pub_funcs.pas

GSM MODEM的收发短信息

    {for I := 0 to 7 do begin
      result := result + IntToHex(WriteBuf[I], 2);
    end; }
    result := BcdToAsc(WriteBuf);

    Offset := Offset + 8;
  until Offset > ((Count + 7) div 8) * 8;
end;

procedure DES_Code(Input: TBlock; var Output: TBlock);
var
  n: byte;
  z: Word;
begin
  L[1] := Ord(Input[7] and 64 > 0); R[1] := Ord(Input[7] and 128 > 0);
  L[2] := Ord(Input[6] and 64 > 0); R[2] := Ord(Input[6] and 128 > 0);
  L[3] := Ord(Input[5] and 64 > 0); R[3] := Ord(Input[5] and 128 > 0);
  L[4] := Ord(Input[4] and 64 > 0); R[4] := Ord(Input[4] and 128 > 0);
  L[5] := Ord(Input[3] and 64 > 0); R[5] := Ord(Input[3] and 128 > 0);
  L[6] := Ord(Input[2] and 64 > 0); R[6] := Ord(Input[2] and 128 > 0);
  L[7] := Ord(Input[1] and 64 > 0); R[7] := Ord(Input[1] and 128 > 0);
  L[8] := Ord(Input[0] and 64 > 0); R[8] := Ord(Input[0] and 128 > 0);
  L[9] := Ord(Input[7] and 16 > 0); R[9] := Ord(Input[7] and 32 > 0);
  L[10] := Ord(Input[6] and 16 > 0); R[10] := Ord(Input[6] and 32 > 0);
  L[11] := Ord(Input[5] and 16 > 0); R[11] := Ord(Input[5] and 32 > 0);
  L[12] := Ord(Input[4] and 16 > 0); R[12] := Ord(Input[4] and 32 > 0);
  L[13] := Ord(Input[3] and 16 > 0); R[13] := Ord(Input[3] and 32 > 0);
  L[14] := Ord(Input[2] and 16 > 0); R[14] := Ord(Input[2] and 32 > 0);
  L[15] := Ord(Input[1] and 16 > 0); R[15] := Ord(Input[1] and 32 > 0);
  L[16] := Ord(Input[0] and 16 > 0); R[16] := Ord(Input[0] and 32 > 0);
  L[17] := Ord(Input[7] and 4 > 0); R[17] := Ord(Input[7] and 8 > 0);
  L[18] := Ord(Input[6] and 4 > 0); R[18] := Ord(Input[6] and 8 > 0);
  L[19] := Ord(Input[5] and 4 > 0); R[19] := Ord(Input[5] and 8 > 0);
  L[20] := Ord(Input[4] and 4 > 0); R[20] := Ord(Input[4] and 8 > 0);
  L[21] := Ord(Input[3] and 4 > 0); R[21] := Ord(Input[3] and 8 > 0);
  L[22] := Ord(Input[2] and 4 > 0); R[22] := Ord(Input[2] and 8 > 0);
  L[23] := Ord(Input[1] and 4 > 0); R[23] := Ord(Input[1] and 8 > 0);
  L[24] := Ord(Input[0] and 4 > 0); R[24] := Ord(Input[0] and 8 > 0);
  L[25] := Input[7] and 1; R[25] := Ord(Input[7] and 2 > 0);
  L[26] := Input[6] and 1; R[26] := Ord(Input[6] and 2 > 0);
  L[27] := Input[5] and 1; R[27] := Ord(Input[5] and 2 > 0);
  L[28] := Input[4] and 1; R[28] := Ord(Input[4] and 2 > 0);
  L[29] := Input[3] and 1; R[29] := Ord(Input[3] and 2 > 0);
  L[30] := Input[2] and 1; R[30] := Ord(Input[2] and 2 > 0);
  L[31] := Input[1] and 1; R[31] := Ord(Input[1] and 2 > 0);
  L[32] := Input[0] and 1; R[32] := Ord(Input[0] and 2 > 0);

  for n := 1 to 16 do begin
    z := ((R[32] xor G[n, 1]) shl 5) or ((R[5] xor G[n, 6]) shl 4)
      or ((R[1] xor G[n, 2]) shl 3) or ((R[2] xor G[n, 3]) shl 2)
      or ((R[3] xor G[n, 4]) shl 1) or (R[4] xor G[n, 5]);
    F[9] := L[9] xor SA1[z];
    F[17] := L[17] xor SB1[z];
    F[23] := L[23] xor SC1[z];
    F[31] := L[31] xor SD1[z];

    z := ((R[4] xor G[n, 7]) shl 5) or ((R[9] xor G[n, 12]) shl 4)
      or ((R[5] xor G[n, 8]) shl 3) or ((R[6] xor G[n, 9]) shl 2)
      or ((R[7] xor G[n, 10]) shl 1) or (R[8] xor G[n, 11]);
    F[13] := L[13] xor SA2[z];
    F[28] := L[28] xor SB2[z];
    F[2] := L[2] xor SC2[z];
    F[18] := L[18] xor SD2[z];

    z := ((R[8] xor G[n, 13]) shl 5) or ((R[13] xor G[n, 18]) shl 4)
      or ((R[9] xor G[n, 14]) shl 3) or ((R[10] xor G[n, 15]) shl 2)
      or ((R[11] xor G[n, 16]) shl 1) or (R[12] xor G[n, 17]);
    F[24] := L[24] xor SA3[z];
    F[16] := L[16] xor SB3[z];
    F[30] := L[30] xor SC3[z];
    F[6] := L[6] xor SD3[z];

    z := ((R[12] xor G[n, 19]) shl 5) or ((R[17] xor G[n, 24]) shl 4)
      or ((R[13] xor G[n, 20]) shl 3) or ((R[14] xor G[n, 21]) shl 2)
      or ((R[15] xor G[n, 22]) shl 1) or (R[16] xor G[n, 23]);
    F[26] := L[26] xor SA4[z];
    F[20] := L[20] xor SB4[z];
    F[10] := L[10] xor SC4[z];
    F[1] := L[1] xor SD4[z];

    z := ((R[16] xor G[n, 25]) shl 5) or ((R[21] xor G[n, 30]) shl 4)
      or ((R[17] xor G[n, 26]) shl 3) or ((R[18] xor G[n, 27]) shl 2)
      or ((R[19] xor G[n, 28]) shl 1) or (R[20] xor G[n, 29]);
    F[8] := L[8] xor SA5[z];
    F[14] := L[14] xor SB5[z];
    F[25] := L[25] xor SC5[z];
    F[3] := L[3] xor SD5[z];

    z := ((R[20] xor G[n, 31]) shl 5) or ((R[25] xor G[n, 36]) shl 4)
      or ((R[21] xor G[n, 32]) shl 3) or ((R[22] xor G[n, 33]) shl 2)
      or ((R[23] xor G[n, 34]) shl 1) or (R[24] xor G[n, 35]);
    F[4] := L[4] xor SA6[z];
    F[29] := L[29] xor SB6[z];
    F[11] := L[11] xor SC6[z];
    F[19] := L[19] xor SD6[z];

    z := ((R[24] xor G[n, 37]) shl 5) or ((R[29] xor G[n, 42]) shl 4)
      or ((R[25] xor G[n, 38]) shl 3) or ((R[26] xor G[n, 39]) shl 2)
      or ((R[27] xor G[n, 40]) shl 1) or (R[28] xor G[n, 41]);
    F[32] := L[32] xor SA7[z];
    F[12] := L[12] xor SB7[z];
    F[22] := L[22] xor SC7[z];
    F[7] := L[7] xor SD7[z];

    z := ((R[28] xor G[n, 43]) shl 5) or ((R[1] xor G[n, 48]) shl 4)
      or ((R[29] xor G[n, 44]) shl 3) or ((R[30] xor G[n, 45]) shl 2)
      or ((R[31] xor G[n, 46]) shl 1) or (R[32] xor G[n, 47]);
    F[5] := L[5] xor SA8[z];
    F[27] := L[27] xor SB8[z];
    F[15] := L[15] xor SC8[z];
    F[21] := L[21] xor SD8[z];

    L := R;
    R := F;
  end;

  Output[0] := (L[8] shl 7) or (R[8] shl 6) or (L[16] shl 5) or (R[16] shl 4)
    or (L[24] shl 3) or (R[24] shl 2) or (L[32] shl 1) or R[32];
  Output[1] := (L[7] shl 7) or (R[7] shl 6) or (L[15] shl 5) or (R[15] shl 4)
    or (L[23] shl 3) or (R[23] shl 2) or (L[31] shl 1) or R[31];
  Output[2] := (L[6] shl 7) or (R[6] shl 6) or (L[14] shl 5) or (R[14] shl 4)
    or (L[22] shl 3) or (R[22] shl 2) or (L[30] shl 1) or R[30];
  Output[3] := (L[5] shl 7) or (R[5] shl 6) or (L[13] shl 5) or (R[13] shl 4)
    or (L[21] shl 3) or (R[21] shl 2) or (L[29] shl 1) or R[29];
  Output[4] := (L[4] shl 7) or (R[4] shl 6) or (L[12] shl 5) or (R[12] shl 4)
    or (L[20] shl 3) or (R[20] shl 2) or (L[28] shl 1) or R[28];
  Output[5] := (L[3] shl 7) or (R[3] shl 6) or (L[11] shl 5) or (R[11] shl 4)
    or (L[19] shl 3) or (R[19] shl 2) or (L[27] shl 1) or R[27];
  Output[6] := (L[2] shl 7) or (R[2] shl 6) or (L[10] shl 5) or (R[10] shl 4)
    or (L[18] shl 3) or (R[18] shl 2) or (L[26] shl 1) or R[26];
  Output[7] := (L[1] shl 7) or (R[1] shl 6) or (L[9] shl 5) or (R[9] shl 4)
    or (L[17] shl 3) or (R[17] shl 2) or (L[25] shl 1) or R[25];
end;

//字符转十六进  WRITER BY JTPBOY   AT 20061209

function MyStrTohex(Strdata: string): string;
var
  I, j: integer;
  TempStr: string;
begin
  TempStr := '';
  for I := 1 to Length(Strdata) do begin
    j := Ord(Strdata[I]);

    TempStr := TempStr + IntToHex(j, 2);
  end;
  result := TempStr;
end;

// //十六进转字符  WRITER BY JTPBOY   AT 20061209

function myHextoStr(Strdata: string): string;
var HexS, tmpStr: string;
  I: integer;
  a: byte;
begin
  HexS := Strdata;
  if Length(HexS) mod 2 = 1 then begin
    HexS := HexS + '0';
  end;
  tmpStr := '';
  for I := 1 to (Length(HexS) div 2) do begin
    a := StrToInt('$' + HexS[2 * I - 1] + HexS[2 * I]);
    tmpStr := tmpStr + Chr(a);
  end;
  result := tmpStr;
end;


// 十六进制 码转换成 ASC 码

function BcdToAsc(string1: array of byte): string;
var
  str2: string;
  I: integer;
  len1: integer;
  cha1: byte;
begin
  str2 := '';
  I := 0;
  len1 := Length(string1);
  while I < len1 do begin
    // 从数据中取一个byte(array of byte 从0开始)
    cha1 := string1[I];
    // 将一个10进制转换成两个16进制(byte本身就是一个10进制数)
    str2 := str2 + IntToHex(cha1, 2);
    Inc(I);
  end;
  BcdToAsc := str2;
end;

function HexToDec(hex: string): integer; // 十六进制转数字
var
  X, Y: integer;
  Temp: integer;
begin
  X := Ord(hex[1]);
  Y := Ord(hex[2]);
  if X >= Ord('A') then X := X - Ord('A') + 10 else X := X - Ord('0');
  if Y >= Ord('A') then Y := Y - Ord('A') + 10 else Y := Y - Ord('0');
  Temp := X * 16 + Y;
  result := Temp;
end; 

function HexToStr(//十六进制字符串处理成字符串
  mHex: string //十六进制字符串
  ): string; //返回处理后的字符串
var
  I: integer;
begin
  result := '';
  mHex := StringReplace(mHex, #32, '', [rfReplaceAll]);
  for I := 1 to Length(mHex) div 2 do
    result := result + Chr(StrToIntDef('$' + Copy(mHex, I * 2 - 1, 2), 0));
end; { HexToStr }

function StrToHex(//字符串处理成十六进制字符串
  mStr: string; //字符串
  mSpace: Boolean = False //是否用空格分开
  ): string; //返回处理后的十六进制字符串
const
  cSpaceStr: array[Boolean] of string = ('', #32);
var
  I: integer;
begin
  result := '';
  for I := 1 to Length(mStr) do
    result := Format('%s%s%.2x', [result, cSpaceStr[mSpace], Ord(mStr[I])]);
  if mSpace then Delete(result, 1, 1);
end; { StrToHex }


//为了这个函数我折腾了一天.这个函数主要用于DES解密.
function HexTobytearray8(//十六进制字符串处理成BYTE数组
  mHex: string //十六进制字符串
  ): TBlock; //返回处理后的byte数组   专用于DES加解密
var
  I: integer;
begin
  FillChar(result, SizeOf(TBlock), 0);
  mHex := StringReplace(mHex, #32, '', [rfReplaceAll]);
  for I := 1 to Length(mHex) div 2 do
    result[I - 1] := HexToDec(Copy(mHex, I * 2 - 1, 2));
end; { HexTobytearr }

//这个函数主要用于打包时赋值,返回动态数组.

function HexTobytearray(//十六进制字符串处理成动态BYTE数组
  mHex: string //十六进制字符串
  ): TBlockA; //返回处理后的动态byte数组
var
  I, Dec_I: integer;
  Temp: string;
begin
  FillChar(result, SizeOf(result), 0);

  mHex := StringReplace(mHex, #32, '', [rfReplaceAll]);
  for I := 1 to Length(mHex) div 2 do begin
    Temp := Copy(mHex, I * 2 - 1, 2);
    Dec_I := HexToDec(Temp);
    result[I - 1] := Dec_I;
    //Move(Dec_I, result[I], 1);
  end;
end; { HexTobytearr }

 //求异或值  WRITER BY JTPBOY   AT 20061209
//二个字符串两两异或  ,用于生成MAC的异或计算
function GetXOR2(HexS, HexSS: string): string;
var
  I: integer;
  ResulthexS: string;
  TempBuf, TempBuf2: TBlock;
begin
  TempBuf := HexTobytearray8(HexS);
  TempBuf2 := HexTobytearray8(HexSS);
  for I := 1 to 8 do begin
    ResulthexS := ResulthexS + IntToHex(TempBuf[I - 1] xor TempBuf2[I - 1], 2);
  end;
  result := ResulthexS;
end;

end.