Ковыряю двигатель Mistfall

Доброго времени всем.
Пытаюсь разобраться в движке, возникают некоторые вопросы... Итак, народ, вся надежда на вас...

Код (Text):

1. /*
2.   This file implements CMistfall class,
3.   i.e. executable file parser/rebuilder.
4. */
5.  
6. #define DUMP_MSG
7.  
8. #include "hooy.cpp"
9.  
10. #include "mistfall.hpp"
11.  
12. CMistfall::CMistfall()
13. {
14.  
15.   error_count = 0;
16.   i_phys_len = 0;
17.   o_phys_len = 0;
18.   ovr_offs = 0;
19.   ovr_size = 0;
20.  
21.   i_phys_mem = NULL;
22.   o_phys_mem = NULL;
23.   edit_header = NULL;
24.   edit_mz = NULL;
25.   edit_pe = NULL;
26.   edit_oe = NULL;
27.   mz = NULL;
28.   pe = NULL;
29.   oe = NULL;
30.   memb = NULL;
31.   flag = NULL;
32.   arg1 = NULL;
33.   arg2 = NULL;
34.   fasthooy = NULL;
35.  
36. } // CMistfall::CMistfall()
37.  
38. CMistfall::~CMistfall()
39. {
40.   ZFreeV( (void**)&i_phys_mem );
41.   ZFreeV( (void**)&o_phys_mem );
42.   ZFreeV( (void**)&memb );
43.   ZFreeV( (void**)&flag );
44.   ZFreeV( (void**)&arg1 );
45.   ZFreeV( (void**)&arg2 );
46.   ZFreeV( (void**)&fasthooy );
47.   ZFreeV( (void**)&edit_header );
48. } // CMistfall::~CMistfall()
49.  
50. int CMistfall::LoadFile(char* fname)
51. {
52.   FILE* f = fopen(fname, "rb");
53.   if (f == NULL) return MF_ERR_CANTOPENFILE;
54.  
55.   i_phys_len = filelength(fileno(f));
56.   if ( (i_phys_len < MF_PHYSFILE_MIN_SIZE) ||
57.        (i_phys_len > MF_PHYSFILE_MAX_SIZE) )
58.   {
59.     fclose(f);
60.     return MF_ERR_BADFILESIZE;
61.   }
62.  
63.   i_phys_mem = (BYTE*)ZReAlloc( i_phys_mem, i_phys_len+1 );
64.   if (i_phys_mem == NULL)
65.   {
66.     fclose(f);
67.     return MF_ERR_NOMEMORY;
68.   }
69.  
70.   fread(i_phys_mem, 1, i_phys_len, f);
71.  
72.   fclose(f);
73.  
74.   return MF_ERR_SUCCESS;
75. } // CMistfall::LoadFile()
76.  
77. int CMistfall::SaveFile(char* fname)
78. {
79.   if (o_phys_mem == NULL) return MF_ERR_NOTASSEMBLED;
80.   FILE* f = fopen(fname, "wb");
81.   if (f == NULL) return MF_ERR_CANTCREATEFILE;
82.   fwrite(o_phys_mem, 1, o_phys_len, f);
83.   fclose(f);
84.   return MF_ERR_SUCCESS;
85. } // CMistfall::LoadFile()
86.  
87. void CMistfall::process_import(DWORD addr)
88. {
89.   if (memd[addr] == 0) return;
90.   markrvadata(addr);
91.   addr = memd[addr];
92.   while (memd[addr])
93.   {
94.     if (memd[addr] < pe->pe_imagesize)
95.       markrvadata(addr);
96.     addr += 4;
97.   } // while
98. } // CMistfall::process_import()
99.  
100. void CMistfall::process_rsrc(DWORD addr)
101. {
102. // 00h  DWord  Flags
103. // 04h  DWord  Time/Date Stamp
104. // 08h  Word   Major Version
105. // 0Ah  Word   Minor Version
106. // 0Ch  Word   Name Entry
107. // 0Eh  Word   ID_Num Entry
108. //
109.   DWORD c = memw[addr + 0x0C] + memw[addr + 0x0E];
110.   DWORD t = addr + 0x10;
111.   while (c--)
112.   {
113.     if (memd[t] & 0x80000000)
114.     {
115.       flag[t] |= FL_RES8;
116.       DWORD q = memd[t] & 0x7FFFFFFF;
117.       markdelta(t, pe->pe_resourcerva, q);
118.     }
119.     t += 4;
120.     if (memd[t] & 0x80000000)
121.     {
122.       flag[t] |= FL_RES8;
123.       DWORD q = memd[t] & 0x7FFFFFFF;
124.       markdelta(t, pe->pe_resourcerva, q);
125.       process_rsrc( pe->pe_resourcerva + q );
126.     }
127.     else
128.     {
129.       markdelta(t, pe->pe_resourcerva, memd[t]);
130.       markrvadata(pe->pe_resourcerva + memd[t]);
131.     }
132.     t += 4;
133.   } // while
134. } // CMistfall::process_rsrc()
135.  
136. void CMistfall::DumpLog(char* logfile)
137. {
138. #ifdef DUMP_MSG
139.   log("+ writing log: %s\n", logfile);
140. #endif // DUMP_MSG
141.  
142.   FILE*f=fopen(logfile, "wb");
143.   if (f==NULL) return;
144.  
145.   HOOY* h;
146.   ForEachInList(HooyList, HOOY, h)
147.   {
148.     fprintf(f,"%08X %08X %08X: ",h->oldrva,h->newrva,h->newofs);
149.     if (h->flags&FL_SECTALIGN)
150.     {
151.       fprintf(f,"SECTALIGN\n");
152.     }
153.     else
154.     if (h->flags&FL_LABEL)
155.     {
156.       fprintf(f,"LABEL");
157.       if (h->flags&FL_CREF) fprintf(f,", CREF");
158.       if (h->flags&FL_DREF) fprintf(f,", DREF");
159.       if (h->flags&FL_DATA) fprintf(f,", DATA");
160.       fprintf(f," (flag=%08X)\n",h->flags);
161.     }
162.     else
163.     if (h->flags&FL_DELTA)
164.     {
165.        fprintf(f,"DELTA %08X    /*%08X..%08X*/ ",
166.          *(DWORD*)h->dataptr, h->arg1,h->arg2);
167.        if (h->flags&FL_RES8) fprintf(f," [RES8]");
168.        fprintf(f,"\n");
169.     }
170.     else
171.     if (h->flags&FL_RVA)
172.     {
173.       fprintf(f,"RVA %08X\n",*(DWORD*)h->dataptr);
174.     }
175.     else
176.     if (h->flags&FL_OPCODE)
177.     {
178.       fprintf(f,"OPCODE: ");
179. //      for (DWORD i=0; i<h->datalen; i++)
180. //        fprintf(f," %02X",h->dataptr[i]);
181. //      fprintf(f,"\n");
182.       //
183.       char s[256];
184. //      BYTE bin[64];
185. //      memset(bin,0x00,sizeof(bin));
186. //      memcpy(bin, h->dataptr, h->datalen);
187. //      if (h->next && h->next->dataptr)
188. //      {
189. //        memcpy(bin+h->datalen, h->next->dataptr, MIN(128-h->datalen,h->next->datalen));
190. //        if (h->next->next && h->next->next->dataptr)
191. //          memcpy(bin+h->datalen+h->next->datalen, h->next->next->dataptr, MIN(128-h->datalen+h->next->datalen,h->next->next->datalen));
192. //      }
193. //      dump_instr(bin, h->oldrva, s);
194.       dump_instr(h->dataptr, h->oldrva, s);
195.       fprintf(f, "%s\n",s);
196.     }
197.     else
198.     if (h->flags&FL_FIXUP)
199.     {
200.       fprintf(f,"FIXUP %08X\n",h->arg1);
201.     }
202.     else
203.     if (h->flags&FL_DATA)
204.     {
205.       fprintf(f,"DATA (%04X) ",h->datalen);
206.       for (DWORD i=0; i<MIN(h->datalen,8); i++)
207.         fprintf(f," %02X",h->dataptr[i]);
208.       if (h->datalen>8) fprintf(f," ...");
209.       fprintf(f,"\n");
210.     }
211.     else
212.     //__emit__(0xcc)
213.     ;
214.   } // for h
215.  
216.   fclose(f);
217. } // CMistfall::DumpLog()
218.  
219.  
220. int CMistfall::Disasm(DWORD dflags)
221. {
222.   error_count = 0;
223.   can_patch   = 0;
224.  
225.   xde_instr diza;
226.  
227. #ifdef DUMP_MSG
228.   log("+ checking file format\n");
229. #endif // DUMP_MSG
230.  
231.   // check file format
232.  
233.   mz = (MZ_HEADER*) &i_phys_mem[0];
234.  
235.   if ( (mz->mz_id != 0x5A4D) ||
236.        (mz->mz_neptr & 3)  ||
237.        (mz->mz_neptr <  sizeof(MZ_HEADER)) ||
238.        (mz->mz_neptr + 1024 >= i_phys_len) )
239.   {
240.     error_count++;
241.     return MF_ERR_BADMZHDR;
242.   }
243.  
244.   pe = (PE_HEADER*) &i_phys_mem[ mz->mz_neptr ];
245.  
246.   if (pe->pe_id != 0x00004550)                // 'PE\0\0'
247.   {
248.     error_count++;
249.     return MF_ERR_BADPEHDR;
250.   }
251.  
252.   if (pe->pe_ntheadersize != 0xE0)
253.   {
254.     error_count++;
255.     return MF_ERR_BADPEHDR;
256.   }
257.  
258.   if ((pe->pe_fixuprva==0) || (pe->pe_flags & 1))
259.   {
260.     // if there is no fixups, check if fixups are required
261.     if ((dflags & DF_FIXUPSREQUIRED) == 0)
262.     {
263.       // there is no fixups, so we increment error_count to disallow file
264.       // reassembling, however "patch" mode remains available
265.       error_count++;
266.     }
267.     else
268.     {
269.       error_count++;
270.       return MF_ERR_NOFIXUPS;
271.     }
272.   }
273.  
274.   if ( (pe->pe_numofobjects == 0) ||
275.        (pe->pe_numofobjects > MF_PE_MAXSECTIONS) )
276.   {
277.     error_count++;
278.     return MF_ERR_BADNSECT;
279.   }
280.  
281.   if (pe->pe_headersize > MIN(i_phys_len, pe->pe_imagesize))
282.   {
283.     error_count++;
284.     return MF_ERR_BADPEHDR;
285.   }
286.  
287.   oe = (PE_OBJENTRY*) &i_phys_mem[ mz->mz_neptr + sizeof(PE_HEADER) ];
288.  
289.   DWORD n;
290.   for(n=0; n<(DWORD)pe->pe_numofobjects; n++)
291.   {
292.     if ( (oe[n].oe_physoffs == 0) ||
293.          (oe[n].oe_physsize == 0) ||
294.          (oe[n].oe_virtrva  == 0) ||
295.          (oe[n].oe_virtsize == 0) )
296.     {
297.       error_count++;
298.       return MF_ERR_BADOBJTABLE;
299.     }
300.     // force alignment
301.     oe[n].oe_virtsize = ALIGN(oe[n].oe_virtsize, pe->pe_objectalign);
302.     oe[n].oe_physsize = ALIGN(oe[n].oe_physsize, pe->pe_filealign);
303.   }
304.  
305.   // calc ovr. params
306.   DWORD t = pe->pe_numofobjects - 1;
307.   ovr_offs = oe[t].oe_physoffs + oe[t].oe_physsize;
308.   ovr_size = i_phys_len - ovr_offs;
309.   if ((signed)ovr_size < 0)
310.   {
311.     error_count++;
312.     return MF_ERR_BADOVRSIZE;
313.   }
314.  
315.   // check if overlay is just zero-bytes alignment at end of file
316.   t = 0;
317.   DWORD i;
318.   for (i=0; i<ovr_size; i++)
319.     t |= i_phys_mem[ovr_offs + i];
320.   if (t == 0)
321.     ovr_size = 0;
322.  
323.   if (dflags & DF_STDSECT)
324.   {
325.     DWORD n;
326.     for(n=0; n<(DWORD)pe->pe_numofobjects; n++)
327.     {
328.       DWORD t = ~( *(DWORD*)&oe[n].oe_name[0] ^      // 8 bytes
329.                    *(DWORD*)&oe[n].oe_name[4] );
330. #define mk1(x) if (t != ~((DWORD)(x)))
331.       mk1(0x45444F43)   //  'CODE'
332.       mk1(0x41544144)   //  'DATA'
333.       mk1(0x4F545541)   //  'AUTO'
334.       mk1(0x00535342)   //  'BSS\x00'
335.       mk1(0x00534C54)   //  'TLS\x00'
336.       mk1(0x7373622E)   //  '.bss'
337.       mk1(0x736C742E)   //  '.tls'
338.       mk1(0x5452432E)   //  '.CRT'
339.       mk1(0x494E497A)   //  '.INI'^'T\x00\x00\x00'
340.       mk1(0x7865745A)   //  '.tex'^'t\x00\x00\x00'
341.       mk1(0x7461644F)   //  '.dat'^'a\x00\x00\x00'
342.       mk1(0x7273724D)   //  '.rsr'^'c\x00\x00\x00'
343.       mk1(0x6C651141)   //  '.rel'^'oc\x00\x00'
344.       mk1(0x6164085A)   //  '.ida'^'ta\x00\x00'
345.       mk1(0x6164135A)   //  '.rda'^'ta\x00\x00'
346.       mk1(0x6164045A)   //  '.eda'^'ta\x00\x00'
347.       mk1(0x6265035B)   //  '.deb'^'ug\x00\x00'
348.       mk1(0x4F521711)   //  'DGRO'^'UP\x00\x00'
349.       {
350.         error_count++;
351.         return MF_ERR_BADSECTNAME;
352.       }
353.     } // for n
354.   } // DF_STDSECT
355.  
356. #ifdef DUMP_MSG
357.   log("+ allocating virtual memory\n");
358. #endif // DUMP_MSG
359.  
360.   // allocate virtual memory
361.  
362.   if (pe->pe_imagesize > MF_PE_MAXIMAGESIZE)
363.   {
364.     error_count++;
365.     return MF_ERR_BADIMAGESIZE;
366.   }
367.  
368.   t = pe->pe_imagesize + 1;  // +1 because we may have last virtual entry
369.  
370.   memb = (BYTE*)ZReAlloc(memb, t);
371.   if (memb == NULL)
372.   {
373.     error_count++;
374.     return MF_ERR_NOMEMORY;
375.   }
376.  
377.   t <<= 2; // now allocating DWORDs
378.  
379.   flag = (DWORD*)ZReAlloc(flag, t);
380.   if (flag == NULL)
381.   {
382.     error_count++;
383.     return MF_ERR_NOMEMORY;
384.   }
385.  
386.   arg1 = (DWORD*)ZReAlloc(arg1, t);
387.   if (arg1 == NULL)
388.   {
389.     error_count++;
390.     return MF_ERR_NOMEMORY;
391.   }
392.  
393.   arg2 = (DWORD*)ZReAlloc(arg2, t);
394.   if (arg2 == NULL)
395.   {
396.     error_count++;
397.     return MF_ERR_NOMEMORY;
398.   }
399.  
400. #ifdef DUMP_MSG
401.   log("+ loading into virtual addresses\n");
402. #endif // DUMP_MSG
403.  
404.   // load into virtual addresses
405.  
406.   memcpy(memb, i_phys_mem, pe->pe_headersize);
407.   for (i=0; i<pe->pe_headersize; i++)
408.     flag[i] |= FL_PRESENT | FL_VPRESENT;
409.  
410.   for(n=0; n<(DWORD)pe->pe_numofobjects; n++)
411.   {
412.     // copy section image
413.     memcpy(&memb[ oe[n].oe_virtrva ],
414.            &i_phys_mem[ oe[n].oe_physoffs ],
415.            MIN(oe[n].oe_physsize, oe[n].oe_virtsize));
416.     // set presence flags
417.     for (i=0; i<oe[n].oe_physsize; i++)
418.       flag[oe[n].oe_virtrva + i] |= FL_PRESENT;
419.     for (i=0; i<oe[n].oe_virtsize; i++)
420.       flag[oe[n].oe_virtrva + i] |= FL_VPRESENT;
421.   } // for n
422.  
423.   // analyze PE structure
424.  
425. #ifdef DUMP_MSG
426.   log("+ PE header\n");
427. #endif // DUMP_MSG
428.  
429.   // PE header
430.  
431.   t = mz->mz_neptr + sizeof(PE_HEADER);
432.  
433.   for (n=0; n<(DWORD)pe->pe_numofobjects; n++)
434.   {
435.     flag[oe[n].oe_virtrva] |= FL_SECTALIGN;
436.  
437.     markdelta(t+0x08, oe[n].oe_virtrva, oe[n].oe_virtsize); // 08=virtsize
438.  
439.     markrva(t+0x0C);                                        // 0C=virtrva
440.  
441.     markdelta(t+0x10, oe[n].oe_virtrva, oe[n].oe_physsize); // 10=physsize
442.     flag[t+0x10] |= FL_PHYS | FL_FORCEFILEALIGN;            // 10=physsize
443.  
444.     flag[t+0x14] |= FL_PHYS | FL_RVA;                       // 14=physoffs
445.     arg1[t+0x14] = oe[n].oe_virtrva;                        // 14=physoffs
446.  
447.     t += sizeof(PE_OBJENTRY);
448.   }
449.   flag[pe->pe_imagesize] |= FL_SECTALIGN;
450.  
451.   t = mz->mz_neptr;
452.  
453.   if (pe->pe_entrypointrva)
454.     markrva(t + 0x28);                 // EntryPointRVA
455.  
456.   markrva(t + 0x2C);                   // 2C=baseofcode
457.   markrva(t + 0x30);                   // 30=baseofdata
458.  
459.   markdelta(t+0x1C, pe->pe_baseofcode, pe->pe_sizeofcode); // 1C=sizeofcode
460.   flag[t+0x1C] |= FL_FORCEOBJALIGN;
461.  
462. //markdelta(t+0x20, pe->pe_baseofdata, pe->pe_sizeofidata);// 20=sizeofidata
463. //flag[t+0x20] |= FL_FORCEOBJALIGN;
464.  
465.   markrva(t + 0x50);                       // 50=imagesize
466.   markrvadata(t + 0x54);                   // 54=headersize
467.  
468.   for(i=0; i<pe->pe_numofrvaandsizes; i++)
469.   {
470.     t = mz->mz_neptr + 0x78 + i * 8;              // rva/size #i
471.     if ( memd[t] )
472.     {
473.       markrvadata(t);
474.       markdelta(t+4, memd[t], memd[t+4]);
475.       for (DWORD i=memd[t]; i<memd[t]+memd[t+4]; i++)
476.       if (i < pe->pe_imagesize)
477.         flag[i] |= FL_DATA;
478.       else
479.         error_count++;
480.     }
481.   }
482.  
483.   // import
484.  
485.   if (pe->pe_importrva)
486.   {
487. #ifdef DUMP_MSG
488.   log("+ imports\n");
489. #endif // DUMP_MSG
490.  
491.     DWORD imp0 = pe->pe_importrva;
492.     flag[imp0] |= FL_LABEL;
493.     while ( memd[imp0 + 0x10] )              // 10=addresstable
494.     {
495.       process_import(imp0 + 0x00);           // 00=lookup
496.       process_import(imp0 + 0x10);           // 10=addresstable
497.       markrvadata(imp0 + 0x0C);              // 0C=name
498.       imp0 += sizeof(PE_IMPORT);
499.     }
500.   }
501.  
502.   // export
503.  
504.   if (pe->pe_exportrva)
505.   {
506. #ifdef DUMP_MSG
507.   log("+ exports\n");
508. #endif // DUMP_MSG
509.  
510.     DWORD exp0 = pe->pe_exportrva;
511.     markrvadata(exp0+0x0C);           // 0C=namerva
512.     markrvadata(exp0+0x1C);           // 1C=addresstablerva
513.     markrvadata(exp0+0x20);           // 20=namepointersrva
514.     markrvadata(exp0+0x24);           // 24=ordinaltablerva
515.     PE_EXPORT *exp = (PE_EXPORT*) &memb[ exp0 ];
516.     exp0 = exp->ex_addresstablerva;
517.     for (DWORD i = 0; i < exp->ex_numoffunctions; i++)
518.       markrva(exp0 + i*4);
519.     exp0 = exp->ex_namepointersrva;
520.     for (i = 0; i < exp->ex_numofnamepointers; i++)
521.       markrvadata(exp0 + i*4);
522.   }
523.  
524.   // fixups
525.  
526.   if ((pe->pe_fixuprva) && ((pe->pe_flags & 1)==0))
527.   {
528. #ifdef DUMP_MSG
529.     log("+ fixups\n");
530. #endif // DUMP_MSG
531.  
532.     DWORD fixupcount = 0;
533.  
534.     PE_FIXUP* fx = (PE_FIXUP*) &memb[ pe->pe_fixuprva ];
535.     DWORD k = 0;
536.     while (k < pe->pe_fixupsize)
537.     {
538.       for (i = 0; i < (fx->fx_blocksize - 8) / 2; i++)
539.       {
540.         DWORD fxtype = fx->fx_typeoffs[i] >> 12;
541.         if (fxtype == 3)
542.         {
543.           fixupcount++;
544.           DWORD j = fx->fx_pagerva + (fx->fx_typeoffs[i] & 0x0FFF);
545.           if (j > pe->pe_imagesize)
546.           {
547.             error_count++;
548.             return MF_ERR_BADFIXUPS;
549.           }
550.           markfixup(j);
551. //#ifdef NEWBASE
552. //        memd[j] = memd[j] - pe->pe_imagebase + NEWBASE;
553. //#endif
554.         }
555.         else
556.         if (fxtype != 0)
557.         {
558.           error_count++;
559.           return MF_ERR_BADFIXUPS;
560.         }
561.       }
562.       k += fx->fx_blocksize;
563.       *(DWORD*)&fx += fx->fx_blocksize;
564.     }
565. //#ifdef NEWBASE
566. //  pe->pe_imagebase = NEWBASE;
567. //#endif
568.  
569.     if (fixupcount == 0)
570.     {
571.       error_count++;
572.       return MF_ERR_NOFIXUPS; // # fixups == 0
573.     }
574.   }
575.  
576.   // resources
577.  
578.   if (pe->pe_resourcerva)
579.   {
580. #ifdef DUMP_MSG
581.   log("+ resources\n");
582. #endif // DUMP_MSG
583.  
584.     process_rsrc( pe->pe_resourcerva );
585.   }
586.  
587.   // sigman-1
588.  
589. #ifdef DUMP_MSG
590.   log("+ analyzing code\n");
591. #endif // DUMP_MSG
592.  
593.   // analyze code
594.  
595.   DWORD code_start;
596.   DWORD code_end;
597.   if (dflags & DF_CODEFIRST)
598.   {
599.     code_start = oe[0].oe_virtrva;
600.     code_end   = oe[0].oe_virtrva + oe[0].oe_physsize;
601.   }
602.   else
603.   {
604.     code_start = pe->pe_headersize;
605.     code_end   = pe->pe_imagesize - 16;
606.   }
607.  
608.   if (pe->pe_entrypointrva)
609.     flag[ pe->pe_entrypointrva ] |= FL_NEXT;
610.  
611.   DWORD ip;
612.  
613.   // find & mark subroutines
614.  
615.   for (ip = code_start; ip < code_end; ip++)
616.   {
617.     if (~(memd[ip] & 0x00FFFFFF) == ~0x00EC8B55U) // to avoid fail on self
618.       flag[ip] |= FL_NEXT;
619.     if (memw[ip] == 0x8B55)
620.       if (flag[ip] & FL_DREF)
621.         flag[ip] |= FL_NEXT;
622.   } // for ip
623.  
624.   if ((dflags & DF_DISABLEDISASM)==0)
625.   {
626.  
627. #ifdef DUMP_MSG
628.     log("+ disassembling\n");
629. #endif // DUMP_MSG
630.  
631.     // disassemble
632.  
633.     for (;;)
634.     {
635.  
636.       for (ip = 0; ip < pe->pe_imagesize; ip++)
637.         if (flag[ip] & FL_NEXT)
638.           goto c1;
639.  
640.       if (dflags & DF_TRY_DREF)
641.       {
642.         for (ip = code_start; ip < code_end; ip++)
643.         if (flag[ip] & FL_DREF)
644.         if (!(flag[ip] & (FL_NEXT | FL_ANALYZED | FL_FIXUP | FL_DATA)))
645.         if (memb[ip] != 0x00)
646.         {
647.  
648.           flag[ip] |= FL_ANALYZED;
649.  
650.           DWORD j = ip;
651.           for (/*int opcount=0*/; j < pe->pe_imagesize - 16; /*opcount++*/)
652.           {
653.             DWORD len = xde_disasm( &memb[j], &diza );
654.             if (len==0) break;
655.  
656.             if (diza.flag & C_BAD) break;
657.  
658.             DWORD rel = NONE;
659.             if (diza.flag & C_REL)
660.             {
661.               if (diza.datasize == 1) rel = j + len + diza.data_c[0];
662.               if (diza.datasize == 2) rel = j + len + diza.data_s[0];
663.               if (diza.datasize == 4) rel = j + len + diza.data_l[0];
664.             }
665.  
666.             if (rel != NONE)
667.             {
668.               if (rel > code_end)
669.                 break;
670.               if (flag[rel] & (FL_DATA | FL_FIXUP))
671.                 break;
672.               if ( (flag[rel] & FL_CODE) && (!(flag[rel] & FL_OPCODE)) )
673.                 break;
674.             }
675.  
676.             if (   (diza.flag & C_STOP) ||
677.                    (flag[j] & FL_OPCODE)   )
678.             {
679.     //        if (opcount < 2) break;
680.               flag[ip] |= FL_NEXT;
681.               goto c1;
682.             }
683.  
684.             if (flag[j] & (FL_DATA | FL_FIXUP))
685.               break;
686.  
687.             for (DWORD i=j+1; i<j+len; i++)
688.               if ( flag[i] & (FL_LABEL|FL_OPCODE|FL_DATA) )
689.                 goto c2;
690.  
691. //            if (len>4)
692. //            for (DWORD i=j+len-3; i<j+len; i++)
693. //              if ( flag[i] & FL_FIXUP )
694. //                goto c2;
695.  
696.             j += len;
697.  
698.             if (j > code_end)
699.               break;
700.  
701.           }
702.     c2: ;
703.         } // FL_DREF
704.       } // DF_TRY_DREF
705.  
706.       if (dflags & DF_TRY_RELREF)
707.       {
708.         for (ip = code_start; ip < code_end; ip++)
709.         if (!(flag[ip] & FL_ANALYZED))
710.         {
711.           DWORD rel = NONE, arg = 0;
712.           BYTE o = memb[ip];
713.           WORD w = memw[ip];
714.           if ((w&0xF0FF)==0x800F)
715.           {
716.             arg = (long)(memd[ip + 2]);
717.             rel = ip + 6 + arg;
718.           }
719.           if ((o==0xE8)||(o==0xE9))
720.           {
721.             arg = (long)(memd[ip + 1]);
722.             rel = ip + 5 + arg;
723.           }
724.           if (rel != NONE)
725.           if (arg & 0x00)
726.           if (rel < code_end)
727.             if (flag[rel] & FL_OPCODE)
728.             {
729.               flag[ip] |= FL_NEXT;
730.               goto c1;
731.             }
732.         }
733.       } // DF_TRY_RELREF
734.  
735.       break;
736.  
737.   c1:
738.  
739.       for (;;)
740.       {
741.         flag[ip] &= ~FL_NEXT;
742.         flag[ip] |= FL_ANALYZED;
743.  
744.         if (ip == 0) break;
745.  
746.         DWORD len = xde_disasm( &memb[ip], &diza );
747.         if (len==0) break;
748.  
749.         //if (diza.flag & C_BAD) break;
750.  
751.         for (DWORD i = 1; i < len; i++)
752.           if (flag[ip + i] & (FL_LABEL | FL_CODE | FL_OPCODE | FL_ANALYZED))
753.           if (!(flag[ip + i] & (FL_FIXUP | FL_SIGNATURE)))    // ???????
754.           {
755.             error_count++;      // !!!
756.             if (dflags & DF_ENABLE_ERRDISASM)
757.             {
758.               return MF_ERR_DISASM;
759.             }
760.             else
761.             {
762.               flag[ip + i] |= FL_ERROR;
763.               goto c3;
764.             }
765.           }
766.  
767.         DWORD nxt = ip + len;
768.         DWORD rel = NONE;
769.  
770.         if (diza.flag & C_REL)
771.         {
772.           if (diza.datasize == 1) // jcc,jcxz,loop/z/nz,jmps
773.           {
774.             rel = nxt + diza.data_c[0];
775.             arg2[ip] = 1;
776.           }
777.           if (diza.datasize == 2) break;
778.           if (diza.datasize == 4) // jcc near,call,jmp
779.           {
780.             rel = nxt + diza.data_l[0];
781.             arg2[ip] = 4;
782.           }
783.         }
784.  
785.         if (diza.flag & C_STOP)
786.           nxt=NONE; // ret/ret#/retf/retf#/iret/jmp modrm
787.  
788.         if (rel != NONE)
789.         {
790.           if (rel > code_end)
791.           {
792.             break;
793.           }
794.  
795.           if (flag[rel] & (FL_DATA | FL_FIXUP)) break;
796.           if ( (flag[rel] & FL_CODE) && (!(flag[rel] & FL_OPCODE)) ) break;
797.  
798.           flag[ip] |= FL_HAVEREL;
799.           flag[rel] |= FL_LABEL | FL_CREF;
800.           if ((flag[rel] & FL_ANALYZED) == 0)
801.             flag[rel] |= FL_NEXT;
802.           arg1[ip] = rel;
803.         }
804.  
805.         for (i = 0; i < len; i++)
806.         {
807.           flag[ip + i] |= FL_CODE | FL_ANALYZED;
808.           flag[ip + i] &= ~(FL_OPCODE | FL_NEXT);
809.         }
810.         flag[ip] |= FL_OPCODE;
811.  
812.         if (nxt == NONE)
813.         {
814.           flag[ip] |= FL_STOP;
815.           break;
816.         }
817.  
818.         ip = nxt;
819.  
820.         if (ip > code_end)
821.           break;
822.  
823.         if (flag[ip] & FL_CODE) break;
824.  
825.       } // cycle until RET
826.   c3: ;
827.     } // main cycle
828.  
829.   } // DF_DISABLEDISASM
830.  
831.   // sigman-2
832.  
833. #ifdef DUMP_MSG
834.   log("+ building list\n");
835. #endif // DUMP_MSG
836.  
837.   // build list
838.  
839.   edit_header = (BYTE*)ZReAlloc(edit_header, pe->pe_headersize);
840.   if (edit_header == NULL)
841.   {
842.     error_count++;
843.     return MF_ERR_NOMEMORY;
844.   }
845.   memcpy(edit_header, memb, pe->pe_headersize);
846.  
847.   edit_mz = (MZ_HEADER*)   &edit_header[ 0 ];
848.   edit_pe = (PE_HEADER*)   &edit_header[ edit_mz->mz_neptr ];
849.   edit_oe = (PE_OBJENTRY*) &edit_header[ edit_mz->mz_neptr + sizeof(PE_HEADER) ];
850.  
851.   //assert(HooyList.entry_size !=0 );
852.   HooyList.Empty();
853.  
854.   for (  i = 0;
855.          (i < pe->pe_imagesize) || ((i == pe->pe_imagesize) && flag[i]);   )
856.   {
857.  
858.     DWORD l;
859.     int fix1 = 0, fix2 = -1;
860.     if (flag[i] & (FL_SECTALIGN | FL_LABEL))
861.       l = 0;
862.     else
863.     if (flag[i] & FL_OPCODE)
864.     {
865.       l = xde_disasm( &memb[i], &diza );
866.       for(int t=1; t<l; t++)
867.       {
868.         if (flag[i+t] & FL_FIXUP)
869.         {
870.           fix1 = arg1[i+t];
871.           fix2 = t;
872.         }
873.         if ((flag[i+t]&(~FL_FIXUP)) != (FL_CODE | FL_ANALYZED | FL_PRESENT | FL_VPRESENT))
874.         {
875.           error_count++;
876.           flag[i] |= FL_ERROR;
877.           l = t;
878.           break;
879.         }
880.       }
881.     }
882.     else
883.     if (flag[i] & (FL_RVA | FL_DELTA | FL_FIXUP))
884.       l = 4;
885.     else
886.     {
887.       for (l=1; (flag[i] == flag[i+l]) && (i+l < pe->pe_imagesize); l++) ;
888.       flag[i] |= FL_DATA;
889.     }
890.  
891.     HOOY* t = (HOOY*) HooyList.Alloc();
892.     if (t==NULL)
893.     {
894.       error_count++;
895.       return MF_ERR_NOMEMORY;
896.     }
897.     t->flags = flag[i];
898.     t->oldrva = i;
899.     t->datalen = l;
900.     if (l)
901.     {
902.       if (t->oldrva < pe->pe_headersize)
903.       {
904.         t->flags |= FL_HEADER;
905.         t->dataptr = &edit_header[i];
906.       }
907.       else
908.       {
909.         t->dataptr = (BYTE*) ZAlloc( l );
910.         if (t->dataptr==0)
911.         {
912.           error_count++;
913.           return MF_ERR_NOMEMORY;
914.         }
915.         memcpy(t->dataptr, &memb[i], l);
916.       }
917.     }
918.     else
919.       t->dataptr = NULL;
920.     t->arg1 = arg1[i];
921.     t->arg2 = arg2[i];
922.     t->next = NULL;
923.  
924.     if (fix2 != -1)
925.     {
926.       t->flags |= FL_FIXUP;
927.       t->arg1  = fix1;
928.       t->arg2  = fix2;
929.     }
930.  
931.     if (flag[i] & FL_SECTALIGN)
932.     {
933.       t->flags &=   FL_SECTALIGN;
934.       flag[i]  &= ~(FL_SECTALIGN);
935.     }
936.     else
937.     if (flag[i] & FL_LABEL)
938.     {
939.       t->flags &=   FL_LABEL | FL_CREF | FL_DREF;
940.       flag[i]  &= ~(FL_LABEL | FL_CREF | FL_DREF);
941.     }
942.  
943.     HooyList.Attach(t);
944.  
945.     i += l;
946.   }
947.  
948.   ZFreeV((void**)&memb);
949.   ZFreeV((void**)&flag);
950.   ZFreeV((void**)&arg1);
951.   ZFreeV((void**)&arg2);
952.  
953.   can_patch = 1;
954.   return MF_ERR_SUCCESS;
955.  
956. } // CMistfall::Disasm()
957.  
958. HOOY* CMistfall::hooybyoldrva(DWORD oldrva, DWORD needflags)
959. {
960.   HOOY* h;
961.   ForEachInList(HooyList, HOOY, h)
962.     if (h->flags & needflags)
963.     if (h->oldrva == oldrva)
964.       return h;
965.   return NULL;
966. } // hooybyoldrva
967.  
968. int CMistfall::Asm(int full)
969. {
970.  
971.   if (full == 0)
972.   {
973.  
974.     ;;
975.  
976.     return MF_ERR_SUCCESS;
977.  
978.   } // full == 0
979.   else
980.   { // full == 1
981.  
982.     // there were errors while disasm, so we cant reassemble file
983.     if (error_count != 0)
984.       return MF_ERR_CANT_REASSEMBLE;
985.  
986.     error_count = 0;
987.  
988.   #ifdef DUMP_MSG
989.     log("+ asm()\n");
990.   #endif // DUMP_MSG
991.  
992.     // its incorrect, because disallows moving PE/OE
993.     memcpy(mz, edit_mz, sizeof(MZ_STRUCT));
994.     memcpy(pe, edit_pe, sizeof(PE_STRUCT));
995.     memcpy(oe, edit_oe, sizeof(PE_OBJENTRY) * pe->pe_numofobjects);
996.  
997.     fasthooy = (HOOY**)ZReAlloc( fasthooy, (pe->pe_imagesize+1)*4 );
998.     if (fasthooy == NULL)
999.     {
1000.       error_count++;
1001.       return MF_ERR_NOMEMORY;
1002.     }
1003.  
1004.     // find entry that describes whole fixup structure
1005.     HOOY* fxrva  = hooybyoldrva(pe->pe_fixuprva, FL_DATA);
1006.     if (fxrva==NULL)
1007.     {
1008.       error_count++;
1009.       return MF_ERR_INTERNAL1;
1010.     }
1011.     HOOY* fxsize = hooybyoldrva(mz->mz_neptr+0xA4, FL_DELTA);   //A4=fixupsize
1012.     if (fxsize==NULL)
1013.     {
1014.       error_count++;
1015.       return MF_ERR_INTERNAL2;
1016.     }
1017.  
1018.   re:
1019.     fxrva->dataptr = (BYTE*) ZReAlloc( fxrva->dataptr, fxrva->datalen );
1020.     if (fxrva->dataptr == NULL)
1021.     {
1022.       error_count++;
1023.       return MF_ERR_NOMEMORY;
1024.     }
1025.  
1026.   #ifdef DUMP_MSG
1027.     log("+ recalculating addresses\n");
1028.   #endif // DUMP_MSG
1029.  
1030.     // recalculate addresses
1031.  
1032.     memset(fasthooy, 0x00, (pe->pe_imagesize+1)*4);
1033.  
1034.     DWORD v = 0, p = 0;
1035.     HOOY* h;
1036.     ForEachInList(HooyList, HOOY, h)
1037.     {
1038.       if (h->flags & FL_LABEL)
1039.         fasthooy[h->oldrva] = h;
1040.  
1041.       h->newrva = v;
1042.       h->newofs = p;
1043.  
1044.       if (h->flags & FL_SECTALIGN)
1045.       {
1046.         v = ALIGN(v, pe->pe_objectalign);
1047.         p = ALIGN(p, pe->pe_filealign);
1048.       }
1049.       else
1050.       {
1051.         if (h->flags & FL_VPRESENT) v += h->datalen;
1052.         if (h->flags & FL_PRESENT)  p += h->datalen;
1053.       }
1054.     }
1055.  
1056.   #ifdef DUMP_MSG
1057.     log("+ rebuilding fixup table\n");
1058.   #endif // DUMP_MSG
1059.  
1060.     // rebuild fixup table
1061.  
1062.     DWORD xptr = 0, o = 0, xbase;
1063.     ForEachInList(HooyList, HOOY, h)
1064.     {
1065.       if (h->flags & FL_FIXUP)
1066.       {
1067.         if (o == 0)
1068.         {
1069.   c7:
1070.           xbase = (h->newrva+h->arg2) & 0xFFFFF000;
1071.           if (xptr+0+4 > fxrva->datalen)
1072.           {
1073.             fxrva->datalen += 65536;
1074.             goto re;
1075.           }
1076.           *(DWORD*)&(fxrva->dataptr[xptr+0]) = xbase;
1077.           o = 8;
1078.         }
1079.         if ((h->newrva+h->arg2) - xbase > 0xFFF)
1080.         {
1081.           if (xptr+4+4 > fxrva->datalen)
1082.           {
1083.             fxrva->datalen += 65536;
1084.             goto re;
1085.           }
1086.           *(DWORD*)&(fxrva->dataptr[xptr+4]) = o;
1087.           xptr += o;
1088.           goto c7;
1089.         }
1090.         if (xptr+o+2 > fxrva->datalen)
1091.         {
1092.           fxrva->datalen += 65536;
1093.           goto re;
1094.         }
1095.         *(WORD*)&(fxrva->dataptr[xptr+o]) = ((h->newrva+h->arg2) - xbase) | 0x3000;
1096.         o += 2;
1097.       }
1098.     }
1099.     if (o != 0)
1100.     {
1101.       if (xptr+o > fxrva->datalen)
1102.       {
1103.         fxrva->datalen += 65536;
1104.         goto re;
1105.       }
1106.       *(DWORD*)&(fxrva->dataptr[xptr+4]) = o;
1107.       xptr += o;
1108.     }
1109.  
1110.     if (xptr==0)
1111.     {
1112.       error_count++;
1113.       return MF_ERR_NOFIXUPS;         // new fixup table size == 0
1114.     }
1115.  
1116.     fxrva->datalen = xptr;
1117.  
1118.     if (*(DWORD*)fxsize->dataptr != xptr)
1119.     {
1120.       *(DWORD*)fxsize->dataptr = xptr;
1121.       goto re;
1122.     }
1123.  
1124.   #ifdef DUMP_MSG
1125.     log("+ recalculating pointers\n");
1126.   #endif // DUMP_MSG
1127.  
1128.     // recalc pointers
1129.  
1130.     int expanded = 0;
1131.  
1132.   #define SETHOOY(x,y)  HOOY* x = (y) <= pe->pe_imagesize ? fasthooy[ y ] : NULL;
1133.  
1134.     ForEachInList(HooyList, HOOY, h)
1135.     {
1136.       if (h->flags & FL_RVA)
1137.       {
1138.         SETHOOY(h1, h->arg1);
1139.         if (h1)
1140.         if (h->flags & FL_PHYS)
1141.           *(DWORD*)h->dataptr = h1->newofs;
1142.         else
1143.           *(DWORD*)h->dataptr = h1->newrva;
1144.       }
1145.       if (h->flags & FL_FIXUP)
1146.       {
1147.         SETHOOY(h1, h->arg1);
1148.         if (h1)
1149.         *(DWORD*)&h->dataptr[h->arg2] = h1->newrva + pe->pe_imagebase;
1150.         // else error
1151.       }
1152.       if (h->flags & FL_DELTA)
1153.       {
1154.         SETHOOY(h1, h->arg1);
1155.         SETHOOY(h2, h->arg2);
1156.         if (h1)
1157.         if (h2)
1158.         if (h->flags & FL_PHYS)
1159.           *(DWORD*)h->dataptr = h2->newofs - h1->newofs;
1160.         else
1161.           *(DWORD*)h->dataptr = h2->newrva - h1->newrva;
1162.       }
1163.       if (h->flags & FL_RES8)
1164.       {
1165.         *(DWORD*)h->dataptr |= 0x80000000;
1166.       }
1167.       if (h->flags & FL_FORCEOBJALIGN)
1168.       {
1169.         *(DWORD*)h->dataptr = ALIGN(*(DWORD*)h->dataptr, pe->pe_objectalign);
1170.       }
1171.       if (h->flags & FL_FORCEFILEALIGN)
1172.       {
1173.         *(DWORD*)h->dataptr = ALIGN(*(DWORD*)h->dataptr, pe->pe_filealign);
1174.       }
1175.       if (h->flags & FL_HAVEREL)
1176.       {
1177.         SETHOOY(h1, h->arg1);
1178.         if (h1)
1179.         {
1180.           DWORD t = h1->newrva - (h->newrva + h->datalen);
1181.  
1182.           if (h->arg2 == 1)
1183.           {
1184.             if ((long)t != (char)t)
1185.             {
1186.               if (h->dataptr[0] == 0xEB)
1187.               {
1188.                 h->dataptr[0]=0xE9;
1189.                 h->datalen=5;
1190.               }
1191.               else
1192.               if ((h->dataptr[0] & 0xF0) == 0x70)
1193.               {
1194.                 h->dataptr[1]=h->dataptr[0]^0x70^0x80;
1195.                 h->dataptr[0]=0x0F;
1196.                 h->datalen=6;
1197.               }
1198.               else
1199.               if (h->dataptr[0]==0xE3)
1200.               {
1201.                 h->dataptr[0]=0x09;     // or ecx, ecx
1202.                 h->dataptr[1]=0xC9;
1203.                 h->dataptr[2]=0x0F;     // jz
1204.                 h->dataptr[3]=0x84;
1205.                 h->datalen=2+6;
1206.               }
1207.               else
1208.               if (h->dataptr[0]==0xE2)
1209.               {
1210.                 h->dataptr[0]=0x49;     // dec ecx
1211.                 h->dataptr[1]=0x0F;     // jnz
1212.                 h->dataptr[2]=0x85;
1213.                 h->datalen=1+6;
1214.               }
1215.               else
1216.               {
1217.                 error_count++;
1218.                 return MF_ERR_CANTEXPAND;
1219.               }
1220.               h->arg2 = 4;
1221.               expanded++;
1222.             }
1223.             else
1224.               h->dataptr[h->datalen-1] = t;
1225.           }
1226.  
1227.           if (h->arg2 == 4)
1228.           {
1229.             *(DWORD*)&(h->dataptr[h->datalen-4]) = t;
1230.           }
1231.         }
1232.       }
1233.     } // for h
1234.  
1235.     if (expanded)
1236.     {
1237.       // +pass
1238.       goto re;
1239.     }
1240.  
1241.   #ifdef DUMP_MSG
1242.     log("+ assembling\n");
1243.   #endif // DUMP_MSG
1244.  
1245.     // assembling
1246.  
1247.     p = ALIGN( ((HOOY*)HooyList.tail)->newofs, pe->pe_filealign );
1248.  
1249.     o_phys_len = p + ovr_size;
1250.     o_phys_mem = (BYTE*)ZReAlloc(o_phys_mem, o_phys_len);
1251.     if (o_phys_mem == NULL)
1252.     {
1253.       error_count++;
1254.       return MF_ERR_NOMEMORY;
1255.     }
1256.  
1257.     ForEachInList(HooyList, HOOY, h)
1258.     if (h->flags & FL_PRESENT)
1259.       memcpy(&o_phys_mem[h->newofs], h->dataptr, h->datalen);
1260.  
1261.     if (ovr_size > 0)
1262.       memcpy(&o_phys_mem[p], &i_phys_mem[ovr_offs], ovr_size);
1263.  
1264.   } // full == 1
1265.  
1266.   // recalc csum
1267.  
1268.   MZ_HEADER* tmz = (MZ_HEADER*) &o_phys_mem[0];
1269.   PE_HEADER* tpe = (PE_HEADER*) &o_phys_mem[ tmz->mz_neptr ];
1270.   if (tpe->pe_checksum != 0)
1271.   {
1272.     tpe->pe_checksum = 0;
1273.     tpe->pe_checksum = calc_pe_csum(o_phys_mem, o_phys_len);
1274.   }
1275.  
1276.   ZFreeV((void**)&fasthooy);
1277.  
1278.   return MF_ERR_SUCCESS;
1279.  
1280. } // CMistfall::Asm()
1281.  
1282. DWORD CMistfall::calc_pe_csum(BYTE* buf, DWORD size)
1283. {
1284.   DWORD csum = 0;
1285.   for (DWORD i=0; i<size; i+=2)
1286.   {
1287.     csum += *(WORD*)&buf[i];
1288.     if (csum & 0x10000)
1289.       csum = ((csum & 0xFFFF) + 1) & 0xffff;
1290.   }
1291.   return csum+size;
1292. } // CMistfall::calc_pe_csum()
1293.  
1294. void CMistfall::markrva(DWORD x)
1295. {
1296.   if (memd[x] <= pe->pe_imagesize)
1297.   {
1298.     flag[x] |= FL_RVA | FL_DATA;
1299.     flag[memd[x]] |= FL_LABEL | FL_DREF;
1300.     arg1[x] = memd[x];
1301.   }
1302.   else
1303.   {
1304.     error_count++;
1305.     flag[ x ] |= FL_ERROR;
1306.   }
1307. } // CMistfall::markrva()
1308.  
1309. void CMistfall::markrvadata(DWORD x)
1310. {
1311.   if (memd[x] <= pe->pe_imagesize)
1312.   {
1313.     flag[x] |= FL_RVA | FL_DATA;
1314.     flag[memd[x]] |= FL_LABEL | FL_DREF | FL_DATA;
1315.     arg1[x] = memd[x];
1316.   }
1317.   else
1318.   {
1319.     error_count++;
1320.     flag[ x ] |= FL_ERROR;
1321.   }
1322. } // CMistfall::markrvadata()
1323.  
1324. void CMistfall::markfixup(DWORD x)
1325. {
1326.   if ( (memd[x] >= pe->pe_imagebase) &&
1327.        (memd[x] < pe->pe_imagebase+pe->pe_imagesize ) )
1328.   {
1329.     flag[ x ] |= FL_FIXUP;
1330.     arg1[x] = memd[x] - pe->pe_imagebase;
1331.     arg2[x] = 0;
1332.     flag[ arg1[x] ] |= FL_LABEL | FL_DREF;
1333.   }
1334.   else
1335.   {
1336.     error_count++;
1337.     flag[ x ] |= FL_ERROR;
1338.   }
1339. } // CMistfall::markfixup()
1340.  
1341. void CMistfall::markdelta(DWORD x,DWORD y,DWORD z)
1342. {
1343.   if ((y <= pe->pe_imagesize) &&
1344.       (z <= pe->pe_imagesize))
1345.   {
1346.     flag[x] |= FL_DELTA;
1347.     arg1[x] = y;
1348.     arg2[x] = y+z;
1349.     flag[y]   |= FL_LABEL | FL_DREF;
1350.     flag[y+z] |= FL_LABEL | FL_DREF;
1351.   }
1352.   else
1353.   {
1354.     error_count++;
1355.     flag[ x ] |= FL_ERROR;
1356.   }
1357. } // CMistfall::markdelta()

Есть функции, например markdelta() или markfixup().
В их теле например:
flag[x] или arg1[x] - что это? массивы? Но объявлены, не как массивы.
И как происходит эти пометки флагов?
flag[x] |= FL_DELTA; \\ "|=" - побитовое ИЛИ с присваиванием. Зачем оно здесь? Каким образом с помощью него ставится пометка?

#define mk1(x) if (t != ~((DWORD)(x)))
mk1(0x45444F43) // 'CODE'
mk1(0x41544144) // 'DATA'
mk1(0x4F545541) // 'AUTO'
mk1(0x00535342) // 'BSS\x00'
mk1(0x00534C54) // 'TLS\x00'
mk1(0x7373622E) // '.bss'
mk1(0x736C742E) // '.tls'
mk1(0x5452432E) // '.CRT'
mk1(0x494E497A) // '.INI'^'T\x00\x00\x00'
mk1(0x7865745A) // '.tex'^'t\x00\x00\x00'
mk1(0x7461644F) // '.dat'^'a\x00\x00\x00'
mk1(0x7273724D) // '.rsr'^'c\x00\x00\x00'
mk1(0x6C651141) // '.rel'^'oc\x00\x00'
mk1(0x6164085A) // '.ida'^'ta\x00\x00'
mk1(0x6164135A) // '.rda'^'ta\x00\x00'
mk1(0x6164045A) // '.eda'^'ta\x00\x00'
mk1(0x6265035B) // '.deb'^'ug\x00\x00'
mk1(0x4F521711) // 'DGRO'^'UP\x00\x00'

mk1(0x4F521711) - это смещения секций? Если да, то как они уже наперед известны?

 

Какие смещения? 0x4F 0x52 - это в ASCII "OR" Сигнатуры наверно. Вы хоть бы на коменты посмотрели.

 

Не знаю... Не сигнатуры, скорее всего.

mk1(0x4F521711) // 'DGRO'^'UP\x00\x00' - не подходит

 

glass0x

Это не смещение секций, а укороченное название: 0x4F521711 = 'DGRO' ^ 'UP\x00\x00'

Смотрите код и все будет ясно:

Код (Text):

1.       DWORD t = ~( *(DWORD*)&oe[n].oe_name[0] ^      // 8 bytes
2.                    *(DWORD*)&oe[n].oe_name[4] );
3. #define mk1(x) if (t != ~((DWORD)(x)))

В коде, видимо, ищутся секции с определенными именами.

Для справки - Название секций в заголовке PE-файла занимает 8 байт.

 

Это ксор ( XOR) двух половинок имени для длинных имен.
Для коротких получается само имя. Ну ВАЩЕ Только бы поспорить.