Tiny Encryption Algorithm implementation produces unexpected results - c++

Question

Here is an implementation of TEA, that attempts to encrypt a file containing a text message:
main.cpp
#include <iostream>
#include <iomanip>
#include <string>
#include <fstream>
#include "TEA.h"
int main()
try
{
// std::cout <<"sizeof(long) = " << sizeof(long) <<'\n';
std::string src("in.txt");
std::string dest("out.txt");
std::string key("bs");
send_msg(src, dest, key);
}
catch(std::exception& e)
{
std::cerr << e.what();
exit(1);
}
TEA.h
#ifndef TEA_h
#define TEA_h
/*
src - eight (2 words or 2*4 bytes) characters to be enciphered.
dest- enciphered output.
key - array of 4 words.
Assumes sizeof(long) == 4 bytes.
*/
void encipher(const unsigned long* const v,
unsigned long* const w,
const unsigned long* const k)
{
unsigned long y = v[0];
unsigned long z = v[1];
unsigned long sum = 0;
unsigned long delta = 0x9E3779B9;
unsigned long n = 32;
while (n-- > 0)
{
y += (z<<4 ^ z>>5) + z^sum + k[sum&3];
sum += delta;
z += (z<<4 ^ z>>5) + y^sum + k[sum>>11&3];
}
w[0] = y;
w[1] = z;
}
//---------------------------------------------------------------------------
/*
Sends the clear text from: src_file as
encrypted text to: dest_file, using TEA
with key: the last argument.
*/
void send_msg(std::string& src_file,
std::string& dest_file,
std::string key)
{
const int nchar = 2 * sizeof(long); // size of I/O chunk: 8 bytes = 64 bits
const int kchar = 2 * nchar; // size of key: 16 bytes = 128 bits
// pad key with 0's to match en-/de- cipher argument input size
while (key.size() < kchar)
{
key += '0';
}
// prepare files
std::ifstream ifs(src_file.c_str());
std::ofstream ofs(dest_file.c_str());
if (!ifs || !ofs)
{
throw std::runtime_error("File can't open!\n");
}
// key: extract raw string data interpreted as pointer to const unsigned long
const unsigned long* k = reinterpret_cast<const unsigned long*>(key.data());
// define C-compatible way to read & write from / to file 128 bits (two unsigned longs) at a time
unsigned long outptr[2];
char inbuf[nchar];
unsigned long* inptr = reinterpret_cast<unsigned long*>(inbuf);
int count = 0;
while (ifs.get(inbuf[count]))
{
ofs << std::hex; // write output in hex
if (++count == nchar) // 8 characters in the input buffer: ready to encode
{
encipher(inptr, outptr, k);
// pad with leading 0's
ofs << std::setw(8) << std::setfill('0') << outptr[0] <<' '
<< std::setw(8) << std::setfill('0') << outptr[1] <<' ';
count = 0;
}
}
if (count) // pad at the end
{
while (count != nchar)
{
inbuf[count++] = '0';
}
encipher(inptr, outptr, k);
ofs << outptr[0] <<' '<< outptr[1] <<' ';
}
}
#endif
Input file, in.txt:
The Tiny
Expected in Output file:
5b8fb57c 806fbcce
Actual in Output file, out.txt:
f3a810ff 3874d755
What am I doing wrong?

Answer 1

The + operation has a higher precedence than ^, so (z<<4 ^ z>>5) + z^sum + k[sum&3] is parsed as
(((z<<4) ^ (z>>5)) + z)^(sum + k[sum&3]).
Similarly for the other expression.
You should add parenthesis to make your expression explicit in how it executes.

Answer 2

The problem was indeed related to those expressions (pointed out by #1201ProgramAlarm), however, it is not related to the (wrong) implicit operator precedence (nor arity).
y += (z<<4 ^ z>>5) + z^sum + k[sum&3];
sum += delta;
z += (z<<4 ^ z>>5) + y^sum + k[sum>>11&3]; // <------ the problem is here
the left and right bit shift operations have to be applied on variable y, i.e.:
z += (y<<4 ^ y>>5) + y^sum + k[sum>>11&3];