@cccsaurora/howler-ui 2.12.0-dev.38 → 2.12.0-dev.40

package/components/routes/help/markdown/en/notebook.md

@@ -0,0 +1,157 @@
+# Notebook Integration
+
+Howler provides the option to add notebooks to analytics to aid in triaging hits and alerts. It allows users to quickly spin up a notebook within a jupyter environment with either analytic and/or hit information.
+
+Howler will look for variables to replace within the first code cell of a notebook, giving the flexibility of providing context within the first cells using markdown.
+
+Here an example of how howler will replace the variables within your notebook:
+
+```notebook tab="Template"
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "id": "fe6f810f-2459-4ad7-92ac-1e925ce892d4",
+      "outputs": [],
+      "source": [
+        "howlerHitId = \"{{hit.howler.id}}\"\n",
+        "howlerAnalyticId = \"{{analytic.analytic_id}}\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "586470ef-c8e6-45b1-bd17-17ccd083eef1",
+      "outputs": [],
+      "source": [
+        "from howler_client import get_client\n\n",
+        "howler = get_client(\"$CURRENT_URL\")\n",
+        "hit = howler.hit(howlerHitId)"
+      ]
+    }
+  ],
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
+```
+
+```notebook tab="Processed"
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "id": "fe6f810f-2459-4ad7-92ac-1e925ce892d4",
+      "outputs": [],
+      "source": [
+        "howlerHitId = \"7dxHCat0Y2Sj48qyU7ZkVV\"\n",
+        "howlerAnalyticId = \"2SXKl6Cq4rOxWLps2SFHyB\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "586470ef-c8e6-45b1-bd17-17ccd083eef1",
+      "outputs": [],
+      "source": [
+        "from howler_client import get_client\n\n",
+        "howler = get_client(\"$CURRENT_URL\")\n",
+        "hit = howler.hit(howlerHitId)"
+      ]
+    }
+  ],
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
+```
+
+or with some markdown in the first cell:
+
+```notebook tab="Template"
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "e17cbaa8-9849-462f-9bd2-bf30943f76b3",
+      "source": [
+        "### Example Notebook"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "fe6f810f-2459-4ad7-92ac-1e925ce892d4",
+      "outputs": [],
+      "source": [
+        "howlerHitId = \"{{hit.howler.id}}\"\n",
+        "howlerAnalyticId = \"{{analytic.analytic_id}}\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "586470ef-c8e6-45b1-bd17-17ccd083eef1",
+      "outputs": [],
+      "source": [
+        "from howler_client import get_client\n\n",
+        "howler = get_client(\"$CURRENT_URL\")\n",
+        "hit = howler.hit(howlerHitId)"
+      ]
+    }
+  ],
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
+```
+
+```notebook tab="Processed"
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "e17cbaa8-9849-462f-9bd2-bf30943f76b3",
+      "source": [
+        "### Example Notebook"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "fe6f810f-2459-4ad7-92ac-1e925ce892d4",
+      "outputs": [],
+      "source": [
+        "howlerHitId = \"7dxHCat0Y2Sj48qyU7ZkVV\"\n",
+        "howlerAnalyticId = \"2SXKl6Cq4rOxWLps2SFHyB\""
+      ]
+    },
+    {
+      "cell_type": "code",
+      "id": "586470ef-c8e6-45b1-bd17-17ccd083eef1",
+      "outputs": [],
+      "source": [
+        "from howler_client import get_client\n\n",
+        "howler = get_client(\"$CURRENT_URL\")\n",
+        "hit = howler.hit(howlerHitId)"
+      ]
+    }
+  ],
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
+```
+
+Currently, howler will only try to replace hit and analytic objects.
+
+# Requirements for the notebook integration to work
+
+- A working NBGallery setup is required.
+  - If the user can send a notebook from nbgallery to their jupyter environment, it will also work using the open in jupyhub button on Howler.
+- Just like with NBGallery, the user needs to make sure their Jupyter Environment is currently running, otherwise Howler will fail to open the notebook.
+
+Howler will append the id of the Hit/Alert when sending a notebook to Jupyter, making it easy to track for analysis. It is possible to open a notebook from within an analytic page, in this case, no hit id will be appended to the file name of the notebook and Howler won't be able to replace hit informations in the templated notebook since no hit was provided.
+
+# Adding a notebook to an analytic
+
+To add a notebook to an analytic, it's only necessary to provide the NBGallery link of the notebook. The link shoud look like this. The notebook shouldn't be private, otherwise, only the user that uploaded it will be able to use it on Howler.
+
+```
+$NBGALLERY_URL/notebooks/5-example
+```
+
+```alert
+It is advised to clear any outputs from a notebook before adding it on NBGallery to avoid leaking sensitive data.
+```

package/components/routes/help/markdown/en/retention.md

@@ -0,0 +1,15 @@
+# Retention in Howler
+
+In order to comply with organizational policies, Howler is configured to purge stale alerts after a specific amount of time. On this instance, that duration is `duration`.
+
+Howler calculates whether it is time for the removal of an alert by the `event.created` date - once this surpasses the confgured deadline, a nightly automated job will remove the alert.
+
+In order to communicate this to the user, see the example alert below:
+
+`alert`
+
+In the top right, hovering over the timestamp will outline how long users have before the alert is removed. In order to ensure compliance with policy, ensure that `event.created` matches the date the underlying data was collected, allowing howler to ensure data is purged in time.
+
+```alert
+This will soon change - there will be a dedicated field to set that will override this approach.
+```

package/components/routes/help/markdown/en/schema.md

@@ -0,0 +1,21 @@
+# Hit Schema
+
+A howler hit can contain a large number of unique fields, each with a particular definition, in order to make hits across analytics mutually intelligible. Below is a table containing all the given hit fields, as well as their type and a short description of what they are used for. While the vast majority of the fields are based on the Elastic Common Schema (see [this guide on ECS](https://www.elastic.co/guide/en/ecs/8.5/index.html) for documentation), there are also custom fields depending on the plugins enabled in Howler.
+
+## Howler Fields - Best Practices
+
+In order to allow for some consistency between various analytics, there are a number of fields with recommended (but not required) styles. These include:
+
+- `howler.analytic`: Denotes the overarching analytic that generated the hit. For example, if the name of your analytic is Bad Guy Finder, you can set this field to Bad Guy Finder. Examples of use:
+
+  - Bad Guy Finder (correct)
+  - BadGuyFinder (acceptable, but spaces are preferred)
+  - bad.guy.finder (incorrect, don't use periods)
+  - bad_guy_finder (incorrect, don't use underscores)
+  - in general, you can use [this regex](https://regexr.com/7ikco) to validate your proposed analytic name
+
+- `howler.detection`: Denotes the specific algorithm or portion of the analytic that generated the hit. For example, if your analytic has three ways of detecting hits that should be looked at (Impossible Travel, Incorrect Login Information, XSS Attack Detection), then the manner in which the hit you're creating was detected should be set. Examples of use:
+  - Impossible Travel (correct)
+  - ImpossibleTravel (acceptable, but spaces are preferred)
+  - impossible.travel (incorrect, don't use periods)
+  - impossible_travel (incorrect, don't use underscores)

package/components/routes/help/markdown/en/templates.md

@@ -0,0 +1,23 @@
+# Howler Templates
+
+Howler is, fundamentally, an application that allows analysts to triage hits and alerts. In order to make sure analysts can do this as efficiently as possible, we want to have the ability to present relevant data for a given alert to analysts in an easy, understandable way.
+
+To this end, Howler allows analysts and detection engineers to create **templates**, which allow various analytics and their detections to present fields and data relevant to triaging alerts generated by that analytic/detection. For example, let's consider two different alerts, by two different detections:
+
+```json
+$ALERT_1
+```
+
+```json
+$ALERT_2
+```
+
+Note that while both share some similar fields, they also differ. We want each of these alert cards to present different data - for that, we can use templates. This allows us to show both hits in the same list, but with differing fields displayed:
+
+===SPLIT===
+
+As we can see, by specifying a template for each of the detections, different data will be presented to the analyst. To do so, you can use the template creator [here]($CURRENT_URL/templates/view?type=personal).
+
+```alert
+Note that you must have ingested some hits for the given analytic/detection pair for it to show as an option in the template creation UI!
+```

package/components/routes/help/markdown/en/views.md

@@ -0,0 +1,11 @@
+# Views
+
+Views are a feature in Howler that allows users to create custom, default queries through which they can organize and triage hits. In this document, we will outline how to create and interact with views.
+
+## Using a View
+
+You can use views by navigating to the view manager under [Manage > Views](/views). Clicking on any view will open it in the search page. Here, you can also use the `search` icon to open the view in the search page. You can also edit views that belong to you, and mark them as favourites. This will show them in the `t(route.views.saved)` dropdown in the sidebar. In the top right, you can also choose your "`t(route.views.manager.default)`", that will be selected by default when opening the alerts page.
+
+## Creating Views
+
+In order to create a view, you can use the create view page, located [here](/views/create). This page allows you to modifer your view, specify a `t(hit.search.sort.fields)` and `t(hit.search.span)`, and save the view with a particular name. You can mark a view as global or personal, depending on who you want to be able to see and use the view.

package/components/routes/help/markdown/fr/actionIntroduction.md

@@ -0,0 +1,33 @@
+# Utilisation des actions dans Howler
+
+Les actions sont une fonctionnalité de Howler qui permet aux utilisateurs d'effectuer des tâches particulières sur un grand nombre de hits, en automatisant l'exécution d'une tâche sur chaque hit. Il y a actuellement `action_count` opérations supportées dans Howler :
+
+`action_list`
+
+Toutes ces opérations peuvent être combinées ensemble dans des actions uniques - c'est-à-dire que les opérations sont essentiellement les blocs de construction des actions dans Howler. Chaque opération ne peut apparaître qu'une seule fois par action, et toutes les opérations sont configurées à travers une interface unifiée. Dans ce document, nous allons parcourir les étapes nécessaires à l'exécution et à la sauvegarde d'une action.
+
+## Configuration d'une action
+
+Pour commencer à configurer votre action, décidez s'il s'agit d'une action unique ou d'une action sauvegardée que vous souhaitez exécuter plusieurs fois. Si vous voulez l'exécuter une fois, utilisez l'entrée `t(route.actions.change)` dans la barre latérale, alors qu'une action sauvegardée est mieux configurée sous `t(route.actions.manager)` en appuyant sur "`t(route.actions.create)`".
+
+La première étape de toute action sera de concevoir une requête sur laquelle vous voulez que cette action s'exécute. La boîte de recherche en haut de l'écran accepte n'importe quelle requête lucene - le même format que pour la recherche d'occurrences.
+
+`tui_phrase`
+
+Une fois que vous êtes satisfait des occurrences qui seront incluses dans cette requête, vous pouvez commencer à ajouter des opérations. Vous pouvez le faire en sélectionnant l'opération que vous voulez ajouter dans la liste déroulante:
+
+`operation_select`
+
+Une fois que vous avez sélectionné l'opération que vous souhaitez ajouter, une liste de paramètres à remplir vous est proposée. Voici un exemple d'ajout d'une étiquette.
+
+`operation_configuration`
+
+Une fois que l'opération est validée avec succès, vous pouvez répéter ce processus avec l'opération suivante. Une fois que vous avez ajouté toutes les opérations qui vous intéressent, vous pouvez exécuter ou sauvegarder l'action en utilisant le bouton situé sous la barre de recherche. Vous obtiendrez ainsi un rapport sur les étapes franchies.
+
+`report`
+
+Il peut arriver que des actions génèrent une erreur, soit lors de la validation, soit lors de l'exécution. Dans ce cas, une alerte d'erreur sera affichée, vous aidant à résoudre le problème.
+
+## Automatiser une action
+
+Pour automatiser une action, ouvrez une action sauvegardée. Les options disponibles pour l'automatisation (`automation_options`) apparaîtront sous forme de cases à cocher. En cochant la case, vous vous assurez que l'action s'exécutera ensuite - aucune autre opération n'est nécessaire.

package/components/routes/help/markdown/fr/authentication.md

@@ -0,0 +1,259 @@
+<!-- docs/ingestion/authentication.fr.md -->
+
+# Authentification de Howler
+
+L'API de Howler prend en charge un certain nombre d'approches d'authentification lors de l'accès à l'API. Ce document présente les
+différentes approches et explique comment utiliser chacune d'entre elles.
+
+## Types d'authentification
+
+Il existe quatre méthodes d'authentification que l'on peut utiliser pour se connecter à l'API howler:
+
+1. Nom d'utilisateur et mot de passe
+2. Nom d'utilisateur et clé API
+3. Nom d'utilisateur et clé d'application (après connexion)
+4. Jeton d'accès OAuth
+
+Nous allons maintenant présenter les cas d'utilisation de chaque type d'authentification.
+
+### Authentification par nom d'utilisateur/mot de passe
+
+L'authentification par nom d'utilisateur et mot de passe est la méthode d'authentification la plus simple et la moins sûre. Il est peu probable qu'elle soit activée
+dans un environnement de production, elle permet aux utilisateurs de se connecter facilement à l'API Howler et d'effectuer des modifications en tant qu'utilisateur donné,
+sans avoir à se soucier de créer des clés API ou d'utiliser un fournisseur OAuth comme Keycloak ou Azure. Les utilisateurs peuvent se connecter
+en utilisant l'authentification par nom d'utilisateur et mot de passe de l'une des deux manières suivantes :
+
+#### Appel direct au point de terminaison requis (mot de passe)
+
+C'est de loin la méthode la plus simple. Il suffit d'ajouter un en-tête d'autorisation de base à la requête HTTP que vous souhaitez effectuer, et tout est pris en charge.
+que vous voulez faire, et tout est pris en charge:
+
+```bash
+echo -n "user:user" | base64 -w0
+# -> dXNlcjp1c2Vy
+```
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Basic dXNlcjp1c2Vy
+```
+
+#### Échange contre un jeton d'application (mot de passe)
+
+Il s'agit d'une approche un peu plus complexe, mais qui présente l'avantage de ne pas exposer le nom d'utilisateur et le mot de passe à chaque demande.
+à chaque requête. Vous pouvez utiliser le point de terminaison `v1/auth/login` pour échanger votre nom d'utilisateur et votre mot de passe contre un jeton d'application. Le jeton
+fonctionne de la même manière qu'un jeton d'accès OAuth - vous le fournissez à chaque requête ultérieure, et il vous authentifie jusqu'à ce que le jeton expire.
+jusqu'à ce que le jeton expire.
+
+```http
+POST $CURRENT_URL/api/v1/auth/login/
+Content-Type: application/json
+
+{
+  "user": "user",
+  "password": "user"
+}
+```
+
+Le résultat sera quelque chose comme:
+
+```json
+{
+  "api_error_message": "",
+  "api_response": {
+    "app_token": "user:5791a142067745c3af51d6596da7da8f86357a9fa92ad78d1ce118ea7d89d34e",
+    "provider": null,
+    "refresh_token": null
+  },
+  "api_server_version": "0.0.0.dev0",
+  "api_status_code": 200
+}
+```
+
+Utilisation de ce jeton dans un autre appel d'API:
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Bearer user:5791a142067745c3af51d6596da7da8f86357a9fa92ad78d1ce118ea7d89d34e
+```
+
+### Authentification par nom d'utilisateur/clé API
+
+L'authentification par nom d'utilisateur et clé API fonctionne en grande partie de la même manière que l'authentification par nom d'utilisateur/mot de passe du point de vue du client.
+Du côté du serveur, cependant, les clés API présentent plusieurs avantages essentiels. Tout d'abord, elles peuvent être facilement révoquées par l'utilisateur.
+Deuxièmement, leurs privilèges peuvent être limités, n'autorisant qu'un sous-ensemble de permissions.
+
+Il existe deux méthodes d'authentification, reflétant le nom d'utilisateur et le mot de passe:
+
+#### Appel direct au point de terminaison requis (clé API)
+
+Il suffit d'ajouter un en-tête d'autorisation de base contenant le nom d'utilisateur et la clé API à la requête HTTP que vous souhaitez effectuer, et
+tout est pris en charge:
+
+```bash
+# note the format is <username>:<apikeyname>:<secret>
+echo -n "user:devkey:user" | base64 -w0
+# -> dXNlcjpkZXZrZXk6dXNlcg==
+```
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Basic dXNlcjpkZXZrZXk6dXNlcg==
+```
+
+#### Échange contre un jeton d'application (clé API)
+
+Vous pouvez également utiliser le point de terminaison `v1/auth/login` pour échanger votre nom d'utilisateur et votre clé API contre un jeton d'application. Le jeton
+fonctionne de la même manière qu'un jeton d'accès OAuth - vous le fournissez à chaque demande ultérieure, et il vous authentifie jusqu'à ce que le jeton expire.
+
+```http
+POST $CURRENT_URL/api/v1/auth/login/
+Content-Type: application/json
+
+{
+  "user": "user",
+  "apikey": "devkey:user"
+}
+```
+
+Le résultat sera quelque chose comme:
+
+```json
+{
+  "api_error_message": "",
+  "api_response": {
+    "app_token": "user:f220eb76ff8404abfece8c0c2f3368c7d89618c776bedcd3a506843dc4a952e4",
+    "provider": null,
+    "refresh_token": null
+  },
+  "api_server_version": "0.0.0.dev0",
+  "api_status_code": 200
+}
+```
+
+Utilisation de ce jeton dans un autre appel d'API:
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Bearer user:f220eb76ff8404abfece8c0c2f3368c7d89618c776bedcd3a506843dc4a952e4
+```
+
+Notez que lorsque vous vous connectez à l'aide d'une clé d'api, les autorisations de la clé d'api continuent de s'appliquer. Ainsi, si vous essayez d'accéder à
+à un point d'accès qui requiert l'autorisation "write" avec une clé API qui n'a que l'autorisation "read", cela provoquera une erreur 403
+Forbidden (Interdit).
+
+### Authentification par jeton d'accès
+
+En plus des méthodes d'authentification fournies en interne par Howler, vous pouvez également vous authentifier avec un fournisseur OAuth externe comme Azure ou Keycloak.
+Pour ce faire, vous devez obtenir un jeton d'accès auprès de l'un de ces fournisseurs.
+Pour obtenir un jeton d'accès, il y a généralement deux flux - On-Behalf-Of, ou le flux de connexion de l'utilisateur (voir [ici](https://www.rfc-editor.org/rfc/rfc6749#section-4.1) pour un récapitulatif
+de cela). Dans le cas de Howler, le point de terminaison `v1/auth/login` est utilisé pour les étapes D & E du flux de connexion de l'utilisateur, et
+il renvoie ce qui suit:
+
+```json
+{
+  "api_response": {
+    "app_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyIn0",
+    "provider": "keycloak",
+    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJyZWZyZXNoIn0"
+  }
+}
+```
+
+Dans ce cas, le `app_token` est le Web Token JSON que l'application utilise comme jeton d'accès. De la même manière, le
+`refresh_token` est un autre JWT qui est utilisé pour rafraîchir le jeton d'accès si nécessaire. Enfin, le champ `provider` (fournisseur)
+indique à quel fournisseur correspond ce jeton d'accès.
+
+Une fois que vous avez ce jeton d'accès, vous pouvez simplement le transmettre dans l'en-tête Authorization :
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyIn0
+```
+
+Howler détectera automatiquement qu'il s'agit d'un JWT et le traitera comme tel. Si le jeton est valide, l'utilisateur sera
+authentifié.
+
+Afin de rafraîchir un jeton d'accès expiré, vous pouvez utiliser l'appel API suivant:
+
+```http
+POST $CURRENT_URL/api/v1/auth/login/
+Content-Type: application/json
+
+{
+  "oauth_provider": "keycloak",
+  "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJyZWZyZXNoIn0"
+}
+```
+
+Et vous obtiendrez quelque chose comme ceci en retour:
+
+```json
+{
+  "api_response": {
+    "app_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMiJ9",
+    "provider": "keycloak",
+    "refresh_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJyZWZyZXNodG9rZW4yIn0"
+  }
+}
+```
+
+## Impersonation
+
+Le dernier élément important du flux d'authentification est la fonctionnalité d'usurpation d'identité. Pour qu'un compte de service
+ou un autre utilisateur puisse se faire passer pour vous (c'est-à-dire créer des alertes en votre nom), Howler permet aux utilisateurs de fournir une deuxième clé API
+afin de s'authentifier en tant qu'autre utilisateur.
+
+Avant d'utiliser la clé API d'un autre utilisateur pour vous authentifier en tant que lui, il est important que la clé API que vous utilisez ait été
+marquée comme valide pour l'usurpation d'identité - vérifiez auprès de l'utilisateur qui l'a fournie. Si c'est le cas, vous pouvez l'utiliser en formulant votre requête
+comme suit:
+
+```bash
+# Your credentials
+echo -n "admin:devkey:admin" | base64 -w0
+# -> YWRtaW46ZGV2a2V5OmFkbWlu
+
+# Their credentials
+echo -n "user:impersonate_admin:user" | base64 -w0
+# -> dXNlcjppbXBlcnNvbmF0ZV9hZG1pbjp1c2Vy
+```
+
+```alert
+Toute forme d'authentification peut être utilisée par l'usurpateur, mais les clés API validées sont la seule méthode d'authentification autorisée pour la personne dont vous usurpez l'identité.
+```
+
+```http
+GET $CURRENT_URL/api/v1/user/whoami
+Authorization: Basic YWRtaW46ZGV2a2V5OmFkbWlu
+X-Impersonating: Basic dXNlcjppbXBlcnNvbmF0ZV9hZG1pbjp1c2Vy
+```
+
+Si la configuration est correcte, le résultat sera le suivant:
+
+```json
+{
+  "api_error_message": "",
+  "api_response": {
+    "avatar": null,
+    "classification": "TLP:W",
+    "email": "user@howler.cyber.gc.ca",
+    "groups": ["USERS"],
+    "is_active": true,
+    "is_admin": false,
+    "name": "User",
+    "roles": ["user"],
+    "username": "user"
+  },
+  "api_server_version": "0.0.0.dev0",
+  "api_status_code": 200
+}
+```
+
+Notez que le serveur a renvoyé cette requête comme si vous étiez `user`, PAS `admin`. Il est cependant clairement indiqué dans les logs que c'est vous qui faites la requête:
+
+```log
+22/12/05 14:15:02 INFO howler.api.security | Authenticating user for path /api/v1/user/whoami/
+22/12/05 14:15:03 WARNING howler.api.security | admin is impersonating user
+22/12/05 14:15:03 INFO howler.api.security | Logged in as user from 127.0.0.1
+22/12/05 14:15:03 INFO howler.api | GET /api/v1/user/whoami/ - 200
+```

package/components/routes/help/markdown/fr/bundles.md

@@ -0,0 +1,70 @@
+<!-- docs/ingestion/bundles.fr.md -->
+
+# Les groupes des hits Howler
+
+Les groupes des hits peuvent être utilisés pour regrouper facilement un grand nombre d'alertes similaires, ce qui permet aux analystes de les traiter comme un seul incident. Prenons l'exemple d'un ordinateur qui effectue à plusieurs reprises un appel réseau vers `baddomain.ru` - bien qu'une alerte puisse être générée pour chaque cas où cet ordinateur accède à ce domaine, il est logique que les analystes traitent toutes ces alertes comme un seul et même cas.
+
+## Création de groupes via le client Howler
+
+Il y a plusieurs façons de créer un groupe via le client Howler:
+
+```python
+from howler_client import get_client
+
+howler = get_client("https://howler.dev.analysis.cyber.gc.ca")
+
+"""Création simultanée d'un groupe howler et de hits"""
+howler.bundle.create(
+    # Le premier argument est le hit de l'offre groupée
+    {
+        "howler.analytic": "example-test",
+        "howler.score": 0
+    },
+    # Le deuxième argument est un hit ou une liste de hits à inclure dans l'offre groupée.
+    [
+        {
+            "howler.analytic": "example-test",
+            "howler.score": 0
+        },
+        {
+            "howler.analytic": "example-test",
+            "howler.score": 0
+        }
+    ]
+)
+
+"""Création d'un groupe howler à partir de hits existants"""
+howler.bundle.create(
+    {
+        "howler.analytic": "example-test",
+        "howler.score": 0,
+        "howler.hits": ["YcUsL8QsjmwwIdstieROk", "6s7MztwuSvz6tM0PgGJhvz"]
+    },
+    # Noter: Dans les prochaines versions, vous n'aurez plus besoin d'inclure cet argument.
+    []
+)
+
+
+"""Création à partir d'une carte"""
+bundle_hit = {
+    "score": 0,
+    "bundle": True
+}
+
+map = {
+    "score": ["howler.score"],
+    "bundle": ["howler.is_bundle"]
+}
+
+howler.bundle.create_from_map("example-test", bundle_hit, map, [{"score": 0}])
+```
+
+## Visualiser les groupes sur l'interface utilisateur de Howler
+
+Afin de visualiser les groupes créés sur l'interface utilisateur de Howler, vous pouvez utiliser la requête `howler.is_bundle:true`. Cela fournira une liste de groupes créés que vous pourrez consulter.
+
+En cliquant sur un groupe, vous ouvrirez une interface de recherche légèrement différente de l'interface normale. Dans ce cas, nous filtrons automatiquement les résultats de la recherche pour n'inclure que les résultats inclus dans le groupe. Pour que cela soit évident, l'en-tête représentant le groupe apparaît au-dessus de la barre de recherche.
+
+Vous pouvez continuer à filtrer les résultats en utilisant les mêmes requêtes que d'habitude et à les visualiser comme d'habitude. Lors du triage d'un groupe, son évaluation s'appliquera à tous les hits du groupe, **sauf ceux qui ont déjà été triés**. En d'autres termes, si le groupe est ouvert, tous les hits ouverts seront évalués lorsque vous l'évaluerez.
+
+Les groupes disposent également d'un onglet **Résumé** qui n'est pas disponible pour les hits ordinaires. Cet onglet vous aidera à regrouper les données relatives à tous les résultats du groupe. Il suffit d'ouvrir l'onglet et de cliquer sur "Créer un sommaire". Notez que cette opération peut prendre un certain temps, car un grand nombre de requêtes sont exécutées pour agréger les données.