PDF Blocks
TarifsSupport
Commencer gratuitement
Ouvrir la page

Protéger et déverrouiller des documents

Comment les actions de sécurité s’articulent entre elles, et dans quel ordre les appeler pour protéger ou déverrouiller un document.

La sécurité d’un PDF, ce sont deux choses distinctes, et trouver le bon ordre suppose de savoir laquelle est laquelle. Un mot de passe chiffre le fichier et contrôle qui peut l’ouvrir. Les restrictions sont des indicateurs d’autorisation qui contrôlent ce qu’un lecteur peut faire une fois le document ouvert : imprimer, copier, modifier. Ce guide ordonne les cinq actions de sécurité en une procédure de protection avant diffusion et une procédure de déverrouillage.

Les actions de sécurité

Action Route Ce qu’elle fait
Ajouter un mot de passe add_password Chiffre le PDF et définit le mot de passe nécessaire pour l’ouvrir.
Ajouter des restrictions add_restrictions Définit les indicateurs d’autorisation (impression, copie, modification) derrière un mot de passe propriétaire ; peut aussi définir un mot de passe d’ouverture.
Supprimer le mot de passe remove_password Déchiffre un PDF lorsque vous fournissez son mot de passe actuel.
Supprimer les restrictions remove_restrictions Efface tous les indicateurs d’autorisation.
Supprimer les signatures remove_signatures Supprime les signatures cryptographiques et les horodatages.

Mots de passe et restrictions. add_password prend un seul password : le mot de passe qu’un lecteur saisit pour ouvrir le fichier. add_restrictions prend un owner_password qui protège les indicateurs d’autorisation, plus un user_password facultatif qui fait office de mot de passe d’ouverture. Définissez user_password et le document exigera un mot de passe pour s’ouvrir ; omettez-le et n’importe qui pourra l’ouvrir, tout en restant soumis aux indicateurs d’autorisation.

La règle unique qui gouverne l’ordre

Chiffrez en dernier. Aucune autre action ne peut ouvrir un PDF chiffré, car il n’existe aucun champ pour fournir son mot de passe. Exécutez donc d’abord toutes les étapes de contenu et d’autorisation (fusion, filigrane, restrictions) et ajoutez le mot de passe d’ouverture en étape finale. Pour modifier un document déjà protégé par mot de passe, supprimez le mot de passe d’abord, traitez-le, puis protégez-le à nouveau.

En raison de cette règle, n’empilez pas add_password puis add_restrictions : l’appel de restrictions ne peut pas ouvrir le fichier qui vient d’être chiffré. Lorsque vous avez besoin à la fois d’un mot de passe d’ouverture et d’indicateurs d’autorisation, définissez-les dans un seul appel à add_restrictions en utilisant owner_password et user_password ensemble.

Protéger un document en vue de sa diffusion

Verrouillez un rapport pour qu’il exige un mot de passe à l’ouverture et ne puisse être ni imprimé, ni copié, ni modifié, le tout en un seul appel.

Préparez d’abord le contenu

Effectuez dès maintenant les fusions, les filigranes ou le travail sur les pages, pendant que le document n’est pas encore chiffré. Consultez Enchaîner les actions.

Appliquez des restrictions et un mot de passe d’ouverture

POST /v1/add_restrictions avec un owner_password (qui protège les autorisations), un user_password (le mot de passe d’ouverture) et les indicateurs d’autorisation à false pour ce que vous voulez interdire.

cURLbash
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
Pythonpython
# 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)
Node.jsjavascript
// 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()));
PHPphp
<?php
$ch = curl_init('https://api.pdfblocks.com/v1/add_restrictions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => 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);
}
Rubyruby
# 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?
Gogo
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)
}
C#csharp
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());

Si vous n’avez besoin que d’un mot de passe d’ouverture et d’aucun indicateur d’autorisation, add_password est l’appel le plus simple :

cURLbash
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

add_password comme add_restrictions acceptent un encryption_algorithm valant AES-128 (la valeur par défaut) ou AES-256. Consultez Ajouter un mot de passe à un PDF et Ajouter des restrictions à un PDF pour tous les champs.

Déverrouiller un document

Pour lever une protection dont vous détenez les identifiants, déchiffrez d’abord, puis effacez les indicateurs d’autorisation.

Supprimez le mot de passe d’ouverture

POST /v1/remove_password avec le password actuel du document. Le résultat n’exige plus de mot de passe à l’ouverture, si bien que les étapes suivantes peuvent le lire.

Effacez les restrictions

POST /v1/remove_restrictions supprime les indicateurs d’autorisation et laisse un PDF sans restrictions.

cURLbash
# 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
Pythonpython
# 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’a pas de champ de mot de passe : il fonctionne donc sur un document soumis à des restrictions mais non protégé par mot de passe. Si un document a un mot de passe d’ouverture, exécutez d’abord remove_password, comme le fait la procédure ci-dessus, pour que l’appel de restrictions puisse le lire.

Supprimer les signatures

Une signature cryptographique verrouille un PDF : toute modification l’invalide. Si vous devez retraiter un document signé, supprimez d’abord les signatures et les horodatages avec remove_signatures. Cela invalide bien les signatures, ce qui est inévitable dès lors que le contenu change.

cURLbash
curl https://api.pdfblocks.com/v1/remove_signatures \
  -H 'X-API-Key: your_api_key' \
  -F file=@signed.pdf \
  -o unsigned.pdf

Voir aussi

Ajouter un mot de passe

Chiffrez un PDF avec un mot de passe d’ouverture.

Ajouter des restrictions

Définissez toute la matrice des indicateurs d’autorisation.

Supprimer un mot de passe

Déchiffrez un PDF dont vous avez le mot de passe.

Enchaîner les actions

Apposez un filigrane ou fusionnez avant de chiffrer.