[VB6] Simple Checksumming Method

[Joe]

I just whipped this up real quick waiting for a spot in the battle grounds. I may use this in JoeChat to make sure you're using the same version as the other person is, etc. You can use this if you ever write a server for something and want to either require your client to be used or have your client present for checksumming. This is the same as CRev() only a lot less complex. See comments for formula format. Untested (written in gedit, not VB).

Code: [Select]

Public Function Checksum(Formula as String, Files() as String)
  ' Used to create a checksum of multiple files based on a Formula
  ' Formula format: Number, Operation, Operation
  ' Formula example: 1+-
  ' Usage example: Checksum("1+^", Array("C:\File1.exe", "C:\File2.txt")
  Dim Ret as Long, I as Integer, I2 as Integer
  Ret = Val(Mid(Formula, 1, 1))
  For i = LBound(Files) To UBound(Files)
    Open Files(I) For Binary Access Read As #1
      For I2 = 1 to LOF(#1)
        sTemp = Space(1)
        Get #1, I2 + 1, sTemp
        If I2 Mod 2 = 0 Then
          Ret = Val(CStr(Ret) & Mid(Formula, 2, 1) & CStr(Asc(sTemp)))
        Else
          Ret = Val(CStr(Ret) & Mid(Formula, 3, 1) & CStr(Asc(sTemp)))
        End If
      Close #1
    Next i2
  Next i
  Checksum = Ret
End Function

[Joe]

Formula Generatior! Again, untested.

Code: [Select]

Public Function MakeForumla() As String
  Operations = "+_^/*"
  Numbers = "123456789"  'Zero is just a mess
  Randomize
  MakeFormula = Mid(Numbers, Int(Rnd * Len(Numbers)) + 1) & Mid(Operations, Int(Rnd * Len(Operations)) + 1) & Mid(Operations, Int(Rnd * Len(Operations)) + 1)
End Function 

[rabbit]

LOF() isn't a number.  You can't use EOF either.  Your random shit sucks.  You need to actually test it and also make sure it works before you release it.

[iago]

Why don't you use CRC32?  That's exactly what it's designed for.  It's generally better to use a tried and tested standard than making your own and guessing at how it can be done. 

[Joe]

You need to actually test it and also make sure it works before you release it.

I don't test code I don't plan to use. This is just suggestive coding, that I do when I'm bored waiting in lines for the battlegrounds to open up in World of Warcraft. I do this in gedit on cave, which is a Linux box, a PowerPC Linux box. VB6 has no way of existing here thanks to that, and thus it will go untested. Anyone needing to checksum a file can fix it themselves, or when I get the time (JoeMomma is always busy) I'll fix it myself.

Why don't you use CRC32?  That's exactly what it's designed for.  It's generally better to use a tried and tested standard than making your own and guessing at how it can be done.

I thought about that. On the toilet actually. I remember you once saying that VB6 sucks because it cannot handle overflows and that most hashing requires it. I thought this would be no exception. CRC32 never came to mind, but hashing itself did.

[Blaze]

Code: [Select]

Private Const CRC32_POLYNOMIAL As Long = &HEDB88320
Private CRC32Table(0 To 255) As Long

Private Sub InitCRC32()
    Dim I As Long, J As Long, K As Long, XorVal As Long
   
    Static CRC32Initialized As Boolean
    If CRC32Initialized Then Exit Sub
    CRC32Initialized = True
   
    For I = 0 To 255
        K = I
       
        For J = 1 To 8
            If K And 1 Then XorVal = CRC32_POLYNOMIAL Else XorVal = 0
            If K < 0 Then K = ((K And &H7FFFFFFF) \ 2) Or &H40000000 Else K = K \ 2
            K = K Xor XorVal
        Next
       
        CRC32Table(I) = K
    Next
End Sub

Private Function CRC32(ByVal Data As String) As Long
    Dim I As Long, J As Long
   
    Call InitCRC32
   
    CRC32 = &HFFFFFFFF
   
    For I = 1 To Len(Data)
        J = CByte(Asc(Mid(Data, I, 1))) Xor (CRC32 And &HFF&)
        If CRC32 < 0 Then CRC32 = ((CRC32 And &H7FFFFFFF) \ &H100&) Or &H800000 Else CRC32 = CRC32 \ &H100&
        CRC32 = CRC32 Xor CRC32Table(J)
    Next
   
    CRC32 = Not CRC32
End Function


[rabbit]

You need to actually test it and also make sure it works before you release it.

I don't test code I don't plan to use. This is just suggestive coding, that I do when I'm bored waiting in lines for the battlegrounds to open up in World of Warcraft. I do this in gedit on cave, which is a Linux box, a PowerPC Linux box. VB6 has no way of existing here thanks to that, and thus it will go untested. Anyone needing to checksum a file can fix it themselves, or when I get the time (JoeMomma is always busy) I'll fix it myself.

Why don't you use CRC32?  That's exactly what it's designed for.  It's generally better to use a tried and tested standard than making your own and guessing at how it can be done.

I thought about that. On the toilet actually. I remember you once saying that VB6 sucks because it cannot handle overflows and that most hashing requires it. I thought this would be no exception. CRC32 never came to mind, but hashing itself did.

VB6 can't handle overloads, there is a difference.  Nothing can handle overflows, that's why they are errors.

overflow:

Code: [Select]

int k = 7829430237407092346273;

Code: [Select]

Const k As Integer = 7829430237407092346273
overload:

Code: [Select]

int blah();
bool blah();
char blah();
void *blah();
int blah(int MOO);
// etc...

Code: [Select]

' OMG WTF?!

[trust]

LOF() isn't a number.  You can't use EOF either.  Your random shit sucks.  You need to actually test it and also make sure it works before you release it.

pssh *remembers rabbits packet buffer in sb.net code bank* =P

[rabbit]

At least mine RAN before getting an error and exploding.

[iago]

You need to actually test it and also make sure it works before you release it.

I don't test code I don't plan to use. This is just suggestive coding, that I do when I'm bored waiting in lines for the battlegrounds to open up in World of Warcraft. I do this in gedit on cave, which is a Linux box, a PowerPC Linux box. VB6 has no way of existing here thanks to that, and thus it will go untested. Anyone needing to checksum a file can fix it themselves, or when I get the time (JoeMomma is always busy) I'll fix it myself.

Why don't you use CRC32?  That's exactly what it's designed for.  It's generally better to use a tried and tested standard than making your own and guessing at how it can be done.

I thought about that. On the toilet actually. I remember you once saying that VB6 sucks because it cannot handle overflows and that most hashing requires it. I thought this would be no exception. CRC32 never came to mind, but hashing itself did.

VB6 can't handle overloads, there is a difference.  Nothing can handle overflows, that's why they are errors.

overflow:

Code: [Select]

int k = 7829430237407092346273;

Code: [Select]

Const k As Integer = 7829430237407092346273
overload:

Code: [Select]

int blah();
bool blah();
char blah();
void *blah();
int blah(int MOO);
// etc...

Code: [Select]

' OMG WTF?!

You obviously don't know what you're talking about :-P

All languages that I know of (except for VB and BASIC) can handle overflows without an error.  If you reach  (unsigned int32)0xFFFFFFFF, and add one, you'll end up at (unsigned int32)0x00000000.  That's not an error, it's an expected result.  It's used for tons of things such as encryption and hashing. 

Overloading is completly different.  As far as I know, overloading is done in Java, Smalltalk and C++.  It's probably also done in other languages that I don't know, but I don't know them.

[MyndFyre]

VB6 can't handle overloads, there is a difference.  Nothing can handle overflows, that's why they are errors.

WTF are you talking about?  Overflows are determined by whether or not a flag was set in the flags register of a CPU (based on Intel architecture).  You can choose whether or not to ignore it in your code.  Ignore it and you won't have an error.

See what iago said.

[Warrior]

It seems worthy enough of an error, nonetheless. I mean if you overflow you can overwrite memory, no?

[iago]

It seems worthy enough of an error, nonetheless. I mean if you overflow you can overwrite memory, no?

No.  I'll follow up in a bit, I'm busy right now

[Tuberload]

It seems worthy enough of an error, nonetheless. I mean if you overflow you can overwrite memory, no?

No.  I'll follow up in a bit, I'm busy right now

Aren't overflows a big bug in software used to run arbitrary code and such?

[Joe]

Overflows are where you try to put too much stuff in a small place, thus it overflows.

Example:
You have a long int, and try to put 0xFFFFFFFFF in it, but the max is 0xFFFFFFFF, you will get an overflow.
You have a gallon jug and try to pour two gallons of soda in it, you will get an overflow.

[iago]

It seems worthy enough of an error, nonetheless. I mean if you overflow you can overwrite memory, no?

No.  I'll follow up in a bit, I'm busy right now

Aren't overflows a big bug in software used to run arbitrary code and such?

All right, sorry about that.

Anyways, there are different types of overflows.  In the sense we're talking about, it is an integer overflow.  That is when you add one to the maximum number and end up with 0.  The only type of vulnerability that that can lead to is a heap overflow, which is how Microsoft's JPEG decoder vulnerability came about.  More on that later.

The type of overflow that you're thinking of is an array overflow.  That is, when the programmer declares an array on the stack and then tries to add data to it that goes past the end of the array, it overwrites other data on the stack.  And if you control a program's stack, it's game over.

Now, back to the integer overflow.  This is something that people are never really taught, but that is very, very important.  Here is some innocent looking C code:

Code: [Select]

int size = data[0]; // The first byte is the size, not including headers
unsigned char *buffer = malloc(size + 10); // allocate 10 extra bytes, to include the header
memcpy(buffer, data, 10); // copy the header
memcpy(buffer + 10, data + 10, size); // copy the rest of the data

That looks innocent enough.  But what if the user sends a size of 0xFFFFFFF6?  it will allocate size+10, or 0x00000000 bytes (due to the overflow).  Then it will go ahead and copy the data into the buffer.  Well, we only allocated 0 bytes, so we're overwriteing other data on the heap now.  This is a head overflow, and doesn't always lead to full control of the process but often it's game over.

[Warrior]

...and what happens to the location in memory if you overflowed the variable...

I'd think the CPU would generate an exception before the memory was written to, no?

[MyndFyre]

I'd think the CPU would generate an exception before the memory was written to, no?

Only if you tried to overwrite from a page of unprotected memory to a page of protected memory, AFAIK.

[iago]

I'd think the CPU would generate an exception before the memory was written to, no?

Only if you tried to overwrite from a page of unprotected memory to a page of protected memory, AFAIK.

Yeah, you only get an exception if you overwrite memory that you aren't allowed to.