Basic Python

Lernen & üben Sie AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lernen & üben Sie GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstützen Sie HackTricks

• Überprüfen Sie die Abonnementpläne!

• Treten Sie der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folgen Sie uns auf Twitter 🐦 @hacktricks_live.

• Teilen Sie Hacking-Tricks, indem Sie PRs an die HackTricks und HackTricks Cloud GitHub-Repos senden.

Python Grundlagen

Nützliche Informationen

list(xrange()) == range() --> In Python 3 ist range das xrange von Python 2 (es ist keine Liste, sondern ein Generator) Der Unterschied zwischen einem Tuple und einer Liste besteht darin, dass die Position eines Wertes in einem Tuple ihm Bedeutung verleiht, während Listen nur geordnete Werte sind. Tuples haben Strukturen, aber Listen haben eine Reihenfolge.

Hauptoperationen

Um eine Zahl zu potenzieren, verwenden Sie: 3**2 (nicht 3^2) Wenn Sie 2/3 machen, gibt es 1 zurück, weil Sie zwei ints (Ganzzahlen) dividieren. Wenn Sie Dezimalzahlen möchten, sollten Sie Floats dividieren (2.0/3.0). i >= j i <= j i == j i != j a und b a oder b nicht 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) = Liste aller verfügbaren Methoden help(str) = Definition der Klasse str "a".upper() = "A" "A".lower() = "a" "abc".capitalize() = "Abc" sum([1,2,3]) = 6 sorted([1,43,5,3,21,4])

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

Teile einer Liste ‘abc’[0] = ‘a’ 'abc’[-1] = ‘c’ 'abc’[1:3] = ‘bc’ von [1] bis [2] "qwertyuiop"[:-1] = 'qwertyuio'

Kommentare # Einzeiliger Kommentar """ Mehrzeiliger Kommentar Ein weiterer """

Schleifen

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"

Tuples

t1 = (1,'2,'three') t2 = (5,6) t3 = t1 + t2 = (1, '2', 'three', 5, 6) (4,) = Singleton d = () leeres Tuple d += (4,) --> Hinzufügen zu einem Tuple CANT! --> t1[1] == 'Neuer Wert' list(t2) = [5,6] --> Von Tuple zu Liste

List (array)

d = [] leer 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) --> Von Liste zu Tuple

Dictionary

d = {} leer monthNumbers={1:’Jan’, 2: ‘feb’,’feb’:2}—> monthNumbers ->{1:’Jan’, 2: ‘feb’,’feb’:2} monthNumbers[1] = ‘Jan’ monthNumbers[‘feb’] = 2 list(monthNumbers) = [1,2,’feb’] monthNumbers.values() = [‘Jan’,’feb’,2] keys = [k for k in monthNumbers] a={'9':9} monthNumbers.update(a) = {'9':9, 1:’Jan’, 2: ‘feb’,’feb’:2} mN = monthNumbers.copy() #Unabhängige Kopie monthNumbers.get('key',0) #Überprüfen, ob der Schlüssel existiert, Rückgabewert von monthNumbers["key"] oder 0, wenn er nicht existiert

Set

In Mengen gibt es keine Wiederholungen myset = set(['a', 'b']) = {'a', 'b'} myset.add('c') = {'a', 'b', 'c'} myset.add('a') = {'a', 'b', 'c'} #Keine Wiederholungen myset.update([1,2,3]) = set(['a', 1, 2, 'b', 'c', 3]) myset.discard(10) #Wenn vorhanden, entfernen, wenn nicht, nichts myset.remove(10) #Wenn vorhanden, entfernen, wenn nicht, Ausnahme auslösen myset2 = set([1, 2, 3, 4]) myset.union(myset2) #Werte in myset ODER myset2 myset.intersection(myset2) #Werte in myset UND myset2 myset.difference(myset2) #Werte in myset, aber nicht in myset2 myset.symmetric_difference(myset2) #Werte, die nicht in myset UND myset2 sind (nicht in beiden) myset.pop() #Erhalte das erste Element der Menge und entferne es myset.intersection_update(myset2) #myset = Elemente in sowohl myset als auch myset2 myset.difference_update(myset2) #myset = Elemente in myset, aber nicht in myset2 myset.symmetric_difference_update(myset2) #myset = Elemente, die nicht in beiden sind

Classes

Die Methode in __It__ wird diejenige sein, die von sort verwendet wird, um zu vergleichen, ob ein Objekt dieser Klasse größer ist als ein anderes

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 und Einzeiler

Map ist wie: [f(x) für 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 stoppt, wenn das kürzere von foo oder bar stoppt:

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

Lambda wird verwendet, um eine Funktion zu definieren (lambda x,y: x+y)(5,3) = 8 --> Verwende lambda als einfache Funktion sorted(range(-5,6), key=lambda x: x** 2) = [0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5] --> Verwende lambda, um eine Liste zu sortieren m = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9]) = [3, 6, 9] --> Verwende lambda, um zu filtern 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 ]

Ausnahmen

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()

Wenn die Bedingung falsch ist, wird der String auf dem Bildschirm ausgegeben.

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

Generatoren, yield

Ein Generator gibt anstelle von etwas zurück, dass er etwas "yielded". Wenn Sie darauf zugreifen, gibt er den ersten generierten Wert "zurück", dann können Sie erneut darauf zugreifen und er gibt den nächsten generierten Wert zurück. So werden nicht alle Werte gleichzeitig generiert, und es kann viel Speicher gespart werden, wenn man dies anstelle einer Liste mit allen Werten verwendet.

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

g = myGen(6) --> 6 next(g) --> 7 next(g) --> Fehler

Reguläre Ausdrücke

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

Spezielle Bedeutungen: . --> Alles \w --> [a-zA-Z0-9_] \d --> Zahl \s --> Leerzeichen char[ \n\r\t\f] \S --> Nicht-Leerzeichen char ^ --> Beginnt mit $ --> Endet mit + --> Eins oder mehr * --> 0 oder mehr ? --> 0 oder 1 Vorkommen

Optionen: re.search(pat,str,re.IGNORECASE) IGNORECASE DOTALL --> Erlaubt, dass Punkt Zeilenumbruch übereinstimmt MULTILINE --> Erlaubt, dass ^ und $ in verschiedenen Zeilen übereinstimmen

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 --> Generiert Kombinationen zwischen 1 oder mehr Listen, möglicherweise wiederholte Werte, kartesisches Produkt (distributive Eigenschaft) 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 --> Generiert Kombinationen aller Zeichen in jeder Position print list(permutations(['1','2','3'])) = [('1', '2', '3'), ('1', '3', '2'), ('2', '1', '3'),... Jede mögliche Kombination print(list(permutations('123',2))) = [('1', '2'), ('1', '3'), ('2', '1'), ('2', '3'), ('3', '1'), ('3', '2')] Jede mögliche Kombination der Länge 2

combinations from itertools import combinations --> Generiert alle möglichen Kombinationen ohne wiederholte Zeichen (wenn "ab" existiert, wird "ba" nicht generiert) print(list(combinations('123',2))) --> [('1', '2'), ('1', '3'), ('2', '3')]

combinations_with_replacement from itertools import combinations_with_replacement --> Generiert alle möglichen Kombinationen ab dem Zeichen (zum Beispiel, die 3. wird ab der 3. gemischt, aber nicht mit der 2. oder 1.) 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')]

Dekoratoren

Dekorator, der die Zeit misst, die eine Funktion benötigt, um ausgeführt zu werden (von hier):

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!")

Wenn Sie es ausführen, werden Sie etwas sehen, das wie folgt aussieht:

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

Lerne & übe AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Lerne & übe GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Unterstütze HackTricks

• Überprüfe die Abonnementpläne!

• Tritt der 💬 Discord-Gruppe oder der Telegram-Gruppe bei oder folge uns auf Twitter 🐦 @hacktricks_live.

• Teile Hacking-Tricks, indem du PRs zu den HackTricks und HackTricks Cloud GitHub-Repos einreichst.