Add affine-cipher exercise (#242)

config.json

@@ -492,6 +492,14 @@
         "prerequisites": [],
         "difficulty": 6
       },
+      {
+        "slug": "affine-cipher",
+        "name": "Affine Cipher",
+        "uuid": "08480307-7d42-49ed-b6b7-2080bba8894e",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 7
+      },
       {
         "slug": "all-your-base",
         "name": "All Your Base",

exercises/practice/affine-cipher/.docs/instructions.append.md

@@ -0,0 +1,3 @@
+# Instructions
+
+If `a` is not coprime to `m`, output an empty string.

exercises/practice/affine-cipher/.docs/instructions.md

@@ -0,0 +1,74 @@
+# Instructions
+
+Create an implementation of the affine cipher, an ancient encryption system created in the Middle East.
+
+The affine cipher is a type of monoalphabetic substitution cipher.
+Each character is mapped to its numeric equivalent, encrypted with a mathematical function and then converted to the letter relating to its new numeric value.
+Although all monoalphabetic ciphers are weak, the affine cipher is much stronger than the atbash cipher, because it has many more keys.
+
+[//]: # " monoalphabetic as spelled by Merriam-Webster, compare to polyalphabetic "
+
+## Encryption
+
+The encryption function is:
+
+```text
+E(x) = (ai + b) mod m
+```
+
+Where:
+
+- `i` is the letter's index from `0` to the length of the alphabet - 1.
+- `m` is the length of the alphabet.
+  For the Roman alphabet `m` is `26`.
+- `a` and `b` are integers which make up the encryption key.
+
+Values `a` and `m` must be _coprime_ (or, _relatively prime_) for automatic decryption to succeed, i.e., they have number `1` as their only common factor (more information can be found in the [Wikipedia article about coprime integers][coprime-integers]).
+In case `a` is not coprime to `m`, your program should indicate that this is an error.
+Otherwise it should encrypt or decrypt with the provided key.
+
+For the purpose of this exercise, digits are valid input but they are not encrypted.
+Spaces and punctuation characters are excluded.
+Ciphertext is written out in groups of fixed length separated by space, the traditional group size being `5` letters.
+This is to make it harder to guess encrypted text based on word boundaries.
+
+## Decryption
+
+The decryption function is:
+
+```text
+D(y) = (a^-1)(y - b) mod m
+```
+
+Where:
+
+- `y` is the numeric value of an encrypted letter, i.e., `y = E(x)`
+- it is important to note that `a^-1` is the modular multiplicative inverse (MMI) of `a mod m`
+- the modular multiplicative inverse only exists if `a` and `m` are coprime.
+
+The MMI of `a` is `x` such that the remainder after dividing `ax` by `m` is `1`:
+
+```text
+ax mod m = 1
+```
+
+More information regarding how to find a Modular Multiplicative Inverse and what it means can be found in the [related Wikipedia article][mmi].
+
+## General Examples
+
+- Encrypting `"test"` gives `"ybty"` with the key `a = 5`, `b = 7`
+- Decrypting `"ybty"` gives `"test"` with the key `a = 5`, `b = 7`
+- Decrypting `"ybty"` gives `"lqul"` with the wrong key `a = 11`, `b = 7`
+- Decrypting `"kqlfd jzvgy tpaet icdhm rtwly kqlon ubstx"` gives `"thequickbrownfoxjumpsoverthelazydog"` with the key `a = 19`, `b = 13`
+- Encrypting `"test"` with the key `a = 18`, `b = 13` is an error because `18` and `26` are not coprime
+
+## Example of finding a Modular Multiplicative Inverse (MMI)
+
+Finding MMI for `a = 15`:
+
+- `(15 * x) mod 26 = 1`
+- `(15 * 7) mod 26 = 1`, ie. `105 mod 26 = 1`
+- `7` is the MMI of `15 mod 26`
+
+[mmi]: https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+[coprime-integers]: https://en.wikipedia.org/wiki/Coprime_integers

exercises/practice/affine-cipher/.gitignore

@@ -0,0 +1,2 @@
+*.o
+tests

exercises/practice/affine-cipher/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "files": {
+    "solution": [
+      "affine_cipher.asm"
+    ],
+    "test": [
+      "affine_cipher_test.c"
+    ],
+    "example": [
+      ".meta/example.asm"
+    ]
+  },
+  "blurb": "Create an implementation of the Affine cipher, an ancient encryption algorithm from the Middle East.",
+  "source": "Wikipedia",
+  "source_url": "https://en.wikipedia.org/wiki/Affine_cipher"
+}

exercises/practice/affine-cipher/.meta/example.asm

@@ -0,0 +1,116 @@
+default rel
+
+section .rodata
+
+reciprocal: db 0,1,0,9,0,21,0,15,0,3,0,19,0,0,0,7,0,23,0,11,0,5,0,17,0,25
+
+section .text
+global encode, decode
+
+;   rdi - buffer
+;   rsi - string
+;   rdx - a
+;   rcx - b
+
+;   r8 - chunk size
+;   r9 - 26
+;   r10 - effective a
+;   r11 - effective b
+;   r12 - remainder of chunk
+;   r13 - digit (0..9) or letter (0..25)
+decode:
+    xor r8, r8 ; no chunking
+    jmp process
+
+encode:
+    mov r8, 5
+
+process:
+    cld ; each lodsb/stosb will increment rsi/rdi
+    mov r9, 26
+    cmp rdx, r9
+    jae .reject ; out of range for reciprocal table
+
+    lea r11, [reciprocal]
+    xor r10, r10
+    mov r10b, byte [r11 + rdx]
+    test r10, r10
+    jz .reject ; a is not coprime to m
+
+    push r12
+    push r13
+    xor r13, r13
+    test r8, r8
+    jz .invert
+
+    mov r10, rdx ; a
+    mov r11, rcx ; b
+    mov r12, r8 ; chunk size
+    jmp .read
+
+.invert:
+    xor rax, rax
+
+.shift:
+    add rax, r9
+    cmp rax, rcx
+    jb .shift
+
+    sub rax, rcx ; -b, shifted by 26 until non-negative
+    mul r10 ; multiply by effective a
+    mov r11, rax ; effective b
+    mov r12, -1 ; no chunking
+    jmp .read
+
+.classify:
+    mov r13b, al
+    sub r13b, '0'
+    cmp r13b, 10
+    jb .write ; jump if we have a digit
+
+    mov r13b, al
+    or r13b, 32 ; force to lower-case
+    sub r13b, 'a'
+    cmp r13b, r9b
+    jae .read ; jump if we do not have a letter
+
+    mov rax, r10
+    mul r13
+    add rax, r11 ; effective a * letter index + effective b
+    xor rdx, rdx
+    div r9
+    mov rax, rdx ; remainder when divided by 26
+    add rax, 'a'
+
+.write:
+    test r12, r12
+    jnz .write_letter_or_digit
+
+    mov r12, r8 ; start a new chunk
+    mov r13b, al
+    mov al, ' '
+    stosb
+    mov al, r13b
+
+.write_letter_or_digit:
+    stosb
+    dec r12
+
+.read:
+    lodsb
+    test al, al
+    jnz .classify
+
+    pop r13
+    pop r12
+    xor rax, rax
+    stosb
+    ret
+
+.reject:
+    mov byte [rdi], 0
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif

exercises/practice/affine-cipher/.meta/tests.toml

@@ -0,0 +1,58 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[2ee1d9af-1c43-416c-b41b-cefd7d4d2b2a]
+description = "encode -> encode yes"
+
+[785bade9-e98b-4d4f-a5b0-087ba3d7de4b]
+description = "encode -> encode no"
+
+[2854851c-48fb-40d8-9bf6-8f192ed25054]
+description = "encode -> encode OMG"
+
+[bc0c1244-b544-49dd-9777-13a770be1bad]
+description = "encode -> encode O M G"
+
+[381a1a20-b74a-46ce-9277-3778625c9e27]
+description = "encode -> encode mindblowingly"
+
+[6686f4e2-753b-47d4-9715-876fdc59029d]
+description = "encode -> encode numbers"
+
+[ae23d5bd-30a8-44b6-afbe-23c8c0c7faa3]
+description = "encode -> encode deep thought"
+
+[c93a8a4d-426c-42ef-9610-76ded6f7ef57]
+description = "encode -> encode all the letters"
+
+[0673638a-4375-40bd-871c-fb6a2c28effb]
+description = "encode -> encode with a not coprime to m"
+
+[3f0ac7e2-ec0e-4a79-949e-95e414953438]
+description = "decode -> decode exercism"
+
+[241ee64d-5a47-4092-a5d7-7939d259e077]
+description = "decode -> decode a sentence"
+
+[33fb16a1-765a-496f-907f-12e644837f5e]
+description = "decode -> decode numbers"
+
+[20bc9dce-c5ec-4db6-a3f1-845c776bcbf7]
+description = "decode -> decode all the letters"
+
+[623e78c0-922d-49c5-8702-227a3e8eaf81]
+description = "decode -> decode with no spaces in input"
+
+[58fd5c2a-1fd9-4563-a80a-71cff200f26f]
+description = "decode -> decode with too many spaces"
+
+[b004626f-c186-4af9-a3f4-58f74cdb86d5]
+description = "decode -> decode with a not coprime to m"

exercises/practice/affine-cipher/Makefile

@@ -0,0 +1,46 @@
+AS = nasm
+
+CFLAGS = -g -Wall -Wextra -pedantic -Werror
+LDFLAGS =
+ASFLAGS = -g -F dwarf -Werror
+
+ifeq ($(shell uname -s),Darwin)
+ifeq ($(shell sysctl -n hw.optional.arm64 2>/dev/null),1)
+	ALL_CFLAGS = -target x86_64-apple-darwin
+endif
+	ALL_LDFLAGS = -Wl,-pie
+	ALL_ASFLAGS = -f macho64 --prefix _
+else
+	ALL_LDFLAGS = -pie -Wl,--fatal-warnings
+	ALL_ASFLAGS = -f elf64
+endif
+
+ALL_CFLAGS += -std=c99 -fPIE -m64 $(CFLAGS)
+ALL_LDFLAGS += $(LDFLAGS)
+ALL_ASFLAGS += $(ASFLAGS)
+
+C_OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
+AS_OBJS = $(patsubst %.asm,%.o,$(wildcard *.asm))
+ALL_OBJS = $(filter-out example.o,$(C_OBJS) $(AS_OBJS) vendor/unity.o)
+
+CC_CMD = $(CC) $(ALL_CFLAGS) -c -o $@ $<
+
+all: tests
+	@./$<
+
+tests: $(ALL_OBJS)
+	@$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -o $@ $(ALL_OBJS)
+
+%.o: %.asm
+	@$(AS) $(ALL_ASFLAGS) -o $@ $<
+
+%.o: %.c
+	@$(CC_CMD)
+
+vendor/unity.o: vendor/unity.c vendor/unity.h vendor/unity_internals.h
+	@$(CC_CMD)
+
+clean:
+	@rm -f *.o vendor/*.o tests
+
+.PHONY: all clean

exercises/practice/affine-cipher/affine_cipher.asm

@@ -0,0 +1,14 @@
+section .text
+global encode, decode
+
+encode:
+    ; Provide your implementation here
+    ret
+
+decode:
+    ; Provide your implementation here
+    ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif