KeyStore: add java interface.
diff --git a/keystore/java/android/security/Credentials.java b/keystore/java/android/security/Credentials.java
index 28c2992..43042c0b 100644
--- a/keystore/java/android/security/Credentials.java
+++ b/keystore/java/android/security/Credentials.java
@@ -28,9 +28,12 @@
*/
public class Credentials {
private static final String LOGTAG = "Credentials";
- private static final String UNLOCK_ACTION = "android.credentials.UNLOCK";
- private static final String INSTALL_ACTION = "android.credentials.INSTALL";
- private static Credentials singleton;
+
+ public static final String UNLOCK_ACTION = "android.credentials.UNLOCK";
+
+ public static final String INSTALL_ACTION = "android.credentials.INSTALL";
+
+ public static final String SYSTEM_INSTALL_ACTION = "android.credentials.SYSTEM_INSTALL";
/** Key prefix for CA certificates. */
public static final String CA_CERTIFICATE = "CACERT_";
@@ -59,6 +62,8 @@
/** Data type for PKCS12. */
public static final String PKCS12 = "PKCS12";
+ private static Credentials singleton;
+
public static Credentials getInstance() {
if (singleton == null) {
singleton = new Credentials();
@@ -95,4 +100,12 @@
Log.w(LOGTAG, e.toString());
}
}
+
+ public void installFromSdCard(Context context) {
+ try {
+ context.startActivity(new Intent(INSTALL_ACTION));
+ } catch (ActivityNotFoundException e) {
+ Log.w(LOGTAG, e.toString());
+ }
+ }
}
diff --git a/keystore/java/android/security/KeyStore.java b/keystore/java/android/security/KeyStore.java
new file mode 100644
index 0000000..b47e399
--- /dev/null
+++ b/keystore/java/android/security/KeyStore.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2009 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.security;
+
+import android.net.LocalSocketAddress;
+import android.net.LocalSocket;
+
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.ArrayList;
+
+/**
+ * {@hide}
+ */
+public class KeyStore {
+ public static int NO_ERROR = 1;
+ public static int LOCKED = 2;
+ public static int UNINITIALIZED = 3;
+ public static int SYSTEM_ERROR = 4;
+ public static int PROTOCOL_ERROR = 5;
+ public static int PERMISSION_DENIED = 6;
+ public static int KEY_NOT_FOUND = 7;
+ public static int VALUE_CORRUPTED = 8;
+ public static int UNDEFINED_ACTION = 9;
+ public static int WRONG_PASSWORD = 10;
+
+ private static final LocalSocketAddress sAddress = new LocalSocketAddress(
+ "keystore", LocalSocketAddress.Namespace.RESERVED);
+
+ private int mError = NO_ERROR;
+
+ private KeyStore() {}
+
+ public static KeyStore getInstance() {
+ return new KeyStore();
+ }
+
+ public int test() {
+ execute('t');
+ return mError;
+ }
+
+ public byte[] get(byte[] key) {
+ byte[][] values = execute('g', key);
+ return (values == null) ? null : values[0];
+ }
+
+ public String get(String key) {
+ byte[] value = get(key.getBytes());
+ return (value == null) ? null : new String(value);
+ }
+
+ public boolean put(byte[] key, byte[] value) {
+ execute('i', key, value);
+ return mError == NO_ERROR;
+ }
+
+ public boolean put(String key, String value) {
+ return put(key.getBytes(), value.getBytes());
+ }
+
+ public boolean delete(byte[] key) {
+ execute('d', key);
+ return mError == NO_ERROR;
+ }
+
+ public boolean delete(String key) {
+ return delete(key.getBytes());
+ }
+
+ public boolean contains(byte[] key) {
+ execute('e', key);
+ return mError == NO_ERROR;
+ }
+
+ public boolean contains(String key) {
+ return contains(key.getBytes());
+ }
+
+ public byte[][] scan(byte[] prefix) {
+ return execute('s', prefix);
+ }
+
+ public String[] scan(String prefix) {
+ byte[][] values = scan(prefix.getBytes());
+ if (values == null) {
+ return null;
+ }
+ String[] strings = new String[values.length];
+ for (int i = 0; i < values.length; ++i) {
+ strings[i] = new String(values[i]);
+ }
+ return strings;
+ }
+
+ public boolean reset() {
+ execute('r');
+ return mError == NO_ERROR;
+ }
+
+ public boolean password(byte[] oldPassword, byte[] newPassword) {
+ execute('p', oldPassword, newPassword);
+ return mError == NO_ERROR;
+ }
+
+ public boolean password(String oldPassword, String newPassword) {
+ return password(oldPassword.getBytes(), newPassword.getBytes());
+ }
+
+ public boolean password(byte[] password) {
+ return password(password, password);
+ }
+
+ public boolean password(String password) {
+ return password(password.getBytes());
+ }
+
+ public boolean lock() {
+ execute('l');
+ return mError == NO_ERROR;
+ }
+
+ public boolean unlock(byte[] password) {
+ execute('u', password);
+ return mError == NO_ERROR;
+ }
+
+ public boolean unlock(String password) {
+ return unlock(password.getBytes());
+ }
+
+ public int getLastError() {
+ return mError;
+ }
+
+ private byte[][] execute(int code, byte[]... parameters) {
+ mError = PROTOCOL_ERROR;
+
+ for (byte[] parameter : parameters) {
+ if (parameter == null || parameter.length > 65535) {
+ return null;
+ }
+ }
+
+ LocalSocket socket = new LocalSocket();
+ try {
+ socket.connect(sAddress);
+
+ OutputStream out = socket.getOutputStream();
+ out.write(code);
+ for (byte[] parameter : parameters) {
+ out.write(parameter.length >> 8);
+ out.write(parameter.length);
+ out.write(parameter);
+ }
+ out.flush();
+ socket.shutdownOutput();
+
+ InputStream in = socket.getInputStream();
+ code = in.read();
+ if (code == -1) {
+ return null;
+ }
+
+ ArrayList<byte[]> results = new ArrayList<byte[]>();
+ while (true) {
+ int i, j;
+ if ((i = in.read()) == -1) {
+ break;
+ }
+ if ((j = in.read()) == -1) {
+ return null;
+ }
+ byte[] result = new byte[i << 8 | j];
+ for (i = 0; i < result.length; i += j) {
+ if ((j = in.read(result, i, result.length - i)) == -1) {
+ return null;
+ }
+ }
+ results.add(result);
+ }
+ mError = code;
+ return results.toArray(new byte[results.size()][]);
+ } catch (IOException e) {
+ // ignore
+ } finally {
+ try {
+ socket.close();
+ } catch (IOException e) {}
+ }
+ return null;
+ }
+}
