All articles

Cybersecurity / 16 Sep 2026 / 9 min read

HTTP Request Smuggling Starts When Intermediaries Disagree on Message Boundaries

A reverse proxy accepts an HTTP/1.1 request, decides where its body ends, and forwards traffic to an application server over a persistent connection. If the application server reaches a different boundary from the same framing information, the two components stop agreeing about which bytes belong to which request. Bytes treated as body data by one component can become the start of a new request for the other. That disagreement is the core condition behind HTTP request smuggling. The defect is not simply a malformed header, a proxy, or connection reuse in isolation. It is a parser differential across a chain in which multiple recipients interpret request framing and at least one connection carries subsequent traffic.

Cybersecurity HTTP

Cybersecurity / 16 Sep 2026 / 8 min read

HTTP Request Framing Desynchronization Turns Parser Differences Into a Proxy Boundary Failure

HTTP Request Framing Desynchronization Turns Parser Differences Into a Proxy Boundary Failure A reverse proxy can validate an HTTP request, forward it to an origin, and still leave the origin processing a different request sequence from the one the proxy approved. The failure is not caused by encryption loss or a missing authorization check. It appears when two recipients consume the same connection bytes with different rules for deciding where one message ends and the next begins.

Cybersecurity HTTP

Software Engineering / 16 Sep 2026 / 8 min read

HTTP If-Range Couples Partial Retrieval to Representation Identity

A client that has only part of an HTTP representation faces a consistency problem when it asks for the missing bytes later. Byte offsets are meaningful only against the representation whose bytes established those offsets. If the selected representation changes between requests, combining an old prefix with a new suffix can produce data that no server ever emitted. If-Range attaches representation identity to that partial-retrieval boundary. When its validator matches, the server can process the accompanying Range field. When it does not match, the server ignores Range and sends the complete selected representation through the normal successful response path instead of returning a failed-precondition response.

Software Engineering HTTP

Software Engineering / 16 Sep 2026 / 8 min read

HTTP If-Match Turns Representation State Into a Write Precondition

An HTTP origin can refuse a PUT or DELETE before applying it when the request carries If-Match and the selected representation no longer has an accepted entity tag. The condition converts a representation validator into a write precondition: a client can say that a mutation is valid only against state matching a version it previously observed. This mechanism addresses a specific concurrency boundary. It can prevent one client from silently replacing resource state after another client has changed the selected representation. It does not turn HTTP into a transaction protocol, lock the resource between requests, or guarantee that an entity tag represents every piece of application state involved in a mutation.

Software Engineering HTTP

Software Engineering / 16 Sep 2026 / 8 min read

HTTP 425 Keeps Replay-Sensitive Requests Out of TLS Early Data

TLS 1.3 can carry application data before a resumed handshake completes, which means an HTTP request can reach server processing earlier than the connection has its final handshake state. That latency optimization changes a security property: early data can be replayed, so a request that is safe to execute once can become unsafe when the same bytes are accepted more than once. HTTP status 425 Too Early marks the boundary between transport acceptance and application acceptance. A server can accept TLS early data at the connection layer yet decline to process a particular HTTP request from that data. The client can then retry after the handshake completes, where the early-data replay condition no longer applies.

Software Engineering HTTP

Software Engineering / 16 Sep 2026 / 7 min read

HTTP 421 Misdirected Request Marks a Connection Authority Boundary

An HTTP/2 client can reuse one secured connection for requests to more than one origin when the server is authoritative for those origins. A request can still reach a server instance whose connection context does not fit the target URI. 421 Misdirected Request exists for that boundary: the server rejects the routing context rather than treating the target resource itself as missing. This distinction separates resource semantics from connection authority. A 421 response says that this server, on this path or connection context, is unable or unwilling to produce an authoritative response for the target URI. It does not say that the resource has been deleted, that its method is forbidden, or that the request representation is invalid.

Software Engineering HTTP

Software Engineering / 16 Sep 2026 / 6 min read

HTTP 103 Early Hints Separate Speculation From Final Response Semantics

An HTTP server can emit a 103 Early Hints informational response before it has produced the final response. A client may act on suitable fields in that interim message, such as starting a preload named by Link, even though the eventual status code, header fields, and representation are still pending. This creates a deliberate split between speculative work and authoritative response semantics. The interim response can move selected preparation earlier in time, but it cannot stand in for the final response or determine its meaning.

Software Engineering HTTP

Cybersecurity / 16 Sep 2026 / 7 min read

HSTS Pins HTTP Navigation to an HTTPS-Only Origin Policy

HSTS Pins HTTP Navigation to an HTTPS-Only Origin Policy A browser receives a link beginning with http:// for a host it has contacted securely before. No HTTP request leaves the machine. Instead, the user agent rewrites the navigation to HTTPS from local policy and starts TLS directly. The server-side redirect that administrators often associate with HTTPS migration never participates in that request path. HTTP Strict Transport Security (HSTS), standardized in RFC 6797, creates this behavior by letting an HTTPS host declare a time-bounded transport policy. Once a conforming user agent records that policy, insecure HTTP is no longer a permissible transport choice for matching requests during the policy lifetime. This shifts an important boundary from server response handling to client-side connection selection.

Cybersecurity HTTP

Cybersecurity / 16 Sep 2026 / 8 min read

HSTS Caches Transport Policy Beyond the Response That Declared It

HSTS Caches Transport Policy Beyond the Response That Declared It A site can redirect every plain-HTTP request to HTTPS and still expose the first request of a fresh browser session to an active network attacker. The redirect is delivered only after the browser has already contacted the HTTP endpoint. HTTP Strict Transport Security changes that sequence by moving a transport decision into browser state. After a valid Strict-Transport-Security response arrives over secure transport, a conforming browser records policy for the host. Later attempts to reach that host through HTTP are rewritten toward HTTPS before an insecure request is sent. The control therefore persists beyond the response that declared it.

Cybersecurity HSTS

Go / 16 Sep 2026 / 5 min read

Go WaitGroup Reuse Requires Completed Wait Boundaries

A sync.WaitGroup can be reused after a wait phase completes, but a new independent task set cannot begin while calls to Wait from the prior phase are still active. The boundary is the return of every earlier Wait, not merely the instant at which the internal task counter reaches zero. This constraint matters when one WaitGroup instance is retained across batches, epochs, request waves, or repeated coordination cycles. Reuse is supported, but phases must not overlap at the zero-to-positive counter transition.

Golang Concurrency

Go / 16 Sep 2026 / 5 min read

Go sync.Pool Items Can Disappear Across Garbage Collection

A value placed in a Go sync.Pool is not guaranteed to remain there until a later Get. The runtime may remove pooled items automatically, so the pool acts as a reuse opportunity rather than durable storage. That property shapes both the performance profile and the correctness boundary of sync.Pool. Code can benefit when an object survives long enough to be reused, but it must remain correct when every Get behaves as if no prior item were available.

Golang Memory

Go / 16 Sep 2026 / 4 min read

Go sync.Cond Wait Rechecks Shared State

sync.Cond.Wait resumes after a notification, but the notification does not assert that a caller-specific condition is still true when the goroutine reacquires the lock. The shared predicate remains the source of truth, so a waiter checks it again after every return from Wait. This boundary separates notification from state. Signal and Broadcast announce that relevant state may have changed; they do not transfer ownership of that state or reserve it for a particular waiter.

Golang Concurrency

Go / 16 Sep 2026 / 5 min read

Go singleflight Shares Only In-Flight Results

singleflight.Group suppresses duplicate function executions only while an operation for the same key is in flight. Concurrent callers can receive one shared result, but a caller arriving after completion starts a new execution. The group is therefore a request-coalescing mechanism, not a result cache. This boundary affects cache fills, metadata refreshes, backend reads, and other keyed operations that can attract bursts of identical concurrent work. A group can reduce simultaneous pressure on the backing operation without extending the lifetime of its returned value.

Golang Concurrency

Go / 16 Sep 2026 / 4 min read

Go Runtime Finalizers Delay Object Reclamation

A Go object with a finalizer is not reclaimed when the garbage collector first determines that it is unreachable. The runtime must retain the object for the finalizer call, and reclamation can occur only after a later collection finds the object unreachable again. That behavior makes runtime.SetFinalizer materially different from ordinary garbage collection. It adds an asynchronous lifecycle phase between loss of application reachability and memory reclamation. Finalization temporarily restores reachability runtime.SetFinalizer(obj, f) associates f with obj. When the collector detects an unreachable object with that association, it clears the association and arranges a call to f(obj).

Golang Runtime

Go / 16 Sep 2026 / 5 min read

Go Nil Channels Disable Select Cases

A send or receive on a nil Go channel can never proceed. Inside a select, that property removes the associated communication case from the set of cases eligible to run, without requiring a separate condition around the select. This behavior follows directly from the channel contract. The zero value of a channel is nil, and a nil channel is never ready for communication. A standalone send or receive therefore blocks indefinitely. A select treats the same operation as a case that cannot currently proceed.

Golang Channels

Go / 16 Sep 2026 / 4 min read

Go Map Iteration Order Is Not Stable

A range over a Go map can visit the same entries in a different order on consecutive iterations. The language specification leaves map iteration order unspecified and gives no guarantee that a later pass over an unchanged map will repeat an earlier sequence. That contract is stronger than saying that maps are merely unsorted. An unsorted container could still expose a stable insertion-dependent or storage-dependent sequence. A Go program cannot assign such meaning to map traversal.

Golang Maps

Go / 16 Sep 2026 / 6 min read

Go errgroup SetLimit Blocks Submitters at the Concurrency Cap

errgroup.Group.SetLimit can block the goroutine that calls Group.Go. The limit is enforced before a new worker goroutine starts, so a full group applies backpressure at task submission rather than building an internal queue. That behavior matters when submission is part of another control path. A loop that appears to launch work asynchronously can itself stop at g.Go(...) until one active function returns. The limit sits on admission A zero-value errgroup.Group has no concurrency limit. After SetLimit(n), at most n functions started by Go are active at once. A negative limit restores unlimited admission, while a zero limit prevents every later Go call from starting a function.

Golang Concurrency

Go / 16 Sep 2026 / 4 min read

Go Defer Saves Call Arguments Before Return

A Go defer statement evaluates its function value and call parameters when execution reaches the statement, even though the deferred function runs only as the surrounding function returns. Mutations between those two moments do not retroactively change already saved argument values. This split between evaluation and invocation is part of the language semantics rather than an optimization detail. Each executed defer records a call with values established at that point. Return processing later invokes recorded calls in reverse registration order.

Golang Defer

Go / 16 Sep 2026 / 3 min read

Go context.AfterFunc Stop Does Not Wait for Callback Completion

The stop function returned by Go’s context.AfterFunc does not wait for a callback that has already started. A false result therefore marks a state boundary, not a completion barrier: the callback may be running concurrently when stop returns. context.AfterFunc(ctx, f) associates f with cancellation of ctx. Cancellation starts f in its own goroutine. If the context is already canceled at registration time, the callback is started promptly in a new goroutine rather than being invoked synchronously by the caller.

Golang Context

Go / 16 Sep 2026 / 4 min read

Go Context Cancellation Cause Follows the First Cancellation

A Go context records its cancellation cause when cancellation first reaches that context. Later cancellation attempts do not replace the recorded cause. This makes context.Cause a record of the winning cancellation event rather than a mutable error slot. The distinction matters in context trees because parent and child cancellation can race. The first event to cancel a given node fixes that node’s cause, while another node in the same tree can retain a different cause.

Golang Context

Tech / 16 Sep 2026 / 5 min read

fsync on a File Does Not Persist Its Directory Entry

A successful fsync() on a regular file does not, by itself, guarantee that the directory entry naming that file has reached persistent storage. Linux documents this boundary explicitly: file synchronization covers the file’s data and associated metadata, while persistence of the containing directory entry requires an fsync() on a file descriptor for that directory. This distinction matters when software creates a new file or atomically replaces an existing pathname. File contents and pathname metadata are separate pieces of filesystem state, and a crash can test the durability boundary between them.

Linux Filesystem

Cybersecurity / 16 Sep 2026 / 7 min read

Fetch Metadata Lets Servers Reject Cross-Site Request Contexts

Fetch Metadata Lets Servers Reject Cross-Site Request Contexts An authenticated endpoint can receive a syntactically valid request carrying ambient credentials even when the navigation or resource load began on another site. Cookies alone do not tell the server what browser context produced the request. Fetch Metadata adds request headers that expose selected context already known to the user agent, giving the server another signal before it accepts a state-changing operation or serves a sensitive resource.

Cybersecurity Web Security

Artificial Intelligence / 16 Sep 2026 / 6 min read

Extend RoPE Context with Positional Interpolation

A transformer using rotary position embeddings can accept tensors longer than the sequence length used during training, yet accepting the shape does not establish that its position signal remains usable at those distances. Rotary angles at unseen positions can place attention computations outside the positional regime the model encountered during optimization. Positional interpolation changes the input to rotary position embeddings rather than merely raising a sequence-length limit. For a target context longer than the original training context, position indices are compressed so the extended sequence maps into the earlier positional range. The model then needs to adapt to denser positional spacing instead of extrapolating directly to larger indices.

Artificial Intelligence Transformers

Tech / 16 Sep 2026 / 6 min read

Ethernet Pause Frames Temporarily Stop Link Transmission

Ethernet links can move frames faster than a receiving device can process or forward them. When that mismatch lasts long enough, receive buffers fill and frames may be dropped. IEEE 802.3x flow control provides a link-level response for full-duplex Ethernet. A device can send a MAC Control PAUSE frame that asks its directly connected peer to stop transmitting ordinary data frames for a specified interval. The pause is temporary, local to that link, and different from congestion control performed by higher-layer protocols.

Networking Ethernet