ESP32 Forum

Code: Select all

espsecure.py encrypt_flash_data

Code: Select all

#include <Arduino.h>
#include "mbedtls/aes.h"

mbedtls_aes_context aes;

unsigned char key[32] ={
0x12, 0xA1, 0x38, 0xEB, 0xF5, 0x01, 0xD7, 0x89, 0x4C, 0x98, 0x12, 0x4E, 0x47, 0x88, 0xE9, 0xB5, 
0x79, 0x16, 0xF7, 0x7C, 0x82, 0x95, 0xBB, 0xD2, 0x14, 0x84, 0xE4, 0x38, 0xF4, 0x6C, 0x82, 0x9E
};
unsigned char iv[16]={0};
size_t iv_off=0;
unsigned char input [16]={"this is my test"};
unsigned char output[16];

size_t input_len = sizeof(input);
size_t output_len = 0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);

  esp_aes_init(&aes);
  esp_aes_setkey( &aes, key, 256 );
  esp_aes_crypt_ecb( &aes, ESP_AES_ENCRYPT, input, output );


  Serial.println(String(output, 16));
}

void loop() {
}

Code: Select all

#include <Arduino.h>
#include "mbedtls/aes.h"

mbedtls_aes_context aes;

unsigned char key[32] ={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x00,0x01,0x02 };
unsigned char iv[16]={0};
size_t iv_off=0;
unsigned char input [16]={"this is my test"};
unsigned char output[32];

size_t output_len = 0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);

  Serial.println(String(key, 32)); 

  esp_aes_init(&aes);
  esp_aes_setkey( &aes, key, 256 );
  /* 
  esp_aes_crypt_ecb( &aes, ESP_AES_ENCRYPT, input, output );
  esp_aes_crypt_ecb( &aes, ESP_AES_DECRYPT, &input[16], &output[16] );
 */
  esp_aes_crypt_cbc(&aes, ESP_AES_ENCRYPT, sizeof(input), iv, input, output);

  Serial.println(String(output, sizeof(output)));
}

Code: Select all

def encrypt(output_file, input_file, keyfile):
    do_decrypt=False

    key = keyfile.read()
 
    backend = default_backend()
    iv=[0, 0, 0 , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    iv= bytes(iv)

    cipher = None
    block_offs = 0x00
    while True:
        block = input_file.read(16)
        

        if len(block) == 0:
            break
        elif len(block) < 16:
            if do_decrypt:
                raise esptool.FatalError("Data length is not a multiple of 16 bytes")
            pad = 16 - len(block)
            block = block + os.urandom(pad)
            print("Note: Padding with %d bytes of random data (encrypted data must be multiple of 16 bytes long)" % pad)

        if block_offs % 32 == 0 or cipher is None:
            # each bit of the flash encryption key is XORed with tweak bits derived from the offset of 32 byte block of flash
            #block_key = _flash_encryption_tweak_key(key, block_offs, tweak_range)
            #block_key = key
            test=key
            print("key: %s" % test)
            print("Decrypt?: %s" % do_decrypt)

            if cipher is None:  # first pass
                cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend)

                # note AES is used inverted for flash encryption, so
                # "decrypting" flash uses AES encrypt algorithm and vice
                # versa. (This does not weaken AES.)
                actor = cipher.encryptor() if do_decrypt else cipher.decryptor()
            
        output = actor.update(block) + actor.finalize()

        #output_file.write(block[::-1])  # reverse output block byte order
        #print("Code: %s" % output)
        output_file.write(output) 
        block_offs += 16

Code: Select all

void handlefirmwareUpload_encrypt(AsyncWebServerRequest *request, String filename, size_t index, uint8_t *data, size_t len, bool final)
{
    static uint8_t* overlape[16]={0}; //Überstand kann maximal 15 sein
    static size_t last_overlape_len=0;     
    uint8_t encrypted_data[2000]={0};
    uint8_t decrypted_data[2000]={0};
    int error_decrypt=0;
      
    if(!index){
      Serial.printf("Update Start: %s\n", filename.c_str());
      if(!Update.begin(0xFFFFFFFF)){
        Update.printError(Serial);
      }
    last_overlape_len=0; //Überlänge beim Start noch NULL
    }

    size_t data_len = len+last_overlape_len; //Länge der encryptbaren Daten
    size_t data_len16 = data_len -  (data_len % 16); //Länge auf 16Byte
    if(encrypted_data){
    memcpy(encrypted_data, overlape, last_overlape_len);//alten Überstand in neue Daten integrieren
    memcpy(encrypted_data+last_overlape_len,data,data_len);//neue Daten hinzufügen
    }

    last_overlape_len = data_len - data_len16; //neu Überlapplänge berechnen
    memcpy(overlape, encrypted_data+data_len16, last_overlape_len);//Überstand mit in neuen Aufruf übernehmen

    if (decrypted_data){
     error_decrypt = esp_aes_crypt_cbc(&aes, ESP_AES_DECRYPT, data_len16 , iv, encrypted_data, decrypted_data); //Decrypten
    }
    
     if(!Update.hasError() && !error_decrypt){
      Serial.print("-");
        if(Update.write(decrypted_data, data_len16) != data_len16){
          Update.printError(Serial);
        }
      } 

    if(final){
        Serial.printf("\r\nEnde: %u Byte\r\n", index+len);

       if(Update.end(true)){
        Serial.printf("Update Success: %uB\n", index+len);
        shouldReboot = true;


      } else {
        Update.printError(Serial);
      } 
    }
 
        
}