Discussion :

[Invité]

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.

[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?

[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é.

[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.

[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 ?

[minnesota]

salut,

Il entendait par là plusieurs passes, c'est à dire réécrire par dessus 3, 4 ou 5 fois maximum.

[Médinoc]

En s'assurant que c'est bien flushé entre deux passes.

[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.

[Invité]

Ok donc je réécrie plusieurs fois dessus la totalité des bits du fichier mais flusher veut dire quoi ?

[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é)

[Invité]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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) ?

[JolyLoic]

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.

[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).

[Invité]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)

[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.

[Invité]

Ok je fait comment MEM_COMMIT ? J'ai enlevé mes casts

[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...

[Invité]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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é...

[Médinoc]

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

[Invité]

C'est bon j'y suis enfin arrivé (avec GetDiskFreeSpace) maintenant comment ne pas avoir tous ces blancs ?