crc32 — Вычисляет CRC32 для строки


Содержание

crc32

(PHP 4 >= 4.0.1, PHP 5, PHP 7)

crc32 � ��������� ������� CRC32 ��� ������

��������

������� ��������� ����������� ���������� ��� 32-������ ��������� (CRC32) ��� ������ str . ��� ������ ������������ ��� �������� ����������� ������������ ������.

� PHP ����� ����� ����� ����, ������� ������ ����������� ����� ����� ��������� �������������� �� 32-������ ����������. �� 64-������ ���������� ��� ���������� crc32() ����� �������������� ������.

������� ��� ����� ������������ ������ «%u» � �������� sprintf() ��� printf() ��� ��������� ���������� ������������� ����� crc32() ��� �����.

��� ������������������ ������������� ����� �� ������ ������������ ��� ������ «%x» � �������� sprintf() � printf() , ��� �� ������� ����������� dechex() . ��� ���� ������� ����� ����������� � ����������� ���������� crc32() � ���������� �����.

��� ������������� 64-������ �������� ����� ��������������� ����������� ���������� ������������� ����� ��� ������� ��������, �� ��� ������ ����������������� �������������, �������� �������������� 0xFFFFFFFF######## �������� ��� ���. ��� ��� ����������������� ������������� �������� ����� ��������������, ���� ������ �� ������ ���, ���� ���� ��� ������ ������ ��������� ������������ �������� � 50% ������� ��� �������� � 32-������ �� 64-������ ���������.

����������� �����, �������� ���������� ����� ����� ���� �� ����� ������ ����� � ����� ���� ���������� ����� ����������������� ������������� (��� �������� ������ md5() ).

����� ��������������� ����� ����� ����� �������� � �������������� ������� hash() . hash(«crc32b», $str) ������ �� �� ������, ��� � str_pad(dechex(crc32($str)), 8, ‘0’, STR_PAD_LEFT) .

crc32

(PHP 4 >= 4.0.1, PHP 5)

crc32 � Вычисляет полином CRC32 для строки

Описание

Функция вычисляет циклический избыточный код 32-битных полиномов (CRC32) для строки str . Это обычно используется для контроля целостности передаваемых данных.

В PHP целые числа имеют знак, поэтому многие контрольные суммы могут оказаться отрицательными. Для получения строкового представления CRC32 без знака используйте формат «%u» в функциях sprintf() или printf() .

Список параметров

Возвращаемые значения

Возвращает контрольную сумму crc32 строки str в виде целого числа.

Примеры

Пример #1 Вывод контрольной суммы CRC32

Этот пример иллюстрирует вывод вычисленной контрольной суммы с помощью функции printf() :

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

  • md5() — Возвращает MD5-хэш строки
  • sha1() — Возвращает SHA1-хэш строки

Crc32 — ��������� CRC32 ��� ������

(PHP 4 >= 4.0.1, PHP 5)

crc32 — ��������� CRC32 ��� ������

�������� int crc32 ( string str )

������� ��������� ����������� ����� �� ��������� CRC32 ��� ������ str . ��� ������ ������������ ��� �������� ������������ �������� ������.

� PHP ����� ����� ����� ����, � ��� ������� ����� ���������� ������������� �����. ��� ��������� ���������� ������������� CRC32 ��� ����� ����������� ������ «%u» � �������� sprintf() ��� printf() .

���� ������ ������������ ����� ����������� CRC32 � ������� ������� printf() :

������ 1. ����� ����������� ����� CRC32

= crc32 ( «The quick brown fox jumped over the lazy dog.» );
printf ( «%u\n» , $checksum );
?>

��. ����� �������� ������� md5() � sha1() .

Crc32 — ��������� CRC32 ��� ������


������� ���� � ��������� ����� �� ������ �� PDA.
��� �������� ����� ����� ������� ��� ����������� ����� CRC32.
����� �������� ������, ��� ������� ���������.
������������ � ����������� ����� ���������� ����������.
�� ���� � �������� ����������� ����� ��������� ����� �� PDA, �� ���
�� ����� ����������� �����, ���������� ��� ������������� ����� �� �������.
����� ���� ���� � ���������? � ��������� Encoding.UTF8
��������� �� PDA ���������� �� ��������� �� ���������� �����.
����� ������, ��� �� ��������� ����������� ����� ��� � ���, ����� ��� ���� �����.

�������� ���������� CRC32 ���������

public static uint CalculateCRC(System.IO.Stream stream)
<
stream.Position = 0;

const int buffer_size = 1024;
const uint POLYNOMIAL = 0xEDB88320;

uint result = 0xFFFFFFFF;
uint Crc32;

byte] buffer = new byte[buffer_size];
uint] table_CRC32 = new uint[256];

//
// ������ �� ������
//
int count = stream.Read(buffer, 0, buffer_size);

//
// ���������� CRC
//
while (count > 0)
<
for (int i = 0; i > 8)
^ table_CRC32[(buffer[i])
^ ((result) & 0x000000FF)];
>

Crc32 — ��������� 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.

���������� ����� ������.

�����

��� ��� ����� ����� ���������.

><
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 ;

CRC32Table [ i ] = dwCRC ;
>

������� ���� ����� ��� 256 ������� � ������ �������� ������, ����������� �� ������� � ������� ����������.

� ����������� �� ����� �������� �� ������ ������ ��� �� ������ ������� ����� ����������, ����� ��������� �������������� ������� ������ ���, ����� �� ������ ������� �������. ���� ��� ��� ������, ������ �������� ���� ��� � ��������� ����������, ���������� ���� ������ � ����, �� �����, ��� ��� ��� �������� ������, � ��������� � ���������� �������� ����� � �������. ���� � ����� 256 * 4 ���� ������ (��� �� ����� ���� �� �����), �� ����� �������� ���� ������� ��� ������������� ��������� ������������� �������.

��� ��� �� ���, ��� �������� ������� ������� �������������� �������������� ������������� ���� ������ 14 �������� ������ ��������� ��������� �������:

������� CRC32

���� ������� ������, �� ����� ��������� �� ������� GetCRC32. ��� ������� ��������� ���� ���� � ���������� ����������� �������� CRC32 (���� ������� ����������).

������, ��� ����� �������� — ��� ��, ��� ������� �������� ����������. ��� ��� �� ���, ��� �� �������� ���� �����������, ��� �� ��� ��� �� ����� ����� ���� �������, ������ ��������� �� ����� ������� � ������ ������ ��� (��� ���������� ��������� ������), ��������� ����� �� ����� ���� �������� ����� ���� ������� � �� �����, ������ ������� ���� �������. ����� ����, ������� � �������� ������ ���� ��� ���, �� ��� ���������� ������ ���, ����� ������� ����������, � ���� �� ����������� ��������� 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 ;
>

// 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 ��� ����� ����� �����, � ���� �������, �������� ���, ������� ��������� ����� ������� — � ���������������� ��� �� ���. ������ �� ������ �������� �������������� �������, ������� ����� ��������� ������ ����� ����� ����������.

// 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 == INVAL >) <
bException = true ;
dwSize = 0 ;
>
>

// SOMETHING SCREWED UP
catch ( . ) <
bException = true ;
>

��� ������� ���������� ������ CRC32ByFile, ������� �� �� ������ � ��� ������ ������������. ��� ���������� � ������ — ����� ����, ��� CRC32ByFile ������� ��������� ���� (�������, ��� �� � ��������), ����� ������� ������� �������� ��������� ����� � ��������� �� DWORD, ������� ������ ������������ ������. ������� ���������� true, ���� ��� �������.

��������� ��� �� ����� ���� ������ ���� � �������� ������ � ��� CRC32 ��������.

// OPEN THE SPECIFIED FILE
if ( ( hFile = CreateFile ( strFileName , GENERIC_READ ,
FILE_SHARE_READ , NULL , OPEN_EXISTING , FILE_ATTRIBUTE_NORMAL
| FILE_FLAG_SEQUENTIAL_SCAN , NULL ) ) == INVAL >) <
// THIS MEANS THAT WE HAVE AN ERROR
dwErrorCode = — 1 ;
>

// CALCULATE THE CRC32 SIGNATURE
else <
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.

������� ����������� ����� ����� �� CRC32: ��������� ���

������������. ���� ��� ���� ���, ���� ��� � ���, ��� ��������� �������� �����, �������������� ������������� ����������������� ����������� ����� �� CRC32 � �������������� ����� ����������� ������ �� ��������� ����� search, �� � ��������� �� ����� ��� �������. ��� ���, ������ �� ���. � ����� ����� ��� �������� ��������� ����������� � ������ �������, ���� � ����� ������ ��� �� � ��. ���� ������� �������!

�������� � C# 2008 ��� .NET 3.5, �� 4 ����� �� ��������!

08.11.2012, 00:49

�������� ������ �� COM-�����. ������� ����������� �����
������������! �������� ��������� � ����� ������� �� C# ������ �������� ����������� �����. 1. .

��� �� ���������. ������ ����������� �����
�������� �������� ��� �� ����� ���������. 1) ������������ ����� ������� ���� 8-�� ��� ��.

������ ����������� ����� �����
������� �������, ���������. ����������, ����������, ������� ������� ����������� ����� �����.

��� ������ ������������ ��� �� ������� �������� ����������� �����?
���� �������, �������������� �������������� �������� ��� �������� ������������ �����-��������.

08.11.2012, 10:23 2
08.11.2012, 13:55 [��] 3

Special-Owl, �� �� ������, �������. =)

�� ����� �� �� ��� ��� ���� ����� ���������? ��� ��������� � �������� �� ���? � ��� ������ array.Length?

08.11.2012, 14:27 4

��� ���������� ���� � ������� ��� �������� � ������������ ������.

���� �� �������, �� ����� ����� ����� ������� � �������� ���:

1)��������� ���������� 111111111111111111111111111 (32 �������, 0xFFFFFFFF)

2.1)�������� ���������(����� ��������� ����� ��� ������� ��� �������, �� � ����� ��� �����) ���� ����������� ���������� (last_byte = (byte)(result & 0xFF)) (��������� ���������, �� �� ����� ���� ��� �� �����, ������)

2.2)�������� ����������� ������ ������ �� 1 ���� (8 ��� (������)), �.�. ����, ��������, 32 �������, ����� 8 ����� � 24 �������.

2.3) ��������� �������� ����������� ��� � ����������� ���������� (� ������ ��� � 00000000111111111111111111111111) � ����������� ����� ��������.

2.3.1) ����� ��������� ������� ���������� ����� ���������� �������� ����������� ��� ���������� ����� ����������� ���������� � �������� ��������� ��������� �������.

2.3.2) �������� ��� — ��� ��������� ��������� ������������ ������ ���� ��������� �� �����, �.�.
0^0=0
1^1=0
1^0=1
0^1=1
�� � �������������� 1010^1100=0110

3) ���������� ����������������� ����������� ����������

������:
crc_table ��������� ��� ������ �� 254 ���������, ��������� ��������� �������� ����������� ���, ���������� ��� ����� �������, ����� �������� 1 ����. �.�. �������� 11111111 ��� ����� 255 (�� � ������ ���������� � ����)

��� ������ ��������� ����������� ����� CRC (CRC32 — CRC16 — CRC8)

��� ������ ������� ������� ��������� � ������. ����, ��� �� ����� CRC? ���� ������, ��� ���� �� �������������� �������� ����������� �����. ����������� ����� — ��� ����� �������� ����������� �������� ���������� �� ������� �������� ��� �������� �� ������� �����. ��������, ���� �� ���������� �������� — ������������� ���� ��������. ��� ����� ����������� ��� ���� ������������� ���������, � ���� ����� ����������� ������, �� � ����� ��������� ����������� 0, ���� �������� — �� 1. ��� ����� ����� �������������� ����� ����� ���������, � ������������ � �������� ����� ��������. ���� ��� ����������, ������ ��� �������� �������� ������, � ������������ ���������� ���� ��������.

�� ����� ������ ����������� ������� ������ — ����� ��������������� � ����������� �� ������, �.�. ��� ��������� ���������� ����� ���������, �������� ����� ����� �� ����������. ������� ���������� ��������� ����� «�����������» ��������, � ��� ����� CRC.

�� ����, CRC — ��� �� �����, � ��������� ������� ������ ������ ���������� (��������������� ���������) �� ���������, � ������ — ������� �� ������� ��������� �� ���������. ��� �� �����, CRC ����������� ����� �������� «����������� �����». � �������� CRC ������ ����� ������ ��� ���������. �� ����, ���� ���� �� ���� ��� ��������� ��������� ��������� ��� ��������, ����������� ����� ���� ���������, ������ �����������. ��� ������� ���� ����� ��������, ��� ��� �� ��������� ���������� ����������, ���������� �������� ��������� ��� �������� ��� ���.

������ ��� ���������� � ���������� CRC, ����������� ��� ������� ������.
��� ����� �������� ��������� ������ ���� �������. ��� ����������� ������������������ ����� ������������ �����.

��� �� ���������, �� ������� �� ������ ������ �������� ���������? ��� ��������� ����� ����� ����� �����, �� ������ ������������ �����, ������� 1 ����� — 8, 16 � 32 ����. ������ ��� ����� �������, ���� ���������� �������� ������ � �������, � �� � ������.

���������-�������� ������ ���������� � ���� �������� (����������) ��� ����� �������: x^8 + x^2 + x^1 + x^0. ����� ������� ����� «x» �������� ������� ����-������� � �����, ������� � �������, � ������� ������ ��������� �� ������� �������� � ������������� ��� ������������� �����. �� ���� ���������� ����� ����� — ��� �� ��� ���� ��� (1)00000111 � �������� ������� ���������, ��� 7 � ����������. � ������� � ������ ��������������� ������� ������ �����.
��� ��� ������: x^16 + x^15 + x^2 + x^0 = (1)1000000000000101″ = 0x8005 = 32773.
������ ������������ ����� ����������� ���������� ��� ������ ����� CRC.

��� ��� �� ������� ����������� �����? ���������� ������� ����� — ������� ��������� �� ������� «� ���» — � ��� ����������� � ����� ���������� ���������� ���������� �, ��������������, ��������� ������� CRC. �� ���������� ������ ������� �����.


� ����� ����, ������� ����� �� ��������� ����������� �� ������ ���������:
1) �������� ������ (�������), ����������� ������, ������ �� ����� ����������� ��������;
2) �������� ��������� ����������� ������ � ������� ��������, � ����������, ������ ����� �������� ��������;
3) � ������� ������ �������� ��������� ���� ������� ��� ���������, � �� �������� ������� �������� ����������� ���� ���;
4) ���� ���������� ��� ����� «1», �� ������������ �������� ����� (�������� XOR, ����������� ���) � ��� �������� ��������, ������� ������������� �������� � ��������;
5) ���� � ��������� ��� ���� ����, ��������� � ���� 3);
6) ����� ��� ���� ��������� ��������� � ������� � ���� ���������� ���� ����������, � �������� ������� ������� �� �������, ������� � �������� ����������� ������ CRC.

������� ������������ ������� �������� ������������������ ����� �� ����� (1)00000111, ��� ��������� x^8 + x^2 + x^1 + x^0.

�������� ��� ���� �������������� �������. ��� �� ����� ��������, ��������� ����� ��������� �� ����� �����. ��� ��� �������? ���������� ��� ����������� ���������, ������� ������������ ��� ���������� CRC. ��������, ��� CRC32 ��� ����� ���� ����� 0x04C11DB7, � ��� CRC16 ��� ����� ���� 0x8005.
����� ����, � ������� � ������ ���������� ����� �������� �� ����, � �����-�� ������ �����.

����� ��� �������� ��������������� ����� ������� ��������� ����������� ����� CRC ����� ������ �� �����-�� ������ �����.

� ���������. ����� ��������� ��� ������ � ������� ����� ���������� ��� ������� ����� «�����», ��� � ��������, �������.

�� ��������� ����� ���������������, ������� ������� ������� �� ����� Basic .NET, ������� ����� ������������ ����������� ����� CRC, �������� ��� ����������, ������� � ������ ����, � ��������� �������� CRC � ���� 32-���������� ������������ �����.

Public Shared Function GetCrc(ByVal bytes As Byte(), ByVal poly As UInteger, Optional ByVal w >
Dim w >
‘��������� ��������� width ������ (������ � ������):
ReDim Preserve bytes(bytes.Length — 1 + widthInBytes)

‘������ ������� ����� �� ���������:
Dim msgFifo As New Queue(Of Boolean)(bytes.Count * 8 — 1)
For Each b As Byte In bytes
Dim ba As New BitArray()
If reverseBytes Then
For i As Integer = 0 To 7
msgFifo.Enqueue(ba(i))
Next
Else
For i As Integer = 7 To 0 Step -1
msgFifo.Enqueue(ba(i))
Next
End If
Next

‘������ ������� �� ����� ���������� ���������� ��������:
Dim initBytes As Byte() = BitConverter.GetBytes(initReg)
Dim initBytesReversed As IEnumerable(Of Byte) = (From b As Byte In initBytes Take widthInBytes).Reverse
Dim initFifo As New Queue(Of Boolean)(width — 1)
For Each b As Byte In initBytesReversed
Dim ba As New BitArray()
If Not reverseBytes Then
For i As Integer = 0 To 7
initFifo.Enqueue(ba(i))
Next
Else
For i As Integer = 7 To 0 Step -1
initFifo.Enqueue(ba(i))
Next
End If
Next

‘����� � XOR:
Dim register As UInteger = 0 ‘��������� width-��������� ������� ������.
Do While msgFifo.Count > 0

Dim poppedBit As Integer = CInt(register >> (width — 1)) And 1 ‘���������� ����� ������� ��������.

Dim shiftedBit As Byte = Convert.ToByte(msgFifo.Dequeue)
If initFifo.Count > 0 Then
Dim b As Byte = Convert.ToByte(initFifo.Dequeue)
shiftedBit = shiftedBit Xor b
End If

register = register > (32 — width)) ‘��������� ������� �������.

crc32

(PHP 4 >= 4.0.1, PHP 5, PHP 7)

crc32 � ��������� ������� CRC32 ��� ������

��������

������� ��������� ����������� ���������� ��� 32-������ ��������� (CRC32) ��� ������ str . ��� ������ ������������ ��� �������� ����������� ������������ ������.

� PHP ����� ����� ����� ����, ������� ������ ����������� ����� ����� ��������� �������������� �� 32-������ ����������. �� 64-������ ���������� ��� ���������� crc32() ����� �������������� ������.

������� ��� ����� ������������ ������ «%u» � �������� sprintf() ��� printf() ��� ��������� ���������� ������������� ����� crc32() ��� �����.

��� ������������������ ������������� ����� �� ������ ������������ ��� ������ «%x» � �������� sprintf() � printf() , ��� �� ������� ����������� dechex() . ��� ���� ������� ����� ����������� � ����������� ���������� crc32() � ���������� �����.

��� ������������� 64-������ �������� ����� ��������������� ����������� ���������� ������������� ����� ��� ������� ��������, �� ��� ������ ����������������� �������������, �������� �������������� 0xFFFFFFFF######## �������� ��� ���. ��� ��� ����������������� ������������� �������� ����� ��������������, ���� ������ �� ������ ���, ���� ���� ��� ������ ������ ��������� ������������ �������� � 50% ������� ��� �������� � 32-������ �� 64-������ ���������.

����������� �����, �������� ���������� ����� ����� ���� �� ����� ������ ����� � ����� ���� ���������� ����� ����������������� ������������� (��� �������� ������ md5() ).

����� ��������������� ����� ����� ����� �������� � �������������� ������� hash() . hash(«crc32b», $str) ������ �� �� ������, ��� � str_pad(dechex(crc32($str)), 8, ‘0’, STR_PAD_LEFT) .

������ ����������

������������ ��������

���������� ����������� ����� crc32 ������ str � ���� ������ �����.

�������

������ #1 ����� ����������� ����� CRC32

���� ������ ������������ ����� ����������� ����������� ����� � ������� ������� printf() :

�������� �����

  • hash() — ���������� ���-��� (�������� ���������)
  • md5() — ���������� MD5-��� ������
  • sha1() — ���������� SHA1-��� ������

User Contributed Notes 23 notes

This function returns an unsigned integer from a 64-bit Linux platform. It does return the signed integer from other 32-bit platforms even a 64-bit Windows one.

The reason is because the two constants PHP_INT_SIZE and PHP_INT_MAX have different values on the 64-bit Linux platform.

I’ve created a work-around function to handle this situation.


function get_signed_int ( $in ) <
$int_max = pow ( 2 , 31 )- 1 ;
if ( $in > $int_max ) <
$out = $in — $int_max * 2 — 2 ;
>
else <
$out = $in ;
>
return $out ;
>
?>

Hope this helps.

The khash() function by sukitsupaluk has two problems, it does not use all 62 characters from the $map set and when corrected it then produces different results on 64-bit compared to 32-bit PHP systems.

Here is my modified version :

/**
* Small sample convert crc32 to character map
* Based upon http://www.php.net/manual/en/function.crc32.php#105703
* (Modified to now use all characters from $map)
* (Modified to be 32-bit PHP safe)
*/
function khash ( $data )
<
static $map = «0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ» ;
$hash = bcadd ( sprintf ( ‘%u’ , crc32 ( $data )) , 0x100000000 );
$str = «» ;
do
<
$str = $map [ bcmod ( $hash , 62 ) ] . $str ;
$hash = bcdiv ( $hash , 62 );
>
while ( $hash >= 1 );
return $str ;
>
//————————————————————————————
$test = array( null , true , false , 0 , «0» , 1 , «1» , «2» , «3» , «ab» , «abc» , «abcd» ,
«abcde» , «abcdefoo» , «248840027» , «1365848013» , // time()
«9223372035488927794» , // PHP_INT_MAX-time()
«901131979» , // mt_rand()
«Sat, 13 Apr 2013 10:13:33 +0000» // gmdate(‘r’)
);
$out = array();
foreach ( $test as $s )
<
$out [] = khash ( $s ) . «: » . $s ;
>
print «

khash() — maps a crc32 result into a (62-character) result

$pefile

» ;
ob_end_flush ();
flush ();
highlight_file ( $pefile );
print » » ;
//————————————————————————————
/* CURRENT output
array(19) <
[0]=>
string(8) «4GFfc4: »
[1]=>
string(9) «76nO4L: 1»
[2]=>
string(8) «4GFfc4: »
[3]=>
string(9) «9aGcIp: 0»
[4]=>
string(9) «9aGcIp: 0»
[5]=>
string(9) «76nO4L: 1»
[6]=>
string(9) «76nO4L: 1»
[7]=>
string(9) «5b8iNn: 2»
[8]=>
string(9) «6HmfFN: 3»
[9]=>
string(10) «7ADPD7: ab»
[10]=>
string(11) «5F0aUq: abc»
[11]=>
string(12) «92kWw9: abcd»
[12]=>
string(13) «78hcpf: abcde»
[13]=>
string(16) «9eBVPB: abcdefoo»
[14]=>
string(17) «5TjOuZ: 248840027»
[15]=>
string(18) «5eNliI: 1365848013»
[16]=>
string(27) «4Q00e5: 9223372035488927794»
[17]=>
string(17) «6DUX8V: 901131979»
[18]=>
string(39) «5i2aOW: Sat, 13 Apr 2013 10:13:33 +0000»
>
*/
//————————————————————————————

I see a lot of function for crc32_file, but for php version >= 5.1.2 don’t forget you can use this :

function crc32_file ( $filename )
<
return hash_file ( ‘CRC32’ , $filename , FALSE );
>
?>

Using crc32(file_get_contents($filename)) will use too many memory on big file so don’t use it.

A faster way I’ve found to return CRC values of larger files, is instead of using the file()/implode() method used below, is to us file_get_contents() (PHP 4 >= 4.3.0) which uses memory mapping techniques if supported by your OS to enhance performance. Here’s my example function:

// $file is the path to the file you want to check.
function file_crc ( $file )
<
$file_string = file_get_contents ( $file );

$crc = crc32 ( $file_string );

return sprintf ( «%u» , $crc );
>

$file_to_crc = / home / path / to / file . jpg ;

echo file_crc ( $file_to_crc ); // Outputs CRC value for given file.
?>

I’ve found in testing this method is MUCH faster for larger binary files.

bit by bit crc32 computation

function bitbybit_crc32 ( $str , $first_call = false )<

//reflection in 32 bits of crc32 polynomial 0x04C11DB7
$poly_reflected = 0xEDB88320 ;

//=0xFFFFFFFF; //keep track of register value after each call
static $reg = 0xFFFFFFFF ;

//initialize register on first call
if( $first_call ) $reg = 0xFFFFFFFF ;

$n = strlen ( $str );
$zeros = $n 4 ? $n : 4 ;

//xor first $zeros=min(4,strlen($str)) bytes into the register
for( $i = 0 ; $i $zeros ; $i ++)
$reg ^= ord ( $str < $i >) $i * 8 ;

//put in enough zeros at the end
for( $i = 0 ; $i $zeros * 8 ; $i ++)
$reg =( $reg >> 1 & 0x7FFFFFFF )^( $reg & 1 )* $poly_reflected ;

//xor the register with 0xFFFFFFFF
return

$str = «123456789» ; //whatever
$blocksize = 4 ; //whatever

for( $i = 0 ; $i strlen ( $str ); $i += $blocksize ) $crc = bitbybit_crc32 ( substr ( $str , $i , $blocksize ),! $i );

Implementation crc64() in php 64bit

/**
* @return array
*/
function crc64Table ()
<
$crc64tab = [];

// ECMA polynomial
$poly64rev = ( 0xC96C5795 32 ) | 0xD7870F42 ;

// ISO polynomial
// $poly64rev = (0xD8 for ( $i = 0 ; $i 256 ; $i ++)
<
for ( $part = $i , $bit = 0 ; $bit 8 ; $bit ++) <
if ( $part & 1 ) <
$part = (( $part >> 1 ) &

( 0x8 60 )) ^ $poly64rev ;
> else <
$part = ( $part >> 1 ) &

$crc64tab [ $i ] = $part ;
>

/**
* @param string $string
* @param string $format
* @return mixed
*
* Formats:
* crc64(‘php’); // afe4e823e7cef190
* crc64(‘php’, ‘0x%x’); // 0xafe4e823e7cef190
* crc64(‘php’, ‘0x%X’); // 0xAFE4E823E7CEF190
* crc64(‘php’, ‘%d’); // -5772233581471534704 signed int
* crc64(‘php’, ‘%u’); // 12674510492238016912 unsigned int
*/
function crc64 ( $string , $format = ‘%x’ )
<
static $crc64tab ;

if ( $crc64tab === null ) <
$crc64tab = crc64Table ();
>

for ( $i = 0 ; $i strlen ( $string ); $i ++) <
$crc = $crc64tab [( $crc ^ ord ( $string [ $i ])) & 0xff ] ^ (( $crc >> 8 ) &

return sprintf ( $format , $crc );
>


This function returns the same int value on a 64 bit mc. like the crc32() function on a 32 bit mc.

The crc32_combine() function provided by petteri at qred dot fi has a bug that causes an infinite loop, a shift operation on a 32-bit signed int might never reach zero. Replacing the function gf2_matrix_times() with the following seems to fix it:

function gf2_matrix_times ( $mat , $vec )
<
$sum = 0 ;
$i = 0 ;

while ( $vec ) <
if ( $vec & 1 ) <
$sum ^= $mat [ $i ];
>
$vec = ( $vec >> 1 ) & 0x7FFFFFFF ;
$i ++;
>
return $sum ;
>
?>

Otherwise, it’s probably the best solution if you can’t use hash_file(). Using a 1meg read buffer, the function only takes twice as long to process a 300meg files than hash_file() in my test.

Dealing with 32 bit unsigned values overflowing 32 bit php signed values can be done by adding 0x10000000 to any unexpected negative result, rather than using sprintf.

$i = crc32(‘1’);
printf(«%u\n», $i);
if (0 > $i)
<
// Implicitly casts i as float, and corrects this sign.
$i += 0x100000000;
>
var_dump($i);

The crc32() function can return a signed integer in certain environments. Assuming that it will always return an unsigned integer is not portable.

Depending on your desired behavior, you should probably use sprintf() on the result or the generic hash() instead. Also note that integer arithmetic operators do not have the precision to work correctly with the integer output.

/* OLDCRC */
define ( ‘POLY64REV’ , «d800000000000000» );
define ( ‘INITIALCRC’ , «0000000000000000» );
define ( ‘TABLELEN’ , 256 );
/* NEWCRC */
// define(‘POLY64REV’, «95AC9329AC4BC9B5»);
// define(‘INITIALCRC’, «FFFFFFFFFFFFFFFF»);

if( function_exists ( ‘gmp_init’ )) <
class CRC64 <

private static $CRCTable = array();

public static function encode ( $seq )<

$crc = gmp_init ( INITIALCRC , 16 );
$init = FALSE ;
$poly64rev = gmp_init ( POLY64REV , 16 );

if (! $init )
<
$init = TRUE ;
for ( $i = 0 ; $i TABLELEN ; $i ++)
<
$part = gmp_init ( $i , 10 );
for ( $j = 0 ; $j 8 ; $j ++)
<
if ( gmp_strval ( gmp_and ( $part , «0x1» )) != «0» ) <
// if (gmp_testbit($part, 1))< /* PHP 5 >= 5.3.0, untested */
$part = gmp_xor ( gmp_div_q ( $part , «2» ), $poly64rev );
> else <
$part = gmp_div_q ( $part , «2» );
>
>
self :: $CRCTable [ $i ] = $part ;
>
>

for( $k = 0 ; $k strlen ( $seq ); $k ++) <
$tmp_gmp_val = gmp_init ( ord ( $seq [ $k ]), 10 );
$tableindex = gmp_xor ( gmp_and ( $crc , «0xff» ), $tmp_gmp_val );
$crc = gmp_div_q ( $crc , «256» );
$crc = gmp_xor ( $crc , self :: $CRCTable [ gmp_strval ( $tableindex , 10 )]);
>

$res = gmp_strval ( $crc , 16 );

return $res ;
>
>
> else <
die( «Please install php-gmp package. » );
>
?>

Here is a tested and working CRC16-Algorithm:

function crc16 ( $string ) <
$crc = 0xFFFF ;
for ( $x = 0 ; $x strlen ( $string ); $x ++) <
$crc = $crc ^ ord ( $string [ $x ]);
for ( $y = 0 ; $y 8 ; $y ++) <
if (( $crc & 0x0001 ) == 0x0001 ) <
$crc = (( $crc >> 1 ) ^ 0xA001 );
> else < $crc = $crc >> 1 ; >
>
>
return $crc ;
>
?>

Regards,
Mario

A faster implementation of modbus CRC16

function crc16($data)
<
$crc = 0xFFFF;
for ($i = 0; $i >= 1;
$crc ^= 0xA001;
>
else
$crc >>= 1;
>
>
return $crc;
>

I made this code to verify Transmition with Vantage Pro2 ( weather station ) based on CRC16-CCITT standard.

// CRC16-CCITT validator
$crc_table = array(
0x0 , 0x1021 , 0x2042 , 0x3063 , 0x4084 , 0x50a5 , 0x60c6 , 0x70e7 ,
0x8108 , 0x9129 , 0xa14a , 0xb16b , 0xc18c , 0xd1ad , 0xe1ce , 0xf1ef ,
0x1231 , 0x210 , 0x3273 , 0x2252 , 0x52b5 , 0x4294 , 0x72f7 , 0x62d6 ,
0x9339 , 0x8318 , 0xb37b , 0xa35a , 0xd3bd , 0xc39c , 0xf3ff , 0xe3de ,
0x2462 , 0x3443 , 0x420 , 0x1401 , 0x64e6 , 0x74c7 , 0x44a4 , 0x5485 ,
0xa56a , 0xb54b , 0x8528 , 0x9509 , 0xe5ee , 0xf5cf , 0xc5ac , 0xd58d ,
0x3653 , 0x2672 , 0x1611 , 0x630 , 0x76d7 , 0x66f6 , 0x5695 , 0x46b4 ,
0xb75b , 0xa77a , 0x9719 , 0x8738 , 0xf7df , 0xe7fe , 0xd79d , 0xc7bc ,
0x48c4 , 0x58e5 , 0x6886 , 0x78a7 , 0x840 , 0x1861 , 0x2802 , 0x3823 ,
0xc9cc , 0xd9ed , 0xe98e , 0xf9af , 0x8948 , 0x9969 , 0xa90a , 0xb92b ,
0x5af5 , 0x4ad4 , 0x7ab7 , 0x6a96 , 0x1a71 , 0xa50 , 0x3a33 , 0x2a12 ,
0xdbfd , 0xcbdc , 0xfbbf , 0xeb9e , 0x9b79 , 0x8b58 , 0xbb3b , 0xab1a ,
0x6ca6 , 0x7c87 , 0x4ce4 , 0x5cc5 , 0x2c22 , 0x3c03 , 0xc60 , 0x1c41 ,
0xedae , 0xfd8f , 0xcdec , 0xddcd , 0xad2a , 0xbd0b , 0x8d68 , 0x9d49 ,
0x7e97 , 0x6eb6 , 0x5ed5 , 0x4ef4 , 0x3e13 , 0x2e32 , 0x1e51 , 0xe70 ,
0xff9f , 0xefbe , 0xdfdd , 0xcffc , 0xbf1b , 0xaf3a , 0x9f59 , 0x8f78 ,
0x9188 , 0x81a9 , 0xb1ca , 0xa1eb , 0xd10c , 0xc12d , 0xf14e , 0xe16f ,
0x1080 , 0xa1 , 0x30c2 , 0x20e3 , 0x5004 , 0x4025 , 0x7046 , 0x6067 ,
0x83b9 , 0x9398 , 0xa3fb , 0xb3da , 0xc33d , 0xd31c , 0xe37f , 0xf35e ,
0x2b1 , 0x1290 , 0x22f3 , 0x32d2 , 0x4235 , 0x5214 , 0x6277 , 0x7256 ,
0xb5ea , 0xa5cb , 0x95a8 , 0x8589 , 0xf56e , 0xe54f , 0xd52c , 0xc50d ,
0x34e2 , 0x24c3 , 0x14a0 , 0x481 , 0x7466 , 0x6447 , 0x5424 , 0x4405 ,
0xa7db , 0xb7fa , 0x8799 , 0x97b8 , 0xe75f , 0xf77e , 0xc71d , 0xd73c ,
0x26d3 , 0x36f2 , 0x691 , 0x16b0 , 0x6657 , 0x7676 , 0x4615 , 0x5634 ,
0xd94c , 0xc96d , 0xf90e , 0xe92f , 0x99c8 , 0x89e9 , 0xb98a , 0xa9ab ,
0x5844 , 0x4865 , 0x7806 , 0x6827 , 0x18c0 , 0x8e1 , 0x3882 , 0x28a3 ,
0xcb7d , 0xdb5c , 0xeb3f , 0xfb1e , 0x8bf9 , 0x9bd8 , 0xabbb , 0xbb9a ,
0x4a75 , 0x5a54 , 0x6a37 , 0x7a16 , 0xaf1 , 0x1ad0 , 0x2ab3 , 0x3a92 ,
0xfd2e , 0xed0f , 0xdd6c , 0xcd4d , 0xbdaa , 0xad8b , 0x9de8 , 0x8dc9 ,
0x7c26 , 0x6c07 , 0x5c64 , 0x4c45 , 0x3ca2 , 0x2c83 , 0x1ce0 , 0xcc1 ,
0xef1f , 0xff3e , 0xcf5d , 0xdf7c , 0xaf9b , 0xbfba , 0x8fd9 , 0x9ff8 ,
0x6e17 , 0x7e36 , 0x4e55 , 0x5e74 , 0x2e93 , 0x3eb2 , 0xed1 , 0x1ef0 );

$test = chr ( 0xC6 ). chr ( 0xCE ). chr ( 0xA2 ). chr ( 0x03 ); // CRC16-CCITT = 0xE2B4
genCRC ( $test );

function genCRC (& $ptr )
<
$crc = 0x0000 ;
$crc_table = $GLOBALS [ ‘crc_table’ ];
for ( $i = 0 ; $i strlen ( $ptr ); $i ++)
$crc = $crc_table [(( $crc >> 8 ) ^ ord ( $ptr [ $i ]))] ^ (( $crc 8 ) & 0x00FFFF );
return $crc ;
>
?>

625 KB/s on my 2.2GHz Turion
far slower than hash_file(‘crc32b’,’filename.ext’)
function crc32_file ( $filename )
<
$f = @ fopen ( $filename , ‘rb’ );
if (! $f ) return false ;

static $CRC32Table , $Reflect8Table ;
if (!isset( $CRC32Table ))
<
$Polynomial = 0x04c11db7 ;
$topBit = 1 31 ;

for( $i = 0 ; $i 256 ; $i ++)
<
$remainder = $i 24 ;
for ( $j = 0 ; $j 8 ; $j ++)
<
if ( $remainder & $topBit )
$remainder = ( $remainder 1 ) ^ $Polynomial ;
else $remainder = $remainder 1 ;
>

$CRC32Table [ $i ] = $remainder ;

if (isset( $Reflect8Table [ $i ])) continue;
$str = str_pad ( decbin ( $i ), 8 , ‘0’ , STR_PAD_LEFT );
$num = bindec ( strrev ( $str ));
$Reflect8Table [ $i ] = $num ;
$Reflect8Table [ $num ] = $i ;
>
>

$remainder = 0xffffffff ;
while ( $data = fread ( $f , 1024 ))
<
$len = strlen ( $data );
for ( $i = 0 ; $i $len ; $i ++)
<
$byte = $Reflect8Table [ ord ( $data [ $i ])];
$index = (( $remainder >> 24 ) & 0xff ) ^ $byte ;
$crc = $CRC32Table [ $index ];
$remainder = ( $remainder 8 ) ^ $crc ;
>
>

$str = decbin ( $remainder );
$str = str_pad ( $str , 32 , ‘0’ , STR_PAD_LEFT );
$remainder = bindec ( strrev ( $str ));
return $remainder ^ 0xffffffff ;
>
?>

= microtime ();
echo dechex ( crc32_file ( ‘filename.ext’ )). «\n» ;
$b = microtime ();
echo array_sum ( explode ( ‘ ‘ , $b )) — array_sum ( explode ( ‘ ‘ , $a )). «\n» ;
?>
Output:
ec7369fe
2.384134054184 (or similiar)

For those who want a more familiar return value for the function:

function strcrc32 ( $text ) <
$crc = crc32 ( $text );
if ( $crc & 0x80000000 ) <
$crc ^= 0xffffffff ;
$crc += 1 ;
$crc = — $crc ;
>
return $crc ;
>
?>

And to show the result in Hex string:

function int32_to_hex ( $value ) <
$value &= 0xffffffff ;
return str_pad ( strtoupper ( dechex ( $value )), 8 , «0» , STR_PAD_LEFT );
>
?>

MODBUS RTU, CRC16,
input-> modbus rtu string
output -> 2bytes string, in correct modbus order

function crc16 ( $string , $length = 0 )<


$auchCRCHi =array( 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 );
$auchCRCLo =array( 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 );
$length =( $length 0 ? strlen ( $string ): $length );
$uchCRCHi = 0xFF ;
$uchCRCLo = 0xFF ;
$uIndex = 0 ;
for ( $i = 0 ; $i $length ; $i ++) <
$uIndex = $uchCRCLo ^ ord ( substr ( $string , $i , 1 ));
$uchCRCLo = $uchCRCHi ^ $auchCRCHi [ $uIndex ];
$uchCRCHi = $auchCRCLo [ $uIndex ] ;
>
return( chr ( $uchCRCLo ). chr ( $uchCRCHi ));
>
?>

small sample convert crc32 to character map

function khash ( $data ) <
static $map = «0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ» ;
$hash = crc32 ( $data )+ 0x100000000 ;
$str = «» ;
do <
$str = $map [ 31 + ( $hash % 31 )] . $str ;
$hash /= 31 ;
> while( $hash >= 1 );
return $str ;
>
$test = array( null , TRUE , FALSE , 0 , «0» , 1 , «1» , «2» , «3» , «ab» , «abc» , «abcd» , «abcde» , «abcdefoo» );
$out = array();
foreach( $test as $s )
<
$out []= khash ( $s ). «: » . $s ;
>
var_dump ( $out );

/*
output:
array
0 => string ‘zVvOYTv: ‘ (length=9)
1 => string ‘xKDKKL8: 1’ (length=10)
2 => string ‘zVvOYTv: ‘ (length=9)
3 => string ‘zOKCQxh: 0’ (length=10)
4 => string ‘zOKCQxh: 0’ (length=10)
5 => string ‘xKDKKL8: 1’ (length=10)
6 => string ‘xKDKKL8: 1’ (length=10)
7 => string ‘AFSzIAO: 2’ (length=10)
8 => string ‘BXGSvQJ: 3’ (length=10)
9 => string ‘xZWOQSu: ab’ (length=11)
10 => string ‘AVAwHOR: abc’ (length=12)
11 => string ‘zKASNE1: abcd’ (length=13)
12 => string ‘xLCTOV7: abcde’ (length=14)
13 => string ‘zQLzKMt: abcdefoo’ (length=17)

I used the abs value of this function on a 32-bit system. When porting the code to a 64-bit system I�ve found that the value is different. The following code has the same outcome on both systems.
= abs ( crc32 ( $string ));
if( $crc & 0x80000000 ) <
$crc ^= 0xffffffff ;
$crc += 1 ;
>

/* Old solution
* $crc = abs(crc32($string))
*/

I needed the crc32 of a file that was pretty large, so I didn’t want to read it into memory.
So I made this:

[ ‘__crc32_table’ ]=array(); // Lookup table array
__crc32_init_table ();

function __crc32_init_table () < // Builds lookup table array
// This is the official polynomial used by
// CRC-32 in PKZip, WinZip and Ethernet.
$polynomial = 0x04c11db7 ;

// 256 values representing ASCII character codes.
for( $i = 0 ; $i 0xFF ;++ $i ) <
$GLOBALS [ ‘__crc32_table’ ][ $i ]=( __crc32_reflect ( $i , 8 ) 24 );
for( $j = 0 ; $j 8 ;++ $j ) <
$GLOBALS [ ‘__crc32_table’ ][ $i ]=(( $GLOBALS [ ‘__crc32_table’ ][ $i ] 1 ) ^
(( $GLOBALS [ ‘__crc32_table’ ][ $i ] & ( 1 31 ))? $polynomial : 0 ));
>
$GLOBALS [ ‘__crc32_table’ ][ $i ] = __crc32_reflect ( $GLOBALS [ ‘__crc32_table’ ][ $i ], 32 );
>
>

// Swap bit 0 for bit 7, bit 1 for bit 6, etc.
for( $i = 1 ; $i $ch + 1 );++ $i ) <
if( $ref & 1 ) $value |= ( 1 $ch — $i ));
$ref = (( $ref >> 1 ) & 0x7fffffff );
>
return $value ;
>

function __crc32_string ( $text ) < // Creates a CRC from a text string
// Once the lookup table has been filled in by the two functions above,
// this function creates all CRCs using only the lookup table.

// You need unsigned variables because negative values
// introduce high bits where zero bits are required.
// PHP doesn’t have unsigned integers:
// I’ve solved this problem by doing a ‘&’ after a ‘>>’.

// Start out with all bits set high.
$crc = 0xffffffff ;
$len = strlen ( $text );

// Perform the algorithm on each character in the string,
// using the lookup table values.
for( $i = 0 ; $i $len ;++ $i ) <
$crc =(( $crc >> 8 ) & 0x00ffffff ) ^ $GLOBALS [ ‘__crc32_table’ ][( $crc & 0xFF ) ^ ord ( $text < $i >)];
>

// Exclusive OR the result with the beginning value.
return $crc ^ 0xffffffff ;
>

function __crc32_file ( $name ) < // Creates a CRC from a file
// Info: look at __crc32_string

// Start out with all bits set high.
$crc = 0xffffffff ;

if(( $fp = fopen ( $name , ‘rb’ ))=== false ) return false ;

// Perform the algorithm on each character in file
for(;;) <
$i =@ fread ( $fp , 1 );
if( strlen ( $i )== 0 ) break;
$crc =(( $crc >> 8 ) & 0x00ffffff ) ^ $GLOBALS [ ‘__crc32_table’ ][( $crc & 0xFF ) ^ ord ( $i )];
>

// Exclusive OR the result with the beginning value.
return $crc ^ 0xffffffff ;
>
?>

���������� ����������/����������� ���������� ���

������� �������� ��� ���������� CRC. ��������� �� ���� ���������� ������������ � Ross Williams [1] .

����������

CRC-4 [ ������� ]

CRC-8 [ ������� ]

CRC-16 [ ������� ]

CRC-CCITT ���������� �� ������������� CRC-16, ��� ��� ���������� ������ ������� � ������� ������.

CRC-32 [ ������� ]

�������� CRC32 ������� �� ����������� �������� 0xEDB88320 (���������� ����������� �������� 0x04C11DB7).

����������� ���������� �� C [ ������� ]

�������� ��������������� ��������� ������� ������������ ������� CRC:

  • ������������ �������� � ��������� ������ ������:

Crc32 — ��������� CRC32 ��� ������

������� ����������� ���� ���������� ������� [3] . � ������������ ���������� CRC ���������������� ������ � ����������� �� ���������: Cyclic Redundancy Code ��� Cyclic Redundancy Check [4] . ��� ������ ������������ �������� �������������� ������� ����������� �����, ��� ������ � ���������� ���������� ����� �������� ��� ���-�������.


���������������� �����������

������ ������� �������� ����� � ���������� ����������� �������� ������� �� ��������� ����������� ��. � �������, ��� � ������������ ����� �������� ���� ����� � ��������� ���� ����������� ����������� �������� ����������� � ��� ����-��������. ������������� � � �� ������� �� �������������� ���������, ��� ��� ���������� �������� ������������� �� �������� ����� ������� ����������� �� ���������. ����� � ���� ������� ��������� ��������������� ������ ����������, �������������� � 1968 ����. ��� ��������, �� ������������ ���������� ������� ������ ����� ��� �����, � �� ��� ���� ������������ � �������� �����������, �������������� ����� RS-������������ ������. ����� ����: ������ ������� ��������� �� ������ ���������� �������, �� � ���������� �������� ������� ������� (���� ����� ������).

�� ������ �� ����� �� ���� ��������� ��������� ������. ������ ����������� ������ ����� �������� ����������� ����������������, � �������� ���������� ���� ���������, ������� �� ������ �������� ��� �������� �����-������ ���������; ��������� �� ������ � ���������� ������� �������� �������� ���������� �� ���������� ����������� �������. � � ���� �������� ����� ������� �������� ��������� ���������, ������������ ����������� �����. CRC ��� ������ ����� �������� ��� �������� �����: ��������� ������� ��������, �������� ���������� � ��� �������������� �������������� ������� �� ������ �������� ����������� ����� ���������� �� �������� ������������.

����������� �����

� ����� ����� ����� ���� ����������� ����� ������������ ����� ��������� ��������, ����������� �� ������������ ����� �� ������ ����������� ���������. ����������� ���������� ��� ��������������� ����������� ������������ � ����� ��������� � ����� �������� ������. �� ����������� ������� ������� ����� �������� ���������� ����������� �����: ��������������, ��������� ����� ����������� ��������� ������������ �������� ������.

��� �������� ������� �� ��������� ������, ����������, ����� ���������� ��������� �������� ���������� ���������� ������ ������� �����������: ������������� �������, ������ �������� ������� � ������ ������. �������� �������� � ���, ��� ��� ������� ��������������� ���-������� � ����������� ����� ������� ������ � ��������� �������� � ��������� ������������ �� ������ �������� CRC. ���� �������� � ����������� ����� �� ����� ����� �����, ����������� ������� � ��������������� �������� ������, � ����� ��������� ��������� �������� ������.

�������������� ��������

�������� CRC ���������� �� ��������� ������� � �������� �������� �����������, �� ���� ����������� ��� �������� ����� . �������� CRC �������� �� ���� �������� �� ������� ����������, ���������������� ������� ������, �� ����� ������������� ����������� ���������.

������ �������� ������������������ ����� ������� ���������� �������������� �������� ������� , ������������������ ������������� �������� ������������ ����� �������� ������������������. ��������, ������������������ ����� 1011010 ������������� ����������:

���������� ��������� ����������� ������� ������� ����� , ��� ��������� � ������ ���� �������� ������������������� ����� .

�������� ����������� ����� � ��������� � ����������� ����������� G(x) ������� N ������������ ��� ������� ������������������ ����� N, �������������� ��������� R(x), ������������ � ������� ��� ������� ���������� P(x), ��������������� ������� ����� ���, �� ��������� G(x):

� ���������, �������������� �������� CRC. � ���������, ������������ �������� ������������ ������� ������. � ����������� ���������. � ������� ������������ ����������.

��������� �������������� ������������� ������� ����� � ������� ������������������, ��� �������� �������� ����������� ��� �������� ������� �������������������.

��� ������� � �������� ��������� ���������� �� ����������� ������� G(x) ������� N ����� �������� 2 N ��������� �������� �� �������. G(x) ������ �������� ������������ �����������. ������ ��� ��������� � ������������ � ������������ � ���-������� � ��������� ������� ����������� ����������.

��� �� �����, ���������� ��������� ������������������� ���������� �����������, ���������� �������� ��������������� � ��������������� ���������� (����������� ����� ��������, �������� ����������). � ������ ��������� ��������� �� ���, � ����� ��������������� ���������� �� ����� ��.

���������� CRC

��������� ���������

������ � ������������ ����������� ����� CRC, � ������ ������� ����� ��������� � ��������-����������. ���������� �������� ��������� �����������, ����������� � ������������ cyclic reduntancy code; ������ �� ��� ������� � ����� ������.

������ ���������� ����������� ��������� ���������� ����������� ����� �������� ������ �����, ��� ��������� ���������� ��������� � �������������� �����, ������������ ��� ���������� ���������� �������� ����. ��� ���� ����������� ����������� ��, ��� ������ ����� � ������� ����������� ����������� ����� �������� ���������. �� �������� ����� ����� �������������� 8, 16 � 32 � ������� �����, ��� �������� ���������� ������������ ����������� ����������� �������������� �������.

� ��������� ��������, ������ ��� �������� ������������ �������� � ��������� ��������� ��������� (��������� �����). ��� ��������� �� ���� �������� �������������; ���� �� � ������������, �� ����� ������������ �������� ���������� CRC, ���� ������ ����������� �������� �� ����� ������������� ������������, �����, ��� �������� ������� ��������� �����.

�������� ���������

�� ����� ������� ������ ����� � ��� ����� ���� ������� (CRC-1), �������� (CRC-8) ��� ����� ������ �������. ���� ������� ��� � ����� �1�, �� ����� ���������� ����� �� ���� ������ � ����������� ����������� �������� XOR. ��������������, ���� ������� ��� � ����� �0�, �� ����� ������ �������� XOR �� �����������. ����� ������ �������� ������ ������� ���, � ������� ��� ������������� � ��� �������� ��������������� ������ ����. �� ����� �������� ���� ����������� ��������� ��� �� �����, � �������� ����������� �� ��� ���, ���� �� ���������� ��������� ��� �����. ����� ����������� ����� �����, � ����� �������� �������, ������� � �������� ����������� ������.

�������� ������������ � ����������������� ��������

� �� �����, ��� ����������� ���������� ���� �������� ������ ����������, � ����� ������� �� ���������� ������������� ����������� � ��������� ��������� ������� ������� ������������ ���� �����. [1] [5]

���� �������� �������� � ������ ����������-����������: �������� ����������������� �������� �� �������� ������ ������������ � ����� �������������� ������� ���������������� �� check reduntancy code .

��� ���� ������ ������ ������������ �������� �� �������� �������� ������������ �� ���� ���������. � 1993�2004 ����� ������ ������ ���������� ������������� ����������� ����������� ����������� �� 16, [1] 24 � 32 ���, [6] [7] � ����� ��������, ������ ������, ������ ������������������� ����������, ������������������ � ������ �������� ����������. [7] ���� �� ����������� ����� ������������ ��� ����� ��� ���������� � ��������� iSCSI.

����� ���������� � ������������� IEEE ������� ��� CRC-32 ������������ � Ethernet, FDDI; ����� ���� ��������� �������� ����������� ���� �������� [8] . ������������� ������� �������� � CRC-32C � ��������� ������� ����� �� ������������������ ��� ����� ��������� ��������� �� 58 ��� �� 131 ����, � � ��������� ���������� ����� �������� ��������� ����� ���� ���� ���� � ������� � ���� ��� �� ���� ���������� �������������. [7] � �������, �������� ITU-T G.hn ���������� CRC-32C � ����� ����������� ������ � �������� ��������.

���� � ������� ����������� �������� ���������������� ���������� � ���������� CRC.�� �������� ���������� CRC ����� �������� ���- � ����-��������, � ����� �������� ������� ��������� �����. � ������������� ����������� CRC ��� ���������� ������� ���� ��������� ��������� ��������� �������� ���������.

�������� ������� �������������: [9] ���������� / ��������������� / ��������������� �� ���������
CRC-1 (������������ � ���������� �������� ������; ����� �������� ��� ��� ��������) 0x1 / 0x1 / 0x1
CRC-4-ITU (ITU G.704 [10] ) 0x3 / 0xC / 0x9
CRC-5-EPC (Gen 2 RF >[11] ) 0x09 / 0x12 / 0x14
CRC-5-ITU (ITU G.704 [12] ) 0x15 / 0x15 / 0x1A
CRC-5-USB (USB token packets) 0x05 / 0x14 / 0x12
CRC-6-ITU (ITU G.704 [13] ) 0x03 / 0x30 / 0x21
CRC-7 (������� ����������������, ITU-T G.707 [14] , ITU-T G.832 [15] , MMC, SD) 0x09 / 0x48 / 0x44
CRC-8-CCITT (ATM HEC), ISDN Header Error Control and Cell Delineation ITU-T I.432.1 (02/99) 0x07 / 0xE0 / 0x83
CRC-8-Dallas/Maxim (1-Wire bus) 0x31 / 0x8C / 0x98
CRC-8 (ETSI EN 302 307 [16] , 5.1.4) 0xD5 / 0xAB / 0xEA [1]
CRC-8-SAE J1850 0x1D / 0xB8 / 0x8E
CRC-10 0x233 / 0x331 / 0x319
CRC-11 (FlexRay [17] ) 0x385 / 0x50E / 0x5C2
CRC-12 (������� ���������������� [18] [19] ) 0x80F / 0xF01 / 0xC07
CRC-15-CAN 0x4599 / 0x4CD1 / 0x62CC
CRC-16-IBM (Bisync, Modbus, USB, ANSI X3.28 [20] , ������ ������; ����� �������� ��� CRC-16CRC-16-ANSI) 0x8005 / 0xA001 / 0xC002
CRC-16-CCITT (X.25, HDLC, XMODEM, Bluetooth, SD � ��.) 0x1021 / 0x8408 / 0x8810 [1]
CRC-16-T10-DIF (SCSI DIF) 0x8BB7 [21] / 0xEDD1 / 0xC5DB
CRC-16-DNP (DNP, IEC 870, M-Bus) 0x3D65 / 0xA6BC / 0x9EB2
CRC-16-Fletcher Not a CRC; see Fletcher’s checksum Used in Adler-32 A & B CRCs
CRC-24 (FlexRay [17] ) 0x5D6DCB / 0xD3B6BA / 0xAEB6E5
CRC-24-Radix-64 (OpenPGP) 0x864CFB / 0xDF3261 / 0xC3267D
CRC-30 (CDMA) 0x2030B9C7 / 0x38E74301 / 0x30185CE3
CRC-32-Adler Not a CRC; see Adler-32 See Adler-32
CRC-32-IEEE 802.3 (V.42, MPEG-2, PNG [22] , POSIX cksum) 0x04C11DB7 / 0xEDB88320 / 0x82608EDB [7]
CRC-32C (Castagnoli) (iSCSI, G.hn payload) 0x1EDC6F41 / 0x82F63B78 / 0x8F6E37A0 [7]
CRC-32K (Koopman) 0x741B8CD7 / 0xEB31D82E / 0xBA0DC66B [7]
CRC-32Q (aviation; AIXM [23] ) 0x814141AB / 0xD5828281 / 0xC0A0A0D5
CRC-64-ISO (HDLC � ISO 3309) 0x000000000000001B / 0xD800000000000000 / 0x800000000000000D
CRC-64-ECMA-182 [24] 0x42F0E1EBA9EA3693 / 0xC96C5795D7870F42 / 0xA17870F5D4F51B49

������������ ��������� CRC-128 (IEEE) � CRC-256 (IEEE) � ��������� ����� ��������� ������������������ ���-���������.

������� �������� ���������� CRC

����� �� ����� ��������� �������� �������� Ross N. Williams [25] . � ��� ������������ ��������� ���������:

  • �������� ��������� (name);