PDF Blocks
PrezziSupporto
Iniziare gratis
Aprire la pagina

Proteggere e sbloccare i documenti

Come si combinano le azioni di sicurezza e in quale ordine chiamarle per proteggere o sbloccare un documento.

La sicurezza di un PDF è fatta di due cose distinte, e trovare l’ordine giusto richiede di sapere quale è quale. Una password crittografa il file e controlla chi può aprirlo. Le restrizioni sono flag di autorizzazione che controllano ciò che un lettore può fare una volta che è aperto: stampare, copiare, modificare. Questa guida mette in sequenza le cinque azioni di sicurezza in una procedura di protezione prima della distribuzione e in una procedura di sblocco.

Le azioni di sicurezza

Azione Percorso Che cosa fa
Aggiungere una password add_password Crittografa il PDF e imposta la password necessaria per aprirlo.
Aggiungere restrizioni add_restrictions Imposta i flag di autorizzazione (stampa, copia, modifica) dietro una password proprietario; può impostare anche una password di apertura.
Rimuovere la password remove_password Decrittografa un PDF quando se ne fornisce la password attuale.
Rimuovere le restrizioni remove_restrictions Azzera tutti i flag di autorizzazione.
Rimuovere le firme remove_signatures Rimuove le firme crittografiche e le marche temporali.

Password e restrizioni. add_password accetta una sola password: quella che un lettore digita per aprire il file. add_restrictions accetta una owner_password che protegge i flag di autorizzazione, più una user_password facoltativa che funge da password di apertura. Impostando user_password il documento richiede una password per essere aperto; omettendola chiunque può aprirlo, restando comunque vincolato dai flag di autorizzazione.

L’unica regola che governa l’ordine

Crittografare per ultimo. Un PDF crittografato non può essere aperto da nessun’altra azione, perché non esiste un campo in cui fornirne la password. Eseguire quindi prima tutti i passaggi sul contenuto e sulle autorizzazioni (unione, filigrana, restrizioni) e aggiungere la password di apertura come passaggio finale. Per modificare un documento già protetto da password, rimuovere prima la password, elaborarlo e poi proteggerlo di nuovo.

Per via di questa regola, non usare add_password seguito da add_restrictions: la chiamata alle restrizioni non può aprire il file appena crittografato. Quando servono sia una password di apertura sia i flag di autorizzazione, impostarli in un’unica chiamata a add_restrictions usando insieme owner_password e user_password.

Proteggere un documento per la distribuzione

Bloccare un report in modo che richieda una password per essere aperto e non possa essere stampato, copiato o modificato, il tutto in un’unica chiamata.

Preparare prima il contenuto

Eseguire ora le unioni, le filigrane o il lavoro sulle pagine, mentre il documento non è ancora crittografato. Vedere Concatenare le azioni.

Applicare le restrizioni e una password di apertura

POST /v1/add_restrictions con una owner_password (protegge le autorizzazioni), una user_password (la password di apertura) e i flag di autorizzazione impostati su false per ciò che si vuole vietare.

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());

Se serve solo una password di apertura e nessun flag di autorizzazione, add_password è la chiamata più semplice:

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

Sia add_password sia add_restrictions accettano un encryption_algorithm pari ad AES-128 (il valore predefinito) o AES-256. Vedere Aggiungere una password e Aggiungere restrizioni per tutti i campi.

Sbloccare un documento

Per togliere una protezione di cui si possiedono le credenziali, decrittografare prima e poi azzerare i flag di autorizzazione.

Rimuovere la password di apertura

POST /v1/remove_password con la password attuale del documento. Il risultato non richiede più una password per essere aperto, così i passaggi successivi possono leggerlo.

Azzerare le restrizioni

POST /v1/remove_restrictions rimuove i flag di autorizzazione e lascia un PDF senza restrizioni.

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 non ha un campo per la password, quindi funziona su un documento che ha restrizioni ma non è protetto da password. Se un documento ha una password di apertura, eseguire prima remove_password, come fa la procedura qui sopra, in modo che la chiamata alle restrizioni possa leggerlo.

Rimuovere le firme

Una firma crittografica blocca un PDF: qualsiasi modifica la invalida. Se occorre rielaborare un documento firmato, rimuovere prima le firme e le marche temporali con remove_signatures. Questo invalida davvero le firme, cosa inevitabile una volta che il contenuto cambia.

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

Vedi anche

Aggiungere una password

Crittografare un PDF con una password di apertura.

Aggiungere restrizioni

Impostare l’intera matrice dei flag di autorizzazione.

Rimuovere la password

Decrittografare un PDF di cui si ha la password.

Concatenare le azioni

Apporre una filigrana o unire prima di crittografare.