E
E
Embedded Application Security Best Practices
Search…
Embedded Application Security Best Practices
What are Embedded Systems?
Buffer and Stack Overflow Protection
Injection Prevention
Firmware Updates and Cryptographic Signatures
Securing Sensitive Information
Identity Management
Embedded Framework and C-Based Toolchain Hardening
Usage of Debugging Code and Interfaces
Transport Layer Security
Usage of Data Collection and Storage - Privacy
Third Party Code and Components
Threat Modeling
About OWASP
Powered By GitBook
Securing Sensitive Information
Do not hardcode secrets such as passwords, usernames, tokens, private keys or similar variants into firmware release images. This also includes the storage of sensitive data that is written to disk. If hardware security element (SE) or Trusted Execution Environment (TEE) is available, it is recommended to utilize such features for storing sensitive data. Otherwise, use of strong cryptography should be evaluated to protect the data.
If possible, all sensitive data in clear-text should be ephemeral by nature and reside in a volatile memory only.
Noncompliant Hardcoded Password Example:
1
int VerifyAdmin(char *password) {
2
​
3
if (strcmp(password, "Mew!")) {
4
printf("Incorrect Password!\n");
5
return 0;
6
}
7
​
8
printf("Entering Diagnostic Mode\n");
9
return 1;
10
}
Copied!
Noncompliant Storing sensitive data to disk Example:
In this noncompliant code example, sensitive information is supposedly stored in the dynamically allocated buffer, secret, which is processed and eventually cleared by a call to memset_s(). The memory page containing secret can be swapped out to disk. If the program crashes before the call to memset_s() completes, the information stored in secret may be stored in the core dump.
1
char *secret;
2
​
3
secret = (char *)malloc(size+1);
4
if (!secret) {
5
/* Handle error */
6
}
7
​
8
/* Perform operations using secret... */
9
​
10
memset_s(secret, '\0', size+1);
11
free(secret);
12
secret = NULL;
Copied!
To prevent the information from being written to a core dump, the size of core dumps that the program will generate should be set to 0 using setrlimit():
1
#include <sys/resource.h>
2
/* ... */
3
struct rlimit limit;
4
limit.rlim_cur = 0;
5
limit.rlim_max = 0;
6
if (setrlimit(RLIMIT_CORE, &limit) != 0) {
7
/* Handle error */
8
}
9
​
10
char *secret;
11
​
12
secret = (char *)malloc(size+1);
13
if (!secret) {
14
/* Handle error */
15
}
16
​
17
/* Perform operations using secret... */
18
​
19
memset_s(secret, '\0', size+1);
20
free(secret);
21
secret = NULL;
Copied!
Alternatively, the use of mlock() can be used to prevent paging by locking memory in place. This compliant solution not only disables the creation of core files but also ensures that the buffer is not swapped to hard disk:
1
#include <sys/resource.h>
2
/* ... */
3
struct rlimit limit;
4
limit.rlim_cur = 0;
5
limit.rlim_max = 0;
6
if (setrlimit(RLIMIT_CORE, &limit) != 0) {
7
/* Handle error */
8
}
9
​
10
long pagesize = sysconf(_SC_PAGESIZE);
11
if (pagesize == -1) {
12
/* Handle error */
13
}
14
​
15
char *secret_buf;
16
char *secret;
17
​
18
secret_buf = (char *)malloc(size+1+pagesize);
19
if (!secret_buf) {
20
/* Handle error */
21
}
22
​
23
/* mlock() may require that address be a multiple of PAGESIZE */
24
secret = (char *)((((intptr_t)secret_buf + pagesize - 1) / pagesize) * pagesize);
25
​
26
if (mlock(secret, size+1) != 0) {
27
/* Handle error */
28
}
29
​
30
/* Perform operations using secret... */
31
​
32
memset_s(secret_buf, '\0', size+1+pagesize);
33
if (munlock(secret, size+1) != 0) {
34
/* Handle error */
35
}
36
secret = NULL;
37
​
38
free(secret_buf);
39
secret_buf = NULL;
Copied!
Storing Sensitive Data, Noncompliant Example: In this example, sensitive information stored in the dynamically allocated memory referenced by secret is copied to the dynamically allocated buffer, new_secret, which is processed and eventually deallocated by a call to free(). Because the memory is not cleared, it may be reallocated to another section of the program where the information stored in new_secret may be unintentionally leaked.
1
char *secret;
2
​
3
/* Initialize secret */
4
​
5
char *new_secret;
6
size_t size = strlen(secret);
7
if (size == SIZE_MAX) {
8
/* Handle error */
9
}
10
​
11
new_secret = (char *)malloc(size+1);
12
if (!new_secret) {
13
/* Handle error */
14
}
15
strcpy(new_secret, secret);
16
​
17
/* Process new_secret... */
18
​
19
free(new_secret);
20
new_secret = NULL;
Copied!
Storing Sensitive Data, Compliant Example: To prevent information leakage, dynamic memory containing sensitive information should be sanitized before being freed. Sanitization is commonly accomplished by clearing the allocated space (that is, filling the space with '\0' characters).
1
char *secret;
2
​
3
/* Initialize secret */
4
​
5
char *new_secret;
6
size_t size = strlen(secret);
7
if (size == SIZE_MAX) {
8
/* Handle error */
9
}
10
​
11
/* Use calloc() to zero-out allocated space */
12
new_secret = (char *)calloc(size+1, sizeof(char));
13
if (!new_secret) {
14
/* Handle error */
15
}
16
strcpy(new_secret, secret);
17
​
18
/* Process new_secret... */
19
​
20
/* Sanitize memory */
21
memset_s(new_secret, '\0', size);
22
free(new_secret);
23
new_secret = NULL;
Copied!
Considerations:
  • Do not hardcode certificates across product lines.
  • Do not hardcode passwords across product lines.
  • Do not store secrets in an unprotected storage location or external storage including within an EEPROM or flash.

Additional References

Previous
Firmware Updates and Cryptographic Signatures
Next
Identity Management
Last modified 3yr ago
Copy link
Contents
Additional References