Die Sicherheitsfirma zscaler hat einen neuen Service herausgebracht, mit dem man Webseiten auf Malware, dubioses JavaScript und allgemeine Reputation hin scannen kann. Das Tool heißt Zulu und bietet eine umfassende Analyse einer Webseite an.
Dabei werden vor allem die folgenden Prüfungen durchgeführt:
Als Ergebnis bekommt man dann eine Übersicht und eine abschließende Bewertung von 0 bis 100.
Die Spam- und Phishing-Landschaft ist im Umbruch. Das zeigen die Analysen des eleven Research-Teams zur Spam-Entwicklung in 2011. Noch nie gab es so viele Schwankungen im Spam-Aufkommen wie im vergangenen Jahr. Für 2012 rechnen die eleven Researcher damit, dass Spam zunehmend in kurzen, massiven, häufigen Wellen versendet wird. Das erhöht die Überlastungsgefahr bei E-Mail-Servern. Außerdem sollten E-Mail-Empfänger auf der Hut sein: Spam- und Phishing-Mails sind längst nicht mehr auf den ersten Blick als solche erkennbar. Damit steigt das Risiko auch für erfahrene Internetnutzer, versehentlich Zugangsdaten zu Online-Banking, Kreditkarten etc. preiszugeben. Die Spam-Analyse zu 2011 und die Vorhersagen für 2012 im Einzelnen:
Spam-Volumen 2011: noch nie so viele Schwankungen
2011 beobachtete das eleven Research Team die größten Schwankungen in der Geschichte des Spam-Aufkommens seit 2003. Dabei kam es wiederholt zu massiven Einbrüchen des Spam-Aufkommens um deutlich über 50 Prozent – zuletzt im Dezember 2011. Gegenüber dem Vormonat sank das Spam-Volumen um 70,4 Prozent. Darin lag auch der Hauptgrund für den deutlichen Abfall des Spam-Aufkommens auf nur noch 19 Prozent des Wertes vom Dezember 2010. Einen Grund zur Entwarnung sehen die eleven Experten jedoch nicht: So kam es bereits zum Jahreswechsel 2010/2011 und in Folge der Abschaltung des Rustock-Botnets im März 2011 zu Spam-Einbrüchen von bis zu 80 Prozent. In der Folge stieg jedoch das Spam-Volumen jedes Mal wieder deutlich an. So lag das Spam-Aufkommen im November 2011 wieder bei 78 Prozent des Wertes vor der Rustock-Abschaltung.
Deutliche Verschiebungen gab es auch bei den Herkunftsländern und Themen der Spam-E-Mails. Hauptgrund war die Abschaltung des weltgrößten Botnets Rustock am 16. März 2011. Vorher kam ein großer Teil des weltweiten Spam-Aufkommens aus westlichen Industrieländern, die USA belegte Monat für Monat die Spitzenposition. Dominierendes Spam-Thema war Pharma-Werbung, die bis zu 70 Prozent des gesamten Spam-Aufkommens ausmachte. Nach Rustock verschwanden Länder wie die USA, Großbritannien und Deutschland aus den Top-10-Listen. Im November belegte die USA nur noch Platz 14. Neue Spitzenreiter beim Spam-Versand waren Schwellenländer, vor allem aus Asien, angeführt von Indien. Ähnliche Veränderungen gab es bei den Spam-Themen: Nach der Rustock-Abschaltung übernahm Casino-Spam die Spitzenposition mit Anteilen von über 50 Prozent am Gesamtaufkommen. Casino-Werbung war auch der Hauptverantwortliche für das deutliche Spam-Wachstum ab August 2011. Ebenso wurde der Spam-Einbruch im Dezember durch das Ausbleiben der Casino-Wellen verursacht.
Ein weiterer beunruhigender Trend in diesem Jahr: eine starke Zunahme lokalisierten Spams, bei dem die Spammer gezielt deutsche E-Mail-Nutzer ansprechen. Zum einen wird nach so genannten „Money Mules“ gesucht, also Personen, die ihr Konto für Geldwäsche zur Verfügung stellen, zum anderen sind verstärkt Online-Betrüger (Phisher und Scammer) unterwegs, die auf diese Art an vertrauliche Daten kommen wollen. Bisher erkannte man diese Art E-Mails häufig an den schlechten Übersetzungen. Die Online-Betrüger haben jedoch dazugelernt und wissen, dass ein fehlerfreier Text für mehr Vertrauen sorgt.
Die drei wichtigsten Spam-Trends 2011
Spam-Trends 2012: zunehmend E-Mail-Zugangsdaten im Visier
Quelle: eleven Spam-Report
Ein kurzer aber sehr guter Linktipp wie ich finde: Web Equitation, damit könnt ihr eine beliebige Formel malen, diese wird automatisch erkannt und dann als LaTeX-Code bzw. MathML-Code ausgegeben. Praktische Sache, vor allem wenn man sich die LaTeX-Syntax nicht merken möchte :).
Oftmals benötigt man als Java-Entwickler eine kleine, feine Cache-Klasse, um verschiedene Objekte zwischenzuspeichern und die Datenbank zu schonen. Oftmals wird dann selber mit Arrays, Maps und Listen rumgefuchtelt. Viele kennen nämlich gar nicht die praktische Klasse java.util.LinkedHashMap.
Dabei ist es mit Hilfe dieser Klasse extrem einfach, einen sogenannten LRU-Cache aufzubauen, also einen Least-Recently-Used-Cache. Sprich einen Cache, der die n letzten Objekte speichert. Man gibt also eine feste Cachegröße vor, zum Beispiel 100 und der Cache sorgt dann selber dafür, das Objekte mit einer hohen Zugriffsanzahl weiterhin gecached bleiben und Objekte mit wenigen Zugriffen aus dem Cache entfernt werden. Altes fliegt also nach hinten raus, in dem Fall wenn es mehr als 100 Elemente sind.
Christian d’Heureuse hat dazu jetzt auf Basis der genannten Klasse einen Cache geschrieben, den ich selber leicht abgewandelt so schon benutzt habe. Auf seiner Seite source-code.biz findet sich der entsprechende Source-Code dazu. BTW: Der Trick daraus einen LRU Cache zu machen, ist das Überschreiben der Methode removeEldestEntry der Klasse LinkedHashMap. Damit hat man einen relativ performanten Cache, ohne selber Iterationen einbauen zu müssen, um ggf. veraltete Elemente zu erkennen.
/** * An LRU cache, based on <code>LinkedHashMap</code>. * * <p> * This cache has a fixed maximum number of elements (<code>cacheSize</code>). * If the cache is full and another entry is added, the LRU (least recently used) entry is dropped. * * <p> * This class is thread-safe. All methods of this class are synchronized. * * <p> * Author: Christian d'Heureuse, Inventec Informatik AG, Zurich, Switzerland<br> * Multi-licensed: EPL / LGPL / GPL / AL / BSD. */ public class LRUCache<K,V> { private static final float hashTableLoadFactor = 0.75f; private LinkedHashMap<K,V> map; private int cacheSize; /** * Creates a new LRU cache. * @param cacheSize the maximum number of entries that will be kept in this cache. */ public LRUCache (int cacheSize) { this.cacheSize = cacheSize; int hashTableCapacity = (int)Math.ceil(cacheSize / hashTableLoadFactor) + 1; map = new LinkedHashMap<K,V>(hashTableCapacity, hashTableLoadFactor, true) { // (an anonymous inner class) private static final long serialVersionUID = 1; @Override protected boolean removeEldestEntry (Map.Entry<K,V> eldest) { return size() > LRUCache.this.cacheSize; }}; } /** * Retrieves an entry from the cache.<br> * The retrieved entry becomes the MRU (most recently used) entry. * @param key the key whose associated value is to be returned. * @return the value associated to this key, or null if no value with this key exists in the cache. */ public synchronized V get (K key) { return map.get(key); } /** * Adds an entry to this cache. * The new entry becomes the MRU (most recently used) entry. * If an entry with the specified key already exists in the cache, it is replaced by the new entry. * If the cache is full, the LRU (least recently used) entry is removed from the cache. * @param key the key with which the specified value is to be associated. * @param value a value to be associated with the specified key. */ public synchronized void put (K key, V value) { map.put (key, value); } /** * Clears the cache. */ public synchronized void clear() { map.clear(); } /** * Returns the number of used entries in the cache. * @return the number of entries currently in the cache. */ public synchronized int usedEntries() { return map.size(); } /** * Returns a <code>Collection</code> that contains a copy of all cache entries. * @return a <code>Collection</code> with a copy of the cache content. */ public synchronized Collection<Map.Entry<K,V>> getAll() { return new ArrayList<Map.Entry<K,V>>(map.entrySet()); } } // end class LRUCache
Benutzen könnt ihr die Klasse dann wie folgt:
import java.util.Map; public class UseCache { // Test routine for the LRUCache class. public static void main(String[] args) { LRUCache<String, String> c = new LRUCache<String, String>(3); c.put("1", "one"); // 1 c.put("2", "two"); // 2 1 c.put("3", "three"); // 3 2 1 c.put("4", "four"); // 4 3 2 if (c.get("2") == null) throw new Error(); // 2 4 3 c.put("5", "five"); // 5 2 4 c.put("4", "second four"); // 4 5 2 // Verify cache content. if (c.usedEntries() != 3) throw new Error(); if (!c.get("4").equals("second four")) throw new Error(); if (!c.get("5").equals("five")) throw new Error(); if (!c.get("2").equals("two")) throw new Error(); // List cache content. for (Map.Entry<String, String> e : c.getAll()) System.out.println(e.getKey() + " : " + e.getValue()); } }
Eine echt praktische Klasse die einem mit Java-Standard-Mitteln eine nette kleine Caching-Funktion bietet.
Ich habe mich mal durch die Jahresstatistiken gewühlt und für euch die 5 beliebtesten Artikel des Jahres 2011 herausgesucht. Dabei sind eigentlich die gleichen Artikel wie auch im letzten Jahr aufgetaucht. Ihr scheint euch immer nur für das gleiche zu interessieren ;). Dabei kann ich auch durchaus mit guten neuen Artikel punkten, zum Beispiel lege ich euch das SOPA Video von Dan Bull ans Herz. Ebenso sind Aktenvernichter ein gutes Weihnachtsgeschenk wie ich finde, warum, das lest ihr in dem entsprechenden Artikel! Aber jetzt zur versprochenen Liste, die folgenden fünf Punkte sind absteigend nach den Besucherzahlen im Jahr 2011 sortiert. Viel Spaß beim stöbern und nicht vergessen sich auch mal durchs Archiv aus dem Jahr 2011 zu klicken, das kann sich durchaus lohnen!
