Основы криптографии

И наконец, последняя часть - цифровые подписи

Цифровые подписи (сигнатура)

B августе 1991 года Национальный институт стандартов и техники Rational Institute of Standards and Technology, MST) предложил для использования в своем Стандарте цифровой подписи (Digital Signature Standard, DSS) Алгоритм цифровой подписи (Digital Signature Algorithm, DSA).

Описание DSA

DSA, представляющий собой вариант алгоритмов подписи EIGamal.

Алгоритм использует следующие параметры :

p = простое число длиной L битов, где L принимает значение, кратное 64, в диапазоне от 512 до 1024 (в первоначальном стандарте размер p был фиксирован и равен 512 битам ).

q = 160-битовой простое число - множитель p-1.

g = h^(p-1)/q mod p, где h - любое число, меньшее p-l, для которого h^(p-1)/q mod p больше 1.

x = число, меньшее q.

у = g^x mod p.

B алгоритме также используется однонаправленная хэш-функция : H(m)

Первые три параметра, p, q и g, открыты и могут быть общими для пользователей сети . Закрытым ключом является x, а открытым - у. Чтобы подписать сообщение, т:

А генерирует случайное число k, меньшее q

А генерирует

r = (g^k mod p) mod q

s = (k^-1 (H(m) + xr)) mod q

Eго подписью служат параметры r и s, он посылает их В.

(3) В проверяет подпись, вычисляяw = s^-1 mod q

u₁ = (H(m} * w) mod q

u₂ = (rw) mod q

v = ((g"¹ *y"² ) mod p) mod q

Если v = r, то подпись правильна.

Таблица представляет собой краткое описание алгоритма.

Подписи DSA

Открытый ключ
p	простое число длиной от 512 до 1024 битов (может использоваться группой пользователей)
q	160-битовый простой множитель р-1
g	=h(p-1)/q mod p, где h любое число меньше p-1, для которого h(p-1)/q >1
y	=gx mod p -p битовое число
Закрытый ключ
x	< q (160-битовое число)
Подпись:
k	выбирается случайно, меньшее q
r	(подпись)=(gk mod p) mod q
s	(подпись)=(k-1 (H(m)+xr)) mod q
Проверка
w	s-1mod q
u1	(H(m)*w)modq
u2	(rw) mod q
V	= ((gu1 *yu2) mod p) mod q
Если v = r, то подпись правильна.

Ускоряющие предварительные вычисления

Ниже приведены примеры скорости работы программных реализаций DSA .

Скорость DSA для различных длин модулей с 160-битовым показателем степени

512битов 768битов 1024битаПодпись 0.20 с 0.43 с 0.57 с

Проверка 0.35c 0.80c 1.27c

Практические реализации DSA часто можно ускорить с помощью предварительных вычислений. Обратите внимание, что значение r не зависит от сообщения. Можно создать строку случайных значений k, и затем рассчитать значения r для каждого из них. Можно также вычислить k^-1 для каждого из этих значений k. Затем, когда приходит сообщение, можно вычислить s для заданных r и k^-1.

Эти предварительные вычисления заметно ускоряют DSA. Ниже приведены сравнения времени вычисления DSA и RSA для конкретной реализации интеллектуальной карточки [

Сравнение времени вычислений RSA и DSA

	DSA	RSA	DSA с общими р, q, g
Глобальные вычисления	Off-card (P)	N/A	Off-card (P)
Генерация ключа	14с	Off-card (S)	4с
Предварительные вычисления	14с	N/A	4с
Подпись	0.03с	15c	0.03с
Проверка	16с	1.5с	Юс
	1-5 с off-card (P)	1-3 с off-card (P)

B обоих алгоритмах используется 512-битовый модуль.

Шифрование ElGamal с DSA

Утверждалось, что DSA так нравится правительству, потому что его нельзя использовать в качестве алгoритма шифрования. Однако можно использовать вызов функции DSA для шифрования EIGamal. Пусть алгоритм реализован как вызов одной функции

DSAsign (p, q, g, k, x, h, r, s)

Задав входные значения p, q, g, k, x и h, можно получить параметры подписи: r и s.

Для шифрования сообщения m алгоритмом EIGamal с помощью открытого ключа у выберем случайное число k и вызовем

DSAsign (p,p, g, k, 0, 0, r, s)

Возвращенное значение r и будет а из схемы EIGamal. Отбросим s. Затем вызовем:

DSAsign (p,p, у, k, 0, 0, r, s)

Переименуем значение r в u, отбросим s. Вызовем

DSAsign (p,p,m,l,u,O,r,s)

Отбросим r. Возвращенное значение s и будет b в схеме EIGamal. Теперь у вас есть шифротекст, а и b. Дешифрирование также просто. Используя закрытый ключ x и шифротекст сообщений, а и b, вызовем

DSAsign (p,p,a,x,0,0,r,s)

Значение r - это a^x mod p. Назовем его e. Затем:

DSAsign (p,p,1,e,b,0,r,s)

Значение s и будет открытым текстом сообщения, m.

Этот способ работает не со всеми реализациями DSA - в некоторых из них могут быть зафиксированы знaчения p и q или длины некоторых других параметров. Тем не менее, если реализация является достаточно общей, то можно шифровать сообщение, не используя ничего, кроме функции цифровой подписи.

Шифрование RSA с DSA

Шифрование RSA еще проще. Используя модуль n, сообщение т и открытый ключ e, вызовем

DSAsign (n,n,m,e,0,0,r,s)

Возвращенное значение r и есть шифротекст. Дешифрирование RSA является точно таким же. Если d - закрытый ключ, то

DSAsign (n,n,m,d,0,0,r,s)

возвращает открытый текст как значение r.

Заключение

В данной работе я дал краткий обзор основных систем криптографии. Следует уточнить- я описывал классические, традиционные, системы шифрования. Конечно существуют и другие реализации симметричных систем (LOKI, NewDES, IDEA, SKIPJAK и.т.д) и систем с открытым ключём (LUC, Rabin)- но принцип действия, у них остается таким-же. Иными словами, я не задавался целью описать все известные системы- целью являлось дать общее описание, и по возможности простым языком.

В конце работы хочу привести исодные коды некоторых алгоритмов (на С)

Недавно меня спросили «А почему С?. Почему, скажем не Delphi, VisualBasic?»

Ответ на данной вопрос довольно прост…. Ну хотябы начнём с того что большинство современных языков базируются на С… точнее будет сказать что концепция обектно-орентированного программирования впервые была применнена в С++.Второе это то что любое написанное на С приложение достаточно легко перенести на другую платформу, например под UNIX. Ну и третьё и заключительное утверждение- Все алгоритмы киптографических систем публикуются и доступны всему миру на С++! Пожалуй этих трех аргументов достаточно, чтоб оправдять и сам выбор языка и меня .

Список литературы

1) Bruce Schneier, "Applied Cryptography: Protocols, Algorithms, and Source Code in C"

2) Landreth, Bill, “A Hacker's Guide to Computer Security”

3) Friedman, W.F., -“Elements of Cryptanalysis”

4) Sarnoff, Jane and Ruffins, Reynold.- “The Code and Cipher Book”

5) Владимир Жельников “Криптография от папируса до компьютер”

6) http://www.cryptography.ru

7) http://www.rsa.com

8) http://www.nsa.gov

9) http://www.pgpi.org

10) http://www.fssr.ru

11) http://www.citforum.ru/internet/securities/cryptobook.shtml

12) http://anmal.narod.ru/secyriti/algorithms/cryptography_algorithms.html

Приложение

DES

// The following DES code has been based and modified from "ALLENDES"

// by Steve Allen. 32 bit modifications, and MS visual C++ wrappers and

// implementations by Aman for inclusion into the "Scramdisk" system for

// MS Windows standard, and 3 key triple des, implemented. CBC feedback

// implemented by the caller. (outer CBC)

#define DES_ENCRYPT 1

#define DES_DECRYPT 0

//#define DEVICEDRIVER // uncomment for driver code......

typedef struct deskey // scramdisk key storage (in ram)

{

unsigned char e[16*8];

unsigned char d[16*8]; // key 2only used in EDE 3des mode......

unsigned char e2[16*8];// key 3 only used in EDE 3des mode

}deskey;

#ifdef DEVICEDRIVER

#pragma VxD_LOCKED_DATA_SEG

#endif

deskey sdisk_des_keys[8]; // 4 scramdisk disks

#if DEVICEDRIVER

#pragma VxD_LOCKED_DATA_SEG

#endif

unsigned long p1[]=

{

0x00000000, 0x00000000,

0x01000000, 0x00000000,

0x00000000, 0x01000000,

0x01000000, 0x01000000,

0x00010000, 0x00000000,

0x01010000, 0x00000000,

0x00010000, 0x01000000,

0x01010000, 0x01000000,

0x00000000, 0x00010000,

0x01000000, 0x00010000,

0x00000000, 0x01010000,

0x01000000, 0x01010000,

0x00010000, 0x00010000,

0x01010000, 0x00010000,

0x00010000, 0x01010000,

0x01010000, 0x01010000,

0x00000000, 0x00000000,

0x00000100, 0x00000000,

0x00000000, 0x00000100,

0x00000100, 0x00000100,

0x00000001, 0x00000000,

0x00000101, 0x00000000,

0x00000001, 0x00000100,

0x00000101, 0x00000100,

0x00000000, 0x00000001,

0x00000100, 0x00000001,

0x00000000, 0x00000101,

0x00000100, 0x00000101,

0x00000001, 0x00000001,

0x00000101, 0x00000001,

0x00000001, 0x00000101,

0x00000101, 0x00000101,

0x00000000, 0x00000000,

0x02000000, 0x00000000,

0x00000000, 0x02000000,

0x02000000, 0x02000000,

0x00020000, 0x00000000,

0x02020000, 0x00000000,

0x00020000, 0x02000000,

0x02020000, 0x02000000,

0x00000000, 0x00020000,

0x02000000, 0x00020000,

0x00000000, 0x02020000,

0x02000000, 0x02020000,

0x00020000, 0x00020000,

0x02020000, 0x00020000,

0x00020000, 0x02020000,

0x02020000, 0x02020000,

0x00000000, 0x00000000,

0x00000200, 0x00000000,

0x00000000, 0x00000200,

0x00000200, 0x00000200,

0x00000002, 0x00000000,

0x00000202, 0x00000000,

0x00000002, 0x00000200,

0x00000202, 0x00000200,

0x00000000, 0x00000002,

0x00000200, 0x00000002,

0x00000000, 0x00000202,

0x00000200, 0x00000202,

0x00000002, 0x00000002,

0x00000202, 0x00000002,

0x00000002, 0x00000202,

0x00000202, 0x00000202,

0x00000000, 0x00000000,

0x04000000, 0x00000000,

0x00000000, 0x04000000,

0x04000000, 0x04000000,

0x00040000, 0x00000000,

0x04040000, 0x00000000,

0x00040000, 0x04000000,

0x04040000, 0x04000000,

0x00000000, 0x00040000,

0x04000000, 0x00040000,

0x00000000, 0x04040000,

0x04000000, 0x04040000,

0x00040000, 0x00040000,

0x04040000, 0x00040000,

0x00040000, 0x04040000,

0x04040000, 0x04040000,

0x00000000, 0x00000000,

0x00000400, 0x00000000,

0x00000000, 0x00000400,

0x00000400, 0x00000400,

0x00000004, 0x00000000,

0x00000404, 0x00000000,

0x00000004, 0x00000400,

0x00000404, 0x00000400,

0x00000000, 0x00000004,

0x00000400, 0x00000004,

0x00000000, 0x00000404,

0x00000400, 0x00000404,

0x00000004, 0x00000004,

0x00000404, 0x00000004,

0x00000004, 0x00000404,

0x00000404, 0x00000404,

0x00000000, 0x00000000,

0x08000000, 0x00000000,

0x00000000, 0x08000000,

0x08000000, 0x08000000,

0x00080000, 0x00000000,

0x08080000, 0x00000000,

0x00080000, 0x08000000,

0x08080000, 0x08000000,

0x00000000, 0x00080000,

0x08000000, 0x00080000,

0x00000000, 0x08080000,

0x08000000, 0x08080000,

0x00080000, 0x00080000,

0x08080000, 0x00080000,

0x00080000, 0x08080000,

0x08080000, 0x08080000,

0x00000000, 0x00000000,

0x00000800, 0x00000000,

0x00000000, 0x00000800,

0x00000800, 0x00000800,

0x00000008, 0x00000000,

0x00000808, 0x00000000,

0x00000008, 0x00000800,

0x00000808, 0x00000800,

0x00000000, 0x00000008,

0x00000800, 0x00000008,

0x00000000, 0x00000808,

0x00000800, 0x00000808,

0x00000008, 0x00000008,

0x00000808, 0x00000008,

0x00000008, 0x00000808,

0x00000808, 0x00000808,

0x00000000, 0x00000000,

0x10000000, 0x00000000,

0x00000000, 0x10000000,

0x10000000, 0x10000000,

0x00100000, 0x00000000,

0x10100000, 0x00000000,

0x00100000, 0x10000000,

0x10100000, 0x10000000,

0x00000000, 0x00100000,

0x10000000, 0x00100000,

0x00000000, 0x10100000,

0x10000000, 0x10100000,

0x00100000, 0x00100000,

0x10100000, 0x00100000,

0x00100000, 0x10100000,

0x10100000, 0x10100000,

0x00000000, 0x00000000,

0x00001000, 0x00000000,

0x00000000, 0x00001000,

0x00001000, 0x00001000,

0x00000010, 0x00000000,

0x00001010, 0x00000000,

0x00000010, 0x00001000,

0x00001010, 0x00001000,

0x00000000, 0x00000010,

0x00001000, 0x00000010,

0x00000000, 0x00001010,

0x00001000, 0x00001010,

0x00000010, 0x00000010,

0x00001010, 0x00000010,

0x00000010, 0x00001010,

0x00001010, 0x00001010,

0x00000000, 0x00000000,

0x20000000, 0x00000000,

0x00000000, 0x20000000,

0x20000000, 0x20000000,

0x00200000, 0x00000000,

0x20200000, 0x00000000,

0x00200000, 0x20000000,

0x20200000, 0x20000000,

0x00000000, 0x00200000,

0x20000000, 0x00200000,

0x00000000, 0x20200000,

0x20000000, 0x20200000,

0x00200000, 0x00200000,

0x20200000, 0x00200000,

0x00200000, 0x20200000,

0x20200000, 0x20200000,

0x00000000, 0x00000000,

0x00002000, 0x00000000,

0x00000000, 0x00002000,

0x00002000, 0x00002000,

0x00000020, 0x00000000,

0x00002020, 0x00000000,

0x00000020, 0x00002000,

0x00002020, 0x00002000,

0x00000000, 0x00000020,

0x00002000, 0x00000020,

0x00000000, 0x00002020,

0x00002000, 0x00002020,

0x00000020, 0x00000020,

0x00002020, 0x00000020,

0x00000020, 0x00002020,

0x00002020, 0x00002020,

0x00000000, 0x00000000,

0x40000000, 0x00000000,

0x00000000, 0x40000000,

0x40000000, 0x40000000,

0x00400000, 0x00000000,

0x40400000, 0x00000000,

0x00400000, 0x40000000,

0x40400000, 0x40000000,

0x00000000, 0x00400000,

0x40000000, 0x00400000,

0x00000000, 0x40400000,

0x40000000, 0x40400000,

0x00400000, 0x00400000,

0x40400000, 0x00400000,

0x00400000, 0x40400000,

0x40400000, 0x40400000,

0x00000000, 0x00000000,

0x00004000, 0x00000000,

0x00000000, 0x00004000,

0x00004000, 0x00004000,

0x00000040, 0x00000000,

0x00004040, 0x00000000,

0x00000040, 0x00004000,

0x00004040, 0x00004000,

0x00000000, 0x00000040,

0x00004000, 0x00000040,

0x00000000, 0x00004040,

0x00004000, 0x00004040,

0x00000040, 0x00000040,

0x00004040, 0x00000040,

0x00000040, 0x00004040,

0x00004040, 0x00004040,

0x00000000, 0x00000000,

0x80000000, 0x00000000,

0x00000000, 0x80000000,

0x80000000, 0x80000000,

0x00800000, 0x00000000,

0x80800000, 0x00000000,

0x00800000, 0x80000000,

0x80800000, 0x80000000,

0x00000000, 0x00800000,

0x80000000, 0x00800000,

0x00000000, 0x80800000,

0x80000000, 0x80800000,

0x00800000, 0x00800000,

0x80800000, 0x00800000,

0x00800000, 0x80800000,

0x80800000, 0x80800000,

0x00000000, 0x00000000,

0x00008000, 0x00000000,

0x00000000, 0x00008000,

0x00008000, 0x00008000,

0x00000080, 0x00000000,

0x00008080, 0x00000000,

0x00000080, 0x00008000,

0x00008080, 0x00008000,

0x00000000, 0x00000080,

0x00008000, 0x00000080,

0x00000000, 0x00008080,

0x00008000, 0x00008080,

0x00000080, 0x00000080,

0x00008080, 0x00000080,

0x00000080, 0x00008080,

0x00008080, 0x00008080

};

unsigned long p2[]=

{

0x00000000, 0x00000000,

0x00000040, 0x00000000,

0x00004000, 0x00000000,

0x00004040, 0x00000000,

0x00400000, 0x00000000,

0x00400040, 0x00000000,

0x00404000, 0x00000000,

0x00404040, 0x00000000,

0x40000000, 0x00000000,

0x40000040, 0x00000000,

0x40004000, 0x00000000,

0x40004040, 0x00000000,

0x40400000, 0x00000000,

0x40400040, 0x00000000,

0x40404000, 0x00000000,

0x40404040, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000040,

0x00000000, 0x00004000,

0x00000000, 0x00004040,

0x00000000, 0x00400000,

0x00000000, 0x00400040,

0x00000000, 0x00404000,

0x00000000, 0x00404040,

0x00000000, 0x40000000,

0x00000000, 0x40000040,

0x00000000, 0x40004000,

0x00000000, 0x40004040,

0x00000000, 0x40400000,

0x00000000, 0x40400040,

0x00000000, 0x40404000,

0x00000000, 0x40404040,

0x00000000, 0x00000000,

0x00000010, 0x00000000,

0x00001000, 0x00000000,

0x00001010, 0x00000000,

0x00100000, 0x00000000,

0x00100010, 0x00000000,

0x00101000, 0x00000000,

0x00101010, 0x00000000,

0x10000000, 0x00000000,

0x10000010, 0x00000000,

0x10001000, 0x00000000,

0x10001010, 0x00000000,

0x10100000, 0x00000000,

0x10100010, 0x00000000,

0x10101000, 0x00000000,

0x10101010, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000010,

0x00000000, 0x00001000,

0x00000000, 0x00001010,

0x00000000, 0x00100000,

0x00000000, 0x00100010,

0x00000000, 0x00101000,

0x00000000, 0x00101010,

0x00000000, 0x10000000,

0x00000000, 0x10000010,

0x00000000, 0x10001000,

0x00000000, 0x10001010,

0x00000000, 0x10100000,

0x00000000, 0x10100010,

0x00000000, 0x10101000,

0x00000000, 0x10101010,

0x00000000, 0x00000000,

0x00000004, 0x00000000,

0x00000400, 0x00000000,

0x00000404, 0x00000000,

0x00040000, 0x00000000,

0x00040004, 0x00000000,

0x00040400, 0x00000000,

0x00040404, 0x00000000,

0x04000000, 0x00000000,

0x04000004, 0x00000000,

0x04000400, 0x00000000,

0x04000404, 0x00000000,

0x04040000, 0x00000000,

0x04040004, 0x00000000,

0x04040400, 0x00000000,

0x04040404, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000004,

0x00000000, 0x00000400,

0x00000000, 0x00000404,

0x00000000, 0x00040000,

0x00000000, 0x00040004,

0x00000000, 0x00040400,

0x00000000, 0x00040404,

0x00000000, 0x04000000,

0x00000000, 0x04000004,

0x00000000, 0x04000400,

0x00000000, 0x04000404,

0x00000000, 0x04040000,

0x00000000, 0x04040004,

0x00000000, 0x04040400,

0x00000000, 0x04040404,

0x00000000, 0x00000000,

0x00000001, 0x00000000,

0x00000100, 0x00000000,

0x00000101, 0x00000000,

0x00010000, 0x00000000,

0x00010001, 0x00000000,

0x00010100, 0x00000000,

0x00010101, 0x00000000,

0x01000000, 0x00000000,

0x01000001, 0x00000000,

0x01000100, 0x00000000,

0x01000101, 0x00000000,

0x01010000, 0x00000000,

0x01010001, 0x00000000,

0x01010100, 0x00000000,

0x01010101, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000001,

0x00000000, 0x00000100,

0x00000000, 0x00000101,

0x00000000, 0x00010000,

0x00000000, 0x00010001,

0x00000000, 0x00010100,

0x00000000, 0x00010101,

0x00000000, 0x01000000,

0x00000000, 0x01000001,

0x00000000, 0x01000100,

0x00000000, 0x01000101,

0x00000000, 0x01010000,

0x00000000, 0x01010001,

0x00000000, 0x01010100,

0x00000000, 0x01010101,

0x00000000, 0x00000000,

0x00000080, 0x00000000,

0x00008000, 0x00000000,

0x00008080, 0x00000000,

0x00800000, 0x00000000,

0x00800080, 0x00000000,

0x00808000, 0x00000000,

0x00808080, 0x00000000,

0x80000000, 0x00000000,

0x80000080, 0x00000000,

0x80008000, 0x00000000,

0x80008080, 0x00000000,

0x80800000, 0x00000000,

0x80800080, 0x00000000,

0x80808000, 0x00000000,

0x80808080, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000080,

0x00000000, 0x00008000,

0x00000000, 0x00008080,

0x00000000, 0x00800000,

0x00000000, 0x00800080,

0x00000000, 0x00808000,

0x00000000, 0x00808080,

0x00000000, 0x80000000,

0x00000000, 0x80000080,

0x00000000, 0x80008000,

0x00000000, 0x80008080,

0x00000000, 0x80800000,

0x00000000, 0x80800080,

0x00000000, 0x80808000,

0x00000000, 0x80808080,

0x00000000, 0x00000000,

0x00000020, 0x00000000,

0x00002000, 0x00000000,

0x00002020, 0x00000000,

0x00200000, 0x00000000,

0x00200020, 0x00000000,

0x00202000, 0x00000000,

0x00202020, 0x00000000,

0x20000000, 0x00000000,

0x20000020, 0x00000000,

0x20002000, 0x00000000,

0x20002020, 0x00000000,

0x20200000, 0x00000000,

0x20200020, 0x00000000,

0x20202000, 0x00000000,

0x20202020, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000020,

0x00000000, 0x00002000,

0x00000000, 0x00002020,

0x00000000, 0x00200000,

0x00000000, 0x00200020,

0x00000000, 0x00202000,

0x00000000, 0x00202020,

0x00000000, 0x20000000,

0x00000000, 0x20000020,

0x00000000, 0x20002000,

0x00000000, 0x20002020,

0x00000000, 0x20200000,

0x00000000, 0x20200020,

0x00000000, 0x20202000,

0x00000000, 0x20202020,

0x00000000, 0x00000000,

0x00000008, 0x00000000,

0x00000800, 0x00000000,

0x00000808, 0x00000000,

0x00080000, 0x00000000,

0x00080008, 0x00000000,

0x00080800, 0x00000000,

0x00080808, 0x00000000,

0x08000000, 0x00000000,

0x08000008, 0x00000000,

0x08000800, 0x00000000,

0x08000808, 0x00000000,

0x08080000, 0x00000000,

0x08080008, 0x00000000,

0x08080800, 0x00000000,

0x08080808, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000008,

0x00000000, 0x00000800,

0x00000000, 0x00000808,

0x00000000, 0x00080000,

0x00000000, 0x00080008,

0x00000000, 0x00080800,

0x00000000, 0x00080808,

0x00000000, 0x08000000,

0x00000000, 0x08000008,

0x00000000, 0x08000800,

0x00000000, 0x08000808,

0x00000000, 0x08080000,

0x00000000, 0x08080008,

0x00000000, 0x08080800,

0x00000000, 0x08080808,

0x00000000, 0x00000000,

0x00000002, 0x00000000,

0x00000200, 0x00000000,

0x00000202, 0x00000000,

0x00020000, 0x00000000,

0x00020002, 0x00000000,

0x00020200, 0x00000000,

0x00020202, 0x00000000,

0x02000000, 0x00000000,

0x02000002, 0x00000000,

0x02000200, 0x00000000,

0x02000202, 0x00000000,

0x02020000, 0x00000000,

0x02020002, 0x00000000,

0x02020200, 0x00000000,

0x02020202, 0x00000000,

0x00000000, 0x00000000,

0x00000000, 0x00000002,

0x00000000, 0x00000200,

0x00000000, 0x00000202,

0x00000000, 0x00020000,

0x00000000, 0x00020002,

0x00000000, 0x00020200,

0x00000000, 0x00020202,

0x00000000, 0x02000000,

0x00000000, 0x02000002,

0x00000000, 0x02000200,

0x00000000, 0x02000202,

0x00000000, 0x02020000,

0x00000000, 0x02020002,

0x00000000, 0x02020200,

0x00000000, 0x02020202

};

unsigned char Pmask[]=

{

0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01

};

unsigned char PC1tbl[]=

{

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00

};

unsigned char PC2tbl[]=

{

0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,

0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00,

0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,

0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,

0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,

0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00,

0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,

0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,

0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00,

0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00

};

unsigned long sp_table[]= // label dword

{

// sp[0]

0x00828000,

0x00000000,

0x00800000,

0x02828000,

0x02808000,

0x02820000,

0x02000000,

0x00800000,

0x00020000,

0x00828000,

0x02828000,

0x00020000,

0x02028000,

0x02808000,

0x00008000,

0x02000000,

0x02020000,

0x00028000,

0x00028000,

0x00820000,

0x00820000,

0x00808000,

0x00808000,

0x02028000,

0x02800000,

0x02008000,

0x02008000,

0x02800000,

0x00000000,

0x02020000,

0x02820000,

0x00008000,

0x00800000,

0x02828000,

0x02000000,

0x00808000,

0x00828000,

0x00008000,

0x00008000,

0x00020000,

0x02808000,

0x00800000,

0x00820000,

0x02008000,

0x00020000,

0x02000000,

0x02028000,

0x02820000,

0x02828000,

0x02800000,

0x00808000,

0x02028000,

0x02008000,

0x02020000,

0x02820000,

0x00828000,

0x02020000,

0x00028000,

0x00028000,

0x00000000,

0x02800000,

0x00820000,

0x00000000,

0x02808000,

//; sp[1]

0x10400840,

0x00400040,

0x00400000,

0x10400800,

0x00000800,

0x10000000,

0x10000840,

0x10400040,

0x10000040,

0x10400840,

0x00400840,

0x00000040,

0x00400040,

0x00000800,

0x10000000,

0x10000840,

0x00400800,

0x10000800,

0x10400040,

0x00000000,

0x00000040,

0x00400000,

0x10400800,

0x00000840,

0x10000800,

0x10000040,

0x00000000,

0x00400800,

0x10400000,

0x00400840,

0x00000840,

0x10400000,

0x00000000,

0x10400800,

0x10000840,

0x00000800,

0x10400040,

0x00000840,

0x00400840,

0x00400000,

0x00000840,

0x00400040,

0x10000000,

0x10400840,

0x10400800,

0x10000000,

0x00400000,

0x00000040,

0x10400000,

0x00400840,

0x00000800,

0x10000040,

0x10000800,

0x10400040,

0x10000040,

0x10000800,

0x00400800,

0x00000000,

0x00400040,

0x10400000,

0x00000040,

0x10000840,

0x10400840,

0x00400800,

//; sp[2]

0x04010000,

0x00010104,

0x00000000,

0x04000104,

0x00010004,

0x00000000,

0x04010100,

0x00010004,

0x04000100,

0x04000004,

0x04000004,

0x00000100,

0x04010104,

0x04000100,

0x00000104,

0x04010000,

0x00000004,

0x04000000,

0x00010104,

0x00010000,

0x00010100,

0x00000104,

0x04000104,

0x04010100,

0x04010004,

0x00010100,

0x00000100,

0x04010004,

0x04000000,

0x04010104,

0x00010000,

0x00000004,

0x00010104,

0x00000004,

0x04000100,

0x04010000,

0x00000100,

0x00010104,

0x00010004,

0x00000000,

0x00010000,

0x04000100,

0x04010104,

0x00010004,

0x04000004,

0x00010000,

0x00000000,

0x04000104,

0x04010004,

0x00000100,

0x00000004,

0x04010104,

0x04000000,

0x04010100,

0x00010100,

0x04000004,

0x00000104,

0x04010004,

0x04010000,

0x00000104,

0x04010100,

0x04000000,

0x04000104,

0x00010100,

//; sp[3]

0x00104080,

0x40100080,

0x40100080,

0x40000000,

0x40104000,

0x40004080,

0x00004080,

0x00100080,

0x00000000,

0x00104000,

0x00104000,

0x40104080,

0x40000080,

0x00000000,

0x40004000,

0x00004080,

0x00000080,

0x00100000,

0x00004000,

0x00104080,

0x40000000,

0x00004000,

0x00100080,

0x40100000,

0x40004080,

0x00000080,

0x40100000,

0x40004000,

0x00100000,

0x40104000,

0x40104080,

0x40000080,

0x40004000,

0x00004080,

0x00104000,

0x40104080,

0x40000080,

0x00000000,

0x00000000,

0x00104000,

0x40100000,

0x40004000,

0x40004080,

0x00000080,

0x00104080,

0x40100080,

0x40100080,

0x40000000,

0x40104080,

0x40000080,

0x00000080,

0x00100000,

0x00004080,

0x00100080,

0x40104000,

0x40004080,

0x00100080,

0x40100000,

0x00004000,

0x00104080,

0x40000000,

0x00004000,

0x00100000,

0x40104000,

//; sp[4]

0x80000000,

0x80000401,

0x00000401,

0x80000021,

0x00000400,

0x80000000,

0x00000020,

0x00000401,

0x80000420,

0x00000400,

0x80000001,

0x80000420,

0x80000021,

0x00000421,

0x80000400,

0x00000020,

0x00000001,

0x00000420,

0x00000420,

0x00000000,

0x80000020,

0x80000421,

0x80000421,

0x80000001,

0x00000421,

0x80000020,

0x00000000,

0x00000021,

0x80000401,

0x00000001,

0x00000021,

0x80000400,

0x00000400,

0x80000021,

0x80000000,

0x00000001,

0x00000020,

0x00000401,

0x80000021,

0x80000420,

0x80000001,

0x00000020,

0x00000421,

0x80000401,

0x80000420,

0x80000000,

0x00000001,

0x00000421,

0x80000421,

0x80000400,

0x00000021,

0x80000421,

0x00000401,

0x00000000,

0x00000420,

0x00000021,

0x80000400,

0x80000001,

0x80000020,

0x00000400,

0x00000000,

0x00000420,

0x80000401,

0x80000020,

//; sp[5]

0x08000010,

0x00002010,

0x00200000,

0x08202010,

0x00002010,

0x08000000,

0x08202010,

0x00002000,

0x00200010,

0x08202000,

0x00002000,

0x08000010,

0x08002000,

0x00200010,

0x00000010,

0x08200000,

0x00000000,

0x08002000,

0x08200010,

0x00200000,

0x00202000,

0x08200010,

0x08000000,

0x08002010,

0x08002010,

0x00000000,

0x08202000,

0x00202010,

0x08200000,

0x00202000,

0x00202010,

0x00000010,

0x00200010,

0x08000000,

0x08002010,

0x00202000,

0x08202010,

0x00002000,

0x08200000,

0x08000010,

0x00002000,

0x00200010,

0x00000010,

0x08200000,

0x08000010,

0x08202010,

0x00202000,

0x00002010,

0x08202000,

0x00202010,

0x00000000,

0x08002010,

0x08000000,

0x00200000,

0x00002010,

0x08202000,

0x00200000,

0x08002000,

0x08200010,

0x00000000,

0x00202010,

0x00000010,

0x08002000,

0x08200010,

//; sp[6]

0x00001000,

0x01001002,

0x01040002,

0x00000000,

0x00040000,

0x01040002,

0x01041000,

0x00041002,

0x01041002,

0x00001000,

0x00000000,

0x01000002,

0x01000000,

0x00000002,

0x01001002,

0x01040000,

0x00040002,

0x01041000,

0x01001000,

0x00040002,

0x01000002,

0x00001002,

0x00041002,

0x01001000,

0x00001002,

0x00040000,

0x01040000,

0x01041002,

0x00041000,

0x01000000,

0x00000002,

0x00041000,

0x00000002,

0x00041000,

0x00001000,

0x01040002,

0x01040002,

0x01001002,

0x01001002,

0x01000000,

0x01001000,

0x00000002,

0x00040002,

0x00001000,

0x00041002,

0x01040000,

0x01041000,

0x00041002,

0x01040000,

0x01000002,

0x01041002,

0x00001002,

0x00041000,

0x00000000,

0x01000000,

0x01041002,

0x00000000,

0x01041000,

0x00001002,

0x00040000,

0x01000002,

0x00040002,

0x00040000,

0x01001000,

//; sp[7]

0x20080008,

0x00080000,

0x00000200,

0x20080208,

0x00000008,

0x20080008,

0x20000000,

0x00000008,

0x20000200,

0x00000208,

0x20080208,

0x00080200,

0x00080208,

0x20080200,

0x00080000,

0x20000000,

0x00000208,

0x20000008,

0x00080008,

0x20080000,

0x00080200,

0x20000200,

0x20000208,

0x00080208,

0x20080000,

0x00000000,

0x00000000,

0x20000208,

0x20000008,

0x00080008,

0x20080200,

0x00000200,

0x20080200,

0x00000200,

0x00080208,

0x00080000,

0x20000000,

0x20000208,

0x00080000,

0x20080200,

0x00080008,

0x20000000,

0x20000008,

0x00000208,

0x20000208,

0x00000008,

0x00000200,

0x20080008,

0x00000000,

0x20080208,

0x20000200,

0x20000008,

0x00000208,

0x00080008,

0x20080008,

0x00000000,

0x20080208,

0x00080200,

0x00080200,

0x20080000,

0x20080000,

0x20000200,

0x00000008,

0x00080208

};

//unsigned char en_keytbl[16*8];

//int loopcount;

//unsigned int block[2];

void des_encrypt(unsigned int *bl,unsigned char* kp,unsigned int mode)

{

static unsigned char * keyptr;

static unsigned int loopcount;

static unsigned int block[2];

keyptr=kp;

block[0]=bl[0];

block[1]=bl[1];

_asm

{

cmp [mode],0

jz decrypt_block

;--------------------------------------------------------------------

; Local PERMUTE for encrypt_block & decrypt_block

;input conditions:

; esi:perm. table ptr

; edx:eax input high and low

; ebp:edi output high and low

; destroys all registers except cx!

;----------------------------------------------------------------------

; void encrypt_block(void);

; encrypts data in (unsigned char block[8] ),

; returning it in the same block[].

;;encrypt_block:

push esi

push edi

push ebp

mov esi, offset p1

mov edx,dword ptr[block]

mov eax,dword ptr[block+4]

call l_permute ;returns with output in ebp:edi

mov eax,edi ;f() input is ebp:eax

mov esi,[keyptr]

add esi,7

mov [loopcount],16 ;yes, this is the full 16 round DES

dxlp1:

and ebx,0ffffh

mov edx,eax ;prepare to operate on right half

mov ecx,eax ;and save it: it becomes left half

bswap edx ;edx has f() input

sub eax,eax ;output gets zero

mov edi,offset sp_table+7*4*64 ;point to combined s & p boxes

rol edx,3 ;prepare for E() function

;THE F() FUNCTION (encrypt)

mov bx,dx ;nybble 1

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 2

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 3

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 4

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 5

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 6

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 7

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ; (E function)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 8

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

xor eax,ebp ;left half^= f(right half,keytbl[n]);

add esi,16 ;point to next keytable

mov ebp,ecx ;old right half becomes new left half

dec [loopcount]

jnz dxlp1

mov esi, offset p2

mov edx,eax

mov eax,ebp

call l_permute

mov ebx,ebp

//mov dword ptr[block],ebp

pop ebp

mov [block],ebx

mov dword ptr[block+4],edi

;;pop ebp

pop edi

pop esi

jmp ddone

;----------------------------------------------------------------------

decrypt_block:

push esi

push edi

push ebp

mov esi, offset p1

mov edx,dword ptr[block] ;get input for l_permute

mov eax,dword ptr[block+4]

call l_permute

mov [loopcount],16 ;yes, this is the full 16 round DES

//ifdef TRIPLE_DES

// mov esi,[de_keyptr]

//else

mov esi,[keyptr]

//endif

add esi,15*8+7

mov eax, edi ;ip.L=op.R

//align 4

dxlp2: and ebx,0ffffh

mov edx,eax ;f() input is ip.L

mov ecx,edx ;op.R=ip.L

bswap edx

sub eax,eax ;output gets zero

mov edi,offset sp_table + 7*4*64 ;point to s&p boxes

rol edx,3 ;set up bits 32,1,2,3,4,5 shl 2

;THE F() FUNCTION (decrypt)

mov bx,dx ;nybble 1

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 2

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 3

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 4

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 5

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec si

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 6

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub edi,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 7

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

ror edx,4 ;(see E Bit-Selection Table)

sub di,4*64 ;sizeof(long)*sizeof(table)

mov bx,dx ;nybble 8

xor bl,[esi] ;XOR with key bits

and bx,11111100b

dec esi

or eax, [ebx+edi] ;set bits for this nybble

xor eax,ebp ;ip.R ^ f(ip.L,keytbl[n]);

mov ebp,ecx ;ip.R=op.R;

dec [loopcount]

jnz dxlp2

mov esi,offset p2 ;set up for inverse permutation

mov edx,eax ;get input

mov eax,ebp

call l_permute

;;mov dword ptr[block],ebp

;;mov dword ptr[block+4],edi

mov ebx,ebp

pop ebp

mov [block],ebx

mov [block+4],edi

pop edi

pop esi

jmp ddone

l_permute:

; do high dword

movzx ebx,dx ;nybble 1

shl bx,3

and bx,1111000b

shr edx,1

mov ebp,[esi+ebx] ;output high

mov edi,[esi+4+ebx] ;output low

add esi,8*16

;@@2:

mov bx,dx ;nybble 2

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 3

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 4

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 5

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 6

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 7

and bx,1111000b

shr edx,4

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx,dx ;nybble 8

and bx,1111000b

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

; do low dword

mov bx,ax ;nybble 1

shl bx,3 ;index * 8

and bx,1111000b

shr eax,1

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

;@@3:

mov bx, ax ;nybble 2

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 3

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 4

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 5

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 6

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 7

and bx,1111000b

shr eax,4 ;next nybble

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

add esi,8*16

mov bx, ax ;nybble 8

and bx,1111000b

or ebp,[esi+ebx]

or edi,[esi+4+ebx]

ret

ddone:

}

bl[0]=block[0];

bl[1]=block[1];

}

void permute(long *op,long *ip, char *tbl,int n)

{

_asm

{

;permute proc near

; arg op:dataptr, ip:dataptr, tbl:dataptr, n:word

; push bp

; mov bp,sp

; push si

; push di

mov ebx,[op]

mov esi,[tbl] ;permutation table to si

mov edi,offset Pmask ;setting-bits in di

mov dword ptr[ebx],0

mov dword ptr[ebx+4],0 ;output=0

mov ebx,[ip]

mov eax,[ebx]

mov edx,[ebx+4] ;input to edx:eax

mov ecx,[n] ;count to cx

pm1: mov ebx,[esi] ;get high dword perm bit

test eax,ebx ;is this bit set?

jnz pmis_hit

mov ebx,[esi+4] ;get low dword perm bit

test edx,ebx ;any action?

jz pmno_hit

pmis_hit:

push esi

mov esi,[op] ;point to output

mov ebx,[edi] ;get setting-bit

or [esi],ebx ;set the bit

mov ebx,[edi+4] ;do for both halves

or [esi+4],ebx ;set bit

pop esi

pmno_hit:

add esi,8 ;next permutation entry

add edi,8 ;next setting-bits entry

loop pm1

; pop di

; pop si

; mov sp,bp

; pop bp

}

}

//;----------------------------------------------------------------------

//; Rotate 28 bits (for KS function)

//; void rotate(long *input,int count);

void rotate(long *input,int count)

//rotate proc near

// arg input:dataptr,count:word

{

_asm

{

mov ecx,[count]

mov ebx, [input]

mov eax,[ebx]

bswap eax ;get bits in good order

xor ebx,ebx

shld ebx, eax,cl ;shift high bits to bl

shl eax,cl

shl ebx,4 ;move from bit 32 to bit 28

add eax,ebx

mov ebx,[input]

bswap eax ;reverse bytes...

mov [ebx],eax ;...so they store correctly

}

}

void set_table(char*input,int num,long*tbl)

{

_asm

{

;----------------------------------------------------------------------

; void set_table(char*input,int n,long*keytbl);

; Take a 48-bit input, and make 8 bytes of 6 bits each.

; Output goes into tbl[].

;align 16

;proc set_table near

; arg input:dataptr,num:word, tbl:dataptr

;push bp

;mov bp,sp

;push di

mov edi, [tbl]

mov eax,[num]

mov bl,8

mul bl

add edi,eax ;now di points to proper offset in keytbl

mov ebx,[input]

mov dx,word ptr[ebx+4]

bswap edx ;edx highbits now has highbits of key sched.

mov ebx,[ebx]

bswap ebx ;ebx gets 48 bits of key sched.

mov cx,8 ;loop count

stble1: shld eax,ebx,6 ;get next 6 bits

shld ebx,edx,6

shl edx,6

shl ax,2 ;pre-shift for sizeof(long) in f() function

and al,11111100b

mov [edi],al

inc edi

loop stble1

;pop di

;mov sp,bp

;pop bp

}

}

void des_key_sched(char * password, unsigned char *keytble)

{

static char *input;

static unsigned char *tbl;

static unsigned long block1[2];

static unsigned long temp [2];

static loopcount;

static unsigned short r_sched[]=

{

1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1

};

input=password;

tbl=keytble;

_asm

{

;----------------------------------------------------------------------

; void schedule(char *password long keytbl[]);

; Expand a password into 16 rounds of Key Schedule.

; Output goes into extern keytbl[16][8]

; (This is not a time-critical function, and I simply

; rewrote the c source into assembler, to make

; DES programming a 2-step process-- schedule the key,

; encrypt/decrypt the block.)

;align 16

;proc schedule

; arg input:dataptr, tbl:dataptr

push ebp

;mov bp,sp

push edi

push 64

push offset PC1tbl

mov ebx,[input]

push ebx

push offset temp

call permute ;select 56 bits

add sp,8*2

mov ecx,16

mov [loopcount],ecx

xor edi,edi

sch1:

mov ebx,edi

shl ebx,1

add ebx,offset r_sched

movzx eax,[word ptr ebx]

push eax ;save for 2nd rotate

push eax ;arg for rotate func.

push offset temp

call rotate

add esp,4*2

push offset temp+4

call rotate

add esp,4*2

push 48

push offset PC2tbl ;perm table

push offset temp ;input

push offset block1 ;output

call permute

add esp,8*2

mov eax,[tbl]

push eax

push edi ;table number

push offset block1 ;input

call set_table

add esp,6*2

inc edi

dec [loopcount]

jnz sch1

mov ebx,[input] ;erase the password space

mov cx,4

xor ax,ax

sch2: mov [ebx],ax

inc ebx

inc ebx

loop sch2

pop edi

pop ebp

jmp scdone

;;set_table:

scdone:

}

}

// Scramdisk specific code.....

//key schedules

// Three key triple des...

void desencipher(unsigned long *b, int slot)

{

des_encrypt(b,sdisk_des_keys[slot].e,DES_ENCRYPT);

}

void threedesencipher(unsigned long *b, int slot)

{

des_encrypt(b, sdisk_des_keys[slot].e,DES_ENCRYPT);

des_encrypt(b, sdisk_des_keys[slot].d,DES_DECRYPT);

des_encrypt(b, sdisk_des_keys[slot].e2,DES_ENCRYPT);

}

void desdecipher(unsigned long *b, int slot)

{

des_encrypt(b, sdisk_des_keys[slot].e,DES_DECRYPT);

}

void threedesdecipher(unsigned long *b, int slot)

{

des_encrypt(b, sdisk_des_keys[slot].e2,DES_DECRYPT);

des_encrypt(b, sdisk_des_keys[slot].d,DES_ENCRYPT);

des_encrypt(b, sdisk_des_keys[slot].e,DES_DECRYPT);

}

void desinitialise(char *key,int slot)

{

des_key_sched(key,sdisk_des_keys[slot].e);

}

void threedesinitialise(char *key,int slot)

{

char *key2=key+8;

char *key3=key2+8;

des_key_sched(key,sdisk_des_keys[slot].e);

des_key_sched(key2,sdisk_des_keys[slot].d);

des_key_sched(key3,sdisk_des_keys[slot].e2);

}

//;1F08260D1AC2465E 6B056E18759F5CCA EF1BF03E5DFA575A

void main (void) //test code

{

//char keytable[16*8];

unsigned char key[]=

{

0x1f,0x08,0x26,0x0d,0x1a,0xc2,0x46,0x5e

};

unsigned char key3[]=

{

0x1f,0x08,0x26,0x0d,0x1a,0xc2,0x46,0x5e,

0x44,0x28,0x1d,0x6b,0x61,0x11,0x52,0x47,

0x12,0x41,0x34,0x26,0x1d,0x3e,0xf4,0x45

};

unsigned char cipher[]=

{

0xef,0x1b,0xf0,0x3e,0x5d,0xfa,0x57,0x5a //cipher text...

};

//void Eblock(unsigned int mode,unsigned int *kp,unsigned int *bl)

//des_key_sched((unsigned char *) &key,keytable);

//des_encrypt((unsigned int *) cipher,keytable,0);

//des_encrypt((unsigned int *) cipher,keytable,1);

desinitialise(key,0);

desdecipher((unsigned long *) cipher,0);

desencipher((unsigned long *) cipher,0);

threedesinitialise(key3,0);

threedesdecipher((unsigned long *) cipher,0);

threedesencipher((unsigned long *) cipher,0);

cout<< Enter key;

}

GOST

/*

* The GOST 28147-89 cipher

*

* This is based on the 25 Movember 1993 draft translation

* by Aleksandr Malchik, with Whitfield Diffie, of the Government

* Standard of the U.S.S.R. GOST 28149-89, "Cryptographic Transformation

* Algorithm", effective 1 July 1990. (Whitfield.Diffie@eng.sun.com)

*

* That is a draft, and may contain errors, which will be faithfully

* reflected here, along with possible exciting new bugs.

*

* Some details have been cleared up by the paper "Soviet Encryption

* Algorithm" by Josef Pieprzyk and Leonid Tombak of the University

* of Wollongong, New South Wales. (josef/leo@cs.adfa.oz.au)

*

* The standard is written by A. Zabotin (project leader), G.P. Glazkov,

* and V.B. Isaeva. It was accepted and introduced into use by the

* action of the State Standards Committee of the USSR on 2 June 89 as

* No. 1409. It was to be reviewed in 1993, but whether anyone wishes

* to take on this obligation from the USSR is questionable.

*

* This code is placed in the public domain.

*/

/*

* If you read the standard, it belabors the point of copying corresponding

* bits from point A to point B quite a bit. It helps to understand that

* the standard is uniformly little-endian, although it numbers bits from

* 1 rather than 0, so bit n has value 2^(n-1). The least significant bit

* of the 32-bit words that are manipulated in the algorithm is the first,

* lowest-numbered, in the bit string.

*/

/* A 32-bit data type */

#ifdef __alpha /* Any other 64-bit machines? */

typedef unsigned int word32;

#else

typedef unsigned long word32;

#endif

/*

* The standard does not specify the contents of the 8 4 bit->4 bit

* substitution boxes, saying they're a parameter of the network

* being set up. For illustration purposes here, I have used

* the first rows of the 8 S-boxes from the DES. (Note that the

* DES S-boxes are numbered starting from 1 at the msb. In keeping

* with the rest of the GOST, I have used little-endian numbering.

* Thus, k8 is S-box 1.

*

* Obviously, a careful look at the cryptographic properties of the cipher

* must be undertaken before "production" substitution boxes are defined.

*

* The standard also does not specify a standard bit-string representation

* for the contents of these blocks.

*/

static unsigned char const k8[16] = {

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

static unsigned char const k7[16] = {

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

static unsigned char const k6[16] = {

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

static unsigned char const k5[16] = {

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

static unsigned char const k4[16] = {

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

static unsigned char const k3[16] = {

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

static unsigned char const k2[16] = {

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

static unsigned char const k1[16] = {

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

/* Byte-at-a-time substitution boxes */

static unsigned char k87[256];

static unsigned char k65[256];

static unsigned char k43[256];

static unsigned char k21[256];

/*

* Build byte-at-a-time subtitution tables.

* This must be called once for global setup.

*/

void

kboxinit(void)

{

int i;

for (i = 0; i < 256; i++) {

k87[i] = k8[i >> 4] << 4 | k7[i & 15];

k65[i] = k6[i >> 4] << 4 | k5[i & 15];

k43[i] = k4[i >> 4] << 4 | k3[i & 15];

k21[i] = k2[i >> 4] << 4 | k1[i & 15];

}

}

/*

* Do the substitution and rotation that are the core of the operation,

* like the expansion, substitution and permutation of the DES.

* It would be possible to perform DES-like optimisations and store

* the table entries as 32-bit words, already rotated, but the

* efficiency gain is questionable.