T4QI-Blog

Quadratic Residues

Fri, 20 Feb 2026 00:00:00 +0000

1. The Concept: Quadratic Residues

In modular arithmetic, an integer $a$ is considered a Quadratic Residue (QR) modulo $n$ if it has a perfect square root under that modulus. Mathematically, there exists some integer $x$ such that:

$$x^2 \equiv a \pmod n$$

If no such integer $x$ exists, then $a$ is a Quadratic Non-Residue (QNR).

Brute Force Implementation

For small numbers, we can iterate through all possible values in the modulus to see if their square matches our target number.

Group Theory and Modular Arithmetic – Foundations for Basic Cryptography

Sun, 15 Feb 2026 00:00:00 +0000

Cryptography relies heavily on specific mathematical structures and number theory. This post breaks down the fundamental definitions of Groups, Modular Arithmetic, and key theorems like the GCD and the Chinese Remainder Theorem based on my study notes.

1. Group Theory

To understand modern encryption (like RSA or Elliptic Curve Cryptography), we must first define the algebraic structures they operate on.

Semigroups

A set $S$ combined with a binary operation $\circ$ is a Semigroup if it satisfies:

Baby_Time_Capsule

Tue, 27 Jan 2026 00:00:00 +0000

Vulnerability Analysis

The provided server.py script reveals the following cryptographic setup:

Message: The same FLAG is encrypted every time a user requests a “time capsule.”
Public Exponent ($e$): Fixed at 5.
Modulus ($n$): A new $1024$-bit RSA modulus is generated for every request.
Process: Each time you ask for a capsule, the server provides a new ciphertext $c_i \equiv m^5 \pmod{n_i}$ and the corresponding public key $(n_i, 5)$.

BabyEncryption

Tue, 27 Jan 2026 00:00:00 +0000

This challenge is a classic example of an Affine Cipher applied at the byte level. Here is a breakdown of how the encryption works and how to reverse it to retrieve the message.

Understanding the Encryption

The provided chall.py script performs a simple linear transformation on each character of the secret message. The mathematical formula for the encryption is:

$$E(x) = (ax + b) \pmod{n}$$

Based on the source code:

Embryonic_Plant

Tue, 27 Jan 2026 00:00:00 +0000

This challenge involves a custom Linear Congruential Generator (LCG) where the parameters of the RNG are tied to the factors of an RSA modulus.

Analysis of the RNG

The RNG class uses three primes: $p$, $q$, and $r$. The modulus $n$ is the product of these three:

$n = p \cdot q \cdot r$

The state of the RNG updates as follows:

$s_{i} = (s_{i-1} \cdot p + q) \pmod{r}$

Protein_Cookies

Tue, 27 Jan 2026 00:00:00 +0000

This challenge involves exploiting a Hash Length Extension vulnerability in a Flask web application to elevate privileges from a guest user to an authenticated member.

Vulnerability Analysis

Prefix-MAC Construction

The application’s core vulnerability lies in how it generates and validates session signatures in models.py. The signature is created by prepending a 16-byte secret to the payload and hashing it with SHA-512:

Python

TEXT

# models.py
hashlib.sha512(secret + payload).hexdigest()

Because SHA-512 uses the Merkle-Damgård construction, an attacker who knows the length of the secret and the original message can calculate the hash of a new message that begins with the original message and its padding.

Quantum_Safe

Tue, 27 Jan 2026 00:00:00 +0000

The challenge provides a SageMath script used to encrypt a flag and an output file containing the resulting ciphertext vectors. The encryption process uses a linear transformation involving a 3x3 public key matrix, a random noise vector, and a constant shift vector.

Encryption Method

Based on the source.sage file, each character $c$ of the flag is processed as follows:

A vector is created using the character’s ASCII value and two random integers: $v = [ord(c), \text{rand}_1, \text{rand}_2]$.

Rhome

Tue, 27 Jan 2026 00:00:00 +0000

This challenge implements a Diffie-Hellman (DH) key exchange but introduces a critical mathematical vulnerability: the generator $g$ operates within a very small subgroup of the prime field.

Analysis of the Source (`server.py`)

The security of Diffie-Hellman relies on the Discrete Logarithm Problem (DLP) being hard. However, the server constructs its parameters $p$ and $g$ in a specific way:

Prime Construction: $p = 2qr + 1$, where $q$ is a 42-bit prime and $r$ is a 512-bit prime.

RSAisEasy

Tue, 27 Jan 2026 00:00:00 +0000

This challenge presents an RSA-based cryptography problem where two separate flags are encrypted using moduli that share a common prime factor $q$.

Challenge Overview

The script RSAisEasy.py performs the following operations:

Generates three 512-bit primes: $p$, $q$, and $z$.
Creates two RSA moduli: $n_1 = p \times q$ and $n_2 = q \times z$.
Encrypts flag1 using $n_1$ and flag2 using $n_2$ with the standard public exponent $e = 65537$.

The_Last_Dance

Tue, 27 Jan 2026 00:00:00 +0000

This challenge demonstrates a critical cryptographic flaw: Nonce Reuse in a stream cipher. When the same key and nonce are used to encrypt two different messages, the security of the cipher is compromised.

Analysis

The provided source.py script reveals how the encryption is handled:

Cipher: ChaCha20 (a stream cipher).
The Flaw: Both the message and the FLAG are encrypted using the same key and the same iv (nonce).

xorxorxor

Tue, 27 Jan 2026 00:00:00 +0000

This challenge involves a hex-encoded ciphertext encrypted using a repeating 4-byte XOR key. In XOR cryptography, if you know a portion of the original message (plaintext), you can easily recover the key and decrypt the rest of the file.

Analysis

The provided encryption script reveals three critical pieces of information:

Key Length: os.urandom(4) tells us the key is exactly 4 bytes long.
Algorithm: It uses a repeating XOR: data[i] ^ key[i % 4].

Aswan CTF RSA Signature Challenges

Sun, 27 Apr 2025 00:00:00 +0000

Description: “can u break my RSA Signature system …”

السلام عليكم ورحمة الله وبركاته

Today, I am going to show how I solved the RSA Signature challenge with a creative approach which I think no one thought of.

PYTHON


from Crypto.Util.number import getPrime,long_to_bytes

FLAG=b'redacted'
m=b'give_me_the_flag'


p=getPrime(512)
q=getPrime(512)
n=p*q
phi=(p-1)*(q-1)
e=0x10001
d=pow(e,-1,phi)
def sign(msg):
	signed=pow(msg,d,n)
	return signed
def verify(s,m):
	msg=pow(s,e,n)
	return long_to_bytes(msg)==m
banner='''1.sign
2.verify
3.exit'''


while True:
	print(banner)
	option=int(input('> '))
	if option==1:
		msg=int(input('enter your msg as hex > '),16)
		if msg==m:
			print('that will not work here ')
			exit()
		s=sign(msg)
		print(f'here is your signed msg : {hex(s)}')

	elif option==2:
		s=int(input('enter your signed msg as hex > '),16)
		if verify(s,m):
			print(f'you got me this time here is the flag : {FLAG}')
			exit()
		else:
			print('wrong msg try harder ')
	else:
		exit()

This is code for the challenge we see here that we need to sign ‘give_me_the_flag’ and then verify it to get the flag but the code will not accept submitting ‘give_me_the_flag’ directly so how will we do it ??

The approach that I took is to transform the ‘give_me_the_flag’ into integer then factor it by factor db then sign the two factors then sign each one then multiply the two signed factors then verify them to get the flag let’s try this.

PYTHON

messege = b'give_me_the_flag'                                
print(int.from_bytes(messege))

then I got an int 137458076091903464215105250758897721703 let’s find it’s factors by factor db

Osint challenges in Aswan CTF finals

Sun, 27 Apr 2025 00:00:00 +0000

Welcome to our write-up for the Aswan CTF 2025, where our team, 0xD4wn, battled it out among fierce competitors to secure a well-earned second place! The competition was a thrilling test of skills, with challenges spanning various domains, but the OSINT (Open-Source Intelligence) category truly put our investigative prowess to the test. In this write-up, we’ll dive into the three gripping OSINT challenges that had us chasing digital breadcrumbs across blockchains and social platforms. From unmasking a notorious crypto whale to tracing their financial trails, here’s how we tackled