Sécurité Informatique: Intro et Théorie

Principes fondamentaux

La sécurité informatique est un ensemble de moyens techniques, juridiques, organisationnels et humains pour garantir la sécurité des systèmes d’information (SI). Les critères de la sécurité des SI sont :

  • La disponibilité : Consiste à assurer l’accessibilité de la ressource informatique (utilisable en un temps de réponse acceptable) et la possibilité de mener à terme une session de travail.
  • L’intégrité : Consiste à pouvoir confirmer que les données, les traitements et les serveurs n’ont pas été altérés, modifiés ou détruits de façon intentionnelle ou accidentelle.
  • La confidentialité : Consiste en le maintien du secret des informations, à savoir que l’information est seulement accessible à ceux qui ont droits.

Remarque :

Bien que la sécurité des SI repose sur ces trois critères, le poids donné à chaque critère dépend de l’institution.

Exemple :

Banque → Intégrité

Militaire → Confidentialité

Fournisseur d’accès internet → Disponibilité

 

Deux critères s’ajoutent aux trois premiers :

  • Traçabilité : Consiste à s’assurer qu’un événement a eu lieu et que seuls les entités identifiées sont à l’origine de l’événement. On parle alors de : authentification, non-reproduction, compatibilité, journalisation.
  • Auditabilité : Consiste en la capacité du système à garantir la présence des informations nécessaires à une analyse ultérieure.

 

Périmètre de sécurité 

La sécurité des SI se décline en plusieurs périmètres de sécurité. Nous parlerons donc de :

  • Sécurité physique : Elle concerne l’environnement dans lequel se situent les systèmes et leurs moyens de maîtrise.
  • Sécurité de l’exploitation : Concerne la grande partie des aspects organisationnels, de gestion et de surveillance, qui touchent au bon fonctionnement des SI.
  • Sécurité logique : Elle concerne l’ensemble des mécanismes de sécurité par logiciel.
  • Sécurité applicative : Elle concerne la sécurité des applications installées ou en phase de réalisation.

On peut ajouter la sécurité des télécommunications et la sécurité juridique.

Exemple :

Programmer proprement ->Sécurité applicative

Configuration d’un pare-feu ->Sécurité des télécommunications

Création de configuration et des mises à jour ->Sécurité de l’exploitation

Installation d’antivirus ->Sécurité logique

Protection d’accès ( porte à code) ->Sécurité physique

Analyse des logs ->Sécurité de l’exploitation

Redondance du matériel ->Sécurité physique

 

Les 7 principes de base de sécurité

  1. Moindre privilège : Ce principe stipule que chaque utilisateur et chaque module d’un système ne doit posséder que les droits minimaux pour effectuer ses tâches.
  2. Goulet d’étranglement : Ce principe consiste à éviter tout moyen possible de contourner les points d’accessibilité.
  3. Défense en profondeur : Elle est réalisée en utilisant plusieurs mécanismes de protection redondants.
  4. Maillon le plus faible : Un système de protection n’est jamais plus efficace que son élément le plus faible.
  5. Déni par défaut : Consiste de partir du principe qui consiste à tout interdire sauf ce qui est explicitement permis.
  6. Simplicité : Plus le système de protection est simple, plus il a de chances d’être configuré et maintenu. Il est ainsi capable de fournir une sécurité presque sans faille car il est plus facile à documenter et à valider.
  7. Participation des utilisateurs : Un système de sécurité n’est efficace que si tous les utilisateurs adhèrent à ses principes.

Le Raspberry Pi

Un ordinateur complet pour 25 euros, de la science fiction ? Eh ben figurez vous que non, depuis quelques temps, un projet fait fureur sur le net. Il s’agit du Raspberry Pi, un Le Raspberry Piordinateur aussi petit qu’une carte de crédit.

Proposé de base avec un noyaux linux (Debian), il intègre de nombreux logiciels dédiés à la programmation, ainsi que le navigateur web Midori réputé pour être l’un des plus légers jamais conçus, il permet un navigation fluide, malgré la faible configuration de la machine.

Les concepteurs du Raspberry pi proposent deux modèles (A et B) relativement similaires.  Les deux intègrent un processeur ARM (Architecture très répandu dans l’informatique embarquée) d’une puissance 700 MHz. Pour l’affichage, nous disposons d’une sortie vidéo composite standard (RCA) ainsi que d’une sortie HDMI. Pour ce qui est de la mémoire le Raspberry Pi inclut 256 Mo de mémoire vive (SDRAM) et un port pour une carte SD qui fait office de disque dur. Pour les périphérique seul le strict nécessaire à été gardé : un ou deux ports USB (selon le modèle choisit) et une prise RJ45 pour la connexion réseau (seulement sur le modèle B). Le tout est alimenté en 5V (micro usb, ou alimentation externe).

Interessant par son prix et son bouquet software, cet ordinateur est adapté non seulement aux « grands bidouilleurs », mais aussi aux débutants. De plus, couplé avec un arduino, il offre aussi de nombreuse possibilité au niveau informatique embarquée.

Vous désirez vous en procurer un ? Désolé, mais 2h après sa commercialisation (Mercredi 29 février), les 10 000 étaient déjà tous vendus. Une seconde vague est a prévoir, alors restez patients !

Site officiel : http://www.raspberrypi.org/

Horloge Binaire Via Arduino + LoL Shield

Aujourd’hui, premier mars, je partage avec vous le code permettant l’affichage d’une horloge binaire sur votre LoL Shield contrôlé par Arduino. Cette horloge se divise en trois colonnes correspondant bien évidemment aux heures, minutes et secondes. Chaque colonne fait deux leds de large. Pour être correct, l’heure doit être initialisée à chaque fois que l’on relance le Arduino et il faut alors renvoyer le programme sur celui-ci. Il serait possible de synchroniser automatiquement l’horloge en se servant d’un shield Ethernet pour récupérer l’heure.

Quelques mots sur la fonction millis(). Cette fonction renvoie le nombre de millisecondes écoulées depuis que le Arduino a commencé à exécuter le programme en cours. Ce nombre revient à 0 après environ 50 jours. Ainsi, cette fonction va nous permettre d’incrémenter les secondes. Nous utiliserons le code suivant:

static unsigned long lastTick = 0;

if (millis() – lastTick >= 1000) {
 lastTick = millis();
 seconde++;}

Si le nombre de millisecondes depuis le début du programme moins le moment du dernier test est supérieur ou égale à 1 000, nous stockons le nombre de ms depuis le début du programme dans lastTick et nous incrémentons les secondes, dans le cas contraire, on ne change rien. Ainsi, toutes les 1 000 ms, les secondes seront incrémentées.

Pour la fonction LedSign::Set, la syntaxe est la suivante: LedSign::Set( C, L, E); . Avec C, le numéro de la colonne de la led concernée, L le numéro de la ligne et E l’état: 0 éteinte, 1 allumée. On a C = {0…13}, L = {0…8} et E = {0, 1}.

Voilà donc le code associé; la façon dont il est présenté ne me satisfait pas du tout. Pas évident d’afficher clairement du code avec WordPress…Donc finalement, j’ai trouvé un autre moyen, fournir le code directement dans un fichier texte: Horloge Binaire LoLShield

#include <avr/pgmspace.h>  //AVR library for writing to ROM
#include <Charliplexing.h> //Imports the library, which needs to be
//Initialized in setup.

void setup() {
  LedSign::Init();  //Initializes the screen
}

int seconde = 42;
int minute = 42;
int heure = 11;
int reste_heure,reste_minute, reste_seconde;

void loop() {
 static unsigned long lastTick = 0;

 //Incrémentation des secondes
 if (millis() - lastTick >= 1000) {
   lastTick = millis();
   seconde++;
 }


/*Remise à zéro des variables si celles-ci atteignent ou dépassent 60 pour les minutes et les secondes et 12 pour les heures.*/
 if(seconde >= 60) {
   minute++;
   seconde = 0;
 }

if(minute >= 60) {
 heure++;
 minute = 0;
}

if(heure >= 12) {
 heure = 0;
}

//calcul des leds allumées pour les heures
if(heure/8>=1) {
  LedSign::Set( 1, 5, 1);
  LedSign::Set( 2, 5, 1);
  reste_heure=heure%8;
} else {
  LedSign::Set( 1, 5, 0);
  LedSign::Set( 2, 5, 0);
  reste_heure=heure;
}

 if(reste_heure/4>=1) {
  LedSign::Set( 1, 6, 1);
  LedSign::Set( 2, 6, 1);
  reste_heure=reste_heure%4;
 } else {
  LedSign::Set( 1, 6, 0);
  LedSign::Set( 2, 6, 0);
 }

 if(reste_heure/2>=1) {
  LedSign::Set( 1, 7, 1);
  LedSign::Set( 2, 7, 1);
  reste_heure=reste_heure%2;
 } else {
  LedSign::Set( 1, 7, 0);
  LedSign::Set( 2, 7, 0);
 }

 if(reste_heure/1>=1) {
  LedSign::Set( 1, 8, 1);
  LedSign::Set( 2, 8, 1);
  reste_heure=reste_heure%1;
 } else {
  LedSign::Set( 1, 8, 0);
  LedSign::Set( 2, 8, 0);
 }

//calcul des leds allumées pour les minutes
 if((minute/32)>=1) {
  LedSign::Set( 6, 3, 1);
  LedSign::Set( 7, 3, 1);
  reste_minute=minute%32;
 } else {
  LedSign::Set( 6, 3, 0);
  LedSign::Set( 7, 3, 0);
  reste_minute=minute;
}

 if((reste_minute/16)>=1) {
  LedSign::Set( 6, 4, 1);
  LedSign::Set( 7, 4, 1);
  reste_minute=reste_minute%16;
 } else {
  LedSign::Set( 6, 4, 0);
  LedSign::Set( 7, 4, 0);
 }

 if((reste_minute/8)>=1) {LedSign::Set( 6, 5, 1); LedSign::Set( 7, 5, 1);reste_minute=reste_minute%8;} else {LedSign::Set( 6, 5, 0); LedSign::Set( 7, 5, 0);}

 if((reste_minute/4)>=1) {LedSign::Set( 6, 6, 1); LedSign::Set( 7, 6, 1);reste_minute=reste_minute%4;} else {LedSign::Set( 6, 6, 0); LedSign::Set( 7, 6, 0);}

 if((reste_minute/2)>=1) {LedSign::Set( 6, 7, 1); LedSign::Set( 7, 7, 1);reste_minute=reste_minute%2;} else {LedSign::Set( 6, 7, 0); LedSign::Set( 7, 7, 0);}

 if((reste_minute/1)>=1) {LedSign::Set( 6, 8, 1); LedSign::Set( 7, 8, 1);reste_minute=reste_minute%1;} else {LedSign::Set( 6, 8, 0); LedSign::Set( 7, 8, 0);}




//calcul des leds allumées pour les secondes
 if((seconde/32)>=1) {LedSign::Set( 11, 3, 1); LedSign::Set( 12, 3, 1);reste_seconde=seconde%32;} else {LedSign::Set( 11, 3, 0); LedSign::Set( 12, 3, 0);reste_seconde=seconde;}
 if((reste_seconde/16)>=1) {LedSign::Set( 11, 4, 1); LedSign::Set( 12, 4, 1);reste_seconde=reste_seconde%16;} else {LedSign::Set( 11, 4, 0); LedSign::Set( 12, 4, 0);}
 if((reste_seconde/8)>=1) {LedSign::Set( 11, 5, 1); LedSign::Set( 12, 5, 1);reste_seconde=reste_seconde%8;} else {LedSign::Set( 11, 5, 0); LedSign::Set( 12, 5, 0);}
 if((reste_seconde/4)>=1) {LedSign::Set( 11, 6, 1); LedSign::Set( 12, 6, 1);reste_seconde=reste_seconde%4;} else {LedSign::Set( 11, 6, 0); LedSign::Set( 12, 6, 0);}
 if((reste_seconde/2)>=1) {LedSign::Set( 11, 7, 1); LedSign::Set( 12, 7, 1);reste_seconde=reste_seconde%2;} else {LedSign::Set( 11, 7, 0); LedSign::Set( 12, 7, 0);}
 if((reste_seconde/1)>=1) {LedSign::Set( 11, 8, 1); LedSign::Set( 12, 8, 1);reste_seconde=reste_seconde%1;} else {LedSign::Set( 11, 8, 0); LedSign::Set( 12, 8, 0);}

}

L’Arduino qu’est-ce donc ?

L’Arduino vous n’en avez pas encore entendu parler ? L’Arduino est tout simplement une petite carte bleue de fabrication Italienne, bien sûr elle ne vous permettra pas de payer vos achats dans le magasin du coin, mais c’est ce qui pourra transformer vos projets rêvés en projets concrets.

L’Arduino est une plateforme open-source programmable de petite taille. Qui est basée sur un micro-contrôleur de la famille des « Atmega ». Un IDE est disponible, permettant d’écrire, compiler et transférer des programmes vers la carte. Le but étant de contrôler des entrées et sorties, pour interagir avec le monde extérieur.

Il existe de plus en plus de « shield » en français « bouclier » qui se fixe sur le dessus de la carte. Comme le « Lots of Led Shield »: Lol Shield.

De plus la carte Arduino possède une communauté grandissante d’utilisateur, une plus en plus large gamme de programmes d’exemples, une quantité florissante de livre d’exercice d’application et autre petit montage.

L’Arduino en elle-même n’est pas qu’une seule et unique carte il existe plusieurs versions de cette carte ayant des applications différentes. La « nano », la « pro », « pro-mini », ou encore la « Duemilanove » et aussi la « Uno ». Et la spéciale vêtements la « LilyPad ».

Si ça vous intéresse rendez-vous sur le site officiel: http://www.arduino.cc/

 

Anonymous, doit-on en avoir peur?

Reportage rapide de France 4 qui s’interroge: doit-on avoir peur des Anonymous?

Avec entre autre, l’intervention de Jean-Marc Manach, ce reportage change de ce que l’on peut lire actuellement dans les médias traditionnels qui ont plutôt tendance à diaboliser le mouvement. On notera également la distinction bienvenue entre hacker et pirate.