Hogyan számoljuk ki a checksum fájlt
És lehetséges, részletesebben?
modulo 256 = x mod 256
Sajnos nem értem, hogyan kell csinálni, akkor kódolni?
Modulo 256 ezen a versenyen, hogy figyelmen kívül hagyja a transzfer, akkor természetesen nem, de egyszerűen hatékonyabb felhasználása bájtok és blokrovat túlcsordulás hiba. Bár maga a műtét nem kell sok idő, de ez is el lehet végezni nagy adathalmazok
Megkérdezhetem, mi az algoritmus a CRC?
Elképzelhető, hogy csökkenti a hibakódot (fordításban) alapján egy bonyolultabb algoritmust, mint az összegzése bájt, egy meglévő tag számos ilyen algoritmusok, számos közülük elismert szabvány szerint.
Kiderülhet, hogy a lényeg, hogy szeretne csinálni, miért és hogyan besprdmetno.
De a kérdés megvan a válasz sokáig, add az összes bájtot a modul 256, a végén az ellenőrző összeget.
CRC algoritmus egy számítási módszere az aláírás (CRC) adatokat, ami lehetővé teszi, hogy egy bizonyos valószínűséggel, hogy pontosságának meghatározására az adatokat azok esetleges torzulások átvitel során, tároló.
Meg kell csinálni a következő: a változás az én programkód akár közvetlen szerkesztését kód, vagy írásban a patch program bekövetkező változásának vizsgálatára kódot, és ha ez megtörtént, csak megszakítja a programot, mielőtt a program elindul.
Ui ha több szívesen válaszolt, akkor megpróbálom megtalálni a választ valahol.
Eugene_post (23.10.02 21:47)
Védelme kényes kérdés, ne feledd, hogy lesz egy falatot vizsgálat nélkül megérteni, hogyan és mit gondol. De minden esetben, CRC hatékonyabb, mint a CS
const
CrcPolynominal = $ 04C11DB7;
// *******************************
// * Számítsuk crc32 pufferrel *
// *******************************
működnek BufToCrc (const Buf; Count: egész szám). longint;
var
I. Egész;
kezdődik
Eredmény: = $ FFFFFFFF;
I: = 0 Count - 1 do kezdődik
Eredmény: = crc32 (Byte (TByteArray (BUF) [I]), Eredmény);
végén;
végén;
// *******************************
// * Számolja crc32 zsineggel *
// *******************************
működni StrToCrc (Érték: string). longint;
var
I. Egész;
kezdődik
Eredmény: = $ FFFFFFFF;
I: = 1-től hossz (Value) nem kezdődik
Eredmény: = crc32 (Byte (Value [I]), Eredmény);
végén;
végén;
Az elektronika (assembler) - lehetőség van elképzelni egy léptető regiszter csapok szükséges bitek (az X fok), és az összes a csapokat, és a bemeneti egybites szekvencia hozzáadott „modulo-2”, és a behelyezés apránként egy regiszterben.
Miután áthaladt az összes számot és a nyilvántartás lesz aláírás (CRC).
Ez a módszer a extrapolálni több bites feldolgozás.
Ahhoz, hogy gyorsítsák fel a számítási táblázat technikákat használnak valójában.
Egyébként ugyanazt irreducibilis polinomok előállítására használják pszeudo-véletlen számokat.
> Eugene_post
Egy másik kiviteli alakban
const
CrcSeed = $ ffffffff;
működnek CRC32 (Puffer pointer; .. const BufLen DWord; Crc DWord.). DWORD; szerelő;
asm
tolja edi
mov edi, eax
mov eax, ecx
mov ecx, edx
és ecx, ecx
JZ @Exit
és edi, edi
JZ @Exit
@ Indítsa:
xor EDX, EDX
mov dl, al
SHR eax, 8
xor dl, [edi]
xor EAX, dword ptr [4 * EDX + crctable32]
inc edi
loop @ Indítsa
@Exit:
pop edi
végén;
funkció CrcStream (patak. TStream). DWORD;
var
P. Pointer;
C. LongInt;
kezdődik
Eredmény: = CrcSeed;
GetMem (P, 8192);
megpróbál
Stream.Position: = 0;
míg Stream.Position
Eredmény: = CRC32 (P, C, Eredmény)
vég
végül
FreeMem (P, 8192)
végén;
Eredmény: = Eredmény xor CrcSeed
végén;
függvény CrcFile (const fájlnevet. string). DWORD;
var
Patak. TFileStream;
kezdődik
Patak: = TFileStream.Create (fájlnév, fmOpenRead + fmShareDenyNone);
megpróbál
Eredmény: = CrcStream (Stream)
végül
Stream.Free
vég
végén;
Változata az asztal jobb maradéktalanul Pascal algoritmikus nem is olyan könnyű perevedesh
Igen, ez a táblázatos módszer generátor polinommal
FUNKCIÓ UpdC32 (oktett: byte; CRC: LONGINT). LONGINT;
BEGIN
UpdC32: = crctabdu32 [BYTE (CRC XOR LONGINT (oktett))] XOR ((CRC SHR 8) és $ 00FFFFFF)
END;
const
CRC32_POLYNOMIAL = $ EDB88320;
var
Ccitt32Table. array [0..255] a longint;
funkció CRC32 (CRC longint; .. const c bájt). longint;
kezdődik
CRC32: = (((CRC SHR 8) és $ 00FFFFFF) XOR (Ccitt32Table [(CRC XOR c) és a $ FF]));
végén;
eljárás BuildCRCTable;
var
i, j, értéket. DWORD;
kezdődik
i: = 0-tól 255 do
kezdődik
érték: = i;
j: = 1 do 8 downto
kezdődik
if ((érték és 1) <> 0), akkor
érték: = (érték SHR 1) xor CRC32_POLYNOMIAL
más
érték: = érték SHR 1;
végén;
Ccitt32Table [i]: = érték;
vég
végén;
Ez is egy táblázatot a módszerrel csak a táblázat számítjuk, nem tárolt.
ROL AL, 1
RCL EDX, 1
JNC @ 2
Ez használ a carry flag, és Pascal nincs hozzáférése. De minden attól függ, a célok, csak nem szeretem a használatát assembler parancsok nem a tolerancia, mint a .NET technológia