How to reverse this algorithm to get back the original text?

Question

Can anyone please explain with the easy coding how to reverse this algorithm so that I get back the original text string?

Public Function CreateIntChecksum(ByVal s As String) As Integer
    Dim r As Integer = 0
    For i As Integer = 0 To (s.Length() - 1)
        Dim bchar As Byte = Convert.ToByte(s(i))
        r = bchar + ((r << 5) - r)
    Next
    Return r
End Function

Answer 1

Although it is impossible to find the original text, it is possible find a preimage easily. The crucial point is

r = bchar + ((r << 5) - r)

which is equivalent to

r = bchar + r*31

Therefore, the hash encodes the string in base-31. To find a preimage, just rewrite the integer in base 31.

For instance, if the result is 3456, we know 3456 = 3 × 31² + 18 × 31 + 15, so one possible original text is "\x03\x12\x0f". Of course, we could rearrange the numbers to give 110 × 31 + 46 ("n.") or 109 × 31 + 77 ("mM") etc, which shows there is no unique preimage.

Answer 2

how to reverse this algorithm so that I get back the original text string?

You can't, by design.
This is a (simple) checksum or hashing function.

Take a look at the size of the information going in and out: the function transforms a string s of arbitrary length into a 32-bit Integer. For each integer value there will be many input strings that will yield that result.

---

Edit: Apparently you want a shuffling algorithm. Maybe take a look at ROT13. Be advised this is not a (very) safe form of encryption.

Answer 3

You can't. What you have here is a Checksum, which is a basic hashing function. The the whole point of a hashing function is that it is irreversible. Hashing functions map a set of inputs (usually infinite) to a smaller set of outputs - so multiple inputs can end up with the same output, and thus this makes reversing a hash impossible (assuming the hash is correctly done). This is why they are used to store passwords - there is no way to read a hash and go "Oh, that is password XYZ".

One way of trying to find out the original value is to use a Rainbow Table. This is merely a massive table of inputs and their equivalent hashed (or in this case checksummed) values. If you have the hashed value of your unknown string you can search for it in the table and get the set of possible inputs. This is not a way to reverse a hash function, which is impossible; it is merely a brute force guessing method. Note also that in this case (assuming the hashing function is not biased) there are an infinite number of strings that match each checksummed value, as a visual basic string can be of arbitrary length. This would make a rainbow table for this very impractical - you could cover the set of probably inputs for a hashing (as most normal users won't enter more than a 10 character code), but nothing stops the user using a 67 character code, or 109, or...

Read the wikipedia articles for Hash Functions, Checksums and Rainbow Tables.

Answer 4

You simply can't reverse it. It's a checksum which is not reversible.

Answer 5

You can't. If nothing else, then simply because Integer contains only 32 bits of data and String can have any length.

Answer 6

First of all the code as posted will throw an exception for anything but the shortest of strings.

The following code includes the OP's original code, plus a simple checksum, and a guess at how the checksum might be used.

Private Sub Button2_Click(ByVal sender As System.Object, _
                          ByVal e As System.EventArgs) Handles Button2.Click

    Dim buffer() As Byte

    Dim tstString As String = "Calculate a checksum for a given string"

    Dim chkSumFix As Integer = CreateIntChecksumFixed(tstString) 'get a checksum

    buffer = SendPacket(tstString, chkSumFix) 'create a byte buffer to send
    tstString = decodePacket(buffer)

    'do the same using the OP's original code
    Dim chkSum As Integer = CreateIntChecksum(tstString) 'error

    buffer = SendPacket(tstString, chkSum)
End Sub

'OP
Public Function CreateIntChecksum(ByVal s As String) As Integer
    Dim r As Integer = 0
    For i As Integer = 0 To (s.Length() - 1)
        Dim bchar As Byte = Convert.ToByte(s(i))
        r = bchar + ((r << 5) - r)
    Next
    Return r
End Function

'a very simple checksum
Public Function CreateIntChecksumFixed(ByVal s As String) As Integer
    Dim r As Integer = 0
    For i As Integer = 0 To (s.Length() - 1)
        Dim bchar As Byte = Convert.ToByte(s(i))
        r = (r And &HFFFF) + bchar
    Next
    Return r
End Function

Private Function SendPacket(ByVal aString As String, _
                            ByVal aChecksum As Integer) As Byte()
    'construct a packet to be sent
    'Packet format
    'returns a byte buffer
    'byte(0 -3) = length of original string - use BitConverter.ToInt32 to extract
    'byte(4-n) = original string.  n = (4 + string length) - 1
    'byte(n + 1, n + 2, n + 3, n + 4) = checksum

    Dim length As Integer
    Dim retV As New List(Of Byte)
    retV.AddRange(System.Text.Encoding.ASCII.GetBytes(aString)) 'add string to packet
    length = retV.Count 'get length - use this length in case a different encoding is used
    retV.AddRange(BitConverter.GetBytes(aChecksum)) 'add checksum
    retV.InsertRange(0, BitConverter.GetBytes(length)) 'insert length at start of packet

    Return retV.ToArray
End Function

Private Function decodePacket(ByVal buffer As Byte()) As String
    Dim sLen As Integer = BitConverter.ToInt32(buffer, 0)
    If sLen + 8 <> buffer.Length Then Throw New ArgumentOutOfRangeException

    Dim s As String = System.Text.Encoding.ASCII.GetChars(buffer, 4, sLen)

    Dim chksum As Integer = CreateIntChecksumFixed(s)

    Dim embeddedChecksum As Integer = BitConverter.ToInt32(buffer, sLen + 4)

    If chksum <> embeddedChecksum Then Throw New ArgumentException("Invalid checksum")
    Return s
End Function