New ID Analysis

[MatthewSH]

I became curious on what they're actually doing to create the IDs. It's being done server side in somewhat real time as the web server when requesting a Username+Discriminator URL takes a second then responds with a 302 redirect.

I'll update this as I go.

Warning

I'm writing bad JavaScript to try to just work with the data. I do not recommend running this yourself.
I'm also not throttling requests and don't know if Blizzard would temporarily IP ban me for spamming search requests. I should probably add throttling

Update 1

I did some research before this so I'm going to just braindump it out here at once.

Part 1

I wanted to start with a generic name, SneakyTurtle.

const rawValues = []
const transformed = []

rawValues.forEach((v) => {
  transformed.push({
    name: v.battleTag,
    id: decodeURI(v.url)
  })
})

// console.log(transformed)

// First sort alphabetically
transformed.sort((a, b) => {
  if (a.id < b.id) 
    return -1

  if (a.id > b.id)
    return 1

  return 0
})

// Then sort by length
transformed.sort((a, b) => {
  if (a.id.length < b.id.length)
    return -1

  if (a.id.length > b.id.length)
    return 1

  return 0
})

// Straight output
transformed.forEach((v) => {
  console.log(`${v.id.split('|')[0]} : ${v.name}`)
})

// Break it out
transformed.forEach(v => {
  let id = v.id.split('|')[0]
  let name = v.name.split('#')[0]
  let discrim = v.name.split('#')[1]
  
  console.log(`${id.substring(0, 26)} (${id.substring(0, 26).length}), ${name} (${name.length}) - ${id.substring(27)} (${id.substring(27).length}), ${discrim} (${discrim.length})`)
})

the "Break it out" portion was done after I saw this: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-1-part-1-before-breaking-it-out

Once I noticed a pattern visually, I broke it up: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-1-part-1-breaking-it-out

That's when I noticed how the pattern of 2 distinct portions. The first portion is the name (case sensitive, length sensitive) the second is the discriminator (length sensitive).

Part 2

I wanted to see how this works against multiple names. So I got some generic and streamer names together and ran a new script:

const fs = require("fs");

const names = [
  "Jay3",
  "ML7",
  "Kabaji",
  "Emongg",
  "GaleAdelade",
  "SneakyTurtle",
  "GoldenPants",
  "Player",
  "PogChamp",
  "Kappa",
  "ABC",
  "DPS",
  "Tank",
  "Support",
  "123456",
  "1234",
];

let output = "";

const results = {};
const promises = names.map((name) => {
  return new Promise(async (resolve, reject) => {
    const result = await fetch(
      `https://overwatch.blizzard.com/en-us/search/account-by-name/${name}`
    );

    results[name] = await result.json();

    resolve();
  });
});

Promise.all(promises).then(() => {
  Object.entries(results).forEach(([name, result]) => {
    // First sort alphabetically
    result.sort((a, b) => {
      if (a.url < b.url) return -1;

      if (a.url > b.url) return 1;

      return 0;
    });

    // Then sort by length
    result.sort((a, b) => {
      if (a.url.length < b.url.length) return -1;

      if (a.url.length > b.url.length) return 1;

      return 0;
    });

    output += `==================== ${name} ====================\n`;

    result.forEach((r) => {
      const id = decodeURI(r.url).split("|")[0];

      output += `${id} (${id.length}) - ${r.battleTag} (${
        r.battleTag.length
      }, ${r.battleTag.split("#")[0].length}, ${
        r.battleTag.split("#")[1].length
      })\n`;
    });

    output += "=================================================\n\n";
  });

  fs.writeFileSync("output.txt", output);
});

Warning

Again, would not advise running it yourself.

This spit out the following: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-1-part-2-multiple-names

Genuinely not sure on some of them..but I just used VSCode text highlighting to manually find the "length" of the name portion on each because I discovered the different lengths.

Here's what I have thus far:

Name: 11 (GoldenPants)
ID: 26 (d551a08eb67fabace7e464bdd)

Name: 4 (Tank)
ID: 11 (c65fa281fe2)

Name: 6 (Player)
ID: 15 (c252ad93b663d6f)

Name: 3 (ML7)
ID: 9 (df72fbc7e)

Name: 8 (PogChamp)
ID: 19 (c251aba9bb7096bda4a)

Name: 3 (DPS)
ID: 9 (d66e9fc7e)

Name: 5 (Kappa)
ID: 13 (d95fbc9ab23cc)

Name: 12 (SneakyTurtle)
ID: 26 (c150a98bb868afb8fbe47bf5c9)

You'll notice that it seems every ID is almost calculated like this:

(name length * 2) + 3

The only outlier is SneakyTurtle where it seems to have the same as an 11 character name. So I pulled up a couple more 12 character names and noticed something:

c156ad8ebc66bfbfe8f778fec900a40f4e53a6a7 (40) - ShadowDragon#1262820 (20, 12, 7)
c150a98bb868afb8fbe47bf5c900a30c4852a0a0 (40) - SneakyTurtle#1554947 (20, 12, 7)

c251ab89bb7096bdb8a027a1c900ae0e4a (34) - Pogchamp1001#1876 (17, 12, 4)
c150a98bb868afb8fbe47bf5c900a1014c (34) - SneakyTurtle#1780 (17, 12, 4)
c251ab89bb7096bdb8a027a1c900ae0e4a (34) - Pogchamp1001#1876 (17, 12, 4)
c35fa28eb27d9e89e0fe70dcc900a1004d (34) - QandaleDingL#1791 (17, 12, 4)
d65bad81a16b9aace8c443c6c903af0144 (34) - DeakrzaaaTTV#2988 (17, 12, 4)

It appears as there's some limit to the ID of the name being 26. I want to do more looking at this, but for now we move on.

That's what I have thus far.

Update 2

I wanted to create a dump of all the IDs to confirm my suspicion. This is the output: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-2

I added 4 characters after the "ID" of the name just as a self-check to make sure I wasn't wrong.

Here's the code that does it:

const results = require("./output.json");
const fs = require("fs");

let output = "";

const ids = {};

Object.entries(results).forEach(([name, result]) => {
  output += `==================== ${name} ====================\n`;

  result.forEach((r) => {
    const id = decodeURI(r.url).split("|")[0];
    const name = r.battleTag.split("#")[0];
    const discrim = r.battleTag.split("#")[1];

    let idLength = name.length * 2 + 3;

    if (name.length >= 12) {
      idLength = 26;
    }

    const idName = id.substring(0, idLength);

    output += `${idName} ${id.substring(idLength, idLength + 4)} - ${name}\n`;

    if (!ids[name]) {
      ids[name] = idName;
    }
  });

  output += "=================================================\n\n";
});

output += "==================== IDS ====================\n";
output += JSON.stringify(ids, null, 2);
output += "=================================================\n\n";

fs.writeFileSync("output v2.txt", output);

I saved the previous JSON output to a file so I don't get flagged by Blizzard or IP banned.
Now I have this I can start looking into the numbers.

Here's the output of names and their IDs:

{
  "메추리": "799758066",
  "느긋한회색곰": "79b45c006b9a165",
  "참된푸른지룡": "7e8e7401438d165",
  "GaleAdelade": "d55fa08f92759ea1e8f472bdd",
  "GALEADELADE": "d57f80af9255be81c8d452bdd",
  "Toast": "c651ad99a73cc",
  "Zen24": "c85ba2d8e73cc",
  "Supp0rt": "c14bbc9ae3638fe0b",
  "Batman4126": "d05fb887b27fcffcbba63aa",
  "Śūppőrŧ": "57a40941a3613e5cf",
  "KirikoChill": "d957be83b87eb8a5e0fc7bbdd",
  "JaY3": "d85f95d9fe2",
  "Jay3": "d85fb5d9fe2",
  "JAY3": "d87f95d9fe2",
  "jay3": "f85fb5d9fe2",
  "Kabaji": "d95fae8bb978d6f",
  "KABAJI": "d97f8eab9958d6f",
  "kabaji": "f95fae8bb978d6f",
  "ShadowDragon": "c156ad8ebc66bfbfe8f778fec9",
  "Emongg": "d753a384b476d6f",
  "emongg": "f753a384b476d6f",
  "DPS": "d66e9fc7e",
  "Dps": "d64ebfc7e",
  "dpS": "f64e9fc7e",
  "dps": "f64ebfc7e",
  "Pogchamp": "c251ab89bb7096bda4a",
  "PogChamP": "c251aba9bb70969da4a",
  "PogChamp": "c251aba9bb7096bda4a",
  "POGchamp": "c2718b89bb7096bda4a",
  "POGCHAMP": "c2718ba99b50b69da4a",
  "pogchamp": "e251ab89bb7096bda4a",
  "PoGchamp": "c2518b89bb7096bda4a",
  "POgChAmP": "c271aba9bb50969da4a",
  "Pogchamp1001": "c251ab89bb7096bdb8a027a1c9",
  "QandaleDingL": "c35fa28eb27d9e89e0fe70dcc9",
  "DeakrzaaaTTV": "d65bad81a16b9aace8c443c6c9",
  "ShadowStorm": "c156ad8ebc66a8b9e6e27abdd",
  "TaNK": "c65f82a1fe2",
  "Tank": "c65fa281fe2",
  "TanK": "c65fa2a1fe2",
  "TANK": "c67f82a1fe2",
  "tank": "e65fa281fe2",
  "gGTank": "f579988bbd7ad6f",
  "SHATTER": "c1768dbe8754a9e0b",
  "Tankraul": "c65fa281a1708ea1a4a",
  "BlueHound": "d052b98f9b7e8ea3edbd2",
  "LavaHound": "de5fba8b9b7e8ea3edbd2",
  "Verdansikgod": "c45bbe8eb27f88a4e2f778f4c9",
  "HiJinxGaming": "da578683bd69bcace4f979f7c9",
  "KaPPa": "d95f9cbab23cc",
  "Kappa": "d95fbc9ab23cc",
  "KappA": "d95fbc9a923cc",
  "KAPPA": "d97f9cba923cc",
  "kappa": "f95fbc9ab23cc",
  "LordKiller": "de51be8e987897a1ece23aa",
  "SeñorJonsey": "c15b0f5bbc63b1a2e7e372e9c",
  "BattlePants": "d05fb89ebf74abace7e464bdd",
  "ML7": "df72fbc7e",
  "ml7": "ff52fbc7e",
  "mL7": "ff72fbc7e",
  "Ml7": "df52fbc7e",
  "MercyLess": "df5bbe89aa5d9ebefabd2",
  "MLSxPaolaPay": "df729f92837094a1e8c076e9c9",
  "ABC": "d37c8fc7e",
  "abc": "f35cafc7e",
  "AbC": "d35c8fc7e",
  "Abc": "d35cafc7e",
  "警告": "7a936a0",
  "SIGMA": "c1778ba7923cc",
  "ping9999": "e257a28dea28c2f4a4a",
  "MrMelatonin": "df4c818fbf708fa2e7f979bdd",
  "SneakyTurtle": "c150a98bb868afb8fbe47bf5c9",
  "sneakyturtle": "e150a98bb8688fb8fbe47bf5c9",
  "PLAYER": "c2728db39643d6f",
  "player": "e252ad93b663d6f",
  "Player": "c252ad93b663d6f",
  "Goldenpants": "d551a08eb67f8bace7e464bdd",
  "GoldenPants": "d551a08eb67fabace7e464bdd",
  "GOLDENPANTS": "d57180ae965fab8cc7c444bdd"
}

Looking through this JSON I'm noticing something...let's isolate the JSON to variations of the same name:

==== 3 Length ====
DPS - d66e9fc7e
Dps - d64ebfc7e
dpS - f64e9fc7e
dps - f64ebfc7e

ML7 - df72fbc7e
ml7 - ff52fbc7e
mL7 - ff72fbc7e
Ml7 - df52fbc7e

ABC - d37c8fc7e
abc - f35cafc7e
AbC - d35c8fc7e
Abc - d35cafc7e

==== 4 Length ====
JaY3 - d85f95d9fe2
Jay3 - d85fb5d9fe2
JAY3 - d87f95d9fe2
jay3 - f85fb5d9fe2

TaNK - c65f82a1fe2
Tank - c65fa281fe2
TanK - c65fa2a1fe2
TANK - c67f82a1fe2
tank - e65fa281fe2

==== 5 Length ====
KaPPa - d95f9cbab23cc
Kappa - d95fbc9ab23cc
KappA - d95fbc9a923cc
KAPPA - d97f9cba923cc
kappa - f95fbc9ab23cc

==== 6 Length ====
PLAYER - c2728db39643d6f
player - e252ad93b663d6f
Player - c252ad93b663d6f

Kabaji - d95fae8bb978d6f
KABAJI - d97f8eab9958d6f
kabaji - f95fae8bb978d6f

Emongg - d753a384b476d6f
emongg - f753a384b476d6f

==== 8 Length ====
Pogchamp - c251ab89bb7096bda4a
PogChamP - c251aba9bb70969da4a
PogChamp - c251aba9bb7096bda4a
POGchamp - c2718b89bb7096bda4a
POGCHAMP - c2718ba99b50b69da4a
pogchamp - e251ab89bb7096bda4a
PoGchamp - c2518b89bb7096bda4a
POgChAmP - c271aba9bb50969da4a

==== 11 Length ====
GaleAdelade - d55fa08f92759ea1e8f472bdd
GALEADELADE - d57f80af9255be81c8d452bdd

Goldenpants - d551a08eb67f8bace7e464bdd
GoldenPants - d551a08eb67fabace7e464bdd
GOLDENPANTS - d57180ae965fab8cc7c444bdd

The 3 characters at the end...they're always the same. Always. which means...something is appended that's then hashed and whatever it is...it's always the same.

The ID

I'm noticing something with the IDs. Let's isolate the above list even more...

TaNK - c65f82a1fe2
Tank - c65fa281fe2
TanK - c65fa2a1fe2
TANK - c67f82a1fe2
tank - e65fa281fe2

I'm seeing repetition. Let's chop off the last 3 as we know it's all repeated.

TaNK - c65f82a1
Tank - c65fa281
TanK - c65fa2a1
TANK - c67f82a1
tank - e65fa281

This leaves us with a 4 letter word and an 8 character ID.
Even more, it looks like there's 2 characters per letter (omitting repeating, organized by right side):

K a1
n a2
T c6
t e5
a 5f
A 7f
N 82
k 81

Let's organize by casing:

T c6
A 7f
N 82
K a1

t e5
a 5f
n a2
k 81

I'm seeing no patterns yet, gonna keep going.

Update 3

I can't get the appearance of a mapping out of my head. I need to explore this. For this I'll need to write a new script.

const results = require("./output.json");
const fs = require("fs");

let output = "";

const chars = {};

Object.entries(results).forEach(([name, result]) => {
  result.forEach((r) => {
    const id = decodeURI(r.url).split("|")[0];
    const name = r.battleTag.split("#")[0];

    let idLength = name.length * 2 + 3;
    let cutoff = 3;

    if (name.length >= 12) {
      cutoff = 2;
    }

    const idName = id.substring(0, idLength - cutoff);

    // Chunk out the ID into 2 character chunks
    for (let i = 0; i < idName.length; i += 2) {
      const chunk = idName.substring(i, i + 2);
      const letter = name.charAt(i / 2);

      if (!chars[letter]) {
        chars[letter] = [];
      }

      if (!chars[letter].includes(chunk)) {
        chars[letter].push(chunk);
      }
    }
  });
});

output += JSON.stringify(chars, null, 2);

fs.writeFileSync("v4.txt", output);

This outputs: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-3

I think I'm on the wrong path here. I think I need to look at the word as a whole again. but this is a later issue.

Update 4

I'm going to go back into the discriminator numbers. I Since there's a finite set of numbers, it may be easier to decode.

I modified the previous script to output the discriminator portion instead: https://gist.github.com/MatthewSH/8926b10b7735476ef1046032ba45eb47#file-update-4

Ω

[TeKrop]

Wow, very nice analysis you started here, I'm curious about the result 😄

[MatthewSH]

Sadly I haven't had much time to come back to it. I want to also test variations to see if they change such as when a player changes a name, even different days (although I highly doubt part of the key is a timestamp).
It's interesting to say the least, they're doing something custom or something I haven't seen before. Usually hashing is all the same length (usually), being length dependent is strange to me which makes me think it's less of a hash and more of a conversion with some hashed value on the right side.