effacement sécurisé windows

Version imprimable

22/01/2014, 16h32
Invité

effacement sécurisé windows

Bonjour,
Je voudrais effacer un fichier de manière sécurisé je voudrais savoir si le fait d'écrire dessus des données aléatoire puis l'effacer suffirait ?

et j'ai une deuxième question qui n'a pas vraiment de rapport je voudrais aussi pouvoir écrire dans mon exécutable pour y écrire un chemin d'un fichier , peut être dans les ressources de l’exécutable ou les sections (mais je veux que ça soit propre donc si il existe des fonctions exclusivement pour ça , sa serait bien)

merci d'avance.
22/01/2014, 20h09
Neckara

Bonjour,

En mode paranoïaque, il faudrait :
- effacer plusieurs fois le fichier et écrire plusieurs fois des données aléatoire dessus ;
- exposer le disque dur à des ultraviolet ou à des champs électriques ;
- casser le disque dur et jeter les différents morceaux un peu partout.

A ton niveau, je pense que tu peux te contenter de la première étape ;)

Pour ta seconde question, pourquoi ne pas simplement utiliser un fichier de configuration au format de ton choix?
22/01/2014, 20h51
Invité

Merci pour ta réponse,
Oui d'accord je vois, tu pourrais préciser "effacer plusieurs fois le fichier" ? donc ma technique est relativement bonne ?

Oui j'y est pensé.
22/01/2014, 21h02
Neckara

Il faut comprendre que quand tu écris dans un disque dur, tu écris en binaire avec des 0 et des 1.

Mais physiquement, tu as des valeurs entre 0 et 5V.
Vers 0V, ce sera 0 et vers 5V ce sera 1.

Sauf que la valeur n'est jamais exactement 0V ou exactement 5V et ces valeurs peuvent changer en fonction de ce qui était précédemment écris.

Je résume grossièrement, mais il y a aussi d'autre choses qui permettent de retrouver ce qui était anciennement écris.

C'est pour cela qu'on conseille d'effacer plusieurs fois le disque dur en écrivant des valeurs aléatoire dessus.
22/01/2014, 21h39
Invité

d'accord mais concrètement tu voulais dire quoi en disant "effacer plusieurs fois le fichier" je fait comment pour l'effacer plusieurs fois ?
23/01/2014, 10h04
minnesota

salut,

Il entendait par là plusieurs passes, c'est à dire réécrire par dessus 3, 4 ou 5 fois maximum.
23/01/2014, 10h58
Médinoc

En s'assurant que c'est bien flushé entre deux passes.
23/01/2014, 11h10
phi1981

Les conseils donnés par les autres (en particulier celui de Médinoc qui conseille de flusher entre les passes) sont tout à fait suffisants pour un usage normal, mais je me sens obligé de préciser :

Certains systèmes de fichiers, comme JFFS (http://en.wikipedia.org/wiki/JFFS), sont optimisés pour des composants qui supportent mal le fait d'écrire plusieurs fois "au même endroit" (comme certaines flashs). Du coup, même si ces systèmes de fichiers donnent l'illusion que tu écris par dessus les données de ton fichier, tu as en fait écrit ailleurs, et les données originales ne sont donc pas forcément effacées.
23/01/2014, 13h24
Invité

Ok donc je réécrie plusieurs fois dessus la totalité des bits du fichier mais flusher veut dire quoi ?
23/01/2014, 14h41
therwald

flusher, c'est s'assurer que le cache disque en écriture (qui permet d'accélérer les opérations en écrivant d'abord en RAM avant de rendre la main à l'appelant et écrire en différé) est bien vidé vers le disque. Sinon, les écritures successives se changeront en modification successives en RAM avant qu'une seule écriture soit faite (voire, si tu termines en supprimant le fichier, aucune écriture et juste le marquage 'fichier effacé)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
#include "stdafx.h"
 
using namespace std;
 
int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hand;
	static char DataBuffer[] = "This is some test data to write to the file.";
	DWORD dwBytesToWrite = (DWORD)strlen(DataBuffer);
	DWORD dwBytesWritten = 0;
	BOOL bErrorFlag = FALSE;
	unsigned int i;
	BOOL aaa;
	LPVOID bb;
 
	bb = VirtualAlloc(NULL, strlen(DataBuffer), MEM_RESERVE, (DWORD)PAGE_READWRITE);
	cout << bb << endl;
 
	hand = CreateFileW(
		(LPCTSTR)L"C:\\Users\\Yohann\\Desktop\\loader.txt",
		GENERIC_READ | GENERIC_WRITE,
		(DWORD)0,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		NULL);
 
	if (hand != INVALID_HANDLE_VALUE)
	{
		unsigned int j;
		j = (unsigned int)GetFileSize(hand, NULL);
		srand(time(NULL));
		/*while(i<j)
		{
		lpBuffer +=
		i+=1;
		}*/
 
		if (WriteFile(hand, DataBuffer, dwBytesToWrite, &dwBytesWritten, NULL))
		{
			cout << "ok write" << endl;
 
		}
		wcout << GetLastError() << endl;
		if (1 == 0)
		{
			DeleteFileW((LPCTSTR)L"C:\\Users\\Yohann\\Desktop\\loader.txt");
		}
 
 
	}
	CloseHandle(hand);
	Sleep(20000);
 
	return 0;
}

Je ne comprend pas pourquoi WriteFile me renvoie 0 et GetLastError , 87 (paramètre invalide) ?

25/01/2014, 12h03
JolyLoic

Citation:

Envoyé par yohann2008

voudrais aussi pouvoir écrire dans mon exécutable pour y écrire un chemin d'un fichier

La plupart du temps, tu n'as pas les droits d'accès nécessaires pour écrire dans un exécutable. Ce qui est une bonne chose pour limiter la prolifération des virus.
25/01/2014, 13h04
Médinoc

À quoi sont supposés servir tous ces horribles casts en LPCTSTR?

PS: WriteFile foire parce que tu es en FILE_FLAG_NO_BUFFERING, et tu lui passes un pointeur de données non-alignées (DataBuffer au lieu de bb).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include "stdafx.h"
 
using namespace std;
 
int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hand;
	static char DataBuffer[] = "This is some test data to write to the file.";
	DWORD dwBytesToWrite = (DWORD)strlen(DataBuffer);
	DWORD dwBytesWritten = 0;
	BOOL bErrorFlag = FALSE;
	LPVOID bb;
 
 
	bb = VirtualAlloc(NULL, strlen(DataBuffer), MEM_RESERVE, (DWORD)PAGE_READWRITE);
 
	hand = CreateFileW(
		(LPCTSTR)L"C:\\Users\\Yohann\\Desktop\\loader.txt",
		GENERIC_READ | GENERIC_WRITE,
		(DWORD)0,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		0);
 
	if (hand != INVALID_HANDLE_VALUE)
	{
 
		if (WriteFile(hand, bb, strlen(DataBuffer), &dwBytesWritten, NULL))
		{
			cout << "ok write" << endl;
 
		}
 
wcout << GetLastError() << endl;
	CloseHandle(hand);
 
	return 0;
}

Toujours 87 pourtant j'ai utilisé virtualAlloc, exécuté avec les droits administrateurs (et le fichier existe)

25/01/2014, 14h53
Médinoc

Je suis surpris que ça n'ait pas planté: La mémoire est réservée, mais pas committée!
De plus, tu n'y as toujours pas recopié la chaîne avant de passer le buffer à WriteFile().

Et tu n'as toujours pas retiré ces casts qui ne servent à rien et castent en le mauvais type de toute façon.
25/01/2014, 15h05
Invité

Ok je fait comment MEM_COMMIT ? J'ai enlevé mes casts
25/01/2014, 15h08
Médinoc

Pour un VirtualAlloc où on veut une zone mémoire là, maintenant, tout de suite, on passe simplement les deux flags MEM_RESERVE|MEM_COMMIT...

Merci beaucoup :?
L'entre temps ou je ne répond pas , je fait mes recherches

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#include "stdafx.h"
 
using namespace std;
 
int _tmain(int argc, _TCHAR* argv[])
{
	HANDLE hand;
	static char DataBuffer[] = "This is some test data to write to the file.";
	DWORD dwBytesToWrite = strlen(DataBuffer);
	DWORD dwBytesWritten = 0;
	BOOL bErrorFlag = FALSE;
	unsigned int i;
	BOOL aaa;
	LPVOID bb;
 
 
	bb = VirtualAlloc(NULL, strlen(DataBuffer), MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
	CopyMemory(
		bb,
		&DataBuffer,
		sizeof(DataBuffer)
		);
 
 
 
	hand = CreateFileW(
		L"C:\\Users\\Yohann\\Desktop\\loader.txt",
		GENERIC_READ | GENERIC_WRITE,
		0,
		NULL,
		OPEN_EXISTING,
		FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
		0);
 
	if (hand != INVALID_HANDLE_VALUE)
	{
 
		if (WriteFile(hand, bb, strlen(DataBuffer), &dwBytesWritten, NULL))
		{
			cout << "ok write" << endl;
 
		}
		wcout << GetLastError() << endl;
 
 
 
	}
	VirtualFree(bb, NULL, MEM_RELEASE);
 
	CloseHandle(hand);
	Sleep(20000);
 
	return 0;
}

Toujours 87 !! J'ai bien copié avec Copymemory ! c'est vrai je suis bête je n'ai pas pensé a faire ça.
Et edit : tu n'es plus connecté...

25/01/2014, 17h26
Médinoc

Apparemment, les lectures/écritures doivent aussi avoir une taille "ronde" (en multiples de la taille d'un secteur).
25/01/2014, 23h21
Invité

C'est bon j'y suis enfin arrivé (avec GetDiskFreeSpace) maintenant comment ne pas avoir tous ces blancs ?
26/01/2014, 00h33
Médinoc

En mode sans buffer, tu ne peux les éviter. Mais pour faire un programme broyeur, tu t'en moques.
26/01/2014, 12h14
Invité

Oupss je n'avait pas vu ton message , mais comment fait windows pour les éviter ?
26/01/2014, 12h20
Médinoc

Il ne les évite pas.
Un fichier ouvert en mode sans buffer aura toujours une taille multiple de la taille de secteur.
26/01/2014, 13h01
Invité

A ok mais avec writefile impossible d'écrire en binaire ? Createfile n'as pas de "flag" binary
Une petite question quesqu'un "high order doubleword" ?
26/01/2014, 13h16
Médinoc

CreateFile/WriteFile est toujours en binaire. Le mode texte est uniquement dans les fonctions de la C Run-Time Library, qui utilisent CreateFile().

High order double-word, c'est les 32 bits supérieurs d'un nombre de 64 bits.