ibd ફાઇલના બાઇટ-બાય-બાઇટ વિશ્લેષણનો ઉપયોગ કરીને સ્ટ્રક્ચર ફાઇલ વિના XtraDB કોષ્ટકોમાંથી ડેટા પુનઃપ્રાપ્ત કરવો

પ્રાગૈતિહાસિક

એવું બન્યું કે સર્વર પર રેન્સમવેર વાયરસ દ્વારા હુમલો કરવામાં આવ્યો, જેણે "ભાગ્યશાળી અકસ્માત" દ્વારા .ibd ફાઇલો (innodb કોષ્ટકોની કાચી ડેટા ફાઇલો) ને આંશિક રીતે અસ્પૃશ્ય છોડી દીધી, પરંતુ તે જ સમયે .fpm ફાઇલોને સંપૂર્ણપણે એન્ક્રિપ્ટ કરી ( સ્ટ્રક્ચર ફાઇલો). આ કિસ્સામાં, .idb ને વિભાજિત કરી શકાય છે:

• માનક સાધનો અને માર્ગદર્શિકાઓ દ્વારા પુનઃસંગ્રહને આધીન. આવા કિસ્સાઓ માટે, એક ઉત્તમ છે banavu;
• આંશિક રીતે એન્ક્રિપ્ટેડ કોષ્ટકો. મોટે ભાગે આ મોટા કોષ્ટકો છે, જેના માટે (જેમ હું સમજું છું) હુમલાખોરો પાસે સંપૂર્ણ એન્ક્રિપ્શન માટે પૂરતી 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)

આમ, તે પ્રથમ પ્રકારની ફાઇલો શોધવાનું બહાર આવ્યું. બીજામાં ઘણાં મેન્યુઅલ વર્કનો સમાવેશ થાય છે, પરંતુ જે મળ્યું તે પહેલેથી જ પૂરતું હતું. બધું સારું રહેશે, પરંતુ તમારે જાણવાની જરૂર છે એકદમ ચોક્કસ માળખું અને (અલબત્ત) એક કિસ્સો ઉભો થયો કે મારે વારંવાર બદલાતા ટેબલ સાથે કામ કરવું પડ્યું. ફીલ્ડનો પ્રકાર બદલાયો હતો કે નવી કૉલમ ઉમેરવામાં આવી હતી તે કોઈને યાદ નથી.

વાઇલ્ડ સિટી, કમનસીબે, આવા કેસમાં મદદ કરી શક્યું નથી, તેથી જ આ લેખ લખવામાં આવી રહ્યો છે.

મુદ્દા પર મેળવો

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 સાથે તેમનું માળખું અપડેટ કરવામાં આવશે નહીં. પરિણામે, ડેટા માળખું ફાઇલની શરૂઆતથી તેના અંત સુધી બદલાઈ શકે છે. જો તમે વારંવાર OPTIMIZE TABLE નો ઉપયોગ કરો છો, તો પછી તમને આવી સમસ્યા આવવાની શક્યતા નથી.

ધ્યાન આપો, DBMS સંસ્કરણ ડેટા સંગ્રહિત કરવાની રીતને અસર કરે છે, અને આ ઉદાહરણ અન્ય મુખ્ય સંસ્કરણો માટે કામ કરતું નથી. મારા કિસ્સામાં, mariadb 10.1.24 ના વિન્ડોઝ વર્ઝનનો ઉપયોગ કરવામાં આવ્યો હતો. ઉપરાંત, જો કે mariadb માં તમે InnoDB કોષ્ટકો સાથે કામ કરો છો, હકીકતમાં તે છે એક્સટ્રાડીબી, જે InnoDB mysql સાથે પદ્ધતિની લાગુતાને બાકાત રાખે છે.

ફાઇલ વિશ્લેષણ

પાયથોનમાં, ડેટા પ્રકાર બાઇટ્સ() સંખ્યાઓના નિયમિત સમૂહની જગ્યાએ યુનિકોડ ડેટા દર્શાવે છે. જો કે તમે આ ફોર્મમાં ફાઈલ જોઈ શકો છો, સુવિધા માટે તમે બાઈટ એરેને નિયમિત એરે (સૂચિ(example_byte_array))માં રૂપાંતરિત કરીને બાઈટને આંકડાકીય સ્વરૂપમાં રૂપાંતરિત કરી શકો છો. કોઈપણ કિસ્સામાં, બંને પદ્ધતિઓ વિશ્લેષણ માટે યોગ્ય છે.

ઘણી ibd ફાઇલો જોયા પછી, તમે નીચેની શોધી શકો છો:

તદુપરાંત, જો તમે આ કીવર્ડ્સ દ્વારા ફાઇલને વિભાજીત કરો છો, તો તમને મોટાભાગે ડેટાના બ્લોક્સ પણ મળશે. અમે વિભાજક તરીકે infimum નો ઉપયોગ કરીશું.

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

એક રસપ્રદ અવલોકન: નાની માત્રામાં ડેટા સાથેના કોષ્ટકો માટે, ઇન્ફિમમ અને સર્વોચ્ચ વચ્ચે બ્લોકમાં પંક્તિઓની સંખ્યા માટે નિર્દેશક છે.

- 1લી પંક્તિ સાથેનું પરીક્ષણ ટેબલ

- 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