Кодек телевизионного сигнала моноадресной телевизионной системы

22. www.philips-semicopdactors.coni/vms113.pdf - описание микросхемы vms 113.

23. www.philips-semicopdactors.coni/vms115.pdf - описание микросхемы vmsl 15.

24. ГОСТ 12.1.004-91 Пожарная безопасность. Общие требования.

25. ГОСТ 12.1.038-82. ССБТ. Электробезопасность. Предельно допустимые уровни напряжений и прикосновений и токов.

26. ГОСТ 12.1.030-81. ССБТ. Электробезопасность. Защитное заземление и зануление.

27. ГОСТ 12.1.003-83. Шум. Общие требования безопасности.

28. ГОСТ 12.1.029-80. Средства и методы защиты от шума. Классификация.

29. СНиП 1 - 33 - 75 Отопление, вентиляция и кондиционирование воздуха.

30. ПДУ 5803 - 91. Предельно допустимы уровни воздействия ЭМП диапазона 10-60 кГц.

31. ГОСТ 12.1.006-87. ЭМП радиочастот. Общие требования безопасности.

32. СНиП 23-05-95. Естественное и искусственное освещение.

33. Безопасность жизнедеятельности. Учеб. пособие/ В.Е. Болтнев, Н.В. Веселкин, Ю.В. Зайцев, В.И. Кремнев/ под общ. ред. Ю.В. Зайцева, РГРТА;Рязань,2002, 100с.

34. ГОСТ 12.2.006-87*.ССБТ. Аппаратура радиоэлектронная бытовая. Требования безопасности.

35. СН 2.2.4/2.1.8.562-96. Шум на рабочих местах, в помещениях жилых, общественных зданиях и на территории жилой застройки.

36. СанПин 2.2.4.548-96. Гигиенические требования к микроклимату производственных помещений.

37. ГОСТ Р 50923-96. Дисплеи. Рабочее место оператора. Общие эргономические требования к производственной среде. Методы измерения.



Приложение

1 Модуль Des

Unit Des;

interface

uses SysUtils, Math;

const

EN0=0; { MODE == encrypt }

DE1=1; { MODE == decrypt }

MaxDataSize=8; // Максимальный размер блока данных в байтах

type

TData = Array[0..MaxDataSize-1] of byte;

TReorderArray = Array[0..63] of byte;

TBlock = Class(TObject)

private

BlockSize: integer; // Размер блока в байтах

FPlain: TData;

function GetBit(Index: Integer): Byte;

procedure SetBit(Index: Integer; Value: Byte);

function PlainToHex: string;

procedure HexToPlain(Hex: string);

public

constructor Create(BSize: integer);

property Plain: TData read FPlain write FPlain;

property Hex: string read PlainToHex write HexToPlain;

property Bit[Index: Integer]: byte read GetBit write SetBit;

function bin: string;

end;

TPlain = Class(TObject)

private

function GetLeft: LongWord;

procedure SetLeft(Value: LongWord);

function GetRight: LongWord;

procedure SetRight(Value: LongWord);

procedure SetLeftAndRight;

procedure SetByLeftAndRight;

public

Plain: TBlock;

LeftBlock: TBlock;

RightBlock: TBlock;

EBlock: TBlock;

SPBlock: TBlock;

constructor Create;

destructor Destroy;

property Left: LongWord read GetLeft write SetLeft;

property Right: LongWord read GetRight write SetRight;

procedure GetEBlock;

procedure XorEBlock(Block48: TBlock);

procedure SBlockPermutation;

procedure PBlockPermutation;

procedure Exchange(Round: byte);

procedure StartPermutation;

procedure EndPermutation;

end;

TKey = Class(TObject)

private

public

Key64: TBlock;

Key56: TBlock;

Key48: TBlock;

constructor Create;

destructor Destroy;

procedure GetKey56;

procedure GetKey48(Round: byte; EncDec: boolean);

end;

implementation

//*************************************************************************

// Методы класса TPlain

//*************************************************************************

constructor TBlock.Create(BSize: integer);

begin

BlockSize := BSize;

end;

function TBlock.GetBit(Index: Integer): Byte;

var

ByteNumber: byte;

begin

ByteNumber := Index div 8;

// Plain[ByteNumber] and (1 shl (Index mod 8)); ??

// FPlain[ByteNumber] and (1 shl (7 - (Index mod 8)))

if FPlain[ByteNumber] and (1 shl (7 - Index mod 8)) > 0 then

Result := 1

else

Result := 0;

end;

procedure TBlock.SetBit(Index: Integer; Value: Byte);

var

ByteNumber: byte;

begin

ByteNumber := Index div 8;

if Value = 0 then

FPlain[ByteNumber] := (FPlain[ByteNumber]) and (255 - (1 shl (7 - (Index mod 8))))

else

FPlain[ByteNumber] := (FPlain[ByteNumber]) or (1 shl (7 - (Index mod 8)));

end;

procedure TBlock.HexToPlain(Hex: string);

var

i: integer;

ExitFlag: boolean;

ByteNumber: Byte;

begin

Hex := UpperCase(Hex);

i := 1;

ExitFlag := false;

for ByteNumber := 0 to BlockSize-1 do

FPlain[ByteNumber] := 0;

ByteNumber := 0;

while (i<=BlockSize*2) and not ExitFlag do begin

if i > Length(Hex) then

ExitFlag := true

else begin

if Hex[i] in ['0'..'9'] then begin

// Нечетные числа - старшие 4 бита числа,

// четный - младие.

FPlain[ByteNumber] := FPlain[ByteNumber]+(Ord(Hex[i])-Ord('0'))*(15*(i mod 2)+1);

end else if Hex[i] in ['A'..'F'] then begin

FPlain[ByteNumber] := FPlain[ByteNumber]+(Ord(Hex[i])-Ord('A')+10)*(15*(i mod 2)+1);

end else

ExitFlag := true;

end;

if (i mod 2) = 0 then

ByteNumber := ByteNumber+1;

i := i + 1;

end;

end;

function TBlock.PlainToHex: string;

var

i: integer;

begin

Result := '';

for i := 0 to BlockSize-1 do begin

// Старие четыре бита

if (Plain[i] div 16) < 10 then

Result := Result + Chr((Plain[i] div 16) + Ord('0'))

else

Result := Result + Chr((Plain[i] div 16) + Ord('a') - 10);

// Младие четыре бита

if (Plain[i] mod 16) < 10 then

Result := Result + Chr((Plain[i] mod 16) + Ord('0'))

else

Result := Result + Chr((Plain[i] mod 16) + Ord('a') - 10);

end;

end;

function TBlock.bin;

var

i, j: integer;

begin

Result := '';

for i := 0 to BlockSize-1 do begin

for j := 0 to 7 do

Result := Result + IntToStr(Bit[i*8+j]);

Result := Result + ' ';

end;

end;

//*************************************************************************

// Методы класса TPlain

//*************************************************************************

constructor TPlain.Create;

begin

Plain := TBlock.Create(8);

LeftBlock := TBlock.Create(4);

RightBlock := TBlock.Create(4);

EBlock := TBlock.Create(6);

SPBlock := TBlock.Create(4);

end;

destructor TPlain.Destroy;

begin

Plain.Free;

LeftBlock.Free;

RightBlock.Free;

EBlock.Free;

SPBlock.Free;

end;

function TPlain.GetLeft: LongWord;

begin

Result := Plain.Plain[0]*16777216+Plain.Plain[1]*65536+Plain.Plain[2]*256+Plain.Plain[3];

end;

procedure TPlain.SetLeft(Value: LongWord);

begin

Plain.FPlain[0] := Value div 16777216;

Plain.FPlain[1] := (Value div 65536) mod 256;

Plain.FPlain[2] := (Value div 256) mod 256;

Plain.FPlain[3] := Value mod 256;

SetLeftAndRight;

end;

function TPlain.GetRight: LongWord;

begin

Result := Plain.Plain[4]*16777216+Plain.Plain[5]*65536+Plain.Plain[6]*256+Plain.Plain[7];

end;

procedure TPlain.SetRight(Value: LongWord);

begin

Plain.FPlain[4] := (Value div 16777216);

Plain.FPlain[5] := (Value div 65536) mod 256;

Plain.FPlain[6] := (Value div 256) mod 256;

Plain.FPlain[7] := (Value mod 256);

SetLeftAndRight;

end;

procedure TPLain.SetLeftAndRight;

begin

LeftBlock.FPlain[0] := Plain.FPlain[0];

LeftBlock.FPlain[1] := Plain.FPlain[1];

LeftBlock.FPlain[2] := Plain.FPlain[2];

LeftBlock.FPlain[3] := Plain.FPlain[3];

RightBlock.FPlain[0] := Plain.FPlain[4];

RightBlock.FPlain[1] := Plain.FPlain[5];

RightBlock.FPlain[2] := Plain.FPlain[6];

RightBlock.FPlain[3] := Plain.FPlain[7];

end;

procedure TPLain.SetByLeftAndRight;

begin

Plain.FPlain[0] := LeftBlock.FPlain[0];

Plain.FPlain[1] := LeftBlock.FPlain[1];

Plain.FPlain[2] := LeftBlock.FPlain[2];

Plain.FPlain[3] := LeftBlock.FPlain[3];

Plain.FPlain[4] := RightBlock.FPlain[0];

Plain.FPlain[5] := RightBlock.FPlain[1];

Plain.FPlain[6] := RightBlock.FPlain[2];

Plain.FPlain[7] := RightBlock.FPlain[3];

end;

procedure TPlain.GetEBlock;

const

EBlockArray: Array[0..47] of byte = (31, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,

8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,

16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,

24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1);

var

i: byte;

begin

// Процедура выполняет расширяющую перестановку над правой половиной и получает

// 48-битный блок.

for i := 0 to 47 do

EBlock.Bit[i] := RightBlock.Bit[EBlockArray[i]-1];

end;

procedure TPlain.StartPermutation;

const

StartReorderArray: Array[0..63] of byte = (58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,

62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,

57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,

61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7);

var

PlainBuffer: TPlain;

i: integer;

begin

PlainBuffer := TPlain.Create;

PlainBuffer.Plain.Hex := Plain.Hex;

for i:=0 to 63 do

PLain.Bit[i] := PlainBuffer.Plain.Bit[StartReorderArray[i]-1];

PlainBuffer.Destroy;

SetLeftAndRight;

end;

procedure TPlain.XorEBlock(Block48: TBlock);

var

i: byte;

begin

for i:=0 to 47 do

EBlock.Bit[i] := EBlock.Bit[i] xor Block48.Bit[i];

end;

procedure TPlain.EndPermutation;

const

EndReorderArray: Array[0..63] of byte = (40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25);

var

PlainBuffer: TPlain;

i: integer;

begin

PlainBuffer := TPlain.Create;

PlainBuffer.Plain.Hex := Plain.Hex;

for i:=0 to 63 do

Plain.Bit[i] := PlainBuffer.Plain.Bit[EndReorderArray[i]-1];

PlainBuffer.Destroy;

SetLeftAndRight;

end;

procedure TPlain.SBlockPermutation;

const

SBlocksArray: Array[1..8,0..3,0..15] of byte = (((14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7),

( 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8),

( 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0),

(15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13)),

((15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10),

( 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5),

( 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15),

(13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9)),

((10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8),

(13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1),

(13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7),

( 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12)),

(( 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15),

(13, 8, 11, 5, 6,, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9),

(10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4),

( 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14)),

(( 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9),

(14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6),

( 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14),

(11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3)),

((12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11),

(10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8),

( 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6),

( 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13)),

(( 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1),

(13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6),

( 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2),

( 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12)),

((13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7),

( 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2),

( 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8),

( 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11)));

var

i, SValue, ColNumber, RowNumber: byte;

begin

for i:=1 to 8 do begin

// Находим SValue

RowNumber := 2*EBlock.Bit[(i-1)*6] + EBlock.Bit[(i-1)*6+5];

ColNumber := 8*EBlock.Bit[(i-1)*6+1] +

4*EBlock.Bit[(i-1)*6+2] +

2*EBlock.Bit[(i-1)*6+3] +

1*EBlock.Bit[(i-1)*6+4];

SValue := SBlocksArray[i,RowNumber,ColNumber];

SPBlock.Bit[(i-1)*4+0] := 8 and SValue;

SPBlock.Bit[(i-1)*4+1] := 4 and SValue;

SPBlock.Bit[(i-1)*4+2] := 2 and SValue;

SPBlock.Bit[(i-1)*4+3] := 1 and SValue;

end;

end;

procedure TPlain.PBlockPermutation;

const

PBlockArray: array[0..31] of byte = (16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,

2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25);

var

BlockBuffer: TBlock;

i: byte;

begin

BlockBuffer := TBlock.Create(4);

BlockBuffer.Hex := SPBlock.Hex;

for i:=0 to 31 do

SPBlock.Bit[i] := BlockBuffer.Bit[PBlockArray[i]-1];

BlockBuffer.Destroy;

end;

procedure TPlain.Exchange(Round: byte);

var

i: byte;

begin

// По xor LeftBlock объединяется с результатом перестановки в P-блоке (SPBlock).

// Результат объединения пиется в RightBlock. RightBlock пишется в

// LeftBlock.

for i:=0 to 31 do

SPBlock.Bit[i] := SPBlock.Bit[i] xor LeftBlock.Bit[i];

if Round<16 then begin

LeftBlock.Hex := RightBlock.Hex;

RightBlock.Hex := SPBlock.Hex;

end else begin

LeftBlock.Hex := SPBlock.Hex;

end;

SetByLeftAndRight;

end;

//*************************************************************************

// Методы класса TKey

//*************************************************************************

constructor TKey.Create;

begin

Key64 := TBlock.Create(8);

Key56 := TBlock.Create(7);

Key48 := TBlock.Create(6);

end;

destructor TKey.Destroy;

begin

Key64.Destroy;

Key56.Destroy;

Key48.Destroy;

end;

procedure TKey.GetKey56;

const

ReorderArray: Array[0..55] of byte = (57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4);

var

i: integer;

begin

for i:=0 to 55 do

Key56.Bit[i] := Key64.Bit[ReorderArray[i]-1];

end;

procedure TKey.GetKey48(Round: byte; EncDec: boolean);

// EncDec = true - шифровать;

// Иначе - дешифровать.

const

ShiftArray: Array[1..16] of byte = (1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1);

CompressPermutationArray: Array[0..47] of byte = (14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32);

var

i: byte;

procedure ShiftLeft;

var

LeftBit1, LeftBit2, i : byte;

begin

LeftBit1 := Key56.Bit[0];

LeftBit2 := Key56.Bit[28];

for i := 0 to 27 - 1 do begin

Key56.Bit[i] := Key56.Bit[i+1];

Key56.Bit[i+28] := Key56.Bit[i+1+28];

end;

Key56.Bit[27] := LeftBit1;

Key56.Bit[55] := LeftBit2;

end;

procedure ShiftRight;

var

LeftBit1, LeftBit2, i : byte;

begin

LeftBit1 := Key56.Bit[27];

LeftBit2 := Key56.Bit[55];

for i := 27 downto 1 do begin

Key56.Bit[i] := Key56.Bit[i-1];

Key56.Bit[i+28] := Key56.Bit[i-1+28];

end;

Key56.Bit[0] := LeftBit1;

Key56.Bit[28] := LeftBit2;

end;

begin

// В зависимости от раунда, разбиваем Key56 на правую и левую часть с сдвигаем Key56

// на количество бит, задаваемых ShiftArray.

if EncDec then

for i := 1 to ShiftArray[Round] do

ShiftLeft

else

for i := 1 to ShiftArray[Round] do

if Round > 1 then

ShiftRight;

// В Key48 записываем результаты сжимающей перестановки.

for i := 0 to 47 do

Key48.Bit[i] := Key56.Bit[CompressPermutationArray[i]-1];

end;

end.

2 Программа AlgDES

program AlgDES;

{$APPTYPE CONSOLE}

uses

SysUtils,

Des;

var

B64: TBlock;

key : Tkey;

Plain: TPlain;

ci: byte;

begin

plain:= Tplain.Create;

key := tkey.Create;

plain.Plain.Hex := '857439086345123116';

writeln(plain.Plain.Hex);

key.Key64 := plain.Plain;

plain.StartPermutation;

for ci := 1 to 16 do

begin

key.GetKey56;

key.GetKey48(ci,true);

plain.GetEBlock;

plain.XorEBlock(plain.EBlock);

plain.SBlockPermutation;

plain.PBlockPermutation;

plain.Exchange(ci);

writeln(plain.Plain.Hex, ' round ' , ci);

end;

plain.EndPermutation;

writeln(plain.Plain.Hex);

Readln;

end.

Размещено на Allbest.ru