% Renforcement de la sécurité d’un lecteur vidéo multiplate-forme par séparation des privilèges
% Alexandre Janniaux
% 19 septembre 2018

## VideoLabs, VLC

<img src="images/videolabs.svg" alt="Logo videolabs" width="50%"/>

## Présentation de l'entreprise

- Créée en 2012
- Sponsorise le développement de VLC
- Propose des prestations en :
    - systèmes embarqués
    - pipeline vidéo
    - multimédia en général
- Composée d'une quinzaine d'employés

## Présentation du stage

+ Principalement de la recherche (4 mois)
+ Utilisation d'une API d'encodage matériel
+ Optimisation d'un moteur de rendu pour la VR
+ Réalisation d'un prototype VLC multiprocessus

## Sandboxing

- Besoin d'isolation mémoire
- Besoin de règles par processus
- Besoin de définir les possibilités pour chaque bout de l'application

## Conteneurs

<img src="images/flatpak.png" alt="Flatpack">
<img src="images/logo-baleine-docker.png" alt="Docker">

## Fined Grained sandboxing

<img src="images/googlechrome.svg" alt="Google Chrome" width="40%">

## Objectifs de la sandbox

- être désactivable au démarrage
- définir des zones de privilège et d'accès
- ne pas réécrire les modules

## Mécanismes de sandboxing sous Linux

- Linux capabilites
- Seccomp
- Linux namespaces
- cgroups

## Mécanismes de sandboxing sous Windows

- Integrity level
- AppContainer
- DACL

## Conception de la sandbox

- Réalisation d'un prototype indépendant
- Intégration dans VLC
- Choix du modèle

<aside class=notes>
</aside>

## Modèles de sandbox : orchestrateur

<img src="images/orchestrateur.svg" alt="Orchestrateur">

<aside class=notes>
+ Socket dédié pour chaque lien entre zone
+ Jetons d'accès
+ Moins d'appel système

Mais

+ Croissance potentiellement quadratique du nombre de socket
+ Difficile à manipuler
+ Difficile à déboguer

Exemple avec strace
</aside>

## Modèles de sandbox : broker

<img src="images/broker.svg" alt="Orchestrateur">

<aside class=notes>
+ droits d'accès plus fin, centralisés et personnalisables
+ point de contrôle pour les logs et le debogage

mais

+ logique de contrôle et de routage
+ plus d'étape de changement de contexte

</aside>

## Premier prototype

- Créer les processus
- Établir la communication entre eux
- Modèle orchestrateur
<img src="images/Nginx_logo.svg" alt="Logo NGINX" width="50%">

Manipulation de l'interface SCM et de la mémoire partagée

## Modification des variables

- Répartition de l'arbre de variables sur plusieurs processus
- Très bon test pour la communication interprocessus
- Devenu gênant dans la suite

## Deadlock version 1

<img src="images/deadlock_rpc_no_loop.svg" alt="">

## Intégration d'une boucle événementielle

<img src="images/eventloop.svg" alt="boucle événementielle">

## Deadlock version 2

<img src="images/deadlock_double_rpc.svg" alt="">

<aside class=notes>
    + impossible à régler sans concepts comme des futures et promesses
    + vivre avec, éviter de faire des IPC dans des handlers d'IPC
</aside>

##

<img src="images/sandboxing_cycle.png" alt="Sandbox cycle XKCD" width="60%">

<aside class=notes>
    + Ressemble beaucoup au XKCD
</aside>

## Objets proxy

- un identifiant
- `proxy_SendMsgReply(proxy, msg, &cookie)`

<img src="images/proxy.svg" alt="Création de proxy">

<aside class=notes>
- nouvel objet proxy par downcasting et aggrégation
</aside>


## Description de l'API

    /* Début du processus */
    sandbox = vlc_sandbox_Init(&(const struct vlc_sandbox_cfg) {
        /* parameters and policy */
    });
    
    vlc_sandbox_Start(sandbox);

<aside class=notes>
</aside>

## Démarrage des processus

    /* vlc_sandbox_Init */
    const char psz_zygote[] = "--sandbox-zygote=";
    const char psz_worker[] = "--sandbox-worker=";
    for(int i=0; i< cfg->argc; ++i)
    {
        if(!strncmp(cfg->argv[i], psz_zygote, strlen(psz_zygote)))
        {
            // it's a zygote
        }
        else if(!strncmp( cfg->argv[i], psz_worker, strlen(psz_worker)))
        {
            // it's a worker
        }
    }

## Architecture du projet

<aside class=notes>
- On a fait la partie correspondant à la mise en place du cadre de sandboxing
- Il faut revenir à VLC
</aside>

## Méthode avec les modules de VLC

- Pattern proxy
- Générer de faux modules se comportant comme les vrais à IPC près

## Méthode avec les objets de libvlccore

- Pattern strategy sur l'architecture de VLC
- Implémenter le pattern proxy

## Protocole de communication

    ------------------------------------------------------------
    | ID d'étage | ID de requête | ID de RPC | Paramètres  RPC |
    ------------------------------------------------------------

+ À qui envoyer ?
+ Comment répondre ?
+ Que faire ?

## Passage de ressources entre processus

    block_t *block = block_Alloc(size);

+ Très peu flexible
+ Devrait être amené à changer pour Windows

## Passage de ressources entre processus

<img src="images/memoire.svg" alt="producteur-consommateur en mémoire partagée" width="100%">

<aside class=notes>
    Buffer multiplexé pour l'écriture de blocs
</aside>

## Passage de ressources sous Linux

- On utilise `memfd_create` dans `block_Alloc`
- Utilisation totalement transparente

Mais plus coûteux que le modèle précédent

## Limitations du travail actuel sous Windows

## Gestion des ressources sous Windows

    BOOL WINAPI DuplicateHandle(
      _In_  HANDLE   hSourceProcessHandle,
      _In_  HANDLE   hSourceHandle,
      _In_  HANDLE   hTargetProcessHandle,
      _Out_ LPHANDLE lpTargetHandle,
      _In_  DWORD    dwDesiredAccess,
      _In_  BOOL     bInheritHandle,
      _In_  DWORD    dwOptions
    );

`SourceProcess` et `TargetProcess` doivent avoir `PROCESS_DUP_HANDLE`

## Gestion des droits sous Windows : Jobs

- Gestion des limitations de ressources dans les processus
- `JOB_OBJECT_ULIMIT_HANDLES`
- `UserHandleGrantAccess`

Malheureusement...

## Gestion des droits sous Windows : Jobs

- Un user handle est un objet de l'interface, pas un objet système
- Les jobs ne sont pas une fonctionnalité de sécurité

On peut faire le parallèle entre les Jobs et cgroups, avec un esprit Windows (i.e. GUI)

<aside class=notes>
</aside>

## Gestion des droits sous Windows : ACL

+ PACL, DACL, ACE, SecurityDescriptor, Tokens...

##

<img src="images/dacl.svg" alt="Construction avec des ACL">

# Conclusion

+ pattern reproductible
+ difficultés à déboguer
+ différences de paradigmes

# Questions