ibd ഫയലിന്റെ ബൈറ്റ്-ബൈ-ബൈറ്റ് വിശകലനം ഉപയോഗിച്ച് ഒരു ഘടനാ ഫയലില്ലാതെ XtraDB പട്ടികകളിൽ നിന്ന് ഡാറ്റ വീണ്ടെടുക്കുന്നു

ചരിത്രാതീതകാലം

ഒരു ransomware വൈറസ് സെർവറിനെ ആക്രമിച്ചു, അത് “ഭാഗ്യകരമായ ഒരു അപകടത്താൽ” .ibd ഫയലുകളെ (innodb ടേബിളുകളുടെ റോ ഡാറ്റ ഫയലുകൾ) ഭാഗികമായി സ്പർശിക്കാതെ വിട്ടു, എന്നാൽ അതേ സമയം .fpm ഫയലുകൾ പൂർണ്ണമായും എൻക്രിപ്റ്റ് ചെയ്തു ( ഘടന ഫയലുകൾ). ഈ സാഹചര്യത്തിൽ, .idb-യെ ഇങ്ങനെ വിഭജിക്കാം:

• സ്റ്റാൻഡേർഡ് ടൂളുകളും ഗൈഡുകളും വഴി പുനഃസ്ഥാപിക്കുന്നതിന് വിധേയമാണ്. അത്തരം സന്ദർഭങ്ങളിൽ, ഒരു മികച്ച ഉണ്ട് ആയിത്തീരുന്നു;
• ഭാഗികമായി എൻക്രിപ്റ്റ് ചെയ്ത പട്ടികകൾ. കൂടുതലും ഇവ വലിയ ടേബിളുകളാണ്, (ഞാൻ മനസ്സിലാക്കിയതുപോലെ) ആക്രമണകാരികൾക്ക് പൂർണ്ണ എൻക്രിപ്ഷനായി മതിയായ റാം ഇല്ലായിരുന്നു;
• ശരി, പുനഃസ്ഥാപിക്കാൻ കഴിയാത്ത പൂർണ്ണമായും എൻക്രിപ്റ്റ് ചെയ്ത പട്ടികകൾ.

ആവശ്യമുള്ള എൻകോഡിംഗിന് കീഴിൽ ഏതെങ്കിലും ടെക്സ്റ്റ് എഡിറ്ററിൽ തുറന്ന് (എന്റെ കാര്യത്തിൽ ഇത് UTF8 ആണ്) കൂടാതെ ടെക്സ്റ്റ് ഫീൽഡുകളുടെ സാന്നിധ്യത്തിനായി ഫയൽ കാണുന്നതിലൂടെയും പട്ടികകൾ ഏത് ഓപ്ഷനാണ് എന്ന് നിർണ്ണയിക്കാൻ സാധിച്ചു, ഉദാഹരണത്തിന്:

കൂടാതെ, ഫയലിന്റെ തുടക്കത്തിൽ നിങ്ങൾക്ക് ധാരാളം 0 ബൈറ്റുകൾ നിരീക്ഷിക്കാൻ കഴിയും, കൂടാതെ ബ്ലോക്ക് എൻക്രിപ്ഷൻ അൽഗോരിതം (ഏറ്റവും സാധാരണമായത്) ഉപയോഗിക്കുന്ന വൈറസുകൾ സാധാരണയായി അവയെയും ബാധിക്കും.

എന്റെ കാര്യത്തിൽ, ആക്രമണകാരികൾ ഓരോ എൻക്രിപ്റ്റ് ചെയ്ത ഫയലിന്റെയും അവസാനം ഒരു 4-ബൈറ്റ് സ്ട്രിംഗ് (1, 0, 0, 0) ഉപേക്ഷിച്ചു, ഇത് ചുമതല ലളിതമാക്കി. ബാധിക്കാത്ത ഫയലുകൾക്കായി തിരയാൻ, സ്ക്രിപ്റ്റ് മതിയായിരുന്നു:

def opened(path):
    files = os.listdir(path)
    for f in files:
        if os.path.isfile(path + f):
            yield path + f

for full_path in opened("C:somepath"):
    file = open(full_path, "rb")
    last_string = ""
    for line in file:
        last_string = line
        file.close()
    if (last_string[len(last_string) -4:len(last_string)]) != (1, 0, 0, 0):
        print(full_path)

അങ്ങനെ, ആദ്യ തരത്തിൽ പെട്ട ഫയലുകൾ കണ്ടെത്താനായി. രണ്ടാമത്തേതിൽ ധാരാളം മാനുവൽ ജോലികൾ ഉൾപ്പെടുന്നു, പക്ഷേ കണ്ടെത്തിയവ ഇതിനകം മതിയായിരുന്നു. എല്ലാം ശരിയാകും, പക്ഷേ നിങ്ങൾ അറിയേണ്ടതുണ്ട് തികച്ചും കൃത്യമായ ഘടന കൂടാതെ (തീർച്ചയായും) എനിക്ക് പതിവായി മാറുന്ന ടേബിളിൽ പ്രവർത്തിക്കേണ്ടി വന്ന ഒരു കേസ് ഉയർന്നു. ഫീൽഡ് തരം മാറ്റിയതോ പുതിയ കോളം ചേർത്തതോ ആരും ഓർത്തില്ല.

വൈൽഡ്സ് സിറ്റി, നിർഭാഗ്യവശാൽ, അത്തരമൊരു കേസിൽ സഹായിക്കാൻ കഴിഞ്ഞില്ല, അതിനാലാണ് ഈ ലേഖനം എഴുതുന്നത്.

കാര്യത്തിലേക്ക് വരൂ

3 മാസം മുമ്പുള്ള ഒരു ടേബിളിന്റെ ഘടനയുണ്ട്, അത് നിലവിലുള്ളവയുമായി പൊരുത്തപ്പെടുന്നില്ല (ഒരുപക്ഷേ ഒരു ഫീൽഡ്, ഒരുപക്ഷേ കൂടുതൽ). പട്ടിക ഘടന:

CREATE TABLE `table_1` (
    `id` INT (11),
    `date` DATETIME ,
    `description` TEXT ,
    `id_point` INT (11),
    `id_user` INT (11),
    `date_start` DATETIME ,
    `date_finish` DATETIME ,
    `photo` INT (1),
    `id_client` INT (11),
    `status` INT (1),
    `lead__time` TIME ,
    `sendstatus` TINYINT (4)
); 

ഈ സാഹചര്യത്തിൽ, നിങ്ങൾ വേർതിരിച്ചെടുക്കേണ്ടതുണ്ട്:

• id_point int (11);
• id_user int (11);
• date_start തീയതി സമയം;
• date_finish തീയതി സമയം.

വീണ്ടെടുക്കലിനായി, .ibd ഫയലിന്റെ ബൈറ്റ്-ബൈ-ബൈറ്റ് വിശകലനം ഉപയോഗിക്കുന്നു, തുടർന്ന് അവയെ കൂടുതൽ വായിക്കാനാകുന്ന രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു. ഞങ്ങൾക്ക് ആവശ്യമുള്ളത് കണ്ടെത്തുന്നതിന്, ഇൻറ്റ്, ഡാറ്റാ ടൈം എന്നിവ പോലുള്ള ഡാറ്റ തരങ്ങൾ മാത്രമേ ഞങ്ങൾ വിശകലനം ചെയ്യേണ്ടതുള്ളൂ, ലേഖനം അവ മാത്രമേ വിവരിക്കുന്നുള്ളൂ, എന്നാൽ ചിലപ്പോൾ ഞങ്ങൾ മറ്റ് സമാന സംഭവങ്ങളിൽ സഹായിക്കുന്ന മറ്റ് ഡാറ്റ തരങ്ങളെയും പരാമർശിക്കും.

പ്രശ്നം 1: DATETIME, TEXT എന്നീ തരങ്ങളുള്ള ഫീൽഡുകൾക്ക് NULL മൂല്യങ്ങൾ ഉണ്ടായിരുന്നു, അവ ഫയലിൽ ഒഴിവാക്കിയിരിക്കുന്നു, ഇക്കാരണത്താൽ, എന്റെ കാര്യത്തിൽ പുനഃസ്ഥാപിക്കുന്നതിനുള്ള ഘടന നിർണ്ണയിക്കാൻ കഴിഞ്ഞില്ല. പുതിയ കോളങ്ങളിൽ, ഡിഫോൾട്ട് മൂല്യം അസാധുവാണ്, കൂടാതെ innodb_flush_log_at_trx_commit = 0 എന്ന ക്രമീകരണം കാരണം ഇടപാടിന്റെ ഒരു ഭാഗം നഷ്‌ടപ്പെടാം, അതിനാൽ ഘടന നിർണ്ണയിക്കാൻ അധിക സമയം ചെലവഴിക്കേണ്ടിവരും.

പ്രശ്നം 2: DELETE വഴി ഇല്ലാതാക്കിയ വരികൾ എല്ലാം ibd ഫയലിലായിരിക്കുമെന്നത് കണക്കിലെടുക്കേണ്ടതാണ്, എന്നാൽ ALTER TABLE ഉപയോഗിച്ച് അവയുടെ ഘടന അപ്ഡേറ്റ് ചെയ്യപ്പെടില്ല. തൽഫലമായി, ഫയലിന്റെ തുടക്കം മുതൽ അവസാനം വരെ ഡാറ്റ ഘടന വ്യത്യാസപ്പെടാം. നിങ്ങൾ പലപ്പോഴും ഒപ്റ്റിമൈസ് ടേബിൾ ഉപയോഗിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് അത്തരമൊരു പ്രശ്നം നേരിടാൻ സാധ്യതയില്ല.

ശ്രദ്ധിക്കുക, DBMS പതിപ്പ് ഡാറ്റ സംഭരിക്കുന്ന രീതിയെ ബാധിക്കുന്നു, മറ്റ് പ്രധാന പതിപ്പുകൾക്ക് ഈ ഉദാഹരണം പ്രവർത്തിച്ചേക്കില്ല. എന്റെ കാര്യത്തിൽ, mariadb 10.1.24-ന്റെ വിൻഡോസ് പതിപ്പ് ഉപയോഗിച്ചു. കൂടാതെ, mariadb-ൽ നിങ്ങൾ InnoDB ടേബിളുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നുണ്ടെങ്കിലും, വാസ്തവത്തിൽ അവയാണ് എക്‌സ്ട്രാഡിബി, ഇത് InnoDB mysql ഉപയോഗിച്ചുള്ള രീതിയുടെ പ്രയോഗക്ഷമത ഒഴിവാക്കുന്നു.

ഫയൽ വിശകലനം

പൈത്തണിൽ, ഡാറ്റ തരം ബൈറ്റുകൾ() ഒരു സാധാരണ സംഖ്യകളുടെ സ്ഥാനത്ത് യൂണികോഡ് ഡാറ്റ പ്രദർശിപ്പിക്കുന്നു. നിങ്ങൾക്ക് ഈ ഫോമിൽ ഫയൽ കാണാൻ കഴിയുമെങ്കിലും, സൗകര്യാർത്ഥം ബൈറ്റ് അറേയെ ഒരു സാധാരണ അറേയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിലൂടെ നിങ്ങൾക്ക് ബൈറ്റുകളെ സംഖ്യാ രൂപത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ കഴിയും (list(example_byte_array)). ഏത് സാഹചര്യത്തിലും, രണ്ട് രീതികളും വിശകലനത്തിന് അനുയോജ്യമാണ്.

നിരവധി ibd ഫയലുകൾ പരിശോധിച്ച ശേഷം, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ കണ്ടെത്താനാകും:

മാത്രമല്ല, ഈ കീവേഡുകൾ ഉപയോഗിച്ച് നിങ്ങൾ ഫയലിനെ വിഭജിക്കുകയാണെങ്കിൽ, നിങ്ങൾക്ക് മിക്കവാറും ഡാറ്റ ബ്ലോക്കുകൾ പോലും ലഭിക്കും. ഞങ്ങൾ ഇൻഫിമം ഒരു വിഭജനമായി ഉപയോഗിക്കും.

table = table.split("infimum".encode())

രസകരമായ ഒരു നിരീക്ഷണം: കുറഞ്ഞ അളവിലുള്ള ഡാറ്റയുള്ള പട്ടികകൾക്കായി, ഇൻഫിമത്തിനും സുപ്രീമത്തിനും ഇടയിൽ ബ്ലോക്കിലെ വരികളുടെ എണ്ണത്തിലേക്ക് ഒരു പോയിന്റർ ഉണ്ട്.

- 1st വരിയുള്ള ടെസ്റ്റ് ടേബിൾ

- 2 വരികളുള്ള ടെസ്റ്റ് ടേബിൾ

വരി അറേ പട്ടിക[0] ഒഴിവാക്കാം. അത് പരിശോധിച്ചതിന് ശേഷം, എനിക്ക് ഇപ്പോഴും റോ ടേബിൾ ഡാറ്റ കണ്ടെത്താൻ കഴിഞ്ഞില്ല. മിക്കവാറും, സൂചികകളും കീകളും സംഭരിക്കുന്നതിന് ഈ ബ്ലോക്ക് ഉപയോഗിക്കുന്നു.
പട്ടിക[1] മുതൽ ഒരു സംഖ്യാ ശ്രേണിയിലേക്ക് വിവർത്തനം ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് ഇതിനകം ചില പാറ്റേണുകൾ ശ്രദ്ധിക്കാനാകും, അതായത്:

ഇവ ഒരു സ്ട്രിംഗിൽ സംഭരിച്ചിരിക്കുന്ന int മൂല്യങ്ങളാണ്. ആദ്യത്തെ ബൈറ്റ് നമ്പർ പോസിറ്റീവ് ആണോ നെഗറ്റീവ് ആണോ എന്ന് സൂചിപ്പിക്കുന്നു. എന്റെ കാര്യത്തിൽ, എല്ലാ നമ്പറുകളും പോസിറ്റീവ് ആണ്. ശേഷിക്കുന്ന 3 ബൈറ്റുകളിൽ നിന്ന്, ഇനിപ്പറയുന്ന ഫംഗ്ഷൻ ഉപയോഗിച്ച് നിങ്ങൾക്ക് നമ്പർ നിർണ്ണയിക്കാനാകും. സ്ക്രിപ്റ്റ്:

def find_int(val: str):  # example '128, 1, 2, 3'
    val = [int(v) for v in  val.split(", ")]
    result_int = val[1]*256**2 + val[2]*256*1 + val[3]
    return result_int

ഉദാഹരണത്തിന്, 128, 0, 0, 1 = 1, അല്ലെങ്കിൽ 128, 0, 75, 108 = 19308.
പട്ടികയ്ക്ക് സ്വയമേവ വർദ്ധനവുള്ള ഒരു പ്രാഥമിക കീ ഉണ്ടായിരുന്നു, അത് ഇവിടെയും കാണാം

ടെസ്റ്റ് ടേബിളുകളിൽ നിന്നുള്ള ഡാറ്റ താരതമ്യം ചെയ്തപ്പോൾ, DATETIME ഒബ്‌ജക്‌റ്റിൽ 5 ബൈറ്റുകൾ അടങ്ങിയിട്ടുണ്ടെന്നും 153-ൽ ആരംഭിച്ചതായും (ഏറ്റവും സാധ്യത വാർഷിക ഇടവേളകളെ സൂചിപ്പിക്കുന്നു) വെളിപ്പെട്ടു. DATTIME ശ്രേണി '1000-01-01' മുതൽ '9999-12-31' വരെയുള്ളതിനാൽ, ബൈറ്റുകളുടെ എണ്ണം വ്യത്യാസപ്പെടാമെന്ന് ഞാൻ കരുതുന്നു, എന്നാൽ എന്റെ കാര്യത്തിൽ, ഡാറ്റ 2016 മുതൽ 2019 വരെയുള്ള കാലയളവിലാണ് വരുന്നത്, അതിനാൽ ഞങ്ങൾ അനുമാനിക്കും 5 ബൈറ്റുകൾ മതി.

സെക്കൻഡുകൾ ഇല്ലാതെ സമയം നിർണ്ണയിക്കാൻ, ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ എഴുതിയിരിക്കുന്നു. സ്ക്രിപ്റ്റ്:

day_ = lambda x: x % 64 // 2  # {x,x,X,x,x }

def hour_(x1, x2):  # {x,x,X1,X2,x}
    if x1 % 2 == 0:
        return x2 // 16
    elif x1 % 2 == 1:
        return x2 // 16 + 16
    else:
        raise ValueError

min_ = lambda x1, x2: (x1 % 16) * 4 + (x2 // 64)  # {x,x,x,X1,X2}

വർഷത്തിനും മാസത്തിനും ഒരു ഫങ്ഷണൽ ഫംഗ്‌ഷൻ എഴുതാൻ കഴിയാത്തതിനാൽ എനിക്ക് അത് ഹാക്ക് ചെയ്യേണ്ടിവന്നു. സ്ക്രിപ്റ്റ്:

ym_list = {'2016, 1': '153, 152, 64', '2016, 2': '153, 152, 128', 
           '2016, 3': '153, 152, 192', '2016, 4': '153, 153, 0',
           '2016, 5': '153, 153, 64', '2016, 6': '153, 153, 128', 
           '2016, 7': '153, 153, 192', '2016, 8': '153, 154, 0', 
           '2016, 9': '153, 154, 64', '2016, 10': '153, 154, 128', 
           '2016, 11': '153, 154, 192', '2016, 12': '153, 155, 0',
           '2017, 1': '153, 155, 128', '2017, 2': '153, 155, 192', 
           '2017, 3': '153, 156, 0', '2017, 4': '153, 156, 64',
           '2017, 5': '153, 156, 128', '2017, 6': '153, 156, 192',
           '2017, 7': '153, 157, 0', '2017, 8': '153, 157, 64',
           '2017, 9': '153, 157, 128', '2017, 10': '153, 157, 192', 
           '2017, 11': '153, 158, 0', '2017, 12': '153, 158, 64', 
           '2018, 1': '153, 158, 192', '2018, 2': '153, 159, 0',
           '2018, 3': '153, 159, 64', '2018, 4': '153, 159, 128', 
           '2018, 5': '153, 159, 192', '2018, 6': '153, 160, 0',
           '2018, 7': '153, 160, 64', '2018, 8': '153, 160, 128',
           '2018, 9': '153, 160, 192', '2018, 10': '153, 161, 0', 
           '2018, 11': '153, 161, 64', '2018, 12': '153, 161, 128',
           '2019, 1': '153, 162, 0', '2019, 2': '153, 162, 64', 
           '2019, 3': '153, 162, 128', '2019, 4': '153, 162, 192', 
           '2019, 5': '153, 163, 0', '2019, 6': '153, 163, 64',
           '2019, 7': '153, 163, 128', '2019, 8': '153, 163, 192',
           '2019, 9': '153, 164, 0', '2019, 10': '153, 164, 64', 
           '2019, 11': '153, 164, 128', '2019, 12': '153, 164, 192',
           '2020, 1': '153, 165, 64', '2020, 2': '153, 165, 128',
           '2020, 3': '153, 165, 192','2020, 4': '153, 166, 0', 
           '2020, 5': '153, 166, 64', '2020, 6': '153, 1, 128',
           '2020, 7': '153, 166, 192', '2020, 8': '153, 167, 0', 
           '2020, 9': '153, 167, 64','2020, 10': '153, 167, 128',
           '2020, 11': '153, 167, 192', '2020, 12': '153, 168, 0'}

def year_month(x1, x2):  # {x,X,X,x,x }

    for key, value in ym_list.items():
        key = [int(k) for k in key.replace("'", "").split(", ")]
        value = [int(v) for v in value.split(", ")]
        if x1 == value[1] and x2 // 64 == value[2] // 64:
            return key
    return 0, 0

നിങ്ങൾ കുറച്ച് സമയം ചിലവഴിച്ചാൽ ഈ തെറ്റിദ്ധാരണ തിരുത്താൻ കഴിയുമെന്ന് എനിക്ക് ഉറപ്പുണ്ട്.
അടുത്തതായി, ഒരു സ്ട്രിംഗിൽ നിന്ന് ഒരു ഡേറ്റ്ടൈം ഒബ്‌ജക്റ്റ് നൽകുന്ന ഒരു ഫംഗ്‌ഷൻ. സ്ക്രിപ്റ്റ്:

def find_data_time(val:str):
    val = [int(v) for v in val.split(", ")]
    day = day_(val[2])
    hour = hour_(val[2], val[3])
    minutes = min_(val[3], val[4])
    year, month = year_month(val[1], val[2])
    return datetime(year, month, day, hour, minutes)

int, int, datetime, datetime എന്നിവയിൽ നിന്ന് പതിവായി ആവർത്തിച്ചുള്ള മൂല്യങ്ങൾ കണ്ടെത്താൻ നിയന്ത്രിക്കുന്നു , ഇതാണ് നിങ്ങൾക്ക് വേണ്ടതെന്ന് തോന്നുന്നു. മാത്രമല്ല, അത്തരമൊരു ക്രമം ഒരു വരിയിൽ രണ്ടുതവണ ആവർത്തിക്കില്ല.

ഒരു സാധാരണ എക്സ്പ്രഷൻ ഉപയോഗിച്ച്, ആവശ്യമായ ഡാറ്റ ഞങ്ങൾ കണ്ടെത്തുന്നു:

fined = re.findall(r'128, d*, d*, d*, 128, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*, 153, 1[6,5,4,3]d, d*, d*, d*', int_array)

ഈ എക്സ്പ്രഷൻ ഉപയോഗിച്ച് തിരയുമ്പോൾ, ആവശ്യമുള്ള ഫീൽഡുകളിൽ NULL മൂല്യങ്ങൾ നിർണ്ണയിക്കാൻ കഴിയില്ല, എന്നാൽ എന്റെ കാര്യത്തിൽ ഇത് നിർണായകമല്ല. അപ്പോൾ നമ്മൾ ഒരു ലൂപ്പിൽ കണ്ടെത്തിയ കാര്യങ്ങളിലൂടെ കടന്നുപോകുന്നു. സ്ക്രിപ്റ്റ്:

result = []
for val in fined:
    pre_result = []
    bd_int  = re.findall(r"128, d*, d*, d*", val)
    bd_date= re.findall(r"(153, 1[6,5,4,3]d, d*, d*, d*)", val)
    for it in bd_int:
        pre_result.append(find_int(bd_int[it]))
    for bd in bd_date:
        pre_result.append(find_data_time(bd))
    result.append(pre_result)

യഥാർത്ഥത്തിൽ, അത്രയേയുള്ളൂ, ഫല ശ്രേണിയിൽ നിന്നുള്ള ഡാറ്റ ഞങ്ങൾക്ക് ആവശ്യമായ ഡാറ്റയാണ്. ###PS.###
ഈ രീതി എല്ലാവർക്കും അനുയോജ്യമല്ലെന്ന് ഞാൻ മനസ്സിലാക്കുന്നു, എന്നാൽ ലേഖനത്തിന്റെ പ്രധാന ലക്ഷ്യം നിങ്ങളുടെ എല്ലാ പ്രശ്നങ്ങളും പരിഹരിക്കുന്നതിനുപകരം നടപടിയെടുക്കുക എന്നതാണ്. സോഴ്സ് കോഡ് സ്വയം പഠിക്കാൻ തുടങ്ങുക എന്നതാണ് ഏറ്റവും ശരിയായ പരിഹാരം എന്ന് ഞാൻ കരുതുന്നു മാരിദാബ്, എന്നാൽ പരിമിതമായ സമയം കാരണം, നിലവിലെ രീതി ഏറ്റവും വേഗതയുള്ളതായി തോന്നി.

ചില സാഹചര്യങ്ങളിൽ, ഫയൽ വിശകലനം ചെയ്ത ശേഷം, നിങ്ങൾക്ക് ഏകദേശ ഘടന നിർണ്ണയിക്കാനും മുകളിലുള്ള ലിങ്കുകളിൽ നിന്നുള്ള സ്റ്റാൻഡേർഡ് രീതികളിൽ ഒന്ന് ഉപയോഗിച്ച് അത് പുനഃസ്ഥാപിക്കാനും കഴിയും. ഇത് കൂടുതൽ ശരിയാകുകയും കുറച്ച് പ്രശ്നങ്ങൾ ഉണ്ടാക്കുകയും ചെയ്യും.

അവലംബം: www.habr.com