אבטחה עם Arduino: Atecc608a: 7 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

נוֹשֵׂא

שלום לכולם !

זהו מאמר ההוראה הראשון שלי, כך שאני מקווה שיהיה מעניין לכולכם.

במאמר זה אסביר לך כיצד להשתמש בשבב מיקרו בשם "ATECC608A" המספק כלי אבטחה מרובים.

שבב זה תוכנן על ידי MicroChip והוא הגרסה האחרונה של "שבב CryptoAuthentication". לפני גרסה זו, היו "ATSHA204A" ו- "ATECC508A".

מדוע החלטתי להשתמש בגרסה האחרונה ולא בגרסה הקודמת?

גרסה זו היא השבב המתקדם ביותר וקיבלה פונקציות שאין לגרסה הישנה (לדוגמה: מודול AES, מודול הגנה IO …).

למה הפרויקט הזה?

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

הוא הראה לנו עם מחשב משלו ומרחרח בלוטות 'שכל פקודה שנשלחת על ידי הסמארטפון זהה בכל פעם וזה מאוד פשוט להעתיק פקודה זו ושלח אותה עם הסמארטפון שלכם. הוא הסביר לנו ש"אבטחה "ל"תעשייה" אינה הבעיה העיקרית. הוא הראה לנו שבבים (פחות מ- 0.60 $) שיכולים להוסיף שכבת אבטחה לאובייקטים אלה.

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

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

מה הרעיון שלי?

במהלך תקשורת בין שני אובייקט IoT, יכולות להיות התקפות מרובות: Man Of the mild, העתק מידע ועוד.. אז הרעיון שלי מאוד פשוט:

1. ניצול נתונים מוצפנים בין שני אובייקט IoT או יותר.
2. אספקה בעלות נמוכה
3. יכול לעבוד עם UNO Arduino

עכשיו אסביר לך כיצד יישמתי את התמונה המופשטת הזו עם Arduino ושבב Atecc608a. במאמר זה אסביר לך כיצד להשתמש ב- UNO Arduino עם ATECC608A.

אכתוב מאמר על תקשורת של שני אובייקטים בפעם הבאה.

אספקה

אתה צריך כמה דברים לפרויקט הזה:

1. Arduino UNO או MEGA (שבב חייב להיות Atmega 328 או ATMEGA 2560)
2. שבב Atecc608A (עלות פחות מ- 0.80 $ כל אחד, קל למצוא באתר הספק שלך)
3. מתאם SOIC בעל 8 פינים
4. כמה חוטים ונגדים

גליון הנתונים של הגרסה הקודמת של שבב זה (Atecc508a) זמין כאן -> גליון הנתונים Atecc508a

שלב 1: שלב אחר שלב

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

נבצע את השלבים האלה:

1. עיצוב המעגל
2. תצורת שבב זה
3. ניצול מודול AES CBC
4. למה אתה צריך להשתמש בשבב הזה

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

Github שלי: Github שלי

שלב 2: אזהרה לגבי Atecc608a

שבב Atecc608a אינו שבב "קל".

ראשית, התיעוד של שבב זה נמצא תחת NDA כך שלא תמצא אותו בשלמותו באינטרנט. אך אין בעיה לכך, גיליון הנתונים של הגרסה הקודמת זמין ב- Internet Data Complete Complete ATECC508A.

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

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

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

השבב ATECC608A

אתה יכול לתקשר עם השבב הזה על ידי I2C. ניתן לשנות את כתובת השבב הזה בתצורה.

שבב זה מכיל 16 חריצים שונים שיכולים להכיל סוגים שונים של נתונים:

1. מפתח ECC (פרטי או ציבורי)
2. מפתח AES
3. נתונים אחרים (כמו שאש או רק מילים)

במקרה שלנו, נשמור את מפתח AES בחריץ אחד.

שלב 3: 1. עיצוב המעגל

1. עיצוב המעגל

הסכימה של מעגל זה פשוטה מאוד!

אתה צריך להשתמש בהספק 3.3V מכיוון שההמלצה היא בין 2.0V ל- 5.5V אבל העדפתי להשתמש ב- 3.3V.

עבור שבב זה, בדרך כלל יש לך נקודה בפינה של השבב, נקודה זו היא סיכה 1 של הלוח הזה. הוספתי את המבט העליון של ה- Atecc608a עם מספר PIN מכיוון שהוא SOIC בעל 8 עופרות כך שהשבב קטן מאוד.

1. ARDUINO 3.3V -> PIN 8 (Atecc608a)
2. ARDUINO GND -> PIN 4 (Atecc608a)
3. ARDUINO A4 (SDL) -> PIN 5 (Atecc608a)
4. ARDUINO A5 (SCL) -> PIN 6 (Atecc608a)

אתה צריך להשתמש בהספק 3.3V מכיוון שההמלצה היא בין 2.0V ל- 5.5V אבל העדפתי להשתמש ב- 3.3V.

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

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

שלב 4: 2. תצורת השבב (Atecc608a)

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

אזהרה: שלב זה הוא ייבוא מאוד ואם אתה נועל את האזורים לפני הסוף לא תוכל לשנות אותם.

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

1. אזור תצורה
2. אזור נתונים

אזור התצורה קיבל גודל של 128 בתים אך לא ניתן לשנות את 16 הבייטים הראשונים.

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

1. צור תבנית תצורה
2. כתוב תבנית זו לשבב
3. נעל את אזור התצורה
4. כתוב את מפתח ה- AES שלך (128 ביט) בחריץ
5. נעל את אזור הנתונים

מֵידָע

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

• Github שלי: Github שלי
• נתיב תצורה לדוגמה: config_example.ino

שלב ראשון: צור תבנית תצורה

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

1. Bytes 16 -> זוהי כתובת I2C של השבב
2. בתים 20 עד 51 -> אתה יכול לשנות כאן את סוג החריץ עבור 16 החריצים של שבב זה
3. Bytes 96 עד 127 -> אתה יכול להגדיר כאן את סוג המפתח או הנתונים המשמשים כל חריץ.

(אם אתה צריך הסבר נוסף של כל האזור הזה, אנא קרא את התיעוד (עמוד 13, סעיף 2.2))

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

0xC0, // כתובת I2C

0x00, 0x00, 0x00, 0x83, 0x20, // חריץ Config חריץ 1 0x85, 0x20, // חריץ Config חריץ 2 0x8F, 0x20, // חריץ Config חריץ 3 0xC4, 0x8F, // חריץ Config חריץ 4 0x8F, 0x8F, // חריץ Config חריץ 5 0x8F, 0x8F, // חריץ Config חריץ 6 0x9F, 0x8F, // חריץ Config חריץ 7 0x0F, 0x0F, // חריץ Config חריץ 8 0x8F, 0x0F, // חריץ Config חריץ 9 0x8F, 0x0F, // חריץ Config חריץ 10 0x8F, 0x0F, // חריץ Config חריץ 11 0x8F, 0x0F, // חריץ Config חריץ 12 0x8F, 0x0F, // חריץ Config חריץ 13 0x00, 0x00, // חריץ Config חריץ 14 0x00, 0x00, // חריץ Config חריץ 15 0xAF, 0x8F, // חריץ Config חריץ 16 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x00, // חריץ תצורת מפתח 1 0x33, 0x00, // חריץ תצורת מפתח 2 0x33, 0x00, // חריץ תצורת מפתח 3 0x1C, 0x00, // חריץ תצורת מפתח 4 0x1C, 0x00, // חריץ תצורת מפתח 5 0x 1C, 0x00, // חריץ תצורת מפתחות 6 חריץ 0x1C, 0x00, // מפתח תצורת מפתח 7 0x3C, 0x00, // חריץ תצורת מפתח 8 0x1A, 0x00, // חריץ תצורת מפתח 9 0x3A, 0x00, // חריץ תצורת מפתח 10 0x1A, 0x00, // חריץ תצורת מפתחות 11 0x3A, 0x00, // חריץ תצורת מפתח 12 0x3A, 0x00, // חריץ תצורת מפתח 13 0x3C, 0x00, // חריץ תצורת מפתחות 14 0x3C, 0x00, // חריץ תצורת מפתחות 15 0x1C, 0x00 // חריץ תצורת מפתחות 16

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

במקרה שלך צריך להבין רק שלושה דברים:

1. Bytes 16 -> זוהי כתובת I2C של השבב
2. בתים 20 עד 51 -> אתה יכול לשנות כאן את סוג החריץ עבור 16 החריצים של שבב זה
3. הבייט 96 עד 127 -> אתה יכול להגדיר כאן את סוג המפתח או הנתונים המשמשים כל חריץ.

אני לא אסביר את סוג התצורה ומדוע השתמשתי בזה ולא באחר כי זה מסובך להסביר הכל. אם אתה זקוק למידע נוסף עבור אל התיעוד, עמוד 16 סעיף 2.2.1 עבור "SlotConfig" ודף 19 סעיף 2.2.5 עבור "KeyConfig"

בדוגמה זו, תשתמש בחריץ 9 לאחסון מפתח AES.

לשם כך עלינו לשים (אם אתה צריך, תוכל להעתיק את הדוגמה למעלה, השינוי בוצע בה):

1. בת 36 = 0x8F
2. בת 37 = 0x0F
3. בת 112 = 0x1A
4. בת 113 = 0x00

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

• חריץ יכול להיות כתיבה או קריאה (פעולה ברורה או הצפנה)
• סוג הנתונים המאוחסנים (מפתח ECC, מפתח ציבורי, SHA Hash, AES מפתח …)
• החריץ יכול להיות נעול
• הפקת מפתח מותרת
• …

כשהבייט 36 ו -37 מוגדר ל- "0x0F8F":

• ניתן לכתוב נתונים ב- Clear
• תוכן החריץ הזה סודי ואי אפשר לקרוא אותו
• לא ניתן להשתמש בחריץ עבור הפקודה CheckMac Copy

כשהבייט 112 ו -113 מוגדר ל- "0x001A":

חריץ יכול לאחסן עד ארבעה מפתחות סימטריים של AES 128 סיביות (KeyType = 0x6)

שלב שני: כתוב תצורה זו

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

אך אין מה לדאוג, כל עוד התצורה אינה נעולה, תוכל לשנות את התצורה שלך.

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

/** / brief כתוב תצורה חדשה לשבב.

* / param [in] cfg תצורת ממשק לוגי. ניתן למצוא כמה תצורות * מוגדרות מראש ב- atca_cfgs.h * / param [in] config Array uint8_t של תצורה (אורך 112) * / param [in] len גודל מערך התצורה * / return ATCA_SUCCESS בהצלחה, אחרת קוד שגיאה. */ ATCA_STATUS write_configuration (ATCAIfaceCfg *cfg, uint8_t *config, size_t len) {if (len! = 112) החזר ATCA_BAD_PARAM; סטטוס ATCA_STATUS; סטטוס = atcab_init (cfg); if (status == ATCA_SUCCESS) {// כתוב את מערך התצורה לשבב // ריפוד של 16 בתים (לא ניתן לכתוב 16 בתים ראשונים) status = atcab_write_bytes_zone (ATCA_ZONE_CONFIG, 0, 16, (uint8_t *) config, len); סטטוס החזרה; } סטטוס החזרה; }

פונקציה זו תכתוב את התצורה שלך בשבב.

שלב שלישי: נעל את אזור התצורה

אזהרה: היזהר בשלב זה, אם אתה נועל אזור זה והתצורה שלך אינה טובה, השבב אינו ניתן לשימוש ולא תוכל לשנות אזור זה

לפעולה זו נשתמש בפונקציה זו:

/** / brief בדוק אם ה- DATA_ZONE או CONFIG_ZONE נעולים

* / param [in] cfg תצורת ממשק לוגי. ניתן למצוא כמה תצורות מוגדרות מראש ב- atca_cfgs.h * / param [in] אזור LOCK_ZONE_DATA או LOCK_ZONE_CONFIG * / החזר ATCA_SUCCESS על הצלחה, אחרת קוד שגיאה. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; נעילת בול = שקר; אם (אזור! = (uint8_t) LOCK_ZONE_CONFIG && אזור! = (uint8_t) LOCK_ZONE_DATA) החזר ATCA_BAD_PARAM; סטטוס = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (אזור, & נעילה))) {return ATCA_FUNC_FAIL; } אם (! נעילה) {החזר ATCA_NOT_LOCKED; } החזר ATCA_SUCCESS; } החזר ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_CONFIG);

שלב רביעי: כתוב לך מפתח AES בחריץ

בחלק זה תגדיר לך מפתח AES אישי בחריץ שהגדרת בתצורת השבב.

בדוגמה זו, אשתמש בחריץ מספר 9 של השבב.

אתה צריך לדעת: תכונה מיוחדת של שבב זה היא שאתה יכול לכתוב נתונים בחריץ רק ב -4 בתים או 32 בתים. עבור AES אנחנו צריכים 128 סיביות מפתח כך 16 בתים של נתונים. אז החלטתי לכתוב למפתח של 16 בתים כל אחד בחריץ הזה כדי שיהיו לו 32 בתים.

כעת, אראה לך את הקוד המשמש:

/** / brief כתוב מפתח AES בחריץ נתון. * / param [in] cfg תצורת ממשק לוגי. ניתן למצוא כמה תצורות * מוגדרות מראש ב- atca_cfgs.h * / param [in] מספר מקש מפתח * / param [in] מערך מפתחות datakey uint8_t * / param [in] len גודל מערך המפתחות * / return ATCA_SUCCESS על הצלחה, אחרת קוד שגיאה. */ ATCA_STATUS write_key_slot (ATCAIfaceCfg *cfg, uint8_t key, uint8_t *datakey, size_t len) {if (key 16) return ATCA_BAD_PARAM; אם (len! = 32) החזר ATCA_BAD_PARAM; סטטוס ATCA_STATUS = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_write_zone (ATCA_ZONE_DATA, (uint16_t) מפתח, 0, 0, datakey, 32); אם (סטטוס! = ATCA_SUCCESS) סטטוס החזרה; } סטטוס החזרה; }

בדוגמה זו אשתמש בשני מקשי AES של 16 בתים כל אחד:

// דוגמה ל- AES KEY (len 32) uint8_t example_of_key [32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot (& cfg, 9, example_of_key, sizeof (example_of_key));

אם פעולה זו טובה, כעת, עליך לעבור את השלב האחרון "נעל את אזור הנתונים"

השלב האחרון: נעל את אזור הנתונים

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

לפעולה זו נשתמש בפונקציה זו:

/** / brief בדוק אם ה- DATA_ZONE או CONFIG_ZONE נעולים

* / param [in] cfg תצורת ממשק לוגי. ניתן למצוא כמה תצורות מוגדרות מראש ב- atca_cfgs.h * / param [in] אזור LOCK_ZONE_DATA או LOCK_ZONE_CONFIG * / החזר ATCA_SUCCESS על הצלחה, אחרת קוד שגיאה. */ ATCA_STATUS check_lock_zone (ATCAIfaceCfg *cfg, uint8_t zone) {ATCA_STATUS status; נעילת בול = שקר; אם (אזור! = (uint8_t) LOCK_ZONE_CONFIG && אזור! = (uint8_t) LOCK_ZONE_DATA) החזר ATCA_BAD_PARAM; סטטוס = atcab_init (cfg); if (status == ATCA_SUCCESS) {if (ATCA_SUCCESS! = (status = atcab_is_locked (אזור, & נעילה))) {return ATCA_FUNC_FAIL; } אם (! נעילה) {החזר ATCA_NOT_LOCKED; } החזר ATCA_SUCCESS; } החזר ATCA_BAD_PARAM; } check_lock_zone (& cfg, LOCK_ZONE_DATA);

אם פעולה זו טובה, השבב שלך מוכן לשימוש

שלב 5: 3. ניצול מודול AES CBC

אסביר כיצד להצפין ולפענח נתונים בעזרת האלגוריתם AES CBC והשבב Atecc608a.

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

לשבב זה יש סוג מרובה של מודול AES (AES 128 סיביות), רק AES 128 סיביות אפשריות:

1. AES רגיל
2. AES CBC
3. AES GCM (עם hash GFM) (ראה ויקיפדיה להסבר נוסף)

כדי להקל על השימוש, יצרתי שתי פונקציות:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

שתי הפונקציות האלה זמינות ב- Github שלי.

הֶסבֵּר

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

מֵידָע

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

• Github: ה- Github שלי
• דוגמה לקוד "הצפן/פענוח": AES_crypto_example.ino

שלב ראשון: הצפן את הנתונים שלך

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

ראשית תזדקק לפונקציה זו:

/** / brief הצפנת נתונים באמצעות אלגוריתם AES CBC* / param [in] תצורת ממשק לוגי של cfg. ניתן למצוא כמה תצורות * מוגדרות מראש ב- atca_cfgs.h * / param [in] נתונים מילים לאנצ'פט (יש לחלק ב 16, אורך מקסימלי 240) * / param [in] אורך מילים לאמץ (יש לחלק ב 16, אורך מקסימלי 240) * / param [החוצה] iv וקטור ראשוני המשמש ב- AES CBC (החזר את הווקטור ב- var זה) * / param [החוצה] צופן החזרה כאן הטקסט הצפרי * / param [in] מספר חריץ של ה- מפתח * / החזר ATCA_SUCCESS על הצלחה, אחרת קוד שגיאה. */ ATCA_STATUS aes_cbc_encrypt (ATCAIfaceCfg *cfg, uint8_t *data, int len, uint8_t *iv, uint8_t *ciphertext, uint8_t key) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC && len % 16! = 0) {Serial.print (F ("שגיאה: ATCA_BAD_PARAM")); החזר ATCA_BAD_PARAM; } uint8_t tmp_iv [IV_LENGTH_CBC]; uint8_t tmp_data [len]; סטטוס ATCA_STATUS = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, tmp_iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("ERROR Encrypt: atcab_aes_cbc_init, Code Error 0x")); Serial.println (סטטוס, HEX); לַחֲזוֹר; } memcpy (iv, tmp_iv, IV_LENGTH_CBC); memcpy (tmp_data, data, len); int max = len / 16; עבור (int j = 0; j <max; j ++) {status = atcab_aes_cbc_encrypt_block (& ctx, & tmp_data [j * 16], & ciphertext [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("הצפנת שגיאה: atcab_aes_cbc_encrypt_block, שגיאת קוד 0x")); Serial.println (סטטוס, HEX); } סטטוס החזרה; } סטטוס החזרה; }

פונקציה זו פשוטה לשימוש, עליך להגדיר שני דברים:

1. IV ריק (וקטור ראשוני) של 16 בתים
2. הצפנת נתונים (גודל מקסימלי של 240 בתים)

להלן דוגמא "כיצד להשתמש בפונקציה זו".

אני רוצה להצפין את המילה "AAAAAAAAAAAAAAAA", כשהמפתח שלי כתוב במספר המשבצת "9":

ATCA_STATUS status = atcab_init (& cfg); if (status! = ATCA_SUCCESS) {Serial.println (F ("atcab_init () נכשל: קוד -> 0x")); Serial.println (סטטוס, HEX); } uint8_t plaintext [16] = "AAAAAAAAAAAAAAAA"; // טקסט מקורי uint8_t iv [IV_LENGTH_CBC]; // וקטור ראשוני uint8_t cypherdata [sizeof (טקסט רגיל)]; // סטטוס מוצפן נתונים = aes_cbc_encrypt (& cfg, plaintext, sizeof (plaintext), iv, cypherdata, 9);

אם הפעולה טובה, יהיו לך הנתונים המוצפנים במשתנה "cypherdata" ובווקטור הראשוני במשתנה "IV".

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

שלב שני: פענוח הנתונים שלך

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

1. הווקטור הראשוני
2. נתוני סייפר (נתונים מוצפנים)

כדי לפענח את הנתונים שלך, תזדקק לפונקציה הבאה:

/** / brief פענוח נתונים באמצעות אלגוריתם AES CBC* / param [in] תצורת ממשק לוגי CFG. כמה תצורות * מוגדרות מראש ניתן למצוא ב- atca_cfgs.h * / param [in] ciphertext מילים לדסיפט (יש לחלק ב 16, אורך מקסימלי 240) * / param [in] len אורך מילים ל decept (יש לחלק ב 16, אורך מקסימלי 240) * / param [in] iv וקטור ראשוני לשימוש ב- AES CBC * / param [out] טקסט פשוט מחזיר כאן את הטקסט המפענח * / param [in] מספר חריץ של המפתח * / return ATCA_SUCCESS על הצלחה, אחרת קוד שגיאה. */ ATCA_STATUS aes_cbc_decrypt (ATCAIfaceCfg *cfg, uint8_t *ciphertext, int len, uint8_t *iv, uint8_t *plaintext, uint8_t key) {atca_aes_cbc_ctx_t ctx; if (len> LIMIT_DATA_SIZE_CBC || len % 16! = 0) {Serial.print (F ("פענוח שגיאה: ATCA_BAD_PARAM")); החזר ATCA_BAD_PARAM; } סטטוס ATCA_STATUS = atcab_init (cfg); if (status == ATCA_SUCCESS) {status = atcab_aes_cbc_init (& ctx, key, 0, iv); if (status! = ATCA_SUCCESS) {Serial.print (F ("פענוח ERROR: atcab_aes_cbc_init, שגיאת קוד 0x")); Serial.println (סטטוס, HEX); לַחֲזוֹר; } int max = len / 16; עבור (int j = 0; j <max; j ++) {status = atcab_aes_cbc_decrypt_block (& ctx, & ciphertext [j * 16], & plaintext [j * 16]); } if (status! = ATCA_SUCCESS) {Serial.print (F ("פענוח ERROR: atcab_aes_cbc_encrypt_block, קוד שגיאה 0x")); Serial.println (סטטוס, HEX); } סטטוס החזרה; } סטטוס החזרה; }

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

uint8_t plaintext [16] = "AAAAAAAAAAAAAAA"; uint8_t iv [IV_LENGTH_CBC]; uint8_t cypherdata [sizeof (טקסט רגיל)]; uint8_t decryptdata [sizeof (טקסט רגיל)]; status = aes_cbc_decrypt (& cfg, cypherdata, sizeof (cypherdata), iv, decryptdata, 9); if (status == ATCA_SUCCESS) {Serial.print ("טקסט מפוענח הוא:"); עבור (size_t i = 0; i <sizeof (decryptdata); i ++) {Serial.print ((char) decryptdata ); } Serial.println (""); } אחר {// עיין בקובץ atca_status.h עבור הקוד שגיאת Serial.print (F ("לא ניתן לבצע את הפענוח | קוד קוד 0x")); Serial.println (סטטוס, HEX); לַחֲזוֹר; }

אם הפעולה טובה, יהיו לך הנתונים המפוענחים במשתנה "decryptdata".

עכשיו אתה יודע כיצד להשתמש בהצפנה ופענוח עם השבב Atecc608a

שלב 6: 5. מדוע עליך להשתמש בשבב זה

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

להלן דוגמא לניצול:

1. נתונים שנשמרו ל- EEPROM חיצוני: תוכל לאבטח נתונים של EEPROM חיצוני ואם מישהו עדיין משתמש ב- EEPROM, הוא יזדקק למפתח ול- IV לצורך הפענוח
2. שלח נתונים אלחוטיים: תוכל לשלוח נתונים מוצפנים אלה באמצעות Wireless (nrf24L01, RFM95W …) ואם מישהו יירט את הנתונים שלך, הנתונים האלה יהיו מאובטחים
3. סיסמא שמורה
4. …

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

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

שלב 7: סיכום

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

תודה שקראתם הכל.

תהנה.