SPEKE Key ID Override Samples

import hashlib
import uuid

inputParameters = "<see above>"

baseToHashAsBytes = str.encode(inputParameters)

# SHA256 hash
hash = hashlib.sha256()
hash.update(baseToHashAsBytes)
baseHashValue = hash.digest()

# XOR the first and second half of the base hash to make a 16 bytes hash
hashPartOne = baseHashValue[:16]
hashPartTwo = baseHashValue[16:32]
xorHash = bytes([_a ^ _b for _a, _b in zip(hashPartOne, hashPartTwo)])

# Convert to a GUID (based on little-endian bytes)
kid = uuid.UUID(bytes_le=xorHash)

print(kid)

const crypto = require("crypto");

const inputParameters = "<see above>";
var baseToHashAsBytes = Buffer.from(inputParameters);

// SHA256 hash
var sha256Hasher = crypto.createHash("sha256");
sha256Hasher.update(buffbaseToHashAsByteser);
const baseHashValue = sha256Hasher.digest();

// XOR the first and second half of the base hash to make a 16 bytes hash
const partOne = baseHashValue.slice(0, 16);
const partTwo = baseHashValue.slice(16, 32);

let xorHash = Buffer.alloc(16);
for (let n = 0; n < 16; n++)
    xorHash[n] = partOne[n] ^ partTwo[n % partTwo.length];

// Convert to a GUID (based on little-endian bytes)
const kid = createGUID(xorHash);

console.log(kid);

function createGUID(buffer:any) {
    // mind the reverse endianess for the first three parts
    return buffer.subarray(0, 4).reverse().toString('hex') + '-' +
        buffer.subarray(4, 6).reverse().toString('hex') + '-' +
        buffer.subarray(6, 8).reverse().toString('hex') + '-' +
        buffer.subarray(8, 10).toString('hex') + '-' +
        buffer.subarray(10, 16).toString('hex');
}

public class App {
    private static String formatByteArrayToUUID(byte[] bytes) {
        StringBuilder formattedString = new StringBuilder();

        for (int i = 0; i < bytes.length; i++) {
            formattedString.append(String.format("%02x", bytes[i]));

            if (i == 3 || i == 5 || i == 7 || i == 9) {
                formattedString.append("-");
            }
        }

        return formattedString.toString();
    }

    public static void main(String[] args) throws NoSuchAlgorithmException {
        String inputParameters = "<see above>";
        byte[] baseToHashAsBytes = inputParameters.getBytes(StandardCharsets.UTF_8);

        // SHA256 hash
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        byte[] baseHashValue = digest.digest(baseToHashAsBytes);

        // XOR the first and second half of the base hash to make a 16 bytes hash
        byte[] hashPartOne = new byte[16];
        System.arraycopy(baseHashValue, 0, hashPartOne, 0, 16);

        byte[] hashPartTwo = new byte[16];
        System.arraycopy(baseHashValue, 16, hashPartTwo, 0, 16);

        byte[] xorHash = new byte[16];
        for (int i = 0; i < 16; i++) {
            xorHash[i] = (byte) (hashPartOne[i] ^ hashPartTwo[i]);
        }

        // Convert to a GUID (based on little-endian bytes)
        byte[] bytes_le = xorHash;
        int resultLength = 4 + (6 - 4) + (8 - 6) + (bytes_le.length - 8);
        byte[] result = new byte[resultLength];

        int index = 0;
        for (int i = 4 - 1; i >= 0; i--) {
            result[index++] = bytes_le[i];
        }
        for (int i = 6 - 1; i >= 4; i--) {
            result[index++] = bytes_le[i];
        }
        for (int i = 8 - 1; i >= 6; i--) {
            result[index++] = bytes_le[i];
        }
        for (int i = 8; i < bytes_le.length; i++) {
            result[index++] = bytes_le[i];
        }

        String formattedLowerCaseString = formatByteArrayToUUID(result);
        System.out.println(formattedLowerCaseString);
    }
}