[Testannounce] Last Day to Save $300!

[testannounce at announce.puri.sm]

The Librem 15 Sale - End of Year Sale

Librem 15


  Last Day to Save $300!

Today is the last day to get *$300 off* the Librem 15

Get your new Desktop Replacement before this sale ends January 1st

Ultra-portable workstation laptop that was designed chip-by-chip,
line-by-line, to respect your rights to privacy, security, and freedom.

Order Now <https://shop.puri.sm/shop/librem-15>


    Why FSF Endorsing PureOS Matters

It was three years ago today, December 21, 2017, that the Free Software
Foundation announced it had endorsed PureOS
<https://www.fsf.org/news/fsf-adds-pureos-to-list-of-endorsed-gnu-linux-distributions-1>.
Getting FSF endorsement is not an easy task and involves a lot of
rigorous evaluation. Sometimes people ask us why we decided to create
and maintain PureOS instead of using an existing distribution such as
Debian (which PureOS is based on). After all, it’s a lot of extra work
to maintain your own distribution, and even more work to maintain one
that qualifies for FSF endorsement. In this article we will discuss why
we consistently choose the harder road and why PureOS being endorsed by
the FSF benefits your freedom, your privacy and your security (in
particular supply chain security).

Tech companies, especially those who are in the FOSS community, often
find themselves in a situation where they must choose between
compromising on their values to take an easier path, or sticking with
those values even if it means a lot of extra work. At each step in
Purism’s history we would have had a much easier path if we had
compromised like so many others have. Instead we have consistently
chosen the longer and more difficult road *because we believe in free
software* to our core <https://puri.sm/about/social-purpose/>.


      Choosing the Harder Road

It would have been a lot easier to rebrand an off-the-shelf laptop, slap
a pre-existing Linux distribution on it, use proprietary drivers for
everything, and not care about coreboot support. There are plenty of
successful businesses out there that do precisely that.

It was a lot harder to design our own laptop not just so it had kill
switches to protect privacy, but design it so that all the hardware
worked out of the box with free software drivers and the CPU supported
coreboot. It was also extra work to maintain our own Linux distribution
that only had free software, so we could qualify for FSF endorsement.

It would have been a lot easier to take an off-the-shelf ARM phone that
already had kernel support with proprietary drivers, and use some
pre-existing mobile-only OS. It would have been easier (and thinner!) to
discard modularity and just have everything on one chip.

It was a lot harder to design a phone from the ground up
<https://puri.sm/posts/breaking-ground/> so that it would qualify for
RYF (a designation that not even everyone in FOSS community values, much
less society at large), that separated the cellular modem from the CPU,
and made it possible to disable it with a hardware kill switch. It was
also harder to invest the software engineering time to have our phone
supported in the mainline Linux kernel and write (and upstream!)
phosh/phoc/libhandy/squeekboard so that the current Linux desktop
ecosystem could work on a mobile platform not just in PureOS, but Debian
(and any other distribution that wanted to package it) as well.


      What's In It For Me?

So why is it so important that the Free Software Foundation endorsed
PureOS? In addition to the fact that we firmly believe in free software,
we also believe that having an operating system that runs on 100% free
software *directly benefits you and the rest of society*. We often say
that we sit on a three-legged stool of Freedom, Privacy and Security.
Let’s talk about how an OS that runs 100% free software directly
benefits you in each of those categories.


      Freedom

Perhaps the most obvious benefit of PureOS being 100% free software is
freedom <https://www.gnu.org/philosophy/free-sw.en.html>. Every piece of
software in PureOS has a corresponding source code repository that is
licensed with a FSF-approved license. This means you are free to
download, inspect, and modify any of the software in PureOS directly. If
you want to improve a piece of PureOS software you are free to fix it
and share your fix with the rest of the world under the same
freedom-preserving license.

You are also free from the whims or poor decisions of a software
maintainer. If a software developer decides to abandon their project, if
they take it in a direction you or the community don’t like, or if you
submit improvements the maintainer doesn’t accept, you are even free to
create a competing version of the software (forking) based on your
modified code.


      Privacy

Privacy is perhaps a benefit that isn’t so obvious in free software.
Yet, one of the main effects of smartphone apps being proprietary
shareware is that they are funded by and large by ads and directly or
indirectly capture and share your private data. This same approach often
extends into proprietary desktop applications as well.

Because PureOS is 100% free software, it doesn’t suffer from these same
privacy problems. Why? Besides the fact that all software has to go
through a rigorous acceptance process before it is added to the OS, if a
developer decided to write software that benefited you while also
violating your privacy, you would be free to fork their code and remove
the privacy-violating bits.

Many proprietary phone apps hide their privacy-violating features as
well. After all, why exactly does a flashlight application need full
access to the Internet, your contact list, your location, and your
photos? In the free software world, you could inspect such an
application and confirm whether they are actually capturing any of that
data, discover how they are using it, and disable or remove those bits.


      Security

The final area where free software provides a huge benefit is in
security. Supply chain security has started to be a hot topic in the
security world, for good reason, and *you cannot get better supply chain
security than with free software*. While we’ve written about protecting
the digital supply chain
<https://puri.sm/posts/protecting-the-digital-supply-chain/> before in
the context of how we protect our products both in firmware and
software, it’s worth highlighting here where a free software OS provides
the biggest benefits.

At the initial level free software and proprietary software use similar
security measures to protect against supply chain attacks. A software
repository is owned by a limited list of maintainers who control what
source code and files are allowed in the repository and approve all
changes. Both free and proprietary software developers these days
typically sign their code changes with a personal signature verifying
that the change came from them. When the software gets packaged, that
binary package is also typically signed with a key owned by the company
or software project so the end user can verify that the package hasn’t
been modified by anyone else, before they install it.

Yet we have seen that supply chain attacks can bypass these security
measures most often by compromising build servers, injecting malicious
code into the binary package, and getting it signed with official
signatures so it looks legitimate. While supply chain attacks do
sometimes target the source code itself, it’s rarer because it’s easier
to trace and more difficult to hide changes to the source code
long-term, even with proprietary software which has a smaller group of
people allowed to audit the code.

Free software adds an additional layer of supply chain security that
proprietary software simply can’t, due to the freedom of the code. While
an attacker can try to sneak malicious code into the source code itself,
it’s much more challenging to hide that code long-term, given that code
changes are not only audited by the software maintainers themselves, but
any interested third party as well as security researchers and even
regular end users. While some security researchers are just as
comfortable auditing binaries as source code, for many it’s a lot easier
and faster to audit code for backdoors when the code is freely available.

Finally, free software has a gigantic advantage over proprietary
software in supply chain security due to Reproducible Builds
<https://reproducible-builds.org/>. With Reproducible Builds you can
download the source code used to build your software, build it yourself,
and compare your output with the output you get from a vendor. If the
output matches, you can be assured that no malicious code was injected
somewhere in the software supply chain and it 100% matches the public
code that can be audited for back doors. Because proprietary software
can’t be reproducibly built by third parties (because they don’t share
the code), you are left relying on the package signature for all your
supply chain security.


      Conclusion

We are proud of PureOS’s Free Software Foundation endorsement, not only
because we spent a lot of effort to get it, because we believe in free
software, or because of our Social Purpose Corporation charter
<https://puri.sm/about/social-purpose/>, but also because we believe
free software directly benefits our customers and society at large and
that is why our laptops, PCs, servers and phones all ship with PureOS.


    Phosh Overview

phosh <https://honk.sigxcpu.org/con/phosh_overview.html> is graphical
shell for mobile, touch based devices like smart phones. It’s the
default graphical shell on Purism’s Librem 5
<https://puri.sm/products/librem-5/> (and that’s where it came to life)
but projects like Postmarket OS
<https://wiki.postmarketos.org/wiki/Phosh>, Mobian
<https://wiki.mobian-project.org/doku.php?id=intro> and Debian
<https://packages.debian.org/sid/phosh> have picked it up putting it
into use on other devices as well and contributing patches.

This post is meant as a short overview how things are tied together so
further posts can provide more details.


      A PHone SHell

As mobile shell phosh provides the interface components commonly found
on mobile devices to:

  * launch applications
  * switch between running applications and close them
  * lock and unlock the screen
  * display status information (e.g. network connectivity, battery level)
  * provide quick access to things like torch or Bluetooth
  * show notifications

Phosh

It uses GObject <https://en.wikipedia.org/wiki/GObject> object system
and GTK <https://en.wikipedia.org/wiki/GTK> to build up the user
interface components. Mobile specific patterns are brought in via
libhandy <https://gitlab.gnome.org/GNOME/libhandy>.

Since phosh is meant to blend into GNOME <https://www.gnome.org/> as
seamlessly as possible it uses the common interfaces present there via
D-Bus <https://en.wikipedia.org/wiki/D-Bus> like |org.gnome.Screensaver|
or |org.gnome.keyring.SystemPrompter| and retrieves user configuration
like keybindings via GSettings <https://developer.gnome.org/GSettings/>
from preexisting schema.

The components of a running graphical session roughly look like this:

Phosh Session

The blue boxes are the very same found on GNOME desktop sessions while
the white ones are currently only found on phones.

feedbackd <https://source.puri.sm/Librem5/feedbackd> is explained
quickly: It’s used for providing haptic or visual user feedback and
makes your phone rumble and blink when applications (or the shell) want
to notify the user about certain events like incoming phone calls or new
messages. What about phoc and squeekboard?


      phoc and squeekboard

Although some stacks combine the graphical shell with the display server
(the component responsible for drawing applications and handling user
input) this isn’t the case for phosh. phosh relies on a Wayland
<https://en.wikipedia.org/wiki/Wayland_(display_server_protocol)>
compositor to be present for that. Keeping shell and compositor apart
has some advantages like being able to restart the shell without
affecting other applications but also adds the need for some additional
communication between compositor and shell. This additional
communication is implemented via Wayland protocols. The Wayland
compositor used with phosh is called /phoc/
<https://source.puri.sm/Librem5/phoc> for /PHone Compositor/.

One of these additional protocols is wlr-layer-shell
<https://github.com/swaywm/wlr-protocols/blob/master/unstable/wlr-layer-shell-unstable-v1.xml>.
It allows the shell to reserve space on the screen that is not used by
other applications and allows it to draw things like the top and bottom
bar or lock screen. Other protocols used by phosh (and hence implemented
by phoc) are wlr-output-management
<https://github.com/swaywm/wlr-protocols/blob/master/unstable/wlr-output-power-management-unstable-v1.xml>
to get information on and control properties of monitors or
wlr-foreign-toplevel-management
<https://github.com/swaywm/wlr-protocols/blob/master/unstable/wlr-foreign-toplevel-management-unstable-v1.xml>
to get information about other windows on the display. The later is used
to allow to switch between running applications.

However these (and other) Wayland protocols are not implemented in phoc
from scratch. phoc leverages the wlroots
<https://github.com/swaywm/wlroots> library for that. The library also
handles many other compositor parts like interacting with the video and
input hardware.

The details on how phoc actually puts things up on the screen deserves a
separate post. For the moment it’s sufficient to note that phosh
requires a Wayland compositor like phoc.

We’ve not talked about entering text without a physical keyboard yet –
phosh itself does not handle that either. squeekboard
<https://source.puri.sm/Librem5/squeekboard> is the on screen keyboard
for text (and emoji) input. It again uses Wayland protocols to talk to
the Wayland compositor and it’s (like phosh) a component that wants
exclusive access to some areas of the screen (where the keyboard is
drawn) and hence leverages the /layer-shell/ protocol. Very roughly
speaking it turns touch input in that area into text and sends that back
to the compositor that then passes it back to the application that
currently gets the text input. squeekboard’s main author dcz has some
more details here <https://dcz_self.gitlab.io/posts/input_method/>.


      The session

So how does the graphical session in the picture above come into
existence? As this is meant to be close to a regular GNOME session it’s
done via gnome-session <https://gitlab.gnome.org/GNOME/gnome-session>
that is invoked somewhat like:

|phoc -E 'gnome-session --session=phosh' |

So the compositor /phoc/ is started up, launches /gnome-session/ which
then looks at /phosh.session/ for the session’s components. These are
/phosh/, /squeekboard/ and /gnome-settings-daemon/. These then either
connect to already running services via D-Bus (e.g. NetworkManager,
ModemManager, …) or spawn them via D-Bus activation when required (e.g.
feedbackd).


      Calling conventions

So when talking about phosh it’s good to keep several things apart:

  * phosh – the graphical /shell/
  * phoc – the /compositor/
  * squeekboard – the /on screen keyboard/
  * phosh.session: The /session/ that ties these and GNOME together

On top of that people sometimes refer to ‘Phosh’ as the software
collection consisting of the above plus more components from GNOME
(/Settings/, /Contacs/, /Clocks/, /Weather/, /Evince/, …) and components
that currently aren’t part of GNOME but adapt to small screen sizes, use
the same technologies and are needed to make a phone fun to use e.g.
/Geary/ for email, /Calls/ for making phone calls and /Chats/ for SMS
handling.

Since just overloading the term Phosh is confusing /GNOME/Phosh Mobile
Environment/ or /Phosh Mobile Environment/ have been used
<https://salsa.debian.org/DebianOnMobile-team/meta-phosh/-/blob/debian/master/debian/control>
to describe the above collection of software and I’ve contacted GNOME on
how to name this properly, to not infringe on the GNOME trademark but
also give proper credit and hopefully being able to move things upstream
that can live upstream.

That’s it for a start. phosh’s development documentation can be browsed
here <https://honk.sigxcpu.org/projects/phosh/docs/> but is also
available in the source code <https://source.puri.sm/Librem5/phosh>.

Besides the projects mentioned above credits go to Purism
<https://puri.sm/> for allowing me and others to work on the above and
other parts related to moving Free Software on mobile Linux forward.


    App Showcase: Animatch

Animatch is a fun, easy to install app on the Librem 5. Pop open the
PureOS store and install.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/Animatch.mp4?_=1>

Each subsequent level is more difficult, changing the shape of the board
and adding additional items into the game.

Animatch

Like all our software, this is install-able on a Desktop as well as
completely open for you to modify share, or reuse
<https://gitlab.com/HolyPangolin/animatch/-/blob/master/COPYING>.


    App Showcase: Lollypop

Within the PureOS Store, you can easily install Lollypop, a desktop
music player that has been adapted for use on the go. Simply put your
music in ~/Music and start the app.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/lollypop2.mp4?_=1>

Like most music players, you can select a category like, genres,
artists, and albums, but you get the extra bonus of being able to use
the desktop features like Audio Scrobbling.

Lollypop

Cut out the ads, and keep the music playing, try out Lollypop
<https://wiki.gnome.org/Apps/Lollypop> today.


    App Showcase: Backups

Déjà Dup <https://wiki.gnome.org/Apps/DejaDup> is the recommended way to
backup your data on all Librem hardware. It allows you to schedule
backups or restore past backups.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/bk.mp4?_=1>

Before you run a backup, you’ll need to set up somewhere for the backup
to go. In most cases, that will be an internal SD card. FAT32 will work
for backups but is not ideal because it lacks support for large files.
Likewise, larger SDs come with an NTFS partition, which is not suitable
for use with PureOS. The solution is to reformat your SD with EXT4.
Install Gparted and you’re off.

Backups View

With an SD card installed and formatted, you can open the backups app,
and select the files you want and don’t want to be backed up, then start
a backup.

Encrypted Passwords

Restoring after a backup is straightforward and intuitive. Select the
backup by date and let the restore begin.

Restoring

If you run into issues starting GParted. Try applying this workaround:

|sudo apt install x11-xserver-utils DISPLAY=:0 xhost +SI:localuser:root |

As the video pointed out, you may also need to install python-gobject if
you see the error: No module named gi.repository.

|sudo apt install -y python-gobject |


    App Showcase: Password Safe

Using strong passwords is a good way to help protect your accounts. On
the Librem 5, we recommend you use Password Safe
<https://gitlab.gnome.org/World/PasswordSafe> to keep track of and
generate better passwords.

Sorry, your client doesn't seem to support embedded videos. View the
video directly here <https://videos.puri.sm/promo/pass_safe2.mp4?_=1>

Password safe is compatible with Keypass databases, this helps make the
switch simple if you're already using a password manager.

Own and manage your own keys, on your own hardware.

Purism

Thanking you for your support,
— the Purism team (feedback at puri.sm)

------------------------------------------------------------------------

Note: contents of this email are CC-by-SA; feel free to forward it to
friends!

/To remove yourself from our announcements list, simply email
announce-leave at announce.puri.sm <mailto:announce-leave at announce.puri.sm>
and you will automatically be instructed how to unsubscribe./

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://announce.puri.sm/pipermail/testannounce/attachments/20201231/97b94d09/attachment-0001.html>