Doporučené postupy v programování - Defenzivní programování

# Příklad: problémy s řetězcovými parametry

## Directory traversal (PHP) – problém

```php bad-code stretch
        <?php
          define ("TEMPLATE_DIR", "/home/users/phpguru/templates");
          define ("DEFAULT_TEMPLATE", "blue.tpl");

if (isset ($_COOKIE ['TEMPLATE'])) {
            $template = $_COOKIE ['TEMPLATE'];
          } else {
            $template = DEFAULT_TEMPLATE;
          }

include (TEMPLATE_DIR . "/" . $template);
          ...
        ?>
        ```

## SQL injection (Java) – problém

```java bad-code stretch
        ...
        String formName = httpRequest.getFormField ("name");
        ...
        Statement statement = connection.createStatement ();
        ResultSet resultSet = statement.executeQuery (
          "SELECT email FROM member WHERE name = '"+ formName +"';");
        ...
        ```

Note:

Příklady pochází z [Wikipedie](http://en.wikipedia.org/wiki/Directory_traversal)
        a z článku Steve Friedla [SQL Injection Attacks by Example](http://www.unixwiz.net/techtips/sql-injection.html).

# Příklad: problémy s řetězcovými parametry

## Directory traversal (PHP) – řešení

```php good-code stretch
        <?php
          define ("TEMPLATE_DIR", "/home/users/phpguru/templates");
          define ("DEFAULT_TEMPLATE", "blue");

$templateMap = array ("blue" => "blue.tpl", "green" => "green.tpl", ...);

if (isset ($_COOKIE ['TEMPLATE'])) {
            $template = $_COOKIE ['TEMPLATE'];
          }
          if (empty ($template)) {
            $template = DEFAULT_TEMPLATE;
          }

include (TEMPLATE_DIR . "/" . $templateMap [$template]);
          ...
        ?>
        ```

## SQL injection (Java) – řešení

```java good-code stretch
        ...
        String formName = httpRequest.getFormField ("name");
        ...
        PreparedStatement preparedStatement = connection.prepareStatement (
          "SELECT email FROM member WHERE name = ?");
        preparedStatement.setString (1, formName);
        ResultSet resultSet = preparedStatement.executeQuery ();
        ...
        ```

Note:

Kontrola správnosti u řetězců může být obzvláště zapeklitá,
        protože obsah může být URL-encoded, může různě escapovat
        uvozovky, tečky, lomítka, atd.

SQL se např. v Javě přímo používá poměrně málo, neboť pro cokoliv
        většího je vhodnější využít některý z frameworků pro perzistenci,
        nicméně např. v PHP je přímé používání SQL poměrně běžné. Pokud
        není k dispozici podpora pro přípravu SQL příkazů, je důležité
        vedle kontroly obsahu používat escapovací funkce, které datům
        znemožní "vyskočit" z uvozovek.

U souborů je zase důležitá normalizace jmen a kontrola přístupu
        podle finálního jména. Ještě lepší je se jakékoliv konstrukci
        jmen přímo s použitím uživatelského vstupu vyhnout, např. přes
        mapovací tabulku.

# Příklad: vynucení dodržování kontraktu

## Kontrakt v kódu metody – explicitně

```java stretch
        public void log(String context, String taskID, Date timestamp, LogLevel level, String message) {
          if (context == null) {
            throw new NullPointerException("Context name is null");
          }
          if (context.equals("")) {
            throw new IllegalArgumentException("Context name is empty");
          }
          if (taskID == null) {
            throw new NullPointerException("Task ID is null");
          }
          if (taskID.equals("")) {
            throw new IllegalArgumentException("Task ID is empty");
          }
          if (timestamp == null) {
            throw new NullPointerException("Timestamp is null");
          }
          if (level == null) {
            throw new NullPointerException("Log level is null");
          }
          if (message == null) {
            throw new NullPointerException("Log message is null");
          }

File contextDir = new File(basedir, context);
          if (!contextDir.isDirectory()) {
            throw new IllegalArgumentException("Context not registered: " + context);
          }

File taskDir = new File(contextDir, taskID);
          if (!taskDir.isDirectory()) {
            throw new IllegalArgumentException("Task not registered: " + taskID);
          }

/* tělo metody */
        }
        ```

Note:

Příklad je mírně upravený kus kódu ze softwarového projektu Davida Majdy
        (http://been.objectweb.org/). Autor kódu (nikoliv David Majda) si krátce před jeho
        napsáním přečetl *Effective Java* a byl odhodlaný psát kód opravdu poctivě a neprůstřelně.

Kód na kontrolu parametrů byl nakonec delší než samotné tělo metody
        (to je v příkladu vynecháno). Je na místě otázka, zda, případně
        kdy, se opravdu vyplatí parametry poctivě kontrolovat.

# Příklad: vynucení dodržování kontraktu

## Kontrakt v kódu metody – pomocné metody

```java stretch
        public void log(String context, String taskID, Date timestamp, LogLevel level, String message) {
          ensureValidContextName(context, "context");
          ensureValidTaskID(taskID, "taskID");

Ensure.objectNotNull(timestamp, "timestamp");
          Ensure.objectNotNull(level, "log level");
          Ensure.objectNotNull(message, "message");

File contextDir = new File(basedir, context);
          File taskDir = new File(contextDir, taskID);

/* tělo metody */
        }
        ```

## Pomocné metody...

```java stretch
        public void ensureValidContextName(String context, String paramName) {
          Ensure.stringNotEmpty(string, "context name in " + paramName);

File contextDir = new File(basedir, context);
          if (!contextDir.isDirectory()) {
            throw new IllegalArgumentException("Context not registered: " + context);
          }
        }

public void Ensure.stringNotEmpty(String string, String paramName) {
          Ensure.objectNotNull(string, paramName);

if (string.length() < 1) {
            throw new IllegalArgumentException(paramName + " is empty");
          }
        }
        ```
        </1>

Note:

Výše uvedený zápis je výrazně kompaktnější než dříve uvedený
        způsob vynucování kontraktu. Třída `Ensure` poskytuje
        statické metody pro kontrolu obecných parametrů, metody
        `ensureValidContextName` a `ensureValidTaskID`
        by typicky byly privátní, protože obsahují implementační detaily třídy.

Samozřejmě je zde vidět určitá duplicita při vytváření objektů
        `File`. To by se dalo odstranit vhodnou privátní funkcí,
        která by takový objekt vracela a zároveň kontrolovala platnost vstupních parametrů.

V některých jednoduchých případech je možné kontroly zobecnit a
        přesunout do společné třídy `Ensure` - v tomto případě
        by to znamenalo vytvořit např. metodu `Ensure.directoryExists`
        a té předat vytvořený objekt `File` a chybovou zprávu,
        která má být použita ve výjimce. Je však potřeba dát pozor na to,
        jak kombinovat např. textové informace a také typy vyhazovaných výjimek.
        Většinou však na vstupu metody vystačíme s
        `NullPointerException` a `IllegalArgumentException`.

Podobný přístup umožňuje třída Preconditions z knihovny [Guava](https://www.baeldung.com/guava-preconditions),
        na kterou odkazuje článek [Avoid Check for Null Statement in Java](https://www.baeldung.com/java-avoid-null-check).

# Příklad: kontrola dodržování kontraktu

## Kontrakt v kódu metody – pomocí assertů
        ```java stretch
        public void log(String context, String taskID, Date timestamp, LogLevel level, String message) {
          assertValidContextName (context, "context");
          assertValidTaskID (taskID, "taskID");

Assert.objectNotNull (timestamp, "timestamp");
          Assert.objectNotNull (level, "log level");
          Assert.objectNotNull (message, "message");

File contextDir = new File (basedir, context);
          File taskDir = new File (contextDir, taskID);

/* tělo metody */
        }
        ```

Note:

Podobnost s kódem v předcházejícím příkladu není vůbec náhodná.
        Místo "ensure" je použito "assert", které indikuje, že metoda se
        volá pouze uvnitř důvěryhodného kódu, a že většina kontrol z
        produkční verze programu zmizí, aby nezdržovala.

Je realistické očekávat, že překladač, pokud zjistí, že těla
        volaných metod jsou prázdná, tato volání eliminuje, takže nebudou
        představovat zdroj zbytečné režie při volání metody.

# Příklad: zdánlivé akceptování špatného vstupu

## Spojení assertů a opravy vstupu
        ```java stretch
        double calculateVelocity (double latitude, double longitude, double elevation) {
          assertValueWithinRange (latitude, LATITUDE_MIN, LATITUDE_MAX, "latitude");
          assertValueWithinRange (longitude, LONGITUDE_MIN, LONGITUDE_MAX, "longitude");
          assertValueWithinRange (elevation, ELEVATION_MIN, ELEVATION_MAX, "elevation");

//
          // Sanitize input data. Values should be within the asserted ranges, but
          // if a value is not within its valid range, it will be changed to the
          // closest legal value.
          //
          double actualLatitude =
            clampValueRange (latitude, LATITUDE_MIN, LATITUDE_MAX, "latitude");
          double actualLongitude =
            clampValueRange (longitude, LONGITUDE_MIN, LONGITUDE_MAX, "longitude");
          double actualElevation =
            clampValueRange (elevation, ELEVATION_MIN, ELEVATION_MAX, "elevation");
          ...
          /* calculate velocity */
          ...
          return velocity;
        }
        ```