Système informatique à verrouillage automatique : 4 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Dans ce didacticiel, nous allons explorer la sécurité du verrouillage de l'écran de l'ordinateur. Les systèmes d'exploitation ont un délai d'attente configurable qui verrouillera votre écran si l'utilisateur n'a pas touché la souris ou le clavier.

La valeur par défaut est généralement d'environ une minute. Si vous suivez cette valeur par défaut et laissez votre ordinateur dans un environnement occupé, quelqu'un pourrait accéder à votre ordinateur dans cette minute jusqu'à ce que l'écran se verrouille. Si vous le réglez sur quelques secondes, vous obtiendrez l'écran de verrouillage très souvent lorsque vous ne touchez pas le clavier et c'est ennuyeux…

Un jour, un collègue de travail m'a demandé si je pouvais "réparer" ce problème avec une sorte de dispositif qui verrouille l'ordinateur quand il n'est pas là, et j'ai relevé le défi:)

J'ai exploré plusieurs options dans ma tête, comme utiliser des arduinos et un capteur de thermomètre infrarouge, un capteur PIR ou peut-être utiliser la détection de visage sur l'ordinateur, mais j'ai opté pour une méthode plus simple:

Nous allons combiner la fonctionnalité Arduino Leonardo HID (émuler le clavier) avec un capteur de distance à ultrasons pour détecter si une personne utilise l'ordinateur, sinon l'appareil enverra une combinaison de touches via USB pour verrouiller l'ordinateur.

Étape 1: Composants

Parce qu'il s'agit d'une preuve de concept, nous allons construire l'appareil sur une maquette

Tu auras besoin:

1. Arduino Leonardo (il est important d'utiliser Leonardo car il peut émuler le clavier)

2. Capteur de distance à ultrasons HC-SR04

3. 2 résistances variables de 10 K

4. planche à pain, fils de planche à pain

5. Câble USB

6. Écran OLED (https://www.adafruit.com/product/931)

Étape 2: Assemblage et téléchargement

Vérifiez d'abord si vous avez tous les composants nécessaires et un IDE Arduino. Je vais brièvement passer aux étapes de connexion, et vous pouvez toujours jeter un œil sur le schéma fritzing ci-joint

Assemblée

1. Placez le Leonardo sur la planche à pain et maintenez-le en place avec un élastique

2. placez les deux résistances variables, l'écran OLED et le capteur à ultrasons sur la planche à pain

3. connecter les masses et les vcc

4. connectez les broches du milieu des résistances aux arduino A0 et A1

5. connectez le SDA et le SCL de l'écran au SDA et au SCL marqués sur le Leonardo

6. connectez le déclencheur et la broche d'écho du capteur à ultrasons aux 12, 13 broches numériques du Leonardo

7. connectez l'USB à l'ordinateur

Télécharger

Tout d'abord, vous devez télécharger et installer les bibliothèques arduino nécessaires:

1. Bibliothèque GOFi2cOLED:

2. Bibliothèque Ultrasonic-HC-SR04:

Si vous ne savez pas comment installer les bibliothèques arduino, consultez ce tutoriel.

Après avoir téléchargé et installé les bibliothèques ci-dessus, vous pouvez cloner ou télécharger mon référentiel arduino situé ici: https://github.com/danionescu0/arduino, et nous utiliserons ce croquis: https://github.com/danionescu0 /arduino/arbre/maître…

Ou vous pouvez copier et coller le code ci-dessous:

/* * Bibliothèques utilisées par ce projet: * * GOFi2cOLED: https://github.com/hramrach/GOFi2cOLED * Ultrasonic-HC-SR04: https://github.com/JRodrigoTech/Ultrasonic-HC-SR04 */ #include "Keyboard.h" #include "Wire.h" #include "GOFi2cOLED.h" #include "Ultrasonic.h"

GOFi2cOLED GOFoled;

Ultrasons ultrasons (12, 13);

octet const distancePot = A0;

octet const timerPot = A1; const float percentMaxDistanceChangedAllowed = 25; int réelleDistance; maxDistanceDetectionTime long non signé; bool lockTimerStarted = false;

void setup()

{ Serial.begin(9600); Keyboard.begin(); initializeDisplay(); }

boucle vide()

{ clearAffichage(); réelleDistance = getActualDistance(); writeStatusData(); faireAffiche(); if (!lockTimerStarted && shouldEnableLockTimer()) { lockTimerStarted = true; maxDistanceDetectionTime = millis(); Serial.println("lock timer begin"); } else if (!shouldEnableLockTimer()){ Serial.println("lock timer disabled"); lockTimerStarted = false; } if (devraitLockScreen()) { lockScreen(); Serial.println("Écran de verrouillage"); } retard (100); }

bool shouldLockScreen()

{ return lockTimerStarted && (millis() - maxDistanceDetectionTime) / 1000 > getTimer(); }

bool devraitEnableLockTimer()

{ int AllowDistance = percentMaxDistanceChangedAllowed / 100 * getDistance(); return getTimer() > 1 && getDistance() > 1 && actualDistance - getDistance() > allowDistance; }

void writeStatusData()

{ setDisplayText(1, "MinDistance:", String(getDistance())); setDisplayText(1, "Timer:", String(getTimer())); setDisplayText(1, "ActualDistance:", String(actualDistance)); int countDown = getTimer() - (millis() - maxDistanceDetectionTime) / 1000; Message de chaîne = ""; if (shouldLockScreen()) { message = "verrou envoyé"; } else if (shouldEnableLockTimer() && countDown >= 0) { message = ".." + String(countDown); } else { message = "non"; } setDisplayText(1, "Verrouillage: ", message); }

void initializeDisplay()

{ GOFoled.init(0x3C); GOFoled.clearDisplay(); GOFoled.setCursor(0, 0); }

void setDisplayText(byte fontSize, String label, String data)

{ GOFoled.setTextSize(fontSize); GOFoled.println(label + ":" + data); }

void doDisplay()

{ GOFoled.display(); }

void clearDisplay()

{ GOFoled.clearDisplay(); GOFoled.setCursor(0, 0); }

int getDistanceActuelle()

{ int distanceSomme = 0; for (byte i=0;i<10;i++) { distanceSum += ultrasonic. Ranging(CM); }

retour distanceSomme / 10;

}

int getDistance()

{ return map(analogRead(timerPot), 0, 1024, 0, 200); }

int getTimer()

{ return map(analogRead(distancePot), 0, 1024, 0, 20); }

void lockScreen()

{ Serial.println("en appuyant"); Keyboard.press(KEY_LEFT_CTRL); retard(10); Keyboard.press(KEY_LEFT_ALT); retard(10); Keyboard.write('l'); retard(10); Keyboard.releaseAll(); }

Enfin, connectez l'arduino à l'ordinateur à l'aide du câble USB et téléchargez le croquis dans l'arduino.

Étape 3: Utilisation de l'appareil

Lorsque l'arduino est connecté à l'ordinateur, il surveillera en permanence la distance devant le capteur et enverra une combinaison de touches d'écran "verrouillé" à l'ordinateur si la distance augmente.

L'appareil a quelques configurations:

1. Distance normale, la distance peut être configurée à l'aide de la résistance variable connectée à l'A0. La distance est également affichée sur l'OLED. Lorsque la distance augmentera de 25% par rapport à celle définie, un compte à rebours commencera

2. Délai d'attente (compte à rebours). Le timeout en secondes est également configurable à partir de la résistance connectée à l'A1. Lorsque le délai expire, la commande de verrouillage sera envoyée

3. Verrouiller la combinaison de touches. La combinaison de touches de verrouillage par défaut est configurée pour fonctionner pour Ubuntu Linux 18 (CTRL+ALT+L). Pour changer la combinaison, vous devez modifier votre croquis en fonction de votre système d'exploitation:

4. Temporisation et protection de distance. Parce qu'il s'agit d'un appareil qui émule le clavier, c'est une bonne idée d'avoir un mécanisme de désactivation de la fonctionnalité du clavier. Dans mon croquis, j'ai choisi que le délai d'attente et la distance doivent être supérieurs à "1". (vous pouvez modifier cela dans le code si vous le souhaitez)

Localisez et modifiez la fonction "lockScreen()"

void lockScreen(){ Serial.println("appuyer"); Keyboard.press(KEY_LEFT_CTRL); retard(10); Keyboard.press(KEY_LEFT_ALT); retard(10); Keyboard.write('l'); retard(10); Keyboard.releaseAll(); }

Pour une liste complète des touches spéciales arduino, consultez ici:

Étape 4: Autres approches

Avant cette implémentation, j'ai également envisagé d'autres implémentations:

1. Thermomètre infrarouge (MLX90614 https://www.sparkfun.com/products/10740). Un thermomètre infrarouge est un appareil qui mesure la température en analysant les rayonnements infrarouges émis par un objet à distance. J'en avais un qui traînait et j'ai pensé que je pourrais peut-être détecter la différence de température devant l'ordinateur.

Je l'ai branché, mais la différence de température était très faible (quand j'étais devant ou pas) 1-2 degrés et je pensais que ça ne pouvait pas être aussi fiable

2. Capteur PIR. (https://www.sparkfun.com/products/13285) Ces capteurs bon marché sont commercialisés sous le nom de "capteurs de mouvement", mais ils détectent vraiment les changements de rayonnement infrarouge, donc en théorie, cela pourrait fonctionner, lorsqu'une personne quitte l'ordinateur, le capteur détecterait que.. De plus, ces capteurs ont des boutons de temporisation et de sensibilité intégrés. J'en ai donc branché un et j'ai joué avec, mais il semble que le capteur ne soit pas fait pour une courte portée (il a un grand angle), il a donné toutes sortes de fausses alertes.

3. Détection de visage à l'aide de la webcam. Cette option m'a semblé très intéressante, car j'ai joué avec ce champ informatique dans mes autres projets comme: https://github.com/danionescu0/robot-camera-platfo… et https://github.com/danionescu0/image-processing- pr…

C'était du gâteau ! Mais il y avait quelques inconvénients: la caméra de l'ordinateur portable ne pouvait pas être utilisée à d'autres fins lorsque le programme était en cours d'exécution, et certaines ressources informatiques seraient nécessaires pour cela. J'ai donc abandonné cette idée aussi.

Si vous avez plus d'idées sur la façon dont cela pourrait être fait, partagez-les, merci!