formularium / formularium

Formularium is a FOSS, privacy-first, and user-friendly toolkit for municipalities to support them in making their public services available online.

Formularium α

⚠️ Formularium is still under heavy development! If you are interested in learning more about formularium or even want to contribute, consider joining our slack channel

About

Formularium is a FOSS, privacy-first, and user-friendly toolkit for small to medium-sized municipalities (1-150k inhabitants) to support them in making their public services available online.

Why?: We feel that municipalities are a backbone to democracy but often are left behind when extending the democratic government to the digital world. We think that neither existing vendors nor the federal government provides the software components and the concepts needed to digitize municipalities’ processes.

So we decided to build open-source concepts and software to allow municipalities to develop their dynamic forms themselves.

Features

• Form editor based on the visual programming language blockly. This allows you to build almost any kind of validation/routing logic into your forms without writing a single line of code.
• Security by Design with End-to-End encryption. Every form gets PGP-encrypted before it will be submitted to the backend. Only the administrative staff can decrypt form data locally.
• Proof of transmission: The applicant gets a digitally signed receipt that the server has received their form.

High Level Architecture

Related Projects

• Formularium Backend
• Formularium Desktop

Project setup

npm install

Compiles and hot-reloads for development

npm run serve

Compiles and minifies for production

npm run build

Run your tests

npm run test

Lints and fixes files

npm run lint

Customize configuration

See Configuration Reference.

formularium's Issues

Form submission and encryption

• The server provides a list of public keys from the administrative staff that the applicant uses to encrypt the form's content.
• The applicant submits the encrypted form to the server.
• The server signs the form that has been submitted by the applicant together with the current timestamp and a list of the public keys of the administrative staff used for encryption and returns this signature to the applicant.
• The applicant checks the signature received from the server.
• The applicant generates a PDF Document which includes:
  • The submitted form in a human-readable way.
  • The submitted form, as a JSON object.
  • The submitted form, encrypted for the administrative staff as submitted to the server.
  • The signature received by the server.
  • All the public keys from the administrative staff that have been used for encryption
  • The public key of the server.

So the applicant can prove that they submitted this form with this specific content, encrypted with the public keys of the administrative staff provided by the server, to the server.

implement textareas

Proposal: Migration to x509 Certificates

What changes?
As a user, I want to use signed x509 certificates for encryption when submitting my forms. For Formularium, that means admins in the future will have the following two options:

• using their own PKI infrastructure (e.g. Bundesdruckerei, …)
• using letsencrypt fully integrated into formularium (as easy as our current PGP implementation)

Due to this step, we will also officially discontinue the electron desktop client in favor of the flutter one.

From a public services staff perspective, the main (internal) change is, that now not a user but teams have access to encryption keys. That means also that newly added users (by team managers) can also access form data submitted before they started using formularium.
Internally, every team has an x509 certificate, and every user still has their PGP key. During the runtime of the desktop client, it downloads and decrypts the team's x509 private key that is encrypted for the PGP key of the user. The PGP key and the x509 private key are still generated locally, and only the x509 key is uploaded to the formularium backend in an encrypted way for each user who can access the key.

Why?
From the beginning, it was kind of clear that using user-based PGP-Keys can only be the first step in ensuring end-to-end encryption. Now, as fitconnect - the hopefully soon de facto standard for e2e encrypted communication between public services and citizens becomes more and more concrete, I think it's time to start implementing it. And the first step would be to change from PGP to certificates.

WDYT?

I registered my dog, the generated .pdf contains 3 instances of the same information

Hi!

Sorry if this is intended behavior or a known issue...

On https://formularium.verdrusssache.de/ I filled the form Hundehaltung/Anmeldung and the generated .pdf contains three copies of

Grund für die Meldung
...
Angaben zur Person
...

see attachment: file.pdf

Idea: Separate Public Key Infrastructure so that citizens know which key to use for encryption

Desktop client for administrative staff

As administrative staff I want to use a desktop client that allows me to:

• Login via oauth2 Authorization Code Flow
  • add the refresh-token to the OS-Keychain with Keytar
• setup encryption/decryption of forms
  • generate a new RSA-Key with a minimum length of 4096 and store it also into the Keychain.
  • add the public key automatically to the server
• see a sortable list of stored forms, that can be decrypted by me.
• open the forms and copy the content as
  • TEXT
  • JSON
  • PDF
  • XML
• manage/revoke my own keys
• generate new keys

Technically it's probably a good idea to build this as an electron app because of cross-platform, …

Blockly Context: autocompletion for the context attribute names

Because we are not generating JSON-Schema objects during runtime anymore, it should be super easy to integrate autocompletion into the getContext block.

• autocompletion for json schema edited via the visual editor
• autocompletion for imported json schema

blockly: convert list to enums

Prototype for BPMN-based Form editor

We want evaluate whether BPMN makes sense to use for designing complex form flows. Therefore we want to do a prototype to explore this possibility.

CONCEPT: user accounts

In the future, there should be a mobile app for applicants. This app would allow them to create an account by submitting a PGP public key and responding to a challenge that has to be signed by their public key. There should be an option to add an eID card as a second-factor authentication (maybe https://gitlab.com/adessoAG/FIDELIO/Documentation could be useful).

After setting up the account, the applicants can set up push notifications to get notified about new messages provided by the server.

Then applicants can submit their forms as before. But now there is a way to communicate between administrative staff and applicants PGP encrypted. And the server allows us to send push notifications/chat communication/…

block types check by blockly

As a user, I only want to connect blocks that actually can be connected.

Add an option to use external files in the forms editor

• add an extra tab to the editor where files like
  • xDatenfelder schemas
  • json schema forms
  • lists
    • xDatenfelder genericode
    • csv
  • static assets like images and video
  • markdown
• can be uploaded
• can be previewed
• can be used in the blockly editor

implement multiple block

This allows rendering a dynamic amount of fields or form sections.

Setup (travis-)ci for automated testing

The browser's back button unexpectedly leaves a form instead of going one step back

When trying to return to a previous page in a form, using the 'back' function of the browser leaves the form entirely. Non intuitive behavior can drive potential users away.

I just saw a tweet about this project, went to the demo and this was my only immediate nitpick. Great idea for a project and i hope it get's some adoption!

implement i18n for forms

• use static code analysis to find the strings in the code (https://github.com/oliviertassinari/i18n-extract)
• add a translation view
• use the translations

CONCEPT: Share Forms with other Municipalities

change names of render{Name} methods in blockly to more generic render('name', payload) method

This will make building the plugin system so much easier.

Replace opengpgp.js with kbpgp.js

As openpgp.js becomes more and more pain to work with I will move first formularium-desktop and soon also formularium itself to kbpgp.js.

• replace in formularium-desktop
• replace in formularium

Convert object to array if multiple occurrences of a key in context

Implement back button in forms