[lyzerk]

Hello, Im trying convert one project c++ to c#. And i have question about XOR's.

(DWORD*)(m_pPacket + woffset)
                                = *(DWORD*)(m_pPacket + roffset) ^ *(DWORD*)(m_pXOR_ENCODE_BYTES + xoffset);

m_pXOR_ENCODE_BYTES,m_pPacket is char array, But i dont know how to convert it to c#

anyone can help me about that ?


Sorry my english not good, Thanks.

[Skydiver]

XOR's are exactly the same in C# as C++.

I think the problem you are running into is the use of pointers. By default C# doesn't allow the use of pointers unless you use the /unsafe compile option.

[lyzerk]

Can you give me some example on c# (i mean for this code) ?
i know something about unsafe, but what about dword ? should i read int32 from byte array and after XOR it ?

[Skydiver]

DWORD's are just UInt32.

Here's your example. I don't know why you need one since it is just like C++.

UInt32 a = 0x81881911;
UInt32 b = 0x11918818;
UInt32 c = a ^ b;

[JackOfAllTrades]

Guess we'll move this to C#

[lyzerk]

Skydiver, on 07 August 2012 - 03:12 AM, said:

DWORD's are just UInt32.

Here's your example. I don't know why you need one since it is just like C++.

UInt32 a = 0x81881911;
UInt32 b = 0x11918818;
UInt32 c = a ^ b;

No i mean that

//m_pXOR_ENCODE_BYTES  byte array
//m_pPacket byte array
m_pPacket + woffset = m_pPacket + roffset ^ m_pXOR_ENCODE_BYTES + xoffset;

it will work like that ? that plus will work in c# ?

[Curtis Rutland]

Ok, I don't know much about C++ code, but I know that's hideous C# code. You're doing addition and assignment at the same time, and disregarding the result.

This part:

m_pPacket + woffset

is on the left of the equals sign. You're not assigning the result to anything. So, I don't see what the point of that is. This has the same result:

woffset = m_pPacket + roffset ^ m_pXOR_ENCODE_BYTES + xoffset;

Without the pointless and confusing addition.

[Skydiver]

lyzerk, on 07 August 2012 - 04:14 AM, said:

Skydiver, on 07 August 2012 - 03:12 AM, said:

DWORD's are just UInt32.

Here's your example. I don't know why you need one since it is just like C++.

UInt32 a = 0x81881911;
UInt32 b = 0x11918818;
UInt32 c = a ^ b;

No i mean that

//m_pXOR_ENCODE_BYTES  byte array
//m_pPacket byte array
m_pPacket + woffset = m_pPacket + roffset ^ m_pXOR_ENCODE_BYTES + xoffset;

it will work like that ? that plus will work in c# ?

So it's not really help about XOR's that you asking about. You are asking about how to translate into C# the following C++ expressions:

// Expression_1: This maps to 'c'
(DWORD*)(m_pPacket + woffset)

// Expression_2: This maps to 'a'
*(DWORD*)(m_pPacket + roffset)

// Expression_3: This maps to 'b'
*(DWORD*)(m_pXOR_ENCODE_BYTES + xoffset);

I suspect that you are missing a leading '*' on Expression_1, because as there is no place to store the result of Expression_2 ^ Expression_3.

I just wanted to make sure that it's the pointer dereferencing that you need help with, and not XOR's.

If it pointer dereferencing, it would help to know what the types are of m_pPacket, woffset, roffset, m_pXOR_ENCODED_BYTES and xoffset.

And the other useful thing to find out is you are willing to compile with the /unsafe flag.

This post has been edited by Skydiver: 07 August 2012 - 11:20 AM

[Curtis Rutland]

So, if you wouldn't mind educating me a bit in C++, is the original intent to store the result at some address of m_pPacket's address plus woffset's value?

[Momerath]

Using base+offset is common in C/C++ and translates to base[offset] in C/C++/C# (you can use either in C/C++ but have to be careful of what type of pointer base is as that's how it determines how much it should 'skip' (if I remember my C/C++ correctly, it's been a while )

[Curtis Rutland]

So it's pretty much a mechanism for array traversal. I'd say that if they're interested in re-writing this in C#, they should learn the "standard" C# mechanisms and paradigms, rather than compiling as unsafe.

[Skydiver]

Momerath, on 07 August 2012 - 11:45 AM, said:

Using base+offset is common in C/C++ and translates to base[offset] in C/C++/C# (you can use either in C/C++ but have to be careful of what type of pointer base is as that's how it determines how much it should 'skip' (if I remember my C/C++ correctly, it's been a while )

You are correct. That is why I was asking what the type of m_pPacket and m_pXOR_ENCODE_BYTES was.

[lyzerk]

Thanks for answers, i solved my problem with like that in C#;

                                *((uint*)(mPacket + woffset)) 
                                    = *((uint*)mPacket + roffset) ^ *((uint*)xor + xoffset);

But now i have problem with another XOR. i want explain my project. my project is encoding/decoding with c++ but i want to convert it to c#, but i can't get correct checkSum.

C++ :

	while(roffset < nEndValue)
	{
		*(DWORD*)(m_pPacket+woffset)
			= *(DWORD*)(m_pPacket+roffset) ^ *(DWORD*)(m_pXOR_ENCODE_BYTES+xoffset);

		checkSum_4B ^= *(DWORD*)(m_pPacket+woffset);

		woffset += 4;
		roffset += 4;
		xoffset = (xoffset + 4) % SIZE_XOR_ENCODE_BYTES;
	}
	checkSum ^= ( *((char*)&checkSum_4B)
				^ *((char*)&checkSum_4B+1)
				^ *((char*)&checkSum_4B+2)
				^ *((char*)&checkSum_4B+3) );

and i covert it like that;

                            while (roffset < nEndValue)
                            {
                                *((uint*)(mPacket + woffset)) 
                                    = *((uint*)mPacket + roffset) ^ *((uint*)xor + xoffset);
                                checkSum_4B ^= *((uint*)(mPacket + woffset));

                                woffset += 4;
                                roffset += 4;
                                xoffset = (xoffset + 4) % 128;
                            }
                            checkSum ^= (*((byte*)&checkSum_4B)
                                ^ *((byte*)&checkSum_4B + 1)
                                ^ *((byte*)&checkSum_4B + 2)
                                ^ *((byte*)&checkSum_4B + 3));

but checkSum not correct. Anyone can help me ?
Thanks

[Skydiver]

Curtis Rutland, on 07 August 2012 - 11:55 AM, said:

So it's pretty much a mechanism for array traversal. I'd say that if they're interested in re-writing this in C#, they should learn the "standard" C# mechanisms and paradigms, rather than compiling as unsafe.

Yes. Assuming that m_pPacket and m_pXOR_ENCODED_BYTES were pointers to DWORD's then his original code would simply translate to something like:

m_pPacket[woffset] = m_pPacket[roffset] ^ m_pXOR_ENCODED_BYTES[xoffset];

Chances are likely though that m_pPacket is a pointer to BYTE's, and things get a bit more complicated, but doable by simply dividing the indexes (_offset) by 4 and pray to the deity of your choice that you don't have any remainders.

The value manipulations are pretty simple. The thing that is haunting me, though, is how will one make the arrays be at a particular memory location without using pointers and unsafe code. For example, you have the following in C#:

byte [] myByteBuffer = new byte[4096];

Let's say that I have an array of DWORDs:

Uint32 [] myDwords;

but I want myDwords to start at myByteBuffer[23] onwards. How would I force myDwords to be at that same memory address? I think that the answer is that I cannot without using unsafe code.

[Curtis Rutland]

Quote

The thing that is haunting me, though, is how will one make the arrays be at a particular memory location without using pointers and unsafe code.

My question would have to be "why would you want to?" I mean, I could understand severe resource or performance requirements, but in that case, shouldn't it be using C/C++ anyway? Isn't one of the reasons we use C# to abstract that kind of thing away?