Hacker VS Programatori – Demo

Pershendetje, jemi perseri ne nje nga temat e nxehta , kam pergatitur nje skenar ku per te shpjeguar “punen” qe bejn pershkruesit “private” public ne java kam shkruajtur versione te ndryshme te nje programi “banke” me funksione shume te thjeshta.
E futa “hackerin” ne loje sepse tema behet shume me interesante, leximi i kodit behet akoma me itneresant dhe ajo qe doja te shpjegoja (mbrojtja e variabilave dhe metodave ne programimin me objekte)  behet me e qarte dhe e kuptueshme.
Kodin e kam komentuar mire, ose me sakt “tabllon e ngjarjes” keshtu qe leximi i kodit do jete shume i mire… Nese nuk lexoni kod:
“Ne kemi nje perkufizim te pergjithshem per lamerat, themi qe jane njerez qe nuk lexojn kod” 
Kodin me gjithe udhezimet e perdorimit mund ta shkarkoni:
http://albanianwizard.org/pub/bhck.zip

Nje pjese te programit mund ta shihni tek:
http://albanianwizard.org/Postokodin/60

Kujtoj qe skenari eshte virtual, ne boten reale nje vulnerabilitet i tipit buffer overflow do ti jepte sulmuesit kontroll te plote mbi programin vulnerabel dhe kjo do te kompromentonte dhe pjesen tjeter te sistemit.
Sigurohet kenaqesi dhe info pa limit gjat leximit 😉
Have Phun 😛

RREGULLA TE ARTA PROGRAMIMI

Shpesh here nje program cilesor ben diferencen, e kam fjalen ne te gjitha aspektet.
Le te permendim disa rregulla te arta qe vertet bejn diferencen:

1. Ne cilen gjuhe ta shkruajm programin?

Shpesh here kjo eshte zgjedhje vendimtare pasi gjuha qe mund te kemi zgjedhur nuk eshte shume e pershtatshme per nje program te caktuar ndersa nje tjeter eshte shume here me e mire, psh te marrim nje rast banal si psh te perdoresh assembly per te koduar nje program me grafik te avancuar ose e kunderta te perdoresh cobol nderkohe qe te duhet nje program shume i shpejt (pra qe mund te kodohej ne assembly ose python qe jane gjuhe qe japin goxha shpejtesi)
Pra ky eshte hap themelor.

2. Dizajni imagjinar i programit

Kjo vertet them se eshte pika kryesore dhe themelore e te gjith kesaj, pasi nese ne e ideojm programin ne koken tone, me te gjitha pjeset e tij pastaj zbatimi eshte thjesht 20% e punes, nderkohe qe nje programator i mire ne UML mund te bente shume pune ne keto raste, njohuri te tilla japin stabilitet, siguri, funksionalitet.

3. Thjeshtesia

Sa me i thjeshte, aq me mire, nje program i thjesht ka fluiditet dhe eshte i thjesht per tu rregulluar ndersa nje program i komplikuar eshte shume i prirur per te pasur bug dhe vulnerabilitete, ndersa nje program i thjesht eshte edhe me i leht per tu rregulluar dhe kjo çon tek nje rregull tjeter qe eshte PAK RRESHTA.

4. Modulariteti

Ketu hyjm tek programimi me objekte, shpesh jane objektet qe na kursejn rreshta kodi dhe na japin thjeshtesi, nje rregull shume i rendesishem ketu eshte:
Mbaje MAIN() me sa me pak rreshta kodi, kjo do te thote qe nese ne bejm nje program (po e zeme ne java) mund te kemi 15 faile.java ku vetem njeri ka main() per te egzekutuar programin, nese ne i ndajm Konstruktoret dhe metodat ne secilin nga failet dhe mainin e mbajm me pak rreshta vetem sa per te egzekutuar objektet e shperndara atehere kjo do japi nje program shume te thjesht per tu shpjeguar edhe njerit qe nuk ja ka idene programimit.

5. Ridizaini

Gjate perfundimit te programit ka shume gjasa qe te na lindin ide te reja, ne keto raste edhe nese duam te bejm nje ridizajn te programit do te jete shume i thjesht pasi objektet klasat jane te ndara secila ne vendin e vet dhe metodat po ashtu keshtu qe duhet te jete shume e thjesht per te “lozur” me programin tone.

6. Algoritmi fitues

Shpesh algoritmi fitues nuk eshte ai me i komplikuar, por ai me i thjeshti, sepse thjeshtesi do te thote dhe fleksibilitet dhe kur kemi perpara nje projekt te perfunduar ku duhet te rregullojm bug-e kjo do te na kursente ore te tera.

Jane dhe shume te tjera, por per momentin po ndalohemi me keto. (jam duke ikur lol, shtoni metoda tek komentet)

Objektet dhe Klasat ne Java

Le ta harrojm per disa momente programimin :)
(kjo teme eshte e kendshme per tu lexuar edhe nga ata qe nuk kane asnje lloj eksperience programimi)
Eshte material shqip rreth “si te programojm” ne vazhden e mesimeve \ ushtrimeve java.

Te mendojm per objektet qe na rrethojn (shiko rreth e rrotull)….

Ne baze te studimeve eshte arritur ne perfundimin se njeriu eshte i prirur ta shohi boten ne objekte,po shoh rreth meje dhe pashe keto objekte:
– kart rimbushese
– liber
– celulari
– karrigia
– tryeza e shkrimit
– monitori
– tastiera
– Kompiuteri :)

Zakonisht te permendesh objekte, eshte me e thjeshte te permendesh jo  objekte, psh ngjyra e makines llogaritese nuk eshte objekt dhe as ajri siper tastieres.
Le te shohim se ç’fare e karakterizon objektin ne boten reale :)
Gjeja e pare qe na vjen ne mendje eshte:

Identiteti – kompiuteri eshte nje (1) pra eshte i plote dhe ka identitet, marrim nje shembull:
Ne rastin e njeriut,  ne bejm kart identiteti per veten tone dhe jo per syrin, doren, kemben pra per pjeset e ndryshme te trupit ose ne rastin e shteteve njihet nje shtet qe ka Identitet sepse te gjith banoret e tij kane nje lloj kulture dhe flasin te njejten gjuhe.

gjithashtu objekti ka:

Gjendje – ne rastin tone kompiuteri ka gjendje te caktuara, i ndezur  i fikur, “ne gjume” , i mbingarkuar e keshtu me radhe tamam siç ka gjendje uji (avull, leng, akull).

Sjellje – kompiuteri karakterizohet edhe nga nje “forme te sjelluri” menyre se si vepron ne situata te caktuara psh kur ne prekim tastieren, kur levizim “miushin” e keshtu me radhe.

Eshte pjese e objekteve te tjera – edhe kjo eshte nje tjeter karakteristik sepse perbehet nga objekte te tjera si ekrani, proçesori, tastiera, memorja etj te cilat te gjitha jane objekte te mirefillta perderisa kane Identitet, Gjendje dhe Sjellje pra nga kjo nxjerrim qe nje objekt mund te jete pjese e nje objekti me te madh ose nje objekt i madh mund te perbehet nga objekte me te vogla.
Ky kusht gjithsesi nuk eshte gjithmone i vertet pasi nese marrim nje laps, lapsi eshte objekt por ngjyra e lapsit ben pjes tek karakteristikat e lapsit dhe nuk eshte nje objekt ne vetvete, pra ne kete rast themi se kushti i katert nuk eshte gjithmon i vertete.

Persa i perket programimit:

Edhe persa i perket programimit, ndodh i njejti fenomen , objektet kane Identitet i cili eshte qelite e memorjes qe okupojne te cilat jane nje grup bitesh dhe ndodhen ne nje vend specifik ne memorje dhe jo ne vend tjeter. Kane gjendje pasi nje objekt ka variabila te cilat kane vlera te cilat percaktojn dhe gjendjen e objektit, pra gjendja e objektit percaktohet nga vlerat qe kane variabilat e tij. Gjithasthu objekti ka Sjellje e cila percaktohet nga “Metodat” te cilat percaktojn se ç’fare duhet te bej objekti, psh main() eshte nje metod shume tipike.

Klasa eshte thjesht pershkrimi i tipit te objektit, pershembull nese ne importojm klasen java.util.Scanner;
import java.util.Scanner;
klasa ka nje emer qe quhet Scanner dhe eshte nje nenklas e util qe do te thote utilities (te nevojshme) e cila eshte nen klas e vet gjuhes java keshtu njehere qe e kemi importuar ne mjafton te perdorim new per te krijuar objektin tone shembull:
Scanner sk = new Scanner (System.in);
Klasa pra siç u tha dhe me siper eshte thjeshte pershkrimi i lloit te objektit dhe mund te jete klase qe e krijojm ne ose mund te jete klas e gatshme qe e perfshijm ne programin tone me “import”.

Sfide programimi Java – I/O

Per programatoret java po sjellim nje ushtrim shume interesant dhe ne te njejten kohe nje sfide ne zgjidhjen e tij. Mua personalisht me mori rreth 40 minuta shume te kendshme. Problemi dhe zgjidhja eshte kompleks dhe kerkon intuite ne programim.

Ja ushtrimi:

/*
http://albanianwizard.org
arditi*at*hush*pik*ai
Liçence GPLv3
———————————————————–
Program i nje niveli relativisht te veshtire per temat I\O
Llogjika e ketij programi eshte goxha e komplikuar 😉
———————————————————–
>>Shkruaj nje program i cili lexon N (numer i pa percaktuar) grupe numrash te plote nga nje skedar ku fillim i secilit grupi shenohet me “grupi”.
>>Programi mund te perdori ç’faredo numri grupesh (pra numri i grupeve nuk eshte i limituar).
>>Programi mund te perdori vetem klasat java.util.Scanner; java.io (objektet qe permbajn Scanner new File, .next(), .trim() etj) dhe gjat zhvillimit te tij lejohet vetem while, if, else !
***********************************************************
Ja faili input
***********************************************************
grupi
2 1 6 3 1 4
grupi
grupi
1 19 1 5 2 4 1 2 1
grupi
10 11
12 13
7   8
9
***********************************************************
Ja dhe outputi

***********************************************************
Shuma e grupit 1, eshte e barabarte me 17
Grupi i 2-te nuk ka te dhena.
Shuma e grupit 3, eshte e barabarte me 36
Shuma e grupit 4, eshte e barabarte me 70
*/

Per c’do sqarim postoni ketu por besoj se nga vet shembulli ne fjale Input – Output e keni kuputar se per cfare ben fjale ushtrimi dhe si eshte kerkesa.

Pritet zgjidhja e tij deri ne 1 jave qe nga data e postimit (dmth sot).
Mbas 1 jave do te postoj vet zgjidhjen.
Programinuk me mori shume rreshta kod, thjesht duhet te mendohet mire zgjidhja. :)
Happy coding.

Si te programojm ne Java – Shembull Input \ Output

http://albanianwizard.org/Postokodin/53
/*
http://albanianwizard.org
arditi*at*hush*pik*ai
Liçence GPLv3
——————————-
USHTRIM
——————————-
Shkruaj nje program i cili analizon nje txt file dhe numrat pozitiv i depoziton
ne nje file pozitive.txt, kurse ato negativet i depoziton ne nje file negative.txt
Pyete perdoruesin per ç’do emer faili.
*/

import java.util.*;
import java.io.*;
public class FiltroNumrat {
public static void main (String []args ) throws IOException
{
//Percaktojm Variabilat\\
int numri;
String origjina, destpozitiv, destnegativ;
//Krijoj Objektin per emrat e faileve\\
Scanner inPuti = new Scanner (System.in);

//Marrim te dhenat nga faili origjinar
System.out.println(“Emri i Failit Origjinar :”);
origjina = inPuti.nextLine().trim();
File origjinaf = new File (origjina);
Scanner ori = new Scanner (origjinaf);

//Marrim te dhenat nga faili i destinacionit te numrave pozitiv
System.out.println (“Emri i Failit ku do te depozitohen numrat pozitiv :”);
destpozitiv = inPuti.nextLine().trim();
File destinapoz = new File (destpozitiv);

//Marrim te dhenat nga faili i destinacionit te numrave negativ
System.out.println (“Emri i Failit ku do te depozitohen numrat negativ :”);
destnegativ = inPuti.nextLine().trim();
File destinaneg = new File (destnegativ);

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
//Krijojm objektet per te printuar tek failet e futura nga perdoruesi
PrintStream psp = new PrintStream(destinapoz);  //Pozitiv
PrintStream psn = new PrintStream (destinaneg);   //Negativ
numri = ori.nextInt(); //numri merr vleren e pare qe vjen nga faili origjinar
while (ori.hasNextInt()) //Nderkohe qe nga faili origjinar vijn numra te plote…
{
while (numri >= 0) //dhe ky numer eshte >= 0
{
psp.println(“Numri pozitiv eshte :” + numri); //printo numrin pozitiv tek faili
System.out.println(“Numri pozitiv eshte :” + numri); //printo numrin pozitive ne ekran
numri = ori.nextInt();//Jepi variabiles numri vleren e radhes qe vjen nga faili origjinar
/*Nese kjo nuk behet atehere programi do te printoj vazhdimisht numrin e pare dhe keshtu
do te kaloj ne infinit */
}
while (numri <= 0)
{
psn.println(“Numri negativ eshte :” + numri);//printo numrin negativ tek faili
System.out.println(“Numri negativ eshte :” + numri);//printo numrin negativ ne ekran
numri = ori.nextInt();//Jepi variabiles numri vleren e radhes qe vjen nga faili origjinar
}
}
psp.close();
psn.close();
/*Kjo pjese eshte pjesa qe me ka marre shume kohe sepse ndodh qe te behet nje gabim banal dhe te
* vendoset mbyllja e printimit ne brendesi te ciklit while gje qe do te sillte qe ne failet
* e outputit pozitive.txt dhe negative.txt do te gjenim vetem nje numer , numrin e fundit.. Kjo
* sepse sa here qe do printohej nje numer faili do te mbyllej dhe kur te printohej tjetri do te rihapej
* gje qe do te sillte ate qe tham me siper.. Ky Bug ka kete pamje:
* while (numri <= 0)
{
psn.println(“Numri negativ eshte :” + numri);
System.out.println(“Numri negativ eshte :” + numri);
numri = ori.nextInt();
psn.close();
}
* Pra siç e shohim psn.close(); do te mbyllte printimin ne ç’do cikel while.
*/
}
}

Cikli While – Te programojm ne Java

Cikli While eshte nje pjese e thjeshte e programimit ne pergjithesi, eshte gjeresisht e perdorur dhe mund te perfitojm shume nga perdorimi i tij. Mund te kisha marre shume shembuj per ta ilustruar por zgjodha shumezimin faktorial ne menyre qe te kuptohet me ne gjeresi.

import java.util.Scanner;    //Importojm klasen skaner pasi do marrim impute nga tastiera
public class Faktorial
{
public static void main (String [ ]args)
{
Scanner inPuti = new Scanner (System.in); //krijojm objektin inPuti
long N, fakt = 1; //Percaktojm 2 variabila 1 long N dhe tjetren 1 per faktorialin
System.out.println ("Fut nje numer :");
N = inPuti.nextLong();
if (N >= 0 && N < 20)
  {
	while (N > 1)  //Perderisa Numri > 1 vazhdo

  {
		fakt = fakt * N;  // 1 = 1 * Numrin
        N = N - 1;        //Numri = Numri - 1
  }  //Numri = Numrin - 1
  System.out.println ("Faktoriali eshte :" + fakt); //Printojm faktorialin e numrit.
  }
 else
          {
          System.out.println ("Numri duhet te jete 0 ose me i madh.");
          System.out.println ("SHENIM: Per numra me te medhenj se 20 perfundimi do jete i gabuar sepse variabila i tejkalon bitet qe mund te mbaj" +
           "dhe automatikisht bitet teper i kalon ne kosh, dhe si problem eshte i njohur me \"Overflow\" ne boten e informatikes");
           }
}
}

Bukur mbasi i hodhem nje sy ushtrimit shpjegojm se ç’fare ndodhi.

Shembull, po kryejm te gjitha operacionet qe do bej cikli yne while nese merr numrin 4 nga perdoruesi:
Fut nje numer: 4, ky numer shkon dhe depozitohet ne variabilen N
if kontrollon nese nje statement eshte i vertete, dhe meqenese 4 >= 0 dhe me i vogel
se 20 atehere e fut ne cikel while i cili nderkohe qe sheh se 4 > 1:
fakt = fakt * N                                        ==> 1 = 1 * 4                           ==> fakt = 4
N = N – 1                                                  ==> N = 4 – 1                          ==> N = 3
while ( N > 1 ) ==> 3 > 1
fakt = fakt * N                                         ==> 4 = 4 * 3                          ==> fakt = 12
N = N – 1                                                   ==> 3 = 3 – 1                          ==> N = 2
while ( N > 1 ) ==> 2 > 1
fakt = fakt * N                                         ==> 12 = 12 * 2                      ==> fakt = 24
N = N – 1                                                   ==> 2 = 2 – 1                           ==> N = 1
while ( N > 1 ) ==> Tani N = 1 dhe 1 nuk eshte me i madh se 1 keshtu qe cikli mbyllet
nderkohe qe variabila fakt ka vleren 24 ndersa variabila N ka vleren 1
Besoj se eshte e qarte, pra Cikli While ka kete forme, “nderkohe qe : kushti : veprime”

Ne kete ushtrim vihet re dhe nje overflow nese fusim numra me te medhenj se 20 , do te ishte interesante ta trajtonim dhe ne nivelin e sigurise kete problem te njohur por shpresojm se ne raste te tjera do te jete diskutim me i pershtatshem

Assemblimi i nje instruksioni assembly ne assembler (:?

Nuk eshte loje fjalesh,  mjafton te lexoni kodin dhe eshte i komentuar shume mire.
http://albanianwizard.org/Postokodin/37
Per te shkarkuar:
http://albanianwizard.org/mips_assembly_source_code_examples/programator/assembly.s

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

#albanianwizard.org #

#Licence GPLv3 #

#arditi – arditi{at}hush{pik}ai #

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

#Asemblo instruksionin ori $8, $9, 0x0019 duke mbledhur 1 nga 1 pjeset e tij [opcode],[rt],[rs],[imm] #

#dhe duke e depozituar instruksionin ne menyre te rregullt duke respektuar formatin ne nje regjister ç’faredo. #

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

#Te assemblojm ORI-n #

#Formatin mund ta gjeni tek: #

#http://albanianwizard.org/informatika_shqiptare/arkitekture_kompiuterike/gjuha_e_programimit_assembly/formati-i-instruksioneve-ne-arkitekturen-mips/ #

#Ne kete ushtrim do te shohim se si duke mbledhur copeza kodi mund te arrijm tek instruksioni i deshiruar. #

#Ne rastin tone eshte: ori $8,$9,0×0019 #

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

.text

.globl main

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

# INTRO #

#ori $8, $9, 0x0019 eshte i barabart me isntruksionin 0x35280019 #

#ori ka opcode 1101 == 13 ne dec ose D ne hex #

#Shohim qe ka 1 operand dhe 1 regjister destinacioni dhe 1 vlere te menjehershme #

#Operandi [rs]= $9 / 0x9 #

#Destinacioni [rt]= $8 / 0x8 #

#Vlera e menjehershme [Imm] = 0x0019 #

#Zgjedhim $24 si regjister per te asembluar instruksionin #

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

main:

ori $11,$0,0xD # opcode /kodi i instruksionit ori (0xD)/13/1101 ===>$11

ori $12,$0,0×9 # operandi $9 / [rs] ===>$12

ori $13,$0,0×8 # destinacioni $8 /[rt] ===>$13

ori $14,$0,0×0019 # [Imm] = 0x0019 ===>$14

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

# Rregullojm Bitet #

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

sll $11,$11,26 # spostojm [opcode] ne pozicionin e vet pasi tani eshte 0000 0000 0000 0000 0000 0000 0000 1101

# dhe duhet te jete (si opcode) ne pozicionin e vet: 0011 0100 0000 0000 0000 0000 0000 0000

sll $12,$12,21 # spostojm [rs] ne pozicionin e vet duke e levizur majtas 21 njesi dhe kemi:

# 0000 0000 0000 0000 0000 0000 0000 1001 mbasi e spostojm 21 njesi majtas kemi

# 0000 0001 0010 0000 0000 0000 0000 0000 [kjo eshte pamja e regjistrit mbas egzekutimit te sll $12, $12, 21

sll $13,$13,16 # spostojm [rt] (destinacionin) ne vendin e vet pasi tani eshte :

# 0000 0000 0000 0000 0000 0000 0000 1000 dhe duhet te jete :

# 0000 0000 0000 1000 0000 0000 0000 0000 [kete e ben instruksioni 😉 ]

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

#Fillojm spostojm bitet ne regjistrin e deshiruar#

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

or $24,$24,$11 # Bejme OR [opcode] (R11) tek regjistri $24 i cili do te marri pamjen:

# 0011 0100 0000 0000 0000 0000 0000 0000

or $24,$24,$12 # Bejme OR [RS] qe e kemi “qendisur” tek regjistri 12 me $24 i cili tani duke u shtuar dhe [rs] do marri pamjen

# 0011 0101 0010 0000 0000 0000 0000 0000

or $24,$24,$13 # Kalojm me OR $13 [rt] (destinacionin) tek regjistri yne $24 qe tani do te mari pamje akoma me te kompletuar :

# 0011 0101 0010 1000 (0000 0000 0000 0000) == IMM 😀

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

#Na ngelen vetem 16 bitet e vleres se menjehershme :D#

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

or $24,$24,$14 # Se fundmi fusim dhe vleren tone 0x0019 qe ne sistemin binar paraqitet me : 0000 0000 0001 1001

# Dhe pamja perfundimtare e regjistrit do jete:

# 0011 0101 0010 1000 0000 0000 0001 1001

ori $2, $0, 10 # Po vdis re Vdis 😛

syscall # Mbyllja e programit

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

# PERFUNDIM #

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

#ori $8,$9,0×0019 <===> 0x35280019 <===> 0011 0101 0010 1000 0000 0000 0001 1001 #

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