Rask implementering av Spoofing-resistent ansiktsgjenkjenning uten sky-tilkobling

Ansiktsgjenkjenning har fått utbredt aksept for autentisering av tilgang til smarttelefoner, men forsøk på å anvende denne teknologien mer bredt har manglet på andre områder til tross for dens effektivitet og brukervennlighet. I tillegg til de tekniske utfordringene med å implementere pålitelige, billige maskinlæringsløsninger, må utviklere håndtere brukerbekymringer rundt påliteligheten og personvernet til konvensjonelle ansiktsgjenkjenningsmetoder som er avhengige av skytilkoblinger som er sårbare mot spoofing.

Denne artikkelen tar for seg vanskelighetene med sikker godkjenning før vi introduserer en maskinvare- og programvareløsning fra NXP Semiconductors som tar for seg problemene. Den viser deretter hvordan utviklere uten forutgående erfaring i maskinlæringsmetoder kan bruke løsningen til raskt å implementere offline anti-spoofing ansiktsgjenkjenning i et smart produkt.

Utfordringene med sikker autentisering for smarte produkter

Når det gjelder å håndtere økende bekymringer om sikkerheten til smarte produkter, har utviklere funnet seg selv igjen med få holdbare alternativer for pålitelig autentisering av brukere som leter etter rask, men sikker tilgang. Tradisjonelle metoder er avhengige av multifaktorautentiseringsmetoder som hviler på en kombinasjon av de klassiske tre autentiseringsfaktorene: «Noe du vet», for eksempel et passord; «Noe du har», for eksempel en fysisk nøkkel eller nøkkelkort; og «Noe du er», som vanligvis er en biometrisk faktor for eksempel et fingeravtrykk eller iris. Ved hjelp av denne tilnærmingen kan en sterkt autentisert dørlås kreve at brukeren angir en passkode, bruker et nøkkelkort og videre gir et fingeravtrykk for å låse opp døren. I praksis er slike strenge krav plagsomme eller rett og slett upraktiske for forbrukere som ofte og enkelt må godkjenne seg selv på nytt med en smarttelefon eller annen rutinemessig brukt enhet.

Bruk av ansiktsgjenkjenning har forenklet godkjenningen betydelig for smarttelefonbrukere, men smarttelefoner har noen fordeler som kanskje ikke er tilgjengelige i alle enheter. I tillegg til den betydelige prosesseringskraften som er tilgjengelig i banebrytende smarttelefoner, er tilkobling alltid på et grunnleggende krav for å levere det sofistikerte spekteret av tjenester som rutinemessig forventes av brukerne.

For mange produkter som krever sikker autentisering, vil den underliggende operativplattformen vanligvis gi mer beskjedne databehandlingsressurser og mer begrenset tilkobling. Ansiktsgjenkjenningstjenester fra de ledende skytjenesteleverandørene flytter behandlingsbelastningen til skyen, men behovet for robust tilkobling for å sikre minimal responslatens kan pålegge krav som forblir utenfor plattformens muligheter. Når brukerne er like opptatt eller mer opptatt av å overføre bildet sitt på tvers av offentlige nettverk for behandling og potensielt lagre det i skyen, skaper det betydelige personvernproblemer.

Ved hjelp av NXP Semiconductors sine i.MX RT106F-prosessorer og tilhørende programvare kan utviklere nå implementere frakoblet ansiktsgjenkjenning som direkte løser disse problemene.

Maskinvare og programvare for spoofing-sikker ansiktgjenkjenning i frakoblet modus

Et medlem av NXP Crossover microcontroller (MCU) i.MX RT1060-familien, NXP i.MX RT106F-serien, er spesielt laget for å støtte enkel integrering av frakoblet ansiktsgjenkjenning i smarte hjemmeenheter, forbruksapparater, sikkerhetsenheter og industrielt utstyr. Basert på en Arm® Cortex®-M7-prosessorkjerne kjører prosessorene ved 528 megahertz (MHz) for MIMXRT106FCVL5B med industriell kvalitet, eller 600 MHz for prosessorer med kommersiell kvalitet, som MIMXRT106FDVL6A og MIMXRT106FDVL6B.

I tillegg til å støtte et bredt spekter av eksterne minnegrensesnitt, inkluderer i.MX RT106F-prosessorer 1 megabyte (Mbyte) RAM (on-chip random access memory) med 512 kilobyte (Kbyte) konfigurert som RAM for generelle formål, og 512 Kbyte som kan konfigureres enten som RAM for generelle formål eller som TCM (tight coupled memory) for instruksjoner (I-TCM) eller data (D-TCM). Sammen med strømstyring på brikken tilbyr disse prosessorene et omfattende sett med integrerte funksjoner for grafikk, sikkerhet, systemkontroll og både analoge og digitale grensesnitt som vanligvis trengs for å støtte forbrukerenheter, industrielle menneskelige maskingrensesnitt og motorstyring (figur 1).

Figur 1: NXP Semiconductors i.MX RT106F-prosessorer kombinerer et komplett sett med funksjonelle blokker som trengs for å støtte ansiktsgjenkjenning for forbruker-, industri- og sikkerhetsprodukter. (Bildekilde: NXP)

Selv om det ligner på andre i.MX RT1060-familiemedlemmer, pakker i.MX RT106F-prosessorer i en kjøretidslisens for NXPs Oasis Lite-programvare for ansiktsgjenkjenning. Oasis Lite-kjøretidsmiljøet er utformet for å fremskynde inferens på denne klassen prosessorer, og utfører ansiktsdeteksjon, gjenkjenning og til og med begrenset følelsesklassifisering ved hjelp av inferensmodeller for nevrale nettverk (NN) som kjører på en inferensmotor og MiniCV-en nedgradert-versjon av OpenCV-datamaskinvisningsbiblioteket for åpen kildekode. Inferensmotoren bygger på et NXP NN-bibliotek og biblioteket Arm Cortex Microcontroller System Interface Standard NN (CMSIS-NN) (figur 2).

Figur 2: NXP Oasis Lite-kjøretidsbiblioteket inkluderer en Oasis Lite-kjerne som bruker MiniCV og en NXP-ledelsesmotor bygget på nevrale nettverksbiblioteker fra NXP og Arm. (Bildekilde: NXP)

Slutningsmodellene ligger på i.MX RT106F-plattformen, så ansiktsdeteksjon og gjenkjenning utføres lokalt, i motsetning til andre løsninger som er avhengige av skybaserte ressurser for å kjøre maskinlæringsalgoritmene. Takket være denne frakoblede ansiktsgjenkjenningsfunksjonen kan designere av smarte produkter sikre privat, sikker autentisering til tross for lav båndbredde eller plettfri Internett-tilkobling. Videre skjer autentisering raskt med denne maskinvare- og programvarekombinasjonen, noe som krever mindre enn 800 millisekunder (ms) for at prosessoren skal våkne fra standby med lav effekt og fullstendig ansiktsgjenkjenning.

Oasis Lite-kjøretiden brukes sammen med i.MX RT106F-prosessoren, og forenkler implementeringen av frakoblet ansiktsgjenkjenning for smarte produkter, men prosessoren og kjøretidsmiljøet er selvfølgelig bare en del av en nødvendig systemløsning. Sammen med et mer komplett sett med systemkomponenter krever en effektiv autentiseringsløsning bildebehandlingskapasitet som kan dempe en type sikkerhetstrussel kalt presentasjonsangrep. Disse angrepene forsøker å spoofe ansiktsgjenkjenning ved å bruke fotografier. For utviklere som ønsker å raskt distribuere ansiktsbasert godkjenning i sine egne produkter, gir NXP SLN-VIZNAS-IOT-utviklingssettet og tilhørende programvare en brukerklar plattform for evaluering, prototyping og utvikling av offline, anti-spoofing ansiktsgjenkjenning.

Komplett sikker systemløsning for ansiktsgjenkjenning

Som med de fleste avanserte prosessorer krever i.MX RT106F-prosessoren bare noen få tilleggskomponenter for å gi en effektiv databehandlingsplattform. NXP SLN-VIZNAS-IOT-settet fullfører designet ved å integrere i.MX RT106F med flere enheter for å gi en komplett maskinvareplattform (figur 3).

Figur 3: NXP SLN-VIZNAS-IOT-settet inkluderer en tilkoblet modul som gir en robust tilkoblet systemplattform som er nødvendig for å kjøre godkjenningsprogramvare. (Bildekilde: NXP)

Settets tilkoblede modulkort kombinerer et NXP MIMXRT106FDVL6A i.MX RT106F-prosessor, et NXP A71CH sikkert element og to tilkoblingsalternativer-NXP sin MKW41Z512VHT4 Kinetis KW41Z Bluetooth-system på en brikke (SoC) og Murata Electronics sin LBEE5KL1DX-883 Wi-Fi/Bluetooth-modul.

For å supplere prosessorens minne på brikke (on-chip), legger den tilkoblede modulen til Winbond Electronics sin W9825G6JB 256 megabit (Mbit) synkront dynamisk RAM (SDRAM), en Integrated Silicon Solution. Inc. (ISSI) IS26KL256S-DABLI00 256 Mbit NOR-flash, og ISSI sin IS25LP256D-256 Mbit Quad-serielt periferigrensesnitt (SPI)-enhet.

Til slutt legger modulen til en Torex Semiconductor XCL214B333DR nedtransformeringsomformer (buck-omformer) for å supplere i.MX RT106F-prosessorens interne strømstyringsfunksjoner for tilleggsenhetene på det tilkoblede modulkortet.

Den tilkoblede modulen monteres igjen på et visjonsapplikasjonskort som kombinerer en Murata Electronics IRA-S210ST01 passiv infrarød (PIR)-sensor, bevegelsessensor, batterilader, lydstøtte, lysdioder (LED), knapper og grensesnittkontakter (figur 4).

Figur 4: I NXP SLN-VIZNAS-IOT-settet er den tilkoblede modulen (venstre) festet til synsapplikasjonskortet for å gi maskinvaregrunnlaget for ansiktsgjenkjenning. (Bildekilde: NXP)

Sammen med denne systemplattformen krever et systemdesign for ansiktsgjenkjenning tydeligvis en egnet kamerasensor for å ta et bilde av brukerens ansikt. Som nevnt tidligere, trenger imidlertid bekymringer om presentasjonsangrep ytterligere bildebehandlingsmuligheter.

Begrensning av presentasjonsangrep

Forskere har i årevis utforsket forskjellige metoder for presentasjonsangrepsdeteksjon (PAD) som er utformet for å redusere forsøk som å bruke latente fingeravtrykk eller bilder av et ansikt til å forfalske (spoofe) biometriske autentiseringssystemer. Selv om detaljene er langt utenfor omfanget av denne artikkelen, bruker PAD-metoder generelt dypanalyse av kvaliteten og egenskapene til de biometriske dataene som er tatt som en del av prosessen, samt «liveness»-deteksjonsmetoder som er utformet for å avgjøre om de biometriske dataene ble tatt fra en levende person. Bak mange av disse forskjellige metodene spiller dype nevrale nettverksmodeller (eep neural network – DNN) en viktig rolle ikke bare når det gjelder ansiktsgjenkjenning, men også når det gjelder å identifisere forsøk på å lure (spoofe) systemet. Likevel kan avbildningssystemet som brukes til å ta brukerens ansikt, gi ytterligere støtte for liveness-deteksjon.

Til SLN-VIZNAS-IOT-settet, inkluderer NXP kameramoduler som inneholder et par ON Semiconductor sin MT9M114-bildesensorer. Her er det ene kameraet utstyrt med et rødt, grønt, blått (RGB) filter, og det andre kameraet er utstyrt med et infrarødt (IR) filter. Knyttet gjennom kameragrensesnitt til synsapplikasjonskortet genererer RGB-kameraet et normalt synlig lysbilde, mens IR-kameraet tar et bilde som ville vært annerledes for en levende person sammenlignet med et bilde av personen. SLN-VIZNAS-IOT-settet bruker denne livlighetsdeteksjonstilnærmingen sammen med sin interne ansiktsigenkjennelsesmulighet, og gir frakoblet, mulighet for anti-spoofing-ansiktsigenkjennelse i en kapsling som måler omtrent 30 x 40 mm (figur 5).

Figur 5: NXP SLN-VIZNAS-IOT-maskinvaresettet integrerer et dobbeltkamerasystem for liveness-deteksjon (øverst) og et visjonsapplikasjonskort (nederst) med en tilkoblet modul for å gi en drop-in-løsning for offlineansiktsgjenkjenning med anti-spoofing-funksjon. (Bildekilde: NXP)

Kom i gang med SLN-VIZNAS-IOT-settet

NXP SLN-VIZNAS-IOT-settet leveres bruksklart med innebygde ansiktsgjenkjenningsmodeller. Utviklere kobler til en USB-kabel og trykker på en knapp på settet for å utføre en enkel manuell ansiktsregistrering ved hjelp av det forhåndslastede “«elock»-programmet og den medfølgende mobilappen (figur 6, venstre). Etter registrering vil mobilappen vise en «velkommen hjem»-melding og «ulåst»-etikett når settet godkjenner det registrerte ansiktet (figur 6, høyre).

Figur 6: NXP SLN-VIZNAS-IOT-maskinvaresettet fungerer som det skal, ved hjelp av en ledsagende app for å registrere et ansikt (venstre) og gjenkjenne registrerte ansikter (høyre). (Bildekilde: NXP)

Settets Oasis Lite-programvare for ansiktsgjenkjenning behandler modeller fra databasen på opptil 3000 RGB-ansikter, med en gjenkjenningsnøyaktighet på 99,6 %, og opptil 100 IR-ansikter med en anti-spoofingsnøyaktighet på 96,5 %. Som nevnt tidligere, trenger NXP maskinvare/programvare mindre enn ett sekund (er) for å utføre ansiktsdeteksjon, bildejustering, kvalitetskontroll, liveness-detection og gjenkjenning over et område fra 0,2 til 1 meter. Faktisk støtter systemet en alternativ «lys» inferensmodell som er i stand til å utføre den samme sekvensen på mindre enn 0,5 sek, men støtter en mindre maksimal databasestørrelse på 1000 RGB-flater og 50 IR-anflater.

Bygger tilpassede ansiktsgjenkjenningsprogrammer

NXP SLN-VIZNAS-IOT-settet brukes som det er, og lar utviklere raskt evaluere, prototype og utvikle ansiktsgjenkjenningsprogrammer. Når tilpassede maskinvareløsninger opprettes, fungerer settet som en komplett referansekonstruksjon med fullstendige skjemaer og en detaljert materialliste (BOM). For programvareutvikling kan programmerere bruke NXP MCUXpresso Integrated Development Environment (IDE) med FreeRTOS-støtte og konfigurasjonsverktøy. For denne utrustningen bruker utviklere bare NXPs online MCUXpresso SDK Builder til å konfigurere programvareutviklingsmiljøet med NXPs VIZNAS SDK, som inkluderer NXP Oasis Lite-maskinlæringssynsjonsmotor (figur 7).

Figur 7: NXP gir et omfattende programvaremiljø som utfører NXP Oasis Lite-kjøretidsbiblioteket og verktøymedlemvaren på FreeRTOS-operativsystemet. (Bildekilde: NXP)

Programvarepakken inneholder fullstendig kildekode for driftsmiljøet så vel som elock-samplingsapplikasjonen nevnt tidligere. NXP oppgir ikke kildekode for sin proprietære Oasis Lite-motor eller for modellene. I stedet jobber utviklere med Oasis Lite-kjøretidsbiblioteket ved hjelp av det medfølgende grensesnittet for API-et (application programming interface) som tilbys, dette inkluderer et sett intuitive funksjonskall for å utføre støttede operasjoner. I tillegg bruker utviklere et gitt sett med C-definisjoner og strukturer for å angi forskjellige parametere, inkludert bildestørrelse, minnetildeling, tilbakekall og aktiverte funksjoner som brukes av systemet når Oasis Lite-kjøretidsmiljøet startes (Oasis Lite runtime environment) (oppføring 1).

Kopi
typedef struct {
    //max input image height, width and channel, min_face: minimum face can be detected
    int height;
    int width;
  
    //only valid for RGB images; for IR image, always GREY888 format
    OASISLTImageFormat_t img_format;
    OASISLTImageType_t img_type;
  
    //min_face should not smaller than 40
    int min_face;
  
    /*memory pool pointer, this memory pool should only be used by OASIS LIB*/
    char* mem_pool;
  
    /*memory pool size*/
    int size;
  
    /*output parameter,indicate authenticated or not*/
    int auth;
  
    /*callback functions provided by caller*/
    InfCallbacks_t cbs;
  
    /*what functions should be enabled in OASIS LIB*/
    uint8_t enable_flags;
  
    /*only valid when OASIS_ENABLE_EMO is activated*/
    OASISLTEmoMode_t emo_mode;
  
    /*false accept rate*/
    OASISLTFar_t false_accept_rate;
  
    /*model class */
    OASISLTModelClass_t mod_class;
  
} OASISLTInitPara_t;

Oppføring 1: Utviklere kan endre parametere for programvareutførelse ved å endre innholdet i strukturer som den som vises her for Oasis Lite-kjøretidsinitialisering. (Kodekilde: NXP)

Elock-samplingsapplikasjonskoden viser de viktigste designmønstrene for å lansere Oasis som en oppgave som kjøres under FreeRTOS, initialisere miljøet og gå inn i det normale kjørefasen. I kjørefasen opererer kjøretidsmiljøet på hver ramme av et bilde, og utfører de angitte tilbakekallingsfunksjonene som er knyttet til hver hendelse definert i miljøet (liste 2).

Kopi
typedef enum {
    /*indicate the start of face detection, user can update frame data if it is needed.
     * all parameter in callback parameter is invalid.*/
    OASISLT_EVT_DET_START,
  
    /*The end of face detection.
     *if a face is found, pfaceBox(OASISLTCbPara_t) indicated the rect(left,top,right,bottom point value)
     *info and landmark value of the face.
     *if no face is found,pfaceBox is NULL, following event will not be triggered for current frame.
     *other parameter in callback parameter is invalid */
    OASISLT_EVT_DET_COMPLETE,
  
    /*Face quality check is done before face recognition*/
    OASISLT_EVT_QUALITY_CHK_START,
    OASISLT_EVT_QUALITY_CHK_COMPLETE,
  
    /*Start of face recognition*/
    OASISLT_EVT_REC_START,
  
    /*The end of face recognition.
     * when face feature in current frame is gotten, GetRegisteredFaces callback will be called to get all
     * faces feature registered and OASIS lib will try to search this face in registered faces, if this face
     * is matched, a valid face ID will be set in callback parameter faceID and corresponding simularity(indicate
     * how confidence for the match) also will be set.
     * if no face match, a invalid(INVALID_FACE_ID) will be set.*/
    OASISLT_EVT_REC_COMPLETE,
  
    /*start of emotion recognition*/
    OASISLT_EVT_EMO_REC_START,
  
    /*End of emotion recognition, emoID indicate which emotion current face is.*/
    OASISLT_EVT_EMO_REC_COMPLETE,
  
    /*if user set a registration flag in a call of OASISLT_run and a face is detected, this two events will be notified
     * for auto registration mode, only new face(not recognized) is added(call AddNewFace callback function)
     * for manu registration mode, face will be added forcely.
     * for both cases, face ID of new added face will be set in callback function */
    OASISLT_EVT_REG_START,
    /*when registration start, for each valid frame is handled,this event will be triggered and indicate
     * registration process is going forward a little.
     * */
    OASISLT_EVT_REG_IN_PROGRESS,
    OASISLT_EVT_REG_COMPLETE,
    OASISLT_EVT_NUM
  
} OASISLTEvt_t;

Liste 2: Oasis Lite-kjøretiden gjenkjenner en rekke hendelser som er dokumentert som et talt sett i Oasis Lite-kjøretidshodefilen. (Kodekilde: NXP)

Samplingsapplikasjonen kan gi utviklere trinnvis feilsøkingsmeldinger som beskriver resultatene knyttet til hver hendelse som behandles av hendelsesbehandleren (EvtHandler). For eksempel, etter at kvalitetskontrollen er fullført (OASISLT_EVT_QUALITY_CHK_COMPLETE), skriver systemet ut feilsøkingsmeldinger som beskriver resultatet, og etter at ansiktsgjenkjenning er fullført (OASISLT_EVT_REC_COMPLETE), trekker systemet bruker-IDen og navnet fra databasen for gjenkjente ansikter og skriver ut denne informasjonen (oppføring 3).

Kopi
static void EvtHandler(ImageFrame_t *frames[], OASISLTEvt_t evt, OASISLTCbPara_t *para, void *user_data)
{
[code redacted for simplification]
        case OASISLT_EVT_QUALITY_CHK_COMPLETE:
        {
            UsbShell_Printf("[OASIS]:quality chk res:%d\r\n", para->qualityResult);
  
            pQMsg->msg.info.irLive  = para->reserved[5];
            pQMsg->msg.info.front   = para->reserved[1];
            pQMsg->msg.info.blur    = para->reserved[3];
            pQMsg->msg.info.rgbLive = para->reserved[8];
  
            if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITHOUT_GLASSES ||
                para->qualityResult == OASIS_QUALITY_RESULT_FACE_OK_WITH_GLASSES)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:ok!\r\n");
            }
            else if (OASIS_QUALITY_RESULT_FACE_SIDE_FACE == para->qualityResult)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:side face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_TOO_SMALL)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]:Small Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FACE_BLUR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: Blurry Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_IR)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: IR Fake Face!\r\n");
            }
            else if (para->qualityResult == OASIS_QUALITY_RESULT_FAIL_LIVENESS_RGB)
            {
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[EVT]: RGB Fake Face!\r\n");
            }
        }
        break;
[code redacted for simplification]
        case OASISLT_EVT_REC_COMPLETE:
        {
            int diff;
            unsigned id                     = para->faceID;
            OASISLTRecognizeRes_t recResult = para->recResult;
  
            timeState->rec_comp = Time_Now();
            pQMsg->msg.info.rt  = timeState->rec_start - timeState->rec_comp;
            face_info.rt        = pQMsg->msg.info.rt;
#ifdef SHOW_FPS
            /*pit timer unit is us*/
            timeState->rec_fps++;
            diff = abs(timeState->rec_fps_start - timeState->rec_comp);
            if (diff > 1000000 / PIT_TIMER_UNIT)
            {
                // update fps
                pQMsg->msg.info.recognize_fps = timeState->rec_fps * 1000.0f / diff;
                timeState->rec_fps            = 0;
                timeState->rec_fps_start      = timeState->rec_comp;
            }
#endif
            memset(pQMsg->msg.info.name, 0x0, sizeof(pQMsg->msg.info.name));
  
            if (recResult == OASIS_REC_RESULT_KNOWN_FACE)
            {
                std::string name;
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d\r\n", id);
                DB_GetName(id, name);
                memcpy(pQMsg->msg.info.name, name.c_str(), name.size());
                face_info.recognize = true;
                face_info.name      = std::string(name);
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face id:%d name:%s\r\n", id, pQMsg->msg.info.name);
            }
            else
            {
                // face is not recognized, do nothing
                UsbShell_DbgPrintf(VERBOSE_MODE_L2, "[OASIS]:face unrecognized\r\n");
                face_info.recognize = false;
            }
  
            VIZN_RecognizeEvent(gApiHandle, face_info);
        }
        break;

Oppføring 3: Som vist i dette utdraget fra en samplingsapplikasjon i NXP-programdistribusjonen, behandler en hendelsesbehandler hendelser som oppstår under ansiktsgjenkjenningssekvensen. (Kodekilde: NXP)

I tillegg til å støtte ansiktsgjenkjenningskrav, er NXP SLN-VIZNAS-IOT-programvaren designet for å beskytte driftsmiljøet. For å sikre kjøretidssikkerhet er systemet designet for å verifisere integriteten og autentisiteten til hvert signert bilde som lastes inn i systemet ved hjelp av et sertifikat lagret i SLN-VIZNAS-IOT-settets filsystem. Ettersom denne verifiseringssekvensen starter med en klarert oppstartslaster lagret i skrivebeskyttet minne (ROM), gir denne prosessen en klareringskjede for kjøring av fastvare for applikasjoner. Fordi kodesignering og verifisering kan bremse utviklingen, er denne verifiseringsprosessen utformet for å omgås under programvaredesign og feilsøking. Faktisk leveres SLN-VIZNAS-IOT-settet forhåndsinnlastet med signerte bilder, men kodesignaturverifisering forbigås som standard. Utviklere kan enkelt angi alternativer for å aktivere fullstendig kodesignaturverifisering for produksjon.

Sammen med kjøretidsmiljøet og tilhørende samplingsapplikasjonskode, gir NXP Android-mobilapper full java-kildekode. En app, VIZNAS FaceRec Manager, sørger for et enkelt grensesnitt for registrering av ansikter og behandling av brukere. En annen app, VIZNAS Companion-appen, lar brukere gi settet Wi-Fi-legitimasjon ved hjelp av en eksisterende Wi-Fi- eller BLE-tilkobling.

Konklusjon

Ansiktsgjenkjenning tilbyr en effektiv tilnærming for å autentisere tilgang til smarte produkter, men å implementere det har vanligvis krevd lokal høyytelsesdatabehandling eller alltid på høy båndbreddetilkobling for raske reaksjoner. Det har også vært et mål for forfalskning (spoofing) og er underlagt bekymringer om brukernes personvern.

Som vist tilbyr et spesialisert prosessor- og programvarebibliotek fra NXP Semiconductors en alternativ tilnærming som nøyaktig kan utføre ansiktsgjenkjenning i frakoblet modus på mindre enn et sekund uten skytilkobling, samtidig som man reduserer forfalskningsforsøk med spoofing.