PDF Blocks
PreciosSoporte
Empezar gratis
Ir a la página

Proteger y desbloquear documentos

Cómo encajan entre sí las acciones de seguridad y en qué orden llamarlas al proteger o desbloquear un documento.

La seguridad de un PDF son dos cosas distintas, y acertar con el orden depende de saber cuál es cuál. Una contraseña cifra el archivo y controla quién puede abrirlo. Las restricciones son indicadores de permiso que controlan qué puede hacer un lector una vez abierto: imprimir, copiar, editar. Esta guía ordena las cinco acciones de seguridad en un flujo de proteger y distribuir y en un flujo de desbloqueo.

Las acciones de seguridad

Acción Ruta Qué hace
Añadir contraseña add_password Cifra el PDF y establece la contraseña necesaria para abrirlo.
Añadir restricciones add_restrictions Establece los indicadores de permiso (imprimir, copiar, editar) detrás de una contraseña de propietario; también puede establecer una contraseña de apertura.
Quitar contraseña remove_password Descifra un PDF cuando usted proporciona su contraseña actual.
Quitar restricciones remove_restrictions Borra todos los indicadores de permiso.
Quitar firmas remove_signatures Quita las firmas criptográficas y las marcas de tiempo.

Contraseñas frente a restricciones. add_password recibe una sola password: la contraseña que teclea el lector para abrir el archivo. add_restrictions recibe una owner_password que protege los indicadores de permiso, más una user_password opcional que funciona como contraseña de apertura. Si establece user_password, el documento necesitará una contraseña para abrirse; si la omite, cualquiera podrá abrirlo pero seguirá sujeto a los indicadores de permiso.

La regla que gobierna el orden

Cifre al final. Ninguna otra acción puede abrir un PDF cifrado, porque no hay ningún campo para indicar su contraseña. Así que ejecute primero todos los pasos de contenido y de permisos (unir, marca de agua, restricciones) y añada la contraseña de apertura como paso final. Para modificar un documento que ya está protegido con contraseña, quite la contraseña primero, procéselo y vuelva a protegerlo.

Por esa regla, no apile add_password y después add_restrictions: la llamada de restricciones no puede abrir el archivo que acaba de cifrarse. Cuando necesite a la vez una contraseña de apertura e indicadores de permiso, establézcalos en una sola llamada a add_restrictions usando owner_password y user_password juntas.

Proteger un documento para distribuirlo

Blinde un informe para que pida una contraseña al abrirse y no se pueda imprimir, copiar ni editar, todo en una sola llamada.

Prepare primero el contenido

Haga ahora cualquier unión, marca de agua o trabajo con páginas, mientras el documento todavía no está cifrado. Consulte Encadenar acciones.

Aplique restricciones y una contraseña de apertura

POST /v1/add_restrictions con una owner_password (protege los permisos), una user_password (la contraseña de apertura) y los indicadores de permiso en false para lo que quiera prohibir.

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 solo necesita una contraseña de apertura y ningún indicador de permiso, add_password es la llamada más 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

Tanto add_password como add_restrictions aceptan un encryption_algorithm de AES-128 (el predeterminado) o AES-256. Consulte Añadir una contraseña y Añadir restricciones para ver todos los campos.

Desbloquear un documento

Para levantar una protección de la que tiene las credenciales, descifre primero y después borre los indicadores de permiso.

Quite la contraseña de apertura

POST /v1/remove_password con la password actual del documento. El resultado ya no pide una contraseña para abrirse, así que los pasos posteriores pueden leerlo.

Borre las restricciones

POST /v1/remove_restrictions quita los indicadores de permiso y deja un PDF sin restricciones.

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 no tiene campo de contraseña, así que funciona sobre un documento restringido pero no protegido con contraseña. Si un documento tiene una contraseña de apertura, ejecute remove_password primero, como hace el flujo anterior, para que la llamada de restricciones pueda leerlo.

Quitar firmas

Una firma criptográfica bloquea un PDF: cualquier edición la invalida. Si tiene que volver a procesar un documento firmado, quite primero las firmas y las marcas de tiempo con remove_signatures. Esto sí invalida las firmas, algo inevitable en cuanto cambia el contenido.

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

Relacionado

Añadir una contraseña

Cifre un PDF con una contraseña de apertura.

Añadir restricciones

Establezca la matriz completa de indicadores de permiso.

Quitar una contraseña

Descifre un PDF del que tiene la contraseña.

Encadenar acciones

Estampe la marca de agua o una los documentos antes de cifrar.