מסתבר שגם טלפון ציבורי הוא טלפון חכם

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

הרכש

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

קבעתי עם המוכר ביום שבת, 2/11/2019, ביריד שנקרא ״ימי בנימינה״:

המוכר היה נחמד מאד וסיפק את הסחורה:

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

זה לא כל כך נעים לראות טלפון סגור

הטלפון ואני הגענו הביתה בשלום, ואז נתקלתי באתגר הראשון:

השאסי של הטלפון היה נעול ולמוכר לא היה את המפתח. לא היה מדובר באיזה מנעול מצ׳וקמק של ארון מגירות אלא בצילינדר רב-בריח מכובד. מכיוון שכמו לכל אדם נורמטיבי לא היה לי ניסיון בפריצת מנעולים כאלו, התחלתי לחשוב מה אני יכול לעשות ופתאום נפל לי האסימון (see what I did there?): בעוד חמישה ימים אהיה בבוקרשט בכנס ההאקרים DefCamp, וכמו בכל כנס האקרים שמכבד את עצמו יהיה שם דוכן של פריצת מנעולים!

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

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

הערוץ הזה, אגב, של LockPickingLawyer, הוא הערוץ אליו ניגשתי כדי ללמוד איך להתמודד עם האתגר שלפני. אם אתם מתעניינים בפריצת מנעולים, זה הערוץ בשבילכם.

מה אגיד לכם? זה היה קשה. ממש קשה. היו כמה פעמים שכמעט התייאשתי אבל בסוף, אחרי לא-זוכר-כבר-כמה-זמן, זה קרה!

כך נראה השולחן עליו עבדתי, עם כל הכלים המעורבים:

אנשים אחרים, אגב, ניגשו אל אותו האתגר בגישה קצת יותר אגרסיבית:

אני מניח שגם אני הייתי מגיע לשם מתישהו, אם לא הייתי מצליח לפרוץ את המנעול...

כך נראה הטלפון כשהוא פתוח לרווחה:

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

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

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

פירוק ראשוני

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

אני חייב להודות שאם הייתם מבקשים ממני לנחש מי מייצר את המכשיר, הייתי מהמר על החשודות המיידיות שהן חברות התקשורת והאלקטרוניקה של סוף ה-80׳ ותחילת ה-90׳, כמו תדיראן, אבל לא היה עולה על דעתי שמי שמייצר את המכשיר זו תעש - התעשייה הצבאית... אבל אם תקראו בוויקיפדיה, תגלו שזה בעצם בכלל לא סוד!

כך נראה החלק האחורי של הטלפון לאחר הסרת לוח האם:

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

מבט מקרוב על לוח האם:

מארז הסוללה הכיל מספר תאים מסוג ניקל-קדמיום:

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

חילוץ התוכנה

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

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

1. ציון גרסת התוכנה שנמצאת על הרכיב;

2. הגנה על תוכן הרכיב, כאשר מדובר ברכיב מסוג EPROM הרגיש לאור אולטרה-סגול.

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

כאשר מסירים את המדבקה מהרכיב, ניתן לזהות אותו:

הרכיב האמור הוא Atmel AT29C256, שהוא רכיב זיכרון מסוג פלאש (Flash). המפרט הטכני שלו - Datasheet - יספר לנו עליו יותר ובאופן ספציפי מה נפחו:

רכיבי זיכרון נמדדים בשני פרמטרים הקשורים זה לזה:

1. הנפח הכולל שלהם, בביטים - במקרה שלנו 256K.

2. רוחב ה-״מילה״, או כמה ביטים אפשר לקבל בכל קריאה - במקרה שלנו רוחב המילה הוא בדיוק 8 ביטים, שהם בייט אחד, ולכן יש 32K בייטים.

שני הנתונים האלו משליכים על מספר הפינים הדרושים לקריאה ולכתיבה: 8 ביטים משמשים למידע עצמו (Data) ו-15 ביטים משמשים לכתובת (Address). אם תסתכלו על העמוד הראשון של ה-Datasheet, אכן תוכלו לראות שיש 15 פינים לכתובות והם נקראים A0..A14 ויש 8 פינים למידע והם נקראים I/O0..I/O7. פינים נוספים משמשים לציון כיוון המידע (קריאה או כתיבה), לבחירה של הרכיב (״בחירה״ אומרת לרכיב שעכשיו תורו להקשיב ולענות, בניגוד לשאר הזמן בו רכיבים אחרים מדברים ומקשיבים. תחשבו על זה כמו הצדף ב-״בעל זבוב״) ולחשמל, בין השאר.

את הרכיב קראתי בעזרת אחד מכמה כלים מתאימים שיש לי:

זה, ספציפית, הוא כלי מיושן ואם הייתי צריך להמליץ לכם על אחד חדש הייתי בוחר ב-TL866 בגרסא האחרונה הזמינה, שנכון לכתיבת שורות אלו היא זו:

T48 TL866-3G Programmer Support 31000+ ICS for EPROM/MCU/SPI/Nor/NAND Flash/EMMC/IC Tester/ TL866CS TL866II Plus Replacement with 9 Adapter(T48 Programmer Host+ 9 Adapter)

הקובץ הנקרא הוא אכן בגודל 32KByte וכך הוא נראה בתחילתו (שמאל) ובסופו (ימין):

מעבר זריז בעין על הקובץ מגלה מחרוזות רלבנטיות באנגלית:

וממש לקראת הסוף - הפתעה נוספת: שמות המתכנתים!

נראה שיהיה מעניין!

ניתוח התוכנה - Reverse Engineering

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

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

כל קוד שתכתבו בשפה אחרת, כגון C או Pascal או Java או Go או כל דבר אחר, צריך לעבור המרה לשפת המכונה של המעבד עליו התוכנה אמורה לרוץ, ולכן ניתן לקרוא את המקבילה שלו בשפת אסמבלי ובאופן תיאורטי להבין מה קורה פה. התהליך הזה נקרא Reverse Engineering וכמיטב המסורת יש לו תרגום מטופש לעברית - ״הנדסה חוזרת״ או ״הנדסה הפוכה״ - ואף אחד לא משתמש בו חוץ מאדם אחד בכל העולם (כן, עודד, אני מדבר עליך.)

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

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

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

ורק פה הבנתי לאיזה בור הכנסתי את עצמי...

בעולם ה-Reverse Engineering יש כלי אחד ששלט בפיסגה ללא עוררין במשך למעלה מעשור: IDA-Pro מבית Hexrays. כמעט כל מי שעסק ב-Reverse Engineering כחלק מהעבודה שלו השתמש בכלי הזה. הבעיה העיקרית שלו היא שהוא יקר טילים ובעצם אם אין לכם מעסיק שמשלם לכם על הכלי, רוב הסיכויים הם שאו שהשתמשתם בגרסת Demo חינמית ומוגבלת, או שפשוט השגתם עותק פרוץ.

לפני כמה שנים, ה-NSA האמריקאי שחרר בקוד פתוח את הכלי שהוא כתב, Ghidra (הלינק לא עובד עבור כתובות IP ישראליות אז תצטרכו להשתמש ב-VPN או ללכת ישירות אל GitHub). זהו כלי מאד חזק אבל לא מאד אינטואיטיבי, במיוחד עבור מי שרגיל היה להשתמש ב-IDA-Pro. למעשה, הדבר הראשון שעשיתי כאשר התקנתי אותו בפעם הראשונה, היה להגדיר מחדש את כל קיצורי המקלדת כך שיהיו זהים לאלו של IDA-Pro :-) לאט לאט הכלי צובר קהל מעריצים ופלח השוק שלו מתגבר.

קיימים מוצרים נוספים, כגון Radare2 או Binary Ninja אבל הם לא היו רלבנטים במיוחד לפרוייקט הזה בנקודת הזמן בו הוא התרחש - לפני חמש שנים.

אז מסתבר שהמעבד הזה הוא כל-כך איזוטרי, עד שאף אחד מהכלים המתקדמים לא תומך בו. אמנם מצאתי כמה Standalone Disassembler שונים, אבל הם אינם אינטראקטיביים ומייצרים רק קובץ טקסט וזה לא הפורמט איתו עובדים, לפחות מאז 1997...

הבנתי שאין לי ברירה ואם אני רוצה להיות מסוגל לבצע Reverse Engineering (להלן: לְרַבְרֵס) את הקוד, מישהו (ז״א אני) יצטרך ללמד את אחד מהכלים האלו איך לעבוד עם המעבד הזה. לשני הכלים יש יכולת ללמוד מעבדים חדשים ומכיוון ש-Ghidra ניצח גם במחיר וגם באופן הגדרת מעבד חדש, זה היה הכיוון בו בחרתי.

הגדרת מעבד חדש ב-Ghidra

בניגוד ל-IDA-Pro, שם ממש צריך לתכנת את המודול, ב-Ghidra ההגדרה של מודול חדש מבוצעת באמצעות קובץ טקסט. הוא ארוך, הוא מסובך, הוא בשפה מיוחדת שלהם, אבל הוא עדיין קובץ טקסט. וככה הוא נראה:

הצעד הגדול הראשון היה להגיע למצב שבו הגדרת המעבד עברה את הבדיקות של Ghidra והצליחה להיטען, כך שהמעבד החדש שהגדרתי הופיע ברשימה:

חדי העין יבחינו שהמעבד שנוסף הוא cdp1805, בזמן שהכיתוב על המעבד עצמו הוא cdp1806. אלו שני דגמים מאד קרובים באותה המשפחה וכשרק התחלתי התייחסתי אל ה-1805 כמייצג אבל ככל שהתקדמתי החלטתי להיצמד אל ה-1806.

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

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

המעבד החדש התגלה כלא פחות מסיוט והחלתי להבין למה אף אחד משני הכלים העיקריים לא תומך בו. יש לו ארכיטקטורה מוזרה ומאפייני ריצה שלא דומים לאלו של אף מעבד אחר שנתקלים בו, ברמה שאפילו אחרי שהגדרתי את המעבד, היו דברים שעדיין לא היו מסתדרים לבד והייתי צריך לעשות אותם באופן ידני, כמו למשל הדרך בה ארגומנטים מועברים לפונקציות: בכל מעבד נורמלי, חלק מהזיכרון מוגדר כ-״מחסנית״ (Stack) ולשם ״דוחפים״ את הארגומנטים לפני שקוראים לפונקציה ולפעמים חלק מהארגומנטים יועברו מעל-גבי אוגרים. ב-1806 לעומת זאת השימוש במחסנית הוא מינימלי באופן כללי וארגומנטים לפונקציה מועברים לפעמים באוגרים (שזה דווקא סביר ודומה למעבדים אחרים) אבל בשאר הזמן אלו בייטים שנמצאים בזיכרון הקוד, מייד אחרי הפקודה לקרוא לפונקציה. ומסתבר שלא IDA-Pro ולא Ghidra יודעים איך לאכול את זה...

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

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

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

בעיית הקידוד

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

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

לרברס חומרה זה קשה

כשמדברים על לרברס, מדברים על שני סוגים:

1. ריברוס דינאמי - Dynamic Analysis או Dynamic Reverse Engineering: זה מצב בו ניתן להריץ את התוכנה תחת פיקוח, למשל ע״י כלי שנקרא Debugger, ולראות איך היא מתנהגת בזמן אמת, בעולם האמיתי, ועם נתוני ריצה אמיתיים. אפשר לקבל הצצה לערכים של אוגרים או למיקומים בזיכרון.

2. ריברוס סטאטי - Static Analysis או Static Reverse Engineering: זה מצב בו לא ניתן להריץ את הקוד, בין אם כי אין לנו בכלל את המכשיר הרלבנטי או כי אין לנו דרך להריץ את הקוד תחת פיקוח.

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

אחד הכלים שעומדים לרשותי הוא Logic Analyzer. לפני כמה שנים קניתי אחד כזה, של חברת Saleae, זמן קצר אחרי שיצא לשוק ועדיין היה במחיר סביר של $300. זהו מכשיר שיש לו מספר מסויים של חיישנים, בדגם שלי מדובר ב-8, שאפשר לחבר אותם לרגליים של רכיבים ולנטר בזמן אמת את המתחים שעוברים במעגל.

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

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

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

זה עבד!!!

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

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

אז מה הלאה?

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

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

עוד דבר שהייתי רוצה לעשות יום אחד, זה להחליף את כל לוח האם במשהו מודרני כגון Arduino או RaspberryPi ובעצם להשמיש טלפון מודרני על החומרה הישנה - הרי יש מסך, יש לוח מקשים ויש שפופרת! התחלתי קצת לחקור על זה ובין השאר מצאתי פרוייקט בשם ״Arduino Telephone Caller ID Unit״ שמישהו כבר עשה. הפרוייקט כולל את הלוח הבא:

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

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

אחרית דבר

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

תודה שקראתם!

[עריכה]

העליתי את החומר הרלוונטי לגיטהאב והוא נמצא כאן. מוזמנים לתרום ולהשתתף.