Check confusable characters

The same thing in your own code

Each code block has been compiled and verified in CI. Provided under the MIT license to illustrate disarm. disarm on GitHub →

# Fold confusables under both digit policies. They answer different questions.
#   pip install disarm
from disarm import normalize_confusables

# A brand spelled with two Devanagari zeros standing in for the letter o.
SPOOF = "g००gle"

numeric = normalize_confusables(SPOOF)                        # the default
tr39 = normalize_confusables(SPOOF, digit_policy="tr39")

# Numeric keeps a digit a digit, which is what stored text means. TR39 folds it
# to a letter, which is what makes a spoof collide with the brand it imitates.
assert numeric == "g00gle", numeric
assert tr39 == "google", tr39
assert numeric != tr39, "the policies must disagree here"

print(f'ok: numeric gives "{numeric}", tr39 gives "{tr39}"')

// Fold confusables under both digit policies. They answer different questions.
//   cargo add disarm
use disarm::api::{normalize_confusables_with, DigitPolicy, TargetScript};

fn main() {
    // A brand spelled with two Devanagari zeros standing in for the letter o.
    let spoof = "g\u{0966}\u{0966}gle";

    let numeric = normalize_confusables_with(spoof, TargetScript::Latin, DigitPolicy::Numeric);
    let tr39 = normalize_confusables_with(spoof, TargetScript::Latin, DigitPolicy::Tr39);

    // Numeric keeps a digit a digit, which is what stored text means. TR39 folds
    // it to a letter, which is what makes a spoof collide with the brand.
    assert_eq!(numeric, "g00gle");
    assert_eq!(tr39, "google");
    assert_ne!(numeric, tr39, "the policies must disagree here");

    println!(r#"ok: numeric gives "{numeric}", tr39 gives "{tr39}""#);
}

// Fold confusables under both digit policies. They answer different questions.
//   npm i disarm
const assert = require("node:assert/strict");
const { normalizeConfusables } = require("disarm");

// A brand spelled with two Devanagari zeros standing in for the letter o.
const SPOOF = "g००gle";

const numeric = normalizeConfusables(SPOOF);                            // the default
const tr39 = normalizeConfusables(SPOOF, { digitPolicy: "tr39" });

// Numeric keeps a digit a digit, which is what stored text means. TR39 folds it
// to a letter, which is what makes a spoof collide with the brand it imitates.
assert.equal(numeric, "g00gle");
assert.equal(tr39, "google");
assert.notEqual(numeric, tr39, "the policies must disagree here");

console.log(`ok: numeric gives "${numeric}", tr39 gives "${tr39}"`);

# Fold confusables under both digit policies. They answer different questions.
#   gem install disarm
require "disarm"

# A brand spelled with two Devanagari zeros standing in for the letter o.
SPOOF = "g००gle"

numeric = Disarm.normalize_confusables(SPOOF)                       # the default
tr39 = Disarm.normalize_confusables(SPOOF, digit_policy: :tr39)

# Numeric keeps a digit a digit, which is what stored text means. TR39 folds it
# to a letter, which is what makes a spoof collide with the brand it imitates.
raise "expected g00gle, got #{numeric}" unless numeric == "g00gle"
raise "expected google, got #{tr39}" unless tr39 == "google"
raise "the policies must disagree here" if numeric == tr39

puts %(ok: numeric gives "#{numeric}", tr39 gives "#{tr39}")

// Fold confusables under both digit policies. They answer different questions.
//   implementation("dev.disarm:disarm:0.14.1")
import dev.disarm.Disarm;
import dev.disarm.DigitPolicy;
import dev.disarm.TargetScript;

public class FoldConfusables {
    public static void main(String[] args) {
        // A brand spelled with two Devanagari zeros standing in for the letter o.
        String spoof = "g००gle";

        String numeric = Disarm.normalizeConfusables(spoof, TargetScript.LATIN, DigitPolicy.NUMERIC);
        String tr39 = Disarm.normalizeConfusables(spoof, TargetScript.LATIN, DigitPolicy.TR39);

        // Numeric keeps a digit a digit, which is what stored text means. TR39
        // folds it to a letter, which is what makes a spoof collide with the brand.
        if (!numeric.equals("g00gle")) throw new AssertionError("expected g00gle, got " + numeric);
        if (!tr39.equals("google")) throw new AssertionError("expected google, got " + tr39);
        if (numeric.equals(tr39)) throw new AssertionError("the policies must disagree here");

        System.out.printf("ok: numeric gives \"%s\", tr39 gives \"%s\"%n", numeric, tr39);
    }
}

// Fold confusables under both digit policies. They answer different questions.
//   implementation("dev.disarm:disarm-kotlin:0.14.1")
import dev.disarm.DigitPolicy
import dev.disarm.TargetScript
import dev.disarm.kotlin.*

fun main() {
    // A brand spelled with two Devanagari zeros standing in for the letter o.
    val spoof = "g००gle"

    val numeric = spoof.normalizeConfusables(TargetScript.LATIN, DigitPolicy.NUMERIC)
    val tr39 = spoof.normalizeConfusables(TargetScript.LATIN, DigitPolicy.TR39)

    // Numeric keeps a digit a digit, which is what stored text means. TR39 folds
    // it to a letter, which is what makes a spoof collide with the brand.
    check(numeric == "g00gle") { "expected g00gle, got $numeric" }
    check(tr39 == "google") { "expected google, got $tr39" }
    check(numeric != tr39) { "the policies must disagree here" }

    println("""ok: numeric gives "$numeric", tr39 gives "$tr39"""")
}

/* Fold confusables under both digit policies. They answer different questions.
 *
 * The C ABI is not published to any registry, so this links against a cdylib
 * built from bindings/cabi in the disarm repository. Unlike the strip functions,
 * the confusable entry points are fallible: they return a DisarmResult_t with
 * exactly one of value / error set, and the caller frees whichever it is.
 */
#include <stdio.h>
#include <string.h>
#include "disarm.h"

int main(void) {
    /* A brand spelled with two Devanagari zeros standing in for the letter o. */
    const char *spoof = "g\U00000966\U00000966gle";

    DisarmResult_t n = disarm_normalize_confusables_opts(spoof, "latin", "numeric");
    DisarmResult_t t = disarm_normalize_confusables_opts(spoof, "latin", "tr39");

    if (n.error || t.error) {
        fprintf(stderr, "disarm: %s\n", n.error ? n.error : t.error);
        return 1;
    }

    /* Numeric keeps a digit a digit, which is what stored text means. TR39 folds
     * it to a letter, which is what makes a spoof collide with the brand. */
    if (strcmp(n.value, "g00gle") != 0) { fprintf(stderr, "expected g00gle, got %s\n", n.value); return 1; }
    if (strcmp(t.value, "google") != 0) { fprintf(stderr, "expected google, got %s\n", t.value); return 1; }
    if (strcmp(n.value, t.value) == 0) { fprintf(stderr, "the policies must disagree here\n"); return 1; }

    printf("ok: numeric gives \"%s\", tr39 gives \"%s\"\n", n.value, t.value);
    disarm_string_free(n.value);
    disarm_string_free(t.value);
    return 0;
}