שחזור נתונים מטבלאות XtraDB ללא קובץ מבנה באמצעות ניתוח בתים אחר בתים של קובץ ibd

פרהיסטוריה

כך קרה שהשרת הותקף על ידי וירוס כופר, אשר, ב"תאונה מזל", השאיר חלקית את קבצי ה-.ibd (קבצי נתונים גולמיים של טבלאות innodb), אך במקביל הצפין לחלוטין את קבצי ה-.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, ולאחר מכן המרתם לצורה קריא יותר. מכיוון שכדי למצוא את מה שאנחנו צריכים, אנחנו צריכים רק לנתח סוגי נתונים כמו int ו-datatime, המאמר יתאר רק אותם, אבל לפעמים נתייחס גם לסוגי נתונים אחרים, שיכולים לעזור בתקריות דומות אחרות.

בעיה 1: לשדות עם הסוגים DATETIME ו-TEXT היו ערכי NULL, והם פשוט מדלגים בקובץ, בגלל זה, לא ניתן היה לקבוע את המבנה לשחזור במקרה שלי. בעמודות החדשות, ערך ברירת המחדל היה null, וחלק מהעסקה עלול ללכת לאיבוד עקב ההגדרה innodb_flush_log_at_trx_commit = 0, כך שיהיה צורך להשקיע זמן נוסף כדי לקבוע את המבנה.

בעיה 2: יש לקחת בחשבון ששורות שנמחקו דרך DELETE יהיו כולן בקובץ ibd, אבל עם ALTER TABLE המבנה שלהן לא יתעדכן. כתוצאה מכך, מבנה הנתונים יכול להשתנות מתחילת הקובץ ועד סופו. אם אתה משתמש לעתים קרובות ב- OPTIMIZE TABLE, לא סביר שתתקל בבעיה כזו.

שים לב, גרסת DBMS משפיעה על האופן שבו נתונים מאוחסנים, וייתכן שדוגמה זו לא תעבוד עבור גרסאות עיקריות אחרות. במקרה שלי, נעשה שימוש בגרסת Windows של mariadb 10.1.24. כמו כן, למרות שב-mariadb אתה עובד עם טבלאות InnoDB, למעשה הם כן XtraDB, אשר אינו כולל את הישימות של השיטה עם InnoDB mysql.

ניתוח קבצים

ב-python, סוג נתונים bytes() מציג נתוני Unicode במקום קבוצה רגילה של מספרים. למרות שאתה יכול להציג את הקובץ בצורה זו, מטעמי נוחות אתה יכול להמיר את הבתים לצורה מספרית על ידי המרת מערך הבתים למערך רגיל (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)

למעשה, זה הכל, הנתונים ממערך התוצאות הם הנתונים שאנו צריכים. ###נ.ב.###
אני מבין ששיטה זו לא מתאימה לכולם, אבל המטרה העיקרית של המאמר היא להניע לפעולה ולא לפתור את כל הבעיות שלך. אני חושב שהפתרון הנכון ביותר יהיה להתחיל ללמוד את קוד המקור בעצמך מריאדב, אך בשל זמן מוגבל, נראה היה שהשיטה הנוכחית היא המהירה ביותר.

במקרים מסוימים, לאחר ניתוח הקובץ, תוכל לקבוע את המבנה המשוער ולשחזר אותו באחת מהשיטות הסטנדרטיות מהקישורים למעלה. זה יהיה הרבה יותר נכון ויגרום פחות בעיות.

מקור: www.habr.com