Megosztás a következőn keresztül:

Biztonságos kapcsolat a Holographic Remoting és az OpenXR API használatával

  • Cikk

Az OpenXR API használatakor minden biztonságos kapcsolattal kapcsolatos API elérhető az XR_MSFT_holographic_remoting OpenXR-bővítmény részeként.

Fontos

A Holographic Remoting OpenXR bővítmény API-val kapcsolatos információkért tekintse meg a Holographic Remoting samples github-adattárban található specifikációt.

Ne feledje, hogy egyéni távoli és lejátszóalkalmazásokat kell implementálnia, ha engedélyezni szeretné a kapcsolatbiztonságot. Mindkét egyéni alkalmazásnak szüksége van a következőkre:

  • Tanúsítványszolgáltató és hitelesítés-érvényesítő, ha az alkalmazás kiszolgálóként fut.
  • Hitelesítési szolgáltató és tanúsítvány-érvényesítő, ha az alkalmazás ügyfélként fut.

Az OpenXR API hasonló az itt leírt Windows Mixed Reality API-hoz. Az interfészek implementálása helyett azonban az OpenXR-bővítményt használó XR_MSFT_holographic_remoting biztonságos kapcsolat legfontosabb elemei a következő visszahívások:

  • xrRemotingRequestAuthenticationTokenCallbackMSFT, létrehozza vagy lekéri az elküldendő hitelesítési jogkivonatot.
  • xrRemotingValidateServerCertificateCallbackMSFT, ellenőrzi a tanúsítványláncot.
  • xrRemotingValidateAuthenticationTokenCallbackMSFT, ellenőrzi az ügyfél-hitelesítési jogkivonatot.
  • xrRemotingRequestServerCertificateCallbackMSFT, adja meg a kiszolgálóalkalmazásnak a használni kívánt tanúsítványt.

Megjegyzés

A Holographic Remoting használatával lehetséges, hogy a lejátszó vagy a távoli kiszolgáló az igényeitől függően (további információ: Holographic Remoting Terminológia). Ha az egyéni távoli vagy egyéni lejátszóalkalmazás ügyfélként és kiszolgálóként is futtatható, az alkalmazásnak mind a négy visszahívást meg kell adnia.

A visszahívások a és xrRemotingSetSecureConnectionServerCallbacksMSFTa használatával biztosíthatók az OpenXR-futtatókörnyezet xrRemotingSetSecureConnectionClientCallbacksMSFT újraegyesítéséhez. Ehhez statikus függvényeket hozhat létre a visszahívásokhoz:

class SecureConnectionCallbacks {
public:
    ...

    // Static callbacks
    static XrResult XRAPI_CALL
    RequestAuthenticationTokenStaticCallback(XrRemotingAuthenticationTokenRequestMSFT* authenticationTokenRequest) {
        if (!authenticationTokenRequest->context) {
            return XR_ERROR_RUNTIME_FAILURE;
        }
        return reinterpret_cast<SecureConnectionCallbacks*>(authenticationTokenRequest->context)
            ->RequestAuthenticationToken(authenticationTokenRequest);
    }

    static XrResult XRAPI_CALL
    ValidateServerCertificateStaticCallback(XrRemotingServerCertificateValidationMSFT* serverCertificateValidation) {
        if (!serverCertificateValidation->context) {
            return XR_ERROR_RUNTIME_FAILURE;
        }
        return reinterpret_cast<SecureConnectionCallbacks*>(serverCertificateValidation->context)
            ->ValidateServerCertificate(serverCertificateValidation);
    }

    static XrResult XRAPI_CALL
    ValidateAuthenticationTokenStaticCallback(XrRemotingAuthenticationTokenValidationMSFT* authenticationTokenValidation) {
        if (!authenticationTokenValidation->context) {
            return XR_ERROR_RUNTIME_FAILURE;
        }
        return reinterpret_cast<SecureConnectionCallbacks*>(authenticationTokenValidation->context)
            ->ValidateAuthenticationToken(authenticationTokenValidation);
    }

    static XrResult XRAPI_CALL
    RequestServerCertificateStaticCallback(XrRemotingServerCertificateRequestMSFT* serverCertificateRequest) {
        if (!serverCertificateRequest->context) {
            return XR_ERROR_RUNTIME_FAILURE;
        }
        return reinterpret_cast<SecureConnectionCallbacks*>(serverCertificateRequest->context)
            ->RequestServerCertificate(serverCertificateRequest);
    }
}

A statikus visszahívási függvények mind hasonlóak, és a fenti példában csak meghívnak egy függvényt a környezeti objektumon, amely a vagy xrRemotingSetSecureConnectionServerCallbacksMSFTa értékben xrRemotingSetSecureConnectionClientCallbacksMSFT van beállítva. A visszahívások tényleges megvalósítása ezután a környezeti objektum tagfüggvényei között történik:

class SecureConnectionCallbacks {   
    ...

private:
    // The client has to provide a token and has to validate the certificate.
    XrResult RequestAuthenticationToken(XrRemotingAuthenticationTokenRequestMSFT* authenticationTokenRequest) {
        // To provide a token fill out the authenticationTokenRequest with your token.
    }
    XrResult ValidateServerCertificate(XrRemotingServerCertificateValidationMSFT* serverCertificateValidation) {
        // Validate the certificate.
    }

    // The server has to provide a certificate and hast to validate the token.
    XrResult ValidateAuthenticationToken(XrRemotingAuthenticationTokenValidationMSFT* authenticationTokenValidation) {
        // Validate the token.
    }
    XrResult RequestServerCertificate(XrRemotingServerCertificateRequestMSFT* serverCertificateRequest) {
        // To provide a certificate fill out the serverCertificateRequest with your certificate.
    }
}

Most már megadhatja a és a visszahívásokat xrRemotingSetSecureConnectionClientCallbacksMSFTxrRemotingSetSecureConnectionServerCallbacksMSFT. Emellett a biztonságos kapcsolatot a secureConnection paraméterrel kell engedélyezni a struktúrán vagy a XrRemotingConnectInfoMSFTXrRemotingListenInfoMSFT struktúrán, attól függően, hogy használja-e xrRemotingConnectMSFT vagy xrRemotingListenMSFT:

...

SecureConnectionCallbacks callbackObject;

...

if (client) 
{
    XrRemotingSecureConnectionClientCallbacksMSFT clientCallbacks{static_cast<XrStructureType>(XR_TYPE_REMOTING_SECURE_CONNECTION_CLIENT_CALLBACKS_MSFT);
    clientCallbacks.context = &callbackObject;
    clientCallbacks.requestAuthenticationTokenCallback = SecureConnectionCallbacks::RequestAuthenticationTokenStaticCallback;
    clientCallbacks.validateServerCertificateCallback = SecureConnectionCallbacks::ValidateServerCertificateStaticCallback;
    clientCallbacks.performSystemValidation = true;
    CHECK_XRCMD(m_extensions.xrRemotingSetSecureConnectionClientCallbacksMSFT(m_instance.Get(), m_systemId, &clientCallbacks));
    
    ...

    connectInfo.secureConnection = true; // Enable secure connection!
    CHECK_XRCMD(m_extensions.xrRemotingConnectMSFT(m_instance.Get(), m_systemId, &connectInfo));
}

if (server) 
{
    XrRemotingSecureConnectionServerCallbacksMSFT serverCallbacks{static_cast<XrStructureType>(XR_TYPE_REMOTING_SECURE_CONNECTION_SERVER_CALLBACKS_MSFT);
    serverCallbacks.context = &callbackObject;
    serverCallbacks.requestServerCertificateCallback = SecureConnectionCallbacks::RequestServerCertificateStaticCallback;
    serverCallbacks.validateAuthenticationTokenCallback = SecureConnectionCallbacks::ValidateAuthenticationTokenStaticCallback;
    serverCallbacks.authenticationRealm = /*YourAuthenticationRealm*/;
    CHECK_XRCMD(m_extensions.xrRemotingSetSecureConnectionServerCallbacksMSFT(m_instance.Get(), m_systemId, &serverCallbacks));

    ...

    listenInfo.secureConnection = true; // Enable secure connection!
    CHECK_XRCMD(m_extensions.xrRemotingListenMSFT(m_instance.Get(), m_systemId, &listenInfo));
}

Megjegyzés

Részletes példát az OpenXR mintaalkalmazásban talál.

Lásd még: