Note 3 Smart Cover

Der Crowdmarktforscher hat das Testhandy zusammen mit dem zugehörigen „Smart Cover“ verschickt, doch was kann denn diese intelligente  Note-3-Hülle?

Obwohl ich persönlich ja nun kein Fan von diesen Covers bin, meine Freundin das Note 3 aber nach dem Testzeitraum möglichst unversehrt wieder zurückschicken soll, haben wir gleich nach dem Auspacken das „Smart Cover“ angebracht. Hier sind die Vor- und Nachteile und ein paar Bilder:

Vorteile:

– Das Handy sperrt und entsperrt sich automatisch beim auf- und zuklappen.

– Durch das Fenster in der Hülle kann man auf dem geteilten Bildschirm Uhrzeit, Datum und die Statusleiste sehen und mit einem Wisch nach rechts die Kamera und „Aktionsmemo“ aufrufen sowie Musik steuern. Schwergängige Bedienung durch die Hülle konnte ich nicht feststellen.

– Es ist möglich den Stift aus der Halterung zu ziehen, obwohl die Hülle angebracht ist.

– Das Telefon selbst bleibt länger hübsch, wovon man aber durch das weniger schöne Cover nichts hat ;).

Nachteile:

– Das Cover bleibt offen stehen, wenn man es eine Weile offen hatte.

– Über Nachrichten (SMS) wird man informiert und kann diese auch anwählen, sie dann aber nicht lesen (siehe Bild) 😀 .

– Die Lauter- und Leisertasten sind schwer zu erreichen, insbesondere wenn man gerade telefoniert, aber wer möchte schon selbst steuern, ob er ins Ohr geschrien bekommt?

Unboxing the Samsung Galaxy Gear

Ebenso wie beim Galaxy Note 3 ist die Verpackung sehr cool aufgemacht. Nach dem Öffnen kann man auch sofort das Display der Uhr bestaunen und erst mal seine Verwunderung über die heutige Technik sacken lassen ;).

Nachdem ich die Uhr dann das erste Mal richtig in der Hand hatte, war auch sofort die erste Enttäuschung da: Das Armband ist – wie ich bereits gelesen hatte – wirklich nicht angenehm. Wenn man diese Uhr jeden Tag im Alltag tragen möchte, ist das ziemlich steife Kunststoffarmband keine echte Freunde.

Als Nächstes wollten wir dann auch gleich mal das Ding in Aktion sehen und haben voller Erwartung eine Bluetooth-Verbindung aufgebaut, die sofort wieder abbrach. Okay, Anleitung lesen (mache ich normalerweise ja immer zuerst …) und feststellen: Die Paarung der Geräte funktioniert zunächst indem man die Ladeschale der Uhr mittels NFC am Handy anmeldet – Top Idee!. Das ging dann in der Tat auch gleich problemlos.

Auf dem Handy öffnete sich dann die Steuerungs-App für die Uhr und kann dann nach Belieben durchstöbert werden. Alle Funktionen einer völlig normalen Digital-Uhr sind vorhanden:  Uhrzeit und Datum, Stoppuhr, Timer, Wetterbericht, Kamera für Fotos und Videos, Schrittzähler, Kalender, Sprachmemo, Anruffunktionen, Spracheingabe (S-Voice), Schrittzähler, Mediencontroller fürs Handy, was halt so ne Armbanduhr heutzutage so kann… 😉

Während wir also so diese Funktionen entdecken, fragen wir uns, ob wir sie in einem Monat immer noch als überflüssig empfinden oder dieser Spielerei doch etwas abgewinnen können. Aus sportlicher Sicht jedenfalls hat uns gefallen, dass es eine Runtastic-App für die Uhr gibt, dessen Funktionsweise noch zu testen bleibt.

Mir persönlich hat gefallen, dass es die USB-Debugging-Option gibt und ich freue mich schon darauf zu sehen, was sich damit anstellen lässt.

Unboxing the Samsung Galaxy Note 3

Neues Hightechspielzeug auspacken ist ja immer wieder ein Erlebnis und vermittelt vor allem auch einen ersten Eindruck zum Gerät. Beim Samsung Galaxy Note 3 war dieser insgesamt sehr positiv. Über die nett gemachte aber relativ kleine Verpackung darf man sich erst mal nicht wundern, da das oben aufliegende Note 3 diese komplett ausfüllt. Darunter befinden sich dann neben den Kopfhörern, dem Ladekabel und einer merkwürdigen Tüte, das Päckchen mit Anleitung, „Key features“, Garantie- und sonstigen Hinweisen.

Das Handy selber wiegt ohne Akku kaum etwas, was aber dem soliden Eindruck nicht schadet, denn es ist eingefasst von einem chromfarbigen Rahmen, dessen tatsächliches Material aber ich bisher nicht ermitteln konnte. Die Rückenabdeckung in Lederoptik ist auch nicht so labil wie bei anderen Geräten und gut griffig. Positiv fällt vor allem das Display auf, da es fast das ganze Mobiltelefon ausfüllt und somit kaum Rahmen stehen lässt.

Aufgefallen ist mir auch sofort der USB-Stecker, der auf den ersten Blick merkwürdig erscheint, was an der Kompatibilität zum USB-2-Microstecker liegt. Ich habe ihn dann mit Hilfe von Google als USB3-Microstecker identifiziert, den ich bisher nicht kannte. Nach einem Blick auf das Ladegerät habe ich freudig festgestellt, dass dieses zwei Ampere liefert.

Auch erst mit Hilfe von Google bin ich auf die Idee gekommen, dass es sich bei der merkwürdigen Tüte um Ersatzspitzen für den S-Pen handelt. Dieser steckt unten gut erreichbar im Handy und ist gar nicht so überflüssig, wie ich zunächst angenommen hatte. Obwohl manche der möglichen Funktionen eher als Spielerei abzustempeln sind.

Nachdem ich das Note 3 bestückt und angeschaltet hatte waren erst mal direkt hintereinander zwei Softwareupdates fällig, was mir persönlich leicht auf die Nerven ging ;). Darüber hinaus ist das Android mit Samsungs Funktionen für meinen Geschmack leicht überfrachtet. Beim Einrichten soll man zunächst gefühlte 100 Seiten mit Nutzungsbedingungen und Datenschutzerklärungen und von Samsung, Google und Dropbox lesen – Pssssst: nicht verraten – aber wir haben, ohne zu lesen „weiter“ gedrückt ;). Danach drängen sich S-Note, S-Planner, S-Dies und S-Das geradezu auf und wollen unbedingt von einem entdeckt werden, was mir für den Anfang auch leicht auf den Wecker gefallen ist. Davon abgesehen ist der Umstieg vom S3 auf das Note 3 insgesamt nicht wirklich schwergefallen, da das meiste bekannt vorkommt.

Die Bilder sind leider etwas unscharf – von der guten Kamera war der Akku leer 😉

Access /data/app/-content from Android-application

Da meine App „App-Checker“ auf dem Handy andere Apps analysieren kann, sollte sie auch Zugriff auf die bereits auf dem Handy installierten Apps haben. Der Dateibrowser kann ohne root-Rechte allerdings nicht zu dem Ordner /data/app/ navigieren, da der „App-Checker“ nicht die Rechte besitzt den Inhalt zu lesen.

Dass es aber eine Möglichkeit gibt, die Apps aus dem Ordner zu lesen habe ich bei „Dex Dump“ und „Dexplorer“ gesehen und bin dem nachgegangen. Eigentlich ist die Lösung ganz einfach… 😉 :

private List<File> getDataApps(String dir) {
	ArrayList<File> list = new ArrayList<File>();
	Iterator<ApplicationInfo> apps = this.getPackageManager()
		.getInstalledApplications(PackageManager.GET_ACTIVITIES)
		.iterator();
	while (apps.hasNext()) {
		ApplicationInfo applicationInfo = (ApplicationInfo) apps.next();
		String path = applicationInfo.sourceDir;
		if (path.startsWith(dir)) {
			list.add(new File(path));
		}
	}
	return list;
}

Google Play Store-Kategorie von Apps finden

Stellt ein Entwickler seine Android-App im Google Play Store ein, muss er eine der – von Google vorgegebenen – Kategorien auswählen, in die die App gehört. Die Kategorie ist dabei nur dem Eintrag im Google Play Store zugeordnet und nicht teil der App selbst.

Möchte man nun zu einer App die zugehörige Kategorie finden, kann man dies anhand des Namens aber auch des Paketnamens suchen. Hier ein Beispiel: https://play.google.com/store/search?q=friendstatus%20de.izeland.friendstatus&c=apps.

Um die Kategorie zu finden, muss man von dieser Ergebnisseite zum Store-Eintrag der jeweiligen App weiterklicken. In der Beschreibung und dem zugehörigen Quelltext der Seite ist die Kategorie auf Englisch und Deutsch verfügbar.

Um alle Apps aus dem Datensatz meiner Masterarbeit zur kategorisieren habe ich ein simples Tool geschrieben, was den eben beschriebenen Vorgang automatisiert:

1. Aus den Apps (genauer einem Ordner mit den *.apk-Dateien) den Namen und den Paketnamen jeder App auslesen.

2. Im Google Play Store als Suchbegriff eingeben und den passenden Eintrag (in der  Regel ist dies der erste) der Suchergebnisse auswählen.

3. Auf der Beschreibungsseite der App die Kategorie extrahieren.

4. Die App auf dem eigenen System in den entsprechenden Ordner der Kategorie verschieben.

Dieses Tool wurde nur als Hilfsmittel programmiert und der Nutzer sollte sich den Quelltext vielleicht anschauen und auf seine Bedürfnisse anpassen. Für größere Datensätze kann eventuell der Heap nicht ausreichen – Fix: -Xmx1024M beim Ausführen der JavaVM angeben.

Bei mir ist es häufig vorgekommen, dass Apps, die beim ersten Durchlauf nicht zu kategorisieren waren, aufgrund eines anderen Fehlers nicht gefunden werden konnten und ein zweiter, dritter, etc. Durchlauf später zum Erfolg führte.

Bisher ist mir kein besserer Ansatz als dieser eingefallen und das Ergebnis ist leider nur teilweise befriedigend. Ich habe meine knapp 140.000 Apps sortieren können, wobei ca. die Hälfte nicht eingruppiert werden konnte (was vielleicht am Datensatz liegen mag, da nicht alle aus dem Play Store stammen). Vielleicht hilft es dennoch jemandem, der seine Apps anhand der Google Play Store Kategorien sortieren muss / möchte und er findet hiermit einen ersten Versuch.

Category Finder
Category Finder
Category Finder.zip
Version: 1.0
4.3 MiB
99 Downloads
Details

Detecting Code Reflection in Android Apps

While looking for more features to detect Android malware (what is basically part of my master thesis) I visited https://www.virustotal.com, which is by the way, a very nice service for analyzing suspicious files. After uploading an arbitrary Andorid-App I found under the section „Code-related observations“ four points. From those one was new: „code reflection“ and I asked myself how to detect this.

After a little bit of googling and reading the API I remembered that there is the method-invocation stuff form JavaSE. So I tried, to find the feature

Ljava/lang/reflect/Method;.invoke:

from the „dexdump -d“ dump and was lucky. This seems to be a very good feature to detect method invocation and is furthermore explainable because the class „Method“ in the Java-API has only the method „invoke(…)“ and no other ways to use method reflection. For detecting invocation of objects  one could also use the „newInstance(…)“-method in the class „Constructor“.

Additionally the use of „Method.invoke(…)“ is often together with the „getMethod“-method in the class „Class“ and therefore

Ljava/lang/Class;.getMethod:

is a good feature too.

 

App-Checker Desktop: A Java Static Feature Generator for APK-Files

Dieses Tool mit dem Namen „App-Checker Desktop“ ist in der Lage aus einer *.apk-Datei – also einer Android-App – die unten genannten Merkmale zu extrahieren.

Hintergrund: Dieses Tool, was kurzfristig den Namen „App-Checker Desktop“ erhalten hat, entstand während der Projektphase zu meiner Masterarbeit und ist die Desktop-Version der im Rahmen dieses Projektes entwickelten App (dem App-Checker).

Motivation: Damit der App-Checker mittels der Methode  „Drebin“ Vorhersagen über die Bös- oder Gutartigkeit dritter Apps – auf dem Android-Gerät – machen kann, muss er in der Lage sein aus einer *.apk-Datei die gleichen Merkmale zu extrahieren, wie es der Webservice Mobile Sandbox tut. Mit der hier vorgestellten Desktop-Version kann man nun unabhängig von Android-Gerät oder der Mobile Sandbox die folgenden Merkmale auf dem Rechner generieren:

Aus dem Android-Manifest:

1. Angeforderte Rechte der App
2. Angeforderte Hard- und Software
3. Intents
4. Activities
5. Services
6. ContentProvider
7. Broadcast Reciever

Aus dem dexdump -d – Auszug (Assambler der App):
1. Benutzte Rechte
2. Benutzte API-Aufrufe, die Rechte benötigen
3. Benutzte gefährliche API-Aufrufe (können selbst festgelegt werden)
4. Benutzte „Networks“
5. Gefundene URLs und IPs

Ist man nicht wie ich an Java als Programmiersprache gebunden empfehle ich für diesen Anwendungsfall androguard.

 

AppChecker Desktop
AppChecker Desktop
AppChecker Desktop.zip
Version: 1.0
3.8 MiB
113 Downloads
Details

Java LibSVMFormatReader

„svm-predict“ gibt für die one-class-SVM scheinbar nur die vorhergesagten Labels zurück, nicht aber die Vorhersagewerte für die Daten. Da das auch für die Java-libsvm-Varriante gilt – die ich in der Android-App zu meiner Masterarbeit benutze – hier eine Klasse, die aus einer Datei im libsvm-Format die Daten in der internen libsvm-Datenstruktur zurückgibt (d. h. als svm_node[][]). Damit kann man dann nach Belieben eine der „predict“-Funktionen von libsvm aufrufen und somit auch die Vorhersagewerte erhalten.

Nachdem die Klasse fertig war, habe ich doch noch in der Java-libsvm-Implementierung ähnliche Funktionalität entdeckt (svm_predict.java – predict(BufferedReader, DataOutputStream, svm_model, int) und musste feststellen, dass ich mir mehr Gedanken bei der Regex hätte machen sollen ;). Aber nun ist es fertig und dafür wenigstens alleinstehend ohne „predict“-Funktion drum herum – vielleicht hilft es ja noch jemandem.

import java.io.BufferedReader;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

import libsvmimpl.libsvm.svm_node;

public class LibSVMFormatReader {

	private BufferedReader libsvmFormatFileReader;
	private svm_node[][] x;
	private double[] y;

	//////////////////
	// Constructors //
	//////////////////
	public LibSVMFormatReader(String libSVMFormatFilename) throws IOException {
		this(new File(libSVMFormatFilename));
	}

	public LibSVMFormatReader(BufferedReader buf) throws IOException {
		this.libsvmFormatFileReader = buf;
		convert();
	}

	public LibSVMFormatReader(File libSVMFormatFile) throws IOException {
		this(new BufferedReader(new InputStreamReader(new FileInputStream(
				libSVMFormatFile))));
	}

	////////////////
	// Converters //
	////////////////
	private void convert() throws IOException {
		ArrayList<svm_node[]> nodeArrayList = new ArrayList<svm_node[]>();
		ArrayList labelsList = new ArrayList();

		String line;
		while ((line = this.libsvmFormatFileReader.readLine()) != null) {
			nodeArrayList.add(devideRow(line));
			labelsList.add(getLabel(line));
		}

		// Copy references 1 by 1:
		svm_node[][] svm_nodeArray = new svm_node[nodeArrayList.size()][];
		double[] labels = new double[labelsList.size()];
		if (labels.length != svm_nodeArray.length) {
			throw new IllegalArgumentException(
					"Converting to Java-libsvm failed: could not find the same number of labels and vectors.");
		}

		for (int i = 0; i < svm_nodeArray.length; i++) {
			svm_nodeArray[i] = nodeArrayList.get(i);
			labels[i] = labelsList.get(i);
		}

		this.x = svm_nodeArray;
		this.y = labels;
	}

	private double getLabel(String line) {
		double ret = Double.NaN;
		try {
			ret = Double.parseDouble(line.split("\\s")[0]);
		} catch (NumberFormatException e) {
			throw new IllegalArgumentException(
					"Could not parse label to double-value.", e);
		} catch (ArrayIndexOutOfBoundsException e) {
			throw new IllegalArgumentException(
					"Could split line into different parts.", e);
		}
		return ret;
	}

	/**
	 * This method takes one row from the libsvm-format and converts it into a
	 * svm_node[]. On error it throws an exception.
	 * 
	 * @param row
	 * @return
	 */
	private svm_node[] devideRow(String row) {
		try {
			svm_node tNode;
			String[] tSplit;
			String tToken;

			ArrayList<svm_node> nodes = new ArrayList<svm_node>();

			// TODO Try out which space or character works finest:
			String[] segs = row.split("\\s");
			for (String string : segs) {
				// Skip first - its the label
				// and make sure there nothing suspicious:
				tToken = string.trim();
				if (tToken.contains(":")) {
					tNode = new svm_node();
					tSplit = tToken.split(":");
					tNode.index = Integer.parseInt(tSplit[0]);
					tNode.value = Double.parseDouble(tSplit[1]);
					nodes.add(tNode);
				}
			}

			// Copy to array 1 by 1:
			svm_node[] svm_nodes = new svm_node[nodes.size()];
			for (int i = 0; i < svm_nodes.length; i++) {
				svm_nodes[i] = nodes.get(i);
			}

			if (svm_nodes.length == 0) {
				throw new IllegalArgumentException(
						"No index-value-pairs found.");
			}

			return svm_nodes;

		} catch (NumberFormatException e) {
			throw new IllegalArgumentException(
					"Could not parse index or value into a number. Please proof your file.",
					e);
		}
	}

	/////////////////
	// getXYZ(...) //
	/////////////////

	public double[] getY() {
		return y;
	}

	public svm_node[][] getX() {
		return x;
	}

	/*
	 * Test-Main ...
	 */
	public static void main(String[] args) {
		try {
			LibSVMFormatReader libSVMFormatReader = new LibSVMFormatReader(
					"/Volumes/Android/BENIGN/LEARNDATA/libsvm/MW/25/BUSINESS_25_MW.libsvmS");
			svm_node[][] nA = libSVMFormatReader.x;
			double[] y = libSVMFormatReader.y;
			for (int i = 0; i < y.length; i++) {
				System.out.print("LABEL: " + y[i] + " ");
				for (svm_node node : nA[i]) {
					System.out.print(node);
				}
				System.out.println();
			}

		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}
LibSVMFormatReader
LibSVMFormatReader
LibSVMFormatReader.java
4.2 KiB
642 Downloads
Details