שלום לכולם,
עברתי קצת על הפורום ועל השאלות הנפוצות לפני שכתבתי את ההודעה הזאת.
רציתי לשאול אותכם שאלה שמסקרנת אותי די הרבה זמן,
כולם מדברים על לינוקס ותוכנות רבות שבאות איתה ובשבילה בתור תוכנות שהן קוד פתוח
ולכן אפשר לשנות ולעדכן דברים וגם לראות איך היא בדיוק עובדת.
ואני שומע הרבה לאחרונה על תהליך שנקרא reverse engeneering.
והבנתי שאיתו אפשר בעצם לקחת תוכנה ולהחזיר אותה למצב שלפני ה-compile
אז למה בעצם אי אפשר לעשות את זה לדוגמא לכל תוכנה? כמו למשל windows או כל דבר אחר
ובעצם לראות אותו כקוד פתוח... ?
והשאלה השניה היא:
אני רוצה להתחיל לתכנת בג'אווה, זאת הפעם הראשונה שאני מתכנת ולכן רציתי לדעת איפה אפשר למצוא מדריך למתחילים בתכנות אבל שיהיה מאוד מקיף על ג'אווה ובעברית...
אגב, אני ידוע שיש שפות שעדיף להתחיל לתכנת איתם מעצם היותם "קלות" יותר או "הגיוניות" יותר בצורת התכנות שלהם, אבל אני חייב להתחיל עם ג'אווה בשביל פרוייקט מסוים.
תודה לכולם.

God created the animals, We created God.

הנדסה לאחור זה בעצם נעשה ע"י מתכנת וכמה כלים שמתאימים .
הוא רואה מה קורה נגיד כשלוחצים על OK והוא מתאם לעצמו דברים לפי הבדיקה שלו.

יש משהו אחר שהוא בעצם כלי של הנדסה לאחור בערך .. זה נקרא DEASM (דיאסמבלי או דיקומפיילר).
זה הופך קוד מכונה לקוד של שפת אסמבלי שהיא שפה של פקודות מאוד קטנות בכל הקשור למעבד/זיכרון והמחשב.

לשפות כמו JAVA וC# יש מין מתאם כזה שהופך את הקוד לשפת מכונה אז כאן נוטצרת קצת בעיה
אם אתה רוצה לראות את הקוד.

כעקרון בC++/C אתה הופך קוד לשפת סף (אסמבלר) ואז כמות של פקודות או פקודה בודדת בשפה יהפכו לפקודה אחת בC++ / C . אבל צריך ממש הרבה עבודה בשביל לבנות תוכנה שעושה את זה.
למרות שקיימות כאלו חלק מהפעמיים הן לא יעשו את זה טוב.

/* לשפות כמו JAVA וC# יש מין מתאם כזה שהופך את הקוד לשפת מכונה אז כאן נוטצרת קצת בעיה
אם אתה רוצה לראות את הקוד. */

דווקא לשחזר קוד ג'אווה בעזרת RE, נחשב לפעולה קלה, לא דורשת הרבה מאמצים.
לכן, נהוג להשתמש ב-obfuscator, מה שיקשה על התהליך, והקוד שתקבל אינו תמיד שימושי.

C pogrammers never die. They are just cast into void.

דבר ראשון עושים את זה בשביל להבין את הפרוטוקול של התוכנה ולכתוב אחת מותאמת לצרכים שלך...
ועם כבר אז כל מה שיוצא מזה זה תוצר שעושה אותו הדבר אבל אתה לא תידע בידיוק מה זה היה אתה יכול רק לנחש איזו פקודה הריצו בשביל להגיע לתוצאה או לפלט מסויים... כמו למלש:

קוד:

int i = 0;
while(i<50)
i++;
יעשה אותו דבר כמו:
for(i=0;i<50;i++)

אבל אתה לא תידע עם זה מה שבאמת נעשה

GNU/Linux - Use the source!

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://petition.mac-it.co.il/promote/buttons/petition_text_less.gif]

למישהו יש אולי מדריך בעברית מלא ומפורט לתכנות ב-java שממש יתחיל מההתחלה ובסוף לנושאים מתקדמים יותר ?
תודה :]

GNU/Linux - Use the source!

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://petition.mac-it.co.il/promote/buttons/petition_text_less.gif]

למעשה כמעט אי אפשר להפוך תוכנה מהודרת מעל כמה מגה לקוד מקור מכמה סיבות.
לפי הבנתי, הבעיה הכי גדולה היא שפקודות הקובץ שמורות כמחרוזת רציפה של מספרים בלי הפרדות. גם הסגמנטים לא מופרדים בבירור.
מה שיוצר בעיה לדוגמה כשיש הגדרות משתנים data בתוך הקוד code. במיוחד אם ההגדרה קצרה. אתה צריך לנחש מה משתנים ומה פקודות. וזו בעיה.

כמו כן כמובן שלא תקבל את שמות המשתנים וכדו' אלא רק כתובות אל המשתנים. בקיצור, קשה מאוד לעבוד עם זה.

יש מפתח אסמבלר צרפתי אחד שאני מכיר שמנסה לאפשר דיסאסמבלי (תרגום לאסמבלר) של קבצים בצורה מלאה שיהיה אפשר אחר כך אפילו לקמפל אותם.
בינתיים זה עובד עם קבצים עד מגה וגם אז לא תמיד.

http://betov.free.fr/SpAsm.html
http://betov.free.fr/RosAsm2028a.zip - אם מישהו מתכוון באמת להוריד אז לאחר ההורדה מהקישור הקודם של כל האסמבלר יעדכן את ה exe מפה.

Download the PDF file from this site - I believe it would be a good way to start
http://www.mh2000.co.il/java

Good luck!

בנוסף למה שאמרו פה חלק מהעניין של קוד פתוח זה החוקיות. בפרויקט קוד פתוח מותר לך לעשות מה שבא לך. גם אם תצליח לעשות ריברס אנג'נירינג לתוכנות קוד סגור לא תוכל לשנות אותן במסגרת החוק.

קודם כל, RE אינו תהליך של לקחת קוד מקומפל ולהחזיר אותו לשפת המקור, אלא לקחת קוד מקומפל ולהבין מה הוא עושה ואיך.

אכן כמו שצויין כאן זהו תהליך שנעשה ע"י מתכנת\ים מוכשר\ים ומספר כלים מיוחדים שאחד מהם הוא הdisassembler כלי הלוקח קוד מקומפל ומספק קוד אסמבלי - קוד שהוא יותר מובן מאשר רצף של ערכים.
הבעיה היא, שפעול הdisassemble אינה חד ערכית. כלומר, כאשר חסרים מספר נתונים - שלא מסופקים לך עם קוד מקומפל - פעולת הdisassembly אינה נכונה במאה אחוז - אלא מספר שמאד קרוב למאה אחוז.

רוב הפעמים, אפליקציה סטנדרטית שקומפלה בכלים ידועים ומוכרים ללא טריקים ואופטימיזציות מתוחכמות תוכל לעבור disassembly נכון. אבל חלק מהפעמים הקוד הdisassembled לא יהיה נכון במאה אחוז.

בנוסף, קוד שקומפל בשפות OOP, עם קוד שהוא autogenerated זה קוד שמאד קשה להבין אותו מהאסמבלי דאמפ שלו. (לדוגמא - אפליקציות MFC)

בנוסף, המון אפליקציות עוברות תהליכים של anti-debugging תהליכים שמקשים, לעיתים מאד לעשות RE לקוד שכבר ככה מאד קשה לעשות לו RE בגלל המאפיינים שציינתי קודם.

בנוסף - קוד שכתוב בשפה עילית כלשהי יכול להתקמפל בכמה צורות - נגיד שהקוד קומפל בקומפיילר ידוע מראש - אז הפלט יהיה זהה תמיד (טוב כמעט תמיד)
אבל הפעולה ההפוכה - קוד אסמבלי --> קוד בשפה עילית - קוד אסמבלי יכול להתפרש ככמה קטעי קוד שונים באותה שפה עם אותו אפקט. (דבר שמסתבך בהרבה כשיש אופטימיזציה)

כאשר מתכנת כותב קוד בשפה עילית הוא מוסיף לעיתים קרובות (במקומות עבודה מסודרים עם צוותי עבודה ונהלי כתיבת קוד מוגדרים מראש אז זו אפילו הגישה הרווחת) המון קוד - הגדרות משתנים למיניהם דפוסי קוד והערות על מנת שיהיה קל להבין את הקוד.

קוד יכול להיות להיות שואה להבין, גם כשמוסיפים את כל הדברים האלו.
אז בתהליך של RE זה עלול להיות אפילו יותר נורא.


בגדול RE נעשה בדרך כלל לחלק קטן של אפליקציה כדי להבין פעילות ספציפית - כמעט ולא עושים את הפעולה הזו על מערכת גדולה - מסובך מדי וקשה מדי

Subtle and insubstantial, the expert leaves no trace; divinely mysterious, he is inaudible.
Thus he is the master of his enemy's fate.

well said, my friend

Subtle and insubstantial, the expert leaves no trace; divinely mysterious, he is inaudible.
Thus he is the master of his enemy's fate.

סלחו לי שאני חולק עליכם בנק אחת קטנה אבל disassembly יכול להיות חד ערכי.
כל פקודה בשפת אסמבלי שקולה (תיאורטית) לשפת מכונה מאוד מצומצמת (פקודה בודדת בשפת מכונה למעט מקרים מיוחדים) וישנן גם גרסאות של אסמבלי שבהן התנאי של פקודה יחידה נאכף.

בהנחה שהכלי בו אתה משתמש עובד נכון ושאתה מתכנת טוב, יודע אסמבלי טוב ומכיר את הארכיטקורה הרלוונטית היטב, (ממש אין לי שום דרישות ) אין סיבה שלא תוכל להמיר בין קוד מכונה לאסמבלי כרצונך. דברים כאלו אף נעשים ומנוצלים בתעשיה לכלים המבצעים Binary transaltion ו Binary instrumentation במיוחד בהקשר של פירוש של קפיצות מותנות וקד המשכתב את עצמו כאשר רוצים לבצע אינסטרומנטציה סטטית (כלומר, בהפשטה, המרת קוד קיים לקוד חדש pre-run והכנסת "hooks" חדשים שלנו, לרוב במטרה לנתח ביצועים של קוד מסויים).
לינק למתעניינים באינסטרומנטציה: http://research.sun.com/techrep/200...tr-2002-105.pdf

חוץ מזה, אני בהחלט מסכים well said (וכמובן יש את העניין הקטן הזה של רישוי). וממילא, אתה צריך צוות של גאונים כדי לפענח קוד מורכב וארוך בשפת אסמבלי בלי הערות לכדי הבנה ברורה מה קורה, מתי, איפה ולמה.

--
גל דיסקין (gal diskin)

עצות והמלצות:

פעולת הdisasembly לא תמיד תהיה חד ערכית.
ברוב המקרים, בהנחה שאתה מכיר את הקומפיילר שייצר את הקוד, תוכל לעשות את הפעולה והיא תהיה נכונה ברוב הכמעט מוחלט של המקרים.

הבעיה בפעולת הdisasmble נובעת מעניין של אופסטים.
כלומר, אם תקח קטע קוד ותתחיל לעשות לו disasmbly
מoffset אפס
יצא לך פלט שונה לגמרי אם תתחיל מoffset אחד

בנוסף יש מקרים בהם יש לך data בתוך הקוד דבר שדופק את כל הdisassembly
וכמובן שיש לך טכניקות של anti-debugging המקרה הקלאסי של קפיצה לתוך opcode

לכן disassembly היא לא פעולה חד ערכית

Subtle and insubstantial, the expert leaves no trace; divinely mysterious, he is inaudible.
Thus he is the master of his enemy's fate.

...לא יצא לי לבקר בזמן האחרון.


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

--
גל דיסקין (gal diskin)

עצות והמלצות:

סבבה אז בגדול, חוץ מהמשפט הראשון אנחנו מסכימים

כל עוד יש אי הסכמה, אפשר להמשיך להתווכח - w00t!

אני לא הבנתי למה אתה מתכוון אם יש בידך מקור בינארי שלם - מילים גדולות בשביל איש קטן כמוני

מה זאת אומרת מקור בינארי שלם?

אתה מקבל אפליקציה מוכנה מחברה.
האפליקציה מכילה executables וdllים ושיט כזה...
אם יצא לך קצת להתעסק עם קבצי pe כל קובץ הרצה בנוי מsections שהsection שרלוונטי לדיון הוא הוא code section או הtext section (לא חייב להופיע אבל אם אנחנו מדברים על הסטנדט אז הוא מופיע)

עכשיו נק' נוספת שיש לך לעניין היא הentry point של האפליקציה - שהיא כתובת, סביר להניח שבתוך הtext section שממנה מתחילה התוכנית לרוץ
אבל הנק' הזו היא לא תחילת הקוד הsection, אלא תחילת הריצה.

ומניסיון - בלי ניתוח מתקדם למדי קשה לדעת מתי בדיוק התחיל הקוד...

אחת השיטות לעשות את זה הוא מעבר על כל הקפיצות בקוד ולראות איפה נעשת קפיצה שהכי קרובה לתחילת הקוד section...

וכאן יש עוד בעיות וגם להם יש פתרונות שונים.

בסופו של דבר, ברוב המקרים, קוד שלא נעשה עליו מהלכים של antidebugging אפשר לעשות כל מיני הנחות מקלות - קוד כזה הרי נוצר באופן אוטומטי לכן קל לזהות patterns ולהסתמך עליהם וכו' וכו'

בסופו של דבר, בכל תהליך של anti-debuggin נעשות הנחות כלשהן שאין להן אסמכטה במאה אחוז והסתמכות על זיהוי של patterns וכדומה.

לי יצא לא פעם לפתוח קובץ בida ולהשתמש באופציה שנותנת להגיד לו - הinstruction מתחילה בכתובת A ולא כתובת B כמו שהוא חשב.

אז בסופו של דבר הנק' שלי היא כזו.
פעולת הDisassembly לקבצי הרצה בינארים אינה פעולה חד ערכית.

כאשר יש לך dump בינארי כלשהו, ויש לך את כתובת ההתחלה, ואתה יודע את כתובת ההתחלה של הקוד, יודע שכל alignment בין פונקציות וקטעי קוד שונים מכיל רק פקודות שמורכבות מבית אחד (כמו 0x90 שזו הפקודה nop או 0xcc שזו הפקודה int 3) אז כן, הפעולה היא חד ערכית...
אבל שוב כאן, אנחנו עושים המון המון הנחות מקלות (לדוגמא - אם תסתכל בקבצי התוצר של visual studio 2005 אתה תראה שalignment בין sections מכיל איזושהי מחרוזת - לא זכור לי בדיוק מה כתוב אבל כתוב משהו, וזה כאן שוב דופק לך את העניין כי הalignment בין הsections דופק לך את הdisassembly - למרות שגם את זה אפשר לעקוף... אבל בכל זאת...)

Subtle and insubstantial, the expert leaves no trace; divinely mysterious, he is inaudible.
Thus he is the master of his enemy's fate.

מאחר שמערכת ההפעלה יכולה לדעת מהי ה entry point גם קוד אחר יכול אם הוא עובד בצורה נכונה. אין ספק שיש הרבה קשיים, במיוחד אם נעשה מאמץ ליצור קשיים, אבל ברמת האסמבלר לשפת מכונה, תרגום מדוייק אפשרי. ברמת עץ ההרצה, חלוקה לפונקציות וכן הלאה, מובן שזה דורש הרבה מיומנות ויכולת אנושית מסויימת, במיוחד אם הוכנס מרכיב מכוון כלשהו של רנדומליות בערבול הקוד.

לגבי מקור בינארי שלם - לעיתים אתה מוצא בידיך רק ספריה או חלק מהמקור הבינארי (החיים קשים, הקו נותק או שניתקת אותו בפראנואידיות לפני שסיימת להעביר הכל, היו הפרעות בתקשורת - אולי לא בדור הזה אבל לפני 12 שנים בערך זו הייתה בעיה נפוצה, ועוד סיבות משונות). שחזור מקוד חלקי, לא יידוע או שקורא בזמן הריצה לספריה לפי קלט תלוי משתמש (ותתפלא, ראיתי כאלו נסיונות להגנות), מגיע לדרגות שבלתי אפשריות מתמטית, אפילו אילו עמד לרשותך כל כח החישוב בעולם. שחזור של קוד קיים ניתן לביצוע בזמן סביר יחסית לאורך הקוד (כולל ספריות וצרות אחרות) לקוד אסמבלי טהור, אך לא בהכרח מובן לבני אדם. זה מה שניסיתי להגיד.

ויש לי הרגשה שיותר משאנחנו מתווכחים אנחנו מתאמים מושגים בינינו.
בכל מקרה, עושה רושם שלמעט אולי עוד 2-3 אנשים, הדיון שלנו לא זוכה אפילו לקוראים בפורום (אם אני טועה, לפחות תכתבו איזו מילה שהדיון מעניין אתכם). אפשר תמיד להמשיך אותו בפרטי במידת הצורך אם אין עניין לציבור או שיש צורך לדון בנושאים שמוטב שלא יהיה בהם עניין לציבור.

עריכה:
אני בכוונה נמנע מלדון לעומק בקשיים המעשיים עצמם - הם אינם הנקודה לדעתי.

--
גל דיסקין (gal diskin)

עצות והמלצות: