cadi/core/src/main/java/org/onap/aaf/cadi/Hash.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.cadi;
  23
  24 import java.nio.ByteBuffer;
  25 import java.security.MessageDigest;
  26 import java.security.NoSuchAlgorithmException;
  27
  28 public class Hash {
  29         private static char hexDigit[] = "0123456789abcdef".toCharArray();
  30
  31 /////////////////////////////////
  32 // MD5
  33 /////////////////////////////////
  34         /**
  35          * Encrypt MD5 from Byte Array to Byte Array
  36          * @param input
  37          * @return
  38          * @throws NoSuchAlgorithmException
  39          */
  40         public static byte[] hashMD5 (byte[] input) throws NoSuchAlgorithmException {
  41                 // Note: Protect against Multi-thread issues with new MessageDigest
  42                 MessageDigest md = MessageDigest.getInstance("MD5");
  43                 md.update(input);
  44                 return md.digest();
  45         }
  46
  47         /**
  48          * Encrypt MD5 from Byte Array to Byte Array
  49          * @param input
  50          * @return
  51          * @throws NoSuchAlgorithmException
  52          */
  53         public static byte[] hashMD5 (byte[] input, int offset, int length) throws NoSuchAlgorithmException {
  54                 // Note: Protect against Multi-thread issues with new MessageDigest
  55                 MessageDigest md = MessageDigest.getInstance("MD5");
  56                 md.update(input,offset,length);
  57                 return md.digest();
  58         }
  59
  60
  61
  62         /**
  63          * Convenience Function: Encrypt MD5 from String to String Hex representation
  64          *
  65          * @param input
  66          * @return
  67          * @throws NoSuchAlgorithmException
  68          */
  69         public static String hashMD5asStringHex(String input) throws NoSuchAlgorithmException {
  70                 byte[] output = hashMD5(input.getBytes());
  71                 StringBuilder sb = new StringBuilder("0x");
  72                  for (byte b : output) {
  73                     sb.append(hexDigit[(b >> 4) & 0x0f]);
  74                     sb.append(hexDigit[b & 0x0f]);
  75                  }
  76                  return sb.toString();
  77         }
  78
  79 /////////////////////////////////
  80 // SHA256
  81 /////////////////////////////////
  82         /**
  83          * SHA256 Hashing
  84          */
  85         public static byte[] hashSHA256(byte[] input) throws NoSuchAlgorithmException {
  86                 // Note: Protect against Multi-thread issues with new MessageDigest
  87                 MessageDigest md = MessageDigest.getInstance("SHA-256");
  88                 md.update(input);
  89                 return md.digest();
  90         }
  91
  92         /**
  93          * SHA256 Hashing
  94          */
  95         public static byte[] hashSHA256(byte[] input, int offset, int length) throws NoSuchAlgorithmException {
  96                 // Note: Protect against Multi-thread issues with new MessageDigest
  97                 MessageDigest md = MessageDigest.getInstance("SHA-256");
  98                 md.update(input,offset,length);
  99                 return md.digest();
 100         }
 101
 102         /**
 103          * Convenience Function: Hash from String to String Hex representation
 104          *
 105          * @param input
 106          * @return
 107          * @throws NoSuchAlgorithmException
 108          */
 109         public static String hashSHA256asStringHex(String input) throws NoSuchAlgorithmException {
 110                 return toHex(hashSHA256(input.getBytes()));
 111         }
 112
 113         /**
 114          * Convenience Function: Hash from String to String Hex representation
 115          *
 116          * @param input
 117          * @return
 118          * @throws NoSuchAlgorithmException
 119          */
 120         public static String hashSHA256asStringHex(String input, int salt) throws NoSuchAlgorithmException {
 121                 byte[] in = input.getBytes();
 122                 ByteBuffer bb = ByteBuffer.allocate(Integer.SIZE + in.length);
 123                 bb.putInt(salt);
 124                 bb.put(input.getBytes());
 125                 return toHex(Hash.hashSHA256(bb.array()));
 126         }
 127
 128         /**
 129          * Compare two byte arrays for equivalency
 130          * @param ba1
 131          * @param ba2
 132          * @return
 133          */
 134         public static boolean isEqual(byte ba1[], byte ba2[]) {
 135                 if(ba1.length!=ba2.length)return false;
 136                 for(int i = 0;i<ba1.length; ++i) {
 137                         if(ba1[i]!=ba2[i])return false;
 138                 }
 139                 return true;
 140         }
 141
 142         public static int compareTo(byte[] a, byte[] b) {
 143                 int end = Math.min(a.length, b.length);
 144                 int compare = 0;
 145                 for(int i=0;compare == 0 && i<end;++i) {
 146                         compare = a[i]-b[i];
 147                 }
 148                 if(compare==0)compare=a.length-b.length;
 149                 return compare;
 150         }
 151
 152         public static String toHexNo0x(byte[] ba) {
 153                 StringBuilder sb = new StringBuilder();
 154                  for (byte b : ba) {
 155                     sb.append(hexDigit[(b >> 4) & 0x0f]);
 156                     sb.append(hexDigit[b & 0x0f]);
 157                  }
 158                  return sb.toString();
 159         }
 160
 161         public static String toHex(byte[] ba) {
 162                 StringBuilder sb = new StringBuilder("0x");
 163                  for (byte b : ba) {
 164                     sb.append(hexDigit[(b >> 4) & 0x0f]);
 165                     sb.append(hexDigit[b & 0x0f]);
 166                  }
 167                  return sb.toString();
 168         }
 169
 170         public static String toHex(byte[] ba, int start, int length) {
 171                 StringBuilder sb = new StringBuilder("0x");
 172                  for (int i=start;i<length;++i) {
 173                     sb.append(hexDigit[(ba[i] >> 4) & 0x0f]);
 174                     sb.append(hexDigit[ba[i] & 0x0f]);
 175                  }
 176                  return sb.toString();
 177         }
 178
 179
 180         public static byte[] fromHex(String s)  throws CadiException{
 181                 if(!s.startsWith("0x")) {
 182                         throw new CadiException("HexString must start with \"0x\"");
 183                 }
 184                 boolean high = true;
 185                 int c;
 186                 byte b;
 187                 byte[] ba = new byte[(s.length()-2)/2];
 188                 int idx;
 189                 for(int i=2;i<s.length();++i) {
 190                         c = s.charAt(i);
 191                         if(c>=0x30 && c<=0x39) {
 192                                 b=(byte)(c-0x30);
 193                         } else if(c>=0x61 && c<=0x66) {
 194                                 b=(byte)(c-0x57);  // account for "A"
 195                         } else if(c>=0x41 && c<=0x46) {
 196                                 b=(byte)(c-0x37);
 197                         } else {
 198                                 throw new CadiException("Invalid char '" + c + "' in HexString");
 199                         }
 200                         idx = (i-2)/2;
 201                         if(high) {
 202                                 ba[idx]=(byte)(b<<4);
 203                                 high = false;
 204                         } else {
 205                                 ba[idx]|=b;
 206                                 high = true;
 207                         }
 208                 }
 209                 return ba;
 210         }
 211
 212         /**
 213          * Does not expect to start with "0x"
 214          * if Any Character doesn't match, it returns null;
 215          *
 216          * @param s
 217          * @return
 218          */
 219         public static byte[] fromHexNo0x(String s) {
 220                 int c;
 221                 byte b;
 222                 byte[] ba;
 223                 boolean high;
 224                 int start;
 225                 if(s.length()%2==0) {
 226                         ba = new byte[s.length()/2];
 227                         high=true;
 228                         start=0;
 229                 } else {
 230                         ba = new byte[(s.length()/2)+1];
 231                         high = false;
 232                         start=1;
 233                 }
 234                 int idx;
 235                 for(int i=start;i<s.length();++i) {
 236                         c = s.charAt((i-start));
 237                         if(c>=0x30 && c<=0x39) {
 238                                 b=(byte)(c-0x30);
 239                         } else if(c>=0x61 && c<=0x66) {
 240                                 b=(byte)(c-0x57);  // account for "A"
 241                         } else if(c>=0x41 && c<=0x46) {
 242                                 b=(byte)(c-0x37);
 243                         } else {
 244                                 return null;
 245                         }
 246                         idx = i/2;
 247                         if(high) {
 248                                 ba[idx]=(byte)(b<<4);
 249                                 high = false;
 250                         } else {
 251                                 ba[idx]|=b;
 252                                 high = true;
 253                         }
 254                 }
 255                 return ba;
 256         }
 257
 258 }