Rzadkością jest znalezienie dobrego anime, długiego jak rzeka, gdzie nawet fillery mogą wciągać. Taką pozycją to właśnie Detektyw Conan.
Historia moja z tym tytułem jest dość długa. Początkowo te anime widziałem na niemieckim programie, chyba RTL2 (już ponad 20 lat emitują różne anime na swoim kanale), później nastąpiła cisza, ale kreska i postacie zapamiętałem. Przypomnienie było, za czasów studiów, bo Conan pojawił się na AXN Sci-fi - już niestety nie ma nawet i kanału. Po wielu latach odświeżyłem i nadal oglądam ta serie dzięki stronie: www.meitantei-sekai.pl
Ogólnym tematem anime jest znajdowanie sprawcy zabójstwa, dodatkowo patrząc na główna linie fabularną, nasz główny bohater szuka sposobu i ludzi którzy go odmienili. Dokładniej stał się młodszy. Mógłbym się rozpisywać na ten temat więcej, ale nie robię recenzji anime tylko chce zachęcić was do niego.
Podsumowując anime Detektyw Conan jest ukryta perełką, którą ciężko znaleźć, ale jak już się znajdzie to zabawa jest przednia.
niedziela, 28 grudnia 2014
niedziela, 30 listopada 2014
Penetrujemy aplikacje napisane w języku C - narzedzie GDB
Tak jak pisałem ostatnio, dziś będę używał narzędzia GDB. Służy ono do analizowania kodu programów napisanych w C lub C++. Niestety jeżeli chodzi o składnie desasemblera to znam tylko Intela i nim będę się posługiwał i tym programie, co powoduje to że muszę je skonfigurować i to wygląda następująco:
gdb -q
(gdb) set disassembly-flavor intel
(gdb) quit
gdb -q ./a.out
Reading symbols from /home/domek/c/a.out...done.
(gdb) list
1 #include <stdio.h>
2
3 int main() {
4 int i;
5 for(i = 0; i < 10; i++) {
6 puts("Hello, world!\n");
7 }
8 return 0; // Informuje OS o zakonczeniu programu
9 }
(gdb) di
directory disable disassemble disconnect display
(gdb) dis
disable disassemble disconnect display
(gdb) disassemble main
Dump of assembler code for function main:
0x000000000040055c <+0>: push %rbp
0x000000000040055d <+1>: mov %rsp,%rbp
0x0000000000400560 <+4>: sub $0x10,%rsp
0x0000000000400564 <+8>: movl $0x0,-0x4(%rbp)
0x000000000040056b <+15>: jmp 0x40057b <main+31>
0x000000000040056d <+17>: mov $0x400634,%edi
0x0000000000400572 <+22>: callq 0x400440 <puts@plt>
0x0000000000400577 <+27>: addl $0x1,-0x4(%rbp)
0x000000000040057b <+31>: cmpl $0x9,-0x4(%rbp)
0x000000000040057f <+35>: jle 0x40056d <main+17>
0x0000000000400581 <+37>: mov $0x0,%eax
0x0000000000400586 <+42>: leaveq
0x0000000000400587 <+43>: retq
End of assembler dump.
(gdb) run
Starting program: /home/domek/c/a.out
Missing separate debuginfo for /lib64/ld-linux-x86-64.so.2
Try: zypper install -C "debuginfo(build-id)=ecb8ef1a6904a2a3ec60a527f415f520c8636158"
Missing separate debuginfo for /lib64/libc.so.6
Try: zypper install -C "debuginfo(build-id)=bd1473e8e6a4c10a14731b5be4b35b4e87db2af7"
Breakpoint 1, main () at zad1.c:5
5 for(i = 0; i < 10; i++) {
(gdb)
(gdb) break mian
Function "mian" not defined.
Make breakpoint pending on future shared library load? (y or [n]) y
Breakpoint 1 (mian) pending.
(gdb) run
Starting program: /home/domek/c/a.out
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
Hello, world!
[Inferior 1 (process 15408) exited normally]
(gdb) info registers eip
The program has no registers now.
(gdb)
break main
Breakpoint 1 at 0x400564: file zad1.c, line 5.
(gdb) x/x $rip
0x400564 <main+8>: 0x00fc45c7
(gdb) x/u $rip
0x400564 <main+8>: 16532935
(gdb) x/t $rip
0x400564 <main+8> 00000000111111000100010111000111
czwartek, 20 listopada 2014
Penetrujemy aplikacje napisane w języku C
Dziś wracam do podstaw programowania w języku C, lecz nie będzie to typowa nauka języka programowania. Aplikacje w języku C są kompilowane i składnia którą piszemy, musi być najpierw przetłumaczona na język maszynowy, gdzie zwykle programiści nie zaglądają. Ja będę tym złym i będę sprawdzał jak moje programy wyglądają od środka.
Początkowo skupie się na instrukcjach warunkowych, pętlach, mechanizmami wejścia i wyjścia itp. i nawet udowodnię moc wskaźników.
Początkowo zaczynam od prostego przykładu:
Teraz wracając do przykładu chciałbym pokazać jak można zajrzeć do skompilowanego programu i przeczytać jego zapis w języku maszynowym. Komputer, który użytkuje jest w architekturze x86 i pod tą architekturę będę pokazywał kod asemblera, a do tego posłuży mi narzędzie objdump. I ten prosty program wygląda u mnie tak.
Polecenie:
Objdump jest przydatnym narzędziem, jeśli chcę zobaczyć aplikacje w kodzie maszynowym, ale nie pomoże jeśli aplikacja zawiera błędy, w poszczególnych instrukcjach, czy też jeżeli sprawdzam odpowiedni fragment kodu aplikacji.
Na szczęście jest narzędzie idealne do większej analizy kody, przeznaczonej dla programistów, czy tez testerów penetracyjnych i zwie się gdb i tak to jest debuger, które omówię już w następnym poście.
Początkowo skupie się na instrukcjach warunkowych, pętlach, mechanizmami wejścia i wyjścia itp. i nawet udowodnię moc wskaźników.
Początkowo zaczynam od prostego przykładu:
#include <stdio.h>
int main() {
int i;
for(i = 0; i < 10; i++) {
puts("Hello, world!\n");
}
return 0; // Informuje OS o zakonczeniu programu
}
Teraz wracając do przykładu chciałbym pokazać jak można zajrzeć do skompilowanego programu i przeczytać jego zapis w języku maszynowym. Komputer, który użytkuje jest w architekturze x86 i pod tą architekturę będę pokazywał kod asemblera, a do tego posłuży mi narzędzie objdump. I ten prosty program wygląda u mnie tak.
Polecenie:
objdump -D zad1.o | grep -A20 main.:
0000000000000000 <main>:
0: 55 push %rbp
1: 48 89 e5 mov %rsp,%rbp
4: 48 83 ec 10 sub $0x10,%rsp
8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%rbp)
f: eb 0e jmp 1f <main+0x1f>
11: bf 00 00 00 00 mov $0x0,%edi
16: e8 00 00 00 00 callq 1b <main+0x1b>
1b: 83 45 fc 01 addl $0x1,-0x4(%rbp)
1f: 83 7d fc 09 cmpl $0x9,-0x4(%rbp)
23: 7e ec jle 11 <main+0x11>
25: b8 00 00 00 00 mov $0x0,%eax
2a: c9 leaveq
2b: c3 retq
Disassembly of section .rodata:
0000000000000000 <.rodata>:
0: 48 rex.W
1: 65 gs
2: 6c insb (%dx),%es:(%rdi)
objdump -M intel -D zad1.o | grep -A20 main.: 0000000000000000 <main>:
0: 55 push rbp
1: 48 89 e5 mov rbp,rsp
4: 48 83 ec 10 sub rsp,0x10
8: c7 45 fc 00 00 00 00 mov DWORD PTR [rbp-0x4],0x0
f: eb 0e jmp 1f <main+0x1f>
11: bf 00 00 00 00 mov edi,0x0
16: e8 00 00 00 00 call 1b <main+0x1b>
1b: 83 45 fc 01 add DWORD PTR [rbp-0x4],0x1
1f: 83 7d fc 09 cmp DWORD PTR [rbp-0x4],0x9
23: 7e ec jle 11 <main+0x11>
25: b8 00 00 00 00 mov eax,0x0
2a: c9 leave
2b: c3 ret
- mov - deklaruje zmienią do pamięci rdp-0x4 == 4,
- jmp - służy do przeskoków pamięci, call wykonuje odpowiedni rozkaz w tym przypadku wywołuje polecenie putsa,
- add - dodaje nam do zmiennej plus jeden,
- cmp - jest instrukcją porównania czy zmienna z pamięci rdp-0x4 jest równa 9 i później wykonanie tego warunku, a jak nie to wraca do punktu 0
Objdump jest przydatnym narzędziem, jeśli chcę zobaczyć aplikacje w kodzie maszynowym, ale nie pomoże jeśli aplikacja zawiera błędy, w poszczególnych instrukcjach, czy też jeżeli sprawdzam odpowiedni fragment kodu aplikacji.
Na szczęście jest narzędzie idealne do większej analizy kody, przeznaczonej dla programistów, czy tez testerów penetracyjnych i zwie się gdb i tak to jest debuger, które omówię już w następnym poście.
środa, 12 listopada 2014
Django + Rest = power cz3
Kolejny post o Django z RESTem, lecz tym razem już będę implementował prosty przykład. Postanowiłem zrobić prosty system wyświetlający pole do wypełnienia o użytkowniku, czyli wziąłem pierwszy i przykład ze stronki o RESTfulu z Django. Jestem w tej sprawie troszkę zielony, więc muszę zaczynać od prostych przykładów.
Początkowo skupie się od razu nad konfiguracją już przygotowanej struktury do tworzenia aplikacji MVC i tak jak już otworzyłem swoje Ninja IDE to przystępie od tworzenia nowego moduły o nazwie: serializers.py, . Poniżej jest pokazany kod tego pliku.
Brakuje mi jeszcze widoku, który powinien wyglądac tak:
Początkowo skupie się od razu nad konfiguracją już przygotowanej struktury do tworzenia aplikacji MVC i tak jak już otworzyłem swoje Ninja IDE to przystępie od tworzenia nowego moduły o nazwie: serializers.py, . Poniżej jest pokazany kod tego pliku.
1: from django.contrib.auth.models import User, Group
2: from rest_framework import serializers
3: """
4: This class define 3 fields
5: """
6: class UserSerializer(serializers.HyperlinkedModelSerializer):
7: class Meta:
8: model = User
9: fields = ('url', 'username', 'email', 'groups')
10: """
11: Bext class generate anotger fields ;)
12: """
13: class GroupSerializer(serializers.HyperlinkedModelSerializer):
14: class Meta:
15: model = Group
16: fields = ('url', 'name')
1: 'rest_framework',
1: REST_FRAMEWORK = {
2: 'DEFAULT_PERMISSION_CLASSES': ('rest_framework.permissions.IsAdminUser',),
3: 'PAGINATE_BY': 10
4: }
1: python ./manage.py runserver
1: from django.conf.urls import url, include
2: from django.contrib.auth.models import User
3: from rest_framework import routers, serializers, viewsets
4: # Serializers define the API representation.
5: class UserSerializer(serializers.HyperlinkedModelSerializer):
6: class Meta:
7: model = User
8: fields = ('url', 'username', 'email', 'is_staff')
9: # ViewSets define the view behavior.
10: class UserViewSet(viewsets.ModelViewSet):
11: queryset = User.objects.all()
12: serializer_class = UserSerializer
13: # Routers provide an easy way of automatically determining the URL conf.
14: router = routers.DefaultRouter()
15: router.register(r'users', UserViewSet)
16: # Wire up our API using automatic URL routing.
17: # Additionally, we include login URLs for the browseable API.
18: urlpatterns = [
19: url(r'^', include(router.urls)),
20: url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework'))
21: ]
1: from django.contrib.auth.models import User, Group
2: from rest_framework import viewsets
3: from tutorial.quickstart.serializers import UserSerializer, GroupSerializer
4: class UserViewSet(viewsets.ModelViewSet):
5: """
6: API endpoint that allows users to be viewed or edited.
7: """
8: queryset = User.objects.all()
9: serializer_class = UserSerializer
10: class GroupViewSet(viewsets.ModelViewSet):
11: """
12: API endpoint that allows groups to be viewed or edited.
13: """
14: queryset = Group.objects.all()
15: serializer_class = GroupSerializer
wtorek, 4 listopada 2014
Poznawanie PERLa
Trochę mi to trwało, by znów coś napisać - spowodowane to było ilością pracy. Teraz chciałbym napisać krótką niedzielo-poniedziałkową przygodę z językiem PERL i przerobiłem tylko podstawy by dowiedzieć i jak znajdę chwilę czasu to przejdę do obiektowej wersji tego języka i zbuduje jakiś mały serwis internetowy.
Przejdę teraz do języka PERL, jest o językiem skryptowym a w składni przypomina PHP, BASHa i nie upodabniał bym go do języków Python i Ruby, bo mają one znaczącą różnice (Python i Ruby są typowo obiektowymi językami, a PERL nie). Posiada tez pewne cechy języka C, ale nie będę się za wiele w tym wypowiadał i przejdę od razu do pokazania składni.
Pierwsze co rzuciło mi się w oczy to komentarze zbudowane z wielu linii.
Następnie bez czytania, na temat PERLa przeszedłem do praktykowania z nimi tak oto powstały poniższe programy - wybrałem tylko dwa, bo sprawdzałem też i CGI w PERlu, ale to opisze następnym razem.
Program1:
Kończę te narzekanie i stwierdzam, że mimo wielu dziwnych wynalazków PERL jest prostym w opanowaniu językiem to że nie ma wielu rozwiązań problemów, które możemy znaleźć w innych językach, nie oznacza że nie napiszemy porządnej, wydajnej i funkcjonalnej aplikacji. Niestety kończę moje wywody na temat języka PERL i jak znajdę chwilę, to pewnie znów coś o nim napisze.
Przejdę teraz do języka PERL, jest o językiem skryptowym a w składni przypomina PHP, BASHa i nie upodabniał bym go do języków Python i Ruby, bo mają one znaczącą różnice (Python i Ruby są typowo obiektowymi językami, a PERL nie). Posiada tez pewne cechy języka C, ale nie będę się za wiele w tym wypowiadał i przejdę od razu do pokazania składni.
Pierwsze co rzuciło mi się w oczy to komentarze zbudowane z wielu linii.
=comment
to jest długi komwntarz
=cut
Następnie bez czytania, na temat PERLa przeszedłem do praktykowania z nimi tak oto powstały poniższe programy - wybrałem tylko dwa, bo sprawdzałem też i CGI w PERlu, ale to opisze następnym razem.
Program1:
#!/usr/bin/perl
use warnings; use strict;
=comment
to jest długi komwntarz
=cut
print "Start programu\n";
print "Podaj liczbe całkowita niejuemną:";
my $zm = <STDIN>;
&bity($zm);
print "Podaj dzielnik:";
my $zm1 = <STDIN>;
my $ans = &nwd($zm,$zm1);
print $ans;
sub bity {
my $zmCal = $_[0];
my $i =0;
for(; $i < $zmCal; $i++) {
$i = 2*$i + $zmCal%2;
}
print "Odwrotna kolejnosc bitów to: ", $i;
print "\n";
}
# nwd
sub nwd {
my $m = $_[0];
my $n = $_[1];
my $r; # tmp memory
# lets play
while($n) {
$r = $m % $n;
$m = $n;
$n = $r;
}
return $m;
}
#!/usr/bin/perl
=comment
Aplikacja będzie przeliczac z liczby calkowitej dodatniej na adnotacje rzymską.
Do tego wykorzystam petle
=cut
use warnings; use strict;
#użyje tego :P
my @liczby = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1, 0) ;
#hmmm, teraz zrobię do tego algorytm
#na poczatku trzeba podac jakąs wartość :)
print "Podaj liczbe całkowita niejuemną:";
my $zm = <STDIN>;
=comment
zastanawiam sie nad sensownym rozwiazaniem
dajmy liczby: 1410, 2525
1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1
1 1 1
2 1 2 1
Wygląda na to, że trzeba to zrobić, przez dzielenie całkowite :)
=cut
print wylicz(\@liczby, $zm);
#ale to nie optymalne :(
sub wylicz {
my %rzymskie = (1000 => 'M', 900 => 'CM', 500 => 'D', 400 => 'CD', 100 => 'C',
90 => 'XC', 50 => 'L', 40 => 'XL', 10 => 'X', 9 => 'IX',
5 => 'V', 4 => 'IV', 1 => 'I');
# tak wyglada referencja o.O => dobrze, że perl nie ma wskazników :D
my $liczby2 = shift;
pop @$liczby2;
my $liczba = $_[0];
my $rest = 0;
my $rzym = "";
foreach my $zmienna (@$liczby2) {
$rest = int($liczba / $zmienna);
if($rest > 0) {
$liczba -= ($rest* $zmienna);
for(my $i = 0; $i < $rest; $i++) {
$rzym .= $rzymskie{$zmienna};
}
}
}
return $rzym;
}
my %rzymskieKończę te narzekanie i stwierdzam, że mimo wielu dziwnych wynalazków PERL jest prostym w opanowaniu językiem to że nie ma wielu rozwiązań problemów, które możemy znaleźć w innych językach, nie oznacza że nie napiszemy porządnej, wydajnej i funkcjonalnej aplikacji. Niestety kończę moje wywody na temat języka PERL i jak znajdę chwilę, to pewnie znów coś o nim napisze.
poniedziałek, 20 października 2014
Django + Rest = power cz2.
Dziś mam chwilę czasu na zapoznanie się z Ninja IDE, a później przejdę do stworzenia przykładu aplikacji RESTowej. Posiada całkiem inny układ niż Netbeans, a dodatkowo po uruchomieniu zużywa tylko 100 do 120 MB RAMu. Jest to dopiero wersja 2.3 przez co nie posiada wielu pluginów i nawet poniżej umieszczę, jakie standardowo są dostępne pokazując przy okazji wygląd aplikacji.
Instalator dodatków jest bardzo podobny do tego z Netbeansa, którego bardziej wole niż w Eclipse IDE - każdy może mieć swoje zdanie. Ja zainstaluje trzy pluginy - dwa z oficjalnego repozytorium i jedn wyszukany z komunikacyjnego repozytorium.
Po zainstalowaniu pluginów, wymagane jest dodatkowe uruchomienie aplikacji.. Po ponownym uruchomieniu pokazała mi się konsola błędu:
1: Traceback (most recent call last):
2: File "ninja_ide\core\plugin_manager.pyc", line 319, in load
3: File "ninja_ide\core\plugin_manager.pyc", line 297, in _load_module
4: PluginManagerException: Error loading "Git": No module named git
Przetestowałem dziś tworzenie projektu i ze względu na dużą ilość problemów - prawdopodobnie to wina Windowsa, a na Linuxie działa IDE i mam dwa rozwiązania:
- Tworzenie projektu z konsoli i otwieranie go w IDE
- Zmianę środowiska na np. Netbeansa i sprawdzić jak on zachowa się z tworzeniem aplki w Pythonie
czwartek, 16 października 2014
Django + Rest = power
Jak wskazuje tytuł, zaczynam przygodę z pythonem od strony web developingu. Wcześniej zajmowałem się od spraw sieciowych, ale trzeba w końcu zacząć coś nowego. Aktualnie siedzę na systemie Windows 7, wcześniej instalowałem pythona na Linuxie, teraz zobaczę jak to wygląda na tym środowisku, całą operacje będę opisywał w punktach.
- Instalacja Na stronie https://www.python.org/download widzę dwie wersje pythona (2 i 3), ja wybrałem wersje 3.4.2 bo wydaje mi się, ze fajnie pracować na najnowszej wersji języka. Instalacja przebiega bardzo prosto, więc nawet tego nie będę opisywał.
- Uruchomienie i instalowanie modułów Uruchomienie pythona to znów prosta rzecz, wystarczy dosłownie kliknąć na start, wybrać wszystkie programy a następnie python 3.4 i uruchamiamy program IDLE. Teraz przejdę do konkretnej sprawy, czyli django z restem, czyli po koleji:
- uruchamiam cmd.exe
- wpisuje:
pip install djangorestframework pip install markdown pip install django-filter pip install virtualenv - Prosty przykład Sprawdzam czy wszystko działa najpierw zacznę od uruchomienia zmiennych środowiskowych:
virtualenv env
piątek, 10 października 2014
Witam
Zawsze chciałem stworzyć jakąś super wypasiona stronkę, gdzie będę umieszczał moje pomysły. Graficznie jestem słaby, a w głowie miałem co jakiś czas coraz to nowszy wygląd strony. Koniec końców wykorzystałem konto utworzone na google i powstał oto ten prosty blog.
Co będę umieszczał na blogu:
- moje pomysły i rozwiązania w programowaniu, gdzie każdy kod umieszczony będzie na githubie
- konfiguracja sieci, oraz jak nimi zarządzać
- typowo subiektywne recenzje i przemyślenia co do anime
Subskrybuj:
Posty (Atom)