Last update: Thu Sep 17 18:12:30 2009

RSP Checksum DLL 0.0.1

(Thu Sep 17 18:12:30 2009)

Win32 DLL to compute very fast the checksum of strings or files using RSP32 , Adler32 , CRC32 , MD5 ,  MD5_32 , SHA-1 and SHA-256

What is new - Small update, added executables to register and unregister the ocx

What is new - Bug fix release , now it handle correctly large files

What is new - Added support to long files ( above 2 gb )

What is new - Recompilation and fixes in the sample project and update of the information available in the control

Generation of a new checksum to replace Adler32 (19/Apr/2004 09:15) After studying the Adler32 problem , we generated a modification on the original Adler32 code in order to solve the security problem , the result is a checksum as fast as Adler32 but as strong as CRC32 and MD5 32 , this new checksum is part now of the CheckSum OCX 2.6.0

What is new - Added a new replacement to Adler32 , the RSP32 is as fast as Adler32 but with several more levels of security , it can be used to replace also CRC32 , notice that this checksum can be modified in future releases , we are yet researching in order to generate a more robust checksum code

What is new - Added a 32 bit version of MD5 to be a replacement to Adler32 and possible CRC32 also , since it can provide more security , the major problem is Adler32 that is just too insecure to be used to check strings or files

Security problem regarding the Adler32 checksum (17/Apr/2004 21:14) During the development of the Parallel Port Connection OCX we had the opportunity to stuck with the Adler32 checksum for a while and check the return code for small strings , and it was a great surprise after checking that it is very easy to confuse this checksum and generate the same checksum code for small strings that have just a change in the sequence of the string , this mean that Adler32 cannot be used to insure the integrity of strings , so , it cannot be used also to insure the integrity of files from my point of view

Just play around with a sequence of strings like this "cab" and "bca" and other small strings that have only a change in the sequence of the data and quickly you will perceive the flaw

I really apologize for the delay to find this limitation of the Adler32 checksum , notice that CRC32 don't provide a huge integrity verification also but it does not have this kind of flaw

What is new - Added new multithread function to generate checksums of files , modified the internal execution to avoid possible bugs , added pause , resume and cancel functions , added progress position , minor bugs fixed

Description

RSP32 description

The code is based on a sum of the input bytes in sequence , in order to generate a 32 bit value

It is a direct descendant of Adler32 , but without the security problem

This checksum can be used to replace Adler32 , CRC32 or MD5 32

It is as fast as Adler32 but with several more levels of security

Implementation in C

SHA-1 description

Secure Hash Standard.

This Standard specifies a secure hash algorithm, SHA-1, for computing a condensed representation of a message or a data file. When a message of any length < 2^64 bits is input, the SHA-1 produces a 160-bit output called a message digest.

The SHA-1 is called secure because it is computationally infeasible to find a message which corresponds to a given message digest, or to find two different messages which produce the same message digest.
Any change to a message in transit will, with very high probability, result in a different message digest, and the signature will fail to verify.
SHA-1 is a technical revision of SHA (FIPS 180).

The SHA-1 is based on principles similar to those used by Professor Ronald L. Rivest of MIT when designing the MD4 message digest algorithm, and is closely modelled after that algorithm.

The MD5 Message-Digest Algorithm

The algorithm takes as input a message of arbitrary length and produces as output a 128-bit "fingerprint" or "message digest" of the input.
It is conjectured that it is computationally infeasible to produce two messages having the same message digest, or to produce any message having a given prespecified target message digest.
The MD5 algorithm is intended for digital signature applications, where a large file must be "compressed" in a secure manner before being encrypted with a private (secret) key under a public-key cryptosystem such as RSA.
The MD5 algorithm is designed to be quite fast on 32-bit machines.
In addition, the MD5 algorithm does not require any large substitution tables; the algorithm can be coded quite compactly.
The MD5 algorithm is an extension of the MD4 message-digest algorithm .
MD5 is slightly slower than MD4, but is more "conservative" in design.
MD5 was designed because it was felt that MD4 was perhaps being adopted for use more quickly than justified by the existing critical review; because MD4 was designed to be exceptionally fast, it is "at the edge" in terms of risking successful cryptanalytic attack.
MD5 backs off a bit, giving up a little in speed for a much greater likelihood of ultimate security.
It incorporates some suggestions made by various reviewers, and contains additional optimizations.
The MD5 algorithm is being placed in the public domain for review and possible adoption as a standard.

The MD5_32 Algorithm

The MD5_32 is the same MD5 implementation , but it will return only the first four bytes of the checksum , it was modified to be a direct replacement to Adler32 or CRC32

This modified MD5 version can provide better security and the speed execution is the same as MD5

SHA-256 description

The SHA-256 compression function operates on a 512-bit message block and a 256-
bit intermediate hash value.
It is essentially a 256-bit block cipher algorithm which encrypts the intermediate hash value using the message block as key.

CRC32 description

Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
  x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.

Polynomials over GF(2) are represented in binary, one bit per coefficient,  with the lowest powers in the most significant bit. 
Then adding polynomials is just exclusive-or, and multiplying a polynomial by x is a right shift by one. 
If we call the above polynomial p, and represent a byte as the polynomial q, also with the lowest power in the most significant bit (so the byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, where a mod b means the remainder after dividing a by b.

This calculation is done using the shift-register method of multiplying and taking the remainder.  The register is initialized to zero, and for each incoming bit, x^32 is added mod p to the register if the bit is a one (where x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by x (which is shifting right by one and adding x^32 mod p if the bit shifted out is a one). 
We start with the highest power (least significant bit) of q and repeat for all eight bits of q.

The table is simply the CRC of all possible eight bit values. 
This is all the information needed to generate CRC's on data a byte at a time for all
  combinations of CRC register values and incoming bytes.
 
(This description come from the sources of Zlib compression )

Adler32 description

Security problem regarding the Adler32 checksum (17/Apr/2004 21:14) During the development of the Parallel Port Connection OCX we had the opportunity to stuck with the Adler32 checksum for a while and check the return code for small strings , and it was a great surprise after checking that it is very easy to confuse this checksum and generate the same checksum code for small strings that have just a change in the sequence of the string , this mean that Adler32 cannot be used to insure the integrity of strings , so , it cannot be used also to insure the integrity of files from my point of view

Just play around with a sequence of strings like this "cab" and "bca" and other small strings that have only a change in the sequence of the data and quickly you will perceive the flaw

I really apologize for the delay to find this limitation of the Adler32 checksum , notice that CRC32 don't provide a huge integrity verification also but it does not have this kind of flaw

Adler32 is a very fast ( and flawed ) checksum based on the sum of the high word with the low word of a dword value in a sequence of input bytes

The dword is sliced in two words and the sum is calculated and mod against 65521 , the result value is added to a dword value that is the return value of the computation

This is the fastest checksum available to win32 , but don't provide a huge level of security , RSP32 and CRC32 can provide a lot better data  integrity support

Features

- Ability to generate the checksum using Adler32, CRC32 , MD5 , SHA-1 and SHA-256

- The process occurs in an in-process code loaded in the same address space of the application using the control

- The speed execution is lightning fast

- The control can pause , resume and cancel the execution

- The control can execute in single-thread or multi-thread environment

- The code is optimized for new AMD and Intel processors ,  check the speed execution against other implementations of these algorithms

Install

Install

- Extract the files and open the c# project

UnInstall

- Delete the files

Windows 95 , Windows 98 , Windows NT 4.0 , Windows 2000 , Windows XP, Windows Vista, Windows 7

Documentation

Download

Register

This dll is available to register at PayPal

This dll is available to register at Shareit!

Click in the link below to register

After the registration the licensed version will be emailed to you , thanks for considering the registration