Computersysteem automatisch vergrendelen: 4 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

In deze zelfstudie gaan we de beveiliging van computerschermvergrendeling onderzoeken. Besturingssystemen hebben een configureerbare time-out die uw scherm vergrendelt als de gebruiker de muis of het toetsenbord niet heeft aangeraakt.

Meestal is de standaardwaarde ongeveer een minuut. Als u deze standaard volgt en uw computer in een drukke omgeving achterlaat, kan iemand binnen die minuut toegang krijgen tot uw computer totdat het scherm wordt vergrendeld. Als je het op een paar seconden zet, krijg je heel vaak het vergrendelscherm als je het toetsenbord niet aanraakt en dat is vervelend…

Op een dag vroeg een collega me of ik dit probleem kon "oplossen" door een soort apparaat dat de computer vergrendelt als hij er niet is, en ik nam de uitdaging aan:)

Ik heb verschillende opties in mijn hoofd onderzocht, zoals het gebruik van arduino's en een infraroodthermometersensor, PIR-sensor of misschien gezichtsdetectie op de computer, maar ik heb gekozen voor een eenvoudigere methode:

We gaan de Arduino Leonardo HID-functionaliteit (toetsenbord emuleren) combineren met een ultrasone afstandssensor om te detecteren of een persoon de computer gebruikt, zo niet, dan stuurt het apparaat een toetsencombinatie via USB om de computer te vergrendelen.

Stap 1: Componenten

Omdat dit een proof of concept is gaan we het apparaat op een breadboard bouwen

Je hebt nodig:

1. Arduino Leonardo (het is belangrijk om Leonardo te gebruiken omdat het toetsenbord kan emuleren)

2. HC-SR04 ultrasone afstandssensor

3. 2 x 10 K variabele weerstanden

4. breadboard, breadboard-draden

5. USB-kabel

6. OLED-scherm (https://www.adafruit.com/product/931)

Stap 2: Montage en uploaden

Controleer eerst of je alle benodigde componenten en een Arduino IDE hebt. Ik ga kort naar de verbindingsstappen, en je kunt altijd een kijkje nemen op het bijgevoegde fritzing-schema

samenkomst

1. Leg de Leonardo op het breadboard en houd hem op zijn plaats met een elastiekje

2. plaats de twee variabele weerstanden, het OLED-display en de ultrasone sensor op het breadboard

3. sluit gronden en vcc's aan

4. sluit de middelste pinnen van de weerstanden aan op de arduino A0 en A1

5. sluit de SDA en SCL van het display aan op de SDA en SCL die op de Leonardo zijn gemarkeerd

6. sluit de trigger- en echo-pin van de ultrasone sensor aan op de 12, 13 digitale pinnen van de Leonardo

7. sluit de USB aan op de computer

Uploaden

Allereerst moet je de benodigde arduino-bibliotheken downloaden en installeren:

1. GOFi2cOLED-bibliotheek:

2. Ultrasonic-HC-SR04-bibliotheek:

Als je niet weet hoe je arduino-bibliotheken moet installeren, bekijk dan deze tutorial.

Nadat je de bovenstaande bibliotheken hebt gedownload en geïnstalleerd, kun je mijn arduino-repository klonen of downloaden die zich hier bevindt: https://github.com/danionescu0/arduino, en we zullen deze schets gebruiken: https://github.com/danionescu0 /arduino/boom/meester…

Of u kunt de onderstaande code kopiëren en plakken:

/* * Bibliotheken gebruikt door dit project: * * 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;

Ultrasoon ultrasoon (12, 13);

const byte afstandPot = A0;

const byte timerPot = A1; const float procentMaxDistanceChangedAllowed = 25; int werkelijkeAfstand; niet-ondertekende lange maxDistanceDetectionTime; bool lockTimerStarted = false;

ongeldige setup()

{ Serieel.begin (9600); Toetsenbord.begin(); initialiseerDisplay(); }

lege lus()

{ clearDisplay(); actualDistance = getActualDistance(); schrijfStatusData(); doDisplay(); if (!lockTimerStarted && shouldEnableLockTimer()) { lockTimerStarted = true; maxDistanceDetectionTime = millis(); Serial.println ("vergrendeltimer begint"); } else if (!shouldEnableLockTimer()){ Serial.println("lock timer uitgeschakeld"); lockTimerStarted = onwaar; } if (shouldLockScreen()) { lockScreen(); Serial.println ("Vergrendelscherm"); } vertraging(100); }

bool shouldLockScreen()

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

bool shouldEnableLockTimer()

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

ongeldig schrijvenStatusData()

{ setDisplayText(1, "MinDistance:", String (getDistance())); setDisplayText(1, "Timer:", String(getTimer())); setDisplayText(1, "ActualDistance:", String (actualDistance)); int countDown = getTimer() - (millis() - maxDistanceDetectionTime) / 1000; Tekenreeksbericht = ""; if (shouldLockScreen()) { message = "vergrendelen verzonden"; } else if (shouldEnableLockTimer() && countDown >= 0) { message = ".." + String (countDown); } else { bericht = "nee"; } setDisplayText(1, "Vergrendelen:", bericht); }

void initializeDisplay()

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

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

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

void doDisplay()

{GOFoled.display(); }

leegte clearDisplay()

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

int getActualDistance()

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

retour afstandSum / 10;

}

int getDistance()

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

int getTimer()

{retourkaart (analogRead (distancePot), 0, 1024, 0, 20); }

void lockScreen()

{ Serial.println("drukken"); Toetsenbord.press(KEY_LEFT_CTRL); vertraging(10); Toetsenbord.press(KEY_LEFT_ALT); vertraging(10); Toetsenbord.write('l'); vertraging(10); Toetsenbord.releaseAll(); }

Sluit ten slotte de arduino aan op de computer met behulp van de usb-kabel en upload de schets naar de arduino.

Stap 3: Het apparaat gebruiken

Wanneer de arduino op de computer is aangesloten, zal deze continu de afstand voor de sensor bewaken en een "vergrendelde" schermtoetscombinatie naar de computer sturen als de afstand groter wordt.

Het apparaat heeft enkele configuraties:

1. Normale afstand, de afstand kan worden geconfigureerd met behulp van de variabele weerstand die is aangesloten op de A0. De afstand wordt ook weergegeven op de OLED. Wanneer de afstand met 25% toeneemt ten opzichte van de ingestelde afstand, begint het aftellen

2. Time-out (aftellen). De time-out in seconden is ook configureerbaar vanaf de weerstand die is aangesloten op de A1. Wanneer de time-out verloopt, wordt het vergrendelingscommando verzonden

3. Toetscombinatie vergrendelen. De standaard vergrendelingstoetscombinatie is ingesteld om te werken voor Ubuntu Linux 18 (CTRL+ALT+L). Om de combinatie te wijzigen, moet u uw schets aanpassen aan uw besturingssysteem:

4. Time-out en afstandsbeveiliging. Omdat dit een apparaat is dat het toetsenbord emuleert, is het een goed idee om een mechanisme te hebben om de toetsenbordfunctionaliteit te deactiveren. In mijn schets heb ik ervoor gekozen dat de time-out en afstand groter moeten zijn dan "1". (je kunt dat desgewenst in de code aanpassen)

Zoek en wijzig de functie "lockScreen()"

void lockScreen(){ Serial.println("drukken"); Toetsenbord.press(KEY_LEFT_CTRL); vertraging(10); Toetsenbord.press(KEY_LEFT_ALT); vertraging(10); Toetsenbord.write('l'); vertraging(10); Toetsenbord.releaseAll(); }

Voor een volledige lijst van speciale Arduino-sleutels, kijk hier:

Stap 4: Andere benaderingen

Vóór deze implementatie heb ik ook enkele andere implementaties overwogen:

1. Infraroodthermometer (MLX90614 https://www.sparkfun.com/products/10740). Een infraroodthermometer is een apparaat dat de temperatuur meet door infraroodstraling te analyseren die wordt uitgezonden door een object op afstand. Ik had er een liggen en ik dacht dat ik misschien het verschil in temperatuur voor de computer kan detecteren.

Ik heb hem aangesloten, maar het temperatuurverschil was erg klein (of ik vooraan zat of niet) 1-2 graden en ik dacht dat het niet zo betrouwbaar kon zijn

2. PIR-sensor. (https://www.sparkfun.com/products/13285) Deze goedkope sensoren worden op de markt gebracht als "bewegingssensoren", maar ze detecteren echt veranderingen in infraroodstraling, dus in theorie zou het kunnen werken, wanneer een persoon de computer verlaat, zou de sensor detecteren dat.. Ook deze sensoren hebben een ingebouwde time-out en gevoeligheidsknoppen. Dus ik heb er een aangesloten en ermee gespeeld, maar het lijkt erop dat de sensor niet gemaakt is voor een korte afstand (hij heeft een groothoek), hij gaf allerlei valse meldingen.

3. Gezichtsdetectie met behulp van de webcam. Deze optie leek erg interessant, omdat ik met dit computerveld speelde in mijn andere projecten zoals: https://github.com/danionescu0/robot-camera-platfo… en https://github.com/danionescu0/image-processing- pr…

Dit was een makkie! Maar er waren enkele nadelen: de laptopcamera kon niet voor andere doeleinden worden gebruikt wanneer het programma draaide, en daarvoor waren enkele computerbronnen nodig. Dus ik heb dit idee ook laten vallen.

Als je meer ideeën hebt over hoe dit kan worden gedaan, deel ze dan, bedankt!