4nny B4rr3to 🏳️‍🌈

Programmer Student 🤓👩🏼‍💻

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

Dia de desafio CTF 🤪🤪
Será q vou ficar estagnada nesse desafio 🤣🤣
Já achei coisa q n tem nd haver com o desafio e nd da resposta 🤣🤣🤣😼

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

🌥️🍃

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

Um dos meus livros favoritos 😍😍😍🥰

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

📖📖🤓📚📚💭

[0xor0ne @0xor0ne]

Reverse engineering and malware analysis for beginners

Part 1: https://t.co/tBYUcvO57g
Part 2: https://t.co/dbs4yVr2L5

#malware #infosec

[Sahn Lam @sahnlam]

Scaling Database: When and How to Shard

Database sharding refers to splitting data across multiple database servers and is commonly used for scaling. However, sharding introduces major operational and infrastructure complexity that should be 𝗮𝘃𝗼𝗶𝗱𝗲𝗱 𝘂𝗻𝗹𝗲𝘀𝘀 𝗮𝗯𝘀𝗼𝗹𝘂𝘁𝗲𝗹𝘆 𝗻𝗲𝗰𝗲𝘀𝘀𝗮𝗿𝘆.

𝗔𝗹𝘁𝗲𝗿𝗻𝗮𝘁𝗶𝘃𝗲 𝗦𝗰𝗮𝗹𝗶𝗻𝗴 𝗔𝗽𝗽𝗿𝗼𝗮𝗰𝗵𝗲𝘀

Vertical Scaling: Use more powerful single database servers with more CPUs, memory, storage and I/O bandwidth. Much simpler to manage than sharding.

SQL Optimization: Tune SQL queries and database schema to maximize performance on a single server using proper indexes, efficient SQL, etc.

Caching: Use in-memory caches like Redis to reduce database load by serving common queries from the cache instead of hitting the database every time.

Read Replicas + Load Balancer: Add horizontal read scaleability without full complexity of sharding. Directs reads across replicas.

These optimization approaches should be exhausted before considering sharding.

𝗦𝗵𝗮𝗿𝗱𝗶𝗻𝗴 𝗠𝗲𝘁𝗵𝗼𝗱𝘀

There are two high-level approaches:

Vertical Sharding: Split database into columnar tables or sections vs rows. For example, having one table for names and another table for emails.

Horizontal Sharding: Split database into row partitions distributed evenly across multiple servers. Methods include range based, directory based, and hash based sharding.

𝗪𝗵𝗲𝗻 𝘀𝗵𝗮𝗿𝗱𝗶𝗻𝗴, 𝘂𝘀𝗲 𝘁𝗵𝗲 𝘀𝗶𝗺𝗽𝗹𝗲𝘀𝘁 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 that meets requirements to minimize complexity. Seek to avoid sharding until necessary despite the scaling benefits. The infrastructure and operational overheads often outweigh gains.

–
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/kNfv0DVDdf

[0xor0ne @0xor0ne]

GhostRace: race conditions on speculatively executed code paths

Paper: https://t.co/WK8A54TDXl
Website: https://t.co/VBfZa9Sbvr
GitHub PoC: https://t.co/cNt3mTQyCT

#infosec #security

[Bytebytego @bytebytego]

Top 6 Load Balancing Algorithms.

🔹 Static Algorithms
1. Round robin
The client requests are sent to different service instances in sequential order. The services are usually required to be stateless.

2. Sticky round-robin
This is an improvement of the round-robin algorithm. If Alice’s first request goes to service A, the following requests go to service A as well.

3. Weighted round-robin
The admin can specify the weight for each service. The ones with a higher weight handle more requests than others.

4. Hash
This algorithm applies a hash function on the incoming requests’ IP or URL. The requests are routed to relevant instances based on the hash function result.

🔹 Dynamic Algorithms
5. Least connections
A new request is sent to the service instance with the least concurrent connections.

6. Least response time
A new request is sent to the service instance with the fastest response time.

--
Subscribe to our weekly newsletter to get a Free System Design PDF (158 pages): https://t.co/FIzCeaWsZV

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

Os servidores do WhatsApp só no vermelho 😂😂😂

[0xor0ne @0xor0ne]

Reverse engineering and vulnerability analysis of DJI drones' firmware.
A two-parts blog series by @nozominetworks

Firmware Analysis: https://t.co/iS1ZZJGpFC
Vulnerability Analysis: https://t.co/AWxOI1FzTd

Particularly interesting is the chain of weak Wi-Fi password cracking (CVE-2023-6951) followed by the unauthenticated video exfiltration (CVE-2023-6949)

#dji #drone

[LetsDefend @LetsDefendIO]

Linux File Systems

[LetsDefend @LetsDefendIO]

File System - Linux

[Nikki Siapno @NikkiSiapno]

This week we will cover:

— SQL execution order
— Edge computing vs cloud computing
— DNS lookup
— Serverless architecture best practices & pitfalls

Don’t want to miss out? Subscribe to our free newsletter for a weekly deep dive & content roundup: https://t.co/o8ShggS5mk

[0xor0ne @0xor0ne]

TETRA (Terrestrial Trunked Radio): security analysis and vulnerabilities
Great research work by Carlo Meijer, Wouter Bokslag and Jos Wetzels

Paper: https://t.co/vx9onVy2FR
Slides: https://t.co/ua14ZIWwKk
Repo: https://t.co/cDg89pkvNG

#tetra #wireless #infosec

[0xor0ne @0xor0ne]

Internals of compilers, linkers, JITs and assemblers with focus on software security hardening)

Low-Level Software Security for Compiler Developers:
https://t.co/7tIZD6zFwP

#infosec #compilers #cybersecurity

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

Moto Fest 👻😜🏍️

[LetsDefend @LetsDefendIO]

8 Popular Network Protocols

[4nny B4rr3to 🏳️‍🌈 @4nnymb]

🌞☁️

[Stanislav Kozlovski @kozlovski]

HTTPS is used everywhere.

But most engineers can’t explain how it simply works.

Let’s change that.

HTTP is a protocol to exchange data, most popularly used between a web browser and a website. 💡

HTTPS is the secure version of that protocol. 🛡

Why is it secure?

Encryption. 😶‍🌫️

The data is encrypted so that only the web browser and the website can read it locally.

Without this, man-in-the-middle (MITM) attacks could intercept your traffic and read sensitive data like passwords, credit card details, etc. 😱

The protocol used to encrypt the data is TLS (Transport Layer Security).

HTTPS = HTTP + TLS. Simple as that.

HTTPS uses asymmetric cryptography to encrypt the data. You have:

🔑 a private key - the website’s SSL certificate’s secret key that isn’t shared with anyone.

🔑 a public key - the certificate’s public key, shared with everyone who wants to interact with the website.

💡 Asymmetric cryptography simply means information that’s encrypted by the public key can only be decrypted by the private key. And vice versa.

In contrast, symmetric cryptography is when only one key is used, and data can be encrypted/decrypted with that same key.

HTTPS actually uses both types! 😎

Asymmetric cryptography is used to verify the server and securely generate a session key that’ll be used for symmetric cryptography.

The session key, as it implies, only lives within the session and is used by both the client & server to encrypt/decrypt data.

Most interestingly, this key is deterministically generated by both the client and server independently - it never crosses the wire. 🪄

So. What are the steps?

1. Client (browser) connects to a server (web page)
2. Server sends its SSL certificate (includes the public key).
3. Client & Server do a TLS handshake & generate a session key to encrypt/decrypt future HTTP data.
4. Business as usual.

The details are in the TLS handshake, and that’s frankly the most interesting part of how HTTPS works.

The TLS handshake serves three purposes:

🧐 1. authenticate the identity of the server
✨ 2. generate session keys for encryption during this single session
🤝 3. decide which version of TLS and what cipher suites you’ll use

Step by step (RSA Algorithm):

1. Client Hello Request: The client initiates the handshake with a message including what TLS version and ciphers it supports, including a string of random bytes (client random)

2. Server Hello Response: The server chooses a cipher suite and generates its own random string bytes (server random). It responds with the suite, its SSL certificate, and the server random.

3. Client Verification: The client verifies the certificate via the trusted certificate authority that issued it. The SSL certificate has a digital signature that’s signed by the CA’s private key so the client uses the CA’s public key to decrypt it.

After this step, the Client has verified that the certificate is the legitimate one verified via the CA - not one fabricated on the fly.

Note it still doesn’t know for sure whether the server actually owns that certificate (i.e has the private key)

Side note: who says what Certificate Authority can be trusted?

Your browser’s provider!

Apple, Microsoft, Google, Mozilla and etc. all maintain their own lists of CAs.

Your browser and operating system ship with this list of trusted CAs.

It’s all based on “trust”, so you better trust them!

Anyway, continuing...

4. Client Key Exchange: The client creates a random string of bytes called the “premaster secret”. It encrypts it with the public key of the server it got from the SSL certificate and sends it over.

5. Session Key Generation: The server decrypts the premaster secret using the SSL certificate’s private key. Both the client and server, independently, generate session keys using the client random, server random, and the premaster secret.

Since they’re using the same data and deterministic algorithm, they should arrive at the same results. If they don’t - the subsequent encryption/decryption won’t result in the HTTP protocol.

💡 This step indirectly verifies to the client that the server has possession of the SSL certificate it presented (it didn’t just pretend to have it)

6. Done! The session key is now used to symmetrically encrypt/decrypt HTTP data.

[LetsDefend @LetsDefendIO]

What happens when you type a URL into a browser?