Supongo que necesita un archivo temporal para alimentar un programa de formato externo que solo ofrece una interfaz basada en archivos (tal vez algo como Crystal Reports o Adobe Acrobat, o lo que sea).

Un enfoque general podría ser limitar su exposición. Podría montar el archivo temporal en una partición o unidad dedicada separada, y restringir el acceso a eso aún más. Si mantiene la partición temporal lo más pequeña posible, los sectores eliminados se reasignarán y sobrescribirán más rápidamente. Podrías usar una partición encriptada.

Aún mejor, podría implementar esa unidad temporal dedicada con un disco RAM (también conocido como unidad RAM) para que los bytes nunca lleguen a los medios de almacenamiento físicos duraderos. Un apagado o reinicio de la máquina asegurará que se borre.

Escribir sobre archivos en el lugar es difícil y casi imposible con los sistemas operativos actuales. Aquí está la nota de advertencia dada por el venerable comando shred:

  

PRECAUCIÓN: tenga en cuenta que shred se basa en una suposición muy importante: que el sistema de archivos sobrescribe los datos en su lugar. Esta es la forma tradicional de hacer las cosas, pero muchos diseños modernos de sistemas de archivos no satisfacen esta suposición. Los siguientes son ejemplos de sistemas de archivos en los que no es efectivo el triturado: ... ext3 ... sistemas de archivos basados en RAID ... NFS

fuente: enlace

Hay algunas cosas que podrías hacer para minimizar tu exposición. Usted podría:

Limpiar adecuadamente

Al utilizar archivos temporales, muchos programadores cometen el siguiente error:

tmp_file = generate_tmp()    

do_something(tmp_file)  

rm -f tmp_file
exit

Esto lamentablemente no garantiza la limpieza. Si do_something() sale de su programa / script, el archivo temporal persistirá hasta que algún tipo de proceso de limpieza lo obtenga.

El mejor enfoque es usar algo como la trampa de BASH o la de finalmente de Java para asegurar Los archivos temporales se limpian adecuadamente durante cualquier condición. Entonces, un enfoque aceptable sería algo como:

tmp_file = generate_tmp()

try {
  do_something(tmp_file)
}
finally {
  rm -f tmp_file
}
exit

Escriba en el almacenamiento volátil

Como señaló John, escriba el contenido en un disco volátil, como tmpfs / ramfs, que se borraría al apagar / apagar el sistema. Aunque esto está obviamente limitado por el tamaño de su RAM, en cuyo caso usted también podría hacer todo el proceso de generación / procesamiento en la memoria.

Es difícil saber en qué sistema operativo se está ejecutando, tal vez sea UNIX o Linux.

Suponiendo que lo está haciendo, puede inmediatamente open() un archivo temporal, y luego remove() . Permanece abierto durante la duración del proceso que abrió el archivo. O hasta que lo haya hecho, llame explícitamente a close() en el descriptor del archivo. Los sockets UDP transferirán los descriptores de archivos entre procesos. El descriptor transferido es válido para ambos procesos.

Debido a que su pregunta es un poco vaga, esto puede estar completamente fuera de lo necesario. Sin embargo, es una característica de seguridad antigua y útil.

Consulte Stevens & Rago 'Programación avanzada en el entorno UNIX' o Michael Kerrisk 'La interfaz de programación de Linux' Hay ejemplos relevantes de todo esto en ambos libros.