Unicode Phishing Domänen Trick

[KodeZwerg]

Hi Leute, ich weiß nicht ob dieses Thema schonmal hier aufkam da es nicht Top-Aktuell ist, wenn ja bitte Thread löschen, Danke.

Ihr wisst ja das man mit Unicode sehr viel blödsinn machen kann, auch bösartiges.
Ich bin hier auf etwas gestossen wo (je nach Browser) der Domänenname nicht der ist der er lesbar zu sein scheint.
Link zu besagter Test-Seite.
Wenn Euer Browser davon betroffen ist, erscheint Anhang 49349

[v2afrank]

Welcher browser macht das denn ? Ich habe hier Edge und Chrome getestet. Bei beiden ist es in Ordnung.
Gerade noch Firefox getestet, der ist davon betroffen
Der Mi Browser und der Chrome mobile auch nicht

[KodeZwerg]

Zitat:

Zitat von v2afrank (Beitrag 1405387)

Gerade noch Firefox getestet, der ist davon betroffen

Schön das Du Dir Deine Eigene Frage beantwortest :-D

edit
Ps: Ein fix für FireFox ist diese Einstellung "network.IDN_show_punycode" auf "True" zu setzen.
Pps: Etwas lustiges kann man so machen, öffne die Website da oben mit MS-Edge, nun kopiere aus der Adress-Leiste die Adresse raus und füge diese in Notepad ein = apple.com ^_^

[Namenloser]

Hatten die Browserhersteller nicht genau dasselbe Problem vor Jahren schon mal behoben? Komisch, jetzt geht es wieder. :?

[KodeZwerg]

Soweit ich auf die schnelle in Erfahrung bringen konnte betrifft es nur FireFox und jeder der darauf aufbaut, TOR zum Beispiel.
Und ja, ist alt die Info weswegen ich in Post #1 schrieb "nicht aktuell", aber da nicht jeder diese Lücke kennt dacht ich mir ich schreib das mal.

[Der schöne Günther]

Wow, ich hätte wirklich erwartet dass das ein alter Hut ist und jeder Browser das deutlichst kenntlich macht. Edge zeigt sogar ein Sondersymbol in der Adressleiste an:
Anhang 49355

Auch wenn ich keinen FF benutze, danke für den Tipp :thumb:

[Sherlock]

Das ist echt das Trauerspiel beim FF, die hauen Major-Releases am Fließband raus, nur um wichtig zu erscheinen, und versäumen dabei solche Trivialitäten zu vermeiden.

Sherlock

[Bernhard Geyer]

Zitat:

Zitat von KodeZwerg (Beitrag 1405388)

... füge diese in Notepad ein = apple.com ^_^

Das Wort "apple" ist aber mit den Kyrilischen Buchstaben geschrieben: 0430 0440 0440 04CF 0435

[pesi]

Ähem... sehe ich das falsch oder ist das einfach nur unserer falschen Leseweise geschuldet???
Die URL hat null komma nix mit dem englischen Apfel zu tun, sondern das was wir alle für ein kleines "l" im Wörtchen Apple halten ist in der Tat ein großes "I" (iiiih).
Für mich ist da also nix mit irgendwelchem Unidoce etc. zu erkennen, sondern erst mal nur was mit unserem Gehirn, dass aus APPIE in anderer Schreibweise ein apple macht (weil apple kennt man ja)

...meine Meinung

[Sherlock]

Siehst Du in der Tat falsch. Denn es ist ein kleines l, nur eben ein kyrillisches.

Das was du sagst ist ja noch ein anderer "Trick". Der allerdings schon älter ist, den gab es schon bevor man Unicode zuließ.

O'Neill

[himitsu]

Klicke nie einen Link aus dubiosen Quellen an,
sondern gib selbst die URL ein, zu der zu willst, bzw. nimm deine eigenen Favoriten.

Vor allem bei Bankzeugs und so.

[KodeZwerg]

Zitat:

Zitat von Der schöne Günther (Beitrag 1405394)

Auch wenn ich keinen FF benutze, danke für den Tipp :thumb:

Gerne doch!

Zitat:

Zitat von Sherlock (Beitrag 1405395)

Das ist echt das Trauerspiel beim FF, die hauen Major-Releases am Fließband raus, nur um wichtig zu erscheinen, und versäumen dabei solche Trivialitäten zu vermeiden.

Dafür gab ich ja den fix für FF damit man sich wappnen kann.

Zitat:

Zitat von Bernhard Geyer (Beitrag 1405406)

Das Wort "apple" ist aber mit den Kyrilischen Buchstaben geschrieben: 0430 0440 0440 04CF 0435

Darum geht es doch, Unicode. (also das ähnlich ausschauene Zeichen falsch gelesen werden können)

Zitat:

Zitat von himitsu (Beitrag 1405432)

Klicke nie einen Link aus dubiosen Quellen an, sondern gib selbst die URL ein, zu der zu willst, bzw. nimm deine eigenen Favoriten.

Dem kann ich nichts weiter hinzufügen.:thumb:

[KodeZwerg]

Habe mal etwas gebastelt basierend hierauf:

Code:

/**
 * Copyright (C) 2011 by Ben Noordhuis <[e-mail]>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#include "punycode.h"

#include <assert.h>
#include <stdint.h>
#include <string.h>
#include <ctype.h>

#define min(a, b) ((a) < (b) ? (a) : (b))

/* punycode parameters, see http://tools.ietf.org/html/rfc3492#section-5 */
#define BASE 36
#define TMIN 1
#define TMAX 26
#define SKEW 38
#define DAMP 700
#define INITIAL_N 128
#define INITIAL_BIAS 72

static uint32_t adapt_bias(uint32_t delta, unsigned n_points, int is_first) {
  uint32_t k;

  delta /= is_first ? DAMP : 2;
  delta += delta / n_points;

  /* while delta > 455: delta /= 35 */
  for (k = 0; delta > ((BASE - TMIN) * TMAX) / 2; k += BASE) {
    delta /= (BASE - TMIN);
  }

  return k + (((BASE - TMIN + 1) * delta) / (delta + SKEW));
}

static char encode_digit(int c) {
  assert(c >= 0 && c <= BASE - TMIN);
  if (c > 25) {
    return c + 22; /* '0'..'9' */
  }
  else {
    return c + 'a'; /* 'a'..'z' */
  }
}

/* Encode as a generalized variable-length integer. Returns number of bytes written. */
static size_t encode_var_int(const size_t bias, const size_t delta, char *const dst, size_t dstlen) {
  size_t i, k, q, t;

  i = 0;
  k = BASE;
  q = delta;

  while (i < dstlen) {
    if (k <= bias) {
      t = TMIN;
    }
    else if (k >= bias + TMAX) {
      t = TMAX;
    }
    else {
      t = k - bias;
    }

    if (q < t) {
      break;
    }

    dst[i++] = encode_digit(t + (q - t) % (BASE - t));

    q = (q - t) / (BASE - t);
    k += BASE;
  }

  if (i < dstlen) {
    dst[i++] = encode_digit(q);
  }

  return i;
}

static size_t decode_digit(uint32_t v) {
  if (isdigit(v)) {
    return 22 + (v - '0');
  }
  if (islower(v)) {
    return v - 'a';
  }
  if (isupper(v)) {
    return v - 'A';
  }
  return SIZE_MAX;
}

size_t punycode_encode(const uint32_t *const src, const size_t srclen, char *const dst, size_t *const dstlen) {
  size_t b, h;
  size_t delta, bias;
  size_t m, n;
  size_t si, di;

  for (si = 0, di = 0; si < srclen && di < *dstlen; si++) {
    if (src[si] < 128) {
      dst[di++] = src[si];
    }
  }

  b = h = di;

  /* Write out delimiter if any basic code points were processed. */
  if (di > 0 && di < *dstlen) {
    dst[di++] = '-';
  }

  n = INITIAL_N;
  bias = INITIAL_BIAS;
  delta = 0;

  for (; h < srclen && di < *dstlen; n++, delta++) {
    /* Find next smallest non-basic code point. */
    for (m = SIZE_MAX, si = 0; si < srclen; si++) {
      if (src[si] >= n && src[si] < m) {
        m = src[si];
      }
    }

    if ((m - n) > (SIZE_MAX - delta) / (h + 1)) {
      /* OVERFLOW */
      assert(0 && "OVERFLOW");
      goto fail;
    }

    delta += (m - n) * (h + 1);
    n = m;

    for (si = 0; si < srclen; si++) {
      if (src[si] < n) {
        if (++delta == 0) {
          /* OVERFLOW */
          assert(0 && "OVERFLOW");
          goto fail;
        }
      }
      else if (src[si] == n) {
        di += encode_var_int(bias, delta, &dst[di], *dstlen - di);
        bias = adapt_bias(delta, h + 1, h == b);
        delta = 0;
        h++;
      }
    }
  }

fail:
  /* Tell the caller how many bytes were written to the output buffer. */
  *dstlen = di;

  /* Return how many Unicode code points were converted. */
  return si;
}

size_t punycode_decode(const char *const src, const size_t srclen, uint32_t *const dst, size_t *const dstlen) {
  const char *p;
  size_t b, n, t;
  size_t i, k, w;
  size_t si, di;
  size_t digit;
  size_t org_i;
  size_t bias;

  /* Ensure that the input contains only ASCII characters. */
  for (si = 0; si < srclen; si++) {
    if (src[si] & 0x80) {
      *dstlen = 0;
      return 0;
    }
  }

  /* Reverse-search for delimiter in input. */
  for (p = src + srclen - 1; p > src && *p != '-'; p--);
  b = p - src;

  /* Copy basic code points to output. */
  di = min(b, *dstlen);

  for (i = 0; i < di; i++) {
    dst[i] = src[i];
  }

  i = 0;
  n = INITIAL_N;
  bias = INITIAL_BIAS;

  for (si = b + (b > 0); si < srclen && di < *dstlen; di++) {
    org_i = i;

    for (w = 1, k = BASE; di < *dstlen; k += BASE) {
      digit = decode_digit(src[si++]);

      if (digit == SIZE_MAX) {
        goto fail;
      }

      if (digit > (SIZE_MAX - i) / w) {
        /* OVERFLOW */
        assert(0 && "OVERFLOW");
        goto fail;
      }

      i += digit * w;

      if (k <= bias) {
        t = TMIN;
      }
      else if (k >= bias + TMAX) {
        t = TMAX;
      }
      else {
        t = k - bias;
      }

      if (digit < t) {
        break;
      }

      if (w > SIZE_MAX / (BASE - t)) {
        /* OVERFLOW */
        assert(0 && "OVERFLOW");
        goto fail;
      }

      w *= BASE - t;
    }

    bias = adapt_bias(i - org_i, di + 1, org_i == 0);

    if (i / (di + 1) > SIZE_MAX - n) {
      /* OVERFLOW */
      assert(0 && "OVERFLOW");
      goto fail;
    }

    n += i / (di + 1);
    i %= (di + 1);

    memmove(dst + i + 1, dst + i, (di - i) * sizeof(uint32_t));
    dst[i++] = n;
  }

fail:
  /* Tell the caller how many bytes were written to the output buffer. */
  *dstlen = di;

  return si;
}

Hier ein Bild Anhang 49365

Ps: Mit Unicode sind kyrilische Zeichen gemeint.