Completely erases files by making recovery impossible.

❓ Why

When you delete a file using the rm command or fs.unlink in node, it only remove direct pointers to the data disk sectors and make the data recovery possible with common software tools.

Permanent data erasure goes beyond basic file deletion commands, which:

1. Allow for selection of a specific standard, based on unique needs, and
2. Verify the overwriting method has been successful and removed data across the entire device.

📦 Install

You can use this package in two different ways, the npm module version:

npm install secure-rm --save

Or the command-line version:

npm install secure-rm -g

Secure-rm will retry 3 times if an error occur to ensure the task succeeded.

🚀 Getting started

If you want your application to delete specific files with a pass of cryptographically strong pseudo-random data, use one of these code snippets:

Callback version

const srm = require('secure-rm')

srm('./folder/*.js', (err, path) => {
  if (err) throw err
  console.log(`Successfully removed ${path} !`)
})

Promise version

const srm = require('secure-rm')

srm('./folder/*.js')
  .then((path) => console.log(`Successfully removed ${path} !`))
  .catch((err) => {throw err})

Command line version

If you want to delete files on the fly, just use the command line tool:

secure-rm ./folder/*.js

📚 Usage

npm module

rm(path[, options] [, callback])

• path <String> :
  • an absolute path (e.g. D:\data, /d/data);
  • a relative path (e.g. ./data/file.js, ../../data);
  • a glob pattern (e.g. ./*.js, ./**/*, @(pattern|pat*|pat?erN)).
• options <Object> (optional) :
  • method <String> : ID of the method (default: 'secure');
  • customMethod <Function> : your own method to remove a file (if specified, priority over method);
  • maxBusyTries <Number> : number of retries if an error occur;
  • disableGlob <Boolean> : allow or not file globbing (default: true).
• callback <Function> (if missing, return a promise):
  • returns err <Error> when finished.

Examples:

const options = {
  method: 'gutmann',
  maxBusyTries: 5,
  disableGlob: true
}

srm('./data/file*.js', options, (err, path) => {
  if (err) throw err
  console.log(`Successfully removed ${path} !`)
})

const options = {
  customMethod: function (file, callback) {
    srm.write.init(file)
      .then(({ fileSize, file }) => srm.write.zeroes(file, fileSize))
      .then(({ fileSize, file }) => srm.write.ones(file, fileSize))
      .then(({ fileSize, file }) => srm.write.random(file, fileSize))
      .then(({ file }) => srm.write.unlink(file))
      .then(() => callback())
      .catch((err) => callback(err))
}

srm('./*', options)
  .then((path) => console.log(`Successfully removed ${path} !`))
  .catch((err) => {throw err})

If you want to make your own cutom method, see write.js file for more details.

Events

When running, secure-rm emits events to let you know the progression of the deletion.

You can indeed intercept error and ending events for each file.

srm.event.on('start', (file) => console.log('Starting ' + file))
srm.event.on('unlink', (file) => console.log('Unlinking ' + file))
srm.event.on('done', (file) => console.log('Done ' + file))

srm.event.on('info', (file, info) => console.log('Info ' + info + file))

srm.event.on('warn', (file, err) => console.log('Warning ' + err + file))
srm.event.on('error', (file, err) => console.log('Error ' + err + file))

Command line tool

secure-rm <PATHS> [OPTIONS]

• PATHS:
  • one or multiple paths (e.g. D:\data /d/data ./data/file.js ../../data)
  • supports glob patterns (e.g. ./*.js ./**/* @(pattern|pat*|pat?erN))
• OPTIONS (flags):
  • -f, --force: avoid checks if you want to use it in a shell or bash file;
  • -h, --help: show CLI help, see below;
  • -m, --method: numerical ID of the method, default is 0. See them detailed below;
  • -r, --retries: max retries if an error occur;
  • -t, --table : show the methods table. See them detailed below;
  • -v, --version : show CLI version;
  • --no-globbing : disable file globbing.

Example:

secure-rm ./folder/*.js ./garbage ./file.js -m 6 -f

You can invoke the built-in help with secure-rm -h:

CLI help:

USAGE
 $ secure-rm PATH

OPTIONS
  -f, --force            avoid checks
  -h, --help             show CLI help
  -m, --method=method    [default: secure] select the erasure method
  -r, --retries=retries  max retries if error
  -t, --table            show the methods table
  -v, --version          show CLI version
  --[no-]globbing        allow or not file globbing

DESCRIPTION
  Completely erases files by making recovery impossible.
  For extra documentation, go to https://www.npmjs.com/package/secure-rm

Methods

Note: Node ensures that the file is correctly written, checking the writing in these algorithms is unnecessary.

🚩 Troubleshooting / Common issues

Should works on OS X, Linux, and Windows.

File systems

secure-rm will only work on file systems that overwrite blocks in place.

List of known file systems that will not work:

• ext3
• ext4
• AthFS – AtheOS
• OneFS
• ssd's at large
• reiserfs
• ...
• especially on the vast majority of journaled file systems.

"WARN Too many open files, cannot ...:"

Don't worry, you've just submited too much file for Node. The tool will retry 3 times to ensure the task succeeded. While you don't get an error, the tool can handle this issue.

If you really need to delete millions of file in one time, split the task (e.g. ./your_folder/a* then ./your_folder/b* ...).

Using Windows:

Be sure to use secure-rm ".\path\file" with doublequotes since back-slashes will always be interpreted as escape characters, not path separators.

Another solution is to double the back-slashes like: secure-rm .\\path\\file

Or if you can, use forward slashes!

📜 Changelog

See the changelog or releases.

📌 TODO

• Release of 1.0.0 (stable API)
• Implement more tests
• TypeScript
• Support of 64bit files

🏗 Contributing

See contributing guidelines

Licensing

This project is under MIT License.