Ein Grund hierfür mag der Dschungel an Richtlinien und Gesetze sein, welche eingehalten werden müssen.
Firmen wandeln aber hier auf dünnem Eis, sofern das Unternehmen nicht alle relevanten Dokumente liefert,
kann das Finanzamt die Unternehmenswerte einer Zwangsschätzung unterziehen, welche meist höher ausfällt.

Ein weitere Grund für mangelnde Archivierung kann der hohe Aufwand sein, ein entsprechendes System bereit
zustellen. Das System muss

* alle E-Mails für 6-10 Jahre aufbewahren (§257 IV HGB, §147 III AO)

* sicherstellen, dass die Daten nicht modifiziert werden können

* sicherstellen, dass die Daten maschinell auswertbar sind

* sicherstellen, dass alle eingehende und ausgehende E-Mails enthalten sind

Folgende Paragrafen sind für die E-Mail Archivierung wichtig…

Handelsgesetzbuch (HGB)

* §238 HGB: behandelt die Verpflichtung zur Buchführung.

* §257 Abs.1 HGB: behandelt die steuerrelevante Daten (wichtig, weil zu ihnen E-Mails zählen können).

Abgabenordnung (AO)

* §140 AO: behandelt die Buchführungspflicht nach anderen Gesetzen, die für die Besteuerung maßgeblich sind.

* §141 AO: behandelt ergänzende Buchführungspflichten für Gewerbebetriebe und Land- und Forstwirtschaft.

* §147 AO: behandelt alle nach HGB aufzubewahrenden Unterlagen sowie alle sonstigen Unterlagen, die für die Besteuerung von Bedeutung sind (hier insbesondere E-Mails).

* §147 I Nr. 5 AO: ist für die E-Mail-Archivierung von besonderer Bedeutung, weil es hier um Unterlagen geht, die für eine Sachverhaltsklärung hinsichtlich der Besteuerung wichtig sind.

Die Frage, welches ein steuerlich relevantes Dokument ist oder nicht, entscheidet im Zweifel das
Finanzamt, und es ist möglich, dass alle E-Mails als steuerlich relevante Dokumente klassifiziert werden
können. In der Konsequenz bedeutet dies für das Unternehmen die Verpflichtung, alle eingehenden und
ausgehenden E-Mails automatisch zu speichern. Auch private, von Mitarbeitern versendete oder
empfangene E-Mails würden dann in einem Archivierungssystem abgelegt und einem Betriebsprüfer
zugänglich sein. Eingriffe seitens der Mitarbeiter, z.B. Löschungen oder Veränderungen, in dieses
System müssten konsequenterweise unterbunden werden.

Eine automatische Abspeicherung und der Zugang zu privaten E-Mails von Mitarbeitern könnte das
Postgeheimnis, welches als Grundrecht im Artikel 10 des Grundgesetzes verankert wurde, verletzen. E-
Mails gehören per Definition zu der Kategorie „Brief“ und unterliegen diesem Grundrecht. Daher kann
eine automatisierte E-Mail-Sicherungsmaßnahme in einem Unternehmen nur durch eine vertragliche
Vereinbarung mit den Mitarbeitern oder mit der Zustimmung eines vertretungsberechtigten Betriebsrates
erlaubt werden. Eine andere Möglichkeit ist die Durchsetzung eines allgemeinen Verbots privater E-
Mail-Kommunikation von Seiten der Geschäftsleitung.

Wichtige Merksätze für die Archivierung von E-Mails

* Geschäftliche E-Mails sind Handelsbriefe

* Orignär digital erzeugt Dokumente sind digital zu archivieren (GoBS), wobei die Technologie der
Archivierung bewusst nicht festgeschrieben wird.

* Hilfsmittel zur Lesbarmachung oder Reproduktion der Daten müssen auf eigene Kosten zu
Verfügung gestellt werden. Dem Prüfer muss der geeignete Zugang zu den Daten zur Verfügung
gestellt werden – verschärft in den GdPDU

* Eine Verfahrensdokumentation muss vorliegen. In ihr findet sich beispielsweise eine
Dokumentation der Organisation und der Abläufe, eine Definition der Verantwortlichkeiten,
Nachvollziehbarkeit durch Aufzeichnungen und Protokolle, Absicherung der Vorgänge bezüglich
der Vertraulichkeit, Verfügbarkeit, Integrität und Authentizität.

* Auf keinen Fall dürfen die private und die geschäftliche E-Mail Nutzung vermischt werden.
Betriebsvereinbarungen müssen existieren, so dass Dritte auf keinen Fall Rechte an den
archivierten Daten erlangen können.

Nur der Betrieb eines revisionssicheren Archivierungssystems garantiert keinesfalls die so genannten
revisionssichere Archivierung. Die gesamte Prozesskette von der Erstellung oder dem Erhalt eines
Dokumentes bis hin zur Archivierung auf einem geeignetem System muss berücksichtig werden. Hierfür
muss eine Verfahrensdokumentation erstellt werden, und der Betrieb muss nachweisen können, dass er
in der Lage ist, diese umzusetzen.

GDPdU

Nach § 147 Abs. 6 AO ist der Finanzbehörde das Recht eingeräumt, die mit Hilfe eines
Datenverarbeitungssystems erstellte Buchführung des Steuerpflichtigen durch Datenzugriff zu prüfen.
Diese neue Prüfungsmethode tritt neben die Möglichkeit der herkömmlichen Prüfung. Das Recht auf
Datenzugriff steht der Finanzbehörde nur im Rahmen steuerlicher Außenprüfungen zu.

Das Recht auf Datenzugriff beschränkt sich ausschließlich auf Daten, die für die Besteuerung von
Bedeutung sind. Hierzu können auch E-Mails zählen, da in zunehmenden Maße der Geschäftsverkehr
papierlos abgewickelt wird. Bei der Ausübung des Rechts auf Datenzugriff stehen der Finanzbehörde
nach dem Gesetz drei Möglichkeiten zur Verfügung. Die Entscheidung, von welcher Möglichkeit des
Datenzugriffs die Finanzbehörde Gebrauch macht, steht in ihrem pflichtgemäßen Ermessen; falls
erforderlich, kann sie auch mehrere Möglichkeiten in Anspruch nehmen:

* Sie hat das Recht, selbst unmittelbar auf das Datenverarbeitungssystem dergestalt zuzugreifen,
dass sie in Form des Nur-Lesezugriffs Einsicht in die gespeicherten Daten nimmt und die vom
Steuerpflichtigen oder von einem beauftragten Dritten eingesetzte Hard- und Software zur
Prüfung der gespeicherten Daten einschließlich der Stammdaten und Verknüpfungen (Daten)
nutzt (unmittelbarer Datenzugriff). Dabei darf sie nur mit Hilfe dieser Hard- und Software auf die
elektronisch gespeicherten Daten zugreifen. Dies schließt eine Fernabfrage (Online-Zugriff) auf
das Datenverarbeitungssystem des Steuerpflichtigen durch die Finanzbehörde aus. Der Nur-
Lesezugriff umfasst das Lesen, Filtern und Sortieren der Daten gegebenenfalls unter Nutzung
der im Datenverarbeitungssystem vorhandenen Auswertungsmöglichkeiten.

* Sie kann vom Steuerpflichtigen auch verlangen, dass er an ihrer Stelle die Daten nach ihren
Vorgaben maschinell auswertet oder von einem beauftragten Dritten maschinell auswerten lässt,
um den Nur-Lesezugriff durchführen zu können (mittelbarer Datenzugriff). Es kann nur eine
maschinelle Auswertung unter Verwendung der im Datenverarbeitungssystem des
Steuerpflichtigen oder des beauftragten Dritten vorhandenen Auswertungsmöglichkeiten verlangt
werden.

* Sie kann ferner verlangen, dass ihr die gespeicherten Unterlagen auf einem maschinell
verwertbaren Datenträger zur Auswertung überlassen werden (Datenträgerüberlassung). Der zur
Auswertung überlassene Datenträger ist spätestens nach Bestandskraft der aufgrund der
Außenprüfung ergangenen Bescheide an den Steuerpflichtigen zurückzugeben oder zu löschen.

Der Steuerpflichtige hat die Finanzbehörde bei Ausübung ihres Rechts auf Datenzugriff zu unterstützen
(§ 200 Abs. 1 AO).

GoBS

Im Schreiben des Bundesministeriums der Finanzen an die obersten Finanzbehörden der Länder (vom
7. November 1995 – IV A 8 – S 0316 – 52/95- BStBl 1995 I S. 738), ist eindeutig beschrieben, welche
Grundsätze erfüllt werden müssen, wenn steuerrelevante Daten in einem DV-System gespeichert
werden.

Das verwendete DV-System muss sicherstellen können, dass die Risiken für die gesicherten
Datenbestände hinsichtlich der Unauffindbarkeit, Vernichtung und Diebstahl vermieden werden (Tz. 5 der GoBS).

Laut Tz. 8 der GoBS ist der Buchführungspflichtige, der aufzubewahrende Unterlagen nur in Form einer
Wiedergabe auf einem Datenträger vorlegen kann, dazu verpflichtet diejenigen Hilfsmittel zur Verfügung
zu stellen, die erforderlich sind, um die Unterlagen lesbar zu machen. §147 Abs. 2 AO schreibt zur
Archivierung von Unterlagen (Dokumenten) auf digitalen Datenträgern keine besondere Technik vor.
Diese Regelung ist bewusst so gefasst worden, dass sie keine bestimmte Technologie vorschreibt.

Bei originär digitalen Dokument muss hard- und softwaremäßig sichergestellt sein, dass während des
Übertragungsvorgangs auf das Speichermedium eine Bearbeitung nicht möglich ist. Das digitale
Dokument ist mit einem unveränderbaren Index zu versehen.

Daraus lässt sich zusammenfassen

* Damit das Postgeheimnis gewahrt bleibt, muss eine vertragliche Vereinbarung mit allen
Mitarbeiter, die Zustimmung eines vertretungsberechtigten Betriebsrates oder ein allgemeines
Verbot von privaten E-Mails seitens der Geschäftsführung vorliegen.

* Jede E-Mail muss archiviert werden

* Hilfsmittel zur Lesbarmachung bzw. Reproduktion müssen vorhanden sein

* Verfahrensdokumentation muss vorhanden sein

* Datensicherheit muss im Archivsystem gewährleistet sein.

* Eine Bearbeitung von digitalen Dokumenten darf während und nach der Übertragung in das
Archiv nicht möglich sein.

* Alle Daten müssen jederzeit reproduzierbar sein.

* Alle Daten müssen bis zu 10 Jahre vorgehalten werden.

GMime baut auf GLib auf und bietet eine Vielzahl an Funktionen um E-Mails
zu parsen bzw. einzelne Teile zu extrahieren. Will man z.B. den Body einer E-Mails auslesen, und feststellen, ob es sich hierbei um HTML Code handelt, dann könnte man es wie folgt machen:

#include <stdio.h>
#include <fcntl.h>
#include <glib.h>
#include <gmime/gmime.h>
 
int main (int argc, char const *argv[]) {
	gboolean is_html;
	GMimeMessage *message;
	GMimeParser *parser;
	GMimeStream *stream;
	char *body;
	int fd, i = 1;
 
	if (argc < 2)
		return 0;
 
	g_mime_init (0);
	if ((fd = open (argv[i], O_RDONLY)) == -1)
		return 0;
 
	stream = g_mime_stream_fs_new (fd);
	parser = g_mime_parser_new_with_stream (stream);
	g_object_unref (stream);
 
	message = g_mime_parser_construct_message (parser);
 
	body = g_mime_message_get_body (message, FALSE, &is_html);
	fprintf (stdout, "Testing get_body (looking for html...%s)\n\n%s\n\n",
		body && is_html ? "found" : "not found",
		body ? body : "No message body found");
 
	g_free (body);
 
	return 0;
}

Kompiliert wird das Programm mit

gcc -g -Wall `pkg-config --cflags gmime-2.0 glib-2.0` `pkg-config --libs gmime-2.0  glib-2.0` test.c -o test

Als erstes Argument muss der Pfad zur E-Mail angegeben werden.

Bei der Verwendung von GMime bin ich aber leider auch über einen Bug gestolpert. Will man die Absender
Adresse einer E-Mail auslesen, und diese ist z.B. angegeben mit J. Doe ,
dann vermurkst GMime die Adresse und liefert J.Doe. Das ist nur der Fall, wenn
die Adresse nicht in Anführungszeichen ist und einen Punkt enthält. Das Problem macht die
Funktion internet_address_parse_string(). Noch habe ich nicht die aktuelle Version
von GMime ausprobiert, ob es da auch noch auftritt.

Aber grundsätzlich kann man sagen, dass GMime eine hervorragende Library ist, um in C E-Mails
zu parsen. GMime wird z.B. auch von DBMail verwendet.

Der Hersteller Ironport biete solche Anti-Spam Appliances an. Es handelt sich hierbei um einen gewöhnlichen Server mit einem eigenem Betriebssystem (AsyncOS, welches auf Unix basiert). Die Appliance wird vor den normalen Mailserver geschalten, und ist MX für die Domains.

Neben Spam und Virenfilter bietet die Appliance noch ein wirkliches “Killerfeature”, nämlich Senderbase. Bei Senderbase handelt es sich um eine globale Datenbank von E-Mail “Versender”. In dieser Datenbank werden nicht nur IPs von Mailservern festgehalten, sondern auch IPs von Dial-Up Leitungen, die Spam verschicken. Das Prinzip von Senderbase ist recht einfach, jede IP, welche der Appliance eine E-Mail zustellen will wird erfasst und in der Datenbank nachgeschlagen. Ist die IP bereits in der Datenbank bekannt, so ist ein Wert dafür hinterlegt. Möglich sind Werte von -10 bis 10, wobei je positiver der Wert ist, desto “vertrauenswürdiger” ist der Sender. Wenn der Wert negativ ist, blockt die Appliance ab einem bestimmten Schwellwert die E-Mail auf SMTP Ebene ab.

Da jede Appliance weltweit in die gleiche Datenbank ihre “Erfahrungen” schreibt ist diese unglaublich aktuell. Senderbase block im Schnitt 75-80% aller E-Mails, und dabei handelt es sich wirklich um Spam! Erst wenn eine E-Mail an Senderbase in der Appliance vorbei gekommen ist, wird sie zum Spamfilter bzw. Virenfilter gereicht.

Man mag es kaum glauben, aber mit der Hilfe einer Ironport Appliance ist mein Spamaufkommen fast bei 0. Der Haken an der Sache ist, dass diese Geräte nicht gerade billig sind….;-)

Viel interessanter ist es einen Contentfilter per spawn einzubinden, was ein Program startet und es an einen Socket bindet, etwa so wie inetd. Die Kommunikation zwischen Postfix und dem Contentfilter läuft dann per STDIN bzw. STDOUT…

Der Contentfilter muss aber SMTP sprechen können, da Postfix per STDIN Smtp Kommandos schickt. Somit musste ich eine SMTPD Klasse in Python schreiben. Da es allgemein wenig Dokumentiert ist, wie so etwas programmiert werden kann, stelle ich hier die Basis-Klasse zur
Verfügung.

import sys, string, os
 
#---------------------------------------------------------------------------------------------
class SMTPServerEngine:
	ST_INIT = 0
	ST_HELO = 1
	ST_MAIL = 2
	ST_RCPT = 3
	ST_DATA = 4
	ST_QUIT = 5
 
	def __init__(self):
		self.state = SMTPServerEngine.ST_INIT
 
	def chug(self):
		while 1:
			data = ''
			completeLine = 0
			while not completeLine:
				lump = os.read(sys.stdin.fileno(), 1024)
				if len(lump):
					data += lump
					if (len(data) >= 2) and data[-2:] == '\r\n':
						completeLine = 1
						if self.state != SMTPServerEngine.ST_DATA:
							rsp, keep = self.doCommand(data)
						else:
							rsp = self.doData(data)
 
						if rsp == None:
							continue
 
						sys.stdout.write(rsp + "\r\n")
						sys.stdout.flush()
 
						if keep == 0:	
							sys.exit(0)
							return	
				else:
					return
 
		return
 
	def doCommand(self, data):
		"""Process a single SMTP Command"""
		cmd = data[0:4]
		cmd = string.upper(cmd)
		keep = 1
		if cmd == "HELO":
			self.state = SMTPServerEngine.ST_HELO
		elif cmd == "RSET":
			self.dataAccum = ""
			self.state = SMTPServerEngine.ST_INIT
		elif cmd == "NOOP":
			pass
		elif cmd == "QUIT":
			keep = 0
		elif cmd == "MAIL":
			if self.state != SMTPServerEngine.ST_HELO:
				return ("503 Bad command sequence", 1)
			self.state = SMTPServerEngine.ST_MAIL
		elif cmd == "RCPT":
			if (self.state != SMTPServerEngine.ST_MAIL) and (self.state != SMTPServerEngine.ST_RCPT):
				return ("503 Bad command sequence", 1)
			self.state = SMTPServerEngine.ST_RCPT
		elif cmd == "DATA":
			if self.state != SMTPServerEngine.ST_RCPT:
				return ("503 Bad command sequence", 1)
			self.state = SMTPServerEngine.ST_DATA
			self.dataAccum = ""
			return ("354 OK, Enter data, terminated with a \\r\\n.\\r\\n", 1)
		else:
			return ("505 Eh? WTF was that?", 1)
 
		return("250 OK", keep)
 
	def doData(self, data):
		"""
		Process SMTP Data. Accumulates client DATA until the
		terminator is found.
		"""
		self.dataAccum = self.dataAccum + data
		if len(self.dataAccum) > 4 and self.dataAccum[-5:] == '\r\n.\r\n':
			self.dataAccum = self.dataAccum[:-5]
			self.state = SMTPServerEngine.ST_HELO
 
			return "250 OK - message accepted"
		else:
			return None
 
 
#---------------------------------------------------------------------------------------------
if __name__ == '__main__':
	try:
		sys.stdout.write("220 localhost\r\n")
		sys.stdout.flush()
		while 1:
			engine = SMTPServerEngine()
			engine.chug()
	except SystemExit:
		pass

Vor kurzem brauchte ich ein Backend für Postfix, welches wenig Speicher verbraucht und ich per Webinterface einfach verwalten kann. Per Webinterface ein lookup table in Form eine Datei zu editieren und danach ein postmap aufzurufen, macht nicht wirklich spass. Aus diesem Grund kam für mich eigentlich nur SQLite in Frage.

Allerdings kann Postfix aktuell keine lookup tables in SQLite Datenbank, deswegen habe ich diese selber eingebaut. Der Patch für Postfix 2.3.3 ist unter http://www.treibsand.com/static/files/postfix-2.3.3_sqlite.patch verfügbar.

Sobald Postfix mit SQLite gebaut ist, sollte man eine Datenbank anlegen, die z.B. wie folgt aufgebaut ist:

CREATE TABLE mail_domains (id INT PRIMARY KEY, DOMAIN VARCHAR(250));  
CREATE TABLE mail_users (id INT PRIMARY KEY, email VARCHAR(128), maildir VARCHAR(250), DOMAIN INT(11));  
CREATE TABLE mail_virtual( id INT(11) PRIMARY KEY, email VARCHAR(50), destination text, DOMAIN INT(11));

In der Datei main.cf kann wie folgt auf die lookup table zugegriffen werden:

virtual_mailbox_maps = sqlite:/etc/postfix/sqlite-mailbox.cf
virtual_mailbox_domains = sqlite:/etc/postfix/sqlite-domains.cf
virtual_alias_maps = sqlite:/etc/postfix/sqlite-alias.cf

Jede Config Datei für SQLite muss 2 Anweisungen enthalten:

• dbpath – Pfad zur SQLite Datenbank
• query – SQL Query

Eine Config Datei kann z.B. wie folgt aussehen:

etc/postfix/aliases.db
query = SELECT forw_addr FROM mxaliases WHERE alias='%s' AND status='active'