Modern distributed systems rely on webhooks to push asynchronous state changes between microservices, SaaS platforms, payment gateways, and CI/CD pipelines. A single HTTP POST is cheap to send. At high ingress rates, though, every delivery needs two layers of cryptographic work before business logic runs. The first is TLS termination, which decrypts the transport stream. The second is application-layer signature verification, which authenticates the sender and confirms payload integrity. Providers typically use HMAC-SHA256 or Ed25519 for this.

When this work runs on general-purpose host CPUs, it consumes cycles, adds latency jitter, and lets bad traffic reach your application tier. A flood of forged or replayed webhooks costs the host nearly as much to reject as a legitimate one costs to accept.

Programmable SmartNICs and DPUs (data processing units) such as NVIDIA BlueField-3 and AMD Pensando are an attractive place to move part of that work. They pair high-speed Ethernet with hardware crypto engines and embedded Arm cores, and they sit in a separate trust domain from the host. The practical picture is more nuanced than “everything runs in silicon at wire speed,” however. This article separates what the vendors document from what you would have to build yourself.

The Webhook Ingress Bottleneck

An unaccelerated webhook request arriving at a Linux server goes through these stages:

  1. Packet arrival and kernel traversal. The NIC DMAs frames into host RAM. The kernel’s TCP/IP stack processes them and hands the byte stream to a reverse proxy such as Envoy, NGINX, or HAProxy.
  2. TLS termination. The proxy completes the handshake and decrypts records, typically with AES-GCM or ChaCha20-Poly1305. High connection churn means many handshakes, which are far more expensive than bulk decryption.
  3. HTTP parsing and body buffering. Most signature schemes sign the exact raw bytes of the request body, so the body must be buffered intact before verification. Re-serializing parsed JSON breaks the signature.
  4. Signature verification. The application reads the signature header, rebuilds the signed string, and computes an HMAC or verifies a digital signature.
  5. Rejection. If verification fails, the host has already spent network, kernel, TLS, and memory resources on a request it will answer with a 401.

Providers differ in how they sign requests, and the differences matter for any offload design:

Provider Algorithm Header What is signed Replay defense
Stripe HMAC-SHA256 Stripe-Signature: t=<unix>,v1=<hex> {t}.{raw body} Signed timestamp; libraries default to a 5-minute tolerance
GitHub HMAC-SHA256 X-Hub-Signature-256: sha256=<hex> Raw body No signed timestamp; deduplicate on the delivery ID
Shopify HMAC-SHA256 X-Shopify-Hmac-SHA256 (base64) Raw body Deduplicate using X-Shopify-Webhook-Id
Discord Interactions Ed25519 X-Signature-Ed25519, X-Signature-Timestamp Timestamp concatenated with raw body Discord requires validating signatures and returning 401 on failure

An “anti-replay window” check is therefore available only for providers that sign a timestamp, such as Stripe and Discord. For GitHub and Shopify, replay protection means tracking delivery IDs, which is stateful work.

What Modern DPUs Actually Offer

NVIDIA BlueField-3

According to NVIDIA’s datasheets, BlueField-3 offers:

  • Compute: up to 16 Arm Cortex-A78 (“Hercules”) cores (Armv8.2+), plus a 16-core, 256-thread programmable datapath accelerator.
  • Networking: up to 400 Gb/s Ethernet or NDR InfiniBand, on a PCIe Gen 5 host interface.
  • Memory: on-board DDR5.
  • Data-in-motion crypto: AES-GCM 128/256-bit acceleration for IPsec, TLS, and PSP.
  • Platform security: secure boot with a hardware root of trust, secure firmware update, flash encryption, and device attestation.

Not every SKU has crypto enabled. NVIDIA’s part tables mark crypto support per model, so confirm that your specific card is crypto-enabled before designing around it.

The DOCA SDK exposes these capabilities to developers. Several details are easy to get wrong:

  • Public-key acceleration. The BlueField PKA engines accelerate RSA, DH, DSA, ECDSA, and ECDH. NVIDIA’s documentation lists RSA, DH, and DSA keys up to 4096 bits and elliptic-curve support for NIST prime curves (160 to 521 bits). It is exposed to applications through an OpenSSL engine, and the documented OpenSSL support covers versions up to 1.1.1 and 3.0.2. Ed25519 and X25519 do not appear in the documented list.
  • SHA acceleration. The DOCA SHA library supports SHA-1, SHA-256, and SHA-512. However, NVIDIA’s documentation states that the SHA hardware engine is available only on BlueField-2, so the DOCA SHA library is not available on BlueField-3. DOCA SHA also computes plain digests, not keyed HMACs.
  • Host-to-DPU communication. DOCA Comch is a channel between host applications and the DPU’s Arm cores. It is not an inline packet-processing or crypto API.
  • Packet steering. DOCA Flow is the library for hardware flow steering and match-action offload.

AMD Pensando (Elba and Salina)

AMD’s Pensando DPUs are built around a P4-programmable pipeline of match-processing units (MPUs), plus Arm cores and crypto engines:

  • Elba (second generation) has 16 Arm Cortex-A72 cores, 144 MPUs, dual 200 GbE ports, and PCIe Gen4.
  • Salina (third generation, announced in October 2024) has 16 Arm Neoverse N1 cores, 232 MPUs, two 400 GbE ports, and PCIe Gen5. AMD’s brief lists 64 GB of DDR5.
  • Programming model. AMD describes data-plane services written in P4, C++, and C.
  • Crypto and TLS. The Salina brief lists TLS/DTLS encryption, a TLS proxy, TCP/TLS termination for load balancing, public-key encryption, authentication, bulk cryptography, and inline IPsec and DTLS. Secure hashes can be chained into programmable pipelines.
  • Elba specifics. AMD’s earlier documentation lists AES-GCM, ChaCha-Poly, HMAC, and SHA-2/SHA-3 offloads. Its inline crypto blocks sit beside the P4 ingress and egress engines. The Hot Chips 2020 presentation described a root of trust based on a physical unclonable function (PUF).

Realistic Offload Architectures

No vendor documentation I could find shows a complete, turnkey “TLS termination plus HMAC/Ed25519 webhook verification in silicon” pipeline on either platform. You can build useful pipelines from documented pieces, but each stage has constraints.

Stage 1: Bulk TLS record crypto (kTLS and inline offload)

In Linux kernel TLS (kTLS), the TLS handshake stays in user space. The library installs the negotiated session keys into the kernel afterward, and with device offload the NIC then encrypts and decrypts records.

  • NVIDIA documents kTLS TX/RX offload for crypto-enabled ConnectX-6 Dx cards, enabled through ethtool (tls-hw-tx-offload and tls-hw-rx-offload). It requires OpenSSL 3.0 or later.
  • Mainline Linux has historically offered device offload only for TLS 1.2 with AES-GCM. TLS 1.3 sessions run as software kTLS. A patch series adding TLS 1.3 hardware offload for mlx5 (ConnectX-6 Dx and newer) was still in review in 2026, so check your kernel version.
  • This means TLS 1.3 handshakes, including their key exchange and signing, still run in software unless you use a vendor-specific stack. The PKA engine’s documented curves are NIST curves, while many TLS 1.3 clients negotiate X25519.

Stage 2: HTTP framing and early rejection

Running the proxy on the DPU’s Arm cores lets you do cheap checks before anything crosses the PCIe bus:

  • Route matching against registered webhook paths.
  • Size limits, rejecting requests whose declared body size exceeds your cap. Remember to bound chunked bodies as well.
  • Replay-window checks for schemes that sign a timestamp, such as Stripe’s t= value or Discord’s X-Signature-Timestamp. Parse the timestamp from the header and compare it to the current time against your tolerance. Stripe’s libraries default to five minutes.
  • Delivery-ID deduplication for providers like GitHub and Shopify, which requires a state store.

Rejecting stale requests before hashing saves cryptographic work.

Stage 3: Signature verification

Treat this stage as engineering you do yourself, because hardware support varies:

  • HMAC-SHA256. HMAC is H((K′ ⊕ opad) ‖ H((K′ ⊕ ipad) ‖ m)), where H is SHA-256, K′ is the key padded to the hash block size, and m is the signed message. On BlueField-3, DOCA SHA’s hardware engine is not available, and DOCA SHA does not compute keyed HMACs in any case. Plan to run HMAC in software on the DPU’s Arm cores unless NVIDIA documents a supported path for your SKU and software version. Pensando documentation lists HMAC and SHA-2 offloads for Elba, but exposing them to a webhook-verification service is custom work.
  • Ed25519. Ed25519 signing hashes with SHA-512 (as defined in RFC 8032) and performs curve arithmetic on Curve25519. Because the documented BlueField PKA algorithms do not include Ed25519, assume software verification on the Arm cores. Ed25519 verification is fast in optimized libraries, and a pool of Arm cores may be sufficient for many workloads.
  • Constant-time comparison. Whatever runs the check must compare digests in constant time.

Stage 4: Forward or drop

On failure, the DPU can drop the connection or return a 401 itself, so the host never sees the request. On success, it forwards the request to the host application, with TLS and signature checks already done.

If you add a “verified” header such as X-Webhook-Verified, strip any inbound header of that name at the DPU edge. Otherwise, an external sender could forge it.

What Offload Changes

Concern Host-CPU ingress DPU-assisted ingress
Bulk TLS record crypto Host cores (using AES-NI or Arm crypto instructions) NIC crypto engine via inline or kTLS offload, where supported
TLS 1.3 handshake Host user space Usually still software; DPU Arm cores can take it off the host
Public-key operations Host software DPU PKA for documented algorithms (e.g. ECDSA on NIST curves); no documented Ed25519 or X25519
HMAC-SHA256 Host software DPU Arm software on BlueField-3 (DOCA SHA hardware is BlueField-2 only); vendor engines on Pensando
Invalid webhooks Consume kernel, TLS, and buffer resources Rejected on the DPU before reaching the host
Key isolation Host process memory DPU memory in a separate trust domain, with a hardware root of trust and secure boot

Vendors’ headline numbers, such as BlueField-3 delivering the services of “up to 300 CPU cores”, describe generic infrastructure offload, not webhook workloads. Benchmark your own traffic mix before committing.

Implementation Considerations

Key distribution

HMAC needs per-tenant secrets and Ed25519 needs per-tenant public keys.

  • A control-plane agent can pull secrets from a manager such as HashiCorp Vault or AWS Secrets Manager and populate an in-memory lookup table keyed by endpoint ID.
  • A DPU is a separate trust domain with its own Arm processor and secure boot chain, so a compromised host does not directly expose secrets held only in DPU memory. That is not an absolute guarantee, and it depends on correct configuration and secure provisioning. Both vendors describe hardware roots of trust. NVIDIA’s BlueField-3 documentation covers secure boot, flash encryption, and device attestation.
  • Rotation. Providers handle rotation differently. During secret rotation, Stripe can send multiple v1 signatures in one header (one per active secret), and the receiver should accept a match against any of them. The v0 scheme in Stripe’s header appears only in test events and should be ignored.

Multi-packet payloads

Webhook bodies often span many TCP segments. A purely stateless match-action pipeline cannot hash a body spread across segments, so you need stateful TCP and TLS handling. The two usual choices are a user-space proxy on the DPU’s Arm cores or a TLS-proxy feature on the card itself. Pensando’s documentation lists a TLS proxy among its security features.

When to offload

Offload tends to pay off for:

  • High-volume public webhook endpoints, where many requests are invalid, replayed, or malicious and early rejection saves host work.
  • Multi-tenant ingress that benefits from isolating signing keys from tenant-facing workloads.
  • Strict latency targets where TLS handshakes on host cores create tail-latency spikes.

For low-volume internal webhooks, host-based verification is simpler to operate and has fewer moving parts. For small payloads, the overhead of dispatching to an accelerator can exceed the cost of computing the hash in software. There is no universal threshold, so measure with your own payload sizes.

Operational Best Practices

  • Keep a software fallback. If a node lacks a DPU or the DPU path fails, the host proxy should verify TLS and signatures itself. Never trust a verification header that wasn’t set by your own DPU.
  • Cap payload sizes early. Enforce body-size limits at the first parsing stage to protect the DPU’s limited DRAM.
  • Export telemetry. Track handshake failures, replay-window rejections, signature mismatches, dedup hits, and crypto-queue depth in Prometheus or OpenTelemetry. This lets you tell network drops apart from cryptographic rejections when debugging partner integrations.
  • Verify the hardware is actually used. Confirm which OpenSSL engine or provider is loaded and check hardware counters. For example, kTLS exposes statistics in /proc/net/tls_stat. A library that silently falls back to software looks fine until load arrives.
  • Check version support. The BlueField PKA engine documents specific OpenSSL versions, and kTLS offload depends on kernel, driver, firmware, and SKU. Pin and test your full stack.

Sources

Originally published at https://instawebhook.com/blog/hardware-accelerated-tls-termination-for-webhooks-what-smartnics-and-dpus-can-an