Comment puis-je effacer mon application C # (auto-destruction)? Je pense que cela peut fonctionner de deux manières:
Ces deux méthodes semblent inefficaces. J’ai l’impression qu’il y a un drapeau intégré ou quelque chose dans Windows qui permet ce genre de choses. Comment devrais-je le faire? Aussi, pouvez-vous fournir un exemple de code?
MISE À JOUR: Merci pour toutes vos réponses! Je vais les essayer et voir où ça me mène.
Tout d’abord, certaines personnes ont demandé pourquoi je voulais que mon application le fasse. Voici la réponse: il y a quelques jours, j’ai lu les spécifications du projet Aardvark que Joel Spolsky a publiées sur son blog, et il a mentionné que l’application client se supprimerait elle-même après la session à distance. Je me demande comment cela fonctionne et comment, si jamais je dois le faire, je peux accomplir un tel exploit.
Voici un petit aperçu de ce qui a été suggéré:
Bien entendu, les deux ont leurs inconvénients, comme indiqué dans les commentaires.
Cependant, une telle méthode, décrite ci-dessous, fonctionnerait-elle?
Il existe deux exécutables: Program.exe et Cleaner.exe. Le premier est le programme lui-même, le second est l’application qui supprime Program.exe et lui-même (s’il est chargé en mémoire, comme je vais l’expliquer). Est-il possible que Program.exe (qui a des dépendances) charge tout Cleaner.exe, qui n’a pas de dépendances, en mémoire et l’exécute?
Si cela est possible, Cleaner.exe pourrait-il être intégré à Program.exe, chargé en mémoire et exécuté?
Il y a une API MoveFileEx qui, lorsqu’elle reçoit un indicateur MOVEFILE_DELAY_UNTIL_REBOOT
, supprime le fichier spécifié au prochain démarrage du système.
Il y a un excellent article CodeProject sur ce sujet.
Edit: Fondamentalement, c’est un simple cmd-call qui supprimera les fichiers spécifiés après quelques secondes.
Process.Start("cmd.exe", "/C ping 1.1.1.1 -n 1 -w 3000 > Nul & Del " + Application.ExecutablePath); Application.Exit();
Vous ne serez jamais en mesure de garantir que cela fonctionnera, tant que vous avez besoin d’une présence physique sur la machine. Par exemple:
Si votre application requirejs ce niveau de sécurité, envisagez de l’héberger sur une machine que vous contrôlez (par exemple, en fournissant un service Web et en autorisant un client de remplacement à y accéder).
Sur une note un peu similaire, on est également tenté de spéculer sur les motivations de quelqu’un qui (1) nécessite une présence physique sur la machine de quelqu’un et (2) souhaite supprimer la preuve de l’existence de l’application.
Une correction à @Bobby répond, au cas où les gens le trouveraient utile – le chemin exécutable doit être cité. En outre, ci-dessous, la fenêtre cmd.exe doit être masquée (sinon, elle clignote en tant que fenêtre de console noire) et convertie pour s’exécuter sans s’appuyer sur l’assembly System.Windows.Forms (la classe Application).
var exepath = Assembly.GetEntryAssembly (). Emplacement; var info = new ProcessStartInfo ("cmd.exe", "/ C ping 1.1.1.1 -n 1 -w 3000> Nul & Del \" "+ exepath +" \ ""); info.WindowStyle = ProcessWindowStyle.Hidden; Process.Start (info) .Dispose (); Environment.Exit (0);
Il existe également FileOptions.DeleteOnClose
, mais cela nécessite que le fichier soit ouvert pour l’écriture. Vous pourrez peut-être le faire avec une séquence comme celle-ci (non testée):
Original.exe
et détecte (à partir de son propre nom) qu’il doit déclencher la fonction d’autodestruction. Original.exe
crée un nouveau fichier Temp.exe
avec FileOptions.DeleteOnClose
et y copie son propre contenu, mais ne le ferme pas encore Original.exe
ouvre un second handle en lecture seule à Temp.exe
et ferme le premier Temp.exe
écriture. Le handle en lecture seule peut coexister avec un handle d’exécution, tout en gardant le fichier ouvert pour retarder la suppression automatique. Original.exe
lance Temp.exe
. Temp.exe
détecte qu’il a été lancé depuis le répertoire temporaire et contourne la séquence d’autodestruction et poursuit son fonctionnement normal. Original.exe
quitte (en prenant son handle en lecture seule à Temp.exe
avec.) Temp.exe
continue à fonctionner. A sa sortie, le fichier Temp.exe
ne sera plus utilisé, il sera donc automatiquement supprimé. Edit # 2 : En fait, je ne pense pas que cela soit possible, car il repose sur l’ouverture du fichier par l’indicateur FILE_SHARE_DELETE
, ce qui est peu probable.
sortingé par NJ c # les autres codes ne fonctionnent pas, donc c’est simple si vous créez un fichier de bain qui boucle à del application et le fichier batch lui-même vous pouvez utiliser la commande takkill pour tuer le processus si vous ne voulez pas utiliser la méthode application.close
`ssortingng delname = "test.cmd"; ssortingng fileurl = Application.ExecutablePath; System.IO.StreamWriter file = new System.IO.StreamWriter(delname); file.WriteLine(":Repeat"); file.WriteLine("del \"" + fileurl + "\""); file.WriteLine("if exist \"" + fileurl + "\" goto Repeat"); file.WriteLine("del \"" + delname + "\""); file.Close(); ProcessStartInfo startInfo = new ProcessStartInfo(); startInfo.CreateNoWindow = true; startInfo.UseShellExecute = false; startInfo.FileName = delname; startInfo.WindowStyle = ProcessWindowStyle.Hidden; Process.Start(startInfo);`
`Th3 3e3 on n’est pas des pièces 3d ov un I5 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Pensez CMD
int sectosleep = 5000; ssortingng exename = "yourexe.exe"; ssortingng location = @"c:\yourexe.exe" Process.Start("cmd.exe", "/C taskkill /f /im " + exename + " & ping 1.1.1.1 -n 1 -w " + sectosleep + " > Nul & Del /F /Q \"" + location + "\"");
;>
Je sais que le réflecteur se supprime si vous utilisez une ancienne version et choisissez de ne pas mettre à jour. Vous pourriez essayer de comprendre ce que ça fait. Je commencerais par FileMon et je verrais s’il génère des processus pour y parvenir.
Étant donné que mon application (un service Windows) est installée via Windows Installer, je supprime automatiquement à l’aide de ceci:
Dim uninstall_params As Ssortingng = "/x {MY-PRODUCTS-GUID} /qn /norestart REBOOT=ReallySuppress" proc.StartInfo = New ProcessStartInfo("msiexec.exe", uninstall_params) proc.Start() Environment.Exit(-1)
Désolé – il est dans VB, mais il devrait être facilement convertible en C #.
Fonctionne dans Windows 7 et 8, ** Assurez-vous que vous exécutez votre application avec des privilèges d’administrateur ou vous obtiendrez une erreur.
Ce code existe ailleurs donc je ne peux pas prendre le crédit complet J’ai trouvé que je l’ai fait fonctionner pour moi en ajoutant “Application.Exit ();”
static void autodelete() { ssortingng batchCommands = ssortingng.Empty; ssortingng exeFileName = Assembly.GetExecutingAssembly().CodeBase.Replace("file:///", ssortingng.Empty).Replace("/", "\\"); batchCommands += "@ECHO OFF\n"; // Do not show any output batchCommands += "ping 127.0.0.1 > nul\n"; // Wait approximately 4 seconds (so that the process is already terminated) batchCommands += "echo j | del /F "; // Delete the executeable batchCommands += exeFileName + "\n"; batchCommands += "echo j | del deleteMyProgram.bat"; // Delete this bat file File.WriteAllText("deleteMyProgram.bat", batchCommands); Process.Start("deleteMyProgram.bat"); Application.Exit(); }