Приложение б текст основной программы шифрования

.SECTION/DM vars;

/* Init. data */

.var P = 0x8003; /* Pollynom */

.var G = 4952; /* Generator */

.var X = 11497; /* Private */

.var Y = 0; /* Public = 0 */

.var K = 5042; /* Session key */

.var P_A = 0x1001; // A

.var P_B = 0x0011; // B

.var TEMP_A = 0;

.var TEMP_B = 0;

.var TEMP_M = 0;

.var TEMP_RES = 0;

.var TEMP_EXP = 0;

.var TEMP_BASE = 0;

.var EXP_;

.var X_;

.var P_;

.var/circ bank_step[16];

.var cntr_save = 0;

.var cntr_save_in = 0;

.var got_fl = 0;

.var irq_i2_save;

.var irq_i3_save;

.var irq_l2_save;

.var irq_l3_save;

.var/circ rx_buf[32];

.var/circ tx_buf[32];

.var/circ vhod[32];

.var/circ vihod[32];

.SECTION/PM varsp;

// A,B shifrotext RX

.var/circ signal_rx[32] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;

.var/circ signal_tx[16] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0;

.SECTION/PM program;

/* --- VEKTORA PRERYVANIY --- */

jump start; rti; rti; rti; /* Reset */

rti; rti; rti; rti; /* IRQ2 */

rti; rti; rti; rti; /* IRQL1 */

rti; rti; rti; rti; /* IRQL0 */

jump tx_cb; rti; rti; rti; /* SPORT0 TX (bit 3) */

jump rx_cb; rti; rti; rti; /* SPORT0 RX (bit 4) */

start:

dis ar_sat; ena m_mode;

// Nastroika buferov DM pamyati

i0 = rx_buf; l0 = length(rx_buf);

i1 = tx_buf; l1 = length(tx_buf);

m1 = 1;

i2 = vihod; l2 = length(vihod);

i3 = vhod; l3 = length(vhod);

// Nastroika PM buferov

i5 = signal_rx; l5 = length(signal_rx);

i6 = signal_tx; l6 = length(signal_tx);

m5 = 1;

// Nastroika SPORT0

ar = dm(0x3fff); ar = clrbit 0xc of ar; dm(0x3fff) = ar;

AX0 = 0;

dm(0x3FF4) = AX0;

dm(0x3FF5) = AX0;

AX0 = 0x0C00;

dm(0x3FF2) = AX0;

dm(0x3FF3) = AX0;

ar = B#1000100000000111; dm(0x3ff6) = ar;

ar = 0x0200; dm(0x3ff7) = ar; dm(0x3ff9) = ar;

ar = dm(0x3fff); ar = setbit 0xc of ar; dm(0x3fff) = ar;

// Generaciya Y odin raz

CALL find_Y;

// Vkluchenie preryvaniy

ifc = 0x00ff; nop;

imask = 0x0060; nop;

ena ints;

jump MAIN;

// Osn. zicl

MAIN:

ar = dm(got_fl); ar = pass ar;

if eq jump MAIN;

// Copirovanie VHOD -> SIGNAL_RX

i3 = vhod;

l3 = length(vhod);

i5 = signal_rx;

l5 = length(signal_rx);

cntr = 32; // Deshifrator: 32 slov

do copy_in_loop until ce;

ar = dm(i3, m1);

copy_in_loop: pm(i5, m5) = ar;

i5 = signal_rx;

i6 = signal_tx;

CALL ENCRYPT;

// Copirovanie SIGNAL_TX -> VIHOD

i2 = vihod; l2 = length(vihod);

i6 = signal_tx; l6 = length(signal_tx);

cntr = 16; // Vyhod deshifratora: 16 slov

do copy_out_loop until ce;

ar = pm(i6, m5);

copy_out_loop: dm(i2, m1) = ar;

ar = 0; dm(got_fl) = ar;

jump MAIN;

// EL-GAMAL ALGORITM

find_Y:

AR = DM(X); DM(EXP_) = AR;

AR = DM(G); DM(X_) = AR;

CALL UMN_step;

DM(Y) = MR0;

RTS;

// SHIFRATOR

ENCRYPT:

// Obnovlenie K

call gen_K;

// A = G^K

AR = DM(K); DM(EXP_) = AR;

AR = DM(G); DM(X_) = AR;

CALL UMN_step;

DM(TEMP_A) = MR0;

// S = Y^K

AR = DM(K); DM(EXP_) = AR;

AR = DM(Y); DM(X_) = AR;

CALL UMN_step;

dm(P_A) = MR0; // S -> P_A

cntr = 16;

do enc_loop until ce;

// Chitaem M

AR = PM(I5,M5); dm(P_B) = AR; // M -> P_B

DM(TEMP_M) = AR;

AR = DM(TEMP_A); PM(I6, M5) = AR;

call UMN_gf_n;

PM(I6,M5) = MR0;

enc_loop: nop;

RTS;

// generate k kogurentn. (K * 5 + 13) mod 2^16

gen_K:

MX0 = DM(K);

MY0 = 5;

MR = MX0 * MY0 (UU);

AX0 = MR0;

AY0 = 13;

AR = AX0 + AY0;

DM(K) = AR;

RTS;

// step.

UMN_step:

DM(cntr_save) = cntr;

CALL bank_fill;

AX0 = 1; DM(TEMP_RES) = AX0;

AX0 = DM(EXP_); DM(TEMP_EXP) = AX0;

I7 = bank_step;

L7 = length(bank_step);

M5 = 1;

CNTR = 16;

DO bank_loop UNTIL CE;

MY0 = DM(I7, M5);

SI = DM(TEMP_EXP);

SR = LSHIFT SI BY 0 (LO);

AR = TSTBIT 0 OF SR0;

IF EQ JUMP no_bank_mult;

/* Res = Res * Bank[i] */

DM(P_B) = MY0;

AR = DM(TEMP_RES);

DM(P_A) = AR;

CALL UMN_gf_n;

DM(TEMP_RES) = MR0;

no_bank_mult:

// shift exp

SI = DM(TEMP_EXP);

SR = LSHIFT SI BY -1 (LO);

SI = SR0;

DM(TEMP_EXP) = SI;

bank_loop: nop;

MR0 = DM(TEMP_RES);

CNTR = dm(cntr_save);

RTS;

bank_fill:

I7 = bank_step;

L7 = length(bank_step);

M5 = 1;

// Bank[0] = X^1 = X_

AX0 = DM(X_);

DM(I7, M5) = AX0;

DM(TEMP_BASE) = AX0; // save step.

// Bank[1]..Bank[15]

CNTR = 15;

DO fill_loop UNTIL CE;

// Base = Base * Base

AR = DM(TEMP_BASE);

DM(P_A) = AR;

DM(P_B) = AR;

CALL UMN_gf_n;

DM(TEMP_BASE) = MR0;

DM(I7, M5) = MR0;

fill_loop: nop;

RTS;

UMN_gf_n:

dm(cntr_save_in) = CNTR;

AX0 = DM(P_A); SI = DM(P_B); AY1 = DM(P);

MR0 = 0; CNTR = 16;

DO mul_loop UNTIL CE;

SR = LSHIFT SI BY 0 (LO); AR = TSTBIT 0 OF SR0;

IF EQ JUMP no_add;

AY0 = MR0; AR = AX0 XOR AY0; MR0 = AR;

no_add:

SR = LSHIFT SI BY -1 (LO); SI = SR0;

AR = AX0; AY0 = 0x4000; NONE = AR AND AY0;

SR = LSHIFT AR BY 1 (LO); AX0 = SR0;

IF EQ JUMP no_reduce;

AR = AX0; AR = AR XOR AY1; AX0 = AR;

no_reduce:

mul_loop: nop;

CNTR = dm(cntr_save_in);

RTS;

// Int.

tx_cb:

ena sec_reg;

dm(irq_i2_save) = i2; dm(irq_i3_save) = i3;

dm(irq_l2_save) = l2; dm(irq_l3_save) = l3;

i2 = tx_buf; l2 = length(tx_buf);

i3 = vihod; l3 = length(vihod);

cntr = 32;

do vic1 until ce;

ar = dm(i3, m1);

vic1: dm(i2, m1) = ar;

i2 = dm(irq_i2_save); i3 = dm(irq_i3_save);

l2 = dm(irq_l2_save); l3 = dm(irq_l3_save);

dis sec_reg;

rti;

rx_cb:

ena sec_reg;

dm(irq_i2_save) = i2; dm(irq_i3_save) = i3;

dm(irq_l2_save) = l2; dm(irq_l3_save) = l3;

i2 = rx_buf; l2 = length(rx_buf);

i3 = vhod; l3 = length(vhod);

cntr = 32;

do vic2 until ce;

ar = dm(i2, m1);

vic2: dm(i3, m1) = ar;

ar = 0x55; dm(got_fl) = ar;

i2 = dm(irq_i2_save); i3 = dm(irq_i3_save);

l2 = dm(irq_l2_save); l3 = dm(irq_l3_save);

dis sec_reg;

rti;

#include <iostream>

#include <random>

#include <algorithm>

#include <format>

int main() {

constexpr int P = 0b1000'0000'0000'0011; // x^15+x+1

constexpr int ORD = 0b1000'0000'0000'0000 - 1; // 2^15 - 1

auto mul = [](int a, int b) {

int r = 0;

for (int i = 0; i < 15; ++i) {

if (b & 1) r ^= a;

a = (a << 1) ^ (a & 0x4000 ? P : 0);

b >>= 1;

}

return r & ORD;

};

auto pow = [&](int b, int e, int r = 1) {

for (; e > 0; e >>= 1, b = mul(b, b)) {

if (e & 1) r = mul(r, b);

}

return r;

};

std::mt19937 rng{std::random_device{}()};

std::uniform_int_distribution d(2, ORD);

int factors[] = {7, 31, 151}, g;

do {

g = d(rng);

}

while (std::ranges::any_of(factors, [&](int f) {

return pow(g, ORD / f) == 1;

}));

std::cout << std::format(

".var P = 0x{:04x};\n.var G = {};\n.var X = {};\n"

".var Y = 0;\n.var K = {};\n",

P, g, d(rng), d(rng));

}