nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-10 01:48:00 +00:00
Code Issues Projects Releases Wiki Activity

New CRC32 implementation, from scratch, not copyrighted by somebody else!

Browse Source 
Removed Gary S Brown's name from copyrights. Only Eric Young's DES left :-)

[originally from svn r397]
This commit is contained in:
Simon Tatham 2000-03-08 16:13:32 +00:00
parent 11821d4d27
commit fe500c4d01
4 changed files with 220 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
LICENCE
View File

@ -1,5 +1,5 @@
PuTTY is copyright 1997-1999 Simon Tatham. Portions copyright Gary PuTTY is copyright 1997-1999 Simon Tatham. Portions copyright Eric
S. Brown and Eric Young. Young.
Permission is hereby granted, free of charge, to any person Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation files obtaining a copy of this software and associated documentation files

2
ssh.h
View File

@ -21,7 +21,7 @@ void rsastr_fmt(char *str, struct RSAKey *key);
typedef unsigned int word32; typedef unsigned int word32;
typedef unsigned int uint32; typedef unsigned int uint32;
unsigned long crc32(const unsigned char *s, unsigned int len); unsigned long crc32(const void *s, size_t len);
struct MD5Context { struct MD5Context {
uint32 buf[4]; uint32 buf[4];

320
sshcrc.c
View File

@ -1,111 +1,221 @@
/* ============================================================= */ /*
/* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or */ * CRC32 implementation.
/* code or tables extracted from it, as desired without restriction. */ *
/* */ * The basic concept of a CRC is that you treat your bit-string
/* First, the polynomial itself and its table of feedback terms. The */ * abcdefg... as a ludicrously long polynomial M=a+bx+cx^2+dx^3+...
/* polynomial is */ * over Z[2]. You then take a modulus polynomial P, and compute the
/* 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+X^0 */ * remainder of M on division by P. Thus, an erroneous message N
/* */ * will only have the same CRC if the difference E = M-N is an
/* Note that we take it "backwards" and put the highest-order term in */ * exact multiple of P. (Note that as we are working over Z[2], M-N
/* the lowest-order bit. The X^32 term is "implied"; the LSB is the */ * = N-M = M+N; but that's not very important.)
/* X^31 term, etc. The X^0 term (usually shown as "+1") results in */ *
/* the MSB being 1. */ * What makes the CRC good is choosing P to have good properties:
/* */ *
/* Note that the usual hardware shift register implementation, which */ * - If its first and last terms are both nonzero then it cannot
/* is what we're using (we're merely optimizing it by doing eight-bit */ * be a factor of any single term x^i. Therefore if M and N
/* chunks at a time) shifts bits into the lowest-order term. In our */ * differ by exactly one bit their CRCs will guaranteeably
/* implementation, that means shifting towards the right. Why do we */ * be distinct.
/* do it this way? Because the calculated CRC must be transmitted in */ *
/* order from highest-order term to lowest-order term. UARTs transmit */ * - If it has a prime (irreducible) factor with three terms then
/* characters in order from LSB to MSB. By storing the CRC this way, */ * it cannot divide a polynomial of the form x^i(1+x^j).
/* we hand it to the UART in the order low-byte to high-byte; the UART */ * Therefore if M and N differ by exactly _two_ bits they will
/* sends each low-bit to hight-bit; and the result is transmission bit */ * have different CRCs.
/* by bit from highest- to lowest-order term without requiring any bit */ *
/* shuffling on our part. Reception works similarly. */ * - If it has a factor (x+1) then it cannot divide a polynomial
/* */ * with an odd number of terms. Therefore if M and N differ by
/* The feedback terms table consists of 256, 32-bit entries. Notes: */ * _any odd_ number of bits they will have different CRCs.
/* */ *
/* The table can be generated at runtime if desired; code to do so */ * - If the error term E is of the form x^i*B(x) where B(x) has
/* is shown later. It might not be obvious, but the feedback */ * order less than P (i.e. a short _burst_ of errors) then P
/* terms simply represent the results of eight shift/xor opera- */ * cannot divide E (since no polynomial can divide a shorter
/* tions for all combinations of data and CRC register values. */ * one), so any such error burst will be spotted.
/* */ *
/* The values must be right-shifted by eight bits by the "updcrc" */ * The CRC32 standard polynomial is
/* logic; the shift must be unsigned (bring in zeroes). On some */ * 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+x^0
/* hardware you could probably optimize the shift in assembler by */ *
/* using byte-swap instructions. */ * In fact, we don't compute M mod P; we compute M*x^32 mod P.
/* polynomial $edb88320 */ *
/* */ * The concrete implementation of the CRC is this: we maintain at
/* -------------------------------------------------------------------- */ * all times a 32-bit word which is the current remainder of the
* polynomial mod P. Whenever we receive an extra bit, we multiply
* the existing remainder by x, add (XOR) the x^32 term thus
* generated to the new x^32 term caused by the incoming bit, and
* remove the resulting combined x^32 term if present by replacing
* it with (P-x^32).
*
* Bit 0 of the word is the x^31 term and bit 31 is the x^0 term.
* Thus, multiplying by x means shifting right. So the actual
* algorithm goes like this:
*
* x32term = (crcword & 1) ^ newbit;
* crcword = (crcword >> 1) ^ (x32term * 0xEDB88320);
*
* In practice, we pre-compute what will happen to crcword on any
* given sequence of eight incoming bits, and store that in a table
* which we then use at run-time to do the job:
*
* outgoingplusnew = (crcword & 0xFF) ^ newbyte;
* crcword = (crcword >> 8) ^ table[outgoingplusnew];
*
* where table[outgoingplusnew] is computed by setting crcword=0
* and then iterating the first code fragment eight times (taking
* the incoming byte low bit first).
*
* Note that all shifts are rightward and thus no assumption is
* made about exact word length! (Although word length must be at
* _least_ 32 bits, but ANSI C guarantees this for `unsigned long'
* anyway.)
*/
static unsigned long crc32_tab[] = { #include <stdlib.h>
0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
0x2d02ef8dL
};
/* Return a 32-bit CRC of the contents of the buffer. */ /* ----------------------------------------------------------------------
* Multi-function module. Can be compiled three ways.
*
* - Compile with no special #defines. Will generate a table
* that's already initialised at compile time, and one function
* crc32(buf,len) that uses it. Normal usage.
*
* - Compile with INITFUNC defined. Will generate an uninitialised
* array as the table, and as well as crc32(buf,len) it will
* also generate void crc32_init(void) which sets up the table
* at run time. Useful if binary size is important.
*
* - Compile with GENPROGRAM defined. Will create a standalone
* program that does the initialisation and outputs the table as
* C code.
*/
unsigned long crc32(const unsigned char *s, unsigned int len) #define POLY (0xEDB88320L)
{
unsigned int i;
unsigned long crc32val;
crc32val = 0; #ifdef GENPROGRAM
for (i = 0; i < len; i ++) #define INITFUNC /* the gen program needs the init func :-) */
{ #endif
crc32val =
crc32_tab[(crc32val ^ s[i]) & 0xff] ^ #ifdef INITFUNC
(crc32val >> 8);
/*
* This variant of the code generates the table at run-time from an
* init function.
*/
static unsigned long crc32_table[256];
void crc32_init(void) {
unsigned long crcword;
int i;
for (i = 0; i < 256; i++) {
unsigned long newbyte, x32term;
int j;
crcword = 0;
newbyte = i;
for (j = 0; j < 8; j++) {
x32term = (crcword ^ newbyte) & 1;
crcword = (crcword >> 1) ^ (x32term * POLY);
newbyte >>= 1;
}
crc32_table[i] = crcword;
} }
return crc32val; }
#else
/*
* This variant of the code has the data already prepared.
*/
static const unsigned long crc32_table[256] = {
0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL,
0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L,
0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L,
0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L,
0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL,
0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L,
0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL,
0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L,
0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L,
0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL,
0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L,
0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L,
0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L,
0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL,
0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L,
0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL,
0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL,
0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L,
0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L,
0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L,
0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL,
0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L,
0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL,
0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L,
0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L,
0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL,
0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L,
0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L,
0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L,
0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL,
0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L,
0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL,
0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL,
0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L,
0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L,
0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L,
0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL,
0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L,
0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL,
0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L,
0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L,
0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL,
0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L,
0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L,
0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L,
0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL,
0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L,
0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL,
0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL,
0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L,
0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L,
0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L,
0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL,
0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L,
0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL,
0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L,
0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L,
0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL,
0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L,
0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L,
0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L,
0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL,
0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L,
0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL
};
#endif
#ifdef GENPROGRAM
int main(void) {
unsigned long crcword;
int i;
crc32_init();
for (i = 0; i < 256; i++) {
printf("%s0x%08XL%s",
(i % 4 == 0 ? " " : " "),
crc32_table[i],
(i % 4 == 3 ? (i == 255 ? "\n" : ",\n") : ","));
}
return 0;
}
#endif
unsigned long crc32(const void *buf, size_t len) {
unsigned long crcword = 0L;
const unsigned char *p = (const unsigned char *) buf;
while (len--) {
unsigned long newbyte = *p++;
newbyte ^= crcword & 0xFFL;
crcword = (crcword >> 8) ^ crc32_table[newbyte];
}
return crcword;
} }

2
win_res.rc
View File

@ -261,7 +261,7 @@ BEGIN
DEFPUSHBUTTON "OK", IDOK, 98, 211, 44, 14 DEFPUSHBUTTON "OK", IDOK, 98, 211, 44, 14
LTEXT "Copyright \251 1997-9 Simon Tatham", 1000, 10, 10, 206, 8 LTEXT "Copyright \251 1997-9 Simon Tatham", 1000, 10, 10, 206, 8
LTEXT "Portions copyright Gary S. Brown and Eric Young", 1100, 10, 18, 206, 8 LTEXT "Portions copyright Eric Young", 1100, 10, 18, 206, 8
LTEXT "Permission is hereby granted, free of charge, to any person", 1002, 10, 34, 206, 8 LTEXT "Permission is hereby granted, free of charge, to any person", 1002, 10, 34, 206, 8
LTEXT "obtaining a copy of this software and associated documentation", 1003, 10, 42, 206, 8 LTEXT "obtaining a copy of this software and associated documentation", 1003, 10, 42, 206, 8