Schnelle Implementierung einer manipulationssicheren Gesichtserkennung ohne Cloud-Verbindung

Die Gesichtserkennung hat sich für die Authentifizierung des Zugriffs auf Smartphones durchgesetzt, aber Versuche, diese Technologie breiter einzusetzen, sind in anderen Bereichen trotz ihrer Effektivität und Benutzerfreundlichkeit gescheitert. Neben den technischen Herausforderungen bei der Implementierung zuverlässiger, kostengünstiger maschineller Lernlösungen müssen die Entwickler auch die Bedenken der Benutzer hinsichtlich der Zuverlässigkeit und des Datenschutzes herkömmlicher Gesichtserkennungsmethoden berücksichtigen, die von Cloud-Verbindungen abhängen, die anfällig für Manipulationen sind.

In diesem Artikel wird die Schwierigkeit einer sicheren Authentifizierung erörtert, bevor eine Hard- und Softwarelösung von NXP Semiconductors vorgestellt wird, die diese Probleme angeht. Anschließend wird gezeigt, wie Entwickler ohne vorherige Erfahrung mit Methoden des maschinellen Lernens die Lösung nutzen können, um schnell eine manipulationsgeschützte Offline-Gesichtserkennung in einem intelligenten Produkt zu implementieren.

Die Herausforderungen der sicheren Authentifizierung für intelligente Produkte

Angesichts der zunehmenden Bedenken hinsichtlich der Sicherheit intelligenter Produkte blieben den Entwicklern nur wenige vertretbare Optionen für die zuverlässige Authentifizierung von Benutzern, die einen schnellen und dennoch sicheren Zugriff wünschen. Traditionelle Methoden setzen auf Multifaktor-Authentifizierungsmethoden, die auf einer Kombination der klassischen drei Authentifizierungsfaktoren beruhen: „Etwas, das Sie wissen“, wie z. B. ein Passwort; „Etwas, das Sie haben“, wie z. B. ein physischer Schlüssel oder eine Schlüsselkarte; und „Etwas, das Sie sind“, was typischerweise ein biometrischer Faktor wie ein Fingerabdruck oder eine Iris ist. Mit diesem Ansatz könnte ein stark authentifiziertes Türschloss verlangen, dass der Benutzer einen Passcode eingibt, eine Schlüsselkarte verwendet und zusätzlich einen Fingerabdruck bereitstellt, um die Tür zu entriegeln. In der Praxis sind solche strengen Anforderungen lästig oder einfach unpraktisch für Verbraucher, die sich häufig und einfach mit einem Smartphone oder einem anderen routinemäßig verwendeten Gerät neu authentifizieren müssen.

Die Verwendung von Gesichtserkennung hat die Authentifizierung für Smartphone-Benutzer erheblich vereinfacht, aber Smartphones besitzen einige Vorteile, die nicht in jedem Gerät verfügbar sind. Neben der beträchtlichen Rechenleistung, die in modernen Smartphones zur Verfügung steht, ist die ständige Vernetzung eine Grundvoraussetzung für die Bereitstellung der anspruchsvollen Dienste, die von ihren Nutzern routinemäßig erwartet werden.

Für viele Produkte, die eine sichere Authentifizierung erfordern, stellt die zugrundeliegende Betriebsplattform in der Regel bescheidenere Rechenressourcen und eine begrenztere Vernetzung zur Verfügung. Die Gesichtserkennungsdienste der führenden Cloud-Service-Anbieter verlagern die Verarbeitungslast in die Cloud, aber die Notwendigkeit einer robusten Vernetzung, um eine minimale Antwortlatenz zu gewährleisten, könnte Anforderungen stellen, die über die Möglichkeiten der Plattform hinausgehen. Genauso wichtig oder noch wichtiger für die Benutzer ist, dass die Übertragung ihres Bildes über öffentliche Netzwerke zur Verarbeitung und potenziellen Speicherung in der Cloud erhebliche Datenschutzprobleme aufwirft.

Mit den Prozessoren i.MX RT106F von NXP Semiconductors und der zugehörigen Software können Entwickler jetzt eine Offline-Gesichtserkennung implementieren, die diese Probleme direkt angeht.

Hardware und Software für manipulationssichere Offline-Gesichtserkennung

Die i.MX-RT106F-Serie von NXP ist ein Mitglied der Crossover-Mikrocontroller(MCU)-Familie i.MX RT1060 von NXP und wurde speziell für die einfache Integration von Offline-Gesichtserkennung in Smart-Home-Geräte, Verbrauchergeräte, Sicherheitsvorrichtungen und Industrieanlagen entwickelt. Basierend auf einem Arm®-Cortex®-M7-Prozessorkern laufen die Prozessoren mit 528 Megahertz (MHz) für den industriellen MIMXRT106FCVL5B oder mit 600 MHz bei kommerziellen Prozessoren wie den MIMXRT106FDVL6A und MIMXRT106FDVL6B.

Neben der Unterstützung einer Vielzahl von externen Speicherschnittstellen verfügen die i.MX-RT106F-Prozessoren über 1 Megabyte (MByte) On-Chip-RAM (Random Access Memory) mit 512 Kilobyte (KByte), die als Allzweck-RAM konfiguriert sind, und 512 KByte, die entweder als Allzweck-RAM oder als Tightly-Coupled-Memory (TCM) für Anweisungen (I-TCM) oder Daten (D-TCM) konfiguriert werden können. Zusammen mit dem integrierten Energiemanagement bieten diese Prozessoren einen umfangreichen Satz integrierter Funktionen für Grafik, Sicherheit, Systemsteuerung und sowohl analoge als auch digitale Schnittstellen, die typischerweise zur Unterstützung von Verbrauchergeräten, industriellen Mensch-Maschine-Schnittstellen (HMIs) und Motorsteuerung benötigt werden (Abbildung 1).

Abbildung 1: Die i.MX-RT106F-Prozessoren von NXP Semiconductor vereinen alle Funktionsblöcke, die zur Unterstützung der Gesichtserkennung für Verbraucher-, Industrie- und Sicherheitsprodukte benötigt werden. (Bildquelle: NXP)

Ähnlich wie bei den anderen Mitgliedern der i.MX-RT1060-Familie ist bei den i.MX-RT106F-Prozessoren eine Runtime-Lizenz für die Gesichtserkennungssoftware Oasis Lite von NXP enthalten. Die Laufzeitumgebung Oasis Lite wurde entwickelt, um die Inferenz auf dieser Prozessorklasse zu beschleunigen. Sie führt Gesichtsdetektion, -erkennung und sogar eine begrenzte Emotionsklassifizierung mit Hilfe von Inferenzmodellen aus neuronalen Netzen (NN) durch, die auf einer Inferenz-Engine und MiniCV laufen - einer abgespeckten Version der Open-Source-Computer-Vision-Bibliothek OpenCV. Die Inferenz-Engine baut auf einer NN-Bibliothek von NXP und der CMSIS-NN-Bibliothek von Arm (Cortex Microcontroller System Interface Standard NN) auf (Abbildung 2).

Abbildung 2: Die Oasis-Lite-Laufzeitbibliothek von NXP umfasst einen Oasis-Lite-Kern, der MiniCV verwendet, und eine NXP-Inferenz-Engine, die auf neuronalen Netzwerkbibliotheken von NXP und Arm aufbaut. (Bildquelle: NXP)

Die Inferenzmodelle befinden sich auf der i.MX-RT106F-Plattform, sodass die Gesichtserkennung lokal ausgeführt wird - im Gegensatz zu anderen Lösungen, die für die Ausführung der maschinellen Lernalgorithmen auf cloudbasierte Ressourcen angewiesen sind. Dank dieser Offline-Gesichtserkennungsfunktion können Designer von intelligenten Produkten eine private, sichere Authentifizierung trotz geringer Bandbreite oder punktueller Internetverbindung gewährleisten. Darüber hinaus erfolgt die Authentifizierung mit dieser Hard- und Softwarekombination sehr schnell: Der Prozessor benötigt weniger als 800 Millisekunden (ms), um aus dem stromsparenden Standby-Modus aufzuwachen und die Gesichtserkennung abzuschließen.

In Verbindung mit dem i.MX-RT106F-Prozessor vereinfacht die Oasis-Lite-Laufzeitumgebung die Implementierung von Offline-Gesichtserkennung für intelligente Produkte, aber der Prozessor und die Laufzeitumgebung sind natürlich nur ein Teil einer erforderlichen Systemlösung. Zusammen mit einem vollständigeren Satz von Systemkomponenten erfordert eine effektive Authentifizierungslösung eine Bildgebungsfunktion, die eine Art von Sicherheitsbedrohung, die so genannten Präsentationsangriffe, entschärfen kann. Diese Angriffe versuchen, die Authentifizierung der Gesichtserkennung mit Hilfe von Fotos zu fälschen. Für Entwickler, die schnell gesichtsbasierte Authentifizierung in ihren eigenen Produkten einsetzen wollen, bieten das Entwicklungskit SLN-VIZNAS-IOT von NXP und die dazugehörige Software eine sofort einsatzbereite Plattform für die Evaluierung, das Prototyping und die Entwicklung von Offline-Gesichtserkennung mit Manipulationsschutzfunktion.

Komplette sichere Systemlösung für die Gesichtserkennung

Wie bei den meisten fortschrittlichen Prozessoren sind auch beim i.MX-RT106F-Prozessor nur wenige zusätzliche Komponenten erforderlich, um eine effektive Computing-Plattform zu schaffen. Das Kit SLN-VIZNAS-IOT von NXP vervollständigt das Design durch die Integration des i.MX RT106F mit zusätzlichen Komponenten zu einer kompletten Hardware-Plattform (Abbildung 3).

Abbildung 3: Das Kit SLN-VIZNAS-IOT von NXP enthält ein vernetztes Modul, das eine robuste, vernetzte Systemplattform bietet, die zur Ausführung von Authentifizierungssoftware benötigt wird. (Bildquelle: NXP)

Die vernetzte Modulplatine des Kits kombiniert einen i.MX-RT106F-Prozessor MIMXRT106FDVL6A von NXP, ein Sicherheitselement A71CH von NXP und zwei Vernetzungsoptionen - das Kinetis-KW41Z-BLE-SoC MKW41Z512VHT4 (BLE: Bluetooth Low Energy, SoC: System-on-Chip) von NXP und das Wi-Fi/Bluetooth-Modul LBEE5KL1DX-883 von Murata Electronics.

Um den On-Chip-Speicher des Prozessors zu ergänzen, fügt das vernetzte Modul noch 256 Megabit (Mbit) synchrones dynamisches RAM (SDRAM) W9825G6JB von Winbond Electronics und von Integrated Silicon Solution. Inc. (ISSI) den 256 Mbit NOR-Flash IS26KL256S-DABLI00 sowie ISSIs 256 Mbit Quad-SPI-Baustein (SPI: Serial Peripheral Interface) IS25LP256D hinzu.

Schließlich fügt das Modul noch einen Abwärtswandler XCL214B333DR von Torex Semiconductor hinzu, um die internen Energiemanagement-Funktionen des i.MX-RT106F-Prozessors für die zusätzlichen Komponenten auf der vernetzten Modulplatine zu ergänzen.

Das vernetzte Modul wiederum wird auf einem Bildverarbeitungsboard montiert, das einen passiven Infrarotsensor (PIR) IRA-S210ST01 von Murata Electronics, einen Bewegungssensor, ein Batterieladegerät, Audio-Unterstützung, Leuchtdioden (LEDs), Tasten und Schnittstellenanschlüsse kombiniert (Abbildung 4).

Abbildung 4: Im Kit SLN-VIZNAS-IOT von NXP wird das vernetzte Modul (links) an das Bildverarbeitungsboard angeschlossen, um die Hardwaregrundlage für die Gesichtserkennung zu schaffen. (Bildquelle: NXP)

Neben dieser Systemplattform ist für das Design eines Gesichtserkennungssystems natürlich auch ein geeigneter Kamerasensor erforderlich, um ein Bild des Gesichts des Benutzers zu erfassen. Wie bereits erwähnt, erfordert die Sorge vor Präsentationsangriffen jedoch zusätzliche Bildgebungsfunktionen.

Entschärfung von Präsentationsangriffen

Forscher haben jahrelang verschiedene Methoden zur Erkennung von Präsentationsangriffen (Presentation Attack Detection, PAD) erforscht, um Versuche zu entschärfen, wie z. B. latente Fingerabdrücke oder Bilder eines Gesichts zu verwenden, um biometrisch basierte Authentifizierungssysteme zu fälschen. Obwohl die Details weit über den Rahmen dieses Artikels hinausgehen, verwenden PAD-Methoden im Allgemeinen eine tiefgehende Analyse der Qualität und der Eigenschaften der erfassten biometrischen Daten als Teil des Prozesses sowie Erkennungsmethoden der „Vitalität“, die darauf ausgelegt sind, festzustellen, ob die biometrischen Daten von einer lebenden Person erfasst wurden. Bei vielen dieser verschiedenen Methoden spielen DNN-Modelle (Deep Neural Network) eine wichtige Rolle, nicht nur bei der Gesichtserkennung, sondern auch bei der Erkennung von Manipulationsversuchen des Systems. Nichtsdestotrotz kann das Bildgebungssystem, mit dem das Gesicht des Benutzers erfasst wird, eine zusätzliche Unterstützung bei der Vitalitätserkennung bieten.

NXP fügt dem Kit SLN-VIZNAS-IOT Kameramodule hinzu, die ein Paar Bildsensoren MT9M114 von ON Semiconductor enthalten. Dabei ist eine Kamera mit einem Rot-Grün-Blau-Filter (RGB) und die andere Kamera mit einem Infrarotfilter (IR) ausgestattet. Die RGB-Kamera, die über Kamera-Schnittstellen mit dem Bildverarbeitungsboard verbunden ist, erzeugt ein normales Bild mit sichtbarem Licht, während die IR-Kamera ein Bild aufnimmt, das sich von einem Bild einer lebenden Person unterscheidet. Durch die Verwendung dieses Ansatzes zur Vitalitätserfassung zusammen mit der internen Gesichtserkennungsfunktion bietet das Kit SLN-VIZNAS-IOT eine Offline-Gesichtserkennungsfunktion mit Manipulationsschutz in einem Gehäuse von etwa 30 x 40 Millimeter (mm) (Abbildung 5).

Abbildung 5: Das Hardware-Kit SLN-VIZNAS-IOT von NXP integriert ein System mit zwei Kameras zur Vitalitätserkennung (oben) und ein Bildverarbeitungsboard (unten) mit einem angeschlossenen Modul, um eine sofort implementierbare Lösung für die Offline-Gesichtserkennung mit Manipulationsschutz bereitzustellen. (Bildquelle: NXP)

Erste Schritte mit dem SLN-VIZNAS-IOT

Das Kit SLN-VIZNAS-IOT von NXP wird gebrauchsfertig mit integrierten Gesichtserkennungsmodellen geliefert. Entwickler schließen ein USB-Kabel an und berühren eine Taste auf dem Kit, um eine einfache manuelle Gesichtsregistrierung mit der vorinstallierten „elock“-Anwendung und der dazugehörigen mobilen App durchzuführen (Abbildung 6, links). Nach der Registrierung zeigt die mobile App eine „Willkommen zu Hause“-Nachricht und ein „Entsperrt“-Label an, wenn das Kit das registrierte Gesicht authentifiziert (Abbildung 6, rechts).

Abbildung 6: Das Hardware-Kit SLN-VIZNAS-IOT von NXP funktioniert sofort nach dem Auspacken und nutzt eine Begleit-App, um ein Gesicht zu registrieren (links) und registrierte Gesichter zu erkennen (rechts). (Bildquelle: NXP)

Die Gesichtserkennungssoftware Oasis Lite des Kits verarbeitet Modelle aus seiner Datenbank von bis zu 3000 RGB-Gesichtern mit einer Erkennungsgenauigkeit von 99,6 % und bis zu 100 IR-Gesichtern mit einer Manipulationsschutz-Genauigkeit von 96,5 %. Wie bereits erwähnt, benötigt die Hardware/Software-Lösung von NXP weniger als eine Sekunde (s), um die Gesichtserkennung, den Bildabgleich, die Qualitätsprüfung, die Erkennung der Vitalität und die Erkennung in einem Bereich von 0,2 bis 1,0 Metern (m) durchzuführen. Tatsächlich unterstützt das System ein alternatives „leichtes“ Inferenzmodell, das die gleiche Sequenz in weniger als 0,5 s durchführen kann, aber eine kleinere maximale Datenbankgröße von 1000 RGB-Gesichtern und 50 IR-Gesichtern unterstützt.

Erstellen von benutzerdefinierten Gesichtserkennungsanwendungen

Mit dem Kit SLN-VIZNAS-IOT von NXP können Entwickler Gesichtserkennungsanwendungen schnell evaluieren, prototypisieren und entwickeln. Bei der Erstellung von kundenspezifischen Hardware-Lösungen dient das Kit als komplettes Referenzdesign mit vollständigen Schaltplänen und einer detaillierten Stückliste (BOM). Für die Softwareentwicklung können Programmierer die integrierte Entwicklungsumgebung (IDE) MCUXpresso von NXP mit FreeRTOS-Unterstützung und Konfigurationstools verwenden. Für diese Anwendung verwenden Entwickler einfach den online verfügbaren MCUXpresso SDK Builder von NXP, um ihre Softwareentwicklungsumgebung mit dem VIZNAS-SDK von NXP zu konfigurieren, das die maschinell lernende Bildverarbeitungsengine Oasis Lite von NXP enthält (Abbildung 7).

Abbildung 7: NXP bietet eine umfassende Softwareumgebung, in der die Laufzeitbibliothek von Oasis Lite von NXP und die Utility-Middleware auf dem FreeRTOS-Betriebssystem ausgeführt werden. (Bildquelle: NXP)

Das Softwarepaket enthält den kompletten Quellcode für die Betriebsumgebung sowie die bereits erwähnte elock-Beispielanwendung. NXP stellt keinen Quellcode für seine proprietäre Oasis-Lite-Engine oder für die Modelle zur Verfügung. Stattdessen arbeiten Entwickler mit der Oasis-Lite-Laufzeitbibliothek unter Verwendung der bereitgestellten Anwendungsprogrammierschnittstelle (API), die einen Satz intuitiver Funktionsaufrufe zur Durchführung unterstützter Operationen enthält. Darüber hinaus verwenden Entwickler einen mitgelieferten Satz von C-Definitionen und -Strukturen, um verschiedene Parameter wie Bildgröße, Speicherzuweisung, Callbacks und aktivierte Funktionen zu spezifizieren, die vom System beim Starten der Oasis-Lite-Laufzeitumgebung verwendet werden (Listing 1).

Kopieren
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;

Listing 1: Entwickler können die Ausführungsparameter der Software ändern, indem sie den Inhalt von Strukturen wie der hier gezeigten für die Laufzeitinitialisierung von Oasis Lite modifizieren. (Codequelle: NXP)

Der elock-Beispielanwendungscode demonstriert die wichtigsten Entwurfsmuster für den Start von Oasis als Task unter FreeRTOS, die Initialisierung der Umgebung und den Eintritt in die normale Laufphase. In der Ausführungsphase arbeitet die Laufzeitumgebung auf jedem Frame eines Bildes und führt die bereitgestellten Callback-Funktionen aus, die mit jedem in der Umgebung definierten Ereignis verbunden sind (Listing 2).

Kopieren
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;

Listing 2: Das Oasis-Lite-Laufzeitsystem erkennt eine Reihe von Ereignissen, die als Aufzählungssatz in der Header-Datei des Oasis-Lite-Laufzeitsystems dokumentiert sind. (Codequelle: NXP)

Die Beispielanwendung kann Entwicklern Schritt-für-Schritt-Debug-Meldungen zur Verfügung stellen, die die Ergebnisse beschreiben, die mit jedem vom Event-Handler (EvtHandler) verarbeiteten Ereignis verbunden sind. Beispielsweise gibt das System nach Abschluss der Qualitätsprüfung (OASISLT_EVT_QUALITY_CHK_COMPLETE) Debug-Meldungen aus, die das Ergebnis beschreiben, und nach Abschluss der Gesichtserkennung (OASISLT_EVT_REC_COMPLETE) zieht das System die Benutzer-ID und den Namen aus seiner Datenbank für erkannte Gesichter und gibt diese Informationen aus (Listing 3).

Kopieren
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;

Listing 3: Wie in diesem Ausschnitt aus einer Beispielanwendung in der NXP-Software-Distribution gezeigt, verarbeitet ein Event-Handler Ereignisse, die während der Gesichtserkennungssequenz auftreten. (Codequelle: NXP)

Neben der Unterstützung der Anforderungen an die Gesichtserkennungsverarbeitung ist die SLN-VIZNAS-IOT-Software von NXP auf den Schutz der Betriebsumgebung ausgelegt. Um die Sicherheit zur Laufzeit zu gewährleisten, ist das System so konzipiert, dass es die Integrität und Authentizität jedes signierten Bildes, das in das System geladen wird, anhand eines im Dateisystem des SLN-VIZNAS-IOT-Kits gespeicherten Zertifikats überprüft. Da diese Verifizierungssequenz mit einem vertrauenswürdigen Bootloader beginnt, der im Nur-Lese-Speicher (ROM) gespeichert ist, bietet dieser Prozess eine Vertrauenskette für die laufende Anwendungsfirmware. Da zudem die Codesignierung und -verifizierung die Entwicklung verlangsamen kann, ist dieser Verifizierungsprozess so konzipiert, dass er während des Softwaredesigns und der Fehlersuche umgangen werden kann. Tatsächlich wird das SLN-VIZNAS-IOT-Kit mit signierten Bildern vorinstalliert, aber die Überprüfung der Codesignatur wird standardmäßig umgangen. Entwickler können auf einfache Weise Optionen setzen, um die vollständige Code-Signaturprüfung für die Produktion zu aktivieren.

Zusammen mit der Laufzeitumgebung und dem zugehörigen Beispielanwendungscode stellt NXP mobile Android-Apps mit vollständigem Java-Quellcode zur Verfügung. Eine App, der „VIZNAS FaceRec Manager“, bietet eine einfache Oberfläche für die Registrierung von Gesichtern und die Verwaltung von Benutzern. Eine weitere App, die „VIZNAS Companion App“, ermöglicht es Benutzern, das Kit mit Wi-Fi-Anmeldeinformationen über eine bestehende Wi-Fi- oder BLE-Verbindung bereitzustellen.

Fazit

Die Gesichtserkennung bietet einen effektiven Ansatz für die Authentifizierung des Zugriffs auf intelligente Produkte, aber ihre Implementierung erfordert in der Regel lokale Hochleistungsrechner oder eine permanente Verbindung mit hoher Bandbreite für schnelle Reaktionen. Sie ist darüber hinaus auch ein Ziel von Manipulation und ist Gegenstand von Bedenken bezüglich der Privatsphäre der Benutzer.

Wie gezeigt, bieten ein spezieller Prozessor und eine Software-Bibliothek von NXP Semiconductors einen alternativen Ansatz, der eine genaue Offline-Gesichtserkennung in weniger als einer Sekunde ohne Cloud-Verbindung durchführen kann und gleichzeitig Manipulationsversuchen entgegenwirkt.