Fix: A few structural changes to the repository and added missing tests and fixed some failing tests (TheAlgorithms#325)

* fix: RSA algorithm

* fix: rename xor cipher directory for better readability

* fix: sorting algorithms failing tests

* fix: linting issues

* fix: run gofmt

* fix: linting issues

* Update golang_lint_and_test.yml

* Add Taj to CODEOWNERS

Author: tjgurwara99

.github/CODEOWNERS

@@ -7,5 +7,5 @@
 
 # Order is important. The last matching pattern has the most precedence.
 
-* @siriak @raklaptudirm
+* @siriak @raklaptudirm @tjgurwara99
 /.*  @cclauss

.github/workflows/golang_lint_and_test.yml

@@ -15,5 +15,6 @@ jobs:
           # Required: the version of golangci-lint is required and must be
           # specified without patch version: we always use the latest patch version.
           # https://github.com/golangci/golangci-lint/releases
-          version: v1.39
+          version: latest
+          args: -E gofmt
       - run: go test ./...

README.md

@@ -19,8 +19,8 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 * [Diffie Hellman Key Exchange](./ciphers/diffie_hellman_key_exchange/)
 * [Polybius](./ciphers/polybius/)
 * [Rot13](./ciphers/rot13/)
-* [Rsa Cipher](./ciphers/rsa_cipher/)
-* [Xor Cipher](./ciphers/xor_cipher/)
+* [Rsa](./ciphers/rsa/)
+* [Xor](./ciphers/xor/)
 
 ## Conversions
 * [Roman To Integer](./conversions/roman_to_integer/)
@@ -64,7 +64,7 @@ Read our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 ## Math
 * [Gcd](./math/gcd/)
 * [Lcm](./math/lcm/)
-* [Modular Arithmetic](./math/modular_arithmetic/) 
+* [Modular](./math/modular/) 
 * [Permutation](./math/permutation/)
 * [Power](./math/power/)
 * [Prime](./math/prime/)

ciphers/rsa/rsa.go

@@ -0,0 +1,54 @@
+// rsa.go
+// description: Simple RSA algorithm implementation
+// details:
+// A simple RSA Encryption and Decryption algorithm.
+// It uses prime numbers that fit in int64 datatypes and
+// thus both the Encrypt and Decrypt are not a production
+// ready implementation. The OpenSSL implementation of RSA
+// also adds a padding which is not present in this algorithm.
+// author(s) [Taj](https://github.com/tjgurwara99)
+// see rsa_test.go
+
+// Package rsa shows a simple implementation of RSA algorithm
+package rsa
+
+import (
+	"errors"
+
+	modular "github.com/TheAlgorithms/Go/math/modular"
+)
+
+// ErrorFailedToEncrypt Raised when Encrypt function fails to encrypt the message
+var ErrorFailedToEncrypt = errors.New("failed to Encrypt")
+
+// ErrorFailedToDecrypt Raised when Decrypt function fails to decrypt the encrypted message
+var ErrorFailedToDecrypt = errors.New("failed to Decrypt")
+
+// Encrypt encrypts based on the RSA algorithm - uses modular exponentitation in math directory
+func Encrypt(message []rune, publicExponent, modulus int64) ([]rune, error) {
+	var encrypted []rune
+
+	for _, letter := range message {
+		encryptedLetter, err := modular.Exponentiation(int64(letter), publicExponent, modulus)
+		if err != nil {
+			return nil, ErrorFailedToEncrypt
+		}
+		encrypted = append(encrypted, rune(encryptedLetter))
+	}
+
+	return encrypted, nil
+}
+
+// Decrypt decrypts encrypted rune slice based on the RSA algorithm
+func Decrypt(encrypted []rune, privateExponent, modulus int64) (string, error) {
+	var decrypted []rune
+
+	for _, letter := range encrypted {
+		decryptedLetter, err := modular.Exponentiation(int64(letter), privateExponent, modulus)
+		if err != nil {
+			return "", ErrorFailedToDecrypt
+		}
+		decrypted = append(decrypted, rune(decryptedLetter))
+	}
+	return string(decrypted), nil
+}

ciphers/rsa/rsa_test.go

@@ -0,0 +1,79 @@
+// rsa_test.go
+// description: Test for RSA Encrypt and Decrypt algorithms
+// author(s) [Taj](https://github.com/tjgurwara99)
+// see rsa.go
+
+package rsa
+
+import (
+	"testing"
+
+	"github.com/TheAlgorithms/Go/math/gcd"
+	"github.com/TheAlgorithms/Go/math/lcm"
+	"github.com/TheAlgorithms/Go/math/modular"
+)
+
+var rsaTestData = []struct {
+	description string
+	input       string
+}{
+	{
+		"Encrypt letter 'a'",
+		"a",
+	},
+	{
+		"Encrypt 'hello world'",
+		"hello world",
+	},
+	{
+		"Encrypt full sentence",
+		"the quick brown fox jumps over the lazy dog.",
+	},
+	{
+		"Encrypt full sentence from rsacipher.go main function",
+		"I think RSA is really great",
+	},
+}
+
+func TestEncryptDecrypt(t *testing.T) {
+	// Both prime numbers
+	p := int64(61)
+	q := int64(53)
+
+	n := p * q
+
+	delta := lcm.Lcm(p-1, q-1)
+
+	e := int64(17) // Coprime with delta
+
+	if gcd.Recursive(e, delta) != 1 {
+		t.Fatal("Algorithm failed in preamble stage:\n\tPrime numbers are chosed statically and it shouldn't fail at this stage")
+	}
+
+	d, err := modular.Inverse(e, delta)
+
+	if err != nil {
+		t.Fatalf("Algorithm failed in preamble stage:\n\tProblem with a modular directory dependency: %v", err)
+	}
+
+	for _, test := range rsaTestData {
+		t.Run(test.description, func(t *testing.T) {
+
+			message := []rune(test.input)
+			encrypted, err := Encrypt(message, e, n)
+			if err != nil {
+				t.Fatalf("Failed to Encrypt test string:\n\tDescription: %v\n\tErrMessage: %v", test.description, err)
+			}
+
+			decrypted, err := Decrypt(encrypted, d, n)
+			if err != nil {
+				t.Fatalf("Failed to Decrypt test message:\n\tDescription: %v\n\tErrMessage: %v", test.description, err)
+			}
+
+			if actual := test.input; actual != decrypted {
+				t.Logf("FAIL: %s", test.description)
+				t.Fatalf("Expecting %v, actual %v", decrypted, actual)
+			}
+		})
+	}
+}