¿Puedo guardar estos documentos en una máquina moribunda del olvido?

Primero, una confesión: no, no hice las copias de seguridad que debería tener.

Segundo, la situación:

Tengo una Dell XPS 9550 con un disco de estado sólido que ejecuta Fedora 25 .

Estaba trabajando en un archivo e intenté guardarlo cuando me dijeron que estaba tratando de guardarlo en un sistema de archivos de solo lectura . Resulta que mi sistema de archivos es de solo lectura ahora y hay errores de E / S por todas partes.

Pude guardar algunos de los archivos enviándolos por correo electrónico a mí mismo a través de un navegador web abierto, pero se bloqueó y no puedo reiniciarlo. Pero todavía tengo archivos de interés abiertos en un editor. Parece que no puedo guardar los archivos en ninguna parte, pero puedo copiar su contenido. Si solo pudiera encontrar una manera de exfiltrar el contenido del archivo, podría ahorrarme meses de trabajo.

Pero hay algunas limitaciones horribles. Intenté insertar una unidad USB, pero ningún dispositivo parece representarla, y el mountcomando muere con un segfault. Puedo intentar ssh a otra computadora, pero recibo un "error de bus" y muere. ping, dmesg, ifconfig, Ninguno de estos trabajos. Pero tengo que vimy lessy lsy puede generar nuevos bashcasos.

No lynx, no firefox, no google-chrome. No hay unidad de DVD.

Básicamente parece que mi SSD ha muerto. O tal vez toda la placa base. Todavía tengo documentos de gran valor en la memoria, tengo una dirección IP y una conexión de red, puedo ejecutar algunos comandos aleatorios y tengo 3500 más en el camino que podría probar.

caty gccparece funcionar Puedo escribir en archivos en / tmp. Tengo una ipythoninstancia en ejecución que todavía parece funcionar.

Entonces ... lo que he intentado hasta ahora ha fallado. Pero siento que todavía hay mil posibilidades. ¿Qué no estoy considerando? ¿Cómo podría sacar estos archivos de mi computadora moribunda?

Debe haber una forma.

ACTUALIZACIÓN : cosas nuevas:

• Perdí mi conexión de red debido a mi propia estupidez.
• Escribí un script de Python para reemplazar cpycp -r
• A menos que encuentre alguna forma de crear una /deventrada para la tarjeta SD o para las unidades USB, mis mejores apuestas para obtener datos parecen ser la pantalla y posiblemente los altavoces / cable de audio.
• Estoy escribiendo una secuencia de comandos para intentar leer archivos y mostrar cuáles son legibles.

Sugerencias siguen siendo muy bienvenidas!

ACTUALIZACIÓN 2 : Cosas más nuevas:

• En la computadora moribunda, escribí un script de Python que leerá un archivo poco a poco y tratará de transmitir esos bits parpadeando la pantalla de un color u otro. En este momento está tratando de hacer un código de dos bits donde rojo, verde, azul y blanco representan un par de dos bits. Sin embargo, esto no funciona tan bien, así que podría cambiar a dos colores y hacer un bit a la vez.
• En mi otra computadora portátil (el viejo y confiable Thinkpad que dejé por este nuevo XPS) escribí un script que lee desde la cámara web usando la biblioteca OpenCV Python. La idea es que decodifique los códigos enviados por la otra computadora. El problema es que la velocidad de fotogramas de la cámara es algo así como 15 fotogramas por segundo, lo que significa que si tuviera una transferencia perfecta y sin errores, mi velocidad máxima de datos sería de 30 bits por segundo, es decir, 225 bytes por segundo. Eso es 324k por día.
• En el XPS moribundo puedo usar tarpara empaquetar los archivos deseados en un solo archivo, que es 1.7 MB. Desafortunadamente, gzip, bzip2, xz, lzopy cualquiera que sea la compresión de los servicios públicos no están disponibles. PERO usando el zlibmódulo de Python, puedo comprimir este archivo a 820 KB. Dado ese tamaño, probablemente podría enviar esta cosa en un par de días.
• Debido a que este método de transferencia probablemente será muy propenso a errores, voy a implementar códigos de Hamming en el XPS para agregar alguna corrección de errores a medida que transmita los datos.
• Probablemente habrá complicaciones porque eso es lo que sucede, ¡pero al menos parece factible sacar estos datos!
• Como esta sigue siendo una forma bastante desagradable de enviar datos, busqué más en los controladores seriales USB. Los módulos que he tratado de carga ( usb-serial-simple, usb-debug, safe-serial) dan i / o errores. Tampoco creo que esté integrado en el núcleo, porque no hay dispositivos / dev / ttyUSB * presentes.

Gracias por las sugerencias de todos hasta ahora --- Sé que esta ni siquiera es una pregunta bien definida ya que ustedes no saben de antemano qué programas / archivos se pueden leer o no. ¡Todavía abierto a mejores sugerencias que este enfoque de video!

ACTUALIZACIÓN 3 : Cosas más nuevas

• Obtuve una cámara web PS3 Eye y, después de deshabilitar su ganancia y exposición automáticas, estoy leyendo con éxito los datos del XPS, aunque con un error de 1 byte por segundo. Este es un gran éxito --- ¡los primeros datos extraídos! Pero la tasa es demasiado lenta para sacar mis 820 KB en un tiempo razonable, y la tasa de error es demasiado alta.

• El problema es que escribir en el terminal es demasiado lento. Las actualizaciones de pantalla no son instantáneas, gracias (creo) a la lentitud del urxvtemulador de terminal al que tengo acceso.
• Descubrí que tengo acceso a un compilador Rust en el XPS. Reescribí el script de transmisión usando Rust para ver si eso mejoraría la velocidad de actualización del terminal, pero no ayudó.
• Debido a que es poco probable que pueda aumentar la velocidad de cuadros, tendré que intentar aumentar la cantidad de datos que obtengo por cuadro. Mi enfoque actual se parece a esto:

La mitad derecha sigue siendo una señal de reloj, parpadeando para marcar la llegada de nuevos cuadros. Pero la izquierda ahora es una cuadrícula donde cada celda está marcada por un cuadrado rojo en la esquina, y luego la celda verde a la derecha y hacia abajo desde el cuadrado rojo se enciende y apaga para indicar un poco. Los cuadrados rojos deberían permitir que la computadora receptora calibre dónde están ubicadas las células. Todavía no tengo datos por este camino, pero es en lo que estoy trabajando.

• Alguien me sugirió que buscara escribir códigos QR en lugar de estos patrones de color ad hoc. Voy a analizar eso también, y tal vez implementarlo en lugar de este enfoque de cuadrícula. La corrección de errores sería una buena victoria, además de poder utilizar bibliotecas estándar para decodificar.
• Aprendí que tengo acceso a libasound (la biblioteca de sonido ALSA), pero no a los archivos de encabezado asociados ( alsa/asoundlib.ho lo que sea). Si alguien sabe cómo usar una biblioteca compartida sin los encabezados, o puede ayudarme a escribir el encabezado correcto para permitirme producir salida de audio, entonces podría tener una forma basada en audio para sacar los archivos.
• Alternativamente, si alguien pudiera ayudarme a manipular los dispositivos USB sin acceso a libusb, ¿tal vez podría hacer algo con eso?

¡Avanzando!

ACTUALIZACIÓN 4 : salida de audio producida!

El usuario Francesco Noferi ha hecho un gran trabajo ayudándome a utilizar la biblioteca ALSA mencionada en la actualización anterior. El compilador de C tuvo un problema, pero al usar el compilador de Rust pude usar el FFI para llamar directamente libasound. ¡Ahora he reproducido muchos de mis datos a través del audio y suena como música para mis oídos! Todavía necesito establecer un canal de comunicación real, pero me siento muy esperanzado. En este punto, mi trabajo es básicamente implementar un módem, por lo que si alguien tiene alguna guía sobre buenas maneras de hacerlo, soy todo oídos. Idealmente, la modulación es fácil de implementar a mano y la demodulación para la que hay una biblioteca existente que puedo usar. Como esto puede pasar directamente por un cable de audio y no a través de la red telefónica, teóricamente podemos hacerlo mucho mejor que 56kbps o lo que sea que fuera el estándar en el día, pero en la práctica quién sabe lo que obtendremos.

Gracias a todos los que siguen aquí y en / r / techsupportmacgyver y en / r / rust aportando tantas sugerencias excelentes. Voy a implementar este "módem" pronto y luego terminaré con un epílogo. Creo que podría poner mi código en algún lugar para que otras personas desesperadas lo utilicen en el futuro, ¿tal vez incluso un repositorio de herramientas de exfiltración extrañas que sean fáciles de escribir en una máquina de morir a mano? Veremos que pasa.

ACTUALIZACIÓN 5 : Me llevó mucho tiempo luchar con ALSA y mi dispositivo de captura de audio USB StarTech barato (sin línea incorporada en la computadora portátil receptora), y muchos falsos comienzos intentan lanzar mi propio protocolo de transmisión, pero finalmente bajo el consejo de algunos Amigos entusiastas de la radioaficionados amigos míos, implementé el protocolo de línea RTTY a 150 baudios, que en la práctica me da unos 10 bytes por segundo. No es súper rápido, pero es bastante confiable. Y casi termino de transferir mi archivo de 820KB, verificado usando las sumas de verificación CRC32 (usando la funcionalidad crc32 de Pythonzlibmódulo, al que tengo acceso). ¡Así que estoy declarando la victoria y quiero agradecerles una vez más! Pasaré más tiempo buscando más archivos que sean legibles y que pueda transferir, pero la base está en su lugar. ¡Ha sido divertido trabajar con todos ustedes!

ACTUALIZACIÓN FINAL :

En la máquina de morir:

$ tar cf ./files
$ ./checksum.py ./files.tar 9999999
Part 1 checksum: -1459633665
$ ./zlib_compress.py ./files.tar
$ ./checksum.py ./files.tar.z 9999999
Part 1 checksum: -378365928
$ ./transmit_rust/target/debug/transmit ./files.tar.z
Transmitting files.tar.gz over audio using RTTY
Period size: 2048
Sample rate: 44100
Samples per bit: 294
Sending start signal.
Transmitting data.
nread: 2048
nread: 2048
...
nread: 2048
nread: 208
Transmission complete. Sending hold signal.

En la máquina de rescate:

$ minimodem --rx -8 --rx-one -R 44100 -S 915 -M 1085 --startbits 3
            --stopbits 2 --alsa=1 150 -q > ./files.tar.z
$ ./checksum.py ./files.tar.z
Part 1 checksum: -378365928
$ ./zlib_decompress.py ./files.tar.z
$ ./checksum.py ./files.tar
Part 1 checksum: -1459633665

:-)

Aquí hay un ejemplo de programa libasound con las definiciones suficientes para obtener una salida wav básica de 44.1k de 2 canales sin los encabezados.

EDITAR: en realidad no estoy seguro de si el volcado directo de datos como wav funcionaría, ya que el ruido al grabar podría dañarlo fácilmente, pero probablemente pueda hacer algo como una onda sinusoidal de bits a alta frecuencia que es más confiable

EDIT2: si hay un aplay presente y funciona, también puede usarlo y simplemente escribir un programa que emita audio sin formato y canalizarlo en aplay o cualquier cosa que pueda reproducir audio

EDITAR3: lo modificó para no usar ningún encabezado

si -lasound no se compila, agregue -L / path / where / libasound / is / ubicado

/*
    gcc alsa_noheader.c -lasound
    cat stuff.wav | ./a.out
*/

typedef unsigned int uint;
typedef unsigned long ulon;

int printf(char*, ...);
void* malloc(long);
long read(int fd, void* buf, ulon count);

int snd_pcm_open(void**, char*, int, int);
ulon snd_pcm_hw_params_sizeof();
int snd_pcm_hw_params_any(void*, void*);
int snd_pcm_hw_params_set_access(void*, void*, int);
int snd_pcm_hw_params_set_format(void*, void*, int);
int snd_pcm_hw_params_set_channels(void*, void*, uint);
int snd_pcm_hw_params_set_rate_near(void*, void*, uint*, int*);
int snd_pcm_hw_params(void*, void*);
int snd_pcm_hw_params_get_period_size(void*, ulon*, int*);
long snd_pcm_writei(void*, void*, uint);
int snd_pcm_prepare(void*);
int snd_pcm_drain(void*);
int snd_pcm_close(void*);

int main(int argc, char* argv[])
{
    void* pcm;
    void* params;

    int rate;
    int nchannels;
    ulon frames;
    void* buf;
    int bufsize;
    long nread;

    snd_pcm_open(&pcm, "default", 0, 0);
    params = malloc(snd_pcm_hw_params_sizeof());
    snd_pcm_hw_params_any(pcm, params);

    /* 3 = rw_interleaved */
    snd_pcm_hw_params_set_access(pcm, params, 3);

    /* 2 = 16-bit signed little endian */
    snd_pcm_hw_params_set_format(pcm, params, 2);

    /* 2 channels */
    nchannels = 2;
    snd_pcm_hw_params_set_channels(pcm, params, nchannels);

    /* sample rate */
    rate = 44100;
    snd_pcm_hw_params_set_rate_near(pcm, params, &rate, 0);

    snd_pcm_hw_params(pcm, params);
    snd_pcm_hw_params_get_period_size(params, &frames, 0);

    bufsize = frames * nchannels * 2;
    buf = malloc(bufsize);

    /* read file from stdin */
    while (nread = read(0, buf, bufsize) > 0)
    {
        if (snd_pcm_writei(pcm, buf, frames) == -29)
        {
            printf("W: underrun\n");
            snd_pcm_prepare(pcm);
        }
    }

    snd_pcm_drain(pcm);
    snd_pcm_close(pcm);

    return 0;
}

¿Funciona su HDMI o cualquier otro puerto de salida de pantalla? Si es así, puede usar un dispositivo de captura de pantalla para grabarlo como video y procesarlo más tarde. Por lo tanto, no estar limitado por la velocidad de fotogramas de su cámara web.

¿Qué tal si codifica de manera hexadecimal sus datos y los envía página por página al terminal?

Puede agregar un prefijo con el desplazamiento en el binario para que pueda regenerar fácilmente una página (¿para corrección manual?)

Luego, en una computadora diferente, use algún software de OCR para escanear las páginas.

El terminal 80x25 produciría 1000 bytes por página (menos algo de espacio para el prefijo). Entonces, en aproximadamente 1000 páginas, puede obtener sus datos. Incluso a una página por segundo, eso es menos de 20 minutos.

La codificación hexadecimal es fácil de escribir y también proporciona una forma cruda de corrección de errores (solo hay 16 símbolos válidos).

¿Puedes configurar una conexión de red? ssh puede ser demasiado, pero si puede usar netcat en 2 máquinas, podría transferir datos. uno en modo de envío, uno en modo de escucha. Si todo lo que necesita hacer es transferir texto, entonces este 'podría' ser una solución.

edit: no importa, solo lee que también perdiste tu conexión de red ...

Es posible que pueda enviarse un correo electrónico desde la línea de comandos, incluido el envío de archivos.

Algo como:

$ mail -s "Hello World" user@yourmaildomain.com < /tmp/urgentFileToSave.txt

Deberia trabajar.

Algunos ejemplos adicionales: http://www.binarytides.com/linux-mail-command-examples/

¿Puede Python acceder a su puerto de salida de audio? Puede intentar transferir datos usando eso, vea esto o aquello .

Puede quitar el SSD de su máquina y dd/ photorec/ etc. en otra máquina que funcione.

Aquí está el manual de servicio de Dell para el 9550 : consulte la sección "Extracción de la unidad de estado sólido". Una vez que extraiga la unidad, puede obtener un gabinete USB M.2 externo y conectar el disco a otra máquina para recuperar sus datos.

Apuesta arriesgada, pero algunas distribuciones tienen protocolos de radioaficionados incorporados. Uno común es fldigi. Prueba cuál fldigi.

Si tiene este u otro, convierten el texto en audio, generalmente utilizando alguna variación de la modificación de fase. La salida va a sus altavoces / auriculares y es recibida por una computadora estable en la misma habitación, que aparece en su micrófono. (Esto elimina las radios de radio que transmiten y reciben el audio a través de las ondas de radio).

El enfoque de los códigos QR podría ser bueno. Puede colocar tantos como pueda en la pantalla y actualizarlos tan pronto como su terminal lo permita. Luego grabe la pantalla del XPS con una cámara (en lugar de usar una cámara web), y solo trabaje en descifrar el video que ha guardado. Puede ser útil utilizar incluso la captura en cámara lenta.

Gran espectáculo :) Tengo 1 sugerencia: también puedes leer datos de la pantalla usando un fotodiodo conectado a la tarjeta de sonido de la otra computadora