> 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 formulaires

Personnalisez le script d'authentification par formulaires dans PowerShell Universal pour valider les identifiants, définir les revendications et prendre en charge l'authentification Basic et la conne

{% hint style="warning" %}
Le script d'authentification par formulaire est appelé uniquement lorsque les utilisateurs se connectent par la page de connexion. Si vous utilisez une 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 et n'importe quel mot de passe. Vous pouvez configurer cette stratégie d'authentification pour qu'elle interagisse avec le système de votre choix. Le script recevra un objet `PSCredential` qui contient le nom d'utilisateur et le mot de passe saisis par l'utilisateur à la page de connexion.

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

Pour mettre à jour l'authentification par formulaires, allez à **Secure > Authentication**, puis cliquez sur le bouton Edit Code pour l'authentification par formulaires.

Vous pouvez mettre à jour le script PowerShell qui se trouve dans les paramètres pour configurer la façon dont l'utilisateur est authentifié. Vous devrez retourner un `New-PSUAuthenticationResult` à partir du 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 de l'identifiant 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

Pendant l'authentification par formulaire, vous pouvez définir des revendications qui seront disponibles dans les stratégies de rôle. Cela peut offrir un gain de performance lors des interactions avec des systèmes distants, puisque vous pouvez effectuer une seule recherche de revendications, puis évaluer les revendications localement plutôt que d'avoir à faire des appels additionnels au système distant.

Cet exemple utilise Active Directory pour rechercher l'appartenance aux groupes et l'assigner comme 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 aux groupes.

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         | Témoins 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 Basic

Lorsque vous appelez des terminaux d'API ou l'API PowerShell Management, vous pouvez utiliser l'authentification Basic 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 identifiants Basic. 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 Native Login sur la méthode d'authentification par formulaires, PowerShell Universal tentera de se connecter à la machine ou au domaine actuel à l'aide des identifiants spécifiés. Une fois connecté, les groupes de l'utilisateur seront collectés puis fournis au système d'autorisation.

Vous pouvez configurer un domaine autre que celui par défaut en spécifiant le domaine de connexion native. 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 consulter des renseignements 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.