• -u: Elimina el archivo una vez sobrescrito
• -z: Sobrescribe el archivo a zeros (supongo que es el que se encarga de convertir los bits 1 a 0)
• -v: Pinta por pantalla el proceso de shred
• -n: Numero de sobrescrituras que hace antes de eliminar el archivo (si esta el -u)

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("",PORT))
sock.listen(CLIENTS)
print(logFile().message(f"running ClassAdmin server, listen {CLIENTS} clients by port {PORT}...",True,"INFO"))
sockSSL = context.wrap_socket(sock,server_side=True)
childProcess = [] # This storages the childs processes
event = multiprocessing.Event() # listening events of childs processes
threading.Thread(target=Client.handlerEvent,name="exitChildProcess",args=(event,childProcess,)).start()
while sockSSL:
    connection, address = sockSSL.accept()
    subproccess = multiprocessing.Process(target=Client,name="client",args=(connection,address,event))
    subproccess.start()
    childProcess.append(subproccess)
    time.sleep(1)
 

threading.Thread(target=Client.handlerEvent,name="exitChildProcess",args=(event,childProcess,)).start()
 

@staticmethod
def handlerEvent(event,childProcesses):
    while True:
        if event.is_set():
            print(childProcesses)
            # terminate child process
            break
        time.sleep(.5)
 

class Client:
def __init__(self,conn,addr,event):
    try:
        self.conn, self.addr = conn, addr
        print(logFile().message(f"Client {self.addr[0]} connected by port {self.addr[1]}", True, "INFO"))
        self.__listenData()
    except (KeyboardInterrupt,SystemExit) as err:
        print(logFile().message(f"The client {self.addr[0]} left", True, "INFO"))
    except BaseException as err:
        type, object, traceback = sys.exc_info()
        file = traceback.tb_frame.f_code.co_filename
        line = traceback.tb_lineno
        print(logFile().message(f"{err} in {file}:{line}", True, "ERROR"))
    finally:
        try:
            self.conn.close()
        except:
            None
        finally:
            event.set()
#[...]
@staticmethod
def handlerEvent(event,childProcesses):
    while True:
        if event.is_set():
            print(childProcesses)
            # terminate child process
            break
        time.sleep(.5)
 

self.conn.close()
 

event.set()
 

@staticmethod
def handlerEvent(event,childProcesses):
    while True:
        if event.is_set():
            print(childProcesses)
            # terminate child process
            break
        time.sleep(.5)
 

event.set()
 

        finally:
            print(os.getpid())
            event.set()
 

@csrf_exempt
    def requests(self,req,table:str,columns:list=False):
        try:
            try:
                if not loginAdmin(req.headers['password'], int(req.headers['otp'])):
                    raise Exception("Access denied")
            except:
                raise Exception("You need authentication")
            conn = sqlite3.connect(Environment().pathDB())
            cursor = conn.cursor()
 

from sources import loginAdmin,Environment,logFile
import sqlite3,re
from django.urls import  path
from django.http import JsonResponse, HttpResponse, QueryDict
from django.views.decorators.csrf import csrf_exempt
 
"""
==========================API REST==========================
 SYNTAX:
    127.0.0.1/api[/table,table1,table3,...][/column]?<key>=[>|<|>=|<=]<value>&[|]<key>=[>|<|>=|<=]<value>&LIMIT=<min>[,max]
============================================================
 IMPORTANT:
    For do a request you need authentication with password and OTP
 
 EXAMPLES:
    GET:
        127.0.0.1/api/server -> SELECT * FROM server
        127.0.0.1/api/server?LIMIT=5 -> SELECT * FROM server LIMIT 5
        127.0.0.1/api/server?password=ejem&id=1&LIMIT=5,7 -> SELECT * FROM server WHERE password='ejem' AND id=1 LIMIT 5,7
        127.0.0.1/api/server/otp,id -> SELECT otp,id FROM server
        127.0.0.1/api/server/otp?id=1&password=hola -> SELECT otp FROM server WHERE id=1 AND password='hola'
        127.0.0.1/api/server/otp?id=1&|password=hola -> SELECT otp FROM server WHERE id=1 OR password='hola'
 
    POST:
        127.0.0.1/api/server -> INSERT INTO server (otp,ejem) VALUES (1234,'1233da')
            Body x-www-form-urlencoded
                key     value
                --------------------
                otp     1234
                ejem    1233da
 
        IMPORTANT: The params in the url doesn't affect
 
    PUT:
        127.0.0.1/api/server?port=8899&|password=h -> UPDATE server SET otp='1234', ejem='1233da' WHERE port=8899 OR password='h'
            Body x-www-form-urlencoded
                key     value
                --------------------
                otp     1234
                ejem    1233da
 
    DELETE:
        127.0.0.1/api/server?port=8899&password=h -> DELETE FROM server WHERE port=8899 AND password='h'
            not body data
"""
 
class getData:
    def __init__(self,data):
        self.list = QueryDict(data)
        self.output = ''
 
    # This method returns key1,key2,key3...
    # For clause as SELECT, INSERT
    def getKeys(self):
        for t in self.list:
            self.output+=f'{t},'
        self.output = re.sub(r",$","",self.output)
        return self.output
 
    # This method returns value1,value2,value3...
    # For clause as SELECT, INSERT
    def getValues(self):
        for t in self.list:
            try:
                if int(self.list[t]):
                    self.output+=f'{self.list[t]},'
            except:
                self.output += f"'{self.list[t]}',"
        self.output = re.sub(r",$","",self.output)
        return self.output
 
    # This method returns key1=value1, key2=value2, key3=value3
    # being '=' the 'delimitator'
    # For clause as UPDATE
    def keysValues(self,delimitator):
        for value in self.list:
            self.output+=f"{value}{delimitator}'{self.list[value]}', "
        self.output = re.sub(r", $", "", self.output)
        return self.output
 
class Database:
    # if there are columns, show it
    def columns(self,columns):
        if columns:
            return  columns
        else:
            return "*"
 
    # This method add the operator specified in the url
    def keyWhere(self,key):
        operator = re.sub(r"[^>|<|=]","",key)
        value = re.sub(r"[>|<|=]","",key)
        if operator == "":
            operator="="
        try:
            if int(value):
                return f"{operator}{value}"
        except:
            return f"{operator}'{value}'"
 
    def LimitClause(self,params):
        if params:
            output = ''
            for key in params:
                if key=="LIMIT":
                    output=f" LIMIT {params[key]}"
            return output
        else:
            return ""
 
    # This method add AND or OR in each condition in WHERE
    def WhereClause(self,params):
        if params:
            output=''
            for key in params:
                if key=="LIMIT":
                    continue
                operator = "OR" if key[0]=="|" else "AND"
                if list(params).index(key) > 0:
                    output+=f" {operator} {key[1::] if operator=='OR' else key}{self.keyWhere(params[key])}"
                else:
                    output += f"WHERE {key[1::] if operator=='OR' else key}{self.keyWhere(params[key])}"
            return output
        else:
            return ""
 
    @csrf_exempt
    def requests(self,req,table:str,columns:list=False):
        try:
            try:
                if not loginAdmin(req.headers['password'], int(req.headers['otp'])):
                    raise Exception("Access denied")
            except:
                raise Exception("You need authentication")
            conn = sqlite3.connect(Environment().pathDB())
            cursor = conn.cursor()
            if req.method == "GET":
                data = cursor.execute(f"SELECT {self.columns(columns)} FROM {table} {self.WhereClause(req.GET.dict())}{self.LimitClause(req.GET.dict())}")
                data = list(data)
                conn.close()
                if len(data) == 0:
                    data = None
                return JsonResponse({
                    "result": data
                })
            elif req.method == "POST":
                if columns:
                    raise Exception("POST not allowed")
                cursor.execute(f"INSERT INTO {table} ({getData(req.body).getKeys()}) VALUES ({getData(req.body).getValues()})")
                conn.commit()
                conn.close()
                return JsonResponse({"INSERT":True})
            elif req.method == "PUT":
                if columns:
                    raise Exception("PUT not allowed")
                cursor.execute(f"UPDATE {table} SET {getData(req.body).keysValues('=')} {self.WhereClause(req.GET.dict())}")
                conn.commit()
                conn.close()
                return JsonResponse({"UPDATE": True})
            elif req.method == 'DELETE':
                if columns:
                    raise Exception("DELETE not allowed")
                cursor.execute(f"DELETE FROM {table} {self.WhereClause(req.GET.dict())}")
                conn.commit()
                conn.close()
                return JsonResponse({"DELETE": True})
        except sqlite3.Error as err:
            return HttpResponse(logFile(True).message(f"DB -> {err}",True))
        except Exception as err:
            return HttpResponse({f"Error in the API REST -> {err}"})
urlpatterns=[
    path('<table>',Database().requests),
    path('<table>/<columns>',Database().requests)
]
 

.
├── ClassAdmin
│   ├── ClassAdmin
│   │   ├── __init__.py
│   │   ├── settings.py
│   │   ├── static
│   │   │   ├── css
│   │   │   │   ├── fonts.css
│   │   │   │   ├── pageLogin.css
│   │   │   │   └── styles.css
│   │   │   ├── data.json
│   │   │   ├── fonts
│   │   │   │   └── Allura-Regular.ttf
│   │   │   ├── images
│   │   │   │   ├── ClassAdminLogo.png
│   │   │   │   └── wallpaper.png
│   │   │   └── js
│   │   ├── templates
│   │   │   ├── pageLogin.html
│   │   │   └── src
│   │   │       └── base.html
│   │   ├── urls.py
│   │   ├── views.py
│   │   └── wsgi.py
│   ├── ClassAdmin.sqlite3
│   └── manage.py
└── sources
    └── __init__.py

class Environment:
    def __init__(self):
        self.directory = os.environ.get("CLASSADMIN")
    def pathDB(self):
        if platform.system() == "Windows":
            return f"{self.directory}\\ClassAdmin\\ClassAdmin.sqlite3"
        elif platform.system() == "Linux":
            return f"{self.directory}/ClassAdmin/ClassAdmin.sqlite3"
    def pathLog(self,name:str):
        if platform.system() == "Windows":
            return f"{self.directory}/{name}.log"
        elif platform.system() == "Linux":
            return f"/var/log/{name}.log"
 
 

from sources import *
STATIC_ROOT = f'{Environment().directory}/ClassAdmin/ClassAdmin/static'
 

• Ahí abrá una opción que es: ocultar las "caracteristicas de windows". Este esta en estado "no configurada", por la cual el problema no está ahí. Ya que si "El administrador del sistema deshabilitó las caracteristicas de windows". teoricamente deberia esta en "Habilitada". Pues esta no esta.
• También lo he mirado en el editor de registro de windows en la ruta HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Policies\, según he visto al haber el mensaje "El administrador del sistema deshabilitó las caracteristicas de windows", en esta ruta deberia de haber una carpeta llamada Programas y dentro el archivo de configuración con clave DWORD NoWindowsFeatures. Que su valor deberia ser 1 y deberia de ponerlo a 0, para deshabilitar el acceso a las caracteristicas de windows. Pues para empezar no existe ni la carpeta. (Puedo crearlo yo?)
• También la opción de acceder a las caracteristicas de windows a traves del CMD, no me va. Ya que no me aparece ninguna lista.
• He mirado en el sistema y en la herramienta MMC, no existe configuración (la raiz esta vacia)
• Ademas accediendo a MMC y creando una nueva directiva de grupo para el usuario administrador con ocultar las "caracteristicas de windows" deshabilitado, no me funciona.

 <script src="../js/panel.js" type="module"></script>

import {DB} from './crud.js';
const API='http://localhost:5000/miramar';
const formLogin=document.querySelector("body #formLogin");
 
const login=(e)=>{
    e.preventDefault();
    let password = formLogin['pass'].value;
    let user = formLogin['user'].value;
    let empleados=new DB(`${API}/empleados/`).show();
    console.log(empleados);
}
 
const init=()=>{
    formLogin.addEventListener("submit",login);
}
 
init();
 

export class DB{
    constructor(API){
        this.API=API;
        this.result;
    }
    show(){
        fetch(this.API)
        .then(res=>res.json())
        .then(data=>this.result=data);
        return this.result;
    }
}
 

    let empleados=new DB(`${API}/empleados/`).show();
    console.log(empleados);
 

export class DB{
    constructor(API){
        this.API=API;
        this.result;
    }
    async show(){
        /*fetch(this.API)
        .then(res=>res.json())
        .then(data=>this.result=data);
        return this.result;*/
        let res = await fetch(this.API);
        let data = await res.json();
        this.result=data;
        return this.result;
    }
 

   setTImeout(()=>console.log(empleados),1000)
 

[
  {
    "APELLIDOS": [
      "León",
      "Guerrero"
    ],
    "_id": "609e833e6746526127be53e6",
    "NOMBRE": "Jhilmar",
    "NACIMIENTO": "2002-02-19T00:00:00.000Z",
    "GENERO": "M",
    "CONTRASENA": "Jhilmar"
  },
  {
    "APELLIDOS": [
      "Antonio",
      "Salazar"
    ],
    "_id": "609e83f26746526127be53e7",
    "NOMBRE": "Juan",
    "NACIMIENTO": "2002-02-19T00:00:00.000Z",
    "GENERO": "M",
    "CONTRASENA": "Juan Antonio"
  },
  {
    "APELLIDOS": [
      "Napola"
    ],
    "_id": "609e84116746526127be53e8",
    "NOMBRE": "Carmen",
    "NACIMIENTO": "2002-02-19T00:00:00.000Z",
    "GENERO": "F",
    "CONTRASENA": "Carmen"
  }
 

[
]
 

let data = {
  "nick": "Drakaris",
  "password": "d404559f602eab6fd602ac7680dacbfaadd13630335e951f097af3900e9de176b6db28512f2e000b9d04fba5133e8b1c6e8df59db3a8ab9d60be4b97cc9e81db",
  "pleasures": [
    "romantic"
  ],
  "dateOfBirth": "2021-02-09",
  "gender": "female"
}
 

            let data = getDataForm() //obtengo el objeto generado dinamicamente
            fetch("json/users.json",{
                method: "POST",
                body: JSON.stringify(data),
                headers:{
                    "Content-type":"application/json"
                }
            }).then((result)=>result.json())
            .then(dat=>console.log(dat))
            .catch(err=>console.log(err)); 

eval("$HERO." + group + ".push('" + item.id.replace("Check","") + "')")
 

eval("delete $HERO." + item[0]);
 

eval("$HERO.skills." + skill + "" + operator + "=" + countSkill);
 

eval("$ELEMENTSPOINTS." + type + "." + element);
 

$ELEMENTSPOINTS[type];
 

$HERO={
    name:null,
    magic:[],
    weapons:[],
    gems:[],
    skills:{
        attack:0,
        defenser:0,
        speed:0
    }
}
const $ELEMENTSPOINTS={
    magic:{ // +
        lightning:{
            attack:10
        },
        ice:{
            attack:4,
            defenser:3
        },
        fire:{
            attack:8
        },
        wind:{
            defenser:2
        }
    },
    weapons:{
        sword:{
            attack:5,
            speed:1 // the speed substraction in the operation
        },
        shield:{
            defenser:10,
            speed:5
        },
        hatchet:{
            attack:10,
            speed:4
        },
        crossbow:{
            attack:7,
            speed:3
        }
    },
    gems:{ // +
        diamond:{
            lightning:2,
            ice:3,
            fire:5,
            wind:4
        },
        esmerald:{
            lightning:2,
            ice:3,
            fire:5,
            wind:4
        },
        ruby:{
            lightning:3,
            ice:2,
            fire:3,
            wind:2
        },
        sapphire:{
            lightning:2,
            ice:2,
            fire:3,
            wind:4
        }
    }
}
 

ActionSkills = (type,element,operator)=>{
        if(type != "gems"){
            /*
                The buttons' group aren't gems, so all skills' type got by the specificed element's sub-objects are iterated, and each iteration
                gets skill's number and if the skill's type is 'speed' and operator is '+' the operator is become to '-' 
                (because the speed substraction of speed's total count), else if the operator is '-', it is became in '+' (because the button is inactive).
 
                Finally is add/substraction the value get with the skill's total specificed. Thanks to eval()
 
                Also, if the button's group clicked is 'magic', apart from does previous it, this runs the function ActionGems()
            */
            for(skill in eval("$ELEMENTSPOINTS." + type + "." + element)){
                countSkill = eval("$ELEMENTSPOINTS." + type + "." + element + "." + skill);
                //console.log(skill + ":" + countSkill);
                (skill == "speed" && operator == " + ")?(operator = "-"):(skill == "speed" && operator == "-")?(operator = " + "):null;
                eval("$HERO.skills." + skill + "" + operator + "=" + countSkill);
            }
 
            (type == "magic")?ActionGems(type,element,operator):null;
        }else{
            /*
                As are gems, the operation is different. So this executes the function ActionGems()
            */
            ActionGems(type,element,operator);
        }
    }
 

 var players=[
    ["player1"],
    ["player2"],
];
 

<html>
    <head>
         <script src='file.js'></script>
    </head>
                        <i class="fas fa-times-circle close-player" onclick="
                            players.splice(this.parentNode.id,1);
                            this.parentNode.parentNode.parentNode.removeChild(this.parentNode.parentNode);
                            console.log(players);
                        "></i>
</html>