Assembly encryption decryption program - c++

Question

The following program compiles and works.
However I cannot figure out what to write for the decryption section.
Can anybody please help me write the corresponding decrypt_chars() routine?
void encrypt_chars(int length, char EKey)
{
char temp_char; // char temporary store
for (int i = 0; i < length; i++) // encrypt characters one at a time
{
temp_char = OChars[i];
__asm {
push eax // save register values on stack to be safe
push ecx //
movzx ecx, temp_char //
lea eax, EKey
call encrypt // encrypt the character
mov temp_char, al
pop ecx // restore original register values from stack
pop eax //
}
EChars[i] = temp_char; // Store encrypted char in the encrypted chars array
}
return;
// --- Start of Assembly code
__asm {
// Inputs: register EAX = 32-bit address of Ekey,
//ECX = the character to be encrypted (in the low 8-bit field, CL).
// Output: register EAX = the encrypted value of the source character (in the low 8-bit field, AL).
encrypt5: push eax
mov al, byte ptr[eax]
push ecx
and eax, 0x7C
ror eax, 1
ror eax, 1
inc eax
mov edx, eax
pop ecx
pop eax
mov byte ptr[eax], dl
xor edx, ecx
mov eax, edx
rol al, 1
ret
encrypt:
mov eax, ecx // get character
inc eax
ret
}
//--- End of Assembly code
}
// end of encrypt_chars function
void decrypt_chars(int length, char EKey)
{
/* needs to be written */
return;
}

Answer 1

As it stands right now, it appears that decryption is almost ridiculously trivial. Although the encrypt5 code attempts to do something rather more elaborate, all that seems to actually be used here is the encrypt routine, which simply increments each input (ignoring the key completely), so A becomes B, B becomes C, and so on.
As such, the decryption routine can be equally trivial:
void decrypt(char *data, int length) {
for (int i=0; i<length; i++)
--data[i];
}
If you really insist on doing this in assembly language, the core would look something like this:
_asm {
mov eax, ecx
dec eax
ret
}
Then you'd do like with the encryption, and invoke that once for each character in the input string.
When/if the encryption is fixed to do something more than just incrementing each input character, the decryption will need to be updated to match. Of course, as it stands right now this encryption doesn't deserve the name "encryption" at all--since it has no key, it offers precisely zero security.