Christian N. Crispy retweeted
Replying to @flatterkatz
Christian N. Crispy retweeted
a free tutorial series takes you from an empty boot sector to a working 32-bit protected mode kernel
you build the bootloader GDT the A20 line VGA text mode and the kernel itself step by step
the entire series is still online for free
Christian N. Crispy retweeted
Fil-C's safety is not only super thorough, but has now been given scrutiny by internet experts. Let's review their findings!
- Intra-object overflows: Fil-C allows an array overflow inside an object to affect the untrusted parts of the rest of that object, for example other primitive fields. But, it does not allow corruption of capabilities associated with those fields, so it's not useful for building memory corruption exploit chains. This makes Fil-C's protections strictly stronger than MTE's, since MTE does allow pointers to become corrupted. Even so, intra-object overflows are rare and not worth overindexing. According to Apple's SEAR: "Although some issues are able to survive MIE — for example, intra-allocation buffer overflows — such issues are extremely rare, and even fewer will lend themselves to a full end-to-end exploit"
- Arenas: a pointer to any object in an arena chunk may be used to corrupt any primitive, untrusted data in that arena chunk. This is a bit stronger than what you'd get from MTE for an arena if you did nothing to "fix" the arena, since Fil-C still protects the capabilities while MTE does not. In Fil-C, fixing the arena means replacing it with just GC allocations, which is super easy to do. Alternatively, you can reconfigure the arena to use finer-grained chunks (which is what we did for obstacks in GNU software ported to Fil-C). Rust also has arenas, like if you allocate objects using Vec<> and refer to them using an integer index. The effect there is sorta like in Fil-C: the guarantees are coarsened from per-object to per-arena (in Fil-C, the guarantees are coarsened to per-arena-chunk, which maybe is a bit safer). Arenas like this are used in pretty much every memory-safe language; another great example is how folks use ArrayBuffers in JavaScript for building data structures that don't rely on GC and can be shared with workers. Similarly to arenas in Fil-C, that coarsens JS's protections to per-buffer rather than per-object. In practice, C/C++ code uses arenas sparingly, for the simple reason that they incur high memory cost. When C code does use arenas, it's often an arena-per-use-case, so an attacker who has an out-of-bounds bug on an object in arena is restricted to just attacking other objects of the same type within the arena chunk. That's a far cry from "corrupt anything in memory", which is that the attacker is after.
Another way to think of arenas in Fil-C and memory safety: a C program that uses arenas in Fil-C has strictly more protection against attacks than running that same C program (arenas or not) in WebAssembly, RLbox, MTE, MIE, or ChkTag.
- Races: Fil-C allows pointer races to create a tear between the pointer's capability and the pointer's untrusted integer value. This is a different kind of "weird" than what you get from races in other languages, but it's not useful for building memory corruption exploit chains, since pointer's capability will still be fully intact and can never be formed out of thin air - it's a capability that was legitimately stored to the raced-on memory location, and the memory model for capabilities follows total ordering.
- `zunsafe_call` and friends: Fil-C has a restricted FFI to assembly code, used in exactly one place, and for a good reason: OpenSSL uses `zunsafe_call` to call into constant-time crypto written in assembly. There are no uses of `zunsafe_call` in Fil-C other than the ~50 or so calls to super hardened assembly crypto. In the net, it's safer to have OpenSSL use constant time crypto written in assembly than memory-safe crypto with potential timing side channels. Worth noting that `zunsafe_call` will be removed from Fil-C once I make assembly memory safe (I'm working on that now).
- The occasional bugs, which have been fixed: folks have found bugs in the Fil-C runtime. Interestingly, none of those bugs could be triggered from any C/C++ code that has been ported to Fil-C because those bugs required use of esoteric features (stuff like calling `malloc` from an `ifunc` - something nobody does).
I think this is an exhaustive list, but let me know if I forgot anything.
TL;DR. Fil-C is so safe that despite attempts to attack it, folks have at best found issues that are not useful for the sorts of memory corruption exploits that make C/C++ unsafe in the first place.
Christian N. Crispy retweeted
We have consistently used the @rrainfo platform for managing and verifying domestic tax records. However, when attempting to verify tax information dating back to 2023, users are now being redirected to the @CityofKigali SORA system.
The challenge is that the new system does not yet appear to have all the historical data available, making it difficult for taxpayers to access or verify previous records.
As digital systems are upgraded and migrated, it is important to ensure that all relevant data is fully transferred, validated, and accessible before the transition is rolled out to the public. This helps avoid disruptions, improves user experience, and maintains confidence in public service delivery.
A smooth migration process requires not only a new platform but also complete and reliable data continuity. @EmmaClaudine
Christian N. Crispy retweeted
Crazy I still have this!!
Goes back to 2019 when I was in ALC 4. Looking back this was a career breaking phase for me. Learned a lot from MWS track that shaped the engineer and person I am today.
Thank you #growwithgoogle #andela #mentors
Christian N. Crispy retweeted
On the International Day of Reflection on the 1994 Genocide Against the Tutsi in Rwanda, we mourn the victims & pay tribute to the survivors.
We must learn from past failures & protect the living — by rejecting hatred, inflammatory rhetoric & incitement to violence.
Christian N. Crispy retweeted
Health probes are an important #Kubernetes concept to understand. Setting these up is not difficult, but getting them wrong can turn a routine database outage into a full cascading failure. This article walks through the distinctions between liveness, readiness, and startup probes and why treating them as interchangeable is a mistake worth avoiding.
One key topic discussed is that your liveness probe should never check external dependencies. If it does, a downed database triggers a restart loop across all your pods. The article also covers graceful degradation, proper timeouts, and the common missteps that catch most teams off guard.
Young Gao has put together a solid reference for anyone configuring health checks in Kubernetes. Check it out!
lckhd.eu/sFOvK4
Christian N. Crispy retweeted
Rate limiting and throttling both control how much someone can use your API, but they handle it differently. Here's what actually separates them.
> Rate limiting blocks requests
Rate limiting sets a hard cap on how many requests you can make in a time window. If you hit 100 requests per minute and try a 101st, the server rejects it with a 429 status code. You're blocked until the window resets. The request doesn't happen at all.
> Throttling slows requests down
Throttling doesn't reject requests outright. Instead, it delays them or reduces their processing speed. If you exceed your limit, the server queues your request and processes it slower. You still get a response, just not immediately. Think of it like traffic control instead of a roadblock.
> When rate limiting makes sense
Use rate limiting to protect against abuse or accidental overload. If someone writes a buggy script that hammers your API thousands of times per second, rate limiting stops it cold. This prevents one user from taking down your service for everyone else.
> When throttling makes sense
Throttling works better when you want to be lenient but still enforce limits. A user going slightly over their quota doesn't get cut off completely, they just experience slower responses. This keeps legitimate users happy while still controlling load.
> How rate limiting is implemented
Most rate limiters use token bucket or sliding window algorithms. With token bucket, you get a certain number of tokens that refill over time. Each request costs one token. No tokens means no service. Sliding window tracks requests in a rolling time period and counts them against your limit.
> How throttling is implemented
Throttling often uses queues or deliberate delays. Requests beyond a threshold get put in a queue and processed at a controlled rate. Some systems add artificial sleep time before responding. Others reduce resource allocation for that user's requests so they run slower.
> Example with APIs
An API might rate limit you to 1000 requests per hour. If you hit 1001, you get rejected and have to wait until the hour resets. That same API might throttle you if you burst 100 requests in one second by queuing extras and processing them over the next few seconds instead of all at once.
> User experience differences
Rate limiting gives clear feedback through error codes. You know you hit the limit and need to back off. Throttling is subtler. Responses just take longer. Users might not realize they're being throttled, they just think the service is slow.
> Combining both approaches
Many systems use both. Rate limiting acts as the hard stop for extreme abuse. Throttling kicks in before you hit that limit to smooth out bursts. You might throttle at 80% of capacity and rate limit at 100%. This gives users a grace period to adjust before getting blocked.
> HTTP headers for rate limiting
Rate limited APIs return headers like X-RateLimit-Limit, X-RateLimit-Remaining, and X-RateLimit-Reset. These tell you your quota, how much is left, and when it refreshes. Clients can use this to pace themselves and avoid hitting the limit.
> Throttling doesn't always communicate limits
Throttled requests might just respond slowly without special headers. Some APIs do include throttling indicators, but it's less standardised than rate limiting headers. This makes throttling harder for clients to handle programmatically.
> Cloud service examples
AWS API Gateway does rate limiting with hard request quotas. If you exceed your quota, requests fail. AWS Lambda does throttling where excess invocations get queued or rejected based on concurrency limits. Both protect the service but handle overages differently.
> Database connection pools
Connection pools throttle by making excess requests wait for an available connection. If all connections are busy, new requests queue up. This is throttling because requests eventually process, they just wait. A rate limiter would reject those requests instead.
> DDoS protection uses rate limiting
When defending against distributed denial of service attacks, you need hard limits. Throttling wouldn't help because attackers don't care about slow responses. Rate limiting blocks malicious traffic entirely and protects backend resources.
> Pricing tier enforcement
SaaS products often rate limit based on your plan. Free tier gets 100 requests per day, paid tier gets 10,000. This is a hard business rule enforced by rate limiting. Throttling wouldn't work here because you need clear boundaries between service levels.
> The key difference summarised
Rate limiting is binary. You're either within your limit or you're not. Throttling is gradual. It degrades performance instead of cutting access. Both manage load, but rate limiting is stricter and throttling is more forgiving. Choose based on whether you need hard enforcement or smooth degradation.
TLDR -
The difference is clear in practice.
Rate limiting puts a strict cap like 100 requests in a minute. Anything above that gets rejected right away, usually with a 429 response.
Throttling lets the requests through but adds delay when things go over the allowed speed. So the extra calls are not dropped, just processed slower to avoid overload.
Rate limiting enforces hard rules and blocks excess. throttling shapes the flow and keeps processing everything, only slower.
In many systems both get used together depending on the situation.
Christian N. Crispy retweeted
Dear Authorities, @RIB_Rw,
@Murangira_BT, @fnamuh, @Rwandapolice, @Muhangadis, @KAYITAREJacky, @CityofKigali, @dusengiyumvas,
@UrugwiroVillage
I am writing to seek your assistance regarding my case involving an individual named Maurice NGABONZIZA, who works as a documentalist at @RwandaParliamnt and who uses this position and influence while pretending to be untouchable (umunyamategeko).
As you can see from the attached screenshots, he produced four forged powers of attorney (with the help of a notary), two of which were made in my name, using a forged signature.
Through these fraudulent documents, he was able to illegally appropriate family plots of land with houses.
I am aware that these actions constitute criminal offenses punishable by law. I therefore question why he has not been held accountable like others.
Thank you for your assistance.
Best wishes for the end-of-year holidays.
Christian N. Crispy retweeted
How Deployment, Service & Ingress connect in Kubernetes ?
Think of Kubernetes traffic flow like this 👇
🔹 Deployment
- Creates & manages Pods
- Ensures desired replicas are always running
➡️Deployment defined service labels in manifest to connect with service
🔹 Service
- Exposes Pods internally
- Uses labels & selectors to route traffic
- Provides a stable endpoint (IP/DNS)
➡️Service defined selectors in manifest to connect with deployment
🔹 Ingress
- Entry point for external traffic
- Routes requests based on host/path
- Forwards traffic to the correct Service
➡️Ingress defined service name in manifest to connect with service
Flow: User → Ingress → Service → Pods (Deployment)
Christian N. Crispy retweeted
When deploying cluster-wide tools like Splunk Otel, choosing the right Kubernetes pattern DaemonSet or Sidecar is crucial for defining scope and efficiency.
They solve fundamentally different problems:
🔹 DaemonSets: Cluster-Wide Coverage 🌐
- A Kubernetes API resource designed to ensure a specific pod runs on every node in the cluster.
- If you scale up your cluster, the DaemonSet automatically places a new pod on that new node.
- Scope: Node-level and cluster-wide.
- Use Cases:
DaemonSets are essential for critical components that must exist on every host.
Examples include running a log collector (like Fluentd) to pick up all pod logs on that node,, deploying a monitoring agent per node (like Node Exporter for Prometheus), or provisioning storage,.
Reliability Insight: DaemonSet pods are scheduled differently and are designed to tolerate node problems like network partition, disk pressure, and memory pressure, prioritizing their deployment even when the default scheduler might deem the node unschedulable,.
🔹The Sidecar Pattern: Application Augmentation ⚙️
- The Sidecar pattern involves running multiple containers within the same pod alongside the main application container.
The sidecar container enhances or extends the main application's functionality.
- Scope: Application-level and pod-specific.
- Shared Resources:
Containers in the same pod can share the same file system using volume mounts, enabling the sidecar to access the main application's files, such as log files or configuration.
- Use Cases:
1. Distributed Tracing: Sidecars are frequently used to run processing containers that hook into microservice runtimes (e.g., .Net, GoLang) and send tracers out to Open Telemetry collectors,.
2. Configuration Management: A sidecar can be used to monitor changes to configuration files (e.g., from a ConfigMap) and then send a hang-up signal to the main application process (like Nginx) to force a hot reload without requiring a full pod restart. For this to work, the pod must be configured to share the process namespace.
3. Legacy Integration: Sidecars help run legacy applications by handling complicated runtime setup, such as injecting secret values into configuration files that the legacy application requires
Christian N. Crispy retweeted
Want to get better at Kubernetes?
Here are the free guides to help you actually understand Kubernetes 👇
📌 From architecture to Argo CD
📌 From EKS to Vault
📌 From init containers to Ingress
This list covers it all:
✅ Setup & Cluster Design
✅ Real-world Deployment Practices
✅ Security, Logging, and more
Here are some must-reads:
- Kubernetes Architecture: devopscube.com/kubernetes-ar…
- High Availability: devopscube.com/kubernetes-hi…
- DaemonSet: devopscube.com/kubernetes-da…
- Init Containers: devopscube.com/kubernetes-in…
- Pod Lifecycle: devopscube.com/kubernetes-po…
- Ingress Basics: devopscube.com/kubernetes-in…
- Kubernetes gateway API: devopscube.com/kubernetes-ga…
- Istio Guide: devopscube.com/setup-istio-o…
🧵 𝗛𝗲𝗿𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗳𝘂𝗹𝗹 𝗹𝗶𝘀𝘁 𝗼𝗳 𝗴𝘂𝗶𝗱𝗲𝘀: devopscube.com/kubernetes-tu…
✅ Bookmark this
♻️ Repost if it helps others
#DevOps #Kubernetes #LearningResources






































