🥇 ibd फाइलचे बाइट-बाय-बाइट विश्लेषण वापरून स्ट्रक्चर फाइलशिवाय XtraDB टेबलमधून डेटा पुनर्प्राप्ती

prehistory

असे घडले की सर्व्हरवर रॅन्समवेअर व्हायरसने हल्ला केला, ज्याने "भाग्यवान अपघाताने" .ibd फाइल्स (इनोडबी टेबल्सच्या कच्च्या डेटा फाइल्स) अंशतः अस्पर्श केल्या, परंतु त्याच वेळी .fpm फाइल्स पूर्णपणे कूटबद्ध केल्या ( संरचना फाइल्स). या प्रकरणात, .idb मध्ये विभागले जाऊ शकते:

मानक साधने आणि मार्गदर्शकांद्वारे पुनर्संचयित करण्याच्या अधीन. अशा प्रकरणांसाठी, एक उत्कृष्ट आहे बनणे;
अंशतः कूटबद्ध सारण्या. बहुतेक ही मोठ्या टेबल्स आहेत, ज्यासाठी (जसे मला समजते) आक्रमणकर्त्यांकडे पूर्ण एनक्रिप्शनसाठी पुरेशी RAM नव्हती;
बरं, पूर्णपणे कूटबद्ध सारण्या ज्या पुनर्संचयित केल्या जाऊ शकत नाहीत.

इच्छित एन्कोडिंग अंतर्गत कोणत्याही मजकूर संपादकामध्ये (माझ्या बाबतीत ते 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)

अशा प्रकारे, प्रथम प्रकारच्या फायली शोधण्यात आल्या. दुसऱ्यामध्ये बरेच मॅन्युअल काम समाविष्ट आहे, परंतु जे सापडले ते आधीच पुरेसे होते. सर्व काही ठीक होईल, परंतु आपल्याला माहित असणे आवश्यक आहे पूर्णपणे अचूक रचना आणि (अर्थातच) एक केस उद्भवली की मला वारंवार बदलणाऱ्या टेबलसह काम करावे लागले. फील्ड प्रकार बदलला होता किंवा नवीन स्तंभ जोडला होता हे कोणालाच आठवत नाही.

Wilds City, दुर्दैवाने, अशा प्रकरणात मदत करू शकत नाही, म्हणूनच हा लेख लिहिला जात आहे.

मुद्द्यावर या

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 फाइलचे बाइट-बाय-बाइट विश्लेषण वापरले जाते, त्यानंतर ते अधिक वाचनीय स्वरूपात रूपांतरित केले जाते. आम्हाला काय हवे आहे ते शोधण्यासाठी, आम्हाला फक्त इंट आणि डेटाटाइम सारख्या डेटा प्रकारांचे विश्लेषण करणे आवश्यक आहे, लेख फक्त त्यांचे वर्णन करेल, परंतु काहीवेळा आम्ही इतर डेटा प्रकारांचा देखील संदर्भ घेऊ, जे इतर समान घटनांमध्ये मदत करू शकतात.

समस्या १: DATETIME आणि TEXT या प्रकारांसह फील्डमध्ये NULL मूल्ये होती, आणि ती फक्त फाइलमध्ये वगळली गेली आहेत, यामुळे, माझ्या बाबतीत पुनर्संचयित करण्यासाठी संरचना निश्चित करणे शक्य नव्हते. नवीन स्तंभांमध्ये, डीफॉल्ट मूल्य शून्य होते आणि innodb_flush_log_at_trx_commit = 0 या सेटिंगमुळे व्यवहाराचा काही भाग गमावला जाऊ शकतो, त्यामुळे रचना निश्चित करण्यासाठी अतिरिक्त वेळ खर्च करावा लागेल.

समस्या १: हे लक्षात घेतले पाहिजे की DELETE द्वारे हटवलेल्या पंक्ती सर्व ibd फाइलमध्ये असतील, परंतु ALTER TABLE सह त्यांची रचना अद्यतनित केली जाणार नाही. परिणामी, फाइलच्या सुरुवातीपासून शेवटपर्यंत डेटा संरचना बदलू शकते. तुम्ही अनेकदा ऑप्टिमाइझ टेबल वापरत असल्यास, तुम्हाला अशी समस्या येण्याची शक्यता नाही.

लक्ष द्या, DBMS आवृत्ती डेटा संचयित करण्याच्या मार्गावर परिणाम करते आणि हे उदाहरण इतर प्रमुख आवृत्त्यांसाठी कार्य करू शकत नाही. माझ्या बाबतीत, mariadb 10.1.24 ची विंडोज आवृत्ती वापरली गेली. तसेच, जरी mariadb मध्ये तुम्ही InnoDB टेबलसह काम करत असलात तरी प्रत्यक्षात ते आहेत एक्सट्राडीबी, जे InnoDB mysql सह पद्धतीची लागूता वगळते.

फाइल विश्लेषण

पायथनमध्ये, डेटा प्रकार बाइट्स() संख्यांच्या नियमित संचाच्या जागी युनिकोड डेटा प्रदर्शित करते. जरी तुम्ही या फॉर्ममध्ये फाइल पाहू शकता, परंतु सोयीसाठी तुम्ही बाइट अॅरेला नियमित अॅरेमध्ये रुपांतरित करून अंकीय स्वरूपात बाइट्सचे रूपांतर करू शकता (सूची(उदाहरण_बाइट_अॅरे)). कोणत्याही परिस्थितीत, दोन्ही पद्धती विश्लेषणासाठी योग्य आहेत.

अनेक ibd फाइल्स पाहिल्यानंतर, तुम्हाला पुढील गोष्टी मिळू शकतात:

शिवाय, जर तुम्ही फाइलला या कीवर्डद्वारे विभाजित केले तर तुम्हाला बहुतांश डेटाचे ब्लॉक्स मिळतील. आम्ही infimum एक विभाजक म्हणून वापरू.

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

एक मनोरंजक निरीक्षण: थोड्या प्रमाणात डेटा असलेल्या सारण्यांसाठी, इन्फिमम आणि सर्वोच्च दरम्यान ब्लॉकमधील पंक्तींच्या संख्येसाठी एक पॉइंटर आहे.

- पहिल्या पंक्तीसह चाचणी सारणी

- 2 पंक्तीसह चाचणी सारणी

पंक्ती अॅरे सारणी[0] वगळली जाऊ शकते. ते पाहिल्यानंतर, मला अजूनही रॉ टेबल डेटा सापडला नाही. बहुधा, हा ब्लॉक अनुक्रमणिका आणि की संग्रहित करण्यासाठी वापरला जातो.
सारणी[1] ने प्रारंभ करून आणि अंकीय अॅरेमध्ये भाषांतरित करून, आपण आधीच काही नमुने लक्षात घेऊ शकता, म्हणजे:

ही इंट व्हॅल्यूज स्ट्रिंगमध्ये साठवलेली असतात. पहिला बाइट संख्या सकारात्मक किंवा ऋण आहे की नाही हे सूचित करते. माझ्या बाबतीत, सर्व संख्या सकारात्मक आहेत. उर्वरित 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

ibd फाइलचे बाइट-बाय-बाइट विश्लेषण वापरून स्ट्रक्चर फाइलशिवाय XtraDB टेबलमधून डेटा पुनर्प्राप्त करणे

prehistory

मुद्द्यावर या

फाइल विश्लेषण

एक टिप्पणी जोडा Отменить ответ