Supprimer les snapshots des mises à jour windows

A exécuter en tant qu’administrateur :

Vssadmin delete shadows /all /quiet

Le lien officiel sur le site Technet de Microsoft : Vssadmin delete shadows




Sommaire

Introduction

Lors du CTF GreHack édition 2016, il y avait une épreuve hardware (Phreak Me) qui consistait à simuler une carte de téléphone. L’épreuve était décomposée en 2 parties de 300 et 200 points avec comme point d’entrée l’article n°48 de phrack sur les cartes de téléphones. La carte à simuler était une carte de téléphone française. Cabine

Le matériel

Nous avions un Arduino - Nano ATMega328 qui s’enfichait sur un support ZIF pour simuler la télécarte.

Lecteur

structure des données et lectures/écritures sur la carte

L’article nous donne plusieurs informations à la fois sur la structure de données et sur la manière de lire et d’écrire sur une carte de téléphone.

extraits de l’article

Memory map / carte française

    I-6) MEMORY MAP of cards from France and Monaco:
	--------------------------------------------

Bytes       Bits      Binary     Hexa

                    +-----------+-----+
  1        1 --> 8  |           |     | ---> Builder code.
                    +-----------+-----+
  2       9 --> 16  | 0000 0011 | $03 | ---> a French telecard
                    +-----------+-----+
  3      17 --> 24  |           |     |
                    +-----------+-----+
  4      25 --> 32  |           |     |
                    +-----------+-----+
  5      33 --> 40  |           |     |
                    +-----------+-----+
  6      41 --> 48  |           |     |
                    +-----------+-----+
  7      49 --> 56  |           |     |
                    +-----------+-----+
  8      57 --> 64  |           |     |
                    +-----------+-----+
  9      65 --> 72  |           |     |
                    +-----------+-----+
 10      73 --> 80  |           |     |
                    +-----------+-----+
 11      81 --> 88  |           |     |
                    +-----------+-----+
 12      33 --> 40  | 0001 0011 | $13 | ---> 120 units card
                    | 0000 0110 | $06 | --->  50 units card
                    | 0000 0101 | $05 | --->  40 units card
                    +-----------+-----+
 13-31  97 --> 248  |           |     | ---> The units area: each time a unit
                    |           |     |      is used, then a bit is set to "1";
                    |           |     |      Generally the first ten units are
                    |           |     |      fused in factory as test.
                    |           |     |
                    |           |     |
                    |           |     |
                    +-----------+-----+
 32    249 --> 256  | 1111 1111 | $FF | ---> the card is empty
                    +-----------+-----+

On notera une petite erreur sur le deuxième 33 –> 40, qui devrait être 89 –> 96.

Diagramme temporel sur les différentes PINS

    I-5) TIME DIAGRAMS:
	---------------

+21V                                     _____________
+5V ____________________________________|             |_________________ Vpp
					:             :
+5V                  ___________________:_____________:_________________ Reset
0V  ________________|                   :             :
		    :                   :             :
+5V     ____        :      ____         :       ______:______
0V  ___|    |_______:_____|    |________:______|      :      |__________ Clock
       :    :       :     :    :        :      :      :      :
+5V    :    :       :     :    :        :______:______:      :           _
0V  ___:____:_______:_____:____:________|      :      |______:__________ R/W
       :    :       :     :    :        :      :      :      :
+5V    :    :       :_____:    :________:      :      :      :__________
0V  XXXXXXXXXXXXXXXXX_____XXXXXX________XXXXXXXXXXXXXXXXXXXXXX__________ Out
       :    :       :     :    :        :<-----><---->:      :
       :    :       :     :    :        :10 to   10 to       :
       :    :       :     :    :        :50 ms   50ms        :
	Reset        Bit 1        Bit2                           Bit 3
	card        reading      reading  Bit2 writing to 1     reading

Extrait du code fourni pour l’épreuve

 1// pinout
 2#define CLK 2
 3#define RST 3
 4#define RW 4
 5#define IO 5
 6
 7void setup() {
 8
 9  pinMode(RW, INPUT);
10  pinMode(CLK, INPUT);
11  pinMode(RST, INPUT);
12  pinMode(IO, OUTPUT);
13
14  attachInterrupt(digitalPinToInterrupt(CLK), intClk, RISING);
15}
16
17void loop() {
18  
19}

Dans la version fournie dans Kali/Debian/Ubuntu (1.0.5) la fonction digitalPinToInterrupt n’existe pas, nous avons remplacé la valeur par 0 (no d’interruption sur la PIN CLK).

300 points : lire la carte

La première partie consistait à lire la carte, nous avons donc dans un premier temps fait une matrice des 32 octets de la carte

+----+----------+
| 55 | 01010101 | > Builder code (valuer bidon mais différente de 0x00)
| 03 | 00000011 | > code correspondant à une carte française
| 78 | 01111000 | \
| 05 | 00000101 | |
| 74 | 01110100 | |
| 22 | 00100010 | |
| A5 | 10100101 |  > valeurs aléatoires 
| B8 | 10111000 | |  pour éviter de mettre des 0x00 ou 0xFF
| 80 | 10000000 | |
| 01 | 00000001 | |
| E7 | 11100111 | /
| 05 | 00000101 | > carte de 40 unités
| FF | 11111111 | \ 10 bits à 1 (tests usine comme indiqué dans la doc) 
| FF | 11111111 | / + 6 bits à 1 correspondant à 6 unités utilisés
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 |
| 00 | 00000000 | > 0x00 la carte n'est pas terminée sinon c'est 0xFF
+----+----------+

on le traduit avec le code suivant :

1char card[] = { 0x55, 
2                0x03, 
3                0x78, 0x05, 0x74, 0x22, (char)0xA5, (char)0xB8, (char)0x80, 0x01, (char)0xE7, 
4                0x05, 
5                (char)0xFF, (char)0xFF, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 0x00, 0x00, 0x00, 0x00, 
6                0x00 
7              };

N.B. : les cast en (char) sont là uniquement pour ne pas avoir de warnings à la compilation.

Dans le code fourni, les événements sont déclenchés sur les fronts montants (RISING) de la clock. La PIN Reset détermine ce qu’on doit faire, si elle est à l’état bas (LOW) cela correspond à un Reset et on envoie sur la PIN IO le premier bit qui sera lu au front montant du Reset (cf Bit 1 reading dans le diagramme temporel) et notre compteur de bits repasse à 1 pour se préparer à envoyer les valeurs suivantes.

Lorsqu’un front montant de la clock arrive, on vérifie si on est en mode Reset ou pas. Si on est en mode Reset on redémarre de zéro et on renvoie le premier bit. Ceci permet de gérer les Reset en plein milieu de la lecture et la carte peut être lue autant de fois que nécessaire. Durant l’épreuve c’était le cas, elle était lue plusieurs fois.

Lorsque l’on n’est pas en mode Reset on envoie tour à tour (sur chaque front montant de la clock) les différents bits et ce jusqu’à 256. Arrivé à 256 on recommence le cycle d’envoi depuis 0.

 1#include <pins_arduino.h>
 2
 3// pinout
 4#define CLK 2
 5#define RST 3
 6#define RW 4
 7#define IO 5
 8
 9char card[] = { 0x55, 
10                0x03, 
11                0x78, 0x05, 0x74, 0x22, (char)0xA5, (char)0xB8, (char)0x80, 0x01, (char)0xE7, 
12                0x05, 
13                (char)0xFF, (char)0xFF, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 0x00, 0x00, 0x00, 0x00, 
14                0x00 
15              };
16
17int count = 0;
18int sending = 0;
19
20
21void sendBit(int count)
22{
23    if(((card[count / 8] >> (7 - (count % 8))) & 0x1) == 0x01)
24    {
25      digitalWrite(IO, HIGH);
26    }
27    else
28    {
29      digitalWrite(IO, LOW);
30    }
31}
32
33
34void intClk() {
35    int reset = digitalRead(RST);
36    int write = digitalRead(RW);
37    
38    if(reset == HIGH)
39    {
40        sendBit(count);
41        count++;
42        if(count >= 256)
43        {
44          count = 0;
45        }
46    }
47    else
48    {
49        sendBit(0);
50        count = 1;
51    }
52}
53
54void setup() {
55
56  pinMode(RW, INPUT);
57  pinMode(CLK, INPUT);
58  pinMode(RST, INPUT);
59  pinMode(IO, OUTPUT);
60
61  attachInterrupt(/*digitalPinToInterrupt(CLK)*/0, intClk, RISING);
62}
63
64void loop() {
65  
66}

A cette phase la carte était lisible, le flag GH16{PhoneHacked} était affiché sur le LCD de la cabine, et nous étions en mesure de passer un appel pour la partie suivante.

200 points : passer un appel

La particularité pour passer un appel c’est que la cabine devait pouvoir “griller” des unités sur la carte. Pour ça il fallait gérer l’écriture dans le micro contrôleur et mémoriser l’état afin de pouvoir le renvoyer à la prochaine lecture de la carte.

A chaque unité utilisée un bit est positionné à 1 à partir du bit no 107.

Pour savoir si la cabine lit ou écrit il faut utiliser la PIN R/W. Si on regarde le diagramme temporel, si Reset est HIGH et R/W est HIGH sur un front montant de la clock alors on écrit 1 en mémoire à l’adresse compteur - 1 (vu que le compteur est déjà positionné sur le bit suivant en vu d’une lecture de la part de la cabine).

Le code suivant valide complètement l’épreuve, et le résultat est donné via de la synthèse vocale à travers le combiné.

 1#include <pins_arduino.h>
 2
 3// pinout
 4#define CLK 2
 5#define RST 3
 6#define RW 4
 7#define IO 5
 8
 9char card[] = { 0x55, 
10                0x03, 
11                0x78, 0x05, 0x74, 0x22, (char)0xA5, (char)0xB8, (char)0x80, 0x01, (char)0xE7, 
12                0x05, 
13                (char)0xFF, (char)0xFF, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, (char)0x00, 0x00, 0x00, 0x00, 0x00, 
14                0x00 
15              };
16
17int count = 0;
18int sending = 0;
19
20
21void sendBit(int count)
22{
23    if(((card[count / 8] >> (7 - (count % 8))) & 0x1) == 0x01)
24    {
25      digitalWrite(IO, HIGH);
26    }
27    else
28    {
29      digitalWrite(IO, LOW);
30    }
31}
32
33void receiveBit(int count)
34{
35    card[count / 8] =  card[count / 8] | (1 << (7 - (count % 8))); 
36}
37
38void intClk() {
39    int reset = digitalRead(RST);
40    int write = digitalRead(RW);
41    
42    if(reset == HIGH)
43    {
44        if(write == HIGH)
45        {
46          receiveBit(count-1);
47        }
48        sendBit(count);
49        count++;
50        if(count >= 256)
51        {
52          count = 0;
53        }
54    }
55    else
56    {
57        sendBit(0);
58        count = 1;
59    }
60}
61
62void setup() {
63
64  pinMode(RW, INPUT);
65  pinMode(CLK, INPUT);
66  pinMode(RST, INPUT);
67  pinMode(IO, OUTPUT);
68
69  attachInterrupt(/*digitalPinToInterrupt(CLK)*/0, intClk, RISING);
70}
71
72void loop() {
73  
74}
75

Conclusion

Un grand merci à Phil pour cette épreuve super intéressante qui nous a pris à deux environ deux bonnes heures à réaliser.

Le Phreak c’est Chic :-).




Le Raspberry Pi comporte un connecteur GPIO permettant de gérer des entrées/sorties avec des composants extérieurs. Ici l’objectif de la manipulation et de voir comment on peut facilement utiliser les (GPIO] en simulant le fonctionnement d’un feu tricolore.

Le matériel

Il faut des composants électroniques comme des résistances (ici 220 ohms, mais 1 kohm serait plus approprié) et des LED des 3 couleurs, une plaque d’expérimentation, et de quoi connecter le tout.

Voici le schéma de câblage de la solution

Schéma

Et une vue réelle de la solution

Vue d'ensemble

Board

GPIO

La partie logicielle

Concernant le système d’exploitation j’utilise la Raspbian (Debian Jessie 8.x), et pour le code la Gem - ruby - pi_piper. Pour faire des tests en ligne de commande il faut installer aussi le package wiringpi qui fournit la commande gpio.

Sous root il faut lancer les commandes suivantes :

apt-get install ruby ruby-ffi ruby-dev wiringpi libssl-dev
gem install pi_piper

A noter que j’ai fait le schéma avec l’outil Fritzing, pour l’installer sur une Ubuntu 14.04, vous devez ajouter le ppa fritzing et installer le package.

Il faut lancer sous root :

apt-add-repository -y ppa:ehbello/fritzing
apt-get update 
apt-get install fritzing fritzing-parts-adafruit

Et voici le code ruby qui permet de simuler les feux. Il y a un mode France et un mode Suisse ;-).

Pour le lancer passer en paramètre le mode comme dans l’exemple ci-dessous :

./traflights france

ou

./traflights suisse

A noter que la méthode releasePort de la classe TrafficLights est un “workaround” pour éviter un plantage du programme. Je capture également le CTRL-C (SIGINT) et j’éteins les LED afin d’éviter qu’elles restent allumées.

  1#!/usr/bin/env ruby
  2
  3require 'pi_piper'
  4include PiPiper
  5
  6class TrafficLights
  7
  8    COLOURS = [:red, :orange, :green]
  9
 10    def initialize(name,red,orange,green)
 11
 12        @name = name
 13        @colours = Hash.new
 14
 15        @colours = Hash.new 
 16        @tmp = { :red => red, :orange => orange, :green => green}
 17
 18        COLOURS.each do |colour|
 19            #puts "gpio -g mode #{@colours[colour]} out"
 20            releasePort(@tmp[colour])
 21        
 22                @colours[colour] = PiPiper::Pin.new(:pin => @tmp[colour].to_i, :direction => :out)
 23        end
 24
 25        reset
 26    end
 27
 28    def on(colour)
 29        @colours[colour].on
 30    end
 31
 32    def off(colour)
 33        @colours[colour].off
 34    end
 35
 36    def test
 37
 38        COLOURS.each do |colour|
 39            puts "#{@name}->#{colour}"
 40            on(colour)
 41            sleep 1
 42            off(colour)
 43
 44        end
 45
 46    end
 47
 48    def reset
 49        COLOURS.each do |colour|
 50            off(colour)
 51        end
 52
 53    end
 54
 55    def releasePort(port)
 56        puts "clean port '#{port}'"
 57        begin
 58            File.open("/sys/class/gpio/unexport", "w") do |f| 
 59                f.write("#{port}")
 60                f.close
 61            end
 62        rescue => e
 63            puts e
 64        end
 65
 66        sleep 0.7
 67    end
 68
 69end
 70
 71class Simulation
 72
 73    SHORT_WAIT = 1
 74    LONG_WAIT = 5
 75
 76    def initialize(tfl1,tfl2)
 77
 78        @tfl1 = tfl1
 79        @tfl2 = tfl2
 80        Signal.trap("SIGINT") do
 81            stop
 82        end
 83
 84    end
 85
 86
 87    def simulate(mode)
 88
 89        case mode
 90
 91        when :france
 92
 93            france
 94
 95        when :suisse
 96
 97            suisse
 98
 99        end
100
101    end
102
103    def stop
104
105        @tfl1.reset
106        @tfl2.reset
107        exit 0
108
109    end
110
111    private
112
113    def france
114        while true
115            @tfl1.on(:red)
116            sleep(SHORT_WAIT)
117            @tfl2.off(:red)
118            @tfl2.on(:green)
119            sleep(LONG_WAIT)
120            @tfl2.off(:green)
121            @tfl2.on(:orange)
122            sleep(SHORT_WAIT)
123            @tfl2.off(:orange)
124            @tfl2.on(:red)
125            sleep(SHORT_WAIT)
126            @tfl1.off(:red)
127            @tfl1.on(:green)
128            sleep(LONG_WAIT)
129            @tfl1.off(:green)
130            @tfl1.on(:orange)
131            sleep(SHORT_WAIT)
132            @tfl1.off(:orange)
133        end
134    end
135
136    def suisse
137        while true
138            @tfl1.on(:red)
139            sleep(SHORT_WAIT)
140            @tfl2.on(:orange)
141            @tfl2.on(:red)
142            sleep(SHORT_WAIT)
143            @tfl2.off(:red)
144            @tfl2.off(:orange)
145            @tfl2.on(:green)
146            sleep(LONG_WAIT)
147            @tfl2.off(:green)
148            @tfl2.on(:orange)
149            sleep(SHORT_WAIT)
150            @tfl2.off(:orange)
151            @tfl2.on(:red)
152            sleep(SHORT_WAIT)
153            @tfl1.on(:orange)
154            @tfl1.on(:red)
155            sleep(SHORT_WAIT)
156            @tfl1.off(:red)
157            @tfl1.off(:orange)
158            @tfl1.on(:green)
159            sleep(LONG_WAIT)
160            @tfl1.off(:green)
161            @tfl1.on(:orange)
162            sleep(SHORT_WAIT)
163            @tfl1.off(:orange)
164        end
165    end
166
167end
168
169sim = Simulation.new(TrafficLights.new("tfl 1",18,23,24),TrafficLights.new("tfl 2",22,4,17))
170sim.simulate(ARGV.shift.to_sym)


Other articles