Eine Studie über ein vages Verhalten

Einführung

• unbestimmtes Verhalten scheint aufgrund der Abstraktheit der möglichen Konsequenzen nicht gefährlich genug zu sein;
• Es ist nicht immer klar, wo sich die Linie befindet.

Standard lesen

6.6.3 Die return-Anweisung
... Das Abfließen
am Ende einer Funktion entspricht einer Rückgabe ohne Wert. Dies führt zu einem undefinierten
Verhalten in einer Wertrückgabefunktion.
...

Das Erreichen des Endes einer Funktion entspricht einer Rückgabe ohne Rückgabewert. Für eine Funktion, deren Rückgabewert angegeben ist, führt dies zu undefiniertem Verhalten.

9.6.3 Die return-Anweisung
... Das Abfließen
des Endes eines Konstruktors, eines Destruktors oder einer Funktion mit dem Rückgabetyp cv void entspricht einer Rückgabe ohne Operanden. Andernfalls führt das Abfließen des Endes einer anderen Funktion als main (6.8.3.1) zu undefiniertem Verhalten.
...

Das Erreichen des Endes eines Konstruktors, Destruktors oder einer Funktion mit einem ungültigen Rückgabewert (möglicherweise mit const- und flüchtigen Qualifikationsmerkmalen) entspricht einer Rückgabe ohne Rückgabewert. Bei allen anderen Funktionen führt dies zu undefiniertem Verhalten (mit Ausnahme der Hauptfunktion).

• Die Ausführung sollte mit einer return-Anweisung mit einer Instanz des entsprechenden Typs enden.
• ansonsten vages Verhalten;
• undefiniertes Verhalten beginnt nicht ab dem Moment, in dem die Funktion aufgerufen wird, und nicht ab dem Moment, an dem der zurückgegebene Wert verwendet wird, sondern ab dem Moment, an dem die Funktion nicht ordnungsgemäß abgeschlossen wird.
• Wenn die Funktion sowohl korrekte als auch falsche Ausführungspfade enthält, tritt undefiniertes Verhalten nur bei falschen Pfaden auf.
• Das fragliche undefinierte Verhalten hat keinen Einfluss auf die Ausführung von Anweisungen, die im Hauptteil der Funktion enthalten sind.

Beispiel 1 - bool

#include <iostream>

bool bad() {};

int main()
{
    std::cout << bad();

    return 0;
}

#include <iostream>
#include <stdlib.h>

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    std::cout << bad();

    return 0;
}

Linux x86-x64 Clang 10.0.0, -O0

UD2—Undefined Instruction
Generates an invalid opcode exception. This instruction is provided for software testing to explicitly generate an invalid opcode exception. The opcode for this instruction is reserved for this purpose.
Other than raising the invalid opcode exception, this instruction has no effect on processor state or memory.

Even though it is the execution of the UD2 instruction that causes the invalid opcode exception, the instruction pointer saved by delivery of the exception references the UD2 instruction (and not the following instruction).

This instruction’s operation is the same in non-64-bit modes and 64-bit mode.

Linux x86-x64 Clang 10.0.0, -O1, -O2

Linux x86-x64 gcc 9.3, -O0

Linux x86-x64 gcc 9.3, -O1, -O2, -O3

macOs X Apple klirrte Version 11.0.0, -O0

macOs X Apple Clang Version 11.0.0, -O1, -O2

Windows MSVC 2019 16.5.4, Erweitertes Beispiel, / Od

Windows MSVC 2019 16.5.4 Kompliziertes Beispiel, / O1, / O2

• kopiert ein Byte von ebx aus dem Speicher bei [rsp + 30h];
• Wenn rand () Null zurückgibt, kopieren Sie die Einheit von ecx nach ebx (Zeile 11).
• kopiert den gleichen Wert nach dl (genauer gesagt das niedrigstwertige Byte) (Zeile 13);
• ruft die Ausgabefunktion in stream auf, die den dl-Wert ausgibt (Zeile 14).

Die Schlussfolgerung von Beispiel 1

Beispiel 1a - Verwalten von undefiniertem Verhalten

Linux x86-x64 gcc 9.3, -O0

#include <iostream>

bool bad() {}

bool goodTrue()
{
    return rand();
}

bool goodFalse()
{
    return !goodTrue();
}

unsigned char goodChar(unsigned char ch)
{
    return ch;
}

int main()
{
    goodTrue();
    std::cout << bad() << std::endl;

    goodChar(85);
    std::cout << bad() << std::endl;

    goodFalse();
    std::cout << bad() << std::endl;

    goodChar(240);
    std::cout << bad() << std::endl;

    return 0;
}

1
85
0
240

Windows MSVC 2019 16.5.4, / Od

#include <iostream>
#include <stdlib.h>

void control(unsigned char value)
{
    uint32_t count = 0;
    srand(0);
    while ((rand() & 0xff) != value) {
        ++count;
    }

    srand(0);
    for (uint32_t i = 0; i < count; ++i) {
        rand();
    }
}

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    control(1);
    std::cout << bad() << std::endl;

    control(85);
    std::cout << bad() << std::endl;

    control(0);
    std::cout << bad() << std::endl;

    control(240);
    std::cout << bad() << std::endl;

    return 0;
}

1
85
0
240

Windows MSVC 2019 16.5.4, / O1, / O2

#include <iostream>
#include <stdlib.h>

bool bad()
{
  if (rand() == 0) {
    return true;
  }
}

int main()
{
  volatile unsigned char ch = 1;
  std::cout << bad() << std::endl;

  ch = 85;
  std::cout << bad() << std::endl;

  ch = 0;
  std::cout << bad() << std::endl;

  ch = 240;
  std::cout << bad() << std::endl;

  return 0;
}

1
85
0
240

macOs X Apple klirrte Version 11.0.0, -O0

#include <iostream>

bool bad() {}

void putToStack(uint8_t value)
{
    uint8_t memory[1]{value};
}

int main()
{
    putToStack(20);
    std::cout << bad() << std::endl;

    putToStack(55);
    std::cout << bad() << std::endl;

    putToStack(0xfe);
    std::cout << bad() << std::endl;

    putToStack(11);
    std::cout << bad() << std::endl;

    return 0;
}

0
1
0
1

Die Schlussfolgerung von Beispiel 1a

Beispiel 1b - gebrochener Bool

Windows MSVC 2019 16.5.4, / Od

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
    if (rand() == 0) {
        return true;
    }
}

int main()
{
    bool badBool1 = bad();
    bool badBool2 = bad();

    std::cout << "badBool1: " << badBool1 << std::endl;
    std::cout << "badBool2: " << badBool2 << std::endl;

    if (badBool1) {
      std::cout << "if (badBool1): true" << std::endl;
    } else {
      std::cout << "if (badBool1): false" << std::endl;
    }
    if (!badBool1) {
      std::cout << "if (!badBool1): true" << std::endl;
    } else {
      std::cout << "if (!badBool1): false" << std::endl;
    }

    std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
              << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
              << std::endl;
    std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
              << std::set<bool>{badBool1, badBool2, true, false}.size()
              << std::endl;
    std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
              << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
              << std::endl;

    return 0;
}

badBool1: 41
badBool2: 35
if (badBool1): true
if (! badBool1): false
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , true, false} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

• Vergleichsoperatoren für boolesche Werte;
• Hash-Funktion des Booleschen Wertes.

Windows MSVC 2019 16.5.4, / O1, / O2

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
  if (rand() == 0) {
    return true;
  }
}

int main()
{
  volatile unsigned char ch = 213;
  bool badBool1 = bad();
  ch = 137;
  bool badBool2 = bad();

  std::cout << "badBool1: " << badBool1 << std::endl;
  std::cout << "badBool2: " << badBool2 << std::endl;

  if (badBool1) {
    std::cout << "if (badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (badBool1): false" << std::endl;
  }
  if (!badBool1) {
    std::cout << "if (!badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (!badBool1): false" << std::endl;
  }

  std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
    << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
    << std::endl;
  std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;
  std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;

  return 0;
}

badBool1: 213
badBool2: 137
if (badBool1): true
if (! badBool1): false
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , true, false} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

Linux x86-x64 gcc 9.3, -O0

#include <iostream>
#include <stdlib.h>
#include <set>
#include <unordered_set>

bool bad()
{
}

unsigned char goodChar(unsigned char ch)
{
  return ch;
}

int main()
{
  goodChar(213);
  bool badBool1 = bad();

  goodChar(137);
  bool badBool2 = bad();

  std::cout << "badBool1: " << badBool1 << std::endl;
  std::cout << "badBool2: " << badBool2 << std::endl;

  if (badBool1) {
    std::cout << "if (badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (badBool1): false" << std::endl;
  }
  if (!badBool1) {
    std::cout << "if (!badBool1): true" << std::endl;
  }
  else {
    std::cout << "if (!badBool1): false" << std::endl;
  }

  std::cout << "(badBool1 == true || badBool1 == false || badBool1 == badBool2): "
    << std::boolalpha << (badBool1 == true || badBool1 == false || badBool1 == badBool2)
    << std::endl;
  std::cout << "std::set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;
  std::cout << "std::unordered_set<bool>{badBool1, badBool2, true, false}.size(): "
    << std::unordered_set<bool>{badBool1, badBool2, true, false}.size()
    << std::endl;

  return 0;
}

badBool1: 213
badBool2: 137
if (badBool1): true
if (! badBool1): true
(badBool1 == true || badBool1 == false || badBool1 == badBool2): false
std :: set <bool> {badBool1, badBool2 , true, false} .size (): 4
std :: unordered_set <bool> {badBool1, badBool2, true, false} .size (): 4

Die Schlussfolgerung von Beispiel 1b

Beispiel 2 - Struktur

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == 1) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();
    std::cout << "rnd: " << rnd << std::endl;

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

• In einigen Fällen wurde die Ausführung fortgesetzt, ohne den Konstruktor aufzurufen. In diesem Fall befand sich das Objekt in einem zufälligen Zustand.
• In anderen Fällen war auf dem Ausführungspfad kein Konstruktoraufruf vorgesehen, was ziemlich seltsam ist.

Linux x86-x64 Clang 10.0.0, -O1, -O2

• Wenn die zweite Bedingung erfüllt ist, müssen Sie den Konstruktor Test mit dem Argument 142 aufrufen.
• Wenn die zweite Bedingung nicht erfüllt ist, wird die Funktion beendet, ohne einen Wert zurückzugeben. Dies bedeutet ein undefiniertes Verhalten, bei dem der Compiler alles tun kann. Einschließen - denselben Konstruktor mit demselben Argument aufrufen;
• Die Überprüfung ist überflüssig. Der Testkonstruktor mit dem Argument 142 kann aufgerufen werden, ohne die Bedingung zu überprüfen.

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == rand()) {
        return {142};
    }
}

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
    if (v == 0) {
        return {42};
    } else if (v == rand()) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();
    std::cout << "rnd: " << rnd << std::endl;

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

Windows MSVC 2019 16.5.4, / Od / RTCs

• Ausfüllen einer Variablen, deren Adresse durch das rcx-Register geleitet wird (hier sehen wir RVO in Aktion);
• Rückgabe der Adresse dieser Variablen über das Rax-Register.

• In eax wird der Wert 0xCCCCCCCC eingegeben, den wir in der Zugriffsverletzungsnachricht (Zeile 9) gesehen haben (beachten Sie, dass es nur 4 Bytes sind, während in der AccessViolation-Nachricht die Adresse aus 8 Bytes besteht).
• Der Befehl rep stos wird aufgerufen und führt 0xC-Zyklen aus, in denen der Inhalt von eax ausgehend von der Adresse rdi (Zeile 10) in den Speicher geschrieben wird. Dies sind 48 Bytes - genau so viel, wie auf dem Stapel in Zeile 6 zugewiesen ist.
• auf den korrekten Ausführungspfaden wird der Wert von rsp + 40h in rax eingegeben (Zeilen 23, 36);
• der Wert des rcx-Registers (durch das main () die Zieladresse übergeben hat) wird bei rsp + 8 (Zeile 4) auf den Stapel geschoben;
• rdi wird auf den Stapel geschoben, wodurch rsp um 8 reduziert wird (Zeile 5);
• 30h Bytes werden auf dem Stapel durch Verringern von rsp zugewiesen (Zeile 6).

• Nullen im oberen Teil der Adresse - es könnte Müll geben;
• Die Adresse hat sich versehentlich als falsch herausgestellt.

Beispiel 2a

Windows MSVC 2019 16.5.4, / Od / RTCs

#include <iostream>
#include <stdlib.h>

struct Test
{
    Test(uint64_t v)
        : value(v)
    {
        std::cout << "Test::Test(" << v << ")" << std::endl;
    }
    ~Test()
    {
        std::cout << "Test::~Test()" << std::endl;
    }

    uint64_t value;
};

Test bad(int v)
{
  std::cout << "rnd: " << v << std::endl;
  
  if (v == 0) {
        return {42};
    } else if (v == 1) {
        return {142};
    }
}

int main()
{
    const auto rnd = rand();

    std::cout << bad(rnd).value << std::endl;

    return 0;
}

rnd: 41
8791039331928
Test :: ~ Test ()

Fazit

• Sammeln Sie ungefähr 10 verschiedene Manifestationen unbestimmten Verhaltens.
• Erfahren Sie im Detail genau, wie diese Optionen ausgeführt werden.