Arduino İle Güvenlik: Atecc608a: 7 Adım

2024 Yazar: John Day | [email protected]. Son düzenleme: 2024-01-30 13:17

Başlık

Herkese merhaba !

Bu benim ilk Eğitilebilir Makalem, umarım hepiniz için ilginç olur.

Bu yazımda sizlere çoklu güvenlik araçları sağlayan "ATECC608A" isimli bir mikro çipin nasıl kullanılacağını anlatacağım.

Bu çip MicroChip tarafından tasarlanmıştır ve "CryptoAuthentication chip" in son versiyonudur. Bu sürümden önce "ATSHA204A" ve "ATECC508A" vardı.

Neden önceki sürümü değil de son sürümü kullanmaya karar verdim?

Bu sürüm en gelişmiş çiptir ve eski sürümde olmayan işlevlere sahiptir (Örneğin: AES modülü, IO koruma modülü…).

Neden bu proje?

Siber Güvenlik alanında çalışıyorum ve herkes olarak programlamayı ve elektroniği sevdim. Çalışmalarım sırasında, Industrial'ın IoT nesnelerinde Security kullanmadığını bize gösteren bir IoT Güvenliği uzmanıyla bir konferans alıyorum. Bluetooth ile akıllı telefonunuzla açılabilen bir asma kilit gösterdim. Asma kilidin üzerinde "Bu asma kilit, anahtarlı asma kilitten daha güvenlidir!" yazıyordu. Bu cümle onu gülümsetti ve "Bu asma kilit şimdiye kadar yapılmış en kötü asma kilit!" cümlesini değiştirdi.

Akıllı telefonun gönderdiği her komutun her seferinde aynı olduğunu ve bu komutu kopyalayıp akıllı telefonunuzla göndermenin çok basit olduğunu bize kendi bilgisayarı ve Bluetooth sniffer ile gösterdi. Bize "Endüstriyel" için "Güvenlik" in asıl sorun olmadığını açıkladı. Bize bu nesnelere bir güvenlik katmanı ekleyebilecek (0.60$'dan az) çipleri gösterdi.

Bu gösterimden sonra, IoT nesnesine güvenlik katmanı ekleyen bazı Açık kaynaklı projeler bulmaya çalıştım ama hiç bulamadım.

Bu yüzden iki IoT nesnesi arasındaki iletişim için güvenlik katmanını kullanan bir proje üzerinde çalışmaya karar verdim.

benim fikrim nedir?

İki IoT Nesnesi arasındaki bir iletişim sırasında birden fazla saldırı olabilir: Man Of the hafif, Bilginin kopyası ve daha fazlası.. Yani benim fikrim çok basit:

1. İki veya daha fazla IoT nesnesi arasında şifrelenmiş verilerin kullanılması.
2. Düşük maliyetli sarf malzemeleri
3. Arduino UNO ile çalışabilir

Şimdi size bu soyut resmi bir Arduino ve bir Atecc608a çipi ile nasıl uyguladığımı anlatacağım. Bu yazımda sizlere Arduino UNO'yu ATECC608A ile nasıl kullanacağınızı anlatacağım.

Bir dahaki sefere iki nesnenin iletişimi hakkında bir makale yazacağım.

Gereçler

Bu proje için birkaç şeye ihtiyacınız var:

1. Arduino UNO veya MEGA (Çip, Atmega 328 veya ATMEGA 2560 olmalıdır)
2. Atecc608A çipi (her birinin maliyeti 0,80$'dan az, tedarikçi web sitenizde bulunması kolay)
3. 8-Pin SOIC Adaptörü
4. Bazı teller ve dirençler

Bu çipin önceki sürümünün (Atecc508a) veri sayfası burada mevcuttur -> Veri Sayfası Atecc508a

Adım 1: Adım Adım

Bu yazımda sizlere bu chipin konfigürasyonunun nasıl değiştirileceğini ve sonrasında AES CBC Algoritması kullanılarak verilerin nasıl şifreleneceğini göstereceğim.

Şu adımları izleyeceğiz:

1. Devre tasarımı
2. Bu çipin konfigürasyonu
3. AES CBC modülünün kullanımı
4. Neden bu çipi kullanmanız gerekiyor?

Her adım için, sizin için her şeyi detaylandıracağım. Ayrıca kodumu Github'a her fonksiyon için yorumlarla ekledim. Kodum veya bu proje hakkında bazı sorularınız varsa, cevaplamaktan memnuniyet duyarım.

Github'ım: Github'ım

Adım 2: Atecc608a Hakkında Uyarı

Atecc608a çipi "kolay" bir çip değildir.

İlk olarak, bu çipin dokümantasyonu NDA kapsamındadır, dolayısıyla internette tam olarak bulamazsınız. Ancak bunun için sorun değil, önceki sürümün veri sayfası Internet Datasheet Complete ATECC508A'da mevcuttur.

İkincisi, bu çipi kullandığınızda konfigürasyonunu kilitlemeniz gerekir ve çip kilitliyse konfigürasyonunu değiştirmek imkansızdır. Bu nedenle, Yapılandırma Bölgesini ve Veri Bölgesini ne zaman kilitleyeceğinize dikkat edin.

Üçüncüsü, C ile yazılan kütüphane çok büyük ve eksiksizdir, bu yüzden daha önce kullanacağınız fonksiyonların dökümantasyonunu okumalısınız.

Dördüncüsü, bu çip için yazılan kütüphane Arduino UNO için çalışmıyor, ancak Arduino UNO ile çalışması için gereken işlevleri ekledi.

ATECC608A çipi

Bu çip ile I2C ile haberleşebilirsiniz. Bu çipin adresi konfigürasyonda değiştirilebilir.

Bu çip, farklı türde veriler içerebilen 16 farklı yuva içerir:

1. ECC Anahtarı (özel veya genel)
2. AES Anahtarı
3. Diğer veriler (Sha hash veya sadece kelimeler gibi)

Bizim durumumuzda, AES Anahtarını bir yuvada saklayacağız.

Adım 3: 1. Devrenin Tasarımı

1. Devrenin tasarımı

Bu devrenin şeması çok basit!

Tavsiye 2.0V ile 5.5V arasında olduğu için 3.3V güç kullanmanız gerekiyor ama ben 3.3V kullanmayı tercih ettim.

Bu çip için normalde çipin bir köşesinde bir nokta bulunur, bu nokta bu kartın Pin 1'idir. Atecc608a'nın Üstten görünümünü PIN Numarası ile ekledim çünkü bu bir 8-Lead SOIC olduğundan çip çok küçük.

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)

Tavsiye 2.0V ile 5.5V arasında olduğu için 3.3V güç kullanmanız gerekiyor ama ben 3.3V kullanmayı tercih ettim.

Atecc608a'nın Üstten görünümünü ekledim çünkü bu 8-Lead SOIC olduğundan çip çok küçük. Tercih ederseniz, tedarikçiler çip lehimli bir tahta inşa ederler, bu sizin için daha kolay olabilir.

Uyarı: Benim durumumda Arduino'nun SDA'sı ile Chip (ayrıca SDL için) arasına bir direnç eklemem gerekiyor. Her biri için 4.7Kohm direnç ekledim.

Adım 4: 2. Çipin Yapılandırması (Atecc608a)

Şifreleme veya şifre çözme işlevini kullanmadan önce çipi yapılandırmanız gerekir. Bu adımda, bu çipin konfigürasyonu için yapmanız gereken her adımı detaylandıracağım.

Uyarı: Bu adım çok önemlidir ve bölgeleri sona ermeden kilitlerseniz onları değiştiremezsiniz.

Daha önce açıklandığı gibi, bu çip iki bölgeye sahiptir:

1. Yapılandırma Bölgesi
2. Veri Bölgesi

Yapılandırma Bölgesi 128 bayt boyutundadır ancak ilk 16 bayt değiştirilemez.

Bu çipi yapılandırmak için şu adımları takip etmeniz gerekiyor. Her adımı sırayla takip etmeniz çok önemlidir, aksi takdirde konfigürasyonunuz çalışmaz ve chipiniz kilitlenir ve kullanılamaz hale gelir. Bu adımlar şunlardır:

1. Bir yapılandırma şablonu oluşturun
2. Bu şablonu çipe yazın
3. Yapılandırma Alanını Kilitle
4. AES Anahtarınızı (128 Bit) bir yuvaya yazın
5. Veri Bölgesini Kilitle

Bilgi

Aşağıda, kodumla yapılandırmanın her adımını ayrıntılarıyla anlatacağım, ancak endişelenmeyin, Github'uma tam bir yapılandırma örneği ekledim. Her fonksiyona yorum yazdım ve sizin için her adımda bir *.ino dosyası mevcut.

• Github'ım: Github'ım
• Örnek Yapılandırma Yolu: configuration_example.ino

İlk adım: Bir yapılandırma şablonu oluşturun

Daha önce açıklandığı gibi, konfigürasyon bölgesi 128 bit boyutundadır, ancak ilk 16 bit değiştirilemez. Bu bölge birden fazla bölümden oluşur, ancak bu proje için bu yapılandırma bölgesinin yalnızca 3 bölümünü bilmeniz gerekir:

1. Bayt 16 -> Bu, çipin I2C adresidir.
2. Bayt 20 - 51 -> Bu çipin 16 yuvası için Yuva türünü buradan değiştirebilirsiniz
3. Bayt 96 ila 127 -> Burada her yuvada kullanılan anahtar veya veri türünü ayarlayabilirsiniz.

(Tüm bu bölgenin daha fazla açıklamasına ihtiyacınız varsa, lütfen belgeleri okuyun (sayfa 13, bölüm 2.2))

Burada, bir Çip konfigürasyonunun 112 baytının her Baytını/Parçasını ayrıntılı olarak koydum. Bu bir örnektir, satın alınan her çipin farklı bir konfigürasyonu olabilir:

0xC0, // I2C adresi

0x00, 0x00, 0x00, 0x83, 0x20, // Yuva Yapılandırma Yuva 1 0x85, 0x20, // Yuva Yapılandırma Yuva 2 0x8F, 0x20, // Yuva Yapılandırma Yuva 3 0xC4, 0x8F, // Yuva Yapılandırma Yuva 4 0x8F, 0x8F, // Yuva Yapılandırma Yuva 5 0x8F, 0x8F, // Yuva Yapılandırma Yuva 6 0x9F, 0x8F, // Yuva Yapılandırma Yuva 7 0x0F, 0x0F, // Yuva Yapılandırma Yuva 8 0x8F, 0x0F, // Yuva Yapılandırma Yuva 9 0x8F, 0x0F, // Yuva Yapılandırma Yuva 10 0x8F, 0x0F, // Yuva Yapılandırma Yuva 11 0x8F, 0x0F, // Yuva Yapılandırma Yuva 12 0x8F, 0x0F, // Yuva Yapılandırma Yuva 13 0x00, 0x00, // Yuva Yapılandırma Yuva 14 0x00, 0x00, // Yuva Yapılandırma Yuva 15 0xAF, 0x8F, // Yuva Yapılandırma Yuva 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, // Anahtar Yapılandırma Yuvası 1 0x33, 0x00, // Anahtar Yapılandırma Yuvası 2 0x33, 0x00, // Anahtar Yapılandırma Yuvası 3 0x1C, 0x00, // Anahtar Yapılandırma Yuvası 4 0x1C, 0x00, // Anahtar Yapılandırma Yuvası 5 0x 1C, 0x00, // Anahtar Yapılandırma Yuvası 6 0x1C, 0x00, // Anahtar Yapılandırma Yuvası 7 0x3C, 0x00, // Anahtar Yapılandırma Yuvası 8 0x1A, 0x00, // Anahtar Yapılandırma Yuvası 9 0x3A, 0x00, // Anahtar Yapılandırma Yuvası 10 0x1A, 0x00, // Anahtar Yapılandırma Yuvası 11 0x3A, 0x00, // Anahtar Yapılandırma Yuvası 12 0x3A, 0x00, // Anahtar Yapılandırma Yuvası 13 0x3C, 0x00, // Anahtar Yapılandırma Yuvası 14 0x3C, 0x00, // Anahtar Yapılandırma Yuvası 15 0x1C, 0x00 // Anahtar Yapılandırma Yuvası 16

Görüldüğü gibi, bu konfigürasyonu daha iyi anlamak için bu koda bazı yorumlar koydum.

Senin durumunda sadece üç şeyi anlaman gerekiyor:

1. Bayt 16 -> Bu, çipin I2C adresidir.
2. Bayt 20 - 51 -> Bu çipin 16 yuvası için Yuva türünü buradan değiştirebilirsiniz
3. Bayt 96 ila 127 -> Her yuvada kullanılan anahtar veya veri türünü buradan ayarlayabilirsiniz.

Her şeyi açıklamak karmaşık olduğundan, yapılandırmanın türünü ve neden başkasını değil de bunu kullandığımı açıklamayacağım. Daha fazla bilgiye ihtiyacınız varsa belgelere gidin, "SlotConfig" için sayfa 16 bölüm 2.2.1 ve "KeyConfig" için sayfa 19 bölüm 2.2.5

Bu örnekte, bir AES anahtarını saklamak için 9 numaralı yuvayı kullanacaksınız.

Bunun için şunu koymamız gerekiyor (gerekirse yukarıdaki örneği kopyalayabilirsiniz, içinde modifikasyon yapılmıştır):

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

Bu konfigürasyonu neden ayarladım: Bu çipin her yuvası için, çipe ne tür verilerin depolanacağını söylemek için parametreler ayarlayabilirsiniz. Birden çok parametreniz var:

• Slot yazılabilir veya okunabilir (temizleme veya şifreleme eylemi)
• Depolanan veri türü (ECC anahtarı, Genel Anahtar, SHA Hash, AES Anahtarı…)
• Yuva kilitlenebilir
• Anahtar üretimine izin verilir
• …

36 ve 37 baytları "0x0F8F" olarak ayarlandığında:

• Veriler Clear olarak yazılabilir
• Bu yuvanın içeriği gizlidir ve okunamaz
• Yuva, CheckMac Kopyalama komutu için kullanılamaz

Bayt 112 ve 113 "0x001A" olarak ayarlandığında:

Yuva, dört adede kadar AES 128 bit simetrik anahtarı saklayabilir (KeyType = 0x6)

İkinci adım: Bu konfigürasyonu yazın

Bu adım çok önemli çünkü biz kendi konfigürasyonumuzla chipi ayarlayacağız ve bu konfigürasyon iyi olmazsa bu chipi kullanacaksınız.

Ancak endişelenmeyin, Yapılandırma kilitli olmadığı sürece yapılandırmanızı değiştirebilirsiniz.

Burada, konfigürasyonu çipe yazmak için kullanılan kod:

/** \brief Yongaya yeni bir konfigürasyon yazın.

* \param[in] cfg Mantıksal arayüz yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları, atca_cfgs.h * \param[in] config Dizin uint8_t of configuration (uzunluk 112) * \param[in] len içinde bulunabilir Yapılandırma dizisinin boyutu * \return ATCA_SUCCESS, aksi takdirde bir hata kodu. */ ATCA_STATUS write_configuration(ATCAIfaceCfg *cfg, uint8_t *config, size_t len) { if (len != 112) ATCA_BAD_PARAM döndürür; ATCA_STATUS durumu; durum = atcab_init(cfg); if (status == ATCA_SUCCESS) { // Konfigürasyon Dizisini çipe yazın // 16 baytlık dolgu (16 ilk bayt yazılamaz) durum = atcab_write_bytes_zone(ATCA_ZONE_CONFIG, 0, 16, (uint8_t *)config, len); iade durumu; } dönüş durumu; }

Bu fonksiyon, konfigürasyonunuzu çipe yazacaktır.

Üçüncü adım: Yapılandırma Bölgesini kilitleyin

Uyarı: Bu adımda dikkatli olun, eğer bu Zone'u kilitlerseniz ve konfigürasyonunuz iyi değilse, chip kullanılamaz hale gelir ve bu zone'u değiştiremezsiniz

Bu eylem için bu işlevi kullanacağız:

/** \brief DATA_ZONE veya CONFIG_ZONE'ın kilitli olup olmadığını kontrol edin

* \param[in] cfg Mantıksal arabirim yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları, başarı durumunda atca_cfgs.h * \param[in] LOCK_ZONE_DATA veya LOCK_ZONE_CONFIG * \return ATCA_SUCCESS içinde, aksi takdirde bir hata kodunda bulunabilir. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t bölgesi) { ATCA_STATUS durumu; bool kilidi = yanlış; if (bölge != (uint8_t)LOCK_ZONE_CONFIG && bölge != (uint8_t)LOCK_ZONE_DATA) ATCA_BAD_PARAM döndürür; durum = atcab_init(cfg); if (durum == ATCA_SUCCESS) { if (ATCA_SUCCESS != (durum = atcab_is_locked(bölge, &kilit))) { dönüş ATCA_FUNC_FAIL; } if (!lock) { dönüş ATCA_NOT_LOCKED; } ATCA_SUCCESS döndür; } ATCA_BAD_PARAM döndür; } check_lock_zone(&cfg, LOCK_ZONE_CONFIG);

Dördüncü adım: Size bir yuvaya AES Anahtarı yazın

Bu kısımda çipin konfigürasyonunda tanımladığınız yuvaya kişisel AES anahtarınızı yerleştireceksiniz.

Bu örnek için çipin 9 numaralı slotunu kullanacağım.

Bilmeniz gerekenler: Bu çipin özel bir özelliği, yuvaya yalnızca 4 bayt veya 32 bayt veri yazabilmenizdir. AES için 128 bit Anahtara, yani 16 bayt veriye ihtiyacımız var. Bu yüzden, 32 bayt veriye sahip olmak için bu yuvadaki her biri 16 baytlık anahtara yazmaya karar verdim.

Şimdi size kullanılan kodu göstereceğim:

/** \brief AES anahtarını belirli bir yuvaya yazın. * \param[in] cfg Mantıksal arayüz yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları atca_cfgs.h içinde bulunabilir * \param[in] anahtar yuva numarası * \param[in] datakey anahtar dizisi uint8_t * \param[in] len Anahtar dizisinin boyutu * \return ATCA_SUCCESS başarı durumunda, aksi takdirde bir hata kodu. */ ATCA_STATUS write_key_slot(ATCAIfaceCfg *cfg, uint8_t anahtarı, uint8_t *datakey, size_t len) { if (anahtar 16) ATCA_BAD_PARAM döndürür; if (len != 32) ATCA_BAD_PARAM döndürür; ATCA_STATUS durumu = atcab_init(cfg); if (durum == ATCA_SUCCESS) { durum = atcab_write_zone(ATCA_ZONE_DATA, (uint16_t)anahtar, 0, 0, veri anahtarı, 32); if (durum != ATCA_SUCCESS) dönüş durumu; } dönüş durumu; }

Bu örnek için, her biri 16 baytlık iki AES Anahtarı kullanacağım:

// AES ANAHTARI Örneği (len 32)uint8_t example_of_key[32] = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"; write_key_slot(&cfg, 9, example_of_key, sizeof(example_of_key));

Bu işlem iyiyse, şimdi son adım olan "veri bölgesini kilitle" adımını geçmeniz gerekiyor.

Son adım: Veri Bölgesini kilitleyin

Uyarı: Bu adımda dikkatli olun, bu Bölgeyi kilitlerseniz ve verileriniz ayarlanmamışsa, çip kullanılamaz ve bu bölgeyi değiştiremezsiniz

Bu eylem için bu işlevi kullanacağız:

/** \brief DATA_ZONE veya CONFIG_ZONE'ın kilitli olup olmadığını kontrol edin

* \param[in] cfg Mantıksal arabirim yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları, başarı durumunda atca_cfgs.h * \param[in] LOCK_ZONE_DATA veya LOCK_ZONE_CONFIG * \return ATCA_SUCCESS içinde, aksi takdirde bir hata kodunda bulunabilir. */ ATCA_STATUS check_lock_zone(ATCAIfaceCfg *cfg, uint8_t bölgesi) { ATCA_STATUS durumu; bool kilidi = yanlış; if (bölge != (uint8_t)LOCK_ZONE_CONFIG && bölge != (uint8_t)LOCK_ZONE_DATA) ATCA_BAD_PARAM döndürür; durum = atcab_init(cfg); if (durum == ATCA_SUCCESS) { if (ATCA_SUCCESS != (durum = atcab_is_locked(bölge, &kilit))) { dönüş ATCA_FUNC_FAIL; } if (!lock) { dönüş ATCA_NOT_LOCKED; } ATCA_SUCCESS döndür; } ATCA_BAD_PARAM döndür; } check_lock_zone(&cfg, LOCK_ZONE_DATA);

Bu işlem iyiyse chipiniz kullanıma hazır

Adım 5: 3. AES CBC Modülünün Kullanımı

AES CBC algoritması ve Atecc608a çipi ile verilerin nasıl şifreleneceğini ve şifresinin nasıl çözüleceğini anlatacağım.

Unutmayın: Bu işlevi kullanmadan önce çipi ayarlamanız gerekir. Bunun için bu makalenin 2. adımını izleyin

Bu çip, birden fazla AES modülüne (AES 128 bit) sahiptir, yalnızca AES 128 bit mümkündür:

1. AES normal
2. AES CBC
3. AES GCM (GFM karma ile) (daha fazla açıklama için wikipedia'ya bakın)

Kullanımı kolaylaştırmak için iki işlev oluşturdum:

1. aes_cbc_encrypt
2. aes_cbc_decrypt

Bu iki işlev Github'ımda mevcut.

açıklama

Temel AES 128 bitlerinden daha güvenli olduğu için AES CBC Algoritmasını kullanmayı seçiyorum. Bu algoritma, verilerinizi şifrelemek için bir İlk Vektör kullanır.

Bilgi

Aşağıda şifreleme ve şifre çözme yönteminin her adımını ayrıntılarıyla anlatacağım. Ama Arduino için bu iki işlevi kullanan bir kod yazdım. Bu kodu Github'ımda görebilirsiniz:

• Github: Benim Github'ım
• "Şifrele/Şifresini Çöz" kodu örneği: AES_crypto_example.ino

İlk adım: Verilerinizi şifreleyin

Bu bölümde size verilerinizi nasıl şifreleyeceğinizi göstereceğim.

İlk önce bu işleve ihtiyacınız olacak:

/** \brief AES CBC algoritmasını kullanarak verileri şifreleyin * \param[in] cfg Mantıksal arayüz yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları atca_cfgs.h içinde bulunabilir * \param[in] data Words to encypt (16'ya bölünmelidir, max uzunluk 240) * \param[in] len Words to encypt uzunluğu (16'ya bölünmelidir), maksimum uzunluk 240) * \param[out] iv AES CBC'de kullanılan Başlangıç Vektörü (bu değişkendeki vektörü döndürür) * \param[out] ciphertext buraya Cypher metnini döndürür * \param[in] anahtarı key * \return ATCA_SUCCESS, aksi takdirde bir hata kodu. */ ATCA_STATUS aes_cbc_encrypt(ATCAIfaceCfg *cfg, uint8_t *veri, int len, uint8_t *iv, uint8_t *şifreli metin, uint8_t anahtarı) { atca_aes_cbc_ctx_t ctx; if (len > LIMIT_DATA_SIZE_CBC && len % 16 != 0) { Serial.print(F("HATA: ATCA_BAD_PARAM")); ATCA_BAD_PARAM döndür; } uint8_t tmp_iv[IV_LENGTH_CBC]; uint8_t tmp_data[len]; ATCA_STATUS durumu = atcab_init(cfg); if (durum == ATCA_SUCCESS) { durum = atcab_aes_cbc_init(&ctx, key, 0, tmp_iv); if (durum != ATCA_SUCCESS) { Serial.print(F("HATA Şifrele: atcab_aes_cbc_init, Kod Hatası 0x")); Serial.println(durum, HEX); dönüş; } memcpy(iv, tmp_iv, IV_LENGTH_CBC); memcpy(tmp_data, veri, uzunluk); int maks = uzunluk / 16; for (int j = 0; j < maks; j++) { status = atcab_aes_cbc_encrypt_block(&ctx, &tmp_data[j * 16], &ciphertext[j * 16]); } if (durum != ATCA_SUCCESS) { Serial.print(F("HATA Şifrele: atcab_aes_cbc_encrypt_block, Kod Hatası 0x")); Serial.println(durum, HEX); } dönüş durumu; } dönüş durumu; }

Bu işlevin kullanımı basittir, iki şeyi ayarlamanız gerekir:

1. 16 Baytlık boş bir IV (İlk Vektör)
2. Şifrelenecek veriler (maksimum boyut 240 Bayt)

İşte bir örnek "bu işlevin nasıl kullanılacağı".

"AAAAAAAAAAAAAAA" kelimesini, anahtarım "9" yuva numarasına yazarak şifrelemek istiyorum:

ATCA_STATUS durumu = atcab_init(&cfg); if (durum != ATCA_SUCCESS) { Serial.println(F("atcab_init() başarısız: Kod -> 0x")); Serial.println(durum, HEX); } uint8_t düz metin[16] = "AAAAAAAAAAAAAAA"; // Orijinal metin uint8_t iv[IV_LENGTH_CBC]; // Başlangıç Vektörü uint8_t cypherdata[sizeof(plaintext)]; // Veri şifreleme durumu = aes_cbc_encrypt(&cfg, düz metin, sizeof(düz metin), iv, cypherdata, 9);

Eylem iyiyse, "cypherdata" değişkeninde şifrelenmiş verilere ve "IV" değişkeninde İlk Vektöre sahip olacaksınız.

Metninizin şifresini çözmek için bu iki değişkeni saklayın!

İkinci adım: verilerinizin şifresini çözün

Verilerinizin şifresini çözmek için iki şeye ihtiyacınız olacak:

1. İlk Vektör
2. Cypher verileri (şifreli veriler)

Verilerinizin şifresini çözmek için bu işleve ihtiyacınız olacak:

/** \brief AES CBC algoritmasını kullanarak verilerin şifresini çözün * \param[in] cfg Mantıksal arayüz yapılandırması. Bazı önceden tanımlanmış * konfigürasyonları atca_cfgs.h içinde bulunabilir * \param[in] şifreli metin Deşifre edilecek kelimeler (16'ya bölünmelidir, maksimum uzunluk 240) * \param[in] Deşifre Edilecek Kelime uzunluğu (16'ya bölünmelidir), maksimum uzunluk 240) * \param[in] iv AES CBC'de kullanılacak İlk Vektör * \param[out] düz metin şifresi çözülen metni buraya döndür * \param[in] anahtarı Anahtarın yuva numarası * \return ATCA_SUCCESS başarı durumunda, aksi takdirde bir hata kodu. */ ATCA_STATUS aes_cbc_decrypt(ATCAIfaceCfg *cfg, uint8_t *şifreli metin, int len, uint8_t *iv, uint8_t *düz metin, uint8_t anahtarı) { atca_aes_cbc_ctx_t ctx; if (len > LIMIT_DATA_SIZE_CBC || len % 16 != 0) { Serial.print(F("ERROR Decrypt: ATCA_BAD_PARAM")); ATCA_BAD_PARAM döndür; } ATCA_STATUS durumu = atcab_init(cfg); if (durum == ATCA_SUCCESS) { durum = atcab_aes_cbc_init(&ctx, anahtar, 0, iv); if (durum != ATCA_SUCCESS) { Serial.print(F("HATA Şifresini Çöz: atcab_aes_cbc_init, Kod Hatası 0x")); Serial.println(durum, HEX); dönüş; } int maks = uzunluk / 16; for (int j = 0; j < maks; j++) { durum = atcab_aes_cbc_decrypt_block(&ctx, &ciphertext[j * 16], &plaintext[j * 16]); } if (durum != ATCA_SUCCESS) { Serial.print(F("HATA Şifresini Çöz: atcab_aes_cbc_encrypt_block, Kod Hatası 0x")); Serial.println(durum, HEX); } dönüş durumu; } dönüş durumu; }

Önceki verilerimin şifresini çözmek istiyorum (aşağıya bakın, İlk adım). Bunun için şunu yapacağım:

uint8_t düz metin[16] = "AAAAAAAAAAAAAAA"; uint8_t iv[IV_LENGTH_CBC]; uint8_t cypherdata[sizeof(plaintext)]; uint8_t decryptdata[boyut(düz metin)]; durum = aes_cbc_decrypt(&cfg, cypherdata, sizeof(cypherdata), iv, decryptdata, 9); if (durum == ATCA_SUCCESS) { Serial.print("Şifrelenmiş metin: "); for (size_t i = 0; i < sizeof(decryptdata); i++) { Serial.print((char)decryptdata); } Serial.println(""); } else { // Hata Serial.print kodu için atca_status.h dosyasına bakın(F("Şifre çözme imkansız | Kod Hatası 0x")); Serial.println(durum, HEX); dönüş; }

Eylem iyiyse, "decryptdata" değişkeninde şifresi çözülen verilere sahip olacaksınız.

Artık Atecc608a çipiyle şifreleme ve şifre çözmeyi nasıl kullanacağınızı biliyorsunuz

Adım 6: 5. Bu Çipi Neden Kullanmanız Gerekiyor?

Şifreli veriler çok kullanışlıdır çünkü bilgilerinizi gizleyip Kablosuz ile gönderebilir veya sadece saklayabilirsiniz.

İşte bazı kullanım örneği:

1. Harici bir EEPROM'da depolanan veriler: Harici bir EEPROM'un verilerini güvence altına alabilirsiniz ve eğer biri hala bu EEPROM'u kullanıyorsa, şifre çözme için Anahtara ve IV'e ihtiyacı olacaktır.
2. Kablosuz veri gönder: Bu şifreli verileri Kablosuz (nrf24L01, RFM95W…) ile gönderebilirsiniz ve birisi verilerinizi ele geçirirse, bu veriler güvenli olacaktır.
3. Saklanan şifre
4. …

Bu çip ile birçok şey yapabilirsiniz. Birden fazla projede kullanılabilir. Vaktiniz varsa söyleyin bu çipi hangi projede kullanacaksınız?

Son bir tavsiye, eğer bir kablosuz proje oluşturursanız veya bazı ham verileri saklarsanız, dikkatli olun, güvenlik çok önemlidir ve bir "noob"un verilerinizi ele geçirmesinin veya çalmasının ne kadar basit olduğunu biliyorsanız. Artık İnternet sayesinde, herkesin yalnızca sizi "hacklemek" için bilgisayarında başlatabileceği komut dosyaları olabilir!

7. Adım: Sonuç

Umarım bu makale sizin için faydalı olacaktır. Yazımda hata yaptıysam özür dilerim ama İngilizce ana dilim değil ve yazdığımdan daha iyi konuşuyorum.

Her şeyi okuduğunuz için teşekkürler.

Tadını çıkar.