פונקציות Keymaster

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

הנחיות כלליות להטמעה

ההנחיות הבאות רלוונטיות לכל הפונקציות ב-API.

פרמטרים של מצביע על קלט

גרסה: 1, 2

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

אם פרמטר הקלט הנדרש הוא NULL, שיטות Keymaster צריכות להחזיר ErrorCode::UNEXPECTED_NULL_POINTER

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

פרמטרים של מצביע לפלט

גרסה: 1, 2

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

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

שימוש לרעה ב-API

גרסה: 1, 2, 3

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

האפליקציות, ה-framework ומאגר המפתחות של Android אחראים לוודא שהקריאות למודולים של Keymaster הגיוניות ושימושיות.

פונקציות

תכונות getHardwareFeature

גרסה: 3

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

• isSecure הוא true אם המפתחות מאוחסנים ב חומרה מאובטחת (TEE וכו') ואף פעם לא יוצאת ממנה.
• supportsEllipticCurve הוא true אם החומרה תומכת בקריפטוגרפיה של Elliptic Curve עם עקומות NIST (P-224, P-256, P-384 ו-P-521).
• הsupportsSymmetricCryptography true אם החומרה תומכת בקריפטוגרפיה סימטרית, כולל AES ו-HMAC.
• supportsAttestation הוא true אם החומרה תומכת ביצירה של אישורי אימות (attestation) של מפתחות ציבוריים של Keymaster, חתומה באמצעות מפתח שהוחדר בסביבה מאובטחת.

קודי השגיאה היחידים ששיטה זו עשויה להחזיר הם ErrorCode:OK, ErrorCode::KEYMASTER_NOT_CONFIGURED או אחד מקודי השגיאה מציין כישלון בתקשורת עם החומרה המאובטחת.

getHardwareFeatures()
    generates(bool isSecure, bool supportsEllipticCurve, bool supportsSymmetricCryptography,
              bool supportsAttestation, bool supportsAllDigests, string keymasterName,
              string keymasterAuthorName);

להגדיר

גרסה: 2

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

הגדרת Keymaster. מתבצעת קריאה לשיטה הזו פעם אחת אחרי שפותחים את המכשיר ולפני שמשתמשים בו. הוא משמש כדי לספק KM_TAG_OS_VERSION וגם KM_TAG_OS_PATCHLEVEL עד מאסטרינג. עד שהשיטה הזו תיקרא, כל שאר השיטות יחזורות KM_ERROR_KEYMASTER_NOT_CONFIGURED הערכים שצוינו ה-method מקובלות ב-Keymaster, רק פעם אחת בכל אתחול. עוקב שיחות מחזירות KM_ERROR_OK, אבל לא לעשות כלום.

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

keymaster_error_t (*configure)(const struct keymaster2_device* dev,
                               const keymaster_key_param_set_t* params);

addRngEntropy

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור add_rng_entropy השם שלו השתנה ב-Keymaster 3.

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

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

יישומי Keymaster שמנסים להעריך את האנטרופיה המאגר הפנימי מניח שהנתונים שסופקו על ידי addRngEntropy לא מכילה אנטרופיה. הטמעות Keymaster עשויות הפונקציה מחזירה את הערך ErrorCode::INVALID_INPUT_LENGTH אם נותנים יותר מ-2 KiB של נתונים בשיחה יחידה.

generateKey

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור generate_key השם שלו השתנה ב-Keymaster 3.

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

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

מפתחות RSA

הפרמטרים הבאים נדרשים כדי ליצור מפתח RSA.

• תג::KEY_SIZE מציין את הגודל של המודולוס הציבורי, בביטים. אם לא צוין, ה-method מחזירה את הערך ErrorCode::UNSUPPORTED_KEY_SIZE. הערכים הנתמכים הם 1024, 2048, 3072 ו-4096. ערכים מומלצים כל גודלי המפתחות שהם כפולה של 8.
• תג::RSA_PUBLIC_EXPONENT מציין את ערך המעריך הציבורי של ה-RSA. אם לא צוין, ה-method הפונקציה מחזירה את הערך ErrorCode::INVALID_ARGUMENT. הערכים הנתמכים הם 3 ו-65537. הערכים המומלצים הם כל הערכים הראשוניים עד 2^64.

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

• תג::PURPOSE מציין למטרות מותרות. מפתחות RSA צריכים לתמוך בכל המטרות. בכל שילוב של נתונים.
• תג::DIGEST מציין של אלגוריתמים לתקצירים שעשויים להיות בשימוש עם המפתח החדש. הטמעות שלא תומכים בכל האלגוריתמים של התקציר, צריכים לקבל יצירת מפתחות בקשות שכוללות תקצירים לא נתמכים. תקצירים שאינם נתמכים צריכים להיות מוצבות בקטע של מאפייני המפתח המוחזרים. הסיבה לכך היא שאפשר להשתמש במפתח עם התקצירים האחרים האלה, אבל הפירוט הוא שבוצעו בתוכנה. לאחר מכן מתבצעת קריאה לחומרה כדי לבצע את הפעולה עם Digest::NONE.
• Tag::PADDING מציין את הערך מצבי מרווח פנימי שניתן להשתמש בהם עם המפתח החדש. הטמעות שלא תומכים בכל האלגוריתמים של התקציר, צריך PaddingMode::RSA_PSS ו-PaddingMode::RSA_OAEP אינץ' את הרשימה של מאפייני המפתח שנאכפת על ידי התוכנה, אם יש כאלה מוגדרים אלגוריתמים של תקציר.

מפתחות ECDSA

רק תג::KEY_SIZE הוא שנדרש כדי ליצור מפתח ECDSA. הוא משמש לבחירת קבוצת ההמרות המשופרות. הערכים הנתמכים הם 224, 256, 384 ו-521, שמציינים את עקומות NIST p-224, p-256, p-384 ו-p521 בהתאמה.

Tag::DIGEST נדרש גם למפתח ECDSA שימושי, אבל לא נדרשת כדי ליצור את התוכן.

מפתחות AES

רק תג::KEY_SIZE יש צורך כדי ליצור מפתח AES. אם לא צוין, ה-method תחזיר ErrorCode::UNSUPPORTED_KEY_SIZE הערכים שנתמכים הם: 128 ו-256, עם תמיכה אופציונלית במפתחות AES של 192 ביט.

הפרמטרים הבאים רלוונטיים במיוחד למפתחות AES, אבל לא שנדרש כדי ליצור אתר:

• Tag::BLOCK_MODE מציין את מצבי החסימה שבהם ניתן להשתמש במפתח החדש.
• Tag::PADDING מציין את מצבי המרווח הפנימי שעשויים להיות בשימוש. האפשרות הזו רלוונטית רק למצבים ECB ו-CBC.

אם צוין מצב בלוק GCM, עליך לציין את תג::MIN_MAC_LENGTH. אם לא מציינים את הפרמטר הזה, השיטה מחזירה ErrorCode::MISSING_MIN_MAC_LENGTH. ערך התג הוא כפולה של 8 ובין 96 ל-128.

מקשי HMAC

כדי ליצור מפתח HMAC, נדרשים הפרמטרים הבאים:

• תג::KEY_SIZE מציין את גודל המפתח בביטים. ערכים קטנים מ-64 וערכים שאינם כפולות של 8 אינם נתמכים. הכול יש תמיכה בכפולות של 8, בין 64 ל-512. ערכים גדולים יותר יכולים להיות נתמך.
• תג::MIN_MAC_LENGTH מציין את האורך המינימלי של כתובות MAC שאפשר ליצור או לאמת באמצעות המפתח הזה. הערך הוא כפולה של 8 ולפחות 64.
• Tag::DIGEST מציין את אלגוריתם התקציר של המפתח. בדיוק צוין תקציר אחד, אחרת מוחזר ErrorCode::UNSUPPORTED_DIGEST אם התקציר לא נתמך באמצעות ה-Trustlet, צריך להחזיר ErrorCode::UNSUPPORTED_DIGEST

מאפיינים מרכזיים

אם הארגומנט 'מאפיינים' הוא לא NULL, הפונקציה generateKey מחזירה של המפתח החדש שנוצר מחולקים כראוי רשימות שנאכפות באמצעות חומרה או תוכנה. צפייה getKeyCharacteristics לתיאור אילו מאפיינים נכללים בכל רשימה. המאפיינים שהוחזרו כוללים את כל הפרמטרים שצוינו בתהליך יצירת המפתחות, מלבד תג::APPLICATION_ID וגם תג::APPLICATION_DATA. אם התגים האלה נכללו בפרמטרים של המפתח, הם יוסרו של המאפיינים המוחזרים, כך שאי אפשר יהיה למצוא את הערכים שלהם באמצעות בדיקת ה-blob של המפתח שהוחזר. עם זאת, הן קשורות מבחינה קריפטוגרפית ל-blob של המפתח, כך שאם הערכים הנכונים לא יסופקו כשהמפתח בשימוש, השימוש נכשל. באופן דומה, התג::ROOT_OF_TRUST הוא מקושר למפתח מבחינה קריפטוגרפית, אבל לא ניתן לציין אותו ביצירת מפתחות או בייבוא של מפתחות והם לא מוחזרים.

בנוסף לתגים שסופקו, ה-Trustlet מוסיף תג::מקור, עם הערך KeyOrigin::GENERATED, ואם המפתח עמיד בפני החזרה,

עמידות לרולבק

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

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

getKeyCharacteristics

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור השם get_key_characteristics שונה ב-Keymaster 3.

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

אם סיפקת את Tag::APPLICATION_ID במהלך יצירת המפתח או ייבוא, אותו ערך מסופק השיטה הזו בארגומנט clientId. אחרת, הפרמטר הפונקציה מחזירה את הערך ErrorCode::INVALID_KEY_BLOB. באופן דומה, אם סיפקת את Tag::APPLICATION_DATA במהלך היצירה או ייבוא, אותו ערך מסופק השיטה הזו בארגומנט appData.

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

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

• Tag::ALGORITHM, תג::KEY_SIZE, ותג::RSA_PUBLIC_EXPONENT הן תכונות מהותיות של המפתח. לכל מפתח שמאובטח באמצעות חומרה, התגים האלה יופיעו ברשימה של אכיפת החומרה.
• ערכי Tag::DIGEST שנתמכים על ידי החומרה המאובטחת, ממוקמים רשימה עם תמיכה בחומרה. תקצירים שלא נתמכים יופיעו ברשימת התקצירים שנתמכים על ידי תוכנות.
• ערכים של Tag::PADDING בדרך כלל נכללות ברשימה שנתמכת על ידי חומרה, אלא אם יכולת לבצע מצב מרווח פנימי ספציפי. במקרה כזה, הם יופיעו ברשימה שנאכפים על ידי התוכנות. אפשרות כזו מופיעה במפתחות RSA שמאפשרים מרווח פנימי מסוג PSS או OAEP עם אלגוריתמים לתקציר שאינם נתמכים על ידי החומרה המאובטחת.
• תג::USER_SECURE_ID ותג::USER_AUTH_TYPE נאכפות באמצעות חומרה רק אם מתבצעת אכיפה של אימות משתמש על ידי חומרה. שפת תרגום לעשות זאת, את האמינות של Keymaster ואת האימות הרלוונטי ה-Trustlet צריך להיות מאובטח ולשתף מפתח HMAC סודי שמשמש לחתימה לאמת אסימוני אימות. לצפייה אימות לפרטים נוספים.
• תג::ACTIVE_DATETIME, תג::: POLICYATION_EXPIRE_DATETIME, ו-Tag::USAGE_EXPIRE_DATETIME נדרשת גישה לשעון קיר תקין שאומת. החומרה המאובטחת ביותר מקבל גישה רק לנתוני הזמן שמסופקים על-ידי מערכת ההפעלה הלא מאובטחת, פירושו שהתגים נאכפים.
• התג::Origin תמיד נמצאת ברשימת החומרה למפתחות שקשורים לחומרה. הנוכחות שלו היא הדרך שבה שכבות גבוהות יותר קובעות שמפתח מגובה בחומרה.

מפתח ייבוא

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור import_key השם שלו השתנה ב-Keymaster 3.

מייבאת חומר מפתח לחומרת Keymaster. פרמטרים של הגדרת מפתחות מאפייני הפלט מטופלים באופן זהה לזה של generateKey, למעט המקרים הבאים:

• תג::KEY_SIZE וגם תג::RSA_PUBLIC_EXPONENT (רק במפתחות RSA) אין צורך בפרמטרים של הקלט. אם לא תספקו אותו, ה-Trustlet מפיק את הערכים מחומר המפתח שסופק ומוסיף של התגים והערכים המתאימים למאפייני המפתח. אם הפרמטרים שצוין, ה-Trustlet מאמת אותם מול חומר המפתח. ב אירוע של אי התאמה, השיטה מחזירה ErrorCode::IMPORT_PARAMETER_MISMATCH.
• התג: MY שהוחזר כולל את זהה לערך KeyOrigin::IMPORTED.

מפתח ייצוא

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור export_key השם שלו השתנה ב-Keymaster 3.

מייצאת מפתח ציבורי מזוג מפתחות RSA או EC של Keymaster.

אם סיפקת את Tag::APPLICATION_ID במהלך יצירת מפתח או , אותו ערך מסופק לשיטה זו ארגומנט clientId. אחרת, ה-method מחזירה ErrorCode::INVALID_KEY_BLOB באופן דומה, אם Tag::APPLICATION_DATA שצוין במהלך היצירה או הייבוא, אותו ערך ניתן השיטה הזו בארגומנט appData.

מקש Delete

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור delete_key השם שלו השתנה ב-Keymaster 3.

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

מחיקתAllKeys

גרסה: 1, 2, 3

הפונקציה הזו הוצגה ב-Keymaster 1 בתור delete_all_keys השם שלו השתנה ב-Keymaster 3.

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

השמדה של מזהי אימות

גרסה: 3

השיטה destroyAttestationIds() משמשת כדי לבצע באופן קבוע השבתת ההגדרה החדשה (אופציונלי, אבל מומלץ מאוד) אימות (attestation) באמצעות תעודה מזהה . אם לצוות ה-TEE אין דרך להבטיח שאימות המזהה באופן קבוע מושבתת אחרי הקריאה לשיטה הזו, אז לא ניתן לבצע אימות זהות (IDV) בכלל, במקרה כזה, השיטה הזו לא עושה דבר הפונקציה מחזירה את הערך ErrorCode::UNIMPLEMENTED. אם אימות הזהות (attestation) הוא נתמך, צריך להטמיע את השיטה הזו וצריך להשבית אותה באופן סופי כל הניסיונות העתידיים לאימות הזהות. ניתן לקרוא לשיטה כל מספר פעמים. אם אימות הזהות (attestation) באמצעות המזהה מושבת כבר באופן סופי, השיטה כלום ומחזיר את הערך ErrorCode::OK.

קודי השגיאה היחידים ששיטה זו עשויה להחזיר הם ErrorCode::UNIMPLEMENTED (אם אין תמיכה באימות המזהה) ErrorCode:OK, ErrorCode::KEYMASTER_NOT_CONFIGURED או אחד מקודי השגיאה שמצביע על כשל בתקשורת עם חומרה.

התחלה

גרסה: 1, 2, 3

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

הטמעת Keymaster תומכת לפחות ב-16 שידורים בו-זמנית ב-AI. ב-Keystore נעשה שימוש ב-15 לכל היותר, ואחד מהם משמש לסיסמה ב-Keystore הצפנה. כשמתבצעות ב-Keystore 15 פעולות (ב-begin יש בוצעה קריאה, אבל finish או abort עדיין לא נקרא) והוא מקבל בקשה להתחיל ב-16 בחודש, abort בפעולה שנעשה בה שימוש הכי פחות לאחרונה כדי לצמצם את מספר פעילות עד 14 לפני קריאה ל-begin כדי להתחיל פעולה חדשה שהתבקשה.

אם תג::APPLICATION_ID או Tag::APPLICATION_DATA שצוינו במהלך יצירה או ייבוא של מפתחות, הקריאות ל-begin כוללות אותם עם הערכים שצוינו במקור בארגומנט inParams לשיטה הזו.

אכיפת הרשאות

במהלך השיטה הזו, הרשאות המפתחות הבאות נאכפות על ידי Trustlet ואם הפעולה היא לא פעולה של מפתח ציבורי. מפתח ציבורי כלומר KeyPurpose::ENCRYPT ו-KeyPurpose::VERIFY, עם מפתחות RSA או EC, יכולים להצליח גם אם לא עומדים בדרישות.

• Tag::PURPOSE: המטרה שצוין בקריאה begin() צריך להתאים לאחת מהמטרות בהרשאות המפתח, אלא אם הפעולה המבוקשת היא מפתח ציבורי פעולה. אם המטרה שצוינה לא מתאימה והפעולה לא פעולה של מפתח ציבורי, הפונקציה begin תחזיר ErrorCode::UNSUPPORTED_PURPOSE. הפעולות של המפתח הציבורי הן של הצפנה אסימטרית או פעולות אימות.
• תג::ACTIVE_DATETIME רק אם יש מקור זמן מהימן לפי שעון UTC, אם התאריך והשעה הנוכחיים לפני ערך התג, השיטה מחזירה ErrorCode::KEY_NOT_YET_VALID
• תג::בתוך POLICYATION_EXPIRE_DATETIME רק אם יש מקור זמן מהימן לפי שעון UTC, אם התאריך והשעה הנוכחיים מאוחרים מערך התג, והמטרה היא KeyPurpose::ENCRYPT או KeyPurpose::SIGN, ה-method הפונקציה מחזירה את הערך ErrorCode::KEY_EXPIRED.
• תג::USAGE_EXPIRE_DATETIME רק אם יש מקור זמן מהימן לפי שעון UTC, אם התאריך והשעה הנוכחיים מאוחרים מערך התג, והמטרה היא KeyPurpose::DECRYPT או KeyPurpose::VERIFY, ה-method הפונקציה מחזירה את הערך ErrorCode::KEY_EXPIRED.
• תג:: :MIN_SECONDS_BETWEEN_OPS בהשוואה לטיימר יחסי מהימן שמציין את השימוש האחרון ב עיקרי אם זמן השימוש האחרון וערך התג נמוכים מהשעה הנוכחית, ה-method מחזירה את הערך ErrorCode::KEY_RATE_LIMIT_EXCEEDED. לצפייה תיאור התג לפרטים חשובים על ההטמעה.
• תג::MAX_USES_PER_BOOT בהשוואה למונה מאובטח שעוקב אחרי השימוש במפתח מאז זמן האתחול. אם מספר השימושים הקודמים חורג מערך התג, הפרמטר הפונקציה מחזירה את הערך ErrorCode::KEY_MAX_OPS_EXCEEDED.
• תג::USER_SECURE_ID נאכפת בשיטה הזו רק אם המפתח כולל גם תג::AUTH_TIMEOUT. אם במפתח יש את שניהם, השיטה הזו חייבת לקבל תג::AUTH_TOKEN ב- inParams. כדי שאסימון האימות יהיה תקף, כל התנאים הבאים צריך להיות נכון:
  • השדה HMAC מאומת כראוי.
  • לפחות אחד מהערכים תג::USER_SECURE_ID מהמפתח תואמים לפחות לאחד מערכי המזהה המאובטח ב-Assistant.
  • למפתח יש תג::USER_AUTH_TYPE שתואם לסוג האימות באסימון.

  אם אחד מהתנאים האלה לא מתקיים, השיטה תחזיר ErrorCode::KEY_USER_NOT_AUTHENTICATED

• תג::CALLER_NONCE מאפשרת לקורא לציין וקטור צופן או אתחול (IV). אם המפתח לא מכיל את התג הזה, אבל המתקשר/ת סיפק/ה תג::NONCE לשיטה הזו, השדה ErrorCode::CALLER_NONCE_PROHIBITED הוחזר.
• תג::BOOTLOADER_ONLY מציין שרק תוכנת האתחול יכולה להשתמש במפתח. אם השיטה הופעלה באמצעות מפתח תוכנת אתחול בלבד לאחר שתוכנת האתחול סיימה להפעיל, הפונקציה מחזירה את הערך ErrorCode::INVALID_KEY_BLOB.

מפתחות RSA

כל הפעולות של מפתחות ה-RSA מציינות בדיוק מצב מרווח פנימי אחד ב-inParams. אם לא צוין או צוין יותר מפעם אחת, השיטה תחזיר ErrorCode::UNSUPPORTED_PADDING_MODE

כדי לבצע פעולות חתימה ואימות של RSA, נדרש תקציר, וכך גם הצפנת RSA ופעולות פענוח באמצעות מצב מרווח פנימי של OAEP. במקרים כאלה, המתקשר מציין תקציר אחד בדיוק ב-inParams. אם לא צוין או צוין יותר מפעם אחת, ה-method מחזירה ErrorCode::UNSUPPORTED_DIGEST.

פעולות של מפתח פרטי (KeyPurpose::DECYPT ו-KeyPurpose::SIGN) נדרשת הרשאה של תקציר ומרווח פנימי, כלומר שהרשאות המפתח צריכה להכיל את הערכים שצוינו. אחרת, ה-method תחזיר ErrorCode::INCOMPATIBLE_DIGEST או ErrorCode::INCOMPATIBLE_PADDING, לפי הצורך. פעולות של מפתח ציבורי (KeyPurpose::ENCRYPT ו-KeyPurpose::VERIFY) מותרים עם תקציר או מרווח פנימי לא מורשה.

מלבד PaddingMode::NONE, כל מצבי המרווח הפנימי של מודעות ה-RSA הם רלוונטית למטרות מסוימות בלבד. ובאופן ספציפי, PaddingMode::RSA_PKCS1_1_5_SIGN ו-PaddingMode::RSA_PSS תומכים רק בחתימה ואימות, ואילו PaddingMode::RSA_PKCS1_1_1_5_ENCRYPT ו-PaddingMode::RSA_OAEP תומכים רק בהצפנה ובפענוח. השיטה מחזירה את הערך ErrorCode::UNSUPPORTED_PADDING_MODE אם המצב שצוין לא תומך למטרה שצוינה.

יש כמה אינטראקציות חשובות בין מצבי המרווח הפנימי והתקצירים:

• PaddingMode::NONE מציין פעולת RSA היא שבוצעו. אם מתבצעת חתימה או אימות, הערך של Digest::NONE הוא שצוינו לתקציר. לא נדרש תקציר עבור הצפנה ללא מרווח או של הפענוח.
• המרווח הפנימי של PaddingMode::RSA_PKCS1_1_5_SIGN מחייב תקציר. התקציר יכול להיות Digest::NONE. במקרה כזה, ה-Keymaster לא יכול ליצור מבנה מתאים של חתימות PKCS#1 v1.5, כי הוא לא יכול להוסיף את מבנה DigestInfo. במקום זאת, יוצר את 0x00 || 0x01 || PS || 0x00 || M, כאשר M הוא ו-PS הוא מחרוזת המרווח הפנימי. הגודל של מפתח ה-RSA צריך יהיה לפחות 11 בייטים גדולים יותר מההודעה. אחרת, ה-method תחזיר ErrorCode::INVALID_INPUT_LENGTH
• המרווח הפנימי של PaddingMode::RSA_PKCS1_1_1_5_ENCRYPT לא מחייב תקציר.
• המרווח הפנימי של PaddingMode::RSA_PSS מחייב תקציר, אבל לא בהכרח Digest::NONE. אם צוין Digest::NONE, הפונקציה מחזירה ErrorCode::INCOMPATIBLE_DIGEST. בנוסף, הגודל של מפתח ה-RSA צריך להיות גדול ב-2 בייטים + D לפחות מהפלט גודל התקציר, כאשר D הוא הגודל של התקציר בבייטים. אחרת ה-method מחזירה את הערך ErrorCode::INCOMPATIBLE_DIGEST. גודל ה-salt הוא י.
• המרווח הפנימי של PaddingMode::RSA_OAEP מחייב תקציר, אבל לא בהכרח Digest::NONE. אם צוין Digest::NONE, הפונקציה מחזירה ErrorCode::INCOMPATIBLE_DIGEST.

מפתחות EC

פעולות של מפתח EC מציינות מצב מרווח פנימי אחד בדיוק ב-inParams. אם לא צוין או צוין יותר מפעם אחת, השיטה הפונקציה מחזירה את הערך ErrorCode::UNSUPPORTED_PADDING_MODE.

לפעולות של מפתח פרטי (KeyPurpose::SIGN) נדרשת הרשאה תקציר ומרווח פנימי, כלומר שהרשאות המפתח צריכה להכיל את הערכים שצוינו. אם לא, צריך להחזיר ErrorCode::INCOMPATIBLE_DIGEST פעולות של מפתח ציבורי (KeyPurpose::VERIFY) מותרים עם תקציר או מרווח פנימי לא מורשה.

מפתחות AES

פעולות של מפתח AES מציינות מצב בלוק אחד ומצב מרווח פנימי אחד בדיוק ב-inParams. אם אחד מהערכים לא צוין או שצוין יותר יותר מפעם אחת, מוחזר ErrorCode::UNSUPPORTED_BLOCK_MODE או ErrorCode::UNSUPPORTED_PADDING_MODE. המצבים שצוינו צריכים להיות מורשה על ידי המפתח, אחרת השיטה תחזיר ErrorCode::INCOMPATIBLE_BLOCK_MODE או ErrorCode::INCOMPATIBLE_PADDING_MODE.

אם מצב החסימה הוא BlockMode::GCM, inParams מציין את Tag::MAC_LENGTH, הערך שצוין הוא כפולה של 8 שלא גדולה מ-128 או קטן מהערך של Tag::MIN_MAC_LENGTH בהרשאות למפתחות. עבור אורכי MAC שגדולים מ-128 או אי-כפולות של 8, החזרת ErrorCode::UNSUPPORTED_MAC_LENGTH. לערכים נמוכים מהאורך המינימלי של המפתח, מוחזר ErrorCode::INVALID_MAC_LENGTH.

אם מצב החסימה הוא BlockMode::GCM או BlockMode::CTR, מצב המרווח הפנימי שצוין צריך להיות PaddingMode::NONE. יכול להיות שהמצב ב-BlockMode::ECB או ב-BlockMode::CBC יהיה PaddingMode::NONE או PaddingMode::PKCS7. אם מדובר במצב מרווח פנימי לא עומד בתנאים האלה, יש להחזיר את הערך ErrorCode::INCOMPATIBLE_PADDING_MODE.

אם מצב החסימה הוא BlockMode::CBC, BlockMode::CTR, או BlockMode::GCM, יש צורך בווקטור אתחול או צופן חד-פעמי. ברוב המקרים, המתקשרים לא צריכים לספק עירום או צופן חד-פעמי. במקרה הזה, הפרמטר הטמעת Keymaster יוצרת IV או צופן אקראי ומחזירה אותם דרך תג::NONCE ב-outParams. CBC ו-CTR IV הם 16 בייטים. צפנים חד-פעמיים ב-GCM הם באורך 12 בייטים. אם המפתח ההרשאות כוללות תג::CALLER_NONCE, אז המתקשר יוכל לספק IV או אף פעם תג::NONCE ב-inParams. אם ניתן צופן חד-פעמי (nonce) תג::CALLER_NONCE אין הרשאה, יש להחזיר את הערך ErrorCode::CALLER_NONCE_PROHIBITED. אם לא ניתן צופן חד-פעמי (nonce) תג::CALLER_NONCE מורשה, צור מספר IV/צופן אקראי.

מקשי HMAC

פעולות של מפתח HMAC מציינות את Tag::MAC_LENGTH ב-inParams. הערך שצוין חייב להיות כפולה של 8 שאינו גדול מהערך אורך התקציר או קטן מהערך של Tag::MIN_MAC_LENGTH בהרשאות המפתח. עבור אורכי MAC שאורכם עולה על אורך התקציר או מספרים שאינם כפולות של 8, הפונקציה מחזירה את הערך ErrorCode::UNSUPPORTED_MAC_LENGTH. לערכים קצרים מהאורך המינימלי של המפתח, יש להחזיר ErrorCode::INVALID_MAC_LENGTH

עדכון

גרסה: 1, 2, 3

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

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

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

טיפול בשגיאות

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

אכיפת הרשאות

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

• תג::USER_SECURE_IDs אחד או יותר, וגם
• לא מכיל תג::AUTH_TIMEOUT

במקרה כזה, למפתח נדרשת הרשאה לכל פעולה, והעדכון method מקבלת תג::AUTH_TOKEN בארגומנט inParams. HMAC מאמת שהאסימון חוקי ומכיל מזהה משתמש מאובטח תואם, שתואם למפתח תג::USER_AUTH_TYPE, ומכיל את מזהה הפעולה של הפעולה הנוכחית לאתגר. אם התנאים האלה לא מתקיימים, הפונקציה תחזיר ErrorCode::KEY_USER_NOT_AUTHENTICATED

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

מפתחות RSA

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

מפתחות ECDSA

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

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

מפתחות AES

מצב AES GCM תומך ב'נתוני אימות משויכים', סופקו דרך תג::ASSOCIATED_DATA בארגומנט inParams. יכול להיות שהנתונים המשויכים יסופקו בשיחות חוזרות (חשוב אם הנתונים גדולים מדי לשליחה בקטע אחד), אך תמיד מופיעים לפני הנתונים כדי שהם יהיו מוצפנים או מפוענחים. שיחת עדכון עשויה לקבל את שני הנתונים המשויכים ונתונים להצפנה/פענוח, אבל עדכונים נוספים עשויים שלא לכלול . אם המתקשר מספק נתונים משויכים לשיחת עדכון אחרי שיחה שכולל נתונים להצפנה/לפענוח, ולהחזיר ErrorCode::INVALID_TAG.

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

סיום

גרסה: 1, 2, 3

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

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

השיטה הזו מסיימת את התהליך הפעולה הזו מבטלת את התוקף של כינוי הפעולה שצוין. כלשהו לשימוש עתידי בכינוי, באמצעות השיטה הזו או עדכון abort, הפונקציה מחזירה ErrorCode::INVALID_OPERATION_HANDLE.

פעולות חתימה מחזירות את החתימה כפלט. פעולות אימות לקבל את החתימה בפרמטר signature, ולא להחזיר פלט.

אכיפת הרשאות

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

• אחד או יותר תג::USER_SECURE_IDs, וגם
• לא מכיל תג::AUTH_TIMEOUT

במקרה כזה, למפתח נדרשת הרשאה לכל פעולה, והעדכון method מקבלת תג::AUTH_TOKEN בארגומנט inParams. HMAC מאמת שהאסימון חוקי ומכיל מזהה משתמש מאובטח תואם, שתואם למפתח תג::USER_AUTH_TYPE, וגם מכיל את מזהה הפעולה של הפעולה הנוכחית לאתגר. אם התנאים האלה לא מתקיימים, הפונקציה תחזיר ErrorCode::KEY_USER_NOT_AUTHENTICATED

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

מפתחות RSA

דרישות נוספות, בהתאם למצב המרווח הפנימי:

• PaddingMode::NONE לצורך פעולות חתימה והצפנה ללא ריפוד, אם הנתונים שסופקו קצרים מהמפתח, הנתונים לא ימולאו בצד ימין לפני חתימה/הצפנה. אם הנתונים באותו אורך כמו המפתח, אבל במספר גדול יותר, הפונקציה מחזירה את הערך ErrorCode::INVALID_ARGUMENT. עבור אימות ופענוח, הנתונים חייבים להיות באורך בדיוק בתור המפתח. אחרת, צריך להחזיר את הערך ErrorCode::INVALID_INPUT_LENGTH.
• PaddingMode::RSA_PSS עבור פעולות חתימה עם ריפוד PSS, ה-salt של PSS הוא הגודל של תקציר ההודעות שנוצר באופן אקראי. התקציר שצוין עם Tag::DIGEST ב-inputParams בתאריך begin משמש כתקציר PSS ובתור אלגוריתם התקציר MGF1.
• PaddingMode::RSA_OAEP התקציר שצוין עם תג::DIGEST ב- inputParams בתאריך התחלה משמש כ-OAEP אלגוריתם התקציר, ו-SHA1 משמש כאלגוריתם התקציר MGF1.

מפתחות ECDSA

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

מפתחות AES

כמה תנאים נוספים, בהתאם למצב החסימה:

• BlockMode::ECB או BlockMode::CBC. אם המרווח הפנימי הוא PaddingMode::NONE אורך הנתונים אינו כפולה של גודל בלוק AES, יש להחזיר ErrorCode::INVALID_INPUT_LENGTH. אם המרווח הפנימי הוא PaddingMode::PKCS7, מתאמים את הנתונים בהתאם למפרט PKCS#7. לתשומת ליבכם: PKCS#7 ממליץ להוסיף בלוק מרווח פנימי נוסף. אם הנתונים מכילים כפולה מאורך הבלוק.
• BlockMode::GCM במהלך ההצפנה, לאחר העיבוד כל טקסט ללא הצפנה, חשבו את התג (תג::MAC_LENGTH בייטים) ומצרפים אותו לטקסט המוצפן שהוחזר. במהלך הפענוח, מעבדים התג האחרון::MAC_LENGTH בייטים בתור התג. אם אימות התג נכשל, צריך לחזור ErrorCode::VERIFICATION_FAILED

לבטל

גרסה: 1, 2, 3

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

get_supported_algorithms

גרסה: 1

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

הטמעות של Keymaster 1 תומכות ב-RSA, EC, AES ו-HMAC.

get_supported_block_modes

גרסה: 1

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

ל-RSA, EC ו-HMAC, שאינם הצפנות בלוקים, השיטה מחזירה ריקה לכל המטרות החוקיות. מטרות לא חוקיות אמורות לגרום ל-method החזרה במחיר ErrorCode::INVALID_PURPOSE.

הטמעות Keymaster 1 תומכות ב-ECB, ב-CBC, ב-CTR וב-GCM ל-AES של הצפנה ופענוח.

get_supported_pann_modes

גרסה: 1

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

ל-HMAC ול-EC אין מושג של מרווח פנימי ולכן השיטה מחזירה רשימה ריקה לכל המטרות החוקיות. מטרות לא חוקיות אמורות לגרום ל-method להחזיר ErrorCode::INVALID_PURPOSE

בהטמעות של RSA, הטמעות Keymaster 1 תומכות:

• הצפנה, פענוח, חתימה ואימות ללא טקסט נוסף. ללא ריפוד הצפנה וחתימה, אם ההודעה קצרה יותר מהמודול הציבורי, והטמעות חייבות להוסיף לו אפסים שמאליים. לפענוח ללא ריפוד אימות, אורך הקלט חייב להתאים לגודל המודולוס הציבורי.
• מצבי הצפנה ומרווח פנימי של חתימה בגרסה 1.5 של PKCS#1
• PSS עם אורך salt מינימלי של 20
• OAEP

ל-AES במצבי ECB ו-CBC, הטמעות Keymaster 1 לא תומכות מרווח פנימי ו-PKCS#7. מצבי CTR ו-GCM תומכים רק במרווח פנימי.

get_supported_digests

גרסה: 1

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

אין מצבי AES שתומכים בתקציר או מחייבים תקציר, לכן השיטה מחזירה ערך ריק למטרות חוקיות.

הטמעות של Keymaster 1 יכולות להטמיע קבוצת משנה של של התקצירים. הטמעות מספקות SHA-256 ויכולה לספק MD5, SHA1, SHA-224 SHA-256, SHA384 ו-SHA512 (הקבוצה המלאה של תקצירים מוגדרים).

get_supported_Import_formats

גרסה: 1

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

הטמעות של Keymaster 1 תומכות בפורמט PKCS#8 (ללא סיסמה להגנה) לייבוא זוגות של מפתחות RSA ו-EC, ולתמיכה בייבוא RAW של חומר מפתחות AES ו-HMAC.

get_supported_export_formats

גרסה: 1

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

הטמעות של Keymaster1 תומכות בפורמט X.509 לייצוא RSA מפתחות ציבוריים של ההמרות המשופרות. אין תמיכה בייצוא של מפתחות פרטיים או מפתחות אסימטריים.

פונקציות היסטוריות

מאסטר מפתח 0

הפונקציות הבאות שייכות להגדרה המקורית של Keymaster 0. הם היו ב-Keymaster 1 struct struct ב-keymaster1_device_t. אבל, ב-Keymaster 1.0 הם לא הוטמעו, והסמנים של הפונקציות שלהם הוגדרו ל-NULL.

• generate_keypair
• import_keypair
• get_keypair_public
• delete_keypair
• delete_all
• sign_data
• Verify_data

Keymaster 1

הפונקציות הבאות שייכות להגדרה של Keymaster 1, אבל הוסרו ב-Keymaster 2, יחד עם הפונקציות של Keymaster 0 שצוינו למעלה.

• get_supported_algorithms
• get_supported_block_modes
• get_supported_padding_modes
• get_supported_digests
• get_supported_import_formats
• get_supported_export_formats

Keymaster 2

הפונקציות הבאות שייכות להגדרה של Keymaster 2, אבל הוסרה ב-Keymaster 3, יחד עם הפונקציות של Keymaster 1 שצוינו למעלה.

• configure