repo stringlengths 7 90 | file_url stringlengths 81 315 | file_path stringlengths 4 228 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 14:38:15 2026-01-05 02:33:18 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/tests/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/tests/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/environ.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/environ.py | import os
def getenv(key: str) -> str:
"""Get environment variable and raise an error if it is unset."""
if val := os.getenv(key):
return val
msg = "ENV variable %s is required!"
raise OSError(msg % key)
IS_DEV = os.getenv("ENV") == "DEV"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/utils.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/utils.py | from base64 import urlsafe_b64decode, urlsafe_b64encode
def encode(content: bytes | str) -> str:
def _encode():
if isinstance(content, str):
return urlsafe_b64encode(content.encode()).decode()
return urlsafe_b64encode(content).decode()
return _encode().replace("=", "")
def decode(content: str | bytes) -> bytes:
rem = len(content) % 4
if rem > 0:
try:
content += b"=" * (4 - rem)
except Exception:
content += "=" * (4 - rem)
if isinstance(content, str):
return urlsafe_b64decode(content.encode())
return urlsafe_b64decode(content)
def chunk(stuff: bytes):
"""Chunk stuff into 16 byte blocks."""
assert len(stuff)
assert len(stuff) % 16 == 0
blocks = []
for i in range(0, len(stuff), 16):
blocks.append(stuff[i : i + 16])
return blocks
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/resp.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/resp.py | from __future__ import annotations
from fastapi import HTTPException, status
PERMISSION_DENIED = HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Permission denied.",
)
def not_found(model: object) -> HTTPException:
return HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"{model.__name__} not found.",
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/auth.py | from __future__ import annotations
import json
from datetime import UTC, datetime, timedelta
from pathlib import Path
from secrets import randbits
from typing import Annotated
from Crypto.Util.number import getPrime, long_to_bytes
from fastapi import Cookie, Depends, HTTPException, Response, status
from mvmcryption.crypto.cipher import SCBCCipher
from mvmcryption.crypto.ecdsa import ECDSA, private_key
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.crypto.rsa import RSA, PrivKey
from mvmcryption.db.users import User, Users
from mvmcryption.resp import PERMISSION_DENIED
SJWT_TTL = timedelta(minutes=15)
def global_ecdsa(private_key: Annotated[int, Depends(private_key)]) -> ECDSA:
return ECDSA(private_key)
def global_sjwt(ecdsa: Annotated[ECDSA, Depends(global_ecdsa)]):
return SJWT(ecdsa)
def create_sjwt(user: User, sjwt: SJWT, expires: datetime | None = None) -> str:
_expires = expires or (datetime.now(UTC) + SJWT_TTL)
return sjwt.encode({"sub": user.id, "exp": _expires.isoformat()})
def decode_sjwt(token: str, sjwt: SJWT, users: Users) -> User | None:
if not token:
return None
try:
decoded = sjwt.decode(token)
except Exception:
return None
if not (
expiry_str := decoded.get("exp")
): # no expiry -> some token generated by an admin
return None # for ~~security~~ budget reasons this is disabled right now # TODO: fix this
if not isinstance(expiry_str, str):
return None
try:
expiry = datetime.fromisoformat(expiry_str)
except Exception:
return None
if not expiry or expiry <= datetime.now(UTC):
return None
user_id = decoded.get("sub")
if user_id is None:
return None
if not isinstance(user_id, int):
return None
user = users.find(user_id)
if user is None:
return None
return user
def authorized_user(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
response: Response,
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
user = decode_sjwt(mvmcryptionauthtoken, sjwt, users)
if not user:
if mvmcryptionauthtoken:
response.delete_cookie("mvmcryptionauthtoken")
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Unauthorized.",
)
return user
def admin_user(user: Annotated[User, Depends(authorized_user)]):
if not user.is_admin:
raise PERMISSION_DENIED
return user
def _aes_key() -> bytes:
f = Path("/etc/aes-key")
if not f.exists():
f.write_bytes(long_to_bytes(randbits(128)))
return f.read_bytes()
def global_rsa() -> RSA:
f = Path("/etc/rsa")
if not f.exists():
key = PrivKey(getPrime(1024), getPrime(1024), 0x10001)
f.write_text(json.dumps(key.__dict__))
rsa = RSA(PrivKey(**json.loads(f.read_text())))
assert rsa.verify(b"hello", rsa.sign(b"hello"))
return rsa
GlobalRSA = Annotated[RSA, Depends(global_rsa)]
def global_aes(key: Annotated[bytes, Depends(_aes_key)]):
return SCBCCipher(key)
AuthorizedUser = Annotated[User, Depends(authorized_user)]
AdminUser = Annotated[User, Depends(admin_user)]
GlobalECDSA = Annotated[ECDSA, Depends(global_ecdsa)]
GlobalSCBCCipher = Annotated[SCBCCipher, Depends(global_aes)]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/app.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/app.py | from fastapi import APIRouter, FastAPI
from mvmcryption.db import initialize
from mvmcryption.environ import IS_DEV
from mvmcryption.routers import auth, crypto, users
tags_metadata = [
{
"name": "users",
"description": "Operations with users.",
},
{
"name": "crypto",
"description": "Cryptography stuff.",
},
{
"name": "auth",
"description": "Logout/Login/Register stuff.",
},
]
app = FastAPI(
title="Much Vulnerable Machine API",
description="3AM Crypto chall.",
version="dQw4w9WgXcQ",
openapi_tags=tags_metadata,
)
if IS_DEV:
from fastapi.middleware.cors import CORSMiddleware
# building a frontend is left as exercise for the player
app.add_middleware(
CORSMiddleware,
allow_origins=[
"http://localhost:5173",
"http://localhost:4200",
"http://localhost:3000",
],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.add_event_handler("startup", initialize)
api_router = APIRouter(prefix="/api")
api_router.include_router(auth)
api_router.include_router(crypto)
api_router.include_router(users)
app.include_router(api_router)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/users.py | from __future__ import annotations
from argon2 import PasswordHasher, exceptions
from pydantic import EmailStr, SecretStr
from .db import BaseModel, DBModel
PH = PasswordHasher()
class User(BaseModel):
username: str
email: EmailStr
password: SecretStr
@property
def is_admin(self):
return self.id == 1
def send_email(self, subject: str, content: str) -> None:
"""Send e-mail to user."""
class Users(DBModel[User]):
tablename = "users"
model = User
columns = (
"username",
"email",
"password",
)
mutable_columns = (
"username",
"email",
)
def find_by_username(self, username: str):
return self.find_by("username")(username)
def create(self, *, username: str, email: str, password: str) -> User:
_password = PH.hash(password)
return self.insert(
{"username": username, "email": email, "password": _password},
)
def login(self, username: str, password: str) -> User | None:
if not (u := self.find_by_username(username)):
return None
try:
PH.verify(u.password.get_secret_value(), password)
return u
except exceptions.VerifyMismatchError:
return None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/db.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/db.py | from __future__ import annotations
import sqlite3
from abc import ABC, abstractmethod
from collections.abc import Callable, Iterator, Sequence
from contextlib import contextmanager
from typing import Annotated, Generic, TypeVar
from fastapi import Depends
from pydantic import BaseModel as _BaseModel
from mvmcryption.environ import getenv
DB_PATH = getenv("DB_PATH")
def connect_dependency() -> sqlite3.Connection:
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
conn.autocommit = True
return conn
@contextmanager
def connect() -> Iterator[sqlite3.Connection]:
conn = connect_dependency()
try:
yield conn
finally:
conn.close()
class BaseModel(_BaseModel):
id: int
T = TypeVar("T", bound=BaseModel)
V = TypeVar("V")
class DBModel(ABC, Generic[T]):
def __init__(self, conn: sqlite3.Connection) -> None:
self.conn = conn
@classmethod
@property
@abstractmethod
def tablename(cls) -> str:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def mutable_columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def model(cls) -> type[T]:
raise NotImplementedError
@classmethod
@property
def select_query(cls) -> str:
return f"SELECT * FROM {cls.tablename} "
@classmethod
@property
def delete_query(cls) -> str:
return f"DELETE FROM {cls.tablename} "
@classmethod
@property
def insert_query(cls) -> str:
return f"INSERT INTO {cls.tablename} ({', '.join(cls.columns)}) VALUES ({', '.join(f':{col}' for col in cls.columns)}) RETURNING *;"
@classmethod
@property
def update_query(cls) -> str:
return f"UPDATE {cls.tablename} SET {', '.join([f'{col} = :{col}' for col in cls.mutable_columns])} "
@contextmanager
def cur(self) -> Iterator[sqlite3.Cursor]:
cur = self.conn.cursor()
try:
yield cur
finally:
cur.close()
def delete(self, id: int) -> None:
return self.delete_by("id")(id)
def delete_by(self, lookup: str) -> None:
q = self.delete_query + f"WHERE {lookup} = ?;"
def _delete_by(value) -> None:
with self.cur() as cur:
cur.execute(q, [value])
return _delete_by
def insert(self, params: dict, **kwargs) -> T:
with self.cur() as cur:
cur.execute(self.insert_query, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
def update(self, id: int, params: dict) -> T:
return self.update_by("id")(id, params)
def update_by(self, lookup: str) -> Callable[[dict, ...], T]:
if not self.update_query:
raise Exception("Model is readonly.")
q = self.update_query + f"WHERE {lookup} = :lookup RETURNING *;"
def _update_by(value, params: dict, **kwargs) -> T:
params["lookup"] = value
with self.cur() as cur:
cur.execute(q, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
return _update_by
def find(self, id: int) -> T | None:
return self.find_by("id")(id)
def find_by(self, lookup: str) -> Callable[[V], T]:
q = self.select_query + f"WHERE {lookup} = :{lookup};"
def _find_by(value) -> T | None:
with self.cur() as cur:
cur.execute(q, [value])
if record := cur.fetchone():
return self.model(**record)
return None
return _find_by
def all(self) -> list[T]:
q = self.select_query + ";"
with self.cur() as cur:
cur.execute(q)
return [self.model(**record) for record in cur.fetchall()]
@classmethod
def dependency(cls, db: Annotated[sqlite3.Connection, Depends(connect_dependency)]):
return cls(db)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/db/__init__.py | from __future__ import annotations
from mvmcryption.environ import getenv
from .db import connect
from .users import Users
ADMIN_PASSWORD = getenv("ADMIN_PASSWORD")
TABLE_QUERY = """
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
email VARCHAR(100) NOT NULL UNIQUE,
password VARCHAR(100) NOT NULL
);
"""
def initialize() -> None:
with connect() as conn:
conn.executescript(TABLE_QUERY)
try:
Users(conn).create(
username="admin",
email="admin@this-company-luckily-does-not-exist.mvm",
password=ADMIN_PASSWORD,
)
except Exception as e: # maybe it already exists
print(e)
__all__ = [
"Users",
"initialize",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/users.py | from typing import Annotated, Literal
from fastapi import APIRouter, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr
from mvmcryption.auth import AuthorizedUser
from mvmcryption.db import Users
from mvmcryption.resp import PERMISSION_DENIED, not_found
from mvmcryption.routers.auth import USERNAME_FIELD
users_router = APIRouter(prefix="/users", tags=["users"])
class UpdateBody(BaseModel):
username: str = USERNAME_FIELD
email: EmailStr
@users_router.get("/")
def user_list(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
):
if user.is_admin:
return users.all()
return [user]
@users_router.patch("/{user_id}")
def update_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
body: UpdateBody,
):
"""Whoa! im updating things!"""
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if user.id != user_id:
user = users.find(user_id)
if user.username != body.username and users.find_by("username")(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if user.email != email and users.find_by("email")(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
try:
return users.update(user.id, dict(username=body.username, email=email))
except Exception:
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
@users_router.delete("/{user_id}")
def delete_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
response: Response,
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
users.delete(user_id)
response.delete_cookie("mvmcryptionauthtoken", secure=False, httponly=True)
response.status_code = status.HTTP_204_NO_CONTENT
@users_router.get("/{user_id}")
def user_detail(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if record := users.find(user_id):
return record
raise not_found(Users.model)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/crypto.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/crypto.py | from datetime import datetime
from random import getrandbits
from Crypto.Util.number import long_to_bytes
from fastapi import APIRouter
from pydantic import BaseModel, validator
from mvmcryption.auth import (
AuthorizedUser,
GlobalECDSA,
GlobalRSA,
GlobalSCBCCipher,
)
from mvmcryption.environ import getenv
from mvmcryption.utils import decode, encode
FLAG = getenv("FLAG").encode()
crypto_router = APIRouter(prefix="/crypto", tags=["crypto"])
class ValidationBody(BaseModel):
ciphertext: str
iv: str
signature: str
debug: bool = False
@validator("ciphertext")
def validate_ciphertext(v):
try:
decoded = decode(v)
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
if len(decoded) % 16 != 0:
msg = "????"
raise ValueError(msg)
return v
@validator("iv")
def validate_iv(v):
try:
decoded = decode(v)
assert len(decoded) == 16
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
return v
@validator("signature")
def validate_signature(v):
try:
decoded = int(v, 16)
assert decoded > 1
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
return v
@crypto_router.get("/public-key")
def ecdsa_public_key(ecdsa: GlobalECDSA) -> dict:
"""ECDSA Public Key."""
return ecdsa.pretty_public_key
@crypto_router.get("/rsa-public-key")
def rsa_public_key(_user: AuthorizedUser, rsa: GlobalRSA) -> dict:
"""RSA Public Key."""
return {
"N": hex(rsa.priv.n),
"e": hex(rsa.priv.e),
}
@crypto_router.post("/decrypt")
def decrypt(user: AuthorizedUser, cipher: GlobalSCBCCipher, body: ValidationBody):
"""
Real men test in production.
- Our CISO, probably
"""
if body.debug:
if not user.is_admin:
raise ValueError("no.")
try:
res = cipher.decrypt(decode(body.ciphertext), decode(body.iv))
user.send_email(
f"Decryption Results from {datetime.now().isoformat()}",
f"Plaintext = {res!r}",
)
return {}
except Exception as e:
if body.debug:
return {"err": str(e)}
return {}
@crypto_router.get("/flag")
def flag(user: AuthorizedUser, cipher: GlobalSCBCCipher, rsa: GlobalRSA):
iv = long_to_bytes(getrandbits(128), 16)
ct = cipher.encrypt(FLAG, iv)
sig = rsa.sign(iv + ct)
return {"ciphertext": encode(ct), "signature": hex(sig)}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/__init__.py | from .auth import auth_router as auth
from .crypto import crypto_router as crypto
from .users import users_router as users
__all__ = [
"auth",
"crypto",
"users",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/routers/auth.py | from datetime import UTC, datetime
from typing import Annotated
from fastapi import APIRouter, Cookie, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr, Field
from mvmcryption.auth import (
SJWT_TTL,
AuthorizedUser,
create_sjwt,
decode_sjwt,
global_sjwt,
)
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.db.users import Users
from mvmcryption.environ import IS_DEV
USERNAME_FIELD = Field(max_length=50, min_length=2)
PASSWORD_FIELD = Field(max_length=100, min_length=8)
class LoginBody(BaseModel):
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
class RegisterBody(BaseModel):
email: EmailStr
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
auth_router = APIRouter(prefix="/auth", tags=["auth"])
@auth_router.get("/status")
def user_status(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
"""Return whether or not user is logged in."""
return {"authorized": bool(decode_sjwt(mvmcryptionauthtoken, sjwt, users))}
@auth_router.post("/login")
def login(
body: LoginBody,
response: Response,
sjwt: Annotated[SJWT, Depends(global_sjwt)],
users: Annotated[Users, Depends(Users.dependency)],
):
if not (user := users.login(body.username, body.password)):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid Credentials.",
)
expires = datetime.now(UTC) + SJWT_TTL
token = create_sjwt(user, sjwt, expires)
response.set_cookie(
"mvmcryptionauthtoken",
token,
expires=expires,
secure=not IS_DEV,
httponly=True,
)
response.status_code = status.HTTP_204_NO_CONTENT
@auth_router.post("/register")
def register(
body: RegisterBody,
users: Annotated[Users, Depends(Users.dependency)],
):
if users.find_by_username(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if users.find_by_username(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
if not (
user := users.create(
username=body.username,
email=email,
password=body.password,
)
):
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
return user
@auth_router.post("/logout")
def logout(response: Response, user: AuthorizedUser):
response.delete_cookie("mvmcryptionauthtoken")
response.status_code = status.HTTP_204_NO_CONTENT
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/ecdsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/ecdsa.py | """Cryptography stuff."""
from dataclasses import dataclass
from hashlib import sha256
from pathlib import Path
from random import getrandbits
from secrets import randbelow
from Crypto.Util.number import bytes_to_long, long_to_bytes
from fastecdsa.curve import P256, Curve
from fastecdsa.ecdsa import verify
from fastecdsa.keys import get_public_key
from fastecdsa.point import Point
from mvmcryption.utils import decode, encode
CURVE = P256
N = CURVE.q
def private_key() -> int:
f = Path("/etc/ecdsa-private-key")
if not f.exists():
privkey = randbelow(N)
f.write_text(str(privkey))
privkey = int(f.read_text())
return privkey
def generate_nonce(k):
"""😇😇😇"""
return getrandbits(k)
def encode_signature(signature: tuple[int, int]) -> str:
"""Encode signature to following format:
`<r.b64>.<s.b64>`
"""
r = encode(long_to_bytes(signature[0]))
s = encode(long_to_bytes(signature[1]))
return ".".join([r, s])
def decode_signature(encoded_signature: tuple[str, str]) -> tuple[int, int]:
"""Decode signature from the following format:
`<r.b64>.<s.b64>`
"""
r = bytes_to_long(decode(encoded_signature[0]))
s = bytes_to_long(decode(encoded_signature[1]))
return r, s
@dataclass
class ECDSA:
private_key: int
curve: Curve = P256
def sign(self, msg: bytes) -> tuple[int, int]:
z = int(sha256(msg).hexdigest(), 16) % N
k = generate_nonce(128) # 😇😇😇
R = k * P256.G
r = R.x % N
s = (pow(k, -1, N) * (z + r * self.private_key)) % N
return (r, s)
@property
def public_key(self) -> Point:
return get_public_key(self.private_key, self.curve)
def verify(self, signature: tuple[int, int], msg: bytes) -> bool:
return verify(signature, msg, self.public_key, curve=self.curve)
@property
def pretty_public_key(self) -> dict:
return {
"curve": {
"name": self.curve.name,
"G": [hex(self.curve.gx), hex(self.curve.gy)],
"p": hex(self.curve.p),
"n": hex(self.curve.q),
},
"Q": [hex(self.public_key.x), hex(self.public_key.y)],
}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/jwt.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/jwt.py | from dataclasses import dataclass
from json import dumps, loads
from mvmcryption.utils import decode as b64decode
from mvmcryption.utils import encode as b64encode
from .ecdsa import ECDSA, decode_signature, encode_signature
# SJWT -> Scuffed JSON Web Token; just some extra pain
class SJWTError(ValueError):
"""Error for SJWT things."""
class SJWTEncodingError(SJWTError):
"""Errors for encoding SJWTs!"""
class SJWTDecodeError(SJWTError):
"""Shit happend while decoding that SJWT!"""
class SJWTVerificationError(SJWTError):
"""That SJWT nasty!"""
@dataclass
class SJWT:
ecdsa: ECDSA
def encode(self, payload: dict[str], requires_expiry=True) -> str:
if "exp" not in payload and requires_expiry:
raise SJWTEncodingError("Sir we need an expiry on the token!")
as_string = dumps(payload)
_body = as_string.encode()
sig = encode_signature(self.ecdsa.sign(_body))
body = b64encode(_body)
return body + "." + sig
def decode(self, string: str, verify: bool = True) -> dict[str]:
parts = string.split(".")
if len(parts) != 3:
# why even try this >:(
raise SJWTDecodeError("WRONG AMOUNT OF parts! parts! >:C")
try:
body = b64decode(parts[0])
r, s = decode_signature(parts[1:])
except Exception:
# JUST STOP IT; THIS IS SECURE!!!!!! >:C
raise SJWTDecodeError("Bad token! bad bad bad!")
if verify:
self._verify(body, (r, s))
try:
return loads(body.decode())
except Exception:
raise SJWTDecodeError("funny user")
def _verify(self, body: bytes, signature: tuple[int, int]) -> None:
# raise if payload not satisfactory
if not (self.ecdsa.verify(signature, body)):
raise SJWTVerificationError(":c stop it")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/rsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/rsa.py | from dataclasses import dataclass
from Crypto.Hash import SHA256
HASH_LEN = SHA256.digest_size
assert HASH_LEN == 32
HASH_BITS = SHA256.digest_size * 8
assert HASH_BITS == 256
@dataclass
class PrivKey:
p: int
q: int
e: int
@property
def phi(self):
return (self.p - 1) * (self.q - 1)
@property
def d(self):
return pow(self.e, -1, self.phi)
@property
def n(self):
return self.p * self.q
@property
def public_key(self):
return PubKey(self.n, self.e)
@property
def u(self):
return pow(self.p, -1, self.q)
@dataclass
class PubKey:
n: int
e: int
@dataclass
class RSA:
priv: PrivKey
def verify(self, m, sig):
m_calc = int(pow(int(sig), int(self.priv.e), int(self.priv.n))).to_bytes(
HASH_LEN, "big"
)
return m_calc == SHA256.new(m).digest()
def sign(self, m):
"""Sign msg."""
m = SHA256.new(m).digest()
m = int.from_bytes(m, "big")
return pow(m, self.priv.d, self.priv.n)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/cipher.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/cipher.py | from dataclasses import dataclass
from random import getrandbits
from Crypto.Cipher import AES
from Crypto.Util.number import long_to_bytes
from Crypto.Util.Padding import pad, unpad
from pwn import xor
from mvmcryption.crypto.rsa import RSA
from mvmcryption.utils import chunk
BLOCK_SIZE = 16
@dataclass
class SCBCCipher:
"""
Scuffed CBC Cipher.
If you're wondering why we aren't using CBC directly, this is part of our "Customer Retention Strategy".
"""
key: bytes
@property
def _ecb(self):
return AES.new(self.key, AES.MODE_ECB)
def encrypt(self, plaintext: bytes, iv: bytes) -> bytes:
padded = pad(plaintext, BLOCK_SIZE)
enc = []
blocks = chunk(padded)
enc.append(self._ecb.encrypt(xor(blocks[0], iv)))
for i, block in enumerate(blocks[1:]):
enc.append(self._ecb.encrypt(xor(block, enc[i])))
return b"".join(enc)
def decrypt(self, ciphertext: bytes, iv: bytes) -> bytes:
ndec = chunk(ciphertext)
dec = []
dec.append(xor(self._ecb.decrypt(ndec[0]), iv))
for i, block in enumerate(ndec[1:]):
dec.append(xor(self._ecb.decrypt(block), ndec[i]))
return unpad(b"".join(dec), BLOCK_SIZE)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-2/api/mvmcryption/crypto/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/test_ecdsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/test_ecdsa.py | import pytest
from mvmcryption.crypto.ecdsa import ECDSA, decode_signature, encode_signature
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_ecdsa(msg: bytes, d: int):
ecdsa = ECDSA(d)
sig = ecdsa.sign(msg)
assert ecdsa.verify(sig, msg)
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_ecdsa_signature_encoding_decoding(msg: bytes, d: int):
ecdsa = ECDSA(d)
sig = ecdsa.sign(msg)
encoded_sig = encode_signature(sig)
assert ecdsa.verify(decode_signature(encoded_sig.split(".")), msg)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/test_cipher.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/test_cipher.py | from random import getrandbits, seed
import pytest
from Crypto.Util.number import long_to_bytes
from mvmcryption.crypto.cipher import XSCBCCipher
from mvmcryption.crypto.rsa import RSA
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_xscbccipher(msg: bytes, d: int):
key = long_to_bytes(d, 16)
rsa = RSA()
ciph = XSCBCCipher(key, rsa)
seed(69)
iv = long_to_bytes(getrandbits(128), 16)
seed(69)
ct, sig = ciph.encrypt(msg)
assert ct
assert sig
assert msg == ciph.decrypt(ct, sig, iv)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/tests/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/environ.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/environ.py | import os
def getenv(key: str) -> str:
"""Get environment variable and raise an error if it is unset."""
if val := os.getenv(key):
return val
msg = "ENV variable %s is required!"
raise OSError(msg % key)
IS_DEV = os.getenv("ENV") == "DEV"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/utils.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/utils.py | from base64 import urlsafe_b64decode, urlsafe_b64encode
def encode(content: bytes | str) -> str:
def _encode():
if isinstance(content, str):
return urlsafe_b64encode(content.encode()).decode()
return urlsafe_b64encode(content).decode()
return _encode().replace("=", "")
def decode(content: str | bytes) -> bytes:
rem = len(content) % 4
if rem > 0:
try:
content += b"=" * (4 - rem)
except Exception:
content += "=" * (4 - rem)
if isinstance(content, str):
return urlsafe_b64decode(content.encode())
return urlsafe_b64decode(content)
def chunk(stuff: bytes):
"""Chunk stuff into 16 byte blocks."""
assert len(stuff)
assert len(stuff) % 16 == 0
blocks = []
for i in range(0, len(stuff), 16):
blocks.append(stuff[i : i + 16])
return blocks
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/resp.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/resp.py | from __future__ import annotations
from fastapi import HTTPException, status
PERMISSION_DENIED = HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Permission denied.",
)
def not_found(model: object) -> HTTPException:
return HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"{model.__name__} not found.",
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/auth.py | from __future__ import annotations
import json
from datetime import UTC, datetime, timedelta
from pathlib import Path
from secrets import randbits
from typing import Annotated
from Crypto.Util.number import long_to_bytes
from fastapi import Cookie, Depends, HTTPException, Response, status
from mvmcryption.crypto.cipher import XSCBCCipher
from mvmcryption.crypto.ecdsa import ECDSA, private_key
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.crypto.rsa import RSA, PrivKey
from mvmcryption.db.users import User, Users
from mvmcryption.resp import PERMISSION_DENIED
SJWT_TTL = timedelta(minutes=15)
def global_ecdsa(private_key: Annotated[int, Depends(private_key)]) -> ECDSA:
return ECDSA(private_key)
def global_sjwt(ecdsa: Annotated[ECDSA, Depends(global_ecdsa)]):
return SJWT(ecdsa)
def create_sjwt(user: User, sjwt: SJWT, expires: datetime | None = None) -> str:
_expires = expires or (datetime.now(UTC) + SJWT_TTL)
return sjwt.encode({"sub": user.id, "exp": _expires.isoformat()})
def decode_sjwt(token: str, sjwt: SJWT, users: Users) -> User | None:
if not token:
return None
try:
decoded = sjwt.decode(token)
except Exception:
return None
if not (
expiry_str := decoded.get("exp")
): # no expiry -> some token generated by an admin
return None # for ~~security~~ budget reasons this is disabled right now # TODO: fix this
if not isinstance(expiry_str, str):
return None
try:
expiry = datetime.fromisoformat(expiry_str)
except Exception:
return None
if not expiry or expiry <= datetime.now(UTC):
return None
user_id = decoded.get("sub")
if user_id is None:
return None
if not isinstance(user_id, int):
return None
user = users.find(user_id)
if user is None:
return None
return user
def authorized_user(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
response: Response,
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
user = decode_sjwt(mvmcryptionauthtoken, sjwt, users)
if not user:
if mvmcryptionauthtoken:
response.delete_cookie("mvmcryptionauthtoken")
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Unauthorized.",
)
return user
def admin_user(user: Annotated[User, Depends(authorized_user)]):
if not user.is_admin:
raise PERMISSION_DENIED
return user
def _aes_key() -> bytes:
f = Path("/etc/aes-key")
if not f.exists():
f.write_bytes(long_to_bytes(randbits(128)))
return f.read_bytes()
def global_rsa() -> RSA:
f = Path("/etc/rsa")
#
# an attack on these should also work on the remote!
e = 116591970041706379718532155665908888266686385012306382255623803049685541583532192334750761495391545779868293489052594691148251145407647036423290759484206824818995957368289817829191698292230111628507603650574855287432967558368023637303008639037850782925263155866362959265023886375680369942961371288326084824041
p = 45451971945342384351746307287759765997973347839090260639694412464552793781005187267114562085821942688227357317219583361362353646878950896940183843297990546009873999147534085320185786757924396902950980568341191320751375188700478249675190215732576343159765113451640650736834237393822708039570047243039620286637
q = 72009118392764261626413427431876874126326129069984217748634549026407244590676396047494273221646252626614631969458719207393002919632651673891260405183783344104061153870552960970102444506174717483826221480719066827975881319667694098081439486875056139219733072421530544103531952960041530707457961396585927096347
if not f.exists():
# key = RSA.new()
key = PrivKey(p, q, e)
f.write_text(json.dumps(key.__dict__))
rsa = RSA(PrivKey(**json.loads(f.read_text())))
assert rsa.verify(b"hello", rsa.sign(b"hello"))
return rsa
GlobalRSA = Annotated[RSA, Depends(global_rsa)]
def global_aes(
key: Annotated[bytes, Depends(_aes_key)],
rsa: GlobalRSA,
):
return XSCBCCipher(key, rsa)
AuthorizedUser = Annotated[User, Depends(authorized_user)]
AdminUser = Annotated[User, Depends(admin_user)]
GlobalECDSA = Annotated[ECDSA, Depends(global_ecdsa)]
GlobalXSCBCCipher = Annotated[XSCBCCipher, Depends(global_aes)]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/app.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/app.py | from fastapi import APIRouter, FastAPI
from mvmcryption.db import initialize
from mvmcryption.environ import IS_DEV
from mvmcryption.routers import auth, crypto, users
tags_metadata = [
{
"name": "users",
"description": "Operations with users.",
},
{
"name": "crypto",
"description": "Cryptography stuff.",
},
{
"name": "auth",
"description": "Logout/Login/Register stuff.",
},
]
app = FastAPI(
title="MVMCryption",
description="3AM Crypto chall. (some stuff might not mmake sense whoopsies)",
version="dQw4w9WgXcQ",
openapi_tags=tags_metadata,
)
if IS_DEV:
from fastapi.middleware.cors import CORSMiddleware
# building a frontend is left as exercise for the player lol...
# because I'm not a monster I added CORS headers, have fun
app.add_middleware(
CORSMiddleware,
allow_origins=[
"http://localhost:5173",
"http://localhost:4200",
"http://localhost:3000",
],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.add_event_handler("startup", initialize)
api_router = APIRouter(prefix="/api")
api_router.include_router(auth)
api_router.include_router(crypto)
api_router.include_router(users)
app.include_router(api_router)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/users.py | from __future__ import annotations
from argon2 import PasswordHasher, exceptions
from pydantic import EmailStr, SecretStr
from .db import BaseModel, DBModel
PH = PasswordHasher()
class User(BaseModel):
username: str
email: EmailStr
password: SecretStr
@property
def is_admin(self):
return self.id == 1
def send_email(self, subject: str, content: str) -> None:
"""Send e-mail to user."""
class Users(DBModel[User]):
tablename = "users"
model = User
columns = (
"username",
"email",
"password",
)
mutable_columns = (
"username",
"email",
)
def find_by_username(self, username: str):
return self.find_by("username")(username)
def create(self, *, username: str, email: str, password: str) -> User:
_password = PH.hash(password)
return self.insert(
{"username": username, "email": email, "password": _password},
)
def login(self, username: str, password: str) -> User | None:
if not (u := self.find_by_username(username)):
return None
try:
PH.verify(u.password.get_secret_value(), password)
return u
except exceptions.VerifyMismatchError:
return None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/db.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/db.py | from __future__ import annotations
import sqlite3
from abc import ABC, abstractmethod
from collections.abc import Callable, Iterator, Sequence
from contextlib import contextmanager
from typing import Annotated, Generic, TypeVar
from fastapi import Depends
from pydantic import BaseModel as _BaseModel
from mvmcryption.environ import getenv
DB_PATH = getenv("DB_PATH")
def connect_dependency() -> sqlite3.Connection:
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
conn.autocommit = True
return conn
@contextmanager
def connect() -> Iterator[sqlite3.Connection]:
conn = connect_dependency()
try:
yield conn
finally:
conn.close()
class BaseModel(_BaseModel):
id: int
T = TypeVar("T", bound=BaseModel)
V = TypeVar("V")
class DBModel(ABC, Generic[T]):
def __init__(self, conn: sqlite3.Connection) -> None:
self.conn = conn
@classmethod
@property
@abstractmethod
def tablename(cls) -> str:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def mutable_columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def model(cls) -> type[T]:
raise NotImplementedError
@classmethod
@property
def select_query(cls) -> str:
return f"SELECT * FROM {cls.tablename} "
@classmethod
@property
def delete_query(cls) -> str:
return f"DELETE FROM {cls.tablename} "
@classmethod
@property
def insert_query(cls) -> str:
return f"INSERT INTO {cls.tablename} ({', '.join(cls.columns)}) VALUES ({', '.join(f':{col}' for col in cls.columns)}) RETURNING *;"
@classmethod
@property
def update_query(cls) -> str:
return f"UPDATE {cls.tablename} SET {', '.join([f'{col} = :{col}' for col in cls.mutable_columns])} "
@contextmanager
def cur(self) -> Iterator[sqlite3.Cursor]:
cur = self.conn.cursor()
try:
yield cur
finally:
cur.close()
def delete(self, id: int) -> None:
return self.delete_by("id")(id)
def delete_by(self, lookup: str) -> None:
q = self.delete_query + f"WHERE {lookup} = ?;"
def _delete_by(value) -> None:
with self.cur() as cur:
cur.execute(q, [value])
return _delete_by
def insert(self, params: dict, **kwargs) -> T:
with self.cur() as cur:
cur.execute(self.insert_query, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
def update(self, id: int, params: dict) -> T:
return self.update_by("id")(id, params)
def update_by(self, lookup: str) -> Callable[[dict, ...], T]:
if not self.update_query:
raise Exception("Model is readonly.")
q = self.update_query + f"WHERE {lookup} = :lookup RETURNING *;"
def _update_by(value, params: dict, **kwargs) -> T:
params["lookup"] = value
with self.cur() as cur:
cur.execute(q, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
return _update_by
def find(self, id: int) -> T | None:
return self.find_by("id")(id)
def find_by(self, lookup: str) -> Callable[[V], T]:
q = self.select_query + f"WHERE {lookup} = :{lookup};"
def _find_by(value) -> T | None:
with self.cur() as cur:
cur.execute(q, [value])
if record := cur.fetchone():
return self.model(**record)
return None
return _find_by
def all(self) -> list[T]:
q = self.select_query + ";"
with self.cur() as cur:
cur.execute(q)
return [self.model(**record) for record in cur.fetchall()]
@classmethod
def dependency(cls, db: Annotated[sqlite3.Connection, Depends(connect_dependency)]):
return cls(db)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/db/__init__.py | from __future__ import annotations
from mvmcryption.environ import getenv
from .db import connect
from .users import Users
ADMIN_PASSWORD = getenv("ADMIN_PASSWORD")
TABLE_QUERY = """
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
email VARCHAR(100) NOT NULL UNIQUE,
password VARCHAR(100) NOT NULL
);
"""
def initialize() -> None:
with connect() as conn:
conn.executescript(TABLE_QUERY)
try:
Users(conn).create(
username="admin",
email="admin@this-company-luckily-does-not-exist.mvm",
password=ADMIN_PASSWORD,
)
except Exception as e: # maybe it already exists
print(e)
__all__ = [
"Users",
"initialize",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/users.py | from typing import Annotated, Literal
from fastapi import APIRouter, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr
from mvmcryption.auth import AuthorizedUser
from mvmcryption.db import Users
from mvmcryption.resp import PERMISSION_DENIED, not_found
from mvmcryption.routers.auth import USERNAME_FIELD
users_router = APIRouter(prefix="/users", tags=["users"])
class UpdateBody(BaseModel):
username: str = USERNAME_FIELD
email: EmailStr
@users_router.get("/")
def user_list(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
):
if user.is_admin:
return users.all()
return [user]
@users_router.patch("/{user_id}")
def update_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
body: UpdateBody,
):
"""Whoa! im updating things!"""
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if user.id != user_id:
user = users.find(user_id)
if user.username != body.username and users.find_by("username")(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if user.email != email and users.find_by("email")(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
try:
return users.update(user.id, dict(username=body.username, email=email))
except Exception:
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
@users_router.delete("/{user_id}")
def delete_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
response: Response,
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
users.delete(user_id)
response.delete_cookie("mvmcryptionauthtoken", secure=False, httponly=True)
response.status_code = status.HTTP_204_NO_CONTENT
@users_router.get("/{user_id}")
def user_detail(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if record := users.find(user_id):
return record
raise not_found(Users.model)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/crypto.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/crypto.py | from datetime import datetime
from fastapi import APIRouter
from pydantic import BaseModel, validator
from mvmcryption.auth import (
AuthorizedUser,
GlobalECDSA,
GlobalRSA,
GlobalXSCBCCipher,
)
from mvmcryption.environ import getenv
from mvmcryption.utils import decode, encode
FLAG = getenv("FLAG").encode()
crypto_router = APIRouter(prefix="/crypto", tags=["crypto"])
class ValidationBody(BaseModel):
ciphertext: str
iv: str
signature: str
debug: bool = False
@validator("ciphertext")
def validate_ciphertext(v):
try:
decoded = decode(v)
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
if len(decoded) % 16 != 0:
msg = "????"
raise ValueError(msg)
return v
@validator("iv")
def validate_iv(v):
try:
decoded = decode(v)
assert len(decoded) == 16
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
return v
@validator("signature")
def validate_signature(v):
try:
decoded = int(v, 16)
assert decoded > 1
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
return v
@crypto_router.get("/public-key")
def ecdsa_public_key(ecdsa: GlobalECDSA) -> dict:
"""ECDSA Public Key."""
return ecdsa.pretty_public_key
@crypto_router.get("/rsa-public-key")
def rsa_public_key(_user: AuthorizedUser, rsa: GlobalRSA) -> dict:
"""RSA Public Key."""
return {
"N": hex(rsa.priv.n),
"e": hex(rsa.priv.e),
}
@crypto_router.post("/decrypt")
def decrypt(user: AuthorizedUser, cipher: GlobalXSCBCCipher, body: ValidationBody):
"""
Real men test in production.
- Our CISO, probably
"""
if body.debug:
if not user.is_admin:
raise ValueError("no.")
try:
res = cipher.decrypt(
decode(body.ciphertext), int(body.signature, 16), decode(body.iv)
)
user.send_email(
f"Decryption Results from {datetime.now().isoformat()}",
f"Plaintext = {res!r}",
)
return {}
except Exception as e:
if body.debug:
return {"err": str(e)}
return {}
@crypto_router.get("/flag")
def flag(user: AuthorizedUser, cipher: GlobalXSCBCCipher):
ct, signature = cipher.encrypt(FLAG)
return {"ciphertext": encode(ct), "signature": hex(signature)}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/__init__.py | from .auth import auth_router as auth
from .crypto import crypto_router as crypto
from .users import users_router as users
__all__ = [
"auth",
"crypto",
"users",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/routers/auth.py | from datetime import UTC, datetime
from typing import Annotated
from fastapi import APIRouter, Cookie, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr, Field
from mvmcryption.auth import (
SJWT_TTL,
AuthorizedUser,
create_sjwt,
decode_sjwt,
global_sjwt,
)
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.db.users import Users
from mvmcryption.environ import IS_DEV
USERNAME_FIELD = Field(max_length=50, min_length=2)
PASSWORD_FIELD = Field(max_length=100, min_length=8)
class LoginBody(BaseModel):
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
class RegisterBody(BaseModel):
email: EmailStr
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
auth_router = APIRouter(prefix="/auth", tags=["auth"])
@auth_router.get("/status")
def user_status(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
"""Return whether or not user is logged in."""
return {"authorized": bool(decode_sjwt(mvmcryptionauthtoken, sjwt, users))}
@auth_router.post("/login")
def login(
body: LoginBody,
response: Response,
sjwt: Annotated[SJWT, Depends(global_sjwt)],
users: Annotated[Users, Depends(Users.dependency)],
):
if not (user := users.login(body.username, body.password)):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid Credentials.",
)
expires = datetime.now(UTC) + SJWT_TTL
token = create_sjwt(user, sjwt, expires)
response.set_cookie(
"mvmcryptionauthtoken",
token,
expires=expires,
secure=not IS_DEV,
httponly=True,
)
response.status_code = status.HTTP_204_NO_CONTENT
@auth_router.post("/register")
def register(
body: RegisterBody,
users: Annotated[Users, Depends(Users.dependency)],
):
if users.find_by_username(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if users.find_by_username(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
if not (
user := users.create(
username=body.username,
email=email,
password=body.password,
)
):
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
return user
@auth_router.post("/logout")
def logout(response: Response, user: AuthorizedUser):
response.delete_cookie("mvmcryptionauthtoken")
response.status_code = status.HTTP_204_NO_CONTENT
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/ecdsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/ecdsa.py | """Cryptography stuff."""
from dataclasses import dataclass
from hashlib import sha256
from pathlib import Path
from random import getrandbits
from secrets import randbelow
from Crypto.Util.number import bytes_to_long, long_to_bytes
from fastecdsa.curve import P256, Curve
from fastecdsa.ecdsa import verify
from fastecdsa.keys import get_public_key
from fastecdsa.point import Point
from mvmcryption.utils import decode, encode
CURVE = P256
N = CURVE.q
def private_key() -> int:
f = Path("/etc/ecdsa-private-key")
if not f.exists():
privkey = randbelow(N)
f.write_text(str(privkey))
privkey = int(f.read_text())
return privkey
def generate_nonce(k):
"""😇😇😇"""
return getrandbits(k)
def encode_signature(signature: tuple[int, int]) -> str:
"""Encode signature to following format:
`<r.b64>.<s.b64>`
"""
r = encode(long_to_bytes(signature[0]))
s = encode(long_to_bytes(signature[1]))
return ".".join([r, s])
def decode_signature(encoded_signature: tuple[str, str]) -> tuple[int, int]:
"""Decode signature from the following format:
`<r.b64>.<s.b64>`
"""
r = bytes_to_long(decode(encoded_signature[0]))
s = bytes_to_long(decode(encoded_signature[1]))
return r, s
@dataclass
class ECDSA:
private_key: int
curve: Curve = P256
def sign(self, msg: bytes) -> tuple[int, int]:
z = int(sha256(msg).hexdigest(), 16) % N
k = generate_nonce(128) # 😇😇😇
R = k * P256.G
r = R.x % N
s = (pow(k, -1, N) * (z + r * self.private_key)) % N
return (r, s)
@property
def public_key(self) -> Point:
return get_public_key(self.private_key, self.curve)
def verify(self, signature: tuple[int, int], msg: bytes) -> bool:
return verify(signature, msg, self.public_key, curve=self.curve)
@property
def pretty_public_key(self) -> dict:
return {
"curve": {
"name": self.curve.name,
"G": [hex(self.curve.gx), hex(self.curve.gy)],
"p": hex(self.curve.p),
"n": hex(self.curve.q),
},
"Q": [hex(self.public_key.x), hex(self.public_key.y)],
}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/jwt.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/jwt.py | from dataclasses import dataclass
from json import dumps, loads
from mvmcryption.utils import decode as b64decode
from mvmcryption.utils import encode as b64encode
from .ecdsa import ECDSA, decode_signature, encode_signature
# SJWT -> Scuffed JSON Web Token; just some extra pain
class SJWTError(ValueError):
"""Error for SJWT things."""
class SJWTEncodingError(SJWTError):
"""Errors for encoding SJWTs!"""
class SJWTDecodeError(SJWTError):
"""Shit happend while decoding that SJWT!"""
class SJWTVerificationError(SJWTError):
"""That SJWT nasty!"""
@dataclass
class SJWT:
ecdsa: ECDSA
def encode(self, payload: dict[str], requires_expiry=True) -> str:
if "exp" not in payload and requires_expiry:
raise SJWTEncodingError("Sir we need an expiry on the token!")
as_string = dumps(payload)
_body = as_string.encode()
sig = encode_signature(self.ecdsa.sign(_body))
body = b64encode(_body)
return body + "." + sig
def decode(self, string: str, verify: bool = True) -> dict[str]:
parts = string.split(".")
if len(parts) != 3:
# why even try this >:(
raise SJWTDecodeError("WRONG AMOUNT OF parts! parts! >:C")
try:
body = b64decode(parts[0])
r, s = decode_signature(parts[1:])
except Exception:
# JUST STOP IT; THIS IS SECURE!!!!!! >:C
raise SJWTDecodeError("Bad token! bad bad bad!")
if verify:
self._verify(body, (r, s))
try:
return loads(body.decode())
except Exception:
raise SJWTDecodeError("funny user")
def _verify(self, body: bytes, signature: tuple[int, int]) -> None:
# raise if payload not satisfactory
if not (self.ecdsa.verify(signature, body)):
raise SJWTVerificationError(":c stop it")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/rsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/rsa.py | from dataclasses import dataclass
from secrets import token_bytes
from Crypto.Hash import SHA256
from Crypto.Signature.pss import MGF1
from Crypto.Util.number import getPrime, isPrime
HASH_LEN = SHA256.digest_size
assert HASH_LEN == 32
HASH_BITS = SHA256.digest_size * 8
assert HASH_BITS == 256
def fast_prime(e: int):
"""
Our CISO mandated we generate primes like this, "apparently" its more efficient and/or faster. (See MVM-7173741 in jira for more on this.)
We already told our CISO that we'd lose our ISO 27k1 certification if we did stuff like this, as a result he started laughing.
After about 10min of cynical laughter he finally calmed down, and told us: "We lost that certification as soon as we were audited.".
"""
while True:
k = getPrime(int(HASH_BITS * 2 - HASH_LEN * 3.5))
d = pow(e, -1, k)
p = 1 + (e * d - 1) // k
if isPrime(p):
return p, d
@dataclass
class PrivKey:
p: int
q: int
# See "Customer Retention Strategies" on confluence
# dp: int
# dq: int
e: int
@property
def phi(self):
return (self.p - 1) * (self.q - 1)
@property
def d(self):
return pow(self.e, -1, self.phi)
@property
def n(self):
return self.p * self.q
@property
def public_key(self):
return PubKey(self.n, self.e)
@property
def u(self):
return pow(self.p, -1, self.q)
@dataclass
class PubKey:
n: int
e: int
def xor(x, y):
if len(x) > len(y):
x, y = y, x
return bytes([x[i] ^ y[i] for i in range(len(x))]) + y[len(x) :]
@dataclass
class RSA:
priv: PrivKey
@classmethod
def new(cls):
n_e = HASH_BITS * 4
e = getPrime(n_e)
# See "Customer Retention Strategies" on confluence
p, _ = fast_prime(e)
q, _ = fast_prime(e)
return cls(PrivKey(p, q, e))
def verify(self, m, sig):
m_pad = int(pow(int(sig), int(self.priv.e), int(self.priv.n))).to_bytes(
HASH_BITS, "big"
)
return self.unpad(m_pad) == SHA256.new(m).digest()
def unpad(self, m_pad):
x, y = m_pad[2:-HASH_LEN], m_pad[-HASH_LEN:]
r = xor(y, MGF1(x, HASH_LEN, SHA256))
m = xor(x, MGF1(r, HASH_BITS - HASH_LEN - 2, SHA256)).rstrip(b"\x00")
return m[:-1]
def pad(self, m):
"""
This might actually be secure, proving/disproving this is above my paygrade tho.
In the end, all i need is $5 anyways.
"""
m += b"\x01" + b"\x00" * (HASH_BITS - HASH_LEN - 3 - len(m))
r = token_bytes(HASH_LEN)
x = xor(m, MGF1(r, HASH_BITS - HASH_LEN - 2, SHA256))
y = xor(r, MGF1(x, HASH_LEN, SHA256))
m_pad = x + y
return m_pad
def sign(self, m):
m = self.pad(SHA256.new(m).digest())
m = int.from_bytes(m, "big")
return pow(m, self.priv.d, self.priv.n)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/cipher.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/cipher.py | from dataclasses import dataclass
from random import getrandbits
from Crypto.Cipher import AES
from Crypto.Util.number import long_to_bytes
from Crypto.Util.Padding import pad, unpad
from pwn import xor
from mvmcryption.crypto.rsa import RSA
from mvmcryption.utils import chunk
BLOCK_SIZE = 16
@dataclass
class SCBCCipher:
"""
Scuffed CBC Cipher.
If you're wondering why we aren't using CBC directly, this is part of our "Customer Retention Strategy".
"""
key: bytes
@property
def _ecb(self):
return AES.new(self.key, AES.MODE_ECB)
def encrypt(self, plaintext: bytes, iv: bytes) -> bytes:
padded = pad(plaintext, BLOCK_SIZE)
enc = []
blocks = chunk(padded)
enc.append(self._ecb.encrypt(xor(blocks[0], iv)))
for i, block in enumerate(blocks[1:]):
enc.append(self._ecb.encrypt(xor(block, enc[i])))
return b"".join(enc)
def decrypt(self, ciphertext: bytes, iv: bytes) -> bytes:
ndec = chunk(ciphertext)
dec = []
dec.append(xor(self._ecb.decrypt(ndec[0]), iv))
for i, block in enumerate(ndec[1:]):
dec.append(xor(self._ecb.decrypt(block), ndec[i]))
return unpad(b"".join(dec), BLOCK_SIZE)
@dataclass
class XSCBCCipher(SCBCCipher):
"""
Extended Scuffed CBC Cipher.
The same but with signatures, an (ex)-customer forced us to implement signatures for this after some of their users started abusing bit-flipping to insert commans and semicolons into all sorts of places.
Our CISO somehow managed to keep this from going public, the general consesus is that he bribed the customer with some, well all the data, we shouldn't have but do. Ig sometimes stuff just works. See MVM-7173763 in Jira for more on this.
"""
rsa: RSA
def encrypt(self, plaintext: bytes) -> tuple[bytes, int]:
iv = long_to_bytes(getrandbits(BLOCK_SIZE * 8), BLOCK_SIZE)
ct = super().encrypt(plaintext, iv)
signature = self.rsa.sign(iv + ct)
# return ct, iv, signature
return ct, signature
def decrypt(self, ciphertext: bytes, signature: int, iv: bytes) -> bytes:
if not self.rsa.verify(iv + ciphertext, signature):
raise ValueError("Funny user.")
return super().decrypt(ciphertext, iv)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-3/api/mvmcryption/crypto/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/test_ecdsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/test_ecdsa.py | import pytest
from mvmcryption.crypto.ecdsa import ECDSA, decode_signature, encode_signature
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_ecdsa(msg: bytes, d: int):
ecdsa = ECDSA(d)
sig = ecdsa.sign(msg)
assert ecdsa.verify(sig, msg)
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_ecdsa_signature_encoding_decoding(msg: bytes, d: int):
ecdsa = ECDSA(d)
sig = ecdsa.sign(msg)
encoded_sig = encode_signature(sig)
assert ecdsa.verify(decode_signature(encoded_sig.split(".")), msg)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/test_cipher.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/test_cipher.py | from random import getrandbits
import pytest
from Crypto.Util.number import long_to_bytes
from mvmcryption.crypto.cipher import SCBCCipher
@pytest.mark.parametrize("msg", [b"helo", b'{"get pwned": 1337}'])
@pytest.mark.parametrize("d", [1337, 895])
def test_scbccipher(msg: bytes, d: int):
key = long_to_bytes(d, 16)
ciph = SCBCCipher(key)
iv = long_to_bytes(getrandbits(128), 16)
ct = ciph.encrypt(msg, iv)
assert ct
assert msg == ciph.decrypt(ct, iv)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/tests/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/environ.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/environ.py | import os
def getenv(key: str) -> str:
"""Get environment variable and raise an error if it is unset."""
if val := os.getenv(key):
return val
msg = "ENV variable %s is required!"
raise OSError(msg % key)
IS_DEV = os.getenv("ENV") == "DEV"
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/utils.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/utils.py | from base64 import urlsafe_b64decode, urlsafe_b64encode
def encode(content: bytes | str) -> str:
def _encode():
if isinstance(content, str):
return urlsafe_b64encode(content.encode()).decode()
return urlsafe_b64encode(content).decode()
return _encode().replace("=", "")
def decode(content: str | bytes) -> bytes:
rem = len(content) % 4
if rem > 0:
try:
content += b"=" * (4 - rem)
except Exception:
content += "=" * (4 - rem)
if isinstance(content, str):
return urlsafe_b64decode(content.encode())
return urlsafe_b64decode(content)
def chunk(stuff: bytes):
"""Chunk stuff into 16 byte blocks."""
assert len(stuff)
assert len(stuff) % 16 == 0
blocks = []
for i in range(0, len(stuff), 16):
blocks.append(stuff[i : i + 16])
return blocks
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/resp.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/resp.py | from __future__ import annotations
from fastapi import HTTPException, status
PERMISSION_DENIED = HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail="Permission denied.",
)
def not_found(model: object) -> HTTPException:
return HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"{model.__name__} not found.",
)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/auth.py | from __future__ import annotations
import json
from datetime import UTC, datetime, timedelta
from pathlib import Path
from secrets import randbits
from typing import Annotated
from Crypto.Util.number import getPrime, long_to_bytes
from fastapi import Cookie, Depends, HTTPException, Response, status
from mvmcryption.crypto.cipher import SCBCCipher
from mvmcryption.crypto.ecdsa import ECDSA, private_key
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.db.users import User, Users
from mvmcryption.resp import PERMISSION_DENIED
SJWT_TTL = timedelta(minutes=15)
def global_ecdsa(private_key: Annotated[int, Depends(private_key)]) -> ECDSA:
return ECDSA(private_key)
def global_sjwt(ecdsa: Annotated[ECDSA, Depends(global_ecdsa)]):
return SJWT(ecdsa)
def create_sjwt(user: User, sjwt: SJWT, expires: datetime | None = None) -> str:
_expires = expires or (datetime.now(UTC) + SJWT_TTL)
return sjwt.encode({"sub": user.id, "exp": _expires.isoformat()})
def decode_sjwt(token: str, sjwt: SJWT, users: Users) -> User | None:
if not token:
return None
try:
decoded = sjwt.decode(token)
except Exception:
return None
if not (
expiry_str := decoded.get("exp")
): # no expiry -> some token generated by an admin
return None # for ~~security~~ budget reasons this is disabled right now # TODO: fix this
if not isinstance(expiry_str, str):
return None
try:
expiry = datetime.fromisoformat(expiry_str)
except Exception:
return None
if not expiry or expiry <= datetime.now(UTC):
return None
user_id = decoded.get("sub")
if user_id is None:
return None
if not isinstance(user_id, int):
return None
user = users.find(user_id)
if user is None:
return None
return user
def authorized_user(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
response: Response,
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
user = decode_sjwt(mvmcryptionauthtoken, sjwt, users)
if not user:
if mvmcryptionauthtoken:
response.delete_cookie("mvmcryptionauthtoken")
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Unauthorized.",
)
return user
def admin_user(user: Annotated[User, Depends(authorized_user)]):
if not user.is_admin:
raise PERMISSION_DENIED
return user
def _aes_key() -> bytes:
f = Path("/etc/aes-key")
if not f.exists():
f.write_bytes(long_to_bytes(randbits(128)))
return f.read_bytes()
def global_aes(key: Annotated[bytes, Depends(_aes_key)]):
return SCBCCipher(key)
AuthorizedUser = Annotated[User, Depends(authorized_user)]
AdminUser = Annotated[User, Depends(admin_user)]
GlobalECDSA = Annotated[ECDSA, Depends(global_ecdsa)]
GlobalSCBCCipher = Annotated[SCBCCipher, Depends(global_aes)]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/app.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/app.py | from fastapi import APIRouter, FastAPI
from mvmcryption.db import initialize
from mvmcryption.environ import IS_DEV
from mvmcryption.routers import auth, crypto, users
tags_metadata = [
{
"name": "users",
"description": "Operations with users.",
},
{
"name": "crypto",
"description": "Cryptography stuff.",
},
{
"name": "auth",
"description": "Logout/Login/Register stuff.",
},
]
app = FastAPI(
title="Much Vulnerable Machine API",
description="3AM Crypto chall.",
version="dQw4w9WgXcQ",
openapi_tags=tags_metadata,
)
if IS_DEV:
from fastapi.middleware.cors import CORSMiddleware
# building a frontend is left as exercise for the player
app.add_middleware(
CORSMiddleware,
allow_origins=[
"http://localhost:5173",
"http://localhost:4200",
"http://localhost:3000",
],
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
app.add_event_handler("startup", initialize)
api_router = APIRouter(prefix="/api")
api_router.include_router(auth)
api_router.include_router(crypto)
api_router.include_router(users)
app.include_router(api_router)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/users.py | from __future__ import annotations
from argon2 import PasswordHasher, exceptions
from pydantic import EmailStr, SecretStr
from .db import BaseModel, DBModel
PH = PasswordHasher()
class User(BaseModel):
username: str
email: EmailStr
password: SecretStr
@property
def is_admin(self):
return self.id == 1
class Users(DBModel[User]):
tablename = "users"
model = User
columns = (
"username",
"email",
"password",
)
mutable_columns = (
"username",
"email",
)
def find_by_username(self, username: str):
return self.find_by("username")(username)
def create(self, *, username: str, email: str, password: str) -> User:
_password = PH.hash(password)
return self.insert(
{"username": username, "email": email, "password": _password},
)
def login(self, username: str, password: str) -> User | None:
if not (u := self.find_by_username(username)):
return None
try:
PH.verify(u.password.get_secret_value(), password)
return u
except exceptions.VerifyMismatchError:
return None
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/db.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/db.py | from __future__ import annotations
import sqlite3
from abc import ABC, abstractmethod
from collections.abc import Callable, Iterator, Sequence
from contextlib import contextmanager
from typing import Annotated, Generic, TypeVar
from fastapi import Depends
from pydantic import BaseModel as _BaseModel
from mvmcryption.environ import getenv
DB_PATH = getenv("DB_PATH")
def connect_dependency() -> sqlite3.Connection:
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
conn.autocommit = True
return conn
@contextmanager
def connect() -> Iterator[sqlite3.Connection]:
conn = connect_dependency()
try:
yield conn
finally:
conn.close()
class BaseModel(_BaseModel):
id: int
T = TypeVar("T", bound=BaseModel)
V = TypeVar("V")
class DBModel(ABC, Generic[T]):
def __init__(self, conn: sqlite3.Connection) -> None:
self.conn = conn
@classmethod
@property
@abstractmethod
def tablename(cls) -> str:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def mutable_columns(cls) -> Sequence[str]:
raise NotImplementedError
@classmethod
@property
@abstractmethod
def model(cls) -> type[T]:
raise NotImplementedError
@classmethod
@property
def select_query(cls) -> str:
return f"SELECT * FROM {cls.tablename} "
@classmethod
@property
def delete_query(cls) -> str:
return f"DELETE FROM {cls.tablename} "
@classmethod
@property
def insert_query(cls) -> str:
return f"INSERT INTO {cls.tablename} ({', '.join(cls.columns)}) VALUES ({', '.join(f':{col}' for col in cls.columns)}) RETURNING *;"
@classmethod
@property
def update_query(cls) -> str:
return f"UPDATE {cls.tablename} SET {', '.join([f'{col} = :{col}' for col in cls.mutable_columns])} "
@contextmanager
def cur(self) -> Iterator[sqlite3.Cursor]:
cur = self.conn.cursor()
try:
yield cur
finally:
cur.close()
def delete(self, id: int) -> None:
return self.delete_by("id")(id)
def delete_by(self, lookup: str) -> None:
q = self.delete_query + f"WHERE {lookup} = ?;"
def _delete_by(value) -> None:
with self.cur() as cur:
cur.execute(q, [value])
return _delete_by
def insert(self, params: dict, **kwargs) -> T:
with self.cur() as cur:
cur.execute(self.insert_query, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
def update(self, id: int, params: dict) -> T:
return self.update_by("id")(id, params)
def update_by(self, lookup: str) -> Callable[[dict, ...], T]:
if not self.update_query:
raise Exception("Model is readonly.")
q = self.update_query + f"WHERE {lookup} = :lookup RETURNING *;"
def _update_by(value, params: dict, **kwargs) -> T:
params["lookup"] = value
with self.cur() as cur:
cur.execute(q, params, **kwargs)
record = cur.fetchone()
return self.model(**record)
return _update_by
def find(self, id: int) -> T | None:
return self.find_by("id")(id)
def find_by(self, lookup: str) -> Callable[[V], T]:
q = self.select_query + f"WHERE {lookup} = :{lookup};"
def _find_by(value) -> T | None:
with self.cur() as cur:
cur.execute(q, [value])
if record := cur.fetchone():
return self.model(**record)
return None
return _find_by
def all(self) -> list[T]:
q = self.select_query + ";"
with self.cur() as cur:
cur.execute(q)
return [self.model(**record) for record in cur.fetchall()]
@classmethod
def dependency(cls, db: Annotated[sqlite3.Connection, Depends(connect_dependency)]):
return cls(db)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/db/__init__.py | from __future__ import annotations
from mvmcryption.environ import getenv
from .db import connect
from .users import Users
ADMIN_PASSWORD = getenv("ADMIN_PASSWORD")
TABLE_QUERY = """
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username VARCHAR(50) NOT NULL UNIQUE,
email VARCHAR(100) NOT NULL UNIQUE,
password VARCHAR(100) NOT NULL
);
"""
def initialize() -> None:
with connect() as conn:
conn.executescript(TABLE_QUERY)
try:
Users(conn).create(
username="admin",
email="admin@this-company-luckily-does-not-exist.mvm",
password=ADMIN_PASSWORD,
)
except Exception as e: # maybe it already exists
print(e)
__all__ = [
"Users",
"initialize",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/users.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/users.py | from typing import Annotated, Literal
from fastapi import APIRouter, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr
from mvmcryption.auth import AuthorizedUser
from mvmcryption.db import Users
from mvmcryption.resp import PERMISSION_DENIED, not_found
from mvmcryption.routers.auth import USERNAME_FIELD
users_router = APIRouter(prefix="/users", tags=["users"])
class UpdateBody(BaseModel):
username: str = USERNAME_FIELD
email: EmailStr
@users_router.get("/")
def user_list(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
):
if user.is_admin:
return users.all()
return [user]
@users_router.patch("/{user_id}")
def update_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
body: UpdateBody,
):
"""Whoa! im updating things!"""
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if user.id != user_id:
user = users.find(user_id)
if user.username != body.username and users.find_by("username")(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if user.email != email and users.find_by("email")(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
try:
return users.update(user.id, dict(username=body.username, email=email))
except Exception:
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
@users_router.delete("/{user_id}")
def delete_user(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
response: Response,
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
users.delete(user_id)
response.delete_cookie("mvmcryptionauthtoken", secure=False, httponly=True)
response.status_code = status.HTTP_204_NO_CONTENT
@users_router.get("/{user_id}")
def user_detail(
user: AuthorizedUser,
users: Annotated[Users, Depends(Users.dependency)],
user_id: int | Literal["me"],
):
if user_id == "me":
user_id = user.id
if user.id != user_id and not user.is_admin:
raise PERMISSION_DENIED
if record := users.find(user_id):
return record
raise not_found(Users.model)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/crypto.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/crypto.py | from random import getrandbits
from Crypto.Util.number import long_to_bytes
from fastapi import APIRouter
from pydantic import BaseModel, validator
from mvmcryption.auth import (
AdminUser,
AuthorizedUser,
GlobalECDSA,
GlobalSCBCCipher,
)
from mvmcryption.environ import getenv
from mvmcryption.utils import decode, encode
FLAG = getenv("FLAG").encode()
crypto_router = APIRouter(prefix="/crypto", tags=["crypto"])
class DecryptionBody(BaseModel):
ciphertext: str
iv: str
@validator("ciphertext")
def validate_ciphertext(v):
try:
decoded = decode(v)
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
if len(decoded) % 16 != 0:
msg = "????"
raise ValueError(msg)
return v
@validator("iv")
def validate_iv(v):
try:
decoded = decode(v)
assert len(decoded) == 16
except Exception:
msg = "What exactly are you trying to achieve?"
raise ValueError(msg)
return v
@crypto_router.get("/public-key")
def ecdsa_public_key(ecdsa: GlobalECDSA) -> dict:
"""ECDSA Public Key."""
return ecdsa.pretty_public_key
@crypto_router.post("/decrypt")
def decrypt(admin: AdminUser, cipher: GlobalSCBCCipher, body: DecryptionBody):
"""
Real men test in production.
- Our CISO, probably
"""
try:
res = cipher.decrypt(decode(body.ciphertext), decode(body.iv))
return {"plaintext": res.decode()}
except Exception as e:
return {"err": str(e)}
@crypto_router.get("/flag")
def flag(user: AuthorizedUser, cipher: GlobalSCBCCipher):
iv = long_to_bytes(getrandbits(128), 16)
ct = cipher.encrypt(FLAG, iv)
return {"ciphertext": encode(ct), "iv": encode(iv)}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/__init__.py | from .auth import auth_router as auth
from .crypto import crypto_router as crypto
from .users import users_router as users
__all__ = [
"auth",
"crypto",
"users",
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/auth.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/routers/auth.py | from datetime import UTC, datetime
from typing import Annotated
from fastapi import APIRouter, Cookie, Depends, HTTPException, Response, status
from pydantic import BaseModel, EmailStr, Field
from mvmcryption.auth import (
SJWT_TTL,
AuthorizedUser,
create_sjwt,
decode_sjwt,
global_sjwt,
)
from mvmcryption.crypto.jwt import SJWT
from mvmcryption.db.users import Users
from mvmcryption.environ import IS_DEV
USERNAME_FIELD = Field(max_length=50, min_length=2)
PASSWORD_FIELD = Field(max_length=100, min_length=8)
class LoginBody(BaseModel):
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
class RegisterBody(BaseModel):
email: EmailStr
username: str = USERNAME_FIELD
password: str = PASSWORD_FIELD
auth_router = APIRouter(prefix="/auth", tags=["auth"])
@auth_router.get("/status")
def user_status(
users: Annotated[Users, Depends(Users.dependency)],
sjwt: Annotated[SJWT, Depends(global_sjwt)],
mvmcryptionauthtoken: Annotated[str | None, Cookie()] = None,
):
"""Return whether or not user is logged in."""
return {"authorized": bool(decode_sjwt(mvmcryptionauthtoken, sjwt, users))}
@auth_router.post("/login")
def login(
body: LoginBody,
response: Response,
sjwt: Annotated[SJWT, Depends(global_sjwt)],
users: Annotated[Users, Depends(Users.dependency)],
):
if not (user := users.login(body.username, body.password)):
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Invalid Credentials.",
)
expires = datetime.now(UTC) + SJWT_TTL
token = create_sjwt(user, sjwt, expires)
response.set_cookie(
"mvmcryptionauthtoken",
token,
expires=expires,
secure=not IS_DEV,
httponly=True,
)
response.status_code = status.HTTP_204_NO_CONTENT
@auth_router.post("/register")
def register(
body: RegisterBody,
users: Annotated[Users, Depends(Users.dependency)],
):
if users.find_by_username(body.username):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Username is not available.",
)
email = body.email.lower()
if users.find_by_username(email):
raise HTTPException(
status_code=status.HTTP_400_BAD_REQUEST,
detail="Email is not available.",
)
if not (
user := users.create(
username=body.username,
email=email,
password=body.password,
)
):
raise HTTPException(
status_code=status.HTTP_418_IM_A_TEAPOT,
detail="Something went very wrong.",
)
return user
@auth_router.post("/logout")
def logout(response: Response, user: AuthorizedUser):
response.delete_cookie("mvmcryptionauthtoken")
response.status_code = status.HTTP_204_NO_CONTENT
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/ecdsa.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/ecdsa.py | """Cryptography stuff."""
from dataclasses import dataclass
from hashlib import sha256
from pathlib import Path
from random import getrandbits
from secrets import randbelow
from Crypto.Util.number import bytes_to_long, long_to_bytes
from fastecdsa.curve import P256, Curve
from fastecdsa.ecdsa import verify
from fastecdsa.keys import get_public_key
from fastecdsa.point import Point
from mvmcryption.utils import decode, encode
CURVE = P256
N = CURVE.q
def private_key() -> int:
f = Path("/etc/ecdsa-private-key")
if not f.exists():
privkey = randbelow(N)
f.write_text(str(privkey))
privkey = int(f.read_text())
return privkey
def generate_nonce(k):
"""😇😇😇"""
return getrandbits(k)
def encode_signature(signature: tuple[int, int]) -> str:
"""Encode signature to following format:
`<r.b64>.<s.b64>`
"""
r = encode(long_to_bytes(signature[0]))
s = encode(long_to_bytes(signature[1]))
return ".".join([r, s])
def decode_signature(encoded_signature: tuple[str, str]) -> tuple[int, int]:
"""Decode signature from the following format:
`<r.b64>.<s.b64>`
"""
r = bytes_to_long(decode(encoded_signature[0]))
s = bytes_to_long(decode(encoded_signature[1]))
return r, s
@dataclass
class ECDSA:
private_key: int
curve: Curve = P256
def sign(self, msg: bytes) -> tuple[int, int]:
z = int(sha256(msg).hexdigest(), 16) % N
k = generate_nonce(128) # 😇😇😇
R = k * P256.G
r = R.x % N
s = (pow(k, -1, N) * (z + r * self.private_key)) % N
return (r, s)
@property
def public_key(self) -> Point:
return get_public_key(self.private_key, self.curve)
def verify(self, signature: tuple[int, int], msg: bytes) -> bool:
return verify(signature, msg, self.public_key, curve=self.curve)
@property
def pretty_public_key(self) -> dict:
return {
"curve": {
"name": self.curve.name,
"G": [hex(self.curve.gx), hex(self.curve.gy)],
"p": hex(self.curve.p),
"n": hex(self.curve.q),
},
"Q": [hex(self.public_key.x), hex(self.public_key.y)],
}
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/jwt.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/jwt.py | from dataclasses import dataclass
from json import dumps, loads
from mvmcryption.utils import decode as b64decode
from mvmcryption.utils import encode as b64encode
from .ecdsa import ECDSA, decode_signature, encode_signature
# SJWT -> Scuffed JSON Web Token; just some extra pain
class SJWTError(ValueError):
"""Error for SJWT things."""
class SJWTEncodingError(SJWTError):
"""Errors for encoding SJWTs!"""
class SJWTDecodeError(SJWTError):
"""Shit happend while decoding that SJWT!"""
class SJWTVerificationError(SJWTError):
"""That SJWT nasty!"""
@dataclass
class SJWT:
ecdsa: ECDSA
def encode(self, payload: dict[str], requires_expiry=True) -> str:
if "exp" not in payload and requires_expiry:
raise SJWTEncodingError("Sir we need an expiry on the token!")
as_string = dumps(payload)
_body = as_string.encode()
sig = encode_signature(self.ecdsa.sign(_body))
body = b64encode(_body)
return body + "." + sig
def decode(self, string: str, verify: bool = True) -> dict[str]:
parts = string.split(".")
if len(parts) != 3:
# why even try this >:(
raise SJWTDecodeError("WRONG AMOUNT OF parts! parts! >:C")
try:
body = b64decode(parts[0])
r, s = decode_signature(parts[1:])
except Exception:
# JUST STOP IT; THIS IS SECURE!!!!!! >:C
raise SJWTDecodeError("Bad token! bad bad bad!")
if verify:
self._verify(body, (r, s))
try:
return loads(body.decode())
except Exception:
raise SJWTDecodeError("funny user")
def _verify(self, body: bytes, signature: tuple[int, int]) -> None:
# raise if payload not satisfactory
if not (self.ecdsa.verify(signature, body)):
raise SJWTVerificationError(":c stop it")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/cipher.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/cipher.py | from dataclasses import dataclass
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
from pwn import xor
from mvmcryption.utils import chunk
BLOCK_SIZE = 16
@dataclass
class SCBCCipher:
"""
Scuffed CBC Cipher.
If you're wondering why we aren't using CBC directly, this is part of our "Customer Retention Strategy".
"""
key: bytes
@property
def _ecb(self):
return AES.new(self.key, AES.MODE_ECB)
def encrypt(self, plaintext: bytes, iv: bytes) -> bytes:
padded = pad(plaintext, BLOCK_SIZE)
enc = []
blocks = chunk(padded)
enc.append(self._ecb.encrypt(xor(blocks[0], iv)))
for i, block in enumerate(blocks[1:]):
enc.append(self._ecb.encrypt(xor(block, enc[i])))
return b"".join(enc)
def decrypt(self, ciphertext: bytes, iv: bytes) -> bytes:
ndec = chunk(ciphertext)
dec = []
dec.append(xor(self._ecb.decrypt(ndec[0]), iv))
for i, block in enumerate(ndec[1:]):
dec.append(xor(self._ecb.decrypt(block), ndec[i]))
return unpad(b"".join(dec), BLOCK_SIZE)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/__init__.py | ctfs/x3ctf/2025/crypto/much-vulnerable-machine-1/api/mvmcryption/crypto/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/curved-mvm/server.py | ctfs/x3ctf/2025/crypto/curved-mvm/server.py | from sage.all import *
import os
from json import dumps
from secrets import randbits
from Crypto.Util.number import bytes_to_long
from hashlib import sha1
FLAG = os.getenv("FLAG", "MVM{f4ke_fl4g}")
# a wonderful curve
p = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF
a = 0xFFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC
b = 0x5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B
Gx = 0x6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296
Gy = 0x4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5
F = GF(p)
EC = EllipticCurve(F, [a, b])
n = EC.order()
SECRET_KEY = bytes_to_long(os.urandom(69420)) % n
G = EC([Gx, Gy])
assert G in EC
Q = SECRET_KEY * G
FUNNY_CREDITS_FOR_FREE_TRIAL = 2
CHALL_NAME = "Curved MVM"
K_SIZE = 18
SAMPLE_MSG = "hardcoded cuz reasons"
REQUIRED_MSG = "mvm mvm mvm"
def sign_msg(msg: str):
z = bytes_to_long(sha1(msg.encode()).digest()) % n
k = (randbits(K_SIZE) + 2) % n
R = k * G
r = ZZ(R.x()) % n
s = (k.inverse_mod(n) * (z + r * SECRET_KEY)) % n
return {"r": hex(r), "s": hex(s)}
def sign_bogus():
return sign_msg(SAMPLE_MSG)
def verify_signature(r, s, msg):
z = bytes_to_long(sha1(msg.encode()).digest()) % n
if r < 1 or r >= n or s < 1 or s >= n:
return {"error": "funny user uwu"}
w = s.inverse_mod(n)
u1 = (z * w) % n
u2 = (r * w) % n
P = u1 * G + u2 * Q
should_r = ZZ(P.x()) % n
if should_r == r:
return {"flag": FLAG}
else:
# user funny
return {"error": "invalid signature"}
def mvm():
r = prompt_integer("r")
s = prompt_integer("s")
try:
return verify_signature(r, s, REQUIRED_MSG)
except:
return {"error": "funny user"}
operations = {
"sign": sign_bogus,
"mvm": mvm,
}
def prompt_operation():
_prompt = "/".join(operations)
prompt = f"({_prompt}): "
try:
recv = input(prompt)
except Exception:
print("user too funny, complaints will be ignored\n")
if recv not in operations:
print("funny operation\n")
return prompt_operation()
return operations[recv]
def prompt_integer(name: str):
prompt = f"{name}: "
try:
recv = input(prompt)
except:
print("user too funny, complaints will be sent to /dev/null\n")
return prompt_integer(name)
try:
number = int(recv, 16)
except:
print("user supplied number too funny, complaints will be ignored\n")
return prompt_integer(name)
if number <= 1:
print("user supplied number funny.\n")
return prompt_integer(name)
return ZZ(number)
funny_credits = FUNNY_CREDITS_FOR_FREE_TRIAL
if __name__ == "__main__":
print(f"Welcome to {CHALL_NAME!r}, enjoy the pain!\n")
while True:
print(
f"You have {funny_credits} funny credit{'s' if funny_credits > 1 else ''}."
)
operation = prompt_operation()
print(dumps(operation()))
funny_credits -= 1
if funny_credits == 0:
print("ran out of funny credits, bye")
exit()
print()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/x3ctf/2025/crypto/curved-mvm/fast.py | ctfs/x3ctf/2025/crypto/curved-mvm/fast.py | import os
from json import dumps
from secrets import randbits
from hashlib import sha1
from fastecdsa.curve import P256
from fastecdsa.point import Point
n = P256.q
FLAG = os.getenv("FLAG", "MVM{f4ke_fl4g}")
SECRET_KEY = int.from_bytes(os.urandom(69420)) % n
Q = SECRET_KEY * P256.G
FUNNY_CREDITS_FOR_FREE_TRIAL = 2
CHALL_NAME = "Curved MVM"
K_SIZE = 18
SAMPLE_MSG = "hardcoded cuz reasons"
REQUIRED_MSG = "mvm mvm mvm"
def sign_msg(msg: str):
z = int.from_bytes(sha1(msg.encode()).digest()) % n
k = (randbits(K_SIZE) + 2) % n
R = k * P256.G
r = R.x % n
s = (pow(k, -1, n) * (z + r * SECRET_KEY)) % n
return {"r": hex(r), "s": hex(s)}
def sign_bogus():
return sign_msg(SAMPLE_MSG)
def verify_signature(r, s, msg):
z = int.from_bytes(sha1(msg.encode()).digest()) % n
if r < 1 or r >= n or s < 1 or s >= n:
return {"error": "funny user uwu"}
w = pow(s, -1, n)
u1 = (z * w) % n
u2 = (r * w) % n
P = u1 * P256.G + u2 * Q
should_r = P.x % n
if should_r == r:
return {"flag": FLAG}
else:
# user funny
return {"error": "invalid signature"}
def mvm():
r = prompt_integer("r")
s = prompt_integer("s")
try:
return verify_signature(r, s, REQUIRED_MSG)
except:
return {"error": "funny user"}
operations = {
"sign": sign_bogus,
"mvm": mvm,
}
def prompt_operation():
_prompt = "/".join(operations)
prompt = f"({_prompt}): "
try:
recv = input(prompt)
except Exception:
print("user too funny, complaints will be ignored\n")
if recv not in operations:
print("funny operation\n")
return prompt_operation()
return operations[recv]
def prompt_integer(name: str):
prompt = f"{name}: "
try:
recv = input(prompt)
except:
print("user too funny, complaints will be sent to /dev/null\n")
return prompt_integer(name)
try:
number = int(recv, 16)
except:
print("user supplied number too funny, complaints will be ignored\n")
return prompt_integer(name)
if number <= 1:
print("user supplied number funny.\n")
return prompt_integer(name)
return number
funny_credits = FUNNY_CREDITS_FOR_FREE_TRIAL
if __name__ == "__main__":
print(f"Welcome to {CHALL_NAME!r}, enjoy the pain!\n")
while True:
print(
f"You have {funny_credits} funny credit{'s' if funny_credits > 1 else ''}."
)
operation = prompt_operation()
print(dumps(operation()))
funny_credits -= 1
if funny_credits == 0:
print("ran out of funny credits, bye")
exit()
print()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/pwn/U2S/stuff/run.py | ctfs/Mapna/2024/pwn/U2S/stuff/run.py | #!/usr/bin/env python3
import tempfile
import pathlib
import os
import re
import json
import time
import signal
import re
if not os.path.exists('/tmp/ips.json'):
f = open('/tmp/ips.json','w')
f.write('{}')
f.close()
ipFile = open('/tmp/ips.json','r+')
peerIp = os.environ['SOCAT_PEERADDR']
ips = {}
ips = json.loads(ipFile.read())
if(peerIp in ips):
if(time.time() > ips[peerIp]):
ips[peerIp] = int(time.time())+5
else:
print('one try every 5 seconds')
exit(0)
else:
ips[peerIp] = int(time.time())+5
ipFile.seek(0)
ipFile.write(json.dumps(ips))
ipFile.close()
os.chdir(pathlib.Path(__file__).parent.resolve())
signal.alarm(10)
os.setgid(1000)
os.setuid(1000)
with tempfile.NamedTemporaryFile() as tmp:
print('Send the file: (ended with "\\n-- EOF --\\n"):')
s = input()
while(re.match('^[\x09-\x7f]*$',s) and s != '-- EOF --' and len(s) < 1024*1024):
tmp.write((s+'\n').encode())
s = input()
tmp.flush()
os.close(0)
os.system('timeout 3 ./lua ' + tmp.name)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/pwn/Protector/generate_directory_tree.py | ctfs/Mapna/2024/pwn/Protector/generate_directory_tree.py | import os
import random
import string
flag = "MAPNA{placeholder_for_flag}"
MIN_NAME_LENGTH = 8
MAX_NAME_LENGTH = 16
FILES_COUNT = 0x100
def get_random_name():
n = random.randint(MIN_NAME_LENGTH, MAX_NAME_LENGTH)
return "".join(random.choice(string.ascii_letters + string.digits) for i in range(n))
def generate_files():
files = [get_random_name() for i in range(FILES_COUNT)]
real_flag_file = random.choice(files)
for filepath in files:
if filepath == real_flag_file:
continue
with open(filepath, "w") as f:
pass
with open(real_flag_file, "w") as f:
f.write(flag)
def main():
os.mkdir("maze")
os.chdir("maze")
generate_files()
if __name__ == "__main__":
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/crypto/What_next_II/what_next_ii.py | ctfs/Mapna/2024/crypto/What_next_II/what_next_ii.py | #!/usr/bin/env python3
from random import *
from Crypto.Util.number import *
from flag import flag
def encrypt(msg, KEY):
m = bytes_to_long(msg)
c = KEY ^ m
return c
n = 80
TMP = [getrandbits(256) * _ ** 2 for _ in range(n)]
KEY = sum([getrandbits(256 >> _) ** 2 for _ in range(8)])
enc = encrypt(flag, KEY)
print(f'TMP = {TMP}')
print(f'enc = {enc}') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/crypto/Be_Fast/be_fast.py | ctfs/Mapna/2024/crypto/Be_Fast/be_fast.py | #!/usr/bin/env python3
from random import *
from binascii import *
from Crypto.Cipher import DES
from signal import *
import sys, os
from flag import flag
def die(*args):
pr(*args)
quit()
def pr(*args):
s = " ".join(map(str, args))
sys.stdout.write(s + "\n")
sys.stdout.flush()
def sc():
return sys.stdin.buffer.readline()
def shift(msg, l):
assert l < len(msg)
return msg[l:] + msg[:l]
def pad(text):
if len(text) % 8 != 0:
text += (b'\xff' * (8 - len(text) % 8))
return text
def encrypt(msg, key):
msg = pad(msg)
assert len(msg) % 8 == 0
assert len(key) == 8
des = DES.new(key, DES.MODE_ECB)
enc = des.encrypt(msg)
return enc
def main():
border = "+"
pr(border*72)
pr(border, ".:: Hi all, you should be fast, I mean super fact!! ::.", border)
pr(border, "You should send twenty 8-byte keys to encrypt the secret message and", border)
pr(border, "just decrypt the ciphertext to get the flag, Are you ready to start?", border)
pr(border*72)
secret_msg = b'TOP_SECRET:' + os.urandom(40)
cnt, STEP, KEYS = 0, 14, []
md = 1
while True:
pr(border, "please send your key as hex: ")
alarm(md + 1)
ans = sc().decode().strip()
alarm(0)
try:
key = unhexlify(ans)
if len(key) == 8 and key not in KEYS:
KEYS += [key]
cnt += 1
else:
die(border, 'Kidding me!? Bye!!')
except:
die(border, 'Your key is not valid! Bye!!')
if len(KEYS) == STEP:
print(KEYS)
HKEY = KEYS[:7]
shuffle(HKEY)
NKEY = KEYS[-7:]
shuffle(NKEY)
for h in HKEY: NKEY = [key, shift(key, 1)] + NKEY
enc = encrypt(secret_msg, NKEY[0])
for key in NKEY[1:]:
enc = encrypt(enc, key)
pr(border, f'enc = {hexlify(enc)}')
pr(border, f'Can you guess the secret message? ')
alarm(md + 1)
msg = sc().strip()
alarm(0)
if msg == hexlify(secret_msg):
die(border, f'Congrats, you deserve the flag: {flag}')
else:
die(border, f'Sorry, your input is incorrect! Bye!!')
if __name__ == '__main__':
main() | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/crypto/Shibs/shibs.py | ctfs/Mapna/2024/crypto/Shibs/shibs.py | #!/usr/bin/env python3
from Crypto.Util.number import *
from flag import flag
def shift(s, B):
assert s < len(B)
return B[s:] + B[:s]
def gen_key(nbit):
while True:
p = getPrime(nbit)
B = bin(p)[2:]
for s in range(1, nbit):
q = int(shift(s, B), 2)
if isPrime(q):
n = p * q
return n, p, s
nbit = 1024
n, p, _ = gen_key(nbit)
q = n // p
dna = p & q
m = bytes_to_long(flag)
c = pow(m, 65537, n)
print(f'n = {n}')
print(f'dna = {dna}')
print(f'enc = {c}')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/crypto/What_next/what_next.py | ctfs/Mapna/2024/crypto/What_next/what_next.py | #!/usr/bin/env python3
from random import *
from Crypto.Util.number import *
from flag import flag
def encrypt(msg, KEY):
m = bytes_to_long(msg)
c = KEY ^ m
return c
n = 80
TMP = [getrandbits(256) * _ ** 2 for _ in range(n)]
KEY = sum([getrandbits(256 >> _) for _ in range(8)])
enc = encrypt(flag, KEY)
print(f'TMP = {TMP}')
print(f'KEY = {KEY}')
print(f'enc = {enc}') | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Mapna/2024/web/Novel_reader/stuff/main.py | ctfs/Mapna/2024/web/Novel_reader/stuff/main.py | from flask import *
from urllib.parse import unquote
import os
def readFile(path):
f = open(path,'r')
buf = f.read(0x1000)
f.close()
return buf
app = Flask(__name__,static_folder='./static')
app.secret_key = 'REDACTED'
indexFile = readFile('index.html')
@app.before_request
def init_session():
if('credit' not in session):
session['credit'] = 100
session['words_balance'] = 1
@app.get('/')
def index():
return indexFile
@app.get('/api/stats')
def getStats():
return {'credit': session['credit'], 'words_balance': session['words_balance']}
@app.post('/api/charge')
def buyWord():
nwords = request.args.get('nwords')
if(nwords):
nwords = int(nwords[:10])
price = nwords * 10
if(price <= session['credit']):
session['credit'] -= price
session['words_balance'] += nwords
return {'success': True, 'msg': 'Added to your account!'}
return {'success': False, 'msg': 'Not enough credit.'}, 402
else:
return {'success': False, 'msg': 'Missing parameteres.'}, 400
@app.get('/api/read/<path:name>')
def readNovel(name):
name = unquote(name)
if(not name.startswith('public/')):
return {'success': False, 'msg': 'You can only read public novels!'}, 400
buf = readFile(name).split(' ')
buf = ' '.join(buf[0:session['words_balance']])+'... Charge your account to unlock more of the novel!'
return {'success': True, 'msg': buf}
@app.get('/api/list-public-novels')
def listPublicNovels():
return os.listdir('./public/')
@app.get('/api/list-private-novels')
def listPrivateNovels():
return os.listdir('./private/')
if(__name__ == '__main__'):
app.run('0.0.0.0',port=8000)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2018/Quals/7amebox1/_7amebox.py | ctfs/Codegate/2018/Quals/7amebox1/_7amebox.py | #!/usr/bin/python
import random
import signal
import sys
PERM_MAPPED = 0b1000
PERM_READ = 0b0100
PERM_WRITE = 0b0010
PERM_EXEC = 0b0001
TYPE_R = 0
TYPE_I = 1
FLAG_NF = 0b0010
FLAG_ZF = 0b0001
CODE_DEFAULT_BASE = 0x00000
STACK_DEFAULT_BASE = 0xf4000
class Stdin:
def read(self, size):
res = ''
buf = sys.stdin.readline(size)
for ch in buf:
if ord(ch) > 0b1111111:
break
if ch == '\n':
res += ch
break
res += ch
return res
def write(self, data):
return None
class Stdout:
def read(self, size):
return None
def write(self, data):
out = ''.join(map(chr, data))
sys.stdout.write(out)
sys.stdout.flush()
return len(out)
class Register:
def __init__(self):
self.register = {}
self.register_list = ['r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7','r8', 'r9', 'r10', 'bp', 'sp', 'pc', 'eflags', 'zero']
def init_register(self):
for reg_name in self.register_list:
self.register[reg_name] = 0
def set_register(self, reg, value):
if isinstance(reg, (int, long)) :
if reg < len(self.register_list):
reg = self.register_list[reg]
else:
self.terminate("[VM] Invalid register")
elif reg not in self.register:
self.terminate("[VM] Invalid register")
self.register[reg] = value
def get_register(self, reg):
if isinstance(reg, (int, long)) :
if reg < len(self.register_list):
reg = self.register_list[reg]
else:
self.terminate("[VM] Invalid register")
elif reg not in self.register:
self.terminate("[VM] Invalid register")
return self.register[reg]
class FileSystem:
def __init__(self):
self.files = {}
def load_file(self, filename):
with open(filename, 'rb') as f:
self.files[filename] = f.read()
def open(self, filename):
if filename in self.files:
fd = File()
fd.set_buffer(self.files[filename])
return fd
else:
return -1
class File:
def __init__(self):
self.buffer = ''
self.pos = 0
self.size = 0
def set_buffer(self, data):
self.buffer = data
self.size = len(self.buffer)
def read(self, size):
res = ''
if self.pos >= self.size:
return ''
if self.pos + size >= len(self.buffer):
res += self.buffer[self.pos : ]
self.pos = len(self.buffer)
else:
res += self.buffer[self.pos : self.pos+size]
self.pos += size
return res
def write(self, data):
return None
class Memory:
def __init__(self, size):
self.memory = [0 for i in range(size)]
self.pages = {}
for page in range(0, size, 0x1000):
self.pages[page] = 0
def __getitem__(self, key):
return self.memory[key]
def __setitem__(self, key, val):
self.memory[key] = val
def get_perm(self, addr):
if (addr & 0b111111111000000000000) not in self.pages:
return 0
else:
return self.pages[addr & 0b111111111000000000000]
def set_perm(self, addr, perm):
self.pages[addr & 0b111111111000000000000] = perm & 0b1111
def allocate(self, new_perm, addr=None):
if addr:
if not (self.get_perm(addr) & PERM_MAPPED):
self.set_perm(addr, (PERM_MAPPED | new_perm) & 0b1111)
return addr
else:
return -1
for page, perm in self.pages.items():
if not (self.get_perm(page) & PERM_MAPPED):
self.set_perm(page, (PERM_MAPPED | new_perm) & 0b1111)
return page
return -1
def check_permission(self, addr, perm):
if self.get_perm(addr) & (PERM_MAPPED | perm):
return True
else:
return False
class EMU:
def __init__(self):
self.config = {'NX':False}
self.firmware = None
self.is_load = False
self.register = Register()
self.register.init_register()
self.pipeline = []
self.memory = Memory(2 ** 20)
self.checkperm = []
self.filesystem = FileSystem()
self.syscall_table = [self.sys_s0, self.sys_s1,
self.sys_s2, self.sys_s3,
self.sys_s4, self.sys_s5]
self.op_hander_table = [self.op_x0, self.op_x1,
self.op_x2, self.op_x3,
self.op_x4, self.op_x5, self.op_x6,
self.op_x7, self.op_x8,
self.op_x9, self.op_x10,
self.op_x11, self.op_x12,
self.op_x13, self.op_x14,
self.op_x15, self.op_x16,
self.op_x17, self.op_x18,
self.op_x19, self.op_x20,
self.op_x21, self.op_x22,
self.op_x23, self.op_x24,
self.op_x25, self.op_x26,
self.op_x27, self.op_x28,
self.op_x29, self.op_x30]
def set_timeout(self, timeout = 30):
def handler(signum, frame):
print 'timeout!'
exit(-1)
signal.signal(signal.SIGALRM, handler)
signal.alarm(timeout)
def set_mitigation(self, nx=False):
if nx:
self.config['NX'] = nx
def init_pipeline(self):
self.pipeline.append(Stdin())
self.pipeline.append(Stdout())
def load_firmware(self, firm_name):
try:
with open(firm_name, 'rb') as f:
data = f.read()
self.firmware = [ord(byte) for byte in data]
self.is_load = True
if self.config['NX']:
stack_perm = PERM_READ | PERM_WRITE
else:
stack_perm = PERM_READ | PERM_WRITE | PERM_EXEC
for i in range(0, len(data) / 0x1000 + 1):
self.memory.allocate(PERM_READ | PERM_WRITE | PERM_EXEC, addr=CODE_DEFAULT_BASE + i*0x1000)
self.write_memory(CODE_DEFAULT_BASE, self.firmware, len(self.firmware))
for i in range(0, len(data) / 0x1000 + 1):
self.memory.set_perm(CODE_DEFAULT_BASE + i*0x1000, PERM_MAPPED | PERM_READ | PERM_EXEC)
self.memory.allocate(stack_perm, addr=STACK_DEFAULT_BASE)
self.memory.allocate(stack_perm, addr=STACK_DEFAULT_BASE + 0x1000)
self.register.set_register('pc', CODE_DEFAULT_BASE)
self.register.set_register('sp', STACK_DEFAULT_BASE+0x1fe0)
except:
self.terminate("[VM] Firmware load error")
def bit_concat(self, bit_list):
res = 0
for bit in bit_list:
res <<= 7
res += bit & 0b1111111
return res
def execute(self):
try:
while 1:
cur_pc = self.register.get_register('pc')
op, op_type, opers, op_size = self.dispatch(cur_pc)
if not self.memory.check_permission(cur_pc, PERM_EXEC) or not self.memory.check_permission(cur_pc + op_size - 1, PERM_EXEC):
self.terminate("[VM] Can't exec memory")
self.register.set_register('pc', cur_pc + op_size)
op_handler = self.op_hander_table[op]
op_handler(op_type, opers)
except:
self.terminate("[VM] Unknown error")
def dispatch(self, addr):
opcode = self.bit_concat(self.read_memory(addr, 2))
op = (opcode & 0b11111000000000) >> 9
if op >= len(self.op_hander_table):
self.terminate("[VM] Invalid instruction")
op_type = (opcode & 0b00000100000000) >> 8
opers = []
if op_type == TYPE_R:
opers.append((opcode & 0b00000011110000) >> 4)
opers.append((opcode & 0b00000000001111))
op_size = 2
elif op_type == TYPE_I:
opers.append((opcode & 0b00000011110000) >> 4)
opers.append(self.read_memory_tri(addr+2, 1)[0])
op_size = 5
else:
self.terminate("[VM] Invalid instruction")
return op, op_type, opers, op_size
def read_memory(self, addr, length):
if not length:
return []
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + length - 1, PERM_READ):
res = self.memory[addr : addr + length]
return res
else:
self.terminate("[VM] Can't read memory")
def read_memory_str(self, addr):
res = []
length = 0
while 0 not in res:
res.append(self.memory[addr + length])
length += 1
res = res[:-1]
length -= 1
if not length:
return '', 0
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + length - 1, PERM_READ):
return ''.join(map(chr,res)), length
else:
self.terminate("[VM] Can't read memory")
def read_memory_tri(self, addr, count):
if not count:
return []
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + count*3 - 1, PERM_READ):
res = []
for i in range(count):
tri = 0
tri |= self.memory[addr + i*3]
tri |= self.memory[addr + i*3 + 1] << 14
tri |= self.memory[addr + i*3 + 2] << 7
res.append(tri)
return res
else:
self.terminate("[VM] Can't read memory")
def write_memory(self, addr, data, length):
if not length:
return
if self.memory.check_permission(addr, PERM_WRITE) and self.memory.check_permission(addr + length - 1, PERM_WRITE):
for offset in range(length):
self.memory[addr + offset] = data[offset] & 0b1111111
else:
self.terminate("[VM] Can't write memory")
def write_memory_tri(self,addr,data_list, count):
if not count:
return
if self.memory.check_permission(addr, PERM_WRITE) and self.memory.check_permission(addr + count*3 - 1, PERM_WRITE):
for i in range(count):
self.memory[addr + i*3] = (data_list[i] & 0b000000000000001111111)
self.memory[addr + i*3 + 1] = (data_list[i] & 0b111111100000000000000) >> 14
self.memory[addr + i*3 + 2] = (data_list[i] & 0b000000011111110000000) >> 7
else:
self.terminate("[VM] Can't write memory")
def op_x0(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
data = self.read_memory_tri(src, 1)[0]
self.register.set_register(dst, data)
else:
self.terminate("[VM] Invalid instruction")
def op_x1(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
ch = self.read_memory(src, 1)[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ch)
else:
self.terminate("[VM] Invalid instruction")
def op_x2(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
dst = self.register.get_register(opers[1])
self.write_memory_tri(dst, [src], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x3(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
dst = self.register.get_register(opers[1])
self.write_memory(dst, [src & 0b1111111], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x4(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
self.register.set_register(dst, src)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
self.register.set_register(dst, src)
else:
self.terminate("[VM] Invalid instruction")
def op_x5(self, op_type, opers):
if op_type == TYPE_R:
src = opers[1]
dst = opers[0]
org_src = self.register.get_register(src)
org_dst = self.register.get_register(dst)
self.register.set_register(src, org_dst)
self.register.set_register(dst, org_src)
else:
self.terminate("[VM] Invalid instruction")
def op_x6(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
sp = self.register.get_register('sp')
self.register.set_register('sp', sp-3)
self.write_memory_tri(sp-3, [src], 1)
elif op_type == TYPE_I:
src = opers[1]
sp = self.register.get_register('sp')
self.register.set_register('sp', sp-3)
self.write_memory_tri(sp-3, [src], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x7(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
sp = self.register.get_register('sp')
value = self.read_memory_tri(sp, 1)[0]
self.register.set_register(dst, value)
self.register.set_register('sp', sp+3)
else:
self.terminate("[VM] Invalid instruction")
def op_x9(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst + src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst + src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x10(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b1111111
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst + src) & 0b1111111))
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst + src) & 0b1111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x11(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst - src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst - src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x12(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b1111111
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst - src) & 0b1111111))
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst - src) & 0b1111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x13(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, org_dst >> value)
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, org_dst >> value)
else:
self.terminate("[VM] Invalid instruction")
def op_x14(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst << value) & 0b111111111111111111111)
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst << value) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x15(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, ((org_dst * value) & 0b111111111111111111111))
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, ((org_dst * value) & 0b111111111111111111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x16(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
if value == 0:
self.terminate("[VM] Divide by zero")
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (int(org_dst / value) & 0b111111111111111111111))
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
if value == 0:
self.terminate("[VM] Divide by zero")
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (int(org_dst / value) & 0b111111111111111111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x17(self, op_type, opers):
if op_type == TYPE_R:
src = opers[0]
value = self.register.get_register(src)
value += 1
self.register.set_register(src, value)
else:
self.terminate("[VM] Invalid instruction")
def op_x18(self, op_type, opers):
if op_type == TYPE_R:
src = opers[0]
value = self.register.get_register(src)
value -= 1
self.register.set_register(src, value)
else:
self.terminate("[VM] Invalid instruction")
def op_x19(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x20(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst | src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst | src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x21(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst ^ src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst ^ src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x22(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst % src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst % src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x23(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = self.register.get_register(opers[0])
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = self.register.get_register(opers[0])
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x24(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b000000000000001111111
dst = self.register.get_register(opers[0]) & 0b000000000000001111111
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1] & 0b000000000000001111111
dst = self.register.get_register(opers[0]) & 0b000000000000001111111
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x25(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if not (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if not (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x26(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x27(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x28(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x29(self, op_type, opers):
if op_type == TYPE_R:
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
base = self.register.get_register(opers[0])
offset = opers[1]
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x30(self, op_type, opers):
if op_type == TYPE_R:
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
ret_addr = self.register.get_register('pc')
self.op_x6(1, [0, ret_addr])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
base = self.register.get_register(opers[0])
offset = opers[1]
ret_addr = self.register.get_register('pc')
self.op_x6(1, [0, ret_addr])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x8(self, op_type, opers):
syscall_num = self.register.get_register('r0')
if 0 <= syscall_num < len(self.syscall_table):
syscall = self.syscall_table[syscall_num]
syscall()
else:
self.terminate("[VM] Invalid syscall")
def sys_s0(self):
exit(0)
def sys_s1(self):
filename, filename_len = self.read_memory_str(self.register.get_register('r1'))
fd = self.filesystem.open(filename)
if fd != -1:
self.pipeline.append(fd)
self.register.set_register('r0', len(self.pipeline) - 1)
else:
self.register.set_register('r0', 0b111111111111111111111)
def sys_s2(self):
fd = self.register.get_register('r1')
buf = self.register.get_register('r2')
size = self.register.get_register('r3')
data = self.read_memory(buf, size)
if 0 <= fd < len(self.pipeline):
self.pipeline[fd].write(data)
self.register.set_register('r0', size)
else:
self.register.set_register('r0', 0)
def sys_s3(self):
fd = self.register.get_register('r1')
buf = self.register.get_register('r2')
size = self.register.get_register('r3')
if 0 <= fd < len(self.pipeline):
data = map(ord, self.pipeline[fd].read(size))
self.write_memory(buf, data, len(data))
self.register.set_register('r0', len(data) & 0b111111111111111111111)
else:
self.register.set_register('r0', 0)
def sys_s4(self):
res_ptr = self.register.get_register('r1')
perm = self.register.get_register('r2')
addr = self.memory.allocate(perm)
if addr != -1:
self.write_memory_tri(res_ptr, [addr], 1)
self.register.set_register('r0', 1)
else:
self.register.set_register('r0', 0)
def sys_s5(self):
self.register.set_register('r0', random.randrange(0, 2**21-1))
def terminate(self, msg):
print msg
exit(-1) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2018/Quals/7amebox1/vm_name.py | ctfs/Codegate/2018/Quals/7amebox1/vm_name.py | #!/usr/bin/python
import string
import random
import _7amebox
from hashlib import sha1
# proof of work
print """
------------------------------------------------------------------------------------
if not (answer.startswith(prefix) and sha1(answer).hexdigest().endswith('000000')):
print 'nope'
exit(-1)
------------------------------------------------------------------------------------
"""
prefix = ''.join(random.sample(string.letters + string.digits, 6))
print 'prefix : {}'.format(prefix)
answer = raw_input('answer : ')
if not (answer.startswith(prefix) and sha1(answer).hexdigest().endswith('000000')):
print 'nope'
exit(-1)
firmware = 'mic_check.firm'
emu = _7amebox.EMU()
emu.filesystem.load_file('flag')
emu.register.init_register()
emu.init_pipeline()
emu.load_firmware(firmware)
emu.set_timeout(30)
emu.execute()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2018/Quals/7amebox2/vm_adventure.py | ctfs/Codegate/2018/Quals/7amebox2/vm_adventure.py | #!/usr/bin/python
import string
import random
import _7amebox
from hashlib import sha1
# proof of work
print """
------------------------------------------------------------------------------------
if not (answer.startswith(prefix) and sha1(answer).hexdigest().endswith('000000')):
print 'nope'
exit(-1)
------------------------------------------------------------------------------------
"""
prefix = ''.join(random.sample(string.letters + string.digits, 6))
print 'prefix : {}'.format(prefix)
answer = raw_input('answer : ')
if not (answer.startswith(prefix) and sha1(answer).hexdigest().endswith('000000')):
print 'nope'
exit(-1)
firmware = 'pwn_adventure.firm'
emu = _7amebox.EMU()
emu.filesystem.load_file('flag')
for i in range(0, 8):
emu.filesystem.load_file('stage_{}.map'.format(i))
emu.register.init_register()
emu.init_pipeline()
emu.load_firmware(firmware)
emu.set_mitigation(nx=True)
emu.set_timeout(360)
emu.execute()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2018/Quals/7amebox2/_7amebox.py | ctfs/Codegate/2018/Quals/7amebox2/_7amebox.py | #!/usr/bin/python
import random
import signal
import sys
PERM_MAPPED = 0b1000
PERM_READ = 0b0100
PERM_WRITE = 0b0010
PERM_EXEC = 0b0001
TYPE_R = 0
TYPE_I = 1
FLAG_NF = 0b0010
FLAG_ZF = 0b0001
CODE_DEFAULT_BASE = 0x00000
STACK_DEFAULT_BASE = 0xf4000
class Stdin:
def read(self, size):
res = ''
buf = sys.stdin.readline(size)
for ch in buf:
if ord(ch) > 0b1111111:
break
if ch == '\n':
res += ch
break
res += ch
return res
def write(self, data):
return None
class Stdout:
def read(self, size):
return None
def write(self, data):
out = ''.join(map(chr, data))
sys.stdout.write(out)
sys.stdout.flush()
return len(out)
class Register:
def __init__(self):
self.register = {}
self.register_list = ['r0', 'r1', 'r2', 'r3', 'r4', 'r5', 'r6', 'r7','r8', 'r9', 'r10', 'bp', 'sp', 'pc', 'eflags', 'zero']
def init_register(self):
for reg_name in self.register_list:
self.register[reg_name] = 0
def set_register(self, reg, value):
if isinstance(reg, (int, long)) :
if reg < len(self.register_list):
reg = self.register_list[reg]
else:
self.terminate("[VM] Invalid register")
elif reg not in self.register:
self.terminate("[VM] Invalid register")
self.register[reg] = value
def get_register(self, reg):
if isinstance(reg, (int, long)) :
if reg < len(self.register_list):
reg = self.register_list[reg]
else:
self.terminate("[VM] Invalid register")
elif reg not in self.register:
self.terminate("[VM] Invalid register")
return self.register[reg]
class FileSystem:
def __init__(self):
self.files = {}
def load_file(self, filename):
with open(filename, 'rb') as f:
self.files[filename] = f.read()
def open(self, filename):
if filename in self.files:
fd = File()
fd.set_buffer(self.files[filename])
return fd
else:
return -1
class File:
def __init__(self):
self.buffer = ''
self.pos = 0
self.size = 0
def set_buffer(self, data):
self.buffer = data
self.size = len(self.buffer)
def read(self, size):
res = ''
if self.pos >= self.size:
return ''
if self.pos + size >= len(self.buffer):
res += self.buffer[self.pos : ]
self.pos = len(self.buffer)
else:
res += self.buffer[self.pos : self.pos+size]
self.pos += size
return res
def write(self, data):
return None
class Memory:
def __init__(self, size):
self.memory = [0 for i in range(size)]
self.pages = {}
for page in range(0, size, 0x1000):
self.pages[page] = 0
def __getitem__(self, key):
return self.memory[key]
def __setitem__(self, key, val):
self.memory[key] = val
def get_perm(self, addr):
if (addr & 0b111111111000000000000) not in self.pages:
return 0
else:
return self.pages[addr & 0b111111111000000000000]
def set_perm(self, addr, perm):
self.pages[addr & 0b111111111000000000000] = perm & 0b1111
def allocate(self, new_perm, addr=None):
if addr:
if not (self.get_perm(addr) & PERM_MAPPED):
self.set_perm(addr, (PERM_MAPPED | new_perm) & 0b1111)
return addr
else:
return -1
for page, perm in self.pages.items():
if not (self.get_perm(page) & PERM_MAPPED):
self.set_perm(page, (PERM_MAPPED | new_perm) & 0b1111)
return page
return -1
def check_permission(self, addr, perm):
if self.get_perm(addr) & (PERM_MAPPED | perm):
return True
else:
return False
class EMU:
def __init__(self):
self.config = {'NX':False}
self.firmware = None
self.is_load = False
self.register = Register()
self.register.init_register()
self.pipeline = []
self.memory = Memory(2 ** 20)
self.checkperm = []
self.filesystem = FileSystem()
self.syscall_table = [self.sys_s0, self.sys_s1,
self.sys_s2, self.sys_s3,
self.sys_s4, self.sys_s5]
self.op_hander_table = [self.op_x0, self.op_x1,
self.op_x2, self.op_x3,
self.op_x4, self.op_x5, self.op_x6,
self.op_x7, self.op_x8,
self.op_x9, self.op_x10,
self.op_x11, self.op_x12,
self.op_x13, self.op_x14,
self.op_x15, self.op_x16,
self.op_x17, self.op_x18,
self.op_x19, self.op_x20,
self.op_x21, self.op_x22,
self.op_x23, self.op_x24,
self.op_x25, self.op_x26,
self.op_x27, self.op_x28,
self.op_x29, self.op_x30]
def set_timeout(self, timeout = 30):
def handler(signum, frame):
print 'timeout!'
exit(-1)
signal.signal(signal.SIGALRM, handler)
signal.alarm(timeout)
def set_mitigation(self, nx=False):
if nx:
self.config['NX'] = nx
def init_pipeline(self):
self.pipeline.append(Stdin())
self.pipeline.append(Stdout())
def load_firmware(self, firm_name):
try:
with open(firm_name, 'rb') as f:
data = f.read()
self.firmware = [ord(byte) for byte in data]
self.is_load = True
if self.config['NX']:
stack_perm = PERM_READ | PERM_WRITE
else:
stack_perm = PERM_READ | PERM_WRITE | PERM_EXEC
for i in range(0, len(data) / 0x1000 + 1):
self.memory.allocate(PERM_READ | PERM_WRITE | PERM_EXEC, addr=CODE_DEFAULT_BASE + i*0x1000)
self.write_memory(CODE_DEFAULT_BASE, self.firmware, len(self.firmware))
for i in range(0, len(data) / 0x1000 + 1):
self.memory.set_perm(CODE_DEFAULT_BASE + i*0x1000, PERM_MAPPED | PERM_READ | PERM_EXEC)
self.memory.allocate(stack_perm, addr=STACK_DEFAULT_BASE)
self.memory.allocate(stack_perm, addr=STACK_DEFAULT_BASE + 0x1000)
self.register.set_register('pc', CODE_DEFAULT_BASE)
self.register.set_register('sp', STACK_DEFAULT_BASE+0x1fe0)
except:
self.terminate("[VM] Firmware load error")
def bit_concat(self, bit_list):
res = 0
for bit in bit_list:
res <<= 7
res += bit & 0b1111111
return res
def execute(self):
try:
while 1:
cur_pc = self.register.get_register('pc')
op, op_type, opers, op_size = self.dispatch(cur_pc)
if not self.memory.check_permission(cur_pc, PERM_EXEC) or not self.memory.check_permission(cur_pc + op_size - 1, PERM_EXEC):
self.terminate("[VM] Can't exec memory")
self.register.set_register('pc', cur_pc + op_size)
op_handler = self.op_hander_table[op]
op_handler(op_type, opers)
except:
self.terminate("[VM] Unknown error")
def dispatch(self, addr):
opcode = self.bit_concat(self.read_memory(addr, 2))
op = (opcode & 0b11111000000000) >> 9
if op >= len(self.op_hander_table):
self.terminate("[VM] Invalid instruction")
op_type = (opcode & 0b00000100000000) >> 8
opers = []
if op_type == TYPE_R:
opers.append((opcode & 0b00000011110000) >> 4)
opers.append((opcode & 0b00000000001111))
op_size = 2
elif op_type == TYPE_I:
opers.append((opcode & 0b00000011110000) >> 4)
opers.append(self.read_memory_tri(addr+2, 1)[0])
op_size = 5
else:
self.terminate("[VM] Invalid instruction")
return op, op_type, opers, op_size
def read_memory(self, addr, length):
if not length:
return []
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + length - 1, PERM_READ):
res = self.memory[addr : addr + length]
return res
else:
self.terminate("[VM] Can't read memory")
def read_memory_str(self, addr):
res = []
length = 0
while 0 not in res:
res.append(self.memory[addr + length])
length += 1
res = res[:-1]
length -= 1
if not length:
return '', 0
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + length - 1, PERM_READ):
return ''.join(map(chr,res)), length
else:
self.terminate("[VM] Can't read memory")
def read_memory_tri(self, addr, count):
if not count:
return []
if self.memory.check_permission(addr, PERM_READ) and self.memory.check_permission(addr + count*3 - 1, PERM_READ):
res = []
for i in range(count):
tri = 0
tri |= self.memory[addr + i*3]
tri |= self.memory[addr + i*3 + 1] << 14
tri |= self.memory[addr + i*3 + 2] << 7
res.append(tri)
return res
else:
self.terminate("[VM] Can't read memory")
def write_memory(self, addr, data, length):
if not length:
return
if self.memory.check_permission(addr, PERM_WRITE) and self.memory.check_permission(addr + length - 1, PERM_WRITE):
for offset in range(length):
self.memory[addr + offset] = data[offset] & 0b1111111
else:
self.terminate("[VM] Can't write memory")
def write_memory_tri(self,addr,data_list, count):
if not count:
return
if self.memory.check_permission(addr, PERM_WRITE) and self.memory.check_permission(addr + count*3 - 1, PERM_WRITE):
for i in range(count):
self.memory[addr + i*3] = (data_list[i] & 0b000000000000001111111)
self.memory[addr + i*3 + 1] = (data_list[i] & 0b111111100000000000000) >> 14
self.memory[addr + i*3 + 2] = (data_list[i] & 0b000000011111110000000) >> 7
else:
self.terminate("[VM] Can't write memory")
def op_x0(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
data = self.read_memory_tri(src, 1)[0]
self.register.set_register(dst, data)
else:
self.terminate("[VM] Invalid instruction")
def op_x1(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
ch = self.read_memory(src, 1)[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ch)
else:
self.terminate("[VM] Invalid instruction")
def op_x2(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
dst = self.register.get_register(opers[1])
self.write_memory_tri(dst, [src], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x3(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
dst = self.register.get_register(opers[1])
self.write_memory(dst, [src & 0b1111111], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x4(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
self.register.set_register(dst, src)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
self.register.set_register(dst, src)
else:
self.terminate("[VM] Invalid instruction")
def op_x5(self, op_type, opers):
if op_type == TYPE_R:
src = opers[1]
dst = opers[0]
org_src = self.register.get_register(src)
org_dst = self.register.get_register(dst)
self.register.set_register(src, org_dst)
self.register.set_register(dst, org_src)
else:
self.terminate("[VM] Invalid instruction")
def op_x6(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[0])
sp = self.register.get_register('sp')
self.register.set_register('sp', sp-3)
self.write_memory_tri(sp-3, [src], 1)
elif op_type == TYPE_I:
src = opers[1]
sp = self.register.get_register('sp')
self.register.set_register('sp', sp-3)
self.write_memory_tri(sp-3, [src], 1)
else:
self.terminate("[VM] Invalid instruction")
def op_x7(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
sp = self.register.get_register('sp')
value = self.read_memory_tri(sp, 1)[0]
self.register.set_register(dst, value)
self.register.set_register('sp', sp+3)
else:
self.terminate("[VM] Invalid instruction")
def op_x9(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst + src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst + src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x10(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b1111111
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst + src) & 0b1111111))
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst + src) & 0b1111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x11(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst - src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst - src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x12(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b1111111
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst - src) & 0b1111111))
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & 0b111111111111110000000) | ((org_dst - src) & 0b1111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x13(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, org_dst >> value)
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, org_dst >> value)
else:
self.terminate("[VM] Invalid instruction")
def op_x14(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst << value) & 0b111111111111111111111)
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst << value) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x15(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
org_dst = self.register.get_register(dst)
self.register.set_register(dst, ((org_dst * value) & 0b111111111111111111111))
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, ((org_dst * value) & 0b111111111111111111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x16(self, op_type, opers):
if op_type == TYPE_R:
dst = opers[0]
value = self.register.get_register(opers[1])
if value == 0:
self.terminate("[VM] Divide by zero")
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (int(org_dst / value) & 0b111111111111111111111))
elif op_type == TYPE_I:
dst = opers[0]
value = opers[1]
if value == 0:
self.terminate("[VM] Divide by zero")
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (int(org_dst / value) & 0b111111111111111111111))
else:
self.terminate("[VM] Invalid instruction")
def op_x17(self, op_type, opers):
if op_type == TYPE_R:
src = opers[0]
value = self.register.get_register(src)
value += 1
self.register.set_register(src, value)
else:
self.terminate("[VM] Invalid instruction")
def op_x18(self, op_type, opers):
if op_type == TYPE_R:
src = opers[0]
value = self.register.get_register(src)
value -= 1
self.register.set_register(src, value)
else:
self.terminate("[VM] Invalid instruction")
def op_x19(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst & src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x20(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst | src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst | src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x21(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst ^ src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst ^ src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x22(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst % src) & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = opers[0]
org_dst = self.register.get_register(dst)
self.register.set_register(dst, (org_dst % src) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x23(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1])
dst = self.register.get_register(opers[0])
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1]
dst = self.register.get_register(opers[0])
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x24(self, op_type, opers):
if op_type == TYPE_R:
src = self.register.get_register(opers[1]) & 0b000000000000001111111
dst = self.register.get_register(opers[0]) & 0b000000000000001111111
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
elif op_type == TYPE_I:
src = opers[1] & 0b000000000000001111111
dst = self.register.get_register(opers[0]) & 0b000000000000001111111
tmp = dst - src
if tmp == 0:
eflags = FLAG_ZF
elif tmp < 0:
eflags = FLAG_NF
else:
eflags = 0b0000
self.register.set_register('eflags', eflags & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x25(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if not (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if not (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x26(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if (eflags & FLAG_NF) and not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x27(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x28(self, op_type, opers):
if op_type == TYPE_R:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
if not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
eflags = self.register.get_register('eflags')
base = self.register.get_register(opers[0])
offset = opers[1]
if not (eflags & FLAG_ZF):
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x29(self, op_type, opers):
if op_type == TYPE_R:
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
base = self.register.get_register(opers[0])
offset = opers[1]
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x30(self, op_type, opers):
if op_type == TYPE_R:
base = self.register.get_register(opers[0])
offset = self.register.get_register(opers[1])
ret_addr = self.register.get_register('pc')
self.op_x6(1, [0, ret_addr])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
elif op_type == TYPE_I:
base = self.register.get_register(opers[0])
offset = opers[1]
ret_addr = self.register.get_register('pc')
self.op_x6(1, [0, ret_addr])
self.register.set_register('pc', (base + offset) & 0b111111111111111111111)
else:
self.terminate("[VM] Invalid instruction")
def op_x8(self, op_type, opers):
syscall_num = self.register.get_register('r0')
if 0 <= syscall_num < len(self.syscall_table):
syscall = self.syscall_table[syscall_num]
syscall()
else:
self.terminate("[VM] Invalid syscall")
def sys_s0(self):
exit(0)
def sys_s1(self):
filename, filename_len = self.read_memory_str(self.register.get_register('r1'))
fd = self.filesystem.open(filename)
if fd != -1:
self.pipeline.append(fd)
self.register.set_register('r0', len(self.pipeline) - 1)
else:
self.register.set_register('r0', 0b111111111111111111111)
def sys_s2(self):
fd = self.register.get_register('r1')
buf = self.register.get_register('r2')
size = self.register.get_register('r3')
data = self.read_memory(buf, size)
if 0 <= fd < len(self.pipeline):
self.pipeline[fd].write(data)
self.register.set_register('r0', size)
else:
self.register.set_register('r0', 0)
def sys_s3(self):
fd = self.register.get_register('r1')
buf = self.register.get_register('r2')
size = self.register.get_register('r3')
if 0 <= fd < len(self.pipeline):
data = map(ord, self.pipeline[fd].read(size))
self.write_memory(buf, data, len(data))
self.register.set_register('r0', len(data) & 0b111111111111111111111)
else:
self.register.set_register('r0', 0)
def sys_s4(self):
res_ptr = self.register.get_register('r1')
perm = self.register.get_register('r2')
addr = self.memory.allocate(perm)
if addr != -1:
self.write_memory_tri(res_ptr, [addr], 1)
self.register.set_register('r0', 1)
else:
self.register.set_register('r0', 0)
def sys_s5(self):
self.register.set_register('r0', random.randrange(0, 2**21-1))
def terminate(self, msg):
print msg
exit(-1) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/pwn/CST/wrapper.py | ctfs/Codegate/2023/Quals/pwn/CST/wrapper.py | import subprocess
import tempfile
import base64
import os
code = input('Enter Your base64 > ')
try:
code = base64.b64decode(code)
except:
print('base64 error')
exit(1)
if b'#' in code:
print('error')
exit(1)
_, filename = tempfile.mkstemp(prefix='ctf-')
f = open(filename, 'wb')
f.write(code)
f.close()
p = subprocess.Popen(['./cst', filename], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
p.wait(timeout=3)
print('======= stdout =======')
print(p.stdout.read().decode())
print('======= stderr =======')
print(p.stderr.read().decode())
# os.unlink(filename)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/pwn/pcpu/precheck.py | ctfs/Codegate/2023/Quals/pwn/pcpu/precheck.py | from pwn import *
import sys
import os
f = open(sys.argv[1], 'rb')
size = int(f.readline())
ops = []
for i in range(size):
ops.append(p32(int(f.readline()) & 0xffffffff))
f.close()
regs = {
'0': {'size': 0, 'data': 0},
'1': {'size': 0, 'data': 0},
'2': {'size': 0, 'data': 0},
'3': {'size': 0, 'data': 0},
}
for op in ops:
inst = op[0]
print(inst)
if inst == 0:
idx = op[1]
data = u16(op[2:])
assert 0 <= idx <= 3
regs[str(idx)]['data'] = data
elif inst == 1:
dest = op[1]
pad = op[2]
src = op[3]
assert 0 <= src <= 3
assert pad == 0
assert 0 <= dest <= 3
regs[str(dest)]['data'] = regs[str(src)]['data']
elif inst == 2:
idx = op[1]
size = u16(op[2:])
assert 0 <= idx <= 3
regs[str(idx)]['size'] = size
regs[str(idx)]['data'] = [0 for i in range(size)]
elif inst == 3:
reg = op[1]
idx = op[2]
data = op[3]
assert 0 <= reg <= 3
assert isinstance(regs[str(reg)]['data'], list)
assert idx < regs[str(reg)]['size']
regs[str(reg)]['data'][idx] = data
elif inst == 4:
dest = op[1]
reg = op[2]
idx = op[3]
assert 0 <= dest <= 3
assert 0 <= reg <= 3
assert isinstance(regs[str(reg)]['data'], list)
assert idx < regs[str(reg)]['size']
regs[str(dest)]['data'] = regs[str(reg)]['data'][idx]
elif inst == 5:
reg = op[1]
pad = op[2]
data = op[3]
assert 0 <= reg <= 3
assert pad == 0
assert isinstance(regs[str(reg)]['data'], list)
assert isinstance(regs['0']['data'], int)
assert regs['0']['data'] < regs[str(reg)]['size']
regs[str(reg)]['data'][regs['0']['data']] = data
elif inst == 6:
dest = op[1]
pad = op[2]
reg = op[3]
assert 0 <= dest <= 3
assert 0 <= reg <= 3
assert pad == 0
assert isinstance(regs[str(reg)]['data'], list)
assert isinstance(regs['0']['data'], int)
assert regs['0']['data'] < regs[str(reg)]['size']
regs[str(dest)]['data'] = regs[str(reg)]['data'][regs['0']['data']]
elif inst == 7:
pass
else:
assert 0 <= inst <= 7 | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/secure_primeGenerator/client_example.py | ctfs/Codegate/2023/Quals/crypto/secure_primeGenerator/client_example.py | from Crypto.Util.number import *
from hashlib import sha256
from pwn import *
from itertools import product
import random
def get_additive_shares(x, n, mod):
shares = [0] * n
shares[n-1] = x
for i in range(n-1):
shares[i] = random.randrange(mod)
shares[n-1] = (shares[n-1] - shares[i]) % mod
assert sum(shares) % mod == x
return shares
BITS = 512
def POW():
print("[DEBUG] POW...")
b_postfix = r.recvline().decode().split(' = ')[1][6:].strip()
h = r.recvline().decode().split(' = ')[1].strip()
for brute in product('0123456789abcdef', repeat=6):
b_prefix = ''.join(brute)
b_ = b_prefix + b_postfix
if sha256(bytes.fromhex(b_)).hexdigest() == h:
r.sendlineafter(b' > ', b_prefix.encode())
return True
assert 0, "Something went wrong.."
def generate_shared_modulus():
print("[DEBUG] generate_shared_modulus...")
p2 = random.randrange(2 ** BITS, 2 ** (BITS+1))
q2 = random.randrange(2 ** BITS, 2 ** (BITS+1))
SMALL_PRIMES = [2, 3, 5, 7, 11, 13]
# Candidates of p1
for prime in SMALL_PRIMES:
remainder_candidates = []
# c = (-p2 % prime) should not be chosen
while len(remainder_candidates) < (prime+1) // 2:
c = random.randrange(prime)
if c == -p2 % prime or c in remainder_candidates:
continue
remainder_candidates.append(c)
r.sendlineafter(b' > ', ' '.join(str(c) for c in remainder_candidates).encode())
# Candidates of q1
for prime in SMALL_PRIMES:
remainder_candidates = []
# c = (-q2 % prime) should not be chosen
while len(remainder_candidates) < (prime+1) // 2:
c = random.randrange(prime)
if c == -q2 % prime or c in remainder_candidates:
continue
remainder_candidates.append(c)
r.sendlineafter(b' > ', ' '.join(str(c) for c in remainder_candidates).encode())
p1_enc = int(r.recvline().decode().split(' = ')[1])
q1_enc = int(r.recvline().decode().split(' = ')[1])
p2_enc = pow(p2, SERVER_E, SERVER_N)
q2_enc = pow(q2, SERVER_E, SERVER_N)
X = []
shares_a = get_additive_shares(1, 4, SERVER_N)
shares_b = get_additive_shares(1, 4, SERVER_N)
shares_c = get_additive_shares(1, 4, SERVER_N)
# N = p1*q1 + sum(pow(x, SERVER_D, SERVER_N) for x in X) = p1*q1 + p1*q2 + p2*q1 * p2*q2 = (p1+p2)*(q1+q2)
for i in range(4):
X.append(pow(shares_a[i], SERVER_E, SERVER_N) * p1_enc * q2_enc % SERVER_N)
X.append(pow(shares_b[i], SERVER_E, SERVER_N) * p2_enc * q1_enc % SERVER_N)
X.append(pow(shares_c[i], SERVER_E, SERVER_N) * p2_enc * q2_enc % SERVER_N)
random.shuffle(X)
r.sendlineafter(b' > ', ' '.join(str(x) for x in X).encode())
N = int(r.recvline().decode().split(' = ')[1])
return p2, q2, N
# STEP 2 - N_validity_check
def N_validity_check_client(p2, q2, N):
print("[DEBUG] N_validity_check_client...")
for _ in range(20):
b = int(r.recvline().decode().split(' = ')[1])
client_digest = sha256(long_to_bytes(pow(b, p2+q2, N))).hexdigest()
r.sendlineafter(b' > ', client_digest.encode())
msg = r.recvline().decode()
if msg != "good!\n":
print(msg)
return -1
flag_enc = int(r.recvline().decode().split(' = ')[1])
return flag_enc
r = process(["python3", "./prob.py"])
POW()
SERVER_N = int(r.recvline().decode().split(' = ')[1])
SERVER_E = int(r.recvline().decode().split(' = ')[1])
p2, q2, N = generate_shared_modulus()
flag_enc = N_validity_check_client(p2, q2, N)
if flag_enc == -1:
exit(-1)
print(f"{N = }")
print(f"{flag_enc = }")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/secure_primeGenerator/prob.py | ctfs/Codegate/2023/Quals/crypto/secure_primeGenerator/prob.py | from Crypto.Util.number import *
from hashlib import sha256
import os
import signal
BITS = 512
def POW():
b = os.urandom(32)
print(f"b = ??????{b.hex()[6:]}")
print(f"SHA256(b) = {sha256(b).hexdigest()}")
prefix = input("prefix > ")
b_ = bytes.fromhex(prefix + b.hex()[6:])
return sha256(b_).digest() == sha256(b).digest()
def generate_server_key():
while True:
p = getPrime(1024)
q = getPrime(1024)
e = 0x10001
if (p-1) % e == 0 or (q-1) % e == 0:
continue
d = pow(e, -1, (p-1)*(q-1))
n = p*q
return e, d, n
# Generate N = (p1+p2) * (q1+q2) where p2 and q2 are shares chosen by the client
def generate_shared_modulus():
SMALL_PRIMES = [2, 3, 5, 7, 11, 13]
print(f"{SERVER_N = }")
print(f"{SERVER_E = }")
p1_remainder_candidates = {}
q1_remainder_candidates = {}
# We prevent p1+p2 is divided by small primes
# by asking the client for a possible remainders of p1
for prime in SMALL_PRIMES:
remainder_candidates = set(map(int, input(f"Candidates of p1 % {prime} > ").split()))
assert len(remainder_candidates) == (prime+1) // 2, f"[-] wrong candidates for {prime}"
p1_remainder_candidates[prime] = remainder_candidates
while True:
p1 = bytes_to_long(os.urandom(BITS // 8))
for prime in SMALL_PRIMES:
if p1 % prime not in p1_remainder_candidates[prime]:
break
else:
break
# and same goes for q1
for prime in SMALL_PRIMES:
remainder_candidates = set(map(int, input(f"Candidates of q1 % {prime} > ").split()))
assert len(remainder_candidates) == (prime+1) // 2, f"[-] wrong candidates for {prime}"
q1_remainder_candidates[prime] = remainder_candidates
while True:
q1 = bytes_to_long(os.urandom(BITS // 8))
for prime in SMALL_PRIMES:
if q1 % prime not in q1_remainder_candidates[prime]:
break
else:
break
p1_enc = pow(p1, SERVER_E, SERVER_N)
q1_enc = pow(q1, SERVER_E, SERVER_N)
print(f"{p1_enc = }")
print(f"{q1_enc = }")
X = list(map(int, input("X > ").split()))
assert len(X) == 12
N = (p1*q1 + sum(pow(x, SERVER_D, SERVER_N) for x in X)) % SERVER_N
assert N.bit_length() >= 1024, f"[-] too short.., {N.bit_length()}"
print(f"{N = }")
return p1, q1, N
# check whether N is a product of two primes
def N_validity_check(p1, q1, N):
for _ in range(20):
b = bytes_to_long(os.urandom(2 * BITS // 8))
print(f"{b = }")
client_digest = input("Client digest > ")
server_digest = sha256(long_to_bytes(pow(b, N+1-p1-q1, N))).hexdigest()
if server_digest != client_digest:
print("N is not a product of two primes I guess..")
return False
else:
print("good!")
return True
if not POW():
exit(-1)
signal.alarm(60)
SERVER_E, SERVER_D, SERVER_N = generate_server_key()
p1, q1, N = generate_shared_modulus()
if not N_validity_check(p1, q1, N):
exit(-1)
FLAG = open("flag", 'rb').read()
FLAG += b'\x00' + os.urandom(128 - 2 - len(FLAG))
FLAG_ENC = pow(bytes_to_long(FLAG), 0x10001, N)
print(f"{FLAG_ENC = }")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/remote.py | ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/remote.py | #!/usr/bin/env python3
from file_crypto import FileCipher, random_index, index_from_bytes
from file_crypto import LOCAL_NONCE
import base64
if __name__ == "__main__":
# Read data
mode = input("mode? ").strip()
nonce = base64.b64decode(input("nonce? ").strip())
index_bytes = base64.b64decode(input("index? ").strip())
data = base64.b64decode(input("data? ").strip())
if len(data) > 0x4000:
print("Sorry, the length of the given data is too long :(")
exit(1)
if nonce == LOCAL_NONCE:
print("Sorry, this nonce is only allowed in the local mode :(")
exit(1)
# Do crypto
cipher = FileCipher()
index = index_from_bytes(index_bytes)
if mode == "enc":
result = cipher.encrypt(nonce, index, data)
elif mode == "dec":
result = cipher.decrypt(nonce, index, data)
else:
print("Wrong mode! :(")
exit(1)
print(base64.b64encode(result).decode())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/local.py | ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/local.py | #!/usr/bin/env python3
from file_crypto import FileCipher, random_index, index_to_bytes, index_from_bytes
from file_crypto import LOCAL_NONCE, BLOCK_SIZE, INDEX_SIZE
import sys
if __name__ == "__main__":
assert len(sys.argv) == 3
cipher = FileCipher()
with open(sys.argv[2], "rb") as f:
data = f.read()
if sys.argv[1] == "enc":
index = random_index()
ciphertext = cipher.encrypt(LOCAL_NONCE, index, data)
index_bytes = index_to_bytes(index)
with open(sys.argv[2] + ".enc", "wb") as f:
f.write(LOCAL_NONCE)
f.write(index_bytes)
f.write(ciphertext)
elif sys.argv[1] == "dec":
nonce = data[:BLOCK_SIZE]
index_bytes = data[BLOCK_SIZE : BLOCK_SIZE + INDEX_SIZE]
ciphertext = data[BLOCK_SIZE + INDEX_SIZE :]
index = index_from_bytes(index_bytes)
plaintext = cipher.decrypt(nonce, index, ciphertext)
with open(sys.argv[2] + ".dec", "wb") as f:
f.write(plaintext)
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/file_crypto.py | ctfs/Codegate/2023/Quals/crypto/My_File_Encryptor/file_crypto.py | #!/usr/bin/env python3
from __future__ import annotations
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import random
import struct
BLOCK_SIZE = 16
INDEX_SIZE = 20
KEY_SIZE = 16
LOCAL_NONCE = bytes(range(BLOCK_SIZE))
def random_index() -> list[int]:
return [random.randint(0, 64) for _ in range(INDEX_SIZE)]
def index_to_bytes(index: list[int]) -> bytes:
assert len(index) == INDEX_SIZE
return struct.pack(f"<{INDEX_SIZE}b", *index)
def index_from_bytes(index_bytes: bytes) -> list[int]:
assert len(index_bytes) == INDEX_SIZE
return list(struct.unpack(f"<{INDEX_SIZE}b", index_bytes))
class GF:
MOD = 0x19F2BBF3EF3A2AB6684710EB139F3A9AD
def __init__(self, v: int):
assert 0 <= v < 2**128
self.v = v
@classmethod
def _double(cls, v):
if v >> 127:
new_v = (v << 1) ^ cls.MOD
else:
new_v = v << 1
return new_v
def __add__(self, other):
return GF(self.v ^ other.v)
def __iadd__(self, other):
self.v ^= other.v
return self
def __mul__(self, other):
res, cur = 0, self.v
for i in range(128):
if (other.v >> i) & 1:
res ^= cur
cur = self._double(cur)
return GF(res)
def __imul__(self, other):
res = self * other
self.v = res.v
return self
def __pow__(self, y):
y %= 2**128 - 1
res, cur = GF(1), GF(self.v)
while y:
if y & 1:
res *= cur
cur *= cur
y >>= 1
return res
@classmethod
def from_bytes(cls, b: bytes):
assert len(b) <= BLOCK_SIZE
return cls(int.from_bytes(b, "little"))
def to_bytes(self) -> bytes:
return self.v.to_bytes(BLOCK_SIZE, "little")
class FileCipher:
def __init__(self):
with open("key", "rb") as f:
key = f.read(KEY_SIZE)
assert len(key) == KEY_SIZE
self.cipher = AES.new(key, AES.MODE_ECB)
with open("vectors", "rb") as f:
self.vectors = []
for _ in range(INDEX_SIZE):
vec = f.read(BLOCK_SIZE)
assert len(vec) == BLOCK_SIZE
self.vectors.append(GF.from_bytes(vec))
def encrypt(self, nonce: bytes, index: list[int], plaintext: bytes) -> bytes:
data = pad(plaintext, BLOCK_SIZE)
assert len(data) % BLOCK_SIZE == 0
assert len(nonce) == BLOCK_SIZE
assert len(index) == INDEX_SIZE
return self._do_crypto(nonce, index, data, is_decrypt=False)
def decrypt(self, nonce: bytes, index: list[int], ciphertext: bytes) -> bytes:
assert len(ciphertext) % BLOCK_SIZE == 0
assert len(nonce) == BLOCK_SIZE
assert len(index) == INDEX_SIZE
return self._do_crypto(nonce, index, ciphertext, is_decrypt=True)
def _initialize_alpha(self, nonce: bytes, index: list[int]) -> GF:
encrypted_nonce = self.cipher.encrypt(nonce)
alpha = GF.from_bytes(encrypted_nonce)
for vector, exponent in zip(self.vectors, index):
alpha *= vector**exponent
return alpha
def _update_alpha(self, index: list[int], alpha: GF, block_num: int) -> GF:
block_num %= INDEX_SIZE
index[block_num] += 1
return alpha * self.vectors[block_num]
def _gf_encrypt(self, v: GF) -> GF:
enc = self.cipher.encrypt(v.to_bytes())
return GF.from_bytes(enc)
def _gf_decrypt(self, v: GF) -> GF:
dec = self.cipher.decrypt(v.to_bytes())
return GF.from_bytes(dec)
def _do_crypto(
self, nonce: bytes, index: list[int], data: bytes, is_decrypt: bool = False
) -> bytes:
index = index[:] # Copy index
# 1. Initialize alpha
alpha = self._initialize_alpha(nonce, index)
result = b""
for offset in range(0, len(data), BLOCK_SIZE):
if index == [0] * INDEX_SIZE:
print("Index cannot be NULL")
return b""
block = data[offset : offset + BLOCK_SIZE]
b = GF.from_bytes(block)
# 2. Do enc/dec
b += alpha
if is_decrypt:
b = self._gf_decrypt(b)
else:
b = self._gf_encrypt(b)
b += alpha
result += b.to_bytes()
# 3. Update alpha
alpha = self._update_alpha(index, alpha, offset // BLOCK_SIZE)
return result
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/crypto/anti_Kerckhoffs/prob.py | ctfs/Codegate/2023/Quals/crypto/anti_Kerckhoffs/prob.py | import math
import os
import hashlib
import signal
import secrets
QUERY_LIMIT = 77777
MOD = 17
m = 20
def quadratic_eval(coeffs, x):
return (coeffs[2] * x ** 2 + coeffs[1] * x + coeffs[0]) % MOD
def get_random_quadratic():
c2 = secrets.randbelow(MOD - 1) + 1
c1 = secrets.randbelow(MOD)
c0 = secrets.randbelow(MOD)
return [c0, c1, c2]
def calc(Inputs):
Outputs = [quadratic_eval(SboxLayer1[i], Inputs[i]) for i in range(m)]
Outputs = [sum(LinearLayer[i][j] * Outputs[j] for j in range(m)) for i in range(m)]
Outputs = [quadratic_eval(SboxLayer2[i], Outputs[i]) for i in range(m)]
return Outputs
def print_list(L, prefix = ''):
print(prefix, end='')
for x in L:
print(x, end = ' ')
print()
def compare(L1, L2):
ret = 0
for i in range(m):
if L1[i] == L2[i]:
ret += 2 ** i
return ret
def list_to_int(L):
assert len(L) == m, "Invalid list format"
assert all(0 <= x < MOD for x in L), "Invalid list format"
ret = 0
for i in range(m):
ret += L[i] * MOD ** i
return ret
def int_to_list(x):
assert 0 <= x < MOD ** m, "Invalid int format"
L = [0] * m
for i in range(m):
L[i] = x % MOD
x //= MOD
return L
SboxLayer1 = [get_random_quadratic() for _ in range(m)]
LinearLayer = [[secrets.randbelow(MOD-1) + 1 for _ in range(m)] for _ in range(m)]
SboxLayer2 = [get_random_quadratic() for _ in range(m)]
HIDDEN = [secrets.randbelow(MOD) for _ in range(m)]
TARGET = calc(HIDDEN)
print(f"TARGET = {list_to_int(TARGET)}")
query_count = 0
win = False
while not win:
Inputs = list(map(int, input("Inputs > ").split()))
query_count += len(Inputs)
if query_count > QUERY_LIMIT:
print("bye..")
exit(-1)
Outputs = []
for I in Inputs:
O = calc(int_to_list(I))
if TARGET == O:
win = True
Outputs.append(compare(TARGET, O))
print_list(Outputs, "Outputs = ")
print("Good job!", open("flag", 'r').read())
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/web/CODEGATE_Music_Player/worker/app/worker.py | ctfs/Codegate/2023/Quals/web/CODEGATE_Music_Player/worker/app/worker.py | #!/usr/bin/python3 -u
#-*- coding: utf-8 -*-
# Developer: stypr (https://harold.kim/)
# Target is at http://nginx/
import os
import asyncio
import time
import redis
import requests
from pyppeteer import launch
redis = redis.Redis('redis')
redis.select(1)
browser = None
browser_option = {
'executablePath': '/usr/bin/google-chrome-stable',
'options': {'args': [
'--no-sandbox',
'--disable-default-apps',
'--disable-extensions',
'--disable-gpu',
'--disable-sync',
'--disable-translate',
'--hide-scrollbars',
'--metrics-recording-only',
"--js-flags='--jitless'",
'--mute-audio',
'--no-first-run',
'--safebrowsing-disable-auto-update',
'--disable-dev-shm-usage',
'--user-agent=Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
]},
'handleSIGINT': False,
'handleSIGTERM': False,
'handleSIGHUP': False,
'headless': True
}
async def init_browser():
global browser
_browser = await launch(**browser_option)
page = await _browser.newPage()
try:
await page.goto("http://nginx/")
cookie = {
"name": "SECRET",
"value": os.environ['SECRET'],
"domain": "nginx",
"path": "/",
"httpOnly": True,
"secure": False
}
await page.setCookie(cookie)
except Exception as e:
print("[!] Error during browser initialization: " + str(e))
finally:
await page.close()
print("[.] Browser is now loaded.")
return _browser
async def render(url):
timeout = 3
try:
print("[.] Begin crawling...")
page = await browser.newPage()
await page.goto(url, {
'timeout': timeout * 1000,
'waitUntil' : 'networkidle0'
})
await page.close()
print("[.] Rendering complete..")
except Exception as e:
print(f"[!!] {e}")
finally:
await page.close()
async def main(loop):
global browser
while True:
try:
print("[+] Handler has begun..")
data = redis.blpop("query")[1].decode()
if data:
print(f"[*] Got a new request: {data}")
if not browser:
browser = await init_browser()
_task = await asyncio.wait_for(render(data), timeout=5)
except Exception as e:
print(f"[!] {e}")
finally:
await asyncio.sleep(0.01)
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.run_until_complete(main(loop))
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/web/Calculator/verify_pow.py | ctfs/Codegate/2023/Quals/web/Calculator/verify_pow.py | #!/usr/bin/env python3
import secrets
import hashlib
from time import time
import sys
class NcPowser:
def __init__(self, difficulty=22, prefix_length=16):
self.difficulty = difficulty
self.prefix_length = prefix_length
def get_challenge(self):
return secrets.token_urlsafe(self.prefix_length)[:self.prefix_length].replace('-', 'b').replace('_', 'a')
def verify_hash(self, prefix, answer):
h = hashlib.sha256()
h.update((prefix + answer).encode())
bits = ''.join(bin(i)[2:].zfill(8) for i in h.digest())
return bits.startswith('0' * self.difficulty)
if __name__ == '__main__':
powser = NcPowser()
if powser.verify_hash(sys.argv[1],sys.argv[2]):
print("success")
else:
print("fail") | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2023/Quals/web/Calculator/gen_pow.py | ctfs/Codegate/2023/Quals/web/Calculator/gen_pow.py | #!/usr/bin/env python3
import secrets
import hashlib
from time import time
class NcPowser:
def __init__(self, difficulty=28, prefix_length=22):
self.difficulty = difficulty
self.prefix_length = prefix_length
def get_challenge(self):
return secrets.token_urlsafe(self.prefix_length)[:self.prefix_length].replace('-', 'b').replace('_', 'a')
def verify_hash(self, prefix, answer):
h = hashlib.sha256()
h.update((prefix + answer).encode())
bits = ''.join(bin(i)[2:].zfill(8) for i in h.digest())
return bits.startswith('0' * self.difficulty)
if __name__ == '__main__':
powser = NcPowser()
prefix = powser.get_challenge()
print(prefix) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/Happy_S-box/chal.py | ctfs/Codegate/2022/Quals/crypto/Happy_S-box/chal.py | #!/usr/bin/python3
import os
import random
class LFSR:
rand = random.Random("Codegate2022")
Sbox = [ [0] * 64 + [1] * 64 for _ in range(512 - 6) ]
for i in range(len(Sbox)):
rand.shuffle(Sbox[i])
def __init__(self, seed):
self.state = seed
for _ in range(1024):
self.next()
def next(self):
v = self.state
# x^512 + x^8 + x^5 + x^2 + 1
n = ((v >> 0) ^ (v >> 504) ^ (v >> 507) ^ (v >> 509)) & 1
self.state = (v >> 1) | (n << 511)
def output(self):
out = 0
for i in range(512 - 6):
out ^= self.Sbox[i][(self.state >> i) & 127]
return out
guess_this = os.urandom((512 - 8) // 8)
guess_this = guess_this[:-1] + bytes([guess_this[-1] & 0xf0])
seed = int.from_bytes(guess_this, 'big') << 8
print("Seed generated. It'll take some time to generate a hint.")
v = 0
for i in range(2 ** 12):
lfsr = LFSR(seed | i)
v <<= 1
v |= lfsr.output()
print("Here's the hint. It should be enough.")
print(v.to_bytes(2 ** 12 // 8, 'big').hex())
ans = input("Guess the seed > ")
if guess_this == bytes.fromhex(ans):
with open('flag', 'r') as f:
print(f.read())
else:
print("WRONG")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/DarkArts/chal.py | ctfs/Codegate/2022/Quals/crypto/DarkArts/chal.py | import os
import hashlib
import signal
signal.alarm(300)
def inner_product(u, v):
assert len(u) == len(v)
res = 0
for a, b in zip(u, v):
res += a * b
return res
def guess_mode(G):
while True:
idx = int(input())
if idx == 0:
x = int(input())
print(G.calc(x))
elif idx == 1:
mode = int(input())
if mode != G.mode:
exit()
else:
break
else:
exit()
def guess_key(G, l):
while True:
idx = int(input())
if idx == 0:
x = int(input())
print(G.func_gen(x))
elif idx == 1:
for i in range(l):
x = int(input())
if x != G.key[i]:
exit()
break
else:
exit()
class Generator1:
def __init__(self):
seed = int.from_bytes(os.urandom(32), "big")
self.key = [0] * 256
for i in range(256):
self.key[i] = (seed >> i) & 1
self.mode = os.urandom(1)[0] & 1
self.p = 2
self.q = 3
self.cache0 = {}
self.cache1 = {}
def func_gen(self, x):
assert 0 <= x < (1 << 256)
if x in self.cache0.keys():
return self.cache0[x]
arr = [0] * 256
for i in range(256):
arr[i] = (x >> i) & 1
prod = inner_product(self.key, arr)
self.cache0[x] = (prod % self.p + prod % self.q) % self.p
return self.cache0[x]
def func_random(self, x):
assert 0 <= x < (1 << 256)
if x in self.cache1.keys():
return self.cache1[x]
self.cache1[x] = os.urandom(1)[0] & 1
return self.cache1[x]
def calc(self, x):
ret0 = self.func_gen(x)
ret1 = self.func_random(x)
if self.mode == 0:
return ret0
else:
return ret1
def challenge_generator_1():
print("Challenge 1")
for _ in range(64):
G = Generator1()
guess_mode(G)
class Generator2:
def __init__(self):
seed = int.from_bytes(os.urandom(32), "big")
self.key = [0] * 256
for i in range(256):
self.key[i] = (seed >> i) & 1
self.mode = os.urandom(1)[0] & 1
self.p = 5
self.q = 7
self.cache0 = {}
self.cache1 = {}
def func_gen(self, x):
x = int.from_bytes(hashlib.sha256(str(x).encode()).digest(), "big")
if x in self.cache0.keys():
return self.cache0[x]
hashed = [0] * 256
for i in range(256):
hashed[i] = (x >> i) & 1
prod = inner_product(self.key, hashed)
self.cache0[x] = (prod % self.p + prod % self.q) % self.p
return self.cache0[x]
def func_random(self, x):
x = int.from_bytes(hashlib.sha256(str(x).encode()).digest(), "big")
if x in self.cache1.keys():
return self.cache1[x]
self.cache1[x] = int.from_bytes(os.urandom(32), "big") % self.p
return self.cache1[x]
def calc(self, x):
ret0 = self.func_gen(x)
ret1 = self.func_random(x)
if self.mode == 0:
return ret0
else:
return ret1
def challenge_generator_2():
print("Challenge 2")
for _ in range(64):
G = Generator2()
guess_mode(G)
class Generator3:
def __init__(self):
seed = int.from_bytes(os.urandom(16), "big")
self.key = [0] * 64
for i in range(64):
self.key[i] = seed & 3
seed = seed >> 2
self.p = 2
self.q = 5
def func_gen(self, x):
x = int.from_bytes(hashlib.sha256(str(x).encode()).digest(), "big")
hashed = [0] * 64
for i in range(64):
hashed[i] = x % self.q
x = x // self.q
prod = inner_product(self.key, hashed)
return (prod % self.q) % self.p
def challenge_generator_3():
print("Challenge 3")
G = Generator3()
guess_key(G, 64)
class Generator4:
def __init__(self):
self.key = [0] * 16
for i in range(16):
self.key[i] = int.from_bytes(os.urandom(32), "big")
self.p = int.from_bytes(os.urandom(32), "big") + (1 << 256)
self.q = int.from_bytes(os.urandom(16), "big") + (1 << 128)
print(self.p)
print(self.q)
def func_gen(self, x):
x = hashlib.sha256(str(x).encode()).digest()
hashed = []
for _ in range(16):
hashed.append(int.from_bytes(x, "big"))
x = hashlib.sha256(x).digest()
prod = inner_product(self.key, hashed)
return (prod % self.p + prod % self.q) % self.p
def challenge_generator_4():
print("Challenge 4")
G = Generator4()
guess_key(G, 16)
challenge_generator_1()
challenge_generator_2()
challenge_generator_3()
challenge_generator_4()
flag = open("flag", "r").read()
print(flag) | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/PrimeGenerator/prime_generator.py | ctfs/Codegate/2022/Quals/crypto/PrimeGenerator/prime_generator.py | #!/usr/bin/python3
from Crypto.Util.number import *
import os
BITS = 512
UPPER_BITS = 296
LOWER_BITS = BITS - UPPER_BITS
UPPER = bytes_to_long(os.urandom(UPPER_BITS // 8)) << LOWER_BITS
FLAG = b'codegate2022{this_is_a_sample_flag}'
def menu1():
while True:
lower = bytes_to_long(os.urandom(LOWER_BITS // 8))
p = UPPER | lower
if isPrime(p): return lower
def menu2():
p = UPPER + menu1()
q = getPrime(512)
e = 0x10001
n = p * q
return n, pow(bytes_to_long(FLAG + b'\x00' + os.urandom(128 - 2 - len(FLAG))), e, n)
while True:
print("1. Generate 10 random primes (only lower bits)")
print("2. Encrypt a flag")
idx = int(input("> "))
if idx == 1:
print("How many? (Up to 10)")
num = int(input("> "))
for _ in range(min(10, num)):
print(menu1())
elif idx == 2:
n, c = menu2()
print(f"n : {n}")
print(f"c : {c}")
UPPER = bytes_to_long(os.urandom(UPPER_BITS // 8)) << LOWER_BITS
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/manage.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/manage.py | #!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys
def main():
"""Run administrative tasks."""
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'nft_web.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/asgi.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/asgi.py | """
ASGI config for nft_web project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/asgi/
"""
import os
from django.core.asgi import get_asgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'nft_web.settings')
application = get_asgi_application()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/settings.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/settings.py | """
Django settings for nft_web project.
Generated by 'django-admin startproject' using Django 3.2.1.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/3.2/ref/settings/
"""
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '****SENSORED****'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = False
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'account.apps.AccountConfig',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'nft_web.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'nft_web.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/
STATIC_URL = '/static/'
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/__init__.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/wsgi.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/wsgi.py | """
WSGI config for nft_web project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/wsgi/
"""
import os
from django.core.wsgi import get_wsgi_application
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'nft_web.settings')
application = get_wsgi_application()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/urls.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/nft_web/urls.py | """nft_web URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/3.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import include, path
urlpatterns = [
path('', include('account.urls')),
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/views.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/views.py | from django.shortcuts import render
from django.http import HttpResponse, HttpResponseRedirect, Http404
from django.template import loader
from django.core.validators import URLValidator, validate_ipv4_address
from .models import User
from .apps import AccountConfig
from .eth import Account, Contract, web3
import ipaddress
import pyseto
import base64
import string
import requests
import json
import hashlib
import os
nft_path = os.path.join('account', 'storages')
def pyseto_decode(token, token_key):
token_obj = pyseto.Key.new(
version=4, purpose="local", key=token_key
)
return pyseto.decode(token_obj, token).payload.decode('utf-8')
def get_contract():
with open('./PrivateNFT.json', 'rb') as f:
build_json = json.load(f)
contract = Contract(build_json)
return contract.at(AccountConfig.nft_addr)
def get_response(uri):
if uri.startswith('http://') or uri.startswith('https://'):
validator = URLValidator()
result = requests.get(uri, timeout=3)
try:
validator(uri)
result = requests.get(uri, timeout=3)
except:
return
return result.text
elif any([uri.startswith(str(i)) for i in range(1, 10)]) and uri.find('/') != -1:
ip = uri.split('/')[0]
if uri.find('..') != -1 or not uri.startswith(os.path.join(ip, nft_path + '/')):
return
try:
validate_ipv4_address(ip)
except:
return
ipv4 = ipaddress.IPv4Address(ip)
if str(ipv4) not in ['127.0.0.1', '0.0.0.0']:
return
nft_file = uri.split(nft_path + '/')[-1]
if nft_file.find('.') != -1 and nft_file.split('.')[-1]:
path = os.path.join(os.getcwd(), nft_path, nft_file)
with open(path, 'rb') as f:
return f.read()
return
def index(request):
if not request.session.get('user_id', ''):
return HttpResponse("login first %s" % AccountConfig.name)
user_id = request.session.get('user_id', '')
token = request.session.get('token', '')
token_key = request.session.get('token_key', '')
private_key = pyseto_decode(token, token_key)
account = Account(private_key=private_key)
return HttpResponse("Hello, %s\nprivate key: %s\ncontract address: %s" % (user_id, private_key, account.address))
def login(request):
user_id = request.GET.get('user_id', '')
user_pw = request.GET.get('user_pw', '')
if not user_id or not user_pw:
return HttpResponse("empty parameter")
try:
user_obj = User.objects.get(user_id=user_id)
if user_obj.user_pw != user_pw:
return HttpResponse("user id or user pw is incorrect");
except:
return HttpResponse("user id or user pw is incorrect");
request.session['user_id'] = user_obj.user_id
request.session['token'] = user_obj.token
request.session['token_key'] = user_obj.token_key
return HttpResponseRedirect("/")
def regist(request):
user_id = request.GET.get('user_id', '')
user_pw = request.GET.get('user_pw', '')
if not user_id or not user_pw:
return HttpResponse("empty parameter")
if any([user_id.count(data) for data in list(string.punctuation + ' ')]):
return HttpResponse("invalid user id");
if User.objects.filter(user_id=user_id).exists():
return HttpResponse("exist user id");
account = Account()
assert account.private_key
with open('/dev/urandom', 'rb') as f:
token_key = base64.b64encode(f.read(128)).decode('utf-8')[:64]
token_obj = pyseto.Key.new(
version=4, purpose="local", key=token_key
)
token = pyseto.encode(token_obj, payload=account.private_key).decode('utf-8')
u = User(user_id=user_id, user_pw=user_pw, token=token, token_key=token_key)
u.save()
return HttpResponse("registered successfully")
def nfts(request, user_id):
if not User.objects.filter(user_id=user_id).exists():
return HttpResponse("no exist");
if request.session.get('user_id', '') != user_id:
return HttpResponse("no authorzation");
user = User.objects.get(user_id=user_id)
token = request.session.get('token', '')
token_key = request.session.get('token_key', '')
private_key = pyseto_decode(token, token_key)
account = Account(private_key=private_key)
contract = get_contract()
ids = contract.getIDs().call({'from':account.address})
result = ""
cache_path = os.path.join(os.getcwd(), nft_path,
user_id + hashlib.sha1(bytes(private_key.encode('utf-8'))).hexdigest()
)
if not user.is_cached:
for tid in ids:
uri = contract.getTokenURI(tid).call({'from':account.address})
if not uri:
continue
resp = get_response(uri)
if not resp:
continue
try:
json_res = json.loads(resp)
for key in list(json_res.keys()):
if key in ['name', 'description']:
result += f'<br/>{key}: {json_res[key]}'
elif key == 'image':
result += f'<br/>{key}: <img src=\"{json_res[key]}\"/>'
result += "<br/>"
except:
result += f"<br/>malformed {uri}: {resp}"
if len(ids) == 3:
with open(cache_path, 'wb') as f:
f.write(result.encode('utf-8'))
user.is_cached = True
user.save()
else:
with open(cache_path, 'rb') as f:
result = f.read().decode('utf-8')
return HttpResponse("= NFT list =" + result)
def logout(request):
session_keys = list(request.session.keys())[::]
for key in session_keys:
del request.session[key]
return HttpResponseRedirect("/")
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/eth.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/eth.py |
from typing import Any, Dict, List, Optional, Union
import rlp
from brownie.exceptions import VirtualMachineError
from eth_typing import ChecksumAddress
from eth_utils import keccak, to_checksum_address
from hexbytes import HexBytes
from web3 import Web3
from web3.contract import ContractFunctions
class Account:
def __init__(self, private_key: Union[int, bytes, str] = None) -> None:
if private_key is None:
w3account = web3.eth.account.create()
else:
w3account = web3.eth.account.from_key(private_key)
self._account = w3account
self.address = self._account.address
self.private_key = HexBytes(self._account.key).hex()
def balance(self) -> int:
balance = web3.eth.get_balance(self.address)
return balance
@property
def nonce(self) -> int:
return web3.eth.get_transaction_count(self.address)
def get_deployment_address(self, nonce: Optional[int] = None) -> ChecksumAddress:
if nonce is None:
nonce = self.nonce
address = HexBytes(self.address)
raw = rlp.encode([address, nonce])
deployment_address = HexBytes(keccak(raw)[12:]).hex()
return to_checksum_address(deployment_address)
def transact(self, tx: Dict) -> str:
tx["chainId"] = web3.eth.chain_id
tx["from"] = self.address
try:
signed_tx = self._account.sign_transaction(tx).rawTransaction # type: ignore
txid = web3.eth.send_raw_transaction(signed_tx)
except ValueError as e:
exc = VirtualMachineError(e)
if not hasattr(exc, "txid"):
raise exc from None
else:
return txid.hex()
class Contract:
def __init__(self, build: Dict) -> None:
self._build = build.copy()
self.bytecode = build["bytecode"]
self.deploy = ContractConstructor(self)
@property
def abi(self) -> List:
return self._build["abi"]
def at(self, address: ChecksumAddress) -> ContractFunctions:
return web3.eth.contract(address=address, abi=self.abi).functions
class ContractConstructor:
def __init__(self, parent: "Contract") -> None:
self._instance = web3.eth.contract(abi=parent.abi, bytecode=parent.bytecode)
def __call__(
self,
sender: Account,
value: int = 0,
args: Optional[Any] = None,
gas_limit: Optional[int] = None,
gas_price: Optional[int] = None,
nonce: Optional[int] = None,
) -> str:
tx: Dict = self._instance.constructor(*args).buildTransaction()
return sender.transact(
{
"value": value,
"nonce": nonce if nonce is not None else sender.nonce,
"gas": gas_limit or tx["gas"],
"gasPrice": gas_price or tx["gasPrice"],
"data": tx["data"],
},
)
def estimate_gas(self, args: Optional[Any] = None) -> int:
return self._instance.constructor(*args).estimateGas()
web3 = Web3()
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/models.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/models.py | from django.db import models
# Create your models here.
class User(models.Model):
user_id = models.CharField(max_length=128)
user_pw = models.CharField(max_length=128)
token = models.CharField(max_length=512)
token_key = models.CharField(max_length=512)
is_cached = models.BooleanField(default=False)
def __str__(self):
return self.user_id
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/__init__.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/__init__.py | python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false | |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/tests.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/tests.py | from django.test import TestCase
# Create your tests here.
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/apps.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/apps.py | from django.apps import AppConfig
from .eth import Account, Contract, web3
import os
class AccountConfig(AppConfig):
default_auto_field = 'django.db.models.BigAutoField'
name = 'account'
nft_addr = open(os.path.join(os.getcwd(), 'contract_addr.txt'), 'rb').read().strip().decode('utf-8')
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
sajjadium/ctf-archives | https://github.com/sajjadium/ctf-archives/blob/129a3a9fe604443211fa4d493a49630c30689df7/ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/urls.py | ctfs/Codegate/2022/Quals/crypto/nft/nft_web/account/urls.py | from django.urls import path
from . import views
urlpatterns = [
path('', views.index, name='index'),
path('login', views.login, name='login'),
path('regist', views.regist, name='regist'),
path('logout', views.logout, name='logout'),
path('<str:user_id>/nfts/', views.nfts, name='nfts'),
]
| python | MIT | 129a3a9fe604443211fa4d493a49630c30689df7 | 2026-01-05T01:34:13.869332Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.