Capturar la pantalla desde un script no es complicado, aunque si quieres hacerlo de forma remota y traerlo al ordenador del profesor hay que afinar un poco la cosa.
Como paso imprescindible e inicial es obligatorio que entre el ordenador del profesor y los de los alumnos exista una relación de confianza ssh que nos permita conectar desde la cuenta de root del PC del profesor sin necesidad de introducir contraseña. Tras generar y copiar las claves, en /root/.ssh/id_rsa y /root/.ssh/id_rsa.pub del profesor tendremos las claves pública y privada, mientras que en /root/.ssh/... de los alumnos tendremos la clave privada.
Una vez resuelto el problema de la comunicación entre profesor y alumnos, tenemos que pensar en los posibles escenarios que nos encontramos en nuestras aulas:
- Aula aislada: profesor y alumnos están una red privada con rango de direcciones propio, mediante una VLAN creada en el switch. En mi caso con los alumnos tienen direccionamamiento 192.168.0.200-253, sin importar si se usan portátiles o equipos de sobremesa.
- Aula integrada: profesor y alumnos no están aislados, si no que usan direcciones públicas de la red del centro. Hay que encontrar una manera de que el PC del profesor sepa a priori cuales son las IP de los PC de alumnos que dependen de él. Esta manera consiste en definir en el fichero /etc/escuela2.0 (el que usamos para configuraciones de nuestras máquinas) una variable llamada IES_IP_ALUMNOS, en la cual indicamos en rango de IP donde están los PC de los alumnos, por ejemplo: 172.23.241.70-85. El valor tomado por defecto es 192.168.0.200-253
- Thinclients: en este caso también es un aula aislada, con direcciones del rango 192.168.0.200 en adelante, pero con una particularidad consistente en que con los thinclients las sesiones de los alumnos se ejecutan en el PC del profesor, en una sesión privada en la que la captura de pantalla se hace de una forma diferente. Para saber si el aula tiene thinclients usaremos la variable IES_ISLTSP de /etc/escuela2.0
Aparte de eso, la aplicación debe tener un interface gráfico sencillo para el usuario. Por esta razón he optado por hacer la aplicación de captura usando python e interface gráfico Qt con PyQt5. Para ello uso Qt Designer para diseñar el interface gráfico y Geany para escribir el programa.
Una vez implementado, los ficheros necesarios son distribuidos por la siguiente tarea puppet:
# cat xubuntu18_photomaton/manifests/init.pp
import "/etc/puppet/defines/*.pp"
class xubuntu18_photomaton {
file {"/usr/local/bin/photomaton.py":
owner=>root, group=>root, mode=>755,
source=>"puppet:///modules/xubuntu18_photomaton/photomaton.py",
}
file {"/usr/local/bin/photomaton_ui.py":
owner=>root, group=>root, mode=>755,
source=>"puppet:///modules/xubuntu18_photomaton/photomaton_ui.py",
}
file {"/usr/local/bin/photomaton.jpg": #/usr/share/icons/photomaton.jpg
owner=>root, group=>root, mode=>644,
source=>"puppet:///modules/xubuntu18_photomaton/photomaton.jpg",
}
file {"/usr/share/applications/Photomaton.desktop" :
owner => root , group =>root, mode => 644 ,
source => "puppet:///modules/xubuntu18_photomaton/Photomaton.desktop",
notify => Exec['update-desktop'],
}
exec { "update-desktop":
path => "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
command => "/usr/bin/update-desktop-database",
refreshonly => true,
require => [File["/usr/local/bin/photomaton.jpg"],File["/usr/share/applications/Photomaton.desktop"]],
}
line { sudoers:
file => "/etc/sudoers",
line => "%teachers ALL = (ALL) NOPASSWD: /usr/local/bin/photomaton.py",
ensure => present
}
package { 'python3-paramiko': ensure => 'installed' }
package { 'python3-nmap': ensure => 'installed' }
package { 'python3-configobj': ensure => 'installed' }
package { 'python3-psutil': ensure => 'installed' }
package { 'python3-pyqt5': ensure => 'installed' }
}
Vamos primero el código del programa principal:
# cat xubuntu18_photomaton/files/photomaton.py
#!/usr/bin/python3
from photomaton_ui import *
import sys
import socket
import subprocess
import os, errno
from datetime import datetime
import paramiko
Para acabar un pequeño detalle: en las au
import time
from configobj import ConfigObj
import psutil
import nmap
class MainWindow(QtWidgets.QMainWindow, Ui_Photomaton):
def __init__(self, *args, **kwargs):
QtWidgets.QMainWindow.__init__(self, *args, **kwargs)
self.setupUi(self)
#Conectamos los botones con los eventos
self.iniciarCaptura.clicked.connect(self.capturar)
self.visualizarCapturas.clicked.connect(self.visualizar)
self.finalizar.clicked.connect(self.finalizarApp)
#Definimos el entorno, creando el directorio destino y leyendo escuela2.0
hostname = socket.gethostname()
#Como se llama usando sudo, el usuario original está en SUDO_USER
try:
self.user=os.environ["SUDO_USER"]
except Exception as e:
print("No eres usuario sudo. Abortando")
#self.user="root"
sys.exit(0)
home = os.path.expanduser("~"+self.user) #Directorio $HOME del usuario
self.pathcapturas=home+"/capturas/"+hostname
config = ConfigObj("/etc/escuela2.0")
self.uso=config.get('USO') #infolab/siatic/...
self.isltsp=config.get('IES_ISLTSP') #true si tiene thinclients
self.ip_alumnos=config.get('IES_IP_ALUMNOS') # Rango de ip de los alumnos, para aulas de workstations.
self.capturando=False
if self.ip_alumnos is None or self.ip_alumnos == "" :
self.ip_alumnos="192.168.0.200-253" # Rango por defecto en aulas con vlan
try:
comando="su "+self.user+" -c 'mkdir -p "+self.pathcapturas+"'"
os.system(comando)
except FileExistsError:
# directory already exists
pass
def finalizarApp(self):
if self.capturando == False:
sys.exit(0)
else:
self.capturando=False
def visualizar(self):
comando="su "+self.user+" -c 'nohup thunar "+self.pathcapturas+" &'"
os.system(comando)
def capturar_ip(self, ip):
s = socket.socket() #Quizá esto se podria quiar, el ssh_client.connnect ya tiene timeout
s.settimeout(30)
address = ip
port = 22
try:
#Intenta conectar por ssh a ver si la IP acepta peticiones ssh
s.connect((address, port)) #Si falla se va a la excepcion
s.close()
#Conectamos por ssh y ejecutamos el comando de captura.
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(ip, 22, 'root', key_filename="/root/.ssh/id_rsa" , timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='rm -f /tmp/captura.jpg; pc=$(hostname); user=$(who | grep "(:0)" | head -1 | cut -f1 -d" "); test -n "$user" && (su $user -c "DISPLAY=:0 import -window root /tmp/captura.jpg"; chmod 777 /tmp/captura.jpg; echo -n $pc/$user)'
#print("Ejecutando "+comando)
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
#Como salida se devuelve "pc/usuario"
signatura=outdata
#Aprovechando la conexion ssh se usa sftp para recuperar el fichero /tmp/captura.jpg y guardarlo en la ruta de destino
sftp = ssh_client.open_sftp()
destino=self.pathcapturas+"/"+signatura
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
sftp.get("/tmp/captura.jpg", "/tmp/captura-local.jpg") #Traemos el fichero a local
comando='su '+self.user+' -c "cp /tmp/captura-local.jpg '+fichero+'"'
#print("Ejecutando "+comando)
os.system(comando)
# Cerramos todo lo abierto
ssh_transp.close()
sftp.close()
ssh_client.close()
except Exception as e:
print("Error "+str(e))
def capturar_thinclients(self):
#Obtenemos la lista de usuarios conectados en el servidor de aula, filtramos por aquellos que están conectados con la ip 192.X.Y.Z (thinclients)
for usuario in psutil.users():
if usuario.host[:4] == "192." :
try:
#Sacamos el home del usuario con getent
comando="getent passwd "+usuario.name
process = subprocess.Popen(comando.split(), stdout=subprocess.PIPE)
output, error = process.communicate()
home_user=output.decode("ascii").split(":")[5]
#Conectamos con el thinclient para sacar el hostname
ssh_client = paramiko.SSHClient()
ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh_client.connect(usuario.host, 22, 'root', key_filename="/root/.ssh/id_rsa", timeout=30)
fecha=datetime.now().strftime("%Y-%m-%d-%H:%M:%S")
sleeptime = 0.001
comando='cat /etc/hostname | tr -d "\n"'
ssh_transp = ssh_client.get_transport()
chan = ssh_transp.open_session()
# chan.settimeout(3 * 60 * 60)
chan.setblocking(0)
outdata=""
chan.exec_command(comando)
while True: # Hay que esperar a que acabe el comando
while chan.recv_ready():
outdata += chan.recv(1000).decode('ascii')
if chan.exit_status_ready(): # If completed
break
time.sleep(sleeptime)
host=outdata
# Cerramos todo lo abierto
ssh_transp.close()
ssh_client.close()
#Ejecutamos el comando de captura de la sesión del usuario. Se usa os.system porque para comandos complejos es mejor que subprocess.popen
comando='su '+usuario.name+' -c "DISPLAY='+usuario.host+':7 XAUTHORITY='+home_user+'/.Xauthority import -window root /tmp/capture.jpg"'
os.system(comando)
#Copiamos la captura a la carpeta destino
destino=self.pathcapturas+"/"+host+"/"+usuario.name
try:
comando='su '+self.user+' -c "mkdir -p '+destino+'"'
os.system(comando)
except FileExistsError:
pass
fichero=destino+"/"+fecha+".jpg"
comando='su '+self.user+' -c "cp /tmp/capture.jpg '+fichero+'"'
os.system(comando)
comando='rm -f /tmp/capture.jpg'
os.system(comando)
except Exception as e:
pass
def capturar(self):
try:
segundos=int(self.intervaloCaptura.text())*60
except ValueError:
segundos=0
self.capturando=True
self.iniciarCaptura.setText("Capturando...")
self.finalizar.setText("Parar captura")
self.iniciarCaptura.setEnabled(False)
while self.capturando == True:
self.iniciarCaptura.setText("Capturando...")
self.iniciarCaptura.setEnabled(False)
self.do_captura()
if segundos == 0:
break
else: #Espera activa hasta la próxima captura
for i in range(segundos):
time.sleep(1)
app.processEvents()
if self.capturando==False: break
self.iniciarCaptura.setEnabled(True)
self.iniciarCaptura.setText("Iniciar Captura")
self.finalizar.setText("Finalizar")
self.capturando=False
def do_captura(self):
app.processEvents()
#print("Inicio captura")
if self.isltsp == "true":
self.capturar_thinclients()
else:
nm = nmap.PortScanner()
nm.scan(self.ip_alumnos, '22')
for ip in nm.all_hosts():# Equipos conectados, up.
#print("Procesando "+ip)
if nm[ip]['tcp'][22]['state']=="open":
#print("Puerto ssh abierto")
self.capturar_ip(ip)
app.processEvents() # Para procesar clicks de raton durante el bucle.
app.processEvents()
#print("Fin captura")
if __name__ == "__main__":
app = QtWidgets.QApplication([])
window = MainWindow()
window.show()
app.exec_()
El fichero photomaton.jpg contendría la imagen:
Seguimos con el fichero .desktop, el acceso directo para poner en el menú principal y en el escritorio. Nótese el uso de "gksu" para ejecutar como root el programa photomaton.py.
# cat xubuntu18_photomaton/files/Photomaton.desktop
[Desktop Entry]
Version=1.0
Encoding=UTF-8
Name=Photomaton
Type=Application
Exec=gksu /usr/local/bin/photomaton.py
TryExec=
Icon=/usr/local/bin/photomaton.jpg
X-GNOME-DocPath=
Terminal=false
Name[es_ES]=Photomaton
GenericName[es_ES]=
Comment[es_ES]=
GenericName=
Comment=
# cat xubuntu18_photomaton/files/photomaton.ui
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Photomaton</class>
<widget class="QDialog" name="Photomaton">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>508</width>
<height>212</height>
</rect>
</property>
<property name="windowTitle">
<string>Photomaton</string>
</property>
<widget class="QPushButton" name="iniciarCaptura">
<property name="geometry">
<rect>
<x>290</x>
<y>70</y>
<width>191</width>
<height>28</height>
</rect>
</property>
<property name="text">
<string>Iniciar Captura</string>
</property>
</widget>
<widget class="QPushButton" name="visualizarCapturas">
<property name="geometry">
<rect>
<x>290</x>
<y>110</y>
<width>191</width>
<height>28</height>
</rect>
</property>
<property name="text">
<string>Visualizar Capturas</string>
</property>
</widget>
<widget class="QPushButton" name="finalizar">
<property name="geometry">
<rect>
<x>290</x>
<y>150</y>
<width>191</width>
<height>28</height>
</rect>
</property>
<property name="text">
<string>Finalizar</string>
</property>
</widget>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>290</x>
<y>30</y>
<width>151</width>
<height>16</height>
</rect>
</property>
<property name="text">
<string>Intervalo capturas (min):</string>
</property>
</widget>
<widget class="QLineEdit" name="intervaloCaptura">
<property name="geometry">
<rect>
<x>440</x>
<y>20</y>
<width>41</width>
<height>28</height>
</rect>
</property>
<property name="inputMask">
<string>09</string>
</property>
<property name="text">
<string>00</string>
</property>
<property name="maxLength">
<number>2</number>
</property>
</widget>
<widget class="QLabel" name="label_2">
<property name="geometry">
<rect>
<x>10</x>
<y>20</y>
<width>261</width>
<height>181</height>
</rect>
</property>
<property name="text">
<string/>
</property>
<property name="pixmap">
<pixmap>/usr/local/bin/photomaton.jpg</pixmap>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>
# cat xubuntu18_photomaton/files/photomaton_ui.py
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'photomaton.ui'
#
# Created by: PyQt5 UI code generator 5.10.1
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_Photomaton(object):
def setupUi(self, Photomaton):
Photomaton.setObjectName("Photomaton")
Photomaton.resize(508, 212)
self.iniciarCaptura = QtWidgets.QPushButton(Photomaton)
self.iniciarCaptura.setGeometry(QtCore.QRect(290, 70, 191, 28))
self.iniciarCaptura.setObjectName("iniciarCaptura")
self.visualizarCapturas = QtWidgets.QPushButton(Photomaton)
self.visualizarCapturas.setGeometry(QtCore.QRect(290, 110, 191, 28))
self.visualizarCapturas.setObjectName("visualizarCapturas")
self.finalizar = QtWidgets.QPushButton(Photomaton)
self.finalizar.setGeometry(QtCore.QRect(290, 150, 191, 28))
self.finalizar.setObjectName("finalizar")
self.label = QtWidgets.QLabel(Photomaton)
self.label.setGeometry(QtCore.QRect(290, 30, 151, 16))
self.label.setObjectName("label")
self.intervaloCaptura = QtWidgets.QLineEdit(Photomaton)
self.intervaloCaptura.setGeometry(QtCore.QRect(440, 20, 41, 28))
self.intervaloCaptura.setMaxLength(2)
self.intervaloCaptura.setObjectName("intervaloCaptura")
self.label_2 = QtWidgets.QLabel(Photomaton)
self.label_2.setGeometry(QtCore.QRect(10, 20, 261, 181))
self.label_2.setText("")
self.label_2.setPixmap(QtGui.QPixmap("/usr/local/bin/photomaton.jpg"))
self.label_2.setObjectName("label_2")
self.retranslateUi(Photomaton)
QtCore.QMetaObject.connectSlotsByName(Photomaton)
def retranslateUi(self, Photomaton):
_translate = QtCore.QCoreApplication.translate
Photomaton.setWindowTitle(_translate("Photomaton", "Photomaton"))
self.iniciarCaptura.setText(_translate("Photomaton", "Iniciar Captura"))
self.visualizarCapturas.setText(_translate("Photomaton", "Visualizar Capturas"))
self.finalizar.setText(_translate("Photomaton", "Finalizar"))
self.label.setText(_translate("Photomaton", "Intervalo capturas (min):"))
self.intervaloCaptura.setInputMask(_translate("Photomaton", "09"))
self.intervaloCaptura.setText(_translate("Photomaton", "00"))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
Photomaton = QtWidgets.QDialog()
ui = Ui_Photomaton()
ui.setupUi(Photomaton)
Photomaton.show()
sys.exit(app.exec_())
En "Intervalo de capturas (min)" indicamos cada cuanto tiempo queremos hacer las capturas de pantalla. Si dejamos 0 solo se realiza una captura en el momento en que damos al botón "Iniciar Captura".
Mientras que está realizando las capturas el botón "Iniciar Captura" se desactiva. El proceso de captura para pulsando el botón "Parar Captura". A veces tarda un rato en responder ya que no se puede interrumpir mientras está ejecutando la conexión con uno de los clientes.
El botón "Visualizar Capturas" nos lleva al directorio donde se realizan las capturas para que veamos las imágenes. Las capturas se estructuran en directorios separados según el patrón: ~/Capturas/$pc_profesor/$pc_alumno/$login_alumno/*.jpg
Los nombres de ficheros jpg nos indican la fecha y hora de captura:
Ahora que con la magnífica serie Chernobyl (quizá desvirtuada con algunos elementos de ficción y drama innecesarios, en detrimento de otros más interesantes como la construcción del sarcófago y los biorobots) se ha reavivado el tema, dejo varios enlaces sobre accidentes nucleares bastante silenciados:
- Three Mile Island: o como "refrigerar" un reactor con vapor de agua en lugar de con agua líquida durante horas hasta fundir parcialmente el núcleo y no darse cuenta.
- Vandellós I: o cómo quedarte a dos grados de explotar, mientras que el director de la central se iba a por tabaco en helicóptero a Barcelona y los trabajadores conseguían controlar la temperatura in extremis con el único turbosoplante que no se había parado por inundación.
- Lucens: o cómo los suizos se lo intentan montar por su cuenta y funden un reactor el día de su puesta en funcionamiento. La única idea buena: como por si las moscas lo hicieron debajo de una montaña, solo se contaminó ésta.
Por supuesto, recomiendo todos los artículos de Yuri sobre Chernobyl:
- Mitos sobre Chernobyl.
- El casco de bombero en el hostital de Pripyat.
- Los 3 heroes de Chernobyl.
- Timing completo de la sucesión de ineptitudes, escrito en forocoches, nunca se plasmó en su blog.
Y no podía faltar:
No hay comentarios:
Publicar un comentario