C# function pointers

[lanman92]

Okay, so I decided to start injecting my code into WoW. I was wondering if there was a way to set a delegate object's address? For example:

unsafe public void main()
{
delegate void condition(bool value);
condition * con = (condition*)0x1337;
}

Can you do this somehow? This is just how I thought it would be =/

[Apoc]

It's possible to do. Just definitely not the way you're trying.

.NET inherently blocks you from any memory addresses outside of the actual process' own address space. (By 'process' in the .NET world, I'm talking the actual assembly, within the actual AppDomain. Something you don't get by injecting into WoW.)

More importantly; your managed addresses are within a VM, whereas WoW's aren't. Definitely won't work that way!

I suggest you do *a lot* of research on what Marshalling is, and the related information.

If you want to call your managed code (i.e; using a delegate callback) you can do that easily from native->managed code.

        [MarshalAs(UnmanagedType.FunctionPtr)]
        private delegate void Foo();

IntPtr delegatePtr = Marshal.GetFunctionPointerForDelegate(new Foo(MyFunctionCallback));
DllPinvokeCallSomeFunc(delegatePtr);

Pretty self explanatory. You will need to do your code in C++ or C++/CLI to make it work properly unfortunately.

[lanman92]

Wow that's gonna be ugly. I might just P/Invoke it. I'm assuming you can't use pointers to variables in C# as well? Sigh.

[Kekke]

Yes you can, by using the keyword unsafe.

    unsafe public static int Main()
    {
        int j=100;
        int k=100;
        Console.WriteLine("address of j={0} and address of k={1}",(int)&j,(int)&k);		
        Console.WriteLine("j={0} k={1}",j,k);
        int *p;
        p=&j;
        Console.WriteLine("p now points to {0}",(int)p);
        *p=200;
        Console.WriteLine("j={0} k={1}",j,k);
        p=&k;
        Console.WriteLine("p now points to {0}",(int)p);
        *p=300;
        Console.WriteLine("j={0} k={1}",j,k);

        return 0;
    }

[lanman92]

Okay, thanks for the help. I was just thinking that the runtime might use some wierd type of pointers instead of actual pointers. Never know what to expect =/

EDIT: On this topic, would using a string * in C# work for reading a games memory? I doubt this is so, but it's worth asking.

[Apoc]

Yes you can, by using the keyword unsafe.

    unsafe public static int Main()
    {
        int j=100;
        int k=100;
        Console.WriteLine("address of j={0} and address of k={1}",(int)&j,(int)&k);		
        Console.WriteLine("j={0} k={1}",j,k);
        int *p;
        p=&j;
        Console.WriteLine("p now points to {0}",(int)p);
        *p=200;
        Console.WriteLine("j={0} k={1}",j,k);
        p=&k;
        Console.WriteLine("p now points to {0}",(int)p);
        *p=300;
        Console.WriteLine("j={0} k={1}",j,k);

        return 0;
    }

He's not talking about pointers for managed memory.

This is stolen from the mem editing section due to laziness:

typedef void (__thiscall *tInteract) (void);
tInteract oInteract;

void Interact(DWORD baseAddress)
{
	DWORD_PTR unitInteractVMT = *reinterpret_cast<DWORD_PTR*>(*reinterpret_cast<DWORD_PTR*>(baseAddress) + (38 *4));
	oInteract= reinterpret_cast<tInteract>(unitInteractVMT );
	oInteract();
}

He's looking for something similar in C#. Would be nice if you could actually assign a delegate to an unmanaged function, but you can't.

Pseudo code would be like this;

[MarshalAs(UnmanagedType.FunctionPtr)]
delegate void InteractHandler();

public unsafe void Interact()
{
InteractHandler i = (InteractHandler*)<address of func>;
i.Invoke();
}

However; .NET restricts you to only the addresses within your own process. (Even if you host the CLR from within WoW, you can't directly manipulate WoW's memory.)

[lanman92]

So, you're pretty much restricted to P/Invoking things like this? I don't really mind making stubs for each function, but it'll be a little messy.

[Apoc]

I just found out (and was proven wrong; thanks jjaa) that you actually can use delegates as native function pointers. However, there's a hitch!

You need to host the CLR in the app you want the delegates to work for. (WoW for example)

        [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
        public delegate long GetLocalPlayerGuid();

        public long Guid()
        {
            var gg = (GetLocalPlayerGuid) Marshal.GetDelegateForFunctionPointer((IntPtr) 0x7BC8D0, typeof(GetLocalPlayerGuid));
            return gg();
        }

Works only as long as the .NET app is running from within WoW itself.

[lanman92]

Awesome! Can this be done to variables as well?