Desarrollo Linux y software libre

Problema: en Linux, al ejecutar Chromium browser se ve todo en azul, como en el siguiente ejemplo:

Solución:

1. Dentro de Chromium-browser, entrar en el enlace chrome://flags/
2. Habilitar «Override software rendering list«
3. Reiniciar Chromium

Si Hashcat no muestra la GPU:
hashcat -I

Es necesario instalar los drivers de la tarjeta gráfica. Para ello:

1º) Descargar el paquete oficial para debian/Ubuntu de:
https://www.amd.com/en/support/download/linux-drivers.html

2º) Instalar el paquete en el sistema
$ dpkg -i amdgpu-install_6.3.60304-1_all.deb

3º) Ejecutar el instalador, limpiado previamente versiones anteriores:

$ amdgpu-install --uninstall
$ sudo usermod -a -G render $LOGNAME
$ sudo usermod -a -G video $LOGNAME
$ sudo amdgpu-install --opencl=rocr --vulkan=amdvlk,pro 
$ reboot

Tras ello, Hashcat si que mostrará dos dispositivos (CPU y GPU).
$ hashcat -I
Backend Device ID #1 (Alias: #2)
  Name...........: AMD Radeon RX 7800 XT


 De esta manera, se puede invocar Hashcat utilizando la GPU:

./hashcat -d 2 -m 22000 --session miSesionHashcatv2 --outfile /home/carlos/capturas_wifi/output/resultados.txt /home/carlos/capturas_wifi/hashes/_hashes2.txt --status-timer=300 /home/carlos/capturas_wifi/diccionarios_WPA/dicc.mergeado4.txt

Utilizando la distribución Kali Linux (recomendado instalarla en un pendrive y posteriormente actualizarla mediante apt update; apt upgrade; apt dist-upgrade; reboot), y una tarjeta wifi que soporte modo monitor, se puede en determinados casos descifrar la clave de redes wifi.

Para realizar la auditoría, se puede proceder con los siguientes pasos:

1. Habilitar la tarjeta en modo monitor, y parar todos los gestores de conexiones wifi del equipo (que harían interferencia en airodump-ng buscando en otros canales distintos al seleccionado:
   
   

airmon-ng check kill
airmon-ng start wlan1

2. Buscar una red objetivo, y comenzar a grabarla

airodump-ng wlan1
airodump-ng -c 1 -w salida.pcapng --output-format pcapng  wlan1 

Sirviendo «-c 1» para escuchar el tráfico solo del canal donde el AP emite, y especificando con «–output-format» que las capturas se guarden en formato pcapng

3. Extraer los handshakes de las redes y los diccionarios básicos

hcxpcapngtool -o hashes/hashes_Todos.txt -E diccionarioNuevo.txt salida.pcapng

Si hay problemas para leerlo, utilizar editcap:

 editcap -F pcap input.cap salida_convertida.pcap

4. Instalar hashcat (recomendable la última versión estable) y comprobar que puede correr con la tarjeta gráfica (habitualmente 10 veces mayor rendimiento que ejecutándolo con la CPU).

/.hashcat -I :
Backend Device ID #1 (Alias: #2)
  Name………..: AMD Radeon RX 7800 XT
  significa que tengo q invocar «hashcat -d 2 [opciones adicionales]»

5. Ejecutar hashcat para intentar obtener la clave por diccionario con el que se generó en la etapa anterior mediante hashcat (que conviene actualizar antes):

hashcat -d 2 -m 22000 --session miSesionHashcat --outfile /home/kali/capturas/hashcat/hashcat.resultados.txt hashes/hashes_Todos.txt --status-timer=300 diccionarioNuevo.txt 

Y si no hay resultado, utilizar otro diccionario (como RockYou o mezcla de varios) para realizar un ataque más universal:

hashcat -d 2 -m 22000 --session miSesionHashcat --outfile /home/kali/capturas/hashcat/hashcat.resultados.txt hashes/hashes_Todos.txt --status-timer=300 /media/kali/B6BA8791BA874CB5/Users/cgaci/Downloads/diccionario_wpa/fich3_sin_dups.txt

De este modo hará el ataque de hash tipo «22000» (WPA2), guardará cada 300 segundos los avances del ataque, comprobará todos los handshakes almacenados en hashes_Todos.txt, guardará los resultados en hashcat_resultados.txt y utilizará el diccionario «fich3_sin_dups.txt». Como es un proceso que tarda horas o días, se puede parar y retomar con el siguiente comando:

hashcat --session miSesionHashcat --restore

En caso de que el diccionario sea insulficiente, también se pueden aplicar reglas para cambiar las palabras del diccionario en el aire. Por ejemplo, para que ponga en mayúsculas la primera letra de cada palabra de un diccionario:

hashcat -r rules/best64.rule -a 0 hash.txt diccionario.txt

En este artículo plantearemos como crear un bot de trading en ProRealTime (manual) para la divisa DKK/EUR. Cabe recordar que la curva de esta moneda es practicamente plana debido a la alta correlación entre ambas economías.

El propósito de este bot consta de «cazar» esos movimientos abruptos del mercado marcados en el gráfico, ya que a corto plazo la divisa siempre retorna a valores previos (regresión a la media).

Para ello, el robot fijará desde el momento inicial (t0) dos órdenes de compra limitadas en extremos, a una distancia «distanciaOPT» de la media. En cada T recalibrará estos extremos a los que entrar en mercado. Utilizará una EMA para asumir cuál es la media de esa curva.

El código consta de 50 líneas, más otras 50 aprox. de comentarios para facilitar su legibilidad:

DEFPARAM CumulateOrders = True // Acumulación de posiciones false, desactivada: Si ya ha abierto posición, que no abra más hasta que no cierre ésta.
DEFPARAM PRELOADBARS =  301// to-do: que coincida con el valor de EMAA calibrado. Cargar 301 barras antes, para que las medias tengan sentido desde el primer momento.

// Bot que "caza" submarinos, esas spikes que hay en determinadas gráficas planas como la del EUR/DKK, y que tras la subida/caída brutal vuelve a la media. Al iniciarse el bot, y cada minuto, se pone tanto una orden limitada de compra como una de venta a niveles inusuales, fuera del rango habitual, en extremos. Estos niveles se pueden calibrar con backtesting (variable "distanciaOPT"). Para entender cuál es la media, se utiliza una EMA en cada momento, y en cada minuto se actualizan las órdenes limitadas, de modo que se evita caer en falsos positivos. Se sale del mercado con un trailing stop cuando se regresa a la EMA (lo cual suele ser a los pocos minutos).

//En TODO momento este bot tiene puestas dos ordenes limitadas (una de compra y otra de venta), por lo que para arrancarlo necesitará tener margin en el broken para abrir DOS operaciones al menos.

//Según el broker (IG), la distancia entre el precio de compra y el stop ha de ser superior a 35p.

//Futuros desarrollos:
//1) correr dos bots como éste, uno calibrado para que entre cuando detecte un 0.30% d diferera cuando detect un 0.50%
//2) aprovechar el CumulateOrders

//**********************************************************************************
saldoInicialDKK = 7400 //en moneda DKK. Esta cifra debe cuadrar con la caja "Capital inicial" del backtesting.
distanciaOPT = 0.002 // Distancia de la media a la que fijaremos las ordenes limitadas de compra (lejos de la media).
EMA = 300  //Valor para calcular cuál es la media de la curva. Calibrable.  
StartPerCentOPT = 0.0001 //Valor para inicial el trailing stop.
StepPerCentOPT = 0.007  //Valor para subir el trailing stop.
sizeLot = 10000 //Por definición del mercado, de la industria. // 1 minilote = 10.000 * 7 dkk = 70.000 dkk = 10.000€. Operamos en un gráfico "mini DKK/EUR".
//Lote estándar: un lote estándar contiene 100.000 unidades de la divisa base.
//Mini-lote. Un mini lote son 10.000 unidades de la divisa base.
//Micro-lote. Un micro lote son 1.000 unidades de la divisa base.

maximaCaida = 0.039 //Para evitar riesgos y que el broker ejecute las garantías por un eventual movto. del mercado (cisne negro), ésta es la volatilidad máxima histórica observada del EUY/DKK, en este caso el 22/6/18. Esto es lo máximo que se puede mover nuestra posición en 1 vela aprox. 

//**********************************************************************************

//Para calcular el apalancamiento máximo que puede hacerse sin riesgo, hay que conocer las garantías que pide el broker.
// éstas se ven en la web de IG, en la ficha de cada activo, https://deal.ig.com/wtp/#/workspace/NWUyY2E5YWE4YTdmMzg3YmFlNjk5NTI3
//[Franja] [Tamaño de la posición (Contracts)] [Depósito]
//     1                  0 - 30                   5%
//     2                  30 - 60                 10%
//     3                  60 - 240                15%
//     4                  240 +                   50%
margenTramo1 = 0.05
margenTramo2 = 0.10
margenTramo3 = 0.15
margenTramo4 = 0.50
// Esto significa que cuanto mayor sea el tamaño de la posicion, más depósito (garantías) se deben poner.

// ************************ CÁLCULOS ****************************
//Cálculo de precio al que entramos al mercado.
EMA  = ExponentialAverage[EMA](Close) //Conocer el precio habitual del activo.

precioLimitadaLargos = EMA * (1 - distanciaOPT) //Calcular a qué precio entraríamos si hubiese una spike bajista
precioLimitadaCortos = EMA * (1 + distanciaOPT) //Calcular a qué precio entraríamos si hubiese una spike alcista

// ************************ TAMAÑO DE POSICIÓN (NÚMERO DE LOTES) ****************************
// Calcular cuántos lotes podemos comprar con el saldo que tenemos, dejando margen de sobra para que el broker NO nos pueda barrer
// practicamente nunca.
//1º calcular cuántas posiciones como máximo podríamos abrir en base a las garantías que nos pide el broker.
capitalDKK = saldoInicialDKK + STRATEGYPROFIT  //el capital con el que empezamos, más lo que hayamos ganado o perdido.
garantiaRequeridaPorLoteEnDKK = 1 * sizeLot * precioLimitadaLargos * margenTramo1 // cuánta garantía nos exige un sólo lote.
maxNumLotesByInitialMargin = capitalDKK / garantiaRequeridaPorLoteEnDKK

//2º calcular cuántas posiciones como máximo podemos abrir aguantándolas vivas si el mercado cae hasta mínimos históricos
maxNumLotesByMaintenanceMargin = capitalDKK / (precioLimitadaLargos * sizeLot * maximaCaida  )
numLotes = floor(min(maxNumLotesByInitialMargin, maxNumLotesByMaintenanceMargin))


// ************************ DECISIONES ****************************
//según la pág 14. del manual de ProRealTime, las órdenes limitadas solo duran una vela, así que hay que reformularlas en cada vela.

IF NOT LONGONMARKET THEN
BUY numLotes LOT ROUNDEDDOWN AT precioLimitadaLargos LIMIT
ENDIF
IF NOT SHORTONMARKET THEN
SELLSHORT numLotes LOT ROUNDEDDOWN AT precioLimitadaCortos LIMIT
ENDIF

// ************************ TRAILING STOP FUNCTION ****************************
//Gestión de TS tomada de Prorealcode
StartPerCent  = StartPerCentOPT    //0.5 Trailing Stop will activate after 0.5% gain
StepPerCent   = StepPerCentOPT    //0.1 Trailing Steps will occur at any further 0.1% gain
trailingstart = PositionPrice * StartPerCent / 100 / PipSize
trailingstep  = PositionPrice * StepPerCent  / 100 / PipSize

IF NOT ONMARKET THEN //reset the stoploss value
newSL=0
ENDIF
 
//POSICIONES LARGAS **********
IF LONGONMARKET THEN
//first move (breakeven)
IF newSL=0 AND close-PositionPrice>=trailingstart*pipsize THEN
newSL = EMA // PositionPrice+trailingstep*pipsize //Funcionamiento habitual del TS en largos
ENDIF
//next moves
IF newSL>0 AND close-newSL>=trailingstep*pipsize THEN
newSL = max(newSL,newSL+trailingstep*pipsize)
ENDIF
ENDIF
 
//POSICIONES CORTAS **********
IF SHORTONMARKET THEN
//first move (breakeven)
IF newSL=0 AND PositionPrice-close>=trailingstart*pipsize THEN
newSL = EMA // PositionPrice-trailingstep*pipsize // Funcionamiento habtiaul del TS en cortos
ENDIF
//next moves
IF newSL>0 AND newSL-close>=trailingstep*pipsize THEN
newSL = min(newSL,newSL-trailingstep*pipsize)
ENDIF
ENDIF
 
//stop order to exit the positions
IF newSL>0 THEN
SELL AT newSL STOP
EXITSHORT AT newSL STOP
ENDIF



// ************************************ DEBUG *****************************************************************


// Para medir el riesgo que llevamos, ver cuántas garantías nos quedan antes de que nos barran.
//NoStopMargin = (CountOfPosition * sizeLot * low) * (margenTramo1)
//InitialMargin = Round(NoStopMargin * 100) / 100
//MaintenanceMargin =   (CountOfPosition * sizeLot * PositionPrice) - (CountOfPosition * sizeLot * low) //to-do: hacerlo tanto para cortos com para largos.

//GRAPH capitalDKK coloured (255,128,0) as "capitalDKK"
//GRAPH MaintenanceMargin coloured (255,128,0) as "MaintenanceMargin"
//GRAPH CountOfPosition coloured (128,128,128) as "CountOfPosition"
//GRAPH sizeLot coloured (128,0,0) as "sizeLot"
//GRAPH PositionPrice coloured (255,128,0) as "PositionPrice"
//GRAPH low coloured (255,128,0) as "low"su
//GRAPH numLotes coloured (255,128,0) as "numLotes"

//if newSL <> 0 THEN
//GRAPH newSL coloured (64,64,0) as "newSL"
//ENDIF

Como se indica en el código, para ponerlo en producción hay que tener suficiente margen (garantías) en la cuenta para poder abrir al menos 2 lotes, pues el bot desde t0 fija tanto una orden de compra en largo como otra en corto:

Nótese en la imagen las dos bandas que recorren el gráfico por encima y por debajo del precio. Son las dos ordenes de compra que están fijadas en T0, y que se actualizan en cada vela en función de las n-velas anteriores.

Las distintas variables se pueden calibrar realizando un backtesting o simulación del comportamiento del bot con datos pasados del mercado:

Tras hacer un backtesting, se puede estudiar los siguientes resultados, en función de las variables anteriormente tanteadas:

Se puede analizar en rendimiento de la estrategia en función de cada variable individual:

así como mostrar superficies para valorar la correlación entre dos variables. En el siguiente ejemplo vemos la ganancia que se obtiene mediante las distintas combinaciones de EMAs y distancias (en %) a fijar las ordenes limitadas de compra:

Con estas superficies es fácil estimar unas variables que faciliten que un movimiento del mercado que altere las variables, permita seguir situándonos en zonas de beneficios por el momento.

Eligiendo cualquier combinación de variables se puede ver en detalles los resultados financieros del backtesting:

E incluso se puede ver gráficamente las operaciones (entradas y salidas al mercado) que se realizan, así como el balance de la cuenta de trading:

ProRealTime es una herramienta potente para desarrollar bots de trading algorítmico. Dispone también de la ventaja de correr en una plataforma mantenida por el broker. Otra herramienta alternativa es MetaTrader4, que desarrollaremos en siguientes artículos.

Al intentar configurar la suspensión de energía en KDE, de cara a que se apague automaticamente el monitor tras unos minutos, parece que hay un bug en KDE que en algunos sistemas impide que se apague. Son ejemplos estos casos reportados:

kscreen2 kicks monitor out of power save mode

When I assign a key combination to turn off the screen and apply it the display output stays off only for one second and then power on again automatically …

[KScreen] [Bug 426609] New: kscreen2 kicks monitor out of power save mode

Esto afecta modo ahorro de energía del monitor. Parece que es un bug conocido que afecta al proceso «kscreen2«. Para solucionarlo temporalmente, basta con desactivar su arrancando automático, de modo que el usuario lo arranque manualmente cuando lo necesite. Para ello:

1. Entrar en las preferencias del sistema.
   
   
2. En ellas, acceder a «Arranque y apagado». Dentro, navegar a «Servicios en segundo plano»
   
   
3. En el panel de «Servicios de inicio», desmarcar «Kscreen 2». Aplicar los cambios.
   
   
4. Para activar el ahorro de energía, entrar desde las «Preferencias del sistema» anteriores, a «Ahorro de energía y configurar al gusto:
   

Tan solo es necesario utilizar la última versión de la herramienta Youtube-DL y después, desde Cmd.exe o consola en Linux, ejecutar el siguiente comando:

./youtube-dl --write-description -f best -ciw -o %(title)s.%(ext)s -v https://www.youtube.com/c/MarcosSanzA/videos

Si se produce el siguiente error:

PDF.js v1.4.20 (build: b15f335)
Message: file origin does not match viewer's

debido a que se intenta mostrar un archivo alojado en un servidor distinto al propio, y la política CORS (Cross-Origin Resource Sharing) del primero rechaza ese hot-linkng, a parte de intentar actualizar a la última versión de la librería si es posible, es necesario emplazar el siguiente fichero .hatccess en la carpeta donde se localice el PDF a mostar:

<IfModule mod_headers.c>   
 Header set Access-Control-Allow-Origin "*"   
</IfModule>

Igualmente en viewer.js añadir los hosts de donde se van a leer ficheros:

var HOSTED_VIEWER_ORIGINS = ['null', 'http://mozilla.github.io', 'https://mozilla.github.io', 'http://192.168.1.117'  ];

Montar Google Drive en Linux (tras añadirlo con rclone config):

carlos@rock64:~/plex$  rclone mount uc3m:/NAS/peliculas/ /home/carlos/plex/peliculas/ –allow-other  &

para copiar ficheros:

carlos@rock64:~$ rclone copy Regg_Fix_Sunrise.reg uc3mcifrado:/cifrado1/

y para acceder a una instalación de Plex desde tu red local, utilizar la siguiente tipología:

http://192.168.1.5:32400/

Una alternativa a Rclone es AirExplorer con un emulador para Windows como Wine.

Recientemente he instalado una cámara (dash-cam) en mi scooter. En este artículo describo cómo hacerlo. Antes de empezar, unas premisas:

• La dashcam es una cámara de grabación que sirve para grabar mientras conduces, como llevan algunos vehículos. Esto es especialmente útil en caso de accidente.
• Pese a que actualmente no está regulado el uso de cámaras, la última palabra la tiene el juez sobre la validez o no de la prueba. Cuanto menos puedes presentar la grabación e incluso en el caso de que la prueba no sea admitida, el juez ya sabrá que tienes la razón. Muchos jueces la admiten, y a las compañías de seguros les vale para evitar llegar a juicio, agilizando enormemente los trámites.
• Esta propuesta que expongo vale sólo para motos scooter, si bien las R podrían hacerlo con alguna adaptación o paso extra que simulase toma de mechero.

 

1. Cámara: Gitup F1

 

• Graba en resoluciones desde 720p (unos 45 min) hasta 4k (unos 20 min). El problema de los 720p es que las matrículas de los vehículos (importante) no se distinguen cuando vamos en movimiento. Si se conecta la cámara a la toma del mechero,no hay problemas de autonomía, y por tanto podremos grabar a 4k sin problemas todo el tiempo que se desee.
• Trae un cable para enchufar a la red eléctrica del vehículo, pero permite alimentarse también con cualquier cable miniusb (sólo que tienes que enchufarla a un sitio donde haya un usb en el otro lado, claro, como la toma de mechero de la que ahora hablaremos).
• La cámara tiene la opción de grabar en bucle, esto es, ir grabando continuamente y cuando se quede sin memoria, borra lo más antiguo y continua. Así no requiere mantenimiento ninguno.
• También el que la cámara como su soporte sean de color negro ayuda tanto a ser discretos y que no os miren por la calle, como a que no os la roben tan fácilmente como si fuese de un color llamativo cuando os la olvidemos puesta en lugares públicos (que ocurre).

 

– Coste: 69.90€ en Amazon.

 

2. Soporte

• Se pueden utilizar la práctica totalidad de los soportes compatibles con GoPro.
• En este caso, elegí el siguiente pues permite amarrarse a la moto sin necesidad de ventosa (imposible al carecer de superficies planas la moto), ni pegamentos o adhesivos, actuando el soporte con apenas una pinza atornillable (que no hace falta atornillar directamente al salpicadero, dejando éste intacto).
• Gira 360º y permite poner la cámara en horizontal detrás de la cúpula, encima del salpicadero.

• Coste: 5.89€ en Aliexpress

 

3. Tarjeta de memoria

• La cámara admite tarjetas Microsd de tamaño máximo 128GB, aunque es probable que admita más.
• Es recomendable que sea de buena calidad pues el uso que se va a hacer de la tarjeta es intensivo: se van a realizar escrituras (grabaciones) en vez de las habituales lecturas que desgastan menos a las tarjetas.
• También el grabar el vídeo en 4K implica que la tarjeta ha de tener buen rendimiento para que no se produzcan cuellos de botella y se descarten automáticamente fragmentos de la grabación.
• Coste: 17.99€ en Amazon

 

4. Cable

• Para conectar la cámara al mechero de la moto y por tanto garantizar su autonomía, es necesario un cable miniusb. Es raro que en 2019 todavía se vendan productos que utilizan miniusb en vez de microusb, y ésta es la única pega que le veo a la cámara (que tampoco es problema en definitiva).
• La cámara viene con un cable miniusb para enchufar a la instalación eléctrico del vehículo, pero si no se tienen conocimientos técnicos se puede enchufar a otro cable miniusb que vaya conectado a la toma del mechero, como se ha hecho en este tutorial.
  
  

 

• En este sentido se recomienda utilizar un cable miniusb de 1m. Más longitud es incómodo pues implica guardar el cable sobrante en la guantera. Algo menos de longitud es posible.
• Se recomienda de color negro por estética, para disimularlo, o incluso si es posible esconderlo por debajo del salpicadero y sacarlo por las tomas de aire.
• Sobre el ángulo, es conveniente que sea acodado para que ocupe menos.

• Coste: 1.73 + 13.92€ en Ebay (15.65€).

 

5. Toma de mechero

• Como ya se ha comentado, la cámara puede funcionar con su propia batería pero con una autonomía bastante limitada, o enchufada a la toma de mechero de la moto, ofreciendo tiempo ilimitado de grabación. Además, no sería necesario tener que cargarla cada día.
• Para ello, se recomienda un adaptador de mechero que tenga suficiente amperaje (2.4a). Además, si dispone de dos tomas para poder utilizar la segunda en otros menesteres (como cargar el móvil mientras se viaja), se optimiza la solución.
• La solución elegida es de Aukey con buenas características y valoraciones en Amazon:

• Coste: 9.99€ en Amazon.

 

RESULTADOS

Coste total: 103.77€

 

USO

• A la hora de grabar, con tan solo enchufarla al cable de la moto y dar el contacto, se enciende la cámara. Para que grabe sólo hay que darle al botón central, el redondo. También hay una función -pendiente de probar- para que empiece a grabar nada más detectar el contacto de la moto.
• En caso de accidente, se pueden ver los vídeos al instante a través de la app del móvil. Éste se conecta por una wifi que crea la cámara al móvil, y las puedes ver con el policía de turno. Y la tarjeta de memoria siempre con vosotros, lo pida la otra parte o el policía, no debéis entregarla sin haber hecho copia antes de los vídeos.

Si al configurar Apache Guacamole sucede el siguiente error:

root@rock64:/var/lib/tomcat8/webapps/guacamole-1.0.0# service guacd start
Failed to start guacd.service: Unit guacd.service is masked.

Se soluciona eliminando la anulación o enmascaramiento:

root@rock64:/var/lib/tomcat8/webapps/guacamole-1.0.0# systemctl unmask guacd.service
Removed /etc/systemd/system/guacd.service.