Lightnews — Scholar-powered news

Caralynx

Caralynx

@sudo.caralynx.com

210 followers 70 following 550 posts

Reverse engineering, Japanese toy hacking, constantly distracted. Is ordinarily a tufty cat. Icon by @rokuromon.bsky.social, banner by @hackmonthegoat.bsky.social‬ Teardowns: @teardowns.caralynx.com | Ko-fi: https://ko-fi.com/caralynx

Posts Media Videos Starter Packs

Pinned

Caralynx @sudo.caralynx.com · Oct 27

Hello! I'm cyanic, and I mess around with Japanese toys. This account will mostly be for personal interests. I'll also repost the start of teardown threads here, but if you want to follow the full thread, check @teardowns.caralynx.com.

🎨: @artmab.bsky.social

Sudo laying on top of a pool of water, with rain falling from a mirrored pool above. Sudo is poking a finger into the mirrored pool.

Caralynx @sudo.caralynx.com · 1d

Read through the repo, you tell me what you think is missing. It's the research folder one. There's some things that have not been fully discovered with regards to content, but there should be sufficient information for doing things with the prongs.

Caralynx @sudo.caralynx.com · 1d

You don't need a microcontroller, just a UART adapter.

Caralynx @sudo.caralynx.com · 1d

It's unknown how unique the device key is. Currently it's the same at least across a manufacturing batch. The P-Com is a microcontroller that wraps the protocol, but is frankly not worth considering due to its proprietary and needlessly complex implementation.

Caralynx @sudo.caralynx.com · 1d

It's in the encrypted part of the firmware. I made a decrypter, which requires the device key, which you can extract with the microcontroller's UART console or SWD (which is disabled in the firmware but enabled when there is no valid firmware).

Caralynx @sudo.caralynx.com · 2d

There's a description of the hardware connection as well.

Caralynx @sudo.caralynx.com · 2d

It's all in or referenced by the repo. You've got the base transport protocol and a reference implementation (but you'll have to find your own transfer secret), a description of the playdate flow, and a description of the gifting flow. Downloads are just bulk files and have no special flow.

Caralynx @sudo.caralynx.com · 2d

All you need is a UART adapter and some software to play the part, so yes, an ESP32 should work. Any microcontroller with a UART peripheral should work as long as you have software to run the protocol.

Caralynx @sudo.caralynx.com · 6d

*keeps the antlers for my collection*

Caralynx @sudo.caralynx.com · 10d

I'd like to get one, though can't right now. Will this be available again some time in the future?

Caralynx @sudo.caralynx.com · 11d

I more or less repacked one of the DLCs with a new sprite and some string edits. Not quite ready for prime time, I want to know how the animations work first.

Caralynx @sudo.caralynx.com · 24d

Here's the code for generating that hash. Way too much SHA256 and SHA512 IMO, they could probably have made this simpler. Or used an HMAC.

$Snippet of C# string HashStringSHA256(string input) { return Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(input))).ToLower(); } string HashStringSHA512(string input) { return Convert.ToHexString(SHA512.HashData(Encoding.UTF8.GetBytes(input))).ToLower(); } string CalculateRequestHash(Dictionary<string, string> parameters) { List<string> hashes = new(); foreach (var p in parameters.OrderBy(p => p.Key)) { hashes.Add($"{HashStringSHA256(p.Key)}_{HashStringSHA512(p.Value)}"); } return HashStringSHA512(HashStringSHA256(string.Join(',', hashes))); }$

Caralynx @sudo.caralynx.com · 24d

Bonus: parameter hashing on the API. When you're calling the API, it expects a hash under the `x-bambi-hash` header that hashes the parameters passed to the endpoint. This is probably to make sure only authorized clients can call the API, but is kind of weak.

Caralynx @sudo.caralynx.com · 24d

And that's pretty much it. The core of it is an xorshift32 RNG with a fixed seed generating a sequence of tiles to draw.

Caralynx @sudo.caralynx.com · 24d

The generate scramble map function takes an array, and then using xorshift32 assigns a number to each element. It then sorts the array by that generated number and returns the sorted array.

The xorshift32 function is also a generator. It puts the seed into a Uint32Array to ensure range.

Caralynx @sudo.caralynx.com · 24d

Finally, we get into the actual scrambling logic. First is a generator function that returns the X/Y coordinate (in terms of tiles, not pixels) of the tiles to swap. It passes the array [0, 1, ..., numTiles ** 2] to the generate scramble map function, and generates which tile to copy in dest order.

$Snippet of JavaScript function* scrambleIterate(numTiles, scrambleSeed) { yield* generateScrambleMap([...Array(numTiles ** 2)].map((element, index) => index), scrambleSeed).map( (element, index) => ({ source: { x: element % numTiles, y: Math.floor(element / numTiles) }, dest: { x: index % numTiles, y: Math.floor(index / numTiles) } })) } function generateScrambleMap(tileIndexes, scrambleSeed) { const rng = xorshift32(scrambleSeed); // tileIndexes is [0, 1, 2, ..., numTiles ** 2 - 1] return tileIndexes.map(element => [rng.next().value, element]) .sort( (a, b) => +(a[0] > b[0]) - +(b[0] > a[0])) // ascending order .map(r => r[1]) } function* xorshift32(scrambleSeed) { const arr = Uint32Array.of(scrambleSeed); while (true) { arr[0] ^= arr[0] << 13, arr[0] ^= arr[0] >>> 17, arr[0] ^= arr[0] << 5, yield arr[0] } }$

Caralynx @sudo.caralynx.com · 24d

The scrambled width and height is capped to that, then it calculates the size of each tile. Because of the requirement that the tile size is a multiple of 8, that means for images that do not have dimensions that are a multiple of 8, a strip on the right and/or bottom side will not be scrambled.

Caralynx @sudo.caralynx.com · 24d

The tile size is calculated by first finding the LCM of the number of tiles horizontally and vertically (defined as 4 by the caller) and 8. Not sure why it needs to be a multiple of 8, but that's what they specified.

Snippet of JavaScript

function getTileSize(imgWidth, imgHeight, numTiles) {
if (imgWidth < numTiles || imgHeight < numTiles)
return null;
const minTileSize = lcm(numTiles, minTileMultipleSize); // minTileMultipleSize = 8
// Make width and height multiple of min tile size
if (imgWidth > minTileSize && imgHeight > minTileSize) {
imgWidth = Math.floor(imgWidth / minTileSize) * minTileSize;
imgHeight = Math.floor(imgHeight / minTileSize) * minTileSize;
}
return {
width: Math.floor(imgWidth / numTiles),
height: Math.floor(imgHeight / numTiles)
}
}

function lcm(a, b) {
const gcd = (a, b) => a ? gcd(b % a, a) : b;
return a * b / gcd(a, b);
}

Caralynx @sudo.caralynx.com · 24d

The scramble seed is valid if it's not undefined and is a 32-bit unsigned number that's at least 1.

Caralynx @sudo.caralynx.com · 24d

Let's look at the unscramble function. It draws the scrambled image, gets the tile size and checks whether it and the scramble seed (supplied by the web API) is valid, clears the scrambled region (we'll see why it draws the image first later), then draws each tile according to a generator.

Snippet of JavaScript

function unscramble(canvasContext, scrambledImg, numTiles, scrambleSeed) {
canvasContext.drawImage(scrambledImg, 0, 0);
const tileSize = getTileSize(scrambledImg.width, scrambledImg.height, numTiles);
if (tileSize && scrambleSeedValid(scrambleSeed)) {
canvasContext.clearRect(0, 0, tileSize.width * numTiles, tileSize.height * numTiles);
for (const tile of scrambleIterate(numTiles, scrambleSeed ?? 1)) {
canvasContext.drawImage(scrambledImg, tile.source.x * tileSize.width, tile.source.y * tileSize.height, tileSize.width, tileSize.height,
tile.dest.x * tileSize.width, tile.dest.y * tileSize.height, tileSize.width, tileSize.height);
}
}
}

function scrambleSeedValid(n) {
if (n === undefined) return false;
return n === Math.max(Math.min(n, scrambleSeedMax), scrambleSeedMin); // scrambleSeedMax = 2 ** 32 - 1, scrambleSeedMin = 1
}

Caralynx @sudo.caralynx.com · 24d

Not sure why they specifically scale it down when it's smaller. Maybe to save on memory?

Caralynx @sudo.caralynx.com · 24d

Basically it draws the scrambled image into an offscreen canvas (if available), unscrambles it, then copies the unscrambled image into the unscrambled canvas. There's an interesting rescaling that happens if the target width for the canvas is less than half the size of the original image.

Caralynx @sudo.caralynx.com · 24d

The page sets up a Vue component for displaying a canvas of the unscrambled image. That then creates a class that generates said canvas, and exposes functions for loading the scrambled image and drawing to the unscrambled canvas. Here's the code for drawing the canvas.

$Snippet of JavaScript function drawImage(targetWidth) { const unscrambledCanvasCtx = unscrambledCanvas.value?.getContext("2d"); let scrambledCanvas, scrambledCanvasCtx; if ("OffscreenCanvas" in window) { scrambledCanvas = new OffscreenCanvas(0,0); scrambledCanvasCtx = scrambledCanvas.getContext("2d", { alpha: false }); } else { scrambledCanvas = document.createElement("canvas"); scrambledCanvasCtx = scrambledCanvas.getContext("2d", { alpha: false }); } if (!unscrambledCanvas.value || !unscrambledCanvasCtx || !scrambledImg.value || !scrambledCanvas || !scrambledCanvasCtx) return false; const scaleFactor = targetWidth * window.devicePixelRatio < scrambledImg.value.width * _e ? _e : 1; // _e = 0.5 if (scaleFactor === cachedScaleFactor.value) return false; cachedScaleFactor.value = scaleFactor; scrambledCanvas.width = scrambledImg.value.width; scrambledCanvas.height = scrambledImg.value.height; unscramble(scrambledCanvasCtx, scrambledImg.value, numTiles, scrambleSeed.value); unscrambledCanvas.value.width = scrambledCanvas.width * scaleFactor; unscrambledCanvas.value.height = scrambledCanvas.height * scaleFactor; unscrambledCanvasCtx.drawImage(scrambledCanvas, 0, 0, scrambledCanvas.width, scrambledCanvas.height, 0, 0, unscrambledCanvas.value.width, unscrambledCanvas.value.height); scrambledCanvas.width = 0; scrambledCanvas.height = 0; return true; }$

Caralynx @sudo.caralynx.com · 24d

I spent some time figuring out Ciao Plus' image scrambling algorithm because I wanted to archive the Tamagotchi Manga on it. Let's take a look.

Reposted by Caralynx

Mab @artmab.bsky.social · 24d

Sprites! The first three monthly brush tests were of Sudo, Banon, and Noko. :D

@sudo.caralynx.com @ucbronzewing.bsky.social
#furryart #furry #commission

Simple sprite art of Sudo, an anthro caracal/lynx. His name is written cascading down rightward from the top right corner

A sprite of Banon, an anthro horse knight, with a sword and little motes of purple light

Simple sprite emotes of Noko, an anthro panther

Caralynx @sudo.caralynx.com · Sep 19

There's more info at github.com/GMMan/tama-p.... The readme of the tamacom library gives an example of how to send and receive packets.