• Home
• org.elastos.did
• didsdk
• 2.2.4
• source code
• DIDStore.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.elastos.did.DIDStore Maven / Gradle / Ivy

/*
 * Copyright (c) 2019 Elastos Foundation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

package org.elastos.did;

import static com.google.common.base.Preconditions.checkArgument;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;

import org.elastos.did.DIDDocument.PublicKey;
import org.elastos.did.crypto.Aes256cbc;
import org.elastos.did.crypto.Base64;
import org.elastos.did.crypto.EcdsaSigner;
import org.elastos.did.crypto.HDKey;
import org.elastos.did.exception.DIDResolveException;
import org.elastos.did.exception.DIDStorageException;
import org.elastos.did.exception.DIDStoreCryptoException;
import org.elastos.did.exception.DIDStoreException;
import org.elastos.did.exception.DIDSyntaxException;
import org.elastos.did.exception.MalformedExportDataException;
import org.elastos.did.exception.WrongPasswordException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.spongycastle.crypto.CryptoException;
import org.spongycastle.crypto.digests.MD5Digest;
import org.spongycastle.crypto.digests.SHA256Digest;
import org.spongycastle.util.encoders.Hex;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

/**
 * This class represents a storage facility for DID objects and private keys.
 *
 * The DIDStore manages different types of entries:
 * - RootIdentity
 * - DIDDocument
 * - VerifiableCredential
 * - PrivateKey
 */
public final class DIDStore {
	/**
	 * The type string for DIDStore.
	 */
	protected static final String DID_STORE_TYPE = "did:elastos:store";
	/**
	 * Current DIDStore version.
	 */
	protected static final int DID_STORE_VERSION = 3;

	private static final int CACHE_INITIAL_CAPACITY = 16;
	private static final int CACHE_MAX_CAPACITY = 128;

	private static final Object NULL = new Object();

	private static final String DID_EXPORT = "did.elastos.export/2.0";
	private static final String DID_LAZY_PRIVATEKEY = "lazy-private-key";

	private Cache cache;

	private DIDStorage storage;
	private Metadata metadata;

	/**
	 * the default conflict handle implementation.
	 */
	protected static final ConflictHandle defaultConflictHandle = (c, l) -> {
		return l;
	};

	private static final Logger log = LoggerFactory.getLogger(DIDStore.class);

	static class Key {
		private static final int TYPE_ROOT_IDENTITY = 0x00;
		private static final int TYPE_ROOT_IDENTITY_PRIVATEKEY = 0x01;
		private static final int TYPE_DID_DOCUMENT = 0x10;
		private static final int TYPE_DID_METADATA = 0x11;
		private static final int TYPE_DID_PRIVATEKEY = 0x12;
		private static final int TYPE_CREDENTIAL = 0x20;
		private static final int TYPE_CREDENTIAL_METADATA = 0x21;

		private int type;
		private Object id;

		private Key(int type, Object id) {
			this.type = type;
			this.id = id;
		}

		@Override
		public int hashCode() {
			return type + id.hashCode();
		}

		@Override
		public boolean equals(Object obj) {
			if (obj == this)
				return true;

			if (obj instanceof Key) {
				Key key = (Key)obj;
				return type == key.type ? id.equals(key.id) : false;
			}

			return false;
		}

		public static Key forRootIdentity(String id) {
			return new Key(TYPE_ROOT_IDENTITY, id);
		}

		public static Key forRootIdentityPrivateKey(String id) {
			return new Key(TYPE_ROOT_IDENTITY_PRIVATEKEY, id);
		}

		public static Key forDidDocument(DID did) {
			return new Key(TYPE_DID_DOCUMENT, did);
		}

		public static Key forDidMetadata(DID did) {
			return new Key(TYPE_DID_METADATA, did);
		}

		private static Key forDidPrivateKey(DIDURL id) {
			return new Key(TYPE_DID_PRIVATEKEY, id);
		}

		private static Key forCredential(DIDURL id) {
			return new Key(TYPE_CREDENTIAL, id);
		}

		private static Key forCredentialMetadata(DIDURL id) {
			return new Key(TYPE_CREDENTIAL_METADATA, id);
		}
	}

	static class Metadata extends AbstractMetadata {
		private static final String TYPE = "type";
		private static final String VERSION = "version";
		private static final String FINGERPRINT = "fingerprint";
		private static final String DEFAULT_ROOT_IDENTITY = "defaultRootIdentity";

		protected Metadata(DIDStore store) {
			super(store);
			put(TYPE, DID_STORE_TYPE);
			put(VERSION, DID_STORE_VERSION);
		}

		/**
		 *  The default constructor for JSON deserialize creator.
		 */
		protected Metadata() {
			this(null);
		}

		protected String getType() {
			return get(TYPE);
		}

		public int getVersion() {
			return getInteger(VERSION, -1);
		}

		private void setFingerprint(String fingerprint) {
			checkArgument(fingerprint != null && !fingerprint.isEmpty(), "Invalid fingerprint");

			put(FINGERPRINT, fingerprint);
		}

		public String getFingerprint() {
			return get(FINGERPRINT);
		}

		protected void setDefaultRootIdentity(String id) {
			put(DEFAULT_ROOT_IDENTITY, id);
		}

		public String getDefaultRootIdentity() {
			return get(DEFAULT_ROOT_IDENTITY);
		}

		@Override
		protected void save() {
			if (attachedStore()) {
				try {
					getStore().storage.storeMetadata(this);
				} catch (DIDStoreException ignore) {
					log.error("INTERNAL - error store metadata for DIDStore");
				}
			}
		}
	}

	/**
	 * ConflictHandle is a interface for solving the conflict,
	 * if the local document is different with the one resolved from chain.
	 */
	@FunctionalInterface
	public interface ConflictHandle {
		/**
		 * The method to merge two did document.
		 *
		 * @param chainCopy the document from chain
		 * @param localCopy the document from local device
		 * @return the merged DIDDocument object
		 */
		DIDDocument merge(DIDDocument chainCopy, DIDDocument localCopy);
	}

	/**
	 * A filter for DIDs.
	 *
	 * 

	 * Instances of this interface may be passed to the listDids(DIDFilter)
	 * method of the DIDStore class.
	 * 
	 */
	@FunctionalInterface
	public interface DIDFilter {
		/**
		 * Tests whether or not the specified DID should be included in a
		 * DIDs list.
		 *
		 * @param did the DID to be tested
		 * @return true if and only if DID should be included
		 */
		public boolean accept(DID did);
	}

	/**
	 * A filter for DIDURLs.
	 *
	 * 

	 * Instances of this interface may be passed to the
	 * listCredentials(CredentialFilter) method of the DIDStore class.
	 * 
	 */
	@FunctionalInterface
	public interface CredentialFilter {
		/**
		 * Tests whether or not the specified id should be included in a
		 * id list.
		 *
		 * @param id the DIDURL to be tested
		 * @return true if and only if DIDURL should be included
		 */
		public boolean accept(DIDURL id);
	}

	private DIDStore(int initialCacheCapacity, int maxCacheCapacity,
			DIDStorage storage) throws DIDStoreException {
		if (initialCacheCapacity < 0)
			initialCacheCapacity = 0;

		if (maxCacheCapacity < 0)
			maxCacheCapacity = 0;

		// The RemovalListener used for debug purpose.
		// TODO: comment the RemovalListener
		/*
		RemovalListener listener;
		listener = new RemovalListener() {
			@Override
			public void onRemoval(RemovalNotification n) {
				if (n.wasEvicted()) {
					String cause = n.getCause().name();
					log.trace("Cache removed {} cause {}", n.getKey(), cause);
				}
			}
		};
		*/

		cache = CacheBuilder.newBuilder()
				.initialCapacity(initialCacheCapacity)
				.maximumSize(maxCacheCapacity)
				.softValues()
				// .removalListener(listener)
				// .recordStats()
				.build();

		this.storage = storage;
		this.metadata = storage.loadMetadata();
		this.metadata.attachStore(this);

		log.info("DID store opened: {}, cache(init:{}, max:{})",
				storage.getLocation(), initialCacheCapacity, maxCacheCapacity);
	}

	/**
	 * Open a DIDStore instance with given storage location.
	 *
	 * @param location the storage location for the DIDStore
	 * @param initialCacheCapacity the initial cache capacity
	 * @param maxCacheCapacity the maximum cache capacity
	 * @return the DIDStore object
	 * @throws DIDStoreException if an error occurred when opening the store
	 */
	public static DIDStore open(File location,
			int initialCacheCapacity, int maxCacheCapacity) throws DIDStoreException {
		checkArgument(location != null, "Invalid store location");
		checkArgument(maxCacheCapacity >= initialCacheCapacity, "Invalid cache capacity spec");

		try {
			location = location.getCanonicalFile();
		} catch (IOException e) {
			throw new IllegalArgumentException("Invalid store location", e);
		}

		DIDStorage storage = new FileSystemStorage(location);
		return new DIDStore(initialCacheCapacity, maxCacheCapacity, storage);
	}

	/**
	 * Open a DIDStore instance with given storage location.
	 *
	 * @param location the storage location for the DIDStore
	 * @param initialCacheCapacity the initial cache capacity
	 * @param maxCacheCapacity the maximum cache capacity
	 * @return the DIDStore object
	 * @throws DIDStoreException if an error occurred when opening the store
	 */
	public static DIDStore open(String location,
			int initialCacheCapacity, int maxCacheCapacity) throws DIDStoreException {
		checkArgument(location != null && !location.isEmpty(), "Invalid store location");

		return open(new File(location), initialCacheCapacity, maxCacheCapacity);
	}

	/**
	 * Open a DIDStore instance with given storage location.
	 *
	 * @param location the storage location for the DIDStore
	 * @return the DIDStore object
	 * @throws DIDStoreException if an error occurred when opening the store
	 */
	public static DIDStore open(File location) throws DIDStoreException {
		return open(location, CACHE_INITIAL_CAPACITY, CACHE_MAX_CAPACITY);
	}

	/**
	 * Open a DIDStore instance with given storage location.
	 *
	 * @param location the storage location for the DIDStore
	 * @return the DIDStore object
	 * @throws DIDStoreException if an error occurred when opening the store
	 */
	public static DIDStore open(String location) throws DIDStoreException {
		return open(location, CACHE_INITIAL_CAPACITY, CACHE_MAX_CAPACITY);
	}

	/**
	 * Close this DIDStore object.
	 */
	public void close() {
		// log.verbose("Cache statistics: {}", cache.stats().toString());
		cache.invalidateAll();
		cache = null;
		metadata = null;
		storage = null;
	}

	private static String calcFingerprint(String password) throws DIDStoreException {
		// Here should use Argon2, better to avoid the password attack.
		// But spongycastle library not include the Argon2 implementation,
		// so here we use one-time AES encryption to secure the password hash.
		MD5Digest md5 = new MD5Digest();
		byte[] digest = new byte[md5.getDigestSize()];
		byte[] passwd = password.getBytes();
		md5.update(passwd, 0, passwd.length);
		md5.doFinal(digest, 0);
		md5.reset();

		try {
			byte[] cipher = Aes256cbc.encrypt(digest, password);
			md5.update(cipher, 0, cipher.length);
			md5.doFinal(digest, 0);

			return Hex.toHexString(digest);
		} catch (CryptoException e) {
			throw new DIDStoreCryptoException("Calculate fingerprint error.", e);
		}
	}

	private static String encryptToBase64(byte[] input, String passwd)
			throws DIDStoreException {
		try {
			byte[] cipher = Aes256cbc.encrypt(input, passwd);

			return Base64.encodeToString(cipher,
					Base64.URL_SAFE | Base64.NO_PADDING | Base64.NO_WRAP);
		} catch (CryptoException e) {
			throw new DIDStoreCryptoException("Encrypt data error.", e);
		}
	}

	private static byte[] decryptFromBase64(String input, String passwd)
			throws DIDStoreException {
		try {
			byte[] cipher = Base64.decode(input,
					Base64.URL_SAFE | Base64.NO_PADDING | Base64.NO_WRAP);

			return Aes256cbc.decrypt(cipher, passwd);
		} catch (CryptoException e) {
			throw new WrongPasswordException("Decrypt private key error.", e);
		}
	}

	private static String reEncrypt(String secret, String oldpass, String newpass)
			throws DIDStoreException {
		byte[] plain = decryptFromBase64(secret, oldpass);
		String newSecret = encryptToBase64(plain, newpass);
		Arrays.fill(plain, (byte)0);
		return newSecret;
	}

	private String encrypt(byte[] input, String passwd) throws DIDStoreException {
		String fingerprint = metadata.getFingerprint();
		String currentFingerprint = calcFingerprint(passwd);

		if (fingerprint != null && !currentFingerprint.equals(fingerprint))
			throw new WrongPasswordException("Password mismatched with previous password.");

		String result = encryptToBase64(input, passwd);

		if (fingerprint == null || fingerprint.isEmpty())
			metadata.setFingerprint(currentFingerprint);

		return result;
	}

	private byte[] decrypt(String input, String passwd) throws DIDStoreException {
		String fingerprint = metadata.getFingerprint();
		String currentFingerprint = calcFingerprint(passwd);

		byte[] result = decryptFromBase64(input, passwd);

		if (fingerprint == null || fingerprint.isEmpty())
			metadata.setFingerprint(currentFingerprint);

		return result;
	}

	/**
	 * Save the RootIdentity object with private keys to this DID store.
	 *
	 * @param identity an RootIdentity object
	 * @param storepass the password for this DID store
	 * @throws DIDStoreException if an error occurred when accessing the store
	 */
	protected void storeRootIdentity(RootIdentity identity, String storepass)
			throws DIDStoreException {
		checkArgument(identity != null, "Invalid identity");
		checkArgument(storepass != null && !storepass.isEmpty(), "Invalid storepass");

		String encryptedMnemonic = null;
		if (identity.getMnemonic() != null)
			encryptedMnemonic = encrypt(identity.getMnemonic().getBytes(), storepass);

		String encryptedPrivateKey = encrypt(identity.getRootPrivateKey().serialize(), storepass);

		String publicKey = identity.getPreDerivedPublicKey().serializePublicKeyBase58();

		storage.storeRootIdentity(identity.getId(), encryptedMnemonic,
				encryptedPrivateKey, publicKey, identity.getIndex());

		if (metadata.getDefaultRootIdentity() == null)
			metadata.setDefaultRootIdentity(identity.getId());

		cache.invalidate(Key.forRootIdentity(identity.getId()));
		cache.invalidate(Key.forRootIdentityPrivateKey(identity.getId()));
	}

	/**
	 * Save the RootIdentity object to this DID store(Update the derive index
	 * only).
	 *
	 * @param identity an RootIdentity object
	 * @throws DIDStoreException if an error occurred when accessing the store
	 */
	protected void storeRootIdentity(RootIdentity identity)
			throws DIDStoreException {
		checkArgument(identity != null, "Invalid identity");
		storage.updateRootIdentityIndex(identity.getId(), identity.getIndex());
	}

	/**
	 * Set the identity as the default RootIdentity of the DIDStore.
	 *
	 * @param identity a RootIdentity object
	 * @throws DIDStoreException if an error occurred when accessing the store
	 */
	protected void setDefaultRootIdentity(RootIdentity identity) throws DIDStoreException {
		checkArgument(identity != null, "Invalid identity");

		if (!containsRootIdentity(identity.getId()))
			throw new IllegalArgumentException("Invalid identity, not exists in the store");

		metadata.setDefaultRootIdentity(identity.getId());
	}

	/**
	 * Load a RootIdentity object from this DIDStore.
	 *
	 * @param id the id of the RootIdentity
	 * @return the RootIdentity object, null if the identity not exists
	 * @throws DIDStoreException if an error occurred when accessing the store
	 */
	public RootIdentity loadRootIdentity(String id) throws DIDStoreException {
		checkArgument(id != null && !id.isEmpty(), "Invalid id");

		try {
			Object value = cache.get(Key.forRootIdentity(id), new Callable