Creating Encrypt/Decrypt Functions using Peter Weinberger's Hash algorithm - c++

Question

Is it possible to decrypt Peter Weinberger's Hash algorithm?
I am attempting to write my own Encrypt Decrypt functions. I understand the concept that a Hash value means you can not or are not supposed to decrypt the hash value but I am thinking that because the algorithm is relatively simple that it maybe possible in this case to decrypt this sort of hash. I've done the simple Encrypt Decrypt that uses simple rotation and now I want to try something more difficult.
So is it possible to decrypt a hash value produced from Peter Weinberger's Hash algorithm?
The following encrypt function is Peter Weinberger's exact Hash algorithm, the decrypt is my own attempt which is not working:
int encrypt(char *s)
{
/* Peter Weinberger's */
char *p;
unsigned int h, g;
h = 0;
for(p=s; *p!='\0'; p++){
h = (h<<4) + *p; printf("Step : ");
if (g = h&0xF0000000) {
h ^= g>>24;
h ^= g;
}
}
return h % 211;
}
std::string decrypt(int v)
{
/* Peter Weinberger's */
unsigned int h, g;
h = 0;
v /= 211;
int s = sqrt(v);
/* Not sure what to do here
for(p=s; *p!='\0'; p++){
}
*/
return string(h);
}

Answer 1

Considering the extremely small output size, a brute-force attack is trivial.
Generate a string(for example randomly)
Hash it
If it matches the known value, you found a first pre-image, else go to step 1
This will take 211 attempts on average to get a string that matches the given hash. It probably won't be the original string, but that's to be expected given the lossy nature of hashing.
For two character inputs this hash becomes (16*s[0]+s[1])%211 which you can rewrite as (16*(s[0]-'A')+(s[1]-'A') + 50)%211
Solving for the string you get:
s[0]=(hash+161)/16+'A';
s[1]=(hash+161)%16+'A';
For example for s == "AB" you get hash==51. Then using above formulas to reverse it:
s[0] = 13 +'A' = 'N'
s[1] = 4 +'A' = 'E'
=> s="NE" which matches the hash 51, but isn't the original string.

Answer 2

If I understand the algorithm correctly, for each character it does:
Multiply the hash by 16 (move it 4 bits to the left)
Add a character of the string
If the result has more than 28 bits, remove the upper 4 bits and XOR them somewhere in the hash.
By limiting the string to size 6 (or 7 if the first byte is less than 16), step 3 will never occur. So all that is left, is a simple shift-and-add.
When the string has 6 characters, the final result is this sum (h = higher 4 bits of a character, l = lower 4 bits):
pos: bits
0: .hl00000
1: ..hl0000
2: ...hl000
3: ....hl00
4: .....hl0
5: ......hl
----------- +
0******* Result is 32 bits with upper 4 bits zero
We see that the bits 24-27 are determined by the high 4 bits of the character at position 0, plus a possible carry from the addition in the lower bits. Bits 20-23 are a sum of the lower bits of char 0 and the higher bits of char 1 (plus possible carry).
If the input characters can have all 255 possible values (with the exception of zero), it is not that hard to create a string that generates the hash.
Look at the highest 4 bits in the hash. This will be the high part of the character at pos 0.
Look at the next 4 bits in the hash. This is the addition of the high part of char 1 and the lower part of char 0.
Pick a value for the highest part. E.g. 'highest part is always zero' or 'highest part is always 0100 (upper case letters)'.
If the bits in the has are less than the value you picked in step 3, borrow some from the previous bits (If those bits were zero, ripply it through to the next bit group).
Now you have the lower part of char 0 and the high part of char 1.
Go back to step 2 for the next 4 bits, until you reach the end of the hash
Check that there are no characters with value 0 in your string.
Code would be a bit more complex as there are all kind of edge cases (e.g. hash 01000000), and is left as an exercise to the reader ;).
Edit: I totally missed the h % 211 operation. Which makes it even easier, as CodesInChaos demonstrates.