TOP SECRET

by John Amphlett

from ZX Computing Apr/May.1985



John Amphlett, masterspy of Haverford West,

gives us a means of keeping our secrets safe!





This secret message encoding / decoding program (16K

SPECTRUM) combines a high degree of security with ease of

operation. The main features are:-



A) The original clear message consists of capital letters,

spaces and full stops, making an "alphabet" of 28

characters.



B) The coded message, which has the same length as the clear

original, uses 52 characters, 26 normal and 26 underlined

capital letters. This method of distinguishing the second

half of the coded character set was chosen because both the

Spectrum and the typewriter can easily underline already

printed characters in the same print position.



C) The elements of the original message are changed to coded

ones by shifting the ZX character codes up and around the

alphabet "circle". This is done by adding a variety of fixed

and randomly chosen integers to the codes then subtracting

the necessary multiples of 26. Decoding is performed in the

opposite direction.



D) The special feature of this program, and one that really

makes such high security possible, is that one of these

integers is the ZX code of the already processed previous

element. This means that the value of a coded element

depends partly on the value of its immediate predecessor and

therefore the whole coded message is made much more

difficult to break.



On running the program, the operator is asked to enter the

Code Number (which controls the RANDOMIZE function), the

Code Letter (which becomes the first integer to be added to

the first element) and the Station Number (the number of the

originating operator). Then he must enter "E" or "D" for the

encode or decode mode. Next he types in the message, clear

or coded as appropriate, and after pressing ENTER the

processed message is displayed on the screen. Finally, after

the result is verified, both original and processed messages

are displayed together.



For those readers who are interested in programming

techniques, here is a brief description of the program. The

first section (lines 10 to 60) sets up some of the fixed

variables and gives the initial input prompts. Line 60

ensures that the appropriate clear and coded messages appear

on the screen on the right lines by means of variables E and

D. The second section (lines 85 to 140) uses the familiar

"typewriter" routine to enter the original message. The

important part of this section is the OVERprinting routine

in line 120 which adds an underline character U$ to a

previously printed normal letter when the decode mode is

operating. This is done simply by pressing the "0" key

immediately after the letter so to be treated. Mistakes can

be rectified by pressing the "5" key (line 115) then typing

in the correct letter. Repeated pressing of the "5" key will

erase letters as far back as you wish. Line 110 provides a

BEEP sound when typing and an "end of message" signal which

triggers the jump out of the typing loop. The message is

printed out on the screen as you go and is also concatenated

in B$ in line 125 and subsequently transferred to M$ for use

in either of the next two sections. B$ is returned to a null

string while O$ is held ready for the final display.



The encoding section (lines 200 to 275) takes each element

of M$ in turn, carries out the arithmetic, adds an underline

where appropriate and types out the coded result along the

encoding line on the screen. First, the RANDOMIZE function

and the variable T (the code of the "previous" element) are

set outside the encoding loop and the random number

generator and the variable U (the underline signal) are set

inside. Then the two extra characters, the space (code 32)

and the full stop (code 46), are given code numbers

immediately before the beginning of the letter alphabet

(codes 63 and 64 respectively) by line 225. Then, line 230

makes all the even numbers except 90 change U to zero whilst

all the odd numbers except 63 are left set to unity. The

reason for this is that the letters Y and Z will, after the

reverse arithmetic procedure in the decode mode, end up with

codes 63 and 64, the same as the space and full stop, and

will therefore be incorrectly decoded. Hence the Y and Z are

given the underline signal and will have an extra 26 added

in line 355. The next three lines perform the necessary

arithmetic and in line 250 the value of T is changed to that

of the new A and used next time round the loop. Line 255

adds the underline character to the appropriate coded

element. The message is printed out on the encoding line on

the screen letter by letter, and B$ collects them in a

string as before. The last two lines in this section sort

out what happens next, line 275 passes the coded message to

M$ for use in the next section for the verification routine

and to P$ for use in the final section, while line 270

operates in the decode mode and passes straight to the final

section.





Decoding



The decode section (lines 300 to 375) has the same pattern

as the encode section so that most of the action is similar.

There is, however, one major difference. The coded message

M$ is printed near the bottom of the screen and SCREEN$

picks up the elements one by one in line 325. Where there is

an underlined character, it is not recognised in line 330.

The underline is cancelled by being reprinted, U is changed

to unity and the program refers back to line 325 when the

normal letter is now recognised and processed. It may be

argued that the use of SCREEN$ is a rather clumsy way of

doing things. It would be much simpler and neater to use

M$(X) directly. I agree, but it is much more fun to watch

those underlinings disappear one by one when the decoding

section is working. The final section (lines 400 to 420)

clears the screen and displays both the original and

processed messages in full.



Although the program as it stands works well, there is a

limitation. Only one line of 31 characters can be dealt with

at one time. However, it should be fairly easy to make a few

necessary alterations to the print statements to get over

that. Other improvements spring to mind, such as multiple

coding, speedier action (approximately 12 seconds a line at

the moment), expanding the character vocabulary and so on.

Perhaps it is better to leave it to others to develop these

ideas.





Variables



A$  elements of M$          A  arithmetic process

B$  concatenation of A$    B  = A/2 (odd or even)

E$  encode/decode input     D  decode

L$  code letter             E  encode

M$  complete message        N  code number

O$  original message        R  random number

P$  processed message       S  station number

U$  underline character     T  "addition" number

V$  continue prompt         U  underline signal

Z$  one line of spaces      X  loop control

(CHR$ 8 = back space	  CHR$ 128 = blank space)





--

Another Fine Product transcribed by:

Jim Grimwood (jimg@globalnet.co.uk), Weardale, England

--