אימות משתמשים באמצעות Cloud Identity-Aware Proxy ל-Python

רקע

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

אפליקציית Hello user-email-address

האפליקציה במדריך הזה היא אפליקציית App Engine מינימלית מסוג Hello world, עם תכונה אחת לא אופיינית: במקום Hello world, היא מציגה את הטקסט Hello user-email-address, כאשר user-email-address היא כתובת האימייל של המשתמש המאומת.

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

• ‫X-Goog-Authenticated-User-Email: כתובת האימייל של המשתמש מזהה אותו. אל תאחסנו מידע אישי אם האפליקציה יכולה להימנע מכך. האפליקציה הזו לא שומרת נתונים, היא רק מחזירה אותם למשתמש.

• ‫X-Goog-Authenticated-User-Id: מזהה המשתמש הזה שמוקצה על ידי Google לא מציג מידע על המשתמש, אבל הוא מאפשר לאפליקציה לדעת שהמשתמש המחובר הוא אותו משתמש שנראה בעבר.

• ‫X-Goog-Iap-Jwt-Assertion: אפשר להגדיר Cloud de Confiance by S3NS אפליקציות לקבל בקשות אינטרנט מאפליקציות אחרות בענן, בלי לעבור דרך IAP, בנוסף לבקשות אינטרנט מהאינטרנט. אם אפליקציה מוגדרת כך, יכול להיות שבבקשות כאלה יהיו כותרות מזויפות. במקום להשתמש באחד מהכותרות של הטקסט הפשוט שצוינו קודם, אפשר להשתמש בכותרת הזו שחתמה באופן קריפטוגרפי ולאמת אותה כדי לבדוק שהמידע סופק על ידי Google. כתובת האימייל של המשתמש ומזהה משתמש קבוע זמינים כחלק מהכותרת החתומה הזו.

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

user_id = request.headers.get('X-Goog-Authenticated-User-ID')

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

יצירת קוד המקור

1. משתמשים בכלי לעריכת טקסט כדי ליצור קובץ בשם main.py, ומדביקים בו את הקוד הבא:

   import sys
   
   from flask import Flask
   app = Flask(__name__)
   
   CERTS = None
   AUDIENCE = None
   
   
   def certs():
       """Returns a dictionary of current Google public key certificates for
       validating Google-signed JWTs. Since these change rarely, the result
       is cached on first request for faster subsequent responses.
       """
       import requests
   
       global CERTS
       if CERTS is None:
           response = requests.get(
               'https://documentation.s3ns.fr/iap/verify/public_key'
           )
           CERTS = response.json()
       return CERTS
   
   
   def get_metadata(item_name):
       """Returns a string with the project metadata value for the item_name.
       See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
       possible item_name values.
       """
       import requests
   
       endpoint = 'http://metadata.google.internal'
       path = '/computeMetadata/v1/project/'
       path += item_name
       response = requests.get(
           '{}{}'.format(endpoint, path),
           headers={'Metadata-Flavor': 'Google'}
       )
       metadata = response.text
       return metadata
   
   
   def audience():
       """Returns the audience value (the JWT 'aud' property) for the current
       running instance. Since this involves a metadata lookup, the result is
       cached when first requested for faster future responses.
       """
       global AUDIENCE
       if AUDIENCE is None:
           project_number = get_metadata('numeric-project-id')
           project_id = get_metadata('project-id')
           AUDIENCE = '/projects/{}/apps/{}'.format(
               project_number, project_id
           )
       return AUDIENCE
   
   
   def validate_assertion(assertion):
       """Checks that the JWT assertion is valid (properly signed, for the
       correct audience) and if so, returns strings for the requesting user's
       email and a persistent user ID. If not valid, returns None for each field.
       """
       from jose import jwt
   
       try:
           info = jwt.decode(
               assertion,
               certs(),
               algorithms=['ES256'],
               audience=audience()
               )
           return info['email'], info['sub']
       except Exception as e:
           print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
           return None, None
   
   
   @app.route('/', methods=['GET'])
   def say_hello():
       from flask import request
   
       assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
       email, id = validate_assertion(assertion)
       page = "<h1>Hello {}</h1>".format(email)
       return page

   הסבר מפורט על הקובץ main.py מופיע בקטע הסבר על הקוד בהמשך המדריך הזה.

2. יוצרים קובץ נוסף בשם requirements.txt ומדביקים בו את הקוד הבא:

   Flask==2.2.5
   cryptography==41.0.2
   python-jose[cryptography]==3.3.0
   requests==2.31.0

   בקובץ requirements.txt מפורטות כל ספריות Python הלא סטנדרטיות שהאפליקציה צריכה לטעון ב-App Engine:

   • ‫Flask היא מסגרת האינטרנט של Python שמשמשת לאפליקציה.

   • ‫cryptography הוא מודול שמספק פונקציות קריפטוגרפיות חזקות.

   • python-jose[cryptography] מספק את פונקציית הבדיקה והפענוח של JWT.

   • ‫requests מאחזר נתונים מאתרים.

3. יוצרים קובץ בשם app.yaml ומזינים בו את הטקסט הבא:

   runtime: python37

   הקובץ app.yaml מציין ל-App Engine איזו סביבת שפה נדרשת לקוד.

הסבר על הקוד

בקטע הזה מוסבר איך הקוד ב-main.py פועל. אם אתם רק רוצים להריץ את האפליקציה, אתם יכולים לדלג לקטע פריסת האפליקציה.

הקוד הבא נמצא בקובץ main.py. כשמתקבלת באפליקציה בקשת HTTP GET לדף הבית, מסגרת Flask מפעילה את הפונקציה say_hello:

@app.route('/', methods=['GET'])
def say_hello():
    from flask import request

    assertion = request.headers.get('X-Goog-IAP-JWT-Assertion')
    email, id = validate_assertion(assertion)
    page = "<h1>Hello {}</h1>".format(email)
    return page

הפונקציה say_hello מקבלת את ערך הכותרת של טענת הנכוֹנוּת (assertion) של JWT ש-IAP הוסיף מהבקשה הנכנסת, וקוראת לפונקציה כדי לאמת את הערך החתום באופן קריפטוגרפי. הערך הראשון שמוחזר (אימייל) משמש לאחר מכן בדף אינטרנט מינימלי שהפונקציה יוצרת ומחזירה.

def validate_assertion(assertion):
    """Checks that the JWT assertion is valid (properly signed, for the
    correct audience) and if so, returns strings for the requesting user's
    email and a persistent user ID. If not valid, returns None for each field.
    """
    from jose import jwt

    try:
        info = jwt.decode(
            assertion,
            certs(),
            algorithms=['ES256'],
            audience=audience()
            )
        return info['email'], info['sub']
    except Exception as e:
        print('Failed to validate assertion: {}'.format(e), file=sys.stderr)
        return None, None

הפונקציה validate_assertion משתמשת בפונקציה jwt.decode מהספרייה jose של צד שלישי כדי לוודא שההצהרה חתומה בצורה תקינה, וכדי לחלץ את פרטי המטען הייעודי (payload) מההצהרה. המידע הזה כולל את כתובת האימייל של המשתמש המאומת ומזהה ייחודי קבוע של המשתמש. אם אי אפשר לפענח את הטענה, הפונקציה הזו מחזירה None לכל אחד מהערכים האלה ומדפיסה הודעה כדי לרשום את השגיאה ביומן.

כדי לאמת הצהרת JWT, צריך לדעת את אישורי המפתח הציבורי של הישות שחתמה על ההצהרה (Google במקרה הזה) ואת קהל היעד שאליו ההצהרה מיועדת. באפליקציית App Engine, הקהל הוא מחרוזת עם Cloud de Confiance פרטי זיהוי של הפרויקט. הפונקציה הזו מקבלת את האישורים האלה ואת מחרוזת הקהל מהפונקציות שקדמו לה.

def audience():
    """Returns the audience value (the JWT 'aud' property) for the current
    running instance. Since this involves a metadata lookup, the result is
    cached when first requested for faster future responses.
    """
    global AUDIENCE
    if AUDIENCE is None:
        project_number = get_metadata('numeric-project-id')
        project_id = get_metadata('project-id')
        AUDIENCE = '/projects/{}/apps/{}'.format(
            project_number, project_id
        )
    return AUDIENCE

אתם יכולים לחפש את Cloud de Confiance המזהה המספרי ואת השם של הפרויקט ולהזין אותם בקוד המקור בעצמכם, אבל הפונקציה audience עושה את זה בשבילכם על ידי שליחת שאילתה לשירות המטא-נתונים הרגיל שזמין לכל אפליקציית App Engine. מכיוון ששירות המטא-נתונים הוא חיצוני לקוד האפליקציה, התוצאה נשמרת במשתנה גלובלי שמוחזר בלי צורך לחפש מטא-נתונים בקריאות הבאות.

def get_metadata(item_name):
    """Returns a string with the project metadata value for the item_name.
    See https://cloud.google.com/compute/docs/storing-retrieving-metadata for
    possible item_name values.
    """
    import requests

    endpoint = 'http://metadata.google.internal'
    path = '/computeMetadata/v1/project/'
    path += item_name
    response = requests.get(
        '{}{}'.format(endpoint, path),
        headers={'Metadata-Flavor': 'Google'}
    )
    metadata = response.text
    return metadata

שירות המטא-נתונים של App Engine (ושירותי מטא-נתונים דומים לשירותי מחשוב אחרים שלCloud de Confiance ) נראה כמו אתר, והשאילתות אליו הן שאילתות אינטרנט רגילות. עם זאת, זה לא אתר חיצוני, אלא תכונה פנימית שמחזירה מידע מבוקש על האפליקציה שפועלת, ולכן בטוח להשתמש בבקשות http במקום בבקשות https. הוא משמש לקבלת המזהים הנוכחיים Cloud de Confiance שנדרשים להגדרת הקהל המיועד של הצהרת ה-JWT.

def certs():
    """Returns a dictionary of current Google public key certificates for
    validating Google-signed JWTs. Since these change rarely, the result
    is cached on first request for faster subsequent responses.
    """
    import requests

    global CERTS
    if CERTS is None:
        response = requests.get(
            'https://documentation.s3ns.fr/iap/verify/public_key'
        )
        CERTS = response.json()
    return CERTS

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

פריסת האפליקציה

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

1. בחלון הטרמינל, עוברים לספרייה שמכילה את הקובץ app.yaml ופורסים את האפליקציה ב-App Engine:

   gcloud app deploy
   

2. כשמופיעה בקשה, בוחרים אזור קרוב.

3. כשמוצגת השאלה אם רוצים להמשיך בפעולת הפריסה, מזינים Y.

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

4. צפייה באפליקציה:

   gcloud app browse
   

   בפלט, מעתיקים את web-site-url, כתובת האינטרנט של האפליקציה.

5. בחלון הדפדפן, מדביקים את web-site-url כדי לפתוח את האפליקציה.

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

הפעלת רכישות מתוך האפליקציה

עכשיו, כשקיים מופע של App Engine, אפשר להגן עליו באמצעות IAP:

1. נכנסים לדף שרת proxy לאימות זהויות (IAP) במסוף Cloud de Confiance .

   מעבר לדף של שרת proxy לאימות זהויות (IAP)

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

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

3. בכרטיסייה OAuth Consent Screen בדף Credentials, ממלאים את השדות הבאים:

   • אם החשבון שלכם נמצא בארגון ב-Google Workspace, בוחרים באפשרות External ולוחצים על Create. בתור התחלה, האפליקציה תהיה זמינה רק למשתמשים שאתם מאשרים במפורש.

   • בשדה Application name, מזינים את הערך IAP Example.

   • בשדה כתובת אימייל לתמיכה, מזינים את כתובת האימייל שלכם.

   • בשדה דומיין מורשה, מזינים את החלק של שם המארח בכתובת ה-URL של האפליקציה, למשל iap-example-999999.uc.r.appspot.com. אחרי שמזינים את שם המארח בשדה, לוחצים על המקש Enter.

   • בשדה Application homepage link, מזינים את כתובת ה-URL של האפליקציה, לדוגמה https://iap-example-999999.uc.r.appspot.com/.

   • בשדה Application privacy policy line (שורת מדיניות הפרטיות של האפליקציה), משתמשים באותה כתובת URL כמו הקישור לדף הבית לצורכי בדיקה.

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

5. נכנסים לדף שרת proxy לאימות זהויות (IAP) במסוף Cloud de Confiance .

   מעבר לדף של שרת proxy לאימות זהויות (IAP)

6. כדי לרענן את הדף, לוחצים על רענון refresh. בדף הזה מופיעה רשימת המשאבים שאפשר להגן עליהם.

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

8. בדפדפן, עוברים אל web-site-url שוב.

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

הוספת משתמשים מורשים לאפליקציה

1. נכנסים לדף שרת proxy לאימות זהויות (IAP) במסוף Cloud de Confiance .

   מעבר לדף של שרת proxy לאימות זהויות (IAP)

2. מסמנים את התיבה של אפליקציית App Engine ולוחצים על הוספת ישות ראשית.

3. מזינים allAuthenticatedUsers ובוחרים את התפקיד Cloud IAP/IAP-Secured Web App User.

4. לוחצים על Save.

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

• כל כתובת אימייל ב-Gmail או ב-Google Workspace

• כתובת אימייל של קבוצה ב-Google

• שם דומיין של Google Workspace

גישה לאפליקציה

1. בדפדפן, עוברים אל web-site-url.

2. כדי לרענן את הדף, לוחצים על רענון refresh.

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

   בדף שמוצג מופיע הכיתוב "שלום user-email-address" עם כתובת האימייל שלכם.

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

מושגי אימות

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

אימות שמנוהל על ידי האפליקציה

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

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

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

אימות חיצוני באמצעות OAuth2

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

בתרשים הבא מודגם אימות חיצוני באמצעות שיטת OAuth2.

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

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

שרת proxy לאימות זהויות (IAP)

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

הטיפול בבקשה מוצג בתרשים הבא.

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

האפליקציה לא צריכה יותר לטפל במידע על חשבונות משתמשים או על סשנים. כל פעולה שצריכה לדעת מזהה ייחודי של המשתמש יכולה לקבל אותו ישירות מכל בקשה לאחזור מהרשת נכנסת. עם זאת, אפשר להשתמש בזה רק בשירותי מחשוב שתומכים ב-IAP, כמו App Engine ומאזני עומסים. אי אפשר להשתמש ב-IAP במחשב פיתוח מקומי.