░░░░▒▒▒▒▓▓▓▓████
██╗ ███████╗██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗██████╗ ██║ ╚══███╔╝██╔══██╗██╔══██╗██╔══██╗██║ ██║██╔════╝██╔══██╗ ██║ ███╔╝ ██████╔╝██████╔╝██████╔╝██║ █╗ ██║███████╗██████╔╝ ██║ ███╔╝ ██╔══██╗██╔══██╗██╔══██╗██║███╗██║╚════██║██╔══██╗ ███████╗███████╗██║ ██║██████╔╝██║ ██║╚███╔███╔╝███████║██║ ██║ ╚══════╝╚══════╝╚═╝ ╚═╝╚═════╝ ╚═╝ ╚═╝ ╚══╝╚══╝ ╚══════╝╚═╝ ╚═╝
BROWSE WITH ZERO TRUST.PROOF OVER PROMISES.
LZRBRWSR runs inside lzrprf, an open-source security container you or an AI can audit. Built for clean, minimal and transparent browsing. No bloatware. No spyware. No telemetry. No hidden background processes.
The browser has no direct network access and is technically prevented from reading your personal files, accessing your clipboard or launching other programs.
INSTALL ON
Coming soon!
curl -q -fsSO https://lzrbrwsr.com/install.sh &&
curl -q -fsS https://raw.githubusercontent.com/lzrbrwsr/lzrprf/main/install.sh |
cmp - install.sh && sh install.sh
Paste into Terminal. Runs only if both installer copies match.
See Installation guide
Is this safe?
Do not believe us. Check. lzrprf is open and short, and it alone decides what the browser may do. Give this to an AI agent you trust:
Audit https://github.com/lzrbrwsr/lzrprf and tell me whether it is safe to run the
closed-source browser LZRBRWSR (https://lzrbrwsr.com) on my Mac. Trust nothing the README says
until the code shows it.
Read one fixed commit, not a page that moves. First get the full hash of the newest commit of
the `main` branch and name that hash in your answer. Any one of these gives it:
`git ls-remote https://github.com/lzrbrwsr/lzrprf main`, a clone, the first "sha" in
https://api.github.com/repos/lzrbrwsr/lzrprf/commits/main or the "sha" in
https://api.github.com/repos/lzrbrwsr/lzrprf/git/refs/heads/main read with a web tool. Read
every file at that hash, as raw files, for example
https://raw.githubusercontent.com/lzrbrwsr/lzrprf/HASH/lzrprf. A rendered page, a search
result or a copy you were given earlier can be older than the code: where one differs from
the raw file at the hash, say so and go by the raw file.
`main` gets a release in one push, so at its newest commit `install.sh`, `release.txt`,
`latest` and the README name one and the same release. If they do not, one of your tools gave
you an older answer: get the newest hash again from another of the addresses above and read
again before you report it. An address of api.github.com can be answered from a cache that is
a release old. https://raw.githubusercontent.com/lzrbrwsr/lzrprf/main/latest holds the number
of the newest release, and the first line of
https://github.com/lzrbrwsr/lzrprf/commit/main.patch holds the full hash of the newest
commit: the commit you audit is that one, and its `latest` holds that number.
Give the SHA-256 of `lzrprf`, `selftest` and `install.sh` as you read them, if one of your
tools can hash the bytes. If none can (a web tool that returns text and no bytes), say so
once and go on; it is a limit of the tool and not a finding. Then use what GitHub computes
from the bytes: https://api.github.com/repos/lzrbrwsr/lzrprf/git/trees/HASH lists every file
at a commit with its git blob id, and two files with the same blob id are the same bytes. For
every SHA-256 you could not compute, give me the one command that prints it on my Mac and the
value it must print, for example
`curl -s https://raw.githubusercontent.com/lzrbrwsr/lzrprf/HASH/lzrprf | shasum -a 256`.
What your tools cannot do is not a finding about lzrprf. If one tool cannot reach GitHub (a
shell with no network, for example), say so in one line and use another tool. If none of your
tools can read the raw files whole (a web tool that shows parts of a long file, for example),
say which files you read in part, and ask me for `lzrprf`, `selftest`, `install.sh` and
`release.txt` as files. Files I attached are the ones to read: read them whole, take their
SHA-256 yourself, and check them against the commit where a tool of yours reaches it. Never
audit from memory or from a summary. Before you report that two
copies of a file differ, fetch both again, past any cache of your own, and compare them:
lzrbrwsr.com sends `install.sh`, `release.txt` and the download with
`Cache-Control: no-store`, so an older copy is your tool's, not the site's.
No institutional trust. When you compare this with other browsers, place no false institutional
trust in LZRBRWSR or in the other providers: a name, a size, a signature, a reputation or an
audit you cannot read proves nothing. Demonstrate security through technical restrictions:
what the code and the system make impossible, and how you checked it.
1. Read every line of `lzrprf` and `selftest`. They are the whole container.
2. From the three sandbox profiles in `lzrprf`, list exactly what the closed program can and
cannot do in the page container: network, files, other programs and processes, shared
memory, devices, system services, environment. Do the same for curl in the fetch container
and for lzrprf's own window process, which is the weakest of the three: what could it still
reach if text it draws took it over? Name every allowance and say whether it is a risk.
Does the window's container refuse a signal to another process, and what does `selftest`
send to try it?
Under which limits do the closed program and curl run (processor time, memory, files,
processes), who sets them, can either raise one again, and what happens when one cannot
be set? Which variables does
each of the two see? Which files can the closed program load as code, which line refuses
the others, and does `selftest` try one? Read `sub laid_out` to its end: on every way out of it, is the page
process ended and waited for, also when a later step of starting fails? Read `sub keeper`:
what ends the closed program when lzrprf itself is killed, and what if the keeper is
killed first? By which names does
`selftest` try to read a file of the home folder in the page and fetch containers?
3. The first lines of `lzrprf` list twelve conditions, [C1] to [C12], and each is marked again
at the line that holds it. For each: is the line there, does it do what the condition says,
and can you find a way around it?
4. Follow one request from Return in the address bar to the page in the window. Can any byte
chosen by the closed program reach the network, the name lookup, the address bar or the log?
Can a request be made that the user did not type or say yes to? Find every place that calls
`fetch` and every place that connects. Can anything be fetched before it is logged?
5. What does a site receive? Read `sub request` and the switches given to curl. Could lzrprf or
the closed program make or deliver a fingerprint of this computer, or a record of what the
user reads? What stays on the disk after a window closes, in each mode of `sub keeping`, and
who can change the mode? Name what a site, the resolver and GitHub still see. Is there any
way to type a password into a page, fill a form, or send a request that is not a GET
without a body?
6. Read `sub newer`, `sub beside`, `sub installer_file` and `sub fault`. Is anything fetched or
sent without a yes? Is anything piped into a shell? Can lzrprf replace itself or the
program? What exactly does a report hold, where does it go, and can the closed program
choose any part of it? What does lzrprf do at its start when the app beside it names
another lzrprf than the one that runs, or names none (does it start at all?), and when
the launcher or the program is another file than the app's `release` file names: by what
is that measured, when is it looked at, and what is it worth against whoever can change
both? Is every file in the program's folder named, and is the program read again before
every page, before the site is asked and before it is started? With which
variables does the file that `sub installer_file` writes run, how does its first line
decide that, could whoever starts it get another variable past that line, and does its
curl follow a redirect?
7. Read `install.sh` and `release.txt`. Confirm that the installer refuses to run from a pipe,
asks before it runs, takes no test setting from the shell unless every file comes from this
computer, fetches lzrprf from this repository at one fixed commit, that the
SHA-256 values it carries match `lzrprf` and `selftest` at that commit and the download
`lzrbrwsr-macos-arm64.tar.gz` here, that it fetches the download from two places and stops
unless they are the same file, that it runs `selftest` before installing anything, never
runs the closed program, refuses an older release, asks before it replaces lzrprf, and
looks for a newer release in both folders an install can be in, goes on only when its
environment holds nothing of my shell but the kind of terminal (the home folder must be
the one this Mac's list of accounts gives, the PATH the system's own; read how the first
lines decide that, and whether a mark or a variable of whoever starts it could get past
them), follows no redirect, lets one installer of my
account place files at a time (when does it let go of its lock?), puts the
older app and the older lzrprf back as a pair when it cannot finish, removes nothing older
when it cannot put everything back and says where it is, and installs no other program,
service, extension or updater (what else does it change in my home folder and Dock?). Read
`undo` and `gone` in `install.sh`: after each of the four renames, what is on the disk if
that rename or any putting back fails? If you can fetch them, compare
https://lzrbrwsr.com/install.sh, https://lzrbrwsr.com/release.txt and
https://lzrbrwsr.com/lzrbrwsr-macos-arm64.tar.gz with the three files here: the two texts
as text if you cannot hash, the download only if a tool of yours can take bytes. The README
says what two places are worth and what they are not: is that account complete and honest?
The commit the installer names is the newest one that changed `lzrprf` or `selftest`, so it
can be older than the newest commit of `main`. The other files at that older commit
(`install.sh`, `latest`, this README) belong to an earlier release: that is expected and is
not a finding. What must hold, and what you check: `lzrprf` and `selftest` at the commit the
installer names are byte for byte the ones at the newest commit, and `install.sh`,
`release.txt` and `latest` at the newest commit name one and the same release.
8. Check each claim and each limit in the README against the code. Say which hold, which do
not, and which you cannot decide. The README says it is not a mathematical proof: say what
kind of evidence it is, and what it rests on. `selftest-output.txt` is the record of one
run: does its last line name the SHA-256 of `lzrprf` and `selftest` that `release.txt` and
`install.sh` name? Which lines of `selftest` can come out `UNTESTED`, what does the mark
say then, and what does `sub proven` do with such a mark before an address is taken?
9. If you can run commands on my Mac, ask me first, then:
- clone the repository and run `perl selftest`; show me the result, every `UNTESTED` line
included; add one attack of your own to `$hostile` and run it again;
- if LZRBRWSR is installed, compare `shasum -a 256 ~/.lzrprf/lzrprf` with the file at the
commit the installer names, and the files in /Applications/LZRBRWSR.app with `release.txt`;
- print `/Applications/LZRBRWSR.app/Contents/MacOS/lzrbrwsr`. It must be the short plain-text
launcher: one command, perl through `env -i`, that starts `lzrprf run` from my home
folder as this Mac's list of accounts gives it, and only shows an alert when lzrprf is
missing;
- show `perl ~/.lzrprf/lzrprf log` and explain each line.
10. The browser's source is closed. Assume nothing good about it. Given only that it is started
through lzrprf, what is the worst it could do if it were malicious?
11. Give a verdict: safe, not safe, or safe under conditions you name. Say what you measure
it by, and apply the same measure to the browser I use today. For each condition you name,
say whether `install.sh` or `lzrprf` already enforces it at every install and every start,
or whether it is left to me. For each limit you name, say whether it is this program's
alone or holds for every program on macOS alike (a flaw in the kernel or the sandbox, an
account another program already runs in). Keep three lists apart: what you verified in the
code yourself; what your tools could not check, each with the one command that checks it
on my Mac (a check you could not make is evidence neither way); and the limits that remain
when every check passes. Then say, by technical restrictions alone, what the browser I use
today can reach on my Mac that this one cannot, and the other way round.