So warum funktioniert das automatische Mounten nach Gingerbread (Android 2.3) nicht mehr? Android verwendet bis einschließlich Gingerbread das USB mass storage protocol, dieses Protokoll erlaubt es aber nicht dass die Partition gleichzeitig auf dem Androidgerät und dem PC gemountet ist. Daraus resultiert also dass die Partition auf dem Androidgerät ausgehängt wird, wenn diese auf dem PC gemountet wird. Android verwendet seit Honeycomb keine getrennten Partitionen für Apps und Daten mehr, dass heißt Android kann die Partition nicht mehr aushängen und somit ist auch das USB mass storage protocol nicht mehr möglich. Um trotzdem Daten zwischen dem PC und dem Smartphone/Tablet austauschen zu können verwendet Android nun ein anderes Protokoll: Media Transfer Protocol (MTP).

Soweit zur Theorie, doch wie mountet man jetzt “das Smartphone” unter (Ubuntu)-Linux? Zuerst müssen wir die dafür nötigen Programme installieren:

sudo apt-get install mtp-tools mtpfs

Dannach können wir die idVendor und die idProduct des Geräts ermitteln:

$ mtp-detect | grep idVendor
   idVendor: 22b8

$ mtp-detect | grep idProduct
   idProduct: 70a9

Mit der idVendor und der idProduct legen wir nun eine neue uDev-Regel an, ich persönlich bevorzuge den Editor vim, der folgende Befehl verwendet allerdings gedit:

gksu gedit /etc/udev/rules.d/51-android.rules

Diese neue Datei füllen wir mit folgendem Inhalt:

# Motorola Xoom
SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", ATTR{idProduct}=="70a9", MODE="0666"

Die Werte für idVendor und idProduct müssen natürlich durch die vorher ermittelten Werte ersetzt werden.

Jetzt können wir (bei abgestecktem Gerät) uDev neustarten, den mount-Ordnet anlegen, useren eigenen Benutzer der fuse Gruppe zuweisen und die fuse-Datei editieren:

$ sudo service udev restart
$ sudo mkdir /media/MotorolaXoom
$ sudo chmod a+rwx /media/MotorolaXoom
$ sudo adduser hdr fuse
$ gksu gedit /etc/fuse.conf

In der /etc/fuse.conf ändern wir folgende Zeile:

#user_allow_other

zu

user_allow_other

Um das (U)Mounten etwas komfortabler zu gestalten erstellen wir 2 aliase:

$ echo "alias android-connect=\"mtpfs -o allow_other /media/MotorolaXoom\"" >> ~/.bashrc
$ echo "alias android-disconnect=\"fusermount -u /media/MotorolaXoom\"" >> ~/.bashrc

Nach einem reboot sollte sich das Androidgerät mit android-connect mounten und mit android-disconnect wieder umounten lassen.

• clientPublicKey.pem
• clientPrivateKey.der

1. Öffentlichen Schlüssel des Clients in PHP importieren, Daten verschlüsseln und in Datei abspeichern:
   

   <?php
   $publicKey = openssl_get_publickey(file_get_contents('keys/clientPublicKey.pem'));
   
   $data = "Geheimer Text....";
   
   $encrypted = '';
   openssl_public_encrypt($data, $encrypted, $publicKey, OPENSSL_PKCS1_PADDING);
   
   file_put_contents('/tmp/encrypted', $encrypted);

2. Privaten Schlüssel in Java importieren:
   

   File privKeyFile = new File("keys/clientPrivateKey.der");
   byte[] buffer = new byte[(int) privKeyFile.length()];
   
   DataInputStream in = new DataInputStream(new FileInputStream(privKeyFile));
   in.readFully(buffer);
   in.close();
   
   KeyFactory keyFactory = KeyFactory.getInstance("RSA");
   RSAPrivateKey privateKey = (RSAPrivateKey) keyFactory.generatePrivate(new PKCS8EncodedKeySpec(buffer));

3. Verschlüsselte Datei lesen:
   

   File cryptedData = new File("/tmp/encrypted");
   buffer = new byte[(int) cryptedData.length()];
   		
   in = new DataInputStream(new FileInputStream(cryptedData));
   in.readFully(buffer);
   in.close();

4. Entschlüsseln:
   

   Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");
   cipher.init(Cipher.DECRYPT_MODE, privateKey);
   
   byte[] decrypted = cipher.doFinal(buffer);
   
   String data = new String(decrypted);
   
   System.out.println(data);

5. Sich über die Ausgabe “Geheimer Text….” freuen.

Eine kleine Anmerkung zur RSA Verschlüsselung allgemein, RSA ist im Vergleich zu symmetrischen Verschlüsselungen wie z.B. AES um ca. Faktor 1000 langsamer. Daher eignet sich RSA nur zum verschlüsseln kleiner Daten, für größere Datein verwendet man daher in der Regel ein “Hybrides Verfahren” indem man die Daten mit z.B. AES verschlüsselt und nur den Schlüssel dann mit RSA. So kann der Empfänger dann mit RSA den AES-Schlüssel entschlüsseln und mit diesem dann die Daten an sich. So ein hybrides Verfahren im Zusammenhang mit JAVA,PHP und RSA werde ich in einem meiner nächsten Posts vorstellen.

Kurz zusammengefaßt lässt sich sagen, dass PHPUnit ab 3.6 alle Ausgaben schluckt, für die CLI Veriante schlagen die CakePHP-Entwickler vor –debug zu verwenden. Da ich aber meine Tests lieber im Browser anschaue war das natürlich auch keine Option.
Die Lösung für mein Problem war dann schließlich eine eigene debug-Methode zu schreiben:

public function debug($data, $pre = true) {
    $data = print_r($data, true);

    if ($pre)
        $data = "[crayon-4fb9926f3c7c8 ]" . $data . "[/crayon]";

    echo $data;

    if (empty($_SERVER['HTTP_HOST'])) // for cli mode use: --debug
        return;

    ob_flush();
}

if ($pre)
$data = “[crayon-4fb9926f3c7c8 ]” . $data . “[/crayon]“;

echo $data;

if (empty($_SERVER['HTTP_HOST'])) // for cli mode use: –debug
return;

ob_flush();
}
[/crayon]

Rufe ich nun im TestCase diese Methode mit $this->debug() statt debug() auf erhalte ich (fast) wie gewohnt meine Debug-Ausgaben.

UPDATE:
Alternativ kann man auch &debug=1 an die URL anhängen um die Ausgaben von debug(), print_r() und Co zu erhalten.

1. Zuerst benötigen wir für den Server (PHP) und für den Client (JAVA) jeweils einen privaten und einen öffentlichen Schlüssel, diese erzeugen wir mit dem Kommandozeilentool openssl:

   openssl genrsa -out serverPrivateKey.pem 2048
   openssl rsa -in serverPrivateKey.pem -pubout -outform DER -out serverPublicKey.der

   Mit dem ersten Befehl wird der private Schlüssel für den Server erzeugt und im openssl Standardformat PEM abgespeichert. Der zweite Befehl speichert dann den dazugehörigen öffentlichen Schlüssel im DER Format ab. (Das DER Format ist das Standardformat für JAVA’s RSA.) Umgekehrt benötigen wir dann noch noch den privatenSchlüssel des JAVA Client (im DER Format) sowie den öffentlichen Schlüssel des Clients im PEM Format:

   openssl genrsa -out clientPrivateKey.pem 2048
   openssl pkcs8 -topk8 -nocrypt -in clientPrivateKey.pem -outform der -out clientPrivateKey.der
   openssl rsa -in clientPrivateKey.pem -pubout -outform PEM -out clientPublicKey.pem

   Die Zahl 2048 gibt die Größe des Schlüssels in Bit an. Weniger als 2048 sollte man heutzutage nicht verwenden. Wer auf Nummer sicher gehen will nimmt hier 4096.

2. Im nächsten Schritt importieren wir den öffentlichen Schlüssel des Servers in unserem JAVA Client:

   File pubKeyFile = new File("keys/serverPublicKey.der");
   byte[] buffer = new byte[(int) pubKeyFile.length()];
   
   DataInputStream in = new DataInputStream(new FileInputStream(pubKeyFile));
   in.readFully(buffer);
   in.close();
   
   KeyFactory keyFactory = KeyFactory.getInstance("RSA");
   RSAPublicKey publicKey = (RSAPublicKey) keyFactory.generatePublic(new X509EncodedKeySpec(buffer));

3. Nach dem importieren des publicKey können wir nun Daten verschlüsseln:

   String text = "Geheimer Text!";
   
   Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1PADDING");
   cipher.init(Cipher.ENCRYPT_MODE, publicKey);
   byte[] encrypted = cipher.doFinal(text.getBytes());

   Um mit den verschlüsselten Daten weiter arbeiten zu können, speichern wir diese ab:

   FileOutputStream fos = new FileOutputStream("/tmp/encrypted");
   fos.write(encrypted);
   fos.flush();
   fos.close();

4. Verschlüsselte Daten mit PHP entschlüsseln.
   

   <?php
   $encryptedData = file_get_contents('/tmp/encrypted');
   $privKeyFile = file_get_contents('keys/serverPrivateKey.pem');
   
   $privKey = openssl_get_privatekey($privKeyFile);
   openssl_private_decrypt($encryptedData, $decrypted, $privKey, OPENSSL_PKCS1_PADDING);
   
   print "$decrypted\n";

   Und als Ausgabe erhalten wir (wie erwartet):
   Geheimer Text!

So das wars mit dem ersten Teil, der zweite Teil, mit der Verschlüsselung in der anderen Richtung folgt hoffentlich bald.

UPDATE:
2. Teil veröffentlich: RSA mit JAVA und PHP – Teil 2 (PHP -> JAVA)

Ausgehend von meiner Suche nach den optimalen Einstellung für das Motorola Xoom mit einer Auflösung von 1280×800 (720p Videos möglich) bin ich auf folgende Seite gestoßen: Motorola XOOM – Optimal video setting, kurz zusammengefasst wird ein x264 Baselineprofil mit folgenden Eigenschaften empfohlen:

- No CABAC entropy coding.
- No B frames
- No 8×8 transforms (DCT)
- No Weighted Prediction

Die Konvertierung habe ich dann mit HandBrake durchgeführt und die Ergebnisse waren einwandfrei, als VideoPlayer auf dem Android Gerät empfehle ich übrigens den MX Video Player, wichtig ist dabei aber zusätzlich den richtigen Codec zu installieren, für das Motorola Xoom (aber auch das Nexus One) ist das dieser hier: MX Video Player Codec (ARMv7)

Für das Nexus One war nur die Änderung der maximalen Auflösung notwendig, die restlichen Einstellungen lieferten auch hier die gewünschten Ergebnisse.

Damit ihr gleich loslegen könnt hab ich meine HandBrake config hochgeladen, einmal für das Motorola Xoom und einmal für Smartphones mit einer Auflösung von 800×480 (wie zum Beispiel das Nexus One oder das Galaxy S1+).

Viel Spaß damit

Den direkten Link gibts hier:

An dieser Stelle auch vielen Dank an Julian Hollmann für den Standardhintergrund und das Logo.

Wers ausprobieren will hier der Link RotatingWallpaper.apk

Bei der App handelt sich um einen LiveWallpaper, der regelmäßig das Hintergrundbild mit Bildern aus dem Ordner “rotatingWallpaper” von der SD-Card auswechselt.

Mal schauen ob mein 2. Versuch klappt