# jmrp.io: Full Context

> Personal technical blog and portfolio of José Manuel Requena Plens, a firmware and software engineer in Valencia, Spain: industrial embedded systems, open-source tooling, and self-hosted infrastructure.

> This file is an index. Every entry links to a markdown twin that carries
> the detail, which is what keeps the index itself small enough to fit in an
> agent's context. Posts, tools, the CV and the publications each live at
> their page's own URL with `index.md` appended.

> Reuse: articles, blog covers and data files are CC BY 4.0 with attribution; the source code is MIT; the portrait is reserved. Full terms: https://jmrp.io/license/

Canonical: https://jmrp.io/

Build-Date: 2026-10-16

## About the Author

José Manuel Requena Plens (JMRP) is a firmware and software engineer in Valencia, Spain. From April 2023 to May 2026 he was an R&D Software Developer at Power Electronics, writing firmware in C on STM32 and FreeRTOS for solar inverters, with Modbus communications and hardware test automation; before that, acoustics research at the UPV (2019–2023) on rocket launch noise mitigation for the European Space Agency (ESA), acoustic metamaterials and biomedical ultrasound. Since May 2026 he has been looking for firmware, software or QA roles, on-site, remote or hybrid. Active open-source contributor and self-hoster.

## Blog Posts

Each post's full body lives in its own file, so no ingestion cap ever truncates mid-guide:

- [Mastering Mutual TLS (mTLS) with Nginx: A Deep Dive](https://jmrp.io/blog/001-secure-nginx-client-certificates/index.md): Implement Mutual TLS (mTLS) with Nginx — create a CA, generate client certificates, configure CRL and OCSP revocation, and enable Zero Trust. ([article](https://jmrp.io/blog/001-secure-nginx-client-certificates/))
- [Mastering Virtual Files in Nginx: A Complete Guide](https://jmrp.io/blog/002-serve-virtual-files-nginx/index.md): Serve virtual files in Nginx without disk I/O. Covers root vs alias vs try_files, named locations, Kubernetes health endpoints, and containers. ([article](https://jmrp.io/blog/002-serve-virtual-files-nginx/))
- [Content Security Policy (CSP) with Nginx: The Complete Guide](https://jmrp.io/blog/003-implementing-content-security-policy-nginx/index.md): Master Content Security Policy from zero to A+ — nonces, hashes, strict-dynamic, Trusted Types, bypass prevention, and production Nginx configs. ([article](https://jmrp.io/blog/003-implementing-content-security-policy-nginx/))
- [Mastering QUIC and HTTP/3 with Nginx: The Complete Guide](https://jmrp.io/blog/004-enabling-quic-http3-nginx/index.md): Deep dive into QUIC and HTTP/3 — technical architecture, security features, and step-by-step Nginx configuration for production deployment. ([article](https://jmrp.io/blog/004-enabling-quic-http3-nginx/))
- [Implementing a Tarpit in Nginx: Trap Malicious Scanners](https://jmrp.io/blog/005-implementing-tarpit-nginx/index.md): Implement an Nginx tarpit to slow down and trap malicious bots, vulnerability scanners, and brute-force attackers. Includes CrowdSec integration. ([article](https://jmrp.io/blog/005-implementing-tarpit-nginx/))
- [MikroTik Honeypot: Trap & Auto-Block Port Scanners](https://jmrp.io/blog/006-implementing-mikrotik-honeypot/index.md): Configure a MikroTik honeypot to detect port scanners, log malicious activity, and auto-block attackers using firewall address lists and the RAW table. ([article](https://jmrp.io/blog/006-implementing-mikrotik-honeypot/))
- [MikroTik WireGuard VPN: Dual-Stack IPv4/IPv6 Configuration](https://jmrp.io/blog/007-mikrotik-wireguard-dual-stack-vpn/index.md): Configure WireGuard VPN on MikroTik RouterOS with full IPv4/IPv6 dual-stack. Access your home network with native IPv6 from any connection. ([article](https://jmrp.io/blog/007-mikrotik-wireguard-dual-stack-vpn/))
- [MikroTik PPPoE + DHCPv6-PD: Dual-Stack for DIGI Spain](https://jmrp.io/blog/008-mikrotik-pppoe-dualstack-digi/index.md): Configure PPPoE with DHCPv6 Prefix Delegation on MikroTik RouterOS for DIGI Spain. VLAN tagging, SLAAC, prefix change handling, and firewall rules. ([article](https://jmrp.io/blog/008-mikrotik-pppoe-dualstack-digi/))
- [Running a Tor Bridge on Linux: obfs4 and WebTunnel Guide](https://jmrp.io/blog/009-running-tor-bridge/index.md): Guide to running obfs4 and WebTunnel Tor bridges on Linux with Nginx camouflage, firewall hardening, Prometheus monitoring, and CrowdSec. ([article](https://jmrp.io/blog/009-running-tor-bridge/))
- [What the Linker Won't Do: Packing i18n Strings on an MCU](https://jmrp.io/blog/010-packed-i18n-string-pool/index.md): A build-time generator packs firmware UI translations into one string pool indexed by uint16 offsets, halving the index table on a 32-bit MCU. ([article](https://jmrp.io/blog/010-packed-i18n-string-pool/))
- [A Vault File That Fails Closed: Encrypt-then-MAC on an MCU](https://jmrp.io/blog/011-encrypt-then-mac-vault/index.md): How a hardware password manager authenticates every vault file before it decrypts: encrypt-then-MAC, verify-before-decrypt, and fail-closed reads. ([article](https://jmrp.io/blog/011-encrypt-then-mac-vault/))
- [Your 4-Digit PIN Is Fine: Device-Bound Keys on ESP32-S3](https://jmrp.io/blog/012-device-bound-key-derivation/index.md): Why PBKDF2 iterations can't protect a 4-digit PIN on a microcontroller, and how an eFuse-HMAC device secret plus HKDF stops offline brute force. ([article](https://jmrp.io/blog/012-device-bound-key-derivation/))
- [What building a GitLab MCP server taught me about GitLab's API](https://jmrp.io/blog/013-gitlab-mcp-server-api-lessons/index.md): Building and checking an MCP server against GitLab found a 401 that meant 403 and writes answered as successes that saved nothing; each went upstream. ([article](https://jmrp.io/blog/013-gitlab-mcp-server-api-lessons/))
- [GitLab fine-grained personal access tokens, one action at a time](https://jmrp.io/blog/014-gitlab-fine-grained-tokens-per-action/index.md): A GitLab fine-grained token holds a grant, not scopes: REST refuses outside it, GraphQL answers null. I derive what each API action needs, ahead of time. ([article](https://jmrp.io/blog/014-gitlab-fine-grained-tokens-per-action/))

## Blog Posts (Español)

El cuerpo completo de cada artículo vive en su propio fichero, para que ningún límite de ingesta corte a mitad de una guía:

- [Dominando Mutual TLS (mTLS) con Nginx: Una Guía Completa](https://jmrp.io/es/blog/001-secure-nginx-client-certificates/index.md): Implementa Mutual TLS (mTLS) con Nginx — crea una CA, genera certificados de cliente, configura revocación CRL y OCSP, y habilita Zero Trust. ([artículo](https://jmrp.io/es/blog/001-secure-nginx-client-certificates/))
- [Domina los archivos virtuales en Nginx: Guía completa](https://jmrp.io/es/blog/002-serve-virtual-files-nginx/index.md): Sirve archivos virtuales en Nginx sin I/O de disco. Cubre root vs alias vs try_files, named locations, endpoints de salud en Kubernetes y containers. ([artículo](https://jmrp.io/es/blog/002-serve-virtual-files-nginx/))
- [Content Security Policy (CSP) con Nginx: La Guía Completa](https://jmrp.io/es/blog/003-implementing-content-security-policy-nginx/index.md): Domina Content Security Policy de cero a A+ — nonces, hashes, strict-dynamic, Trusted Types, prevención de bypass y configuraciones Nginx en producción. ([artículo](https://jmrp.io/es/blog/003-implementing-content-security-policy-nginx/))
- [Dominando QUIC y HTTP/3 con Nginx: La Guía Completa](https://jmrp.io/es/blog/004-enabling-quic-http3-nginx/index.md): Inmersión profunda en QUIC y HTTP/3 — arquitectura técnica, seguridad y configuración paso a paso de Nginx para despliegue en producción. ([artículo](https://jmrp.io/es/blog/004-enabling-quic-http3-nginx/))
- [Implementar un Tarpit en Nginx: Atrapa a los Escáneres Maliciosos](https://jmrp.io/es/blog/005-implementing-tarpit-nginx/index.md): Implementa un tarpit en Nginx para ralentizar bots maliciosos, escáneres de vulnerabilidades y ataques de fuerza bruta. Integración con CrowdSec incluida. ([artículo](https://jmrp.io/es/blog/005-implementing-tarpit-nginx/))
- [Honeypot en MikroTik: Atrapa y Bloquea Escáneres de Puertos](https://jmrp.io/es/blog/006-implementing-mikrotik-honeypot/index.md): Configura un honeypot en MikroTik para detectar escáneres de puertos, registrar actividad maliciosa y bloquear atacantes automáticamente con la tabla RAW. ([artículo](https://jmrp.io/es/blog/006-implementing-mikrotik-honeypot/))
- [WireGuard en MikroTik: configuración dual-stack IPv4/IPv6](https://jmrp.io/es/blog/007-mikrotik-wireguard-dual-stack-vpn/index.md): Configura WireGuard en MikroTik RouterOS con dual-stack IPv4/IPv6 completo. Accede a tu red doméstica con IPv6 nativo desde cualquier conexión. ([artículo](https://jmrp.io/es/blog/007-mikrotik-wireguard-dual-stack-vpn/))
- [MikroTik PPPoE + DHCPv6-PD: Dual-Stack para DIGI España](https://jmrp.io/es/blog/008-mikrotik-pppoe-dualstack-digi/index.md): Configura PPPoE con DHCPv6 Prefix Delegation en MikroTik RouterOS para DIGI España. VLAN tagging, SLAAC, gestión de cambios de prefijo y firewall. ([artículo](https://jmrp.io/es/blog/008-mikrotik-pppoe-dualstack-digi/))
- [Bridge Tor en Linux: guía completa de obfs4 y WebTunnel](https://jmrp.io/es/blog/009-running-tor-bridge/index.md): Guía para ejecutar bridges Tor obfs4 y WebTunnel en Linux con camuflaje Nginx, firewall, monitorización Prometheus e integración CrowdSec. ([artículo](https://jmrp.io/es/blog/009-running-tor-bridge/))
- [Lo que el linker no hará: empaquetar cadenas i18n en un MCU](https://jmrp.io/es/blog/010-packed-i18n-string-pool/index.md): Un generador empaqueta las traducciones del firmware en un pool indexado por offsets uint16, reduciendo a la mitad la tabla índice en un MCU de 32 bits. ([artículo](https://jmrp.io/es/blog/010-packed-i18n-string-pool/))
- [Una bóveda con bloqueo ante fallos: Encrypt-then-MAC en un MCU](https://jmrp.io/es/blog/011-encrypt-then-mac-vault/index.md): Cómo un gestor de contraseñas hardware autentica cada fichero antes de descifrar: Encrypt-then-MAC, verificación antes de descifrar y bloqueo ante fallos. ([artículo](https://jmrp.io/es/blog/011-encrypt-then-mac-vault/))
- [Un PIN de 4 dígitos basta: claves vinculadas al ESP32-S3](https://jmrp.io/es/blog/012-device-bound-key-derivation/index.md): Por qué las iteraciones de PBKDF2 no protegen un PIN de 4 dígitos en un MCU, y cómo un secreto del dispositivo más HKDF frenan la fuerza bruta offline. ([artículo](https://jmrp.io/es/blog/012-device-bound-key-derivation/))
- [Lo que construir un servidor MCP me enseñó sobre la API de GitLab](https://jmrp.io/es/blog/013-gitlab-mcp-server-api-lessons/index.md): Construir y contrastar un servidor MCP con GitLab destapó un 401 que era un 403 y escrituras aceptadas que no guardaban nada; cada caso acabó upstream. ([artículo](https://jmrp.io/es/blog/013-gitlab-mcp-server-api-lessons/))
- [Tokens de grano fino de GitLab, acción por acción](https://jmrp.io/es/blog/014-gitlab-fine-grained-tokens-per-action/index.md): Un token de grano fino de GitLab lleva una concesión, no scopes: fuera de ella, REST rechaza y GraphQL responde null. Deduzco qué necesita cada acción. ([artículo](https://jmrp.io/es/blog/014-gitlab-fine-grained-tokens-per-action/))

## Developer Tools

### Base64 Encoder / Decoder

URL: https://jmrp.io/tools/base64-encoder/
Markdown: https://jmrp.io/tools/base64-encoder/index.md
Category: developer
Tags: base64, encoding, decoding, hex, url-encoding
Encode and decode Base64, Base64URL, URL encoding, hex, and HTML entities. File support for images and documents. Runs client-side.

Features:
- Encode and decode Base64 and Base64URL
- Convert URL, hex, HTML entities, and binary
- Encode files via drag-and-drop with preview
- Generate Data URIs for CSS and HTML
- Runs fully client-side, no uploads

Questions answered:

**Is Base64 a form of encryption?**

No. Base64 is an encoding scheme, not encryption. It makes binary data safe to transmit as text but provides no confidentiality, since anyone can decode it instantly. Never use it to protect secrets.

**What is the difference between Base64 and Base64URL?**

Standard Base64 ([RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648)) uses + and / characters plus = padding, which can break inside URLs. Base64URL replaces them with - and _ and usually drops the padding, making it safe for URLs and JWTs.

**Is my data uploaded to a server when I encode a file?**

No. All encoding and decoding runs entirely in your browser. Files you drop are never uploaded, so your data never leaves your device.

**Why is my Base64 output larger than the original file?**

Base64 represents every 3 bytes of input as 4 ASCII characters, so the output is roughly 33% larger than the source data. This is expected overhead for any Base64 encoding.

**What is a Data URI and when should I use it?**

A Data URI embeds the Base64-encoded content directly inside CSS or HTML using a data:<mime-type>;base64,... prefix, avoiding a separate file request. Enable the Data URI toggle to get a ready-to-paste string for small assets like icons.


### Certificate Inspector

URL: https://jmrp.io/tools/cert-inspector/
Markdown: https://jmrp.io/tools/cert-inspector/index.md
Category: security
Tags: ssl, tls, certificates, x509, pem, security
Decode PEM SSL/TLS certificates or fetch from a URL client-side. Inspect subject, issuer, validity, SANs, key usage, and security assessment.

Features:
- Decode PEM or fetch certificates by URL
- Inspect subject, issuer, validity, and SANs
- View key details, usage, and extensions
- Compute SHA-256 fingerprint in-browser
- Security assessment of keys and algorithms

Questions answered:

**Is my certificate uploaded to a server?**

No. All ASN.1/DER parsing, SHA-256 fingerprinting, and the security assessment run entirely in your browser. Pasted PEM data never leaves your device.

**Can I inspect a private or internal certificate?**

Yes. Paste the PEM-encoded data directly instead of fetching by URL. URL fetching relies on public Certificate Transparency log APIs (certspotter, crt.sh) and only works for publicly logged certificates.

**What does the security assessment check?**

The Certificate Inspector's security assessment evaluates key strength, the signature algorithm, the validity duration, and Certificate Transparency (SCT) compliance, flagging weak keys, deprecated algorithms, and overly long validity periods.

**What is a Subject Alternative Name (SAN)?**

A SAN lists every hostname, IP, email, or URI a certificate is valid for. Modern browsers ignore the Common Name and match the requested host against the SAN entries, so a missing SAN causes trust errors.

**How do I inspect a certificate without this tool?**

Use OpenSSL from the terminal, for example "openssl s_client -connect host:443" piped into "openssl x509 -noout -text". The Linux command reference above lists ready-to-use snippets.


### Color Contrast Checker

URL: https://jmrp.io/tools/color-contrast-checker/
Markdown: https://jmrp.io/tools/color-contrast-checker/index.md
Category: developer
Tags: accessibility, wcag, contrast, color, a11y, apca
Check color contrast ratios for WCAG 2.2 AA and AAA compliance with APCA support, color blindness simulation, and auto-fix suggestions. Runs client-side.

Features:
- Check WCAG 2.2 AA and AAA contrast ratios
- Score perceptual contrast with APCA Lc
- Simulate four color vision deficiencies
- Auto-fix suggestions for failing colors
- Export CSS and share via URL

Questions answered:

**What is the minimum WCAG 2.2 contrast ratio for normal text?**

Normal text needs at least 4.5:1 for AA and 7:1 for AAA. Large text (18pt+, or 14pt+ bold) only needs 3:1 for AA and 4.5:1 for AAA.

**What's the difference between WCAG 2.2 contrast and APCA?**

WCAG 2.x uses a simple luminance ratio, while APCA (planned for WCAG 3.0) models human perception, accounting for text polarity, font size, and weight. This tool reports both so you can compare them.

**Does the contrast checker run in my browser?**

Yes. All contrast calculations happen entirely client-side and no color data is sent to any server. Shareable links only encode the colors in the URL parameters.

**Why check colors against color blindness simulations?**

Roughly 8% of men and 0.5% of women have some color vision deficiency, so a pair that passes for typical vision may still fail for them. Each simulation card shows the perceived contrast ratio for protanopia, deuteranopia, tritanopia, and achromatopsia.

**What does the non-text contrast (SC 1.4.11) check cover?**

The non-text contrast check (SC 1.4.11) applies the WCAG 2.2 minimum of 3:1 to UI components such as buttons, inputs, and borders, plus graphical objects that convey information "meaning".


### Cron Expression Builder

URL: https://jmrp.io/tools/cron-builder/
Markdown: https://jmrp.io/tools/cron-builder/index.md
Category: developer
Tags: cron, scheduling, linux, crontab, automation
Visual cron expression builder with interactive field selectors, presets, next execution preview, and crontab output. Runs client-side.

Features:
- Build cron expressions with visual field selectors
- Choose from 14 common schedule presets
- Read human-readable schedule descriptions
- Preview the next 10 executions
- Generate crontab lines and shareable links

Questions answered:

**What is a cron expression?**

A cron expression is a string of five space-separated fields (minute, hour, day of month, month, day of week) that tells a Unix-like scheduler when to run a task repeatedly.

**How do I run a cron job every 5 minutes?**

Use the step syntax "*/5 * * * *". You can build it here by selecting the minute field's step or picking the "every 5 minutes" preset, then copy the generated crontab line.

**Does this tool send my cron expression to a server?**

No. All parsing, the human-readable description, and the next-execution preview run entirely in your browser. The shareable link only encodes the expression in the URL.

**What happens when both day of month and day of week are set?**

Most cron implementations use OR logic: when neither field is "*", the job runs whenever either the day-of-month or the day-of-week condition matches.

**Why does my cron job fail even though the schedule is correct?**

Cron runs with a minimal PATH and the system timezone, so use absolute paths for commands and check timedatectl. Redirect output with ">> /var/log/myjob.log 2>&1" to capture errors.


### CSP Hash Calculator

URL: https://jmrp.io/tools/hash-calculator/
Markdown: https://jmrp.io/tools/hash-calculator/index.md
Category: security
Tags: csp, hash, sha256, security, sri
Generate SHA-256 hashes for inline scripts. Get ready-to-use CSP directives for your Content Security Policy. Runs client-side.

Features:
- Real-time SHA-256 hashing as you type
- Supports SHA-256, SHA-384 and SHA-512
- Outputs ready-to-use CSP script-src directives
- Optional whitespace cleanup before hashing
- Web Crypto API, content never sent to a server

Questions answered:

**When should I use a CSP hash instead of a nonce?**

Use a hash for inline scripts or styles whose content never changes, so you can allow them without "unsafe-inline". If the script contains dynamic values like a user ID, use a nonce instead, because any change to the content breaks the hash.

**Why does my inline script still get blocked after adding the hash?**

CSP hashes require an exact byte-for-byte match, so even a single extra space or newline produces a different hash and the browser blocks the script. Make sure you hash only the inner content, without the surrounding "<script>" or "<style>" tags.

**What is the difference between a CSP hash and an SRI hash?**

A CSP hash (SHA-256 base64) authorizes specific inline code in your Content Security Policy. An SRI hash (typically SHA-384) goes in the "integrity" attribute of an external script or link tag to verify a fetched file has not been tampered with.

**Is my script content sent to a server?**

No. All hashing runs locally in your browser using the Web Crypto API, so your script or style content is never transmitted over the network.

**Which hash algorithm should I choose?**

SHA-256 is the standard and most widely supported choice for CSP. SHA-384 and SHA-512 are also valid and are commonly used for Subresource Integrity, but SHA-256 is sufficient for nearly all CSP use cases.


### CSP Policy Builder

URL: https://jmrp.io/tools/csp-builder/
Markdown: https://jmrp.io/tools/csp-builder/index.md
Category: security
Tags: csp, security, headers, xss, nginx
Build Content Security Policy headers interactively. Toggle directives, see the policy generated live, and get a security rating. Runs client-side.

Features:
- Toggle 20+ CSP directives by category
- Quick presets for common third-party services
- Export to 7 server formats (Nginx, Apache, Vercel)
- Report-Only mode and live security assessment
- Runs entirely in your browser

Questions answered:

**What is a Content Security Policy and why do I need one?**

A Content Security Policy (CSP) is an HTTP response header that tells the browser which sources of content are trusted, helping detect and mitigate attacks like Cross-Site Scripting (XSS) and data injection. It is a critical defense-in-depth layer for any modern website.

**Is my CSP configuration sent to a server?**

No. All policy building and formatting happens entirely in your browser. No domains, URLs, or policy settings ever leave your device.

**Which server formats can I export to?**

The builder generates ready-to-use configuration in 7 formats, including Nginx, Apache, Cloudflare, and Vercel. Select your server and copy the output directly into your configuration.

**What does Report-Only mode do?**

Report-Only mode lets you test a policy without actually blocking any resources. The browser reports violations it would have blocked, so you can refine your CSP safely before enforcing it.

**Why does the tool warn about 'unsafe-inline'?**

The security assessment flags insecure configurations like 'unsafe-inline' because they weaken your policy by allowing inline scripts or styles, defeating much of CSP's protection against XSS. Prefer nonces or hashes instead.


### Encrypt-then-MAC Envelope Visualizer

URL: https://jmrp.io/tools/etm-envelope-visualizer/
Markdown: https://jmrp.io/tools/etm-envelope-visualizer/index.md
Category: security
Tags: security, cryptography, encrypt-then-mac, aes, hmac, firmware
Seal a secret into an encrypt-then-MAC envelope, flip a byte, and watch the read verify the tag before decrypting. Runs client-side.

Features:
- Live AES-256-CBC + HMAC-SHA256 envelope sealing
- Separate encKey and macKey sub-key derivation
- Context-bound tag: ver‖recordType‖slotId‖generation
- Seven real attacks: flip, forge, truncate, relocate, retype, roll back
- Encrypt-then-MAC vs decrypt-first, with a live padding-oracle attack
- Web Crypto API, nothing leaves your browser

Questions answered:

**What does "encrypt-then-MAC" mean?**

Encrypt-then-MAC means you encrypt the plaintext first, then compute a MAC over the resulting ciphertext (plus the version byte and IV). On read, the MAC is verified before any decryption is attempted.

**Why verify the MAC before decrypting?**

Checking the tag first means a tampered file never reaches the AES-CBC decrypt path, which closes off padding-oracle attacks. If the tag does not match, the read fails closed and no plaintext is produced.

**Why use separate keys for encryption and the MAC?**

Reusing one key for both AES and HMAC is unsafe, so the passphrase derives a master key that fans out into distinct encKey and macKey sub-keys. The encryption key and the MAC key are never the same value.

**What happens when I flip a byte in the envelope?**

Flipping any byte changes the data the HMAC covers, so the recomputed tag no longer matches the stored tag. The read fails closed — no decryption runs and no plaintext is returned.

**Is my secret or passphrase sent anywhere?**

No. All cryptography runs entirely in your browser via the Web Crypto API, and nothing you type is transmitted to any server.


### HTTP Security Headers Analyzer

URL: https://jmrp.io/tools/http-headers-analyzer/
Markdown: https://jmrp.io/tools/http-headers-analyzer/index.md
Category: security
Tags: http, headers, security, hsts, csp, analysis
Analyze HTTP response headers for security best practices. Get a security score, recommendations, and detailed analysis for each header.

Features:
- Analyzes 10 critical security headers
- Weighted score with A+ to F letter grade
- Detects information leakage headers
- Fetch from URL or paste headers manually
- All analysis runs in your browser

Questions answered:

**Which HTTP security headers does this tool check?**

The HTTP Security Headers Analyzer evaluates 10 critical headers including Content-Security-Policy, Strict-Transport-Security, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy and the three Cross-Origin policies. It also flags information leakage from "Server", "X-Powered-By" and "X-AspNet-Version" headers.

**How is the security score calculated?**

Each header carries a weight reflecting its impact, with Content-Security-Policy worth the most (25 points) and X-XSS-Protection the least (3 points). The weighted total maps to a letter grade from A+ (90-100) down to F (0-29).

**Why are some headers missing when I fetch them from a URL?**

Fetch asks this site's own proxy for the headers, and that proxy issues a HEAD request with its own User-Agent and no cookies. Headers a server only sends on GET, only to a signed-in session, or only after content negotiation will not appear, and if the site sits behind a CDN you see the edge's headers rather than the origin's. For an exact capture, paste the output of curl -sI or the response headers from browser DevTools.

**Is my data sent to a server when I analyze headers?**

The analysis never leaves your browser: whatever is in the text box is parsed, scored and graded on your own machine. The optional Fetch button is the exception, because a browser is not allowed to read another site's response headers (CORS forbids it) so the URL you submit goes to a small proxy on this domain, which requests the headers and hands them back. That proxy writes no log of any kind, so the URL you inspect is never written beside your address, and the site being inspected sees this server rather than you. Paste headers instead of fetching and nothing is sent at all.

**Should I still set X-XSS-Protection?**

No. X-XSS-Protection is a legacy filter that modern browsers ignore or that can introduce vulnerabilities; the recommended value is "0" to disable it, and a strong Content-Security-Policy is the proper XSS defense.


### IP / Subnet Calculator

URL: https://jmrp.io/tools/subnet-calculator/
Markdown: https://jmrp.io/tools/subnet-calculator/index.md
Category: network
Tags: networking, ip, subnet, cidr, ipv4, ipv6, vlsm
IPv4 and IPv6 subnet calculator with CIDR notation, VLSM planner, range-to-CIDR converter, and reverse DNS. Runs client-side.

Features:
- IPv4 and IPv6 subnet calculation
- VLSM planner with waste analysis
- Range-to-CIDR block conversion
- Address type detection and reverse DNS
- Runs locally in your browser

Questions answered:

**How do I calculate the number of usable hosts in a subnet?**

Usable hosts equal the total addresses in the prefix minus the network and broadcast addresses, so a /24 has 254 usable hosts (256 − 2). Enter the IP and CIDR prefix and the tool reports usable hosts, host range, broadcast, and mask automatically.

**What is the difference between a /30 and a /31 subnet?**

A /30 has 4 addresses with 2 usable hosts after reserving network and broadcast, while a /31 ([RFC 3021](https://datatracker.ietf.org/doc/html/rfc3021)) uses both of its 2 addresses for a point-to-point link with no broadcast. Both are common for router-to-router links.

**Why is /64 the standard subnet size for IPv6?**

A /64 prefix is required by SLAAC, which derives the 64-bit interface identifier from the host, so it is the standard size for almost every IPv6 subnet. The tool uses BigInt math to handle these 128-bit calculations accurately.

**How do I convert an arbitrary IP range into CIDR blocks?**

Use the Range to CIDR mode: enter the start and end IPv4 addresses and the tool returns the minimal set of CIDR prefixes that exactly cover the range. This is useful for firewall rules, route aggregation, and access control lists.

**Is my IP address data sent anywhere when I use this calculator?**

No. All calculations run entirely in your browser and no IP addresses or network data are sent to any server. The tool keeps working offline after the initial page load.


### Modbus Frame Builder

URL: https://jmrp.io/tools/modbus-frame-builder/
Markdown: https://jmrp.io/tools/modbus-frame-builder/index.md
Category: embedded
Tags: modbus, rtu, tcp, industrial, plc, embedded, serial
Build and decode Modbus RTU/TCP/ASCII frames with CRC-16/LRC calculation, register interpretation, and byte visualization. Runs client-side.

Features:
- Builds Modbus RTU, TCP, and ASCII frames
- Auto CRC-16, LRC, and MBAP headers
- Decodes hex frames with exception detection
- Interprets registers with selectable byte order
- Runs fully client-side, no server

Questions answered:

**What is the difference between Modbus RTU and Modbus TCP frames?**

RTU frames are binary and end with a 16-bit CRC for serial lines, while TCP frames prepend a 7-byte MBAP header (transaction ID, protocol ID, length, unit ID) and drop the CRC because TCP/IP handles error checking. This tool builds and decodes both, plus Modbus ASCII with LRC.

**How is the Modbus RTU CRC-16 calculated?**

The Modbus RTU CRC-16 uses the polynomial 0xA001 (the reflected form of 0x8005) computed over every byte except the CRC itself, then appended low byte first, high byte second. The tool calculates and validates it automatically when you build or decode a frame.

**Why do my 32-bit register values look wrong when decoded?**

Modbus registers are 16-bit, so 32-bit integers and floats span two registers and vendors disagree on the order. Try switching the byte order between Big-Endian, Little-Endian, Mid Big-Endian, and Mid Little-Endian in the data interpretation panel until the value matches your device.

**What does a Modbus exception response look like?**

The slave echoes the function code ORed with 0x80 followed by an exception code such as 01 (Illegal Function) or 02 (Illegal Data Address). Paste the frame into Decode mode and the tool flags the exception and names the error.

**Is my Modbus data sent to a server?**

No. All frame building, decoding, CRC/LRC calculation, and data interpretation run entirely in your browser; nothing is transmitted. The shareable link only encodes frame parameters in the URL query string.


### Nginx Config Generator

URL: https://jmrp.io/tools/nginx-config-generator/
Markdown: https://jmrp.io/tools/nginx-config-generator/index.md
Category: network
Tags: nginx, server, ssl, tls, reverse-proxy, http3
Generate Nginx server blocks with upstream, QUIC/HTTP3, rate limiting, tarpit, OCSP stapling, and modern TLS. Runs client-side.

Features:
- Six presets: static, proxy, SPA, PHP, API, hardened
- Modern TLS with QUIC/HTTP3 and OCSP stapling
- Upstream load balancing and reverse proxy
- Rate limiting, tarpit, and security headers
- Generates entirely client-side, nothing sent

Questions answered:

**Is my server configuration sent to any server?**

No. All configuration generation happens entirely in your browser. Domains, IP addresses, and backend paths are never transmitted, so your server architecture stays private.

**Where do I place the generated Nginx config file?**

Copy the output into your Nginx sites directory (commonly /etc/nginx/sites-available/ with a symlink in sites-enabled/, or /etc/nginx/conf.d/). Then run "nginx -t" to validate and "nginx -s reload" to apply it without dropping connections.

**How do I enable QUIC/HTTP3 in the generated config?**

Toggle the QUIC/HTTP3 option in the SSL/TLS section. Note your Nginx build must include the http_v3 module — check with "nginx -V" and look for --with-http_v3_module.

**What does the tarpit feature do?**

The tarpit deliberately sends slow responses to attackers and scanners hitting blocked or exploit paths (like wp-admin or phpMyAdmin), wasting their time and resources instead of returning a quick error.

**Which preset should I start with?**

Pick the preset closest to your use case — Static, Reverse Proxy, SPA, PHP-FPM, API Server, or Hardened — then customize the domain, root path, and SSL certificate paths from there.


### Offline PIN Brute-Force Calculator

URL: https://jmrp.io/tools/pin-brute-force-calculator/
Markdown: https://jmrp.io/tools/pin-brute-force-calculator/index.md
Category: security
Tags: security, cryptography, pbkdf2, brute-force, pin, key-derivation
Estimate how long an offline GPU takes to brute-force a PIN through PBKDF2 — then toggle device binding and watch it become infeasible. Runs client-side.

Features:
- Estimates offline PIN time-to-crack
- Adjustable PBKDF2 work factor
- Configurable keyspace and GPU throughput
- Shows device binding making attacks infeasible
- Computes client-side, no inputs transmitted

Questions answered:

**How long does it take to brute-force a 4-digit PIN?**

A 4-digit PIN has only 10,000 possible values, so a GPU with no key-stretching cracks it almost instantly. The real defense is a PBKDF2 work factor that slows each guess, or device binding that makes offline guessing infeasible.

**Does increasing the PBKDF2 iteration count stop brute-force attacks?**

Higher iteration counts multiply the per-guess cost, raising the time to sweep the whole keyspace, but the count is sized for unlock latency, not as the brute-force defense. For a small PIN keyspace it slows an offline attacker but does not make the attack infeasible on its own.

**How does device binding make a PIN brute-force infeasible?**

Device binding mixes a per-chip secret into key derivation, so every guess needs hardware that can't be extracted from the dumped flash. The attacker can no longer test candidates offline against the exfiltrated vault.

**How does the calculator estimate attacker speed?**

The PIN brute-force calculator divides the GPU's raw SHA-256 throughput by the PBKDF2 work, treating each iteration as roughly two SHA-256 compressions. Keyspace divided by that rate gives the time to try every candidate; the expected time to find the secret is about half of that.

**Is anything I type sent to a server?**

No. Every value is computed in your browser with simple arithmetic, and no inputs are transmitted anywhere.


### Password Generator

URL: https://jmrp.io/tools/password-generator/
Markdown: https://jmrp.io/tools/password-generator/index.md
Category: security
Tags: password, security, crypto, passphrase, entropy
Generate strong passwords and passphrases using the Web Crypto API. Estimate entropy, crack time, and customize character sets — all client-side.

Features:
- Web Crypto API with rejection sampling
- Password and Diceware passphrase modes
- Real-time entropy and crack-time estimates
- Customizable length, charsets, and separators
- Excludes ambiguous characters, runs client-side

Questions answered:

**Is it safe to generate passwords in a web browser?**

Yes. This generator runs entirely client-side using the browser's Web Crypto API (crypto.getRandomValues), so passwords are never transmitted, stored, or logged. Nothing leaves your device.

**What is password entropy and how many bits do I need?**

Entropy measures unpredictability in bits — each bit doubles the number of guesses needed to crack the password. Aim for at least 80 bits for important accounts, and 100+ bits for high-value secrets.

**Are passphrases more secure than random passwords?**

A passphrase can match or beat a random password if it has enough words. Each random word from a large list adds roughly 12-13 bits of entropy, so a 5-6 word Diceware-style passphrase is both strong and easier to remember.

**Why should I exclude ambiguous characters like 0, O, l, 1 and I?**

Excluding visually similar characters prevents transcription errors when reading or typing a password manually. It slightly shrinks the character pool, so add a little length to keep the same entropy.

**Does crack time alone tell me if my password is strong?**

Not by itself. The crack-time estimate assumes brute force at 1 trillion guesses per second, but real attacks exploit reuse, leaks, and dictionary patterns. Use a unique, high-entropy password per account and a password manager.


### Regex Tester

URL: https://jmrp.io/tools/regex-tester/
Markdown: https://jmrp.io/tools/regex-tester/index.md
Category: developer
Tags: regex, regexp, pattern, grep, sed, testing
Test regular expressions with real-time match highlighting, capture groups, replace mode, and common pattern presets. Runs in your browser.

Features:
- Real-time match highlighting as you type
- Named and numbered capture groups
- Replace mode with backreferences
- Toggleable g/i/m/s/u flags and presets
- Runs locally in your browser

Questions answered:

**Are my regex patterns and test strings sent to a server?**

No. All pattern matching and text processing runs entirely in your browser using JavaScript's built-in RegExp engine. Your patterns and test strings never leave your device.

**Which regex flavor does this tester use?**

The Regex Tester uses JavaScript's native RegExp engine, which follows the ECMAScript specification. Patterns may behave differently in PCRE, Python, or POSIX tools, so check the flavor comparison table before porting them.

**What do the g, i, m, s, and u flags do?**

g finds all matches instead of just the first, i makes matching case-insensitive, m makes ^ and $ match the start/end of each line, s lets . match newlines, and u enables full Unicode matching and property escapes.

**How do I test a find-and-replace?**

Toggle Replace Mode and enter a replacement string. You can reference captured groups with $1, the whole match with $&, and named groups with $<name>.

**Why does my pattern hang or take a long time?**

Patterns like (a+)+b cause catastrophic backtracking on long non-matching input. The tool shows the execution time for each test, so if a pattern takes more than a few milliseconds, simplify it or use negated character classes instead of greedy wildcards.


### String-Pool Packer

URL: https://jmrp.io/tools/string-pool-packer/
Markdown: https://jmrp.io/tools/string-pool-packer/index.md
Category: embedded
Tags: i18n, embedded, firmware, c++, flash, optimization
Compare a pointer table vs a packed, tail-merged string pool with uint16 offsets. Paste strings and watch the bytes saved. Runs client-side.

Features:
- Pointer table vs packed pool comparison
- String deduplication and tail-merging
- uint16 offset and 64 KiB guard
- Lines and CSV i18n input modes
- Runs locally in your browser

Questions answered:

**Why do const char* pointer tables waste so much flash on an MCU?**

Each cell in a 2-D (language × string ID) table holds a pointer, which is 4 bytes on a 32-bit MCU before a single character of text. Switching to a uint16 offset table halves that index overhead, a structural win the linker can't make for you.

**How much can a packed, tail-merged string pool save versus a pointer table?**

The savings come from three places: halving the index (4-byte pointers to 2-byte uint16 offsets), deduplicating identical strings shared across languages, and tail-merging strings that are suffixes of longer ones. Paste your real strings to see the exact byte total for both layouts.

**What is tail-merging in a string pool?**

Tail-merging stores a string that is the suffix of a longer one by pointing its offset partway into that longer entry, instead of storing it separately. Strings are placed longest-first so the shorter suffix reuses the same bytes.

**When do uint16 offsets stop working for a string pool?**

uint16 offsets can only address the first 64 KiB of the pool. The tool flags when your pool grows past that limit, at which point you would need wider offsets to reach later strings.

**Does this tool send my strings to a server?**

No. All parsing, deduplication, tail-merging, and byte counting happen entirely in your browser, and nothing you type is transmitted anywhere.


### Unix Timestamp to Date Converter

URL: https://jmrp.io/tools/timestamp-converter/
Markdown: https://jmrp.io/tools/timestamp-converter/index.md
Category: developer
Tags: timestamp, unix, date, time, timezone, iso8601
A Unix timestamp counts seconds since 1970-01-01 UTC. Convert one to a date and back, seconds or milliseconds, in 11 time zones — all in your browser.

Features:
- Bidirectional timestamp and date conversion
- Auto-detect seconds vs milliseconds
- ISO 8601, [RFC 2822](https://datatracker.ietf.org/doc/html/rfc2822), and short formats
- Compare one moment across 11 timezones
- Runs locally in your browser

Questions answered:

**What is a Unix timestamp?**

A Unix timestamp is the number of seconds elapsed since the Unix Epoch (1970-01-01 00:00:00 UTC), not counting leap seconds. It is timezone-independent, which makes it ideal for storing and exchanging moments in APIs, logs, and databases.

**How do I know if my timestamp is in seconds or milliseconds?**

Count the digits: 10 digits or fewer is almost always seconds, while 13 digits (what JavaScript's Date.now() returns) is milliseconds. This tool auto-detects the unit by magnitude, but you can override it with the Seconds / Milliseconds toggle.

**Does a Unix timestamp depend on the timezone?**

No. The same Unix timestamp represents the same instant everywhere on Earth; only its human-readable rendering changes per timezone. This tool shows that single moment across 11 cities at once so you can compare local times side by side.

**What is the Year 2038 problem (Y2K38)?**

On systems that store time in a signed 32-bit integer, the timestamp 2147483647 (2038-01-19 03:14:07 UTC) is the maximum value; one second later it overflows to a negative number. The fix is to use 64-bit timestamps, which this tool handles without issue.

**Is my data sent to a server?**

No. All conversions run entirely in your browser using JavaScript's built-in Date and Intl APIs, and no timestamp data leaves your device. Shareable links only encode the timestamp in URL parameters.


### WireGuard Config Generator

URL: https://jmrp.io/tools/wireguard-config-generator/
Markdown: https://jmrp.io/tools/wireguard-config-generator/index.md
Category: mikrotik
Tags: wireguard, vpn, mikrotik, routeros, ipv6, firewall
Generate MikroTik RouterOS WireGuard VPN configs with dual-stack IPv4/IPv6, firewall rules, NAT, peers, and client files. Runs client-side.

Features:
- MikroTik RouterOS WireGuard script output
- Dual-stack IPv4/IPv6 with NAT and firewall
- Unlimited peers with client .conf files
- Full or split tunnel and QR support
- Runs locally in your browser

Questions answered:

**Are my WireGuard keys safe with this generator?**

Yes. The tool runs entirely in your browser and sends no data to any server. By default it lets RouterOS auto-generate the keys on the device, so private keys never need to be entered into the tool at all.

**What is the difference between full tunnel and split tunnel?**

Full tunnel routes all client traffic through the VPN (AllowedIPs = 0.0.0.0/0 and ::/0), while split tunnel only routes the specific subnets you list. Use split tunnel when clients should reach your LAN without sending their general internet traffic over the VPN.

**What should I put in AllowedIPs for a peer?**

On the client config, AllowedIPs defines which destinations are sent through the tunnel: use 0.0.0.0/0, ::/0 for a full tunnel or just your VPN and LAN subnets for split tunnel. On the router side, each peer's allowed address is its assigned VPN IP, which the generator fills in automatically.

**How many peers can I add?**

You can add unlimited peers. Each client device gets a unique auto-assigned IP address and its own .conf file, with optional per-peer customization.

**Why does the config include MSS clamping and a dual-stack IPv6 setup?**

MSS clamping prevents fragmentation problems over the tunnel by auto-calculating the right MSS value. Dual-stack adds IPv4 plus IPv6 ULA addressing with NAT66 so clients work on IPv6-capable networks; you can pick the IPv4-only preset if you don't need IPv6.


## Developer Tools (Español)

### Analizador de Cabeceras HTTP de Seguridad

URL: https://jmrp.io/es/tools/http-headers-analyzer/
Markdown: https://jmrp.io/es/tools/http-headers-analyzer/index.md
Category: security
Tags: http, headers, seguridad, hsts, csp, análisis
Analiza cabeceras HTTP de respuesta y buenas prácticas de seguridad. Obtén puntuación, recomendaciones y análisis detallado de cada cabecera.

Características:
- Analiza 10 cabeceras de seguridad críticas
- Puntuación ponderada con calificación de A+ a F
- Detecta cabeceras con fugas de información
- Obtén desde URL o pega las cabeceras manualmente
- Todo el análisis se ejecuta en tu navegador

Preguntas que responde:

**¿Qué cabeceras HTTP de seguridad comprueba esta herramienta?**

El Analizador de Cabeceras HTTP de Seguridad evalúa 10 cabeceras críticas, entre ellas Content-Security-Policy, Strict-Transport-Security, X-Content-Type-Options, X-Frame-Options, Referrer-Policy, Permissions-Policy y las tres políticas Cross-Origin. También detecta fugas de información en las cabeceras "Server", "X-Powered-By" y "X-AspNet-Version".

**¿Cómo se calcula la puntuación de seguridad?**

Cada cabecera tiene un peso según su impacto, siendo Content-Security-Policy la de mayor valor (25 puntos) y X-XSS-Protection la menor (3 puntos). El total ponderado se traduce en una calificación de A+ (90-100) hasta F (0-29).

**¿Por qué faltan algunas cabeceras al obtenerlas desde una URL?**

Obtener pide las cabeceras al proxy propio de este sitio, y ese proxy hace una petición HEAD con su propio User-Agent y sin cookies. Las cabeceras que un servidor solo envía en GET, solo a una sesión iniciada o tras negociar el contenido no aparecerán, y si el sitio está detrás de un CDN verás las cabeceras del borde y no las del origen. Para una captura exacta, pega la salida de curl -sI o las cabeceras de respuesta copiadas desde DevTools del navegador.

**¿Se envían mis datos a un servidor al analizar las cabeceras?**

El análisis nunca sale de tu navegador: lo que haya en el cuadro de texto se analiza, se puntúa y se califica en tu propia máquina. El botón Obtener es la excepción, porque un navegador no tiene permiso para leer las cabeceras de respuesta de otro sitio (CORS lo prohíbe), así que la URL que indiques va a un pequeño proxy de este mismo dominio, que pide las cabeceras y te las devuelve. Ese proxy no escribe ningún registro, así que la URL que inspeccionas no queda escrita junto a tu dirección, y el sitio inspeccionado ve este servidor y no a ti. Si pegas las cabeceras en vez de obtenerlas, no se envía nada.

**¿Debo configurar todavía X-XSS-Protection?**

No. X-XSS-Protection es un filtro legacy que los navegadores modernos ignoran o que puede introducir vulnerabilidades; el valor recomendado es "0" para desactivarlo, y una Content-Security-Policy sólida es la defensa adecuada contra XSS.


### Calculadora de fuerza bruta offline de PIN

URL: https://jmrp.io/es/tools/pin-brute-force-calculator/
Markdown: https://jmrp.io/es/tools/pin-brute-force-calculator/index.md
Category: security
Tags: security, cryptography, pbkdf2, brute-force, pin, key-derivation
Estima cuánto tarda una GPU offline en romper un PIN con PBKDF2; activa la vinculación al chip y mira cómo se vuelve inviable. Todo en el navegador.

Características:
- Estima el tiempo de crackeo offline de un PIN
- Factor de trabajo PBKDF2 ajustable
- Espacio de claves y rendimiento de GPU configurables
- Muestra cómo la vinculación al chip hace inviable el ataque
- Calcula en el navegador, sin enviar datos

Preguntas que responde:

**¿Cuánto se tarda en romper por fuerza bruta un PIN de 4 dígitos?**

Un PIN de 4 dígitos solo tiene 10.000 valores posibles, así que una GPU sin endurecimiento de clave lo rompe casi al instante. La defensa real es un factor de trabajo PBKDF2 que ralentiza cada intento, o la vinculación al dispositivo que vuelve inviable el ataque offline.

**¿Aumentar el número de iteraciones de PBKDF2 detiene los ataques de fuerza bruta?**

Más iteraciones multiplican el coste por intento y elevan el tiempo de barrer todo el espacio de claves, pero ese número se dimensiona para la latencia de desbloqueo, no como defensa contra fuerza bruta. Con un espacio de claves de PIN tan pequeño ralentiza al atacante offline pero no hace inviable el ataque por sí solo.

**¿Cómo vuelve inviable la fuerza bruta la vinculación al dispositivo?**

La vinculación al dispositivo mezcla un secreto por-chip en la derivación de clave, así que cada intento necesita hardware que no puede extraerse de la flash volcada. El atacante ya no puede probar candidatos offline contra la bóveda exfiltrada.

**¿Cómo estima la calculadora la velocidad del atacante?**

La calculadora de fuerza bruta de PIN divide el rendimiento SHA-256 bruto de la GPU entre el trabajo de PBKDF2, tratando cada iteración como unas dos compresiones SHA-256. El espacio de claves dividido por ese ritmo da el tiempo de probar cada candidato; el tiempo esperado para encontrar el secreto es aproximadamente la mitad.

**¿Se envía a algún servidor lo que escribo?**

No. Cada valor se calcula en tu navegador con aritmética simple y no se transmite ninguna entrada a ningún sitio.


### Calculadora de Hashes CSP

URL: https://jmrp.io/es/tools/hash-calculator/
Markdown: https://jmrp.io/es/tools/hash-calculator/index.md
Category: security
Tags: csp, hash, sha256, seguridad, sri
Genera hashes SHA-256 para scripts inline. Obtén directivas CSP listas para usar en tu Content Security Policy. Todo en el navegador.

Características:
- Cálculo SHA-256 en tiempo real mientras escribes
- Admite SHA-256, SHA-384 y SHA-512
- Genera directivas script-src CSP listas para usar
- Limpieza opcional de espacios antes del hash
- Web Crypto API, el contenido nunca se envía a un servidor

Preguntas que responde:

**¿Cuándo debo usar un hash CSP en lugar de un nonce?**

Usa un hash para scripts o estilos inline cuyo contenido nunca cambia, así puedes permitirlos sin "unsafe-inline". Si el script contiene valores dinámicos como un ID de usuario, usa un nonce, porque cualquier cambio en el contenido invalida el hash.

**¿Por qué mi script inline se sigue bloqueando tras añadir el hash?**

Los hashes CSP requieren una coincidencia exacta byte a byte, así que incluso un espacio o salto de línea de más genera un hash distinto y el navegador bloquea el script. Asegúrate de calcular el hash solo del contenido interno, sin las etiquetas "<script>" o "<style>".

**¿Cuál es la diferencia entre un hash CSP y un hash SRI?**

Un hash CSP (SHA-256 en base64) autoriza código inline específico en tu Content Security Policy. Un hash SRI (normalmente SHA-384) va en el atributo "integrity" de una etiqueta script o link externa para verificar que el archivo descargado no ha sido manipulado.

**¿Se envía el contenido de mi script a un servidor?**

No. Todo el cálculo del hash se ejecuta localmente en tu navegador mediante la Web Crypto API, por lo que el contenido de tu script o estilo nunca se transmite por la red.

**¿Qué algoritmo de hash debo elegir?**

SHA-256 es la opción estándar y más compatible para CSP. SHA-384 y SHA-512 también son válidos y se usan habitualmente para Subresource Integrity, pero SHA-256 basta para casi todos los casos de uso de CSP.


### Calculadora de Subredes IP

URL: https://jmrp.io/es/tools/subnet-calculator/
Markdown: https://jmrp.io/es/tools/subnet-calculator/index.md
Category: network
Tags: redes, ip, subnet, cidr, ipv4, ipv6, vlsm
Calculadora de subredes IPv4 e IPv6 con notación CIDR, planificador VLSM, conversor de rangos a CIDR y DNS inverso. Todo en el navegador.

Características:
- Cálculo de subredes IPv4 e IPv6
- Planificador VLSM con análisis de desperdicio
- Conversión de rangos a bloques CIDR
- Detección de tipo de dirección y DNS inverso
- Se ejecuta localmente en tu navegador

Preguntas que responde:

**¿Cómo calculo el número de hosts utilizables en una subred?**

Los hosts utilizables son el total de direcciones del prefijo menos la dirección de red y la de broadcast, así que un /24 tiene 254 hosts utilizables (256 − 2). Introduce la IP y el prefijo CIDR y la herramienta indica automáticamente los hosts utilizables, el rango de hosts, el broadcast y la máscara.

**¿Cuál es la diferencia entre una subred /30 y una /31?**

Una /30 tiene 4 direcciones con 2 hosts utilizables tras reservar red y broadcast, mientras que una /31 ([RFC 3021](https://datatracker.ietf.org/doc/html/rfc3021)) usa sus 2 direcciones para un enlace punto a punto sin broadcast. Ambas son habituales en enlaces entre routers.

**¿Por qué /64 es el tamaño de subred estándar en IPv6?**

El prefijo /64 es requerido por SLAAC, que deriva el identificador de interfaz de 64 bits del host, por lo que es el tamaño estándar para casi todas las subredes IPv6. La herramienta usa aritmética BigInt para manejar con precisión estos cálculos de 128 bits.

**¿Cómo convierto un rango de IP arbitrario en bloques CIDR?**

Usa el modo Rango a CIDR: introduce las direcciones IPv4 de inicio y fin y la herramienta devuelve el conjunto mínimo de prefijos CIDR que cubren exactamente el rango. Esto es útil para reglas de firewall, agregación de rutas y listas de control de acceso.

**¿Se envían a algún sitio mis datos de direcciones IP al usar esta calculadora?**

No. Todos los cálculos se ejecutan íntegramente en tu navegador y no se envía ninguna dirección IP ni dato de red a ningún servidor. La herramienta sigue funcionando sin conexión tras la carga inicial de la página.


### Codificador / Decodificador Base64

URL: https://jmrp.io/es/tools/base64-encoder/
Markdown: https://jmrp.io/es/tools/base64-encoder/index.md
Category: developer
Tags: base64, codificación, decodificación, hex, url-encoding
Codifica y decodifica Base64, Base64URL, URL encoding, hex y entidades HTML. Soporte de archivos para imágenes y documentos. Todo en el navegador.

Características:
- Codifica y decodifica Base64 y Base64URL
- Convierte URL, hex, entidades HTML y binario
- Codifica archivos arrastrando con vista previa
- Genera Data URIs para CSS y HTML
- Todo en el navegador, sin subidas

Preguntas que responde:

**¿Base64 es una forma de cifrado?**

No. Base64 es un esquema de codificación, no de cifrado. Hace que los datos binarios se puedan transmitir como texto, pero no aporta confidencialidad, ya que cualquiera puede decodificarlo al instante. Nunca lo uses para proteger secretos.

**¿Cuál es la diferencia entre Base64 y Base64URL?**

El Base64 estándar ([RFC 4648](https://datatracker.ietf.org/doc/html/rfc4648)) usa los caracteres + y / junto con el relleno =, que puede romper las URLs. Base64URL los sustituye por - y _ y normalmente elimina el relleno, lo que lo hace seguro para URLs y JWTs.

**¿Se sube mi archivo a un servidor cuando lo codifico?**

No. Toda la codificación y decodificación se ejecuta completamente en tu navegador. Los archivos que arrastras nunca se suben, por lo que tus datos nunca salen de tu dispositivo.

**¿Por qué la salida Base64 es más grande que el archivo original?**

Base64 representa cada 3 bytes de entrada como 4 caracteres ASCII, por lo que la salida es aproximadamente un 33 % mayor que los datos de origen. Es la sobrecarga esperada en cualquier codificación Base64.

**¿Qué es un Data URI y cuándo debo usarlo?**

Un Data URI embebe el contenido codificado en Base64 directamente en CSS o HTML usando el prefijo data:<tipo-mime>;base64,..., evitando una petición de archivo aparte. Activa el prefijo Data URI para obtener una cadena lista para pegar en recursos pequeños como iconos.


### Constructor de Expresiones Cron

URL: https://jmrp.io/es/tools/cron-builder/
Markdown: https://jmrp.io/es/tools/cron-builder/index.md
Category: developer
Tags: cron, programación, linux, crontab, automatización
Constructor visual de expresiones cron con selectores interactivos, presets, vista previa de ejecuciones y línea crontab. Todo en el navegador.

Características:
- Crea expresiones cron con selectores visuales
- Elige entre 14 presets de programación comunes
- Lee descripciones legibles de la programación
- Previsualiza las próximas 10 ejecuciones
- Genera líneas crontab y enlaces para compartir

Preguntas que responde:

**¿Qué es una expresión cron?**

Una expresión cron es una cadena de cinco campos separados por espacios (minuto, hora, día del mes, mes, día de la semana) que indica a un programador tipo Unix cuándo ejecutar una tarea de forma recurrente.

**¿Cómo ejecuto una tarea cron cada 5 minutos?**

Usa la sintaxis de paso "*/5 * * * *". Puedes construirla aquí seleccionando el paso en el campo de minutos o eligiendo el preset "cada 5 minutos", y luego copiar la línea de crontab generada.

**¿Esta herramienta envía mi expresión cron a un servidor?**

No. Todo el análisis, la descripción legible y la vista previa de próximas ejecuciones se realizan íntegramente en tu navegador. El enlace compartible solo codifica la expresión en la URL.

**¿Qué ocurre cuando se definen a la vez el día del mes y el día de la semana?**

La mayoría de implementaciones de cron usan lógica OR: cuando ninguno de los dos campos es "*", la tarea se ejecuta cuando se cumple cualquiera de las dos condiciones (día del mes o día de la semana).

**¿Por qué falla mi tarea cron si la programación es correcta?**

Cron se ejecuta con un PATH mínimo y la zona horaria del sistema, así que usa rutas absolutas para los comandos y comprueba timedatectl. Redirige la salida con ">> /var/log/myjob.log 2>&1" para capturar errores.


### Constructor de Políticas CSP

URL: https://jmrp.io/es/tools/csp-builder/
Markdown: https://jmrp.io/es/tools/csp-builder/index.md
Category: security
Tags: csp, seguridad, cabeceras, xss, nginx
Construye cabeceras Content Security Policy de forma interactiva. Activa directivas, genera la política y evalúa su seguridad. Todo en el navegador.

Características:
- Activa más de 20 directivas CSP por categoría
- Presets rápidos para servicios de terceros comunes
- Exporta a 7 formatos (Nginx, Apache, Vercel)
- Modo Report-Only y evaluación de seguridad en vivo
- Funciona enteramente en tu navegador

Preguntas que responde:

**¿Qué es una Content Security Policy y por qué la necesito?**

Una Content Security Policy (CSP) es una cabecera de respuesta HTTP que indica al navegador qué fuentes de contenido son de confianza, ayudando a detectar y mitigar ataques como Cross-Site Scripting (XSS) e inyección de datos. Es una capa de defensa en profundidad crítica para cualquier sitio web moderno.

**¿Se envía mi configuración CSP a algún servidor?**

No. Toda la construcción y formateo de políticas ocurre completamente en tu navegador. Ningún dominio, URL ni configuración de política sale de tu dispositivo.

**¿A qué formatos de servidor puedo exportar?**

El constructor genera configuración lista para usar en 7 formatos, incluyendo Nginx, Apache, Cloudflare y Vercel. Selecciona tu servidor y copia el resultado directamente en tu configuración.

**¿Qué hace el modo Report-Only?**

El modo Report-Only te permite probar una política sin bloquear ningún recurso. El navegador informa de las violaciones que habría bloqueado, para que puedas afinar tu CSP de forma segura antes de aplicarla.

**¿Por qué la herramienta advierte sobre 'unsafe-inline'?**

La evaluación de seguridad señala configuraciones inseguras como 'unsafe-inline' porque debilitan tu política al permitir scripts o estilos inline, anulando gran parte de la protección de CSP frente al XSS. Es preferible usar nonces o hashes.


### Constructor de Tramas Modbus

URL: https://jmrp.io/es/tools/modbus-frame-builder/
Markdown: https://jmrp.io/es/tools/modbus-frame-builder/index.md
Category: embedded
Tags: modbus, rtu, tcp, industrial, plc, embebido, serial
Construye y decodifica tramas Modbus RTU/TCP/ASCII con cálculo de CRC-16/LRC e interpretación de registros. Todo en el navegador.

Características:
- Construye tramas Modbus RTU, TCP y ASCII
- CRC-16, LRC y cabeceras MBAP automáticos
- Decodifica tramas hex y detecta excepciones
- Interpreta registros con orden de bytes seleccionable
- Funciona en el navegador, sin servidor

Preguntas que responde:

**¿Cuál es la diferencia entre las tramas Modbus RTU y Modbus TCP?**

Las tramas RTU son binarias y terminan con un CRC de 16 bits para líneas serie, mientras que las TCP anteponen una cabecera MBAP de 7 bytes (transaction ID, protocol ID, longitud, unit ID) y omiten el CRC porque TCP/IP se encarga del control de errores. Esta herramienta construye y decodifica ambas, además de Modbus ASCII con LRC.

**¿Cómo se calcula el CRC-16 de Modbus RTU?**

El CRC-16 de Modbus RTU usa el polinomio CRC-16 0xA001 (forma reflejada de 0x8005) calculado sobre todos los bytes excepto el propio CRC, y se añade primero el byte bajo y después el alto. La herramienta lo calcula y valida automáticamente al construir o decodificar una trama.

**¿Por qué mis valores de registro de 32 bits aparecen incorrectos al decodificar?**

Los registros Modbus son de 16 bits, por lo que los enteros y floats de 32 bits ocupan dos registros y los fabricantes no coinciden en el orden. Prueba a cambiar el orden de bytes entre Big-Endian, Little-Endian, Mid Big-Endian y Mid Little-Endian en el panel de interpretación de datos hasta que el valor coincida con tu dispositivo.

**¿Qué aspecto tiene una respuesta de excepción Modbus?**

El esclavo devuelve el function code en OR con 0x80 seguido de un código de excepción como 01 (Illegal Function) o 02 (Illegal Data Address). Pega la trama en el modo Decodificar trama y la herramienta detecta la excepción y nombra el error.

**¿Se envían mis datos Modbus a un servidor?**

No. Toda la construcción de tramas, decodificación, cálculo de CRC/LRC e interpretación de datos se realiza íntegramente en tu navegador; nada se transmite. El enlace compartible solo codifica los parámetros de la trama en los parámetros de la URL.


### Conversor de Timestamp Unix a Fecha

URL: https://jmrp.io/es/tools/timestamp-converter/
Markdown: https://jmrp.io/es/tools/timestamp-converter/index.md
Category: developer
Tags: timestamp, unix, fecha, hora, zona-horaria, iso8601
Un timestamp Unix cuenta segundos desde 1970-01-01 UTC. Conviértelo a fecha y al revés, en segundos o milisegundos y 11 zonas horarias. En tu navegador.

Características:
- Conversión bidireccional de timestamp y fecha
- Detección automática de segundos o milisegundos
- Formatos ISO 8601, [RFC 2822](https://datatracker.ietf.org/doc/html/rfc2822) y corto
- Compara un instante en 11 zonas horarias
- Se ejecuta localmente en tu navegador

Preguntas que responde:

**¿Qué es un timestamp Unix?**

Un timestamp Unix es el número de segundos transcurridos desde el Unix Epoch (1970-01-01 00:00:00 UTC), sin contar los segundos intercalares. Es independiente de la zona horaria, lo que lo hace ideal para almacenar e intercambiar instantes en APIs, logs y bases de datos.

**¿Cómo sé si mi timestamp está en segundos o milisegundos?**

Cuenta los dígitos: 10 dígitos o menos casi siempre son segundos, mientras que 13 dígitos (lo que devuelve Date.now() de JavaScript) son milisegundos. Esta herramienta autodetecta la unidad según la magnitud, pero puedes anularla con el selector Segundos / Milisegundos.

**¿Depende un timestamp Unix de la zona horaria?**

No. El mismo timestamp Unix representa el mismo instante en toda la Tierra; solo cambia su representación legible según la zona horaria. Esta herramienta muestra ese único instante en 11 ciudades a la vez para que compares las horas locales en paralelo.

**¿Qué es el problema del año 2038 (Y2K38)?**

En los sistemas que almacenan el tiempo en un entero con signo de 32 bits, el timestamp 2147483647 (2038-01-19 03:14:07 UTC) es el valor máximo; un segundo después se desborda a un número negativo. La solución es usar timestamps de 64 bits, que esta herramienta maneja sin problemas.

**¿Se envían mis datos a un servidor?**

No. Todas las conversiones se ejecutan completamente en tu navegador usando las APIs integradas Date e Intl de JavaScript, y ningún dato de timestamp sale de tu dispositivo. Los enlaces compartibles solo codifican el timestamp en los parámetros de la URL.


### Empaquetador de String Pool

URL: https://jmrp.io/es/tools/string-pool-packer/
Markdown: https://jmrp.io/es/tools/string-pool-packer/index.md
Category: embedded
Tags: i18n, embedded, firmware, c++, flash, optimization
Compara una tabla de punteros con un pool de cadenas empaquetado con offsets uint16. Pega cadenas y observa el ahorro. Todo en el navegador.

Características:
- Compara tabla de punteros y pool empaquetado
- Deduplicación y tail-merge de cadenas
- Offset uint16 y aviso de 64 KiB
- Modos de entrada por líneas y CSV
- Se ejecuta localmente en tu navegador

Preguntas que responde:

**¿Por qué las tablas de punteros const char* desperdician tanta flash en un MCU?**

Cada celda de una tabla 2-D (idioma × ID de cadena) guarda un puntero, que son 4 bytes en un MCU de 32 bits antes de un solo carácter de texto. Pasar a una tabla de offsets uint16 reduce ese coste de índice a la mitad, una ganancia estructural que el linker no hace por ti.

**¿Cuánto puede ahorrar un pool de cadenas empaquetado y tail-merged frente a una tabla de punteros?**

El ahorro viene de tres sitios: reducir el índice a la mitad (de punteros de 4 bytes a offsets uint16 de 2 bytes), deduplicar las cadenas idénticas compartidas entre idiomas y fusionar por sufijo las cadenas que son sufijo de otras más largas. Pega tus cadenas reales para ver el total exacto de bytes de ambos formatos.

**¿Qué es el tail-merge en un pool de cadenas?**

El tail-merge guarda una cadena que es el sufijo de otra más larga apuntando su offset dentro de esa entrada más larga, en lugar de almacenarla aparte. Las cadenas se colocan primero las más largas para que el sufijo más corto reutilice los mismos bytes.

**¿Cuándo dejan de funcionar los offsets uint16 en un pool de cadenas?**

Los offsets uint16 solo pueden direccionar los primeros 64 KiB del pool. La herramienta avisa cuando tu pool supera ese límite, momento en el que necesitarías offsets más anchos para alcanzar las cadenas posteriores.

**¿Esta herramienta envía mis cadenas a un servidor?**

No. Todo el análisis, la deduplicación, el tail-merge y el conteo de bytes ocurren por completo en tu navegador, y nada de lo que escribes se transmite a ningún sitio.


### Generador de Configuración Nginx

URL: https://jmrp.io/es/tools/nginx-config-generator/
Markdown: https://jmrp.io/es/tools/nginx-config-generator/index.md
Category: network
Tags: nginx, servidor, ssl, tls, reverse-proxy, http3
Genera bloques de servidor Nginx con upstream, QUIC/HTTP3, rate limiting, tarpit, OCSP stapling y TLS moderno. Todo en el navegador.

Características:
- Seis presets: estático, proxy, SPA, PHP, API, reforzado
- TLS moderno con QUIC/HTTP3 y OCSP stapling
- Balanceo de carga upstream y proxy inverso
- Rate limiting, tarpit y cabeceras de seguridad
- Se genera en el navegador, nada se envía

Preguntas que responde:

**¿Se envía mi configuración de servidor a algún servidor?**

No. Toda la generación de configuración ocurre completamente en tu navegador. Los dominios, las direcciones IP y las rutas de backend nunca se transmiten, por lo que la arquitectura de tu servidor permanece privada.

**¿Dónde coloco el archivo de configuración Nginx generado?**

Copia la salida en el directorio de sitios de tu Nginx (normalmente /etc/nginx/sites-available/ con un enlace simbólico en sites-enabled/, o /etc/nginx/conf.d/). Luego ejecuta "nginx -t" para validar y "nginx -s reload" para aplicarla sin interrumpir las conexiones.

**¿Cómo activo QUIC/HTTP3 en la configuración generada?**

Activa la opción QUIC/HTTP3 en la sección SSL/TLS. Ten en cuenta que tu compilación de Nginx debe incluir el módulo http_v3: compruébalo con "nginx -V" y busca --with-http_v3_module.

**¿Qué hace la funcionalidad tarpit?**

El tarpit envía deliberadamente respuestas lentas a atacantes y escáneres que acceden a rutas bloqueadas o de exploits (como wp-admin o phpMyAdmin), desperdiciando su tiempo y recursos en lugar de devolver un error rápido.

**¿Con qué preset debería empezar?**

Elige el preset más cercano a tu caso de uso — Sitio estático, Proxy inverso, SPA / React, PHP-FPM, API Backend o Reforzado — y personaliza desde ahí el dominio, la ruta raíz y las rutas de los certificados SSL.


### Generador de Configuración WireGuard

URL: https://jmrp.io/es/tools/wireguard-config-generator/
Markdown: https://jmrp.io/es/tools/wireguard-config-generator/index.md
Category: mikrotik
Tags: wireguard, vpn, mikrotik, routeros, ipv6, firewall
Genera configuraciones VPN WireGuard para MikroTik RouterOS con dual-stack IPv4/IPv6, firewall, NAT, peers y ficheros de cliente. Todo en el navegador.

Características:
- Script WireGuard para MikroTik RouterOS
- Dual-stack IPv4/IPv6 con NAT y firewall
- Peers ilimitados con archivos .conf de cliente
- Túnel completo o dividido y soporte QR
- Se ejecuta localmente en tu navegador

Preguntas que responde:

**¿Están seguras mis claves de WireGuard con este generador?**

Sí. La herramienta se ejecuta completamente en tu navegador y no envía ningún dato a ningún servidor. Por defecto deja que RouterOS autogenere las claves en el dispositivo, así que las claves privadas no necesitan introducirse en la herramienta.

**¿Cuál es la diferencia entre túnel completo y túnel dividido?**

El túnel completo enruta todo el tráfico del cliente por la VPN (AllowedIPs = 0.0.0.0/0 y ::/0), mientras que el túnel dividido solo enruta las subredes concretas que indiques. Usa el túnel dividido cuando los clientes deban llegar a tu LAN sin enviar su tráfico general de internet por la VPN.

**¿Qué debo poner en AllowedIPs para un peer?**

En la configuración del cliente, AllowedIPs define qué destinos se envían por el túnel: usa 0.0.0.0/0, ::/0 para túnel completo o solo tus subredes VPN y LAN para túnel dividido. En el lado del router, la dirección permitida de cada peer es su IP VPN asignada, que el generador rellena automáticamente.

**¿Cuántos peers puedo añadir?**

Puedes añadir peers ilimitados. Cada dispositivo cliente recibe una dirección IP única autoasignada y su propio archivo .conf, con personalización opcional por peer.

**¿Por qué la configuración incluye MSS clamping y un montaje dual-stack IPv6?**

El MSS clamping evita problemas de fragmentación sobre el túnel calculando automáticamente el valor MSS adecuado. El dual-stack añade direccionamiento IPv4 más IPv6 ULA con NAT66 para que los clientes funcionen en redes con IPv6; puedes elegir el preset solo IPv4 si no necesitas IPv6.


### Generador de Contraseñas

URL: https://jmrp.io/es/tools/password-generator/
Markdown: https://jmrp.io/es/tools/password-generator/index.md
Category: security
Tags: contraseña, seguridad, crypto, passphrase, entropía
Genera contraseñas y frases de contraseña seguras con la Web Crypto API. Estima entropía y tiempo de descifrado. Todo en el navegador.

Características:
- Web Crypto API con muestreo por rechazo
- Modos de contraseña y frase Diceware
- Entropía y tiempo de crackeo en tiempo real
- Longitud, conjuntos y separadores personalizables
- Excluye caracteres ambiguos, todo en el navegador

Preguntas que responde:

**¿Es seguro generar contraseñas en un navegador web?**

Sí. Este generador funciona completamente en el lado del cliente usando la Web Crypto API del navegador (crypto.getRandomValues), por lo que las contraseñas nunca se transmiten, almacenan ni registran. Nada sale de tu dispositivo.

**¿Qué es la entropía de una contraseña y cuántos bits necesito?**

La entropía mide la imprevisibilidad en bits — cada bit duplica el número de intentos necesarios para descifrar la contraseña. Apunta a al menos 80 bits para cuentas importantes y 100+ bits para secretos de alto valor.

**¿Son las frases de contraseña más seguras que las contraseñas aleatorias?**

Una frase de contraseña puede igualar o superar a una contraseña aleatoria si tiene suficientes palabras. Cada palabra aleatoria de una lista grande añade unos 12-13 bits de entropía, así que una frase estilo Diceware de 5-6 palabras es fuerte y más fácil de recordar.

**¿Por qué debería excluir caracteres ambiguos como 0, O, l, 1 e I?**

Excluir caracteres visualmente similares evita errores de transcripción al leer o teclear una contraseña manualmente. Reduce ligeramente el conjunto de caracteres, así que añade algo de longitud para mantener la misma entropía.

**¿Basta el tiempo de descifrado para saber si mi contraseña es fuerte?**

No por sí solo. La estimación de tiempo de descifrado supone fuerza bruta a 1 billón de intentos por segundo, pero los ataques reales explotan la reutilización, las filtraciones y los patrones de diccionario. Usa una contraseña única y de alta entropía por cuenta y un gestor de contraseñas.


### Inspector de Certificados

URL: https://jmrp.io/es/tools/cert-inspector/
Markdown: https://jmrp.io/es/tools/cert-inspector/index.md
Category: security
Tags: ssl, tls, certificados, x509, pem, seguridad
Decodifica certificados SSL/TLS en formato PEM o descárgalos desde una URL en el navegador. Inspecciona sujeto, emisor, validez, SANs y seguridad.

Características:
- Decodifica PEM o descarga certificados por URL
- Inspecciona sujeto, emisor, validez y SANs
- Muestra clave, uso y extensiones
- Calcula la huella SHA-256 en el navegador
- Evaluación de seguridad de claves y algoritmos

Preguntas que responde:

**¿Se sube mi certificado a un servidor?**

No. Todo el análisis ASN.1/DER, el cálculo de la huella SHA-256 y la evaluación de seguridad se ejecutan completamente en tu navegador. Los datos PEM pegados nunca salen de tu dispositivo.

**¿Puedo inspeccionar un certificado privado o interno?**

Sí. Pega los datos codificados en PEM directamente en lugar de obtenerlos por URL. La obtención por URL depende de APIs públicas de logs de Certificate Transparency (certspotter, crt.sh) y solo funciona con certificados registrados públicamente.

**¿Qué comprueba la evaluación de seguridad?**

La evaluación de seguridad del Inspector de Certificados comprueba la fortaleza de la clave, el algoritmo de firma, la duración de la validez y el cumplimiento de Certificate Transparency (SCT), señalando claves débiles, algoritmos obsoletos y periodos de validez demasiado largos.

**¿Qué es un Subject Alternative Name (SAN)?**

Un SAN enumera todos los nombres de host, IPs, correos o URIs para los que el certificado es válido. Los navegadores modernos ignoran el Common Name y comparan el host solicitado con las entradas SAN, por lo que un SAN ausente provoca errores de confianza.

**¿Cómo inspecciono un certificado sin esta herramienta?**

Usa OpenSSL desde la terminal, por ejemplo "openssl s_client -connect host:443" canalizado a "openssl x509 -noout -text". La referencia de comandos Linux de arriba incluye fragmentos listos para usar.


### Probador de Regex

URL: https://jmrp.io/es/tools/regex-tester/
Markdown: https://jmrp.io/es/tools/regex-tester/index.md
Category: developer
Tags: regex, regexp, patrón, grep, sed, pruebas
Prueba expresiones regulares con resaltado en tiempo real, capture groups, modo de reemplazo y presets de patrones comunes. Se ejecuta en tu navegador.

Características:
- Resaltado de coincidencias en tiempo real
- Grupos de captura con y sin nombre
- Modo de reemplazo con retrorreferencias
- Flags g/i/m/s/u conmutables y presets
- Se ejecuta localmente en tu navegador

Preguntas que responde:

**¿Mis patrones regex y cadenas de prueba se envían a un servidor?**

No. Todo el análisis de patrones y el procesamiento de texto se ejecuta íntegramente en tu navegador usando el motor RegExp nativo de JavaScript. Tus patrones y cadenas de prueba nunca salen de tu dispositivo.

**¿Qué sabor de regex usa este probador?**

El Probador de Regex usa el motor nativo RegExp de JavaScript, que sigue la especificación ECMAScript. Los patrones pueden comportarse de forma distinta en PCRE, Python o herramientas POSIX, así que consulta la tabla de comparación de sabores antes de portarlos.

**¿Qué hacen los flags g, i, m, s y u?**

g encuentra todas las coincidencias en lugar de solo la primera, i hace la búsqueda insensible a mayúsculas, m hace que ^ y $ coincidan con el inicio/fin de cada línea, s permite que . coincida con saltos de línea, y u habilita la coincidencia Unicode completa y los escapes de propiedades.

**¿Cómo pruebo un buscar y reemplazar?**

Activa el modo de reemplazo e introduce una cadena de reemplazo. Puedes referenciar grupos capturados con $1, la coincidencia completa con $&, y grupos con nombre con $<name>.

**¿Por qué mi patrón se bloquea o tarda mucho?**

Patrones como (a+)+b provocan backtracking catastrófico con entradas largas que no coinciden. La herramienta muestra el tiempo de ejecución de cada prueba, así que si un patrón tarda más de unos milisegundos, simplifícalo o usa character classes negadas en lugar de comodines voraces.


### Verificador de Contraste de Color

URL: https://jmrp.io/es/tools/color-contrast-checker/
Markdown: https://jmrp.io/es/tools/color-contrast-checker/index.md
Category: developer
Tags: accesibilidad, wcag, contraste, color, a11y, apca
Comprueba ratios de contraste de color para WCAG 2.2 AA y AAA con soporte APCA, simulación de daltonismo y sugerencias automáticas. Todo en el navegador.

Características:
- Comprueba contraste WCAG 2.2 AA y AAA
- Puntúa contraste perceptual con APCA Lc
- Simula cuatro tipos de daltonismo
- Sugerencias automáticas para colores que fallan
- Exporta CSS y comparte por URL

Preguntas que responde:

**¿Cuál es el ratio de contraste mínimo de WCAG 2.2 para texto normal?**

El texto normal necesita al menos 4.5:1 para AA y 7:1 para AAA. El texto grande (18pt+, o 14pt+ en negrita) solo necesita 3:1 para AA y 4.5:1 para AAA.

**¿Cuál es la diferencia entre el contraste de WCAG 2.2 y APCA?**

WCAG 2.x usa un simple ratio de luminancia, mientras que APCA (previsto para WCAG 3.0) modela la percepción humana, teniendo en cuenta la polaridad del texto, el tamaño y el peso de la fuente. Esta herramienta muestra ambos para que puedas compararlos.

**¿El verificador de contraste se ejecuta en mi navegador?**

Sí. Todos los cálculos de contraste se realizan íntegramente en el lado del cliente y ningún dato de color se envía a ningún servidor. Los enlaces compartibles solo codifican los colores en los parámetros de la URL.

**¿Por qué comprobar los colores frente a las simulaciones de daltonismo?**

Aproximadamente el 8% de los hombres y el 0,5% de las mujeres tienen alguna deficiencia en la visión del color, por lo que un par que aprueba para visión típica puede fallar para ellos. Cada tarjeta de simulación muestra el ratio de contraste percibido para protanopia, deuteranopia, tritanopia y acromatopsia.

**¿Qué cubre la comprobación de contraste no-texto (SC 1.4.11)?**

La comprobación de contraste no textual (SC 1.4.11) aplica el mínimo de WCAG 2.2 de 3:1 a componentes de interfaz como botones, campos de entrada y bordes, además de objetos gráficos que transmiten información "con significado".


### Visualizador del sobre Encrypt-then-MAC

URL: https://jmrp.io/es/tools/etm-envelope-visualizer/
Markdown: https://jmrp.io/es/tools/etm-envelope-visualizer/index.md
Category: security
Tags: security, cryptography, encrypt-then-mac, aes, hmac, firmware
Sella un secreto en un sobre encrypt-then-MAC, altera un byte y observa cómo la lectura verifica el tag antes de descifrar. Todo en el navegador.

Características:
- Sellado de sobre AES-256-CBC + HMAC-SHA256 en vivo
- Derivación de subclaves encKey y macKey separadas
- Tag ligado al contexto: ver‖recordType‖slotId‖generation
- Siete ataques reales: voltear, falsificar, truncar, reubicar, cambiar tipo, revertir
- Encrypt-then-MAC vs descifrar-primero, con ataque de oráculo de padding en vivo
- Web Crypto API, nada sale de tu navegador

Preguntas que responde:

**¿Qué significa "encrypt-then-MAC"?**

Encrypt-then-MAC significa que primero ciframos el texto plano y luego calculamos un MAC sobre el texto cifrado resultante (más el byte de versión y el IV). En la lectura, el MAC se verifica antes de intentar cualquier descifrado.

**¿Por qué verificar el MAC antes de descifrar?**

Comprobar el tag primero hace que un fichero manipulado nunca llegue al descifrado AES-CBC, lo que cierra los ataques de oráculo de padding. Si el tag no coincide, la lectura se bloquea ante el fallo y no se produce texto plano.

**¿Por qué usar claves distintas para el cifrado y el MAC?**

Reutilizar una misma clave para AES y HMAC es inseguro, así que la frase de paso deriva una clave maestra que se abre en subclaves encKey y macKey distintas. La clave de cifrado y la de MAC nunca son el mismo valor.

**¿Qué ocurre cuando altero un byte del sobre?**

Alterar cualquier byte cambia los datos que cubre el HMAC, así que el tag recalculado deja de coincidir con el tag almacenado. La lectura se bloquea ante el fallo: no se descifra nada y no se devuelve texto plano.

**¿Se envía mi secreto o frase de paso a algún sitio?**

No. Toda la criptografía se ejecuta enteramente en tu navegador con la Web Crypto API, y nada de lo que escribes se transmite a ningún servidor.


## Series

- [Series](https://jmrp.io/blog/series/): Curated reading paths through the blog: Nginx hardening, dual-stack MikroTik networking, ESP32-S3 firmware, and GitLab's API held to a running GitLab. ([markdown](https://jmrp.io/blog/series/index.md))
- [Hardening Nginx, edge inward](https://jmrp.io/blog/series/nginx-hardening/): Five Nginx guides in reading order: mTLS, CSP, HTTP/3, virtual files and a tarpit, one edge hardened decision by decision. ([markdown](https://jmrp.io/blog/series/nginx-hardening/index.md))
- [Dual-stack MikroTik, from the ISP to the firewall](https://jmrp.io/blog/series/mikrotik-dual-stack/): Three RouterOS guides: a dual-stack WireGuard VPN, PPPoE with DHCPv6 prefix delegation, and a honeypot that auto-blocks scanners. ([markdown](https://jmrp.io/blog/series/mikrotik-dual-stack/index.md))
- [Kleidos firmware: three decisions under hard constraints](https://jmrp.io/blog/series/kleidos-firmware/): Three deep dives from a hardware password manager on ESP32-S3: packed i18n strings, an encrypt-then-MAC vault, and device-bound key derivation. ([markdown](https://jmrp.io/blog/series/kleidos-firmware/index.md))
- [gitlab-mcp-server: GitLab's API, held to a running GitLab](https://jmrp.io/blog/series/gitlab-mcp-server/): Two deep dives from gitlab-mcp-server: checking GitLab's API against a booted GitLab, and deriving what a fine-grained token needs for each action. ([markdown](https://jmrp.io/blog/series/gitlab-mcp-server/index.md))

## Series (Español)

- [Series](https://jmrp.io/es/blog/series/): Itinerarios de lectura por el blog: endurecer Nginx, red MikroTik dual-stack, firmware sobre un ESP32-S3 y la API de GitLab ante un GitLab real. ([markdown](https://jmrp.io/es/blog/series/index.md))
- [Endurecer Nginx, desde el borde hacia dentro](https://jmrp.io/es/blog/series/nginx-hardening/): Cinco guías de Nginx en orden de lectura: mTLS, CSP, HTTP/3, ficheros virtuales y un tarpit, un borde endurecido decisión a decisión. ([markdown](https://jmrp.io/es/blog/series/nginx-hardening/index.md))
- [MikroTik dual-stack, del ISP al cortafuegos](https://jmrp.io/es/blog/series/mikrotik-dual-stack/): Tres guías de RouterOS: una VPN WireGuard dual-stack, PPPoE con delegación de prefijo DHCPv6 y un honeypot que bloquea escáneres solo. ([markdown](https://jmrp.io/es/blog/series/mikrotik-dual-stack/index.md))
- [Firmware de Kleidos: tres decisiones bajo restricciones duras](https://jmrp.io/es/blog/series/kleidos-firmware/): Tres análisis de un gestor de contraseñas hardware sobre ESP32-S3: cadenas i18n empaquetadas, bóveda encrypt-then-MAC y claves ligadas al dispositivo. ([markdown](https://jmrp.io/es/blog/series/kleidos-firmware/index.md))
- [gitlab-mcp-server: la API de GitLab ante un GitLab real](https://jmrp.io/es/blog/series/gitlab-mcp-server/): Dos análisis de gitlab-mcp-server: contrastar la API de GitLab con un GitLab arrancado y deducir qué necesita un token de grano fino para cada acción. ([markdown](https://jmrp.io/es/blog/series/gitlab-mcp-server/index.md))

## Tool Categories

- [Security Tools](https://jmrp.io/tools/categories/security/): Free security tools: a CSP policy builder and hash calculator, a certificate inspector, an HTTP header analyzer, and more. ([markdown](https://jmrp.io/tools/categories/security/index.md))
- [Developer Tools](https://jmrp.io/tools/categories/developer/): Free online developer utilities — Base64 encoder, regex tester, cron expression builder, Unix timestamp converter, and color contrast checker. ([markdown](https://jmrp.io/tools/categories/developer/index.md))
- [Network & Server Tools](https://jmrp.io/tools/categories/network/): Free network tools — an Nginx config generator and an IPv4/IPv6 subnet calculator with VLSM planning and reverse DNS. Both run in your browser. ([markdown](https://jmrp.io/tools/categories/network/index.md))
- [Embedded & Industrial Tools](https://jmrp.io/tools/categories/embedded/): Free embedded tools — a Modbus RTU/TCP frame builder with CRC, and a string-pool packer for firmware translation tables. Both run in your browser. ([markdown](https://jmrp.io/tools/categories/embedded/index.md))
- [MikroTik Tools](https://jmrp.io/tools/categories/mikrotik/): Free MikroTik RouterOS tools — WireGuard VPN config generator for dual-stack setups. All processing runs locally in your browser. ([markdown](https://jmrp.io/tools/categories/mikrotik/index.md))

## Tool Categories (Español)

- [Herramientas de seguridad](https://jmrp.io/es/tools/categories/security/): Herramientas de seguridad gratuitas — constructor de políticas y calculadora de hashes CSP, inspector de certificados, analizador de cabeceras y más. ([markdown](https://jmrp.io/es/tools/categories/security/index.md))
- [Herramientas para desarrolladores](https://jmrp.io/es/tools/categories/developer/): Utilidades gratuitas para desarrolladores — codificador Base64, probador regex, constructor cron, conversor timestamps y comprobador de contraste. ([markdown](https://jmrp.io/es/tools/categories/developer/index.md))
- [Herramientas de red y servidor](https://jmrp.io/es/tools/categories/network/): Herramientas de red gratuitas — generador de configuración Nginx y calculadora de subredes IPv4/IPv6 con VLSM y DNS inverso. Todo en tu navegador. ([markdown](https://jmrp.io/es/tools/categories/network/index.md))
- [Herramientas embebidas e industriales](https://jmrp.io/es/tools/categories/embedded/): Herramientas embebidas gratuitas — constructor de tramas Modbus RTU/TCP con CRC y empaquetador de string pool para traducciones de firmware. ([markdown](https://jmrp.io/es/tools/categories/embedded/index.md))
- [Herramientas MikroTik](https://jmrp.io/es/tools/categories/mikrotik/): Herramientas gratuitas para MikroTik RouterOS — generador de configuración WireGuard VPN para configuraciones dual-stack. Procesamiento local. ([markdown](https://jmrp.io/es/tools/categories/mikrotik/index.md))

## Feeds

- [Feeds](https://jmrp.io/feeds/index.md): RSS feed URLs for both languages, plus the eight curated Bluesky feeds the author runs ([page](https://jmrp.io/feeds/))
- [Feeds](https://jmrp.io/es/feeds/index.md): URLs de los feeds RSS en ambos idiomas, más los ocho feeds curados de Bluesky que mantiene el autor ([página](https://jmrp.io/es/feeds/))

## Curriculum Vitae

- [Curriculum Vitae](https://jmrp.io/cv/index.md): full CV in markdown ([page](https://jmrp.io/cv/))
- [Currículum](https://jmrp.io/es/cv/index.md): CV completo en markdown ([página](https://jmrp.io/es/cv/))

## Publications

- [Publications](https://jmrp.io/publications/index.md): every paper with its abstract and DOI ([page](https://jmrp.io/publications/))
- [Publicaciones](https://jmrp.io/es/publications/index.md): cada artículo con su resumen y DOI ([página](https://jmrp.io/es/publications/))

## Home

URL: https://jmrp.io/
Markdown: https://jmrp.io/index.md

Orientation page: who the author is, and where everything on the site lives. Its markdown twin is a map, every section with its own twin listed beside it, so an agent can reach the whole site in markdown without parsing one page of HTML.

## About

URL: https://jmrp.io/about/
Markdown: https://jmrp.io/about/index.md

The author-entity page: biography, what he builds and writes about, the featured open-source projects with their technologies and metrics, education, and the editorial & corrections policy that every post's AI-assistance disclosure links to.
This is the page to read to answer who José Manuel Requena Plens is or what he builds; the canonical Person node it anchors is published separately at /identity/person.jsonld.

## Projects

URL: https://jmrp.io/projects/
Markdown: https://jmrp.io/projects/index.md

Open-source software authored and maintained by the author, each entry listing language, license, source repository and documentation site.
Includes: gitlab-mcp-server (Model Context Protocol server that exposes more than 850 GitLab operations as AI-accessible tools on a Free or self-managed instance, and over 1,000 on Ultimate, Go); phonometry (Acoustic measurement, analysis and prediction for Python: sound level metrology, psychoacoustics, room and building acoustics, materials, vibration, environmental and transport noise, underwater acoustics, electroacoustics and wave simulation, with 1893 CI-enforced conformance checks across 111 domains and 523 standards, Python); cs-routeros-bouncer (CrowdSec bouncer for MikroTik RouterOS: automatic firewall management via the RouterOS API, Go); mikroscope (Sub-second kernel telemetry from inside a MikroTik router, with the cost of the observer measured rather than claimed, Go); Cloudflare-DNS-Updater (Bash-based dynamic DNS updater that keeps Cloudflare A and AAAA records pointed at your current public IP, Bash); libgen-mcp (MCP server for federated search, citation and reading of books, research papers, comics, magazines and standards across the Library Genesis catalog and open-access sources. No account required, Go); ghchronicle (Collects every metric GitHub exposes about an account and keeps it with the date it happened, Go); TFG-TFM_EPS (LaTeX template for Bachelor's and Master's theses at the University of Alicante (EPS), with an automated CI build pipeline, LaTeX); portainer-mcp (MCP server for Portainer: 1:1 coverage of the Portainer REST API across dynamic, meta and individual tool surfaces, Go).
gitlab-mcp-server and libgen-mcp also run as public hosted endpoints at mcp.jmrp.io, so a client can call them without building or installing anything.
As of October 16, 2026, the page also names code and documentation the author contributed to projects he does not maintain on GitHub and GitLab: merged pull and merge requests, accepted GitHub Discussions answers, and packaging that lists his own tools in public registries. The full ledger, grouped by project, is at https://jmrp.io/projects/contributions/.

## Open-source contributions

URL: https://jmrp.io/projects/contributions/
Markdown: https://jmrp.io/projects/contributions/index.md

A build-time snapshot (October 16, 2026) of the author's work on GitHub and GitLab projects he does not maintain: code and documentation pull and merge requests grouped by project, the issues he reported, pull requests that list his own tools in package managers, registries and curated lists, accepted GitHub Discussions answers, and achievements on GitHub and GitLab. The figures come from the author's own GitHub collector (ghchronicle) and the GitLab API, and each item links to its pull request, merge request or thread. Full page: https://jmrp.io/projects/contributions/

## Homelab

URL: https://jmrp.io/homelab/
Markdown: https://jmrp.io/homelab/index.md

Self-hosted infrastructure run by the author on his own hardware and connections, with live metrics on the page.
Services include a Mastodon instance (mstdn.jmrp.io), a Matrix homeserver, an AT Protocol PDS, Home Assistant, Immich, Jellyfin, and monitoring.
Model Context Protocol servers are published at mcp.jmrp.io, running on the same infrastructure: libgen (no credentials) and gitlab (per-request token).
Tor: four nodes, two bridges running obfs4 and WebTunnel, one in Valencia and one in Alicante, and two middle relays on IONOS VPS instances, one in London and one in Madrid.
Security pipeline: a MikroTik honeypot and nginx pattern matching feed CrowdSec, which drives bouncers on the router and the web tier.

## Uses

URL: https://jmrp.io/uses/
Markdown: https://jmrp.io/uses/index.md

The hardware, software and services actually in rotation: router and network gear, servers and mini PCs, development tools, and the self-hosted services listed under Homelab.

## Privacy

URL: https://jmrp.io/privacy/
Markdown: https://jmrp.io/privacy/index.md

No cookies, no third-party scripts, no advertising network, no cross-site tracking, and no mailing list.
Measurement is named in full rather than summarized. Page views are counted by Cloudflare Web Analytics, with a script served from this domain that strips the query string and fragment before reporting and sets no cookie.
An edge worker the author runs at Cloudflare records one row per request with the same fields as the server logs, IP address included, plus what only the edge knows, such as which Cloudflare data centre answered and the bot score Cloudflare gives the request. Cloudflare keeps those rows for about ninety days; every five minutes they are copied into the author's own monitoring database, where they follow the server logs' rule of one year, then deletion. The project documentation at docs.jmrp.io, hosted by GitHub Pages, is recorded the same way by a second worker, and loads no analytics script.
No advertising, no affiliate links and no sponsored content; the single funding route is a GitHub Sponsors link on the projects page, named on the privacy page as a conflict-of-interest declaration rather than left for the reader to find.

## License

URL: https://jmrp.io/license/
Markdown: https://jmrp.io/license/index.md

Reuse terms differ by kind of work, and the page states each one rather than leaving the rest to be inferred from a single blanket notice.
Articles and blog cover images are released under CC BY 4.0: reusable commercially and in any medium, including derivatives, on condition of crediting the author and marking changes.
The portrait used as the avatar is excluded from that grant, because it identifies a person rather than illustrating an article; the site source is MIT-licensed, and the terms are emitted as machine-readable metadata on every page rather than only stated in prose.

## Inicio

URL: https://jmrp.io/es/
Markdown: https://jmrp.io/es/index.md

Página de orientación: quién es el autor y dónde vive cada cosa del sitio. Su gemelo markdown es un mapa, cada sección con su propio gemelo al lado, así que un agente alcanza el sitio entero en markdown sin analizar una sola página de HTML.

## Sobre mí

URL: https://jmrp.io/es/about/
Markdown: https://jmrp.io/es/about/index.md

La página de entidad del autor: biografía, qué construye y sobre qué escribe, los proyectos open source destacados con sus tecnologías y métricas, la formación y la política editorial y de correcciones a la que enlaza la nota de asistencia por IA de cada entrada.
Es la página que hay que leer para responder quién es José Manuel Requena Plens o qué construye; el nodo Person canónico que ancla se publica aparte en /identity/person.jsonld.

## Proyectos

URL: https://jmrp.io/es/projects/
Markdown: https://jmrp.io/es/projects/index.md

Software de código abierto escrito y mantenido por el autor; cada entrada indica lenguaje, licencia, repositorio de código y sitio de documentación.
Incluye: gitlab-mcp-server (Servidor Model Context Protocol que expone más de 850 operaciones de GitLab como herramientas accesibles para asistentes de IA en una instancia Free o autoalojada, y más de 1.000 en Ultimate, en Go); phonometry (Medición, análisis y predicción acústica para Python: metrología de niveles sonoros, psicoacústica, acústica de salas y edificación, materiales, vibración, ruido ambiental y de transporte, acústica subacuática, electroacústica y simulación de ondas, con 1893 comprobaciones de conformidad en CI sobre 111 dominios y 523 normas, en Python); cs-routeros-bouncer (Bouncer de CrowdSec para MikroTik RouterOS: gestión automática del firewall mediante la API de RouterOS, en Go); mikroscope (Telemetría de kernel por debajo del segundo desde dentro de un router MikroTik, con el coste del observador medido y no prometido, en Go); Cloudflare-DNS-Updater (Cliente de DNS dinámico en Bash que mantiene los registros A y AAAA de Cloudflare apuntando a tu IP pública actual, en Bash); libgen-mcp (Servidor MCP para búsqueda federada, cita y lectura de libros, artículos de investigación, cómics, revistas y normas en el catálogo de Library Genesis y en fuentes de acceso abierto. Sin necesidad de cuenta, en Go); ghchronicle (Recoge todas las métricas que GitHub expone sobre una cuenta y las guarda con la fecha en que ocurrieron, en Go); TFG-TFM_EPS (Plantilla LaTeX para Trabajos Fin de Grado y Fin de Máster en la Universidad de Alicante (EPS), con pipeline de compilación automatizado en CI, en LaTeX); portainer-mcp (Servidor MCP para Portainer: cobertura 1:1 de la API REST de Portainer en superficies de herramientas dinámicas, meta e individuales, en Go).
gitlab-mcp-server y libgen-mcp corren además como endpoints públicos alojados en mcp.jmrp.io, así que un cliente puede llamarlos sin compilar ni instalar nada.
A fecha de 16 de octubre de 2026, la página también recoge código y documentación que el autor ha aportado a proyectos que no mantiene en GitHub y GitLab: pull requests y merge requests fusionadas, respuestas aceptadas en GitHub Discussions y empaquetado que lista sus propias herramientas en registros públicos. El libro completo, agrupado por proyecto, está en https://jmrp.io/es/projects/contributions/.

## Aportaciones open source

URL: https://jmrp.io/es/projects/contributions/
Markdown: https://jmrp.io/es/projects/contributions/index.md

Instantánea del build (16 de octubre de 2026) del trabajo del autor en proyectos de GitHub y GitLab que no mantiene: pull requests y merge requests de código y documentación agrupadas por proyecto, las issues que ha reportado, pull requests que publican sus propias herramientas en gestores de paquetes, registros y listas curadas, respuestas aceptadas en GitHub Discussions y logros en GitHub y GitLab. Las cifras salen del recolector de GitHub del propio autor (ghchronicle) y de la API de GitLab, y cada elemento enlaza a su pull request, merge request o hilo. Página completa: https://jmrp.io/es/projects/contributions/

## Homelab

URL: https://jmrp.io/es/homelab/
Markdown: https://jmrp.io/es/homelab/index.md

Infraestructura autoalojada que el autor opera sobre su propio hardware y sus propias conexiones, con métricas en tiempo real en la página.
Entre los servicios hay una instancia de Mastodon (mstdn.jmrp.io), un homeserver de Matrix, un PDS de AT Protocol, Home Assistant, Immich, Jellyfin y monitorización.
Los servidores Model Context Protocol se publican en mcp.jmrp.io, sobre la misma infraestructura: libgen (sin credenciales) y gitlab (token por petición).
Tor: cuatro nodos, dos puentes que ejecutan obfs4 y WebTunnel, uno en Valencia y otro en Alicante, y dos relays intermedios en VPS de IONOS, uno en Londres y otro en Madrid.
Tubería de seguridad: un honeypot en MikroTik y la coincidencia de patrones de nginx alimentan a CrowdSec, que a su vez acciona los bouncers del router y de la capa web.

## Uses

URL: https://jmrp.io/es/uses/
Markdown: https://jmrp.io/es/uses/index.md

El hardware, el software y los servicios que están realmente en uso: router y equipamiento de red, servidores y mini PCs, herramientas de desarrollo y los servicios autoalojados que aparecen en Homelab.

## Privacidad

URL: https://jmrp.io/es/privacy/
Markdown: https://jmrp.io/es/privacy/index.md

Sin cookies, sin scripts de terceros, sin red publicitaria, sin rastreo entre sitios y sin lista de correo.
La medición se enuncia entera en vez de resumirse. Las páginas vistas las cuenta Cloudflare Web Analytics, con un script servido desde este dominio que elimina la cadena de consulta y el fragmento antes de informar y no pone ninguna cookie.
Un worker que el autor ejecuta en el borde de Cloudflare anota una fila por petición con los mismos campos que los registros del servidor, dirección IP incluida, más lo que solo sabe el borde, como qué centro de datos de Cloudflare respondió o la puntuación de bot que Cloudflare asigna a la petición. Cloudflare conserva esas filas unos noventa días; cada cinco minutos se copian a la base de datos de monitorización del autor, donde siguen la regla de los registros del servidor: un año y después se borran. La documentación de los proyectos en docs.jmrp.io, alojada en GitHub Pages, la registra igual un segundo worker, y no carga ningún script de analítica.
Ni publicidad, ni enlaces de afiliado, ni contenido patrocinado; la única vía de financiación es un enlace de GitHub Sponsors en la página de proyectos, nombrado en la página de privacidad como declaración de conflicto de intereses en vez de dejarlo a que el lector lo descubra.

## Licencia

URL: https://jmrp.io/es/license/
Markdown: https://jmrp.io/es/license/index.md

Las condiciones de reutilización cambian según el tipo de obra, y la página enuncia cada una en vez de dejar el resto a deducir de un único aviso general.
Los artículos y las portadas del blog se publican bajo CC BY 4.0: reutilizables comercialmente y en cualquier medio, derivados incluidos, a condición de citar la autoría e indicar los cambios.
El retrato que se usa como avatar queda fuera de esa cesión, porque identifica a una persona en lugar de ilustrar un artículo; el código del sitio está bajo MIT, y las condiciones se emiten como metadatos legibles por máquina en cada página, no solo enunciadas en prosa.

## MCP Servers (self-hosted, different domain)

- [mcp.jmrp.io](https://mcp.jmrp.io/): Public Model Context Protocol servers the author runs on his own infrastructure, with a browser inspector to try them. Streamable HTTP transport; `POST` only: a `GET` on an endpoint returns 405 by design.
- [gitlab](https://mcp.jmrp.io/gitlab): 850+ GitLab actions as tools (1,000+ depending on edition and deployment). Needs a `PRIVATE-TOKEN` header per request; the token is never stored server-side. Source: [gitlab-mcp-server](https://github.com/jmrplens/gitlab-mcp-server).
- [libgen](https://mcp.jmrp.io/libgen): Search and download books, papers, comics, magazines and standards from Library Genesis. No credentials required. Source: [libgen-mcp](https://github.com/jmrplens/libgen-mcp).
- [servers.json](https://mcp.jmrp.io/servers.json): The same list as machine-readable JSON, for automatic clients.

## Servidores MCP (autoalojados, en otro dominio)

- [mcp.jmrp.io](https://mcp.jmrp.io/es/): Servidores públicos de Model Context Protocol que el autor ejecuta en su propia infraestructura, con un inspector en el navegador para probarlos. Transporte Streamable HTTP; solo `POST`: un `GET` a un endpoint devuelve 405 por diseño.
- [gitlab](https://mcp.jmrp.io/gitlab): Más de 850 acciones de GitLab como tools (más de 1.000 según edición y despliegue). Requiere una cabecera `PRIVATE-TOKEN` por petición; el token nunca se guarda en el servidor. Código: [gitlab-mcp-server](https://github.com/jmrplens/gitlab-mcp-server).
- [libgen](https://mcp.jmrp.io/libgen): Busca y descarga libros, artículos, cómics, revistas y normas de Library Genesis. Sin credenciales. Código: [libgen-mcp](https://github.com/jmrplens/libgen-mcp).
- [servers.json](https://mcp.jmrp.io/servers.json): La misma lista como JSON legible por máquina, para clientes automáticos.

## Contact

- [GitHub](https://github.com/jmrplens)
- [GitLab](https://gitlab.com/jmrp)
- [LinkedIn](https://www.linkedin.com/in/jmrplens)
- [Mastodon](https://mstdn.jmrp.io/@jmrplens)
- [Bluesky](https://bsky.app/profile/jmrp.io)
- [Matrix](https://matrix.to/#/@jmrplens:matrix.jmrp.io)
- [Keyoxide](https://keyoxide.org/0A993B268654DBBA52B7E8D3FCF653391E2C91FC)
- [Codeberg](https://codeberg.org/jmrplens)
- [Google Scholar](https://scholar.google.com/citations?user=9b0kPaUAAAAJ)
- [ORCID](https://orcid.org/0000-0003-1250-6212)
- [ResearchGate](https://www.researchgate.net/profile/Jose-Requena-Plens-2)
- [MATLAB Central](https://www.mathworks.com/matlabcentral/profile/authors/5890853)
- [PyPI](https://pypi.org/user/jmrplens/)
- [Docker Hub](https://hub.docker.com/u/jmrplens)
- [npmjs.com](https://www.npmjs.com/~jmrpio)
- [nuget.org](https://www.nuget.org/profiles/jmrplens)
- [mcptoplist.com](https://mcptoplist.com/u/jmrplens)
- [community.home-assistant.io](https://community.home-assistant.io/u/jmrplens)
- [forum.mikrotik.com](https://forum.mikrotik.com/u/jmrplens)
- [sifa.id](https://sifa.id/p/jmrp.io)
- [stackexchange.com](https://stackexchange.com/users/7889616/jmrplens)
- [dsp.stackexchange.com](https://dsp.stackexchange.com/users/51783/jmrplens)
- [stackoverflow.com](https://stackoverflow.com/users/5960262/jmrplens)
- [tangled.org](https://tangled.org/jmrp.io)
- [Email](mailto:mail@jmrp.io)

## Technical Details

- Built with Astro 7 (Static Site Generation)
- Bilingual: English (default) and Spanish; all content available in both languages under the /es/ prefix
- Zero client-side JavaScript (except progressive enhancement islands)
- WCAG 2.2 AA/AAA accessibility compliant
- Content Security Policy with SRI hashes
- RSS feeds: https://jmrp.io/rss.xml (EN) and https://jmrp.io/es/rss.xml (ES)