myke2002
15-08-2003, 05:22 PM
Maybe this helps.
unit Calcul;
// Input Data is 13 bytes of MsId number in MsId[0..12] and 7 bytes of IMEI number in Imei[0..6]
//
// for i := 0 to 11 do Cobba[i] := 0; // Clear Cobba S/N Buffer
// Algo_8x := MsId[0];
// for i := 0 to 11 do BufVar[i] := MsId[i+1]; // Get MsId from Buffer
// BufTab := SelAlg(Algo_8x,0,Cobba);
// // BufVar have source, BufTab have Decode or Encode table, depend on 8X MsId
//
// CoDecN(BufVar,BufTab,DecodTabl); // Do Decode
// // Msid is decoded now in BufVar (Flash CRC, COBBA s/n, Hash)
// for i := 0 to 3 do Cobba[i] := BufVar[i+4]; // Get Decoded COBBA s/n
//
// // Now begin encoding
//
// BufTab := SelAlg(Algo_8x,1,Cobba); // Choose Algo Table for FlId and Set COBBA s/n
// PpmCrc(BufVar); // Prepare Decoded FLASH CRC for encoding
// CoDecN(BufVar,BufTab,EncodTabl); // Do Encode
// // BufVar now have FLASH ID registry EE Data
//
// BufTab := SelAlg(Algo_8x,2,Cobba);
// BufVar := Lock1_Def; // Set Default SimLock Part1(MCC, MNC, MSIN)
// CoDecN(BufVar,BufTab,EncodTabl);
// // BufVar have now SimLock p.1 EE Data
//
// BufVar := Lock2_Def; // Set Default Sim Lock Part2(GID1, GID2)
// CoDecN(BufVar,BufTab,EncodTabl);
// // BufVar have now SimLock p.2 EE Data
// BufTab := SelAlg(Algo_8x,3,Cobba);
// BufVar := Imei_Def; // Set Default IMEI 000000-00-000000
// for i := 0 to 6 do BufVar[i+2] := Imei[i]; // Set required IMEI
// CoDecN(BufVar,BufTab,EncodTabl);
// // BufVar have now IMEI EE Data
//
interface
type By12Ar = array[0..11] of byte;
function RevByt(b: byte):byte;
procedure Do_CRC(Dat: Longword;var Res: Longword);
procedure RevBuf(var Buf: By12Ar);
procedure CRR32k(var Buf: By12Ar;P: byte;k: integer);
procedure XorOrB(var Buf: By12Ar);
procedure ScrStt(var Buf: By12Ar;Tab1,Tab: By12Ar;TabP: byte);
procedure Permut(var Buf: By12Ar);
procedure PpmCrc(var Buf: By12Ar);
procedure CoDecN(var Buf: By12Ar;Tab,Key: By12Ar);
function SelAlg(A,M: byte;var Cb: By12Ar): By12Ar;
const
Imei_Def : By12Ar = ($79,$29,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00);
// IMEI: 000000-00-000000
Lock1_Def : By12Ar = ($00,$10,$10,$00,$00,$00,$00,$10,$00,$79,$54,$C2);
// MccMnc: 001-01 Msin: 0000000001
Lock2_Def : By12Ar = ($00,$00,$00,$00,$29,$00,$00,$00,$00,$00,$54,$C2);
EncodTabl : By12Ar = ($B1,$73,$E6,$5A,$AB,$47,$8E,$0D,$1A,$34,$68,$0B);
DecodTabl : By12Ar = ($D0,$16,$2C,$58,$B0,$71,$E2,$D5,$5A,$67,$CE,$8D);
Msid_Dec_81 : By12Ar = ($83,$CB,$74,$24,$DF,$F1,$E9,$97,$68,$71,$DB,$44);
Msid_Dec_82 : By12Ar = ($9F,$7A,$AD,$34,$E7,$79,$27,$73,$4E,$41,$0D,$26);
Msid_Dec_83 : By12Ar = ($50,$F3,$65,$25,$D2,$B1,$C1,$B6,$09,$AE,$FF,$4C);
Flid_Enc_81 : By12Ar = ($2C,$03,$6F,$34,$5D,$23,$C6,$58,$03,$09,$52,$C4);
Flid_Enc_82 : By12Ar = ($4F,$B9,$6C,$27,$02,$DD,$77,$DD,$06,$E3,$E2,$DF);
Flid_Enc_83 : By12Ar = ($B8,$33,$80,$04,$B8,$48,$85,$1A,$2D,$CE,$A1,$28);
Lock_Enc_81 : By12Ar = ($7B,$B4,$D0,$EF,$9E,$B2,$0A,$BE,$73,$DA,$D3,$35);
// bad table for MsId 81x, do not use
Lock_Enc_82 : By12Ar = ($D1,$A2,$5F,$EB,$4F,$F0,$2D,$7B,$0F,$4C,$E1,$C3);
Lock_Enc_83 : By12Ar = ($7B,$B4,$D0,$EF,$9E,$B2,$0A,$BE,$73,$DA,$D3,$35);
Imei_Enc_81 : By12Ar = ($CA,$63,$5A,$E7,$19,$FA,$A6,$4C,$0D,$78,$FC,$16);
// bad table for MsId 81x, do not use
Imei_Enc_82 : By12Ar = ($0B,$AE,$FC,$8C,$C7,$FC,$79,$2A,$C1,$94,$C2,$37);
Imei_Enc_83 : By12Ar = ($CA,$63,$5A,$E7,$19,$FA,$A6,$4C,$0D,$78,$FC,$16);
implementation
{*************************************************
*****************************}
function SelAlg(A,M: byte;var Cb: By12Ar): By12Ar;
var
i : integer;
begin
for i := 0 to 11 do
case M of
0: case A of
$81: SelAlg := Msid_Dec_81;
$82: SelAlg := Msid_Dec_82;
$83: SelAlg := Msid_Dec_83;
end;
1: case A of
$81: SelAlg[i] := Flid_Enc_81[i] xor Cb[i];
$82: SelAlg[i] := Flid_Enc_82[i] xor Cb[i];
$83: SelAlg[i] := Flid_Enc_83[i] xor Cb[i];
end;
2: case A of
$81: SelAlg[i] := Lock_Enc_81[i] xor Cb[i];
$82: SelAlg[i] := Lock_Enc_82[i] xor Cb[i];
$83: SelAlg[i] := Lock_Enc_83[i] xor Cb[i];
end;
3: case A of
$81: SelAlg[i] := Imei_Enc_81[i] xor Cb[i];
$82: SelAlg[i] := Imei_Enc_82[i] xor Cb[i];
$83: SelAlg[i] := Imei_Enc_83[i] xor Cb[i];
end;
end;
end;
{*************************************************
*****************************}
procedure CoDecN(var Buf: By12Ar;Tab,Key: By12Ar);
var
i : integer;
begin
for i := 0 to 10 do
begin
ScrStt(Buf,Tab,Key,i);
Permut(Buf);
CRR32k(Buf,0,10);
CRR32k(Buf,8,31);
XorOrB(Buf);
CRR32k(Buf,8,10);
CRR32k(Buf,0,31);
end;
ScrStt(Buf,Tab,Key,11);
Permut(Buf);
RevBuf(Buf);
end;
{*************************************************
*****************************}
procedure PpmCrc(var Buf: By12Ar);
begin
Buf[0] := Buf[0] xor $17; // Restore PPM (last 4x bytes) record to CRC result
Buf[1] := Buf[1] xor $CA;
Buf[2] := Buf[2] xor $60;
Buf[3] := Buf[3] xor $89;
Buf[4] := Buf[0] xor $FF; // Complement of CRC
Buf[5] := Buf[1] xor $FF;
Buf[6] := Buf[2] xor $FF;
Buf[7] := Buf[3] xor $FF;
Buf[8] := 0; // Zerros
Buf[9] := 0;
Buf[10] := 0;
Buf[11] := 0;
end;
{*************************************************
*****************************}
procedure Permut(var Buf: By12Ar);
var
i : integer;
w,x : byte;
Wbuf : array[0..11] of byte;
begin
w := Buf[0];x := w;
Wbuf[01]:= w;
Wbuf[04]:= w;
Wbuf[08]:= w;
Wbuf[09]:= w;
Wbuf[11]:= w;
//
w := Buf[1];x := x xor w;
Wbuf[05]:= w;
Wbuf[06]:= w;
Wbuf[10]:= w;
Wbuf[08]:= w xor Wbuf[08];
Wbuf[09]:= w xor Wbuf[09];
//
w := Buf[2];x := x xor w;
Wbuf[03]:= w;
Wbuf[01]:= w xor Wbuf[01];
Wbuf[06]:= w xor Wbuf[06];
Wbuf[10]:= w xor Wbuf[10];
Wbuf[11]:= w xor Wbuf[11];
//
w := Buf[3];x := x xor w;
Wbuf[00]:= w;
Wbuf[07]:= w;
Wbuf[08]:= w xor Wbuf[08];
Wbuf[10]:= w xor Wbuf[10];
Wbuf[11]:= w xor Wbuf[11];
//
w := Buf[4];x := x xor w;
Wbuf[00]:= w xor Wbuf[00];
Wbuf[01]:= w xor Wbuf[01];
Wbuf[03]:= w xor Wbuf[03];
Wbuf[05]:= w xor Wbuf[05];
Wbuf[08]:= w xor Wbuf[08];
//
w := Buf[5];x := x xor w;
Wbuf[02]:= w;
Wbuf[00]:= w xor Wbuf[00];
Wbuf[01]:= w xor Wbuf[01];
Wbuf[09]:= w xor Wbuf[09];
Wbuf[10]:= w xor Wbuf[10];
//
w := Buf[6];x := x xor w;
Wbuf[02]:= w xor Wbuf[02];
Wbuf[03]:= w xor Wbuf[03];
Wbuf[05]:= w xor Wbuf[05];
Wbuf[07]:= w xor Wbuf[07];
Wbuf[10]:= w xor Wbuf[10];
//
w := Buf[7];x := x xor w;
Wbuf[00]:= w xor Wbuf[00];
Wbuf[02]:= w xor Wbuf[02];
Wbuf[03]:= w xor Wbuf[03];
Wbuf[04]:= w xor Wbuf[04];
Wbuf[11]:= w xor Wbuf[11];
//
w := Buf[8];x := x xor w;
Wbuf[00]:= w xor Wbuf[00];
Wbuf[04]:= w xor Wbuf[04];
Wbuf[05]:= w xor Wbuf[05];
Wbuf[07]:= w xor Wbuf[07];
Wbuf[09]:= w xor Wbuf[09];
//
w := Buf[9];x := x xor w;
Wbuf[01]:= w xor Wbuf[01];
Wbuf[02]:= w xor Wbuf[02];
Wbuf[04]:= w xor Wbuf[04];
Wbuf[05]:= w xor Wbuf[05];
Wbuf[06]:= w xor Wbuf[06];
//
w := Buf[10];x := x xor w;
Wbuf[02]:= w xor Wbuf[02];
Wbuf[06]:= w xor Wbuf[06];
Wbuf[07]:= w xor Wbuf[07];
Wbuf[09]:= w xor Wbuf[09];
Wbuf[11]:= w xor Wbuf[11];
//
w := Buf[11];x := x xor w;
Wbuf[03]:= w xor Wbuf[03];
Wbuf[04]:= w xor Wbuf[04];
Wbuf[06]:= w xor Wbuf[06];
Wbuf[07]:= w xor Wbuf[07];
Wbuf[08]:= w xor Wbuf[08];
//
for i := 0 to 11 do Buf[i] := Wbuf[i] xor x;
end;
{*************************************************
*****************************}
procedure ScrStt(var Buf: By12Ar;Tab1,Tab: By12Ar;TabP: byte);
begin
Buf[00] := Buf[00] xor Tab1[00];
Buf[01] := Buf[01] xor Tab1[01];
//
Buf[02] := Buf[02] xor Tab1[02] xor Tab[TabP];
Buf[03] := Buf[03] xor Tab1[03] xor Tab[TabP];
//
Buf[04] := Buf[04] xor Tab1[04];
Buf[05] := Buf[05] xor Tab1[05];
//
Buf[06] := Buf[06] xor Tab1[06];
Buf[07] := Buf[07] xor Tab1[07];
//
Buf[08] := Buf[08] xor Tab1[08] xor Tab[TabP];
Buf[09] := Buf[09] xor Tab1[09] xor Tab[TabP];
//
Buf[10] := Buf[10] xor Tab1[10];
Buf[11] := Buf[11] xor Tab1[11];
end;
{*************************************************
*****************************}
procedure XorOrB(var Buf: By12Ar);
var
i,j,k : integer;
Cbuf : array[0..11] of byte;
begin
for i := 0 to 11 do Cbuf[i] := Buf[i]; // Copy original
j := 4; k := 8;
for i := 0 to 11 do // Xn := Xn xor (Xn+4 or not Xn+8)
begin
Buf[i] := Cbuf[i] xor (Cbuf[j] or not Cbuf[k]);
inc(j);inc(k);
if j = 12 then j := 0;
if k = 12 then k := 0;
end;
end;
{*************************************************
*****************************}
procedure CRR32k(var Buf: By12Ar;P: byte;k: integer);
var
i : integer;
x,y : Longword;
begin
x := Buf[P];x := x shl 8;
x := x or Buf[P + 1];x := x shl 8;
x := x or Buf[P + 2];x := x shl 8;
x := x or Buf[P + 3];
for i := 1 to k do
begin
// Cyclical Rotate 32 bits word right k times
y := x and 1; // Extract Carry
y := y shl 31; // Move Carry to Msb
x := x shr 1; // Do Shift
x := x or y; // Add Carry
end;
Buf[P + 3] := x;
x := x shr 8;Buf[P + 2] := x;
x := x shr 8;Buf[P + 1] := x;
x := x shr 8;Buf[P] := x;
end;
Powered by vBulletin® Version 4.2.0 Copyright © 2024 vBulletin Solutions, Inc. All rights reserved.