SilentError, קוד מקור והסברים.

[Idan Dor]

הבטחנו שנעשה את זה מתישהו אז הנה זה מגיע: קוד מקור והסברים, מאת קבוצת SilentError.

קצת על עלינו
אנחנו השתתפנו בקודגורו 9 עם שורד בשם KenGeruX (חשבנו שככה כותבים kangaroo כמעט עד התחרות, תצחקו) ובקודגורו 9.5 עם שורד בשם Paranoia – הגרסא המתוקנת של KenGeruX. אחרי קודגורו 9 החלטנו שאת התחרות הבאה אנחנו ננצח והתחלנו להעלות רעיונות ולהכין כלים (שבין השאר כוללים דיבאגר ממש טוב ששחררנו בפורום) לתחרות.
והנה, לאחר כמה מיליוני משחקים (אנחנו רציניים: הרצנו כמה מיליוני משחקים), חודשים של עבודה (כשהיה לנו זמן) והרצה נגד כל שורד בהיסטוריה של קודגורו (יש כמה מאות) 10,000~ פעמים, הכנו שורד שמנצח כל שיטה נפוצה שיש לשורדים (ישנם דברים שהוא לא מנצח אבל לא נגלה אותם). הגענו לתחרות קודגורו 10 עם כל הגרסאות של הקוד שלנו כתובות מראש ומוכנות (כדי לא לעשות טעויות כמו שעשינו עם KenGeruX), ועם ביטחון כמעט מלא שנסיים במקום ראשון.

מקור השורד שלנו
בקודגורו 9 השתתפה קבוצה בשם phobia. האסטרטגיה שלהם כללה לשים שתי מלכודות ולבדוק אותם כל הזמן תוך כדי הפצצה איטית. בשלב הראשון של התחרות הם הובילו בממש ממש הרבה, אבל כאשר אנשים שמו לב שהם אינם מעתיקים את הקוד שלהם כל הזמן מחדש ולכן הגודל הפגיע שלהם גדול מאוד, פחות או יותר כולם החליפו לשורדים שמפציצים במרחקים במקום בשורות ולכן phobia סיימה במקום השלישי בסופו של דבר. דרך ההפצצה הטובה ביותר להפצצה עם מרווחים היא call far, ול-phobia לא היה משהו שינצח מפציצים כאלו. שתי הקבוצות שיצאו במקום הראשון והשני החליפו הראשון לשורד המבוסס על 007ninja משנת 2007, והאחר לשורד המבוסס על zeus משנת 2006, שניהם מפציצי call far עם מרווחים ולכן מאוד טובים בלהרוג את phobia.
היתרון הגדול ביותר של השורד שלנו על phobia הוא ששלנו בודק את המלכודות פעם ב80~ אופקודים וכל הזמן כותב את הקוד שלנו מחדש, בעוד phobia בודקת את המלכודות שלה כל הזמן ולא כותבת את עצמה מחדש. בזמן שאנחנו מחכים השורד מפציץ בשיטה שגודלה הפגיע הממוצע הוא קטן, ואז יוצא שמרבית הזמן מאוד קשה לפגוע בנו בהפצצה רנדומלית. שיטה זאת להקטנת הגודל ממוצע הופיע גם בשורד משנת 2007 בשם hutshuts, שהיה הראשון שהשתמש במלכודות בשביל יכולת אנטי call-far ובכך ניצח את 007ninja.
בניגוד ל hutshuts- שלא תקף בכלל ו-phobia שתקפה בשורות, אנחנו השתמשנו בהפצצה עם מרווחים כדי לנצח שורדים כמו phobia, שלהם גודל פגיע גבוה.

שיטת ההפצצה שלנו
השורד המקורי של השלבים הראשונים מפציץ בשתי שיטות שונות, הראשונה היא הפצצה עם מרווחים והשנייה הפצצת שורות movsw push פשוטה ונפוצה. בגרסא הסופית שני השורדים מפציצים במרווחים, בגלל שכך קוד האתחול שלהם מהיר יותר וקצר יותר, אך אין זה אומר שזה יותר חזק מהפצצות בשתי הדרכים, זה תלוי נגד מי השורד משחק (והאם אתה משתלט על הזומבים, ואם כן מה אתה גורם להם לעשות).
רצינו להשתמש בשיטת ההפצצה עם המרווחים על מנת לפגוע בשורדים אחרים המשתמשים במלכודות, כמו phobia, ורצינו לפגוע בשורדים עם גודל ממוצע גבוהה (כאילו שרצים בלולאה גדולה למשל).
בנוסף, רצינו להשתמש ב-int 0x86 כדי להפציץ את הפקודות שלנו לסגמנט es בתחילת המשחק כמו שנפוץ לעשות בשורדים המבוססים על mamaliga, אבל כדי להפציץ במרווחים כביכול דרוש 6 בתים ולא ארבעה כמו שניתן ב int 0x86. חלק הפצצה הדורש שישה בתים לדוגמא:
Push dx
Movsw
Movsw
Sub sp, dx
Movsw
לקוד זה גודל ממוצע פגיע של 1.8 בתים והוא מפציץ במהירות של 2 בתים לחמישה אופקודים, אבל העתקה שלו הרבה פעמים ל-es היא איטית ולכן החלטנו להפציץ ל-es את הפקודות:
Movsw
Sub sp, dx
Stosw
שזה ארבעה בתים ולכן אפשרי, כך שמתקיים
mov ax, 0xa552 ;ax = push dx , movsw
ללולאת ההפצצה הזאת גם גודל ממוצע פגיע של 1.8 בתים ומהירות הפצצה של 2/5 אבל היתרון שלה, כפי שציינו מקודם, הוא שניתן לכתוב אותה ל-es בעזרת int 0x86 במחיר שלא ניתן יותר להשתמש באוגר ax למטרות אחרות.
במקרה שלנו, השתמשנו באוגר dx גם כדי לאחסן את ערך ההפצצה, גם את הערך במלכודות וגם את ההפרשים בין ההפצצות. עשינו זאת כדי לחסוך באוגרים, שהשורד דורש הרבה מהם.
### חשוב לציין כי צריך להחליף את הערך הרשום במלכודות (במקרה שלנו גם ערך ההפצצה) בין שלבי התחרות בשורדים הדומים ל-SilentError, כי אחרת אחרים יכולים לשנות את ערך ההפצצה שלהם כך שיהיה שווה לערך המלכודות וככה לא להפעיל אותם ###

הגנה מ-int 0x87
כדי ששורד יהיה מוגן מ-int 0x87 הוא צריך שכפולים של הקוד שלו מעל הקוד שהוא מריץ ומתחתיו. מכיוון שלכל קבוצה יש שני int 0x87 אז צריך שני מגנים מלמעלה ושניים מלמטה, ולהריץ את הקוד שבאמצע. מותר לשים עד שלוש פקודות לפני ה-jmp לקוד שבאמצע ואז את שלוש הפקודות האלו לא צריך להעתיק 5 פעמים. חשוב לציין שבין כל שיכפול צריך להיות שלוש פעמים הבית 0xcc (חידה למחשבה: למה חייבים לעשות את זה).
אז מה עושים אם הקוד ארוך מדי ולא ניתן להעתיק את כולו חמש פעמים? אם זהו מצבכם אז הגעתם למצב דומה לנו: הקוד של SilentError2 הוא קצר מספיק על מנת להעתיקו 5 פעמים וגם הקוד של SilentError1 קצר מספיק בשביל להעתיקו 5 פעמים, אבל לא נותר לנו מספיק מקום על מנת להעתיק את הקוד ש-SilentError1 מעתיק ל-es בתחילת המשחק חמש פעמים.
איך פותרים זאת? הצפנה. מכינים קוד (אנחנו עשינו בפייתון והוא מצורף למטה) שעושה xor של כל זוג בתים שני בקוד שמעתיקים ל-es עם ערך מוחלט מראש, ואז לאחר ההעתקה של הקוד ל-es ולאחר שהוא מוגן עושים לו xor חזרה. אם כל שלב מחליפים את מפתח ההצפנה אז לא צריך להעתיק קוד זה חמש פעמים וככה ניתן לחסוך מקום רב. (מומלץ לעשות זאת רק עם הקוד שמועתק ל-es ולא להצפין קוד אתחול כי זה מסבך את הכול).
זאת שיטה שגם שורד משנת 2009 ששמו xlii השתמש בה כאשר נתקל באותה בעיה.

מלכודות
את המלכודות שמנו במרחק מינימלי מהשורד שלנו כדי שיהיה פחות סיכוי שיפגעו בנו ולא במלכודות לפני כן. מכיוון שההפצצה המהירה ביותר כלפי מעלה היא במהירות של 4 בתים לאופקוד (call far) וההפצצה המהירה ביותר כלפי מטה היא במהירות של 2 בתים לאופקוד (rep mosvw), אז המלכודת למטה רחוקה יותר מאשר המלכודת למעלה. בשתי המלכודות שמנו ערך שחשבנו שאחרים לא ישתמשו בו בטעות ושינינו אותו בין השלבים כדי שלא יוכלו להחליף אליו.
אז יש לך מלכודת ומישהו פגע בה, מה עכשיו? אז במקרה שלנו השורד עושה שלושה דברים. הדבר הראשון שהוא עושה זה בורח בהתאם לכיוון ההפצצה, אם המלכודת למטה נפגעה אז ההנחה היא שהשורד התוקף מפציץ שורות כלפי מעלה ולכן נקפוץ מתחת לשורות ההפצצה שלו בקפיצה למטה, אם המלכודת מלמעלה נפגעת אז נקפוץ למעלה מאותה סיבה.
דבר שני: אנטי call far. עד כה ישנם רק עוד שני שורדי עבר שהשתמשו במנגנון אנטי call farוהם hutshuts משנת 2007 ו xlii משנת 2009. ל-SilentError ישנה גרסא יעילה יותר של המנגנון של xlii והיא הולכת ככה:
תקרא מהמלכודת את ארבעת הבתים הרשומים עליה (בגלל שאורך המלכודת הוא שני בתים, אז ישנן 5 דרכים לפגוע בה עם מתקפה של ארבעה בתים כמו call far, ולכן נעשה את כל הלולאה חמש פעמים).
תעשה shl register, cl כאשר cl = 4 ו-register הוא האוגר שהשתמשנו בו לקרוא את הסגמנט של הקול פאר (אצלנו זה היה bp).
תפציץ את המיקום [bp + si – 0x3] בפקודה כלשהי כאשר bp היה אוגר הסגמנט ו-si אוגר ההיסט ובכך תפגע במפציץ הקול פארי של האויב.
הדבר השלישי שאנחנו עשינו היה מנגנון אנטי שורדים מבוססי mamaliga שקבוצת phobia המציאו; המנגנון שלנו פוגע פחות מאשר שלהם אבל הוא מהיר יותר.
התהליך מתחיל כשהשורד שואל את עצמו: "אם מי שפגע בי היה mamaliga הזז למטה במהירות בית לאופקוד, היכן הוא היה נמצא עכשיו?" ואז מפציץ מיקום זה. בגלל שאנחנו בודקים את המלכודות כל שמונים מהלכים בערך, אנחנו לא יודעים היכן בדיוק האויב יהיה, אז אנחנו מפציצים אזור שלם במקום רק מקום בודד. בגלל שאנחנו רוצים לעשות זאת מהר ובגלל שעבר זמן רב בשלב זה מאז הפגיעה במלכודת יש סיכוי לא קטן שהאויב כבר ברח משם.

שימוש בזומבים
הפתרון שלנו לזומבים בתחרות נותן לנו בממוצע 7 מתוך השמונה והוא לא מושלם בעיקר כדי לחסוך זמן וזיכרון (הוא לא פתרון שפותר בסיכוי גבוה יותר את כולם בכוונה כדי לחסוך זמן וגודל שורד, אלא פותר "מספיק טוב"). הוא פתרון מוזר שכולל לקיחת מספר שמצאנו בעזרת סקריפט והפעלת פעולה מתמטית עליו 16 פעמים, כאשר כל פעם רושמים מספר זה לזומבים (בעזרת שימוש בשש עשרה מספרים שונים אפשר להגיע לפתרון יותר טוב אבל אז צריך לזכור את כל השש עשרה במקום רק את הראשון). לאחר שהשתלטנו עליהם אנחנו הופכים אותם לשורדים בסיסיים מאוד שפשוט עושים movsw push כל הזמן. הרעיון הוא שאנחנו מוגנים מהם ומתישהו נהרוג אותם לאחר שהם הרגו אחרים, ושאם אנחנו כבר מתים אז שהם יהרגו אחרים בלי למות ובכך "יגנבו" ניצחונות מאלו שהרגו אותנו.
איך מנצחים את SilentError
זה משהו שאנחנו לא נגלה לכם, אבל אנחנו מבטיחים לכם שיש אסטרטגיות קצת מוזרות אבל מאוד מאוד אפקטיביות נגד SilentError וכל דומיו. ישנם שורדי עבר שמשתמשים באסטרטגיות שכאלו, בהצלחה בחיפוש.

לסיכום
מצורף פה קוד המקור של השורד מהשלב השלישי עם הערות. הקוד בשורד אינו מעותק חמש פעמים מכיוון שזה סתם מבלבל ומקשה על קריאת הקוד, אבל בתחרות עצמה כן העתקנו את הקוד חמש פעמים.
על מנת לקמפל את השורד יש להשתמש באסמבלר בשם FASM ובסקריפט פייתון המצורף.
לינק להורדת :fasm http://flatassembler.net/download.php.
צריך שהסקריפט ירוץ ככה ש /survivors יוביל אותנו לתיקיית השורדים של המנוע, /SurvivorCode יביא אותנו לתיקייה שבה שני קבצי asm: silenterror1 ,silenterror2, וש-/Assemblers/fasm יוביל אותנו לתיקייה של fasm.
אם יש לכם שאלות אתם מוזמנים לשאול ונשמח לענות לכם. את הסקריפט יש להריץ עם הערך "0x6464" כדי שהוא יעבוד לגרסא זאת של השורד.
עידן דור ויואב קמפפר מקבוצת SilentError.
 
#####Python Encrypter#####
import os
import random
import subprocess

SRC_DIR = '.\\SurvivorCode'
FASM_DIR = '.\\Assemblers\\fasm'
DEST_DIR = '.\\survivors'

XOR_FLAG = bytearray((int(0xA4), int(0xFF), int(0xE5), int(0xcc), int(0xcc), int(0xcc), int(0xa5)))

def FASM(file):
subprocess.Popen(FASM_DIR + '\\fasm ' + SRC_DIR + '\\' + file,
shell=False, stdout=subprocess.PIPE).wait()

def Move_File(file):
try:
os.remove(DEST_DIR + '\\' + os.path.splitext(file)[0])
except WindowsError:
pass
os.rename(SRC_DIR + '\\' + os.path.splitext(file)[0] + '.bin', DEST_DIR + '\\' + os.path.splitext(file)[0])

def XOR(file, key):
ba = None
with open(DEST_DIR + '\\' + os.path.splitext(file)[0], 'rb') as f:
ba = bytearray(f.read())
i = ba.find(XOR_FLAG) + len(XOR_FLAG) – 1
while i + 1 < len(ba):
ba[i] ^= key % 0x100
ba[i + 1] ^= int(key / 0x100)
i += 4
if i < len(ba):
ba[i] ^= key % 0x100
with open(DEST_DIR + '\\' + os.path.splitext(file)[0], 'wb') as f:
f.write(ba)

def Put_Key(file, key):
with open(DEST_DIR + '\\' + os.path.splitext(file)[0], 'ab') as f:
f.write(bytearray([key % 0x100, int(key / 0x100)]))

###Main Code###

def Start():
#key = random.randint(257,65535)
key = int(raw_input('Please enter the key: '), 16)
for file in os.listdir(SRC_DIR):
FASM(file)
Move_File(file)
if os.path.splitext(file)[0][-1] == '1':
XOR(file, key)
elif os.path.splitext(file)[0][-1] == '2':
#Put_Key(file, key)
pass

#print('Key: ' + hex(key))
#raw_input('Press ENTER to exit')

if __name__ == '__main__':
Start()
 
;-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-SURVIVOR 1-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-

bombing_loop_length = 0x48 ;the section of the int 0x86 bombarding code that the survivor does
trap_distance_up = 0x83 + bombing_loop_length/4 + 1 ;distance between the start of the code and the top trap
trap_distance_down = 0x2ca ;distance between the start of the code and the bottom trap
jump_length = 0x500 ;distance that the survivor jumps
anti_mamaliga_distance = 0xe0 ;Calculated
anti_mamaliga_bombing_length = 0x3a ;Calculated
starting_modifier_DONTCHANGE = 0x2

zombie_address_location = 0x1000
sp_modifier = 0x6c6c ;the distance between each bomb – 2 (because the push also does – 2), the bomb itself and the memory in the traps

;Jumps to the real part of the code
@AXStart:
mov si, 0xa5ab ;stosw movsw
mov dx, 0xd429 ;sub sp, dx
mov bp, word [zombie_address_location] ;it is allowed to do 3 commands and still being int 0x87 protected
jmp @Start

;Place junk here

@Start:

;Loading code to extra segment
add ax, @CodeAtStart – @AXStart
xchg si, ax
movsw
movsw
movsw
movsw ;copying the code at @CodeAtStart to es
int 0x86 ;bombarding the bombing commands into es
sub di, 0x100 – bombing_loop_length
mov cl, (@CodeEnd – @CodeAfterBombing + 1)/2
rep movsw ;coping the rest of the code into es

;Changing Segments
push ds
push es
push ds
pop es
pop ds
pop ss ;ss, es, cs = arena ds = extra segment

;int 0x87 things, change them if you wish to use int 0x87, we placed something here between the phases depending on who we were against.
mov ax, 0x0000
mov dx, 0x0000
int 0x87

;Resetting everything and jumping to correct spot
lea sp, [bp – trap_distance_up + 0x2]
mov di, bp ;resetting registers to starting location
mov ax, 0xa552 ;ax = push dx , movsw
mov si, @CodeAtStartEnd – @CodeAtStart
mov dx, sp_modifier ;this is the distance between each bomb, and the bomb itself, and the memory in the traps
push dx ;placing the trap above
mov word [bp + trap_distance_down], dx ;placing the trap below
mov word [bp + 0x13], 0xe1ff ;letting the zombies loose by changing jmp $ to jmp cx
movsb ;starting to write the code for the survivor from es
jmp bp ;bp = code starting location

DB 0xcc
DB 0xcc
DB 0xcc
;(Full flag is 0x A4 FF E5 60 which is movsb, jmp bp, db 0xcc, db 0xcc, db 0xcc, movsw)

;Here starts the code that the survivor copies to es
;Here are the commands that make the survivor jump up each time
@CodeAtStart:
movsw
movsw
movsw
mov di, bp
movsb
jmp bp
@CodeAtStartEnd:

;In here the survivor places his bombing loop using int 0x86

;This is the code after the bombing loop
@CodeAfterBombing:
;This code loads the code that checks the bottom trap
@CompareTrapsLoader:
movsw
movsw
mov cl, (@CompareTrapsEnd – @CompareTraps) / 2
movsw
movsw ;This is to allow the 'xor si, si' even though it makes it odd length
rep movsw
;This code compares both traps against each other
@CompareTraps:
mov bx, [bp + trap_distance_down]
cmp [bp – trap_distance_up], bx
jnz @Continue1
xor si, si
@Continue1:
movsw
@CompareTrapsEnd:

;This code loads the code that defines which trap was bombarded
@JumpLoader:
movsw
mov cl, (@JumpEnd – @Jump) / 2
movsw
rep movsw
;This code defines which trap was bombarded
@Jump:
cmp bx, dx
lea bx, [bp + trap_distance_down – 0x3]
jnz @Continue2
sub bp, jump_length * 2
sub bx, trap_distance_down + trap_distance_up
@Continue2:
add bp, jump_length
mov di, bp
movsw
jmp bp
DB 0x64 ;THIS IS TO MAKE IT AN EVEN LENGTH
@JumpEnd:

;This code loads the code that is used to kill call far users
@AntiCallFarLoader:
movsw
mov cl, (@AntiCallFarEnd – @AntiCallFar) / 2
movsw
rep movsw
;This code is anti call far and is used to kill call far users
@AntiCallFar:
mov cx, 0x504
xchg bx, sp
mov dx, bp
xchg ax, si
@KillLoop:
pop si
pop bp
shl bp, cl
mov word [bp + si – 0x3], bx ;bx = random number, the last location of bombing
sub sp, 0x3
dec ch
jnz @KillLoop
@KillLoopEnd:
xchg si, ax
movsw
@AntiCallFarEnd:

;This code loads the code that resets the registers and makes them ready for anti mamaliga
@ResetRegistersLoader:
movsw
mov cl, (@ResetingRegistersEnd – @ResetingRegisters) / 2
movsw
rep movsw
;Reseting the Registers that had to be changed to do the anti call far
@ResetingRegisters:
xchg sp, bx
add bx, anti_mamaliga_distance – 2
mov ax, sp_modifier
mov bp, dx
movsw
@ResetingRegistersEnd:

;This code loads the code that kills mamaligas
@AntiMamaligaLoader:
movsw
mov cl, (@AntiMamaligaEnd – @AntiMamaliga) / 2
movsw
movsw ;This is to allow the this part to have odd length
rep movsw
;This code kills mamaligas and similar survivors
@AntiMamaliga:
mov cl, anti_mamaliga_bombing_length
xchg bx, di
std
rep stosw
mov di, bx
cld
movsw
@AntiMamaligaEnd:

;This code loads the code that first gets ran after the jump to the new location
@MakeTrapsLoader:
movsw
mov cl, (@MakeTrapsEnd – @MakeTraps) / 2
movsw
movsw
rep movsw
;This code happens after the jump and it makes new traps at the new location
@MakeTraps:
mov word [bp – trap_distance_up], ax ;placing the trap above
mov word [bp + trap_distance_down], ax ;placing the trap below
xchg dx, ax
mov ax, 0xa552
xor si, si
movsw
@MakeTrapsEnd:

@CodeEnd:
 
;-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-SURVIVOR 2-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-l-

bombing_loop_length = 0x48 ;the section of the int 0x86 bombarding code that the survivor does
trap_distance_up = 0x83 + bombing_loop_length/4 + 1 ;distance between the start of the code and the top trap
trap_distance_down = 0x2ca ;distance between the start of the code and the bottom trap
starting_modifier = 0xfef

;THIS FOUR NEED TO BE CHANGED BETWEEN PHASES
zombie_address_location = 0x1000
xoring_key = 0x6464
zombie_key = 0xbd4
sp_modifier = 0x6c6c ;the distance between each bomb – 2 (because the push also does – 2), the bomb itself and the memory in the traps

;Jumps to the real part of the code
@AXStart:
add ax, @ZombieCode – @AXStart
mov word [zombie_address_location], ax ;it is allowed to do 3 commands and still being int 0x87 protected
mov bx, zombie_key
jmp @Start

;Place junk here

@Start:
;Acquring zombies
mov cl, 0x10
mov bp, es
@ZombieHunter:
mov di, 0x2
mov word [0x2015], bx
mov word [bx], 0x5f0e ;actual command is 'push cs, pop di, call word [di]'
mov word [bx + di], 0x15ff ;writing to the zombies where to jump so as to get to the zombie code in SilentError2
rol bx, 0x1
dec bx
push cs
push es
nop
loop @ZombieHunter

;Acquire encryption key
xchg bp, ax
mov bx, xoring_key

;Changing segments
pop ds
pop es

;Decrypting the code at the extra segment
xor word [si], bx ;si = 0x0 but it makes the opcode length shorter
xor word [si + 0x4], bx ;si = 0x4 but it makes the opcode length shorter
mov si, bombing_loop_length + 0x8
mov cl, (0x95 + 0x3)/0x4
@XoringLoop:
xor word [si], bx
add si, 0x4
loop @XoringLoop

;int 0x87 things, change them if you wish to use int 0x87, we placed something here between the phases depending on who we were against.
mov ax, 0x0000
mov dx, 0x0000
int 0x87

;Continue changing segments
push cs
pop ss

;Resetting everything and jumping to correct spot
sub bp, starting_modifier
lea sp, [bp – trap_distance_up + 0x2]
mov di, bp ;resetting registers to starting location
mov ax, 0xa552 ;ax = push dx , movsw
mov si, 0x8
mov dx, sp_modifier ;this is the memory in the traps, bombing distance and bombing value
push dx ;placing the trap above
mov word [bp + trap_distance_down], dx ;placing the trap below
movsb ;starting to write the code for the survivor from es
jmp bp ;bp = code starting location

;Place junk here

DB 0xcc
DB 0xcc
DB 0xcc

DB 0xcc ; this is junk that needs to be replaced with more junk

@ZombieCode:
push cs
pop ss
and cx, 0xe000
add ch, 0xf
add cx, word [di]
mov sp, cx
mov di, cx
mov ax, 0xab50
stosw
jmp $

@TrueEnd:

[מאת]

תגובות