Zijn tekststrings een kwetsbaarheid in embedded software?

Al vele jaren is de beveiliging van desktopcomputers een punt van zorg. Zodra een machine is verbonden met internet, is er intrinsiek een mogelijkheid voor een soort aanval. Dergelijke infiltraties kunnen zijn om gegevens te stelen, het systeem te beschadigen of de werking ervan op de een of andere manier te wijzigen. Beschermingsmiddelen zijn algemeen bekend en worden veel toegepast. Geïntegreerde systemen leken altijd immuun voor dergelijke problemen, omdat ze zelden in een netwerk waren opgenomen en hun code normaal gesproken in een of andere vorm van ROM was. Dingen zijn veranderd. Een groot deel van de moderne systemen is verbonden met internet en het is gebruikelijk dat code naar het RAM wordt gekopieerd en van daaruit wordt uitgevoerd. Dit betekent dat beveiliging nu een belangrijke overweging is bij het ontwerpen van embedded software.

De Engelse taal is een geweldig communicatiemiddel. Het is een zeer expressieve taal die communicatie met grote precisie en subtiliteit mogelijk maakt. In de dagelijkse spraak zijn de meesten van ons echter lui en gebruiken ze vaak woorden zonder 100% nauwkeurigheid. Het voorbeeld dat ik hier in gedachten heb, is de manier waarop veiligheid en beveiliging worden bijna door elkaar gebruikt, alsof het synoniemen zijn. Ik denk dat de beste definitie die ik heb gehoord ongeveer als volgt luidt:veiligheid is het proces waarbij de wereld wordt beschermd tegen het apparaat; beveiliging beschermt het apparaat tegen de wereld. Beveiliging is mijn onderwerp voor vandaag.

Als een systeem echt volledig kogelvrij moet zijn, is versleuteling van industriële kwaliteit vereist. Dit vereist normaal gesproken specifieke hardware-ondersteuning, die, hoewel direct beschikbaar, als overkill kan worden beschouwd voor een toepassing waar een dergelijke hoge beveiliging niet nodig is. In dergelijke gevallen zijn er andere opties en dat zou ik graag willen onderzoeken.

Als een hacker toegang kan krijgen tot de geheugeninhoud van een apparaat, kunnen ze erachter komen wat het doet en hoe het dat doet. Dit is de eerste stap in het wijzigen van de werking ervan. Code kan worden gedemonteerd en daarom kan de logica worden onthuld. Zonder encryptie is er weinig dat kan worden gedaan om dit te voorkomen. Het volgende dat de hacker zou kunnen doen, is kijken naar een hex/ASCII-dump van de gegevens en zien wat ze daar kunnen vinden dat logisch is. Ze zijn op zoek naar patronen en herkenbare structuren. Hier kunnen enkele voorzorgsmaatregelen worden genomen. Hoewel encryptie misschien geen optie is, is verduistering een mogelijkheid.

Het doel van gegevensverduistering is om de hacker te vertragen of af te schrikken door de gegevens simpelweg minder herkenbaar te maken voor wat ze zijn. Als u door een geheugendump scant, is een van de gemakkelijkste dingen om te herkennen tekstreeksen. Dit is dus waar ik me hier op zal concentreren.

In C/C++-code zijn tekstreeksen normaal gesproken slechts reeksen bytes die ASCII-codes bevatten die worden afgesloten met een null-byte. Dat is heel gemakkelijk te herkennen, dus ik zal het veranderen. Ten eerste, in plaats van de null-terminator, zal de eerste byte van elke string een lengtespecificatie zijn. De gegevens van de karakters van de string zullen een beetje vervormd zijn, zodat ze er minder vertrouwd uitzien - ik zal alleen de twee nibbles van elke byte verwisselen. Ik heb een hulpprogramma nodig waarin ik de platte tekstreeksen zou invoeren en het genereert de verklaring voor een array met de juiste initialisatie. Dit is de functie in het hart van dit hulpprogramma:

void scramble(int index, unsigned char *input){    unsigned char *charpointer, character; printf("unsigned char string%d[%d] ={0x%02x,", index,           strlen(input)+1, strlen(input)); charpointer =invoer; while(*charpointer)    {        character =*charpointer++; karakter =((karakter &0x0f) <<4) | ((teken &0xf0)>> 4); printf("0x%02x", teken); if (*charpointer)            printf(","); }    printf("};  // \"%s\"\n", invoer);}

Als ik deze functie een index van 4 en een tekenreeks "Hallo wereld" (origineel toch?), zou doorgeven, zou de uitvoer zijn:

unsigned char string4[12] ={0x0b, 0x84, 0x56, 0xc6, 0xc6, 0xf6, 0x02, 0x77, 0xf6, 0x27, 0xc6, 0x46}; // "Hallo wereld"

Ik kan dit kopiëren en in mijn code plakken, dan hoef ik alleen maar een functie te schrijven om de tekst te decoderen wanneer ik deze moet weergeven. In plaats van elke string een indexnummer te geven, zou ik er een willekeurige naam aan kunnen geven door de index te vervangen parameter met een string. Merk op dat de gegenereerde code enigszins zelfdocumenterend is, aangezien het commentaar de string in een leesbare vorm toont, maar dit verschijnt natuurlijk alleen in de broncode. Als de hacker toegang heeft tot je broncode, dan heb je genoeg problemen dat ik je niet verder kan helpen!

Hier is wat code om het decoderingsproces te illustreren:

void main(){    unsigned char temp, buffer[50]; int count =string4[0], index=0; while(count--)    {        temp =string4[index+1]; temp =((temp &0x0f) <<4) | ((temp &0xf0)>> 4); buffer[index] =temp; index++; }    buffer[index] =0; printf("-%s-\n", buffer);}

Het verwisselen van nibbles in elke byte is een van de vele verschillende manieren waarop het scrambling kan worden gedaan. Een andere mogelijkheid is om bijvoorbeeld elk teken drie bits naar links te draaien. Hier is wat code om precies dat te doen:

unsigned char leftrotate3(unsigned char c){    c =(c <<3) | (c>> 5); retourneer c;}

De verduisteringstechnieken die ik heb geschetst, vervormen de tekenreeks per teken. Het zou mogelijk zijn om in plaats daarvan dingen met de hele string te doen. Behandel de string bijvoorbeeld als een lange reeks bits en draai deze een willekeurig getal naar links. Ik laat de codering van dit algoritme over aan de meer enthousiaste lezer.

Het is vermeldenswaard dat een neveneffect van het lokaliseren van alle tekstreeksen is dat het vrij eenvoudig is om verschillende versies van de software voor andere talen te maken.

Ik moet herhalen en benadrukken dat het verduisteren van gegevens verre van kogelvrij is en in het beste geval de serieuze hacker zal vertragen. Als er niets anders is, kan de decoderingscode worden gedemonteerd. De truc met deze techniek is om van de verduistering een moeilijk te volgen spoor te maken. Als je echt meer beveiliging nodig hebt, moet je kijken naar volledige codering.