მონაცემთა აღდგენა XtraDB ცხრილებიდან სტრუქტურული ფაილის გარეშე ibd ფაილის ბაიტი-ბაიტი ანალიზის გამოყენებით

წინაისტორია

მოხდა ისე, რომ სერვერს თავს დაესხა გამოსასყიდი ვირუსი, რომელმაც „იღბლიანი შემთხვევის“ შედეგად ნაწილობრივ დატოვა .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)

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

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 DATETIME;
• date_finish DATETIME.

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

პრობლემა 1: DATETIME და TEXT ტიპების ველებს ჰქონდათ NULL მნიშვნელობები და ისინი უბრალოდ გამოტოვებულია ფაილში, ამის გამო შეუძლებელი იყო ჩემს შემთხვევაში აღდგენილი სტრუქტურის დადგენა. ახალ სვეტებში ნაგულისხმევი მნიშვნელობა იყო null და ტრანზაქციის ნაწილი შეიძლება დაიკარგოს innodb_flush_log_at_trx_commit = 0 პარამეტრის გამო, ამიტომ დამატებითი დრო უნდა დაიხარჯოს სტრუქტურის დასადგენად.

პრობლემა 2: გასათვალისწინებელია, რომ DELETE-ის საშუალებით წაშლილი რიგები ყველა იქნება ibd ფაილში, მაგრამ ALTER TABLE-ით მათი სტრუქტურა არ განახლდება. შედეგად, მონაცემთა სტრუქტურა შეიძლება განსხვავდებოდეს ფაილის დასაწყისიდან მის ბოლომდე. თუ ხშირად იყენებთ OPTIMIZE TABLE-ს, მაშინ ნაკლებად სავარაუდოა, რომ შეგხვდეთ ასეთი პრობლემა.

შენიშვნა, DBMS ვერსია გავლენას ახდენს მონაცემების შენახვაზე და ეს მაგალითი შეიძლება არ იმუშაოს სხვა ძირითად ვერსიებზე. ჩემს შემთხვევაში გამოყენებული იყო mariadb 10.1.24 windows ვერსია. გარდა ამისა, მიუხედავად იმისა, რომ mariadb-ში მუშაობთ InnoDB ცხრილებთან, სინამდვილეში ისინი არიან XtraDB, რაც გამორიცხავს მეთოდის გამოყენებადობას InnoDB mysql-ით.

ფაილის ანალიზი

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

რამდენიმე ibd ფაილის დათვალიერების შემდეგ, შეგიძლიათ იპოვოთ შემდეგი:

უფრო მეტიც, თუ ფაილს ამ საკვანძო სიტყვებზე გაყოფთ, ძირითადად მიიღებთ მონაცემთა ბლოკებს. გამყოფად გამოვიყენებთ infimum-ს.

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

საინტერესო დაკვირვება: მცირე რაოდენობის მონაცემების მქონე ცხრილებისთვის, infimum-სა და supremum-ს შორის არის მაჩვენებელი ბლოკში მწკრივების რაოდენობაზე.

- ტესტის მაგიდა 1 რიგით

- ტესტის მაგიდა 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

დარწმუნებული ვარ, რომ თუ თქვენ დახარჯავთ n დროს, ეს გაუგებრობა შეიძლება გამოსწორდეს.
შემდეგი, ფუნქცია, რომელიც აბრუნებს თარიღის დროის ობიექტს სტრიქონიდან. სკრიპტი:

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