שימוש ב-ES2015 Proxy להנאה ורווח
אמ;לק
מאמר זה מיועד למפתחי JavaScript ומציג את התכונה 'Proxy' ב-ECMAScript 2015. הוא מתאר כיצד להשתמש ב-Proxy ליצירת אובייקטים מרובים ולשלוט באינטראקציות עמהם, ומספק דוגמאות מעשיות לפיתוח תכונות מתקדמות.
סיכום בעברית: מערכת VibeSec · מדיניות המקורות
נוסף ל-VibeSec:
כותרת מקורית: Using ES2015 Proxy for fun and profit
התוכן המלא בעברית
תרגום אוטומטי מהמקור; מונחים טכניים נשארו באנגלית. לנוסח המחייב — הכתבה המקורית.
הרבה נכתב על ES2015 - על פונקציות החץ (arrow functions), הצהרות משתנים עם scope ועל מחלקות (classes) שנויות במחלוקת. עם זאת, תכונה מסוימת קיבלה מעט אהבה עד כה: Proxy. כמפתחי JS, אנחנו לא רגילים להסתמך על מנגנוני לכידה (trapping mechanisms) לאורך בסיס הקוד שלנו, אך יש להם כמה יישומים שימושיים מאוד. אם למנות כמה:
• דפוסי העיצוב Observer and Visitor
עד כה, השפה לא סיפקה לנו מנגנון כזה. אני מרגיש ש-Proxy פותר את הבעיה הזו תוך שמירה על התחושה של ה-JS שאנו מכירים ואוהבים (כלומר, ללא מתודות [Symbol.__setattr__] עבור האובייקטים שלנו). בפוסט זה אתן דוגמה למלכודות (traps) הנפוצות ביותר (get, set, has ו-deleteProperty), ובהתאם לרוח Snyk, נעסוק בניהול תלויות.
המטרה שלנו
אנו רוצים ליצור חבילה המאפשרת למפתח לדרוש בבטחה מודולים, להגביל את הגישה שלהם למודולים ספציפיים. אחרי הכל, לא נרצה לסמוך על מודול כלי עזר פונקציונליים עם ה-fs שלנו, נכון?
הגדרת הבמה
הבנאי Proxy מקבל 2 פרמטרים:
• target : זה ה-Object שאנחנו רוצים להעניק לו פרוקסי
• handler : זהו Object המכיל את המפרט עבור המלכודות שאנו רוצים לטפל בהן (טראפ, במובן זה, היא פונקציה שנקראת באירועים מסוימים שקורים ל-proxy, כגון מאפיין שניגש, מוגדר או נמחק) - דוגמאות להלן.
איך עובד require
אני כולל את החלק הזה מכיוון שבעוד שהתיעוד של Node עושה עבודה מצוינת בהסבר, אנחנו עומדים לבצע כמה דברים מתוחכמים במטמון המודולים, לכן אני רוצה לוודא שזרימת ה-require ברורה:
• שם y נפתר לנתיב מוחלט (או לא, אם זה מודול ליבה, כגון fs )
• השם שנפתר נלקח מהמטמון, מבלי לבדוק את קיומו
• אם הערך שאוחזר מוגדר (אובייקט Module), הערכים המיוצאים יוחזרו
• אחרת, Node למעשה מביא את הקובץ מה-FS, מקמפל אותו לאובייקט Module שמוכנס למטמון, והערכים המיוצאים שלו מוחזרים.
מטמון זה הוא Singleton גלובלי, הנגיש דרך require('module')._cache ו-require.cache, והוא אובייקט JS רגיל.
סוף סוף, קצת קוד
לשם הפשטות, הבה נניח שאנחנו רק רוצים לספק ממשק לרשימה שחורה עבור מודולים שלא אמורים לשמש את המודול הנדרש שלנו. זה הולך להיראות כך:
// our code here, patent pending ;) const snykwire = require ( 'snykwire' ); // don't allow this module access either 'fs' nor 'net' core modules const nefarious = snykwire ( 'nefarious' , [ 'fs' , 'net' ] );
אוקיי, אז עכשיו יש לנו תחושה איך זה הולך להיראות, בואו נתחיל בקידוד:
// snykwire/index.js const Module = require ( 'module' ); // we need this to access the global cache module . exports = ( moduleName , blacklist =[] ) => { // let's make sure we have a set of RESOLVED blacklisted // modules we can easily check against. const blackSet = new Set ( blacklist . map ( require . resolve )); // we're going to save a reference to the "clean" version of the cache, // so we can set it right afterwards const cache = Module . _cache ; Module . _cache = new Proxy ( cache , { /* * כפי שציינתי קודם, שליפת [resolvedName] מהמטמון היא * הפעולה הראשונה שמבוצעת, כך שאנחנו יכולים להיות בטוחים שנלכוד כאן כל קריאת `require`. * מלכודת ה-`get` מקבלת 2 פרמטרים: `target` (שהוא האובייקט * עליו מופעל ה-proxy - כלומר המטמון) וה-property שאליו ניגשים (כאן זה השם המלא של המודול אליו ניגשים). * אם לא נצהיר על מלכודת זו, כל property שאליו ניגשים יועבר * ישירות ל-target, כאילו לא היה proxy בכלל. */ get ( target , resolvedName ) { if ( blackSet . has ( resolvedName )) { // we could return a dummy module here, but it's easier to just throw an error for now throw new Error ( `Module ' ${ moduleName } ' has attempted to access module ' ${ resolvedName } '` ); } // else, just act natural return target [ resolvedName ] ; } }); try { // let's see if we can require the module now... ^-*_*-^ return require ( moduleName ); } finally { // and... let's put things back where they belong Module . _cache = cache ; } };
מגניב, סיימנו, נכון? ובכן, לא בדיוק. כן, וידאנו שהמודול המרושע שלנו לא ידרוש מודול ברשימה השחורה, אבל יש טריקים מלוכלכים אחרים שהוא יכול לעשות:
// nefarious/index.js // require('fs').writeFileSync('/etc/passwd', 'muhahaha'); // Drat! Foiled! Let's try something else... require . cache . fs = { exports: { readFile () { process . exit ( 1 ); // muhahaha! } } }
הערה צדדית לגבי require.cache : אם ברצונך להשחית מודול בודד במטמון המודול, השתמש ב-require.cache . אם, לעומת זאת, אתה רוצה להחליף את כל מנגנון האחסון במטמון, השתמש ב-require('module')._cache = ... .בוא נתקן את הקוד שלנו כדי להתמודד עם המצב הזה:
// ... Module . _cache = new Proxy ( cache , { get ( target , resolvedName ) { if ( blackSet . has ( resolvedName )) { throw new Error ( `Module ' ${ moduleName } ' has attempted to access module ' ${ resolvedName } '` ); } return target [ resolvedName ] ; }, /* * מלכודת ה-`set` מקבלת 3 פרמטרים: `target` (שהוא האובייקט * עליו מופעל ה-proxy - כלומר המטמון), ה-property שמוגדר (כאן זה השם המלא של המודול) ואובייקט ה-Module עצמו. * אם לא נצהיר על מלכודת זו, כל הגדרת property תתבצע * ישירות ל-target, כאילו לא היה proxy בכלל. */ set ( target , resolvedName , mod ) { if ( blackSet . has ( resolvedName )) { throw new Error ( `Module ' ${ moduleName } ' has attempted to corrupt module ' ${ resolvedName } '` ); } target [ resolvedName ] = mod ; // ה-`set` trap חייבת להחזיר `true` אם הצליחה. // החזרת ערך falsy תזרוק `TypeError`. return true; } // ...
ו...עכשיו סיימנו... נכון? לֹא. בואו ניקח בחשבון את הקוד המרושע הזה:
// nefarious/index.js if ( 'fs' in require . cache ) { delete require . cache . fs ; // if I can't use it, nobody can! // (as long as they run in strict mode...) Object . freeze ( require . cache ); }
// ... Module . _cache = new Proxy ( cache , { get ( target , resolvedName ) { throwIfForbidden ( blackSet , resolvedName ); return target [ resolvedName ] ; }, set ( target , resolvedName , mod ) { throwIfForbidden ( blackSet , resolvedName ); target [ resolvedName ] = mod ; return true; }, // This traps resolvedName ב-proxy has ( target , resolvedName ) { throwIfForbidden ( blackSet , resolvedName ); return resolvedName in target ; }, // This traps מחיקת proxy[resolvedName] deleteProperty ( target , resolvedName ) { throwIfForbidden ( blackSet , resolvedName ); delete target [ resolvedName ] ; // like with the set trap, return true on success return true; }, // Traps Object.preventExtensions, and by extension, Object.freeze preventExtensions ( target ) { // Let's not let anyone mess with our cache throw new Error ( המודול ' ${ moduleName } ' ניסה לנעול את מטמון המודול שלך ); } // ...
ועכשיו סיימנו. או, לפחות, אני חושב שכן.
יש לך רעיון איך לעקוף את הפרוקסי הזה? שתף אותם איתנו ב-Twitter @snyksec !
המאגר עבור POC זה זמין כאן.
התחלה עם Capture The Flag
למדו כיצד לפתור אתגרי Capture The Flag על ידי צפייה בסדנת ה-101 הווירטואלית שלנו לפי דרישה.
קרא עוד
Stadium Summer: ה-Snyk Connect Fan Zone Tour
סיור ה-Fan Zone של Snyk הביא סדנאות אבטחת AI, נטוורקינג ותחרות ידידותית ל-8 ערים ו-3 מפגשים וירטואליים. המשתתפים בנו מיומנויות, שיתפו רעיונות והשתפרו יחד.
Snyk VulnBench JS 1.0: האם LLMs יכולים למצוא את אותם באגים פעמיים?
Snyk VulnBench JS 1.0: 300 סריקות חוזרות מראות שממצאי אבטחה של LLM משתנים בין הרצה להרצה, בעוד ש-SAST ומודלים שונים תופסים פערי פגיעות שונים.
בניית אבטחת AI עם הלקוחות שלנו: 5 לקחים מתוכנית ה-Design Partner של Evo
למדו 5 לקחי מפתח מתוכנית שותפי העיצוב (Design Partner) של Evo מבית Snyk. גלו כיצד גילוי AI, מודיעין סיכונים ואוטומציה של מדיניות עוזרים לצוותים לאבטח AI גנרטיבי ולנהל את התפשטות ה-AI בארגון בקנה מידה רחב.