HashManager.java

  1. /**
  2.  *
  3.  * Copyright © 2017 Paul Schaub, 2019-2020 Florian Schmaus
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.hashes;

  19. import static org.jivesoftware.smack.util.StringUtils.encodeHex;
  20. import static org.jivesoftware.smack.util.StringUtils.toUtf8Bytes;
  21. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.BLAKE2B160;
  22. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.BLAKE2B256;
  23. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.BLAKE2B384;
  24. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.BLAKE2B512;
  25. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.MD5;
  26. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA3_224;
  27. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA3_256;
  28. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA3_384;
  29. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA3_512;
  30. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA_1;
  31. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA_224;
  32. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA_256;
  33. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA_384;
  34. import static org.jivesoftware.smackx.hashes.HashManager.ALGORITHM.SHA_512;

  36. import java.security.MessageDigest;
  37. import java.security.NoSuchAlgorithmException;
  38. import java.util.Arrays;
  39. import java.util.Collections;
  40. import java.util.List;
  41. import java.util.WeakHashMap;

  43. import org.jivesoftware.smack.Manager;
  44. import org.jivesoftware.smack.XMPPConnection;

  46. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  47. import org.jivesoftware.smackx.hashes.element.HashElement;

  49. /**
  50.  * Manager that can be used to determine support for hash functions. By default,the Manager announces support for
  51.  * XEP-0300, as well as for the recommended set of hash algorithms. Those contain SHA256, SHA384, SHA512, SHA3-256,
  52.  * SHA3-384, SHA3-512, BLAKE2B256, BLAKE2B384 and BLAKE2B512. Those algorithms got recommended here:
  53.  * <a href="https://xmpp.org/extensions/xep-0300.html#recommendations">https://xmpp.org/extensions/xep-0300.html#recommendations</a>.
  54.  */
  55. public final class HashManager extends Manager {

  57.     public static final String PREFIX_NS_ALGO = "urn:xmpp:hash-function-text-names:";

  59.     public enum NAMESPACE {
  60.         V1 ("urn:xmpp:hashes:1"),
  61.         V2 ("urn:xmpp:hashes:2");

  63.         final String name;

  65.         NAMESPACE(String name) {
  66.             this.name = name;
  67.         }

  69.         @Override
  70.         public String toString() {
  71.             return this.name;
  72.         }
  73.     }

  75.     public static final List<ALGORITHM> RECOMMENDED = Collections.unmodifiableList(Arrays.asList(
  76.             SHA_256, SHA_384, SHA_512,
  77.             SHA3_256, SHA3_384, SHA3_512,
  78.             BLAKE2B256, BLAKE2B384, BLAKE2B512));

  80.     private static final WeakHashMap<XMPPConnection, HashManager> INSTANCES = new WeakHashMap<>();

  82.     /**
  83.      * Constructor of the HashManager.
  84.      *
  85.      * @param connection connection
  86.      */
  87.     private HashManager(XMPPConnection connection) {
  88.         super(connection);
  89.         ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
  90.         sdm.addFeature(NAMESPACE.V2.toString());
  91.         addAlgorithmsToFeatures(RECOMMENDED);
  92.     }

  94.     public static HashElement calculateHashElement(ALGORITHM algorithm, byte[] data) {
  95.         return new HashElement(algorithm, hash(algorithm, data));
  96.     }

  98.     public static HashElement assembleHashElement(ALGORITHM algorithm, byte[] hash) {
  99.         return new HashElement(algorithm, hash);
  100.     }

  102.     /**
  103.      * Announce support for the given list of algorithms.
  104.      * @param algorithms TODO javadoc me please
  105.      */
  106.     public void addAlgorithmsToFeatures(List<ALGORITHM> algorithms) {
  107.         ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection());
  108.         for (ALGORITHM algo : algorithms) {
  109.             sdm.addFeature(asFeature(algo));
  110.         }
  111.     }

  113.     /**
  114.      * Get an instance of the HashManager for the  given connection.
  115.      * @param connection TODO javadoc me please
  116.      * @return the manager for the given connection.
  117.      */
  118.     public static synchronized HashManager getInstanceFor(XMPPConnection connection) {
  119.         HashManager hashManager = INSTANCES.get(connection);
  120.         if (hashManager == null) {
  121.             hashManager = new HashManager(connection);
  122.             INSTANCES.put(connection, hashManager);
  123.         }
  124.         return hashManager;
  125.     }

  127.     /**
  128.      * Return the feature name of the given algorithm.
  129.      * @param algorithm eg. 'SHA_1'
  130.      * @return feature name (eg. urn:xmpp:hash-function-text-names:sha-1')
  131.      */
  132.     public static String asFeature(ALGORITHM algorithm) {
  133.         return PREFIX_NS_ALGO + algorithm.toString();
  134.     }

  136.     enum AlgorithmRecommendation {
  137.         unknown,
  138.         must_not,
  139.         should_not,
  140.         should,
  141.         must,
  142.     }

  144.     public enum ALGORITHM {
  145.         MD5 ("md5", AlgorithmRecommendation.must_not),
  146.         SHA_1 ("sha-1", AlgorithmRecommendation.should_not),
  147.         SHA_224 ("sha-224", AlgorithmRecommendation.unknown),
  148.         SHA_256 ("sha-256", AlgorithmRecommendation.must),
  149.         SHA_384 ("sha-384", AlgorithmRecommendation.unknown),
  150.         SHA_512 ("sha-512", AlgorithmRecommendation.should),
  151.         SHA3_224 ("sha3-224", AlgorithmRecommendation.unknown),
  152.         SHA3_256 ("sha3-256", AlgorithmRecommendation.must),
  153.         SHA3_384 ("sha3-384", AlgorithmRecommendation.unknown),
  154.         SHA3_512 ("sha3-512", AlgorithmRecommendation.should),
  155.         BLAKE2B160("id-blake2b160", AlgorithmRecommendation.unknown),
  156.         BLAKE2B256("id-blake2b256", AlgorithmRecommendation.must),
  157.         BLAKE2B384("id-blake2b384", AlgorithmRecommendation.unknown),
  158.         BLAKE2B512("id-blake2b512", AlgorithmRecommendation.should);

  160.         private final String name;
  161.         private final AlgorithmRecommendation recommendation;

  163.         ALGORITHM(String name, AlgorithmRecommendation recommendation) {
  164.             this.name = name;
  165.             this.recommendation = recommendation;
  166.         }

  168.         /**
  169.          * Return the name of the algorithm as it is used in the XEP.
  170.          * @return name.
  171.          */
  172.         @Override
  173.         public String toString() {
  174.             return this.name;
  175.         }

  177.         public AlgorithmRecommendation getRecommendation() {
  178.             return recommendation;
  179.         }

  181.         /**
  182.          * Compensational method for static 'valueOf' function.
  183.          *
  184.          * @param s TODO javadoc me please
  185.          * @return the algorithm for the given string.
  186.          * @throws IllegalArgumentException if no algorithm for the given string is known.
  187.          */
  188.         public static ALGORITHM valueOfName(String s) {
  189.             for (ALGORITHM a : ALGORITHM.values()) {
  190.                 if (a.toString().equals(s)) {
  191.                     return a;
  192.                 }
  193.             }
  194.             throw new IllegalArgumentException("No ALGORITHM enum with this name (" + s + ") found.");
  195.         }
  196.     }

  198.     /**
  199.      * Calculate the hash sum of data using algorithm.
  200.      *
  201.      * @param algorithm the algorithm to use.
  202.      * @param data the data to calculate the hash for.
  203.      * @return the hash value produced by the given algorithm for the given data.
  204.      */
  205.     public static byte[] hash(ALGORITHM algorithm, byte[] data) {
  206.         return getMessageDigest(algorithm).digest(data);
  207.     }

  209.     public static byte[] hash(ALGORITHM algorithm, String data) {
  210.         return hash(algorithm, toUtf8Bytes(data));
  211.     }

  213.     public static MessageDigest getMessageDigest(ALGORITHM algorithm) {
  214.         MessageDigest md;
  215.         try {
  216.             switch (algorithm) {
  217.                 case MD5:
  218.                     md = MessageDigest.getInstance("MD5");
  219.                     break;
  220.                 case SHA_1:
  221.                     md = MessageDigest.getInstance("SHA-1");
  222.                     break;
  223.                 case SHA_224:
  224.                     md = MessageDigest.getInstance("SHA-224");
  225.                     break;
  226.                 case SHA_256:
  227.                     md = MessageDigest.getInstance("SHA-256");
  228.                     break;
  229.                 case SHA_384:
  230.                     md = MessageDigest.getInstance("SHA-384");
  231.                     break;
  232.                 case SHA_512:
  233.                     md = MessageDigest.getInstance("SHA-512");
  234.                     break;
  235.                 case SHA3_224:
  236.                     md = MessageDigest.getInstance("SHA3-224");
  237.                     break;
  238.                 case SHA3_256:
  239.                     md = MessageDigest.getInstance("SHA3-256");
  240.                     break;
  241.                 case SHA3_384:
  242.                     md = MessageDigest.getInstance("SHA3-384");
  243.                     break;
  244.                 case SHA3_512:
  245.                     md = MessageDigest.getInstance("SHA3-512");
  246.                     break;
  247.                 case BLAKE2B160:
  248.                     md = MessageDigest.getInstance("BLAKE2b-160");
  249.                     break;
  250.                 case BLAKE2B256:
  251.                     md = MessageDigest.getInstance("BLAKE2b-256");
  252.                     break;
  253.                 case BLAKE2B384:
  254.                     md = MessageDigest.getInstance("BLAKE2b-384");
  255.                     break;
  256.                 case BLAKE2B512:
  257.                     md = MessageDigest.getInstance("BLAKE2b-512");
  258.                     break;
  259.                 default:
  260.                     throw new AssertionError("Invalid enum value: " + algorithm);
  261.             }
  262.             return md;
  263.         } catch (NoSuchAlgorithmException e) {
  264.             throw new AssertionError(e);
  265.         }
  266.     }

  268.     public static byte[] md5(byte[] data) {
  269.         return getMessageDigest(MD5).digest(data);
  270.     }

  272.     public static byte[] md5(String data) {
  273.         return md5(toUtf8Bytes(data));
  274.     }

  276.     public static String md5HexString(byte[] data) {
  277.         return encodeHex(md5(data));
  278.     }

  280.     public static String md5HexString(String data) {
  281.         return encodeHex(md5(data));
  282.     }

  284.     public static byte[] sha_1(byte[] data) {
  285.         return getMessageDigest(SHA_1).digest(data);
  286.     }

  288.     public static byte[] sha_1(String data) {
  289.         return sha_1(toUtf8Bytes(data));
  290.     }

  292.     public static String sha_1HexString(byte[] data) {
  293.         return encodeHex(sha_1(data));
  294.     }

  296.     public static String sha_1HexString(String data) {
  297.         return encodeHex(sha_1(data));
  298.     }

  300.     public static byte[] sha_224(byte[] data) {
  301.         return getMessageDigest(SHA_224).digest(data);
  302.     }

  304.     public static byte[] sha_224(String data) {
  305.         return sha_224(toUtf8Bytes(data));
  306.     }

  308.     public static String sha_224HexString(byte[] data) {
  309.         return encodeHex(sha_224(data));
  310.     }

  312.     public static String sha_224HexString(String data) {
  313.         return encodeHex(sha_224(data));
  314.     }

  316.     public static byte[] sha_256(byte[] data) {
  317.         return getMessageDigest(SHA_256).digest(data);
  318.     }

  320.     public static byte[] sha_256(String data) {
  321.         return sha_256(toUtf8Bytes(data));
  322.     }

  324.     public static String sha_256HexString(byte[] data) {
  325.         return encodeHex(sha_256(data));
  326.     }

  328.     public static String sha_256HexString(String data) {
  329.         return encodeHex(sha_256(data));
  330.     }

  332.     public static byte[] sha_384(byte[] data) {
  333.         return getMessageDigest(SHA_384).digest(data);
  334.     }

  336.     public static byte[] sha_384(String data) {
  337.         return sha_384(toUtf8Bytes(data));
  338.     }

  340.     public static String sha_384HexString(byte[] data) {
  341.         return encodeHex(sha_384(data));
  342.     }

  344.     public static String sha_384HexString(String data) {
  345.         return encodeHex(sha_384(data));
  346.     }

  348.     public static byte[] sha_512(byte[] data) {
  349.         return getMessageDigest(SHA_512).digest(data);
  350.     }

  352.     public static byte[] sha_512(String data) {
  353.         return sha_512(toUtf8Bytes(data));
  354.     }

  356.     public static String sha_512HexString(byte[] data) {
  357.         return encodeHex(sha_512(data));
  358.     }

  360.     public static String sha_512HexString(String data) {
  361.         return encodeHex(sha_512(data));
  362.     }

  364.     public static byte[] sha3_224(byte[] data) {
  365.         return getMessageDigest(SHA3_224).digest(data);
  366.     }

  368.     public static byte[] sha3_224(String data) {
  369.         return sha3_224(toUtf8Bytes(data));
  370.     }

  372.     public static String sha3_224HexString(byte[] data) {
  373.         return encodeHex(sha3_224(data));
  374.     }

  376.     public static String sha3_224HexString(String data) {
  377.         return encodeHex(sha3_224(data));
  378.     }

  380.     public static byte[] sha3_256(byte[] data) {
  381.         return getMessageDigest(SHA3_256).digest(data);
  382.     }

  384.     public static byte[] sha3_256(String data) {
  385.         return sha3_256(toUtf8Bytes(data));
  386.     }

  388.     public static String sha3_256HexString(byte[] data) {
  389.         return encodeHex(sha3_256(data));
  390.     }

  392.     public static String sha3_256HexString(String data) {
  393.         return encodeHex(sha3_256(data));
  394.     }

  396.     public static byte[] sha3_384(byte[] data) {
  397.         return getMessageDigest(SHA3_384).digest(data);
  398.     }

  400.     public static byte[] sha3_384(String data) {
  401.         return sha3_384(toUtf8Bytes(data));
  402.     }

  404.     public static String sha3_384HexString(byte[] data) {
  405.         return encodeHex(sha3_384(data));
  406.     }

  408.     public static String sha3_384HexString(String data) {
  409.         return encodeHex(sha3_384(data));
  410.     }

  412.     public static byte[] sha3_512(byte[] data) {
  413.         return getMessageDigest(SHA3_512).digest(data);
  414.     }

  416.     public static byte[] sha3_512(String data) {
  417.         return sha3_512(toUtf8Bytes(data));
  418.     }

  420.     public static String sha3_512HexString(byte[] data) {
  421.         return encodeHex(sha3_512(data));
  422.     }

  424.     public static String sha3_512HexString(String data) {
  425.         return encodeHex(sha3_512(data));
  426.     }

  428.     public static byte[] blake2b160(byte[] data) {
  429.         return getMessageDigest(BLAKE2B160).digest(data);
  430.     }

  432.     public static byte[] blake2b160(String data) {
  433.         return blake2b160(toUtf8Bytes(data));
  434.     }

  436.     public static String blake2b160HexString(byte[] data) {
  437.         return encodeHex(blake2b160(data));
  438.     }

  440.     public static String blake2b160HexString(String data) {
  441.         return encodeHex(blake2b160(data));
  442.     }

  444.     public static byte[] blake2b256(byte[] data) {
  445.         return getMessageDigest(BLAKE2B256).digest(data);
  446.     }

  448.     public static byte[] blake2b256(String data) {
  449.         return blake2b256(toUtf8Bytes(data));
  450.     }

  452.     public static String blake2b256HexString(byte[] data) {
  453.         return encodeHex(blake2b256(data));
  454.     }

  456.     public static String blake2b256HexString(String data) {
  457.         return encodeHex(blake2b256(data));
  458.     }

  460.     public static byte[] blake2b384(byte[] data) {
  461.         return getMessageDigest(BLAKE2B384).digest(data);
  462.     }

  464.     public static byte[] blake2b384(String data) {
  465.         return blake2b384(toUtf8Bytes(data));
  466.     }

  468.     public static String blake2b384HexString(byte[] data) {
  469.         return encodeHex(blake2b384(data));
  470.     }

  472.     public static  String blake2b384HexString(String data) {
  473.         return encodeHex(blake2b384(data));
  474.     }

  476.     public static byte[] blake2b512(byte[] data) {
  477.         return getMessageDigest(BLAKE2B512).digest(data);
  478.     }

  480.     public static byte[] blake2b512(String data) {
  481.         return blake2b512(toUtf8Bytes(data));
  482.     }

  484.     public static String blake2b512HexString(byte[] data) {
  485.         return encodeHex(blake2b512(data));
  486.     }

  488.     public static String blake2b512HexString(String data) {
  489.         return encodeHex(blake2b512(data));
  490.     }

  492. }
Created with JaCoCo 0.8.6.202009150832