Skip to content

Persona Studio v0.2.0

Choose a tag to compare

@github-actions github-actions released this 25 Oct 20:38
· 4 commits to main since this release

Download

Windows: PersonaStudio-0.2.0-windows-x64.zip below. Unzip it anywhere and
run PersonaStudio.exe. It starts the engine and the dashboard together and opens
http://localhost:8787. The first start downloads Chromium (about 170 MB).
Bundled engines: Playwright, Patchright, CloakBrowser (Camoufox needs a source
install). Check the download against SHA256SUMS.txt.

From source: see the Quick start.

What's new in 0.2.0

Added

  • Windows app (packaging/PersonaStudio.spec, persona/app.py): one
    PersonaStudio.exe that runs the engine and serves the built dashboard on
    http://localhost:8787, with no Python or Node needed. It downloads Chromium on
    first run and bundles Playwright, Patchright and CloakBrowser. With arguments
    it acts as the persona CLI. persona serve --dashboard dashboard/dist does
    the same from source. Version is now 0.2.0.

Fixed

  • A profile created through the API or an import without tags blanked the
    whole dashboard. The server now fills in missing fields, and the list
    tolerates old records.

Security

  • Local API locked down. persona serve used to accept CORS from any origin
    without auth, so any web page open in the user's browser could launch profiles
    or read their cookies through localhost:8787. It now requires a per-start
    X-Persona-Token (written to <data-dir>/api-token, given via /api/token
    only to the dashboard's origins). CORS is restricted to the dashboard, and
    non-loopback Host headers are rejected to block DNS rebinding.
    /api/health stays open. The dashboard picks up the token automatically.

  • DNS lockdown at launch. With a proxy, Chromium engines now start with
    --host-resolver-rules="MAP * ~NOTFOUND, EXCLUDE <proxy host>, EXCLUDE localhost",
    so prefetching, WebRTC STUN names and the like can't ask the real ISP's
    resolver. Before, DNS leaks were only detected (persona dns), never prevented.

Fixed

  • GPU strings no real Chrome reports. The dashboard's GPU picker used short
    labels (ANGLE (NVIDIA GeForce RTX 3060 Direct3D11)) and sent them to the
    browser as-is, while real Chrome reports ANGLE (NVIDIA, NVIDIA GeForce RTX 3060 Direct3D11 vs_5_0 ps_5_0, D3D11). The picker now offers the exact
    strings, and profiles saved with an old label are upgraded on launch. Picking
    a GPU or switching OS also updates the WebGL vendor to match.
  • macOS GPUs are Metal now. Chrome on macOS renders WebGL through ANGLE's
    Metal backend, so it reports ANGLE (Apple, ANGLE Metal Renderer: Apple M1, Unspecified Version). New macOS profiles use those strings, old OpenGL 4.1
    ones are upgraded, and the coherence check accepts Metal on macOS only.
  • Dashboard: new and bulk-created profiles start on Chrome 148–151 like the
    engine, instead of 125–128.
  • Same device on every launch (Camoufox). Camoufox salted each launch
    randomly, so a profile came up as a new device every session (a different
    screen each time in testing). Each profile's Camoufox fingerprint is now
    generated once and pinned in its user-data dir
    (.persona-camoufox-fingerprint.json). Backup/restore carries the pin along,
    and "duplicate as template" gets a fresh one. Canvas still varies per session
    there, because Firefox's own baseline fingerprinting protection does that for
    every real Firefox user.
  • CloakBrowser presents Persona's fingerprint. Hardware cores, RAM, screen,
    GPU vendor/renderer and platform are now passed as --fingerprint-* flags, and
    the seed comes from the profile (a profile Cloak already opened keeps its
    existing seed). The UA is no longer forced, so UA and Client Hints both come
    from the binary and agree. Before, Cloak showed Chrome/128 in the UA but 146
    in sec-ch-ua.
  • navigator.deviceMemory was impossible. Profiles reported raw RAM (16, 32,
    6, 12); Chrome only ever reports a power of two capped at 8. Fixed in the
    stealth script, Cloak flags, the trust check and auto-adjust.
  • Chrome version follows the engine. At launch, a profile's UA moves to the
    engine's real Chromium major (Playwright 151, Cloak 146 today) and the
    dashboard copy follows. A UA older than the engine is caught by feature
    detection. Default versions for new profiles moved from 125–128 to 148–151.
  • navigator.userAgentData on Playwright/Patchright reported
    HeadlessChrome/Chromium with no "Google Chrome", which contradicted the UA
    and sec-ch-ua. Now set through CDP Emulation.setUserAgentOverride with full
    metadata (brands, full version, platform version, architecture, model), so JS
    and every Client Hints header agree.
  • Dashboard: api.health was defined twice, so the startup liveness probe was
    actually calling /api/profiles/health. The probe is now api.ping().

Added

  • Active session lock (persona/locks.py). A profile can only be open in one
    live process. Opening it twice is the "same account, two devices at once"
    signal, and two browsers writing one user-data dir corrupt it. The lock is a
    file in the profile's user-data dir naming its process, taken atomically by
    every launch path (dashboard, persona launch, attach, warm-up, cookie and
    trust tools). A lock left by a crashed process is detected and taken over.
    The dashboard now shows a profile opened from a terminal as running, and
    refuses to open its session. persona unlock <profile> clears a lock by hand.
  • Profile history (persona/history.py). When a session ends (launch,
    warm-up, automation), the caches the browser rebuilds by itself (HTTP cache,
    code cache, GPU shader caches) are deleted, and the rest of the session is
    saved as a zipped snapshot. The last 5 are kept (history_keep in Settings
    or PUT /api/config, 0 turns it off). An unchanged session isn't saved twice.
    Restore rolls cookies and site data back, and snapshots the current state
    first so a restore can be undone. In the dashboard: editor Session tab →
    Session history. From the CLI: persona history <profile>, with
    --snapshot or --restore <id>. API: GET/POST /api/profiles/{id}/history,
    POST …/history/{snapshot}/restore.
  • Backups leave out those same caches and the browser's lock files, so they're
    much smaller.
  • Per-profile storage toggles (editor Advanced → Keep between
    sessions
    , persona storage <profile> --off history passwords). Local
    storage, IndexedDB, history, saved passwords, open tabs, bookmarks and Web
    Store extensions can each be switched off. Switched-off data is cleared when
    the browser closes (and before the next launch, in case it crashed), so it
    never builds up or lands in snapshots and backups. Works for Chromium engines
    and Camoufox. Cookies are always kept.
  • WebGL capability table (persona/webgl.py). Fingerprinters read the
    whole WebGL table (limits, extensions, shader precision), not just the GPU
    name. The trust check now reads it and verifies two things. First, that the
    limits fit the GPU's graphics API: Chrome's Direct3D 11 backend has a unique
    signature (32767 viewport, 4095 vertex and 1024 fragment uniform vectors,
    measured on Chrome 151), so a profile claiming an Apple GPU on a Windows PC,
    or a Windows GPU on SwiftShader, is caught. Second, that it's the same device
    as before: the first reading is stored with the profile, and a later change
    is flagged. Auto-adjust re-baselines it, validate() and the dashboard's
    coherence meter flag a recorded table that no longer fits the chosen GPU.
    The table is read, never faked: a JS patch can't make the GPU honour limits
    it doesn't have.
  • Headless sessions use the real GPU (--enable-gpu on Playwright and
    Patchright). Headless Chrome otherwise renders WebGL in software
    (SwiftShader), a known headless tell that also contradicts the claimed GPU.
    This affects trust checks, warm-ups and headless automation.
  • Launch-flag denylist, with reasons. Extra launch flags that would change
    the identity behind Persona's back are now ignored too: --user-agent,
    --lang, --window-size (it has to agree with the spoofed screen),
    --force-device-scale-factor, --use-angle/--use-gl (GPU backend),
    --webrtc-ip-handling-policy, --no-sandbox, --headless, and CloakBrowser's
    identity flags (--fingerprint-gpu-renderer and friends; --fingerprint-noise
    stays allowed). Each ignored flag now says why, both in launch warnings and
    live under the field in the editor. A flag must look like a flag
    (--name or --name=value).
  • Languages from the exit IP (opt-in per profile: editor Proxy tab →
    Languages follow the exit IP, or persona edit <profile> --auto-lang on).
    Each launch sets navigator.languages, the locale and the Accept-Language
    header from the proxy's exit country, in the shape real non-English users
    have: de-DE, de, en-US, en. 70 countries are mapped (English where it's the
    usual browser language, e.g. India, Pakistan, Nigeria). The trust check
    expects the launch languages and auto-adjust doesn't write them back. Off by
    default, because moving an existing account to a new language is a signal of
    its own.
  • SOCKS4 proxies work on every engine and in the pool's health check. They
    go through the local bridge, spoken as SOCKS4a so hostnames resolve at the
    proxy (no DNS leak). The dashboard was quietly saving SOCKS4 as HTTP; it's
    now a proxy type of its own.
  • Change-IP URL for rotating and mobile proxies. Save the vendor's
    rotation URL on a proxy, then press Change IP in the editor (or
    persona proxy change-ip <profile>, POST /api/profiles/{id}/proxy/change-ip,
    POST /api/proxies/{id}/change-ip). The next launch re-reads the new exit
    IP's timezone and location. Assigning a pool proxy carries its URL along.
  • Paste a proxy in any format. The editor's Proxy tab fills itself in from
    a pasted host:port:user:pass, user:pass@host:port or
    socks5://user:pass@host:port, and persona create/edit --proxy accept the
    same formats.
  • Launch lifecycle. The exit-IP lookup now starts first and runs while the
    engine starts, so a proxied launch takes about as long as the slower of the
    two, not both. Each driver marks the launch ready in the session lock once
    its window exists (ready in the API). The dashboard logs a slow start after
    60 s and stops a launch that isn't up after 5 minutes, with a clear error,
    instead of the profile showing as running forever.
  • No more orphaned browsers (persona/procs.py). Stopping a profile on
    Windows used to end only the launcher, leaving Chrome running and holding the
    profile folder, so the next launch failed with "profile in use". Browser
    processes are now found by the profile directory on their command line and
    ended on stop, and any left over from a crash are ended before the next launch.
  • devicePixelRatio as part of the device. Macs are 2, phones carry their
    panel's exact ratio (Pixel 7 2.625, Galaxy S21 3, …), and Windows 1536x864 is
    1.25 (a 1920x1080 laptop at 125%). Before, every desktop was 1, so every macOS
    profile was a tell. validate() flags impossible ratios, and the trust check
    and auto-adjust read the real one. Old profiles derive it automatically.
    Deliberately not GoLogin's "+0.00000001" trick: a real Retina Mac reports
    exactly 2.
  • Timezone + geolocation from the proxy's exit IP (persona/geo.py). At
    launch the exit IP is looked up through the proxy, and the browser presents
    that IP's timezone and city. Rotating/residential pools no longer contradict
    the stored zone. Geolocation is a per-profile spot within a few km of the city,
    stable across launches. Before, every profile in a country reported the same
    capital-city coordinate. Falls back to the stored values if the lookup fails.
    The trust check expects the launch timezone, and auto-adjust won't rewrite an
    account's locale to follow it. Cloak also gets the resolved IP for WebRTC.
  • SOCKS5 proxies with username/password (persona/bridge.py). Chromium can't
    authenticate to SOCKS5 (launch failed with "Browser does not support socks5
    proxy authentication"). A loopback HTTP bridge now carries the credentials,
    hands hostnames to the proxy unresolved (no local DNS), and is shared per
    upstream. The proxy pool's health check now tests SOCKS5 through it too.
  • Engine/machine warnings (launch_warnings): a profile whose OS differs
    from this machine on Playwright/Patchright gets a warning, because text renders
    with the machine's real fonts and no JS patch hides that. Cloak warns for
    Linux/Android profiles (it can only present Windows/macOS) and for macOS
    profiles off a Mac (needs Mac fonts and a HiDPI screen). Shown at
    persona launch, on the Health page, and from /api/fingerprint/validate.
  • Per-profile extra launch flags (launch_args / dashboard "Extra launch
    flags"). Flags Persona manages itself (proxy, user-data dir, DNS lockdown,
    debugging port, extensions, Cloak seed) are dropped with a warning instead of
    silently undoing a guarantee.

Full history: CHANGELOG.md