hacktricks/generic-methodologies-and-resources/python/basic-python.md

Python di base

{% hint style="success" %} Impara e pratica l'hacking su AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR a HackTricks e HackTricks Cloud repos di github.

{% endhint %}

Concetti di base di Python

Informazioni utili

list(xrange()) == range() --> In python3 range è l'equivalente di xrange in python2 (non è una lista ma un generatore)
La differenza tra una Tuple e una List è che la posizione di un valore in una tupla gli conferisce un significato, mentre le liste sono solo valori ordinati. Le tuple hanno strutture, ma le liste hanno un ordine.

Operazioni principali

Per elevare un numero si usa: 3**2 (non 3^2)
Se fai 2/3 restituisce 1 perché stai dividendo due interi (integers). Se vuoi decimali dovresti dividere float (2.0/3.0).
i >= j
i <= j
i == j
i != j
a and b
a or b
not a
float(a)
int(a)
str(d)
ord("A") = 65
chr(65) = 'A'
hex(100) = '0x64'
hex(100)[2:] = '64'
isinstance(1, int) = True
"a b".split(" ") = ['a', 'b']
" ".join(['a', 'b']) = "a b"
"abcdef".startswith("ab") = True
"abcdef".contains("abc") = True
"abc\n".strip() = "abc"
"apbc".replace("p","") = "abc"
dir(str) = Lista di tutti i metodi disponibili
help(str) = Definizione della classe str
"a".upper() = "A"
"A".lower() = "a"
"abc".capitalize() = "Abc"
sum([1,2,3]) = 6
sorted([1,43,5,3,21,4])

Unisci caratteri
3 * ’a’ = ‘aaa’
‘a’ + ‘b’ = ‘ab’
‘a’ + str(3) = ‘a3’
[1,2,3]+[4,5]=[1,2,3,4,5]

Parti di una lista
‘abc’[0] = ‘a’
'abc’[-1] = ‘c’
'abc’[1:3] = ‘bc’ da [1] a [2]
"qwertyuiop"[:-1] = 'qwertyuio'

Commenti
# Commento su una riga
"""
Commento su più righe
Un altro
"""

Loop

if a:
#somethig
elif b:
#something
else:
#something

while(a):
#comething

for i in range(0,100):
#something from 0 to 99

for letter in "hola":
#something with a letter in "hola"

Tuple

t1 = (1, '2', 'tre')
t2 = (5, 6)
t3 = t1 + t2 = (1, '2', 'tre', 5, 6)
(4,) = Singelton
d = () tupla vuota
d += (4,) --> Aggiunta in una tupla
NON POSSIBILE! --> t1[1] == 'Nuovo valore'
list(t2) = [5, 6] --> Da tupla a lista

Lista (array)

d = [] vuoto
a = [1, 2, 3]
b = [4, 5]
a + b = [1, 2, 3, 4, 5]
b.append(6) = [4, 5, 6]
tuple(a) = (1, 2, 3) --> Da lista a tupla

Dizionario

d = {} vuoto
monthNumbers={1:'Gen', 2: 'feb','feb':2}—> monthNumbers ->{1:'Gen', 2: 'feb','feb':2}
monthNumbers[1] = 'Gen'
monthNumbers['feb'] = 2
list(monthNumbers) = [1, 2, 'feb']
monthNumbers.values() = ['Gen', 'feb', 2]
keys = [k for k in monthNumbers]
a={'9':9}
monthNumbers.update(a) = {'9':9, 1:'Gen', 2: 'feb','feb':2}
mN = monthNumbers.copy() #Copia indipendente
monthNumbers.get('chiave',0) #Controlla se la chiave esiste, Restituisce il valore di monthNumbers["chiave"] o 0 se non esiste

Insieme

Negli insiemi non ci sono ripetizioni
myset = set(['a', 'b']) = {'a', 'b'}
myset.add('c') = {'a', 'b', 'c'}
myset.add('a') = {'a', 'b', 'c'} #Nessuna ripetizione
myset.update([1, 2, 3]) = set(['a', 1, 2, 'b', 'c', 3])
myset.discard(10) #Se presente, rimuovilo, altrimenti niente
myset.remove(10) #Se presente, rimuovilo, altrimenti genera un'eccezione
myset2 = set([1, 2, 3, 4])
myset.union(myset2) #Valori in myset O myset2
myset.intersection(myset2) #Valori in myset E myset2
myset.difference(myset2) #Valori in myset ma non in myset2
myset.symmetric_difference(myset2) #Valori che non sono in myset E myset2 (non in entrambi)
myset.pop() #Ottieni il primo elemento dell'insieme e rimuovilo
myset.intersection_update(myset2) #myset = Elementi in entrambi myset e myset2
myset.difference_update(myset2) #myset = Elementi in myset ma non in myset2
myset.symmetric_difference_update(myset2) #myset = Elementi che non sono in entrambi

Classi

Il metodo in __It__ sarà quello usato da sort per confrontare se un oggetto di questa classe è più grande di un altro

class Person(name):
def __init__(self,name):
self.name= name
self.lastName = name.split(‘ ‘)[-1]
self.birthday = None
def __It__(self, other):
if self.lastName == other.lastName:
return self.name < other.name
return self.lastName < other.lastName #Return True if the lastname is smaller

def setBirthday(self, month, day. year):
self.birthday = date tame.date(year,month,day)
def getAge(self):
return (date time.date.today() - self.birthday).days


class MITPerson(Person):
nextIdNum = 0	# Attribute of the Class
def __init__(self, name):
Person.__init__(self,name)
self.idNum = MITPerson.nextIdNum  —> Accedemos al atributo de la clase
MITPerson.nextIdNum += 1 #Attribute of the class +1

def __it__(self, other):
return self.idNum < other.idNum

map, zip, filter, lambda, sorted e one-liners

Map è simile a: [f(x) for x in iterable] --> map(tutple,[a,b]) = [(1,2,3),(4,5)]
m = map(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) --> [False, False, True, False, False, True, False, False, True]

zip si interrompe quando il più corto tra foo o bar si interrompe:

for f, b in zip(foo, bar):
print(f, b)

Lambda viene utilizzato per definire una funzione
(lambda x,y: x+y)(5,3) = 8 --> Utilizzare lambda come semplice funzione
sorted(range(-5,6), key=lambda x: x** 2) = [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Utilizzare lambda per ordinare una lista
m = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) = [3, 6, 9] --> Utilizzare lambda per filtrare
reduce (lambda x,y: x*y, [1,2,3,4]) = 24

def make_adder(n):
return lambda x: x+n
plus3 = make_adder(3)
plus3(4) = 7 # 3 + 4 = 7

class Car:
crash = lambda self: print('Boom!')
my_car = Car(); my_car.crash() = 'Boom!'

mult1 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x%3 == 0 ]

Eccezioni

def divide(x,y):
try:
result = x/y
except ZeroDivisionError, e:
print “division by zero!” + str(e)
except TypeError:
divide(int(x),int(y))
else:
print “result i”, result
finally
print “executing finally clause in any case”

Assert()

Se la condizione è falsa, la stringa verrà stampata a schermo

def avg(grades, weights):
assert not len(grades) == 0, 'no grades data'
assert len(grades) == 'wrong number grades'

Generatori, yield

Un generatore, invece di restituire qualcosa, "cede" qualcosa. Quando accedi ad esso, "restituirà" il primo valore generato, quindi potrai accedere nuovamente e restituirà il valore successivo generato. Quindi, tutti i valori non vengono generati contemporaneamente e si potrebbe risparmiare molta memoria utilizzando questo invece di una lista con tutti i valori.

def myGen(n):
yield n
yield n + 1

g = myGen(6) --> 6\
next(g) --> 7\
next(g) --> Errore

### Espressioni Regolari

import re\
re.search("\w","hola").group() = "h"\
re.findall("\w","hola") = \['h', 'o', 'l', 'a']\
re.findall("\w+(la)","hola caracola") = \['la', 'la']

**Significati speciali:**\
. --> Tutto\
\w --> \[a-zA-Z0-9\_]\
\d --> Numero\
\s --> Carattere spazio bianco\[ \n\r\t\f]\
\S --> Carattere non spazio bianco\
^ --> Inizia con\
$ --> Finisce con\
\+ --> Uno o più\
\* --> 0 o più\
? --> 0 o 1 occorrenze

**Opzioni:**\
re.search(pat,str,re.IGNORECASE)\
IGNORECASE\
DOTALL --> Consente al punto di corrispondere alla nuova riga\
MULTILINE --> Consente a ^ e $ di corrispondere in righe diverse

re.findall("<.\*>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>foo\</b>and\<i>so on\</i>']\
re.findall("<.\*?>", "\<b>foo\</b>and\<i>so on\</i>") = \['\<b>', '\</b>', '\<i>', '\</i>']

IterTools\
**product**\
from **itertools** import product --> Genera combinazioni tra 1 o più liste, forse ripetendo valori, prodotto cartesiano (proprietà distributiva)\
print list(**product**(\[1,2,3],\[3,4])) = \[(1, 3), (1, 4), (2, 3), (2, 4), (3, 3), (3, 4)]\
print list(**product**(\[1,2,3],repeat = 2)) = \[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]

**permutations**\
from **itertools** import **permutations** --> Genera combinazioni di tutti i caratteri in ogni posizione\
print list(permutations(\['1','2','3'])) = \[('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Ogni possibile combinazione\
print(list(permutations('123',2))) = \[('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Ogni possibile combinazione di lunghezza 2

**combinations**\
from itertools import **combinations** --> Genera tutte le possibili combinazioni senza ripetere i caratteri (se "ab" esiste, non genera "ba")\
print(list(**combinations**('123',2))) --> \[('1', '2'), ('1', '3'), ('2', '3')]

**combinations\_with\_replacement**\
from itertools import **combinations\_with\_replacement** --> Genera tutte le possibili combinazioni dal carattere in poi (ad esempio, il 3° è mescolato dal 3° in poi ma non con il 2° o il primo)\
print(list(**combinations\_with\_replacement**('1133',2))) = \[('1', '1'), ('1', '1'), ('1', '3'), ('1', '3'), ('1', '1'), ('1', '3'), ('1', '3'), ('3', '3'), ('3', '3'), ('3', '3')]

### Decoratori

Decoratore che misura il tempo necessario affinché una funzione venga eseguita (da [qui](https://towardsdatascience.com/decorating-functions-in-python-619cbbe82c74)):

from functools import wraps
import time
def timeme(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("Let's call our decorated function")
start = time.time()
result = func(*args, **kwargs)
print('Execution time: {} seconds'.format(time.time() - start))
return result
return wrapper

@timeme
def decorated_func():
print("Decorated func!")

Se esegui il codice, vedrai qualcosa di simile al seguente:

Let's call our decorated function
Decorated func!
Execution time: 4.792213439941406e-05 seconds

{% hint style="success" %} Impara e pratica l'hacking su AWS: HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica l'hacking su GCP: HackTricks Training GCP Red Team Expert (GRTE)

Sostieni HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repository di Github.

{% endhint %}