Files added to repository

controllers/CompartidosController.js

@@ -0,0 +1,112 @@
+const mongoose = require('mongoose');
+const fsp = require("fs/promises");
+const fs = require("fs");
+const path = require("path");
+const service = require('../config/services');
+const { type } = require('os');
+const log = require('../middlewares/log');
+
+
+/*function plantillaUsuarios(usuario, listUsuarios){
+    if(usuario != ""){
+      this.usuario = usuario;
+    }
+    if(listUsuarios != ""){
+      this.listUsuarios = listUsuarios;
+    }
+  }*/
+
+var compartidosController = {};
+
+compartidosController.listaUsuarios = async function (req, res) {
+    let usuarios = {usuarios: []};
+    fs.readdirSync(path.join(__dirname, '../UsuariosRegistrados/')).forEach(file => {
+        usuarios.usuarios.push(file);
+    });
+    log.serverActionInfo(req,"Listar los usuarios de la aplicación");
+    return res.status(200).send(usuarios);
+};
+
+compartidosController.listaCompartidos = async function (req, res) {
+    //let nombre = req.query.usuario;
+    let nombre = req.usuario;
+    let ficheros = {ficheros: []};
+    fs.readdirSync(path.join(__dirname, '../ArchivosCompartidos/Usuarios/' + nombre + '/')).forEach(file => {
+        if(file.split('-')[1].split('.')[0] === nombre){
+            ficheros.ficheros.push(file);
+        }
+    });
+    log.serverActionInfo(req,"Listar los archivos compartidos");
+    return res.status(200).send(ficheros);
+};
+
+compartidosController.listaCompartidosConmigo = async function (req, res) {
+    //let nombre = req.query.usuario;
+    let nombre = req.usuario;
+    let ficheros = {ficheros: []};
+    fs.readdirSync(path.join(__dirname, '../ArchivosCompartidos/Usuarios/' + nombre + '/')).forEach(file => {
+        if(file.split('-')[1].split('.')[0] !== nombre){
+            ficheros.ficheros.push(file);
+        }
+    });
+    log.serverActionInfo(req,"Listar los archivos compartidos conmigo");
+    return res.status(200).send(ficheros);
+};
+
+compartidosController.guardarArchivoCompartido = async function (req, res) {
+    let ficheroCompartido=req.body.ficheroCompartido;
+    let objetoContraseñas=req.body.contraseñas;
+    //let usuario=req.body.usuario;
+    let usuario = req.usuario;
+
+
+    if(!fs.existsSync(path.join(__dirname, '../ArchivosCompartidos/Usuarios/' + usuario))){
+        log.errorMensaje(req,"No existe la carpeta archivos compartidos del usuario");
+        return res.status(200).send({result:null,error:"No existe la carpeta archivos compartidos del usuario"});
+    }
+    try{
+        let id = fs.readFileSync('ArchivosCompartidos/id.txt', 'utf-8');
+        let idNuevo = parseInt(id);
+        idNuevo ++;
+        await fsp.writeFile('ArchivosCompartidos/id.txt', idNuevo.toString());
+        await fsp.writeFile('ArchivosCompartidos/Ficheros/' + id + '-' + usuario + '.enc', ficheroCompartido);
+
+        for (const propiedad in objetoContraseñas) {
+            await fsp.writeFile('ArchivosCompartidos/Usuarios/' + propiedad + '/' + id + '-' + usuario + '.enc', objetoContraseñas[propiedad]);
+        }
+        log.serverActionInfo(req,"Archivo compartido guardado");
+        res.status(200).send({result:{status:'Archivo compartido correctamente'},error:null}); 
+    }catch (err){
+        console.log(err);
+        log.errorMensaje(req,"Error al compartir archivo");
+        res.status(200).send({result:null,error:"Error al compartir archivo"});
+    }
+};
+
+
+compartidosController.obtenerPublicas = async function (req, res) {
+    let publicas = {};
+    for(let i = 0; i<req.body.usuarios.length; i++){
+        let publica = fs.readFileSync('UsuariosRegistrados/' + req.body.usuarios[i] + '/clavePublica.enc', 'utf-8');
+        publicas[req.body.usuarios[i]] = publica;
+    }
+    log.serverActionInfo(req,"Listado claves públicas devuelto");
+    res.status(200).send({result:publicas,error:null}); 
+};
+
+
+compartidosController.recuperarFicheroCompartido = async function (req, res) {
+    let fichero = req.query.fichero;
+    let usuario = req.usuario;
+    let privada = fs.readFileSync('UsuariosRegistrados/' + usuario + '/clavePrivada.enc', 'utf-8');
+    let claveRandom = fs.readFileSync('ArchivosCompartidos/Usuarios/' + usuario + '/' + fichero , 'utf-8');
+    let ficheroA = fs.readFileSync('ArchivosCompartidos/Ficheros/' + fichero , 'utf-8');
+
+    log.serverActionInfo(req,"Fichero compartido y claves devueltas");
+    res.status(200).send({privada:privada,claveRandom:claveRandom, fichero: ficheroA }); 
+};
+/*
+ * Other actions
+ */
+
+module.exports = compartidosController;

controllers/DatosController.js

@@ -0,0 +1,57 @@
+const mongoose = require("mongoose");
+const fsp = require("fs/promises");
+const fs = require("fs");
+const path = require("path");
+const service = require("../config/services");
+const log = require('../middlewares/log');
+
+
+var datosController = {};
+
+datosController.recuperarDatos = async function (req, res) {
+  //let nombre = req.query.nombre;
+  let nombre = req.usuario;
+
+  if (
+    !fs.existsSync(path.join(__dirname, "../UsuariosRegistrados/" + nombre))
+  ) {
+    log.errorMensaje(req,"No existe el usuario");
+    return res
+      .status(200)
+      .send({ result: null, error: "No existe el usuario" });
+  }
+  let datos = fs.readFileSync(
+    "UsuariosRegistrados/" + nombre + "/datos.json.enc",
+    "utf-8"
+  );
+  log.serverActionInfo(req,"Datos devueltos");
+  return res
+    .status(200)
+    .send({ result: { status: "ok", datos: datos }, error: null });
+};
+
+datosController.subirDatos = async function (req, res) {
+  //let nombre = req.body.usuario;
+  let nombre = req.usuario;
+
+  if (
+    !fs.existsSync(path.join(__dirname, "../UsuariosRegistrados/" + nombre))
+  ) {
+    log.errorMensaje(req,"No existe el usuario");
+    return res
+      .status(200)
+      .send({ result: null, error: "No existe el usuario" });
+  }
+  await fsp.writeFile('UsuariosRegistrados/' + nombre + '/datos.json.enc', req.body.fichero);
+  log.serverActionInfo(req,"Datos subidos");
+  return res
+    .status(200)
+    .send({ result: "ok", error: null });
+
+};
+
+/*
+ * Other actions
+ */
+
+module.exports = datosController;

controllers/UsuarioController.js

@@ -0,0 +1,133 @@
+const mongoose = require('mongoose');
+const fsp = require("fs/promises");
+const fs = require("fs");
+const path = require("path");
+const service = require('../config/services');
+const CryptoJS = require("crypto-js");
+const log = require('../middlewares/log');
+var speakeasy = require("speakeasy");
+
+
+
+var usuarioController = {};
+
+usuarioController.registrar = async function (req, res) {
+    let nombre = req.body.usuario; let token = "";
+
+    if(fs.existsSync(path.join(__dirname, '../UsuariosRegistrados/' + nombre))){
+        log.errorMensaje(req,"Ya existe el usuario");
+        return res.status(200).send({result:null,error:"Ya existe el usuario"});
+    }
+    try{
+        //creacion carpeta archivos compartidos
+        fs.mkdir(path.join(__dirname, '../ArchivosCompartidos/Usuarios/' + nombre),
+            { recursive: true }, async (err) => {
+            if (err) {
+                throw err;
+            }
+            log.serverActionInfo(req,"Carpeta Archivos Compartidos del usuario creada");
+        });
+        //creación carpeta usuario y sus archivos
+        fs.mkdir(path.join(__dirname, '../UsuariosRegistrados/' + nombre),
+            { recursive: true }, async (err) => {
+            if (err) {
+                throw err;
+            }
+            console.log('Carpeta usuario creada!');
+            const hashPassword = CryptoJS.SHA512(req.body.contraseña).toString();
+            await fsp.writeFile('UsuariosRegistrados/' + nombre + '/datos.json.enc', req.body.fichero);
+            await fsp.writeFile('UsuariosRegistrados/' + nombre + '/contraseña.enc', hashPassword);
+            await fsp.writeFile('UsuariosRegistrados/' + nombre + '/clavePublica.enc', req.body.clavePublica);
+            await fsp.writeFile('UsuariosRegistrados/' + nombre + '/clavePrivada.enc', req.body.clavePrivada);
+            let newId = new mongoose.mongo.ObjectId(); 
+            let user = nombre + '-' + newId.toString();
+            token = service.createToken(user);
+            log.serverActionInfo(req,"Carpeta del usuario y sus archivos creados");
+            res.status(200).send({result:{status:'Usuario creado correctamente',token: token},error:null}); 
+        });
+
+    }catch (err){
+        console.log(err);
+        log.errorMensaje(req,"Error al crear usuario");
+        res.status(200).send({result:null,error:"Error al crear usuario"});
+    }
+};
+
+
+usuarioController.iniciarSesion = async function (req, res) {
+    let nombre = req.body.usuario;
+    let newId = new mongoose.mongo.ObjectId(); 
+    let user = nombre + '-' + newId.toString();
+    if (!fs.existsSync(path.join(__dirname, '../UsuariosRegistrados/' + nombre))){
+        log.errorMensaje(req,"No existe el usuario");
+        return res.status(200).send({result:null,error:"No existe el usuario"}); //400
+    }
+    let contraseña = fs.readFileSync('UsuariosRegistrados/' + nombre + '/contraseña.enc', 'utf-8');
+    const hashPassword = CryptoJS.SHA512(req.body.contraseña).toString();
+    if(contraseña !== hashPassword){
+        log.errorMensaje(req,"Contraseña incorrecta");
+        return res.status(200).send({result:null,error:"Error Contraseña"});
+    }
+    //let datos = fs.readFileSync('UsuariosRegistrados/' + nombre + '/datos.json.enc', 'utf-8');
+
+    //Check TOTP
+    if(fs.existsSync(path.join(__dirname, '../UsuariosRegistrados/' + nombre + '/secreto.enc'))){
+        token = service.createToken(user,1);
+        return res.status(200).send({result:{status:'ok', token: token, TFA: 1},error:null});
+    }
+    else{
+        token = service.createToken(user,0);
+        return res.status(200).send({result:{status:'ok', token: token, TFA: 0},error:null});
+    }
+    
+};
+
+usuarioController.iniciarSesionFA = async function (req, res) {
+    let user = req.usuario;
+    token = service.createToken(user,0);
+    log.serverActionInfo(req,"Inicia sesión");
+    let dataTFA;
+    if(fs.existsSync(path.join(__dirname, '../UsuariosRegistrados/' + user + '/secreto.enc'))){
+        dataTFA = fs.readFileSync(
+            "UsuariosRegistrados/" + user + "/secreto.enc",
+            "utf-8"
+          );
+        var verified = speakeasy.totp.verify({ secret: dataTFA,
+            token: req.body.tokSecret });
+        if(verified){
+            let urlQR = speakeasy.otpauthURL({ secret: dataTFA, label: 'ES' });
+            return res.status(200).send({result:{status:'ok', token: token, TFA: 1, urlQR: urlQR},error:null});
+        }
+        else{
+            return res.status(200).send({result:null,error:"Prueba otra vez"});
+        }
+        
+    }
+    else{
+        return res.status(200).send({result:null,error:"Error doble factor no activo"}); 
+    }
+}
+
+usuarioController.activar2FA = async function (req, res) {
+    let nombre = req.usuario;
+    if (fs.existsSync(path.join(__dirname, '../UsuariosRegistrados/' + nombre + '/secreto.enc'))){
+        log.errorMensaje(req,"Ya esta activado el doble factor");
+        return res.status(200).send({result:null,error:"Ya existe el doble factor para esta cuenta"}); //400
+    }
+
+    //const hashsecreto = CryptoJS.SHA512(req.body.secreto).toString();
+    await fsp.writeFile('UsuariosRegistrados/' + nombre + '/secreto.enc', req.body.secreto);
+    let dataTFA = fs.readFileSync(
+        "UsuariosRegistrados/" + nombre + "/secreto.enc",
+        "utf-8"
+      );
+    let urlQR = speakeasy.otpauthURL({ secret: dataTFA, label: 'ES' });
+    return res.status(200).send({result:{status:'Activación completa', TFA: 1, urlQR: urlQR},error:null});
+};
+
+
+/*
+ * Other actions
+ */
+
+module.exports = usuarioController;