Java tutorial
/* * Copyright 2000-2012 JetBrains s.r.o. * * 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 com.intellij.ide.passwordSafe.impl.providers.masterKey; import com.intellij.ide.passwordSafe.impl.providers.ByteArrayWrapper; import com.intellij.openapi.components.PersistentStateComponent; import com.intellij.openapi.components.State; import com.intellij.openapi.components.Storage; import com.intellij.openapi.components.StoragePathMacros; import com.intellij.openapi.diagnostic.Logger; import org.apache.commons.codec.DecoderException; import org.apache.commons.codec.binary.Hex; import org.jetbrains.annotations.Nullable; import java.util.HashMap; import java.util.Map; import java.util.TreeMap; /** * The password database. The internal component for {@link MasterKeyPasswordSafe}. */ @State(name = "PasswordDatabase", storages = { @Storage(file = StoragePathMacros.APP_CONFIG + "/security.xml") }) public class PasswordDatabase implements PersistentStateComponent<PasswordDatabase.State> { /** * The name of logger */ private final static Logger LOG = Logger.getInstance(PasswordDatabase.class.getName()); /** * The password database */ private transient final Map<ByteArrayWrapper, byte[]> myDatabase = new HashMap<ByteArrayWrapper, byte[]>(); /** * OS-specific information about master password */ private transient byte[] myMasterPasswordInfo; /** * Clear the password database */ public void clear() { synchronized (myDatabase) { myDatabase.clear(); } } /** * @return true if the database is empty */ public boolean isEmpty() { synchronized (myDatabase) { return myDatabase.isEmpty(); } } /** * Put password in the database * * @param key the encrypted key * @param value the encrypted value */ public void put(byte[] key, byte[] value) { synchronized (myDatabase) { myDatabase.put(new ByteArrayWrapper(key), value); } } /** * Get all entries in the database * * @param copy the copy to use */ public void copyTo(Map<ByteArrayWrapper, byte[]> copy) { synchronized (myDatabase) { copy.putAll(myDatabase); } } /** * Put all entries to the database * * @param copy the copy to use */ public void putAll(Map<ByteArrayWrapper, byte[]> copy) { synchronized (myDatabase) { myDatabase.putAll(copy); } } /** * Get password from the database * * @param key the encrypted key * @return the encrypted value or null */ public byte[] get(byte[] key) { synchronized (myDatabase) { return myDatabase.get(new ByteArrayWrapper(key)); } } /** * Remove password from the database * * @param key the encrypted key */ public void remove(byte[] key) { synchronized (myDatabase) { myDatabase.remove(new ByteArrayWrapper(key)); } } /** * {@inheritDoc} */ public State getState() { TreeMap<ByteArrayWrapper, byte[]> sorted; String pi; synchronized (myDatabase) { pi = toHex(myMasterPasswordInfo); sorted = new TreeMap<ByteArrayWrapper, byte[]>(myDatabase); } String[][] db = new String[2][sorted.size()]; int i = 0; for (Map.Entry<ByteArrayWrapper, byte[]> e : sorted.entrySet()) { db[0][i] = toHex(e.getKey().unwrap()); db[1][i] = toHex(e.getValue()); i++; } State s = new State(); s.PASSWORDS = db; s.MASTER_PASSWORD_INFO = pi; return s; } /** * Covert bytes to hex * * @param bytes bytes to convert * @return hex representation */ @Nullable private static String toHex(byte[] bytes) { return bytes == null ? null : new String(Hex.encodeHex(bytes)); } /** * Covert hex to bytes * * @param hex string to convert * @return bytes representation * @throws DecoderException if invalid data encountered */ @Nullable private static byte[] fromHex(String hex) throws DecoderException { return hex == null ? null : Hex.decodeHex(hex.toCharArray()); } /** * {@inheritDoc} */ public void loadState(State state) { String[][] db = state.PASSWORDS; String pi = state.MASTER_PASSWORD_INFO; synchronized (myDatabase) { try { myMasterPasswordInfo = fromHex(pi); if (myMasterPasswordInfo == null) { myMasterPasswordInfo = new byte[0]; } } catch (DecoderException e) { myMasterPasswordInfo = new byte[0]; } myDatabase.clear(); if (db[0].length != db[1].length) { LOG.warn("The password database is in inconsistent state, ignoring it: " + db[0].length + " != " + db[1].length); } int n = db[0].length; for (int i = 0; i < n; i++) { try { byte[] key = fromHex(db[0][i]); byte[] value = fromHex(db[1][i]); if (key != null && value != null) { myDatabase.put(new ByteArrayWrapper(key), value); } } catch (DecoderException e) { // skip the entry } } } } /** * @return the object over which database is synchronized */ Object getDbLock() { return myDatabase; } /** * @return master password information */ byte[] getPasswordInfo() { synchronized (myDatabase) { return myMasterPasswordInfo; } } /** * Set master password information * * @param bytes the bytes for the master password */ public void setPasswordInfo(byte[] bytes) { synchronized (myDatabase) { myMasterPasswordInfo = bytes; } } /** * The state for passwords database */ public static class State { /** * Information about master password (used in OS specific way) */ public String MASTER_PASSWORD_INFO = ""; /** * The password database */ public String[][] PASSWORDS = new String[0][]; } }