Strict Memory Protection for Microcontrollers

Abstract

Moderne datasystemer beskytter prosesser fra hverandre med minnebeskyttelse. Mikrokontrollersystemer, som mangler støtte for minnevirtualisering, bruker typisk sett kun minnebeskyttelse for områder som programmereren finner nødvendig og separerer ikke prosesser fullstendig. Resultatet er at applikasjonen er monolitisk og kun enkelte feil kan oppdages.

Denne oppgaven presenterer et sett løsninger for komplett separasjon av prosesser, og benytter det fulle potensialet til maskinvaren i moderne ARM-baserte mikrokontrollere. Operativsystemet laster inn flere programmer fra disk inn i frittstående og beskyttede deler med minne. Disse programmene kan så startes, stoppes, endres, avbrytes osv. uten å påvirke andre programmer. Når programmer lastes, benyttes en ny allokeringsalgoritme som automatisk setter opp minneregioner for bruk med minnebeskyttelsen. En "pager" er skrevet for å oppfylle videre krav om minneallokering etter at programmene er startet, og primitiver for inter-prosess kommunikasjon er gjort tilgjengelig.

Siden hver kjørende prosess ikke kan få tilgang til andre kjørende prosesser, blir ikke kun pålitelighet men også sikkerhet forbedret. Et program kan splittes opp slik at usikre eller feilbarlige deler kan separeres fra kritisk kode. Dermed kan den usikre koden startes på nytt for seg selv om den skulle feile. Med eksekverbare og skrivbare minnerettigheter gjort eksklusive fra hverandre er det gjort vanskeligere for en angriper å sette inn kode i et kjørende program. Løsningen er transparent for programmereren. Alt som trengs å gjøre for å ta løsningen i bruk er å splitte programmet i mindre deler. En ekstra fordel med dette er at de mindre programmene også blir lettere å utvikle og teste separat. Det standard POSIX grensesnittet brukes av programmereren, slik at eksisterende kunnskap og kode kan brukes. Programmer som ikke er avhengig av spesiell maskinvare kan i tillegg utvikles og testes i sin helhet på et fullkommet, normalt datasystem og så kjøres direkte på mikrokontrolleren i etterkant.

Modern desktop systems protect processes from each other with memory protection. Microcontroller systems, which lack support for memory virtualization, typically only uses memory protection for areas that the programmer deems necessary and does not separate processes completely. As a result the application still appears monolithic and only a handful of errors may be detected.

This thesis presents a set of solutions for complete separation of processes, unleashing the full potential of the memory protection unit embedded in modern ARM-based microcontrollers. The operating system loads multiple programs from disk into independently protected portions of memory. These programs may then be started, stopped, modified, crashed etc. without affecting other running programs. When loading programs, a new allocation algorithm is used that automatically aligns the memories for use with the protection hardware. A pager is written to satisfy additional run-time demands of applications, and communication primitives for inter-process communication is made available.

Since every running process is unable to get access to other running processes, not only reliability but also security is improved. An application may be split so that unsafe or error-prone code is separated from mission-critical code, allowing it to be independently restarted when an error occurs. With executable and writeable memory access rights being mutually exclusive, code injection is made harder to perform. The solution is all transparent to the programmer. All that is required is to split an application into sub-programs that operates largely independently. An added benefit of this modularity is that code may also be developed and tested as independent programs. The standard POSIX API is used as the programming interface, allowing programmers to use existing knowledge and code when designing applications. For programs that do not depend on specific hardware, development may be done and tested on a regular desktop system entirely before running it on a microcontroller.