# Create A Program In Masm That Allows You To Encode And Decode Messages With Simple Substitution Cypher Assignment Solution.

## Instructions

Objective
Write a program in MASM that allows you to encode and decode messages with simple substitution cypher assignment solution.

## Requirements and Specifications

Objectives
1. Working on a project that utilizes a broad spectrum of knowledge from this course
2. Using various forms of indirect addressing
3. Passing parameters on the stack
4. Extensive interaction with arrays
Description:
Alex and Sila are espionage agents working for the Top Secret Agency (TSA). Sometimes they discuss sensitive intelligence information that needs to be kept secret from the Really Bad Guys (RBG). Alex and Sila have decided to use a simple obfuscation algorithm that should be good enough to confuse the RBG. As the TSA’s resident programmer you’ve been assigned to write a MASM procedure that will implement the requested behavior. Your code must be capable of encrypting and decrypting messages (and meet the other requirements given in this document). This final project is written less like an academic assignment and more like a real-life programming task. This might seem daunting at first but don’t despair! Algorithm Details Ankur and Sila’s algorithm is a simple substitution cipher. If you are not familiar with substitution ciphers, I suggest reading the Wikipedia page (available here: Links to an external site.). For this implementation, the key consists of 26 lowercase English letters. The following example demonstrates the obfuscation algorithm that Ankur and Sila are requesting. Suppose that you are provided the following 26 character secret key: efbcdghijklmnopqrstuvwxyza. Each character listed in the key corresponds to a character from the English alphabet. In other words, the key is a map that tells you how to take the original text (also known as plaintext) and replace each letter with the encrypted character. In order to understand the key, consider the alphabetical arrangement of the English alphabet beginning with a, b, c, d, e, f, (and so on). Now reconsider the key, which starts with e, f, b, c, d, g, (and so on).
Screenshots of output
Source Code
Computer.asm
```INCLUDE Irvine32.inc .code ;------------------------------------------ compute PROC ; ; Computes the operation given as argument ; Receives: for the decoy mode: ; 16 bit signed WORD operand ; 16 bit signed WORD operand ; 32 bit OFFSET of a signed DWORD ; For the encryption mode: ; 32 bit OFFSET of a BYTE array ; 32 bit OFFSET of a BYTE array ; 32 bit OFFSET of a signed DWORD ; For the decryption mode: ; 32 bit OFFSET of a BYTE array ; 32 bit OFFSET of a BYTE array ; 32 bit OFFSET of a signed DWORD ; For the key generation mode: ; 32 bit OFFSET of a BYTE array ; 32 bit OFFSET of signed DWORD ; Returns: nothing ;------------------------------------------     push ebp     mov ebp, esp     push ebx     mov ebx, [ebp + 8] ; load dest address     cmp DWORD PTR [ebx], -1 ; check selected mode     je callEnc ; if -1, encrypt     cmp DWORD PTR [ebx], -2 ; check selected mode     je callDec ; if -2, decrypt     cmp DWORD PTR [ebx], -3 ; check selected mode     je callGen ; if -3, generate     ; else, use decoy mode     mov ax, [ebp + 12] ; pass numbers to procedure     push ax     mov ax, [ebp + 14]     push ax     call addNumbers ; add numbers     add esp, 4 ; remove args from stack     mov [ebx], eax ; save result     jmp compRet callEnc:     mov eax, [ebp + 16] ; pass pointers to procedure     push eax     mov eax, [ebp + 12]     push eax     call encrypt ; encrypt message     add esp, 8 ; remove args from stack     jmp compRet callDec:     mov eax, [ebp + 16] ; pass pointers to procedure     push eax     mov eax, [ebp + 12]     push eax     call decrypt ; decrypt message     add esp, 8 ; remove args from stack     jmp compRet callGen:     call Randomize     mov eax, [ebp + 12] ; pass pointer to procedure     push eax     call generateKey ; generate key     add esp, 4 ; remove arg from stack compRet:     pop ebx     pop ebp     ret compute ENDP ;------------------------------------------ addNumbers PROC ; ; Calculates the sum of two signed WORD numbers ; Receives: two signed WORD arguments in the stack ; Returns: sum of the two numbers in eax ;------------------------------------------     push ebp     mov ebp, esp     push ebx     movsx eax, SWORD PTR [ebp + 8] ; load first number     movsx ebx, SWORD PTR [ebp + 10] ; load second number     add eax, ebx ; return sum     pop ebx     pop ebp     ret addNumbers ENDP ;------------------------------------------ encrypt PROC ; ; Encrypts the message passed as argument using the ; given key ; Receives: two string addresses in stack ; Returns: nothing ;------------------------------------------     push ebp     mov ebp, esp     push esi     push edi     mov esi, [ebp + 12] ; load key pointer     mov edi, [ebp + 8] ; load message pointer     mov eax, 0 encLoop:     mov al, [edi] ; load char from message     cmp al, 0 ; if end of string     je encRet ; terminate     cmp al, 'a' ; see if it's a letter     jl encSkip ; if not, do not encrypt     cmp al, 'z' ; see if it's a letter     jg encSkip ; if not, do not encrypt     sub al, 'a' ; convert to 0-25     mov al, [esi + eax] ; load encrypted char     mov [edi], al ; save encrypted char encSkip:     inc edi ; advance to next char in message     jmp encLoop encRet:     pop edi     pop esi     pop ebp     ret encrypt ENDP ;------------------------------------------ decrypt PROC ; ; Decrypts the message passed as argument using the ; given key ; Receives: two string addresses in stack ; Returns: nothing ;------------------------------------------     push ebp     mov ebp, esp     push esi     push edi     mov esi, [ebp + 12] ; load key pointer     mov edi, [ebp + 8] ; load message pointer     mov eax, 0 decLoop:     mov al, [edi] ; load char from message     cmp al, 0 ; if end of string     je decRet ; terminate     cmp al, 'a' ; see if it's a letter     jl decSkip ; if not, do not decrypt     cmp al, 'z' ; see if it's a letter     jg decSkip ; if not, do not decrypt     mov ecx, 0 ; find letter in key find:     cmp al, [esi + ecx] ; see if we found the letter in the key     je found ; if so, end     inc ecx ; advance to next char     jmp find found:     add cl, 'a' ; convert position to ascii     mov [edi], cl ; save decrypted char decSkip:     inc edi ; advance to next char in message     jmp decLoop decRet:     pop edi     pop esi     pop ebp     ret decrypt ENDP ;------------------------------------------ generateKey PROC ; ; Generates a new key and saves it in the argument ; Receives: one string addresses in stack ; Returns: nothing ;------------------------------------------     push ebp     mov ebp, esp     push edi     push ebx     push ecx     push edx     mov edi, [ebp + 8] ; load key pointer     ; fill key with letters in order     mov ecx, 26     mov al, 'a' fill:     mov [edi], al     inc edi     inc al     loop fill     mov edi, [ebp + 8] ; reload key pointer     ; shuffle 26 times     mov ecx, 26 shuffle:     ; generate pair to exchange     mov eax, 26     call RandomRange     mov edx, eax     mov eax, 26     call RandomRange     ; save old chars     mov bl, [edi + eax]     mov bh, [edi + edx]     ; swap them     mov [edi + eax], bh     mov [edi + edx], bl     loop shuffle     pop edx     pop ecx     pop ebx     pop edi     pop ebp     ret generateKey ENDPEND ```
Main.asm
```INCLUDE Irvine32.inc EXTERN compute@0:PROC compute EQU compute@0 .data operand1 WORD 46 operand2 WORD -20 dest0 DWORD 0 myKey BYTE "efbcdghijklmnopqrstuvwxyza" message BYTE "the contents of this message will be a mystery.",0 dest1 DWORD -1 dest2 DWORD -2 newKey BYTE 26 DUP(?)         BYTE 0 dest3 DWORD -3.code main PROC     push operand1     push operand2     push OFFSET dest0     call compute     add esp, 8     mov eax, dest0     call WriteInt     call CrLf     push OFFSET myKey     push OFFSET message     push OFFSET dest1     call compute     add esp, 12     mov edx, OFFSET message     call WriteString     call CrLf     push OFFSET myKey     push OFFSET message     push OFFSET dest2     call compute     add esp, 12     mov edx, OFFSET message     call WriteString     call CrLf     push OFFSET newKey     push OFFSET dest3     call compute     add esp, 8     mov edx, OFFSET newKey     call WriteString     call CrLf     call CrLf     call WaitMsg     exit main ENDP END main```