Analisi delle Squadre
Ogni partita della U19 League Hungary offre un'opportunità unica per scoprire i futuri campioni del calcio. Analizziamo le principali forze e debolezze delle squadre in campo domani.
FC Debrecen U19
Il Debrecen ha costruito una squadra molto equilibrata, con una difesa solida e un centrocampo dinamico. I difensori centrali sono stati particolarmente efficaci nel bloccare le incursioni avversarie, mentre i centrocampisti offensivi hanno creato numerose occasioni da gol.
Újpest FC U19
L'Újpest si distingue per il suo attacco veloce e pericoloso. I giovani attaccanti hanno mostrato una grande capacità di finalizzazione nelle ultime partite, rendendo difficile per le difese avversarie contenerli.
MTK Budapest FC U19
MTK Budapest punta sulla tecnica individuale dei suoi giocatori. I centrocampisti sono abili nel palleggio e nel creare gioco, mentre gli attaccanti sono bravi a sfruttare ogni occasione.
Ferencvárosi TC U19
Ferencvárosi ha una squadra fisicamente robusta, capace di dominare il centrocampo grazie alla sua presenza fisica. Gli attaccanti sono abili nel sfruttare gli spazi lasciati liberi dalla difesa avversaria.
Győri ETO FC U19
Győri ETO ha mostrato una grande solidità difensiva nelle ultime partite. La squadra è stata capace di mantenere la porta inviolata in diverse occasioni, grazie a una difesa compatta e organizzata.
Puskás Akadémia FC U19
Puskás Akadémia ha una squadra giovane ma talentuosa, capace di sorprendere con soluzioni offensive imprevedibili. Gli attaccanti sono particolarmente bravi nel dribbling e nel superare gli avversari in uno contro uno.
Formazioni Probabili
Analizziamo ora le formazioni probabili delle squadre che si affronteranno domani. Le scelte tattiche dei mister saranno cruciali per il successo delle loro squadre.
FC Debrecen U19 - Probabile Formazione: 4-4-2
- Portiere: Péter Kovács
- Difesa: András Horváth, Zsolt Tóth, Béla Nagy, Dániel Kovács
- Centrocampo: Gergő Farkas, Márk Szabó, Balázs Molnár, László Varga
- Attacco: Tamás Szabó, Máté Kovács
Újpest FC U19 - Probabile Formazione: 4-3-3
- Portiere: László Horváth
- Difesa: Péter Nagy, Bence Kalmár, Dániel Tóth, Gergő Kovács
- Centrocampo: Attila Horváth, Zoltán Farkas, Máté Nagy
- Attacco: Gergő Tóth, Dávid Molnár, Tamás Szabó
MTK Budapest FC U19 - Probabile Formazione: 4-2-3-1
- Portiere: Dániel Horváth
- Difesa: Bence Kovács, Péter Nagy, Gergő Tóth, Máté Farkas
- Centrocampo: Zsolt Molnár, Balázs Horváth
- Trequartista: László Szabó
- Punta: Máté Kovács
- Soprattutto al fianco dell'attaccante: Attila Nagy, Gergő Farkas, Zoltán Tóth
Ferencvárosi TC U19 - Probabile Formazione: 4-5-1
- Portiere: Gergő Nagy
- Difesa: Péter Tóth, Dániel Horváth, Béla Kovács, Zsolt Nagy
- Centrocampo: Máté Farkas, Gergő Molnár, Zoltán Kovács, Balázs Tóth, Attila Szabó
- Punta: Tamás Horváth
farrukhimanazir/ctf<|file_sep|>/README.md
# CTF Writeups
## [CSAW CTF Quals](https://github.com/farrukhimanazir/ctf/tree/master/csaw)
### [Baby Reversing](https://github.com/farrukhimanazir/ctf/tree/master/csaw/baby_reversing)
Score: 300
Solves: 60
### [I am the Matrix](https://github.com/farrukhimanazir/ctf/tree/master/csaw/i_am_the_matrix)
Score: 500
Solves: 30
### [Pwn Me](https://github.com/farrukhimanazir/ctf/tree/master/csaw/pwn_me)
Score: 1000
Solves: 9
## [Hack.lu CTF Quals](https://github.com/farrukhimanazir/ctf/tree/master/hacklu)
### [Reversing: Pi](https://github.com/farrukhimanazir/ctf/tree/master/hacklu/reversing_pi)
Score: 300
Solves: 73
### [Web: Image of the day](https://github.com/farrukhimanazir/ctf/tree/master/hacklu/web_image_of_the_day)
Score: 200
Solves: 80
## [Root Me CTF Quals](https://github.com/farrukhimanazir/ctf/tree/master/rootme)
### [Reversing: Code Breaker](https://github.com/farrukhimanazir/ctf/tree/master/rootme/reversing_code_breaker)
Score: 1000
Solves: 7
### [Reversing: Reversing is Fun!](https://github.com/farrukhimanazir/ctf/tree/master/rootme/reversing_is_fun)
Score: 500
Solves: 31
<|file_sep|>#include
#include
#include
#include
#include
#include
int main(int argc,char *argv[]){
char buf[128],secret[32],key[32];
int fd;
if(argc!=2){
printf("Usage : %s keyn",argv[0]);
exit(1);
}
strcpy(key,"$$$");
strcat(key,"x90x90x90x90x90x90");
strcat(key,"x90x90x90x90x90x90");
strcat(key,"x90x90x90x90x90x90");
strcat(key,"x90x90x90x90x90x90");
strcat(key,"$$$");
fd=open("/flag",O_RDONLY);
read(fd,&secret,sizeof(secret));
close(fd);
printf("Welcome to the puzzle game.n");
printf("You have to find the secret word by guessing it letter by letter.n");
printf("You have %d tries.n",strlen(secret)+1);
int i=0,j=0;
while(i#include
#include
#include
int main(int argc,char *argv[]){
char buf[256],secret[32];
int i=0,j=0;
if(argc!=2){
printf("Usage : %s keyn",argv[0]);
exit(1);
}
strcpy(secret,"$$$");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"x00");
strcat(secret,"$$$");
while(1){
printf("Welcome to the puzzle game.nYou have to find the secret word by guessing it letter by letter.nYou have %d tries.n",strlen(secret)+1);
printf("Guess the next letter of the secret word : ");
scanf("%c",&buf[i]);
fflush(stdin);
if(buf[i]==secret[i]){
i++;
j=0;
continue;
}
else{
j++;
if(j==strlen(secret)-i+1){
break;
}
i--;
continue;
}
}
if(i==strlen(secret)){
printf("Congratulations! The secret word is : %sn",secret);
system("/bin/cat flag.txt");
exit(0);
}
else{
system("/bin/cat flag.txt");
exit(0);
}
}<|repo_name|>farrukhimanazir/ctf<|file_sep|>/rootme/reversing_code_breaker/puzzle.c
/*
* This code is released under GPLv2 or later.
*
* Author:
* Robin Wenk ([email protected])
*
* Compile with:
* gcc -o puzzle puzzle.c
*
*/
#include
#include
#include
static const char *flag = "r00tMe{the_l337_mastah_is_here}";
#define FLAG_SIZE (sizeof(flag) - sizeof(char *))
static const unsigned char xor_key[] =
{
't', 'e', 'm', 'e', 'r', 'm',
'e', 't', 'e', 'm', 'e', 'r',
'm', 'e', 't', 'e', 'm', 'e',
'r', 'm', 'e'
};
int main(int argc,char *argv[])
{
if (argc != 2) {
printf("Usage:t%s keyn", argv[0]);
exit(-1);
}
char buffer[FLAG_SIZE];
memset(buffer,' ',sizeof(buffer));
for (int i = FLAG_SIZE; i--;) {
buffer[i] = flag[i] ^ xor_key[i % sizeof(xor_key)];
}
if (!strncmp(argv[1], buffer + FLAG_SIZE / 2 - strlen(argv[1]), strlen(argv[1])))
printf("%sn", flag);
return EXIT_SUCCESS;
}<|repo_name|>farrukhimanazir/ctf<|file_sep|>/hacklu/reversing_pi/pi.c
/*
This code is released under GPLv2 or later.
Author:
Robin Wenk ([email protected])
Compile with:
gcc -o pi pi.c
*/
#include
#include
#include
static const char *flag = "hacklu{the_l337_mastah_is_here}";
#define FLAG_SIZE (sizeof(flag) - sizeof(char *))
static int foo(const unsigned char *key)
{
unsigned char buffer[FLAG_SIZE];
int i;
for (i = FLAG_SIZE; i--;)
buffer[i] = key[i % sizeof(key)] ^ key[(i + FLAG_SIZE / 4) % sizeof(key)] ^ key[(i + FLAG_SIZE / 2) % sizeof(key)] ^ key[(i + FLAG_SIZE /4 *3) % sizeof(key)];
return !strncmp(flag + FLAG_SIZE /2 - strlen((const char *)key), buffer + FLAG_SIZE /2 - strlen((const char *)key), strlen((const char *)key));
}
int main(int argc,char *argv[])
{
if (argc != 2) {
printf("Usage:t%s keyn", argv[0]);
exit(-1);
}
if (foo((unsigned char *)argv[1]))
printf("%sn", flag);
return EXIT_SUCCESS;
}<|repo_name|>farrukhimanazir/ctf<|file_sep|>/rootme/reversing_is_fun/main.py
#!/usr/bin/env python
import sys
def getFlag():
with open('flag.txt') as f:
return f.read()
def encode(s):
cipher = ''
for c in s:
cipher += chr(ord(c) ^ ord('R'))
return cipher
def decode(s):
cipher = ''
for c in s:
cipher += chr(ord(c) ^ ord('R'))
return cipher
def check(string):
s = string.split(',')
if len(s) != len(set(s)):
return False
for x in s:
if len(x) != len(set(x)):
return False
return True
def main():
flag = getFlag()
flag = encode(flag)
print "Welcome to my new game!"
print "Try to guess my flag!"
print "Please enter your guess:"
while True:
try:
guess = raw_input()
except EOFError:
sys.exit(1)
guess = encode(guess)
if check(guess):
if guess == flag:
print "Congratulations! Here is your flag:"
print decode(flag)
sys.exit(0)
else:
print "Try again!"
else:
print "Wrong!"
if __name__ == '__main__':
main()<|file_sep|># CSAW CTF Quals Writeups
## Baby Reversing
The binary provided to us was as follows:
c++
#include
#include
#include
int main(int argc,char *argv[]){
char buf[128],secret[32];
int i=0,j=0;
if(argc!=2){
printf("Usage : %s keyn",argv[0]);
exit(