> For the complete documentation index, see [llms.txt](https://docs.devolutions.net/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.devolutions.net/powershell-universal/fr/securite/forms-authentication.md).

# Authentification par formulaire

{% hint style="warning" %}
Le script d'authentification par formulaire est appelé uniquement lorsque les utilisateurs se connectent via la page de connexion. Si vous utilisez toute autre méthode d'authentification, ce script n'est pas appelé. Les scripts de stratégie de rôle sont appelés pour tous les types d'authentification.
{% endhint %}

Par défaut, le script d'authentification par formulaire est configuré pour accepter l'utilisateur Admin avec n'importe quel mot de passe. Vous pouvez configurer cette stratégie d'authentification pour interagir avec n'importe quel système de votre choix. Le script recevra un objet `PSCredential` contenant le nom d'utilisateur et le mot de passe saisis par l'utilisateur sur la page de connexion.

{% hint style="info" %}
Les paramètres d'authentification sont également stockés dans `authentication.ps1`
{% endhint %}

Pour mettre à jour l'authentification par formulaire, vous pouvez cliquer sur ***Paramètres*** > ***Sécurité***, puis cliquer sur le bouton Modifier le code pour l'authentification par formulaire.

Vous pouvez mettre à jour le script PowerShell dans les paramètres pour configurer la façon dont l'utilisateur est authentifié. Vous devez retourner un `New-PSUAuthenticationResult` depuis le script pour indiquer si l'utilisateur a été authentifié avec succès.

```powershell
param(
    [PSCredential]$Credential
)

#
#   You can call whatever cmdlets you like to conduct authentication here.
#   Just make sure to return the $Result with the Success property set to $true
#

if ($Credential.UserName -eq 'Admin') 
{
    New-PSUAuthenticationResult -Success -UserName 'Admin'
}
else 
{
    New-PSUAuthenticationResult -ErrorMessage 'Bad username or password'
}
```

## Définir un mot de passe

Vous pouvez vérifier le mot de passe des informations d'identification en utilisant la méthode `GetNetworkCredential()` de `PSCredential`.

```powershell
param(
    [PSCredential]$Credential
)

#
#   You can call whatever cmdlets you like to conduct authentication here.
#   Just make sure to return the $Result with the Success property set to $true
#

if ($Credential.UserName -eq 'Admin' -and $Credential.GetNetworkCredential().Password -eq 'MySuperSecretPassword') 
{
    New-PSUAuthenticationResult -Success -UserName 'Admin'
}
else 
{
    New-PSUAuthenticationResult -ErrorMessage 'Bad username or password'
}
```

## Définir des revendications

Lors de l'authentification par formulaire, vous pouvez définir des revendications qui seront disponibles dans les stratégies de rôle. Cela peut offrir un avantage en termes de performances lors de l'interaction avec des systèmes distants, car vous pouvez effectuer une seule recherche de revendication, puis évaluer les revendications localement plutôt que d'effectuer des appels supplémentaires au système distant.

Cet exemple utilise Active Directory pour rechercher l'appartenance à des groupes et les attribuer en tant que revendications qui seront disponibles dans les scripts de rôles.

```powershell
param(
    [PSCredential]$Credential
)

#
#   You can call whatever cmdlets you like to conduct authentication here.
#   Just make sure to return the $Result with the Success property set to $true
#

$Result = [Security.AuthenticationResult]::new()
if ($Credential.UserName -eq 'Admin') 
{
    #Maintain the out of box admin user
    New-PSUAuthenticationResult -UserName 'Admin' -Success
}
else
{
    # Get current domain using logged-on user's credentials - this validates their credential
    $CurrentDomain = "LDAP://DC=mydemodomain,DC=com"  # Insert Your Domain Here
    $domain = New-Object System.DirectoryServices.DirectoryEntry($CurrentDomain,($Credential.UserName),$Credential.GetNetworkCredential().password)

    if ($domain.name -eq $null)
    {
        "Authentication failed for $($Credential.UserName)!" | Out-File "C:\test\adlogin.txt"
        write-host "Authentication failed - please verify your username and password."
        New-PSUAuthenticationResult -UserName $Credential.UserName
    }
    else
    {
        write-host "Successfully authenticated with domain $($domain.name)"
        "Authentication success for $($Credential.UserName)!" | Out-File "C:\test\adlogin.txt"

        New-PSUAuthenticationResult -UserName $Credential.UserName -Success -Claims { 
            Get-ADPrincipalGroupMembership $Credential.UserName | Select-Object -ExpandProperty name | ForEach-Object {
                New-PSUAuthorizationClaim -Type Role -Value $_
            }
        }
    }
}
```

Dans votre fichier `roles.ps1`, vous pourrez utiliser ces revendications pour valider l'appartenance à un groupe.

Cet exemple vérifie si l'utilisateur fait partie du groupe SOC\_Admins.

```powershell
param($User)

$Roles = $User.Claims | Where-Object Type -eq Role | Select-Object -ExpandProperty Value
$Roles -contains 'SOC_Admins'
```

## Variables

Voici les variables définies dans les scripts de sécurité.

| Nom              | Description                                      | Type      |
| ---------------- | ------------------------------------------------ | --------- |
| $Cookies         | Cookies fournis dans la requête HTTP du client.  | hashtable |
| $Headers         | En-têtes fournis dans la requête HTTP du client. | hashtable |
| $LocalIpAddress  | L'adresse IP locale de la requête.               | string    |
| $LocalPort       | Le port local de la requête.                     | string    |
| $RemoteIpAddress | L'adresse IP distante de la requête.             | string    |
| $RemotePort      | Le port distant de la requête.                   | string    |

## Authentification de base

Lors de l'appel aux points de terminaison API ou à l'API de gestion PowerShell, vous pouvez utiliser l'authentification de base pour transmettre un nom d'utilisateur et un mot de passe. Cela invoquera les scripts d'authentification et d'autorisation par formulaire pour valider la connexion. Le nom d'utilisateur et le mot de passe doivent être encodés en Base64 au format `username:password` et envoyés dans l'en-tête Authorization avec le préfixe `Basic`.

```powershell
$credentials = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes("admin:admin"))
Invoke-RestMethod $Env:UniversalUrl/api/v1/accessible -Headers @{
    Authorization = "Basic $credentials"
} 
```

Vous pouvez également utiliser le paramètre intégré -Credential sur Invoke-RestMethod pour éviter d'avoir à encoder vous-même les informations d'identification de base. Le `$AdminCredential` ci-dessous doit être un `PSCredential`.

```powershell
Invoke-RestMethod $Env:UniversalUrl/api/v1/accessible -Credential $AdminCredential -Authentication Basic
```

## Connexion Windows

Si vous activez la connexion native sur la méthode d'authentification par formulaire, PowerShell Universal tentera de se connecter à la machine actuelle ou au domaine en utilisant les informations d'identification spécifiées. Une fois connecté, les groupes de l'utilisateur seront collectés et transmis au système d'autorisation.

Vous pouvez configurer un domaine non défini par défaut en spécifiant le domaine de connexion natif. Si vous ne spécifiez pas ce domaine, le domaine de la machine par défaut ou le domaine spécifié par l'utilisateur sera utilisé.

## Journal en direct

Vous pouvez utiliser la vue du journal en direct sur la page d'authentification pour afficher des informations sur l'exécution du script. La vue du journal en direct affichera les flux PowerShell.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.devolutions.net/powershell-universal/fr/securite/forms-authentication.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.