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

עמוד

הדיון הזה מכיל 0 תגובות, ויש לו משתתף 1, והוא עודכן לאחרונה ע״י  Idan Dor לפני 4 שנים, 4 חודשים.

מוצגות 1 תגובות (מתוך 1 סה״כ)
  • מאת
    תגובות
  • #83157

    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:

מוצגות 1 תגובות (מתוך 1 סה״כ)

יש להתחבר למערכת על מנת להגיב.