Solver for the Riddler's Legacy 2 challenge

main.js

const { Socket } = require("net");
const { StringDecoder } = require("string_decoder");
const solve = require("./solve.js");

const ip = "192.168.200.234";
const port = 2224;

const client = new Socket();
client.on("connect", connectHandler);
client.on("data", dataHandler);
client.on("error", errorHandler);
client.on("close", closeHandler);
client.connect(port, ip);

function connectHandler() {
    console.log("Connected");
}

function dataHandler(data) {
    const dataStr = new StringDecoder("utf8").write(data).trim();
    console.log("Riddle: " + dataStr);
    if (/.+;.+;.+/.test(dataStr)) {
        const answer = solve(dataStr);
        console.log("Answer: " + answer);
        client.write(answer + "\n");
    }
}

function errorHandler(error) {
    console.error(error);
}

function closeHandler() {
    console.log("Closed");
}

solve.js

const fs = require("fs");

const beale = fs.readFileSync("beale.txt", "utf8");
const bealeWords = beale.split(/[ ,\.]+/);
const morse = {
    ".-":    "a", '-...':  "b", '-.-.':  "c", '-..':   "d", '.':     "e", '..-.':   "f",
    "--.":   "g", '....':  "h", '..':    "i", '.---':  "j", '-.-':   "k", '.-..':   "l",
    "--":    "m", '-.':    "n", '---':   "o", '.--.':  "p", '--.-':  "q", '.-.':    "r",
    "...":   "s", '-':     "t", '..-':   "u", '...-':  "v", '.--':   "w", '-..-':   "x",
    "-.--":  "y", '--..':  "z", '-----': "0", '.----': "1", '..---': "2", '...--':  "3",
    "....-": "4", '.....': "5", '-....': "6", '--...': "7", '---..': "8", '----.:': "9"
};

function solve(data) {
    const parts = data.split(";");
    switch (parts[1]) {
        case "0":
            return solveType0(parts[2]);
        case "1":
            return solveType1(parts[2]);
        case "2":
            return solveType2(parts[2]);
        case "3":
            return solveType3(parts[2]);
        case "4":
            return solveType4(parts[2]);
        case "5":
            return solveType5(parts[2]);
        case "6":
            return solveType6(parts[2]);
        case "7":
            return solveType7(parts[2]);
        case "8":
            return solveType8(parts[2]);
        default:
            console.log("Unknow riddle type");
            return null;
    }
}

// ASCII codes
function solveType0(riddle) {
    let characters = [];
    for (let pos = 0; pos < riddle.length; pos++) {
        let char;
        for (let offset = 1; offset < riddle.length; offset++) {
            const code = riddle.substr(pos, offset);
            char = String.fromCharCode(code);
            if (/[a-z]/.test(char)) {
                characters.push(char);
                pos += offset - 1;
                break;
            }
        }
    }
    return characters.join("");
}

// First letter of word in text
function solveType1(riddle) {
    const numbers = riddle.split(":")[1].split(",");
    let answer = "";
    for (let i = 0; i < numbers.length; i++) {
        answer += bealeWords[numbers[i] - 1].slice(0,1).toLowerCase();
    }
    return answer;
}

// Base64
function solveType2(riddle) {
    return Buffer.from(riddle, "base64").toString("ascii");
}

// Caesar
function solveType3(riddle) {
    const parts = riddle.split(":");
    const word = parts[1];
    const shift = parseInt(parts[0]);
    let answer = "";
    for (let i = 0; i < word.length; i++) {
        const code = ((word.charCodeAt(i)-65+(26-shift))%26)+65;
        answer += String.fromCharCode(code);
    }
    return answer;
}

// Morse
function solveType4(riddle) {
    const parts = riddle.split(" ");
    let answer = "";
    for (let i = 0; i < parts.length; i++) {
        answer += morse[parts[i]];
    }
    return answer;
}

// Reversed
function solveType5(riddle) {
    return riddle.split("").reverse().join("")
}

// Split words in n parts and alternate between parts
function solveType6(riddle) {
    const parts = riddle.split(":");
    const splits = parseInt(parts[0]);
    let word = parts[1];
    let answer = "";
    for (let start = 0; start < word.length/splits; start++) {   
        for (let i = start; i < word.length; i += word.length/splits) {
            if (word[i] !== "0") {
                answer += word[i]
            }
        }
    }
    return answer;
}

// Vigenére
function solveType7(riddle) {
    const parts = riddle.split(":");
    const key = parts[0];
    const word = parts[1];
    let answer = "";
    for (let i = 0; i < word.length; i++) {
        const cipher = key[i % key.length];
        const x = cipher.charCodeAt(0)-97;
        const y = word.charCodeAt(i)-97;
        answer += String.fromCharCode((y-x+26) % 26 + 97);
    }
    return answer;
}

// XOR'd Base64
function solveType8(riddle) {
    const parts = riddle.split(":");
    const data = new Buffer(parts[1], "base64").toString("utf8");
    let answer = "";
    for (let i = 0; i < data.length; i++) {
        const c = data.charCodeAt(i);
        const k = parts[0].charCodeAt(i % parts[0].length);
        answer += String.fromCharCode(c ^ k);
    }
    return answer;
}

module.exports = solve;