Open source et architecture logicielle

Je reprends un peu le cours de mon fil sur le hardening et l’audit de sécurité.
Sur un hardening de serveur il sera nécessaire de modifier certains fichiers de configuration du serveur cible (par exemple httpd.conf) pour remédier les vulnérabilités détectées
Mais nous devrons au préalable faire une sauvegarde des fichiers modifiés.
J’ai donc créé une classe Fichier dont je me sers fréquemment pour ce type d’opération.
Cette classe prend en paramètre (de son constructeur) le nom du fichier à sauvegarder et le recherche récursivement depuis le répertoire courant.
Elle possède une méthode mCreateBackup pour faire la sauvegarde dans le même répertoire que le fichier en rajoutant sufixe .old

Code java :

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
58
59
60
61
62
63
64
65
66
public class Fichier {
	private File pFile;
 
	public Fichier(String name) {
		File currentDirectory = new File(System.getProperty("user.dir"));
		String absoluteName = this.mFindByName(currentDirectory, name);
		pFile = new File(absoluteName);
	}
 
	private String mFindByName(File folder, String filename){
	    String path = null;
	    if(folder.isDirectory()){
	        List<File> files = Arrays.asList(folder.listFiles());
	        Iterator<File> fileIterator = files.iterator();
	        while(fileIterator.hasNext() &&  path==null){
	            path = mFindByName(fileIterator.next(), filename);
	        }
	    } 
	    else if (folder.getName().compareTo(filename) == 0) {
	            path = folder.getAbsolutePath();
	    }
	    return path;
	}
 
	public boolean mCreateBackUp() {
		boolean result = false;
		FileInputStream sourceFile=null;
        FileOutputStream destinationFile=null;
        String destinationName = pFile.getAbsolutePath().concat(".old");
        try {
                File destination = new File(destinationName);
 
                sourceFile = new java.io.FileInputStream(pFile);
                destinationFile = new java.io.FileOutputStream(destination);
 
                // Lecture par segment de 0.5Mo 
                byte buffer[]=new byte[512*1024];
                int nbLecture;
 
                while( (nbLecture = sourceFile.read(buffer)) != -1 ) {
                        destinationFile.write(buffer, 0, nbLecture);
                } 
 
                // Copie réussie
                result = true;
        } catch(FileNotFoundException f ) {
 
        } catch(IOException e ) {
 
        } finally {
                // Quoi qu'il arrive, on ferme les flux
                try {
                        sourceFile.close();
                } catch(Exception e) { }
                try {
                        destinationFile.close();
                } catch(Exception e) { }
        } 
        return result ;
 
	}
 
	public File getpFile() {
		return pFile;
	}
}

Je tenterai dans un prochain post de vous faire une démonstration d’un audit de serveur, pour être plus concret.
D’ici là, si vous êtes intéressé, dites-moi si vous préférez plutôt que je fasses la démo d’un audit en bash (langage qu’affectionnent les devOps) ; Sinon je continu en Java.