Develop Reference

Android: Room: no encryption and security?

I am using OrmLite over SQLite with SQLCipher to encrypt a database on Android. Is there a way to cipher a Room database?

Room by default store data in the app's internal storage which any root user can access.
if you need some security you need to use encryption lib like this cwac-saferoom.

SQLCipher for Android now directly supports Room. You can find the documentation here
Consequently, #CommonsWare will not be actively developing cwac-saferoom any longer and recommends using SQLCipher's support

Android Room DB explicitly doesn't support encryption. A typical
SQLite database in unencrypted. You can use SQLCipher for Android with
Room or other consumers of the androidx.sqlite API to Secure Your Data
stored in sqlite DB. QLCipher has a SupportFactory class in
the net.sqlcipher.database package that can be used to configure Room
to use SQLCipher for Android. See the hexdumps of a standard SQLite db
and one implementing SQLCipher.
~ sjlombardo$ hexdump -C sqlite.db
00000000 53 51 4c 69 74 65 20 66 6f 72 6d 61 74 20 33 00 |SQLite format 3.|
…
000003c0 65 74 32 74 32 03 43 52 45 41 54 45 20 54 41 42 |et2t2.CREATE TAB|
000003d0 4c 45 20 74 32 28 61 2c 62 29 24 01 06 17 11 11 |LE t2(a,b)$…..|
…
000007e0 20 74 68 65 20 73 68 6f 77 15 01 03 01 2f 01 6f | the show…./.o|
000007f0 6e 65 20 66 6f 72 20 74 68 65 20 6d 6f 6e 65 79 |ne for the money|
~ $ sqlite3 sqlcipher.db
sqlite> PRAGMA KEY=’test123′;
sqlite> CREATE TABLE t1(a,b);
sqlite> INSERT INTO t1(a,b) VALUES (‘one for the money’, ‘two for the show’);
sqlite> .quit
~ $ hexdump -C sqlcipher.db
00000000 84 d1 36 18 eb b5 82 90 c4 70 0d ee 43 cb 61 87 |.?6.?..?p.?C?a.|
00000010 91 42 3c cd 55 24 ab c6 c4 1d c6 67 b4 e3 96 bb |.B?..?|
00000bf0 8e 99 ee 28 23 43 ab a4 97 cd 63 42 8a 8e 7c c6 |..?(#C??.?cB..|?|
~ $ sqlite3 sqlcipher.db
sqlite> SELECT * FROM t1;
Error: file is encrypted or is not a database
https://github.com/sqlcipher/android-database-sqlcipher

got UICC carrier priviliges but failed to open channel in android 5.1

I am trying to develop some functions with newly added UICC features in TelephonyManager in android 5.1,
using these configuration in my UICC and got UICC carrier privileges already.
( refer to https://source.android.com/devices/tech/config/uicc.html )
my UICC configuration in TLV format :
FF40
81 A8
E2 3E
E1 30 //UICC rule
C1 14 CD AE 0D 74 62 B8 ED 7D 58 68 59 23 16 45 E9 7C A5 DA 1F 90
CA 18 63 6f 6d 2e 74 61 69 73 79 73 2e 73 6d 61 72 74 63 61 72 64 74 65 73 74
E3 0A DB 08 FF FF FF FF FF FF FF FF
E2 32 //SEEK smartcard api AID and hash
E1 28
4F 10 01 A4 04 00 0B A0 00 00 00 18 47 50 41 43 2D 31 //AID
C1 14 EA 76 BC 02 00 00 3B 6E 0C 58 12 72 37 F4 1F F9 78 FC 10 6B //sha-1 hash
E3 06 //SEEK smartcard api rule
D0 01 01
D1 01 01
E2 32
E1 28 //uicc privilege AID and hash
4F 10 01 A4 04 00 0B A0 00 00 00 18 47 50 41 43 2D 32
C1 14 CD AE 0D 74 62 B8 ED 7D 58 68 59 23 16 45 E9 7C A5 DA 1F 90
E3 06
D0 01 01
D1 01 01
but after getting UICC privileges and trying to open iccOpenLogicalChannel, This is the stack trace I get when calling one of the above functions:
"java.lang.SecurityException: Only Smartcard API may access UICC"
How to modify the UICC configuration and open channel successfully in Telephonymanager ?
Thanks in advance !

Can't BER decode RSA public key with NDK Android

I have problems using Crypto++ to save a RSA public key string. When decoding the key, I always get a BERDecodeErr exception.
Code:
string RsaEncryptor::encryptor(string plaintext, string publicKey)
{
std::string cipher;
AutoSeededRandomPool prng;
try
{
ByteQueue queue;
Base64Decoder decoder(new Redirector(queue));
decoder.Put((const byte *) publicKey.data(), publicKey.size());
decoder.MessageEnd();
RSA::PublicKey rsaPublick;
rsaPublick.BERDecodePublicKey(queue, false, (size_t) queue.MaxRetrievable());
// BERDecodePrivateKey is a void function. Here's the only check
// we have regarding the DER bytes consumed.
CRYPTOPP_ASSERT(queue.IsEmpty());
bool valid = rsaPublick.Validate(prng, 3);
if (!valid)
cipher = "RSA private key is not valid";
RSAES_OAEP_SHA_Encryptor e(rsaPublick);
StringSource ss(plaintext, true,
new PK_EncryptorFilter(prng, e,
new StringSink(cipher)
) // PK_EncryptorFilter
); // StringSource
}
catch (CryptoPP::Exception &e) {
cipher = e.what();
}
return cipher;
}
The public key is:
MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQDs648aASMAR9VprkzNVS7b‌​36N1hiYvbBG0c
dE0QkS3‌​H/sc3+Ej92lGBQErpBu9‌​LVhwN/beBX4QnbCn1eNS‌​rKoOzS4yqWlwOaCe0WLm‌​FDHCn1
cMTkX89cT4A0pc‌​jBbY+0W7htxWcqHxEQH9‌​x/AjQ9/4blerh1i6/lLI‌​o6hn2hB8kQIB

MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQDs648aASMAR9VprkzNVS7b‌​36N1hiYvbBG0c
dE0QkS3‌​H/sc3+Ej92lGBQErpBu9‌​LVhwN/beBX4QnbCn1eNS‌​rKoOzS4yqWlwOaCe0WLm‌​FDHCn1
cMTkX89cT4A0pc‌​jBbY+0W7htxWcqHxEQH9‌​x/AjQ9/4blerh1i6/lLI‌​o6hn2hB8kQIB
The key is malformed.
Stripping the Base64 encoding:
FileSource fs1("key.b64", true, new Base64Decoder);
FileSink fs2("key.der");
fs1.CopyTo(fs2);
And then viewing it under Gutmann's dumpasn1 reveals:
$ dumpasn1 key.der
0 157: SEQUENCE {
3 13: SEQUENCE {
5 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
16 0: NULL
: }
18 139: BIT STRING, encapsulates {
22 135: SEQUENCE {
25 129: INTEGER
: 00 EC EB 8F 1A 01 23 00 47 D5 69 AE 4C CD 55 2E
: DB DF A3 75 86 26 2F 6C 11 B4 71 D1 34 42 44 B7
: 1F FB 1C DF E1 23 F7 69 46 05 01 2B A4 1B BD 2D
: 58 70 37 F6 DE 05 7E 10 9D B0 A7 D5 E3 52 AC AA
: 0E CD 2E 32 A9 69 70 39 A0 9E D1 62 E6 14 31 C2
: 9F 57 0C 4E 45 FC F5 C4 F8 03 4A 5C 8C 16 D8 FB
: 45 BB 86 DC 56 72 A1 F1 11 01 FD C7 F0 23 43 DF
: F8 6E 57 AB 87 58 BA FE 52 C8 A3 A8 67 DA 10 7C
: 91
157 1: INTEGER -1
: Error: Integer has a negative value.
: }
: }
: }
From above, the problem ASN.1 is at position 157. Looking at the file sizes:
-rw-r--r-- 1 jwalton staff 261 Oct 18 23:09 key.b64
-rw-r--r-- 1 jwalton staff 159 Oct 18 23:18 key.der
It looks like there's two byte remaining to be processed. The 02 is the ASN.1 tag for an INTEGER. It should be followed by a length and a value, but there's only the length octet (01) is present. The value is missing.
$ xxd -g 1 key.der
0000000: 30 81 9d 30 0d 06 09 2a 86 48 86 f7 0d 01 01 01 0..0...*.H......
0000010: 05 00 03 81 8b 00 30 81 87 02 81 81 00 ec eb 8f ......0.........
0000020: 1a 01 23 00 47 d5 69 ae 4c cd 55 2e db df a3 75 ..#.G.i.L.U....u
0000030: 86 26 2f 6c 11 b4 71 d1 34 42 44 b7 1f fb 1c df .&/l..q.4BD.....
0000040: e1 23 f7 69 46 05 01 2b a4 1b bd 2d 58 70 37 f6 .#.iF..+...-Xp7.
0000050: de 05 7e 10 9d b0 a7 d5 e3 52 ac aa 0e cd 2e 32 ..~......R.....2
0000060: a9 69 70 39 a0 9e d1 62 e6 14 31 c2 9f 57 0c 4e .ip9...b..1..W.N
0000070: 45 fc f5 c4 f8 03 4a 5c 8c 16 d8 fb 45 bb 86 dc E.....J\....E...
0000080: 56 72 a1 f1 11 01 fd c7 f0 23 43 df f8 6e 57 ab Vr.......#C..nW.
0000090: 87 58 ba fe 52 c8 a3 a8 67 da 10 7c 91 02 01 .X..R...g..|...
Here's another view of the problem. 02 is the ASN.1 INTEGER, 01 is the length of the integer, but the value is missing:
0000090: 87 58 ba fe 52 c8 a3 a8 67 da 10 7c 91 ***02 01 ??***
Here's what a good 1024 bit key looks like. Its different than yours:
$ dumpasn1 key.der
0 157: SEQUENCE {
3 13: SEQUENCE {
5 9: OBJECT IDENTIFIER rsaEncryption (1 2 840 113549 1 1 1)
16 0: NULL
: }
18 139: BIT STRING, encapsulates {
22 135: SEQUENCE {
25 129: INTEGER
: 00 D0 52 BA 4B 3F 44 AA 7B C9 C2 84 46 17 D6 17
: A0 43 03 69 7B 18 06 5B D4 EA 29 E2 74 24 40 62
: 58 16 52 9D 73 82 77 D7 9D 13 97 53 71 76 9F B2
: 99 CA 36 1E D4 E1 DF 0D BE C4 07 1E A0 F2 F2 E9
: EF 32 FA 00 4B 0B 8E C2 91 BA 8B 1D 1C 4D F0 98
: 6C 64 C5 9E 4D EE 58 17 06 20 C9 3C 9A F0 33 BB
: A8 FC 7B 7B 6C F9 C6 FD A0 17 76 3A 3D 1D 7E E7
: 42 C2 49 AD 4C 26 AE B6 F6 DC 99 A3 24 99 1A 30
: D9
157 1: INTEGER 17
: }
: }
: }
0 warnings, 0 errors.
Notice there are two octets following the 02 (01 11 below), and not one octet (like yours):
$ xxd -g 1 key.der
0000000: 30 81 9d 30 0d 06 09 2a 86 48 86 f7 0d 01 01 01 0..0...*.H......
0000010: 05 00 03 81 8b 00 30 81 87 02 81 81 00 d0 52 ba ......0.......R.
0000020: 4b 3f 44 aa 7b c9 c2 84 46 17 d6 17 a0 43 03 69 K?D.{...F....C.i
0000030: 7b 18 06 5b d4 ea 29 e2 74 24 40 62 58 16 52 9d {..[..).t$#bX.R.
0000040: 73 82 77 d7 9d 13 97 53 71 76 9f b2 99 ca 36 1e s.w....Sqv....6.
0000050: d4 e1 df 0d be c4 07 1e a0 f2 f2 e9 ef 32 fa 00 .............2..
0000060: 4b 0b 8e c2 91 ba 8b 1d 1c 4d f0 98 6c 64 c5 9e K........M..ld..
0000070: 4d ee 58 17 06 20 c9 3c 9a f0 33 bb a8 fc 7b 7b M.X.. .<..3...{{
0000080: 6c f9 c6 fd a0 17 76 3a 3d 1d 7e e7 42 c2 49 ad l.....v:=.~.B.I.
0000090: 4c 26 ae b6 f6 dc 99 a3 24 99 1a 30 d9 02 01 11 L&......$..0....

Error in TLS handshake when using mutual authentication

While testing my app (https://play.google.com/apps/testing/com.degoo.android) I've found that on some devices the TLS handshake between the app and our servers fail if the https request requires a client certificate (i.e. mutual authentication). The same code works on Windows and on OS X, so I know that it's not caused by an incorrect cert or that I have forgotten to include the cert into the SSLContext. I have detected it on both some Android 4.4 devices and on some 5.0 devices. Unfortunately I haven't found any common denominator which causes it to fail (other than Android). However, on devices were it fails it fails 100% of the time.
I've analyzed the network traffic to see more precisely when the error occurs. The following thing works on all devices:
The connection is established and the client successfully validates the server's certs.
The client sends it's HTTP request.
The server detects that the request is for protected area and sends a certificate_request.
The client decides which client certificate to send (we can see that it selects the correct certificate) and sends it.
After the client has responded with its certificate it sends two more TLS records and then the handshake fails.
Here's an example of how what these two TLS records looks like on a device were the handshake SUCCEEDS:
14 03 01 00 20 9c 07 49 78 9f ba 09 03 41 6b 66 ad 46 e2 75 94 f7 cf 18 bd 11 cf 35 a2 eb 5e b8 a8 4c 2a 1d c5
16 03 01 00 30 20 0e 13 d7 48 b9 6e b2 1b 96 6f 10 56 67 81 63 d9 d8 c7 73 23 95 3b f9 da f9 ce f4 f8 d1 7e 1b a4 12 92 4c 4f 54 a5 f8 49 75 d5 46 f4 2d 29 97
Here's an example of how what these two TLS records looks like on a device were the handshake FAILS:
14 03 01 00 20 a9 86 c2 fd 03 0a f8 08 fa f8 9e eb b7 97 07 56 6f 27 c0 d6 8f 95 be 77 c1 44 84 e9 e1 56 6f 6a
16 03 01 00 30 ff 36 76 e5 47 87 84 71 1c ce c9 08 41 45 fc 09 c6 ef 08 e6 21 ff 45 3a 10 ae 8d 5a 99 5f ca c5 ac bd bf 7e ca 69 32 4d 1f 01 c6 30 83 8e 06 cb
From the first byte of the records I can see that both clients send a change cipher spec record and then a handshake record. A funny thing about the failing devices is that byte with index 5 of the second record has value ff. When I look in TLS specification I don't see any handshake record type with that value. The device that succeeds has that byte set to 20, which means "finished".
Any idea on what's going on? What could cause this?

Decoding AAC audio stream coming from red5 server with javacv-ffmpeg on Android

I am trying to play AAC audio live stream coming from Red5 server, so to decode the audio data i am using Javacv-ffmpeg. Data is received as packets of byte[]
Here is what i tried
public Frame decodeAudio(byte[] adata,long timestamp){
BytePointer audio_data = new BytePointer(adata);
avcodec.AVCodec codec1 = avcodec.avcodec_find_decoder(avcodec.AV_CODEC_ID_AAC);// For AAC
if (codec1 == null) {
Log.d("showit","avcodec_find_decoder() error: Unsupported audio format or codec not found: " + audio_c.codec_id() + ".");
}
audio_c = null;
audio_c = avcodec.avcodec_alloc_context3(codec1);
audio_c.sample_rate(44100);
audio_c.sample_fmt(3);
audio_c.bits_per_raw_sample(16);
audio_c.channels(1);
if ((ret = avcodec.avcodec_open2( audio_c, codec1, (PointerPointer)null)) < 0) {
Log.d("showit","avcodec_open2() error " + ret + ": Could not open audio codec.");
}
if (( samples_frame = avcodec.avcodec_alloc_frame()) == null)
Log.d("showit","avcodec_alloc_frame() error: Could not allocate audio frame.");
avcodec.av_init_packet(pkt2);
samples_frame = avcodec.avcodec_alloc_frame();
avcodec.av_init_packet(pkt2);
pkt2.data(audio_data);
pkt2.size(audio_data.capacity());
pkt2.pts(timestamp);
pkt2.pos(0);
int len = avcodec.avcodec_decode_audio4( audio_c, samples_frame, got_frame, pkt2);
}
But len after decoding returns -1 for first frame and then -22 always.
First packet is like this always
AF 00 12 08 56 E5 00
Further packets are like
AF 01 01 1E 34 2C F0 A4 71 19 06 00 00 95 12 AE AA 82 5A 38 F3 E6 C2 46 DD CB 2B 09 D1 00 78 1D B7 99 F8 AB 41 6A C4 F4 D2 40 51 17 F5 28 51 9E 4C F6 8F 15 39 49 42 54 78 63 D5 29 74 1B 4C 34 9B 85 20 8E 2C 0E 0C 19 D2 E9 40 6E 9C 85 70 C2 74 44 E4 84 9B 3C B9 8A 83 EC 66 9D 40 1B 42 88 E2 F3 65 CF 6D B3 20 88 31 29 94 29 A4 B4 DE 26 B0 75 93 3A 0C 57 12 8A E3 F4 B9 F9 23 9C 69 C9 D4 BF 9E 26 63 F2 78 D6 FD 36 B9 32 62 01 91 19 71 30 2D 54 24 62 A1 20 1E BA 3D 21 AC F3 80 33 3A 1A 6C 30 3C 44 29 F2 A7 DC 9A FF 0F 99 F2 38 85 AB 41 FD C7 C5 40 5C 3F EE 38 70
Couldn't figure out where is the problem, whether in setting the AVcodec context audio_c or setting packet for decoder.
Any help appreciated. Thanks in advance.

The first packet (config) describes the stream data if I'm not mistaken the follow on data is the encoded audio. You can't assume the sample rate etc.. as you have done above, you need to pull that out of the config data which is marked "AF 00".

I have a similar problem. I've intercepted the packets with Wireshark and here is what it told me:
AF is the control byte of AAC frame, and it decodes to following bits:
1010 .... = Format: HE-AAC
.... 11.. = Sample rate: 44kHz (allthough FFMPEG shows me 48kHz and I would lean to believe it more)
.... ..1. = Sample size: 16 bit
.... ...1 = Channels: stereo
I still can't figure out how to universally decode this data.
edit:
Ha! I've got something :)
I guess the first 2 bytes are RTMP specific bytes. The second one seems to state, whether it is the configuration (0) or actual payload (1) - i've found no sources confirming that, it is just my assumption.
Then the first, short package is the AAC configuration description described here:
http://thompsonng.blogspot.com/2010/03/aac-configuration.html
In my case it is:
11 90
which is binary:
0001 0001 1001 0000
and that decodes to:
0001 0... .... .... = 2 = AAC LC
.... .001 1... .... = 3 = 48 kHz
.... .... .001 0... = 2 = 2 channels (stereo)
.... .... .... .0.. = 0 = 1024 sample length
.... .... .... ..0. = 0 = doesn't depends on core code (?)
.... .... .... ...0 = 0 = extension flag