LG

Outils pour utilisateurs

Outils du site

Piste :
lib:rlbox

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentesRévision précédente
lib:rlbox [2021/07/13 23:39] – Ajout du diaporama rootlib:rlbox [2021/07/14 17:05] (Version actuelle) – Ajout de "Fonction renvoyant un char* alloué" root
Ligne 1: Ligne 1:
 Librairie SandBox développé par Firefox. 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://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}}
Ligne 18: Ligne 20:
     * 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 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.     * 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>
lib/rlbox.1626212349.txt.gz · Dernière modification : de root