Riot.IM Messenger: Kurzanleitung für Benutzer mit Videos (Stand 05/2019)

Riot Messenger, die neue Art der Kommunikation!

  • Freie Open Source Anwendung
  • verfügbar für Windows, Linux, Mac, Android und IOS
  • Unterstützt End-to-End Verschlüsselung ohne Mitleser, auch bei Gruppenchat!
  • Chat, Voice und Video. Voice verschlüsselt, wenn der Raum verschlüsselt ist!
  • Der Referenz Client für den Matrix Server.
  • Jeder kann seinen eigenen Matrix Server betreiben oder sich auf einem öffentliche Server einen Account lösen.

UPDATE / HINWEIS / WICHTIG (2019-05-16)

Aufgrund der Überlastung des größten öffentlichen Servers matrix.org empfehle ich einen anderen öffentlichen Server aus dieser Liste für die Erstellung eines Accounts zu wählen:

Ich empfehle Freunden den Server: https://www.privacytools.io/, welcher in dieser Anleitung auch referenziert wird. Der Homeserver zur Registrierung findet sich hier: https://riot.privacytools.io/#/welcome . Für die Riot Windows, Linux, MAC,, Android oder IOS App, verfügbar von https://riot.im sind folgende Einstellungen zu verwenden: Heimserver: https://chat.privacytools.io . Deine Adresse wird dann: benutzername:privacytools.io

Erfreuliche News

Es ist sehr erfreulich, dass immer mehr Menschen auf Ihre Privatsphäre und Daten achten. Langsam bildet sich auch bei breiteren Bevölkerungsschichten ein Bewusstsein für mehr Kontrolle über die eigenen Daten aus. Riot.im als Anwendung für den Benutzer in Verbindung mit dem Open Source Matrix Synapse Server (Matrix.org) ist mehr als ein Messenger, es ist ein Tool für dezentralisierte Zusammenarbeit, Internettelefonie, Videotelefonie und Messaging. Durch den dezentralen Aufbau wird nur eine minimale Menge an Metadaten erzeugt und bei aktivierter End-to-End Verschlüsselung ist Mitlesen auch am Server unmöglich. Da so viele Menschen in die Matrix wechseln und dieser Beitrag extrem oft abgerufen wird, erfolgte nun ein Update der Anleitung.

Dezentraler Aufbau heißt, dass alle Matrix Server, ähnlich wie bei E-Mail untereinander kommunizieren können. Der Benutzer verbindet sich zu seinem Homeserver und damit wird seine IP für Betreiber anderer Server auch nicht sichtbar.

Anleitungen

Matrix Server (nur für alle, die selbst einen Server betreiben möchten)

Unter https://kmj.at/how-to-setup-your-matrix-synapse-messaging-homeserver-may-2019-english/ findet sich eine Anleitung zur Einrichtung eines eigenen Servers. Alle die einen eigenen Server für sich, Freunde oder die Firma an die Matrix anschließen wollen, finden sich hier alle Informationen für das sehr einfache Setup.

Riot.im (für alle Benutzer, Step-by-Step Anleitung)

Riot.im ist die App zum Einstieg in die Matrix für alle die einfach und sicher kommunizieren wollen!. Das wirklich genial daran ist, dass es die Riot App für IOS (Apple), Android, Windows, MAC und Linux gibt und man mit allen Geräten gleichzeitig online sein kann. Alle Geräte sind immer synchron und es ist egal, wo man gerade liest oder kommuniziert.

Diese Anleitung zeigt, wie man einen Account anlegt und den ersten Chat startet.

1) Registrierung des Accounts

Jeder Benutzer in der Matrix benötigt einen Account auf einem Homeserver. Ähnlich wie bei E-Mail haben die Adressen 2 Teile. Zum Beispiel ist meine Adresse:

  • @karl:matrix.ctseuro.com

Diese Adresse besteht auf dem @, welche die Adresse eröffnet. Danach folgt der Name des Benutzers am Homeserver, in meinem Fall karl. Die Trennung des Namens und der Servers erfolgt durch einen :. Danach folgt der Servername, auf dem der Benutzer einen Account hat, in meinem Fall am Server matrix.ctseuro.com.

Wir registrieren für diese Anleitung einen Account bei privacytools.io, welchen wir aus obiger Liste ausgewählt haben. Um den Account zu registrieren gehen wir auf:

klicken dort auf Konto erstellen und geben in der folgenden Maske

Benutzernamen und Passwort ein. Als Open Source Messenger sammelt Riot, anders als zentrale Datensilos keine Telefonnummern, oder E-Mail Adressen. Damit ist auch die Eingabe einer E-Mail Adresse nicht notwendig. Auf mobilen Endgeräten fragt Riot höflich um den Zugriff auf Kontakt, Mikorofon und Kamera. Den Zugriff auf die Kontakte sollte man generell ablehnen und Mikrofon und Kamera benötigt man nur, wenn man über Riot auch telefoniert, bzw. Videochats führt.

ACHTUNG Ohne E-Mail Adresse kann das Passwort natürlich auch nicht über diese zurückgesetzt werden. Ändern kann man es in den Einstellungen, aber wer sein Passwort vergisst hat den Account für immer verloren! Also Passwort gut merken. Es empfiehlt sich ein Passwort Safe ala Keepass.

Danach auf Registrieren klicken und die Frage nach der fehlenden E-Mail mit fortfahren beantworten.

Danach befinden wir uns bereits in der Webversion des Riot Messengers. Diese wollen wir aber, da wir überall mit End-to-End Verschlüsselung arbeiten wollen, nicht verwenden. Details dazu später. Über Einstellungen -> Abmelden melden wir uns ab. Abmelden ist extrem wichtig!

Beim Abmelden werden wir gefragt, ob wir die Schlüsselsicherung verwenden wollen. Dazu muss ich etwas ausholen, dieser Punkt ist aber sehr wichtig.

Ich versuche es nicht ganz so technisch, einfach verständlich zu erklären. Jedes Gerät eines Benutzers hat einen Schlüssel, zusätzlich haben Räume Schlüssel. Jeder Chat is ein Raum. D.h. 1:1 Chat ist ein Raum mit den beiden Benutzern, ein Gruppenchat ist ein Raum mit mehr als zwei Benutzern. Diese Schlüssel werden auf dem Endgerät gespeichert und wären einem anderen Gerät am selben Account nicht zugänglich. Zusätzlich löscht das Programm beim Abmelden aus Sicherheitsgründen alle Schlüssel. Um nun sicherzustellen, dass diese Schlüssel nicht verloren gehen – dann wären ältere Chats mangels fehlender Schlüssel nicht mehr lesbar – wurde die Möglichkeit eines Schlüsselbackups am Server eingerichtet.

Es ist ganz wichtig ein wirklich langes und sicheres Passwort zu verwenden und sich dieses und den Wiederherstellungsschlüssel sehr gut zu merken! (Keepass!) Es kann niemand helfen! Wer vergisst, hat verloren!

Ein Klick auf Beginne die Schlüsselsicherung zu nutzen bringt die Passwortabfrage. Hier wird das sichere Passwort eingegeben und auf Nächstes geklickt.

Nun ist es ganz wichtig den Wiederherstellungsschlüssel sicher zu verwahren!

Nicht fortfahren, bevor alles gut gesichert verwahrt ist! In die Zwischenablage kopieren und verwenden, bzw. herunterladen. Danach OK!

Und bei Erfolg noch einmal OK!

Nun, da die Schüssel gesichert sind, noch einmal Einstellungen und Abmelden, danach sollte die Abmeldung erfolgen.

2) Installation und Start der Riot APP

Der Riot Messenger ist für alle Betriebssysteme verfügbar und es können mehrere Geräte gleichzeitig verwendet werden. Z.B. am PC und am Handy, oder Tablet. Wir verwenden in dieser Anleitung die PC Version, jedoch funktionieren Android und IOS analog dazu.

Das Programm laden wir von https://riot.im und installieren es am System.

Danach den Riot Messenger starten und auf Anmelden klicken oder tippen.

Nun ist es notwendig den Homeserver umzustellen. Als Default ist matrix.org vorgegeben, d.h. wir klicken auf Ändern und geben den Homeserver: - https://chat.privacytools.io

und unsere zuvor registrierten Benutzerdaten ein.

Die vollständige Matrix Adresse ist @meinwunschname:privacytools.io

Der Server gibt einen Raum vor. Hier einfach auf den Raumnamen klicken, dann auf das Zahnrad und den Raum verlassen und die Einstellungsseite mit dem X schließen.

Die persönlichen Einstellungen finden sich beim eigenen Namen unter Einstellungen. Pro Raum gibt es das Zahnrad für die Raumeinstellungen. Es gibt sehr viele Möglichkeiten Benachrichtigungen und anderes Wichtiges einzustellen.

Hinweis: MeinRiot läuft aus verschiedenen selbst eingestellten Gründen in Englisch, aber natürlich spricht Riot per Default, auf einem deutschsprachigen System Deutsch.

3) Schlüsselsicherung verbinden

Nun ist es ganz wichtig die zuerst erstellte Schlüsselsicherung zu aktivieren. Auf Connect this device, bzw, Verdinden Schlüsselsicherung klicken.

Passwort eingeben

Und fertig. Mit X wegklicken.

chritt 2 und 3 müssen pro Gerät, für welches dieser Account verwendet wird, wiederholt werden.

4) Der erste Chat

Wir starten mit einem 1:1 Chat und schreiben mich an. Dazu klicken wir auf das + neben Personen und geben meine Adresse @karl:matrix.ctseuro.com ein.

Mit Chat beginnen leiten wir den Chat ein. Danach muss gewartet werden, ob die Einladung zum Chat von der anderen Seite akzeptiert wird.

Wenn der Eingeladene den Raum betritt wird eine Statusmeldung ausgegeben:

WICHTIG: Der Chat ist aktuell noch nicht verschlüsselt!

Über das Zahnrad in die Raumeinstellungen gehen, dort auf Sicherheit und Datenschutz und den Verschlüsselungsregler auf EIN stellen:

und OK, danach mit X wegklicken:

Das Einschalten der Verschlüsselung wird als Statusmeldung eingetragen.

Sicher einer der gewöhnungsbedürftigsten Punkte beim Umstieg ist die Verschlüsselung. Um es für Benutzer ohne Kenntnisse über Verschlüsselung und Kryptografie verständlich zu machen:

  • Nachdem die Verschlüsselung aktiviert wird, erscheinen bei anderen Benutzern orange Warndreiecke. Nun müssen die Schlüssel (einer oder mehrere pro Benutzer) verifiziert werden. Danach erscheint beim Schreiben ein grünes Schloss.
  • Bei Gruppenräumen kann es sinnvoller sein, die Warnmeldung mit „Trotzdem senden“ zu quittieren und nicht alle Benutzer des Raumes zu verifizieren.

Um die Geräte eines Benutzers zu verifizieren, klickt man auf den Benutzer und lässt sich die Geräteliste anzeigen. Mit Verifizieren kann man die Geräte verifizieren. Am besten mit Legacy Verifizierung verwenden (für veraltete Clients), das geht am schnellsten.

Dieser Vorgang muss für alle Geräte durchgeführt werden, andernfalls muss die Warnmeldung mit „Trotzdem senden“ quittiert werden, um Text zu senden.

HINWEIS

Bitte keine Suppportanfragen oder ähnliches an meine persönliche Adresse richten.

Es gibt einen öffentlichen Raum, den Sie über die Raumliste, oder durch Eingabe von

  • /j #kmj:matrix.ctseuro.com

betreten können. Hier helfe ich ab und zu mit Tipps aus.

Verschiedenes

Aufbau Mobile:

Musterbild zeigt die Android App, die Symbole sind aber auf allen Systemen gleich.

Im Hauptbereich sieht man:

  • Favoriten (über die Raumeinstellungen)
  • Personen (1:1 Kommunikation)
  • Räume (Gruppenkommunikation)
  • Niedrige Priorität (Nur Sortierung, sonst, keine Auswirkung)

In der Auswahlleiste unten:

  • Zurück zum Home Schirm
  • Favoriten anzeigen
  • Personen anzeigen
  • Räume anzeigen
  • Communities anzeigen

Communities:

Du kannst Communities (bestehen aus Personen und Räumen) erstellen, beitreten, oder eingeladen werden. Communities machen die Kommunikation, bzw. die Organisation von Projekten einfacher, da man in einer Ansicht alle Personen und Räume sieht. In der PC App und am Tablet werden die Communitysymbole für eine einfachere Navigation auch links angezeigt.

Räume:

Riot besteht aus Räumen, auch 1:1 Chats sind Räume, jedoch mit nur 2 Personen. Gruppenräume sind für mehrere Personen offen. Der Eröffner des Raumes ist Administrator und kann über das Zahnrad, bzw. über das Menü des Raum verwalten. Nur bei 1:1 Räumen sind beide Gesprächspartner Raumadministrator. Räume können manuell den Favoriten, bzw. der niedrigen Priorität zugeordnet werden. Damit bleibt die Übersicht gewahrt.

Räume haben vielfältige Einstellungsmöglichkeiten für Berechtigungen, Bild, Beschreibung und vieles mehr. Alle Einstellungen finden sich im Zahnrad, bzw. über die Raumeinstellungen. Die wichtigste Einstellung ist, egal ob 1:1 oder Gruppe, die Verschlüsselung zu aktivieren. Damit ist alles sicher End-to-End verschlüsselt.

Adressen in der Matrix:

Ähnlich wie bei E-Mails werden die Adressen in der Matrix aufgebaut und bestehen auch aus Benutzer und Domain. Eine persönliche Adresse sieht so aus:

  • @benutzername:server.com

Anders als bei E-Mails ist die erste Stelle speziell:

@ - steht für eine Person
# - steht für einen Gruppenraum
+ - steht für eine Community

Danach folgt der Benutzername und durch : getrennt der Server auf der der Benutzer registriert ist. Da sich aktuell sehr viele am öffentlichen Matrix Server registrieren sehen viele Adressen so aus:

@meinname:matrix.org

Wenn jemand auf einem anderen Server registriert ist, wie z.B. ich, dann sieht die Adresse z.B. so aus:

@karl:matrix.ctseuro.com

Mit dieser Adresse kann man einen 1:1 Chat mit dieser Person starten. Wenn Sie die Adresse eines Raumes kennen, können Sie durch Eingabe von:

- /j #kmj:matrix.ctseuro.com

einen Raum betreten.

Sprachnachrichten

Multi Account auf Android und LineageOS

  • Riot.IM für Account 1 installieren
  • miniVector (Riot Version ohne Telefonie) für Account 2 installieren

How to Setup your Matrix Synapse Messaging Homeserver (May 2019/English)

Feel free to link to this page if you like this blog post, but do not copy/paste the text somewhere else without asking. If you want to post the text in full or partial on your site or blog you must add in bold inside a h1 tag:

Just to be clear

This is how I have done it. Whatever you do, you do it for yourself. I am in no way responsible for anything. Everything you do is on your own risk!

Public Matrix Room

There is a public room #kmj:matrix.ctseuro.com where I answer questions from time to time in English or German. Please join if you have questions.

A guide to setup a Matrix Synapse Homeserver

End-to-end encrypted messenger and collaboration server using Python 3.6. We will add Turnserver for voice based communicatioa, add a firewall and more. If we are done you run your own homeserver which is able to communicate with all other matrix servers on the Internet via federation. Prefered Client on Linux, Mac, Windows, Android and IOS is https://riot.im .

At the time of writing this age we use FreeBSD 12.0. Newer FreeBSD Versions are very similar to setup.

prepare everything

For bare bone setup write the ISO to some USB stick, for virtual setup using Proxmox or VMWare, place the ISO on your host and create a virtual machine booting with the ISO file.

The required resources are:

  • RAM 4-6 GB for up to 100 users
  • 2-3 Cores
  • 80GB Harddisk
  • network card
  • static IP address with DNS entry pointing to it

Assume we create the homeserver matrix.ourdomain.com on IP 1.2.3.4. Each Matrix Synapse server is called homeserver. We have pointed an DNS A record matrix.ourdomain.com to IP 1.2.3.4. Check with nslookup matrix.ourdomain.com, or ping matrix.ourdomain.com that the name resolves.

NOTE: you must change ourdomain.com to your domain name and 1.2.3.4 to your IP!

Setup FreeBSD

Boot the ISO file and do a minimum setup of FreeBSD as described on FreeBSD.org. Enable sshd to be able to login. This sets the hostname, creates your user account, formats the harddisk and creates the partitions. Do not install ports or other stuff, except sshd. Finally reboot and login with the user you created. Detailed FreeBSD setup instructions is out of the scope of this document.

Setup additional software

use su to become root and enter y if asked to fetch and install pkg system.

  • pkg install ca_root_nss gcc mc bash curl
  • pkg install libffi libxslt jpeg
  • pkg install py36-virtualenv
  • pkg install py36-psycopg2
  • pkg clean -a

Create Environment

  • virtualenv-3.6 -p python3.6 /home/synapse/env

Always use sh for working with virtualenv.

sh
. /home/synapse/env/bin/activate
(env) #

The env # must be shown and do not forget to add the . at the beginning of the line. If it is not shown you have made some error! Go back and recheck if this happens!

Setup basic Synapse inside virtualenv

While still showing (env) # do:

  • pip install –upgrade pip
  • pip install –upgrade setuptools

This should show:

 . /home/synapse/env/bin/activate
(env) # pip install --upgrade pip
Requirement already up-to-date: pip in /usr/home/synapse/env/lib/python3.6/site-packages (19.1.1)
(env) # pip install --upgrade setuptools
Requirement already up-to-date: setuptools in /usr/home/synapse/env/lib/python3.6/site-packages (41.0.1)

If this is fine, continue with:

  • pip install matrix-synapse[all]

This will take some time, download different things and should finally end without error.

Setup Postgresql Database

  • leave virtualenv with typing: deactivate
  • you should only see # without env now
  • pkg install postgresql95-server
  • sysrc postgresql_enable=yes
  • service postgresql initdb
  • service postgresql start

now we have a running Postgresql database engine.

Setup the Firewall, DNS, NTP and Mail.

Before we continue we should setup our firewall to avoid attacks while runnign our setup.

Create /etc/rc.firewall.KMJ with the following content:

#!/bin/sh -
#
# Setup system for ipfw(4) firewall service.
#

# Suck in the configuration variables.
if [ -z "${source_rc_confs_defined}" ]; then
        if [ -r /etc/defaults/rc.conf ]; then
                . /etc/defaults/rc.conf
                source_rc_confs
        elif [ -r /etc/rc.conf ]; then
                . /etc/rc.conf
        fi
fi

############

setup_loopback() {
        ############
        # Only in rare cases do you want to change these rules
        #
        ${fwcmd} add 100 pass all from any to any via lo0
        ${fwcmd} add 200 deny all from any to 127.0.0.0/8
        ${fwcmd} add 300 deny ip from 127.0.0.0/8 to any
        ${fwcmd} add 400 deny all from any to ::1
        ${fwcmd} add 500 deny all from ::1 to any
}

. /etc/rc.subr
. /etc/network.subr

############
# Set quiet mode if requested
#
case ${firewall_quiet} in
[Yy][Ee][Ss])
        fwcmd="/sbin/ipfw -q"
        ;;
*)
        fwcmd="/sbin/ipfw"
        ;;
esac

############
# Flush out the list before we begin.
#
${fwcmd} -f flush
setup_loopback

############
#
# We do not allow IPv6 Traffic
${fwcmd} add deny  ip6 from any to any

# Allow TCP through if setup succeeded
${fwcmd} add pass tcp from any to any established

# Allow IP fragments to pass through
${fwcmd} add pass all from any to any frag

# Allow setup of incoming connections
         
${fwcmd} add pass tcp from ${MGMTIP} to me 22 setup     # SSH

${fwcmd} add pass tcp from any to me 8448 setup         # MATRIX
${fwcmd} add pass tcp from any to me 3478 setup         # TURN
${fwcmd} add pass udp from any to me 3478 keep-state    # TURN
${fwcmd} add pass tcp from any to me 5349 setup         # TURN TLS
${fwcmd} add pass udp from any to me 5349 keep-state    # TURN TLS

${fwcmd} add pass tcp from any to me 80 setup           # letsencrypt only
${fwcmd} add pass tcp from any to me 443 setup          # https rev proxy fuer matrix

# Allow setup of outgoing TCP connections only
${fwcmd} add pass tcp from me to any setup

# Disallow setup of all other TCP connections
${fwcmd} add deny tcp from any to any setup

# Allow DNS queries out in the world
${fwcmd} add pass udp from me to any 53 keep-state

# Allow NTP queries out in the world
${fwcmd} add pass udp from me to any 123 keep-state

# Deny the Rest
${fwcmd} add deny all from any to any

Assuming you have an IPv4 connectivity only we block all IPv6 traffic. Furthermore it is not recommended to open SSH to the public. I assume you are a good administrator and restrict ssh access to the static IP of your notebook or desktop system. Otherwise you should setup OpenVPN to access your server. Do not use any as MGMTIP. If you open critial services to the public you will regret it later. They will brute force you and one day somebody will break into your system. Be smart and work like a professional!

Now add or change the settings in /etc/rc.conf. We already add settings we need later. You network configuration is not shown here and should not be touched. Do not change

  • hostname=
  • ifconfig_
  • defaultrouter=

parameters.

keymap="de.kbd" # do not change your keymap. we use german
clear_tmp_enable="YES"
syslogd_flags="-ss"
dumpdev="NO"

MGMTIP="5.6.8.9" # change to static IP of your notebook or desktop system
 
firewall_enable="YES"           # Set to YES to enable firewall functionality
firewall_script="/etc/rc.firewall.KMJ" # Which script to run to set up the firewall
firewall_type="KMJ"         # Firewall type (see /etc/rc.firewall)
firewall_quiet="NO"             # Set to YES to suppress rule display
firewall_logging="YES"          # Set to YES to enable events logging
firewall_logif="NO"             # Set to YES to create logging-pseudo interface

#######################
 
local_unbound_enable="YES"
sshd_enable="YES"
ntpd_enable="YES"

apache24_enable="YES"
postgresql_enable="YES"

synapse_enable="YES"
turnserver_enable="YES"

###############################

now change /etc/resolv.conf so it reads:

search ourdomain.com
nameserver 127.0.0.1
options edns0

The final setting requires that our server is able to send out e-mails.

  • cd /etc/mail
  • make
  • make install
  • edit /etc/mail/aliases and uncomment the root: entry.
  • change it to root: you@yourmaildomain.com
  • run newaliases

Using this settings we run a local cache DNS and resolve locally. Furthermore we run a time syncing via NTP daemon. To make sure everything is done OK, we should reboot now.

  • shutdown -r now

Check our Setup

  • login after reboot
  • do a ps -xaj and check that local-ubound, syslogd, ntpd and postgres deamons are running
  • do a mail -s “test” root, enter some text+ and press CTRL+d to send. You should receive your root mail. Check /var/log/maillog if not,

Setup Turnserver

To handle voice calls behind NAT you should setup Turnserver as kind of proxy. Setup is pretty easy.

  • pkg install turnserver
  • create turnserver.conf like below, but change your IP, domain and secret!
realm=matrix.ourdomain.com
listening-ip=1.2.3.4
#lt-cred-mech
use-auth-secret
static-auth-secret=1cd6c96c1f8d4f1008042d76d646691e3b0512e830d7f486d6ad6b702bfc234e
no-tcp-relay
user-quota=12 # 4 streams per video call, so 12 streams = 3 simultaneous relayed calls per user.
total-quota=1200

cert=/usr/local/etc/matrix-synapse/certs/matrix.ourdomain.com/cert.pem
pkey=/usr/local/etc/matrix-synapse/certs/matrix.ourdomain.com/privkey.pem

do not start turnserver now!

Setup Apache Reversed-Proxy and SSL Cert

We want Apache to handle the connections to https Port 443 from the clients. Federation is done via port 8448. So we need to setup an Apache Reversed-Proxy and get a free SSL Cert from Letsencrypt.

  • pkg install apache24 cronolog
  • we already added apache24_enable=“YES” to /etc/rc.conf earlier
  • save /usr/local/etc/apache24/httpd.conf and replace its content with
  • replace ourdomain.com with your domain
ServerRoot "/usr/local"

ServerSignature Off

Listen 80

LoadModule authn_file_module libexec/apache24/mod_authn_file.so
LoadModule authn_core_module libexec/apache24/mod_authn_core.so
LoadModule authz_host_module libexec/apache24/mod_authz_host.so
LoadModule authz_groupfile_module libexec/apache24/mod_authz_groupfile.so
LoadModule authz_user_module libexec/apache24/mod_authz_user.so
LoadModule authz_core_module libexec/apache24/mod_authz_core.so
LoadModule access_compat_module libexec/apache24/mod_access_compat.so
LoadModule auth_basic_module libexec/apache24/mod_auth_basic.so
LoadModule socache_shmcb_module libexec/apache24/mod_socache_shmcb.so
LoadModule reqtimeout_module libexec/apache24/mod_reqtimeout.so
LoadModule filter_module libexec/apache24/mod_filter.so
LoadModule mime_module libexec/apache24/mod_mime.so
LoadModule log_config_module libexec/apache24/mod_log_config.so
LoadModule env_module libexec/apache24/mod_env.so
LoadModule headers_module libexec/apache24/mod_headers.so
LoadModule setenvif_module libexec/apache24/mod_setenvif.so
LoadModule version_module libexec/apache24/mod_version.so
LoadModule ssl_module libexec/apache24/mod_ssl.so
LoadModule mpm_prefork_module libexec/apache24/mod_mpm_prefork.so
LoadModule unixd_module libexec/apache24/mod_unixd.so
LoadModule autoindex_module libexec/apache24/mod_autoindex.so
<IfModule !mpm_prefork_module>
        #LoadModule cgid_module libexec/apache24/mod_cgid.so
</IfModule>
<IfModule mpm_prefork_module>
        #LoadModule cgi_module libexec/apache24/mod_cgi.so
</IfModule>
LoadModule dir_module libexec/apache24/mod_dir.so
LoadModule userdir_module libexec/apache24/mod_userdir.so
LoadModule alias_module libexec/apache24/mod_alias.so
LoadModule rewrite_module libexec/apache24/mod_rewrite.so

LoadModule proxy_module libexec/apache24/mod_proxy.so
LoadModule proxy_connect_module libexec/apache24/mod_proxy_connect.so
LoadModule proxy_http_module libexec/apache24/mod_proxy_http.so
IncludeOptional etc/apache24/modules.d/[0-9][0-9][0-9]_*.conf
<IfModule unixd_module>
    User www
    Group www
</IfModule>

ServerAdmin hostmaster@ourdomain.com
ServerName matrix.ourdomain.com:80

DirectoryIndex index.html

<Directory />
    AllowOverride none
    Require all denied
</Directory>

DocumentRoot "/usr/local/www/apache24/data"
<Directory "/usr/local/www/apache24/data">
    Options -Indexes +FollowSymLinks -ExecCGI -MultiViews
    AllowOverride None
    Require all granted
</Directory>

<Files ".ht*">
    Require all denied
</Files>

ErrorLog  "|/usr/local/sbin/cronolog /var/log/www/%Y/%m/%d/errors.log"
LogLevel warn

LogFormat "%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i port:%p\"" combined
CustomLog "|/usr/local/sbin/cronolog /var/log/www/%Y/%m/%d/access.log" combined

<IfModule mime_module>
    #
    TypesConfig etc/apache24/mime.types
    #AddType application/x-gzip .tgz
    #AddEncoding x-compress .Z
    #AddEncoding x-gzip .gz .tgz
    AddType application/x-compress .Z
    AddType application/x-gzip .gz .tgz
</IfModule>

Include etc/apache24/extra/httpd-ssl.conf

SSLRandomSeed startup builtin
SSLRandomSeed connect builtin

Include etc/apache24/Includes/*.conf

then save /usr/local/etc/apache24/extra/httpd-ssl.conf and replace it with the following content. Again replace IP and ourdomain.com with yours.

lISTEN 443

SSLCipherSuite HIGH:MEDIUM:!SSLv3:!kRSA
SSLProxyCipherSuite HIGH:MEDIUM:!SSLv3:!kRSA

SSLHonorCipherOrder on

SSLProtocol all -SSLv3
SSLProxyProtocol all -SSLv3

SSLPassPhraseDialog  builtin

SSLSessionCache        "shmcb:/var/run/ssl_scache(512000)"
SSLSessionCacheTimeout  300

<VirtualHost _default_:443>

ServerName matrix.ourdomain.com:443
ServerAdmin hostmaster@ourdomain.com

DocumentRoot "/usr/local/www/apache24/data-ssl"
SSLEngine on

SSLCertificateFile /usr/home/letsencrypt/cts/conf-ip1/certs/matrix.ourdomain.com/cert.pem
SSLCertificateKeyFile /usr/home/letsencrypt/cts/conf-ip1/certs/matrix.ourdomain.com/privkey.pem
SSLCertificateChainFile //usr/home/letsencrypt/cts/conf-ip1/certs/matrix.ourdomain.com/fullchain.pem

UserDir disabled
DirectoryIndex index.html index.htm


<Directory /usr/local/www/apache24/data-ssl>
    Options -Indexes -FollowSymLinks -ExecCGI -MultiViews
    AllowOverride None
    require all granted
</Directory>

################################################################################
# Matrix Synapse
################################################################################

ProxyPass /_matrix http://127.0.0.1:8008/_matrix
ProxyPassReverse /_matrix http://127.0.0.1:8008/_matrix

################################################################################

BrowserMatch "MSIE [2-5]" \
         nokeepalive ssl-unclean-shutdown \
         downgrade-1.0 force-response-1.0

LogFormat "%v %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i port:%p\"" combined
CustomLog "|/usr/local/sbin/cronolog /var/log/www/%Y/%m/%d/access.log" combined

</VirtualHost>

Now create the SSL directory:

  • mkdir /usr/local/www/apache24/data-ssl
  • touch /usr/local/www/apache24/data-ssl/index.html
  • echo “Server is offline” > /usr/local/www/apache24/data-ssl/index.html

NOTE

To be able to receive our cert from Letsenrypt, temporary change

  • Include etc/apache24/extra/httpd-ssl.conf

to

  • #Include etc/apache24/extra/httpd-ssl.conf

in httpd.conf. This must be changed back after we received the initial cert.

Now create the Letsencrypt stuff

  • mkdir -p /home/letsencrypt/cts
  • mkdir -p /usr/local/etc/matrix-synapse/certs
  • create /home/letsencrypt/cts/Run_Certs.sh with the following content
#!/bin/sh

cd /home/letsencrypt/cts
chmod 750 dehydrated
/home/letsencrypt/cts/dehydrated  -c  --config /home/letsencrypt/cts/conf-ip1/config.sh \
                                      --hook /home/letsencrypt/cts/conf-ip1/hook.sh

/usr/sbin/service apache24 restart

########################################################################

HOST=`hostname`
echo "copy cert for synapse / matrix server on ${HOST}"

/bin/cp -r /usr/home/letsencrypt/cts/conf-ip1/certs/${HOST} /usr/local/etc/matrix-synapse/certs
/usr/sbin/chown -R root:nobody /usr/local/etc/matrix-synapse/certs
/bin/chmod -R 755 /usr/local/etc/matrix-synapse/certs

/usr/sbin/service synapse restart

/bin/ps -xaj | /usr/bin/grep synapse
########################################################################
  • chown root:wheel /home/letsencrypt/cts/Run_Certs.sh
  • chmod 750 /home/letsencrypt/cts/Run_Certs.sh

  • create /home/letsencrypt/cts/dehydrated with the following content

#!/usr/bin/env bash

# dehydrated by lukas2511
# Source: https://github.com/lukas2511/dehydrated
#
# This script is licensed under The MIT License (see LICENSE for more information).

set -e
set -u
set -o pipefail
[[ -n "${ZSH_VERSION:-}" ]] && set -o SH_WORD_SPLIT && set +o FUNCTION_ARGZERO
umask 077 # paranoid umask, we're creating private keys

# Find directory in which this script is stored by traversing all symbolic links
SOURCE="${0}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
SCRIPTDIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"

BASEDIR="${SCRIPTDIR}"

# Create (identifiable) temporary files
_mktemp() {
  # shellcheck disable=SC2068
  mktemp ${@:-} "${TMPDIR:-/tmp}/dehydrated-XXXXXX"
}

# Check for script dependencies
check_dependencies() {
  # just execute some dummy and/or version commands to see if required tools exist and are actually usable
  openssl version > /dev/null 2>&1 || _exiterr "This script requires an openssl binary."
  _sed "" < /dev/null > /dev/null 2>&1 || _exiterr "This script requires sed with support for extended (modern) regular expressions."
  command -v grep > /dev/null 2>&1 || _exiterr "This script requires grep."
  _mktemp -u > /dev/null 2>&1 || _exiterr "This script requires mktemp."
  diff -u /dev/null /dev/null || _exiterr "This script requires diff."

  # curl returns with an error code in some ancient versions so we have to catch that
  set +e
  curl -V > /dev/null 2>&1
  retcode="$?"
  set -e
  if [[ ! "${retcode}" = "0" ]] && [[ ! "${retcode}" = "2" ]]; then
    _exiterr "This script requires curl."
  fi
}

store_configvars() {
  __KEY_ALGO="${KEY_ALGO}"
  __OCSP_MUST_STAPLE="${OCSP_MUST_STAPLE}"
  __PRIVATE_KEY_RENEW="${PRIVATE_KEY_RENEW}"
  __KEYSIZE="${KEYSIZE}"
  __CHALLENGETYPE="${CHALLENGETYPE}"
  __HOOK="${HOOK}"
  __WELLKNOWN="${WELLKNOWN}"
  __HOOK_CHAIN="${HOOK_CHAIN}"
  __OPENSSL_CNF="${OPENSSL_CNF}"
  __RENEW_DAYS="${RENEW_DAYS}"
  __IP_VERSION="${IP_VERSION}"
}

reset_configvars() {
  KEY_ALGO="${__KEY_ALGO}"
  OCSP_MUST_STAPLE="${__OCSP_MUST_STAPLE}"
  PRIVATE_KEY_RENEW="${__PRIVATE_KEY_RENEW}"
  KEYSIZE="${__KEYSIZE}"
  CHALLENGETYPE="${__CHALLENGETYPE}"
  HOOK="${__HOOK}"
  WELLKNOWN="${__WELLKNOWN}"
  HOOK_CHAIN="${__HOOK_CHAIN}"
  OPENSSL_CNF="${__OPENSSL_CNF}"
  RENEW_DAYS="${__RENEW_DAYS}"
  IP_VERSION="${__IP_VERSION}"
}

# verify configuration values
verify_config() {
  [[ "${CHALLENGETYPE}" =~ (http-01|dns-01) ]] || _exiterr "Unknown challenge type ${CHALLENGETYPE}... can not continue."
  if [[ "${CHALLENGETYPE}" = "dns-01" ]] && [[ -z "${HOOK}" ]]; then
    _exiterr "Challenge type dns-01 needs a hook script for deployment... can not continue."
  fi
  if [[ "${CHALLENGETYPE}" = "http-01" && ! -d "${WELLKNOWN}" ]]; then
    _exiterr "WELLKNOWN directory doesn't exist, please create ${WELLKNOWN} and set appropriate permissions."
  fi
  [[ "${KEY_ALGO}" =~ ^(rsa|prime256v1|secp384r1)$ ]] || _exiterr "Unknown public key algorithm ${KEY_ALGO}... can not continue."
  if [[ -n "${IP_VERSION}" ]]; then
    [[ "${IP_VERSION}" = "4" || "${IP_VERSION}" = "6" ]] || _exiterr "Unknown IP version ${IP_VERSION}... can not continue."
  fi
}

# Setup default config values, search for and load configuration files
load_config() {
  # Check for config in various locations
  if [[ -z "${CONFIG:-}" ]]; then
    for check_config in "/etc/dehydrated" "/usr/local/etc/dehydrated" "${PWD}" "${SCRIPTDIR}"; do
      if [[ -f "${check_config}/config" ]]; then
        BASEDIR="${check_config}"
        CONFIG="${check_config}/config"
        break
      fi
    done
  fi

  # Default values
  CA="https://acme-v01.api.letsencrypt.org/directory"
  LICENSE="https://letsencrypt.org/documents/LE-SA-v1.2-November-15-2017.pdf"
  CERTDIR=
  ACCOUNTDIR=
  CHALLENGETYPE="http-01"
  CONFIG_D=
  DOMAINS_D=
  DOMAINS_TXT=
  HOOK=
  HOOK_CHAIN="no"
  RENEW_DAYS="30"
  KEYSIZE="4096"
  WELLKNOWN=
  PRIVATE_KEY_RENEW="yes"
  KEY_ALGO=rsa
  OPENSSL_CNF="$(openssl version -d | cut -d\" -f2)/openssl.cnf"
  CONTACT_EMAIL=
  LOCKFILE=
  OCSP_MUST_STAPLE="no"
  IP_VERSION=

  if [[ -z "${CONFIG:-}" ]]; then
    echo "#" >&2
    echo "# !! WARNING !! No main config file found, using default config!" >&2
    echo "#" >&2
  elif [[ -f "${CONFIG}" ]]; then
    echo "# INFO: Using main config file ${CONFIG}"
    BASEDIR="$(dirname "${CONFIG}")"
    # shellcheck disable=SC1090
    . "${CONFIG}"
  else
    _exiterr "Specified config file doesn't exist."
  fi

  if [[ -n "${CONFIG_D}" ]]; then
    if [[ ! -d "${CONFIG_D}" ]]; then
      _exiterr "The path ${CONFIG_D} specified for CONFIG_D does not point to a directory." >&2
    fi

    for check_config_d in "${CONFIG_D}"/*.sh; do
      if [[ ! -e "${check_config_d}" ]]; then
        echo "# !! WARNING !! Extra configuration directory ${CONFIG_D} exists, but no configuration found in it." >&2
        break
      elif [[ -f "${check_config_d}" ]] && [[ -r "${check_config_d}" ]]; then
        echo "# INFO: Using additional config file ${check_config_d}"
        # shellcheck disable=SC1090
        . "${check_config_d}"
      else
        _exiterr "Specified additional config ${check_config_d} is not readable or not a file at all." >&2
      fi
   done
  fi

  # Remove slash from end of BASEDIR. Mostly for cleaner outputs, doesn't change functionality.
  BASEDIR="${BASEDIR%%/}"

  # Check BASEDIR and set default variables
  [[ -d "${BASEDIR}" ]] || _exiterr "BASEDIR does not exist: ${BASEDIR}"

  CAHASH="$(echo "${CA}" | urlbase64)"
  [[ -z "${ACCOUNTDIR}" ]] && ACCOUNTDIR="${BASEDIR}/accounts"
  mkdir -p "${ACCOUNTDIR}/${CAHASH}"
  [[ -f "${ACCOUNTDIR}/${CAHASH}/config" ]] && . "${ACCOUNTDIR}/${CAHASH}/config"
  ACCOUNT_KEY="${ACCOUNTDIR}/${CAHASH}/account_key.pem"
  ACCOUNT_KEY_JSON="${ACCOUNTDIR}/${CAHASH}/registration_info.json"

  if [[ -f "${BASEDIR}/private_key.pem" ]] && [[ ! -f "${ACCOUNT_KEY}" ]]; then
    echo "! Moving private_key.pem to ${ACCOUNT_KEY}"
    mv "${BASEDIR}/private_key.pem" "${ACCOUNT_KEY}"
  fi
  if [[ -f "${BASEDIR}/private_key.json" ]] && [[ ! -f "${ACCOUNT_KEY_JSON}" ]]; then
    echo "! Moving private_key.json to ${ACCOUNT_KEY_JSON}"
    mv "${BASEDIR}/private_key.json" "${ACCOUNT_KEY_JSON}"
  fi

  [[ -z "${CERTDIR}" ]] && CERTDIR="${BASEDIR}/certs"
  [[ -z "${DOMAINS_TXT}" ]] && DOMAINS_TXT="${BASEDIR}/domains.txt"
  [[ -z "${WELLKNOWN}" ]] && WELLKNOWN="/var/www/dehydrated"
  [[ -z "${LOCKFILE}" ]] && LOCKFILE="${BASEDIR}/lock"
  [[ -n "${PARAM_NO_LOCK:-}" ]] && LOCKFILE=""

  [[ -n "${PARAM_HOOK:-}" ]] && HOOK="${PARAM_HOOK}"
  [[ -n "${PARAM_CERTDIR:-}" ]] && CERTDIR="${PARAM_CERTDIR}"
  [[ -n "${PARAM_CHALLENGETYPE:-}" ]] && CHALLENGETYPE="${PARAM_CHALLENGETYPE}"
  [[ -n "${PARAM_KEY_ALGO:-}" ]] && KEY_ALGO="${PARAM_KEY_ALGO}"
  [[ -n "${PARAM_OCSP_MUST_STAPLE:-}" ]] && OCSP_MUST_STAPLE="${PARAM_OCSP_MUST_STAPLE}"
  [[ -n "${PARAM_IP_VERSION:-}" ]] && IP_VERSION="${PARAM_IP_VERSION}"

  verify_config
  store_configvars
}

# Initialize system
init_system() {
  load_config

  # Lockfile handling (prevents concurrent access)
  if [[ -n "${LOCKFILE}" ]]; then
    LOCKDIR="$(dirname "${LOCKFILE}")"
    [[ -w "${LOCKDIR}" ]] || _exiterr "Directory ${LOCKDIR} for LOCKFILE ${LOCKFILE} is not writable, aborting."
    ( set -C; date > "${LOCKFILE}" ) 2>/dev/null || _exiterr "Lock file '${LOCKFILE}' present, aborting."
    remove_lock() { rm -f "${LOCKFILE}"; }
    trap 'remove_lock' EXIT
  fi

  # Get CA URLs
  CA_DIRECTORY="$(http_request get "${CA}")"
  CA_NEW_CERT="$(printf "%s" "${CA_DIRECTORY}" | get_json_string_value new-cert)" &&
  CA_NEW_AUTHZ="$(printf "%s" "${CA_DIRECTORY}" | get_json_string_value new-authz)" &&
  CA_NEW_REG="$(printf "%s" "${CA_DIRECTORY}" | get_json_string_value new-reg)" &&
  # shellcheck disable=SC2015
  CA_REVOKE_CERT="$(printf "%s" "${CA_DIRECTORY}" | get_json_string_value revoke-cert)" ||
  _exiterr "Problem retrieving ACME/CA-URLs, check if your configured CA points to the directory entrypoint."

  # Export some environment variables to be used in hook script
  export WELLKNOWN BASEDIR CERTDIR CONFIG

  # Checking for private key ...
  register_new_key="no"
  if [[ -n "${PARAM_ACCOUNT_KEY:-}" ]]; then
    # a private key was specified from the command line so use it for this run
    echo "Using private key ${PARAM_ACCOUNT_KEY} instead of account key"
    ACCOUNT_KEY="${PARAM_ACCOUNT_KEY}"
    ACCOUNT_KEY_JSON="${PARAM_ACCOUNT_KEY}.json"
  else
    # Check if private account key exists, if it doesn't exist yet generate a new one (rsa key)
    if [[ ! -e "${ACCOUNT_KEY}" ]]; then
      echo "+ Generating account key..."
      _openssl genrsa -out "${ACCOUNT_KEY}" "${KEYSIZE}"
      register_new_key="yes"
    fi
  fi
  openssl rsa -in "${ACCOUNT_KEY}" -check 2>/dev/null > /dev/null || _exiterr "Account key is not valid, can not continue."

  # Get public components from private key and calculate thumbprint
  pubExponent64="$(printf '%x' "$(openssl rsa -in "${ACCOUNT_KEY}" -noout -text | awk '/publicExponent/ {print $2}')" | hex2bin | urlbase64)"
  pubMod64="$(openssl rsa -in "${ACCOUNT_KEY}" -noout -modulus | cut -d'=' -f2 | hex2bin | urlbase64)"

  thumbprint="$(printf '{"e":"%s","kty":"RSA","n":"%s"}' "${pubExponent64}" "${pubMod64}" | openssl dgst -sha256 -binary | urlbase64)"

  # If we generated a new private key in the step above we have to register it with the acme-server
  if [[ "${register_new_key}" = "yes" ]]; then
    echo "+ Registering account key with ACME server..."
    [[ ! -z "${CA_NEW_REG}" ]] || _exiterr "Certificate authority doesn't allow registrations."
    # If an email for the contact has been provided then adding it to the registration request
    FAILED=false
    if [[ -n "${CONTACT_EMAIL}" ]]; then
      (signed_request "${CA_NEW_REG}" '{"resource": "new-reg", "contact":["mailto:'"${CONTACT_EMAIL}"'"], "agreement": "'"$LICENSE"'"}' > "${ACCOUNT_KEY_JSON}") || FAILED=true
    else
      (signed_request "${CA_NEW_REG}" '{"resource": "new-reg", "agreement": "'"$LICENSE"'"}' > "${ACCOUNT_KEY_JSON}") || FAILED=true
    fi
    if [[ "${FAILED}" = "true" ]]; then
      echo
      echo
      echo "Error registering account key. See message above for more information."
      rm "${ACCOUNT_KEY}" "${ACCOUNT_KEY_JSON}"
      exit 1
    fi
  fi

}

# Different sed version for different os types...
_sed() {
  if [[ "${OSTYPE}" = "Linux" ]]; then
    sed -r "${@}"
  else
    sed -E "${@}"
  fi
}

# Print error message and exit with error
_exiterr() {
  echo "ERROR: ${1}" >&2
  exit 1
}

# Remove newlines and whitespace from json
clean_json() {
  tr -d '\r\n' | _sed -e 's/ +/ /g' -e 's/\{ /{/g' -e 's/ \}/}/g' -e 's/\[ /[/g' -e 's/ \]/]/g'
}

# Encode data as url-safe formatted base64
urlbase64() {
  # urlbase64: base64 encoded string with '+' replaced with '-' and '/' replaced with '_'
  #_sed 's/^\x0+//g' | openssl base64 -e | tr -d '\n\r' | _sed -e 's:=*$::g' -e 'y:+/:-_:'
   openssl base64 -e | tr -d '\n\r' | _sed -e 's:=*$::g' -e 'y:+/:-_:'
}

# Convert hex string to binary data
hex2bin() {
  # Remove spaces, add leading zero, escape as hex string and parse with printf
  printf -- "$(cat | _sed -e 's/[[:space:]]//g' -e 's/^(.(.{2})*)$/0\1/' -e 's/(.{2})/\\x\1/g')"
}

# Get string value from json dictionary
get_json_string_value() {
  local filter
  filter=$(printf 's/.*"%s": *"\([^"]*\)".*/\\1/p' "$1")
  sed -n "${filter}"
}

# OpenSSL writes to stderr/stdout even when there are no errors. So just
# display the output if the exit code was != 0 to simplify debugging.
_openssl() {
  set +e
  out="$(openssl "${@}" 2>&1)"
  res=$?
  set -e
  if [[ ${res} -ne 0 ]]; then
    echo "  + ERROR: failed to run $* (Exitcode: ${res})" >&2
    echo >&2
    echo "Details:" >&2
    echo "${out}" >&2
    echo >&2
    exit ${res}
  fi
}

# Send http(s) request with specified method
http_request() {
  tempcont="$(_mktemp)"

  if [[ -n "${IP_VERSION:-}" ]]; then
      ip_version="-${IP_VERSION}"
  fi

  set +e
  if [[ "${1}" = "head" ]]; then
    statuscode="$(curl ${ip_version:-} -s -w "%{http_code}" -o "${tempcont}" "${2}" -I)"
    curlret="${?}"
  elif [[ "${1}" = "get" ]]; then
    statuscode="$(curl ${ip_version:-} -s -w "%{http_code}" -o "${tempcont}" "${2}")"
    curlret="${?}"
  elif [[ "${1}" = "post" ]]; then
    statuscode="$(curl ${ip_version:-} -s -w "%{http_code}" -o "${tempcont}" "${2}" -d "${3}")"
    curlret="${?}"
  else
    set -e
    _exiterr "Unknown request method: ${1}"
  fi
  set -e

  if [[ ! "${curlret}" = "0" ]]; then
    _exiterr "Problem connecting to server (${1} for ${2}; curl returned with ${curlret})"
  fi

  if [[ ! "${statuscode:0:1}" = "2" ]]; then
    echo "  + ERROR: An error occurred while sending ${1}-request to ${2} (Status ${statuscode})" >&2
    echo >&2
    echo "Details:" >&2
    cat "${tempcont}" >&2
    echo >&2
    echo >&2
    rm -f "${tempcont}"

    # Wait for hook script to clean the challenge if used
    if [[ -n "${HOOK}" ]] && [[ "${HOOK_CHAIN}" != "yes" ]] && [[ -n "${challenge_token:+set}" ]]; then
      "${HOOK}" "clean_challenge" '' "${challenge_token}" "${keyauth}"
    fi

    # remove temporary domains.txt file if used
    [[ -n "${PARAM_DOMAIN:-}" && -n "${DOMAINS_TXT:-}" ]] && rm "${DOMAINS_TXT}"
    exit 1
  fi

  cat "${tempcont}"
  rm -f "${tempcont}"
}

# Send signed request
signed_request() {
  # Encode payload as urlbase64
  payload64="$(printf '%s' "${2}" | urlbase64)"

  # Retrieve nonce from acme-server
  nonce="$(http_request head "${CA}" | grep Replay-Nonce: | awk -F ': ' '{print $2}' | tr -d '\n\r')"

  # Build header with just our public key and algorithm information
  header='{"alg": "RS256", "jwk": {"e": "'"${pubExponent64}"'", "kty": "RSA", "n": "'"${pubMod64}"'"}}'

  # Build another header which also contains the previously received nonce and encode it as urlbase64
  protected='{"alg": "RS256", "jwk": {"e": "'"${pubExponent64}"'", "kty": "RSA", "n": "'"${pubMod64}"'"}, "nonce": "'"${nonce}"'"}'
  protected64="$(printf '%s' "${protected}" | urlbase64)"

  # Sign header with nonce and our payload with our private key and encode signature as urlbase64
  signed64="$(printf '%s' "${protected64}.${payload64}" | openssl dgst -sha256 -sign "${ACCOUNT_KEY}" | urlbase64)"

  # Send header + extended header + payload + signature to the acme-server
  data='{"header": '"${header}"', "protected": "'"${protected64}"'", "payload": "'"${payload64}"'", "signature": "'"${signed64}"'"}'

  http_request post "${1}" "${data}"
}

# Extracts all subject names from a CSR
# Outputs either the CN, or the SANs, one per line
extract_altnames() {
  csr="${1}" # the CSR itself (not a file)

  if ! <<<"${csr}" openssl req -verify -noout 2>/dev/null; then
    _exiterr "Certificate signing request isn't valid"
  fi

  reqtext="$( <<<"${csr}" openssl req -noout -text )"
  if <<<"${reqtext}" grep -q '^[[:space:]]*X509v3 Subject Alternative Name:[[:space:]]*$'; then
    # SANs used, extract these
    altnames="$( <<<"${reqtext}" grep -A1 '^[[:space:]]*X509v3 Subject Alternative Name:[[:space:]]*$' | tail -n1 )"
    # split to one per line:
    # shellcheck disable=SC1003
    altnames="$( <<<"${altnames}" _sed -e 's/^[[:space:]]*//; s/, /\'$'\n''/g' )"
    # we can only get DNS: ones signed
    if grep -qv '^DNS:' <<<"${altnames}"; then
      _exiterr "Certificate signing request contains non-DNS Subject Alternative Names"
    fi
    # strip away the DNS: prefix
    altnames="$( <<<"${altnames}" _sed -e 's/^DNS://' )"
    echo "${altnames}"

  else
    # No SANs, extract CN
    altnames="$( <<<"${reqtext}" grep '^[[:space:]]*Subject:' | _sed -e 's/.* CN=([^ /,]*).*/\1/' )"
    echo "${altnames}"
  fi
}

# Create certificate for domain(s) and outputs it FD 3
sign_csr() {
  csr="${1}" # the CSR itself (not a file)

  if { true >&3; } 2>/dev/null; then
    : # fd 3 looks OK
  else
    _exiterr "sign_csr: FD 3 not open"
  fi

  shift 1 || true
  altnames="${*:-}"
  if [ -z "${altnames}" ]; then
    altnames="$( extract_altnames "${csr}" )"
  fi

  if [[ -z "${CA_NEW_AUTHZ}" ]] || [[ -z "${CA_NEW_CERT}" ]]; then
    _exiterr "Certificate authority doesn't allow certificate signing"
  fi

  local idx=0
  if [[ -n "${ZSH_VERSION:-}" ]]; then
    local -A challenge_uris challenge_tokens keyauths deploy_args
  else
    local -a challenge_uris challenge_tokens keyauths deploy_args
  fi

  # Request challenges
  for altname in ${altnames}; do
    # Ask the acme-server for new challenge token and extract them from the resulting json block
    echo " + Requesting challenge for ${altname}..."
    response="$(signed_request "${CA_NEW_AUTHZ}" '{"resource": "new-authz", "identifier": {"type": "dns", "value": "'"${altname}"'"}}' | clean_json)"

    challenges="$(printf '%s\n' "${response}" | sed -n 's/.*\("challenges":[^\[]*\[[^]]*]\).*/\1/p')"
    repl=$'\n''{' # fix syntax highlighting in Vim
    challenge="$(printf "%s" "${challenges//\{/${repl}}" | grep \""${CHALLENGETYPE}"\")"
    challenge_token="$(printf '%s' "${challenge}" | get_json_string_value token | _sed 's/[^A-Za-z0-9_\-]/_/g')"
    challenge_uri="$(printf '%s' "${challenge}" | get_json_string_value uri)"

    if [[ -z "${challenge_token}" ]] || [[ -z "${challenge_uri}" ]]; then
      _exiterr "Can't retrieve challenges (${response})"
    fi

    # Challenge response consists of the challenge token and the thumbprint of our public certificate
    keyauth="${challenge_token}.${thumbprint}"

    case "${CHALLENGETYPE}" in
      "http-01")
        # Store challenge response in well-known location and make world-readable (so that a webserver can access it)
        printf '%s' "${keyauth}" > "${WELLKNOWN}/${challenge_token}"
        chmod a+r "${WELLKNOWN}/${challenge_token}"
        keyauth_hook="${keyauth}"
        ;;
      "dns-01")
        # Generate DNS entry content for dns-01 validation
        keyauth_hook="$(printf '%s' "${keyauth}" | openssl dgst -sha256 -binary | urlbase64)"
        ;;
    esac

    challenge_uris[${idx}]="${challenge_uri}"
    keyauths[${idx}]="${keyauth}"
    challenge_tokens[${idx}]="${challenge_token}"
    # Note: assumes args will never have spaces!
    deploy_args[${idx}]="${altname} ${challenge_token} ${keyauth_hook}"
    idx=$((idx+1))
  done

  # Wait for hook script to deploy the challenges if used
  # shellcheck disable=SC2068
  [[ -n "${HOOK}" ]] && [[ "${HOOK_CHAIN}" = "yes" ]] && "${HOOK}" "deploy_challenge" ${deploy_args[@]}

  # Respond to challenges
  idx=0
  for altname in ${altnames}; do
    challenge_token="${challenge_tokens[${idx}]}"
    keyauth="${keyauths[${idx}]}"

    # Wait for hook script to deploy the challenge if used
    # shellcheck disable=SC2086
    [[ -n "${HOOK}" ]] && [[ "${HOOK_CHAIN}" != "yes" ]] && "${HOOK}" "deploy_challenge" ${deploy_args[${idx}]}

    # Ask the acme-server to verify our challenge and wait until it is no longer pending
    echo " + Responding to challenge for ${altname}..."
    result="$(signed_request "${challenge_uris[${idx}]}" '{"resource": "challenge", "keyAuthorization": "'"${keyauth}"'"}' | clean_json)"

    reqstatus="$(printf '%s\n' "${result}" | get_json_string_value status)"

    while [[ "${reqstatus}" = "pending" ]]; do
      sleep 1
      result="$(http_request get "${challenge_uris[${idx}]}")"
      reqstatus="$(printf '%s\n' "${result}" | get_json_string_value status)"
    done

    [[ "${CHALLENGETYPE}" = "http-01" ]] && rm -f "${WELLKNOWN}/${challenge_token}"

    # Wait for hook script to clean the challenge if used
    if [[ -n "${HOOK}" ]] && [[ "${HOOK_CHAIN}" != "yes" ]] && [[ -n "${challenge_token}" ]]; then
      # shellcheck disable=SC2086
      "${HOOK}" "clean_challenge" ${deploy_args[${idx}]}
    fi
    idx=$((idx+1))

    if [[ "${reqstatus}" = "valid" ]]; then
      echo " + Challenge is valid!"
    else
      break
    fi
  done

  # Wait for hook script to clean the challenges if used
  # shellcheck disable=SC2068
  [[ -n "${HOOK}" ]] && [[ "${HOOK_CHAIN}" = "yes" ]] && "${HOOK}" "clean_challenge" ${deploy_args[@]}

  if [[ "${reqstatus}" != "valid" ]]; then
    # Clean up any remaining challenge_tokens if we stopped early
    if [[ "${CHALLENGETYPE}" = "http-01" ]]; then
      while [ ${idx} -lt ${#challenge_tokens[@]} ]; do
        rm -f "${WELLKNOWN}/${challenge_tokens[${idx}]}"
        idx=$((idx+1))
      done
    fi

    _exiterr "Challenge is invalid! (returned: ${reqstatus}) (result: ${result})"
  fi

  # Finally request certificate from the acme-server and store it in cert-${timestamp}.pem and link from cert.pem
  echo " + Requesting certificate..."
  csr64="$( <<<"${csr}" openssl req -outform DER | urlbase64)"
  crt64="$(signed_request "${CA_NEW_CERT}" '{"resource": "new-cert", "csr": "'"${csr64}"'"}' | openssl base64 -e)"
  crt="$( printf -- '-----BEGIN CERTIFICATE-----\n%s\n-----END CERTIFICATE-----\n' "${crt64}" )"

  # Try to load the certificate to detect corruption
  echo " + Checking certificate..."
  _openssl x509 -text <<<"${crt}"

  echo "${crt}" >&3

  unset challenge_token
  echo " + Done!"
}

# Create certificate for domain(s)
sign_domain() {
  domain="${1}"
  altnames="${*}"
  timestamp="$(date +%s)"

  echo " + Signing domains..."
  if [[ -z "${CA_NEW_AUTHZ}" ]] || [[ -z "${CA_NEW_CERT}" ]]; then
    _exiterr "Certificate authority doesn't allow certificate signing"
  fi

  # If there is no existing certificate directory => make it
  if [[ ! -e "${CERTDIR}/${domain}" ]]; then
    echo " + Creating new directory ${CERTDIR}/${domain} ..."
    mkdir -p "${CERTDIR}/${domain}" || _exiterr "Unable to create directory ${CERTDIR}/${domain}"
  fi

  privkey="privkey.pem"
  # generate a new private key if we need or want one
  if [[ ! -r "${CERTDIR}/${domain}/privkey.pem" ]] || [[ "${PRIVATE_KEY_RENEW}" = "yes" ]]; then
    echo " + Generating private key..."
    privkey="privkey-${timestamp}.pem"
    case "${KEY_ALGO}" in
      rsa) _openssl genrsa -out "${CERTDIR}/${domain}/privkey-${timestamp}.pem" "${KEYSIZE}";;
      prime256v1|secp384r1) _openssl ecparam -genkey -name "${KEY_ALGO}" -out "${CERTDIR}/${domain}/privkey-${timestamp}.pem";;
    esac
  fi

  # Generate signing request config and the actual signing request
  echo " + Generating signing request..."
  SAN=""
  for altname in ${altnames}; do
    SAN+="DNS:${altname}, "
  done
  SAN="${SAN%%, }"
  local tmp_openssl_cnf
  tmp_openssl_cnf="$(_mktemp)"
  cat "${OPENSSL_CNF}" > "${tmp_openssl_cnf}"
  printf "[SAN]\nsubjectAltName=%s" "${SAN}" >> "${tmp_openssl_cnf}"
  if [ "${OCSP_MUST_STAPLE}" = "yes" ]; then
    printf "\n1.3.6.1.5.5.7.1.24=DER:30:03:02:01:05" >> "${tmp_openssl_cnf}"
  fi
  openssl req -new -sha256 -key "${CERTDIR}/${domain}/${privkey}" -out "${CERTDIR}/${domain}/cert-${timestamp}.csr" -subj "/CN=${domain}/" -reqexts SAN -config "${tmp_openssl_cnf}"
  rm -f "${tmp_openssl_cnf}"

  crt_path="${CERTDIR}/${domain}/cert-${timestamp}.pem"
  # shellcheck disable=SC2086
  sign_csr "$(< "${CERTDIR}/${domain}/cert-${timestamp}.csr" )" ${altnames} 3>"${crt_path}"

  # Create fullchain.pem
  echo " + Creating fullchain.pem..."
  cat "${crt_path}" > "${CERTDIR}/${domain}/fullchain-${timestamp}.pem"
  tmpchain="$(_mktemp)"
  http_request get "$(openssl x509 -in "${CERTDIR}/${domain}/cert-${timestamp}.pem" -noout -text | grep 'CA Issuers - URI:' | cut -d':' -f2-)" > "${tmpchain}"
  if grep -q "BEGIN CERTIFICATE" "${tmpchain}"; then
    mv "${tmpchain}" "${CERTDIR}/${domain}/chain-${timestamp}.pem"
  else
    openssl x509 -in "${tmpchain}" -inform DER -out "${CERTDIR}/${domain}/chain-${timestamp}.pem" -outform PEM
    rm "${tmpchain}"
  fi
  cat "${CERTDIR}/${domain}/chain-${timestamp}.pem" >> "${CERTDIR}/${domain}/fullchain-${timestamp}.pem"

  # Update symlinks
  [[ "${privkey}" = "privkey.pem" ]] || ln -sf "privkey-${timestamp}.pem" "${CERTDIR}/${domain}/privkey.pem"

  ln -sf "chain-${timestamp}.pem" "${CERTDIR}/${domain}/chain.pem"
  ln -sf "fullchain-${timestamp}.pem" "${CERTDIR}/${domain}/fullchain.pem"
  ln -sf "cert-${timestamp}.csr" "${CERTDIR}/${domain}/cert.csr"
  ln -sf "cert-${timestamp}.pem" "${CERTDIR}/${domain}/cert.pem"

  # Wait for hook script to clean the challenge and to deploy cert if used
  export KEY_ALGO
  [[ -n "${HOOK}" ]] && "${HOOK}" "deploy_cert" "${domain}" "${CERTDIR}/${domain}/privkey.pem" "${CERTDIR}/${domain}/cert.pem" "${CERTDIR}/${domain}/fullchain.pem" "${CERTDIR}/${domain}/chain.pem" "${timestamp}"

  unset challenge_token
  echo " + Done!"
}

# Usage: --cron (-c)
# Description: Sign/renew non-existant/changed/expiring certificates.
command_sign_domains() {
  init_system

  if [[ -n "${PARAM_DOMAIN:-}" ]]; then
    DOMAINS_TXT="$(_mktemp)"
    printf -- "${PARAM_DOMAIN}" > "${DOMAINS_TXT}"
  elif [[ -e "${DOMAINS_TXT}" ]]; then
    if [[ ! -r "${DOMAINS_TXT}" ]]; then
      _exiterr "domains.txt found but not readable"
    fi
  else
    _exiterr "domains.txt not found and --domain not given"
  fi

  # Generate certificates for all domains found in domains.txt. Check if existing certificate are about to expire
  ORIGIFS="${IFS}"
  IFS=$'\n'
  for line in $(<"${DOMAINS_TXT}" tr -d '\r' | tr '[:upper:]' '[:lower:]' | _sed -e 's/^[[:space:]]*//g' -e 's/[[:space:]]*$//g' -e 's/[[:space:]]+/ /g' | (grep -vE '^(#|$)' || true)); do
    reset_configvars
    IFS="${ORIGIFS}"
    domain="$(printf '%s\n' "${line}" | cut -d' ' -f1)"
    morenames="$(printf '%s\n' "${line}" | cut -s -d' ' -f2-)"
    cert="${CERTDIR}/${domain}/cert.pem"

    force_renew="${PARAM_FORCE:-no}"

    if [[ -z "${morenames}" ]];then
      echo "Processing ${domain}"
    else
      echo "Processing ${domain} with alternative names: ${morenames}"
    fi

    # read cert config
    # for now this loads the certificate specific config in a subshell and parses a diff of set variables.
    # we could just source the config file but i decided to go this way to protect people from accidentally overriding
    # variables used internally by this script itself.
    if [[ -n "${DOMAINS_D}" ]]; then
      certconfig="${DOMAINS_D}/${domain}"
    else
      certconfig="${CERTDIR}/${domain}/config"
    fi

    if [ -f "${certconfig}" ]; then
      echo " + Using certificate specific config file!"
      ORIGIFS="${IFS}"
      IFS=$'\n'
      for cfgline in $(
        beforevars="$(_mktemp)"
        aftervars="$(_mktemp)"
        set > "${beforevars}"
        # shellcheck disable=SC1090
        . "${certconfig}"
        set > "${aftervars}"
        diff -u "${beforevars}" "${aftervars}" | grep -E '^\+[^+]'
        rm "${beforevars}"
        rm "${aftervars}"
      ); do
        config_var="$(echo "${cfgline:1}" | cut -d'=' -f1)"
        config_value="$(echo "${cfgline:1}" | cut -d'=' -f2-)"
        case "${config_var}" in
          KEY_ALGO|OCSP_MUST_STAPLE|PRIVATE_KEY_RENEW|KEYSIZE|CHALLENGETYPE|HOOK|WELLKNOWN|HOOK_CHAIN|OPENSSL_CNF|RENEW_DAYS)
            echo "   + ${config_var} = ${config_value}"
            declare -- "${config_var}=${config_value}"
            ;;
          _) ;;
          *) echo "   ! Setting ${config_var} on a per-certificate base is not (yet) supported"
        esac
      done
      IFS="${ORIGIFS}"
    fi
    verify_config

    if [[ -e "${cert}" ]]; then
      printf " + Checking domain name(s) of existing cert..."

      certnames="$(openssl x509 -in "${cert}" -text -noout | grep DNS: | _sed 's/DNS://g' | tr -d ' ' | tr ',' '\n' | sort -u | tr '\n' ' ' | _sed 's/ $//')"
      givennames="$(echo "${domain}" "${morenames}"| tr ' ' '\n' | sort -u | tr '\n' ' ' | _sed 's/ $//' | _sed 's/^ //')"

      if [[ "${certnames}" = "${givennames}" ]]; then
        echo " unchanged."
      else
        echo " changed!"
        echo " + Domain name(s) are not matching!"
        echo " + Names in old certificate: ${certnames}"
        echo " + Configured names: ${givennames}"
        echo " + Forcing renew."
        force_renew="yes"
      fi
    fi

    if [[ -e "${cert}" ]]; then
      echo " + Checking expire date of existing cert..."
      valid="$(openssl x509 -enddate -noout -in "${cert}" | cut -d= -f2- )"

      printf " + Valid till %s " "${valid}"
      if openssl x509 -checkend $((RENEW_DAYS * 86400)) -noout -in "${cert}"; then
        printf "(Longer than %d days). " "${RENEW_DAYS}"
        if [[ "${force_renew}" = "yes" ]]; then
          echo "Ignoring because renew was forced!"
        else
          # Certificate-Names unchanged and cert is still valid
          echo "Skipping renew!"
          [[ -n "${HOOK}" ]] && "${HOOK}" "unchanged_cert" "${domain}" "${CERTDIR}/${domain}/privkey.pem" "${CERTDIR}/${domain}/cert.pem" "${CERTDIR}/${domain}/fullchain.pem" "${CERTDIR}/${domain}/chain.pem"
          continue
        fi
      else
        echo "(Less than ${RENEW_DAYS} days). Renewing!"
      fi
    fi

    # shellcheck disable=SC2086
    if [[ "${PARAM_KEEP_GOING:-}" = "yes" ]]; then
      sign_domain ${line} &
      wait $! || true
    else
      sign_domain ${line}
    fi
  done

  # remove temporary domains.txt file if used
  [[ -n "${PARAM_DOMAIN:-}" ]] && rm -f "${DOMAINS_TXT}"

  exit 0
}

# Usage: --signcsr (-s) path/to/csr.pem
# Description: Sign a given CSR, output CRT on stdout (advanced usage)
command_sign_csr() {
  # redirect stdout to stderr
  # leave stdout over at fd 3 to output the cert
  exec 3>&1 1>&2

  init_system

  csrfile="${1}"
  if [ ! -r "${csrfile}" ]; then
    _exiterr "Could not read certificate signing request ${csrfile}"
  fi

  # gen cert
  certfile="$(_mktemp)"
  sign_csr "$(< "${csrfile}" )" 3> "${certfile}"

  # print cert
  echo "# CERT #" >&3
  cat "${certfile}" >&3
  echo >&3

  # print chain
  if [ -n "${PARAM_FULL_CHAIN:-}" ]; then
    # get and convert ca cert
    chainfile="$(_mktemp)"
    tmpchain="$(_mktemp)"
    http_request get "$(openssl x509 -in "${certfile}" -noout -text | grep 'CA Issuers - URI:' | cut -d':' -f2-)" > "${tmpchain}"
    if grep -q "BEGIN CERTIFICATE" "${tmpchain}"; then
      mv "${tmpchain}" "${chainfile}"
    else
      openssl x509 -in "${tmpchain}" -inform DER -out "${chainfile}" -outform PEM
      rm "${tmpchain}"
    fi

    echo "# CHAIN #" >&3
    cat "${chainfile}" >&3

    rm "${chainfile}"
  fi

  # cleanup
  rm "${certfile}"

  exit 0
}

# Usage: --revoke (-r) path/to/cert.pem
# Description: Revoke specified certificate
command_revoke() {
  init_system

  [[ -n "${CA_REVOKE_CERT}" ]] || _exiterr "Certificate authority doesn't allow certificate revocation."

  cert="${1}"
  if [[ -L "${cert}" ]]; then
    # follow symlink and use real certificate name (so we move the real file and not the symlink at the end)
    local link_target
    link_target="$(readlink -n "${cert}")"
    if [[ "${link_target}" =~ ^/ ]]; then
      cert="${link_target}"
    else
      cert="$(dirname "${cert}")/${link_target}"
    fi
  fi
  [[ -f "${cert}" ]] || _exiterr "Could not find certificate ${cert}"

  echo "Revoking ${cert}"

  cert64="$(openssl x509 -in "${cert}" -inform PEM -outform DER | urlbase64)"
  response="$(signed_request "${CA_REVOKE_CERT}" '{"resource": "revoke-cert", "certificate": "'"${cert64}"'"}' | clean_json)"
  # if there is a problem with our revoke request _request (via signed_request) will report this and "exit 1" out
  # so if we are here, it is safe to assume the request was successful
  echo " + Done."
  echo " + Renaming certificate to ${cert}-revoked"
  mv -f "${cert}" "${cert}-revoked"
}

# Usage: --cleanup (-gc)
# Description: Move unused certificate files to archive directory
command_cleanup() {
  load_config

  # Create global archive directory if not existant
  if [[ ! -e "${BASEDIR}/archive" ]]; then
    mkdir "${BASEDIR}/archive"
  fi

  # Loop over all certificate directories
  for certdir in "${CERTDIR}/"*; do
    # Skip if entry is not a folder
    [[ -d "${certdir}" ]] || continue

    # Get certificate name
    certname="$(basename "${certdir}")"

    # Create certitifaces archive directory if not existant
    archivedir="${BASEDIR}/archive/${certname}"
    if [[ ! -e "${archivedir}" ]]; then
      mkdir "${archivedir}"
    fi

    # Loop over file-types (certificates, keys, signing-requests, ...)
    for filetype in cert.csr cert.pem chain.pem fullchain.pem privkey.pem; do
      # Skip if symlink is broken
      [[ -r "${certdir}/${filetype}" ]] || continue

      # Look up current file in use
      current="$(basename "$(readlink "${certdir}/${filetype}")")"

      # Split filetype into name and extension
      filebase="$(echo "${filetype}" | cut -d. -f1)"
      fileext="$(echo "${filetype}" | cut -d. -f2)"

      # Loop over all files of this type
      for file in "${certdir}/${filebase}-"*".${fileext}"; do
        # Handle case where no files match the wildcard
        [[ -f "${file}" ]] || break

        # Check if current file is in use, if unused move to archive directory
        filename="$(basename "${file}")"
        if [[ ! "${filename}" = "${current}" ]]; then
          echo "Moving unused file to archive directory: ${certname}/${filename}"
          mv "${certdir}/${filename}" "${archivedir}/${filename}"
        fi
      done
    done
  done

  exit 0
}

# Usage: --help (-h)
# Description: Show help text
command_help() {
  printf "Usage: %s [-h] [command [argument]] [parameter [argument]] [parameter [argument]] ...\n\n" "${0}"
  printf "Default command: help\n\n"
  echo "Commands:"
  grep -e '^[[:space:]]*# Usage:' -e '^[[:space:]]*# Description:' -e '^command_.*()[[:space:]]*{' "${0}" | while read -r usage; read -r description; read -r command; do
    if [[ ! "${usage}" =~ Usage ]] || [[ ! "${description}" =~ Description ]] || [[ ! "${command}" =~ ^command_ ]]; then
      _exiterr "Error generating help text."
    fi
    printf " %-32s %s\n" "${usage##"# Usage: "}" "${description##"# Description: "}"
  done
  printf -- "\nParameters:\n"
  grep -E -e '^[[:space:]]*# PARAM_Usage:' -e '^[[:space:]]*# PARAM_Description:' "${0}" | while read -r usage; read -r description; do
    if [[ ! "${usage}" =~ Usage ]] || [[ ! "${description}" =~ Description ]]; then
      _exiterr "Error generating help text."
    fi
    printf " %-32s %s\n" "${usage##"# PARAM_Usage: "}" "${description##"# PARAM_Description: "}"
  done
}

# Usage: --env (-e)
# Description: Output configuration variables for use in other scripts
command_env() {
  echo "# dehydrated configuration"
  load_config
  typeset -p CA LICENSE CERTDIR CHALLENGETYPE DOMAINS_D DOMAINS_TXT HOOK HOOK_CHAIN RENEW_DAYS ACCOUNT_KEY ACCOUNT_KEY_JSON KEYSIZE WELLKNOWN PRIVATE_KEY_RENEW OPENSSL_CNF CONTACT_EMAIL LOCKFILE
}

# Main method (parses script arguments and calls command_* methods)
main() {
  COMMAND=""
  set_command() {
    [[ -z "${COMMAND}" ]] || _exiterr "Only one command can be executed at a time. See help (-h) for more information."
    COMMAND="${1}"
  }

  check_parameters() {
    if [[ -z "${1:-}" ]]; then
      echo "The specified command requires additional parameters. See help:" >&2
      echo >&2
      command_help >&2
      exit 1
    elif [[ "${1:0:1}" = "-" ]]; then
      _exiterr "Invalid argument: ${1}"
    fi
  }

  [[ -z "${@}" ]] && eval set -- "--help"

  while (( ${#} )); do
    case "${1}" in
      --help|-h)
        command_help
        exit 0
        ;;

      --env|-e)
        set_command env
        ;;

      --cron|-c)
        set_command sign_domains
        ;;

      --signcsr|-s)
        shift 1
        set_command sign_csr
        check_parameters "${1:-}"
        PARAM_CSR="${1}"
        ;;

      --revoke|-r)
        shift 1
        set_command revoke
        check_parameters "${1:-}"
        PARAM_REVOKECERT="${1}"
        ;;

      --cleanup|-gc)
        set_command cleanup
        ;;

      # PARAM_Usage: --full-chain (-fc)
      # PARAM_Description: Print full chain when using --signcsr
      --full-chain|-fc)
        PARAM_FULL_CHAIN="1"
        ;;

      # PARAM_Usage: --ipv4 (-4)
      # PARAM_Description: Resolve names to IPv4 addresses only
      --ipv4|-4)
        PARAM_IP_VERSION="4"
        ;;

      # PARAM_Usage: --ipv6 (-6)
      # PARAM_Description: Resolve names to IPv6 addresses only
      --ipv6|-6)
        PARAM_IP_VERSION="6"
        ;;

      # PARAM_Usage: --domain (-d) domain.tld
      # PARAM_Description: Use specified domain name(s) instead of domains.txt entry (one certificate!)
      --domain|-d)
        shift 1
        check_parameters "${1:-}"
        if [[ -z "${PARAM_DOMAIN:-}" ]]; then
          PARAM_DOMAIN="${1}"
        else
          PARAM_DOMAIN="${PARAM_DOMAIN} ${1}"
         fi
        ;;

      # PARAM_Usage: --keep-going (-g)
      # PARAM_Description: Keep going after encountering an error while creating/renewing multiple certificates in cron mode
      --keep-going|-g)
        PARAM_KEEP_GOING="yes"
        ;;

      # PARAM_Usage: --force (-x)
      # PARAM_Description: Force renew of certificate even if it is longer valid than value in RENEW_DAYS
      --force|-x)
        PARAM_FORCE="yes"
        ;;

      # PARAM_Usage: --no-lock (-n)
      # PARAM_Description: Don't use lockfile (potentially dangerous!)
      --no-lock|-n)
        PARAM_NO_LOCK="yes"
        ;;

      # PARAM_Usage: --ocsp
      # PARAM_Description: Sets option in CSR indicating OCSP stapling to be mandatory
      --ocsp)
        PARAM_OCSP_MUST_STAPLE="yes"
        ;;

      # PARAM_Usage: --privkey (-p) path/to/key.pem
      # PARAM_Description: Use specified private key instead of account key (useful for revocation)
      --privkey|-p)
        shift 1
        check_parameters "${1:-}"
        PARAM_ACCOUNT_KEY="${1}"
        ;;

      # PARAM_Usage: --config (-f) path/to/config
      # PARAM_Description: Use specified config file
      --config|-f)
        shift 1
        check_parameters "${1:-}"
        CONFIG="${1}"
        ;;

      # PARAM_Usage: --hook (-k) path/to/hook.sh
      # PARAM_Description: Use specified script for hooks
      --hook|-k)
        shift 1
        check_parameters "${1:-}"
        PARAM_HOOK="${1}"
        ;;

      # PARAM_Usage: --out (-o) certs/directory
      # PARAM_Description: Output certificates into the specified directory
      --out|-o)
        shift 1
        check_parameters "${1:-}"
        PARAM_CERTDIR="${1}"
        ;;

      # PARAM_Usage: --challenge (-t) http-01|dns-01
      # PARAM_Description: Which challenge should be used? Currently http-01 and dns-01 are supported
      --challenge|-t)
        shift 1
        check_parameters "${1:-}"
        PARAM_CHALLENGETYPE="${1}"
        ;;

      # PARAM_Usage: --algo (-a) rsa|prime256v1|secp384r1
      # PARAM_Description: Which public key algorithm should be used? Supported: rsa, prime256v1 and secp384r1
      --algo|-a)
        shift 1
        check_parameters "${1:-}"
        PARAM_KEY_ALGO="${1}"
        ;;

      *)
        echo "Unknown parameter detected: ${1}" >&2
        echo >&2
        command_help >&2
        exit 1
        ;;
    esac

    shift 1
  done

  case "${COMMAND}" in
    env) command_env;;
    sign_domains) command_sign_domains;;
    sign_csr) command_sign_csr "${PARAM_CSR}";;
    revoke) command_revoke "${PARAM_REVOKECERT}";;
    cleanup) command_cleanup;;
    *) command_help; exit 1;;
  esac
}

# Determine OS type
OSTYPE="$(uname)"

# Check for missing dependencies
check_dependencies

# Run script
main "${@:-}"
  • chown root:wheel /home/letsencrypt/cts/dehydrated
  • chmod 750 /home/letsencrypt/cts/dehydrated

We now need to create some additional stuff for our Letsencrypt script. Remember to change IP and ourdomain.com to yours!

  • mkdir -p /home/letsencrypt/cts/conf-ip1
  • mkdir -p /usr/home/letsencrypt/cts/www/wellknown/acme-challenge
  • touch /usr/home/letsencrypt/cts/www/wellknown/acme-challenge/index.html
  • ln -s /usr/home/letsencrypt/cts/www/wellknown /usr/local/www/apache24/data/.well-known
  • echo “matrix.ourdomain.com” > /home/letsencrypt/cts/conf-ip1/domains.txt

  • create /home/letsencrypt/cts/conf-ip1/config.sh with the following content:

#!/usr/bin/env /usr/local/bin/bash
# FreeBSD special:
alias openssl='/usr/bin/openssl'
# Path to license agreement (default: https://letsencrypt.org/documents/LE-SA-v1.0.1-July-27-2015.pdf)
#LICENSE="https://letsencrypt.org/documents/LE-SA-v1.0.1-July-27-2015.pdf"
# Which challenge should be used? Currently http-01 and dns-01 are supported
CHALLENGETYPE="http-01"
#WELLKNOWN="${BASEDIR}/.acme-challenges"
WELLKNOWN="/home/letsencrypt/cts/www/wellknown/acme-challenge"
  • chown root:wheel /home/letsencrypt/cts/conf-ip1/config.sh
  • chmod 750 /home/letsencrypt/cts/conf-ip1/config.sh

  • create /home/letsencrypt/cts/conf-ip1/hook.sh with the following content:

#!/usr/bin/env /usr/local/bin/bash

function deploy_challenge {
    local DOMAIN="${1}" TOKEN_FILENAME="${2}" TOKEN_VALUE="${3}"
}

function clean_challenge {
    local DOMAIN="${1}" TOKEN_FILENAME="${2}" TOKEN_VALUE="${3}"
}

function deploy_cert {
    local DOMAIN="${1}" KEYFILE="${2}" CERTFILE="${3}" FULLCHAINFILE="${4}" CHAINFILE="${5}" TIMESTAMP="${6}"

    ########################################################################
    # CTS-Solutions.AT cron script to create/renew certs v1.0 20160515
    # Professional-Help: http://cts-solutions.at
    # License: GNU General Public License version 3.0 (GPL-3.0)
    ########################################################################
    echo "#######################################################################################"
    echo " Handle updated certs for FreeBSD Servers"
    echo "#######################################################################################"
    echo  "DOMAIN=${1} KEYFILE=${2} CERTFILE=${3} FULLCHAINFILE=${4} CHAINFILE=${5} TIMESTAMP=${6}"
}

function unchanged_cert {
    local DOMAIN="${1}" KEYFILE="${2}" CERTFILE="${3}" FULLCHAINFILE="${4}" CHAINFILE="${5}"
    ########################################################################
    # CTS-Solutions.AT cron script to create/renew certs v1.0 20160515
    # Professional-Help: http://cts-solutions.at
    # License: GNU General Public License version 3.0 (GPL-3.0)
    ########################################################################
    echo "#######################################################################################"
    echo " No Changes for Domain ${1}"
    echo "#######################################################################################"
}

HANDLER=$1; shift; $HANDLER $@
  • chown root:wheel /home/letsencrypt/cts/conf-ip1/hook.sh
  • chmod 750 /home/letsencrypt/cts/conf-ip1/hook.sh

to receive our first cert we should start Apache and Turnserver

  • service turnserver start
  • service apache24 start

  • cd /home/letsencrypt/cts

  • ./Run_Certs.sh

if all goes well you should have placed your certs in

  • /home/letsencrypt/cts/conf-ip1/certs

and

  • /usr/local/etc/matrix-synapse/certs

Add the following to /etc/crontab:

#######################################################################
# Run letsencrypt renewals every thuesday @ 9:01
#######################################################################

5       9       *       *       2       root    /home/letsencrypt/cts/Run_Certs.sh

Now where we have the correct cert, change back

  • #Include etc/apache24/extra/httpd-ssl.conf

to

  • Include etc/apache24/extra/httpd-ssl.conf

in /usr/local/etc/apache24/httpd.conf and

  • service apache24 restart

Point your browser to https://matrix.ourdomain.com and check if you get a secure connection. Logs are in /var/log/www.

We have done most of our way. Lets finalize everything.

Finish Postgresql Setup

su to user pgsql and create synape user and database.su - pgsql

su - pgsql
createdb pgsql
createuser --pwprompt synapse_user
# check with
psql
\l
\du
\?
CREATE DATABASE synapse ENCODING 'UTF8' LC_COLLATE='C' LC_CTYPE='C'  template=template0  OWNER synapse_user;
\l
\q
exit

Finish Matrix Synapse setup

Add a synapse user, so we do not need to run the homeserver as root.

  • adduser synapse
adduser synapse
Username: synapse
Full name: synapse
Uid (Leave empty for default): 
Login group [synapse]: 
Login group is synapse. Invite synapse into other groups? []: 
Login class [default]: 
Shell (sh csh tcsh bash rbash nologin) [sh]: nologin
Home directory [/home/synapse]: 
Home directory permissions (Leave empty for default): 
Use password-based authentication? [yes]: 
Use an empty password? (yes/no) [no]: 
Use a random password? (yes/no) [no]: yes
Lock out the account after creation? [no]: 
Username   : synapse
Password   : <random>
Full Name  : synapse
Uid        : 1002
Class      : 
Groups     : synapse 
Home       : /nonexistent
Home Mode  : 
Shell      : /usr/sbin/nologin
Locked     : no
OK? (yes/no): yes

Now lets create a base config for our homeserver. Again, do not forget to change ourdomain.com to yours!

  • sh
  • . /home/synapse/env/bin/activate
  • cd /usr/local/etc/matrix-synapse
  • python -m synapse.app.homeserver –server-name matrix.ourdomain.com –config-path homeserver.yaml –generate-config –report-stats=no
  • Replace the content of homeserver.yaml with:
tls_certificate_path: "/usr/local/etc/matrix-synapse/certs/matrix.ourdomain.com/cert.pem"
tls_certificate_path: "/usr/local/etc/matrix-synapse/certs/matrix.ourdomain.com/fullchain.pem"
tls_private_key_path: "/usr/local/etc/matrix-synapse/certs/matrix.ourdomain.com/privkey.pem"

# PEM dh parameters for ephemeral keys
tls_dh_params_path: "/usr/local/etc/matrix-synapse/tls.dh"

# Don't bind to the https port
no_tls: False

tls_fingerprints: []

## Server ##
server_name: "matrix.ourdomain.com"
pid_file: /var/run/matrix-synapse/homeserver.pid
# We don't want the web client
web_client: False

public_baseurl: "https://matrix.ourdomain.com:8448/"

soft_file_limit: 0

listeners:
  -
    port: 8448

    bind_addresses:
      - '1.2.3.4'

    type: http

    tls: true
    x_forwarded: false

    resources:
      -
        names:
          - client     # The client-server APIs, both v1 and v2

        compress: true

      - names: [federation]  # Federation APIs
        compress: false

  - port: 8008
    tls: false
    bind_addresses: ['127.0.0.1']
    type: http

    x_forwarded: false

    resources:
      - names: [client]
        compress: true
      - names: [federation]
        compress: false

# Database configuration
database:
  name: "psycopg2"
  args:
    database: "synapse"
    user: "synapse_user"
    password: "yourpassword"
    cp_min: 5
    cp_max: 10

event_cache_size: "10K"

verbose: 0

log_file: "/var/log/matrix-synapse/homeserver.log"
log_config: "/usr/local/etc/matrix-synapse/matrix.ourdomain.com.log.config"

rc_messages_per_second: 0.2
rc_message_burst_count: 10.0
federation_rc_window_size: 1000
federation_rc_sleep_limit: 10
federation_rc_sleep_delay: 500
federation_rc_reject_limit: 50
federation_rc_concurrent: 3

media_store_path: "/var/db/matrix-synapse/media_store"
uploads_path: "/var/db/matrix-synapse/uploads"
max_upload_size: "1M"
max_image_pixels: "32M"
dynamic_thumbnails: false

# List of thumbnail to precalculate when an image is uploaded.
thumbnail_sizes:
- width: 32
  height: 32
  method: crop
- width: 96
  height: 96
  method: crop
- width: 320
  height: 240
  method: scale
- width: 640
  height: 480
  method: scale
- width: 800
  height: 600
  method: scale

url_preview_enabled: False

max_spider_size: "1M"
recaptcha_public_key: "DISABLED"
recaptcha_private_key: "DISABLED"
enable_registration_captcha: False

recaptcha_siteverify_api: "https://www.google.com/recaptcha/api/siteverify"

## Turn ##
## CHANGE AS USED above in turnserver.conf!!!!!!!!!

# The public URIs of the TURN server to give to clients
turn_uris: ["turn:matrix.ourdomain.com:3478?transport=udp", "turn:matrix.ourdomain.com:3478?transport=tcp"]
turn_shared_secret: "1cd6c96c1f8d4f1008042d76d646691e3b0512e830d7f486d6ad6b702bfc234e"
turn_user_lifetime: "1h"
turn_allow_guests: False


## Registration ##
enable_registration: False
registration_shared_secret: "jkdshkdjshdfzv9d87v89df77v897df987v89df7v87df89vu89df7v89df7v7df897vsdfuvhfdjkhvdf89"
bcrypt_rounds: 12
allow_guest_access: False

trusted_third_party_id_servers:
    - matrix.org
    - vector.im


enable_metrics: False
report_stats: False

room_invite_state_types:
    - "m.room.join_rules"
    - "m.room.canonical_alias"
    - "m.room.avatar"
    - "m.room.name"


app_service_config_files: []
macaroon_secret_key: "hfdjkfhdjkshjbncnsuivhsdf8sduv8duv8dfuvufd8uv8fdu89"
expire_access_token: False

## Signing Keys ##

# Path to the signing key to sign messages with
signing_key_path: "/usr/local/etc/matrix-synapse/matrix.ourdomain.com.signing.key"

old_signing_keys: {}
key_refresh_interval: "1d" # 1 Day.

# The trusted servers to download signing keys from.
perspectives:
  servers:
    "matrix.org":
      verify_keys:
        "ed25519:auto":
          key: "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw"

# Enable password for login.
password_config:
   enabled: true
   # Uncomment and change to a secret random string for extra security.
   # DO NOT CHANGE THIS AFTER INITIAL SETUP!
   #pepper: ""

email:
   enable_notifs: false
   smtp_host: "localhost"
   smtp_port: 25
   require_transport_security: False
   notif_from: "Ourdomain MATRIX <noreply@ourdomain.com>"
   app_name: Matrix
   template_dir:  res/templates
   riot_base_url: "https://matrix.ourdomain.com/riot"


#server_notices:
#   system_mxid_localpart: serveralarm
#   system_mxid_display_name: "Server Infos and Alerts"
#   system_mxid_avatar_url: "https://matrix.ourdomain.com/_matrix/media/v1/thumbnail/matrix.ourdomain.com/fcpNAbnjbfjjHIegqEMoPFew"
#   room_name: "Server Infos and Alerts"

  • mkdir -p /var/run/matrix-synapse
  • chown synapse /var/run/matrix-synapse
  • mkdir -p /var/log/matrix-synapse/
  • chown synapse /var/log/matrix-synapse/
  • change log file in matrix.ourdomain.com.log.config to filename: /var/log/matrix-synapse/homeserver.log
  • mkdir -p /var/db/matrix-synapse/media_store
  • mkdir -p /var/db/matrix-synapse/uploads
  • chown -R synapse:synapse /var/db/matrix-synapse

  • create tls.h file in /usr/local/etc/matrix-synapse

  • cd /usr/local/etc/matrix-synapse/

  • openssl dhparam -out tls.dh 2048

Finally we need a startup script for Matrix Synapse. Lets create /usr/local/etc/rc.d/synapse:

#!/bin/sh
#
# Created by: Karl M. Joch <k.joch@cts.at>
#

# PROVIDE: synapse
# REQUIRE: LOGIN postgresql
# KEYWORD: shutdown

# synapse_enable="YES"

. /etc/rc.subr

#----------------------
# we run in virtual env
#----------------------
VIRTUAL_ENV="/home/synapse/env"
export VIRTUAL_ENV
PATH="$VIRTUAL_ENV/bin:$PATH"
export PATH
# to check run here: env

name=synapse

rcvar=synapse_enable
load_rc_config ${name}

: ${synapse_enable:=NO}
: ${synapse_user:=synapse}
: ${synapse_conf:=/usr/local/etc/matrix-synapse/homeserver.yaml}
: ${synapse_dbdir:=/var/db/matrix-synapse}
: ${synapse_logdir:=/var/log/matrix-synapse}
: ${synapse_pidfile:=/var/run/matrix-synapse/homeserver.pid}

pidfile="${synapse_pidfile}"
procname=/usr/home/synapse/env/bin/python3.6
command=/usr/home/synapse/env/bin/python3.6
command_args="-m synapse.app.homeserver --daemonize -c ${synapse_conf}"
start_precmd=start_precmd

start_precmd()
{
        if [ ! -d ${synapse_pidfile%/*} ] ; then
                install -d -o synapse -g wheel ${synapse_pidfile%/*};
        fi

        if [ ! -d ${synapse_dbdir} ] ; then
                install -d -o synapse -g wheel ${synapse_dbdir};
        fi

        if [ ! -d ${synapse_logdir} ] ; then
                install -d -o synapse -g wheel ${synapse_logdir};
        fi

        if $(grep -q CHANGEME ${synapse_conf}) ; then
                echo "Error: Default secret values in config."
                echo "Please replace the CHANGEME values in ${synapse_conf}"
                exit 1
        fi
}

run_rc_command "$1"
  • chown root:wheel /usr/local/etc/rc.d/synapse
  • chmod 750 /usr/local/etc/rc.d/synapse

Start Matrix Synapse the first time

  • service synapse start

will hopefully end in something like this:

2019-05-11 18:02:13,846 - synapse.server - 222 - INFO - None - Setting up.
2019-05-11 18:02:13,884 - synapse.storage.event_push_actions - 471 - INFO - None - Searching for stream ordering 1 month ago
2019-05-11 18:02:13,885 - synapse.storage.event_push_actions - 477 - INFO - None - Found stream ordering 1 month ago: it's 0
2019-05-11 18:02:13,885 - synapse.storage.event_push_actions - 479 - INFO - None - Searching for stream ordering 1 day ago
2019-05-11 18:02:13,885 - synapse.storage.event_push_actions - 485 - INFO - None - Found stream ordering
2019-05-11 18:02:13,887 - synapse.server - 226 - INFO - None - Finished setting up.

You can check the running synapse with ps -xaj and netstat -an should show you listeners on 8008 and 8448. If yes, you can open the first beer. Your log is in /var/log/matrix-synapse.

Adding the admin user

Again, change ourdomain.com to your domain!!!!!

  • sh
  • . /home/synapse/env/bin/activate
  • cd /usr/local/etc/matrix-synapse
  • register_new_matrix_user -c homeserver.yaml https://matrix.ourdomain.com:8448
  • make this user the admin for you!

  • reboot your server, to restart everything

  • shutdown -r now

  • download the https://riot.im messenger for your platform and login

  • test everything

if everything works as expected:

  • create all other users the same way, but without being admin!

UPDATING

Updating FreeBSD and Packages

  • freebsd-update fetch
  • freebsd-update install
  • pkg update
  • pkg upgrade

Updating Matrix Synapse

  • service synapse stop
  • sh
  • . /home/synapse/env/bin/activate
  • pip install -U matrix-synapse[all]
  • service synapse start
  • if massive update, simply reboot the server

Join my public room

If you like this blog entry feel free to join my public room by entering

/join #kmj:matrix.ctseuro.com

anywhere in the box to send a message! Feedback welcome!

Enterprise Support

Riot.IM Messenger: Kurzanleitung für Benutzer mit Videos (Stand 01/2019)

neue Version der Anleitung verfügbar:



UPDATE / HINWEIS / WICHTIG 2019-05-16:

Aufgrund der Überlastung des größten öffentlichen Servers matrix.org empfehle ich einen anderen öffentlichen Server aus dieser Liste zu wählen: https://www.hello-matrix.net/public_servers.php . Ich empfehle Freunden den Server: https://www.privacytools.io/ . Der Homeserver zur Registrierung findet sich hier: https://riot.privacytools.io/#/welcome . Für die Riot Windows, Linux, MAC,, Android oder IOS App, verfügbar von https://riot.im sind folgende Einstellungen zu verwenden: Heimserver: https://chat.privacytools.io . Deine Adresse wird dann: benutzername:privacytools.io

Erfreuliche News

Es ist sehr erfreulich, dass immer mehr Menschen auf Ihre Privatsphäre und Daten achten. Langsam bildet sich auch bei breiteren Bevölkerungsschichten ein Bewusstsein für mehr Kontrolle über die eigenen Daten aus. Riot.im/Matrix.org ist mehr als ein Messenger, es ist ein Tool für dezentralisierte Zusammenarbeit, Internettelefonie, Videotelefonie und Messaging. Durch den dezentralen Aufbau wird nur eine minimale Menge an Metadaten erzeugt und bei aktivierter End-to-End Verschlüsselung ist Mitlesen auch am Server unmöglich. Da so viele Menschen in die Matrix wechseln und dieser Beitrag extrem oft abgerufen wird, erfolgte nun ein Update der Anleitung.

Da keiner etwas liest → NEUE KURZANLEITUNG

Matrix.org (für Administratoren)

Unter https://matrix.org findet sich der serverseitige Teil. Alle die einen eigenen Server für sich, Freunde oder die Firma an die Matrix anschließen wollen, finden sich hier alle Informationen für das sehr einfache Setup. Ziemlich cool Administrator eines Teils der Matrix zu sein. Guides finden sich hier: https://matrix.org/docs/guides/

Riot.im (für Benutzer)

Riot.im ist die App zum Einstieg in die Matrix für alle die einfach und sicher kommunizieren wollen!. Das wirklich genial daran ist, dass es die Riot App für IOS (Apple), Android, Windows, MAC und Linux gibt und man mit allen Geräten gleichzeitig online sein kann. Alle Geräte sind immer synchron und es ist egal, wo man gerade liest oder kommuniziert.

Wichtig:

Aufbau:

Es gibt im Messenger folgende Bereiche:

Musterbild zeigt die Android App, die Symbole sind aber auf allen Systemen gleich.

Im Hauptbereich sieht man:

  • Favoriten (über die Raumeinstellungen)
  • Personen (1:1 Kommunikation)
  • Räume (Gruppenkommunikation)
  • Niedrige Priorität (Nur Sortierung, sonst, keine Auswirkung)

In der Auswahlleiste unten:

  • Zurück zum Home Schirm
  • Favoriten anzeigen
  • Personen anzeigen
  • Räume anzeigen
  • Communities anzeigen

Communities:

Du kannst Communities (bestehen aus Personen und Räumen) erstellen, beitreten, oder eingeladen werden. Communities machen die Kommunikation, bzw. die Organisation von Projekten einfacher, da man in einer Ansicht alle Personen und Räume sieht. In der PC App und am Tablet werden die Communitysymbole für eine einfachere Navigation auch links angezeigt.

Räume:

Riot besteht aus Räumen, auch 1:1 Chats sind Räume, jedoch mit nur 2 Personen. Gruppenräume sind für mehrere Personen offen. Der Eröffner des Raumes ist Administrator und kann über das Zahnrad, bzw. über das Menü des Raum verwalten. Nur bei 1:1 Räumen sind beide Gesprächspartner Raumadministrator. Räume können manuell den Favoriten, bzw. der niedrigen Priorität zugeordnet werden. Damit bleibt die Übersicht gewahrt.

Räume haben vielfältige Einstellungsmöglichkeiten für Berechtigungen, Bild, Beschreibung und vieles mehr. Alle Einstellungen finden sich im Zahnrad, bzw. über die Raumeinstellungen. Die wichtigste Einstellung ist, egal ob 1:1 oder Gruppe, die Verschlüsselung zu aktivieren. Damit ist alles sicher End-to-End verschlüsselt.

Adressen in der Matrix:

Ähnlich wie bei E-Mails werden die Adressen in der Matrix aufgebaut und bestehen auch aus Benutzer und Domain. Eine Persönliche Adresse sieht so aus:

@benutzername:server.com

Anders als bei E-Mails ist die erste Stelle speziell:

@ - steht für eine Person
# - steht für einen Gruppenraum
+ - steht für eine Community

Danach folgt der Benutzername und durch : getrennt der Server auf der der Benutzer registriert ist. Da sich aktuell sehr viele am öffentlichen Matrix Server registrieren sehen viele Adressen so aus:

@meinname:matrix.org

Wenn jemand auf einem anderen Server registriert ist, wie z.B. ich, dann sieht die Adresse z.B. so aus:

@karl:matrix.ctseuro.com

Mit dieser Adresse kann man einen 1:1 Chat mit dieser Person starten. Wenn Sie die Adresse eines Raumes kennen, können Sie durch Eingabe von:

- /j #msg:matrix.ctseuro.com

einen Raum betreten.

Sicher einer der gewöhnungsbedürftigsten Punkte beim Umstieg ist die Verschlüsselung. Um es für Benutzer ohne Kenntnisse über Verschlüsselung und Kryptografie verständlich zu machen:

- Nachdem die Verschlüsselung aktiviert wird, erscheinen bei anderen Benutzern orange Warndreiecke. Nun müssen die Schlüssel (einer oder mehrere pro Benutzer) verifiziert werden. Danach erscheint beim Schreiben ein grünes Schloss. 
- Bei Gruppenräumen kann es sinnvoller sein, die Warnmeldung mit „Trotzdem senden“ zu quittieren und nicht alle Benutzer des Raumes zu verifizieren.

WICHTIG: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der End-to-End-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

Meine Kontakte auf Riot/Matrix sind zu 80% EDV Laien und alle haben es in kürzester Zeit geschafft, sich in dieser sicheren Lösung zu bewegen und zu kommunizieren. Wer E-Mails senden kann, kann Riot auch bedienen.

Update 11.2.2019

Keys sichern:

Ab Riot (Android und LineageOS 0.8.22) können nun die zur Verschlüsselung notwendigen Keys, verschlüsselt und mit Passwort gesichert, auch am Server gespeichert werden. Damit werden nie mehr verschlüsselte Nachrichten verloren.

Sprachnachrichten

Multi Account auf Android und LineageOS

  • Riot.IM für Account 1 installieren
  • miniVector (Riot Version ohne Telefonie) für Account 2 installieren

Der frühere Artikel - für Leser

findet sich hier:

https://kmj.at/2018-03-12-riot-im-messenger-kurzanleitung-fuer-benutze-updated/

Models und Fotografen Community (Pay Jobs, Update)

UPDATE / HINWEIS 2019-05-16:

Aufgrund der Überlastung des größten öffentlichen Servers matrix.org empfehle ich einen anderen öffentlichen Server aus dieser Liste zu wählen:

Ich empfehle Freunden den Server:

Der Homeserver zur Registrierung findet sich hier:

Danach für die Riot Windows, Linux, MAC,, Android oder IOS App, verfügbar von https://riot.im sind folgende Einstellungen zu verwenden:

Bitte obiges Update beachten

Da andere Systeme nicht mehr wirklich angenommen werden, wurde die „Models und Fotografen“ Community in der Riot Matrix eingerichtet. Der kostenlose Open Source Messenger Riot (https://riot.im) ist ein perfektes Tool für die Zusammenarbeit im Internet. In der Community existieren öffentliche Räume, zusätzlich können Models und Fotografen einen Direktchat starten, bzw. Projekte in separierten und optional auch versteckten Räumen organisieren. Auf Wunsch können Räume von Community Mitgliedern auch der Community Liste hinzugefügt werden.

Die Themen der Community

  • Pay Jobs für Models
  • Pay Jobs für Fotografen
  • TFP Jobs
  • Räume nach Regionen um eine bessere Übersicht zu erhalten.
  • allgemeine Diskussionsräume
  • weiteres auf Wunsch der User (Admins oder Moderatoren ansprechen)

Für Ungeduldige

  • Kostenloser Download der App von https://riot.im
  • Kostenlos und ohne persönliche Daten Account registrieren (siehe oben!)
  • Mit Benutzer/Password in der App anmelden
  • Deine Adresse wird @BENUTZERNAME:matrix.org (siehe update oben!)
  • Direkten Chat mit mir @karl:matrix.ctseuro.com starten
  • Ich helfe bei den weiteren Schritten

Alle anderen lesen weiter …..

Riot.IM Info

Für alle die den Riot Messenger noch nicht verwenden findet sich unten eine Anleitung. Die wichtigsten Punkte:

  • Der Riot Messenger ist kostenlos und Open Source.
  • Bei Registrierung am öffentlichen Server keine persönlichen Daten wie E-Mail oder Telefonnummer notwendig! Hier ist niemand an den Daten interessiert.
  • Jeder kann, bei Interesse, auch einen eigenen Server betreiben und zur Matrix verbinden
  • Bei aktivierter Verschlüsselung kann auch am Server niemand mitlesen
  • Sogar die französische Regierung baut gerade eine Riot/Martix Landschaft auf um WhatsApp oder Telegram abzulösen. https://matrix.org/blog/2018/04/26/matrix-and-riot-confirmed-as-the-basis-for-frances-secure-instant-messenger-app/

  • Verfügbar für IOS, Android, Linux, Mac, Windows

  • Mehrere Endgeräte können gleichzeitig online sein

  • Potential so gut wie jede Kommunikation in einer Software zu halten

  • Verschlüsselte Telefonie zwischen den Teilnehmern möglich

Riot Rauminfo für die Models und Fotografen Community

Wie im Riot Messenger üblich ist die Rezeption der Model und Fotografen Community über die Eingabe von:

/j #muf-rezeption:matrix.ctseuro.com

in der Chat Box, oder über die Raumliste des Servers

matrix.ctseuro.com

betreten. Die Rezeptions ist öffentlich zugänglich und dient als Welcome Room für Interessierte. Sollten Probleme auftreten, starte einen Direktchat mit @karl:matrix.ctseuro.com .

Bitte kontaktiere im Raum einen der Moderatoren oder Admins, bzw. @karl:matrix.ctseuro.com um eine Einladung in die Community und damit Zugang zu den anderen Räumen zu erhalten. Einladungen erfolgen nur für aktive Models und Fotografen!

Raumvorschläge, oder Anfragen um Moderator zu werden bitte an @karl:matrix.ctseuro.com .

RIOT Messenger komplette Anleitung

Kostenloser, Open Source Messenger mit Apps für IOS und Android, sowie Desktop Versionen für Windows, MAC und Linux! Unterstützt sichere End-to-End Verschlüsselung auch bei Gruppenchats!

Mittlerweile sind alle meine Kontakte, mit denen ich laufend in Kontakt bin, auf den kostenlosen Open Source Messenger, Riot.IM umgestiegen und einige betreiben auch einen eigenen Matrix/Synapse Server. Dadurch können wir wieder sicher, end-to-end verschlüsselt, kommunizieren und wissen, dass niemand mitliest und unsere Gespräche auswertet. Die Möglichkeiten von Riot.im sind wirklich grenzenlos und bis jetzt gab es, auch bei gleichzeitiger Verwunden von mehreren Endgeräten (Linux, IOS, Android), keine Probleme. Dieses Multi-Device Syncing ist wirklich mehr als genial. Riot.IM ist perfekt um Kontakte zu pflegen, bzw. im Firmenbereich Kunden und Interessenten an sich zu binden. Mit einem Account die Kommunikation (Einzel- und Gruppenchat, Voice und Video), sogar auf mehreren Geräten gleichzeitig zu managen ist eine neue Art der Kommunikation.

WICHTIG: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der End-to-End-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

INTRO VIDEO auf Youtube

KURZANLEITUNG:

  • Registrieren Sei Ihren kostenlosen Account unter Riot.IM
  • Installieren Sie die App für IOS oder Android, bzw. die Desktop Version für Windows, MAC, oder Linux (mehrere Clients können gleichzeitig betrieben werden!)
  • melden Sie sich mit Ihrem Benutzernamen und dem Passwort an
  • Wichtig: Ein Passwort-Reset ist ohne E-Mail Adresse nicht möglich. Das Passwort darf nicht vergessen werden!
  • Meine Riot Adresse: @karl:matrix.ctseuro.com

Endanwender können die kostenlose Open-Source-Software über die Webseite Riot.IM herunterladen.

Für Leser: Kostenloser Open Source Messenger

Dezentral, optional End-to-End verschlüsselt, sicher kommunizieren ohne Profil- und Kommunikationsdaten an die großen Datensammler weiterzugeben!

Folgend auf den eher technischen Artikel zu Matrix/Synapse + Riot:

/matrixsynapse-riot-im-die-neue-form-der-kommunikation-fuer-endanwender-und-unternehmen/

folgt nun eine Kurzanleitung zum Schnellstart für Benutzer. Unternehmen können zur Hilfestellung beim Setup ihrer Matrix/Synapse Server gerne die CTS GMBH unter support@cts-solutions.at kontaktieren oder die Installation laut Beschreibung vornehmen. Setup Link für Unternehmensserver: github.com/matrix-org/synapse

Kurzanleitung für Endanwender

Wer nur einmal hineinschnuppern möchte, kann sich auch über den Browser unter riot.im/app/ anmelden. Ich rate von der Verwendung des Browsers, sobald verschlüsselte Verbindungen verwendet werden, ab.

Nach der Installation können Sie sich mit „Benutzerkonto erstellen“  einen kostenlosen Account registrieren.

Sollten Sie sich nicht auf einem speziellen Server eines Serverbetreibers registrieren, erhalten Sie eine Adresse auf matrix.org. Sie müssen keine E-Mail-Adresse oder Telefonnummer eingeben und können nur durch Eingabe von Nutzername und Passwort sofort loslegen.  Beachten Sie aber, dass damit keine „Passwort verloren“ Aktion möglich ist und wenn Sie Ihr Passwort verlieren ist auch Ihr Account dauerhaft verloren.

Wie bei E-Mail-Adressen baut sich eine Matrix Adresse wie folgt auf:

Benutzernamen für Direktchat: @Benutzername:Server.Domain

Sie erhalten zum Beispiel @IhrBenutzername:matrix.org, wenn Sie sich auf dem matrix.org Server registriert haben. Wenn Sie mich ansprechen wollen, können Sie dies unter @karl:matrix.ctseuro.com tun. Ihre Nachricht wird dann zu meinem Server (matrix.ctseuro.com) weitergeleitet. Sobald die End-to-End Verschlüsselung aktiviert wird, ist es sogar dem Server Admin unmöglich, die Unterhaltung mitzulesen.

Räume funktionieren, da auch diese als Raum (mit eben nur 2 Personen) geführt werden, wie 1:1 Chats. Adressen von Räumen werden mit einer # adressiert. So könnte zum Beispiel ein Raum mit dem Befehl /join #raumname:servername betreten werden. In einem Raum befinden sich im Normalfall mehrere Personen.

In der Linken Leiste sehen Sie Ihre Direktchats, Ihre besuchten Räume und verschiedene Buttons um 1:1 Gespräche zu starten. Hier können Sie auch Räume erstellen oder betreten. Einladungen werden mit einer Meldung angezeigt.

Das Gesamtsystem ist sehr intuitiv und eigentlich selbst erklärend. Riot verfügt auch über die Möglichkeit von Voice und Video Calls.  Die Verwendung dieser Dienste sollten Sie aber mit dem Gesprächspartner vorher abklären.

Perfekt ist, dass keiner der großen Datensammler Zugriff auf Ihr Profil oder Ihre Kommunikation hat. Nur die in einem Gespräch involvierten Server routen den Traffic. Wobei, End-to-End Verschlüsselung vorausgesetzt, auch die Admins der involvierten Server keine Möglichkeit haben das Gespräch mitzulesen.  Privatsphäre wie sie sein soll.

Sie können mit mehreren Geräten gleichzeitig Online sein und alle Geräte sind in Real-Time synchronisiert. Die Benachrichtigungen können pro Gerät eingestellt werden. Für große Räume bietet sich die Einstellung „nur bei Erwähnung“ an. Dann erhalten Sie nur eine Benachrichtigung, wenn jemand im Chat Ihren Namen erwähnt.

Verschlüsselung aktivieren

Jedes Gespräch (1:1 Raum), bzw. jeder Gruppen-Chat Raum hat eine Möglichkeit, Einstellungen für den Raum zu setzen (Zahnrad neben dem Raumnamen anklicken). Dort kann man die Verschlüsselung aktivieren. Aufgrund der extrem vielen Features des Systems ist die Ersteinrichtung der Verschlüsselung mit einigen wenigen Aktivitäten verbunden. Dies sollte Sie aber nicht abschrecken und ich empfehle soweit als möglich verschlüsselt zu kommunizieren.

Danach ändert sich die Nachrichten Eingabebox von

  • Nachricht senden (unverschlüsselt)

auf

  • Nachricht senden (verschlüsselt).

Wichtig ist, dass Sie die Verschlüsselungskey(s) Ihrer Gesprächspartner verifizieren müssen. Nur dann ist eine einwandfreie Kommunikation gewährleistet.

Nach Aktivierung der Verschlüsselung schreiben Sie am besten eine Testnachricht. Danach werden Sie aufgefordert die Schlüssel zu bestätigen.

Wichtig: Bestätigen Sie alle Schlüssel Ihrer Partner. Ein Benutzer kann mehrere Schlüssel benutzen. Bei mir sind es z.B. 5 Schlüssel für verschiedene Geräte. Nur wenn Sie alle Schlüssel richtig bestätigt haben werden die Nachrichten aller involvierten Systeme mit einem grünen, geschlossenen, Schloss angezeigt. Sollte ein gelbes Warndreieck erscheinen müssen Sie, am besten durch Klick auf das Warndreieck, fehlende Schlüssel noch bestätigen. Bei Verwendung mehrere Geräte müssen Sie diesen Vorgang auf jedem Gerät wiederholen.

Sollten Sie sich abmelden – ist bei Apps und Desktop nicht notwendig – müssen Sie vorher den Key exportieren und nach dem Login wieder importieren. Andernfalls können ältere Nachrichten nicht dechiffriert werden.

Hilfe Videos am Riot Server:

about.riot.im/need-help/

Es ist schön zu sehen, dass die eigene Privatsphäre von vielen Menschen mittlerweile wieder ernst genommen wird. Die Zahl derer steigt täglich. Der Schwarm der Lemminge wird, wie bei einem Börsencrash, irgendwann panikartig auf dezentrale Systeme, ohne Möglichkeit des Zugriffes von Dritten, umschwenken. Bis dahin wird noch mit verschlossenen Augen kollektiv über die Klippe gesprungen.

Gehören Sie besser nicht dazu!

1:1 Chat

INTRO VIDEO auf Youtube

Create a room for group chat

INTRO VIDEO auf Youtube


UPDATE 9.5.2018

Aktuell wechseln extrem viele von anderen Messengern zu Riot/Matrix. Um Überlastungen des Projektservers zu verhindernempfiehlt sich:

für Computer Semi-Pros und Pros:

Einrichten eines eigenen Homeservers, siehe

für Benutzer ohne EDV Kenntnisse:

  • Registrieren des Accounts über das Webinterface des öffentlichen Servers:

https://riot.im/app/#/register

  • Danach sofort Download der App, bzw. der Desktop Version:

https://about.riot.im/downloads/

  • Login mit den erzeugten Benutzerdaten der Registrierung.

Nicht mit dem Browser arbeiten, denn sobald die Verschlüsselug aktiviert wird, besteht für Anfänger die Möglichkeit die privaten Schlüssel zu verlieren. Sofort nach der Registrierung App oder Linux, MAC, bzw. Windows Version nutzen!

UPDATE 20.11.2018

Bewerbungen für Pay Model Jobs wurden in die Community verlegt.

UPDATE 1.12.2018

Diverse Veränderungen in den Räumen

Update 15.5.2019

Eigene Anleitung zum einrichten eines eigenen Servers:

Models und Fotografen Community (Pay Jobs, Update)

Von diesem Beitrag gibt es eine neuere Version unter:

https://kmj.at/models-und-fotografen-community/



Da andere Systeme nicht mehr wirklich angenommen werden, wurde die „Models und Fotografen“ Community in der Riot Matrix eingerichtet. Der kostenlose Open Source Messenger Riot (https://riot.im) ist ein perfektes Tool für die Zusammenarbeit im Internet. In der Community existieren öffentliche Räume, zusätzlich können Models und Fotografen einen Direktchat starten, bzw. Projekte in separierten und optional auch versteckten Räumen organisieren. Auf Wunsch können Räume von Community Mitgliedern auch der Community Liste hinzugefügt werden.

Die Themen der Community

  • Pay Jobs für Models
  • Pay Jobs für Fotografen
  • TFP Jobs
  • Räume nach Regionen um eine bessere Übersicht zu erhalten.
  • allgemeine Diskussionsräume
  • weiteres auf Wunsch der User (Admins oder Moderatoren ansprechen)

Für Ungeduldige

  • Kostenloser Download der App von https://riot.im
  • Kostenlos und ohne persönliche Daten Account registrieren
  • Mit Benutzer/Password in der App anmelden
  • Deine Adresse wird @BENUTZERNAME:matrix.org
  • Direkten Chat mit mir @karl:matrix.ctseuro.com starten
  • Ich helfe bei den weiteren Schritten

Alle anderen lesen weiter …..

Riot.IM Info

Für alle die den Riot Messenger noch nicht verwenden findet sich unten eine Anleitung. Die wichtigsten Punkte:

  • Der Riot Messenger ist kostenlos und Open Source.
  • Bei Registrierung am öffentlichen Server keine persönlichen Daten wie E-Mail oder Telefonnummer notwendig! Hier ist niemand an den Daten interessiert.
  • Jeder kann, bei Interesse, auch einen eigenen Server betreiben und zur Matrix verbinden
  • Bei aktivierter Verschlüsselung kann auch am Server niemand mitlesen
  • Sogar die französische Regierung baut gerade eine Riot/Martix Landschaft auf um WhatsApp oder Telegram abzulösen. https://matrix.org/blog/2018/04/26/matrix-and-riot-confirmed-as-the-basis-for-frances-secure-instant-messenger-app/

  • Verfügbar für IOS, Android, Linux, Mac, Windows

  • Mehrere Endgeräte können gleichzeitig online sein

  • Potential so gut wie jede Kommunikation in einer Software zu halten

  • Verschlüsselte Telefonie zwischen den Teilnehmern möglich

Riot Rauminfo für die Models und Fotografen Community

Wie im Riot Messenger üblich ist die Rezeption der Model und Fotografen Community über die Eingabe von:

/j #muf-rezeption:matrix.ctseuro.com

in der Chat Box, oder über die Raumliste des Servers

matrix.ctseuro.com

betreten. Die Rezeptions ist öffentlich zugänglich und dient als Welcome Room für Interessierte. Sollten Probleme auftreten, starte einen Direktchat mit @karl:matrix.ctseuro.com .

Bitte kontaktiere im Raum einen der Moderatoren oder Admins, bzw. @karl:matrix.ctseuro.com um eine Einladung in die Community und damit Zugang zu den anderen Räumen zu erhalten. Einladungen erfolgen nur für aktive Models und Fotografen!

Raumvorschläge, oder Anfragen um Moderator zu werden bitte an @karl:matrix.ctseuro.com .

RIOT Messenger komplette Anleitung

Kostenloser, Open Source Messenger mit Apps für IOS und Android, sowie Desktop Versionen für Windows, MAC und Linux! Unterstützt sichere End-to-End Verschlüsselung auch bei Gruppenchats!

Mittlerweile sind alle meine Kontakte, mit denen ich laufend in Kontakt bin, auf den kostenlosen Open Source Messenger, Riot.IM umgestiegen und einige betreiben auch einen eigenen Matrix/Synapse Server. Dadurch können wir wieder sicher, end-to-end verschlüsselt, kommunizieren und wissen, dass niemand mitliest und unsere Gespräche auswertet. Die Möglichkeiten von Riot.im sind wirklich grenzenlos und bis jetzt gab es, auch bei gleichzeitiger Verwunden von mehreren Endgeräten (Linux, IOS, Android), keine Probleme. Dieses Multi-Device Syncing ist wirklich mehr als genial. Riot.IM ist perfekt um Kontakte zu pflegen, bzw. im Firmenbereich Kunden und Interessenten an sich zu binden. Mit einem Account die Kommunikation (Einzel- und Gruppenchat, Voice und Video), sogar auf mehreren Geräten gleichzeitig zu managen ist eine neue Art der Kommunikation.

WICHTIG: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der End-to-End-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

INTRO VIDEO auf Youtube

KURZANLEITUNG:

  • Registrieren Sei Ihren kostenlosen Account unter Riot.IM
  • Installieren Sie die App für IOS oder Android, bzw. die Desktop Version für Windows, MAC, oder Linux (mehrere Clients können gleichzeitig betrieben werden!)
  • melden Sie sich mit Ihrem Benutzernamen und dem Passwort an
  • Wichtig: Ein Passwort-Reset ist ohne E-Mail Adresse nicht möglich. Das Passwort darf nicht vergessen werden!
  • Meine Riot Adresse: @karl:matrix.ctseuro.com

Endanwender können die kostenlose Open-Source-Software über die Webseite Riot.IM herunterladen.

Für Leser: Kostenloser Open Source Messenger

Dezentral, optional End-to-End verschlüsselt, sicher kommunizieren ohne Profil- und Kommunikationsdaten an die großen Datensammler weiterzugeben!

Folgend auf den eher technischen Artikel zu Matrix/Synapse + Riot:

/matrixsynapse-riot-im-die-neue-form-der-kommunikation-fuer-endanwender-und-unternehmen/

folgt nun eine Kurzanleitung zum Schnellstart für Benutzer. Unternehmen können zur Hilfestellung beim Setup ihrer Matrix/Synapse Server gerne die CTS GMBH unter support@cts-solutions.at kontaktieren oder die Installation laut Beschreibung vornehmen. Setup Link für Unternehmensserver: github.com/matrix-org/synapse

Kurzanleitung für Endanwender

Wer nur einmal hineinschnuppern möchte, kann sich auch über den Browser unter riot.im/app/ anmelden. Ich rate von der Verwendung des Browsers, sobald verschlüsselte Verbindungen verwendet werden, ab.

Nach der Installation können Sie sich mit „Benutzerkonto erstellen“  einen kostenlosen Account registrieren.

Sollten Sie sich nicht auf einem speziellen Server eines Serverbetreibers registrieren, erhalten Sie eine Adresse auf matrix.org. Sie müssen keine E-Mail-Adresse oder Telefonnummer eingeben und können nur durch Eingabe von Nutzername und Passwort sofort loslegen.  Beachten Sie aber, dass damit keine „Passwort verloren“ Aktion möglich ist und wenn Sie Ihr Passwort verlieren ist auch Ihr Account dauerhaft verloren.

Wie bei E-Mail-Adressen baut sich eine Matrix Adresse wie folgt auf:

Benutzernamen für Direktchat: @Benutzername:Server.Domain

Sie erhalten zum Beispiel @IhrBenutzername:matrix.org, wenn Sie sich auf dem matrix.org Server registriert haben. Wenn Sie mich ansprechen wollen, können Sie dies unter @karl:matrix.ctseuro.com tun. Ihre Nachricht wird dann zu meinem Server (matrix.ctseuro.com) weitergeleitet. Sobald die End-to-End Verschlüsselung aktiviert wird, ist es sogar dem Server Admin unmöglich, die Unterhaltung mitzulesen.

Räume funktionieren, da auch diese als Raum (mit eben nur 2 Personen) geführt werden, wie 1:1 Chats. Adressen von Räumen werden mit einer # adressiert. So könnte zum Beispiel ein Raum mit dem Befehl /join #raumname:servername betreten werden. In einem Raum befinden sich im Normalfall mehrere Personen.

In der Linken Leiste sehen Sie Ihre Direktchats, Ihre besuchten Räume und verschiedene Buttons um 1:1 Gespräche zu starten. Hier können Sie auch Räume erstellen oder betreten. Einladungen werden mit einer Meldung angezeigt.

Das Gesamtsystem ist sehr intuitiv und eigentlich selbst erklärend. Riot verfügt auch über die Möglichkeit von Voice und Video Calls.  Die Verwendung dieser Dienste sollten Sie aber mit dem Gesprächspartner vorher abklären.

Perfekt ist, dass keiner der großen Datensammler Zugriff auf Ihr Profil oder Ihre Kommunikation hat. Nur die in einem Gespräch involvierten Server routen den Traffic. Wobei, End-to-End Verschlüsselung vorausgesetzt, auch die Admins der involvierten Server keine Möglichkeit haben das Gespräch mitzulesen.  Privatsphäre wie sie sein soll.

Sie können mit mehreren Geräten gleichzeitig Online sein und alle Geräte sind in Real-Time synchronisiert. Die Benachrichtigungen können pro Gerät eingestellt werden. Für große Räume bietet sich die Einstellung „nur bei Erwähnung“ an. Dann erhalten Sie nur eine Benachrichtigung, wenn jemand im Chat Ihren Namen erwähnt.

Verschlüsselung aktivieren

Jedes Gespräch (1:1 Raum), bzw. jeder Gruppen-Chat Raum hat eine Möglichkeit, Einstellungen für den Raum zu setzen (Zahnrad neben dem Raumnamen anklicken). Dort kann man die Verschlüsselung aktivieren. Aufgrund der extrem vielen Features des Systems ist die Ersteinrichtung der Verschlüsselung mit einigen wenigen Aktivitäten verbunden. Dies sollte Sie aber nicht abschrecken und ich empfehle soweit als möglich verschlüsselt zu kommunizieren.

Danach ändert sich die Nachrichten Eingabebox von

  • Nachricht senden (unverschlüsselt)

auf

  • Nachricht senden (verschlüsselt).

Wichtig ist, dass Sie die Verschlüsselungskey(s) Ihrer Gesprächspartner verifizieren müssen. Nur dann ist eine einwandfreie Kommunikation gewährleistet.

Nach Aktivierung der Verschlüsselung schreiben Sie am besten eine Testnachricht. Danach werden Sie aufgefordert die Schlüssel zu bestätigen.

Wichtig: Bestätigen Sie alle Schlüssel Ihrer Partner. Ein Benutzer kann mehrere Schlüssel benutzen. Bei mir sind es z.B. 5 Schlüssel für verschiedene Geräte. Nur wenn Sie alle Schlüssel richtig bestätigt haben werden die Nachrichten aller involvierten Systeme mit einem grünen, geschlossenen, Schloss angezeigt. Sollte ein gelbes Warndreieck erscheinen müssen Sie, am besten durch Klick auf das Warndreieck, fehlende Schlüssel noch bestätigen. Bei Verwendung mehrere Geräte müssen Sie diesen Vorgang auf jedem Gerät wiederholen.

Sollten Sie sich abmelden – ist bei Apps und Desktop nicht notwendig – müssen Sie vorher den Key exportieren und nach dem Login wieder importieren. Andernfalls können ältere Nachrichten nicht dechiffriert werden.

Hilfe Videos am Riot Server:

about.riot.im/need-help/

Es ist schön zu sehen, dass die eigene Privatsphäre von vielen Menschen mittlerweile wieder ernst genommen wird. Die Zahl derer steigt täglich. Der Schwarm der Lemminge wird, wie bei einem Börsencrash, irgendwann panikartig auf dezentrale Systeme, ohne Möglichkeit des Zugriffes von Dritten, umschwenken. Bis dahin wird noch mit verschlossenen Augen kollektiv über die Klippe gesprungen.

Gehören Sie besser nicht dazu!

1:1 Chat

INTRO VIDEO auf Youtube

Create a room for group chat

INTRO VIDEO auf Youtube


UPDATE 9.5.2018

Aktuell wechseln extrem viele von anderen Messengern zu Riot/Matrix. Um Überlastungen des Projektservers zu verhindernempfiehlt sich:

für Computer Semi-Pros und Pros:

Einrichten eines eigenen Homeservers, siehe https://matrix.org

für Benutzer ohne EDV Kenntnisse:

  • Registrieren des Accounts über das Webinterface des öffentlichen Servers:

https://riot.im/app/#/register

  • Danach sofort Download der App, bzw. der Desktop Version:

https://about.riot.im/downloads/

  • Login mit den erzeugten Benutzerdaten der Registrierung.

Nicht mit dem Browser arbeiten, denn sobald die Verschlüsselug aktiviert wird, besteht für Anfänger die Möglichkeit die privaten Schlüssel zu verlieren. Sofort nach der Registrierung App oder Linux, MAC, bzw. Windows Version nutzen!

UPDATE 20.11.2018

Bewerbungen für Pay Model Jobs wurden in die Community verlegt.

Models und Fotografen Community (Update 9.5.2018)

Es existiert ein neuerer Artikel unter:

https://kmj.at/2018-11-20-models-und-fotografen-community/

Update vom 9.5.2018

zum Artikel:

/2018-04-29-models-und-fotografen-community/

finden sich hier eine aktuelles Updates:

Registrieung:

Aktuell wechseln extrem viele von anderen Messengern zu Riot/Matrix. Um Überlastungen des Projektservers zu verhindernempfiehlt sich:

für Computer Semi-Pros und Pros:

Einrichten eines eigenen Homeservers, siehe https://matrix.org

für Benutzer ohne EDV Kenntnisse:

  • Registrieren des Accounts über das Webinterface des öffentlichen Servers:

https://riot.im/app/#/register

  • Danach sofort Download der App, bzw. der Desktop Version:

https://about.riot.im/downloads/

  • Login mit den erzeugten Benutzerdaten der Registrierung.

Nicht mit dem Browser arbeiten, denn sobald die Verschlüsselug aktiviert wird, besteht für Anfänger die Möglichkeit die privaten Schlüssel zu verlieren. Sofort nach der Registrierung App oder Linux, MAC, bzw. Windows Version nutzen!

Models und Fotografen Community (Pay Jobs)

Es existiert ein neuerer Artikel unter:

https://kmj.at/2018-11-20-models-und-fotografen-community/

Da andere Systeme nicht mehr wirklich angenommen werden, wurde die „Models und Fotografen“ Community in der Riot Matrix eingerichtet. Der kostenlose Open Source Messenger Riot (https://riot.im) ist ein perfektes Tool für die Zusammenarbeit im Internet. In der Community existieren öffentliche Räume, zusätzlich können Models und Fotografen einen Direktchat starten, bzw. Projekte in separierten und optional auch versteckten Räumen organisieren. Auf Wunsch können Räume von Community Mitgliedern auch der Community Liste hinzugefügt werden.

Die Themen der Community

  • Pay Jobs für Models
  • Pay Jobs für Fotografen
  • TFP Jobs
  • Räume nach Regionen um eine bessere Übersicht zu erhalten.
  • allgemeine Diskussionsräume
  • weiteres auf Wunsch der User (Admins oder Moderatoren ansprechen)

Für Ungeduldige

  • Kostenloser Download der App von https://riot.im
  • Kostenlos und ohne persönliche Daten Account registrieren
  • Mit Benutzer/Password in der App anmelden
  • Deine Adresse wird @BENUTZERNAME:matrix.org
  • Direkten Chat mit mir @karl:matrix.ctseuro.com starten
  • Ich helfe bei den weiteren Schritten

Alle anderen lesen weiter …..

Riot.IM Info

Für alle die den Riot Messenger noch nicht verwenden findet sich unten eine Anleitung. Die wichtigsten Punkte:

  • Der Riot Messenger ist kostenlos und Open Source.
  • Bei Registrierung am öffentlichen Server keine persönlichen Daten wie E-Mail oder Telefonnummer notwendig! Hier ist niemand an den Daten interessiert.
  • Jeder kann, bei Interesse, auch einen eigenen Server betreiben und zur Matrix verbinden
  • Bei aktivierter Verschlüsselung kann auch am Server niemand mitlesen
  • Sogar die französische Regierung baut gerade eine Riot/Martix Landschaft auf um WhatsApp oder Telegram abzulösen. https://matrix.org/blog/2018/04/26/matrix-and-riot-confirmed-as-the-basis-for-frances-secure-instant-messenger-app/

  • Verfügbar für IOS, Android, Linux, Mac, Windows

  • Mehrere Endgeräte können gleichzeitig online sein

  • Potential so gut wie jede Kommunikation in einer Software zu halten

  • Verschlüsselte Telefonie zwischen den Teilnehmern möglich

Riot Rauminfo für die Models und Fotografen Community

Wie im Riot Messenger üblich ist die Rezeption der Model und Fotografen Community über die Eingabe von:

/j #muf-rezeption:matrix.ctseuro.com

in der Chat Box, oder über die Raumliste des Servers

matrix.ctseuro.com

betreten. Die Rezeptions ist öffentlich zugänglich und dient als Welcome Room für Interessierte. Sollten Probleme auftreten, starte einen Direktchat mit @karl:matrix.ctseuro.com .

Bitte kontaktiere im Raum einen der Moderatoren oder Admins, bzw. @karl:matrix.ctseuro.com um eine Einladung in die Community und damit Zugang zu den anderen Räumen zu erhalten. Einladungen erfolgen nur für aktive Models und Fotografen!

Raumvorschläge, oder Anfragen um Moderator zu werden bitte an @karl:matrix.ctseuro.com .

RIOT Messenger komplette Anleitung

Kostenloser, Open Source Messenger mit Apps für IOS und Android, sowie Desktop Versionen für Windows, MAC und Linux! Unterstützt sichere End-to-End Verschlüsselung auch bei Gruppenchats!

Mittlerweile sind alle meine Kontakte, mit denen ich laufend in Kontakt bin, auf den kostenlosen Open Source Messenger, Riot.IM umgestiegen und einige betreiben auch einen eigenen Matrix/Synapse Server. Dadurch können wir wieder sicher, end-to-end verschlüsselt, kommunizieren und wissen, dass niemand mitliest und unsere Gespräche auswertet. Die Möglichkeiten von Riot.im sind wirklich grenzenlos und bis jetzt gab es, auch bei gleichzeitiger Verwunden von mehreren Endgeräten (Linux, IOS, Android), keine Probleme. Dieses Multi-Device Syncing ist wirklich mehr als genial. Riot.IM ist perfekt um Kontakte zu pflegen, bzw. im Firmenbereich Kunden und Interessenten an sich zu binden. Mit einem Account die Kommunikation (Einzel- und Gruppenchat, Voice und Video), sogar auf mehreren Geräten gleichzeitig zu managen ist eine neue Art der Kommunikation.

WICHTIG: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der End-to-End-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

INTRO VIDEO auf Youtube

KURZANLEITUNG:

  • Registrieren Sei Ihren kostenlosen Account unter Riot.IM
  • Installieren Sie die App für IOS oder Android, bzw. die Desktop Version für Windows, MAC, oder Linux (mehrere Clients können gleichzeitig betrieben werden!)
  • melden Sie sich mit Ihrem Benutzernamen und dem Passwort an
  • Wichtig: Ein Passwort-Reset ist ohne E-Mail Adresse nicht möglich. Das Passwort darf nicht vergessen werden!
  • Meine Riot Adresse: @karl:matrix.ctseuro.com

Endanwender können die kostenlose Open-Source-Software über die Webseite Riot.IM herunterladen.

Für Leser: Kostenloser Open Source Messenger

Dezentral, optional End-to-End verschlüsselt, sicher kommunizieren ohne Profil- und Kommunikationsdaten an die großen Datensammler weiterzugeben!

Folgend auf den eher technischen Artikel zu Matrix/Synapse + Riot:

/matrixsynapse-riot-im-die-neue-form-der-kommunikation-fuer-endanwender-und-unternehmen/

folgt nun eine Kurzanleitung zum Schnellstart für Benutzer. Unternehmen können zur Hilfestellung beim Setup ihrer Matrix/Synapse Server gerne die CTS GMBH unter support@cts-solutions.at kontaktieren oder die Installation laut Beschreibung vornehmen. Setup Link für Unternehmensserver: github.com/matrix-org/synapse

Kurzanleitung für Endanwender

Wer nur einmal hineinschnuppern möchte, kann sich auch über den Browser unter riot.im/app/ anmelden. Ich rate von der Verwendung des Browsers, sobald verschlüsselte Verbindungen verwendet werden, ab.

Nach der Installation können Sie sich mit „Benutzerkonto erstellen“  einen kostenlosen Account registrieren.

Sollten Sie sich nicht auf einem speziellen Server eines Serverbetreibers registrieren, erhalten Sie eine Adresse auf matrix.org. Sie müssen keine E-Mail-Adresse oder Telefonnummer eingeben und können nur durch Eingabe von Nutzername und Passwort sofort loslegen.  Beachten Sie aber, dass damit keine „Passwort verloren“ Aktion möglich ist und wenn Sie Ihr Passwort verlieren ist auch Ihr Account dauerhaft verloren.

Wie bei E-Mail-Adressen baut sich eine Matrix Adresse wie folgt auf:

Benutzernamen für Direktchat: @Benutzername:Server.Domain

Sie erhalten zum Beispiel @IhrBenutzername:matrix.org, wenn Sie sich auf dem matrix.org Server registriert haben. Wenn Sie mich ansprechen wollen, können Sie dies unter @karl:matrix.ctseuro.com tun. Ihre Nachricht wird dann zu meinem Server (matrix.ctseuro.com) weitergeleitet. Sobald die End-to-End Verschlüsselung aktiviert wird, ist es sogar dem Server Admin unmöglich, die Unterhaltung mitzulesen.

Räume funktionieren, da auch diese als Raum (mit eben nur 2 Personen) geführt werden, wie 1:1 Chats. Adressen von Räumen werden mit einer # adressiert. So könnte zum Beispiel ein Raum mit dem Befehl /join #raumname:servername betreten werden. In einem Raum befinden sich im Normalfall mehrere Personen.

In der Linken Leiste sehen Sie Ihre Direktchats, Ihre besuchten Räume und verschiedene Buttons um 1:1 Gespräche zu starten. Hier können Sie auch Räume erstellen oder betreten. Einladungen werden mit einer Meldung angezeigt.

Das Gesamtsystem ist sehr intuitiv und eigentlich selbst erklärend. Riot verfügt auch über die Möglichkeit von Voice und Video Calls.  Die Verwendung dieser Dienste sollten Sie aber mit dem Gesprächspartner vorher abklären.

Perfekt ist, dass keiner der großen Datensammler Zugriff auf Ihr Profil oder Ihre Kommunikation hat. Nur die in einem Gespräch involvierten Server routen den Traffic. Wobei, End-to-End Verschlüsselung vorausgesetzt, auch die Admins der involvierten Server keine Möglichkeit haben das Gespräch mitzulesen.  Privatsphäre wie sie sein soll.

Sie können mit mehreren Geräten gleichzeitig Online sein und alle Geräte sind in Real-Time synchronisiert. Die Benachrichtigungen können pro Gerät eingestellt werden. Für große Räume bietet sich die Einstellung „nur bei Erwähnung“ an. Dann erhalten Sie nur eine Benachrichtigung, wenn jemand im Chat Ihren Namen erwähnt.

Verschlüsselung aktivieren

Jedes Gespräch (1:1 Raum), bzw. jeder Gruppen-Chat Raum hat eine Möglichkeit, Einstellungen für den Raum zu setzen (Zahnrad neben dem Raumnamen anklicken). Dort kann man die Verschlüsselung aktivieren. Aufgrund der extrem vielen Features des Systems ist die Ersteinrichtung der Verschlüsselung mit einigen wenigen Aktivitäten verbunden. Dies sollte Sie aber nicht abschrecken und ich empfehle soweit als möglich verschlüsselt zu kommunizieren.

Danach ändert sich die Nachrichten Eingabebox von

  • Nachricht senden (unverschlüsselt)

auf

  • Nachricht senden (verschlüsselt).

Wichtig ist, dass Sie die Verschlüsselungskey(s) Ihrer Gesprächspartner verifizieren müssen. Nur dann ist eine einwandfreie Kommunikation gewährleistet.

Nach Aktivierung der Verschlüsselung schreiben Sie am besten eine Testnachricht. Danach werden Sie aufgefordert die Schlüssel zu bestätigen.

Wichtig: Bestätigen Sie alle Schlüssel Ihrer Partner. Ein Benutzer kann mehrere Schlüssel benutzen. Bei mir sind es z.B. 5 Schlüssel für verschiedene Geräte. Nur wenn Sie alle Schlüssel richtig bestätigt haben werden die Nachrichten aller involvierten Systeme mit einem grünen, geschlossenen, Schloss angezeigt. Sollte ein gelbes Warndreieck erscheinen müssen Sie, am besten durch Klick auf das Warndreieck, fehlende Schlüssel noch bestätigen. Bei Verwendung mehrere Geräte müssen Sie diesen Vorgang auf jedem Gerät wiederholen.

Sollten Sie sich abmelden – ist bei Apps und Desktop nicht notwendig – müssen Sie vorher den Key exportieren und nach dem Login wieder importieren. Andernfalls können ältere Nachrichten nicht dechiffriert werden.

Hilfe Videos am Riot Server:

about.riot.im/need-help/

Es ist schön zu sehen, dass die eigene Privatsphäre von vielen Menschen mittlerweile wieder ernst genommen wird. Die Zahl derer steigt täglich. Der Schwarm der Lemminge wird, wie bei einem Börsencrash, irgendwann panikartig auf dezentrale Systeme, ohne Möglichkeit des Zugriffes von Dritten, umschwenken. Bis dahin wird noch mit verschlossenen Augen kollektiv über die Klippe gesprungen.

Gehören Sie besser nicht dazu!

1:1 Chat

INTRO VIDEO auf Youtube

Create a room for group chat

INTRO VIDEO auf Youtube



UPDATE 9.5.2018

Aktuell wechseln extrem viele von anderen Messengern zu Riot/Matrix. Um Überlastungen des Projektservers zu verhindernempfiehlt sich:

für Computer Semi-Pros und Pros:

Einrichten eines eigenen Homeservers, siehe https://matrix.org

für Benutzer ohne EDV Kenntnisse:

  • Registrieren des Accounts über das Webinterface des öffentlichen Servers:

https://riot.im/app/#/register

  • Danach sofort Download der App, bzw. der Desktop Version:

https://about.riot.im/downloads/

  • Login mit den erzeugten Benutzerdaten der Registrierung.

Nicht mit dem Browser arbeiten, denn sobald die Verschlüsselug aktiviert wird, besteht für Anfänger die Möglichkeit die privaten Schlüssel zu verlieren. Sofort nach der Registrierung App oder Linux, MAC, bzw. Windows Version nutzen!

Ein weiterer Schritt in eine dezentrale Zukunft ist getan (Mastodon / Riot / Matrix / kostenlos / dezentral / Open Source)!

Umstieg auf Mastodon als dezentrale Open Source Micro Blogging Plattform

Was bisher geschah

Lange vor den nun aufkommenden Datenskandalen habe ich schon massiv vor der Problematik von Programmen (Apps), welche die Leute ohne nachzudenken auf Ihre Endgeräte laden, gewarnt. Zentrale Lösungen, welche 95% Ihres Umsatzes damit generieren möglichst viel über die Benutzer zu erfahren, werden alles tun um eine möglichst große Datensammlung zu erzeugen.

Viele Beispiele zeigen, dass sich die Benutzer noch immer keine ausreichenden EDV Kenntnisse angeeignet haben um die volle Auswirkung Ihres Handelns zu erfassen. Ohne Nachzudenken wird Apps der Zugriff, z.B. auf die am Handy gespeicherten Kontakte gewährt – EDV Laien haben Ja-Ja-Weiter ohne Nachdenken am liebsten - und damit alle Daten an fremde Rechner übermittelt. Teilweise werden Kontakte dann dadurch eingeladen irgendwelche Apps, welche Sie nie wollten, zu benutzen. Zusätzlich werden diese Daten in vielen Fällen auch weiter verkauft.

der angerichtete Schaden

Geheime Kundendatenbanken von Firmen, welche z.B. dem Vertrieb auf das Handy geladen werden, kommen so, über den Zugriff diverser von den Mitarbeitern installierter Programme (Apps) in den Zugriff von Personen, welche dem Unternehmen und dem Mitarbeiter nicht bekannt sind.

Die Entscheidung, ob Firmen und Privatpersonen Ihre ganze persönlichen Daten, kostenlos und frei Haus, an irgendwelche Menschen, Firmen und Rechner im Internet übermitteln, ist keine rein interne Entscheidung. Sie geben Ihre gesammelten Daten von Personen und Firmen im Netz frei, welche Ihnen dafür keine Erlaubnis erteilt haben.

Privatsphäre

In der Zukunft werden sich mehrere Anwendergruppen bilden.

  • die Lemminge, welche Ihren Lobbyisten klatschend nachlaufen, jedes Programm (App) installieren und Ihre Daten ohne nachzudenken im Netz verbreiten. Mit dieser Gruppe beschäftigt sich dieser Beitrag nicht, ich erinnere aber an das Bild der Lemminge, welche mit geschlossenen Augen hinter Ihrem Guru über die Klippe springen. Wirklich genervt ist man nur, dass genau diese Menschen dann am lautesten jammern und weinen, wenn Sie von einem Datenproblem betroffen sind. Zuerst ohne Lesen jede Nutzungsbedingung akzeptieren und dann jammern, geht gar nicht. Ich bin kein Freund von den großen Datensammlern, aber man muss denen zu Gute halten, dass jeder der in den „Sozialen Medien“ etwas postet, zugestimmt hat, dass die Plattform die Daten auswerten, verbreiten und anders verwenden darf. Warum soll jemand für diese Lemminge ohne Mitglieds- oder Nutzungsgebühr eine extrem teure IT Infrastruktur bauen. Natürlich müssen die Kosten gedeckt werden, das ist allen bewusst. Die Bezahlung erfolgt mit den Daten und das wissen alle!

  • die smarten Benutzer und Unternehmen, bedacht auf Ihre Privatsphäre und gleichzeitig erfolgreich im Aufbau einer treuen Fan-Gemeinde ohne jeden Algorithmus eines zentralen Anbieters. Durch die Dezentralisierung ergeben sich ohne Zensur viele neue Möglichkeiten für Benutzer und Unternehmen. Für diese Gruppe ist dieser Beitrag.

Lösungen

Basis Dezentralisierung

Jeder verwendet mit E-Mail zumindest eine dezentrale Lösung im Internet. Trotz Milliarden an Accounts werden Daten nur zwischen den beteiligten Servern ausgetauscht, obwohl jeder mit jedem, basierend auf der E-Mail Adresse kommunizieren kann. Eine E-Mail von Firma A an Firma B geht, vorausgesetzt jede der Firmen betreibt, wie es unbedingt sein sollte, einen hausinternen E-Mail Server ohne Fremdzugriff, direkt vom Server der Firma A an den Server der Firma B. Die E-Mail wird auf keinem anderen Server gespeichert.

Für private Benutzer ohne EDV Kenntnisse gibt es E-Mail Anbieter, welche deren Accounts führen. Hier und auch bei schlecht organisierten Firmen, welche Ihre E-Mail Server außer Haus betreiben, besteht ein vollkommener Fremdzugriff auf Ihre Daten von Personen, welche den Beteiligten vollkommen unbekannt sind.

Insbesondere bei Anbietern mit der geringsten Verbindung in die USA muss davon ausgegangen werden, dass Daten von Servern in den USA vollkommen offen für die Administratoren und die Behörden sind. Mit dem „Cloud Act von 2018“ gibt es diesen Zugriff auch auf Server außerhalb der USA und damit wird auch klar, dass jede angebotene Datenverschlüsselung für die Betreiber und die Behörden offen für den Zugriff ist:

“Cloud Act”: US-Behörden erhalten Zugriff auf europäische Daten

https://deutsch.rt.com/nordamerika/67269-cloud-act-us-behoerden-erhalten-zugriff-auf-daten-ausserhalb-der-eigenen-grenzen/

https://fcw.com/articles/2018/02/09/cloud-act.aspx

https://www.eff.org/deeplinks/2018/02/cloud-act-dangerous-expansion-police-snooping-cross-border-data

Nur mit Dezentralisierung, Weiterbildung der Benutzer und Administratoren, sowie Interesse für die Privatsphäre lassen sich viele dieser Risiken umgehen.

Auf Open Source Software basierende Lösungen

Nur bei Open Source Software können viele Augen den Programmcode kontrollieren, auf Sicherheit und eventuelle Backdoors prüfen. Damit ist es viel unwahrscheinlicher, dass ein Programm Daten der Benutzer an fremde Personen und Unternehmen überträgt. Zusätzlich werden Fehlerkorrekturen meist schneller angeboten.

Eine wachsende Zahl an Administratoren hat die Vorteile von kostenlosen Open Source Lösungen erkannt und sich mit Linux und FreeBSD als Betriebssystem auseinander gesetzt. Fachlich kompetente Administratoren mit einem breiten IT Allgemeinwissen setzen seit langem verstärkt auf diese Lösungen und reduzieren proprietäre Losungen soweit als möglich. Höhere Sicherheit, mehr Flexibilität und geringere IT-Kosten sind im Normalfall die Folge.

Wie schon hier auf meiner Webseite mehrfach berichtet gibt es im Bereich Messaging, Voice Telefonie und Micro Blogging wirklich perfekte Lösungen, welche auch für den Enterprise Einsatz gedacht sind.

Messaging und Voice Calls – Open Team Collaboration

Seit längerem kristallisiert sich die dezentrale, auf dem Matrix Server ( https://matrix.org) basierende Riot.IM (https://riot.im/) Lösung als die Zukunft des Messaging/Voice Calls heraus. Server, wie auch die Client-seitig Anwendung Riot.IM (verfügbar für Linux, Windows, MAC, IOS, Android), sind kostenlose Open Source Lösungen, bei denen niemand an den Daten der Benutzer Interesse hat.

Riot.IM bietet 1:1 Messaging und Internet Telefonie mit End-to-End Verrschlüsselung. Zusätzlich bietet das System auch End-to-End verschlüsselten Gruppenchat und Voice Konferenzen, bzw. Vortragsmöglichkeiten. Intuitiv, auch von EDV Laien sofort bedienbar.

Benutzer unterschiedlicher Server können, als E-Mail über die @user:domain Adresse kommunizieren, telefonieren und Konferenzen einrichten.

Firmen können auf einfache Weise Ihren eigenen Matrix Server für Riot.IM Anwender betreiben und reine Benutzer können sich auf öffentlichen Servern, nur durch Angabe von Benutzername und Passwort registrieren. Es werden keine persönlichen Daten abgefragt und aufgrund des Verschlüsselungs-Verifizierungs-Systems ist ein Mitlesen durch Dritte ausgeschlossen. Software und Accounts sind kostenlos. Perfekt für Kommunikation, Chat, Internet Telefonie, Information, Support und Internet basierter Zusammenarbeit.

Endlich ohne Mitleser dezentral kommunizieren. Auch bei Matrix/Riot.IM sind nur die beteiligten Server in den Datentransfer involviert. Das kennen Sie bereits von E-Mails. Meine Riot.IM Adresse ist im Footer dieser Seite.

Micro Blogging – Open Source Alternative zu einem bekannten 140 Zeichen Anbieter

Soziales Netzwerken wieder in deinen Händen

Das weltgrößte freie, quelloffene und dezentralisierte Mikroblogging-Netzwerk.

Auch im Micro Blogging Bereich hat sich viel getan. Salopp formuliert ist Mastodon (https://joinmastodon.org/) der feuchte Traum aller Werbetreibenden in USA und Asien. Endlich ohne Algorithmus eines Anbieters eine Fangemeinde aufbauen. Firmen, Werbetreibende und Private können eigene Instanzen (ähnlich eigenem Mail Server) installieren und betreiben. Damit ist es möglich ohne jede Zensur eigene Informationen zu verbreiten.

Durch die sogenannte Federation (Verbindung der Server) kann jeder Benutzer einer anderen Instanz einem anderen Benutzer im Mastodon Universum folgen. So aufgebaute Fan Gemeinden sind frei von jeder Kontrolle zentraler Anbieter und jedes Unternehmen und jeder Benutzer hat die exakt gleichen Chancen Followers aufzubauen.

Anwendungen für IOS, Android und jeder anderen erdenklichen Plattform bieten einen unproblematischen Zugriff, frei von Datensammlern und anderen unerwünschten Erscheinungen.

Meine Mastodon Adresse ist im Footer dieser Seite.

Zusammenfassung

Abschließen sei gesagt, dass es immer etwas mehr Interesse und Aufwand benötigt gute Lösungen einzusetzen. Natürlich versuchen die großen Datensammler und Cloud Anbieter Ihnen den Einstieg auf deren Plattform ganz einfach zu machen. Ihre Daten sind bares Geld wert, da strengt man sich an. Aber das sollte Sie nicht aufhalten auf dezentrale Lösungen unter Ihrer Kontrolle zu wechseln.

Als Anwender bedarf es sehr wenig Aufwand auf diese neuen Plattformen umzusteigen, viele smarte User sind bereits dabei.

Betreiber von Instanzen können, einen guten Admin im Haus, bzw. einen erfahrenen externen Betreuer vorausgesetzt, diese Server auf einfachste Weise installieren und betreiben. Alle aufgebauten Verbindungen zu Benutzern bleiben Ihnen dauerhaft erhalten und werden nicht von einem Anbieter zur Umsatzgenerierung verwendet. Nach ein paar Minuten des Nachdenkens werden Sie zustimmen, der Einsatz lohnt sich für alle!

Und wenn Menschen glauben, dass das Leben an Ihnen vorbei geht, wenn sie eine gewisse Kommunikations App (Programm) nicht installieren, denke ich, dass diese Leute das Leben bereits verpasst haben. Wer wirklich glaubt nur mit tausenden Likes oder Freunden ein Selbstbewusstsein zu haben, der sollte über sich selbst nachdenken.

Am Ende geht nichts über das persönliche Gespräch und Netzwerk Kontakte die man persönlich kennt.

Ja, auch ich habe Facebook, aber natürlich kein Programm (App) dafür installiert. Der Zugriff erfolgt nut mit einem sicheren Browser. Kein Datensammeln im Hintergrund und nur Kontakte, welche, bis auf ganz wenige Ausnahmen, persönlich bekannt sind. Und natürlich wurden meine Kontakte nie mit irgendeiner Plattform synchronisiert. Facebook Messenger oder andere Messenger werden nicht benutzt, nur in absoluten Ausnahmefällen Facebook Messenger mit nicht kritischen Inhalten über den Browser. Aber da dabei kein Notify ausgelöst wird, lese ich das erst beim nächsten Einstieg mit dem Browser.

Und wer wirklich glaubt, er ist nur über die proprietäre Datensammel und Mitlese-App irgendwas erreichbar, muss halt auf die Kommunikation mit mir verzichten. Ich denke aber, die Kommunikation wird mir dann auch nicht fehlen.

Alle Kontakte mit denen ich regelmäßig kommuniziere befinden sich bereits auf Riot.IM/Matrix und für alle anderen gibt es ja auch noch das gute alte Telefon.

Sollten Sie HIlfe beim Aufsetzen eigener Instanzen oder Server benötigen finden Sie hier Hilfe:

/2018-03-29-cts-support-remote-it-support-fuer-open-source/

Update 2018-11-23:

Fortsetzung: https://kmj.at/gedanken-user-die-privatsphaere-und-sicherheit-der-eigenen-daten-im-netz/

Riot.IM Messenger: Kurzanleitung für Benutzer mit Videos (Stand 03/2018)

Eine neue Version des Dokumentes finden Sie hier:

/2019-01-23-riot-im-messenger-kurzanleitung-fuer-benutze-updated

OUTDATED VERSION!

Kostenloser, Open Source Messenger mit Apps für IOS und Android, sowie Desktop Versionen für Windows, MAC und Linux! Unterstützt sichere End-to-End Verschlüsselung auch bei Gruppenchats!

Mittlerweile sind alle meine Kontakte, mit denen ich laufend in Kontakt bin, auf den kostenlosen Open Source Messenger, Riot.IM umgestiegen und einige betreiben auch einen eigenen Matrix/Synapse Server. Dadurch können wir wieder sicher, end-to-end verschlüsselt, kommunizieren und wissen, dass niemand mitliest und unsere Gespräche auswertet. Die Möglichkeiten von Riot.im sind wirklich grenzenlos und bis jetzt gab es, auch bei gleichzeitiger Verwunden von mehreren Endgeräten (Linux, IOS, Android), keine Probleme. Dieses Multi-Device Syncing ist wirklich mehr als genial. Riot.IM ist perfekt um Kontakte zu pflegen, bzw. im Firmenbereich Kunden und Interessenten an sich zu binden. Mit einem Account die Kommunikation (Einzel- und Gruppenchat, Voice und Video), sogar auf mehreren Geräten gleichzeitig zu managen ist eine neue Art der Kommunikation.

WICHTIG: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der End-to-End-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

INTRO VIDEO auf Youtube

KURZANLEITUNG:

  • Registrieren Sei Ihren kostenlosen Account unter Riot.IM
  • Installieren Sie die App für IOS oder Android, bzw. die Desktop Version für Windows, MAC, oder Linux (mehrere Clients können gleichzeitig betrieben werden!)
  • melden Sie sich mit Ihrem Benutzernamen und dem Passwort an
  • Wichtig: Ein Passwort-Reset ist ohne E-Mail Adresse nicht möglich. Das Passwort darf nicht vergessen werden!
  • Meine Riot Adresse: @karl:matrix.ctseuro.com

Endanwender können die kostenlose Open-Source-Software über die Webseite Riot.IM herunterladen.

Für Leser: Kostenloser Open Source Messenger

Dezentral, optional End-to-End verschlüsselt, sicher kommunizieren ohne Profil- und Kommunikationsdaten an die großen Datensammler weiterzugeben!

Folgend auf den eher technischen Artikel zu Matrix/Synapse + Riot:

/matrixsynapse-riot-im-die-neue-form-der-kommunikation-fuer-endanwender-und-unternehmen/

folgt nun eine Kurzanleitung zum Schnellstart für Benutzer. Unternehmen können zur Hilfestellung beim Setup ihrer Matrix/Synapse Server gerne die CTS GMBH unter support@cts-solutions.at kontaktieren oder die Installation laut Beschreibung vornehmen. Setup Link für Unternehmensserver: github.com/matrix-org/synapse

Kurzanleitung für Endanwender

Wer nur einmal hineinschnuppern möchte, kann sich auch über den Browser unter riot.im/app/ anmelden. Ich rate von der Verwendung des Browsers, sobald verschlüsselte Verbindungen verwendet werden, ab.

Nach der Installation können Sie sich mit „Benutzerkonto erstellen“  einen kostenlosen Account registrieren.

Sollten Sie sich nicht auf einem speziellen Server eines Serverbetreibers registrieren, erhalten Sie eine Adresse auf matrix.org. Sie müssen keine E-Mail-Adresse oder Telefonnummer eingeben und können nur durch Eingabe von Nutzername und Passwort sofort loslegen.  Beachten Sie aber, dass damit keine „Passwort verloren“ Aktion möglich ist und wenn Sie Ihr Passwort verlieren ist auch Ihr Account dauerhaft verloren.

Wie bei E-Mail-Adressen baut sich eine Matrix Adresse wie folgt auf:

Benutzernamen für Direktchat: @Benutzername:Server.Domain

Sie erhalten zum Beispiel @IhrBenutzername:matrix.org, wenn Sie sich auf dem matrix.org Server registriert haben. Wenn Sie mich ansprechen wollen, können Sie dies unter @karl:matrix.ctseuro.com tun. Ihre Nachricht wird dann zu meinem Server (matrix.ctseuro.com) weitergeleitet. Sobald die End-to-End Verschlüsselung aktiviert wird, ist es sogar dem Server Admin unmöglich, die Unterhaltung mitzulesen.

Räume funktionieren, da auch diese als Raum (mit eben nur 2 Personen) geführt werden, wie 1:1 Chats. Adressen von Räumen werden mit einer # adressiert. So könnte zum Beispiel ein Raum mit dem Befehl /join #raumname:servername betreten werden. In einem Raum befinden sich im Normalfall mehrere Personen.

In der Linken Leiste sehen Sie Ihre Direktchats, Ihre besuchten Räume und verschiedene Buttons um 1:1 Gespräche zu starten. Hier können Sie auch Räume erstellen oder betreten. Einladungen werden mit einer Meldung angezeigt.

Das Gesamtsystem ist sehr intuitiv und eigentlich selbst erklärend. Riot verfügt auch über die Möglichkeit von Voice und Video Calls.  Die Verwendung dieser Dienste sollten Sie aber mit dem Gesprächspartner vorher abklären.

Perfekt ist, dass keiner der großen Datensammler Zugriff auf Ihr Profil oder Ihre Kommunikation hat. Nur die in einem Gespräch involvierten Server routen den Traffic. Wobei, End-to-End Verschlüsselung vorausgesetzt, auch die Admins der involvierten Server keine Möglichkeit haben das Gespräch mitzulesen.  Privatsphäre wie sie sein soll.

Sie können mit mehreren Geräten gleichzeitig Online sein und alle Geräte sind in Real-Time synchronisiert. Die Benachrichtigungen können pro Gerät eingestellt werden. Für große Räume bietet sich die Einstellung „nur bei Erwähnung“ an. Dann erhalten Sie nur eine Benachrichtigung, wenn jemand im Chat Ihren Namen erwähnt.

Verschlüsselung aktivieren

Jedes Gespräch (1:1 Raum), bzw. jeder Gruppen-Chat Raum hat eine Möglichkeit, Einstellungen für den Raum zu setzen (Zahnrad neben dem Raumnamen anklicken). Dort kann man die Verschlüsselung aktivieren. Aufgrund der extrem vielen Features des Systems ist die Ersteinrichtung der Verschlüsselung mit einigen wenigen Aktivitäten verbunden. Dies sollte Sie aber nicht abschrecken und ich empfehle soweit als möglich verschlüsselt zu kommunizieren.

Danach ändert sich die Nachrichten Eingabebox von

  • Nachricht senden (unverschlüsselt)

auf

  • Nachricht senden (verschlüsselt).

Wichtig ist, dass Sie die Verschlüsselungskey(s) Ihrer Gesprächspartner verifizieren müssen. Nur dann ist eine einwandfreie Kommunikation gewährleistet.

Nach Aktivierung der Verschlüsselung schreiben Sie am besten eine Testnachricht. Danach werden Sie aufgefordert die Schlüssel zu bestätigen.

Wichtig: Bestätigen Sie alle Schlüssel Ihrer Partner. Ein Benutzer kann mehrere Schlüssel benutzen. Bei mir sind es z.B. 5 Schlüssel für verschiedene Geräte. Nur wenn Sie alle Schlüssel richtig bestätigt haben werden die Nachrichten aller involvierten Systeme mit einem grünen, geschlossenen, Schloss angezeigt. Sollte ein gelbes Warndreieck erscheinen müssen Sie, am besten durch Klick auf das Warndreieck, fehlende Schlüssel noch bestätigen. Bei Verwendung mehrere Geräte müssen Sie diesen Vorgang auf jedem Gerät wiederholen.

Sollten Sie sich abmelden – ist bei Apps und Desktop nicht notwendig – müssen Sie vorher den Key exportieren und nach dem Login wieder importieren. Andernfalls können ältere Nachrichten nicht dechiffriert werden.

Hilfe Videos am Riot Server:

about.riot.im/need-help/

Es ist schön zu sehen, dass die eigene Privatsphäre von vielen Menschen mittlerweile wieder ernst genommen wird. Die Zahl derer steigt täglich. Der Schwarm der Lemminge wird, wie bei einem Börsencrash, irgendwann panikartig auf dezentrale Systeme, ohne Möglichkeit des Zugriffes von Dritten, umschwenken. Bis dahin wird noch mit verschlossenen Augen kollektiv über die Klippe gesprungen.

Gehören Sie besser nicht dazu!

1:1 Chat

INTRO VIDEO auf Youtube

Create a room for group chat

INTRO VIDEO auf Youtube

Riot.IM Messenger: Kurzanleitung für Benutzer (Updated 01/2018)

Eine neue Version des Dokumentes finden Sie hier:

2018-03-12-riot-im-messenger-kurzanleitung-fuer-benutze-updated

OUTDATED VERSION!:

  • UPDATE / HINWEIS 2019-05-16: Aufgrund der Überlastung des größten öffentlichen Servers matrix.org empfehle ich einen anderen öffentlichen Server aus dieser Liste zu wählen: https://www.hello-matrix.net/public_servers.php . Ich empfehle Freunden den Server: https://www.privacytools.io/ . Der Homeserver zur Registrierung findet sich hier: https://riot.privacytools.io/#/welcome . Für die Riot Windows, Linux, MAC,, Android oder IOS App, verfügbar von https://riot.im sind folgende Einstellungen zu verwenden: Heimserver: https://chat.privacytools.io

  • UPDATE 2018-01-06: Registrieren Sie, sofern Sie keinen eigenen Server betreiben, Ihren kostenlosen Account unter https://Riot.IM. Zur Registrierung ist nur Benutzername und Passwort notwendig. Es wird keine E-Mail abgefragt. Danach sollte unbedingt die Desktop Version, bzw. die App installiert werden um alle Vorteile bei der E2E-Verschlüsselung nutzen zu können. Die Web-Version ist nur zum ersten Schnuppern gedacht.

Kostenloser Open Source Messenger

Dezentral, optional End-to-End verschlüsselt, sicher kommunizieren ohne Profil- und Kommunikationsdaten an die großen Datensammler weiterzugeben!

Folgend auf den eher technischen Artikel zu Matrix/Synapse + Riot:

/matrixsynapse-riot-im-die-neue-form-der-kommunikation-fuer-endanwender-und-unternehmen/

folgt nun eine Kurzanleitung zum Schnellstart für Benutzer. Unternehmen können zur Hilfestellung beim Setup ihrer Matrix/Synapse Server gerne die CTS GMBH unter support@cts-solutions.at kontaktieren oder die Installation laut Beschreibung vornehmen. Setup Link für Unternehmensserver: https://github.com/matrix-org/synapse

Kurzanleitung für Endanwender

Endanwender können die kostenlose Open-Source-Software über die Webseite https://riot.im herunterladen.

Für Apples IOS ist die App im App Store verfügbar:

https://itunes.apple.com/us/app/vector.im/id1083446067

Für Android Geräte findet sich die App im Google Play oder alternativ bei F-Droid:

Google Play:

https://play.google.com/store/apps/details?id=im.vector.alpha

F-Droid:

https://f-droid.org/repository/browse/?fdid=im.vector.alpha

Desktop Anwendungen für Windows, MAC, oder Linux können direkt bei Riot.im geladen werden:

https://riot.im/desktop.html

Wer nur einmal hineinschnuppern möchte, kann sich auch über den Browser unter https://riot.im/app/ anmelden. Ich rate von der Verwendung des Browsers, sobald verschlüsselte Verbindungen verwendet werden, ab.

Nach der Installation können Sie sich mit „Benutzerkonto erstellen“  einen kostenlosen Account registrieren.

Sollten Sie sich nicht auf einem speziellen Server eines Serverbetreibers registrieren, erhalten Sie eine Adresse auf matrix.org. Sie müssen keine E-Mail-Adresse oder Telefonnummer eingeben und können nur durch Eingabe von Nutzername und Passwort sofort loslegen.  Beachten Sie aber, dass damit keine „Passwort verloren“ Aktion möglich ist und wenn Sie Ihr Passwort verlieren ist auch Ihr Account dauerhaft verloren.

Wie bei E-Mail-Adressen baut sich eine Matrix Adresse wie folgt auf:

Benutzernamen für Direktchat:

@Benutzername:Server.Domain

Sie erhalten zum Beispiel @IhrBenutzername:matrix.org, wenn Sie sich auf dem matrix.org Server registriert haben. Wenn Sie mich ansprechen wollen, können Sie dies unter @karl:matrix.ctseuro.com tun.

Ihre Nachricht wird dann zu meinem Server (matrix.ctseuro.com) weitergeleitet. Sobald die End-to-End Verschlüsselung aktiviert wird, ist es sogar dem Server Admin unmöglich, die Unterhaltung mitzulesen.

Räume funktionieren, da auch diese als Raum (mit eben nur 2 Personen) geführt werden, wie 1:1 Chats. Adressen von Räumen werden mit einer # adressiert. So könnte zum Beispiel ein Raum mit dem Befehl

/join #raumname:servername

betreten werden. In einem Raum befinden sich im Normalfall mehrere Personen.

In der Linken Leiste sehen Sie Ihre Direktchats, Ihre besuchten Räume und verschiedene Buttons um 1:1 Gespräche zu starten. Hier können Sie auch Räume erstellen oder betreten. Einladungen werden mit einer Meldung angezeigt.

Das Gesamtsystem ist sehr intuitiv und eigentlich selbst erklärend. Riot verfügt auch über die Möglichkeit von Voice und Video Calls.  Die Verwendung dieser Dienste sollten Sie aber mit dem Gesprächspartner vorher abklären.

Perfekt ist, dass keiner der großen Datensammler Zugriff auf Ihr Profil oder Ihre Kommunikation hat. Nur die in einem Gespräch involvierten Server routen den Traffic. Wobei, End-to-End Verschlüsselung vorausgesetzt, auch die Admins der involvierten Server keine Möglichkeit haben das Gespräch mitzulesen.  Privatsphäre wie sie sein soll.

Sie können mit mehreren Geräten gleichzeitig Online sein und alle Geräte sind in Real-Time synchronisiert. Die Benachrichtigungen können pro Gerät eingestellt werden. Für große Räume bietet sich die Einstellung „nur bei Erwähnung“ an. Dann erhalten Sie nur eine Benachrichtigung, wenn jemand im Chat Ihren Namen erwähnt.

Verschlüsselung aktivieren

Jedes Gespräch (1:1 Raum), bzw. jeder Gruppen-Chat Raum hat eine Möglichkeit, Einstellungen für den Raum zu setzen (Zahnrad neben dem Raumnamen anklicken). Dort kann man die Verschlüsselung aktivieren. Aufgrund der extrem vielen Features des Systems ist die Ersteinrichtung der Verschlüsselung mit einigen wenigen Aktivitäten verbunden. Dies sollte Sie aber nicht abschrecken und ich empfehle soweit als möglich verschlüsselt zu kommunizieren.

Danach ändert sich die Nachrichten Eingabebox von

Nachricht senden (unverschlüsselt)

auf

Nachricht senden (verschlüsselt).

Wichtig ist, dass Sie die Verschlüsselungskey(s) Ihrer Gesprächspartner verifizieren müssen. Nur dann ist eine einwandfreie Kommunikation gewährleistet.

Nach Aktivierung der Verschlüsselung schreiben Sie am besten eine Testnachricht. Danach werden Sie aufgefordert die Schlüssel zu bestätigen.

Wichtig: Bestätigen Sie alle Schlüssel Ihrer Partner. Ein Benutzer kann mehrere Schlüssel benutzen. Bei mir sind es z.B. 5 Schlüssel für verschiedene Geräte. Nur wenn Sie alle Schlüssel richtig bestätigt haben werden die Nachrichten aller involvierten Systeme mit einem grünen, geschlossenen, Schloss angezeigt.

Sollte ein gelbes Warndreieck erscheinen müssen Sie, am besten durch Klick auf das Warndreieck, fehlende Schlüssel noch bestätigen. Bei Verwendung mehrere Geräte müssen Sie diesen Vorgang auf jedem Gerät wiederholen.

Sollten Sie sich abmelden – ist bei Apps und Desktop nicht notwendig – müssen Sie vorher den Key exportieren und nach dem Login wieder importieren. Andernfalls können ältere Nachrichten nicht dechiffriert werden.

Auf dem matrix.ctseuro.com Server geben Anwender im Raum

#hilfe:matrix.ctseuro.com

Hilfestellung. Englischsprachige Hilfe unter

#riot:matrix.org

Support Raum für Serverbetreiber (Englisch):

#matrix:matrix.org

Hilfe Videos am Riot Server:

https://about.riot.im/need-help/

Es ist schön zu sehen, dass die eigene Privatsphäre von vielen Menschen mittlerweile wieder ernst genommen wird. Die Zahl derer steigt täglich. Der Schwarm der Lemminge wird, wie bei einem Börsencrash, irgendwann panikartig auf dezentrale Systeme, ohne Möglichkeit des Zugriffes von Dritten, umschwenken. Bis dahin wird noch mit verschlossenen Augen kollektiv über die Klippe gesprungen.

Gehören Sie besser nicht dazu!