Veilige Geheue Allocator in C++

StackOverflow https://stackoverflow.com/questions/8451

Vra

Ek wil om te skep'n allocator wat bied geheue met die volgende eienskappe:

  • kan nie blaai om skyf.
  • is ongelooflik moeilik om toegang te verkry deur middel van'n aangehegte debugger

Die idee is dat dit sal bevat sensitiewe inligting (soos lisensie inligting) wat ontoeganklik is vir die gebruiker.Wat ek gedoen het die gewone aanlyn navorsing en gevra om'n paar ander mense oor hierdie, maar ek kan nie vind'n goeie plek om te begin op hierdie probleem.

Updates

Josh noem die gebruik van VirtualAlloc te stel beskerming op die geheue spasie.Ek het'n persoonlike allocator ( hieronder getoon ) ek het gevind dat die gebruik van die VirtualLock funksie dit beperk die bedrag van die geheue wat ek kan ken.Dit blyk te wees by die ontwerp al.Sedert ek gebruik dit vir klein voorwerpe dit is nie'n probleem.

//
template<class _Ty>
class LockedVirtualMemAllocator : public std::allocator<_Ty>
{
public:
    template<class _Other>
    LockedVirtualMemAllocator<_Ty>& operator=(const LockedVirtualMemAllocator<_Other>&)
    {   // assign from a related LockedVirtualMemAllocator (do nothing)
        return (*this);
    }

    template<class Other>
    struct rebind {
        typedef LockedVirtualMemAllocator<Other> other;
    };

    pointer allocate( size_type _n )
    {
        SIZE_T  allocLen = (_n * sizeof(_Ty));
        DWORD   allocType = MEM_COMMIT;
        DWORD   allocProtect = PAGE_READWRITE;
        LPVOID pMem = ::VirtualAlloc( NULL, allocLen, allocType, allocProtect );
        if ( pMem != NULL ) {
            ::VirtualLock( pMem, allocLen );
        }
        return reinterpret_cast<pointer>( pMem );
    }
    pointer allocate( size_type _n, const void* )
    {
        return allocate( _n );
    }

    void deallocate(void* _pPtr, size_type _n )
    {
        if ( _pPtr != NULL ) {
            SIZE_T  allocLen = (_n * sizeof(_Ty));
            ::SecureZeroMemory( _pPtr, allocLen );
            ::VirtualUnlock( _pPtr, allocLen );
            ::VirtualFree( _pPtr, 0, MEM_RELEASE );
        }
    }
};

en is gebruik

 //a memory safe std::string
 typedef std::basic_string<char, std::char_traits<char>, 
                           LockedVirtualMemAllocato<char> > modulestring_t;

Ted Percival noem mlock, maar ek het geen implementering van wat nog.

Ek het gevind dat Praktiese Kriptografie deur Neil Furguson en Bruce Schneier baie nuttig as goed.

Was dit nuttig?

Oplossing

Jy kan nie regtig beskerm teen toegang geheue. Jy kan waarskynlik voorkom blaai as jy met so 'n administrateur of as die stelsel nie, maar jy kan nie verhoed dat die admin of stelsel van die lees van jou geheue. Selfs as jy kan een of ander manier heeltemal ander prosesse verhoed die lees van jou geheue (wat jy kan nie), 'n ander proses kan nog eintlik 'n nuwe draad te spuit in jou proses en lees die geheue dat die pad.

Selfs as jy kan een of ander manier heeltemal sluit af jou proses en waarborg dat die bedryfstelsel sal nooit enigiemand anders toelaat om toegang te verkry tot jou proses, jy nog nie 'n volledige beskerming. Die hele OS kon wees wat in 'n virtuele masjien, wat kan gestop en besigtig word by enige tyd.

Jy kan nie beskerm inhoud geheue van die eienaar van die stelsel. Hollywood en die musiekbedryf is seer vir hierdie vir die jaar. As dit moontlik was, sou hulle reeds doen dit.

Ander wenke

Op Unix sisteme jy kan gebruik mlock (2) om geheue bladsye in RAM slot , die voorkoming van hulle word blaai.

  

mlock () en mlockall () onderskeidelik slot deel van of al die roeping   virtuele adresruimte proses se toetrede tot RAM, die voorkoming van daardie geheue van   word blaai om die ruil area.

Daar is 'n beperking op hoeveel geheue elke proses kan sluit, kan dit getoon met ulimit -l en word gemeet in kilogrepe. Op my stelsel, die verstek beperk is 32 KIB per proses.

As jy die ontwikkeling van nou vir Windows, daar is maniere waarop jy kan toegang tot geheue beperk, maar absoluut blokkeer ander is nie uitvoerbaar. As jy hoop om 'n geheim geheim te hou, lees Skryf Secure Code - wat hierdie probleem op 'n sekere lengte spreek, maar wees bewus daarvan dat jy het geen manier om te weet as jou kode is wat uitgevoer word op 'n werklike masjien of 'n virtuele masjien. Daar is 'n klomp van die Win32 API dinge om te gaan met crypto dat hierdie soort van ding, insluitende veilige bewaring van geheime hanteer - die boek praat oor wat. Jy kan kyk na die aanlyn Microsoft CyproAPI vir besonderhede; die OS ontwerpers erken hierdie einste probleem en die behoefte om die clear text veilig te hou (weer, lees Skryf Secure Code ).

Die Win32 API funksie VirtualAlloc is die bedryfstelsel vlak geheue allocator. Dit laat jou toe om beskerming toegang stel; wat jy kan doen is ingestel toegang tot PAGE_GUARD of PAGE_NOACCESS, en flip die toegang tot iets vriendeliker terwyl jou program lees, en herstel dit daarna, maar dit is bloot 'n spoedwal as iemand probeer werklik hard om loer by jou geheim.

In opsomming, kyk na die crypto APIs op jou platform, sal hulle die probleem beter as iets wat jy hack up jouself te spreek.

Kom ons hierdie neem 'n bietjie op 'n slag:

  

Ek wil 'n allocator skep wat   bied geheue met die volgende   skryf:

Dit is fair enough. 

* cannot be paged to disk.

Dit gaan moeilik wees. Sover ek weet, kan jy nie Virtual Paging afskakel as dit hanteer word deur die bedryfstelsel. As daar 'n manier, dan sal jy in spelunking in die ingewande van die bedryfstelsel. 

* is incredibly hard to access through an attached debugger

Jy kan dit loop deur PGE en stoor dit geïnkripteer in die geheue en dekripteer dit as dit nodig is. Massiewe prestasie treffer.

  

Die idee is dat dit sal bevat   sensitiewe inligting (soos lisensie   inligting) wat behoort te wees   ontoeganklik vir die gebruiker. ek het gedoen   die gewone navorsing aanlyn en gevra om 'n   paar ander mense oor hierdie, maar ek   kan nie 'n goeie plek begin op hierdie   probleem.

Hou alle sensitiewe inligting uit die masjien. Ernstig. Moenie sensitiewe inligting in die geheue stoor nie. Skryf 'n persoonlike verwyder roetine wat outomaties al die data van enige toekennings wat jy doen sal verwyder. Moet nooit toelaat dat algemene toegang tot 'n rekenaar met 'n sensitiewe materiaal op dit. As jy toegang db voer, maak seker dat al toegang ontsmet voor die vuur. Slegs mense met spesifieke log-ins word toegelaat om toegang. Geen algemene toegang groep.

  

Op 'n kant nota, wat ander metodes is   daar van toegang tot die geheue van 'n   proses behalwe heg 'n   debugger?

Neem 'n stort van die geheue.

installeer Libsodium, gebruik toekenning meganismes #including <sodium.h>

Bewaakte hoop toekennings

Stadiger as malloc () en vriende, wat hulle nodig het 3 of 4 ekstra bladsye van virtuele geheue. 

void *sodium_malloc(size_t size);

geheue Ken sensitiewe data met behulp van sodium_malloc() en sodium_allocarray() stoor. Jy moet eerste oproep sodium_init() voor die gebruik van hierdie hoop wagte. 

void *sodium_allocarray(size_t count, size_t size);

Die sodium_allocarray() funksie gee terug 'n wyser waaruit tel voorwerpe wat grootte grepe van die geheue elke kan verkry is. Dit bied dieselfde waarborge as sodium_malloc() maar ook beskerm teen rekenkundige oorloop wanneer count * size SIZE_MAX oorskry.

Hierdie funksies by te voeg wag bladsye rondom die beskermde data te maak dit minder waarskynlik toeganklik in 'n heartbleed-agtige scenario wees.

Daarbenewens het die beskerming van geheue streke toegeken dié manier kan verander word met behulp van die sluiting geheue bedrywighede. sodium_mprotect_noaccess(), sodium_mprotect_readonly() en sodium_mprotect_readwrite()

Na sodium_malloc kan jy sodium_free() gebruik te ontsluit en deallocate geheue. Op hierdie punt in jou implementering oorweeg Nulstellen die geheue na gebruik.

nul die geheue na gebruik 

void sodium_memzero(void * const pnt, const size_t len);

Na gebruik, moet sensitief data oorskryf, maar memset () en handgeskrewe kode kan stil word gestroop deur 'n optimalisering samesteller of deur die linkerkant.

Die sodium_memzero () funksie probeer om effektief nul Len grepe vanaf pnt, selfs al optimalisaties word toegepas op die kode.

sluit die geheue toekenning 

int sodium_mlock(void * const addr, const size_t len);

Die sodium_mlock() funksie slotte ten minste Len grepe van die geheue begin by addr. Dit kan help om te verhoed dat die uitruiling van sensitiewe data op skyf. 

int sodium_mprotect_noaccess(void *ptr);

Die funksie sodium_mprotect_noaccess () maak 'n streek toegeken met behulp van sodium_malloc () of sodium_allocarray () ontoeganklik. Dit kan nie gelees of geskryf, maar die data word saam behou. Hierdie funksie kan gebruik word om vertroulike inligting ontoeganklik behalwe wanneer eintlik wat nodig is vir 'n spesifieke bedryf te maak. 

int sodium_mprotect_readonly(void *ptr);

Die funksie sodium_mprotect_readonly () dui op 'n streek toegeken met behulp van sodium_malloc () of sodium_allocarray () as read-only. 'N poging om die data te verander sal veroorsaak dat die proses te beëindig. 

int sodium_mprotect_readwrite(void *ptr);

Die sodium_mprotect_readwrite() funksie dui op 'n streek toegeken met behulp van sodium_malloc() of sodium_allocarray() as leesbare en skryfbare, nadat hy beskerm met behulp van sodium_mprotect_readonly() of sodium_mprotect_noaccess().

Wat jy vra vir hanteer op die OS vlak. Sodra die data is in jou program, dit is aanspreeklik te blaai uit.

Vir toegang tot die geheue, 'n gemotiveerde individu kan 'n hardeware debugger heg.

@graham

  

Jy kan dit loop deur PGE en stoor dit geïnkripteer in die geheue en dekripteer dit as dit nodig is. Massiewe prestasie treffer.

Toe jy wil hê om die sleutel in die geheue te hou. Dit sou dit 'n bietjie moeiliker, maar beslis nie onmoontlik nie. Enigiemand gemotiveerde sal steeds daarin slaag om die data te kry uit die geheue.

@Derek: Ag, maar met betroubare rekenaar, kan jy geheue gordyne gebruik ! :-P

@roo

Ek was regtig hoop dit is moontlik was, en dat ek net het nie gevind dat dit nie.Jou voorbeeld het my net besef dat dit is presies wat ons probeer om te doen - net toelaat dat toegang tot die lêers in die konteks van ons program en so bewaar die IP.

Ek dink ek het om te aanvaar dat daar is geen werklik veilige manier te stoor iemand se lêers op'n ander rekenaar, veral as op'n sekere punt toegang word toegelaat tot die lêer deur die eienaar.

Dit is beslis die probleem.Jy kan die winkel iets veilig so lank as wat jy nog nooit toegang verleen nie, maar so gou as wat jy gee toegang, jou beheer is weg.Jy kan maak dit'n bietjie meer moeilik, maar dis al.

@Chris

  

O, maar met betroubare rekenaar, jy kan geheue gordyne te gebruik! :-P

Maar dan moet jy eintlik bereid is om te betaal vir 'n rekenaar iemand anders besit wees. : P

@Derek Park

Hy het gesê net harder, nie onmoontlik nie. PGE sal dit moeiliker, nie onmoontlik maak.

Gelisensieer onder: CC-BY-SA met toeskrywing
Nie verbonde aan StackOverflow
scroll top