chat-server/main.js

#!/usr/bin/node

// Get some libraries
const winston = require("winston");
const random_bytes = require("random-bytes");
const bsplit = require("buffer-split");
const node_rsa = require("node-rsa");
const sqlite3 = require('sqlite3');
const btoa = require("btoa");
const atob = require("atob");
const net = require("net");
const fs = require("fs");

// Load the settings
var settings = require("./settings.json");

// Create a sqlite3 database
var db = new sqlite3.Database("./app.db", function(err)
{
  // Was there an error
  if(err)
  {
    // Tell the user the error
    console.log("SQlite3 failed to start:", err);
  }

  else
  {
    // Tell the user it worked
    console.log("SQlite3 ready.");
  }
});

function sqlite3_createTable(name, callback)
{
  // Run the create table task with the callback
  db.run('CREATE TABLE IF NOT EXISTS '+name
  +'(id INTEGER PRIMARY KEY AUTOINCREMENT, data TEXT)',  callback);
}

function sqlite3_insertData(name, data)
{
  // Write data to the table
  db.run('INSERT INTO '+name+' (data) VALUES (?)', [JSON.stringify(data)]);
}

function sqlite3_getData(name, callback)
{
  // Get the sqlite3 data and send it to the callback
  db.all('SELECT rowid AS id, data FROM '+name, callback);
}

function getrows_sqlite3(name, callback)
{
  // Create the table
  sqlite3_createTable(name, function()
  {
    // Load the table
    sqlite3_getData(name, function(err, rows)
    {
      // Throw an error if there is one
      if(err) throw err;

      // Loop over the rows
      for(var i=0;i<rows.length;i++)
      {
        // Parse the data
        var data = JSON.parse(rows[i].data);

        // Call the callback
        callback(data, i);
      }
    });
  });
}

// Load some databases
var users = {};
var chats = [];

// Get the users table
getrows_sqlite3("users", function(data)
{
  // Load a user
  users[data.username] = {
    password: data.password
  };
});

// Get the chats table
getrows_sqlite3("chats", function(data)
{
  // Push the chat
  chats.push({
    messages: [],
    name: data.name
  });
});

// Create a new messages table
getrows_sqlite3("messages", function(data)
{
  // Push all the messages to the chats
  chats[data.channel].messages.push({
    message: data.message,
    from: data.from,
    date: data.date
  });
});

console.log("Server ready.");

function toBuffer(bytes)
{
  // String
  if(typeof(bytes) == 'string')
  {
    // Create a buffer
    var buffer = new Buffer.alloc(bytes.length);

    // Loop over the bytes
    for(var i=0;i<bytes.length;i++)
    {
      // Save to the buffer
      buffer[i] = bytes[i].charCodeAt(0);
    }

    // Return the buffer
    return buffer;
  }

  // Return if this is anything else
  return bytes;
}

function toBytes(buffer)
{
  // Make sure the buffer is a buffer
  buffer = toBuffer(buffer);

  // Create some bytes
  var bytes = "";

  // Loop over the buffer
  for(var i=0;i<buffer.length;i++)
  {
    // Add to the bytes string
    bytes += String.fromCharCode(buffer[i]);
  }

  // Return the bytes
  return bytes;
}

function recieve_ordered(data, recieve, callback)
{
  // Convert the data into a buffer
  data = toBuffer(data);

  // Loop over the data
  for(var i=0;i<data.length;i++)
  {
    // Add the data to the buffer
    recieve.buffer = new Buffer.concat([recieve.buffer, Buffer([data[i]])]);

    // Is the buffer getting data
    if(!recieve.get)
    {
      // Does the buffer contain a number
      if(recieve.buffer.length >= 4)
      {
        // Get the number
        recieve.size = recieve.buffer.readUInt32BE(0);

        // Reset the buffer
        recieve.buffer = new Buffer.alloc(0);

        // Set the get data mode to true
        recieve.get = true;
      }
    }

    else
    {
      // Is the recieve buffer as big as the size
      if(recieve.buffer.length == recieve.size)
      {
        // Call the callback
        callback(recieve.buffer);

        // Reset the buffer and the size
        recieve.buffer = new Buffer.alloc(0);
        recieve.size = 0;

        // Set the get data mode to false
        recieve.get = false;
      }
    }
  }
}

function send_ordered(data)
{
  // Convert the data into a buffer
  data = toBuffer(data);

  // Get the size of the data
  var size = data.length;

  // Turn it into a 32 bit buffer
  var bytes = new Buffer.alloc(4);
  bytes.writeUInt32BE(size, 0);

  // Return the buffer and the data
  return new Buffer.concat([bytes, data]);
}

function string_decrypt(key, string)
{
  // Convert the string to a buffer
  var buff = toBuffer(string);

  // Create some new data
  var decrypted = new Buffer.alloc(buff.length);

  // Iterate over the string
  for(var i=0;i<string.length;i++)
  {
    // Convert the string item to a number
    var d = buff[i]-key.str[key.at.rx];
    while(d < 0) d += 256;
    decrypted[i] = d;

    // Add 1 to the key counter
    key.at.rx += 1;

    // Is the key counter out of range
    if(key.at.rx >= key.str.length)
    {
      // Set to zero
      key.at.rx = 0;
    }
  }

  // Return the encrypted data
  return decrypted;
}

function string_encrypt(key, string)
{
  // Convert the string to a buffer
  var buff = toBuffer(string);

  // Create some new data
  var encrypted = new Buffer.alloc(buff.length);

  // Iterate over the string
  for(var i=0;i<string.length;i++)
  {
    // Convert the string item to a number
    var e = buff[i]+key.str[key.at.tx];
    while(e > 255) e -= 256;
    encrypted[i] = e;

    // Add 1 to the key counter
    key.at.tx += 1;

    // Is the key counter out of range
    if(key.at.tx >= key.str.length)
    {
      // Set to zero
      key.at.tx = 0;
    }
  }

  // Return the encrypted data
  return encrypted;
}

function make_encryption_key(string)
{
  // Make a new key
  var key = new Object();

  // Set the varibles
  key.str = toBuffer(string);
  key.at = new Object();
  key.at.rx = 0;
  key.at.tx = 0;

  //console.log("make_encryption_key:", key.str);

  // Return the key
  return key;
}

function socket_write(socket, data)
{
  // Send the data encrypted with JSON
  socket.sock.write(send_ordered(string_encrypt(socket.key, JSON.stringify(data)+"\n")));
}

function socket_init(socket, ondata)
{
  // Set the socket
  var sock = new Object();
  sock.sock = socket;
  sock.new = true;

  // Create the recieve ordered memory model
  var recieve_ordered_memory = {
    buffer: new Buffer.alloc(0),
    get: false,
    size: 0
  }

  // Wait for data
  sock.sock.on('data', function(data)
  {
    // Recieve data in order
    recieve_ordered(data, recieve_ordered_memory, function(data)
    {
      //console.log(data);

      // Is the socket new
      if(sock.new)
      {
        // Set sock new
        sock.new = false;

        // Convert from JSON
        data = JSON.parse(data);

        // Is this the public key
        if(data.mode == 'pubkey')
        {
          // Load the key
          var key = new node_rsa();
          key.importKey(data.key, 'public');
          //console.log("Loaded the RSA key");

          // Get some random bytes
          random_bytes(settings.encryption_key_size, function(error,string)
          {
            //console.log("btoa(string):",btoa(string));

            // Throw an error if there is one
            if(error) throw error;

            // Make the key
            sock.key = make_encryption_key(string);
            //console.log("Created an encryption key")

            // Encrypt the key with RSA
            var key_encrypted = key.encrypt(string, 'base64');
            //console.log("Encrypted the key");

            // Send the key to the client
            sock.sock.write(send_ordered(JSON.stringify({
              key: toBytes(key_encrypted),
              mode: "encryption_key"
            })));

            //console.log("Sent the key to the client");
          });
        }
      }

      else
      {
        // Decrypt the data
        data = string_decrypt(sock.key, data);

        //console.log(data);

        // Parse the json data
        var data = JSON.parse(data);

        // Send the parsed data to the callback
        ondata(data);
      }
    });
  });

  // Return the socket
  return sock;
}

// Create a connections varible
var connections = [];

// Create a server
var server = net.createServer(function(socket)
{
  console.log("Connection from "+socket.remoteAddress);

  // Is this a whitelist
  if(settings.ips.type == "whitelist")
  {
    // Is the ip not in the whitelist
    if(!settings.ips.list.includes(socket.remoteAddress))
    {
      // Close the socket
      socket.destroy();

      // Tell the user
      console.log("User at "+socket.remoteAddress+" failed. Reason: whitelist");

      // Return
      return;
    }
  }

  // Is this a blacklist
  if(settings.ips.type == "blacklist")
  {
    // Is the ip in the blacklist
    if(settings.ips.list.includes(socket.remoteAddress))
    {
      // Close the socket
      socket.destroy();

      // Tell the user
      console.log("User at "+socket.remoteAddress+" failed. Reason: blacklist");

      // Return
      return;
    }
  }

  // Setup the sock varible
  var sock;

  // Initialise the socket and wait for data
  sock = socket_init(socket, function(data)
  {
    // Does the user want to login
    if(data.mode == "login" && !sock.logged_in)
    {
      // Is the user registered here
      if(users[data.username])
      {
        // Is the password correct
        if(users[data.username].password == data.password)
        {
          // Log the user in
          sock.username = data.username;

          console.log("Logged "+sock.username+" in.");

          // Set logged in
          sock.logged_in = true;
        }
      }

      // Is register on fail set
      else if(settings.register_on_fail)
      {
        // Make a new user
        users[data.username] = new Object();
        users[data.username].password = data.password;

        // Send it to sqlite3
        sqlite3_insertData("users", {
          username: data.username,
          password: data.password
        });

        // Send the status to all connections
        for(var i=0;i<connections.length;i++)
        {
          // Does the connection exist
          if(connections[i])
          {
            // Send data to the connection
            socket_write(connections[i], {
              mode: "new_user",
              user: data.username,
              data: {

              }
            });
          }
        }

        console.log("Creating account "+data.username+".");

        // Set logged in
        sock.logged_in = true;
      }

      // Is the user now logged in
      if(sock.logged_in)
      {
        // Set the users username
        sock.username = data.username;

        // Add the user to the connections array
        sock.connection_id = connections.length;
        connections.push(sock);

        // Set on disconnect
        sock.sock.on('close', function()
        {
          console.log("Connection from "+data.username+" closed.")

          // Delete the connection id
          delete connections[sock.connection_id];
        });

        // Get a list of chat keys
        var chats_client = [];

        // Get a list of user keys
        var user_keys = Object.keys(users);
        var users_client = {};

        // Loop over the chats
        for(var i=0;i<chats.length;i++)
        {
          // Push it to the temporary varible
          chats_client.push({
            name: chats[i].name,
            messages: chats[i].messages
          });
        }

        // Loop over the users
        for(var i=0;i<user_keys.length;i++)
        {
          // Register the key to the temporary varible
          users_client[user_keys[i]] = {

          };
        }

        //console.log("Sending server data");

        // Send the server data
        socket_write(sock, {
          mode: "login",
          chats: chats_client,
          users: users_client
        });
      }

      else
      {
        console.log("Authentication failed.");

        // Send back an error message
        socket_write(sock, {
          mode: "error",
          error: "auth"
        });
      }
    }

    // Is the socket logged in
    if(sock.logged_in)
    {
      // Does the user want to make a new chat
      if(data.mode == "new_chat")
      {
        // Make a new chat
        chats.push({
          messages: [],
          name: data.name
        });

        // Write it to the chats table
        sqlite3_insertData("chats", {
          name: data.name
        });

        // Update all the clients, loop over them
        for(var i=0;i<connections.length;i++)
        {
          // Is this an active connection
          if(connections[i])
          {
            // Send them the chat update
            socket_write(connections[i], {
              mode: "new_chat",
              name: data.name
            });
          }
        }
      }

      // Does the user want to send a message
      if(data.mode == "send_message")
      {
        // Is the channel real
        if(chats[data.channel])
        {
          // Save the message to sqlite3
          sqlite3_insertData("messages", {
            channel: data.channel,
            message: data.message,
            from: sock.username,
            date: data.date
          });

          // Add it to the channel
          chats[data.channel].messages.push({
            message: data.message,
            from: sock.username,
            date: data.date
          });

          // Send it to all the connected clients
          for(var i=0;i<connections.length;i++)
          {
            // Is the client connected
            if(connections[i])
            {
              // Send the client the message
              socket_write(connections[i], {
                mode: "new_message",
                message: data.message,
                channel: data.channel,
                from: sock.username,
                date: data.date
              });
            }
          }
        }
      }
    }
  });

  // Setup some varibles
  sock.logged_in = false;
});

// Set some default settings
settings.port = settings.port || 22068;
settings.ips = settings.ips || {
  type: "blacklist",
  list: []
};
settings.ips.type = settings.ips.type || "blacklist";
settings.ips.list = settings.ips.list || [];
settings.register_on_fail = settings.register_on_fail || true;
settings.encryption_key_size = settings.encryption_key_size || 16384;

// Listen for data
server.listen(settings.port, '');