> For the complete documentation index, see [llms.txt](https://docs.keeper.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.keeper.io/user-guides/pl/import-records-1/import-from-cyberark-pacli.md).

# Import z narzędzia CyberArk PACLI

Import kont z sejfów CyberArk za pomocą programu Microsoft PowerShell i narzędzia CyberArk PACLI.

<figure><img src="https://914511346-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F-LSGVtOTYUIkVBoYtFvK%2Fuploads%2Fp1rub66SO3Rvd4Fod9Hh%2FImport-Keeper-Cyberark.jpg?alt=media&#x26;token=2dd2db77-c695-4c77-bcda-68974a31bdf0" alt=""><figcaption></figcaption></figure>

CyberArk udostępnia interfejs wiersza polecenia PACLI, który komunikuje się bezpośrednio z serwerem CyberArk Vault. Narzędzie działa na „plikach” przechowywanych w „sejfach” (ang. *safes*) na serwerze Vault i może eksportować dane *kont* CyberArk. Klienci CyberArk, takie jak *PrivateArk* i *Password Vault Web Access (PVWA)*, zapisują te dane jako *pliki* w sejfach.

Poniższa instrukcja opiera się na skrypcie PowerShell, który za pomocą narzędzia PACLI eksportuje wszystkie pliki pasujące do wzorca. Przy domyślnym wzorcu „\*” skrypt eksportuje wszystkie pliki z sejfu. Dla każdego z nich pobiera nazwę użytkownika (Username), adres (Address) i hasło, ale w razie potrzeby można skonfigurować pobieranie innych pól. Skrypt zwraca wyeksportowane pliki jako obiekty, dlatego do przekształcenia ich w format CSV (wartości rozdzielone przecinkami), który można zaimportować do aplikacji Keeper, służy polecenie ConvertTo-CSV.

## Wymagania wstępne

Do uruchomienia poniższego skryptu potrzebne są trzy zewnętrzne składniki:

1. CyberArk PACLI
2. Plik konfiguracyjny Vault.ini
3. Plik poświadczeń User.ini

### CyberArk PACLI

Narzędzie PACLI można pobrać z witryny CyberArk Marketplace. Jest to archiwum zip zawierające plik binarny `PACLI.exe` i kilka plików pomocniczych. Skrypt oczekuje ścieżki do *folderu*, w którym znajduje się plik `PACLI.exe`.

### Vault.ini

Plik vault.ini zawiera parametry, których PACLI potrzebuje, aby znaleźć serwer Vault i zalogować się do niego. Przykład:

```ini
VAULT=CAMainVault
ADDRESS=10.11.12.13
PREAUTHSECUREDSESSION=YES
TRUSTSSC=YES
```

Parametr VAULT zwykle można pozostawić z wartością „CAMainVault”.

Parametr ADDRESS to nazwa hosta lub adres IP serwera CyberArk Vault.

Ustawienia PREAUTHSECUREDSESSION i TRUSTSSC są wymagane, gdy użytkownik logujący się jest uwierzytelniany przez LDAP (Active Directory) lub RADIUS. W pozostałych przypadkach można je pominąć.

### User.ini

Plik User.ini ma format INI, ale generuje się go za pomocą narzędzia `CreateCredFile.exe`, które CyberArk dołącza do niektórych swoich składników. Przykład generowania pliku user.ini dla użytkownika *Myuser* w domenie Active Directory *CORP*:

```powershell
CreateCredFile.exe User.ini Password /Username Myuser /Password "MyPassw0rd!" /ExternalAuth /OSUsername CORP\Myusername
```

Najnowsza wersja archiwum zip z PACLI zawiera to narzędzie. Po uruchomieniu go z parametrem `/?` zobaczysz opis pozostałych opcji, przydatnych w innych scenariuszach uwierzytelniania.

## Eksport

Wklej poniższy kod do pliku z rozszerzeniem *.ps1*, na przykład *Export-CyberArkSafeFiles.ps1*.

```powershell
<#
.SYNOPSIS
Exports 'files', i.e., CyberArk Account passwords from a CyberArk Safe using PACLI.

.DESCRIPTION
Uses CyberArk's PACLI command to export files from a CyberArk Safe.
It retrieves files, their categories, and contents and exports an object for each.
It uses filepattern=* to get all files in the safe by default.
The default categories are 'Address' and 'UserName'.
#>
param (
    # The name of the 'Vault' in CyberArk, e.g., 'CAMainVault'
    [Parameter(Mandatory = $true)][string]$VaultName,
    # The name of the 'Safe' in CyberArk
    [Parameter(Mandatory = $true)][ValidateNotNullOrEmpty()][string]$SafeName,
    # The CyberArk log on user (must match credentials in the User.ini)
    [Parameter(Mandatory = $true)][ValidateNotNullOrEmpty()][string]$Username,
    # The path to the PACLI directory containing PACLI.exe
    [Parameter(Mandatory = $true)]
    [ValidateScript({ Test-Path -PathType Leaf (Join-Path $_ 'PACLI.exe') })]
    [string]$PACLIPath,
    # Arguments `findfiles` uses to generate the list of files to export
    [string[]]$FindFilesArguments = 'filepattern=*',
    # The categories to export from the files
    [Parameter()][string[]]$Categories = @('Address', 'UserName'),
    # A CyberArk Vault.ini file
    [Parameter()][ValidateScript({ Test-Path $_ -PathType Leaf })]
    [string]$VaultIniPath = 'Vault.ini',
    # A CyberArk User.ini (or .cred) file as generated by CreateCredFile.exe
    [Parameter()][ValidateScript({ Test-Path $_ -PathType Leaf })]
    [string]$UserIniPath = 'User.ini',
    # The folder in the safe to export files from--most use 'Root'
    [string]$FolderName = 'Root',
    # The session ID to use for the underlying PACLI commands
    [Parameter()][ValidateNotNullOrEmpty()][string]$SessionId,
    # ErrorAction for retrievefile errors
    [Parameter()][ValidateSet('Stop', 'Continue', 'SilentlyContinue')]
    [string]$PACLIErrorAction = 'Continue'
)

$PACLI = Join-Path $PACLIPath 'PACLI.exe' -Resolve

function Invoke-PACLI {
    param (
        [Parameter(Mandatory = $True)][string]$Command,
        [Parameter(ValueFromRemainingArguments)][string[]]$Arguments
    )
    $Executable = ".\{0}" -f (Split-Path -Leaf $PACLI)
    $CommandLine = "$Executable $Command $($Arguments -join ' ')"
    try {
        Push-Location $(Split-Path -Parent $PACLI) -StackName 'PACLI'
        $Output = (& $Executable $Command $Arguments 2>$null)
        if ($LastExitCode -eq 0) {
            $Output
        }
        else {
            switch ($PACLIErrorAction) {
                'Continue' {
                    Write-Error "'$CommandLine' exited with code $LastExitCode"
                }
                'Stop' { throw "'$CommandLine' exited with code $LastExitCode" }
            }
        }
    }
    finally {
        Pop-Location -StackName 'PACLI'
    }
}

Invoke-PACLI init

$PACLIDefaults = "vault=$VaultName", "user=$Username", "safe=$SafeName", 
"folder=$FolderName"
if ($SessionId) {
    $PACLIDefaults += "sessionId=$SessionId"
}
Invoke-PACLI default @PACLIDefaults
Invoke-PACLI definefromfile vault=$VaultName parmfile=(Resolve-Path $VaultIniPath) |
Out-Null
Invoke-PACLI logon logonfile=(Resolve-Path $UserIniPath) | Out-Null
Invoke-PACLI opensafe | Out-Null

try {
    # Create a temporary file to store the file contents during processing
    $tempFile = [IO.Path]::GetTempFileName()
    # Split the tempFile path into the folder and the filename for 'retrievefile'
    $localFolder = Split-Path $tempFile
    $localFile = Split-Path -Leaf $tempFile

    # Get the list of files in the safe
    Invoke-PACLI findfiles $FindFilesArguments 'output(name)' |
    Where-Object { $_.Trim() -ne '' } |
    ForEach-Object {
        $file = @{ Name = $_ }
        # Retrieve the file and store the contents (the password) in the file object
        Invoke-PACLI retrievefile file=$_ localfolder=$localFolder localfile=$localFile
        if ($LastExitCode -ne 0) { return }
        $file.Password = (Get-Content $tempFile).TrimEnd([Char]0) # Can be null-padded
        # Get the list of categories for the file as a quoted CSV string
        Invoke-PACLI listfilecategories file=$_ 'output(all,enclose)' |
        ForEach-Object {
            # Get the category name and value and strip the quotes
            $category = ($_ -split ',' | ForEach-Object { $_.Trim('"') })[0..1]
            # Add the category to the file object if it is on the list
            if ($category[0] -in $Categories) {
                $file[$category[0]] = $category[1]
            }
        }
        [PSCustomObject]$file
    }
}
finally {
    Remove-Item -Path $tempFile -Force
}

Invoke-PACLI closesafe vault=$VaultName user=$Username safe=$SafeName | Out-Null
Invoke-PACLI logoff vault=$VaultName user=$Username | Out-Null
Invoke-PACLI term | Out-Null
```

Wyodrębnij archiwum PACLI.zip do folderu ze skryptem lub do jego podfolderu.

Otwórz program PowerShell i przejdź do folderu ze skryptem.

Uruchom skrypt i przekaż jego wynik potokiem do polecenia [Export-CSV](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/export-csv) (po angielsku):

```powershell
.\Export-CyberArkSafeFiles.ps1 CAMainVault MySafe Myuser .\PACLI-Rls-v11.5.3 |
Export-CSV Records.csv -Delimiter "`t" -Encoding utf8 -NoHeader -UseQuotes Never
```

Aby aplikacja Keeper poprawnie zaimportowała dane, użyj znaków tabulacji zamiast przecinków i kodowania UTF-8 oraz pomiń nagłówek i cudzysłowy wokół danych.

### Przekształcanie danych

Za pomocą programu PowerShell można przekształcić dane nie tylko do formatu CSV. Ten bardziej zaawansowany przykład tworzy pole „login” z połączenia pól Username i Address i używa go również jako pola „title”.

```powershell
.\Export-CyberArkSafeFiles.ps1 CAMainVault MySafe Myuser .\PACLI-Rls-v11.5.3 |
Select-Object @{l='Folder';e={$_.Name -replace "-$($_.Address)-$($_.Username)", '' }},
 @{l='Login';e={'{0}@{1}' -f $_.Username, $_.Address}}, Password |
Select-Object Folder, @{l='Title';e={$_.Login}}, Login, Password |
Export-Csv Records.csv -Delimiter "`t" -Encoding utf8 -NoHeader -UseQuotes Never
```

## Import

Postępuj zgodnie z instrukcją [Import z pliku tekstowego (.csv, .xls, .tsv)](https://docs.keeper.io/user-guides/pl/import-records-1/import-a-.csv-file.md).


---

# 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 by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.keeper.io/user-guides/pl/import-records-1/import-from-cyberark-pacli.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
