hacknite2026
Differences
This shows you the differences between two versions of the page.
| Next revision | Previous revision | ||
| hacknite2026 [2026/11/16 15:27] – created mbunic | hacknite2026 [2026/11/16 20:44] (current) – [Sigurnost Umjetne Inteligencije] mbunic | ||
|---|---|---|---|
| Line 1588: | Line 1588: | ||
| [[mathscriptbuilder|CTF writeup - Math ScriptBuilder]] | [[mathscriptbuilder|CTF writeup - Math ScriptBuilder]] | ||
| + | |||
| ======Sigurnost Umjetne Inteligencije====== | ======Sigurnost Umjetne Inteligencije====== | ||
| + | |||
| + | ====Unknown Image Detection Model 1==== | ||
| + | < | ||
| + | Trenirali smo model da prepoznaje nešto na slikama, | ||
| + | ali smo zaboravili za što smo ga točno trenirali! | ||
| + | Možete li otkriti za što je model treniran i dobiti flag? | ||
| + | |||
| + | http:// | ||
| + | </ | ||
| + | |||
| + | Uz zadatak je dan izvorni kod. | ||
| + | |||
| + | Potrebno je uploadati PNG sliku traženog formata za koju će izračunata vrijednost '' | ||
| + | |||
| + | Kako bi se riješio zadatak, može se koristiti automatizirana skripta koja iterativno generira slike te nad njima izvršava i skriptu za izračun vrijednosti vizualne strukture i pokreće model nad slikama. Tako se traži i otkriva koji oblici i atributi rezultiraju većim traženim vrijednostima. | ||
| + | |||
| + | Druga tehnika je **gradient ascent**, gdje se optimiziraju vrijednosti piksela ulazne slike kako bi se maksimizirala aktivacija neurona modela. | ||
| + | |||
| + | Na temelju funkcija neurona modela u odnosu na vrijednosti piksela, derivacijom se pronađe na koji način mijenjanje piksela slike najviše povećava aktivaciju neurona. Ovako se pronalazi gradijent, vektor koji pokazuje smjer najvećeg povećanja aktivacije neurona. | ||
| + | |||
| + | Nakon toga se slika iterativno generira u skladu s pronađenim gradijentom, | ||
| + | |||
| + | Rezultirajuća slika je često mutna i nejasna pa se mogu koristiti dodatne tehnike pri generaciji slike kako bi bilo jasnije što je traženi objekt. | ||
| + | |||
| + | Kako bi se smanjila pojava više detektiranih objekata, kojima se rubovi mogu preklapati i učiniti sliku nejasnijom, može se koristiti dodavanje prosjeka sigurnosti svih detekcija objekata kao negativnog doprinosa rezultatu pojedine iteracije uz maksimiziranje detekcije s najvećom sigurnošću. Time se postupak generacije slike usmjerava da generira samo jedan objekt za kojeg je sigurnost detekcije jako visoka, dok se ostale pojave sa slabijom detekcijom potiskuju. | ||
| + | |||
| + | Također se mogu koristiti i tehnike **jittering** i **zamućivanje slike uz postupno smanjivanje intenziteta**. Slika se u svakoj iteraciji nasumično pomiče za nekoliko piksela te se na pomaknutoj slici računa gradijent. Tako se smanjuju artefakti, odnosno neželjene lokalizirane strukture na točno određenim dijelovima slike koje zbog svoje prostorne pozicije povećavaju sigurnost modela, a ne doprinose prepoznatljivosti traženog objekta (prepoznatljivosti u smislu da je čovjeku jasno što taj objekt predstavlja). Ovako se potiče da se sigurnost detekcije objekta temelji na njegovim karakteristikama bez obzira na njegovu poziciju na slici, odnosno smanjuje se osjetljivost na točan položaj pojedinih struktura na slici. | ||
| + | |||
| + | Zamućivanje se snažnije koristi pri prvim iteracijama te se naknadno postupno smanjuje kako bi generirana slika u ranijim iteracijama bila mutnija, čime se potiče definiranje općenitog oblika objekta, a u kasnijim iteracijama postaje oštrija kako bi se jasnije vidjele granice traženog objekta nakon što je oblik već " | ||
| + | |||
| + | Bash skripta za postavljanje virtualnog okruženja: | ||
| + | |||
| + | <code bash> | ||
| + | #!/bin/bash | ||
| + | |||
| + | set -e | ||
| + | |||
| + | echo " | ||
| + | echo " YOLO environment setup" | ||
| + | echo " | ||
| + | |||
| + | cd " | ||
| + | |||
| + | if [ ! -d " | ||
| + | echo " | ||
| + | python3 -m venv .venv | ||
| + | else | ||
| + | echo " | ||
| + | fi | ||
| + | |||
| + | source .venv/ | ||
| + | |||
| + | echo "Using Python:" | ||
| + | python --version | ||
| + | |||
| + | echo | ||
| + | echo " | ||
| + | python -m pip install --upgrade pip | ||
| + | |||
| + | echo | ||
| + | echo " | ||
| + | python -m pip install --upgrade \ | ||
| + | " | ||
| + | ultralytics \ | ||
| + | opencv-python | ||
| + | |||
| + | echo | ||
| + | echo " | ||
| + | python -c " | ||
| + | import numpy | ||
| + | import cv2 | ||
| + | import ultralytics | ||
| + | |||
| + | print(' | ||
| + | print(' | ||
| + | print(' | ||
| + | print() | ||
| + | print(' | ||
| + | " | ||
| + | |||
| + | echo | ||
| + | echo " | ||
| + | echo " Setup complete!" | ||
| + | echo " | ||
| + | </ | ||
| + | |||
| + | |||
| + | Python skripta za generiranje slike objekta koji je model treniran da prepoznaje: | ||
| + | |||
| + | <code python> | ||
| + | import torch | ||
| + | import torch.nn as nn | ||
| + | import torch.optim as optim | ||
| + | import cv2 | ||
| + | import numpy as np | ||
| + | from ultralytics import YOLO | ||
| + | |||
| + | # 1. Load the model | ||
| + | model_wrapper = YOLO(' | ||
| + | model = model_wrapper.model | ||
| + | model.eval() | ||
| + | |||
| + | # 2. Parameters | ||
| + | img_size = 416 | ||
| + | iterations = 2000 | ||
| + | input_image = torch.randn(1, | ||
| + | optimizer = optim.Adam([input_image], | ||
| + | |||
| + | def total_variation_loss(img): | ||
| + | tv_h = torch.pow(img[:,:, | ||
| + | tv_w = torch.pow(img[:,:,:, | ||
| + | return (tv_h + tv_w) | ||
| + | |||
| + | for i in range(iterations): | ||
| + | optimizer.zero_grad() | ||
| + | | ||
| + | # Forward pass | ||
| + | output = model(input_image)[0] | ||
| + | | ||
| + | # --- 1.st class --- | ||
| + | scores = output[0, 4, :] | ||
| + | max_score = scores.max() | ||
| + | suppression_loss = scores.mean() | ||
| + | | ||
| + | # Force stronger color (maximize diff between R,G,B) | ||
| + | r, g, b = input_image[0, | ||
| + | color_variance = torch.var(torch.stack([r, | ||
| + | | ||
| + | # Primary Loss | ||
| + | # Subtract max_score (maximize it) and subtract color_variance (maximize it) | ||
| + | class_loss = -max_score + (suppression_loss * 0.5) | ||
| + | color_loss = -color_variance * 2.0 # " | ||
| + | | ||
| + | # General Regularization | ||
| + | tv_loss = total_variation_loss(input_image) * 0.00001 | ||
| + | l2_loss = torch.norm(input_image) * 0.001 | ||
| + | | ||
| + | total_loss = class_loss + color_loss + tv_loss + l2_loss | ||
| + | |||
| + | # Find gradient | ||
| + | total_loss.backward() | ||
| + | optimizer.step() | ||
| + | |||
| + | # --- DECAYED BLURRING --- | ||
| + | with torch.no_grad(): | ||
| + | input_image.clamp_(0, | ||
| + | | ||
| + | # Slower blur decay | ||
| + | if i < 600: k, s = 9, 4 | ||
| + | elif i < 1100: k, s = 5, 2 | ||
| + | elif i < 1600: k, s = 3, 1 | ||
| + | else: k, s = 0, 0 | ||
| + | | ||
| + | if k > 0 and i % 10 == 0: | ||
| + | input_image.data = torch.nn.functional.avg_pool2d( | ||
| + | input_image.data, | ||
| + | ) | ||
| + | |||
| + | if i % 100 == 0: | ||
| + | print(f" | ||
| + | |||
| + | # Output | ||
| + | final_img = input_image.detach().squeeze().permute(1, | ||
| + | final_img = (final_img * 255).astype(np.uint8) | ||
| + | final_img = cv2.cvtColor(final_img, | ||
| + | cv2.imwrite(" | ||
| + | </ | ||
| + | |||
| + | Korištenjem opisane tehnike može se vidjeti da se na generiranoj slici pojavljuje zeleni krug. Ako generirana slika ne zadovoljava uvjet minimalne vrijednosti '' | ||
| + | |||
| + | ====Unknown Image Detection Model 2==== | ||
| + | < | ||
| + | Ne zna se što točno model klasificira kao " | ||
| + | |||
| + | Izvorni kod zadatka: https:// | ||
| + | |||
| + | http:// | ||
| + | </ | ||
| + | |||
| + | Uz zadatak je dan izvorni kod. | ||
| + | |||
| + | Zadatak je vrlo sličan prošlom, razlika je što se ne koristi '' | ||
| + | |||
| + | Kako bi se zadatak riješio, potrebno je poslati sliku koja će se detektirati kao klasa '' | ||
| + | |||
| + | Jedna od prepreka je to što se na poslužitelj ne mogu slati slike direktno, nego se šalje JSON iz kojeg se na strani poslužitelja konstruira slika koja se potom daje modelu na klasifikaciju. Na stranici zadatka je dostupno sučelje za izradu slike koje automatski napravljenu sliku šalje kao JSON na server gdje se ista slika rekonstruira. | ||
| + | |||
| + | U ovom zadatku traženi je objekt značajno kompleksniji od zelenog kruga, a slika koja bi se dobila s pomoću tehnike '' | ||
| + | |||
| + | Skripta koja također koristi '' | ||
| + | |||
| + | <code python> | ||
| + | # | ||
| + | |||
| + | import argparse | ||
| + | from pathlib import Path | ||
| + | |||
| + | import cv2 | ||
| + | import numpy as np | ||
| + | import torch | ||
| + | import torch.nn as nn | ||
| + | import torch.nn.functional as F | ||
| + | from torchvision import models | ||
| + | |||
| + | |||
| + | # ============================================================ | ||
| + | # Configuration | ||
| + | # ============================================================ | ||
| + | |||
| + | IMAGE_SIZE = 224 | ||
| + | |||
| + | ITERATIONS = 1250 | ||
| + | RESTARTS = 1 | ||
| + | |||
| + | LEARNING_RATE = 0.05 | ||
| + | |||
| + | # Regularization | ||
| + | TV_WEIGHT = 0.00002 | ||
| + | L2_WEIGHT = 0.0005 | ||
| + | HIGH_FREQ_WEIGHT = 0.00005 | ||
| + | |||
| + | # How often to save progress | ||
| + | SAVE_EVERY = 250 | ||
| + | |||
| + | OUTPUT_DIR = Path(" | ||
| + | |||
| + | DEVICE = torch.device(" | ||
| + | |||
| + | |||
| + | # ============================================================ | ||
| + | # ImageNet normalization | ||
| + | # defined in app.py (used by pretrained models, ResNet18 ) | ||
| + | # ============================================================ | ||
| + | |||
| + | IMAGENET_MEAN = torch.tensor( | ||
| + | [0.485, 0.456, 0.406] | ||
| + | ).view(1, 3, 1, 1) | ||
| + | |||
| + | IMAGENET_STD = torch.tensor( | ||
| + | [0.229, 0.224, 0.225] | ||
| + | ).view(1, 3, 1, 1) | ||
| + | |||
| + | |||
| + | # ============================================================ | ||
| + | # Helpers | ||
| + | # ============================================================ | ||
| + | |||
| + | def normalize_image(x): | ||
| + | mean = IMAGENET_MEAN.to(x.device) | ||
| + | std = IMAGENET_STD.to(x.device) | ||
| + | |||
| + | return (x - mean) / std | ||
| + | |||
| + | |||
| + | def total_variation_loss(img): | ||
| + | """ | ||
| + | -> neighboring pixels should be similar. | ||
| + | """ | ||
| + | |||
| + | vertical = img[:, :, 1:, :] - img[:, :, :-1, :] | ||
| + | horizontal = img[:, :, :, 1:] - img[:, :, :, :-1] | ||
| + | |||
| + | return ( | ||
| + | vertical.pow(2).mean() | ||
| + | + horizontal.pow(2).mean() | ||
| + | ) | ||
| + | |||
| + | |||
| + | def high_frequency_loss(img): | ||
| + | """ | ||
| + | -> discourage very high-frequency patterns. | ||
| + | |||
| + | classifier can otherwise exploit tiny pixel-level | ||
| + | structures (imperceptible to humans). | ||
| + | """ | ||
| + | |||
| + | blurred = F.avg_pool2d( | ||
| + | img, | ||
| + | kernel_size=3, | ||
| + | stride=1, | ||
| + | padding=1, | ||
| + | ) | ||
| + | |||
| + | return (img - blurred).pow(2).mean() | ||
| + | |||
| + | |||
| + | def random_jitter(img, | ||
| + | |||
| + | shift_x = torch.randint( | ||
| + | -amount, | ||
| + | amount + 1, | ||
| + | (1,), | ||
| + | device=img.device, | ||
| + | ).item() | ||
| + | |||
| + | shift_y = torch.randint( | ||
| + | -amount, | ||
| + | amount + 1, | ||
| + | (1,), | ||
| + | device=img.device, | ||
| + | ).item() | ||
| + | |||
| + | return torch.roll( | ||
| + | img, | ||
| + | shifts=(shift_x, | ||
| + | dims=(2, 3), | ||
| + | ) | ||
| + | |||
| + | |||
| + | def save_image(tensor, | ||
| + | |||
| + | image = ( | ||
| + | tensor.detach() | ||
| + | .clamp(0, 1) | ||
| + | .squeeze(0) | ||
| + | .permute(1, 2, 0) | ||
| + | .cpu() | ||
| + | .numpy() | ||
| + | ) | ||
| + | |||
| + | image = (image * 255).astype(np.uint8) | ||
| + | |||
| + | # RGB -> BGR for OpenCV | ||
| + | image = cv2.cvtColor( | ||
| + | image, | ||
| + | cv2.COLOR_RGB2BGR, | ||
| + | ) | ||
| + | |||
| + | cv2.imwrite( | ||
| + | str(path), | ||
| + | image, | ||
| + | ) | ||
| + | |||
| + | |||
| + | def load_model(checkpoint_path): | ||
| + | |||
| + | print(" | ||
| + | print(" | ||
| + | print(" | ||
| + | |||
| + | checkpoint = torch.load( | ||
| + | checkpoint_path, | ||
| + | map_location=DEVICE, | ||
| + | ) | ||
| + | |||
| + | class_names = None | ||
| + | |||
| + | if isinstance(checkpoint, | ||
| + | if " | ||
| + | state_dict = checkpoint[" | ||
| + | class_names = checkpoint.get(" | ||
| + | |||
| + | else: | ||
| + | state_dict = checkpoint | ||
| + | else: | ||
| + | raise ValueError( | ||
| + | " | ||
| + | ) | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # Determine output size from fc.weight | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | fc_weight = state_dict.get(" | ||
| + | |||
| + | if fc_weight is None: | ||
| + | raise ValueError( | ||
| + | "Could not find ' | ||
| + | ) | ||
| + | |||
| + | num_classes = fc_weight.shape[0] | ||
| + | |||
| + | print(f" | ||
| + | |||
| + | if class_names: | ||
| + | print(f" | ||
| + | |||
| + | |||
| + | model = models.resnet18( | ||
| + | weights=None | ||
| + | ) | ||
| + | |||
| + | model.fc = nn.Linear( | ||
| + | model.fc.in_features, | ||
| + | num_classes, | ||
| + | ) | ||
| + | |||
| + | model.load_state_dict( | ||
| + | state_dict | ||
| + | ) | ||
| + | |||
| + | model.eval() | ||
| + | model.to(DEVICE) | ||
| + | |||
| + | # Disable gradients for model parameters. | ||
| + | for parameter in model.parameters(): | ||
| + | parameter.requires_grad_(False) | ||
| + | |||
| + | print(" | ||
| + | print() | ||
| + | |||
| + | return model, class_names | ||
| + | |||
| + | |||
| + | # ============================================================ | ||
| + | # Activation maximization | ||
| + | # ============================================================ | ||
| + | |||
| + | def optimize_class( | ||
| + | model, | ||
| + | class_index, | ||
| + | class_name, | ||
| + | output_dir, | ||
| + | model_name | ||
| + | ): | ||
| + | """ | ||
| + | -> maximize the selected class. | ||
| + | """ | ||
| + | |||
| + | print(model_name) | ||
| + | |||
| + | print() | ||
| + | print(" | ||
| + | print( | ||
| + | f" | ||
| + | ) | ||
| + | print(" | ||
| + | |||
| + | best_score = -float(" | ||
| + | best_image = None | ||
| + | |||
| + | for restart in range(1, RESTARTS + 1): | ||
| + | |||
| + | print() | ||
| + | print( | ||
| + | f" | ||
| + | ) | ||
| + | |||
| + | # ---------------------------------------------------- | ||
| + | # Starting image | ||
| + | # | ||
| + | # Start close to gray rather than random noise. | ||
| + | # ---------------------------------------------------- | ||
| + | |||
| + | image = ( | ||
| + | torch.randn( | ||
| + | 1, | ||
| + | 3, | ||
| + | IMAGE_SIZE, | ||
| + | IMAGE_SIZE, | ||
| + | device=DEVICE, | ||
| + | ) | ||
| + | * 0.15 | ||
| + | + 0.5 | ||
| + | ) | ||
| + | |||
| + | image = image.clamp(0, | ||
| + | |||
| + | image.requires_grad_(True) | ||
| + | |||
| + | optimizer = torch.optim.Adam( | ||
| + | [image], | ||
| + | lr=LEARNING_RATE, | ||
| + | ) | ||
| + | |||
| + | restart_best_score = -float(" | ||
| + | restart_best_image = None | ||
| + | |||
| + | for iteration in range( | ||
| + | 1, | ||
| + | ITERATIONS + 1, | ||
| + | ): | ||
| + | |||
| + | optimizer.zero_grad() | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # jitter | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | jittered = random_jitter( | ||
| + | image, | ||
| + | amount=8, | ||
| + | ) | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # input normalization | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | model_input = normalize_image( | ||
| + | jittered | ||
| + | ) | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Forward pass | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | logits = model( | ||
| + | model_input | ||
| + | ) | ||
| + | |||
| + | target_logit = logits[ | ||
| + | 0, | ||
| + | class_index, | ||
| + | ] | ||
| + | |||
| + | # Encourage differentiation relative to other classes. | ||
| + | other_logits = torch.cat( | ||
| + | [ | ||
| + | logits[:, : | ||
| + | logits[:, class_index + 1:], | ||
| + | ], | ||
| + | dim=1, | ||
| + | ) | ||
| + | |||
| + | if other_logits.shape[1] > 0: | ||
| + | competing_logit = other_logits.mean() | ||
| + | class_objective = ( | ||
| + | target_logit | ||
| + | - competing_logit | ||
| + | ) | ||
| + | else: | ||
| + | class_objective = target_logit | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Regularization | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | tv = total_variation_loss(image) | ||
| + | |||
| + | l2 = ( | ||
| + | image - 0.5 | ||
| + | ).pow(2).mean() | ||
| + | |||
| + | hf = high_frequency_loss(image) | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Total loss | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | loss = ( | ||
| + | -class_objective | ||
| + | + TV_WEIGHT * tv | ||
| + | + L2_WEIGHT * l2 | ||
| + | + HIGH_FREQ_WEIGHT * hf | ||
| + | ) | ||
| + | |||
| + | loss.backward() | ||
| + | |||
| + | optimizer.step() | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Keep valid pixel range | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | with torch.no_grad(): | ||
| + | image.clamp_(0, | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Track best candidate | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | score = target_logit.item() | ||
| + | |||
| + | if score > restart_best_score: | ||
| + | restart_best_score = score | ||
| + | restart_best_image = image.detach().clone() | ||
| + | |||
| + | if score > best_score: | ||
| + | best_score = score | ||
| + | best_image = image.detach().clone() | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Progressive blur | ||
| + | # Strong early, gradually relax | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | if iteration % 10 == 0: | ||
| + | |||
| + | if iteration < 500: | ||
| + | kernel = 9 | ||
| + | elif iteration < 1000: | ||
| + | kernel = 7 | ||
| + | elif iteration < 1600: | ||
| + | kernel = 5 | ||
| + | elif iteration < 2100: | ||
| + | kernel = 3 | ||
| + | else: | ||
| + | kernel = 0 | ||
| + | |||
| + | if kernel > 0: | ||
| + | |||
| + | with torch.no_grad(): | ||
| + | |||
| + | padding = kernel // 2 | ||
| + | |||
| + | image.copy_( | ||
| + | F.avg_pool2d( | ||
| + | image, | ||
| + | kernel_size=kernel, | ||
| + | stride=1, | ||
| + | padding=padding, | ||
| + | ) | ||
| + | ) | ||
| + | |||
| + | # ------------------------------------------------ | ||
| + | # Progress | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | if iteration == 1 or iteration % 100 == 0: | ||
| + | |||
| + | probabilities = torch.softmax( | ||
| + | logits, | ||
| + | dim=1, | ||
| + | ) | ||
| + | |||
| + | probability = probabilities[ | ||
| + | 0, | ||
| + | class_index, | ||
| + | ].item() | ||
| + | |||
| + | print( | ||
| + | f" | ||
| + | f" | ||
| + | f" | ||
| + | f" | ||
| + | f" | ||
| + | f"TV: {tv.item(): | ||
| + | end="", | ||
| + | flush=True, | ||
| + | ) | ||
| + | # ------------------------------------------------ | ||
| + | # Save intermediate | ||
| + | # ------------------------------------------------ | ||
| + | |||
| + | if iteration % SAVE_EVERY == 0: | ||
| + | |||
| + | path = ( | ||
| + | output_dir | ||
| + | / f" | ||
| + | / f" | ||
| + | / f" | ||
| + | ) | ||
| + | |||
| + | path.parent.mkdir( | ||
| + | parents=True, | ||
| + | exist_ok=True, | ||
| + | ) | ||
| + | |||
| + | save_image( | ||
| + | image, | ||
| + | path, | ||
| + | ) | ||
| + | |||
| + | print() | ||
| + | |||
| + | # ---------------------------------------------------- | ||
| + | # Save best result | ||
| + | # ---------------------------------------------------- | ||
| + | |||
| + | restart_path = ( | ||
| + | output_dir | ||
| + | / f" | ||
| + | / f" | ||
| + | ) | ||
| + | |||
| + | save_image( | ||
| + | restart_best_image, | ||
| + | restart_path, | ||
| + | ) | ||
| + | |||
| + | print( | ||
| + | f" | ||
| + | f" | ||
| + | ) | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # Save global best | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | final_path = ( | ||
| + | output_dir | ||
| + | / f" | ||
| + | ) | ||
| + | |||
| + | save_image( | ||
| + | best_image, | ||
| + | final_path, | ||
| + | ) | ||
| + | |||
| + | print() | ||
| + | print( | ||
| + | f"BEST activation: {best_score: | ||
| + | ) | ||
| + | |||
| + | print( | ||
| + | f" | ||
| + | ) | ||
| + | |||
| + | return best_image, best_score | ||
| + | |||
| + | def main(): | ||
| + | |||
| + | parser = argparse.ArgumentParser( | ||
| + | description=( | ||
| + | " | ||
| + | " | ||
| + | ) | ||
| + | ) | ||
| + | |||
| + | parser.add_argument( | ||
| + | " | ||
| + | help=" | ||
| + | ) | ||
| + | |||
| + | parser.add_argument( | ||
| + | " | ||
| + | default=" | ||
| + | help=" | ||
| + | ) | ||
| + | |||
| + | args = parser.parse_args() | ||
| + | |||
| + | |||
| + | model_name = args.model.split(" | ||
| + | |||
| + | |||
| + | |||
| + | global OUTPUT_DIR | ||
| + | |||
| + | OUTPUT_DIR = Path(args.output) | ||
| + | OUTPUT_DIR.mkdir( | ||
| + | parents=True, | ||
| + | exist_ok=True, | ||
| + | ) | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # Load model | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | model, class_names = load_model( | ||
| + | Path(args.model) | ||
| + | ) | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # class names | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | num_classes = model.fc.out_features | ||
| + | |||
| + | if class_names is None: | ||
| + | |||
| + | class_names = [ | ||
| + | f" | ||
| + | for i in range(num_classes) | ||
| + | ] | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # Optimize every class | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | results = [] | ||
| + | |||
| + | for class_index in range(num_classes): | ||
| + | |||
| + | name = class_names[class_index] | ||
| + | |||
| + | image, score = optimize_class( | ||
| + | model=model, | ||
| + | class_index=class_index, | ||
| + | class_name=name, | ||
| + | output_dir=OUTPUT_DIR, | ||
| + | model_name=model_name | ||
| + | ) | ||
| + | |||
| + | results.append( | ||
| + | ( | ||
| + | class_index, | ||
| + | name, | ||
| + | score, | ||
| + | ) | ||
| + | ) | ||
| + | |||
| + | # -------------------------------------------------------- | ||
| + | # Summary | ||
| + | # -------------------------------------------------------- | ||
| + | |||
| + | print() | ||
| + | print(" | ||
| + | print(" | ||
| + | print(" | ||
| + | |||
| + | for class_index, | ||
| + | |||
| + | print( | ||
| + | f" | ||
| + | f" | ||
| + | f"best logit = {score: | ||
| + | ) | ||
| + | |||
| + | print() | ||
| + | print( | ||
| + | f" | ||
| + | f" | ||
| + | ) | ||
| + | |||
| + | |||
| + | if __name__ == " | ||
| + | main() | ||
| + | </ | ||
| + | |||
| + | |||
| + | Pokretanjem ove skripte dobiva se uzorak nalik cvijetu ili leptiru koji se potom može nacrtati u dostupnom sučelju na stranici zadatka kako bi se riješio zadatak. | ||
| + | |||
| + | ====Unknown Image Detection Model 3==== | ||
| + | < | ||
| + | Imate na odabir dostupna 3 modela koji su svi vrlo slični, | ||
| + | trenirani su s istom raspodjelom klasa i s istom namjenom, | ||
| + | no s različitim varijacijama broja epoha i podataka za treniranje. | ||
| + | Ako za bilo koji model zadovoljite traženu kombinaciju, | ||
| + | |||
| + | Izvorni kod zadatka: https:// | ||
| + | |||
| + | http:// | ||
| + | </ | ||
| + | |||
| + | Uz zadatak je dan izvorni kod. | ||
| + | |||
| + | U ovom se zadatku koristi model '' | ||
| + | |||
| + | Također, slike se ne šalju direktno, nego kao JSON objekt koji se rekonstruira na strani poslužitelja. Dostupno je sučelje na stranici zadatka za generiranje slike koja se potom prevedena u JSON šalje na poslužitelj. | ||
| + | |||
| + | Kako bi se riješio zadatak, za poslanu sliku potrebno je dobiti točno određenu kombinaciju triju klasa, pri čemu sigurnost za svaku mora biti veća od 90%. | ||
| + | |||
| + | Također je moguć odabir jednog od tri modela koji će klasificirati generiranu sliku korisnika. Naziv jednog modela je '' | ||
| + | |||
| + | Ovdje je problem što se, ako se radi '' | ||
| + | |||
| + | Kako bi se riješio zadatak, najbolje je prvo za svaku od triju ciljanih klasa generirati sliku koja ih najviše aktivira, a potom pokušati generirati sliku za sve tri istovremeno, | ||
| + | |||
| + | Analizom svih klasifikacija i klasa koje model detektira s pomoću tehnike '' | ||
| + | |||
| + | Tražena kombinacija je slika piramide s uzorkom sinusoidnih valova i visokim kontrastom između boja. | ||
| + | |||
| + | |||
| + | Skripta za generiranje slika korištenjem tehnike '' | ||
| + | |||
| + | <code python> | ||
| + | import argparse | ||
| + | import json | ||
| + | import random | ||
| + | from pathlib import Path | ||
| + | |||
| + | import cv2 | ||
| + | import numpy as np | ||
| + | import torch | ||
| + | import torch.nn as nn | ||
| + | import torch.optim as optim | ||
| + | import torch.nn.functional as F | ||
| + | from torchvision import models, transforms | ||
| + | |||
| + | # ============================================================ | ||
| + | # 1. Command Line & Configuration | ||
| + | # ============================================================ | ||
| + | |||
| + | parser = argparse.ArgumentParser(description=" | ||
| + | parser.add_argument(" | ||
| + | parser.add_argument( | ||
| + | " | ||
| + | nargs="?", | ||
| + | default=" | ||
| + | help=" | ||
| + | ) | ||
| + | |||
| + | args = parser.parse_args() | ||
| + | |||
| + | |||
| + | |||
| + | combo = int(args.combo) | ||
| + | |||
| + | MODEL_PATH = args.model_path | ||
| + | |||
| + | IMAGE_SIZE = 224 | ||
| + | ITERATIONS = 1500 | ||
| + | LEARNING_RATE = 0.05 | ||
| + | DEVICE = torch.device(" | ||
| + | |||
| + | SHAPE_CLASSES = [" | ||
| + | PATTERN_CLASSES = [" | ||
| + | CONTRAST_CLASSES = [" | ||
| + | |||
| + | |||
| + | # quickfix | ||
| + | TARGET_SHAPE = combo // 100 | ||
| + | TARGET_PATTERN = (combo % 100 - combo % 10) // 10 | ||
| + | TARGET_CONTRAST = combo %10 | ||
| + | |||
| + | |||
| + | print([TARGET_CONTRAST, | ||
| + | print(SHAPE_CLASSES[TARGET_SHAPE], | ||
| + | |||
| + | |||
| + | |||
| + | MODEL_NAME = Path(MODEL_PATH).stem | ||
| + | TARGET_NAME = f" | ||
| + | RUN_DIR = Path(" | ||
| + | RUN_DIR.mkdir(parents=True, | ||
| + | |||
| + | # ============================================================ | ||
| + | # Spatial Priors (single, centered object) | ||
| + | # ============================================================ | ||
| + | |||
| + | # 2D distance map from the center | ||
| + | Y, X = torch.meshgrid(torch.arange(IMAGE_SIZE), | ||
| + | dist_from_center = torch.sqrt((X - IMAGE_SIZE// | ||
| + | |||
| + | FG_MASK = torch.clamp(1.0 - (dist_from_center - 50) / 40, 0.0, 1.0).view(1, | ||
| + | BG_MASK = 1.0 - FG_MASK | ||
| + | |||
| + | class MathVisionNet(nn.Module): | ||
| + | def __init__(self): | ||
| + | super().__init__() | ||
| + | self.backbone = models.mobilenet_v3_small(weights=models.MobileNet_V3_Small_Weights.DEFAULT).features | ||
| + | self.pool = nn.AdaptiveAvgPool2d(1) | ||
| + | self.dropout = nn.Dropout(0.2) | ||
| + | self.head_shape = nn.Linear(576, | ||
| + | self.head_pattern = nn.Linear(576, | ||
| + | self.head_contrast = nn.Linear(576, | ||
| + | |||
| + | def forward(self, | ||
| + | x = self.dropout(torch.flatten(self.pool(self.backbone(x)), | ||
| + | return self.head_shape(x), | ||
| + | |||
| + | normalize = transforms.Normalize(mean=[0.485, | ||
| + | |||
| + | def total_variation_loss_L1(img): | ||
| + | """ | ||
| + | tv_h = torch.abs(img[:, | ||
| + | tv_w = torch.abs(img[:, | ||
| + | return tv_h + tv_w | ||
| + | |||
| + | def canvas_to_bgr(canvas): | ||
| + | img = (canvas.detach().squeeze(0).permute(1, | ||
| + | return cv2.cvtColor(img, | ||
| + | |||
| + | # ============================================================ | ||
| + | # Loop | ||
| + | # ============================================================ | ||
| + | |||
| + | def solve(): | ||
| + | print(" | ||
| + | model = MathVisionNet().to(DEVICE) | ||
| + | checkpoint = torch.load(MODEL_PATH, | ||
| + | | ||
| + | state_dict = checkpoint[" | ||
| + | model.load_state_dict(state_dict, | ||
| + | model.eval() | ||
| + | for param in model.parameters(): | ||
| + | |||
| + | # Initialize canvas with neutral gray + slight noise | ||
| + | canvas = (torch.randn(1, | ||
| + | optimizer = optim.Adam([canvas], | ||
| + | |||
| + | best_shape, best_pattern, | ||
| + | best_imgs = {" | ||
| + | best_iters = {" | ||
| + | last_metrics = {} | ||
| + | |||
| + | target_s_tensor = torch.tensor([TARGET_SHAPE], | ||
| + | target_p_tensor = torch.tensor([TARGET_PATTERN], | ||
| + | target_c_tensor = torch.tensor([TARGET_CONTRAST], | ||
| + | |||
| + | for i in range(ITERATIONS): | ||
| + | optimizer.zero_grad() | ||
| + | |||
| + | # Force background to be a solid flat color | ||
| + | bg_mean = (canvas * BG_MASK).sum(dim=(2, | ||
| + | fg_mean = (canvas * FG_MASK).sum(dim=(2, | ||
| + | | ||
| + | bg_variance_loss = torch.mean(BG_MASK * torch.abs(canvas - bg_mean)) | ||
| + | | ||
| + | # Maximize RGB distance between Foreground and Background | ||
| + | fg_bg_dist_loss = -torch.norm(fg_mean - bg_mean) | ||
| + | |||
| + | # ---Transformation Robustness --- | ||
| + | scale_factor = random.uniform(0.9, | ||
| + | new_size = int(IMAGE_SIZE * scale_factor) | ||
| + | | ||
| + | transformed = F.interpolate(canvas, | ||
| + | ox, oy = random.randint(-4, | ||
| + | transformed = torch.roll(transformed, | ||
| + | | ||
| + | if new_size > IMAGE_SIZE: | ||
| + | start = (new_size - IMAGE_SIZE) // 2 | ||
| + | transformed = transformed[:, | ||
| + | elif new_size < IMAGE_SIZE: | ||
| + | pad = (IMAGE_SIZE - new_size) // 2 | ||
| + | transformed = F.pad(transformed, | ||
| + | |||
| + | # --- Forward Pass --- | ||
| + | out_shape, out_pattern, | ||
| + | |||
| + | loss_shape = F.cross_entropy(out_shape, | ||
| + | loss_pattern = F.cross_entropy(out_pattern, | ||
| + | loss_contrast = F.cross_entropy(out_contrast, | ||
| + | |||
| + | # --- Total Loss --- | ||
| + | # Color diversity to foreground mask | ||
| + | color_var = torch.var(torch.stack([canvas[0, | ||
| + | | ||
| + | total_loss = ( | ||
| + | loss_shape | ||
| + | + loss_pattern | ||
| + | + loss_contrast | ||
| + | + (bg_variance_loss * 15.0) # Enforce flat background | ||
| + | + (fg_bg_dist_loss * 2.0) # Push FG/BG colors apart | ||
| + | - (color_var * 5.0) # Shape detail | ||
| + | + (total_variation_loss_L1(transformed) * 0.005) # L1 TV for HARD EDGES | ||
| + | ) | ||
| + | | ||
| + | total_loss.backward() | ||
| + | optimizer.step() | ||
| + | |||
| + | # --- Reduced Blurring --- | ||
| + | with torch.no_grad(): | ||
| + | canvas.clamp_(0.0, | ||
| + | | ||
| + | if i < 400: k, s = 5, 2 | ||
| + | elif i < 800: k, s = 3, 1 | ||
| + | else: k, s = 0, 0 | ||
| + | | ||
| + | if k > 0 and i % 20 == 0: | ||
| + | canvas.copy_(F.avg_pool2d(canvas, | ||
| + | |||
| + | # --- Evaluation Pass --- | ||
| + | c_shape, c_pattern, c_contrast = model(normalize(canvas)) | ||
| + | | ||
| + | prob_s = torch.softmax(c_shape, | ||
| + | prob_p = torch.softmax(c_pattern, | ||
| + | prob_c = torch.softmax(c_contrast, | ||
| + | prob_overall = (prob_s * prob_p * prob_c) ** (1.0 / 3.0) | ||
| + | |||
| + | current_img = canvas_to_bgr(canvas) | ||
| + | last_metrics = {" | ||
| + | " | ||
| + | |||
| + | # Track Bests | ||
| + | if prob_s > best_shape: best_shape, best_iters[" | ||
| + | if prob_p > best_pattern: | ||
| + | if prob_c > best_contrast: | ||
| + | if prob_overall > best_overall: | ||
| + | |||
| + | if i % 100 == 0 or i == ITERATIONS - 1: | ||
| + | print(f" | ||
| + | |||
| + | # ============================================================ | ||
| + | # 7. Save Outputs | ||
| + | # ============================================================ | ||
| + | print(" | ||
| + | | ||
| + | cv2.imwrite(str(RUN_DIR / " | ||
| + | cv2.imwrite(str(RUN_DIR / " | ||
| + | cv2.imwrite(str(RUN_DIR / " | ||
| + | cv2.imwrite(str(RUN_DIR / " | ||
| + | cv2.imwrite(str(RUN_DIR / " | ||
| + | |||
| + | results = { | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | }, | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | } | ||
| + | } | ||
| + | |||
| + | with open(RUN_DIR / " | ||
| + | json.dump(results, | ||
| + | |||
| + | print(f" | ||
| + | print(f" | ||
| + | print(f" | ||
| + | print(f" | ||
| + | |||
| + | if __name__ == " | ||
| + | solve() | ||
| + | </ | ||
| + | |||
| + | |||
| + | |||
| + | JSON koji definira opisanu sliku koju će '' | ||
| + | |||
| + | <code JSON> | ||
| + | {" | ||
| + | " | ||
| + | " | ||
| + | {" | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | {" | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | {" | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | " | ||
| + | {" | ||
| + | " | ||
| + | " | ||
| + | {" | ||
| + | " | ||
| + | </ | ||
| + | |||
| + | ====Flask Autocomplete==== | ||
| + | Rješenje zadatka dostupno je ovdje: | ||
| + | [[flaskautocomplete|CTF writeup - Flask Autocomplete]] | ||
hacknite2026.1794842841.txt.gz · Last modified: 2026/11/16 15:27 by mbunic