Kurs asemblera x86_64
Kurs asemblera x86_64 aka amd64 / 64bit
1. Co będzie potrzebne?
- kompilator NASM (link)
- linker, np. ld dostępny na każdym linuxie
VPN
VPN Na routerze Cisco
Ustawiamy zakresy adresów dla komputerów łączących się przez VPN i muszą być z poza zakresów lokalnych sieci VLAN
Wpisujemy adres WAN Routera i koniecznie użytkownika z grupy admin lub założyć grupę z opcją VPN na routerze i dodać użytkownika. Na początku można logować się na użytkownika CISCO
W właściwościach połączenia VPN w zakładce zabezpieczenia zezwolić na użycie hasła nieszyfrowanego PAP
Windows !0
Resetowanie hasła win10
Resetowanie zapomnianego hasła do systemu Windows 10 - www.soisk.pl
odpalamy komputer z zewnętrznego nośnika i wybieramy konsolę cmd
move D:\Windows\System32\sethc.exe D:\Windows\System32\sethc.exe.bak
copy D:\windows\system32\cmd.exe D:\windows\system32\sethc.exe
5xSHIFT
net user
net user użytkownik hasło
koniec ;)
odblokowanie konta administratora: net user Administrator /active:yes
dodanie zwykłego użytkownika do grupy administratorzy: net localgroup Administratorzy użytkownik /add
można dodać nowego użytkownika: net user użytkownik /add
open_suse_linux_423
-
Zmiana nazwy serwera
-
wchodzimy w terminalu w tryb root za pomocą komendy su -
-
instalujemy nano wpisując w terminal apt-get install nano
-
edytujemy plik /etc/hostname komendą nano /etc/hostname
-
zapisujemy plik klikając ctrl+O
-
opuszczamy nano za pomocą ctrl+X
-
Karty sieciowe(polecenia dot. obsługi)
-
komendą ip a sprawdzamy nazwy naszych interfejsów
- przechodzimy do folderu: cd /etc/sysconfig/network
-
kopiujemy kartę sieciową poleceniem cp ifcfg-lo ifcfg-nazwa_interfejsu
-
za pomocą komendy nano /etc/sysconfig/network/ifcfg-nazwa_interfejsu edytujemy plik konfiguracyjny karty sieciowej
-
wpisujemy kolejno parametry:
-
#nazwa_karty która będzie nam służyła żebyśmy mogli zidentyfikować kartę
-
IPADDR=wartość IP
-
NETMASK=wartość maski
-
BROADCAST=adres rozgłoszeniowy
-
zapisujemy klikając ctrl+O
-
opuszczamy edytor nano za pomocą ctrl+X
-
resetujemy kartę poleceniami ifdown nazwa_interfejsu, ifup nazwa_interfejsu
-
odpalamy win 10 ni testujemy połączenie pingiem
-
DHCP dhcp-serwer(polecenia dot. obsługi)
można także skorzystać z poniższego linku:
http://trener-it.pl/old/materialy/Linux_serwer_DHCP.pdf -
Zainstaluj dhcp-server: „apt-get install dhcp-server”
-
Edytuj plik konfiguracyjny „nano /etc/dhcpd.conf”
-
Usuń wszystko oprócz tego co na screen
-
Ustaw odpowiednie IP i konfiguracje
-
zapisz plik
-
Edytuj plik „nano /etc/sysconfig/dhcpd”
-
Wpisz nazwę interfejsu gdzie ma być DHCP (u mnie eth2)
-
zapisujemy
-
Restartujemy usługę „systemctl restart dhcpd”
- Dodajemy jeszczę nasz serwer do autostartu
systemctl enable dhcpd.service -
I działa jak talala, możemy testować na win 10 lub win 11
-
Samba(restart samby)
-
strona www apache(polecenia dot. obsługi)
-
ftp vsftp(polecenia dot. obsługi)
-
dodanie dysku fstab i montowanie dysku i formatowanie dysku
-
ip tables(nat)(polecenia dot. obsługi)
(polecenia dot. obsługi=uruchomienie, restart, edycja plików)
Kurs C++
Wprowadzenie.
Cześć! Ten kurs pomoże Ci zrozumieć jak programować bez żadnej wiedzy/doświadczenia.
Stworzyłem go dla osób które chcą się przygotować na egzamin z programowania i mam nadzieję że Tobie pomoże.
Autorzy kursu:
Jakub Pajor
mgr. Andrzej Pławecki
Czym jest C++? Bądź czym może być? To pytanie też sam sobie zadawałem i znalazłem odpowiedź. Jest to zmiana z języka jakiego widzimy na język C a potem na język asemblera i dopiero z asemblera na kod binarny. Schemat:
C++ -> C -> Asembler -> kod binarny
Stworzył go w 1983 roku Bjarne Stroustrup, poprzez ulepszenie języka C. Był to przełom w jego czasach. Jest on używany do dzisiaj, np. napisano w nim grę Counter Strike Global Offensive o której na pewno Słyszaleś/aś.
Kompilatory - czym są i ich rodzaje.
Kompilator to program który zamienia kod C++ na kod binarny. Tylko jak on działa? Krótko opiszę jak:
"tekst" dostaje parser który zamienia "tokeny" (np. '{' ) na polecenia dla kompilera.
Polecenia są zamieniane na język C a potem na język asemblera.
Na sam koniec Linker dosłownie scala pliki z kodem asemblera i zmienia na kod binarny, dodając biblioteki z jakich "korzysta" dany kod.
Rodzaje najważniejszych kompilatorów:
cross-compilery (cross-platoform-compiler) - kompilery które mogą kompilować na innej platformie niż są uruchomione
bootstrap compilery - kompilują w języku w którym są napisane
Najpopularniejsze compilery:
GCC - GNU Compiler Collection (cross-platform)
(link)
MSVC Compiler (bootstrap compiler)
(link)
Środowiska programowania.
Najpopularniejsze z nich:
- Dev-C++
(link)
- Code Blocks
(link)
- Microsoft Visual Studio
(link)
#1 Pierwsze kroki i zmienne
! zmienne !
double - zmienna z miejscami po przecinku
float - zmienna rzeczywista (podobna do double)
int - liczba całkowita
string - tekst
short - krótsza wersja int
long - dłuższa wersja int
char - pojedynczy znak
bool / boolean - zmienna bitowa (zawiera 1 albo 0)
Prosty program do wyświetlania tekstu:
////////////////////////////////////////
#include <iostream>
using namespace std;
int main() {
cout << "przykladowa wiadomosc\n";
return 0;
}
////////////////////////////////////////
#include <iostream> // definiujemy że używamy biblioteki "iostream"
using namespace std; // definiujemy że używamy namespace standard o skrócie std
int main() { // startowa funkcja i początek bloku
cout << "przykladowa wiadomosc"; // wyświetlamy przykładową wiadomość
return 0; // kończymy działanie programu statusem 0
} // koniec bloku startowej funkcji
Zadanie 1: Napisz program który wyświetli Twoje imię oraz nazwisko.
Zadanie 2: Napisz program który wyświetli Imiona całej klasy. Do tego zadania użyj tokenu '\n' do napisania w kolejnej linijce kodu.
Zadanie 3: Napisz program który wyświetli pole kwadratu o boku 7.
#2 Wyjście i wejście
std::cout // wyjście
std::cin // wejście
////////////////////////////////////////
int main() {
std::cout << "Wprowadz bok kwadratu: ";
double bok;
std::cin >> bok;
std::cout << "Pole kwadratu wynosi " << (bok * bok) << "\n";
}
////////////////////////////////////////
int main() {
std::cout << "Wprowadz bok kwadratu: "; // komunikat
double bok; // definiujemy zmienną o nazwie "bok"
std::cin >> bok; // zmienna "bok" przyjmuje wartość wprowadzoną przez użytkownika
std::cout << "Pole kwadratu wynosi " << (bok * bok) << "\n"; // komunikat oraz operacja mnożenia (bok * bok)
}
Zadanie 1: Napisz program który wyświetli pole trójkąta o boku N, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 2: Napisz program który wyświetli pole prostokąta o bokach N oraz H, gdzie N oraz H to liczby wprowadzone przez użytkownika
Zadanie 3: Napisz program który wyświetli liczbę 3 razy większą niż N, gdzie N to liczba wprowadzona przez użytkownika
#3 operacje matematyczne
operacje wbudowane:
- "+" - dodawanie
- "-" - odejmowanie
- "*" - mnożenie
- "/" - dzielenie
- "%" - reszta z dzielenia
wybrane operacje z biblioteki <math.h>:
- sin(X) - sinus X
- cos(X) - cosinus X
- tan(X) - tanges X
- sqrt(X) - pierwiastek 2. stopnia z X
Zadanie 1: Napisz program który wyświetli pole sześcianu o boku N, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 2: Napisz program który wyświetli pierwiastek 2. stopnia z N, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 3: Napisz program który wyświetli liczbę o tan(N) większą niż N, gdzie N to liczba wprowadzona przez użytkownika
#4 Operacje logiczne
operacje logiczne:
- znak większości/mniejszości, np.
if (X > Y) {
std::cout << "X jest wieksze niz Y";
}
- znak równości, np.
if (X == Y) {
std::cout << "X jest rowne Y";
}
- znak większości/mniejszości i równości, np.
if (X >= Y) {
std::cout << "X jest wieksze niz lub rowne Y";
}
Zadanie 1: Napisz program który wyświetli czy N jest większe niż 10, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 2: Napisz program który wyświetli czy N jest większe niż 20 i czy jest mniejsze niż 50, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 3: Napisz program który wyświetli czy N jest mniejsze lub równe 2137, gdzie N to liczba wprowadzona przez użytkownika
#5 zmienna string
Najciekawszą zmienną jest string - w skrócie tekst. Najczęstsze operacje w niej to:
- size() - długość tekstu
- pop_back() - usuwamy ostatnią literę
- operator "+=" - dodaje tekst do zmiennej string
Przykładowe zastosowanie zmiennej string:
int main() {
std::cout << "Wprowadz przykladowy tekst: ";
std::string tekst;
std::cin >> tekst;
std::cout << "Wprowadzony tekst to: \n" << tekst << "\n";
}
Zadanie 1: Napisz program który wyświetli N bez 4 ostatnich liter, gdzie N to tekst wprowadzony przez użytkownika
Zadanie 2: Napisz program który wyświetli długość M, gdzie N to tekst wprowadzony przez użytkownika
Zadanie 3: Napisz program który wyświetli słowa "dzień dobry" + N gdzie N to imię wprowadzone przez użytkownika
#6 Pętla for
Składnia pętli for :
for (zmienna; warunek; opcjonalna funkcja po wykonaniu jednego przejścia) {
}
Najczęściej używa się tego typu pętli:
for (int i = 0; i < n; i++) {
//todo
}
gdzie n to liczba powtórzeń.
Drugi (rzadziej używany) to:
for (zmienna x : vector zmiennych) {
//todo
}
W drugim typie pętli for nie trzeba definiować liczby powtórzeń, i można "zastosować" dany segment kodu dla każdej zmiennej w vectorze.
Zadanie 1: Napisz program który wyświetli N razy dowolny tekst, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 2: Napisz program który wyświetli N 50 razy, gdzie N to tekst wprowadzony przez użytkownika
Zadanie 3: Napisz program który wyświetli pierwsze 5 tekstów wprowadzonych przez użytkownika
#7 Pętla while i do while
składnia pętli while:
while (warunek) {
//todo
}
składnia pętli do while:
do {
//todo
} while (warunek);
przykład nieskończonej pętli while:
while (1) {
//todo
}
przykład nieskończonej pętli do while:
do {
//todo
} while (1);
Aby opuścić pętlę w dowolnym momencie należy użyć polecenia "break". Przykładowo, jeśli chcemy 10 razy powtórzyć kod w pętli, możemy użyć iteracji. Przykład iteracji:
zmienna++ - zmienna powiększa się o 1
zmienna-- - zmienna zmniejsza się o 1
Przykład zagadnienia z zastosowaniem pętli while:
int i = 0;
while (i < 10) {
//todo - kod
i++;
}
Przykład zagadnienia z zastosowaniem pętli do while:
int i = 0;
do {
//todo - kod
i++;
} while (i < 10);
Zadanie 1: Napisz program który wyświetli N razy dowolny tekst, gdzie N to liczba wprowadzona przez użytkownika
Zadanie 2: Napisz program który wyświetli N 50 razy, gdzie N to tekst wprowadzony przez użytkownika
Zadanie 3: Napisz program który będzie wyświetlać tekst wprowadzony przez użytkownika który można zmienić w każdym momencie
#8 Konsola oraz windows.h
system(polecenie) - używa polecenie z Windows Command Prompt (cmd)
#define _WIN32_WINNT 0x0500 - definiujemy wersje minimalną wersję windows'a na której można uruchomić aplikację, w tej definicji to Windows 2000
Wszystkie definicje:
- 0x0400 // Windows NT 4.0
- 0x0500 // Windows 2000
- 0x0501 // Windows XP
- 0x0502 // Windows Server 2003
- 0x0600 // Windows Vista
- 0x0600 // Windows Vista
- 0x0600 // Windows Server 2008
- 0x0600 // Windows Vista
- 0x0601 // Windows 7
- 0x0602 // Windows 8
- 0x0603 // Windows 8.1
- 0x0A00 // Windows 10
- 0x0A00 // Windows 10
HWND - obiekt okna w windows.h
struct - definicja struktury
RECT - struktura składająca się z 4 zmiennych long
Jeśli chcemy wyczyścić okno konsoli z tekstu:
system("cls");
Jeśli chcemy zapałzować program na czas następnego wejścia z klawiatury:
system("pause");
Przykładowo gdy chcemy zablokować możliwość zmiany wysokości i szerokości okna konsoli, należy użyć:
HWND console = GetConsoleWindow(); // bierzemy instancje okna konsoli jako zmienną console
SetWindowLong(console, GWL_STYLE, GetWindowLong(console, GWL_STYLE) & ~WS_MAXIMIZEBOX & ~WS_SIZEBOX); // wyłączamy możliwość zmainy wysokości i szerokości okna konsoli
RECT consoleRect;
GetWindowRect(console, &consoleRect); // ta funkcja zmienia wartości zmiennej consoleRect na wymiary okna konsoli
MoveWindow(console, consoleRect.left, consoleRect.top, 800, 600, TRUE); // zmieniamy wysokość i szerokość okna konsoli na 800x600 pikseli
Struktury:
Składnia struktury:
struct nazwa {
zmienne
};
Przykłady:
struct vector3d {
double x;
double y;
double z;
};
struct uczen {
std::string imie;
std::string nazwisko;
};
Czyszczenie konsoli:
FreeConsole();
Proste wyświetlanie tesktu przy użyciu windows.h (MessageBox):
MessageBox(0, "komunikat", "tytul", MB_OK);
Wyświetlanie tekstu przy użyciu funkcji MessageBox:
std::wstringstream ss;
ss << zmienna;
MessageBox(0, ss.str().c_str(), "tytul", MB_OK);
Zadanie 1: Napisz program który wyświetla tekst, kasując wcześniejszy
Zadanie 2: Napisz program który wyświetla strukturę składającą się z 5 dowolnych zmiennych
Zadanie 3: Napisz program który będzie wyświetlać tekst na MessageBox, wprowadzony przez użytkownika w konsoli
#9 std::string
Biblioteka: <string>
Podstawowe operatory/polecenia z std::string :
operator += // dodaje do std::string tekst
pop_back(); // usuwa ostatnią literę/char
c_str(); // konwertuje std::string do const char*
size(); // długość tekstu
clear(); // czyści cały tekst
Dołączanie dowolnej standardowej zmiennej do string:
Biblioteka: #include <sstream>
Przykładowe łączenie zmiennej w std::string
std::stringstream ss;
ss << zmienna;
std::string str = ss.str();
#10 klasy (class)
Klasy najczęściej służą do przechowywania danych w pamięci, przykładowo:
class uczen {
private: // funkcje i zmienne prywatne
std::string name;
std::string nazwisko;
public: // funkcje i zmienne publiczne
uczen() { // konstruktor w którym można zawrzeć operacje po stworzeniu klasy
name = "Andrzej";
}
void setName(std::string a) {
name = a;
}
void setNazwisko(std::string a) {
nazwisko = a;
}
std::string getNazwisko() {
return nazwisko;
}
std::string getName() {
return name;
}
}
Najczęściej klasy zawiera się w headerach a implementacje funkcji w plikach źródłowych, np:
[klasa.h]
class uczen {
private:
std::string name;
std::string nazwisko;
public:
uczen();
void setName(std::string a);
void setNazwisko(std::string a);
std::string getNazwisko();
std::string getName();
}
[klasa.cpp]
uczen::uczen() { // konstruktor
}
void uczen::setName(std::string a) { // przykładowa funkcja ustawiająca zmienną name na zmienną argumentową
name = a;
}
void uczen::setNazwisko(std::string a) {
nazwisko = a;
}
std::string uczen::getNazwisko() { // przykładowa funkcja zwrotna
return nazwisko;
}
std::string uczen::getName() {
return name;
}
#11 std::vector i tabele
std::vector jest listą w C++
Prosta tabela zmiennych 3x3 typu int:
int zmienne[3][3];
aby użyć / zmienić z tabeli o wymiarach NxN element XxZ, gdzie N, X, Z są dodatnie:
tabela[X - 1][Z - 1]
Biblioteka:
#include <vector>
konstruktor:
std::vector<typ_zmiennej> zmienna;
lub
std::vector<int> zmienna;
Używając std::vector nie musimy znać rozmiaru by dodać element na koniec, np.
std::vector<int> zmienna; // deklaracja
zmienna.push_back(5); // dodajemy 5 na sam koniec
Użycie zmiennej z vectora vec z indexem N:
vec[N]
#12 kółko i krzyżyk
////////////////////////////////////////
#include <iostream>
#include <string>
char mem[9]; // tabela
int input; // index wybranego pola
bool player; // "kogo jest tura"
std::string player1; // imie gracza 1
std::string player2; // imie gracza 2
char winner = ' '; // kod gracza który wygrał
void printCmd() { // wyświetlanie
std::cout << "\n\n";
std::cout << " [" << mem[0] << "|1] [" << mem[1] << "|2] [" << mem[2] << "|3]\n\n";
std::cout << " [" << mem[3] << "|4] [" << mem[4] << "|5] [" << mem[5] << "|6]\n\n";
std::cout << " [" << mem[6] << "|7] [" << mem[7] << "|8] [" << mem[8] << "|9]\n\n";
std::cout << " \n";
std::cout << "Kolej gracza: [" << (player == true ? player1 : player2) << "]\n\n[1-9]>";
}
void tick() { // funkcja w której dostajemy wejście z konsoli od gracza
std::cin >> input;
if (input < 1 || input >> 9) {
std::cout << "\nWybierz liczbe od 1 do 9!\n";
return;
}
input--;
if (mem[input] != ' ') {
std::cout << "\nTo pole juz zawiera znak [" << (player == true ? "X" : "O") << "]!\n";
return;
}
if (player) {
mem[input] = 'X';
} else {
mem[input] = 'O';
}
player = !player;
}
void printWin() { // wyświetlamy zwycięzce
std::cout << "\n\n\n";
std::cout << "Wygral: " << (winner == 'X' ? player1 : player2) << "\n\n";
system("pause");
exit(0);
}
void win(char p) {
winner = p;
}
bool isWin() { // strawdzamy czy ktoś nie wygrał
// X X X
// 0 0 0
// 0 0 0
if (mem[0] == mem[1] && mem[1] == mem[2] && mem[0] != ' ') {
win(mem[0]);
return true;
}
// 0 0 0
// X X X
// 0 0 0
if (mem[3] == mem[4] && mem[4] == mem[5] && mem[3] != ' ') {
win(mem[3]);
return true;
}
// 0 0 0
// 0 0 0
// X X X
if (mem[6] == mem[7] && mem[7] == mem[8] && mem[6] != ' ') {
win(mem[6]);
return true;
}
//
// X 0 0
// X 0 0
// X 0 0
if (mem[0] == mem[3] && mem[3] == mem[6] && mem[0] != ' ') {
win(mem[0]);
return true;
}
// 0 X 0
// 0 X 0
// 0 X 0
if (mem[1] == mem[4] && mem[4] == mem[5] && mem[1] != ' ') {
win(mem[1]);
return true;
}
// 0 0 X
// 0 0 X
// 0 0 X
if (mem[2] == mem[5] && mem[5] == mem[8] && mem[2] != ' ') {
win(mem[2]);
return true;
}
//
// X 0 0
// 0 X 0
// 0 0 X
if (mem[0] == mem[4] && mem[4] == mem[8] && mem[0] != ' ') {
win(mem[0]);
return true;
}
// 0 0 X
// 0 X 0
// X 0 0
if (mem[2] == mem[4] && mem[4] == mem[6] && mem[2] != ' ') {
win(mem[1]);
return true;
}
//
return false;
}
int main() {
system("title Kolko i krzyzyk");
for (int i = 0; i < 9; i++) {
mem[i] = ' ';
}
std::cout << "Imie gracza 1 [X]: ";
std::cin >> player1;
std::cout << "Imie gracza 2 [O]: ";
std::cin >> player2;
printCmd();
while (true) {
isWin();
if (winner != ' ') {
printWin();
break;
}
if (mem[0] != ' ' && mem[1] != ' ' && mem[2] != ' ' && mem[3] != ' ' && mem[4] != ' ' && mem[5] != ' ' && mem[6] != ' ' && mem[7] != ' ' && mem[8] != ' ') {
std::cout << "\n\nREMIS!\n";
system("Pause");
break;
}
tick();
printCmd();
}
return 0;
}
////////////////////////////////////////