Skip to content

Latest commit

 

History

History
308 lines (270 loc) · 17.5 KB

privacy.md

File metadata and controls

308 lines (270 loc) · 17.5 KB

Privacy

What Solid Memo does with personal data. It has no server of its own and no accounts: a learner's study is in their own pod or, before they log in, in the browser. The app has no analytics, sets no cookies and doesn't track anyone.

In your pod

Once the learner logs in, all their study is in their pod, in an instance folder (solid-memo/<name>/ by default). It holds decks and cards, each card's review state, the answer log, preferences, drafts, and a digest that speeds up the next visit (data-model.md lists every document). The app reads and writes them from the browser, straight to the pod's server, and keeps no other copy.

The Studio's graph of an instance reads those documents and, as logging in does, the WebID profile, whose storages tell which addresses are in the pod (instanceGraph.ts). It draws addresses the documents name, such as the WebID, a library release or a card's picture, as they are, and never fetches them, in the pod or not.

The pod's server decides who else may read them. Solid Memo registers only the instance in a type index, a private one unless the learner chooses a public one, and none of its data by itself (data-model.md). A public type index the app creates is readable by everyone, so other apps find what it registers: the instance's name and address, not its data. Only a release the learner publishes from the Studio is public; it carries the authors' names, and their email addresses when given.

Each answer in the log records the card, when, and how well. Since vocabulary 1.19, it records too how long the learner took to recall the answer and, in study, to grade it, leaving out time the app was hidden and any wait over ten minutes. It records the day the card was due and the device's offset from UTC at answer time, which hints at the learner's time zone then (data-model.md, statistics.md). These go with every answer, in study and in a course, and no setting turns them off. They stay in the log's private documents.

The digest keeps a summary of each past month of the log, so the strip above the deck list needn't reread them (data-model.md). For each study day, it counts answers, new cards, reviews, lapses, remembered reviews of young cards, and how many answers took each second. It's the instance's digest.ttl, beside the log.

In the browser

Before logging in, the learner studies as a guest, in a pod kept in the browser's IndexedDB (database solid-memo-guest-pod, indexedDbResourceStore.ts, guest-mode.md). It stays on that device until the learner moves it into their own pod.

A few choices stay in localStorage, out of the pod and in force before any pod is reached:

Key What Written by
solid-memo:language the chosen language localStorageLanguagePreference.ts
solid-memo:theme light, dark or the browser's; copied from the preferences once saved localStorageThemePreference.ts
solid-memo:palette the chosen colors (none for Standard); copied from the preferences localStoragePalettePreference.ts
solid-memo:palette-colors a chosen custom palette's address, base and colors, for the first paint; copied from the pod (none for a built-in palette) localStorageCustomPalettePreference.ts
solid-memo:textSize the chosen text size (none for Default); copied from the preferences localStorageTextSizePreference.ts
solid-memo:seenHighlights the new-version highlights this browser has shown localStorageSeenHighlights.ts
solid-memo:recentLanguages.deck, solid-memo:recentLanguages.own languages picked lately for text remembered.ts
solid-memo:webId the WebID last logged in with, only if the learner checked the box to remember it remembered.ts
solid-memo:collapsedGroups.<instance URL> which deck groups the learner folded remembered.ts
solid-memo:update:<…> a guest's study being moved or added, so another tab knows localStorageUpdateJournal.ts
solid-memo:logout set and taken off at once to tell other tabs of a logout, only where the browser has no BroadcastChannel; holds nothing logoutChannel.ts
solid-memo:studioLayout.v1, solid-memo:studioRecent.v1, solid-memo:studioInstances.v1 the Studio's layout; its palette's last commands; and, by instance URL, saved views, pins and the decks and drafts opened last prefs.ts

A logout leaves these keys in place, solid-memo:palette-colors, solid-memo:webId, solid-memo:collapsedGroups.<instance URL> and solid-memo:studioInstances.v1 among them. They hold no credential. They do hold instance, deck, draft and palette URLs, a palette's colors, and a remembered WebID, which anyone using the same browser profile can read. That is why the WebID is kept only when the learner asks, and a login with the box unchecked forgets it. They stay because they are this device's and not the session's. The folds, saved views and pins are kept nowhere else, so removing them at a logout would lose them for good. The palette's copy is what the next first paint uses.

During a login, sessionStorage holds the page the learner was on (solid-memo:login-hash), to bring them back to it. Until the next page load, it holds the address of the identity provider a login or a silent restore went to, which the provider's answer is checked against (solid-memo:login-issuer) (solidSessionGateway.ts). While a login or a session restore is under way, it also holds the sign-in client's mark that this tab may have sent the learner to the identity provider (solid-memo:provider-redirect). The mark stays until the next restore in that tab ends, or the tab closes. Until the next page load, it holds the address of the provider a silent restore went to and when it went (solid-memo:restore-attempt). A login with the box to remember the WebID checked holds that WebID (solid-memo:login-webId, remembered.ts) until the next page load, which keeps it as solid-memo:webId if the login succeeded with it. The authentication library under the sign-in client (client/session.ts, @inrupt/solid-client-authn-browser) stores in the browser what it needs to restore the session, such as the identity provider and the app's registration with it. A build with the other sign-in client, solid-memo-client, keeps it in IndexedDB instead (database solid-memo-oidc): the identity provider, the app's registration, the WebID, the refresh token and a key pair whose private key can't leave the browser. During a login, sessionStorage holds the request under way (solid-memo:oidc-login). Its access tokens stay in memory (solid-memo-client.md).

None of this leaves the device. Clearing the site's data removes it all, the guest's pod included.

What the site's host sees

The site is static files on GitHub Pages (deployment.md). Loading a page sends GitHub the learner's IP address, the browser's user agent and the address asked for, under GitHub's privacy statement. The deck library comes from the same site, so GitHub sees which deck versions the app fetches. GitHub never sees pod data.

Someone else's copy of Solid Memo is served by their host and may read its deck library from elsewhere (VITE_LIBRARY_INDEX_URL, deck-library.md).

Other servers your browser contacts

The browser contacts these, each when it's needed:

  • The WebID's server, to read the learner's profile at login (authentication.md).
  • The identity provider, which handles the login and sees that the learner logged in to Solid Memo. The provider, not the browser, may fetch Solid Memo's Client ID Document from the site to learn who the app is (authentication.md). A provider picked from the suggestions (onboarding.md) is one in podProvider.ts; the project runs none of them.
  • The pod's server, for everything the learner studies.
  • The server of a deck's document outside the learner's pod, when their study's catalog names one there. It's asked as no one, and the app saves nothing to it (boundaries.md).
  • The servers of pictures on cards, each seeing a request from the browser: for the library's decks, image hosts such as flagcdn.com, upload.wikimedia.org, thumb.wikimedia.org and iiif.micr.io; for the learner's own cards, wherever their pictures are. For a deck added by link, they're only the hosts the learner chose (below).
  • The address of a deck or release added by link, and, to look for its newer version, the folders above it up to its instance and a storage description one of them links to (deck-library.md).
  • The server of a release a Studio draft follows, or whose next version the Studio starts, once a page load. It's asked as no one, unless it's the learner's own pod. Starting a next version also asks, as no one, the servers of the documents the release names its series and publisher in (studio.md).

Links the learner follows, such as a deck's sources, lead to those sites as any link does.

Pictures on a deck added by link

A card's picture is a request from the learner's browser to the server its address names, and the author of a release chooses that address and may run that server. With an address of its own for each card and side, that server's log could tell when the learner studies, from which IP address and which cards came up. Were the answer's picture requested as it's revealed, it could tell how long they took.

So a deck from a release outside the library's index, a course too, shows no picture until the learner chooses to (deckPictures.tsx), and so does every deck of an instance outside the learner's own pod and every Studio draft (below):

  • Until then, nothing is requested from the picture's host, in study, in a course, in card lists and their thumbnails, or on a card's page. The card shows its text, the picture's description and Show pictures from the host, which says what showing them means. A list has the choice above it and an empty frame in each picture's place. In the Studio, a card open beside its deck's cards shares the list's choice. Adding the release shows no card's picture, and that screen says they stay hidden.
  • The choice is for one deck and one host. A picture from another host, which an upgrade may bring, asks again. It's kept with the deck in the pod (sm:deckPictureHost on its catalog entry, data-model.md), never set by a release, and the deck's Preferences page lists the hosts, each with a button to stop showing its pictures. A deck keeps at most 100 hosts: past that, choosing another drops the one chosen first.
  • Once a host is chosen, it sees a request for each picture it serves as the card comes up: the IP address, the user agent, the address asked for and the time. The answer's picture is requested with the question's, so a request doesn't mark the reveal.
  • Every card's picture is requested with no referrer.

The learner's own decks and copies of the library's load their pictures as before. A card the learner adds to a deck added by link follows the deck, as nothing tells it from the release's for certain, and a card moved or copied to another deck is that deck's.

What counts as a copy of the library's is what the index lists now. A copy whose series has left the index, or one made on a deployment with another library, asks as a deck added by link does. So does any copy while the index can't be read. A copy added by link is never offered a release of the index as its next version, so it can't become a copy of the library's by an upgrade.

Decks and drafts from elsewhere

  • A deck in an instance attached from someone else's pod is written by that pod's owner, along with what it says of itself: a release it was copied from, and hosts as chosen. So every deck there asks, library copy or not, and what its entry says of its hosts isn't believed. The learner's own pod means the storages their profile names, the storage found by walking up from their WebID, or a guest's pod on this device. An instance in a storage entered by hand counts as outside it, and so does every instance until the storages have been read once.
  • A Studio draft may be made from a linked deck or a linked release, and nothing in it says so afterward, so every draft's previews and trial ask, including for pictures the author added.
  • In both, the choice lasts until the page is reloaded and is written nowhere: the pod of an attached instance isn't the learner's, and a draft is published as it's written.
  • A deck read from a file is what the file says. One that names a release outside the index stays a linked deck, and keeps the hosts the file states as chosen, up to the 100 a deck keeps. So a file from someone else can carry pictures from any host and state its own choice. One that names no release, or a release of the library, loads its pictures as the learner's own do. A file is only as trustworthy as whoever gave it.

No analytics, no cookies, no tracking

The app runs no analytics or tracking script and sets no cookies of its own. Its Content Security Policy allows scripts from the site alone, plus one inline script named by its hash (apps/web/index.html, checked by build.test.ts). The project learns nothing about who uses the app.

When something goes wrong

When a screen fails to render, the app shows "Something went wrong" in its place, between the same header and footer. An error nothing else caught (in a button's handler, say) gets a closable notice (ErrorGuard.tsx). Neither sends anything: the error goes to the browser's console and leaves only if the learner takes it out:

  • Copy details copies the app's version and commit, the route the learner was at without its values (#/study?instance=&deck=), and the error's message and stack.
  • Report it opens the project's bug form on GitHub with only the app's version and that route filled in. The details stay out of the link, since a link's query reaches GitHub as soon as it opens: the learner pastes them from Copy details into the form, and they are sent only when the learner submits it.

The app first strips every address from the details, except the paths of the site's own scripts, which show where the code broke (errorReport.ts). It strips web addresses, such as a pod's, a WebID's, a deck's or a card's, with any token in their query. An http: or https: address goes to the end of its word, also when its host is an IPv6 one, its path holds brackets or quotes, its slashes are escaped or missing, or it's URL-encoded once or more. It strips email addresses, including ones in other scripts, and blob:, data:, mailto:, tel: and urn: values. An error's message can still quote other text, such as a card's, a host name written without its https://, or an address split across words or encoded in a way the app doesn't undo. The details stay short. Of the message, each frame of the stack, the route's path and each name in its query, the app reads only the first thousand or so characters, without the word they end in. It cuts what is left to a few hundred once the addresses are stripped. Only the stack's first frames and the query's first names are kept. The details appear under "Technical details" for the learner to read before sending.

What the project has published

Each library deck version names who compiled it. The first 205 name the maintainer, Anton Wiklund, as creator, with his email address as foaf:mbox, and keep it: a published version is never edited (deck-library.md). Later versions name a project contact instead: a dcat:contactPoint pointing at the issue tracker, with no personal email address (deck-library.md). The library's index gives no email address.

The maintainer's email address is published on purpose in CODE_OF_CONDUCT.md, as the private contact for code of conduct reports. Mail to it about anything else, such as a deck published with it, gets a pointer to the public channels (GOVERNANCE.md).