LG

Cette page est en lecture seule. Vous pouvez afficher le texte source, mais ne pourrez pas le modifier. Contactez votre administrateur si vous pensez qu'il s'agit d'une erreur.
Librairie SandBox développé par Firefox.

====Théorie====

[[https://plsyssec.github.io/rlbox_sandboxing_api/sphinx/|Doc]] {{ :lib:rlbox:overview_rlbox_sandboxing_api_documentation_2020-08-08_13_38_15_.html |Archive du 31/03/202 le 08/08/2020}}

[[https://github.com/PLSysSec/rlbox_sandboxing_api|Code source]] {{ :lib:rlbox:rlbox_sandboxing_api-master-2020-07-17.zip |Archive du 17/07/2020 le 08/08/2020}}

[[https://arxiv.org/abs/2003.00572|Théorie]] {{ :lib:rlbox:2003.00572.pdf |Archive du 10/03/2020 le 08/08/2020}}

[[https://www.usenix.org/system/files/sec20_slides_narayan.pdf|Diaporama]] {{ :lib:rlbox:sec20_slides_narayan.pdf |Archive du 22/07/2020 le 13/07/2021}}

De ce que j'ai compris, cela force la réalisation d'une copie dans le tas de la donnée à transmettre à la librairie.

Cela est sécuritaire car :
  * même si la donnée est déclarée en ''const'' dans la librairie, elle vient peut-être d'une donnée où la mémoire est accessible en écriture. 
  * Le fait de passer la donnée directement peut permettre de déterminer l'aléa de l%%'%%''ASLR'' (Address space layout randomization) ou de déduire le pointeur vers la table virtuelle.
  * en cas de buffer overflow, on ne risque pas d'écrire sur la pile.
  * Lorsque la fonction renvoie sa valeur, il y a :
    * une vérification automatique de type UBSan pour vérifier que la variable qui va héberger la valeur est assez grande pour la valeur renvoyée.
    * Une vérification manuelle peut être ajoutée. La fonction doit alors être écrite par le développeur.

====Exemples====

===Fonction renvoyant un char* alloué===

La libération de la mémoire du texte renvoyé est à notre charge.

<code cpp>
#define RLBOX_SINGLE_THREADED_INVOCATIONS
#define RLBOX_USE_STATIC_CALLS() rlbox_noop_sandbox_lookup_symbol

#include <iostream>
#include <memory>
#include <mutex>
#include <optional>
#include <rlbox.hpp>
#include <rlbox_noop_sandbox.hpp>
#include <string_view>

#include <simdjson.h>

// Classe libérant la mémoire quand la donnée n'est plus utilisée.
template <typename T>
class AutoFree
{
 public:
  AutoFree(rlbox::tainted<T, rlbox::rlbox_noop_sandbox> taint) : _taint(taint)
  {
  }
  ~AutoFree() { free(_taint.UNSAFE_unverified()); }
  rlbox::tainted<T, rlbox::rlbox_noop_sandbox>& get() { return _taint; }

 private:
  rlbox::tainted<T, rlbox::rlbox_noop_sandbox> _taint;
};

// Fonction risquée
char* unsecure_function(char* data, int nb)
{
  char* retval = static_cast<char*>(malloc(sizeof(char) * (strlen(data) + 1)));
  strcpy(retval, data);
  return retval;
}

// Fonction sécurisée
std::string
    secure_function(rlbox::rlbox_sandbox<rlbox::rlbox_noop_sandbox>& sandbox,
                    const std::string& unsafe_data)
{
  size_t helloSize = unsafe_data.length() + 1;

  auto taintedStr = sandbox.malloc_in_sandbox<char>(helloSize);

  // La librairie n'ayant pas la possibilité d'écrire, on le fait à sa place.
  std::strncpy(
      taintedStr.unverified_safe_pointer_because(helloSize, "writing only"),
      unsafe_data.c_str(), helloSize);

  // On récupère la valeur de retour de façon sécurisée.
  AutoFree<char*> retvalTainted(
      sandbox.invoke_sandbox_function(unsecure_function, taintedStr, 3));

  // On récupère la valeur de retour après vérification.
  auto retval = retvalTainted.get().copy_and_verify_string(
      [](std::unique_ptr<char[]> ret) -> std::optional<std::string>
      {
        size_t len = strlen(ret.get());
        if (simdjson::validate_utf8(ret.get(), len))
          return std::optional<std::string>(std::string{ret.get(), len});
        else
          return std::nullopt;
      });

  sandbox.free_in_sandbox(taintedStr);

  return retval.value_or("nullptr");
}

int main()
{
  rlbox::rlbox_sandbox<rlbox::rlbox_noop_sandbox> sandbox;
  sandbox.create_sandbox();

  std::cout << secure_function(sandbox, std::string{"\xc3\xb1"}) << std::endl;
  std::cout << secure_function(sandbox, std::string{"\xc3\x28"}) << std::endl;

  sandbox.destroy_sandbox();
}
</code>