asm inline vs 2015 with call RegCreateKeyEx - c++

Question

I tried to test the RegCreateKeyEx call using asm inline.
This is the code :
long regkey(HKEY lnKey, LPCTSTR lpsub, DWORD rise, LPTSTR lpc, DWORD dwopt, REGSAM sd, LPSECURITY_ATTRIBUTES lpas, HKEY * const &llkey, DWORD * const &dwDisposition)
{
__asm
{
lea eax, dwDisposition
push eax // put eax at the top of the stack
lea eax, llkey
push eax
lea eax, lpas
push eax
lea eax, sd
push eax
lea eax, dwopt
push eax
lea eax, lpc
push eax
lea eax, rise
push eax
lea eax, lpsub
push eax
lea eax, lnKey
push eax
call DWORD ptr RegCreateKeyEx
}
return;
}
int main()
{
HKEY lnKey;
LPCTSTR lpsub;
DWORD rise;
LPTSTR lpc;
DWORD dwopt;
REGSAM sd;
LPSECURITY_ATTRIBUTES lpas;
HKEY llkey;
DWORD dwDisposition;
long ret0 = regkey(HKEY_CURRENT_USER, TEXT(linkey.c_str()), 0, NULL, 0, KEY_WRITE, NULL, &llkey, &dwDisposition);
printf("CREATE %d\n", ret0);
return 0;
}
However, it returns error 87 (INVALID ARGUMENT).
The linkey.c_str () variable contains the string "Software\\Microsoft\\Windows\\CurrentVersion\\Run\\" path and passes it correctly because I tried to use it directly by calling directly the RegCreateKeyEx (HKEY_CURRENT_USER,
TEXT (linkey.c_str ()),
0, NULL, 0,
KEY_WRITE, NULL,
& Llkey, & dwDisposition) ad it's all OK
Where am I wrong in use asm inline?

Answer 1

If you wrote the code in C++, like so:
LONG regkey(HKEY lnKey, LPCTSTR lpsub, DWORD rise, LPTSTR lpc, DWORD dwopt, REGSAM sd, LPSECURITY_ATTRIBUTES lpas, HKEY * const &llkey, DWORD * const &dwDisposition)
{
return RegCreateKeyEx(lnKey, lpsub, rise, lpc, dwopt, sd, lpas, llkey, dwDisposition);
}
then you could compile it using the /FA switch, as advised in the comments, to get the compiler to generate an assembly listing of the code it would generate. Alternatively, you could compile it and then break in, using the debugger to show the disassembly of the actual binary. Either way, you'd see the following assembly code being generated by the compiler:
mov eax, DWORD PTR [esp+36] ; dwDisposition
push DWORD PTR [eax]
mov eax, DWORD PTR [esp+36] ; llkey
push DWORD PTR [eax]
push DWORD PTR [esp+36] ; lpas
push DWORD PTR [esp+36] ; sd
push DWORD PTR [esp+36] ; dwopt
push DWORD PTR [esp+36] ; lpc
push DWORD PTR [esp+36] ; rise
push DWORD PTR [esp+36] ; lpsub
push DWORD PTR [esp+36] ; lnKey
call DWORD PTR RegCreateKeyEx
ret 0
So, the inline assembly should be:
LONG regkey(HKEY lnKey, LPCTSTR lpsub, DWORD rise, LPTSTR lpc, DWORD dwopt, REGSAM sd, LPSECURITY_ATTRIBUTES lpas, HKEY * const &llkey, DWORD * const &dwDisposition)
{
__asm
{
mov eax, DWORD PTR [dwDisposition]
push DWORD PTR [eax]
mov eax, DWORD PTR [llkey]
push DWORD PTR [eax]
push DWORD PTR [lpas];
push DWORD PTR [sd];
push DWORD PTR [dwopt];
push DWORD PTR [lpc];
push DWORD PTR [rise];
push DWORD PTR [lpsub]
push DWORD PTR [lnKey]
call DWORD PTR RegCreateKeyEx
} // return value is left in EAX
}
which is pretty darn easy. You don't need to worry about calculating offsets from the stack pointer, because the inline assembler supports the use of C++ variables. There is never a need for a LEA instruction. In fact, the LEA instruction is wrong, because it causes you to pass pointers as parameters to the RegCreateKeyEx function, instead of the values themselves, which is why you were getting error code 87, "Invalid parameter".
The only complicated thing is the way the dwDisposition and llkey parameters are handled. First, the address has to be loaded into a register (EAX), and then that address is dereferenced as it is pushed onto the stack. This additional level of indirection is necessary because you passed these parameters as references to pointers. I have no idea why you've chosen to do that, but because you did, the reference has to be dereferenced. (Under the hood, a C++ compiler implements references like pointers.)
However, I have no idea why you would actually write this code in inline assembly. There is absolutely no reason to do so; it isn't buying you anything, it's just making things more complicated to write and maintain. It's also costing you something in performance. Above, I showed what a C++ compiler would generate for the function call. Here is what the compiler generates when you use inline assembly:
push ebp
mov ebp, esp
mov eax, DWORD PTR _dwDisposition$[ebp]
push DWORD PTR [eax]
mov eax, DWORD PTR _llkey$[ebp]
push DWORD PTR [eax]
push DWORD PTR _lpas$[ebp]
push DWORD PTR _sd$[ebp]
push DWORD PTR _dwopt$[ebp]
push DWORD PTR _lpc$[ebp]
push DWORD PTR _rise$[ebp]
push DWORD PTR _lpsub$[ebp]
push DWORD PTR _lnKey$[ebp]
call DWORD PTR RegCreateKey
pop ebp
ret 0
Notice the extra prologue and epilogue instructions that are made necessary by the use of inline assembly, since the compiler has no idea what you are actually doing inside of the inline assembly and therefore has to compensate for it by setting up and tearing down a stack frame. It isn't a massive performance cost or anything, but again, it's completely pointless.
Your follow-up question/problem (from a comment and an answer you posted) makes no sense to me. You shouldn't need any sort of exception handler, and since you didn't quote the exact error message you're getting, I have no idea what it might be trying to say. It is likely that the problem relates to strtemp, whose declaration you don't show us. Since you said you are calling the ANSI version of RegCreateKeyEx, strtemp should be a pointer to a char buffer, terminated with a NUL character. Also, the next parameter you are passing to RegSetValueEx is wrong: cbData must include the terminating NUL character, so this should properly be strlen(strtemp) + 1.
Other problems with your code include the fact that there is absolutely no error checking. If the attempt to create the registry key fails, then you should not attempt to write into it, nor should you attempt to close it.
Also, there is never a reason in the year 2017 to call the ANSI version of a Windows API function. Everything has been Unicode internally for almost two decades, and your code needs to get with the program. This means using strings consisting of wchar_t characters.