diff --git a/OLD.megaschmarrn b/OLD.megaschmarrn
index 181cafe..8076dd5 100644
--- a/OLD.megaschmarrn
+++ b/OLD.megaschmarrn
Binary files differ
diff --git a/OLD.schmarrn b/OLD.schmarrn
index 1a45984..84bd6d6 100644
--- a/OLD.schmarrn
+++ b/OLD.schmarrn
@@ -407670,3 +407670,40 @@
 
 
 
+Re^3: Meldung ueber das Ende von schnell (Croft,  7. Sep 2017, 08:48:13):
+~#! rn=Anatol rt=1504766396 rg=gilden.abenteurer
+~#! tid=1504545314
+SSL und Java sind ein Abenteuer?
+
+Croft
+
+-----------------------------------------------------------------------------
+
+
+
+Re: Re: Meldung ueber das Ende von schnell (Anatol,  7. Sep 2017, 10:19:14):
+~#! on=Anatol ot=1504766396 og=gilden.abenteurer
+~#! rn=Zesstra rt=1504637761 rg=gilden.abenteurer
+~#! tid=1504545314
+SSL ist scheisse. Zumindest wenn man mit java keystores herummachen 
+muss und davon eigentlich keine Ahnung hat.
+
+(murmelt was von "unable to find valid certification path")
+
+
+-----------------------------------------------------------------------------
+
+
+
+Re^3: Meldung ueber das Ende von schnell (Zesstra,  7. Sep 2017, 18:25:27):
+~#! rn=Anatol rt=1504772354 rg=schmarrn
+~#! tid=1504545314
+Ohja, diese Java keystores sind in der Tat sehr unhandlich. Bzw. eigentlich
+das keytool dazu...
+
+Zesstra
+
+-----------------------------------------------------------------------------
+
+
+
