תחומים - פורום חרדי מקצועי

אני חייב המון הכרת הטוב לפורום הזה

את הפוסט הראשון שלי כתבתי ככל הנראה לפני בדיוק (כמעט...) 8 שנים
מאז הצלחתי לצבור פה כ-6,200 פוסטים (ממוצע של כ-2.1 פוסטים ליום!). חלקם פוסטים ממש מושקעים. הרבה מהם בלי הרבה מאמץ או מחשבה (ועל כך התנצלויותיי...)

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

קיבלתי המון המון תועלת מכל הנ"ל.

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

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

תודה ל @dovid ולכל מי שעשה את המקום למה שהמקום היה

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

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

אגב,
יש באג בקוד שלך (וגם @לי-ראש לא תיקן אותו)
אחרי סוף הלולאה, המצביע rdi לא מצביע על תחילת המחרוזת, אלא בית אחד לפני התחילה. למה? כי בכל איטרציה של הלולאה אתה מוריד 1 מ-RDI, גם באיטרציה האחרונה
התוצאה היא שאתה מדפיס 7 בתים לקונסול במקום ה-6 שהתכוונת להדפיס ("10000\n")
בפועל, ההתנהגות של הקונסול של ווינדוס הוא שהוא מתעלם מפלט של null bytes אז זה לא מזיק, אבל זה לא תקני

עוד הערה:
בתוכנה שכתבת עבור לינוקס אתה משתמש בפונקציה write כדי לכתוב ל-stdout
פה אתה משתמש בWriteConsoleA שהוא כותב רק לקונסול, לא לכל stdout שמוגדר
בתוכנות שורת פקודה יותר נפוץ להשתמש בWriteFile כדי שזה יעבוד על כל סוגי stdout, אלא אם כן מסיבה כלשהו אתה בדוקא רוצה לכתוב רק לקונסול.
(עיין כאן ליותר הסבר על stdout)

@לי-ראש למרות שהתוכנה שלך עובדת היא פחות נכונה מכמה טעמים

השורות 18 ו19 מיותרות לחלוטין.

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

גם את השורות 33, 34 ניתן לפשט

במקרה מה שעשית עובד, אבל זה לא תקני, כי ב-calling convention של ווינדוס אתה לא יכול לסמוך ש-rad ו-rdx ישמרו על הערך שלהם אחרי חזרה מקריאת פונקציה (הם מה שנקרא volatile registers) והדבר התקני הוא לשמור את ערכן במקום לא volatile לפני הקריאה ל-GetStdHandle

3. השמטת את הפרמטר החמישי ל GetStdHandle. אני לא יודע אם בכוונה

mov     qword [rsp+32], 0

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

4. השמטת את הקריאה ל-ExitProcess. אני לא יודע אם זה בכוונה, אבל זה גורם לתוכנה לקרוס

@שאלתיאל קודם כל צריך שיהיה לך מבט-על של מה התוכנה עושה, התמונה הכללית

בעיקרון מדובר בקוד שעושה פעולה מיותרת (אין לי ביקורת על זה, זה טוב ללמידה)
יש החלטה שרירותית בתוכנה שאתה הולך להדפיס את המספר 10000 כמחרוזת, אבל במקום להזין את זה כמחרוזת מלכתחילה, אתה מזין את זה כמספר ואז ממיר למחרוזת
להזכירך: המספר 10000 בבינארי זה 10011100010000, איך מקבלים מזה את המחרוזת "10000"?

האלגוריתם להמיר מספר בינארי n למחרוזת s בייצוג דצימלי הוא כזה (בפסאודו קוד) :

while n > 0:
  d = n % 10
  s = d + s
  n = n / 10

️ הפעולה % היא "מודולו", ופעולת החילוק כאן היא חילוק אינטגרלי (מספר שלם) בלי השארית.

ניקח לדוגמה את המספר 1234.

המצב ההתחלתי:

n = 1234
d =
s = ""

הנה השלבים המלאים:

• n > 0? ⇐ כן!
• d = n % 10 ⇐ תוצאה: d = 4
• s = d + s ⇐ תוצאה: s = "4"‎
• n = n / 10 ⇐ תוצאה: n = 123

---

• n > 0? ⇐ כן!
• d = n % 10 ⇐ תוצאה: d = 3
• s = d + s ⇐ תוצאה: s = "34"‎
• n = n / 10 ⇐ תוצאה: n = 12

---

• n > 0? ⇐ כן!
• d = n % 10 ⇐ תוצאה: d = 2
• s = d + s ⇐ תוצאה: s = "234"‎
• n = n / 10 ⇐ תוצאה: n = 1

---

• n > 0? ⇐ כן!
• d = n % 10 ⇐ תוצאה: d = 1
• s = d + s ⇐ תוצאה: s = "1234"‎
• n = n / 10 ⇐ תוצאה: n = 0

---

• n > 0? ⇐ לא.

הלולאה הסתיימה וקיבלנו:

s = "1234"

הנקודה החשובה לשים לב אליה הוא שהמספרים מתקבלים מימין לשמאל, כלומר מהסוף להתחלה

לכן בתוכנה שלך הלולאה עוברת על הבאפר מהסוף להתחלה

כדי למלאות את הבאפר מהסוף להתחלה, המצביע RDI מתחיל בהצבעה על buffer+7 ואז עובר ל-buffer+6, עובר ל-buffer+5 וכן הלאה

עדיין לא מובן? תשאל שוב

ולמה בתוך הלולאה (שורה 27) מחסרים אחד מ-RDI, זה כן הבנת?
בגדול הקוד עובר בסדר הפוך על הבתים של הבאפר וממלא אותם, אחרי שהוא ממלא את הבית האחרון עם התו \n הוא חוזר לבית שלפני זה על ידי ה-dec

אגב, מאיפה הקוד? זה מועתק מאיפשהו? כי ChatGPT טוען שיש באג בקוד... (אני מאמין לו, אבל לא התעמצתי יותר מדי לוודא את זה)

גלוי נאות: אני אדם עצלן ואני משתמש ב-AI כדי לענות לך. אבל אני לא כותב שום דבר שאני לא מבין טוב. אבל תדע לך שגם אתה יכול להתשתמש ב-AI כדי להבין, ואפשר לשגע אותו עד שאתה מבין כל מילה.

זה לא קשור לנושא זה, @dovid מקפיד על זה
ואגב הקוד הוא חלקי, אפשר רק לנחש שזה חלק מלולאה שממיר מספר למחרוזת, אחרי שהוא כותב תו \n (דהיינו 0x10) לסוף bufffer הוא חוזר אחורה לכתוב את הספרה האחרונה של המספר

זה לא תחום שאני בקי בו, התשובה הבסיסית היא ככה:
צריך להבחין בין מיעון שהוא יחסי לבסיס כלשהו סתמי לבין מיעון יחסי ל-RIP

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

לגבי מיעון שהוא יחסי ל-RIP, זה סיפור קצת שונה:
הצורך בזה הוא כדי לבנות ספריות נטענות (DLL-ים בווינדוס או shared objects בלינוקס) בצורה שאפשר להטעין אותם לכל מקום בראם בלי לעבור על כל הכתובות ולעדכן אותם (מה שנקרא Position Independent Code או PIC)
הסבר:
בהרבה ספריות יש בנוסף לאוסף של פונקציות, גם צורך לשמור ולגשת לדאטה גלובלי כלשהו, אם הכתובת של המשתנה הגלובלי הזה יהיה קבוע, אי אפשר יהיה לטעון את הספרייה לכל מיקום בזכרון בלי לעדכן כל מקום שניגש למשתנה הגלובלי הזה, לכן המציאו אפשרות לגשת למיקום שהוא יחסי ל-RIP ככה בכל כתובת שתטען את הספרייה הקוד יעבוד
אגב, בלי אפשרות זו, לא היה אפשר לעשות את זה עם פקודות מתמטיות, כי אין גישה ישירה לערך של RIP

@dovid כתב:

כי המחירים של האחסון בינתיים רק עולים, ככה זה סוג של השקעה בחיסכון

התקווה הוא שההצע יתאים עצמו מחדש לביקוש בשנים הקרובות והמחירים ירדו שוב

(אגב, אני מרגיש עלוב מאוד עם ה-16GB שלי... ויש עוד אנשים שמסתובבים בינינו עם 8GB...)

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

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

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

בשלב כלשהו יהיה כדאי להסתכל בקוד המקור של תוכנה כזאת כדי לקבל מושג איך זה בנוי

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

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

yossiz כתב:

לכן יש פה שימוש ב-ecx

הוא טוען שבאמת היה אפשר להשתמש גם ב-rcx בעקרון כי ה-ABI (שים לב לניסוח, ABI ולא API, מה ההבדל? נושא לעוד שיעור...) של ווינדוס בפירוש מתעלם מבייטים העליונים כאשר הרוחב של הארגומנט מוצהר כ-DWORD

היתרון של שימוש ב-ecx הוא כי הבינארי של הפקודה קצרה יותר

B9 F5 FF FF FF              ; mov ecx, -11   → 5 bytes
48 C7 C1 F5 FF FF FF        ; mov rcx, -11   → 7 bytes

(היו עוד ביקורות אבל דקויות ממש עדינות שלא כדאי להעלות לפה)

@שאלתיאל קיוויתי בתשובה הנ"ל לתת לך טעימה שתבין למה כדאי לך ללמוד כל הידע המקדים שהספרים/קורסים מנסים ללמד אותך
למה כדאי להבין שיטת המספור הבינארי, ולמה כדאי להבין שפת C
מקווה ששיכנעתי אותך קצת

@שאלתיאל כן, בטח אתה צודק בהבנה שלך
אבל אפשר להוסיף המון הסבר

למה ecx?
יש פה שתי שאלות,
א) למה רג'יסטר c ולא a או b או משהו אחר
ב) למה לבחור ב-ecx (גירסת ה-32 סיביות מתוך משפחת c, לעומת rcx) מדובר הרי בקוד של 64 סיביות (עוד שאלה: איך ידעתי מתוך שתי השורות שהבאת שזה 64 סיביות?)

התשובה לשאלה הראשונה (וגם לשאלה שבסוגריים בסוף השאלה השנייה) קשורה ל-calling conventions = המוסכמה איך נהוג לקרוא פונקציות בווינדוס 64. וקונבנציה של win64 הוא ששמים את הארגומנט הראשון (מסוג int) ב-rcx (זה שונה לגמרי מהקונבנציות הן של win32 והן של לינוקס)
אפשר להמשיך ולשאול למה הקונבנציה ככה, אבל קונבנציה כשמו כן הוא, סתם מוסכמה כי חייבים להסכים על שיטה כלשהו, (אולי יש טעם יותר עמוק, אני לא יודע)

התשובה לשאלה השניה יותר מסובכת: זה חוזר לאיך מוגדר הקבוע STD_OUTPUT_HANDLE בקבצי ה-hearders של windows api
ככה זה מוגדר:

typedef unsigned long DWORD;
#define STD_OUTPUT_HANDLE ((DWORD)-11)

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

יש פה דקויות שצריך לשים אליהם את הדעת:
א) מה כתוב בשפת C
ה--11 כשלעצמו (בשפת C) הוא signed int אבל הערך שהפונקציה מקבלת הוא מסוג DWORD שהוא unsigned long שזה א) unsigned וב) long דהיינו 32 סיביות, לכן יש casting (= כפייה לטייפ אחר) של הערך ל-DWORD
עכשיו צריך להבין שכאשר אתה כופה -11 לטייפ unsigned ו-unsigned הרי לא יכול לקבל ערך שלילי, אז מה הערך??
התשובה היא: 0xFFFFFFF5 (למה? ע"ע משלים ל-2)

ב) איך זה ממומש באסמבלי
עכשיו כשנבוא לתרגם את זה לאסמבלי ונרצה להעביר את הערך 0xFFFFFFF5 בתור ארגומנט יש דבר נוסף שצריך לשים עליו לב, וזה שאם נכתוב mov rcx, -11 אז הערך ש-rcx יקבל יהיה 0xFFFFFFFFFFFFFFF5
לכן יש פה שימוש ב-ecx, שעובד אחרי שנדע התנהגות ה"הרחבה" של המעבד, כלומר איך המעבד "מרחיב" מספר בן 32 סיביות לתוך רג'יסטר בן 64 סיביות (התשובה על ידי מילוי המיקומים הריקים ב-0, למרות שבמקרה של מספר signed זה גורם לשינוי הערך של המספר)

יש עוד דברים שאפשר לשאול כמו למשל למה ה-API של ווינדוס מגדיר את הקבוע של STD_OUTPUT_HANDLE כמספר שלילי ולא מספר חיובי, וגם לזה יש תשובות טובות, ולמה -11 ולא -1, וגם לזה יש תשובה טובה

כהנה וכהנה תמיד אפשר וחייבים לחטט ולהיות סקרני

@מד לא, מה פתאום
חוץ מזה שגם לי לא ברור מה פה השאלה

יפה לראות את כל הפלפולים על כוונת השואל...

@שאלתיאל זה לא היה מבחן (לא מבחן ממני, אתה אמור לבחון את עצמך) לכן לא ציפיתי לקבל תשובות
אבל אם כבר כתבת תשובות, אז ארשה לעצמי להעיר שהם תשובות חלקיות
למשל:

• האם השימוש ב-rax ב-mov rax, 1 בדוקא או שמא כל רג'יסטר טוב לזה?
• למה 1 זה write? כלומר מי קבע את זה?
• האם אתה יודע לפשט יותר את המילים "קריאה לקרנל לינוקס" למשהו יותר מפורט ויותר קונקרטי
• מה הבדל בין קריאה לקרנל לקריאה ל-API

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

@שאלתיאל כתב בהאם יש הבדל משמעותי בכתיבת תוכניות אסמבלי ללינוקס או ווינדוס?:

עוד משהו אני ודיבגאר פחות חברים אפשר להסתדר עם זה אם אני יודע בערך איך זה אמור להיראות

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

@שאלתיאל לענ"ד (בלי שלמדתי אסמבלי בצורה מסודרת או עם תכניות גדולות)
שלב ראשון: תדאג שאתה מבין כל תו מהקוד שהבאת (אולי אתה כבר מבין, אין לי דרך לדעת)
ביתר פירוט (מה שרלוונטי להבדלים בין לינוקס לווידוס):

• mov rax, 1 - למה rax? מה המשמעות של מספר 1 פה?
• mov rdi, 1 - שוב כנ"ל,
• כנ"ל בשורות הבאות, למה הבחירה ב-rsi ו-rdx
• מה עושה syscall

אח"כ יהיה כדאי מאוד באמת לכתוב תוכנה מקבילה לווינדוס ולשאול את עצמך מה ההבדלים ולמה (למה בווינדוס קוראים ל-API ולא עושים syscall? האם אפשרי לעשות syscall בווינדוס? האם אפשרי לעשות קריאת API בלינוקס לקבל אותה תוצאה? שימת לב לשינויים ברג'יסטרים בקריאות API, וכו')

אח"כ אין באמת יותר מדי הבדל אם אתה מתמקד בלינוקס או ווינדוס, כדאי לענ"ד להכיר שניהם ואת ההבדלים העיקריים (סתם לידע כללי ומקיף)

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

@שאלתיאל כתב בDOS- ללימוד אסמבלי:

סגמנטים

שים לב שזה כמעט לא רלוונטי במעבדים מודרניים... אבל לא נורא ללמוד עליהם

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