Connexion sécurisée avec la communication à distance holographique et l’API OpenXR
Lors de l’utilisation de l’API OpenXR, toute l’API liée à la connexion sécurisée est disponible dans le cadre de l’extension XR_MSFT_holographic_remoting OpenXR.
Important
Pour en savoir plus sur l’API d’extension Holographic Remoting OpenXR, case activée la spécification qui se trouve dans le référentiel github d’exemples de communication à distance holographiques.
N’oubliez pas que vous devez implémenter des applications distantes et de lecteur personnalisées si vous souhaitez activer la sécurité de connexion. Les deux applications personnalisées ont besoin des éléments suivants :
- Un fournisseur de certificat et un validateur d’authentification si l’application s’exécute en tant que serveur.
- Un fournisseur d’authentification et un validateur de certificat si l’application s’exécute en tant que client.
L’API OpenXR est similaire à l’API Windows Mixed Reality décrite ici.
Toutefois, au lieu d’implémenter des interfaces, les éléments clés pour une connexion sécurisée à l’aide de l’extension XR_MSFT_holographic_remoting OpenXR sont les rappels suivants :
xrRemotingRequestAuthenticationTokenCallbackMSFT, génère ou récupère le jeton d’authentification à envoyer.xrRemotingValidateServerCertificateCallbackMSFT, valide la chaîne de certificats.xrRemotingValidateAuthenticationTokenCallbackMSFT, valide le jeton d’authentification client.xrRemotingRequestServerCertificateCallbackMSFT, fournissez à l’application serveur le certificat à utiliser.
Notes
Avec la communication à distance holographique, il est possible que le lecteur ou le serveur distant soit le serveur en fonction de vos besoins (pour plus d’informations, consultez Terminologie de communication à distance holographique). Si votre application de lecteur distant ou personnalisé peut s’exécuter en tant que client et serveur, l’application doit fournir les quatre rappels.
Les rappels peuvent être fournis au runtime OpenXR de communication à distance via xrRemotingSetSecureConnectionClientCallbacksMSFT et xrRemotingSetSecureConnectionServerCallbacksMSFT.
Pour ce faire, vous pouvez créer des fonctions statiques pour les rappels :
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);
}
}
Les fonctions de rappel statiques se ressemblent toutes et, dans l’exemple ci-dessus, elles appellent simplement une fonction sur l’objet de contexte, qui est défini dans xrRemotingSetSecureConnectionClientCallbacksMSFT ou xrRemotingSetSecureConnectionServerCallbacksMSFT. L’implémentation réelle des rappels est ensuite effectuée à l’intérieur des fonctions membres de l’objet de contexte :
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.
}
}
Vous pouvez maintenant fournir les rappels à xrRemotingSetSecureConnectionClientCallbacksMSFT et xrRemotingSetSecureConnectionServerCallbacksMSFT. En outre, la connexion sécurisée doit être activée via le paramètre secureConnection sur la XrRemotingConnectInfoMSFT structure ou la XrRemotingListenInfoMSFT structure selon que vous utilisez xrRemotingConnectMSFT ou 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));
}
Notes
Vous trouverez un exemple détaillé dans l’exemple d’application OpenXR.