digesttool.java

JXTA&#8482 is a set of open, generalized peer-to-peer (P2P) protocols that allow any networked devi

    /**
     * Create a PeerID based on the BinaryID type with a digest of the clearTextID and function.
     *
     * @param peerGroupID Parent peer group ID.
     * @param clearTextID String used as the significant part of the address
     * @param function    String used to diferentiate different clearTextID addresses (can be null).
     * @return PeerBinaryID with the digest hash of the string: clearTextID+"~"+function.
     */
    public final PeerBinaryID createPeerID(net.jxta.peergroup.PeerGroupID peerGroupID, String clearTextID, String function) {
        byte[] digest = generateHash(clearTextID, function);
        PeerBinaryID peerID = new PeerBinaryID(peerGroupID, digest, false);

        return peerID;
    }

    /**
     * Creates a new instance of DigestPipe. Because this is a  utility,
     * this is private to prevent construction.
     */
    
    /**
     * Generates a Base64 encoded string of an SHA-1 digest hash of the string: clearTextID.<p>
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @return Base64 encoded string containing the hash of the string: clearTextID.
     */
    public final String generateHashString(String clearTextID) {
        try {
            java.io.StringWriter base64 = new java.io.StringWriter();
            net.jxta.impl.util.BASE64OutputStream encode = new net.jxta.impl.util.BASE64OutputStream(base64);

            encode.write(generateHash(clearTextID));
            encode.close();

            return base64.toString();
        } catch (Exception failed) {
            LOG.log(Level.SEVERE, "Unable to encode hash value.", failed);
            throw new RuntimeException("Unable to encode hash value.");
        }
    }

    /**
     * Generates a Base64 encoded string of an SHA-1 digest hash of the string: clearTextID+"-"+function or: clearTextID if function was blank.<p>
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @param function    A function related to the clearTextID string. This is used to create a hash associated with clearTextID so that it is a uique code.
     * @return Base64 encoded string containing the hash of the string: clearTextID+"-"+function or clearTextID if function was blank.
     */
    public final String generateHashString(String clearTextID, String function) {
        try {
            java.io.StringWriter base64 = new java.io.StringWriter();
            net.jxta.impl.util.BASE64OutputStream encode = new net.jxta.impl.util.BASE64OutputStream(base64);

            encode.write(generateHash(clearTextID, function));
            encode.close();

            return base64.toString();
        } catch (Exception failed) {
            LOG.log(Level.SEVERE, "Unable to encode hash value.", failed);
            throw new RuntimeException("Unable to encode hash value.");
        }
    }

    /**
     * Generates a SHA-1 digest hash of the string: clearTextID.<p>
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @return String containing the hash of the string: clearTextID.
     */
    public final byte[] generateHash(String clearTextID) {
        return generateHash(clearTextID, null);
    }

    /**
     * Generates an SHA-1 digest hash of the string: clearTextID+"-"+function or: clearTextID if function was blank.<p>
     * <p/>
     * Note that the SHA-1 used only creates a 20 byte hash.<p>
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @param function    A function related to the clearTextID string. This is used to create a hash associated with clearTextID so that it is a uique code.
     * @return array of bytes containing the hash of the string: clearTextID+"-"+function or clearTextID if function was blank. Can return null if SHA-1 does not exist on platform.
     */
    public final byte[] generateHash(String clearTextID, String function) {
        String id;

        if (function == null) {
            id = clearTextID;
        } else {
            id = clearTextID + functionSeperator + function;
        }
        byte[] buffer = id.getBytes();

        MessageDigest algorithm;

        try {
            algorithm = MessageDigest.getInstance(algorithmType);
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Cannot load selected Digest Hash implementation", e);
            return null;
        }

        // Generate the digest.
        algorithm.reset();
        algorithm.update(buffer);

        try {
            byte[] digest1 = algorithm.digest();

            return digest1;
        } catch (Exception de) {
            LOG.log(Level.SEVERE, "Failed to creat a digest.", de);
            return null;
        }
    }

    /**
     * Generates an SHA-1 digest hash of the string: clearTextID.<p>
     *
     * @param function    the function
     * @param testHash    test hash
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @return String containing the hash of the string: clearTextID.
     */
    public final boolean test(String clearTextID, String function, String testHash) {
        String id = clearTextID + functionSeperator + function;

        return test(id, testHash);

    }

    /**
     * Compares a clear text code or ID with a candidate hash code.
     * This is used to confirm that the clearTextID can be successfully converted to the hash.
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @param testHash    A string of hashed string.
     * @return true if the hash created from clearTextID is equal to the testHash string.Can return false if SHA-1 does not exist on platform.
     */
    public final boolean test(String clearTextID, String testHash) {

        byte[] digest1 = generateHash(clearTextID);
        byte[] digest2;

        try {
            java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
            net.jxta.impl.util.BASE64InputStream decoder = new net.jxta.impl.util.BASE64InputStream(
                    new java.io.StringReader(testHash));

            while (true) {
                int c = decoder.read();

                if (-1 == c) {
                    break;
                }

                bos.write(c);
            }

            digest2 = bos.toByteArray();
        } catch (Exception e) {
            LOG.log(Level.SEVERE, "Failed to create a digest.", e);
            return false;
        }

        if (digest1.length != digest2.length) {
            // Not a match! because of length.
            return false;
        }

        for (int i = 0; i < digest1.length; i++) {
            if (digest1[i] != digest2[i]) {
                // Not a match because of byte:"+i+" did not match
                return false;
            }
        }

        // Match was ok
        return true;
    }

    /**
     * Compares a clear text code or ID with a candidate hash code.
     * This is used to confirm that the clearTextID can be successfully converted to the hash.
     *
     * @param clearTextID A string that is to be hashed. This can be any string used for hashing or hiding data.
     * @param testHash    A string of hashed string.
     * @return true if the hash created from clearTextID is equal to the testHash string.Can return false if SHA-1 does not exist on platform.
     */
    public final boolean test(String clearTextID, byte[] testHash) {

        byte[] digest1 = generateHash(clearTextID);

        if (digest1.length != testHash.length) {
            // Not a match! because of length.
            return false;
        }

        for (int i = 0; i < testHash.length; i++) {
            if (digest1[i] != testHash[i]) {
                // Not a match because of byte:"+i+" did not match
                return false;
            }
        }

        // Match was ok
        return true;
    }
}