How can a program delete its own executable

Question

Is there any way that a running process can delete its own executable?

For example, I make a console application (single exe) and after doing some tasks it somehow deletes the exe file.

I have to send a single file to someone. And I want it deleted after it does its intended task.

Is there anyway to do it in Windows

Answer 1

One way to do this is to use the MoveFileEx function with the MOVEFILE_DELAY_UNTIL_REBOOT flag and a NULL destination. According to the documentation, this:

registers the lpExistingFileName file to be deleted when the system restarts. If lpExistingFileName refers to a directory, the system removes the directory at restart only if the directory is empty.

Answer 2

process.start("cmd /c ping localhost -n 3 > nul & del filepath")
exit

Explanation :

ping localhost -n 3

Adds a slight delay before executing del filepath. By the time it's triggered, your program has exited.

Replace process.start with whatever command your programming language uses to start programs with arguments.

Replace filepath with the path to your exe.

Replace exit with the command for terminating your program.

===

10yr anniverary edit, if this doesn't work, you must find a way to perform a "process.start" that starts a separate (external) process, not one subordinate to your original calling program: Python, Bash, C, ...... or search for a different language

Replace the search in the catch all with your programming language and you will likely find a suitable guide for this essential step. Please take care to ignore superfluous information as every question may come with obscure specific details that are unrelated to you.

Answer 3

You can use windows scheduler to schedule a task to delete your program after X seconds.

Command line: http://msdn.microsoft.com/en-us/library/bb736357%28VS.85%29.aspx

Or API: http://msdn.microsoft.com/en-us/library/aa383608%28VS.85%29.aspx

Answer 4

You can run another application, which would wait for parent process to terminate, and then delete its executable.

Answer 5

It's possible to do this on Linux. You'll find that it is generally not possible to delete a running executable on Windows. However, you can have Windows delete the EXE for you on the next reboot: http://www.howtodothings.com/computers/a1402-delete-a-running-exe.html

If you want the file deleted after it's been run, you could simply ask the user to delete it. If the reason you want this is as a security measure, then what you're doing is misguided. The user could circumvent this by simply making a copy of the file first.

Answer 6

While it's not possible to self delete a file when it's running it is possible to launch a detached cmd command from the file, then end the file operation before the command executes. So, if you want to delete a bat file you can just add at the end of the file the line: start cmd /c del %0 and the file would self destruct.

The start cmd will start a new cmd window (detached from your main process). The /c tells the windows to execute whatever comes after the /c in the line. Then the del will delete the file at the path it is given. The parameter $0 refers to the first command line argument which is usually the name and path to the file that was executed, which is what we want. (the $0 parameter is the path to the file, you want to pass that to the del command).

Answer 7

Until that exe is in memory, it will not be able to delete itself. However, it can register with the system a task for deleting itself after a set time period of gap when it would be expected to be completing its execution.

Answer 8

I solved this problem (using Visual Basic) by creating a batchfile that is executed while the process is still running, waits 1sec so the program can close itself and than deletes the program.

You might need to modify it for this will delete every thing in the same folder. After your task just call del() and it should work.

 Sub del()
    Dim file As System.IO.StreamWriter
    file = My.Computer.FileSystem.OpenTextFileWriter("del.bat", True)
    file.WriteLine("")
    file.WriteLine("timeout 1")
    file.WriteLine("echo Y | del *.*")
    file.Close()
    Process.Start("del.bat")
    Me.Close()
End Sub

Answer 9

I couldn't find any solutions anywhere else so I'll post my fix here.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(int argc, char* argv[])
{
    char* process_name = argv[0];
    char command[256] = "start /min cmd /c del ";
    strcat(command, process_name);

    printf("Attempting to delete self...\n");

    system(command);
    return 0;
}

Normally, trying to use system to call the command prompt to delete an executable would not work because the command prompt that is spawned is a child process that system executes and waits for a return status.

This method calls the system to start a command prompt process on its own thread.

The /min argument starts the process as "hidden".
The /c argument supplies arguments to the spawned command prompt.

I know this is an old thread, but I hopes those that come here in the future.