# Proteger e desbloquear documentos Como as ações de segurança se encaixam e em que ordem chamá-las ao proteger ou desbloquear um documento. A segurança de um PDF são duas coisas distintas, e acertar a ordem depende de saber qual é qual. Uma **senha** criptografa o arquivo e controla quem pode *abri-lo*. As **restrições** são sinalizadores de permissão que controlam o que um leitor pode *fazer* depois que ele está aberto: imprimir, copiar, editar. Este guia coloca as cinco ações de segurança em sequência: um fluxo para proteger antes de distribuir e um fluxo para desbloquear. ## As ações de segurança | Ação | Rota | O que faz | | --- | --- | --- | | [Adicionar senha](/docs/api/add-password-to-pdf) | `add_password` | Criptografa o PDF e define a senha necessária para abri-lo. | | [Adicionar restrições](/docs/api/add-restrictions-to-pdf) | `add_restrictions` | Define os sinalizadores de permissão (impressão, cópia, edição) por trás de uma senha de proprietário; também pode definir uma senha de abertura. | | [Remover senha](/docs/api/remove-password-from-pdf) | `remove_password` | Descriptografa um PDF quando você fornece a senha atual dele. | | [Remover restrições](/docs/api/remove-restrictions-from-pdf) | `remove_restrictions` | Limpa todos os sinalizadores de permissão. | | [Remover assinaturas](/docs/api/remove-signatures-from-pdf) | `remove_signatures` | Remove as assinaturas criptográficas e as marcas de tempo. | **Senhas vs. restrições.** O `add_password` recebe uma única `password`: a senha que o leitor digita para abrir o arquivo. O `add_restrictions` recebe uma `owner_password`, que protege os sinalizadores de permissão, mais uma `user_password` opcional, que funciona como a senha de abertura. Defina a `user_password` e o documento passa a exigir senha para abrir; omita-a e qualquer pessoa poderá abri-lo, mas continuará sujeita aos sinalizadores de permissão. ## A única regra que rege a ordem **Criptografe por último.** Nenhuma outra ação consegue abrir um PDF criptografado, porque não há campo para fornecer a senha dele. Então execute primeiro todas as etapas de conteúdo e de permissão (mesclar, marca-d’água, restrições) e adicione a senha de abertura como etapa final. Para modificar um documento que já está protegido por senha, primeiro [remova a senha](/docs/api/remove-password-from-pdf), processe-o e depois proteja-o de novo. Por causa dessa regra, não empilhe `add_password` e depois `add_restrictions`: a chamada de restrições não consegue abrir o arquivo recém-criptografado. Quando você precisar **das duas coisas**, uma senha de abertura e sinalizadores de permissão, defina-as em uma única chamada a `add_restrictions`, usando `owner_password` e `user_password` juntas. ## Proteger um documento para distribuição Bloqueie um relatório para que ele exija uma senha para abrir e não possa ser impresso, copiado nem editado, tudo em uma única chamada. Faça agora qualquer mesclagem, marca-d’água ou trabalho com páginas, enquanto o documento ainda não está criptografado. Consulte [Encadear ações](/docs/api/chaining-actions). `POST /v1/add_restrictions` com uma `owner_password` (que protege as permissões), uma `user_password` (a senha de abertura) e os sinalizadores de permissão definidos como `false` para o que você quiser proibir. ```bash title="cURL" curl https://api.pdfblocks.com/v1/add_restrictions \ -H 'X-API-Key: your_api_key' \ -F file=@input.pdf \ -F owner_password='owner-secret' \ -F user_password='open-secret' \ -F allow_print=false \ -F allow_copy_content=false \ -F allow_change_content=false \ -o protected.pdf ``` ```python title="Python" # pip install requests import requests with open('input.pdf', 'rb') as file: response = requests.post( 'https://api.pdfblocks.com/v1/add_restrictions', headers={'X-API-Key': 'your_api_key'}, files={'file': file}, data={ 'owner_password': 'owner-secret', 'user_password': 'open-secret', 'allow_print': 'false', 'allow_copy_content': 'false', 'allow_change_content': 'false', }, ) response.raise_for_status() with open('protected.pdf', 'wb') as output: output.write(response.content) ``` ```javascript title="Node.js" // Node.js 18+ import { readFile, writeFile } from 'node:fs/promises'; const body = new FormData(); body.set('file', new Blob([await readFile('input.pdf')]), 'input.pdf'); body.set('owner_password', 'owner-secret'); body.set('user_password', 'open-secret'); body.set('allow_print', 'false'); body.set('allow_copy_content', 'false'); body.set('allow_change_content', 'false'); const response = await fetch('https://api.pdfblocks.com/v1/add_restrictions', { method: 'POST', headers: { 'X-API-Key': 'your_api_key' }, body, }); if (!response.ok) throw new Error(`Request failed: ${response.status}`); await writeFile('protected.pdf', Buffer.from(await response.arrayBuffer())); ``` ```php title="PHP" true, CURLOPT_HTTPHEADER => ['X-API-Key: your_api_key'], CURLOPT_POST => true, CURLOPT_POSTFIELDS => [ 'file' => new CURLFile('input.pdf', 'application/pdf'), 'owner_password' => 'owner-secret', 'user_password' => 'open-secret', 'allow_print' => 'false', 'allow_copy_content' => 'false', 'allow_change_content' => 'false', ], ]); $pdf = curl_exec($ch); if (curl_getinfo($ch, CURLINFO_HTTP_CODE) === 200) { file_put_contents('protected.pdf', $pdf); } ``` ```ruby title="Ruby" # gem install http require 'http' response = HTTP .headers('X-API-Key' => 'your_api_key') .post('https://api.pdfblocks.com/v1/add_restrictions', form: { file: HTTP::FormData::File.new('input.pdf'), owner_password: 'owner-secret', user_password: 'open-secret', allow_print: 'false', allow_copy_content: 'false', allow_change_content: 'false', }) File.write('protected.pdf', response.body) if response.status.success? ``` ```go title="Go" package main import ( "bytes" "io" "mime/multipart" "net/http" "os" ) func main() { var buf bytes.Buffer form := multipart.NewWriter(&buf) file, _ := os.Open("input.pdf") defer file.Close() part, _ := form.CreateFormFile("file", "input.pdf") io.Copy(part, file) form.WriteField("owner_password", "owner-secret") form.WriteField("user_password", "open-secret") form.WriteField("allow_print", "false") form.WriteField("allow_copy_content", "false") form.WriteField("allow_change_content", "false") form.Close() req, _ := http.NewRequest("POST", "https://api.pdfblocks.com/v1/add_restrictions", &buf) req.Header.Set("Content-Type", form.FormDataContentType()) req.Header.Set("X-API-Key", "your_api_key") res, _ := http.DefaultClient.Do(req) defer res.Body.Close() out, _ := os.Create("protected.pdf") defer out.Close() io.Copy(out, res.Body) } ``` ```csharp title="C#" using var client = new HttpClient(); client.DefaultRequestHeaders.Add("X-API-Key", "your_api_key"); using var form = new MultipartFormDataContent { { new ByteArrayContent(File.ReadAllBytes("input.pdf")), "file", "input.pdf" }, { new StringContent("owner-secret"), "owner_password" }, { new StringContent("open-secret"), "user_password" }, { new StringContent("false"), "allow_print" }, { new StringContent("false"), "allow_copy_content" }, { new StringContent("false"), "allow_change_content" }, }; var response = await client.PostAsync( "https://api.pdfblocks.com/v1/add_restrictions", form); response.EnsureSuccessStatusCode(); await File.WriteAllBytesAsync( "protected.pdf", await response.Content.ReadAsByteArrayAsync()); ``` Se você precisa apenas de uma senha de abertura e de nenhum sinalizador de permissão, `add_password` é a chamada mais simples: ```bash title="cURL" curl https://api.pdfblocks.com/v1/add_password \ -H 'X-API-Key: your_api_key' \ -F file=@input.pdf \ -F password='pa$$word' \ -o encrypted.pdf ``` Tanto `add_password` quanto `add_restrictions` aceitam um `encryption_algorithm` igual a `AES-128` (o padrão) ou `AES-256`. Consulte [Adicionar senha](/docs/api/add-password-to-pdf) e [Adicionar restrições](/docs/api/add-restrictions-to-pdf) para ver todos os campos. ## Desbloquear um documento Para retirar uma proteção cujas credenciais você tem, descriptografe primeiro e depois limpe os sinalizadores de permissão. `POST /v1/remove_password` com a `password` atual do documento. O resultado não exige mais senha para abrir, então as etapas seguintes conseguem lê-lo. `POST /v1/remove_restrictions` remove os sinalizadores de permissão e deixa um PDF sem restrições. ```bash title="cURL" # 1. Decrypt with the known password. curl -sS https://api.pdfblocks.com/v1/remove_password \ -H 'X-API-Key: your_api_key' \ -F file=@protected.pdf \ -F password='open-secret' | # 2. Clear the permission flags from the decrypted bytes. curl -sS https://api.pdfblocks.com/v1/remove_restrictions \ -H 'X-API-Key: your_api_key' \ -F 'file=@-;filename=unlocked.pdf;type=application/pdf' \ -o unrestricted.pdf ``` ```python title="Python" # pip install requests import requests BASE = 'https://api.pdfblocks.com' HEADERS = {'X-API-Key': 'your_api_key'} # 1. Decrypt with the known password. with open('protected.pdf', 'rb') as file: unlocked = requests.post( f'{BASE}/v1/remove_password', headers=HEADERS, files={'file': file}, data={'password': 'open-secret'}, ) unlocked.raise_for_status() # 2. Clear the permission flags from the decrypted bytes. unrestricted = requests.post( f'{BASE}/v1/remove_restrictions', headers=HEADERS, files={'file': ('unlocked.pdf', unlocked.content, 'application/pdf')}, ) unrestricted.raise_for_status() with open('unrestricted.pdf', 'wb') as output: output.write(unrestricted.content) ``` `remove_restrictions` não tem campo de senha, então funciona em um documento que está restrito, mas não protegido por senha. Se um documento tiver uma senha de abertura, execute `remove_password` primeiro, como faz o fluxo acima, para que a chamada de restrições consiga lê-lo. ## Remover assinaturas Uma assinatura criptográfica tranca um PDF: qualquer edição a invalida. Se você precisa reprocessar um documento assinado, remova antes as assinaturas e as marcas de tempo com `remove_signatures`. Isso de fato invalida as assinaturas, o que é inevitável quando o conteúdo muda. ```bash title="cURL" curl https://api.pdfblocks.com/v1/remove_signatures \ -H 'X-API-Key: your_api_key' \ -F file=@signed.pdf \ -o unsigned.pdf ``` ## Veja também Criptografe um PDF com uma senha de abertura. Defina a matriz completa de sinalizadores de permissão. Descriptografe um PDF cuja senha você tem. Aplique a marca-d’água ou mescle antes de criptografar.