GitHub attestation tool verified an unreleased container image, researchers find

·1 views

Security researchers discovered that GitHub's 'gh attestation verify' command returned a passing result for a container image that had never been officially released. The issue stems from how the tool handles multi-platform OCI image indexes, where a signed attestation can cover a digest that does not correspond to the intended release manifest. Investigators traced the problem through multiple layers of container metadata, including image indexes, platform manifests, and Sigstore bundles attached via the OCI referrers API. The finding highlights a gap between cryptographic signature verification and confirming that a specific digest matches what a project actually shipped. The researchers note that checking provenance alone is insufficient without also validating the digest against an authoritative release manifest.

Read the full story at DEV Community

This is an AI-generated summary. ShortSingh links to the original source for the complete article.

Discussion (0)

How One Developer Built a Secure, Read-Only MCP Server Before Going to Production

A developer building Lutions, a private web app for project and ticket management, designed security constraints for its Model Context Protocol (MCP) server before any production tools were deployed. The core decision was to limit the server to six read-only tools that search and retrieve tickets, comments, and links — preventing it from acting as an open API or autonomous agent. Each tool accepts only tightly scoped inputs, such as bounded search text and capped result limits, to avoid becoming a vector for arbitrary data access. Authorisation is enforced server-side through user context and visibility rules, meaning tool schemas serve as structural guardrails rather than security substitutes. The approach reflects a broader architectural principle: narrowing the tool surface reduces misuse risk and keeps the permission model aligned with what the underlying application already enforces.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Common Database Indexing Mistakes That Silently Degrade App Performance

Database indexing is widely used by developers but rarely reasoned through carefully, leading to recurring performance issues in production systems. Adding indexes to every column in a WHERE clause is a common error, as each index adds overhead to every write operation, slowing inserts, updates, and deletes. Composite index column ordering also matters significantly, since databases can only leverage such indexes efficiently from left to right, meaning a mismatch with actual query patterns renders them ineffective. Foreign keys without supporting indexes force full table scans on joins and cascading deletes, often causing dashboards to slow progressively as related tables grow. Developers are advised to use query planner tools like EXPLAIN ANALYZE to verify indexes are actually being used, audit existing indexes against real query logs, and consider pre-computation or materialized views for heavy aggregation workloads.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Common API Rate Limiting Mistakes That Cause Production Failures

Many development teams implement API rate limiting reactively, only after incidents like scraper attacks or retry loops have already disrupted services. A flat request-count limit per API key often fails in practice because it treats all requests equally, ignores natural traffic bursts, and creates edge-of-window spikes with fixed time windows. More resilient approaches include token bucket or sliding window algorithms, cost-based endpoint weighting, and separate limits for authenticated versus anonymous traffic. A critical but commonly overlooked flaw is storing rate limit counters in each server's local memory, which allows clients to effectively multiply their allowed limit by the number of server instances; centralizing counters via a tool like Redis resolves this. Teams retrofitting rate limiting onto existing APIs are advised to begin with traffic monitoring, use per-client limits, return clear retry headers on 429 responses, and alert on clients consistently approaching their thresholds.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Rust-based rekuiper uses 5–10 MB memory vs rivals' 1 GB in edge stream processing

I-Dacs Labs Engineering rebuilt LF Edge eKuiper as 'rekuiper' in Rust and benchmarked it against eKuiper, Telegraf, and Redpanda Connect across five real-world MQTT workloads on a single-core, 1 GB memory setup. The key finding was not peak throughput but memory efficiency: rekuiper held between 5 and 10 MB on windowed workloads, while Go-based engines consumed up to a full gigabyte or failed entirely. rekuiper matched eKuiper's REST API, SQL dialect, and CLI surface so existing rules and tooling require no changes. The engine uses bounded queues and a reserve-then-commit admission model to prevent data loss and backpressure buildup under bursty traffic typical of industrial edge deployments. Benchmarking also uncovered a correctness bug in rekuiper itself that a throughput-only test would have missed, highlighting the importance of message-by-message output verification.

0 comments Read more at DEV Community