Программа вычисления crc32


Циклический избыточный код | Контроль Разума

Алгоритм вычисления контрольной суммы (CRC, англ. cyclic redundancy check, проверка избыточности циклической суммы) — способ цифровой идентификации некоторой последовательности данных, который заключается в вычислении контрольного значения её циклического избыточного кода.

С точки зрения математики КС является типом хэш-функции, используемой для вычисления контрольного кода — небольшого количества бит внутри большого блока данных, например сетевого пакета или блока компьютерного файла, применяемого для обнаружения ошибок при передаче или хранении информации. Результат вычисления КС добавляется в конец блока данных непосредственно перед началом передачи или сохранения данных на каком-либо носителе информации. Впоследствии он проверяется для подтверждения её целостности. Популярность КС обусловлена тем, что подобная проверка просто реализуема в двоичном цифровом оборудовании, легко анализируется, и хорошо подходит для обнаружения общих ошибок, вызванных наличием шума в каналах передачи данных.

    Алгоритм CRC базируется на свойствах деления с остатком двоичных многочленов, т.е. хэш-функция является по сути остатком от деления многочлена, соответствующего входным данным, на некий фиксированный порождающий многочлен.

    Каждому конечному двоичному набору данных взаимооднозначно сопоставляется двоичный многочлен , последовательность коэффициентов которого представляет из себя исходную последовательность. Например, десятичное число 90 (1011010 в двоичной записи) соответствует многочлену:

    Подобным же образом в виде двоичного многочлена может быть представлен любой из блоков обрабатываемых данных, и любой двоичный многочлен обращается в набор битов. Нетрудно видеть, что количество различных многочленов степени меньше N равно , что совпадает с числом всех двоичных последовательностей длины N.

    При делении с остатком степень многочлена остатка строго меньше степени многочлена делителя, т.е. если в качестве делителя выбрать многочлен степени N, то различных остатков от деления он будет давать как раз

    При "правильном" выборе порождающего многочлена (делителя), остатки от деления на него будут обладать нужными свойствами хэширования - хорошей перемешиваемостью и быстрым алгоритмом вычисления. Второе обеспечивается тем, что степень порождающего многочлена обычно пропорциональна длине байта или машинного слова (например 8, 16 или 32).

    Таким образом, контрольная сумма CRC с порождающим многочленом степени N есть битовая последовательность длины N, представляющая многочлен, получившийся в остатке при делении исходного многочлена (представляющего входной поток бит) на порождающий многочлен:

    где

     — контрольный код многочлена .  — исходный многочлен.  — порождающий многочлен.  — степень порождающего многочлена.

    Умножение осуществляется приписыванием нулей к входной последовательности, что улучшает качество хэширования для коротких входных последовательностей.

    Ниже представлены реализации получения некоторых CRC для многочленов степени 8 (CRC-8), 16 (CRC-16) и 32 (CRC-32).

    Формализованный алгоритм расчёта CRC16 Править

    Для получения контрольной суммы, необходимо сгенерировать полином. Основное требование к полиному: его степень должна быть равна длине контрольной суммы в битах. При этом старший бит полинома обязательно должен быть равен “1”.

    Из файла берется первое слово. В зависимости от того, равен ли старший бит этого слова “1” или нет, выполняем (или нет) операцию XOR на полином. Полученный результат, вне зависимости от того, выполнялась ли операция XOR, сдвигаем на один бит влево (т.е. умножаем на 2). После сдвига (умножения) теряется старый старший бит, а младший бит освобождается (обнуляется). На место младшего бита загружается очередной бит из файла. Операция повторяется до тех пор, пока не загрузится последний бит файла.

    После прохождения всего файла, в слове остается остаток, который и является контрольной суммой.

    Обучающую программу для пересчета контрольной суммы(CRC), построения кодера и декодера можно скачать здесь http://depositfiles.com/ru/files/6182190.

    Пример программы расчёта CRC8 на языке C Править

    /* Name  : CRC-8 Poly  : 0x31 x^8 + x^5 + x^4 + 1 Init  : 0xFF Revert: false XorOut: 0x00 Check : 0xF7 ("123456789") MaxLen: 15 байт(127 бит) - обнаружение одинарных, двойных, тройных и всех нечетных ошибок */ unsigned char Crc8(unsigned char *pcBlock, unsigned char len) { unsigned char crc = 0xFF; unsigned char i;   while (len--) { crc ^= *pcBlock++;   for (i = 0; i < 8; i++) crc = crc & 0x80 ? (crc << 1) ^ 0x31 : crc << 1; }   return crc; }

    Пример программы табличного(быстрого) расчёта CRC8 на языке C Править

    /* Name  : CRC-8 Poly  : 0x31 x^8 + x^5 + x^4 + 1 Init  : 0xFF Revert: false XorOut: 0x00 Check : 0xF7 ("123456789") MaxLen: 15 байт (127 бит) - обнаружение одинарных, двойных, тройных и всех нечетных ошибок */ const unsigned char Crc8Table[256] = { 0x00, 0x31, 0x62, 0x53, 0xC4, 0xF5, 0xA6, 0x97, 0xB9, 0x88, 0xDB, 0xEA, 0x7D, 0x4C, 0x1F, 0x2E, 0x43, 0x72, 0x21, 0x10, 0x87, 0xB6, 0xE5, 0xD4, 0xFA, 0xCB, 0x98, 0xA9, 0x3E, 0x0F, 0x5C, 0x6D, 0x86, 0xB7, 0xE4, 0xD5, 0x42, 0x73, 0x20, 0x11, 0x3F, 0x0E, 0x5D, 0x6C, 0xFB, 0xCA, 0x99, 0xA8, 0xC5, 0xF4, 0xA7, 0x96, 0x01, 0x30, 0x63, 0x52, 0x7C, 0x4D, 0x1E, 0x2F, 0xB8, 0x89, 0xDA, 0xEB, 0x3D, 0x0C, 0x5F, 0x6E, 0xF9, 0xC8, 0x9B, 0xAA, 0x84, 0xB5, 0xE6, 0xD7, 0x40, 0x71, 0x22, 0x13, 0x7E, 0x4F, 0x1C, 0x2D, 0xBA, 0x8B, 0xD8, 0xE9, 0xC7, 0xF6, 0xA5, 0x94, 0x03, 0x32, 0x61, 0x50, 0xBB, 0x8A, 0xD9, 0xE8, 0x7F, 0x4E, 0x1D, 0x2C, 0x02, 0x33, 0x60, 0x51, 0xC6, 0xF7, 0xA4, 0x95, 0xF8, 0xC9, 0x9A, 0xAB, 0x3C, 0x0D, 0x5E, 0x6F, 0x41, 0x70, 0x23, 0x12, 0x85, 0xB4, 0xE7, 0xD6, 0x7A, 0x4B, 0x18, 0x29, 0xBE, 0x8F, 0xDC, 0xED, 0xC3, 0xF2, 0xA1, 0x90, 0x07, 0x36, 0x65, 0x54, 0x39, 0x08, 0x5B, 0x6A, 0xFD, 0xCC, 0x9F, 0xAE, 0x80, 0xB1, 0xE2, 0xD3, 0x44, 0x75, 0x26, 0x17, 0xFC, 0xCD, 0x9E, 0xAF, 0x38, 0x09, 0x5A, 0x6B, 0x45, 0x74, 0x27, 0x16, 0x81, 0xB0, 0xE3, 0xD2, 0xBF, 0x8E, 0xDD, 0xEC, 0x7B, 0x4A, 0x19, 0x28, 0x06, 0x37, 0x64, 0x55, 0xC2, 0xF3, 0xA0, 0x91, 0x47, 0x76, 0x25, 0x14, 0x83, 0xB2, 0xE1, 0xD0, 0xFE, 0xCF, 0x9C, 0xAD, 0x3A, 0x0B, 0x58, 0x69, 0x04, 0x35, 0x66, 0x57, 0xC0, 0xF1, 0xA2, 0x93, 0xBD, 0x8C, 0xDF, 0xEE, 0x79, 0x48, 0x1B, 0x2A, 0xC1, 0xF0, 0xA3, 0x92, 0x05, 0x34, 0x67, 0x56, 0x78, 0x49, 0x1A, 0x2B, 0xBC, 0x8D, 0xDE, 0xEF, 0x82, 0xB3, 0xE0, 0xD1, 0x46, 0x77, 0x24, 0x15, 0x3B, 0x0A, 0x59, 0x68, 0xFF, 0xCE, 0x9D, 0xAC }; unsigned char Crc8(unsigned char *pcBlock, unsigned char len) { unsigned char crc = 0xFF; while (len--) crc = Crc8Table[crc ^ *pcBlock++]; return crc; }

    CRC-CCITT (отличается от классического CRC-16, т.к. использует другой полином и порядок данных

    Пример программы расчёта CRC-16 CCITT на языке C Править

    /* Name  : CRC-16 CCITT Poly  : 0x11021 x^16 + x^12 + x^5 + 1 Init  : 0xFFFF Revert: false XorOut: 0x0000 Check : 0x29B1 ("123456789") MaxLen: 4095 байт (32767 бит) - обнаружение одинарных, двойных, тройных и всех нечетных ошибок */ unsigned short Crc16( unsigned char *pcBlock, unsigned short len ) { unsigned short crc = 0xFFFF; unsigned char i;   while( len-- ) { crc ^= *pcBlock++ << 8;   for( i = 0; i < 8; i++ ) crc = crc & 0x8000 ? ( crc << 1 ) ^ 0x1021 : crc << 1; }   return crc; }

    Пример программы табличного(быстрого) расчёта CRC-16 CCITT на языке C Править

    /* Name  : CRC-16 CCITT Poly  : 0x11021 x^16 + x^12 + x^5 + 1 Init  : 0xFFFF Revert: false XorOut: 0x0000 Check : 0x29B1 ("123456789") MaxLen: 4095 байт (32767 бит) - обнаружение одинарных, двойных, тройных и всех нечетных ошибок */ const unsigned short Crc16Table[256] = { 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 };   unsigned short Crc16(unsigned char * pcBlock, unsigned short len) { unsigned short crc = 0xFFFF;   while (len--) crc = (crc << 8) ^ Crc16Table[(crc >> 8) ^ *pcBlock++];   return crc; }

    Пример программы табличного(быстрого) расчёта стандартного (ARC) CRC-16 на языке C Править

    /* Name  : CRC-16 Poly  : 0x18005 x^16 + x^15 + x^2 + 1 Init  : 0x0000 Revert: true XorOut: 0x0000 Check : 0x4B37 ("123456789") MaxLen: 4095 байт (32767 бит) - обнаружение одинарных, двойных, тройных и всех нечетных ошибок */ const unsigned short Crc16Table[256] = { 0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040 };   unsigned short Crc16(unsigned char * pcBlock, unsigned short len) { unsigned short crc = 0xFFFF;   while (len--) crc = (crc >> 8) ^ Crc16Table[(crc & 0xFF) ^ *pcBlock++];   return crc; }

    Алгоритм CRC32 основан на примитивном полиноме EDB88320 (шестн).

    Пример программы расчёта CRC32 на языке C Править

    /* Name  : CRC-32 Poly  : 0x04C11DB7 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 Init  : 0xFFFFFFFF Revert: true XorOut: 0xFFFFFFFF Check : 0xCBF43926 ("123456789") MaxLen: 268 435 455 байт (2 147 483 647 бит) - обнаружение одинарных, двойных, пакетных и всех нечетных ошибок */ unsigned long Crc32(unsigned char *buf, unsigned long len) { unsigned long crc_table[256]; unsigned long crc;   for (int i = 0; i < 256; i++) { crc = i; for (int j = 0; j < 8; j++) crc = crc & 1 ? (crc >> 1) ^ 0xEDB88320UL : crc >> 1;   crc_table[i] = crc; };   crc = 0xFFFFFFFFUL;   while (len--) crc = crc_table[(crc ^ *buf++) & 0xFF] ^ (crc >> 8);   return crc ^ 0xFFFFFFFFUL; };
    • Генри С. Уоррен, мл. Глава 5. Подсчет битов // Алгоритмические трюки для программистов = Hacker's Delight. — М.: «Вильямс», 2007. — С. 288. — ISBN 0-201-91465-4
    ar:اختبار التكرار الدوري

    bg:CRC ca:Control de redundància cíclica cs:Cyklický redundantní součet de:Zyklische Redundanzprüfung en:Cyclic redundancy check es:Control de redundancia cíclica eu:CRC fi:CRC fr:Contrôle de redondance cyclique he:בדיקת יתירות מחזורית id:CRC it:Cyclic redundancy check ja:巡回冗長検査 ko:순환 중복 검사 nl:Cyclic Redundancy Check pl:CRC pt:CRC simple:Cyclic redundancy check sk:Kontrola cyklickým kódom sv:Cyclic Redundancy Check vi:CRC zh:循環冗餘校驗

    mind-control.wikia.com

    CRC-16 CRC-32

    CRC-16 CRC-32 .

    CRC (Cyclic Redundancy Code) . CRC .

    CRC-16 x16 + x15 + x2 + 1, ANSI, Modbus, USB CRC-32 x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1, POSIX, V.42 IEEE 802.3.

    . 17422-82 " . ". 215 . - 232 .

    CRC-16 34.402-91 " 3,81 (0,15 ) 4 / (100 /) 63 / (1600 /)".

    - 25873-83 " . ".

    , .

    .

    RX. / RX , - . - CRC . /, / .

    X . .

    , - . , . : 9816 = 15210 - 9 8.

    \ 0 1 2 3 4 5 6 7 8 9 A B C D E F
    0 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    1 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
    2 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
    3 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
    4 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
    5 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
    6 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
    7 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    8 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
    9 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
    A 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
    B 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
    C 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
    D 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
    E 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
    F 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

    , - . , . : 2418 = 16110 - 248 1.

    \ 0 1 2 3 4 5 6 7
    0 0 1 2 3 4 5 6 7
    1 8 9 10 11 12 13 14 15
    2 16 17 18 19 20 21 22 23
    3 24 25 26 27 28 29 30 31
    4 32 33 34 35 36 37 38 39
    5 40 41 42 43 44 45 46 47
    6 48 49 50 51 52 53 54 55
    7 56 57 58 59 60 61 62 63
    10 64 65 66 67 68 69 70 71
    11 72 73 74 75 76 77 78 79
    12 80 81 82 83 84 85 86 87
    13 88 89 90 91 92 93 94 95
    14 96 97 98 99 100 101 102 103
    15 104 105 106 107 108 109 110 111
    16 112 113 114 115 116 117 118 119
    17 120 121 122 123 124 125 126 127
    20 128 129 130 131 132 133 134 135
    21 136 137 138 139 140 141 142 143
    22 144 145 146 147 148 149 150 151
    23 152 153 154 155 156 157 158 159
    24 160 161 162 163 164 165 166 167
    25 168 169 170 171 172 173 174 175
    26 176 177 178 179 180 181 182 183
    27 184 185 186 187 188 189 190 191
    30 192 193 194 195 196 197 198 199
    31 200 201 202 203 204 205 206 207
    32 208 209 210 211 212 213 214 215
    33 216 217 218 219 220 221 222 223
    34 224 225 226 227 228 229 230 231
    35 232 233 234 235 236 237 238 239
    36 240 241 242 243 244 245 246 247
    37 248 249 250 251 252 253 254 255

    : ODT, FODT, DOC, PDF.

    "CRC-16"

    . "/", "/". - "/".

    . "123456789" {49, 50, 51, 52, 53, 54, 55, 56, 57} CRC-16 4B3716.

    crc16.mkp ( 64834/36)

      0 1 2 3 4 5 6 7 8 9
    000 Cx 4 2 5 5 A B 1 + 6
    010 0 0 8 3 E 2 PP 91 00 0
    020 0 6 1 PP 90 26 Cx / B K XOR
    030 2 × E + PP 90 42 PP 90 44
    040 9 PP 90 44 A K XOR B 9 A 6
    050 × + PP 91 02 4 1 + 4
    060 27 43h 'C' 52h 'R' 43h 'C' 31h '1' 36h '6' 3Ah ':' 20h ' ' A2h '' A2h ''
    070 AEh '' A4h '' 20h ' ' A2h '' 20h ' ' 52h 'R' 58h 'X' 2Ch ',' 20h ' ' 91h ''
    080 2Fh '/' 8Fh '' 00h 00h 00h C0h C1h C1h 81h 01h
    090 40h C3h 01h 03h C0h 02h 80h C2h 41h C6h
    100 01h 06h C0h 07h 80h C7h 41h 05h 00h C5h
    110 C1h C4h 81h 04h 40h CCh 01h 0Ch C0h 0Dh
    120 80h CDh 41h 0Fh 00h CFh C1h CEh 81h 0Eh
    130 40h 0Ah 00h CAh C1h CBh 81h 0Bh 40h C9h
    140 01h 09h C0h 08h 80h C8h 41h D8h 01h 18h
    150 C0h 19h 80h D9h 41h 1Bh 00h DBh C1h DAh
    160 81h 1Ah 40h 1Eh 00h DEh C1h DFh 81h 1Fh
    170 40h DDh 01h 1Dh C0h 1Ch 80h DCh 41h 14h
    180 00h D4h C1h D5h 81h 15h 40h D7h 01h 17h
    190 C0h 16h 80h D6h 41h D2h 01h 12h C0h 13h
    200 80h D3h 41h 11h 00h D1h C1h D0h 81h 10h
    210 40h F0h 01h 30h C0h 31h 80h F1h 41h 33h
    220 00h F3h C1h F2h 81h 32h 40h 36h 00h F6h
    230 C1h F7h 81h 37h 40h F5h 01h 35h C0h 34h
    240 80h F4h 41h 3Ch 00h FCh C1h FDh 81h 3Dh
    250 40h FFh 01h 3Fh C0h 3Eh 80h FEh 41h FAh
    260 01h 3Ah C0h 3Bh 80h FBh 41h 39h 00h F9h
    270 C1h F8h 81h 38h 40h 28h 00h E8h C1h E9h
    280 81h 29h 40h EBh 01h 2Bh C0h 2Ah 80h EAh
    290 41h EEh 01h 2Eh C0h 2Fh 80h EFh 41h 2Dh
    300 00h EDh C1h ECh 81h 2Ch 40h E4h 01h 24h
    310 C0h 25h 80h E5h 41h 27h 00h E7h C1h E6h
    320 81h 26h 40h 22h 00h E2h C1h E3h 81h 23h
    330 40h E1h 01h 21h C0h 20h 80h E0h 41h A0h
    340 01h 60h C0h 61h 80h A1h 41h 63h 00h A3h
    350 C1h A2h 81h 62h 40h 66h 00h A6h C1h A7h
    360 81h 67h 40h A5h 01h 65h C0h 64h 80h A4h
    370 41h 6Ch 00h ACh C1h ADh 81h 6Dh 40h AFh
    380 01h 6Fh C0h 6Eh 80h AEh 41h AAh 01h 6Ah
    390 C0h 6Bh 80h ABh 41h 69h 00h A9h C1h A8h
    400 81h 68h 40h 78h 00h B8h C1h B9h 81h 79h
    410 40h BBh 01h 7Bh C0h 7Ah 80h BAh 41h BEh
    420 01h 7Eh C0h 7Fh 80h BFh 41h 7Dh 00h BDh
    430 C1h BCh 81h 7Ch 40h B4h 01h 74h C0h 75h
    440 80h B5h 41h 77h 00h B7h C1h B6h 81h 76h
    450 40h 72h 00h B2h C1h B3h 81h 73h 40h B1h
    460 01h 71h C0h 70h 80h B0h 41h 50h 00h 90h
    470 C1h 91h 81h 51h 40h 93h 01h 53h C0h 52h
    480 80h 92h 41h 96h 01h 56h C0h 57h 80h 97h
    490 41h 55h 00h 95h C1h 94h 81h 54h 40h 9Ch
    500 01h 5Ch C0h 5Dh 80h 9Dh 41h 5Fh 00h 9Fh
    510 C1h 9Eh 81h 5Eh 40h 5Ah 00h 9Ah C1h 9Bh
    520 81h 5Bh 40h 99h 01h 59h C0h 58h 80h 98h
    530 41h 88h 01h 48h C0h 49h 80h 89h 41h 4Bh
    540 00h 8Bh C1h 8Ah 81h 4Ah 40h 4Eh 00h 8Eh
    550 C1h 8Fh 81h 4Fh 40h 8Dh 01h 4Dh C0h 4Ch
    560 80h 8Ch 41h 44h 00h 84h C1h 85h 81h 45h
    570 40h 87h 01h 47h C0h 46h 80h 86h 41h 82h
    580 01h 42h C0h 43h 80h 83h 41h 41h 00h 81h
    590 C1h 80h 81h 40h 40h          
    -

    crc16.mkl

    .CHARSET 1251 ; () CRC-16 ; 0x8005 ; x16 + x15 + x2 + 1 ; ANSI, Modbus, Bisync, USB ... ; R4 - ; R6=256 ; R9 - ; RA,RB - CRC16 ; RE - ; / / - ; RX, / - CRC16 .ORG 0 CX M4 255 MA MB 1 + M6 .NUM TBL16 ME 2 PP M 9100 ; 2 .NUM STR1 PP M 9026 CX A1: R/S RMB K XOR 2 * RME + PP M 9042 ; PP RM 9044 M9 PP RM 9044 RMA K XOR MB RM9 MA RM6 * + PP M 9102 ; RM4 1 + M4 GOTO A1 STR1: .TEXT "CRC16: RX, /\0" TBL16: .DB 00h,00h .DB 0C0h,0C1h .DB 0C1h,81h .DB 01h,40h .DB 0C3h,01h .DB 03h,0C0h .DB 02h,80h .DB 0C2h,41h .DB 0C6h,01h .DB 06h,0C0h .DB 07h,80h .DB 0C7h,41h .DB 05h,00h .DB 0C5h,0C1h .DB 0C4h,81h .DB 04h,40h .DB 0CCh,01h .DB 0Ch,0C0h .DB 0Dh,80h .DB 0CDh,41h .DB 0Fh,00h .DB 0CFh,0C1h .DB 0CEh,81h .DB 0Eh,40h .DB 0Ah,00h .DB 0CAh,0C1h .DB 0CBh,81h .DB 0Bh,40h .DB 0C9h,01h .DB 09h,0C0h .DB 08h,80h .DB 0C8h,41h .DB 0D8h,01h .DB 18h,0C0h .DB 19h,80h .DB 0D9h,41h .DB 1Bh,00h .DB 0DBh,0C1h .DB 0DAh,81h .DB 1Ah,40h .DB 1Eh,00h .DB 0DEh,0C1h .DB 0DFh,81h .DB 1Fh,40h .DB 0DDh,01h .DB 1Dh,0C0h .DB 1Ch,80h .DB 0DCh,41h .DB 14h,00h .DB 0D4h,0C1h .DB 0D5h,81h .DB 15h,40h .DB 0D7h,01h .DB 17h,0C0h .DB 16h,80h .DB 0D6h,41h .DB 0D2h,01h .DB 12h,0C0h .DB 13h,80h .DB 0D3h,41h .DB 11h,00h .DB 0D1h,0C1h .DB 0D0h,81h .DB 10h,40h .DB 0F0h,01h .DB 30h,0C0h .DB 31h,80h .DB 0F1h,41h .DB 33h,00h .DB 0F3h,0C1h .DB 0F2h,81h .DB 32h,40h .DB 36h,00h .DB 0F6h,0C1h .DB 0F7h,81h .DB 37h,40h .DB 0F5h,01h .DB 35h,0C0h .DB 34h,80h .DB 0F4h,41h .DB 3Ch,00h .DB 0FCh,0C1h .DB 0FDh,81h .DB 3Dh,40h .DB 0FFh,01h .DB 3Fh,0C0h .DB 3Eh,80h .DB 0FEh,41h .DB 0FAh,01h .DB 3Ah,0C0h .DB 3Bh,80h .DB 0FBh,41h .DB 39h,00h .DB 0F9h,0C1h .DB 0F8h,81h .DB 38h,40h .DB 28h,00h .DB 0E8h,0C1h .DB 0E9h,81h .DB 29h,40h .DB 0EBh,01h .DB 2Bh,0C0h .DB 2Ah,80h .DB 0EAh,41h .DB 0EEh,01h .DB 2Eh,0C0h .DB 2Fh,80h .DB 0EFh,41h .DB 2Dh,00h .DB 0EDh,0C1h .DB 0ECh,81h .DB 2Ch,40h .DB 0E4h,01h .DB 24h,0C0h .DB 25h,80h .DB 0E5h,41h .DB 27h,00h .DB 0E7h,0C1h .DB 0E6h,81h .DB 26h,40h .DB 22h,00h .DB 0E2h,0C1h .DB 0E3h,81h .DB 23h,40h .DB 0E1h,01h .DB 21h,0C0h .DB 20h,80h .DB 0E0h,41h .DB 0A0h,01h .DB 60h,0C0h .DB 61h,80h .DB 0A1h,41h .DB 63h,00h .DB 0A3h,0C1h .DB 0A2h,81h .DB 62h,40h .DB 66h,00h .DB 0A6h,0C1h .DB 0A7h,81h .DB 67h,40h .DB 0A5h,01h .DB 65h,0C0h .DB 64h,80h .DB 0A4h,41h .DB 6Ch,00h .DB 0ACh,0C1h .DB 0ADh,81h .DB 6Dh,40h .DB 0AFh,01h .DB 6Fh,0C0h .DB 6Eh,80h .DB 0AEh,41h .DB 0AAh,01h .DB 6Ah,0C0h .DB 6Bh,80h .DB 0ABh,41h .DB 69h,00h .DB 0A9h,0C1h .DB 0A8h,81h .DB 68h,40h .DB 78h,00h .DB 0B8h,0C1h .DB 0B9h,81h .DB 79h,40h .DB 0BBh,01h .DB 7Bh,0C0h .DB 7Ah,80h .DB 0BAh,41h .DB 0BEh,01h .DB 7Eh,0C0h .DB 7Fh,80h .DB 0BFh,41h .DB 7Dh,00h .DB 0BDh,0C1h .DB 0BCh,81h .DB 7Ch,40h .DB 0B4h,01h .DB 74h,0C0h .DB 75h,80h .DB 0B5h,41h .DB 77h,00h .DB 0B7h,0C1h .DB 0B6h,81h .DB 76h,40h .DB 72h,00h .DB 0B2h,0C1h .DB 0B3h,81h .DB 73h,40h .DB 0B1h,01h .DB 71h,0C0h .DB 70h,80h .DB 0B0h,41h .DB 50h,00h .DB 90h,0C1h .DB 91h,81h .DB 51h,40h .DB 93h,01h .DB 53h,0C0h .DB 52h,80h .DB 92h,41h .DB 96h,01h .DB 56h,0C0h .DB 57h,80h .DB 97h,41h .DB 55h,00h .DB 95h,0C1h .DB 94h,81h .DB 54h,40h .DB 9Ch,01h .DB 5Ch,0C0h .DB 5Dh,80h .DB 9Dh,41h .DB 5Fh,00h .DB 9Fh,0C1h .DB 9Eh,81h .DB 5Eh,40h .DB 5Ah,00h .DB 9Ah,0C1h .DB 9Bh,81h .DB 5Bh,40h .DB 99h,01h .DB 59h,0C0h .DB 58h,80h .DB 98h,41h .DB 88h,01h .DB 48h,0C0h .DB 49h,80h .DB 89h,41h .DB 4Bh,00h .DB 8Bh,0C1h .DB 8Ah,81h .DB 4Ah,40h .DB 4Eh,00h .DB 8Eh,0C1h .DB 8Fh,81h .DB 4Fh,40h .DB 8Dh,01h .DB 4Dh,0C0h .DB 4Ch,80h .DB 8Ch,41h .DB 44h,00h .DB 84h,0C1h .DB 85h,81h .DB 45h,40h .DB 87h,01h .DB 47h,0C0h .DB 46h,80h .DB 86h,41h .DB 82h,01h .DB 42h,0C0h .DB 43h,80h .DB 83h,41h .DB 41h,00h .DB 81h,0C1h .DB 80h,81h .DB 40h,40h .END
    "CRC-32"

    . "/", "/". - "/".

    . "123456789" {49, 50, 51, 52, 53, 54, 55, 56, 57} CRC-32 CBF4392616.

    crc32.mkp ( 64834/36)

      0 1 2 3 4 5 6 7 8 9
    0000 Cx 4 2 5 5 5 A B C D
    0010 1 + 6 0 1 1 9 E 4 PP
    0020 91 00 0 0 9 7 PP 90 26 Cx
    0030 / D K XOR 4 × E + PP 90 42
    0040 PP 90 44 7 PP 90 44 8 PP 90
    0050 44 9 PP 90 44 C K XOR D 9 B
    0060 K XOR C 8 A K XOR B 7 A 5 K XOR
    0070 6 × B 5 K XOR + 6 × C 5
    0080 K XOR + 6 × D 5 K XOR + PP 91
    0090 02 4 1 + 4 30 43h 'C' 52h 'R' 43h 'C'
    0100 33h '3' 32h '2' 3Ah ':' 20h ' ' A2h '' A2h '' AEh '' A4h '' 20h ' ' A2h ''
    0110 20h ' ' 52h 'R' 58h 'X' 2Ch ',' 20h ' ' 91h '' 2Fh '/' 8Fh '' 00h 00h
    0120 00h 00h 00h 77h 07h 30h 96h EEh 0Eh 61h
    0130 2Ch 99h 09h 51h BAh 07h 6Dh C4h 19h 70h
    0140 6Ah F4h 8Fh E9h 63h A5h 35h 9Eh 64h 95h
    0150 A3h 0Eh DBh 88h 32h 79h DCh B8h A4h E0h
    0160 D5h E9h 1Eh 97h D2h D9h 88h 09h B6h 4Ch
    0170 2Bh 7Eh B1h 7Ch BDh E7h B8h 2Dh 07h 90h
    0180 BFh 1Dh 91h 1Dh B7h 10h 64h 6Ah B0h 20h
    0190 F2h F3h B9h 71h 48h 84h BEh 41h DEh 1Ah
    0200 DAh D4h 7Dh 6Dh DDh E4h EBh F4h D4h B5h
    0210 51h 83h D3h 85h C7h 13h 6Ch 98h 56h 64h
    0220 6Bh A8h C0h FDh 62h F9h 7Ah 8Ah 65h C9h
    0230 ECh 14h 01h 5Ch 4Fh 63h 06h 6Ch D9h FAh
    0240 0Fh 3Dh 63h 8Dh 08h 0Dh F5h 3Bh 6Eh 20h
    0250 C8h 4Ch 69h 10h 5Eh D5h 60h 41h E4h A2h
    0260 67h 71h 72h 3Ch 03h E4h D1h 4Bh 04h D4h
    0270 47h D2h 0Dh 85h FDh A5h 0Ah B5h 6Bh 35h
    0280 B5h A8h FAh 42h B2h 98h 6Ch DBh BBh C9h
    0290 D6h ACh BCh F9h 40h 32h D8h 6Ch E3h 45h
    0300 DFh 5Ch 75h DCh D6h 0Dh CFh ABh D1h 3Dh
    0310 59h 26h D9h 30h ACh 51h DEh 00h 3Ah C8h
    0320 D7h 51h 80h BFh D0h 61h 16h 21h B4h F4h
    0330 B5h 56h B3h C4h 23h CFh BAh 95h 99h B8h
    0340 BDh A5h 0Fh 28h 02h B8h 9Eh 5Fh 05h 88h
    0350 08h C6h 0Ch D9h B2h B1h 0Bh E9h 24h 2Fh
    0360 6Fh 7Ch 87h 58h 68h 4Ch 11h C1h 61h 1Dh
    0370 ABh B6h 66h 2Dh 3Dh 76h DCh 41h 90h 01h
    0380 DBh 71h 06h 98h D2h 20h BCh EFh D5h 10h
    0390 2Ah 71h B1h 85h 89h 06h B6h B5h 1Fh 9Fh
    0400 BFh E4h A5h E8h B8h D4h 33h 78h 07h C9h
    0410 A2h 0Fh 00h F9h 34h 96h 09h A8h 8Eh E1h
    0420 0Eh 98h 18h 7Fh 6Ah 0Dh BBh 08h 6Dh 3Dh
    0430 2Dh 91h 64h 6Ch 97h E6h 63h 5Ch 01h 6Bh
    0440 6Bh 51h F4h 1Ch 6Ch 61h 62h 85h 65h 30h
    0450 D8h F2h 62h 00h 4Eh 6Ch 06h 95h EDh 1Bh
    0460 01h A5h 7Bh 82h 08h F4h C1h F5h 0Fh C4h
    0470 57h 65h B0h D9h C6h 12h B7h E9h 50h 8Bh
    0480 BEh B8h EAh FCh B9h 88h 7Ch 62h DDh 1Dh
    0490 DFh 15h DAh 2Dh 49h 8Ch D3h 7Ch F3h FBh
    0500 D4h 4Ch 65h 4Dh B2h 61h 58h 3Ah B5h 51h
    0510 CEh A3h BCh 00h 74h D4h BBh 30h E2h 4Ah
    0520 DFh A5h 41h 3Dh D8h 95h D7h A4h D1h C4h
    0530 6Dh D3h D6h F4h FBh 43h 69h E9h 6Ah 34h
    0540 6Eh D9h FCh ADh 67h 88h 46h DAh 60h B8h
    0550 D0h 44h 04h 2Dh 73h 33h 03h 1Dh E5h AAh
    0560 0Ah 4Ch 5Fh DDh 0Dh 7Ch C9h 50h 05h 71h
    0570 3Ch 27h 02h 41h AAh BEh 0Bh 10h 10h C9h
    0580 0Ch 20h 86h 57h 68h B5h 25h 20h 6Fh 85h
    0590 B3h B9h 66h D4h 09h CEh 61h E4h 9Fh 5Eh
    0600 DEh F9h 0Eh 29h D9h C9h 98h B0h D0h 98h
    0610 22h C7h D7h A8h B4h 59h B3h 3Dh 17h 2Eh
    0620 B4h 0Dh 81h B7h BDh 5Ch 3Bh C0h BAh 6Ch
    0630 ADh EDh B8h 83h 20h 9Ah BFh B3h B6h 03h
    0640 B6h E2h 0Ch 74h B1h D2h 9Ah EAh D5h 47h
    0650 39h 9Dh D2h 77h AFh 04h DBh 26h 15h 73h
    0660 DCh 16h 83h E3h 63h 0Bh 12h 94h 64h 3Bh
    0670 84h 0Dh 6Dh 6Ah 3Eh 7Ah 6Ah 5Ah A8h E4h
    0680 0Eh CFh 0Bh 93h 09h FFh 9Dh 0Ah 00h AEh
    0690 27h 7Dh 07h 9Eh B1h F0h 0Fh 93h 44h 87h
    0700 08h A3h D2h 1Eh 01h F2h 68h 69h 06h C2h
    0710 FEh F7h 62h 57h 5Dh 80h 65h 67h CBh 19h
    0720 6Ch 36h 71h 6Eh 6Bh 06h E7h FEh D4h 1Bh
    0730 76h 89h D3h 2Bh E0h 10h DAh 7Ah 5Ah 67h
    0740 DDh 4Ah CCh F9h B9h DFh 6Fh 8Eh BEh EFh
    0750 F9h 17h B7h BEh 43h 60h B0h 8Eh D5h D6h
    0760 D6h A3h E8h A1h D1h 93h 7Eh 38h D8h C2h
    0770 C4h 4Fh DFh F2h 52h D1h BBh 67h F1h A6h
    0780 BCh 57h 67h 3Fh B5h 06h DDh 48h B2h 36h
    0790 4Bh D8h 0Dh 2Bh DAh AFh 0Ah 1Bh 4Ch 36h
    0800 03h 4Ah F6h 41h 04h 7Ah 60h DFh 60h EFh
    0810 C3h A8h 67h DFh 55h 31h 6Eh 8Eh EFh 46h
    0820 69h BEh 79h CBh 61h B3h 8Ch BCh 66h 83h
    0830 1Ah 25h 6Fh D2h A0h 52h 68h E2h 36h CCh
    0840 0Ch 77h 95h BBh 0Bh 47h 03h 22h 02h 16h
    0850 B9h 55h 05h 26h 2Fh C5h BAh 3Bh BEh B2h
    0860 BDh 0Bh 28h 2Bh B4h 5Ah 92h 5Ch B3h 6Ah
    0870 04h C2h D7h FFh A7h B5h D0h CFh 31h 2Ch
    0880 D9h 9Eh 8Bh 5Bh DEh AEh 1Dh 9Bh 64h C2h
    0890 B0h ECh 63h F2h 26h 75h 6Ah A3h 9Ch 02h
    0900 6Dh 93h 0Ah 9Ch 09h 06h A9h EBh 0Eh 36h
    0910 3Fh 72h 07h 67h 85h 05h 00h 57h 13h 95h
    0920 BFh 4Ah 82h E2h B8h 7Ah 14h 7Bh B1h 2Bh
    0930 AEh 0Ch B6h 1Bh 38h 92h D2h 8Eh 9Bh E5h
    0940 D5h BEh 0Dh 7Ch DCh EFh B7h 0Bh DBh DFh
    0950 21h 86h D3h D2h D4h F1h D4h E2h 42h 68h
    0960 DDh B3h F8h 1Fh DAh 83h 6Eh 81h BEh 16h
    0970 CDh F6h B9h 26h 5Bh 6Fh B0h 77h E1h 18h
    0980 B7h 47h 77h 88h 08h 5Ah E6h FFh 0Fh 6Ah
    0990 70h 66h 06h 3Bh CAh 11h 01h 0Bh 5Ch 8Fh
    1000 65h 9Eh FFh F8h 62h AEh 69h 61h 6Bh FFh
    1010 D3h 16h 6Ch CFh 45h A0h 0Ah E2h 78h D7h
    1020 0Dh D2h EEh 4Eh 04h 83h 54h 39h 03h B3h
    1030 C2h A7h 67h 26h 61h D0h 60h 16h F7h 49h
    1040 69h 47h 4Dh 3Eh 6Eh 77h DBh AEh D1h 6Ah
    1050 4Ah D9h D6h 5Ah DCh 40h DFh 0Bh 66h 37h
    1060 D8h 3Bh F0h A9h BCh AEh 53h DEh BBh 9Eh
    1070 C5h 47h B2h CFh 7Fh 30h B5h FFh E9h BDh
    1080 BDh F2h 1Ch CAh BAh C2h 8Ah 53h B3h 93h
    1090 30h 24h B4h A3h A6h BAh D0h 36h 05h CDh
    1100 D7h 06h 93h 54h DEh 57h 29h 23h D9h 67h
    1110 BFh B3h 66h 7Ah 2Eh C4h 61h 4Ah B8h 5Dh
    1120 68h 1Bh 02h 2Ah 6Fh 2Bh 94h B4h 0Bh BEh
    1130 37h C3h 0Ch 8Eh A1h 5Ah 05h DFh 1Bh 2Dh
    1140 02h EFh 8Dh              
    -

    crc32.mkl

    .CHARSET 1251 ; () CRC-32 ; 0xEDB88320 ; x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x + 1 ; POSIX V.42 ; R4 - ; R5=255 (0FFh), R6=256 ; R7-R9 - ; RA-RD - CRC ; RE - ; / / - ; RX, / - CRC32 .ORG 0 CX M4 255 M5 MA MB MC MD 1 + M6 .NUM TBL32 ME 4 PP M 9100 ; .NUM STR1 PP M 9026 CX A1: R/S RMD K XOR 4 * RME + PP M 9042 ; PP RM 9044 M7 PP RM 9044 M8 PP RM 9044 M9 PP RM 9044 RMC K XOR MD RM9 RMB K XOR MC RM8 RMA K XOR MB RM7 MA RM5 K XOR RM6 * RMB RM5 K XOR + RM6 * RMC RM5 K XOR + RM6 * RMD RM5 K XOR + PP M 9102 ; RM4 1 + M4 GOTO A1 STR1: .TEXT "CRC32: RX, /\0" TBL32: .DB 00h,00h,00h,00h .DB 77h,07h,30h,96h .DB 0EEh,0Eh,61h,2Ch .DB 99h,09h,51h,0BAh .DB 07h,6Dh,0C4h,19h .DB 70h,6Ah,0F4h,8Fh .DB 0E9h,63h,0A5h,35h .DB 9Eh,64h,95h,0A3h .DB 0Eh,0DBh,88h,32h .DB 79h,0DCh,0B8h,0A4h .DB 0E0h,0D5h,0E9h,1Eh .DB 97h,0D2h,0D9h,88h .DB 09h,0B6h,4Ch,2Bh .DB 7Eh,0B1h,7Ch,0BDh .DB 0E7h,0B8h,2Dh,07h .DB 90h,0BFh,1Dh,91h .DB 1Dh,0B7h,10h,64h .DB 6Ah,0B0h,20h,0F2h .DB 0F3h,0B9h,71h,48h .DB 84h,0BEh,41h,0DEh .DB 1Ah,0DAh,0D4h,7Dh .DB 6Dh,0DDh,0E4h,0EBh .DB 0F4h,0D4h,0B5h,51h .DB 83h,0D3h,85h,0C7h .DB 13h,6Ch,98h,56h .DB 64h,6Bh,0A8h,0C0h .DB 0FDh,62h,0F9h,7Ah .DB 8Ah,65h,0C9h,0ECh .DB 14h,01h,5Ch,4Fh .DB 63h,06h,6Ch,0D9h .DB 0FAh,0Fh,3Dh,63h .DB 8Dh,08h,0Dh,0F5h .DB 3Bh,6Eh,20h,0C8h .DB 4Ch,69h,10h,5Eh .DB 0D5h,60h,41h,0E4h .DB 0A2h,67h,71h,72h .DB 3Ch,03h,0E4h,0D1h .DB 4Bh,04h,0D4h,47h .DB 0D2h,0Dh,85h,0FDh .DB 0A5h,0Ah,0B5h,6Bh .DB 35h,0B5h,0A8h,0FAh .DB 42h,0B2h,98h,6Ch .DB 0DBh,0BBh,0C9h,0D6h .DB 0ACh,0BCh,0F9h,40h .DB 32h,0D8h,6Ch,0E3h .DB 45h,0DFh,5Ch,75h .DB 0DCh,0D6h,0Dh,0CFh .DB 0ABh,0D1h,3Dh,59h .DB 26h,0D9h,30h,0ACh .DB 51h,0DEh,00h,3Ah .DB 0C8h,0D7h,51h,80h .DB 0BFh,0D0h,61h,16h .DB 21h,0B4h,0F4h,0B5h .DB 56h,0B3h,0C4h,23h .DB 0CFh,0BAh,95h,99h .DB 0B8h,0BDh,0A5h,0Fh .DB 28h,02h,0B8h,9Eh .DB 5Fh,05h,88h,08h .DB 0C6h,0Ch,0D9h,0B2h .DB 0B1h,0Bh,0E9h,24h .DB 2Fh,6Fh,7Ch,87h .DB 58h,68h,4Ch,11h .DB 0C1h,61h,1Dh,0ABh .DB 0B6h,66h,2Dh,3Dh .DB 76h,0DCh,41h,90h .DB 01h,0DBh,71h,06h .DB 98h,0D2h,20h,0BCh .DB 0EFh,0D5h,10h,2Ah .DB 71h,0B1h,85h,89h .DB 06h,0B6h,0B5h,1Fh .DB 9Fh,0BFh,0E4h,0A5h .DB 0E8h,0B8h,0D4h,33h .DB 78h,07h,0C9h,0A2h .DB 0Fh,00h,0F9h,34h .DB 96h,09h,0A8h,8Eh .DB 0E1h,0Eh,98h,18h .DB 7Fh,6Ah,0Dh,0BBh .DB 08h,6Dh,3Dh,2Dh .DB 91h,64h,6Ch,97h .DB 0E6h,63h,5Ch,01h .DB 6Bh,6Bh,51h,0F4h .DB 1Ch,6Ch,61h,62h .DB 85h,65h,30h,0D8h .DB 0F2h,62h,00h,4Eh .DB 6Ch,06h,95h,0EDh .DB 1Bh,01h,0A5h,7Bh .DB 82h,08h,0F4h,0C1h .DB 0F5h,0Fh,0C4h,57h .DB 65h,0B0h,0D9h,0C6h .DB 12h,0B7h,0E9h,50h .DB 8Bh,0BEh,0B8h,0EAh .DB 0FCh,0B9h,88h,7Ch .DB 62h,0DDh,1Dh,0DFh .DB 15h,0DAh,2Dh,49h .DB 8Ch,0D3h,7Ch,0F3h .DB 0FBh,0D4h,4Ch,65h .DB 4Dh,0B2h,61h,58h .DB 3Ah,0B5h,51h,0CEh .DB 0A3h,0BCh,00h,74h .DB 0D4h,0BBh,30h,0E2h .DB 4Ah,0DFh,0A5h,41h .DB 3Dh,0D8h,95h,0D7h .DB 0A4h,0D1h,0C4h,6Dh .DB 0D3h,0D6h,0F4h,0FBh .DB 43h,69h,0E9h,6Ah .DB 34h,6Eh,0D9h,0FCh .DB 0ADh,67h,88h,46h .DB 0DAh,60h,0B8h,0D0h .DB 44h,04h,2Dh,73h .DB 33h,03h,1Dh,0E5h .DB 0AAh,0Ah,4Ch,5Fh .DB 0DDh,0Dh,7Ch,0C9h .DB 50h,05h,71h,3Ch .DB 27h,02h,41h,0AAh .DB 0BEh,0Bh,10h,10h .DB 0C9h,0Ch,20h,86h .DB 57h,68h,0B5h,25h .DB 20h,6Fh,85h,0B3h .DB 0B9h,66h,0D4h,09h .DB 0CEh,61h,0E4h,9Fh .DB 5Eh,0DEh,0F9h,0Eh .DB 29h,0D9h,0C9h,98h .DB 0B0h,0D0h,98h,22h .DB 0C7h,0D7h,0A8h,0B4h .DB 59h,0B3h,3Dh,17h .DB 2Eh,0B4h,0Dh,81h .DB 0B7h,0BDh,5Ch,3Bh .DB 0C0h,0BAh,6Ch,0ADh .DB 0EDh,0B8h,83h,20h .DB 9Ah,0BFh,0B3h,0B6h .DB 03h,0B6h,0E2h,0Ch .DB 74h,0B1h,0D2h,9Ah .DB 0EAh,0D5h,47h,39h .DB 9Dh,0D2h,77h,0AFh .DB 04h,0DBh,26h,15h .DB 73h,0DCh,16h,83h .DB 0E3h,63h,0Bh,12h .DB 94h,64h,3Bh,84h .DB 0Dh,6Dh,6Ah,3Eh .DB 7Ah,6Ah,5Ah,0A8h .DB 0E4h,0Eh,0CFh,0Bh .DB 93h,09h,0FFh,9Dh .DB 0Ah,00h,0AEh,27h .DB 7Dh,07h,9Eh,0B1h .DB 0F0h,0Fh,93h,44h .DB 87h,08h,0A3h,0D2h .DB 1Eh,01h,0F2h,68h .DB 69h,06h,0C2h,0FEh .DB 0F7h,62h,57h,5Dh .DB 80h,65h,67h,0CBh .DB 19h,6Ch,36h,71h .DB 6Eh,6Bh,06h,0E7h .DB 0FEh,0D4h,1Bh,76h .DB 89h,0D3h,2Bh,0E0h .DB 10h,0DAh,7Ah,5Ah .DB 67h,0DDh,4Ah,0CCh .DB 0F9h,0B9h,0DFh,6Fh .DB 8Eh,0BEh,0EFh,0F9h .DB 17h,0B7h,0BEh,43h .DB 60h,0B0h,8Eh,0D5h .DB 0D6h,0D6h,0A3h,0E8h .DB 0A1h,0D1h,93h,7Eh .DB 38h,0D8h,0C2h,0C4h .DB 4Fh,0DFh,0F2h,52h .DB 0D1h,0BBh,67h,0F1h .DB 0A6h,0BCh,57h,67h .DB 3Fh,0B5h,06h,0DDh .DB 48h,0B2h,36h,4Bh .DB 0D8h,0Dh,2Bh,0DAh .DB 0AFh,0Ah,1Bh,4Ch .DB 36h,03h,4Ah,0F6h .DB 41h,04h,7Ah,60h .DB 0DFh,60h,0EFh,0C3h .DB 0A8h,67h,0DFh,55h .DB 31h,6Eh,8Eh,0EFh .DB 46h,69h,0BEh,79h .DB 0CBh,61h,0B3h,8Ch .DB 0BCh,66h,83h,1Ah .DB 25h,6Fh,0D2h,0A0h .DB 52h,68h,0E2h,36h .DB 0CCh,0Ch,77h,95h .DB 0BBh,0Bh,47h,03h .DB 22h,02h,16h,0B9h .DB 55h,05h,26h,2Fh .DB 0C5h,0BAh,3Bh,0BEh .DB 0B2h,0BDh,0Bh,28h .DB 2Bh,0B4h,5Ah,92h .DB 5Ch,0B3h,6Ah,04h .DB 0C2h,0D7h,0FFh,0A7h .DB 0B5h,0D0h,0CFh,31h .DB 2Ch,0D9h,9Eh,8Bh .DB 5Bh,0DEh,0AEh,1Dh .DB 9Bh,64h,0C2h,0B0h .DB 0ECh,63h,0F2h,26h .DB 75h,6Ah,0A3h,9Ch .DB 02h,6Dh,93h,0Ah .DB 9Ch,09h,06h,0A9h .DB 0EBh,0Eh,36h,3Fh .DB 72h,07h,67h,85h .DB 05h,00h,57h,13h .DB 95h,0BFh,4Ah,82h .DB 0E2h,0B8h,7Ah,14h .DB 7Bh,0B1h,2Bh,0AEh .DB 0Ch,0B6h,1Bh,38h .DB 92h,0D2h,8Eh,9Bh .DB 0E5h,0D5h,0BEh,0Dh .DB 7Ch,0DCh,0EFh,0B7h .DB 0Bh,0DBh,0DFh,21h .DB 86h,0D3h,0D2h,0D4h .DB 0F1h,0D4h,0E2h,42h .DB 68h,0DDh,0B3h,0F8h .DB 1Fh,0DAh,83h,6Eh .DB 81h,0BEh,16h,0CDh .DB 0F6h,0B9h,26h,5Bh .DB 6Fh,0B0h,77h,0E1h .DB 18h,0B7h,47h,77h .DB 88h,08h,5Ah,0E6h .DB 0FFh,0Fh,6Ah,70h .DB 66h,06h,3Bh,0CAh .DB 11h,01h,0Bh,5Ch .DB 8Fh,65h,9Eh,0FFh .DB 0F8h,62h,0AEh,69h .DB 61h,6Bh,0FFh,0D3h .DB 16h,6Ch,0CFh,45h .DB 0A0h,0Ah,0E2h,78h .DB 0D7h,0Dh,0D2h,0EEh .DB 4Eh,04h,83h,54h .DB 39h,03h,0B3h,0C2h .DB 0A7h,67h,26h,61h .DB 0D0h,60h,16h,0F7h .DB 49h,69h,47h,4Dh .DB 3Eh,6Eh,77h,0DBh .DB 0AEh,0D1h,6Ah,4Ah .DB 0D9h,0D6h,5Ah,0DCh .DB 40h,0DFh,0Bh,66h .DB 37h,0D8h,3Bh,0F0h .DB 0A9h,0BCh,0AEh,53h .DB 0DEh,0BBh,9Eh,0C5h .DB 47h,0B2h,0CFh,7Fh .DB 30h,0B5h,0FFh,0E9h .DB 0BDh,0BDh,0F2h,1Ch .DB 0CAh,0BAh,0C2h,8Ah .DB 53h,0B3h,93h,30h .DB 24h,0B4h,0A3h,0A6h .DB 0BAh,0D0h,36h,05h .DB 0CDh,0D7h,06h,93h .DB 54h,0DEh,57h,29h .DB 23h,0D9h,67h,0BFh .DB 0B3h,66h,7Ah,2Eh .DB 0C4h,61h,4Ah,0B8h .DB 5Dh,68h,1Bh,02h .DB 2Ah,6Fh,2Bh,94h .DB 0B4h,0Bh,0BEh,37h .DB 0C3h,0Ch,8Eh,0A1h .DB 5Ah,05h,0DFh,1Bh .DB 2Dh,02h,0EFh,8Dh .END

    mk.semico.ru

    Контрольная сумма файла

    А вы, слышали о контрольной сумме файла? Этот термин очень часто встречается на просторах сети и все постоянно зачем-то ее рассчитывают. В этой статье мы разберемся что же это такое и определим, какую пользу можно извлечь, работая с контрольными суммами.

    Что такое контрольная сумма файла?

    Контрольная сумма (часто называют «хеш») — предназначена для контроля целостности передаваемых данных и представляет собой некое значение, которое было рассчитано при помощи специальных алгоритмов. Среди алгоритмов, которые чаще всего применяются, есть CRC32, MD5 и SHA-1.

    CRC32 — переводится как циклический избыточный код, он применим для архиваторов.

    MD5 — очень распространенный алгоритм, у которого есть множество применений. Его можно использовать даже для идентификации файлов. Это удобно при поиске идентичных документов и файлов, достаточно только сравнивать одинаковые контрольные суммы.

    SHA-1 — с помощью него проверяют целостность данных во время загрузки через торренты.

    • Контрольная сумма — это сумма, выводимая в результате работы одного из известных алгоритмов (избыточный код). Любые данные, которые передаются цифровым способом, отправляются фрагментами и нередки случаи, когда эти фрагменты теряются по дороге. Хеш предназначен для проверки целостности данных и выявления поврежденных фрагментов.
    • Специальный алгоритм рассчитывает сумму полученного файла, если она совпадает с контрольной суммой оригинала, значит передача прошла успешно. Если файл (или его фрагмент) имеет отличающийся, от оригинального, хеш, то появляется ошибка контрольной суммы. Она гласит о нарушении целостности файла. Сейчас мы немного заглянем в теорию возникновения ошибок подобного рода.
    • Самое интересное, что такая ошибка может возникнуть задолго до передачи данных. Например, при записи со сменного носителя (флешки, диска), файл уже может некорректно записаться и его хеш будет отличаться от оригинала. Причины этому могут быть разными.
    • При попытке открыть такой файл, начать установку, или воспроизвести его может и ничего не произойти, а могут начаться и серьезные глюки. Мало кому понравится, если в середине игры окажется серьезная ошибка, которая не позволит пройти ее до конца.
    • А еще, несоответствие контрольной суммы может говорить о том, что файл не оригинальный, или в нем выполнялись определенные действия. К примеру, могли прицепить компьютерный вирус. Что тоже не сильно приятно.

    Почему возникает ошибка контрольной суммы?

    Давайте немножко углубимся в тему. Многим известно, из курса школьной физики, что вокруг любого проводника, через который течет электрический ток, образуется магнитное поле. Если такой проводник намотать на катушку, получится достаточно сильный магнит. Но при обычных условиях, это поле незаметно, по крайней мере для человека. Любой проводник, по соседству, сразу же воспринимает это поле и в нем образуются побочные токи. Это называется помехами. Производители разными способами пытаются снизить их влияние, но они практически всегда присутствуют.

    А теперь возьмем любой компьютер, в котором и так места нет, так еще и куча проводов плотно набито. Если даже хозяин пк их красиво уложил, то это никак не улучшает ситуацию. По ним текут разные токи, с разными потенциалами и разным направлением. Одни предназначены для питания, другие передают информацию. В этой коробочке, под названием компьютер, просто хаос невидимых магнитных полей. И все они мешают друг другу, постоянно создают помехи.

    Эта ситуация может показаться фантастической, но такова реальность любой электроники. И самое интересное, что эти помехи считываются системой как реальные сигналы, распознаются и записываются к передаваемому файлу. Чтобы снизить вероятность постоянных наводок, лучше всего размещать все провода как можно дальше друг от друга.

    Можно пойти еще более сложным способом и заменить все провода на экранированные. Они имеют плотную медную оплетку, которая как экран принимает любые помехи на себя и выводит их на корпус компьютера. Правда это сработает только при заземлении этого корпуса, когда питание компьютера подключено через трехпроводную сеть. Профи или те, кто хоть немного разбирается в электронике, для борьбы с помехами, могут воспользоваться ферритовыми сердечниками и кольцами. Хотя подобна мера будет уже посложнее.

    На современных операционных системах возникновение подобных ошибок очень маловероятно и может быть связанно с подменой файла или нестабильным интернет соединением. Ошибки, возникающие из-за внутренних помех компьютера, довольно легко исправляются программным путем и не представляют проблемы для пользователя.

    Но этого нельзя сказать о старых операционных системах. Если вам приходится использовать старенький DOS, ошибка может доставить немножко проблем. Как правило, причина связанна с тем, что система выполняет сброс скорости обмена данных с производительного режима DMA, на очень непроизводительный PIO. Это режим не отличается большой скоростью и не поддерживает работу с контрольными суммами. Исходя из этого, целостность данных не контролируется.

    Можно проверить, какой ражим используется для передачи данных с оптических дисков. Откройте меню «Пуск» и выберите «Панель управления». В следующем окне, откройте раздел «Система» и перейдите в «Диспетчер устройств», выберите «Первичный канал IDE», нажмите на «Свойства» и в окне свойств, откройте вкладку «Дополнительные параметры».

    Все параметры должны выглядеть следующим образом:

    Режим передачи обязательно должен иметь параметр «DMA, если доступно». Если этот режим никак не выставляется, то следует задуматься о покупке нового привода.

    К примеру, вы скачали из сети игру или приложение и хотите проверить целостность файла, насколько корректно он был скачан и не было ли каких-либо ошибок при передаче. Вот здесь и приходят на помощь контрольные суммы. Берете хеш своего файла и сравниваете его с тем, что предоставляет раздающий или автор программы. Если они совпали, то все хорошо, если нет, то приложение может иметь серьезные ошибки и его лучше скачать заново. Такие действия позволят предугадать и избежать появление возможных глюков и зависаний в программе (или игре).

    Чтобы узнать и проверить контрольную сумму нужного файла, используют специальные утилиты. Сейчас мы рассмотрим самые проверенные из них.

    HashTab — программа для проверки контрольная сумма файла

    Эта простенькая программа встраивается в систему и позволяет воспользоваться проверкой контрольных сумм в любой удобный момент.

    Скачать данную утилиту можно на сайте разработчиков: hashtab.ru На этом ресурсе, нажимаем на ссылку «Скачать для Winodws» и сохраняем файл установки на свой компьютер.Запускаем скачанный файл и производим установку программы.

    После этого, в контекстном меню любого файла, можно выбрать свойства и найти раздел с хеш-суммами. По умолчанию, там будут три основных типа сумм, которые мы упоминали выше.

    Например, так выглядят контрольные суммы для файла Microsoft Office Word, с расширением docx.

    Чтобы проверять эти суммы на соответствие, ниже находятся специальное поле. В него необходимо вставить оригинальный хеш и нажать на кнопку «Сравнить файл».

    Если файл соответствует введенной контрольной сумме, то рядом с полем должна появиться зеленая галочка. Если файл не совпадает по контрольным суммам, то появится красный крестик.

    В случае несовпадения хеша, нужно заново скачать данный файл и повторить эту проверку. На этой же вкладке можно настроить вычисление контрольной суммы. Нажмите на ссылку «Настройки».

    Откроется окошко, в котором можно выбрать, из списка, какие типы хеша будут отображаться в основном окне свойств и использоваться для проверки соответствия файлов. Здесь же можно включить отображение хеш-сумм строчными символами.Программа очень простая в управлении и сможет выручить в любой момент, достаточно только зайти в свойства файла.

    Проверяем хэш файла с помощью утилиты MD5 FileChecker

    Есть еще одна полезная программа, которая может помочь проверить контрольные суммы MD5. Отличительной чертой данной утилиты, является возможность работы без установки. Загрузить ее можно здесь:

    После загрузки можете сразу же запустить.

    Нажмите на кнопку «Обзор…» и выберите файл для проверки. Далее нажимаете на «Рассчитать» и через некоторое время (пока программа вычисляет сумму) появится полученное значение MD5 для данного файла.

    Теперь, чуть ниже, в соответствующее поле, вставляем контрольную сумму алгоритма MD5 и делаем клик по кнопке «Проверить». Если все Ок, то появится сообщение о совпадении сумм и о том, что файл не поврежден.

    Если это не так, то появится сообщение следующего вида.

    Так что смело устанавливаем игру или программу на свой компьютер только в том случае, если фактическая сумма совпадает с контрольной

    Итог

    Теперь вы разобрались что такое контрольная сумма и узнали для чего она предназначена. И вы можете извлечь пользу вычисления подобных сумм, определяя целостность скачанных данных. В этом помогут упомянутые, в данной статье, программы HashTab и MD5 FileChecker. Плюс первой, ее способность работать разными типами алгоритмов, для вычисления хеша. Но зато вторая, хоть и работает только с MD5, но зато способна запускаться без установки на компьютер. Это плюс, если вы не хотите слишком засорять свою систему множеством программ.

    Если возникли вопросы, то можете смело их задавать в комментариях.

    prostocomp.net

    Скачать Вычисление CRC-32 - Turbo Pascal

    ----- Пакет CRC32, версия 2 ----- ----- Вычисление контрольного кода CRC-32 ----- ----- Турбо Паскаль 6.0, Ассемблер -----

    Торговые марки: - PKZIP принадлежит PKWARE, Inc.; - ARJ принадлежит Роберту К. Янгу (Robert K Jung).; - Turbo PASCAL и Turbo Assembler принадлежат Borland Internatio- nal, Inc.; - Turbo Professional принадлежит TurboPower Software. CRC32 распространяется по принципу SOURCEWARE - свободно с исходным текстом. Он может быть свободно использован кем угодно для некоммерческих целей. Его можно распространять, сохраняя имя автора и не внося никаких изменений. CRC32 распространяется AS-IS, то есть, автор отвергает всякую ответственность и весь возможный риск ложится на пользователя. Copyright (C) 1991, А.Е. Колесников. CRC32 состоит из следующих компонент: Имя файла Размер Дата Время CRC-32 Примечание ------------------------------------------------------------------ README.1ST 818 22/05/92 16:00:00 824ccfd3 CRC32.ASM 2301 28/12/91 19:00:00 020520f1 Для TASM 2.0 CRC32.DOC 5024 22/05/92 16:00:00 ???????? Этот документ CRCDIR.EXE 31296 28/12/91 19:00:00 f8b3583d После TP 6.0 CRCTEST.EXE 17072 28/12/91 19:00:00 ba25b170 После TP 6.0 CRC32.OBJ 343 28/12/91 19:00:00 aa6a19b7 После TASM 2.0 CRC32.PAS 3300 28/12/91 19:00:00 02e41cfc Для TP 6.0 CRCDIR.PAS 10173 28/12/91 19:00:00 a601852c Печать оглавлений CRCTEST.PAS 385 28/12/91 19:00:00 4111c388 Простой пример CRC32.TPU 1568 28/12/91 19:00:00 82ea9dec После TP 6.0 TPCRT.TPU 26880 04/01/90 05:09:00 0d0d92cc \ Из Turbo Profes- TPDOS.TPU 12448 04/01/90 05:09:00 3b97da9b | sional 5.09 для TPHEAP6.TPU 432 04/01/90 05:09:00 1ad325dd | CRCDIR.PAS TPINLINE.TPU 1792 04/01/90 05:09:00 7ae6f42d | (доработка TPSTRING.TPU 14608 04/01/90 05:09:00 ed9673d9 / к Паскалю 6.0) ------------ Всего 15 файлов ------------------------------------------------------------------ !!! Примечание составителя: Бинарные файлы и модули из библиотеки Turbo Professional 5.09 НЕ ВКЛЮЧЕНЫ по понятным причинам ------------------------------------------------------------------ Модуль CRC32.TPU вычисляет контрольный код CRC-32 для задан- ной последовательности байтов. Это тот самый контрольный код, ко- торый используется архиваторами PKZIP фирмы PKWARE, Inc., и ARJ Роберта К. Янга. Известно, что CRC-32 вычисляется на неупакованном файле. Для вычисления CRC-32 заданной последовательности байтов надо применить три процедуры. Первая - InitCRC - инициализирует CRC-32 значением $FFFFFFFF. Затем надо помещать порции заданной последо- вательности в буфер и для каждой порции вызывать IncCRC. В конце FinishCRC инвертирует все биты результата. Две другие функции, CRCFileB и CRCFile, позволяют получить CRC-32 заданного файла. Они возвращают целый результат - значение IOResult, полученное в процессе чтения (порции) файла. Если ре- зультат - 0, все в порядке; ненулевой результат означает ошибку чтения. Включены две демонстрационные программы - CRCTEST и CRCDIR. Две основные программы реализованы на TASM 2.0, остальные на Turbo PASCAL 6.0 с использованием Turbo Professional 5.09. CRC-32 инициализируется значением $FFFFFFFF. Потом для каждо- го байта B входной последовательности CRC-32 сдвигается вправо на 1 байт. Если байты CRC-32 были {C1,C2,C3,C4} (C1 - старший, C4 - младший), сдвиг дает {0,C1,C2,C3}. Младший байт C4 побитно склады- вается с B по модулю 2 (C4 xor B). Новым значением CRC-32 будет его сдвинутое значение, сложенное побитно по модулю 2 (xor) с 4-байтовой величиной из "магической" таблицы с использованием [B xor C4] в качестве индекса. Было: CRC-32 = {C1,C2,C3,C4} и получили очередной байт B. Стало: CRC-32 = { 0,C1,C2,C3} xor Magic[B xor C4]. На Паскале: CRC := (CRC shr 8) xor Magic[B xor byte(CRC and $FF)]; (здесь CRC - longint, Magic - array[byte] of longint). Последний этап вычисления CRC-32 - инвертировать все биты: CRC := not CRC; Инициализация магической таблицы очень сложна и я воздержусь от ее описания здесь. Почитайте CRC32.ASM. Очевидное применение этих алгоритмов - проверка целостности файлов. Для контакта: 277028 Молдова, Кишинев, ул. Академии 5, Институт математики АН Молдовы, Колесников Александр Евгеньевич Тел.: (код 0422) 73-80-58, 72-59-82 (дирекция).

    tpdn.ru

    Простой расчет контрольной суммы / Хабрахабр

    void crc_calculating(unsigned char puchMsg, unsigned short usDataLen) /*##Расчёт контрольной суммы##*/ { { unsigned char uchCRCHi = 0xFF ; /* Инициализация последнего байта CRC */ unsigned char uchCRCLo = 0xFF ; /* Инициализация первого байта CRC */ unsigned uIndex ; /* will index into CRC lookup table */ while (usDataLen--) /* pass through message buffer */ { uIndex = uchCRCHi ^ *puchMsg++ ; /* Расчёт CRC */ uchCRCLo = uchCRCLo ^ auchCRCHi[uIndex] ; uchCRCHi = auchCRCLo[uIndex] ; } return (uchCRCHi << 8 | uchCRCLo) ; /* Table of CRC values for high–order byte */ static unsigned char auchCRCHi[] = { 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40, 0x01, 0xC0, 0x80, 0x41, 0x01, 0xC0, 0x80, 0x41, 0x00, 0xC1, 0x81, 0x40 }; /* Table of CRC values for low–order byte */ static char auchCRCLo[] = { 0x00, 0xC0, 0xC1, 0x01, 0xC3, 0x03, 0x02, 0xC2, 0xC6, 0x06, 0x07, 0xC7, 0x05, 0xC5, 0xC4, 0x04, 0xCC, 0x0C, 0x0D, 0xCD, 0x0F, 0xCF, 0xCE, 0x0E, 0x0A, 0xCA, 0xCB, 0x0B, 0xC9, 0x09, 0x08, 0xC8, 0xD8, 0x18, 0x19, 0xD9, 0x1B, 0xDB, 0xDA, 0x1A, 0x1E, 0xDE, 0xDF, 0x1F, 0xDD, 0x1D, 0x1C, 0xDC, 0x14, 0xD4, 0xD5, 0x15, 0xD7, 0x17, 0x16, 0xD6, 0xD2, 0x12, 0x13, 0xD3, 0x11, 0xD1, 0xD0, 0x10, 0xF0, 0x30, 0x31, 0xF1, 0x33, 0xF3, 0xF2, 0x32, 0x36, 0xF6, 0xF7, 0x37, 0xF5, 0x35, 0x34, 0xF4, 0x3C, 0xFC, 0xFD, 0x3D, 0xFF, 0x3F, 0x3E, 0xFE, 0xFA, 0x3A, 0x3B, 0xFB, 0x39, 0xF9, 0xF8, 0x38, 0x28, 0xE8, 0xE9, 0x29, 0xEB, 0x2B, 0x2A, 0xEA, 0xEE, 0x2E, 0x2F, 0xEF, 0x2D, 0xED, 0xEC, 0x2C, 0xE4, 0x24, 0x25, 0xE5, 0x27, 0xE7, 0xE6, 0x26, 0x22, 0xE2, 0xE3, 0x23, 0xE1, 0x21, 0x20, 0xE0, 0xA0, 0x60, 0x61, 0xA1, 0x63, 0xA3, 0xA2, 0x62, 0x66, 0xA6, 0xA7, 0x67, 0xA5, 0x65, 0x64, 0xA4, 0x6C, 0xAC, 0xAD, 0x6D, 0xAF, 0x6F, 0x6E, 0xAE, 0xAA, 0x6A, 0x6B, 0xAB, 0x69, 0xA9, 0xA8, 0x68, 0x78, 0xB8, 0xB9, 0x79, 0xBB, 0x7B, 0x7A, 0xBA, 0xBE, 0x7E, 0x7F, 0xBF, 0x7D, 0xBD, 0xBC, 0x7C, 0xB4, 0x74, 0x75, 0xB5, 0x77, 0xB7, 0xB6, 0x76, 0x72, 0xB2, 0xB3, 0x73, 0xB1, 0x71, 0x70, 0xB0, 0x50, 0x90, 0x91, 0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9C, 0x5C, 0x5D, 0x9D, 0x5F, 0x9F, 0x9E, 0x5E, 0x5A, 0x9A, 0x9B, 0x5B, 0x99, 0x59, 0x58, 0x98, 0x88, 0x48, 0x49, 0x89, 0x4B, 0x8B, 0x8A, 0x4A, 0x4E, 0x8E, 0x8F, 0x4F, 0x8D, 0x4D, 0x4C, 0x8C, 0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80, 0x40 }; } }

    habrahabr.ru

    Иллюстрированный самоучитель по задачам и примерам Assembler › Вычисление CRC › "Зеркальный" табличный алгоритм CRC32 [страница - 193] | Самоучители по программированию

    "Зеркальный" табличный алгоритм CRC32

    Для того, кто обладает солидным багажом знаний по проблеме CRC-вычислений, написание программы, реализующей зеркальный алгоритм, – дело техники. На стороне источника код будет выглядеть так:

    ;prg09_09.asm – программа вычисления кода CRC32 на стороне источника :для зеркального алгоритма CRC32 и полинома 0EDB88320h. .data ;исходная битовая последовательность в символах bit_stnng db "123456789" len_bit_string=$-bit_string crc_32 dd 0:сюда мы поместим рассчитанное значение CRC32 adr_bit_string dd bit_string :СРС32-таблица для зеркального табличного алгоритма вычисления CRC32. : tab1_32_mirror dd 256 dup (0) len_tabl_32_mirror=$-tabl_32_mirror adr_tabl_32_mirror dd tabl_32_mirror polinom dd 0EDB88320h.code :-------……расчитываем зеркальную СКС32-таблицу……… les di.adr_tabl_32_mirror add di,len_tabl_32_mirror-4 std:идем назад по таблице mov ex.255 mov ebx.polinom ml: xor eax.eax mov al.cl;индекс в таблице для вычисления CRC push ex;вложенные циклы mov ex.8 m2: shr eax.l jnc m3;старшие разряды не равны – выполняем сдвиг (частное нас не интересует) :старшие разряды равны – выполняем XOR: xor eax.ebx:ax XOR polinom m3: loop m2 pop сх stosd ' ' loop ml закончили расчет СРС32-таблицы xor bx.bx mov eax. OFFFFFFFFh Ids si,adr_bit_string mov cx,len_bit_string m4: mov Ы.al shr eax.8 xor bl.[si] xor eax.tabl_32_mirror[bx] inc si 1 oop m4 xor eax. OFFFFFFFFh;запишем сгс-32 в конец последовательности: mov сгс_32.еах добавляем в конец исходной последовательности

    Для исходной строки "123456789" получили CRC=lb948a57h. Теперь осталось приемнику проверить целостность полученной им строки. Приемник работает по второму варианту и выполняет действия, иллюстрируемые следующей программой. Если полученная им строка совпадает с исходной, то результатом работы программы должно быть значение 6b202ca2h.

    :prg09_10.asm – программа вычисления кода CRC32 на стороне приемника ;для зеркального алгоритма CRC32 и полинома 0EDB88320h. :исходная битовая последовательность в символах bit_string db "123456789" 1en_bit_string=$-bit_string сгс_32 dd Ib948a57h:сюда мы поместили рассчитанное значение CRC32 adr_bit_string dd bit_string :С(}С32-таблица для зеркального табличного алгоритма вычисления CRC32 tabl_32_mirror dd 256 dup (0) 1 en_tabl_32_mi rror=$-tabl_32_nii rror adr_tabl_32_mirror dd tabl_32_mirror polinom dd 0EDB88320h .code :……… ;----……..расчитываем зеркальную CRC32-Таблицу……… les di,adr_tabl_32_mirror add di,len_tabl_32_mirror-4 std;идем назад по таблице mov ex.255 mov ebx.poli nom ml: xor eax.eax mov al.cl:индекс в таблице для вычисления CRC push сх сложенные циклы mov сх,8 m2: shr eax.l jnc m3;старшие разряды не равны – выполняем сдвиг (частное нас не интересует) :старшие разряды равны – выполняем XOR: * xor eax,ebx:ax XOR polinom m3: loop m2 pop ex stosd loop ml закончили расчет (CRC32-таблицы xor bx.bx mov eax. OFFFFFFFFh Ids si.adr_bit_string mov cx.len_bit_string+4;4 – длина crc_32 m4: mov bl.al shr eax.8 xor bl.[si] xor eax.tabl_32_mirror[bx] inc si loop m4:сравнить – результат должен быть константой 6b202ca2h

    Этот вариант работы алгоритма вычисления CRC32 удобен тем, что не нужно знать длину собственно исходной последовательности (без значения CRC). Достаточно просто обработать весь входной поток, не различая в строке завершающую ее подстроку с CRC. Далее необходимо сравнить содержимое регистра ЕАХ с 6b202ca2h. Если эти значения равны, значит, исходная последовательность нарушена не была. Для получения собственно строки достаточно отбросить последние 4 байта сообщения, полученного приемником.

    И последнее замечание, которое говорит о том, что проблема вычисления CRC неоднозначна для понимания и предоставляет большое поле для проведения различных экспериментов и совершенствования существующих алгоритмов. Небольшой поправкой в алгоритме работы источника можно сделать так, что успехом целостности при принятии приемником сообщения может быть не указанная выше константа, а нуль. Для этого источнику достаточно не объединять вычисленное значение CRC32 по XOR с Offffffffh, а просто добавить его к исходной последовательности. Оба эти варианта хороши тем, что не нужно заранее знать длину анализируемого сообщения.

    На этом, пожалуй, можно и закончить обсуждение проблемы вычисления CRC. На примере этой достаточно сложной задачи были в очередной раз продемонстрированы варианты использования средств ассемблера для обработки информации на различных уровнях, вплоть до битового. За дальнейшими подробностями по проблематике вычисления CRC обратитесь к соответствующим источникам.

    samoychiteli.ru

    Cyclic Redundancy Checking (CRC32) | Уроки и примеры программирования

    by Clifford M. Roche

    Предисловие

    В этой статье я намерен передать основные аспекты CRC32 алгоритма. Это относительно простая статья, прежде всего источник информации - демо для Borland C++ и MSVC++ NET. (которые должны быть легко переносимы на MSVC++6) также доступен с настоящей статьей.

    Небольшое понимание математики (многочлен деления) было бы полезно, но я пишу эту статью так, чтобы оно не потребовалось. Вы, однако, должны понимать C++ - это само собой подразумевается.

    Зачем использовать CRC32?

    Мне оно понадобилось для одного из своих небольших проектов - я решил написать приложение для онлайн обновления, которое просто генерирует уникальную подпись для набора файлов, сравнивает эти значения с подписью мастер-списка на сервере, и обновляет файлы, которые не соответствуют этой подписи.

    Есть несколько способов, которыми я могу проверить целостность файлов и решить, требуется ли обновить их с главного сервера. Приходят на ум время создания/таймстамп, размер файла и CRC32. Есть и некоторые, очевидно, более сложные способы, такие как учет файлов в базе данных, однако нет необходимости слишком всё усложнять. То же самое касается большинства видов применения CRC32 в играх. Кроме того, большинство из более сложных алгоритмов примеряют гораздо больше вычислений, чем CRC32.

    CRC32, изо всех представленных вариантов, в настоящее время является наиболее приемлемым, поскольку вам не придется беспокоиться о файлах, которые имеют одинаковый размер или дату изменения (очень часто такое бывает с растровыми изображениями, а также несколькими другими распространенными типами игровых файлов) и у нас нет повода беспокоиться о неточном времени создания файла/таймстампа из-за их изменения. Хотя CRC32 не совершенный алгоритм, и всегда есть шанс, что 2 файла будет иметь одинаковое значение CRC32, случаи эти настолько редки, что CRC32 становится идеальным кандидатом для генерации подписи файла.

    CRC32 значение содержит 32-битное (4-байтовое) число (также известное как подпись), что однозначно определяет указанный кусок данных. Преимуществом CRC32 для контрольных подписей является и то, что его алгоритм устроен так, что небольшие изменения в файле (будь то изменение, удаление или вставка) должны вызывать большие изменения в подписи CRC32. CRC32 имеет 2 ^ 32 возможных значений; в общей сложности 4.294967E +09.

    По этим причинам подписи CRC32 очень полезны в играх, так как оставляет нам простор для творчества. Они могут быть использованы для проверки файлов, чтобы увидеть, были ли изменены, чтобы помочь предотвратить попытки взлома игры с целью читерства, или они могут быть использованы для проверки файлов или данных, которые передаются по интернету во время игры, такие как файл карты, например.

    Как CRC32 работает?

    CRC32 это несколько сложный процесс, и состоит он из многих математических операций. Но вот как он, как правило, работает:

    Сначала мы собираемся взять значение многочлена, и с этим значением мы генерируем CRC32 поиска. В конце этой статьи я покажу, как правильно создать обзорную таблицу с данным многочленом. Далее мы возьмём данные, для которых хотим сгенерировать подпись CRC32, и специальная функция сгенерирует обновлённое значение CRC32 для каждого байта в файле, строке или структуре, которую мы проверяем. Это делается для каждого байта в строке, структуре или файле. После завершения самое обновлённое значение становится подписью.

    Сердце алгоритма CRC32 - простая система, которая принимает переданный байт для вычисления из набора данных, и текущее значение CRC32, которое есть у нас, и выполняет поиск в нашей обзорной таблице. Если нет текущего значения CRC32, мы должны использовать 0xFFFFFFFF. Немного математики, а именно - многочлен деления, и функция вернет обновленное значение CRC32.

    Реализация очень проста.

    Класс

    Так наш класс будет выглядеть.

    class ECRC32 {public:      static DWORD CRC32ByString( LPCTSTR, DWORD& );      static DWORD CRC32ByFile( LPCTSTR, DWORD& );      static DWORD CRC32ByStruct( BYTE*, DWORD, DWORD& ); private:      static bool GetFileSize( HANDLE, DWORD& );      static inline void GetCRC32( BYTE, DWORD& );       static DWORD CRC32Table[256];};

    Всё просто - у нас есть функция для каждого типа данных, который мы планируем использовать, которая будет генерировать для них CRC32 подписи. У нас также есть две приватные функций, одна будет вычислять размер файла - необходимо для правильной работы внутренних алгоритмов, вторая для выполнения другой математики и обновления значения CRC32 для конкретного байта.

    Существует также один статический массив, он просто хранит для нас таблицу CRC32. На самом деле вам не нужно хранить эту таблицу постоянно, если не хотите. Используя конструктор и деструктор, вы можете создавать и очищать таблицу только тогда, когда планируете использовать её. Для наших целей более целесообразно использовать таблицу, так как это может значительно уменьшить время обработки.

    Создание таблицы подстановки

    Для создания таблицы поиска необходимо указать многочленное значение для использования, которое даст нам значения, которые мы используем в нашей таблице. Многочленное значение, которое вы используете, теоретически должно уменьшить вероятность дубликатов подписей в ваших данных, однако математика, скрывающаяся за одним из этих значений, является слишком сложной и не входит в рамки данной статьи. Это нормально, так как для нас уже выбрали оптимальное значение. Значение, которое мы будем использовать для создания нашей таблицы, будет 0x04c11db7.

    Следовательно, этот многочлен также используется многими другими приложениями и системами, такими как WinZip, PKZip, и Ethernet.

    Примечание: Вам нужно будет генерировать таблицу по крайней мере один раз, даже если вы используете фиксированную таблицу. Если, конечно, вы используете таблицу, представленную в моём демо.

    Прежде чем продолжить - стандартные CRC состояния, которые мы должны отражать значениями в нашей таблице поиска, что может быть сделано, отражая многочлен. В этом случае 0x04c11db7 становится 0xedb88320. Хотя некоторые уравнения будут отражать значения в таблице, поскольку они их и создают, я собираюсь отражать многочлен. В конечном счёте это заканчивается лишь тем, что мы используем меньше строк кода.

    Примечание: Отражение - это простой процесс реверса бинарной структуры данного бинарного сегмента. Например, 10100111 станет при отражении 11100101.

    DWORD dwPolynomial = 0xEDB88320;DWORD* CRC32Table = NULL; CRC32Table = new DWORD[256]; DWORD dwCRC;for(int i = 0; i < 256; i++){      dwCRC = i;      for(int j = 8; j > 0; j--)      {            if(dwCRC & 1)                  dwCRC = (dwCRC >> 1) ^ dwPolynomial;            else                  dwCRC >>= 1;      }      CRC32Table[i] = dwCRC;}

    Простой цикл через все 256 записей и создав значения поиска, основанного на позиции в таблице многочлена.

    В зависимости от вашей ситуации вы можете хотеть или не хотеть тратить циклы процессора, чтобы сохранить регенерирующую таблицу каждый раз, когда Вы хотите создать подпись. Если это ваш случай, просто выделите этот код в отдельное приложение, сохраняйте дамп таблиц в файл, на экран, или где вам наиболее удобно, и копируйте и вставляйте значения прямо в таблицу. Хотя и ценой 256 * 4 байт памяти (что на самом деле не много), вы резко улучшите врёмя расчета без необходимости постоянно пересчитывать таблицы.

    Для тех из вас, кто пытается создать таблицу использованием полиномиальных перечисленных выше первых 14 значений должен выглядеть следующим образом:

    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91

    Рассчет CRC32

    Имея таблицу поиска, мы можем взглянуть на функцию GetCRC32. Эта функция принимает один байт и предыдущее вычисленное значение CRC32 (если таковое существует).

    inline void ECRC32::GetCRC32(const BYTE byte, DWORD &dwCRC32){dwCRC32 = (( dwCRC32 ) >> 8 )^ CRC32Table[( byte )^(( dwCrc32 ) & 0x000000FF )];}

    Первое, что нужно отметить - это то, что функция является встроенной. Для тех из вас, кто не понимает этой особенности, где бы ваш код ни делал вызов этой функции, вместо апрыгания на место функции в памяти каждый раз (что потреблять несколько циклов), процессор будет на самом деле вставить копию кода функции в то место, откуда функция была вызвана. Может быть, функция и занимает только цикл или два, но это происходит каждый раз, когда функция вызывается, и если вы попытаетесь вычислить CRC32 значение 4gig файла, вы увидите, почему один или два цикла для каждого обрабатываемого байта могут реально сэкономить много время.

    Обратите внимание: использование встроенных функций не следует воспринимать легкомысленно. Это может привести к весьма значительному увеличению объема итогового кода и может в конечном итоге счёте привести к снижению общей производительности приложения, потребляя слишком много памяти (что что приводит к недостатку ресурсов и ошибкам во время выполнения приложения). В нашей ситуации GetCRC32 вызывается весьма ограниченно и, таким образом, общий размер приложения не имеет значения.

    Вы также можете посмотреть на спецификацию __fastcall. __fastcall работает путем передачи аргументов в функцию через регистры процессора, в отличие от стандартного способа прохождения их через стек. Это может привести к заметному увеличению скорости так же, как это делает inline.

    С переданным байтом и предыдущим его CRC32 значением функциия выполняет деление многочлена, со ссылкой ссылкой на таблицу, и обновление CRC32 подписи.

    Расчет для структур

    Две предыдущих основные функции - ядро нашего CRC32 алгоритма. Все, что осталось сделать - прочитать данные и, используя эти две функции, создать CRC32 подпись для них.

    DWORD ECRC32::CRC32ByStruct( BYTE* byStruct, DWORD dwSize, DWORD &dwCRC32 ){         // MAKE SURE WE HAVE A VALID BYTE STREAM        if( byStruct == NULL ){                return -1;        }         dwCRC32 = 0xFFFFFFFF;         // LOOP TO READ THE STRUCTURE        for( DWORD i = 0; i < dwSize; i++ ){                GetCRC32( *byStruct, dwCRC32 );                byStruct++;        }         // FINISH UP        dwCRC32 = ~dwCRC32;        return 0;}

    Функция принимает в BYTE указатель на базовый адрес структуры, и проходит в цикле через каждый байт этой структуры, передавая значение каждого байта в GetCRC32 вместе с предыдущим значением CRC32. В ситуации, когда предыдущие CRC32 значение неизвестно, мы просто присваиваем значение 0xFFFFFFFF.

    Перед заполнением структуры с данными, которые будут обработаны, очень важно, инициализировать всю структуру в NULL, потому что структуры, как правило, дополняются до 8 байт. Другими словами, если у вас есть структура, которая имеет 7 символов (7 байт), sizeof(структура) вернёт 8 байт. Последний бит будет инициализирован как "мусорное" значение и не может быть такими же, если вы воссоздать структуру позже с теми же данными. Это будет изменять итоговое значение CRC32. Существует еще один вариант - при передаче размера структуры, если вы знаете точный размер структуры без разделителя, вы можете использовать это значение, что заставит наш алгоритм игнорировать любые дополнительные байты-разделители. Однако не следует смешивать два метода, поскольку это будет приводить к различным несовпадениям CRC32 значения двух идентичных структур.

    Расчет для файла

    Расчет подписи CRC для файла очень похож, и хотя функция, делающая это, кажется несколько более сложной - в действительности это не так. Однако мы должны добавить дополнительную функцию, которая будет вычислять размер файла перед обработкой.

    bool ECRC32::GetFileSize( const HANDLE hFile, DWORD &dwSize ){        // WE HAVE TO HAVE A VALID HANDLE        if( hFile == INVALID_HANDLE_VALUE ){                return false;        }         // NOW WE CAN GET THE FILE SIZE        bool bException = false;        dwSize = 0;         try {                // SETS THE UPPER AND LOWER SIZE VALUES                dwSize = GetFileSize( hFile, NULL );                 if( dwSize == INVALID_FILE_SIZE ){                        bException = true;                        dwSize = 0;                }        }         // SOMETHING SCREWED UP        catch( ... ) {                bException = true;        }         return !bException;}    

    Эта функция вызывается внутри CRC32ByFile, поэтому мы не должны о ней сильно беспокоиться. Что происходит в идеале - после того, как CRC32ByFile открыла указанный файл (успешно, мог бы я добавить), будет сделана попытка передать указатель файла и указатель на DWORD, который вернет рассчитанный размер. Функция возвращает true, если это удалось.

    Следующий код на самом деле читает файл и передает данные в наш CRC32 алгоритм.

    // OPEN THE SPECIFIED FILEif(( hFile = CreateFile( strFileName, GENERIC_READ,FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL )) == INVALID_HANDLE_VALUE ){// THIS MEANS THAT WE HAVE AN ERRORdwErrorCode = -1;      }       // CALCULATE THE CRC32 SIGNATUREelse {      BYTE cBuffer[ 512 ];DWORD dwBytesInOut, dwLoop;      bool bSuccess = false;       bSuccess = ReadFile( hFile, cBuffer, sizeof( cBuffer ),      &dwBytesInOut, NULL );       while( bSuccess && dwBytesInOut ){            for( dwLoop = 0; dwLoop < dwBytesInOut; dwLoop++ );            GetCRC32( cBuffer[ dwLoop ], dwCRC32 );bSuccess = ReadFile( hFile, cBuffer, sizeof( cBuffer ), &dwBytesInOut, NULL );      }}

    Это небольшой фрагмент кода из функции, представленой в демо, который принимает файл, открывает его, заполняет буфер данными, вычисляет CRC32-значение для этих данных и повторяется, пока не дойдёт до конца файла.

    Другие применения CRC

    CRC32, как и в играх, также используется вне игр по тем же причинам - для проверки целостности файлов и данных, когда они каким-то способом копируются.

    Великолепное расширение подобного метода использования, которое также широко используются в играх, будет добавить значение CRC32 в пакеты, которые вы посылаете по Интернету; это гарантирует, что данные, которые поступают в место назначения - те же, какими были перед отправкой. Хотя TCP и UDP протоколы хранят значения CRC в заголовках, они будут только проверять, как передаётся каждый пакет. Структуры и данные, которые отправляются в нескольких пакетах, могут в итоге прийти повреждёными и использованными в таком виде без проверки CRC.

    CRC может даже быть использована в целях безопасности, чтобы убедиться, что текстовые сообщения и другие типы сообщений не изменены намеренно. Это система, которая обычно используется в PGP при подписании сообщения таким образом, что получающая сторона может проверить, что оно было отправлено действительно вами, тем, кто его подписал. PGP не использует CRC32 для создания подписей, алгоритм CRC32 несколько слаб для таких ситуаций. Другие общие алгоритмы, используемые для этих целей - это MD5, SHA8, SHA256 и т.д. Они называются HASH-алгоритмы и используются обычно в целях безопасности.

    Если вам нужно использовать генератор подписей, который производит большее количество значений, чем CRC32 и должен иметь большую, чем CRC32, точность, обратите внимание на эти три алгоритма.

    И наконец, если у вас есть какие-либо замечания, вопросы, и так далее, вы легко можете найти меня в irc на канале #gamedev под ником kurifu или seta.

    Войдите, чтобы оставить комментарий:

    masandilov.ru


    Смотрите также