encryptify.go

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	fmt.Println("Welcome to the Encryptify!")

	for {
		toEncrypt, encoding, message := getInput()

		if toEncrypt {
			switch encoding {
			case "ROT13":
				fmt.Println(encryptROT13(message))
			case "Reverse":
				fmt.Println(encryptReverse(message))
			case "XOR":
				fmt.Println(encryptXOR(message))
			default:
				fmt.Println("Invalid encoding method.")
			}
		} else {
			switch encoding {
			case "ROT13":
				fmt.Println(decryptROT13(message))
			case "Reverse":
				fmt.Println(decryptReverse(message))
			case "XOR":
				fmt.Println(decryptXOR(message))
			default:
				fmt.Println("Invalid encoding method.")
			}
		}
	}
}

func getInput() (bool, string, string) {
	reader := bufio.NewReader(os.Stdin)
	var operation, encoding string

	// Select operation (Encryption/Decryption)
	for attempts := 0; attempts < 3; attempts++ {
		fmt.Println("Select operation (1/2):")
		fmt.Println("1. Encrypt.")
		fmt.Println("2. Decrypt.")

		operation, _ = reader.ReadString('\n')
		operation = strings.TrimSpace(operation)

		if operation == "1" || operation == "2" {
			break
		}
		fmt.Println("Invalid input. Please enter 1 or 2.")
		if attempts == 2 {
			fmt.Println("Too many invalid attempts. Exiting.")
			os.Exit(1)
		}
	}

	toEncrypt := (operation == "1")

	// Select cipher method
	for attempts := 0; attempts < 3; attempts++ {
		fmt.Println("Select cipher (1/2/3):")
		fmt.Println("1. ROT13.")
		fmt.Println("2. Reverse.")
		fmt.Println("3. XOR.")

		encoding, _ = reader.ReadString('\n')
		encoding = strings.TrimSpace(encoding)

		switch encoding {
		case "1":
			encoding = "ROT13"
		case "2":
			encoding = "Reverse"
		case "3":
			encoding = "XOR"
		default:
			fmt.Println("Invalid input. Please enter 1, 2, or 3.")
			if attempts == 2 {
				fmt.Println("Too many invalid attempts. Exiting.")
				os.Exit(1)
			}
			continue
		}
		break
	}

	// Get the message
	fmt.Printf("Enter the message: ")
	message, _ := reader.ReadString('\n')
	message = strings.TrimSpace(message)

	return toEncrypt, encoding, message
}

func encryptROT13(s string) string {
	var result strings.Builder
	for _, char := range s {
		switch {
		case char >= 'A' && char <= 'Z':
			result.WriteRune('A' + (char-'A'+13)%26)
		case char >= 'a' && char <= 'z':
			result.WriteRune('a' + (char-'a'+13)%26)
		default:
			result.WriteRune(char)
		}
	}
	return result.String()
}

func decryptROT13(s string) string {
	return encryptROT13(s) // ROT13 is symmetrical
}

func encryptReverse(s string) string {
	var result strings.Builder
	for _, char := range s {
		switch {
		case char >= 'A' && char <= 'Z':
			result.WriteRune('Z' - (char - 'A'))
		case char >= 'a' && char <= 'z':
			result.WriteRune('z' - (char - 'a'))
		default:
			result.WriteRune(char)
		}
	}
	return result.String()
}

func decryptReverse(s string) string {
	return encryptReverse(s) // Reverse is symmetrical
}

func encryptXOR(s string) string {
	reader := bufio.NewReader(os.Stdin)

	var key string
	for {
		fmt.Printf("Please enter a key to encrypt: ")
		keyInput, _ := reader.ReadString('\n')
		keyInput = strings.TrimSpace(keyInput)

		if len(keyInput) > 0 {
			key = keyInput
			break
		}
		fmt.Println("The key field is empty. Please try again.")
	}

	// Adjust key length
	key = adjustKeyLength(key, len(s))

	// XOR operation
	encryptedBytes := make([]byte, len(s))
	for i := 0; i < len(s); i++ {
		encryptedBytes[i] = s[i] ^ key[i]
	}

	return bytesToHex(encryptedBytes)
}

func decryptXOR(encryptedS string) string {
	reader := bufio.NewReader(os.Stdin)

	var key string
	for {
		fmt.Printf("Please enter the key to decrypt: ")
		keyInput, _ := reader.ReadString('\n')
		keyInput = strings.TrimSpace(keyInput)

		if len(keyInput) > 0 {
			key = keyInput
			break
		}
		fmt.Println("The key field is empty. Please try again.")
	}

	encryptedBytes := hexToBytes(encryptedS)
	if len(encryptedBytes) == 0 {
		fmt.Println("Invalid encrypted message. Restarting input process.")
		return ""
	}

	// Adjust key length
	key = adjustKeyLength(key, len(encryptedBytes))

	// XOR operation for decryption
	decryptedBytes := make([]byte, len(encryptedBytes))
	for i := 0; i < len(encryptedBytes); i++ {
		decryptedBytes[i] = encryptedBytes[i] ^ key[i]
	}

	return string(decryptedBytes)
}

// Adjusts the key length to match the input message length
func adjustKeyLength(key string, length int) string {
	if len(key) < length {
		repeated := strings.Repeat(key, (length/len(key))+1)
		key = repeated[:length]
	} else if len(key) > length {
		key = key[:length]
	}
	return key
}

// Converts byte array into hexadecimal string
func bytesToHex(byteArray []byte) string {
	var hexString strings.Builder
	for _, b := range byteArray {
		hexString.WriteString(fmt.Sprintf("%02x", b))
	}
	return hexString.String()
}

// Converts hexadecimal string into byte array
func hexToBytes(hexString string) []byte {
	if len(hexString)%2 != 0 {
		fmt.Println("Invalid hex string length.")
		return []byte{}
	}

	byteArray := make([]byte, len(hexString)/2)
	for i := 0; i < len(hexString); i += 2 {
		byteValue, err := strconv.ParseUint(hexString[i:i+2], 16, 8)
		if err != nil {
			fmt.Println("Invalid hex input.")
			return []byte{}
		}
		byteArray[i/2] = byte(byteValue)
	}
	return byteArray
}